plmeta.c

Go to the documentation of this file.

//  Copyright (C) 1991, 1992, 1993, 1994, 1995  Geoffrey Furnish
//  Copyright (C) 1991, 1992, 1993, 1994, 1995  Maurice LeBrun
//
// PLplot is free software; you can redistribute it and/or modify
// it under the terms of the GNU Library General Public License as published
// by the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// PLplot 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 Library General Public License for more details.
//
// You should have received a copy of the GNU Library General Public License
// along with PLplot; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
//--------------------------------------------------------------------------
//
//  This is a metafile writer for PLplot.
//
//
#include "plDevs.h"
 
//#define DEBUG
 
#ifdef PLD_plmeta
 
#define NEED_PLDEBUG
#include "plplotP.h"
#include "drivers.h"
#include "metadefs.h"
#include <string.h>
 
// Device info
PLDLLIMPEXP_DRIVER const char* plD_DEVICE_INFO_plmeta = "plmeta:PLplot Native Meta-File:0:plmeta:26:plm\n";
 
 
void plD_dispatch_init_plm( PLDispatchTable *pdt );
 
void plD_init_plm( PLStream * );
void plD_line_plm( PLStream *, short, short, short, short );
void plD_polyline_plm( PLStream *, short *, short *, PLINT );
void plD_eop_plm( PLStream * );
void plD_bop_plm( PLStream * );
void plD_tidy_plm( PLStream * );
void plD_state_plm( PLStream *, PLINT );
void plD_esc_plm( PLStream *, PLINT, void * );
 
// Struct to hold device-specific info.
 
// Used for constructing error messages
 
#define BUFFER_LEN    256
 
// Function prototypes
 
static void WriteFileHeader( PLStream *pls );
static void UpdatePrevPagehdr( PLStream *pls );
static void WritePageInfo( PLStream *pls, FPOS_T pp_offset );
static void UpdateIndex( PLStream *pls, FPOS_T cp_offset );
static void plm_fill( PLStream *pls );
static void plm_swin( PLStream *pls );
static void plm_text( PLStream *pls, EscText *args );
 
// A little function to help with debugging
 
#ifdef DEBUG
#define DEBUG_PRINT_LOCATION( a )    PrintLocation( pls, a )
 
static void PrintLocation( PLStream *pls, char *tag )
{
    int isfile = ( pls->output_type == 0 );
    if ( isfile )
    {
        FILE   *file = pls->OutFile;
        FPOS_T current_offset;
 
        if ( pl_fgetpos( file, &current_offset ) )
            plexit( "PrintLocation (plmeta.c): fgetpos call failed" );
 
        pldebug( tag, "at offset %d in file %s\n",
            (int) current_offset, pls->FileName );
    }
}
#else
#define DEBUG_PRINT_LOCATION( a )
#endif
 
void plD_dispatch_init_plm( PLDispatchTable *pdt )
{
#ifndef ENABLE_DYNDRIVERS
    pdt->pl_MenuStr = "PLplot Native Meta-File";
    pdt->pl_DevName = "plmeta";
#endif
    pdt->pl_type     = plDevType_FileOriented;
    pdt->pl_seq      = 26;
    pdt->pl_init     = (plD_init_fp) plD_init_plm;
    pdt->pl_line     = (plD_line_fp) plD_line_plm;
    pdt->pl_polyline = (plD_polyline_fp) plD_polyline_plm;
    pdt->pl_eop      = (plD_eop_fp) plD_eop_plm;
    pdt->pl_bop      = (plD_bop_fp) plD_bop_plm;
    pdt->pl_tidy     = (plD_tidy_fp) plD_tidy_plm;
    pdt->pl_state    = (plD_state_fp) plD_state_plm;
    pdt->pl_esc      = (plD_esc_fp) plD_esc_plm;
}
 
//--------------------------------------------------------------------------
// plD_init_plm()
//
// Initialize device.
//--------------------------------------------------------------------------
 
