dlls/user32/sysparams.c

   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 "user_private.h"
  22 #include "controls.h"
  23 #include "wine/asm.h"
  24 #include "wine/debug.h"
  25
  26 WINE_DEFAULT_DEBUG_CHANNEL(system);
  27
  28
  29 static HDC display_dc;
  30 static CRITICAL_SECTION display_dc_section;
  31 static CRITICAL_SECTION_DEBUG critsect_debug =
  32 {
  33     0, 0, &display_dc_section,
  34     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
  35       0, 0, { (DWORD_PTR)(__FILE__ ": display_dc_section") }
  36 };
  37 static CRITICAL_SECTION display_dc_section = { &critsect_debug, -1 ,0, 0, 0, 0 };
  38
  39
  40 /* System parameters storage */
  41 static UINT system_dpi;
  42
  43 static void SYSPARAMS_LogFont32WTo32A( const LOGFONTW* font32W, LPLOGFONTA font32A )
  44 {
  45     font32A->lfHeight = font32W->lfHeight;
  46     font32A->lfWidth = font32W->lfWidth;
  47     font32A->lfEscapement = font32W->lfEscapement;
  48     font32A->lfOrientation = font32W->lfOrientation;
  49     font32A->lfWeight = font32W->lfWeight;
  50     font32A->lfItalic = font32W->lfItalic;
  51     font32A->lfUnderline = font32W->lfUnderline;
  52     font32A->lfStrikeOut = font32W->lfStrikeOut;
  53     font32A->lfCharSet = font32W->lfCharSet;
  54     font32A->lfOutPrecision = font32W->lfOutPrecision;
  55     font32A->lfClipPrecision = font32W->lfClipPrecision;
  56     font32A->lfQuality = font32W->lfQuality;
  57     font32A->lfPitchAndFamily = font32W->lfPitchAndFamily;
  58     WideCharToMultiByte( CP_ACP, 0, font32W->lfFaceName, -1, font32A->lfFaceName, LF_FACESIZE, NULL, NULL );
  59     font32A->lfFaceName[LF_FACESIZE-1] = 0;
  60 }
  61
  62 static void SYSPARAMS_LogFont32ATo32W( const LOGFONTA* font32A, LPLOGFONTW font32W )
  63 {
  64     font32W->lfHeight = font32A->lfHeight;
  65     font32W->lfWidth = font32A->lfWidth;
  66     font32W->lfEscapement = font32A->lfEscapement;
  67     font32W->lfOrientation = font32A->lfOrientation;
  68     font32W->lfWeight = font32A->lfWeight;
  69     font32W->lfItalic = font32A->lfItalic;
  70     font32W->lfUnderline = font32A->lfUnderline;
  71     font32W->lfStrikeOut = font32A->lfStrikeOut;
  72     font32W->lfCharSet = font32A->lfCharSet;
  73     font32W->lfOutPrecision = font32A->lfOutPrecision;
  74     font32W->lfClipPrecision = font32A->lfClipPrecision;
  75     font32W->lfQuality = font32A->lfQuality;
  76     font32W->lfPitchAndFamily = font32A->lfPitchAndFamily;
  77     MultiByteToWideChar( CP_ACP, 0, font32A->lfFaceName, -1, font32W->lfFaceName, LF_FACESIZE );
  78     font32W->lfFaceName[LF_FACESIZE-1] = 0;
  79 }
  80
  81 static void SYSPARAMS_NonClientMetrics32WTo32A( const NONCLIENTMETRICSW* lpnm32W, LPNONCLIENTMETRICSA lpnm32A )
  82 {
  83     lpnm32A->iBorderWidth       = lpnm32W->iBorderWidth;
  84     lpnm32A->iScrollWidth       = lpnm32W->iScrollWidth;
  85     lpnm32A->iScrollHeight      = lpnm32W->iScrollHeight;
  86     lpnm32A->iCaptionWidth      = lpnm32W->iCaptionWidth;
  87     lpnm32A->iCaptionHeight     = lpnm32W->iCaptionHeight;
  88     SYSPARAMS_LogFont32WTo32A(  &lpnm32W->lfCaptionFont,        &lpnm32A->lfCaptionFont );
  89     lpnm32A->iSmCaptionWidth    = lpnm32W->iSmCaptionWidth;
  90     lpnm32A->iSmCaptionHeight   = lpnm32W->iSmCaptionHeight;
  91     SYSPARAMS_LogFont32WTo32A( &lpnm32W->lfSmCaptionFont,       &lpnm32A->lfSmCaptionFont );
  92     lpnm32A->iMenuWidth         = lpnm32W->iMenuWidth;
  93     lpnm32A->iMenuHeight        = lpnm32W->iMenuHeight;
  94     SYSPARAMS_LogFont32WTo32A( &lpnm32W->lfMenuFont,            &lpnm32A->lfMenuFont );
  95     SYSPARAMS_LogFont32WTo32A( &lpnm32W->lfStatusFont,          &lpnm32A->lfStatusFont );
  96     SYSPARAMS_LogFont32WTo32A( &lpnm32W->lfMessageFont,         &lpnm32A->lfMessageFont );
  97     if (lpnm32A->cbSize > FIELD_OFFSET(NONCLIENTMETRICSA, iPaddedBorderWidth))
  98     {
  99         if (lpnm32W->cbSize > FIELD_OFFSET(NONCLIENTMETRICSW, iPaddedBorderWidth))
 100             lpnm32A->iPaddedBorderWidth = lpnm32W->iPaddedBorderWidth;
 101         else
 102             lpnm32A->iPaddedBorderWidth = 0;
 103     }
 104 }
 105
 106 static void SYSPARAMS_NonClientMetrics32ATo32W( const NONCLIENTMETRICSA* lpnm32A, LPNONCLIENTMETRICSW lpnm32W )
 107 {
 108     lpnm32W->iBorderWidth       = lpnm32A->iBorderWidth;
 109     lpnm32W->iScrollWidth       = lpnm32A->iScrollWidth;
 110     lpnm32W->iScrollHeight      = lpnm32A->iScrollHeight;
 111     lpnm32W->iCaptionWidth      = lpnm32A->iCaptionWidth;
 112     lpnm32W->iCaptionHeight     = lpnm32A->iCaptionHeight;
 113     SYSPARAMS_LogFont32ATo32W(  &lpnm32A->lfCaptionFont,        &lpnm32W->lfCaptionFont );
 114     lpnm32W->iSmCaptionWidth    = lpnm32A->iSmCaptionWidth;
 115     lpnm32W->iSmCaptionHeight   = lpnm32A->iSmCaptionHeight;
 116     SYSPARAMS_LogFont32ATo32W( &lpnm32A->lfSmCaptionFont,       &lpnm32W->lfSmCaptionFont );
 117     lpnm32W->iMenuWidth         = lpnm32A->iMenuWidth;
 118     lpnm32W->iMenuHeight        = lpnm32A->iMenuHeight;
 119     SYSPARAMS_LogFont32ATo32W( &lpnm32A->lfMenuFont,            &lpnm32W->lfMenuFont );
 120     SYSPARAMS_LogFont32ATo32W( &lpnm32A->lfStatusFont,          &lpnm32W->lfStatusFont );
 121     SYSPARAMS_LogFont32ATo32W( &lpnm32A->lfMessageFont,         &lpnm32W->lfMessageFont );
 122     if (lpnm32W->cbSize > FIELD_OFFSET(NONCLIENTMETRICSW, iPaddedBorderWidth))
 123     {
 124         if (lpnm32A->cbSize > FIELD_OFFSET(NONCLIENTMETRICSA, iPaddedBorderWidth))
 125             lpnm32W->iPaddedBorderWidth = lpnm32A->iPaddedBorderWidth;
 126         else
 127             lpnm32W->iPaddedBorderWidth = 0;
 128     }
 129 }
 130
 131
 132 /* Helper functions to retrieve monitors info */
 133
 134 HDC get_display_dc(void)
 135 {
 136     EnterCriticalSection( &display_dc_section );
 137     if (!display_dc)
 138     {
 139         HDC dc;
 140
 141         LeaveCriticalSection( &display_dc_section );
 142         dc = CreateDCW( L"DISPLAY", NULL, NULL, NULL );
 143         EnterCriticalSection( &display_dc_section );
 144         if (display_dc)
 145             DeleteDC(dc);
 146         else
 147             display_dc = dc;
 148     }
 149     return display_dc;
 150 }
 151
 152 void release_display_dc( HDC hdc )
 153 {
 154     LeaveCriticalSection( &display_dc_section );
 155 }
 156
 157 /***********************************************************************
 158  *           SYSPARAMS_Init
 159  */
 160 void SYSPARAMS_Init(void)
 161 {
 162     system_dpi = NtUserGetSystemDpiForProcess( NULL );
 163 }
 164
 165 static BOOL update_desktop_wallpaper(void)
 166 {
 167     DWORD pid;
 168
 169     if (GetWindowThreadProcessId( GetDesktopWindow(), &pid ) && pid == GetCurrentProcessId())
 170     {
 171         WCHAR wallpaper[MAX_PATH], pattern[256];
 172
 173         if (NtUserSystemParametersInfo( SPI_GETDESKWALLPAPER, ARRAYSIZE(wallpaper), wallpaper, 0 ) &&
 174             NtUserCallOneParam( (ULONG_PTR)pattern, NtUserGetDeskPattern ))
 175         {
 176             update_wallpaper( wallpaper, pattern );
 177         }
 178     }
 179     else SendMessageW( GetDesktopWindow(), WM_SETTINGCHANGE, SPI_SETDESKWALLPAPER, 0 );
 180     return TRUE;
 181 }
 182
 183
 184 /***********************************************************************
 185  *              SystemParametersInfoForDpi (USER32.@)
 186  */
 187 BOOL WINAPI SystemParametersInfoForDpi( UINT action, UINT val, PVOID ptr, UINT winini, UINT dpi )
 188 {
 189     BOOL ret = NtUserSystemParametersInfoForDpi( action, val, ptr, winini, dpi );
 190     if (ret && (action == SPI_SETDESKWALLPAPER || action == SPI_SETDESKPATTERN))
 191         ret = update_desktop_wallpaper();
 192     return ret;
 193 }
 194
 195
 196 /***********************************************************************
 197  *              SystemParametersInfoW (USER32.@)
 198  */
 199 BOOL WINAPI SystemParametersInfoW( UINT action, UINT val, void *ptr, UINT winini )
 200 {
 201     BOOL ret = NtUserSystemParametersInfo( action, val, ptr, winini );
 202     if (ret && (action == SPI_SETDESKWALLPAPER || action == SPI_SETDESKPATTERN))
 203         ret = update_desktop_wallpaper();
 204     return ret;
 205 }
 206
 207
 208 /***********************************************************************
 209  *              SystemParametersInfoA (USER32.@)
 210  */
 211 BOOL WINAPI SystemParametersInfoA( UINT uiAction, UINT uiParam,
 212                                    PVOID pvParam, UINT fuWinIni )
 213 {
 214     BOOL ret;
 215
 216     TRACE("(%u, %u, %p, %u)\n", uiAction, uiParam, pvParam, fuWinIni);
 217
 218     switch (uiAction)
 219     {
 220     case SPI_SETDESKWALLPAPER:                  /*     20 */
 221     case SPI_SETDESKPATTERN:                    /*     21 */
 222     {
 223         WCHAR buffer[256];
 224         if (pvParam)
 225             if (!MultiByteToWideChar( CP_ACP, 0, pvParam, -1, buffer, ARRAY_SIZE( buffer )))
 226                 buffer[ARRAY_SIZE(buffer)-1] = 0;
 227         ret = SystemParametersInfoW( uiAction, uiParam, pvParam ? buffer : NULL, fuWinIni );
 228         break;
 229     }
 230
 231     case SPI_GETICONTITLELOGFONT:               /*     31 */
 232     {
 233         LOGFONTW tmp;
 234         ret = SystemParametersInfoW( uiAction, uiParam, pvParam ? &tmp : NULL, fuWinIni );
 235         if (ret && pvParam)
 236             SYSPARAMS_LogFont32WTo32A( &tmp, pvParam );
 237         break;
 238     }
 239
 240     case SPI_GETNONCLIENTMETRICS:               /*     41  WINVER >= 0x400 */
 241     {
 242         NONCLIENTMETRICSW tmp;
 243         LPNONCLIENTMETRICSA lpnmA = pvParam;
 244         if (lpnmA && (lpnmA->cbSize == sizeof(NONCLIENTMETRICSA) ||
 245                       lpnmA->cbSize == FIELD_OFFSET(NONCLIENTMETRICSA, iPaddedBorderWidth)))
 246         {
 247             tmp.cbSize = sizeof(NONCLIENTMETRICSW);
 248             ret = SystemParametersInfoW( uiAction, uiParam, &tmp, fuWinIni );
 249             if (ret)
 250                 SYSPARAMS_NonClientMetrics32WTo32A( &tmp, lpnmA );
 251         }
 252         else
 253             ret = FALSE;
 254         break;
 255     }
 256
 257     case SPI_SETNONCLIENTMETRICS:               /*     42  WINVER >= 0x400 */
 258     {
 259         NONCLIENTMETRICSW tmp;
 260         LPNONCLIENTMETRICSA lpnmA = pvParam;
 261         if (lpnmA && (lpnmA->cbSize == sizeof(NONCLIENTMETRICSA) ||
 262                       lpnmA->cbSize == FIELD_OFFSET(NONCLIENTMETRICSA, iPaddedBorderWidth)))
 263         {
 264             tmp.cbSize = sizeof(NONCLIENTMETRICSW);
 265             SYSPARAMS_NonClientMetrics32ATo32W( lpnmA, &tmp );
 266             ret = SystemParametersInfoW( uiAction, uiParam, &tmp, fuWinIni );
 267         }
 268         else
 269             ret = FALSE;
 270         break;
 271     }
 272
 273     case SPI_GETICONMETRICS:                    /*     45  WINVER >= 0x400 */
 274     {
 275         ICONMETRICSW tmp;
 276         LPICONMETRICSA lpimA = pvParam;
 277         if (lpimA && lpimA->cbSize == sizeof(ICONMETRICSA))
 278         {
 279             tmp.cbSize = sizeof(ICONMETRICSW);
 280             ret = SystemParametersInfoW( uiAction, uiParam, &tmp, fuWinIni );
 281             if (ret)
 282             {
 283                 lpimA->iHorzSpacing = tmp.iHorzSpacing;
 284                 lpimA->iVertSpacing = tmp.iVertSpacing;
 285                 lpimA->iTitleWrap   = tmp.iTitleWrap;
 286                 SYSPARAMS_LogFont32WTo32A( &tmp.lfFont, &lpimA->lfFont );
 287             }
 288         }
 289         else
 290             ret = FALSE;
 291         break;
 292     }
 293
 294     case SPI_SETICONMETRICS:                    /*     46  WINVER >= 0x400 */
 295     {
 296         ICONMETRICSW tmp;
 297         LPICONMETRICSA lpimA = pvParam;
 298         if (lpimA && lpimA->cbSize == sizeof(ICONMETRICSA))
 299         {
 300             tmp.cbSize = sizeof(ICONMETRICSW);
 301             tmp.iHorzSpacing = lpimA->iHorzSpacing;
 302             tmp.iVertSpacing = lpimA->iVertSpacing;
 303             tmp.iTitleWrap = lpimA->iTitleWrap;
 304             SYSPARAMS_LogFont32ATo32W(  &lpimA->lfFont, &tmp.lfFont);
 305             ret = SystemParametersInfoW( uiAction, uiParam, &tmp, fuWinIni );
 306         }
 307         else
 308             ret = FALSE;
 309         break;
 310     }
 311
 312     case SPI_GETHIGHCONTRAST:                   /*     66  WINVER >= 0x400 */
 313     {
 314         HIGHCONTRASTW tmp;
 315         LPHIGHCONTRASTA lphcA = pvParam;
 316         if (lphcA && lphcA->cbSize == sizeof(HIGHCONTRASTA))
 317         {
 318             tmp.cbSize = sizeof(HIGHCONTRASTW);
 319             ret = SystemParametersInfoW( uiAction, uiParam, &tmp, fuWinIni );
 320             if (ret)
 321             {
 322                 lphcA->dwFlags = tmp.dwFlags;
 323                 lphcA->lpszDefaultScheme = NULL;  /* FIXME? */
 324             }
 325         }
 326         else
 327             ret = FALSE;
 328         break;
 329     }
 330
 331     case SPI_GETDESKWALLPAPER:                  /*     115 */
 332     {
 333         WCHAR buffer[MAX_PATH];
 334         ret = (SystemParametersInfoW( SPI_GETDESKWALLPAPER, uiParam, buffer, fuWinIni ) &&
 335                WideCharToMultiByte(CP_ACP, 0, buffer, -1, pvParam, uiParam, NULL, NULL));
 336         break;
 337     }
 338
 339     default:
 340         ret = SystemParametersInfoW( uiAction, uiParam, pvParam, fuWinIni );
 341         break;
 342     }
 343     return ret;
 344 }
 345
 346
 347 /***********************************************************************
 348  *              GetSystemMetrics (USER32.@)
 349  */
 350 INT WINAPI GetSystemMetrics( INT index )
 351 {
 352     return NtUserGetSystemMetrics( index );
 353 }
 354
 355
 356 /***********************************************************************
 357  *              GetSystemMetricsForDpi (USER32.@)
 358  */
 359 INT WINAPI GetSystemMetricsForDpi( INT index, UINT dpi )
 360 {
 361     return NtUserGetSystemMetricsForDpi( index, dpi );
 362 }
 363
 364
 365 /***********************************************************************
 366  *              SwapMouseButton (USER32.@)
 367  *  Reverse or restore the meaning of the left and right mouse buttons
 368  *  fSwap  [I ] TRUE - reverse, FALSE - original
 369  * RETURN
 370  *   previous state
 371  */
 372 BOOL WINAPI SwapMouseButton( BOOL fSwap )
 373 {
 374     BOOL prev = GetSystemMetrics(SM_SWAPBUTTON);
 375     SystemParametersInfoW(SPI_SETMOUSEBUTTONSWAP, fSwap, 0, 0);
 376     return prev;
 377 }
 378
 379
 380 /**********************************************************************
 381  *              SetDoubleClickTime (USER32.@)
 382  */
 383 BOOL WINAPI SetDoubleClickTime( UINT interval )
 384 {
 385     return SystemParametersInfoW(SPI_SETDOUBLECLICKTIME, interval, 0, 0);
 386 }
 387
 388
 389 /*************************************************************************
 390  *              GetSysColor (USER32.@)
 391  */
 392 COLORREF WINAPI DECLSPEC_HOTPATCH GetSysColor( INT index )
 393 {
 394     return NtUserGetSysColor( index );
 395 }
 396
 397
 398 /*************************************************************************
 399  *              SetSysColorsTemp (USER32.@)
 400  */
 401 DWORD_PTR WINAPI SetSysColorsTemp( const COLORREF *pPens, const HBRUSH *pBrushes, DWORD_PTR n)
 402 {
 403     FIXME( "no longer supported\n" );
 404     return FALSE;
 405 }
 406
 407
 408 /***********************************************************************
 409  *              GetSysColorBrush (USER32.@)
 410  */
 411 HBRUSH WINAPI DECLSPEC_HOTPATCH GetSysColorBrush( INT index )
 412 {
 413     return NtUserGetSysColorBrush( index );
 414 }
 415
 416
 417 /***********************************************************************
 418  *              SYSCOLOR_GetPen
 419  */
 420 HPEN SYSCOLOR_GetPen( INT index )
 421 {
 422     return NtUserGetSysColorPen( index );
 423 }
 424
 425
 426 /***********************************************************************
 427  *              SYSCOLOR_Get55AABrush
 428  */
 429 HBRUSH SYSCOLOR_Get55AABrush(void)
 430 {
 431     return NtUserGetSysColorBrush( COLOR_55AA_BRUSH );
 432 }
 433
 434 /***********************************************************************
 435  *              ChangeDisplaySettingsA (USER32.@)
 436  */
 437 LONG WINAPI ChangeDisplaySettingsA( LPDEVMODEA devmode, DWORD flags )
 438 {
 439     if (devmode) devmode->dmDriverExtra = 0;
 440
 441     return ChangeDisplaySettingsExA(NULL,devmode,NULL,flags,NULL);
 442 }
 443
 444
 445 /***********************************************************************
 446  *              ChangeDisplaySettingsW (USER32.@)
 447  */
 448 LONG WINAPI ChangeDisplaySettingsW( LPDEVMODEW devmode, DWORD flags )
 449 {
 450     if (devmode) devmode->dmDriverExtra = 0;
 451
 452     return ChangeDisplaySettingsExW(NULL,devmode,NULL,flags,NULL);
 453 }
 454
 455
 456 /***********************************************************************
 457  *              ChangeDisplaySettingsExA (USER32.@)
 458  */
 459 LONG WINAPI ChangeDisplaySettingsExA( LPCSTR devname, LPDEVMODEA devmode, HWND hwnd,
 460                                       DWORD flags, LPVOID lparam )
 461 {
 462     LONG ret;
 463     UNICODE_STRING nameW;
 464
 465     if (devname) RtlCreateUnicodeStringFromAsciiz(&nameW, devname);
 466     else nameW.Buffer = NULL;
 467
 468     if (devmode)
 469     {
 470         DEVMODEW *devmodeW;
 471
 472         devmodeW = GdiConvertToDevmodeW(devmode);
 473         if (devmodeW)
 474         {
 475             ret = ChangeDisplaySettingsExW(nameW.Buffer, devmodeW, hwnd, flags, lparam);
 476             HeapFree(GetProcessHeap(), 0, devmodeW);
 477         }
 478         else
 479             ret = DISP_CHANGE_SUCCESSFUL;
 480     }
 481     else
 482     {
 483         ret = ChangeDisplaySettingsExW(nameW.Buffer, NULL, hwnd, flags, lparam);
 484     }
 485
 486     if (devname) RtlFreeUnicodeString(&nameW);
 487     return ret;
 488 }
 489
 490
 491 /***********************************************************************
 492  *              ChangeDisplaySettingsExW (USER32.@)
 493  */
 494 LONG WINAPI ChangeDisplaySettingsExW( LPCWSTR devname, LPDEVMODEW devmode, HWND hwnd,
 495                                       DWORD flags, LPVOID lparam )
 496 {
 497     UNICODE_STRING str;
 498     RtlInitUnicodeString( &str, devname );
 499     return NtUserChangeDisplaySettings( &str, devmode, hwnd, flags, lparam );
 500 }
 501
 502
 503 /***********************************************************************
 504  *              EnumDisplaySettingsW (USER32.@)
 505  *
 506  * RETURNS
 507  *      TRUE if nth setting exists found (described in the LPDEVMODEW struct)
 508  *      FALSE if we do not have the nth setting
 509  */
 510 BOOL WINAPI EnumDisplaySettingsW( LPCWSTR name, DWORD n, LPDEVMODEW devmode )
 511 {
 512     return EnumDisplaySettingsExW(name, n, devmode, 0);
 513 }
 514
 515
 516 /***********************************************************************
 517  *              EnumDisplaySettingsA (USER32.@)
 518  */
 519 BOOL WINAPI EnumDisplaySettingsA(LPCSTR name,DWORD n,LPDEVMODEA devmode)
 520 {
 521     return EnumDisplaySettingsExA(name, n, devmode, 0);
 522 }
 523
 524
 525 /***********************************************************************
 526  *              EnumDisplaySettingsExA (USER32.@)
 527  */
 528 BOOL WINAPI EnumDisplaySettingsExA(LPCSTR lpszDeviceName, DWORD iModeNum,
 529                                    LPDEVMODEA lpDevMode, DWORD dwFlags)
 530 {
 531     DEVMODEW devmodeW;
 532     BOOL ret;
 533     UNICODE_STRING nameW;
 534
 535     if (lpszDeviceName) RtlCreateUnicodeStringFromAsciiz(&nameW, lpszDeviceName);
 536     else nameW.Buffer = NULL;
 537
 538     memset(&devmodeW, 0, sizeof(devmodeW));
 539     devmodeW.dmSize = sizeof(devmodeW);
 540     ret = EnumDisplaySettingsExW(nameW.Buffer,iModeNum,&devmodeW,dwFlags);
 541     if (ret)
 542     {
 543         lpDevMode->dmSize = FIELD_OFFSET(DEVMODEA, dmICMMethod);
 544         lpDevMode->dmSpecVersion = devmodeW.dmSpecVersion;
 545         lpDevMode->dmDriverVersion = devmodeW.dmDriverVersion;
 546         WideCharToMultiByte(CP_ACP, 0, devmodeW.dmDeviceName, -1,
 547                             (LPSTR)lpDevMode->dmDeviceName, CCHDEVICENAME, NULL, NULL);
 548         lpDevMode->dmDriverExtra      = 0; /* FIXME */
 549         lpDevMode->dmBitsPerPel       = devmodeW.dmBitsPerPel;
 550         lpDevMode->dmPelsHeight       = devmodeW.dmPelsHeight;
 551         lpDevMode->dmPelsWidth        = devmodeW.dmPelsWidth;
 552         lpDevMode->dmDisplayFlags  = devmodeW.dmDisplayFlags;
 553         lpDevMode->dmDisplayFrequency = devmodeW.dmDisplayFrequency;
 554         lpDevMode->dmFields           = devmodeW.dmFields;
 555
 556         lpDevMode->dmPosition.x = devmodeW.dmPosition.x;
 557         lpDevMode->dmPosition.y = devmodeW.dmPosition.y;
 558         lpDevMode->dmDisplayOrientation = devmodeW.dmDisplayOrientation;
 559         lpDevMode->dmDisplayFixedOutput = devmodeW.dmDisplayFixedOutput;
 560     }
 561     if (lpszDeviceName) RtlFreeUnicodeString(&nameW);
 562     return ret;
 563 }
 564
 565
 566 /***********************************************************************
 567  *             EnumDisplaySettingsExW (USER32.@)
 568  */
 569 BOOL WINAPI EnumDisplaySettingsExW( const WCHAR *device, DWORD mode,
 570                                     DEVMODEW *dev_mode, DWORD flags )
 571 {
 572     UNICODE_STRING str;
 573     RtlInitUnicodeString( &str, device );
 574     return NtUserEnumDisplaySettings( &str, mode, dev_mode, flags );
 575 }
 576
 577 /**********************************************************************
 578  *              SetProcessDpiAwarenessContext   (USER32.@)
 579  */
 580 BOOL WINAPI SetProcessDpiAwarenessContext( DPI_AWARENESS_CONTEXT context )
 581 {
 582     ULONG awareness;
 583
 584     switch (GetAwarenessFromDpiAwarenessContext( context ))
 585     {
 586     case DPI_AWARENESS_UNAWARE:
 587         awareness = NTUSER_DPI_UNAWARE;
 588         break;
 589     case DPI_AWARENESS_SYSTEM_AWARE:
 590         awareness = NTUSER_DPI_SYSTEM_AWARE;
 591         break;
 592     case DPI_AWARENESS_PER_MONITOR_AWARE:
 593         awareness = context == DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2
 594             ? NTUSER_DPI_PER_MONITOR_AWARE_V2 : NTUSER_DPI_PER_MONITOR_AWARE;
 595         break;
 596     default:
 597         SetLastError( ERROR_INVALID_PARAMETER );
 598         return FALSE;
 599     }
 600
 601     if (!NtUserSetProcessDpiAwarenessContext( awareness, 0 ))
 602     {
 603         SetLastError( ERROR_ACCESS_DENIED );
 604         return FALSE;
 605     }
 606
 607     TRACE( "set to %p\n", context );
 608     return TRUE;
 609 }
 610
 611 /**********************************************************************
 612  *              GetProcessDpiAwarenessInternal   (USER32.@)
 613  */
 614 BOOL WINAPI GetProcessDpiAwarenessInternal( HANDLE process, DPI_AWARENESS *awareness )
 615 {
 616     *awareness = NtUserGetProcessDpiAwarenessContext( process ) & 3;
 617     return TRUE;
 618 }
 619
 620 /**********************************************************************
 621  *              SetProcessDpiAwarenessInternal   (USER32.@)
 622  */
 623 BOOL WINAPI SetProcessDpiAwarenessInternal( DPI_AWARENESS awareness )
 624 {
 625     static const DPI_AWARENESS_CONTEXT contexts[3] = { DPI_AWARENESS_CONTEXT_UNAWARE,
 626                                                        DPI_AWARENESS_CONTEXT_SYSTEM_AWARE,
 627                                                        DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE };
 628
 629     if (awareness < DPI_AWARENESS_UNAWARE || awareness > DPI_AWARENESS_PER_MONITOR_AWARE)
 630     {
 631         SetLastError( ERROR_INVALID_PARAMETER );
 632         return FALSE;
 633     }
 634     return SetProcessDpiAwarenessContext( contexts[awareness] );
 635 }
 636
 637 /***********************************************************************
 638  *              AreDpiAwarenessContextsEqual   (USER32.@)
 639  */
 640 BOOL WINAPI AreDpiAwarenessContextsEqual( DPI_AWARENESS_CONTEXT ctx1, DPI_AWARENESS_CONTEXT ctx2 )
 641 {
 642     DPI_AWARENESS aware1 = GetAwarenessFromDpiAwarenessContext( ctx1 );
 643     DPI_AWARENESS aware2 = GetAwarenessFromDpiAwarenessContext( ctx2 );
 644     return aware1 != DPI_AWARENESS_INVALID && aware1 == aware2;
 645 }
 646
 647 /***********************************************************************
 648  *              GetAwarenessFromDpiAwarenessContext   (USER32.@)
 649  */
 650 DPI_AWARENESS WINAPI GetAwarenessFromDpiAwarenessContext( DPI_AWARENESS_CONTEXT context )
 651 {
 652     switch ((ULONG_PTR)context)
 653     {
 654     case 0x10:
 655     case 0x11:
 656     case 0x12:
 657     case 0x80000010:
 658     case 0x80000011:
 659     case 0x80000012:
 660         return (ULONG_PTR)context & 3;
 661     case (ULONG_PTR)DPI_AWARENESS_CONTEXT_UNAWARE:
 662     case (ULONG_PTR)DPI_AWARENESS_CONTEXT_SYSTEM_AWARE:
 663     case (ULONG_PTR)DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE:
 664         return ~(ULONG_PTR)context;
 665     default:
 666         return DPI_AWARENESS_INVALID;
 667     }
 668 }
 669
 670 /***********************************************************************
 671  *              IsValidDpiAwarenessContext   (USER32.@)
 672  */
 673 BOOL WINAPI IsValidDpiAwarenessContext( DPI_AWARENESS_CONTEXT context )
 674 {
 675     return GetAwarenessFromDpiAwarenessContext( context ) != DPI_AWARENESS_INVALID;
 676 }
 677
 678 /***********************************************************************
 679  *              SetProcessDPIAware   (USER32.@)
 680  */
 681 BOOL WINAPI SetProcessDPIAware(void)
 682 {
 683     TRACE("\n");
 684     NtUserSetProcessDpiAwarenessContext( NTUSER_DPI_SYSTEM_AWARE, 0 );
 685     return TRUE;
 686 }
 687
 688 /***********************************************************************
 689  *              IsProcessDPIAware   (USER32.@)
 690  */
 691 BOOL WINAPI IsProcessDPIAware(void)
 692 {
 693     return GetAwarenessFromDpiAwarenessContext( GetThreadDpiAwarenessContext() ) != DPI_AWARENESS_UNAWARE;
 694 }
 695
 696 /**********************************************************************
 697  *              EnableNonClientDpiScaling   (USER32.@)
 698  */
 699 BOOL WINAPI EnableNonClientDpiScaling( HWND hwnd )
 700 {
 701     FIXME("(%p): stub\n", hwnd);
 702     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 703     return FALSE;
 704 }
 705
 706 /***********************************************************************
 707  *              GetDpiForSystem   (USER32.@)
 708  */
 709 UINT WINAPI GetDpiForSystem(void)
 710 {
 711     if (!IsProcessDPIAware()) return USER_DEFAULT_SCREEN_DPI;
 712     return system_dpi;
 713 }
 714
 715 /**********************************************************************
 716  *              GetThreadDpiAwarenessContext   (USER32.@)
 717  */
 718 DPI_AWARENESS_CONTEXT WINAPI GetThreadDpiAwarenessContext(void)
 719 {
 720     struct ntuser_thread_info *info = NtUserGetThreadInfo();
 721
 722     if (info->dpi_awareness) return ULongToHandle( info->dpi_awareness );
 723     return UlongToHandle( (NtUserGetProcessDpiAwarenessContext( GetCurrentProcess() ) & 3 ) | 0x10 );
 724 }
 725
 726 /**********************************************************************
 727  *              SetThreadDpiAwarenessContext   (USER32.@)
 728  */
 729 DPI_AWARENESS_CONTEXT WINAPI SetThreadDpiAwarenessContext( DPI_AWARENESS_CONTEXT context )
 730 {
 731     struct ntuser_thread_info *info = NtUserGetThreadInfo();
 732     DPI_AWARENESS prev, val = GetAwarenessFromDpiAwarenessContext( context );
 733
 734     if (val == DPI_AWARENESS_INVALID)
 735     {
 736         SetLastError( ERROR_INVALID_PARAMETER );
 737         return 0;
 738     }
 739     if (!(prev = info->dpi_awareness))
 740     {
 741         prev = NtUserGetProcessDpiAwarenessContext( GetCurrentProcess() ) & 3;
 742         prev |= 0x80000010;  /* restore to process default */
 743     }
 744     if (((ULONG_PTR)context & ~(ULONG_PTR)0x13) == 0x80000000) info->dpi_awareness = 0;
 745     else info->dpi_awareness = val | 0x10;
 746     return ULongToHandle( prev );
 747 }
 748
 749 /***********************************************************************
 750  *              MonitorFromRect (USER32.@)
 751  */
 752 HMONITOR WINAPI MonitorFromRect( const RECT *rect, DWORD flags )
 753 {
 754     return NtUserMonitorFromRect( rect, flags );
 755 }
 756
 757 /***********************************************************************
 758  *              MonitorFromPoint (USER32.@)
 759  */
 760 HMONITOR WINAPI MonitorFromPoint( POINT pt, DWORD flags )
 761 {
 762     RECT rect;
 763
 764     SetRect( &rect, pt.x, pt.y, pt.x + 1, pt.y + 1 );
 765     return MonitorFromRect( &rect, flags );
 766 }
 767
 768 /***********************************************************************
 769  *              MonitorFromWindow (USER32.@)
 770  */
 771 HMONITOR WINAPI MonitorFromWindow( HWND hwnd, DWORD flags )
 772 {
 773     return NtUserMonitorFromWindow( hwnd, flags );
 774 }
 775
 776 /***********************************************************************
 777  *              GetMonitorInfoA (USER32.@)
 778  */
 779 BOOL WINAPI GetMonitorInfoA( HMONITOR monitor, LPMONITORINFO info )
 780 {
 781     MONITORINFOEXW miW;
 782     BOOL ret;
 783
 784     if (info->cbSize == sizeof(MONITORINFO)) return GetMonitorInfoW( monitor, info );
 785     if (info->cbSize != sizeof(MONITORINFOEXA)) return FALSE;
 786
 787     miW.cbSize = sizeof(miW);
 788     ret = GetMonitorInfoW( monitor, (MONITORINFO *)&miW );
 789     if (ret)
 790     {
 791         MONITORINFOEXA *miA = (MONITORINFOEXA *)info;
 792         miA->rcMonitor = miW.rcMonitor;
 793         miA->rcWork = miW.rcWork;
 794         miA->dwFlags = miW.dwFlags;
 795         WideCharToMultiByte(CP_ACP, 0, miW.szDevice, -1, miA->szDevice, sizeof(miA->szDevice), NULL, NULL);
 796     }
 797     return ret;
 798 }
 799
 800 /***********************************************************************
 801  *              GetMonitorInfoW (USER32.@)
 802  */
 803 BOOL WINAPI GetMonitorInfoW( HMONITOR monitor, LPMONITORINFO info )
 804 {
 805     return NtUserGetMonitorInfo( monitor, info );
 806 }
 807
 808 #ifdef __i386__
 809 /* Some apps pass a non-stdcall callback to EnumDisplayMonitors,
 810  * so we need a small assembly wrapper to call it.
 811  */
 812 extern BOOL enum_mon_callback_wrapper( void *proc, HMONITOR monitor, HDC hdc, RECT *rect, LPARAM lparam );
 813 __ASM_GLOBAL_FUNC( enum_mon_callback_wrapper,
 814     "pushl %ebp\n\t"
 815     __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
 816     __ASM_CFI(".cfi_rel_offset %ebp,0\n\t")
 817     "movl %esp,%ebp\n\t"
 818     __ASM_CFI(".cfi_def_cfa_register %ebp\n\t")
 819     "subl $8,%esp\n\t"
 820     "pushl 24(%ebp)\n\t"        /* lparam */
 821     /* MJ's Help Diagnostic expects that %ecx contains the address to the rect. */
 822     "movl 20(%ebp),%ecx\n\t"    /* rect */
 823     "pushl %ecx\n\t"
 824     "pushl 16(%ebp)\n\t"        /* hdc */
 825     "pushl 12(%ebp)\n\t"        /* monitor */
 826     "movl 8(%ebp),%eax\n"       /* proc */
 827     "call *%eax\n\t"
 828     "leave\n\t"
 829     __ASM_CFI(".cfi_def_cfa %esp,4\n\t")
 830     __ASM_CFI(".cfi_same_value %ebp\n\t")
 831     "ret" )
 832 #endif /* __i386__ */
 833
 834 BOOL WINAPI User32CallEnumDisplayMonitor( struct enum_display_monitor_params *params, ULONG size )
 835 {
 836 #ifdef __i386__
 837     return enum_mon_callback_wrapper( params->proc, params->monitor, params->hdc,
 838                                       &params->rect, params->lparam );
 839 #else
 840     return params->proc( params->monitor, params->hdc, &params->rect, params->lparam );
 841 #endif
 842 }
 843
 844 /***********************************************************************
 845  *              EnumDisplayDevicesA (USER32.@)
 846  */
 847 BOOL WINAPI EnumDisplayDevicesA( LPCSTR device, DWORD index, DISPLAY_DEVICEA *info, DWORD flags )
 848 {
 849     UNICODE_STRING deviceW;
 850     DISPLAY_DEVICEW ddW;
 851     BOOL ret;
 852
 853     if (device)
 854         RtlCreateUnicodeStringFromAsciiz( &deviceW, device );
 855     else
 856         deviceW.Buffer = NULL;
 857
 858     ddW.cb = sizeof(ddW);
 859     ret = EnumDisplayDevicesW( deviceW.Buffer, index, &ddW, flags );
 860     RtlFreeUnicodeString( &deviceW );
 861
 862     if (!ret)
 863         return ret;
 864
 865     WideCharToMultiByte( CP_ACP, 0, ddW.DeviceName, -1, info->DeviceName, sizeof(info->DeviceName), NULL, NULL );
 866     WideCharToMultiByte( CP_ACP, 0, ddW.DeviceString, -1, info->DeviceString, sizeof(info->DeviceString), NULL, NULL );
 867     info->StateFlags = ddW.StateFlags;
 868
 869     if (info->cb >= offsetof(DISPLAY_DEVICEA, DeviceID) + sizeof(info->DeviceID))
 870         WideCharToMultiByte( CP_ACP, 0, ddW.DeviceID, -1, info->DeviceID, sizeof(info->DeviceID), NULL, NULL );
 871     if (info->cb >= offsetof(DISPLAY_DEVICEA, DeviceKey) + sizeof(info->DeviceKey))
 872         WideCharToMultiByte( CP_ACP, 0, ddW.DeviceKey, -1, info->DeviceKey, sizeof(info->DeviceKey), NULL, NULL );
 873
 874     return TRUE;
 875 }
 876
 877 /***********************************************************************
 878  *              EnumDisplayDevicesW (USER32.@)
 879  */
 880 BOOL WINAPI EnumDisplayDevicesW( LPCWSTR device, DWORD index, DISPLAY_DEVICEW *info, DWORD flags )
 881 {
 882     UNICODE_STRING str;
 883     RtlInitUnicodeString( &str, device );
 884     return NT_SUCCESS(NtUserEnumDisplayDevices( &str, index, info, flags ));
 885 }
 886
 887 /**********************************************************************
 888  *              GetAutoRotationState [USER32.@]
 889  */
 890 BOOL WINAPI GetAutoRotationState( AR_STATE *state )
 891 {
 892     TRACE("(%p)\n", state);
 893
 894     if (!state)
 895     {
 896         SetLastError(ERROR_INVALID_PARAMETER);
 897         return FALSE;
 898     }
 899
 900     *state = AR_NOSENSOR;
 901     return TRUE;
 902 }
 903
 904 /**********************************************************************
 905  *              GetDisplayAutoRotationPreferences [USER32.@]
 906  */
 907 BOOL WINAPI GetDisplayAutoRotationPreferences( ORIENTATION_PREFERENCE *orientation )
 908 {
 909     FIXME("(%p): stub\n", orientation);
 910     *orientation = ORIENTATION_PREFERENCE_NONE;
 911     return TRUE;
 912 }
 913
 914 /* physical<->logical mapping functions from win8 that are nops in later versions */
 915
 916 /***********************************************************************
 917  *              GetPhysicalCursorPos   (USER32.@)
 918  */
 919 BOOL WINAPI GetPhysicalCursorPos( POINT *point )
 920 {
 921     return GetCursorPos( point );
 922 }
 923
 924 /***********************************************************************
 925  *              SetPhysicalCursorPos   (USER32.@)
 926  */
 927 BOOL WINAPI SetPhysicalCursorPos( INT x, INT y )
 928 {
 929     return NtUserSetCursorPos( x, y );
 930 }
 931
 932 /***********************************************************************
 933  *              WindowFromPhysicalPoint (USER32.@)
 934  */
 935 HWND WINAPI WindowFromPhysicalPoint( POINT pt )
 936 {
 937     return WindowFromPoint( pt );
 938 }
 939
 940 /***********************************************************************
 941  *              LogicalToPhysicalPoint (USER32.@)
 942  */
 943 BOOL WINAPI LogicalToPhysicalPoint( HWND hwnd, POINT *point )
 944 {
 945     return TRUE;
 946 }
 947
 948 /***********************************************************************
 949  *              PhysicalToLogicalPoint (USER32.@)
 950  */
 951 BOOL WINAPI PhysicalToLogicalPoint( HWND hwnd, POINT *point )
 952 {
 953     return TRUE;
 954 }
 955
 956 /***********************************************************************
 957  *              DisplayConfigGetDeviceInfo (USER32.@)
 958  */
 959 LONG WINAPI DisplayConfigGetDeviceInfo(DISPLAYCONFIG_DEVICE_INFO_HEADER *packet)
 960 {
 961     return RtlNtStatusToDosError(NtUserDisplayConfigGetDeviceInfo(packet));
 962 }
 963
 964 /***********************************************************************
 965  *              SetDisplayConfig (USER32.@)
 966  */
 967 LONG WINAPI SetDisplayConfig(UINT32 path_info_count, DISPLAYCONFIG_PATH_INFO *path_info, UINT32 mode_info_count,
 968         DISPLAYCONFIG_MODE_INFO *mode_info, UINT32 flags)
 969 {
 970     FIXME("path_info_count %u, path_info %p, mode_info_count %u, mode_info %p, flags %#x stub.\n",
 971             path_info_count, path_info, mode_info_count, mode_info, flags);
 972
 973     return ERROR_SUCCESS;
 974 }