/* HTML-PSformat.c -  Module for NCSA's Mosaic software
 *
 * Purpose:	to parse Hypertext widget contents into appropriate PostScript
 *
 * Author:	Ameet A. Raval & Frans van Hoesel & Andrew Ford
 *		(aar@gfdl.gov & hoesel@chem.rug.nl). 
 *		send bugreports to hoesel@chem.rug.nl
 *
 * Institution: for Ameet A. Raval:
 *			Geophysical Fluid Dynamics Laboratory,
 *			National Oceanic and Atmospheric Administration,
 *			U.S. Department of Commerce
 *			P.O. Box 308
 *			Princeton, NJ 08542
 *		for Frans van Hoesel:
 *			Xtreme graphics software
 *			Herepoortenmolendrift 36
 *			9711 DH  Groningen
 *			The Netherlands
 *		also:
 *			Andrew Ford
 *			Independent Software Consultant
 *			30 Upper Cheltenham Place,
 *			Montpelier, Bristol, BS6 5HR, GB
 *			E-mail: andrew@icarus.demon.co.uk
 *
 * Date:		1 aug 1993 
 * Modification:	8 nov 1993
 *				o added support for bold/italics courier
 *				o removed unused or no longer needed stuff
 *				o fixed the font alignment problem
 *		 	23 nov 1993
 *				o added support for horizontal ruler
 *				o on request of Ameet, added a specific
 *					line about whome to send bugreports to
 *			15 jun 1994
 *				o add headers, footers and footnotes to convey
 *				  title, page number, url of document, date (of
 *				  printing) and urls of links.
 *				o use A4 or US Letter size paper (currently hard coded)
 *
 *			9 may 1995 (Andrew Ford)
 *				o general overhaul
 *
 * Copyright:   This work is the product of the United States Government,
 *		and is precluded from copyright protection.  It is hereby
 *		released into the public domain.
 *
 * WE MAKE NO REPRESENTATIONS ABOUT THE SUITABILITY OF THIS SOFTWARE FOR
 * ANY PURPOSE.  IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED
 * WARRANTY. WE SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY THE
 * USERS OF THIS SOFTWARE. 
 * 
 *		pieces of code are taken from xvps by kind
 *		permission of John Bradley.
 *
 * To-do:
 *		* printing of tables and forms fields (and any new features that appear)
 *
 */

#include <varargs.h>

#include <string.h>
#include <stdio.h>
#include <ctype.h>
#include <math.h>
#include <malloc.h>
#include <time.h>
#include <sys/types.h>
#include <time.h>
#include "HTMLP.h"

/* Fix thanks to robm. */
#ifdef __alpha
#include <Xm/VaSimpleP.h>
#endif

#define CR '\015'
#define LF '\012'

extern int SwapElements();

#define USLETTER 	0
#define A4 		1

#if !defined(DEFAULT_PAGE_SIZE)
#define DEFAULT_PAGE_SIZE USLETTER
#endif

#define F_FULLCOLOR	0
#define F_GREYSCALE	1
#define F_BWDITHER 	2
#define F_REDUCED  	3

#define L_PAREN		'('
#define R_PAREN		')'
#define B_SLASH		'\\'
#define MAX_ASCII	'\177'


/* MONO returns total intensity of r,g,b components .33R+ .5G+ .17B */
#define MONO(rd,gn,bl) (((rd)*11 + (gn)*16 + (bl)*5) >> 13)

/* PSconst_out outputs to the postscript buffer an array of constant
 * strings
 */
#define PSconst_out(txt) {				\
	int n=(sizeof txt)/(sizeof txt[0]); 		\
	  	int i; 					\
	  	for (i=0; i<n; i++) { 			\
			PSprintf("%s\n", txt[i]) ; 	\
		} 					\
}
	
/* STREQ tests whether two strings are equal. */
#define STREQ(a, b)	(strcmp((a), (b)) == 0)

/* for regular-font, bold-font, italic-font, fixed-font */
typedef enum { RF, BF, IF, FF, FB, FI } PS_fontstyle;

static int PS_size, PS_len, PS_offset, PS_curr_page, PS_start_y, PS_hexi;
static int PS_page_offset;
static char *PS_string;
static float Points_Pixel;
static int Pixels_Page;
static PS_fontstyle PS_oldfn = RF;
static int PS_fontascent = 0;
static int PS_oldfs = 0;

static XColor fg_color, bg_color;


static int footnote_space  = 8;		/* Space from main text to footnotes */
static int footnote_ptsize = 8;		/* Point size for footnote text */
static int cur_ftn_no;			/* Current footnote number */
static int n_saved_ftns;		/* Number of saved footnotes on page */
static int ftn_array_size=0;		/* Size of allocated footnote array */
static char **footnotes=NULL;		/* Pointer to array of footnote pointers */

typedef struct {
    double	page_height;
    double	page_width;
    double	top_margin;
    double	bot_margin;
    double	left_margin;
    double	right_margin;
    double	text_height;
    double	text_width;
}
PAGE_DIMENS_T;

#define INCH	72
#define MM	INCH / 25.4

PAGE_DIMENS_T	page_dimens;
PAGE_DIMENS_T	a4_page_dimens = {
    297 * MM,
    210 * MM, 
     20 * MM,
     20 * MM,
     20 * MM,
     20 * MM
};

PAGE_DIMENS_T	us_letter_page_dimens = {
    11  * INCH,		/* page_height */
    8.5 * INCH,		/* page_width  */
    0.9 * INCH,		/* top_margin  */
    0.7 * INCH,
    0.9 * INCH,
    0.9 * INCH
};


/* Globals to get button value in print dialog -- swp/AF */

int HTML_Print_Headers       = 1;	/* Flag whether page headers enabled */
int HTML_Print_Footers     = 1;	/* Flag whether footnote printing enabled */

/* Paper format (currently either A4 or letter).  This should be generalized. */

int HTML_Print_Paper_Size_A4 = DEFAULT_PAGE_SIZE;


/*
 * GetDpi - return Dots-per-inch of the screen
 *
 * calculate the pixel density in dots per inch on the current widget
 * screen
 *
 */
static float 
GetDpi(HTMLWidget hw)
{
    Screen *s = XtScreen(hw);
    float dpi;

    dpi = 25.4 * WidthOfScreen(s) / WidthMMOfScreen(s);
    if (dpi<1.0 || dpi>10000.0)
	dpi = 72.0;
    return dpi;
}


/*
 * PSprintf - dynamic string concatenation function.
 *
 *  In successive calls, the formatted string will be appended to the global
 *  output string Sp.
 *  It assumes that on each call, the length of the text appended to Sp
 *  is less than 1024.
 *  The format string is used as in printf, so you can use additional
 *  arguments.
 *
 *  When successful, PSprintf returns the number of characters printed
 *  in this call, otherwise it returns EOF (just as printf does)
 *
 */

#ifdef BROKEN_SOLARIS_COMPILER_STDARG
/* "Looks like there's a bug in Sun's C compiler and the stdarg.h use
   of va_start() in HTML-PSformat.c. Until the SunPro folks can take a
   look at the problem, the following pre-ANSI code should workaround
   the problem." */
