R6.6 is the Xorg base-lineXORG-MAIN

22 files changed, 7942 insertions, 0 deletions

diff --git a/Xprint/ps/Ps.h b/Xprint/ps/Ps.h
new file mode 100644
index 000000000..942e8f9f8
--- /dev/null
+++ b/Xprint/ps/Ps.h
@@ -0,0 +1,520 @@
+/* $Xorg: Ps.h,v 1.5 2001/02/09 02:04:35 xorgcvs Exp $ */
+/*
+
+Copyright 1996, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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
+OPEN GROUP 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 name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+/*
+ * (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:		Ps.h
+**    *
+**    *  Contents:  defines and includes for the Ps driver
+**    *             for a printing X server.
+**    *
+**    *  Created By:	Roger Helmendach (Liberty Systems)
+**    *
+**    *  Copyright:	Copyright 1996 The Open Group, Inc.
+**    *
+**    *********************************************************
+** 
+********************************************************************/
+
+#ifndef _PS_H_
+#define _PS_H_
+
+#include <stdio.h>
+
+#ifdef abs
+#undef abs   /* this is because of a non-Spec1170ness in misc.h */
+#endif
+#include <stdlib.h>
+#include "scrnintstr.h"
+#include "dix.h"
+
+/*
+#include "X.h" 
+#include "Xproto.h"
+#include "Xatom.h"
+#include "misc.h"
+#include "screenint.h"
+#include "colormapst.h"
+#include "windowstr.h"
+#include "propertyst.h"
+#include "servermd.h"*/    /* needed for IMAGE_BUFSIZE */
+
+#include "PsDef.h"
+#include "psout.h"
+
+#define _XP_PRINT_SERVER_
+#include "Print.h"
+#include "extensions/Printstr.h"
+#undef _XP_PRINT_SERVER_
+
+#include "miscstruct.h"
+#include "fontstruct.h"
+#include "dixfontstr.h"
+#include "gcstruct.h"
+
+/*
+ *  Some sleazes to force the XrmDB stuff into the server
+ */
+typedef char *XPointer;
+#define Status int
+#define True 1
+#define False 0
+#include "misc.h"
+#include <Xfuncproto.h>
+#include "../Xresource.h"
+
+/*
+ *  Public index variables from PsInit.c
+ */
+
+extern int PsScreenPrivateIndex;
+extern int PsWindowPrivateIndex;
+extern int PsContextPrivateIndex;
+extern int PsPixmapPrivateIndex;
+extern int PsGCPrivateIndex;
+
+/*
+ *  Display list structures
+ */
+
+#define DPY_BLOCKSIZE 4096
+
+typedef struct
+{
+  int      mode;
+  int      nPoints;
+  xPoint  *pPoints;
+} PsPolyPointsRec;
+
+typedef struct
+{
+  int        nSegments;
+  xSegment  *pSegments;
+} PsSegmentsRec;
+
+typedef struct
+{
+  int          nRects;
+  xRectangle  *pRects;
+} PsRectanglesRec;
+
+typedef struct
+{
+  int     nArcs;
+  xArc   *pArcs;
+} PsArcsRec;
+
+typedef struct
+{
+  int     x;
+  int     y;
+  int     count;
+  char   *string;
+} PsText8Rec;
+
+typedef struct
+{
+  int             x;
+  int             y;
+  int             count;
+  unsigned short *string;
+} PsText16Rec;
+
+typedef struct
+{
+  int     depth;
+  int     x;
+  int     y;
+  int     w;
+  int     h;
+  int     leftPad;
+  int     format;
+  int     res;		/* image resolution */
+  char   *pData;
+} PsImageRec;
+
+typedef struct
+{
+  int   x;
+  int   y;
+  int   w;
+  int   h;
+} PsFrameRec;
+
+typedef enum
+{
+  PolyPointCmd,
+  PolyLineCmd,
+  PolySegmentCmd,
+  PolyRectangleCmd,
+  FillPolygonCmd,
+  PolyFillRectCmd,
+  PolyArcCmd,
+  PolyFillArcCmd,
+  Text8Cmd,
+  Text16Cmd,
+  TextI8Cmd,
+  TextI16Cmd,
+  PutImageCmd,
+  BeginFrameCmd,
+  EndFrameCmd
+} DisplayElmType;
+
+typedef struct _DisplayElmRec
+{
+  DisplayElmType  type;
+  GCPtr           gc;
+  union
+  {
+    PsPolyPointsRec  polyPts;
+    PsSegmentsRec    segments;
+    PsRectanglesRec  rects;
+    PsArcsRec        arcs;
+    PsText8Rec       text8;
+    PsText16Rec      text16;
+    PsImageRec       image;
+    PsFrameRec       frame;
+  } c;
+} DisplayElmRec;
+
+typedef DisplayElmRec *DisplayElmPtr;
+
+typedef struct _DisplayListRec
+{
+  struct _DisplayListRec *next;
+  int                     nelms;
+  DisplayElmRec           elms[DPY_BLOCKSIZE];
+} DisplayListRec;
+
+typedef DisplayListRec *DisplayListPtr;
+
+/*
+ *  Private structures
+ */
+
+typedef struct
+{
+  XrmDatabase   resDB;
+  ColormapPtr   CMap;
+  Bool        (*DestroyWindow)();
+} PsScreenPrivRec, *PsScreenPrivPtr;
+
+typedef struct
+{
+  char              *jobFileName;
+  FILE              *pJobFile;
+  GC                 lastGC;
+  unsigned char     *dash;
+  int                validGC;
+  ClientPtr          getDocClient;
+  int                getDocBufSize;
+  PsOutPtr           pPsOut;
+} PsContextPrivRec, *PsContextPrivPtr;
+
+typedef struct
+{
+  int          validContext;
+  XpContextPtr context;
+} PsWindowPrivRec, *PsWindowPrivPtr;
+
+typedef struct
+{
+  unsigned  freeCompClip;
+  RegionPtr pCompositeClip;
+} PsGCPrivRec, *PsGCPrivPtr;
+
+typedef struct
+{
+  XpContextPtr    context;
+  GC              lastGC;
+  int             validGC;
+  DisplayListPtr  dispList;
+} PsPixmapPrivRec, *PsPixmapPrivPtr;
+
+/*
+ *  Macro functions
+ */
+
+#define SEND_PS(f,c) fwrite( c, sizeof( char ), strlen( c ), f )
+#define MIN(a,b) (((a)<(b))?(a):(b))
+#define MAX(a,b) (((a)>(b))?(a):(b))
+
+/*
+ *  Functions in PsInit.c
+ */
+
+extern Bool InitializePsDriver(int ndx, ScreenPtr pScreen, int argc,
+    char **argv);
+static Bool         PsDestroyContext(XpContextPtr pCon);
+extern XpContextPtr PsGetContextFromWindow(WindowPtr win);
+
+/*
+ *  Functions in PsPrint.c
+ */
+
+extern int PsStartJob(XpContextPtr pCon, Bool sendClientData, ClientPtr client);
+extern int PsEndJob(XpContextPtr pCon, Bool cancel);
+extern int PsStartPage(XpContextPtr pCon, WindowPtr pWin);
+extern int PsEndPage(XpContextPtr pCon, WindowPtr pWin);
+extern int PsStartDoc(XpContextPtr pCon, XPDocumentType type);
+extern int PsEndDoc(XpContextPtr pCon, Bool cancel);
+extern int PsDocumentData(XpContextPtr pCon, DrawablePtr pDraw, char *pData,
+    int len_data, char *pFmt, int len_fmt, char *pOpt, int len_opt,
+    ClientPtr client);
+extern int PsGetDocumentData(XpContextPtr pCon, ClientPtr client,
+    int maxBufferSize);
+
+/*
+ *  Functions in PsGC.c
+ */
+
+extern Bool PsCreateGC(GCPtr pGC);
+static int  PsGetDrawablePrivateStuff(DrawablePtr pDrawable, GC *gc,
+                                      unsigned long *valid, PsOutPtr *psOut,
+                                      ColormapPtr *cMap);
+extern int  PsUpdateDrawableGC(GCPtr pGC, DrawablePtr pDrawable,
+                               PsOutPtr *psOut, ColormapPtr *cMap);
+extern void PsValidateGC(GCPtr pGC, unsigned long changes, DrawablePtr pDrawable);
+extern void PsChangeGC(GCPtr pGC, unsigned long changes);
+extern void PsCopyGC(GCPtr pGCSrc, unsigned long mask, GCPtr pGCDst);
+extern void PsDestroyGC(GCPtr pGC);
+extern void PsChangeClip(GCPtr pGC, int type, pointer pValue, int nrects);
+extern void PsDestroyClip(GCPtr pGC);
+extern void PsCopyClip(GCPtr pgcDst, GCPtr pgcSrc);
+
+extern GCPtr PsCreateAndCopyGC(DrawablePtr pDrawable, GCPtr pSrc);
+
+/*
+ *  Functions in PsMisc.c
+ */
+
+extern void PsQueryBestSize(int type, short *pwidth, short *pheight,
+                            ScreenPtr pScreen);
+extern Bool PsCloseScreen(int index, ScreenPtr pScreen);
+extern void PsLineAttrs(PsOutPtr psOut, GCPtr pGC, ColormapPtr cMap);
+extern int PsGetMediumDimensions(
+    XpContextPtr pCon,
+    CARD16 *pWidth,
+    CARD16 *pHeight);
+extern int PsGetReproducibleArea(
+    XpContextPtr pCon,
+    xRectangle *pRect);
+extern int PsSetImageResolution(
+    XpContextPtr pCon,
+    int imageRes,
+    Bool *status);
+
+/*
+ *  Functions in PsSpans.c
+ */
+
+extern void PsFillSpans(DrawablePtr pDrawable, GCPtr pGC, int nSpans,
+                        DDXPointPtr pPoints, int *pWidths, int fSorted);
+extern void PsSetSpans(DrawablePtr pDrawable, GCPtr pGC, char *pSrc,
+                       DDXPointPtr pPoints, int *pWidths, int nSpans,
+                       int fSorted);
+
+/*
+ *  Functions in PsArea.c
+ */
+
+extern void PsPutScaledImage(DrawablePtr pDrawable, GCPtr pGC, int depth,
+                       int x, int y, int w, int h, int leftPad, int format,
+                       int imageRes, char *pImage);
+extern void PsPutImage(DrawablePtr pDrawable, GCPtr pGC, int depth,
+                       int x, int y, int w, int h, int leftPad, int format,
+                       char *pImage);
+extern RegionPtr PsCopyArea(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
+                            int srcx, int srcy, int width, int height,
+                            int dstx, int dsty);
+extern RegionPtr PsCopyPlane(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
+                             int srcx, int srcy, int width, int height,
+                             int dstx, int dsty, unsigned long plane);
+
+/*
+ *  Functions in PsPixel.c
+ */
+
+extern void PsPolyPoint(DrawablePtr pDrawable, GCPtr pGC, int mode,
+                       int nPoints, xPoint *pPoints);
+extern void PsPushPixels(GCPtr pGC, PixmapPtr pBitmap, DrawablePtr pDrawable,
+                         int width, int height, int x, int y);
+
+/*
+ *  Functions in PsLine.c
+ */
+
+extern void PsPolyLine(DrawablePtr pDrawable, GCPtr pGC, int mode,
+                       int nPoints, xPoint *pPoints);
+extern void PsPolySegment(DrawablePtr pDrawable, GCPtr pGC, int nSegments,
+                          xSegment *pSegments);
+
+/*
+ *  Functions in PsPolygon.c
+ */
+
+extern void PsPolyRectangle(DrawablePtr pDrawable, GCPtr pGC, int nRects,
+                            xRectangle *pRects);
+extern void PsFillPolygon(DrawablePtr pDrawable, GCPtr pGC, int shape,
+                          int mode, int nPoints, DDXPointPtr pPoints);
+extern void PsPolyFillRect(DrawablePtr pDrawable, GCPtr pGC, int nRects,
+                          xRectangle *pRects);
+
+/*
+ *  Functions in PsPolygon.c
+ */
+
+extern void PsPolyArc(DrawablePtr pDrawable, GCPtr pGC, int nArcs,
+                            xArc *pArcs);
+extern void PsPolyFillArc(DrawablePtr pDrawable, GCPtr pGC, int nArcs,
+                            xArc *pArcs);
+
+/*
+ *  Functions in PsText.c
+ */
+
+extern int  PsPolyText8(DrawablePtr pDrawable, GCPtr pGC, int x, int y,
+                        int count, char *string);
+extern int  PsPolyText16(DrawablePtr pDrawable, GCPtr pGC, int x, int y,
+                         int count, unsigned short *string);
+extern void PsImageText8(DrawablePtr pDrawable, GCPtr pGC, int x, int y,
+                         int count, char *string);
+extern void PsImageText16(DrawablePtr pDrawable, GCPtr pGC, int x, int y,
+                          int count, unsigned short *string);
+extern void PsImageGlyphBlt(DrawablePtr pDrawable, GCPtr pGC, int x, int y,
+                            unsigned int nGlyphs, CharInfoPtr *pCharInfo,
+                            pointer pGlyphBase);
+extern void PsPolyGlyphBlt(DrawablePtr pDrawable, GCPtr pGC, int x, int y,
+                           unsigned int nGlyphs, CharInfoPtr *pCharInfo,
+                           pointer pGlyphBase);
+
+/*
+ *  Functions in PsWindow.c
+ */
+
+extern Bool PsCreateWindow(WindowPtr pWin);
+extern Bool PsMapWindow(WindowPtr pWin);
+extern Bool PsPositionWindow(WindowPtr pWin, int x, int y);
+extern Bool PsUnmapWindow(WindowPtr pWin);
+extern void PsCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg,
+                         RegionPtr prgnSrc);
+extern Bool PsChangeWindowAttributes(WindowPtr pWin, unsigned long mask);
+extern void PsPaintWindow(WindowPtr pWin, RegionPtr pRegion, int what);
+extern Bool PsDestroyWindow(WindowPtr pWin);
+
+/*
+ *  Functions in PsFonts.c
+ */
+
+extern Bool PsRealizeFont(ScreenPtr pscr, FontPtr pFont);
+extern Bool PsUnrealizeFont(ScreenPtr pscr, FontPtr pFont);
+extern char *PsGetFontName(FontPtr pFont);
+extern int PsGetFontSize(FontPtr pFont, float *mtx);
+extern char *PsGetPSFontName(FontPtr pFont);
+extern int PsIsISOLatin1Encoding(FontPtr pFont);
+
+/*
+ *  Functions in PsAttr.c
+ */
+
+extern char *PsGetAttributes(XpContextPtr pCon, XPAttributes pool);
+extern char *PsGetOneAttribute(XpContextPtr pCon, XPAttributes pool,
+                               char *attr);
+extern int PsAugmentAttributes(XpContextPtr pCon, XPAttributes pool,
+                               char *attrs);
+extern int PsSetAttributes(XpContextPtr pCon, XPAttributes pool, char *attrs);
+
+/*
+ *  Functions in PsColor.c
+ */
+
+extern Bool PsCreateColormap(ColormapPtr pColor);
+extern void PsDestroyColormap(ColormapPtr pColor);
+extern void PsInstallColormap(ColormapPtr pColor);
+extern void PsUninstallColormap(ColormapPtr pColor);
+extern int  PsListInstalledColormaps(ScreenPtr pScreen, XID *pCmapList);
+extern void PsStoreColors(ColormapPtr pColor, int ndef, xColorItem *pdefs);
+extern void PsResolveColor(unsigned short *pRed, unsigned short *pGreen,
+                           unsigned short *pBlue, VisualPtr pVisual);
+extern int  PsGetPixelColor(ColormapPtr cMap, int pixval);
+extern void PsSetFillColor(DrawablePtr pDrawable, GCPtr pGC, PsOutPtr psOut,
+                           ColormapPtr cMap);
+
+/*
+ *  Functions in PsPixmap.c
+ */
+
+extern PixmapPtr PsCreatePixmap(ScreenPtr pScreen, int width, int height,
+                                int depth);
+extern Bool PsDestroyPixmap(PixmapPtr pPixmap);
+extern DisplayListPtr PsGetFreeDisplayBlock(PsPixmapPrivPtr priv);
+extern void PsReplayPixmap(PixmapPtr pix, DrawablePtr pDrawable);
+extern int PsCloneDisplayElm(PixmapPtr dst,
+			     DisplayElmPtr elm, DisplayElmPtr newElm,
+                             int xoff, int yoff);
+extern void PsCopyDisplayList(PixmapPtr src, PixmapPtr dst, int xoff,
+                              int yoff, int x, int y, int w, int h);
+extern PsElmPtr PsCreateFillElementList(PixmapPtr pix, int *nElms);
+extern PsElmPtr PsCloneFillElementList(int nElms, PsElmPtr elms);
+extern void PsDestroyFillElementList(int nElms, PsElmPtr elms);
+
+#endif  /* _PS_H_ */
diff --git a/Xprint/ps/PsArc.c b/Xprint/ps/PsArc.c
new file mode 100644
index 000000000..76804bb18
--- /dev/null
+++ b/Xprint/ps/PsArc.c
@@ -0,0 +1,178 @@
+/* $Xorg: PsArc.c,v 1.4 2001/02/09 02:04:35 xorgcvs Exp $ */
+/*
+
+Copyright 1996, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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
+OPEN GROUP 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 name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+/*
+ * (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:		PsArc.c
+**    *
+**    *  Contents:	Arc-drawing code for the PS DDX driver
+**    *
+**    *  Created By:	Roger Helmendach (Liberty Systems)
+**    *
+**    *  Copyright:	Copyright 1996 The Open Group, Inc.
+**    *
+**    *********************************************************
+** 
+********************************************************************/
+
+#include <stdio.h>
+
+#include "Ps.h"
+#include "gcstruct.h"
+#include "windowstr.h"
+
+void
+PsPolyArc(
+  DrawablePtr pDrawable,
+  GCPtr       pGC,
+  int         nArcs,
+  xArc       *pArcs)
+{
+  if( pDrawable->type==DRAWABLE_PIXMAP )
+  {
+    DisplayElmPtr   elm;
+    PixmapPtr       pix  = (PixmapPtr)pDrawable;
+    PsPixmapPrivPtr priv = (PsPixmapPrivPtr)pix->devPrivate.ptr;
+    DisplayListPtr  disp;
+    GCPtr           gc;
+
+    if ((gc = PsCreateAndCopyGC(pDrawable, pGC)) == NULL) return;
+
+    disp = PsGetFreeDisplayBlock(priv);
+
+    elm  = &disp->elms[disp->nelms];
+    elm->type = PolyArcCmd;
+    elm->gc   = gc;
+    elm->c.arcs.nArcs = nArcs;
+    elm->c.arcs.pArcs = (xArc *)xalloc(nArcs*sizeof(xArc));
+    memcpy(elm->c.arcs.pArcs, pArcs, nArcs*sizeof(xArc));
+    disp->nelms += 1;
+  }
+  else
+  {
+    int         i;
+    PsOutPtr    psOut;
+    ColormapPtr cMap;
+
+    if( PsUpdateDrawableGC(pGC, pDrawable, &psOut, &cMap)==FALSE ) return;
+    PsOut_Offset(psOut, pDrawable->x, pDrawable->y);
+    PsOut_Color(psOut, PsGetPixelColor(cMap, pGC->fgPixel));
+    PsLineAttrs(psOut, pGC, cMap);
+    for( i=0 ; i<nArcs ; i++ )
+    {
+      PsOut_DrawArc(psOut, (int)pArcs[i].x, (int)pArcs[i].y,
+                    (int)pArcs[i].width, (int)pArcs[i].height,
+                    (float)pArcs[i].angle1/64.,
+                    (float)pArcs[i].angle2/64.);
+    }
+  }
+}
+
+void
+PsPolyFillArc(
+  DrawablePtr pDrawable,
+  GCPtr       pGC,
+  int         nArcs,
+  xArc       *pArcs)
+{
+  if( pDrawable->type==DRAWABLE_PIXMAP )
+  {
+    DisplayElmPtr   elm;
+    PixmapPtr       pix  = (PixmapPtr)pDrawable;
+    PsPixmapPrivPtr priv = (PsPixmapPrivPtr)pix->devPrivate.ptr;
+    DisplayListPtr  disp;
+    GCPtr           gc;
+
+    if ((gc = PsCreateAndCopyGC(pDrawable, pGC)) == NULL) return;
+
+    disp = PsGetFreeDisplayBlock(priv);
+
+    elm  = &disp->elms[disp->nelms];
+    elm->type = PolyFillArcCmd;
+    elm->gc   = gc;
+    elm->c.arcs.nArcs = nArcs;
+    elm->c.arcs.pArcs = (xArc *)xalloc(nArcs*sizeof(xArc));
+    memcpy(elm->c.arcs.pArcs, pArcs, nArcs*sizeof(xArc));
+    disp->nelms += 1;
+  }
+  else
+  {
+    int         i;
+    PsOutPtr    psOut;
+    PsArcEnum   styl;
+    ColormapPtr cMap;
+
+    if( PsUpdateDrawableGC(pGC, pDrawable, &psOut, &cMap)==FALSE ) return;
+    PsOut_Offset(psOut, pDrawable->x, pDrawable->y);
+    PsSetFillColor(pDrawable, pGC, psOut, cMap);
+    PsLineAttrs(psOut, pGC, cMap);
+    if( pGC->arcMode==ArcChord ) styl = PsChord;
+    else                         styl = PsPieSlice;
+    for( i=0 ; i<nArcs ; i++ )
+    {
+      PsOut_FillArc(psOut, (int)pArcs[i].x, (int)pArcs[i].y,
+                    (int)pArcs[i].width, (int)pArcs[i].height,
+                    (float)pArcs[i].angle1/64.,
+                    (float)pArcs[i].angle2/64., styl);
+    }
+  }
+}
diff --git a/Xprint/ps/PsArea.c b/Xprint/ps/PsArea.c
new file mode 100644
index 000000000..134686a87
--- /dev/null
+++ b/Xprint/ps/PsArea.c
@@ -0,0 +1,464 @@
+/* $Xorg: PsArea.c,v 1.6 2001/03/14 18:27:44 pookie Exp $ */
+/*
+
+Copyright 1996, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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
+OPEN GROUP 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 name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+/*
+ * (c) Copyright 1996 Hewlett-Packard Company
+ * (c) Copyright 1996 International Business Machines Corp.
+ * (c) Copyright 1996, 2000 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:		PsArea.c
+**    *
+**    *  Contents:	Image and Area functions for the PS DDX driver
+**    *
+**    *  Created By:	Roger Helmendach (Liberty Systems)
+**    *
+**    *  Copyright:	Copyright 1996 The Open Group, Inc.
+**    *
+**    *********************************************************
+** 
+********************************************************************/
+
+#include "Ps.h"
+#include "gcstruct.h"
+#include "windowstr.h"
+
+void
+PsPutScaledImage(DrawablePtr pDrawable, GCPtr pGC, int depth, int x, int y,
+           int w, int h, int leftPad, int format, int imageRes, char *pImage)
+{
+  if( pDrawable->type==DRAWABLE_PIXMAP )
+  {
+    int             size = PixmapBytePad(w, depth)*h;
+    DisplayElmPtr   elm;
+    PixmapPtr       pix  = (PixmapPtr)pDrawable;
+    PsPixmapPrivPtr priv = (PsPixmapPrivPtr)pix->devPrivate.ptr;
+    DisplayListPtr  disp;
+    GCPtr           gc;   
+
+    if ((gc = PsCreateAndCopyGC(pDrawable, pGC)) == NULL) return;
+
+    disp = PsGetFreeDisplayBlock(priv);
+    elm  = &disp->elms[disp->nelms];
+    elm->type = PutImageCmd;
+    elm->gc = gc;
+    elm->c.image.depth   = depth;
+    elm->c.image.x       = x;
+    elm->c.image.y       = y;
+    elm->c.image.w       = w;
+    elm->c.image.h       = h;
+    elm->c.image.leftPad = leftPad;
+    elm->c.image.format  = format;
+    elm->c.image.res     = imageRes;
+    elm->c.image.pData   = (char *)xalloc(size);
+    memcpy(elm->c.image.pData, pImage, size);
+    disp->nelms += 1;
+  }
+  else
+  {
+    int          i, j;
+    int          r, c;
+    int          swap;
+    char        *pt;
+    PsOutPtr     psOut;
+    ColormapPtr  cMap;
+    int          pageRes, sw, sh;
+
+    if( PsUpdateDrawableGC(pGC, pDrawable, &psOut, &cMap)==FALSE ) return;
+    if (!imageRes) {
+	sw = w;
+	sh = h;
+    } else {
+	pageRes = XpGetResolution(XpGetPrintContext(requestingClient));
+	sw = (float)w * (float)pageRes / (float)imageRes + 0.5;
+	sh = (float)h * (float)pageRes / (float)imageRes + 0.5;
+    }
+    PsOut_Offset(psOut, pDrawable->x, pDrawable->y);
+    pt = (char *)(&i); i = 1; if( pt[0]=='\001' ) swap = 1; else swap = 0;
+
+    if( depth==24 )
+    {
+      PsOut_BeginImage(psOut, 0, 0, x, y, w, h, sw, sh, 3);
+      if( format==XYPixmap )
+      {
+        int   rowsiz = PixmapBytePad(w, depth);
+        char *planes[3];
+        planes[0] = pImage;
+        planes[1] = &pImage[rowsiz*h];
+        planes[2] = &pImage[rowsiz*h*2];
+        for( r=0 ; r<h ; r++ )
+        {
+          char *pt[3];
+          for( i=0 ; i<3 ;  i++ ) pt[i] = &planes[i][rowsiz*r];
+          for( c=0 ; c<w ; c++ )
+          {
+            for( i=0 ; i<3 ; i++ )
+              { PsOut_OutImageBytes(psOut, 1, &pt[i][c]); pt[i]++; }
+          }
+        }
+      }
+      else if( format==ZPixmap )
+      {
+        int  rowsiz = PixmapBytePad(w, depth);
+        for( r=0 ; r<h ; r++ )
+        {
+          char *pt = &pImage[rowsiz*r];
+          for( c=0 ; c<w ; c++,pt+=4 )
+          {
+            if( swap )
+            {
+              char tmp[4];
+              tmp[0] = pt[3]; tmp[1] = pt[2]; tmp[2] = pt[1]; tmp[3] = pt[0];
+              PsOut_OutImageBytes(psOut, 3, &tmp[1]);
+            }
+            else
+              PsOut_OutImageBytes(psOut, 3, &pt[1]);
+          }
+        }
+      }
+      else goto error;
+      PsOut_EndImage(psOut);
+    }
+    else if( depth==8 )
+    {
+      int  rowsiz = PixmapBytePad(w, depth);
+      PsOut_BeginImage(psOut, 0, 0, x, y, w, h, sw, sh, 3);
+      for( r=0 ; r<h ; r++ )
+      {
+        char *pt = &pImage[rowsiz*r];
+        for( c=0 ; c<w ; c++,pt++ )
+        {
+          int   val = PsGetPixelColor(cMap, (int)(*pt)&0xFF);
+          char *ipt = (char *)&val;
+          if( swap )
+          {
+            char tmp[4];
+            tmp[0] = ipt[3]; tmp[1] = ipt[2]; tmp[2] = ipt[1]; tmp[3] = ipt[0];
+            PsOut_OutImageBytes(psOut, 3, &tmp[1]);
+          }
+          else
+            PsOut_OutImageBytes(psOut, 3, &ipt[1]);
+        }
+      }
+      PsOut_EndImage(psOut);
+    }
+    else if( depth==1 )
+    {
+      {
+        int  rowsiz = BitmapBytePad(w);
+        int  psrsiz = (w+7)/8;
+        PsOut_BeginImage(psOut, PsGetPixelColor(cMap, pGC->bgPixel),
+                         PsGetPixelColor(cMap, pGC->fgPixel),
+			 x, y, w, h, sw, sh, 1);
+        for( r=0 ; r<h ; r++ )
+        {
+          char *pt = &pImage[rowsiz*r];
+          for( i=0 ; i<psrsiz ; i++ )
+          {
+            int  iv_, iv = (int)pt[i]&0xFF;
+            char c;
+            if( swap )
+              { for( j=0,iv_=0 ; j<8 ; j++ ) iv_ |= (((iv>>j)&1)<<(7-j)); }
+            else
+              iv_ = iv;
+            c = iv_;
+            PsOut_OutImageBytes(psOut, 1, &c);
+          }
+        }
+        PsOut_EndImage(psOut);
+      }
+    }
+  }
+error:
+  return;
+}
+
+void
+PsPutScaledImageIM(DrawablePtr pDrawable, GCPtr pGC, int depth, int x, int y,
+           int w, int h, int leftPad, int format, int imageRes, char *pImage)
+{
+  if( pDrawable->type==DRAWABLE_PIXMAP )
+  {
+    int             size = PixmapBytePad(w, depth)*h;
+    DisplayElmPtr   elm;
+    PixmapPtr       pix  = (PixmapPtr)pDrawable;
+    PsPixmapPrivPtr priv = (PsPixmapPrivPtr)pix->devPrivate.ptr;
+    DisplayListPtr  disp;
+    GCPtr           gc;
+
+    if ((gc = PsCreateAndCopyGC(pDrawable, pGC)) == NULL) return;
+
+    disp = PsGetFreeDisplayBlock(priv);
+    elm  = &disp->elms[disp->nelms];
+    elm->type = PutImageCmd;
+    elm->gc = gc;
+    elm->c.image.depth   = depth;
+    elm->c.image.x       = x;
+    elm->c.image.y       = y;
+    elm->c.image.w       = w;
+    elm->c.image.h       = h;
+    elm->c.image.leftPad = leftPad;
+    elm->c.image.format  = format;
+    elm->c.image.res     = imageRes;
+    elm->c.image.pData   = (char *)xalloc(size);
+    memcpy(elm->c.image.pData, pImage, size);
+    disp->nelms += 1;
+  }
+  else
+  {
+    int          i, j;
+    int          r, c;
+    int          swap;
+    char        *pt;
+    PsOutPtr     psOut;
+    ColormapPtr  cMap;
+    int          pageRes, sw, sh;
+#ifdef BM_CACHE
+    long	 cache_id = 0;
+#endif
+
+    if( PsUpdateDrawableGC(pGC, pDrawable, &psOut, &cMap)==FALSE ) return;
+    if (!imageRes) {
+        sw = w;
+        sh = h;
+    } else {
+        pageRes = XpGetResolution(XpGetPrintContext(requestingClient));
+        sw = (float)w * (float)pageRes / (float)imageRes + 0.5;
+        sh = (float)h * (float)pageRes / (float)imageRes + 0.5;
+    }
+    PsOut_Offset(psOut, pDrawable->x, pDrawable->y);
+    pt = (char *)(&i); i = 1; if( pt[0]=='\001' ) swap = 1; else swap = 0;
+
+#ifdef BM_CACHE
+    cache_id = PsBmIsImageCached(w, h, pImage);
+
+    if(!cache_id)
+    {
+      cache_id = PsBmPutImageInCache(w, h, pImage);
+
+      if(!cache_id)
+         return;
+
+      PsOut_BeginImageCache(psOut, cache_id);
+#endif
+      if( depth==24 )
+      {
+        PsOut_BeginImageIM(psOut, 0, 0, x, y, w, h, sw, sh, 3);
+        if( format==XYPixmap )
+        {
+          int   rowsiz = PixmapBytePad(w, depth);
+          char *planes[3];
+          planes[0] = pImage;
+          planes[1] = &pImage[rowsiz*h];
+          planes[2] = &pImage[rowsiz*h*2];
+          for( r=0 ; r<h ; r++ )
+          {
+            char *pt[3];
+            for( i=0 ; i<3 ;  i++ ) pt[i] = &planes[i][rowsiz*r];
+            for( c=0 ; c<w ; c++ )
+            {
+              for( i=0 ; i<3 ; i++ )
+                { PsOut_OutImageBytes(psOut, 1, &pt[i][c]); pt[i]++; }
+            }
+          }
+        }
+        else if( format==ZPixmap )
+        {
+          int  rowsiz = PixmapBytePad(w, depth);
+          for( r=0 ; r<h ; r++ )
+          {
+            char *pt = &pImage[rowsiz*r];
+            for( c=0 ; c<w ; c++,pt+=4 )
+            {
+              if( swap )
+              {
+                char tmp[4];
+                tmp[0] = pt[3]; tmp[1] = pt[2]; tmp[2] = pt[1]; tmp[3] = pt[0];
+                PsOut_OutImageBytes(psOut, 3, &tmp[1]);
+              }
+              else
+                PsOut_OutImageBytes(psOut, 3, &pt[1]);
+            }
+          }
+        }
+        else goto error;
+        PsOut_EndImage(psOut);
+      }
+      else if( depth==8 )
+      {
+        int  rowsiz = PixmapBytePad(w, depth);
+        PsOut_BeginImageIM(psOut, 0, 0, x, y, w, h, sw, sh, 3);
+        for( r=0 ; r<h ; r++ )
+        {
+          char *pt = &pImage[rowsiz*r];
+          for( c=0 ; c<w ; c++,pt++ )
+          {
+            int   val = PsGetPixelColor(cMap, (int)(*pt)&0xFF);
+            char *ipt = (char *)&val;
+            if( swap )
+            {
+              char tmp[4];
+              tmp[0] = ipt[3]; tmp[1] = ipt[2]; tmp[2] = ipt[1]; tmp[3] = ipt[0];
+              PsOut_OutImageBytes(psOut, 3, &tmp[1]);
+            }
+            else
+              PsOut_OutImageBytes(psOut, 3, &ipt[1]);
+          }
+        }
+        PsOut_EndImage(psOut);
+      }
+      else if( depth==1 )
+      {
+        {
+          int  rowsiz = BitmapBytePad(w);
+          int  psrsiz = (w+7)/8;
+          PsOut_BeginImageIM(psOut, PsGetPixelColor(cMap, pGC->bgPixel),
+                           PsGetPixelColor(cMap, pGC->fgPixel),
+                           x, y, w, h, sw, sh, 1);
+          for( r=0 ; r<h ; r++ )
+          {
+            char *pt = &pImage[rowsiz*r];
+            for( i=0 ; i<psrsiz ; i++ )
+            {
+              int  iv_, iv = (int)pt[i]&0xFF;
+              char c;
+              if( swap )
+                { for( j=0,iv_=0 ; j<8 ; j++ ) iv_ |= (((iv>>j)&1)<<(7-j)); }
+              else
+                iv_ = iv;
+              c = iv_;
+              PsOut_OutImageBytes(psOut, 1, &c);
+            }
+          }
+          PsOut_EndImage(psOut);
+        }
+      }
+#ifdef BM_CACHE
+      PsOut_EndImageCache(psOut);
+    }
+    PsOut_ImageCache(psOut, x, y, cache_id, PsGetPixelColor(cMap, pGC->bgPixel),
+                           PsGetPixelColor(cMap, pGC->fgPixel));
+#endif
+  }
+error:
+  return;
+}
+void
+PsPutImage(DrawablePtr pDrawable, GCPtr pGC, int depth, int x, int y,
+           int w, int h, int leftPad, int format, char *pImage)
+{
+    XpContextPtr pcon;
+    if (requestingClient && (pcon = XpGetPrintContext(requestingClient)))
+	PsPutScaledImage(pDrawable, pGC, depth, x, y, w, h, leftPad, format,
+			 pcon->imageRes, pImage);
+}
+void
+PsPutImageMask(DrawablePtr pDrawable, GCPtr pGC, int depth, int x, int y,
+           int w, int h, int leftPad, int format, char *pImage)
+{
+    XpContextPtr pcon;
+    if (requestingClient && (pcon = XpGetPrintContext(requestingClient)))
+        PsPutScaledImageIM(pDrawable, pGC, depth, x, y, w, h, leftPad, format,
+                         pcon->imageRes, pImage);
+}
+
+RegionPtr
+PsCopyArea(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC, int srcx, int srcy,
+           int width, int height, int dstx, int dsty)
+{
+  PixmapPtr  src = (PixmapPtr)pSrc;
+  PixmapPtr  dst = (PixmapPtr)pDst;
+
+  if( pSrc->type!=DRAWABLE_PIXMAP ) return NULL;
+  if( pDst->type!=DRAWABLE_PIXMAP )
+  {
+    PsOutPtr     psOut;
+    ColormapPtr  cMap;
+    if( PsUpdateDrawableGC(pGC, pDst, &psOut, &cMap)==FALSE ) return NULL;
+    PsOut_Offset(psOut, pDst->x, pDst->y);
+    PsOut_BeginFrame(psOut, dstx-srcx, dsty-srcy, dstx, dsty, width, height);
+    PsReplayPixmap(src, pDst);
+    PsOut_EndFrame(psOut);
+  }
+  else PsCopyDisplayList(src, dst, dstx-srcx, dsty-srcy, dstx, dsty,
+                         width, height);
+  return NULL;
+}
+
+RegionPtr
+PsCopyPlane(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC, int srcx, int srcy,
+            int width, int height, int dstx, int dsty, unsigned long plane)
+{
+  PixmapPtr  src = (PixmapPtr)pSrc;
+  PixmapPtr  dst = (PixmapPtr)pDst;
+
+  if( pSrc->type!=DRAWABLE_PIXMAP ) return NULL;
+  if( pDst->type!=DRAWABLE_PIXMAP )
+  {
+    PsOutPtr     psOut;
+    ColormapPtr  cMap;
+    if( PsUpdateDrawableGC(pGC, pDst, &psOut, &cMap)==FALSE ) return NULL;
+    PsOut_Offset(psOut, pDst->x, pDst->y);
+    PsOut_BeginFrame(psOut, dstx-srcx, dsty-srcy, dstx, dsty, width, height);
+    PsReplayPixmap(src, pDst);
+    PsOut_EndFrame(psOut);
+  }
+  else PsCopyDisplayList(src, dst, dstx-srcx, dsty-srcy, dstx, dsty,
+                         width, height);
+  return NULL;
+}
diff --git a/Xprint/ps/PsAttVal.c b/Xprint/ps/PsAttVal.c
new file mode 100644
index 000000000..83133e53a
--- /dev/null
+++ b/Xprint/ps/PsAttVal.c
@@ -0,0 +1,202 @@
+/*
+ * $Xorg: PsAttVal.c,v 1.5 2001/03/13 18:45:31 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.
+*/
+
+#include "Ps.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,
+    xpoid_val_content_orientation_reverse_portrait,
+    xpoid_val_content_orientation_reverse_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, xpoid_val_plex_duplex, xpoid_val_plex_tumble
+};
+static XpOidList ValidPlexes = {
+    ValidPlexesOids, XpNumber(ValidPlexesOids)
+};
+
+static XpOid DefaultPlexesOids[] = {
+    xpoid_val_plex_simplex
+};
+static XpOidList DefaultPlexes = {
+    DefaultPlexesOids, XpNumber(DefaultPlexesOids)
+};
+
+static unsigned long ValidPrinterResolutionsCards[] = {
+    300,
+    600,
+    720,
+    940,
+    1200,
+    1440,
+    2400
+};
+static XpOidCardList ValidPrinterResolutions = {
+    ValidPrinterResolutionsCards, XpNumber(ValidPrinterResolutionsCards)
+};
+
+static unsigned long DefaultPrinterResolutionsCards[] = {
+    300
+};
+static XpOidCardList DefaultPrinterResolutions = {
+    DefaultPrinterResolutionsCards, XpNumber(DefaultPrinterResolutionsCards)
+};
+
+static XpOid ValidListfontsModesOids[] = {
+    xpoid_val_xp_list_internal_printer_fonts, 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 }
+};
+static XpOidDocFmtList ValidDocFormatsSupported = {
+    ValidDocFormatsSupportedFmts, XpNumber(ValidDocFormatsSupportedFmts)
+};
+
+static XpOidDocFmt DefaultDocFormatsSupportedFmts[] = {
+    { "Postscript", "2", NULL }
+};
+static XpOidDocFmtList DefaultDocFormatsSupported = {
+    DefaultDocFormatsSupportedFmts, XpNumber(DefaultDocFormatsSupportedFmts)
+};
+
+static XpOidDocFmt ValidEmbeddedFormatsSupportedFmts[] = {
+    { "Postscript", "2", NULL }
+};
+static XpOidDocFmtList ValidEmbeddedFormatsSupported = {
+    ValidEmbeddedFormatsSupportedFmts, XpNumber(ValidEmbeddedFormatsSupportedFmts)
+};
+
+static XpOidDocFmt DefaultEmbeddedFormatsSupportedFmts[] = {
+    { "Postscript", "2", NULL }
+};
+static XpOidDocFmtList DefaultEmbeddedFormatsSupported = {
+    DefaultEmbeddedFormatsSupportedFmts, XpNumber(DefaultEmbeddedFormatsSupportedFmts)
+};
+
+static XpOidDocFmt ValidRawFormatsSupportedFmts[] = {
+    { "Postscript", "2", NULL }
+    
+};
+static XpOidDocFmtList ValidRawFormatsSupported = {
+    ValidRawFormatsSupportedFmts, XpNumber(ValidRawFormatsSupportedFmts)
+};
+
+static XpOidDocFmt DefaultRawFormatsSupportedFmts[] = {
+    { "Postscript", "2", NULL }
+};
+static XpOidDocFmtList DefaultRawFormatsSupported = {
+    DefaultRawFormatsSupportedFmts, XpNumber(DefaultRawFormatsSupportedFmts)
+};
+
+static XpOid ValidInputTraysOids[] = {
+    xpoid_val_input_tray_manual,
+    xpoid_val_input_tray_main,
+    xpoid_val_input_tray_envelope,
+    xpoid_val_input_tray_large_capacity,
+    xpoid_val_input_tray_bottom
+};
+static XpOidList ValidInputTrays = {
+    ValidInputTraysOids, XpNumber(ValidInputTraysOids)
+};
+
+static XpOid ValidMediumSizesOids[] = {
+    xpoid_val_medium_size_iso_a4,
+    xpoid_val_medium_size_na_letter,
+    xpoid_val_medium_size_na_legal,
+    xpoid_val_medium_size_executive,
+    xpoid_val_medium_size_iso_designated_long,
+    xpoid_val_medium_size_na_number_10_envelope
+};
+static XpOidList ValidMediumSizes = {
+    ValidMediumSizesOids, XpNumber(ValidMediumSizesOids)
+};
+
+static XpOidDocFmt DefaultDocumentFormat = {
+    "Postscript", "2", NULL
+};
+
+
+/*
+ * init struct for XpValidate*Pool
+ */
+XpValidatePoolsRec PsValidatePoolsRec = {
+    &ValidContentOrientations, &DefaultContentOrientations,
+    &ValidDocFormatsSupported, &DefaultDocFormatsSupported,
+    &ValidInputTrays, &ValidMediumSizes,
+    &ValidPlexes, &DefaultPlexes,
+    &ValidPrinterResolutions, &DefaultPrinterResolutions,
+    &ValidEmbeddedFormatsSupported, &DefaultEmbeddedFormatsSupported,
+    &ValidListfontsModes, &DefaultListfontsModes,
+    &ValidRawFormatsSupported, &DefaultRawFormatsSupported,
+    &ValidSetupProviso,
+    &DefaultDocumentFormat
+};
diff --git a/Xprint/ps/PsAttr.c b/Xprint/ps/PsAttr.c
new file mode 100644
index 000000000..8a5bee9e3
--- /dev/null
+++ b/Xprint/ps/PsAttr.c
@@ -0,0 +1,113 @@
+/* $Xorg: PsAttr.c,v 1.4 2001/02/09 02:04:35 xorgcvs Exp $ */
+/*
+
+Copyright 1996, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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
+OPEN GROUP 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 name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+/*
+ * (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:		PsAttr.c
+**    *
+**    *  Contents:	Attribute-handling functions for the PS driver
+**    *
+**    *  Created By:	Roger Helmendach (Liberty Systems)
+**    *
+**    *  Copyright:	Copyright 1996 The Open Group, Inc.
+**    *
+**    *********************************************************
+** 
+********************************************************************/
+
+#include "Ps.h"
+#include "attributes.h"
+
+char *
+PsGetAttributes(
+  XpContextPtr pCon,
+  XPAttributes pool)
+{
+  return XpGetAttributes(pCon, pool);
+}
+
+char *
+PsGetOneAttribute(
+  XpContextPtr  pCon,
+  XPAttributes  pool,
+  char         *attr)
+{
+  return XpGetOneAttribute(pCon, pool, attr);
+}
+
+int
+PsAugmentAttributes(
+  XpContextPtr  pCon,
+  XPAttributes  pool,
+  char         *attrs)
+{
+  return XpAugmentAttributes(pCon, pool, attrs);
+}
+
+int
+PsSetAttributes(
+  XpContextPtr  pCon,
+  XPAttributes  pool,
+  char         *attrs)
+{
+  return XpSetAttributes(pCon, pool, attrs);
+}
diff --git a/Xprint/ps/PsCache.c b/Xprint/ps/PsCache.c
new file mode 100644
index 000000000..8c9f4a926
--- /dev/null
+++ b/Xprint/ps/PsCache.c
@@ -0,0 +1,324 @@
+/*
+
+Copyright 1996, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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
+OPEN GROUP 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 name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+/*
+ * (c) Copyright 1996 Hewlett-Packard Company
+ * (c) Copyright 1996 International Business Machines Corp.
+ * (c) Copyright 1996, 2000 Sun Microsystems, Inc.  All Rights Reserved.
+ * (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:          PsCache.c
+**    *
+**    *  Contents:      Character-caching routines
+**    *
+**    *  Created By:    Jay Hobson (Sun MicroSystems)
+**    *
+**    *  Copyright:     Copyright 1996 The Open Group, Inc.
+**    *
+**    *********************************************************
+**
+********************************************************************/
+
+#include "Ps.h"
+#include "gcstruct.h"
+#include "windowstr.h"
+#include "fntfil.h"
+#include "fntfilst.h"
+
+#define  GET	0
+#define  RESET	1
+
+struct bm_cache_list {
+	struct bm_cache_list *next;
+	struct bm_cache_list *prev;
+        int                   height;
+	long	              id;
+        char                 *pBuffer;
+};
+
+struct bm_cache_head {
+	struct bm_cache_list *head;
+	int		      width;
+	struct bm_cache_head *next;
+        struct bm_cache_head *prev;
+};
+
+static struct bm_cache_head *bm_cache = NULL;
+
+static long
+PsBmUniqueId(int func)
+{
+    static long unique_id = 0;
+
+    if(func == RESET)
+    {
+	unique_id = 0;
+	return 0;
+    }
+    else
+	return ++unique_id;
+}
+
+int 
+PsBmIsImageCached(
+    int gWidth,
+    int gHeight,
+    char *pBuffer)
+{
+    int return_val = 0;
+    struct bm_cache_head *pList = bm_cache;
+
+    while(pList != NULL && !return_val)
+    {
+        if(pList->width == gWidth)
+        {
+	    struct bm_cache_list *pItem = pList->head;
+
+	    while(pItem != NULL)
+	    {
+	        if(pItem->height == gHeight)
+	        {
+		    int length = 4*(gWidth/32+(gWidth%32!=0))*gHeight;
+
+	            if(!memcmp(pItem->pBuffer, pBuffer, sizeof(char)*length))
+	            {
+		        return_val = pItem->id;
+		        break;
+	            }
+	        }
+		else if(pItem->height > gHeight)
+		    break;
+
+	        pItem = pItem->next;
+	    }
+        }
+	else if(pList->width > gWidth)
+	    break;
+
+        pList = pList->next;
+    }
+    return return_val;
+}
+
+int
+PsBmPutImageInCache(
+    int gWidth,
+    int gHeight,
+    char *pBuffer)
+{
+    int return_val = 0;
+    struct bm_cache_head *pList = bm_cache;
+    struct bm_cache_list *pNew;
+    int length = 4*(gWidth/32+(gWidth%32!=0))*gHeight;
+
+    if(gWidth == 1 && gHeight == 1 && pBuffer[0] == 0)
+        return return_val;
+
+    pNew = (struct bm_cache_list *)malloc(sizeof(struct bm_cache_list));
+    pNew->next    = NULL;
+    pNew->prev    = NULL;
+    pNew->height  = gHeight;
+    pNew->id      = PsBmUniqueId(GET);
+    pNew->pBuffer = (char *)malloc(sizeof(char)*length);
+
+    memcpy(pNew->pBuffer, pBuffer, length);
+
+    while(pList != NULL)
+    {
+        if(pList->width == gWidth)
+	{
+	    struct bm_cache_list *pItem = pList->head;
+
+	    while(pItem != NULL)
+	    {
+		if(pItem->height >= gHeight)
+		{
+		    pNew->next = pItem;
+		    pNew->prev = pItem->prev;
+		    if(pItem->prev != NULL)
+		       pItem->prev->next = pNew;
+                    else
+		       pList->head = pNew;
+                    pItem->prev = pNew;
+
+		    return_val = pNew->id;
+
+		    break;
+		}
+		else if(pItem->next == NULL)
+		{
+		    pNew->prev = pItem;
+		    pItem->next = pNew;
+
+		    return_val = pNew->id;
+
+		    break;
+		}
+
+		pItem = pItem->next;
+	    }
+
+	    break;
+        }
+
+        pList = pList->next;
+    }
+
+    if(pList == NULL)
+    {
+        struct bm_cache_head *pNewList;
+
+        pNewList = (struct bm_cache_head *)malloc(sizeof(struct bm_cache_head));
+ 
+        pNewList->next  = NULL;
+        pNewList->prev  = NULL;
+        pNewList->width = gWidth;
+        pNewList->head  = pNew;
+ 
+        if(bm_cache == NULL)
+        {
+	    bm_cache = pNewList;
+	    return_val = pNew->id;
+        }
+        else
+        {
+ 	    pList = bm_cache;
+
+	    while(pList != NULL)
+	    {
+	        if(pList->width > gWidth)
+		{
+		    pNewList->next  = pList;
+		    pNewList->prev  = pList->prev;
+
+		    if(pList->prev != NULL)
+		       pList->prev->next = pNewList;
+                    else
+		       bm_cache = pNewList;
+		    pList->prev = pNewList;
+
+		    return_val = pNew->id;
+
+		    break;
+		}
+		else if(pList->next == NULL)
+                {
+		    pNewList->prev  = pList;
+		    pList->next = pNewList;
+
+		    return_val = pNew->id;
+
+		    break;
+		}
+
+		pList = pList->next;
+	    }
+        }
+    }
+
+    return return_val;
+}
+
+
+static void
+PsBmClearImageCacheItem(
+    struct bm_cache_list *pItem)
+{
+    if(pItem != NULL)
+    {
+	if(pItem->pBuffer != NULL)
+	   free(pItem->pBuffer);
+        pItem->pBuffer = NULL;
+
+	if(pItem->next)
+	   PsBmClearImageCacheItem(pItem->next);
+        pItem->next = NULL;
+
+	free(pItem);
+	pItem = NULL;
+    }
+}
+
+static void 
+PsBmClearImageCacheList(
+    struct bm_cache_head *pList)
+{
+    if(pList != NULL)
+    {
+	if(pList->head)
+	    PsBmClearImageCacheItem(pList->head);
+        pList->head = NULL;
+
+	if(pList->next)
+	    PsBmClearImageCacheList(pList->next);
+        pList->next = NULL;
+
+	free(pList);
+	pList = NULL;
+    }
+}
+
+void
+PsBmClearImageCache()
+{
+   PsBmClearImageCacheList(bm_cache);
+
+   bm_cache = NULL;
+
+   PsBmUniqueId(RESET);
+}
+
diff --git a/Xprint/ps/PsColor.c b/Xprint/ps/PsColor.c
new file mode 100644
index 000000000..9c76904d6
--- /dev/null
+++ b/Xprint/ps/PsColor.c
@@ -0,0 +1,223 @@
+/* $Xorg: PsColor.c,v 1.4 2001/02/09 02:04:36 xorgcvs Exp $ */
+/*
+
+Copyright 1996, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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
+OPEN GROUP 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 name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+/*
+ * (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:		PsColor.c
+**    *
+**    *  Contents:	Color routines for the PS driver
+**    *
+**    *  Created By:	Roger Helmendach (Liberty Systems)
+**    *
+**    *  Copyright:	Copyright 1996 The Open Group, Inc.
+**    *
+**    *********************************************************
+** 
+********************************************************************/
+
+#include "Ps.h"
+#include "gcstruct.h"
+#include "windowstr.h"
+#include "colormapst.h"
+
+Bool
+PsCreateColormap(ColormapPtr pColor)
+{
+  int            i;
+  unsigned short rgb;
+  VisualPtr      pVisual = pColor->pVisual;
+  Pixel          pix;
+
+  if( pVisual->class==TrueColor )
+  {
+    for( i=0 ; i<pVisual->ColormapEntries ; i++ )
+    {
+      rgb = (i<<8)|i;
+
+      pColor->red[i].fShared = FALSE;
+      pColor->red[i].co.local.red     = rgb;
+      pColor->red[i].co.local.green   = 0;
+      pColor->red[i].co.local.blue    = 0;
+
+      pColor->green[i].fShared = FALSE;
+      pColor->green[i].co.local.red   = 0;
+      pColor->green[i].co.local.green = rgb;
+      pColor->green[i].co.local.blue  = 0;
+
+      pColor->blue[i].fShared = FALSE;
+      pColor->blue[i].co.local.red    = 0;
+      pColor->blue[i].co.local.green  = 0;
+      pColor->blue[i].co.local.blue   = rgb;
+    }
+  }
+  return TRUE;
+}
+
+void
+PsDestroyColormap(ColormapPtr pColor)
+{
+}
+
+void
+PsInstallColormap(ColormapPtr pColor)
+{
+  PsScreenPrivPtr pPriv =
+    (PsScreenPrivPtr)pColor->pScreen->devPrivates[PsScreenPrivateIndex].ptr;
+  pPriv->CMap = pColor;
+}
+
+void
+PsUninstallColormap(ColormapPtr pColor)
+{
+}
+
+int
+PsListInstalledColormaps(
+  ScreenPtr pScreen,
+  XID      *pCmapList)
+{
+  return 0;
+}
+
+void
+PsStoreColors(
+  ColormapPtr  pColor,
+  int          ndef,
+  xColorItem  *pdefs)
+{
+  int  i;
+  for( i=0 ; i<ndef ; i++ )
+  {
+    if( pdefs[i].flags&DoRed )
+      pColor->red[pdefs[i].pixel].co.local.red   = pdefs[i].red;
+    if( pdefs[i].flags&DoGreen )
+      pColor->red[pdefs[i].pixel].co.local.green = pdefs[i].green;
+    if( pdefs[i].flags&DoBlue )
+      pColor->red[pdefs[i].pixel].co.local.blue  = pdefs[i].blue;
+  }
+}
+
+void
+PsResolveColor(
+  unsigned short *pRed,
+  unsigned short *pGreen,
+  unsigned short *pBlue,
+  VisualPtr       pVisual)
+{
+}
+
+int
+PsGetPixelColor(ColormapPtr cMap, int pixval)
+{
+  int r, g, b;
+  if( cMap->pVisual->class==TrueColor ) return(pixval);
+  if( pixval<0 || pixval>255 ) return(0);
+  r = cMap->red[pixval].co.local.red>>8;
+  g = cMap->red[pixval].co.local.green>>8;
+  b = cMap->red[pixval].co.local.blue>>8;
+  return((r<<16)|(g<<8)|b);
+}
+
+void
+PsSetFillColor(DrawablePtr pDrawable, GCPtr pGC, PsOutPtr psOut,
+               ColormapPtr cMap)
+{
+  switch(pGC->fillStyle)
+  {
+    case FillSolid:
+      PsOut_Color(psOut, PsGetPixelColor(cMap, pGC->fgPixel));
+      break;
+    case FillTiled:
+      if( !PsOut_BeginPattern(psOut, pGC->tile.pixmap,
+             pGC->tile.pixmap->drawable.width,
+             pGC->tile.pixmap->drawable.height, PsTile, 0, 0) )
+      {
+        PsReplayPixmap(pGC->tile.pixmap, pDrawable);
+        PsOut_EndPattern(psOut);
+      }
+      PsOut_SetPattern(psOut, pGC->tile.pixmap, PsTile);
+      break;
+    case FillStippled:
+      if( !PsOut_BeginPattern(psOut, pGC->stipple,
+             pGC->stipple->drawable.width,
+             pGC->stipple->drawable.height, PsStip, 0,
+             PsGetPixelColor(cMap, pGC->fgPixel)) )
+      {
+        PsReplayPixmap(pGC->stipple, pDrawable);
+        PsOut_EndPattern(psOut);
+      }
+      PsOut_SetPattern(psOut, pGC->stipple, PsStip);
+      break;
+    case FillOpaqueStippled:
+      if( !PsOut_BeginPattern(psOut, pGC->stipple,
+             pGC->stipple->drawable.width,
+             pGC->stipple->drawable.height, PsOpStip,
+             PsGetPixelColor(cMap, pGC->bgPixel),
+             PsGetPixelColor(cMap, pGC->fgPixel)) )
+      {
+        PsReplayPixmap(pGC->stipple, pDrawable);
+        PsOut_EndPattern(psOut);
+      }
+      PsOut_SetPattern(psOut, pGC->stipple, PsOpStip);
+      break;
+  }
+}
diff --git a/Xprint/ps/PsDef.h b/Xprint/ps/PsDef.h
new file mode 100644
index 000000000..ec648c442
--- /dev/null
+++ b/Xprint/ps/PsDef.h
@@ -0,0 +1,93 @@
+/* $Xorg: PsDef.h,v 1.4 2001/02/09 02:04:36 xorgcvs Exp $ */
+/*
+
+Copyright 1996, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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
+OPEN GROUP 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 name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+/*
+ * (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:		PsDef.h
+**    *
+**    *  Contents:  extran defines and includes for the Ps driver
+**    *             for a printing X server.
+**    *
+**    *  Created By:	Roger Helmendach (Liberty Systems)
+**    *
+**    *  Copyright:	Copyright 1996 The Open Group, Inc.
+**    *
+**    *********************************************************
+** 
+********************************************************************/
+#ifndef _PSDEF_H_
+#define _PSDEF_H_
+
+#define DT_PRINT_JOB_HEADER "DT_PRINT_JOB_HEADER"
+#define DT_PRINT_JOB_TRAILER "DT_PRINT_JOB_TRAILER"
+#define DT_PRINT_JOB_COMMAND "DT_PRINT_JOB_COMMAND"
+#define DT_PRINT_JOB_EXEC_COMMAND "DT_PRINT_JOB_EXEC_COMMAND"
+#define DT_PRINT_JOB_EXEC_OPTIONS "DT_PRINT_JOB_EXEC_OPTION"
+#define DT_PRINT_PAGE_HEADER "DT_PRINT_PAGE_HEADER"
+#define DT_PRINT_PAGE_TRAILER "DT_PRINT_PAGE_TRAILER"
+#define DT_PRINT_PAGE_COMMAND "DT_PRINT_PAGE_COMMAND"
+
+#define DT_IN_FILE_STRING "%(InFile)%"
+#define DT_OUT_FILE_STRING "%(OutFile)%"
+#define DT_ALLOWED_COMMANDS_FILE "printCommands"
+
+#endif  /* _PSDEF_H_ */
diff --git a/Xprint/ps/PsFonts.c b/Xprint/ps/PsFonts.c
new file mode 100644
index 000000000..1a4692692
--- /dev/null
+++ b/Xprint/ps/PsFonts.c
@@ -0,0 +1,185 @@
+/* $Xorg: PsFonts.c,v 1.6 2001/03/06 16:30:15 pookie Exp $ */
+/*
+
+Copyright 1996, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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
+OPEN GROUP 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 name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+/*
+ * (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:		PsFonts.c
+**    *
+**    *  Contents:	Font code for PS driver.
+**    *
+**    *  Created By:	Roger Helmendach (Liberty Systems)
+**    *
+**    *  Copyright:	Copyright 1996 The Open Group, Inc.
+**    *
+**    *********************************************************
+** 
+********************************************************************/
+
+#include "miscstruct.h"
+#include "fontstruct.h"
+#include "dixfontstr.h"
+#include "scrnintstr.h"
+#include "fontxlfd.h"
+
+#include "Ps.h"
+
+Bool
+PsRealizeFont(
+  ScreenPtr  pscr,
+  FontPtr    pFont)
+{
+  return TRUE;
+}
+
+Bool
+PsUnrealizeFont(
+  ScreenPtr  pscr,
+  FontPtr    pFont)
+{
+  return TRUE;
+}
+
+char *
+PsGetFontName(FontPtr pFont)
+{
+  int         i;
+  int         nprops = pFont->info.nprops;
+  FontPropPtr props  = pFont->info.props;
+  Atom        name   = MakeAtom("FONT", 4, True);
+  Atom        value  = (Atom)0;
+
+  for( i=0 ; i<nprops ; i++ )
+  {
+    if( props[i].name==name )
+      { value = props[i].value; break; }
+  }
+  if( !value ) return (char *)0;
+  return NameForAtom(value);
+}
+
+int
+PsGetFontSize(FontPtr pFont, float *mtx)
+{
+  FontScalableRec   vals;
+  char             *name = PsGetFontName(pFont);
+  int               value = 0;
+
+  FontParseXLFDName(name, &vals, FONT_XLFD_REPLACE_NONE);
+  if( vals.values_supplied&PIXELSIZE_ARRAY )
+  {
+    int  i;
+    for( i=0 ; i<4 ; i++ )
+      mtx[i] = (float)vals.pixel_matrix[i];
+  }
+  else
+  {
+    value = vals.pixel;
+    if( !value ) value = 20;
+  }
+  return value;
+}
+
+char *
+PsGetPSFontName(FontPtr pFont)
+{
+  int         i;
+  int         nprops = pFont->info.nprops;
+  FontPropPtr props  = pFont->info.props;
+  Atom        name   = MakeAtom("PRINTER_RESIDENT_FONT", 21, True);
+  Atom        value  = (Atom)0;
+
+  for( i=0 ; i<nprops ; i++ )
+  {
+    if( props[i].name==name )
+      { value = props[i].value; break; }
+  }
+  if( !value ) return (char *)0; 
+  return NameForAtom(value);
+}
+
+int
+PsIsISOLatin1Encoding(FontPtr pFont)
+{
+  int          i;
+  int          nprops = pFont->info.nprops;
+  FontPropPtr  props  = pFont->info.props;
+  Atom         reg = MakeAtom("CHARSET_REGISTRY", 16, True);
+  Atom         enc = MakeAtom("CHARSET_ENCODING", 16, True);
+  Atom         rv = 0, ev = 0;
+  char        *rp = 0;
+  char        *ep = 0;
+
+  for( i=0 ; i<nprops ; i++ )
+  {
+    if( props[i].name==reg ) rv = props[i].value;
+    if( props[i].name==enc ) ev = props[i].value;
+  }
+  if( rv ) rp = NameForAtom(rv);
+  if( ev ) ep = NameForAtom(ev);
+  if( (!rp) || (!ep) ) return(0);
+  if( (char)tolower(rp[0])!='i' ||
+      (char)tolower(rp[1])!='s' ||
+      (char)tolower(rp[2])!='o' ||
+      memcmp(&rp[3], "8859", 4)!=0 ||
+      ep[0]!='1' ) return(0);
+  return(1);
+}
diff --git a/Xprint/ps/PsGC.c b/Xprint/ps/PsGC.c
new file mode 100644
index 000000000..c6e352279
--- /dev/null
+++ b/Xprint/ps/PsGC.c
@@ -0,0 +1,380 @@
+/* $Xorg: PsGC.c,v 1.4 2001/02/09 02:04:36 xorgcvs Exp $ */
+/*
+
+Copyright 1996, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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
+OPEN GROUP 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 name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+/*
+ * (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:		PsGC.c
+**    *
+**    *  Contents:	Graphics Context handling for the PS driver
+**    *
+**    *  Created By:	Roger Helmendach (Liberty Systems)
+**    *
+**    *  Copyright:	Copyright 1996 The Open Group, Inc.
+**    *
+**    *********************************************************
+** 
+********************************************************************/
+
+#include "Ps.h"
+#include "gcstruct.h"
+#include "pixmapstr.h"
+#include "windowstr.h"
+#include "migc.h"
+#include "scrnintstr.h"
+
+static GCOps PsGCOps = 
+{
+  PsFillSpans,
+  PsSetSpans,
+  PsPutImage,
+  PsCopyArea,
+  PsCopyPlane,
+  PsPolyPoint,
+  PsPolyLine,
+  PsPolySegment,
+  PsPolyRectangle,
+  PsPolyArc,
+  PsFillPolygon,
+  PsPolyFillRect,
+  PsPolyFillArc,
+  PsPolyText8,
+  PsPolyText16,
+  PsImageText8,
+  PsImageText16,
+  PsImageGlyphBlt,
+  PsPolyGlyphBlt,
+  PsPushPixels
+#ifdef NEED_LINEHELPER
+    ,NULL
+#endif
+};
+
+
+static GCFuncs PsGCFuncs = 
+{
+  PsValidateGC,
+  PsChangeGC,
+  PsCopyGC,
+  PsDestroyGC,
+  PsChangeClip,
+  PsDestroyClip,
+  PsCopyClip
+};
+
+Bool
+PsCreateGC(pGC)
+  GCPtr pGC;
+{
+  pGC->clientClip     = NULL;
+  pGC->clientClipType = CT_NONE;
+
+  pGC->ops = &PsGCOps;
+  pGC->funcs = &PsGCFuncs;
+
+  pGC->clientClip = (pointer)xalloc(sizeof(PsClipRec));
+  memset(pGC->clientClip, 0, sizeof(PsClipRec));
+  return TRUE;
+}
+
+static int
+PsGetDrawablePrivateStuff(
+  DrawablePtr     pDrawable,
+  GC             *gc,
+  unsigned long  *valid,
+  PsOutPtr       *psOut,
+  ColormapPtr    *cMap)
+{
+  XpContextPtr     pCon;
+  PsPixmapPrivPtr  pPriv;
+  PsContextPrivPtr cPriv;
+  PsScreenPrivPtr  sPriv;
+
+  switch(pDrawable->type)
+  {
+    case DRAWABLE_PIXMAP:
+      return FALSE;
+    case DRAWABLE_WINDOW:
+      pCon  = PsGetContextFromWindow((WindowPtr)pDrawable);
+      if( pCon==NULL ) return FALSE;
+      else
+      {
+        cPriv = pCon->devPrivates[PsContextPrivateIndex].ptr;
+        sPriv = (PsScreenPrivPtr)
+                pDrawable->pScreen->devPrivates[PsScreenPrivateIndex].ptr;
+        *gc     = cPriv->lastGC;
+        *valid  = cPriv->validGC;
+        *psOut  = cPriv->pPsOut;
+        *cMap   = sPriv->CMap;
+        return TRUE;
+      }
+    default:
+      return FALSE;
+  }
+}
+
+int
+PsUpdateDrawableGC(
+  GCPtr        pGC,
+  DrawablePtr  pDrawable,
+  PsOutPtr    *psOut,
+  ColormapPtr *cMap)
+{
+  GC               dGC;
+  unsigned long    valid;
+  int              i;
+  PsContextPrivPtr cPriv;
+  BoxPtr           boxes;
+
+  if (!PsGetDrawablePrivateStuff(pDrawable, &dGC, &valid, psOut, cMap))
+    return FALSE;
+    
+  switch (pDrawable->type) {
+
+    case DRAWABLE_PIXMAP:
+      /* we don't support pixmaps yet! */
+      return FALSE;
+      break;
+    case DRAWABLE_WINDOW: 
+      if( pGC )
+      {
+        RegionPtr pReg;
+        WindowPtr pWin = (WindowPtr)pDrawable;
+        Bool      freeClip;
+        PsClipPtr clp = (PsClipPtr)pGC->clientClip;
+        if( clp->outterClips )
+          { xfree(clp->outterClips); clp->outterClips = 0; }
+        clp->nOutterClips = 0;
+        if( pGC->subWindowMode==IncludeInferiors )
+        {
+          pReg = NotClippedByChildren(pWin);
+          freeClip = TRUE;
+        }
+        else
+        {
+          pReg = &pWin->clipList;
+          freeClip = FALSE;
+        }
+
+        if( pReg->data )
+        {
+          boxes = (BoxPtr)((char *)pReg->data+sizeof(long)*2);
+          clp->nOutterClips = pReg->data->numRects;
+          clp->outterClips  =
+                      (PsRectPtr)xalloc(clp->nOutterClips*sizeof(PsRectRec));
+          for( i=0 ; i<clp->nOutterClips ; i++ )
+          {
+            clp->outterClips[i].x = boxes[i].x1;
+            clp->outterClips[i].y = boxes[i].y1;
+            clp->outterClips[i].w = (boxes[i].x2-boxes[i].x1)+1;
+            clp->outterClips[i].h = (boxes[i].y2-boxes[i].y1)+1;
+          }
+        }
+
+        if( freeClip ) (*pGC->pScreen->RegionDestroy)(pReg);
+        PsOut_Offset(*psOut, pDrawable->x, pDrawable->y);
+        PsOut_Clip(*psOut, pGC->clientClipType, (PsClipPtr)pGC->clientClip);
+      }
+      cPriv = ( PsGetContextFromWindow( (WindowPtr)pDrawable ) )
+             ->devPrivates[PsContextPrivateIndex].ptr;
+      break;
+  }
+  return TRUE;
+}
+
+void
+PsValidateGC(GCPtr pGC, unsigned long changes, DrawablePtr pDrawable)
+{
+  pGC->ops = &PsGCOps;
+}
+
+void
+PsChangeGC(GCPtr pGC, unsigned long changes)
+{
+}
+
+void
+PsCopyGC(GCPtr pGCSrc, unsigned long mask, GCPtr pGCDst)
+{
+}
+
+void
+PsDestroyGC(GCPtr pGC)
+{
+  PsDestroyClip(pGC);
+  xfree(pGC->clientClip);
+}
+
+void
+PsChangeClip(GCPtr pGC, int type, pointer pValue, int nrects)
+{
+  int         i;
+  PsClipPtr   clp = (PsClipPtr)pGC->clientClip;
+  RegionPtr   rgn;
+  BoxPtr      boxes;
+  xRectangle *rects;
+
+  PsDestroyClip(pGC);
+  pGC->clientClipType = type;
+  switch(type)
+  {
+    case CT_NONE: break;
+    case CT_PIXMAP:
+      clp->elms = PsCreateFillElementList((PixmapPtr)pValue, &clp->nElms);
+      (*pGC->pScreen->DestroyPixmap)((PixmapPtr)pValue);
+      break;
+    case CT_REGION:
+      rgn = (RegionPtr)pValue;
+      boxes = (BoxPtr)((char *)rgn->data+sizeof(long)*2);
+      clp->nRects = rgn->data->numRects;
+      clp->rects  = (PsRectPtr)xalloc(clp->nRects*sizeof(PsRectRec));
+      for( i=0 ; i<clp->nRects ; i++ )
+      {
+        clp->rects[i].x = boxes[i].x1;
+        clp->rects[i].y = boxes[i].y1;
+        clp->rects[i].w = (boxes[i].x2-boxes[i].x1)+1;
+        clp->rects[i].h = (boxes[i].y2-boxes[i].y1)+1;
+      }
+      (*pGC->pScreen->RegionDestroy)((RegionPtr)pValue);
+      break;
+    case CT_UNSORTED:
+    case CT_YSORTED:
+    case CT_YXSORTED:
+    case CT_YXBANDED:
+      rects = (xRectangle *)pValue;
+      clp->nRects = nrects;
+      clp->rects  = (PsRectPtr)xalloc(clp->nRects*sizeof(PsRectRec));
+      for( i=0 ; i<clp->nRects ; i++ )
+      {
+        clp->rects[i].x = rects[i].x;
+        clp->rects[i].y = rects[i].y;
+        clp->rects[i].w = rects[i].width;
+        clp->rects[i].h = rects[i].height;
+      }
+      xfree(pValue);
+      break;
+  }
+}
+
+void
+PsDestroyClip(GCPtr pGC)
+{
+  PsClipPtr clp = (PsClipPtr)pGC->clientClip;
+
+  if( clp->rects )       xfree(clp->rects);
+  if( clp->outterClips ) xfree(clp->outterClips);
+  clp->rects       = (PsRectPtr)0;
+  clp->outterClips = (PsRectPtr)0;
+  clp->nRects       = 0;
+  clp->nOutterClips = 0;
+  if( clp->elms ) PsDestroyFillElementList(clp->nElms, clp->elms);
+  clp->elms   = (PsElmPtr)0;
+  clp->nElms  = 0;
+  pGC->clientClipType = CT_NONE;
+}
+
+void
+PsCopyClip(GCPtr pDst, GCPtr pSrc)
+{
+  PsClipPtr src = (PsClipPtr)pSrc->clientClip;
+  PsClipPtr dst = (PsClipPtr)pDst->clientClip;
+
+  PsDestroyClip(pDst);
+  pDst->clientClipType = pSrc->clientClipType;
+  *dst = *src;
+  if( src->rects )
+  {
+    dst->rects = (PsRectPtr)xalloc(src->nRects*sizeof(PsRectRec));
+    memcpy(dst->rects, src->rects, src->nRects*sizeof(PsRectRec));
+  }
+  if( src->elms )
+    dst->elms = PsCloneFillElementList(src->nElms, src->elms);
+}
+
+
+GCPtr
+PsCreateAndCopyGC(DrawablePtr pDrawable, GCPtr pSrc)
+{
+    GCPtr pDst;
+    
+    if ((pDst =
+	 CreateScratchGC(pDrawable->pScreen, pDrawable->depth)) == NULL) 
+    {
+	return NULL;
+    }
+
+    if (CopyGC(pSrc, pDst, 
+	       GCFunction | GCPlaneMask | GCForeground | GCBackground |
+	       GCLineWidth | GCLineStyle | GCCapStyle | GCJoinStyle | 
+	       GCFillStyle | GCFillRule | GCTile | GCStipple |
+	       GCTileStipXOrigin | GCTileStipYOrigin | GCFont | 
+	       GCSubwindowMode | GCGraphicsExposures | GCClipXOrigin |
+	       GCClipYOrigin | GCClipMask | GCDashOffset | GCDashList |
+	       GCArcMode) != Success)
+    {
+	(void)FreeGC(pDst, (GContext)0);
+
+	return NULL;
+    }
+    
+    return pDst;
+}
+
diff --git a/Xprint/ps/PsInit.c b/Xprint/ps/PsInit.c
new file mode 100644
index 000000000..72c83448e
--- /dev/null
+++ b/Xprint/ps/PsInit.c
@@ -0,0 +1,413 @@
+/* $Xorg: PsInit.c,v 1.4 2001/02/09 02:04:36 xorgcvs Exp $ */
+/*
+
+Copyright 1996, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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
+OPEN GROUP 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 name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+/*
+ * (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:		PsInit.c
+**    *
+**    *  Contents:      Initialization code of Ps driver for the print server.
+**    *
+**    *  Created By:	Roger Helmendach (Liberty Systems)
+**    *
+**    *  Copyright:	Copyright 1996 The Open Group, Inc.
+**    *
+**    *********************************************************
+** 
+********************************************************************/
+
+#include <stdio.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/wait.h>
+
+#include "Ps.h"
+#include "AttrValid.h"
+#include "../../mfb/mfb.h"
+
+#include "windowstr.h"
+
+static void AllocatePsPrivates(ScreenPtr pScreen);
+static int PsInitContext(XpContextPtr pCon);
+
+extern Bool _XpBoolNoop();
+extern void _XpVoidNoop();
+extern Bool cfbCreateDefColormap(ScreenPtr pScreen);
+
+int PsScreenPrivateIndex;
+int PsContextPrivateIndex;
+int PsPixmapPrivateIndex;
+int PsWindowPrivateIndex;
+int PsGCPrivateIndex;
+
+Bool
+InitializePsDriver(ndx, pScreen, argc, argv)
+  int         ndx;
+  ScreenPtr   pScreen;
+  int         argc;
+  char      **argv;
+{
+  int               maxXres, maxYres, maxWidth, maxHeight;
+  int               maxRes, maxDim, numBytes;
+  PsScreenPrivPtr   pPriv;
+  char            **printerNames;
+  int               numPrinters;
+  int               nVisuals;
+  int               nDepths;
+  VisualPtr         visuals;
+  DepthPtr          depths;
+
+/*
+ * Register this driver's InitContext function with the print
+ * extension.
+ */
+  XpRegisterInitFunc(pScreen, "XP-POSTSCRIPT", PsInitContext);
+
+/*
+ * Create and fill in the devPrivate for the PS driver.
+ */
+  AllocatePsPrivates(pScreen);
+
+  pPriv = (PsScreenPrivPtr)pScreen->devPrivates[PsScreenPrivateIndex].ptr;
+/*pPriv->resDB = rmdb;*/
+
+  pScreen->defColormap            = (Colormap) FakeClientID(0);
+  pScreen->blackPixel             = 1;
+  pScreen->whitePixel             = 0;
+  pScreen->QueryBestSize          = (QueryBestSizeProcPtr)PsQueryBestSize;
+  pScreen->SaveScreen             = _XpBoolNoop;
+  pScreen->GetImage               = _XpVoidNoop;
+  pScreen->GetSpans               = _XpVoidNoop;
+  pScreen->CreateWindow           = PsCreateWindow;
+  pScreen->DestroyWindow          = PsDestroyWindow;
+  pScreen->PositionWindow         = PsPositionWindow;
+  pScreen->ChangeWindowAttributes = PsChangeWindowAttributes;
+  pScreen->RealizeWindow          = PsMapWindow;
+  pScreen->UnrealizeWindow        = PsUnmapWindow;
+  pScreen->PaintWindowBackground  = PsPaintWindow;
+  pScreen->PaintWindowBorder      = PsPaintWindow;
+  pScreen->CloseScreen            = PsCloseScreen;
+  pScreen->CopyWindow             = PsCopyWindow;
+       /* XXX Hard routine to write! */
+
+/*
+ * These two are going to be VERY different...
+ */
+  pScreen->CreatePixmap           = PsCreatePixmap;
+  pScreen->DestroyPixmap          = PsDestroyPixmap;
+  pScreen->RealizeFont            = PsRealizeFont;
+  pScreen->UnrealizeFont          = PsUnrealizeFont;
+  pScreen->CreateGC               = PsCreateGC;
+  pScreen->CreateColormap         = PsCreateColormap;
+  pScreen->DestroyColormap        = PsDestroyColormap;
+  pScreen->InstallColormap        = PsInstallColormap;
+  pScreen->UninstallColormap      = PsUninstallColormap;
+  pScreen->ListInstalledColormaps = PsListInstalledColormaps;
+  pScreen->StoreColors            = PsStoreColors;
+  pScreen->ResolveColor           = PsResolveColor;
+    /* Will BitmapToRegion make any difference at all? */
+  pScreen->BitmapToRegion         = mfbPixmapToRegion;
+
+  nVisuals = 2;
+  nDepths  = 2;
+  visuals  = (VisualPtr)xalloc(nVisuals*sizeof(VisualRec));
+  depths   = (DepthPtr) xalloc(nDepths*sizeof(DepthRec));
+
+  visuals[0].vid             = FakeClientID(0);
+  visuals[0].class           = TrueColor;
+  visuals[0].bitsPerRGBValue = 8;
+  visuals[0].ColormapEntries = 256;
+  visuals[0].nplanes         = 24;
+  visuals[0].redMask         = 0x00FF0000;
+  visuals[0].greenMask       = 0x0000FF00;
+  visuals[0].blueMask        = 0x000000FF;
+  visuals[0].offsetRed       = 16;
+  visuals[0].offsetGreen     = 8;
+  visuals[0].offsetBlue      = 0;
+
+  visuals[1].vid             = FakeClientID(0);
+  visuals[1].class           = PseudoColor;
+  visuals[1].bitsPerRGBValue = 0;
+  visuals[1].ColormapEntries = 256;
+  visuals[1].nplanes         = 8;
+  visuals[1].redMask         = 0x0;
+  visuals[1].greenMask       = 0x0;
+  visuals[1].blueMask        = 0x0;
+  visuals[1].offsetRed       = 0x0;
+  visuals[1].offsetGreen     = 0x0;
+  visuals[1].offsetBlue      = 0x0;
+
+  depths[0].depth   = 24;
+  depths[0].numVids = 1;
+  depths[0].vids    = &visuals[0].vid;
+
+  depths[1].depth   = 8;
+  depths[1].numVids = 1;
+  depths[1].vids    = &visuals[1].vid;
+
+/*  THE FOLLOWING CAUSES SERVER DEFAULT VISUAL TO BE 24 BIT  */
+/*  miScreenInit(pScreen, (pointer)0,
+	       pScreen->width, pScreen->height,
+	       pScreen->width / (pScreen->mmWidth / 25.40), 
+	       pScreen->height / (pScreen->mmHeight / 25.40),
+	       0, 24, nDepths,
+               depths, visuals[1].vid, nVisuals, visuals, (miBSFuncPtr)0); */
+
+/*  THE FOLLOWING CAUSES SERVER DEFAULT VISUAL TO BE 8 BIT  */
+  miScreenInit(pScreen, (pointer)0,
+	       pScreen->width, pScreen->height,
+	       (int) (pScreen->width / (pScreen->mmWidth / 25.40)), 
+	       (int) (pScreen->height / (pScreen->mmHeight / 25.40)),
+	       0, 8, nDepths,
+               depths, visuals[1].vid, nVisuals, visuals, (miBSFuncPtr)0);
+
+  if( cfbCreateDefColormap(pScreen)==FALSE ) return FALSE;
+
+/*scalingScreenInit(pScreen);*/
+
+  return TRUE;
+}
+
+static void
+AllocatePsPrivates(ScreenPtr pScreen)
+{
+  static int PsGeneration = -1;
+
+  if(PsGeneration != serverGeneration)
+  {
+    PsScreenPrivateIndex = AllocateScreenPrivateIndex();
+
+    PsWindowPrivateIndex = AllocateWindowPrivateIndex();
+    AllocateWindowPrivate(pScreen, PsWindowPrivateIndex,
+                          sizeof(PsWindowPrivRec));
+
+    PsContextPrivateIndex = XpAllocateContextPrivateIndex();
+    XpAllocateContextPrivate(PsContextPrivateIndex, 
+                             sizeof(PsContextPrivRec));
+
+    PsGCPrivateIndex = AllocateGCPrivateIndex();
+    AllocateGCPrivate(pScreen, PsGCPrivateIndex,
+                      sizeof(PsGCPrivRec));
+
+    PsPixmapPrivateIndex = AllocatePixmapPrivateIndex();
+    AllocatePixmapPrivate(pScreen, PsPixmapPrivateIndex,
+                          sizeof(PsPixmapPrivRec));
+
+    PsGeneration = serverGeneration;
+  }
+  pScreen->devPrivates[PsScreenPrivateIndex].ptr =
+           (pointer)xalloc(sizeof(PsScreenPrivRec));
+}
+
+/*
+ * PsInitContext
+ *
+ * Establish the appropriate values for a PrintContext used with the PS
+ * driver.
+ */
+
+static char DOC_ATT_SUPP[]="document-attributes-supported";
+static char DOC_ATT_VAL[]="document-format";
+static char JOB_ATT_SUPP[]="job-attributes-supported";
+static char JOB_ATT_VAL[]="";
+static char PAGE_ATT_SUPP[]="xp-page-attributes-supported";
+static char PAGE_ATT_VAL[]="content-orientation default-printer-resolution \
+default-input-tray default-medium plex";
+
+static int
+PsInitContext(pCon)
+  XpContextPtr pCon;
+{
+  XpDriverFuncsPtr pFuncs;
+  PsContextPrivPtr pConPriv;
+  char *server, *attrStr;
+  extern XpValidatePoolsRec PsValidatePoolsRec;
+    
+  /*
+   * Initialize the attribute store for this printer.
+   */
+  XpInitAttributes(pCon);
+
+  /*
+   * Initialize the function pointers
+   */
+  pFuncs = &(pCon->funcs);
+  pFuncs->StartJob          = PsStartJob;
+  pFuncs->EndJob            = PsEndJob;
+  pFuncs->StartDoc          = PsStartDoc;
+  pFuncs->EndDoc            = PsEndDoc;
+  pFuncs->StartPage         = PsStartPage;
+  pFuncs->EndPage           = PsEndPage;
+  pFuncs->PutDocumentData   = PsDocumentData;
+  pFuncs->GetDocumentData   = PsGetDocumentData;
+  pFuncs->GetAttributes     = (char *(*)())PsGetAttributes;
+  pFuncs->SetAttributes     = (int   (*)())PsSetAttributes;
+  pFuncs->AugmentAttributes = (int   (*)())PsAugmentAttributes;
+  pFuncs->GetOneAttribute   = (char *(*)())PsGetOneAttribute;
+  pFuncs->DestroyContext    = PsDestroyContext;
+  pFuncs->GetMediumDimensions = PsGetMediumDimensions;
+  pFuncs->GetReproducibleArea = PsGetReproducibleArea;
+  pFuncs->SetImageResolution = PsSetImageResolution;
+    
+  /*
+   * Set up the context privates
+   */
+  pConPriv =
+      (PsContextPrivPtr)pCon->devPrivates[PsContextPrivateIndex].ptr;
+
+  pConPriv->jobFileName  = (char *)NULL;
+  pConPriv->pJobFile     = (FILE *)NULL;
+
+  pConPriv->getDocClient = (ClientPtr)NULL;
+  pConPriv->getDocBufSize = 0;
+
+  /*
+   * document-attributes-supported
+   */
+  server = XpGetOneAttribute( pCon, XPServerAttr, DOC_ATT_SUPP );
+  if ((attrStr = (char *) xalloc(strlen(server) +
+				strlen(DOC_ATT_SUPP) + strlen(DOC_ATT_VAL)
+				+ strlen(PAGE_ATT_VAL) + 6)) == NULL) 
+  {
+      return BadAlloc;
+  }
+  sprintf(attrStr, "*%s:\t%s %s %s", 
+	  DOC_ATT_SUPP, server, DOC_ATT_VAL, PAGE_ATT_VAL);
+  XpAugmentAttributes( pCon, XPPrinterAttr, attrStr);
+  xfree(attrStr);
+    
+  /*
+   * job-attributes-supported
+   */
+  server = XpGetOneAttribute( pCon, XPServerAttr, JOB_ATT_SUPP );
+  if ((attrStr = (char *) xalloc(strlen(server) + strlen(JOB_ATT_SUPP) +
+				 strlen(JOB_ATT_VAL) + 4)) == NULL)
+  {
+      return BadAlloc;
+  }
+  sprintf(attrStr, "*%s:\t%s %s", JOB_ATT_SUPP, server, JOB_ATT_VAL);
+  XpAugmentAttributes(pCon, XPPrinterAttr, attrStr);
+  xfree(attrStr);
+    
+  /*
+   * xp-page-attributes-supported
+   */
+  server = XpGetOneAttribute( pCon, XPServerAttr, PAGE_ATT_SUPP );
+  if ((attrStr = (char *) xalloc(strlen(server) + strlen(PAGE_ATT_SUPP) +
+				 strlen(PAGE_ATT_VAL) + 4)) == NULL)
+  {
+      return BadAlloc;
+  }
+  sprintf(attrStr, "*%s:\t%s %s", PAGE_ATT_SUPP, server, PAGE_ATT_VAL);
+  XpAugmentAttributes(pCon, XPPrinterAttr, attrStr);
+  xfree(attrStr);
+
+  /*
+   * Validate the attribute pools
+   */
+  XpValidateAttributePool(pCon, XPPrinterAttr, &PsValidatePoolsRec);
+  XpValidateAttributePool(pCon, XPDocAttr, &PsValidatePoolsRec);
+  XpValidateAttributePool(pCon, XPJobAttr, &PsValidatePoolsRec);
+  XpValidateAttributePool(pCon, XPPageAttr, &PsValidatePoolsRec);
+
+  return Success;
+}
+
+static Bool
+PsDestroyContext(pCon)
+  XpContextPtr pCon;
+{
+  PsContextPrivPtr pConPriv =
+      (PsContextPrivPtr)pCon->devPrivates[PsContextPrivateIndex].ptr;
+    
+  if( pConPriv->pJobFile!=(FILE *)NULL )
+  {
+    fclose(pConPriv->pJobFile);
+    pConPriv->pJobFile = NULL;
+  }
+  if( pConPriv->jobFileName!=(char *)NULL )
+  {
+    unlink(pConPriv->jobFileName);
+    xfree(pConPriv->jobFileName);
+    pConPriv->jobFileName = (char *)NULL;
+  }
+
+/*### free up visuals/depths ###*/
+
+  return Success;
+}
+
+XpContextPtr
+PsGetContextFromWindow(win)
+  WindowPtr win;
+{
+  PsWindowPrivPtr pPriv;
+
+  while( win )
+  {
+    pPriv = (PsWindowPrivPtr)win->devPrivates[PsWindowPrivateIndex].ptr;
+    if( pPriv->validContext ) return pPriv->context;
+    win = win->parent;
+  }
+
+  return NULL;
+}
diff --git a/Xprint/ps/PsLine.c b/Xprint/ps/PsLine.c
new file mode 100644
index 000000000..23e105804
--- /dev/null
+++ b/Xprint/ps/PsLine.c
@@ -0,0 +1,188 @@
+/* $Xorg: PsLine.c,v 1.4 2001/02/09 02:04:36 xorgcvs Exp $ */
+/*
+
+Copyright 1996, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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
+OPEN GROUP 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 name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+/*
+ * (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:		PsLine.c
+**    *
+**    *  Contents:	Line drawing routines for the PS driver
+**    *
+**    *  Created By:	Roger Helmendach (Liberty Systems)
+**    *
+**    *  Copyright:	Copyright 1996 The Open Group, Inc.
+**    *
+**    *********************************************************
+** 
+********************************************************************/
+
+#include "Ps.h"
+#include "gcstruct.h"
+#include "windowstr.h"
+
+void
+PsPolyLine(
+  DrawablePtr  pDrawable,
+  GCPtr        pGC,
+  int          mode,
+  int          nPoints,
+  xPoint      *pPoints)
+{
+  if( pDrawable->type==DRAWABLE_PIXMAP )
+  {
+    DisplayElmPtr   elm;
+    PixmapPtr       pix  = (PixmapPtr)pDrawable;
+    PsPixmapPrivPtr priv = (PsPixmapPrivPtr)pix->devPrivate.ptr;
+    DisplayListPtr  disp;
+    GCPtr           gc;
+
+    if ((gc = PsCreateAndCopyGC(pDrawable, pGC)) == NULL) return;
+
+    disp = PsGetFreeDisplayBlock(priv);
+
+    elm  = &disp->elms[disp->nelms];
+    elm->type = PolyLineCmd;
+    elm->gc   = gc;
+    elm->c.polyPts.mode    = mode;
+    elm->c.polyPts.nPoints = nPoints;
+    elm->c.polyPts.pPoints = (xPoint *)xalloc(nPoints*sizeof(xPoint));
+    memcpy(elm->c.polyPts.pPoints, pPoints, nPoints*sizeof(xPoint));
+    disp->nelms += 1;
+  }
+  else
+  {
+    int         i;
+    PsOutPtr    psOut;
+    PsPointPtr  pts;
+    ColormapPtr cMap;
+
+    if( PsUpdateDrawableGC(pGC, pDrawable, &psOut, &cMap)==FALSE ) return;
+    PsOut_Offset(psOut, pDrawable->x, pDrawable->y);
+    PsOut_Color(psOut, PsGetPixelColor(cMap, pGC->fgPixel));
+    PsLineAttrs(psOut, pGC, cMap);
+    pts = (PsPointPtr)xalloc(sizeof(PsPointRec)*nPoints);
+    if( mode==CoordModeOrigin )
+    {
+      for( i=0 ; i<nPoints ; i++ )
+        { pts[i].x = pPoints[i].x; pts[i].y = pPoints[i].y; }
+    }
+    else
+    {
+      pts[0].x = pPoints[0].x; pts[0].y = pPoints[0].y;
+      for( i=1 ; i<nPoints ;  i++ )
+      {
+        pts[i].x = pts[i-1].x+pPoints[i].x;
+        pts[i].y = pts[i-1].y+pPoints[i].y;
+      }
+    }
+    PsOut_Lines(psOut, nPoints, pts);
+    xfree(pts);
+  }
+}
+
+void
+PsPolySegment(
+  DrawablePtr  pDrawable,
+  GCPtr        pGC,
+  int          nSegments,
+  xSegment    *pSegments)
+{
+  if( pDrawable->type==DRAWABLE_PIXMAP )
+  {
+    DisplayElmPtr   elm;
+    PixmapPtr       pix  = (PixmapPtr)pDrawable;
+    PsPixmapPrivPtr priv = (PsPixmapPrivPtr)pix->devPrivate.ptr;
+    DisplayListPtr  disp;
+    GCPtr           gc;
+
+    if ((gc = PsCreateAndCopyGC(pDrawable, pGC)) == NULL) return;
+
+    disp = PsGetFreeDisplayBlock(priv);
+
+    elm  = &disp->elms[disp->nelms];
+    elm->type = PolySegmentCmd;
+    elm->gc   = gc;
+    elm->c.segments.nSegments = nSegments;
+    elm->c.segments.pSegments = (xSegment *)xalloc(nSegments*sizeof(xSegment));
+    memcpy(elm->c.segments.pSegments, pSegments, nSegments*sizeof(xSegment));
+    disp->nelms += 1;
+  }
+  else
+  {
+    int         i;
+    PsOutPtr    psOut;
+    PsPointRec  pts[2];
+    ColormapPtr cMap;
+
+    if( PsUpdateDrawableGC(pGC, pDrawable, &psOut, &cMap)==FALSE ) return;
+    PsOut_Offset(psOut, pDrawable->x, pDrawable->y);
+    PsOut_Color(psOut, PsGetPixelColor(cMap, pGC->fgPixel));
+    PsLineAttrs(psOut, pGC, cMap);
+    for( i=0 ; i<nSegments ; i++ )
+    {
+      pts[0].x = pSegments[i].x1;
+      pts[0].y = pSegments[i].y1;
+      pts[1].x = pSegments[i].x2;
+      pts[1].y = pSegments[i].y2;
+      PsOut_Lines(psOut, 2, pts);
+    }
+  }
+}
diff --git a/Xprint/ps/PsMisc.c b/Xprint/ps/PsMisc.c
new file mode 100644
index 000000000..86d862ce1
--- /dev/null
+++ b/Xprint/ps/PsMisc.c
@@ -0,0 +1,320 @@
+/* $Xorg: PsMisc.c,v 1.4 2001/02/09 02:04:36 xorgcvs Exp $ */
+/*
+
+Copyright 1996, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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
+OPEN GROUP 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 name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+/*
+ * (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:		PsMisc.c
+**    *
+**    *  Contents:	Miscellaneous code for Ps driver.
+**    *
+**    *  Created By:	Roger Helmendach (Liberty Systems)
+**    *
+**    *  Copyright:	Copyright 1996 The Open Group, Inc.
+**    *
+**    *********************************************************
+** 
+********************************************************************/
+
+#include "Xos.h"	/* for SIGCLD on pre-POSIX systems */
+#include <stdio.h>
+#include "Ps.h"
+
+#include "cursor.h"
+#include "resource.h"
+
+#include "windowstr.h"
+#include "propertyst.h"
+
+
+/*ARGSUSED*/
+void
+PsQueryBestSize(
+  int type,
+  short *pwidth,
+  short *pheight,
+  ScreenPtr pScreen)
+{
+  unsigned width, highBit;
+
+  switch(type)
+  {
+    case CursorShape:
+      *pwidth  = 0;
+      *pheight = 0;
+      break;
+    case TileShape:
+    case StippleShape:
+      width = *pwidth;
+      if (!width) break;
+      /* Return the nearest power of two >= what they gave us */
+      highBit = 0x80000000;
+      /* Find the highest 1 bit in the given width */
+      while(!(highBit & width))
+        highBit >>= 1;
+      /* If greater than that then return the next power of two */
+      if((highBit - 1) & width)
+        highBit <<= 1;
+      *pwidth = highBit;
+      /* height is a don't-care */
+        break;
+  }
+}
+
+/*
+ * PsGetMediumDimensions is installed in the GetMediumDimensions field
+ * of each Ps-initialized context.
+ */
+int
+PsGetMediumDimensions(XpContextPtr pCon, CARD16 *width, CARD16 *height)
+{
+    XpGetMediumDimensions(pCon, width, height);
+    return Success;
+}
+
+/*
+ * PsGetReproducibleArea is installed in the GetReproducibleArea field
+ * of each Ps-initialized context.
+ */
+int
+PsGetReproducibleArea(XpContextPtr pCon, xRectangle *pRect)
+{
+    XpGetReproductionArea(pCon, pRect);
+    return Success;
+}
+
+/*
+ * PsSetImageResolution is installed in the SetImageResolution field
+ * of each Ps-initialized context.
+ */
+int
+PsSetImageResolution(XpContextPtr pCon, int imageRes, Bool *status)
+{
+    pCon->imageRes = imageRes;
+    *status = True;
+    return Success;
+}
+
+/*
+ * GetPropString searches the window heirarchy from pWin up looking for
+ * a property by the name of propName.  If found, returns the property's
+ * value. If not, it returns NULL.
+ */
+/*
+char *
+GetPropString(
+    WindowPtr pWin,
+    char *propName)
+{
+    Atom atom;
+    PropertyPtr pProp = (PropertyPtr)NULL;
+    char *retVal;
+
+    atom = MakeAtom(propName, strlen(propName), FALSE);
+    if(atom != BAD_RESOURCE)
+    {
+        WindowPtr pPropWin;
+	int n;
+*/
+
+	/*
+	 * The atom has been defined, but it might only exist as a
+	 * property on an unrelated window.
+	 */
+/*
+        for(pPropWin = pWin; pPropWin != (WindowPtr)NULL; 
+	    pPropWin = pPropWin->parent)
+        {
+	    for(pProp = (PropertyPtr)(wUserProps(pPropWin)); 
+		pProp != (PropertyPtr)NULL;
+	        pProp = pProp->next)
+	    {
+                if (pProp->propertyName == atom)
+                    break;
+	    }
+	    if(pProp != (PropertyPtr)NULL)
+	        break;
+        }
+	if(pProp == (PropertyPtr)NULL)
+	    return (char *)NULL;
+
+	n = (pProp->format/8) * pProp->size; *//* size (bytes) of prop */
+/*
+	retVal = (char *)xalloc(n + 1);
+	(void)memcpy((void *)retVal, (void *)pProp->data, n);
+	retVal[n] = '\0';
+
+	return retVal;
+    }
+
+    return (char *)NULL;
+}
+
+#include <signal.h>
+
+*/
+/* ARGSUSED */
+/*
+static void SigchldHndlr (int dummy)
+{
+    int   status, w;
+    struct sigaction act;
+    sigfillset(&act.sa_mask);
+    act.sa_flags = 0;
+    act.sa_handler = SigchldHndlr;
+
+    w = wait (&status);
+
+*/
+    /*
+     * Is this really necessary?
+     */
+/*
+    sigaction(SIGCHLD, &act, (struct sigaction *)NULL);
+}
+*/
+
+/*
+ * 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.
+ */
+/*
+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;
+}
+*/
+
+Bool
+PsCloseScreen(
+  int       index,
+  ScreenPtr pScreen)
+{
+  return TRUE;
+}
+
+void
+PsLineAttrs(
+  PsOutPtr    psOut,
+  GCPtr       pGC,
+  ColormapPtr cMap)
+{
+  int        i;
+  int        nDsh;
+  int        dshOff;
+  int       *dsh;
+  PsCapEnum  cap;
+  PsJoinEnum join;
+
+  switch(pGC->capStyle) {
+    case CapButt:       cap = PsCButt;   break;
+    case CapRound:      cap = PsCRound;  break;
+    case CapProjecting: cap = PsCSquare; break;
+    default:            cap = PsCButt;   break; }
+  switch(pGC->joinStyle) {
+    case JoinMiter:   join = PsJMiter; break;
+    case JoinRound:   join = PsJRound; break;
+    case JoinBevel:   join = PsJBevel; break;
+    default:          join = PsJBevel; break; }
+  if( pGC->lineStyle==LineSolid ) { nDsh = dshOff = 0; dsh = (int *)0; }
+  else
+  {
+    nDsh   = pGC->numInDashList;
+    dshOff = pGC->dashOffset;
+    if( !nDsh ) dsh = (int *)0;
+    else
+    {
+      dsh = (int *)xalloc(sizeof(int)*nDsh);
+      for( i=0 ; i<nDsh ; i++ ) dsh[i] = (int)pGC->dash[i]&0xFF;
+    }
+  }
+
+  if( pGC->lineStyle!=LineDoubleDash )
+    PsOut_LineAttrs(psOut, (int)pGC->lineWidth,
+                    cap, join, nDsh, dsh, dshOff, -1);
+  else
+    PsOut_LineAttrs(psOut, (int)pGC->lineWidth,
+                    cap, join, nDsh, dsh, dshOff,
+                    PsGetPixelColor(cMap, pGC->bgPixel));
+  if( nDsh && dsh ) xfree(dsh);
+}
diff --git a/Xprint/ps/PsPixel.c b/Xprint/ps/PsPixel.c
new file mode 100644
index 000000000..c2c360d2e
--- /dev/null
+++ b/Xprint/ps/PsPixel.c
@@ -0,0 +1,153 @@
+/* $Xorg: PsPixel.c,v 1.4 2001/02/09 02:04:36 xorgcvs Exp $ */
+/*
+
+Copyright 1996, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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
+OPEN GROUP 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 name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+/*
+ * (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:		PsPixel.c
+**    *
+**    *  Contents:	Pixel-drawing code for the PS DDX driver
+**    *
+**    *  Created By:	Roger Helmendach (Liberty Systems)
+**    *
+**    *  Copyright:	Copyright 1995 The Open Group, Inc.
+**    *
+**    *********************************************************
+** 
+********************************************************************/
+
+#include <stdio.h>
+
+#include "windowstr.h"
+#include "gcstruct.h"
+
+#include "Ps.h"
+
+void
+PsPolyPoint(
+  DrawablePtr  pDrawable,
+  GCPtr        pGC,
+  int          mode,
+  int          nPoints,
+  xPoint      *pPoints)
+{
+  if( pDrawable->type==DRAWABLE_PIXMAP )
+  {
+    DisplayElmPtr   elm;
+    PixmapPtr       pix  = (PixmapPtr)pDrawable;
+    PsPixmapPrivPtr priv = (PsPixmapPrivPtr)pix->devPrivate.ptr;
+    DisplayListPtr  disp;
+    GCPtr           gc;
+
+    if ((gc = PsCreateAndCopyGC(pDrawable, pGC)) == NULL) return;
+
+    disp = PsGetFreeDisplayBlock(priv);
+
+    elm  = &disp->elms[disp->nelms];
+    elm->type = PolyPointCmd;
+    elm->gc   = gc;
+    elm->c.polyPts.mode    = mode;
+    elm->c.polyPts.nPoints = nPoints;
+    elm->c.polyPts.pPoints = (xPoint *)xalloc(nPoints*sizeof(xPoint));
+    memcpy(elm->c.polyPts.pPoints, pPoints, nPoints*sizeof(xPoint));
+    disp->nelms += 1;
+  }
+  else
+  {
+    int         i;
+    PsOutPtr    psOut;
+    PsPointPtr  pts;
+    ColormapPtr cMap;
+
+    if( PsUpdateDrawableGC(pGC, pDrawable, &psOut, &cMap)==FALSE ) return;
+    PsOut_Offset(psOut, pDrawable->x, pDrawable->y);
+    PsOut_Color(psOut, PsGetPixelColor(cMap, pGC->fgPixel));
+    pts = (PsPointPtr)xalloc(sizeof(PsPointRec)*nPoints);
+    if( mode==CoordModeOrigin )
+    {
+      for( i=0 ; i<nPoints ; i++ )
+        { pts[i].x = pPoints[i].x; pts[i].y = pPoints[i].y; }
+    }
+    else
+    {
+      pts[0].x = pPoints[0].x; pts[0].y = pPoints[0].y;
+      for( i=1 ; i<nPoints ;  i++ )
+      {
+        pts[i].x = pts[i-1].x+pPoints[i].x;
+        pts[i].y = pts[i-1].y+pPoints[i].y;
+      }
+    }
+    PsOut_Points(psOut, nPoints, pts);
+    xfree(pts);
+  }
+}
+
+void
+PsPushPixels(
+  GCPtr       pGC,
+  PixmapPtr   pBitmap,
+  DrawablePtr pDrawable,
+  int         width,
+  int         height,
+  int         x,
+  int         y)
+{
+}
diff --git a/Xprint/ps/PsPixmap.c b/Xprint/ps/PsPixmap.c
new file mode 100644
index 000000000..2c3e43245
--- /dev/null
+++ b/Xprint/ps/PsPixmap.c
@@ -0,0 +1,597 @@
+/* $Xorg: PsPixmap.c,v 1.4 2001/02/09 02:04:36 xorgcvs Exp $ */
+/*
+
+Copyright 1996, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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
+OPEN GROUP 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 name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+/*
+ * (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:		PsPixmap.c
+**    *
+**    *  Contents:	Pixmap functions for the PS DDX driver
+**    *
+**    *  Created By:	Roger Helmendach (Liberty Systems)
+**    *
+**    *  Copyright:	Copyright 1995 The Open Group, Inc.
+**    *
+**    *********************************************************
+** 
+********************************************************************/
+
+#include "windowstr.h"
+#include "gcstruct.h"
+
+#include "Ps.h"
+
+#define BitsPerPixel(d) (\
+  (1 << PixmapWidthPaddingInfo[d].padBytesLog2) * 8 / \
+  (PixmapWidthPaddingInfo[d].padRoundUp+1))
+
+PixmapPtr
+PsCreatePixmap(
+  ScreenPtr pScreen,
+  int       width,
+  int       height,
+  int       depth)
+{
+  PixmapPtr pPixmap;
+
+  pPixmap = (PixmapPtr)xalloc(sizeof(PixmapRec));
+  if( !pPixmap)  return NullPixmap;
+  pPixmap->drawable.type         = DRAWABLE_PIXMAP;
+  pPixmap->drawable.class        = 0;
+  pPixmap->drawable.pScreen      = pScreen;
+  pPixmap->drawable.depth        = depth;
+  pPixmap->drawable.bitsPerPixel = BitsPerPixel(depth);
+  pPixmap->drawable.id           = 0;
+  pPixmap->drawable.serialNumber = NEXT_SERIAL_NUMBER;
+  pPixmap->drawable.x            = 0;
+  pPixmap->drawable.y            = 0;
+  pPixmap->drawable.width        = width;
+  pPixmap->drawable.height       = height;
+  pPixmap->devKind               = 0;
+  pPixmap->refcnt                = 1;
+
+  pPixmap->devPrivate.ptr = (PsPixmapPrivPtr)xalloc(sizeof(PsPixmapPrivRec));
+  if( !pPixmap->devPrivate.ptr )
+    { xfree(pPixmap); return NullPixmap; }
+  memset(pPixmap->devPrivate.ptr, 0, sizeof(PsPixmapPrivRec));
+  return pPixmap;
+}
+
+Bool
+PsDestroyPixmap(PixmapPtr pPixmap)
+{
+  PsPixmapPrivPtr priv = (PsPixmapPrivPtr)pPixmap->devPrivate.ptr;
+  DisplayListPtr  disp = priv->dispList;
+
+  if( --pPixmap->refcnt ) return TRUE;
+  while( disp )
+  {
+    int            i;
+    DisplayListPtr oldDisp = disp;
+    disp = disp->next;
+    for( i=0 ; i<oldDisp->nelms ; i++ )
+    {
+      DisplayElmPtr elm = &oldDisp->elms[i];
+
+      switch(elm->type)
+      {
+        case PolyPointCmd:
+        case PolyLineCmd:
+          if( elm->c.polyPts.pPoints ) xfree(elm->c.polyPts.pPoints);
+          break;
+        case PolySegmentCmd:
+          if( elm->c.segments.pSegments ) xfree(elm->c.segments.pSegments);
+          break;
+        case PolyRectangleCmd:
+          if( elm->c.rects.pRects ) xfree(elm->c.rects.pRects);
+          break;
+        case FillPolygonCmd:
+          if( elm->c.polyPts.pPoints ) xfree(elm->c.polyPts.pPoints);
+          break;
+        case PolyFillRectCmd:
+          if( elm->c.rects.pRects ) xfree(elm->c.rects.pRects);
+          break;
+        case PolyArcCmd:
+          if( elm->c.arcs.pArcs ) xfree(elm->c.arcs.pArcs);
+          break;
+        case PolyFillArcCmd:
+          if( elm->c.arcs.pArcs ) xfree(elm->c.arcs.pArcs);
+          break;
+        case Text8Cmd:
+        case TextI8Cmd:
+          if( elm->c.text8.string ) xfree(elm->c.text8.string);
+          break;
+        case Text16Cmd:
+        case TextI16Cmd:
+          if( elm->c.text16.string ) xfree(elm->c.text16.string);
+          break;
+        case PutImageCmd:
+          if( elm->c.image.pData ) xfree(elm->c.image.pData);
+          break;
+        case BeginFrameCmd:
+          break;
+        case EndFrameCmd:
+          break;
+      }
+
+      if (elm->type != BeginFrameCmd && elm->type != EndFrameCmd) {
+	  (void) FreeGC(elm->gc, (GContext) 0);
+      }
+    }
+    xfree(oldDisp);
+  }
+  xfree(priv);
+  xfree(pPixmap);
+  return TRUE;
+}
+
+DisplayListPtr
+PsGetFreeDisplayBlock(PsPixmapPrivPtr priv)
+{
+  DisplayListPtr disp = priv->dispList;
+
+  for(; disp ; disp=disp->next )
+  {
+    if( disp->nelms>=DPY_BLOCKSIZE && disp->next ) continue;
+    if( disp->nelms<DPY_BLOCKSIZE ) return(disp);
+    disp->next = (DisplayListPtr)xalloc(sizeof(DisplayListRec));
+    disp->next->next  = (DisplayListPtr)0;
+    disp->next->nelms = 0;
+  }
+  disp = (DisplayListPtr)xalloc(sizeof(DisplayListRec));
+  disp->next     = (DisplayListPtr)0;
+  disp->nelms    = 0;
+  priv->dispList = disp;
+  return(disp);
+}
+
+void
+PsReplay(DisplayElmPtr elm, DrawablePtr pDrawable)
+{
+  switch(elm->type)
+  {
+    case PolyPointCmd:
+      PsPolyPoint(pDrawable, elm->gc, elm->c.polyPts.mode,
+                 elm->c.polyPts.nPoints, elm->c.polyPts.pPoints);
+      break;
+    case PolyLineCmd:
+      PsPolyLine(pDrawable, elm->gc, elm->c.polyPts.mode,
+                 elm->c.polyPts.nPoints, elm->c.polyPts.pPoints);
+      break;
+    case PolySegmentCmd:
+      PsPolySegment(pDrawable, elm->gc, elm->c.segments.nSegments,
+                    elm->c.segments.pSegments);
+      break;
+    case PolyRectangleCmd:
+      PsPolyRectangle(pDrawable, elm->gc, elm->c.rects.nRects,
+                      elm->c.rects.pRects);
+      break;
+    case FillPolygonCmd:
+      PsFillPolygon(pDrawable, elm->gc, 0, elm->c.polyPts.mode,
+                    elm->c.polyPts.nPoints, elm->c.polyPts.pPoints);
+      break;
+    case PolyFillRectCmd:
+      PsPolyFillRect(pDrawable, elm->gc, elm->c.rects.nRects,
+                     elm->c.rects.pRects);
+      break;
+    case PolyArcCmd:
+      PsPolyArc(pDrawable, elm->gc, elm->c.arcs.nArcs, elm->c.arcs.pArcs);
+      break;
+    case PolyFillArcCmd:
+      PsPolyFillArc(pDrawable, elm->gc, elm->c.arcs.nArcs, elm->c.arcs.pArcs);
+      break;
+    case Text8Cmd:
+      PsPolyText8(pDrawable, elm->gc, elm->c.text8.x, elm->c.text8.y,
+                  elm->c.text8.count, elm->c.text8.string);
+      break;
+    case Text16Cmd:
+      PsPolyText16(pDrawable, elm->gc, elm->c.text16.x, elm->c.text16.y,
+                   elm->c.text16.count, elm->c.text16.string);
+      break;
+    case TextI8Cmd:
+      PsImageText8(pDrawable, elm->gc, elm->c.text8.x, elm->c.text8.y,
+                   elm->c.text8.count, elm->c.text8.string);
+      break;
+    case TextI16Cmd:
+      PsImageText16(pDrawable, elm->gc, elm->c.text16.x, elm->c.text16.y,
+                    elm->c.text16.count, elm->c.text16.string);
+      break;
+    case PutImageCmd:
+      PsPutScaledImage(pDrawable, elm->gc, elm->c.image.depth,
+		       elm->c.image.x, elm->c.image.y,
+		       elm->c.image.w, elm->c.image.h, elm->c.image.leftPad,
+		       elm->c.image.format, elm->c.image.res,
+		       elm->c.image.pData);
+      break;
+    case BeginFrameCmd:
+      {
+        PsOutPtr     psOut;
+        ColormapPtr  cMap;
+        if( PsUpdateDrawableGC(NULL, pDrawable, &psOut, &cMap)==FALSE ) return;
+        PsOut_BeginFrame(psOut, 0, 0, elm->c.frame.x, elm->c.frame.y,
+                         elm->c.frame.w, elm->c.frame.h);
+      }
+      break;
+    case EndFrameCmd:
+      {
+        PsOutPtr     psOut;
+        ColormapPtr  cMap;
+        if( PsUpdateDrawableGC(NULL, pDrawable, &psOut, &cMap)==FALSE ) return;
+        PsOut_EndFrame(psOut);
+      }
+      break;
+  }
+}
+
+void
+PsReplayPixmap(PixmapPtr pix, DrawablePtr pDrawable)
+{
+  PsPixmapPrivPtr priv = (PsPixmapPrivPtr)pix->devPrivate.ptr;
+  DisplayListPtr  disp = priv->dispList;
+  DisplayElmPtr   elm;
+
+  for(; disp ; disp=disp->next )
+  {
+    int  i;
+    for( i=0,elm=disp->elms ; i<disp->nelms ; i++,elm++ )
+      PsReplay(elm, pDrawable);
+  }
+}
+
+int
+PsCloneDisplayElm(PixmapPtr dst, DisplayElmPtr elm, DisplayElmPtr newElm, 
+		  int xoff, int yoff)
+{
+  int           i;
+  int           size;
+  int           status = 0;
+
+  *newElm = *elm;
+
+  /* I think this is the correct return value */
+  if ((newElm->gc = PsCreateAndCopyGC(&dst->drawable, elm->gc)) == NULL) {
+      return 1;
+  }
+
+  switch(elm->type)
+  {
+    case PolyPointCmd:
+    case PolyLineCmd:
+      newElm->c.polyPts.pPoints =
+        (xPoint *)xalloc(elm->c.polyPts.nPoints*sizeof(xPoint));
+      for( i=0 ; i<elm->c.polyPts.nPoints ; i++ )
+      {
+        newElm->c.polyPts.pPoints[i].x = elm->c.polyPts.pPoints[i].x+xoff;
+        newElm->c.polyPts.pPoints[i].y = elm->c.polyPts.pPoints[i].y+yoff;
+      }
+      break;
+    case PolySegmentCmd:
+      newElm->c.segments.pSegments =
+        (xSegment *)xalloc(elm->c.segments.nSegments*sizeof(xSegment));
+      for( i=0 ; i<elm->c.segments.nSegments ; i++ )
+      {
+        newElm->c.segments.pSegments[i].x1 =
+           elm->c.segments.pSegments[i].x1+xoff;
+        newElm->c.segments.pSegments[i].y1 =
+           elm->c.segments.pSegments[i].y1+yoff;
+        newElm->c.segments.pSegments[i].x2 =
+           elm->c.segments.pSegments[i].x2+xoff;
+        newElm->c.segments.pSegments[i].y2 =
+           elm->c.segments.pSegments[i].y2+yoff;
+      }
+      break;
+    case PolyRectangleCmd:
+      newElm->c.rects.pRects =
+        (xRectangle *)xalloc(elm->c.rects.nRects*sizeof(xRectangle));
+      for( i=0 ; i<elm->c.rects.nRects ; i++ )
+      {
+        newElm->c.rects.pRects[i].x      = elm->c.rects.pRects[i].x+xoff;
+        newElm->c.rects.pRects[i].y      = elm->c.rects.pRects[i].y+yoff;
+        newElm->c.rects.pRects[i].width  = elm->c.rects.pRects[i].width;
+        newElm->c.rects.pRects[i].height = elm->c.rects.pRects[i].height;
+      }
+      break;
+    case FillPolygonCmd:
+      newElm->c.polyPts.pPoints =
+        (xPoint *)xalloc(elm->c.polyPts.nPoints*sizeof(xPoint));
+      for( i=0 ; i<elm->c.polyPts.nPoints ; i++ )
+      {
+        newElm->c.polyPts.pPoints[i].x = elm->c.polyPts.pPoints[i].x+xoff;
+        newElm->c.polyPts.pPoints[i].y = elm->c.polyPts.pPoints[i].y+yoff;
+      }
+      break;
+    case PolyFillRectCmd:
+      newElm->c.rects.pRects =
+        (xRectangle *)xalloc(elm->c.rects.nRects*sizeof(xRectangle));
+      for( i=0 ; i<elm->c.rects.nRects ; i++ )
+      {
+        newElm->c.rects.pRects[i].x      = elm->c.rects.pRects[i].x+xoff;
+        newElm->c.rects.pRects[i].y      = elm->c.rects.pRects[i].y+yoff;
+        newElm->c.rects.pRects[i].width  = elm->c.rects.pRects[i].width;
+        newElm->c.rects.pRects[i].height = elm->c.rects.pRects[i].height;
+      }
+      break;
+    case PolyArcCmd:
+      newElm->c.arcs.pArcs =
+        (xArc *)xalloc(elm->c.arcs.nArcs*sizeof(xArc));
+      for( i=0 ; i<elm->c.arcs.nArcs ; i++ )
+      {
+        newElm->c.arcs.pArcs[i].x      = elm->c.arcs.pArcs[i].x+xoff;
+        newElm->c.arcs.pArcs[i].y      = elm->c.arcs.pArcs[i].y+yoff;
+        newElm->c.arcs.pArcs[i].width  = elm->c.arcs.pArcs[i].width;
+        newElm->c.arcs.pArcs[i].height = elm->c.arcs.pArcs[i].height;
+        newElm->c.arcs.pArcs[i].angle1 = elm->c.arcs.pArcs[i].angle1;
+        newElm->c.arcs.pArcs[i].angle2 = elm->c.arcs.pArcs[i].angle2;
+      }
+      break;
+    case PolyFillArcCmd:
+      newElm->c.arcs.pArcs =
+        (xArc *)xalloc(elm->c.arcs.nArcs*sizeof(xArc));
+      for( i=0 ; i<elm->c.arcs.nArcs ; i++ )
+      {
+        newElm->c.arcs.pArcs[i].x      = elm->c.arcs.pArcs[i].x+xoff;
+        newElm->c.arcs.pArcs[i].y      = elm->c.arcs.pArcs[i].y+yoff;
+        newElm->c.arcs.pArcs[i].width  = elm->c.arcs.pArcs[i].width;
+        newElm->c.arcs.pArcs[i].height = elm->c.arcs.pArcs[i].height;
+        newElm->c.arcs.pArcs[i].angle1 = elm->c.arcs.pArcs[i].angle1;
+        newElm->c.arcs.pArcs[i].angle2 = elm->c.arcs.pArcs[i].angle2;
+      }
+      break;
+    case Text8Cmd:
+    case TextI8Cmd:
+      newElm->c.text8.string = (char *)xalloc(elm->c.text8.count);
+      memcpy(newElm->c.text8.string, elm->c.text8.string, elm->c.text8.count);
+      newElm->c.text8.x += xoff;
+      newElm->c.text8.y += yoff;
+      break;
+    case Text16Cmd:
+    case TextI16Cmd:
+      newElm->c.text16.string =
+        (unsigned short *)xalloc(elm->c.text16.count*sizeof(unsigned short));
+      memcpy(newElm->c.text16.string, elm->c.text16.string,
+             elm->c.text16.count*sizeof(unsigned short));
+      newElm->c.text16.x += xoff;
+      newElm->c.text16.y += yoff;
+      break;
+    case PutImageCmd:
+      size = PixmapBytePad(elm->c.image.w, elm->c.image.depth)*elm->c.image.h;
+      newElm->c.image.pData = (char *)xalloc(size);
+      memcpy(newElm->c.image.pData, elm->c.image.pData, size);
+      newElm->c.image.x += xoff;
+      newElm->c.image.y += yoff;
+      break;
+    case BeginFrameCmd:
+    case EndFrameCmd:
+      status = 1;
+      break;
+  }
+  return(status);
+}
+
+void
+PsCopyDisplayList(PixmapPtr src, PixmapPtr dst, int xoff, int yoff,
+                  int x, int y, int w, int h)
+{
+  PsPixmapPrivPtr sPriv = (PsPixmapPrivPtr)src->devPrivate.ptr;
+  PsPixmapPrivPtr dPriv = (PsPixmapPrivPtr)dst->devPrivate.ptr;
+  DisplayListPtr  sDisp;
+  DisplayListPtr  dDisp = PsGetFreeDisplayBlock(dPriv);
+  DisplayElmPtr   elm   = &dDisp->elms[dDisp->nelms];
+
+  elm->type = BeginFrameCmd;
+  elm->c.frame.x = x;
+  elm->c.frame.y = y;
+  elm->c.frame.w = w;
+  elm->c.frame.h = h;
+  dDisp->nelms += 1;
+
+  sDisp = sPriv->dispList;
+  for(; sDisp ; sDisp=sDisp->next )
+  {
+    int  i;
+    for( i=0,elm=sDisp->elms ; i<sDisp->nelms ; i++,elm++ )
+    {
+      dDisp = PsGetFreeDisplayBlock(dPriv);
+      if (PsCloneDisplayElm(dst, elm, &dDisp->elms[dDisp->nelms],
+			    xoff, yoff)==0)
+      {
+	  dDisp->nelms += 1;
+      }
+    }
+  }
+
+  dDisp = PsGetFreeDisplayBlock(dPriv);
+  elm   = &dDisp->elms[dDisp->nelms];
+  elm->type = EndFrameCmd;
+  dDisp->nelms += 1;
+}
+
+PsElmPtr
+PsCreateFillElementList(PixmapPtr pix, int *nElms)
+{
+  PsElmPtr        elms = (PsElmPtr)0;
+  PsPixmapPrivPtr priv = (PsPixmapPrivPtr)pix->devPrivate.ptr;
+  DisplayListPtr  disp = priv->dispList;
+  PsArcEnum       styl;
+
+  *nElms = 0;
+  for(; disp ; disp=disp->next )
+  {
+    int           i;
+    DisplayElmPtr elm = disp->elms;
+
+    for( i=0 ; i<disp->nelms ; i++,elm++ )
+    {
+      if( !elm->gc->fgPixel ) continue;
+      switch(elm->type)
+      {
+        case FillPolygonCmd:
+          *nElms += 1;
+          break;
+        case PolyFillRectCmd:
+          *nElms += elm->c.rects.nRects;
+          break;
+        case PolyFillArcCmd:
+          *nElms += elm->c.arcs.nArcs;
+          break;
+      }
+    }
+  }
+
+  if( (*nElms) )
+  {
+    elms = (PsElmPtr)xalloc((*nElms)*sizeof(PsElmRec));
+    if( elms )
+    {
+      disp = priv->dispList;
+      *nElms = 0;
+      for(; disp ; disp=disp->next )
+      {
+        int           i, k;
+        DisplayElmPtr elm = disp->elms;
+
+        for( i=0 ; i<disp->nelms ; i++,elm++ )
+        {
+          if( !elm->gc->fgPixel ) continue;
+          switch(elm->type)
+          {
+            case FillPolygonCmd:
+              elms[*nElms].type     = PSOUT_POINTS;
+              elms[*nElms].nPoints  = elm->c.polyPts.nPoints;
+              elms[*nElms].c.points =
+                  (PsPointPtr)xalloc(elms[*nElms].nPoints*sizeof(PsPointRec));
+              for( k=0 ; k<elms[*nElms].nPoints ; k++ )
+              {
+                elms[*nElms].c.points[k].x = elm->c.polyPts.pPoints[k].x;
+                elms[*nElms].c.points[k].y = elm->c.polyPts.pPoints[k].y;
+              }
+              *nElms += 1;
+              break;
+            case PolyFillRectCmd:
+              for( k=0 ; k<elm->c.rects.nRects ; k++ )
+              {
+                elms[*nElms].type = PSOUT_RECT;
+                elms[*nElms].nPoints  = 0;
+                elms[*nElms].c.rect.x = elm->c.rects.pRects[k].x;
+                elms[*nElms].c.rect.y = elm->c.rects.pRects[k].y;
+                elms[*nElms].c.rect.w = elm->c.rects.pRects[k].width;
+                elms[*nElms].c.rect.h = elm->c.rects.pRects[k].height;
+                *nElms += 1;
+              }
+              break;
+            case PolyFillArcCmd:
+              if( elm->gc->arcMode==ArcChord ) styl = PsChord;
+              else                            styl = PsPieSlice;
+              for( k=0 ; k<elm->c.rects.nRects ; k++ )
+              {
+                elms[*nElms].type = PSOUT_ARC;
+                elms[*nElms].nPoints     = 0;
+                elms[*nElms].c.arc.x     = elm->c.arcs.pArcs[k].x;
+                elms[*nElms].c.arc.y     = elm->c.arcs.pArcs[k].y;
+                elms[*nElms].c.arc.w     = elm->c.arcs.pArcs[k].width;
+                elms[*nElms].c.arc.h     = elm->c.arcs.pArcs[k].height;
+                elms[*nElms].c.arc.a1    = elm->c.arcs.pArcs[k].angle1;
+                elms[*nElms].c.arc.a2    = elm->c.arcs.pArcs[k].angle2;
+                elms[*nElms].c.arc.style = styl;
+                *nElms += 1;
+              }
+              break;
+          }
+        }
+      }
+    }
+  }
+  return(elms);
+}
+
+PsElmPtr
+PsCloneFillElementList(int nElms, PsElmPtr elms)
+{
+  int      i;
+  PsElmPtr newElms;
+
+  newElms = (PsElmPtr)xalloc(nElms*sizeof(PsElmRec));
+  if( !newElms ) return(newElms);
+  for( i=0 ; i<nElms ; i++ )
+  {
+    newElms[i] = elms[i];
+
+    if( elms[i].type==PSOUT_POINTS )
+    {
+      newElms[i].c.points =
+             (PsPointPtr)xalloc(elms[i].nPoints*sizeof(PsElmRec));
+      memcpy(newElms[i].c.points, elms[i].c.points,
+             elms[i].nPoints*sizeof(PsPointRec));
+    }
+  }
+  return(newElms);
+}
+
+void
+PsDestroyFillElementList(int nElms, PsElmPtr elms)
+{
+  int  i;
+
+  for( i=0 ; i<nElms ; i++ )
+    { if( elms[i].type==PSOUT_POINTS ) xfree(elms[i].c.points); }
+
+  xfree(elms);
+}
diff --git a/Xprint/ps/PsPolygon.c b/Xprint/ps/PsPolygon.c
new file mode 100644
index 000000000..e1f0b9003
--- /dev/null
+++ b/Xprint/ps/PsPolygon.c
@@ -0,0 +1,232 @@
+/* $Xorg: PsPolygon.c,v 1.4 2001/02/09 02:04:36 xorgcvs Exp $ */
+/*
+
+Copyright 1996, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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
+OPEN GROUP 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 name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+/*
+ * (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:		PsPolygon.c
+**    *
+**    *  Contents:	Draws Polygons and Rectangles for the PS DDX
+**    *
+**    *  Created By:	Roger Helmendach (Liberty Systems)
+**    *
+**    *  Copyright:	Copyright 1996 The Open Group, Inc.
+**    *
+**    *********************************************************
+** 
+********************************************************************/
+
+#include "Ps.h"
+#include "gcstruct.h"
+#include "windowstr.h"
+
+void
+PsPolyRectangle(
+  DrawablePtr pDrawable,
+  GCPtr       pGC,
+  int         nRects,
+  xRectangle *pRects)
+{
+  if( pDrawable->type==DRAWABLE_PIXMAP )
+  {
+    DisplayElmPtr   elm;
+    PixmapPtr       pix  = (PixmapPtr)pDrawable;
+    PsPixmapPrivPtr priv = (PsPixmapPrivPtr)pix->devPrivate.ptr;
+    DisplayListPtr  disp;
+    GCPtr           gc;
+
+    if ((gc = PsCreateAndCopyGC(pDrawable, pGC)) == NULL) return;
+
+    disp = PsGetFreeDisplayBlock(priv);
+
+    elm  = &disp->elms[disp->nelms];
+    elm->type = PolyRectangleCmd;
+    elm->gc   = gc;
+    elm->c.rects.nRects = nRects;
+    elm->c.rects.pRects = (xRectangle *)xalloc(nRects*sizeof(xRectangle));
+    memcpy(elm->c.rects.pRects, pRects, nRects*sizeof(xRectangle));
+    disp->nelms += 1;
+  }
+  else
+  {
+    int         i;
+    PsOutPtr    psOut;
+    ColormapPtr cMap;
+
+    if( PsUpdateDrawableGC(pGC, pDrawable, &psOut, &cMap)==FALSE ) return;
+    PsOut_Offset(psOut, pDrawable->x, pDrawable->y);
+    PsOut_Color(psOut, PsGetPixelColor(cMap, pGC->fgPixel));
+    PsLineAttrs(psOut, pGC, cMap);
+    for( i=0 ; i<nRects ; i++ )
+    {
+      PsOut_DrawRect(psOut, (int)pRects[i].x, (int)pRects[i].y,
+                     (int)pRects[i].width, (int)pRects[i].height);
+    }
+  }
+}
+
+void
+PsFillPolygon(
+  DrawablePtr   pDrawable,
+  GCPtr         pGC,
+  int           shape,
+  int           mode,
+  int           nPoints,
+  DDXPointPtr   pPoints)
+{
+  if( pDrawable->type==DRAWABLE_PIXMAP )
+  {
+    DisplayElmPtr   elm;
+    PixmapPtr       pix  = (PixmapPtr)pDrawable;
+    PsPixmapPrivPtr priv = (PsPixmapPrivPtr)pix->devPrivate.ptr;
+    DisplayListPtr  disp;
+    GCPtr           gc;
+
+    if ((gc = PsCreateAndCopyGC(pDrawable, pGC)) == NULL) return;
+
+    disp = PsGetFreeDisplayBlock(priv);
+
+    elm  = &disp->elms[disp->nelms];
+    elm->type = FillPolygonCmd;
+    elm->gc   = gc;
+    elm->c.polyPts.mode    = mode;
+    elm->c.polyPts.nPoints = nPoints;
+    elm->c.polyPts.pPoints = (xPoint *)xalloc(nPoints*sizeof(xPoint));
+    memcpy(elm->c.polyPts.pPoints, pPoints, nPoints*sizeof(xPoint));
+    disp->nelms += 1;
+  }
+  else
+  {
+    int           i;
+    PsOutPtr      psOut;
+    PsPointPtr    pts;
+    PsRuleEnum    rule;
+    ColormapPtr   cMap;
+
+    if( PsUpdateDrawableGC(pGC, pDrawable, &psOut, &cMap)==FALSE ) return;
+    PsOut_Offset(psOut, pDrawable->x, pDrawable->y);
+    PsSetFillColor(pDrawable, pGC, psOut, cMap);
+    if( pGC->fillRule==EvenOddRule ) rule = PsEvenOdd;
+    else                             rule = PsNZWinding;
+    PsOut_FillRule(psOut, rule);
+    pts = (PsPointPtr)xalloc(sizeof(PsPointRec)*nPoints);
+    if( mode==CoordModeOrigin )
+    {
+      for( i=0 ; i<nPoints ; i++ )
+        { pts[i].x = pPoints[i].x; pts[i].y = pPoints[i].y; }
+    }
+    else
+    {
+      pts[0].x = pPoints[i].x; pts[0].y = pPoints[i].y;
+      for( i=1 ; i<nPoints ;  i++ )
+      {
+        pts[i].x = pts[i-1].x+pPoints[i].x;
+        pts[i].y = pts[i-1].y+pPoints[i].y;
+      }
+    }
+    PsOut_Polygon(psOut, nPoints, pts);
+    xfree(pts);
+  }
+}
+
+void
+PsPolyFillRect(
+  DrawablePtr pDrawable,
+  GCPtr       pGC,
+  int         nRects,
+  xRectangle *pRects)
+{
+  if( pDrawable->type==DRAWABLE_PIXMAP )
+  {
+    DisplayElmPtr   elm;
+    PixmapPtr       pix  = (PixmapPtr)pDrawable;
+    PsPixmapPrivPtr priv = (PsPixmapPrivPtr)pix->devPrivate.ptr;
+    DisplayListPtr  disp;
+    GCPtr           gc;
+
+    if ((gc = PsCreateAndCopyGC(pDrawable, pGC)) == NULL) return;
+
+    disp = PsGetFreeDisplayBlock(priv);
+
+    elm  = &disp->elms[disp->nelms];
+    elm->type = PolyFillRectCmd;
+    elm->gc   = gc;
+    elm->c.rects.nRects = nRects;
+    elm->c.rects.pRects = (xRectangle *)xalloc(nRects*sizeof(xRectangle));
+    memcpy(elm->c.rects.pRects, pRects, nRects*sizeof(xRectangle));
+    disp->nelms += 1;
+  }
+  else
+  {
+    int         i;
+    PsOutPtr    psOut;
+    ColormapPtr cMap;
+
+    if( PsUpdateDrawableGC(pGC, pDrawable, &psOut, &cMap)==FALSE ) return;
+    PsOut_Offset(psOut, pDrawable->x, pDrawable->y);
+    PsSetFillColor(pDrawable, pGC, psOut, cMap);
+    for( i=0 ; i<nRects ; i++ )
+    {
+      PsOut_FillRect(psOut, (int)pRects[i].x, (int)pRects[i].y,
+                     (int)pRects[i].width, (int)pRects[i].height);
+    }
+  }
+}
diff --git a/Xprint/ps/PsPrint.c b/Xprint/ps/PsPrint.c
new file mode 100644
index 000000000..49ed97583
--- /dev/null
+++ b/Xprint/ps/PsPrint.c
@@ -0,0 +1,434 @@
+/* $Xorg: PsPrint.c,v 1.7 2001/03/14 18:28:18 pookie Exp $ */
+/*
+
+Copyright 1996, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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
+OPEN GROUP 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 name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+/*
+ * (c) Copyright 1996 Hewlett-Packard Company
+ * (c) Copyright 1996 International Business Machines Corp.
+ * (c) Copyright 1996, 2000 Sun Microsystems, Inc.  All rights reserved.
+ * (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:		PsPrint.c
+**    *
+**    *  Contents:	Print extension code of Ps driver
+**    *
+**    *  Created By:	Roger Helmendach (Liberty Systems)
+**    *
+**    *  Copyright:	Copyright 1996 The Open Group, Inc.
+**    *
+**    *********************************************************
+** 
+********************************************************************/
+
+#include <stdio.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <errno.h>
+#include <X11/Xprotostr.h>
+
+#define NEED_EVENTS
+#include "Xproto.h"
+#undef NEED_EVENTS
+
+#include "Ps.h"
+
+#include "windowstr.h"
+#include "attributes.h"
+#include "Oid.h"
+
+/* static utility function to get document/page attributes */
+static void
+S_GetPageAttributes(XpContextPtr pCon,int *iorient,int *icount, int *iplex,
+                  int *ires, unsigned short *iwd, unsigned short *iht)
+{
+    char               *count;
+    XpOid              orient, plex;
+    /*
+     *  Get the orientation
+     */
+    orient = XpGetContentOrientation(pCon);
+    switch (orient) {
+    case xpoid_val_content_orientation_landscape:
+      *iorient = 1;
+      break;
+    case xpoid_val_content_orientation_reverse_portrait:
+      *iorient = 2;
+      break;
+    case xpoid_val_content_orientation_reverse_landscape:
+      *iorient = 3;
+      break;
+    case xpoid_val_content_orientation_portrait:
+    default:
+      *iorient = 0;
+      break;
+    }
+
+    /*
+     *  Get the count
+     */
+    count = XpGetOneAttribute(pCon, XPDocAttr, "copy-count");
+    if( count )
+    {
+      int ii = sscanf(count, "%d", icount);
+      if( ii!=1 ) *icount = 1;
+    }
+    else *icount = 1;
+
+    /*
+     * Get the plex
+     */
+    plex = XpGetPlex(pCon);
+    switch(plex)
+    {
+    case xpoid_val_plex_duplex:
+      *iplex = 1;
+      break;
+    case xpoid_val_plex_tumble:
+      *iplex = 2;
+      break;
+    default:
+      *iplex = 0;
+      break;
+    }
+
+  /*
+   *  Get the resolution and media size
+   */
+    *ires = XpGetResolution(pCon);
+    XpGetMediumDimensions(pCon, iwd, iht);
+}
+
+
+int
+PsStartJob(
+  XpContextPtr pCon,
+  Bool         sendClientData,
+  ClientPtr    client)
+{
+  PsContextPrivPtr  pConPriv = 
+      (PsContextPrivPtr)pCon->devPrivates[PsContextPrivateIndex].ptr;
+
+  /* 
+   * Create a temporary file to store the printer output.
+   */
+  if (!XpOpenTmpFile("w", &pConPriv->jobFileName, &pConPriv->pJobFile))
+      return BadAlloc;
+
+  return Success;
+}
+
+
+
+/* I thought about making this following code into a set of routines
+   or using a goto, or something, but in the end decided not to,
+   because the plain old listing here makes the logic clearer. */
+int
+PsEndJob(
+  XpContextPtr pCon,
+  Bool         cancel)
+{
+  int r;
+  struct stat buffer;
+  int error;
+
+  PsContextPrivPtr priv =
+    (PsContextPrivPtr)pCon->devPrivates[PsContextPrivateIndex].ptr;
+
+  if (cancel == True) {
+    if (priv->getDocClient != (ClientPtr) NULL) {
+      (void) XpFinishDocData( priv->getDocClient );
+
+      priv->getDocClient = NULL;
+      priv->getDocBufSize = 0;
+    }
+
+    /* job is cancelled - do we really care if we're out of space? */
+    (void) fclose(priv->pJobFile);
+    priv->pJobFile = NULL;
+
+    unlink(priv->jobFileName);
+    xfree(priv->jobFileName);
+    priv->jobFileName = (char *)NULL;
+
+    return Success;
+  }
+    
+  /*
+   * Append any trailing information here
+   */
+  PsOut_EndFile(priv->pPsOut, 0);
+  
+  /* this is where we find out if we're out of space */
+  error = (fclose(priv->pJobFile) == EOF);
+  priv->pJobFile = NULL;
+
+  /* status to the client if we have ran out of space on the disk or 
+     some other resource problem with the temporary file... */
+  if (error) {
+    if (priv->getDocClient != (ClientPtr) NULL) {
+      (void) XpFinishDocData( priv->getDocClient );
+
+      priv->getDocClient = NULL;
+      priv->getDocBufSize = 0;
+    }
+
+    unlink(priv->jobFileName);
+    xfree(priv->jobFileName);
+    priv->jobFileName = (char *)NULL;
+
+    return BadAlloc;
+  }
+    
+  /* we have finished without incident & no cancel */
+
+  if (priv->getDocClient != NULL && priv->getDocBufSize > 0) {
+    FILE *file;
+
+    file = fopen(priv->jobFileName, "r");
+    if (!file || (fstat(fileno(file), &buffer) < 0))
+	r = BadAlloc;
+    else
+	r = XpSendDocumentData(priv->getDocClient, file, buffer.st_size,
+			       priv->getDocBufSize);
+    if (file)
+	fclose(file);
+
+    (void) XpFinishDocData(priv->getDocClient);
+
+    priv->getDocClient = NULL;
+    priv->getDocBufSize = 0;
+  }
+  else {
+      XpSubmitJob(priv->jobFileName, pCon);
+
+      r = Success;
+  }
+
+  unlink(priv->jobFileName);
+  xfree(priv->jobFileName);
+  priv->jobFileName = (char *)NULL;
+
+#ifdef BM_CACHE
+  PsBmClearImageCache();
+#endif
+
+  return r;
+}
+
+/* StartPage 
+ */
+int
+PsStartPage(
+  XpContextPtr pCon,
+  WindowPtr    pWin)
+{
+  int                iorient, iplex, icount, ires;
+  unsigned short     iwd, iht;
+  register WindowPtr pChild;
+  PsContextPrivPtr   pConPriv =
+     (PsContextPrivPtr)pCon->devPrivates[PsContextPrivateIndex].ptr;
+  PsWindowPrivPtr    pWinPriv =
+     (PsWindowPrivPtr)pWin->devPrivates[PsWindowPrivateIndex].ptr;
+  char               s[80];
+  xEvent event;
+
+/*
+ * Put a pointer to the context in the window private structure
+ */
+  pWinPriv->validContext = 1;
+  pWinPriv->context      = pCon;
+
+  /* get page level attributes */
+  S_GetPageAttributes(pCon,&iorient,&icount,&iplex,&ires,&iwd,&iht);
+  /*
+   *  Start the page
+   */
+  if (pConPriv->pPsOut == NULL) {
+      pConPriv->pPsOut = PsOut_BeginFile(pConPriv->pJobFile,
+				   iorient, icount, iplex, ires,
+				   (int)iwd, (int)iht, False);
+  }
+  PsOut_BeginPage(pConPriv->pPsOut, iorient, icount, iplex, ires,
+		  (int)iwd, (int)iht);
+
+  return Success;
+}
+
+
+/*
+ * EndPage:
+ *
+ * Write page trailer to page file
+ * Write page file to job file
+ */
+int
+PsEndPage(
+  XpContextPtr pCon,
+  WindowPtr    pWin)
+{
+  PsWindowPrivPtr    pWinPriv =
+     (PsWindowPrivPtr)pWin->devPrivates[PsWindowPrivateIndex].ptr;
+  PsContextPrivPtr pConPriv =
+    (PsContextPrivPtr)pCon->devPrivates[PsContextPrivateIndex].ptr;
+
+  PsOut_EndPage(pConPriv->pPsOut);
+
+  pWinPriv->validContext = 0;
+  pWinPriv->context      = NULL;
+
+  /* status to the client if we have ran out of space on the disk or 
+     some other resource problem with the temporary file... */
+/*  if (ferror(pConPriv->pJobFile)) return BadAlloc; */
+
+  return Success;
+}
+
+/*
+ * The PsStartDoc() and PsEndDoc() functions serve basically as NOOP
+ * placeholders.  This driver doesn't deal with the notion of multiple
+ * documents per page.
+ */
+
+int
+PsStartDoc(XpContextPtr pCon, XPDocumentType type)
+{
+  int                iorient, iplex, icount, ires;
+  unsigned short     iwd, iht;
+  PsContextPrivPtr   pConPriv = 
+      (PsContextPrivPtr)pCon->devPrivates[PsContextPrivateIndex].ptr;
+
+  /* get document level attributes */
+  S_GetPageAttributes(pCon,&iorient,&icount,&iplex,&ires,&iwd,&iht);
+
+  pConPriv->pPsOut = PsOut_BeginFile(pConPriv->pJobFile,
+                                   iorient, icount, iplex, ires,
+                                   (int)iwd, (int)iht, (type == XPDocRaw));
+
+  return Success;
+}
+
+int
+PsEndDoc(
+  XpContextPtr pCon,
+  Bool         cancel)
+{
+  return Success;
+}
+
+/*
+ * PsDocumentData()
+ *
+ * Hand any pre-generated PDL down to the spool files, formatting it
+ * as necessary to fit the given window.
+ */
+
+int
+PsDocumentData(
+  XpContextPtr  pCon,
+  DrawablePtr   pDraw,
+  char         *pData,
+  int           len_data,
+  char         *pFmt,
+  int		len_fmt,
+  char         *pOpt,
+  int		len_opt,
+  ClientPtr	client)
+{
+    PsContextPrivPtr cPriv;
+    PsOutPtr psOut;
+
+    if (len_fmt != 12 || !strcmp(pFmt, "PostScript 2") || len_opt)
+	return BadValue;
+    cPriv = pCon->devPrivates[PsContextPrivateIndex].ptr;
+    psOut = cPriv->pPsOut;
+
+    if (pDraw)
+	PsOut_BeginFrame(psOut, 0, 0, pDraw->x, pDraw->y,
+			 pDraw->width, pDraw->height);
+    PsOut_RawData(psOut, pData, len_data);
+    if (pDraw)
+	PsOut_EndFrame(psOut);
+
+    return Success;
+}
+
+/*
+ *
+ * PsGetDocumentData()
+ *
+ * This function allows the driver to send the generated PS back to
+ * the client.
+ */
+
+int
+PsGetDocumentData(
+  XpContextPtr pCon,
+  ClientPtr    client,
+  int          maxBufferSize)
+{
+  PsContextPrivPtr pPriv = (PsContextPrivPtr)
+    pCon->devPrivates[PsContextPrivateIndex].ptr;
+
+  pPriv->getDocClient = client;
+  pPriv->getDocBufSize = maxBufferSize;
+
+  return Success;
+}
+
diff --git a/Xprint/ps/PsSpans.c b/Xprint/ps/PsSpans.c
new file mode 100644
index 000000000..4d8fb3459
--- /dev/null
+++ b/Xprint/ps/PsSpans.c
@@ -0,0 +1,162 @@
+/* $Xorg: PsSpans.c,v 1.4 2001/02/09 02:04:36 xorgcvs Exp $ */
+/*
+
+Copyright 1996, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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
+OPEN GROUP 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 name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+/*
+ * (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:		PsSpans.c
+**    *
+**    *  Contents:	Code to set and fill spans in the PS DDX
+**    *
+**    *  Created By:	Roger Helmendach (Liberty Systems)
+**    *
+**    *  Copyright:	Copyright 1996 The Open Group, Inc.
+**    *
+**    *********************************************************
+** 
+********************************************************************/
+
+#include "Ps.h"
+#include "gcstruct.h"
+#include "windowstr.h"
+
+void
+PsFillSpans(
+  DrawablePtr  pDrawable,
+  GCPtr        pGC,
+  int          nSpans,
+  DDXPointPtr  pPoints,
+  int         *pWidths,
+  int          fSorted)
+{
+  char        t[80];
+  PsOutPtr    psOut;
+  int         xoffset, yoffset;
+  xRectangle *rects, *r;
+  RegionPtr   fillRegion, region;
+  int         i;
+  int         nbox;
+  BoxPtr      pbox;
+  ColormapPtr cMap;
+
+  if( PsUpdateDrawableGC(pGC, pDrawable, &psOut, &cMap)==FALSE ) return;
+
+  /*
+   * Build a region out of the spans
+   */
+  rects   = (xRectangle *)xalloc(nSpans*sizeof(xRectangle));
+  xoffset = pDrawable->x;
+  yoffset = pDrawable->y;
+
+  for( i = 0, r = rects; i < nSpans; i++, r++ )
+  {
+    r->x = pPoints[i].x + xoffset;
+    r->y = pPoints[i].y + yoffset;
+    r->width = pWidths[i];
+    r->height = 1;
+  }
+  fillRegion = miRectsToRegion(nSpans, rects,
+                               (fSorted)?CT_YSORTED:CT_UNSORTED);
+
+  /*
+   * Intersect this region with the clip region.  Whatever's left,
+   * should be filled.
+   */
+/*miIntersect(region, fillRegion, pGC->clientClip);*/
+
+  pbox = REGION_RECTS(region);
+  nbox = REGION_NUM_RECTS(region);
+
+  /* Enter HP-GL/2 */
+  /*###SEND_PCL( outFile, "\27%0B" );*/
+
+  while( nbox )
+  {
+/*###
+    sprintf( t, "PU%d,%d;RR%d,%d;", pbox->x1, pbox->y1, pbox->x2, pbox->y2);
+    SEND_PCL( outFile, t );
+*/
+    nbox--;
+    pbox++;
+  }
+
+  /* Go back to PCL */
+  /*###SEND_PCL( outFile, "\27%0A" );*/
+
+  /*
+   * Clean up the temporary regions
+   */
+  miRegionDestroy(fillRegion);
+  miRegionDestroy(region);
+  xfree(rects);
+}
+
+void
+PsSetSpans(
+  DrawablePtr  pDrawable,
+  GCPtr        pGC,
+  char        *pSrc,
+  DDXPointPtr  pPoints,
+  int         *pWidths,
+  int          nSpans,
+  int          fSorted)
+{
+}
diff --git a/Xprint/ps/PsText.c b/Xprint/ps/PsText.c
new file mode 100644
index 000000000..618d0a163
--- /dev/null
+++ b/Xprint/ps/PsText.c
@@ -0,0 +1,478 @@
+/* $Xorg: PsText.c,v 1.7 2001/02/09 02:04:36 xorgcvs Exp $ */
+/*
+
+Copyright 1996, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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
+OPEN GROUP 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 name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+/*
+ * (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:		PsText.c
+**    *
+**    *  Contents:	Character-drawing routines for the PS DDX
+**    *
+**    *  Created By:	Roger Helmendach (Liberty Systems)
+**    *
+**    *  Copyright:	Copyright 1996 The Open Group, Inc.
+**    *
+**    *********************************************************
+** 
+********************************************************************/
+
+#include "Ps.h"
+#include "gcstruct.h"
+#include "windowstr.h"
+#include "fntfil.h"
+#include "fntfilst.h"
+#include <sys/stat.h>
+
+static int readFontName(char *fileName, char *file_name, char *dlfnam)
+{
+    FILE        *file;
+    struct stat statb;
+    int         count, i, status;
+    char        buf[256];
+    char 	*front, *end, *fn;
+
+    file = fopen(fileName, "r");
+    if(file)
+    {
+        if (fstat (fileno(file), &statb) == -1)
+            return 0;
+	while(fgets(buf, 255, file))
+	{
+	    if((fn = strstr(buf, " -")))
+	    {
+		strcpy(file_name, buf);
+		file_name[fn - buf - 4] = '\0';
+	        fn++;
+	        if((front = strstr(fn, "normal-")))
+	        {
+		    fn[front - fn] = '\0';
+	 	    if(strstr(dlfnam, fn))	
+		    {
+		        fclose(file);
+		        return 1; 
+		    }
+	        }
+	    }
+	}
+    }
+    file_name[0] = '\0';
+    fclose(file);
+    return 0;
+}
+
+int
+PsPolyText8(
+  DrawablePtr pDrawable,
+  GCPtr       pGC,
+  int         x,
+  int         y,
+  int         count,
+  char       *string)
+{
+  if( pDrawable->type==DRAWABLE_PIXMAP )
+  {
+    DisplayElmPtr   elm;
+    PixmapPtr       pix  = (PixmapPtr)pDrawable;
+    PsPixmapPrivPtr priv = (PsPixmapPrivPtr)pix->devPrivate.ptr;
+    DisplayListPtr  disp;
+    GCPtr           gc;
+
+    if ((gc = PsCreateAndCopyGC(pDrawable, pGC)) == NULL) return x;
+
+    disp = PsGetFreeDisplayBlock(priv);
+
+    elm  = &disp->elms[disp->nelms];
+    elm->type = Text8Cmd;
+    elm->gc   = gc;
+    elm->c.text8.x      = x;
+    elm->c.text8.y      = y;
+    elm->c.text8.count  = count;
+    elm->c.text8.string = (char *)xalloc(count);
+    memcpy(elm->c.text8.string, string, count);
+    disp->nelms += 1;
+  }
+  else
+  {
+    char  *fnam, ffname[512], *dlfnam;
+    FontDirectoryPtr    dir;
+    char        file_name[MAXFONTNAMELEN];
+
+    dir = pGC->font->fpe->private;
+    sprintf(ffname, "%s%s", dir->directory, "fonts.dir"); 
+
+    fnam = PsGetPSFontName(pGC->font); 
+    if(!fnam){
+	if(!(dlfnam = PsGetFontName(pGC->font))) 
+	    return x;
+	/* If Type1 font, try to download to printer first */
+	if(strstr(ffname, "Type1") && readFontName(ffname, file_name, dlfnam)) 
+	{
+            int          iso;
+            int          siz;
+            float        mtx[4];
+            PsOutPtr     psOut;
+            ColormapPtr  cMap;
+
+	    if( PsUpdateDrawableGC(pGC, pDrawable, &psOut, &cMap)==FALSE ) 
+		return x; 
+	    sprintf(ffname, "%s%s%s", dir->directory, file_name, ".pfa");
+	    PsOut_DownloadType1(psOut, file_name, ffname);
+            PsOut_Offset(psOut, pDrawable->x, pDrawable->y);
+       	    PsOut_Color(psOut, PsGetPixelColor(cMap, pGC->fgPixel)); 
+       	    siz = PsGetFontSize(pGC->font, mtx);
+       	    iso = PsIsISOLatin1Encoding(pGC->font);
+       	    if( !siz ) PsOut_TextAttrsMtx(psOut, file_name, mtx, 1); 
+            else PsOut_TextAttrs(psOut, file_name, siz, 1); 
+       	    PsOut_Text(psOut, x, y, string, count, -1);
+	    return x;
+	}
+	{
+	    unsigned long n, i;
+	    int w;
+	    CharInfoPtr charinfo[255];  
+
+	    GetGlyphs(pGC->font, (unsigned long)count, 
+		(unsigned char *)string, Linear8Bit,&n, charinfo);
+	    w = 0;
+	    for (i=0; i < n; i++) w += charinfo[i]->metrics.characterWidth;
+	    if (n != 0)
+	        PsPolyGlyphBlt(pDrawable, pGC, x, y, n, 
+			charinfo, FONTGLYPHS(pGC->font));
+	    x += w;
+	}  
+    }else{
+	int          iso;
+	int          siz;
+	float        mtx[4];
+	PsOutPtr     psOut;
+	ColormapPtr  cMap;
+
+	if( PsUpdateDrawableGC(pGC, pDrawable, &psOut, &cMap)==FALSE ) return x;
+	PsOut_Offset(psOut, pDrawable->x, pDrawable->y);
+	PsOut_Color(psOut, PsGetPixelColor(cMap, pGC->fgPixel));
+	siz = PsGetFontSize(pGC->font, mtx);
+	iso = PsIsISOLatin1Encoding(pGC->font);
+	if( !siz ) PsOut_TextAttrsMtx(psOut, fnam, mtx, iso);
+	else       PsOut_TextAttrs(psOut, fnam, siz, iso);
+	PsOut_Text(psOut, x, y, string, count, -1);
+    }
+  }
+  return x;
+}
+
+int
+PsPolyText16(
+  DrawablePtr     pDrawable,
+  GCPtr           pGC,
+  int             x,
+  int             y,
+  int             count,
+  unsigned short *string)
+{
+  if( pDrawable->type==DRAWABLE_PIXMAP )
+  {
+    DisplayElmPtr   elm;
+    PixmapPtr       pix  = (PixmapPtr)pDrawable;
+    PsPixmapPrivPtr priv = (PsPixmapPrivPtr)pix->devPrivate.ptr;
+    DisplayListPtr  disp;
+    GCPtr           gc;
+
+    if ((gc = PsCreateAndCopyGC(pDrawable, pGC)) == NULL) return x;
+
+    disp = PsGetFreeDisplayBlock(priv);
+
+    elm  = &disp->elms[disp->nelms];
+    elm->type = Text16Cmd;
+    elm->gc   = gc;
+    elm->c.text16.x      = x;
+    elm->c.text16.y      = y;
+    elm->c.text16.count  = count;
+    elm->c.text16.string =
+      (unsigned short *)xalloc(count*sizeof(unsigned short));
+    memcpy(elm->c.text16.string, string, count*sizeof(unsigned short));
+    disp->nelms += 1;
+  }
+  else
+  {
+    unsigned long n, i;
+    int w;
+    CharInfoPtr charinfo[255];  /* encoding only has 1 byte for count */
+
+    GetGlyphs(pGC->font, (unsigned long)count, (unsigned char *)string,
+              (FONTLASTROW(pGC->font) == 0) ? Linear16Bit : TwoD16Bit,
+              &n, charinfo);
+    w = 0;
+    for (i=0; i < n; i++) w += charinfo[i]->metrics.characterWidth;
+    if (n != 0)
+	PsPolyGlyphBlt(pDrawable, pGC, x, y, n, charinfo, FONTGLYPHS(pGC->font));
+    x += w;
+  }
+  return x;
+}
+
+void
+PsImageText8(
+  DrawablePtr pDrawable,
+  GCPtr       pGC,
+  int         x,
+  int         y,
+  int         count,
+  char       *string)
+{
+  if( pDrawable->type==DRAWABLE_PIXMAP )
+  {
+    DisplayElmPtr   elm;
+    PixmapPtr       pix  = (PixmapPtr)pDrawable;
+    PsPixmapPrivPtr priv = (PsPixmapPrivPtr)pix->devPrivate.ptr;
+    DisplayListPtr  disp;
+    GCPtr           gc;
+
+    if ((gc = PsCreateAndCopyGC(pDrawable, pGC)) == NULL) return;
+
+    disp = PsGetFreeDisplayBlock(priv);
+
+    elm  = &disp->elms[disp->nelms];
+    elm->type = TextI8Cmd;
+    elm->gc   = gc;
+    elm->c.text8.x      = x;
+    elm->c.text8.y      = y;
+    elm->c.text8.count  = count;
+    elm->c.text8.string = (char *)xalloc(count);
+    memcpy(elm->c.text8.string, string, count);
+    disp->nelms += 1;
+  }
+  else
+  {
+    int          iso;
+    int          siz;
+    float        mtx[4];
+    char        *fnam;
+    PsOutPtr     psOut;
+    ColormapPtr  cMap;
+
+    if( PsUpdateDrawableGC(pGC, pDrawable, &psOut, &cMap)==FALSE ) return;
+    PsOut_Offset(psOut, pDrawable->x, pDrawable->y);
+    PsOut_Color(psOut, PsGetPixelColor(cMap, pGC->fgPixel));
+    fnam = PsGetPSFontName(pGC->font);
+    if( !fnam ) fnam = "Times-Roman";
+    siz = PsGetFontSize(pGC->font, mtx);
+    iso = PsIsISOLatin1Encoding(pGC->font);
+    if( !siz ) PsOut_TextAttrsMtx(psOut, fnam, mtx, iso);
+    else       PsOut_TextAttrs(psOut, fnam, siz, iso);
+    PsOut_Text(psOut, x, y, string, count, PsGetPixelColor(cMap, pGC->bgPixel));
+  }
+}
+
+void
+PsImageText16(
+  DrawablePtr     pDrawable,
+  GCPtr           pGC,
+  int             x,
+  int             y,
+  int             count,
+  unsigned short *string)
+{
+  if( pDrawable->type==DRAWABLE_PIXMAP )
+  {
+    DisplayElmPtr   elm;
+    PixmapPtr       pix  = (PixmapPtr)pDrawable;
+    PsPixmapPrivPtr priv = (PsPixmapPrivPtr)pix->devPrivate.ptr;
+    DisplayListPtr  disp;
+    GCPtr           gc;
+
+    if ((gc = PsCreateAndCopyGC(pDrawable, pGC)) == NULL) return;
+
+    disp = PsGetFreeDisplayBlock(priv);
+
+    elm  = &disp->elms[disp->nelms];
+    elm->type = TextI16Cmd;
+    elm->gc   = gc;
+    elm->c.text16.x      = x;
+    elm->c.text16.y      = y;
+    elm->c.text16.count  = count;
+    elm->c.text16.string =
+      (unsigned short *)xalloc(count*sizeof(unsigned short));
+    memcpy(elm->c.text16.string, string, count*sizeof(unsigned short));
+    disp->nelms += 1;
+  }
+  else
+  {
+    int   i;
+    char *str;
+    if( !count ) return;
+    str = (char *)xalloc(count);
+    for( i=0 ; i<count ; i++ ) str[i] = string[i];
+    PsImageText8(pDrawable, pGC, x, y, count, str);
+    free(str);
+  }
+}
+
+void
+PsImageGlyphBlt(
+  DrawablePtr   pDrawable,
+  GCPtr         pGC,
+  int           x,
+  int           y,
+  unsigned int  nGlyphs,
+  CharInfoPtr  *pCharInfo,
+  pointer       pGlyphBase)
+{
+  /* NOT TO BE IMPLEMENTED */
+}
+
+void
+PsPolyGlyphBlt(
+  DrawablePtr   pDrawable,
+  GCPtr         pGC,
+  int           x,
+  int           y,
+  unsigned int  nGlyphs,
+  CharInfoPtr  *pCharInfo,
+  pointer       pGlyphBase)
+{
+    int width, height;
+    PixmapPtr pPixmap;
+    int nbyLine;                        /* bytes per line of padded pixmap */
+    FontPtr pfont;
+    GCPtr pGCtmp;
+    register int i;
+    register int j;
+    unsigned char *pbits;               /* buffer for PutImage */
+    register unsigned char *pb;         /* temp pointer into buffer */
+    register CharInfoPtr pci;           /* currect char info */
+    register unsigned char *pglyph;     /* pointer bits in glyph */
+    int gWidth, gHeight;                /* width and height of glyph */
+    register int nbyGlyphWidth;         /* bytes per scanline of glyph */
+    int nbyPadGlyph;                    /* server padded line of glyph */
+    int w, tmpx;
+    XID gcvals[3];
+
+    pfont = pGC->font;
+    width = FONTMAXBOUNDS(pfont,rightSideBearing) -
+            FONTMINBOUNDS(pfont,leftSideBearing);
+    height = FONTMAXBOUNDS(pfont,ascent) +
+             FONTMAXBOUNDS(pfont,descent);
+
+    if ((width == 0) || (height == 0) )
+        return;
+    {
+        int i;
+        w = 0;
+        for (i=0; i < nGlyphs; i++) w += pCharInfo[i]->metrics.characterWidth;
+    }
+    pGCtmp = GetScratchGC(1, pDrawable->pScreen);
+    if (!pGCtmp)
+    {
+        (*pDrawable->pScreen->DestroyPixmap)(pPixmap);
+        return;
+    }
+
+    gcvals[0] = GXcopy;
+    gcvals[1] = pGC->fgPixel;
+    gcvals[2] = pGC->bgPixel; 
+
+    DoChangeGC(pGCtmp, GCFunction|GCForeground|GCBackground, gcvals, 0);
+
+    
+    nbyLine = BitmapBytePad(width);
+    pbits = (unsigned char *)ALLOCATE_LOCAL(height*nbyLine);
+    if (!pbits){
+        PsDestroyPixmap(pPixmap);
+        return;
+    }
+    tmpx = 0;
+    while(nGlyphs--)
+    {
+        pci = *pCharInfo++;
+        pglyph = FONTGLYPHBITS(pGlyphBase, pci);
+        gWidth = GLYPHWIDTHPIXELS(pci);
+        gHeight = GLYPHHEIGHTPIXELS(pci);
+        if (gWidth && gHeight)
+        {
+            nbyGlyphWidth = GLYPHWIDTHBYTESPADDED(pci);
+            nbyPadGlyph = BitmapBytePad(gWidth);
+
+            if (nbyGlyphWidth == nbyPadGlyph
+#if GLYPHPADBYTES != 4
+                && (((int) pglyph) & 3) == 0
+#endif
+                )
+            {
+                pb = pglyph;
+            }
+            else
+            {
+                for (i=0, pb = pbits; i<gHeight; i++, pb = pbits+(i*nbyPadGlyph))
+                    for (j = 0; j < nbyGlyphWidth; j++)
+                        *pb++ = *pglyph++;
+                pb = pbits;
+            }
+
+	    PsPutImageMask((DrawablePtr)pDrawable, pGCtmp, 
+		   1, x + pci->metrics.leftSideBearing, 
+		   y - pci->metrics.ascent, gWidth, gHeight,
+                   0, XYBitmap, (char *)pb);
+	    x  += pci->metrics.characterWidth;
+	}
+    }
+    DEALLOCATE_LOCAL(pbits);
+    FreeScratchGC(pGCtmp);
+}
diff --git a/Xprint/ps/PsWindow.c b/Xprint/ps/PsWindow.c
new file mode 100644
index 000000000..3a9a7ed2a
--- /dev/null
+++ b/Xprint/ps/PsWindow.c
@@ -0,0 +1,458 @@
+/* $Xorg: PsWindow.c,v 1.4 2001/02/09 02:04:36 xorgcvs Exp $ */
+/*
+
+Copyright 1996, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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
+OPEN GROUP 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 name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+/*
+ * (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:		PsWindow.c
+**    *
+**    *  Contents:	Window code for PS driver.
+**    *
+**    *  Created By:	Roger Helmendach (Liberty Systems)
+**    *
+**    *  Copyright:	Copyright 1996 The Open Group, Inc.
+**    *
+**    *********************************************************
+** 
+********************************************************************/
+
+#include <stdio.h>
+#include <string.h>
+#include <sys/wait.h>
+
+#include "mistruct.h"
+#include "regionstr.h"
+#include "windowstr.h"
+#include "gcstruct.h"
+
+#include "Ps.h"
+
+extern WindowPtr *WindowTable;
+
+/*
+ * The following list of strings defines the properties which will be
+ * placed on the screen's root window if the property was defined in
+ * the start-up configuration resource database.
+ */
+static char *propStrings[] = {
+	DT_PRINT_JOB_HEADER,
+	DT_PRINT_JOB_TRAILER,
+	DT_PRINT_JOB_COMMAND,
+	DT_PRINT_JOB_EXEC_COMMAND,
+	DT_PRINT_JOB_EXEC_OPTIONS,
+	DT_PRINT_PAGE_HEADER,
+	DT_PRINT_PAGE_TRAILER,
+	DT_PRINT_PAGE_COMMAND,
+	(char *)NULL
+};
+
+
+/*
+ * PsCreateWindow - watch for the creation of the root window.
+ * When it's created, register the screen with the print extension,
+ * and put the default command/header properties on it.
+ */
+/*ARGSUSED*/
+
+Bool
+PsCreateWindow(WindowPtr pWin)
+{
+  PsWindowPrivPtr pPriv;
+
+#if 0
+    Bool status = Success;
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    PsScreenPrivPtr pScreenPriv = (PsScreenPrivPtr) 
+		     pScreen->devPrivates[PsScreenPrivateIndex].ptr;
+    PsWindowPrivPtr pWinPriv = (PsWindowPrivPtr)
+			 pWin->devPrivates[PsWindowPrivateIndex].ptr;
+
+    /*
+     * Initialize this window's private struct.
+     */
+    pWinPriv->jobFileName = (char *)NULL;
+    pWinPriv->pJobFile = (FILE *)NULL;
+    pWinPriv->pageFileName = (char *)NULL;
+    pWinPriv->pPageFile = (FILE *)NULL;
+    
+    if(pWin->parent == (WindowPtr)NULL)  /* root window? */
+    {
+	Atom propName; /* type = XA_STRING */
+	char *propVal;
+	int i;
+        XrmDatabase rmdb = pScreenPriv->resDB;
+
+        /*
+         * Put the defaults spec'd in the config files in properties on this
+	 * screen's root window.
+         */
+	for(i = 0; propStrings[i] != (char *)NULL; i++)
+	{
+            if((propVal = _DtPrintGetPrinterResource(pWin, rmdb, 
+						     propStrings[i])) !=
+	       (char *)NULL)
+	    {
+                propName = MakeAtom(propStrings[i], strlen(propStrings[i]),
+				    TRUE);
+	        ChangeWindowProperty(pWin, propName, XA_STRING, 8, 
+			             PropModeReplace,  strlen(propVal), 
+			             (pointer)propVal, FALSE);
+	        xfree(propVal);
+	    }
+	}
+    }
+
+    return status;
+#endif
+
+  pPriv = (PsWindowPrivPtr)pWin->devPrivates[PsWindowPrivateIndex].ptr;
+  pPriv->validContext = 0;
+
+  return TRUE;
+}
+
+
+/*ARGSUSED*/
+Bool PsMapWindow(WindowPtr pWindow)
+{
+  return TRUE;
+}
+
+/*ARGSUSED*/
+Bool 
+PsPositionWindow(
+  WindowPtr pWin,
+  int x,
+  int y)
+{
+  return TRUE;
+}
+
+/*ARGSUSED*/
+Bool 
+PsUnmapWindow(WindowPtr pWindow)
+{
+  return TRUE;
+}
+
+/*ARGSUSED*/
+void 
+PsCopyWindow(
+  WindowPtr   pWin,
+  DDXPointRec ptOldOrg,
+  RegionPtr   prgnSrc)
+{
+}
+
+/*ARGSUSED*/
+Bool
+PsChangeWindowAttributes(
+  WindowPtr     pWin,
+  unsigned long mask)
+{
+  return TRUE;
+}
+
+
+void
+PsPaintWindow(
+  WindowPtr pWin,
+  RegionPtr pRegion,
+  int       what)
+{
+  int       status;
+  WindowPtr pRoot;
+
+#define FUNCTION        0
+#define FOREGROUND      1
+#define TILE            2
+#define FILLSTYLE       3
+#define ABSX            4
+#define ABSY            5
+#define CLIPMASK        6
+#define SUBWINDOW       7
+#define COUNT_BITS      8
+
+  pointer              gcval[7];
+  pointer              newValues [COUNT_BITS];
+
+  BITS32               gcmask, index, mask;
+  RegionRec            prgnWin;
+  DDXPointRec          oldCorner;
+  BoxRec               box;
+  WindowPtr            pBgWin;
+  GCPtr                pGC;
+  register int         i;
+  register BoxPtr      pbox;
+  register ScreenPtr   pScreen = pWin->drawable.pScreen;
+  register xRectangle *prect;
+  int                  numRects;
+
+  gcmask = 0;
+
+  /*
+   * We don't want to paint a window that has no place to put the
+   * PS output.
+   */
+  if( PsGetContextFromWindow(pWin)==(XpContextPtr)NULL ) return;
+
+  if( what==PW_BACKGROUND )
+  {
+    switch(pWin->backgroundState)
+    {
+      case None: return;
+      case ParentRelative:
+        (*pWin->parent->drawable.pScreen->PaintWindowBackground)
+          (pWin->parent, pRegion, what);
+        return;
+      case BackgroundPixel:
+        newValues[FOREGROUND] = (pointer)pWin->background.pixel;
+        newValues[FILLSTYLE] = (pointer)FillSolid;
+        gcmask |= GCForeground | GCFillStyle;
+        break;
+      case BackgroundPixmap:
+        newValues[TILE] = (pointer)pWin->background.pixmap;
+        newValues[FILLSTYLE] = (pointer)FillTiled;
+        gcmask |= GCTile | GCFillStyle | GCTileStipXOrigin | GCTileStipYOrigin;
+        break;
+    }
+  }
+  else
+  {
+    if( pWin->borderIsPixel )
+    {
+      newValues[FOREGROUND] = (pointer)pWin->border.pixel;
+      newValues[FILLSTYLE] = (pointer)FillSolid;
+      gcmask |= GCForeground | GCFillStyle;
+    }
+    else
+    {
+      newValues[TILE] = (pointer)pWin->border.pixmap;
+      newValues[FILLSTYLE] = (pointer)FillTiled;
+      gcmask |= GCTile | GCFillStyle | GCTileStipXOrigin | GCTileStipYOrigin;
+    }
+  }
+
+  prect = (xRectangle *)ALLOCATE_LOCAL(REGION_NUM_RECTS(pRegion) *
+                                         sizeof(xRectangle));
+  if( !prect ) return;
+
+  newValues[FUNCTION] = (pointer)GXcopy;
+  gcmask |= GCFunction | GCClipMask;
+
+  i = pScreen->myNum;
+  pRoot = WindowTable[i];
+
+  pBgWin = pWin;
+  if (what == PW_BORDER)
+  {
+    while( pBgWin->backgroundState==ParentRelative ) pBgWin = pBgWin->parent;
+  }
+
+  pGC = GetScratchGC(pWin->drawable.depth, pWin->drawable.pScreen);
+  if( !pGC )
+  {
+    DEALLOCATE_LOCAL(prect);
+    return;
+  }
+  /*
+   * mash the clip list so we can paint the border by
+   * mangling the window in place, pretending it
+   * spans the entire screen
+   */
+  if( what==PW_BORDER )
+  {
+    prgnWin = pWin->clipList;
+    oldCorner.x = pWin->drawable.x;
+    oldCorner.y = pWin->drawable.y;
+    pWin->drawable.x = pWin->drawable.y = 0;
+    box.x1 = 0;
+    box.y1 = 0;
+    box.x2 = pScreen->width;
+    box.y2 = pScreen->height;
+    REGION_INIT(pScreen, &pWin->clipList, &box, 1);
+    pWin->drawable.serialNumber = NEXT_SERIAL_NUMBER;
+    newValues[ABSX] = (pointer)(long)pBgWin->drawable.x;
+    newValues[ABSY] = (pointer)(long)pBgWin->drawable.y;
+  }
+  else
+  {
+    newValues[ABSX] = (pointer)0;
+    newValues[ABSY] = (pointer)0;
+  }
+
+/*
+ * XXX Backing store is turned off for the PS driver
+
+  if( pWin->backStorage )
+    (*pWin->drawable.pScreen->DrawGuarantee) (pWin, pGC, GuaranteeVisBack);
+ */
+
+  mask = gcmask;
+  gcmask = 0;
+  i = 0;
+  while( mask )
+  {
+    index = lowbit (mask);
+    mask &= ~index;
+    switch(index)
+    {
+      case GCFunction:
+        if( (pointer)(long)pGC->alu!=newValues[FUNCTION] )
+        {
+          gcmask |= index;
+          gcval[i++] = newValues[FUNCTION];
+        }
+        break;
+      case GCTileStipXOrigin:
+        if( (pointer)(long)pGC->patOrg.x!=newValues[ABSX] )
+        {
+          gcmask |= index;
+          gcval[i++] = newValues[ABSX];
+        }
+        break;
+      case GCTileStipYOrigin:
+        if( (pointer)(long)pGC->patOrg.y!=newValues[ABSY] )
+        {
+          gcmask |= index;
+          gcval[i++] = newValues[ABSY];
+        }
+        break;
+      case GCClipMask:
+        if( (pointer)pGC->clientClipType!=(pointer)CT_NONE )
+        {
+          gcmask |= index;
+          gcval[i++] = (pointer)CT_NONE;
+        }
+        break;
+      case GCSubwindowMode:
+        if( (pointer)pGC->subWindowMode!=newValues[SUBWINDOW] )
+        {
+          gcmask |= index;
+          gcval[i++] = newValues[SUBWINDOW];
+        }
+        break;
+      case GCTile:
+        if( pGC->tileIsPixel || (pointer)pGC->tile.pixmap!=newValues[TILE] )
+        {
+          gcmask |= index;
+          gcval[i++] = newValues[TILE];
+        }
+        break;
+      case GCFillStyle:
+        if( (pointer)pGC->fillStyle!=newValues[FILLSTYLE] )
+        {
+          gcmask |= index;
+          gcval[i++] = newValues[FILLSTYLE];
+        }
+        break;
+      case GCForeground:
+        if( (pointer)pGC->fgPixel!=newValues[FOREGROUND] )
+        {
+          gcmask |= index;
+          gcval[i++] = newValues[FOREGROUND];
+        }
+        break;
+    }
+  }
+
+  if( gcmask ) DoChangeGC(pGC, gcmask, (XID *)gcval, 1);
+
+  if( pWin->drawable.serialNumber!=pGC->serialNumber )
+    ValidateGC((DrawablePtr)pWin, pGC);
+
+  numRects = REGION_NUM_RECTS(pRegion);
+  pbox = REGION_RECTS(pRegion);
+  for( i=numRects ; --i >= 0 ; pbox++,prect++ )
+  {
+    prect->x = pbox->x1 - pWin->drawable.x;
+    prect->y = pbox->y1 - pWin->drawable.y;
+    prect->width = pbox->x2 - pbox->x1;
+    prect->height = pbox->y2 - pbox->y1;
+  }
+  prect -= numRects;
+  (*pGC->ops->PolyFillRect)((DrawablePtr)pWin, pGC, numRects, prect);
+  DEALLOCATE_LOCAL(prect);
+
+/*
+ * XXX Backing store is turned off for the PS driver
+
+  if( pWin->backStorage )
+    (*pWin->drawable.pScreen->DrawGuarantee) (pWin, pGC, GuaranteeNothing);
+ */
+
+  if( what==PW_BORDER )
+  {
+    REGION_UNINIT(pScreen, &pWin->clipList);
+    pWin->clipList = prgnWin;
+    pWin->drawable.x = oldCorner.x;
+    pWin->drawable.y = oldCorner.y;
+    pWin->drawable.serialNumber = NEXT_SERIAL_NUMBER;
+  }
+  FreeScratchGC(pGC);
+}
+
+/*ARGSUSED*/
+Bool
+PsDestroyWindow(WindowPtr pWin)
+{
+  return TRUE;
+}
diff --git a/Xprint/ps/psout.c b/Xprint/ps/psout.c
new file mode 100644
index 000000000..d4a64eacb
--- /dev/null
+++ b/Xprint/ps/psout.c
@@ -0,0 +1,1623 @@
+/* $Xorg: psout.c,v 1.9 2001/03/26 15:25:12 coskrey Exp $ */
+/*
+
+Copyright 1996, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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
+OPEN GROUP 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 name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+/*
+ * (c) Copyright 1996 Hewlett-Packard Company
+ * (c) Copyright 1996 International Business Machines Corp.
+ * (c) Copyright 1996, 2000 Sun Microsystems, Inc.  All Rights Reserved.
+ * (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:          psout.c
+**    *
+**    *  Contents:      Code to output PostScript to file
+**    *
+**    *  Created By:    Roger Helmendach (Liberty Systems)
+**    *
+**    *  Copyright:     Copyright 1996 The Open Group, Inc.
+**    *
+**    *********************************************************
+**
+********************************************************************/
+
+#include <stdlib.h>
+#include "os.h"
+#include "psout.h"
+
+PsElmPtr PsCloneFillElementList(int nElms, PsElmPtr elms);
+
+typedef void *voidPtr;
+
+typedef struct PsPatRec_
+{
+  PsFillEnum type;
+  voidPtr    tag;
+} PsPatRec;
+
+typedef PsPatRec *PsPatPtr;
+
+typedef struct PsOutRec_
+{
+  FILE       *Fp;
+  char        Buf[256];
+  int         CurColor;
+  int         LineWidth;
+  PsCapEnum   LineCap;
+  PsJoinEnum  LineJoin;
+  int         NDashes;
+  int        *Dashes;
+  int         DashOffset;
+  int         LineBClr;
+  PsRuleEnum  FillRule;
+  char       *FontName;
+  int         FontSize;
+  float       FontMtx[4];
+  int         ImageFormat;
+  int         RevImage;
+  int         NPatterns;
+  int         MxPatterns;
+  PsPatPtr    Patterns;
+  int         ClipType;
+  PsClipRec   Clip;
+  int         InFrame;
+  int         XOff;
+  int         YOff;
+
+  PsFillEnum  InTile;
+  int         ImgSkip;
+  int         ImgBClr;
+  int         ImgFClr;
+  int         ImgX;
+  int         ImgY;
+  int         ImgW;
+  int         ImgH;
+  int         SclW;
+  int         SclH;
+
+  int         NDownloads;
+  int         MxDownloads;
+  char      **Downloads;
+  Bool        isRaw;
+
+  int         start_image;
+} PsOutRec;
+
+/*
+ *  Standard definitions
+ */
+
+static char *S_StandardDefs = "\
+/d{def}bind def\
+/b{bind}bind d\
+/bd{b d}b d\
+/x{exch}bd\
+/xd{x d}bd\
+/dp{dup}bd\
+/t{true}bd\
+/f{false}bd\
+/p{pop}bd\
+/r{roll}bd\
+/c{copy}bd\
+/i{index}bd\
+/rp{repeat}bd\
+/n{newpath}bd\
+/w{setlinewidth}bd\
+/lc{setlinecap}bd\
+/lj{setlinejoin}bd\
+/sml{setmiterlimit}bd\
+/ds{setdash}bd\
+/ie{ifelse}bd\
+/len{length}bd\
+/m{moveto}bd\
+/l{lineto}bd\
+/rl{rlineto}bd\
+/a{arc}bd\
+/an{arcn}bd\
+/st{stroke}bd\
+/fl{fill}bd\
+/ef{eofill}bd\
+/sp{showpage}bd\
+/cp{closepath}bd\
+/clp{clippath}bd\
+/cl{clip}bd\
+/pb{pathbbox}bd\
+/tr{translate}bd\
+/rt{rotate}bd\
+/dv{div}bd\
+/ml{mul}bd\
+/ad{add}bd\
+/ng{neg}bd\
+/scl{scale}bd\
+/sc{setrgbcolor}bd\
+/g{setgray}bd\
+/gs{gsave}bd\
+/gr{grestore}bd\
+/sv{save}bd\
+/rs{restore}bd\
+/mx{matrix}bd\
+/cm{currentmatrix}bd\
+/sm{setmatrix}bd\
+/ccm{concatmatrix}bd\
+/cc{concat}bd\
+/ff{findfont}bd\
+/mf{makefont}bd\
+/sf{setfont}bd\
+/cft{currentfont}bd\
+/fd{FontDirectory}bd\
+/sh{show}bd\
+/stw{stringwidth}bd\
+/ci{colorimage}bd\
+/ig{image}bd\
+/im{imagemask}bd\
+/cf{currentfile}bd\
+/rh{readhexstring}bd\
+/str{string}bd\
+/al{aload}bd\
+/wh{where}bd\
+/kn{known}bd\
+/stp{stopped}bd\
+/bg{begin}bd\
+/ed{end}bd\
+/fa{forall}bd\
+/pi{putinterval}bd\
+/mk{mark}bd\
+/ctm{cleartomark}bd\
+/df{definefont}bd\
+/cd{currentdict}bd\
+/db{20 dict dp bg}bd\
+/de{ed}bd\
+/languagelevel wh{p languagelevel}{1}ie\
+ 1 eq{/makepattern{p}bd/setpattern{p}bd/setpagedevice{p}bd}if\
+/mp{makepattern}bd\
+/spt{setpattern}bd\
+/spd{setpagedevice}bd\
+";
+
+/*
+ *  Composite definitions
+ *
+ *
+ *    XYr  -  Return X/Y dpi for device
+ *
+ *      XYr <xdpi> <ydpi>
+ *
+ *    Cs  -  Coordinate setup (for origin upper left)
+ *
+ *      <orient(0,1,2,3)> Cs
+ *
+ *    P  -  Draw a point
+ *
+ *      <x> <y> P
+ *
+ *    R  -  Add rectangle to path
+ *
+ *      <x> <y> <w> <h> R
+ *
+ *    Ac  -  Add arc to path
+ *
+ *      <x> <y> <w> <h> <ang1> <ang2> Ac
+ *
+ *    An  -  Add arc to path (counterclockwise)
+ *
+ *      <x> <y> <w> <h> <ang1> <ang2> An
+ *
+ *    Tf  -  Set font
+ *
+ *      <font_name> <size> <iso> Tf
+ *
+ *    Tfm  -  Set font with matrix
+ *
+ *      <font_name> <matrix> <iso> Tfm
+ *
+ *    T  -  Draw text
+ *
+ *      <text> <x> <y> T
+ *
+ *    Tb  -  Draw text with background color
+ *
+ *      <text> <x> <y> <bg_red> <bg_green> <bg_blue> Tb
+ *
+ *    Im1  -  Image 1 bit monochrome imagemask
+ *
+ *      <x> <y> <w> <h> <sw> <sh> Im1
+ *
+ *    Im24  -  Image 24 bit RGB color
+ *
+ *      <x> <y> <w> <h> <sw> <sh> Im24
+ *
+ *    Im1t  -  Image 1 bit monochrome imagemask (in tile)
+ *
+ *      <data> <x> <y> <w> <h> <sw> <sh> Im1t
+ *
+ *    Im24t  -  Image 24 bit RGB color (in tile)
+ *
+ *      <data> <x> <y> <w> <h> <sw> <sh> Im24t
+ */
+
+static char *S_CompositeDefs = "\
+/XYr{/currentpagedevice wh\
+  {p currentpagedevice dp /HWResolution kn\
+    {/HWResolution get al p}{p 300 300}ie}{300 300}ie}bd\
+/Cs{dp 0 eq{0 pHt tr XYr -1 x dv 72 ml x 1 x dv 72 ml x scl}if\
+  dp 1 eq{90 rt XYr -1 x dv 72 ml x 1 x dv 72 ml x scl}if\
+  dp 2 eq{pWd 0 tr XYr 1 x dv 72 ml x -1 x dv 72 ml x scl}if\
+  3 eq{pHt pWd tr 90 rt XYr 1 x dv 72 ml x -1 x dv 72 ml x scl}if}bd\
+/P{gs 1 w [] 0 ds 2 c m .1 ad x .1 ad x l st gr}bd\
+/R{4 2 r m 1 i 0 rl 0 x rl ng 0 rl cp}bd\
+/Ac{mx_ cm p 6 -2 r tr 4 2 r ng scl 0 0 .5 5 3 r a mx_ sm}bd\
+/An{mx_ cm p 6 -2 r tr 4 2 r ng scl 0 0 .5 5 3 r an mx_ sm}bd\
+/ISO{dp len dict bg{1 i/FID ne{d}{p p}ie}fa\
+  /Encoding ISOLatin1Encoding d cd ed df}bd\
+/iN{dp len str cvs dp len x 1 i 3 ad str 2 c c p x p dp 3 -1 r(ISO)pi}bd\
+/Tp{{x dp iN dp fd x kn{x p dp/f_ x d ff}{dp/f_ x d x ff ISO}ie x}\
+  {x dp/f_ x d ff x}ie}bd\
+/Tf{Tp[x 0 0 2 i ng 0 0] dp/fm_ x d mf sf}bd\
+/Tfm{Tp 1 -1 tm1_ scl tm2_ ccm dp/fm_ x d mf sf}bd\
+/T{m sh}bd\
+/Tb{gs sc f_ ff sf cft/FontMatrix get 3 get\
+  cft/FontBBox get dp 1 get x 3 get 2 i ml 3 1 r ml\
+  0 0 m 4 i stw p 4 i 4 i m fm_ cc\
+  0 2 i rl dp 0 rl 0 2 i ng rl 0 3 i rl ng 0 rl cp fl p p\
+  gr T}bd\
+/Im1{6 4 r tr scl t [3 i 0 0 5 i 0 0]{cf str1 rh p} im}bd\
+/Im1rev{6 4 r tr scl f [3 i 0 0 5 i 0 0]{cf str1 rh p} im}bd\
+/Im24{gs 6 4 r tr scl 8 [3 i 0 0 5 i 0 0]{cf str3 rh p} f 3 ci}bd\
+/Im1t{6 4 r tr scl t [3 i 0 0 5 i 0 0]{} im}bd\
+/Im24t{gs 6 4 r tr scl 8 [3 i 0 0 5 i 0 0]{} f 3 ci}bd\
+/ck2{/currentpagedevice wh \
+{p dp currentpagedevice dp 3 -1 r kn \
+{x get al p 3 -1 r eq 3 1 r eq and } \
+{p p p p t}ie} \
+{p p p t}ie}bd \
+/ck1{/currentpagedevice wh \
+{p dp currentpagedevice dp 3 -1 r kn \
+{x get eq} {p p p t}ie} \
+{p p t}ie}bd \
+/mtx{scl t [3 i 0 0 5 i 0 0]}bd \
+";
+
+int  pagenum = 0;
+char *pg_orient[] = {"Portrait","Landscape","Reverse Portrait","Reverse Landscape"};
+/*
+ *  Setup definitions
+ */
+
+static char *S_SetupDefs = "\
+ /mx_ mx d\
+ /im_ mx d\
+ /tm1_ mx d\
+ /tm2_ mx d\
+ /str3 3 str d\
+ /str1 1 str d\
+";
+
+/*******************************************************************
+ *                       PRIVATE FUNCTIONS                         *
+ *******************************************************************/
+
+static void
+S_Flush(PsOutPtr self)
+{
+  if( self->Buf[0] )
+  {
+    if( self->Buf[strlen(self->Buf)-1]!='\n' ) strcat(self->Buf, "\n");
+
+    if (!ferror(self->Fp)) {
+	(void) fputs(self->Buf, self->Fp);
+    }
+
+    self->Buf[0] = '\0';
+  }
+}
+
+static void
+S_Comment(PsOutPtr self, char *comment)
+{
+  S_Flush(self);
+  strcpy(self->Buf, comment);
+  S_Flush(self);
+}
+
+static void
+S_OutDefs(PsOutPtr self, char *defs)
+{
+  int  i, k=0;
+  S_Flush(self);
+  memset(self->Buf, 0, 256);
+  for( i=0 ; defs[i]!='\0' ;)
+  {
+    if( k>70 && (i==0 || (i && defs[i-1]!='/')) &&
+        (defs[i]==' ' || defs[i]=='/' || defs[i]=='{') )
+    {
+      S_Flush(self);
+      k = 0;
+      memset(self->Buf, 0, 256);
+    }
+    if( k && self->Buf[k-1]==' ' && defs[i]==' ' ) { i++; continue; }
+    self->Buf[k] = defs[i];
+    k++; i++;
+  }
+  S_Flush(self);
+}
+
+static void
+S_OutNum(PsOutPtr self, float num)
+{
+  int  i;
+  char buf[64];
+  sprintf(buf, "%.3f", num);
+  for( i=strlen(buf)-1 ; buf[i]=='0' ; i-- ); buf[i+1] = '\0';
+  if( buf[strlen(buf)-1]=='.' ) buf[strlen(buf)-1] = '\0';
+  if( self->Buf[0] ) strcat(self->Buf, " ");
+  strcat(self->Buf, buf);
+  if( strlen(self->Buf)>70 ) S_Flush(self);
+}
+
+static void
+S_OutStr(PsOutPtr self, char *txt, int txtl)
+{
+  int  i, k;
+  char buf[512];
+  for( i=0,k=0 ; i<txtl ; i++ )
+  {
+    if( (txt[i]>=' ' && txt[i]<='~') &&
+        txt[i]!='(' && txt[i]!=')' && txt[i]!='\\' )
+      { buf[k] = txt[i]; k++; continue; }
+    buf[k] = '\\'; k++;
+    sprintf(&buf[k], "%03o", txt[i]&0xFF);
+    k += 3;
+  }
+  strcat(self->Buf, "(");
+  i = strlen(self->Buf);
+  memcpy(&self->Buf[i], buf, k);
+  self->Buf[i+k] = '\0';
+  strcat(self->Buf, ")");
+  if( strlen(self->Buf)>70 ) S_Flush(self);
+}
+
+static void
+S_OutTok(PsOutPtr self, char *tok, int cr)
+{
+  if( self->Buf[0] ) strcat(self->Buf, " ");
+  strcat(self->Buf, tok);
+  if( cr ) S_Flush(self);
+}
+
+static void
+S_Color(PsOutPtr self, int clr)
+{
+  int   ir, ig, ib;
+  ir = clr>>16; ig = (clr>>8)&0xFF; ib = clr&0xFF;
+  if( ir==ig && ig==ib )
+    { S_OutNum(self, (float)ir/255.); S_OutTok(self, "g", 1); }
+  else
+  {
+    S_OutNum(self, (float)ir/255.);
+    S_OutNum(self, (float)ig/255.);
+    S_OutNum(self, (float)ib/255.);
+    S_OutTok(self, "sc", 1);
+  }
+}
+
+static void
+S_SetPageDevice(PsOutPtr self, int orient, int count, int plex, int res,
+                int wd, int ht, int isPage)
+{
+    float fwd = ((float)wd/(float)res)*72.;
+    float fht = ((float)ht/(float)res)*72.;
+
+    S_OutTok(self, "/pWd", 0);
+    S_OutNum(self, fwd);
+    S_OutTok(self, "d /pHt", 0);
+    S_OutNum(self, fht);
+    S_OutTok(self, "d", 1);
+
+  /*
+   * if these are page attributes, have PostScript check to see if they
+   * have changed.  If not, don't do setpagedevice, since it will cause
+   * a page flush and screw up duplex printing.  Having PostScript check
+   * means we don't have to keep track ourselves.
+   */
+    if(isPage) {
+      S_OutNum(self, (float) orient);
+      S_OutTok(self, "/Orientation ck1", 0);
+      S_OutTok(self, "pWd pHt /PageSize ck2 and not {", 1);
+    }
+    S_OutTok(self, "{db", 0);
+
+    S_OutTok(self, "/Orientation", 0);
+    S_OutNum(self, (float) orient);
+    S_OutTok(self, " d ", 0);
+    S_OutTok(self, "/PageSize [pWd pHt] d", 0);
+
+    S_OutTok(self, " de spd", 0);
+    /*
+   * save a flag to show if we failed to set orientation... determined
+   * by both/either Orientation and/or PageSize, use this
+   * later to set/not set orientation using Cs command.
+   */
+    S_OutTok(self,"}stp /orientationFailed x d", 1);
+    /*
+   * if these are page attributes, have PostScript check to see if they
+   * have changed.  If not, don't do setpagedevice, since it will cause
+   * a page flush and screw up duplex printing.  Having PostScript check
+   * means we don't have to keep track ourselves.
+   */
+    if(isPage)
+    {
+      S_OutTok(self,"}if",1);
+
+      S_OutTok(self, (plex==0)?"f":"t", 0);
+      S_OutTok(self, "/Duplex ck1 ", 0);
+
+      S_OutTok(self, (plex==2)?"t":"f", 0);
+      S_OutTok(self, "/Tumble ck1 and ", 0);
+
+
+      S_OutNum(self, (float)res);
+      S_OutNum(self, (float)res);
+      S_OutTok(self, " /HWResolution ck2 and", 0);
+      
+      if( count>1 )
+      {
+          S_OutNum(self, (float)count);
+          S_OutTok(self, " /NumCopies", 0);
+          S_OutTok(self, " ck1 and ", 0);
+      }
+      S_OutTok(self," not {",1);
+    }
+    S_OutTok(self, "{db", 0);
+
+    S_OutTok(self, "/Duplex ", 0);
+    S_OutTok(self, (plex==0)?"f":"t", 0);
+    S_OutTok(self, " d ", 0);
+
+    S_OutTok(self, "/Tumble ", 0);
+    S_OutTok(self, (plex==2)?"t":"f", 0);
+    S_OutTok(self, " d ", 0);
+  
+    S_OutTok(self, " /HWResolution [", 0);
+    S_OutNum(self, (float)res);
+    S_OutNum(self, (float)res);
+    S_OutTok(self, "] d ", 0);
+
+    if( count>1 )
+    {
+      S_OutTok(self, " /NumCopies", 0);
+      S_OutNum(self, (float)count);
+      S_OutTok(self, " d ", 0);
+    }
+    S_OutTok(self, " de spd}stp p", 1);
+
+    if(isPage)
+    {
+      S_OutTok(self, "}if", 1);
+    }
+}
+
+/*******************************************************************
+ *                        PUBLIC FUNCTIONS                         *
+ *******************************************************************/
+
+FILE *
+PsOut_ChangeFile(PsOutPtr self, FILE *fp)
+{
+  FILE *nfp;
+
+  nfp = self->Fp;
+
+  self->Fp = fp;
+
+  return nfp;
+}
+
+PsOutPtr
+PsOut_BeginFile(FILE *fp, int orient, int count, int plex, int res,
+                int wd, int ht, Bool raw)
+{
+  int  i;
+/*
+ *  Get ready to output PostScript header
+ */
+  PsOutPtr psout;
+  psout = (PsOutPtr)xalloc(sizeof(PsOutRec));
+  memset(psout, 0, sizeof(PsOutRec));
+  psout->Fp = fp;
+  psout->isRaw = raw;
+  pagenum = 0;
+
+  if (!raw) {
+/*
+ *  Output PostScript header
+ */
+      S_Comment(psout, "%!PS-Adobe-3.0 EPSF-3.0");
+      S_Comment(psout, "%%Creator: The Open Group PostScript Print Server");
+      /*### BoundingBox ###*/
+      S_Comment(psout, "%%EndComments");
+      S_Comment(psout, "%%BeginProlog");
+      S_Comment(psout, "%%BeginProcSet: XServer_PS_Functions");
+      S_OutDefs(psout, S_StandardDefs);
+      S_OutDefs(psout, S_CompositeDefs);
+      S_Comment(psout, "%%EndProcSet");
+      S_Comment(psout, "%%EndProlog");
+      S_Comment(psout, "%%BeginSetup");
+      /* set document level page attributes */
+      S_SetPageDevice(psout, orient, count, plex, res, wd, ht, 0);
+      S_Comment(psout, "%%Pages: atend");
+      S_OutDefs(psout, S_SetupDefs);
+      S_Comment(psout, "%%EndSetup");
+  }
+/*
+ *  Initialize the structure
+ */
+  psout->CurColor    = 0xFFFFFFFF;
+  psout->LineWidth   = 1;
+  psout->LineCap     = PsCButt;
+  psout->LineJoin    = PsJMiter;
+  psout->NDashes     = 0;
+  psout->Dashes      = (int *)0;
+  psout->FontName    = (char *)0;
+  psout->FontSize    = 0;
+  psout->start_image = 0;
+  for( i=0 ; i<4 ; i++ ) psout->FontMtx[i] = 0.;
+  psout->ImageFormat = 0;
+  return(psout);
+}
+
+void
+PsOut_EndFile(PsOutPtr self, int closeFile)
+{
+  char coms[50];
+  int  i;
+
+  if (!self->isRaw) {
+      S_Comment(self,"%%Trailer");
+      sprintf(coms,"%%%%Pages: %d",pagenum);
+      S_Comment(self, coms);
+      S_Comment(self, "%%EOF");
+  }
+  if( self->NDashes && self->Dashes ) xfree(self->Dashes);
+  if( self->FontName ) xfree(self->FontName);
+  if( self->Patterns ) xfree(self->Patterns);
+  if( self->Clip.rects ) xfree(self->Clip.rects);
+  if( closeFile ) fclose(self->Fp);
+  for( i=0 ; i<self->NDownloads ; i++ ) xfree(self->Downloads[i]);
+  if( self->Downloads ) xfree(self->Downloads);
+  pagenum = 0; /* reset page num back to 0 */
+  xfree(self);
+}
+
+void
+PsOut_BeginPage(PsOutPtr self, int orient, int count, int plex, int res,
+                int wd, int ht)
+{
+  char coms[50];
+
+/*** comment for pagenumbers *****/
+
+  S_Comment(self,"%%PageHeader");
+  pagenum++;
+  sprintf(coms,"%%%%Page: %d %d",pagenum,pagenum);
+  S_Comment(self, coms);
+  sprintf(coms,"%%%%PageOrientation: %s",pg_orient[orient]);
+  S_Comment(self, coms);
+
+/*** end comment *****************/
+
+  /* set page level page attributes */
+  S_SetPageDevice(self, orient, count, plex, res, wd, ht, 1);
+  
+  S_OutTok(self, "gs ", 0);
+  /*
+   * check to see if we set orientation already; if it wasn't set,
+   * use Cs to set orientation here.
+   */
+  S_OutNum(self, (float)orient);
+  S_OutTok(self, "orientationFailed { ", 0);
+  S_OutNum(self, (float)orient);
+  S_OutTok(self, " } { 0 }ie Cs 100 sml gs", 1);
+}
+
+void
+PsOut_EndPage(PsOutPtr self)
+{
+  S_OutTok(self, "gr gr sp", 1);
+
+  /* did grestore: mark attributes 'dirty' so they will be re-sent */
+  PsOut_DirtyAttributes(self);
+
+/*** comment for pagenumbers *****/
+
+  S_Comment(self,"%%PageTrailer");
+
+/*** end comment *****************/
+}
+
+void
+PsOut_DirtyAttributes(PsOutPtr self)
+{
+  int  i;
+  self->CurColor    = 0xFFFFFFFF;
+  self->LineWidth   = -1;
+  self->LineCap     = (PsCapEnum)-1;
+  self->LineJoin    = (PsJoinEnum)-1;
+  self->NDashes     = -1;
+  self->FontSize    = -1;
+  for( i=0 ; i<4 ; i++ ) self->FontMtx[i] = -1.;
+  if( self->Dashes   ) { xfree(self->Dashes);   self->Dashes   = (int *)0;  }
+  if( self->FontName ) { xfree(self->FontName); self->FontName = (char *)0; }
+}
+
+void
+PsOut_Comment(PsOutPtr self, char *comment)
+{
+  S_Comment(self, comment);
+}
+
+void
+PsOut_Offset(PsOutPtr self, int x, int y)
+{
+  self->XOff = x;
+  self->YOff = y;
+}
+
+void
+PsOut_Clip(PsOutPtr self, int clpTyp, PsClipPtr clpinf)
+{
+  int  i, k;
+  int  changed = 0;
+  int  xo = self->XOff;
+  int  yo = self->YOff;
+
+  if( self->InTile ) return;
+  if( self->InFrame ) xo = yo = 0;
+  if( clpTyp!=self->ClipType ) changed = 1;
+  else
+  {
+    if( clpinf->nRects!=self->Clip.nRects ) changed = 1;
+    else
+    {
+      if( clpinf->nOutterClips!=self->Clip.nOutterClips ) changed = 1;
+      else
+      {
+        for( i=0 ; i<clpinf->nOutterClips ; i++ )
+        {
+          if( memcmp(&clpinf->outterClips[i], &self->Clip.outterClips[i],
+                     sizeof(PsRectRec))!=0 ) break;
+        }
+        if( i<clpinf->nOutterClips ) changed = 1;
+        else
+        {
+          for( i=0 ; i<clpinf->nRects ; i++ )
+          {
+            if( memcmp(&clpinf->rects[i], &self->Clip.rects[i],
+                       sizeof(PsRectRec))!=0 ) { changed = 1; break; }
+          }
+        }
+      }
+    }
+    if( clpinf->nElms!=self->Clip.nElms ) changed = 1;
+    else
+    {
+      for( i=0 ; i<clpinf->nElms ; i++ )
+      {
+        if( clpinf->elms[i].type!=PSOUT_POINTS )
+        {
+          if( memcmp(&clpinf->elms[i], &self->Clip.elms[i],
+                     sizeof(PsElmRec))!=0 ) { changed = 1; break; }
+        }
+        else
+        {
+          if( clpinf->elms[i].type!=self->Clip.elms[i].type ||
+              clpinf->elms[i].nPoints!=self->Clip.elms[i].nPoints )
+            { changed = 1; break; }
+          else
+          {
+            for( k=0 ; k<clpinf->elms[i].nPoints ; k++ )
+            {
+              if( memcmp(&clpinf->elms[i].c.points[k],
+                         &self->Clip.elms[i].c.points[k], sizeof(PsPointRec)) )
+                { changed = 1; break; }
+            }
+            if( changed ) break;
+          }
+        }
+      }
+    }
+  }
+
+  if( self->Clip.rects )       xfree(self->Clip.rects);
+  if( self->Clip.outterClips ) xfree(self->Clip.outterClips);
+  if( self->Clip.elms )
+    PsDestroyFillElementList(self->Clip.nElms, self->Clip.elms);
+  self->ClipType          = clpTyp;
+  self->Clip.nRects       = clpinf->nRects;
+  self->Clip.nElms        = clpinf->nElms;
+  self->Clip.nOutterClips = clpinf->nOutterClips;
+  if( clpinf->nRects )
+  {
+    self->Clip.rects = (PsRectPtr)xalloc(clpinf->nRects*sizeof(PsRectRec));
+    memcpy(self->Clip.rects, clpinf->rects, clpinf->nRects*sizeof(PsRectRec));
+  }
+  else self->Clip.rects = 0;
+  if( clpinf->nOutterClips )
+  {
+    self->Clip.outterClips = (PsRectPtr)xalloc(clpinf->nOutterClips*
+					       sizeof(PsRectRec));
+    memcpy(self->Clip.outterClips, clpinf->outterClips,
+           clpinf->nOutterClips*sizeof(PsRectRec));
+  }
+  else self->Clip.outterClips = 0;
+  if( clpinf->nElms )
+    self->Clip.elms = PsCloneFillElementList(clpinf->nElms, clpinf->elms);
+  else self->Clip.elms = 0;
+
+  PsOut_DirtyAttributes(self);
+  S_OutTok(self, "gr gs", 1);
+  if( self->Clip.nOutterClips )
+  {
+    for( i=0 ; i<self->Clip.nOutterClips ; i++ )
+    {
+      S_OutNum(self, (float)(self->Clip.outterClips[i].x));
+      S_OutNum(self, (float)(self->Clip.outterClips[i].y));
+      S_OutNum(self, (float)self->Clip.outterClips[i].w);
+      S_OutNum(self, (float)self->Clip.outterClips[i].h);
+      S_OutTok(self, "R", 1);
+    }
+    S_OutTok(self, "cl n", 1);
+  }
+  if( self->Clip.nRects )
+  {
+    for( i=0 ; i<self->Clip.nRects ; i++ )
+    {
+      S_OutNum(self, (float)(self->Clip.rects[i].x+xo));
+      S_OutNum(self, (float)(self->Clip.rects[i].y+yo));
+      S_OutNum(self, (float)self->Clip.rects[i].w);
+      S_OutNum(self, (float)self->Clip.rects[i].h);
+      S_OutTok(self, "R", 1);
+    }
+    S_OutTok(self, "cl n", 1);
+  }
+  if( self->Clip.nElms )
+  {
+    PsElmPtr elm = self->Clip.elms;
+    for( i=0 ; i<self->Clip.nElms ; i++,elm++ )
+    {
+      switch(elm->type)
+      {
+        case PSOUT_POINTS:
+          for( k=0 ; k<elm->nPoints ; k++ )
+          {
+            S_OutNum(self, (float)elm->c.points[k].x+xo);
+            S_OutNum(self, (float)elm->c.points[k].y+yo);
+            if( k==0 ) S_OutTok(self, "m", 0);
+            else       S_OutTok(self, "l", 0);
+          }
+          S_OutTok(self, "cp", 1);
+          break;
+        case PSOUT_RECT:
+          S_OutNum(self, (float)elm->c.rect.x+xo);
+          S_OutNum(self, (float)elm->c.rect.y+yo);
+          S_OutNum(self, (float)elm->c.rect.w);
+          S_OutNum(self, (float)elm->c.rect.h);
+          S_OutTok(self, "R", 1);
+          break;
+        case PSOUT_ARC:
+          if( elm->c.arc.style==PsPieSlice )
+          {
+            S_OutNum(self, (float)elm->c.arc.x+xo+(float)elm->c.arc.w/2.);
+            S_OutNum(self, (float)elm->c.arc.y+yo+(float)elm->c.arc.h/2.);
+            S_OutTok(self, "m", 0);
+          }
+          S_OutNum(self, (float)elm->c.arc.x+xo+(float)elm->c.arc.w/2.);
+          S_OutNum(self, (float)elm->c.arc.y+yo+(float)elm->c.arc.h/2.);
+          S_OutNum(self, (float)elm->c.arc.w);
+          S_OutNum(self, (float)elm->c.arc.h);
+          S_OutNum(self, (float)elm->c.arc.a1/64.);
+          S_OutNum(self, (float)elm->c.arc.a1/64.+(float)elm->c.arc.a2/64.);
+          if( elm->c.arc.a2<0 ) S_OutTok(self, "An cp", 1);
+          else                  S_OutTok(self, "Ac cp", 1);
+          break;
+      }
+    }
+    S_OutTok(self, "cl n", 1);
+  }
+}
+
+void
+PsOut_Color(PsOutPtr self, int clr)
+{
+  if( clr==self->CurColor || self->InTile>=PsStip ) return;
+  self->CurColor = clr;
+  S_Color(self, clr);
+}
+
+void
+PsOut_FillRule(PsOutPtr self, PsRuleEnum rule)
+{
+  self->FillRule = rule;
+}
+
+void
+PsOut_LineAttrs(PsOutPtr self, int wd, PsCapEnum cap, PsJoinEnum join,
+                int nDsh, int *dsh, int dshOff, int bclr)
+{
+  int         i;
+  int         same = 1;
+
+  if( wd!=self->LineWidth && wd>=0 )
+  {
+    if( wd==0 ) wd = 1;
+    self->LineWidth = wd;
+    S_OutNum(self, (float)wd); S_OutTok(self, "w", 1);
+  }
+  if( cap!=self->LineCap )
+  {
+    self->LineCap = cap;
+    S_OutNum(self, (float)cap); S_OutTok(self, "lc", 1);
+  }
+  if( join!=self->LineJoin )
+  {
+    self->LineJoin = join;
+    S_OutNum(self, (float)join); S_OutTok(self, "lj", 1);
+  }
+  if( nDsh!=self->NDashes ) same = 0;
+  else if( dshOff!=self->DashOffset ) same = 0;
+  else if( nDsh )
+  {
+    for( i=0 ; i<nDsh ; i++ )
+      { if( dsh[i]!=self->Dashes[i] ) break; }
+    if( i<nDsh ) same = 0;
+  }
+  if( !same )
+  {
+    if( self->NDashes && self->Dashes )
+      { xfree(self->Dashes); self->Dashes = (int *)0; }
+    self->NDashes    = nDsh;
+    self->DashOffset = dshOff;
+    if( nDsh ) self->Dashes = (int *)xalloc(sizeof(int)*nDsh);
+    S_OutTok(self, "[", 0);
+    for( i=0 ; i<nDsh ; i++ )
+    {
+      self->Dashes[i] = dsh[i];
+      S_OutNum(self, (float)dsh[i]);
+    }
+    S_OutTok(self, "]", 0);
+    S_OutNum(self, (float)dshOff);
+    S_OutTok(self, "ds", 1);
+  }
+
+  if( nDsh ) self->LineBClr = bclr; else bclr = -1;
+}
+
+void
+PsOut_TextAttrs(PsOutPtr self, char *fnam, int siz, int iso)
+{
+  int       i;
+  char      buf[256];
+  if( self->FontName && strcmp(fnam, self->FontName)==0 &&
+      siz==self->FontSize ) return;
+  if( self->FontName ) xfree(self->FontName);
+  self->FontName = (char *)xalloc(strlen(fnam)+1);
+  strcpy(self->FontName, fnam);
+  self->FontSize = siz;
+  for( i=0 ; i<4 ; i++ ) self->FontMtx[i] = -1.;
+  strcpy(buf, "/"); strcat(buf, fnam);
+  S_OutTok(self, buf, 0);
+  S_OutNum(self, (float)siz);
+  if( iso ) S_OutTok(self, "t", 0);
+  else      S_OutTok(self, "f", 0);
+  S_OutTok(self, "Tf", 1);
+}
+
+void
+PsOut_TextAttrsMtx(PsOutPtr self, char *fnam, float *mtx, int iso)
+{
+  int       i;
+  char      buf[256];
+  if( self->FontName && strcmp(fnam, self->FontName)==0 &&
+      mtx[0]==self->FontMtx[0] && mtx[1]==self->FontMtx[1] &&
+      mtx[2]==self->FontMtx[2] && mtx[3]==self->FontMtx[3] ) return;
+  if( self->FontName ) xfree(self->FontName);
+  self->FontName = (char *)xalloc(strlen(fnam)+1);
+  strcpy(self->FontName, fnam);
+  for( i=0 ; i<4 ; i++ ) self->FontMtx[i] = mtx[i];
+  self->FontSize = -1;
+  strcpy(buf, "/"); strcat(buf, fnam); strcat(buf, " [");
+  S_OutTok(self, buf, 0);
+  for( i=0 ; i<4 ; i++ ) S_OutNum(self, mtx[i]);
+  S_OutTok(self, "0 0]", 0);
+  if( iso ) S_OutTok(self, "t", 0);
+  else      S_OutTok(self, "f", 0);
+  S_OutTok(self, "Tfm", 1);
+}
+
+void
+PsOut_Polygon(PsOutPtr self, int nPts, PsPointPtr pts)
+{
+  int  i;
+  int  xo = self->XOff;
+  int  yo = self->YOff;
+
+  if( self->InFrame || self->InTile ) xo = yo = 0;
+  if( nPts<=2 ) return;
+  for( i=0 ; i<nPts ; i++ )
+  {
+    S_OutNum(self, (float)(pts[i].x+xo));
+    S_OutNum(self, (float)(pts[i].y+yo));
+    if( i==0 ) S_OutTok(self, "m", 0);
+    else       S_OutTok(self, "l", 0);
+  }
+  if( self->FillRule==PsEvenOdd ) S_OutTok(self, "cp ef", 1);
+  else                            S_OutTok(self, "cp fl", 1);
+}
+
+void
+PsOut_FillRect(PsOutPtr self, int x, int y, int w, int h)
+{
+  int  xo = self->XOff;
+  int  yo = self->YOff;
+
+  if( self->InFrame || self->InTile ) xo = yo = 0;
+  x += xo; y += yo;
+  S_OutNum(self, (float)x);
+  S_OutNum(self, (float)y);
+  S_OutNum(self, (float)w);
+  S_OutNum(self, (float)h);
+  S_OutTok(self, "R fl", 1);
+}
+
+void
+PsOut_FillArc(PsOutPtr self, int x, int y, int w, int h,
+	      float ang1, float ang2, PsArcEnum style)
+{
+  int  xo = self->XOff;
+  int  yo = self->YOff;
+
+  if( self->InFrame || self->InTile ) xo = yo = 0;
+  x += xo; y += yo;
+  if( style==PsPieSlice )
+  {
+    S_OutNum(self, (float)x+(float)w/2.);
+    S_OutNum(self, (float)y+(float)h/2.);
+    S_OutTok(self, "m", 0);
+  }
+  S_OutNum(self, (float)x+(float)w/2.);
+  S_OutNum(self, (float)y+(float)h/2.);
+  S_OutNum(self, (float)w);
+  S_OutNum(self, (float)h);
+  S_OutNum(self, ang1);
+  S_OutNum(self, ang1+ang2);
+  if( ang2<0 ) S_OutTok(self, "An cp fl", 1);
+  else         S_OutTok(self, "Ac cp fl", 1);
+}
+
+void
+PsOut_Lines(PsOutPtr self, int nPts, PsPointPtr pts)
+{
+  int  i;
+  int  xo = self->XOff;
+  int  yo = self->YOff;
+
+  if( self->InFrame || self->InTile ) xo = yo = 0;
+  if( nPts<1 ) return;
+  for( i=0 ; i<nPts ; i++ )
+  {
+    S_OutNum(self, (float)(pts[i].x+xo));
+    S_OutNum(self, (float)(pts[i].y+yo));
+    if( i==0 ) S_OutTok(self, "m", 0);
+    else       S_OutTok(self, "l", 0);
+  }
+  if( self->LineBClr>=0 )
+  {
+    S_OutTok(self, "gs", 0);
+    S_Color(self, self->LineBClr);
+    S_OutTok(self, "[] 0 ds st gr", 0);
+  }
+  S_OutTok(self, "st", 1);
+}
+
+void
+PsOut_Points(PsOutPtr self, int nPts, PsPointPtr pts)
+{
+  int  i;
+  int  xo = self->XOff;
+  int  yo = self->YOff;
+
+  if( self->InFrame || self->InTile ) xo = yo = 0;
+  if( nPts<1 ) return;
+  for( i=0 ; i<nPts ; i++ )
+  {
+    S_OutNum(self, (float)(pts[i].x+xo));
+    S_OutNum(self, (float)(pts[i].y+yo));
+    S_OutTok(self, "P", 1);
+  }
+}
+
+void
+PsOut_DrawRect(PsOutPtr self, int x, int y, int w, int h)
+{
+  int  xo = self->XOff;
+  int  yo = self->YOff;
+
+  if( self->InFrame || self->InTile ) xo = yo = 0;
+  x += xo; y += yo;
+  S_OutNum(self, (float)x);
+  S_OutNum(self, (float)y);
+  S_OutNum(self, (float)w);
+  S_OutNum(self, (float)h);
+  S_OutTok(self, "R", 0);
+  if( self->LineBClr>=0 )
+  {
+    S_OutTok(self, "gs", 0);
+    S_Color(self, self->LineBClr);
+    S_OutTok(self, "[] 0 ds st gr", 0);
+  }
+  S_OutTok(self, "st", 1);
+}
+
+void
+PsOut_DrawArc(PsOutPtr self, int x, int y, int w, int h, 
+	      float ang1, float ang2)
+{
+  int  xo = self->XOff;
+  int  yo = self->YOff;
+
+  if( self->InFrame || self->InTile ) xo = yo = 0;
+  x += xo; y += yo;
+  S_OutNum(self, (float)x+(float)w/2.);
+  S_OutNum(self, (float)y+(float)h/2.);
+  S_OutNum(self, (float)w);
+  S_OutNum(self, (float)h);
+  S_OutNum(self, ang1);
+  S_OutNum(self, ang1+ang2);
+  if( ang2<0 ) S_OutTok(self, "An", 0);
+  else         S_OutTok(self, "Ac", 0);
+  if( self->LineBClr>=0 )
+  {
+    S_OutTok(self, "gs", 0);
+    S_Color(self, self->LineBClr);
+    S_OutTok(self, "[] 0 ds st gr", 0);
+  }
+  S_OutTok(self, "st", 1);
+}
+
+void
+PsOut_Text(PsOutPtr self, int x, int y, char *text, int textl, int bclr)
+{
+  int  xo = self->XOff;
+  int  yo = self->YOff;
+
+  if( self->InFrame || self->InTile ) xo = yo = 0;
+  x += xo; y += yo;
+  S_OutStr(self, text, textl);
+  S_OutNum(self, (float)x);
+  S_OutNum(self, (float)y);
+  if( bclr<0 ) S_OutTok(self, "T", 1);
+  else
+  {
+    int ir = bclr>>16;
+    int ig = (bclr>>8)&0xFF;
+    int ib = bclr&0xFF;
+    S_OutNum(self, (float)ir/255.);
+    S_OutNum(self, (float)ig/255.);
+    S_OutNum(self, (float)ib/255.);
+    S_OutTok(self, "Tb", 1);
+  }
+}
+
+#ifdef BM_CACHE
+void  /* new */
+PsOut_ImageCache(PsOutPtr self, int x, int y, long cache_id, int bclr, int fclr)
+{
+  char cacheID[10];
+  int xo = self->XOff;
+  int yo = self->YOff;
+
+  if( self->InFrame || self->InTile ) xo = yo = 0;
+  x += xo; y += yo;
+  sprintf(cacheID, "c%di", cache_id);
+
+  S_OutNum(self, (float)x);
+  S_OutNum(self, (float)y);
+
+  if( fclr==0xFFFFFF )
+  {
+    int   ir, ig, ib;
+    ir = bclr>>16; ig = (bclr>>8)&0xFF; ib = bclr&0xFF;
+    if( ir==ig && ig==ib )
+      S_OutNum(self, (float)ir/255.);
+    else
+      S_OutNum(self, (float)0);
+      self->RevImage = 1;
+    }
+  else
+  {
+    int   ir, ig, ib;
+    ir = fclr>>16; ig = (fclr>>8)&0xFF; ib = fclr&0xFF;
+    if( ir==ig && ig==ib )
+      S_OutNum(self, (float)ir/255.);
+    else
+      S_OutNum(self, (float)0);
+  }
+
+  S_OutTok(self, cacheID, 1);
+}     /* new */
+
+void  /* new */
+PsOut_BeginImageCache(PsOutPtr self, long cache_id)
+{
+  char cacheID[10];
+
+  sprintf(cacheID, "/c%di {", cache_id);
+
+  S_OutTok(self, cacheID, 0);
+}     /* new */
+
+void  /* new */
+PsOut_EndImageCache(PsOutPtr self)
+{
+  S_OutTok(self, "}bd", 1);
+}     /* new */
+#endif
+
+void
+PsOut_BeginImage(PsOutPtr self, int bclr, int fclr, int x, int y,
+                 int w, int h, int sw, int sh, int format)
+{
+  int savClr = self->CurColor;
+  int xo = self->XOff;
+  int yo = self->YOff;
+
+  if( self->InFrame || self->InTile ) xo = yo = 0;
+  x += xo; y += yo;
+  if( self->InTile )
+  {
+    if( self->InTile>=PsStip && format!=1 ) { self->ImgSkip = 1; return; }
+    self->ImgBClr = bclr; self->ImgFClr = fclr;
+    self->ImgX    = x;    self->ImgY    = y;
+    self->ImgW    = w;    self->ImgH    = h;
+    self->SclW    = sw;   self->SclH    = sh;
+    S_OutTok(self, "<", 0);
+    self->ImageFormat = format;
+    self->RevImage = 0;
+    if( self->InTile==PsTile && format==1 && fclr==0xFFFFFF )
+      self->RevImage = 1;
+    return;
+  }
+
+  self->RevImage = 0;
+  if( format==1 )
+  {
+    S_OutTok(self, "gs", 0);
+    if( fclr==0xFFFFFF )
+    {
+      PsOut_Color(self, fclr);
+      PsOut_FillRect(self, x, y, sw, sh);
+      PsOut_Color(self, bclr);
+      self->RevImage = 1;
+    }
+    else
+    {
+      PsOut_Color(self, bclr);
+      PsOut_FillRect(self, x, y, sw, sh);
+      PsOut_Color(self, fclr);
+    }
+  }
+  S_OutNum(self, (float)x);
+  S_OutNum(self, (float)y);
+  S_OutNum(self, (float)w);
+  S_OutNum(self, (float)h);
+  S_OutNum(self, (float)sw);
+  S_OutNum(self, (float)sh);
+  if( format==1 ) {
+	if(self->RevImage) 
+	    S_OutTok(self, "Im1rev", 1);
+	else
+	    S_OutTok(self, "Im1", 1);
+  }
+  else            S_OutTok(self, "Im24", 1);
+  self->ImageFormat = format;
+  self->CurColor    = savClr;
+}
+
+void
+PsOut_BeginImageIM(PsOutPtr self, int bclr, int fclr, int x, int y,
+                 int w, int h, int sw, int sh, int format)
+{
+  int savClr = self->CurColor;
+  int xo = self->XOff;
+  int yo = self->YOff;
+
+  if( self->InFrame || self->InTile ) xo = yo = 0;
+  x += xo; y += yo;
+  if( self->InTile )
+  {
+    if( self->InTile>=PsStip && format!=1 ) { self->ImgSkip = 1; return; }
+    self->ImgBClr = bclr; self->ImgFClr = fclr;
+    self->ImgX    = x;    self->ImgY    = y;
+    self->ImgW    = w;    self->ImgH    = h;
+    self->SclW    = sw;   self->SclH    = sh;
+    S_OutTok(self, "<", 0);
+    self->ImageFormat = format;
+    self->RevImage = 0;
+    if( self->InTile==PsTile && format==1 && fclr==0xFFFFFF )
+      self->RevImage = 1;
+    return;
+  }
+
+  self->RevImage = 0;
+  if( format==1 )
+  {
+    S_OutTok(self, "gs", 0);
+#ifdef BM_CACHE
+    S_OutTok(self, "g", 1);
+#else
+    if( fclr==0xFFFFFF )
+    {
+      PsOut_Color(self, bclr);
+      self->RevImage = 1;
+    }
+    else
+    {
+      PsOut_Color(self, fclr);
+    }
+#endif
+  }
+
+#ifdef BM_CACHE
+  S_OutTok(self, "tr", 0);    /* new */
+#else
+  S_OutNum(self, (float)x);
+  S_OutNum(self, (float)y);
+#endif
+  S_OutNum(self, (float)w);
+  S_OutNum(self, (float)h);
+  S_OutNum(self, (float)sw);
+  S_OutNum(self, (float)sh);
+#ifdef BM_CACHE
+  S_OutTok(self, "mtx", 1);   /* new */
+  S_OutTok(self, "<", 0);     /* new */
+  self->start_image = 1;
+#else
+  if( format==1 ){
+        if(self->RevImage)
+            S_OutTok(self, "Im1rev", 1);
+        else
+            S_OutTok(self, "Im1", 1);
+  }
+  else      S_OutTok(self, "Im24", 1);
+#endif
+  self->ImageFormat = format;
+  self->CurColor    = savClr;
+}
+
+void
+PsOut_EndImage(PsOutPtr  self)
+{
+  if( self->ImgSkip ) { self->ImgSkip = 0; return; }
+  if( self->InTile )
+  {
+    S_OutTok(self, ">", 1);
+    if( self->ImageFormat==1 && self->InTile==PsTile )
+    {
+      if( self->ImgFClr==0xFFFFFF )
+      {
+        PsOut_Color(self, self->ImgFClr);
+        PsOut_FillRect(self, self->ImgX, self->ImgY, self->SclW, self->SclH);
+        PsOut_Color(self, self->ImgBClr);
+      }
+      else
+      {
+        PsOut_Color(self, self->ImgBClr);
+        PsOut_FillRect(self, self->ImgX, self->ImgY, self->SclW, self->SclH);
+        PsOut_Color(self, self->ImgFClr);
+      }
+    }
+    S_OutNum(self, (float)self->ImgX);
+    S_OutNum(self, (float)self->ImgY);
+    S_OutNum(self, (float)self->ImgW);
+    S_OutNum(self, (float)self->ImgH);
+    S_OutNum(self, (float)self->SclW);
+    S_OutNum(self, (float)self->SclH);
+    if( self->ImageFormat==1 ) S_OutTok(self, "Im1t", 1);
+    else                       S_OutTok(self, "Im24t", 1);
+    self->ImageFormat = 0;
+    self->RevImage    = 0;
+    return;
+  }
+
+#ifdef BM_CACHE
+  if(self->start_image)
+    S_OutTok(self, "> im", 1);       /* new */
+#endif
+  self->ImageFormat = 0;
+  self->RevImage    = 0;
+  S_Flush(self);
+#ifdef BM_CACHE
+  if(self->start_image)
+  {
+    self->start_image = 0;
+    S_OutTok(self, "gr", 0);
+  }
+  else
+    S_OutTok(self, "gr", 1);
+#else
+  S_OutTok(self, "gr", 1);
+#endif
+}
+
+void
+PsOut_OutImageBytes(PsOutPtr self, int nBytes, char *bytes)
+{
+  int   i;
+  char  buf[5];
+
+  if( (!self->ImageFormat) || self->ImgSkip ) return;
+  for( i=0 ; i<nBytes ; i++ )
+  {
+    if( self->RevImage ) sprintf(buf, "%02x", (int)(bytes[i]^0xFF)&0xFF);
+    else                 sprintf(buf, "%02x", (int)bytes[i]&0xFF);
+    strcat(self->Buf, buf);
+    if( strlen(self->Buf)>70 ) S_Flush(self);
+  }
+}
+
+void
+PsOut_BeginFrame(PsOutPtr self, int xoff, int yoff, int x, int y,
+                 int w, int h)
+{
+  int  xo = self->XOff;
+  int  yo = self->YOff;
+
+  if( self->InFrame ) xo = yo = 0;
+  S_OutTok(self, "gs", 0);
+  S_OutNum(self, (float)(x+xo));
+  S_OutNum(self, (float)(y+yo));
+  S_OutNum(self, (float)w);
+  S_OutNum(self, (float)h);
+  S_OutTok(self, "R cl n", 0);
+  xoff += xo; yoff += yo;
+  if( xoff || yoff )
+  {
+    S_OutNum(self, (float)xoff);
+    S_OutNum(self, (float)yoff);
+    S_OutTok(self, "tr", 0);
+  }
+  S_OutTok(self, "gs", 1);
+  self->InFrame += 1;
+}
+
+void
+PsOut_EndFrame(PsOutPtr self)
+{
+  self->InFrame -= 1;
+  if( self->InFrame<0 ) self->InFrame = 0;
+  S_OutTok(self, "gr gr", 1);
+  PsOut_DirtyAttributes(self);
+}
+
+int
+PsOut_BeginPattern(PsOutPtr self, void *tag, int w, int h, PsFillEnum type,
+                   int bclr, int fclr)
+{
+  int   i;
+  char  key[64];
+
+  for( i=0 ; i<self->NPatterns ; i++ )
+    { if( self->Patterns[i].tag==tag && self->Patterns[i].type==type ) break; }
+  if( i<self->NPatterns ) return(1);
+  if( (self->NPatterns+1)>self->MxPatterns )
+  {
+    if( self->Patterns )
+    {
+      self->MxPatterns *= 2;
+      self->Patterns =
+        (PsPatPtr)xrealloc(self->Patterns, sizeof(PsPatRec)*self->MxPatterns);
+    }
+    else
+    {
+      self->MxPatterns = 64;
+      self->Patterns = (PsPatPtr)xalloc(sizeof(PsPatRec)*self->MxPatterns);
+    }
+  }
+  self->Patterns[self->NPatterns].tag  = tag;
+  self->Patterns[self->NPatterns].type = type;
+  sprintf(key, "/ %d", (int)tag);
+  switch(type) {
+    case PsTile:   key[1] = 't'; break;
+    case PsStip:   key[1] = 's'; break;
+    case PsOpStip: key[1] = 'o'; break; }
+  S_OutTok(self, key, 0);
+  S_OutTok(self, "db/PatternType 1 d/PaintType 1 d", 0);
+  S_OutTok(self, "/TilingType 1 d/BBox[0 0", 0);
+  S_OutNum(self, (float)w);
+  S_OutNum(self, (float)h);
+  S_OutTok(self, "]d/XStep", 0);
+  S_OutNum(self, (float)w);
+  S_OutTok(self, "d/YStep", 0);
+  S_OutNum(self, (float)h);
+  S_OutTok(self, "d/PaintProc{bg sv", 1);
+  if( type==PsOpStip )
+  {
+    S_Color(self, bclr);
+    S_OutTok(self, "0 0", 0);
+    S_OutNum(self, (float)w);
+    S_OutNum(self, (float)h);
+    S_OutTok(self, "R fl", 1);
+  }
+  if( type!=PsTile ) S_Color(self, fclr);
+  self->NPatterns += 1;
+  self->InTile = type;
+  return(0);
+}
+
+void
+PsOut_EndPattern(PsOutPtr self)
+{
+  self->InTile = PsSolid;
+  S_OutTok(self, "rs ed}d de im_ mp d", 1);
+}
+
+void
+PsOut_SetPattern(PsOutPtr self, void *tag, PsFillEnum type)
+{
+  int   i;
+  char  key[64];
+
+  for( i=0 ; i<self->NPatterns ; i++ )
+    { if( tag==self->Patterns[i].tag && type==self->Patterns[i].type ) break; }
+  if( i>=self->NPatterns ) return;
+  sprintf(key, " %d", (int)tag);
+  switch(type) {
+    case PsTile:   key[0] = 't'; break;
+    case PsStip:   key[0] = 's'; break;
+    case PsOpStip: key[0] = 'o'; break; }
+  S_OutTok(self, key, 0);
+  S_OutTok(self, "spt", 1);
+  self->CurColor = 0xFFFFFFFF;
+}
+
+void
+PsOut_RawData(PsOutPtr self, char *data, int len)
+{
+    S_Flush(self);
+    if (!ferror(self->Fp)) {
+	(void) fwrite(data, 1, len, self->Fp);
+    }
+}
+
+void
+PsOut_DownloadType1(PsOutPtr self, char *name, char *fname)
+{
+  int     i;
+  int     stt;
+  char    buf[256];
+  FILE   *fp;
+
+  for( i=0 ; i<self->NDownloads ; i++ )
+    { if( strcmp(name, self->Downloads[i])==0 ) break; }
+  if( i<self->NDownloads ) return;
+
+  if( (self->NDownloads+1)>self->MxDownloads )
+  {
+    if( self->NDownloads )
+    {
+      self->MxDownloads *= 2;
+      self->Downloads = (char **)xrealloc(self->Downloads,
+                                self->MxDownloads*sizeof(char *));
+    }
+    else
+    {
+      self->MxDownloads = 32;
+      self->Downloads = (char **)xalloc(self->MxDownloads*sizeof(char *));
+    }
+  }
+
+  self->Downloads[self->NDownloads] = (char *)xalloc(strlen(name)+1);
+  strcpy(self->Downloads[self->NDownloads], name);
+  self->NDownloads += 1;
+
+  S_Flush(self);
+  sprintf(buf, "%%%%BeginFont: %s", name);
+  S_Comment(self, buf);
+  fp = fopen(fname, "r");
+  if( !fp ) return;
+  fread(buf, 1, 1, fp);
+  fseek(fp, (long)0, 0);
+  if( (buf[0]&0xFF)==0x80 )
+  {
+    int  len;
+
+    for(;;)
+    {
+      stt = fread(buf, 1, 2, fp);
+      if( stt!=2 || (buf[0]&0xFF)!=0x80 ) break;
+      if( (int)buf[1]<1 || (int)buf[1]>2 ) break;
+      stt = fread(buf, 1, 4, fp);
+      if( stt!=4 ) break;
+      len = ((buf[3]&0xFF)<<24)|((buf[2]&0xFF)<<16)|
+            ((buf[1]&0xFF)<<8)|(buf[0]&0xFF);
+      for(; len ;)
+      {
+        i = len<256 ? len : 256;
+        stt = fread(buf, 1, i, fp);
+        if( stt<=0 ) break;
+        if (!ferror(self->Fp)) {
+	    (void) fwrite(buf, 1, stt, self->Fp);
+	}
+        if( stt<i ) break;
+        len -= i;
+      }
+    }
+  }
+  else
+  {
+    for(;;)
+    {
+      stt = fread(buf, 1, 256, fp);
+      if( stt<=0 ) break;
+      if (!ferror(self->Fp)) {
+	  (void) fwrite(buf, 1, stt, self->Fp);
+      }
+      if( stt<256 ) break;
+    }
+  }
+  fclose(fp);
+  S_Flush(self);
+  S_Comment(self, "%%EndFont");
+}
diff --git a/Xprint/ps/psout.h b/Xprint/ps/psout.h
new file mode 100644
index 000000000..e8ca56458
--- /dev/null
+++ b/Xprint/ps/psout.h
@@ -0,0 +1,202 @@
+/* $Xorg: psout.h,v 1.6 2001/02/09 02:04:37 xorgcvs Exp $ */
+/*
+
+Copyright 1996, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+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
+OPEN GROUP 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 name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+/*
+ * (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:          psout.h
+**    *
+**    *  Contents:      Include file for psout.c
+**    *
+**    *  Created By:    Roger Helmendach (Liberty Systems)
+**    *
+**    *  Copyright:     Copyright 1996 The Open Group, Inc.
+**    *
+**    *********************************************************
+**
+********************************************************************/
+
+#ifndef _psout_
+#define _psout_
+
+#include <stdio.h>
+
+typedef enum PsCapEnum_  { PsCButt=0,   PsCRound, PsCSquare    } PsCapEnum;
+typedef enum PsJoinEnum_ { PsJMiter=0,  PsJRound, PsJBevel     } PsJoinEnum;
+typedef enum PsArcEnum_  { PsChord,     PsPieSlice             } PsArcEnum;
+typedef enum PsRuleEnum_ { PsEvenOdd,   PsNZWinding            } PsRuleEnum;
+typedef enum PsFillEnum_ { PsSolid=0, PsTile, PsStip, PsOpStip } PsFillEnum;
+
+typedef struct PsPointRec_
+{
+  int  x;
+  int  y;
+} PsPointRec;
+
+typedef PsPointRec *PsPointPtr;
+
+typedef struct PsRectRec_
+{
+  int  x;
+  int  y;
+  int  w;
+  int  h;
+} PsRectRec;
+
+typedef PsRectRec *PsRectPtr;
+
+typedef struct PsArcRec_
+{
+  int       x;
+  int       y;
+  int       w;
+  int       h;
+  int       a1;
+  int       a2;
+  PsArcEnum style;
+} PsArcRec;
+
+typedef PsArcRec *PsArcPtr;
+
+#define PSOUT_RECT    0
+#define PSOUT_ARC     1
+#define PSOUT_POINTS  2
+
+typedef struct PsElmRec_
+{
+  int  type;
+  int  nPoints;
+  union
+  {
+    PsRectRec  rect;
+    PsArcRec   arc;
+    PsPointPtr points;
+  } c;
+} PsElmRec;
+
+typedef PsElmRec *PsElmPtr;
+
+typedef struct PsClipRec_
+{
+  int        nRects;
+  PsRectPtr  rects;
+  int        nElms;
+  PsElmPtr   elms;
+  int        nOutterClips;
+  PsRectPtr  outterClips;
+} PsClipRec;
+
+typedef PsClipRec *PsClipPtr;
+
+typedef struct PsOutRec_ *PsOutPtr;
+
+extern PsOutPtr PsOut_BeginFile(FILE *fp, int orient, int count, int plex,
+                              int res, int wd, int ht, Bool raw);
+extern void PsOut_EndFile(PsOutPtr self, int closeFile);
+extern void PsOut_BeginPage(PsOutPtr self, int orient, int count, int plex,
+                            int res, int wd, int ht);
+extern void PsOut_EndPage(PsOutPtr self);
+extern void PsOut_DirtyAttributes(PsOutPtr self);
+extern void PsOut_Comment(PsOutPtr self, char *comment);
+extern void PsOut_Offset(PsOutPtr self, int x, int y);
+
+extern void PsOut_Clip(PsOutPtr self, int clpTyp, PsClipPtr clpinf);
+
+extern void PsOut_Color(PsOutPtr self, int clr);
+extern void PsOut_FillRule(PsOutPtr self, PsRuleEnum rule);
+extern void PsOut_LineAttrs(PsOutPtr self, int wd, PsCapEnum cap,
+                            PsJoinEnum join, int nDsh, int *dsh, int dshOff,
+                            int bclr);
+extern void PsOut_TextAttrs(PsOutPtr self, char *fnam, int siz, int iso);
+extern void PsOut_TextAttrsMtx(PsOutPtr self, char *fnam, float *mtx, int iso);
+
+extern void PsOut_Polygon(PsOutPtr self, int nPts, PsPointPtr pts);
+extern void PsOut_FillRect(PsOutPtr self, int x, int y, int w, int h);
+extern void PsOut_FillArc(PsOutPtr self, int x, int y, int w, int h,
+                          float ang1, float ang2, PsArcEnum style);
+
+extern void PsOut_Lines(PsOutPtr self, int nPts, PsPointPtr pts);
+extern void PsOut_Points(PsOutPtr self, int nPts, PsPointPtr pts);
+extern void PsOut_DrawRect(PsOutPtr self, int x, int y, int w, int h);
+extern void PsOut_DrawArc(PsOutPtr self, int x, int y, int w, int h,
+                          float ang1, float ang2);
+
+extern void PsOut_Text(PsOutPtr self, int x, int y, char *text, int textl,
+                       int bclr);
+
+extern void PsOut_BeginImage(PsOutPtr self, int bclr, int  fclr, int x, int y,
+                             int w, int h, int sw, int sh, int format);
+extern void PsOut_EndImage(PsOutPtr self);
+extern void PsOut_OutImageBytes(PsOutPtr self, int nBytes, char *bytes);
+
+extern void PsOut_BeginFrame(PsOutPtr self, int xoff, int yoff, int x, int y,
+                             int w, int h);
+extern void PsOut_EndFrame(PsOutPtr self);
+
+extern int  PsOut_BeginPattern(PsOutPtr self, void *tag, int w, int h,
+                               PsFillEnum type, int bclr, int fclr);
+extern void PsOut_EndPattern(PsOutPtr self);
+extern void PsOut_SetPattern(PsOutPtr self, void *tag, PsFillEnum type);
+
+extern void PsOut_RawData(PsOutPtr self, char *data, int len);
+extern void PsOut_DownloadType1(PsOutPtr self, char *name, char *fname);
+
+#endif