xml-io.c 70.4 KB
Newer Older
1 2 3
/*
 * xml-io.c: save/read gnumeric Sheets using an XML encoding.
 *
4 5 6
 * Authors:
 *   Daniel Veillard <Daniel.Veillard@w3.org>
 *   Miguel de Icaza <miguel@gnu.org>
7
 *
8
 * $Id$
9 10 11 12 13
 */

#include <config.h>
#include <stdio.h>
#include <gnome.h>
14
#include <locale.h>
15
#include <math.h>
16
#include "gnumeric.h"
17
#include "gnome-xml/parser.h"
Daniel Veillard's avatar
Daniel Veillard committed
18
#include "gnome-xml/parserInternals.h"
19
#include "gnome-xml/xmlmemory.h"
20
#include "color.h"
21
#include "border.h"
22
#include "sheet-object.h"
23
#include "sheet-object-graphic.h"
24
#include "print-info.h"
25
#include "xml-io.h"
26
#include "file.h"
27
#include "expr.h"
28
#include "cell.h"
29
#include "workbook.h"
30 31
#include "workbook-view.h"
#include "selection.h"
32
#include "command-context.h"
33 34 35 36

/*
 * A parsing context.
 */
37 38 39 40 41 42
typedef struct {
	xmlDocPtr doc;		/* Xml document */
	xmlNsPtr ns;		/* Main name space */
	xmlNodePtr parent;	/* used only for g_hash_table_foreach callbacks */
	Sheet *sheet;		/* the associated sheet */
	Workbook *wb;		/* the associated sheet */
43
	GHashTable *style_table;/* old style styles compatibility */
44 45
} parse_xml_context_t;

46 47 48
/*
 * Internal stuff: xml helper functions.
 */
49

50 51 52 53
static void
xml_arg_set (GtkArg *arg, gchar *string)
{
	switch (arg->type) {
JP Rosevear's avatar
JP Rosevear committed
54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86
	case GTK_TYPE_CHAR:
		GTK_VALUE_CHAR (*arg) = string[0];
		break;
	case GTK_TYPE_UCHAR:
		GTK_VALUE_UCHAR (*arg) = string[0];
		break;
	case GTK_TYPE_BOOL:
		if (!strcmp (string, "TRUE")) 
			GTK_VALUE_BOOL (*arg) = TRUE;
		else
			GTK_VALUE_BOOL (*arg) = FALSE;
		break;
	case GTK_TYPE_INT:
		GTK_VALUE_INT (*arg) = atoi (string);
		break;
	case GTK_TYPE_UINT:
		GTK_VALUE_UINT (*arg) = atoi (string);
		break;
	case GTK_TYPE_LONG:
		GTK_VALUE_LONG (*arg) = atol (string);
		break;
	case GTK_TYPE_ULONG:
		GTK_VALUE_ULONG (*arg) = atol (string);
		break;
	case GTK_TYPE_FLOAT:
		GTK_VALUE_FLOAT (*arg) = atof (string);
		break;
	case GTK_TYPE_DOUBLE:
		GTK_VALUE_DOUBLE (*arg) = atof (string);
		break;
	case GTK_TYPE_STRING:
		GTK_VALUE_STRING (*arg) = g_strdup (string);
		break;
87 88 89 90 91 92 93
	}
}

static char *
xml_arg_get (GtkArg *arg)
{
	switch (arg->type) {
JP Rosevear's avatar
JP Rosevear committed
94 95 96 97 98 99 100 101 102 103 104 105 106 107
	case GTK_TYPE_CHAR:
		return g_strdup (&GTK_VALUE_CHAR (*arg));
	case GTK_TYPE_UCHAR:
		return g_strdup (&GTK_VALUE_UCHAR (*arg));
	case GTK_TYPE_BOOL:
		if (GTK_VALUE_BOOL (*arg))
			return g_strdup ("TRUE");
		else
			return g_strdup ("FALSE");
	case GTK_TYPE_INT:
		return g_strdup_printf("%i", GTK_VALUE_INT (*arg));
	case GTK_TYPE_UINT:
		return g_strdup_printf("%u", GTK_VALUE_UINT (*arg));
	case GTK_TYPE_LONG:
Jon K Hellan's avatar
Jon K Hellan committed
108
		return g_strdup_printf("%l", GTK_VALUE_LONG (*arg));
JP Rosevear's avatar
JP Rosevear committed
109
	case GTK_TYPE_ULONG:
Jon K Hellan's avatar
Jon K Hellan committed
110
		return g_strdup_printf("%ul", GTK_VALUE_ULONG (*arg));
JP Rosevear's avatar
JP Rosevear committed
111 112 113 114 115 116
	case GTK_TYPE_FLOAT:
		return g_strdup_printf("%f", GTK_VALUE_FLOAT (*arg));
	case GTK_TYPE_DOUBLE:
		return g_strdup_printf("%f", GTK_VALUE_DOUBLE (*arg));
	case GTK_TYPE_STRING:
		return g_strdup (GTK_VALUE_STRING (*arg));
117 118 119 120 121
	}

	return NULL;
}
 
