write.c 26 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765
  1. /*
  2. +----------------------------------------------------------------------+
  3. | XlsWriter Extension |
  4. +----------------------------------------------------------------------+
  5. | Copyright (c) 2017-2018 The Viest |
  6. +----------------------------------------------------------------------+
  7. | http://www.viest.me |
  8. +----------------------------------------------------------------------+
  9. | Author: viest <[email protected]> |
  10. +----------------------------------------------------------------------+
  11. */
  12. #include "include.h"
  13. /*
  14. * According to the zval type written to the file
  15. */
  16. void type_writer(zval *value, zend_long row, zend_long columns, xls_resource_t *res, zend_string *format)
  17. {
  18. lxw_format *value_format = NULL;
  19. switch (Z_TYPE_P(value)) {
  20. case IS_STRING:
  21. worksheet_write_string(res->worksheet, row, columns, ZSTR_VAL(zval_get_string(value)), NULL);
  22. break;
  23. case IS_LONG:
  24. if(format) {
  25. value_format = workbook_add_format(res->workbook);
  26. format_set_num_format(value_format, ZSTR_VAL(format));
  27. worksheet_write_number(res->worksheet, row, columns, zval_get_long(value), value_format);
  28. } else {
  29. worksheet_write_number(res->worksheet, row, columns, zval_get_long(value), NULL);
  30. }
  31. break;
  32. case IS_DOUBLE:
  33. if(format) {
  34. value_format = workbook_add_format(res->workbook);
  35. format_set_num_format(value_format, ZSTR_VAL(format));
  36. worksheet_write_number(res->worksheet, row, columns, zval_get_double(value), value_format);
  37. } else {
  38. worksheet_write_number(res->worksheet, row, columns, zval_get_double(value), NULL);
  39. }
  40. break;
  41. }
  42. }
  43. /*
  44. * Write the image to the file
  45. */
  46. void image_writer(zval *value, zend_long row, zend_long columns, double width, double height, xls_resource_t *res)
  47. {
  48. lxw_image_options options = {.x_scale = width, .y_scale = height};
  49. worksheet_insert_image_opt(res->worksheet, row, columns, ZSTR_VAL(zval_get_string(value)), &options);
  50. }
  51. /*
  52. * Write the image to the file
  53. */
  54. void formula_writer(zval *value, zend_long row, zend_long columns, xls_resource_t *res)
  55. {
  56. worksheet_write_formula(res->worksheet, row, columns, ZSTR_VAL(zval_get_string(value)), NULL);
  57. }
  58. /*
  59. * Add the autofilter.
  60. */
  61. void auto_filter(zend_string *range, xls_resource_t *res)
  62. {
  63. worksheet_autofilter(res->worksheet, RANGE(ZSTR_VAL(range)));
  64. }
  65. /*
  66. * Merge cells.
  67. */
  68. void merge_cells(zend_string *range, zend_string *value, xls_resource_t *res)
  69. {
  70. worksheet_merge_range(res->worksheet, RANGE(ZSTR_VAL(range)), ZSTR_VAL(value), NULL);
  71. }
  72. /*
  73. * Set column format
  74. */
  75. void set_column(zend_string *range, double width, xls_resource_t *res, lxw_format *format)
  76. {
  77. worksheet_set_column(res->worksheet, COLS(ZSTR_VAL(range)), width, format);
  78. }
  79. /*
  80. * Set row format
  81. */
  82. void set_row(zend_string *range, double height, xls_resource_t *res, lxw_format *format)
  83. {
  84. char *rows = ZSTR_VAL(range);
  85. if (strchr(rows, ':')) {
  86. worksheet_set_rows(ROWS(rows), height, res, format);
  87. } else {
  88. worksheet_set_row(res->worksheet, ROW(rows), height, format);
  89. }
  90. }
  91. /*
  92. * Set rows format
  93. */
  94. void worksheet_set_rows(lxw_row_t start, lxw_row_t end, double height, xls_resource_t *res, lxw_format *format)
  95. {
  96. while (1) {
  97. worksheet_set_row(res->worksheet, end, height, format);
  98. if (end == start)
  99. break;
  100. end--;
  101. }
  102. }
  103. /*
  104. * Call finalization code and close file.
  105. */
  106. lxw_error
  107. workbook_file(xls_resource_t *self)
  108. {
  109. lxw_worksheet *worksheet = NULL;
  110. lxw_packager *packager = NULL;
  111. lxw_error error = LXW_NO_ERROR;
  112. /* Add a default worksheet if non have been added. */
  113. if (!self->workbook->num_sheets)
  114. workbook_add_worksheet(self->workbook, NULL);
  115. /* Ensure that at least one worksheet has been selected. */
  116. if (self->workbook->active_sheet == 0) {
  117. worksheet = STAILQ_FIRST(self->workbook->worksheets);
  118. worksheet->selected = 1;
  119. worksheet->hidden = 0;
  120. }
  121. /* Set the active sheet. */
  122. STAILQ_FOREACH(worksheet, self->workbook->worksheets, list_pointers) {
  123. if (worksheet->index == self->workbook->active_sheet)
  124. worksheet->active = 1;
  125. }
  126. /* Set the defined names for the worksheets such as Print Titles. */
  127. _prepare_defined_names(self->workbook);
  128. /* Prepare the drawings, charts and images. */
  129. _prepare_drawings(self->workbook);
  130. /* Add cached data to charts. */
  131. _add_chart_cache_data(self->workbook);
  132. /* Create a packager object to assemble sub-elements into a zip file. */
  133. packager = lxw_packager_new(self->workbook->filename, self->workbook->options.tmpdir);
  134. /* If the packager fails it is generally due to a zip permission error. */
  135. if (packager == NULL) {
  136. fprintf(stderr, "[ERROR] workbook_close(): "
  137. "Error creating '%s'. "
  138. "Error = %s\n", self->workbook->filename, strerror(errno));
  139. error = LXW_ERROR_CREATING_XLSX_FILE;
  140. goto mem_error;
  141. }
  142. /* Set the workbook object in the packager. */
  143. packager->workbook = self->workbook;
  144. /* Assemble all the sub-files in the xlsx package. */
  145. error = lxw_create_package(packager);
  146. /* Error and non-error conditions fall through to the cleanup code. */
  147. if (error == LXW_ERROR_CREATING_TMPFILE) {
  148. fprintf(stderr, "[ERROR] workbook_close(): "
  149. "Error creating tmpfile(s) to assemble '%s'. "
  150. "Error = %s\n", self->workbook->filename, strerror(errno));
  151. }
  152. /* If LXW_ERROR_ZIP_FILE_OPERATION then errno is set by zlib. */
  153. if (error == LXW_ERROR_ZIP_FILE_OPERATION) {
  154. fprintf(stderr, "[ERROR] workbook_close(): "
  155. "Zlib error while creating xlsx file '%s'. "
  156. "Error = %s\n", self->workbook->filename, strerror(errno));
  157. }
  158. /* The next 2 error conditions don't set errno. */
  159. if (error == LXW_ERROR_ZIP_FILE_ADD) {
  160. fprintf(stderr, "[ERROR] workbook_close(): "
  161. "Zlib error adding file to xlsx file '%s'.\n",
  162. self->workbook->filename);
  163. }
  164. if (error == LXW_ERROR_ZIP_CLOSE) {
  165. fprintf(stderr, "[ERROR] workbook_close(): "
  166. "Zlib error closing xlsx file '%s'.\n", self->workbook->filename);
  167. }
  168. mem_error:
  169. lxw_packager_free(packager);
  170. return error;
  171. }
  172. void _php_vtiful_xls_close(zend_resource *rsrc TSRMLS_DC)
  173. {
  174. }
  175. /*
  176. * Iterate through the worksheets and store any defined names used for print
  177. * ranges or repeat rows/columns.
  178. */
  179. STATIC void
  180. _prepare_defined_names(lxw_workbook *self)
  181. {
  182. lxw_worksheet *worksheet;
  183. char app_name[LXW_DEFINED_NAME_LENGTH];
  184. char range[LXW_DEFINED_NAME_LENGTH];
  185. char area[LXW_MAX_CELL_RANGE_LENGTH];
  186. char first_col[8];
  187. char last_col[8];
  188. STAILQ_FOREACH(worksheet, self->worksheets, list_pointers) {
  189. /*
  190. * Check for autofilter settings and store them.
  191. */
  192. if (worksheet->autofilter.in_use) {
  193. lxw_snprintf(app_name, LXW_DEFINED_NAME_LENGTH,
  194. "%s!_FilterDatabase", worksheet->quoted_name);
  195. lxw_rowcol_to_range_abs(area,
  196. worksheet->autofilter.first_row,
  197. worksheet->autofilter.first_col,
  198. worksheet->autofilter.last_row,
  199. worksheet->autofilter.last_col);
  200. lxw_snprintf(range, LXW_DEFINED_NAME_LENGTH, "%s!%s",
  201. worksheet->quoted_name, area);
  202. /* Autofilters are the only defined name to set the hidden flag. */
  203. _store_defined_name(self, "_xlnm._FilterDatabase", app_name, range, worksheet->index, LXW_TRUE);
  204. }
  205. /*
  206. * Check for Print Area settings and store them.
  207. */
  208. if (worksheet->print_area.in_use) {
  209. lxw_snprintf(app_name, LXW_DEFINED_NAME_LENGTH,
  210. "%s!Print_Area", worksheet->quoted_name);
  211. /* Check for print area that is the max row range. */
  212. if (worksheet->print_area.first_row == 0
  213. && worksheet->print_area.last_row == LXW_ROW_MAX - 1) {
  214. lxw_col_to_name(first_col,
  215. worksheet->print_area.first_col, LXW_FALSE);
  216. lxw_col_to_name(last_col,
  217. worksheet->print_area.last_col, LXW_FALSE);
  218. lxw_snprintf(area, LXW_MAX_CELL_RANGE_LENGTH - 1, "$%s:$%s",
  219. first_col, last_col);
  220. }
  221. /* Check for print area that is the max column range. */
  222. else if (worksheet->print_area.first_col == 0
  223. && worksheet->print_area.last_col == LXW_COL_MAX - 1) {
  224. lxw_snprintf(area, LXW_MAX_CELL_RANGE_LENGTH - 1, "$%d:$%d",
  225. worksheet->print_area.first_row + 1,
  226. worksheet->print_area.last_row + 1);
  227. }
  228. else {
  229. lxw_rowcol_to_range_abs(area,
  230. worksheet->print_area.first_row,
  231. worksheet->print_area.first_col,
  232. worksheet->print_area.last_row,
  233. worksheet->print_area.last_col);
  234. }
  235. lxw_snprintf(range, LXW_DEFINED_NAME_LENGTH, "%s!%s",
  236. worksheet->quoted_name, area);
  237. _store_defined_name(self, "_xlnm.Print_Area", app_name,
  238. range, worksheet->index, LXW_FALSE);
  239. }
  240. /*
  241. * Check for repeat rows/cols. aka, Print Titles and store them.
  242. */
  243. if (worksheet->repeat_rows.in_use || worksheet->repeat_cols.in_use) {
  244. if (worksheet->repeat_rows.in_use
  245. && worksheet->repeat_cols.in_use) {
  246. lxw_snprintf(app_name, LXW_DEFINED_NAME_LENGTH,
  247. "%s!Print_Titles", worksheet->quoted_name);
  248. lxw_col_to_name(first_col,
  249. worksheet->repeat_cols.first_col, LXW_FALSE);
  250. lxw_col_to_name(last_col,
  251. worksheet->repeat_cols.last_col, LXW_FALSE);
  252. lxw_snprintf(range, LXW_DEFINED_NAME_LENGTH,
  253. "%s!$%s:$%s,%s!$%d:$%d",
  254. worksheet->quoted_name, first_col,
  255. last_col, worksheet->quoted_name,
  256. worksheet->repeat_rows.first_row + 1,
  257. worksheet->repeat_rows.last_row + 1);
  258. _store_defined_name(self, "_xlnm.Print_Titles", app_name,
  259. range, worksheet->index, LXW_FALSE);
  260. }
  261. else if (worksheet->repeat_rows.in_use) {
  262. lxw_snprintf(app_name, LXW_DEFINED_NAME_LENGTH,
  263. "%s!Print_Titles", worksheet->quoted_name);
  264. lxw_snprintf(range, LXW_DEFINED_NAME_LENGTH,
  265. "%s!$%d:$%d", worksheet->quoted_name,
  266. worksheet->repeat_rows.first_row + 1,
  267. worksheet->repeat_rows.last_row + 1);
  268. _store_defined_name(self, "_xlnm.Print_Titles", app_name,
  269. range, worksheet->index, LXW_FALSE);
  270. }
  271. else if (worksheet->repeat_cols.in_use) {
  272. lxw_snprintf(app_name, LXW_DEFINED_NAME_LENGTH,
  273. "%s!Print_Titles", worksheet->quoted_name);
  274. lxw_col_to_name(first_col,
  275. worksheet->repeat_cols.first_col, LXW_FALSE);
  276. lxw_col_to_name(last_col,
  277. worksheet->repeat_cols.last_col, LXW_FALSE);
  278. lxw_snprintf(range, LXW_DEFINED_NAME_LENGTH,
  279. "%s!$%s:$%s", worksheet->quoted_name,
  280. first_col, last_col);
  281. _store_defined_name(self, "_xlnm.Print_Titles", app_name,
  282. range, worksheet->index, LXW_FALSE);
  283. }
  284. }
  285. }
  286. }
  287. /*
  288. * Iterate through the worksheets and set up any chart or image drawings.
  289. */
  290. STATIC void
  291. _prepare_drawings(lxw_workbook *self)
  292. {
  293. lxw_worksheet *worksheet;
  294. lxw_image_options *image_options;
  295. uint16_t chart_ref_id = 0;
  296. uint16_t image_ref_id = 0;
  297. uint16_t drawing_id = 0;
  298. STAILQ_FOREACH(worksheet, self->worksheets, list_pointers) {
  299. if (STAILQ_EMPTY(worksheet->image_data)
  300. && STAILQ_EMPTY(worksheet->chart_data))
  301. continue;
  302. drawing_id++;
  303. STAILQ_FOREACH(image_options, worksheet->chart_data, list_pointers) {
  304. chart_ref_id++;
  305. #ifdef HAVE_LXW_CHARTSHEET_NEW
  306. lxw_worksheet_prepare_chart(worksheet, chart_ref_id, drawing_id,
  307. image_options, 0);
  308. #else
  309. lxw_worksheet_prepare_chart(worksheet, chart_ref_id, drawing_id,
  310. image_options);
  311. #endif
  312. if (image_options->chart)
  313. STAILQ_INSERT_TAIL(self->ordered_charts, image_options->chart,
  314. ordered_list_pointers);
  315. }
  316. STAILQ_FOREACH(image_options, worksheet->image_data, list_pointers) {
  317. if (image_options->image_type == LXW_IMAGE_PNG)
  318. self->has_png = LXW_TRUE;
  319. if (image_options->image_type == LXW_IMAGE_JPEG)
  320. self->has_jpeg = LXW_TRUE;
  321. if (image_options->image_type == LXW_IMAGE_BMP)
  322. self->has_bmp = LXW_TRUE;
  323. image_ref_id++;
  324. lxw_worksheet_prepare_image(worksheet, image_ref_id, drawing_id,
  325. image_options);
  326. }
  327. }
  328. self->drawing_count = drawing_id;
  329. }
  330. /*
  331. * Add "cached" data to charts to provide the numCache and strCache data for
  332. * series and title/axis ranges.
  333. */
  334. STATIC void
  335. _add_chart_cache_data(lxw_workbook *self)
  336. {
  337. lxw_chart *chart;
  338. lxw_chart_series *series;
  339. STAILQ_FOREACH(chart, self->ordered_charts, ordered_list_pointers) {
  340. _populate_range(self, chart->title.range);
  341. _populate_range(self, chart->x_axis->title.range);
  342. _populate_range(self, chart->y_axis->title.range);
  343. if (STAILQ_EMPTY(chart->series_list))
  344. continue;
  345. STAILQ_FOREACH(series, chart->series_list, list_pointers) {
  346. _populate_range(self, series->categories);
  347. _populate_range(self, series->values);
  348. _populate_range(self, series->title.range);
  349. }
  350. }
  351. }
  352. /*
  353. * Process and store the defined names. The defined names are stored with
  354. * the Workbook.xml but also with the App.xml if they refer to a sheet
  355. * range like "Sheet1!:A1". The defined names are store in sorted
  356. * order for consistency with Excel. The names need to be normalized before
  357. * sorting.
  358. */
  359. STATIC lxw_error
  360. _store_defined_name(lxw_workbook *self, const char *name, const char *app_name, const char *formula, int16_t index, uint8_t hidden)
  361. {
  362. lxw_worksheet *worksheet;
  363. lxw_defined_name *defined_name;
  364. lxw_defined_name *list_defined_name;
  365. char name_copy[LXW_DEFINED_NAME_LENGTH];
  366. char *tmp_str;
  367. char *worksheet_name;
  368. /* Do some checks on the input data */
  369. if (!name || !formula)
  370. return LXW_ERROR_NULL_PARAMETER_IGNORED;
  371. if (lxw_utf8_strlen(name) > LXW_DEFINED_NAME_LENGTH ||
  372. lxw_utf8_strlen(formula) > LXW_DEFINED_NAME_LENGTH) {
  373. return LXW_ERROR_128_STRING_LENGTH_EXCEEDED;
  374. }
  375. /* Allocate a new defined_name to be added to the linked list of names. */
  376. defined_name = calloc(1, sizeof(struct lxw_defined_name));
  377. RETURN_ON_MEM_ERROR(defined_name, LXW_ERROR_MEMORY_MALLOC_FAILED);
  378. /* Copy the user input string. */
  379. lxw_strcpy(name_copy, name);
  380. /* Set the worksheet index or -1 for a global defined name. */
  381. defined_name->index = index;
  382. defined_name->hidden = hidden;
  383. /* Check for local defined names like like "Sheet1!name". */
  384. tmp_str = strchr(name_copy, '!');
  385. if (tmp_str == NULL) {
  386. /* The name is global. We just store the defined name string. */
  387. lxw_strcpy(defined_name->name, name_copy);
  388. }
  389. else {
  390. /* The name is worksheet local. We need to extract the sheet name
  391. * and map it to a sheet index. */
  392. /* Split the into the worksheet name and defined name. */
  393. *tmp_str = '\0';
  394. tmp_str++;
  395. worksheet_name = name_copy;
  396. /* Remove any worksheet quoting. */
  397. if (worksheet_name[0] == '\'')
  398. worksheet_name++;
  399. if (worksheet_name[strlen(worksheet_name) - 1] == '\'')
  400. worksheet_name[strlen(worksheet_name) - 1] = '\0';
  401. /* Search for worksheet name to get the equivalent worksheet index. */
  402. STAILQ_FOREACH(worksheet, self->worksheets, list_pointers) {
  403. if (strcmp(worksheet_name, worksheet->name) == 0) {
  404. defined_name->index = worksheet->index;
  405. lxw_strcpy(defined_name->normalised_sheetname,
  406. worksheet_name);
  407. }
  408. }
  409. /* If we didn't find the worksheet name we exit. */
  410. if (defined_name->index == -1)
  411. goto mem_error;
  412. lxw_strcpy(defined_name->name, tmp_str);
  413. }
  414. /* Print titles and repeat title pass in the name used for App.xml. */
  415. if (app_name) {
  416. lxw_strcpy(defined_name->app_name, app_name);
  417. lxw_strcpy(defined_name->normalised_sheetname, app_name);
  418. }
  419. else {
  420. lxw_strcpy(defined_name->app_name, name);
  421. }
  422. /* We need to normalize the defined names for sorting. This involves
  423. * removing any _xlnm namespace and converting it to lowercase. */
  424. tmp_str = strstr(name_copy, "_xlnm.");
  425. if (tmp_str)
  426. lxw_strcpy(defined_name->normalised_name, defined_name->name + 6);
  427. else
  428. lxw_strcpy(defined_name->normalised_name, defined_name->name);
  429. lxw_str_tolower(defined_name->normalised_name);
  430. lxw_str_tolower(defined_name->normalised_sheetname);
  431. /* Strip leading "=" from the formula. */
  432. if (formula[0] == '=')
  433. lxw_strcpy(defined_name->formula, formula + 1);
  434. else
  435. lxw_strcpy(defined_name->formula, formula);
  436. /* We add the defined name to the list in sorted order. */
  437. list_defined_name = TAILQ_FIRST(self->defined_names);
  438. if (list_defined_name == NULL ||
  439. _compare_defined_names(defined_name, list_defined_name) < 1) {
  440. /* List is empty or defined name goes to the head. */
  441. TAILQ_INSERT_HEAD(self->defined_names, defined_name, list_pointers);
  442. return LXW_NO_ERROR;
  443. }
  444. TAILQ_FOREACH(list_defined_name, self->defined_names, list_pointers) {
  445. int res = _compare_defined_names(defined_name, list_defined_name);
  446. /* The entry already exists. We exit and don't overwrite. */
  447. if (res == 0)
  448. goto mem_error;
  449. /* New defined name is inserted in sorted order before other entries. */
  450. if (res < 0) {
  451. TAILQ_INSERT_BEFORE(list_defined_name, defined_name,
  452. list_pointers);
  453. return LXW_NO_ERROR;
  454. }
  455. }
  456. /* If the entry wasn't less than any of the entries in the list we add it
  457. * to the end. */
  458. TAILQ_INSERT_TAIL(self->defined_names, defined_name, list_pointers);
  459. return LXW_NO_ERROR;
  460. mem_error:
  461. free(defined_name);
  462. return LXW_ERROR_MEMORY_MALLOC_FAILED;
  463. }
  464. /*
  465. * Compare two defined_name structures.
  466. */
  467. static int
  468. _compare_defined_names(lxw_defined_name *a, lxw_defined_name *b)
  469. {
  470. int res = strcmp(a->normalised_name, b->normalised_name);
  471. /* Primary comparison based on defined name. */
  472. if (res)
  473. return res;
  474. /* Secondary comparison based on worksheet name. */
  475. res = strcmp(a->normalised_sheetname, b->normalised_sheetname);
  476. return res;
  477. }
  478. /* Convert a chart range such as Sheet1!$A$1:$A$5 to a sheet name and row-col
  479. * dimensions, or vice-versa. This gives us the dimensions to read data back
  480. * from the worksheet.
  481. */
  482. STATIC void
  483. _populate_range_dimensions(lxw_workbook *self, lxw_series_range *range)
  484. {
  485. char formula[LXW_MAX_FORMULA_RANGE_LENGTH] = { 0 };
  486. char *tmp_str;
  487. char *sheetname;
  488. /* If neither the range formula or sheetname is defined then this probably
  489. * isn't a valid range.
  490. */
  491. if (!range->formula && !range->sheetname) {
  492. range->ignore_cache = LXW_TRUE;
  493. return;
  494. }
  495. /* If the sheetname is already defined it was already set via
  496. * chart_series_set_categories() or chart_series_set_values().
  497. */
  498. if (range->sheetname)
  499. return;
  500. /* Ignore non-contiguous range like (Sheet1!$A$1:$A$2,Sheet1!$A$4:$A$5) */
  501. if (range->formula[0] == '(') {
  502. range->ignore_cache = LXW_TRUE;
  503. return;
  504. }
  505. /* Create a copy of the formula to modify and parse into parts. */
  506. lxw_snprintf(formula, LXW_MAX_FORMULA_RANGE_LENGTH, "%s", range->formula);
  507. /* Check for valid formula. TODO. This needs stronger validation. */
  508. tmp_str = strchr(formula, '!');
  509. if (tmp_str == NULL) {
  510. range->ignore_cache = LXW_TRUE;
  511. return;
  512. }
  513. else {
  514. /* Split the formulas into sheetname and row-col data. */
  515. *tmp_str = '\0';
  516. tmp_str++;
  517. sheetname = formula;
  518. /* Remove any worksheet quoting. */
  519. if (sheetname[0] == '\'')
  520. sheetname++;
  521. if (sheetname[strlen(sheetname) - 1] == '\'')
  522. sheetname[strlen(sheetname) - 1] = '\0';
  523. /* Check that the sheetname exists. */
  524. if (!workbook_get_worksheet_by_name(self, sheetname)) {
  525. LXW_WARN_FORMAT2("workbook_add_chart(): worksheet name '%s' "
  526. "in chart formula '%s' doesn't exist.",
  527. sheetname, range->formula);
  528. range->ignore_cache = LXW_TRUE;
  529. return;
  530. }
  531. range->sheetname = lxw_strdup(sheetname);
  532. range->first_row = lxw_name_to_row(tmp_str);
  533. range->first_col = lxw_name_to_col(tmp_str);
  534. if (strchr(tmp_str, ':')) {
  535. /* 2D range. */
  536. range->last_row = lxw_name_to_row_2(tmp_str);
  537. range->last_col = lxw_name_to_col_2(tmp_str);
  538. }
  539. else {
  540. /* 1D range. */
  541. range->last_row = range->first_row;
  542. range->last_col = range->first_col;
  543. }
  544. }
  545. }
  546. /*
  547. * Populate the data cache of a chart data series by reading the data from the
  548. * relevant worksheet and adding it to the cached in the range object as a
  549. * list of points.
  550. *
  551. * Note, the data cache isn't strictly required by Excel but it helps if the
  552. * chart is embedded in another application such as PowerPoint and it also
  553. * helps with comparison testing.
  554. */
  555. STATIC void
  556. _populate_range_data_cache(lxw_workbook *self, lxw_series_range *range)
  557. {
  558. lxw_worksheet *worksheet;
  559. lxw_row_t row_num;
  560. lxw_col_t col_num;
  561. lxw_row *row_obj;
  562. lxw_cell *cell_obj;
  563. struct lxw_series_data_point *data_point;
  564. uint16_t num_data_points = 0;
  565. /* If ignore_cache is set then don't try to populate the cache. This flag
  566. * may be set manually, for testing, or due to a case where the cache
  567. * can't be calculated.
  568. */
  569. if (range->ignore_cache)
  570. return;
  571. /* Currently we only handle 2D ranges so ensure either the rows or cols
  572. * are the same.
  573. */
  574. if (range->first_row != range->last_row
  575. && range->first_col != range->last_col) {
  576. range->ignore_cache = LXW_TRUE;
  577. return;
  578. }
  579. /* Check that the sheetname exists. */
  580. worksheet = workbook_get_worksheet_by_name(self, range->sheetname);
  581. if (!worksheet) {
  582. LXW_WARN_FORMAT2("workbook_add_chart(): worksheet name '%s' "
  583. "in chart formula '%s' doesn't exist.",
  584. range->sheetname, range->formula);
  585. range->ignore_cache = LXW_TRUE;
  586. return;
  587. }
  588. /* We can't read the data when worksheet optimization is on. */
  589. if (worksheet->optimize) {
  590. range->ignore_cache = LXW_TRUE;
  591. return;
  592. }
  593. /* Iterate through the worksheet data and populate the range cache. */
  594. for (row_num = range->first_row; row_num <= range->last_row; row_num++) {
  595. row_obj = lxw_worksheet_find_row(worksheet, row_num);
  596. for (col_num = range->first_col; col_num <= range->last_col;
  597. col_num++) {
  598. data_point = calloc(1, sizeof(struct lxw_series_data_point));
  599. if (!data_point) {
  600. range->ignore_cache = LXW_TRUE;
  601. return;
  602. }
  603. cell_obj = lxw_worksheet_find_cell(row_obj, col_num);
  604. if (cell_obj) {
  605. if (cell_obj->type == NUMBER_CELL) {
  606. data_point->number = cell_obj->u.number;
  607. }
  608. if (cell_obj->type == STRING_CELL) {
  609. data_point->string = lxw_strdup(cell_obj->sst_string);
  610. data_point->is_string = LXW_TRUE;
  611. range->has_string_cache = LXW_TRUE;
  612. }
  613. }
  614. else {
  615. data_point->no_data = LXW_TRUE;
  616. }
  617. STAILQ_INSERT_TAIL(range->data_cache, data_point, list_pointers);
  618. num_data_points++;
  619. }
  620. }
  621. range->num_data_points = num_data_points;
  622. }
  623. /* Set the range dimensions and set the data cache.
  624. */
  625. STATIC void
  626. _populate_range(lxw_workbook *self, lxw_series_range *range)
  627. {
  628. _populate_range_dimensions(self, range);
  629. _populate_range_data_cache(self, range);
  630. }