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