program/psiconv/gen_html4.c

/*
 * gen_html4.c - Part of psiconv, a PSION 5 data formats converter
 * Copyright (c) 1999  Andrew Johnson <anjohnson@iee.org>
 * Portions Copyright (c) 1999  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 <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include "psiconv/data.h"
#include "psiconv/list.h"
#include "gen.h"
#include "psiconv.h"

#ifndef TRUE
#define TRUE (0==0)
#endif

/*
 * Various string tables for HTML4 settings
 */

/* How to display each character */
static const char *char_table[0x100] = {
  /* 0x00 */ "", "", "", "", "", "", "<BR>\n", "<BR>\n",
  /* 0x08 */ "\n<HR>\n", "\t", "", "", "", "", "", "",
  /* 0x10 */ " ", "", "", "", "", "", "", "",
  /* 0x18 */ "", "", "", "", "", "", "", "",
  /* 0x20 */ " ", "!", "&quot;", "#", "$", "%", "&amp;", "'",
  /* 0x28 */ "(", ")", "*", "+", ",", "-", ".", "/",
  /* 0x30 */ "0", "1", "2", "3", "4", "5", "6", "7",
  /* 0x38 */ "8", "9", ":", ";", "&lt;", "=", "&gt;", "?",
  /* 0x40 */ "@", "A", "B", "C", "D", "E", "F", "G",
  /* 0x48 */ "H", "I", "J", "K", "L", "M", "N", "O",
  /* 0x50 */ "P", "Q", "R", "S", "T", "U", "V", "W",
  /* 0x58 */ "X", "Y", "Z", "[", "\\", "]", "^", "_",
  /* 0x60 */ "`", "a", "b", "c", "d", "e", "f", "g",
  /* 0x68 */ "h", "i", "j", "k", "l", "m", "n", "o",
  /* 0x70 */ "p", "q", "r", "s", "t", "u", "v", "w",
  /* 0x78 */ "x", "y", "z", "{", "|", "}", "~", "",
  /* 0x80 */ "", "", "&#8218;", "&#402;",
             "&#8222;", "&#8230;", "&#8224;", "&#8225;",
  /* 0x88 */ "&#136;", "&#8240;", "&#352;", "<",
             "&#338;", "", "", "",
  /* 0x90 */ "", "&#8216;", "&#8217;", "&#8220;",
             "&#8221;","&#8226;", "&#8211;", "&#8212;",
  /* 0x98 */ "&#732;", "&#8482;", "&#353;", ">",
             "&#339;", "", "", "&#376;",
  /* 0xa0 */ "&nbsp;", "&iexcl;", "&cent;", "&pound;",
             "&curren;", "&yen;", "&brvbar;", "&sect;",
  /* 0xa8 */ "&uml;", "&copy;", "&ordf;", "&laquo;",
             "&not;", "&shy;", "&reg;", "&#175;",
  /* 0xb0 */ "&deg;", "&plusmn;", "&sup2;", "&sup3;",
             "&acute;", "&micro;", "&para;", "&middot;",
  /* 0xb8 */ "&cedil;", "&sup1;", "&ordm;", "&raquo;",
             "&frac14;", "&frac12;", "&frac34;", "&iquest;",
  /* 0xc0 */ "&Agrave;", "&Aacute;", "&Acirc;", "&Atilde;",
             "&Auml;", "&Aring;", "&AElig;", "&Ccedil;",
  /* 0xc8 */ "&Egrave;", "&Eacute;", "&Ecirc;", "&Euml;",
             "&Igrave;", "&Iacute;", "&Icirc;", "&Iuml;",
  /* 0xd0 */ "&ETH;", "&Ntilde;", "&Ograve;", "&Oacute;",
             "&Ocirc;", "&Otilde;", "&Ouml;", "&times;",
  /* 0xd8 */ "&Oslash;", "&Ugrave;", "&Uacute;", "&Ucirc;",
             "&Uuml;", "&Yacute;", "&THORN;", "&szlig;",
  /* 0xe0 */ "&agrave;", "&aacute;", "&acirc;", "&atilde;",
             "&auml;", "&aring;", "&aelig;", "&ccedil;",
  /* 0xe8 */ "&egrave;", "&eacute;", "&ecirc;", "&euml;",
             "&igrave;", "&iacute;", "&icirc;", "&iuml;",
  /* 0xf0 */ "&eth;", "&ntilde;", "&ograve;", "&oacute;",
             "&ocirc;", "&otilde;", "&ouml;", "&divide;",
  /* 0xf8 */ "&oslash;", "&ugrave;", "&uacute;", "&ucirc;",
             "&uuml;", "&yacute;", "&thorn;", "&yuml;"
};

/* The order of these must match the enum psiconv_border_kind (data.h) */
static const char *border_strings[] = {
    "none", "solid", "double", "dotted", "dashed", "dashed", "dotted"
};

/* The order of these must match the enum psiconv_justify (data.h) */
static const char *justify_strings[] = {
    "left", "center", "right", "justify"
};

/* The order of these must match the enum psiconv_super_sub (data.h) */
static const char *vertical_strings[] = {
    "baseline", "super", "sub"
};


