/*@z50.c:PDF Back End:PDF_BackEnd@********************************************/
/*                                                                           */
/*  THE LOUT DOCUMENT FORMATTING SYSTEM (VERSION 3.24)                       */
/*  COPYRIGHT (C) 1991, 2000 Jeffrey H. Kingston                             */
/*                                                                           */
/*  Jeffrey H. Kingston (jeff@cs.usyd.edu.au)                                */
/*  Basser Department of Computer Science                                    */
/*  The University of Sydney 2006                                            */
/*  AUSTRALIA                                                                */
/*                                                                           */
/*  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, 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., 59 Temple Place, Suite 330, Boston MA 02111-1307 USA   */
/*                                                                           */
/*  FILE:         z49.c                                                      */
/*  MODULE:       PDF Back End                                               */
/*  EXTERNS:      PDF_BackEnd                                                */
/*                                                                           */
/*****************************************************************************/
#include <math.h>			/* for fabs()                        */
#include "externs.h"


/*****************************************************************************/
/*                                                                           */
/*  State variables for this module                                          */
/*                                                                           */
/*****************************************************************************/
#define	NO_FONT		0		/* actually stolen from z37.c        */
#define	NO_COLOUR	0
#define	MAX_GS		50		/* maximum depth of graphics states  */

static FILE		*out_fp;	/* file to print PDF on              */

typedef struct
{
  FONT_NUM	gs_font;		/* font number of this state         */
  COLOUR_NUM	gs_colour;		/* colour number of this state       */
  BOOLEAN	gs_cpexists;		/* TRUE if a current point exists    */
  FULL_LENGTH	gs_currenty;		/* if cpexists, its y coordinate     */
  short		gs_xheight2;		/* of font exists, half xheight      */
} GRAPHICS_STATE;

static GRAPHICS_STATE	gs_stack[MAX_GS];/* graphics state stack             */
static int		gs_stack_top;	/* top of graphics state stack       */

static FONT_NUM		currentfont;	/* font of most recent atom          */
static COLOUR_NUM	currentcolour;	/* colour of most recent atom        */
static short		currentxheight2;/* half xheight in current font      */
static BOOLEAN		cpexists;	/* true if a current point exists    */
static FULL_LENGTH	currenty;	/* if cpexists, its y coordinate     */

static int		wordcount;	/* atoms printed since last newline  */
static int		pagecount;	/* total number of pages printed     */
static BOOLEAN		prologue_done;	/* TRUE after prologue is printed    */
static OBJECT		needs;		/* Resource needs of included EPSFs  */
static OBJECT		supplied;	/* Resources supplied by this file   */


/*****************************************************************************/
/*                                                                           */
/*  Print a number x on file fp.                                             */
/*                                                                           */
/*****************************************************************************/

#define printnum(x, fp)							\
{ char buff[20];  register int i, y;					\
  if( x >= 0 )  y = x;							\
  else { y = -x; putc(CH_MINUS, fp); }					\
  i = 0;								\
  do { buff[i++] = numtodigitchar(y % 10);				\
     } while( (y = (y / 10)) > 0 );					\
  do { --i; putc(buff[i], fp);						\
     } while( i );							\
}


/*****************************************************************************/
/*                                                                           */
/*  PDF_PrintInitialize(FILE *fp)                                            */
/*                                                                           */
/*  Initialize this module; fp is the output file.                           */
/*                                                                           */
/*****************************************************************************/

static void PDF_PrintInitialize(FILE *fp)
{
  debug0(DPF, DD, "PDF_PrintInitialize(fp)");
  out_fp = fp;
  prologue_done = FALSE;
  gs_stack_top = -1;
  currentfont = NO_FONT;
  currentcolour = NO_COLOUR;
  cpexists = FALSE;
  wordcount = pagecount = 0;
  New(needs, ACAT);
  New(supplied, ACAT);
  debug0(DPF, DD, "PDF_PrintInitialize returning.");
} /* end PDF_PrintInitialize */


/*****************************************************************************/
/*                                                                           */
/*  void PDF_PrintLength(FULL_CHAR *buff, int length, int length_dim)        */
/*                                                                           */
/*  Print a length (debugging only)                                          */
/*                                                                           */
/*****************************************************************************/

