graphics/psdrv/escape.c

   1 /*
   2  *      PostScript driver Escape function
   3  *
   4  *      Copyright 1998  Huw D M Davies
   5  */
   6 #include "wine/winuser16.h"
   7 #include "psdrv.h"
   8 #include "debugtools.h"
   9 #include "winspool.h"
  10 #include "heap.h"
  11
  12 DEFAULT_DEBUG_CHANNEL(psdrv)
  13
  14
  15 INT PSDRV_Escape( DC *dc, INT nEscape, INT cbInput,
  16                   SEGPTR lpInData, SEGPTR lpOutData )
  17 {
  18     PSDRV_PDEVICE *physDev = (PSDRV_PDEVICE *)dc->physDev;
  19
  20     switch(nEscape) {
  21
  22     case NEXTBAND: {
  23         RECT16 *r = (RECT16 *)PTR_SEG_TO_LIN(lpOutData);
  24         if(!physDev->job.banding) {
  25             physDev->job.banding = TRUE;
  26             SetRect16( r, 0, 0, dc->w.devCaps->horzRes,
  27                                      dc->w.devCaps->vertRes );
  28             TRACE("NEXTBAND returning %d,%d - %d,%d\n", r->left,
  29                   r->top, r->right, r->bottom );
  30             return 1;
  31         }
  32         SetRect16( r, 0, 0, 0, 0 );
  33         TRACE("NEXTBAND rect to 0,0 - 0,0\n" );
  34         physDev->job.banding = FALSE;
  35     }   /* Fall through */
  36
  37     case NEWFRAME:
  38         TRACE("NEWFRAME\n");
  39
  40         if(!physDev->job.hJob) {
  41             FIXME("hJob == 0. Now what?\n");
  42             return SP_ERROR;
  43         }
  44
  45         if(!PSDRV_EndPage( dc ))
  46             return SP_ERROR;
  47         return 1;
  48
  49     case QUERYESCSUPPORT:
  50         if(cbInput < 2) {
  51             WARN("cbInput < 2 (=%d) for QUERYESCSUPPORT\n", cbInput);
  52             return 0;
  53         } else {
  54             UINT16 num = *(UINT16 *)PTR_SEG_TO_LIN(lpInData);
  55             TRACE("QUERYESCSUPPORT for %d\n", num);
  56
  57             switch(num) {
  58             case NEWFRAME:
  59             case NEXTBAND:
  60             case QUERYESCSUPPORT:
  61             case SETABORTPROC:
  62             case STARTDOC:
  63             case ENDDOC:
  64             case GETPHYSPAGESIZE:
  65             case GETPRINTINGOFFSET:
  66             case GETSCALINGFACTOR:
  67             case SETCOPYCOUNT:
  68             case GETTECHNOLOGY:
  69             case SETLINECAP:
  70             case SETLINEJOIN:
  71             case SETMITERLIMIT:
  72             case SETCHARSET:
  73             case EXT_DEVICE_CAPS:
  74             case SET_BOUNDS:
  75                 return TRUE;
  76
  77             default:
  78                 return FALSE;
  79             }
  80         }
  81
  82     case SETABORTPROC:
  83         TRACE("SETABORTPROC\n");
  84         return 1;
  85
  86     case STARTDOC:
  87       {
  88         DOCINFOA doc;
  89         char *name = NULL;
  90         INT16 ret;
  91
  92         TRACE("STARTDOC\n");
  93
  94         /* lpInData may not be 0 terminated so we must copy it */
  95         if(lpInData) {
  96             name = HeapAlloc( GetProcessHeap(), 0, cbInput+1 );
  97             memcpy(name, PTR_SEG_TO_LIN(lpInData), cbInput);
  98             name[cbInput] = '\0';
  99         }
 100         doc.cbSize = sizeof(doc);
 101         doc.lpszDocName = name;
 102         doc.lpszOutput = doc.lpszDatatype = NULL;
 103         doc.fwType = 0;
 104
 105         ret = PSDRV_StartDoc(dc, &doc);
 106         if(name) HeapFree( GetProcessHeap(), 0, name );
 107         if(ret <= 0) return -1;
 108         ret = PSDRV_StartPage(dc);
 109         if(ret <= 0) return -1;
 110         return ret;
 111       }
 112
 113     case ENDDOC:
 114         TRACE("ENDDOC\n");
 115         return PSDRV_EndDoc( dc );
 116
 117     case GETPHYSPAGESIZE:
 118         {
 119             POINT16 *p  = (POINT16 *)PTR_SEG_TO_LIN(lpOutData);
 120
 121             p->x = dc->w.devCaps->horzRes;
 122             p->y = dc->w.devCaps->vertRes;
 123             TRACE("GETPHYSPAGESIZE: returning %dx%d\n", p->x, p->y);
 124             return 1;
 125         }
 126
 127     case GETPRINTINGOFFSET:
 128         {
 129             POINT16 *p = (POINT16 *)PTR_SEG_TO_LIN(lpOutData);
 130
 131             p->x = p->y = 0;
 132             TRACE("GETPRINTINGOFFSET: returning %dx%d\n", p->x, p->y);
 133             return 1;
 134         }
 135
 136     case GETSCALINGFACTOR:
 137         {
 138             POINT16 *p = (POINT16 *)PTR_SEG_TO_LIN(lpOutData);
 139
 140             p->x = p->y = 0;
 141             TRACE("GETSCALINGFACTOR: returning %dx%d\n", p->x, p->y);
 142             return 1;
 143         }
 144
 145     case SETCOPYCOUNT:
 146         {
 147             INT16 *NumCopies = (INT16 *)PTR_SEG_TO_LIN(lpInData);
 148             INT16 *ActualCopies = (INT16 *)PTR_SEG_TO_LIN(lpOutData);
 149             if(cbInput != 2) {
 150                 WARN("cbInput != 2 (=%d) for SETCOPYCOUNT\n", cbInput);
 151                 return 0;
 152             }
 153             TRACE("SETCOPYCOUNT %d\n", *NumCopies);
 154             *ActualCopies = 1;
 155             return 1;
 156         }
 157
 158     case GETTECHNOLOGY:
 159         {
 160             LPSTR p = (LPSTR)PTR_SEG_TO_LIN(lpOutData);
 161             strcpy(p, "PostScript");
 162             *(p + strlen(p) + 1) = '\0'; /* 2 '\0's at end of string */
 163             return 1;
 164         }
 165
 166     case SETLINECAP:
 167         {
 168             INT16 newCap = *(INT16 *)PTR_SEG_TO_LIN(lpInData);
 169             if(cbInput != 2) {
 170                 WARN("cbInput != 2 (=%d) for SETLINECAP\n", cbInput);
 171                 return 0;
 172             }
 173             TRACE("SETLINECAP %d\n", newCap);
 174             return 0;
 175         }
 176
 177     case SETLINEJOIN:
 178         {
 179             INT16 newJoin = *(INT16 *)PTR_SEG_TO_LIN(lpInData);
 180             if(cbInput != 2) {
 181                 WARN("cbInput != 2 (=%d) for SETLINEJOIN\n", cbInput);
 182                 return 0;
 183             }
 184             TRACE("SETLINEJOIN %d\n", newJoin);
 185             return 0;
 186         }
 187
 188     case SETMITERLIMIT:
 189         {
 190             INT16 newLimit = *(INT16 *)PTR_SEG_TO_LIN(lpInData);
 191             if(cbInput != 2) {
 192                 WARN("cbInput != 2 (=%d) for SETMITERLIMIT\n", cbInput);
 193                 return 0;
 194             }
 195             TRACE("SETMITERLIMIT %d\n", newLimit);
 196             return 0;
 197         }
 198
 199     case SETCHARSET:
 200       /* Undocumented escape used by winword6.
 201          Switches between ANSI and a special charset.
 202          If *lpInData == 1 we require that
 203          0x91 is quoteleft
 204          0x92 is quoteright
 205          0x93 is quotedblleft
 206          0x94 is quotedblright
 207          0x95 is bullet
 208          0x96 is endash
 209          0x97 is emdash
 210          0xa0 is non break space - yeah right.
 211
 212          If *lpInData == 0 we get ANSI.
 213          Since there's nothing else there, let's just make these the default
 214          anyway and see what happens...
 215       */
 216         return 1;
 217
 218     case EXT_DEVICE_CAPS:
 219         {
 220             UINT16 cap = *(UINT16 *)PTR_SEG_TO_LIN(lpInData);
 221             if(cbInput != 2) {
 222                 WARN("cbInput != 2 (=%d) for EXT_DEVICE_CAPS\n",
 223                      cbInput);
 224                 return 0;
 225             }
 226             TRACE("EXT_DEVICE_CAPS %d\n", cap);
 227             return 0;
 228         }
 229
 230     case SET_BOUNDS:
 231         {
 232             RECT16 *r = (RECT16 *)PTR_SEG_TO_LIN(lpInData);
 233             if(cbInput != 8) {
 234                 WARN("cbInput != 8 (=%d) for SET_BOUNDS\n", cbInput);
 235                 return 0;
 236             }
 237             TRACE("SET_BOUNDS (%d,%d) - (%d,%d)\n", r->left, r->top,
 238                   r->right, r->bottom);
 239             return 0;
 240         }
 241
 242     default:
 243         FIXME("Unimplemented code 0x%x\n", nEscape);
 244         return 0;
 245     }
 246 }
 247
 248 /************************************************************************
 249  *           PSDRV_StartPage
 250  */
 251 INT PSDRV_StartPage( DC *dc )
 252 {
 253     PSDRV_PDEVICE *physDev = (PSDRV_PDEVICE *)dc->physDev;
 254
 255     if(!physDev->job.OutOfPage) {
 256         FIXME("Already started a page?\n");
 257         return 1;
 258     }
 259     physDev->job.PageNo++;
 260     if(!PSDRV_WriteNewPage( dc ))
 261         return 0;
 262     physDev->job.OutOfPage = FALSE;
 263     return 1;
 264 }
 265
 266
 267 /************************************************************************
 268  *           PSDRV_EndPage
 269  */
 270 INT PSDRV_EndPage( DC *dc )
 271 {
 272     PSDRV_PDEVICE *physDev = (PSDRV_PDEVICE *)dc->physDev;
 273
 274     if(physDev->job.OutOfPage) {
 275         FIXME("Already ended a page?\n");
 276         return 1;
 277     }
 278     if(!PSDRV_WriteEndPage( dc ))
 279         return 0;
 280     physDev->job.OutOfPage = TRUE;
 281     return 1;
 282 }
 283
 284
 285 /************************************************************************
 286  *           PSDRV_StartDoc
 287  */
 288 INT PSDRV_StartDoc( DC *dc, const DOCINFOA *doc )
 289 {
 290     PSDRV_PDEVICE *physDev = (PSDRV_PDEVICE *)dc->physDev;
 291
 292     if(physDev->job.hJob) {
 293         FIXME("hJob != 0. Now what?\n");
 294         return 0;
 295     }
 296
 297     if(doc->lpszOutput) {
 298         HeapFree( PSDRV_Heap, 0, physDev->job.output );
 299         physDev->job.output = HEAP_strdupA( PSDRV_Heap, 0, doc->lpszOutput );
 300     }
 301     physDev->job.hJob = OpenJob16(physDev->job.output,  doc->lpszDocName,
 302                                   dc->hSelf);
 303     if(!physDev->job.hJob) {
 304         WARN("OpenJob failed\n");
 305         return 0;
 306     }
 307     physDev->job.banding = FALSE;
 308     physDev->job.OutOfPage = TRUE;
 309     physDev->job.PageNo = 0;
 310     if(!PSDRV_WriteHeader( dc, doc->lpszDocName ))
 311         return 0;
 312
 313     return physDev->job.hJob;
 314 }
 315
 316
 317 /************************************************************************
 318  *           PSDRV_EndDoc
 319  */
 320 INT PSDRV_EndDoc( DC *dc )
 321 {
 322     PSDRV_PDEVICE *physDev = (PSDRV_PDEVICE *)dc->physDev;
 323
 324     if(!physDev->job.hJob) {
 325         FIXME("hJob == 0. Now what?\n");
 326         return 0;
 327     }
 328
 329     if(!physDev->job.OutOfPage) {
 330         WARN("Somebody forgot a EndPage\n");
 331         PSDRV_EndPage( dc );
 332     }
 333     if(!PSDRV_WriteFooter( dc ))
 334         return 0;
 335
 336     if( CloseJob16( physDev->job.hJob ) == SP_ERROR ) {
 337         WARN("CloseJob error\n");
 338         return 0;
 339     }
 340     physDev->job.hJob = 0;
 341     return 1;
 342 }