dlls/wineps/escape.c - wine - Git at Google

 /*
  *	PostScript driver Escape function
  *
  *	Copyright 1998  Huw D M Davies
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  */
 #include <stdarg.h>

 #include "windef.h"
 #include "winbase.h"
 #include "wingdi.h"
 #include "wine/wingdi16.h"
 #include "wine/winuser16.h"
 #include "wownt32.h"
 #include "psdrv.h"
 #include "wine/debug.h"
 #include "winspool.h"
 #include "heap.h"

 WINE_DEFAULT_DEBUG_CHANNEL(psdrv);

 static const char psbegindocument[] =
 "%%BeginDocument: Wine passthrough\n";

 /**********************************************************************
  *           ExtEscape  (WINEPS.@)
  */
 INT PSDRV_ExtEscape( PSDRV_PDEVICE *physDev, INT nEscape, INT cbInput, LPCVOID in_data,
                      INT cbOutput, LPVOID out_data )
 {
     switch(nEscape)
     {
     case QUERYESCSUPPORT:
         if(cbInput < sizeof(INT))
         {
 	    WARN("cbInput < sizeof(INT) (=%d) for QUERYESCSUPPORT\n", cbInput);
 	    return 0;
 	} else {
 	    UINT num = *(const UINT *)in_data;
 	    TRACE("QUERYESCSUPPORT for %d\n", num);

 	    switch(num) {
 	    case NEXTBAND:
 	    /*case BANDINFO:*/
 	    case SETCOPYCOUNT:
 	    case GETTECHNOLOGY:
 	    case SETLINECAP:
 	    case SETLINEJOIN:
 	    case SETMITERLIMIT:
 	    case SETCHARSET:
 	    case EXT_DEVICE_CAPS:
 	    case SET_BOUNDS:
             case EPSPRINTING:
 	    case POSTSCRIPT_DATA:
             case PASSTHROUGH:
             case POSTSCRIPT_PASSTHROUGH:
 	    case POSTSCRIPT_IGNORE:
 	    case BEGIN_PATH:
 	    case CLIP_TO_PATH:
 	    case END_PATH:
 	    /*case DRAWPATTERNRECT:*/
 	        return TRUE;

 	    default:
 		FIXME("QUERYESCSUPPORT(%d) - not supported.\n", num);
 	        return FALSE;
 	    }
 	}

     case MFCOMMENT:
     {
 	FIXME("MFCOMMENT(%p, %d)\n", in_data, cbInput);
 	return 1;
     }
     case DRAWPATTERNRECT:
     {
 	DRAWPATRECT	*dpr = (DRAWPATRECT*)in_data;

 	FIXME("DRAWPATTERNRECT(pos (%ld,%ld), size %ldx%ld, style %d, pattern %x), stub!\n",
 		dpr->ptPosition.x, dpr->ptPosition.y,
 		dpr->ptSize.x, dpr->ptSize.y,
 		dpr->wStyle, dpr->wPattern
 	);
 	return 1;
     }
     case BANDINFO:
     {
 	BANDINFOSTRUCT	*ibi = (BANDINFOSTRUCT*)in_data;
 	BANDINFOSTRUCT	*obi = (BANDINFOSTRUCT*)out_data;

 	FIXME("BANDINFO(graphics %d, text %d, rect [%ldx%ld-%ldx%ld]), stub!\n",
 		ibi->GraphicsFlag,
 		ibi->TextFlag,
 		ibi->GraphicsRect.top,
 		ibi->GraphicsRect.bottom,
 		ibi->GraphicsRect.left,
 		ibi->GraphicsRect.right
 	);
 	memcpy (obi, ibi, sizeof(*ibi));
 	return 1;
     }
     case NEXTBAND:
     {
         RECT *r = out_data;
 	if(!physDev->job.banding) {
 	    physDev->job.banding = TRUE;
             r->left   = 0;
             r->top    = 0;
             r->right  = physDev->horzRes;
             r->bottom = physDev->vertRes;
             TRACE("NEXTBAND returning %ld,%ld - %ld,%ld\n", r->left, r->top, r->right, r->bottom );
 	    return 1;
 	}
         r->left   = 0;
         r->top    = 0;
         r->right  = 0;
         r->bottom = 0;
 	TRACE("NEXTBAND rect to 0,0 - 0,0\n" );
 	physDev->job.banding = FALSE;
         return EndPage( physDev->hdc );
     }

     case SETCOPYCOUNT:
         {
             const INT *NumCopies = in_data;
             INT *ActualCopies = out_data;
             if(cbInput != sizeof(INT)) {
                 WARN("cbInput != sizeof(INT) (=%d) for SETCOPYCOUNT\n", cbInput);
 		return 0;
 	    }
 	    TRACE("SETCOPYCOUNT %d\n", *NumCopies);
 	    *ActualCopies = 1;
 	    return 1;
 	}

     case GETTECHNOLOGY:
         {
 	    LPSTR p = out_data;
 	    strcpy(p, "PostScript");
 	    *(p + strlen(p) + 1) = '\0'; /* 2 '\0's at end of string */
 	    return 1;
 	}

     case SETLINECAP:
         {
             INT newCap = *(const INT *)in_data;
             if(cbInput != sizeof(INT)) {
                 WARN("cbInput != sizeof(INT) (=%d) for SETLINECAP\n", cbInput);
 		return 0;
             }
 	    TRACE("SETLINECAP %d\n", newCap);
 	    return 0;
 	}

     case SETLINEJOIN:
         {
             INT newJoin = *(const INT *)in_data;
             if(cbInput != sizeof(INT)) {
                 WARN("cbInput != sizeof(INT) (=%d) for SETLINEJOIN\n", cbInput);
 		return 0;
             }
 	    TRACE("SETLINEJOIN %d\n", newJoin);
 	    return 0;
 	}

     case SETMITERLIMIT:
         {
             INT newLimit = *(const INT *)in_data;
             if(cbInput != sizeof(INT)) {
                 WARN("cbInput != sizeof(INT) (=%d) for SETMITERLIMIT\n", cbInput);
 		return 0;
             }
 	    TRACE("SETMITERLIMIT %d\n", newLimit);
 	    return 0;
 	}

     case SETCHARSET:
       /* Undocumented escape used by winword6.
 	 Switches between ANSI and a special charset.
 	 If *lpInData == 1 we require that
 	 0x91 is quoteleft
 	 0x92 is quoteright
 	 0x93 is quotedblleft
 	 0x94 is quotedblright
 	 0x95 is bullet
 	 0x96 is endash
 	 0x97 is emdash
 	 0xa0 is non break space - yeah right.

 	 If *lpInData == 0 we get ANSI.
 	 Since there's nothing else there, let's just make these the default
 	 anyway and see what happens...
       */
         return 1;

     case EXT_DEVICE_CAPS:
         {
             UINT cap = *(const UINT *)in_data;
             if(cbInput != sizeof(UINT)) {
                 WARN("cbInput != sizeof(UINT) (=%d) for EXT_DEVICE_CAPS\n", cbInput);
 		return 0;
             }
 	    TRACE("EXT_DEVICE_CAPS %d\n", cap);
 	    return 0;
 	}

     case SET_BOUNDS:
         {
             const RECT *r = in_data;
             if(cbInput != sizeof(RECT)) {
                 WARN("cbInput != sizeof(RECT) (=%d) for SET_BOUNDS\n", cbInput);
 		return 0;
             }
 	    TRACE("SET_BOUNDS (%ld,%ld) - (%ld,%ld)\n", r->left, r->top,
 		  r->right, r->bottom);
 	    return 0;
 	}

     case EPSPRINTING:
 	{
             UINT epsprint = *(const UINT*)in_data;
 	    /* FIXME: In this mode we do not need to send page intros and page
 	     * ends according to the doc. But I just ignore that detail
 	     * for now.
 	     */
 	    TRACE("EPS Printing support %sable.\n",epsprint?"en":"dis");
 	    return 1;
         }

     case POSTSCRIPT_DATA:
     case PASSTHROUGH:
     case POSTSCRIPT_PASSTHROUGH:
         {
             /* Write directly to spool file, bypassing normal PS driver
              * processing that is done along with writing PostScript code
              * to the spool.
 	     * We have a WORD before the data counting the size, but
 	     * cbInput is just this +2.
              * However Photoshop 7 has a bug that sets cbInput to 2 less than the
              * length of the string, rather than 2 more.  So we'll use the WORD at
              * in_data[0] instead.
              */
             if(!physDev->job.in_passthrough) {
                 WriteSpool16(physDev->job.hJob, (LPSTR)psbegindocument, sizeof(psbegindocument)-1);
                 physDev->job.in_passthrough = TRUE;
             }
             return WriteSpool16(physDev->job.hJob,((char*)in_data)+2,*(const WORD*)in_data);
         }

     case POSTSCRIPT_IGNORE:
       {
 	BOOL ret = physDev->job.quiet;
         TRACE("POSTSCRIPT_IGNORE %d\n", *(const short*)in_data);
 	physDev->job.quiet = *(const short*)in_data;
 	return ret;
       }

     case GETSETPRINTORIENT:
 	{
 	    /* If lpInData is present, it is a 20 byte structure, first 32
 	     * bit LONG value is the orientation. if lpInData is NULL, it
 	     * returns the current orientation.
 	     */
 	    FIXME("GETSETPRINTORIENT not implemented (data %p)!\n",in_data);
 	    return 1;
 	}
     case BEGIN_PATH:
         TRACE("BEGIN_PATH\n");
 	if(physDev->pathdepth)
 	    FIXME("Nested paths not yet handled\n");
 	return ++physDev->pathdepth;

     case END_PATH:
       {
 	const struct PATH_INFO *info = (const struct PATH_INFO*)in_data;

 	TRACE("END_PATH\n");
         if(!physDev->pathdepth) {
 	    ERR("END_PATH called without a BEIGN_PATH\n");
 	    return -1;
 	}
 	TRACE("RenderMode = %d, FillMode = %d, BkMode = %d\n",
 	      info->RenderMode, info->FillMode, info->BkMode);
 	switch(info->RenderMode) {
 	case RENDERMODE_NO_DISPLAY:
 	    PSDRV_WriteClosePath(physDev); /* not sure if this is necessary, but it can't hurt */
 	    break;
 	case RENDERMODE_OPEN:
 	case RENDERMODE_CLOSED:
 	default:
 	    FIXME("END_PATH: RenderMode %d, not yet supported\n", info->RenderMode);
 	    break;
 	}
 	return --physDev->pathdepth;
       }

     case CLIP_TO_PATH:
       {
 	WORD mode = *(const WORD*)in_data;

 	switch(mode) {
 	case CLIP_SAVE:
 	    TRACE("CLIP_TO_PATH: CLIP_SAVE\n");
 	    PSDRV_WriteGSave(physDev);
 	    return 1;
 	case CLIP_RESTORE:
 	    TRACE("CLIP_TO_PATH: CLIP_RESTORE\n");
 	    PSDRV_WriteGRestore(physDev);
 	    return 1;
 	case CLIP_INCLUSIVE:
 	    TRACE("CLIP_TO_PATH: CLIP_INCLUSIVE\n");
 	    /* FIXME to clip or eoclip ? (see PATH_INFO.FillMode) */
 	    PSDRV_WriteClip(physDev);
             PSDRV_WriteNewPath(physDev);
 	    return 1;
 	case CLIP_EXCLUSIVE:
 	    FIXME("CLIP_EXCLUSIVE: not implemented\n");
 	    return 0;
 	default:
 	    FIXME("Unknown CLIP_TO_PATH mode %d\n", mode);
 	    return 0;
 	}
       }
     default:
         FIXME("Unimplemented code 0x%x\n", nEscape);
 	return 0;
     }
 }

 /************************************************************************
  *           PSDRV_StartPage
  */
 INT PSDRV_StartPage( PSDRV_PDEVICE *physDev )
 {
     if(!physDev->job.OutOfPage) {
         FIXME("Already started a page?\n");
 	return 1;
     }

     if(physDev->job.PageNo++ == 0) {
         if(!PSDRV_WriteHeader( physDev, physDev->job.DocName ))
             return 0;
     }

     if(!PSDRV_WriteNewPage( physDev ))
         return 0;
     physDev->job.OutOfPage = FALSE;
     return 1;
 }


 /************************************************************************
  *           PSDRV_EndPage
  */
 INT PSDRV_EndPage( PSDRV_PDEVICE *physDev )
 {
     if(physDev->job.OutOfPage) {
         FIXME("Already ended a page?\n");
 	return 1;
     }
     if(!PSDRV_WriteEndPage( physDev ))
         return 0;
     PSDRV_EmptyDownloadList(physDev, FALSE);
     physDev->job.OutOfPage = TRUE;
     return 1;
 }


 /************************************************************************
  *           PSDRV_StartDocA
  */
 INT PSDRV_StartDocA( PSDRV_PDEVICE *physDev, const DOCINFOA *doc )
 {
     LPCSTR output = "LPT1:";
     BYTE buf[300];
     HANDLE hprn = INVALID_HANDLE_VALUE;
     PRINTER_INFO_5A *pi5 = (PRINTER_INFO_5A*)buf;
     DWORD needed;

     if(physDev->job.hJob) {
         FIXME("hJob != 0. Now what?\n");
 	return 0;
     }

     if(doc->lpszOutput)
         output = doc->lpszOutput;
     else if(physDev->job.output)
         output = physDev->job.output;
     else {
         if(OpenPrinterA(physDev->pi->FriendlyName, &hprn, NULL) &&
            GetPrinterA(hprn, 5, buf, sizeof(buf), &needed)) {
             output = pi5->pPortName;
         }
         if(hprn != INVALID_HANDLE_VALUE)
             ClosePrinter(hprn);
     }

     physDev->job.hJob = OpenJob16(output,  doc->lpszDocName, HDC_16(physDev->hdc) );
     if(!physDev->job.hJob) {
         WARN("OpenJob failed\n");
 	return 0;
     }
     physDev->job.banding = FALSE;
     physDev->job.OutOfPage = TRUE;
     physDev->job.PageNo = 0;
     physDev->job.quiet = FALSE;
     physDev->job.in_passthrough = FALSE;
     physDev->job.had_passthrough_rect = FALSE;
     if(doc->lpszDocName) {
         physDev->job.DocName = HeapAlloc(GetProcessHeap(), 0, strlen(doc->lpszDocName)+1);
         strcpy(physDev->job.DocName, doc->lpszDocName);
     } else
         physDev->job.DocName = NULL;

     return physDev->job.hJob;
 }

 /************************************************************************
  *           PSDRV_StartDoc
  */
 INT PSDRV_StartDoc( PSDRV_PDEVICE *physDev, const DOCINFOW *doc )
 {
     DOCINFOA docA;
     INT ret;

     docA.cbSize = doc->cbSize;
     docA.lpszDocName = doc->lpszDocName ?
       HEAP_strdupWtoA( GetProcessHeap(), 0, doc->lpszDocName ) : NULL;
     docA.lpszOutput = doc->lpszOutput ?
       HEAP_strdupWtoA( GetProcessHeap(), 0, doc->lpszOutput ) : NULL;
     docA.lpszDatatype = doc->lpszDatatype ?
       HEAP_strdupWtoA( GetProcessHeap(), 0, doc->lpszDatatype ) : NULL;
     docA.fwType = doc->fwType;

     ret = PSDRV_StartDocA(physDev, &docA);

     HeapFree( GetProcessHeap(), 0, (LPSTR)docA.lpszDocName );
     HeapFree( GetProcessHeap(), 0, (LPSTR)docA.lpszOutput );
     HeapFree( GetProcessHeap(), 0, (LPSTR)docA.lpszDatatype );

     return ret;
 }

 /************************************************************************
  *           PSDRV_EndDoc
  */
 INT PSDRV_EndDoc( PSDRV_PDEVICE *physDev )
 {
     INT ret = 1;
     if(!physDev->job.hJob) {
         FIXME("hJob == 0. Now what?\n");
 	return 0;
     }

     if(!physDev->job.OutOfPage) {
         WARN("Somebody forgot an EndPage\n");
 	PSDRV_EndPage( physDev );
     }
     PSDRV_WriteFooter( physDev );

     if( CloseJob16( physDev->job.hJob ) == SP_ERROR ) {
         WARN("CloseJob error\n");
 	ret = 0;
     }
     physDev->job.hJob = 0;
     HeapFree(GetProcessHeap(), 0, physDev->job.DocName);
     physDev->job.DocName = NULL;

     return ret;
 }
	/*
	* PostScript driver Escape function
	*
	* Copyright 1998 Huw D M Davies
	*
	* This library is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Lesser General Public
	* License as published by the Free Software Foundation; either
	* version 2.1 of the License, or (at your option) any later version.
	*
	* This library is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Lesser General Public License for more details.
	*
	* You should have received a copy of the GNU Lesser General Public
	* License along with this library; if not, write to the Free Software
	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
	*/
	#include <stdarg.h>

	#include "windef.h"
	#include "winbase.h"
	#include "wingdi.h"
	#include "wine/wingdi16.h"
	#include "wine/winuser16.h"
	#include "wownt32.h"
	#include "psdrv.h"
	#include "wine/debug.h"
	#include "winspool.h"
	#include "heap.h"

	WINE_DEFAULT_DEBUG_CHANNEL(psdrv);

	static const char psbegindocument[] =
	"%%BeginDocument: Wine passthrough\n";

	/**********************************************************************
	* ExtEscape (WINEPS.@)
	*/
	INT PSDRV_ExtEscape( PSDRV_PDEVICE *physDev, INT nEscape, INT cbInput, LPCVOID in_data,
	INT cbOutput, LPVOID out_data )
	{
	switch(nEscape)
	{
	case QUERYESCSUPPORT:
	if(cbInput < sizeof(INT))
	{
	WARN("cbInput < sizeof(INT) (=%d) for QUERYESCSUPPORT\n", cbInput);
	return 0;
	} else {
	UINT num = (const UINT )in_data;
	TRACE("QUERYESCSUPPORT for %d\n", num);

	switch(num) {
	case NEXTBAND:
	/case BANDINFO:/
	case SETCOPYCOUNT:
	case GETTECHNOLOGY:
	case SETLINECAP:
	case SETLINEJOIN:
	case SETMITERLIMIT:
	case SETCHARSET:
	case EXT_DEVICE_CAPS:
	case SET_BOUNDS:
	case EPSPRINTING:
	case POSTSCRIPT_DATA:
	case PASSTHROUGH:
	case POSTSCRIPT_PASSTHROUGH:
	case POSTSCRIPT_IGNORE:
	case BEGIN_PATH:
	case CLIP_TO_PATH:
	case END_PATH:
	/case DRAWPATTERNRECT:/
	return TRUE;

	default:
	FIXME("QUERYESCSUPPORT(%d) - not supported.\n", num);
	return FALSE;
	}
	}

	case MFCOMMENT:
	{
	FIXME("MFCOMMENT(%p, %d)\n", in_data, cbInput);
	return 1;
	}
	case DRAWPATTERNRECT:
	{
	DRAWPATRECT dpr = (DRAWPATRECT)in_data;

	FIXME("DRAWPATTERNRECT(pos (%ld,%ld), size %ldx%ld, style %d, pattern %x), stub!\n",
	dpr->ptPosition.x, dpr->ptPosition.y,
	dpr->ptSize.x, dpr->ptSize.y,
	dpr->wStyle, dpr->wPattern
	);
	return 1;
	}
	case BANDINFO:
	{
	BANDINFOSTRUCT ibi = (BANDINFOSTRUCT)in_data;
	BANDINFOSTRUCT obi = (BANDINFOSTRUCT)out_data;

	FIXME("BANDINFO(graphics %d, text %d, rect [%ldx%ld-%ldx%ld]), stub!\n",
	ibi->GraphicsFlag,
	ibi->TextFlag,
	ibi->GraphicsRect.top,
	ibi->GraphicsRect.bottom,
	ibi->GraphicsRect.left,
	ibi->GraphicsRect.right
	);
	memcpy (obi, ibi, sizeof(*ibi));
	return 1;
	}
	case NEXTBAND:
	{
	RECT *r = out_data;
	if(!physDev->job.banding) {
	physDev->job.banding = TRUE;
	r->left = 0;
	r->top = 0;
	r->right = physDev->horzRes;
	r->bottom = physDev->vertRes;
	TRACE("NEXTBAND returning %ld,%ld - %ld,%ld\n", r->left, r->top, r->right, r->bottom );
	return 1;
	}
	r->left = 0;
	r->top = 0;
	r->right = 0;
	r->bottom = 0;
	TRACE("NEXTBAND rect to 0,0 - 0,0\n" );
	physDev->job.banding = FALSE;
	return EndPage( physDev->hdc );
	}

	case SETCOPYCOUNT:
	{
	const INT *NumCopies = in_data;
	INT *ActualCopies = out_data;
	if(cbInput != sizeof(INT)) {
	WARN("cbInput != sizeof(INT) (=%d) for SETCOPYCOUNT\n", cbInput);
	return 0;
	}
	TRACE("SETCOPYCOUNT %d\n", *NumCopies);
	*ActualCopies = 1;
	return 1;
	}

	case GETTECHNOLOGY:
	{
	LPSTR p = out_data;
	strcpy(p, "PostScript");
	(p + strlen(p) + 1) = '\0'; / 2 '\0's at end of string */
	return 1;
	}

	case SETLINECAP:
	{
	INT newCap = (const INT )in_data;
	if(cbInput != sizeof(INT)) {
	WARN("cbInput != sizeof(INT) (=%d) for SETLINECAP\n", cbInput);
	return 0;
	}
	TRACE("SETLINECAP %d\n", newCap);
	return 0;
	}

	case SETLINEJOIN:
	{
	INT newJoin = (const INT )in_data;
	if(cbInput != sizeof(INT)) {
	WARN("cbInput != sizeof(INT) (=%d) for SETLINEJOIN\n", cbInput);
	return 0;
	}
	TRACE("SETLINEJOIN %d\n", newJoin);
	return 0;
	}

	case SETMITERLIMIT:
	{
	INT newLimit = (const INT )in_data;
	if(cbInput != sizeof(INT)) {
	WARN("cbInput != sizeof(INT) (=%d) for SETMITERLIMIT\n", cbInput);
	return 0;
	}
	TRACE("SETMITERLIMIT %d\n", newLimit);
	return 0;
	}

	case SETCHARSET:
	/* Undocumented escape used by winword6.
	Switches between ANSI and a special charset.
	If *lpInData == 1 we require that
	0x91 is quoteleft
	0x92 is quoteright
	0x93 is quotedblleft
	0x94 is quotedblright
	0x95 is bullet
	0x96 is endash
	0x97 is emdash
	0xa0 is non break space - yeah right.

	If *lpInData == 0 we get ANSI.
	Since there's nothing else there, let's just make these the default
	anyway and see what happens...
	*/
	return 1;

	case EXT_DEVICE_CAPS:
	{
	UINT cap = (const UINT )in_data;
	if(cbInput != sizeof(UINT)) {
	WARN("cbInput != sizeof(UINT) (=%d) for EXT_DEVICE_CAPS\n", cbInput);
	return 0;
	}
	TRACE("EXT_DEVICE_CAPS %d\n", cap);
	return 0;
	}

	case SET_BOUNDS:
	{
	const RECT *r = in_data;
	if(cbInput != sizeof(RECT)) {
	WARN("cbInput != sizeof(RECT) (=%d) for SET_BOUNDS\n", cbInput);
	return 0;
	}
	TRACE("SET_BOUNDS (%ld,%ld) - (%ld,%ld)\n", r->left, r->top,
	r->right, r->bottom);
	return 0;
	}

	case EPSPRINTING:
	{
	UINT epsprint = (const UINT)in_data;
	/* FIXME: In this mode we do not need to send page intros and page
	* ends according to the doc. But I just ignore that detail
	* for now.
	*/
	TRACE("EPS Printing support %sable.\n",epsprint?"en":"dis");
	return 1;
	}

	case POSTSCRIPT_DATA:
	case PASSTHROUGH:
	case POSTSCRIPT_PASSTHROUGH:
	{
	/* Write directly to spool file, bypassing normal PS driver
	* processing that is done along with writing PostScript code
	* to the spool.
	* We have a WORD before the data counting the size, but
	* cbInput is just this +2.
	* However Photoshop 7 has a bug that sets cbInput to 2 less than the
	* length of the string, rather than 2 more. So we'll use the WORD at
	* in_data[0] instead.
	*/
	if(!physDev->job.in_passthrough) {
	WriteSpool16(physDev->job.hJob, (LPSTR)psbegindocument, sizeof(psbegindocument)-1);
	physDev->job.in_passthrough = TRUE;
	}
	return WriteSpool16(physDev->job.hJob,((char)in_data)+2,(const WORD*)in_data);
	}

	case POSTSCRIPT_IGNORE:
	{
	BOOL ret = physDev->job.quiet;
	TRACE("POSTSCRIPT_IGNORE %d\n", (const short)in_data);
	physDev->job.quiet = (const short)in_data;
	return ret;
	}

	case GETSETPRINTORIENT:
	{
	/* If lpInData is present, it is a 20 byte structure, first 32
	* bit LONG value is the orientation. if lpInData is NULL, it
	* returns the current orientation.
	*/
	FIXME("GETSETPRINTORIENT not implemented (data %p)!\n",in_data);
	return 1;
	}
	case BEGIN_PATH:
	TRACE("BEGIN_PATH\n");
	if(physDev->pathdepth)
	FIXME("Nested paths not yet handled\n");
	return ++physDev->pathdepth;

	case END_PATH:
	{
	const struct PATH_INFO info = (const struct PATH_INFO)in_data;

	TRACE("END_PATH\n");
	if(!physDev->pathdepth) {
	ERR("END_PATH called without a BEIGN_PATH\n");
	return -1;
	}
	TRACE("RenderMode = %d, FillMode = %d, BkMode = %d\n",
	info->RenderMode, info->FillMode, info->BkMode);
	switch(info->RenderMode) {
	case RENDERMODE_NO_DISPLAY:
	PSDRV_WriteClosePath(physDev); /* not sure if this is necessary, but it can't hurt */
	break;
	case RENDERMODE_OPEN:
	case RENDERMODE_CLOSED:
	default:
	FIXME("END_PATH: RenderMode %d, not yet supported\n", info->RenderMode);
	break;
	}
	return --physDev->pathdepth;
	}

	case CLIP_TO_PATH:
	{
	WORD mode = (const WORD)in_data;

	switch(mode) {
	case CLIP_SAVE:
	TRACE("CLIP_TO_PATH: CLIP_SAVE\n");
	PSDRV_WriteGSave(physDev);
	return 1;
	case CLIP_RESTORE:
	TRACE("CLIP_TO_PATH: CLIP_RESTORE\n");
	PSDRV_WriteGRestore(physDev);
	return 1;
	case CLIP_INCLUSIVE:
	TRACE("CLIP_TO_PATH: CLIP_INCLUSIVE\n");
	/* FIXME to clip or eoclip ? (see PATH_INFO.FillMode) */
	PSDRV_WriteClip(physDev);
	PSDRV_WriteNewPath(physDev);
	return 1;
	case CLIP_EXCLUSIVE:
	FIXME("CLIP_EXCLUSIVE: not implemented\n");
	return 0;
	default:
	FIXME("Unknown CLIP_TO_PATH mode %d\n", mode);
	return 0;
	}
	}
	default:
	FIXME("Unimplemented code 0x%x\n", nEscape);
	return 0;
	}
	}

	/************************************************************************
	* PSDRV_StartPage
	*/
	INT PSDRV_StartPage( PSDRV_PDEVICE *physDev )
	{
	if(!physDev->job.OutOfPage) {
	FIXME("Already started a page?\n");
	return 1;
	}

	if(physDev->job.PageNo++ == 0) {
	if(!PSDRV_WriteHeader( physDev, physDev->job.DocName ))
	return 0;
	}

	if(!PSDRV_WriteNewPage( physDev ))
	return 0;
	physDev->job.OutOfPage = FALSE;
	return 1;
	}


	/************************************************************************
	* PSDRV_EndPage
	*/
	INT PSDRV_EndPage( PSDRV_PDEVICE *physDev )
	{
	if(physDev->job.OutOfPage) {
	FIXME("Already ended a page?\n");
	return 1;
	}
	if(!PSDRV_WriteEndPage( physDev ))
	return 0;
	PSDRV_EmptyDownloadList(physDev, FALSE);
	physDev->job.OutOfPage = TRUE;
	return 1;
	}


	/************************************************************************
	* PSDRV_StartDocA
	*/
	INT PSDRV_StartDocA( PSDRV_PDEVICE physDev, const DOCINFOA doc )
	{
	LPCSTR output = "LPT1:";
	BYTE buf[300];
	HANDLE hprn = INVALID_HANDLE_VALUE;
	PRINTER_INFO_5A pi5 = (PRINTER_INFO_5A)buf;
	DWORD needed;

	if(physDev->job.hJob) {
	FIXME("hJob != 0. Now what?\n");
	return 0;
	}

	if(doc->lpszOutput)
	output = doc->lpszOutput;
	else if(physDev->job.output)
	output = physDev->job.output;
	else {
	if(OpenPrinterA(physDev->pi->FriendlyName, &hprn, NULL) &&
	GetPrinterA(hprn, 5, buf, sizeof(buf), &needed)) {
	output = pi5->pPortName;
	}
	if(hprn != INVALID_HANDLE_VALUE)
	ClosePrinter(hprn);
	}

	physDev->job.hJob = OpenJob16(output, doc->lpszDocName, HDC_16(physDev->hdc) );
	if(!physDev->job.hJob) {
	WARN("OpenJob failed\n");
	return 0;
	}
	physDev->job.banding = FALSE;
	physDev->job.OutOfPage = TRUE;
	physDev->job.PageNo = 0;
	physDev->job.quiet = FALSE;
	physDev->job.in_passthrough = FALSE;
	physDev->job.had_passthrough_rect = FALSE;
	if(doc->lpszDocName) {
	physDev->job.DocName = HeapAlloc(GetProcessHeap(), 0, strlen(doc->lpszDocName)+1);
	strcpy(physDev->job.DocName, doc->lpszDocName);
	} else
	physDev->job.DocName = NULL;

	return physDev->job.hJob;
	}

	/************************************************************************
	* PSDRV_StartDoc
	*/
	INT PSDRV_StartDoc( PSDRV_PDEVICE physDev, const DOCINFOW doc )
	{
	DOCINFOA docA;
	INT ret;

	docA.cbSize = doc->cbSize;
	docA.lpszDocName = doc->lpszDocName ?
	HEAP_strdupWtoA( GetProcessHeap(), 0, doc->lpszDocName ) : NULL;
	docA.lpszOutput = doc->lpszOutput ?
	HEAP_strdupWtoA( GetProcessHeap(), 0, doc->lpszOutput ) : NULL;
	docA.lpszDatatype = doc->lpszDatatype ?
	HEAP_strdupWtoA( GetProcessHeap(), 0, doc->lpszDatatype ) : NULL;
	docA.fwType = doc->fwType;

	ret = PSDRV_StartDocA(physDev, &docA);

	HeapFree( GetProcessHeap(), 0, (LPSTR)docA.lpszDocName );
	HeapFree( GetProcessHeap(), 0, (LPSTR)docA.lpszOutput );
	HeapFree( GetProcessHeap(), 0, (LPSTR)docA.lpszDatatype );

	return ret;
	}

	/************************************************************************
	* PSDRV_EndDoc
	*/
	INT PSDRV_EndDoc( PSDRV_PDEVICE *physDev )
	{
	INT ret = 1;
	if(!physDev->job.hJob) {
	FIXME("hJob == 0. Now what?\n");
	return 0;
	}

	if(!physDev->job.OutOfPage) {
	WARN("Somebody forgot an EndPage\n");
	PSDRV_EndPage( physDev );
	}
	PSDRV_WriteFooter( physDev );

	if( CloseJob16( physDev->job.hJob ) == SP_ERROR ) {
	WARN("CloseJob error\n");
	ret = 0;
	}
	physDev->job.hJob = 0;
	HeapFree(GetProcessHeap(), 0, physDev->job.DocName);
	physDev->job.DocName = NULL;

	return ret;
	}