static int 
PSprintf(char *format, ...) 
{
    va_dcl
    va_list args;
    int     len;
    char    *s;

    va_start(args);

    if (PS_size - PS_len < 1024) {
	PS_size += 1024;
	if ((s = (char *) realloc(PS_string, PS_size)) == NULL) {
	    fprintf(stderr, "PSprintf malloc failed\n");
	    return(EOF);
	}
	PS_string = s;
    }
    len = vsprintf(PS_string+PS_len, format, args);
    /* this is a hack to make it work on systems were vsprintf(s,.)
     * returns s, instead of the len.
     */
    if (len != EOF && len != NULL)
	PS_len += strlen(PS_string+PS_len);
    va_end(args);
    return(len);
}
#else /* not BROKEN_SOLARIS_COMPILER_STDARG */
static int 
PSprintf(format, va_alist)
    char* format;
    va_dcl
{
    int 	len;
    char 	*s;
    va_list	args;

    if (PS_size - PS_len < 1024) 
    {
	PS_size += 1024;
	if ((s = (char *) realloc(PS_string, PS_size)) == NULL) 
	{
	    fprintf(stderr, "PSprintf malloc failed\n");
	    return(EOF);
	}
	PS_string = s;
    }
    va_start(args);
    len = vsprintf(PS_string+PS_len, format, args);
    /* this is a hack to make it work on systems were vsprintf(s,...)
     * returns s, instead of the len.
     */
    if (len != EOF && len != 0) 
	PS_len += strlen(PS_string+PS_len);
    va_end(args);
    return(len);
}
#endif /* not BROKEN_SOLARIS_COMPILER_STDARG */


/*
 * PShex - output hex byte
 *
 * Append the byte "val" to an internal string buffer in hexadecimal
 * format.  If the argument "flush" is True, or if the buffer has filled
 * up, flush the buffer to the larger postscript output buffer (using
 * PSprintf).
 *
 */
static int 
PShex(unsigned char val, int flush)
{
    static unsigned char hexline[80];
    static char digit[] = "0123456789abcdef";

    if (!flush) 
    {
	hexline[PS_hexi++] = (char) digit[((unsigned) val >>
					   (unsigned) 4) & (unsigned) 0x0f];
	hexline[PS_hexi++] = (char) digit[(unsigned) val &
					  (unsigned) 0x0f];
    }

    /* Changed from ">78" to ">77" on advice of
       debra@info.win.tue.nl (Paul De Bra). */

    if ((flush && PS_hexi) || (PS_hexi>77)) 
    {
	hexline[PS_hexi] = '\0';
	PS_hexi=0;
	return (PSprintf("%s\n", hexline));
    }
    return (0);
}


/*
 * PSfont - change font
 *
 * change local font in buf to "font"
 * fontfamily indicates if the overall style is times, helvetica, century
 * schoolbook or lucida.
 *
 */
static void
PSfont(HTMLWidget hw, XFontStruct *font, int fontfamily) 
{
    PS_fontstyle fn;
    int style, size;
    int fs;

    static PS_fontstyle fontstyle[17] = 
    {
	RF, IF, BF, FF, BF, BF, BF, BF, BF,
	BF, IF, FF, FF, FB, FI, FB, FI
    };

    static char fnchar[6][3] = {"RF", "BF", "IF", "FF", "FB", "FI"};

    /* fontsizes as set in gui.c and in HTML.c (listing font is only
     * defined in HTML.c)
     */
    static int fontsizes[4][3][17] = 
    {
	/* times font sizes */
	{
	    {14, 14, 14, 14, 18, 17, 14, 12, 10, 8, 14, 12, 12, 14, 14, 12, 12},
	    {17, 17, 17, 17, 24, 18, 17, 14, 12, 10, 17, 14, 12, 17, 17, 14, 14},
	    {20, 20, 20, 20, 25, 24, 20, 18, 17, 14, 20, 18, 12, 20, 20, 18, 18}
	},
	/* helvetica sizes */
	{
	    {14, 14, 14, 14, 18, 17, 14, 12, 10, 8, 14, 12, 12, 14, 14, 12, 12},
	    {17, 17, 17, 17, 24, 18, 17, 14, 12, 10, 17, 14, 12, 17, 17, 14, 14},
	    {20, 20, 20, 20, 25, 24, 20, 18, 17, 14, 20, 18, 12, 20, 20, 18, 18}
	},
	/* new century schoolbook sizes */
	{
	    {14, 14, 14, 14, 18, 17, 14, 12, 10, 8, 14, 12, 12, 14, 14, 12, 12},
	    {18, 18, 18, 18, 24, 18, 17, 14, 12, 10, 18, 14, 12, 18, 18, 14, 14},
	    {20, 20, 20, 20, 25, 24, 20, 18, 17, 14, 20, 18, 12, 20, 20, 18, 18}
	},
	/* lucida sizes */
	{
	    {14, 14, 14, 14, 18, 17, 14, 12, 11, 10, 14, 12, 12, 14, 14, 12, 12},
	    {17, 17, 17, 17, 24, 18, 17, 14, 12, 10, 17, 14, 12, 17, 17, 14, 14},
	    {20, 20, 20, 20, 25, 24, 20, 18, 17, 14, 20, 18, 12, 20, 20, 18, 18}
	}
    };

    /* next is for each fontfamily the ascent value as given by the 
     * medium sized bold x-font (the regular font has the same
     * ascent value for both the medium and the large size Century
     * font).
     * it is use in the check for the fontsize (small, medium, large)
     */
    static int medium_fontascent[4] = {
	14, 14, 16, 15
    };

    /* for each fontfamily, for each fontsize, and for each font style
     * give the ascent value, so the output from Postscript is correct.
     * If the value is given between parenthesis, then it is different
     * from the value as stored in the x-font.
     * Note that this is a fix, and need to be changed, if the browser
     * is fixed (in the current version 1.2 the baseline of various fonts
     * is not aligned very well).
     */
    static int fontascent[4][3][17] = {
	/*rg, itl, bld, fix,  h1,  h2,  h3,  h4,  h5,  h6,
	  add, pla, lis, fixbold, fixital, plabold, plaital, */
	/* times */
	{
	    {12, 11, 12, 10, 15, 14, 12, 10, 8, 6, 11, 9, 10, 10, 10, 9, 9},
	    {13, 13, 14, 12, 20, 15, 14, 12, 10, 8, 13, 10, 10, 12, 12, 10, 10},
	    {16, 15, 15, 13, 21, 20, 15, 15, 14, 12, 15, 13, 10, 13, 13, 13, 13}
	},
	/* helvetica */
	{
	    {12, 12, 12, 10, 15, 14, 12, 10, 9, 7, 12, 9, 10, 10, 10, 9, 9},
	    {14, 14, 14, 12, 22, 15, 14, 12, 10, 9, 14, 10, 10, 12, 12, 10, 10},
	    {16, 16, 16, 13, 22, 22, 16, 15, 14, 12, 16, 13, 10, 13, 13, 13, 13}
	},
	/* new century schoolbook */
	{
	    {12, 12, 13, 10, 16, 14, 13, 10, 9, 7, 12, 9, 10, 10, 10, 9, 9},
	    {16, 14, 16, 13, 22, 16, 14, 13, 10, 9, 14, 10, 10, 13, 13, 10, 10},
	    {17, 16, 17, 13, 22, 22, 17, 16, 14, 13, 16, 13, 10, 13, 13, 13, 13}
	},
	/* lucida bright */
	{
	    {11, 11, 11, 11, 15, 14, 11, 10, 9, 7, 11, 9, 10, 11, 10, 9, 9},
	    {14, 15, 14, 13, 20, 15, 14, 11, 10, 7, 15, 11, 10, 13, 13, 11, 10},
	    {17, 17, 17, 16, 21, 20, 17, 15, 14, 11, 17, 14, 10, 16, 13, 14, 13}
	}
    };

    /* NULL case - reflush old font or the builtin default: */
    if ((hw == NULL) || (font == NULL))
    {
	if (PS_oldfs != 0)
	    PSprintf( "%2s %d SF\n", fnchar[PS_oldfn], PS_oldfs);
	return;
    }
    /* added the next line in case xmosaic version 199.4 has more fonts */
    style = 3;

    if (font == hw->html.font) {
	style = 0;
    } else if (font == hw->html.italic_font) {
	style = 1;
    } else if (font == hw->html.bold_font) {
	style = 2;
    } else if (font == hw->html.fixed_font) {
	style = 3;
    } else if (font == hw->html.header1_font) {
	style = 4;
    } else if (font == hw->html.header2_font) {
	style = 5;
    } else if (font == hw->html.header3_font) {
	style = 6;
    } else if (font == hw->html.header4_font) {
	style = 7;
    } else if (font == hw->html.header5_font) {
	style = 8;
    } else if (font == hw->html.header6_font) {
	style = 9;
    } else if (font == hw->html.address_font) {
	style = 10;
    } else if (font == hw->html.plain_font) {
	style = 11;
    } else if (font == hw->html.listing_font) {
	style = 12;
    } else if (font == hw->html.fixedbold_font) {
	style = 13;
    } else if (font == hw->html.fixeditalic_font) {
	style = 14;
    } else if (font == hw->html.plainbold_font) {
	style = 15;
    } else if (font == hw->html.plainitalic_font) {
	style = 16;
    }

    /* check size, by looking at the size of the regular font */
    size = 1;
    if (hw->html.bold_font->ascent > medium_fontascent[fontfamily]) 
    {
	/* large font */
	size = 2;
    }
    else if (hw->html.bold_font->ascent < medium_fontascent[fontfamily]) 
    {
	/* small font */
	size = 0;
    }
    fn = fontstyle[style];
    fs = fontsizes[fontfamily][size][style];
    PS_fontascent = fontascent[fontfamily][size][style];

    if (fn != PS_oldfn || fs != PS_oldfs) 
    {
	PSprintf( "%2s %d SF\n", fnchar[fn], fs);
	PS_oldfn=fn, PS_oldfs=fs;
    }
}


