fast_excel 0.5.0 → 0.6.1

data/libxlsxwriter/src/worksheet.c

@@ -3,7 +3,8 @@
  *
  * Used in conjunction with the libxlsxwriter library.
  *
- * Copyright 2014-2022, John McNamara, jmcnamara@cpan.org. See LICENSE.txt.
+ * SPDX-License-Identifier: BSD-2-Clause
+ * Copyright 2014-2026, John McNamara, jmcnamara@cpan.org.
  *
  */
 
@@ -141,6 +142,11 @@ lxw_worksheet_new(lxw_worksheet_init_data *init_data)
     GOTO_LABEL_ON_MEM_ERROR(worksheet->image_props, mem_error);
     STAILQ_INIT(worksheet->image_props);
 
+    worksheet->embedded_image_props =
+        calloc(1, sizeof(struct lxw_embedded_image_props));
+    GOTO_LABEL_ON_MEM_ERROR(worksheet->embedded_image_props, mem_error);
+    STAILQ_INIT(worksheet->embedded_image_props);
+
     worksheet->chart_data = calloc(1, sizeof(struct lxw_chart_props));
     GOTO_LABEL_ON_MEM_ERROR(worksheet->chart_data, mem_error);
     STAILQ_INIT(worksheet->chart_data);
@@ -288,6 +294,7 @@ lxw_worksheet_new(lxw_worksheet_init_data *init_data)
         worksheet->first_sheet = init_data->first_sheet;
         worksheet->default_url_format = init_data->default_url_format;
         worksheet->max_url_length = init_data->max_url_length;
+        worksheet->use_1904_epoch = init_data->use_1904_epoch;
     }
 
     return worksheet;
@@ -367,7 +374,8 @@ _free_cell(lxw_cell *cell)
         return;
 
     if (cell->type != NUMBER_CELL && cell->type != STRING_CELL
-        && cell->type != BLANK_CELL && cell->type != BOOLEAN_CELL) {
+        && cell->type != BLANK_CELL && cell->type != BOOLEAN_CELL
+        && cell->type != ERROR_CELL) {
 
         free((void *) cell->u.string);
     }
@@ -606,6 +614,17 @@ lxw_worksheet_free(lxw_worksheet *worksheet)
         free(worksheet->image_props);
     }
 
