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 "debug.h"
   9 #include "winspool.h"
  10
  11
  12 INT PSDRV_Escape( DC *dc, INT nEscape, INT cbInput,
  13                               SEGPTR lpInData, SEGPTR lpOutData )
  14 {
  15     PSDRV_PDEVICE *physDev = (PSDRV_PDEVICE *)dc->physDev;
  16
  17     switch(nEscape) {
  18
  19     case NEXTBAND: {
  20         RECT16 *r = (RECT16 *)PTR_SEG_TO_LIN(lpOutData);
  21         if(!physDev->job.banding) {
  22             physDev->job.banding = TRUE;
  23             SetRect16( r, 0, 0, dc->w.devCaps->horzRes,
  24                                      dc->w.devCaps->vertRes );
  25             TRACE(psdrv, "NEXTBAND returning %d,%d - %d,%d\n", r->left,
  26                   r->top, r->right, r->bottom );
  27             return 1;
  28         }
  29         SetRect16( r, 0, 0, 0, 0 );
  30         TRACE(psdrv, "NEXTBAND rect to 0,0 - 0,0\n" );
  31         physDev->job.banding = FALSE;
  32     }   /* Fall through */
  33
  34     case NEWFRAME:
  35         TRACE(psdrv, "NEWFRAME\n");
  36
  37         if(!physDev->job.hJob) {
  38             FIXME(psdrv, "hJob == 0. Now what?\n");
  39             return 0;
  40         }
  41
  42         if(!PSDRV_WriteEndPage( dc ))
  43             return 0;
  44
  45         physDev->job.NeedPageHeader = TRUE;
  46         return 1;
  47
  48     case QUERYESCSUPPORT:
  49         if(cbInput != 2) {
  50             WARN(psdrv, "cbInput != 2 (=%d) for QUERYESCSUPPORT\n", cbInput);
  51             return 0;
  52         } else {
  53             UINT16 num = *(UINT16 *)PTR_SEG_TO_LIN(lpInData);
  54             TRACE(psdrv, "QUERYESCSUPPORT for %d\n", num);
  55
  56             switch(num) {
  57             case NEWFRAME:
  58             case NEXTBAND:
  59             case QUERYESCSUPPORT:
  60             case SETABORTPROC:
  61             case STARTDOC:
  62             case ENDDOC:
  63             case GETPHYSPAGESIZE:
  64             case GETPRINTINGOFFSET:
  65             case GETSCALINGFACTOR:
  66             case SETCOPYCOUNT:
  67             case GETTECHNOLOGY:
  68             case SETLINECAP:
  69             case SETLINEJOIN:
  70             case SETMITERLIMIT:
  71             case SETCHARSET:
  72             case EXT_DEVICE_CAPS:
  73             case SET_BOUNDS:
  74                 return TRUE;
  75
  76             default:
  77                 return FALSE;
  78             }
  79         }
  80
  81     case SETABORTPROC:
  82         FIXME(psdrv, "SETABORTPROC: Ignoring\n");
  83
  84 /*      dc->w.lpfnPrint = (FARPROC16)lpInData;
  85  */
  86         return 1;
  87
  88     case STARTDOC:
  89         TRACE(psdrv, "STARTDOC\n");
  90         if(physDev->job.hJob) {
  91             FIXME(psdrv, "hJob != 0. Now what?\n");
  92             return 0;
  93         }
  94
  95         physDev->job.hJob = OpenJob16(physDev->job.output,
  96                                     PTR_SEG_TO_LIN(lpInData), dc->hSelf);
  97         if(!physDev->job.hJob) {
  98             WARN(psdrv, "OpenJob failed\n");
  99             return 0;
 100         }
 101         physDev->job.banding = FALSE;
 102         physDev->job.NeedPageHeader = FALSE;
 103         physDev->job.PageNo = 1;
 104         if(!PSDRV_WriteHeader( dc, PTR_SEG_TO_LIN(lpInData), cbInput ))
 105             return 0;
 106
 107         if(!PSDRV_WriteNewPage( dc ))
 108             return 0;
 109         return 1;
 110
 111     case ENDDOC:
 112         TRACE(psdrv, "ENDDOC\n");
 113         if(!physDev->job.hJob) {
 114             FIXME(psdrv, "hJob == 0. Now what?\n");
 115             return 0;
 116         }
 117
 118         physDev->job.NeedPageHeader = FALSE;
 119
 120         if(!PSDRV_WriteFooter( dc ))
 121             return 0;
 122
 123         if( CloseJob16( physDev->job.hJob ) == SP_ERROR ) {
 124             WARN(psdrv, "CloseJob error\n");
 125             return 0;
 126         }
 127         physDev->job.hJob = 0;
 128         return 1;
 129
 130     case GETPHYSPAGESIZE:
 131         {
 132             POINT16 *p  = (POINT16 *)PTR_SEG_TO_LIN(lpOutData);
 133
 134             p->x = dc->w.devCaps->horzRes;
 135             p->y = dc->w.devCaps->vertRes;
 136             TRACE(psdrv, "GETPHYSPAGESIZE: returning %dx%d\n", p->x, p->y);
 137             return 1;
 138         }
 139
 140     case GETPRINTINGOFFSET:
 141         {
 142             POINT16 *p = (POINT16 *)PTR_SEG_TO_LIN(lpOutData);
 143
 144             p->x = p->y = 0;
 145             TRACE(psdrv, "GETPRINTINGOFFSET: returning %dx%d\n", p->x, p->y);
 146             return 1;
 147         }
 148
 149     case GETSCALINGFACTOR:
 150         {
 151             POINT16 *p = (POINT16 *)PTR_SEG_TO_LIN(lpOutData);
 152
 153             p->x = p->y = 0;
 154             TRACE(psdrv, "GETSCALINGFACTOR: returning %dx%d\n", p->x, p->y);
 155             return 1;
 156         }
 157
 158     case SETCOPYCOUNT:
 159         {
 160             INT16 *NumCopies = (INT16 *)PTR_SEG_TO_LIN(lpInData);
 161             INT16 *ActualCopies = (INT16 *)PTR_SEG_TO_LIN(lpOutData);
 162             if(cbInput != 2) {
 163                 WARN(psdrv, "cbInput != 2 (=%d) for SETCOPYCOUNT\n", cbInput);
 164                 return 0;
 165             }
 166             TRACE(psdrv, "SETCOPYCOUNT %d\n", *NumCopies);
 167             *ActualCopies = 1;
 168             return 1;
 169         }
 170
 171     case GETTECHNOLOGY:
 172         {
 173             LPSTR p = (LPSTR)PTR_SEG_TO_LIN(lpOutData);
 174             strcpy(p, "PostScript");
 175             *(p + strlen(p) + 1) = '\0'; /* 2 '\0's at end of string */
 176             return 1;
 177         }
 178
 179     case SETLINECAP:
 180         {
 181             INT16 newCap = *(INT16 *)PTR_SEG_TO_LIN(lpInData);
 182             if(cbInput != 2) {
 183                 WARN(psdrv, "cbInput != 2 (=%d) for SETLINECAP\n", cbInput);
 184                 return 0;
 185             }
 186             TRACE(psdrv, "SETLINECAP %d\n", newCap);
 187             return 0;
 188         }
 189
 190     case SETLINEJOIN:
 191         {
 192             INT16 newJoin = *(INT16 *)PTR_SEG_TO_LIN(lpInData);
 193             if(cbInput != 2) {
 194                 WARN(psdrv, "cbInput != 2 (=%d) for SETLINEJOIN\n", cbInput);
 195                 return 0;
 196             }
 197             TRACE(psdrv, "SETLINEJOIN %d\n", newJoin);
 198             return 0;
 199         }
 200
 201     case SETMITERLIMIT:
 202         {
 203             INT16 newLimit = *(INT16 *)PTR_SEG_TO_LIN(lpInData);
 204             if(cbInput != 2) {
 205                 WARN(psdrv, "cbInput != 2 (=%d) for SETMITERLIMIT\n", cbInput);
 206                 return 0;
 207             }
 208             TRACE(psdrv, "SETMITERLIMIT %d\n", newLimit);
 209             return 0;
 210         }
 211
 212     case SETCHARSET:
 213       /* Undocumented escape used by winword6.
 214          Switches between ANSI and a special charset.
 215          If *lpInData == 1 we require that
 216          0x91 is quoteleft
 217          0x92 is quoteright
 218          0x93 is quotedblleft
 219          0x94 is quotedblright
 220          0x95 is bullet
 221          0x96 is endash
 222          0x97 is emdash
 223          0xa0 is non break space - yeah right.
 224
 225          If *lpInData == 0 we get ANSI.
 226          Since there's nothing else there, let's just make these the default
 227          anyway and see what happens...
 228       */
 229         return 1;
 230
 231     case EXT_DEVICE_CAPS:
 232         {
 233             UINT16 cap = *(UINT16 *)PTR_SEG_TO_LIN(lpInData);
 234             if(cbInput != 2) {
 235                 WARN(psdrv, "cbInput != 2 (=%d) for EXT_DEVICE_CAPS\n",
 236                      cbInput);
 237                 return 0;
 238             }
 239             TRACE(psdrv, "EXT_DEVICE_CAPS %d\n", cap);
 240             return 0;
 241         }
 242
 243     case SET_BOUNDS:
 244         {
 245             RECT16 *r = (RECT16 *)PTR_SEG_TO_LIN(lpInData);
 246             if(cbInput != 8) {
 247                 WARN(psdrv, "cbInput != 8 (=%d) for SET_BOUNDS\n", cbInput);
 248                 return 0;
 249             }
 250             TRACE(psdrv, "SET_BOUNDS (%d,%d) - (%d,%d)\n", r->left, r->top,
 251                   r->right, r->bottom);
 252             return 0;
 253         }
 254
 255     default:
 256         FIXME(psdrv, "Unimplemented code 0x%x\n", nEscape);
 257         return 0;
 258     }
 259 }