static void PDF_PrintLength(FULL_CHAR *buff, int length, int length_dim)
{
  sprintf( (char *) buff, "%.3fc", (float) length/CM);
}


/*****************************************************************************/
/*                                                                           */
/*  void PDF_PrintPageSetupForFont(OBJECT face, int font_curr_page,          */
/*    FULL_CHAR *font_name, FULL_CHAR *first_size_str)                       */
/*                                                                           */
/*  Print the page setup commands required to use a font on some page:       */
/*                                                                           */
/*    face            The font face record, defining which font we need      */
/*    font_curr_page  The current page number                                */
/*    fp              The file to print the command(s) on                    */
/*    font_name       The name of the font                                   */
/*    first_size_str  No idea, have to check                                 */
/*                                                                           */
/*****************************************************************************/

static void PDF_PrintPageSetupForFont(OBJECT face, int font_curr_page,
  FULL_CHAR *font_name, FULL_CHAR *first_size_str)
{
  FULL_CHAR *enc = NULL;
  fprintf(out_fp, "%%%%IncludeResource: font %s\n", font_name);
  /***
  PDFFont_AddFont(out_fp, first_size_str, font_name,
    MapEncodingName(font_mapping(face)));
  ***/
  if (font_recoded(face)) {
    MAPPING m = font_mapping(face);
    /* This is a NASTY hack.  Need to rework the interface Since
       PDF is random-access format - we don't care which page this
       encoding is for and we need to only print it once -- Uwe */
    MapEnsurePrinted(m, 1);
    enc = MapEncodingName(m);
  }
  PDFFont_AddFont(out_fp, first_size_str, font_name, enc);
} /* end PDF_PrintPageSetupForFont */


/*****************************************************************************/
/*                                                                           */
/*  PDF_PrintPageResourceForFont(FULL_CHAR *font_name, BOOLEAN first)        */
/*                                                                           */
/*  Print page resource info on file fp for font font_name; first is true    */
/*  if this is the first resource on this page.                              */
/*                                                                           */
/*****************************************************************************/

static void PDF_PrintPageResourceForFont(FULL_CHAR *font_name, BOOLEAN first)
{
  /* JK: this was always commented out */
  /* PDFWriteFontResource(out_fp, font_name); */
} /* end PDF_PrintPageResourceForFont */


/*****************************************************************************/
/*                                                                           */
/*  static void PDF_PrintMapping(MAPPING m)                                  */
/*                                                                           */
/*  Print mapping m.                                                         */
/*                                                                           */
/*****************************************************************************/

static void PDF_PrintMapping(MAPPING m)
{ MAP_VEC map = MapTable[m]; int i;
  PDFFile_BeginFontEncoding(out_fp, (char*) string(map->name));
  for( i = 0;  i < MAX_CHARS;  i++ )
    fprintf(out_fp, "/%s%c", string(map->vector[i]), (i+1)%8 != 0 ? ' ' : '\n');
  PDFFile_EndFontEncoding(out_fp);
} /* end PDF_PrintMapping */


/*****************************************************************************/
/*                                                                           */
/*  PDF_PrintBeforeFirstPage(h, v, label)                                    */
/*                                                                           */
/*  This procedure is called just before starting to print the first         */
/*  component of the output.  Its size is h, v, and label is the page        */
/*  label to attach to the %%Page comment.                                   */
/*                                                                           */
/*****************************************************************************/

static void PDF_PrintBeforeFirstPage(FULL_LENGTH h, FULL_LENGTH v,
  FULL_CHAR *label)
{
  debug2(DPF, DD, "PrintBeforeFirst(%d, %d)", h, v);
  PDFFile_Init(out_fp, h/PT, v/PT, IN, CM, PT, EM);
  FontPrintPageSetup(out_fp);
  PDFPage_Init(out_fp, 1.0 / PT, PT/2);
  FontPrintPageResources(out_fp);	/*	write out font objects	*/
  FontAdvanceCurrentPage();
  prologue_done = TRUE;
} /* end PDF_PrintBeforeFirstPage */