122 123 124
/*
 * Get a value for a node either carried as an attibute or as
 * the content of a child.
125 126
 *
 * Returns a g_malloc'ed string.  Caller must free.
127
 */
128
static char *
129
xml_value_get (xmlNodePtr node, const char *name)
130
{
131
	char *ret, *val;
132 133
	xmlNodePtr child;

134 135 136 137
	val = (char *) xmlGetProp (node, name);
	if (val != NULL) {
		ret = g_strdup (val);
		xmlFree (val);
Morten Welinder's avatar
Morten Welinder committed
138
		return ret;
139
	}
140 141 142
	child = node->childs;

	while (child != NULL) {
143 144 145 146
		if (!strcmp (child->name, name)) {
		        /*
			 * !!! Inefficient, but ...
			 */
147 148 149 150 151 152
			val = xmlNodeGetContent(child);
			if (val != NULL) {
				ret = g_strdup (val);
				xmlFree (val);
				return ret;
			}
153
		}
154 155 156 157
		child = child->next;
	}

	return NULL;
158 159
}

160 161 162 163
/*
 * Get a String value for a node either carried as an attibute or as
 * the content of a child.
 */
164
static String *
165
xml_get_value_string (xmlNodePtr node, const char *name)
166
{
167
	char *val;
168 169
	String *ret;

170 171 172 173 174
	val = xml_value_get (node, name);
	if (val == NULL) return NULL;
        ret = string_get (val);
	g_free (val);
	return ret;
175 176
}

177 178 179 180
/*
 * Get an integer value for a node either carried as an attibute or as
 * the content of a child.
 */
181
static int
182
xml_get_value_int (xmlNodePtr node, const char *name, int *val)
183
{
184
	char *ret;
185
	int i;
186
	int res;
187

188
	ret = xml_value_get (node, name);
189
	if (ret == NULL) return 0;
190
	res = sscanf (ret, "%d", &i);
191 192
	g_free (ret);

193 194
	if (res == 1) {
	        *val = i;
195 196 197
		return 1;
	}
	return 0;
198 199
}

200
#if 0
201 202 203 204
/*
 * Get a float value for a node either carried as an attibute or as
 * the content of a child.
 */
205
static int
206
xml_get_value_float (xmlNodePtr node, const char *name, float *val)
207
{
208 209
	int res;
	char *ret;
210 211
	float f;

212
	ret = xml_value_get (node, name);
213
	if (ret == NULL) return 0;
214
	res = sscanf (ret, "%f", &f);
215 216
	g_free (ret);

217 218
	if (res == 1) {
	        *val = f;
219 220 221
		return 1;
	}
	return 0;
222
}
223
#endif
224 225 226 227 228

/*
 * Get a double value for a node either carried as an attibute or as
 * the content of a child.
 */
229
static int
230
xml_get_value_double (xmlNodePtr node, const char *name, double *val)
231
{
232 233
	int res;
	char *ret;
234

235
	ret = xml_value_get (node, name);
236
	if (ret == NULL) return 0;
237
	res = sscanf (ret, "%lf", val);
238
	g_free (ret);
239

240
	return (res == 1);
241 242
}

243
#if 0
244 245 246
/*
 * Get a set of coodinates for a node, carried as the content of a child.
 */
247
static int
248
xml_get_coordinate (xmlNodePtr node, const char *name, double *x, double *y)
249
{
250 251
	int res;
	char *ret;
252
	float X, Y;
253

254
	ret = xml_value_get (node, name);
255
	if (ret == NULL) return 0;
256
	res = sscanf (ret, "(%lf %lf)", x, y)
257
	g_free (ret);
258 259

	return (res == 2)
260
}
261
#endif
262 263 264 265 266

/*
 * Get a pair of coodinates for a node, carried as the content of a child.
 */

267
static int
268
xml_get_coordinates (xmlNodePtr node, const char *name,
269 270
		   double *x1, double *y1, double *x2, double *y2)
{
271 272
	int res;
	char *ret;
273

274
	ret = xml_value_get (node, name);
275
	if (ret == NULL) return 0;
276
	res = sscanf (ret, "(%lf %lf)(%lf %lf)", x1, y1, x2, y2);
277 278 279
	g_free (ret);

	if (res == 4)
280
		return 1;
281

282
	return 0;
283 284
}

285
#if 0
286 287 288
/*
 * Get a GnomeCanvasPoints for a node, carried as the content of a child.
 */
289
static GnomeCanvasPoints *
290
xml_get_gnome_canvas_points (xmlNodePtr node, const char *name)
291
{
292
	char *val;
293 294 295 296
	GnomeCanvasPoints *ret = NULL;
	int res;
	const char *ptr;
	int index = 0, i;
297
	float coord[20];	/* TODO: must be dynamic !!!! */
298

299
	val = xml_value_get (node, name);
300
	if (val == NULL) return NULL;
301 302 303 304 305
	ptr = val;
	do {
		while ((*ptr) && (*ptr != '('))
			ptr++;
		if (*ptr == 0)
306
			break;
307
		res = sscanf (ptr, "(%lf %lf)", &coord[index], &coord[index + 1]);
308 309 310 311 312
		if (res != 2)
			break;
		index += 2;
		ptr++;
	} while (res > 0);
313
	g_free (val);
314 315 316 317 318 319 320

	if (index >= 2)
		ret = gnome_canvas_points_new (index / 2);
	if (ret == NULL)
		return NULL;
	for (i = 0; i < index; i++)
		ret->coords[i] = coord[i];
321
	return ret;
322
}
323
#endif
324 325 326 327 328

