reactos/subsys/win32k/objects/dc.c

   1 /*
   2  *  ReactOS W32 Subsystem
   3  *  Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  */
  19 /* $Id: dc.c,v 1.154 2004/12/21 21:38:27 weiden Exp $
  20  *
  21  * DC.C - Device context functions
  22  *
  23  */
  24 #include <w32k.h>
  25
  26 #ifndef OBJ_COLORSPACE
  27 #define OBJ_COLORSPACE  (14)
  28 #endif
  29
  30 static GDIDEVICE PrimarySurface;
  31
  32 /* FIXME: DCs should probably be thread safe  */
  33
  34 /*
  35  * DC device-independent Get/SetXXX functions
  36  * (RJJ) swiped from WINE
  37  */
  38
  39 #define DC_GET_VAL( func_type, func_name, dc_field ) \
  40 func_type STDCALL  func_name( HDC hdc ) \
  41 {                                   \
  42   func_type  ft;                    \
  43   PDC  dc = DC_LockDc( hdc );  \
  44   if (!dc)                          \
  45   {                                 \
  46     SetLastWin32Error(ERROR_INVALID_HANDLE); \
  47     return 0;                       \
  48   }                                 \
  49   ft = dc->dc_field;                \
  50   DC_UnlockDc( hdc );                           \
  51   return ft;                        \
  52 }
  53
  54 /* DC_GET_VAL_EX is used to define functions returning a POINT or a SIZE. It is
  55  * important that the function has the right signature, for the implementation
  56  * we can do whatever we want.
  57  */
  58 #define DC_GET_VAL_EX( FuncName, ret_x, ret_y, type, ax, ay ) \
  59 VOID FASTCALL Int##FuncName ( PDC dc, LP##type pt) \
  60 { \
  61   ASSERT(dc); \
  62   ASSERT(pt); \
  63   pt->ax = dc->ret_x; \
  64   pt->ay = dc->ret_y; \
  65 } \
  66 BOOL STDCALL NtGdi##FuncName ( HDC hdc, LP##type pt ) \
  67 { \
  68   NTSTATUS Status; \
  69   type Safept; \
  70   PDC dc; \
  71   if(!pt) \
  72   { \
  73     SetLastWin32Error(ERROR_INVALID_PARAMETER); \
  74     return FALSE; \
  75   } \
  76   if(!(dc = DC_LockDc(hdc))) \
  77   { \
  78     SetLastWin32Error(ERROR_INVALID_HANDLE); \
  79     return FALSE; \
  80   } \
  81   Int##FuncName( dc, &Safept); \
  82   DC_UnlockDc(hdc); \
  83   Status = MmCopyToCaller(pt, &Safept, sizeof( type )); \
  84   if(!NT_SUCCESS(Status)) \
  85   { \
  86     SetLastNtError(Status); \
  87     return FALSE; \
  88   } \
  89   return TRUE; \
  90 }
  91
  92 #define DC_SET_MODE( func_name, dc_field, min_val, max_val ) \
  93 INT STDCALL  func_name( HDC hdc, INT mode ) \
  94 {                                           \
  95   INT  prevMode;                            \
  96   PDC  dc;                                  \
  97   if ((mode < min_val) || (mode > max_val)) \
  98   { \
  99     SetLastWin32Error(ERROR_INVALID_PARAMETER); \
 100     return 0;                               \
 101   } \
 102   dc = DC_LockDc ( hdc );              \
 103   if ( !dc )                                \
 104   { \
 105     SetLastWin32Error(ERROR_INVALID_HANDLE); \
 106     return 0;                               \
 107   } \
 108   prevMode = dc->dc_field;                  \
 109   dc->dc_field = mode;                      \
 110   DC_UnlockDc ( hdc );                    \
 111   return prevMode;                          \
 112 }
 113
 114
 115 //  ---------------------------------------------------------  File Statics
 116
 117 //  -----------------------------------------------------  Public Functions
 118
 119 BOOL STDCALL
 120 NtGdiCancelDC(HDC  hDC)
 121 {
 122   UNIMPLEMENTED;
 123   return FALSE;
 124 }
 125
 126 HDC STDCALL
 127 NtGdiCreateCompatableDC(HDC hDC)
 128 {
 129   PDC  NewDC, OrigDC;
 130   HBITMAP  hBitmap;
 131   HDC hNewDC, DisplayDC;
 132   HRGN hVisRgn;
 133   UNICODE_STRING DriverName;
 134
 135   DisplayDC = NULL;
 136   if (hDC == NULL)
 137     {
 138       RtlInitUnicodeString(&DriverName, L"DISPLAY");
 139       DisplayDC = IntGdiCreateDC(&DriverName, NULL, NULL, NULL);
 140       if (NULL == DisplayDC)
 141         {
 142           return NULL;
 143         }
 144       hDC = DisplayDC;
 145     }
 146
 147   /*  Allocate a new DC based on the original DC's device  */
 148   OrigDC = DC_LockDc(hDC);
 149   if (NULL == OrigDC)
 150     {
 151       if (NULL != DisplayDC)
 152         {
 153           NtGdiDeleteDC(DisplayDC);
 154         }
 155       return NULL;
 156     }
 157   hNewDC = DC_AllocDC(&OrigDC->DriverName);
 158
 159   if (NULL == hNewDC)
 160     {
 161       DC_UnlockDc(hDC);
 162       if (NULL != DisplayDC)
 163         {
 164           NtGdiDeleteDC(DisplayDC);
 165         }
 166       return  NULL;
 167     }
 168   NewDC = DC_LockDc( hNewDC );
 169
 170   /* Copy information from original DC to new DC  */
 171   NewDC->hSelf = hNewDC;
 172
 173   NewDC->PDev = OrigDC->PDev;
 174   NewDC->DMW = OrigDC->DMW;
 175   memcpy(NewDC->FillPatternSurfaces,
 176          OrigDC->FillPatternSurfaces,
 177          sizeof OrigDC->FillPatternSurfaces);
 178   NewDC->GDIInfo = OrigDC->GDIInfo;
 179   NewDC->DevInfo = OrigDC->DevInfo;
 180   NewDC->w.bitsPerPixel = OrigDC->w.bitsPerPixel;
 181
 182   /* DriverName is copied in the AllocDC routine  */
 183   NewDC->DeviceDriver = OrigDC->DeviceDriver;
 184   NewDC->wndOrgX = OrigDC->wndOrgX;
 185   NewDC->wndOrgY = OrigDC->wndOrgY;
 186   NewDC->wndExtX = OrigDC->wndExtX;
 187   NewDC->wndExtY = OrigDC->wndExtY;
 188   NewDC->vportOrgX = OrigDC->vportOrgX;
 189   NewDC->vportOrgY = OrigDC->vportOrgY;
 190   NewDC->vportExtX = OrigDC->vportExtX;
 191   NewDC->vportExtY = OrigDC->vportExtY;
 192
 193   /* Create default bitmap */
 194   if (!(hBitmap = NtGdiCreateBitmap( 1, 1, 1, NewDC->w.bitsPerPixel, NULL )))
 195     {
 196       DC_UnlockDc( hDC );
 197       DC_UnlockDc( hNewDC );
 198       DC_FreeDC( hNewDC );
 199       if (NULL != DisplayDC)
 200         {
 201           NtGdiDeleteDC(DisplayDC);
 202         }
 203       return NULL;
 204     }
 205   NewDC->w.flags        = DC_MEMORY;
 206   NewDC->w.hBitmap      = hBitmap;
 207   NewDC->w.hFirstBitmap = hBitmap;
 208   NewDC->GDIDevice      = OrigDC->GDIDevice;
 209
 210   NewDC->w.hPalette = OrigDC->w.hPalette;
 211   NewDC->w.textColor = OrigDC->w.textColor;
 212   NewDC->w.textAlign = OrigDC->w.textAlign;
 213   NewDC->w.backgroundColor = OrigDC->w.backgroundColor;
 214   NewDC->w.backgroundMode = OrigDC->w.backgroundMode;
 215   DC_UnlockDc( hDC );
 216   if (NULL != DisplayDC)
 217     {
 218       NtGdiDeleteDC(DisplayDC);
 219     }
 220   DC_UnlockDc(hNewDC);
 221
 222   hVisRgn = NtGdiCreateRectRgn(0, 0, 1, 1);
 223   NtGdiSelectVisRgn(hNewDC, hVisRgn);
 224   NtGdiDeleteObject(hVisRgn);
 225
 226   DC_InitDC(hNewDC);
 227
 228   return hNewDC;
 229 }
 230
 231 static BOOL FASTCALL
 232 GetRegistryPath(PUNICODE_STRING RegistryPath, ULONG DisplayNumber)
 233 {
 234   RTL_QUERY_REGISTRY_TABLE QueryTable[2];
 235   WCHAR DeviceNameBuffer[20];
 236   NTSTATUS Status;
 237
 238   swprintf(DeviceNameBuffer, L"\\Device\\Video%d", DisplayNumber);
 239   RtlInitUnicodeString(RegistryPath, NULL);
 240   RtlZeroMemory(QueryTable, sizeof(QueryTable));
 241   QueryTable[0].Flags = RTL_QUERY_REGISTRY_REQUIRED | RTL_QUERY_REGISTRY_DIRECT;
 242   QueryTable[0].Name = DeviceNameBuffer;
 243   QueryTable[0].EntryContext = RegistryPath;
 244
 245   Status = RtlQueryRegistryValues(RTL_REGISTRY_DEVICEMAP,
 246                                   L"VIDEO",
 247                                   QueryTable,
 248                                   NULL,
 249                                   NULL);
 250   if (! NT_SUCCESS(Status))
 251     {
 252       DPRINT1("No \\Device\\Video%d value in DEVICEMAP\\VIDEO found\n", DisplayNumber);
 253       return FALSE;
 254     }
 255
 256   DPRINT("RegistryPath %S\n", RegistryPath->Buffer);
 257
 258   return TRUE;
 259 }
 260
 261 static BOOL FASTCALL
 262 FindDriverFileNames(PUNICODE_STRING DriverFileNames, ULONG DisplayNumber)
 263 {
 264   RTL_QUERY_REGISTRY_TABLE QueryTable[2];
 265   UNICODE_STRING RegistryPath;
 266   NTSTATUS Status;
 267
 268   if (! GetRegistryPath(&RegistryPath, DisplayNumber))
 269     {
 270       DPRINT("GetRegistryPath failed\n");
 271       return FALSE;
 272     }
 273
 274   RtlZeroMemory(QueryTable, sizeof(QueryTable));
 275   QueryTable[0].Flags = RTL_QUERY_REGISTRY_REQUIRED | RTL_QUERY_REGISTRY_DIRECT;
 276   QueryTable[0].Name = L"InstalledDisplayDrivers";
 277   QueryTable[0].EntryContext = DriverFileNames;
 278
 279   Status = RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE,
 280                                   RegistryPath.Buffer,
 281                                   QueryTable,
 282                                   NULL,
 283                                   NULL);
 284   RtlFreeUnicodeString(&RegistryPath);
 285   if (! NT_SUCCESS(Status))
 286     {
 287       DPRINT1("No InstalledDisplayDrivers value in service entry found\n");
 288       return FALSE;
 289     }
 290
 291   DPRINT("DriverFileNames %S\n", DriverFileNames->Buffer);
 292
 293   return TRUE;
 294 }
 295
 296 static NTSTATUS STDCALL
 297 DevModeCallback(IN PWSTR ValueName,
 298                 IN ULONG ValueType,
 299                 IN PVOID ValueData,
 300                 IN ULONG ValueLength,
 301                 IN PVOID Context,
 302                 IN PVOID EntryContext)
 303 {
 304   PDEVMODEW DevMode = (PDEVMODEW) Context;
 305
 306   DPRINT("Found registry value for name %S: type %d, length %d\n",
 307          ValueName, ValueType, ValueLength);
 308
 309   if (REG_DWORD == ValueType && sizeof(DWORD) == ValueLength)
 310     {
 311       if (0 == _wcsicmp(ValueName, L"DefaultSettings.BitsPerPel"))
 312         {
 313           DevMode->dmBitsPerPel = *((DWORD *) ValueData);
 314         }
 315       else if (0 == _wcsicmp(ValueName, L"DefaultSettings.Flags"))
 316         {
 317           DevMode->dmDisplayFlags = *((DWORD *) ValueData);
 318         }
 319       else if (0 == _wcsicmp(ValueName, L"DefaultSettings.VRefresh"))
 320         {
 321           DevMode->dmDisplayFrequency = *((DWORD *) ValueData);
 322         }
 323       else if (0 == _wcsicmp(ValueName, L"DefaultSettings.XPanning"))
 324         {
 325           DevMode->dmPanningWidth = *((DWORD *) ValueData);
 326         }
 327       else if (0 == _wcsicmp(ValueName, L"DefaultSettings.XResolution"))
 328         {
 329           DevMode->dmPelsWidth = *((DWORD *) ValueData);
 330         }
 331       else if (0 == _wcsicmp(ValueName, L"DefaultSettings.YPanning"))
 332         {
 333           DevMode->dmPanningHeight = *((DWORD *) ValueData);
 334         }
 335       else if (0 == _wcsicmp(ValueName, L"DefaultSettings.YResolution"))
 336         {
 337           DevMode->dmPelsHeight = *((DWORD *) ValueData);
 338         }
 339     }
 340
 341   return STATUS_SUCCESS;
 342 }
 343
 344 static BOOL FASTCALL
 345 SetupDevMode(PDEVMODEW DevMode, ULONG DisplayNumber)
 346 {
 347   static WCHAR RegistryMachineSystem[] = L"\\REGISTRY\\MACHINE\\SYSTEM\\";
 348   static WCHAR CurrentControlSet[] = L"CURRENTCONTROLSET\\";
 349   static WCHAR ControlSet[] = L"CONTROLSET";
 350   static WCHAR Insert[] = L"Hardware Profiles\\Current\\System\\CurrentControlSet\\";
 351   UNICODE_STRING RegistryPath;
 352   BOOL Valid;
 353   PWCHAR AfterControlSet;
 354   PWCHAR ProfilePath;
 355   RTL_QUERY_REGISTRY_TABLE QueryTable[2];
 356   NTSTATUS Status;
 357
 358   if (! GetRegistryPath(&RegistryPath, DisplayNumber))
 359     {
 360       DPRINT("GetRegistryPath failed\n");
 361       return FALSE;
 362     }
 363
 364   Valid = (0 == _wcsnicmp(RegistryPath.Buffer, RegistryMachineSystem,
 365                           wcslen(RegistryMachineSystem)));
 366   if (Valid)
 367     {
 368       AfterControlSet = RegistryPath.Buffer + wcslen(RegistryMachineSystem);
 369       if (0 == _wcsnicmp(AfterControlSet, CurrentControlSet, wcslen(CurrentControlSet)))
 370         {
 371           AfterControlSet += wcslen(CurrentControlSet);
 372         }
 373       else if (0 == _wcsnicmp(AfterControlSet, ControlSet, wcslen(ControlSet)))
 374         {
 375           AfterControlSet += wcslen(ControlSet);
 376           while (L'0' <= *AfterControlSet && L'9' <= *AfterControlSet)
 377             {
 378               AfterControlSet++;
 379             }
 380           Valid = (L'\\' == *AfterControlSet);
 381           AfterControlSet++;
 382         }
 383       else
 384         {
 385           Valid = FALSE;
 386         }
 387     }
 388
 389   if (Valid)
 390     {
 391       ProfilePath = ExAllocatePoolWithTag(PagedPool,
 392                                           (wcslen(RegistryPath.Buffer) +
 393                                            wcslen(Insert) + 1) * sizeof(WCHAR),
 394                                           TAG_DC);
 395       if (NULL != ProfilePath)
 396         {
 397           wcsncpy(ProfilePath, RegistryPath.Buffer, AfterControlSet - RegistryPath.Buffer);
 398           wcscpy(ProfilePath + (AfterControlSet - RegistryPath.Buffer), Insert);
 399           wcscat(ProfilePath, AfterControlSet);
 400
 401           RtlZeroMemory(QueryTable, sizeof(QueryTable));
 402           QueryTable[0].QueryRoutine = DevModeCallback;
 403           QueryTable[0].Flags = 0;
 404           QueryTable[0].Name = NULL;
 405           QueryTable[0].EntryContext = NULL;
 406           QueryTable[0].DefaultType = REG_NONE;
 407           QueryTable[0].DefaultData = NULL;
 408           QueryTable[0].DefaultLength = 0;
 409
 410           Status = RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE,
 411                                           ProfilePath,
 412                                           QueryTable,
 413                                           DevMode,
 414                                           NULL);
 415           if (! NT_SUCCESS(Status))
 416             {
 417               DPRINT("RtlQueryRegistryValues for %S failed with status 0x%08x\n",
 418                      ProfilePath, Status);
 419               Valid = FALSE;
 420             }
 421           else
 422             {
 423               DPRINT("dmBitsPerPel %d dmDisplayFrequency %d dmPelsWidth %d dmPelsHeight %d\n",
 424                      DevMode->dmBitsPerPel, DevMode->dmDisplayFrequency,
 425                      DevMode->dmPelsWidth, DevMode->dmPelsHeight);
 426               if (0 == DevMode->dmBitsPerPel || 0 == DevMode->dmDisplayFrequency
 427                   || 0 == DevMode->dmPelsWidth || 0 == DevMode->dmPelsHeight)
 428                 {
 429                   DPRINT("Not all required devmode members are set\n");
 430                   Valid = FALSE;
 431                 }
 432             }
 433
 434           ExFreePool(ProfilePath);
 435         }
 436       else
 437         {
 438           Valid = FALSE;
 439         }
 440     }
 441   else
 442     {
 443       DPRINT1("Unparsable registry path %S in DEVICEMAP\\VIDEO0", RegistryPath.Buffer);
 444     }
 445
 446   RtlFreeUnicodeString(&RegistryPath);
 447
 448   if (! Valid)
 449     {
 450       RtlZeroMemory(DevMode, sizeof(DEVMODEW));
 451     }
 452
 453   return Valid;
 454 }
 455
 456 BOOL FASTCALL
 457 IntCreatePrimarySurface()
 458 {
 459    PGD_ENABLEDRIVER GDEnableDriver;
 460    DRVENABLEDATA DED;
 461    SURFOBJ *SurfObj;
 462    SIZEL SurfSize;
 463    UNICODE_STRING DriverFileNames;
 464    PWSTR CurrentName;
 465    BOOL GotDriver;
 466    BOOL DoDefault;
 467    ULONG DisplayNumber;
 468    RECTL SurfaceRect;
 469
 470    for (DisplayNumber = 0; ; DisplayNumber++)
 471    {
 472       DPRINT("Trying to load display driver no. %d\n", DisplayNumber);
 473
 474       RtlZeroMemory(&PrimarySurface, sizeof(PrimarySurface));
 475
 476       PrimarySurface.VideoFileObject = DRIVER_FindMPDriver(DisplayNumber);
 477
 478       /* Open the miniport driver  */
 479       if (PrimarySurface.VideoFileObject == NULL)
 480       {
 481          DPRINT1("FindMPDriver failed\n");
 482          return FALSE;
 483       }
 484
 485       /* Retrieve DDI driver names from registry */
 486       RtlInitUnicodeString(&DriverFileNames, NULL);
 487       if (!FindDriverFileNames(&DriverFileNames, DisplayNumber))
 488       {
 489          DPRINT1("FindDriverFileNames failed\n");
 490          /* return FALSE; */
 491          continue;
 492       }
 493
 494       /*
 495        * DriverFileNames may be a list of drivers in REG_SZ_MULTI format,
 496        * scan all of them until a good one found.
 497        */
 498       CurrentName = DriverFileNames.Buffer;
 499       GotDriver = FALSE;
 500       while (!GotDriver &&
 501              CurrentName < DriverFileNames.Buffer + (DriverFileNames.Length / sizeof (WCHAR)))
 502       {
 503          /* Get the DDI driver's entry point */
 504          GDEnableDriver = DRIVER_FindDDIDriver(CurrentName);
 505          if (NULL == GDEnableDriver)
 506          {
 507             DPRINT("FindDDIDriver failed for %S\n", CurrentName);
 508          }
 509          else
 510          {
 511             /*  Call DDI driver's EnableDriver function  */
 512             RtlZeroMemory(&DED, sizeof(DED));
 513
 514             if (! GDEnableDriver(DDI_DRIVER_VERSION_NT5_01, sizeof(DED), &DED))
 515             {
 516                DPRINT("DrvEnableDriver failed for %S\n", CurrentName);
 517             }
 518             else
 519             {
 520                GotDriver = TRUE;
 521             }
 522          }
 523
 524          if (! GotDriver)
 525          {
 526             /* Skip to the next name but never get past the Unicode string */
 527             while (L'\0' != *CurrentName &&
 528                    CurrentName < DriverFileNames.Buffer + (DriverFileNames.Length / sizeof (WCHAR)))
 529             {
 530                CurrentName++;
 531             }
 532             if (CurrentName < DriverFileNames.Buffer + (DriverFileNames.Length / sizeof (WCHAR)))
 533             {
 534                CurrentName++;
 535             }
 536          }
 537       }
 538
 539       RtlFreeUnicodeString(&DriverFileNames);
 540
 541       if (!GotDriver)
 542       {
 543          ObDereferenceObject(PrimarySurface.VideoFileObject);
 544          DPRINT1("No suitable DDI driver found\n");
 545          /* return FALSE; */
 546          continue;
 547       }
 548
 549       DPRINT("Display driver %S loaded\n", CurrentName);
 550
 551       DPRINT("Building DDI Functions\n");
 552
 553       /* Construct DDI driver function dispatch table */
 554       if (!DRIVER_BuildDDIFunctions(&DED, &PrimarySurface.DriverFunctions))
 555       {
 556          ObDereferenceObject(PrimarySurface.VideoFileObject);
 557          DPRINT1("BuildDDIFunctions failed\n");
 558          return FALSE;
 559       }
 560
 561       /* Allocate a phyical device handle from the driver */
 562       PrimarySurface.DMW.dmSize = sizeof (PrimarySurface.DMW);
 563       if (SetupDevMode(&PrimarySurface.DMW, DisplayNumber))
 564       {
 565          PrimarySurface.PDev = PrimarySurface.DriverFunctions.EnablePDEV(
 566             &PrimarySurface.DMW,
 567             L"",
 568             HS_DDI_MAX,
 569             PrimarySurface.FillPatterns,
 570             sizeof(PrimarySurface.GDIInfo),
 571             (ULONG *) &PrimarySurface.GDIInfo,
 572             sizeof(PrimarySurface.DevInfo),
 573             &PrimarySurface.DevInfo,
 574             NULL,
 575             L"",
 576             (HANDLE) (PrimarySurface.VideoFileObject->DeviceObject));
 577          DoDefault = (NULL == PrimarySurface.PDev);
 578          if (DoDefault)
 579          {
 580             DPRINT1("DrvEnablePDev with registry parameters failed\n");
 581          }
 582       }
 583       else
 584       {
 585          DoDefault = TRUE;
 586       }
 587
 588       if (DoDefault)
 589       {
 590          RtlZeroMemory(&(PrimarySurface.DMW), sizeof(DEVMODEW));
 591          PrimarySurface.DMW.dmSize = sizeof (PrimarySurface.DMW);
 592          PrimarySurface.PDev = PrimarySurface.DriverFunctions.EnablePDEV(
 593             &PrimarySurface.DMW,
 594             L"",
 595             HS_DDI_MAX,
 596             PrimarySurface.FillPatterns,
 597             sizeof(PrimarySurface.GDIInfo),
 598             (ULONG *) &PrimarySurface.GDIInfo,
 599             sizeof(PrimarySurface.DevInfo),
 600             &PrimarySurface.DevInfo,
 601             NULL,
 602             L"",
 603             (HANDLE) (PrimarySurface.VideoFileObject->DeviceObject));
 604
 605          if (NULL == PrimarySurface.PDev)
 606          {
 607             ObDereferenceObject(PrimarySurface.VideoFileObject);
 608             DPRINT1("DrvEnablePDEV with default parameters failed\n");
 609             DPRINT1("Perhaps DDI driver doesn't match miniport driver?\n");
 610             /* return FALSE; */
 611             continue;
 612          }
 613       }
 614
 615       if (0 == PrimarySurface.GDIInfo.ulLogPixelsX)
 616       {
 617          DPRINT("Adjusting GDIInfo.ulLogPixelsX\n");
 618          PrimarySurface.GDIInfo.ulLogPixelsX = 96;
 619       }
 620       if (0 == PrimarySurface.GDIInfo.ulLogPixelsY)
 621       {
 622          DPRINT("Adjusting GDIInfo.ulLogPixelsY\n");
 623          PrimarySurface.GDIInfo.ulLogPixelsY = 96;
 624       }
 625
 626       PrimarySurface.Pointer.Exclude.right = -1;
 627
 628       DPRINT("calling completePDev\n");
 629
 630       /* Complete initialization of the physical device */
 631       PrimarySurface.DriverFunctions.CompletePDEV(
 632          PrimarySurface.PDev,
 633          (HDEV)&PrimarySurface);
 634
 635       DPRINT("calling DRIVER_ReferenceDriver\n");
 636
 637       DRIVER_ReferenceDriver(L"DISPLAY");
 638
 639       DPRINT("calling EnableSurface\n");
 640
 641       /* Enable the drawing surface */
 642       PrimarySurface.Handle =
 643          PrimarySurface.DriverFunctions.EnableSurface(PrimarySurface.PDev);
 644       if (NULL == PrimarySurface.Handle)
 645       {
 646 /*         PrimarySurface.DriverFunctions.AssertMode(PrimarySurface.PDev, FALSE);*/
 647          PrimarySurface.DriverFunctions.DisablePDEV(PrimarySurface.PDev);
 648          ObDereferenceObject(PrimarySurface.VideoFileObject);
 649          DPRINT1("DrvEnableSurface failed\n");
 650          /* return FALSE; */
 651          continue;
 652       }
 653
 654       /* attach monitor */
 655       IntAttachMonitor(&PrimarySurface, DisplayNumber);
 656
 657       SurfObj = EngLockSurface((HSURF)PrimarySurface.Handle);
 658       SurfObj->dhpdev = PrimarySurface.PDev;
 659       SurfSize = SurfObj->sizlBitmap;
 660       SurfSize = SurfObj->sizlBitmap;
 661       SurfaceRect.left = SurfaceRect.top = 0;
 662       SurfaceRect.right = SurfObj->sizlBitmap.cx;
 663       SurfaceRect.bottom = SurfObj->sizlBitmap.cy;
 664       /* FIXME - why does EngEraseSurface() sometimes crash?
 665         EngEraseSurface(SurfObj, &SurfaceRect, 0); */
 666       EngUnlockSurface(SurfObj);
 667       break;
 668    }
 669
 670    return TRUE;
 671 }
 672
 673 VOID FASTCALL
 674 IntDestroyPrimarySurface()
 675   {
 676     DRIVER_UnreferenceDriver(L"DISPLAY");
 677
 678     /* detach monitor */
 679     IntDetachMonitor(&PrimarySurface);
 680
 681     /*
 682      * FIXME: Hide a mouse pointer there. Also because we have to prevent
 683      * memory leaks with the Eng* mouse routines.
 684      */
 685
 686     DPRINT("Reseting display\n" );
 687     PrimarySurface.DriverFunctions.AssertMode(PrimarySurface.PDev, FALSE);
 688     PrimarySurface.DriverFunctions.DisableSurface(PrimarySurface.PDev);
 689     PrimarySurface.DriverFunctions.DisablePDEV(PrimarySurface.PDev);
 690
 691     DceEmptyCache();
 692
 693     ObDereferenceObject(PrimarySurface.VideoFileObject);
 694   }
 695
 696 HDC FASTCALL
 697 IntGdiCreateDC(PUNICODE_STRING Driver,
 698                PUNICODE_STRING Device,
 699                PUNICODE_STRING Output,
 700                CONST PDEVMODEW InitData)
 701 {
 702   HDC      hNewDC;
 703   PDC      NewDC;
 704   HDC      hDC = NULL;
 705   SURFOBJ *SurfObj;
 706   HRGN     hVisRgn;
 707   UNICODE_STRING StdDriver;
 708
 709   RtlInitUnicodeString(&StdDriver, L"DISPLAY");
 710
 711   if (NULL == Driver || 0 == RtlCompareUnicodeString(Driver, &StdDriver, TRUE))
 712     {
 713       if (! IntGraphicsCheck(TRUE))
 714         {
 715           DPRINT1("Unable to initialize graphics, returning NULL dc\n");
 716           return NULL;
 717         }
 718     }
 719
 720   /*  Check for existing DC object  */
 721   if ((hNewDC = DC_FindOpenDC(Driver)) != NULL)
 722   {
 723     hDC = hNewDC;
 724     return  NtGdiCreateCompatableDC(hDC);
 725   }
 726
 727   if (Driver != NULL && Driver->Buffer != NULL)
 728   {
 729     DPRINT("NAME: %S\n", Driver->Buffer); // FIXME: Should not crash if NULL
 730   }
 731
 732   /*  Allocate a DC object  */
 733   if ((hNewDC = DC_AllocDC(Driver)) == NULL)
 734   {
 735     return  NULL;
 736   }
 737
 738   NewDC = DC_LockDc( hNewDC );
 739   /* FIXME - NewDC can be NULL!!! Don't assert here! */
 740   if ( !NewDC )
 741   {
 742     DC_FreeDC( hNewDC );
 743     return NULL;
 744   }
 745
 746   NewDC->DMW = PrimarySurface.DMW;
 747   NewDC->DevInfo = &PrimarySurface.DevInfo;
 748   NewDC->GDIInfo = &PrimarySurface.GDIInfo;
 749   memcpy(NewDC->FillPatternSurfaces, PrimarySurface.FillPatterns,
 750          sizeof(NewDC->FillPatternSurfaces));
 751   NewDC->PDev = PrimarySurface.PDev;
 752   NewDC->GDIDevice = (HDEV)&PrimarySurface;
 753   NewDC->DriverFunctions = PrimarySurface.DriverFunctions;
 754   NewDC->w.hBitmap = PrimarySurface.Handle;
 755
 756   NewDC->DMW.dmSize = sizeof(NewDC->DMW);
 757   NewDC->DMW.dmFields = 0x000fc000;
 758
 759   /* FIXME: get mode selection information from somewhere  */
 760
 761   NewDC->DMW.dmLogPixels = 96;
 762   SurfObj = EngLockSurface((HSURF)PrimarySurface.Handle);
 763   if ( !SurfObj )
 764   {
 765           DC_UnlockDc ( hNewDC );
 766           DC_FreeDC ( hNewDC) ;
 767           return NULL;
 768   }
 769   NewDC->DMW.dmBitsPerPel = BitsPerFormat(SurfObj->iBitmapFormat);
 770   NewDC->DMW.dmPelsWidth = SurfObj->sizlBitmap.cx;
 771   NewDC->DMW.dmPelsHeight = SurfObj->sizlBitmap.cy;
 772   NewDC->DMW.dmDisplayFlags = 0;
 773   NewDC->DMW.dmDisplayFrequency = 0;
 774
 775   NewDC->w.bitsPerPixel = NewDC->DMW.dmBitsPerPel; // FIXME: set this here??
 776
 777   NewDC->w.hPalette = NewDC->DevInfo->hpalDefault;
 778
 779   DPRINT("Bits per pel: %u\n", NewDC->w.bitsPerPixel);
 780
 781   DC_UnlockDc( hNewDC );
 782
 783   hVisRgn = NtGdiCreateRectRgn(0, 0, SurfObj->sizlBitmap.cx,
 784                               SurfObj->sizlBitmap.cy);
 785   NtGdiSelectVisRgn(hNewDC, hVisRgn);
 786   NtGdiDeleteObject(hVisRgn);
 787
 788   /*  Initialize the DC state  */
 789   DC_InitDC(hNewDC);
 790   NtGdiSetTextColor(hNewDC, RGB(0, 0, 0));
 791   NtGdiSetTextAlign(hNewDC, TA_TOP);
 792   NtGdiSetBkColor(hNewDC, RGB(255, 255, 255));
 793   NtGdiSetBkMode(hNewDC, OPAQUE);
 794
 795   EngUnlockSurface(SurfObj);
 796
 797   return hNewDC;
 798 }
 799
 800 HDC STDCALL
 801 NtGdiCreateDC(PUNICODE_STRING Driver,
 802               PUNICODE_STRING Device,
 803               PUNICODE_STRING Output,
 804               CONST PDEVMODEW InitData)
 805 {
 806   UNICODE_STRING SafeDriver, SafeDevice;
 807   DEVMODEW SafeInitData;
 808   HDC Ret;
 809   NTSTATUS Status;
 810
 811   if(InitData)
 812   {
 813     Status = MmCopyFromCaller(&SafeInitData, InitData, sizeof(DEVMODEW));
 814     if(!NT_SUCCESS(Status))
 815     {
 816       SetLastNtError(Status);
 817       return NULL;
 818     }
 819     /* FIXME - InitData can have some more bytes! */
 820   }
 821
 822   if(Driver)
 823   {
 824     Status = IntSafeCopyUnicodeString(&SafeDriver, Driver);
 825     if(!NT_SUCCESS(Status))
 826     {
 827       SetLastNtError(Status);
 828       return NULL;
 829     }
 830   }
 831
 832   if(Device)
 833   {
 834     Status = IntSafeCopyUnicodeString(&SafeDevice, Device);
 835     if(!NT_SUCCESS(Status))
 836     {
 837       RtlFreeUnicodeString(&SafeDriver);
 838       SetLastNtError(Status);
 839       return NULL;
 840     }
 841   }
 842
 843   Ret = IntGdiCreateDC(&SafeDriver, &SafeDevice, NULL, &SafeInitData);
 844
 845   return Ret;
 846 }
 847
 848 HDC STDCALL
 849 NtGdiCreateIC(PUNICODE_STRING Driver,
 850               PUNICODE_STRING Device,
 851               PUNICODE_STRING Output,
 852               CONST PDEVMODEW DevMode)
 853 {
 854   /* FIXME: this should probably do something else...  */
 855   return  NtGdiCreateDC(Driver, Device, Output, DevMode);
 856 }
 857
 858 BOOL STDCALL
 859 NtGdiDeleteDC(HDC  DCHandle)
 860 {
 861   PDC  DCToDelete;
 862
 863   DCToDelete = DC_LockDc(DCHandle);
 864   if (DCToDelete == NULL)
 865     {
 866       return  FALSE;
 867     }
 868
 869   /*  First delete all saved DCs  */
 870   while (DCToDelete->saveLevel)
 871   {
 872     PDC  savedDC;
 873     HDC  savedHDC;
 874
 875     savedHDC = DC_GetNextDC (DCToDelete);
 876     savedDC = DC_LockDc (savedHDC);
 877     if (savedDC == NULL)
 878     {
 879       break;
 880     }
 881     DC_SetNextDC (DCToDelete, DC_GetNextDC (savedDC));
 882     DCToDelete->saveLevel--;
 883     DC_UnlockDc( savedHDC );
 884     NtGdiDeleteDC (savedHDC);
 885   }
 886
 887   /*  Free GDI resources allocated to this DC  */
 888   if (!(DCToDelete->w.flags & DC_SAVED))
 889   {
 890     /*
 891     NtGdiSelectObject (DCHandle, STOCK_BLACK_PEN);
 892     NtGdiSelectObject (DCHandle, STOCK_WHITE_BRUSH);
 893     NtGdiSelectObject (DCHandle, STOCK_SYSTEM_FONT);
 894     DC_LockDC (DCHandle); NtGdiSelectObject does not recognize stock objects yet  */
 895     if (DCToDelete->w.flags & DC_MEMORY)
 896     {
 897       NtGdiDeleteObject (DCToDelete->w.hFirstBitmap);
 898     }
 899     if (DCToDelete->XlateBrush != NULL)
 900       EngDeleteXlate(DCToDelete->XlateBrush);
 901     if (DCToDelete->XlatePen != NULL)
 902       EngDeleteXlate(DCToDelete->XlatePen);
 903   }
 904   if (DCToDelete->w.hClipRgn)
 905   {
 906     NtGdiDeleteObject (DCToDelete->w.hClipRgn);
 907   }
 908   if (DCToDelete->w.hVisRgn)
 909   {
 910     NtGdiDeleteObject (DCToDelete->w.hVisRgn);
 911   }
 912   if (NULL != DCToDelete->CombinedClip)
 913     {
 914       IntEngDeleteClipRegion(DCToDelete->CombinedClip);
 915     }
 916   if (DCToDelete->w.hGCClipRgn)
 917   {
 918     NtGdiDeleteObject (DCToDelete->w.hGCClipRgn);
 919   }
 920 #if 0 /* FIXME */
 921   PATH_DestroyGdiPath (&DCToDelete->w.path);
 922 #endif
 923   DC_UnlockDc( DCHandle );
 924   DC_FreeDC ( DCHandle );
 925
 926   return TRUE;
 927 }
 928
 929 INT STDCALL
 930 NtGdiDrawEscape(HDC  hDC,
 931                INT  nEscape,
 932                INT  cbInput,
 933                LPCSTR  lpszInData)
 934 {
 935   UNIMPLEMENTED;
 936   return 0;
 937 }
 938
 939 INT STDCALL
 940 NtGdiEnumObjects(HDC  hDC,
 941                 INT  ObjectType,
 942                 GOBJENUMPROC  ObjectFunc,
 943                 LPARAM  lParam)
 944 {
 945   UNIMPLEMENTED;
 946   return 0;
 947 }
 948
 949 DC_GET_VAL( COLORREF, NtGdiGetBkColor, w.backgroundColor )
 950 DC_GET_VAL( INT, NtGdiGetBkMode, w.backgroundMode )
 951 DC_GET_VAL_EX( GetBrushOrgEx, w.brushOrgX, w.brushOrgY, POINT, x, y )
 952 DC_GET_VAL( HRGN, NtGdiGetClipRgn, w.hClipRgn )
 953
 954 HGDIOBJ STDCALL
 955 NtGdiGetCurrentObject(HDC  hDC, UINT  ObjectType)
 956 {
 957   HGDIOBJ SelObject;
 958   DC *dc;
 959
 960   if(!(dc = DC_LockDc(hDC)))
 961   {
 962     SetLastWin32Error(ERROR_INVALID_HANDLE);
 963     return NULL;
 964   }
 965
 966   switch(ObjectType)
 967   {
 968     case OBJ_PEN:
 969       SelObject = dc->w.hPen;
 970       break;
 971     case OBJ_BRUSH:
 972       SelObject = dc->w.hBrush;
 973       break;
 974     case OBJ_PAL:
 975       DPRINT1("FIXME: NtGdiGetCurrentObject() ObjectType OBJ_PAL not supported yet!\n");
 976       SelObject = NULL;
 977       break;
 978     case OBJ_FONT:
 979       SelObject = dc->w.hFont;
 980       break;
 981     case OBJ_BITMAP:
 982       SelObject = dc->w.hBitmap;
 983       break;
 984     case OBJ_COLORSPACE:
 985       DPRINT1("FIXME: NtGdiGetCurrentObject() ObjectType OBJ_COLORSPACE not supported yet!\n");
 986       SelObject = NULL;
 987       break;
 988     default:
 989       SelObject = NULL;
 990       SetLastWin32Error(ERROR_INVALID_PARAMETER);
 991       break;
 992   }
 993
 994   DC_UnlockDc(hDC);
 995   return SelObject;
 996 }
 997
 998 DC_GET_VAL_EX ( GetCurrentPositionEx, w.CursPosX, w.CursPosY, POINT, x, y )
 999
