projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
BUGFIX: NtGdiGetDeviceCaps() called NtGdiEscape() with hDC when it already had it...
[reactos.git] / 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.152 2004/12/12 21:58:42 royce 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 IntShowDesktop(IntGetActiveDesktop(), SurfSize.cx, SurfSize.cy);
668 break;
669 }
670
671 return TRUE;
672 }
673
674 VOID FASTCALL
675 IntDestroyPrimarySurface()
676 {
677 DRIVER_UnreferenceDriver(L"DISPLAY");
678
679 /* detach monitor */
680 IntDetachMonitor(&PrimarySurface);
681
682 /*
683 * FIXME: Hide a mouse pointer there. Also because we have to prevent
684 * memory leaks with the Eng* mouse routines.
685 */
686
687 DPRINT("Reseting display\n" );
688 PrimarySurface.DriverFunctions.AssertMode(PrimarySurface.PDev, FALSE);
689 PrimarySurface.DriverFunctions.DisableSurface(PrimarySurface.PDev);
690 PrimarySurface.DriverFunctions.DisablePDEV(PrimarySurface.PDev);
691
692 DceEmptyCache();
693
694 ObDereferenceObject(PrimarySurface.VideoFileObject);
695 }
696
697 HDC FASTCALL
698 IntGdiCreateDC(PUNICODE_STRING Driver,
699 PUNICODE_STRING Device,
700 PUNICODE_STRING Output,
701 CONST PDEVMODEW InitData)
702 {
703 HDC hNewDC;
704 PDC NewDC;
705 HDC hDC = NULL;
706 SURFOBJ *SurfObj;
707 HRGN hVisRgn;
708 UNICODE_STRING StdDriver;
709
710 RtlInitUnicodeString(&StdDriver, L"DISPLAY");
711
712 if (NULL == Driver || 0 == RtlCompareUnicodeString(Driver, &StdDriver, TRUE))
713 {
714 if (! IntGraphicsCheck(TRUE))
715 {
716 DPRINT1("Unable to initialize graphics, returning NULL dc\n");
717 return NULL;
718 }
719 }
720
721 /* Check for existing DC object */
722 if ((hNewDC = DC_FindOpenDC(Driver)) != NULL)
723 {
724 hDC = hNewDC;
725 return NtGdiCreateCompatableDC(hDC);
726 }
727
728 if (Driver != NULL && Driver->Buffer != NULL)
729 {
730 DPRINT("NAME: %S\n", Driver->Buffer); // FIXME: Should not crash if NULL
731 }
732
733 /* Allocate a DC object */
734 if ((hNewDC = DC_AllocDC(Driver)) == NULL)
735 {
736 return NULL;
737 }
738
739 NewDC = DC_LockDc( hNewDC );
740 /* FIXME - NewDC can be NULL!!! Don't assert here! */
741 ASSERT( NewDC );
742
743 NewDC->DMW = PrimarySurface.DMW;
744 NewDC->DevInfo = &PrimarySurface.DevInfo;
745 NewDC->GDIInfo = &PrimarySurface.GDIInfo;
746 memcpy(NewDC->FillPatternSurfaces, PrimarySurface.FillPatterns,
747 sizeof(NewDC->FillPatternSurfaces));
748 NewDC->PDev = PrimarySurface.PDev;
749 NewDC->GDIDevice = (HDEV)&PrimarySurface;
750 NewDC->DriverFunctions = PrimarySurface.DriverFunctions;
751 NewDC->w.hBitmap = PrimarySurface.Handle;
752
753 NewDC->DMW.dmSize = sizeof(NewDC->DMW);
754 NewDC->DMW.dmFields = 0x000fc000;
755
756 /* FIXME: get mode selection information from somewhere */
757
758 NewDC->DMW.dmLogPixels = 96;
759 SurfObj = EngLockSurface((HSURF)PrimarySurface.Handle);
760 NewDC->DMW.dmBitsPerPel = BitsPerFormat(SurfObj->iBitmapFormat);
761 NewDC->DMW.dmPelsWidth = SurfObj->sizlBitmap.cx;
762 NewDC->DMW.dmPelsHeight = SurfObj->sizlBitmap.cy;
763 NewDC->DMW.dmDisplayFlags = 0;
764 NewDC->DMW.dmDisplayFrequency = 0;
765
766 NewDC->w.bitsPerPixel = NewDC->DMW.dmBitsPerPel; // FIXME: set this here??
767
768 NewDC->w.hPalette = NewDC->DevInfo->hpalDefault;
769
770 DPRINT("Bits per pel: %u\n", NewDC->w.bitsPerPixel);
771
772 DC_UnlockDc( hNewDC );
773
774 hVisRgn = NtGdiCreateRectRgn(0, 0, SurfObj->sizlBitmap.cx,
775 SurfObj->sizlBitmap.cy);
776 NtGdiSelectVisRgn(hNewDC, hVisRgn);
777 NtGdiDeleteObject(hVisRgn);
778
779 /* Initialize the DC state */
780 DC_InitDC(hNewDC);
781 NtGdiSetTextColor(hNewDC, RGB(0, 0, 0));
782 NtGdiSetTextAlign(hNewDC, TA_TOP);
783 NtGdiSetBkColor(hNewDC, RGB(255, 255, 255));
784 NtGdiSetBkMode(hNewDC, OPAQUE);
785
786 EngUnlockSurface(SurfObj);
787
788 return hNewDC;
789 }
790
791 HDC STDCALL
792 NtGdiCreateDC(PUNICODE_STRING Driver,
793 PUNICODE_STRING Device,
794 PUNICODE_STRING Output,
795 CONST PDEVMODEW InitData)
796 {
797 UNICODE_STRING SafeDriver, SafeDevice;
798 DEVMODEW SafeInitData;
799 HDC Ret;
800 NTSTATUS Status;
801
802 if(InitData)
803 {
804 Status = MmCopyFromCaller(&SafeInitData, InitData, sizeof(DEVMODEW));
805 if(!NT_SUCCESS(Status))
806 {
807 SetLastNtError(Status);
808 return NULL;
809 }
810 /* FIXME - InitData can have some more bytes! */
811 }
812
813 if(Driver)
814 {
815 Status = IntSafeCopyUnicodeString(&SafeDriver, Driver);
816 if(!NT_SUCCESS(Status))
817 {
818 SetLastNtError(Status);
819 return NULL;
820 }
821 }
822
823 if(Device)
824 {
825 Status = IntSafeCopyUnicodeString(&SafeDevice, Device);
826 if(!NT_SUCCESS(Status))
827 {
828 RtlFreeUnicodeString(&SafeDriver);
829 SetLastNtError(Status);
830 return NULL;
831 }
832 }
833
834 Ret = IntGdiCreateDC(&SafeDriver, &SafeDevice, NULL, &SafeInitData);
835
836 return Ret;
837 }
838
839 HDC STDCALL
840 NtGdiCreateIC(PUNICODE_STRING Driver,
841 PUNICODE_STRING Device,
842 PUNICODE_STRING Output,
843 CONST PDEVMODEW DevMode)
844 {
845 /* FIXME: this should probably do something else... */
846 return NtGdiCreateDC(Driver, Device, Output, DevMode);
847 }
848
849 BOOL STDCALL
850 NtGdiDeleteDC(HDC DCHandle)
851 {
852 PDC DCToDelete;
853
854 DCToDelete = DC_LockDc(DCHandle);
855 if (DCToDelete == NULL)
856 {
857 return FALSE;
858 }
859
860 /* First delete all saved DCs */
861 while (DCToDelete->saveLevel)
862 {
863 PDC savedDC;
864 HDC savedHDC;
865
866 savedHDC = DC_GetNextDC (DCToDelete);
867 savedDC = DC_LockDc (savedHDC);
868 if (savedDC == NULL)
869 {
870 break;
871 }
872 DC_SetNextDC (DCToDelete, DC_GetNextDC (savedDC));
873 DCToDelete->saveLevel--;
874 DC_UnlockDc( savedHDC );
875 NtGdiDeleteDC (savedHDC);
876 }
877
878 /* Free GDI resources allocated to this DC */
879 if (!(DCToDelete->w.flags & DC_SAVED))
880 {
881 /*
882 NtGdiSelectObject (DCHandle, STOCK_BLACK_PEN);
883 NtGdiSelectObject (DCHandle, STOCK_WHITE_BRUSH);
884 NtGdiSelectObject (DCHandle, STOCK_SYSTEM_FONT);
885 DC_LockDC (DCHandle); NtGdiSelectObject does not recognize stock objects yet */
886 if (DCToDelete->w.flags & DC_MEMORY)
887 {
888 NtGdiDeleteObject (DCToDelete->w.hFirstBitmap);
889 }
890 if (DCToDelete->XlateBrush != NULL)
891 EngDeleteXlate(DCToDelete->XlateBrush);
892 if (DCToDelete->XlatePen != NULL)
893 EngDeleteXlate(DCToDelete->XlatePen);
894 }
895 if (DCToDelete->w.hClipRgn)
896 {
897 NtGdiDeleteObject (DCToDelete->w.hClipRgn);
898 }
899 if (DCToDelete->w.hVisRgn)
900 {
901 NtGdiDeleteObject (DCToDelete->w.hVisRgn);
902 }
903 if (NULL != DCToDelete->CombinedClip)
904 {
905 IntEngDeleteClipRegion(DCToDelete->CombinedClip);
906 }
907 if (DCToDelete->w.hGCClipRgn)
908 {
909 NtGdiDeleteObject (DCToDelete->w.hGCClipRgn);
910 }
911 #if 0 /* FIXME */
912 PATH_DestroyGdiPath (&DCToDelete->w.path);
913 #endif
914 DC_UnlockDc( DCHandle );
915 DC_FreeDC ( DCHandle );
916
917 return TRUE;
918 }
919
920 INT STDCALL
921 NtGdiDrawEscape(HDC hDC,
922 INT nEscape,
923 INT cbInput,
924 LPCSTR lpszInData)
925 {
926 UNIMPLEMENTED;
927 return 0;
928 }
929
930 INT STDCALL
931 NtGdiEnumObjects(HDC hDC,
932 INT ObjectType,
933 GOBJENUMPROC ObjectFunc,
934 LPARAM lParam)
935 {
936 UNIMPLEMENTED;
937 return 0;
938 }
939
940 DC_GET_VAL( COLORREF, NtGdiGetBkColor, w.backgroundColor )
941 DC_GET_VAL( INT, NtGdiGetBkMode, w.backgroundMode )
942 DC_GET_VAL_EX( GetBrushOrgEx, w.brushOrgX, w.brushOrgY, POINT, x, y )
943 DC_GET_VAL( HRGN, NtGdiGetClipRgn, w.hClipRgn )
944
945 HGDIOBJ STDCALL
946 NtGdiGetCurrentObject(HDC hDC, UINT ObjectType)
947 {
948 HGDIOBJ SelObject;
949 DC *dc;
950
951 if(!(dc = DC_LockDc(hDC)))
952 {
953 SetLastWin32Error(ERROR_INVALID_HANDLE);
954 return NULL;
955 }
956
957 switch(ObjectType)
958 {
959 case OBJ_PEN:
960 SelObject = dc->w.hPen;
961 break;
962 case OBJ_BRUSH:
963 SelObject = dc->w.hBrush;
964 break;
965 case OBJ_PAL:
966 DPRINT1("FIXME: NtGdiGetCurrentObject() ObjectType OBJ_PAL not supported yet!\n");
967 SelObject = NULL;
968 break;
969 case OBJ_FONT:
970 SelObject = dc->w.hFont;
971 break;
972 case OBJ_BITMAP:
973 SelObject = dc->w.hBitmap;
974 break;
975 case OBJ_COLORSPACE:
976 DPRINT1("FIXME: NtGdiGetCurrentObject() ObjectType OBJ_COLORSPACE not supported yet!\n");
977 SelObject = NULL;
978 break;
979 default:
980 SelObject = NULL;
981 SetLastWin32Error(ERROR_INVALID_PARAMETER);
982 break;
983 }
984
985 DC_UnlockDc(hDC);
986 return SelObject;
987 }
988
989 DC_GET_VAL_EX ( GetCurrentPositionEx, w.CursPosX, w.CursPosY, POINT, x, y )
990
991 BOOL FASTCALL
992 IntGdiGetDCOrgEx(DC *dc, LPPOINT Point)
993 {
994 Point->x = dc->w.DCOrgX;
995 Point->y = dc->w.DCOrgY;
996
997 return TRUE;
998 }
999
1000 BOOL STDCALL
1001 NtGdiGetDCOrgEx(HDC hDC, LPPOINT Point)
1002 {
1003 BOOL Ret;
1004 DC *dc;
1005 POINT SafePoint;
1006 NTSTATUS Status;
1007
1008 if(!Point)
1009 {
1010 SetLastWin32Error(ERROR_INVALID_PARAMETER);
1011 return FALSE;
1012 }
1013
1014 dc = DC_LockDc(hDC);
1015 if(!dc)
1016 {
1017 SetLastWin32Error(ERROR_INVALID_HANDLE);
1018 return FALSE;
1019 }
1020
1021 Ret = IntGdiGetDCOrgEx(dc, &SafePoint);
1022
1023 Status = MmCopyToCaller(Point, &SafePoint, sizeof(POINT));
1024 if(!NT_SUCCESS(Status))
1025 {
1026 SetLastNtError(Status);
1027 DC_UnlockDc(hDC);
1028 return FALSE;
1029 }
1030
1031 DC_UnlockDc(hDC);
1032 return Ret;
1033 }
1034
1035 COLORREF STDCALL
1036 NtGdiSetBkColor(HDC hDC, COLORREF color)
1037 {
1038 COLORREF oldColor;
1039 PDC dc;
1040 HBRUSH hBrush;
1041
1042 if (!(dc = DC_LockDc(hDC)))
1043 {
1044 SetLastWin32Error(ERROR_INVALID_HANDLE);
1045 return CLR_INVALID;
1046 }
1047
1048 oldColor = dc->w.backgroundColor;
1049 dc->w.backgroundColor = color;
1050 hBrush = dc->w.hBrush;
1051 DC_UnlockDc ( hDC );
1052 NtGdiSelectObject(hDC, hBrush);
1053 return oldColor;
1054 }
1055
1056 HDC STDCALL
1057 NtGdiGetDCState(HDC hDC)
1058 {
1059 PDC newdc, dc;
1060 HDC hnewdc;
1061
1062 dc = DC_LockDc(hDC);
1063 if (dc == NULL)
1064 {
1065 SetLastWin32Error(ERROR_INVALID_HANDLE);
1066 return 0;
1067 }
1068
1069 hnewdc = DC_AllocDC(NULL);
1070 if (hnewdc == NULL)
1071 {
1072 DC_UnlockDc( hDC );
1073 return 0;
1074 }
1075 newdc = DC_LockDc( hnewdc );
1076 /* FIXME - newdc can be NULL!!!! Don't assert here!!! */
1077 ASSERT( newdc );
1078
1079 newdc->w.flags = dc->w.flags | DC_SAVED;
1080 newdc->w.hPen = dc->w.hPen;
1081 newdc->w.hBrush = dc->w.hBrush;
1082 newdc->w.hFont = dc->w.hFont;
1083 newdc->w.hBitmap = dc->w.hBitmap;
1084 newdc->w.hFirstBitmap = dc->w.hFirstBitmap;
1085 #if 0
1086 newdc->w.hDevice = dc->w.hDevice;
1087 #endif
1088 newdc->w.hPalette = dc->w.hPalette;
1089 newdc->w.totalExtent = dc->w.totalExtent;
1090 newdc->w.bitsPerPixel = dc->w.bitsPerPixel;
1091 newdc->w.ROPmode = dc->w.ROPmode;
1092 newdc->w.polyFillMode = dc->w.polyFillMode;
1093 newdc->w.stretchBltMode = dc->w.stretchBltMode;
1094 newdc->w.relAbsMode = dc->w.relAbsMode;
1095 newdc->w.backgroundMode = dc->w.backgroundMode;
1096 newdc->w.backgroundColor = dc->w.backgroundColor;
1097 newdc->w.textColor = dc->w.textColor;
1098 newdc->w.brushOrgX = dc->w.brushOrgX;
1099 newdc->w.brushOrgY = dc->w.brushOrgY;
1100 newdc->w.textAlign = dc->w.textAlign;
1101 newdc->w.charExtra = dc->w.charExtra;
1102 newdc->w.breakTotalExtra = dc->w.breakTotalExtra;
1103 newdc->w.breakCount = dc->w.breakCount;
1104 newdc->w.breakExtra = dc->w.breakExtra;
1105 newdc->w.breakRem = dc->w.breakRem;
1106 newdc->w.MapMode = dc->w.MapMode;
1107 newdc->w.GraphicsMode = dc->w.GraphicsMode;
1108 #if 0
1109 /* Apparently, the DC origin is not changed by [GS]etDCState */
1110 newdc->w.DCOrgX = dc->w.DCOrgX;
1111 newdc->w.DCOrgY = dc->w.DCOrgY;
1112 #endif
1113 newdc->w.CursPosX = dc->w.CursPosX;
1114 newdc->w.CursPosY = dc->w.CursPosY;
1115 newdc->w.ArcDirection = dc->w.ArcDirection;
1116 newdc->w.xformWorld2Wnd = dc->w.xformWorld2Wnd;
1117 newdc->w.xformWorld2Vport = dc->w.xformWorld2Vport;
1118 newdc->w.xformVport2World = dc->w.xformVport2World;
1119 newdc->w.vport2WorldValid = dc->w.vport2WorldValid;
1120 newdc->wndOrgX = dc->wndOrgX;
1121 newdc->wndOrgY = dc->wndOrgY;
1122 newdc->wndExtX = dc->wndExtX;
1123 newdc->wndExtY = dc->wndExtY;
1124 newdc->vportOrgX = dc->vportOrgX;
1125 newdc->vportOrgY = dc->vportOrgY;
1126 newdc->vportExtX = dc->vportExtX;
1127 newdc->vportExtY = dc->vportExtY;
1128
1129 newdc->hSelf = hnewdc;
1130 newdc->saveLevel = 0;
1131
1132 #if 0
1133 PATH_InitGdiPath( &newdc->w.path );
1134 #endif
1135
1136 /* Get/SetDCState() don't change hVisRgn field ("Undoc. Windows" p.559). */
1137
1138 newdc->w.hGCClipRgn = newdc->w.hVisRgn = 0;
1139 if (dc->w.hClipRgn)
1140 {
1141 newdc->w.hClipRgn = NtGdiCreateRectRgn( 0, 0, 0, 0 );
1142 NtGdiCombineRgn( newdc->w.hClipRgn, dc->w.hClipRgn, 0, RGN_COPY );
1143 }
1144 DC_UnlockDc( hnewdc );
1145 DC_UnlockDc( hDC );
1146 return hnewdc;
1147 }
1148
1149
1150 VOID
1151 STDCALL
1152 NtGdiSetDCState ( HDC hDC, HDC hDCSave )
1153 {
1154 PDC dc, dcs;
1155
1156 dc = DC_LockDc ( hDC );
1157 if ( dc )
1158 {
1159 dcs = DC_LockDc ( hDCSave );
1160 if ( dcs )
1161 {
1162 if ( dcs->w.flags & DC_SAVED )
1163 {
1164 dc->w.flags = dcs->w.flags & ~DC_SAVED;
1165
1166 dc->w.hFirstBitmap = dcs->w.hFirstBitmap;
1167
1168 #if 0
1169 dc->w.hDevice = dcs->w.hDevice;
1170 #endif
1171
1172 dc->w.totalExtent = dcs->w.totalExtent;
1173 dc->w.ROPmode = dcs->w.ROPmode;
1174 dc->w.polyFillMode = dcs->w.polyFillMode;
1175 dc->w.stretchBltMode = dcs->w.stretchBltMode;
1176 dc->w.relAbsMode = dcs->w.relAbsMode;
1177 dc->w.backgroundMode = dcs->w.backgroundMode;
1178 dc->w.backgroundColor = dcs->w.backgroundColor;
1179 dc->w.textColor = dcs->w.textColor;
1180 dc->w.brushOrgX = dcs->w.brushOrgX;
1181 dc->w.brushOrgY = dcs->w.brushOrgY;
1182 dc->w.textAlign = dcs->w.textAlign;
1183 dc->w.charExtra = dcs->w.charExtra;
1184 dc->w.breakTotalExtra = dcs->w.breakTotalExtra;
1185 dc->w.breakCount = dcs->w.breakCount;
1186 dc->w.breakExtra = dcs->w.breakExtra;
1187 dc->w.breakRem = dcs->w.breakRem;
1188 dc->w.MapMode = dcs->w.MapMode;
1189 dc->w.GraphicsMode = dcs->w.GraphicsMode;
1190 #if 0
1191 /* Apparently, the DC origin is not changed by [GS]etDCState */
1192 dc->w.DCOrgX = dcs->w.DCOrgX;
1193 dc->w.DCOrgY = dcs->w.DCOrgY;
1194 #endif
1195 dc->w.CursPosX = dcs->w.CursPosX;
1196 dc->w.CursPosY = dcs->w.CursPosY;
1197 dc->w.ArcDirection = dcs->w.ArcDirection;
1198
1199 dc->w.xformWorld2Wnd = dcs->w.xformWorld2Wnd;
1200 dc->w.xformWorld2Vport = dcs->w.xformWorld2Vport;
1201 dc->w.xformVport2World = dcs->w.xformVport2World;
1202 dc->w.vport2WorldValid = dcs->w.vport2WorldValid;
1203
1204 dc->wndOrgX = dcs->wndOrgX;
1205 dc->wndOrgY = dcs->wndOrgY;
1206 dc->wndExtX = dcs->wndExtX;
1207 dc->wndExtY = dcs->wndExtY;
1208 dc->vportOrgX = dcs->vportOrgX;
1209 dc->vportOrgY = dcs->vportOrgY;
1210 dc->vportExtX = dcs->vportExtX;
1211 dc->vportExtY = dcs->vportExtY;
1212
1213 if (!(dc->w.flags & DC_MEMORY))
1214 {
1215 dc->w.bitsPerPixel = dcs->w.bitsPerPixel;
1216 }
1217
1218 #if 0
1219 if (dcs->w.hClipRgn)
1220 {
1221 if (!dc->w.hClipRgn)
1222 {
1223 dc->w.hClipRgn = NtGdiCreateRectRgn( 0, 0, 0, 0 );
1224 }
1225 NtGdiCombineRgn( dc->w.hClipRgn, dcs->w.hClipRgn, 0, RGN_COPY );
1226 }
1227 else
1228 {
1229 if (dc->w.hClipRgn)
1230 {
1231 NtGdiDeleteObject( dc->w.hClipRgn );
1232 }
1233
1234 dc->w.hClipRgn = 0;
1235 }
1236 {
1237 int res;
1238 res = CLIPPING_UpdateGCRegion( dc );
1239 ASSERT ( res != ERROR );
1240 }
1241 DC_UnlockDc ( hDC );
1242 #else
1243 DC_UnlockDc ( hDC );
1244 NtGdiSelectClipRgn(hDC, dcs->w.hClipRgn);
1245 #endif
1246
1247 NtGdiSelectObject( hDC, dcs->w.hBitmap );
1248 NtGdiSelectObject( hDC, dcs->w.hBrush );
1249 NtGdiSelectObject( hDC, dcs->w.hFont );
1250 NtGdiSelectObject( hDC, dcs->w.hPen );
1251 NtGdiSetBkColor( hDC, dcs->w.backgroundColor);
1252 NtGdiSetTextColor( hDC, dcs->w.textColor);
1253
1254 NtGdiSelectPalette( hDC, dcs->w.hPalette, FALSE );
1255
1256 #if 0
1257 GDISelectPalette16( hDC, dcs->w.hPalette, FALSE );
1258 #endif
1259 } else {
1260 DC_UnlockDc(hDC);
1261 }
1262 DC_UnlockDc ( hDCSave );
1263 } else {
1264 DC_UnlockDc ( hDC );
1265 SetLastWin32Error(ERROR_INVALID_HANDLE);
1266 }
1267 }
1268 else
1269 SetLastWin32Error(ERROR_INVALID_HANDLE);
1270 }
1271
1272 INT FASTCALL
1273 IntGdiGetDeviceCaps(PDC dc, INT Index)
1274 {
1275 INT ret;
1276 POINT pt;
1277
1278 /* Retrieve capability */
1279 switch (Index)
1280 {
1281 case DRIVERVERSION:
1282 ret = dc->GDIInfo->ulVersion;
1283 break;
1284
1285 case TECHNOLOGY:
1286 ret = dc->GDIInfo->ulTechnology;
1287 break;
1288
1289 case HORZSIZE:
1290 ret = dc->GDIInfo->ulHorzSize;
1291 break;
1292
1293 case VERTSIZE:
1294 ret = dc->GDIInfo->ulVertSize;
1295 break;
1296
1297 case HORZRES:
1298 ret = dc->GDIInfo->ulHorzRes;
1299 break;
1300
1301 case VERTRES:
1302 ret = dc->GDIInfo->ulVertRes;
1303 break;
1304
1305 case LOGPIXELSX:
1306 ret = dc->GDIInfo->ulLogPixelsX;
1307 break;
1308
1309 case LOGPIXELSY:
1310 ret = dc->GDIInfo->ulLogPixelsY;
1311 break;
1312
1313 case BITSPIXEL:
1314 ret = dc->GDIInfo->cBitsPixel;
1315 break;
1316
1317 case PLANES:
1318 ret = dc->GDIInfo->cPlanes;
1319 break;
1320
1321 case NUMBRUSHES:
1322 UNIMPLEMENTED; /* FIXME */
1323 break;
1324
1325 case NUMPENS:
1326 UNIMPLEMENTED; /* FIXME */
1327 break;
1328
1329 case NUMFONTS:
1330 UNIMPLEMENTED; /* FIXME */
1331 break;
1332
1333 case NUMCOLORS:
1334 ret = dc->GDIInfo->ulNumColors;
1335 break;
1336
1337 case ASPECTX:
1338 ret = dc->GDIInfo->ulAspectX;
1339 break;
1340
1341 case ASPECTY:
1342 ret = dc->GDIInfo->ulAspectY;
1343 break;
1344
1345 case ASPECTXY:
1346 ret = dc->GDIInfo->ulAspectXY;
1347 break;
1348
1349 case PDEVICESIZE:
1350 UNIMPLEMENTED; /* FIXME */
1351 break;
1352
1353 case CLIPCAPS:
1354 UNIMPLEMENTED; /* FIXME */
1355 break;
1356
1357 case SIZEPALETTE:
1358 ret = dc->GDIInfo->ulNumPalReg; /* FIXME not sure */
1359 break;
1360
1361 case NUMRESERVED:
1362 ret = 0;
1363 break;
1364
1365 case COLORRES:
1366 UNIMPLEMENTED; /* FIXME */
1367 break;
1368
1369 case PHYSICALWIDTH:
1370 if(IntGdiEscape(dc, GETPHYSPAGESIZE, 0, NULL, (LPVOID)&pt) > 0)
1371 {
1372 ret = pt.x;
1373 }
1374 else
1375 {
1376 ret = 0;
1377 }
1378 break;
1379
1380 case PHYSICALHEIGHT:
1381 if(IntGdiEscape(dc, GETPHYSPAGESIZE, 0, NULL, (LPVOID)&pt) > 0)
1382 {
1383 ret = pt.y;
1384 }
1385 else
1386 {
1387 ret = 0;
1388 }
1389 break;
1390
1391 case PHYSICALOFFSETX:
1392 if(IntGdiEscape(dc, GETPRINTINGOFFSET, 0, NULL, (LPVOID)&pt) > 0)
1393 {
1394 ret = pt.x;
1395 }
1396 else
1397 {
1398 ret = 0;
1399 }
1400 break;
1401
1402 case PHYSICALOFFSETY:
1403 if(IntGdiEscape(dc, GETPRINTINGOFFSET, 0, NULL, (LPVOID)&pt) > 0)
1404 {
1405 ret = pt.y;
1406 }
1407 else
1408 {
1409 ret = 0;
1410 }
1411 break;
1412
1413 case VREFRESH:
1414 UNIMPLEMENTED; /* FIXME */
1415 break;
1416
1417 case SCALINGFACTORX:
1418 if(IntGdiEscape(dc, GETSCALINGFACTOR, 0, NULL, (LPVOID)&pt) > 0)
1419 {
1420 ret = pt.x;
1421 }
1422 else
1423 {
1424 ret = 0;
1425 }
1426 break;
1427
1428 case SCALINGFACTORY:
1429 if(IntGdiEscape(dc, GETSCALINGFACTOR, 0, NULL, (LPVOID)&pt) > 0)
1430 {
1431 ret = pt.y;
1432 }
1433 else
1434 {
1435 ret = 0;
1436 }
1437 break;
1438
1439 case RASTERCAPS:
1440 ret = dc->GDIInfo->flRaster;
1441 break;
1442
1443 case CURVECAPS:
1444 UNIMPLEMENTED; /* FIXME */
1445 break;
1446
1447 case LINECAPS:
1448 UNIMPLEMENTED; /* FIXME */
1449 break;
1450
1451 case POLYGONALCAPS:
1452 UNIMPLEMENTED; /* FIXME */
1453 break;
1454
1455 case TEXTCAPS:
1456 ret = dc->GDIInfo->flTextCaps;
1457 break;
1458
1459 default:
1460 ret = 0;
1461 break;
1462 }
1463
1464 return ret;
1465 }
1466
1467 INT STDCALL
1468 NtGdiGetDeviceCaps(HDC hDC,
1469 INT Index)
1470 {
1471 PDC dc;
1472 INT ret;
1473
1474 dc = DC_LockDc(hDC);
1475 if (dc == NULL)
1476 {
1477 SetLastWin32Error(ERROR_INVALID_HANDLE);
1478 return 0;
1479 }
1480
1481 ret = IntGdiGetDeviceCaps(dc, Index);
1482
1483 DPRINT("(%04x,%d): returning %d\n", hDC, Index, ret);
1484
1485 DC_UnlockDc( hDC );
1486 return ret;
1487 }
1488
1489 DC_GET_VAL( INT, NtGdiGetMapMode, w.MapMode )
1490 DC_GET_VAL( INT, NtGdiGetPolyFillMode, w.polyFillMode )
1491
1492 INT FASTCALL
1493 IntGdiGetObject(HANDLE Handle, INT Count, LPVOID Buffer)
1494 {
1495 PVOID GdiObject;
1496 INT Result = 0;
1497 DWORD ObjectType;
1498
1499 GdiObject = GDIOBJ_LockObj(Handle, GDI_OBJECT_TYPE_DONTCARE);
1500 if (NULL == GdiObject)
1501 {
1502 SetLastWin32Error(ERROR_INVALID_HANDLE);
1503 return 0;
1504 }
1505
1506 ObjectType = GDIOBJ_GetObjectType(Handle);
1507 switch (ObjectType)
1508 {
1509 #if 0
1510 case GDI_OBJECT_TYPE_PEN:
1511 Result = PEN_GetObject((PENOBJ *) GdiObject, Count, Buffer);
1512 break;
1513 case GDI_OBJECT_TYPE_BRUSH:
1514 Result = BRUSH_GetObject((BRUSHOBJ *) GdiObject, Count, Buffer);
1515 break;
1516 #endif
1517 case GDI_OBJECT_TYPE_BITMAP:
1518 Result = BITMAP_GetObject((BITMAPOBJ *) GdiObject, Count, Buffer);
1519 break;
1520 case GDI_OBJECT_TYPE_FONT:
1521 Result = FontGetObject((PTEXTOBJ) GdiObject, Count, Buffer);
1522 #if 0
1523 // Fix the LOGFONT structure for the stock fonts
1524 if (FIRST_STOCK_HANDLE <= Handle && Handle <= LAST_STOCK_HANDLE)
1525 {
1526 FixStockFontSizeW(Handle, Count, Buffer);
1527 }
1528 #endif
1529 break;
1530 #if 0
1531 case GDI_OBJECT_TYPE_PALETTE:
1532 Result = PALETTE_GetObject((PALETTEOBJ *) GdiObject, Count, Buffer);
1533 break;
1534 #endif
1535 default:
1536 DPRINT1("GDI object type 0x%08x not implemented\n", ObjectType);
1537 break;
1538 }
1539
1540 GDIOBJ_UnlockObj(Handle);
1541
1542 return Result;
1543 }
1544
1545 INT STDCALL
1546 NtGdiGetObject(HANDLE handle, INT count, LPVOID buffer)
1547 {
1548 INT Ret;
1549 LPVOID SafeBuf;
1550 NTSTATUS Status;
1551
1552 if (count <= 0)
1553 {
1554 return 0;
1555 }
1556
1557 SafeBuf = ExAllocatePoolWithTag(PagedPool, count, TAG_GDIOBJ);
1558 if(!SafeBuf)
1559 {
1560 SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
1561 return 0;
1562 }
1563
1564 Ret = IntGdiGetObject(handle, count, SafeBuf);
1565
1566 Status = MmCopyToCaller(buffer, SafeBuf, count);
1567 ExFreePool(SafeBuf);
1568 if(!NT_SUCCESS(Status))
1569 {
1570 SetLastNtError(Status);
1571 return 0;
1572 }
1573
1574 return Ret;
1575 }
1576
1577 DWORD STDCALL
1578 NtGdiGetObjectType(HANDLE handle)
1579 {
1580 GDIOBJHDR * ptr;
1581 INT result;
1582 DWORD objectType;
1583
1584 ptr = GDIOBJ_LockObj(handle, GDI_OBJECT_TYPE_DONTCARE);
1585 if (ptr == 0)
1586 {
1587 SetLastWin32Error(ERROR_INVALID_HANDLE);
1588 return 0;
1589 }
1590
1591 objectType = GDIOBJ_GetObjectType(handle);
1592 switch(objectType)
1593 {
1594 case GDI_OBJECT_TYPE_PEN:
1595 result = OBJ_PEN;
1596 break;
1597 case GDI_OBJECT_TYPE_BRUSH:
1598 result = OBJ_BRUSH;
1599 break;
1600 case GDI_OBJECT_TYPE_BITMAP:
1601 result = OBJ_BITMAP;
1602 break;
1603 case GDI_OBJECT_TYPE_FONT:
1604 result = OBJ_FONT;
1605 break;
1606 case GDI_OBJECT_TYPE_PALETTE:
1607 result = OBJ_PAL;
1608 break;
1609 case GDI_OBJECT_TYPE_REGION:
1610 result = OBJ_REGION;
1611 break;
1612 case GDI_OBJECT_TYPE_DC:
1613 result = OBJ_DC;
1614 break;
1615 case GDI_OBJECT_TYPE_METADC:
1616 result = OBJ_METADC;
1617 break;
1618 case GDI_OBJECT_TYPE_METAFILE:
1619 result = OBJ_METAFILE;
1620 break;
1621 case GDI_OBJECT_TYPE_ENHMETAFILE:
1622 result = OBJ_ENHMETAFILE;
1623 break;
1624 case GDI_OBJECT_TYPE_ENHMETADC:
1625 result = OBJ_ENHMETADC;
1626 break;
1627 case GDI_OBJECT_TYPE_EXTPEN:
1628 result = OBJ_EXTPEN;
1629 break;
1630 case GDI_OBJECT_TYPE_MEMDC:
1631 result = OBJ_MEMDC;
1632 break;
1633
1634 default:
1635 DPRINT1("Magic 0x%08x not implemented\n", objectType);
1636 result = 0;
1637 break;
1638 }
1639 GDIOBJ_UnlockObj(handle);
1640 return result;
1641 }
1642
1643 DC_GET_VAL( INT, NtGdiGetRelAbs, w.relAbsMode )
1644 DC_GET_VAL( INT, NtGdiGetROP2, w.ROPmode )
1645 DC_GET_VAL( INT, NtGdiGetStretchBltMode, w.stretchBltMode )
1646 DC_GET_VAL( UINT, NtGdiGetTextAlign, w.textAlign )
1647 DC_GET_VAL( COLORREF, NtGdiGetTextColor, w.textColor )
1648 DC_GET_VAL_EX( GetViewportExtEx, vportExtX, vportExtY, SIZE, cx, cy )
1649 DC_GET_VAL_EX( GetViewportOrgEx, vportOrgX, vportOrgY, POINT, x, y )
1650 DC_GET_VAL_EX( GetWindowExtEx, wndExtX, wndExtY, SIZE, cx, cy )
1651 DC_GET_VAL_EX( GetWindowOrgEx, wndOrgX, wndOrgY, POINT, x, y )
1652
1653 HDC STDCALL
1654 NtGdiResetDC(HDC hDC, CONST DEVMODEW *InitData)
1655 {
1656 UNIMPLEMENTED;
1657 return 0;
1658 }
1659
1660 BOOL STDCALL
1661 NtGdiRestoreDC(HDC hDC, INT SaveLevel)
1662 {
1663 PDC dc, dcs;
1664 BOOL success;
1665
1666 DPRINT("NtGdiRestoreDC(%lx, %d)\n", hDC, SaveLevel);
1667
1668 dc = DC_LockDc(hDC);
1669 if (!dc)
1670 {
1671 SetLastWin32Error(ERROR_INVALID_HANDLE);
1672 return FALSE;
1673 }
1674
1675 if (SaveLevel == -1)
1676 SaveLevel = dc->saveLevel;
1677
1678 if ((SaveLevel < 1) || (SaveLevel > dc->saveLevel))
1679 {
1680 DC_UnlockDc(hDC);
1681 return FALSE;
1682 }
1683
1684 success = TRUE;
1685 while (dc->saveLevel >= SaveLevel)
1686 {
1687 HDC hdcs = DC_GetNextDC (dc);
1688
1689 dcs = DC_LockDc (hdcs);
1690 if (dcs == NULL)
1691 {
1692 DC_UnlockDc(hDC);
1693 return FALSE;
1694 }
1695 DC_SetNextDC (dcs, DC_GetNextDC (dcs));
1696 if (--dc->saveLevel < SaveLevel)
1697 {
1698 DC_UnlockDc( hDC );
1699 DC_UnlockDc( hdcs );
1700 NtGdiSetDCState(hDC, hdcs);
1701 #if 0
1702 if (!PATH_AssignGdiPath( &dc->w.path, &dcs->w.path ))
1703 {
1704 /* FIXME: This might not be quite right, since we're
1705 * returning FALSE but still destroying the saved DC state */
1706 success = FALSE;
1707 }
1708 #endif
1709 dc = DC_LockDc(hDC);
1710 if(!dc)
1711 {
1712 return FALSE;
1713 }
1714 }
1715 else
1716 {
1717 DC_UnlockDc( hdcs );
1718 }
1719 NtGdiDeleteDC (hdcs);
1720 }
1721 DC_UnlockDc( hDC );
1722 return success;
1723 }
1724
1725 INT STDCALL
1726 NtGdiSaveDC(HDC hDC)
1727 {
1728 HDC hdcs;
1729 PDC dc, dcs;
1730 INT ret;
1731
1732 DPRINT("NtGdiSaveDC(%lx)\n", hDC);
1733
1734 if (!(hdcs = NtGdiGetDCState(hDC)))
1735 {
1736 return 0;
1737 }
1738
1739 dcs = DC_LockDc (hdcs);
1740 if (dcs == NULL)
1741 {
1742 SetLastWin32Error(ERROR_INVALID_HANDLE);
1743 return 0;
1744 }
1745 dc = DC_LockDc (hDC);
1746 if (dc == NULL)
1747 {
1748 DC_UnlockDc(hdcs);
1749 SetLastWin32Error(ERROR_INVALID_HANDLE);
1750 return 0;
1751 }
1752
1753 #if 0
1754 /* Copy path. The reason why path saving / restoring is in SaveDC/
1755 * RestoreDC and not in GetDCState/SetDCState is that the ...DCState
1756 * functions are only in Win16 (which doesn't have paths) and that
1757 * SetDCState doesn't allow us to signal an error (which can happen
1758 * when copying paths).
1759 */
1760 if (!PATH_AssignGdiPath (&dcs->w.path, &dc->w.path))
1761 {
1762 NtGdiDeleteDC (hdcs);
1763 return 0;
1764 }
1765 #endif
1766
1767 DC_SetNextDC (dcs, DC_GetNextDC (dc));
1768 DC_SetNextDC (dc, hdcs);
1769 ret = ++dc->saveLevel;
1770 DC_UnlockDc( hdcs );
1771 DC_UnlockDc( hDC );
1772
1773 return ret;
1774 }
1775
1776 HGDIOBJ
1777 STDCALL
1778 NtGdiSelectObject(HDC hDC, HGDIOBJ hGDIObj)
1779 {
1780 HGDIOBJ objOrg = NULL; // default to failure
1781 BITMAPOBJ *pb;
1782 PDC dc;
1783 PGDIBRUSHOBJ pen;
1784 PGDIBRUSHOBJ brush;
1785 XLATEOBJ *XlateObj;
1786 DWORD objectType;
1787 ULONG NumColors = 0;
1788 HRGN hVisRgn;
1789 BOOLEAN Failed;
1790
1791 if(!hDC || !hGDIObj) return NULL;
1792
1793 dc = DC_LockDc(hDC);
1794 if (NULL == dc)
1795 {
1796 SetLastWin32Error(ERROR_INVALID_HANDLE);
1797 return NULL;
1798 }
1799
1800 objectType = GDIOBJ_GetObjectType(hGDIObj);
1801
1802 switch (objectType)
1803 {
1804 case GDI_OBJECT_TYPE_PEN:
1805 pen = PENOBJ_LockPen((HPEN) hGDIObj);
1806 if (pen == NULL)
1807 {
1808 SetLastWin32Error(ERROR_INVALID_HANDLE);
1809 break;
1810 }
1811
1812 XlateObj = IntGdiCreateBrushXlate(dc, pen, &Failed);
1813 PENOBJ_UnlockPen(hGDIObj);
1814 if (Failed)
1815 {
1816 SetLastWin32Error(ERROR_NO_SYSTEM_RESOURCES);
1817 break;
1818 }
1819
1820 objOrg = (HGDIOBJ)dc->w.hPen;
1821 dc->w.hPen = hGDIObj;
1822 if (dc->XlatePen != NULL)
1823 EngDeleteXlate(dc->XlatePen);
1824 dc->XlatePen = XlateObj;
1825 break;
1826
1827 case GDI_OBJECT_TYPE_BRUSH:
1828 brush = BRUSHOBJ_LockBrush((HPEN) hGDIObj);
1829 if (brush == NULL)
1830 {
1831 SetLastWin32Error(ERROR_INVALID_HANDLE);
1832 break;
1833 }
1834
1835 XlateObj = IntGdiCreateBrushXlate(dc, brush, &Failed);
1836 BRUSHOBJ_UnlockBrush(hGDIObj);
1837 if (Failed)
1838 {
1839 SetLastWin32Error(ERROR_NO_SYSTEM_RESOURCES);
1840 break;
1841 }
1842
1843 objOrg = (HGDIOBJ)dc->w.hBrush;
1844 dc->w.hBrush = hGDIObj;
1845 if (dc->XlateBrush != NULL)
1846 EngDeleteXlate(dc->XlateBrush);
1847 dc->XlateBrush = XlateObj;
1848 break;
1849
1850 case GDI_OBJECT_TYPE_FONT:
1851 if(NT_SUCCESS(TextIntRealizeFont((HFONT)hGDIObj)))
1852 {
1853 objOrg = (HGDIOBJ)dc->w.hFont;
1854 dc->w.hFont = (HFONT) hGDIObj;
1855 }
1856 break;
1857
1858 case GDI_OBJECT_TYPE_BITMAP:
1859 // must be memory dc to select bitmap
1860 if (!(dc->w.flags & DC_MEMORY))
1861 {
1862 DC_UnlockDc(hDC);
1863 return NULL;
1864 }
1865 pb = BITMAPOBJ_LockBitmap(hGDIObj);
1866 if (NULL == pb)
1867 {
1868 SetLastWin32Error(ERROR_INVALID_HANDLE);
1869 DC_UnlockDc(hDC);
1870 return NULL;
1871 }
1872 objOrg = (HGDIOBJ)dc->w.hBitmap;
1873
1874 /* Release the old bitmap, lock the new one and convert it to a SURF */
1875 dc->w.hBitmap = hGDIObj;
1876
1877 // if we're working with a DIB, get the palette [fixme: only create if the selected palette is null]
1878 if(pb->dib)
1879 {
1880 dc->w.bitsPerPixel = pb->dib->dsBmih.biBitCount;
1881
1882 if(pb->dib->dsBmih.biBitCount <= 8)
1883 {
1884 if(pb->dib->dsBmih.biBitCount == 1) { NumColors = 2; } else
1885 if(pb->dib->dsBmih.biBitCount == 4) { NumColors = 16; } else
1886 if(pb->dib->dsBmih.biBitCount == 8) { NumColors = 256; }
1887 dc->w.hPalette = PALETTE_AllocPaletteIndexedRGB(NumColors, pb->ColorMap);
1888 }
1889 else
1890 {
1891 dc->w.hPalette = PALETTE_AllocPalette(PAL_BITFIELDS, 0, NULL,
1892 pb->dib->dsBitfields[0],
1893 pb->dib->dsBitfields[1],
1894 pb->dib->dsBitfields[2]);
1895 }
1896 }
1897 else
1898 {
1899 dc->w.bitsPerPixel = BitsPerFormat(pb->SurfObj.iBitmapFormat);
1900 dc->w.hPalette = dc->DevInfo->hpalDefault;
1901 }
1902
1903 /* Reselect brush and pen to regenerate the XLATEOBJs. */
1904 NtGdiSelectObject ( hDC, dc->w.hBrush );
1905 NtGdiSelectObject ( hDC, dc->w.hPen );
1906
1907 DC_UnlockDc ( hDC );
1908 hVisRgn = NtGdiCreateRectRgn ( 0, 0, pb->SurfObj.sizlBitmap.cx, pb->SurfObj.sizlBitmap.cy );
1909 BITMAPOBJ_UnlockBitmap( hGDIObj );
1910 NtGdiSelectVisRgn ( hDC, hVisRgn );
1911 NtGdiDeleteObject ( hVisRgn );
1912
1913 return objOrg;
1914
1915 case GDI_OBJECT_TYPE_REGION:
1916 DC_UnlockDc (hDC);
1917 /*
1918 * The return value is one of the following values:
1919 * SIMPLEREGION
1920 * COMPLEXREGION
1921 * NULLREGION
1922 */
1923 return (HGDIOBJ) NtGdiSelectClipRgn(hDC, (HRGN) hGDIObj);
1924
1925 default:
1926 break;
1927 }
1928 DC_UnlockDc( hDC );
1929 return objOrg;
1930 }
1931
1932 WORD STDCALL
1933 NtGdiSetHookFlags(HDC hDC, WORD Flags)
1934 {
1935 WORD wRet;
1936 DC *dc = DC_LockDc(hDC);
1937
1938 if (NULL == dc)
1939 {
1940 SetLastWin32Error(ERROR_INVALID_HANDLE);
1941 return 0;
1942 }
1943
1944 wRet = dc->w.flags & DC_DIRTY;
1945
1946 /* "Undocumented Windows" info is slightly confusing.
1947 */
1948
1949 DPRINT("DC %p, Flags %04x\n", hDC, Flags);
1950
1951 if (Flags & DCHF_INVALIDATEVISRGN)
1952 {
1953 dc->w.flags |= DC_DIRTY;
1954 }
1955 else if (Flags & DCHF_VALIDATEVISRGN || 0 == Flags)
1956 {
1957 dc->w.flags &= ~DC_DIRTY;
1958 }
1959
1960 DC_UnlockDc(hDC);
1961
1962 return wRet;
1963 }
1964
1965 DC_SET_MODE( NtGdiSetBkMode, w.backgroundMode, TRANSPARENT, OPAQUE )
1966 DC_SET_MODE( NtGdiSetPolyFillMode, w.polyFillMode, ALTERNATE, WINDING )
1967 // DC_SET_MODE( NtGdiSetRelAbs, w.relAbsMode, ABSOLUTE, RELATIVE )
1968 DC_SET_MODE( NtGdiSetROP2, w.ROPmode, R2_BLACK, R2_WHITE )
1969 DC_SET_MODE( NtGdiSetStretchBltMode, w.stretchBltMode, BLACKONWHITE, HALFTONE )
1970
1971 // ---------------------------------------------------- Private Interface
1972
1973 HDC FASTCALL
1974 DC_AllocDC(PUNICODE_STRING Driver)
1975 {
1976 PDC NewDC;
1977 HDC hDC;
1978 PWSTR Buf = NULL;
1979
1980 if (Driver != NULL)
1981 {
1982 Buf = ExAllocatePoolWithTag(PagedPool, Driver->MaximumLength, TAG_DC);
1983 if(!Buf)
1984 {
1985 return NULL;
1986 }
1987 RtlCopyMemory(Buf, Driver->Buffer, Driver->MaximumLength);
1988 }
1989
1990 hDC = (HDC) GDIOBJ_AllocObj(GDI_OBJECT_TYPE_DC);
1991 if (hDC == NULL)
1992 {
1993 if(Buf)
1994 {
1995 ExFreePool(Buf);
1996 }
1997 return NULL;
1998 }
1999
2000 NewDC = DC_LockDc(hDC);
2001 /* FIXME - Handle NewDC == NULL! */
2002
2003 if (Driver != NULL)
2004 {
2005 RtlCopyMemory(&NewDC->DriverName, Driver, sizeof(UNICODE_STRING));
2006 NewDC->DriverName.Buffer = Buf;
2007 }
2008
2009 NewDC->w.xformWorld2Wnd.eM11 = 1.0f;
2010 NewDC->w.xformWorld2Wnd.eM12 = 0.0f;
2011 NewDC->w.xformWorld2Wnd.eM21 = 0.0f;
2012 NewDC->w.xformWorld2Wnd.eM22 = 1.0f;
2013 NewDC->w.xformWorld2Wnd.eDx = 0.0f;
2014 NewDC->w.xformWorld2Wnd.eDy = 0.0f;
2015 NewDC->w.xformWorld2Vport = NewDC->w.xformWorld2Wnd;
2016 NewDC->w.xformVport2World = NewDC->w.xformWorld2Wnd;
2017 NewDC->w.vport2WorldValid = TRUE;
2018 NewDC->w.MapMode = MM_TEXT;
2019 NewDC->wndExtX = 1.0f;
2020 NewDC->wndExtY = 1.0f;
2021 NewDC->vportExtX = 1.0f;
2022 NewDC->vportExtY = 1.0f;
2023 NewDC->w.textColor = 0;
2024 NewDC->w.backgroundColor = 0xffffff;
2025
2026 NewDC->w.hFont = NtGdiGetStockObject(SYSTEM_FONT);
2027 TextIntRealizeFont(NewDC->w.hFont);
2028
2029 NewDC->w.hPalette = NtGdiGetStockObject(DEFAULT_PALETTE);
2030
2031 DC_UnlockDc(hDC);
2032
2033 return hDC;
2034 }
2035
2036 HDC FASTCALL
2037 DC_FindOpenDC(PUNICODE_STRING Driver)
2038 {
2039 return NULL;
2040 }
2041
2042 /*!
2043 * Initialize some common fields in the Device Context structure.
2044 */
2045 VOID FASTCALL
2046 DC_InitDC(HDC DCHandle)
2047 {
2048 // NtGdiRealizeDefaultPalette(DCHandle);
2049
2050 NtGdiSelectObject(DCHandle, NtGdiGetStockObject( WHITE_BRUSH ));
2051 NtGdiSelectObject(DCHandle, NtGdiGetStockObject( BLACK_PEN ));
2052 //NtGdiSelectObject(DCHandle, hFont);
2053
2054 /*
2055 {
2056 int res;
2057 res = CLIPPING_UpdateGCRegion(DCToInit);
2058 ASSERT ( res != ERROR );
2059 }
2060 */
2061 }
2062
2063 VOID FASTCALL
2064 DC_FreeDC(HDC DCToFree)
2065 {
2066 if (!GDIOBJ_FreeObj(DCToFree, GDI_OBJECT_TYPE_DC))
2067 {
2068 DPRINT("DC_FreeDC failed\n");
2069 }
2070 }
2071
2072 BOOL INTERNAL_CALL
2073 DC_Cleanup(PVOID ObjectBody)
2074 {
2075 PDC pDC = (PDC)ObjectBody;
2076 RtlFreeUnicodeString(&pDC->DriverName);
2077 return TRUE;
2078 }
2079
2080 HDC FASTCALL
2081 DC_GetNextDC (PDC pDC)
2082 {
2083 return pDC->hNext;
2084 }
2085
2086 VOID FASTCALL
2087 DC_SetNextDC (PDC pDC, HDC hNextDC)
2088 {
2089 pDC->hNext = hNextDC;
2090 }
2091
2092 VOID FASTCALL
2093 DC_UpdateXforms(PDC dc)
2094 {
2095 XFORM xformWnd2Vport;
2096 FLOAT scaleX, scaleY;
2097
2098 /* Construct a transformation to do the window-to-viewport conversion */
2099 scaleX = (dc->wndExtX ? (FLOAT)dc->vportExtX / (FLOAT)dc->wndExtX : 0.0f);
2100 scaleY = (dc->wndExtY ? (FLOAT)dc->vportExtY / (FLOAT)dc->wndExtY : 0.0f);
2101 xformWnd2Vport.eM11 = scaleX;
2102 xformWnd2Vport.eM12 = 0.0;
2103 xformWnd2Vport.eM21 = 0.0;
2104 xformWnd2Vport.eM22 = scaleY;
2105 xformWnd2Vport.eDx = (FLOAT)dc->vportOrgX - scaleX * (FLOAT)dc->wndOrgX;
2106 xformWnd2Vport.eDy = (FLOAT)dc->vportOrgY - scaleY * (FLOAT)dc->wndOrgY;
2107
2108 /* Combine with the world transformation */
2109 IntGdiCombineTransform(&dc->w.xformWorld2Vport, &dc->w.xformWorld2Wnd, &xformWnd2Vport);
2110
2111 /* Create inverse of world-to-viewport transformation */
2112 dc->w.vport2WorldValid = DC_InvertXform(&dc->w.xformWorld2Vport, &dc->w.xformVport2World);
2113 }
2114
2115 BOOL FASTCALL
2116 DC_InvertXform(const XFORM *xformSrc,
2117 XFORM *xformDest)
2118 {
2119 FLOAT determinant;
2120
2121 determinant = xformSrc->eM11*xformSrc->eM22 - xformSrc->eM12*xformSrc->eM21;
2122 if (determinant > -1e-12 && determinant < 1e-12)
2123 {
2124 return FALSE;
2125 }
2126
2127 xformDest->eM11 = xformSrc->eM22 / determinant;
2128 xformDest->eM12 = -xformSrc->eM12 / determinant;
2129 xformDest->eM21 = -xformSrc->eM21 / determinant;
2130 xformDest->eM22 = xformSrc->eM11 / determinant;
2131 xformDest->eDx = -xformSrc->eDx * xformDest->eM11 - xformSrc->eDy * xformDest->eM21;
2132 xformDest->eDy = -xformSrc->eDx * xformDest->eM12 - xformSrc->eDy * xformDest->eM22;
2133
2134 return TRUE;
2135 }
2136
2137 VOID FASTCALL
2138 DC_SetOwnership(HDC hDC, PEPROCESS Owner)
2139 {
2140 PDC DC;
2141
2142 GDIOBJ_SetOwnership(hDC, Owner);
2143 DC = DC_LockDc(hDC);
2144 if (NULL != DC)
2145 {
2146 if (NULL != DC->w.hClipRgn)
2147 {
2148 GDIOBJ_CopyOwnership(hDC, DC->w.hClipRgn);
2149 }
2150 if (NULL != DC->w.hVisRgn)
2151 {
2152 GDIOBJ_CopyOwnership(hDC, DC->w.hVisRgn);
2153 }
2154 if (NULL != DC->w.hGCClipRgn)
2155 {
2156 GDIOBJ_CopyOwnership(hDC, DC->w.hGCClipRgn);
2157 }
2158 DC_UnlockDc(hDC);
2159 }
2160 }
2161
2162 BOOL FASTCALL
2163 IntIsPrimarySurface(SURFOBJ *SurfObj)
2164 {
2165 if (PrimarySurface.Handle == NULL)
2166 {
2167 return FALSE;
2168 }
2169 return SurfObj->hsurf == PrimarySurface.Handle;
2170 }
2171
2172 /*
2173 * Returns the color of the brush or pen that is currently selected into the DC.
2174 * This function is called from GetDCBrushColor() and GetDCPenColor()
2175 */
2176 COLORREF FASTCALL
2177 IntGetDCColor(HDC hDC, ULONG Object)
2178 {
2179 /*
2180 * The previous implementation was completly incorrect. It modified the
2181 * brush that was currently selected into the device context, but in fact
2182 * the DC pen/brush color should be stored directly in the device context
2183 * (at address 0x2C of the user mode DC object memory on Windows 2K/XP).
2184 * The actual color is then used when DC_BRUSH/DC_PEN object is selected
2185 * into the device context and BRUSHOBJ for drawing is composed (belongs
2186 * to IntGdiInitBrushInstance in the current ReactOS implementation). Also
2187 * the implementation should be moved to user mode GDI32.dll when UM
2188 * mapped GDI objects will be implemented.
2189 */
2190
2191 DPRINT("WIN32K:IntGetDCColor is unimplemented\n");
2192 return 0xFFFFFF; /* The default DC color. */
2193 }
2194
2195 /*
2196 * Changes the color of the brush or pen that is currently selected into the DC.
2197 * This function is called from SetDCBrushColor() and SetDCPenColor()
2198 */
2199 COLORREF FASTCALL
2200 IntSetDCColor(HDC hDC, ULONG Object, COLORREF Color)
2201 {
2202 /* See the comment in IntGetDCColor. */
2203
2204 DPRINT("WIN32K:IntSetDCColor is unimplemented\n");
2205 return CLR_INVALID;
2206 }
2207
2208 #define SIZEOF_DEVMODEW_300 188
2209 #define SIZEOF_DEVMODEW_400 212
2210 #define SIZEOF_DEVMODEW_500 220
2211
2212 /*! \brief Enumerate possible display settings for the given display...
2213 *
2214 * \todo Make thread safe!?
2215 * \todo Don't ignore lpszDeviceName
2216 * \todo Implement non-raw mode (only return settings valid for driver and monitor)
2217 */
2218 BOOL FASTCALL
2219 IntEnumDisplaySettings(
2220 PUNICODE_STRING lpszDeviceName,
2221 DWORD iModeNum,
2222 LPDEVMODEW lpDevMode,
2223 DWORD dwFlags)
2224 {
2225 static DEVMODEW *CachedDevModes = NULL, *CachedDevModesEnd = NULL;
2226 static DWORD SizeOfCachedDevModes = 0;
2227 LPDEVMODEW CachedMode = NULL;
2228 DEVMODEW DevMode;
2229 INT Size, OldSize;
2230 ULONG DisplayNumber = 0; /* only default display supported */
2231
2232 if (lpDevMode->dmSize != SIZEOF_DEVMODEW_300 &&
2233 lpDevMode->dmSize != SIZEOF_DEVMODEW_400 &&
2234 lpDevMode->dmSize != SIZEOF_DEVMODEW_500)
2235 {
2236 SetLastWin32Error(STATUS_INVALID_PARAMETER);
2237 return FALSE;
2238 }
2239
2240 if (iModeNum == ENUM_CURRENT_SETTINGS)
2241 {
2242 CachedMode = &PrimarySurface.DMW;
2243 assert(CachedMode->dmSize > 0);
2244 }
2245 else if (iModeNum == ENUM_REGISTRY_SETTINGS)
2246 {
2247 RtlZeroMemory(&DevMode, sizeof (DevMode));
2248 DevMode.dmSize = sizeof (DevMode);
2249 DevMode.dmDriverExtra = 0;
2250 if (SetupDevMode(&DevMode, DisplayNumber))
2251 CachedMode = &DevMode;
2252 else
2253 {
2254 SetLastWin32Error(0); /* FIXME: use error code */
2255 return FALSE;
2256 }
2257 /* FIXME: Maybe look for the matching devmode supplied by the
2258 * driver so we can provide driver private/extra data?
2259 */
2260 }
2261 else
2262 {
2263 if (iModeNum == 0 || CachedDevModes == NULL) /* query modes from drivers */
2264 {
2265 BOOL PrimarySurfaceCreated = FALSE;
2266 UNICODE_STRING DriverFileNames;
2267 LPWSTR CurrentName;
2268 DRVENABLEDATA DrvEnableData;
2269
2270 /* Retrieve DDI driver names from registry */
2271 RtlInitUnicodeString(&DriverFileNames, NULL);
2272 if (!FindDriverFileNames(&DriverFileNames, DisplayNumber))
2273 {
2274 DPRINT1("FindDriverFileNames failed\n");
2275 return FALSE;
2276 }
2277
2278 if (!HalQueryDisplayOwnership())
2279 {
2280 IntCreatePrimarySurface();
2281 PrimarySurfaceCreated = TRUE;
2282 }
2283
2284 /*
2285 * DriverFileNames may be a list of drivers in REG_SZ_MULTI format,
2286 * scan all of them until a good one found.
2287 */
2288 CurrentName = DriverFileNames.Buffer;
2289 for (;CurrentName < DriverFileNames.Buffer + (DriverFileNames.Length / sizeof (WCHAR));
2290 CurrentName += wcslen(CurrentName) + 1)
2291 {
2292 INT i;
2293 PGD_ENABLEDRIVER GDEnableDriver;
2294
2295 /* Get the DDI driver's entry point */
2296 GDEnableDriver = DRIVER_FindDDIDriver(CurrentName);
2297 if (NULL == GDEnableDriver)
2298 {
2299 DPRINT("FindDDIDriver failed for %S\n", CurrentName);
2300 continue;
2301 }
2302
2303 /* Call DDI driver's EnableDriver function */
2304 RtlZeroMemory(&DrvEnableData, sizeof (DrvEnableData));
2305
2306 if (!GDEnableDriver(DDI_DRIVER_VERSION_NT5_01, sizeof (DrvEnableData), &DrvEnableData))
2307 {
2308 DPRINT("DrvEnableDriver failed for %S\n", CurrentName);
2309 continue;
2310 }
2311
2312 CachedDevModesEnd = CachedDevModes;
2313
2314 /* find DrvGetModes function */
2315 for (i = 0; i < DrvEnableData.c; i++)
2316 {
2317 PDRVFN DrvFn = DrvEnableData.pdrvfn + i;
2318 PGD_GETMODES GetModes;
2319 INT SizeNeeded, SizeUsed;
2320
2321 if (DrvFn->iFunc != INDEX_DrvGetModes)
2322 continue;
2323
2324 GetModes = (PGD_GETMODES)DrvFn->pfn;
2325
2326 /* make sure we have enough memory to hold the modes */
2327 SizeNeeded = GetModes((HANDLE)(PrimarySurface.VideoFileObject->DeviceObject), 0, NULL);
2328 if (SizeNeeded <= 0)
2329 {
2330 DPRINT("DrvGetModes failed for %S\n", CurrentName);
2331 break;
2332 }
2333
2334 SizeUsed = CachedDevModesEnd - CachedDevModes;
2335 if (SizeOfCachedDevModes - SizeUsed < SizeNeeded)
2336 {
2337 PVOID NewBuffer;
2338
2339 SizeOfCachedDevModes += SizeNeeded;
2340 NewBuffer = ExAllocatePool(PagedPool, SizeOfCachedDevModes);
2341 if (NewBuffer == NULL)
2342 {
2343 /* clean up */
2344 ExFreePool(CachedDevModes);
2345 SizeOfCachedDevModes = 0;
2346 CachedDevModes = NULL;
2347 CachedDevModesEnd = NULL;
2348 if (PrimarySurfaceCreated)
2349 {
2350 IntDestroyPrimarySurface();
2351 }
2352 SetLastWin32Error(STATUS_NO_MEMORY);
2353 return FALSE;
2354 }
2355 if (CachedDevModes != NULL)
2356 {
2357 RtlCopyMemory(NewBuffer, CachedDevModes, SizeUsed);
2358 ExFreePool(CachedDevModes);
2359 }
2360 CachedDevModes = NewBuffer;
2361 CachedDevModesEnd = (DEVMODEW *)((PCHAR)NewBuffer + SizeUsed);
2362 }
2363
2364 /* query modes */
2365 SizeNeeded = GetModes((HANDLE)(PrimarySurface.VideoFileObject->DeviceObject),
2366 SizeOfCachedDevModes - SizeUsed,
2367 CachedDevModesEnd);
2368 if (SizeNeeded <= 0)
2369 {
2370 DPRINT("DrvGetModes failed for %S\n", CurrentName);
2371 }
2372 else
2373 {
2374 CachedDevModesEnd = (DEVMODEW *)((PCHAR)CachedDevModesEnd + SizeNeeded);
2375 }
2376 break;
2377 }
2378 }
2379
2380 if (PrimarySurfaceCreated)
2381 {
2382 IntDestroyPrimarySurface();
2383 }
2384
2385 RtlFreeUnicodeString(&DriverFileNames);
2386 }
2387
2388 /* return cached info */
2389 CachedMode = CachedDevModes;
2390 if (CachedMode >= CachedDevModesEnd)
2391 {
2392 SetLastWin32Error(STATUS_NO_MORE_ENTRIES);
2393 return FALSE;
2394 }
2395 while (iModeNum-- > 0 && CachedMode < CachedDevModesEnd)
2396 {
2397 assert(CachedMode->dmSize > 0);
2398 CachedMode = (DEVMODEW *)((PCHAR)CachedMode + CachedMode->dmSize + CachedMode->dmDriverExtra);
2399 }
2400 if (CachedMode >= CachedDevModesEnd)
2401 {
2402 SetLastWin32Error(STATUS_NO_MORE_ENTRIES);
2403 return FALSE;
2404 }
2405 }
2406
2407 assert(CachedMode != NULL);
2408
2409 Size = OldSize = lpDevMode->dmSize;
2410 if (Size > CachedMode->dmSize)
2411 Size = CachedMode->dmSize;
2412 RtlCopyMemory(lpDevMode, CachedMode, Size);
2413 RtlZeroMemory((PCHAR)lpDevMode + Size, OldSize - Size);
2414 lpDevMode->dmSize = OldSize;
2415
2416 Size = OldSize = lpDevMode->dmDriverExtra;
2417 if (Size > CachedMode->dmDriverExtra)
2418 Size = CachedMode->dmDriverExtra;
2419 RtlCopyMemory((PCHAR)lpDevMode + lpDevMode->dmSize,
2420 (PCHAR)CachedMode + CachedMode->dmSize, Size);
2421 RtlZeroMemory((PCHAR)lpDevMode + lpDevMode->dmSize + Size, OldSize - Size);
2422 lpDevMode->dmDriverExtra = OldSize;
2423
2424 return TRUE;
2425 }
2426
2427 /* EOF */
A free Windows-compatible Operating System