fast_excel 0.2.2 → 0.4.0

data/libxlsxwriter/src/worksheet.c

@@ -3,7 +3,7 @@
  *
  * Used in conjunction with the libxlsxwriter library.
  *
- * Copyright 2014-2017, John McNamara, jmcnamara@cpan.org. See LICENSE.txt.
+ * Copyright 2014-2019, John McNamara, jmcnamara@cpan.org. See LICENSE.txt.
  *
  */
 
@@ -15,11 +15,11 @@
 #include "xlsxwriter/utility.h"
 #include "xlsxwriter/relationships.h"
 
-#define LXW_STR_MAX      32767
-#define LXW_BUFFER_SIZE  4096
-#define LXW_PORTRAIT     1
-#define LXW_LANDSCAPE    0
-#define LXW_PRINT_ACROSS 1
+#define LXW_STR_MAX                      32767
+#define LXW_BUFFER_SIZE                  4096
+#define LXW_PRINT_ACROSS                 1
+#define LXW_VALIDATION_MAX_TITLE_LENGTH  32
+#define LXW_VALIDATION_MAX_STRING_LENGTH 255
 
 /*
  * Forward declarations.
@@ -123,6 +123,11 @@ lxw_worksheet_new(lxw_worksheet_init_data *init_data)
     GOTO_LABEL_ON_MEM_ERROR(worksheet->selections, mem_error);
     STAILQ_INIT(worksheet->selections);
 
+    worksheet->data_validations =
+        calloc(1, sizeof(struct lxw_data_validations));
+    GOTO_LABEL_ON_MEM_ERROR(worksheet->data_validations, mem_error);
+    STAILQ_INIT(worksheet->data_validations);
+
     worksheet->external_hyperlinks = calloc(1, sizeof(struct lxw_rel_tuples));
     GOTO_LABEL_ON_MEM_ERROR(worksheet->external_hyperlinks, mem_error);
     STAILQ_INIT(worksheet->external_hyperlinks);
@@ -187,6 +192,9 @@ lxw_worksheet_new(lxw_worksheet_init_data *init_data)
     worksheet->zoom_scale_normal = LXW_TRUE;
     worksheet->show_zeros = LXW_TRUE;
     worksheet->outline_on = LXW_TRUE;
+    worksheet->outline_style = LXW_TRUE;
+    worksheet->outline_below = LXW_TRUE;
+    worksheet->outline_right = LXW_FALSE;
     worksheet->tab_color = LXW_COLOR_UNSET;
 
     if (init_data) {
@@ -261,13 +269,34 @@ _free_image_options(lxw_image_options *image)
         return;
 
     free(image->filename);
-    free(image->short_name);
+    free(image->description);
     free(image->extension);
     free(image->url);
     free(image->tip);
+    free(image->image_buffer);
     free(image);
 }
 
+/*
+ * Free a worksheet data_validation.
+ */
+STATIC void
+_free_data_validation(lxw_data_validation *data_validation)
+{
+    if (!data_validation)
+        return;
+
+    free(data_validation->value_formula);
+    free(data_validation->maximum_formula);
+    free(data_validation->input_title);
+    free(data_validation->input_message);
+    free(data_validation->error_title);
+    free(data_validation->error_message);
+    free(data_validation->minimum_formula);
+
+    free(data_validation);
+}
+
 /*
  * Free a worksheet object.
  */
@@ -280,6 +309,7 @@ lxw_worksheet_free(lxw_worksheet *worksheet)
     lxw_merged_range *merged_range;
     lxw_image_options *image_options;
     lxw_selection *selection;
+    lxw_data_validation *data_validation;
     lxw_rel_tuple *relationship;
 
     if (!worksheet)