/*
 * PSshowpage - end of page function
 *
 * show the current page and restore any changes to the printer state.
 * Any accumulated footnotes are output and the outstanding footnote count
 * reset to zero.  Footnotes are preceded by a footnote rule and each footnote
 * is consists of a raised mark and the footnote text (i.e. the url).  The mark
 * is in a smaller font than the text.  The ideas are filched from LaTeX. 
 */
static void
PSshowpage(void)
{
    PSprintf("restore\n");
    if (n_saved_ftns > 0) 
    {
	int	i;

	PSprintf("gsave 0.2 setlinewidth newpath %.2f %.2f M %.2f 0 RL stroke\n", 
		 page_dimens.left_margin,
		 (page_dimens.bot_margin + (footnote_ptsize * n_saved_ftns) + 4),
		 (page_dimens.text_width * 0.4));
	for (i = 0; n_saved_ftns; n_saved_ftns--, i++) 
	{
	    PSprintf("newpath %.2f %.2f M RF %.2f SF (%d) S 3 -2 R RF %d SF (%s) S\n", 
		     page_dimens.left_margin,
		     page_dimens.bot_margin + 5 + (n_saved_ftns - 1) * footnote_ptsize,
		     (0.7 * footnote_ptsize), cur_ftn_no - n_saved_ftns, 
		     footnote_ptsize, footnotes[i]);
	}
	PSprintf("grestore\n");
    }
    PSprintf("showpage\n");
}



/*
 * PSnewpage - begin a fresh page
 *
 * increment the page count and handle the structured comment
 * conventions
 *
 */
static void
PSnewpage(void) 
{
    PS_curr_page++;
    
    /* the PostScript reference Manual states that the Page: Tag
       should have a label and a ordinal; otherwise programs like
       psutils fail    -gustaf */

    PSprintf("%%%%Page: %d %d\n", PS_curr_page, PS_curr_page);
    PSprintf("save\n");
    if (HTML_Print_Headers)
	PSprintf("%d ", PS_curr_page);
    PSprintf("NP\n");
    PSfont( NULL, NULL, 0);	/* force re-flush of last font used */
}



/*
 * PSinit_latin1 - handle ISO encoding
 *
 * print out initializing PostScript text for ISO Latin1 font encoding
 * This code is copied from the Idraw program (from Stanford's InterViews 
 * package), courtesy of Steinar Kjaernsr|d, steinar@ifi.uio.no
 *
 */
static void
PSinit_latin1(void)
{

    static char *txt[] = {

	"/reencodeISO {",
	"dup dup findfont dup length dict begin",
	"{ 1 index /FID ne { def }{ pop pop } ifelse } forall",
	"/Encoding ISOLatin1Encoding D",
	"currentdict end definefont",
	"} D",
	"/ISOLatin1Encoding [",
	"/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef",
	"/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef",
	"/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef",
	"/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef",
	"/space/exclam/quotedbl/numbersign/dollar/percent/ampersand/quoteright",
	"/parenleft/parenright/asterisk/plus/comma/minus/period/slash",
	"/zero/one/two/three/four/five/six/seven/eight/nine/colon/semicolon",
	"/less/equal/greater/question/at/A/B/C/D/E/F/G/H/I/J/K/L/M/N",
	"/O/P/Q/R/S/T/U/V/W/X/Y/Z/bracketleft/backslash/bracketright",
	"/asciicircum/underscore/quoteleft/a/b/c/d/e/f/g/h/i/j/k/l/m",
	"/n/o/p/q/r/s/t/u/v/w/x/y/z/braceleft/bar/braceright/asciitilde",
	"/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef",
	"/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef",
	"/.notdef/dotlessi/grave/acute/circumflex/tilde/macron/breve",
	"/dotaccent/dieresis/.notdef/ring/cedilla/.notdef/hungarumlaut",
	"/ogonek/caron/space/exclamdown/cent/sterling/currency/yen/brokenbar",
	"/section/dieresis/copyright/ordfeminine/guillemotleft/logicalnot",
	"/hyphen/registered/macron/degree/plusminus/twosuperior/threesuperior",
	"/acute/mu/paragraph/periodcentered/cedilla/onesuperior/ordmasculine",
	"/guillemotright/onequarter/onehalf/threequarters/questiondown",
	"/Agrave/Aacute/Acircumflex/Atilde/Adieresis/Aring/AE/Ccedilla",
	"/Egrave/Eacute/Ecircumflex/Edieresis/Igrave/Iacute/Icircumflex",
	"/Idieresis/Eth/Ntilde/Ograve/Oacute/Ocircumflex/Otilde/Odieresis",
	"/multiply/Oslash/Ugrave/Uacute/Ucircumflex/Udieresis/Yacute",
	"/Thorn/germandbls/agrave/aacute/acircumflex/atilde/adieresis",
	"/aring/ae/ccedilla/egrave/eacute/ecircumflex/edieresis/igrave",
	"/iacute/icircumflex/idieresis/eth/ntilde/ograve/oacute/ocircumflex",
	"/otilde/odieresis/divide/oslash/ugrave/uacute/ucircumflex/udieresis",
	"/yacute/thorn/ydieresis",
	"] D",
	"[RF BF IF FF FB FI] {reencodeISO D} forall"
    };

    PSconst_out(txt);
}


/*
 * PSinit - initialize Postscript output
 *
 * does the initialization per html document
 *
 */
static void
PSinit(void) 
{
    PS_size = PS_len = PS_offset = PS_hexi = PS_page_offset = 0;
    PS_start_y = 0;
    PS_string = (char *) malloc(1);
    PS_oldfs = 0;
    PS_oldfn = RF;
    PS_curr_page = 0 ;
    n_saved_ftns = 0;
    cur_ftn_no = 1;
}



