ReactOS  0.4.15-dev-3303-g1ade494
dc.c
Go to the documentation of this file.
1 #include <precomp.h>
2 
3 #define NDEBUG
4 #include <debug.h>
5 
6 HDC
9  LPCWSTR lpwszDriver,
10  LPCWSTR lpwszDevice,
11  LPCWSTR lpwszOutput,
12  PDEVMODEW lpInitData,
13  ULONG iType)
14 {
16  HDC hdc = NULL;
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 
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  */
95 HDC
96 WINAPI
98  _In_ HDC hdc)
99 {
100  HDC hdcNew;
101 // PDC_ATTR pdcattr;
102 
103  hdcNew = NtGdiCreateCompatibleDC(hdc);
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  */
120 HDC
121 WINAPI
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  */
191 HDC
192 WINAPI
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  */
210 HDC
211 WINAPI
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  */
229 HDC
230 WINAPI
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  */
280 BOOL
281 WINAPI
283 {
284  ULONG hType = GDI_HANDLE_GET_TYPE(hdc);
285 
286  if (hType != GDILoObjType_LO_DC_TYPE)
287  {
288  return METADC_RosGlueDeleteDC(hdc);
289  }
290 
291  //if ( ghICM || pdcattr->pvLIcm )
292  // IcmDeleteLocalDC( hdc, pdcattr, NULL );
293 
294  return NtGdiDeleteObjectApp(hdc);
295 }
296 
297 
298 /*
299  * @implemented
300  */
301 INT
302 WINAPI
304 {
306  return NtGdiSaveDC(hdc);
307 }
308 
309 
310 /*
311  * @implemented
312  */
313 BOOL
314 WINAPI
316  IN INT iLevel)
317 {
318  HANDLE_METADC(BOOL, RestoreDC, FALSE, hdc, iLevel);
319  return NtGdiRestoreDC(hdc, iLevel);
320 }
321 
322 
323 /*
324  * @implemented
325  */
326 BOOL
327 WINAPI
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 
356 INT
357 WINAPI
359  _In_ HDC hdc)
360 {
361  return GetDCDWord( hdc, GdiGetArcDirection, 0);
362 }
363 
364 
365 INT
366 WINAPI
368  _In_ HDC hdc,
369  _In_ INT nDirection)
370 {
372 }
373 
374 /*
375  * @unimplemented
376  */
377 BOOL
378 WINAPI
380 {
381  return 0;
382 }
383 
384 
385 /*
386  * @implemented
387  */
388 BOOL
389 WINAPI
391 {
393  return TRUE;
395  return FALSE;
396 }
397 
398 /*
399  * @implemented
400  */
401 HDC
402 WINAPI
404 {
405  PLDC pldc;
406  ULONG hType = GDI_HANDLE_GET_TYPE(hdc);
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  */
426 HGDIOBJ
427 WINAPI
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  */
487 int
488 WINAPI
490  int nObjectType,
491  GOBJENUMPROC lpObjectFunc,
492  LPARAM lParam)
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;
536  Buffer = (PVOID)((DWORD_PTR)Buffer + Size);
537  }
538 
540  return Result;
541 }
542 
543 
544 /*
545  * @implemented
546  *
547  */
548 int
549 WINAPI
551  _In_ HDC hdc,
552  _In_ int nIndex)
553 {
554  PDC_ATTR pdcattr;
555  PLDC pldc;
556  ULONG hType = GDI_HANDLE_GET_TYPE(hdc);
557  PDEVCAPS pDevCaps = GdiDevCaps; // Primary display device capabilities.
558  DPRINT("Device CAPS1\n");
559 
560  HANDLE_METADC16(INT, GetDeviceCaps, 0, hdc, nIndex);
561 
562  if ( hType != GDILoObjType_LO_DC_TYPE && hType != GDILoObjType_LO_METADC16_TYPE )
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:
671  return pDevCaps->ulColorMgmtCaps;
672 
673  case PHYSICALWIDTH:
674  return pDevCaps->ulPhysicalWidth;
675 
676  case PHYSICALHEIGHT:
677  return pDevCaps->ulPhysicalHeight;
678 
679  case PHYSICALOFFSETX:
680  return pDevCaps->ulPhysicalOffsetX;
681 
682  case PHYSICALOFFSETY:
683  return pDevCaps->ulPhysicalOffsetY;
684 
685  case VREFRESH:
686  return pDevCaps->ulVRefresh;
687 
688  case RASTERCAPS:
689  return pDevCaps->ulRasterCaps;
690 
691  case CURVECAPS:
692  return (CC_CIRCLES | CC_PIE | CC_CHORD | CC_ELLIPSES | CC_WIDE |
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  */
718 DWORD
719 WINAPI
721  _In_ HDC hdc,
722  _In_ DWORD dwIgnore)
723 {
724  return GetDCDWord(hdc, GdiGetRelAbs, 0);
725 }
726 
727 
728 /*
729  * @implemented
730  */
731 INT
732 WINAPI
734  HDC hdc,
735  INT Mode)
736 {
738 }
739 
740 
741 /*
742  * @implemented
743  */
744 DWORD
745 WINAPI
747  _In_ HDC hdc,
748  _In_ UINT u,
749  _In_ DWORD dwIn,
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  */
785 DWORD
786 WINAPI
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  */
806 BOOL
807 WINAPI
809  HDC hdc,
810  LPSIZE lpAspectRatio)
811 {
812  return NtGdiGetDCPoint(hdc, GdiGetAspectRatioFilter, (PPOINTL)lpAspectRatio );
813 }
814 
815 
816 /*
817  * @implemented
818  */
819 UINT
820 WINAPI
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  */
834 UINT
835 WINAPI
837  CONST RECT *prc,
838  UINT flags)
839 {
840  /* FIXME add check for validate the flags */
842 }
843 
844 
845 /*
846  * @implemented
847  *
848  */
849 int
850 WINAPI
852  LPRECT lprc)
853 {
854  return NtGdiGetAppClipBox(hdc, lprc);
855 }
856 
857 
858 /*
859  * @implemented
860  */
861 COLORREF
862 WINAPI
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  */
882 COLORREF
883 WINAPI
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  */
903 COLORREF
904 WINAPI
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  */
939 COLORREF
940 WINAPI
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  */
976 COLORREF
977 WINAPI
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  */
997 COLORREF
998 WINAPI
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  */
1033 int
1034 WINAPI
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  */
1054 int
1055 WINAPI
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  */
1084 int
1085 WINAPI
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  */
1105 int
1106 WINAPI
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  */
1144 int
1145 WINAPI
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  */
1165 int
1166 WINAPI
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  */
1203 int
1204 WINAPI
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  */
1224 int
1225 WINAPI
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  */
1275 HDC
1276 WINAPI
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  */
1289 HDC
1290 WINAPI
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 
1310 HPALETTE
1311 WINAPI
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  */
1344 int
1345 WINAPI
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  */
1364 int
1365 WINAPI
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  */
1397 HFONT
1398 WINAPI
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 
1417 HBITMAP
1418 WINAPI
1420  _In_ HDC hdc,
1421  _In_ HBITMAP hbmp)
1422 {
1423  return NtGdiSelectBitmap(hdc, hbmp);
1424 }
1425 
1426 HBRUSH
1427 WINAPI
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 
1456 HPEN
1457 WINAPI
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 
1486 HFONT
1487 WINAPI
1489  _In_ HDC hdc,
1490  _In_ HFONT hfont)
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  */
1537 HGDIOBJ
1538 WINAPI
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 }
1582 
1583 /***********************************************************************
1584  * D3DKMTCreateDCFromMemory (GDI32.@)
1585  */
1587 {
1589 }
1590 
1592 {
1594 }
HDC WINAPI CreateICA(LPCSTR lpszDriver, LPCSTR lpszDevice, LPCSTR lpszOutput, CONST DEVMODEA *lpdvmInit)
Definition: dc.c:231
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 CP_RECTANGLE
Definition: wingdi.h:826
BOOL EMFDC_SelectPalette(LDC *dc_attr, HPALETTE palette) DECLSPEC_HIDDEN
__kernel_entry W32KAPI DWORD APIENTRY NtGdiDdDDIDestroyDCFromMemory(_In_ CONST D3DKMT_DESTROYDCFROMMEMORY *desc)
#define DESKTOPHORZRES
Definition: wingdi.h:742
int WINAPI GetStretchBltMode(HDC hdc)
Definition: dc.c:1346
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define CC_PIE
Definition: wingdi.h:762
_Out_ PDEVCAPS pDevCaps
Definition: ntgdi.h:2664
#define DESKTOPVERTRES
Definition: wingdi.h:743
#define NUMBRUSHES
Definition: wingdi.h:722
#define CC_CHORD
Definition: wingdi.h:763
#define BITSPIXEL
Definition: wingdi.h:720
#define IN
Definition: typedefs.h:39
VOID HEAP_free(LPVOID memory)
Definition: heap.c:63
#define EMR_SETARCDIRECTION
Definition: wingdi.h:131
__kernel_entry W32KAPI BOOL APIENTRY NtGdiGetDCDword(_In_ HDC hdc, _In_ UINT u, _Out_ DWORD *Result)
#define HORZRES
Definition: wingdi.h:716
#define LOGPIXELSX
Definition: wingdi.h:718
ULONG ulBltAlignment
Definition: ntgdityp.h:327
#define NUMRESERVED
Definition: wingdi.h:733
#define LC_WIDE
Definition: wingdi.h:775
HDC WINAPI ResetDCA(_In_ HDC hdc, _In_ CONST DEVMODEA *lpInitData)
Definition: dc.c:1291
ULONG ulHorzRes
Definition: ntgdityp.h:304
HPALETTE WINAPI SelectPalette(HDC hdc, HPALETTE hpal, BOOL bForceBackground)
Definition: dc.c:1312
_In_ int _Inout_ LPRECT lprc
Definition: winuser.h:4441
HCOLORSPACE WINAPI SetColorSpace(_In_ HDC, _In_ HCOLORSPACE)
#define DWORD_PTR
Definition: treelist.c:76
DWORD WINAPI GetDCDWord(_In_ HDC hdc, _In_ UINT u, _In_ DWORD dwError)
Definition: dc.c:787
#define DbgPrint
Definition: hal.h:12
_In_ ULONG iMode
Definition: winddi.h:3520
#define PC_INTERIORS
Definition: wingdi.h:804
_In_ ULONG Mode
Definition: hubbusif.h:303
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
#define LDC_LDC
Definition: gdi_private.h:104
#define ASPECTX
Definition: wingdi.h:727
#define ERROR_INVALID_FUNCTION
Definition: dderror.h:6
ULONG ulRasterCaps
Definition: ntgdityp.h:311
HANDLE hbrush
Definition: ntgdihdl.h:313
#define TRUE
Definition: types.h:120
BYTE jStretchBltMode
Definition: ntgdihdl.h:328
HANDLE hpen
Definition: ntgdihdl.h:314
_In_ ULONG iType
Definition: winddi.h:3748
#define LC_POLYLINE
Definition: wingdi.h:772
#define DIRTY_CHARSET
Definition: ntgdihdl.h:149
INT WINAPI SetArcDirection(_In_ HDC hdc, _In_ INT nDirection)
Definition: dc.c:367
HPALETTE WINAPI NtUserSelectPalette(HDC hDC, HPALETTE hpal, BOOL ForceBackground)
Definition: windc.c:1033
FORCEINLINE PDC_ATTR GdiGetDcAttr(HDC hdc)
Definition: gdi32p.h:451
#define CC_STYLED
Definition: wingdi.h:766
ULONG ulNumFonts
Definition: ntgdityp.h:309
__kernel_entry W32KAPI ULONG APIENTRY NtGdiEnumObjects(_In_ HDC hdc, _In_ INT iObjectType, _In_ ULONG cjBuf, _Out_writes_bytes_opt_(cjBuf) PVOID pvBuf)
#define MAXSTRETCHBLTMODE
Definition: wingdi.h:956
#define DC_PEN_DIRTY
Definition: ntgdihdl.h:158
BOOL WINAPI METADC_SetD(_In_ HDC hdc, _In_ DWORD dwIn, _In_ USHORT usMF16Id)
Definition: rosglue.c:312
#define ERROR_INVALID_HANDLE
Definition: compat.h:98
LONG NTSTATUS
Definition: precomp.h:26
PDEVCAPS GdiDevCaps
Definition: dllmain.c:10
HDC WINAPI ResetDCW(_In_ HDC hdc, _In_ CONST DEVMODEW *lpInitData)
Definition: dc.c:1277
HFONT WINAPI GetHFONT(HDC hdc)
Definition: dc.c:1399
#define HANDLE_METADC16(_RetType, _Func, dwError, hdc,...)
Definition: gdi32p.h:613
#define COLORRES
Definition: wingdi.h:734
__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
static HDC
Definition: imagelist.c:92
#define DRIVERVERSION
Definition: wingdi.h:705
_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)
#define CLR_INVALID
Definition: wingdi.h:883
HCOLORSPACE hColorSpace
Definition: ntgdihdl.h:337
#define PDEVICESIZE
Definition: wingdi.h:730
__kernel_entry W32KAPI BOOL APIENTRY NtGdiRestoreDC(_In_ HDC hdc, _In_ INT iLevel)
#define DC_DIBSECTION
Definition: ntgdihdl.h:159
__kernel_entry W32KAPI HBITMAP APIENTRY NtGdiSelectBitmap(_In_ HDC hdc, _In_ HBITMAP hbm)
#define BLTALIGNMENT
Definition: wingdi.h:744
ULONG ulHorzSize
Definition: ntgdityp.h:302
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:361
int WINAPI SetStretchBltMode(_In_ HDC hdc, _In_ int iStretchMode)
Definition: dc.c:1366
#define SCALINGFACTORX
Definition: wingdi.h:739
LONG lFillMode
Definition: ntgdihdl.h:332
int WINAPI GetClipBox(HDC hdc, LPRECT lprc)
Definition: dc.c:851
__kernel_entry W32KAPI BOOL APIENTRY NtGdiCancelDC(_In_ HDC hdc)
BOOL WINAPI CancelDC(HDC hDC)
Definition: dc.c:328
#define LC_POLYMARKER
Definition: wingdi.h:774
#define POLYGONALCAPS
Definition: wingdi.h:779
#define DCB_WINDOWMGR
Definition: gdi_private.h:62
COLORREF crPenClr
Definition: ntgdihdl.h:321
static HPEN hpen
ULONG ulBitsPixel
Definition: ntgdityp.h:306
#define PC_WINDPOLYGON
Definition: wingdi.h:798
char * LPSTR
Definition: xmlstorage.h:182
ULONG ulPhysicalHeight
Definition: ntgdityp.h:320
#define RASTERCAPS
Definition: wingdi.h:745
DWORD WINAPI D3DKMTDestroyDCFromMemory(const D3DKMT_DESTROYDCFROMMEMORY *desc)
Definition: dc.c:1591
#define FASTCALL
Definition: nt_native.h:50
DEVMODEW *WINAPI GdiConvertToDevmodeW(const DEVMODEA *)
Definition: misc.c:969
int32_t INT
Definition: typedefs.h:58
#define TECHNOLOGY
Definition: wingdi.h:706
ULONG ulVRefresh
Definition: ntgdityp.h:324
#define HANDLE_METADC(_RetType, _Func, dwError, hdc,...)
Definition: gdi32p.h:589
ULONG Flags
Definition: ntgdihdl.h:287
#define DIRTY_BACKGROUND
Definition: ntgdihdl.h:148
int WINAPI GetROP2(_In_ HDC hdc)
Definition: dc.c:1086
ULONG ulBackgroundClr
Definition: ntgdihdl.h:316
NTSYSAPI VOID NTAPI RtlInitAnsiString(PANSI_STRING DestinationString, PCSZ SourceString)
DWORD WINAPI GetRelAbs(_In_ HDC hdc, _In_ DWORD dwIgnore)
Definition: dc.c:720
#define OBJ_PEN
Definition: objidl.idl:1409
int WINAPI StartPage(_In_ HDC)
#define TEXTCAPS
Definition: wingdi.h:806
__kernel_entry W32KAPI DWORD APIENTRY NtGdiSetBoundsRect(_In_ HDC hdc, _In_ LPRECT prc, _In_ DWORD f)
#define PHYSICALHEIGHT
Definition: wingdi.h:736
ULONG ulShadeBlend
Definition: ntgdityp.h:332
#define DC_PRIMARY_DISPLAY
Definition: ntgdihdl.h:161
int WINAPI ExtSelectClipRgn(_In_ HDC, _In_opt_ HRGN, _In_ int)
#define PC_WIDESTYLED
Definition: wingdi.h:803
__kernel_entry W32KAPI INT APIENTRY NtGdiSaveDC(_In_ HDC hdc)
#define LDC_KILL_DOCUMENT
Definition: ntgdihdl.h:180
BOOL WINAPI GdiCleanCacheDC(HDC hdc)
Definition: dc.c:390
NTSYSAPI ULONG WINAPI RtlNtStatusToDosError(NTSTATUS)
UINT WINAPI SetBoundsRect(HDC hdc, CONST RECT *prc, UINT flags)
Definition: dc.c:836
COLORREF WINAPI SetDCBrushColor(_In_ HDC hdc, _In_ COLORREF crColor)
Definition: dc.c:905
#define NUMCOLORS
Definition: wingdi.h:725
BOOL WINAPI EMFDC_SetD(_In_ PLDC pldc, _In_ DWORD dwIn, _In_ ULONG ulMFId)
Definition: rosglue.c:331
#define FALSE
Definition: types.h:117
unsigned int BOOL
Definition: ntddk_ex.h:94
INT WINAPI GetArcDirection(_In_ HDC hdc)
Definition: dc.c:358
static const WCHAR desc[]
Definition: protectdata.c:36
ULONG ulNumPens
Definition: ntgdityp.h:308
ULONG ulVertRes
Definition: ntgdityp.h:305
HANDLE hlfntNew
Definition: ntgdihdl.h:348
#define OBJ_COLORSPACE
Definition: wingdi.h:704
#define VREFRESH
Definition: wingdi.h:741
int WINAPI GetDeviceCaps(_In_ HDC hdc, _In_ int nIndex)
Definition: dc.c:550
#define CC_INTERIORS
Definition: wingdi.h:768
ULONG ulVertSize
Definition: ntgdityp.h:303
int WINAPI EnumObjects(HDC hdc, int nObjectType, GOBJENUMPROC lpObjectFunc, LPARAM lParam)
Definition: dc.c:489
HBITMAP WINAPI GdiSelectBitmap(_In_ HDC hdc, _In_ HBITMAP hbmp)
Definition: dc.c:1419
HANDLE ghSpooler
Definition: printdrv.c:40
ULONG ulAspectXY
Definition: ntgdityp.h:314
NTSTATUS HEAP_strdupA2W(LPWSTR *ppszW, LPCSTR lpszA)
Definition: heap.c:43
#define LC_MARKER
Definition: wingdi.h:773
_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:426
#define _In_
Definition: ms_sal.h:308
LONG_PTR LPARAM
Definition: windef.h:208
int WINAPI GetBkMode(HDC hdc)
Definition: dc.c:1035
HDC hDC
Definition: ntgdihdl.h:286
#define LDC_INIT_DOCUMENT
Definition: ntgdihdl.h:173
Definition: bufpool.h:45
BOOL WINAPI DeleteDC(HDC hdc)
Definition: dc.c:282
const char * LPCSTR
Definition: xmlstorage.h:183
void * PVOID
Definition: retypes.h:9
INT WINAPI SaveDC(IN HDC hdc)
Definition: dc.c:303
HGDIOBJ WINAPI GdiFixUpHandle(HGDIOBJ hGO)
Definition: misc.c:734
#define GDI_OBJECT_TYPE_PALETTE
Definition: gdi.h:49
static HFONT hfont
__kernel_entry W32KAPI HANDLE APIENTRY NtGdiGetDCObject(_In_ HDC hdc, _In_ INT itype)
ULONG ulDirty_
Definition: ntgdihdl.h:312
#define GDI_HANDLE_GET_TYPE(h)
Definition: gdi.h:31
#define SCALINGFACTORY
Definition: wingdi.h:740
HBITMAP hbmp
#define PC_STYLED
Definition: wingdi.h:802
__kernel_entry W32KAPI NTSTATUS APIENTRY NtGdiFlush(VOID)
Definition: gdibatch.c:471
#define CC_WIDE
Definition: wingdi.h:765
ULONG ulColorRes
Definition: ntgdityp.h:318
Status
Definition: gdiplustypes.h:24
ULONG ulPhysicalOffsetY
Definition: ntgdityp.h:322
#define LC_STYLED
Definition: wingdi.h:776
#define LDC_STARTPAGE
Definition: ntgdihdl.h:175
__kernel_entry W32KAPI HFONT APIENTRY NtGdiSelectFont(_In_ HDC hdc, _In_ HFONT hf)
Definition: dcobjs.c:597
ULONG ulAspectY
Definition: ntgdityp.h:313
VOID GdiSAPCallback(PLDC pldc)
Definition: misc.c:819
#define PC_WIDE
Definition: wingdi.h:801
COLORREF crBackgroundClr
Definition: ntgdihdl.h:315
ULONG ulPlanes
Definition: ntgdityp.h:307
PLDC FASTCALL GdiGetLDC(HDC hDC)
Definition: misc.c:785
#define ASPECTXY
Definition: wingdi.h:729
int WINAPI SetBkMode(_In_ HDC hdc, _In_ int iBkMode)
Definition: dc.c:1056
ULONG ulVersion
Definition: ntgdityp.h:298
#define GetProcessHeap()
Definition: compat.h:595
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
#define LMEM_ZEROINIT
Definition: winbase.h:372
#define PHYSICALOFFSETY
Definition: wingdi.h:738
int WINAPI GetPolyFillMode(HDC hdc)
Definition: dc.c:1146
BOOL WINAPI GetAspectRatioFilterEx(HDC hdc, LPSIZE lpAspectRatio)
Definition: dc.c:808
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
HGDIOBJ hgdiobj
Definition: ntgdityp.h:560
DWORD COLORREF
Definition: windef.h:300
#define UlongToHandle(ul)
Definition: basetsd.h:97
BYTE jROP2
Definition: ntgdihdl.h:325
#define CC_ROUNDRECT
Definition: wingdi.h:769
#define ASPECTY
Definition: wingdi.h:728
#define WINAPI
Definition: msvc.h:6
COLORREF crBrushClr
Definition: ntgdihdl.h:319
#define HANDLE_EMETAFDC(_RetType, _Func, dwError, hdc,...)
Definition: gdi32p.h:644
#define DC_PLAYMETAFILE
Definition: ntgdihdl.h:156
HFONT WINAPI GdiSelectFont(_In_ HDC hdc, _In_ HFONT hfont)
Definition: dc.c:1488
unsigned long DWORD
Definition: ntddk_ex.h:95
#define CLIPCAPS
Definition: wingdi.h:731
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
HBRUSH WINAPI GdiSelectBrush(_In_ HDC hdc, _In_ HBRUSH hbr)
Definition: dc.c:1428
#define SetLastError(x)
Definition: compat.h:611
#define OBJ_PAL
Definition: objidl.idl:1413
#define GDI_OBJECT_TYPE_METADC
Definition: gdi.h:57
#define OBJ_FONT
Definition: objidl.idl:1414
BOOL METADC_SelectPalette(HDC hdc, HPALETTE palette) DECLSPEC_HIDDEN
Definition: metadc.c:1220
GLbitfield flags
Definition: glext.h:7161
#define LC_WIDESTYLED
Definition: wingdi.h:777
#define GM_COMPATIBLE
Definition: wingdi.h:864
FARPROC GOBJENUMPROC
Definition: wingdi.h:2905
Definition: ntgdihdl.h:284
#define SIZEPALETTE
Definition: wingdi.h:732
INT iType
Definition: ntgdihdl.h:288
COLORREF WINAPI GetBkColor(_In_ HDC hdc)
Definition: dc.c:978
#define DIRTY_FILL
Definition: ntgdihdl.h:145
#define GDI_OBJECT_TYPE_DC
Definition: gdi.h:46
static const WCHAR L[]
Definition: oid.c:1250
ULONG ulLogPixelsY
Definition: ntgdityp.h:316
HDC hdc
Definition: main.c:9
#define SLOW_WIDTHS
Definition: ntgdihdl.h:150
Definition: arc.h:85
#define DC_MODE_DIRTY
Definition: ntgdihdl.h:166
#define CC_ELLIPSES
Definition: wingdi.h:764
#define GDI_OBJECT_TYPE_BITMAP
Definition: gdi.h:48
#define META_SETRELABS
Definition: wingdi.h:214
ULONG ulPhysicalOffsetX
Definition: ntgdityp.h:321
BOOL APIENTRY NtGdiGetDCPoint(HDC hDC, UINT iPoint, PPOINTL Point)
Definition: coord.c:1424
HGDIOBJ WINAPI GetCurrentObject(_In_ HDC hdc, _In_ UINT uObjectType)
Definition: dc.c:428
uint32_t DWORD_PTR
Definition: typedefs.h:65
_Must_inspect_result_ _In_ WDFDEVICE Device
Definition: wdfchildlist.h:474
#define OBJ_EXTPEN
Definition: objidl.idl:1419
ULONG ulPenClr
Definition: ntgdihdl.h:322
BYTE jBkMode
Definition: ntgdihdl.h:326
unsigned char BYTE
Definition: xxhash.c:193
INT WINAPI SetRelAbs(HDC hdc, INT Mode)
Definition: dc.c:733
__kernel_entry W32KAPI HDC APIENTRY NtGdiCreateCompatibleDC(_In_opt_ HDC hdc)
#define HORZSIZE
Definition: wingdi.h:714
#define RGN_COPY
Definition: wingdi.h:357
#define LDC_SAPCALLBACK
Definition: ntgdihdl.h:172
#define PHYSICALOFFSETX
Definition: wingdi.h:737
static HDC hDC
Definition: 3dtext.c:33
HDC WINAPI CreateICW(LPCWSTR lpszDriver, LPCWSTR lpszDevice, LPCWSTR lpszOutput, CONST DEVMODEW *lpdvmInit)
Definition: dc.c:212
struct tagLOGPEN LOGPEN
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
#define PHYSICALWIDTH
Definition: wingdi.h:735
#define PC_RECTANGLE
Definition: wingdi.h:797
#define VERTSIZE
Definition: wingdi.h:715
PVOID GdiGetHandleUserData(_In_ HGDIOBJ hobj)
Definition: gditools.c:68
FORCEINLINE struct _TEB * NtCurrentTeb(VOID)
Definition: psfuncs.h:420
__kernel_entry W32KAPI BOOL APIENTRY NtGdiDeleteObjectApp(_In_ HANDLE hobj)
int WINAPI SetPolyFillMode(_In_ HDC hdc, _In_ int iPolyFillMode)
Definition: dc.c:1167
HDC FASTCALL IntCreateDICW(LPCWSTR lpwszDriver, LPCWSTR lpwszDevice, LPCWSTR lpwszOutput, PDEVMODEW lpInitData, ULONG iType)
Definition: dc.c:8
LONG lStretchBltMode
Definition: ntgdihdl.h:333
#define OBJ_BRUSH
Definition: objidl.idl:1410
#define NUMPENS
Definition: wingdi.h:723
unsigned short USHORT
Definition: pedump.c:61
#define LINECAPS
Definition: wingdi.h:770
int WINAPI SetROP2(_In_ HDC hdc, _In_ int rop2)
Definition: dc.c:1107
ULONG ulBrushClr
Definition: ntgdihdl.h:320
COLORREF WINAPI GetDCBrushColor(_In_ HDC hdc)
Definition: dc.c:863
NTSYSAPI NTSTATUS NTAPI RtlAnsiStringToUnicodeString(PUNICODE_STRING DestinationString, PANSI_STRING SourceString, BOOLEAN AllocateDestinationString)
ULONG ulTextCaps
Definition: ntgdityp.h:323
__kernel_entry W32KAPI DWORD APIENTRY NtGdiDdDDICreateDCFromMemory(_Inout_ D3DKMT_CREATEDCFROMMEMORY *desc)
#define HANDLE_METADC1P(_RetType, _Func, dwError, hdc,...)
Definition: gdi32p.h:666
HDC WINAPI CreateDCA(LPCSTR lpszDriver, LPCSTR lpszDevice, LPCSTR lpszOutput, CONST DEVMODEA *lpdvmInit)
Definition: dc.c:122
DWORD WINAPI D3DKMTCreateDCFromMemory(D3DKMT_CREATEDCFROMMEMORY *desc)
Definition: dc.c:1586
unsigned int UINT
Definition: ndis.h:50
#define NULL
Definition: types.h:112
__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
ULONG ulPhysicalWidth
Definition: ntgdityp.h:319
#define VERTRES
Definition: wingdi.h:717
#define DC_BRUSH_DIRTY
Definition: ntgdihdl.h:157
HGDIOBJ WINAPI SelectObject(_In_ HDC hdc, _In_ HGDIOBJ hobj)
Definition: dc.c:1539
DEVCAPS DevCaps
Definition: ntgdihdl.h:302
_In_ UINT _In_ DWORD dwIn
Definition: ntgdi.h:248
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
#define PC_POLYGON
Definition: wingdi.h:794
#define DPRINT1
Definition: precomp.h:8
LONG lBkMode
Definition: ntgdihdl.h:331
#define PC_SCANLINE
Definition: wingdi.h:799
static DWORD *static HFONT(WINAPI *pCreateFontIndirectExA)(const ENUMLOGFONTEXDVA *)
#define LDC_DEVCAPS
Definition: ntgdihdl.h:188
BOOL WINAPI GdiReleaseDC(HDC hdc)
Definition: dc.c:379
ULONG ulAspectX
Definition: ntgdityp.h:312
COLORREF WINAPI GetDCPenColor(_In_ HDC hdc)
Definition: dc.c:884
DWORD APIENTRY NtGdiGetBoundsRect(IN HDC hdc, OUT LPRECT prc, IN DWORD flags)
Definition: dcutil.c:708
int Display
Definition: x11stubs.h:25
unsigned int ULONG
Definition: retypes.h:1
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define DIRTY_LINE
Definition: ntgdihdl.h:146
#define ULONG_PTR
Definition: config.h:101
ULONG ulColorMgmtCaps
Definition: ntgdityp.h:333
#define LOGPIXELSY
Definition: wingdi.h:719
ULONG ulNumColors
Definition: ntgdityp.h:310
#define CC_WIDESTYLED
Definition: wingdi.h:767
static HBITMAP
Definition: button.c:44
HLOCAL NTAPI LocalAlloc(UINT uFlags, SIZE_T dwBytes)
Definition: heapmem.c:1373
COLORREF WINAPI SetDCPenColor(_In_ HDC hdc, _In_ COLORREF crColor)
Definition: dc.c:941
BOOL WINAPI RestoreDC(IN HDC hdc, IN INT iLevel)
Definition: dc.c:315
__kernel_entry W32KAPI INT APIENTRY NtGdiGetDeviceCaps(_In_ HDC hdc, _In_ INT i)
UINT WINAPI GetBoundsRect(HDC hdc, LPRECT lprcBounds, UINT flags)
Definition: dc.c:821
COLORREF WINAPI SetBkColor(_In_ HDC hdc, _In_ COLORREF crColor)
Definition: dc.c:999
FORCEINLINE PVOID GdiAllocBatchCommand(HDC hdc, USHORT Cmd)
Definition: gdi32p.h:381
BOOL FASTCALL LoadTheSpoolerDrv(VOID)
Definition: printdrv.c:188
#define DPRINT
Definition: sndvol32.h:71
WCHAR * LPWSTR
Definition: xmlstorage.h:184
HDC WINAPI CreateCompatibleDC(_In_ HDC hdc)
Definition: dc.c:97
ULONG ulSizePalette
Definition: ntgdityp.h:317
#define CC_CIRCLES
Definition: wingdi.h:761
ULONG ulLogPixelsX
Definition: ntgdityp.h:315
_Out_ LPRECT prc
Definition: ntgdi.h:1658
struct tagLOGBRUSH LOGBRUSH
#define LC_INTERIORS
Definition: wingdi.h:778
#define CURVECAPS
Definition: wingdi.h:759
#define NUMFONTS
Definition: wingdi.h:724
#define GDI_OBJECT_TYPE_FONT
Definition: gdi.h:50
LPARAM lParam
Definition: combotst.c:139
#define OBJ_BITMAP
Definition: objidl.idl:1415
#define HeapFree(x, y, z)
Definition: compat.h:594
#define CONST
Definition: pedump.c:81
int WINAPI GetGraphicsMode(HDC hdc)
Definition: dc.c:1205
HPEN WINAPI GdiSelectPen(_In_ HDC hdc, _In_ HPEN hpen)
Definition: dc.c:1458
ULONG ulTechnology
Definition: ntgdityp.h:299
#define WHITEONBLACK
Definition: wingdi.h:953
BOOL WINAPI GdiValidateHandle(HGDIOBJ)
Definition: misc.c:712
int WINAPI SetGraphicsMode(_In_ HDC hdc, _In_ int iMode)
Definition: dc.c:1226
HDC WINAPI GdiConvertAndCheckDC(HDC hdc)
Definition: dc.c:403
#define PLANES
Definition: wingdi.h:721
HDC WINAPI CreateDCW(LPCWSTR lpwszDriver, LPCWSTR lpwszDevice, LPCWSTR lpwszOutput, CONST DEVMODEW *lpInitData)
Definition: dc.c:193
BOOL WINAPI METADC_RosGlueDeleteDC(_In_ HDC hdc)
Definition: rosglue.c:392
#define LDC_EMFLDC
Definition: gdi_private.h:105
#define GM_ADVANCED
Definition: wingdi.h:865
INT iGraphicsMode
Definition: ntgdihdl.h:324