void
plD_init_plm( PLStream *pls )
{
    PLmDev *dev;
 
    dbug_enter( "plD_init_plm" );
 
    pls->color     = 1;         // Is a color device
    pls->dev_fill0 = 1;         // Handle solid fills
    pls->dev_fill1 = 1;         // Driver handles pattern fills
 
    if ( strncmp( PLMETA_VERSION, "2005", 4 ) == 0 )
    {
        pls->dev_text    = 0;       // Disable text handling by the driver
        pls->dev_unicode = 0;       // Disable unicode support
        pls->dev_hrshsym = 0;
    }
    else
    {
        // NOTE:  This breaks compatibility with the 2005 version of
        // the plot metafile format
        // Unicode support is not needed because the plmeta driver
        // stores the unprocessed string data that was passed to PLplot.
        // However, we turn it on to force unicode representation of the
        // plot symbols in plsym.c rather than vectorization.
        pls->dev_text    = 1;       // Enable text handling by the driver
        pls->dev_unicode = 1;       // Enable unicode support
        pls->dev_hrshsym = 0;       // Disable vectorizaton of Hershey symbols
    }
 
// Initialize family file info
 
    plFamInit( pls );
 
// Prompt for a file name if not already set
 
    plOpenFile( pls );
    pls->pdfs = pdf_finit( pls->OutFile );
 
// Allocate and initialize device-specific data
 
    pls->dev = calloc( 1, (size_t) sizeof ( PLmDev ) );
    if ( pls->dev == NULL )
        plexit( "plD_init_plm: Out of memory." );
 
    dev = (PLmDev *) pls->dev;
 
    dev->xold = PL_UNDEFINED;
    dev->yold = PL_UNDEFINED;
 
    dev->xmin = 0;
    dev->xmax = PIXELS_X - 1;
    dev->ymin = 0;
    dev->ymax = PIXELS_Y - 1;
 
    dev->pxlx = (double) PIXELS_X / (double) LPAGE_X;
    dev->pxly = (double) PIXELS_Y / (double) LPAGE_Y;
 
    plP_setpxl( dev->pxlx, dev->pxly );
    plP_setphy( dev->xmin, dev->xmax, dev->ymin, dev->ymax );
 
// Write Metafile header.
 
    WriteFileHeader( pls );
 
// Write color map state info
 
    plD_state_plm( pls, PLSTATE_CMAP0 );
    plD_state_plm( pls, PLSTATE_CMAP1 );
 
// Write initialization command.
 
    DEBUG_PRINT_LOCATION( "before init" );
    plm_wr( pdf_wr_1byte( pls->pdfs, (U_CHAR) INITIALIZE ) );
}
 
//--------------------------------------------------------------------------
// plD_line_plm()
//
// Draw a line in the current color from (x1,y1) to (x2,y2).
//--------------------------------------------------------------------------
 
void
plD_line_plm( PLStream *pls, short x1, short y1, short x2, short y2 )
{
    PLmDev  *dev = (PLmDev *) pls->dev;
    U_SHORT xy[4];
 
    // dbug_enter("plD_line_plm");
 
    // Failsafe check
 
#ifdef DEBUG
    if ( x1 < dev->xmin || x1 > dev->xmax ||
         x2 < dev->xmin || x2 > dev->xmax ||
         y1 < dev->ymin || y1 > dev->ymax ||
         y2 < dev->ymin || y2 > dev->ymax )
    {
        pldebug( "plD_line_plm",
            "coordinates out of bounds -- \nActual: (%i,%i), (%i,%i) Bounds: (%i,%i,%i,%i)\n",
            x1, y1, x2, y2, dev->xmin, dev->xmax, dev->ymin, dev->ymax );
    }
#endif
 
// If continuation of previous line send the LINETO command, which uses
// the previous (x,y) point as it's starting location.  This results in a
// storage reduction of not quite 50%, since the instruction length for
// a LINETO is 5/9 of that for the LINE command, and given that most
// graphics applications use this command heavily.
//
// Still not quite as efficient as tektronix format since we also send the
// command each time (so shortest command is 25% larger), but a lot easier
// to implement than the tek method.
//
    if ( x1 == dev->xold && y1 == dev->yold )
    {
        plm_wr( pdf_wr_1byte( pls->pdfs, (U_CHAR) LINETO ) );
 
        xy[0] = x2;
        xy[1] = y2;
        plm_wr( pdf_wr_2nbytes( pls->pdfs, xy, 2 ) );
    }
    else
    {
        plm_wr( pdf_wr_1byte( pls->pdfs, (U_CHAR) LINE ) );
 
        xy[0] = x1;
        xy[1] = y1;
        xy[2] = x2;
        xy[3] = y2;
        plm_wr( pdf_wr_2nbytes( pls->pdfs, xy, 4 ) );
    }
    dev->xold = x2;
    dev->yold = y2;
}
 