/*
 * Set a string value for a node either carried as an attibute or as
 * the content of a child.
 */
329
static void
330
xml_set_gnome_canvas_points (xmlNodePtr node, const char *name,
331
			     GnomeCanvasPoints *val)
332 333 334
{
	xmlNodePtr child;
	char *str, *base;
335
	char *tstr;
336 337 338 339 340 341
	int i;

	if (val == NULL)
		return;
	if ((val->num_points < 0) || (val->num_points > 5000))
		return;
342
	base = str = g_malloc (val->num_points * 30 * sizeof (char) + 1);
343 344 345
	if (str == NULL)
		return;
	for (i = 0; i < val->num_points; i++){
346 347 348
		sprintf (str, "(%f %f)", val->coords[2 * i],
			 val->coords[2 * i + 1]);
		str += strlen (str);
349
	}
350
	*str = 0;
351 352 353 354 355

	child = node->childs;
	while (child != NULL){
		if (!strcmp (child->name, name)){
			xmlNodeSetContent (child, base);
356
			g_free (base);
357 358 359 360
			return;
		}
		child = child->next;
	}
361 362 363 364

	tstr = xmlEncodeEntitiesReentrant (node->doc, base);
	xmlNewChild (node, NULL, name, tstr);
	if (tstr) xmlFree (tstr);
365
	g_free (base);
366 367
}

368 369 370 371
/*
 * Set a string value for a node either carried as an attibute or as
 * the content of a child.
 */
372 373
static void
xml_set_value (xmlNodePtr node, const char *name, const char *val)
374
{
375
	char *ret;
376 377 378 379
	xmlNodePtr child;

	ret = xmlGetProp (node, name);
	if (ret != NULL){
380
		xmlFree (ret);
381 382 383 384 385 386 387 388 389 390 391 392
		xmlSetProp (node, name, val);
		return;
	}
	child = node->childs;
	while (child != NULL){
		if (!strcmp (child->name, name)){
			xmlNodeSetContent (child, val);
			return;
		}
		child = child->next;
	}
	xmlSetProp (node, name, val);
393 394
}

395 396 397 398
/*
 * Set a String value for a node either carried as an attibute or as
 * the content of a child.
 */
399 400
static void
xml_set_value_string (xmlNodePtr node, const char *name, String *val)
401
{
402
	char *ret;
403 404 405 406
	xmlNodePtr child;

	ret = xmlGetProp (node, name);
	if (ret != NULL){
407
		xmlFree (ret);
408 409 410 411 412 413 414 415 416 417 418 419
		xmlSetProp (node, name, val->str);
		return;
	}
	child = node->childs;
	while (child != NULL){
		if (!strcmp (child->name, name)){
			xmlNodeSetContent (child, val->str);
			return;
		}
		child = child->next;
	}
	xmlSetProp (node, name, val->str);
420 421
}

422 423 424 425
/*
 * Set an integer value for a node either carried as an attibute or as
 * the content of a child.
 */
426
static void
427
xml_set_value_int (xmlNodePtr node, const char *name, int val)
428
{
429
	char *ret;
430 431 432 433 434 435
	xmlNodePtr child;
	char str[101];

	snprintf (str, 100, "%d", val);
	ret = xmlGetProp (node, name);
	if (ret != NULL){
436
		xmlFree (ret);
437 438 439 440 441 442 443 444 445 446 447 448
		xmlSetProp (node, name, str);
		return;
	}
	child = node->childs;
	while (child != NULL){
		if (!strcmp (child->name, name)){
			xmlNodeSetContent (child, str);
			return;
		}
		child = child->next;
	}
	xmlSetProp (node, name, str);
449 450
}

451
#if 0
452 453 454 455
/*
 * Set a float value for a node either carried as an attibute or as
 * the content of a child.
 */
456
static void
457
xml_set_value_float (xmlNodePtr node, const char *name, float val)
458
{
459
	char *ret;
460 461 462 463 464 465
	xmlNodePtr child;
	char str[101];

	snprintf (str, 100, "%f", val);
	ret = xmlGetProp (node, name);
	if (ret != NULL){
466
		xmlFree (ret);
467 468 469 470 471 472 473 474 475 476 477 478
		xmlSetProp (node, name, str);
		return;
	}
	child = node->childs;
	while (child != NULL){
		if (!strcmp (child->name, name)){
			xmlNodeSetContent (child, str);
			return;
		}
		child = child->next;
	}
	xmlSetProp (node, name, str);
479
}
480
#endif
481 482 483 484 485

/*
 * Set a double value for a node either carried as an attibute or as
 * the content of a child.
 */