1000 BOOL FASTCALL
1001 IntGdiGetDCOrgEx(DC *dc, LPPOINT  Point)
1002 {
1003   Point->x = dc->w.DCOrgX;
1004   Point->y = dc->w.DCOrgY;
1005
1006   return  TRUE;
1007 }
1008
1009 BOOL STDCALL
1010 NtGdiGetDCOrgEx(HDC  hDC, LPPOINT  Point)
1011 {
1012   BOOL Ret;
1013   DC *dc;
1014   POINT SafePoint;
1015   NTSTATUS Status;
1016
1017   if(!Point)
1018   {
1019     SetLastWin32Error(ERROR_INVALID_PARAMETER);
1020     return FALSE;
1021   }
1022
1023   dc = DC_LockDc(hDC);
1024   if(!dc)
1025   {
1026     SetLastWin32Error(ERROR_INVALID_HANDLE);
1027     return FALSE;
1028   }
1029
1030   Ret = IntGdiGetDCOrgEx(dc, &SafePoint);
1031
1032   Status = MmCopyToCaller(Point, &SafePoint, sizeof(POINT));
1033   if(!NT_SUCCESS(Status))
1034   {
1035     SetLastNtError(Status);
1036     DC_UnlockDc(hDC);
1037     return FALSE;
1038   }
1039
1040   DC_UnlockDc(hDC);
1041   return Ret;
1042 }
1043
1044 COLORREF STDCALL
1045 NtGdiSetBkColor(HDC hDC, COLORREF color)
1046 {
1047   COLORREF oldColor;
1048   PDC dc;
1049   HBRUSH hBrush;
1050
1051   if (!(dc = DC_LockDc(hDC)))
1052   {
1053     SetLastWin32Error(ERROR_INVALID_HANDLE);
1054     return CLR_INVALID;
1055   }
1056
1057   oldColor = dc->w.backgroundColor;
1058   dc->w.backgroundColor = color;
1059   hBrush = dc->w.hBrush;
1060   DC_UnlockDc ( hDC );
1061   NtGdiSelectObject(hDC, hBrush);
1062   return oldColor;
1063 }
1064
1065 HDC STDCALL
1066 NtGdiGetDCState(HDC  hDC)
1067 {
1068   PDC  newdc, dc;
1069   HDC hnewdc;
1070
1071   dc = DC_LockDc(hDC);
1072   if (dc == NULL)
1073   {
1074     SetLastWin32Error(ERROR_INVALID_HANDLE);
1075     return 0;
1076   }
1077
1078   hnewdc = DC_AllocDC(NULL);
1079   if (hnewdc == NULL)
1080   {
1081     DC_UnlockDc( hDC );
1082     return 0;
1083   }
1084   newdc = DC_LockDc( hnewdc );
1085   /* FIXME - newdc can be NULL!!!! Don't assert here!!! */
1086   ASSERT( newdc );
1087
1088   newdc->w.flags            = dc->w.flags | DC_SAVED;
1089   newdc->w.hPen             = dc->w.hPen;
1090   newdc->w.hBrush           = dc->w.hBrush;
1091   newdc->w.hFont            = dc->w.hFont;
1092   newdc->w.hBitmap          = dc->w.hBitmap;
1093   newdc->w.hFirstBitmap     = dc->w.hFirstBitmap;
1094 #if 0
1095   newdc->w.hDevice          = dc->w.hDevice;
1096 #endif
1097   newdc->w.hPalette         = dc->w.hPalette;
1098   newdc->w.totalExtent      = dc->w.totalExtent;
1099   newdc->w.bitsPerPixel     = dc->w.bitsPerPixel;
1100   newdc->w.ROPmode          = dc->w.ROPmode;
1101   newdc->w.polyFillMode     = dc->w.polyFillMode;
1102   newdc->w.stretchBltMode   = dc->w.stretchBltMode;
1103   newdc->w.relAbsMode       = dc->w.relAbsMode;
1104   newdc->w.backgroundMode   = dc->w.backgroundMode;
1105   newdc->w.backgroundColor  = dc->w.backgroundColor;
1106   newdc->w.textColor        = dc->w.textColor;
1107   newdc->w.brushOrgX        = dc->w.brushOrgX;
1108   newdc->w.brushOrgY        = dc->w.brushOrgY;
1109   newdc->w.textAlign        = dc->w.textAlign;
1110   newdc->w.charExtra        = dc->w.charExtra;
1111   newdc->w.breakTotalExtra  = dc->w.breakTotalExtra;
1112   newdc->w.breakCount       = dc->w.breakCount;
1113   newdc->w.breakExtra       = dc->w.breakExtra;
1114   newdc->w.breakRem         = dc->w.breakRem;
1115   newdc->w.MapMode          = dc->w.MapMode;
1116   newdc->w.GraphicsMode     = dc->w.GraphicsMode;
1117 #if 0
1118   /* Apparently, the DC origin is not changed by [GS]etDCState */
1119   newdc->w.DCOrgX           = dc->w.DCOrgX;
1120   newdc->w.DCOrgY           = dc->w.DCOrgY;
1121 #endif
1122   newdc->w.CursPosX         = dc->w.CursPosX;
1123   newdc->w.CursPosY         = dc->w.CursPosY;
1124   newdc->w.ArcDirection     = dc->w.ArcDirection;
1125   newdc->w.xformWorld2Wnd   = dc->w.xformWorld2Wnd;
1126   newdc->w.xformWorld2Vport = dc->w.xformWorld2Vport;
1127   newdc->w.xformVport2World = dc->w.xformVport2World;
1128   newdc->w.vport2WorldValid = dc->w.vport2WorldValid;
1129   newdc->wndOrgX            = dc->wndOrgX;
1130   newdc->wndOrgY            = dc->wndOrgY;
1131   newdc->wndExtX            = dc->wndExtX;
1132   newdc->wndExtY            = dc->wndExtY;
1133   newdc->vportOrgX          = dc->vportOrgX;
1134   newdc->vportOrgY          = dc->vportOrgY;
1135   newdc->vportExtX          = dc->vportExtX;
1136   newdc->vportExtY          = dc->vportExtY;
1137
1138   newdc->hSelf = hnewdc;
1139   newdc->saveLevel = 0;
1140
1141 #if 0
1142   PATH_InitGdiPath( &newdc->w.path );
1143 #endif
1144
1145   /* Get/SetDCState() don't change hVisRgn field ("Undoc. Windows" p.559). */
1146
1147   newdc->w.hGCClipRgn = newdc->w.hVisRgn = 0;
1148   if (dc->w.hClipRgn)
1149   {
1150     newdc->w.hClipRgn = NtGdiCreateRectRgn( 0, 0, 0, 0 );
1151     NtGdiCombineRgn( newdc->w.hClipRgn, dc->w.hClipRgn, 0, RGN_COPY );
1152   }
1153   DC_UnlockDc( hnewdc );
1154   DC_UnlockDc( hDC );
1155   return  hnewdc;
1156 }
1157
1158
1159 VOID
1160 STDCALL
1161 NtGdiSetDCState ( HDC hDC, HDC hDCSave )
1162 {
1163   PDC  dc, dcs;
1164
1165   dc = DC_LockDc ( hDC );
1166   if ( dc )
1167   {
1168     dcs = DC_LockDc ( hDCSave );
1169     if ( dcs )
1170     {
1171       if ( dcs->w.flags & DC_SAVED )
1172       {
1173         dc->w.flags            = dcs->w.flags & ~DC_SAVED;
1174
1175         dc->w.hFirstBitmap     = dcs->w.hFirstBitmap;
1176
1177 #if 0
1178         dc->w.hDevice          = dcs->w.hDevice;
1179 #endif
1180
1181         dc->w.totalExtent      = dcs->w.totalExtent;
1182         dc->w.ROPmode          = dcs->w.ROPmode;
1183         dc->w.polyFillMode     = dcs->w.polyFillMode;
1184         dc->w.stretchBltMode   = dcs->w.stretchBltMode;
1185         dc->w.relAbsMode       = dcs->w.relAbsMode;
1186         dc->w.backgroundMode   = dcs->w.backgroundMode;
1187         dc->w.backgroundColor  = dcs->w.backgroundColor;
1188         dc->w.textColor        = dcs->w.textColor;
1189         dc->w.brushOrgX        = dcs->w.brushOrgX;
1190         dc->w.brushOrgY        = dcs->w.brushOrgY;
1191         dc->w.textAlign        = dcs->w.textAlign;
1192         dc->w.charExtra        = dcs->w.charExtra;
1193         dc->w.breakTotalExtra  = dcs->w.breakTotalExtra;
1194         dc->w.breakCount       = dcs->w.breakCount;
1195         dc->w.breakExtra       = dcs->w.breakExtra;
1196         dc->w.breakRem         = dcs->w.breakRem;
1197         dc->w.MapMode          = dcs->w.MapMode;
1198         dc->w.GraphicsMode     = dcs->w.GraphicsMode;
1199 #if 0
1200         /* Apparently, the DC origin is not changed by [GS]etDCState */
1201         dc->w.DCOrgX           = dcs->w.DCOrgX;
1202         dc->w.DCOrgY           = dcs->w.DCOrgY;
1203 #endif
1204         dc->w.CursPosX         = dcs->w.CursPosX;
1205         dc->w.CursPosY         = dcs->w.CursPosY;
1206         dc->w.ArcDirection     = dcs->w.ArcDirection;
1207
1208         dc->w.xformWorld2Wnd   = dcs->w.xformWorld2Wnd;
1209         dc->w.xformWorld2Vport = dcs->w.xformWorld2Vport;
1210         dc->w.xformVport2World = dcs->w.xformVport2World;
1211         dc->w.vport2WorldValid = dcs->w.vport2WorldValid;
1212
1213         dc->wndOrgX            = dcs->wndOrgX;
1214         dc->wndOrgY            = dcs->wndOrgY;
1215         dc->wndExtX            = dcs->wndExtX;
1216         dc->wndExtY            = dcs->wndExtY;
1217         dc->vportOrgX          = dcs->vportOrgX;
1218         dc->vportOrgY          = dcs->vportOrgY;
1219         dc->vportExtX          = dcs->vportExtX;
1220         dc->vportExtY          = dcs->vportExtY;
1221
1222         if (!(dc->w.flags & DC_MEMORY))
1223         {
1224           dc->w.bitsPerPixel = dcs->w.bitsPerPixel;
1225         }
1226
1227 #if 0
1228         if (dcs->w.hClipRgn)
1229         {
1230           if (!dc->w.hClipRgn)
1231           {
1232             dc->w.hClipRgn = NtGdiCreateRectRgn( 0, 0, 0, 0 );
1233           }
1234           NtGdiCombineRgn( dc->w.hClipRgn, dcs->w.hClipRgn, 0, RGN_COPY );
1235         }
1236         else
1237         {
1238           if (dc->w.hClipRgn)
1239           {
1240             NtGdiDeleteObject( dc->w.hClipRgn );
1241           }
1242
1243           dc->w.hClipRgn = 0;
1244         }
1245         {
1246                 int res;
1247                 res = CLIPPING_UpdateGCRegion( dc );
1248                 ASSERT ( res != ERROR );
1249         }
1250         DC_UnlockDc ( hDC );
1251 #else
1252         DC_UnlockDc ( hDC );
1253         NtGdiSelectClipRgn(hDC, dcs->w.hClipRgn);
1254 #endif
1255
1256         NtGdiSelectObject( hDC, dcs->w.hBitmap );
1257         NtGdiSelectObject( hDC, dcs->w.hBrush );
1258         NtGdiSelectObject( hDC, dcs->w.hFont );
1259         NtGdiSelectObject( hDC, dcs->w.hPen );
1260         NtGdiSetBkColor( hDC, dcs->w.backgroundColor);
1261         NtGdiSetTextColor( hDC, dcs->w.textColor);
1262
1263         NtGdiSelectPalette( hDC, dcs->w.hPalette, FALSE );
1264
1265 #if 0
1266         GDISelectPalette16( hDC, dcs->w.hPalette, FALSE );
1267 #endif
1268       } else {
1269         DC_UnlockDc(hDC);
1270       }
1271       DC_UnlockDc ( hDCSave );
1272     } else {
1273       DC_UnlockDc ( hDC );
1274       SetLastWin32Error(ERROR_INVALID_HANDLE);
1275     }
1276   }
1277   else
1278     SetLastWin32Error(ERROR_INVALID_HANDLE);
1279 }
1280
1281 INT FASTCALL
1282 IntGdiGetDeviceCaps(PDC dc, INT Index)
1283 {
1284   INT ret;
1285   POINT  pt;
1286
1287   /* Retrieve capability */
1288   switch (Index)
1289   {
1290     case DRIVERVERSION:
1291       ret = dc->GDIInfo->ulVersion;
1292       break;
1293
1294     case TECHNOLOGY:
1295       ret = dc->GDIInfo->ulTechnology;
1296       break;
1297
1298     case HORZSIZE:
1299       ret = dc->GDIInfo->ulHorzSize;
1300       break;
1301
1302     case VERTSIZE:
1303       ret = dc->GDIInfo->ulVertSize;
1304       break;
1305
1306     case HORZRES:
1307       ret = dc->GDIInfo->ulHorzRes;
1308       break;
1309
1310     case VERTRES:
1311       ret = dc->GDIInfo->ulVertRes;
1312       break;
1313
1314     case LOGPIXELSX:
1315       ret = dc->GDIInfo->ulLogPixelsX;
1316       break;
1317
1318     case LOGPIXELSY:
1319       ret = dc->GDIInfo->ulLogPixelsY;
1320       break;
1321
1322     case BITSPIXEL:
1323       ret = dc->GDIInfo->cBitsPixel;
1324       break;
1325
1326     case PLANES:
1327       ret = dc->GDIInfo->cPlanes;
1328       break;
1329
1330     case NUMBRUSHES:
1331       UNIMPLEMENTED; /* FIXME */
1332       break;
1333
1334     case NUMPENS:
1335       UNIMPLEMENTED; /* FIXME */
1336       break;
1337
1338     case NUMFONTS:
1339       UNIMPLEMENTED; /* FIXME */
1340       break;
1341
1342     case NUMCOLORS:
1343       ret = dc->GDIInfo->ulNumColors;
1344       break;
1345
1346     case ASPECTX:
1347       ret = dc->GDIInfo->ulAspectX;
1348       break;
1349
1350     case ASPECTY:
1351       ret = dc->GDIInfo->ulAspectY;
1352       break;
1353
1354     case ASPECTXY:
1355       ret = dc->GDIInfo->ulAspectXY;
1356       break;
1357
1358     case PDEVICESIZE:
1359       UNIMPLEMENTED; /* FIXME */
1360       break;
1361
1362     case CLIPCAPS:
1363       UNIMPLEMENTED; /* FIXME */
1364       break;
1365
1366     case SIZEPALETTE:
1367       ret = dc->GDIInfo->ulNumPalReg; /* FIXME not sure */
1368       break;
1369
1370     case NUMRESERVED:
1371       ret = 0;
1372       break;
1373
1374     case COLORRES:
1375       UNIMPLEMENTED; /* FIXME */
1376       break;
1377
1378     case PHYSICALWIDTH:
1379       if(IntGdiEscape(dc, GETPHYSPAGESIZE, 0, NULL, (LPVOID)&pt) > 0)
1380       {
1381         ret = pt.x;
1382       }
1383       else
1384       {
1385         ret = 0;
1386       }
1387       break;
1388
1389     case PHYSICALHEIGHT:
1390       if(IntGdiEscape(dc, GETPHYSPAGESIZE, 0, NULL, (LPVOID)&pt) > 0)
1391       {
1392         ret = pt.y;
1393       }
1394       else
1395       {
1396         ret = 0;
1397       }
1398       break;
1399
1400     case PHYSICALOFFSETX:
1401       if(IntGdiEscape(dc, GETPRINTINGOFFSET, 0, NULL, (LPVOID)&pt) > 0)
1402       {
1403         ret = pt.x;
1404       }
1405       else
1406       {
1407         ret = 0;
1408       }
1409       break;
1410
1411     case PHYSICALOFFSETY:
1412       if(IntGdiEscape(dc, GETPRINTINGOFFSET, 0, NULL, (LPVOID)&pt) > 0)
1413       {
1414         ret = pt.y;
1415       }
1416       else
1417       {
1418         ret = 0;
1419       }
1420       break;
1421
1422     case VREFRESH:
1423       UNIMPLEMENTED; /* FIXME */
1424       break;
1425
1426     case SCALINGFACTORX:
1427       if(IntGdiEscape(dc, GETSCALINGFACTOR, 0, NULL, (LPVOID)&pt) > 0)
1428       {
1429         ret = pt.x;
1430       }
1431       else
1432       {
1433         ret = 0;
1434       }
1435       break;
1436
1437     case SCALINGFACTORY:
1438       if(IntGdiEscape(dc, GETSCALINGFACTOR, 0, NULL, (LPVOID)&pt) > 0)
1439       {
1440         ret = pt.y;
1441       }
1442       else
1443       {
1444         ret = 0;
1445       }
1446       break;
1447
1448     case RASTERCAPS:
1449       ret = dc->GDIInfo->flRaster;
1450       break;
1451
1452     case CURVECAPS:
1453       UNIMPLEMENTED; /* FIXME */
1454       break;
1455
1456     case LINECAPS:
1457       UNIMPLEMENTED; /* FIXME */
1458       break;
1459
1460     case POLYGONALCAPS:
1461       UNIMPLEMENTED; /* FIXME */
1462       break;
1463
1464     case TEXTCAPS:
1465       ret = dc->GDIInfo->flTextCaps;
1466       break;
1467
1468     default:
1469       ret = 0;
1470       break;
1471   }
1472
1473   return ret;
1474 }
1475
1476 INT STDCALL
1477 NtGdiGetDeviceCaps(HDC  hDC,
1478                   INT  Index)
1479 {
1480   PDC  dc;
1481   INT  ret;
1482
1483   dc = DC_LockDc(hDC);
1484   if (dc == NULL)
1485   {
1486     SetLastWin32Error(ERROR_INVALID_HANDLE);
1487     return 0;
1488   }
1489
1490   ret = IntGdiGetDeviceCaps(dc, Index);
1491
1492   DPRINT("(%04x,%d): returning %d\n", hDC, Index, ret);
1493
1494   DC_UnlockDc( hDC );
1495   return ret;
1496 }
1497
1498 DC_GET_VAL( INT, NtGdiGetMapMode, w.MapMode )
1499 DC_GET_VAL( INT, NtGdiGetPolyFillMode, w.polyFillMode )
1500
1501 INT FASTCALL
1502 IntGdiGetObject(HANDLE Handle, INT Count, LPVOID Buffer)
1503 {
1504   PVOID GdiObject;
1505   INT Result = 0;
1506   DWORD ObjectType;
1507
1508   GdiObject = GDIOBJ_LockObj(Handle, GDI_OBJECT_TYPE_DONTCARE);
1509   if (NULL == GdiObject)
1510     {
1511       SetLastWin32Error(ERROR_INVALID_HANDLE);
1512       return 0;
1513     }
1514
1515   ObjectType = GDIOBJ_GetObjectType(Handle);
1516   switch (ObjectType)
1517     {
1518 #if 0
1519       case GDI_OBJECT_TYPE_PEN:
1520         Result = PEN_GetObject((PENOBJ *) GdiObject, Count, Buffer);
1521         break;
1522       case GDI_OBJECT_TYPE_BRUSH:
1523         Result = BRUSH_GetObject((BRUSHOBJ *) GdiObject, Count, Buffer);
1524         break;
1525 #endif
1526       case GDI_OBJECT_TYPE_BITMAP:
1527         Result = BITMAP_GetObject((BITMAPOBJ *) GdiObject, Count, Buffer);
1528         break;
1529       case GDI_OBJECT_TYPE_FONT:
1530         Result = FontGetObject((PTEXTOBJ) GdiObject, Count, Buffer);
1531 #if 0
1532         // Fix the LOGFONT structure for the stock fonts
1533         if (FIRST_STOCK_HANDLE <= Handle && Handle <= LAST_STOCK_HANDLE)
1534           {
1535             FixStockFontSizeW(Handle, Count, Buffer);
1536           }
1537 #endif
1538         break;
1539 #if 0
1540       case GDI_OBJECT_TYPE_PALETTE:
1541         Result = PALETTE_GetObject((PALETTEOBJ *) GdiObject, Count, Buffer);
1542         break;
1543 #endif
1544       default:
1545         DPRINT1("GDI object type 0x%08x not implemented\n", ObjectType);
1546         break;
1547     }
1548
1549   GDIOBJ_UnlockObj(Handle);
1550
1551   return Result;
1552 }
1553
1554 INT STDCALL
1555 NtGdiGetObject(HANDLE handle, INT count, LPVOID buffer)
1556 {
1557   INT Ret;
1558   LPVOID SafeBuf;
1559   NTSTATUS Status;
1560
1561   if (count <= 0)
1562   {
1563     return 0;
1564   }
1565
1566   SafeBuf = ExAllocatePoolWithTag(PagedPool, count, TAG_GDIOBJ);
1567   if(!SafeBuf)
1568   {
1569     SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
1570     return 0;
1571   }
1572
1573   Ret = IntGdiGetObject(handle, count, SafeBuf);
1574
1575   Status = MmCopyToCaller(buffer, SafeBuf, count);
1576   ExFreePool(SafeBuf);
1577   if(!NT_SUCCESS(Status))
1578   {
1579     SetLastNtError(Status);
1580     return 0;
1581   }
1582
1583   return Ret;
1584 }
1585
1586 DWORD STDCALL
1587 NtGdiGetObjectType(HANDLE handle)
1588 {
1589   GDIOBJHDR * ptr;
1590   INT result;
1591   DWORD objectType;
1592
1593   ptr = GDIOBJ_LockObj(handle, GDI_OBJECT_TYPE_DONTCARE);
1594   if (ptr == 0)
1595   {
1596     SetLastWin32Error(ERROR_INVALID_HANDLE);
1597     return 0;
1598   }
1599
1600   objectType = GDIOBJ_GetObjectType(handle);
1601   switch(objectType)
1602   {
1603     case GDI_OBJECT_TYPE_PEN:
1604       result = OBJ_PEN;
1605       break;
1606     case GDI_OBJECT_TYPE_BRUSH:
1607       result = OBJ_BRUSH;
1608       break;
1609     case GDI_OBJECT_TYPE_BITMAP:
1610       result = OBJ_BITMAP;
1611       break;
1612     case GDI_OBJECT_TYPE_FONT:
1613       result = OBJ_FONT;
1614       break;
1615     case GDI_OBJECT_TYPE_PALETTE:
1616       result = OBJ_PAL;
1617       break;
1618     case GDI_OBJECT_TYPE_REGION:
1619       result = OBJ_REGION;
1620       break;
1621     case GDI_OBJECT_TYPE_DC:
1622       result = OBJ_DC;
1623       break;
1624     case GDI_OBJECT_TYPE_METADC:
1625       result = OBJ_METADC;
1626       break;
1627     case GDI_OBJECT_TYPE_METAFILE:
1628       result = OBJ_METAFILE;
1629       break;
1630     case GDI_OBJECT_TYPE_ENHMETAFILE:
1631       result = OBJ_ENHMETAFILE;
1632       break;
1633     case GDI_OBJECT_TYPE_ENHMETADC:
1634       result = OBJ_ENHMETADC;
1635       break;
1636     case GDI_OBJECT_TYPE_EXTPEN:
1637       result = OBJ_EXTPEN;
1638       break;
1639     case GDI_OBJECT_TYPE_MEMDC:
1640       result = OBJ_MEMDC;
1641       break;
1642
1643     default:
1644       DPRINT1("Magic 0x%08x not implemented\n", objectType);
1645       result = 0;
1646       break;
1647   }
1648   GDIOBJ_UnlockObj(handle);
1649   return result;
1650 }
1651
1652 DC_GET_VAL( INT, NtGdiGetRelAbs, w.relAbsMode )
1653 DC_GET_VAL( INT, NtGdiGetROP2, w.ROPmode )
1654 DC_GET_VAL( INT, NtGdiGetStretchBltMode, w.stretchBltMode )
1655 DC_GET_VAL( UINT, NtGdiGetTextAlign, w.textAlign )
1656 DC_GET_VAL( COLORREF, NtGdiGetTextColor, w.textColor )
1657 DC_GET_VAL_EX( GetViewportExtEx, vportExtX, vportExtY, SIZE, cx, cy )
1658 DC_GET_VAL_EX( GetViewportOrgEx, vportOrgX, vportOrgY, POINT, x, y )
1659 DC_GET_VAL_EX( GetWindowExtEx, wndExtX, wndExtY, SIZE, cx, cy )
1660 DC_GET_VAL_EX( GetWindowOrgEx, wndOrgX, wndOrgY, POINT, x, y )
1661
1662 HDC STDCALL
1663 NtGdiResetDC(HDC  hDC, CONST DEVMODEW *InitData)
1664 {
1665   UNIMPLEMENTED;
1666   return 0;
1667 }
1668
1669 BOOL STDCALL
1670 NtGdiRestoreDC(HDC  hDC, INT  SaveLevel)
1671 {
1672   PDC dc, dcs;
1673   BOOL success;
1674
1675   DPRINT("NtGdiRestoreDC(%lx, %d)\n", hDC, SaveLevel);
1676
1677   dc = DC_LockDc(hDC);
1678   if (!dc)
1679   {
1680     SetLastWin32Error(ERROR_INVALID_HANDLE);
1681     return FALSE;
1682   }
1683
1684   if (SaveLevel == -1)
1685     SaveLevel = dc->saveLevel;
1686
1687   if ((SaveLevel < 1) || (SaveLevel > dc->saveLevel))
1688   {
1689     DC_UnlockDc(hDC);
1690     return FALSE;
1691   }
1692
1693   success = TRUE;
1694   while (dc->saveLevel >= SaveLevel)
1695   {
1696     HDC hdcs = DC_GetNextDC (dc);
1697
1698     dcs = DC_LockDc (hdcs);
1699     if (dcs == NULL)
1700     {
1701       DC_UnlockDc(hDC);
1702       return FALSE;
1703     }
1704     DC_SetNextDC (dcs, DC_GetNextDC (dcs));
1705     if (--dc->saveLevel < SaveLevel)
1706       {
1707         DC_UnlockDc( hDC );
1708         DC_UnlockDc( hdcs );
1709         NtGdiSetDCState(hDC, hdcs);
1710 #if 0
1711         if (!PATH_AssignGdiPath( &dc->w.path, &dcs->w.path ))
1712         {
1713           /* FIXME: This might not be quite right, since we're
1714            * returning FALSE but still destroying the saved DC state */
1715           success = FALSE;
1716         }
1717 #endif
1718         dc = DC_LockDc(hDC);
1719         if(!dc)
1720         {
1721           return FALSE;
1722         }
1723       }
1724     else
1725       {
1726       DC_UnlockDc( hdcs );
1727       }
1728     NtGdiDeleteDC (hdcs);
1729   }
1730   DC_UnlockDc( hDC );
1731   return  success;
1732 }
1733
1734 INT STDCALL
1735 NtGdiSaveDC(HDC  hDC)
1736 {
1737   HDC  hdcs;
1738   PDC  dc, dcs;
1739   INT  ret;
1740
1741   DPRINT("NtGdiSaveDC(%lx)\n", hDC);
1742
1743   if (!(hdcs = NtGdiGetDCState(hDC)))
1744   {
1745     return 0;
1746   }
1747
1748   dcs = DC_LockDc (hdcs);
1749   if (dcs == NULL)
1750   {
1751     SetLastWin32Error(ERROR_INVALID_HANDLE);
1752     return 0;
1753   }
1754   dc = DC_LockDc (hDC);
1755   if (dc == NULL)
1756   {
1757     DC_UnlockDc(hdcs);
1758     SetLastWin32Error(ERROR_INVALID_HANDLE);
1759     return 0;
1760   }
1761
1762 #if 0
1763     /* Copy path. The reason why path saving / restoring is in SaveDC/
1764      * RestoreDC and not in GetDCState/SetDCState is that the ...DCState
1765      * functions are only in Win16 (which doesn't have paths) and that
1766      * SetDCState doesn't allow us to signal an error (which can happen
1767      * when copying paths).
1768      */
1769   if (!PATH_AssignGdiPath (&dcs->w.path, &dc->w.path))
1770   {
1771     NtGdiDeleteDC (hdcs);
1772     return 0;
1773   }
1774 #endif
1775
1776   DC_SetNextDC (dcs, DC_GetNextDC (dc));
1777   DC_SetNextDC (dc, hdcs);
1778   ret = ++dc->saveLevel;
1779   DC_UnlockDc( hdcs );
1780   DC_UnlockDc( hDC );
1781
1782   return  ret;
1783 }
1784
1785 HGDIOBJ
1786 STDCALL
1787 NtGdiSelectObject(HDC  hDC, HGDIOBJ  hGDIObj)
1788 {
1789   HGDIOBJ objOrg = NULL; // default to failure
1790   BITMAPOBJ *pb;
1791   PDC dc;
1792   PGDIBRUSHOBJ pen;
1793   PGDIBRUSHOBJ brush;
1794   XLATEOBJ *XlateObj;
1795   DWORD objectType;
1796   ULONG NumColors = 0;
1797   HRGN hVisRgn;
1798   BOOLEAN Failed;
1799
1800   if(!hDC || !hGDIObj) return NULL;
1801
1802   dc = DC_LockDc(hDC);
1803   if (NULL == dc)
1804     {
1805       SetLastWin32Error(ERROR_INVALID_HANDLE);
1806       return NULL;
1807     }
1808
1809   objectType = GDIOBJ_GetObjectType(hGDIObj);
1810
1811   switch (objectType)
1812   {
1813     case GDI_OBJECT_TYPE_PEN:
1814       pen = PENOBJ_LockPen((HPEN) hGDIObj);
1815       if (pen == NULL)
1816       {
1817         SetLastWin32Error(ERROR_INVALID_HANDLE);
1818         break;
1819       }
1820
1821       XlateObj = IntGdiCreateBrushXlate(dc, pen, &Failed);
1822       PENOBJ_UnlockPen(hGDIObj);
1823       if (Failed)
1824       {
1825         SetLastWin32Error(ERROR_NO_SYSTEM_RESOURCES);
1826         break;
1827       }
1828
1829       objOrg = (HGDIOBJ)dc->w.hPen;
1830       dc->w.hPen = hGDIObj;
1831       if (dc->XlatePen != NULL)
1832         EngDeleteXlate(dc->XlatePen);
1833       dc->XlatePen = XlateObj;
1834       break;
1835
1836     case GDI_OBJECT_TYPE_BRUSH:
1837       brush = BRUSHOBJ_LockBrush((HPEN) hGDIObj);
1838       if (brush == NULL)
1839       {
1840         SetLastWin32Error(ERROR_INVALID_HANDLE);
1841         break;
1842       }
1843
1844       XlateObj = IntGdiCreateBrushXlate(dc, brush, &Failed);
1845       BRUSHOBJ_UnlockBrush(hGDIObj);
1846       if (Failed)
1847       {
1848         SetLastWin32Error(ERROR_NO_SYSTEM_RESOURCES);
1849         break;
1850       }
1851
1852       objOrg = (HGDIOBJ)dc->w.hBrush;
1853       dc->w.hBrush = hGDIObj;
1854       if (dc->XlateBrush != NULL)
1855         EngDeleteXlate(dc->XlateBrush);
1856       dc->XlateBrush = XlateObj;
1857       break;
1858
1859     case GDI_OBJECT_TYPE_FONT:
1860       if(NT_SUCCESS(TextIntRealizeFont((HFONT)hGDIObj)))
1861       {
1862         objOrg = (HGDIOBJ)dc->w.hFont;
1863         dc->w.hFont = (HFONT) hGDIObj;
1864       }
1865       break;
1866
1867     case GDI_OBJECT_TYPE_BITMAP:
1868       // must be memory dc to select bitmap
1869       if (!(dc->w.flags & DC_MEMORY))
1870         {
1871           DC_UnlockDc(hDC);
1872           return NULL;
1873         }
1874       pb = BITMAPOBJ_LockBitmap(hGDIObj);
1875       if (NULL == pb)
1876         {
1877           SetLastWin32Error(ERROR_INVALID_HANDLE);
1878           DC_UnlockDc(hDC);
1879           return NULL;
1880         }
1881       objOrg = (HGDIOBJ)dc->w.hBitmap;
1882
1883       /* Release the old bitmap, lock the new one and convert it to a SURF */
1884       dc->w.hBitmap = hGDIObj;
1885
1886       // if we're working with a DIB, get the palette [fixme: only create if the selected palette is null]
1887       if(pb->dib)
1888       {
1889         dc->w.bitsPerPixel = pb->dib->dsBmih.biBitCount;
1890
1891         if(pb->dib->dsBmih.biBitCount <= 8)
1892         {
1893           if(pb->dib->dsBmih.biBitCount == 1) { NumColors = 2; } else
1894           if(pb->dib->dsBmih.biBitCount == 4) { NumColors = 16; } else
1895           if(pb->dib->dsBmih.biBitCount == 8) { NumColors = 256; }
1896           dc->w.hPalette = PALETTE_AllocPaletteIndexedRGB(NumColors, pb->ColorMap);
1897         }
1898         else
1899         {
1900           dc->w.hPalette = PALETTE_AllocPalette(PAL_BITFIELDS, 0, NULL,
1901                                                 pb->dib->dsBitfields[0],
1902                                                 pb->dib->dsBitfields[1],
1903                                                 pb->dib->dsBitfields[2]);
1904         }
1905       }
1906       else
1907       {
1908         dc->w.bitsPerPixel = BitsPerFormat(pb->SurfObj.iBitmapFormat);
1909         dc->w.hPalette = dc->DevInfo->hpalDefault;
1910       }
1911
1912       /* Reselect brush and pen to regenerate the XLATEOBJs. */
1913       NtGdiSelectObject ( hDC, dc->w.hBrush );
1914       NtGdiSelectObject ( hDC, dc->w.hPen );
1915
1916       DC_UnlockDc ( hDC );
1917       hVisRgn = NtGdiCreateRectRgn ( 0, 0, pb->SurfObj.sizlBitmap.cx, pb->SurfObj.sizlBitmap.cy );
1918       BITMAPOBJ_UnlockBitmap( hGDIObj );
1919       NtGdiSelectVisRgn ( hDC, hVisRgn );
1920       NtGdiDeleteObject ( hVisRgn );
1921
1922       return objOrg;
1923
1924     case GDI_OBJECT_TYPE_REGION:
1925       DC_UnlockDc (hDC);
1926       /*
1927        * The return value is one of the following values:
1928        *  SIMPLEREGION
1929        *  COMPLEXREGION
1930        *  NULLREGION
1931        */
1932       return (HGDIOBJ) NtGdiSelectClipRgn(hDC, (HRGN) hGDIObj);
1933
1934     default:
1935       break;
1936   }
1937   DC_UnlockDc( hDC );
1938   return objOrg;
1939 }
1940
1941 WORD STDCALL
1942 NtGdiSetHookFlags(HDC hDC, WORD Flags)
1943 {
1944   WORD wRet;
1945   DC *dc = DC_LockDc(hDC);
1946
1947   if (NULL == dc)
1948     {
1949       SetLastWin32Error(ERROR_INVALID_HANDLE);
1950       return 0;
1951     }
1952
1953   wRet = dc->w.flags & DC_DIRTY;
1954
1955   /* "Undocumented Windows" info is slightly confusing.
1956    */
1957
1958   DPRINT("DC %p, Flags %04x\n", hDC, Flags);
1959
1960   if (Flags & DCHF_INVALIDATEVISRGN)
1961     {
1962       dc->w.flags |= DC_DIRTY;
1963     }
1964   else if (Flags & DCHF_VALIDATEVISRGN || 0 == Flags)
1965     {
1966       dc->w.flags &= ~DC_DIRTY;
1967     }
1968
1969   DC_UnlockDc(hDC);
1970
1971   return wRet;
1972 }
1973
1974 DC_SET_MODE( NtGdiSetBkMode, w.backgroundMode, TRANSPARENT, OPAQUE )
1975 DC_SET_MODE( NtGdiSetPolyFillMode, w.polyFillMode, ALTERNATE, WINDING )
1976 // DC_SET_MODE( NtGdiSetRelAbs, w.relAbsMode, ABSOLUTE, RELATIVE )
1977 DC_SET_MODE( NtGdiSetROP2, w.ROPmode, R2_BLACK, R2_WHITE )
1978 DC_SET_MODE( NtGdiSetStretchBltMode, w.stretchBltMode, BLACKONWHITE, HALFTONE )
1979
1980 //  ----------------------------------------------------  Private Interface
1981
1982 HDC FASTCALL
1983 DC_AllocDC(PUNICODE_STRING Driver)
1984 {
1985   PDC  NewDC;
1986   HDC  hDC;
1987   PWSTR Buf = NULL;
1988
1989   if (Driver != NULL)
1990   {
1991     Buf = ExAllocatePoolWithTag(PagedPool, Driver->MaximumLength, TAG_DC);
1992     if(!Buf)
1993     {
1994       return NULL;
1995     }
1996     RtlCopyMemory(Buf, Driver->Buffer, Driver->MaximumLength);
1997   }
1998
1999   hDC = (HDC) GDIOBJ_AllocObj(GDI_OBJECT_TYPE_DC);
2000   if (hDC == NULL)
2001   {
2002     if(Buf)
2003     {
2004       ExFreePool(Buf);
2005     }
2006     return  NULL;
2007   }
2008
2009   NewDC = DC_LockDc(hDC);
2010   /* FIXME - Handle NewDC == NULL! */
2011
2012   if (Driver != NULL)
2013   {
2014     RtlCopyMemory(&NewDC->DriverName, Driver, sizeof(UNICODE_STRING));
2015     NewDC->DriverName.Buffer = Buf;
2016   }
2017
2018   NewDC->w.xformWorld2Wnd.eM11 = 1.0f;
2019   NewDC->w.xformWorld2Wnd.eM12 = 0.0f;
2020   NewDC->w.xformWorld2Wnd.eM21 = 0.0f;
2021   NewDC->w.xformWorld2Wnd.eM22 = 1.0f;
2022   NewDC->w.xformWorld2Wnd.eDx = 0.0f;
2023   NewDC->w.xformWorld2Wnd.eDy = 0.0f;
2024   NewDC->w.xformWorld2Vport = NewDC->w.xformWorld2Wnd;
2025   NewDC->w.xformVport2World = NewDC->w.xformWorld2Wnd;
2026   NewDC->w.vport2WorldValid = TRUE;
2027   NewDC->w.MapMode = MM_TEXT;
2028   NewDC->wndExtX = 1.0f;
2029   NewDC->wndExtY = 1.0f;
2030   NewDC->vportExtX = 1.0f;
2031   NewDC->vportExtY = 1.0f;
2032   NewDC->w.textColor = 0;
2033   NewDC->w.backgroundColor = 0xffffff;
2034
2035   NewDC->w.hFont = NtGdiGetStockObject(SYSTEM_FONT);
2036   TextIntRealizeFont(NewDC->w.hFont);
2037
2038   NewDC->w.hPalette = NtGdiGetStockObject(DEFAULT_PALETTE);
2039
2040   DC_UnlockDc(hDC);
2041
2042   return  hDC;
2043 }
2044
2045 HDC FASTCALL
2046 DC_FindOpenDC(PUNICODE_STRING  Driver)
2047 {
2048   return NULL;
2049 }
2050
2051 /*!
2052  * Initialize some common fields in the Device Context structure.
2053 */
2054 VOID FASTCALL
2055 DC_InitDC(HDC  DCHandle)
2056 {
2057 //  NtGdiRealizeDefaultPalette(DCHandle);
2058
2059   NtGdiSelectObject(DCHandle, NtGdiGetStockObject( WHITE_BRUSH ));
2060   NtGdiSelectObject(DCHandle, NtGdiGetStockObject( BLACK_PEN ));
2061   //NtGdiSelectObject(DCHandle, hFont);
2062
2063 /*
2064   {
2065     int res;
2066     res = CLIPPING_UpdateGCRegion(DCToInit);
2067     ASSERT ( res != ERROR );
2068   }
2069 */
2070 }
2071
2072 VOID FASTCALL
2073 DC_FreeDC(HDC  DCToFree)
2074 {
2075   if (!GDIOBJ_FreeObj(DCToFree, GDI_OBJECT_TYPE_DC))
2076   {
2077     DPRINT("DC_FreeDC failed\n");
2078   }
2079 }
2080
2081 BOOL INTERNAL_CALL
2082 DC_Cleanup(PVOID ObjectBody)
2083 {
2084   PDC pDC = (PDC)ObjectBody;
2085   RtlFreeUnicodeString(&pDC->DriverName);
2086   return TRUE;
2087 }
2088
2089 HDC FASTCALL
2090 DC_GetNextDC (PDC pDC)
2091 {
2092   return pDC->hNext;
2093 }
2094
2095 VOID FASTCALL
2096 DC_SetNextDC (PDC pDC, HDC hNextDC)
2097 {
2098   pDC->hNext = hNextDC;
2099 }
2100
2101 VOID FASTCALL
2102 DC_UpdateXforms(PDC  dc)
2103 {
2104   XFORM  xformWnd2Vport;
2105   FLOAT  scaleX, scaleY;
2106
2107   /* Construct a transformation to do the window-to-viewport conversion */
2108   scaleX = (dc->wndExtX ? (FLOAT)dc->vportExtX / (FLOAT)dc->wndExtX : 0.0f);
2109   scaleY = (dc->wndExtY ? (FLOAT)dc->vportExtY / (FLOAT)dc->wndExtY : 0.0f);
2110   xformWnd2Vport.eM11 = scaleX;
2111   xformWnd2Vport.eM12 = 0.0;
2112   xformWnd2Vport.eM21 = 0.0;
2113   xformWnd2Vport.eM22 = scaleY;
2114   xformWnd2Vport.eDx  = (FLOAT)dc->vportOrgX - scaleX * (FLOAT)dc->wndOrgX;
2115   xformWnd2Vport.eDy  = (FLOAT)dc->vportOrgY - scaleY * (FLOAT)dc->wndOrgY;
2116
2117   /* Combine with the world transformation */
2118   IntGdiCombineTransform(&dc->w.xformWorld2Vport, &dc->w.xformWorld2Wnd, &xformWnd2Vport);
2119
2120   /* Create inverse of world-to-viewport transformation */
2121   dc->w.vport2WorldValid = DC_InvertXform(&dc->w.xformWorld2Vport, &dc->w.xformVport2World);
2122 }
2123
2124 BOOL FASTCALL
2125 DC_InvertXform(const XFORM *xformSrc,
2126                XFORM *xformDest)
2127 {
2128   FLOAT  determinant;
2129
2130   determinant = xformSrc->eM11*xformSrc->eM22 - xformSrc->eM12*xformSrc->eM21;
2131   if (determinant > -1e-12 && determinant < 1e-12)
2132   {
2133     return  FALSE;
2134   }
2135
2136   xformDest->eM11 =  xformSrc->eM22 / determinant;
2137   xformDest->eM12 = -xformSrc->eM12 / determinant;
2138   xformDest->eM21 = -xformSrc->eM21 / determinant;
2139   xformDest->eM22 =  xformSrc->eM11 / determinant;
2140   xformDest->eDx  = -xformSrc->eDx * xformDest->eM11 - xformSrc->eDy * xformDest->eM21;
2141   xformDest->eDy  = -xformSrc->eDx * xformDest->eM12 - xformSrc->eDy * xformDest->eM22;
2142
2143   return  TRUE;
2144 }
2145
2146 VOID FASTCALL
2147 DC_SetOwnership(HDC hDC, PEPROCESS Owner)
2148 {
2149   PDC DC;
2150
2151   GDIOBJ_SetOwnership(hDC, Owner);
2152   DC = DC_LockDc(hDC);
2153   if (NULL != DC)
2154     {
2155       if (NULL != DC->w.hClipRgn)
2156         {
2157           GDIOBJ_CopyOwnership(hDC, DC->w.hClipRgn);
2158         }
2159       if (NULL != DC->w.hVisRgn)
2160         {
2161           GDIOBJ_CopyOwnership(hDC, DC->w.hVisRgn);
2162         }
2163       if (NULL != DC->w.hGCClipRgn)
2164         {
2165           GDIOBJ_CopyOwnership(hDC, DC->w.hGCClipRgn);
2166         }
2167       DC_UnlockDc(hDC);
2168     }
2169 }
2170
2171 BOOL FASTCALL
2172 IntIsPrimarySurface(SURFOBJ *SurfObj)
2173 {
2174    if (PrimarySurface.Handle == NULL)
2175      {
2176        return FALSE;
2177      }
2178    return SurfObj->hsurf == PrimarySurface.Handle;
2179 }
2180
2181 /*
2182  * Returns the color of the brush or pen that is currently selected into the DC.
2183  * This function is called from GetDCBrushColor() and GetDCPenColor()
2184  */
2185 COLORREF FASTCALL
2186 IntGetDCColor(HDC hDC, ULONG Object)
2187 {
2188    /*
2189     * The previous implementation was completly incorrect. It modified the
2190     * brush that was currently selected into the device context, but in fact
2191     * the DC pen/brush color should be stored directly in the device context
2192     * (at address 0x2C of the user mode DC object memory on Windows 2K/XP).
2193     * The actual color is then used when DC_BRUSH/DC_PEN object is selected
2194     * into the device context and BRUSHOBJ for drawing is composed (belongs
2195     * to IntGdiInitBrushInstance in the current ReactOS implementation). Also
2196     * the implementation should be moved to user mode GDI32.dll when UM
2197     * mapped GDI objects will be implemented.
2198     */
2199
2200    DPRINT("WIN32K:IntGetDCColor is unimplemented\n");
2201    return 0xFFFFFF; /* The default DC color. */
2202 }
2203
2204 /*
2205  * Changes the color of the brush or pen that is currently selected into the DC.
2206  * This function is called from SetDCBrushColor() and SetDCPenColor()
2207  */
2208 COLORREF FASTCALL
2209 IntSetDCColor(HDC hDC, ULONG Object, COLORREF Color)
2210 {
2211    /* See the comment in IntGetDCColor. */
2212
2213    DPRINT("WIN32K:IntSetDCColor is unimplemented\n");
2214    return CLR_INVALID;
2215 }
2216
2217 #define SIZEOF_DEVMODEW_300 188
2218 #define SIZEOF_DEVMODEW_400 212
2219 #define SIZEOF_DEVMODEW_500 220
2220
2221 /*! \brief Enumerate possible display settings for the given display...
2222  *
2223  * \todo Make thread safe!?
2224  * \todo Don't ignore lpszDeviceName
2225  * \todo Implement non-raw mode (only return settings valid for driver and monitor)
2226  */
2227 BOOL FASTCALL
2228 IntEnumDisplaySettings(
2229   PUNICODE_STRING lpszDeviceName,
2230   DWORD iModeNum,
2231   LPDEVMODEW lpDevMode,
2232   DWORD dwFlags)
2233 {
2234   static DEVMODEW *CachedDevModes = NULL, *CachedDevModesEnd = NULL;
2235   static DWORD SizeOfCachedDevModes = 0;
2236   LPDEVMODEW CachedMode = NULL;
2237   DEVMODEW DevMode;
2238   INT Size, OldSize;
2239   ULONG DisplayNumber = 0; /* only default display supported */
2240
2241   if (lpDevMode->dmSize != SIZEOF_DEVMODEW_300 &&
2242       lpDevMode->dmSize != SIZEOF_DEVMODEW_400 &&
2243       lpDevMode->dmSize != SIZEOF_DEVMODEW_500)
2244   {
2245     SetLastWin32Error(STATUS_INVALID_PARAMETER);
2246     return FALSE;
2247   }
2248
2249   if (iModeNum == ENUM_CURRENT_SETTINGS)
2250   {
2251     CachedMode = &PrimarySurface.DMW;
2252     assert(CachedMode->dmSize > 0);
2253   }
2254   else if (iModeNum == ENUM_REGISTRY_SETTINGS)
2255   {
2256     RtlZeroMemory(&DevMode, sizeof (DevMode));
2257     DevMode.dmSize = sizeof (DevMode);
2258     DevMode.dmDriverExtra = 0;
2259     if (SetupDevMode(&DevMode, DisplayNumber))
2260       CachedMode = &DevMode;
2261     else
2262     {
2263       SetLastWin32Error(0); /* FIXME: use error code */
2264       return FALSE;
2265     }
2266     /* FIXME: Maybe look for the matching devmode supplied by the
2267      *        driver so we can provide driver private/extra data?
2268      */
2269   }
2270   else
2271   {
2272     if (iModeNum == 0 || CachedDevModes == NULL) /* query modes from drivers */
2273     {
2274       BOOL PrimarySurfaceCreated = FALSE;
2275       UNICODE_STRING DriverFileNames;
2276       LPWSTR CurrentName;
2277       DRVENABLEDATA DrvEnableData;
2278
2279       /* Retrieve DDI driver names from registry */
2280       RtlInitUnicodeString(&DriverFileNames, NULL);
2281       if (!FindDriverFileNames(&DriverFileNames, DisplayNumber))
2282       {
2283         DPRINT1("FindDriverFileNames failed\n");
2284         return FALSE;
2285       }
2286
2287       if (!HalQueryDisplayOwnership())
2288       {
2289         IntCreatePrimarySurface();
2290         PrimarySurfaceCreated = TRUE;
2291       }
2292
2293       /*
2294        * DriverFileNames may be a list of drivers in REG_SZ_MULTI format,
2295        * scan all of them until a good one found.
2296        */
2297       CurrentName = DriverFileNames.Buffer;
2298       for (;CurrentName < DriverFileNames.Buffer + (DriverFileNames.Length / sizeof (WCHAR));
2299            CurrentName += wcslen(CurrentName) + 1)
2300       {
2301         INT i;
2302         PGD_ENABLEDRIVER GDEnableDriver;
2303
2304         /* Get the DDI driver's entry point */
2305         GDEnableDriver = DRIVER_FindDDIDriver(CurrentName);
2306         if (NULL == GDEnableDriver)
2307         {
2308           DPRINT("FindDDIDriver failed for %S\n", CurrentName);
2309           continue;
2310         }
2311
2312         /*  Call DDI driver's EnableDriver function  */
2313         RtlZeroMemory(&DrvEnableData, sizeof (DrvEnableData));
2314
2315         if (!GDEnableDriver(DDI_DRIVER_VERSION_NT5_01, sizeof (DrvEnableData), &DrvEnableData))
2316         {
2317           DPRINT("DrvEnableDriver failed for %S\n", CurrentName);
2318           continue;
2319         }
2320
2321         CachedDevModesEnd = CachedDevModes;
2322
2323         /* find DrvGetModes function */
2324         for (i = 0; i < DrvEnableData.c; i++)
2325         {
2326           PDRVFN DrvFn = DrvEnableData.pdrvfn + i;
2327           PGD_GETMODES GetModes;
2328           INT SizeNeeded, SizeUsed;
2329
2330           if (DrvFn->iFunc != INDEX_DrvGetModes)
2331             continue;
2332
2333           GetModes = (PGD_GETMODES)DrvFn->pfn;
2334
2335           /* make sure we have enough memory to hold the modes */
2336           SizeNeeded = GetModes((HANDLE)(PrimarySurface.VideoFileObject->DeviceObject), 0, NULL);
2337           if (SizeNeeded <= 0)
2338           {
2339             DPRINT("DrvGetModes failed for %S\n", CurrentName);
2340             break;
2341           }
2342
2343           SizeUsed = CachedDevModesEnd - CachedDevModes;
2344           if (SizeOfCachedDevModes - SizeUsed < SizeNeeded)
2345           {
2346             PVOID NewBuffer;
2347
2348             SizeOfCachedDevModes += SizeNeeded;
2349             NewBuffer = ExAllocatePool(PagedPool, SizeOfCachedDevModes);
2350             if (NewBuffer == NULL)
2351             {
2352               /* clean up */
2353               ExFreePool(CachedDevModes);
2354               SizeOfCachedDevModes = 0;
2355               CachedDevModes = NULL;
2356               CachedDevModesEnd = NULL;
2357               if (PrimarySurfaceCreated)
2358               {
2359                 IntDestroyPrimarySurface();
2360               }
2361               SetLastWin32Error(STATUS_NO_MEMORY);
2362               return FALSE;
2363             }
2364             if (CachedDevModes != NULL)
2365             {
2366               RtlCopyMemory(NewBuffer, CachedDevModes, SizeUsed);
2367               ExFreePool(CachedDevModes);
2368             }
2369             CachedDevModes = NewBuffer;
2370             CachedDevModesEnd = (DEVMODEW *)((PCHAR)NewBuffer + SizeUsed);
2371           }
2372
2373           /* query modes */
2374           SizeNeeded = GetModes((HANDLE)(PrimarySurface.VideoFileObject->DeviceObject),
2375                                 SizeOfCachedDevModes - SizeUsed,
2376                                 CachedDevModesEnd);
2377           if (SizeNeeded <= 0)
2378           {
2379             DPRINT("DrvGetModes failed for %S\n", CurrentName);
2380           }
2381           else
2382           {
2383             CachedDevModesEnd = (DEVMODEW *)((PCHAR)CachedDevModesEnd + SizeNeeded);
2384           }
2385           break;
2386         }
2387       }
2388
2389       if (PrimarySurfaceCreated)
2390       {
2391         IntDestroyPrimarySurface();
2392       }
2393
2394       RtlFreeUnicodeString(&DriverFileNames);
2395     }
2396
2397     /* return cached info */
2398     CachedMode = CachedDevModes;
2399     if (CachedMode >= CachedDevModesEnd)
2400     {
2401       SetLastWin32Error(STATUS_NO_MORE_ENTRIES);
2402       return FALSE;
2403     }
2404     while (iModeNum-- > 0 && CachedMode < CachedDevModesEnd)
2405     {
2406       assert(CachedMode->dmSize > 0);
2407       CachedMode = (DEVMODEW *)((PCHAR)CachedMode + CachedMode->dmSize + CachedMode->dmDriverExtra);
2408     }
2409     if (CachedMode >= CachedDevModesEnd)
2410     {
2411       SetLastWin32Error(STATUS_NO_MORE_ENTRIES);
2412       return FALSE;
2413     }
2414   }
2415
2416   assert(CachedMode != NULL);
2417
2418   Size = OldSize = lpDevMode->dmSize;
2419   if (Size > CachedMode->dmSize)
2420     Size = CachedMode->dmSize;
2421   RtlCopyMemory(lpDevMode, CachedMode, Size);
2422   RtlZeroMemory((PCHAR)lpDevMode + Size, OldSize - Size);
2423   lpDevMode->dmSize = OldSize;
2424
2425   Size = OldSize = lpDevMode->dmDriverExtra;
2426   if (Size > CachedMode->dmDriverExtra)
2427     Size = CachedMode->dmDriverExtra;
2428   RtlCopyMemory((PCHAR)lpDevMode + lpDevMode->dmSize,
2429                 (PCHAR)CachedMode + CachedMode->dmSize, Size);
2430   RtlZeroMemory((PCHAR)lpDevMode + lpDevMode->dmSize + Size, OldSize - Size);
2431   lpDevMode->dmDriverExtra = OldSize;
2432
2433   return TRUE;
2434 }
2435
2436 /* EOF */