//--------------------------------------------------------------------------
// plD_polyline_plm()
//
// Draw a polyline in the current color.
//--------------------------------------------------------------------------
 
void
plD_polyline_plm( PLStream *pls, short *xa, short *ya, PLINT npts )
{
    PLmDev *dev = (PLmDev *) pls->dev;
 
    dbug_enter( "plD_polyline_plm" );
 
    plm_wr( pdf_wr_1byte( pls->pdfs, (U_CHAR) POLYLINE ) );
 
    plm_wr( pdf_wr_2bytes( pls->pdfs, (U_SHORT) npts ) );
 
    plm_wr( pdf_wr_2nbytes( pls->pdfs, (U_SHORT *) xa, npts ) );
    plm_wr( pdf_wr_2nbytes( pls->pdfs, (U_SHORT *) ya, npts ) );
 
    dev->xold = xa[npts - 1];
    dev->yold = ya[npts - 1];
}
 
//--------------------------------------------------------------------------
// plD_eop_plm()
//
// End of page.
//--------------------------------------------------------------------------
 
void
plD_eop_plm( PLStream *pls )
{
    plm_wr( pdf_wr_1byte( pls->pdfs, (U_CHAR) EOP ) );
}
 
//--------------------------------------------------------------------------
// plD_bop_plm()
//
// Set up for the next page.
//
// Page header layout as follows:
//
// BOP                  (U_CHAR)
// page number          (U_SHORT)
// prev page offset     (U_LONG)
// next page offset     (U_LONG)
//
// Each call after the first is responsible for updating the table of
// contents and the next page offset from the previous page.
//--------------------------------------------------------------------------
 
void
plD_bop_plm( PLStream *pls )
{
    PLmDev *dev      = (PLmDev *) pls->dev;
    int    isfile    = ( pls->output_type == 0 );
    FPOS_T pp_offset = dev->lp_offset;
 
    dbug_enter( "plD_bop_plm" );
 
    dev->xold = PL_UNDEFINED;
    dev->yold = PL_UNDEFINED;
 
// Update previous page header
 
    if ( isfile )
        UpdatePrevPagehdr( pls );
 
// Start next family file if necessary.
 
    pls->bytecnt = pls->pdfs->bp;
    plGetFam( pls );
 
// Update page counter
 
    pls->page++;
 
// Update table of contents info & write new page header.
 
    WritePageInfo( pls, pp_offset );
}
 
//--------------------------------------------------------------------------
// plD_tidy_plm()
//
// Close graphics file
//--------------------------------------------------------------------------
 
void
plD_tidy_plm( PLStream *pls )
{
    dbug_enter( "plD_tidy_plm" );
 
    plm_wr( pdf_wr_1byte( pls->pdfs, (U_CHAR) CLOSE ) );
    pdf_close( pls->pdfs );
    free_mem( pls->dev );
}
 
//--------------------------------------------------------------------------
// plD_state_plm()
//
// Handle change in PLStream state (color, pen width, fill attribute, etc).
//--------------------------------------------------------------------------
 
