/[public]/psiconv/trunk/program/psiconv/gen_xhtml.c
ViewVC logotype

Annotation of /psiconv/trunk/program/psiconv/gen_xhtml.c

Parent Directory Parent Directory | Revision Log Revision Log

Revision 193 - (hide annotations)
Mon Feb 2 21:56:48 2004 UTC (20 years, 2 months ago) by frodo
File MIME type: text/plain
File size: 26328 byte(s) 
(Frodo) Make the formats stuff work again

  * Amend the configure.in to select the right targets
  * Remove RTF support (it never worked anyway)
  * Update the links creation scripts

And in the psiconv program and library:
  * Some fixes to reduce compiler warnings
  * Emit tabs as spaces in the HTML4/XHTML generators
1 frodo 190 /* gen_html.c - Part of psiconv, a PSION 5 file formats converter
2     Copyright (c) 1999-2004 Frodo Looijaard <frodol@dds.nl>
3    
4     This program is free software; you can redistribute it and/or modify
5     it under the terms of the GNU General Public License as published by
6     the Free Software Foundation; either version 2 of the License, or
7     (at your option) any later version.
8    
9     This program is distributed in the hope that it will be useful,
10     but WITHOUT ANY WARRANTY; without even the implied warranty of
11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12     GNU General Public License for more details.
13    
14     You should have received a copy of the GNU General Public License
15     along with this program; if not, write to the Free Software
16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17     */
18    
19     #include "config.h"
20    
21     #include <psiconv/configuration.h>
22     #include <psiconv/data.h>
23     #include "general.h"
24 frodo 193 #include "gen.h"
25 frodo 190
26     #include <string.h>
27     #include <stdlib.h>
28 frodo 193 #include <stdio.h>
29 frodo 190
30     #ifdef DMALLOC
31     #include "dmalloc.h"
32     #endif
33    
34     #define TEMPSTR_LEN 100
35    
36 frodo 192 static void text(const psiconv_config config,psiconv_list list,
37     psiconv_string_t data,const encoding enc);
38     static void color(const psiconv_config config, psiconv_list list,
39     psiconv_color color,int may_be_transparant, const encoding enc);
40     static void border(const psiconv_config config, psiconv_list list,
41     psiconv_border_kind_t border,const encoding enc);
42     static void style_name(const psiconv_config config, psiconv_list list,
43     const psiconv_string_t name,const encoding enc);
44     static void character_layout_diffs(const psiconv_config config,
45     psiconv_list list,
46     const psiconv_character_layout new,
47     const psiconv_character_layout base,
48     const encoding enc);
49     static void paragraph_layout_diffs(const psiconv_config config,
50     psiconv_list list,
51     const psiconv_paragraph_layout new,
52     const psiconv_paragraph_layout base,
53     const encoding enc);
54     static void style(const psiconv_config config, psiconv_list list,
55     const psiconv_word_style style,
56     const psiconv_paragraph_layout base_para,
57     const psiconv_character_layout base_char,
58     const encoding enc);
59     static void styles(const psiconv_config config, psiconv_list list,
60     const psiconv_word_styles_section styles_sec,const encoding enc);
61     static void header(const psiconv_config config, psiconv_list list,
62     const psiconv_word_styles_section styles_sec,const encoding enc);
63     static void footer(const psiconv_config config, psiconv_list list,
64     const encoding enc);
65     static void characters(const psiconv_config config, psiconv_list list,
66     const psiconv_string_t textstr,
67     const psiconv_character_layout layout,
68     const psiconv_character_layout base,
69     const encoding enc);
70 frodo 193 static void paragraphs(const psiconv_config config, psiconv_list list,
71     psiconv_text_and_layout paragraphs,
72     const psiconv_word_styles_section styles,
73     const encoding enc);
74 frodo 192 static void paragraph(const psiconv_config config, psiconv_list list,
75     const psiconv_paragraph para,
76     const psiconv_word_styles_section styles_sec,
77     const encoding enc);
78     static void gen_word(const psiconv_config config, psiconv_list list,
79     const psiconv_word_f file, const encoding enc);
80     static void gen_texted(const psiconv_config config, psiconv_list list,
81     const psiconv_texted_f file, const encoding enc);
82 frodo 193 static int gen_xhtml(const psiconv_config config, psiconv_list list,
83     const psiconv_file file, const char *dest,
84     const encoding enc);
85 frodo 192
86    
87    
88 frodo 191 void text(const psiconv_config config,psiconv_list list,
89     psiconv_string_t data,const encoding enc)
90     {
91     int i;
92     for (i = 0; i < psiconv_unicode_strlen(data); i++) {
93     if ((data[i] == 0x06) || (data[i] == 0x07) || (data[i] == 0x08))
94     output_simple_chars(config,list,"<br/>",enc);
95     else if ((data[i] == 0x0b) || (data[i] == 0x0c))
96     output_simple_chars(config,list,"-",enc);
97 frodo 193 else if ((data[i] == 0x0f) || (data[i] == 0x09) || (data[i] == 0x0a))
98 frodo 191 output_simple_chars(config,list," ",enc);
99     else if (data[i] >= 0x20)
100     output_char(config,list,data[i],enc);
101     }
102     }
103    
104 frodo 190 void color(const psiconv_config config, psiconv_list list,
105     psiconv_color color,int may_be_transparant, const encoding enc)
106     {
107     char tempstr[TEMPSTR_LEN];
108     if (may_be_transparant &&
109     (color->red == 0xff) &&
110     (color->blue == 0xff) &&
111     (color->green == 0xff))
112     output_simple_chars(config,list,"transparant",enc);
113     else {
114     snprintf(tempstr,TEMPSTR_LEN,"rgb(%d,%d,%d)",
115     color->red,
116     color->green,
117     color->blue);
118     output_simple_chars(config,list,tempstr,enc);
119     }
120     }
121    
122 frodo 191 void border(const psiconv_config config, psiconv_list list,
123     psiconv_border_kind_t border,const encoding enc)
124     {
125     output_simple_chars(config,list,
126     border == psiconv_border_none?"none":
127     border == psiconv_border_solid?"solid":
128     border == psiconv_border_double?"double":
129     border == psiconv_border_dotted?"dotted":
130     border == psiconv_border_dashed?"dashed":
131     border == psiconv_border_dotdashed?"dashed":
132     border == psiconv_border_dotdotdashed?"dashed":"",enc);
133     }
134    
135 frodo 190 void style_name(const psiconv_config config, psiconv_list list,
136     const psiconv_string_t name,const encoding enc)
137     {
138     psiconv_string_t name_copy;
139     int i;
140    
141     if (!name)
142     return;
143    
144     if (!(name_copy = psiconv_unicode_strdup(name))) {
145     fputs("Out of memory error\n",stderr);
146     exit(1);
147     }
148     for (i = 0; i < psiconv_unicode_strlen(name_copy); i++) {
149     if ((name_copy[i] < 0x21) ||
150     ((name_copy[i] >= 0x7f) && name_copy[i] <= 0xa0))
151     name_copy[i] = '_';
152     }
153     output_string(config,list,name_copy,enc);
154     free(name_copy);
155     }
156    
157     void character_layout_diffs(const psiconv_config config, psiconv_list list,
158     const psiconv_character_layout new,
159     const psiconv_character_layout base,
160     const encoding enc)
161     {
162     char tempstr[TEMPSTR_LEN];
163    
164     if (!base || (new->color->red != base->color->red) ||
165     (new->color->green != base->color->green) ||
166     (new->color->blue != base->color->blue)) {
167     output_simple_chars(config,list,"color:",enc);
168     color(config,list,new->color,0,enc);
169     output_simple_chars(config,list,";",enc);
170     }
171    
172     if (!base || (new->back_color->red != base->back_color->red) ||
173     (new->back_color->green != base->back_color->green) ||
174     (new->back_color->blue != base->back_color->blue)) {
175     output_simple_chars(config,list,"background-color:",enc);
176     color(config,list,new->back_color,1,enc);
177     output_simple_chars(config,list,";",enc);
178     }
179    
180     if (!base || (new->font_size != base->font_size)) {
181     output_simple_chars(config,list,"font-size:",enc);
182     snprintf(tempstr,TEMPSTR_LEN,"%f",new->font_size);
183     output_simple_chars(config,list,tempstr,enc);
184     output_simple_chars(config,list,"pt;",enc);
185     }
186 frodo 191
187     if (!base || (new->italic != base->italic)) {
188     output_simple_chars(config,list,"font-style:",enc);
189     output_simple_chars(config,list,new->italic?"italic":"normal",enc);
190     output_simple_chars(config,list,";",enc);
191     }
192     if (!base || (new->bold != base->bold)) {
193     output_simple_chars(config,list,"font-weight:",enc);
194     output_simple_chars(config,list,new->bold?"bold":"normal",enc);
195     output_simple_chars(config,list,";",enc);
196     }
197     if (!base || (new->super_sub != base->super_sub)) {
198     output_simple_chars(config,list,"font-style:",enc);
199     output_simple_chars(config,list,
200     new->super_sub==psiconv_superscript?"super":
201     new->super_sub==psiconv_subscript?"sub":
202     "normal",enc);
203     output_simple_chars(config,list,";",enc);
204     }
205     if (!base || (new->underline != base->underline) ||
206     (new->strikethrough != base->strikethrough)) {
207     output_simple_chars(config,list,"text-decoration:",enc);
208     output_simple_chars(config,list,new->underline?"underline":
209     new->strikethrough?"line-through":
210     "none",enc);
211     output_simple_chars(config,list,";",enc);
212     }
213     if (!base || (new->font->screenfont != base->font->screenfont)) {
214     output_simple_chars(config,list,"font-family:",enc);
215     output_simple_chars(config,list,
216     new->font->screenfont == psiconv_font_serif?"serif":
217     new->font->screenfont == psiconv_font_sansserif?"sans-serif":
218     new->font->screenfont == psiconv_font_nonprop?"monospace":
219     new->font->screenfont == psiconv_font_misc?"fantasy":"",
220     enc);
221     }
222 frodo 190 }
223    
224     void paragraph_layout_diffs(const psiconv_config config, psiconv_list list,
225     const psiconv_paragraph_layout new,
226     const psiconv_paragraph_layout base,
227     const encoding enc)
228     {
229     char tempstr[TEMPSTR_LEN];
230 frodo 191 float pad_left_base=0.0,pad_left_new,text_indent_base=0.0,text_indent_new;
231 frodo 190
232 frodo 191 if (new->bullet->on) {
233     pad_left_new = new->indent_left < new->indent_first?
234     new->indent_left:new->indent_first;
235     text_indent_new = 0.0;
236     } else {
237     pad_left_new = new->indent_left;
238     text_indent_new = new->indent_first;
239     }
240     if (base) {
241     if (base->bullet->on) {
242     pad_left_base = base->indent_left < base->indent_first?
243     base->indent_left:base->indent_first;
244     text_indent_base = 0.0;
245     } else {
246     pad_left_base = base->indent_left;
247     text_indent_base = base->indent_first;
248     }
249     }
250    
251    
252 frodo 190 if (!base || (new->back_color->red != base->back_color->red) ||
253     (new->back_color->green != base->back_color->green) ||
254     (new->back_color->blue != base->back_color->blue)) {
255     output_simple_chars(config,list,"background-color:",enc);
256     color(config,list,new->back_color,1,enc);
257     output_simple_chars(config,list,";",enc);
258     }
259    
260 frodo 191 if (!base || (pad_left_new != pad_left_base)) {
261 frodo 190 output_simple_chars(config,list,"padding-left:",enc);
262 frodo 191 snprintf(tempstr,TEMPSTR_LEN,"%f",pad_left_new);
263 frodo 190 output_simple_chars(config,list,tempstr,enc);
264     output_simple_chars(config,list,"cm;",enc);
265     }
266    
267     if (!base || (new->indent_right != base->indent_right)) {
268     output_simple_chars(config,list,"padding-right:",enc);
269     snprintf(tempstr,TEMPSTR_LEN,"%f",new->indent_right);
270     output_simple_chars(config,list,tempstr,enc);
271     output_simple_chars(config,list,"cm;",enc);
272     }
273    
274 frodo 191 if (!base || (text_indent_new != text_indent_base)) {
275 frodo 190 output_simple_chars(config,list,"text-indent:",enc);
276 frodo 191 snprintf(tempstr,TEMPSTR_LEN,"%f",text_indent_new);
277 frodo 190 output_simple_chars(config,list,tempstr,enc);
278     output_simple_chars(config,list,"cm;",enc);
279     }
280    
281     if (!base || (new->justify_hor != base ->justify_hor)) {
282     output_simple_chars(config,list,"font-style:",enc);
283     output_simple_chars(config,list,
284     new->justify_hor==psiconv_justify_left?"left":
285     new->justify_hor==psiconv_justify_centre?"center":
286     new->justify_hor==psiconv_justify_right?"right":
287     new->justify_hor==psiconv_justify_full?"justify":
288     "",enc);
289     output_simple_chars(config,list,";",enc);
290     }
291    
292     if (!base || (new->linespacing != base->linespacing)) {
293     output_simple_chars(config,list,"line-height:",enc);
294     snprintf(tempstr,TEMPSTR_LEN,"%f",new->linespacing);
295     output_simple_chars(config,list,tempstr,enc);
296     output_simple_chars(config,list,"pt;",enc);
297     }
298    
299     if (!base || (new->space_above != base->space_above)) {
300     output_simple_chars(config,list,"padding-top:",enc);
301     snprintf(tempstr,TEMPSTR_LEN,"%f",new->space_above);
302     output_simple_chars(config,list,tempstr,enc);
303     output_simple_chars(config,list,"pt;",enc);
304     }
305    
306     if (!base || (new->space_below != base->space_below)) {
307     output_simple_chars(config,list,"padding-bottom:",enc);
308     snprintf(tempstr,TEMPSTR_LEN,"%f",new->space_below);
309     output_simple_chars(config,list,tempstr,enc);
310     output_simple_chars(config,list,"pt;",enc);
311     }
312 frodo 191
313     if (!base || (new->right_border->kind != base->right_border->kind)) {
314     output_simple_chars(config,list,"border-right-style:",enc);
315     border(config,list,new->right_border->kind,enc);
316     output_simple_chars(config,list,";",enc);
317     }
318     if (!base || (new->bottom_border->kind != base->bottom_border->kind)) {
319     output_simple_chars(config,list,"border-bottom-style:",enc);
320     border(config,list,new->bottom_border->kind,enc);
321     output_simple_chars(config,list,";",enc);
322     }
323     if (!base || (new->top_border->kind != base->top_border->kind)) {
324     output_simple_chars(config,list,"border-top-style:",enc);
325     border(config,list,new->top_border->kind,enc);
326     output_simple_chars(config,list,";",enc);
327     }
328     if (!base || (new->left_border->kind != base->left_border->kind)) {
329     output_simple_chars(config,list,"border-left-style:",enc);
330     border(config,list,new->left_border->kind,enc);
331     output_simple_chars(config,list,";",enc);
332     }
333    
334     if (!base ||
335     ((new->right_border->kind != psiconv_border_none) &&
336     (new->right_border->thickness != base->right_border->thickness))) {
337     output_simple_chars(config,list,"border-right-width:",enc);
338     snprintf(tempstr,TEMPSTR_LEN,"%f",new->right_border->thickness);
339     output_simple_chars(config,list,tempstr,enc);
340     output_simple_chars(config,list,"pt;",enc);
341     }
342     if (!base ||
343     ((new->bottom_border->kind != psiconv_border_none) &&
344     (new->bottom_border->thickness != base->bottom_border->thickness))) {
345     output_simple_chars(config,list,"border-bottom-width:",enc);
346     snprintf(tempstr,TEMPSTR_LEN,"%f",new->bottom_border->thickness);
347     output_simple_chars(config,list,tempstr,enc);
348     output_simple_chars(config,list,"pt;",enc);
349     }
350     if (!base ||
351     ((new->top_border->kind != psiconv_border_none) &&
352     ( new->top_border->thickness != base->top_border->thickness))) {
353     output_simple_chars(config,list,"border-top-width:",enc);
354     snprintf(tempstr,TEMPSTR_LEN,"%f",new->top_border->thickness);
355     output_simple_chars(config,list,tempstr,enc);
356     output_simple_chars(config,list,"pt;",enc);
357     }
358     if (!base ||
359     ((new->left_border->kind != psiconv_border_none) &&
360     (new->left_border->thickness != base->left_border->thickness))) {
361     output_simple_chars(config,list,"border-left-width:",enc);
362     snprintf(tempstr,TEMPSTR_LEN,"%f",new->left_border->thickness);
363     output_simple_chars(config,list,tempstr,enc);
364     output_simple_chars(config,list,"pt;",enc);
365     }
366    
367     if (!base ||
368     ((new->right_border->kind != psiconv_border_none) &&
369     ((new->right_border->color->red != base->right_border->color->red) ||
370     (new->right_border->color->green != base->right_border->color->green)||
371     (new->right_border->color->blue != base->right_border->color->blue)))) {
372     output_simple_chars(config,list,"border-right-color:",enc);
373     color(config,list,new->right_border->color,0,enc);
374     output_simple_chars(config,list,";",enc);
375     }
376     if (!base ||
377     ((new->top_border->kind != psiconv_border_none) &&
378     ((new->top_border->color->red != base->top_border->color->red) ||
379     (new->top_border->color->green != base->top_border->color->green) ||
380     (new->top_border->color->blue != base->top_border->color->blue)))) {
381     output_simple_chars(config,list,"border-top-color:",enc);
382     color(config,list,new->top_border->color,0,enc);
383     output_simple_chars(config,list,";",enc);
384     }
385     if (!base ||
386     ((new->bottom_border->kind != psiconv_border_none) &&
387     ((new->bottom_border->color->red != base->bottom_border->color->red) ||
388     (new->bottom_border->color->green !=base->bottom_border->color->green)||
389     (new->bottom_border->color->blue != base->bottom_border->color->blue)))){
390     output_simple_chars(config,list,"border-bottom-color:",enc);
391     color(config,list,new->bottom_border->color,0,enc);
392     output_simple_chars(config,list,";",enc);
393     }
394     if (!base ||
395     ((new->left_border->kind != psiconv_border_none) &&
396     ((new->left_border->color->red != base->left_border->color->red) ||
397     (new->left_border->color->green != base->left_border->color->green) ||
398     (new->left_border->color->blue != base->left_border->color->blue)))) {
399     output_simple_chars(config,list,"border-left-color:",enc);
400     color(config,list,new->left_border->color,0,enc);
401     output_simple_chars(config,list,";",enc);
402     }
403 frodo 190 }
404    
405     void style(const psiconv_config config, psiconv_list list,
406     const psiconv_word_style style,
407     const psiconv_paragraph_layout base_para,
408     const psiconv_character_layout base_char,
409     const encoding enc)
410     {
411 frodo 191 output_simple_chars(config,list,"*.style_",enc);
412 frodo 190 style_name(config,list,style->name,enc);
413 frodo 191 output_simple_chars(config,list," {",enc);
414 frodo 190 paragraph_layout_diffs(config,list,style->paragraph,base_para,enc);
415     character_layout_diffs(config,list,style->character,base_char,enc);
416     output_simple_chars(config,list,"}\n",enc);
417     }
418    
419     void styles(const psiconv_config config, psiconv_list list,
420     const psiconv_word_styles_section styles_sec,const encoding enc)
421     {
422     int i;
423     psiconv_word_style styl;
424     psiconv_character_layout base_char;
425     psiconv_paragraph_layout base_para;
426    
427     if (!(base_char = psiconv_basic_character_layout())) {
428     fputs("Out of memory error\n",stderr);
429     exit(1);
430     }
431     if (!(base_para = psiconv_basic_paragraph_layout())) {
432     fputs("Out of memory error\n",stderr);
433     exit(1);
434     }
435    
436     output_simple_chars(config,list,"<style type=\"text/css\">\n",enc);
437     /* output_simple_chars(config,list,"<![CDATA[\n",enc); */
438    
439     output_simple_chars(config,list,"body {",enc);
440     paragraph_layout_diffs(config,list,base_para,NULL,enc);
441     character_layout_diffs(config,list,base_char,NULL,enc);
442     output_simple_chars(config,list,"}\n",enc);
443    
444     if (styles_sec) {
445     style(config,list,styles_sec->normal,base_para,base_char,enc);
446    
447     for (i = 0; i < psiconv_list_length(styles_sec->styles); i++) {
448     if (!(styl = psiconv_list_get(styles_sec->styles,i))) {
449     fputs("Internal datastructure corruption\n",stderr);
450     exit(1);
451     }
452     style(config,list,styl,base_para,base_char,enc);
453     }
454     }
455    
456     /* output_simple_chars(config,list,"]]>\n",enc); */
457     output_simple_chars(config,list,"</style>\n",enc);
458     }
459    
460     void header(const psiconv_config config, psiconv_list list,
461     const psiconv_word_styles_section styles_sec,const encoding enc)
462     {
463     output_simple_chars(config,list,
464     "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n",enc);
465     output_simple_chars(config,list,"<!DOCTYPE html PUBLIC ",enc);
466     output_simple_chars(config,list, "\"-//W3C//DTD XHTML 1.0 Strict//EN\" ",enc);
467     output_simple_chars(config,list,
468     "\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">",
469     enc);
470     output_simple_chars(config,list,"\n<html",enc);
471     output_simple_chars(config,list,
472     " xmlns=\"http://www.w3.org/1999/xhtml\"",enc);
473     output_simple_chars(config,list,">\n",enc);
474     output_simple_chars(config,list,"<head>\n",enc);
475     output_simple_chars(config,list,"<meta http-equiv=\"Content-Type\" "
476     "content=\"text/html; charset=",enc);
477     output_simple_chars(config,list,enc==ENCODING_UTF8?"UTF-8":
478     enc==ENCODING_UCS2?"UTF-16BE":
479     enc==ENCODING_ASCII?"US-ASCII":
480     "",enc);
481     output_simple_chars(config,list,"\">\n",enc);
482     output_simple_chars(config,list,"<meta http-equiv=\"Content-Style-Type\" "
483     "content=\"text/css\">\n",enc);
484     output_simple_chars(config,list,"<title>EPOC32 file "
485     "converted by psiconv</title>\n",enc);
486     styles(config,list,styles_sec,enc);
487     output_simple_chars(config,list,"</head>\n",enc);
488     output_simple_chars(config,list,"<body>\n",enc);
489     }
490    
491     void footer(const psiconv_config config, psiconv_list list, const encoding enc)
492     {
493     output_simple_chars(config,list,"</body>\n",enc);
494     output_simple_chars(config,list,"</html>\n",enc);
495     }
496    
497     void characters(const psiconv_config config, psiconv_list list,
498 frodo 191 const psiconv_string_t textstr,
499 frodo 190 const psiconv_character_layout layout,
500     const psiconv_character_layout base,
501     const encoding enc)
502     {
503     psiconv_list templist;
504    
505     if (!(templist = psiconv_list_new(sizeof(psiconv_u8)))) {
506     fputs("Out of memory error\n",stderr);
507     exit(1);
508     }
509     character_layout_diffs(config,templist,layout,base,enc);
510    
511     if (psiconv_list_length(templist)) {
512     output_simple_chars(config,list,"<span style=\"",enc);
513     if (psiconv_list_concat(list,templist)) {
514     fputs("Out of memory error\n",stderr);
515     exit(1);
516     }
517     output_simple_chars(config,list,"\">",enc);
518     }
519    
520 frodo 191 text(config,list,textstr,enc);
521 frodo 190
522     if (psiconv_list_length(templist)) {
523     output_simple_chars(config,list,"</span>",enc);
524     }
525    
526     psiconv_list_free(templist);
527     }
528    
529     void paragraph(const psiconv_config config, psiconv_list list,
530     const psiconv_paragraph para,
531     const psiconv_word_styles_section styles_sec,
532     const encoding enc)
533     {
534     int i,charnr;
535     psiconv_string_t text;
536     psiconv_in_line_layout layout;
537     psiconv_word_style style = NULL;
538     psiconv_paragraph_layout base_para;
539     psiconv_character_layout base_char;
540     psiconv_list templist;
541    
542     if (!(templist = psiconv_list_new(sizeof(psiconv_u8)))) {
543     fputs("Out of memory error\n",stderr);
544     exit(1);
545     }
546    
547     if (styles_sec) {
548     if (!(style = psiconv_get_style(styles_sec,para->base_style))) {
549     fputs("Unknown style found; data corrupt\n",stderr);
550     exit(1);
551     }
552     base_para = style->paragraph;
553     base_char = style->character;
554     } else {
555     base_para = psiconv_basic_paragraph_layout();
556     base_char = psiconv_basic_character_layout();
557     if (!base_para || !base_char) {
558     fputs("Out of memory error\n",stderr);
559     exit(1);
560     }
561     }
562    
563 frodo 191 output_simple_chars(config,
564     list,para->base_paragraph->bullet->on?"<ul><li ":"<p ",
565     enc);
566 frodo 190
567     if (styles_sec) {
568     output_simple_chars(config,list,"class=\"style_",enc);
569     style_name(config,list,style->name,enc);
570     output_simple_chars(config,list,"\" ",enc);
571     }
572    
573     paragraph_layout_diffs(config,templist,para->base_paragraph,base_para,enc);
574     character_layout_diffs(config,templist,para->base_character,base_char,enc);
575    
576     if (psiconv_list_length(templist)) {
577     output_simple_chars(config,list,"style=\"",enc);
578     if (psiconv_list_concat(list,templist)) {
579     fputs("Out of memory error\n",stderr);
580     exit(1);
581     }
582     output_simple_chars(config,list,"\"",enc);
583     }
584     output_simple_chars(config,list,">",enc);
585    
586     if (psiconv_list_length(para->in_lines) == 0) {
587     characters(config,list,para->text,para->base_character,
588     para->base_character,enc);
589     } else {
590     charnr = 0;
591     for (i = 0; i < psiconv_list_length(para->in_lines); i++) {
592     if (!(layout = psiconv_list_get(para->in_lines,i))) {
593     fputs("Internal data structures corruption\n",stderr);
594     exit(1);
595     }
596     if (!(text = malloc(sizeof (*text) * (layout->length + 1)))) {
597     fputs("Out of memory error\n",stderr);
598     exit(1);
599     }
600     memcpy(text,para->text+charnr,layout->length * sizeof(*text));
601     text[layout->length] = 0;
602     characters(config,list,text,layout->layout,para->base_character,enc);
603     free(text);
604     charnr += layout->length;
605     }
606     }
607 frodo 191 output_simple_chars(config, list,
608 frodo 192 para->base_paragraph->bullet->on?"</li></ul>\n":"</p>\n",
609 frodo 191 enc);
610 frodo 190 if (!styles_sec) {
611     psiconv_free_paragraph_layout(base_para);
612     psiconv_free_character_layout(base_char);
613     }
614     psiconv_list_free(templist);
615     }
616    
617     void paragraphs(const psiconv_config config, psiconv_list list,
618     psiconv_text_and_layout paragraphs,
619     const psiconv_word_styles_section styles,
620     const encoding enc)
621     {
622     int i;
623     psiconv_paragraph para;
624     for (i = 0; i < psiconv_list_length(paragraphs); i++) {
625     if (!(para = psiconv_list_get(paragraphs,i))) {
626     fputs("Internal datastructure corruption\n",stderr);
627     exit(1);
628     }
629     paragraph(config,list,para,styles,enc);
630     }
631     }
632    
633 frodo 192 void gen_word(const psiconv_config config, psiconv_list list,
634 frodo 190 const psiconv_word_f file, const encoding enc)
635     {
636     if (!file)
637     return;
638    
639     header(config,list,file->styles_sec,enc);
640     paragraphs(config,list,file->paragraphs,file->styles_sec,enc);
641     footer(config,list,enc);
642     }
643    
644    
645 frodo 192 void gen_texted(const psiconv_config config, psiconv_list list,
646 frodo 190 const psiconv_texted_f file, const encoding enc)
647     {
648     header(config,list,NULL,enc);
649     paragraphs(config,list,file->texted_sec->paragraphs,NULL,enc);
650     footer(config,list,enc);
651     }
652    
653 frodo 192 int gen_xhtml(const psiconv_config config, psiconv_list list,
654 frodo 190 const psiconv_file file, const char *dest,
655     const encoding enc)
656     {
657 frodo 192 encoding enc1 = enc;
658    
659 frodo 190 if (enc == ENCODING_PSION) {
660     fputs("Unsupported encoding\n",stderr);
661     return -1;
662 frodo 192 } else if (enc == ENCODING_ASCII)
663     enc1 = ENCODING_ASCII_HTML;
664 frodo 190
665     if (file->type == psiconv_word_file) {
666 frodo 192 gen_word(config,list,(psiconv_word_f) file->file,enc1);
667 frodo 190 return 0;
668     } else if (file->type == psiconv_texted_file) {
669 frodo 192 gen_texted(config,list,(psiconv_texted_f) file->file,enc1);
670 frodo 190 return 0;
671     } else
672     return -1;
673     }
674    
675    
676     static struct fileformat_s ffs[] =
677     {
678     {
679     "XHTML",
680     "XHTML 1.0 Strict, using CSS for formatting",
681 frodo 192 FORMAT_WORD | FORMAT_TEXTED,
682     gen_xhtml
683 frodo 190 },
684     {
685     NULL,
686     NULL,
687 frodo 192 0,
688 frodo 190 NULL
689     }
690     };
691    
692    
693 frodo 192 void init_xhtml(void)
694 frodo 190 {
695     int i;
696     for (i = 0; ffs[i].name; i++)
697     psiconv_list_add(fileformat_list,ffs+i);
698     }
frodo@frodo.looijaard.name
 ViewVC Help
Powered by ViewVC 1.1.26