/*
 * Support routines for particular formatting structures
 */

static void fput_name(FILE * of, const char *string) {
    int i;

    for (i = 0; i < strlen(string); i++)
        if (isalnum(string[i]))
            putc(string[i], of);
}

static void fput_text(FILE * of, const char *text, int length, int *pwasspace) {
    int j;
    int space;
    
    for (j = 0; j < length; j++) {
        space = (text[j] == ' ');
        if (*pwasspace && space)
            fputs("&nbsp;", of);
        else
            fputs(char_table[(unsigned char) (text[j])], of);
        *pwasspace = space;
    }
}

static const char *screenfont_name(psiconv_u8 screenfont)
{
  if (screenfont == 1)
    return "sans-serif";
  else if (screenfont == 2)
    return "monospace";
  else if (screenfont == 3)
    return "serif";
  else
    return "serif";
}

static const char *generic_font_family(const char *font_name) {
    static const char *sans_font_names[] = {
        "Arial", "Univers", "Sans Serif"
    };
    static const char *mono_font_names[] = {
        "Courier New", "Courier", "Mono", "Lineprinter", "Elite", "Swiss",
        "Courier (compressed)", "Courier (expanded)", "Letter Gothic"
    };
    int i;
    
    for (i=0; i < sizeof(sans_font_names) / sizeof(sans_font_names[0]); i++)
        if (!strcmp(font_name, sans_font_names[i]))
            return "sans-serif";
    
    for (i=0; i < sizeof(mono_font_names) / sizeof(mono_font_names[0]); i++)
        if (!strcmp(font_name, mono_font_names[i]))
            return "monospace";
    
    return "serif";
}

static int colors_different(
    const psiconv_color old,
    const psiconv_color new)
{
    return ((old->red != new->red) ||
            (old->green != new->green) ||
            (old->blue != new->blue));
}


/* Borders */
static int borders_different(
    const psiconv_border old, 
    const psiconv_border new)
{
    return (!old || 
            (old->kind != new->kind) ||
            colors_different(old->color, new->color) ||
            (old->thickness != new->thickness));
}

static void fput_border(FILE * of, 
    const char *which,
    const psiconv_border old, 
    const psiconv_border new)
{
    /* If the border changed at all we'll set all parameters, as they're
     * fairly closely linked and it's much easier to do it this way */
    if (borders_different(old, new)) {
        fprintf(of, "border-%s-style:%s;", 
                which, border_strings[new->kind]);
        if ((new->kind != psiconv_border_none) &&
            (new->color->red || new->color->green || new->color->blue))
            fprintf(of, "border-%s-color:#%02x%02x%02x;", which,
                    new->color->red, new->color->green, new->color->blue);
        if ((new->kind == psiconv_border_solid) ||
            (new->kind == psiconv_border_double))
            fprintf(of, "border-%s-width:%.0fpx;", 
                    which, (new->thickness / 10.0) - 1);
        else if (new->kind != psiconv_border_none)
            fprintf(of, "border-%s-width:1px;", which);
    }
}

/* Paragraph formats */
static int paragraph_layouts_different(
    const psiconv_paragraph_layout old,
    const psiconv_paragraph_layout new)
{
    return ((old->top_space != new->top_space) ||
            (old->indent_right != new->indent_right) ||
            (old->bottom_space != new->bottom_space) ||
            (old->indent_left != new->indent_left) ||
            (old->indent_first != new->indent_first) ||
            (old->justify_hor != new->justify_hor) ||
            (old->interline_exact != new->interline_exact) ||
            borders_different(old->left_border, new->left_border) ||
            borders_different(old->right_border, new->right_border) ||
            borders_different(old->top_border, new->top_border) ||
            borders_different(old->bottom_border, new->bottom_border));
}

static void fput_paragraph_layout(FILE * of, 
    const psiconv_paragraph_layout old,
    const psiconv_paragraph_layout new)
{
    if (!old || (old->top_space != new->top_space))
        fprintf(of, "margin-top:%.1fpt;", new->top_space);
    if (!old || (old->indent_right != new->indent_right))
        fprintf(of, "margin-right:%.2fcm;", new->indent_right);
    if (!old || (old->bottom_space != new->bottom_space))
        fprintf(of, "margin-bottom:%.1fpt;", new->bottom_space);
    if (!old || 
        (old->bullet->on != new->bullet->on) ||
        (old->bullet->indent != new->bullet->indent) ||
        (old->indent_left != new->indent_left) ||
        (old->indent_first != new->indent_first)) {
        psiconv_length_t indent = new->indent_first;
        psiconv_length_t margin = new->indent_left;
        /* Bullets with indent set cause strange margin behaviour: */
        if (new->bullet->on && new->bullet->indent) {
            if (indent > 0.0) {
                margin += indent;
                indent = new->indent_left - indent;
            }
        }
        fprintf(of, "margin-left:%.2fcm;", margin);
        fprintf(of, "text-indent:%.2fcm;", indent);
    }
    if (!old || (old->justify_hor != new->justify_hor))
        fprintf(of, "text-align:%s;", justify_strings[new->justify_hor]);
    if (!old || (old->interline_exact != new->interline_exact)) {
        if (!old || old->interline_exact)
            fputs("line-height:normal;", of);
        else
            fprintf(of, "line-height:%.1fpt;", new->interline);
    }
    fput_border(of, "left", old ? old->left_border : NULL, 
                new->left_border);
    fput_border(of, "right", old ? old->right_border : NULL, 
                new->right_border);
    fput_border(of, "top", old ? old->top_border : NULL, 
                new->top_border);
    fput_border(of, "bottom", old ? old->bottom_border : NULL, 
                new->bottom_border);
}

