source: trunk/kitgen/8.x/blt/generic/bltGrPs.c@ 199

/*
 * bltGrPs.c --
 *
 *      This module implements the "postscript" operation for BLT
 *      graph widget.
 *
 * Copyright 1991-1998 Lucent Technologies, Inc.
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation for any purpose and without fee is hereby
 * granted, provided that the above copyright notice appear in all
 * copies and that both that the copyright notice and warranty
 * disclaimer appear in supporting documentation, and that the names
 * of Lucent Technologies any of their entities not be used in
 * advertising or publicity pertaining to distribution of the software
 * without specific, written prior permission.
 *
 * Lucent Technologies disclaims all warranties with regard to this
 * software, including all implied warranties of merchantability and
 * fitness.  In no event shall Lucent Technologies be liable for any
 * special, indirect or consequential damages or any damages
 * whatsoever resulting from loss of use, data or profits, whether in
 * an action of contract, negligence or other tortuous action, arising
 * out of or in connection with the use or performance of this
 * software.  
 */

/*
 * -----------------------------------------------------------------
 *
 * PostScript routines to print a graph
 *
 * -----------------------------------------------------------------
 */
#include "bltGraph.h"
#include <X11/Xutil.h>
#if defined(__STDC__)
#include <stdarg.h>
#else
#include <varargs.h>
#endif

#define PS_PREVIEW_EPSI 0
#define PS_PREVIEW_WMF  1
#define PS_PREVIEW_TIFF 2

static Tk_OptionParseProc StringToColorMode;
static Tk_OptionPrintProc ColorModeToString;
static Tk_CustomOption colorModeOption =
{
    StringToColorMode, ColorModeToString, (ClientData)0,
};
static Tk_OptionParseProc StringToFormat;
static Tk_OptionPrintProc FormatToString;
static Tk_CustomOption formatOption =
{
    StringToFormat, FormatToString, (ClientData)0,
};
extern Tk_CustomOption bltDistanceOption;
extern Tk_CustomOption bltPositiveDistanceOption;
extern Tk_CustomOption bltPadOption;

#define DEF_PS_CENTER           "yes"
#define DEF_PS_COLOR_MAP        (char *)NULL
#define DEF_PS_COLOR_MODE       "color"
#define DEF_PS_DECORATIONS      "yes"
#define DEF_PS_FONT_MAP         (char *)NULL
#define DEF_PS_FOOTER           "no"
#define DEF_PS_HEIGHT           "0"
#define DEF_PS_LANDSCAPE        "no"
#define DEF_PS_MAXPECT          "no"
#define DEF_PS_PADX             "1.0i"
#define DEF_PS_PADY             "1.0i"
#define DEF_PS_PAPERHEIGHT      "11.0i"
#define DEF_PS_PAPERWIDTH       "8.5i"
#define DEF_PS_PREVIEW          "no"
#define DEF_PS_PREVIEW_FORMAT   "epsi"
#define DEF_PS_WIDTH            "0"

static Tk_ConfigSpec configSpecs[] =
{
    {TK_CONFIG_BOOLEAN, "-center", "center", "Center",
        DEF_PS_CENTER, Tk_Offset(PostScript, center),
        TK_CONFIG_DONT_SET_DEFAULT},
    {TK_CONFIG_STRING, "-colormap", "colorMap", "ColorMap",
        DEF_PS_COLOR_MAP, Tk_Offset(PostScript, colorVarName),
        TK_CONFIG_NULL_OK},
    {TK_CONFIG_CUSTOM, "-colormode", "colorMode", "ColorMode",
        DEF_PS_COLOR_MODE, Tk_Offset(PostScript, colorMode),
        TK_CONFIG_DONT_SET_DEFAULT, &colorModeOption},
    {TK_CONFIG_BOOLEAN, "-decorations", "decorations", "Decorations",
        DEF_PS_DECORATIONS, Tk_Offset(PostScript, decorations),
        TK_CONFIG_DONT_SET_DEFAULT},
    {TK_CONFIG_STRING, "-fontmap", "fontMap", "FontMap",
        DEF_PS_FONT_MAP, Tk_Offset(PostScript, fontVarName),
        TK_CONFIG_NULL_OK},
    {TK_CONFIG_BOOLEAN, "-footer", "footer", "Footer",
        DEF_PS_FOOTER, Tk_Offset(PostScript, footer),
        TK_CONFIG_DONT_SET_DEFAULT},
    {TK_CONFIG_CUSTOM, "-height", "height", "Height",
        DEF_PS_HEIGHT, Tk_Offset(PostScript, reqHeight),
        TK_CONFIG_DONT_SET_DEFAULT, &bltDistanceOption},
    {TK_CONFIG_BOOLEAN, "-landscape", "landscape", "Landscape",
        DEF_PS_LANDSCAPE, Tk_Offset(PostScript, landscape),
        TK_CONFIG_DONT_SET_DEFAULT},
    {TK_CONFIG_BOOLEAN, "-maxpect", "maxpect", "Maxpect",
        DEF_PS_MAXPECT, Tk_Offset(PostScript, maxpect),
        TK_CONFIG_DONT_SET_DEFAULT},
    {TK_CONFIG_CUSTOM, "-padx", "padX", "PadX",
        DEF_PS_PADX, Tk_Offset(PostScript, padX), 0, &bltPadOption},
    {TK_CONFIG_CUSTOM, "-pady", "padY", "PadY",
        DEF_PS_PADY, Tk_Offset(PostScript, padY), 0, &bltPadOption},
    {TK_CONFIG_CUSTOM, "-paperheight", "paperHeight", "PaperHeight",
        DEF_PS_PAPERHEIGHT, Tk_Offset(PostScript, reqPaperHeight),
        0, &bltPositiveDistanceOption},
    {TK_CONFIG_CUSTOM, "-paperwidth", "paperWidth", "PaperWidth",
        DEF_PS_PAPERWIDTH, Tk_Offset(PostScript, reqPaperWidth),
        0, &bltPositiveDistanceOption},
    {TK_CONFIG_BOOLEAN, "-preview", "preview", "Preview",
        DEF_PS_PREVIEW, Tk_Offset(PostScript, addPreview),
        TK_CONFIG_DONT_SET_DEFAULT},
    {TK_CONFIG_CUSTOM, "-previewformat", "previewFormat", "PreviewFormat",
        DEF_PS_PREVIEW_FORMAT, Tk_Offset(PostScript, previewFormat), 
        TK_CONFIG_DONT_SET_DEFAULT, &formatOption},
    {TK_CONFIG_CUSTOM, "-width", "width", "Width",
        DEF_PS_WIDTH, Tk_Offset(PostScript, reqWidth),
        TK_CONFIG_DONT_SET_DEFAULT, &bltDistanceOption},
    {TK_CONFIG_END, NULL, NULL, NULL, NULL, 0, 0}
};

