/[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 193 - (show 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 /* 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 #include "gen.h"
25
26 #include <string.h>
27 #include <stdlib.h>
28 #include <stdio.h>
29
30 #ifdef DMALLOC
31 #include "dmalloc.h"
32 #endif
33
34 #define TEMPSTR_LEN 100
35
36 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 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 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 static int gen_xhtml(const psiconv_config config, psiconv_list list,
83 const psiconv_file file, const char *dest,
84 const encoding enc);
85
86
87
88 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 else if ((data[i] == 0x0f) || (data[i] == 0x09) || (data[i] == 0x0a))
98 output_simple_chars(config,list," ",enc);
99 else if (data[i] >= 0x20)
100 output_char(config,list,data[i],enc);
101 }
102 }
103
104 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 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 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
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 }
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 float pad_left_base=0.0,pad_left_new,text_indent_base=0.0,text_indent_new;
231
232 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 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 if (!base || (pad_left_new != pad_left_base)) {
261 output_simple_chars(config,list,"padding-left:",enc);
262 snprintf(tempstr,TEMPSTR_LEN,"%f",pad_left_new);
263 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 if (!base || (text_indent_new != text_indent_base)) {
275 output_simple_chars(config,list,"text-indent:",enc);
276 snprintf(tempstr,TEMPSTR_LEN,"%f",text_indent_new);
277 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
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 }
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 output_simple_chars(config,list,"*.style_",enc);
412 style_name(config,list,style->name,enc);
413 output_simple_chars(config,list," {",enc);
414 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 const psiconv_string_t textstr,
499 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 text(config,list,textstr,enc);
521
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 output_simple_chars(config,
564 list,para->base_paragraph->bullet->on?"<ul><li ":"<p ",
565 enc);
566
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 output_simple_chars(config, list,
608 para->base_paragraph->bullet->on?"</li></ul>\n":"</p>\n",
609 enc);
610 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 void gen_word(const psiconv_config config, psiconv_list list,
634 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 void gen_texted(const psiconv_config config, psiconv_list list,
646 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 int gen_xhtml(const psiconv_config config, psiconv_list list,
654 const psiconv_file file, const char *dest,
655 const encoding enc)
656 {
657 encoding enc1 = enc;
658
659 if (enc == ENCODING_PSION) {
660 fputs("Unsupported encoding\n",stderr);
661 return -1;
662 } else if (enc == ENCODING_ASCII)
663 enc1 = ENCODING_ASCII_HTML;
664
665 if (file->type == psiconv_word_file) {
666 gen_word(config,list,(psiconv_word_f) file->file,enc1);
667 return 0;
668 } else if (file->type == psiconv_texted_file) {
669 gen_texted(config,list,(psiconv_texted_f) file->file,enc1);
670 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 FORMAT_WORD | FORMAT_TEXTED,
682 gen_xhtml
683 },
684 {
685 NULL,
686 NULL,
687 0,
688 NULL
689 }
690 };
691
692
693 void init_xhtml(void)
694 {
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