/* Character formats */
static int character_layouts_different(
    const psiconv_character_layout old,
    const psiconv_character_layout new)
{
    return ((old->font->screenfont != new->font->screenfont) ||
            (strcmp(old->font->name,new->font->name)) ||
            (old->font_size != new->font_size) ||
            (old->color->red != new->color->red) ||
            (old->color->green != new->color->green) ||
            (old->color->blue != new->color->blue) ||
            (old->back_color->red != new->back_color->red) ||
            (old->back_color->green != new->back_color->green) ||
            (old->back_color->blue != new->back_color->blue) ||
            (old->italic != new->italic) ||
            (old->bold != new->bold) ||
            (old->super_sub != new->super_sub) ||
            (old->underline != new->underline) ||
            (old->strike_out != new->strike_out));
}

static void fput_character_layout(FILE * of,
    const psiconv_character_layout old,
    const psiconv_character_layout new,
    psiconv_word_f wf)
{
    if (!old || (old->font->screenfont != new->font->screenfont) ||
        strcmp(old->font->name,new->font->name)) {
           fprintf(of, "font-family:%s,%s,%s;", new->font->name,
                   generic_font_family(new->font->name),
                   screenfont_name(new->font->screenfont));
    }
    if (!old || (old->font_size != new->font_size))
        fprintf(of, "font-size:%.1f%%;", 100.0 * new->font_size / 10.0);
    if (!old || (old->bold != new->bold))
        fprintf(of, "font-weight:%s;", new->bold ? "bold" : "normal");
    if (!old || (old->italic != new->italic))
        fprintf(of, "font-style:%s;", new->italic ? "italic" : "normal");
    if (!old || (colors_different(old->color, new->color)))
        fprintf(of, "color:#%02x%02x%02x;", 
                new->color->red, new->color->green, new->color->blue);
    if (!old || (colors_different(old->back_color, new->back_color)))
        fprintf(of, "background-color:#%02x%02x%02x;",
                new->back_color->red, new->back_color->green, new->back_color->blue);
    if (!old || (old->super_sub != new->super_sub))
        fprintf(of, "vertical-align:%s;", vertical_strings[new->super_sub]);
    if (!old || (old->underline != new->underline) ||
        (old->strike_out != new->strike_out)) {
        fputs("text-decoration:", of);
        if (new->strike_out)
            fputs("line-through ", of);
        if (new->underline)
            fputs("underline", of);
        else if (!new->strike_out)
            fputs("none", of);
        fputs(";", of);
    }
}


/* Formatted paragraphs */
static void fput_para(FILE * of, 
    const psiconv_paragraph para, 
    psiconv_word_f wf)
{
    psiconv_paragraph_layout base_para = para->base_paragraph;
    psiconv_character_layout base_char = para->base_character;
    psiconv_character_layout cur_char;
    psiconv_character_layout *layout_stack;
    psiconv_in_line_layout inl;
    psiconv_word_style sty;
    int spans = 0;
    int wasspace = 0;
    int i, j, loc;
    
    layout_stack = calloc(psiconv_list_length(para->in_lines),
                          sizeof(*layout_stack));
    fputs("<P", of);
    sty = psiconv_get_style(wf->styles_sec, para->base_style);
    cur_char = sty->character;
    
    if (sty->name) {
        fputs(" CLASS=\"", of);
        fput_name(of, sty->name);
        putc('"', of);
    }
    
    if (paragraph_layouts_different(sty->paragraph, base_para) ||
        character_layouts_different(cur_char, base_char)) {
        fputs(" STYLE=\"", of);
        fput_paragraph_layout(of, sty->paragraph, base_para);
        fput_character_layout(of, cur_char, base_char, wf);
        cur_char = base_char;
        putc('"', of);
    }
    putc('>', of);
    
    if (base_para->bullet->on) {
        fputs("<SPAN STYLE=\"", of);
        if (base_para->bullet->font != base_char->font) {
            fprintf(of, "font-family:%s,%s,%s;", 
                    base_para->bullet->font->name, 
                    generic_font_family(base_para->bullet->font->name),
                    screenfont_name(base_para->bullet->font->screenfont));
        }
        if (base_para->bullet->font_size != base_char->font_size)
            fprintf(of, "font-size:%.1f%%;", 
                    100.0 * base_para->bullet->font_size / 10.0);
        if ((base_para->bullet->color->red != base_char->color->red) ||
            (base_para->bullet->color->green != base_char->color->green) ||
            (base_para->bullet->color->blue != base_char->color->blue))
            fprintf(of, "color:#%02x%02x%02x;", 
                    base_para->bullet->color->red, 
                    base_para->bullet->color->green, 
                    base_para->bullet->color->blue);
        fprintf(of, "\">%s </SPAN>", 
                char_table[base_para->bullet->character]);
        wasspace = TRUE;
    }
    
    loc = 0;
    for (i = 0; i < psiconv_list_length(para->in_lines); i++) {
        inl = psiconv_list_get(para->in_lines, i);
        if (character_layouts_different(cur_char, inl->layout)) {
            for (j = 0; j < spans; j++)
                if (!character_layouts_different(inl->layout, layout_stack[j]))
                    break;
            if (j < spans) {
                while (spans > j) {
                    fputs("</SPAN>",of);
                    spans--;
                }
            } else {
                fputs("<SPAN STYLE=\"", of);
                fput_character_layout(of, cur_char, inl->layout, wf);
                fputs("\">",of);
                layout_stack[spans++] = cur_char;
            }
            cur_char = inl->layout;
        }
        fput_text(of, &para->text[loc], inl->length, &wasspace);
        loc += inl->length;
    }
    
    while (spans > 0) {
        fputs("</SPAN>",of);
        spans--;
    }

    if (loc < strlen(para->text)) {
        fput_text(of, &para->text[loc], strlen(para->text) - loc, &wasspace);
    }
    
    if (strlen(para->text) == 0)
        fputs("&nbsp;", of);

    fputs("</P>\n", of);
    free(layout_stack);
}