486
static void
487
xml_set_value_double (xmlNodePtr node, const char *name, double val)
488
{
489
	char *ret;
490
	xmlNodePtr child;
491
	char str[101 + DBL_DIG];
492

493 494 495 496
	if (fabs (val) < 1e9 && fabs (val) > 1e-5)
		snprintf (str, 100 + DBL_DIG, "%.*g", DBL_DIG, val);
	else
		snprintf (str, 100 + DBL_DIG, "%f", val);
497

498 499
	ret = xmlGetProp (node, name);
	if (ret != NULL){
500
		xmlFree (ret);
501 502 503 504 505 506 507 508 509 510 511 512
		xmlSetProp (node, name, str);
		return;
	}
	child = node->childs;
	while (child != NULL){
		if (!strcmp (child->name, name)){
			xmlNodeSetContent (child, str);
			return;
		}
		child = child->next;
	}
	xmlSetProp (node, name, str);
513 514
}

515 516 517 518 519
static void
xml_set_print_unit (xmlNodePtr node, const char *name,
		    const PrintUnit * const pu)
{
	xmlNodePtr  child;
Jody Goldberg's avatar
Jody Goldberg committed
520
	char       *txt = "points";
521
	char       *tstr;
522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540

	if (pu == NULL || name == NULL)
		return;

	switch (pu->desired_display) {
	case UNIT_POINTS:
		txt = "points";
		break;
	case UNIT_MILLIMETER:
		txt = "mm";
		break;
	case UNIT_CENTIMETER:
		txt = "cm";
		break;
	case UNIT_INCH:
		txt = "in";
		break;
	}

541 542 543 544
	tstr = xmlEncodeEntitiesReentrant (node->doc, name);
	child = xmlNewChild (node, NULL, "PrintUnit", tstr);
	if (tstr) xmlFree (tstr);

545
	xml_set_value_double (child, "Points", pu->points);
546 547 548 549

	tstr = xmlEncodeEntitiesReentrant (node->doc, txt);
	xml_set_value (child, "PrefUnit", tstr);
	if (tstr) xmlFree (tstr);
550 551 552 553 554 555
}

static void
xml_get_print_unit (xmlNodePtr node, PrintUnit * const pu)
{
	char       *txt;
556

557 558 559 560 561 562 563 564 565 566 567 568 569 570 571
	g_return_if_fail (pu != NULL);
	g_return_if_fail (node != NULL);
	g_return_if_fail (node->childs != NULL);

	xml_get_value_double (node, "Points", &pu->points);
	txt = xml_value_get  (node, "PrefUnit");
	if (txt) {
		if (!g_strcasecmp (txt, "points"))
			pu->desired_display = UNIT_POINTS;
		else if (!g_strcasecmp (txt, "mm"))
			pu->desired_display = UNIT_MILLIMETER;
		else if (!g_strcasecmp (txt, "cm"))
			pu->desired_display = UNIT_CENTIMETER;
		else if (!g_strcasecmp (txt, "in"))
			pu->desired_display = UNIT_INCH;
572
		g_free (txt);
573 574 575
	}
}

576
/*
577
 * Search a child by name, if needed go down the tree to find it.
578
 */
579 580
static xmlNodePtr
xml_search_child (xmlNodePtr node, const char *name)
581 582 583 584 585 586 587 588 589 590 591 592
{
	xmlNodePtr ret;
	xmlNodePtr child;

	child = node->childs;
	while (child != NULL){
		if (!strcmp (child->name, name))
			return child;
		child = child->next;
	}
	child = node->childs;
	while (child != NULL){
593
		ret = xml_search_child (child, name);
594 595 596 597 598
		if (ret != NULL)
			return ret;
		child = child->next;
	}
	return NULL;
599 600
}

601 602 603
static gboolean
xml_read_range (xmlNodePtr tree, Range *res)
{
Jody Goldberg's avatar
Jody Goldberg committed
604
	return
605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631
	    xml_get_value_int (tree, "startCol", &res->start.col) &&
	    xml_get_value_int (tree, "startRow", &res->start.row) &&
	    xml_get_value_int (tree, "endCol",   &res->end.col) &&
	    xml_get_value_int (tree, "endRow",   &res->end.row);
}

static void
xml_write_range (xmlNodePtr tree, Range *value)
{
	xml_set_value_int (tree, "startCol", value->start.col);
	xml_set_value_int (tree, "startRow", value->start.row);
	xml_set_value_int (tree, "endCol",   value->end.col);
	xml_set_value_int (tree, "endRow",   value->end.row);
}

static void
xml_read_selection_info (parse_xml_context_t *ctxt, Sheet *sheet, xmlNodePtr tree)
{
	Range r;
	int row, col;
	xmlNodePtr sel, selections = xml_search_child (tree, "Selections");
	if (selections == NULL)
		return;

	sheet_selection_reset_only (sheet);
	for (sel = selections->childs; sel; sel = sel->next) {
		if (xml_read_range (sel, &r))
632 633 634 635
			sheet_selection_add_range (sheet,
						   r.start.col, r.start.row,
						   r.start.col, r.start.row,
						   r.end.col, r.end.row);
636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658
	}

	if (xml_get_value_int (tree, "CursorCol", &col) &&
	    xml_get_value_int (tree, "CursorRow", &row))
		sheet_cursor_set (sheet, col, row, col, row, col, row);
}