void
plD_state_plm( PLStream *pls, PLINT op )
{
    int i;
 
    dbug_enter( "plD_state_plm" );
 
    plm_wr( pdf_wr_1byte( pls->pdfs, (U_CHAR) CHANGE_STATE ) );
    plm_wr( pdf_wr_1byte( pls->pdfs, op ) );
 
    switch ( op )
    {
    case PLSTATE_WIDTH:
        plm_wr( pdf_wr_2bytes( pls->pdfs, (U_SHORT) ( pls->width ) ) );
        break;
 
    case PLSTATE_COLOR0:
        plm_wr( pdf_wr_2bytes( pls->pdfs, (short) pls->icol0 ) );
 
        if ( pls->icol0 == PL_RGB_COLOR )
        {
            plm_wr( pdf_wr_1byte( pls->pdfs, pls->curcolor.r ) );
            plm_wr( pdf_wr_1byte( pls->pdfs, pls->curcolor.g ) );
            plm_wr( pdf_wr_1byte( pls->pdfs, pls->curcolor.b ) );
        }
        break;
 
    case PLSTATE_COLOR1:
        plm_wr( pdf_wr_2bytes( pls->pdfs, (U_SHORT) pls->icol1 ) );
        break;
 
    case PLSTATE_FILL:
        plm_wr( pdf_wr_1byte( pls->pdfs, (U_CHAR) pls->patt ) );
        break;
 
    case PLSTATE_CMAP0:
        plm_wr( pdf_wr_2bytes( pls->pdfs, (U_SHORT) pls->ncol0 ) );
        for ( i = 0; i < pls->ncol0; i++ )
        {
            plm_wr( pdf_wr_1byte( pls->pdfs, pls->cmap0[i].r ) );
            plm_wr( pdf_wr_1byte( pls->pdfs, pls->cmap0[i].g ) );
            plm_wr( pdf_wr_1byte( pls->pdfs, pls->cmap0[i].b ) );
        }
        break;
 
    case PLSTATE_CMAP1:
        plm_wr( pdf_wr_2bytes( pls->pdfs, (U_SHORT) pls->ncol1 ) );
        for ( i = 0; i < pls->ncol1; i++ )
        {
            plm_wr( pdf_wr_1byte( pls->pdfs, pls->cmap1[i].r ) );
            plm_wr( pdf_wr_1byte( pls->pdfs, pls->cmap1[i].g ) );
            plm_wr( pdf_wr_1byte( pls->pdfs, pls->cmap1[i].b ) );
        }
        break;
 
    case PLSTATE_CHR:
        // save the chrdef and chrht parameters
        if ( strncmp( PLMETA_VERSION, "2005", 4 ) != 0 )
        {
            plm_wr( pdf_wr_ieeef( pls->pdfs, (float) pls->chrdef ) );
            plm_wr( pdf_wr_ieeef( pls->pdfs, (float) pls->chrht ) );
        }
        break;
 
    case PLSTATE_SYM:
        // save the symdef and symht parameters
        if ( strncmp( PLMETA_VERSION, "2005", 4 ) != 0 )
        {
            plm_wr( pdf_wr_ieeef( pls->pdfs, (float) pls->symdef ) );
            plm_wr( pdf_wr_ieeef( pls->pdfs, (float) pls->symht ) );
        }
        break;
    }
}
 
//--------------------------------------------------------------------------
// plD_esc_plm()
//
// Escape function.  Note that any data written must be in device
// independent form to maintain the transportability of the metafile.
//
// Functions:
//
//      PLESC_FILL      Fill polygon
//      PLESC_SWIN      Set window parameters
//
//--------------------------------------------------------------------------
 