/*
 * PSheader - initialize Postscript output
 *
 * Prints out the prolog.  The following PostScript macros are defined
 *	D	def - define a macro
 *	E	exch - exhange parameters
 *	M	moveto
 *	R	rmoveto
 *	L	lineto
 *	RL	rlineto
 *	SQ	draw a unit square
 *	U	underline a string
 *	B	draw a bullet
 *	OB	draw an open bullet
 *	HR	draw a horizontal rule
 *	SF	set font
 *	RF	roman font (dependent on font family)
 *	BF	bold font (dependent on font family)
 *	IF	italic font (dependent on font family)
 *	FF	fixed font (courier)
 *	FB	fixed bold font (courier bold)
 *	FI	fixed italic font (courier oblique)
 *	nstr	buffer for creating page number string
 *	pageno	literal "Page "
 *	url	URL of document
 *	title	title of document
 *	date	date modified/printed
 */
static void 
PSheader(char *title, int font, char *url, char *time_str) 
{
    static char *fontname[] = {
	/* in order: regular, bold, italic */
	"Times-Roman", "Times-Bold", "Times-Italic",
	"Helvetica", "Helvetica-Bold", "Helvetica-Oblique",
	"NewCenturySchlbk-Roman", "NewCenturySchlbk-Bold",
	"NewCenturySchlbk-Italic",
	/* this is a nasty trick, I have put Times in place of
	 * Lucida, because most printers don't have Lucida font
	 */
	"Times-Roman", "Times-Bold", "Times-Italic"
	    /* "Lucida", "Lucida-Bold", "Lucida-Italic" */
    };

    static char *txt[] = {
	"/M {moveto} D",
	"/S {show} D",
	"/R {rmoveto} D",
	"/L {lineto} D",
	"/RL {rlineto} D",
	"/SQ {newpath 0 0 M 0 1 L 1 1 L 1 0 L closepath} D",
	"/U {gsave currentpoint currentfont /FontInfo get /UnderlinePosition get",
	" 0 E currentfont /FontMatrix get dtransform E pop add newpath moveto",
	" dup stringwidth rlineto stroke grestore S } D",
	"/B {/r E D gsave -13 0  R currentpoint ",
	"  newpath r 0 360 arc closepath fill grestore } D",
	"/OB {/r E D gsave -13 0  R currentpoint ",
	"  newpath r 0 360 arc closepath stroke grestore } D",
	"/HR {/l E D gsave 0 1 RL l 0 RL 0 -1 RL l neg 0 RL stroke grestore } D",
	"/SF {E findfont E scalefont setfont } D",
	"/FF {/Courier } D",
	"/FB {/Courier-Bold } D",
	"/FI {/Courier-Oblique } D"
	};

    char		time_buf[40];
    time_t		clock = time(NULL);

    strftime(time_buf, sizeof(time_buf), 
	     "Printed %a %b %e %T %Y", localtime(&clock));
    if (!time_str || (time_str[0] == '\0'))
    {
	time_str = time_buf;
    }
    PSprintf("%%!PS-Adobe-1.0\n");
    PSprintf("%%%%Creator: NCSA Mosaic, Postscript by Ameet Raval, Frans van Hoesel\n");
    PSprintf("%%%%         and Andrew Ford\n");
    if (title)
    {
	char *tmp;
	for (tmp = title; *tmp; tmp++)
	    if (*tmp == CR || *tmp == LF)
                *tmp = ' ';
	PSprintf("%%%%Title: %s\n", title);
    }
    PSprintf("%%%%CreationDate: %s\n", time_buf + 8);
    PSprintf("%%%%Pages: (atend)\n");
    PSprintf("%%%%PageOrder: Ascend\n");
    PSprintf("%%%%BoundingBox: %d %d %d %d\n",
	     (int)page_dimens.left_margin,
	     (int)(page_dimens.bot_margin - 12),
	     (int)(page_dimens.left_margin + page_dimens.text_width + 0.5),
	     (int)(page_dimens.bot_margin + page_dimens.text_height + 12.5));
    PSprintf("%%%%DocumentFonts: %s %s %s Courier Courier-Bold Courier-Oblique\n",
	     fontname[font*3], fontname[font*3+1], fontname[font*3+2]);
    PSprintf("%%%%EndComments\n");
    PSprintf("save /D {def} def /E {exch} D\n");
    PSprintf("/RF {/%s} D\n", fontname[font*3]);
    PSprintf("/BF {/%s} D\n", fontname[font*3+1]);
    PSprintf("/IF {/%s} D\n", fontname[font*3+2]);
    PSprintf("/nstr 6 string D /pgno (Page ) D\n");
    PSprintf("/url (%s) D\n", url);
    PSprintf("/title (%s) D\n", title);
    PSprintf("/date (%s) D\n", time_str);
    PSconst_out(txt);
    
    /* Output the newpage definition. */
    
    PSprintf("/NP {");
    if (HTML_Print_Headers) 
    {
	PSprintf("gsave 0.4 setlinewidth\n");
	PSprintf("  newpath %.2f %.2f M %.2f 0 RL stroke", 
		 page_dimens.left_margin,
		 (page_dimens.bot_margin + page_dimens.text_height), 
		 page_dimens.text_width);
	PSprintf("  newpath %.2f %.2f M %.2f 0 RL stroke\n",
		 page_dimens.left_margin, page_dimens.bot_margin,
		 page_dimens.text_width);
	PSprintf("  BF 12 SF %.2f %.2f M (%s) S\n",
		 page_dimens.left_margin,
		 (page_dimens.bot_margin + page_dimens.text_height + 6), title);
	PSprintf("  nstr cvs dup stringwidth pop pgno stringwidth pop add\n");
	PSprintf("  %.2f E sub %.2f M pgno S S\n",
		 (page_dimens.left_margin + page_dimens.text_width), 
		 (page_dimens.bot_margin + page_dimens.text_height + 6));
	PSprintf("  BF 10 SF %.2f %.2f M (%s) S\n",
		 page_dimens.left_margin, page_dimens.bot_margin - 12, url);
	PSprintf("  (%s) dup stringwidth pop %.2f E sub %.2f M S grestore\n",
		 time_str, page_dimens.left_margin + page_dimens.text_width,
		 page_dimens.bot_margin - 12);
    }
    PSprintf("  %.2f %.2f translate %.5f %.5f scale } D\n",
	     page_dimens.left_margin, 
	     page_dimens.bot_margin + page_dimens.text_height,
	     Points_Pixel, Points_Pixel);
    PSinit_latin1();
    
    PSprintf("%%%%EndProlog\n");
}



/*
 * PStrailer - write postscript trailer
 *
 */
static void
PStrailer(void)
{

    PSprintf("%%%%Trailer\n");
    PSprintf("restore\n");
    PSprintf("%%%%Pages: %d\n", PS_curr_page);
    if (footnotes)
    {
	free(footnotes);
	footnotes = NULL;
	ftn_array_size = 0;
    }
}


/*
 * PSmoveto - move to new x,y location
 *
 * if the Y value does not fit on the current page, begin a new page
 * (I think in the current implementation, this never happens)
 *
 */
static void
PSmoveto(int x, int y) 
{
    if (y > PS_start_y + Pixels_Page) 
    {
	PS_start_y = y;
	PSshowpage();
	PSnewpage();
    }
    PS_offset = 0;
    PSprintf( "%d %d M\n", x, -(y - PS_start_y));
}


/*
 * PSmove_offset - set Y-offset
 *
 * do a relative vertical move, whenever the offset changes
 *
 */
static void
PSmove_offset(int offset)
{
    if (offset != PS_offset) 
    {
	PSprintf("0 %d R\n", PS_offset - offset );
	PS_offset = offset;
    }
}


/*
 * Return an indication of whether or not the current element has a footnote.
 *
 * an element has a footnote if it is text or an image and its anchorHRef is not null.
 * If the element is a textual element with an anchorHRef, that has been split across 
 * lines then it should be followed by a linefeed element and a text element with the
 * same anchorHRef.  In this case say that the element doesn't have a footnote so as
 * to avoid duplicate footnotes.
 */