static void
xml_write_selection_info (parse_xml_context_t *ctxt, Sheet *sheet, xmlNodePtr tree)
{
	GList *ptr, *copy;
	tree = xmlNewChild (tree, ctxt->ns, "Selections", NULL);

	/* Insert the selections in REVERSE order */
	copy = g_list_copy (sheet->selections);
	ptr = g_list_reverse (copy);
	for (; ptr != NULL ; ptr = ptr->next) {
		SheetSelection *sel = ptr->data;
		xmlNodePtr child = xmlNewChild (tree, ctxt->ns, "Selection", NULL);
		xml_write_range (child, &sel->user);
	}
	g_list_free (copy);

659 660
	xml_set_value_int (tree, "CursorCol", sheet->cursor.edit_pos.col);
	xml_set_value_int (tree, "CursorRow", sheet->cursor.edit_pos.row);
661 662
}

663 664 665 666 667 668 669 670
/*
 * Get a color value for a node either carried as an attibute or as
 * the content of a child.
 *
 * TODO PBM: at parse time one doesn't have yet a widget, so we have
 *           to retrieve the default colormap, but this may be a bad
 *           option ...
 */
671
static int
672
xml_get_color_value (xmlNodePtr node, const char *name, StyleColor **color)
673
{
674
	char *ret;
675 676
	int red, green, blue;

677
	ret = xml_value_get (node, name);
678
	if (ret == NULL) return 0;
679
	if (sscanf (ret, "%X:%X:%X", &red, &green, &blue) == 3){
680
		*color = style_color_new (red, green, blue);
681
		g_free (ret);
682 683
		return 1;
	}
684
	g_free (ret);
685
	return 0;
686 687 688 689 690 691
}

/*
 * Set a color value for a node either carried as an attibute or as
 * the content of a child.
 */
692 693
static void
xml_set_color_value (xmlNodePtr node, const char *name, StyleColor *val)
694
{
695
	char *ret;
696 697 698 699 700 701
	xmlNodePtr child;
	char str[101];

	snprintf (str, 100, "%X:%X:%X", val->color.red, val->color.green, val->color.blue);
	ret = xmlGetProp (node, name);
	if (ret != NULL){
702
		xmlFree (ret);
703 704 705 706 707 708 709 710 711 712 713 714
		xmlSetProp (node, name, str);
		return;
	}
	child = node->childs;
	while (child != NULL){
		if (!strcmp (child->name, name)){
			xmlNodeSetContent (child, str);
			return;
		}
		child = child->next;
	}
	xmlSetProp (node, name, str);
715
}
716 717 718 719 720

/**
 **
 ** Private functions : mapping between in-memory structure and XML tree
 **
721
 **/
722

723 724
static int
style_is_default_fore (StyleColor *color)
725
{
726 727
	if (!color)
		return TRUE;
728

729 730 731 732
	if (color->color.red == 0 && color->color.green == 0 && color->color.blue == 0)
		return TRUE;
	else
		return FALSE;
733 734
}

735 736
static int
style_is_default_back (StyleColor *color)
737
{
738 739
	if (!color)
		return TRUE;
740

741 742 743 744
	if (color->color.red == 0xffff && color->color.green == 0xffff && color->color.blue == 0xffff)
		return TRUE;
	else
		return FALSE;
745 746 747 748 749
}

/*
 * Create an XML subtree of doc equivalent to the given StyleBorder.
 */
750

Michael Meeks's avatar
Michael Meeks committed
751
static char *StyleSideNames[6] =
752 753 754 755
{
 	"Top",
 	"Bottom",
 	"Left",
Michael Meeks's avatar
Michael Meeks committed
756 757 758
 	"Right",
	"Diagonal",
	"Rev-Diagonal"
Arturo Espinosa's avatar
Arturo Espinosa committed
759
};
760

761
static xmlNodePtr
762 763
xml_write_style_border (parse_xml_context_t *ctxt,
			const MStyle *style)
764 765 766
{
	xmlNodePtr cur;
	xmlNodePtr side;
767
	int        i;
768

769 770 771
	for (i = MSTYLE_BORDER_TOP; i <= MSTYLE_BORDER_REV_DIAGONAL; i++) {
		MStyleBorder const *border;
		if (mstyle_is_element_set (style, i) &&
772
		    NULL != (border = mstyle_get_border (style, i))) {
Arturo Espinosa's avatar
Arturo Espinosa committed
773
			break;
774
		}
775
	}
776
	if (i > MSTYLE_BORDER_REV_DIAGONAL)
Arturo Espinosa's avatar
Arturo Espinosa committed
777
		return NULL;
778

779
	cur = xmlNewDocNode (ctxt->doc, ctxt->ns, "StyleBorder", NULL);
780

Michael Meeks's avatar
Michael Meeks committed
781
	for (i = MSTYLE_BORDER_TOP; i <= MSTYLE_BORDER_REV_DIAGONAL; i++) {
Jody Goldberg's avatar
Jody Goldberg committed
782 783
		MStyleBorder const *border;
		if (mstyle_is_element_set (style, i) &&
784
		    NULL != (border = mstyle_get_border (style, i))) {
Jody Goldberg's avatar
Jody Goldberg committed
785 786
			StyleBorderType t = border->line_type;
			StyleColor *col   = border->color;
787 788
 			side = xmlNewChild (cur, ctxt->ns,
					    StyleSideNames [i - MSTYLE_BORDER_TOP],
789
 					    NULL);
790
 			xml_set_color_value (side, "Color", col);
791
			xml_set_value_int (side, "Style", t);
792
 		}
793 794
	}
	return cur;
795 796 797 798 799
}

