graphics/escape.c

   1 /*
   2  * Escape() function.
   3  *
   4  * Copyright 1994  Bob Amstadt
   5  */
   6
   7 #include <string.h>
   8 #include "wingdi.h"
   9 #include "gdi.h"
  10 #include "heap.h"
  11 #include "ldt.h"
  12 #include "dc.h"
  13 #include "debugtools.h"
  14
  15 DEFAULT_DEBUG_CHANNEL(driver)
  16
  17 /***********************************************************************
  18  *            Escape16  [GDI.38]
  19  */
  20 INT16 WINAPI Escape16( HDC16 hdc, INT16 nEscape, INT16 cbInput,
  21                        SEGPTR lpszInData, SEGPTR lpvOutData )
  22 {
  23     DC * dc = DC_GetDCPtr( hdc );
  24     if (!dc || !dc->funcs->pEscape) return 0;
  25     if(nEscape == SETABORTPROC) SetAbortProc16(hdc, lpszInData);
  26     return dc->funcs->pEscape( dc, nEscape, cbInput, lpszInData, lpvOutData );
  27 }
  28
  29 /************************************************************************
  30  *             Escape  [GDI32.200]
  31  */
  32 INT WINAPI Escape( HDC hdc, INT nEscape, INT cbInput,
  33                    LPCSTR lpszInData, LPVOID lpvOutData )
  34 {
  35     SEGPTR      segin,segout;
  36     INT ret;
  37     DC * dc = DC_GetDCPtr( hdc );
  38     if (!dc || !dc->funcs->pEscape) return 0;
  39
  40     segin       = (SEGPTR)lpszInData;
  41     segout      = (SEGPTR)lpvOutData;
  42     switch (nEscape) {
  43         /* Escape(hdc,QUERYESCSUPPORT,LPINT,NULL) */
  44         /* Escape(hdc,CLIP_TO_PATH,LPINT,NULL) */
  45     case QUERYESCSUPPORT:
  46     case CLIP_TO_PATH:
  47       {
  48         LPINT16 x = (LPINT16)SEGPTR_NEW(INT16);
  49         *x = *(INT*)lpszInData;
  50         segin = SEGPTR_GET(x);
  51         cbInput = sizeof(INT16);
  52         break;
  53       }
  54
  55         /* Escape(hdc,GETSCALINGFACTOR,NULL,LPPOINT32) */
  56         /* Escape(hdc,GETPHYSPAGESIZE,NULL,LPPOINT32) */
  57         /* Escape(hdc,GETPRINTINGOFFSET,NULL,LPPOINT32) */
  58
  59     case GETSCALINGFACTOR:
  60     case GETPHYSPAGESIZE:
  61     case GETPRINTINGOFFSET:
  62         segout = SEGPTR_GET(SEGPTR_NEW(POINT16));
  63         cbInput = sizeof(POINT16);
  64         break;
  65
  66         /* Escape(hdc,EXT_DEVICE_CAPS,LPINT,LPDWORD) */
  67     case EXT_DEVICE_CAPS:
  68       {
  69         LPINT16 lpIndex = (LPINT16)SEGPTR_NEW(INT16);
  70         LPDWORD lpCaps = (LPDWORD)SEGPTR_NEW(DWORD);
  71         *lpIndex = *(INT*)lpszInData;
  72
  73         segin = SEGPTR_GET(lpIndex);
  74         segout = SEGPTR_GET(lpCaps);
  75         cbInput = sizeof(INT16);
  76         break;
  77       }
  78
  79         /* Escape(hdc,SETLINECAP,LPINT,LPINT) */
  80     case SETLINECAP:
  81     case SETLINEJOIN:
  82     case SETMITERLIMIT:
  83       {
  84         LPINT16 new = (LPINT16)SEGPTR_NEW(INT16);
  85         LPINT16 old = (LPINT16)SEGPTR_NEW(INT16);
  86         *new = *(INT*)lpszInData;
  87         segin = SEGPTR_GET(new);
  88         segout = SEGPTR_GET(old);
  89         cbInput = sizeof(INT16);
  90         break;
  91       }
  92       /* Escape(hdc,GETTECHNOLOGY,NULL,LPSTR); */
  93     case GETTECHNOLOGY: {
  94         segout = SEGPTR_GET(SEGPTR_ALLOC(200)); /* enough I hope */
  95         break;
  96
  97     }
  98
  99       /* Escape(hdc,ENABLEPAIRKERNING,LPINT16,LPINT16); */
 100
 101     case ENABLEPAIRKERNING: {
 102         LPINT16 enab = SEGPTR_NEW(INT16);
 103         segout = SEGPTR_GET(SEGPTR_NEW(INT16));
 104         segin = SEGPTR_GET(enab);
 105         *enab = *(INT*)lpszInData;
 106         cbInput = sizeof(INT16);
 107         break;
 108     }
 109
 110       /* Escape(hdc,GETFACENAME,NULL,LPSTR); */
 111
 112     case GETFACENAME: {
 113         segout = SEGPTR_GET(SEGPTR_ALLOC(200));
 114         break;
 115     }
 116
 117       /* Escape(hdc,STARTDOC,LPSTR,NULL); */
 118
 119     case STARTDOC: /* string may not be \0 terminated */
 120         if(lpszInData) {
 121             char *cp = SEGPTR_ALLOC(cbInput);
 122             memcpy(cp, lpszInData, cbInput);
 123             segin = SEGPTR_GET(cp);
 124         } else
 125             segin = 0;
 126         break;
 127
 128     case SETABORTPROC:
 129         SetAbortProc(hdc, (ABORTPROC)lpszInData);
 130         break;
 131
 132       /* Escape(hdc,END_PATH,PATHINFO,NULL); */
 133     case END_PATH:
 134       {
 135         BYTE *p = SEGPTR_ALLOC(cbInput);
 136         memcpy(p, lpszInData, cbInput);
 137         segin = SEGPTR_GET(p);
 138         break;
 139       }
 140
 141     default:
 142         break;
 143
 144     }
 145
 146     ret = dc->funcs->pEscape( dc, nEscape, cbInput, segin, segout );
 147
 148     switch(nEscape) {
 149     case QUERYESCSUPPORT:
 150         if (ret)
 151                 TRACE("target DC implements Escape %d\n",nEscape);
 152         SEGPTR_FREE(PTR_SEG_TO_LIN(segin));
 153         break;
 154
 155     case SETLINECAP:
 156     case SETLINEJOIN:
 157     case SETMITERLIMIT:
 158         *(LPINT)lpvOutData = *(LPINT16)PTR_SEG_TO_LIN(segout);
 159         SEGPTR_FREE(PTR_SEG_TO_LIN(segin));
 160         SEGPTR_FREE(PTR_SEG_TO_LIN(segout));
 161         break;
 162     case GETSCALINGFACTOR:
 163     case GETPRINTINGOFFSET:
 164     case GETPHYSPAGESIZE: {
 165         LPPOINT16 x = (LPPOINT16)PTR_SEG_TO_LIN(segout);
 166         CONV_POINT16TO32(x,(LPPOINT)lpvOutData);
 167         SEGPTR_FREE(x);
 168         break;
 169     }
 170     case EXT_DEVICE_CAPS:
 171         *(LPDWORD)lpvOutData = *(LPDWORD)PTR_SEG_TO_LIN(segout);
 172         SEGPTR_FREE(PTR_SEG_TO_LIN(segin));
 173         SEGPTR_FREE(PTR_SEG_TO_LIN(segout));
 174         break;
 175
 176     case GETTECHNOLOGY: {
 177         LPSTR x=PTR_SEG_TO_LIN(segout);
 178         lstrcpyA(lpvOutData,x);
 179         SEGPTR_FREE(x);
 180         break;
 181     }
 182     case ENABLEPAIRKERNING: {
 183         LPINT16 enab = (LPINT16)PTR_SEG_TO_LIN(segout);
 184
 185         *(LPINT)lpvOutData = *enab;
 186         SEGPTR_FREE(enab);
 187         SEGPTR_FREE(PTR_SEG_TO_LIN(segin));
 188         break;
 189     }
 190     case GETFACENAME: {
 191         LPSTR x = (LPSTR)PTR_SEG_TO_LIN(segout);
 192         lstrcpyA(lpvOutData,x);
 193         SEGPTR_FREE(x);
 194         break;
 195     }
 196     case STARTDOC:
 197     case CLIP_TO_PATH:
 198     case END_PATH:
 199         SEGPTR_FREE(PTR_SEG_TO_LIN(segin));
 200         break;
 201
 202     default:
 203         break;
 204     }
 205     return ret;
 206 }
 207
 208 /******************************************************************************
 209  *              ExtEscape       [GDI32.95]
 210  *
 211  * PARAMS
 212  *    hdc         [I] Handle to device context
 213  *    nEscape     [I] Escape function
 214  *    cbInput     [I] Number of bytes in input structure
 215  *    lpszInData  [I] Pointer to input structure
 216  *    cbOutput    [I] Number of bytes in output structure
 217  *    lpszOutData [O] Pointer to output structure
 218  *
 219  * RETURNS
 220  *    Success: >0
 221  *    Not implemented: 0
 222  *    Failure: <0
 223  */
 224 INT WINAPI ExtEscape( HDC hdc, INT nEscape, INT cbInput,
 225                       LPCSTR lpszInData, INT cbOutput, LPSTR lpszOutData )
 226 {
 227     char *inBuf, *outBuf;
 228     INT ret;
 229
 230     inBuf = SEGPTR_ALLOC(cbInput);
 231     memcpy(inBuf, lpszInData, cbInput);
 232     outBuf = cbOutput ? SEGPTR_ALLOC(cbOutput) : NULL;
 233     ret = Escape16( hdc, nEscape, cbInput, SEGPTR_GET(inBuf),
 234                     SEGPTR_GET(outBuf) );
 235     SEGPTR_FREE(inBuf);
 236     if(outBuf) {
 237         memcpy(lpszOutData, outBuf, cbOutput);
 238         SEGPTR_FREE(outBuf);
 239     }
 240     return ret;
 241 }
 242
 243 /*******************************************************************
 244  *      DrawEscape [GDI32.74]
 245  *
 246  *
 247  */
 248 INT WINAPI DrawEscape(HDC hdc, INT nEscape, INT cbInput, LPCSTR lpszInData)
 249 {
 250     FIXME("DrawEscape, stub\n");
 251     return 0;
 252 }