void
plD_esc_plm( PLStream *pls, PLINT op, void *ptr )
{
    dbug_enter( "plD_esc_plm" );
 
    plm_wr( pdf_wr_1byte( pls->pdfs, (U_CHAR) ESCAPE ) );
    plm_wr( pdf_wr_1byte( pls->pdfs, (U_CHAR) op ) );
 
    switch ( op )
    {
    case PLESC_FILL:
        plm_fill( pls );
        break;
 
    case PLESC_SWIN:
        plm_swin( pls );
        break;
 
    // Unicode and non-Unicode text handling
    case PLESC_HAS_TEXT:
        plm_text( pls, (EscText *) ptr );
        break;
 
    // Alternate unicode text handling
    case PLESC_BEGIN_TEXT:
    case PLESC_TEXT_CHAR:
    case PLESC_CONTROL_CHAR:
    case PLESC_END_TEXT:
        // NOP these for now until a decision is made
        // which method should be implemented for metafiles
        plwarn( "plmeta: Alternate Unicode text handling is not implemented" );
        break;
    }
}
 
//--------------------------------------------------------------------------
// Private functions
//--------------------------------------------------------------------------
 
//--------------------------------------------------------------------------
// plm_fill()
//
// Fill polygon described in points pls->dev_x[] and pls->dev_y[].
//--------------------------------------------------------------------------
 
static void
plm_fill( PLStream *pls )
{
    PLmDev *dev = (PLmDev *) pls->dev;
 
    dbug_enter( "plm_fill" );
 
    plm_wr( pdf_wr_2bytes( pls->pdfs, (U_SHORT) pls->dev_npts ) );
 
    plm_wr( pdf_wr_2nbytes( pls->pdfs, (U_SHORT *) pls->dev_x, pls->dev_npts ) );
    plm_wr( pdf_wr_2nbytes( pls->pdfs, (U_SHORT *) pls->dev_y, pls->dev_npts ) );
 
    dev->xold = PL_UNDEFINED;
    dev->yold = PL_UNDEFINED;
}
 
//--------------------------------------------------------------------------
// plm_swin()
//
// Set window parameters.
// Each parameter or group of parameters is tagged to make backward
// compatibility easier.
//--------------------------------------------------------------------------
 
static void
plm_swin( PLStream *pls )
{
    dbug_enter( "plm_swin" );
}
 
//--------------------------------------------------------------------------
// plm_text()
//
// Stores the text into the metafile.
//--------------------------------------------------------------------------
 
