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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 195 - (show annotations)
Wed Feb 4 11:35:35 2004 UTC (20 years, 1 month ago) by frodo
File MIME type: text/plain
File size: 12226 byte(s)
(Frodo) Format documentation work

  * Uploaded newest Format documentation
  * Split generate_html.sh into xhtml and html4 specific versions
  * Changed gen_xhtml and gen_html4 to combine spans that have the
    same layout codes
  * Changed gen_xhtml and gen_html4 not to emit empty spans

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 header(const psiconv_config config, psiconv_list list,
37 const encoding enc);
38 static void footer(const psiconv_config config, psiconv_list list,
39 const encoding enc);
40 static void characters(const psiconv_config config, psiconv_list list,
41 const psiconv_string_t textstr,
42 const psiconv_character_layout layout,const encoding enc);
43 static void paragraph(const psiconv_config config, psiconv_list list,
44 psiconv_paragraph para, const encoding enc);
45 static void paragraphs(const psiconv_config config, psiconv_list list,
46 psiconv_text_and_layout paragraphs, const encoding enc);
47 static void gen_word(const psiconv_config config, psiconv_list list,
48 const psiconv_word_f file, const encoding enc);
49 static void gen_texted(const psiconv_config config, psiconv_list list,
50 const psiconv_texted_f file, const encoding enc);
51 static int gen_html4(const psiconv_config config, psiconv_list list,
52 const psiconv_file file, const char *dest,
53 const encoding enc);
54
55
56 void text(const psiconv_config config,psiconv_list list,
57 psiconv_string_t data,const encoding enc)
58 {
59 int i;
60 for (i = 0; i < psiconv_unicode_strlen(data); i++) {
61 if ((data[i] == 0x06) || (data[i] == 0x07) || (data[i] == 0x08))
62 output_simple_chars(config,list,"<BR>",enc);
63 else if ((data[i] == 0x0b) || (data[i] == 0x0c))
64 output_simple_chars(config,list,"-",enc);
65 else if ((data[i] == 0x0f) || (data[i] == 0x09) || (data[i] == 0x0a))
66 output_simple_chars(config,list," ",enc);
67 else if (data[i] >= 0x20)
68 output_char(config,list,data[i],enc);
69 }
70 }
71
72 void header(const psiconv_config config, psiconv_list list, const encoding enc)
73 {
74 output_simple_chars(config,list,"<!DOCTYPE html PUBLIC "
75 "\"-//W3C//DTD HTML 4.01 Transitional//EN\" "
76 "\"http://www.w3.org/TR/html4/loose.dtd\">\n",
77 enc);
78 output_simple_chars(config,list,"<HTML>\n",enc);
79 output_simple_chars(config,list,"<HEAD>\n",enc);
80 output_simple_chars(config,list,"<META HTTP-EQUIV=\"Content-Type\" "
81 "CONTENT=\"text/html; charset=",enc);
82 output_simple_chars(config,list,enc==ENCODING_UTF8?"UTF-8":
83 enc==ENCODING_UCS2?"UTF-16BE":
84 enc==ENCODING_ASCII?"US-ASCII":
85 "",enc);
86 output_simple_chars(config,list,"\">\n",enc);
87 output_simple_chars(config,list,"<TITLE>EPOC32 file "
88 "converted by psiconv</TITLE>\n",enc);
89 output_simple_chars(config,list,"</HEAD>\n",enc);
90 output_simple_chars(config,list,"<BODY>\n",enc);
91 }
92
93 void footer(const psiconv_config config, psiconv_list list, const encoding enc)
94 {
95 output_simple_chars(config,list,"</BODY>\n",enc);
96 output_simple_chars(config,list,"</HTML>\n",enc);
97 }
98
99 int character_layout_equal(const psiconv_character_layout l1,
100 const psiconv_character_layout l2)
101 {
102 int font_size1,font_size2;
103
104 font_size1 = l1->font_size < 8 ?1:
105 l1->font_size < 10 ?2:
106 l1->font_size < 13 ?3:
107 l1->font_size < 17 ?4:
108 l1->font_size < 24 ?5:
109 l1->font_size < 36 ?6:7;
110 font_size2 = l2->font_size < 8 ?1:
111 l2->font_size < 10 ?2:
112 l2->font_size < 13 ?3:
113 l2->font_size < 17 ?4:
114 l2->font_size < 24 ?5:
115 l2->font_size < 36 ?6:7;
116
117 return (l1 && l2 &&
118 (l1->color->red == l2->color->red) &&
119 (l1->color->green == l2->color->green) &&
120 (l1->color->blue == l2->color->blue) &&
121 (font_size1 == font_size2) &&
122 (l1->italic == l2->italic) &&
123 (l1->bold == l2->bold) &&
124 (l1->super_sub == l2->super_sub) &&
125 (l1->underline == l2->underline) &&
126 (l1->strikethrough == l2->strikethrough) &&
127 (l1->font->screenfont == l2->font->screenfont));
128 }
129
130 void characters(const psiconv_config config, psiconv_list list,
131 const psiconv_string_t textstr,
132 const psiconv_character_layout layout,const encoding enc)
133 {
134 char tempstr[TEMPSTR_LEN];
135
136 output_simple_chars(config,list,"<FONT face=\"",enc);
137 output_simple_chars(config,list,
138 layout->font->screenfont == psiconv_font_serif?"serif":
139 layout->font->screenfont == psiconv_font_sansserif?"sans-serif":
140 layout->font->screenfont == psiconv_font_nonprop?"monospace":
141 layout->font->screenfont == psiconv_font_misc?"fantasy":"",
142 enc);
143 output_simple_chars(config,list,"\"",enc);
144
145 if ((layout->font_size < 10) || (layout->font_size >= 13)) {
146 output_simple_chars(config,list," size=",enc);
147 output_simple_chars(config,list,
148 layout->font_size < 8 ?"1":
149 layout->font_size < 10 ?"2":
150 layout->font_size < 13 ?"3":
151 layout->font_size < 17 ?"4":
152 layout->font_size < 24 ?"5":
153 layout->font_size < 36 ?"6":"7",enc);
154 }
155 if ((layout->color->red != 0) || (layout->color->green != 0) ||
156 (layout->color->blue != 0)) {
157 snprintf(tempstr,TEMPSTR_LEN,"%02x%02x%02x",
158 layout->color->red,layout->color->green,layout->color->blue);
159 output_simple_chars(config,list," color=#",enc);
160 output_simple_chars(config,list,tempstr,enc);
161 }
162 output_simple_chars(config,list,">",enc);
163
164
165 if (layout->italic)
166 output_simple_chars(config,list,"<I>",enc);
167 if (layout->bold)
168 output_simple_chars(config,list,"<B>",enc);
169 if (layout->super_sub != psiconv_normalscript)
170 output_simple_chars(config,list,
171 layout->super_sub == psiconv_superscript?"<SUP>":
172 layout->super_sub == psiconv_subscript?"<SUB>":
173 "",enc);
174 if (layout->strikethrough)
175 output_simple_chars(config,list,"<S>",enc);
176 if (layout->underline)
177 output_simple_chars(config,list,"<U>",enc);
178
179 text(config,list,textstr,enc);
180
181 if (layout->underline)
182 output_simple_chars(config,list,"</U>",enc);
183 if (layout->strikethrough)
184 output_simple_chars(config,list,"</S>",enc);
185 if (layout->super_sub != psiconv_normalscript)
186 output_simple_chars(config,list,
187 layout->super_sub == psiconv_superscript?"</SUP>":
188 layout->super_sub == psiconv_subscript?"</SUB>":
189 "",enc);
190 if (layout->bold)
191 output_simple_chars(config,list,"</B>",enc);
192 if (layout->italic)
193 output_simple_chars(config,list,"</I>",enc);
194 output_simple_chars(config,list,"</FONT>",enc);
195 }
196
197 void paragraph(const psiconv_config config, psiconv_list list,
198 psiconv_paragraph para, const encoding enc)
199 {
200 int i,charnr,start,len;
201 psiconv_string_t text;
202 psiconv_in_line_layout layout,next_layout;
203
204
205 output_simple_chars(config,list,
206 para->base_paragraph->bullet->on?"<UL><LI":"<P",enc);
207
208 if (para->base_paragraph->justify_hor == psiconv_justify_centre)
209 output_simple_chars(config,list," align=center",enc);
210 else if (para->base_paragraph->justify_hor == psiconv_justify_right)
211 output_simple_chars(config,list," align=right",enc);
212 else if (para->base_paragraph->justify_hor == psiconv_justify_full)
213 output_simple_chars(config,list," align=justify",enc);
214
215 output_simple_chars(config,list,">",enc);
216
217 if (psiconv_list_length(para->in_lines) == 0) {
218 if (psiconv_unicode_strlen(para->text))
219 characters(config,list,para->text,para->base_character,enc);
220 } else {
221 charnr = 0;
222 start = -1;
223 for (i = 0; i < psiconv_list_length(para->in_lines); i++) {
224 if (start < 0)
225 start = charnr;
226 if (!(layout = psiconv_list_get(para->in_lines,i))) {
227 fputs("Internal data structures corruption\n",stderr);
228 exit(1);
229 }
230 if (i+1 < psiconv_list_length(para->in_lines)) {
231 if (!(next_layout = psiconv_list_get(para->in_lines,i+1))) {
232 fputs("Internal data structures corruption\n",stderr);
233 exit(1);
234 }
235 } else {
236 next_layout = NULL;
237 }
238 if (next_layout &&
239 character_layout_equal(layout->layout,next_layout->layout)) {
240 charnr += layout->length;
241 continue;
242 }
243 len = charnr - start + layout->length;
244 if (len) {
245 if (!(text = malloc(sizeof (*text) * (len + 1)))) {
246 fputs("Out of memory error\n",stderr);
247 exit(1);
248 }
249 memcpy(text,para->text+charnr,len * sizeof(*text));
250 text[len] = 0;
251 characters(config,list,text,layout->layout,enc);
252 free(text);
253 }
254 charnr += layout->length;
255 start = -1;
256 }
257 }
258 output_simple_chars(config, list,
259 para->base_paragraph->bullet->on?"</UL>\n":"\n",enc);
260 }
261
262 void paragraphs(const psiconv_config config, psiconv_list list,
263 psiconv_text_and_layout paragraphs, const encoding enc)
264 {
265 int i;
266 psiconv_paragraph para;
267 for (i = 0; i < psiconv_list_length(paragraphs); i++) {
268 if (!(para = psiconv_list_get(paragraphs,i))) {
269 fputs("Internal datastructure corruption\n",stderr);
270 exit(1);
271 }
272 paragraph(config,list,para,enc);
273 }
274 }
275
276 void gen_word(const psiconv_config config, psiconv_list list,
277 const psiconv_word_f file, const encoding enc)
278 {
279 if (!file)
280 return;
281
282 header(config,list,enc);
283 paragraphs(config,list,file->paragraphs,enc);
284 footer(config,list,enc);
285 }
286
287
288 void gen_texted(const psiconv_config config, psiconv_list list,
289 const psiconv_texted_f file, const encoding enc)
290 {
291 header(config,list,enc);
292 paragraphs(config,list,file->texted_sec->paragraphs,enc);
293 footer(config,list,enc);
294 }
295
296 int gen_html4(const psiconv_config config, psiconv_list list,
297 const psiconv_file file, const char *dest,
298 const encoding enc)
299 {
300 encoding enc1 = enc;
301
302 if (enc == ENCODING_PSION) {
303 fputs("Unsupported encoding\n",stderr);
304 return -1;
305 } else if (enc == ENCODING_ASCII)
306 enc1 = ENCODING_ASCII_HTML;
307
308 if (file->type == psiconv_word_file) {
309 gen_word(config,list,(psiconv_word_f) file->file,enc1);
310 return 0;
311 } else if (file->type == psiconv_texted_file) {
312 gen_texted(config,list,(psiconv_texted_f) file->file,enc1);
313 return 0;
314 } else
315 return -1;
316 }
317
318
319 static struct fileformat_s ffs[] =
320 {
321 {
322 "HTML4",
323 "HTML 4.01 Transitional, without CSS",
324 FORMAT_WORD | FORMAT_TEXTED,
325 gen_html4
326 },
327 {
328 NULL,
329 NULL,
330 0,
331 NULL
332 }
333 };
334
335
336 void init_html4(void)
337 {
338 int i;
339 for (i = 0; ffs[i].name; i++)
340 psiconv_list_add(fileformat_list,ffs+i);
341 }

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