/*****************************************************************************/
/*                                                                           */
/*  PDF_PrintBetweenPages(h, v, label)                                       */
/*                                                                           */
/*  Start a new output component, of size h by v; label is the page label    */
/*  to attach to the %%Page comment.                                         */
/*                                                                           */
/*****************************************************************************/

static void PDF_PrintBetweenPages(FULL_LENGTH h, FULL_LENGTH v,
  FULL_CHAR *label)
{
  debug2(DPF, DD, "PrintBetween(%d, %d)", h, v);

  /* write out page objects	*/
  PDFPage_Cleanup(out_fp);
  PDFPage_Init(out_fp, 1.0 / PT, PT/2);

  /* write out font objects	*/
  FontPrintPageResources(out_fp);
  FontPrintPageSetup(out_fp);
  FontAdvanceCurrentPage();
} /* end PDF_PrintBetweenPages */


/*****************************************************************************/
/*                                                                           */
/*  KernLength(fnum, ch1, ch2, res)                                          */
/*                                                                           */
/*  Set res to the kern length between ch1 and ch2 in font fnum, or 0 if     */
/*  none.                                                                    */
/*                                                                           */
/*****************************************************************************/

#define KernLength(fnum, mp, ch1, ch2, res)				\
{ int ua_ch1 = mp[ch1];							\
  int ua_ch2 = mp[ch2];							\
  int i, j;								\
  i = finfo[fnum].kern_table[ua_ch1], j;				\
  if( i == 0 )  res = 0;						\
  else									\
  { FULL_CHAR *kc = finfo[fnum].kern_chars;				\
    for( j = i;  kc[j] > ua_ch2;  j++ );				\
    res = (kc[j] == ua_ch2) ?						\
      finfo[fnum].kern_sizes[finfo[fnum].kern_value[j]] : 0;		\
  }									\
} /* end KernLength */


/*****************************************************************************/
/*                                                                           */
/*  static void PrintComposite(COMPOSITE *cp, BOOLEAN outline, FILE *fp)     */
/*                                                                           */
/*  This routine is unused in this module because it is the PostScript       */
/*  version and no PDF version has been written so far.  JeffK 2/5/00.       */
/*                                                                           */
/*  Print composite character cp, assuming that the current point is         */
/*  set to the correct origin.  If outline is true, we want to print the     */
/*  composite character in outline.                                          */
/*                                                                           */
/*****************************************************************************/

static void PrintComposite(COMPOSITE *cp, BOOLEAN outline, FILE *fp)
{ debug1(DPF, D, "PrintComposite(cp, %s, fp)", bool(outline));
  while( cp->char_code != '\0' )
  {
    debug4(DPF, D, "  cp = %d printing code %d (%d, %d)", (int) cp,
      cp->char_code, cp->x_offset, cp->y_offset);
    fprintf(fp, "%d %d (%c)%s ", cp->x_offset, cp->y_offset,
      cp->char_code, outline ? "co" : "c");
    cp++;
  }
} /* end PrintComposite */


/*****************************************************************************/
/*                                                                           */
/*  PDF_PrintWord(x, hpos, vpos)                                             */
/*                                                                           */
/*  Print non-empty word x; its marks cross at the point (hpos, vpos).       */
/*                                                                           */
/*****************************************************************************/

