ReactOS 0.4.15-dev-8231-g29a56f3
dc.c
Go to the documentation of this file.
1#include <precomp.h>
2
3#define NDEBUG
4#include <debug.h>
5
6HDC
9 LPCWSTR lpwszDriver,
10 LPCWSTR lpwszDevice,
11 LPCWSTR lpwszOutput,
12 PDEVMODEW lpInitData,
14{
16 HDC hdc = NULL;
17 BOOL Display = FALSE, Default = FALSE;
18 HANDLE UMdhpdev = 0;
19
20 HANDLE hspool = NULL;
21
22 if ( !ghSpooler && !LoadTheSpoolerDrv())
23 {
24 DPRINT1("WinSpooler.Drv Did not load!\n");
25 }
26 else
27 {
28 DPRINT("WinSpooler.Drv Loaded! hMod -> 0x%p\n", ghSpooler);
29 }
30
31 if ((!lpwszDevice) && (!lpwszDriver))
32 {
33 Default = TRUE; // Ask Win32k to set Default device.
34 Display = TRUE; // Most likely to be DISPLAY.
35 }
36 else
37 {
38 if ((lpwszDevice) && (wcslen(lpwszDevice) != 0)) // First
39 {
40 if (!_wcsnicmp(lpwszDevice, L"\\\\.\\DISPLAY",11)) Display = TRUE;
41 RtlInitUnicodeString(&Device, lpwszDevice);
42 }
43 else
44 {
45 if (lpwszDriver) // Second
46 {
47 if ((!_wcsnicmp(lpwszDriver, L"DISPLAY",7)) ||
48 (!_wcsnicmp(lpwszDriver, L"\\\\.\\DISPLAY",11))) Display = TRUE;
49 RtlInitUnicodeString(&Device, lpwszDriver);
50 }
51 }
52 }
53
54 if (lpwszOutput) RtlInitUnicodeString(&Output, lpwszOutput);
55
56 // Handle Print device or something else.
57 if (!Display)
58 {
59 // WIP - GDI Print Commit coming in soon.
60 DPRINT1("Not a DISPLAY device! %wZ\n", &Device);
61 return NULL; // Return NULL until then.....
62 }
63
64 hdc = NtGdiOpenDCW((Default ? NULL : &Device),
65 (PDEVMODEW) lpInitData,
66 (lpwszOutput ? &Output : NULL),
67 iType, // DCW 0 and ICW 1.
68 Display,
69 hspool,
70 &UMdhpdev );
71#if 0
72// Handle something other than a normal dc object.
74 {
75 PDC_ATTR Dc_Attr;
76 PLDC pLDC;
77
79
80 pLDC = LocalAlloc(LMEM_ZEROINIT, sizeof(LDC));
81
82 Dc_Attr->pvLDC = pLDC;
83 pLDC->hDC = hdc;
84 pLDC->iType = LDC_LDC; // 1 (init) local DC, 2 EMF LDC
85 DbgPrint("DC_ATTR Allocated -> 0x%x\n",Dc_Attr);
86 }
87#endif
88 return hdc;
89}
90
91
92/*
93 * @implemented
94 */
95HDC
98 _In_ HDC hdc)
99{
100 HDC hdcNew;
101// PDC_ATTR pdcattr;
102
104#if 0
105 if ( hdc && hdcNew)
106 {
108 {
109 if (pdcattr->pvLIcm) IcmCompatibleDC(hdcNew, hdc, pdcattr);
110 }
111 }
112#endif
113
114 return hdcNew;
115}
116
117/*
118 * @implemented
119 */
120HDC
121WINAPI
123 LPCSTR lpszDriver,
124 LPCSTR lpszDevice,
125 LPCSTR lpszOutput,
126 CONST DEVMODEA * lpdvmInit)
127{
128 ANSI_STRING DriverA, DeviceA, OutputA;
129 UNICODE_STRING DriverU, DeviceU, OutputU;
130 LPDEVMODEW dvmInitW = NULL;
131 HDC hdc;
132
133 /*
134 * If needed, convert to Unicode
135 * any string parameter.
136 */
137
138 if (lpszDriver != NULL)
139 {
140 RtlInitAnsiString(&DriverA, (LPSTR)lpszDriver);
141 RtlAnsiStringToUnicodeString(&DriverU, &DriverA, TRUE);
142 }
143 else
144 {
145 DriverU.Buffer = NULL;
146 }
147
148 if (lpszDevice != NULL)
149 {
150 RtlInitAnsiString(&DeviceA, (LPSTR)lpszDevice);
151 RtlAnsiStringToUnicodeString(&DeviceU, &DeviceA, TRUE);
152 }
153 else
154 {
155 DeviceU.Buffer = NULL;
156 }
157
158 if (lpszOutput != NULL)
159 {
160 RtlInitAnsiString(&OutputA, (LPSTR)lpszOutput);
161 RtlAnsiStringToUnicodeString(&OutputU, &OutputA, TRUE);
162 }
163 else
164 {
165 OutputU.Buffer = NULL;
166 }
167
168 if (lpdvmInit != NULL)
169 dvmInitW = GdiConvertToDevmodeW((LPDEVMODEA)lpdvmInit);
170
171 hdc = IntCreateDICW(DriverU.Buffer,
172 DeviceU.Buffer,
173 OutputU.Buffer,
174 lpdvmInit ? dvmInitW : NULL,
175 0);
176 HEAP_free(dvmInitW);
177
178 /* Free Unicode parameters. */
179 RtlFreeUnicodeString(&DriverU);
180 RtlFreeUnicodeString(&DeviceU);
181 RtlFreeUnicodeString(&OutputU);
182
183 /* Return the DC handle. */
184 return hdc;
185}
186
187
188/*
189 * @implemented
190 */
191HDC
192WINAPI
194 LPCWSTR lpwszDriver,
195 LPCWSTR lpwszDevice,
196 LPCWSTR lpwszOutput,
197 CONST DEVMODEW *lpInitData)
198{
199 return IntCreateDICW(lpwszDriver,
200 lpwszDevice,
201 lpwszOutput,
202 (PDEVMODEW)lpInitData,
203 0);
204}
205
206
207/*
208 * @implemented
209 */
210HDC
211WINAPI
213 LPCWSTR lpszDriver,
214 LPCWSTR lpszDevice,
215 LPCWSTR lpszOutput,
216 CONST DEVMODEW *lpdvmInit)
217{
218 return IntCreateDICW(lpszDriver,
219 lpszDevice,
220 lpszOutput,
221 (PDEVMODEW)lpdvmInit,
222 1);
223}
224
225
226/*
227 * @implemented
228 */
229HDC
230WINAPI
232 LPCSTR lpszDriver,
233 LPCSTR lpszDevice,
234 LPCSTR lpszOutput,
235 CONST DEVMODEA *lpdvmInit)
236{
238 LPWSTR lpszDriverW, lpszDeviceW, lpszOutputW;
239 LPDEVMODEW dvmInitW = NULL;
240 HDC hdc = 0;
241
242 Status = HEAP_strdupA2W(&lpszDriverW, lpszDriver);
243 if (!NT_SUCCESS(Status))
245 else
246 {
247 Status = HEAP_strdupA2W(&lpszDeviceW, lpszDevice);
248 if (!NT_SUCCESS(Status))
250 else
251 {
252 Status = HEAP_strdupA2W(&lpszOutputW, lpszOutput);
253 if (!NT_SUCCESS(Status))
255 else
256 {
257 if (lpdvmInit)
258 dvmInitW = GdiConvertToDevmodeW((LPDEVMODEA)lpdvmInit);
259
260 hdc = IntCreateDICW(lpszDriverW,
261 lpszDeviceW,
262 lpszOutputW,
263 lpdvmInit ? dvmInitW : NULL,
264 1 );
265 HEAP_free(dvmInitW);
266 HEAP_free(lpszOutputW);
267 }
268 HEAP_free(lpszDeviceW);
269 }
270 HEAP_free(lpszDriverW);
271 }
272
273 return hdc;
274}
275
276
277/*
278 * @implemented
279 */
280BOOL
281WINAPI
283{
285
286 if (hType != GDILoObjType_LO_DC_TYPE)
287 {
289 }
290
291 //if ( ghICM || pdcattr->pvLIcm )
292 // IcmDeleteLocalDC( hdc, pdcattr, NULL );
293
295}
296
297
298/*
299 * @implemented
300 */
301INT
302WINAPI
304{
306 return NtGdiSaveDC(hdc);
307}
308
309
310/*
311 * @implemented
312 */
313BOOL
314WINAPI
316 IN INT iLevel)
317{
319 return NtGdiRestoreDC(hdc, iLevel);
320}
321
322
323/*
324 * @implemented
325 */
326BOOL
327WINAPI
329{
330 PDC_ATTR pDc_Attr;
331
334 {
335 PLDC pLDC = GdiGetLDC(hDC);
336 if ( !pLDC )
337 {
339 return FALSE;
340 }
341 /* If a document has started set it to die. */
342 if (pLDC->Flags & LDC_INIT_DOCUMENT) pLDC->Flags |= LDC_KILL_DOCUMENT;
343
344 return NtGdiCancelDC(hDC);
345 }
346
348 {
349 pDc_Attr->ulDirty_ &= ~DC_PLAYMETAFILE;
350 return TRUE;
351 }
352
353 return FALSE;
354}
355
356INT
357WINAPI
359 _In_ HDC hdc)
360{
361 return GetDCDWord( hdc, GdiGetArcDirection, 0);
362}
363
364
365INT
366WINAPI
368 _In_ HDC hdc,
369 _In_ INT nDirection)
370{
372}
373
374/*
375 * @unimplemented
376 */
377BOOL
378WINAPI
380{
381 return 0;
382}
383
384
385/*
386 * @implemented
387 */
388BOOL
389WINAPI
391{
393 return TRUE;
395 return FALSE;
396}
397
398/*
399 * @implemented
400 */
401HDC
402WINAPI
404{
405 PLDC pldc;
408 return hdc;
409 pldc = GdiGetLDC(hdc);
410 if (pldc)
411 {
412 if (pldc->Flags & LDC_SAPCALLBACK) GdiSAPCallback(pldc);
413 if (pldc->Flags & LDC_KILL_DOCUMENT) return NULL;
414 if (pldc->Flags & LDC_STARTPAGE) StartPage(hdc);
415 return hdc;
416 }
418 return NULL;
419}
420
421
422/*
423 * @implemented
424 *
425 */
427WINAPI
429 _In_ HDC hdc,
430 _In_ UINT uObjectType)
431{
432 PDC_ATTR pdcattr = NULL;
433
434 /* Check if this is a user mode object */
435 if ((uObjectType == OBJ_PEN) ||
436 (uObjectType == OBJ_EXTPEN) ||
437 (uObjectType == OBJ_BRUSH) ||
438 (uObjectType == OBJ_COLORSPACE))
439 {
440 /* Get the DC attribute */
441 pdcattr = GdiGetDcAttr(hdc);
442 if (pdcattr == NULL)
443 {
444 return NULL;
445 }
446 }
447
448 /* Check what object was requested */
449 switch (uObjectType)
450 {
451 case OBJ_EXTPEN:
452 case OBJ_PEN:
453 return pdcattr->hpen;
454
455 case OBJ_BRUSH:
456 return pdcattr->hbrush;
457
458 case OBJ_COLORSPACE:
459 return pdcattr->hColorSpace;
460
461 case OBJ_PAL:
462 uObjectType = GDI_OBJECT_TYPE_PALETTE;
463 break;
464
465 case OBJ_FONT:
466 uObjectType = GDI_OBJECT_TYPE_FONT;
467 break;
468
469 case OBJ_BITMAP:
470 uObjectType = GDI_OBJECT_TYPE_BITMAP;
471 break;
472
473 /* All others are invalid */
474 default:
476 return NULL;
477 }
478
479 /* Pass the request to win32k */
480 return NtGdiGetDCObject(hdc, uObjectType);
481}
482
483
484/*
485 * @implemented
486 */
487int
488WINAPI
490 int nObjectType,
491 GOBJENUMPROC lpObjectFunc,
493{
494 ULONG ObjectsCount;
495 ULONG Size;
496 PVOID Buffer = NULL;
497 DWORD_PTR EndOfBuffer;
498 int Result = 0;
499
500 switch (nObjectType)
501 {
502 case OBJ_BRUSH:
503 Size = sizeof(LOGBRUSH);
504 break;
505
506 case OBJ_PEN:
507 Size = sizeof(LOGPEN);
508 break;
509
510 default:
512 return 0;
513 }
514
515 ObjectsCount = NtGdiEnumObjects(hdc, nObjectType, 0, NULL);
516 if (!ObjectsCount) return 0;
517
518 Buffer = HeapAlloc(GetProcessHeap(), 0, ObjectsCount * Size);
519 if (!Buffer)
520 {
522 return 0;
523 }
524
525 if (!NtGdiEnumObjects(hdc, nObjectType, ObjectsCount * Size, Buffer))
526 {
528 return 0;
529 }
530
531 EndOfBuffer = (DWORD_PTR)Buffer + (ObjectsCount * Size);
532 while ((DWORD_PTR)Buffer < EndOfBuffer)
533 {
534 Result = lpObjectFunc(Buffer, lParam);
535 if (!Result) break;
537 }
538
540 return Result;
541}
542
543
544/*
545 * @implemented
546 *
547 */
548int
549WINAPI
551 _In_ HDC hdc,
552 _In_ int nIndex)
553{
554 PDC_ATTR pdcattr;
555 PLDC pldc;
557 PDEVCAPS pDevCaps = GdiDevCaps; // Primary display device capabilities.
558 DPRINT("Device CAPS1\n");
559
560 HANDLE_METADC16(INT, GetDeviceCaps, 0, hdc, nIndex);
561
563 {
564 pldc = GdiGetLDC(hdc);
565 if ( !pldc )
566 {
568 return 0;
569 }
570 if (!(pldc->Flags & LDC_DEVCAPS) )
571 {
572 if (!NtGdiGetDeviceCapsAll(hdc, &pldc->DevCaps) )
574
575 pldc->Flags |= LDC_DEVCAPS;
576 }
577 pDevCaps = &pldc->DevCaps;
578 }
579 else
580 {
581 /* Get the DC attribute */
582 pdcattr = GdiGetDcAttr(hdc);
583 if ( pdcattr == NULL )
584 {
586 return 0;
587 }
588
589 if (!(pdcattr->ulDirty_ & DC_PRIMARY_DISPLAY))
590 return NtGdiGetDeviceCaps(hdc, nIndex);
591 }
592
593 switch (nIndex)
594 {
595 case DRIVERVERSION:
596 return pDevCaps->ulVersion;
597
598 case TECHNOLOGY:
599 return pDevCaps->ulTechnology;
600
601 case HORZSIZE:
602 return pDevCaps->ulHorzSize;
603
604 case VERTSIZE:
605 return pDevCaps->ulVertSize;
606
607 case HORZRES:
608 return pDevCaps->ulHorzRes;
609
610 case VERTRES:
611 return pDevCaps->ulVertRes;
612
613 case LOGPIXELSX:
614 return pDevCaps->ulLogPixelsX;
615
616 case LOGPIXELSY:
617 return pDevCaps->ulLogPixelsY;
618
619 case BITSPIXEL:
620 return pDevCaps->ulBitsPixel;
621
622 case PLANES:
623 return pDevCaps->ulPlanes;
624
625 case NUMBRUSHES:
626 return -1;
627
628 case NUMPENS:
629 return pDevCaps->ulNumPens;
630
631 case NUMFONTS:
632 return pDevCaps->ulNumFonts;
633
634 case NUMCOLORS:
635 return pDevCaps->ulNumColors;
636
637 case ASPECTX:
638 return pDevCaps->ulAspectX;
639
640 case ASPECTY:
641 return pDevCaps->ulAspectY;
642
643 case ASPECTXY:
644 return pDevCaps->ulAspectXY;
645
646 case CLIPCAPS:
647 return CP_RECTANGLE;
648
649 case SIZEPALETTE:
650 return pDevCaps->ulSizePalette;
651
652 case NUMRESERVED:
653 return 20;
654
655 case COLORRES:
656 return pDevCaps->ulColorRes;
657
658 case DESKTOPVERTRES:
659 return pDevCaps->ulVertRes;
660
661 case DESKTOPHORZRES:
662 return pDevCaps->ulHorzRes;
663
664 case BLTALIGNMENT:
665 return pDevCaps->ulBltAlignment;
666
667 case SHADEBLENDCAPS:
668 return pDevCaps->ulShadeBlend;
669
670 case COLORMGMTCAPS:
672
673 case PHYSICALWIDTH:
675
676 case PHYSICALHEIGHT:
678
679 case PHYSICALOFFSETX:
681
682 case PHYSICALOFFSETY:
684
685 case VREFRESH:
686 return pDevCaps->ulVRefresh;
687
688 case RASTERCAPS:
689 return pDevCaps->ulRasterCaps;
690
691 case CURVECAPS:
694
695 case LINECAPS:
698
699 case POLYGONALCAPS:
702
703 case TEXTCAPS:
704 return pDevCaps->ulTextCaps;
705
706 case PDEVICESIZE:
707 case SCALINGFACTORX:
708 case SCALINGFACTORY:
709 default:
710 return 0;
711 }
712 return 0;
713}
714
715/*
716 * @implemented
717 */
718DWORD
719WINAPI
721 _In_ HDC hdc,
722 _In_ DWORD dwIgnore)
723{
724 return GetDCDWord(hdc, GdiGetRelAbs, 0);
725}
726
727
728/*
729 * @implemented
730 */
731INT
732WINAPI
734 HDC hdc,
735 INT Mode)
736{
738}
739
740
741/*
742 * @implemented
743 */
744DWORD
745WINAPI
747 _In_ HDC hdc,
748 _In_ UINT u,
750 _In_ ULONG ulMFId,
751 _In_ USHORT usMF16Id,
752 _In_ DWORD dwError)
753{
754 DWORD dwResult;
755 PLDC pldc;
756
758 ulMFId != EMR_MAX + 1 )
759 {
761 {
762 return METADC_SetD( hdc, dwIn, usMF16Id );
763 }
764 pldc = GdiGetLDC(hdc);
765 if ( pldc->iType == LDC_EMFLDC)
766 {
767 if (!EMFDC_SetD( pldc, dwIn, ulMFId ))
768 return 0;
769 }
770 }
771
772 /* Call win32k to do the real work */
773 if (!NtGdiGetAndSetDCDword(hdc, u, dwIn, &dwResult))
774 {
775 return dwError;
776 }
777
778 return dwResult;
779}
780
781
782/*
783 * @implemented
784 */
785DWORD
786WINAPI
788 _In_ HDC hdc,
789 _In_ UINT u,
790 _In_ DWORD dwError)
791{
792 DWORD dwResult;
793
794 if (!NtGdiGetDCDword(hdc, u, &dwResult))
795 {
796 return dwError;
797 }
798
799 return dwResult;
800}
801
802
803/*
804 * @implemented
805 */
806BOOL
807WINAPI
809 HDC hdc,
810 LPSIZE lpAspectRatio)
811{
812 return NtGdiGetDCPoint(hdc, GdiGetAspectRatioFilter, (PPOINTL)lpAspectRatio );
813}
814
815
816/*
817 * @implemented
818 */
819UINT
820WINAPI
822 HDC hdc,
823 LPRECT lprcBounds,
824 UINT flags
825)
826{
827 return NtGdiGetBoundsRect(hdc,lprcBounds,flags & ~DCB_WINDOWMGR);
828}
829
830
831/*
832 * @implemented
833 */
834UINT
835WINAPI
837 CONST RECT *prc,
838 UINT flags)
839{
840 /* FIXME add check for validate the flags */
842}
843
844
845/*
846 * @implemented
847 *
848 */
849int
850WINAPI
852 LPRECT lprc)
853{
854 return NtGdiGetAppClipBox(hdc, lprc);
855}
856
857
858/*
859 * @implemented
860 */
862WINAPI
864 _In_ HDC hdc)
865{
866 PDC_ATTR pdcattr;
867
868 /* Get the DC attribute */
869 pdcattr = GdiGetDcAttr(hdc);
870 if (pdcattr == NULL)
871 {
873 return CLR_INVALID;
874 }
875
876 return pdcattr->ulBrushClr;
877}
878
879/*
880 * @implemented
881 */
883WINAPI
885 _In_ HDC hdc)
886{
887 PDC_ATTR pdcattr;
888
889 /* Get the DC attribute */
890 pdcattr = GdiGetDcAttr(hdc);
891 if (pdcattr == NULL)
892 {
894 return CLR_INVALID;
895 }
896
897 return pdcattr->ulPenClr;
898}
899
900/*
901 * @implemented
902 */
904WINAPI
906 _In_ HDC hdc,
907 _In_ COLORREF crColor)
908{
909 PDC_ATTR pdcattr;
910 COLORREF crOldColor;
911
912 /* Get the DC attribute */
913 pdcattr = GdiGetDcAttr(hdc);
914 if (pdcattr == NULL)
915 {
917 return CLR_INVALID;
918 }
919
920 /* We handle only enhanced meta DCs here */
922
923 /* Get old color and store the new */
924 crOldColor = pdcattr->ulBrushClr;
925 pdcattr->ulBrushClr = crColor;
926
927 if (pdcattr->crBrushClr != crColor)
928 {
929 pdcattr->ulDirty_ |= DIRTY_FILL;
930 pdcattr->crBrushClr = crColor;
931 }
932
933 return crOldColor;
934}
935
936/*
937 * @implemented
938 */
940WINAPI
942 _In_ HDC hdc,
943 _In_ COLORREF crColor)
944{
945 PDC_ATTR pdcattr;
946 COLORREF crOldColor;
947
948 /* Get the DC attribute */
949 pdcattr = GdiGetDcAttr(hdc);
950 if (pdcattr == NULL)
951 {
953 return CLR_INVALID;
954 }
955
956 /* We handle only enhanced meta DCs here */
958
959 /* Get old color and store the new */
960 crOldColor = pdcattr->ulPenClr;
961 pdcattr->ulPenClr = (ULONG)crColor;
962
963 if (pdcattr->crPenClr != crColor)
964 {
965 pdcattr->ulDirty_ |= DIRTY_LINE;
966 pdcattr->crPenClr = crColor;
967 }
968
969 return crOldColor;
970}
971
972/*
973 * @implemented
974 *
975 */
977WINAPI
979 _In_ HDC hdc)
980{
981 PDC_ATTR pdcattr;
982
983 /* Get the DC attribute */
984 pdcattr = GdiGetDcAttr(hdc);
985 if (pdcattr == NULL)
986 {
987 /* Don't set LastError here! */
988 return CLR_INVALID;
989 }
990
991 return pdcattr->ulBackgroundClr;
992}
993
994/*
995 * @implemented
996 */
998WINAPI
1000 _In_ HDC hdc,
1001 _In_ COLORREF crColor)
1002{
1003 PDC_ATTR pdcattr;
1004 COLORREF crOldColor;
1005
1007
1008 /* Get the DC attribute */
1009 pdcattr = GdiGetDcAttr(hdc);
1010 if (pdcattr == NULL)
1011 {
1013 return CLR_INVALID;
1014 }
1015
1016 /* Get old color and store the new */
1017 crOldColor = pdcattr->ulBackgroundClr;
1018 pdcattr->ulBackgroundClr = crColor;
1019
1020 if (pdcattr->crBackgroundClr != crColor)
1021 {
1023 pdcattr->crBackgroundClr = crColor;
1024 }
1025
1026 return crOldColor;
1027}
1028
1029/*
1030 * @implemented
1031 *
1032 */
1033int
1034WINAPI
1036{
1037 PDC_ATTR pdcattr;
1038
1039 /* Get the DC attribute */
1040 pdcattr = GdiGetDcAttr(hdc);
1041 if (pdcattr == NULL)
1042 {
1043 /* Don't set LastError here! */
1044 return 0;
1045 }
1046
1047 return pdcattr->lBkMode;
1048}
1049
1050/*
1051 * @implemented
1052 *
1053 */
1054int
1055WINAPI
1057 _In_ HDC hdc,
1058 _In_ int iBkMode)
1059{
1060 PDC_ATTR pdcattr;
1061 INT iOldMode;
1062
1063 HANDLE_METADC(INT, SetBkMode, 0, hdc, iBkMode);
1064
1065 /* Get the DC attribute */
1066 pdcattr = GdiGetDcAttr(hdc);
1067 if (pdcattr == NULL)
1068 {
1070 return 0;
1071 }
1072
1073 iOldMode = pdcattr->lBkMode;
1074 pdcattr->jBkMode = iBkMode; // Processed
1075 pdcattr->lBkMode = iBkMode; // Raw
1076
1077 return iOldMode;
1078}
1079
1080/*
1081 * @implemented
1082 *
1083 */
1084int
1085WINAPI
1087 _In_ HDC hdc)
1088{
1089 PDC_ATTR pdcattr;
1090
1091 /* Get the DC attribute */
1092 pdcattr = GdiGetDcAttr(hdc);
1093 if (pdcattr == NULL)
1094 {
1095 /* Do not set LastError here! */
1096 return 0;
1097 }
1098
1099 return pdcattr->jROP2;
1100}
1101
1102/*
1103 * @implemented
1104 */
1105int
1106WINAPI
1108 _In_ HDC hdc,
1109 _In_ int rop2)
1110{
1111 PDC_ATTR pdcattr;
1112 INT rop2Old;
1113
1114 HANDLE_METADC(INT, SetROP2, 0, hdc, rop2);
1115
1116 /* Get the DC attribute */
1117 pdcattr = GdiGetDcAttr(hdc);
1118 if (pdcattr == NULL)
1119 {
1121 return 0;
1122 }
1123
1124 if (NtCurrentTeb()->GdiTebBatch.HDC == hdc)
1125 {
1126 if (pdcattr->ulDirty_ & DC_MODE_DIRTY)
1127 {
1128 NtGdiFlush();
1129 pdcattr->ulDirty_ &= ~DC_MODE_DIRTY;
1130 }
1131 }
1132
1133 rop2Old = pdcattr->jROP2;
1134 pdcattr->jROP2 = (BYTE)rop2;
1135
1136 return rop2Old;
1137}
1138
1139
1140/*
1141 * @implemented
1142 *
1143 */
1144int
1145WINAPI
1147{
1148 PDC_ATTR pdcattr;
1149
1150 /* Get DC attribute */
1151 pdcattr = GdiGetDcAttr(hdc);
1152 if (pdcattr == NULL)
1153 {
1154 /* Don't set LastError here! */
1155 return 0;
1156 }
1157
1158 /* Return current fill mode */
1159 return pdcattr->lFillMode;
1160}
1161
1162/*
1163 * @unimplemented
1164 */
1165int
1166WINAPI
1168 _In_ HDC hdc,
1169 _In_ int iPolyFillMode)
1170{
1171 INT iOldPolyFillMode;
1172 PDC_ATTR pdcattr;
1173
1174 HANDLE_METADC(INT, SetPolyFillMode, 0, hdc, iPolyFillMode);
1175
1176 /* Get the DC attribute */
1177 pdcattr = GdiGetDcAttr(hdc);
1178 if (pdcattr == NULL)
1179 {
1181 return 0;
1182 }
1183
1184 if (NtCurrentTeb()->GdiTebBatch.HDC == hdc)
1185 {
1186 if (pdcattr->ulDirty_ & DC_MODE_DIRTY)
1187 {
1188 NtGdiFlush(); // Sync up pdcattr from Kernel space.
1189 pdcattr->ulDirty_ &= ~DC_MODE_DIRTY;
1190 }
1191 }
1192
1193 iOldPolyFillMode = pdcattr->lFillMode;
1194 pdcattr->lFillMode = iPolyFillMode;
1195
1196 return iOldPolyFillMode;
1197}
1198
1199/*
1200 * @implemented
1201 *
1202 */
1203int
1204WINAPI
1206{
1207 PDC_ATTR pdcattr;
1208
1209 /* Get the DC attribute */
1210 pdcattr = GdiGetDcAttr(hdc);
1211 if (pdcattr == NULL)
1212 {
1213 /* Don't set LastError here! */
1214 return 0;
1215 }
1216
1217 /* Return current graphics mode */
1218 return pdcattr->iGraphicsMode;
1219}
1220
1221/*
1222 * @unimplemented
1223 */
1224int
1225WINAPI
1227 _In_ HDC hdc,
1228 _In_ int iMode)
1229{
1230 INT iOldMode;
1231 PDC_ATTR pdcattr;
1232
1233 /* Check parameters */
1234 if ((iMode < GM_COMPATIBLE) || (iMode > GM_ADVANCED))
1235 {
1237 return 0;
1238 }
1239
1240 /* Get the DC attribute */
1241 pdcattr = GdiGetDcAttr(hdc);
1242 if (pdcattr == NULL)
1243 {
1245 return 0;
1246 }
1247
1248 /* Check for trivial case */
1249 if (iMode == pdcattr->iGraphicsMode)
1250 return iMode;
1251
1252 if (NtCurrentTeb()->GdiTebBatch.HDC == hdc)
1253 {
1254 if (pdcattr->ulDirty_ & DC_MODE_DIRTY)
1255 {
1256 NtGdiFlush(); // Sync up pdcattr from Kernel space.
1257 pdcattr->ulDirty_ &= ~DC_MODE_DIRTY;
1258 }
1259 }
1260
1261 /* One would think that setting the graphics mode to GM_COMPATIBLE
1262 * would also reset the world transformation matrix to the unity
1263 * matrix. However, in Windows, this is not the case. This doesn't
1264 * make a lot of sense to me, but that's the way it is.
1265 */
1266 iOldMode = pdcattr->iGraphicsMode;
1267 pdcattr->iGraphicsMode = iMode;
1268
1269 return iOldMode;
1270}
1271
1272/*
1273 * @implemented
1274 */
1275HDC
1276WINAPI
1278 _In_ HDC hdc,
1279 _In_ CONST DEVMODEW *lpInitData)
1280{
1281 NtGdiResetDC ( hdc, (PDEVMODEW)lpInitData, NULL, NULL, NULL);
1282 return hdc;
1283}
1284
1285
1286/*
1287 * @implemented
1288 */
1289HDC
1290WINAPI
1292 _In_ HDC hdc,
1293 _In_ CONST DEVMODEA *lpInitData)
1294{
1295 LPDEVMODEW InitDataW;
1296
1297 InitDataW = GdiConvertToDevmodeW((LPDEVMODEA)lpInitData);
1298
1299 NtGdiResetDC ( hdc, InitDataW, NULL, NULL, NULL);
1300 HEAP_free(InitDataW);
1301 return hdc;
1302}
1303
1304
1305/* FIXME: include correct header */
1307 HPALETTE hpal,
1308 BOOL ForceBackground);
1309
1310HPALETTE
1311WINAPI
1313 HDC hdc,
1314 HPALETTE hpal,
1315 BOOL bForceBackground)
1316{
1318 {
1320 {
1321 return (HPALETTE)((ULONG_PTR)METADC_SelectPalette(hdc, hpal));
1322 }
1323 else
1324 {
1325 PLDC pLDC = GdiGetLDC(hdc);
1326 if ( !pLDC )
1327 {
1329 return NULL;
1330 }
1331 if ( pLDC->iType == LDC_EMFLDC && !(EMFDC_SelectPalette(pLDC, hpal)) )
1332 {
1333 return NULL;
1334 }
1335 }
1336 }
1337 return NtUserSelectPalette(hdc, hpal, bForceBackground);
1338}
1339
1340/*
1341 * @implemented
1342 *
1343 */
1344int
1345WINAPI
1347{
1348 PDC_ATTR pdcattr;
1349
1350 /* Get the DC attribute */
1351 pdcattr = GdiGetDcAttr(hdc);
1352 if (pdcattr == NULL)
1353 {
1354 /* Don't set LastError here! */
1355 return 0;
1356 }
1357
1358 return pdcattr->lStretchBltMode;
1359}
1360
1361/*
1362 * @implemented
1363 */
1364int
1365WINAPI
1367 _In_ HDC hdc,
1368 _In_ int iStretchMode)
1369{
1370 INT iOldMode;
1371 PDC_ATTR pdcattr;
1372
1373 HANDLE_METADC(INT, SetStretchBltMode, 0, hdc, iStretchMode);
1374
1375 /* Get the DC attribute */
1376 pdcattr = GdiGetDcAttr(hdc);
1377 if (pdcattr == NULL)
1378 {
1380 return 0;
1381 }
1382
1383 iOldMode = pdcattr->lStretchBltMode;
1384 pdcattr->lStretchBltMode = iStretchMode;
1385
1386 // Wine returns an error here. We set the default.
1387 if ((iStretchMode <= 0) || (iStretchMode > MAXSTRETCHBLTMODE)) iStretchMode = WHITEONBLACK;
1388
1389 pdcattr->jStretchBltMode = iStretchMode;
1390
1391 return iOldMode;
1392}
1393
1394/*
1395 * @implemented
1396 */
1397HFONT
1398WINAPI
1400{
1401 PDC_ATTR pdcattr;
1402
1403 /* Get the DC attribute */
1404 pdcattr = GdiGetDcAttr(hdc);
1405 if (pdcattr == NULL)
1406 {
1407 /* Don't set LastError here! */
1408 return NULL;
1409 }
1410
1411 /* Return the current font */
1412 return pdcattr->hlfntNew;
1413}
1414
1415
1416
1417HBITMAP
1418WINAPI
1420 _In_ HDC hdc,
1422{
1423 return NtGdiSelectBitmap(hdc, hbmp);
1424}
1425
1426HBRUSH
1427WINAPI
1429 _In_ HDC hdc,
1430 _In_ HBRUSH hbr)
1431{
1432 PDC_ATTR pdcattr;
1433 HBRUSH hbrOld;
1434
1435 HANDLE_METADC(HBRUSH, SelectObject, NULL, hdc, hbr);
1436
1437 /* Get the DC attribute */
1438 pdcattr = GdiGetDcAttr(hdc);
1439 if (pdcattr == NULL)
1440 {
1442 return NULL;
1443 }
1444
1445 /* Get the current brush. If it matches the new brush, we're done */
1446 hbrOld = pdcattr->hbrush;
1447 if (hbrOld == hbr)
1448 return hbrOld;
1449
1450 /* Set the new brush and update dirty flags */
1451 pdcattr->hbrush = hbr;
1452 pdcattr->ulDirty_ |= DC_BRUSH_DIRTY;
1453 return hbrOld;
1454}
1455
1456HPEN
1457WINAPI
1459 _In_ HDC hdc,
1460 _In_ HPEN hpen)
1461{
1462 PDC_ATTR pdcattr;
1463 HPEN hpenOld;
1464
1466
1467 /* Get the DC attribute */
1468 pdcattr = GdiGetDcAttr(hdc);
1469 if (pdcattr == NULL)
1470 {
1472 return NULL;
1473 }
1474
1475 /* Get the current pen. If it matches the new pen, we're done */
1476 hpenOld = pdcattr->hpen;
1477 if (hpenOld == hpen)
1478 return hpenOld;
1479
1480 /* Set the new pen and update dirty flags */
1481 pdcattr->ulDirty_ |= DC_PEN_DIRTY;
1482 pdcattr->hpen = hpen;
1483 return hpenOld;
1484}
1485
1486HFONT
1487WINAPI
1489 _In_ HDC hdc,
1491{
1492 PDC_ATTR pdcattr;
1493 HFONT hfontOld;
1494
1496
1497 /* Get the DC attribute */
1498 pdcattr = GdiGetDcAttr(hdc);
1499 if (pdcattr == NULL)
1500 {
1502 return NULL;
1503 }
1504
1505 /* Get the current font. If it matches the new font, we're done */
1506 hfontOld = pdcattr->hlfntNew;
1507 if (hfontOld == hfont)
1508 return hfontOld;
1509
1510 /* Set the new font and update dirty flags */
1511 pdcattr->hlfntNew = hfont;
1512 pdcattr->ulDirty_ &= ~SLOW_WIDTHS;
1513 pdcattr->ulDirty_ |= DIRTY_CHARSET;
1514
1515 /* If the DC does not have a DIB section selected, try a batch command */
1516 if (!(pdcattr->ulDirty_ & DC_DIBSECTION))
1517 {
1518 PGDIBSOBJECT pgO;
1519
1521 if (pgO)
1522 {
1523 pgO->hgdiobj = hfont;
1524 return hfontOld;
1525 }
1526 }
1527
1528 /* We could not use the batch command, call win32k */
1529 return NtGdiSelectFont(hdc, hfont);
1530}
1531
1532
1533/*
1534 * @implemented
1535 *
1536 */
1537HGDIOBJ
1538WINAPI
1540 _In_ HDC hdc,
1541 _In_ HGDIOBJ hobj)
1542{
1543 /* Fix up 16 bit handles */
1544 hobj = GdiFixUpHandle(hobj);
1545 if (!GdiValidateHandle(hobj))
1546 {
1547 return NULL;
1548 }
1549
1550 /* Call the appropriate select function */
1551 switch (GDI_HANDLE_GET_TYPE(hobj))
1552 {
1555
1558 return GdiSelectBitmap(hdc, hobj);
1559
1561 return GdiSelectBrush(hdc, hobj);
1562
1565 return GdiSelectPen(hdc, hobj);
1566
1568 return GdiSelectFont(hdc, hobj);
1569
1571 return SetColorSpace(hdc, hobj);
1572
1575
1576 default:
1577 return NULL;
1578 }
1579
1580 return NULL;
1581}
static HDC hDC
Definition: 3dtext.c:33
static HFONT hfont
static HPEN hpen
LONG NTSTATUS
Definition: precomp.h:26
#define DPRINT1
Definition: precomp.h:8
#define UlongToHandle(ul)
Definition: basetsd.h:97
HBITMAP hbmp
Definition: bufpool.h:45
LPARAM lParam
Definition: combotst.c:139
DWORD APIENTRY NtGdiGetBoundsRect(IN HDC hdc, OUT LPRECT prc, IN DWORD flags)
Definition: dcutil.c:708
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
#define ERROR_INVALID_FUNCTION
Definition: dderror.h:6
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define GetProcessHeap()
Definition: compat.h:736
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define SetLastError(x)
Definition: compat.h:752
#define HeapAlloc
Definition: compat.h:733
#define HeapFree(x, y, z)
Definition: compat.h:735
#define ERROR_INVALID_HANDLE
Definition: compat.h:98
#define ULONG_PTR
Definition: config.h:101
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
FORCEINLINE PVOID GdiAllocBatchCommand(HDC hdc, USHORT Cmd)
Definition: gdi32p.h:381
BOOL WINAPI GdiValidateHandle(HGDIOBJ)
Definition: misc.c:712
HGDIOBJ WINAPI GdiFixUpHandle(HGDIOBJ hGO)
Definition: misc.c:734
BOOL WINAPI EMFDC_SetD(_In_ PLDC pldc, _In_ DWORD dwIn, _In_ ULONG ulMFId)
Definition: rosglue.c:331
VOID GdiSAPCallback(PLDC pldc)
Definition: misc.c:819
BOOL WINAPI METADC_RosGlueDeleteDC(_In_ HDC hdc)
Definition: rosglue.c:392
#define HANDLE_METADC16(_RetType, _Func, dwError, hdc,...)
Definition: gdi32p.h:613
#define HANDLE_METADC(_RetType, _Func, dwError, hdc,...)
Definition: gdi32p.h:589
NTSTATUS HEAP_strdupA2W(LPWSTR *ppszW, LPCSTR lpszA)
Definition: heap.c:43
BOOL WINAPI METADC_SetD(_In_ HDC hdc, _In_ DWORD dwIn, _In_ USHORT usMF16Id)
Definition: rosglue.c:312
BOOL EMFDC_SelectPalette(LDC *dc_attr, HPALETTE palette) DECLSPEC_HIDDEN
#define HANDLE_METADC1P(_RetType, _Func, dwError, hdc,...)
Definition: gdi32p.h:666
PDEVCAPS GdiDevCaps
Definition: dllmain.c:10
VOID HEAP_free(LPVOID memory)
Definition: heap.c:63
HANDLE ghSpooler
Definition: printdrv.c:40
FORCEINLINE PDC_ATTR GdiGetDcAttr(HDC hdc)
Definition: gdi32p.h:451
BOOL METADC_SelectPalette(HDC hdc, HPALETTE palette) DECLSPEC_HIDDEN
Definition: metadc.c:1220
PLDC FASTCALL GdiGetLDC(HDC hDC)
Definition: misc.c:785
#define HANDLE_EMETAFDC(_RetType, _Func, dwError, hdc,...)
Definition: gdi32p.h:644
BOOL FASTCALL LoadTheSpoolerDrv(VOID)
Definition: printdrv.c:188
#define GDI_OBJECT_TYPE_DC
Definition: gdi.h:46
#define GDI_HANDLE_GET_TYPE(h)
Definition: gdi.h:31
#define GDI_OBJECT_TYPE_BITMAP
Definition: gdi.h:48
#define GDI_OBJECT_TYPE_PALETTE
Definition: gdi.h:49
#define GDI_OBJECT_TYPE_FONT
Definition: gdi.h:50
#define GDI_OBJECT_TYPE_METADC
Definition: gdi.h:57
#define LDC_LDC
Definition: gdi_private.h:104
#define DCB_WINDOWMGR
Definition: gdi_private.h:62
#define LDC_EMFLDC
Definition: gdi_private.h:105
@ GDILoObjType_LO_FONT_TYPE
Definition: gdi_private.h:37
@ GDILoObjType_LO_PALETTE_TYPE
Definition: gdi_private.h:36
@ GDILoObjType_LO_BRUSH_TYPE
Definition: gdi_private.h:33
@ GDILoObjType_LO_BITMAP_TYPE
Definition: gdi_private.h:35
@ GDILoObjType_LO_METADC16_TYPE
Definition: gdi_private.h:49
@ GDILoObjType_LO_REGION_TYPE
Definition: gdi_private.h:38
@ GDILoObjType_LO_EXTPEN_TYPE
Definition: gdi_private.h:45
@ GDILoObjType_LO_ICMLCS_TYPE
Definition: gdi_private.h:39
@ GDILoObjType_LO_DC_TYPE
Definition: gdi_private.h:34
@ GDILoObjType_LO_PEN_TYPE
Definition: gdi_private.h:44
@ GDILoObjType_LO_DIBSECTION_TYPE
Definition: gdi_private.h:46
Status
Definition: gdiplustypes.h:25
PVOID GdiGetHandleUserData(_In_ HGDIOBJ hobj)
Definition: gditools.c:68
GLbitfield flags
Definition: glext.h:7161
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble * u
Definition: glfuncs.h:240
#define DbgPrint
Definition: hal.h:12
HLOCAL NTAPI LocalAlloc(UINT uFlags, SIZE_T dwBytes)
Definition: heapmem.c:1390
_In_ ULONG Mode
Definition: hubbusif.h:303
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
NTSYSAPI ULONG WINAPI RtlNtStatusToDosError(NTSTATUS)
#define NtCurrentTeb
HDC hdc
Definition: main.c:9
static HBITMAP
Definition: button.c:44
static HDC
Definition: imagelist.c:92
static DWORD *static HFONT(WINAPI *pCreateFontIndirectExA)(const ENUMLOGFONTEXDVA *)
#define _In_
Definition: ms_sal.h:308
unsigned int UINT
Definition: ndis.h:50
NTSYSAPI NTSTATUS NTAPI RtlAnsiStringToUnicodeString(PUNICODE_STRING DestinationString, PANSI_STRING SourceString, BOOLEAN AllocateDestinationString)
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define FASTCALL
Definition: nt_native.h:50
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
NTSYSAPI VOID NTAPI RtlInitAnsiString(PANSI_STRING DestinationString, PCSZ SourceString)
BOOL APIENTRY NtGdiGetDCPoint(HDC hDC, UINT iPoint, PPOINTL Point)
Definition: coord.c:1424
__kernel_entry W32KAPI DWORD APIENTRY NtGdiSetBoundsRect(_In_ HDC hdc, _In_ LPRECT prc, _In_ DWORD f)
__kernel_entry W32KAPI HDC APIENTRY NtGdiCreateCompatibleDC(_In_opt_ HDC hdc)
__kernel_entry W32KAPI INT APIENTRY NtGdiGetDeviceCaps(_In_ HDC hdc, _In_ INT i)
__kernel_entry W32KAPI BOOL APIENTRY NtGdiRestoreDC(_In_ HDC hdc, _In_ INT iLevel)
__kernel_entry W32KAPI NTSTATUS APIENTRY NtGdiFlush(VOID)
Definition: gdibatch.c:471
_Out_ LPRECT prc
Definition: ntgdi.h:1658
_Out_ PDEVCAPS pDevCaps
Definition: ntgdi.h:2664
_In_ UINT _In_ DWORD dwIn
Definition: ntgdi.h:249
__kernel_entry W32KAPI BOOL APIENTRY NtGdiGetDCDword(_In_ HDC hdc, _In_ UINT u, _Out_ DWORD *Result)
__kernel_entry W32KAPI BOOL APIENTRY NtGdiCancelDC(_In_ HDC hdc)
__kernel_entry W32KAPI INT APIENTRY NtGdiSaveDC(_In_ HDC hdc)
__kernel_entry W32KAPI HBITMAP APIENTRY NtGdiSelectBitmap(_In_ HDC hdc, _In_ HBITMAP hbm)
__kernel_entry W32KAPI ULONG APIENTRY NtGdiEnumObjects(_In_ HDC hdc, _In_ INT iObjectType, _In_ ULONG cjBuf, _Out_writes_bytes_opt_(cjBuf) PVOID pvBuf)
__kernel_entry W32KAPI HANDLE APIENTRY NtGdiGetDCObject(_In_ HDC hdc, _In_ INT itype)
__kernel_entry W32KAPI BOOL APIENTRY NtGdiDeleteObjectApp(_In_ HANDLE hobj)
__kernel_entry W32KAPI BOOL APIENTRY NtGdiResetDC(_In_ HDC hdc, _In_ LPDEVMODEW pdm, _Out_ PBOOL pbBanding, _In_opt_ DRIVER_INFO_2W *pDriverInfo2, _At_((PUMDHPDEV *) ppUMdhpdev, _Out_) PVOID ppUMdhpdev)
Definition: dcstate.c:122
__kernel_entry W32KAPI HDC APIENTRY NtGdiOpenDCW(_In_opt_ PUNICODE_STRING pustrDevice, _In_ DEVMODEW *pdm, _In_ PUNICODE_STRING pustrLogAddr, _In_ ULONG iType, _In_ BOOL bDisplay, _In_opt_ HANDLE hspool, _At_((PUMDHPDEV *) pUMdhpdev, _Out_) PVOID pUMdhpdev)
Definition: dclife.c:694
__kernel_entry W32KAPI HFONT APIENTRY NtGdiSelectFont(_In_ HDC hdc, _In_ HFONT hf)
Definition: dcobjs.c:597
#define LDC_INIT_DOCUMENT
Definition: ntgdihdl.h:151
#define DC_PRIMARY_DISPLAY
Definition: ntgdihdl.h:139
#define LDC_DEVCAPS
Definition: ntgdihdl.h:166
#define DC_DIBSECTION
Definition: ntgdihdl.h:137
#define DIRTY_FILL
Definition: ntgdihdl.h:123
#define LDC_KILL_DOCUMENT
Definition: ntgdihdl.h:158
#define DC_MODE_DIRTY
Definition: ntgdihdl.h:144
#define DC_PEN_DIRTY
Definition: ntgdihdl.h:136
#define LDC_SAPCALLBACK
Definition: ntgdihdl.h:150
#define LDC_STARTPAGE
Definition: ntgdihdl.h:153
#define DIRTY_LINE
Definition: ntgdihdl.h:124
#define DIRTY_BACKGROUND
Definition: ntgdihdl.h:126
#define DIRTY_CHARSET
Definition: ntgdihdl.h:127
#define DC_BRUSH_DIRTY
Definition: ntgdihdl.h:135
@ GdiGetArcDirection
Definition: ntgdityp.h:52
@ GdiGetRelAbs
Definition: ntgdityp.h:49
@ GdiGetSetArcDirection
Definition: ntgdityp.h:70
@ GdiGetSetRelAbs
Definition: ntgdityp.h:65
@ GdiBCSelObj
Definition: ntgdityp.h:92
@ GdiGetAspectRatioFilter
Definition: ntgdityp.h:79
#define L(x)
Definition: ntvdm.h:50
#define OBJ_EXTPEN
Definition: objidl.idl:1419
#define OBJ_PEN
Definition: objidl.idl:1409
#define OBJ_BRUSH
Definition: objidl.idl:1410
#define OBJ_FONT
Definition: objidl.idl:1414
#define OBJ_BITMAP
Definition: objidl.idl:1415
#define OBJ_PAL
Definition: objidl.idl:1413
#define CONST
Definition: pedump.c:81
unsigned short USHORT
Definition: pedump.c:61
_Check_return_ _CRTIMP int __cdecl _wcsnicmp(_In_reads_or_z_(_MaxCount) const wchar_t *_Str1, _In_reads_or_z_(_MaxCount) const wchar_t *_Str2, _In_ size_t _MaxCount)
@ Output
Definition: arc.h:85
#define DPRINT
Definition: sndvol32.h:73
HANDLE hbrush
Definition: ntgdihdl.h:295
HANDLE hpen
Definition: ntgdihdl.h:296
LONG lStretchBltMode
Definition: ntgdihdl.h:315
LONG lFillMode
Definition: ntgdihdl.h:314
LONG lBkMode
Definition: ntgdihdl.h:313
ULONG ulBrushClr
Definition: ntgdihdl.h:302
BYTE jBkMode
Definition: ntgdihdl.h:308
PVOID pvLDC
Definition: ntgdihdl.h:293
BYTE jStretchBltMode
Definition: ntgdihdl.h:310
ULONG ulBackgroundClr
Definition: ntgdihdl.h:298
INT iGraphicsMode
Definition: ntgdihdl.h:306
COLORREF crBrushClr
Definition: ntgdihdl.h:301
ULONG ulPenClr
Definition: ntgdihdl.h:304
COLORREF crPenClr
Definition: ntgdihdl.h:303
HANDLE hlfntNew
Definition: ntgdihdl.h:330
COLORREF crBackgroundClr
Definition: ntgdihdl.h:297
HCOLORSPACE hColorSpace
Definition: ntgdihdl.h:319
ULONG ulDirty_
Definition: ntgdihdl.h:294
BYTE jROP2
Definition: ntgdihdl.h:307
ULONG ulVertSize
Definition: ntgdityp.h:303
ULONG ulPhysicalOffsetX
Definition: ntgdityp.h:321
ULONG ulNumFonts
Definition: ntgdityp.h:309
ULONG ulTechnology
Definition: ntgdityp.h:299
ULONG ulTextCaps
Definition: ntgdityp.h:323
ULONG ulAspectY
Definition: ntgdityp.h:313
ULONG ulLogPixelsX
Definition: ntgdityp.h:315
ULONG ulLogPixelsY
Definition: ntgdityp.h:316
ULONG ulVersion
Definition: ntgdityp.h:298
ULONG ulAspectX
Definition: ntgdityp.h:312
ULONG ulHorzSize
Definition: ntgdityp.h:302
ULONG ulBltAlignment
Definition: ntgdityp.h:327
ULONG ulSizePalette
Definition: ntgdityp.h:317
ULONG ulBitsPixel
Definition: ntgdityp.h:306
ULONG ulColorMgmtCaps
Definition: ntgdityp.h:333
ULONG ulHorzRes
Definition: ntgdityp.h:304
ULONG ulPhysicalHeight
Definition: ntgdityp.h:320
ULONG ulColorRes
Definition: ntgdityp.h:318
ULONG ulNumPens
Definition: ntgdityp.h:308
ULONG ulPhysicalOffsetY
Definition: ntgdityp.h:322
ULONG ulPhysicalWidth
Definition: ntgdityp.h:319
ULONG ulVertRes
Definition: ntgdityp.h:305
ULONG ulRasterCaps
Definition: ntgdityp.h:311
ULONG ulNumColors
Definition: ntgdityp.h:310
ULONG ulShadeBlend
Definition: ntgdityp.h:332
ULONG ulAspectXY
Definition: ntgdityp.h:314
ULONG ulPlanes
Definition: ntgdityp.h:307
ULONG ulVRefresh
Definition: ntgdityp.h:324
HGDIOBJ hgdiobj
Definition: ntgdityp.h:560
Definition: ntgdihdl.h:263
DEVCAPS DevCaps
Definition: ntgdihdl.h:280
INT iType
Definition: ntgdihdl.h:266
HDC hDC
Definition: ntgdihdl.h:264
ULONG Flags
Definition: ntgdihdl.h:265
#define DWORD_PTR
Definition: treelist.c:76
uint32_t DWORD_PTR
Definition: typedefs.h:65
void * PVOID
Definition: typedefs.h:50
int32_t INT
Definition: typedefs.h:58
#define IN
Definition: typedefs.h:39
uint32_t ULONG
Definition: typedefs.h:59
_Must_inspect_result_ _In_ WDFDEVICE Device
Definition: wdfchildlist.h:474
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ DEVPROPTYPE _In_ ULONG Size
Definition: wdfdevice.h:4533
HDC WINAPI GdiConvertAndCheckDC(HDC hdc)
Definition: dc.c:403
BOOL WINAPI CancelDC(HDC hDC)
Definition: dc.c:328
int WINAPI SetGraphicsMode(_In_ HDC hdc, _In_ int iMode)
Definition: dc.c:1226
COLORREF WINAPI SetDCPenColor(_In_ HDC hdc, _In_ COLORREF crColor)
Definition: dc.c:941
int WINAPI GetROP2(_In_ HDC hdc)
Definition: dc.c:1086
INT WINAPI GetArcDirection(_In_ HDC hdc)
Definition: dc.c:358
HBRUSH WINAPI GdiSelectBrush(_In_ HDC hdc, _In_ HBRUSH hbr)
Definition: dc.c:1428
INT WINAPI SetRelAbs(HDC hdc, INT Mode)
Definition: dc.c:733
int WINAPI SetROP2(_In_ HDC hdc, _In_ int rop2)
Definition: dc.c:1107
HPALETTE WINAPI NtUserSelectPalette(HDC hDC, HPALETTE hpal, BOOL ForceBackground)
Definition: windc.c:1034
HDC WINAPI CreateDCW(LPCWSTR lpwszDriver, LPCWSTR lpwszDevice, LPCWSTR lpwszOutput, CONST DEVMODEW *lpInitData)
Definition: dc.c:193
HFONT WINAPI GdiSelectFont(_In_ HDC hdc, _In_ HFONT hfont)
Definition: dc.c:1488
COLORREF WINAPI GetDCPenColor(_In_ HDC hdc)
Definition: dc.c:884
BOOL WINAPI GetAspectRatioFilterEx(HDC hdc, LPSIZE lpAspectRatio)
Definition: dc.c:808
int WINAPI SetBkMode(_In_ HDC hdc, _In_ int iBkMode)
Definition: dc.c:1056
HGDIOBJ WINAPI GetCurrentObject(_In_ HDC hdc, _In_ UINT uObjectType)
Definition: dc.c:428
DWORD WINAPI GetRelAbs(_In_ HDC hdc, _In_ DWORD dwIgnore)
Definition: dc.c:720
HDC WINAPI CreateICA(LPCSTR lpszDriver, LPCSTR lpszDevice, LPCSTR lpszOutput, CONST DEVMODEA *lpdvmInit)
Definition: dc.c:231
HFONT WINAPI GetHFONT(HDC hdc)
Definition: dc.c:1399
DWORD WINAPI GetDCDWord(_In_ HDC hdc, _In_ UINT u, _In_ DWORD dwError)
Definition: dc.c:787
DWORD WINAPI GetAndSetDCDWord(_In_ HDC hdc, _In_ UINT u, _In_ DWORD dwIn, _In_ ULONG ulMFId, _In_ USHORT usMF16Id, _In_ DWORD dwError)
Definition: dc.c:746
HDC WINAPI CreateICW(LPCWSTR lpszDriver, LPCWSTR lpszDevice, LPCWSTR lpszOutput, CONST DEVMODEW *lpdvmInit)
Definition: dc.c:212
int WINAPI EnumObjects(HDC hdc, int nObjectType, GOBJENUMPROC lpObjectFunc, LPARAM lParam)
Definition: dc.c:489
BOOL WINAPI GdiCleanCacheDC(HDC hdc)
Definition: dc.c:390
HPALETTE WINAPI SelectPalette(HDC hdc, HPALETTE hpal, BOOL bForceBackground)
Definition: dc.c:1312
INT WINAPI SetArcDirection(_In_ HDC hdc, _In_ INT nDirection)
Definition: dc.c:367
HPEN WINAPI GdiSelectPen(_In_ HDC hdc, _In_ HPEN hpen)
Definition: dc.c:1458
COLORREF WINAPI SetDCBrushColor(_In_ HDC hdc, _In_ COLORREF crColor)
Definition: dc.c:905
int WINAPI GetStretchBltMode(HDC hdc)
Definition: dc.c:1346
HDC FASTCALL IntCreateDICW(LPCWSTR lpwszDriver, LPCWSTR lpwszDevice, LPCWSTR lpwszOutput, PDEVMODEW lpInitData, ULONG iType)
Definition: dc.c:8
BOOL WINAPI GdiReleaseDC(HDC hdc)
Definition: dc.c:379
int WINAPI GetGraphicsMode(HDC hdc)
Definition: dc.c:1205
COLORREF WINAPI GetDCBrushColor(_In_ HDC hdc)
Definition: dc.c:863
int WINAPI GetPolyFillMode(HDC hdc)
Definition: dc.c:1146
int WINAPI GetBkMode(HDC hdc)
Definition: dc.c:1035
int WINAPI SetPolyFillMode(_In_ HDC hdc, _In_ int iPolyFillMode)
Definition: dc.c:1167
HBITMAP WINAPI GdiSelectBitmap(_In_ HDC hdc, _In_ HBITMAP hbmp)
Definition: dc.c:1419
int WINAPI SetStretchBltMode(_In_ HDC hdc, _In_ int iStretchMode)
Definition: dc.c:1366
HDC WINAPI ResetDCW(_In_ HDC hdc, _In_ CONST DEVMODEW *lpInitData)
Definition: dc.c:1277
#define LMEM_ZEROINIT
Definition: winbase.h:375
_In_ ULONG iMode
Definition: winddi.h:3520
_In_ ULONG iType
Definition: winddi.h:3748
LONG_PTR LPARAM
Definition: windef.h:208
DWORD COLORREF
Definition: windef.h:300
#define WINAPI
Definition: msvc.h:6
#define NUMRESERVED
Definition: wingdi.h:733
#define PHYSICALOFFSETY
Definition: wingdi.h:738
#define GM_COMPATIBLE
Definition: wingdi.h:864
#define NUMBRUSHES
Definition: wingdi.h:722
#define WHITEONBLACK
Definition: wingdi.h:953
#define LC_WIDESTYLED
Definition: wingdi.h:777
#define RASTERCAPS
Definition: wingdi.h:745
#define CC_CIRCLES
Definition: wingdi.h:761
#define HORZRES
Definition: wingdi.h:716
#define CC_WIDESTYLED
Definition: wingdi.h:767
struct tagLOGPEN LOGPEN
HCOLORSPACE WINAPI SetColorSpace(_In_ HDC, _In_ HCOLORSPACE)
#define ASPECTX
Definition: wingdi.h:727
int WINAPI GetClipBox(_In_ HDC, _Out_ LPRECT)
int WINAPI GetDeviceCaps(_In_opt_ HDC, _In_ int)
#define PC_RECTANGLE
Definition: wingdi.h:797
#define CC_WIDE
Definition: wingdi.h:765
#define GM_ADVANCED
Definition: wingdi.h:865
#define CC_INTERIORS
Definition: wingdi.h:768
COLORREF WINAPI SetBkColor(_In_ HDC, _In_ COLORREF)
Definition: dc.c:999
#define PHYSICALHEIGHT
Definition: wingdi.h:736
#define CP_RECTANGLE
Definition: wingdi.h:826
#define COLORRES
Definition: wingdi.h:734
#define SCALINGFACTORX
Definition: wingdi.h:739
DEVMODEW *WINAPI GdiConvertToDevmodeW(const DEVMODEA *)
Definition: misc.c:969
#define BLTALIGNMENT
Definition: wingdi.h:744
#define OBJ_COLORSPACE
Definition: wingdi.h:704
#define META_SETRELABS
Definition: wingdi.h:214
#define LC_STYLED
Definition: wingdi.h:776
#define PC_SCANLINE
Definition: wingdi.h:799
#define VERTSIZE
Definition: wingdi.h:715
#define LOGPIXELSY
Definition: wingdi.h:719
#define PHYSICALOFFSETX
Definition: wingdi.h:737
#define SIZEPALETTE
Definition: wingdi.h:732
HDC WINAPI ResetDCA(_In_ HDC, _In_ const DEVMODEA *)
#define DRIVERVERSION
Definition: wingdi.h:705
#define NUMCOLORS
Definition: wingdi.h:725
#define POLYGONALCAPS
Definition: wingdi.h:779
HGDIOBJ WINAPI SelectObject(_In_ HDC, _In_ HGDIOBJ)
Definition: dc.c:1539
HDC WINAPI CreateDCA(_In_opt_ LPCSTR pszDriver, _In_opt_ LPCSTR pszDevice, _In_opt_ LPCSTR pszOutput, _In_opt_ const DEVMODEA *pdmInit)
#define CC_ELLIPSES
Definition: wingdi.h:764
HDC WINAPI CreateCompatibleDC(_In_opt_ HDC hdc)
#define LC_POLYMARKER
Definition: wingdi.h:774
#define HORZSIZE
Definition: wingdi.h:714
#define RGN_COPY
Definition: wingdi.h:357
#define PDEVICESIZE
Definition: wingdi.h:730
#define TEXTCAPS
Definition: wingdi.h:806
#define SCALINGFACTORY
Definition: wingdi.h:740
#define CLR_INVALID
Definition: wingdi.h:883
#define VREFRESH
Definition: wingdi.h:741
BOOL WINAPI RestoreDC(_In_ HDC, _In_ int)
#define VERTRES
Definition: wingdi.h:717
#define EMR_SETARCDIRECTION
Definition: wingdi.h:131
COLORREF WINAPI GetBkColor(_In_ HDC)
Definition: dc.c:978
#define LC_POLYLINE
Definition: wingdi.h:772
#define CC_ROUNDRECT
Definition: wingdi.h:769
#define PC_WINDPOLYGON
Definition: wingdi.h:798
#define CURVECAPS
Definition: wingdi.h:759
#define PHYSICALWIDTH
Definition: wingdi.h:735
int WINAPI StartPage(_In_ HDC)
#define PC_WIDE
Definition: wingdi.h:801
#define LC_WIDE
Definition: wingdi.h:775
#define PLANES
Definition: wingdi.h:721
#define DESKTOPHORZRES
Definition: wingdi.h:742
#define CC_PIE
Definition: wingdi.h:762
#define LOGPIXELSX
Definition: wingdi.h:718
#define CC_STYLED
Definition: wingdi.h:766
#define BITSPIXEL
Definition: wingdi.h:720
FARPROC GOBJENUMPROC
Definition: wingdi.h:2905
#define PC_STYLED
Definition: wingdi.h:802
#define CC_CHORD
Definition: wingdi.h:763
#define NUMFONTS
Definition: wingdi.h:724
#define PC_INTERIORS
Definition: wingdi.h:804
#define LC_INTERIORS
Definition: wingdi.h:778
#define PC_POLYGON
Definition: wingdi.h:794
#define LINECAPS
Definition: wingdi.h:770
#define ASPECTY
Definition: wingdi.h:728
#define NUMPENS
Definition: wingdi.h:723
#define LC_MARKER
Definition: wingdi.h:773
BOOL WINAPI DeleteDC(_In_ HDC)
#define DESKTOPVERTRES
Definition: wingdi.h:743
UINT WINAPI SetBoundsRect(_In_ HDC, _In_opt_ LPCRECT, _In_ UINT)
int WINAPI SaveDC(_In_ HDC)
int WINAPI ExtSelectClipRgn(_In_ HDC, _In_opt_ HRGN, _In_ int)
#define CLIPCAPS
Definition: wingdi.h:731
#define ASPECTXY
Definition: wingdi.h:729
#define TECHNOLOGY
Definition: wingdi.h:706
UINT WINAPI GetBoundsRect(_In_ HDC, _Out_ LPRECT, _In_ UINT)
struct tagLOGBRUSH LOGBRUSH
#define PC_WIDESTYLED
Definition: wingdi.h:803
#define MAXSTRETCHBLTMODE
Definition: wingdi.h:956
_In_ int _Inout_ LPRECT lprc
Definition: winuser.h:4466
_At_(*)(_In_ PWSK_CLIENT Client, _In_opt_ PUNICODE_STRING NodeName, _In_opt_ PUNICODE_STRING ServiceName, _In_opt_ ULONG NameSpace, _In_opt_ GUID *Provider, _In_opt_ PADDRINFOEXW Hints, _Outptr_ PADDRINFOEXW *Result, _In_opt_ PEPROCESS OwningProcess, _In_opt_ PETHREAD OwningThread, _Inout_ PIRP Irp Result)(Mem)) NTSTATUS(WSKAPI *PFN_WSK_GET_ADDRESS_INFO
Definition: wsk.h:409
int Display
Definition: x11stubs.h:25
const char * LPCSTR
Definition: xmlstorage.h:183
char * LPSTR
Definition: xmlstorage.h:182
WCHAR * LPWSTR
Definition: xmlstorage.h:184
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
unsigned char BYTE
Definition: xxhash.c:193