ReactOS 0.4.16-dev-1214-gd663eb4
display.c File Reference
#include <win32k.h>
Include dependency graph for display.c:

Go to the source code of this file.

Macros

#define READ(field, str, flag)
 

Functions

 DBG_DEFAULT_CHANNEL (UserDisplay)
 
VOID RegWriteDisplaySettings (HKEY hkey, PDEVMODEW pdm)
 
VOID RegReadDisplaySettings (HKEY hkey, PDEVMODEW pdm)
 
PGRAPHICS_DEVICE NTAPI InitDisplayDriver (IN PWSTR pwszDeviceName, IN PWSTR pwszRegKey)
 
NTSTATUS NTAPI InitVideo (VOID)
 
VOID UserRefreshDisplay (IN PPDEVOBJ ppdev)
 
NTSTATUS NTAPI UserEnumDisplayDevices (PUNICODE_STRING pustrDevice, DWORD iDevNum, PDISPLAY_DEVICEW pdispdev, DWORD dwFlags)
 
BOOL NTAPI NtUserEnumDisplayDevices (PUNICODE_STRING pustrDevice, DWORD iDevNum, PDISPLAY_DEVICEW pDisplayDevice, DWORD dwFlags)
 
NTSTATUS NTAPI UserEnumCurrentDisplaySettings (PUNICODE_STRING pustrDevice, PDEVMODEW *ppdm)
 
NTSTATUS NTAPI UserEnumDisplaySettings (PUNICODE_STRING pustrDevice, DWORD iModeNum, LPDEVMODEW *ppdm, DWORD dwFlags)
 
NTSTATUS NTAPI UserOpenDisplaySettingsKey (OUT PHKEY phkey, IN PUNICODE_STRING pustrDevice, IN BOOL bGlobal)
 
NTSTATUS NTAPI UserEnumRegistryDisplaySettings (IN PUNICODE_STRING pustrDevice, OUT LPDEVMODEW pdm)
 
NTSTATUS APIENTRY NtUserEnumDisplaySettings (IN PUNICODE_STRING pustrDevice, IN DWORD iModeNum, OUT LPDEVMODEW lpDevMode, IN DWORD dwFlags)
 
VOID UserUpdateFullscreen (DWORD flags)
 
LONG APIENTRY UserChangeDisplaySettings (PUNICODE_STRING pustrDevice, LPDEVMODEW pdm, DWORD flags, LPVOID lParam)
 
VOID UserDisplayNotifyShutdown (PPROCESSINFO ppiCurrent)
 
LONG APIENTRY NtUserChangeDisplaySettings (PUNICODE_STRING pustrDevice, LPDEVMODEW lpDevMode, DWORD dwflags, LPVOID lParam)
 

Variables

BOOL gbBaseVideo = FALSE
 
static PPROCESSINFO gpFullscreen = NULL
 
static const PWCHAR KEY_VIDEO = L"\\Registry\\Machine\\HARDWARE\\DEVICEMAP\\VIDEO"
 

Macro Definition Documentation

◆ READ