/*
 * Create a StyleBorder equivalent to the XML subtree of doc.
 */
800
static void
801
xml_read_style_border (parse_xml_context_t *ctxt, xmlNodePtr tree, MStyle *mstyle)
802 803
{
	xmlNodePtr side;
804
	int        i;
805 806 807

	if (strcmp (tree->name, "StyleBorder")){
		fprintf (stderr,
808
			 "xml_read_style_border: invalid element type %s, 'StyleBorder' expected`\n",
809 810
			 tree->name);
	}
811

Michael Meeks's avatar
Michael Meeks committed
812
	for (i = MSTYLE_BORDER_TOP; i <= MSTYLE_BORDER_REV_DIAGONAL; i++) {
813 814
 		if ((side = xml_search_child (tree,
					      StyleSideNames [i - MSTYLE_BORDER_TOP])) != NULL) {
815 816 817 818 819
			int		 t;
			StyleColor      *color = NULL;
			MStyleBorder    *border;
			xml_get_value_int (side, "Style", &t);
			xml_get_color_value (side, "Color", &color);
820
			border = style_border_fetch ((StyleBorderType)t, color,
Michael Meeks's avatar
Michael Meeks committed
821
						     style_border_get_orientation (i));
822 823
			if (border)
				mstyle_set_border (mstyle, i, border);
824
 		}
825
	}
826 827 828 829 830
}

/*
 * Create an XML subtree of doc equivalent to the given Style.
 */
831
static xmlNodePtr
832 833
xml_write_style (parse_xml_context_t *ctxt,
		 MStyle *style)
834
{
835
	xmlNodePtr  cur, child;
836
	char       *tstr;
837

838
	cur = xmlNewDocNode (ctxt->doc, ctxt->ns, "Style", NULL);
839

840 841 842 843 844 845 846 847 848 849 850 851
	if (mstyle_is_element_set (style, MSTYLE_ALIGN_H))
		xml_set_value_int (cur, "HAlign", mstyle_get_align_h (style));
	if (mstyle_is_element_set (style, MSTYLE_ALIGN_V))
		xml_set_value_int (cur, "VAlign", mstyle_get_align_v (style));
	if (mstyle_is_element_set (style, MSTYLE_FIT_IN_CELL))
		xml_set_value_int (cur, "Fit", mstyle_get_fit_in_cell (style));
	if (mstyle_is_element_set (style, MSTYLE_ORIENTATION))
		xml_set_value_int (cur, "Orient", mstyle_get_orientation (style));
	if (mstyle_is_element_set (style, MSTYLE_PATTERN))
		xml_set_value_int (cur, "Shade", mstyle_get_pattern (style));

	if (mstyle_is_element_set (style, MSTYLE_COLOR_FORE)) {
852
/*		if (!style_is_default_fore (mstyle_get_color (style, MSTYLE_COLOR_FORE)))*/
853 854 855
			xml_set_color_value (cur, "Fore", mstyle_get_color (style, MSTYLE_COLOR_FORE));
	}
	if (mstyle_is_element_set (style, MSTYLE_COLOR_BACK)) {
856
/*		if (!style_is_default_back (mstyle_get_color (style, MSTYLE_COLOR_BACK)))*/
857 858
			xml_set_color_value (cur, "Back", mstyle_get_color (style, MSTYLE_COLOR_BACK));
	}
859
	if (mstyle_is_element_set (style, MSTYLE_COLOR_PATTERN)) {
860
/*		if (!style_is_default_back (mstyle_get_color (style, MSTYLE_COLOR_PATTERN)))*/
861 862
			xml_set_color_value (cur, "PatternColor", mstyle_get_color (style, MSTYLE_COLOR_PATTERN));
	}
863 864 865 866 867 868 869 870 871 872 873 874 875
	if (mstyle_is_element_set (style, MSTYLE_FORMAT))
		xml_set_value (cur, "Format", mstyle_get_format (style)->format);

	if (mstyle_is_element_set (style, MSTYLE_FONT_NAME) ||
	    mstyle_is_element_set (style, MSTYLE_FONT_BOLD) ||
	    mstyle_is_element_set (style, MSTYLE_FONT_ITALIC) ||
	    mstyle_is_element_set (style, MSTYLE_FONT_SIZE)) {
		const char *fontname;

		if (mstyle_is_element_set (style, MSTYLE_FONT_NAME))
			fontname = mstyle_get_font_name (style);
		else /* backwards compatibility */
			fontname = "Helvetica";
876

877 878 879 880
		tstr = xmlEncodeEntitiesReentrant (ctxt->doc, fontname);
		child = xmlNewChild (cur, ctxt->ns, "Font", tstr);
		if (tstr) xmlFree (tstr);

881 882 883 884 885 886 887 888 889
		if (mstyle_is_element_set (style, MSTYLE_FONT_SIZE))
			xml_set_value_double (child, "Unit",
					      mstyle_get_font_size (style));
		if (mstyle_is_element_set (style, MSTYLE_FONT_BOLD))
			xml_set_value_int (child, "Bold",
					   mstyle_get_font_bold (style));
		if (mstyle_is_element_set (style, MSTYLE_FONT_ITALIC))
			xml_set_value_int (child, "Italic",
					   mstyle_get_font_italic (style));
Jody Goldberg's avatar
Jody Goldberg committed
890 891 892
		if (mstyle_is_element_set (style, MSTYLE_FONT_UNDERLINE))
			xml_set_value_int (child, "Underline",
					   (int)mstyle_get_font_uline (style));
893 894 895
		if (mstyle_is_element_set (style, MSTYLE_FONT_STRIKETHROUGH))
			xml_set_value_int (child, "StrikeThrough",
					   mstyle_get_font_strike (style));
896 897 898 899 900
	}

	child = xml_write_style_border (ctxt, style);
	if (child)
		xmlAddChild (cur, child);
901 902

	return cur;
903 904
}