static void
plm_text( PLStream *pls, EscText *args )
{
    PLmDev *dev = (PLmDev *) pls->dev;
    size_t len;
 
    // Write state information needed to render the text
 
    plm_wr( pdf_wr_ieeef( pls->pdfs, pls->chrht ) );
    plm_wr( pdf_wr_ieeef( pls->pdfs, pls->diorot ) );
    plm_wr( pdf_wr_2bytes( pls->pdfs, pls->clpxmi ) );
    plm_wr( pdf_wr_2bytes( pls->pdfs, pls->clpxma ) );
    plm_wr( pdf_wr_2bytes( pls->pdfs, pls->clpymi ) );
    plm_wr( pdf_wr_2bytes( pls->pdfs, pls->clpyma ) );
 
    //  Write the text layout information
 
    plm_wr( pdf_wr_2bytes( pls->pdfs, (U_SHORT) args->base ) );
    plm_wr( pdf_wr_ieeef( pls->pdfs, (float) args->just ) );
 
    // Do we have a rotation shear that needs to be saved
    if ( args->xform != NULL )
    {
        plm_wr( pdf_wr_ieeef( pls->pdfs, (float) args->xform[0] ) );
        plm_wr( pdf_wr_ieeef( pls->pdfs, (float) args->xform[1] ) );
        plm_wr( pdf_wr_ieeef( pls->pdfs, (float) args->xform[2] ) );
        plm_wr( pdf_wr_ieeef( pls->pdfs, (float) args->xform[3] ) );
    }
    else
    {
        plwarn( "plmeta: transformation matrix undefined, using a guess" );
        plm_wr( pdf_wr_ieeef( pls->pdfs, (float) 1.0 ) );
        plm_wr( pdf_wr_ieeef( pls->pdfs, (float) 0.0 ) );
        plm_wr( pdf_wr_ieeef( pls->pdfs, (float) 0.0 ) );
        plm_wr( pdf_wr_ieeef( pls->pdfs, (float) 1.0 ) );
    }
 
    plm_wr( pdf_wr_2bytes( pls->pdfs, (U_SHORT) args->x ) );
    plm_wr( pdf_wr_2bytes( pls->pdfs, (U_SHORT) args->y ) );
    plm_wr( pdf_wr_2bytes( pls->pdfs, (U_SHORT) args->refx ) );
    plm_wr( pdf_wr_2bytes( pls->pdfs, (U_SHORT) args->refy ) );
    plm_wr( pdf_wr_1byte( pls->pdfs, (U_CHAR) args->font_face ) );
    plm_wr( pdf_wr_4bytes( pls->pdfs, (int) args->text_type ) );
 
    // Was a text string passed or a plot symbol?
    if ( args->text_type == PL_STRING_TEXT )
    {
        // Text string
        len = strlen( args->string );
        plm_wr( pdf_wr_2bytes( pls->pdfs, (U_SHORT) len ) );
        if ( len > 0 )
            plm_wr( pdf_wr_string( pls->pdfs, args->string ) );
    }
    else
    {
        // Plot symbol
        plm_wr( pdf_wr_2bytes( pls->pdfs, (U_SHORT) args->symbol ) );
    }
 
    // Clear the last known position
    dev->xold = PL_UNDEFINED;
    dev->yold = PL_UNDEFINED;
}
 
//--------------------------------------------------------------------------
// Provide a consistent method for handling a failed fsetpos.
//--------------------------------------------------------------------------
static void
handle_fsetpos_failed( const char *where, const char *which, FPOS_T position )
{
    char buffer[BUFFER_LEN];
 
    // Format a standard message detailing the failure location
    snprintf( buffer, BUFFER_LEN,
        "%s: fsetpos to %s (%lu) failed",
        where,
        which,
        (unsigned long) position );
 
    plexit( buffer );
}
 
//--------------------------------------------------------------------------
// WriteFileHeader()
//
// Writes Metafile header.
//--------------------------------------------------------------------------
 
