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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 192 - (show annotations)
Mon Feb 2 20:43:04 2004 UTC (20 years, 1 month 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 /* 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 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 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 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 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 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
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 }
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 float pad_left_base=0.0,pad_left_new,text_indent_base=0.0,text_indent_new;
222
223 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 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 if (!base || (pad_left_new != pad_left_base)) {
252 output_simple_chars(config,list,"padding-left:",enc);
253 snprintf(tempstr,TEMPSTR_LEN,"%f",pad_left_new);
254 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 if (!base || (text_indent_new != text_indent_base)) {
266 output_simple_chars(config,list,"text-indent:",enc);
267 snprintf(tempstr,TEMPSTR_LEN,"%f",text_indent_new);
268 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
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 }
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 output_simple_chars(config,list,"*.style_",enc);
403 style_name(config,list,style->name,enc);
404 output_simple_chars(config,list," {",enc);
405 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 const psiconv_string_t textstr,
490 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 text(config,list,textstr,enc);
512
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 output_simple_chars(config,
555 list,para->base_paragraph->bullet->on?"<ul><li ":"<p ",
556 enc);
557
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 output_simple_chars(config, list,
599 para->base_paragraph->bullet->on?"</li></ul>\n":"</p>\n",
600 enc);
601 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 void gen_word(const psiconv_config config, psiconv_list list,
625 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 void gen_texted(const psiconv_config config, psiconv_list list,
637 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 int gen_xhtml(const psiconv_config config, psiconv_list list,
645 const psiconv_file file, const char *dest,
646 const encoding enc)
647 {
648 encoding enc1 = enc;
649
650 if (enc == ENCODING_PSION) {
651 fputs("Unsupported encoding\n",stderr);
652 return -1;
653 } else if (enc == ENCODING_ASCII)
654 enc1 = ENCODING_ASCII_HTML;
655
656 if (file->type == psiconv_word_file) {
657 gen_word(config,list,(psiconv_word_f) file->file,enc1);
658 return 0;
659 } else if (file->type == psiconv_texted_file) {
660 gen_texted(config,list,(psiconv_texted_f) file->file,enc1);
661 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 FORMAT_WORD | FORMAT_TEXTED,
673 gen_xhtml
674 },
675 {
676 NULL,
677 NULL,
678 0,
679 NULL
680 }
681 };
682
683
684 void init_xhtml(void)
685 {
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