git.oblomov.eu Git - wine/blob - dlls/wineps/escape.c

   1 /*
   2  *      PostScript driver Escape function
   3  *
   4  *      Copyright 1998  Huw D M Davies
   5  */
   6 #include "windef.h"
   7 #include "wingdi.h"
   8 #include "wine/winuser16.h"
   9 #include "psdrv.h"
  10 #include "debugtools.h"
  11 #include "winspool.h"
  12 #include "heap.h"
  13
  14 DEFAULT_DEBUG_CHANNEL(psdrv);
  15
  16
  17 INT PSDRV_Escape( DC *dc, INT nEscape, INT cbInput,
  18                   SEGPTR lpInData, SEGPTR lpOutData )
  19 {
  20     PSDRV_PDEVICE *physDev = (PSDRV_PDEVICE *)dc->physDev;
  21
  22     switch(nEscape) {
  23
  24     case NEXTBAND: {
  25         RECT16 *r = MapSL(lpOutData);
  26         if(!physDev->job.banding) {
  27             physDev->job.banding = TRUE;
  28             r->left   = 0;
  29             r->top    = 0;
  30             r->right  = dc->devCaps->horzRes;
  31             r->bottom = dc->devCaps->vertRes;
  32             TRACE("NEXTBAND returning %d,%d - %d,%d\n", r->left,
  33                   r->top, r->right, r->bottom );
  34             return 1;
  35         }
  36         r->left   = 0;
  37         r->top    = 0;
  38         r->right  = 0;
  39         r->bottom = 0;
  40         TRACE("NEXTBAND rect to 0,0 - 0,0\n" );
  41         physDev->job.banding = FALSE;
  42     }   /* Fall through */
  43
  44     case NEWFRAME:
  45         TRACE("NEWFRAME\n");
  46
  47         if(!physDev->job.hJob) {
  48             FIXME("hJob == 0. Now what?\n");
  49             return SP_ERROR;
  50         }
  51
  52         if(!PSDRV_EndPage( dc ))
  53             return SP_ERROR;
  54         return 1;
  55
  56     case QUERYESCSUPPORT:
  57         if(cbInput < 2) {
  58             WARN("cbInput < 2 (=%d) for QUERYESCSUPPORT\n", cbInput);
  59             return 0;
  60         } else {
  61             UINT16 num = *(UINT16 *)MapSL(lpInData);
  62             TRACE("QUERYESCSUPPORT for %d\n", num);
  63
  64             switch(num) {
  65             case NEWFRAME:
  66             case NEXTBAND:
  67             case QUERYESCSUPPORT:
  68             case SETABORTPROC:
  69             case STARTDOC:
  70             case ENDDOC:
  71             case GETPHYSPAGESIZE:
  72             case GETPRINTINGOFFSET:
  73             case GETSCALINGFACTOR:
  74             case SETCOPYCOUNT:
  75             case GETTECHNOLOGY:
  76             case SETLINECAP:
  77             case SETLINEJOIN:
  78             case SETMITERLIMIT:
  79             case SETCHARSET:
  80             case EXT_DEVICE_CAPS:
  81             case SET_BOUNDS:
  82             case EPSPRINTING:
  83             case PASSTHROUGH:
  84             case POSTSCRIPT_PASSTHROUGH:
  85                 return TRUE;
  86
  87             default:
  88                 return FALSE;
  89             }
  90         }
  91
  92     case SETABORTPROC:
  93         TRACE("SETABORTPROC\n");
  94         return 1;
  95
  96     case STARTDOC:
  97       {
  98         DOCINFOA doc;
  99         char *name = NULL;
 100         INT16 ret;
 101
 102         TRACE("STARTDOC\n");
 103
 104         /* lpInData may not be 0 terminated so we must copy it */
 105         if(lpInData) {
 106             name = HeapAlloc( GetProcessHeap(), 0, cbInput+1 );
 107             memcpy(name, MapSL(lpInData), cbInput);
 108             name[cbInput] = '\0';
 109         }
 110         doc.cbSize = sizeof(doc);
 111         doc.lpszDocName = name;
 112         doc.lpszOutput = doc.lpszDatatype = NULL;
 113         doc.fwType = 0;
 114
 115         ret = PSDRV_StartDoc(dc, &doc);
 116         if(name) HeapFree( GetProcessHeap(), 0, name );
 117         if(ret <= 0) return -1;
 118         ret = PSDRV_StartPage(dc);
 119         if(ret <= 0) return -1;
 120         return ret;
 121       }
 122
 123     case ENDDOC:
 124         TRACE("ENDDOC\n");
 125         return PSDRV_EndDoc( dc );
 126
 127     case GETPHYSPAGESIZE:
 128         {
 129             PSDRV_PDEVICE   *pdev = (PSDRV_PDEVICE *)(dc->physDev);
 130             POINT16         *p = MapSL(lpOutData);
 131
 132             p->x = p->y = 0;
 133
 134             if ((pdev->Devmode->dmPublic.dmFields & DM_PAPERSIZE) != 0 &&
 135                     pdev->Devmode->dmPublic.u1.s1.dmPaperSize != 0)
 136             {
 137                 PAGESIZE    *page = pdev->pi->ppd->PageSizes;
 138
 139                 while (page != NULL)
 140                 {
 141                     if (page->WinPage ==
 142                             pdev->Devmode->dmPublic.u1.s1.dmPaperSize)
 143                         break;
 144                     page = page->next;
 145                 }
 146
 147                 if (page == NULL)
 148                 {
 149                     ERR("No entry for papersize %u in PPD file for '%s'\n",
 150                             pdev->Devmode->dmPublic.u1.s1.dmPaperSize,
 151                             pdev->pi->FriendlyName);
 152                     return 0;
 153                 }
 154
 155                 TRACE("Found '%s' for paper size %u\n", page->FullName,
 156                         pdev->Devmode->dmPublic.u1.s1.dmPaperSize);
 157
 158                 p->x = page->PaperDimension->x * dc->devCaps->logPixelsX / 72;
 159                 p->y = page->PaperDimension->y * dc->devCaps->logPixelsY / 72;
 160
 161                 TRACE("%fx%f PostScript points = %ix%i device units\n",
 162                         page->PaperDimension->x, page->PaperDimension->y,
 163                         p->x, p->y);
 164             }
 165
 166             /* These are in tenths of a millimeter */
 167
 168             if ((pdev->Devmode->dmPublic.dmFields & DM_PAPERWIDTH) != 0 &&
 169                     pdev->Devmode->dmPublic.u1.s1.dmPaperWidth != 0)
 170             {
 171                 p->x = (pdev->Devmode->dmPublic.u1.s1.dmPaperWidth *
 172                         dc->devCaps->logPixelsX) / 254;
 173                 TRACE("dmPaperWidth = %i device units\n", p->x);
 174             }
 175
 176             if ((pdev->Devmode->dmPublic.dmFields & DM_PAPERLENGTH) != 0 &&
 177                     pdev->Devmode->dmPublic.u1.s1.dmPaperLength != 0)
 178             {
 179                 p->y = (pdev->Devmode->dmPublic.u1.s1.dmPaperLength *
 180                         dc->devCaps->logPixelsY) / 254;
 181                 TRACE("dmPaperLength = %i device units\n", p->y);
 182             }
 183
 184             if (p->x == 0 || p->y == 0)
 185             {
 186                 ERR("Paper size not properly set for '%s'\n",
 187                         pdev->pi->FriendlyName);
 188                 return 0;
 189             }
 190
 191             if ((pdev->Devmode->dmPublic.dmFields & DM_ORIENTATION) != 0 &&
 192                     pdev->Devmode->dmPublic.u1.s1.dmOrientation ==
 193                     DMORIENT_LANDSCAPE)
 194             {
 195                 register INT16  temp = p->y;
 196                 p->y = p->x;
 197                 p->x = temp;
 198             }
 199
 200             return 1;
 201         }
 202
 203     case GETPRINTINGOFFSET:
 204         {
 205             POINT16 *p = MapSL(lpOutData);
 206
 207             p->x = p->y = 0;
 208             TRACE("GETPRINTINGOFFSET: returning %dx%d\n", p->x, p->y);
 209             return 1;
 210         }
 211
 212     case GETSCALINGFACTOR:
 213         {
 214             POINT16 *p = MapSL(lpOutData);
 215
 216             p->x = p->y = 0;
 217             TRACE("GETSCALINGFACTOR: returning %dx%d\n", p->x, p->y);
 218             return 1;
 219         }
 220
 221     case SETCOPYCOUNT:
 222         {
 223             INT16 *NumCopies = MapSL(lpInData);
 224             INT16 *ActualCopies = MapSL(lpOutData);
 225             if(cbInput != 2) {
 226                 WARN("cbInput != 2 (=%d) for SETCOPYCOUNT\n", cbInput);
 227                 return 0;
 228             }
 229             TRACE("SETCOPYCOUNT %d\n", *NumCopies);
 230             *ActualCopies = 1;
 231             return 1;
 232         }
 233
 234     case GETTECHNOLOGY:
 235         {
 236             LPSTR p = MapSL(lpOutData);
 237             strcpy(p, "PostScript");
 238             *(p + strlen(p) + 1) = '\0'; /* 2 '\0's at end of string */
 239             return 1;
 240         }
 241
 242     case SETLINECAP:
 243         {
 244             INT16 newCap = *(INT16 *)MapSL(lpInData);
 245             if(cbInput != 2) {
 246                 WARN("cbInput != 2 (=%d) for SETLINECAP\n", cbInput);
 247                 return 0;
 248             }
 249             TRACE("SETLINECAP %d\n", newCap);
 250             return 0;
 251         }
 252
 253     case SETLINEJOIN:
 254         {
 255             INT16 newJoin = *(INT16 *)MapSL(lpInData);
 256             if(cbInput != 2) {
 257                 WARN("cbInput != 2 (=%d) for SETLINEJOIN\n", cbInput);
 258                 return 0;
 259             }
 260             TRACE("SETLINEJOIN %d\n", newJoin);
 261             return 0;
 262         }
 263
 264     case SETMITERLIMIT:
 265         {
 266             INT16 newLimit = *(INT16 *)MapSL(lpInData);
 267             if(cbInput != 2) {
 268                 WARN("cbInput != 2 (=%d) for SETMITERLIMIT\n", cbInput);
 269                 return 0;
 270             }
 271             TRACE("SETMITERLIMIT %d\n", newLimit);
 272             return 0;
 273         }
 274
 275     case SETCHARSET:
 276       /* Undocumented escape used by winword6.
 277          Switches between ANSI and a special charset.
 278          If *lpInData == 1 we require that
 279          0x91 is quoteleft
 280          0x92 is quoteright
 281          0x93 is quotedblleft
 282          0x94 is quotedblright
 283          0x95 is bullet
 284          0x96 is endash
 285          0x97 is emdash
 286          0xa0 is non break space - yeah right.
 287
 288          If *lpInData == 0 we get ANSI.
 289          Since there's nothing else there, let's just make these the default
 290          anyway and see what happens...
 291       */
 292         return 1;
 293
 294     case EXT_DEVICE_CAPS:
 295         {
 296             UINT16 cap = *(UINT16 *)MapSL(lpInData);
 297             if(cbInput != 2) {
 298                 WARN("cbInput != 2 (=%d) for EXT_DEVICE_CAPS\n",
 299                      cbInput);
 300                 return 0;
 301             }
 302             TRACE("EXT_DEVICE_CAPS %d\n", cap);
 303             return 0;
 304         }
 305
 306     case SET_BOUNDS:
 307         {
 308             RECT16 *r = MapSL(lpInData);
 309             if(cbInput != 8) {
 310                 WARN("cbInput != 8 (=%d) for SET_BOUNDS\n", cbInput);
 311                 return 0;
 312             }
 313             TRACE("SET_BOUNDS (%d,%d) - (%d,%d)\n", r->left, r->top,
 314                   r->right, r->bottom);
 315             return 0;
 316         }
 317
 318     case EPSPRINTING:
 319         {
 320             UINT16      epsprint = *(UINT16*)MapSL(lpInData);
 321             /* FIXME: In this mode we do not need to send page intros and page
 322              * ends according to the doc. But I just ignore that detail
 323              * for now.
 324              */
 325             TRACE("EPS Printing support %sable.\n",epsprint?"en":"dis");
 326             return 1;
 327         }
 328     case PASSTHROUGH:
 329     case POSTSCRIPT_PASSTHROUGH:
 330         {
 331             /* Write directly to spool file, bypassing normal PS driver
 332              * processing that is done along with writing PostScript code
 333              * to the spool.
 334              * (Usually we have a WORD before the data counting the size, but
 335              * cbInput is just this +2.)
 336              */
 337             return WriteSpool16(physDev->job.hJob,((char*)lpInData)+2,cbInput-2);
 338         }
 339
 340     case GETSETPRINTORIENT:
 341         {
 342             /* If lpInData is present, it is a 20 byte structure, first 32
 343              * bit LONG value is the orientation. if lpInData is NULL, it
 344              * returns the current orientation.
 345              */
 346             FIXME("GETSETPRINTORIENT not implemented (lpInData %ld)!\n",lpInData);
 347             return 1;
 348         }
 349     default:
 350         FIXME("Unimplemented code 0x%x\n", nEscape);
 351         return 0;
 352     }
 353 }
 354
 355 /************************************************************************
 356  *           PSDRV_StartPage
 357  */
 358 INT PSDRV_StartPage( DC *dc )
 359 {
 360     PSDRV_PDEVICE *physDev = (PSDRV_PDEVICE *)dc->physDev;
 361
 362     if(!physDev->job.OutOfPage) {
 363         FIXME("Already started a page?\n");
 364         return 1;
 365     }
 366     physDev->job.PageNo++;
 367     if(!PSDRV_WriteNewPage( dc ))
 368         return 0;
 369     physDev->job.OutOfPage = FALSE;
 370     return 1;
 371 }
 372
 373
 374 /************************************************************************
 375  *           PSDRV_EndPage
 376  */
 377 INT PSDRV_EndPage( DC *dc )
 378 {
 379     PSDRV_PDEVICE *physDev = (PSDRV_PDEVICE *)dc->physDev;
 380
 381     if(physDev->job.OutOfPage) {
 382         FIXME("Already ended a page?\n");
 383         return 1;
 384     }
 385     if(!PSDRV_WriteEndPage( dc ))
 386         return 0;
 387     physDev->job.OutOfPage = TRUE;
 388     return 1;
 389 }
 390
 391
 392 /************************************************************************
 393  *           PSDRV_StartDoc
 394  */
 395 INT PSDRV_StartDoc( DC *dc, const DOCINFOA *doc )
 396 {
 397     PSDRV_PDEVICE *physDev = (PSDRV_PDEVICE *)dc->physDev;
 398
 399     if(physDev->job.hJob) {
 400         FIXME("hJob != 0. Now what?\n");
 401         return 0;
 402     }
 403
 404     if(doc->lpszOutput) {
 405         HeapFree( PSDRV_Heap, 0, physDev->job.output );
 406         physDev->job.output = HEAP_strdupA( PSDRV_Heap, 0, doc->lpszOutput );
 407     }
 408     physDev->job.hJob = OpenJob16(physDev->job.output,  doc->lpszDocName,
 409                                   dc->hSelf);
 410     if(!physDev->job.hJob) {
 411         WARN("OpenJob failed\n");
 412         return 0;
 413     }
 414     physDev->job.banding = FALSE;
 415     physDev->job.OutOfPage = TRUE;
 416     physDev->job.PageNo = 0;
 417     if(!PSDRV_WriteHeader( dc, doc->lpszDocName ))
 418         return 0;
 419
 420     return physDev->job.hJob;
 421 }
 422
 423
 424 /************************************************************************
 425  *           PSDRV_EndDoc
 426  */
 427 INT PSDRV_EndDoc( DC *dc )
 428 {
 429     PSDRV_PDEVICE *physDev = (PSDRV_PDEVICE *)dc->physDev;
 430
 431     if(!physDev->job.hJob) {
 432         FIXME("hJob == 0. Now what?\n");
 433         return 0;
 434     }
 435
 436     if(!physDev->job.OutOfPage) {
 437         WARN("Somebody forgot a EndPage\n");
 438         PSDRV_EndPage( dc );
 439     }
 440     if(!PSDRV_WriteFooter( dc ))
 441         return 0;
 442
 443     if( CloseJob16( physDev->job.hJob ) == SP_ERROR ) {
 444         WARN("CloseJob error\n");
 445         return 0;
 446     }
 447     physDev->job.hJob = 0;
 448     return 1;
 449 }