extern void Blt_MarkersToPostScript _ANSI_ARGS_((Graph *graphPtr, 
        PsToken psToken, int under));
extern void Blt_ElementsToPostScript _ANSI_ARGS_((Graph *graphPtr, 
        PsToken psToken));
extern void Blt_ActiveElementsToPostScript _ANSI_ARGS_((Graph *graphPtr,
        PsToken psToken));
extern void Blt_LegendToPostScript _ANSI_ARGS_((Legend *legendPtr, 
        PsToken psToken));
extern void Blt_GridToPostScript _ANSI_ARGS_((Graph *graphPtr, 
        PsToken psToken));
extern void Blt_AxesToPostScript _ANSI_ARGS_((Graph *graphPtr, 
        PsToken psToken));
extern void Blt_AxisLimitsToPostScript _ANSI_ARGS_((Graph *graphPtr,
        PsToken psToken));
/*
 *----------------------------------------------------------------------
 *
 * StringToColorMode --
 *
 *      Convert the string representation of a PostScript color mode
 *      into the enumerated type representing the color level:
 *
 *          PS_MODE_COLOR       - Full color
 *          PS_MODE_GREYSCALE   - Color converted to greyscale
 *          PS_MODE_MONOCHROME  - Only black and white
 *
 * Results:
 *      A standard Tcl result.  The color level is written into the
 *      page layout information structure.
 *
 * Side Effects:
 *      Future invocations of the "postscript" option will use this
 *      variable to determine how color information will be displayed
 *      in the PostScript output it produces.
 *
 *----------------------------------------------------------------------
 */
/*ARGSUSED*/
static int
StringToColorMode(clientData, interp, tkwin, string, widgRec, offset)
    ClientData clientData;      /* Not used. */
    Tcl_Interp *interp;         /* Interpreter to send results back to */
    Tk_Window tkwin;            /* Not used. */
    char *string;               /* New value. */
    char *widgRec;              /* Widget record */
    int offset;                 /* Offset of field in record */
{
    PsColorMode *modePtr = (PsColorMode *) (widgRec + offset);
    unsigned int length;
    char c;

    c = string[0];
    length = strlen(string);
    if ((c == 'c') && (strncmp(string, "color", length) == 0)) {
        *modePtr = PS_MODE_COLOR;
    } else if ((c == 'g') && (strncmp(string, "grayscale", length) == 0)) {
        *modePtr = PS_MODE_GREYSCALE;
    } else if ((c == 'g') && (strncmp(string, "greyscale", length) == 0)) {
        *modePtr = PS_MODE_GREYSCALE;
    } else if ((c == 'm') && (strncmp(string, "monochrome", length) == 0)) {
        *modePtr = PS_MODE_MONOCHROME;
    } else {
        Tcl_AppendResult(interp, "bad color mode \"", string, "\": should be \
\"color\", \"greyscale\", or \"monochrome\"", (char *)NULL);
        return TCL_ERROR;
    }
    return TCL_OK;
}

/*
 *----------------------------------------------------------------------
 *
 * NameOfColorMode --
 *
 *      Convert the PostScript mode value into the string representing
 *      a valid color mode.
 *
 * Results:
 *      The static string representing the color mode is returned.
 *
 *----------------------------------------------------------------------
 */
static char *
NameOfColorMode(colorMode)
    PsColorMode colorMode;
{
    switch (colorMode) {
    case PS_MODE_COLOR:
        return "color";
    case PS_MODE_GREYSCALE:
        return "greyscale";
    case PS_MODE_MONOCHROME:
        return "monochrome";
    default:
        return "unknown color mode";
    }
}

/*
 *----------------------------------------------------------------------
 *
 * ColorModeToString --
 *
 *      Convert the current color mode into the string representing a
 *      valid color mode.
 *
 * Results:
 *      The string representing the color mode is returned.
 *
 *----------------------------------------------------------------------
 */
/*ARGSUSED*/
static char *
ColorModeToString(clientData, tkwin, widgRec, offset, freeProcPtr)
    ClientData clientData;      /* Not used. */
    Tk_Window tkwin;            /* Not used. */
    char *widgRec;              /* Widget record. */
    int offset;                 /* field of colorMode in record */
    Tcl_FreeProc **freeProcPtr; /* Not used. */
{
    PsColorMode mode = *(PsColorMode *) (widgRec + offset);

    return NameOfColorMode(mode);
}

/*
 *----------------------------------------------------------------------
 *
 * StringToFormat --
 *
 *      Convert the string of the PostScript preview format into 
 *      an enumerated type representing the desired format.  The
 *      available formats are:
 *
 *          PS_PREVIEW_WMF      - Windows Metafile.
 *          PS_PREVIEW_TIFF     - TIFF bitmap image.
 *          PS_PREVIEW_EPSI     - Device independent ASCII preview
 *
 * Results:
 *      A standard Tcl result.  The format is written into the
 *      page layout information structure.
 *
 * Side Effects:
 *      Future invocations of the "postscript" option will use this
 *      variable to determine how to format a preview image (if one
 *      is selected) when the PostScript output is produced.
 *
 *----------------------------------------------------------------------
 */
