reactos/win32ss/gdi/ntgdi/print.c

   1 /*
   2  * PROJECT:         ReactOS win32 kernel mode subsystem
   3  * LICENSE:         GPL - See COPYING in the top level directory
   4  * FILE:            win32ss/gdi/ntgdi/print.c
   5  * PURPOSE:         Print functions
   6  * PROGRAMMER:
   7  */
   8
   9 #include <win32k.h>
  10
  11 #define NDEBUG
  12 #include <debug.h>
  13
  14 INT
  15 APIENTRY
  16 NtGdiAbortDoc(HDC  hDC)
  17 {
  18   UNIMPLEMENTED;
  19   return 0;
  20 }
  21
  22 INT
  23 APIENTRY
  24 NtGdiEndDoc(HDC  hDC)
  25 {
  26   UNIMPLEMENTED;
  27   return 0;
  28 }
  29
  30 INT
  31 APIENTRY
  32 NtGdiEndPage(HDC  hDC)
  33 {
  34   UNIMPLEMENTED;
  35   return 0;
  36 }
  37
  38 INT
  39 FASTCALL
  40 IntGdiEscape(PDC    dc,
  41              INT    Escape,
  42              INT    InSize,
  43              LPCSTR InData,
  44              LPVOID OutData)
  45 {
  46   if (Escape == QUERYESCSUPPORT)
  47     return FALSE;
  48
  49   UNIMPLEMENTED;
  50   return SP_ERROR;
  51 }
  52
  53 INT
  54 APIENTRY
  55 NtGdiEscape(HDC  hDC,
  56             INT  Escape,
  57             INT  InSize,
  58             LPCSTR  InData,
  59             LPVOID  OutData)
  60 {
  61   PDC dc;
  62   INT ret;
  63
  64   dc = DC_LockDc(hDC);
  65   if (dc == NULL)
  66   {
  67     EngSetLastError(ERROR_INVALID_HANDLE);
  68     return SP_ERROR;
  69   }
  70
  71   /* TODO: FIXME: Don't pass umode buffer to an Int function */
  72   ret = IntGdiEscape(dc, Escape, InSize, InData, OutData);
  73
  74   DC_UnlockDc( dc );
  75   return ret;
  76 }
  77
  78 INT
  79 APIENTRY
  80 IntGdiExtEscape(
  81    PDC    dc,
  82    INT    Escape,
  83    INT    InSize,
  84    LPCSTR InData,
  85    INT    OutSize,
  86    LPSTR  OutData)
  87 {
  88    SURFACE *psurf;
  89    INT Result;
  90
  91    if ((dc->ppdev->DriverFunctions.Escape == NULL) ||
  92        (dc->dclevel.pSurface == NULL))
  93    {
  94       Result = 0;
  95    }
  96    else
  97    {
  98       DC_vPrepareDCsForBlit(dc, NULL, NULL, NULL);
  99       psurf = dc->dclevel.pSurface;
 100
 101       Result = dc->ppdev->DriverFunctions.Escape(
 102          &psurf->SurfObj,
 103          Escape,
 104          InSize,
 105          (PVOID)InData,
 106          OutSize,
 107          (PVOID)OutData );
 108
 109       DC_vFinishBlit(dc, NULL);
 110    }
 111
 112    return Result;
 113 }
 114
 115 INT
 116 APIENTRY
 117 NtGdiExtEscape(
 118    HDC    hDC,
 119    IN OPTIONAL PWCHAR pDriver,
 120    IN INT nDriver,
 121    INT    Escape,
 122    INT    InSize,
 123    OPTIONAL LPSTR UnsafeInData,
 124    INT    OutSize,
 125    OPTIONAL LPSTR  UnsafeOutData)
 126 {
 127    PDC      pDC;
 128    LPVOID   SafeInData = NULL;
 129    LPVOID   SafeOutData = NULL;
 130    NTSTATUS Status = STATUS_SUCCESS;
 131    INT      Result;
 132
 133    if (hDC == 0)
 134    {
 135        hDC = UserGetWindowDC(NULL);
 136    }
 137
 138    pDC = DC_LockDc(hDC);
 139    if ( pDC == NULL )
 140    {
 141       EngSetLastError(ERROR_INVALID_HANDLE);
 142       return -1;
 143    }
 144    if ( pDC->dctype == DC_TYPE_INFO)
 145    {
 146       DC_UnlockDc(pDC);
 147       return 0;
 148    }
 149
 150    if ( InSize && UnsafeInData )
 151    {
 152       _SEH2_TRY
 153       {
 154         ProbeForRead(UnsafeInData,
 155                      InSize,
 156                      1);
 157       }
 158       _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 159       {
 160         Status = _SEH2_GetExceptionCode();
 161       }
 162       _SEH2_END;
 163
 164       if (!NT_SUCCESS(Status))
 165       {
 166         DC_UnlockDc(pDC);
 167         SetLastNtError(Status);
 168         return -1;
 169       }
 170
 171       SafeInData = ExAllocatePoolWithTag ( PagedPool, InSize, GDITAG_TEMP );
 172       if ( !SafeInData )
 173       {
 174          DC_UnlockDc(pDC);
 175          EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
 176          return -1;
 177       }
 178
 179       _SEH2_TRY
 180       {
 181         /* Pointers were already probed! */
 182         RtlCopyMemory(SafeInData,
 183                       UnsafeInData,
 184                       InSize);
 185       }
 186       _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 187       {
 188         Status = _SEH2_GetExceptionCode();
 189       }
 190       _SEH2_END;
 191
 192       if ( !NT_SUCCESS(Status) )
 193       {
 194          ExFreePoolWithTag ( SafeInData, GDITAG_TEMP );
 195          DC_UnlockDc(pDC);
 196          SetLastNtError(Status);
 197          return -1;
 198       }
 199    }
 200
 201    if ( OutSize && UnsafeOutData )
 202    {
 203       _SEH2_TRY
 204       {
 205         ProbeForWrite(UnsafeOutData,
 206                       OutSize,
 207                       1);
 208       }
 209       _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 210       {
 211         Status = _SEH2_GetExceptionCode();
 212       }
 213       _SEH2_END;
 214
 215       if (!NT_SUCCESS(Status))
 216       {
 217         SetLastNtError(Status);
 218         goto freeout;
 219       }
 220
 221       SafeOutData = ExAllocatePoolWithTag ( PagedPool, OutSize, GDITAG_TEMP );
 222       if ( !SafeOutData )
 223       {
 224          EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
 225 freeout:
 226          if ( SafeInData )
 227             ExFreePoolWithTag ( SafeInData, GDITAG_TEMP );
 228          DC_UnlockDc(pDC);
 229          return -1;
 230       }
 231    }
 232
 233    Result = IntGdiExtEscape ( pDC, Escape, InSize, SafeInData, OutSize, SafeOutData );
 234
 235    DC_UnlockDc(pDC);
 236
 237    if ( SafeInData )
 238       ExFreePoolWithTag ( SafeInData ,GDITAG_TEMP );
 239
 240    if ( SafeOutData )
 241    {
 242       _SEH2_TRY
 243       {
 244         /* Pointers were already probed! */
 245         RtlCopyMemory(UnsafeOutData,
 246                       SafeOutData,
 247                       OutSize);
 248       }
 249       _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 250       {
 251         Status = _SEH2_GetExceptionCode();
 252       }
 253       _SEH2_END;
 254
 255       ExFreePoolWithTag ( SafeOutData, GDITAG_TEMP );
 256       if ( !NT_SUCCESS(Status) )
 257       {
 258          SetLastNtError(Status);
 259          return -1;
 260       }
 261    }
 262
 263    return Result;
 264 }
 265
 266 INT
 267 APIENTRY
 268 NtGdiStartDoc(
 269     IN HDC hdc,
 270     IN DOCINFOW *pdi,
 271     OUT BOOL *pbBanding,
 272     IN INT iJob)
 273 {
 274   UNIMPLEMENTED;
 275   return 0;
 276 }
 277
 278 INT
 279 APIENTRY
 280 NtGdiStartPage(HDC  hDC)
 281 {
 282   UNIMPLEMENTED;
 283   return 0;
 284 }
 285 /* EOF */