static void PDF_PrintWord(OBJECT x, int hpos, int vpos)
{ FULL_CHAR *p, *q, *a, *b, *lig, *unacc;
  int ksize;  char *command;  MAPPING m;
  unsigned short *composite; COMPOSITE *cmp; /* currently unused - JeffK */
  static int last_hpos;	/* does not need to be initialised */
  static int next_hpos = -1;
#if 0
  struct metrics *fnt;
#endif

  debug6(DPF, DD, "PrintWord( %s, %d, %d ) font %d colour %d%s", string(x),
    hpos, vpos, word_font(x), word_colour(x),
    word_outline(x) ? " outline" : "");
  TotalWordCount++;

  /* if font is different to previous word then print change */
  if( word_font(x) != currentfont )
  { currentfont = word_font(x);
    currentxheight2 = FontHalfXHeight(currentfont);
    PDFFont_Set(out_fp, FontSize(currentfont, x), FontName(currentfont));
  }

  /* if colour is different to previous word then print change */
  if( word_colour(x) != currentcolour )
  {
    currentcolour = word_colour(x);
    if( currentcolour > 0 )
    { char str[256];
      sprintf(str, "%s ", ColourCommand(currentcolour));
      PDFPage_Write(out_fp, str);
    }
  }

  /* move to coordinate of x */
  debug1(DPF, DDD, "  currentxheight2 = %d", currentxheight2);
  vpos = vpos - currentxheight2;
  if( cpexists && (currenty == vpos) && PDFHasValidTextMatrix() )
  { /* printnum(hpos, out_fp); */
    command = "s";

    /* Note: I calculate the width of the space char here in case the
       font has changed. This prevents subtle spacing errors.  */
#if 0
    fnt = finfo[currentfont].size_table;
    if( (next_hpos + fnt[' '].right /* width of space char */ ) == hpos )
      command = " ";
#endif
  }
  else
  { currenty = vpos;
    /* printnum(hpos, out_fp);
    fputs(" ", out_fp);
    printnum(currenty, out_fp); */
    command = "m";
    cpexists = TRUE;
  }

  /* convert ligature sequences into ligature characters */
  lig = finfo[word_font(x)].lig_table;
  p = q = string(x);
  do
  { 
    /* check for missing glyph (lig[] == 1) or ligatures (lig[] > 1) */
    if( lig[*q++ = *p++] )
    {
      if( lig[*(q-1)] == 1 ) continue;
      else
      {	a = &lig[ lig[*(p-1)] + MAX_CHARS ];
	while( *a++ == *(p-1) )
	{ b = p;
	  while( *a == *b && *(a+1) != '\0' && *b != '\0' )  a++, b++;
	  if( *(a+1) == '\0' )
	  { *(q-1) = *a;
	    p = b;
	    break;
	  }
	  else
	  { while( *++a );
	    a++;
	  }
	}
      }
    }
  } while( *p );
  *q = '\0';

  switch (command[0])
  {
    case 'm':

      PDFText_OpenXY(out_fp, hpos, vpos);
      last_hpos = hpos;
      next_hpos = hpos + fwd(x, COLM);	/* fwd(x, COLM) = width of wd */
      break;


    case 's':
#if 0
      PDFText_Open(out_fp);
      PDFText_Kern(out_fp, hpos - next_hpos);
#else
      PDFText_OpenX(out_fp, hpos - last_hpos);
#endif
      last_hpos = hpos;
      next_hpos = hpos + fwd(x, COLM);	/* fwd(x, COLM) = width of wd */
      break;
#if 0


    case ' ':

      PDFText_Open(out_fp);
#if 1
      /* try kerning to get correct position */
      PDFText_Kern(out_fp, fnt[' '].right);
#else
      PDFPage_Write(out_fp, EightBitToPrintForm[' ']);
#endif
      next_hpos += fwd(x, COLM) + fnt[' '].right;	/* width of space ch */
      break;
#endif

  }

  p = string(x);
  PDFPage_Write(out_fp, EightBitToPrintForm[*p]);

  m = font_mapping(finfo[word_font(x)].font_table);
  unacc = MapTable[m]->map[MAP_UNACCENTED];
  /* acc   = MapTable[m]->map[MAP_ACCENT]; */
  for( p++;  *p;  p++ )
  {
    /* *** this seems right but is actually wrong for PDF,
    which according to Uwe uses original units for kerning
    KernLength(word_font(x), unacc, *(p-1), *p, ksize);
    *** */
    KernLength(font_num(finfo[word_font(x)].original_face),
      unacc, *(p-1), *p, ksize);
    if ( ksize != 0 )
    {
      PDFText_Kern(out_fp, ksize);
    }
    PDFPage_Write(out_fp, EightBitToPrintForm[*p]);
  }
  PDFText_Close(out_fp);

  debug0(DPF, DDD, "PDF_PrintWord returning");
} /* end PDF_PrintWord */