#define READ (   field,
  str,
  flag 
)
Value:
if (RegReadDWORD(hkey, L##str, &dwValue)) \
{ \
pdm->field = dwValue; \
pdm->dmFields |= flag; \
}
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 flag
Definition: glfuncs.h:52
#define L(x)
Definition: ntvdm.h:50
const WCHAR * str
BOOL NTAPI RegReadDWORD(HKEY hkey, PCWSTR pwszValue, PDWORD pdwData)
Definition: registry.c:149

Function Documentation

◆ DBG_DEFAULT_CHANNEL()

DBG_DEFAULT_CHANNEL ( UserDisplay  )

◆ InitDisplayDriver()

PGRAPHICS_DEVICE NTAPI InitDisplayDriver ( IN PWSTR  pwszDeviceName,
IN PWSTR  pwszRegKey 
)

Definition at line 66 of file display.c.

69{
70 PGRAPHICS_DEVICE pGraphicsDevice;
71 UNICODE_STRING ustrDeviceName, ustrDisplayDrivers, ustrDescription;
73 WCHAR awcBuffer[128];
74 ULONG cbSize;
75 HKEY hkey;
76 DWORD dwVga;
77
78 TRACE("InitDisplayDriver(%S, %S);\n",
79 pwszDeviceName, pwszRegKey);
80
81 /* Open the driver's registry key */
82 Status = RegOpenKey(pwszRegKey, &hkey);
83 if (!NT_SUCCESS(Status))
84 {
85 ERR("Failed to open registry key: %ls\n", pwszRegKey);
86 return NULL;
87 }
88
89 /* Query the diplay drivers */
90 cbSize = sizeof(awcBuffer) - 10;
91 Status = RegQueryValue(hkey,
92 L"InstalledDisplayDrivers",
94 awcBuffer,
95 &cbSize);
96 if (!NT_SUCCESS(Status))
97 {
98 ERR("Didn't find 'InstalledDisplayDrivers', status = 0x%lx\n", Status);
99 ZwClose(hkey);
100 return NULL;
101 }
102
103 /* Initialize the UNICODE_STRING */
104 ustrDisplayDrivers.Buffer = awcBuffer;
105 ustrDisplayDrivers.MaximumLength = (USHORT)cbSize;
106 ustrDisplayDrivers.Length = (USHORT)cbSize;
107
108 /* Set Buffer for description and size of remaining buffer */
109 ustrDescription.Buffer = awcBuffer + (cbSize / sizeof(WCHAR));
110 cbSize = sizeof(awcBuffer) - cbSize;
111
112 /* Query the device string */
113 Status = RegQueryValue(hkey,
114 L"Device Description",
115 REG_SZ,
116 ustrDescription.Buffer,
117 &cbSize);
118 if (NT_SUCCESS(Status))
119 {
120 ustrDescription.MaximumLength = (USHORT)cbSize;
121 ustrDescription.Length = (USHORT)cbSize;
122 }
123 else
124 {
125 RtlInitUnicodeString(&ustrDescription, L"<unknown>");
126 }
127
128 /* Query if this is a VGA compatible driver */
129 cbSize = sizeof(DWORD);
130 Status = RegQueryValue(hkey, L"VgaCompatible", REG_DWORD, &dwVga, &cbSize);
131 if (!NT_SUCCESS(Status)) dwVga = 0;
132
133 /* Close the registry key */
134 ZwClose(hkey);
135
136 /* Register the device with GDI */
137 RtlInitUnicodeString(&ustrDeviceName, pwszDeviceName);
138 pGraphicsDevice = EngpRegisterGraphicsDevice(&ustrDeviceName,
139 &ustrDisplayDrivers,
140 &ustrDescription);
141 if (pGraphicsDevice && dwVga)
142 {
143 pGraphicsDevice->StateFlags |= DISPLAY_DEVICE_VGA_COMPATIBLE;
144 }
145
146 return pGraphicsDevice;
147}
LONG NTSTATUS
Definition: precomp.h:26
#define ERR(fmt,...)
Definition: precomp.h:57
#define NULL
Definition: types.h:112
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:33
unsigned long DWORD
Definition: ntddk_ex.h:95
Status
Definition: gdiplustypes.h:25
#define REG_SZ
Definition: layer.c:22
NTSYSAPI NTSTATUS NTAPI ZwClose(_In_ HANDLE Handle)
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define REG_MULTI_SZ
Definition: nt_native.h:1501
#define DWORD
Definition: nt_native.h:44
unsigned short USHORT
Definition: pedump.c:61
#define REG_DWORD
Definition: sdbapi.c:596
#define TRACE(s)
Definition: solgame.cpp:4
DWORD StateFlags
Definition: pdevobj.h:66
USHORT MaximumLength
Definition: env_spec_w32.h:370
uint32_t ULONG
Definition: typedefs.h:59
PGRAPHICS_DEVICE NTAPI EngpRegisterGraphicsDevice(_In_ PUNICODE_STRING pustrDeviceName, _In_ PUNICODE_STRING pustrDiplayDrivers, _In_ PUNICODE_STRING pustrDescription)
Definition: device.c:647
_In_ LPWSTR _In_ ULONG _In_ ULONG _In_ ULONG _Out_ DEVINFO _In_ HDEV _In_ LPWSTR pwszDeviceName
Definition: winddi.h:3556
#define DISPLAY_DEVICE_VGA_COMPATIBLE
Definition: wingdi.h:1400
#define RegOpenKey
Definition: winreg.h:519
#define RegQueryValue
Definition: winreg.h:523
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by EngpUpdateGraphicsDeviceList().

◆ InitVideo()

NTSTATUS NTAPI InitVideo ( VOID  )

Definition at line 151 of file display.c.

152{
154 HKEY hkey;
155
156 TRACE("----------------------------- InitVideo() -------------------------------\n");
157
158 /* Check if VGA mode is requested, by finding the special volatile key created by VIDEOPRT */
159 Status = RegOpenKey(L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\GraphicsDrivers\\BaseVideo", &hkey);
160 if (NT_SUCCESS(Status))
161 ZwClose(hkey);
163 if (gbBaseVideo)
164 ERR("VGA mode requested.\n");
165
166 /* Initialize all display devices */
168 if (!NT_SUCCESS(Status))
169 return Status;
170
172
173 return STATUS_SUCCESS;
174}
#define STATUS_SUCCESS
Definition: shellext.h:65
BOOL InitSysParams()
NTSTATUS EngpUpdateGraphicsDeviceList(VOID)
Definition: device.c:182
BOOL gbBaseVideo
Definition: display.c:12

Referenced by UserInitialize().

◆ NtUserChangeDisplaySettings()

LONG APIENTRY NtUserChangeDisplaySettings ( PUNICODE_STRING  pustrDevice,
LPDEVMODEW  lpDevMode,
DWORD  dwflags,
LPVOID  lParam 
)

Definition at line 950 of file display.c.

955{
956 WCHAR awcDevice[CCHDEVICENAME];
957 UNICODE_STRING ustrDevice;
958 DEVMODEW dmLocal;
959 LONG lRet;
960
961 /* Check arguments */
962 if ((dwflags != CDS_VIDEOPARAMETERS) && (lParam != NULL))
963 {
966 }
967
968 /* Check flags */
970 {
972 }
973
974 if ((dwflags & CDS_RESET) && (dwflags & CDS_NORESET))
975 {
977 }
978
979 /* Copy the device name */
980 if (pustrDevice)
981 {
982 /* Initialize destination string */
983 RtlInitEmptyUnicodeString(&ustrDevice, awcDevice, sizeof(awcDevice));
984
986 {
987 /* Probe the UNICODE_STRING and the buffer */
988 ProbeForRead(pustrDevice, sizeof(UNICODE_STRING), 1);
989 ProbeForRead(pustrDevice->Buffer, pustrDevice->Length, 1);
990
991 /* Copy the string */
992 RtlCopyUnicodeString(&ustrDevice, pustrDevice);
993 }
995 {
996 /* Set and return error */
999 }
1000 _SEH2_END
1001
1002 pustrDevice = &ustrDevice;
1003 }
1004
1005 /* Copy devmode */
1006 if (lpDevMode)
1007 {
1008 _SEH2_TRY
1009 {
1010 /* Probe the size field of the structure */
1011 ProbeForRead(lpDevMode, sizeof(dmLocal.dmSize), 1);
1012
1013 /* Calculate usable size */
1014 dmLocal.dmSize = min(sizeof(dmLocal), lpDevMode->dmSize);
1015
1016 /* Probe and copy the full DEVMODE */
1017 ProbeForRead(lpDevMode, dmLocal.dmSize, 1);
1018 RtlCopyMemory(&dmLocal, lpDevMode, dmLocal.dmSize);
1019 }
1021 {
1022 /* Set and return error */
1025 }
1026 _SEH2_END
1027
1028 /* Check for extra parameters */
1029 if (dmLocal.dmDriverExtra > 0)
1030 {
1031 /* FIXME: TODO */
1032 ERR("lpDevMode->dmDriverExtra is IGNORED!\n");
1033 dmLocal.dmDriverExtra = 0;
1034 }
1035
1036 /* Use the local structure */
1037 lpDevMode = &dmLocal;
1038 }
1039
1040 // FIXME: Copy videoparameters
1041
1042 /* Acquire global USER lock */
1044
1045 /* Call internal function */
1046 lRet = UserChangeDisplaySettings(pustrDevice, lpDevMode, dwflags, NULL);
1047
1048 /* Release lock */
1049 UserLeave();
1050
1051 return lRet;
1052}
LPARAM lParam
Definition: combotst.c:139
#define CCHDEVICENAME
Definition: ddrawi.h:63
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
VOID NTAPI ProbeForRead(IN CONST VOID *Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:102
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:90
static _In_ DWORD dwflags
Definition: dispmode.c:64
static _In_ DWORD _Inout_ PDEVMODEA lpDevMode
Definition: dispmode.c:77
#define min(a, b)
Definition: monoChain.cc:55
NTSYSAPI VOID NTAPI RtlCopyUnicodeString(PUNICODE_STRING DestinationString, PUNICODE_STRING SourceString)
VOID FASTCALL UserLeave(VOID)
Definition: ntuser.c:258
VOID FASTCALL UserEnterExclusive(VOID)
Definition: ntuser.c:249
long LONG
Definition: pedump.c:60
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:181
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:82
#define _SEH2_END
Definition: pseh2_64.h:171
#define _SEH2_TRY
Definition: pseh2_64.h:71
#define _SEH2_YIELD(__stmt)
Definition: pseh2_64.h:184
WORD dmSize
Definition: wingdi.h:1568
WORD dmDriverExtra
Definition: wingdi.h:1621
WORD dmSize
Definition: wingdi.h:1620
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
VOID FASTCALL SetLastNtError(_In_ NTSTATUS Status)
Definition: error.c:31
LONG APIENTRY UserChangeDisplaySettings(PUNICODE_STRING pustrDevice, LPDEVMODEW pdm, DWORD flags, LPVOID lParam)
Definition: display.c:720
ENGAPI VOID APIENTRY EngSetLastError(_In_ ULONG iError)
Definition: error.c:22
#define CDS_VIDEOPARAMETERS
Definition: winuser.h:186
#define DISP_CHANGE_BADPARAM
Definition: winuser.h:193
#define CDS_UPDATEREGISTRY
Definition: winuser.h:181
#define DISP_CHANGE_BADFLAGS
Definition: winuser.h:192
#define CDS_NORESET
Definition: winuser.h:189
#define CDS_RESET
Definition: winuser.h:187
#define CDS_GLOBAL
Definition: winuser.h:184

Referenced by ChangeDisplaySettingsExA(), and ChangeDisplaySettingsExW().

◆ NtUserEnumDisplayDevices()

BOOL NTAPI NtUserEnumDisplayDevices ( PUNICODE_STRING  pustrDevice,
DWORD  iDevNum,
PDISPLAY_DEVICEW  pDisplayDevice,
DWORD  dwFlags 
)

Definition at line 374 of file display.c.

379{
380 UNICODE_STRING ustrDevice;
381 WCHAR awcDevice[CCHDEVICENAME];
382 DISPLAY_DEVICEW dispdev;
384
385 TRACE("Enter NtUserEnumDisplayDevices(%wZ, %lu)\n",
386 pustrDevice, iDevNum);
387
388 dispdev.cb = sizeof(dispdev);
389
390 if (pustrDevice)
391 {
392 /* Initialize destination string */
393 RtlInitEmptyUnicodeString(&ustrDevice, awcDevice, sizeof(awcDevice));
394
396 {
397 /* Probe the UNICODE_STRING and the buffer */
398 ProbeForRead(pustrDevice, sizeof(UNICODE_STRING), 1);
399 ProbeForRead(pustrDevice->Buffer, pustrDevice->Length, 1);
400
401 /* Copy the string */
402 RtlCopyUnicodeString(&ustrDevice, pustrDevice);
403 }
405 {
406// _SEH2_YIELD(return _SEH2_GetExceptionCode());
408 }
410
411 if (ustrDevice.Length > 0)
412 pustrDevice = &ustrDevice;
413 else
414 pustrDevice = NULL;
415 }
416
417 /* Acquire global USER lock */
419
420 /* Call the internal function */
421 Status = UserEnumDisplayDevices(pustrDevice, iDevNum, &dispdev, dwFlags);
422
423 /* Release lock */
424 UserLeave();
425
426 /* On success copy data to caller */
427 if (NT_SUCCESS(Status))
428 {
429 /* Enter SEH */
431 {
432 /* First probe the cb field */
433 ProbeForWrite(&pDisplayDevice->cb, sizeof(DWORD), 1);
434
435 /* Check the buffer size */
436 if (pDisplayDevice->cb)
437 {
438 /* Probe the output buffer */
439 pDisplayDevice->cb = min(pDisplayDevice->cb, sizeof(dispdev));
440 ProbeForWrite(pDisplayDevice, pDisplayDevice->cb, 1);
441
442 /* Copy as much as the given buffer allows */
443 RtlCopyMemory(pDisplayDevice, &dispdev, pDisplayDevice->cb);
444 }
445 }
447 {
449 }
451 }
452
453 TRACE("Leave NtUserEnumDisplayDevices, Status = 0x%lx\n", Status);
454 /* Return the result */
455// return Status;
456 return NT_SUCCESS(Status); // FIXME
457}
VOID NTAPI ProbeForWrite(IN PVOID Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:143
VOID FASTCALL UserEnterShared(VOID)
Definition: ntuser.c:242
NTSTATUS NTAPI UserEnumDisplayDevices(PUNICODE_STRING pustrDevice, DWORD iDevNum, PDISPLAY_DEVICEW pdispdev, DWORD dwFlags)
Definition: display.c:217
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1176

Referenced by EnumDisplayDevicesA(), and EnumDisplayDevicesW().

◆ NtUserEnumDisplaySettings()

NTSTATUS APIENTRY NtUserEnumDisplaySettings ( IN PUNICODE_STRING  pustrDevice,
IN DWORD  iModeNum,
OUT LPDEVMODEW  lpDevMode,
IN DWORD  dwFlags 
)

Definition at line 592 of file display.c.

597{
598 UNICODE_STRING ustrDeviceUser;
599 UNICODE_STRING ustrDevice;
600 WCHAR awcDevice[CCHDEVICENAME];
602 ULONG cbSize, cbExtra;
603 DEVMODEW dmReg, *pdm;
604
605 TRACE("Enter NtUserEnumDisplaySettings(%wZ, %lu, %p, 0x%lx)\n",
606 pustrDevice, iModeNum, lpDevMode, dwFlags);
607
609 {
610 ProbeForRead(lpDevMode, sizeof(DEVMODEW), sizeof(UCHAR));
611
612 cbSize = lpDevMode->dmSize;
613 cbExtra = lpDevMode->dmDriverExtra;
614
615 ProbeForWrite(lpDevMode, cbSize + cbExtra, sizeof(UCHAR));
616 }
618 {
620 }
621 _SEH2_END;
622
623 if (cbSize != sizeof(DEVMODEW))
624 {
626 }
627
628 if (pustrDevice)
629 {
630 /* Initialize destination string */
631 RtlInitEmptyUnicodeString(&ustrDevice, awcDevice, sizeof(awcDevice));
632
634 {
635 /* Probe the UNICODE_STRING and the buffer */
636 ustrDeviceUser = ProbeForReadUnicodeString(pustrDevice);
637
638 if (!ustrDeviceUser.Length || !ustrDeviceUser.Buffer)
640
641 ProbeForRead(ustrDeviceUser.Buffer,
642 ustrDeviceUser.Length,
643 sizeof(UCHAR));
644
645 /* Copy the string */
646 RtlCopyUnicodeString(&ustrDevice, &ustrDeviceUser);
647 }
649 {
651 }
652 _SEH2_END;
653
654 pustrDevice = &ustrDevice;
655 }
656
657 /* Acquire global USER lock */
659
661 {
662 /* Get the registry settings */
663 Status = UserEnumRegistryDisplaySettings(pustrDevice, &dmReg);
664 pdm = &dmReg;
665 pdm->dmSize = sizeof(DEVMODEW);
666 }
668 {
669 /* Get the current settings */
670 Status = UserEnumCurrentDisplaySettings(pustrDevice, &pdm);
671 }
672 else
673 {
674 /* Get specified settings */
675 Status = UserEnumDisplaySettings(pustrDevice, iModeNum, &pdm, dwFlags);
676 }
677
678 /* Release lock */
679 UserLeave();
680
681 /* Did we succeed? */
682 if (NT_SUCCESS(Status))
683 {
684 /* Copy some information back */
686 {
687 /* Output what we got */
688 RtlCopyMemory(lpDevMode, pdm, min(cbSize, pdm->dmSize));
689
690 /* Output private/extra driver data */
691 if (cbExtra > 0 && pdm->dmDriverExtra > 0)
692 {
693 RtlCopyMemory((PCHAR)lpDevMode + cbSize,
694 (PCHAR)pdm + pdm->dmSize,
695 min(cbExtra, pdm->dmDriverExtra));
696 }
697 }
699 {
701 }
702 _SEH2_END;
703 }
704
705 return Status;
706}
#define STATUS_NO_MEMORY
Definition: d3dkmdt.h:51
static _In_ DWORD iModeNum
Definition: dispmode.c:77
#define ExRaiseStatus
Definition: ntoskrnl.h:114
#define STATUS_INVALID_PARAMETER_1
Definition: ntstatus.h:475
#define ProbeForReadUnicodeString(Ptr)
Definition: probe.h:77
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
WORD dmDriverExtra
Definition: wingdi.h:1569
char * PCHAR
Definition: typedefs.h:51
NTSTATUS NTAPI UserEnumRegistryDisplaySettings(IN PUNICODE_STRING pustrDevice, OUT LPDEVMODEW pdm)
Definition: display.c:575
NTSTATUS NTAPI UserEnumDisplaySettings(PUNICODE_STRING pustrDevice, DWORD iModeNum, LPDEVMODEW *ppdm, DWORD dwFlags)
Definition: display.c:484
NTSTATUS NTAPI UserEnumCurrentDisplaySettings(PUNICODE_STRING pustrDevice, PDEVMODEW *ppdm)
Definition: display.c:461
struct _devicemodeW DEVMODEW
#define ENUM_REGISTRY_SETTINGS
Definition: winuser.h:180
#define ENUM_CURRENT_SETTINGS
Definition: winuser.h:179
unsigned char UCHAR
Definition: xmlstorage.h:181

Referenced by EnumDisplaySettingsExA(), and EnumDisplaySettingsExW().

◆ RegReadDisplaySettings()

VOID RegReadDisplaySettings ( HKEY  hkey,
PDEVMODEW  pdm 
)

Definition at line 35 of file display.c.

36{
37 DWORD dwValue;
38
39 /* Zero out the structure */
40 RtlZeroMemory(pdm, sizeof(DEVMODEW));
41
42/* Helper macro */
43#define READ(field, str, flag) \
44 if (RegReadDWORD(hkey, L##str, &dwValue)) \
45 { \
46 pdm->field = dwValue; \
47 pdm->dmFields |= flag; \
48 }
49
50 /* Read all present settings */
51 READ(dmBitsPerPel, "DefaultSettings.BitsPerPel", DM_BITSPERPEL);
52 READ(dmPelsWidth, "DefaultSettings.XResolution", DM_PELSWIDTH);
53 READ(dmPelsHeight, "DefaultSettings.YResolution", DM_PELSHEIGHT);
54 READ(dmDisplayFlags, "DefaultSettings.Flags", DM_DISPLAYFLAGS);
55 READ(dmDisplayFrequency, "DefaultSettings.VRefresh", DM_DISPLAYFREQUENCY);
56 READ(dmPanningWidth, "DefaultSettings.XPanning", DM_PANNINGWIDTH);
57 READ(dmPanningHeight, "DefaultSettings.YPanning", DM_PANNINGHEIGHT);
58 READ(dmDisplayOrientation, "DefaultSettings.Orientation", DM_DISPLAYORIENTATION);
59 READ(dmDisplayFixedOutput, "DefaultSettings.FixedOutput", DM_DISPLAYFIXEDOUTPUT);
60 READ(dmPosition.x, "Attach.RelativeX", DM_POSITION);
61 READ(dmPosition.y, "Attach.RelativeY", DM_POSITION);
62}
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
#define READ(field, str, flag)
#define DM_DISPLAYFREQUENCY
Definition: wingdi.h:1272
#define DM_PELSWIDTH
Definition: wingdi.h:1269
#define DM_POSITION
Definition: wingdi.h:1255
#define DM_PANNINGHEIGHT
Definition: wingdi.h:1278
#define DM_BITSPERPEL
Definition: wingdi.h:1268
#define DM_DISPLAYORIENTATION
Definition: wingdi.h:1257
#define DM_PELSHEIGHT
Definition: wingdi.h:1270
#define DM_PANNINGWIDTH
Definition: wingdi.h:1277
#define DM_DISPLAYFLAGS
Definition: wingdi.h:1271

Referenced by UserEnumRegistryDisplaySettings().

◆ RegWriteDisplaySettings()

VOID RegWriteDisplaySettings ( HKEY  hkey,
PDEVMODEW  pdm 
)

Definition at line 18 of file display.c.

19{
20 RegWriteDWORD(hkey, L"DefaultSettings.BitsPerPel", pdm->dmBitsPerPel);
21 RegWriteDWORD(hkey, L"DefaultSettings.XResolution", pdm->dmPelsWidth);
22 RegWriteDWORD(hkey, L"DefaultSettings.YResolution", pdm->dmPelsHeight);
23 RegWriteDWORD(hkey, L"DefaultSettings.Flags", pdm->dmDisplayFlags);
24 RegWriteDWORD(hkey, L"DefaultSettings.VRefresh", pdm->dmDisplayFrequency);
25 RegWriteDWORD(hkey, L"DefaultSettings.XPanning", pdm->dmPanningWidth);
26 RegWriteDWORD(hkey, L"DefaultSettings.YPanning", pdm->dmPanningHeight);
27 RegWriteDWORD(hkey, L"DefaultSettings.Orientation", pdm->dmDisplayOrientation);
28 RegWriteDWORD(hkey, L"DefaultSettings.FixedOutput", pdm->dmDisplayFixedOutput);
29 RegWriteDWORD(hkey, L"Attach.RelativeX", pdm->dmPosition.x);
30 RegWriteDWORD(hkey, L"Attach.RelativeY", pdm->dmPosition.y);
31// RegWriteDWORD(hkey, L"Attach.ToDesktop, pdm->dmBitsPerPel", pdm->);
32}
LONG y
Definition: windef.h:330
LONG x
Definition: windef.h:329
DWORD dmBitsPerPel
Definition: wingdi.h:1647
POINTL dmPosition
Definition: wingdi.h:1635
DWORD dmDisplayFixedOutput
Definition: wingdi.h:1637
DWORD dmDisplayOrientation
Definition: wingdi.h:1636
DWORD dmPelsWidth
Definition: wingdi.h:1648
DWORD dmDisplayFlags
Definition: wingdi.h:1651
DWORD dmPelsHeight
Definition: wingdi.h:1649
DWORD dmDisplayFrequency
Definition: wingdi.h:1654
VOID NTAPI RegWriteDWORD(HKEY hkey, PCWSTR pwszValue, DWORD dwData)
Definition: registry.c:139

Referenced by UserChangeDisplaySettings().

◆ UserChangeDisplaySettings()

LONG APIENTRY UserChangeDisplaySettings ( PUNICODE_STRING  pustrDevice,
LPDEVMODEW  pdm,
DWORD  flags,
LPVOID  lParam 
)

Definition at line 720 of file display.c.

725{
726 DEVMODEW dm;
728 HKEY hkey;
730 PPDEVOBJ ppdev;
731 WORD OrigBC;
732 //PDESKTOP pdesk;
733 PDEVMODEW newDevMode = NULL;
734
735 /* If no DEVMODE is given, use registry settings */
736 if (!pdm)
737 {
738 /* Get the registry settings */
739 Status = UserEnumRegistryDisplaySettings(pustrDevice, &dm);
740 if (!NT_SUCCESS(Status))
741 {
742 ERR("Could not load registry settings\n");
744 }
745 }
746 else if (pdm->dmSize < FIELD_OFFSET(DEVMODEW, dmFields))
747 {
748 return DISP_CHANGE_BADMODE; /* This is what WinXP SP3 returns */
749 }
750 else
751 {
752 dm = *pdm;
753 }
754
755 /* Save original bit count */
756 OrigBC = gpsi->BitCount;
757
758 /* Check params */
760 {
761 ERR("Devmode doesn't specify the resolution.\n");
762 return DISP_CHANGE_BADMODE;
763 }
764
765 /* Get the PDEV */
766 ppdev = EngpGetPDEV(pustrDevice);
767 if (!ppdev)
768 {
769 ERR("Failed to get PDEV\n");
771 }
772
773 /* Fixup values */
774 if (dm.dmBitsPerPel == 0 || !(dm.dmFields & DM_BITSPERPEL))
775 {
776 dm.dmBitsPerPel = ppdev->pdmwDev->dmBitsPerPel;
778 }
779
780 if ((dm.dmFields & DM_DISPLAYFREQUENCY) && (dm.dmDisplayFrequency == 0))
782
783 /* Look for the requested DEVMODE */
784 if (!LDEVOBJ_bProbeAndCaptureDevmode(ppdev->pGraphicsDevice, &dm, &newDevMode, FALSE))
785 {
786 ERR("Could not find a matching DEVMODE\n");
787 lResult = DISP_CHANGE_BADMODE;
788 goto leave;
789 }
790 else if (flags & CDS_TEST)
791 {
792 /* It's possible, go ahead! */
793 lResult = DISP_CHANGE_SUCCESSFUL;
794 goto leave;
795 }
796
797 /* Shall we update the registry? */
799 {
800 /* Open the local or global settings key */
801 Status = UserOpenDisplaySettingsKey(&hkey, pustrDevice, flags & CDS_GLOBAL);
802 if (NT_SUCCESS(Status))
803 {
804 /* Store the settings */
805 RegWriteDisplaySettings(hkey, newDevMode);
806
807 /* Close the registry key */
808 ZwClose(hkey);
809 }
810 else
811 {
812 ERR("Could not open registry key\n");
813 lResult = DISP_CHANGE_NOTUPDATED;
814 }
815 }
816
817 /* Check if DEVMODE matches the current mode */
818 if (newDevMode->dmSize == ppdev->pdmwDev->dmSize &&
819 RtlCompareMemory(newDevMode, ppdev->pdmwDev, newDevMode->dmSize) == newDevMode->dmSize &&
820 !(flags & CDS_RESET))
821 {
822 ERR("DEVMODE matches, nothing to do\n");
823 goto leave;
824 }
825
826 /* Shall we apply the settings? */
827 if (!(flags & CDS_NORESET))
828 {
829 ULONG_PTR ulResult;
830 PVOID pvOldCursor;
831 TEXTMETRICW tmw;
832
833 /* Remove mouse pointer */
834 pvOldCursor = UserSetCursor(NULL, TRUE);
835
836 /* Do the mode switch */
837 ulResult = PDEVOBJ_bSwitchMode(ppdev, newDevMode);
838
839 /* Restore mouse pointer, no hooks called */
840 pvOldCursor = UserSetCursor(pvOldCursor, TRUE);
841 ASSERT(pvOldCursor == NULL);
842
843 /* Check for success or failure */
844 if (!ulResult)
845 {
846 /* Setting mode failed */
847 ERR("Failed to set mode\n");
848
849 /* Set the correct return value */
850 if ((flags & CDS_UPDATEREGISTRY) && (lResult != DISP_CHANGE_NOTUPDATED))
851 lResult = DISP_CHANGE_RESTART;
852 else
853 lResult = DISP_CHANGE_FAILED;
854 }
855 else
856 {
857 /* Setting mode succeeded */
858 lResult = DISP_CHANGE_SUCCESSFUL;
860 ppdev->pdmwDev = newDevMode;
861
863
864 /* Update the system metrics */
865 InitMetrics();
866
867 /* Set new size of the monitor */
868 UserUpdateMonitorSize((HDEV)ppdev);
869
870 /* Update the SERVERINFO */
871 gpsi->dmLogPixels = ppdev->gdiinfo.ulLogPixelsY;
872 gpsi->Planes = ppdev->gdiinfo.cPlanes;
873 gpsi->BitsPixel = ppdev->gdiinfo.cBitsPixel;
874 gpsi->BitCount = gpsi->Planes * gpsi->BitsPixel;
875 gpsi->aiSysMet[SM_CXSCREEN] = ppdev->gdiinfo.ulHorzRes;
876 gpsi->aiSysMet[SM_CYSCREEN] = ppdev->gdiinfo.ulVertRes;
877 if (ppdev->gdiinfo.flRaster & RC_PALETTE)
878 {
879 gpsi->PUSIFlags |= PUSIF_PALETTEDISPLAY;
880 }
881 else
882 {
883 gpsi->PUSIFlags &= ~PUSIF_PALETTEDISPLAY;
884 }
885 // Font is realized and this dc was previously set to internal DC_ATTR.
886 gpsi->cxSysFontChar = IntGetCharDimensions(hSystemBM, &tmw, (DWORD*)&gpsi->cySysFontChar);
887 gpsi->tmSysFont = tmw;
888 }
889
890 /*
891 * Refresh the display on success and even on failure,
892 * since the display may have been messed up.
893 */
894
895 /* Remove all cursor clipping */
897
898 //pdesk = IntGetActiveDesktop();
899 //IntHideDesktop(pdesk);
900
901 /* Send WM_DISPLAYCHANGE to all toplevel windows */
903 WM_DISPLAYCHANGE,
904 gpsi->BitCount,
905 MAKELONG(gpsi->aiSysMet[SM_CXSCREEN], gpsi->aiSysMet[SM_CYSCREEN]),
907 100,
908 &ulResult );
909
910 ERR("BitCount New %d Orig %d ChkNew %d\n",gpsi->BitCount,OrigBC,ppdev->gdiinfo.cBitsPixel);
911
912 /* Not full screen and different bit count, send messages */
913 if (!(flags & CDS_FULLSCREEN) &&
914 gpsi->BitCount != OrigBC)
915 {
916 ERR("Detect settings changed.\n");
919 }
920
921 //co_IntShowDesktop(pdesk, ppdev->gdiinfo.ulHorzRes, ppdev->gdiinfo.ulVertRes);
922
924 }
925
926leave:
927 if (newDevMode && newDevMode != ppdev->pdmwDev)
929
930 /* Release the PDEV */
931 PDEVOBJ_vRelease(ppdev);
932
933 return lResult;
934}
#define leave
Definition: btrfs_drv.h:138
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define RtlCompareMemory(s1, s2, l)
Definition: env_spec_w32.h:465
unsigned short WORD
Definition: ntddk_ex.h:93
GLbitfield flags
Definition: glext.h:7161
PSERVERINFO gpsi
Definition: imm.c:18
#define PUSIF_PALETTEDISPLAY
Definition: ntuser.h:993
HDC hSystemBM
Definition: stockobj.c:52
BOOL LDEVOBJ_bProbeAndCaptureDevmode(_Inout_ PGRAPHICS_DEVICE pGraphicsDevice, _In_ PDEVMODEW RequestedMode, _Out_ PDEVMODEW *pSelectedMode, _In_ BOOL bSearchClosestMode)
Definition: ldevobj.c:738
#define ASSERT(a)
Definition: mode.c:44
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1109
PCURICON_OBJECT FASTCALL UserSetCursor(PCURICON_OBJECT NewCursor, BOOL ForceChange)
Definition: msgqueue.c:93
PPDEVOBJ NTAPI EngpGetPDEV(_In_opt_ PUNICODE_STRING pustrDeviceName)
Definition: pdevobj.c:815
BOOL NTAPI PDEVOBJ_bSwitchMode(PPDEVOBJ ppdev, PDEVMODEW pdm)
Definition: pdevobj.c:712
VOID NTAPI PDEVOBJ_vRelease(_Inout_ PPDEVOBJ ppdev)
Definition: pdevobj.c:105
ULONG ulLogPixelsY
Definition: winddi.h:889
ULONG cBitsPixel
Definition: winddi.h:884
ULONG ulVertRes
Definition: winddi.h:883
ULONG ulHorzRes
Definition: winddi.h:882
ULONG flRaster
Definition: winddi.h:887
ULONG cPlanes
Definition: winddi.h:885
GDIINFO gdiinfo
Definition: pdevobj.h:123
PDEVMODEW pdmwDev
Definition: pdevobj.h:129
PGRAPHICS_DEVICE pGraphicsDevice
Definition: pdevobj.h:127
DWORD dmFields
Definition: wingdi.h:1622
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define MAKELONG(a, b)
Definition: typedefs.h:249
DWORD FASTCALL IntGetCharDimensions(_In_ HDC hdc, _Out_opt_ PTEXTMETRICW ptm, _Out_opt_ PDWORD height)
Definition: font.c:335
BOOL APIENTRY UserClipCursor(RECTL *prcl)
Definition: cursoricon.c:700
VOID APIENTRY UserRedrawDesktop(VOID)
Definition: desktop.c:1616
VOID UserUpdateFullscreen(DWORD flags)
Definition: display.c:709
VOID RegWriteDisplaySettings(HKEY hkey, PDEVMODEW pdm)
Definition: display.c:18
NTSTATUS NTAPI UserOpenDisplaySettingsKey(OUT PHKEY phkey, IN PUNICODE_STRING pustrDevice, IN BOOL bGlobal)
Definition: display.c:544
BOOL FASTCALL UserSendNotifyMessage(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: message.c:2090
LRESULT FASTCALL co_IntSendMessageTimeout(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam, UINT uFlags, UINT uTimeout, ULONG_PTR *uResult)
Definition: message.c:1707
BOOL NTAPI InitMetrics(VOID)
Definition: metric.c:45
NTSTATUS NTAPI UserUpdateMonitorSize(IN HDEV hDev)
Definition: monitor.c:225
#define GDITAG_DEVMODE
Definition: tags.h:73
#define RC_PALETTE
Definition: wingdi.h:790
#define CDS_TEST
Definition: winuser.h:182
#define DISP_CHANGE_NOTUPDATED
Definition: winuser.h:196
#define SM_CYSCREEN
Definition: winuser.h:971
#define DISP_CHANGE_BADMODE
Definition: winuser.h:195
#define HWND_BROADCAST
Definition: winuser.h:1215
#define DISP_CHANGE_SUCCESSFUL
Definition: winuser.h:190
#define CDS_FULLSCREEN
Definition: winuser.h:183
#define WM_SYSCOLORCHANGE
Definition: winuser.h:1645
#define DISP_CHANGE_FAILED
Definition: winuser.h:194
#define WM_SETTINGCHANGE
Definition: winuser.h:1648
#define SM_CXSCREEN
Definition: winuser.h:970
#define DISP_CHANGE_RESTART
Definition: winuser.h:191
#define SMTO_NORMAL
Definition: winuser.h:1236

Referenced by NtUserChangeDisplaySettings(), and UserDisplayNotifyShutdown().

◆ UserDisplayNotifyShutdown()

VOID UserDisplayNotifyShutdown ( PPROCESSINFO  ppiCurrent)

Definition at line 937 of file display.c.

939{
940 if (ppiCurrent == gpFullscreen)
941 {
943 if (gpFullscreen)
944 ERR("Failed to restore display mode!\n");
945 }
946}
static PPROCESSINFO gpFullscreen
Definition: display.c:13

Referenced by ExitThreadCallback().

◆ UserEnumCurrentDisplaySettings()

NTSTATUS NTAPI UserEnumCurrentDisplaySettings ( PUNICODE_STRING  pustrDevice,
PDEVMODEW ppdm 
)

Definition at line 461 of file display.c.

464{
465 PPDEVOBJ ppdev;
466
467 /* Get the PDEV for the device */
468 ppdev = EngpGetPDEV(pustrDevice);
469 if (!ppdev)
470 {
471 /* No device found */
472 ERR("No PDEV found!\n");
474 }
475
476 *ppdm = ppdev->pdmwDev;
477 PDEVOBJ_vRelease(ppdev);
478
479 return STATUS_SUCCESS;
480}

Referenced by NtUserEnumDisplaySettings().

◆ UserEnumDisplayDevices()

NTSTATUS NTAPI UserEnumDisplayDevices ( PUNICODE_STRING  pustrDevice,
DWORD  iDevNum,
PDISPLAY_DEVICEW  pdispdev,
DWORD  dwFlags 
)

Definition at line 217 of file display.c.

222{
223 PGRAPHICS_DEVICE pGraphicsDevice;
224 PDEVICE_OBJECT pdo;
225 PWCHAR pHardwareId;
226 ULONG cbSize, dwLength;
227 HKEY hkey;
229
230 if (!pustrDevice)
231 {
232 /* Check if some devices have been added since last time */
234 }
235
236 /* Ask gdi for the GRAPHICS_DEVICE */
237 pGraphicsDevice = EngpFindGraphicsDevice(pustrDevice, iDevNum);
238 if (!pGraphicsDevice)
239 {
240 /* No device found */
241 if (iDevNum == 0)
242 ERR("No GRAPHICS_DEVICE found for '%wZ', iDevNum %lu\n", pustrDevice, iDevNum);
243 else
244 TRACE("No GRAPHICS_DEVICE found for '%wZ', iDevNum %lu\n", pustrDevice, iDevNum);
245 return STATUS_UNSUCCESSFUL;
246 }
247
248 if (!pustrDevice)
249 {
250 pdo = pGraphicsDevice->PhysDeviceHandle;
251 }
252 else
253 {
254 EngpUpdateMonitorDevices(pGraphicsDevice);
255 if (iDevNum >= pGraphicsDevice->dwMonCnt)
256 {
257 TRACE("No monitor #%u for '%wZ'\n", iDevNum + 1, pustrDevice);
258 return STATUS_UNSUCCESSFUL;
259 }
260 pdo = pGraphicsDevice->pvMonDev[iDevNum].pdo;
261 }
262
263
264 /* Open the device map registry key */
265 Status = RegOpenKey(KEY_VIDEO, &hkey);
266 if (!NT_SUCCESS(Status))
267 {
268 /* No device found */
269 ERR("Could not open reg key\n");
270 return STATUS_UNSUCCESSFUL;
271 }
272
273 /* Query the registry path */
274 cbSize = sizeof(pdispdev->DeviceKey);
275 RegQueryValue(hkey,
276 pGraphicsDevice->szNtDeviceName,
277 REG_SZ,
278 pdispdev->DeviceKey,
279 &cbSize);
280
281 /* Close registry key */
282 ZwClose(hkey);
283
284 /* Copy device name, device string and StateFlags */
285 if (!pustrDevice)
286 {
287 RtlStringCbCopyW(pdispdev->DeviceName, sizeof(pdispdev->DeviceName), pGraphicsDevice->szWinDeviceName);
288 RtlStringCbCopyW(pdispdev->DeviceString, sizeof(pdispdev->DeviceString), pGraphicsDevice->pwszDescription);
289 pdispdev->StateFlags = pGraphicsDevice->StateFlags;
290 }
291 else
292 {
293 swprintf(pdispdev->DeviceName, L"%ws\\Monitor%u", pGraphicsDevice->szWinDeviceName, iDevNum);
294 if (pdo)
295 {
298 sizeof(pdispdev->DeviceString),
299 pdispdev->DeviceString,
300 &dwLength);
301 if (!NT_SUCCESS(Status))
302 pdispdev->DeviceString[0] = UNICODE_NULL;
303 }
304 pdispdev->StateFlags = pGraphicsDevice->pvMonDev[iDevNum].flag;
305 }
306 pdispdev->DeviceID[0] = UNICODE_NULL;
307
308 /* Fill in DeviceID */
309 if (pdo != NULL)
310 {
313 0,
314 NULL,
315 &dwLength);
316
318 {
319 pHardwareId = ExAllocatePoolWithTag(PagedPool,
320 dwLength,
322 if (!pHardwareId)
323 {
326 }
327
330 dwLength,
331 pHardwareId,
332 &dwLength);
333
334 if (!NT_SUCCESS(Status))
335 {
336 ERR("IoGetDeviceProperty() failed with status 0x%08lx\n", Status);
337 }
338 else
339 {
340 /* For video adapters it should be the first Hardware ID
341 * which usually is the longest one and unique enough */
342 RtlStringCbCopyW(pdispdev->DeviceID, sizeof(pdispdev->DeviceID), pHardwareId);
343
344 if (pustrDevice)
345 {
346 /* For monitors it should be the first Hardware ID,
347 * which we already have obtained above,
348 * concatenated with the unique driver registry key */
349
350 RtlStringCbCatW(pdispdev->DeviceID, sizeof(pdispdev->DeviceID), L"\\");
351
352 /* FIXME: DevicePropertyDriverKeyName string should be appended */
353 pHardwareId[0] = UNICODE_NULL;
354 RtlStringCbCatW(pdispdev->DeviceID, sizeof(pdispdev->DeviceID), pHardwareId);
355 }
356
357 TRACE("Hardware ID: %ls\n", pdispdev->DeviceID);
358 }
359
361 }
362 else
363 {
364 ERR("IoGetDeviceProperty() failed with status 0x%08lx\n", Status);
365 }
366 }
367
368 return STATUS_SUCCESS;
369}
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
static DWORD DWORD * dwLength
Definition: fusion.c:86
#define swprintf
Definition: precomp.h:40
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
#define PagedPool
Definition: env_spec_w32.h:308
#define UNICODE_NULL
NTSTRSAFEAPI RtlStringCbCopyW(_Out_writes_bytes_(cbDest) _Always_(_Post_z_) NTSTRSAFE_PWSTR pszDest, _In_ size_t cbDest, _In_ NTSTRSAFE_PCWSTR pszSrc)
Definition: ntstrsafe.h:174
NTSTRSAFEAPI RtlStringCbCatW(_Inout_updates_bytes_(cbDest) _Always_(_Post_z_) NTSTRSAFE_PWSTR pszDest, _In_ size_t cbDest, _In_ NTSTRSAFE_PCWSTR pszSrc)
Definition: ntstrsafe.h:636
NTSTATUS NTAPI IoGetDeviceProperty(IN PDEVICE_OBJECT DeviceObject, IN DEVICE_REGISTRY_PROPERTY DeviceProperty, IN ULONG BufferLength, OUT PVOID PropertyBuffer, OUT PULONG ResultLength)
Definition: pnpmgr.c:1382
WCHAR DeviceName[32]
Definition: wingdi.h:2818
DWORD StateFlags
Definition: wingdi.h:2820
WCHAR DeviceString[128]
Definition: wingdi.h:2819
WCHAR DeviceKey[128]
Definition: wingdi.h:2822
WCHAR DeviceID[128]
Definition: wingdi.h:2821
WCHAR szWinDeviceName[CCHDEVICENAME/2]
Definition: pdevobj.h:60
DWORD dwMonCnt
Definition: pdevobj.h:73
WCHAR szNtDeviceName[CCHDEVICENAME/2]
Definition: pdevobj.h:59
LPWSTR pwszDescription
Definition: pdevobj.h:72
PVIDEO_MONITOR_DEVICE pvMonDev
Definition: pdevobj.h:74
PDEVICE_OBJECT PhysDeviceHandle
Definition: pdevobj.h:64
uint16_t * PWCHAR
Definition: typedefs.h:56
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
PGRAPHICS_DEVICE NTAPI EngpFindGraphicsDevice(_In_opt_ PUNICODE_STRING pustrDevice, _In_ ULONG iDevNum)
Definition: device.c:780
NTSTATUS NTAPI EngpUpdateMonitorDevices(_In_ PGRAPHICS_DEVICE pGraphicsDevice)
Definition: device.c:568
static const PWCHAR KEY_VIDEO
Definition: display.c:15
#define USERTAG_DISPLAYINFO
Definition: tags.h:225
@ DevicePropertyHardwareID
Definition: iotypes.h:1196
@ DevicePropertyDeviceDescription
Definition: iotypes.h:1195

Referenced by NtUserEnumDisplayDevices(), and UserOpenDisplaySettingsKey().

◆ UserEnumDisplaySettings()

NTSTATUS NTAPI UserEnumDisplaySettings ( PUNICODE_STRING  pustrDevice,
DWORD  iModeNum,
LPDEVMODEW ppdm,
DWORD  dwFlags 
)

Definition at line 484 of file display.c.

489{
490 PGRAPHICS_DEVICE pGraphicsDevice;
491 PDEVMODEENTRY pdmentry;
492 ULONG i, iFoundMode;
493 PPDEVOBJ ppdev;
494
495 TRACE("Enter UserEnumDisplaySettings('%wZ', %lu)\n",
496 pustrDevice, iModeNum);
497
498 /* Ask GDI for the GRAPHICS_DEVICE */
499 pGraphicsDevice = EngpFindGraphicsDevice(pustrDevice, 0);
500 ppdev = EngpGetPDEV(pustrDevice);
501
502 if (!pGraphicsDevice || !ppdev)
503 {
504 /* No device found */
505 ERR("No device found!\n");
507 }
508
509 /* let's politely ask the driver for an updated mode list,
510 just in case there's something new in there (vbox) */
511
513 PDEVOBJ_vRelease(ppdev);
514
515 iFoundMode = 0;
516 for (i = 0; i < pGraphicsDevice->cDevModes; i++)
517 {
518 pdmentry = &pGraphicsDevice->pDevModeList[i];
519
520 /* FIXME: Consider EDS_RAWMODE */
521#if 0
522 if ((!(dwFlags & EDS_RAWMODE) && (pdmentry->dwFlags & 1)) ||!
523 (dwFlags & EDS_RAWMODE))
524#endif
525 {
526 /* Is this the one we want? */
527 if (iFoundMode == iModeNum)
528 {
529 *ppdm = pdmentry->pdm;
530 return STATUS_SUCCESS;
531 }
532
533 /* Increment number of found modes */
534 iFoundMode++;
535 }
536 }
537
538 /* Nothing was found */
540}
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 const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define STATUS_INVALID_PARAMETER_2
Definition: ntstatus.h:476
PDEVMODEW pdm
Definition: pdevobj.h:53
DWORD dwFlags
Definition: pdevobj.h:52
PDEVMODEENTRY pDevModeList
Definition: pdevobj.h:70
ULONG cDevModes
Definition: pdevobj.h:69
VOID NTAPI PDEVOBJ_vRefreshModeList(PPDEVOBJ ppdev)
Definition: pdevobj.c:436

Referenced by NtUserEnumDisplaySettings().

◆ UserEnumRegistryDisplaySettings()

NTSTATUS NTAPI UserEnumRegistryDisplaySettings ( IN PUNICODE_STRING  pustrDevice,
OUT LPDEVMODEW  pdm 
)

Definition at line 575 of file display.c.

578{
579 HKEY hkey;
580 NTSTATUS Status = UserOpenDisplaySettingsKey(&hkey, pustrDevice, 0);
581 if(NT_SUCCESS(Status))
582 {
583 RegReadDisplaySettings(hkey, pdm);
584 ZwClose(hkey);
585 return STATUS_SUCCESS;
586 }
587 return Status;
588}
VOID RegReadDisplaySettings(HKEY hkey, PDEVMODEW pdm)
Definition: display.c:35

Referenced by NtUserEnumDisplaySettings(), and UserChangeDisplaySettings().

◆ UserOpenDisplaySettingsKey()

NTSTATUS NTAPI UserOpenDisplaySettingsKey ( OUT PHKEY  phkey,
IN PUNICODE_STRING  pustrDevice,
IN BOOL  bGlobal 
)

Definition at line 544 of file display.c.

548{
549 HKEY hkey;
550 DISPLAY_DEVICEW dispdev;
552
553 /* Get device info */
554 Status = UserEnumDisplayDevices(pustrDevice, 0, &dispdev, 0);
555 if (!NT_SUCCESS(Status))
556 return Status;
557
558 if (bGlobal)
559 {
560 // FIXME: Need to fix the registry key somehow
561 }
562
563 /* Open the registry key */
564 Status = RegOpenKey(dispdev.DeviceKey, &hkey);
565 if (!NT_SUCCESS(Status))
566 return Status;
567
568 *phkey = hkey;
569
570 return Status;
571}

Referenced by UserChangeDisplaySettings(), and UserEnumRegistryDisplaySettings().

◆ UserRefreshDisplay()

VOID UserRefreshDisplay ( IN PPDEVOBJ  ppdev)

Definition at line 177 of file display.c.

178{
179 ULONG_PTR ulResult;
180 // PVOID pvOldCursor;
181
182 // TODO: Re-enable the cursor reset code once this function becomes called
183 // from within a Win32 thread... Indeed UserSetCursor() requires this, but
184 // at the moment this function is directly called from a separate thread
185 // from within videoprt, instead of by a separate win32k system thread.
186
187 if (!ppdev)
188 return;
189
190 PDEVOBJ_vReference(ppdev);
191
192 /* Remove mouse pointer */
193 // pvOldCursor = UserSetCursor(NULL, TRUE);
194
195 /* Do the mode switch -- Use the actual same current mode */
196 ulResult = PDEVOBJ_bSwitchMode(ppdev, ppdev->pdmwDev);
197 ASSERT(ulResult);
198
199 /* Restore mouse pointer, no hooks called */
200 // pvOldCursor = UserSetCursor(pvOldCursor, TRUE);
201 // ASSERT(pvOldCursor == NULL);
202
203 /* Update the system metrics */
204 InitMetrics();
205
206 /* Set new size of the monitor */
207 // UserUpdateMonitorSize((HDEV)ppdev);
208
209 //co_IntShowDesktop(pdesk, ppdev->gdiinfo.ulHorzRes, ppdev->gdiinfo.ulVertRes);
211
212 PDEVOBJ_vRelease(ppdev);
213}
FORCEINLINE VOID PDEVOBJ_vReference(_In_ PPDEVOBJ ppdev)
Definition: pdevobj.h:160

Referenced by VideoPortCallout().

◆ UserUpdateFullscreen()

VOID UserUpdateFullscreen ( DWORD  flags)

Definition at line 709 of file display.c.

711{
712 if (flags & CDS_FULLSCREEN)
714 else
716}
PTHREADINFO gptiCurrent
Definition: ntuser.c:15
PPROCESSINFO ppi
Definition: win32.h:88

Referenced by UserChangeDisplaySettings().

Variable Documentation

◆ gbBaseVideo

BOOL gbBaseVideo = FALSE

◆ gpFullscreen

PPROCESSINFO gpFullscreen = NULL
static

Definition at line 13 of file display.c.

Referenced by UserDisplayNotifyShutdown(), and UserUpdateFullscreen().

◆ KEY_VIDEO

const PWCHAR KEY_VIDEO = L"\\Registry\\Machine\\HARDWARE\\DEVICEMAP\\VIDEO"
static

Definition at line 15 of file display.c.

Referenced by EngpGetRegistryHandleFromDeviceMap(), and UserEnumDisplayDevices().