static int 
has_footnote(struct ele_rec *el)
{
    int			rc = 0;
    struct ele_rec 	*next;
    char		*anchorHRef;

    if (el == NULL) {
	return 0;
    }

    anchorHRef = el->anchorHRef;

    if (anchorHRef != NULL)
    {
	switch (el->type)
	{
	case E_TEXT:
	case E_IMAGE:
	    for (next = el->next; el; el = next, next = el->next)
	    {
		if (next == NULL)
		{
		    rc = 1;
		    break;
		}
		else if (next->anchorHRef == NULL) {
			rc = 1;
			break;
		}
		else if (!STREQ(next->anchorHRef, anchorHRef))
		{
		    rc = 1;
		    break;
		}
		else if (   (next->type == E_TEXT)
			 || (next->type == E_IMAGE))
		{
		    rc = 0;
		    break;
		}
	    }
	    break;

	default:
	    break;
	}
    }
    return rc;
}


/*
 * PSfootnote - output a footnote mark and store the footnote
 *
 * the footnote mark is placed at the current point, enclosed in a gsave/grestore
 * pair so that the position of the following output is not affected.
 * The reference is stored in a malloced array (which may need to be expanded), to
 * be output at the end of the page.
 */
static void
PSfootnote(char *href, double height)
{
    PSprintf("gsave 0 %.2f R RF %d SF (%d) S grestore\n", 
	     height, footnote_ptsize, cur_ftn_no++);

    if (n_saved_ftns == ftn_array_size) 
    {
	ftn_array_size += 16;
	if (!footnotes) {
		footnotes = (char **)calloc(ftn_array_size,sizeof(char *));
	}
	else {
		footnotes = (char **)realloc((void *)footnotes,
				     (ftn_array_size * sizeof(char *)));
	}
	if (footnotes == NULL) 
	{
	    fprintf(stderr, "PSfootnote realloc failed\n");
	    return;
	}
    }

    footnotes[n_saved_ftns++] = href;
}


/*
 * PStext - output text
 *
 * show text "t", and protect special characters if needed
 * if Underline is non-zero, the text is underlined.
 *
 */
static void
PStext(HTMLWidget hw, struct ele_rec *eptr, int fontfamily, String s)
{
    String 		s2;
    String 		stmp;
    unsigned char	ch;
    int 		underline = eptr->underline_number;
    int		 	ascent;
			  
    PSfont(hw, eptr->font, fontfamily);	/* set font */
    if (PS_fontascent == 0) 
	ascent = eptr->font->ascent;
    else
	ascent = PS_fontascent;
    PSmove_offset(eptr->y_offset + ascent);


    /* Allocate a string long enough to hold the original string with
       every character stored as an octal escape (worst case scenario). */

    s2 = (String) malloc(strlen(s) * 4 + 1);
    if (s2 == NULL) 
    {
	fprintf(stderr, "PStext malloc failed\n");
	return;
    }

    /*  For each char in s, if it is a special char, insert "\"
     *  into the new string s2, then insert the actual char
     */
    for (stmp = s2; (ch = *s++) != '\0';)
    {
	if ((ch == L_PAREN) || (ch == R_PAREN) || (ch == B_SLASH))
	{
	    *stmp++ = B_SLASH;
	    *stmp++ = ch;
	}
	else if (ch > (unsigned char) MAX_ASCII) 
	{
	    /*  convert to octal */
	    *stmp++ = B_SLASH;
	    *stmp++ = ((ch >> 6) & 007) + '0';
	    *stmp++ = ((ch >> 3) & 007) + '0';
	    *stmp++ = (ch & 007) + '0';
	} 
	else
	{
	    *stmp++ = ch;
	}
    }
    *(stmp) = '\0';
    PSprintf("(%s)%c\n", s2, (underline)?'U':'S');
    if (HTML_Print_Footers && has_footnote(eptr)) 
    {
	PSfootnote(eptr->anchorHRef, 0.7 * ascent);
    }
    free(s2);
}


/*
 * PSbullet - output a bullet
 *
 * The bullet is normally filled, except for a bullet with an indent level
 * of two. The size of the higher level bullets is just somewhat smaller
 *
 */
static void 
PSbullet(HTMLWidget hw, struct ele_rec *eptr, int fontfamily)
{
    int 	width  = (  eptr->font->max_bounds.lbearing 
		          + eptr->font->max_bounds.rbearing);
    int 	offset = eptr->y_offset + eptr->font->ascent;
    int		level  = eptr->indent_level;
    double 	size   = eptr->line_height / 5.5;

    if (size < 1.1) size = 1.1;
    if (level > 2)  size /= 1.33333;

    /* the next line is a hack to get a good position of the
     * bullet in most practical cases, otherwise the
     * bullet may appear just a bit too low (for large fonts)
     * What is does is to compare the lineheight with
     * the lineheight of the next element, to correct
     * for the possibly too large y_offset
     */

    if (   (eptr->next != NULL)
	&& (   (eptr->next->type == E_TEXT)
	    || (eptr->next->type == E_IMAGE)))
    {
	offset += (eptr->line_height - eptr->next->line_height);
    }

    PSfont(hw, eptr->font, fontfamily);
    PSmove_offset(offset - width/4);
    PSprintf(" %f %s\n", size, (level == 2) ? "OB" : "B");
}


/*
 * PShrule - draw a horizontal line with the given width
 *
 * nothing special, just draw a line, from the current position to
 * the right side of the paper.
 *
 */
static void
PShrule(HTMLWidget hw, struct ele_rec *eptr, int fontfamily)
{
    int length = hw->html.doc_width;

    PSmove_offset(eptr->y_offset);
    PSprintf("%d HR\n", length);
}




/*
 * PStable - draw a table
 *
 * Currently just draw a box of the dimensions of the table.
 *
 */
static void
PStable(HTMLWidget hw, struct ele_rec *eptr, int fontfamily)
{
    struct table_rec	*tptr = eptr->table_data;
    int width  = tptr->width;
    int height = tptr->height;

#if 0
    PSmove_offset(eptr->y_offset);
    PSprintf("gsave currentpoint %d sub translate ", height);
    PSprintf("%d %d scale\n", width, height);
    PSprintf("SQ stroke\n");
    PSprintf("grestore\n");
#endif
}


/*
 * PSwidget - draw a widget (form field)
 *
 * Currently just draw a grey box of the dimensions of the field.
 * This is nowhere near complete but is a first step.
 * The widget record type field gives the type of field:
 *	0	textfield
 *	1	checkbox
 *	2	radiobox
 *	3	pushbutton
 *	4	password
 *	5	option menu
 */
static void
PSwidget(HTMLWidget hw, struct ele_rec *eptr, int fontfamily)
{
    struct wid_rec *wptr = eptr->widget_data;
    int w = wptr->width;
    int h = wptr->height;

#if 1	/* Comment out? */
    PSmove_offset(eptr->y_offset);
    PSprintf("gsave currentpoint %d sub translate ", h);
    PSprintf("%d %d scale\n", w, h);
    PSprintf("SQ 0.9 setgray fill\n");
    PSprintf("grestore\n");
#endif
}