/*ARGSUSED*/
static int
StringToFormat(clientData, interp, tkwin, string, widgRec, offset)
    ClientData clientData;      /* Not used. */
    Tcl_Interp *interp;         /* Interpreter to send results back to */
    Tk_Window tkwin;            /* Not used. */
    char *string;               /* New value. */
    char *widgRec;              /* Widget record */
    int offset;                 /* Offset of field in record */
{
    int *formatPtr = (int *) (widgRec + offset);
    unsigned int length;
    char c;

    c = string[0];
    length = strlen(string);
    if ((c == 'c') && (strncmp(string, "epsi", length) == 0)) {
        *formatPtr = PS_PREVIEW_EPSI;
#ifdef WIN32
#ifdef HAVE_TIFF_H
    } else if ((c == 't') && (strncmp(string, "tiff", length) == 0)) {
        *formatPtr = PS_PREVIEW_TIFF;
#endif /* HAVE_TIFF_H */
    } else if ((c == 'w') && (strncmp(string, "wmf", length) == 0)) {
        *formatPtr = PS_PREVIEW_WMF;
#endif /* WIN32 */
    } else {
        Tcl_AppendResult(interp, "bad format \"", string, "\": should be ",
#ifdef WIN32
#ifdef HAVE_TIFF_H
                         "\"tiff\" or ",
#endif /* HAVE_TIFF_H */
                         "\"wmf\" or ",
#endif /* WIN32 */
                         "\"epsi\"", (char *)NULL);
        return TCL_ERROR;
    }
    return TCL_OK;
}

/*
 *----------------------------------------------------------------------
 *
 * FormatToString --
 *
 *      Convert the preview format into the string representing its
 *      type.
 *
 * Results:
 *      The string representing the preview format is returned.
 *
 *----------------------------------------------------------------------
 */
/*ARGSUSED*/
static char *
FormatToString(clientData, tkwin, widgRec, offset, freeProcPtr)
    ClientData clientData;      /* Not used. */
    Tk_Window tkwin;            /* Not used. */
    char *widgRec;              /* PostScript structure record */
    int offset;                 /* field of colorMode in record */
    Tcl_FreeProc **freeProcPtr; /* Not used. */
{
    int format = *(int *)(widgRec + offset);

    switch (format) {
    case PS_PREVIEW_EPSI:
        return "epsi";
    case PS_PREVIEW_WMF:
        return "wmf";
    case PS_PREVIEW_TIFF:
        return "tiff";
    }
    return "?unknown preview format?";
}


void
Blt_DestroyPostScript(graphPtr)
    Graph *graphPtr;
{
    Tk_FreeOptions(configSpecs, (char *)graphPtr->postscript, 
           graphPtr->display, 0);
    Blt_Free(graphPtr->postscript);
}

/*
 *----------------------------------------------------------------------
 *
 * CgetOp --
 *
 *----------------------------------------------------------------------
 */
/*ARGSUSED*/
static int
CgetOp(graphPtr, interp, argc, argv)
    Graph *graphPtr;
    Tcl_Interp *interp;
    int argc;
    char *argv[];
{
    PostScript *psPtr = (PostScript *)graphPtr->postscript;

    if (Tk_ConfigureValue(interp, graphPtr->tkwin, configSpecs, (char *)psPtr,
            argv[3], 0) != TCL_OK) {
        return TCL_ERROR;
    }
    return TCL_OK;
}

/*
 * ----------------------------------------------------------------------
 *
 * ConfigureOp --
 *
 *      This procedure is invoked to print the graph in a file.
 *
 * Results:
 *      A standard TCL result.
 *
 * Side effects:
 *      A new PostScript file is created.
 *
 * ----------------------------------------------------------------------
 */
static int
ConfigureOp(graphPtr, interp, argc, argv)
    Graph *graphPtr;
    Tcl_Interp *interp;
    int argc;                   /* Number of options in argv vector */
    char **argv;                /* Option vector */
{
    int flags = TK_CONFIG_ARGV_ONLY;
    PostScript *psPtr = (PostScript *)graphPtr->postscript;

    if (argc == 3) {
        return Tk_ConfigureInfo(interp, graphPtr->tkwin, configSpecs,
                (char *)psPtr, (char *)NULL, flags);
    } else if (argc == 4) {
        return Tk_ConfigureInfo(interp, graphPtr->tkwin, configSpecs,
                (char *)psPtr, argv[3], flags);
    }
    if (Tk_ConfigureWidget(interp, graphPtr->tkwin, configSpecs, argc - 3,
            argv + 3, (char *)psPtr, flags) != TCL_OK) {
        return TCL_ERROR;
    }
    return TCL_OK;
}

/*
 * --------------------------------------------------------------------------
 *
 * ComputeBoundingBox --
 *
 *      Computes the bounding box for the PostScript plot.  First get
 *      the size of the plot (by default, it's the size of graph's X
 *      window).  If the plot plus the page border is bigger than the
 *      designated paper size, or if the "-maxpect" option is turned
 *      on, scale the plot to the page.
 *
 *      Note: All coordinates/sizes are in screen coordinates, not
 *            PostScript coordinates.  This includes the computed
 *            bounding box and paper size.  They will be scaled to
 *            printer points later.
 *
 * Results:
 *      Returns the height of the paper in screen coordinates.
 *
 * Side Effects:
 *      The graph dimensions (width and height) are changed to the
 *      requested PostScript plot size.
 *
 * --------------------------------------------------------------------------
 */
