projects / reactos.git / blob
? search:


462b759d89315f7b441d089582699f32813f0caa
[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.151 2004/12/12 21:25:05 weiden Exp $
20 *
21 * DC.C - Device context functions
22 *
23 */
24 #include <w32k.h>
25
26 #ifndef OBJ_COLORSPACE
27 #define OBJ_COLORSPACE (14)
28 #endif
29
30 static GDIDEVICE PrimarySurface;
31
32 /* FIXME: DCs should probably be thread safe */
33
34 /*
35 * DC device-independent Get/SetXXX functions
36 * (RJJ) swiped from WINE
37 */
38
39 #define DC_GET_VAL( func_type, func_name, dc_field ) \
40 func_type STDCALL func_name( HDC hdc ) \
41 { \
42 func_type ft; \
43 PDC dc = DC_LockDc( hdc ); \
44 if (!dc) \
45 { \
46 SetLastWin32Error(ERROR_INVALID_HANDLE); \
47 return 0; \
48 } \
49 ft = dc->dc_field; \
50 DC_UnlockDc( hdc ); \
51 return ft; \
52 }
53
54 /* DC_GET_VAL_EX is used to define functions returning a POINT or a SIZE. It is
55 * important that the function has the right signature, for the implementation
56 * we can do whatever we want.
57 */
58 #define DC_GET_VAL_EX( FuncName, ret_x, ret_y, type, ax, ay ) \
59 VOID FASTCALL Int##FuncName ( PDC dc, LP##type pt) \
60 { \
61 ASSERT(dc); \
62 ASSERT(pt); \
63 pt->ax = dc->ret_x; \
64 pt->ay = dc->ret_y; \
65 } \
66 BOOL STDCALL NtGdi##FuncName ( HDC hdc, LP##type pt ) \
67 { \
68 NTSTATUS Status; \
69 type Safept; \
70 PDC dc; \
71 if(!pt) \
72 { \
73 SetLastWin32Error(ERROR_INVALID_PARAMETER); \
74 return FALSE; \
75 } \
76 if(!(dc = DC_LockDc(hdc))) \
77 { \
78 SetLastWin32Error(ERROR_INVALID_HANDLE); \
79 return FALSE; \
80 } \
81 Int##FuncName( dc, &Safept); \
82 DC_UnlockDc(hdc); \
83 Status = MmCopyToCaller(pt, &Safept, sizeof( type )); \
84 if(!NT_SUCCESS(Status)) \
85 { \
86 SetLastNtError(Status); \
87 return FALSE; \
88 } \
89 return TRUE; \
90 }
91
92 #define DC_SET_MODE( func_name, dc_field, min_val, max_val ) \
93 INT STDCALL func_name( HDC hdc, INT mode ) \
94 { \
95 INT prevMode; \
96 PDC dc; \
97 if ((mode < min_val) || (mode > max_val)) \
98 { \
99 SetLastWin32Error(ERROR_INVALID_PARAMETER); \
100 return 0; \
101 } \
102 dc = DC_LockDc ( hdc ); \
103 if ( !dc ) \
104 { \
105 SetLastWin32Error(ERROR_INVALID_HANDLE); \
106 return 0; \
107 } \
108 prevMode = dc->dc_field; \
109 dc->dc_field = mode; \
110 DC_UnlockDc ( hdc ); \
111 return prevMode; \
112 }
113
114
115 // --------------------------------------------------------- File Statics
116
117 // ----------------------------------------------------- Public Functions
118
119 BOOL STDCALL
120 NtGdiCancelDC(HDC hDC)
121 {
122 UNIMPLEMENTED;
123 return FALSE;
124 }
125
126 HDC STDCALL
127 NtGdiCreateCompatableDC(HDC hDC)
128 {
129 PDC NewDC, OrigDC;
130 HBITMAP hBitmap;
131 HDC hNewDC, DisplayDC;
132 HRGN hVisRgn;
133 UNICODE_STRING DriverName;
134
135 DisplayDC = NULL;
136 if (hDC == NULL)
137 {
138 RtlInitUnicodeString(&DriverName, L"DISPLAY");
139 DisplayDC = IntGdiCreateDC(&DriverName, NULL, NULL, NULL);
140 if (NULL == DisplayDC)
141 {
142 return NULL;
143 }
144 hDC = DisplayDC;
145 }
146
147 /* Allocate a new DC based on the original DC's device */
148 OrigDC = DC_LockDc(hDC);
149 if (NULL == OrigDC)
150 {
151 if (NULL != DisplayDC)
152 {
153 NtGdiDeleteDC(DisplayDC);
154 }
155 return NULL;
156 }
157 hNewDC = DC_AllocDC(&OrigDC->DriverName);
158
159 if (NULL == hNewDC)
160 {
161 DC_UnlockDc(hDC);
162 if (NULL != DisplayDC)
163 {
164 NtGdiDeleteDC(DisplayDC);
165 }
166 return NULL;
167 }
168 NewDC = DC_LockDc( hNewDC );
169
170 /* Copy information from original DC to new DC */
171 NewDC->hSelf = hNewDC;
172
173 NewDC->PDev = OrigDC->PDev;
174 NewDC->DMW = OrigDC->DMW;
175 memcpy(NewDC->FillPatternSurfaces,
176 OrigDC->FillPatternSurfaces,
177 sizeof OrigDC->FillPatternSurfaces);
178 NewDC->GDIInfo = OrigDC->GDIInfo;
179 NewDC->DevInfo = OrigDC->DevInfo;
180 NewDC->w.bitsPerPixel = OrigDC->w.bitsPerPixel;
181
182 /* DriverName is copied in the AllocDC routine */
183 NewDC->DeviceDriver = OrigDC->DeviceDriver;
184 NewDC->wndOrgX = OrigDC->wndOrgX;
185 NewDC->wndOrgY = OrigDC->wndOrgY;
186 NewDC->wndExtX = OrigDC->wndExtX;
187 NewDC->wndExtY = OrigDC->wndExtY;
188 NewDC->vportOrgX = OrigDC->vportOrgX;
189 NewDC->vportOrgY = OrigDC->vportOrgY;
190 NewDC->vportExtX = OrigDC->vportExtX;
191 NewDC->vportExtY = OrigDC->vportExtY;
192
193 /* Create default bitmap */
194 if (!(hBitmap = NtGdiCreateBitmap( 1, 1, 1, NewDC->w.bitsPerPixel, NULL )))
195 {
196 DC_UnlockDc( hDC );
197 DC_UnlockDc( hNewDC );
198 DC_FreeDC( hNewDC );
199 if (NULL != DisplayDC)
200 {
201 NtGdiDeleteDC(DisplayDC);
202 }
203 return NULL;
204 }
205 NewDC->w.flags = DC_MEMORY;
206 NewDC->w.hBitmap = hBitmap;
207 NewDC->w.hFirstBitmap = hBitmap;
208 NewDC->GDIDevice = OrigDC->GDIDevice;
209
210 NewDC->w.hPalette = OrigDC->w.hPalette;
211 NewDC->w.textColor = OrigDC->w.textColor;
212 NewDC->w.textAlign = OrigDC->w.textAlign;
213 NewDC->w.backgroundColor = OrigDC->w.backgroundColor;
214 NewDC->w.backgroundMode = OrigDC->w.backgroundMode;
215 DC_UnlockDc( hDC );
216 if (NULL != DisplayDC)
217 {
218 NtGdiDeleteDC(DisplayDC);
219 }
220 DC_UnlockDc(hNewDC);
221
222 hVisRgn = NtGdiCreateRectRgn(0, 0, 1, 1);
223 NtGdiSelectVisRgn(hNewDC, hVisRgn);
224 NtGdiDeleteObject(hVisRgn);
225
226 DC_InitDC(hNewDC);
227
228 return hNewDC;
229 }
230
231 static BOOL FASTCALL
232 GetRegistryPath(PUNICODE_STRING RegistryPath, ULONG DisplayNumber)
233 {
234 RTL_QUERY_REGISTRY_TABLE QueryTable[2];
235 WCHAR DeviceNameBuffer[20];
236 NTSTATUS Status;
237
238 swprintf(DeviceNameBuffer, L"\\Device\\Video%d", DisplayNumber);
239 RtlInitUnicodeString(RegistryPath, NULL);
240 RtlZeroMemory(QueryTable, sizeof(QueryTable));
241 QueryTable[0].Flags = RTL_QUERY_REGISTRY_REQUIRED | RTL_QUERY_REGISTRY_DIRECT;
242 QueryTable[0].Name = DeviceNameBuffer;
243 QueryTable[0].EntryContext = RegistryPath;
244
245 Status = RtlQueryRegistryValues(RTL_REGISTRY_DEVICEMAP,
246 L"VIDEO",
247 QueryTable,
248 NULL,
249 NULL);
250 if (! NT_SUCCESS(Status))
251 {
252 DPRINT1("No \\Device\\Video%d value in DEVICEMAP\\VIDEO found\n", DisplayNumber);
253 return FALSE;
254 }
255
256 DPRINT("RegistryPath %S\n", RegistryPath->Buffer);
257
258 return TRUE;
259 }
260
261 static BOOL FASTCALL
262 FindDriverFileNames(PUNICODE_STRING DriverFileNames, ULONG DisplayNumber)
263 {
264 RTL_QUERY_REGISTRY_TABLE QueryTable[2];
265 UNICODE_STRING RegistryPath;
266 NTSTATUS Status;
267
268 if (! GetRegistryPath(&RegistryPath, DisplayNumber))
269 {
270 DPRINT("GetRegistryPath failed\n");
271 return FALSE;
272 }
273
274 RtlZeroMemory(QueryTable, sizeof(QueryTable));
275 QueryTable[0].Flags = RTL_QUERY_REGISTRY_REQUIRED | RTL_QUERY_REGISTRY_DIRECT;
276 QueryTable[0].Name = L"InstalledDisplayDrivers";
277 QueryTable[0].EntryContext = DriverFileNames;
278
279 Status = RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE,
280 RegistryPath.Buffer,
281 QueryTable,
282 NULL,
283 NULL);
284 RtlFreeUnicodeString(&RegistryPath);
285 if (! NT_SUCCESS(Status))
286 {
287 DPRINT1("No InstalledDisplayDrivers value in service entry found\n");
288 return FALSE;
289 }
290
291 DPRINT("DriverFileNames %S\n", DriverFileNames->Buffer);
292
293 return TRUE;
294 }
295
296 static NTSTATUS STDCALL
297 DevModeCallback(IN PWSTR ValueName,
298 IN ULONG ValueType,
299 IN PVOID ValueData,
300 IN ULONG ValueLength,
301 IN PVOID Context,
302 IN PVOID EntryContext)
303 {
304 PDEVMODEW DevMode = (PDEVMODEW) Context;
305
306 DPRINT("Found registry value for name %S: type %d, length %d\n",
307 ValueName, ValueType, ValueLength);
308
309 if (REG_DWORD == ValueType && sizeof(DWORD) == ValueLength)
310 {
311 if (0 == _wcsicmp(ValueName, L"DefaultSettings.BitsPerPel"))
312 {
313 DevMode->dmBitsPerPel = *((DWORD *) ValueData);
314 }
315 else if (0 == _wcsicmp(ValueName, L"DefaultSettings.Flags"))
316 {
317 DevMode->dmDisplayFlags = *((DWORD *) ValueData);
318 }
319 else if (0 == _wcsicmp(ValueName, L"DefaultSettings.VRefresh"))
320 {
321 DevMode->dmDisplayFrequency = *((DWORD *) ValueData);
322 }
323 else if (0 == _wcsicmp(ValueName, L"DefaultSettings.XPanning"))
324 {
325 DevMode->dmPanningWidth = *((DWORD *) ValueData);
326 }
327 else if (0 == _wcsicmp(ValueName, L"DefaultSettings.XResolution"))
328 {
329 DevMode->dmPelsWidth = *((DWORD *) ValueData);
330 }
331 else if (0 == _wcsicmp(ValueName, L"DefaultSettings.YPanning"))
332 {
333 DevMode->dmPanningHeight = *((DWORD *) ValueData);
334 }
335 else if (0 == _wcsicmp(ValueName, L"DefaultSettings.YResolution"))
336 {
337 DevMode->dmPelsHeight = *((DWORD *) ValueData);
338 }
339 }
340
341 return STATUS_SUCCESS;
342 }
343
344 static BOOL FASTCALL
345 SetupDevMode(PDEVMODEW DevMode, ULONG DisplayNumber)
346 {
347 static WCHAR RegistryMachineSystem[] = L"\\REGISTRY\\MACHINE\\SYSTEM\\";
348 static WCHAR CurrentControlSet[] = L"CURRENTCONTROLSET\\";
349 static WCHAR ControlSet[] = L"CONTROLSET";
350 static WCHAR Insert[] = L"Hardware Profiles\\Current\\System\\CurrentControlSet\\";
351 UNICODE_STRING RegistryPath;
352 BOOL Valid;
353 PWCHAR AfterControlSet;
354 PWCHAR ProfilePath;
355 RTL_QUERY_REGISTRY_TABLE QueryTable[2];
356 NTSTATUS Status;
357
358 if (! GetRegistryPath(&RegistryPath, DisplayNumber))
359 {
360 DPRINT("GetRegistryPath failed\n");
361 return FALSE;
362 }
363
364 Valid = (0 == _wcsnicmp(RegistryPath.Buffer, RegistryMachineSystem,
365 wcslen(RegistryMachineSystem)));
366 if (Valid)
367 {
368 AfterControlSet = RegistryPath.Buffer + wcslen(RegistryMachineSystem);
369 if (0 == _wcsnicmp(AfterControlSet, CurrentControlSet, wcslen(CurrentControlSet)))
370 {
371 AfterControlSet += wcslen(CurrentControlSet);
372 }
373 else if (0 == _wcsnicmp(AfterControlSet, ControlSet, wcslen(ControlSet)))
374 {
375 AfterControlSet += wcslen(ControlSet);
376 while (L'0' <= *AfterControlSet && L'9' <= *AfterControlSet)
377 {
378 AfterControlSet++;
379 }
380 Valid = (L'\\' == *AfterControlSet);
381 AfterControlSet++;
382 }
383 else
384 {
385 Valid = FALSE;
386 }
387 }
388
389 if (Valid)
390 {
391 ProfilePath = ExAllocatePoolWithTag(PagedPool,
392 (wcslen(RegistryPath.Buffer) +
393 wcslen(Insert) + 1) * sizeof(WCHAR),
394 TAG_DC);
395 if (NULL != ProfilePath)
396 {
397 wcsncpy(ProfilePath, RegistryPath.Buffer, AfterControlSet - RegistryPath.Buffer);
398 wcscpy(ProfilePath + (AfterControlSet - RegistryPath.Buffer), Insert);
399 wcscat(ProfilePath, AfterControlSet);
400
401 RtlZeroMemory(QueryTable, sizeof(QueryTable));
402 QueryTable[0].QueryRoutine = DevModeCallback;
403 QueryTable[0].Flags = 0;
404 QueryTable[0].Name = NULL;
405 QueryTable[0].EntryContext = NULL;
406 QueryTable[0].DefaultType = REG_NONE;
407 QueryTable[0].DefaultData = NULL;
408 QueryTable[0].DefaultLength = 0;
409
410 Status = RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE,
411 ProfilePath,
412 QueryTable,
413 DevMode,
414 NULL);
415 if (! NT_SUCCESS(Status))
416 {
417 DPRINT("RtlQueryRegistryValues for %S failed with status 0x%08x\n",
418 ProfilePath, Status);
419 Valid = FALSE;
420 }
421 else
422 {
423 DPRINT("dmBitsPerPel %d dmDisplayFrequency %d dmPelsWidth %d dmPelsHeight %d\n",
424 DevMode->dmBitsPerPel, DevMode->dmDisplayFrequency,
425 DevMode->dmPelsWidth, DevMode->dmPelsHeight);
426 if (0 == DevMode->dmBitsPerPel || 0 == DevMode->dmDisplayFrequency
427 || 0 == DevMode->dmPelsWidth || 0 == DevMode->dmPelsHeight)
428 {
429 DPRINT("Not all required devmode members are set\n");
430 Valid = FALSE;
431 }
432 }
433
434 ExFreePool(ProfilePath);
435 }
436 else
437 {
438 Valid = FALSE;
439 }
440 }
441 else
442 {
443 DPRINT1("Unparsable registry path %S in DEVICEMAP\\VIDEO0", RegistryPath.Buffer);
444 }
445
446 RtlFreeUnicodeString(&RegistryPath);
447
448 if (! Valid)
449 {
450 RtlZeroMemory(DevMode, sizeof(DEVMODEW));
451 }
452
453 return Valid;
454 }
455
456 BOOL FASTCALL
457 IntCreatePrimarySurface()
458 {
459 PGD_ENABLEDRIVER GDEnableDriver;
460 DRVENABLEDATA DED;
461 SURFOBJ *SurfObj;
462 SIZEL SurfSize;
463 UNICODE_STRING DriverFileNames;
464 PWSTR CurrentName;
465 BOOL GotDriver;
466 BOOL DoDefault;
467 ULONG DisplayNumber;
468 RECTL SurfaceRect;
469
470 for (DisplayNumber = 0; ; DisplayNumber++)
471 {
472 DPRINT("Trying to load display driver no. %d\n", DisplayNumber);
473
474 RtlZeroMemory(&PrimarySurface, sizeof(PrimarySurface));
475
476 PrimarySurface.VideoFileObject = DRIVER_FindMPDriver(DisplayNumber);
477
478 /* Open the miniport driver */
479 if (PrimarySurface.VideoFileObject == NULL)
480 {
481 DPRINT1("FindMPDriver failed\n");
482 return FALSE;
483 }
484
485 /* Retrieve DDI driver names from registry */
486 RtlInitUnicodeString(&DriverFileNames, NULL);
487 if (!FindDriverFileNames(&DriverFileNames, DisplayNumber))
488 {
489 DPRINT1("FindDriverFileNames failed\n");
490 /* return FALSE; */
491 continue;
492 }
493
494 /*
495 * DriverFileNames may be a list of drivers in REG_SZ_MULTI format,
496 * scan all of them until a good one found.
497 */
498 CurrentName = DriverFileNames.Buffer;
499 GotDriver = FALSE;
500 while (!GotDriver &&
501 CurrentName < DriverFileNames.Buffer + (DriverFileNames.Length / sizeof (WCHAR)))
502 {
503 /* Get the DDI driver's entry point */
504 GDEnableDriver = DRIVER_FindDDIDriver(CurrentName);
505 if (NULL == GDEnableDriver)
506 {
507 DPRINT("FindDDIDriver failed for %S\n", CurrentName);
508 }
509 else
510 {
511 /* Call DDI driver's EnableDriver function */
512 RtlZeroMemory(&DED, sizeof(DED));
513
514 if (! GDEnableDriver(DDI_DRIVER_VERSION_NT5_01, sizeof(DED), &DED))
515 {
516 DPRINT("DrvEnableDriver failed for %S\n", CurrentName);
517 }
518 else
519 {
520 GotDriver = TRUE;
521 }
522 }
523
524 if (! GotDriver)
525 {
526 /* Skip to the next name but never get past the Unicode string */
527 while (L'\0' != *CurrentName &&
528 CurrentName < DriverFileNames.Buffer + (DriverFileNames.Length / sizeof (WCHAR)))
529 {
530 CurrentName++;
531 }
532 if (CurrentName < DriverFileNames.Buffer + (DriverFileNames.Length / sizeof (WCHAR)))
533 {
534 CurrentName++;
535 }
536 }
537 }
538
539 RtlFreeUnicodeString(&DriverFileNames);
540
541 if (!GotDriver)
542 {
543 ObDereferenceObject(PrimarySurface.VideoFileObject);
544 DPRINT1("No suitable DDI driver found\n");
545 /* return FALSE; */
546 continue;
547 }
548
549 DPRINT("Display driver %S loaded\n", CurrentName);
550
551 DPRINT("Building DDI Functions\n");
552
553 /* Construct DDI driver function dispatch table */
554 if (!DRIVER_BuildDDIFunctions(&DED, &PrimarySurface.DriverFunctions))
555 {
556 ObDereferenceObject(PrimarySurface.VideoFileObject);
557 DPRINT1("BuildDDIFunctions failed\n");
558 return FALSE;
559 }
560
561 /* Allocate a phyical device handle from the driver */
562 PrimarySurface.DMW.dmSize = sizeof (PrimarySurface.DMW);
563 if (SetupDevMode(&PrimarySurface.DMW, DisplayNumber))
564 {
565 PrimarySurface.PDev = PrimarySurface.DriverFunctions.EnablePDEV(
566 &PrimarySurface.DMW,
567 L"",
568 HS_DDI_MAX,
569 PrimarySurface.FillPatterns,
570 sizeof(PrimarySurface.GDIInfo),
571 (ULONG *) &PrimarySurface.GDIInfo,
572 sizeof(PrimarySurface.DevInfo),
573 &PrimarySurface.DevInfo,
574 NULL,
575 L"",
576 (HANDLE) (PrimarySurface.VideoFileObject->DeviceObject));
577 DoDefault = (NULL == PrimarySurface.PDev);
578 if (DoDefault)
579 {
580 DPRINT1("DrvEnablePDev with registry parameters failed\n");
581 }
582 }
583 else
584 {
585 DoDefault = TRUE;
586 }
587
588 if (DoDefault)
589 {
590 RtlZeroMemory(&(PrimarySurface.DMW), sizeof(DEVMODEW));
591 PrimarySurface.DMW.dmSize = sizeof (PrimarySurface.DMW);
592 PrimarySurface.PDev = PrimarySurface.DriverFunctions.EnablePDEV(
593 &PrimarySurface.DMW,
594 L"",
595 HS_DDI_MAX,
596 PrimarySurface.FillPatterns,
597 sizeof(PrimarySurface.GDIInfo),
598 (ULONG *) &PrimarySurface.GDIInfo,
599 sizeof(PrimarySurface.DevInfo),
600 &PrimarySurface.DevInfo,
601 NULL,
602 L"",
603 (HANDLE) (PrimarySurface.VideoFileObject->DeviceObject));
604
605 if (NULL == PrimarySurface.PDev)
606 {
607 ObDereferenceObject(PrimarySurface.VideoFileObject);
608 DPRINT1("DrvEnablePDEV with default parameters failed\n");
609 DPRINT1("Perhaps DDI driver doesn't match miniport driver?\n");
610 /* return FALSE; */
611 continue;
612 }
613 }
614
615 if (0 == PrimarySurface.GDIInfo.ulLogPixelsX)
616 {
617 DPRINT("Adjusting GDIInfo.ulLogPixelsX\n");
618 PrimarySurface.GDIInfo.ulLogPixelsX = 96;
619 }
620 if (0 == PrimarySurface.GDIInfo.ulLogPixelsY)
621 {
622 DPRINT("Adjusting GDIInfo.ulLogPixelsY\n");
623 PrimarySurface.GDIInfo.ulLogPixelsY = 96;
624 }
625
626 PrimarySurface.Pointer.Exclude.right = -1;
627
628 DPRINT("calling completePDev\n");
629
630 /* Complete initialization of the physical device */
631 PrimarySurface.DriverFunctions.CompletePDEV(
632 PrimarySurface.PDev,
633 (HDEV)&PrimarySurface);
634
635 DPRINT("calling DRIVER_ReferenceDriver\n");
636
637 DRIVER_ReferenceDriver(L"DISPLAY");
638
639 DPRINT("calling EnableSurface\n");
640
641 /* Enable the drawing surface */
642 PrimarySurface.Handle =
643 PrimarySurface.DriverFunctions.EnableSurface(PrimarySurface.PDev);
644 if (NULL == PrimarySurface.Handle)
645 {
646 /* PrimarySurface.DriverFunctions.AssertMode(PrimarySurface.PDev, FALSE);*/
647 PrimarySurface.DriverFunctions.DisablePDEV(PrimarySurface.PDev);
648 ObDereferenceObject(PrimarySurface.VideoFileObject);
649 DPRINT1("DrvEnableSurface failed\n");
650 /* return FALSE; */
651 continue;
652 }
653
654 /* attach monitor */
655 IntAttachMonitor(&PrimarySurface, DisplayNumber);
656
657 SurfObj = EngLockSurface((HSURF)PrimarySurface.Handle);
658 SurfObj->dhpdev = PrimarySurface.PDev;
659 SurfSize = SurfObj->sizlBitmap;
660 SurfSize = SurfObj->sizlBitmap;
661 SurfaceRect.left = SurfaceRect.top = 0;
662 SurfaceRect.right = SurfObj->sizlBitmap.cx;
663 SurfaceRect.bottom = SurfObj->sizlBitmap.cy;
664 /* FIXME - why does EngEraseSurface() sometimes crash?
665 EngEraseSurface(SurfObj, &SurfaceRect, 0); */
666 EngUnlockSurface(SurfObj);
667 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 STDCALL
1273 NtGdiGetDeviceCaps(HDC hDC,
1274 INT Index)
1275 {
1276 PDC dc;
1277 INT ret;
1278 POINT pt;
1279
1280 dc = DC_LockDc(hDC);
1281 if (dc == NULL)
1282 {
1283 SetLastWin32Error(ERROR_INVALID_HANDLE);
1284 return 0;
1285 }
1286
1287 /* Retrieve capability */
1288 switch (Index)
1289 {
1290 case DRIVERVERSION:
1291 ret = dc->GDIInfo->ulVersion;
1292 break;
1293
1294 case TECHNOLOGY:
1295 ret = dc->GDIInfo->ulTechnology;
1296 break;
1297
1298 case HORZSIZE:
1299 ret = dc->GDIInfo->ulHorzSize;
1300 break;
1301
1302 case VERTSIZE:
1303 ret = dc->GDIInfo->ulVertSize;
1304 break;
1305
1306 case HORZRES:
1307 ret = dc->GDIInfo->ulHorzRes;
1308 break;
1309
1310 case VERTRES:
1311 ret = dc->GDIInfo->ulVertRes;
1312 break;
1313
1314 case LOGPIXELSX:
1315 ret = dc->GDIInfo->ulLogPixelsX;
1316 break;
1317
1318 case LOGPIXELSY:
1319 ret = dc->GDIInfo->ulLogPixelsY;
1320 break;
1321
1322 case BITSPIXEL:
1323 ret = dc->GDIInfo->cBitsPixel;
1324 break;
1325
1326 case PLANES:
1327 ret = dc->GDIInfo->cPlanes;
1328 break;
1329
1330 case NUMBRUSHES:
1331 UNIMPLEMENTED; /* FIXME */
1332 break;
1333
1334 case NUMPENS:
1335 UNIMPLEMENTED; /* FIXME */
1336 break;
1337
1338 case NUMFONTS:
1339 UNIMPLEMENTED; /* FIXME */
1340 break;
1341
1342 case NUMCOLORS:
1343 ret = dc->GDIInfo->ulNumColors;
1344 break;
1345
1346 case ASPECTX:
1347 ret = dc->GDIInfo->ulAspectX;
1348 break;
1349
1350 case ASPECTY:
1351 ret = dc->GDIInfo->ulAspectY;
1352 break;
1353
1354 case ASPECTXY:
1355 ret = dc->GDIInfo->ulAspectXY;
1356 break;
1357
1358 case PDEVICESIZE:
1359 UNIMPLEMENTED; /* FIXME */
1360 break;
1361
1362 case CLIPCAPS:
1363 UNIMPLEMENTED; /* FIXME */
1364 break;
1365
1366 case SIZEPALETTE:
1367 ret = dc->GDIInfo->ulNumPalReg; /* FIXME not sure */
1368 break;
1369
1370 case NUMRESERVED:
1371 ret = 0;
1372 break;
1373
1374 case COLORRES:
1375 UNIMPLEMENTED; /* FIXME */
1376 break;
1377
1378 case PHYSICALWIDTH:
1379 if(NtGdiEscape(hDC, GETPHYSPAGESIZE, 0, NULL, (LPVOID)&pt) > 0)
1380 {
1381 ret = pt.x;
1382 }
1383 else
1384 {
1385 ret = 0;
1386 }
1387 break;
1388
1389 case PHYSICALHEIGHT:
1390 if(NtGdiEscape(hDC, GETPHYSPAGESIZE, 0, NULL, (LPVOID)&pt) > 0)
1391 {
1392 ret = pt.y;
1393 }
1394 else
1395 {
1396 ret = 0;
1397 }
1398 break;
1399
1400 case PHYSICALOFFSETX:
1401 if(NtGdiEscape(hDC, GETPRINTINGOFFSET, 0, NULL, (LPVOID)&pt) > 0)
1402 {
1403 ret = pt.x;
1404 }
1405 else
1406 {
1407 ret = 0;
1408 }
1409 break;
1410
1411 case PHYSICALOFFSETY:
1412 if(NtGdiEscape(hDC, GETPRINTINGOFFSET, 0, NULL, (LPVOID)&pt) > 0)
1413 {
1414 ret = pt.y;
1415 }
1416 else
1417 {
1418 ret = 0;
1419 }
1420 break;
1421
1422 case VREFRESH:
1423 UNIMPLEMENTED; /* FIXME */
1424 break;
1425
1426 case SCALINGFACTORX:
1427 if(NtGdiEscape(hDC, GETSCALINGFACTOR, 0, NULL, (LPVOID)&pt) > 0)
1428 {
1429 ret = pt.x;
1430 }
1431 else
1432 {
1433 ret = 0;
1434 }
1435 break;
1436
1437 case SCALINGFACTORY:
1438 if(NtGdiEscape(hDC, GETSCALINGFACTOR, 0, NULL, (LPVOID)&pt) > 0)
1439 {
1440 ret = pt.y;
1441 }
1442 else
1443 {
1444 ret = 0;
1445 }
1446 break;
1447
1448 case RASTERCAPS:
1449 ret = dc->GDIInfo->flRaster;
1450 break;
1451
1452 case CURVECAPS:
1453 UNIMPLEMENTED; /* FIXME */
1454 break;
1455
1456 case LINECAPS:
1457 UNIMPLEMENTED; /* FIXME */
1458 break;
1459
1460 case POLYGONALCAPS:
1461 UNIMPLEMENTED; /* FIXME */
1462 break;
1463
1464 case TEXTCAPS:
1465 ret = dc->GDIInfo->flTextCaps;
1466 break;
1467
1468 default:
1469 ret = 0;
1470 break;
1471 }
1472
1473 DPRINT("(%04x,%d): returning %d\n", hDC, Index, ret);
1474
1475 DC_UnlockDc( hDC );
1476 return ret;
1477 }
1478
1479 DC_GET_VAL( INT, NtGdiGetMapMode, w.MapMode )
1480 DC_GET_VAL( INT, NtGdiGetPolyFillMode, w.polyFillMode )
1481
1482 INT FASTCALL
1483 IntGdiGetObject(HANDLE Handle, INT Count, LPVOID Buffer)
1484 {
1485 PVOID GdiObject;
1486 INT Result = 0;
1487 DWORD ObjectType;
1488
1489 GdiObject = GDIOBJ_LockObj(Handle, GDI_OBJECT_TYPE_DONTCARE);
1490 if (NULL == GdiObject)
1491 {
1492 SetLastWin32Error(ERROR_INVALID_HANDLE);
1493 return 0;
1494 }
1495
1496 ObjectType = GDIOBJ_GetObjectType(Handle);
1497 switch (ObjectType)
1498 {
1499 #if 0
1500 case GDI_OBJECT_TYPE_PEN:
1501 Result = PEN_GetObject((PENOBJ *) GdiObject, Count, Buffer);
1502 break;
1503 case GDI_OBJECT_TYPE_BRUSH:
1504 Result = BRUSH_GetObject((BRUSHOBJ *) GdiObject, Count, Buffer);
1505 break;
1506 #endif
1507 case GDI_OBJECT_TYPE_BITMAP:
1508 Result = BITMAP_GetObject((BITMAPOBJ *) GdiObject, Count, Buffer);
1509 break;
1510 case GDI_OBJECT_TYPE_FONT:
1511 Result = FontGetObject((PTEXTOBJ) GdiObject, Count, Buffer);
1512 #if 0
1513 // Fix the LOGFONT structure for the stock fonts
1514 if (FIRST_STOCK_HANDLE <= Handle && Handle <= LAST_STOCK_HANDLE)
1515 {
1516 FixStockFontSizeW(Handle, Count, Buffer);
1517 }
1518 #endif
1519 break;
1520 #if 0
1521 case GDI_OBJECT_TYPE_PALETTE:
1522 Result = PALETTE_GetObject((PALETTEOBJ *) GdiObject, Count, Buffer);
1523 break;
1524 #endif
1525 default:
1526 DPRINT1("GDI object type 0x%08x not implemented\n", ObjectType);
1527 break;
1528 }
1529
1530 GDIOBJ_UnlockObj(Handle);
1531
1532 return Result;
1533 }
1534
1535 INT STDCALL
1536 NtGdiGetObject(HANDLE handle, INT count, LPVOID buffer)
1537 {
1538 INT Ret;
1539 LPVOID SafeBuf;
1540 NTSTATUS Status;
1541
1542 if (count <= 0)
1543 {
1544 return 0;
1545 }
1546
1547 SafeBuf = ExAllocatePoolWithTag(PagedPool, count, TAG_GDIOBJ);
1548 if(!SafeBuf)
1549 {
1550 SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
1551 return 0;
1552 }
1553
1554 Ret = IntGdiGetObject(handle, count, SafeBuf);
1555
1556 Status = MmCopyToCaller(buffer, SafeBuf, count);
1557 ExFreePool(SafeBuf);
1558 if(!NT_SUCCESS(Status))
1559 {
1560 SetLastNtError(Status);
1561 return 0;
1562 }
1563
1564 return Ret;
1565 }
1566
1567 DWORD STDCALL
1568 NtGdiGetObjectType(HANDLE handle)
1569 {
1570 GDIOBJHDR * ptr;
1571 INT result;
1572 DWORD objectType;
1573
1574 ptr = GDIOBJ_LockObj(handle, GDI_OBJECT_TYPE_DONTCARE);
1575 if (ptr == 0)
1576 {
1577 SetLastWin32Error(ERROR_INVALID_HANDLE);
1578 return 0;
1579 }
1580
1581 objectType = GDIOBJ_GetObjectType(handle);
1582 switch(objectType)
1583 {
1584 case GDI_OBJECT_TYPE_PEN:
1585 result = OBJ_PEN;
1586 break;
1587 case GDI_OBJECT_TYPE_BRUSH:
1588 result = OBJ_BRUSH;
1589 break;
1590 case GDI_OBJECT_TYPE_BITMAP:
1591 result = OBJ_BITMAP;
1592 break;
1593 case GDI_OBJECT_TYPE_FONT:
1594 result = OBJ_FONT;
1595 break;
1596 case GDI_OBJECT_TYPE_PALETTE:
1597 result = OBJ_PAL;
1598 break;
1599 case GDI_OBJECT_TYPE_REGION:
1600 result = OBJ_REGION;
1601 break;
1602 case GDI_OBJECT_TYPE_DC:
1603 result = OBJ_DC;
1604 break;
1605 case GDI_OBJECT_TYPE_METADC:
1606 result = OBJ_METADC;
1607 break;
1608 case GDI_OBJECT_TYPE_METAFILE:
1609 result = OBJ_METAFILE;
1610 break;
1611 case GDI_OBJECT_TYPE_ENHMETAFILE:
1612 result = OBJ_ENHMETAFILE;
1613 break;
1614 case GDI_OBJECT_TYPE_ENHMETADC:
1615 result = OBJ_ENHMETADC;
1616 break;
1617 case GDI_OBJECT_TYPE_EXTPEN:
1618 result = OBJ_EXTPEN;
1619 break;
1620 case GDI_OBJECT_TYPE_MEMDC:
1621 result = OBJ_MEMDC;
1622 break;
1623
1624 default:
1625 DPRINT1("Magic 0x%08x not implemented\n", objectType);
1626 result = 0;
1627 break;
1628 }
1629 GDIOBJ_UnlockObj(handle);
1630 return result;
1631 }
1632
1633 DC_GET_VAL( INT, NtGdiGetRelAbs, w.relAbsMode )
1634 DC_GET_VAL( INT, NtGdiGetROP2, w.ROPmode )
1635 DC_GET_VAL( INT, NtGdiGetStretchBltMode, w.stretchBltMode )
1636 DC_GET_VAL( UINT, NtGdiGetTextAlign, w.textAlign )
1637 DC_GET_VAL( COLORREF, NtGdiGetTextColor, w.textColor )
1638 DC_GET_VAL_EX( GetViewportExtEx, vportExtX, vportExtY, SIZE, cx, cy )
1639 DC_GET_VAL_EX( GetViewportOrgEx, vportOrgX, vportOrgY, POINT, x, y )
1640 DC_GET_VAL_EX( GetWindowExtEx, wndExtX, wndExtY, SIZE, cx, cy )
1641 DC_GET_VAL_EX( GetWindowOrgEx, wndOrgX, wndOrgY, POINT, x, y )
1642
1643 HDC STDCALL
1644 NtGdiResetDC(HDC hDC, CONST DEVMODEW *InitData)
1645 {
1646 UNIMPLEMENTED;
1647 return 0;
1648 }
1649
1650 BOOL STDCALL
1651 NtGdiRestoreDC(HDC hDC, INT SaveLevel)
1652 {
1653 PDC dc, dcs;
1654 BOOL success;
1655
1656 DPRINT("NtGdiRestoreDC(%lx, %d)\n", hDC, SaveLevel);
1657
1658 dc = DC_LockDc(hDC);
1659 if (!dc)
1660 {
1661 SetLastWin32Error(ERROR_INVALID_HANDLE);
1662 return FALSE;
1663 }
1664
1665 if (SaveLevel == -1)
1666 SaveLevel = dc->saveLevel;
1667
1668 if ((SaveLevel < 1) || (SaveLevel > dc->saveLevel))
1669 {
1670 DC_UnlockDc(hDC);
1671 return FALSE;
1672 }
1673
1674 success = TRUE;
1675 while (dc->saveLevel >= SaveLevel)
1676 {
1677 HDC hdcs = DC_GetNextDC (dc);
1678
1679 dcs = DC_LockDc (hdcs);
1680 if (dcs == NULL)
1681 {
1682 DC_UnlockDc(hDC);
1683 return FALSE;
1684 }
1685 DC_SetNextDC (dcs, DC_GetNextDC (dcs));
1686 if (--dc->saveLevel < SaveLevel)
1687 {
1688 DC_UnlockDc( hDC );
1689 DC_UnlockDc( hdcs );
1690 NtGdiSetDCState(hDC, hdcs);
1691 #if 0
1692 if (!PATH_AssignGdiPath( &dc->w.path, &dcs->w.path ))
1693 {
1694 /* FIXME: This might not be quite right, since we're
1695 * returning FALSE but still destroying the saved DC state */
1696 success = FALSE;
1697 }
1698 #endif
1699 dc = DC_LockDc(hDC);
1700 if(!dc)
1701 {
1702 return FALSE;
1703 }
1704 }
1705 else
1706 {
1707 DC_UnlockDc( hdcs );
1708 }
1709 NtGdiDeleteDC (hdcs);
1710 }
1711 DC_UnlockDc( hDC );
1712 return success;
1713 }
1714
1715 INT STDCALL
1716 NtGdiSaveDC(HDC hDC)
1717 {
1718 HDC hdcs;
1719 PDC dc, dcs;
1720 INT ret;
1721
1722 DPRINT("NtGdiSaveDC(%lx)\n", hDC);
1723
1724 if (!(hdcs = NtGdiGetDCState(hDC)))
1725 {
1726 return 0;
1727 }
1728
1729 dcs = DC_LockDc (hdcs);
1730 if (dcs == NULL)
1731 {
1732 SetLastWin32Error(ERROR_INVALID_HANDLE);
1733 return 0;
1734 }
1735 dc = DC_LockDc (hDC);
1736 if (dc == NULL)
1737 {
1738 DC_UnlockDc(hdcs);
1739 SetLastWin32Error(ERROR_INVALID_HANDLE);
1740 return 0;
1741 }
1742
1743 #if 0
1744 /* Copy path. The reason why path saving / restoring is in SaveDC/
1745 * RestoreDC and not in GetDCState/SetDCState is that the ...DCState
1746 * functions are only in Win16 (which doesn't have paths) and that
1747 * SetDCState doesn't allow us to signal an error (which can happen
1748 * when copying paths).
1749 */
1750 if (!PATH_AssignGdiPath (&dcs->w.path, &dc->w.path))
1751 {
1752 NtGdiDeleteDC (hdcs);
1753 return 0;
1754 }
1755 #endif
1756
1757 DC_SetNextDC (dcs, DC_GetNextDC (dc));
1758 DC_SetNextDC (dc, hdcs);
1759 ret = ++dc->saveLevel;
1760 DC_UnlockDc( hdcs );
1761 DC_UnlockDc( hDC );
1762
1763 return ret;
1764 }
1765
1766 HGDIOBJ
1767 STDCALL
1768 NtGdiSelectObject(HDC hDC, HGDIOBJ hGDIObj)
1769 {
1770 HGDIOBJ objOrg = NULL; // default to failure
1771 BITMAPOBJ *pb;
1772 PDC dc;
1773 PGDIBRUSHOBJ pen;
1774 PGDIBRUSHOBJ brush;
1775 XLATEOBJ *XlateObj;
1776 DWORD objectType;
1777 ULONG NumColors = 0;
1778 HRGN hVisRgn;
1779 BOOLEAN Failed;
1780
1781 if(!hDC || !hGDIObj) return NULL;
1782
1783 dc = DC_LockDc(hDC);
1784 if (NULL == dc)
1785 {
1786 SetLastWin32Error(ERROR_INVALID_HANDLE);
1787 return NULL;
1788 }
1789
1790 objectType = GDIOBJ_GetObjectType(hGDIObj);
1791
1792 switch (objectType)
1793 {
1794 case GDI_OBJECT_TYPE_PEN:
1795 pen = PENOBJ_LockPen((HPEN) hGDIObj);
1796 if (pen == NULL)
1797 {
1798 SetLastWin32Error(ERROR_INVALID_HANDLE);
1799 break;
1800 }
1801
1802 XlateObj = IntGdiCreateBrushXlate(dc, pen, &Failed);
1803 PENOBJ_UnlockPen(hGDIObj);
1804 if (Failed)
1805 {
1806 SetLastWin32Error(ERROR_NO_SYSTEM_RESOURCES);
1807 break;
1808 }
1809
1810 objOrg = (HGDIOBJ)dc->w.hPen;
1811 dc->w.hPen = hGDIObj;
1812 if (dc->XlatePen != NULL)
1813 EngDeleteXlate(dc->XlatePen);
1814 dc->XlatePen = XlateObj;
1815 break;
1816
1817 case GDI_OBJECT_TYPE_BRUSH:
1818 brush = BRUSHOBJ_LockBrush((HPEN) hGDIObj);
1819 if (brush == NULL)
1820 {
1821 SetLastWin32Error(ERROR_INVALID_HANDLE);
1822 break;
1823 }
1824
1825 XlateObj = IntGdiCreateBrushXlate(dc, brush, &Failed);
1826 BRUSHOBJ_UnlockBrush(hGDIObj);
1827 if (Failed)
1828 {
1829 SetLastWin32Error(ERROR_NO_SYSTEM_RESOURCES);
1830 break;
1831 }
1832
1833 objOrg = (HGDIOBJ)dc->w.hBrush;
1834 dc->w.hBrush = hGDIObj;
1835 if (dc->XlateBrush != NULL)
1836 EngDeleteXlate(dc->XlateBrush);
1837 dc->XlateBrush = XlateObj;
1838 break;
1839
1840 case GDI_OBJECT_TYPE_FONT:
1841 if(NT_SUCCESS(TextIntRealizeFont((HFONT)hGDIObj)))
1842 {
1843 objOrg = (HGDIOBJ)dc->w.hFont;
1844 dc->w.hFont = (HFONT) hGDIObj;
1845 }
1846 break;
1847
1848 case GDI_OBJECT_TYPE_BITMAP:
1849 // must be memory dc to select bitmap
1850 if (!(dc->w.flags & DC_MEMORY))
1851 {
1852 DC_UnlockDc(hDC);
1853 return NULL;
1854 }
1855 pb = BITMAPOBJ_LockBitmap(hGDIObj);
1856 if (NULL == pb)
1857 {
1858 SetLastWin32Error(ERROR_INVALID_HANDLE);
1859 DC_UnlockDc(hDC);
1860 return NULL;
1861 }
1862 objOrg = (HGDIOBJ)dc->w.hBitmap;
1863
1864 /* Release the old bitmap, lock the new one and convert it to a SURF */
1865 dc->w.hBitmap = hGDIObj;
1866
1867 // if we're working with a DIB, get the palette [fixme: only create if the selected palette is null]
1868 if(pb->dib)
1869 {
1870 dc->w.bitsPerPixel = pb->dib->dsBmih.biBitCount;
1871
1872 if(pb->dib->dsBmih.biBitCount <= 8)
1873 {
1874 if(pb->dib->dsBmih.biBitCount == 1) { NumColors = 2; } else
1875 if(pb->dib->dsBmih.biBitCount == 4) { NumColors = 16; } else
1876 if(pb->dib->dsBmih.biBitCount == 8) { NumColors = 256; }
1877 dc->w.hPalette = PALETTE_AllocPaletteIndexedRGB(NumColors, pb->ColorMap);
1878 }
1879 else
1880 {
1881 dc->w.hPalette = PALETTE_AllocPalette(PAL_BITFIELDS, 0, NULL,
1882 pb->dib->dsBitfields[0],
1883 pb->dib->dsBitfields[1],
1884 pb->dib->dsBitfields[2]);
1885 }
1886 }
1887 else
1888 {
1889 dc->w.bitsPerPixel = BitsPerFormat(pb->SurfObj.iBitmapFormat);
1890 dc->w.hPalette = dc->DevInfo->hpalDefault;
1891 }
1892
1893 /* Reselect brush and pen to regenerate the XLATEOBJs. */
1894 NtGdiSelectObject ( hDC, dc->w.hBrush );
1895 NtGdiSelectObject ( hDC, dc->w.hPen );
1896
1897 DC_UnlockDc ( hDC );
1898 hVisRgn = NtGdiCreateRectRgn ( 0, 0, pb->SurfObj.sizlBitmap.cx, pb->SurfObj.sizlBitmap.cy );
1899 BITMAPOBJ_UnlockBitmap( hGDIObj );
1900 NtGdiSelectVisRgn ( hDC, hVisRgn );
1901 NtGdiDeleteObject ( hVisRgn );
1902
1903 return objOrg;
1904
1905 case GDI_OBJECT_TYPE_REGION:
1906 DC_UnlockDc (hDC);
1907 /*
1908 * The return value is one of the following values:
1909 * SIMPLEREGION
1910 * COMPLEXREGION
1911 * NULLREGION
1912 */
1913 return (HGDIOBJ) NtGdiSelectClipRgn(hDC, (HRGN) hGDIObj);
1914
1915 default:
1916 break;
1917 }
1918 DC_UnlockDc( hDC );
1919 return objOrg;
1920 }
1921
1922 WORD STDCALL
1923 NtGdiSetHookFlags(HDC hDC, WORD Flags)
1924 {
1925 WORD wRet;
1926 DC *dc = DC_LockDc(hDC);
1927
1928 if (NULL == dc)
1929 {
1930 SetLastWin32Error(ERROR_INVALID_HANDLE);
1931 return 0;
1932 }
1933
1934 wRet = dc->w.flags & DC_DIRTY;
1935
1936 /* "Undocumented Windows" info is slightly confusing.
1937 */
1938
1939 DPRINT("DC %p, Flags %04x\n", hDC, Flags);
1940
1941 if (Flags & DCHF_INVALIDATEVISRGN)
1942 {
1943 dc->w.flags |= DC_DIRTY;
1944 }
1945 else if (Flags & DCHF_VALIDATEVISRGN || 0 == Flags)
1946 {
1947 dc->w.flags &= ~DC_DIRTY;
1948 }
1949
1950 DC_UnlockDc(hDC);
1951
1952 return wRet;
1953 }
1954
1955 DC_SET_MODE( NtGdiSetBkMode, w.backgroundMode, TRANSPARENT, OPAQUE )
1956 DC_SET_MODE( NtGdiSetPolyFillMode, w.polyFillMode, ALTERNATE, WINDING )
1957 // DC_SET_MODE( NtGdiSetRelAbs, w.relAbsMode, ABSOLUTE, RELATIVE )
1958 DC_SET_MODE( NtGdiSetROP2, w.ROPmode, R2_BLACK, R2_WHITE )
1959 DC_SET_MODE( NtGdiSetStretchBltMode, w.stretchBltMode, BLACKONWHITE, HALFTONE )
1960
1961 // ---------------------------------------------------- Private Interface
1962
1963 HDC FASTCALL
1964 DC_AllocDC(PUNICODE_STRING Driver)
1965 {
1966 PDC NewDC;
1967 HDC hDC;
1968 PWSTR Buf = NULL;
1969
1970 if (Driver != NULL)
1971 {
1972 Buf = ExAllocatePoolWithTag(PagedPool, Driver->MaximumLength, TAG_DC);
1973 if(!Buf)
1974 {
1975 return NULL;
1976 }
1977 RtlCopyMemory(Buf, Driver->Buffer, Driver->MaximumLength);
1978 }
1979
1980 hDC = (HDC) GDIOBJ_AllocObj(GDI_OBJECT_TYPE_DC);
1981 if (hDC == NULL)
1982 {
1983 if(Buf)
1984 {
1985 ExFreePool(Buf);
1986 }
1987 return NULL;
1988 }
1989
1990 NewDC = DC_LockDc(hDC);
1991 /* FIXME - Handle NewDC == NULL! */
1992
1993 if (Driver != NULL)
1994 {
1995 RtlCopyMemory(&NewDC->DriverName, Driver, sizeof(UNICODE_STRING));
1996 NewDC->DriverName.Buffer = Buf;
1997 }
1998
1999 NewDC->w.xformWorld2Wnd.eM11 = 1.0f;
2000 NewDC->w.xformWorld2Wnd.eM12 = 0.0f;
2001 NewDC->w.xformWorld2Wnd.eM21 = 0.0f;
2002 NewDC->w.xformWorld2Wnd.eM22 = 1.0f;
2003 NewDC->w.xformWorld2Wnd.eDx = 0.0f;
2004 NewDC->w.xformWorld2Wnd.eDy = 0.0f;
2005 NewDC->w.xformWorld2Vport = NewDC->w.xformWorld2Wnd;
2006 NewDC->w.xformVport2World = NewDC->w.xformWorld2Wnd;
2007 NewDC->w.vport2WorldValid = TRUE;
2008 NewDC->w.MapMode = MM_TEXT;
2009 NewDC->wndExtX = 1.0f;
2010 NewDC->wndExtY = 1.0f;
2011 NewDC->vportExtX = 1.0f;
2012 NewDC->vportExtY = 1.0f;
2013 NewDC->w.textColor = 0;
2014 NewDC->w.backgroundColor = 0xffffff;
2015
2016 NewDC->w.hFont = NtGdiGetStockObject(SYSTEM_FONT);
2017 TextIntRealizeFont(NewDC->w.hFont);
2018
2019 NewDC->w.hPalette = NtGdiGetStockObject(DEFAULT_PALETTE);
2020
2021 DC_UnlockDc(hDC);
2022
2023 return hDC;
2024 }
2025
2026 HDC FASTCALL
2027 DC_FindOpenDC(PUNICODE_STRING Driver)
2028 {
2029 return NULL;
2030 }
2031
2032 /*!
2033 * Initialize some common fields in the Device Context structure.
2034 */
2035 VOID FASTCALL
2036 DC_InitDC(HDC DCHandle)
2037 {
2038 // NtGdiRealizeDefaultPalette(DCHandle);
2039
2040 NtGdiSelectObject(DCHandle, NtGdiGetStockObject( WHITE_BRUSH ));
2041 NtGdiSelectObject(DCHandle, NtGdiGetStockObject( BLACK_PEN ));
2042 //NtGdiSelectObject(DCHandle, hFont);
2043
2044 /*
2045 {
2046 int res;
2047 res = CLIPPING_UpdateGCRegion(DCToInit);
2048 ASSERT ( res != ERROR );
2049 }
2050 */
2051 }
2052
2053 VOID FASTCALL
2054 DC_FreeDC(HDC DCToFree)
2055 {
2056 if (!GDIOBJ_FreeObj(DCToFree, GDI_OBJECT_TYPE_DC))
2057 {
2058 DPRINT("DC_FreeDC failed\n");
2059 }
2060 }
2061
2062 BOOL INTERNAL_CALL
2063 DC_Cleanup(PVOID ObjectBody)
2064 {
2065 PDC pDC = (PDC)ObjectBody;
2066 RtlFreeUnicodeString(&pDC->DriverName);
2067 return TRUE;
2068 }
2069
2070 HDC FASTCALL
2071 DC_GetNextDC (PDC pDC)
2072 {
2073 return pDC->hNext;
2074 }
2075
2076 VOID FASTCALL
2077 DC_SetNextDC (PDC pDC, HDC hNextDC)
2078 {
2079 pDC->hNext = hNextDC;
2080 }
2081
2082 VOID FASTCALL
2083 DC_UpdateXforms(PDC dc)
2084 {
2085 XFORM xformWnd2Vport;
2086 FLOAT scaleX, scaleY;
2087
2088 /* Construct a transformation to do the window-to-viewport conversion */
2089 scaleX = (dc->wndExtX ? (FLOAT)dc->vportExtX / (FLOAT)dc->wndExtX : 0.0f);
2090 scaleY = (dc->wndExtY ? (FLOAT)dc->vportExtY / (FLOAT)dc->wndExtY : 0.0f);
2091 xformWnd2Vport.eM11 = scaleX;
2092 xformWnd2Vport.eM12 = 0.0;
2093 xformWnd2Vport.eM21 = 0.0;
2094 xformWnd2Vport.eM22 = scaleY;
2095 xformWnd2Vport.eDx = (FLOAT)dc->vportOrgX - scaleX * (FLOAT)dc->wndOrgX;
2096 xformWnd2Vport.eDy = (FLOAT)dc->vportOrgY - scaleY * (FLOAT)dc->wndOrgY;
2097
2098 /* Combine with the world transformation */
2099 IntGdiCombineTransform(&dc->w.xformWorld2Vport, &dc->w.xformWorld2Wnd, &xformWnd2Vport);
2100
2101 /* Create inverse of world-to-viewport transformation */
2102 dc->w.vport2WorldValid = DC_InvertXform(&dc->w.xformWorld2Vport, &dc->w.xformVport2World);
2103 }
2104
2105 BOOL FASTCALL
2106 DC_InvertXform(const XFORM *xformSrc,
2107 XFORM *xformDest)
2108 {
2109 FLOAT determinant;
2110
2111 determinant = xformSrc->eM11*xformSrc->eM22 - xformSrc->eM12*xformSrc->eM21;
2112 if (determinant > -1e-12 && determinant < 1e-12)
2113 {
2114 return FALSE;
2115 }
2116
2117 xformDest->eM11 = xformSrc->eM22 / determinant;
2118 xformDest->eM12 = -xformSrc->eM12 / determinant;
2119 xformDest->eM21 = -xformSrc->eM21 / determinant;
2120 xformDest->eM22 = xformSrc->eM11 / determinant;
2121 xformDest->eDx = -xformSrc->eDx * xformDest->eM11 - xformSrc->eDy * xformDest->eM21;
2122 xformDest->eDy = -xformSrc->eDx * xformDest->eM12 - xformSrc->eDy * xformDest->eM22;
2123
2124 return TRUE;
2125 }
2126
2127 VOID FASTCALL
2128 DC_SetOwnership(HDC hDC, PEPROCESS Owner)
2129 {
2130 PDC DC;
2131
2132 GDIOBJ_SetOwnership(hDC, Owner);
2133 DC = DC_LockDc(hDC);
2134 if (NULL != DC)
2135 {
2136 if (NULL != DC->w.hClipRgn)
2137 {
2138 GDIOBJ_CopyOwnership(hDC, DC->w.hClipRgn);
2139 }
2140 if (NULL != DC->w.hVisRgn)
2141 {
2142 GDIOBJ_CopyOwnership(hDC, DC->w.hVisRgn);
2143 }
2144 if (NULL != DC->w.hGCClipRgn)
2145 {
2146 GDIOBJ_CopyOwnership(hDC, DC->w.hGCClipRgn);
2147 }
2148 DC_UnlockDc(hDC);
2149 }
2150 }
2151
2152 BOOL FASTCALL
2153 IntIsPrimarySurface(SURFOBJ *SurfObj)
2154 {
2155 if (PrimarySurface.Handle == NULL)
2156 {
2157 return FALSE;
2158 }
2159 return SurfObj->hsurf == PrimarySurface.Handle;
2160 }
2161
2162 /*
2163 * Returns the color of the brush or pen that is currently selected into the DC.
2164 * This function is called from GetDCBrushColor() and GetDCPenColor()
2165 */
2166 COLORREF FASTCALL
2167 IntGetDCColor(HDC hDC, ULONG Object)
2168 {
2169 /*
2170 * The previous implementation was completly incorrect. It modified the
2171 * brush that was currently selected into the device context, but in fact
2172 * the DC pen/brush color should be stored directly in the device context
2173 * (at address 0x2C of the user mode DC object memory on Windows 2K/XP).
2174 * The actual color is then used when DC_BRUSH/DC_PEN object is selected
2175 * into the device context and BRUSHOBJ for drawing is composed (belongs
2176 * to IntGdiInitBrushInstance in the current ReactOS implementation). Also
2177 * the implementation should be moved to user mode GDI32.dll when UM
2178 * mapped GDI objects will be implemented.
2179 */
2180
2181 DPRINT("WIN32K:IntGetDCColor is unimplemented\n");
2182 return 0xFFFFFF; /* The default DC color. */
2183 }
2184
2185 /*
2186 * Changes the color of the brush or pen that is currently selected into the DC.
2187 * This function is called from SetDCBrushColor() and SetDCPenColor()
2188 */
2189 COLORREF FASTCALL
2190 IntSetDCColor(HDC hDC, ULONG Object, COLORREF Color)
2191 {
2192 /* See the comment in IntGetDCColor. */
2193
2194 DPRINT("WIN32K:IntSetDCColor is unimplemented\n");
2195 return CLR_INVALID;
2196 }
2197
2198 #define SIZEOF_DEVMODEW_300 188
2199 #define SIZEOF_DEVMODEW_400 212
2200 #define SIZEOF_DEVMODEW_500 220
2201
2202 /*! \brief Enumerate possible display settings for the given display...
2203 *
2204 * \todo Make thread safe!?
2205 * \todo Don't ignore lpszDeviceName
2206 * \todo Implement non-raw mode (only return settings valid for driver and monitor)
2207 */
2208 BOOL FASTCALL
2209 IntEnumDisplaySettings(
2210 PUNICODE_STRING lpszDeviceName,
2211 DWORD iModeNum,
2212 LPDEVMODEW lpDevMode,
2213 DWORD dwFlags)
2214 {
2215 static DEVMODEW *CachedDevModes = NULL, *CachedDevModesEnd = NULL;
2216 static DWORD SizeOfCachedDevModes = 0;
2217 LPDEVMODEW CachedMode = NULL;
2218 DEVMODEW DevMode;
2219 INT Size, OldSize;
2220 ULONG DisplayNumber = 0; /* only default display supported */
2221
2222 if (lpDevMode->dmSize != SIZEOF_DEVMODEW_300 &&
2223 lpDevMode->dmSize != SIZEOF_DEVMODEW_400 &&
2224 lpDevMode->dmSize != SIZEOF_DEVMODEW_500)
2225 {
2226 SetLastWin32Error(STATUS_INVALID_PARAMETER);
2227 return FALSE;
2228 }
2229
2230 if (iModeNum == ENUM_CURRENT_SETTINGS)
2231 {
2232 CachedMode = &PrimarySurface.DMW;
2233 assert(CachedMode->dmSize > 0);
2234 }
2235 else if (iModeNum == ENUM_REGISTRY_SETTINGS)
2236 {
2237 RtlZeroMemory(&DevMode, sizeof (DevMode));
2238 DevMode.dmSize = sizeof (DevMode);
2239 DevMode.dmDriverExtra = 0;
2240 if (SetupDevMode(&DevMode, DisplayNumber))
2241 CachedMode = &DevMode;
2242 else
2243 {
2244 SetLastWin32Error(0); /* FIXME: use error code */
2245 return FALSE;
2246 }
2247 /* FIXME: Maybe look for the matching devmode supplied by the
2248 * driver so we can provide driver private/extra data?
2249 */
2250 }
2251 else
2252 {
2253 if (iModeNum == 0 || CachedDevModes == NULL) /* query modes from drivers */
2254 {
2255 BOOL PrimarySurfaceCreated = FALSE;
2256 UNICODE_STRING DriverFileNames;
2257 LPWSTR CurrentName;
2258 DRVENABLEDATA DrvEnableData;
2259
2260 /* Retrieve DDI driver names from registry */
2261 RtlInitUnicodeString(&DriverFileNames, NULL);
2262 if (!FindDriverFileNames(&DriverFileNames, DisplayNumber))
2263 {
2264 DPRINT1("FindDriverFileNames failed\n");
2265 return FALSE;
2266 }
2267
2268 if (!HalQueryDisplayOwnership())
2269 {
2270 IntCreatePrimarySurface();
2271 PrimarySurfaceCreated = TRUE;
2272 }
2273
2274 /*
2275 * DriverFileNames may be a list of drivers in REG_SZ_MULTI format,
2276 * scan all of them until a good one found.
2277 */
2278 CurrentName = DriverFileNames.Buffer;
2279 for (;CurrentName < DriverFileNames.Buffer + (DriverFileNames.Length / sizeof (WCHAR));
2280 CurrentName += wcslen(CurrentName) + 1)
2281 {
2282 INT i;
2283 PGD_ENABLEDRIVER GDEnableDriver;
2284
2285 /* Get the DDI driver's entry point */
2286 GDEnableDriver = DRIVER_FindDDIDriver(CurrentName);
2287 if (NULL == GDEnableDriver)
2288 {
2289 DPRINT("FindDDIDriver failed for %S\n", CurrentName);
2290 continue;
2291 }
2292
2293 /* Call DDI driver's EnableDriver function */
2294 RtlZeroMemory(&DrvEnableData, sizeof (DrvEnableData));
2295
2296 if (!GDEnableDriver(DDI_DRIVER_VERSION_NT5_01, sizeof (DrvEnableData), &DrvEnableData))
2297 {
2298 DPRINT("DrvEnableDriver failed for %S\n", CurrentName);
2299 continue;
2300 }
2301
2302 CachedDevModesEnd = CachedDevModes;
2303
2304 /* find DrvGetModes function */
2305 for (i = 0; i < DrvEnableData.c; i++)
2306 {
2307 PDRVFN DrvFn = DrvEnableData.pdrvfn + i;
2308 PGD_GETMODES GetModes;
2309 INT SizeNeeded, SizeUsed;
2310
2311 if (DrvFn->iFunc != INDEX_DrvGetModes)
2312 continue;
2313
2314 GetModes = (PGD_GETMODES)DrvFn->pfn;
2315
2316 /* make sure we have enough memory to hold the modes */
2317 SizeNeeded = GetModes((HANDLE)(PrimarySurface.VideoFileObject->DeviceObject), 0, NULL);
2318 if (SizeNeeded <= 0)
2319 {
2320 DPRINT("DrvGetModes failed for %S\n", CurrentName);
2321 break;
2322 }
2323
2324 SizeUsed = CachedDevModesEnd - CachedDevModes;
2325 if (SizeOfCachedDevModes - SizeUsed < SizeNeeded)
2326 {
2327 PVOID NewBuffer;
2328
2329 SizeOfCachedDevModes += SizeNeeded;
2330 NewBuffer = ExAllocatePool(PagedPool, SizeOfCachedDevModes);
2331 if (NewBuffer == NULL)
2332 {
2333 /* clean up */
2334 ExFreePool(CachedDevModes);
2335 SizeOfCachedDevModes = 0;
2336 CachedDevModes = NULL;
2337 CachedDevModesEnd = NULL;
2338 if (PrimarySurfaceCreated)
2339 {
2340 IntDestroyPrimarySurface();
2341 }
2342 SetLastWin32Error(STATUS_NO_MEMORY);
2343 return FALSE;
2344 }
2345 if (CachedDevModes != NULL)
2346 {
2347 RtlCopyMemory(NewBuffer, CachedDevModes, SizeUsed);
2348 ExFreePool(CachedDevModes);
2349 }
2350 CachedDevModes = NewBuffer;
2351 CachedDevModesEnd = (DEVMODEW *)((PCHAR)NewBuffer + SizeUsed);
2352 }
2353
2354 /* query modes */
2355 SizeNeeded = GetModes((HANDLE)(PrimarySurface.VideoFileObject->DeviceObject),
2356 SizeOfCachedDevModes - SizeUsed,
2357 CachedDevModesEnd);
2358 if (SizeNeeded <= 0)
2359 {
2360 DPRINT("DrvGetModes failed for %S\n", CurrentName);
2361 }
2362 else
2363 {
2364 CachedDevModesEnd = (DEVMODEW *)((PCHAR)CachedDevModesEnd + SizeNeeded);
2365 }
2366 break;
2367 }
2368 }
2369
2370 if (PrimarySurfaceCreated)
2371 {
2372 IntDestroyPrimarySurface();
2373 }
2374
2375 RtlFreeUnicodeString(&DriverFileNames);
2376 }
2377
2378 /* return cached info */
2379 CachedMode = CachedDevModes;
2380 if (CachedMode >= CachedDevModesEnd)
2381 {
2382 SetLastWin32Error(STATUS_NO_MORE_ENTRIES);
2383 return FALSE;
2384 }
2385 while (iModeNum-- > 0 && CachedMode < CachedDevModesEnd)
2386 {
2387 assert(CachedMode->dmSize > 0);
2388 CachedMode = (DEVMODEW *)((PCHAR)CachedMode + CachedMode->dmSize + CachedMode->dmDriverExtra);
2389 }
2390 if (CachedMode >= CachedDevModesEnd)
2391 {
2392 SetLastWin32Error(STATUS_NO_MORE_ENTRIES);
2393 return FALSE;
2394 }
2395 }
2396
2397 assert(CachedMode != NULL);
2398
2399 Size = OldSize = lpDevMode->dmSize;
2400 if (Size > CachedMode->dmSize)
2401 Size = CachedMode->dmSize;
2402 RtlCopyMemory(lpDevMode, CachedMode, Size);
2403 RtlZeroMemory((PCHAR)lpDevMode + Size, OldSize - Size);
2404 lpDevMode->dmSize = OldSize;
2405
2406 Size = OldSize = lpDevMode->dmDriverExtra;
2407 if (Size > CachedMode->dmDriverExtra)
2408 Size = CachedMode->dmDriverExtra;
2409 RtlCopyMemory((PCHAR)lpDevMode + lpDevMode->dmSize,
2410 (PCHAR)CachedMode + CachedMode->dmSize, Size);
2411 RtlZeroMemory((PCHAR)lpDevMode + lpDevMode->dmSize + Size, OldSize - Size);
2412 lpDevMode->dmDriverExtra = OldSize;
2413
2414 return TRUE;
2415 }
2416
2417 /* EOF */
A free Windows-compatible Operating System