static void fput_style(FILE * of, 
    const psiconv_word_style normal, 
    const psiconv_word_style sty, 
    psiconv_word_f wf)
{
    if (sty->name == NULL)
        fputs("  P {", of);
    else {
        fputs("  P.", of);
        fput_name(of, sty->name);
        fputs(" {", of);
    }
    fput_paragraph_layout(of, normal ? normal->paragraph : NULL, sty->paragraph);
    fput_character_layout(of, normal ? normal->character : NULL, sty->character, wf);
    fputs("}\n", of);
}

static int psiconv_gen_html4(const char *filename, const psiconv_file file, 
                             const char *dest)
{
    FILE * of;
    int i;
    psiconv_paragraph para;
    psiconv_word_style normal, sty;
    psiconv_word_f wf;

    if (file->type == psiconv_word_file)
      wf = file->file;
    else {
      /* Fall back on the normal HTML generator */
      return psiconv_gen_html(filename,file,dest);
    }

    if (! (of = fopen(filename,"w"))) 
        return -1;

    fputs("<!doctype html public \"-//W3C//DTD HTML 4.0 STRICT//EN\">", of);
    fputs("\n<HTML>\n<HEAD>\n  <META NAME=\"GENERATOR\"", of);
    fputs(" CONTENT=\"psiconv-" VERSION "\">\n", of);
    
    if (psiconv_list_length(wf->page_sec->header->text->paragraphs) > 0) {
        fputs("  <TITLE>", of);
        para = psiconv_list_get(wf->page_sec->header->text->paragraphs, 0);
        i = 0;
        fput_text(of, para->text, strlen(para->text), &i);
        fputs("</TITLE>\n", of);
    }
    
    normal = wf->styles_sec->normal;
    fputs("  <STYLE TYPE=\"text/css\"><!--\n", of);
    fprintf(of,"  BODY { background-color: #%02x%02x%02x }\n",
          normal->paragraph->back_color->red, 
          normal->paragraph->back_color->green,
          normal->paragraph->back_color->blue);
    fput_style(of, NULL, normal, wf);
    for (i = 0; i < psiconv_list_length(wf->styles_sec->styles); i++) {
        sty = psiconv_list_get(wf->styles_sec->styles, i);
        fput_style(of, normal, sty, wf);
    }
    fputs("  --></STYLE>\n</HEAD>\n<BODY>\n", of);
    for (i = 0; i < psiconv_list_length(wf->paragraphs); i++) {
        para = psiconv_list_get(wf->paragraphs, i);
        fput_para(of, para, wf);
    }
    fputs("</BODY>\n</HTML>\n", of);

    return fclose(of);
}

static struct psiconv_fileformat_s ff =
  {
    "HTML4",
    "HTML 4.0 with cascading style sheets",
    psiconv_gen_html4
  };

void init_html4(void)
{
  psiconv_list_add(fileformat_list,&ff);
}