static int
ComputeBoundingBox(graphPtr, psPtr)
    Graph *graphPtr;
    PostScript *psPtr;
{
    int paperWidth, paperHeight;
    int x, y, hSize, vSize, hBorder, vBorder;
    double hScale, vScale, scale;

    x = psPtr->padLeft;
    y = psPtr->padTop;
    hBorder = PADDING(psPtr->padX);
    vBorder = PADDING(psPtr->padY);

    if (psPtr->reqWidth > 0) {
        graphPtr->width = psPtr->reqWidth;
    }
    if (psPtr->reqHeight > 0) {
        graphPtr->height = psPtr->reqHeight;
    }
    if (psPtr->landscape) {
        hSize = graphPtr->height;
        vSize = graphPtr->width;
    } else {
        hSize = graphPtr->width;
        vSize = graphPtr->height;
    }
    /*
     * If the paper size wasn't specified, set it to the graph size plus
     * the paper border.
     */
    paperWidth = psPtr->reqPaperWidth;
    paperHeight = psPtr->reqPaperHeight;
    if (paperWidth < 1) {
        paperWidth = hSize + hBorder;
    }
    if (paperHeight < 1) {
        paperHeight = vSize + vBorder;
    }
    hScale = vScale = 1.0;
    /*
     * Scale the plot size (the graph itself doesn't change size) if
     * it's bigger than the paper or if -maxpect was set.
     */
    if ((psPtr->maxpect) || ((hSize + hBorder) > paperWidth)) {
        hScale = (double)(paperWidth - hBorder) / (double)hSize;
    }
    if ((psPtr->maxpect) || ((vSize + vBorder) > paperHeight)) {
        vScale = (double)(paperHeight - vBorder) / (double)vSize;
    }
    scale = MIN(hScale, vScale);
    if (scale != 1.0) {
        hSize = (int)((hSize * scale) + 0.5);
        vSize = (int)((vSize * scale) + 0.5);
    }
    psPtr->pageScale = scale;
    if (psPtr->center) {
        if (paperWidth > hSize) {
            x = (paperWidth - hSize) / 2;
        }
        if (paperHeight > vSize) {
            y = (paperHeight - vSize) / 2;
        }
    }
    psPtr->left = x;
    psPtr->bottom = y;
    psPtr->right = x + hSize - 1;
    psPtr->top = y + vSize - 1;

    graphPtr->flags |= LAYOUT_NEEDED | MAP_WORLD;
    Blt_LayoutGraph(graphPtr);
    return paperHeight;
}

/*
 * --------------------------------------------------------------------------
 *
 * PreviewImage --
 *
 *      Generates a EPSI thumbnail of the graph.  The thumbnail is
 *      restricted to a certain size.  This is to keep the size of the
 *      PostScript file small and the processing time low.
 *
 *      The graph is drawn into a pixmap.  We then take a snapshot
 *      of that pixmap, and rescale it to a smaller image.  Finally,
 *      the image is dumped to PostScript.
 *
 * Results:
 *      None.
 *
 * --------------------------------------------------------------------------
 */
static void
PreviewImage(graphPtr, psToken)
    Graph *graphPtr;
    PsToken psToken;
{
    PostScript *psPtr = (PostScript *)graphPtr->postscript;
    int noBackingStore = 0;
    Pixmap drawable;
    Blt_ColorImage image;
    int nLines;
    Tcl_DString dString;

    /* Create a pixmap and draw the graph into it. */

    drawable = Tk_GetPixmap(graphPtr->display, Tk_WindowId(graphPtr->tkwin),
        graphPtr->width, graphPtr->height, Tk_Depth(graphPtr->tkwin));
    Blt_DrawGraph(graphPtr, drawable, noBackingStore);
    
    /* Get a color image from the pixmap */
    image = Blt_DrawableToColorImage(graphPtr->tkwin, drawable, 0, 0, 
        graphPtr->width, graphPtr->height, 1.0);
    Tk_FreePixmap(graphPtr->display, drawable);
    if (image == NULL) {
        return;                 /* Can't grab pixmap? */
    }
#ifdef THUMBNAIL_PREVIEW
    {
        double scale, xScale, yScale;
        int width, height;
        Blt_ColorImage destImage;

        /* Scale the source image into a size appropriate for a thumbnail. */
#define PS_MAX_PREVIEW_WIDTH    300.0
#define PS_MAX_PREVIEW_HEIGHT   300.0
        xScale = PS_MAX_PREVIEW_WIDTH / (double)graphPtr->width;
        yScale = PS_MAX_PREVIEW_HEIGHT / (double)graphPtr->height;
        scale = MIN(xScale, yScale);

        width = (int)(scale * graphPtr->width + 0.5);
        height = (int)(scale * graphPtr->height + 0.5);
        destImage = Blt_ResampleColorImage(image, width, height, 
                bltBoxFilterPtr, bltBoxFilterPtr);
        Blt_FreeColorImage(image);
        image = destImage;
    }
#endif /* THUMBNAIL_PREVIEW */
    Blt_ColorImageToGreyscale(image);
    if (psPtr->landscape) {
        Blt_ColorImage oldImage;

        oldImage = image;
        image = Blt_RotateColorImage(image, 90.0);
        Blt_FreeColorImage(oldImage);
    }
    Tcl_DStringInit(&dString);
    /* Finally, we can generate PostScript for the image */
    nLines = Blt_ColorImageToPsData(image, 1, &dString, "%");

    Blt_AppendToPostScript(psToken, "%%BeginPreview: ", (char *)NULL);
    Blt_FormatToPostScript(psToken, "%d %d 8 %d\n", Blt_ColorImageWidth(image),
        Blt_ColorImageHeight(image), nLines);
    Blt_AppendToPostScript(psToken, Tcl_DStringValue(&dString), (char *)NULL);
    Blt_AppendToPostScript(psToken, "%%EndPreview\n\n", (char *)NULL);
    Tcl_DStringFree(&dString);
    Blt_FreeColorImage(image);
}

/*
 * --------------------------------------------------------------------------
 *
 * PostScriptPreamble
 *
 *      The PostScript preamble calculates the needed translation and scaling
 *      to make X11 coordinates compatible with PostScript.
 *
 * ---------------------------------------------------------------------
 */

#ifdef TIME_WITH_SYS_TIME
#include <sys/time.h>
#include <time.h>
#else
#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
#else
#include <time.h>
#endif /* HAVE_SYS_TIME_H */
#endif /* TIME_WITH_SYS_TIME */