/*****************************************************************************/
/*                                                                           */
/*  PDF_PrintPlainGraphic(OBJECT x, FULL_LENGTH xmk, ymk, OBJECT z)          */
/*                                                                           */
/*  Print a plain graphic object                                             */
/*                                                                           */
/*****************************************************************************/

static void PDF_PrintPlainGraphic(OBJECT x, FULL_LENGTH xmk,
  FULL_LENGTH ymk, OBJECT z)
{
  assert(FALSE, "PDF_PrintPlainGraphic: this routine should never be called!");
} /* end PDF_PrintPlainGraphic */


/*****************************************************************************/
/*                                                                           */
/*  PDF_PrintUnderline(fnum, col, xstart, xstop, ymk)                        */
/*                                                                           */
/*  Draw an underline suitable for font fnum, in colour col from xstart to   */
/*  xstop at the appropriate distance below mark ymk.                        */
/*                                                                           */
/*****************************************************************************/

static void PDF_PrintUnderline(FONT_NUM fnum, COLOUR_NUM col,
  FULL_LENGTH xstart, FULL_LENGTH xstop, FULL_LENGTH ymk)
{
  debug5(DPF, DD, "PDF_PrintUnderline(ft %d, co %d, xstrt %s, xstp %s, ymk %s)",
    fnum, col, EchoLength(xstart), EchoLength(xstop), EchoLength(ymk));
  PDFPage_PrintUnderline(out_fp,  xstart, xstop,
    ymk - finfo[fnum].underline_pos, finfo[fnum].underline_thick);
  debug0(DPF, DD, "PrintUnderline returning.");
} /* end PDF_PrintUnderline */


/*****************************************************************************/
/*                                                                           */
/*  PDF_PrintAfterLastPage()                                                 */
/*                                                                           */
/*  Clean up this module and close output stream.                            */
/*                                                                           */
/*****************************************************************************/

void PDF_PrintAfterLastPage(void)
{
  if( prologue_done )
  { 
    PDFPage_Cleanup(out_fp);		/* write out page objects */
    /* MapPrintResources(out_fp); not needed */
    PDFFile_Cleanup(out_fp);
  }
} /* end PDF_PrintAfterLastPage */


/*****************************************************************************/
/*                                                                           */
/*  PDF_CoordTranslate(xdist, ydist)                                         */
/*                                                                           */
/*  Translate coordinate system by the given x and y distances.              */
/*                                                                           */
/*****************************************************************************/

static void PDF_CoordTranslate(FULL_LENGTH xdist, FULL_LENGTH ydist)
{ debug2(DPF, D, "CoordTranslate(%s, %s)",
  EchoLength(xdist), EchoLength(ydist));
  if ((xdist != 0) || (ydist != 0))
  {
#if 1
    PDFPage_Translate(out_fp, xdist, ydist);
#else
    char	temp_str[64];
    sprintf(temp_str, "1 0 0 1 %d %d cm\n", xdist, ydist);
    PDFPage_Write(out_fp, temp_str);
#endif
  }
  cpexists = FALSE;
  debug0(DPF, D, "PDF_CoordTranslate returning.");
} /* end PDF_CoordTranslate */


/*****************************************************************************/
/*                                                                           */
/*  PDF_CoordRotate(amount)                                                  */
/*                                                                           */
/*  Rotate coordinate system by given amount (in internal DG units)          */
/*                                                                           */
/*****************************************************************************/
#define PI 3.1415926535897931160

static void PDF_CoordRotate(FULL_LENGTH amount)
{ int theAmount;
  debug1(DPF, D, "PDF_CoordRotate(%.1f degrees)", (float) amount / DG);
  theAmount = ((amount / DG) % 360);
  if( theAmount != 0 )
    PDFPage_Rotate(out_fp, (double) theAmount * (double) PI / (double) 180.0);
  cpexists = FALSE;
  debug0(DPF, D, "CoordRotate returning.");
} /* end PDF_CoordRotate */


/*****************************************************************************/
/*                                                                           */
/*  PDF_CoordScale(ratio, dim)                                               */
/*                                                                           */
/*  Scale coordinate system by ratio in the given dimension.                 */
/*                                                                           */
/*****************************************************************************/