905
static xmlNodePtr
906
xml_write_names (parse_xml_context_t *ctxt, GList *names)
907
{
908
	xmlNodePtr  cur;
909
	char       *tstr;
910 911 912 913 914 915 916 917 918 919 920 921 922 923

	if (!names)
		return NULL;

	cur = xmlNewDocNode (ctxt->doc, ctxt->ns, "Names", NULL);

	while (names) {
		xmlNodePtr   tmp;
		ExprName    *expr_name = names->data;
		char        *text;

		g_return_val_if_fail (expr_name != NULL, NULL);

		tmp = xmlNewDocNode (ctxt->doc, ctxt->ns, "Name", NULL);
924 925 926
		tstr = xmlEncodeEntitiesReentrant (ctxt->doc, expr_name->name->str);
		xmlNewChild (tmp, ctxt->ns, "name", tstr);
		if (tstr) xmlFree (tstr);
927 928

		text = expr_name_value (expr_name);
929 930 931
		tstr = xmlEncodeEntitiesReentrant (ctxt->doc, text);
		xmlNewChild (tmp, ctxt->ns, "value", tstr);
		if (tstr) xmlFree (tstr);
932 933 934 935 936
		g_free (text);

		xmlAddChild (cur, tmp);
		names = g_list_next (names);
	}
937

938 939 940 941
	return cur;
}

static void
942 943
xml_read_names (parse_xml_context_t *ctxt, xmlNodePtr tree, Workbook *wb,
		Sheet *sheet)
944 945 946 947 948 949 950 951
{
	xmlNodePtr child;

	g_return_if_fail (ctxt != NULL);
	g_return_if_fail (tree != NULL);

	child = tree->childs;
	while (child) {
952
		char *name  = NULL;
953 954 955 956 957
		if (child->name && !strcmp (child->name, "Name")) {
			xmlNodePtr bits;

			bits = child->childs;
			while (bits) {
958

959 960 961 962 963 964 965 966 967 968 969
				if (!strcmp (bits->name, "name")) {
					name = xmlNodeGetContent (bits);
				} else {
					char     *txt;
					char     *error;
					g_return_if_fail (name != NULL);

					txt = xmlNodeGetContent (bits);
					g_return_if_fail (txt != NULL);
					g_return_if_fail (!strcmp (bits->name, "value"));

970
					if (!expr_name_create (wb, sheet, name, txt, &error))
971 972
						g_warning (error);

Daniel Veillard's avatar
Daniel Veillard committed
973
					xmlFree (txt);
974
				}
975
				bits = bits->next;
976 977 978 979 980 981
			}
		}
		child = child->next;
	}
}

982
static xmlNodePtr
983
xml_write_summary (parse_xml_context_t *ctxt, SummaryInfo *summary_info)
984 985
{
	GList *items, *m;
986
	char *tstr;
987 988
	xmlNodePtr cur;

989
	if (!summary_info)
990 991
		return NULL;

992
	m = items = summary_info_as_list (summary_info);
993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005

	if (!items)
		return NULL;

	cur = xmlNewDocNode (ctxt->doc, ctxt->ns, "Summary", NULL);

	while (items) {
		xmlNodePtr   tmp;
		SummaryItem *sit = items->data;
		if (sit) {
			char *text;

			tmp = xmlNewDocNode (ctxt->doc, ctxt->ns, "Item", NULL);
1006 1007 1008
			tstr = xmlEncodeEntitiesReentrant (ctxt->doc, sit->name);
			xmlNewChild (tmp, ctxt->ns, "name", tstr);
			if (tstr) xmlFree (tstr);
1009 1010 1011

			if (sit->type == SUMMARY_INT) {
				text = g_strdup_printf ("%d", sit->v.i);
1012 1013 1014
				tstr = xmlEncodeEntitiesReentrant (ctxt->doc, text);
				xmlNewChild (tmp, ctxt->ns, "val-int", tstr);
				if (tstr) xmlFree (tstr);
1015 1016
			} else {
				text = summary_item_as_text (sit);
1017 1018 1019
				tstr = xmlEncodeEntitiesReentrant (ctxt->doc, text);
				xmlNewChild (tmp, ctxt->ns, "val-string", tstr);
				if (tstr) xmlFree (tstr);
1020 1021
			}
			g_free (text);
1022
			xmlAddChild (cur, tmp);
1023 1024 1025 1026 1027 1028 1029 1030
		}
		items = g_list_next (items);
	}
	g_list_free (m);
	return cur;
}