static int
PostScriptPreamble(graphPtr, fileName, psToken)
    Graph *graphPtr;
    char *fileName;
    PsToken psToken;
{
    PostScript *psPtr = (PostScript *)graphPtr->postscript;
    time_t ticks;
    char date[200];             /* Hold the date string from ctime() */
    CONST char *version;
    double dpiX, dpiY;
    double xPixelsToPica, yPixelsToPica; /* Scales to convert pixels to pica */
    Screen *screenPtr;
    char *nl;
    int paperHeightPixels;

    paperHeightPixels = ComputeBoundingBox(graphPtr, psPtr);
    if (fileName == NULL) {
        fileName = Tk_PathName(graphPtr->tkwin);
    }
    Blt_AppendToPostScript(psToken, "%!PS-Adobe-3.0 EPSF-3.0\n", 
                           (char *)NULL);

    /*
     * Compute the scale factors to convert PostScript to X11 coordinates.
     * Round the pixels per inch (dpi) to an integral value before computing
     * the scale.
     */
#define MM_INCH         25.4
#define PICA_INCH       72.0
    screenPtr = Tk_Screen(graphPtr->tkwin);
    dpiX = (WidthOfScreen(screenPtr) * MM_INCH) / WidthMMOfScreen(screenPtr);
    xPixelsToPica = PICA_INCH / dpiX;
    dpiY = (HeightOfScreen(screenPtr) * MM_INCH) / HeightMMOfScreen(screenPtr);
    yPixelsToPica = PICA_INCH / dpiY;

    /*
     * The "BoundingBox" comment is required for EPS files. The box
     * coordinates are integers, so we need round away from the
     * center of the box.
     */
    Blt_FormatToPostScript(psToken, "%%%%BoundingBox: %d %d %d %d\n",
        (int)floor(psPtr->left * xPixelsToPica),
        (int)floor((paperHeightPixels - psPtr->top) * yPixelsToPica),
        (int)ceil(psPtr->right * xPixelsToPica),
        (int)ceil((paperHeightPixels - psPtr->bottom) * yPixelsToPica));

    Blt_AppendToPostScript(psToken, "%%Pages: 0\n", (char *)NULL);

    version = Tcl_GetVar(graphPtr->interp, "blt_version", TCL_GLOBAL_ONLY);
    if (version == NULL) {
        version = "???";
    }
    Blt_FormatToPostScript(psToken, "%%%%Creator: (BLT %s %s)\n", version,
        Tk_Class(graphPtr->tkwin));

    ticks = time((time_t *) NULL);
    strcpy(date, ctime(&ticks));
    nl = date + strlen(date) - 1;
    if (*nl == '\n') {
        *nl = '\0';
    }
    Blt_FormatToPostScript(psToken, "%%%%CreationDate: (%s)\n", date);
    Blt_FormatToPostScript(psToken, "%%%%Title: (%s)\n", fileName);
    Blt_AppendToPostScript(psToken, "%%DocumentData: Clean7Bit\n", 
                           (char *)NULL);
    if (psPtr->landscape) {
        Blt_AppendToPostScript(psToken, "%%Orientation: Landscape\n", 
                               (char *)NULL);
    } else {
        Blt_AppendToPostScript(psToken, "%%Orientation: Portrait\n", 
                               (char *)NULL);
    }
    Blt_AppendToPostScript(psToken,
        "%%DocumentNeededResources: font Helvetica Courier\n", (char *)NULL);
    Blt_AppendToPostScript(psToken, "%%EndComments\n\n", (char *)NULL);
    if ((psPtr->addPreview) && (psPtr->previewFormat == PS_PREVIEW_EPSI)) {
        PreviewImage(graphPtr, psToken);
    }
    if (Blt_FileToPostScript(psToken, "bltGraph.pro") != TCL_OK) {
        return TCL_ERROR;
    }
    if (psPtr->footer) {
        char *who;

        who = getenv("LOGNAME");
        if (who == NULL) {
            who = "???";
        }
        Blt_AppendToPostScript(psToken,
            "8 /Helvetica SetFont\n",
            "10 30 moveto\n",
            "(Date: ", date, ") show\n",
            "10 20 moveto\n",
            "(File: ", fileName, ") show\n",
            "10 10 moveto\n",
            "(Created by: ", who, "@", Tcl_GetHostName(), ") show\n",
            "0 0 moveto\n",
            (char *)NULL);
    }
    /*
     * Set the conversion from PostScript to X11 coordinates.  Scale
     * pica to pixels and flip the y-axis (the origin is the upperleft
     * corner).
     */
    Blt_AppendToPostScript(psToken,
        "% Transform coordinate system to use X11 coordinates\n\n",
        "% 1. Flip y-axis over by reversing the scale,\n",
        "% 2. Translate the origin to the other side of the page,\n",
        "%    making the origin the upper left corner\n", (char *)NULL);
    Blt_FormatToPostScript(psToken, "%g -%g scale\n", xPixelsToPica, 
        yPixelsToPica);
    /* Papersize is in pixels.  Translate the new origin *after*
     * changing the scale. */
    Blt_FormatToPostScript(psToken, "0 %d translate\n\n", 
        -paperHeightPixels);
    Blt_AppendToPostScript(psToken, "% User defined page layout\n\n",
        "% Set color level\n", (char *)NULL);
    Blt_FormatToPostScript(psToken, "/CL %d def\n\n", psPtr->colorMode);
    Blt_FormatToPostScript(psToken, "%% Set origin\n%d %d translate\n\n",
        psPtr->left, psPtr->bottom);
    if (psPtr->landscape) {
        Blt_FormatToPostScript(psToken,
            "%% Landscape orientation\n0 %g translate\n-90 rotate\n",
            ((double)graphPtr->width * psPtr->pageScale));
    }
    if (psPtr->pageScale != 1.0) {
        Blt_AppendToPostScript(psToken, "\n% Setting graph scale factor\n",
            (char *)NULL);
        Blt_FormatToPostScript(psToken, " %g %g scale\n", psPtr->pageScale,
            psPtr->pageScale);
    }
    Blt_AppendToPostScript(psToken, "\n%%EndSetup\n\n", (char *)NULL);
    return TCL_OK;
}