static void PDF_CoordScale(float hfactor, float vfactor)
{
#if DEBUG_ON
  char buff[20];
#endif
  ifdebug(DPF, D, sprintf(buff, "%.3f, %.3f", hfactor, vfactor));
  debug1(DPF, D, "CoordScale(%s)", buff);
  if ( (fabs(hfactor - 1.0) > 0.01) || (fabs(vfactor - 1.0) > 0.01) )
  {
#if 1
    PDFPage_Scale(out_fp, hfactor, vfactor);
#else
    char temp_str[64];
    sprintf(temp_str, "%.2f 0 0 %.2f 0 0 cm\n", hfactor, vfactor);
    PDFPage_Write(out_fp, temp_str);
#endif
  }
  cpexists = FALSE;
  debug0(DPF, D, "CoordScale returning.");
} /* end PDF_CoordScale */


/*****************************************************************************/
/*                                                                           */
/*  PDF_SaveGraphicState(x)                                                  */
/*                                                                           */
/*  Save current coord system on stack for later restoration.                */
/*  Object x is just for error reporting, not really used at all.            */
/*                                                                           */
/*****************************************************************************/

void PDF_SaveGraphicState(OBJECT x)
{ debug0(DPF, D, "PDF_SaveGraphicState()");
  PDFPage_Push(out_fp);
  gs_stack_top++;
  if( gs_stack_top >= MAX_GS )
    Error(50, 1, "rotations, graphics etc. too deeply nested (max is %d)",
      FATAL, &fpos(x), MAX_GS);
  gs_stack[gs_stack_top].gs_font	= currentfont;
  gs_stack[gs_stack_top].gs_colour	= currentcolour;
  gs_stack[gs_stack_top].gs_cpexists	= cpexists;
  gs_stack[gs_stack_top].gs_currenty	= currenty;
  gs_stack[gs_stack_top].gs_xheight2	= currentxheight2;
  debug0(DPF, D, "PDF_SaveGraphicState returning.");
} /* end PDF_SaveGraphicState */


/*****************************************************************************/
/*                                                                           */
/*  PDF_RestoreGraphicState()                                                */
/*                                                                           */
/*  Restore previously saved coordinate system.                              */
/*                                                                           */
/*  The following note probably only applies to the PostScript back end      */
/*  but I have not looked into this issue myself:                            */
/*                                                                           */
/*                                               NB we normally assume that  */
/*  no white space is needed before any item of output, but since this       */
/*  procedure is sometimes called immediately after PrintGraphicObject(),    */
/*  which does not append a concluding space, we prepend one here.           */
/*                                                                           */
/*****************************************************************************/

void PDF_RestoreGraphicState(void)
{ debug0(DPF, D, "PDF_RestoreGraphicState()");
  PDFPage_Pop(out_fp);
  currentfont	  = gs_stack[gs_stack_top].gs_font;
  currentcolour	  = gs_stack[gs_stack_top].gs_colour;
  cpexists	  = gs_stack[gs_stack_top].gs_cpexists;
  currenty	  = gs_stack[gs_stack_top].gs_currenty;
  currentxheight2 = gs_stack[gs_stack_top].gs_xheight2;
  gs_stack_top--;
  debug0(DPF, D, "PDF_RestoreGraphicState returning.");
} /* end PDF_RestoreGraphicState */


/*****************************************************************************/
/*                                                                           */
/*  PDF_PrintGraphicObject(x)                                                */
/*                                                                           */
/*  Print object x on out_fp                                                 */
/*                                                                           */
/*****************************************************************************/