static void
WriteFileHeader( PLStream *pls )
{
    PLmDev *dev   = (PLmDev *) pls->dev;
    FILE   *file  = pls->OutFile;
    int    isfile = ( pls->output_type == 0 );
 
    dbug_enter( "WriteFileHeader(PLStream *pls" );
 
    plm_wr( pdf_wr_header( pls->pdfs, PLMETA_HEADER ) );
    plm_wr( pdf_wr_header( pls->pdfs, PLMETA_VERSION ) );
 
    // Write file index info.  Right now only number of pages.
    // The order here is critical
 
    if ( isfile )
    {
        // Save the position of the pages field so that it can
        // be updated when a new page is created
        if ( pl_fgetpos( file, &dev->index_offset ) )
            plexit( "WriteFileHeader: fgetpos call failed" );
    }
 
    plm_wr( pdf_wr_header( pls->pdfs, "pages" ) );
    plm_wr( pdf_wr_2bytes( pls->pdfs, (U_SHORT) 0 ) );
 
    // Write initialization info.  Tag via strings to make backward
    // compatibility with old metafiles as easy as possible.
 
    plm_wr( pdf_wr_header( pls->pdfs, "xmin" ) );
    plm_wr( pdf_wr_2bytes( pls->pdfs, (U_SHORT) dev->xmin ) );
 
    plm_wr( pdf_wr_header( pls->pdfs, "xmax" ) );
    plm_wr( pdf_wr_2bytes( pls->pdfs, (U_SHORT) dev->xmax ) );
 
    plm_wr( pdf_wr_header( pls->pdfs, "ymin" ) );
    plm_wr( pdf_wr_2bytes( pls->pdfs, (U_SHORT) dev->ymin ) );
 
    plm_wr( pdf_wr_header( pls->pdfs, "ymax" ) );
    plm_wr( pdf_wr_2bytes( pls->pdfs, (U_SHORT) dev->ymax ) );
 
    plm_wr( pdf_wr_header( pls->pdfs, "pxlx" ) );
    plm_wr( pdf_wr_ieeef( pls->pdfs, (float) dev->pxlx ) );
 
    plm_wr( pdf_wr_header( pls->pdfs, "pxly" ) );
    plm_wr( pdf_wr_ieeef( pls->pdfs, (float) dev->pxly ) );
 
    // Geometry info, needed to properly transmit e.g. aspect ratio, via the
    // length params.  Not sure if the others are useful, but they're included
    // for completeness.
 
    plm_wr( pdf_wr_header( pls->pdfs, "xdpi" ) );
    plm_wr( pdf_wr_ieeef( pls->pdfs, (float) pls->xdpi ) );
 
    plm_wr( pdf_wr_header( pls->pdfs, "ydpi" ) );
    plm_wr( pdf_wr_ieeef( pls->pdfs, (float) pls->ydpi ) );
 
    plm_wr( pdf_wr_header( pls->pdfs, "xlength" ) );
    plm_wr( pdf_wr_2bytes( pls->pdfs, (U_SHORT) pls->xlength ) );
 
    plm_wr( pdf_wr_header( pls->pdfs, "ylength" ) );
    plm_wr( pdf_wr_2bytes( pls->pdfs, (U_SHORT) pls->ylength ) );
 
    plm_wr( pdf_wr_header( pls->pdfs, "xoffset" ) );
    plm_wr( pdf_wr_2bytes( pls->pdfs, (U_SHORT) pls->xoffset ) );
 
    plm_wr( pdf_wr_header( pls->pdfs, "yoffset" ) );
    plm_wr( pdf_wr_2bytes( pls->pdfs, (U_SHORT) pls->yoffset ) );
 
    plm_wr( pdf_wr_header( pls->pdfs, "" ) );
}
 
//--------------------------------------------------------------------------
// WritePageInfo()
//
// Update table of contents info & write new page header.
//--------------------------------------------------------------------------
 
static void
WritePageInfo( PLStream *pls, FPOS_T pp_offset )
{
    PLmDev *dev   = (PLmDev *) pls->dev;
    FILE   *file  = pls->OutFile;
    int    isfile = ( pls->output_type == 0 );
    U_CHAR c;
    FPOS_T cp_offset = 0;
 
    // Update table of contents.
 
    if ( isfile )
    {
        // Get the position of this page in order to update the index
        if ( pl_fgetpos( file, &cp_offset ) )
            plexit( "WritePageInfo (plmeta.c): fgetpos call failed" );
 
        UpdateIndex( pls, cp_offset );
    }
 
    // Write new page header
 
    if ( dev->notfirst )
        c = BOP;
    else
    {
        c             = BOP0;
        dev->notfirst = 1;
    }
    plm_wr( pdf_wr_1byte( pls->pdfs, c ) );
    plm_wr( pdf_wr_2bytes( pls->pdfs, (U_SHORT) pls->page ) );
    plm_wr( pdf_wr_4bytes( pls->pdfs, (U_LONG) pp_offset ) );
    plm_wr( pdf_wr_4bytes( pls->pdfs, (U_LONG) 0 ) );
 
    // Update last page offset with current page value
 
    dev->lp_offset = cp_offset;
 
    // Write some page state information just to make things nice later on
    // Eventually there will be more
 
    plD_state_plm( pls, PLSTATE_COLOR0 );
}
 
//--------------------------------------------------------------------------
// UpdatePrevPagehdr()
//
// Update previous page header.
//--------------------------------------------------------------------------
 