static void
MarginsToPostScript(graphPtr, psToken)
    Graph *graphPtr;
    PsToken psToken;
{
    PostScript *psPtr = (PostScript *)graphPtr->postscript;
    XRectangle margin[4];

    margin[0].x = margin[0].y = margin[3].x = margin[1].x = 0;
    margin[0].width = margin[3].width = graphPtr->width;
    margin[0].height = graphPtr->top;
    margin[3].y = graphPtr->bottom;
    margin[3].height = graphPtr->height - graphPtr->bottom;
    margin[2].y = margin[1].y = graphPtr->top;
    margin[1].width = graphPtr->left;
    margin[2].height = margin[1].height = graphPtr->bottom - graphPtr->top;
    margin[2].x = graphPtr->right;
    margin[2].width = graphPtr->width - graphPtr->right;

    /* Clear the surrounding margins and clip the plotting surface */
    if (psPtr->decorations) {
        Blt_BackgroundToPostScript(psToken,
            Tk_3DBorderColor(graphPtr->border));
    } else {
        Blt_ClearBackgroundToPostScript(psToken);
    }
    Blt_RectanglesToPostScript(psToken, margin, 4);
    
    /* Interior 3D border */
    if ((psPtr->decorations) && (graphPtr->plotBorderWidth > 0)) {
        int x, y, width, height;

        x = graphPtr->left - graphPtr->plotBorderWidth;
        y = graphPtr->top - graphPtr->plotBorderWidth;
        width = (graphPtr->right - graphPtr->left) + 
            (2 * graphPtr->plotBorderWidth);
        height = (graphPtr->bottom - graphPtr->top) + 
            (2 * graphPtr->plotBorderWidth);
        Blt_Draw3DRectangleToPostScript(psToken, graphPtr->border, 
           (double)x, (double)y, width, height, graphPtr->plotBorderWidth, 
           graphPtr->plotRelief);
    }
    if (Blt_LegendSite(graphPtr->legend) & LEGEND_IN_MARGIN) {
        /*
         * Print the legend if we're using a site which lies in one
         * of the margins (left, right, top, or bottom) of the graph.
         */
        Blt_LegendToPostScript(graphPtr->legend, psToken);
    }
    if (graphPtr->title != NULL) {
        Blt_TextToPostScript(psToken, graphPtr->title, 
                &graphPtr->titleTextStyle, (double)graphPtr->titleX, 
                (double)graphPtr->titleY);
    }
    Blt_AxesToPostScript(graphPtr, psToken);
}


static int
GraphToPostScript(graphPtr, ident, psToken)
    Graph *graphPtr;
    char *ident;                /* Identifier string (usually the filename) */
    PsToken psToken;
{
    int x, y, width, height;
    int result;

    /*   
     * We need to know how big a graph to print.  If the graph hasn't
     * been drawn yet, the width and height will be 1.  Instead use
     * the requested size of the widget.  The user can still override
     * this with the -width and -height postscript options.  
     */
    if (graphPtr->height <= 1) {
        graphPtr->height = Tk_ReqHeight(graphPtr->tkwin);
    }
    if (graphPtr->width <= 1) {
        graphPtr->width = Tk_ReqWidth(graphPtr->tkwin);
    }
    result = PostScriptPreamble(graphPtr, ident, psToken);
    if (result != TCL_OK) {
        goto error;
    }
    /*
     * Determine rectangle of the plotting area for the graph window
     */
    x = graphPtr->left - graphPtr->plotBorderWidth;
    y = graphPtr->top - graphPtr->plotBorderWidth;

    width = (graphPtr->right - graphPtr->left + 1) + 
        (2 * graphPtr->plotBorderWidth);
    height = (graphPtr->bottom - graphPtr->top + 1) + 
        (2 * graphPtr->plotBorderWidth);

    Blt_FontToPostScript(psToken, graphPtr->titleTextStyle.font);
    Blt_RegionToPostScript(psToken, (double)x, (double)y, width, height);
    if (graphPtr->postscript->decorations) {
        Blt_BackgroundToPostScript(psToken, graphPtr->plotBg);
    } else {
        Blt_ClearBackgroundToPostScript(psToken);
    }
    Blt_AppendToPostScript(psToken, "Fill\n", (char *)NULL);
    Blt_AppendToPostScript(psToken, "gsave clip\n\n", (char *)NULL);
    /* Draw the grid, elements, and markers in the plotting area. */
    if (!graphPtr->gridPtr->hidden) {
        Blt_GridToPostScript(graphPtr, psToken);
    }
    Blt_MarkersToPostScript(graphPtr, psToken, TRUE);
    if ((Blt_LegendSite(graphPtr->legend) & LEGEND_IN_PLOT) && 
        (!Blt_LegendIsRaised(graphPtr->legend))) {
        /* Print legend underneath elements and markers */
        Blt_LegendToPostScript(graphPtr->legend, psToken);
    }
    Blt_AxisLimitsToPostScript(graphPtr, psToken);
    Blt_ElementsToPostScript(graphPtr, psToken);
    if ((Blt_LegendSite(graphPtr->legend) & LEGEND_IN_PLOT) && 
        (Blt_LegendIsRaised(graphPtr->legend))) {
        /* Print legend above elements (but not markers) */
        Blt_LegendToPostScript(graphPtr->legend, psToken);
    }
    Blt_MarkersToPostScript(graphPtr, psToken, FALSE);
    Blt_ActiveElementsToPostScript(graphPtr, psToken);
    Blt_AppendToPostScript(psToken, "\n",
        "% Unset clipping\n",
        "grestore\n\n", (char *)NULL);
    MarginsToPostScript(graphPtr, psToken);
    Blt_AppendToPostScript(psToken,
        "showpage\n",
        "%Trailer\n",
        "grestore\n",
        "end\n",
        "%EOF\n", (char *)NULL);
  error:
    /* Reset height and width of graph window */
    graphPtr->width = Tk_Width(graphPtr->tkwin);
    graphPtr->height = Tk_Height(graphPtr->tkwin);
    graphPtr->flags = MAP_WORLD;

    /*
     * Redraw the graph in order to re-calculate the layout as soon as
     * possible. This is in the case the crosshairs are active.
     */
    Blt_EventuallyRedrawGraph(graphPtr);
    return result;
}

#ifdef WIN32