1	frodo	14	/*
2			* gen_html4.c - Part of psiconv, a PSION 5 data formats converter
3			* Copyright (c) 1999 Andrew Johnson <anjohnson@iee.org>
4			* Portions Copyright (c) 1999 Frodo Looijaard <frodol@dds.nl>
5			*
6			* This program is free software; you can redistribute it and/or modify
7			* it under the terms of the GNU General Public License as published by
8			* the Free Software Foundation; either version 2 of the License, or
9			* (at your option) any later version.
10			*
11			* This program is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU General Public License for more details.
15			*
16			* You should have received a copy of the GNU General Public License
17			* along with this program; if not, write to the Free Software
18			* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19			*/
20
21			#include "config.h"
22			#include <stdio.h>
23			#include <string.h>
24			#include <ctype.h>
25			#include <stdlib.h>
26	frodo	58	#include "psiconv/data.h"
27			#include "psiconv/list.h"
28	frodo	14	#include "gen.h"
29	frodo	34	#include "psiconv.h"
30	frodo	14
31			#ifndef TRUE
32			#define TRUE (0==0)
33			#endif
34
35			/*
36			* Various string tables for HTML4 settings
37			*/
38
39			/* How to display each character */
40			static const char *char_table[0x100] = {
41			/* 0x00 */ "", "", "", "", "", "", "<BR>\n", "<BR>\n",
42			/* 0x08 */ "\n<HR>\n", "\t", "", "", "", "", "", "",
43			/* 0x10 */ " ", "", "", "", "", "", "", "",
44			/* 0x18 */ "", "", "", "", "", "", "", "",
45			/* 0x20 */ " ", "!", """, "#", "$", "%", "&", "'",
46			/* 0x28 / "(", ")", "", "+", ",", "-", ".", "/",
47			/* 0x30 */ "0", "1", "2", "3", "4", "5", "6", "7",
48			/* 0x38 */ "8", "9", ":", ";", "<", "=", ">", "?",
49			/* 0x40 */ "@", "A", "B", "C", "D", "E", "F", "G",
50			/* 0x48 */ "H", "I", "J", "K", "L", "M", "N", "O",
51			/* 0x50 */ "P", "Q", "R", "S", "T", "U", "V", "W",
52			/* 0x58 */ "X", "Y", "Z", "[", "\\", "]", "^", "_",
53			/* 0x60 */ "`", "a", "b", "c", "d", "e", "f", "g",
54			/* 0x68 */ "h", "i", "j", "k", "l", "m", "n", "o",
55			/* 0x70 */ "p", "q", "r", "s", "t", "u", "v", "w",
56			/* 0x78 */ "x", "y", "z", "{", "\|", "}", "~", "",
57			/* 0x80 */ "", "", "‚", "ƒ",
58			"„", "…", "†", "‡",
59			/* 0x88 */ "", "‰", "Š", "<",
60			"Œ", "", "", "",
61			/* 0x90 */ "", "‘", "’", "“",
62			"”","•", "–", "—",
63			/* 0x98 */ "˜", "™", "š", ">",
64			"œ", "", "", "Ÿ",
65			/* 0xa0 */ " ", "¡", "¢", "£",
66			"¤", "¥", "¦", "§",
67			/* 0xa8 */ "¨", "©", "ª", "«",
68			"¬", "", "®", "¯",
69			/* 0xb0 */ "°", "±", "²", "³",
70			"´", "µ", "¶", "·",
71			/* 0xb8 */ "¸", "¹", "º", "»",
72			"¼", "½", "¾", "¿",
73			/* 0xc0 */ "À", "Á", "Â", "Ã",
74			"Ä", "Å", "Æ", "Ç",
75			/* 0xc8 */ "È", "É", "Ê", "Ë",
76			"Ì", "Í", "Î", "Ï",
77			/* 0xd0 */ "Ð", "Ñ", "Ò", "Ó",
78			"Ô", "Õ", "Ö", "×",
79			/* 0xd8 */ "Ø", "Ù", "Ú", "Û",
80			"Ü", "Ý", "Þ", "ß",
81			/* 0xe0 */ "à", "á", "â", "ã",
82			"ä", "å", "æ", "ç",
83			/* 0xe8 */ "è", "é", "ê", "ë",
84			"ì", "í", "î", "ï",
85			/* 0xf0 */ "ð", "ñ", "ò", "ó",
86			"ô", "õ", "ö", "÷",
87			/* 0xf8 */ "ø", "ù", "ú", "û",
88			"ü", "ý", "þ", "ÿ"
89			};
90
91			/* The order of these must match the enum psiconv_border_kind (data.h) */
92			static const char *border_strings[] = {
93			"none", "solid", "double", "dotted", "dashed", "dashed", "dotted"
94			};
95
96			/* The order of these must match the enum psiconv_justify (data.h) */
97			static const char *justify_strings[] = {
98			"left", "center", "right", "justify"
99			};
100
101			/* The order of these must match the enum psiconv_super_sub (data.h) */
102			static const char *vertical_strings[] = {
103			"baseline", "super", "sub"
104			};
105
106
107			/*
108			* Support routines for particular formatting structures
109			*/
110
111			static void fput_name(FILE * of, const char *string) {
112			int i;
113
114			for (i = 0; i < strlen(string); i++)
115			if (isalnum(string[i]))
116			putc(string[i], of);
117			}
118
119			static void fput_text(FILE * of, const char text, int length, int pwasspace) {
120			int j;
121			int space;
122
123			for (j = 0; j < length; j++) {
124			space = (text[j] == ' ');
125			if (*pwasspace && space)
126			fputs(" ", of);
127			else
128			fputs(char_table[(unsigned char) (text[j])], of);
129			*pwasspace = space;
130			}
131			}
132
133			static const char *screenfont_name(psiconv_u8 screenfont)
134			{
135			if (screenfont == 1)
136			return "sans-serif";
137			else if (screenfont == 2)
138			return "monospace";
139			else if (screenfont == 3)
140			return "serif";
141			else
142			return "serif";
143			}
144
145			static const char generic_font_family(const char font_name) {
146			static const char *sans_font_names[] = {
147			"Arial", "Univers", "Sans Serif"
148			};
149			static const char *mono_font_names[] = {
150			"Courier New", "Courier", "Mono", "Lineprinter", "Elite", "Swiss",
151			"Courier (compressed)", "Courier (expanded)", "Letter Gothic"
152			};
153			int i;
154
155			for (i=0; i < sizeof(sans_font_names) / sizeof(sans_font_names[0]); i++)
156			if (!strcmp(font_name, sans_font_names[i]))
157			return "sans-serif";
158
159			for (i=0; i < sizeof(mono_font_names) / sizeof(mono_font_names[0]); i++)
160			if (!strcmp(font_name, mono_font_names[i]))
161			return "monospace";
162
163			return "serif";
164			}
165
166			static int colors_different(
167			const psiconv_color old,
168			const psiconv_color new)
169			{
170			return ((old->red != new->red) \|\|
171			(old->green != new->green) \|\|
172			(old->blue != new->blue));
173			}
174
175
176			/* Borders */
177			static int borders_different(
178			const psiconv_border old,
179			const psiconv_border new)
180			{
181			return (!old \|\|
182			(old->kind != new->kind) \|\|
183			colors_different(old->color, new->color) \|\|
184			(old->thickness != new->thickness));
185			}
186
187			static void fput_border(FILE * of,
188			const char *which,
189			const psiconv_border old,
190			const psiconv_border new)
191			{
192			/* If the border changed at all we'll set all parameters, as they're
193			* fairly closely linked and it's much easier to do it this way */
194			if (borders_different(old, new)) {
195			fprintf(of, "border-%s-style:%s;",
196			which, border_strings[new->kind]);
197			if ((new->kind != psiconv_border_none) &&
198			(new->color->red \|\| new->color->green \|\| new->color->blue))
199			fprintf(of, "border-%s-color:#%02x%02x%02x;", which,
200			new->color->red, new->color->green, new->color->blue);
201			if ((new->kind == psiconv_border_solid) \|\|
202			(new->kind == psiconv_border_double))
203			fprintf(of, "border-%s-width:%.0fpx;",
204			which, (new->thickness / 10.0) - 1);
205			else if (new->kind != psiconv_border_none)
206			fprintf(of, "border-%s-width:1px;", which);
207			}
208			}
209
210			/* Paragraph formats */
211			static int paragraph_layouts_different(
212			const psiconv_paragraph_layout old,
213			const psiconv_paragraph_layout new)
214			{
215			return ((old->top_space != new->top_space) \|\|
216			(old->indent_right != new->indent_right) \|\|
217			(old->bottom_space != new->bottom_space) \|\|
218			(old->indent_left != new->indent_left) \|\|
219			(old->indent_first != new->indent_first) \|\|
220			(old->justify_hor != new->justify_hor) \|\|
221			(old->interline_exact != new->interline_exact) \|\|
222			borders_different(old->left_border, new->left_border) \|\|
223			borders_different(old->right_border, new->right_border) \|\|
224			borders_different(old->top_border, new->top_border) \|\|
225			borders_different(old->bottom_border, new->bottom_border));
226			}
227
228			static void fput_paragraph_layout(FILE * of,
229			const psiconv_paragraph_layout old,
230			const psiconv_paragraph_layout new)
231			{
232			if (!old \|\| (old->top_space != new->top_space))
233			fprintf(of, "margin-top:%.1fpt;", new->top_space);
234			if (!old \|\| (old->indent_right != new->indent_right))
235			fprintf(of, "margin-right:%.2fcm;", new->indent_right);
236			if (!old \|\| (old->bottom_space != new->bottom_space))
237			fprintf(of, "margin-bottom:%.1fpt;", new->bottom_space);
238			if (!old \|\|
239			(old->bullet->on != new->bullet->on) \|\|
240			(old->bullet->indent != new->bullet->indent) \|\|
241			(old->indent_left != new->indent_left) \|\|
242			(old->indent_first != new->indent_first)) {
243			psiconv_length_t indent = new->indent_first;
244			psiconv_length_t margin = new->indent_left;
245			/* Bullets with indent set cause strange margin behaviour: */
246			if (new->bullet->on && new->bullet->indent) {
247			if (indent > 0.0) {
248			margin += indent;
249			indent = new->indent_left - indent;
250			}
251			}
252			fprintf(of, "margin-left:%.2fcm;", margin);
253			fprintf(of, "text-indent:%.2fcm;", indent);
254			}
255			if (!old \|\| (old->justify_hor != new->justify_hor))
256			fprintf(of, "text-align:%s;", justify_strings[new->justify_hor]);
257			if (!old \|\| (old->interline_exact != new->interline_exact)) {
258			if (!old \|\| old->interline_exact)
259			fputs("line-height:normal;", of);
260			else
261			fprintf(of, "line-height:%.1fpt;", new->interline);
262			}
263			fput_border(of, "left", old ? old->left_border : NULL,
264			new->left_border);
265			fput_border(of, "right", old ? old->right_border : NULL,
266			new->right_border);
267			fput_border(of, "top", old ? old->top_border : NULL,
268			new->top_border);
269			fput_border(of, "bottom", old ? old->bottom_border : NULL,
270			new->bottom_border);
271			}
272
273			/* Character formats */
274			static int character_layouts_different(
275			const psiconv_character_layout old,
276			const psiconv_character_layout new)
277			{
278			return ((old->font->screenfont != new->font->screenfont) \|\|
279			(strcmp(old->font->name,new->font->name)) \|\|
280			(old->font_size != new->font_size) \|\|
281			(old->color->red != new->color->red) \|\|
282			(old->color->green != new->color->green) \|\|
283			(old->color->blue != new->color->blue) \|\|
284			(old->back_color->red != new->back_color->red) \|\|
285			(old->back_color->green != new->back_color->green) \|\|
286			(old->back_color->blue != new->back_color->blue) \|\|
287			(old->italic != new->italic) \|\|
288			(old->bold != new->bold) \|\|
289			(old->super_sub != new->super_sub) \|\|
290			(old->underline != new->underline) \|\|
291			(old->strike_out != new->strike_out));
292			}
293
294			static void fput_character_layout(FILE * of,
295			const psiconv_character_layout old,
296			const psiconv_character_layout new,
297			psiconv_word_f wf)
298			{
299			if (!old \|\| (old->font->screenfont != new->font->screenfont) \|\|
300			strcmp(old->font->name,new->font->name)) {
301			fprintf(of, "font-family:%s,%s,%s;", new->font->name,
302			generic_font_family(new->font->name),
303			screenfont_name(new->font->screenfont));
304			}
305			if (!old \|\| (old->font_size != new->font_size))
306			fprintf(of, "font-size:%.1f%%;", 100.0 * new->font_size / 10.0);
307			if (!old \|\| (old->bold != new->bold))
308			fprintf(of, "font-weight:%s;", new->bold ? "bold" : "normal");
309			if (!old \|\| (old->italic != new->italic))
310			fprintf(of, "font-style:%s;", new->italic ? "italic" : "normal");
311			if (!old \|\| (colors_different(old->color, new->color)))
312			fprintf(of, "color:#%02x%02x%02x;",
313			new->color->red, new->color->green, new->color->blue);
314			if (!old \|\| (colors_different(old->back_color, new->back_color)))
315			fprintf(of, "background-color:#%02x%02x%02x;",
316			new->back_color->red, new->back_color->green, new->back_color->blue);
317			if (!old \|\| (old->super_sub != new->super_sub))
318			fprintf(of, "vertical-align:%s;", vertical_strings[new->super_sub]);
319			if (!old \|\| (old->underline != new->underline) \|\|
320			(old->strike_out != new->strike_out)) {
321			fputs("text-decoration:", of);
322			if (new->strike_out)
323			fputs("line-through ", of);
324			if (new->underline)
325			fputs("underline", of);
326			else if (!new->strike_out)
327			fputs("none", of);
328			fputs(";", of);
329			}
330			}
331
332
333			/* Formatted paragraphs */
334			static void fput_para(FILE * of,
335			const psiconv_paragraph para,
336			psiconv_word_f wf)
337			{
338			psiconv_paragraph_layout base_para = para->base_paragraph;
339			psiconv_character_layout base_char = para->base_character;
340			psiconv_character_layout cur_char;
341			psiconv_character_layout *layout_stack;
342			psiconv_in_line_layout inl;
343			psiconv_word_style sty;
344			int spans = 0;
345			int wasspace = 0;
346			int i, j, loc;
347
348			layout_stack = calloc(psiconv_list_length(para->in_lines),
349			sizeof(*layout_stack));
350			fputs("<P", of);
351			sty = psiconv_get_style(wf->styles_sec, para->base_style);
352			cur_char = sty->character;
353
354			if (sty->name) {
355			fputs(" CLASS=\"", of);
356			fput_name(of, sty->name);
357			putc('"', of);
358			}
359
360			if (paragraph_layouts_different(sty->paragraph, base_para) \|\|
361			character_layouts_different(cur_char, base_char)) {
362			fputs(" STYLE=\"", of);
363			fput_paragraph_layout(of, sty->paragraph, base_para);
364			fput_character_layout(of, cur_char, base_char, wf);
365			cur_char = base_char;
366			putc('"', of);
367			}
368			putc('>', of);
369
370			if (base_para->bullet->on) {
371			fputs("<SPAN STYLE=\"", of);
372			if (base_para->bullet->font != base_char->font) {
373			fprintf(of, "font-family:%s,%s,%s;",
374			base_para->bullet->font->name,
375			generic_font_family(base_para->bullet->font->name),
376			screenfont_name(base_para->bullet->font->screenfont));
377			}
378			if (base_para->bullet->font_size != base_char->font_size)
379			fprintf(of, "font-size:%.1f%%;",
380			100.0 * base_para->bullet->font_size / 10.0);
381			if ((base_para->bullet->color->red != base_char->color->red) \|\|
382			(base_para->bullet->color->green != base_char->color->green) \|\|
383			(base_para->bullet->color->blue != base_char->color->blue))
384			fprintf(of, "color:#%02x%02x%02x;",
385			base_para->bullet->color->red,
386			base_para->bullet->color->green,
387			base_para->bullet->color->blue);
388			fprintf(of, "\">%s </SPAN>",
389			char_table[base_para->bullet->character]);
390			wasspace = TRUE;
391			}
392
393			loc = 0;
394			for (i = 0; i < psiconv_list_length(para->in_lines); i++) {
395			inl = psiconv_list_get(para->in_lines, i);
396			if (character_layouts_different(cur_char, inl->layout)) {
397			for (j = 0; j < spans; j++)
398			if (!character_layouts_different(inl->layout, layout_stack[j]))
399			break;
400			if (j < spans) {
401			while (spans > j) {
402			fputs("</SPAN>",of);
403			spans--;
404			}
405			} else {
406			fputs("<SPAN STYLE=\"", of);
407			fput_character_layout(of, cur_char, inl->layout, wf);
408			fputs("\">",of);
409			layout_stack[spans++] = cur_char;
410			}
411			cur_char = inl->layout;
412			}
413			fput_text(of, &para->text[loc], inl->length, &wasspace);
414			loc += inl->length;
415			}
416
417			while (spans > 0) {
418			fputs("</SPAN>",of);
419			spans--;
420			}
421
422			if (loc < strlen(para->text)) {
423			fput_text(of, &para->text[loc], strlen(para->text) - loc, &wasspace);
424			}
425
426			if (strlen(para->text) == 0)
427			fputs(" ", of);
428
429			fputs("</P>\n", of);
430			free(layout_stack);
431			}
432
433			static void fput_style(FILE * of,
434			const psiconv_word_style normal,
435			const psiconv_word_style sty,
436			psiconv_word_f wf)
437			{
438			if (sty->name == NULL)
439			fputs(" P {", of);
440			else {
441			fputs(" P.", of);
442			fput_name(of, sty->name);
443			fputs(" {", of);
444			}
445			fput_paragraph_layout(of, normal ? normal->paragraph : NULL, sty->paragraph);
446			fput_character_layout(of, normal ? normal->character : NULL, sty->character, wf);
447			fputs("}\n", of);
448			}
449
450	frodo	53	static int psiconv_gen_html4(const char *filename, const psiconv_file file,
451	frodo	34	const char *dest)
452	frodo	14	{
453	frodo	53	FILE * of;
454	frodo	14	int i;
455			psiconv_paragraph para;
456			psiconv_word_style normal, sty;
457			psiconv_word_f wf;
458
459			if (file->type == psiconv_word_file)
460			wf = file->file;
461			else {
462			/* Fall back on the normal HTML generator */
463	frodo	53	return psiconv_gen_html(filename,file,dest);
464	frodo	14	}
465
466	frodo	53	if (! (of = fopen(filename,"w")))
467			return -1;
468
469	frodo	14	fputs("<!doctype html public \"-//W3C//DTD HTML 4.0 STRICT//EN\">", of);
470			fputs("\n<HTML>\n<HEAD>\n <META NAME=\"GENERATOR\"", of);
471			fputs(" CONTENT=\"psiconv-" VERSION "\">\n", of);
472
473			if (psiconv_list_length(wf->page_sec->header->text->paragraphs) > 0) {
474			fputs(" <TITLE>", of);
475			para = psiconv_list_get(wf->page_sec->header->text->paragraphs, 0);
476			i = 0;
477			fput_text(of, para->text, strlen(para->text), &i);
478			fputs("</TITLE>\n", of);
479			}
480
481			normal = wf->styles_sec->normal;
482			fputs(" <STYLE TYPE=\"text/css\"><!--\n", of);
483			fprintf(of," BODY { background-color: #%02x%02x%02x }\n",
484			normal->paragraph->back_color->red,
485			normal->paragraph->back_color->green,
486			normal->paragraph->back_color->blue);
487			fput_style(of, NULL, normal, wf);
488			for (i = 0; i < psiconv_list_length(wf->styles_sec->styles); i++) {
489			sty = psiconv_list_get(wf->styles_sec->styles, i);
490			fput_style(of, normal, sty, wf);
491			}
492			fputs(" --></STYLE>\n</HEAD>\n<BODY>\n", of);
493			for (i = 0; i < psiconv_list_length(wf->paragraphs); i++) {
494			para = psiconv_list_get(wf->paragraphs, i);
495			fput_para(of, para, wf);
496			}
497			fputs("</BODY>\n</HTML>\n", of);
498	frodo	53
499			return fclose(of);
500	frodo	14	}
501
502	frodo	56	static struct psiconv_fileformat_s ff =
503	frodo	34	{
504			"HTML4",
505			"HTML 4.0 with cascading style sheets",
506			psiconv_gen_html4
507			};
508
509			void init_html4(void)
510			{
511			psiconv_list_add(fileformat_list,&ff);
512			}
513
frodo@frodo.looijaard.name	ViewVC Help
Powered by ViewVC 1.1.26