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