static void
InitAPMHeader(
    Tk_Window tkwin,
    int width, int height,
    APMHEADER *headerPtr)
{
    unsigned int *p;
    unsigned int sum;
    Screen *screen;
#define MM_INCH         25.4
    double dpiX, dpiY;

    headerPtr->key = 0x9ac6cdd7L;
    headerPtr->hmf = 0;
    headerPtr->inch = 1440;

    screen = Tk_Screen(tkwin);
    dpiX = (WidthOfScreen(screen) * MM_INCH) / WidthMMOfScreen(screen);
    dpiY = (HeightOfScreen(screen) * MM_INCH) / HeightMMOfScreen(screen);

    headerPtr->bbox.Left = headerPtr->bbox.Top = 0;
    headerPtr->bbox.Bottom = (SHORT)((width * 1440) / dpiX);
    headerPtr->bbox.Right = (SHORT)((height * 1440) / dpiY);
    headerPtr->reserved = 0;
    sum = 0;
    for (p = (unsigned int *)headerPtr; 
         p < (unsigned int *)&(headerPtr->checksum); p++) {
        sum ^= *p;
    }
    headerPtr->checksum = sum;
}

/*
 * --------------------------------------------------------------------------
 *
 * CreateWindowEPS --
 *
 *      Generates an EPS file with a Window metafile preview.  
 *
 *      Windows metafiles aren't very robust.  Including exactly the
 *      same metafile (one embedded in a DOS EPS, the other as .wmf
 *      file) will play back differently.  
 *      
 * Results:
 *      None.
 *
 * -------------------------------------------------------------------------- 
 */
static int
CreateWindowsEPS(
    Graph *graphPtr,
    PsToken psToken,
    FILE *f)
{
    DWORD size;
    DOSEPSHEADER epsHeader;
    HANDLE hMem;
    HDC hRefDC, hDC;
    HENHMETAFILE hMetaFile;
    Tcl_DString dString;
    TkWinDC drawableDC;
    TkWinDCState state;
    int result;
    unsigned char *buffer, *psBuffer;
    
    Blt_AppendToPostScript(psToken, "\n", (char *)NULL);
    psBuffer = Blt_PostScriptFromToken(psToken);
    /*
     * Fill out as much information as we can into the DOS EPS header.
     * We won't know the start of the length of the WMF segment until 
     * we create the metafile.
     */
    epsHeader.magic[0] = 0xC5;
    epsHeader.magic[1] = 0xD0;
    epsHeader.magic[2] = 0xD3;
    epsHeader.magic[3] = 0xC6;
    epsHeader.psStart = sizeof(epsHeader); 
    epsHeader.psLength = strlen(psBuffer) + 1;
    epsHeader.wmfStart = epsHeader.psStart + epsHeader.psLength;
    epsHeader.wmfLength = 0L;   /* Fill in later. */
    epsHeader.tiffStart = 0L;   
    epsHeader.tiffLength = 0L;
    epsHeader.checksum = 0xFFFF;

    result = TCL_ERROR;
    hRefDC = TkWinGetDrawableDC(graphPtr->display, 
        Tk_WindowId(graphPtr->tkwin), &state);

    /* Build a description string. */
    Tcl_DStringInit(&dString);
    Tcl_DStringAppend(&dString, "BLT Graph ", -1);
    Tcl_DStringAppend(&dString, BLT_VERSION, -1);
    Tcl_DStringAppend(&dString, "\0", -1);
    Tcl_DStringAppend(&dString, Tk_PathName(graphPtr->tkwin), -1);
    Tcl_DStringAppend(&dString, "\0", -1);

    hDC = CreateEnhMetaFile(hRefDC, NULL, NULL, Tcl_DStringValue(&dString));
    Tcl_DStringFree(&dString);
    
    if (hDC == NULL) {
        Tcl_AppendResult(graphPtr->interp, "can't create metafile: ",   
                Blt_LastError(), (char *)NULL);
        return TCL_ERROR;
    }
    /* Assemble a Tk drawable that points to the metafile and let the
     * graph's drawing routine draw into it. */
    drawableDC.hdc = hDC;
    drawableDC.type = TWD_WINDC;
    
    graphPtr->width = Tk_Width(graphPtr->tkwin);
    graphPtr->height = Tk_Height(graphPtr->tkwin);
    graphPtr->flags |= RESET_WORLD;
    Blt_LayoutGraph(graphPtr);
    Blt_DrawGraph(graphPtr, (Drawable)&drawableDC, FALSE);
    GdiFlush();
    hMetaFile = CloseEnhMetaFile(hDC);

    size = GetWinMetaFileBits(hMetaFile, 0, NULL, MM_ANISOTROPIC, hRefDC);
    hMem = GlobalAlloc(GHND, size);
    if (hMem == NULL) {
        Tcl_AppendResult(graphPtr->interp, "can't allocate global memory:", 
                Blt_LastError(), (char *)NULL);
        goto error;
    }
    buffer = (LPVOID)GlobalLock(hMem);
    if (!GetWinMetaFileBits(hMetaFile, size, buffer, MM_ANISOTROPIC, hRefDC)) {
        Tcl_AppendResult(graphPtr->interp, "can't get metafile data:", 
                Blt_LastError(), (char *)NULL);
        goto error;
    }

    /*  
     * Fix up the EPS header with the correct metafile length and PS
     * offset (now that we what they are).
     */
    epsHeader.wmfLength = size;
    epsHeader.wmfStart = epsHeader.psStart + epsHeader.psLength;

    /* Write out the eps header, */
    if (fwrite(&epsHeader, 1, sizeof(epsHeader), f) != sizeof(epsHeader)) {
        Tcl_AppendResult(graphPtr->interp, "error writing eps header:", 
                Blt_LastError(), (char *)NULL);
        goto error;
    }
    /* the PostScript, */
    if (fwrite(psBuffer, 1, epsHeader.psLength, f) != epsHeader.psLength) {
        Tcl_AppendResult(graphPtr->interp, "error writing PostScript data:", 
                Blt_LastError(), (char *)NULL);
        goto error;
    }
    /* and finally the metadata itself. */
    if (fwrite(buffer, 1, size, f) != size) {
        Tcl_AppendResult(graphPtr->interp, "error writing metafile data:", 
                Blt_LastError(), (char *)NULL);
        goto error;
    }
    result = TCL_OK;

 error:
    DeleteEnhMetaFile(hMetaFile); 
    TkWinReleaseDrawableDC(Tk_WindowId(graphPtr->tkwin), hRefDC, &state);
    fclose(f);
    if (hMem != NULL) {
        GlobalUnlock(hMem);
        GlobalFree(hMem);
    }
    graphPtr->flags = MAP_WORLD;
    Blt_EventuallyRedrawGraph(graphPtr);
    return result;
}