/*
 * PSrle_encode - perform run length encoding
 *
 * does the run-length encoding. This is done to reduce the file size and
 * therefore the time to send the file to the printer. You get longer
 * processing time instead.
 * 
 * rle is encoded as such:
 *  <count> <value>			# 'run' of count+1 equal pixels
 *  <count | 0x80> <count+1 data bytes>	# count+1 non-equal pixels
 * count can range between 0 and 127
 *
 * returns length of the rleline vector
 *
*/ 
static int
PSrle_encode(unsigned char *scanline, 
	     unsigned char *rleline,
	     int wide) 
{
    int  i, j, blocklen, isrun, rlen;
    unsigned char block[256], pix;

    blocklen = isrun = rlen = 0;

    for (i = 0; i < wide; i++) 
    {
	/*  there are 5 possible states:
	 *   0: block empty.
	 *   1: block is a run, current pix == previous pix
	 *   2: block is a run, current pix != previous pix
	 *   3: block not a run, current pix == previous pix
	 *   4: block not a run, current pix != previous pix
	 */

	pix = scanline[i];

	if (!blocklen) 
	{
	    /* case 0:  empty */
	    block[blocklen++] = pix;
	    isrun = 1;
	}
	else if (isrun) 
	{
	    if (pix == block[blocklen-1])
	    { 
		/*  case 1:  isrun, prev==cur */
		block[blocklen++] = pix;
	    }
	    else 
	    {
		/*  case 2:  isrun, prev!=cur */
		if (blocklen>1) 
		{
		    /*  we have a run block to flush */
		    rleline[rlen++] = blocklen-1;
		    rleline[rlen++] = block[0];
		    /*  start new run block with pix */
		    block[0] = pix;
		    blocklen = 1;
		}
		else
		{
		    /*  blocklen<=1, turn into non-run */
		    isrun = 0;
		    block[blocklen++] = pix;
		}
	    }
	}
	else
	{ 
	    /* not a run */
	    if (pix == block[blocklen-1]) 
	    {
		/* case 3: non-run, prev==cur */
		if (blocklen>1) 
		{
		    /*  have a non-run block to flush */
		    rleline[rlen++] = (blocklen-1) | 0x80;
		    for (j=0; j<blocklen; j++)
			rleline[rlen++] = block[j];
		    /*  start new run block with pix */
		    block[0] = pix;
		    blocklen = isrun = 1;
		} 
		else
		{
		    /*  blocklen<=1 turn into a run */
		    isrun = 1;
		    block[blocklen++] = pix;
		}
	    }
	    else 
	    {
		/* case 4:  non-run, prev!=cur */
		block[blocklen++] = pix;
	    }
	}
	
	/* max block length.  flush */
	if (blocklen == 128)
	{
	    if (isrun) 
	    {
		rleline[rlen++] = blocklen-1;
		rleline[rlen++] = block[0];
	    }
	    else
	    {
		rleline[rlen++] = (blocklen-1) | 0x80;
		for (j=0; j<blocklen; j++)
		    rleline[rlen++] = block[j];
	    }
	    blocklen = 0;
	}
    }

    /* flush last block */
    if (blocklen)
    {
	if (isrun)
	{
	    rleline[rlen++] = blocklen-1;
	    rleline[rlen++] = block[0];
	}
	else
	{
	    rleline[rlen++] = (blocklen-1) | 0x80;
	    for (j=0; j<blocklen; j++)
		rleline[rlen++] = block[j];
	}
    }

    return rlen;
}


/*
 * PScolor_image - created postscript colorimage operator 
 *
 * spits out code that checks if the PostScript device in question
 * knows about the 'colorimage' operator.  If it doesn't, it defines
 * 'colorimage' in terms of image (ie, generates a greyscale image from
 * RGB data)
 *
*/

static void 
PScolor_image(void) 
{
    static char *txt[] = {

	"% define 'colorimage' if it isn't defined",
	"%   ('colortogray' and 'mergeprocs' come from xwd2ps",
	"%	 via xgrab)",
	"/colorimage where   % do we know about 'colorimage'?",
	"  { pop }		   % yes: pop off the 'dict' returned",
	"  {				 % no:  define one",
	"	/colortogray {  % define an RGB->I function",
	"	  /rgbdata exch store	% call input 'rgbdata'",
	"	  rgbdata length 3 idiv",
	"	  /npixls exch store",
	"	  /rgbindx 0 store",
	"	  /grays npixls string store  % str to hold the result",
	"	  0 1 npixls 1 sub {",
	"		grays exch",
	"		rgbdata rgbindx	   get 20 mul	% Red",
	"		rgbdata rgbindx 1 add get 32 mul	% Green",
	"		rgbdata rgbindx 2 add get 12 mul	% Blue",
	"		add add 64 idiv	  % I = .5G + .31R + .18B",
	"		put",
	"		/rgbindx rgbindx 3 add store",
	"	  } for",
	"	  grays",
	"	} bind def\n",
	/* Utility procedure for colorimage operator.
	 * This procedure takes two procedures off the
	 * stack and merges them into a single procedure
	 */
	"	/mergeprocs { % def",
	"	  dup length",
	"	  3 -1 roll dup length dup 5 1 roll",
	"	  3 -1 roll add array cvx dup",
	"	  3 -1 roll 0 exch putinterval",
	"	  dup 4 2 roll putinterval",
	"	} bind def\n",
	"	/colorimage { % def",
	/* remove 'false 3' operands */
	"	  pop pop",
	"	  {colortogray} mergeprocs",
	"	  image",
	"	} bind def",
	/* end of 'false' case */
	"  } ifelse"
    };

    PSconst_out(txt);
}
 

/*
 * PScolormap - write colormap
 *
 * spits out code for the colormap of the following image
 * if !color, it spits out a mono-ized graymap
 * 
*/
static void
PScolormap(int color, 
	   int nc, 
	   int *rmap, 
	   int *gmap, 
	   int *bmap) 
{
    int i;

    /*  define the colormap */
    PSprintf("/cmap %d string def\n\n\n", nc * ((color) ? 3 : 1));

    /*  load up the colormap */
    PSprintf("currentfile cmap readhexstring\n");

    for (i=0; i<nc; i++) 
    {
	if (color)  
	    PSprintf("%02x%02x%02x ", rmap[i]>>8,
		     gmap[i]>>8, bmap[i]>>8);
	else  
	    PSprintf("%02x ", MONO(rmap[i], gmap[i], bmap[i]));
	if ((i%10) == 9)
	    PSprintf("\n");
    }
    PSprintf("\n");
    PSprintf("pop pop\n"); /* lose return values from readhexstring */
}


/*
 * PSrle_cmapimage - define rlecmapimage operator
 * 
 */
static void
PSrle_cmapimage(int color) 
{

    static char *txt[] = {

	/* rlecmapimage expects to have 'w h bits matrix' on stack */
	"/rlecmapimage {",
	"  /buffer 1 string def",
	"  /rgbval 3 string def",
	"  /block  384 string def",
	"  { currentfile buffer readhexstring pop",
	"	/bcount exch 0 get store",
	"	bcount 128 ge",
	"	{ ",
	"	  0 1 bcount 128 sub",
	"	{ currentfile buffer readhexstring pop pop"
    };

    static char *txt_color[] = {
	"		/rgbval cmap buffer 0 get 3 mul 3 getinterval store",
	"		block exch 3 mul rgbval putinterval",
	"	  } for",
	"	  block  0  bcount 127 sub 3 mul  getinterval",
	"	}",
	"	{ ",
	"	  currentfile buffer readhexstring pop pop",
	"	  /rgbval cmap buffer 0 get 3 mul 3 getinterval store",
	"	  0 1 bcount { block exch 3 mul rgbval putinterval } for",
	"	  block 0 bcount 1 add 3 mul getinterval",
	"	} ifelse",
	"  }",
	"  false 3 colorimage",
	"} bind def"
    };

    static char *txt_gray[] = {
	"		/rgbval cmap buffer 0 get 1 getinterval store",
	"		block exch rgbval putinterval",
	"	  } for",
	"	  block  0  bcount 127 sub  getinterval",
	"	}",
	"	{ ",
	"	  currentfile buffer readhexstring pop pop",
	"	  /rgbval cmap buffer 0 get 1 getinterval store",
	"	  0 1 bcount { block exch rgbval putinterval } for",
	"	  block 0 bcount 1 add getinterval",
	"	} ifelse",
	"  }",
	"  image",
	"} bind def"
    };

    PSconst_out(txt);
    if (color) 
    {
	PSconst_out(txt_color);
    } 
    else 
    {
	PSconst_out(txt_gray);
    }
}


