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     return dc->funcs->pEscape( dc, nEscape, cbInput, lpszInData, lpvOutData );
  26 }
  27
  28 /************************************************************************
  29  *             Escape  [GDI32.200]
  30  */
  31 INT WINAPI Escape( HDC hdc, INT nEscape, INT cbInput,
  32                    LPCSTR lpszInData, LPVOID lpvOutData )
  33 {
  34     SEGPTR      segin,segout;
  35     INT ret;
  36
  37     segin       = (SEGPTR)lpszInData;
  38     segout      = (SEGPTR)lpvOutData;
  39     switch (nEscape) {
  40         /* Escape(hdc,QUERYESCSUPPORT,LPINT,NULL) */
  41         /* Escape(hdc,EXT_DEVICE_CAPS,LPINT,NULL) */
  42         /* Escape(hdc,SETLINECAP,LPINT,NULL) */
  43     case QUERYESCSUPPORT:
  44     case EXT_DEVICE_CAPS:
  45     case SETLINECAP:
  46     case SETLINEJOIN:
  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,GETTECHNOLOGY,NULL,LPSTR); */
  67
  68     case GETTECHNOLOGY: {
  69         segout = SEGPTR_GET(SEGPTR_ALLOC(200)); /* enough I hope */
  70         break;
  71
  72     }
  73
  74       /* Escape(hdc,ENABLEPAIRKERNING,LPINT16,LPINT16); */
  75
  76     case ENABLEPAIRKERNING: {
  77         LPINT16 enab = SEGPTR_NEW(INT16);
  78         segout = SEGPTR_GET(SEGPTR_NEW(INT16));
  79         segin = SEGPTR_GET(enab);
  80         *enab = *(INT*)lpszInData;
  81         cbInput = sizeof(INT16);
  82         break;
  83     }
  84
  85       /* Escape(hdc,GETFACENAME,NULL,LPSTR); */
  86
  87     case GETFACENAME: {
  88         segout = SEGPTR_GET(SEGPTR_ALLOC(200));
  89         break;
  90     }
  91
  92       /* Escape(hdc,STARTDOC,LPSTR,NULL); */
  93
  94     case STARTDOC: /* string may not be \0 terminated */
  95         if(lpszInData) {
  96             char *cp = SEGPTR_ALLOC(cbInput);
  97             memcpy(cp, lpszInData, cbInput);
  98             segin = SEGPTR_GET(cp);
  99         } else
 100             segin = 0;
 101         break;
 102
 103     default:
 104         break;
 105
 106     }
 107
 108     ret = Escape16( hdc, nEscape, cbInput, segin, segout );
 109
 110     switch(nEscape) {
 111     case QUERYESCSUPPORT:
 112         if (ret)
 113                 TRACE("target DC implements Escape %d\n",nEscape);
 114         SEGPTR_FREE(PTR_SEG_TO_LIN(segin));
 115         break;
 116     case EXT_DEVICE_CAPS:
 117     case SETLINECAP:
 118     case SETLINEJOIN:
 119         SEGPTR_FREE(PTR_SEG_TO_LIN(segin));
 120         break;
 121     case GETSCALINGFACTOR:
 122     case GETPRINTINGOFFSET:
 123     case GETPHYSPAGESIZE: {
 124         LPPOINT16 x = (LPPOINT16)PTR_SEG_TO_LIN(segout);
 125         CONV_POINT16TO32(x,(LPPOINT)lpvOutData);
 126         SEGPTR_FREE(x);
 127         break;
 128     }
 129     case GETTECHNOLOGY: {
 130         LPSTR x=PTR_SEG_TO_LIN(segout);
 131         lstrcpyA(lpvOutData,x);
 132         SEGPTR_FREE(x);
 133         break;
 134     }
 135     case ENABLEPAIRKERNING: {
 136         LPINT16 enab = (LPINT16)PTR_SEG_TO_LIN(segout);
 137
 138         *(LPINT)lpvOutData = *enab;
 139         SEGPTR_FREE(enab);
 140         SEGPTR_FREE(PTR_SEG_TO_LIN(segin));
 141         break;
 142     }
 143     case GETFACENAME: {
 144         LPSTR x = (LPSTR)PTR_SEG_TO_LIN(segout);
 145         lstrcpyA(lpvOutData,x);
 146         SEGPTR_FREE(x);
 147         break;
 148     }
 149     case STARTDOC:
 150         SEGPTR_FREE(PTR_SEG_TO_LIN(segin));
 151         break;
 152
 153     default:
 154         break;
 155     }
 156     return ret;
 157 }
 158
 159 /******************************************************************************
 160  *              ExtEscape       [GDI32.95]
 161  *
 162  * PARAMS
 163  *    hdc         [I] Handle to device context
 164  *    nEscape     [I] Escape function
 165  *    cbInput     [I] Number of bytes in input structure
 166  *    lpszInData  [I] Pointer to input structure
 167  *    cbOutput    [I] Number of bytes in output structure
 168  *    lpszOutData [O] Pointer to output structure
 169  *
 170  * RETURNS
 171  *    Success: >0
 172  *    Not implemented: 0
 173  *    Failure: <0
 174  */
 175 INT WINAPI ExtEscape( HDC hdc, INT nEscape, INT cbInput,
 176                       LPCSTR lpszInData, INT cbOutput, LPSTR lpszOutData )
 177 {
 178     char *inBuf, *outBuf;
 179     INT ret;
 180
 181     inBuf = SEGPTR_ALLOC(cbInput);
 182     memcpy(inBuf, lpszInData, cbInput);
 183     outBuf = cbOutput ? SEGPTR_ALLOC(cbOutput) : NULL;
 184     ret = Escape16( hdc, nEscape, cbInput, SEGPTR_GET(inBuf),
 185                     SEGPTR_GET(outBuf) );
 186     SEGPTR_FREE(inBuf);
 187     if(outBuf) {
 188         memcpy(lpszOutData, outBuf, cbOutput);
 189         SEGPTR_FREE(outBuf);
 190     }
 191     return ret;
 192 }
 193
 194 /*******************************************************************
 195  *      DrawEscape [GDI32.74]
 196  *
 197  *
 198  */
 199 INT WINAPI DrawEscape(HDC hdc, INT nEscape, INT cbInput, LPCSTR lpszInData)
 200 {
 201     FIXME("DrawEscape, stub\n");
 202     return 0;
 203 }