reactos/subsystems/win32/win32k/objects/metafile.c

   1 /*
   2  * PROJECT:         ReactOS Win32k Subsystem
   3  * LICENSE:         GPL - See COPYING in the top level directory
   4  * FILE:            win32k/objects/metafile.c
   5  * PURPOSE:         Metafile Implementation
   6  * PROGRAMMERS:     ...
   7  */
   8
   9 /* INCLUDES ******************************************************************/
  10
  11 #include <win32k.h>
  12
  13 #define NDEBUG
  14 #include <debug.h>
  15
  16 /* System Service Calls ******************************************************/
  17
  18 /*
  19  * @unimplemented
  20  */
  21 LONG
  22 APIENTRY
  23 NtGdiConvertMetafileRect(IN HDC hDC,
  24                          IN OUT PRECTL pRect)
  25 {
  26     UNIMPLEMENTED;
  27     return 0;
  28 }
  29
  30 /*
  31  * @unimplemented
  32  */
  33 HDC
  34 APIENTRY
  35 NtGdiCreateMetafileDC(IN HDC hdc)
  36 {
  37
  38     UNIMPLEMENTED;
  39     return NULL;
  40
  41
  42 #if 0
  43    PDC Dc;
  44    HDC ret = NULL;
  45    DWORD length = 0;
  46    HDC tempHDC;
  47    DWORD MemSize;
  48    DWORD dwDesiredAccess;
  49
  50    tempHDC = hDCRef;
  51    if (hDCRef == NULL)
  52    {
  53        /* FIXME ??
  54         * Shall we create hdc NtGdiHdcCompatible hdc ??
  55         */
  56        UNICODE_STRING DriverName;
  57        RtlInitUnicodeString(&DriverName, L"DISPLAY");
  58        //IntGdiCreateDC(&DriverName, NULL, NULL, NULL, FALSE);
  59            tempHDC = NtGdiOpenDCW( &DriverName,
  60                                           NULL,
  61                                           NULL,
  62                                              0,  // DCW 0 and ICW 1.
  63                                           NULL,
  64                                   (PVOID) NULL,
  65                                   (PVOID) NULL );
  66    }
  67
  68    GDIOBJ_SetOwnership(GdiHandleTable, tempHDC, PsGetCurrentProcess());
  69    DC_SetOwnership(tempHDC, PsGetCurrentProcess());
  70
  71    Dc = DC_LockDc(tempHDC);
  72    if (Dc == NULL)
  73    {
  74           if (hDCRef == NULL)
  75           {
  76           NtGdiDeleteObjectApp(tempHDC);
  77           }
  78       SetLastWin32Error(ERROR_INVALID_HANDLE);
  79       return NULL;
  80    }
  81
  82    if(Description)
  83    {
  84       length = wcslen(Description);
  85       length += wcslen(Description + length + 1);
  86       length += 3;
  87       length *= 2;
  88    }
  89
  90    MemSize = sizeof(ENHMETAHEADER) + (length + 3) / 4 * 4;
  91
  92    if (!(Dc->emh = EngAllocMem(FL_ZERO_MEMORY, MemSize, 0)))
  93    {
  94        DC_UnlockDc(Dc);
  95        if (hDCRef == NULL)
  96        {
  97            NtGdiDeleteObjectApp(tempHDC);
  98        }
  99        SetLastWin32Error(ERROR_INVALID_HANDLE);
 100        return NULL;
 101    }
 102
 103    Dc->emh->iType = EMR_HEADER;
 104    Dc->emh->nSize = MemSize;
 105
 106    Dc->emh->rclBounds.left = Dc->emh->rclBounds.top = 0;
 107    Dc->emh->rclBounds.right = Dc->emh->rclBounds.bottom = -1;
 108
 109    if(Rect)
 110    {
 111       Dc->emh->rclFrame.left   = Rect->left;
 112       Dc->emh->rclFrame.top    = Rect->top;
 113       Dc->emh->rclFrame.right  = Rect->right;
 114       Dc->emh->rclFrame.bottom = Rect->bottom;
 115    }
 116    else
 117    {
 118       /* Set this to {0,0 - -1,-1} and update it at the end */
 119       Dc->emh->rclFrame.left = Dc->emh->rclFrame.top = 0;
 120       Dc->emh->rclFrame.right = Dc->emh->rclFrame.bottom = -1;
 121    }
 122
 123    Dc->emh->dSignature = ENHMETA_SIGNATURE;
 124    Dc->emh->nVersion = 0x10000;
 125    Dc->emh->nBytes = Dc->emh->nSize;
 126    Dc->emh->nRecords = 1;
 127    Dc->emh->nHandles = 1;
 128
 129    Dc->emh->sReserved = 0; /* According to docs, this is reserved and must be 0 */
 130    Dc->emh->nDescription = length / 2;
 131
 132    Dc->emh->offDescription = length ? sizeof(ENHMETAHEADER) : 0;
 133
 134    Dc->emh->nPalEntries = 0; /* I guess this should start at 0 */
 135
 136    /* Size in pixels */
 137    Dc->emh->szlDevice.cx = NtGdiGetDeviceCaps(tempHDC, HORZRES);
 138    Dc->emh->szlDevice.cy = NtGdiGetDeviceCaps(tempHDC, VERTRES);
 139
 140    /* Size in millimeters */
 141    Dc->emh->szlMillimeters.cx = NtGdiGetDeviceCaps(tempHDC, HORZSIZE);
 142    Dc->emh->szlMillimeters.cy = NtGdiGetDeviceCaps(tempHDC, VERTSIZE);
 143
 144    /* Size in micrometers */
 145    Dc->emh->szlMicrometers.cx = Dc->emh->szlMillimeters.cx * 1000;
 146    Dc->emh->szlMicrometers.cy = Dc->emh->szlMillimeters.cy * 1000;
 147
 148    if(Description)
 149    {
 150       memcpy((char *)Dc->emh + sizeof(ENHMETAHEADER), Description, length);
 151    }
 152
 153    ret = tempHDC;
 154    if (File)
 155    {
 156       OBJECT_ATTRIBUTES ObjectAttributes;
 157       IO_STATUS_BLOCK IoStatusBlock;
 158       IO_STATUS_BLOCK Iosb;
 159       UNICODE_STRING NtPathU;
 160       NTSTATUS Status;
 161       ULONG FileAttributes = (FILE_ATTRIBUTE_VALID_FLAGS & ~FILE_ATTRIBUTE_DIRECTORY);
 162
 163       DPRINT1("Trying Create EnhMetaFile\n");
 164
 165       /* disk based metafile */
 166       dwDesiredAccess = GENERIC_WRITE | GENERIC_READ | SYNCHRONIZE | FILE_READ_ATTRIBUTES;
 167
 168       if (!RtlDosPathNameToNtPathName_U (File, &NtPathU, NULL, NULL))
 169       {
 170          DC_UnlockDc(Dc);
 171          if (hDCRef == NULL)
 172          {
 173              NtGdiDeleteObjectApp(tempHDC);
 174          }
 175          DPRINT1("Can not Create EnhMetaFile\n");
 176          SetLastWin32Error(ERROR_PATH_NOT_FOUND);
 177          return NULL;
 178       }
 179
 180       InitializeObjectAttributes(&ObjectAttributes, &NtPathU, 0, NULL, NULL);
 181
 182       Status = NtCreateFile (&Dc->hFile, dwDesiredAccess, &ObjectAttributes, &IoStatusBlock,
 183                              NULL, FileAttributes, 0, FILE_OVERWRITE_IF, FILE_NON_DIRECTORY_FILE,
 184                              NULL, 0);
 185
 186       RtlFreeHeap(RtlGetProcessHeap(), 0, NtPathU.Buffer);
 187
 188       if (!NT_SUCCESS(Status))
 189       {
 190          Dc->hFile = NULL;
 191          DC_UnlockDc(Dc);
 192          if (hDCRef == NULL)
 193          {
 194              NtGdiDeleteObjectApp(tempHDC);
 195          }
 196          DPRINT1("Create EnhMetaFile fail\n");
 197          SetLastWin32Error(ERROR_INVALID_HANDLE);
 198          return NULL;
 199       }
 200
 201       SetLastWin32Error(IoStatusBlock.Information == FILE_OVERWRITTEN ? ERROR_ALREADY_EXISTS : 0);
 202
 203       Status = NtWriteFile(Dc->hFile, NULL, NULL, NULL, &Iosb, (PVOID)&Dc->emh, Dc->emh->nSize, NULL, NULL);
 204       if (Status == STATUS_PENDING)
 205       {
 206           Status = NtWaitForSingleObject(Dc->hFile,FALSE,NULL);
 207           if (NT_SUCCESS(Status))
 208           {
 209               Status = Iosb.Status;
 210           }
 211       }
 212
 213       if (NT_SUCCESS(Status))
 214       {
 215           ret = tempHDC;
 216           DC_UnlockDc(Dc);
 217       }
 218       else
 219       {
 220           Dc->hFile = NULL;
 221           DPRINT1("Write to EnhMetaFile fail\n");
 222           SetLastWin32Error(ERROR_CAN_NOT_COMPLETE);
 223           ret = NULL;
 224           DC_UnlockDc(Dc);
 225           if (hDCRef == NULL)
 226           {
 227              NtGdiDeleteObjectApp(tempHDC);
 228           }
 229       }
 230     }
 231     else
 232     {
 233       DC_UnlockDc(Dc);
 234     }
 235
 236     return ret;
 237 #endif
 238 }
 239
 240 /*
 241  * @unimplemented
 242  */
 243 HANDLE
 244 APIENTRY
 245 NtGdiCreateServerMetaFile(IN DWORD iType,
 246                           IN ULONG cjData,
 247                           IN PBYTE pjData,
 248                           IN DWORD mm,
 249                           IN DWORD xExt,
 250                           IN DWORD yExt)
 251 {
 252     UNIMPLEMENTED;
 253     return NULL;
 254 }
 255
 256 /*
 257  * @unimplemented
 258  */
 259 ULONG
 260 APIENTRY
 261 NtGdiGetServerMetaFileBits(IN HANDLE hmo,
 262                            IN ULONG cjData,
 263                            OUT OPTIONAL PBYTE pjData,
 264                            OUT PDWORD piType,
 265                            OUT PDWORD pmm,
 266                            OUT PDWORD pxExt,
 267                            OUT PDWORD pyExt)
 268 {
 269     UNIMPLEMENTED;
 270     return 0;
 271 }
 272
 273 /* EOF */