static void
UpdatePrevPagehdr( PLStream *pls )
{
    PLmDev *dev      = (PLmDev *) pls->dev;
    FILE   *file     = pls->OutFile;
    FPOS_T cp_offset = 0;
 
    fflush( file );
 
    // Determine where we are
 
    if ( pl_fgetpos( file, &cp_offset ) )
        plexit( "plD_bop_plm: fgetpos call failed" );
 
    // Seek back to previous page header.
 
    if ( dev->lp_offset > 0 )
    {
        FPOS_T fwbyte_offset = 0;
 
        pldebug( "UpdatePrevPagehdr 1 (plmeta.c)",
            "Location: %d, seeking to: %d\n",
            (int) cp_offset, (int) dev->lp_offset );
 
        // The forward byte offset is located exactly 7 bytes after the BOP
        fwbyte_offset = dev->lp_offset + 7;
        if ( pl_fsetpos( file, &fwbyte_offset ) )
        {
            handle_fsetpos_failed( "UpdatePrevPagehdr",
                "fwbyte_offset", fwbyte_offset );
        }
 
        // DEBUG: verify current location
 
#ifdef DEBUG
        if ( pl_fgetpos( file, &fwbyte_offset ) )
            plexit( "UpdatePrevPagehdr (plmeta.c): fgetpos call failed" );
 
        pldebug( "UpdatePrevPagehdr 2 (plmeta.c)",
            "Now at: %d, to write: %d\n",
            (int) fwbyte_offset, (int) cp_offset );
#endif
 
        // Write forward byte offset into previous page header.
 
        plm_wr( pdf_wr_4bytes( pls->pdfs, (U_LONG) cp_offset ) );
        fflush( file );
 
        // DEBUG: move back to before the write & read it to verify
 
#ifdef DEBUG
        if ( pl_fsetpos( file, &fwbyte_offset ) )
        {
            handle_fsetpos_failed( "UpdatePrevPagehdr",
                "fwbyte_offset", fwbyte_offset );
        }
        {
            U_LONG read_offset;
            plm_rd( pdf_rd_4bytes( pls->pdfs, &read_offset ) );
            pldebug( "UpdatePrevPagehdr 3 (plmeta.c)",
                "Value read as: %d\n", read_offset );
        }
#endif
 
        // Return to current page offset
 
        if ( pl_fsetpos( file, &cp_offset ) )
        {
            handle_fsetpos_failed( "UpdatePrevPagehdr",
                "cp_offset", cp_offset );
        }
    }
}
 
//--------------------------------------------------------------------------
// UpdateIndex()
//
// Update file index.
//--------------------------------------------------------------------------
 
static void
UpdateIndex( PLStream *pls, FPOS_T cp_offset )
{
    PLmDev *dev  = (PLmDev *) pls->dev;
    FILE   *file = pls->OutFile;
 
    // Update file index.  Right now only number of pages.
    // The ordering here is critical
 
    if ( dev->index_offset > 0 )
    {
        pldebug( "UpdateIndex (plmeta.c)",
            "Location: %d, seeking to: %d\n",
            (int) cp_offset, (int) dev->lp_offset );
 
        if ( pl_fsetpos( file, &dev->index_offset ) )
        {
            handle_fsetpos_failed( "UpdateIndex",
                "index_offset", dev->index_offset );
        }
        plm_wr( pdf_wr_header( pls->pdfs, "pages" ) );
        plm_wr( pdf_wr_2bytes( pls->pdfs, (U_SHORT) pls->page ) );
 
        pldebug( "UpdateIndex (plmeta.c)",
            "Location: %d, seeking to: %d\n",
            (int) dev->lp_offset, (int) cp_offset );
 
        if ( pl_fsetpos( file, &cp_offset ) )
        {
            handle_fsetpos_failed( "UpdateIndex",
                "cp_offset", cp_offset );
        }
    }
}
 
#else
int
pldummy_plmeta()
{
    return 0;
}
 
#endif                          // PLD_plmeta