/*
 * PSwrite_bw - write B&W image
 *
 * Write the given image array 'pic' (B/W stippled, 1 byte per pixel,
 * 0=blk,1=wht) out as hexadecimal, max of 72 hex chars per line.  If
 * 'flipbw', then 0=white, 1=black.  Returns '0' if everythings fine,
 * 'EOF' if writing failed.
 *
*/
static int
PSwrite_bw(unsigned char *pic, int w, int h, int flipbw)
{
    int	i, j;
    int	err=0;
    unsigned char outbyte, bitnum, bit;
    
    outbyte = bitnum = 0;
    for (i=0; i<h && err != EOF; i++) {
	for (j=0; j<w && err != EOF; j++) {
	    bit = *(pic++);
	    outbyte = (outbyte<<1) | ((bit)&0x01);
	    bitnum++;
	    
	    if (bitnum==8) {
		if (flipbw)
		    outbyte = ~outbyte & 0xff;
		err=PShex(outbyte, False);
		outbyte = bitnum = 0;
	    }
	}
	if (bitnum) {	/*  few bits left over in this row */
	    outbyte <<= 8-bitnum;
	    if (flipbw)
		outbyte = ~outbyte & 0xff;
	    err=PShex(outbyte, False);
	    outbyte = bitnum = 0;
	}
    }
    err=PShex('\0', True);	/*  Flush the hex buffer if needed */
    
    return err;
}


/*
 * PSimage - generate image Postscript code
 *
 * Draw the image, unless there was no image, in which case an empty grey
 * rectangle is shown.
 * If anchor is set, a black border is shown around the image.
 * Positioning is not exactly that of Xmosaic's screen, but close enough.
 * 
*/

static void 
PSimage(HTMLWidget hw, struct ele_rec *eptr, int fontfamily)
{
    ImageInfo 		*img = eptr->pic_data;
    unsigned char 	*imgp = img->image_data;
    int 		anchor = (eptr->anchorHRef != NULL); 	
    int 		ncolors = img->num_colors;
    int 		i, j;
    int 		w = img->width;
    int 		h = img->height;
    int 		slen, colorps, colortype, bits;
    int 		err=0;
    int 		extra = 0;


    /* Isgray returns true if the nth color index is a gray value */
#	define Isgray(i,n) (i->reds[n]==i->greens[n] && i->reds[n]==i->blues[n])
    /* Is_bg returns true if the nth color index is the screen background */
#	define Is_bg(i,n)  (i->reds[n]==bg_color.red &&			\
		i->greens[n]==bg_color.green && i->blues[n]==bg_color.blue)
    /* Is_fg returns true if the nth color index is the screen foreground */
#	define Is_fg(i,n)  (i->reds[n]==fg_color.red &&			\
		i->greens[n]==fg_color.green && i->blues[n]==fg_color.blue)


    PSmove_offset(eptr->y_offset);
    if (anchor) 
    {
	/*  draw an outline by drawing a slightly larger black square
	 *  below the actual image
	 */
	PSprintf("gsave currentpoint %d sub translate ", h);
	PSprintf("0 -2 translate %d %d scale\n", w+4, h+4);
	PSprintf("SQ fill\n");
	PSprintf("grestore\n");
	extra = 4;
    }
	
    if (imgp == NULL) 
    {
	/*  image was not available... do something instead
	 *  draw an empty square for example
	 */
	PSprintf("gsave currentpoint %d sub translate", h);
	if (anchor)
	    PSprintf(" 2 0 translate");
	else
	    PSprintf(" 0 2 translate");
	PSprintf(" %d %d scale\n", w, h);
	PSprintf("0.9 setgray SQ fill\n");
	PSprintf("grestore\n");
	/*  move currentpoint just right of image */
	PSprintf("%d 0 R\n", w+extra);
	return;
    }

    /*  this is a hack to see if the image is Black & White, 
     *  Greyscale or 8 bit color
     *  assume it's bw if it has only one or two colors, both some grey's
     *  assume it's greyscale if all the colors (>2) are grey
     *  Images with only one color do occur too.
     */
    
    if (   (   (ncolors == 2) 
	    && (   (Isgray(img,0) && Isgray(img,1))
	        || (Is_bg(img,0) && Is_fg(img,1)) 
	        || (Is_fg(img,0) && Is_bg(img,1)) ))
	|| (   (ncolors == 1)
	    && (Isgray(img,0)
		|| Is_bg(img,0) 
		|| Is_fg(img,0))))
    {
	colortype = F_BWDITHER;
	slen = (w+7)/8;
	bits = 1;
	colorps = 0;
    } else {
	colortype = F_GREYSCALE;
	slen = w;
	bits = 8;
	colorps = 0;
	for (i=0; i<ncolors; i++) {
	    if (!Isgray(img,i)) {
		colortype = F_REDUCED;
		slen = w*3;
		bits = 8;
		colorps = 1;
		break;
	    }
	}
    }
	
    /*  build a temporary dictionary */
    PSprintf("20 dict begin\n\n");

    /*  define string to hold a scanline's worth of data */
    PSprintf("/pix %d string def\n\n", slen);
    
    /*  position and scaling */
    PSprintf("gsave currentpoint %d sub translate", h);
    if (anchor)
	PSprintf(" 2 0 translate");
    else
	PSprintf(" 0 2 translate");
    PSprintf(" %d %d scale\n", w, h);
    
    if (colortype == F_BWDITHER) 
    {
	/*  1-bit dither code uses 'image' */
	int flipbw = 0;
	
	/*  set if color#0 is 'white' */
	if ((ncolors == 2 &&
	     MONO(img->reds[0], img->greens[0],img->blues[0]) >
	     MONO(img->reds[1], img->greens[1], img->blues[1])) ||
	    (ncolors == 1 && 
	     MONO(img->reds[0], img->greens[0],img->blues[0]) >
	     MONO(127, 127, 127) ))
	{
	    flipbw=1; 
	}
	
	/*  dimensions of data */
	PSprintf("%d %d %d\n", w, h, bits);
	
	/*  mapping matrix */
	PSprintf("[%d 0 0 %d 0 %d]\n\n", w, -h, h);
	
	PSprintf("{currentfile pix readhexstring pop}\n");
	PSprintf("image\n");

	/*  write the actual image data */
	err = PSwrite_bw(imgp, w, h, flipbw);
    } 
    else
    {
	/*  all other formats */
	unsigned char *rleline = (unsigned char *) NULL;
	int rlen;
	
	/*  if we're using color, make sure 'colorimage' is defined */
	if (colorps)
	    PScolor_image();
	
	PScolormap(colorps, ncolors, img->reds, img->greens, img->blues);
	PSrle_cmapimage(colorps);

	/*  dimensions of data */
	PSprintf("%d %d %d\n", w, h, bits);
	/*  mapping matrix */
	PSprintf("[%d 0 0 %d 0 %d]\n", w, -h, h);
	PSprintf("rlecmapimage\n");
	
	rleline = (unsigned char *) malloc(w * 2);
	if (!rleline) 
	{
	    fprintf(stderr,"failed to malloc space for rleline\n");
	    return;
	}

	for (i=0; i<h && err != EOF; i++) 
	{
	    rlen = PSrle_encode(imgp, rleline, w);
	    imgp += w;
	    for (j=0; j<rlen && err != EOF; j++)
		err=PShex(rleline[j], False);
	    err=PShex('\0', True);	/*  Flush the hex buffer */
	}
	free(rleline);
    }
	
    /*  stop using temporary dictionary */
    PSprintf("end\n");
    PSprintf("grestore\n");
	
    /*  move currentpoint just right of image */
    PSprintf("%d 0 R\n", w + extra); 
    if (HTML_Print_Footers && has_footnote(eptr)) 
    {
	PSmove_offset(0);
	PSfootnote(eptr->anchorHRef, 2.0);
    }


    /* forget about the macro's */