#endif /*WIN32*/

/*
 *----------------------------------------------------------------------
 *
 * OutputOp --
 *
 *      This procedure is invoked to print the graph in a file.
 *
 * Results:
 *      Standard TCL result.  TCL_OK if plot was successfully printed,
 *      TCL_ERROR otherwise.
 *
 * Side effects:
 *      A new PostScript file is created.
 *
 *----------------------------------------------------------------------
 */
static int
OutputOp(graphPtr, interp, argc, argv)
    Graph *graphPtr;            /* Graph widget record */
    Tcl_Interp *interp;
    int argc;                   /* Number of options in argv vector */
    char **argv;                /* Option vector */
{
    PostScript *psPtr = (PostScript *)graphPtr->postscript;
    FILE *f = NULL;
    PsToken psToken;
    char *fileName;             /* Name of file to write PostScript output
                                 * If NULL, output is returned via
                                 * interp->result. */
    fileName = NULL;
    if (argc > 3) {
        if (argv[3][0] != '-') {
            fileName = argv[3]; /* First argument is the file name. */
            argv++, argc--;
        }
        if (Tk_ConfigureWidget(interp, graphPtr->tkwin, configSpecs, argc - 3,
                argv + 3, (char *)psPtr, TK_CONFIG_ARGV_ONLY) != TCL_OK) {
            return TCL_ERROR;
        }
        if (fileName != NULL) {
#ifdef WIN32
            f = fopen(fileName, "wb");
#else 
            f = fopen(fileName, "w");
#endif
            if (f == NULL) {
                Tcl_AppendResult(interp, "can't create \"", fileName, "\": ",
                    Tcl_PosixError(interp), (char *)NULL);
                return TCL_ERROR;
            }
        }
    }
    psToken = Blt_GetPsToken(graphPtr->interp, graphPtr->tkwin);
    psToken->fontVarName = psPtr->fontVarName;
    psToken->colorVarName = psPtr->colorVarName;
    psToken->colorMode = psPtr->colorMode;

    if (GraphToPostScript(graphPtr, fileName, psToken) != TCL_OK) {
        goto error;
    }
    /*
     * If a file name was given, write the results to that file
     */
    if (f != NULL) {
#ifdef WIN32
        if ((psPtr->addPreview) && (psPtr->previewFormat != PS_PREVIEW_EPSI)) {
            if (CreateWindowsEPS(graphPtr, psToken, f)) {
                return TCL_ERROR;
            }
        } else {            
            fputs(Blt_PostScriptFromToken(psToken), f);
            if (ferror(f)) {
                Tcl_AppendResult(interp, "error writing file \"", fileName, 
                        "\": ", Tcl_PosixError(interp), (char *)NULL);
                goto error;
            }
        }
#else 
        fputs(Blt_PostScriptFromToken(psToken), f);
        if (ferror(f)) {
            Tcl_AppendResult(interp, "error writing file \"", fileName, "\": ",
                Tcl_PosixError(interp), (char *)NULL);
            goto error;
        }
#endif /* WIN32 */
        fclose(f);
    } else {
        Tcl_SetResult(interp, Blt_PostScriptFromToken(psToken), TCL_VOLATILE);
    }
    Blt_ReleasePsToken(psToken);
    return TCL_OK;

  error:
    if (f != NULL) {
        fclose(f);
    }
    Blt_ReleasePsToken(psToken);
    return TCL_ERROR;
}

/*
 *----------------------------------------------------------------------
 *
 * Blt_CreatePostScript --
 *
 *      Creates a postscript structure.
 *
 * Results:
 *      Always TCL_OK.
 *
 * Side effects:
 *      A new PostScript structure is created.
 *
 *----------------------------------------------------------------------
 */
int
Blt_CreatePostScript(graphPtr)
    Graph *graphPtr;
{
    PostScript *psPtr;

    psPtr = Blt_Calloc(1, sizeof(PostScript));
    assert(psPtr);
    psPtr->colorMode = PS_MODE_COLOR;
    psPtr->center = TRUE;
    psPtr->decorations = TRUE;
    graphPtr->postscript = psPtr;

    if (Blt_ConfigureWidgetComponent(graphPtr->interp, graphPtr->tkwin,
            "postscript", "Postscript", configSpecs, 0, (char **)NULL,
            (char *)psPtr, 0) != TCL_OK) {
        return TCL_ERROR;
    }
    return TCL_OK;
}

/*
 *--------------------------------------------------------------
 *
 * Blt_PostScriptOp --
 *
 *      This procedure is invoked to process the Tcl command
 *      that corresponds to a widget managed by this module.
 *      See the user documentation for details on what it does.
 *
 * Results:
 *      A standard Tcl result.
 *
 * Side effects:
 *      See the user documentation.
 *
 *--------------------------------------------------------------
 */
static Blt_OpSpec psOps[] =
{
    {"cget", 2, (Blt_Op)CgetOp, 4, 4, "option",},
    {"configure", 2, (Blt_Op)ConfigureOp, 3, 0, "?option value?...",},
    {"output", 1, (Blt_Op)OutputOp, 3, 0,
        "?fileName? ?option value?...",},
};

static int nPsOps = sizeof(psOps) / sizeof(Blt_OpSpec);

int
Blt_PostScriptOp(graphPtr, interp, argc, argv)
    Graph *graphPtr;            /* Graph widget record */
    Tcl_Interp *interp;
    int argc;                   /* # arguments */
    char **argv;                /* Argument list */
{
    Blt_Op proc;
    int result;

    proc = Blt_GetOp(interp, nPsOps, psOps, BLT_OP_ARG2, argc, argv, 0);
    if (proc == NULL) {
        return TCL_ERROR;
    }
    result = (*proc) (graphPtr, interp, argc, argv);
    return result;
}