void PDF_PrintGraphicObject(OBJECT x)
{ OBJECT y, link;
  debug3(DPF, D, "PDF_PrintGraphicObject(%s %s %s)",
    EchoFilePos(&fpos(x)), Image(type(x)), EchoObject(x));
  switch( type(x) )
  {
    case WORD:
    case QWORD:

      PDFPage_WriteGraphic(out_fp, string(x));
      break;
	

    case ACAT:
    
      for( link = Down(x);  link != x;  link = NextDown(link) )
      {	Child(y, link);
	if( type(y) == GAP_OBJ )
	{
	  if( vspace(y) > 0 )  PDFPage_Write(out_fp, "\n");
	  else if( hspace(y) > 0 ) PDFPage_Write(out_fp, " ");
	}
	else if( is_word(type(y)) || type(y) == ACAT )
	  PDF_PrintGraphicObject(y);
	else if( type(y) == WIDE || is_index(type(y)) )
	{
	  /* ignore: @Wide, indexes are sometimes inserted by Manifest */
	}
	else
	{ Error(50, 2, "error in left parameter of %s",
	    WARN, &fpos(x), KW_GRAPHIC);
	  debug1(DPF, D, "  type(y) = %s, y =", Image(type(y)));
	  ifdebug(DPF, D, DebugObject(y));
	}
      }
      break;


    default:
    
      Error(50, 3, "error in left parameter of %s", WARN, &fpos(x), KW_GRAPHIC);
      debug1(DPF, D, "  type(x) = %s, x =", Image(type(x)));
      ifdebug(DPF, D, DebugObject(x));
      break;

  }
  debug0(DPF, D, "PDF_PrintGraphicObject returning");
} /* end PDF_PrintGraphicObject */


/*****************************************************************************/
/*                                                                           */
/*  PDF_DefineGraphicNames(x)                                                */
/*                                                                           */
/*  Generate PostScript for xsize, ysize etc. names of graphic object.       */
/*                                                                           */
/*****************************************************************************/

void PDF_DefineGraphicNames(OBJECT x)
{ assert( type(x) == GRAPHIC, "PrintGraphic: type(x) != GRAPHIC!" );
  debug1(DPF, D, "DefineGraphicNames( %s )", EchoObject(x));
  debug1(DPF, DD, "  style = %s", EchoStyle(&save_style(x)));

  /* if font is different to previous word then print change */
  if( font(save_style(x)) != currentfont )
  { currentfont = font(save_style(x));
    if( currentfont > 0 )
    { currentxheight2 = FontHalfXHeight(currentfont);
      PDFFont_Set(out_fp, FontSize(currentfont, x), FontName(currentfont));
    }
  }

  /* if colour is different to previous word then print change */
  if( colour(save_style(x)) != currentcolour )
  { currentcolour = colour(save_style(x));
    if( currentcolour > 0 )
    { char str[256];
      sprintf(str, "%s ", ColourCommand(currentcolour));
      PDFPage_Write(out_fp, str);
    }
  }

  PDFPage_SetVars(size(x, COLM), size(x, ROWM), back(x, COLM), fwd(x, ROWM),
    currentfont <= 0 ? 12*PT : FontSize(currentfont, x),
    width(line_gap(save_style(x))), width(space_gap(save_style(x))));

  debug0(DPF, D, "PDF_DefineGraphicNames returning.");
} /* end PDF_DefineGraphicNames */


/*****************************************************************************/
/*                                                                           */
/*  PDF_SaveTranslateDefineSave(x, xdist, ydist)                             */
/*                                                                           */
/*  Equivalent to the sequence of calls                                      */
/*                                                                           */
/*      SaveGraphicState(x)                                                  */
/*      CoordTranslate(xdist, ydist)                                         */
/*      DefineGraphicNames(x)                                                */
/*      SaveGraphicState(x)                                                  */
/*                                                                           */
/*  but offers prospects for optimization (not taken up in PDF).             */
/*                                                                           */
/*****************************************************************************/

void PDF_SaveTranslateDefineSave(OBJECT x, FULL_LENGTH xdist, FULL_LENGTH ydist)
{
  PDF_SaveGraphicState(x);
  PDF_CoordTranslate(xdist, ydist);
  PDF_DefineGraphicNames(x);
  PDF_SaveGraphicState(x);
} /* end PDF_SaveTranslateDefineSave */


/*****************************************************************************/
/*                                                                           */
/*  PDF_PrintGraphicInclude(x, colmark, rowmark)                             */
/*                                                                           */
/*  Print graphic include file, with appropriate surrounds.                  */
/*                                                                           */
/*****************************************************************************/

