static void
gog_xy_dropbar_plot_clear_formats (GogXYDropBarPlot *plot)
{
go_format_unref (plot->x.fmt);
plot->x.fmt = NULL;
go_format_unref (plot->y.fmt);
plot->y.fmt = NULL;
}
static GSList *
xlsx_write_pivots (XLSXWriteState *state, GsfOutfile *wb_part)
{
GHashTable *caches = excel_collect_pivot_caches (state->base.wb);
GHashTableIter iter;
GSList *refs = NULL;
gpointer key, value;
char const *cache_def_id;
if (caches == NULL)
return NULL;
state->date_fmt = xlsx_pivot_date_fmt ();
state->pivotCache.count = state->pivotTable.count = 0;
state->pivotCache.dir = (GsfOutfile *)gsf_outfile_new_child (state->xl_dir, "pivotCache", TRUE);
state->pivotTable.dir = (GsfOutfile *)gsf_outfile_new_child (state->xl_dir, "pivotTable", TRUE);
g_hash_table_iter_init (&iter, caches);
while (g_hash_table_iter_next (&iter, &key, &value))
if (NULL != key) {
cache_def_id = xlsx_write_pivot_cache_definition (state, wb_part, key, GPOINTER_TO_UINT(value));
refs = g_slist_prepend (refs, (gpointer)cache_def_id);
}
gsf_output_close (GSF_OUTPUT (state->pivotCache.dir));
gsf_output_close (GSF_OUTPUT (state->pivotTable.dir));
g_hash_table_destroy (caches);
go_format_unref (state->date_fmt);
return g_slist_reverse (refs);
}
static void
cb_popup_menu_extend_format (GtkWidget *widget, gpointer data)
{
StfDialogData *pagedata = data;
guint index = pagedata->format.index;
GOFormat *colformat = g_ptr_array_index
(pagedata->format.formats, pagedata->format.index);
for (index++; index < pagedata->format.formats->len; index++) {
GOFormat *sf = g_ptr_array_index
(pagedata->format.formats, index);
GtkTreeViewColumn* column =
stf_preview_get_column (pagedata->format.renderdata,
index);
GtkWidget *w = g_object_get_data (G_OBJECT (column),
"formatlabel");
go_format_unref (sf);
g_ptr_array_index (pagedata->format.formats, index)
= go_format_ref (colformat);
gtk_button_set_label (GTK_BUTTON (w),
go_format_sel_format_classification (colformat));
}
format_page_update_preview (data);
}
static void
gnm_so_path_write_xml_sax (SheetObject const *so, GsfXMLOut *output,
G_GNUC_UNUSED GnmConventions const *convs)
{
GnmSOPath const *sop = GNM_SO_PATH (so);
char *svg;
if (sop->text != NULL && *(sop->text) != '\0') {
gsf_xml_out_add_cstr (output, "Label", sop->text);
if (sop->markup != NULL) {
GOFormat *fmt = go_format_new_markup (sop->markup, TRUE);
gsf_xml_out_add_cstr (output, "LabelFormat",
go_format_as_XL (fmt));
go_format_unref (fmt);
}
}
if (sop->path) {
svg = go_path_to_svg (sop->path);
gsf_xml_out_add_cstr (output, "Path", svg);
g_free (svg);
} else if (sop->paths) {
unsigned i;
for (i = 0; i < sop->paths->len; i++) {
gsf_xml_out_start_element (output, "Path");
svg = go_path_to_svg ((GOPath *) g_ptr_array_index (sop->paths, i));
gsf_xml_out_add_cstr (output, "Path", svg);
g_free (svg);
gsf_xml_out_end_element (output); /* </Path> */
}
}
gsf_xml_out_start_element (output, "Style");
go_persist_sax_save (GO_PERSIST (sop->style), output);
gsf_xml_out_end_element (output); /* </Style> */
}
/**
* stf_parse_options_free:
*
* will free @parseoptions, note that this will not free the splitpositions
* member (GArray) of the struct, the caller is responsible for that.
**/
void
stf_parse_options_free (StfParseOptions_t *parseoptions)
{
g_return_if_fail (parseoptions != NULL);
g_free (parseoptions->col_import_array);
g_free (parseoptions->locale);
g_free (parseoptions->sep.chr);
if (parseoptions->sep.str) {
GSList *l;
for (l = parseoptions->sep.str; l != NULL; l = l->next)
g_free ((char *) l->data);
g_slist_free (parseoptions->sep.str);
}
g_array_free (parseoptions->splitpositions, TRUE);
stf_parse_options_clear_line_terminator (parseoptions);
if (parseoptions->formats) {
unsigned int ui;
GPtrArray *formats = parseoptions->formats;
for (ui = 0; ui < formats->len; ui++)
go_format_unref (g_ptr_array_index (formats, ui));
g_ptr_array_free (formats, TRUE);
parseoptions->formats = NULL;
}
g_free (parseoptions);
}
static char const *
xlsx_write_pivot_cache_definition (XLSXWriteState *state, GsfOutfile *wb_part,
GODataCache const *cache, unsigned int cache_def_num)
{
GsfXMLOut *xml;
int i, n;
char const *record_id;
char *name = g_strdup_printf ("pivotCacheDefinition%u.xml", cache_def_num);
GsfOutput *cache_def_part = gsf_outfile_new_child_full (state->pivotCache.dir, name, FALSE,
"content-type", "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheDefinition+xml",
NULL);
char const *cache_def_id = gsf_outfile_open_pkg_relate (GSF_OUTFILE_OPEN_PKG (cache_def_part),
GSF_OUTFILE_OPEN_PKG (wb_part),
"http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotCacheDefinition");
record_id = xlsx_write_pivot_cache_records (state, cache, cache_def_part, cache_def_num);
xml = gsf_xml_out_new (cache_def_part);
gsf_xml_out_start_element (xml, "pivotCacheDefinition");
gsf_xml_out_add_cstr_unchecked (xml, "xmlns", ns_ss);
gsf_xml_out_add_cstr_unchecked (xml, "xmlns:r", ns_rel);
gsf_xml_out_add_cstr (xml, "r:id", record_id);
if (cache->refreshed_by) gsf_xml_out_add_cstr (xml, "refreshedBy", cache->refreshed_by);
if (cache->refreshed_on) {
if (state->version == ECMA_376_2006)
gsf_xml_out_add_float (xml, "refreshedDate",
go_val_as_float (cache->refreshed_on), -1);
else {
GOFormat const *format = go_format_new_from_XL ("yyyy-mm-dd\"T\"hh:mm:ss");
gchar *date = format_value (format, cache->refreshed_on, NULL, -1, NULL);
gsf_xml_out_add_cstr_unchecked (xml, "refreshedDateIso", date);
g_free (date);
go_format_unref (format);
}
}
gsf_xml_out_add_int (xml, "createdVersion", cache->XL_created_ver);
gsf_xml_out_add_int (xml, "refreshedVersion", cache->XL_refresh_ver);
gsf_xml_out_add_uint (xml, "recordCount", go_data_cache_num_items (cache));
xlsx_add_bool (xml, "upgradeOnRefresh", cache->refresh_upgrades);
xlsx_write_pivot_cache_source (state, xml, cache);
gsf_xml_out_start_element (xml, "cacheFields");
n = go_data_cache_num_fields (cache);
gsf_xml_out_add_uint (xml, "count", n);
for (i = 0 ; i < n ; i++)
xlsx_write_pivot_cache_field (state, xml, go_data_cache_get_field (cache, i));
gsf_xml_out_end_element (xml); /* </cacheFields> */
gsf_xml_out_end_element (xml); /* </pivotCacheDefinition> */
g_object_unref (xml);
gsf_output_close (cache_def_part);
g_object_unref (cache_def_part);
g_free (name);
return cache_def_id;
}
static char *
try_auto_date (GnmValue *value, const GOFormat *format,
GODateConventions const *date_conv)
{
gnm_float v, vr, vs;
GOFormat *actual;
char *res;
gboolean needs_date, needs_time, needs_frac_sec;
gboolean is_date;
int is_time;
GString *xlfmt;
GDate date;
format = gnm_format_specialize (format, value);
is_date = go_format_is_date (format) > 0;
is_time = go_format_is_time (format);
if (!is_date && is_time <= 0)
return NULL;
/* We don't want to coerce strings. */
if (!VALUE_IS_FLOAT (value))
return NULL;
/* Verify that the date is valid. */
if (!datetime_value_to_g (&date, value, date_conv))
return NULL;
v = value_get_as_float (value);
vr = gnm_fake_round (v);
vs = (24 * 60 * 60) * gnm_abs (v - vr);
needs_date = is_time < 2 && (is_date || gnm_abs (v) >= 1);
needs_time = is_time > 0 || gnm_abs (v - vr) > 1e-9;
needs_frac_sec = needs_time && gnm_abs (vs - gnm_fake_round (vs)) >= 0.5e-3;
xlfmt = g_string_new (NULL);
if (needs_date) g_string_append (xlfmt, "yyyy/mm/dd");
if (needs_time) {
if (needs_date)
g_string_append_c (xlfmt, ' ');
if (is_time == 2)
g_string_append (xlfmt, "[h]:mm:ss");
else
g_string_append (xlfmt, "hh:mm:ss");
if (needs_frac_sec)
g_string_append (xlfmt, ".000");
}
actual = go_format_new_from_XL (xlfmt->str);
g_string_free (xlfmt, TRUE);
res = format_value (actual, value, -1, date_conv);
go_format_unref (actual);
return res;
}
void
sylk_file_open (GOFileOpener const *fo,
GOIOContext *io_context,
WorkbookView *wb_view,
GsfInput *input)
{
SylkReader state;
char const *input_name;
char *name = NULL;
int i;
GnmLocale *locale;
memset (&state, 0, sizeof (state));
state.io_context = io_context;
state.input = (GsfInputTextline *) gsf_input_textline_new (input);
state.converter = g_iconv_open ("UTF-8", "ISO-8859-1");
state.finished = FALSE;
state.line_no = 0;
state.pp.wb = wb_view_get_workbook (wb_view);
if (NULL == (input_name = gsf_input_name (input)) ||
NULL == (name = g_path_get_basename (input_name)) ||
'\0' == *name) {
g_free (name);
name = g_strdup ("Sheet");
}
state.pp.sheet = sheet_new (state.pp.wb, name, 256, 65536);
workbook_sheet_attach (state.pp.wb, state.pp.sheet);
g_free (name);
state.pp.eval.col = state.pp.eval.row = 1;
state.convs = gnm_conventions_xls_r1c1;
state.formats = g_ptr_array_new ();
state.fonts = g_ptr_array_new ();
locale = gnm_push_C_locale ();
sylk_parse_sheet (&state);
gnm_pop_C_locale (locale);
workbook_set_saveinfo (state.pp.wb, GO_FILE_FL_AUTO,
go_file_saver_for_id ("Gnumeric_sylk:sylk"));
for (i = state.fonts->len ; i-- > 0 ; )
gnm_style_unref (g_ptr_array_index (state.fonts, i));
g_ptr_array_free (state.fonts, TRUE);
for (i = state.formats->len ; i-- > 0 ; )
go_format_unref (g_ptr_array_index (state.formats, i));
g_ptr_array_free (state.formats, TRUE);
gsf_iconv_close (state.converter);
g_object_unref (G_OBJECT (state.input));
}
/**
* stf_preview_colformats_clear
* @renderdata : a struct containing rendering information
*
* This will clear the @renderdata->colformats array which contains the format of
* each column.
*
* returns : nothing
**/
void
stf_preview_colformats_clear (RenderData_t *renderdata)
{
guint i;
g_return_if_fail (renderdata != NULL);
for (i = 0; i < renderdata->colformats->len; i++)
go_format_unref (g_ptr_array_index (renderdata->colformats, i));
g_ptr_array_free (renderdata->colformats, TRUE);
renderdata->colformats = g_ptr_array_new ();
}
static void
render_timestamp_with_format (GString *target, char const *number_format, HFRenderInfo *info)
{
GOFormat *format;
/* TODO : Check this assumption. Is it a localized format? */
format = go_format_new_from_XL (number_format);
format_value_gstring (target, format, info->date_time,
-1, info->date_conv);
go_format_unref (format);
}
static void
cb_format_clicked (GtkButton *widget, gpointer _i)
{
int i = GPOINTER_TO_INT (_i);
StfDialogData *pagedata =
g_object_get_data (G_OBJECT (widget), "pagedata");
gint result;
GOFormat *sf;
GtkWidget *dialog = gtk_dialog_new_with_buttons
(_("Format Selector"),
GTK_WINDOW (pagedata->dialog),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
NULL);
GOFormatSel *format_selector
= GO_FORMAT_SEL (go_format_sel_new_full (TRUE));
GtkWidget *w = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
GtkTreeViewColumn* column;
GtkWidget *format_label;
sf = g_ptr_array_index (pagedata->format.formats, i);
go_format_sel_set_style_format (format_selector, sf);
go_format_sel_set_locale (format_selector, pagedata->locale);
gtk_box_pack_start (GTK_BOX (w), GTK_WIDGET (format_selector),
FALSE, TRUE, 5);
gtk_widget_show (GTK_WIDGET (format_selector));
result = gtk_dialog_run (GTK_DIALOG (dialog));
switch (result)
{
case GTK_RESPONSE_ACCEPT:
column = stf_preview_get_column (pagedata->format.renderdata, i);
format_label = g_object_get_data (G_OBJECT (column),
"formatlabel");
sf = g_ptr_array_index (pagedata->format.formats, i);
go_format_unref (sf);
sf = go_format_ref (go_format_sel_get_fmt (format_selector));
gtk_button_set_label (GTK_BUTTON (format_label),
go_format_sel_format_classification (sf));
g_ptr_array_index (pagedata->format.formats, i) = sf;
format_page_update_preview (pagedata);
default:
break;
}
gtk_widget_destroy (dialog);
return;
}
void
stf_dialog_format_page_cleanup (StfDialogData *pagedata)
{
GPtrArray *formats = pagedata->format.formats;
if (formats) {
unsigned int ui;
for (ui = 0; ui < formats->len; ui++)
go_format_unref (g_ptr_array_index (formats, ui));
g_ptr_array_free (formats, TRUE);
}
stf_preview_free (pagedata->format.renderdata);
g_free (pagedata->format.col_import_array);
g_free (pagedata->format.col_autofit_array);
pagedata->format.col_import_array = NULL;
pagedata->format.col_autofit_array = NULL;
pagedata->format.col_import_array_len = 0;
pagedata->format.col_import_count = 0;
}
/*
* Figure out whether the format engine in goffice allows negative values
* or (as XL) considers them errors.
*/
gboolean
gnm_datetime_allow_negative (void)
{
static int allow = -1;
if (allow == -1) {
GOFormat *fmt = go_format_new_from_XL ("yyyy-mm-dd");
GnmValue *v = value_new_int (-42);
GODateConventions const *conv =
go_date_conv_from_str ("Lotus:1900");
char *text = format_value (fmt, v, NULL, -1, conv);
allow = (strcmp (text, "1899-11-19") == 0);
value_release (v);
go_format_unref (fmt);
g_free (text);
}
return (gboolean)allow;
}
static void
gnm_so_path_prep_sax_parser (SheetObject *so, GsfXMLIn *xin,
xmlChar const **attrs,
G_GNUC_UNUSED GnmConventions const *convs)
{
static GsfXMLInNode const dtd[] = {
GSF_XML_IN_NODE (SOPATH, SOPATH, -1, "SheetObjectPath", GSF_XML_NO_CONTENT, NULL, NULL),
GSF_XML_IN_NODE (SOPATH, PATH, -1, "Path", GSF_XML_NO_CONTENT, &sop_sax_path, NULL),
GSF_XML_IN_NODE (SOPATH, STYLE, -1, "Style", GSF_XML_NO_CONTENT, &sop_sax_style, NULL),
GSF_XML_IN_NODE_END
};
static GsfXMLInDoc *doc = NULL;
GnmSOPath *sop = GNM_SO_PATH(so);
if (NULL == doc) {
doc = gsf_xml_in_doc_new (dtd, NULL);
gnm_xml_in_doc_dispose_on_exit (&doc);
}
gsf_xml_in_push_state (xin, doc, NULL, NULL, attrs);
for (; attrs != NULL && attrs[0] && attrs[1] ; attrs += 2)
if (attr_eq (attrs[0], "Label"))
g_object_set (G_OBJECT (sop), "text", attrs[1], NULL);
else if (attr_eq (attrs[0], "LabelFormat")) {
GOFormat * fmt = go_format_new_from_XL (attrs[1]);
if (go_format_is_markup (fmt))
g_object_set (G_OBJECT (sop),
"markup", go_format_get_markup (fmt),
NULL);
go_format_unref (fmt);
} else if (attr_eq (attrs[0], "Path")) {
GOPath *path = go_path_new_from_svg (attrs[1]);
if (path) {
g_object_set (G_OBJECT (sop), "path", path, NULL);
go_path_free (path);
}
}
}