@@ -309,7 +339,6 @@ lxw_worksheet_free(lxw_worksheet *worksheet)
     }
 
     if (worksheet->hyperlinks) {
-
         for (row = RB_MIN(lxw_table_rows, worksheet->hyperlinks); row;
              row = next_row) {
 
@@ -361,6 +390,16 @@ lxw_worksheet_free(lxw_worksheet *worksheet)
         free(worksheet->selections);
     }
 
+    if (worksheet->data_validations) {
+        while (!STAILQ_EMPTY(worksheet->data_validations)) {
+            data_validation = STAILQ_FIRST(worksheet->data_validations);
+            STAILQ_REMOVE_HEAD(worksheet->data_validations, list_pointers);
+            _free_data_validation(data_validation);
+        }
+
+        free(worksheet->data_validations);
+    }
+
     /* TODO. Add function for freeing the relationship lists. */
     while (!STAILQ_EMPTY(worksheet->external_hyperlinks)) {
         relationship = STAILQ_FIRST(worksheet->external_hyperlinks);
@@ -409,6 +448,7 @@ lxw_worksheet_free(lxw_worksheet *worksheet)
     free(worksheet->vbreaks);
     free(worksheet->name);
     free(worksheet->quoted_name);
+    free(worksheet->vba_codename);
 
     free(worksheet);
     worksheet = NULL;
@@ -498,6 +538,26 @@ _new_inline_string_cell(lxw_row_t row_num,
     return cell;
 }
 
+/*
+ * Create a new worksheet inline_string cell object for rich strings.
+ */
+STATIC lxw_cell *
+_new_inline_rich_string_cell(lxw_row_t row_num,
+                             lxw_col_t col_num, char *string,
+                             lxw_format *format)
+{
+    lxw_cell *cell = calloc(1, sizeof(lxw_cell));
+    RETURN_ON_MEM_ERROR(cell, cell);
+
+    cell->row_num = row_num;
+    cell->col_num = col_num;
+    cell->type = INLINE_RICH_STRING_CELL;
+    cell->format = format;
+    cell->u.string = string;
+
+    return cell;
+}
+
 /*
  * Create a new worksheet formula cell object.
  */
@@ -801,38 +861,6 @@ _cell_cmp(lxw_cell *cell1, lxw_cell *cell2)
     return 0;
 }
 
-/*
- * Hash a worksheet password. Based on the algorithm provided by Daniel Rentz
- * of OpenOffice.
- */
-STATIC uint16_t
-_hash_password(const char *password)
-{
-    size_t count;
-    uint8_t i;
-    uint16_t hash = 0x0000;
-
-    count = strlen(password);
-
-    for (i = 0; i < count; i++) {
-        uint32_t low_15;
-        uint32_t high_15;
-        uint32_t letter = password[i] << (i + 1);
-
-        low_15 = letter & 0x7fff;
-        high_15 = letter & (0x7fff << 15);
-        high_15 = high_15 >> 15;
-        letter = low_15 | high_15;
-
-        hash ^= letter;
-    }
-
-    hash ^= count;
-    hash ^= 0xCE4B;
-
-    return hash;
-}
-
 /*
  * Simple replacement for libgen.h basename() for compatibility with MSVC. It
  * handles forward and back slashes. It doesn't copy exactly the return
@@ -860,6 +888,61 @@ lxw_basename(const char *path)
         return back_slash + 1;
 }
 
+/* Function to count the total concatenated length of the strings in a
+ * validation list array, including commas. */
+size_t
+_validation_list_length(char **list)
+{
+    uint8_t i = 0;
+    size_t length = 0;
+
+    if (!list || !list[0])
+        return 0;
+
+    while (list[i] && length <= LXW_VALIDATION_MAX_STRING_LENGTH) {
+        /* Include commas in the length. */
+        length += 1 + lxw_utf8_strlen(list[i]);
+        i++;
+    }
+
+    /* Adjust the count for extraneous comma at end. */
+    length--;
+
+    return length;
+}
+
+/* Function to convert an array of strings into a CSV string for data
+ * validation lists. */
+char *
+_validation_list_to_csv(char **list)
+{
+    uint8_t i = 0;
+    char *str;
+
+    /* Create a buffer for the concatenated, and quoted, string. */
+    /* Add +3 for quotes and EOL. */
+    str = calloc(1, LXW_VALIDATION_MAX_STRING_LENGTH + 3);
+    if (!str)
+        return NULL;
+
+    /* Add the start quote and first element. */
+    strcat(str, "\"");
+    strcat(str, list[0]);
+
+    /* Add the other elements preceded by a comma. */
+    i = 1;
+    while (list[i]) {
+        strcat(str, ",");
+        strcat(str, list[i]);
+        i++;
+    }
+
+    /* Add the end quote. */
+    strcat(str, "\"");
+
+    return str;
+}
+
 /*****************************************************************************
  *
  * XML functions.
@@ -1372,6 +1455,12 @@ _worksheet_write_sheet_format_pr(lxw_worksheet *self)
     if (self->default_row_zeroed)
         LXW_PUSH_ATTRIBUTES_STR("zeroHeight", "1");
 
+    if (self->outline_row_level)
+        LXW_PUSH_ATTRIBUTES_INT("outlineLevelRow", self->outline_row_level);
+
+    if (self->outline_col_level)
+        LXW_PUSH_ATTRIBUTES_INT("outlineLevelCol", self->outline_col_level);
+
     lxw_xml_empty_tag(self->file, "sheetFormatPr", &attributes);
 
     LXW_FREE_ATTRIBUTES();
@@ -1608,6 +1697,9 @@ _write_row(lxw_worksheet *self, lxw_row *row, char *spans)
     if (height != LXW_DEF_ROW_HEIGHT)
         LXW_PUSH_ATTRIBUTES_STR("customHeight", "1");
 
+    if (row->level)
+        LXW_PUSH_ATTRIBUTES_INT("outlineLevel", row->level);
+
     if (row->collapsed)
         LXW_PUSH_ATTRIBUTES_STR("collapsed", "1");
 
@@ -1649,6 +1741,9 @@ _worksheet_size_col(lxw_worksheet *self, lxw_col_t col_num)
     }
 
     if (col_opt) {
+        if (col_opt->hidden)
+            return 0;
+
         width = col_opt->width;
 
         /* Convert to pixels. */
@@ -1684,6 +1779,9 @@ _worksheet_size_row(lxw_worksheet *self, lxw_row_t row_num)
     row = lxw_worksheet_find_row(self, row_num);
 
     if (row) {
+        if (row->hidden)
+            return 0;
+
         height = row->height;
 
         if (height == 0)
@@ -1810,23 +1908,30 @@ _worksheet_position_object_pixels(lxw_worksheet *self,
     y_abs += y1;
 
     /* Adjust start col for offsets that are greater than the col width. */
-    while (x1 >= _worksheet_size_col(self, col_start)) {
-        x1 -= _worksheet_size_col(self, col_start);
-        col_start++;
+    if (_worksheet_size_col(self, col_start) > 0) {
+        while (x1 >= _worksheet_size_col(self, col_start)) {
+            x1 -= _worksheet_size_col(self, col_start);
+            col_start++;
+        }
     }
 
     /* Adjust start row for offsets that are greater than the row height. */
-    while (y1 >= _worksheet_size_row(self, row_start)) {
-        y1 -= _worksheet_size_row(self, row_start);
-        row_start++;
+    if (_worksheet_size_row(self, row_start) > 0) {
+        while (y1 >= _worksheet_size_row(self, row_start)) {
+            y1 -= _worksheet_size_row(self, row_start);
+            row_start++;
+        }
     }
 
     /* Initialize end cell to the same as the start cell. */
     col_end = col_start;
     row_end = row_start;
 
-    width = width + x1;
-    height = height + y1;
+    /* Only offset the image in the cell if the row/col isn't hidden. */
+    if (_worksheet_size_col(self, col_start) > 0)
+        width = width + x1;
+    if (_worksheet_size_row(self, row_start) > 0)
+        height = height + y1;
 
     /* Subtract the underlying cell widths to find the end cell. */
     while (width >= _worksheet_size_col(self, col_end)) {
@@ -1888,7 +1993,7 @@ _worksheet_position_object_emus(lxw_worksheet *self,
  */
 void
 lxw_worksheet_prepare_image(lxw_worksheet *self,
-                            uint16_t image_ref_id, uint16_t drawing_id,
+                            uint32_t image_ref_id, uint32_t drawing_id,
                             lxw_image_options *image_data)
 {
     lxw_drawing_object *drawing_object;
@@ -1923,7 +2028,7 @@ lxw_worksheet_prepare_image(lxw_worksheet *self,
 
     drawing_object->anchor_type = LXW_ANCHOR_TYPE_IMAGE;
     drawing_object->edit_as = LXW_ANCHOR_EDIT_AS_ONE_CELL;
-    drawing_object->description = lxw_strdup(image_data->short_name);
+    drawing_object->description = lxw_strdup(image_data->description);
 
     /* Scale to user scale. */
     width = image_data->width * image_data->x_scale;
@@ -1975,8 +2080,10 @@ mem_error:
  */
 void
 lxw_worksheet_prepare_chart(lxw_worksheet *self,
-                            uint16_t chart_ref_id, uint16_t drawing_id,
-                            lxw_image_options *image_data)
+                            uint32_t chart_ref_id,
+                            uint32_t drawing_id,
+                            lxw_image_options *image_data,
+                            uint8_t is_chartsheet)
 {
     lxw_drawing_object *drawing_object;
     lxw_rel_tuple *relationship;
@@ -1986,9 +2093,16 @@ lxw_worksheet_prepare_chart(lxw_worksheet *self,
 
     if (!self->drawing) {
         self->drawing = lxw_drawing_new();
-        self->drawing->embedded = LXW_TRUE;
         RETURN_VOID_ON_MEM_ERROR(self->drawing);
 
+        if (is_chartsheet) {
+            self->drawing->embedded = LXW_FALSE;
+            self->drawing->orientation = self->orientation;
+        }
+        else {
+            self->drawing->embedded = LXW_TRUE;
+        }
+
         relationship = calloc(1, sizeof(lxw_rel_tuple));
         GOTO_LABEL_ON_MEM_ERROR(relationship, mem_error);
 
@@ -2155,8 +2269,7 @@ _process_png(lxw_image_options *image_options)
 
 file_error:
     LXW_WARN_FORMAT1("worksheet_insert_image()/_opt(): "
-                     "no size data found in file: %s.",
-                     image_options->filename);
+                     "no size data found in: %s.", image_options->filename);
 
     return LXW_ERROR_IMAGE_DIMENSIONS;
 }
@@ -2183,8 +2296,7 @@ _process_jpeg(lxw_image_options *image_options)
     if (fseek_err)
         goto file_error;
 
-    /* Search through the image data to read the height and width in the */
-    /* 0xFFC0/C2 element. Also read the DPI in the 0xFFE0 element. */
+    /* Search through the image data and read the JPEG markers. */
     while (!feof(stream)) {
 
         /* Read the JPEG marker and length fields for the sub-section. */
@@ -2201,7 +2313,10 @@ _process_jpeg(lxw_image_options *image_options)
         /* The offset for next fseek() is the field length + type length. */
         offset = length - 2;
 
-        if (marker == 0xFFC0 || marker == 0xFFC2) {
+        /* Read the height and width in the 0xFFCn elements (except C4, C8 */
+        /* and CC which aren't SOF markers). */
+        if ((marker & 0xFFF0) == 0xFFC0 && marker != 0xFFC4
+            && marker != 0xFFC8 && marker != 0xFFCC) {
             /* Skip 1 byte to height and width. */
             fseek_err = fseek(stream, 1, SEEK_CUR);
             if (fseek_err)
@@ -2219,6 +2334,7 @@ _process_jpeg(lxw_image_options *image_options)
             offset -= 9;
         }
 
+        /* Read the DPI in the 0xFFE0 element. */
         if (marker == 0xFFE0) {
             uint16_t x_density = 0;
             uint16_t y_density = 0;
@@ -2279,8 +2395,7 @@ _process_jpeg(lxw_image_options *image_options)
 
 file_error:
     LXW_WARN_FORMAT1("worksheet_insert_image()/_opt(): "
-                     "no size data found in file: %s.",
-                     image_options->filename);
+                     "no size data found in: %s.", image_options->filename);
 
     return LXW_ERROR_IMAGE_DIMENSIONS;
 }
@@ -2314,6 +2429,9 @@ _process_bmp(lxw_image_options *image_options)
     if (width == 0)
         goto file_error;
 
+    height = LXW_UINT32_HOST(height);
+    width = LXW_UINT32_HOST(width);
+
     /* Set the image metadata. */
     image_options->image_type = LXW_IMAGE_BMP;
     image_options->width = width;
@@ -2326,8 +2444,7 @@ _process_bmp(lxw_image_options *image_options)
 
 file_error:
     LXW_WARN_FORMAT1("worksheet_insert_image()/_opt(): "
-                     "no size data found in file: %s.",
-                     image_options->filename);
+                     "no size data found in: %s.", image_options->filename);
 
     return LXW_ERROR_IMAGE_DIMENSIONS;
 }
@@ -2344,7 +2461,7 @@ _get_image_properties(lxw_image_options *image_options)
     /* Read 4 bytes to look for the file header/signature. */
     if (fread(signature, 1, 4, image_options->stream) < 4) {
         LXW_WARN_FORMAT1("worksheet_insert_image()/_opt(): "
-                         "couldn't read file type for file: %s.",
+                         "couldn't read image type for: %s.",
                          image_options->filename);
         return LXW_ERROR_IMAGE_DIMENSIONS;
     }
@@ -2363,7 +2480,7 @@ _get_image_properties(lxw_image_options *image_options)
     }
     else {
         LXW_WARN_FORMAT1("worksheet_insert_image()/_opt(): "
-                         "unsupported image format for file: %s.",
+                         "unsupported image format for: %s.",
                          image_options->filename);
         return LXW_ERROR_IMAGE_DIMENSIONS;
     }
@@ -2385,6 +2502,18 @@ STATIC void
 _write_number_cell(lxw_worksheet *self, char *range,
                    int32_t style_index, lxw_cell *cell)
 {
+#ifdef USE_DOUBLE_FUNCTION
+    char data[LXW_ATTR_32];
+
+    lxw_sprintf_dbl(data, cell->u.number);
+
+    if (style_index)
+        fprintf(self->file,
+                "<c r=\"%s\" s=\"%d\"><v>%s</v></c>",
+                range, style_index, data);
+    else
+        fprintf(self->file, "<c r=\"%s\"><v>%s</v></c>", range, data);
+#else
     if (style_index)
         fprintf(self->file,
                 "<c r=\"%s\" s=\"%d\"><v>%.16g</v></c>",
@@ -2392,6 +2521,8 @@ _write_number_cell(lxw_worksheet *self, char *range,
     else
         fprintf(self->file,
                 "<c r=\"%s\"><v>%.16g</v></c>", range, cell->u.number);
+
+#endif
 }
 
 /*
@@ -2402,6 +2533,7 @@ STATIC void
 _write_string_cell(lxw_worksheet *self, char *range,
                    int32_t style_index, lxw_cell *cell)
 {
+
     if (style_index)
         fprintf(self->file,
                 "<c r=\"%s\" s=\"%d\" t=\"s\"><v>%d</v></c>",
@@ -2451,6 +2583,41 @@ _write_inline_string_cell(lxw_worksheet *self, char *range,
     free(string);
 }
 
+/*
+ * Write out an inline rich string. Doesn't use the xml functions as an
+ * optimization in the inner cell writing loop.
+ */
+STATIC void
+_write_inline_rich_string_cell(lxw_worksheet *self, char *range,
+                               int32_t style_index, lxw_cell *cell)
+{
+    char *string = cell->u.string;
+
+    /* Add attribute to preserve leading or trailing whitespace. */
+    if (isspace((unsigned char) string[0])
+        || isspace((unsigned char) string[strlen(string) - 1])) {
+
+        if (style_index)
+            fprintf(self->file,
+                    "<c r=\"%s\" s=\"%d\" t=\"inlineStr\"><is>%s</is></c>",
+                    range, style_index, string);
+        else
+            fprintf(self->file,
+                    "<c r=\"%s\" t=\"inlineStr\"><is>%s</is></c>",
+                    range, string);
+    }
+    else {
+        if (style_index)
+            fprintf(self->file,
+                    "<c r=\"%s\" s=\"%d\" t=\"inlineStr\">"
+                    "<is>%s</is></c>", range, style_index, string);
+        else
+            fprintf(self->file,
+                    "<c r=\"%s\" t=\"inlineStr\">"
+                    "<is>%s</is></c>", range, string);
+    }
+}
+
 /*
  * Write out a formula worksheet cell with a numeric result.
  */
@@ -2459,8 +2626,7 @@ _write_formula_num_cell(lxw_worksheet *self, lxw_cell *cell)
 {
     char data[LXW_ATTR_32];
 
-    lxw_snprintf(data, LXW_ATTR_32, "%.16g", cell->formula_result);
-
+    lxw_sprintf_dbl(data, cell->formula_result);
     lxw_xml_data_element(self->file, "f", cell->u.string, NULL);
     lxw_xml_data_element(self->file, "v", data, NULL);
 }
@@ -2479,7 +2645,7 @@ _write_array_formula_num_cell(lxw_worksheet *self, lxw_cell *cell)
     LXW_PUSH_ATTRIBUTES_STR("t", "array");
     LXW_PUSH_ATTRIBUTES_STR("ref", cell->user_data1);
 
-    lxw_snprintf(data, LXW_ATTR_32, "%.16g", cell->formula_result);
+    lxw_sprintf_dbl(data, cell->formula_result);
 
     lxw_xml_data_element(self->file, "f", cell->u.string, &attributes);
     lxw_xml_data_element(self->file, "v", data, NULL);
@@ -2515,8 +2681,10 @@ _write_boolean_cell(lxw_worksheet *self, lxw_cell *cell)
 STATIC void
 _calculate_spans(struct lxw_row *row, char *span, int32_t *block_num)
 {
-    lxw_col_t span_col_min = RB_MIN(lxw_table_cells, row->cells)->col_num;
-    lxw_col_t span_col_max = RB_MAX(lxw_table_cells, row->cells)->col_num;
+    lxw_cell *cell_min = RB_MIN(lxw_table_cells, row->cells);
+    lxw_cell *cell_max = RB_MAX(lxw_table_cells, row->cells);
+    lxw_col_t span_col_min = cell_min->col_num;
+    lxw_col_t span_col_max = cell_max->col_num;
     lxw_col_t col_min;
     lxw_col_t col_max;
     *block_num = row->row_num / 16;
@@ -2526,8 +2694,10 @@ _calculate_spans(struct lxw_row *row, char *span, int32_t *block_num)
     while (row && (int32_t) (row->row_num / 16) == *block_num) {
 
         if (!RB_EMPTY(row->cells)) {
-            col_min = RB_MIN(lxw_table_cells, row->cells)->col_num;
-            col_max = RB_MAX(lxw_table_cells, row->cells)->col_num;
+            cell_min = RB_MIN(lxw_table_cells, row->cells);
+            cell_max = RB_MAX(lxw_table_cells, row->cells);
+            col_min = cell_min->col_num;
+            col_max = cell_max->col_num;
 
             if (col_min < span_col_min)
                 span_col_min = col_min;
@@ -2584,6 +2754,11 @@ _write_cell(lxw_worksheet *self, lxw_cell *cell, lxw_format *row_format)
         return;
     }
 
+    if (cell->type == INLINE_RICH_STRING_CELL) {
+        _write_inline_rich_string_cell(self, range, style_index, cell);
+        return;
+    }
+
     /* For other cell types use the general functions. */
     LXW_INIT_ATTRIBUTES();
     LXW_PUSH_ATTRIBUTES_STR("r", range);
@@ -2922,6 +3097,37 @@ _worksheet_write_tab_color(lxw_worksheet *self)
     LXW_FREE_ATTRIBUTES();
 }
 
+/*
+ * Write the <outlinePr> element.
+ */
+STATIC void
+_worksheet_write_outline_pr(lxw_worksheet *self)
+{
+    struct xml_attribute_list attributes;
+    struct xml_attribute *attribute;
+
+    if (!self->outline_changed)
+        return;
+
+    LXW_INIT_ATTRIBUTES();
+
+    if (self->outline_style)
+        LXW_PUSH_ATTRIBUTES_STR("applyStyles", "1");
+
+    if (!self->outline_below)
+        LXW_PUSH_ATTRIBUTES_STR("summaryBelow", "0");
+
+    if (!self->outline_right)
+        LXW_PUSH_ATTRIBUTES_STR("summaryRight", "0");
+
+    if (!self->outline_on)
+        LXW_PUSH_ATTRIBUTES_STR("showOutlineSymbols", "0");
+
+    lxw_xml_empty_tag(self->file, "outlinePr", &attributes);
+
+    LXW_FREE_ATTRIBUTES();
+}
+
 /*
  * Write the <sheetPr> element for Sheet level properties.
  */
@@ -2934,14 +3140,15 @@ _worksheet_write_sheet_pr(lxw_worksheet *self)
     if (!self->fit_page
         && !self->filter_on
         && self->tab_color == LXW_COLOR_UNSET
-        && !self->outline_changed && !self->vba_codename) {
+        && !self->outline_changed
+        && !self->vba_codename && !self->is_chartsheet) {
         return;
     }
 
     LXW_INIT_ATTRIBUTES();
 
     if (self->vba_codename)
-        LXW_PUSH_ATTRIBUTES_INT("codeName", self->vba_codename);
+        LXW_PUSH_ATTRIBUTES_STR("codeName", self->vba_codename);
 
     if (self->filter_on)
         LXW_PUSH_ATTRIBUTES_STR("filterMode", "1");
@@ -2950,7 +3157,7 @@ _worksheet_write_sheet_pr(lxw_worksheet *self)
         || self->outline_changed) {
         lxw_xml_start_tag(self->file, "sheetPr", &attributes);
         _worksheet_write_tab_color(self);
-        /* _worksheet_write_outline_pr(self); */
+        _worksheet_write_outline_pr(self);
         _worksheet_write_page_set_up_pr(self);
         lxw_xml_end_tag(self->file, "sheetPr");
     }
@@ -3205,13 +3412,12 @@ mem_error:
  * Write the <sheetProtection> element.
  */
 STATIC void
-_worksheet_write_sheet_protection(lxw_worksheet *self)
+_worksheet_write_sheet_protection(lxw_worksheet *self,
+                                  lxw_protection *protect)
 {
     struct xml_attribute_list attributes;
     struct xml_attribute *attribute;
 
-    struct lxw_protection *protect = &self->protection;
-
     if (!protect->is_configured)
         return;
 
@@ -3223,7 +3429,7 @@ _worksheet_write_sheet_protection(lxw_worksheet *self)
     if (!protect->no_sheet)
         LXW_PUSH_ATTRIBUTES_INT("sheet", 1);
 
-    if (protect->content)
+    if (!protect->no_content)
         LXW_PUSH_ATTRIBUTES_INT("content", 1);
 
     if (!protect->objects)
@@ -3280,7 +3486,7 @@ _worksheet_write_sheet_protection(lxw_worksheet *self)
  * Write the <drawing> element.
  */
 STATIC void
-_write_drawing(lxw_worksheet *self, uint16_t id)
+_worksheet_write_drawing(lxw_worksheet *self, uint16_t id)
 {
     struct xml_attribute_list attributes;
     struct xml_attribute *attribute;
@@ -3302,120 +3508,387 @@ _write_drawing(lxw_worksheet *self, uint16_t id)
  * Write the <drawing> elements.
  */
 STATIC void
-_write_drawings(lxw_worksheet *self)
+_worksheet_write_drawings(lxw_worksheet *self)
 {
     if (!self->drawing)
         return;
 
     self->rel_count++;
 
-    _write_drawing(self, self->rel_count);
+    _worksheet_write_drawing(self, self->rel_count);
 }
 
 /*
- * Assemble and write the XML file.
+ * Write the <formula1> element for numbers.
  */
-void
-lxw_worksheet_assemble_xml_file(lxw_worksheet *self)
+STATIC void
+_worksheet_write_formula1_num(lxw_worksheet *self, double number)
 {
-    /* Write the XML declaration. */
-    _worksheet_xml_declaration(self);
+    char data[LXW_ATTR_32];
 
-    /* Write the worksheet element. */
-    _worksheet_write_worksheet(self);
+    lxw_sprintf_dbl(data, number);
 
-    /* Write the worksheet properties. */
-    _worksheet_write_sheet_pr(self);
+    lxw_xml_data_element(self->file, "formula1", data, NULL);
+}
 
-    /* Write the worksheet dimensions. */
-    _worksheet_write_dimension(self);
+/*
+ * Write the <formula1> element for strings/formulas.
+ */
+STATIC void
+_worksheet_write_formula1_str(lxw_worksheet *self, char *str)
+{
+    lxw_xml_data_element(self->file, "formula1", str, NULL);
+}
 
-    /* Write the sheet view properties. */
-    _worksheet_write_sheet_views(self);
+/*
+ * Write the <formula2> element for numbers.
+ */
+STATIC void
+_worksheet_write_formula2_num(lxw_worksheet *self, double number)
+{
+    char data[LXW_ATTR_32];
 
-    /* Write the sheet format properties. */
-    _worksheet_write_sheet_format_pr(self);
+    lxw_sprintf_dbl(data, number);
 
-    /* Write the sheet column info. */
-    _worksheet_write_cols(self);
+    lxw_xml_data_element(self->file, "formula2", data, NULL);
+}
 
-    /* Write the sheetData element. */
-    if (!self->optimize)
-        _worksheet_write_sheet_data(self);
-    else
-        _worksheet_write_optimized_sheet_data(self);
+/*
+ * Write the <formula2> element for strings/formulas.
+ */
+STATIC void
+_worksheet_write_formula2_str(lxw_worksheet *self, char *str)
+{
+    lxw_xml_data_element(self->file, "formula2", str, NULL);
+}
 
-    /* Write the sheetProtection element. */
-    _worksheet_write_sheet_protection(self);
+/*
+ * Write the <dataValidation> element.
+ */
+STATIC void
+_worksheet_write_data_validation(lxw_worksheet *self,
+                                 lxw_data_validation *validation)
+{
+    struct xml_attribute_list attributes;
+    struct xml_attribute *attribute;
+    uint8_t is_between = 0;
 
-    /* Write the autoFilter element. */
-    _worksheet_write_auto_filter(self);
+    LXW_INIT_ATTRIBUTES();
 
-    /* Write the mergeCells element. */
-    _worksheet_write_merge_cells(self);
+    switch (validation->validate) {
+        case LXW_VALIDATION_TYPE_INTEGER:
+        case LXW_VALIDATION_TYPE_INTEGER_FORMULA:
+            LXW_PUSH_ATTRIBUTES_STR("type", "whole");
+            break;
+        case LXW_VALIDATION_TYPE_DECIMAL:
+        case LXW_VALIDATION_TYPE_DECIMAL_FORMULA:
+            LXW_PUSH_ATTRIBUTES_STR("type", "decimal");
+            break;
+        case LXW_VALIDATION_TYPE_LIST:
+        case LXW_VALIDATION_TYPE_LIST_FORMULA:
+            LXW_PUSH_ATTRIBUTES_STR("type", "list");
+            break;
+        case LXW_VALIDATION_TYPE_DATE:
+        case LXW_VALIDATION_TYPE_DATE_FORMULA:
+        case LXW_VALIDATION_TYPE_DATE_NUMBER:
+            LXW_PUSH_ATTRIBUTES_STR("type", "date");
+            break;
+        case LXW_VALIDATION_TYPE_TIME:
+        case LXW_VALIDATION_TYPE_TIME_FORMULA:
+        case LXW_VALIDATION_TYPE_TIME_NUMBER:
+            LXW_PUSH_ATTRIBUTES_STR("type", "time");
+            break;
+        case LXW_VALIDATION_TYPE_LENGTH:
+        case LXW_VALIDATION_TYPE_LENGTH_FORMULA:
+            LXW_PUSH_ATTRIBUTES_STR("type", "textLength");
+            break;
+        case LXW_VALIDATION_TYPE_CUSTOM_FORMULA:
+            LXW_PUSH_ATTRIBUTES_STR("type", "custom");
+            break;
+    }
 
-    /* Write the hyperlink element. */
-    _worksheet_write_hyperlinks(self);
+    switch (validation->criteria) {
+        case LXW_VALIDATION_CRITERIA_EQUAL_TO:
+            LXW_PUSH_ATTRIBUTES_STR("operator", "equal");
+            break;
+        case LXW_VALIDATION_CRITERIA_NOT_EQUAL_TO:
+            LXW_PUSH_ATTRIBUTES_STR("operator", "notEqual");
+            break;
+        case LXW_VALIDATION_CRITERIA_LESS_THAN:
+            LXW_PUSH_ATTRIBUTES_STR("operator", "lessThan");
+            break;
+        case LXW_VALIDATION_CRITERIA_LESS_THAN_OR_EQUAL_TO:
+            LXW_PUSH_ATTRIBUTES_STR("operator", "lessThanOrEqual");
+            break;
+        case LXW_VALIDATION_CRITERIA_GREATER_THAN:
+            LXW_PUSH_ATTRIBUTES_STR("operator", "greaterThan");
+            break;
+        case LXW_VALIDATION_CRITERIA_GREATER_THAN_OR_EQUAL_TO:
+            LXW_PUSH_ATTRIBUTES_STR("operator", "greaterThanOrEqual");
+            break;
+        case LXW_VALIDATION_CRITERIA_BETWEEN:
+            /* Between is the default for 2 formulas and isn't added. */
+            is_between = 1;
+            break;
+        case LXW_VALIDATION_CRITERIA_NOT_BETWEEN:
+            is_between = 1;
+            LXW_PUSH_ATTRIBUTES_STR("operator", "notBetween");
+            break;
+    }
 
-    /* Write the printOptions element. */
-    _worksheet_write_print_options(self);
+    if (validation->error_type == LXW_VALIDATION_ERROR_TYPE_WARNING)
+        LXW_PUSH_ATTRIBUTES_STR("errorStyle", "warning");
 
-    /* Write the worksheet page_margins. */
-    _worksheet_write_page_margins(self);
+    if (validation->error_type == LXW_VALIDATION_ERROR_TYPE_INFORMATION)
+        LXW_PUSH_ATTRIBUTES_STR("errorStyle", "information");
 
-    /* Write the worksheet page setup. */
-    _worksheet_write_page_setup(self);
+    if (validation->ignore_blank)
+        LXW_PUSH_ATTRIBUTES_INT("allowBlank", 1);
 
-    /* Write the headerFooter element. */
-    _worksheet_write_header_footer(self);
+    if (validation->dropdown == LXW_VALIDATION_OFF)
+        LXW_PUSH_ATTRIBUTES_INT("showDropDown", 1);
 
-    /* Write the rowBreaks element. */
-    _worksheet_write_row_breaks(self);
+    if (validation->show_input)
+        LXW_PUSH_ATTRIBUTES_INT("showInputMessage", 1);
 
-    /* Write the colBreaks element. */
-    _worksheet_write_col_breaks(self);
+    if (validation->show_error)
+        LXW_PUSH_ATTRIBUTES_INT("showErrorMessage", 1);
 
-    /* Write the drawing element. */
-    _write_drawings(self);
+    if (validation->error_title)
+        LXW_PUSH_ATTRIBUTES_STR("errorTitle", validation->error_title);
 
-    /* Close the worksheet tag. */
-    lxw_xml_end_tag(self->file, "worksheet");
-}
+    if (validation->error_message)
+        LXW_PUSH_ATTRIBUTES_STR("error", validation->error_message);
 
-/*****************************************************************************
- *
- * Public functions.
- *
- ****************************************************************************/
+    if (validation->input_title)
+        LXW_PUSH_ATTRIBUTES_STR("promptTitle", validation->input_title);
 
-/*
- * Write a number to a cell in Excel.
- */
-lxw_error
-worksheet_write_number(lxw_worksheet *self,
-                       lxw_row_t row_num,
-                       lxw_col_t col_num, double value, lxw_format *format)
-{
-    lxw_cell *cell;
-    lxw_error err;
+    if (validation->input_message)
+        LXW_PUSH_ATTRIBUTES_STR("prompt", validation->input_message);
 
-    err = _check_dimensions(self, row_num, col_num, LXW_FALSE, LXW_FALSE);
-    if (err)
-        return err;
+    LXW_PUSH_ATTRIBUTES_STR("sqref", validation->sqref);
 
-    cell = _new_number_cell(row_num, col_num, value, format);
+    if (validation->validate == LXW_VALIDATION_TYPE_ANY)
+        lxw_xml_empty_tag(self->file, "dataValidation", &attributes);
+    else
+        lxw_xml_start_tag(self->file, "dataValidation", &attributes);
+
+    /* Write the formula1 and formula2 elements. */
+    switch (validation->validate) {
+        case LXW_VALIDATION_TYPE_INTEGER:
+        case LXW_VALIDATION_TYPE_DECIMAL:
+        case LXW_VALIDATION_TYPE_LENGTH:
+        case LXW_VALIDATION_TYPE_DATE:
+        case LXW_VALIDATION_TYPE_TIME:
+        case LXW_VALIDATION_TYPE_DATE_NUMBER:
+        case LXW_VALIDATION_TYPE_TIME_NUMBER:
+            _worksheet_write_formula1_num(self, validation->value_number);
+            if (is_between)
+                _worksheet_write_formula2_num(self,
+                                              validation->maximum_number);
+            break;
+        case LXW_VALIDATION_TYPE_INTEGER_FORMULA:
+        case LXW_VALIDATION_TYPE_DECIMAL_FORMULA:
+        case LXW_VALIDATION_TYPE_LENGTH_FORMULA:
+        case LXW_VALIDATION_TYPE_DATE_FORMULA:
+        case LXW_VALIDATION_TYPE_TIME_FORMULA:
+        case LXW_VALIDATION_TYPE_LIST:
+        case LXW_VALIDATION_TYPE_LIST_FORMULA:
+        case LXW_VALIDATION_TYPE_CUSTOM_FORMULA:
+            _worksheet_write_formula1_str(self, validation->value_formula);
+            if (is_between)
+                _worksheet_write_formula2_str(self,
+                                              validation->maximum_formula);
+            break;
+    }
 
-    _insert_cell(self, row_num, col_num, cell);
+    if (validation->validate != LXW_VALIDATION_TYPE_ANY)
+        lxw_xml_end_tag(self->file, "dataValidation");
 
-    return LXW_NO_ERROR;
+    LXW_FREE_ATTRIBUTES();
 }
 
 /*
- * Write a string to an Excel file.
+ * Write the <dataValidations> element.
  */
-lxw_error
-worksheet_write_string(lxw_worksheet *self,
-                       lxw_row_t row_num,
+STATIC void
+_worksheet_write_data_validations(lxw_worksheet *self)
+{
+    struct xml_attribute_list attributes;
+    struct xml_attribute *attribute;
+    lxw_data_validation *data_validation;
+
+    if (self->num_validations == 0)
+        return;
+
+    LXW_INIT_ATTRIBUTES();
+    LXW_PUSH_ATTRIBUTES_INT("count", self->num_validations);
+
+    lxw_xml_start_tag(self->file, "dataValidations", &attributes);
+
+    STAILQ_FOREACH(data_validation, self->data_validations, list_pointers) {
+        /* Write the dataValidation element. */
+        _worksheet_write_data_validation(self, data_validation);
+    }
+
+    lxw_xml_end_tag(self->file, "dataValidations");
+
+    LXW_FREE_ATTRIBUTES();
+}
+
+/*
+ * External functions to call intern XML methods shared with chartsheet.
+ */
+void
+lxw_worksheet_write_sheet_views(lxw_worksheet *self)
+{
+    _worksheet_write_sheet_views(self);
+}
+
+void
+lxw_worksheet_write_page_margins(lxw_worksheet *self)
+{
+    _worksheet_write_page_margins(self);
+}
+
+void
+lxw_worksheet_write_drawings(lxw_worksheet *self)
+{
+    _worksheet_write_drawings(self);
+}
+
+void
+lxw_worksheet_write_sheet_protection(lxw_worksheet *self,
+                                     lxw_protection *protect)
+{
+    _worksheet_write_sheet_protection(self, protect);
+}
+
+void
+lxw_worksheet_write_sheet_pr(lxw_worksheet *self)
+{
+    _worksheet_write_sheet_pr(self);
+}
+
+void
+lxw_worksheet_write_page_setup(lxw_worksheet *self)
+{
+    _worksheet_write_page_setup(self);
+}
+
+void
+lxw_worksheet_write_header_footer(lxw_worksheet *self)
+{
+    _worksheet_write_header_footer(self);
+}
+
+/*
+ * Assemble and write the XML file.
+ */
+void
+lxw_worksheet_assemble_xml_file(lxw_worksheet *self)
+{
+    /* Write the XML declaration. */
+    _worksheet_xml_declaration(self);
+
+    /* Write the worksheet element. */
+    _worksheet_write_worksheet(self);
+
+    /* Write the worksheet properties. */
+    _worksheet_write_sheet_pr(self);
+
+    /* Write the worksheet dimensions. */
+    _worksheet_write_dimension(self);
+
+    /* Write the sheet view properties. */
+    _worksheet_write_sheet_views(self);
+
+    /* Write the sheet format properties. */
+    _worksheet_write_sheet_format_pr(self);
+
+    /* Write the sheet column info. */
+    _worksheet_write_cols(self);
+
+    /* Write the sheetData element. */
+    if (!self->optimize)
+        _worksheet_write_sheet_data(self);
+    else
+        _worksheet_write_optimized_sheet_data(self);
+
+    /* Write the sheetProtection element. */
+    _worksheet_write_sheet_protection(self, &self->protection);
+
+    /* Write the autoFilter element. */
+    _worksheet_write_auto_filter(self);
+
+    /* Write the mergeCells element. */
+    _worksheet_write_merge_cells(self);
+
+    /* Write the dataValidations element. */
+    _worksheet_write_data_validations(self);
+
+    /* Write the hyperlink element. */
+    _worksheet_write_hyperlinks(self);
+
+    /* Write the printOptions element. */
+    _worksheet_write_print_options(self);
+
+    /* Write the worksheet page_margins. */
+    _worksheet_write_page_margins(self);
+
+    /* Write the worksheet page setup. */
+    _worksheet_write_page_setup(self);
+
+    /* Write the headerFooter element. */
+    _worksheet_write_header_footer(self);
+
+    /* Write the rowBreaks element. */
+    _worksheet_write_row_breaks(self);
+
+    /* Write the colBreaks element. */
+    _worksheet_write_col_breaks(self);
+
+    /* Write the drawing element. */
+    _worksheet_write_drawings(self);
+
+    /* Close the worksheet tag. */
+    lxw_xml_end_tag(self->file, "worksheet");
+}
+
+/*****************************************************************************
+ *
+ * Public functions.
+ *
+ ****************************************************************************/
+
+/*
+ * Write a number to a cell in Excel.
+ */
+lxw_error
+worksheet_write_number(lxw_worksheet *self,
+                       lxw_row_t row_num,
+                       lxw_col_t col_num, double value, lxw_format *format)
+{
+    lxw_cell *cell;
+    lxw_error err;
+
+    err = _check_dimensions(self, row_num, col_num, LXW_FALSE, LXW_FALSE);
+    if (err)
+        return err;
+
+    cell = _new_number_cell(row_num, col_num, value, format);
+
+    _insert_cell(self, row_num, col_num, cell);
+
+    return LXW_NO_ERROR;
+}
+
+/*
+ * Write a string to an Excel file.
+ */
+lxw_error
+worksheet_write_string(lxw_worksheet *self,
+                       lxw_row_t row_num,
                        lxw_col_t col_num, const char *string,
                        lxw_format *format)
 {
@@ -3431,7 +3904,7 @@ worksheet_write_string(lxw_worksheet *self,
         if (format)
             return worksheet_write_blank(self, row_num, col_num, format);
         else
-            return LXW_ERROR_NULL_PARAMETER_IGNORED;
+            return LXW_NO_ERROR;
     }
 
     err = _check_dimensions(self, row_num, col_num, LXW_FALSE, LXW_FALSE);
@@ -3443,7 +3916,7 @@ worksheet_write_string(lxw_worksheet *self,
 
     if (!self->optimize) {
         /* Get the SST element and string id. */
-        sst_element = lxw_get_sst_index(self->sst, string);
+        sst_element = lxw_get_sst_index(self->sst, string, LXW_FALSE);
 
         if (!sst_element)
             return LXW_ERROR_SHARED_STRING_INDEX_NOT_FOUND;
@@ -3918,6 +4391,156 @@ worksheet_write_url(lxw_worksheet *self,
                                    NULL);
 }
 
+/*
+ * Write a rich string to an Excel file.
+ *
+ * Rather than duplicate several of the styles.c font xml methods of styles.c
+ * and write the data to a memory buffer this function creates a temporary
+ * styles object and uses it to write the data to a file. It then reads that
+ * data back into memory and closes the file.
+ */
+lxw_error
+worksheet_write_rich_string(lxw_worksheet *self,
+                            lxw_row_t row_num,
+                            lxw_col_t col_num,
+                            lxw_rich_string_tuple *rich_strings[],
+                            lxw_format *format)
+{
+    lxw_cell *cell;
+    int32_t string_id;
+    struct sst_element *sst_element;
+    lxw_error err;
+    uint8_t i;
+    long file_size;
+    char *rich_string = NULL;
+    char *string_copy = NULL;
+    lxw_styles *styles = NULL;
+    lxw_format *default_format = NULL;
+    lxw_rich_string_tuple *rich_string_tuple = NULL;
+    FILE *tmpfile;
+
+    err = _check_dimensions(self, row_num, col_num, LXW_FALSE, LXW_FALSE);
+    if (err)
+        return err;
+
+    /* Iterate through rich string fragments to check for input errors. */
+    i = 0;
+    err = LXW_NO_ERROR;
+    while ((rich_string_tuple = rich_strings[i++]) != NULL) {
+
+        /* Check for NULL or empty strings. */
+        if (!rich_string_tuple->string || !*rich_string_tuple->string) {
+            err = LXW_ERROR_PARAMETER_VALIDATION;
+        }
+    }
+
+    /* If there are less than 2 fragments it isn't a rich string. */
+    if (i <= 2)
+        err = LXW_ERROR_PARAMETER_VALIDATION;
+
+    if (err)
+        return err;
+
+    /* Create a tmp file for the styles object. */
+    tmpfile = lxw_tmpfile(self->tmpdir);
+    if (!tmpfile)
+        return LXW_ERROR_CREATING_TMPFILE;
+
+    /* Create a temp styles object for writing the font data. */
+    styles = lxw_styles_new();
+    GOTO_LABEL_ON_MEM_ERROR(styles, mem_error);
+    styles->file = tmpfile;
+
+    /* Create a default format for non-formatted text. */
+    default_format = lxw_format_new();
+    GOTO_LABEL_ON_MEM_ERROR(default_format, mem_error);
+
+    /* Iterate through the rich string fragments and write each one out. */
+    i = 0;
+    while ((rich_string_tuple = rich_strings[i++]) != NULL) {
+        lxw_xml_start_tag(tmpfile, "r", NULL);
+
+        if (rich_string_tuple->format) {
+            /* Write the user defined font format. */
+            lxw_styles_write_rich_font(styles, rich_string_tuple->format);
+        }
+        else {
+            /* Write a default font format. Except for the first fragment. */
+            if (i > 1)
+                lxw_styles_write_rich_font(styles, default_format);
+        }
+
+        lxw_styles_write_string_fragment(styles, rich_string_tuple->string);
+        lxw_xml_end_tag(tmpfile, "r");
+    }
+
+    /* Free the temp objects. */
+    lxw_styles_free(styles);
+    lxw_format_free(default_format);
+
+    /* Flush the file and read the size to calculate the required memory. */
+    fflush(tmpfile);
+    file_size = ftell(tmpfile);
+
+    /* Allocate a buffer for the rich string xml data. */
+    rich_string = calloc(file_size + 1, 1);
+    GOTO_LABEL_ON_MEM_ERROR(rich_string, mem_error);
+
+    /* Rewind the file and read the data into the memory buffer. */
+    rewind(tmpfile);
+    if (fread(rich_string, file_size, 1, tmpfile) < 1) {
+        fclose(tmpfile);
+        free(rich_string);
+        return LXW_ERROR_READING_TMPFILE;
+    }
+
+    /* Close the temp file. */
+    fclose(tmpfile);
+
+    if (lxw_utf8_strlen(rich_string) > LXW_STR_MAX) {
+        free(rich_string);
+        return LXW_ERROR_MAX_STRING_LENGTH_EXCEEDED;
+    }
+
+    if (!self->optimize) {
+        /* Get the SST element and string id. */
+        sst_element = lxw_get_sst_index(self->sst, rich_string, LXW_TRUE);
+        free(rich_string);
+
+        if (!sst_element)
+            return LXW_ERROR_SHARED_STRING_INDEX_NOT_FOUND;
+
+        string_id = sst_element->index;
+        cell = _new_string_cell(row_num, col_num, string_id,
+                                sst_element->string, format);
+    }
+    else {
+        /* Look for and escape control chars in the string. */
+        if (strpbrk(rich_string, "\x01\x02\x03\x04\x05\x06\x07\x08\x0B\x0C"
+                    "\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16"
+                    "\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F")) {
+            string_copy = lxw_escape_control_characters(rich_string);
+            free(rich_string);
+        }
+        else {
+            string_copy = rich_string;
+        }
+        cell = _new_inline_rich_string_cell(row_num, col_num, string_copy,
+                                            format);
+    }
+
+    _insert_cell(self, row_num, col_num, cell);
+
+    return LXW_NO_ERROR;
+
+mem_error:
+    lxw_styles_free(styles);
+    lxw_format_free(default_format);
+    fclose(tmpfile);
+
+    return LXW_ERROR_MEMORY_MALLOC_FAILED;
+}
+
 /*
  * Set the properties of a single column or a range of columns with options.
  */
@@ -4010,6 +4633,14 @@ worksheet_set_column_opt(lxw_worksheet *self,
     copied_options = calloc(1, sizeof(lxw_col_options));
     RETURN_ON_MEM_ERROR(copied_options, LXW_ERROR_MEMORY_MALLOC_FAILED);
 
+    /* Ensure the level is <= 7). */
+    if (level > 7)
+        level = 7;
+
+    if (level > self->outline_col_level)
+        self->outline_col_level = level;
+
+    /* Set the column properties. */
     copied_options->firstcol = firstcol;
     copied_options->lastcol = lastcol;
     copied_options->width = width;
@@ -4082,6 +4713,14 @@ worksheet_set_row_opt(lxw_worksheet *self,
         height = self->default_row_height;
     }
 
+    /* Ensure the level is <= 7). */
+    if (level > 7)
+        level = 7;
+
+    if (level > self->outline_row_level)
+        self->outline_row_level = level;
+
+    /* Store the row properties. */
     row = _get_row(self, row_num);
 
     row->height = height;
@@ -4467,7 +5106,7 @@ worksheet_set_header_opt(lxw_worksheet *self, const char *string,
                          lxw_header_footer_options *options)
 {
     if (options) {
-        if (options->margin > 0)
+        if (options->margin >= 0.0)
             self->margin_header = options->margin;
     }
 
@@ -4491,7 +5130,7 @@ worksheet_set_footer_opt(lxw_worksheet *self, const char *string,
                          lxw_header_footer_options *options)
 {
     if (options) {
-        if (options->margin > 0)
+        if (options->margin >= 0.0)
             self->margin_footer = options->margin;
     }
 
@@ -4819,20 +5458,50 @@ worksheet_protect(lxw_worksheet *self, const char *password,
     struct lxw_protection *protect = &self->protection;
 
     /* Copy any user parameters to the internal structure. */
-    if (options)
-        memcpy(protect, options, sizeof(lxw_protection));
-
-    /* Zero the hash storage in case of copied initialization data. */
-    protect->hash[0] = '\0';
+    if (options) {
+        protect->no_select_locked_cells = options->no_select_locked_cells;
+        protect->no_select_unlocked_cells = options->no_select_unlocked_cells;
+        protect->format_cells = options->format_cells;
+        protect->format_columns = options->format_columns;
+        protect->format_rows = options->format_rows;
+        protect->insert_columns = options->insert_columns;
+        protect->insert_rows = options->insert_rows;
+        protect->insert_hyperlinks = options->insert_hyperlinks;
+        protect->delete_columns = options->delete_columns;
+        protect->delete_rows = options->delete_rows;
+        protect->sort = options->sort;
+        protect->autofilter = options->autofilter;
+        protect->pivot_tables = options->pivot_tables;
+        protect->scenarios = options->scenarios;
+        protect->objects = options->objects;
+    }
 
     if (password) {
-        uint16_t hash = _hash_password(password);
+        uint16_t hash = lxw_hash_password(password);
         lxw_snprintf(protect->hash, 5, "%X", hash);
     }
 
+    protect->no_content = LXW_TRUE;
     protect->is_configured = LXW_TRUE;
 }
 
+/*
+ * Set the worksheet properties for outlines and grouping.
+ */
+void
+worksheet_outline_settings(lxw_worksheet *self,
+                           uint8_t visible,
+                           uint8_t symbols_below,
+                           uint8_t symbols_right, uint8_t auto_style)
+{
+    self->outline_on = visible;
+    self->outline_below = symbols_below;
+    self->outline_right = symbols_right;
+    self->outline_style = auto_style;
+
+    self->outline_changed = LXW_TRUE;
+}
+
 /*
  * Set the default row properties
  */
@@ -4864,7 +5533,7 @@ worksheet_insert_image_opt(lxw_worksheet *self,
                            lxw_image_options *user_options)
 {
     FILE *image_stream;
-    char *short_name;
+    char *description;
     lxw_image_options *options;
 
     if (!filename) {
@@ -4882,9 +5551,9 @@ worksheet_insert_image_opt(lxw_worksheet *self,
         return LXW_ERROR_PARAMETER_VALIDATION;
     }
 
-    /* Get the filename from the full path to add to the Drawing object. */
-    short_name = lxw_basename(filename);
-    if (!short_name) {
+    /* Use the filename as the default description, like Excel. */
+    description = lxw_basename(filename);
+    if (!description) {
         LXW_WARN_FORMAT1("worksheet_insert_image()/_opt(): "
                          "couldn't get basename for file: %s.", filename);
         fclose(image_stream);
@@ -4899,14 +5568,15 @@ worksheet_insert_image_opt(lxw_worksheet *self,
     }
 
     if (user_options) {
-        memcpy(options, user_options, sizeof(lxw_image_options));
-        options->url = lxw_strdup(user_options->url);
-        options->tip = lxw_strdup(user_options->tip);
+        options->x_offset = user_options->x_offset;
+        options->y_offset = user_options->y_offset;
+        options->x_scale = user_options->x_scale;
+        options->y_scale = user_options->y_scale;
     }
 
     /* Copy other options or set defaults. */
     options->filename = lxw_strdup(filename);
-    options->short_name = lxw_strdup(short_name);
+    options->description = lxw_strdup(description);
     options->stream = image_stream;
     options->row = row_num;
     options->col = col_num;
@@ -4919,10 +5589,12 @@ worksheet_insert_image_opt(lxw_worksheet *self,
 
     if (_get_image_properties(options) == LXW_NO_ERROR) {
         STAILQ_INSERT_TAIL(self->image_data, options, list_pointers);
+        fclose(image_stream);
         return LXW_NO_ERROR;
     }
     else {
-        free(options);
+        _free_image_options(options);
+        fclose(image_stream);
         return LXW_ERROR_IMAGE_DIMENSIONS;
     }
 }
@@ -4938,6 +5610,95 @@ worksheet_insert_image(lxw_worksheet *self,
     return worksheet_insert_image_opt(self, row_num, col_num, filename, NULL);
 }
 
+lxw_error
+worksheet_insert_image_buffer_opt(lxw_worksheet *self,
+                                  lxw_row_t row_num,
+                                  lxw_col_t col_num,
+                                  const unsigned char *image_buffer,
+                                  size_t image_size,
+                                  lxw_image_options *user_options)
+{
+    FILE *image_stream;
+    lxw_image_options *options;
+
+    if (!image_size) {
+        LXW_WARN("worksheet_insert_image_buffer()/_opt(): "
+                 "size must be non-zero.");
+        return LXW_ERROR_NULL_PARAMETER_IGNORED;
+    }
+
+    /* Write the image buffer to a temporary file so we can read the
+     * dimensions like an ordinary file. */
+    image_stream = lxw_tmpfile(self->tmpdir);
+    if (!image_stream)
+        return LXW_ERROR_CREATING_TMPFILE;
+
+    fwrite(image_buffer, 1, image_size, image_stream);
+    rewind(image_stream);
+
+    /* Create a new object to hold the image options. */
+    options = calloc(1, sizeof(lxw_image_options));
+    if (!options) {
+        fclose(image_stream);
+        return LXW_ERROR_MEMORY_MALLOC_FAILED;
+    }
+
+    /* Store the image data in the options structure. */
+    options->image_buffer = calloc(1, image_size);
+    if (!options->image_buffer) {
+        _free_image_options(options);
+        fclose(image_stream);
+        return LXW_ERROR_MEMORY_MALLOC_FAILED;
+    }
+    else {
+        memcpy(options->image_buffer, image_buffer, image_size);
+        options->image_buffer_size = image_size;
+        options->is_image_buffer = LXW_TRUE;
+    }
+
+    if (user_options) {
+        options->x_offset = user_options->x_offset;
+        options->y_offset = user_options->y_offset;
+        options->x_scale = user_options->x_scale;
+        options->y_scale = user_options->y_scale;
+        options->description = lxw_strdup(user_options->description);
+    }
+
+    /* Copy other options or set defaults. */
+    options->filename = lxw_strdup("image_buffer");
+    options->stream = image_stream;
+    options->row = row_num;
+    options->col = col_num;
+
+    if (!options->x_scale)
+        options->x_scale = 1;
+
+    if (!options->y_scale)
+        options->y_scale = 1;
+
+    if (_get_image_properties(options) == LXW_NO_ERROR) {
+        STAILQ_INSERT_TAIL(self->image_data, options, list_pointers);
+        fclose(image_stream);
+        return LXW_NO_ERROR;
+    }
+    else {
+        _free_image_options(options);
+        fclose(image_stream);
+        return LXW_ERROR_IMAGE_DIMENSIONS;
+    }
+}
+
+lxw_error
+worksheet_insert_image_buffer(lxw_worksheet *self,
+                              lxw_row_t row_num,
+                              lxw_col_t col_num,
+                              const unsigned char *image_buffer,
+                              size_t image_size)
+{
+    return worksheet_insert_image_buffer_opt(self, row_num, col_num,
+                                             image_buffer, image_size, NULL);
+}
+
 /*
  * Insert an chart into the worksheet.
  */
@@ -4984,8 +5745,12 @@ worksheet_insert_chart_opt(lxw_worksheet *self,
     options = calloc(1, sizeof(lxw_image_options));
     RETURN_ON_MEM_ERROR(options, LXW_ERROR_MEMORY_MALLOC_FAILED);
 
-    if (user_options)
-        memcpy(options, user_options, sizeof(lxw_image_options));
+    if (user_options) {
+        options->x_offset = user_options->x_offset;
+        options->y_offset = user_options->y_offset;
+        options->x_scale = user_options->x_scale;
+        options->y_scale = user_options->y_scale;
+    }
 
     /* Copy other options or set defaults. */
     options->row = row_num;
@@ -5020,3 +5785,304 @@ worksheet_insert_chart(lxw_worksheet *self,
 {
     return worksheet_insert_chart_opt(self, row_num, col_num, chart, NULL);
 }
+
+/*
+ * Add a data validation to a worksheet, for a range. Ironically this requires
+ * a lot of validation of the user input.
+ */
+lxw_error
+worksheet_data_validation_range(lxw_worksheet *self, lxw_row_t first_row,
+                                lxw_col_t first_col,
+                                lxw_row_t last_row,
+                                lxw_col_t last_col,
+                                lxw_data_validation *validation)
+{
+    lxw_data_validation *copy;
+    uint8_t is_between = LXW_FALSE;
+    uint8_t is_formula = LXW_FALSE;
+    uint8_t has_criteria = LXW_TRUE;
+    lxw_error err;
+    lxw_row_t tmp_row;
+    lxw_col_t tmp_col;
+    size_t length;
+
+    /* No action is required for validation type 'any' unless there are
+     * input messages to display.*/
+    if (validation->validate == LXW_VALIDATION_TYPE_ANY
+        && !(validation->input_title || validation->input_message)) {
+
+        return LXW_NO_ERROR;
+    }
+
+    /* Check for formula types. */
+    switch (validation->validate) {
+        case LXW_VALIDATION_TYPE_INTEGER_FORMULA:
+        case LXW_VALIDATION_TYPE_DECIMAL_FORMULA:
+        case LXW_VALIDATION_TYPE_LIST_FORMULA:
+        case LXW_VALIDATION_TYPE_LENGTH_FORMULA:
+        case LXW_VALIDATION_TYPE_DATE_FORMULA:
+        case LXW_VALIDATION_TYPE_TIME_FORMULA:
+        case LXW_VALIDATION_TYPE_CUSTOM_FORMULA:
+            is_formula = LXW_TRUE;
+            break;
+    }
+
+    /* Check for types without a criteria. */
+    switch (validation->validate) {
+        case LXW_VALIDATION_TYPE_LIST:
+        case LXW_VALIDATION_TYPE_LIST_FORMULA:
+        case LXW_VALIDATION_TYPE_ANY:
+        case LXW_VALIDATION_TYPE_CUSTOM_FORMULA:
+            has_criteria = LXW_FALSE;
+            break;
+    }
+
+    /* Check that a validation parameter has been specified
+     * except for 'list', 'any' and 'custom'. */
+    if (has_criteria && validation->criteria == LXW_VALIDATION_CRITERIA_NONE) {
+
+        LXW_WARN_FORMAT("worksheet_data_validation_cell()/_range(): "
+                        "criteria parameter must be specified.");
+        return LXW_ERROR_PARAMETER_VALIDATION;
+    }
+
+    /* Check for "between" criteria so we can do additional checks. */
+    if (has_criteria
+        && (validation->criteria == LXW_VALIDATION_CRITERIA_BETWEEN
+            || validation->criteria == LXW_VALIDATION_CRITERIA_NOT_BETWEEN)) {
+
+        is_between = LXW_TRUE;
+    }
+
+    /* Check that formula values are non NULL. */
+    if (is_formula) {
+        if (is_between) {
+            if (!validation->minimum_formula) {
+                LXW_WARN_FORMAT("worksheet_data_validation_cell()/_range(): "
+                                "minimum_formula parameter cannot be NULL.");
+                return LXW_ERROR_PARAMETER_VALIDATION;
+            }
+            if (!validation->maximum_formula) {
+                LXW_WARN_FORMAT("worksheet_data_validation_cell()/_range(): "
+                                "maximum_formula parameter cannot be NULL.");
+                return LXW_ERROR_PARAMETER_VALIDATION;
+            }
+        }
+        else {
+            if (!validation->value_formula) {
+                LXW_WARN_FORMAT("worksheet_data_validation_cell()/_range(): "
+                                "formula parameter cannot be NULL.");
+                return LXW_ERROR_PARAMETER_VALIDATION;
+            }
+        }
+    }
+
+    /* Check Excel limitations on input strings. */
+    if (validation->input_title) {
+        length = lxw_utf8_strlen(validation->input_title);
+        if (length > LXW_VALIDATION_MAX_TITLE_LENGTH) {
+            LXW_WARN_FORMAT1("worksheet_data_validation_cell()/_range(): "
+                             "input_title length > Excel limit of %d.",
+                             LXW_VALIDATION_MAX_TITLE_LENGTH);
+            return LXW_ERROR_32_STRING_LENGTH_EXCEEDED;
+        }
+    }
+
+    if (validation->error_title) {
+        length = lxw_utf8_strlen(validation->error_title);
+        if (length > LXW_VALIDATION_MAX_TITLE_LENGTH) {
+            LXW_WARN_FORMAT1("worksheet_data_validation_cell()/_range(): "
+                             "error_title length > Excel limit of %d.",
+                             LXW_VALIDATION_MAX_TITLE_LENGTH);
+            return LXW_ERROR_32_STRING_LENGTH_EXCEEDED;
+        }
+    }
+
+    if (validation->input_message) {
+        length = lxw_utf8_strlen(validation->input_message);
+        if (length > LXW_VALIDATION_MAX_STRING_LENGTH) {
+            LXW_WARN_FORMAT1("worksheet_data_validation_cell()/_range(): "
+                             "input_message length > Excel limit of %d.",
+                             LXW_VALIDATION_MAX_STRING_LENGTH);
+            return LXW_ERROR_255_STRING_LENGTH_EXCEEDED;
+        }
+    }
+
+    if (validation->error_message) {
+        length = lxw_utf8_strlen(validation->error_message);
+        if (length > LXW_VALIDATION_MAX_STRING_LENGTH) {
+            LXW_WARN_FORMAT1("worksheet_data_validation_cell()/_range(): "
+                             "error_message length > Excel limit of %d.",
+                             LXW_VALIDATION_MAX_STRING_LENGTH);
+            return LXW_ERROR_255_STRING_LENGTH_EXCEEDED;
+        }
+    }
+
+    if (validation->validate == LXW_VALIDATION_TYPE_LIST) {
+        length = _validation_list_length(validation->value_list);
+
+        if (length == 0) {
+            LXW_WARN_FORMAT("worksheet_data_validation_cell()/_range(): "
+                            "list parameters cannot be zero.");
+            return LXW_ERROR_PARAMETER_VALIDATION;
+        }
+
+        if (length > LXW_VALIDATION_MAX_STRING_LENGTH) {
+            LXW_WARN_FORMAT1("worksheet_data_validation_cell()/_range(): "
+                             "list length with commas > Excel limit of %d.",
+                             LXW_VALIDATION_MAX_STRING_LENGTH);
+            return LXW_ERROR_255_STRING_LENGTH_EXCEEDED;
+        }
+    }
+
+    /* Swap last row/col with first row/col as necessary */
+    if (first_row > last_row) {
+        tmp_row = last_row;
+        last_row = first_row;
+        first_row = tmp_row;
+    }
+    if (first_col > last_col) {
+        tmp_col = last_col;
+        last_col = first_col;
+        first_col = tmp_col;
+    }
+
+    /* Check that dimensions are valid but don't store them. */
+    err = _check_dimensions(self, last_row, last_col, LXW_TRUE, LXW_TRUE);
+    if (err)
+        return err;
+
+    /* Create a copy of the parameters from the user data validation. */
+    copy = calloc(1, sizeof(lxw_data_validation));
+    GOTO_LABEL_ON_MEM_ERROR(copy, mem_error);
+
+    /* Create the data validation range. */
+    if (first_row == last_row && first_col == last_col)
+        lxw_rowcol_to_cell(copy->sqref, first_row, last_col);
+    else
+        lxw_rowcol_to_range(copy->sqref, first_row, first_col, last_row,
+                            last_col);
+
+    /* Copy the parameters from the user data validation. */
+    copy->validate = validation->validate;
+    copy->value_number = validation->value_number;
+    copy->error_type = validation->error_type;
+    copy->dropdown = validation->dropdown;
+    copy->is_between = is_between;
+
+    if (has_criteria)
+        copy->criteria = validation->criteria;
+
+    if (is_between) {
+        copy->value_number = validation->minimum_number;
+        copy->maximum_number = validation->maximum_number;
+    }
+
+    /* Copy the input/error titles and messages. */
+    if (validation->input_title) {
+        copy->input_title = lxw_strdup_formula(validation->input_title);
+        GOTO_LABEL_ON_MEM_ERROR(copy->input_title, mem_error);
+    }
+
+    if (validation->input_message) {
+        copy->input_message = lxw_strdup_formula(validation->input_message);
+        GOTO_LABEL_ON_MEM_ERROR(copy->input_message, mem_error);
+    }
+
+    if (validation->error_title) {
+        copy->error_title = lxw_strdup_formula(validation->error_title);
+        GOTO_LABEL_ON_MEM_ERROR(copy->error_title, mem_error);
+    }
+
+    if (validation->error_message) {
+        copy->error_message = lxw_strdup_formula(validation->error_message);
+        GOTO_LABEL_ON_MEM_ERROR(copy->error_message, mem_error);
+    }
+
+    /* Copy the formula strings. */
+    if (is_formula) {
+        if (is_between) {
+            copy->value_formula =
+                lxw_strdup_formula(validation->minimum_formula);
+            GOTO_LABEL_ON_MEM_ERROR(copy->value_formula, mem_error);
+            copy->maximum_formula =
+                lxw_strdup_formula(validation->maximum_formula);
+            GOTO_LABEL_ON_MEM_ERROR(copy->maximum_formula, mem_error);
+        }
+        else {
+            copy->value_formula =
+                lxw_strdup_formula(validation->value_formula);
+            GOTO_LABEL_ON_MEM_ERROR(copy->value_formula, mem_error);
+        }
+    }
+
+    /* Copy the validation list as a csv string. */
+    if (validation->validate == LXW_VALIDATION_TYPE_LIST) {
+        copy->value_formula = _validation_list_to_csv(validation->value_list);
+        GOTO_LABEL_ON_MEM_ERROR(copy->value_formula, mem_error);
+    }
+
+    if (validation->validate == LXW_VALIDATION_TYPE_LIST_FORMULA) {
+        copy->value_formula = lxw_strdup_formula(validation->value_formula);
+        GOTO_LABEL_ON_MEM_ERROR(copy->value_formula, mem_error);
+    }
+
+    if (validation->validate == LXW_VALIDATION_TYPE_DATE
+        || validation->validate == LXW_VALIDATION_TYPE_TIME) {
+        if (is_between) {
+            copy->value_number =
+                lxw_datetime_to_excel_date(&validation->minimum_datetime,
+                                           LXW_EPOCH_1900);
+            copy->maximum_number =
+                lxw_datetime_to_excel_date(&validation->maximum_datetime,
+                                           LXW_EPOCH_1900);
+        }
+        else {
+            copy->value_number =
+                lxw_datetime_to_excel_date(&validation->value_datetime,
+                                           LXW_EPOCH_1900);
+        }
+    }
+
+    /* These options are on by default so we can't take plain booleans. */
+    copy->ignore_blank = validation->ignore_blank ^ 1;
+    copy->show_input = validation->show_input ^ 1;
+    copy->show_error = validation->show_error ^ 1;
+
+    STAILQ_INSERT_TAIL(self->data_validations, copy, list_pointers);
+
+    self->num_validations++;
+
+    return LXW_NO_ERROR;
+
+mem_error:
+    _free_data_validation(copy);
+    return LXW_ERROR_MEMORY_MALLOC_FAILED;
+}
+
+/*
+ * Add a data validation to a worksheet, for a cell.
+ */
+lxw_error
+worksheet_data_validation_cell(lxw_worksheet *self, lxw_row_t row,
+                               lxw_col_t col, lxw_data_validation *validation)
+{
+    return worksheet_data_validation_range(self, row, col,
+                                           row, col, validation);
+}
+
+/*
+ * Set the VBA name for the worksheet.
+ */
+lxw_error
+worksheet_set_vba_name(lxw_worksheet *self, const char *name)
+{
+    if (!name) {
+        LXW_WARN("worksheet_set_vba_name(): " "name must be specified.");
+        return LXW_ERROR_NULL_PARAMETER_IGNORED;
+    }
+
+    self->vba_codename = lxw_strdup(name);
+
+    return LXW_NO_ERROR;
+}