void PDF_PrintGraphicInclude(OBJECT x, FULL_LENGTH colmark, FULL_LENGTH rowmark)
{ OBJECT y;
  debug0(DPF, D, "PDF_PrintGraphicInclude(x)");
  Child(y, Down(x));
  Error(50, 4, "cannot include EPS file in PDF output; EPS file %s ignored",
      WARN, &fpos(x), string(y));
  debug0(DPF, D, "PDF_PrintGraphicInclude returning.");
} /* end PDF_PrintGraphicInclude */


/*****************************************************************************/
/*                                                                           */
/*  PDF_LinkSource(name, llx, lly, urx, ury)                                 */
/*                                                                           */
/*  Print a link source point.                                               */
/*                                                                           */
/*****************************************************************************/

static void PDF_LinkSource(OBJECT name, FULL_LENGTH llx, FULL_LENGTH lly,
  FULL_LENGTH urx, FULL_LENGTH ury)
{
  debug5(DPF, D, "PDF_LinkSource(%s, %d, %d, %d, %d)", EchoObject(name),
    llx, lly, urx, ury);

  /* still to do */

  debug0(DPF, D, "PDF_LinkSource returning.");
} /* end PDF_LinkSource */


/*****************************************************************************/
/*                                                                           */
/*  PDF_LinkDest(name, llx, lly, urx, ury)                                   */
/*                                                                           */
/*  Print a link dest point.                                                 */
/*                                                                           */
/*  Still to do: check that the name has not been used by a previous         */
/*  dest point.                                                              */
/*                                                                           */
/*****************************************************************************/

static void PDF_LinkDest(OBJECT name, FULL_LENGTH llx, FULL_LENGTH lly,
  FULL_LENGTH urx, FULL_LENGTH ury)
{
  debug5(DPF, D, "PDF_LinkDest(%s, %d, %d, %d, %d)", EchoObject(name),
    llx, lly, urx, ury);

  /* still to do */

  debug0(DPF, D, "PDF_LinkDest returning.");
} /* end PDF_LinkDest */


/*****************************************************************************/
/*                                                                           */
/*  PDF_LinkCheck()                                                          */
/*                                                                           */
/*  Called at end of run; will check that for every link source point there  */
/*  is a link dest point.                                                    */
/*                                                                           */
/*****************************************************************************/

static void PDF_LinkCheck()
{
  debug0(DPF, D, "PDF_LinkCheck()");

  /* still to do */

  debug0(DPF, D, "PDF_LinkCheck returning.");
} /* end PDF_LinkCheck */


/*****************************************************************************/
/*                                                                           */
/*  PDF_BackEnd                                                              */
/*                                                                           */
/*  The record into which all of these functions are packaged.               */
/*                                                                           */
/*****************************************************************************/

static struct back_end_rec pdf_back = {
  PDF,					/* the code number of the back end   */
  STR_PDF,				/* string name of the back end       */
  TRUE,					/* TRUE if @Scale is available       */
  TRUE,					/* TRUE if @Rotate is available      */
  TRUE,					/* TRUE if @Graphic is available     */
  TRUE,					/* TRUE if @IncludeGraphic is avail. */
  FALSE,				/* TRUE if @PlainGraphic is avail.   */
  TRUE,					/* TRUE if fractional spacing avail. */
  TRUE,					/* TRUE if actual font metrics used  */
  TRUE,					/* TRUE if colour is available       */
  PDF_PrintInitialize,
  PDF_PrintLength,
  PDF_PrintPageSetupForFont,
  PDF_PrintPageResourceForFont,
  PDF_PrintMapping,
  PDF_PrintBeforeFirstPage,
  PDF_PrintBetweenPages,
  PDF_PrintAfterLastPage,
  PDF_PrintWord,
  PDF_PrintPlainGraphic,
  PDF_PrintUnderline,
  PDF_CoordTranslate,
  PDF_CoordRotate,
  PDF_CoordScale,
  PDF_SaveGraphicState,
  PDF_RestoreGraphicState,
  PDF_PrintGraphicObject,
  PDF_DefineGraphicNames,
  PDF_SaveTranslateDefineSave,
  PDF_PrintGraphicInclude,
  PDF_LinkSource,
  PDF_LinkDest,
  PDF_LinkCheck,
};

BACK_END PDF_BackEnd = &pdf_back;