program/psiconv/gen_html4.c

/*  gen_html.c - Part of psiconv, a PSION 5 file formats converter
    Copyright (c) 1999-2004  Frodo Looijaard <frodol@dds.nl>
                                                                                
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.
                                                                                
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
                                                                                
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#include "config.h"

#include <psiconv/configuration.h>
#include <psiconv/data.h>
#include "general.h"

#include <string.h>
#include <stdlib.h>

#ifdef DMALLOC
#include "dmalloc.h"
#endif

#define TEMPSTR_LEN 100

static void text(const psiconv_config config,psiconv_list list,
                 psiconv_string_t data,const encoding enc);
static void header(const psiconv_config config, psiconv_list list, 
                   const encoding enc);
static void footer(const psiconv_config config, psiconv_list list, 
                   const encoding enc);
static void characters(const psiconv_config config, psiconv_list list,
                const psiconv_string_t textstr,
                const psiconv_character_layout layout,const encoding enc);
static void paragraph(const psiconv_config config, psiconv_list list,
               psiconv_paragraph para, const encoding enc);
static void paragraphs(const psiconv_config config, psiconv_list list,
                psiconv_text_and_layout paragraphs, const encoding enc);
static void gen_word(const psiconv_config config, psiconv_list list,
                           const psiconv_word_f file, const encoding enc);
static void gen_texted(const psiconv_config config, psiconv_list list,
                    const psiconv_texted_f file, const encoding enc);
static int gen_html4(const psiconv_config config, psiconv_list list,
              const psiconv_file file, const char *dest,
              const encoding enc);


void text(const psiconv_config config,psiconv_list list,
          psiconv_string_t data,const encoding enc)
{
  int i;
  for (i = 0; i < psiconv_unicode_strlen(data); i++) {
    if ((data[i] == 0x06) || (data[i] == 0x07) || (data[i] == 0x08))
      output_simple_chars(config,list,"<BR>",enc);
    else if ((data[i] == 0x0b) || (data[i] == 0x0c))
      output_simple_chars(config,list,"-",enc);
    else if ((data[i] == 0x0f) || (data[i] == 0x09) || (data[i] == 0x0a))
      output_simple_chars(config,list," ",enc);
    else if (data[i] >= 0x20)
      output_char(config,list,data[i],enc);
  }
}

void header(const psiconv_config config, psiconv_list list, const encoding enc)
{
  output_simple_chars(config,list,"<!DOCTYPE html PUBLIC "
                                  "\"-//W3C//DTD HTML 4.01 Transitional//EN\" "
                                  "\"http://www.w3.org/TR/html4/loose.dtd\">\n",
                      enc);
  output_simple_chars(config,list,"<HTML>\n",enc);
  output_simple_chars(config,list,"<HEAD>\n",enc);
  output_simple_chars(config,list,"<META HTTP-EQUIV=\"Content-Type\" "
                                  "CONTENT=\"text/html; charset=",enc);
  output_simple_chars(config,list,enc==ENCODING_UTF8?"UTF-8":
                                  enc==ENCODING_UCS2?"UTF-16BE":
                                  enc==ENCODING_ASCII?"US-ASCII":
                                  "",enc);
  output_simple_chars(config,list,"\">\n",enc);
  output_simple_chars(config,list,"<TITLE>EPOC32 file "
                                  "converted by psiconv</TITLE>\n",enc);
  output_simple_chars(config,list,"</HEAD>\n",enc);
  output_simple_chars(config,list,"<BODY>\n",enc);
}

void footer(const psiconv_config config, psiconv_list list, const encoding enc)
{
  output_simple_chars(config,list,"</BODY>\n",enc);
  output_simple_chars(config,list,"</HTML>\n",enc);
}

int character_layout_equal(const psiconv_character_layout l1,
                           const psiconv_character_layout l2)
{
  int font_size1,font_size2; 

  font_size1 = l1->font_size < 8  ?1:
               l1->font_size < 10 ?2:
               l1->font_size < 13 ?3:
               l1->font_size < 17 ?4:
               l1->font_size < 24 ?5:
               l1->font_size < 36 ?6:7;
  font_size2 = l2->font_size < 8  ?1:
               l2->font_size < 10 ?2:
               l2->font_size < 13 ?3:
               l2->font_size < 17 ?4:
               l2->font_size < 24 ?5:
               l2->font_size < 36 ?6:7;

  return (l1 && l2 &&
          (l1->color->red == l2->color->red) &&
          (l1->color->green == l2->color->green) &&
          (l1->color->blue == l2->color->blue) &&
          (font_size1 == font_size2) &&
          (l1->italic == l2->italic) &&
          (l1->bold == l2->bold) &&
          (l1->super_sub == l2->super_sub) &&
          (l1->underline == l2->underline) &&
          (l1->strikethrough == l2->strikethrough) &&
          (l1->font->screenfont == l2->font->screenfont));
}
                                                                                
void characters(const psiconv_config config, psiconv_list list,
                const psiconv_string_t textstr,
                const psiconv_character_layout layout,const encoding enc)
{
  char tempstr[TEMPSTR_LEN];

  output_simple_chars(config,list,"<FONT face=\"",enc);
  output_simple_chars(config,list,
                layout->font->screenfont == psiconv_font_serif?"serif":
                layout->font->screenfont == psiconv_font_sansserif?"sans-serif":
                layout->font->screenfont == psiconv_font_nonprop?"monospace":
                layout->font->screenfont == psiconv_font_misc?"fantasy":"",
                enc);
  output_simple_chars(config,list,"\"",enc);
  
  if ((layout->font_size < 10)  || (layout->font_size >= 13)) {
    output_simple_chars(config,list," size=",enc);
    output_simple_chars(config,list,
                        layout->font_size < 8  ?"1":
                        layout->font_size < 10 ?"2":
                        layout->font_size < 13 ?"3":
                        layout->font_size < 17 ?"4":
                        layout->font_size < 24 ?"5":
                        layout->font_size < 36 ?"6":"7",enc);
  }
  if ((layout->color->red != 0) || (layout->color->green != 0) || 
      (layout->color->blue != 0)) {
    snprintf(tempstr,TEMPSTR_LEN,"%02x%02x%02x",
             layout->color->red,layout->color->green,layout->color->blue);
    output_simple_chars(config,list," color=#",enc);
    output_simple_chars(config,list,tempstr,enc);
  }
  output_simple_chars(config,list,">",enc);


  if (layout->italic)
    output_simple_chars(config,list,"<I>",enc);
  if (layout->bold)
    output_simple_chars(config,list,"<B>",enc);
  if (layout->super_sub != psiconv_normalscript)
    output_simple_chars(config,list,
                        layout->super_sub == psiconv_superscript?"<SUP>":
                        layout->super_sub == psiconv_subscript?"<SUB>":
                        "",enc);
  if (layout->strikethrough)
    output_simple_chars(config,list,"<S>",enc);
  if (layout->underline)
    output_simple_chars(config,list,"<U>",enc);

  text(config,list,textstr,enc);
  
  if (layout->underline)
    output_simple_chars(config,list,"</U>",enc);
  if (layout->strikethrough)
    output_simple_chars(config,list,"</S>",enc);
  if (layout->super_sub != psiconv_normalscript)
    output_simple_chars(config,list,
                        layout->super_sub == psiconv_superscript?"</SUP>":
                        layout->super_sub == psiconv_subscript?"</SUB>":
                        "",enc);
  if (layout->bold)
    output_simple_chars(config,list,"</B>",enc);
  if (layout->italic)
    output_simple_chars(config,list,"</I>",enc);
  output_simple_chars(config,list,"</FONT>",enc);
}

void paragraph(const psiconv_config config, psiconv_list list,
               psiconv_paragraph para, const encoding enc)
{
  int i,charnr,start,len;
  psiconv_string_t text;
  psiconv_in_line_layout layout,next_layout;


  output_simple_chars(config,list,
                      para->base_paragraph->bullet->on?"<UL><LI":"<P",enc);

  if (para->base_paragraph->justify_hor == psiconv_justify_centre) 
    output_simple_chars(config,list," align=center",enc);
  else if (para->base_paragraph->justify_hor == psiconv_justify_right) 
    output_simple_chars(config,list," align=right",enc);
  else if (para->base_paragraph->justify_hor == psiconv_justify_full) 
    output_simple_chars(config,list," align=justify",enc);

  output_simple_chars(config,list,">",enc);

  if (psiconv_list_length(para->in_lines) == 0) {
    if (psiconv_unicode_strlen(para->text))
      characters(config,list,para->text,para->base_character,enc);
  } else {
    charnr = 0;
    start = -1;
    for (i = 0; i < psiconv_list_length(para->in_lines); i++) {
      if (start < 0)
        start = charnr;
      if (!(layout = psiconv_list_get(para->in_lines,i))) {
        fputs("Internal data structures corruption\n",stderr);
        exit(1);
      }
      if (i+1 < psiconv_list_length(para->in_lines)) {
        if (!(next_layout = psiconv_list_get(para->in_lines,i+1))) {
          fputs("Internal data structures corruption\n",stderr);
          exit(1);
        }
      } else {
        next_layout = NULL;
      }
      if (next_layout &&
          character_layout_equal(layout->layout,next_layout->layout)) {
        charnr += layout->length;
        continue;
      }
      len = charnr - start + layout->length;
      if (len) {
        if (!(text = malloc(sizeof (*text) * (len + 1)))) {
          fputs("Out of memory error\n",stderr);
          exit(1);
        }
        memcpy(text,para->text+charnr,len * sizeof(*text));
        text[len] = 0;
        characters(config,list,text,layout->layout,enc);
        free(text);
      }
      charnr += layout->length;
      start = -1;
    }
  }
  output_simple_chars(config, list,
                      para->base_paragraph->bullet->on?"</UL>\n":"\n",enc);
}

void paragraphs(const psiconv_config config, psiconv_list list,
                psiconv_text_and_layout paragraphs, const encoding enc)
{
  int i;
  psiconv_paragraph para;
  for (i = 0; i < psiconv_list_length(paragraphs); i++) {
    if (!(para = psiconv_list_get(paragraphs,i))) {
      fputs("Internal datastructure corruption\n",stderr);
      exit(1);
    }
    paragraph(config,list,para,enc);
  }
}

void gen_word(const psiconv_config config, psiconv_list list,
                    const psiconv_word_f file, const encoding enc)
{
  if (!file)
    return;

  header(config,list,enc);
  paragraphs(config,list,file->paragraphs,enc);
  footer(config,list,enc);
}


void gen_texted(const psiconv_config config, psiconv_list list,
                    const psiconv_texted_f file, const encoding enc)
{
  header(config,list,enc);
  paragraphs(config,list,file->texted_sec->paragraphs,enc);
  footer(config,list,enc);
}

int gen_html4(const psiconv_config config, psiconv_list list,
              const psiconv_file file, const char *dest,
              const encoding enc)
{
  encoding enc1 = enc;

  if (enc == ENCODING_PSION) {
    fputs("Unsupported encoding\n",stderr);
      return -1;
  } else if (enc == ENCODING_ASCII)
    enc1 = ENCODING_ASCII_HTML;

  if (file->type == psiconv_word_file) {
    gen_word(config,list,(psiconv_word_f) file->file,enc1);
    return 0;
  } else if (file->type == psiconv_texted_file) {
    gen_texted(config,list,(psiconv_texted_f) file->file,enc1);
    return 0;
  } else
    return -1;
}
                                                                                

static struct fileformat_s ffs[] =
  {
    {
      "HTML4",
      "HTML 4.01 Transitional, without CSS",
      FORMAT_WORD | FORMAT_TEXTED,
      gen_html4
    },
    {
      NULL,
      NULL,
      0,
      NULL
    }
  };


void init_html4(void)
{
  int i;
  for (i = 0; ffs[i].name; i++)
    psiconv_list_add(fileformat_list,ffs+i);
}
1	frodo	192	/* 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	frodo	14
19	frodo	192	#include "config.h"
20	frodo	147
21	frodo	192	#include <psiconv/configuration.h>
22			#include <psiconv/data.h>
23			#include "general.h"
24	frodo	147
25	frodo	14	#include <string.h>
26			#include <stdlib.h>
27
28	frodo	142	#ifdef DMALLOC
29			#include "dmalloc.h"
30			#endif
31
32	frodo	192	#define TEMPSTR_LEN 100
33	frodo	14
34	frodo	192	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	frodo	193	static int gen_html4(const psiconv_config config, psiconv_list list,
52			const psiconv_file file, const char *dest,
53			const encoding enc);
54	frodo	14
55	frodo	147
56	frodo	192	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	frodo	193	else if ((data[i] == 0x0f) \|\| (data[i] == 0x09) \|\| (data[i] == 0x0a))
66	frodo	192	output_simple_chars(config,list," ",enc);
67			else if (data[i] >= 0x20)
68			output_char(config,list,data[i],enc);
69			}
70			}
71	frodo	147
72	frodo	192	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	frodo	147
93	frodo	192	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	frodo	14
99	frodo	195	int character_layout_equal(const psiconv_character_layout l1,
100			const psiconv_character_layout l2)
101			{
102			int font_size1,font_size2;
103	frodo	14
104	frodo	195	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	frodo	192	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	frodo	14
136	frodo	192	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	frodo	14
164
165	frodo	192	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	frodo	14
179	frodo	192	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	frodo	14	}
196
197	frodo	192	void paragraph(const psiconv_config config, psiconv_list list,
198			psiconv_paragraph para, const encoding enc)
199	frodo	14	{
200	frodo	195	int i,charnr,start,len;
201	frodo	192	psiconv_string_t text;
202	frodo	195	psiconv_in_line_layout layout,next_layout;
203	frodo	14
204
205	frodo	192	output_simple_chars(config,list,
206			para->base_paragraph->bullet->on?"<UL><LI":"<P",enc);
207	frodo	14
208	frodo	192	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	frodo	14
215	frodo	192	output_simple_chars(config,list,">",enc);
216	frodo	14
217	frodo	192	if (psiconv_list_length(para->in_lines) == 0) {
218	frodo	195	if (psiconv_unicode_strlen(para->text))
219			characters(config,list,para->text,para->base_character,enc);
220	frodo	192	} else {
221			charnr = 0;
222	frodo	195	start = -1;
223	frodo	192	for (i = 0; i < psiconv_list_length(para->in_lines); i++) {
224	frodo	195	if (start < 0)
225			start = charnr;
226	frodo	192	if (!(layout = psiconv_list_get(para->in_lines,i))) {
227			fputs("Internal data structures corruption\n",stderr);
228			exit(1);
229			}
230	frodo	195	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	frodo	192	}
238	frodo	195	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	frodo	192	charnr += layout->length;
255	frodo	195	start = -1;
256	frodo	14	}
257	frodo	192	}
258			output_simple_chars(config, list,
259			para->base_paragraph->bullet->on?"</UL>\n":"\n",enc);
260	frodo	14	}
261
262	frodo	192	void paragraphs(const psiconv_config config, psiconv_list list,
263			psiconv_text_and_layout paragraphs, const encoding enc)
264	frodo	14	{
265	frodo	192	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	frodo	14	}
272	frodo	192	paragraph(config,list,para,enc);
273			}
274	frodo	14	}
275
276	frodo	192	void gen_word(const psiconv_config config, psiconv_list list,
277			const psiconv_word_f file, const encoding enc)
278	frodo	14	{
279	frodo	192	if (!file)
280			return;
281	frodo	14
282	frodo	192	header(config,list,enc);
283			paragraphs(config,list,file->paragraphs,enc);
284			footer(config,list,enc);
285	frodo	14	}
286
287
288	frodo	192	void gen_texted(const psiconv_config config, psiconv_list list,
289			const psiconv_texted_f file, const encoding enc)
290	frodo	14	{
291	frodo	192	header(config,list,enc);
292			paragraphs(config,list,file->texted_sec->paragraphs,enc);
293			footer(config,list,enc);
294	frodo	14	}
295
296	frodo	192	int gen_html4(const psiconv_config config, psiconv_list list,
297			const psiconv_file file, const char *dest,
298			const encoding enc)
299	frodo	14	{
300	frodo	192	encoding enc1 = enc;
301	frodo	14
302	frodo	192	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	frodo	14
308	frodo	192	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	frodo	14	}
317	frodo	192
318	frodo	14
319	frodo	192	static struct fileformat_s ffs[] =
320	frodo	34	{
321	frodo	192	{
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	frodo	34	};
334
335	frodo	192
336	frodo	34	void init_html4(void)
337			{
338	frodo	192	int i;
339			for (i = 0; ffs[i].name; i++)
340			psiconv_list_add(fileformat_list,ffs+i);
341	frodo	34	}
frodo@frodo.looijaard.name	ViewVC Help
Powered by ViewVC 1.1.26