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