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