#	undef Isgray
#	undef Is_fg
#	undef Is_bg
}



/*
 * ParseTextToPSString - entry point for postscript output
 *
 * Parse all the formatted text elements from start to end
 * into an ascii text string, and return it.
 * Very like ParseTextToString() except the text is prettied up
 * into Postscript to show headers and the like.
 * space_width and lmargin tell us how many spaces
 * to indent lines.
 * Because this routine is only used to print whole documents,
 * some parameters are not needed at all!
 * Also it assumes that you are indeed printing the whole document, and
 * not just a selected portion of it. It therefore can assume that
 * only for the first page the initialization is needed, and only
 * the last page has the trailers. You cannot use ParseTextToPSString()
 * as you can use ParseTextToString() because of this initialization code.
 *
 * the fontfamily parameter is new
 * The font is encoded as:
 *	0: times (default for now)
 *	1: helvetica
 *	2: new century schoolbook
 *	3: lucida
 */
String ParseTextToPSString(HTMLWidget	 	hw, 
			   struct ele_rec	*elist,
			   struct ele_rec	*startp,
			   struct ele_rec	*endp,
			   int			start_pos, 
			   int			end_pos,
			   int			space_width,
			   int			lmargin,
			   int			fontfamily,
			   char   		*url,
			   char	   		*time_str)
{
    int			xpos, ypos, epos;
    int			height;
    double		pagewidth;
    int			line = -1;
    struct		ele_rec	*eptr;
    struct		ele_rec	*start;
    struct		ele_rec	*end;
    struct		ele_rec	*last;
    struct		ele_rec	*tmpptr;
    unsigned long 	fg_pixel, bg_pixel;    
    int			footnotes_this_page = 0;
    int			footnotes_this_line;
    int			reserved_space;
 	
    if (startp == NULL)
	return(NULL);


    /*
     * Get the foreground and background colors so we can check later
     * for black&white documents
     */
    XtVaGetValues (hw->html.view, 
#ifdef MOTIF
		   XtNforeground, &fg_pixel,
#endif
		   XtNbackground, &bg_pixel, 
		   NULL);
#ifndef MOTIF
    XtVaGetValues ((Widget)hw, 
		   XtNforeground, &fg_pixel,
		   NULL);
#endif	
    fg_color.pixel = fg_pixel;
    bg_color.pixel = bg_pixel;
    XQueryColor(XtDisplay(hw->html.view),
		DefaultColormap(XtDisplay(hw->html.view),
				DefaultScreen(XtDisplay(hw->html.view))),
		&fg_color);
    XQueryColor(XtDisplay(hw->html.view),
		DefaultColormap(XtDisplay(hw->html.view),
				DefaultScreen(XtDisplay(hw->html.view))),
		&bg_color);
    
    /*  this piece of code is needed if the user selects a portion
     *  of the document with the mouse.
     *  I think it will never be used, but I left it in anyway. F.
     */
    if (SwapElements(startp, endp, start_pos, end_pos)) 
    {
	start = endp;
	end = startp;
	epos = start_pos;
	start_pos = end_pos;
	end_pos = epos;
    }
    else
    {
	start = startp;
	end = endp;
    }
	
    /* Setup page size according to user preference. */

    if (HTML_Print_Paper_Size_A4)
	page_dimens = a4_page_dimens;
    else
	page_dimens = us_letter_page_dimens;

    page_dimens.text_height = (  page_dimens.page_height
			       - page_dimens.top_margin 
			       - page_dimens.bot_margin);
    page_dimens.text_width  = (  page_dimens.page_width
			       - page_dimens.left_margin 
			       - page_dimens.right_margin);

    /* Calculate the number of Postscript points per pixel of current
     * screen, and the height of the page in pixels (used in figuring
     * when we've hit the bottom of the page).
     */
    Points_Pixel = 72.0 / GetDpi(hw);
#ifdef OLD
    pagewidth = hw->html.doc_width;
#else /* gustaf fix */
    pagewidth = hw->html.view_width;
#endif /* gustaf fix */

    /* reduce the scaling if the width used for formatting is greater
     * than 8 * 72 pixels (8 inch)
     * In theory, this is not what you want for A4 paper (only 8.27 inch
     * wide), but I guess that the hw->html.doc_width includes some
     * left and right margins, so it seems to work in practice.
     */
    if (pagewidth > page_dimens.text_width) 
	Points_Pixel = Points_Pixel * page_dimens.text_width / pagewidth;
    Pixels_Page = (int) (page_dimens.text_height / Points_Pixel);		
	
    PSinit();
    PSheader(hw->html.title, fontfamily, url, time_str);
    PSnewpage();

    last = start;
    eptr = start;

    while ((eptr != NULL) && (eptr != end)) 
    {
	/* Skip the special internal text added for multi-page
	 * documents.
	 */
	if (eptr->internal == True) 
	{
	    if (eptr->type == E_LINEFEED) 
	    {
		PS_page_offset += eptr->line_height;
	    }
	    eptr = eptr->next;
	    continue;
	}

	/* check if this is a newline */
	if (line != eptr->line_number) 
	{
	    /* calculate max height */
	    height = 0;
	    footnotes_this_line = 0;
	    line = eptr->line_number;
	    tmpptr = eptr;
	    while (tmpptr != NULL && tmpptr->line_number == line) 
	    {
		if (tmpptr->line_height > height)
		    height = tmpptr->line_height;
		tmpptr = tmpptr->next;
		if (HTML_Print_Footers && has_footnote(tmpptr))
		    footnotes_this_line++;
	    }
	    ypos = eptr->y - PS_page_offset ;
	    xpos = eptr->x - lmargin;
	    if (xpos < 0)
		xpos = 0;

	    /* check if line fits completly on page */
	    
	    reserved_space = 0;
	    if (footnotes_this_page || footnotes_this_line) 
	    {
		reserved_space = (  (  footnote_space
				     + (  footnote_ptsize
					* (  footnotes_this_page 
					   + footnotes_this_line)))
				  / Points_Pixel);
	    }

	    if (ypos + height + reserved_space > PS_start_y + Pixels_Page) 
	    {
		PS_start_y = ypos;
		PSshowpage();
		PSnewpage();
		footnotes_this_page = 0;
	    }
	    footnotes_this_page += footnotes_this_line;
	    PSmoveto( xpos, ypos);
	}
		

	switch (eptr->type) 
	{
	case E_TEXT:
	    PStext(hw, eptr, fontfamily,
		   (String)((eptr == start) ? (eptr->edata + start_pos) : eptr->edata));
	    break;

	case E_BULLET: 
	    PSbullet(hw, eptr, fontfamily);
	    break;

	case E_IMAGE: 
	    PSimage(hw, eptr, fontfamily);
	    break;

	case E_LINEFEED: 
	    break;

	case E_HRULE:
	    PShrule(hw, eptr, fontfamily);
	    break;

	case E_TABLE:
	    PStable(hw, eptr, fontfamily);
	    break;

	case E_WIDGET:
	    PSwidget(hw, eptr, fontfamily);
	    break;

	}
	last = eptr;
	eptr = eptr->next;
    }
	
    PSshowpage();
    PStrailer();

    return (PS_string);
}

