/[public]/psiconv/trunk/lib/psiconv/data.c
ViewVC logotype

Annotation of /psiconv/trunk/lib/psiconv/data.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 159 - (hide annotations)
Wed Nov 19 21:04:06 2003 UTC (20 years, 4 months ago) by frodo
File MIME type: text/plain
File size: 39465 byte(s)
(Frodo) Data structures for (Word) objects created.

1 frodo 2 /*
2     data.c - Part of psiconv, a PSION 5 file formats converter
3 frodo 63 Copyright (c) 1999, 2000 Frodo Looijaard <frodol@dds.nl>
4 frodo 2
5     This program is free software; you can redistribute it and/or modify
6     it under the terms of the GNU General Public License as published by
7     the Free Software Foundation; either version 2 of the License, or
8     (at your option) any later version.
9    
10     This program is distributed in the hope that it will be useful,
11     but WITHOUT ANY WARRANTY; without even the implied warranty of
12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13     GNU General Public License for more details.
14    
15     You should have received a copy of the GNU General Public License
16     along with this program; if not, write to the Free Software
17     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18     */
19    
20     #include "config.h"
21 frodo 20 #include "compat.h"
22 frodo 2 #include <stdlib.h>
23     #include <string.h>
24     #include "data.h"
25 frodo 87 #include "list.h"
26 frodo 2
27 frodo 142 #ifdef DMALLOC
28     #include <dmalloc.h>
29     #endif
30    
31 frodo 2 static psiconv_color clone_color(psiconv_color color);
32     static psiconv_font clone_font(psiconv_font font);
33     static psiconv_border clone_border(psiconv_border border);
34     static psiconv_bullet clone_bullet(psiconv_bullet bullet);
35     static psiconv_all_tabs clone_all_tabs(psiconv_all_tabs all_tabs);
36     static void psiconv_free_style_aux(void *style);
37     static void psiconv_free_in_line_layout_aux(void * layout);
38     static void psiconv_free_paragraph_aux(void * paragraph);
39 frodo 12 static void psiconv_free_paint_data_section_aux(void * section);
40 frodo 42 static void psiconv_free_clipart_section_aux(void * section);
41 frodo 99 static void psiconv_free_formula_aux(void *data);
42 frodo 111 static void psiconv_free_sheet_worksheet_aux (void *data);
43 frodo 129 static void psiconv_free_sheet_variable_aux(void * variable);
44 frodo 2
45 frodo 87 static psiconv_word_styles_section psiconv_empty_word_styles_section(void);
46     static psiconv_text_and_layout psiconv_empty_text_and_layout(void);
47     static psiconv_texted_section psiconv_empty_texted_section(void);
48     static psiconv_page_header psiconv_empty_page_header(void);
49     static psiconv_page_layout_section psiconv_empty_page_layout_section(void);
50     static psiconv_word_status_section psiconv_empty_word_status_section(void);
51     static psiconv_word_f psiconv_empty_word_f(void);
52 frodo 94 static psiconv_sheet_status_section psiconv_empty_sheet_status_section(void);
53 frodo 98 static psiconv_formula_list psiconv_empty_formula_list(void);
54 frodo 95 static psiconv_sheet_workbook_section
55     psiconv_empty_sheet_workbook_section(void);
56 frodo 94 static psiconv_sheet_f psiconv_empty_sheet_f(void);
57 frodo 87 static psiconv_texted_f psiconv_empty_texted_f(void);
58     static psiconv_paint_data_section psiconv_empty_paint_data_section(void);
59     static psiconv_pictures psiconv_empty_pictures(void);
60     static psiconv_mbm_f psiconv_empty_mbm_f(void);
61     static psiconv_sketch_section psiconv_empty_sketch_section(void);
62     static psiconv_sketch_f psiconv_empty_sketch_f(void);
63     static psiconv_clipart_f psiconv_empty_clipart_f(void);
64     static psiconv_cliparts psiconv_empty_cliparts(void);
65    
66    
67 frodo 69 /* Note: these defaults seem to be hard-coded somewhere outside the
68     files themself. */
69 frodo 2 psiconv_character_layout psiconv_basic_character_layout(void)
70     {
71 frodo 20 /* Make the structures static, to oblige IRIX */
72 frodo 56 static struct psiconv_color_s black =
73 frodo 2 {
74     0x00, /* red */
75     0x00, /* green */
76     0x00, /* blue */
77     };
78 frodo 56 static struct psiconv_color_s white =
79 frodo 2 {
80     0xff, /* red */
81     0xff, /* green */
82     0xff, /* blue */
83     };
84 frodo 56 static struct psiconv_font_s font =
85 frodo 20 {
86     "Times New Roman", /* name */
87     3 /* screenfont */
88     };
89 frodo 56 struct psiconv_character_layout_s cl =
90 frodo 2 {
91     &black, /* color */
92     &white, /* back_color */
93     10.0, /* font_size */
94     psiconv_bool_false, /* italic */
95     psiconv_bool_false, /* bold */
96     psiconv_normalscript, /* super_sub */
97     psiconv_bool_false, /* underline */
98 frodo 67 psiconv_bool_false, /* strikethrough */
99 frodo 24 &font, /* font */
100 frodo 2 };
101    
102     return psiconv_clone_character_layout(&cl);
103     }
104    
105 frodo 69 /* Note: these defaults seem to be hard-coded somewhere outside the
106     files themself. */
107 frodo 2 psiconv_paragraph_layout psiconv_basic_paragraph_layout(void)
108     {
109 frodo 56 static struct psiconv_font_s font =
110 frodo 2 {
111 frodo 20 "Times New Roman", /* name */
112 frodo 2 2 /* screenfont */
113     };
114 frodo 56 static struct psiconv_color_s black =
115 frodo 2 {
116     0x00, /* red */
117     0x00, /* green */
118     0x00, /* blue */
119     };
120 frodo 56 static struct psiconv_color_s white =
121 frodo 2 {
122     0xff, /* red */
123     0xff, /* green */
124     0xff, /* blue */
125     };
126 frodo 56 static struct psiconv_border_s no_border =
127 frodo 2 {
128     psiconv_border_none, /* kind */
129     1, /* thickness */
130     &black /* color */
131     };
132 frodo 56 static struct psiconv_bullet_s bullet =
133 frodo 2 {
134     psiconv_bool_false, /* on */
135     10.0, /* font_size */
136     0x95, /* character */
137     psiconv_bool_true, /* indent */
138     &black, /* color */
139     &font, /* font */
140     };
141 frodo 56 static struct psiconv_all_tabs_s tabs =
142 frodo 2 {
143     0.64, /* normal */
144     NULL /* kind */
145     };
146 frodo 56 struct psiconv_paragraph_layout_s pl =
147 frodo 2 {
148     &white, /* back_color */
149     0.0, /* indent_left */
150     0.0, /* indent_right */
151     0.0, /* indent_first */
152     psiconv_justify_left, /* justify_hor */
153     psiconv_justify_middle,/* justify_ver */
154 frodo 69 10.0, /* linespacing */
155 frodo 67 psiconv_bool_false, /* linespacing_exact */
156     0.0, /* space_above */
157     0.0, /* space_below */
158     psiconv_bool_false, /* keep_together */
159     psiconv_bool_false, /* keep_with_next */
160 frodo 2 psiconv_bool_false, /* on_next_page */
161     psiconv_bool_false, /* no_widow_protection */
162 frodo 104 psiconv_bool_false, /* wrap_to_fit_cell */
163 frodo 2 0.0, /* left_margin */
164     &bullet, /* bullet */
165     &no_border, /* left_border */
166     &no_border, /* right_border */
167     &no_border, /* top_border */
168     &no_border, /* bottom_border */
169     &tabs, /* tabs */
170     };
171     psiconv_paragraph_layout res;
172    
173 frodo 62 if (!(pl.tabs->extras = psiconv_list_new(sizeof(struct psiconv_tab_s))))
174     return NULL;
175 frodo 2 res = psiconv_clone_paragraph_layout(&pl);
176     psiconv_list_free(pl.tabs->extras);
177     return res;
178     }
179    
180     psiconv_color clone_color(psiconv_color color)
181     {
182     psiconv_color result;
183 frodo 62 if (!(result = malloc(sizeof(*result))))
184     return NULL;
185 frodo 2 *result = *color;
186     return result;
187     }
188    
189     psiconv_font clone_font(psiconv_font font)
190     {
191     psiconv_font result;
192 frodo 62 if(!(result = malloc(sizeof(*result))))
193     goto ERROR1;
194 frodo 2 *result = *font;
195 frodo 62 if (!(result->name = strdup(result->name)))
196     goto ERROR2;
197 frodo 2 return result;
198 frodo 62 ERROR2:
199     free(result);
200     ERROR1:
201     return NULL;
202 frodo 2 }
203    
204     psiconv_border clone_border(psiconv_border border)
205     {
206     psiconv_border result;
207 frodo 62 if (!(result = malloc(sizeof(*result))))
208     goto ERROR1;
209 frodo 2 *result = *border;
210 frodo 62 if(!(result->color = clone_color(result->color)))
211     goto ERROR2;
212 frodo 2 return result;
213 frodo 62 ERROR2:
214     free(result);
215     ERROR1:
216     return NULL;
217 frodo 2 }
218    
219     psiconv_bullet clone_bullet(psiconv_bullet bullet)
220     {
221     psiconv_bullet result;
222 frodo 62 if (!(result = malloc(sizeof(*result))))
223     goto ERROR1;
224 frodo 2 *result = *bullet;
225 frodo 62 if (!(result->font = clone_font(result->font)))
226     goto ERROR2;
227     if (!(result->color = clone_color(result->color)))
228     goto ERROR3;
229 frodo 2 return result;
230 frodo 62 ERROR3:
231     psiconv_free_font(result->font);
232     ERROR2:
233     free(result);
234     ERROR1:
235     return NULL;
236 frodo 2 }
237    
238     psiconv_all_tabs clone_all_tabs(psiconv_all_tabs all_tabs)
239     {
240     psiconv_all_tabs result;
241 frodo 62 if (!(result = malloc(sizeof(*result))))
242     goto ERROR1;
243 frodo 2 *result = *all_tabs;
244 frodo 62 if (!(result->extras = psiconv_list_clone(result->extras)))
245     goto ERROR2;
246 frodo 2 return result;
247 frodo 62 ERROR2:
248     free(result);
249     ERROR1:
250     return NULL;
251 frodo 2 }
252    
253     psiconv_character_layout psiconv_clone_character_layout
254     (psiconv_character_layout ls)
255     {
256     psiconv_character_layout result;
257    
258 frodo 62 if (!(result = malloc(sizeof(*result))))
259     goto ERROR1;
260 frodo 2 *result = *ls;
261 frodo 62 if (!(result->color = clone_color(result->color)))
262     goto ERROR2;
263     if (!(result->back_color = clone_color(result->back_color)))
264     goto ERROR3;
265     if (!(result->font = clone_font(result->font)))
266     goto ERROR4;
267 frodo 2 return result;
268 frodo 62 ERROR4:
269     psiconv_free_color(result->back_color);
270     ERROR3:
271     psiconv_free_color(result->color);
272     ERROR2:
273     free(result);
274     ERROR1:
275     return NULL;
276 frodo 2 }
277    
278     psiconv_paragraph_layout psiconv_clone_paragraph_layout
279     (psiconv_paragraph_layout ls)
280     {
281     psiconv_paragraph_layout result;
282    
283 frodo 62 if (!(result = malloc(sizeof(*result))))
284     goto ERROR1;
285 frodo 2 *result = *ls;
286 frodo 62 if (!(result->back_color = clone_color(result->back_color)))
287     goto ERROR2;
288     if (!(result->bullet = clone_bullet(result->bullet)))
289     goto ERROR3;
290     if (!(result->left_border = clone_border(result->left_border)))
291     goto ERROR4;
292     if (!(result->right_border = clone_border(result->right_border)))
293     goto ERROR5;
294     if (!(result->top_border = clone_border(result->top_border)))
295     goto ERROR6;
296     if (!(result->bottom_border = clone_border(result->bottom_border)))
297     goto ERROR7;
298     if (!(result->tabs = clone_all_tabs(result->tabs)))
299     goto ERROR8;
300 frodo 2 return result;
301 frodo 62 ERROR8:
302     psiconv_free_border(result->bottom_border);
303     ERROR7:
304     psiconv_free_border(result->top_border);
305     ERROR6:
306     psiconv_free_border(result->right_border);
307     ERROR5:
308     psiconv_free_border(result->left_border);
309     ERROR4:
310     psiconv_free_bullet(result->bullet);
311     ERROR3:
312     psiconv_free_color(result->back_color);
313     ERROR2:
314     free(result);
315     ERROR1:
316     return NULL;
317 frodo 2 }
318    
319     psiconv_word_style psiconv_get_style (psiconv_word_styles_section ss, int nr)
320     {
321     if (nr == 0)
322     return ss->normal;
323     else
324     return psiconv_list_get(ss->styles,0xff - nr);
325     }
326    
327 frodo 125 psiconv_formula psiconv_get_formula (psiconv_formula_list ss, int nr)
328     {
329     return psiconv_list_get(ss,psiconv_list_length(ss)-nr-1);
330     }
331    
332 frodo 128 /* TODO: What if a cell is both in a default row and a default column?!? */
333     psiconv_sheet_cell_layout psiconv_get_default_layout
334     (psiconv_sheet_line_list row_defaults,
335     psiconv_sheet_line_list col_defaults,
336     psiconv_sheet_cell_layout cell_default,
337     int row,int col)
338     {
339     int i;
340     psiconv_sheet_line line;
341     for (i = 0;i < psiconv_list_length(row_defaults);i++) {
342     line = psiconv_list_get(row_defaults,i);
343     if (line->position == row)
344     return line->layout;
345     }
346     for (i = 0;i < psiconv_list_length(col_defaults);i++) {
347     line = psiconv_list_get(col_defaults,i);
348     if (line->position == col)
349     return line->layout;
350     }
351     return cell_default;
352     }
353 frodo 125
354 frodo 128
355 frodo 2 void psiconv_free_color (psiconv_color color)
356     {
357     if (color)
358     free(color);
359     }
360    
361     void psiconv_free_border(psiconv_border border)
362     {
363     if (border) {
364     psiconv_free_color(border->color);
365     free(border);
366     }
367     }
368    
369     void psiconv_free_font(psiconv_font font)
370     {
371     if (font) {
372     if (font->name)
373     free(font->name);
374     free(font);
375     }
376     }
377    
378     void psiconv_free_bullet(psiconv_bullet bullet)
379     {
380     if (bullet) {
381     psiconv_free_color(bullet->color);
382     psiconv_free_font(bullet->font);
383     free(bullet);
384     }
385     }
386    
387     void psiconv_free_character_layout(psiconv_character_layout layout)
388     {
389     if (layout) {
390     psiconv_free_color(layout->color);
391     psiconv_free_color(layout->back_color);
392     psiconv_free_font(layout->font);
393     free(layout);
394     }
395     }
396    
397     void psiconv_free_tab(psiconv_tab tab)
398     {
399     if (tab)
400     free(tab);
401     }
402    
403     void psiconv_free_tabs(psiconv_all_tabs tabs)
404     {
405     if (tabs) {
406     psiconv_list_free(tabs->extras);
407     free(tabs);
408     }
409     }
410    
411     void psiconv_free_paragraph_layout(psiconv_paragraph_layout layout)
412     {
413     if (layout) {
414     psiconv_free_color(layout->back_color);
415     psiconv_free_bullet(layout->bullet);
416     psiconv_free_border(layout->left_border);
417     psiconv_free_border(layout->right_border);
418     psiconv_free_border(layout->top_border);
419     psiconv_free_border(layout->bottom_border);
420     psiconv_free_tabs(layout->tabs);
421     free(layout);
422     }
423     }
424    
425     void psiconv_free_style_aux(void *style)
426     {
427     if(((psiconv_word_style) style)->name)
428     free(((psiconv_word_style) style)->name);
429     psiconv_free_character_layout(((psiconv_word_style) style)->character);
430     psiconv_free_paragraph_layout(((psiconv_word_style) style)->paragraph);
431     }
432    
433     void psiconv_free_word_style(psiconv_word_style style)
434     {
435     if (style) {
436     psiconv_free_style_aux(style);
437     free(style);
438     }
439     }
440    
441     void psiconv_free_word_styles_section(psiconv_word_styles_section styles)
442     {
443     if (styles) {
444     psiconv_free_word_style(styles->normal);
445     if (styles->styles)
446     psiconv_list_free_el(styles->styles,psiconv_free_style_aux);
447 frodo 143 free(styles);
448 frodo 2 }
449     }
450    
451     void psiconv_free_header_section(psiconv_header_section header)
452     {
453     if (header)
454     free(header);
455     }
456    
457     void psiconv_free_section_table_entry(psiconv_section_table_entry entry)
458     {
459     if (entry)
460     free(entry);
461     }
462    
463     void psiconv_free_section_table_section(psiconv_section_table_section section)
464     {
465     if (section)
466     psiconv_list_free(section);
467     }
468    
469     void psiconv_free_application_id_section(psiconv_application_id_section section)
470     {
471     if (section) {
472     if (section->name)
473     free(section->name);
474     free(section);
475     }
476     }
477    
478 frodo 159 void psiconv_free_object_icon_section(psiconv_object_icon_section section)
479     {
480     if (section) {
481     if (section->icon_name)
482     free(section->icon_name);
483     free(section);
484     }
485     }
486    
487     void psiconv_free_object_display_section(psiconv_object_display_section section)
488     {
489     if (section)
490     free(section);
491     }
492    
493     void psiconv_free_object(psiconv_object object)
494     {
495     if (object) {
496     psiconv_free_object_icon_section(object->icon);
497     psiconv_free_object_display_section(object->display);
498     psiconv_free_file(object->object);
499     free(object);
500     }
501     }
502    
503 frodo 2 void psiconv_free_in_line_layout_aux(void * layout)
504     {
505     psiconv_free_character_layout(((psiconv_in_line_layout) layout)->layout);
506 frodo 159 psiconv_free_object(((psiconv_in_line_layout) layout)->object);
507 frodo 2 }
508    
509     void psiconv_free_in_line_layout(psiconv_in_line_layout layout)
510     {
511     if (layout) {
512     psiconv_free_in_line_layout_aux(layout);
513     free(layout);
514     }
515     }
516    
517     void psiconv_free_in_line_layouts(psiconv_in_line_layouts layouts)
518     {
519     if (layouts)
520     psiconv_list_free_el(layouts,&psiconv_free_in_line_layout_aux);
521     }
522    
523     void psiconv_free_replacement(psiconv_replacement replacement)
524     {
525     if (replacement)
526     free(replacement);
527     }
528    
529     void psiconv_free_replacements(psiconv_replacements replacements)
530     {
531     if (replacements)
532     psiconv_list_free(replacements);
533     }
534    
535     void psiconv_free_paragraph_aux(void * paragraph)
536     {
537     if(((psiconv_paragraph) paragraph)->text)
538     free(((psiconv_paragraph) paragraph)->text);
539     psiconv_free_character_layout(((psiconv_paragraph) paragraph)
540     ->base_character);
541     psiconv_free_paragraph_layout(((psiconv_paragraph) paragraph)
542     ->base_paragraph);
543     psiconv_free_in_line_layouts(((psiconv_paragraph) paragraph)
544     ->in_lines);
545     psiconv_free_replacements(((psiconv_paragraph) paragraph)
546     ->replacements);
547     }
548    
549     void psiconv_free_paragraph(psiconv_paragraph paragraph)
550     {
551     if (paragraph) {
552     psiconv_free_paragraph_aux(paragraph);
553     free(paragraph);
554     }
555     }
556    
557     void psiconv_free_text_and_layout(psiconv_text_and_layout text)
558     {
559     if (text)
560     psiconv_list_free_el(text,&psiconv_free_paragraph_aux);
561     }
562    
563     void psiconv_free_texted_section(psiconv_texted_section section)
564     {
565     if (section) {
566     psiconv_free_text_and_layout(section->paragraphs);
567     free(section);
568     }
569     }
570    
571     void psiconv_free_page_header(psiconv_page_header header)
572     {
573     if (header) {
574     psiconv_free_character_layout(header->base_character_layout);
575     psiconv_free_paragraph_layout(header->base_paragraph_layout);
576     psiconv_free_texted_section(header->text);
577     free(header);
578     }
579     }
580    
581     void psiconv_free_page_layout_section(psiconv_page_layout_section section)
582     {
583     if (section) {
584     psiconv_free_page_header(section->header);
585     psiconv_free_page_header(section->footer);
586     free(section);
587     }
588     }
589    
590     void psiconv_free_word_status_section(psiconv_word_status_section section)
591     {
592     if (section)
593     free(section);
594     }
595    
596     void psiconv_free_word_f(psiconv_word_f file)
597     {
598     if (file) {
599     psiconv_free_page_layout_section(file->page_sec);
600     psiconv_free_text_and_layout(file->paragraphs);
601     psiconv_free_word_status_section(file->status_sec);
602     psiconv_free_word_styles_section(file->styles_sec);
603     free(file);
604     }
605     }
606    
607 frodo 94 void psiconv_free_sheet_status_section(psiconv_sheet_status_section section)
608     {
609     if (section)
610     free(section);
611     }
612    
613 frodo 111 void psiconv_free_sheet_numberformat(psiconv_sheet_numberformat numberformat)
614 frodo 110 {
615     if (numberformat)
616     free(numberformat);
617     }
618    
619 frodo 111 void psiconv_free_sheet_cell_layout(psiconv_sheet_cell_layout layout)
620     {
621     psiconv_free_paragraph_layout(layout->paragraph);
622     psiconv_free_character_layout(layout->character);
623     psiconv_free_sheet_numberformat(layout->numberformat);
624     }
625    
626 frodo 121 void psiconv_free_sheet_cell_aux(void *cell)
627     {
628     psiconv_sheet_cell data = cell;
629    
630     psiconv_free_sheet_cell_layout(data->layout);
631    
632     if ((data->type == psiconv_cell_string) && (data->data.dat_string))
633     free(data->data.dat_string);
634     }
635    
636 frodo 110 void psiconv_free_sheet_cell(psiconv_sheet_cell cell)
637     {
638     if (cell) {
639 frodo 121 psiconv_free_sheet_cell_aux(cell);
640 frodo 111 free(cell);
641 frodo 110 }
642     }
643    
644     void psiconv_free_sheet_cell_list(psiconv_sheet_cell_list list)
645     {
646     if (list)
647     psiconv_list_free_el(list,psiconv_free_sheet_cell_aux);
648     }
649    
650 frodo 128 void psiconv_free_sheet_line_aux(void *line)
651     {
652     psiconv_sheet_line data = line;
653    
654     psiconv_free_sheet_cell_layout(data->layout);
655     }
656    
657     void psiconv_free_sheet_line(psiconv_sheet_line line)
658     {
659     if (line) {
660     psiconv_free_sheet_line_aux(line);
661     free(line);
662     }
663     }
664    
665 frodo 134
666 frodo 128 void psiconv_free_sheet_line_list(psiconv_sheet_line_list list)
667     {
668     if (list)
669     psiconv_list_free_el(list,psiconv_free_sheet_line_aux);
670     }
671    
672 frodo 134 void psiconv_free_sheet_grid_break_list(psiconv_sheet_grid_break_list list)
673     {
674     if (list)
675     psiconv_list_free(list);
676     }
677    
678     void psiconv_free_sheet_grid_size(psiconv_sheet_grid_size s)
679     {
680     if (s)
681     free(s);
682     }
683    
684     void psiconv_free_sheet_grid_size_list(psiconv_sheet_grid_size_list list)
685     {
686     if (list)
687     psiconv_list_free(list);
688     }
689    
690     void psiconv_free_sheet_grid_section(psiconv_sheet_grid_section sec)
691     {
692     if (sec) {
693     psiconv_free_sheet_grid_size_list(sec->row_heights);
694     psiconv_free_sheet_grid_size_list(sec->column_heights);
695     psiconv_free_sheet_grid_break_list(sec->row_page_breaks);
696     psiconv_free_sheet_grid_break_list(sec->column_page_breaks);
697     free(sec);
698     }
699     }
700    
701 frodo 111 void psiconv_free_sheet_worksheet_aux (void *data)
702 frodo 110 {
703 frodo 111 psiconv_sheet_worksheet section = data;
704     psiconv_free_sheet_cell_layout(section->default_layout);
705     psiconv_free_sheet_cell_list(section->cells);
706 frodo 128 psiconv_free_sheet_line_list(section->row_default_layouts);
707     psiconv_free_sheet_line_list(section->col_default_layouts);
708 frodo 134 psiconv_free_sheet_grid_section(section->grid);
709 frodo 111 }
710    
711     void psiconv_free_sheet_worksheet(psiconv_sheet_worksheet sheet)
712     {
713     if (sheet) {
714     psiconv_free_sheet_worksheet_aux(sheet);
715     free(sheet);
716 frodo 110 }
717     }
718    
719 frodo 111 void psiconv_free_sheet_worksheet_list(psiconv_sheet_worksheet_list list)
720     {
721     if (list)
722     psiconv_list_free_el(list,psiconv_free_sheet_worksheet_aux);
723     }
724    
725 frodo 99 void psiconv_free_formula_aux(void *data)
726     {
727     psiconv_formula formula;
728     formula = data;
729     if (formula->type == psiconv_formula_dat_string)
730     free(formula->data.dat_string);
731     else if ((formula->type != psiconv_formula_dat_int) &&
732     (formula->type != psiconv_formula_dat_var) &&
733     (formula->type != psiconv_formula_dat_float) &&
734     (formula->type != psiconv_formula_dat_cellref) &&
735     (formula->type != psiconv_formula_dat_cellblock) &&
736     (formula->type != psiconv_formula_dat_vcellblock) &&
737     (formula->type != psiconv_formula_mark_opsep) &&
738     (formula->type != psiconv_formula_mark_opend) &&
739     (formula->type != psiconv_formula_mark_eof) &&
740     (formula->type != psiconv_formula_unknown))
741     psiconv_free_formula_list(formula->data.fun_operands);
742     }
743    
744 frodo 98 void psiconv_free_formula(psiconv_formula formula)
745 frodo 97 {
746 frodo 99 if (formula) {
747     psiconv_free_formula_aux(formula);
748 frodo 97 free(formula);
749 frodo 99 }
750 frodo 97 }
751    
752 frodo 98 void psiconv_free_formula_list(psiconv_formula_list list)
753 frodo 97 {
754 frodo 99 if (list)
755     psiconv_list_free_el(list,psiconv_free_formula_aux);
756 frodo 97 }
757    
758 frodo 129 void psiconv_free_sheet_name_section(psiconv_sheet_name_section section)
759     {
760     if (section) {
761     if(section->name)
762     free(section->name);
763     free(section);
764     }
765     }
766    
767     void psiconv_free_sheet_info_section(psiconv_sheet_info_section section)
768     {
769     if (section) {
770     free(section);
771     }
772     }
773    
774     void psiconv_free_sheet_variable_aux(void * variable)
775     {
776     psiconv_sheet_variable var = variable;
777     if (var->name)
778     free(var->name);
779     if (var->type == psiconv_var_string)
780     free(var->data.dat_string);
781     }
782    
783     void psiconv_free_sheet_variable(psiconv_sheet_variable var)
784     {
785     if (var) {
786     psiconv_free_sheet_variable_aux(var);
787     free(var);
788     }
789     }
790    
791     void psiconv_free_sheet_variable_list(psiconv_sheet_variable_list list)
792     {
793     if (list)
794     psiconv_list_free_el(list,psiconv_free_sheet_variable_aux);
795     }
796    
797 frodo 95 void psiconv_free_sheet_workbook_section(psiconv_sheet_workbook_section section)
798     {
799 frodo 97 if (section) {
800 frodo 98 psiconv_free_formula_list(section->formulas);
801 frodo 121 psiconv_free_sheet_worksheet_list(section->worksheets);
802 frodo 129 psiconv_free_sheet_name_section(section->name);
803     psiconv_free_sheet_info_section(section->info);
804     psiconv_free_sheet_variable_list(section->variables);
805 frodo 95 free(section);
806 frodo 97 }
807 frodo 95 }
808    
809 frodo 94 void psiconv_free_sheet_f(psiconv_sheet_f file)
810     {
811     if (file) {
812     psiconv_free_page_layout_section(file->page_sec);
813     psiconv_free_sheet_status_section(file->status_sec);
814 frodo 95 psiconv_free_sheet_workbook_section(file->workbook_sec);
815 frodo 94 free(file);
816     }
817     }
818    
819 frodo 12 void psiconv_free_texted_f(psiconv_texted_f file)
820     {
821     if (file) {
822     psiconv_free_page_layout_section(file->page_sec);
823     psiconv_free_texted_section(file->texted_sec);
824     free(file);
825     }
826     }
827    
828     void psiconv_free_paint_data_section_aux(void * section)
829     {
830     if (((psiconv_paint_data_section) section)->red)
831     free(((psiconv_paint_data_section)section) -> red);
832     if (((psiconv_paint_data_section) section)->green)
833     free(((psiconv_paint_data_section)section) -> green);
834     if (((psiconv_paint_data_section) section)->blue)
835     free(((psiconv_paint_data_section)section) -> blue);
836     }
837    
838     void psiconv_free_paint_data_section(psiconv_paint_data_section section)
839     {
840     if (section) {
841     psiconv_free_paint_data_section_aux(section);
842     free(section);
843     }
844     }
845    
846     void psiconv_free_pictures(psiconv_pictures section)
847     {
848     if (section)
849     psiconv_list_free_el(section,&psiconv_free_paint_data_section_aux);
850     }
851    
852 frodo 42 void psiconv_free_jumptable_section (psiconv_jumptable_section section)
853 frodo 13 {
854     if (section)
855     psiconv_list_free(section);
856     }
857    
858 frodo 12 void psiconv_free_mbm_f(psiconv_mbm_f file)
859     {
860     if (file) {
861     psiconv_free_pictures(file->sections);
862     free(file);
863     }
864     }
865    
866 frodo 24 void psiconv_free_sketch_section(psiconv_sketch_section sec)
867     {
868     if (sec) {
869     psiconv_free_paint_data_section(sec->picture);
870     free(sec);
871     }
872     }
873    
874     void psiconv_free_sketch_f(psiconv_sketch_f file)
875     {
876     if (file) {
877     psiconv_free_sketch_section(file->sketch_sec);
878     free(file);
879     }
880     }
881    
882 frodo 42 void psiconv_free_clipart_section_aux(void *section)
883 frodo 41 {
884     if (section)
885 frodo 42 free(((psiconv_clipart_section ) section)->picture);
886 frodo 41 }
887    
888     void psiconv_free_clipart_section(psiconv_clipart_section section)
889     {
890     if (section) {
891     psiconv_free_clipart_section_aux(section);
892     free(section);
893     }
894     }
895    
896     void psiconv_free_cliparts(psiconv_cliparts section)
897     {
898     if (section)
899     psiconv_list_free_el(section,&psiconv_free_clipart_section_aux);
900     }
901    
902     void psiconv_free_clipart_f(psiconv_clipart_f file)
903     {
904     if (file) {
905     psiconv_free_cliparts(file->sections);
906     free(file);
907     }
908     }
909    
910 frodo 2 void psiconv_free_file(psiconv_file file)
911     {
912     if (file) {
913     if (file->type == psiconv_word_file)
914     psiconv_free_word_f((psiconv_word_f) file->file);
915 frodo 12 else if (file->type == psiconv_texted_file)
916     psiconv_free_texted_f((psiconv_texted_f) file->file);
917     else if (file->type == psiconv_mbm_file)
918     psiconv_free_mbm_f((psiconv_mbm_f) file->file);
919 frodo 24 else if (file->type == psiconv_sketch_file)
920     psiconv_free_sketch_f((psiconv_sketch_f) file->file);
921 frodo 41 else if (file->type == psiconv_clipart_file)
922 frodo 42 psiconv_free_clipart_f((psiconv_clipart_f) file->file);
923 frodo 94 else if (file->type == psiconv_sheet_file)
924     psiconv_free_sheet_f((psiconv_sheet_f) file->file);
925 frodo 2 free(file);
926     }
927     }
928 frodo 78
929     int psiconv_compare_color(const psiconv_color value1,
930     const psiconv_color value2)
931     {
932     if (!value1 || !value2)
933     return 1;
934     if ((value1->red == value2->red) &&
935     (value1->green == value2->green) &&
936     (value1->blue == value2->blue))
937     return 0;
938     else
939     return 1;
940     }
941    
942     int psiconv_compare_font(const psiconv_font value1,
943     const psiconv_font value2)
944     {
945     if (!value1 || !value2 || !value1->name || !value2->name)
946     return 1;
947     if ((value1->screenfont == value2->screenfont) &&
948     !strcmp(value1->name,value2->name))
949     return 0;
950     else
951     return 1;
952     }
953    
954     int psiconv_compare_border(const psiconv_border value1,
955     const psiconv_border value2)
956     {
957     if (!value1 || !value2)
958     return 1;
959     if ((value1->kind == value2->kind) &&
960     (value1->thickness == value2->thickness) &&
961     !psiconv_compare_color(value1->color,value2->color))
962     return 0;
963     else
964     return 1;
965     }
966    
967     int psiconv_compare_bullet(const psiconv_bullet value1,
968     const psiconv_bullet value2)
969     {
970     if (!value1 || !value2)
971     return 1;
972     if ((value1->on == value2->on) &&
973     (value1->font_size == value2->font_size) &&
974     (value1->character == value2->character) &&
975     (value1->indent == value2->indent) &&
976     !psiconv_compare_color(value1->color,value2->color) &&
977     !psiconv_compare_font(value1->font,value2->font))
978     return 0;
979     else
980     return 1;
981     }
982    
983     int psiconv_compare_tab(const psiconv_tab value1, const psiconv_tab value2)
984     {
985     if (!value1 || !value2)
986     return 1;
987     if ((value1->location == value2->location) &&
988     (value1->kind == value2->kind))
989     return 0;
990     else
991     return 1;
992     }
993    
994     int psiconv_compare_all_tabs(const psiconv_all_tabs value1,
995     const psiconv_all_tabs value2)
996     {
997     int i;
998    
999     if (!value1 || !value2 || !value1->extras || !value2->extras)
1000     return 1;
1001    
1002     if ((value1->normal != value2->normal) ||
1003     psiconv_list_length(value1->extras) !=
1004     psiconv_list_length(value2->extras))
1005     return 1;
1006     for (i = 0; i < psiconv_list_length(value1->extras); i++)
1007     if (psiconv_compare_tab(psiconv_list_get(value1->extras,i),
1008     psiconv_list_get(value2->extras,i)))
1009    
1010     return 1;
1011     return 0;
1012     }
1013    
1014     int psiconv_compare_paragraph_layout(const psiconv_paragraph_layout value1,
1015     const psiconv_paragraph_layout value2)
1016     {
1017     if (!value1 || !value2)
1018     return 1;
1019     if ((value1->indent_left == value2->indent_left) &&
1020     (value1->indent_right == value2->indent_right) &&
1021     (value1->indent_first == value2->indent_first) &&
1022     (value1->justify_hor == value2->justify_hor) &&
1023     (value1->justify_ver == value2->justify_ver) &&
1024     (value1->linespacing == value2->linespacing) &&
1025     (value1->space_above == value2->space_above) &&
1026     (value1->space_below == value2->space_below) &&
1027     (value1->keep_together == value2->keep_together) &&
1028     (value1->keep_with_next == value2->keep_with_next) &&
1029     (value1->on_next_page == value2->on_next_page) &&
1030     (value1->no_widow_protection == value2->no_widow_protection) &&
1031     (value1->border_distance == value2->border_distance) &&
1032     !psiconv_compare_color(value1->back_color,value2->back_color) &&
1033     !psiconv_compare_bullet(value1->bullet,value2->bullet) &&
1034     !psiconv_compare_border(value1->left_border,value2->left_border) &&
1035     !psiconv_compare_border(value1->right_border,value2->right_border) &&
1036     !psiconv_compare_border(value1->top_border,value2->top_border) &&
1037     !psiconv_compare_border(value1->bottom_border,value2->bottom_border) &&
1038     !psiconv_compare_all_tabs(value1->tabs,value2->tabs))
1039     return 0;
1040     else
1041     return 1;
1042     }
1043    
1044    
1045     int psiconv_compare_character_layout(const psiconv_character_layout value1,
1046     const psiconv_character_layout value2)
1047     {
1048     if (!value1 || !value2)
1049     return 1;
1050     if ((value1->font_size == value2->font_size) &&
1051     (value1->italic == value2->italic) &&
1052     (value1->bold == value2->bold) &&
1053     (value1->super_sub == value2->super_sub) &&
1054     (value1->underline == value2->underline) &&
1055     (value1->strikethrough == value2->strikethrough) &&
1056     !psiconv_compare_color(value1->color,value2->color) &&
1057     !psiconv_compare_color(value1->back_color,value2->back_color) &&
1058     !psiconv_compare_font(value1->font,value2->font))
1059     return 0;
1060     else
1061     return 1;
1062     }
1063 frodo 87
1064    
1065    
1066     psiconv_word_styles_section psiconv_empty_word_styles_section(void)
1067     {
1068     psiconv_word_styles_section result;
1069     if (!(result = malloc(sizeof(*result))))
1070     goto ERROR1;
1071     if (!(result->styles = psiconv_list_new(sizeof(struct psiconv_word_style_s))))
1072     goto ERROR2;
1073     if (!(result->normal = malloc(sizeof(struct psiconv_word_style_s))))
1074     goto ERROR3;
1075     if (!(result->normal->character = psiconv_basic_character_layout()))
1076     goto ERROR4;
1077     if (!(result->normal->paragraph = psiconv_basic_paragraph_layout()))
1078     goto ERROR5;
1079     result->normal->hotkey = 'N';
1080     result->normal->name = NULL;
1081     result->normal->built_in = psiconv_bool_true;
1082     result->normal->outline_level = 0;
1083     return result;
1084     ERROR5:
1085     psiconv_free_character_layout(result->normal->character);
1086     ERROR4:
1087     free(result->normal);
1088     ERROR3:
1089     psiconv_list_free(result->styles);
1090     ERROR2:
1091     free(result);
1092     ERROR1:
1093     return NULL;
1094     }
1095    
1096     psiconv_text_and_layout psiconv_empty_text_and_layout(void)
1097     {
1098     return psiconv_list_new(sizeof(struct psiconv_paragraph_s));
1099     }
1100    
1101     psiconv_texted_section psiconv_empty_texted_section(void)
1102     {
1103     psiconv_texted_section result;
1104     if (!(result = malloc(sizeof(*result))))
1105     goto ERROR1;
1106     if (!(result->paragraphs = psiconv_empty_text_and_layout()))
1107     goto ERROR2;
1108     return result;
1109     ERROR2:
1110     free(result);
1111     ERROR1:
1112     return NULL;
1113     }
1114    
1115     psiconv_page_header psiconv_empty_page_header(void)
1116     {
1117     psiconv_page_header result;
1118     if (!(result = malloc(sizeof(*result))))
1119     goto ERROR1;
1120     result->on_first_page = psiconv_bool_true;
1121     if (!(result->base_paragraph_layout = psiconv_basic_paragraph_layout()))
1122     goto ERROR2;
1123     if (!(result->base_character_layout = psiconv_basic_character_layout()))
1124     goto ERROR3;
1125     if (!(result->text = psiconv_empty_texted_section()))
1126     goto ERROR4;
1127     return result;
1128     ERROR4:
1129     psiconv_free_character_layout(result->base_character_layout);
1130     ERROR3:
1131     psiconv_free_paragraph_layout(result->base_paragraph_layout);
1132     ERROR2:
1133     free(result);
1134     ERROR1:
1135     return NULL;
1136     }
1137    
1138     psiconv_page_layout_section psiconv_empty_page_layout_section(void)
1139     {
1140     psiconv_page_layout_section result;
1141     if (!(result = malloc(sizeof(*result))))
1142     goto ERROR1;
1143 frodo 88 result->first_page_nr = 1;
1144 frodo 87 result->header_dist = result->footer_dist = 1.27;
1145     result->left_margin = result->right_margin = 3.175;
1146     result->top_margin = result->bottom_margin = 2.54;
1147     result->page_width = 21.0;
1148     result->page_height = 29.7;
1149     result->landscape = psiconv_bool_false;
1150     if (!(result->header = psiconv_empty_page_header()))
1151     goto ERROR2;
1152     if (!(result->footer = psiconv_empty_page_header()))
1153     goto ERROR3;
1154     return result;
1155     ERROR3:
1156     psiconv_free_page_header(result->header);
1157     ERROR2:
1158     free(result);
1159     ERROR1:
1160     return NULL;
1161     }
1162    
1163     psiconv_word_status_section psiconv_empty_word_status_section(void)
1164     {
1165     psiconv_word_status_section result;
1166     if (!(result = malloc(sizeof(*result))))
1167     return NULL;
1168     result->show_tabs = result->show_spaces = result->show_paragraph_ends =
1169     result->show_hard_minus = result->show_hard_space =
1170     result->fit_lines_to_screen = psiconv_bool_false;
1171     result->show_full_pictures = result->show_full_graphs =
1172     result->show_top_toolbar = result->show_side_toolbar =
1173     psiconv_bool_true;
1174     result->cursor_position = 0;
1175     result->display_size = 1000;
1176     return result;
1177     }
1178    
1179     psiconv_word_f psiconv_empty_word_f(void)
1180     {
1181     psiconv_word_f result;
1182     if (!(result = malloc(sizeof(*result))))
1183     goto ERROR1;
1184     if (!(result->page_sec = psiconv_empty_page_layout_section()))
1185     goto ERROR2;
1186     if (!(result->paragraphs = psiconv_empty_text_and_layout()))
1187     goto ERROR3;
1188     if (!(result->status_sec = psiconv_empty_word_status_section()))
1189     goto ERROR4;
1190     if (!(result->styles_sec = psiconv_empty_word_styles_section()))
1191     goto ERROR5;
1192     return result;
1193     ERROR5:
1194     psiconv_free_word_status_section(result->status_sec);
1195     ERROR4:
1196     psiconv_free_text_and_layout(result->paragraphs);
1197     ERROR3:
1198     psiconv_free_page_layout_section(result->page_sec);
1199     ERROR2:
1200     free(result);
1201     ERROR1:
1202     return NULL;
1203     }
1204    
1205 frodo 94 psiconv_sheet_status_section psiconv_empty_sheet_status_section(void)
1206     {
1207     psiconv_sheet_status_section result;
1208     if (!(result = malloc(sizeof(*result))))
1209     return NULL;
1210     result->show_horizontal_scrollbar = result->show_vertical_scrollbar =
1211     psiconv_triple_auto;
1212     result->show_graph = psiconv_bool_false;
1213     result->show_top_sheet_toolbar = result->show_side_sheet_toolbar =
1214     result->show_top_graph_toolbar = result->show_side_graph_toolbar =
1215     psiconv_bool_true;
1216     result->cursor_row = result->cursor_column = 0;
1217     result->sheet_display_size = result->graph_display_size = 1000;
1218     return result;
1219     }
1220    
1221 frodo 98 psiconv_formula_list psiconv_empty_formula_list(void)
1222 frodo 97 {
1223 frodo 98 return psiconv_list_new(sizeof(struct psiconv_formula_s));
1224 frodo 97 }
1225    
1226 frodo 95 psiconv_sheet_workbook_section psiconv_empty_sheet_workbook_section(void)
1227     {
1228     psiconv_sheet_workbook_section result;
1229     if (!(result = malloc(sizeof(*result))))
1230 frodo 97 goto ERROR1;
1231 frodo 98 if (!(result->formulas = psiconv_empty_formula_list()))
1232 frodo 97 goto ERROR2;
1233 frodo 95 return result;
1234 frodo 97 ERROR2:
1235     free(result);
1236     ERROR1:
1237     return NULL;
1238 frodo 95 }
1239    
1240 frodo 97
1241 frodo 94 psiconv_sheet_f psiconv_empty_sheet_f(void)
1242     {
1243     psiconv_sheet_f result;
1244     if (!(result = malloc(sizeof(*result))))
1245     goto ERROR1;
1246     if (!(result->page_sec = psiconv_empty_page_layout_section()))
1247     goto ERROR2;
1248     if (!(result->status_sec = psiconv_empty_sheet_status_section()))
1249     goto ERROR3;
1250 frodo 95 if (!(result->workbook_sec = psiconv_empty_sheet_workbook_section()))
1251     goto ERROR4;
1252 frodo 94 return result;
1253 frodo 95 ERROR4:
1254     psiconv_free_sheet_status_section(result->status_sec);
1255 frodo 94 ERROR3:
1256     psiconv_free_page_layout_section(result->page_sec);
1257     ERROR2:
1258     free(result);
1259     ERROR1:
1260     return NULL;
1261     }
1262    
1263 frodo 87 psiconv_texted_f psiconv_empty_texted_f(void)
1264     {
1265     psiconv_texted_f result;
1266     if (!(result = malloc(sizeof(*result))))
1267     goto ERROR1;
1268     if (!(result->page_sec = psiconv_empty_page_layout_section()))
1269     goto ERROR2;
1270     if (!(result->texted_sec = psiconv_empty_texted_section()))
1271     goto ERROR3;
1272     return result;
1273     ERROR3:
1274     psiconv_free_page_layout_section(result->page_sec);
1275     ERROR2:
1276     free(result);
1277     ERROR1:
1278     return NULL;
1279     }
1280    
1281     psiconv_paint_data_section psiconv_empty_paint_data_section(void)
1282     {
1283     psiconv_paint_data_section result;
1284     if (!(result = malloc(sizeof(*result))))
1285     goto ERROR1;
1286     /* Is this correct? */
1287     result->xsize = result->ysize = result->pic_xsize = result->pic_ysize = 0;
1288     /* Probably forbidden... */
1289     if (!(result->red = malloc(0)))
1290     goto ERROR2;
1291     if (!(result->green = malloc(0)))
1292     goto ERROR3;
1293     if (!(result->blue = malloc(0)))
1294     goto ERROR4;
1295     return result;
1296     ERROR4:
1297     free(result->green);
1298     ERROR3:
1299     free(result->red);
1300     ERROR2:
1301     free(result);
1302     ERROR1:
1303     return NULL;
1304     }
1305    
1306    
1307     psiconv_pictures psiconv_empty_pictures(void)
1308     {
1309     psiconv_pictures result;
1310     psiconv_paint_data_section pds;
1311     if (!(result = psiconv_list_new(sizeof(struct psiconv_paint_data_section_s))))
1312     goto ERROR1;
1313     if (!(pds = psiconv_empty_paint_data_section()))
1314     goto ERROR2;
1315     if (psiconv_list_add(result,pds))
1316     goto ERROR3;
1317     free(pds);
1318     return result;
1319     ERROR3:
1320     psiconv_free_paint_data_section(pds);
1321     ERROR2:
1322     psiconv_list_free(result);
1323     ERROR1:
1324     return NULL;
1325     }
1326    
1327     psiconv_mbm_f psiconv_empty_mbm_f(void)
1328     {
1329     psiconv_mbm_f result;
1330     if (!(result = malloc(sizeof(*result))))
1331     goto ERROR1;
1332     if (!(result->sections = psiconv_empty_pictures()))
1333     goto ERROR2;
1334     return result;
1335     ERROR2:
1336     free(result);
1337     ERROR1:
1338     return NULL;
1339     }
1340    
1341     psiconv_sketch_section psiconv_empty_sketch_section(void)
1342     {
1343     psiconv_sketch_section result;
1344     if (!(result = malloc(sizeof(*result))))
1345     goto ERROR1;
1346     result->form_xsize = 320;
1347     result->form_ysize = 200;
1348     result->picture_x_offset = result->picture_y_offset = result->picture_xsize =
1349     result->picture_ysize = 0;
1350     result->magnification_x = result->magnification_y = 1.0;
1351     result->cut_left = result->cut_right = result->cut_top =
1352     result->cut_bottom = 0.0;
1353     if (!(result->picture = psiconv_empty_paint_data_section()))
1354     goto ERROR2;
1355     return result;
1356     ERROR2:
1357     free(result);
1358     ERROR1:
1359     return NULL;
1360     }
1361    
1362     psiconv_sketch_f psiconv_empty_sketch_f(void)
1363     {
1364     psiconv_sketch_f result;
1365     if (!(result = malloc(sizeof(*result))))
1366     goto ERROR1;
1367     if (!(result->sketch_sec = psiconv_empty_sketch_section()))
1368     goto ERROR2;
1369     return result;
1370     ERROR2:
1371     free(result);
1372     ERROR1:
1373     return NULL;
1374     }
1375    
1376     psiconv_cliparts psiconv_empty_cliparts(void)
1377     {
1378     /* Is this correct? */
1379     return psiconv_list_new(sizeof(struct psiconv_clipart_section_s));
1380     }
1381    
1382     psiconv_clipart_f psiconv_empty_clipart_f(void)
1383     {
1384     psiconv_clipart_f result;
1385     if (!(result = malloc(sizeof(*result))))
1386     goto ERROR1;
1387     if (!(result->sections = psiconv_empty_cliparts()))
1388     goto ERROR2;
1389     return result;
1390     ERROR2:
1391     free(result);
1392     ERROR1:
1393     return NULL;
1394     }
1395    
1396     psiconv_file psiconv_empty_file(psiconv_file_type_t type)
1397     {
1398     psiconv_file result;
1399     if (!(result = malloc(sizeof(*result))))
1400     return NULL;
1401     result->type = type;
1402     if (type == psiconv_word_file) {
1403     if (!(result->file = psiconv_empty_word_f()))
1404     goto ERROR;
1405 frodo 94 } else if (type == psiconv_sheet_file) {
1406     if (!(result->file = psiconv_empty_sheet_f()))
1407     goto ERROR;
1408 frodo 87 } else if (type == psiconv_texted_file) {
1409     if (!(result->file = psiconv_empty_texted_f()))
1410     goto ERROR;
1411     } else if (type == psiconv_mbm_file) {
1412     if (!(result->file = psiconv_empty_mbm_f()))
1413     goto ERROR;
1414     } else if (type == psiconv_sketch_file) {
1415     if (!(result->file = psiconv_empty_sketch_f()))
1416     goto ERROR;
1417     } else if (type == psiconv_clipart_file) {
1418     if (!(result->file = psiconv_empty_clipart_f()))
1419     goto ERROR;
1420     } else
1421     goto ERROR;
1422     return result;
1423     ERROR:
1424     free(result);
1425     return NULL;
1426     }

frodo@frodo.looijaard.name
ViewVC Help
Powered by ViewVC 1.1.26