?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
user32/tests: Test EnableMouseInPointer behavior.
[wine.git] / dlls / user32 / sysparams.c
blobc7bd702726a96f05c14189dbe952450361a7e6a0
1 /*
2 * System parameters functions
3 *
4 * Copyright 1994 Alexandre Julliard
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include <assert.h>
22 #include <limits.h>
23 #include <stdarg.h>
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <wchar.h>
28
29 #include "windef.h"
30 #include "winbase.h"
31 #include "winnls.h"
32 #include "wingdi.h"
33 #include "winuser.h"
34 #include "winreg.h"
35 #include "wine/wingdi16.h"
36 #include "winerror.h"
37
38 #include "initguid.h"
39 #include "d3dkmdt.h"
40 #include "devguid.h"
41 #include "setupapi.h"
42 #include "controls.h"
43 #include "user_private.h"
44 #include "wine/asm.h"
45 #include "wine/debug.h"
46
47 WINE_DEFAULT_DEBUG_CHANNEL(system);
48
49
50 DEFINE_DEVPROPKEY(DEVPROPKEY_MONITOR_GPU_LUID, 0xca085853, 0x16ce, 0x48aa, 0xb1, 0x14, 0xde, 0x9c, 0x72, 0x33, 0x42, 0x23, 1);
51 DEFINE_DEVPROPKEY(DEVPROPKEY_MONITOR_OUTPUT_ID, 0xca085853, 0x16ce, 0x48aa, 0xb1, 0x14, 0xde, 0x9c, 0x72, 0x33, 0x42, 0x23, 2);
52
53 /* Wine specific monitor properties */
54 DEFINE_DEVPROPKEY(WINE_DEVPROPKEY_MONITOR_STATEFLAGS, 0x233a9ef3, 0xafc4, 0x4abd, 0xb5, 0x64, 0xc3, 0x2f, 0x21, 0xf1, 0x53, 0x5b, 2);
55 DEFINE_DEVPROPKEY(WINE_DEVPROPKEY_MONITOR_ADAPTERNAME, 0x233a9ef3, 0xafc4, 0x4abd, 0xb5, 0x64, 0xc3, 0x2f, 0x21, 0xf1, 0x53, 0x5b, 5);
56
57
58 static HDC display_dc;
59 static CRITICAL_SECTION display_dc_section;
60 static CRITICAL_SECTION_DEBUG critsect_debug =
61 {
62 0, 0, &display_dc_section,
63 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
64 0, 0, { (DWORD_PTR)(__FILE__ ": display_dc_section") }
65 };
66 static CRITICAL_SECTION display_dc_section = { &critsect_debug, -1 ,0, 0, 0, 0 };
67
68
69 /* System parameters storage */
70 static UINT system_dpi;
71
72 static void SYSPARAMS_LogFont32WTo32A( const LOGFONTW* font32W, LPLOGFONTA font32A )
73 {
74 font32A->lfHeight = font32W->lfHeight;
75 font32A->lfWidth = font32W->lfWidth;
76 font32A->lfEscapement = font32W->lfEscapement;
77 font32A->lfOrientation = font32W->lfOrientation;
78 font32A->lfWeight = font32W->lfWeight;
79 font32A->lfItalic = font32W->lfItalic;
80 font32A->lfUnderline = font32W->lfUnderline;
81 font32A->lfStrikeOut = font32W->lfStrikeOut;
82 font32A->lfCharSet = font32W->lfCharSet;
83 font32A->lfOutPrecision = font32W->lfOutPrecision;
84 font32A->lfClipPrecision = font32W->lfClipPrecision;
85 font32A->lfQuality = font32W->lfQuality;
86 font32A->lfPitchAndFamily = font32W->lfPitchAndFamily;
87 WideCharToMultiByte( CP_ACP, 0, font32W->lfFaceName, -1, font32A->lfFaceName, LF_FACESIZE, NULL, NULL );
88 font32A->lfFaceName[LF_FACESIZE-1] = 0;
89 }
90
91 static void SYSPARAMS_LogFont32ATo32W( const LOGFONTA* font32A, LPLOGFONTW font32W )
92 {
93 font32W->lfHeight = font32A->lfHeight;
94 font32W->lfWidth = font32A->lfWidth;
95 font32W->lfEscapement = font32A->lfEscapement;
96 font32W->lfOrientation = font32A->lfOrientation;
97 font32W->lfWeight = font32A->lfWeight;
98 font32W->lfItalic = font32A->lfItalic;
99 font32W->lfUnderline = font32A->lfUnderline;
100 font32W->lfStrikeOut = font32A->lfStrikeOut;
101 font32W->lfCharSet = font32A->lfCharSet;
102 font32W->lfOutPrecision = font32A->lfOutPrecision;
103 font32W->lfClipPrecision = font32A->lfClipPrecision;
104 font32W->lfQuality = font32A->lfQuality;
105 font32W->lfPitchAndFamily = font32A->lfPitchAndFamily;
106 MultiByteToWideChar( CP_ACP, 0, font32A->lfFaceName, -1, font32W->lfFaceName, LF_FACESIZE );
107 font32W->lfFaceName[LF_FACESIZE-1] = 0;
108 }
109
110 static void SYSPARAMS_NonClientMetrics32WTo32A( const NONCLIENTMETRICSW* lpnm32W, LPNONCLIENTMETRICSA lpnm32A )
111 {
112 lpnm32A->iBorderWidth = lpnm32W->iBorderWidth;
113 lpnm32A->iScrollWidth = lpnm32W->iScrollWidth;
114 lpnm32A->iScrollHeight = lpnm32W->iScrollHeight;
115 lpnm32A->iCaptionWidth = lpnm32W->iCaptionWidth;
116 lpnm32A->iCaptionHeight = lpnm32W->iCaptionHeight;
117 SYSPARAMS_LogFont32WTo32A( &lpnm32W->lfCaptionFont, &lpnm32A->lfCaptionFont );
118 lpnm32A->iSmCaptionWidth = lpnm32W->iSmCaptionWidth;
119 lpnm32A->iSmCaptionHeight = lpnm32W->iSmCaptionHeight;
120 SYSPARAMS_LogFont32WTo32A( &lpnm32W->lfSmCaptionFont, &lpnm32A->lfSmCaptionFont );
121 lpnm32A->iMenuWidth = lpnm32W->iMenuWidth;
122 lpnm32A->iMenuHeight = lpnm32W->iMenuHeight;
123 SYSPARAMS_LogFont32WTo32A( &lpnm32W->lfMenuFont, &lpnm32A->lfMenuFont );
124 SYSPARAMS_LogFont32WTo32A( &lpnm32W->lfStatusFont, &lpnm32A->lfStatusFont );
125 SYSPARAMS_LogFont32WTo32A( &lpnm32W->lfMessageFont, &lpnm32A->lfMessageFont );
126 if (lpnm32A->cbSize > FIELD_OFFSET(NONCLIENTMETRICSA, iPaddedBorderWidth))
127 {
128 if (lpnm32W->cbSize > FIELD_OFFSET(NONCLIENTMETRICSW, iPaddedBorderWidth))
129 lpnm32A->iPaddedBorderWidth = lpnm32W->iPaddedBorderWidth;
130 else
131 lpnm32A->iPaddedBorderWidth = 0;
132 }
133 }
134
135 static void SYSPARAMS_NonClientMetrics32ATo32W( const NONCLIENTMETRICSA* lpnm32A, LPNONCLIENTMETRICSW lpnm32W )
136 {
137 lpnm32W->iBorderWidth = lpnm32A->iBorderWidth;
138 lpnm32W->iScrollWidth = lpnm32A->iScrollWidth;
139 lpnm32W->iScrollHeight = lpnm32A->iScrollHeight;
140 lpnm32W->iCaptionWidth = lpnm32A->iCaptionWidth;
141 lpnm32W->iCaptionHeight = lpnm32A->iCaptionHeight;
142 SYSPARAMS_LogFont32ATo32W( &lpnm32A->lfCaptionFont, &lpnm32W->lfCaptionFont );
143 lpnm32W->iSmCaptionWidth = lpnm32A->iSmCaptionWidth;
144 lpnm32W->iSmCaptionHeight = lpnm32A->iSmCaptionHeight;
145 SYSPARAMS_LogFont32ATo32W( &lpnm32A->lfSmCaptionFont, &lpnm32W->lfSmCaptionFont );
146 lpnm32W->iMenuWidth = lpnm32A->iMenuWidth;
147 lpnm32W->iMenuHeight = lpnm32A->iMenuHeight;
148 SYSPARAMS_LogFont32ATo32W( &lpnm32A->lfMenuFont, &lpnm32W->lfMenuFont );
149 SYSPARAMS_LogFont32ATo32W( &lpnm32A->lfStatusFont, &lpnm32W->lfStatusFont );
150 SYSPARAMS_LogFont32ATo32W( &lpnm32A->lfMessageFont, &lpnm32W->lfMessageFont );
151 if (lpnm32W->cbSize > FIELD_OFFSET(NONCLIENTMETRICSW, iPaddedBorderWidth))
152 {
153 if (lpnm32A->cbSize > FIELD_OFFSET(NONCLIENTMETRICSA, iPaddedBorderWidth))
154 lpnm32W->iPaddedBorderWidth = lpnm32A->iPaddedBorderWidth;
155 else
156 lpnm32W->iPaddedBorderWidth = 0;
157 }
158 }
159
160
161 /* Helper functions to retrieve monitors info */
162
163 static BOOL CALLBACK get_virtual_screen_proc( HMONITOR monitor, HDC hdc, LPRECT rect, LPARAM lp )
164 {
165 RECT *virtual_rect = (RECT *)lp;
166
167 UnionRect( virtual_rect, virtual_rect, rect );
168 return TRUE;
169 }
170
171 RECT get_virtual_screen_rect(void)
172 {
173 RECT rect = {0};
174
175 NtUserEnumDisplayMonitors( 0, NULL, get_virtual_screen_proc, (LPARAM)&rect );
176 return rect;
177 }
178
179 static BOOL CALLBACK get_primary_monitor_proc( HMONITOR monitor, HDC hdc, LPRECT rect, LPARAM lp )
180 {
181 RECT *primary_rect = (RECT *)lp;
182
183 if (!rect->top && !rect->left && rect->right && rect->bottom)
184 {
185 *primary_rect = *rect;
186 return FALSE;
187 }
188
189 return TRUE;
190 }
191
192 RECT get_primary_monitor_rect(void)
193 {
194 RECT rect = {0};
195
196 NtUserEnumDisplayMonitors( 0, NULL, get_primary_monitor_proc, (LPARAM)&rect );
197 return rect;
198 }
199
200 HDC get_display_dc(void)
201 {
202 EnterCriticalSection( &display_dc_section );
203 if (!display_dc)
204 {
205 HDC dc;
206
207 LeaveCriticalSection( &display_dc_section );
208 dc = CreateDCW( L"DISPLAY", NULL, NULL, NULL );
209 EnterCriticalSection( &display_dc_section );
210 if (display_dc)
211 DeleteDC(dc);
212 else
213 display_dc = dc;
214 }
215 return display_dc;
216 }
217
218 void release_display_dc( HDC hdc )
219 {
220 LeaveCriticalSection( &display_dc_section );
221 }
222
223 static HANDLE get_display_device_init_mutex( void )
224 {
225 HANDLE mutex = CreateMutexW( NULL, FALSE, L"display_device_init" );
226
227 WaitForSingleObject( mutex, INFINITE );
228 return mutex;
229 }
230
231 static void release_display_device_init_mutex( HANDLE mutex )
232 {
233 ReleaseMutex( mutex );
234 CloseHandle( mutex );
235 }
236
237 /* Wait until graphics driver is loaded by explorer */
238 void wait_graphics_driver_ready(void)
239 {
240 static BOOL ready = FALSE;
241
242 if (!ready)
243 {
244 SendMessageW( GetDesktopWindow(), WM_NULL, 0, 0 );
245 ready = TRUE;
246 }
247 }
248
249 /***********************************************************************
250 * SYSPARAMS_Init
251 */
252 void SYSPARAMS_Init(void)
253 {
254 system_dpi = NtUserGetSystemDpiForProcess( NULL );
255 }
256
257 static BOOL update_desktop_wallpaper(void)
258 {
259 DWORD pid;
260
261 if (GetWindowThreadProcessId( GetDesktopWindow(), &pid ) && pid == GetCurrentProcessId())
262 {
263 WCHAR wallpaper[MAX_PATH], pattern[256];
264
265 if (NtUserSystemParametersInfo( SPI_GETDESKWALLPAPER, ARRAYSIZE(wallpaper), wallpaper, 0 ) &&
266 NtUserCallOneParam( (ULONG_PTR)pattern, NtUserGetDeskPattern ))
267 {
268 update_wallpaper( wallpaper, pattern );
269 }
270 }
271 else SendMessageW( GetDesktopWindow(), WM_SETTINGCHANGE, SPI_SETDESKWALLPAPER, 0 );
272 return TRUE;
273 }
274
275
276 /***********************************************************************
277 * SystemParametersInfoForDpi (USER32.@)
278 */
279 BOOL WINAPI SystemParametersInfoForDpi( UINT action, UINT val, PVOID ptr, UINT winini, UINT dpi )
280 {
281 BOOL ret = NtUserSystemParametersInfoForDpi( action, val, ptr, winini, dpi );
282 if (ret && (action == SPI_SETDESKWALLPAPER || action == SPI_SETDESKPATTERN))
283 ret = update_desktop_wallpaper();
284 return ret;
285 }
286
287
288 /***********************************************************************
289 * SystemParametersInfoW (USER32.@)
290 */
291 BOOL WINAPI SystemParametersInfoW( UINT action, UINT val, void *ptr, UINT winini )
292 {
293 BOOL ret = NtUserSystemParametersInfo( action, val, ptr, winini );
294 if (ret && (action == SPI_SETDESKWALLPAPER || action == SPI_SETDESKPATTERN))
295 ret = update_desktop_wallpaper();
296 return ret;
297 }
298
299
300 /***********************************************************************
301 * SystemParametersInfoA (USER32.@)
302 */
303 BOOL WINAPI SystemParametersInfoA( UINT uiAction, UINT uiParam,
304 PVOID pvParam, UINT fuWinIni )
305 {
306 BOOL ret;
307
308 TRACE("(%u, %u, %p, %u)\n", uiAction, uiParam, pvParam, fuWinIni);
309
310 switch (uiAction)
311 {
312 case SPI_SETDESKWALLPAPER: /* 20 */
313 case SPI_SETDESKPATTERN: /* 21 */
314 {
315 WCHAR buffer[256];
316 if (pvParam)
317 if (!MultiByteToWideChar( CP_ACP, 0, pvParam, -1, buffer, ARRAY_SIZE( buffer )))
318 buffer[ARRAY_SIZE(buffer)-1] = 0;
319 ret = SystemParametersInfoW( uiAction, uiParam, pvParam ? buffer : NULL, fuWinIni );
320 break;
321 }
322
323 case SPI_GETICONTITLELOGFONT: /* 31 */
324 {
325 LOGFONTW tmp;
326 ret = SystemParametersInfoW( uiAction, uiParam, pvParam ? &tmp : NULL, fuWinIni );
327 if (ret && pvParam)
328 SYSPARAMS_LogFont32WTo32A( &tmp, pvParam );
329 break;
330 }
331
332 case SPI_GETNONCLIENTMETRICS: /* 41 WINVER >= 0x400 */
333 {
334 NONCLIENTMETRICSW tmp;
335 LPNONCLIENTMETRICSA lpnmA = pvParam;
336 if (lpnmA && (lpnmA->cbSize == sizeof(NONCLIENTMETRICSA) ||
337 lpnmA->cbSize == FIELD_OFFSET(NONCLIENTMETRICSA, iPaddedBorderWidth)))
338 {
339 tmp.cbSize = sizeof(NONCLIENTMETRICSW);
340 ret = SystemParametersInfoW( uiAction, uiParam, &tmp, fuWinIni );
341 if (ret)
342 SYSPARAMS_NonClientMetrics32WTo32A( &tmp, lpnmA );
343 }
344 else
345 ret = FALSE;
346 break;
347 }
348
349 case SPI_SETNONCLIENTMETRICS: /* 42 WINVER >= 0x400 */
350 {
351 NONCLIENTMETRICSW tmp;
352 LPNONCLIENTMETRICSA lpnmA = pvParam;
353 if (lpnmA && (lpnmA->cbSize == sizeof(NONCLIENTMETRICSA) ||
354 lpnmA->cbSize == FIELD_OFFSET(NONCLIENTMETRICSA, iPaddedBorderWidth)))
355 {
356 tmp.cbSize = sizeof(NONCLIENTMETRICSW);
357 SYSPARAMS_NonClientMetrics32ATo32W( lpnmA, &tmp );
358 ret = SystemParametersInfoW( uiAction, uiParam, &tmp, fuWinIni );
359 }
360 else
361 ret = FALSE;
362 break;
363 }
364
365 case SPI_GETICONMETRICS: /* 45 WINVER >= 0x400 */
366 {
367 ICONMETRICSW tmp;
368 LPICONMETRICSA lpimA = pvParam;
369 if (lpimA && lpimA->cbSize == sizeof(ICONMETRICSA))
370 {
371 tmp.cbSize = sizeof(ICONMETRICSW);
372 ret = SystemParametersInfoW( uiAction, uiParam, &tmp, fuWinIni );
373 if (ret)
374 {
375 lpimA->iHorzSpacing = tmp.iHorzSpacing;
376 lpimA->iVertSpacing = tmp.iVertSpacing;
377 lpimA->iTitleWrap = tmp.iTitleWrap;
378 SYSPARAMS_LogFont32WTo32A( &tmp.lfFont, &lpimA->lfFont );
379 }
380 }
381 else
382 ret = FALSE;
383 break;
384 }
385
386 case SPI_SETICONMETRICS: /* 46 WINVER >= 0x400 */
387 {
388 ICONMETRICSW tmp;
389 LPICONMETRICSA lpimA = pvParam;
390 if (lpimA && lpimA->cbSize == sizeof(ICONMETRICSA))
391 {
392 tmp.cbSize = sizeof(ICONMETRICSW);
393 tmp.iHorzSpacing = lpimA->iHorzSpacing;
394 tmp.iVertSpacing = lpimA->iVertSpacing;
395 tmp.iTitleWrap = lpimA->iTitleWrap;
396 SYSPARAMS_LogFont32ATo32W( &lpimA->lfFont, &tmp.lfFont);
397 ret = SystemParametersInfoW( uiAction, uiParam, &tmp, fuWinIni );
398 }
399 else
400 ret = FALSE;
401 break;
402 }
403
404 case SPI_GETHIGHCONTRAST: /* 66 WINVER >= 0x400 */
405 {
406 HIGHCONTRASTW tmp;
407 LPHIGHCONTRASTA lphcA = pvParam;
408 if (lphcA && lphcA->cbSize == sizeof(HIGHCONTRASTA))
409 {
410 tmp.cbSize = sizeof(HIGHCONTRASTW);
411 ret = SystemParametersInfoW( uiAction, uiParam, &tmp, fuWinIni );
412 if (ret)
413 {
414 lphcA->dwFlags = tmp.dwFlags;
415 lphcA->lpszDefaultScheme = NULL; /* FIXME? */
416 }
417 }
418 else
419 ret = FALSE;
420 break;
421 }
422
423 case SPI_GETDESKWALLPAPER: /* 115 */
424 {
425 WCHAR buffer[MAX_PATH];
426 ret = (SystemParametersInfoW( SPI_GETDESKWALLPAPER, uiParam, buffer, fuWinIni ) &&
427 WideCharToMultiByte(CP_ACP, 0, buffer, -1, pvParam, uiParam, NULL, NULL));
428 break;
429 }
430
431 default:
432 ret = SystemParametersInfoW( uiAction, uiParam, pvParam, fuWinIni );
433 break;
434 }
435 return ret;
436 }
437
438
439 /***********************************************************************
440 * GetSystemMetrics (USER32.@)
441 */
442 INT WINAPI GetSystemMetrics( INT index )
443 {
444 return NtUserGetSystemMetrics( index );
445 }
446
447
448 /***********************************************************************
449 * GetSystemMetricsForDpi (USER32.@)
450 */
451 INT WINAPI GetSystemMetricsForDpi( INT index, UINT dpi )
452 {
453 return NtUserGetSystemMetricsForDpi( index, dpi );
454 }
455
456
457 /***********************************************************************
458 * SwapMouseButton (USER32.@)
459 * Reverse or restore the meaning of the left and right mouse buttons
460 * fSwap [I ] TRUE - reverse, FALSE - original
461 * RETURN
462 * previous state
463 */
464 BOOL WINAPI SwapMouseButton( BOOL fSwap )
465 {
466 BOOL prev = GetSystemMetrics(SM_SWAPBUTTON);
467 SystemParametersInfoW(SPI_SETMOUSEBUTTONSWAP, fSwap, 0, 0);
468 return prev;
469 }
470
471
472 /**********************************************************************
473 * SetDoubleClickTime (USER32.@)
474 */
475 BOOL WINAPI SetDoubleClickTime( UINT interval )
476 {
477 return SystemParametersInfoW(SPI_SETDOUBLECLICKTIME, interval, 0, 0);
478 }
479
480
481 /*************************************************************************
482 * GetSysColor (USER32.@)
483 */
484 COLORREF WINAPI DECLSPEC_HOTPATCH GetSysColor( INT index )
485 {
486 return NtUserGetSysColor( index );
487 }
488
489
490 /*************************************************************************
491 * SetSysColorsTemp (USER32.@)
492 */
493 DWORD_PTR WINAPI SetSysColorsTemp( const COLORREF *pPens, const HBRUSH *pBrushes, DWORD_PTR n)
494 {
495 FIXME( "no longer supported\n" );
496 return FALSE;
497 }
498
499
500 /***********************************************************************
501 * GetSysColorBrush (USER32.@)
502 */
503 HBRUSH WINAPI DECLSPEC_HOTPATCH GetSysColorBrush( INT index )
504 {
505 return NtUserGetSysColorBrush( index );
506 }
507
508
509 /***********************************************************************
510 * SYSCOLOR_GetPen
511 */
512 HPEN SYSCOLOR_GetPen( INT index )
513 {
514 return NtUserGetSysColorPen( index );
515 }
516
517
518 /***********************************************************************
519 * SYSCOLOR_Get55AABrush
520 */
521 HBRUSH SYSCOLOR_Get55AABrush(void)
522 {
523 return NtUserGetSysColorBrush( COLOR_55AA_BRUSH );
524 }
525
526 /***********************************************************************
527 * ChangeDisplaySettingsA (USER32.@)
528 */
529 LONG WINAPI ChangeDisplaySettingsA( LPDEVMODEA devmode, DWORD flags )
530 {
531 if (devmode) devmode->dmDriverExtra = 0;
532
533 return ChangeDisplaySettingsExA(NULL,devmode,NULL,flags,NULL);
534 }
535
536
537 /***********************************************************************
538 * ChangeDisplaySettingsW (USER32.@)
539 */
540 LONG WINAPI ChangeDisplaySettingsW( LPDEVMODEW devmode, DWORD flags )
541 {
542 if (devmode) devmode->dmDriverExtra = 0;
543
544 return ChangeDisplaySettingsExW(NULL,devmode,NULL,flags,NULL);
545 }
546
547
548 /***********************************************************************
549 * ChangeDisplaySettingsExA (USER32.@)
550 */
551 LONG WINAPI ChangeDisplaySettingsExA( LPCSTR devname, LPDEVMODEA devmode, HWND hwnd,
552 DWORD flags, LPVOID lparam )
553 {
554 LONG ret;
555 UNICODE_STRING nameW;
556
557 if (devname) RtlCreateUnicodeStringFromAsciiz(&nameW, devname);
558 else nameW.Buffer = NULL;
559
560 if (devmode)
561 {
562 DEVMODEW *devmodeW;
563
564 devmodeW = GdiConvertToDevmodeW(devmode);
565 if (devmodeW)
566 {
567 ret = ChangeDisplaySettingsExW(nameW.Buffer, devmodeW, hwnd, flags, lparam);
568 HeapFree(GetProcessHeap(), 0, devmodeW);
569 }
570 else
571 ret = DISP_CHANGE_SUCCESSFUL;
572 }
573 else
574 {
575 ret = ChangeDisplaySettingsExW(nameW.Buffer, NULL, hwnd, flags, lparam);
576 }
577
578 if (devname) RtlFreeUnicodeString(&nameW);
579 return ret;
580 }
581
582
583 /***********************************************************************
584 * ChangeDisplaySettingsExW (USER32.@)
585 */
586 LONG WINAPI ChangeDisplaySettingsExW( LPCWSTR devname, LPDEVMODEW devmode, HWND hwnd,
587 DWORD flags, LPVOID lparam )
588 {
589 UNICODE_STRING str;
590 RtlInitUnicodeString( &str, devname );
591 return NtUserChangeDisplaySettings( &str, devmode, hwnd, flags, lparam );
592 }
593
594
595 /***********************************************************************
596 * EnumDisplaySettingsW (USER32.@)
597 *
598 * RETURNS
599 * TRUE if nth setting exists found (described in the LPDEVMODEW struct)
600 * FALSE if we do not have the nth setting
601 */
602 BOOL WINAPI EnumDisplaySettingsW( LPCWSTR name, DWORD n, LPDEVMODEW devmode )
603 {
604 return EnumDisplaySettingsExW(name, n, devmode, 0);
605 }
606
607
608 /***********************************************************************
609 * EnumDisplaySettingsA (USER32.@)
610 */
611 BOOL WINAPI EnumDisplaySettingsA(LPCSTR name,DWORD n,LPDEVMODEA devmode)
612 {
613 return EnumDisplaySettingsExA(name, n, devmode, 0);
614 }
615
616
617 /***********************************************************************
618 * EnumDisplaySettingsExA (USER32.@)
619 */
620 BOOL WINAPI EnumDisplaySettingsExA(LPCSTR lpszDeviceName, DWORD iModeNum,
621 LPDEVMODEA lpDevMode, DWORD dwFlags)
622 {
623 DEVMODEW devmodeW;
624 BOOL ret;
625 UNICODE_STRING nameW;
626
627 if (lpszDeviceName) RtlCreateUnicodeStringFromAsciiz(&nameW, lpszDeviceName);
628 else nameW.Buffer = NULL;
629
630 memset(&devmodeW, 0, sizeof(devmodeW));
631 devmodeW.dmSize = sizeof(devmodeW);
632 ret = EnumDisplaySettingsExW(nameW.Buffer,iModeNum,&devmodeW,dwFlags);
633 if (ret)
634 {
635 lpDevMode->dmSize = FIELD_OFFSET(DEVMODEA, dmICMMethod);
636 lpDevMode->dmSpecVersion = devmodeW.dmSpecVersion;
637 lpDevMode->dmDriverVersion = devmodeW.dmDriverVersion;
638 WideCharToMultiByte(CP_ACP, 0, devmodeW.dmDeviceName, -1,
639 (LPSTR)lpDevMode->dmDeviceName, CCHDEVICENAME, NULL, NULL);
640 lpDevMode->dmDriverExtra = 0; /* FIXME */
641 lpDevMode->dmBitsPerPel = devmodeW.dmBitsPerPel;
642 lpDevMode->dmPelsHeight = devmodeW.dmPelsHeight;
643 lpDevMode->dmPelsWidth = devmodeW.dmPelsWidth;
644 lpDevMode->dmDisplayFlags = devmodeW.dmDisplayFlags;
645 lpDevMode->dmDisplayFrequency = devmodeW.dmDisplayFrequency;
646 lpDevMode->dmFields = devmodeW.dmFields;
647
648 lpDevMode->dmPosition.x = devmodeW.dmPosition.x;
649 lpDevMode->dmPosition.y = devmodeW.dmPosition.y;
650 lpDevMode->dmDisplayOrientation = devmodeW.dmDisplayOrientation;
651 lpDevMode->dmDisplayFixedOutput = devmodeW.dmDisplayFixedOutput;
652 }
653 if (lpszDeviceName) RtlFreeUnicodeString(&nameW);
654 return ret;
655 }
656
657
658 /***********************************************************************
659 * EnumDisplaySettingsExW (USER32.@)
660 */
661 BOOL WINAPI EnumDisplaySettingsExW( const WCHAR *device, DWORD mode,
662 DEVMODEW *dev_mode, DWORD flags )
663 {
664 UNICODE_STRING str;
665 RtlInitUnicodeString( &str, device );
666 return NtUserEnumDisplaySettings( &str, mode, dev_mode, flags );
667 }
668
669 /**********************************************************************
670 * SetProcessDpiAwarenessContext (USER32.@)
671 */
672 BOOL WINAPI SetProcessDpiAwarenessContext( DPI_AWARENESS_CONTEXT context )
673 {
674 ULONG awareness;
675
676 switch (GetAwarenessFromDpiAwarenessContext( context ))
677 {
678 case DPI_AWARENESS_UNAWARE:
679 awareness = NTUSER_DPI_UNAWARE;
680 break;
681 case DPI_AWARENESS_SYSTEM_AWARE:
682 awareness = NTUSER_DPI_SYSTEM_AWARE;
683 break;
684 case DPI_AWARENESS_PER_MONITOR_AWARE:
685 awareness = context == DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2
686 ? NTUSER_DPI_PER_MONITOR_AWARE_V2 : NTUSER_DPI_PER_MONITOR_AWARE;
687 break;
688 default:
689 SetLastError( ERROR_INVALID_PARAMETER );
690 return FALSE;
691 }
692
693 if (!NtUserSetProcessDpiAwarenessContext( awareness, 0 ))
694 {
695 SetLastError( ERROR_ACCESS_DENIED );
696 return FALSE;
697 }
698
699 TRACE( "set to %p\n", context );
700 return TRUE;
701 }
702
703 /**********************************************************************
704 * GetProcessDpiAwarenessInternal (USER32.@)
705 */
706 BOOL WINAPI GetProcessDpiAwarenessInternal( HANDLE process, DPI_AWARENESS *awareness )
707 {
708 *awareness = NtUserGetProcessDpiAwarenessContext( process ) & 3;
709 return TRUE;
710 }
711
712 /**********************************************************************
713 * SetProcessDpiAwarenessInternal (USER32.@)
714 */
715 BOOL WINAPI SetProcessDpiAwarenessInternal( DPI_AWARENESS awareness )
716 {
717 static const DPI_AWARENESS_CONTEXT contexts[3] = { DPI_AWARENESS_CONTEXT_UNAWARE,
718 DPI_AWARENESS_CONTEXT_SYSTEM_AWARE,
719 DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE };
720
721 if (awareness < DPI_AWARENESS_UNAWARE || awareness > DPI_AWARENESS_PER_MONITOR_AWARE)
722 {
723 SetLastError( ERROR_INVALID_PARAMETER );
724 return FALSE;
725 }
726 return SetProcessDpiAwarenessContext( contexts[awareness] );
727 }
728
729 /***********************************************************************
730 * AreDpiAwarenessContextsEqual (USER32.@)
731 */
732 BOOL WINAPI AreDpiAwarenessContextsEqual( DPI_AWARENESS_CONTEXT ctx1, DPI_AWARENESS_CONTEXT ctx2 )
733 {
734 DPI_AWARENESS aware1 = GetAwarenessFromDpiAwarenessContext( ctx1 );
735 DPI_AWARENESS aware2 = GetAwarenessFromDpiAwarenessContext( ctx2 );
736 return aware1 != DPI_AWARENESS_INVALID && aware1 == aware2;
737 }
738
739 /***********************************************************************
740 * GetAwarenessFromDpiAwarenessContext (USER32.@)
741 */
742 DPI_AWARENESS WINAPI GetAwarenessFromDpiAwarenessContext( DPI_AWARENESS_CONTEXT context )
743 {
744 switch ((ULONG_PTR)context)
745 {
746 case 0x10:
747 case 0x11:
748 case 0x12:
749 case 0x80000010:
750 case 0x80000011:
751 case 0x80000012:
752 return (ULONG_PTR)context & 3;
753 case (ULONG_PTR)DPI_AWARENESS_CONTEXT_UNAWARE:
754 case (ULONG_PTR)DPI_AWARENESS_CONTEXT_SYSTEM_AWARE:
755 case (ULONG_PTR)DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE:
756 return ~(ULONG_PTR)context;
757 default:
758 return DPI_AWARENESS_INVALID;
759 }
760 }
761
762 /***********************************************************************
763 * IsValidDpiAwarenessContext (USER32.@)
764 */
765 BOOL WINAPI IsValidDpiAwarenessContext( DPI_AWARENESS_CONTEXT context )
766 {
767 return GetAwarenessFromDpiAwarenessContext( context ) != DPI_AWARENESS_INVALID;
768 }
769
770 /***********************************************************************
771 * SetProcessDPIAware (USER32.@)
772 */
773 BOOL WINAPI SetProcessDPIAware(void)
774 {
775 TRACE("\n");
776 NtUserSetProcessDpiAwarenessContext( NTUSER_DPI_SYSTEM_AWARE, 0 );
777 return TRUE;
778 }
779
780 /***********************************************************************
781 * IsProcessDPIAware (USER32.@)
782 */
783 BOOL WINAPI IsProcessDPIAware(void)
784 {
785 return GetAwarenessFromDpiAwarenessContext( GetThreadDpiAwarenessContext() ) != DPI_AWARENESS_UNAWARE;
786 }
787
788 /**********************************************************************
789 * EnableNonClientDpiScaling (USER32.@)
790 */
791 BOOL WINAPI EnableNonClientDpiScaling( HWND hwnd )
792 {
793 FIXME("(%p): stub\n", hwnd);
794 SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
795 return FALSE;
796 }
797
798 /***********************************************************************
799 * GetDpiForSystem (USER32.@)
800 */
801 UINT WINAPI GetDpiForSystem(void)
802 {
803 if (!IsProcessDPIAware()) return USER_DEFAULT_SCREEN_DPI;
804 return system_dpi;
805 }
806
807 /**********************************************************************
808 * GetThreadDpiAwarenessContext (USER32.@)
809 */
810 DPI_AWARENESS_CONTEXT WINAPI GetThreadDpiAwarenessContext(void)
811 {
812 struct ntuser_thread_info *info = NtUserGetThreadInfo();
813
814 if (info->dpi_awareness) return ULongToHandle( info->dpi_awareness );
815 return UlongToHandle( (NtUserGetProcessDpiAwarenessContext( GetCurrentProcess() ) & 3 ) | 0x10 );
816 }
817
818 /**********************************************************************
819 * SetThreadDpiAwarenessContext (USER32.@)
820 */
821 DPI_AWARENESS_CONTEXT WINAPI SetThreadDpiAwarenessContext( DPI_AWARENESS_CONTEXT context )
822 {
823 struct ntuser_thread_info *info = NtUserGetThreadInfo();
824 DPI_AWARENESS prev, val = GetAwarenessFromDpiAwarenessContext( context );
825
826 if (val == DPI_AWARENESS_INVALID)
827 {
828 SetLastError( ERROR_INVALID_PARAMETER );
829 return 0;
830 }
831 if (!(prev = info->dpi_awareness))
832 {
833 prev = NtUserGetProcessDpiAwarenessContext( GetCurrentProcess() ) & 3;
834 prev |= 0x80000010; /* restore to process default */
835 }
836 if (((ULONG_PTR)context & ~(ULONG_PTR)0x13) == 0x80000000) info->dpi_awareness = 0;
837 else info->dpi_awareness = val | 0x10;
838 return ULongToHandle( prev );
839 }
840
841 /***********************************************************************
842 * MonitorFromRect (USER32.@)
843 */
844 HMONITOR WINAPI MonitorFromRect( const RECT *rect, DWORD flags )
845 {
846 return NtUserMonitorFromRect( rect, flags );
847 }
848
849 /***********************************************************************
850 * MonitorFromPoint (USER32.@)
851 */
852 HMONITOR WINAPI MonitorFromPoint( POINT pt, DWORD flags )
853 {
854 RECT rect;
855
856 SetRect( &rect, pt.x, pt.y, pt.x + 1, pt.y + 1 );
857 return MonitorFromRect( &rect, flags );
858 }
859
860 /***********************************************************************
861 * MonitorFromWindow (USER32.@)
862 */
863 HMONITOR WINAPI MonitorFromWindow( HWND hwnd, DWORD flags )
864 {
865 return NtUserMonitorFromWindow( hwnd, flags );
866 }
867
868 /***********************************************************************
869 * GetMonitorInfoA (USER32.@)
870 */
871 BOOL WINAPI GetMonitorInfoA( HMONITOR monitor, LPMONITORINFO info )
872 {
873 MONITORINFOEXW miW;
874 BOOL ret;
875
876 if (info->cbSize == sizeof(MONITORINFO)) return GetMonitorInfoW( monitor, info );
877 if (info->cbSize != sizeof(MONITORINFOEXA)) return FALSE;
878
879 miW.cbSize = sizeof(miW);
880 ret = GetMonitorInfoW( monitor, (MONITORINFO *)&miW );
881 if (ret)
882 {
883 MONITORINFOEXA *miA = (MONITORINFOEXA *)info;
884 miA->rcMonitor = miW.rcMonitor;
885 miA->rcWork = miW.rcWork;
886 miA->dwFlags = miW.dwFlags;
887 WideCharToMultiByte(CP_ACP, 0, miW.szDevice, -1, miA->szDevice, sizeof(miA->szDevice), NULL, NULL);
888 }
889 return ret;
890 }
891
892 /***********************************************************************
893 * GetMonitorInfoW (USER32.@)
894 */
895 BOOL WINAPI GetMonitorInfoW( HMONITOR monitor, LPMONITORINFO info )
896 {
897 return NtUserGetMonitorInfo( monitor, info );
898 }
899
900 #ifdef __i386__
901 /* Some apps pass a non-stdcall callback to EnumDisplayMonitors,
902 * so we need a small assembly wrapper to call it.
903 */
904 extern BOOL enum_mon_callback_wrapper( void *proc, HMONITOR monitor, HDC hdc, RECT *rect, LPARAM lparam );
905 __ASM_GLOBAL_FUNC( enum_mon_callback_wrapper,
906 "pushl %ebp\n\t"
907 __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
908 __ASM_CFI(".cfi_rel_offset %ebp,0\n\t")
909 "movl %esp,%ebp\n\t"
910 __ASM_CFI(".cfi_def_cfa_register %ebp\n\t")
911 "subl $8,%esp\n\t"
912 "pushl 24(%ebp)\n\t" /* lparam */
913 /* MJ's Help Diagnostic expects that %ecx contains the address to the rect. */
914 "movl 20(%ebp),%ecx\n\t" /* rect */
915 "pushl %ecx\n\t"
916 "pushl 16(%ebp)\n\t" /* hdc */
917 "pushl 12(%ebp)\n\t" /* monitor */
918 "movl 8(%ebp),%eax\n" /* proc */
919 "call *%eax\n\t"
920 "leave\n\t"
921 __ASM_CFI(".cfi_def_cfa %esp,4\n\t")
922 __ASM_CFI(".cfi_same_value %ebp\n\t")
923 "ret" )
924 #endif /* __i386__ */
925
926 BOOL WINAPI User32CallEnumDisplayMonitor( struct enum_display_monitor_params *params, ULONG size )
927 {
928 #ifdef __i386__
929 return enum_mon_callback_wrapper( params->proc, params->monitor, params->hdc,
930 &params->rect, params->lparam );
931 #else
932 return params->proc( params->monitor, params->hdc, &params->rect, params->lparam );
933 #endif
934 }
935
936 /***********************************************************************
937 * EnumDisplayDevicesA (USER32.@)
938 */
939 BOOL WINAPI EnumDisplayDevicesA( LPCSTR device, DWORD index, DISPLAY_DEVICEA *info, DWORD flags )
940 {
941 UNICODE_STRING deviceW;
942 DISPLAY_DEVICEW ddW;
943 BOOL ret;
944
945 if (device)
946 RtlCreateUnicodeStringFromAsciiz( &deviceW, device );
947 else
948 deviceW.Buffer = NULL;
949
950 ddW.cb = sizeof(ddW);
951 ret = EnumDisplayDevicesW( deviceW.Buffer, index, &ddW, flags );
952 RtlFreeUnicodeString( &deviceW );
953
954 if (!ret)
955 return ret;
956
957 WideCharToMultiByte( CP_ACP, 0, ddW.DeviceName, -1, info->DeviceName, sizeof(info->DeviceName), NULL, NULL );
958 WideCharToMultiByte( CP_ACP, 0, ddW.DeviceString, -1, info->DeviceString, sizeof(info->DeviceString), NULL, NULL );
959 info->StateFlags = ddW.StateFlags;
960
961 if (info->cb >= offsetof(DISPLAY_DEVICEA, DeviceID) + sizeof(info->DeviceID))
962 WideCharToMultiByte( CP_ACP, 0, ddW.DeviceID, -1, info->DeviceID, sizeof(info->DeviceID), NULL, NULL );
963 if (info->cb >= offsetof(DISPLAY_DEVICEA, DeviceKey) + sizeof(info->DeviceKey))
964 WideCharToMultiByte( CP_ACP, 0, ddW.DeviceKey, -1, info->DeviceKey, sizeof(info->DeviceKey), NULL, NULL );
965
966 return TRUE;
967 }
968
969 /***********************************************************************
970 * EnumDisplayDevicesW (USER32.@)
971 */
972 BOOL WINAPI EnumDisplayDevicesW( LPCWSTR device, DWORD index, DISPLAY_DEVICEW *info, DWORD flags )
973 {
974 UNICODE_STRING str;
975 RtlInitUnicodeString( &str, device );
976 return NT_SUCCESS(NtUserEnumDisplayDevices( &str, index, info, flags ));
977 }
978
979 /**********************************************************************
980 * GetAutoRotationState [USER32.@]
981 */
982 BOOL WINAPI GetAutoRotationState( AR_STATE *state )
983 {
984 TRACE("(%p)\n", state);
985
986 if (!state)
987 {
988 SetLastError(ERROR_INVALID_PARAMETER);
989 return FALSE;
990 }
991
992 *state = AR_NOSENSOR;
993 return TRUE;
994 }
995
996 /**********************************************************************
997 * GetDisplayAutoRotationPreferences [USER32.@]
998 */
999 BOOL WINAPI GetDisplayAutoRotationPreferences( ORIENTATION_PREFERENCE *orientation )
1000 {
1001 FIXME("(%p): stub\n", orientation);
1002 *orientation = ORIENTATION_PREFERENCE_NONE;
1003 return TRUE;
1004 }
1005
1006 /* physical<->logical mapping functions from win8 that are nops in later versions */
1007
1008 /***********************************************************************
1009 * GetPhysicalCursorPos (USER32.@)
1010 */
1011 BOOL WINAPI GetPhysicalCursorPos( POINT *point )
1012 {
1013 return GetCursorPos( point );
1014 }
1015
1016 /***********************************************************************
1017 * SetPhysicalCursorPos (USER32.@)
1018 */
1019 BOOL WINAPI SetPhysicalCursorPos( INT x, INT y )
1020 {
1021 return NtUserSetCursorPos( x, y );
1022 }
1023
1024 /***********************************************************************
1025 * WindowFromPhysicalPoint (USER32.@)
1026 */
1027 HWND WINAPI WindowFromPhysicalPoint( POINT pt )
1028 {
1029 return WindowFromPoint( pt );
1030 }
1031
1032 /***********************************************************************
1033 * LogicalToPhysicalPoint (USER32.@)
1034 */
1035 BOOL WINAPI LogicalToPhysicalPoint( HWND hwnd, POINT *point )
1036 {
1037 return TRUE;
1038 }
1039
1040 /***********************************************************************
1041 * PhysicalToLogicalPoint (USER32.@)
1042 */
1043 BOOL WINAPI PhysicalToLogicalPoint( HWND hwnd, POINT *point )
1044 {
1045 return TRUE;
1046 }
1047
1048 static DISPLAYCONFIG_ROTATION get_dc_rotation(const DEVMODEW *devmode)
1049 {
1050 if (devmode->dmFields & DM_DISPLAYORIENTATION)
1051 return devmode->dmDisplayOrientation + 1;
1052 else
1053 return DISPLAYCONFIG_ROTATION_IDENTITY;
1054 }
1055
1056 static DISPLAYCONFIG_SCANLINE_ORDERING get_dc_scanline_ordering(const DEVMODEW *devmode)
1057 {
1058 if (!(devmode->dmFields & DM_DISPLAYFLAGS))
1059 return DISPLAYCONFIG_SCANLINE_ORDERING_UNSPECIFIED;
1060 else if (devmode->dmDisplayFlags & DM_INTERLACED)
1061 return DISPLAYCONFIG_SCANLINE_ORDERING_INTERLACED;
1062 else
1063 return DISPLAYCONFIG_SCANLINE_ORDERING_PROGRESSIVE;
1064 }
1065
1066 static DISPLAYCONFIG_PIXELFORMAT get_dc_pixelformat(DWORD dmBitsPerPel)
1067 {
1068 if ((dmBitsPerPel == 8) || (dmBitsPerPel == 16) ||
1069 (dmBitsPerPel == 24) || (dmBitsPerPel == 32))
1070 return dmBitsPerPel / 8;
1071 else
1072 return DISPLAYCONFIG_PIXELFORMAT_NONGDI;
1073 }
1074
1075 static void set_mode_target_info(DISPLAYCONFIG_MODE_INFO *info, const LUID *gpu_luid, UINT32 target_id,
1076 UINT32 flags, const DEVMODEW *devmode)
1077 {
1078 DISPLAYCONFIG_TARGET_MODE *mode = &info->targetMode;
1079
1080 info->infoType = DISPLAYCONFIG_MODE_INFO_TYPE_TARGET;
1081 info->adapterId = *gpu_luid;
1082 info->id = target_id;
1083
1084 /* FIXME: Populate pixelRate/hSyncFreq/totalSize with real data */
1085 mode->targetVideoSignalInfo.pixelRate = devmode->dmDisplayFrequency * devmode->dmPelsWidth * devmode->dmPelsHeight;
1086 mode->targetVideoSignalInfo.hSyncFreq.Numerator = devmode->dmDisplayFrequency * devmode->dmPelsWidth;
1087 mode->targetVideoSignalInfo.hSyncFreq.Denominator = 1;
1088 mode->targetVideoSignalInfo.vSyncFreq.Numerator = devmode->dmDisplayFrequency;
1089 mode->targetVideoSignalInfo.vSyncFreq.Denominator = 1;
1090 mode->targetVideoSignalInfo.activeSize.cx = devmode->dmPelsWidth;
1091 mode->targetVideoSignalInfo.activeSize.cy = devmode->dmPelsHeight;
1092 if (flags & QDC_DATABASE_CURRENT)
1093 {
1094 mode->targetVideoSignalInfo.totalSize.cx = 0;
1095 mode->targetVideoSignalInfo.totalSize.cy = 0;
1096 }
1097 else
1098 {
1099 mode->targetVideoSignalInfo.totalSize.cx = devmode->dmPelsWidth;
1100 mode->targetVideoSignalInfo.totalSize.cy = devmode->dmPelsHeight;
1101 }
1102 mode->targetVideoSignalInfo.videoStandard = D3DKMDT_VSS_OTHER;
1103 mode->targetVideoSignalInfo.scanLineOrdering = get_dc_scanline_ordering(devmode);
1104 }
1105
1106 static void set_path_target_info(DISPLAYCONFIG_PATH_TARGET_INFO *info, const LUID *gpu_luid,
1107 UINT32 target_id, UINT32 mode_index, const DEVMODEW *devmode)
1108 {
1109 info->adapterId = *gpu_luid;
1110 info->id = target_id;
1111 info->modeInfoIdx = mode_index;
1112 info->outputTechnology = DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DISPLAYPORT_EXTERNAL;
1113 info->rotation = get_dc_rotation(devmode);
1114 info->scaling = DISPLAYCONFIG_SCALING_IDENTITY;
1115 info->refreshRate.Numerator = devmode->dmDisplayFrequency;
1116 info->refreshRate.Denominator = 1;
1117 info->scanLineOrdering = get_dc_scanline_ordering(devmode);
1118 info->targetAvailable = TRUE;
1119 info->statusFlags = DISPLAYCONFIG_TARGET_IN_USE;
1120 }
1121
1122 static void set_mode_source_info(DISPLAYCONFIG_MODE_INFO *info, const LUID *gpu_luid,
1123 UINT32 source_id, const DEVMODEW *devmode)
1124 {
1125 DISPLAYCONFIG_SOURCE_MODE *mode = &(info->sourceMode);
1126
1127 info->infoType = DISPLAYCONFIG_MODE_INFO_TYPE_SOURCE;
1128 info->adapterId = *gpu_luid;
1129 info->id = source_id;
1130
1131 mode->width = devmode->dmPelsWidth;
1132 mode->height = devmode->dmPelsHeight;
1133 mode->pixelFormat = get_dc_pixelformat(devmode->dmBitsPerPel);
1134 if (devmode->dmFields & DM_POSITION)
1135 {
1136 mode->position = devmode->dmPosition;
1137 }
1138 else
1139 {
1140 mode->position.x = 0;
1141 mode->position.y = 0;
1142 }
1143 }
1144
1145 static void set_path_source_info(DISPLAYCONFIG_PATH_SOURCE_INFO *info, const LUID *gpu_luid,
1146 UINT32 source_id, UINT32 mode_index)
1147 {
1148 info->adapterId = *gpu_luid;
1149 info->id = source_id;
1150 info->modeInfoIdx = mode_index;
1151 info->statusFlags = DISPLAYCONFIG_SOURCE_IN_USE;
1152 }
1153
1154 static BOOL source_mode_exists(const DISPLAYCONFIG_MODE_INFO *modeinfo, UINT32 num_modes,
1155 UINT32 source_id, UINT32 *found_mode_index)
1156 {
1157 UINT32 i;
1158
1159 for (i = 0; i < num_modes; i++)
1160 {
1161 if (modeinfo[i].infoType == DISPLAYCONFIG_MODE_INFO_TYPE_SOURCE &&
1162 modeinfo[i].id == source_id)
1163 {
1164 *found_mode_index = i;
1165 return TRUE;
1166 }
1167 }
1168 return FALSE;
1169 }
1170
1171 /***********************************************************************
1172 * QueryDisplayConfig (USER32.@)
1173 */
1174 LONG WINAPI QueryDisplayConfig(UINT32 flags, UINT32 *numpathelements, DISPLAYCONFIG_PATH_INFO *pathinfo,
1175 UINT32 *numinfoelements, DISPLAYCONFIG_MODE_INFO *modeinfo,
1176 DISPLAYCONFIG_TOPOLOGY_ID *topologyid)
1177 {
1178 LONG adapter_index, ret;
1179 HANDLE mutex;
1180 HDEVINFO devinfo;
1181 SP_DEVINFO_DATA device_data = {sizeof(device_data)};
1182 DWORD monitor_index = 0, state_flags, type;
1183 UINT32 output_id, source_mode_index, path_index = 0, mode_index = 0;
1184 LUID gpu_luid;
1185 WCHAR device_name[CCHDEVICENAME];
1186 DEVMODEW devmode;
1187
1188 FIXME("(%08x %p %p %p %p %p): semi-stub\n", flags, numpathelements, pathinfo, numinfoelements, modeinfo, topologyid);
1189
1190 if (!numpathelements || !numinfoelements)
1191 return ERROR_INVALID_PARAMETER;
1192
1193 if (!*numpathelements || !*numinfoelements)
1194 return ERROR_INVALID_PARAMETER;
1195
1196 if (flags != QDC_ALL_PATHS &&
1197 flags != QDC_ONLY_ACTIVE_PATHS &&
1198 flags != QDC_DATABASE_CURRENT)
1199 return ERROR_INVALID_PARAMETER;
1200
1201 if (((flags == QDC_DATABASE_CURRENT) && !topologyid) ||
1202 ((flags != QDC_DATABASE_CURRENT) && topologyid))
1203 return ERROR_INVALID_PARAMETER;
1204
1205 if (flags != QDC_ONLY_ACTIVE_PATHS)
1206 FIXME("only returning active paths\n");
1207
1208 if (topologyid)
1209 {
1210 FIXME("setting toplogyid to DISPLAYCONFIG_TOPOLOGY_INTERNAL\n");
1211 *topologyid = DISPLAYCONFIG_TOPOLOGY_INTERNAL;
1212 }
1213
1214 wait_graphics_driver_ready();
1215 mutex = get_display_device_init_mutex();
1216
1217 /* Iterate through "targets"/monitors.
1218 * Each target corresponds to a path, and each path corresponds to one or two unique modes.
1219 */
1220 devinfo = SetupDiGetClassDevsW(&GUID_DEVCLASS_MONITOR, L"DISPLAY", NULL, DIGCF_PRESENT);
1221 if (devinfo == INVALID_HANDLE_VALUE)
1222 {
1223 ret = ERROR_GEN_FAILURE;
1224 goto done;
1225 }
1226
1227 ret = ERROR_GEN_FAILURE;
1228 while (SetupDiEnumDeviceInfo(devinfo, monitor_index++, &device_data))
1229 {
1230 /* Only count active monitors */
1231 if (!SetupDiGetDevicePropertyW(devinfo, &device_data, &WINE_DEVPROPKEY_MONITOR_STATEFLAGS,
1232 &type, (BYTE *)&state_flags, sizeof(state_flags), NULL, 0))
1233 goto done;
1234 if (!(state_flags & DISPLAY_DEVICE_ACTIVE))
1235 continue;
1236
1237 if (!SetupDiGetDevicePropertyW(devinfo, &device_data, &DEVPROPKEY_MONITOR_GPU_LUID,
1238 &type, (BYTE *)&gpu_luid, sizeof(gpu_luid), NULL, 0))
1239 goto done;
1240
1241 if (!SetupDiGetDevicePropertyW(devinfo, &device_data, &DEVPROPKEY_MONITOR_OUTPUT_ID,
1242 &type, (BYTE *)&output_id, sizeof(output_id), NULL, 0))
1243 goto done;
1244
1245 if (!SetupDiGetDevicePropertyW(devinfo, &device_data, &WINE_DEVPROPKEY_MONITOR_ADAPTERNAME,
1246 &type, (BYTE *)device_name, sizeof(device_name), NULL, 0))
1247 goto done;
1248
1249 memset(&devmode, 0, sizeof(devmode));
1250 devmode.dmSize = sizeof(devmode);
1251 if (!EnumDisplaySettingsW(device_name, ENUM_CURRENT_SETTINGS, &devmode))
1252 goto done;
1253
1254 /* Extract the adapter index from device_name to use as the source ID */
1255 adapter_index = wcstol(device_name + lstrlenW(L"\\\\.\\DISPLAY"), NULL, 10);
1256 adapter_index--;
1257
1258 if (path_index == *numpathelements || mode_index == *numinfoelements)
1259 {
1260 ret = ERROR_INSUFFICIENT_BUFFER;
1261 goto done;
1262 }
1263
1264 pathinfo[path_index].flags = DISPLAYCONFIG_PATH_ACTIVE;
1265 set_mode_target_info(&modeinfo[mode_index], &gpu_luid, output_id, flags, &devmode);
1266 set_path_target_info(&(pathinfo[path_index].targetInfo), &gpu_luid, output_id, mode_index, &devmode);
1267
1268 mode_index++;
1269 if (mode_index == *numinfoelements)
1270 {
1271 ret = ERROR_INSUFFICIENT_BUFFER;
1272 goto done;
1273 }
1274
1275 /* Multiple targets can be driven by the same source, ensure a mode
1276 * hasn't already been added for this source.
1277 */
1278 if (!source_mode_exists(modeinfo, mode_index, adapter_index, &source_mode_index))
1279 {
1280 set_mode_source_info(&modeinfo[mode_index], &gpu_luid, adapter_index, &devmode);
1281 source_mode_index = mode_index;
1282 mode_index++;
1283 }
1284 set_path_source_info(&(pathinfo[path_index].sourceInfo), &gpu_luid, adapter_index, source_mode_index);
1285 path_index++;
1286 }
1287
1288 *numpathelements = path_index;
1289 *numinfoelements = mode_index;
1290 ret = ERROR_SUCCESS;
1291
1292 done:
1293 SetupDiDestroyDeviceInfoList(devinfo);
1294 release_display_device_init_mutex(mutex);
1295 return ret;
1296 }
1297
1298 /***********************************************************************
1299 * DisplayConfigGetDeviceInfo (USER32.@)
1300 */
1301 LONG WINAPI DisplayConfigGetDeviceInfo(DISPLAYCONFIG_DEVICE_INFO_HEADER *packet)
1302 {
1303 return RtlNtStatusToDosError(NtUserDisplayConfigGetDeviceInfo(packet));
1304 }
1305
1306 /***********************************************************************
1307 * SetDisplayConfig (USER32.@)
1308 */
1309 LONG WINAPI SetDisplayConfig(UINT32 path_info_count, DISPLAYCONFIG_PATH_INFO *path_info, UINT32 mode_info_count,
1310 DISPLAYCONFIG_MODE_INFO *mode_info, UINT32 flags)
1311 {
1312 FIXME("path_info_count %u, path_info %p, mode_info_count %u, mode_info %p, flags %#x stub.\n",
1313 path_info_count, path_info, mode_info_count, mode_info, flags);
1314
1315 return ERROR_SUCCESS;
1316 }
Windows API implementation