+    if (worksheet->embedded_image_props) {
+        while (!STAILQ_EMPTY(worksheet->embedded_image_props)) {
+            object_props = STAILQ_FIRST(worksheet->embedded_image_props);
+            STAILQ_REMOVE_HEAD(worksheet->embedded_image_props,
+                               list_pointers);
+            _free_object_properties(object_props);
+        }
+
+        free(worksheet->embedded_image_props);
+    }
+
     if (worksheet->chart_data) {
         while (!STAILQ_EMPTY(worksheet->chart_data)) {
             object_props = STAILQ_FIRST(worksheet->chart_data);
@@ -990,6 +1009,25 @@ _new_boolean_cell(lxw_row_t row_num, lxw_col_t col_num, int value,
     return cell;
 }
 
+/*
+ * Create a new worksheet error cell object.
+ */
+STATIC lxw_cell *
+_new_error_cell(lxw_row_t row_num, lxw_col_t col_num, uint32_t value,
+                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 = ERROR_CELL;
+    cell->format = format;
+    cell->u.number = value;
+
+    return cell;
+}
+
 /*
  * Create a new comment cell object.
  */
@@ -1454,13 +1492,13 @@ lxw_basename(const char *path)
 size_t
 _validation_list_length(const char **list)
 {
-    uint8_t i = 0;
+    size_t i = 0;
     size_t length = 0;
 
     if (!list || !list[0])
         return 0;
 
-    while (list[i] && length < LXW_VALIDATION_MAX_STRING_LENGTH) {
+    while (list[i]) {
         /* Include commas in the length. */
         length += 1 + lxw_utf8_strlen(list[i]);
         i++;
@@ -1477,7 +1515,7 @@ _validation_list_length(const char **list)
 char *
 _validation_list_to_csv(const char **list)
 {
-    uint8_t i = 0;
+    size_t i = 0;
     char *str;
 
     /* Create a buffer for the concatenated, and quoted, string. */
@@ -1651,7 +1689,7 @@ _set_default_table_columns(lxw_table_obj *table_obj)
     for (i = 0; i < num_cols; i++) {
         lxw_snprintf(col_name, LXW_ATTR_32, "Column%d", i + 1);
 
-        column = calloc(num_cols, sizeof(lxw_table_column));
+        column = calloc(1, sizeof(lxw_table_column));
         RETURN_ON_MEM_ERROR(column, LXW_ERROR_MEMORY_MALLOC_FAILED);
 
         header = lxw_strdup(col_name);
@@ -1680,9 +1718,11 @@ _expand_table_formula(const char *formula)
 
     ptr = formula;
 
-    while (*ptr++) {
+    while (*ptr) {
         if (*ptr == '@')
             ref_count++;
+
+        ptr++;
     }
 
     if (ref_count == 0) {
@@ -2967,13 +3007,15 @@ _worksheet_position_object_pixels(lxw_worksheet *self,
         height = height + y1;
 
     /* Subtract the underlying cell widths to find the end cell. */
-    while (width >= _worksheet_size_col(self, col_end, anchor)) {
+    while (width >= _worksheet_size_col(self, col_end, anchor)
+           && col_end < LXW_COL_MAX) {
         width -= _worksheet_size_col(self, col_end, anchor);
         col_end++;
     }
 
     /* Subtract the underlying cell heights to find the end cell. */
-    while (height >= _worksheet_size_row(self, row_end, anchor)) {
+    while (height >= _worksheet_size_row(self, row_end, anchor)
+           && row_end < LXW_ROW_MAX) {
         height -= _worksheet_size_row(self, row_end, anchor);
         row_end++;
     }
@@ -4138,11 +4180,13 @@ _process_bmp(lxw_object_properties *image_props)
         height = 0;
 
     /* Ensure that we read some valid data from the file. */
-    if (width == 0)
+    if (width == 0 || height == 0)
         goto file_error;
 
-    height = LXW_UINT32_HOST(height);
-    width = LXW_UINT32_HOST(width);
+    /* The height can be stored as negative for a top-down DIB so we need to
+     * take the absolute value. */
+    height = (uint32_t) abs(LXW_INT32_HOST(height));
+    width = (uint32_t) LXW_INT32_HOST(width);
 
     /* Set the image metadata. */
     image_props->image_type = LXW_IMAGE_BMP;
@@ -4521,6 +4565,15 @@ _write_boolean_cell(lxw_worksheet *self, lxw_cell *cell)
     lxw_xml_data_element(self->file, "v", data, NULL);
 }
 
+/*
+ * Write out a error worksheet cell.
+ */
+STATIC void
+_write_error_cell(lxw_worksheet *self)
+{
+    lxw_xml_data_element(self->file, "v", "#VALUE!", NULL);
+}
+
 /*
  * Calculate the "spans" attribute of the <row> tag. This is an XLSX
  * optimization and isn't strictly required. However, it makes comparing
@@ -4651,6 +4704,13 @@ _write_cell(lxw_worksheet *self, lxw_cell *cell, lxw_format *row_format)
         _write_array_formula_num_cell(self, cell);
         lxw_xml_end_tag(self->file, "c");
     }
+    else if (cell->type == ERROR_CELL) {
+        LXW_PUSH_ATTRIBUTES_STR("t", "e");
+        LXW_PUSH_ATTRIBUTES_DBL("vm", cell->u.number);
+        lxw_xml_start_tag(self->file, "c", &attributes);
+        _write_error_cell(self);
+        lxw_xml_end_tag(self->file, "c");
+    }
 
     LXW_FREE_ATTRIBUTES();
 }
@@ -7492,6 +7552,105 @@ _validate_conditional_cell(lxw_cond_format_obj *cond_format,
     return LXW_NO_ERROR;
 }
 
+/* Check that the correct criteria and used with the correct conditional format. */
+lxw_error
+_validate_conditional_criteria(lxw_cond_format_obj *cond_format)
+{
+    uint8_t criteria_mismatch = LXW_FALSE;
+
+    if (cond_format->type == LXW_CONDITIONAL_TYPE_CELL) {
+        switch (cond_format->criteria) {
+            case LXW_CONDITIONAL_CRITERIA_EQUAL_TO:
+            case LXW_CONDITIONAL_CRITERIA_NOT_EQUAL_TO:
+            case LXW_CONDITIONAL_CRITERIA_GREATER_THAN:
+            case LXW_CONDITIONAL_CRITERIA_LESS_THAN:
+            case LXW_CONDITIONAL_CRITERIA_GREATER_THAN_OR_EQUAL_TO:
+            case LXW_CONDITIONAL_CRITERIA_LESS_THAN_OR_EQUAL_TO:
+            case LXW_CONDITIONAL_CRITERIA_BETWEEN:
+            case LXW_CONDITIONAL_CRITERIA_NOT_BETWEEN:
+                criteria_mismatch = LXW_FALSE;
+                break;
+            default:
+                criteria_mismatch = LXW_TRUE;
+        }
+    }
+    else if (cond_format->type == LXW_CONDITIONAL_TYPE_TIME_PERIOD) {
+        switch (cond_format->criteria) {
+            case LXW_CONDITIONAL_CRITERIA_TIME_PERIOD_YESTERDAY:
+            case LXW_CONDITIONAL_CRITERIA_TIME_PERIOD_TODAY:
+            case LXW_CONDITIONAL_CRITERIA_TIME_PERIOD_TOMORROW:
+            case LXW_CONDITIONAL_CRITERIA_TIME_PERIOD_LAST_7_DAYS:
+            case LXW_CONDITIONAL_CRITERIA_TIME_PERIOD_LAST_WEEK:
+            case LXW_CONDITIONAL_CRITERIA_TIME_PERIOD_THIS_WEEK:
+            case LXW_CONDITIONAL_CRITERIA_TIME_PERIOD_NEXT_WEEK:
+            case LXW_CONDITIONAL_CRITERIA_TIME_PERIOD_LAST_MONTH:
+            case LXW_CONDITIONAL_CRITERIA_TIME_PERIOD_THIS_MONTH:
+            case LXW_CONDITIONAL_CRITERIA_TIME_PERIOD_NEXT_MONTH:
+                criteria_mismatch = LXW_FALSE;
+                break;
+            default:
+                criteria_mismatch = LXW_TRUE;
+        }
+    }
+    else if (cond_format->type == LXW_CONDITIONAL_TYPE_TEXT) {
+        switch (cond_format->criteria) {
+            case LXW_CONDITIONAL_CRITERIA_TEXT_CONTAINING:
+            case LXW_CONDITIONAL_CRITERIA_TEXT_NOT_CONTAINING:
+            case LXW_CONDITIONAL_CRITERIA_TEXT_BEGINS_WITH:
+            case LXW_CONDITIONAL_CRITERIA_TEXT_ENDS_WITH:
+                criteria_mismatch = LXW_FALSE;
+                break;
+            default:
+                criteria_mismatch = LXW_TRUE;
+        }
+    }
+    else if (cond_format->type == LXW_CONDITIONAL_TYPE_AVERAGE) {
+        switch (cond_format->criteria) {
+            case LXW_CONDITIONAL_CRITERIA_AVERAGE_ABOVE:
+            case LXW_CONDITIONAL_CRITERIA_AVERAGE_BELOW:
+            case LXW_CONDITIONAL_CRITERIA_AVERAGE_ABOVE_OR_EQUAL:
+            case LXW_CONDITIONAL_CRITERIA_AVERAGE_BELOW_OR_EQUAL:
+            case LXW_CONDITIONAL_CRITERIA_AVERAGE_1_STD_DEV_ABOVE:
+            case LXW_CONDITIONAL_CRITERIA_AVERAGE_1_STD_DEV_BELOW:
+            case LXW_CONDITIONAL_CRITERIA_AVERAGE_2_STD_DEV_ABOVE:
+            case LXW_CONDITIONAL_CRITERIA_AVERAGE_2_STD_DEV_BELOW:
+            case LXW_CONDITIONAL_CRITERIA_AVERAGE_3_STD_DEV_ABOVE:
+            case LXW_CONDITIONAL_CRITERIA_AVERAGE_3_STD_DEV_BELOW:
+                criteria_mismatch = LXW_FALSE;
+                break;
+            default:
+                criteria_mismatch = LXW_TRUE;
+        }
+    }
+    else if (cond_format->type == LXW_CONDITIONAL_TYPE_TOP
+             || cond_format->type == LXW_CONDITIONAL_TYPE_BOTTOM) {
+        switch (cond_format->criteria) {
+            case LXW_CONDITIONAL_CRITERIA_NONE:
+            case LXW_CONDITIONAL_CRITERIA_TOP_OR_BOTTOM_PERCENT:
+                criteria_mismatch = LXW_FALSE;
+                break;
+            default:
+                criteria_mismatch = LXW_TRUE;
+        }
+    }
+    else {
+        /* Any other conditional type should have a zero criteria. */
+        cond_format->criteria = LXW_CONDITIONAL_CRITERIA_NONE;
+    }
+
+    if (criteria_mismatch) {
+        LXW_WARN_FORMAT2("worksheet_conditional_format_cell()/_range(): "
+                         "LXW_CONDITIONAL_CRITERIA_* = %d is not valid for "
+                         "LXW_CONDITIONAL_TYPE_* = %d", cond_format->criteria,
+                         cond_format->type);
+
+        return LXW_ERROR_PARAMETER_VALIDATION;
+    }
+    else {
+        return LXW_NO_ERROR;
+    }
+}
+
 /*
  * Write the <ignoredErrors> element.
  */
@@ -7844,6 +8003,9 @@ worksheet_write_formula_num(lxw_worksheet *self,
     if (!formula)
         return LXW_ERROR_NULL_PARAMETER_IGNORED;
 
+    if (lxw_str_is_empty(formula))
+        return LXW_ERROR_PARAMETER_IS_EMPTY;
+
     err = _check_dimensions(self, row_num, col_num, LXW_FALSE, LXW_FALSE);
     if (err)
         return err;
@@ -7879,6 +8041,9 @@ worksheet_write_formula_str(lxw_worksheet *self,
     if (!formula)
         return LXW_ERROR_NULL_PARAMETER_IGNORED;
 
+    if (lxw_str_is_empty(formula))
+        return LXW_ERROR_PARAMETER_IS_EMPTY;
+
     err = _check_dimensions(self, row_num, col_num, LXW_FALSE, LXW_FALSE);
     if (err)
         return err;
@@ -7944,6 +8109,9 @@ _store_array_formula(lxw_worksheet *self,
     if (!formula)
         return LXW_ERROR_NULL_PARAMETER_IGNORED;
 
+    if (lxw_str_is_empty(formula))
+        return LXW_ERROR_PARAMETER_IS_EMPTY;
+
     /* Check that row and col are valid and store max and min values. */
     err = _check_dimensions(self, first_row, first_col, LXW_FALSE, LXW_FALSE);
     if (err)
@@ -7964,7 +8132,7 @@ _store_array_formula(lxw_worksheet *self,
 
     /* Copy and trip leading "{=" from formula. */
     if (formula[0] == '{')
-        if (formula[1] == '=')
+        if (strlen(formula) >= 2 && formula[1] == '=')
             formula_copy = lxw_strdup(formula + 2);
         else
             formula_copy = lxw_strdup(formula + 1);
@@ -7972,8 +8140,17 @@ _store_array_formula(lxw_worksheet *self,
         formula_copy = lxw_strdup_formula(formula);
 
     /* Strip trailing "}" from formula. */
-    if (formula_copy[strlen(formula_copy) - 1] == '}')
+    if (strlen(formula_copy) > 0
+        && formula_copy[strlen(formula_copy) - 1] == '}') {
         formula_copy[strlen(formula_copy) - 1] = '\0';
+    }
+
+    /* Check for empty formula that started as {=}. */
+    if (lxw_str_is_empty(formula_copy)) {
+        free(formula_copy);
+        free(range);
+        return LXW_ERROR_PARAMETER_IS_EMPTY;
+    }
 
     /* Create a new array formula cell object. */
     cell = _new_array_formula_cell(first_row, first_col,
@@ -7984,7 +8161,7 @@ _store_array_formula(lxw_worksheet *self,
     _insert_cell(self, first_row, first_col, cell);
 
     if (is_dynamic)
-        self->has_dynamic_arrays = LXW_TRUE;
+        self->has_dynamic_functions = LXW_TRUE;
 
     /* Pad out the rest of the area with formatted zeroes. */
     if (!self->optimize) {
@@ -8159,7 +8336,12 @@ worksheet_write_datetime(lxw_worksheet *self,
     if (err)
         return err;
 
-    excel_date = lxw_datetime_to_excel_date_epoch(datetime, LXW_EPOCH_1900);
+    err = lxw_datetime_validate(datetime);
+    if (err)
+        return err;
+
+    excel_date =
+        lxw_datetime_to_excel_date_with_epoch(datetime, self->use_1904_epoch);
 
     cell = _new_number_cell(row_num, col_num, excel_date, format);
 
@@ -8185,7 +8367,8 @@ worksheet_write_unixtime(lxw_worksheet *self,
     if (err)
         return err;
 
-    excel_date = lxw_unixtime_to_excel_date_epoch(unixtime, LXW_EPOCH_1900);
+    excel_date =
+        lxw_unixtime_to_excel_date_with_epoch(unixtime, self->use_1904_epoch);
 
     cell = _new_number_cell(row_num, col_num, excel_date, format);
 
@@ -8362,9 +8545,13 @@ worksheet_write_url_opt(lxw_worksheet *self,
     else
         format = user_format;
 
-    err = worksheet_write_string(self, row_num, col_num, string_copy, format);
-    if (err)
-        goto mem_error;
+    if (!self->storing_embedded_image) {
+        err =
+            worksheet_write_string(self, row_num, col_num, string_copy,
+                                   format);
+        if (err)
+            goto mem_error;
+    }
 
     /* Reset default error condition. */
     err = LXW_ERROR_MEMORY_MALLOC_FAILED;
@@ -8419,7 +8606,7 @@ worksheet_write_rich_string(lxw_worksheet *self,
     int32_t string_id;
     struct sst_element *sst_element;
     lxw_error err;
-    uint8_t i;
+    size_t i;
     long file_size;
     char *rich_string = NULL;
     const char *string_copy = NULL;
@@ -8570,6 +8757,9 @@ worksheet_write_comment_opt(lxw_worksheet *self,
     if (!text)
         return LXW_ERROR_NULL_PARAMETER_IGNORED;
 
+    if (lxw_str_is_empty(text))
+        return LXW_ERROR_PARAMETER_IS_EMPTY;
+
     if (lxw_utf8_strlen(text) > LXW_STR_MAX)
         return LXW_ERROR_MAX_STRING_LENGTH_EXCEEDED;
 
@@ -9433,7 +9623,7 @@ worksheet_hide(lxw_worksheet *self)
 /*
  * Set which cell or cells are selected in a worksheet.
  */
-void
+lxw_error
 worksheet_set_selection(lxw_worksheet *self,
                         lxw_row_t first_row, lxw_col_t first_col,
                         lxw_row_t last_row, lxw_col_t last_col)
@@ -9441,19 +9631,33 @@ worksheet_set_selection(lxw_worksheet *self,
     lxw_selection *selection;
     lxw_row_t tmp_row;
     lxw_col_t tmp_col;
+    lxw_error err;
     char active_cell[LXW_MAX_CELL_RANGE_LENGTH];
     char sqref[LXW_MAX_CELL_RANGE_LENGTH];
 
     /* Only allow selection to be set once to avoid freeing/re-creating it. */
     if (!STAILQ_EMPTY(self->selections))
-        return;
+        return LXW_ERROR_PARAMETER_VALIDATION;
 
     /* Excel doesn't set a selection for cell A1 since it is the default. */
     if (first_row == 0 && first_col == 0 && last_row == 0 && last_col == 0)
-        return;
+        return LXW_NO_ERROR;
 
     selection = calloc(1, sizeof(lxw_selection));
-    RETURN_VOID_ON_MEM_ERROR(selection);
+    RETURN_ON_MEM_ERROR(selection, LXW_ERROR_MEMORY_MALLOC_FAILED);
+
+    /* Check that row and col are valid without storing. */
+    err = _check_dimensions(self, first_row, first_col, LXW_TRUE, LXW_TRUE);
+    if (err) {
+        free(selection);
+        return err;
+    }
+
+    err = _check_dimensions(self, last_row, last_col, LXW_TRUE, LXW_TRUE);
+    if (err) {
+        free(selection);
+        return err;
+    }
 
     /* Set the cell range selection. Do this before swapping max/min to  */
     /* allow the selection direction to be reversed. */
@@ -9483,6 +9687,8 @@ worksheet_set_selection(lxw_worksheet *self,
     lxw_strcpy(selection->sqref, sqref);
 
     STAILQ_INSERT_TAIL(self->selections, selection, list_pointers);
+
+    return LXW_NO_ERROR;
 }
 
 /*
@@ -9591,6 +9797,12 @@ worksheet_set_page_view(lxw_worksheet *self)
 void
 worksheet_set_paper(lxw_worksheet *self, uint8_t paper_size)
 {
+    if (paper_size > 118) {
+        LXW_WARN_FORMAT1("worksheet_set_paper(): invalid paper size: %d. "
+                         "Valid range is 0-118", paper_size);
+        return;
+    }
+
     self->paper_size = paper_size;
     self->page_setup_changed = LXW_TRUE;
 }
@@ -10094,7 +10306,7 @@ worksheet_print_black_and_white(lxw_worksheet *self)
 lxw_error
 worksheet_set_h_pagebreaks(lxw_worksheet *self, lxw_row_t hbreaks[])
 {
-    uint16_t count = 0;
+    size_t count = 0;
 
     if (hbreaks == NULL)
         return LXW_ERROR_NULL_PARAMETER_IGNORED;
@@ -10121,7 +10333,7 @@ worksheet_set_h_pagebreaks(lxw_worksheet *self, lxw_row_t hbreaks[])
 lxw_error
 worksheet_set_v_pagebreaks(lxw_worksheet *self, lxw_col_t vbreaks[])
 {
-    uint16_t count = 0;
+    size_t count = 0;
 
     if (vbreaks == NULL)
         return LXW_ERROR_NULL_PARAMETER_IGNORED;
@@ -10311,9 +10523,9 @@ worksheet_insert_image_opt(lxw_worksheet *self,
         object_props->y_offset = user_options->y_offset;
         object_props->x_scale = user_options->x_scale;
         object_props->y_scale = user_options->y_scale;
-        object_props->object_position = user_options->object_position;
         object_props->url = lxw_strdup(user_options->url);
         object_props->tip = lxw_strdup(user_options->tip);
+        object_props->object_position = user_options->object_position;
         object_props->decorative = user_options->decorative;
 
         if (user_options->description)
@@ -10467,6 +10679,253 @@ worksheet_insert_image_buffer(lxw_worksheet *self,
                                              image_buffer, image_size, NULL);
 }
 
+/*
+ * Embed an image with options into the worksheet.
+ */
+lxw_error
+worksheet_embed_image_opt(lxw_worksheet *self,
+                          lxw_row_t row_num, lxw_col_t col_num,
+                          const char *filename,
+                          lxw_image_options *user_options)
+{
+    FILE *image_stream;
+    lxw_object_properties *object_props;
+    lxw_error err;
+
+    if (!filename) {
+        LXW_WARN("worksheet_embed_image()/_opt(): "
+                 "filename must be specified.");
+        return LXW_ERROR_NULL_PARAMETER_IGNORED;
+    }
+
+    /* Check that the image file exists and can be opened. */
+    image_stream = lxw_fopen(filename, "rb");
+    if (!image_stream) {
+        LXW_WARN_FORMAT1("worksheet_embed_image()/_opt(): "
+                         "file doesn't exist or can't be opened: %s.",
+                         filename);
+        return LXW_ERROR_PARAMETER_VALIDATION;
+    }
+
+    /* Check and store the cell dimensions. */
+    err = _check_dimensions(self, row_num, col_num, LXW_FALSE, LXW_FALSE);
+    if (err) {
+        fclose(image_stream);
+        return err;
+    }
+
+    /* Create a new object to hold the image properties. */
+    object_props = calloc(1, sizeof(lxw_object_properties));
+    if (!object_props) {
+        fclose(image_stream);
+        return LXW_ERROR_MEMORY_MALLOC_FAILED;
+    }
+
+    /* We only copy/use a limited number of options for embedded images. */
+    if (user_options) {
+        if (user_options->cell_format)
+            object_props->format = user_options->cell_format;
+
+        /* The url for embedded images is written as a cell url. */
+        if (user_options->url) {
+            if (!user_options->cell_format)
+                object_props->format = self->default_url_format;
+
+            self->storing_embedded_image = LXW_TRUE;
+            err = worksheet_write_url(self,
+                                      row_num,
+                                      col_num,
+                                      user_options->url,
+                                      object_props->format);
+            if (err) {
+                _free_object_properties(object_props);
+                fclose(image_stream);
+                return err;
+            }
+
+            self->storing_embedded_image = LXW_FALSE;
+        }
+
+        object_props->decorative = user_options->decorative;
+        if (user_options->description)
+            object_props->description = lxw_strdup(user_options->description);
+    }
+
+    /* Copy other options or set defaults. */
+    object_props->filename = lxw_strdup(filename);
+    object_props->stream = image_stream;
+    object_props->row = row_num;
+    object_props->col = col_num;
+
+    if (object_props->x_scale == 0.0)
+        object_props->x_scale = 1;
+
+    if (object_props->y_scale == 0.0)
+        object_props->y_scale = 1;
+
+    if (_get_image_properties(object_props) == LXW_NO_ERROR) {
+        STAILQ_INSERT_TAIL(self->embedded_image_props, object_props,
+                           list_pointers);
+        fclose(image_stream);
+
+        return LXW_NO_ERROR;
+    }
+    else {
+        _free_object_properties(object_props);
+        fclose(image_stream);
+        return LXW_ERROR_IMAGE_DIMENSIONS;
+    }
+}
+
+/*
+ * Embed an image into the worksheet.
+ */
+lxw_error
+worksheet_embed_image(lxw_worksheet *self,
+                      lxw_row_t row_num, lxw_col_t col_num,
+                      const char *filename)
+{
+    return worksheet_embed_image_opt(self, row_num, col_num, filename, NULL);
+}
+
+/*
+ * Embed an image buffer, with options, into the worksheet.
+ */
+lxw_error
+worksheet_embed_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_object_properties *object_props;
+    lxw_error err;
+
+    if (!image_size) {
+        LXW_WARN("worksheet_embed_image_buffer()/_opt(): "
+                 "size must be non-zero.");
+        return LXW_ERROR_NULL_PARAMETER_IGNORED;
+    }
+
+    /* Write the image buffer to a file (preferably in memory) so we can read
+     * the dimensions like an ordinary file. For embedded images we really only
+     * need the image type. */
+#ifdef USE_FMEMOPEN
+    image_stream = fmemopen((void *) image_buffer, image_size, "rb");
+
+    if (!image_stream)
+        return LXW_ERROR_CREATING_TMPFILE;
+#else
+    image_stream = lxw_tmpfile(self->tmpdir);
+
+    if (!image_stream)
+        return LXW_ERROR_CREATING_TMPFILE;
+
+    if (fwrite(image_buffer, 1, image_size, image_stream) != image_size) {
+        fclose(image_stream);
+        return LXW_ERROR_CREATING_TMPFILE;
+    }
+
+    rewind(image_stream);
+#endif
+
+    /* Check and store the cell dimensions. */
+    err = _check_dimensions(self, row_num, col_num, LXW_FALSE, LXW_FALSE);
+    if (err)
+        return err;
+
+    /* Create a new object to hold the image properties. */
+    object_props = calloc(1, sizeof(lxw_object_properties));
+    if (!object_props) {
+        fclose(image_stream);
+        return LXW_ERROR_MEMORY_MALLOC_FAILED;
+    }
+
+    /* Store the image data in the properties structure. */
+    object_props->image_buffer = calloc(1, image_size);
+    if (!object_props->image_buffer) {
+        _free_object_properties(object_props);
+        fclose(image_stream);
+        return LXW_ERROR_MEMORY_MALLOC_FAILED;
+    }
+    else {
+        memcpy(object_props->image_buffer, image_buffer, image_size);
+        object_props->image_buffer_size = image_size;
+        object_props->is_image_buffer = LXW_TRUE;
+    }
+
+    /* We only copy/use a limited number of options for embedded images. */
+    if (user_options) {
+        if (user_options->cell_format)
+            object_props->format = user_options->cell_format;
+
+        /* The url for embedded images is written as a cell url. */
+        if (user_options->url) {
+            if (!user_options->cell_format)
+                object_props->format = self->default_url_format;
+
+            self->storing_embedded_image = LXW_TRUE;
+            err = worksheet_write_url(self,
+                                      row_num,
+                                      col_num,
+                                      user_options->url,
+                                      object_props->format);
+            if (err) {
+                _free_object_properties(object_props);
+                fclose(image_stream);
+                return err;
+            }
+
+            self->storing_embedded_image = LXW_FALSE;
+        }
+
+        object_props->decorative = user_options->decorative;
+        if (user_options->description)
+            object_props->description = lxw_strdup(user_options->description);
+    }
+
+    /* Copy other options or set defaults. */
+    object_props->filename = lxw_strdup("image_buffer");
+    object_props->stream = image_stream;
+    object_props->row = row_num;
+    object_props->col = col_num;
+
+    if (object_props->x_scale == 0.0)
+        object_props->x_scale = 1;
+
+    if (object_props->y_scale == 0.0)
+        object_props->y_scale = 1;
+
+    if (_get_image_properties(object_props) == LXW_NO_ERROR) {
+        STAILQ_INSERT_TAIL(self->embedded_image_props, object_props,
+                           list_pointers);
+        fclose(image_stream);
+
+        return LXW_NO_ERROR;
+    }
+    else {
+        _free_object_properties(object_props);
+        fclose(image_stream);
+        return LXW_ERROR_IMAGE_DIMENSIONS;
+    }
+}
+
+/*
+ * Insert an image buffer into the worksheet.
+ */
+lxw_error
+worksheet_embed_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_embed_image_buffer_opt(self, row_num, col_num,
+                                            image_buffer, image_size, NULL);
+}
+
 /*
  * Set an image as a worksheet background.
  */
@@ -10921,16 +11380,16 @@ worksheet_data_validation_range(lxw_worksheet *self, lxw_row_t first_row,
         || validation->validate == LXW_VALIDATION_TYPE_TIME) {
         if (is_between) {
             copy->value_number =
-                lxw_datetime_to_excel_date_epoch
-                (&validation->minimum_datetime, LXW_EPOCH_1900);
+                lxw_datetime_to_excel_date_with_epoch
+                (&validation->minimum_datetime, self->use_1904_epoch);
             copy->maximum_number =
-                lxw_datetime_to_excel_date_epoch
-                (&validation->maximum_datetime, LXW_EPOCH_1900);
+                lxw_datetime_to_excel_date_with_epoch
+                (&validation->maximum_datetime, self->use_1904_epoch);
         }
         else {
             copy->value_number =
-                lxw_datetime_to_excel_date_epoch(&validation->value_datetime,
-                                                 LXW_EPOCH_1900);
+                lxw_datetime_to_excel_date_with_epoch
+                (&validation->value_datetime, self->use_1904_epoch);
         }
     }
 
@@ -11064,6 +11523,11 @@ worksheet_conditional_format_range(lxw_worksheet *self, lxw_row_t first_row,
     cond_format->stop_if_true = user_options->stop_if_true;
     cond_format->type_string = lxw_strdup(type_strings[cond_format->type]);
 
+    /* Check that the criteria matches the conditional type. */
+    err = _validate_conditional_criteria(cond_format);
+    if (err)
+        goto error;
+
     /* Validate the user input for various types of rules. */
     if (user_options->type == LXW_CONDITIONAL_TYPE_CELL
         || cond_format->type == LXW_CONDITIONAL_TYPE_DUPLICATE
@@ -11292,3 +11756,19 @@ worksheet_ignore_errors(lxw_worksheet *self, uint8_t type, const char *range)
 
     return LXW_NO_ERROR;
 }
+
+/*
+ * Write an error cell for versions of Excel that don't support embedded images.
+ */
+void
+worksheet_set_error_cell(lxw_worksheet *self,
+                         lxw_object_properties *object_props, uint32_t ref_id)
+{
+    lxw_row_t row_num = object_props->row;
+    lxw_col_t col_num = object_props->col;
+
+    lxw_cell *cell =
+        _new_error_cell(row_num, col_num, ref_id, object_props->format);
+    _insert_cell(self, row_num, col_num, cell);
+
+}