Imported nx-X11-3.1.0-1.tar.gznx-X11/3.1.0-1

Summary: Imported nx-X11-3.1.0-1.tar.gz
Keywords:

Imported nx-X11-3.1.0-1.tar.gz
into Git repository

4 files changed, 1995 insertions, 0 deletions

diff --git a/nx-X11/programs/Xserver/Xprint/raster/Imakefile b/nx-X11/programs/Xserver/Xprint/raster/Imakefile
new file mode 100644
index 000000000..e2112c00b
--- /dev/null
+++ b/nx-X11/programs/Xserver/Xprint/raster/Imakefile
@@ -0,0 +1,28 @@
+XCOMM $Xorg: Imakefile,v 1.3 2000/08/17 19:48:11 cpqbld Exp $
+
+#include <Server.tmpl>
+
+SRCS1 =	Raster.c RasterAttVal.c
+OBJS1 = Raster.o RasterAttVal.o
+
+SRCS = $(SRCS1)
+
+OBJS = $(OBJS1)
+
+   INCLUDES = -I. -I$(XINCLUDESRC) -I.. -I$(LIBSRC) \
+             -I../../cfb -I../../mfb -I../../mi \
+             -I../../include -I$(TOP)/include -I$(FONTINCSRC)
+
+
+   LINTLIBS = ../../dix/llib-ldix.ln ../../os/llib-los.ln \
+	      ../../mfb/llib-lmfb.ln ../../mi/llib-lmi.ln \
+	      ../../cfb/llib-lcfb.ln
+
+   DEFINES  = -D_XP_PRINT_SERVER_ -UXFree86LOADER
+
+NormalLibraryObjectRule()
+
+NormalLibraryTarget(raster,$(OBJS))
+NormalLintTarget($(SRCS1) $(SRCS2))
+
+DependTarget()
diff --git a/nx-X11/programs/Xserver/Xprint/raster/Raster.c b/nx-X11/programs/Xserver/Xprint/raster/Raster.c
new file mode 100644
index 000000000..781327b33
--- /dev/null
+++ b/nx-X11/programs/Xserver/Xprint/raster/Raster.c
@@ -0,0 +1,1580 @@
+/* $Xorg: Raster.c,v 1.4 2001/03/14 18:46:12 pookie Exp $ */
+/*
+(c) Copyright 1996 Hewlett-Packard Company
+(c) Copyright 1996 International Business Machines Corp.
+(c) Copyright 1996 Sun Microsystems, Inc.
+(c) Copyright 1996 Novell, Inc.
+(c) Copyright 1996 Digital Equipment Corp.
+(c) Copyright 1996 Fujitsu Limited
+(c) Copyright 1996 Hitachi, Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the names of the copyright holders shall
+not be used in advertising or otherwise to promote the sale, use or other
+dealings in this Software without prior written authorization from said
+copyright holders.
+*/
+
+/* $XFree86: xc/programs/Xserver/Xprint/raster/Raster.c,v 1.11tsi Exp $ */
+
+/*******************************************************************
+**
+**    *********************************************************
+**    *
+**    *  File:		printer/Raster.c
+**    *
+**    *  Contents:
+**    *                 Raster driver for the print server.
+**    *
+**    *  Copyright:	Copyright 1993, 1995 Hewlett-Packard Company
+**    *
+**    *********************************************************
+** 
+********************************************************************/
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <X11/X.h>
+#include <X11/Xos.h>	/* for SIGCLD on pre-POSIX systems */
+#define NEED_EVENTS
+#include <X11/Xproto.h>
+#undef NEED_EVENTS
+#include <X11/Xatom.h>
+#include "misc.h"
+#include "dixstruct.h"
+#include "scrnintstr.h"
+#include "screenint.h"
+#include "colormapst.h"
+#include "windowstr.h"
+#include "propertyst.h"
+#include "servermd.h"	/* needed for IMAGE_BUFSIZE */
+#include "mfb.h"
+#include "mi.h"
+
+#include <X11/extensions/Print.h>
+#include "Raster.h"
+
+#include "attributes.h"
+#include "AttrValid.h"
+#include "DiPrint.h"
+
+static void AllocateRasterPrivates(
+    ScreenPtr pScreen);
+static Bool RasterChangeWindowAttributes(
+    WindowPtr pWin,
+    unsigned long   mask);
+static int StartJob(
+    XpContextPtr pCon,
+    Bool sendClientData,
+    ClientPtr client);
+static int StartPage(
+    XpContextPtr pCon,
+    WindowPtr pWin);
+static int StartDoc(
+    XpContextPtr pCon,
+    XPDocumentType type);
+static int EndDoc(
+    XpContextPtr pCon,
+    Bool cancel);
+static int EndJob(
+    XpContextPtr pCon,
+    Bool cancel);
+static int EndPage(
+    XpContextPtr pCon,
+    WindowPtr pWin);
+static int DocumentData(
+    XpContextPtr pCon,
+    DrawablePtr pDraw,
+    char *pData,
+    int len_data,
+    char *pDoc_fmt,
+    int len_fmt,
+    char *pOptions,
+    int len_options,
+    ClientPtr client);
+static int GetDocumentData(
+    XpContextPtr pContext,
+    ClientPtr client,
+    int maxBufferSize);
+static void FreePageFiles(
+    RasterContextPrivPtr pWinPriv);
+static int SystemCmd(
+    char *pCommand);
+static Bool RasterCloseScreen(
+    int index,
+    ScreenPtr pScreen);
+static int RasterInitContext(XpContextPtr pCon);
+static Bool RasterDestroyContext(XpContextPtr pCon);
+static char *RasterGetAttributes(
+		XpContextPtr pContext,
+		XPAttributes class);
+static char *RasterGetOneAttribute(XpContextPtr pCon,
+			   XPAttributes class, 
+			   char *attribute);
+static int RasterSetAttributes(XpContextPtr pCon,
+			  XPAttributes class,
+			  char *attributes);
+static int RasterAugmentAttributes(XpContextPtr pCon,
+			      XPAttributes class,
+			      char *attributes);
+static int RasterMediumDimensions(XpContextPtr pCon,
+			      CARD16 *width,
+			      CARD16 *height);
+static int RasterReproducibleArea(XpContextPtr pCon,
+			      xRectangle *pRect);
+
+#define MAX(a,b) (((a) > (b)) ? (a) : (b))
+#define DOC_PCL		1
+#define DOC_RASTER	2
+
+static int RasterScreenPrivateIndex, RasterContextPrivateIndex;
+static int RasterGeneration = 0;
+static char RASTER_DRIV_NAME[] = "XP-RASTER";
+static int doc_type = DOC_RASTER;
+
+#define ABSOLUTE_PCLCOMP_PATH1 "/usr/openwin/bin/pclcomp"
+#define ABSOLUTE_PCLCOMP_PATH2 "/usr/X11/bin/pclcomp"
+
+static char *pcl3_output_cmds[] = {
+        "xpr -device ljet -rv -landscape < %(InFile)% | pclcomp -0 > %(OutFile)%",
+        "xpr -device ljet -rv -landscape < %(InFile)% | pclcomp -01 > %(OutFile)%",
+        "xpr -device ljet -rv -landscape < %(InFile)% | pclcomp -02 > %(OutFile)%",
+        "xpr -device ljet -rv -landscape < %(InFile)% | pclcomp -03 > %(OutFile)%",
+        "xpr -device ljet -rv -landscape < %(InFile)% | pclcomp -012 > %(OutFile)%",
+        "xpr -device ljet -rv -landscape < %(InFile)% | pclcomp -013 > %(OutFile)%",
+        "xpr -device ljet -rv -landscape < %(InFile)% | pclcomp -023 > %(OutFile)%",
+        "xpr -device ljet -rv -landscape < %(InFile)% | pclcomp -0123 > %(OutFile)%",
+        "xpr -device ljet -rv -landscape < %(InFile)% > %(OutFile)%",
+        "xpr -device ljet -rv < %(InFile)% | pclcomp -0 > %(OutFile)%",
+        "xpr -device ljet -rv < %(InFile)% | pclcomp -01 > %(OutFile)%",
+        "xpr -device ljet -rv < %(InFile)% | pclcomp -02 > %(OutFile)%",
+        "xpr -device ljet -rv < %(InFile)% | pclcomp -03 > %(OutFile)%",
+        "xpr -device ljet -rv < %(InFile)% | pclcomp -012 > %(OutFile)%",
+        "xpr -device ljet -rv < %(InFile)% | pclcomp -013 > %(OutFile)%",
+        "xpr -device ljet -rv < %(InFile)% | pclcomp -023 > %(OutFile)%",
+        "xpr -device ljet -rv < %(InFile)% | pclcomp -0123 > %(OutFile)%",
+        "xpr -device ljet -rv < %(InFile)% > %(OutFile)%"};
+
+Bool
+InitializeRasterDriver(
+     int ndx,
+     ScreenPtr pScreen,
+     int argc,
+     char **argv)
+{
+    int xRes, yRes;
+    int maxRes, maxDim, numBytes;
+    RasterScreenPrivPtr pPriv;
+    
+    /*
+     * Register this driver's InitContext function with the print extension.
+     * This is a bit
+     * sleazy, as the extension hasn't yet been initialized, but the
+     * extension needs to know this, and this seems the best time to
+     * provide the information.
+     */
+    XpRegisterInitFunc( pScreen, RASTER_DRIV_NAME, RasterInitContext );
+
+    /*
+     * Create and load the devPrivate for the printer layer.
+     */
+    AllocateRasterPrivates(pScreen);
+   
+    pPriv = (RasterScreenPrivPtr)
+      pScreen->devPrivates[RasterScreenPrivateIndex].ptr;
+
+    maxDim = MAX( pScreen->height, pScreen->width );
+    numBytes = maxDim + BITMAP_SCANLINE_PAD - 1; /* pixels per row */
+    numBytes *= maxDim;
+    numBytes /=  8; /* bytes per row */
+    xRes = pScreen->width / (pScreen->mmWidth / 25.4);
+    yRes = pScreen->height / (pScreen->mmHeight / 25.4);
+    maxRes = MAX( xRes, yRes );
+
+    pPriv->pBits = (char *)xalloc(numBytes);
+
+    /*
+     * Have to allocate maxDim X maxDim to allow for landscape mode.
+     */
+    mfbScreenInit(pScreen, pPriv->pBits, maxDim, maxDim, maxRes,
+		  maxRes, maxDim);
+    miInitializeBackingStore(pScreen);
+    pScreen->blackPixel = 1;
+    pScreen->whitePixel = 0;
+    if(mfbCreateDefColormap(pScreen) == FALSE)
+	; /* XXX what do I do if it fails? */
+    
+    /*
+    cfbScreenInit(pScreen, pPriv->pBits, maxWidth, maxHeight, maxXres,
+		  maxYres, maxWidth);
+    miInitializeBackingStore(pScreen);
+    scalingScreenInit(pScreen);
+    */
+
+    pScreen->SaveScreen = (SaveScreenProcPtr)_XpBoolNoop;
+    pPriv->ChangeWindowAttributes = pScreen->ChangeWindowAttributes;
+    pScreen->ChangeWindowAttributes = RasterChangeWindowAttributes;
+    pPriv->CloseScreen = pScreen->CloseScreen;
+    pScreen->CloseScreen = RasterCloseScreen;
+
+    return TRUE;
+}
+
+/*
+ * GetPropString searches the context's config database for a property
+ * by the name of propName.  If found, it returns the property's
+ * value, otherwise it returns NULL unless the requested attribute
+ * is RASTER_PRINT_PAGE_COMMAND, in which case it returns a hard-coded
+ * default string to invoke xpr to produce a PostScript(tm) formatted
+ * raster.
+ */
+
+static char *
+GetPropString(
+     XpContextPtr pCon,
+     char *propName)
+{
+    RasterContextPrivPtr pConPriv = (RasterContextPrivPtr)
+      pCon->devPrivates[RasterContextPrivateIndex].ptr;
+    char *type;
+    XrmValue val;
+    struct stat status;
+    int pclcomp_exists = 0;
+
+    if( XrmGetResource(pConPriv->config, propName, propName, &type, &val) == 
+       True )
+        return (char *)val.addr;
+
+    if( !strcmp( propName, RASTER_PRINT_PAGE_COMMAND ) )
+      if( doc_type == DOC_RASTER )
+        return "xpr -device ps %(InFile)% > %(OutFile)%";
+      else
+      {
+        XpOid orientation;
+        XpOid compression;
+        int   pcl3_output_index = 0;
+
+        orientation = XpGetContentOrientation(pCon);
+        compression = XpGetAvailableCompression(pCon);
+
+        switch(orientation) {
+        case xpoid_val_content_orientation_landscape:
+           pcl3_output_index = 0;
+           break;
+        default:
+           pcl3_output_index += 9;
+           break;
+        }
+
+        if(stat(ABSOLUTE_PCLCOMP_PATH1, &status) != -1)
+           pclcomp_exists = 1;
+        else if(stat(ABSOLUTE_PCLCOMP_PATH2, &status) != -1)
+           pclcomp_exists = 1;
+
+        if(pclcomp_exists)
+           switch(compression) {
+           case xpoid_val_available_compressions_0:
+              pcl3_output_index += 0;
+              break;
+           case xpoid_val_available_compressions_01:
+              pcl3_output_index += 1;
+              break;
+           case xpoid_val_available_compressions_02:
+              pcl3_output_index += 2;
+              break;
+           case xpoid_val_available_compressions_03:
+              pcl3_output_index += 3;
+              break;
+           case xpoid_val_available_compressions_012:
+              pcl3_output_index += 4;
+              break;
+           case xpoid_val_available_compressions_013:
+              pcl3_output_index += 5;
+              break;
+           case xpoid_val_available_compressions_023:
+              pcl3_output_index += 6;
+              break;
+           default:
+              pcl3_output_index += 7;
+              break;
+           }
+        else
+           pcl3_output_index += 8;
+
+        return pcl3_output_cmds[pcl3_output_index];
+      }
+    else
+      return NULL;
+}
+
+static void
+SetDocumentType(
+     XpContextPtr pCon)
+{
+    XpOidList* attrs_supported;
+
+    /*
+     * only validate attributes found in document-attributes-supported
+     */
+    attrs_supported =
+	XpGetListAttr(pCon, XPPrinterAttr,
+		      xpoid_att_document_attributes_supported,
+		      (const XpOidList*)NULL);
+
+    if(XpOidListHasOid(attrs_supported, xpoid_att_document_format))
+    {
+	const char* value_in;
+	XpOidDocFmt *f;
+
+	value_in = XpGetStringAttr(pCon, XPDocAttr, xpoid_att_document_format);
+
+	f = XpOidDocFmtNew( value_in );
+
+	if( f != NULL )
+	{
+	    if( !strcmp( f->format, "PCL" ) )
+		doc_type = DOC_PCL;
+	    else
+		doc_type = DOC_RASTER;
+
+	    XpOidDocFmtDelete( f );
+	}
+    }
+
+    /*
+     * clean up
+     */
+    XpOidListDelete(attrs_supported);
+}
+
+static int
+StartJob(
+     XpContextPtr pCon,
+     Bool sendClientData,
+     ClientPtr client)
+{
+    RasterContextPrivPtr pConPriv = (RasterContextPrivPtr)
+			 pCon->devPrivates[RasterContextPrivateIndex].ptr;
+
+    SetDocumentType( pCon );
+
+    /*
+     * Check for existing page file, and delete it if it exists.
+     */
+    if(pConPriv->pageFileName != (char *)NULL)
+    {
+	if(pConPriv->pPageFile != (FILE *)NULL)
+	{
+	    fclose(pConPriv->pPageFile);
+	    pConPriv->pPageFile = (FILE *)NULL;
+	}
+	unlink(pConPriv->pageFileName);
+	Xfree(pConPriv->pageFileName);
+	pConPriv->pageFileName = (char *)NULL;
+    }
+
+    /* 
+     * Create a temporary file to store the printer output.
+     */
+    if(!sendClientData)
+    {
+	/* 
+	 * Create a temporary file to store the printer output.
+	 */
+	if (!XpOpenTmpFile("w", &pConPriv->jobFileName, &pConPriv->pJobFile))
+	    return BadAlloc;
+    }
+
+    return Success;
+}
+
+/*
+ * StartDoc and EndDoc are just no-ops in this implementation, since
+ * our view of the spooler really doesn't recognize documents.
+ */
+
+static int 
+StartDoc(
+     XpContextPtr pCon,
+     XPDocumentType type)
+{
+    return Success;
+}
+
+static int EndDoc(
+     XpContextPtr pCon,
+     Bool cancel)
+{
+    return Success;
+}
+
+#if 0
+
+/* XXX Not used. */
+
+/*
+ * BuidArgVector takes a pointer to a comma-separated list of command
+ * options and splits it out into an array of argument pointers.  The
+ * caller must not free the optionList after calling this function until
+ * the returned arg vector is no longer needed, at which time the arg
+ * vector should also be freed.
+ */
+
+#define SEPARATOR_CHAR (char)','
+
+static char **
+BuildArgVector(
+    char *optionList,
+    char **argVector,
+    int argCount)
+{
+    char *curArg, *lastChar, *endArg;
+
+    curArg = optionList;
+    lastChar = optionList + strlen(optionList); /* includes final NULL */
+
+    while(curArg != (char *)NULL && curArg < lastChar)
+    {
+	/* strip leading white space */
+	while(curArg < lastChar && isascii((int)*curArg) && 
+	      isspace((int)*curArg))
+	    curArg++;
+
+	if(curArg < lastChar)
+	{
+	    argVector = (char **)Xrealloc(argVector, 
+					  sizeof(char *) * (argCount + 2));
+	    argVector[argCount] = curArg;
+	    argVector[++argCount] = (char *)NULL;
+
+	    endArg = strchr(curArg, SEPARATOR_CHAR);
+
+	    /* Should I strip trailing white space ??? */
+
+	    if(endArg != (char *)NULL)
+	    {
+	        *endArg = (char)'\0';
+	        curArg = endArg + 1;
+	    }
+	    else
+	        curArg = (char *)NULL;
+	}
+    }
+
+    return argVector;
+}
+#endif
+
+static int
+EndJob(
+     XpContextPtr pCon,
+     Bool cancel)
+{
+    RasterContextPrivPtr pConPriv = (RasterContextPrivPtr)
+			 pCon->devPrivates[RasterContextPrivateIndex].ptr;
+
+    if( cancel == True )
+    {
+        if(pConPriv->getDocClient != (ClientPtr)NULL) {
+	    XpFinishDocData(pConPriv->getDocClient);
+	    
+	    pConPriv->getDocClient = (ClientPtr)NULL;
+	    pConPriv->getDocBufSize = 0;
+	}
+	    
+	if(pConPriv->jobFileName != (char *)NULL)
+	{
+	    unlink(pConPriv->jobFileName);
+	    Xfree(pConPriv->jobFileName);
+	    pConPriv->jobFileName = (char *)NULL;
+	}
+
+        return Success;
+    }
+
+    if(pConPriv->getDocClient != (ClientPtr)NULL&&pConPriv->getDocBufSize > 0)
+    {
+        XpFinishDocData(pConPriv->getDocClient);
+	    
+	pConPriv->getDocClient = (ClientPtr)NULL;
+	pConPriv->getDocBufSize = 0;
+
+        return Success;
+    }
+    
+    if(pConPriv->pJobFile != (FILE *)NULL)
+    {
+        fclose(pConPriv->pJobFile);
+        pConPriv->pJobFile = (FILE *)NULL;
+	
+	if(pConPriv->jobFileName != (char *)NULL)
+	{
+	      XpSubmitJob( pConPriv->jobFileName, pCon );
+	      unlink(pConPriv->jobFileName);
+	      Xfree(pConPriv->jobFileName);
+	      pConPriv->jobFileName = (char *)NULL;
+	}
+    }
+
+    return Success;
+}
+
+/* StartPage 
+ *
+ * If page file exists
+ *     close page file
+ *     set page file pointer = NULL
+ *     unlink page file
+ */
+static int
+StartPage(
+     XpContextPtr pCon,
+     WindowPtr pWin)
+{
+    RasterContextPrivPtr pConPriv = (RasterContextPrivPtr)
+			 pCon->devPrivates[RasterContextPrivateIndex].ptr;
+
+    if(pConPriv->pPageFile != (FILE *)NULL)
+    {
+	fclose(pConPriv->pPageFile);
+	pConPriv->pPageFile = (FILE *)NULL;
+    }
+    if(pConPriv->pageFileName != (char *)NULL)
+    {
+	unlink(pConPriv->pageFileName);
+	pConPriv->pageFileName = (char *)NULL;
+    }
+
+    return Success;
+}
+
+#include "X11/XWDFile.h"
+
+
+#define lowbit(x) ((x) & (~(x) + 1))
+
+/*
+ * Get the XWDColors of all pixels in colormap - returns # of colors
+ */
+static XWDColor *
+Get_XWDColors(
+     ColormapPtr pCmap)
+{
+    int i, ncolors;
+    xrgb *prgbList;
+    Pixel *pPixels;
+    XWDColor *colors;
+
+    ncolors = pCmap->pVisual->ColormapEntries;
+    if (!(colors = (XWDColor *) malloc (sizeof(XWDColor) * ncolors)))
+        return (XWDColor *) NULL;
+    if (!(prgbList = (xrgb*) malloc(sizeof(xrgb) * ncolors)))
+    {
+	Xfree(colors);
+        return (XWDColor *) NULL;
+    }
+    if (!(pPixels = (Pixel*) malloc(sizeof(Pixel) * ncolors)))
+    {
+	Xfree(colors);
+	Xfree(prgbList);
+        return (XWDColor *) NULL;
+    }
+
+    if (pCmap->pVisual->class == DirectColor ||
+        pCmap->pVisual->class == TrueColor) {
+        Pixel red, green, blue, red1, green1, blue1;
+
+        red = green = blue = 0;
+        red1 = lowbit(pCmap->pVisual->redMask);
+        green1 = lowbit(pCmap->pVisual->greenMask);
+        blue1 = lowbit(pCmap->pVisual->blueMask);
+        for (i=0; i<ncolors; i++) {
+          colors[i].pixel = red|green|blue;
+          colors[i].pad = 0;
+          red += red1;
+          if (red > pCmap->pVisual->redMask)
+            red = 0;
+          green += green1;
+          if (green > pCmap->pVisual->greenMask)
+            green = 0;
+          blue += blue1;
+          if (blue > pCmap->pVisual->blueMask)
+            blue = 0;
+        }
+    } else {
+        for (i=0; i<ncolors; i++) {
+          colors[i].pixel = i;
+          colors[i].pad = 0;
+        }
+    }
+
+    for(i = 0; i < ncolors; i++)
+	pPixels[i] = colors[i].pixel;
+
+    QueryColors(pCmap, ncolors, pPixels, prgbList);
+    Xfree(pPixels);
+
+    for(i = 0; i < ncolors; i++)
+    {
+	colors[i].red = prgbList[i].red;
+	colors[i].green = prgbList[i].green;
+	colors[i].blue = prgbList[i].blue;
+    }
+    Xfree(prgbList);
+
+    return(colors);
+}
+
+static void
+_swapshort (
+    register char *bp,
+    register unsigned n)
+{
+    register char c;
+    register char *ep = bp + n;
+
+    while (bp < ep) {
+        c = *bp;
+        *bp = *(bp + 1);
+        bp++;
+        *bp++ = c;
+    }
+}
+
+static void
+_swaplong (
+    register char *bp,
+    register unsigned n)
+{
+    register char c;
+    register char *ep = bp + n;
+    register char *sp;
+
+    while (bp < ep) {
+        sp = bp + 3;
+        c = *sp;
+        *sp = *bp;
+        *bp++ = c;
+        sp = bp + 1;
+        c = *sp;
+        *sp = *bp;
+        *bp++ = c;
+        bp += 2;
+    }
+}
+static int
+WriteWindowRaster(
+    WindowPtr pWin,
+    FILE *pRasterFile)
+{
+    long widthBytesLine, length;
+    int nlines, linesPerBuf, height, linesDone;
+    char *pBuf;
+    DrawablePtr pDraw = &pWin->drawable;
+    XWDFileHeader header;
+    int win_name_size;
+    int header_size;
+    int ncolors, i;
+    char *win_name;
+    VisualPtr pVisual;
+    ColormapPtr pCmap;
+    XWDColor *pColors;
+    unsigned long swaptest = 1;
+
+    widthBytesLine = PixmapBytePad(pWin->drawable.width, pWin->drawable.depth);
+    length = widthBytesLine * pWin->drawable.height;
+    height = pWin->drawable.height;
+
+    if(length <= 0)
+        return Success;
+
+    if (widthBytesLine >= IMAGE_BUFSIZE)
+        linesPerBuf = 1;
+    else
+    {
+        linesPerBuf = IMAGE_BUFSIZE / widthBytesLine;
+        if (linesPerBuf > height)
+            linesPerBuf = height;
+    }
+    length = linesPerBuf * widthBytesLine;
+    if (linesPerBuf < height)
+    {
+        /* we have to make sure intermediate buffers don't need padding */
+        while ((linesPerBuf > 1) && (length & 3))
+        {
+            linesPerBuf--;
+            length -= widthBytesLine;
+        }
+        while (length & 3)
+        {
+            linesPerBuf++;
+            length += widthBytesLine;
+        }
+    }
+    if(!(pBuf = (char *) Xalloc(length)))
+        return (BadAlloc);
+
+    /*
+     * Start of Xwd header code.
+     */
+
+    /*
+     * XXX - Should we use the real window name???
+     */
+    win_name = "xwdump";
+    /* sizeof(char) is included for the null string terminator. */
+    win_name_size = strlen(win_name) + sizeof(char);
+    
+    pCmap = (ColormapPtr)LookupIDByType(wColormap (pWin), RT_COLORMAP);
+    pVisual = pCmap->pVisual;
+    if((pColors = Get_XWDColors(pCmap)) == (XWDColor *)NULL)
+    {
+	Xfree(pBuf);
+	return (BadAlloc);
+    }
+
+    /*
+     * Write out header information.
+     */
+    header_size = sizeof(header) + win_name_size;
+    header.header_size = (CARD32) header_size;
+    header.file_version = (CARD32) XWD_FILE_VERSION;
+    header.pixmap_format = (CARD32) ZPixmap; /* Must match GetImage below */
+    header.pixmap_depth = (CARD32) pDraw->depth;
+    header.pixmap_width = (CARD32) pDraw->width;
+    header.pixmap_height = (CARD32) pDraw->height;
+    header.xoffset = (CARD32) 0;
+    header.byte_order = (CARD32) screenInfo.imageByteOrder;
+    header.bitmap_unit = (CARD32) screenInfo.bitmapScanlineUnit;
+    header.bitmap_bit_order = (CARD32) screenInfo.bitmapBitOrder;
+    header.bitmap_pad = (CARD32) screenInfo.bitmapScanlinePad;
+    header.bits_per_pixel = (CARD32) pDraw->bitsPerPixel;
+    header.bytes_per_line = (CARD32) widthBytesLine;
+    header.visual_class = (CARD32) pVisual->class;
+    header.red_mask = (CARD32) pVisual->redMask;
+    header.green_mask = (CARD32) pVisual->greenMask;
+    header.blue_mask = (CARD32) pVisual->blueMask;
+    header.bits_per_rgb = (CARD32) pVisual->bitsPerRGBValue;
+    header.colormap_entries = (CARD32) pVisual->ColormapEntries;
+    header.ncolors = ncolors = (CARD32) pVisual->ColormapEntries;
+    header.window_width = (CARD32) pDraw->width;
+    header.window_height = (CARD32) pDraw->height;
+    header.window_x = 0;
+    header.window_y = 0;
+    header.window_bdrwidth = (CARD32) 0;
+
+    if (*(char *) &swaptest) {
+        _swaplong((char *) &header, sizeof(header));
+        for (i = 0; i < ncolors; i++) {
+            _swaplong((char *) &pColors[i].pixel, sizeof(long));
+            _swapshort((char *) &pColors[i].red, 3 * sizeof(short));
+        }
+    }
+
+    (void) fwrite((char *)&header, sizeof(header), 1, pRasterFile);
+    (void) fwrite(win_name, win_name_size, 1, pRasterFile);
+    (void) fwrite((char *) pColors, sizeof(XWDColor), ncolors, pRasterFile);
+
+    Xfree(pColors);
+
+    /*
+     * End of Xwd header code.
+     */
+
+    linesDone = 0;
+    while(height - linesDone > 0)
+    {
+        nlines = min(linesPerBuf, height - linesDone);
+        (*pDraw->pScreen->GetImage) (pDraw,
+                                     0,
+                                     linesDone,
+                                     pWin->drawable.width,
+                                     nlines,
+                                     ZPixmap,
+                                     ~0,
+                                     pBuf);
+
+        if(fwrite(pBuf, sizeof(char), (size_t)(nlines * widthBytesLine),
+	   pRasterFile) != 
+	   (size_t)(nlines * widthBytesLine))
+	{
+	    Xfree(pBuf);
+	    return BadAlloc;
+	}
+        linesDone += nlines;
+    }
+    Xfree(pBuf);
+    return Success;
+}
+
+
+static int
+SendPage( XpContextPtr pCon )
+{
+    struct stat statBuf;
+    RasterContextPrivPtr pConPriv = (RasterContextPrivPtr)
+			 pCon->devPrivates[RasterContextPrivateIndex].ptr;
+
+    if(stat(pConPriv->pageFileName, &statBuf) < 0)
+        return BadAlloc;
+
+    return XpSendDocumentData(pConPriv->getDocClient, 
+		              pConPriv->pPageFile, (int)statBuf.st_size, 
+		              pConPriv->getDocBufSize);
+}
+
+/*
+ * EndPage:
+ *
+ * If page file doesn't exist:
+ * {
+ *     Create page file
+ *     Open page file
+ *     Write page header to page file
+ *     if(preRasterFile exists)
+ *         copy preRasterFile contents to page file
+ *     if(noRasterFile exists)
+ *         write noRasterFile contents to page file
+ *     else
+ *         Create raster image file
+ *         Open raster image file
+ *         GetImage data
+ *         Write Image data to raster image file
+ *         invoke page_command on raster image file
+ *         Write raster image file contents to page file
+ *         Unlink tempPage file
+ *     if(postRasterFile exists)
+ *         write postRasterFile contents to page file
+ *     Write page trailer to page file
+ * }
+ * Write page file to job file
+ */
+static int
+EndPage(
+     XpContextPtr pCon,
+     WindowPtr pWin)
+{
+    RasterContextPrivPtr pConPriv = (RasterContextPrivPtr)
+			 pCon->devPrivates[RasterContextPrivateIndex].ptr;
+    struct stat statBuf;
+    char *rasterFileName = (char *)NULL, *pCommand = (char *)NULL;
+    FILE *pRasterFile = (FILE *)NULL;
+
+    if(pConPriv->pageFileName == (char *)NULL)
+    {
+	/*
+	 * Open the page file.
+	 */
+	if (!XpOpenTmpFile("w+", &pConPriv->pageFileName,
+			   &pConPriv->pPageFile))
+	    goto BAD_PAGE_ALLOC;
+
+	/*
+	 * Copy any pre-raster document data to the page file.
+	 */
+	if(pConPriv->pPreRasterFile != (FILE *)NULL)
+	{
+	    if(CopyContentsAndDelete(&pConPriv->pPreRasterFile, 
+			             &pConPriv->preRasterFileName,
+			             pConPriv->pPageFile) == FALSE)
+		goto BAD_PAGE_ALLOC;
+	}
+
+	/*
+	 * Copy either the no-raster document data, or the raster 
+	 * data itself to the page file.
+	 * If the no-raster file exists, then we don't process the
+	 * actual window raster bits.
+	 */
+	if(pConPriv->pNoRasterFile != (FILE *)NULL)
+	{
+	    if(CopyContentsAndDelete(&pConPriv->pNoRasterFile, 
+			             &pConPriv->noRasterFileName,
+			             pConPriv->pPageFile) == FALSE)
+		goto BAD_PAGE_ALLOC;
+	}
+	else
+	{
+	    /*
+	     * Open the raster image file.
+	     */
+	    if (!XpOpenTmpFile("w", &rasterFileName, &pRasterFile))
+		goto BAD_PAGE_ALLOC;
+    
+	    /*
+	     * Write the page image data to the raster image file.
+	     */
+	    if(WriteWindowRaster(pWin, pRasterFile) != Success)
+	        goto BAD_PAGE_ALLOC;
+
+	    /*
+	     * Invoke the page_command on the raster image file.
+	     */
+	    if((pCommand = GetPropString(pCon, RASTER_PRINT_PAGE_COMMAND)) !=
+	       (char *)NULL)
+	    {
+	        char *outFileName;
+	        FILE *pOutFile;
+
+		if (!XpOpenTmpFile("w", &outFileName, &pOutFile))
+		    goto BAD_PAGE_ALLOC;
+	        fclose(pOutFile);
+
+	        pCommand = ReplaceFileString(strdup(pCommand), rasterFileName,
+					     outFileName);
+	        fclose(pRasterFile);
+	        SystemCmd(pCommand);
+		free(pCommand);
+	        /*
+	         * Delete the unprocessed raster file.
+	         */
+	        unlink(rasterFileName);
+	        Xfree(rasterFileName);
+	        rasterFileName = outFileName;
+                if((pRasterFile = fopen(rasterFileName, "r")) == (FILE *)NULL)
+	            goto BAD_PAGE_ALLOC;
+	    }
+	    else
+	    {
+	        fclose(pRasterFile);
+                if((pRasterFile = fopen(rasterFileName, "r")) == (FILE *)NULL)
+	            goto BAD_PAGE_ALLOC;
+	    }
+
+	    /*
+	     * Copy the raster image file contents to the page file.
+	     * Note that pRasterFile must be set to the start of the
+	     * raster file.
+	     */
+	    if(CopyContentsAndDelete(&pRasterFile,
+			             &rasterFileName,
+			             pConPriv->pPageFile) == FALSE)
+		goto BAD_PAGE_ALLOC;
+	}
+
+	/*
+	 * Copy any post-raster document data to the page file.
+	 */
+	if(pConPriv->pPostRasterFile != (FILE *)NULL)
+	{
+	    if(CopyContentsAndDelete(&pConPriv->pPostRasterFile, 
+			             &pConPriv->postRasterFileName,
+			             pConPriv->pPageFile) == FALSE)
+		goto BAD_PAGE_ALLOC;
+	}
+
+    }
+
+    /*
+     * Write the page file contents to the job file or to the client
+     * performing GetDocumentData.
+     * pConPriv->pPageFile must first be set to the start of the page file.
+     */
+    rewind(pConPriv->pPageFile);
+    if(stat(pConPriv->pageFileName, &statBuf) < 0)
+        goto BAD_PAGE_ALLOC;
+
+    /*
+     * Send the page data to whatever client has called GetDocumentData.
+     */
+    if(pConPriv->getDocClient != (ClientPtr)NULL&&pConPriv->getDocBufSize > 0)
+    {
+	int retval;
+        /*
+         * We should do something like the following: suspend the 
+         * caller until we can gracefully write all the data in small
+         * chunks to the receiver, but for now we'll just call WriteToClient
+         * on the huge chunk
+         */
+	retval = SendPage(pCon);
+        fclose(pConPriv->pPageFile);
+        pConPriv->pPageFile = (FILE *)NULL;
+        unlink(pConPriv->pageFileName);
+        free(pConPriv->pageFileName);
+        pConPriv->pageFileName = (char *)NULL;
+	return retval;
+    }
+
+    if(pConPriv->pJobFile == (FILE *)NULL)
+    {
+	/*
+	 * This shouldn't be necessary.  I believe we only get here if
+	 * someone calls "EndPage" prior to "StartJob".  This error 
+	 * condition should probably be trapped at a higher level.
+	 */
+
+	if(pConPriv->jobFileName != (char *)NULL)
+	    Xfree(pConPriv->jobFileName);
+        /*
+         * Create a temporary file to store the printer output.
+         */
+	if (!XpOpenTmpFile("w", &pConPriv->jobFileName, &pConPriv->pJobFile))
+	    goto BAD_PAGE_ALLOC;
+    }
+
+    if(TransferBytes(pConPriv->pPageFile, pConPriv->pJobFile, 
+       (int)statBuf.st_size) != (int)statBuf.st_size)
+        goto BAD_PAGE_ALLOC;
+
+    fclose(pConPriv->pPageFile);
+    pConPriv->pPageFile = (FILE *)NULL;
+    unlink(pConPriv->pageFileName);
+    free(pConPriv->pageFileName);
+    pConPriv->pageFileName = (char *)NULL;
+
+    return Success;
+
+  BAD_PAGE_ALLOC:
+
+    FreePageFiles(pConPriv);
+
+    if(pRasterFile != (FILE *)NULL)
+	fclose(pRasterFile);
+    if(rasterFileName != (char *)NULL)
+    {
+	unlink(rasterFileName);
+        Xfree(rasterFileName);
+    }
+    return BadAlloc;
+}
+
+static int
+DocumentData(
+     XpContextPtr pCon,
+     DrawablePtr pDraw,
+     char *pData,
+     int len_data,
+     char *pDoc_fmt,
+     int len_fmt,
+     char *pOptions,
+     int len_options,
+     ClientPtr client)
+{
+    RasterContextPrivPtr pConPriv = (RasterContextPrivPtr)
+			 pCon->devPrivates[RasterContextPrivateIndex].ptr;
+    char *preRasterStr = PRE_RASTER, *postRasterStr = POST_RASTER,
+	 *noRasterStr = NO_RASTER;
+
+    /*
+     * Check that options equals either PRE_RASTER or POST_RASTER.
+     */
+    if(len_options == strlen(preRasterStr) &&
+       strncmp(pOptions, preRasterStr, strlen(preRasterStr)) == 0)
+    {
+	if(pConPriv->pPreRasterFile == (FILE *)NULL)
+	{
+	    if (!XpOpenTmpFile("w+", &pConPriv->preRasterFileName,
+			       &pConPriv->pPreRasterFile))
+		return BadAlloc;
+	}
+	if(fwrite(pData, sizeof(char), (size_t)len_data,
+	   pConPriv->pPreRasterFile) != (size_t)len_data)
+	    return BadAlloc;
+	fflush(pConPriv->pPreRasterFile);
+    }
+    else if(len_options == strlen(postRasterStr) &&
+	    strncmp(pOptions, postRasterStr, strlen(postRasterStr)) == 0)
+    {
+	if(pConPriv->pPostRasterFile == (FILE *)NULL)
+	{
+	    if (!XpOpenTmpFile("w+", &pConPriv->postRasterFileName,
+			       &pConPriv->pPostRasterFile))
+		return BadAlloc;
+	}
+	if(fwrite(pData, sizeof(char), (size_t)len_data,
+	   pConPriv->pPostRasterFile) != (size_t)len_data)
+	    return BadAlloc;
+	fflush(pConPriv->pPostRasterFile);
+    }
+    else if(len_options == strlen(noRasterStr) &&
+	    strncmp(pOptions, noRasterStr, strlen(noRasterStr)) == 0)
+    {
+	if(pConPriv->pNoRasterFile == (FILE *)NULL)
+	{
+	    if (!XpOpenTmpFile("w+", &pConPriv->noRasterFileName,
+			       &pConPriv->pNoRasterFile))
+		return BadAlloc;
+	}
+	if(fwrite(pData, sizeof(char), (size_t)len_data,
+	   pConPriv->pNoRasterFile) != (size_t)len_data)
+	    return BadAlloc;
+	fflush(pConPriv->pNoRasterFile);
+    }
+    else
+	return BadValue;
+
+    return Success;
+}
+
+/*
+ * GetDocumentData notes which client is requesting the document data for
+ * a particular context. The Raster driver's EndPage function causes the
+ * data to be written to the proper client.
+ */
+static int
+GetDocumentData(
+    XpContextPtr pContext, 
+    ClientPtr client,
+    int maxBufferSize)
+{
+    RasterContextPrivPtr pConPriv = (RasterContextPrivPtr)
+			 pContext->devPrivates[RasterContextPrivateIndex].ptr;
+
+    pConPriv->getDocClient = client;
+    pConPriv->getDocBufSize = maxBufferSize;
+    return Success;
+}
+
+static void
+AllocateRasterPrivates(
+    ScreenPtr pScreen)
+{
+    if(RasterGeneration != serverGeneration)
+    {
+        RasterScreenPrivateIndex = AllocateScreenPrivateIndex();
+	RasterContextPrivateIndex = XpAllocateContextPrivateIndex();
+        XpAllocateContextPrivate( RasterContextPrivateIndex, 
+			     sizeof( RasterContextPrivRec ) );
+
+        RasterGeneration = serverGeneration;
+    }
+    pScreen->devPrivates[RasterScreenPrivateIndex].ptr = (pointer)Xalloc(
+                sizeof(RasterScreenPrivRec));
+}
+
+/*
+ * RasterChangeWindowAttributes - Make sure that the window's backing
+ * store is turned on.
+ */
+static Bool 
+RasterChangeWindowAttributes(
+    WindowPtr pWin,
+    unsigned long mask)
+{
+    Bool status = Success;
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    RasterScreenPrivPtr pScreenPriv = (RasterScreenPrivPtr) 
+		     pScreen->devPrivates[RasterScreenPrivateIndex].ptr;
+
+    if(pWin->backingStore == NotUseful)
+    {
+	pWin->backingStore = WhenMapped;
+	mask |= CWBackingStore;
+    }
+
+    if(pScreenPriv->ChangeWindowAttributes != NULL)
+    {
+        pScreen->ChangeWindowAttributes = pScreenPriv->ChangeWindowAttributes;
+        status = pScreen->ChangeWindowAttributes(pWin, mask);
+        pScreen->ChangeWindowAttributes = RasterChangeWindowAttributes;
+    }
+    return status;
+}
+
+/*
+ * RasterValidateDocFormats - Inspects the files available in the 
+ * ddx-config/XP-RASTER directory to find the names of PDLs for which
+ * we have processing commands.  These names are then intersected with
+ * the contents of the printer's document-formats-supported attribute,
+ * and the result is stored back into document-formats-supported.  
+ * We have hard-coded knowledge of how to produce PS, so we always 
+ * leave that in, if it's listed in document-formats-supported, 
+ * even if we don't have a configuration file.  If there is a 
+ * configuration file for PS, then its contents will override our default.
+ */
+static void
+RasterValidateDocFormats(
+     XpContextPtr pCon)
+{
+}
+
+/*
+ * RasterValidateAttrs - Inspects and Corrects the attribute values
+ * in the specified context.
+ */
+static void
+RasterValidateAttrs(
+     XpContextPtr pCon)
+{
+    RasterValidateDocFormats(pCon);
+    XpValidatePrinterPool(pCon, &RasterValidatePoolsRec);
+    XpValidateJobPool(pCon, &RasterValidatePoolsRec);
+    XpValidateDocumentPool(pCon, &RasterValidatePoolsRec);
+}
+    
+/*
+ * RasterInitContext - Establish the appropriate values for a
+ * PrintContext used with the Raster Driver.
+ */
+static char DOC_ATT_SUPP[]="document-attributes-supported:\tdefault-medium document-format";
+static char JOB_ATT_SUPP[]="job-attributes-supported:\t";
+static char DDX_DIR[]="ddx-config";
+
+static int
+RasterInitContext(
+     XpContextPtr pCon)
+{
+    char *configFileName, *val, *attrStr;
+    RasterContextPrivPtr pConPriv;
+    XpDriverFuncsPtr pFuncs;
+    
+    /*
+     * Initialize the attribute store for this printer.
+     */
+    XpInitAttributes( pCon );
+
+    /*
+     * Validate the attributes
+     */
+    RasterValidateAttrs( pCon );
+
+
+    /*
+     * Initialize the function pointers
+     */
+    pFuncs = &( pCon->funcs );
+    pFuncs->StartJob = StartJob;
+    pFuncs->EndJob = EndJob;
+    pFuncs->StartDoc = StartDoc;
+    pFuncs->EndDoc = EndDoc;
+    pFuncs->StartPage = StartPage;
+    pFuncs->EndPage = EndPage;
+    pFuncs->PutDocumentData = DocumentData;
+    pFuncs->GetDocumentData = GetDocumentData;
+    pFuncs->DestroyContext = RasterDestroyContext;
+    pFuncs->GetAttributes = RasterGetAttributes;
+    pFuncs->GetOneAttribute = RasterGetOneAttribute;
+    pFuncs->SetAttributes = RasterSetAttributes;
+    pFuncs->AugmentAttributes = RasterAugmentAttributes;
+    pFuncs->GetMediumDimensions = RasterMediumDimensions;
+    pFuncs->GetReproducibleArea = RasterReproducibleArea;
+    
+    /*
+     * Set up the context privates
+     */
+    pConPriv = (RasterContextPrivPtr)
+      pCon->devPrivates[RasterContextPrivateIndex].ptr;
+    
+    pConPriv->jobFileName = (char *)NULL;
+    pConPriv->pageFileName = (char *)NULL;
+    pConPriv->preRasterFileName = (char *)NULL;
+    pConPriv->postRasterFileName = (char *)NULL;
+    pConPriv->noRasterFileName = (char *)NULL;
+    pConPriv->pJobFile = (FILE *)NULL;
+    pConPriv->pPageFile = (FILE *)NULL;
+    pConPriv->pPreRasterFile = (FILE *)NULL;
+    pConPriv->pPostRasterFile = (FILE *)NULL;
+    pConPriv->pNoRasterFile = (FILE *)NULL;
+
+    pConPriv->getDocClient = (ClientPtr)NULL;
+    pConPriv->getDocBufSize = 0;
+
+    /*
+     * Get the configuration information for the context's printer
+     */
+    configFileName = XpGetOneAttribute( pCon, XPPrinterAttr,
+				       "xp-ddx-config-file-name" );
+    if(configFileName && strlen(configFileName))
+    {
+        if( configFileName[0] == '/' )
+            pConPriv->config = XrmGetFileDatabase( configFileName );
+        else
+        {
+	    char *configDir, *configFilePath;
+
+	    configDir = XpGetConfigDir(FALSE);
+            configFilePath = (char *)malloc((strlen(configDir) +
+					     strlen(DDX_DIR) +
+					     strlen(RASTER_DRIV_NAME) +
+					     strlen(configFileName) +
+					     4)* sizeof(char));
+	    sprintf(configFilePath, "%s/%s/%s/%s", configDir, DDX_DIR,
+		    RASTER_DRIV_NAME, configFileName);
+	    pConPriv->config = XrmGetFileDatabase(configFilePath);
+	    free(configDir);
+	    free(configFilePath);
+        }
+    }
+    else
+	pConPriv->config = (XrmDatabase)NULL;
+
+    /*
+     * Add our own attribute initialization
+     */
+    /*
+     * document-attributes-supported
+     */
+    val = XpGetOneAttribute(pCon, XPServerAttr, "document-attributes-supported");
+    if((attrStr = (char *)xalloc(strlen(val) + strlen(DOC_ATT_SUPP) + 4)) == 
+       (char *)NULL)
+	return BadAlloc;
+    sprintf(attrStr, "*%s %s", DOC_ATT_SUPP, val);
+    XpAugmentAttributes(pCon, XPPrinterAttr, attrStr);
+    xfree(attrStr);
+
+    /*
+     * job-attributes-supported
+     */
+    val = XpGetOneAttribute(pCon, XPServerAttr, "job-attributes-supported");
+    if((attrStr = (char *)xalloc(strlen(val) + strlen(JOB_ATT_SUPP) + 4)) == 
+       (char *)NULL)
+	return BadAlloc;
+    sprintf(attrStr, "*%s %s", JOB_ATT_SUPP, val);
+    XpAugmentAttributes(pCon, XPPrinterAttr, attrStr);
+    xfree(attrStr);
+
+    /*
+     * PageAttributesSupported
+     */
+    XpAugmentAttributes(pCon, XPPrinterAttr, "*xp-page-attributes-supported:");
+    
+    return Success;
+}
+
+    
+
+static Bool
+RasterDestroyContext(
+     XpContextPtr pCon)
+{
+    RasterContextPrivPtr pConPriv = (RasterContextPrivPtr)
+      pCon->devPrivates[RasterContextPrivateIndex].ptr;
+    
+    /*
+     * Clean up the temporary files
+     */
+    FreePageFiles( pConPriv );
+    
+    if( pConPriv->pJobFile != (FILE *)NULL )
+      {
+	  fclose( pConPriv->pJobFile );
+	  pConPriv->pJobFile = (FILE *)NULL;
+      }
+    if( pConPriv->jobFileName != (char *)NULL )
+      {
+	  unlink( pConPriv->jobFileName );
+	  Xfree( pConPriv->jobFileName );
+      }
+    if(pConPriv->config)
+    {
+	XrmDestroyDatabase(pConPriv->config);
+	pConPriv->config = (XrmDatabase)NULL;
+    }
+
+    XpDestroyAttributes( pCon );
+    return Success;
+}
+
+static char *
+RasterGetAttributes(
+     XpContextPtr pContext,
+     XPAttributes class)
+{
+    return XpGetAttributes( pContext, class );
+}
+
+static char *
+RasterGetOneAttribute(
+     XpContextPtr pContext,
+     XPAttributes class,
+     char *attr)
+{
+    return XpGetOneAttribute( pContext, class, attr );
+}
+
+static int 
+RasterSetAttributes(XpContextPtr pCon,
+    XPAttributes class,
+    char *attributes)
+{
+    return XpSetAttributes( pCon, class, attributes );
+}
+
+static int
+RasterAugmentAttributes(
+     XpContextPtr pCon,
+     XPAttributes class,
+     char *attributes)
+{
+    return XpAugmentAttributes( pCon, class, attributes );
+}
+
+static void
+FreePageFiles(
+    RasterContextPrivPtr pConPriv)
+{
+    if(pConPriv->pPageFile != (FILE *)NULL)
+    {
+        fclose(pConPriv->pPageFile);
+        pConPriv->pPageFile = (FILE *)NULL;
+    }
+    if(pConPriv->pageFileName != (char *)NULL)
+    {
+	unlink(pConPriv->pageFileName);
+        Xfree(pConPriv->pageFileName);
+        pConPriv->pageFileName = (char *)NULL;
+    }
+    if(pConPriv->pPreRasterFile != (FILE *)NULL)
+    {
+        fclose(pConPriv->pPreRasterFile);
+        pConPriv->pPreRasterFile = (FILE *)NULL;
+    }
+    if(pConPriv->preRasterFileName != (char *)NULL)
+    {
+	unlink(pConPriv->preRasterFileName);
+	Xfree(pConPriv->preRasterFileName);
+	pConPriv->preRasterFileName = (char *)NULL;
+    }
+    if(pConPriv->pPostRasterFile != (FILE *)NULL)
+    {
+        fclose(pConPriv->pPostRasterFile);
+        pConPriv->pPostRasterFile = (FILE *)NULL;
+    }
+    if(pConPriv->postRasterFileName != (char *)NULL)
+    {
+	unlink(pConPriv->postRasterFileName);
+	Xfree(pConPriv->postRasterFileName);
+	pConPriv->postRasterFileName = (char *)NULL;
+    }
+    if(pConPriv->pNoRasterFile != (FILE *)NULL)
+    {
+        fclose(pConPriv->pNoRasterFile);
+        pConPriv->pNoRasterFile = (FILE *)NULL;
+    }
+    if(pConPriv->noRasterFileName != (char *)NULL)
+    {
+	unlink(pConPriv->noRasterFileName);
+	Xfree(pConPriv->noRasterFileName);
+	pConPriv->noRasterFileName = (char *)NULL;
+    }
+}
+
+/*
+ * RasterCloseScreen - Call any wrapped CloseScreen function,
+ * and free the screen memory.
+ */
+static Bool 
+RasterCloseScreen(
+    int index,
+    ScreenPtr pScreen)
+{
+    Bool status = Success;
+    RasterScreenPrivPtr pScreenPriv = (RasterScreenPrivPtr) 
+		     pScreen->devPrivates[RasterScreenPrivateIndex].ptr;
+    
+    /*
+     * Call any wrapped CloseScreen proc.
+     */
+    if(pScreenPriv->CloseScreen != NULL)
+    {
+        pScreen->CloseScreen = pScreenPriv->CloseScreen;
+        status = pScreen->CloseScreen(index, pScreen);
+        pScreen->CloseScreen = RasterCloseScreen;
+    }
+
+    Xfree(pScreenPriv->pBits);
+    Xfree(pScreenPriv);
+
+    return status;
+}
+
+#include <signal.h>
+
+/* ARGSUSED */
+static void SigchldHndlr (int dummy)
+{
+    int   status;
+    int   olderrno = errno;
+    struct sigaction act;
+    sigfillset(&act.sa_mask);
+    act.sa_flags = 0;
+    act.sa_handler = SigchldHndlr;
+
+    (void) wait (&status);
+
+    /*
+     * Is this really necessary?
+     */
+    sigaction(SIGCHLD, &act, (struct sigaction *)NULL);
+    errno = olderrno;
+}
+
+/*
+ * SystemCmd provides a wrapper for the 'system' library call.  The call
+ * appears to be sensitive to the handling of SIGCHLD, so this wrapper
+ * sets the status to SIG_DFL, and then resets the established handler
+ * after system returns.
+ */
+static int
+SystemCmd(char *cmdStr)
+{
+    int status;
+    struct sigaction newAct, oldAct;
+    sigfillset(&newAct.sa_mask);
+    newAct.sa_flags = 0;
+    newAct.sa_handler = SIG_DFL;
+    sigfillset(&oldAct.sa_mask);
+    oldAct.sa_flags = 0;
+    oldAct.sa_handler = SigchldHndlr;
+
+    /*
+     * get the old handler, and set the action to IGN
+     */
+    sigaction(SIGCHLD, &newAct, &oldAct);
+
+    status = system (cmdStr);
+
+    sigaction(SIGCHLD, &oldAct, (struct sigaction *)NULL);
+    return status;
+}
+
+/*
+ * RasterMediumDimensions is installed in the GetMediumDimensions field
+ * of each raster-initialized context.
+ */
+static int
+RasterMediumDimensions(XpContextPtr pCon, 
+		       CARD16 *width,
+		       CARD16 *height)
+{
+    XpGetMediumDimensions(pCon, width, height);
+    return Success;
+}
+
+/*
+ * RasterReproducibleArea is installed in the GetReproducibleArea field
+ * of each raster-initialized context.
+ */
+static int 
+RasterReproducibleArea(XpContextPtr pCon, 
+		       xRectangle *pRect)
+{
+    XpGetReproductionArea(pCon, pRect);
+    return Success;
+}
diff --git a/nx-X11/programs/Xserver/Xprint/raster/Raster.h b/nx-X11/programs/Xserver/Xprint/raster/Raster.h
new file mode 100644
index 000000000..25da756e5
--- /dev/null
+++ b/nx-X11/programs/Xserver/Xprint/raster/Raster.h
@@ -0,0 +1,118 @@
+/* $Xorg: Raster.h,v 1.3 2000/08/17 19:48:12 cpqbld Exp $ */
+/*
+(c) Copyright 1996 Hewlett-Packard Company
+(c) Copyright 1996 International Business Machines Corp.
+(c) Copyright 1996 Sun Microsystems, Inc.
+(c) Copyright 1996 Novell, Inc.
+(c) Copyright 1996 Digital Equipment Corp.
+(c) Copyright 1996 Fujitsu Limited
+(c) Copyright 1996 Hitachi, Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the names of the copyright holders shall
+not be used in advertising or otherwise to promote the sale, use or other
+dealings in this Software without prior written authorization from said
+copyright holders.
+*/
+/*******************************************************************
+**
+**    *********************************************************
+**    *
+**    *  File:		printer/Raster.h
+**    *
+**    *  Contents:  defines and includes for the raster layer
+**    *             for a printing X server.
+**    *
+**    *  Copyright:	Copyright 1993 Hewlett-Packard Company
+**    *
+**    *********************************************************
+** 
+********************************************************************/
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#ifndef _RASTER_H_
+#define _RASTER_H_
+
+/*
+ * Some sleazes to force the XrmDB stuff into the server
+ */
+#ifndef HAVE_XPointer
+#define HAVE_XPointer 1
+typedef char *XPointer;
+#endif
+#define Status int
+#define True 1
+#define False 0
+#include "misc.h"
+#include <X11/Xfuncproto.h>
+#include <X11/Xresource.h>
+#include "attributes.h"
+
+#include <X11/extensions/Printstr.h>
+
+#define MAX_TOKEN_LEN 512
+
+#define RASTER_PRINT_PAGE_COMMAND	"_XP_RASTER_PAGE_PROC_COMMAND"
+
+#define RASTER_IN_FILE_STRING		"%(InFile)%"
+#define RASTER_OUT_FILE_STRING		"%(OutFile)%"
+
+#define RASTER_ALLOWED_COMMANDS_FILE	"printCommands"
+
+/*
+ * Defines for the "options" in DtPrintDocumentData.
+ */
+#define PRE_RASTER	"PRE-RASTER"
+#define POST_RASTER	"POST-RASTER"
+#define NO_RASTER	"NO-RASTER"
+
+
+typedef struct {
+    char *pBits;
+    CreateWindowProcPtr CreateWindow;
+    ChangeWindowAttributesProcPtr ChangeWindowAttributes;
+    DestroyWindowProcPtr DestroyWindow;
+    CloseScreenProcPtr CloseScreen;
+} RasterScreenPrivRec, *RasterScreenPrivPtr;
+
+typedef struct {
+    XrmDatabase config;
+    char *jobFileName;
+    FILE *pJobFile;
+    char *pageFileName;
+    FILE *pPageFile;
+    char *preRasterFileName; /* Pre-raster document data */
+    FILE *pPreRasterFile;
+    char *noRasterFileName; /* Raster replacement document data */
+    FILE *pNoRasterFile;
+    char *postRasterFileName; /* Post-raster document data */
+    FILE *pPostRasterFile;
+    ClientPtr getDocClient;
+    int getDocBufSize;
+} RasterContextPrivRec, *RasterContextPrivPtr;
+
+
+extern XpValidatePoolsRec RasterValidatePoolsRec;
+
+extern Bool InitializeRasterDriver(int ndx, ScreenPtr pScreen, int argc,
+                                  char **argv);
+
+#endif  /* _RASTER_H_ */
diff --git a/nx-X11/programs/Xserver/Xprint/raster/RasterAttVal.c b/nx-X11/programs/Xserver/Xprint/raster/RasterAttVal.c
new file mode 100644
index 000000000..fc00cde5a
--- /dev/null
+++ b/nx-X11/programs/Xserver/Xprint/raster/RasterAttVal.c
@@ -0,0 +1,269 @@
+/* $Xorg: RasterAttVal.c,v 1.4 2001/03/14 18:46:34 pookie Exp $ */
+/*
+(c) Copyright 1996 Hewlett-Packard Company
+(c) Copyright 1996 International Business Machines Corp.
+(c) Copyright 1996 Sun Microsystems, Inc.
+(c) Copyright 1996 Novell, Inc.
+(c) Copyright 1996 Digital Equipment Corp.
+(c) Copyright 1996 Fujitsu Limited
+(c) Copyright 1996 Hitachi, Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the names of the copyright holders shall
+not be used in advertising or otherwise to promote the sale, use or other
+dealings in this Software without prior written authorization from said
+copyright holders.
+*/
+/* $XFree86: xc/programs/Xserver/Xprint/raster/RasterAttVal.c,v 1.3 2001/10/31 22:50:29 tsi Exp $ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <stdio.h>
+#include <X11/X.h>
+#include "misc.h"
+#include "dixstruct.h"
+#include "scrnintstr.h"
+#include "screenint.h"
+#include <X11/extensions/Print.h>
+#include "Raster.h"
+
+#include "attributes.h"
+#include "AttrValid.h"
+
+/*
+ * define valid values and defaults for Printer pool
+ */
+static XpOid ValidContentOrientationsOids[] = {
+    xpoid_val_content_orientation_portrait,
+    xpoid_val_content_orientation_landscape
+};
+static XpOidList ValidContentOrientations = {
+    ValidContentOrientationsOids, XpNumber(ValidContentOrientationsOids)
+};
+
+static XpOid DefaultContentOrientationsOids[] = {
+    xpoid_val_content_orientation_portrait,
+    xpoid_val_content_orientation_landscape
+};
+static XpOidList DefaultContentOrientations = {
+    DefaultContentOrientationsOids, XpNumber(DefaultContentOrientationsOids)
+};
+
+static XpOid ValidPlexesOids[] = {
+    xpoid_val_plex_simplex
+};
+static XpOidList ValidPlexes = {
+    ValidPlexesOids, XpNumber(ValidPlexesOids)
+};
+
+static XpOid DefaultPlexesOids[] = {
+    xpoid_val_plex_simplex
+};
+static XpOidList DefaultPlexes = {
+    DefaultPlexesOids, XpNumber(DefaultPlexesOids)
+};
+
+static unsigned long ValidPrinterResolutionsCards[] = {
+    150, 300, 600
+};
+static XpOidCardList ValidPrinterResolutions = {
+    ValidPrinterResolutionsCards, XpNumber(ValidPrinterResolutionsCards)
+};
+
+static unsigned long DefaultPrinterResolutionsCards[] = {
+    300
+};
+static XpOidCardList DefaultPrinterResolutions = {
+    DefaultPrinterResolutionsCards, XpNumber(DefaultPrinterResolutionsCards)
+};
+
+static XpOid ValidListfontsModesOids[] = {
+    xpoid_val_xp_list_glyph_fonts
+};
+static XpOidList ValidListfontsModes = {
+    ValidListfontsModesOids, XpNumber(ValidListfontsModesOids)
+};
+
+static XpOid DefaultListfontsModesOids[] = {
+    xpoid_val_xp_list_glyph_fonts
+};
+static XpOidList DefaultListfontsModes = {
+    DefaultListfontsModesOids, XpNumber(DefaultListfontsModesOids)
+};
+
+static XpOid ValidSetupProvisoOids[] = {
+    xpoid_val_xp_setup_mandatory, xpoid_val_xp_setup_optional
+};
+static XpOidList ValidSetupProviso = {
+    ValidSetupProvisoOids, XpNumber(ValidSetupProvisoOids)
+};
+
+static XpOidDocFmt ValidDocFormatsSupportedFmts[] = {
+    { "Postscript", "2", NULL },
+    { "PCL", "3", NULL }
+};
+static XpOidDocFmtList ValidDocFormatsSupported = {
+    ValidDocFormatsSupportedFmts, XpNumber(ValidDocFormatsSupportedFmts)
+};
+
+static XpOidDocFmt DefaultDocFormatsSupportedFmts[] = {
+    { "Postscript", "2", NULL }
+};
+static XpOidDocFmtList DefaultDocFormatsSupported = {
+    DefaultDocFormatsSupportedFmts, XpNumber(DefaultDocFormatsSupportedFmts)
+};
+
+static XpOidDocFmtList ValidEmbeddedFormatsSupported = {
+    (XpOidDocFmt *)NULL, 0
+};
+
+static XpOidDocFmtList DefaultEmbeddedFormatsSupported = {
+    (XpOidDocFmt *)NULL, 0
+};
+
+static XpOidDocFmt ValidRawFormatsSupportedFmts[] = {
+    { "Postscript", "2", NULL },
+    { "PCL", "3", NULL }
+};
+static XpOidDocFmtList ValidRawFormatsSupported = {
+    ValidRawFormatsSupportedFmts, XpNumber(ValidRawFormatsSupportedFmts)
+};
+
+static XpOidDocFmt DefaultRawFormatsSupportedFmts[] = {
+    { "Postscript", "2", NULL }
+};
+static XpOidDocFmtList DefaultRawFormatsSupported = {
+    DefaultRawFormatsSupportedFmts, XpNumber(DefaultRawFormatsSupportedFmts)
+};
+
+static XpOidList ValidInputTrays = {
+    (XpOid *)NULL, 0
+};
+
+static XpOid ValidMediumSizesOids[] = {
+    xpoid_val_medium_size_iso_a0,
+    xpoid_val_medium_size_iso_a1,
+    xpoid_val_medium_size_iso_a2,
+    xpoid_val_medium_size_iso_a3,
+    xpoid_val_medium_size_iso_a4,
+    xpoid_val_medium_size_iso_a5,
+    xpoid_val_medium_size_iso_a6,
+    xpoid_val_medium_size_iso_a7,
+    xpoid_val_medium_size_iso_a8,
+    xpoid_val_medium_size_iso_a9,
+    xpoid_val_medium_size_iso_a10,
+    xpoid_val_medium_size_iso_b0,
+    xpoid_val_medium_size_iso_b1,
+    xpoid_val_medium_size_iso_b2,
+    xpoid_val_medium_size_iso_b3,
+    xpoid_val_medium_size_iso_b4,
+    xpoid_val_medium_size_iso_b5,
+    xpoid_val_medium_size_iso_b6,
+    xpoid_val_medium_size_iso_b7,
+    xpoid_val_medium_size_iso_b8,
+    xpoid_val_medium_size_iso_b9,
+    xpoid_val_medium_size_iso_b10,
+    xpoid_val_medium_size_na_letter,
+    xpoid_val_medium_size_na_legal,
+    xpoid_val_medium_size_executive,
+    xpoid_val_medium_size_folio,
+    xpoid_val_medium_size_invoice,
+    xpoid_val_medium_size_ledger,
+    xpoid_val_medium_size_quarto,
+    xpoid_val_medium_size_iso_c3,
+    xpoid_val_medium_size_iso_c4,
+    xpoid_val_medium_size_iso_c5,
+    xpoid_val_medium_size_iso_c6,
+    xpoid_val_medium_size_iso_designated_long,
+    xpoid_val_medium_size_na_10x13_envelope,
+    xpoid_val_medium_size_na_9x12_envelope,
+    xpoid_val_medium_size_na_number_10_envelope,
+    xpoid_val_medium_size_na_7x9_envelope,
+    xpoid_val_medium_size_na_9x11_envelope,
+    xpoid_val_medium_size_na_10x14_envelope,
+    xpoid_val_medium_size_na_number_9_envelope,
+    xpoid_val_medium_size_monarch_envelope,
+    xpoid_val_medium_size_a,
+    xpoid_val_medium_size_b,
+    xpoid_val_medium_size_c,
+    xpoid_val_medium_size_d,
+    xpoid_val_medium_size_e,
+    xpoid_val_medium_size_jis_b0,
+    xpoid_val_medium_size_jis_b1,
+    xpoid_val_medium_size_jis_b2,
+    xpoid_val_medium_size_jis_b3,
+    xpoid_val_medium_size_jis_b4,
+    xpoid_val_medium_size_jis_b5,
+    xpoid_val_medium_size_jis_b6,
+    xpoid_val_medium_size_jis_b7,
+    xpoid_val_medium_size_jis_b8,
+    xpoid_val_medium_size_jis_b9,
+    xpoid_val_medium_size_jis_b10
+};
+static XpOidList ValidMediumSizes = {
+    ValidMediumSizesOids, XpNumber(ValidMediumSizesOids)
+};
+
+static XpOidDocFmt DefaultDocumentFormat = {
+    "Postscript", "2", NULL
+};
+
+static XpOid ValidAvailableCompressionsOids[] = {
+    xpoid_val_available_compressions_0,
+    xpoid_val_available_compressions_01,
+    xpoid_val_available_compressions_02,
+    xpoid_val_available_compressions_03,
+    xpoid_val_available_compressions_012,
+    xpoid_val_available_compressions_013,
+    xpoid_val_available_compressions_023,
+    xpoid_val_available_compressions_0123
+};
+
+static XpOidList ValidAvailableCompressions = {
+    ValidAvailableCompressionsOids, XpNumber(ValidAvailableCompressionsOids)
+};
+
+static XpOid DefaultAvailableCompressionsOids[] = {
+    xpoid_val_available_compressions_0123,
+    xpoid_val_available_compressions_0
+};
+
+static XpOidList DefaultAvailableCompressions = {
+    DefaultAvailableCompressionsOids, XpNumber(DefaultAvailableCompressionsOids)
+};
+
+
+/*
+ * init struct for XpValidate*Pool
+ */
+XpValidatePoolsRec RasterValidatePoolsRec = {
+    &ValidContentOrientations, &DefaultContentOrientations,
+    &ValidDocFormatsSupported, &DefaultDocFormatsSupported,
+    &ValidInputTrays, &ValidMediumSizes,
+    &ValidPlexes, &DefaultPlexes,
+    &ValidPrinterResolutions, &DefaultPrinterResolutions,
+    &ValidEmbeddedFormatsSupported, &DefaultEmbeddedFormatsSupported,
+    &ValidListfontsModes, &DefaultListfontsModes,
+    &ValidRawFormatsSupported, &DefaultRawFormatsSupported,
+    &ValidSetupProviso,
+    &DefaultDocumentFormat,
+    &ValidAvailableCompressions, &DefaultAvailableCompressions
+};