static void
1031
xml_read_summary (parse_xml_context_t *ctxt, xmlNodePtr tree, SummaryInfo *summary_info)
1032
{
1033
	xmlNodePtr child;
1034

1035 1036 1037
	g_return_if_fail (ctxt != NULL);
	g_return_if_fail (tree != NULL);
	g_return_if_fail (summary_info != NULL);
1038 1039 1040

	child = tree->childs;
	while (child) {
1041
		char *name = NULL;
Miguel de Icaza's avatar
Miguel de Icaza committed
1042

1043 1044 1045 1046 1047 1048
		if (child->name && !strcmp (child->name, "Item")) {
			xmlNodePtr bits;

			bits = child->childs;
			while (bits) {
				SummaryItem *sit = NULL;
1049

1050
				if (!strcmp (bits->name, "name")) {
1051
					name = xmlNodeGetContent (bits);
1052 1053 1054 1055 1056
				} else {
					char *txt;
					g_return_if_fail (name);

					txt = xmlNodeGetContent (bits);
1057 1058 1059 1060
					if (txt != NULL){
						if (!strcmp (bits->name, "val-string"))
							sit = summary_item_new_string (name, txt);
						else if (!strcmp (bits->name, "val-int"))
Miguel de Icaza's avatar
Miguel de Icaza committed
1061
							sit = summary_item_new_int (name, atoi (txt));
1062

1063
						if (sit)
1064
							summary_info_add (summary_info, sit);
Daniel Veillard's avatar
Daniel Veillard committed
1065
						xmlFree (txt);
1066
					}
1067
				}
1068
				bits = bits->next;
1069 1070
			}
		}
Miguel de Icaza's avatar
Miguel de Icaza committed
1071
		if (name){
1072
			xmlFree (name);
Miguel de Icaza's avatar
Miguel de Icaza committed
1073 1074
			name = NULL;
		}
1075 1076 1077 1078
		child = child->next;
	}
}

Michael Meeks's avatar
Michael Meeks committed
1079 1080 1081 1082 1083 1084 1085 1086 1087 1088
static void
xml_set_print_hf (xmlNodePtr node, const char *name,
		  const PrintHF * const hf)
{
	xmlNodePtr  child;

	if (hf == NULL || name == NULL)
		return;

	child = xmlNewChild (node, NULL, name, NULL);
1089 1090 1091
	xml_set_value (child, "Left", hf->left_format);
	xml_set_value (child, "Middle", hf->middle_format);
	xml_set_value (child, "Right", hf->right_format);
Michael Meeks's avatar
Michael Meeks committed
1092 1093 1094
}

static void
Arturo Espinosa's avatar
Arturo Espinosa committed
1095
xml_get_print_hf (xmlNodePtr node, PrintHF *const hf)
Michael Meeks's avatar
Michael Meeks committed
1096 1097
{
	char *txt;
1098

Michael Meeks's avatar
Michael Meeks committed
1099 1100 1101 1102
	g_return_if_fail (hf != NULL);
	g_return_if_fail (node != NULL);

	txt = xml_value_get (node, "Left");
1103
	if (txt) {
Arturo Espinosa's avatar
Arturo Espinosa committed
1104 1105
		if (hf->left_format)
			g_free (hf->left_format);
1106
		hf->left_format = txt;
Arturo Espinosa's avatar
Arturo Espinosa committed
1107
	}
1108

Michael Meeks's avatar
Michael Meeks committed
1109
	txt = xml_value_get (node, "Middle");
1110
	if (txt) {
Arturo Espinosa's avatar
Arturo Espinosa committed
1111 1112
		if (hf->middle_format)
			g_free (hf->middle_format);
1113
		hf->middle_format = txt;
Arturo Espinosa's avatar
Arturo Espinosa committed
1114
	}
Michael Meeks's avatar
Michael Meeks committed
1115 1116

	txt = xml_value_get (node, "Right");
1117
	if (txt) {
Arturo Espinosa's avatar
Arturo Espinosa committed
1118 1119
		if (hf->right_format)
			g_free (hf->right_format);
1120
		hf->right_format = txt;
Arturo Espinosa's avatar
Arturo Espinosa committed
1121
	}
Michael Meeks's avatar
Michael Meeks committed
1122 1123
}

1124 1125 1126 1127