win32ss/user/user32/misc/display.c

   1 /*
   2  * PROJECT:         ReactOS user32.dll
   3  * FILE:            win32ss/user/user32/misc/display.c
   4  * PURPOSE:         DDE
   5  * PROGRAMMER:      Casper S. Hornstrup (chorns@users.sourceforge.net)
   6  */
   7
   8 #include <user32.h>
   9
  10 WINE_DEFAULT_DEBUG_CHANNEL(user32);
  11
  12 #define SIZEOF_DEVMODEA_300 124
  13 #define SIZEOF_DEVMODEA_400 148
  14 #define SIZEOF_DEVMODEA_500 156
  15 #define SIZEOF_DEVMODEW_300 188
  16 #define SIZEOF_DEVMODEW_400 212
  17 #define SIZEOF_DEVMODEW_500 220
  18
  19 /*
  20  * @implemented
  21  */
  22 BOOL WINAPI
  23 EnumDisplayDevicesA(
  24     LPCSTR lpDevice,
  25     DWORD iDevNum,
  26     PDISPLAY_DEVICEA lpDisplayDevice,
  27     DWORD dwFlags)
  28 {
  29     BOOL rc;
  30     UNICODE_STRING Device;
  31     DISPLAY_DEVICEW DisplayDeviceW;
  32
  33     if (!RtlCreateUnicodeStringFromAsciiz(&Device, (PCSZ)lpDevice))
  34     {
  35         SetLastError(ERROR_OUTOFMEMORY);
  36         return FALSE;
  37     }
  38
  39     RtlZeroMemory(&DisplayDeviceW, sizeof(DISPLAY_DEVICEW));
  40     DisplayDeviceW.cb = sizeof(DISPLAY_DEVICEW);
  41     rc = NtUserEnumDisplayDevices(&Device,
  42                                   iDevNum,
  43                                   &DisplayDeviceW,
  44                                   dwFlags);
  45     if (rc)
  46     {
  47         /* Copy result from DisplayDeviceW to lpDisplayDevice. Buffers have the same size so result is always NULL terminated. */
  48         lpDisplayDevice->StateFlags = DisplayDeviceW.StateFlags;
  49         WideCharToMultiByte(CP_ACP, 0, DisplayDeviceW.DeviceName, -1,
  50                             lpDisplayDevice->DeviceName,
  51                             sizeof(lpDisplayDevice->DeviceName) / sizeof(lpDisplayDevice->DeviceName[0]),
  52                             NULL, NULL);
  53         WideCharToMultiByte(CP_ACP, 0, DisplayDeviceW.DeviceString, -1,
  54                             lpDisplayDevice->DeviceString,
  55                             sizeof(lpDisplayDevice->DeviceString) / sizeof(lpDisplayDevice->DeviceString[0]),
  56                             NULL, NULL);
  57         WideCharToMultiByte(CP_ACP, 0, DisplayDeviceW.DeviceID, -1,
  58                             lpDisplayDevice->DeviceID,
  59                             sizeof(lpDisplayDevice->DeviceID) / sizeof(lpDisplayDevice->DeviceID[0]),
  60                             NULL, NULL);
  61         WideCharToMultiByte(CP_ACP, 0, DisplayDeviceW.DeviceKey, -1,
  62                             lpDisplayDevice->DeviceKey,
  63                             sizeof(lpDisplayDevice->DeviceKey) / sizeof(lpDisplayDevice->DeviceKey[0]),
  64                             NULL, NULL);
  65     }
  66
  67     RtlFreeUnicodeString(&Device);
  68
  69     return rc;
  70 }
  71
  72
  73 /*
  74  * @implemented
  75  */
  76 BOOL
  77 WINAPI
  78 EnumDisplayDevicesW(
  79     LPCWSTR lpDevice,
  80     DWORD iDevNum,
  81     PDISPLAY_DEVICEW lpDisplayDevice,
  82     DWORD dwFlags)
  83 {
  84     UNICODE_STRING Device;
  85     BOOL rc;
  86
  87     RtlInitUnicodeString(&Device, lpDevice);
  88
  89     rc = NtUserEnumDisplayDevices(
  90              &Device,
  91              iDevNum,
  92              lpDisplayDevice,
  93              dwFlags);
  94
  95     return rc;
  96 }
  97
  98
  99 /*
 100  * @implemented
 101  */
 102 BOOL
 103 WINAPI
 104 EnumDisplayMonitors(
 105     HDC hdc,
 106     LPCRECT lprcClip,
 107     MONITORENUMPROC lpfnEnum,
 108     LPARAM dwData)
 109 {
 110     INT iCount, i;
 111     HMONITOR *hMonitorList;
 112     LPRECT pRectList;
 113     HANDLE hHeap;
 114     BOOL ret = FALSE;
 115
 116     /* get list of monitors/rects */
 117     iCount = NtUserEnumDisplayMonitors(hdc, lprcClip, NULL, NULL, 0);
 118     if (iCount < 0)
 119     {
 120         /* FIXME: SetLastError() */
 121         return FALSE;
 122     }
 123     if (iCount == 0)
 124     {
 125         return TRUE;
 126     }
 127
 128     hHeap = GetProcessHeap();
 129     hMonitorList = HeapAlloc(hHeap, 0, sizeof (HMONITOR) * iCount);
 130     if (hMonitorList == NULL)
 131     {
 132         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 133         return FALSE;
 134     }
 135     pRectList = HeapAlloc(hHeap, 0, sizeof (RECT) * iCount);
 136     if (pRectList == NULL)
 137     {
 138         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 139         goto cleanup;
 140     }
 141
 142     iCount = NtUserEnumDisplayMonitors(hdc, lprcClip, hMonitorList, pRectList, iCount);
 143     if (iCount <= 0)
 144     {
 145         /* FIXME: SetLastError() */
 146         goto cleanup;
 147     }
 148
 149     /* enumerate list */
 150     for (i = 0; i < iCount; i++)
 151     {
 152         HMONITOR hMonitor = hMonitorList[i];
 153         LPRECT pMonitorRect = pRectList + i;
 154         HDC hMonitorDC = NULL;
 155
 156         if (hdc != NULL)
 157         {
 158             /* make monitor DC */
 159             hMonitorDC = hdc;
 160         }
 161
 162         if (!lpfnEnum(hMonitor, hMonitorDC, pMonitorRect, dwData))
 163             goto cleanup; /* return FALSE */
 164     }
 165
 166     ret = TRUE;
 167
 168 cleanup:
 169     if(hMonitorList)
 170         HeapFree(hHeap, 0, hMonitorList);
 171     if(pRectList)
 172         HeapFree(hHeap, 0, pRectList);
 173     return ret;
 174 }
 175
 176
 177 /*
 178  * @implemented
 179  */
 180 BOOL
 181 WINAPI
 182 EnumDisplaySettingsExA(
 183     LPCSTR lpszDeviceName,
 184     DWORD iModeNum,
 185     LPDEVMODEA lpDevMode,
 186     DWORD dwFlags)
 187 {
 188     NTSTATUS Status;
 189     UNICODE_STRING usDeviceName;
 190     PUNICODE_STRING pusDeviceName = NULL;
 191     LPDEVMODEW lpExtendedDevMode;
 192     BOOL Result = FALSE;
 193
 194     if (lpszDeviceName)
 195     {
 196         if (!RtlCreateUnicodeStringFromAsciiz(&usDeviceName, (PCSZ)lpszDeviceName))
 197         {
 198             SetLastError(ERROR_OUTOFMEMORY);
 199             return FALSE;
 200         }
 201         pusDeviceName = &usDeviceName;
 202     }
 203
 204     /* Allocate memory for DEVMODEW and extra data */
 205     lpExtendedDevMode = RtlAllocateHeap(RtlGetProcessHeap(),
 206                                         HEAP_ZERO_MEMORY,
 207                                         sizeof(DEVMODEW) + lpDevMode->dmDriverExtra);
 208     if (!lpExtendedDevMode)
 209     {
 210         if (pusDeviceName)
 211             RtlFreeUnicodeString(&usDeviceName);
 212
 213         return FALSE;
 214     }
 215
 216     /* Initialize structure fields */
 217     lpExtendedDevMode->dmSize = sizeof(DEVMODEW);
 218     lpExtendedDevMode->dmDriverExtra = lpDevMode->dmDriverExtra;
 219
 220     Status = NtUserEnumDisplaySettings(pusDeviceName, iModeNum, lpExtendedDevMode, dwFlags);
 221
 222     if (pusDeviceName)
 223         RtlFreeUnicodeString(&usDeviceName);
 224
 225     if (NT_SUCCESS(Status))
 226     {
 227         /* Store old structure size */
 228         WORD OldSize = lpDevMode->dmSize;
 229
 230 #define COPYS(f,len) WideCharToMultiByte(CP_THREAD_ACP, 0, lpExtendedDevMode->f, len, (LPSTR)lpDevMode->f, len, NULL, NULL)
 231 #define COPYN(f) lpDevMode->f = lpExtendedDevMode->f
 232
 233         COPYS(dmDeviceName, CCHDEVICENAME);
 234         COPYN(dmSpecVersion);
 235         COPYN(dmDriverVersion);
 236         COPYN(dmFields);
 237         COPYN(dmPosition.x);
 238         COPYN(dmPosition.y);
 239         COPYN(dmScale);
 240         COPYN(dmCopies);
 241         COPYN(dmDefaultSource);
 242         COPYN(dmPrintQuality);
 243         COPYN(dmColor);
 244         COPYN(dmDuplex);
 245         COPYN(dmYResolution);
 246         COPYN(dmTTOption);
 247         COPYN(dmCollate);
 248         COPYS(dmFormName,CCHFORMNAME);
 249         COPYN(dmLogPixels);
 250         COPYN(dmBitsPerPel);
 251         COPYN(dmPelsWidth);
 252         COPYN(dmPelsHeight);
 253         COPYN(dmDisplayFlags); // aka dmNup
 254         COPYN(dmDisplayFrequency);
 255
 256         /* we're done with 0x300 fields */
 257         if (OldSize > SIZEOF_DEVMODEA_300)
 258         {
 259             COPYN(dmICMMethod);
 260             COPYN(dmICMIntent);
 261             COPYN(dmMediaType);
 262             COPYN(dmDitherType);
 263             COPYN(dmReserved1);
 264             COPYN(dmReserved2);
 265
 266             /* we're done with 0x400 fields */
 267             if (OldSize > SIZEOF_DEVMODEA_400)
 268             {
 269                 COPYN(dmPanningWidth);
 270                 COPYN(dmPanningHeight);
 271             }
 272         }
 273
 274         /* Restore old size */
 275         lpDevMode->dmSize = OldSize;
 276
 277         /* Extra data presented? */
 278         if (lpDevMode->dmDriverExtra && lpExtendedDevMode->dmDriverExtra)
 279         {
 280             /* We choose the smallest size */
 281             if (lpDevMode->dmDriverExtra > lpExtendedDevMode->dmDriverExtra)
 282                 lpDevMode->dmDriverExtra = lpExtendedDevMode->dmDriverExtra;
 283
 284             /* Copy extra data */
 285             RtlCopyMemory((PUCHAR)lpDevMode + OldSize,
 286                           lpExtendedDevMode + 1,
 287                           lpDevMode->dmDriverExtra);
 288         }
 289
 290         /* If the size of source structure is less, than used, we clean unsupported flags */
 291         if (OldSize < FIELD_OFFSET(DEVMODEA, dmPanningHeight))
 292             lpDevMode->dmFields &= ~DM_PANNINGHEIGHT;
 293
 294         if (OldSize < FIELD_OFFSET(DEVMODEA, dmPanningWidth))
 295             lpDevMode->dmFields &= ~DM_PANNINGWIDTH;
 296
 297         Result = TRUE;
 298     }
 299
 300     /* Free memory */
 301     RtlFreeHeap(RtlGetProcessHeap(), 0, lpExtendedDevMode);
 302
 303     return Result;
 304 }
 305
 306
 307 /*
 308  * @implemented
 309  */
 310 BOOL
 311 WINAPI
 312 EnumDisplaySettingsA(
 313     LPCSTR lpszDeviceName,
 314     DWORD iModeNum,
 315     LPDEVMODEA lpDevMode)
 316 {
 317     /* Fixup sizes */
 318     lpDevMode->dmSize = FIELD_OFFSET(DEVMODEA, dmICMMethod);
 319     lpDevMode->dmDriverExtra = 0;
 320
 321     return EnumDisplaySettingsExA(lpszDeviceName, iModeNum, lpDevMode, 0);
 322 }
 323
 324
 325 /*
 326  * @implemented
 327  */
 328 BOOL
 329 WINAPI
 330 EnumDisplaySettingsExW(
 331     LPCWSTR lpszDeviceName,
 332     DWORD iModeNum,
 333     LPDEVMODEW lpDevMode,
 334     DWORD dwFlags)
 335 {
 336     NTSTATUS Status;
 337     UNICODE_STRING usDeviceName;
 338     PUNICODE_STRING pusDeviceName = NULL;
 339     LPDEVMODEW lpExtendedDevMode;
 340     BOOL Result = FALSE;
 341
 342     if (lpszDeviceName)
 343     {
 344         RtlInitUnicodeString(&usDeviceName, lpszDeviceName);
 345         pusDeviceName = &usDeviceName;
 346     }
 347
 348     /* Allocate memory for DEVMODEW and extra data */
 349     lpExtendedDevMode = RtlAllocateHeap(RtlGetProcessHeap(),
 350                                         HEAP_ZERO_MEMORY,
 351                                         sizeof(DEVMODEW) + lpDevMode->dmDriverExtra);
 352     if (!lpExtendedDevMode)
 353         return FALSE;
 354
 355     /* Initialize structure fields */
 356     lpExtendedDevMode->dmSize = sizeof(DEVMODEW);
 357     lpExtendedDevMode->dmDriverExtra = lpDevMode->dmDriverExtra;
 358
 359     Status = NtUserEnumDisplaySettings(pusDeviceName, iModeNum, lpExtendedDevMode, dwFlags);
 360     if (NT_SUCCESS(Status))
 361     {
 362         /* Store old structure sizes */
 363         WORD OldSize = lpDevMode->dmSize;
 364         WORD OldDriverExtra = lpDevMode->dmDriverExtra;
 365
 366         /* Copy general data */
 367         RtlCopyMemory(lpDevMode, lpExtendedDevMode, OldSize);
 368
 369         /* Restore old sizes */
 370         lpDevMode->dmSize = OldSize;
 371         lpDevMode->dmDriverExtra = OldDriverExtra;
 372
 373         /* Extra data presented? */
 374         if (lpDevMode->dmDriverExtra && lpExtendedDevMode->dmDriverExtra)
 375         {
 376             /* We choose the smallest size */
 377             if (lpDevMode->dmDriverExtra > lpExtendedDevMode->dmDriverExtra)
 378                 lpDevMode->dmDriverExtra = lpExtendedDevMode->dmDriverExtra;
 379
 380             /* Copy extra data */
 381             RtlCopyMemory((PUCHAR)lpDevMode + OldSize,
 382                           lpExtendedDevMode + 1,
 383                           lpDevMode->dmDriverExtra);
 384         }
 385
 386         /* If the size of source structure is less, than used, we clean unsupported flags */
 387         if (OldSize < FIELD_OFFSET(DEVMODEW, dmPanningHeight))
 388             lpDevMode->dmFields &= ~DM_PANNINGHEIGHT;
 389
 390         if (OldSize < FIELD_OFFSET(DEVMODEW, dmPanningWidth))
 391             lpDevMode->dmFields &= ~DM_PANNINGWIDTH;
 392
 393         Result = TRUE;
 394     }
 395
 396     /* Free memory */
 397     RtlFreeHeap(RtlGetProcessHeap(), 0, lpExtendedDevMode);
 398
 399     return Result;
 400 }
 401
 402
 403 /*
 404  * @implemented
 405  */
 406 BOOL
 407 WINAPI
 408 EnumDisplaySettingsW(
 409     LPCWSTR lpszDeviceName,
 410     DWORD iModeNum,
 411     LPDEVMODEW lpDevMode)
 412 {
 413     /* Fixup sizes */
 414     lpDevMode->dmSize = FIELD_OFFSET(DEVMODEW, dmICMMethod);
 415     lpDevMode->dmDriverExtra = 0;
 416
 417     return EnumDisplaySettingsExW(lpszDeviceName, iModeNum, lpDevMode, 0);
 418 }
 419
 420
 421 /*
 422  * @implemented
 423  */
 424 BOOL
 425 WINAPI
 426 GetMonitorInfoA(
 427     HMONITOR hMonitor,
 428     LPMONITORINFO lpmi)
 429 {
 430     if (lpmi->cbSize == sizeof (MONITORINFO))
 431     {
 432         return NtUserGetMonitorInfo(hMonitor, lpmi);
 433     }
 434     else if (lpmi->cbSize != sizeof (MONITORINFOEXA))
 435     {
 436         SetLastError(ERROR_INVALID_PARAMETER);
 437         return FALSE;
 438     }
 439     else
 440     {
 441         MONITORINFOEXW miExW;
 442         INT res;
 443
 444         miExW.cbSize = sizeof (MONITORINFOEXW);
 445         if (!NtUserGetMonitorInfo(hMonitor, (LPMONITORINFO)&miExW))
 446         {
 447             return FALSE;
 448         }
 449         memcpy(lpmi, &miExW, sizeof (MONITORINFO));
 450         res = WideCharToMultiByte(CP_THREAD_ACP, 0, miExW.szDevice, -1,
 451                                   ((LPMONITORINFOEXA)lpmi)->szDevice, CCHDEVICENAME,
 452                                   NULL, NULL);
 453         if (res == 0)
 454         {
 455             WARN("WideCharToMultiByte() failed!\n");
 456             return FALSE;
 457         }
 458     }
 459
 460     return TRUE;
 461 }
 462
 463
 464 /*
 465  * @implemented
 466  */
 467 BOOL
 468 WINAPI
 469 GetMonitorInfoW(
 470     HMONITOR hMonitor,
 471     LPMONITORINFO lpmi)
 472 {
 473     return NtUserGetMonitorInfo(hMonitor, lpmi);
 474 }
 475
 476
 477 /*
 478  * @implemented
 479  */
 480 HMONITOR
 481 WINAPI
 482 MonitorFromPoint(
 483     IN POINT ptPoint,
 484     IN DWORD dwFlags )
 485 {
 486     return NtUserMonitorFromPoint(ptPoint, dwFlags);
 487 }
 488
 489
 490 /*
 491  * @implemented
 492  */
 493 HMONITOR
 494 WINAPI
 495 MonitorFromRect(
 496     IN LPCRECT lpcRect,
 497     IN DWORD dwFlags )
 498 {
 499     return NtUserMonitorFromRect(lpcRect, dwFlags);
 500 }
 501
 502
 503 /*
 504  * @implemented
 505  */
 506 HMONITOR
 507 WINAPI
 508 MonitorFromWindow(
 509     IN HWND hWnd,
 510     IN DWORD dwFlags )
 511 {
 512     return NtUserMonitorFromWindow(hWnd, dwFlags);
 513 }
 514
 515
 516 /*
 517  * @implemented
 518  */
 519 LONG
 520 WINAPI
 521 ChangeDisplaySettingsExA(
 522     LPCSTR lpszDeviceName,
 523     LPDEVMODEA lpDevMode,
 524     HWND hwnd,
 525     DWORD dwflags,
 526     LPVOID lParam)
 527 {
 528     LONG rc;
 529     UNICODE_STRING DeviceName;
 530     PUNICODE_STRING pDeviceName = &DeviceName;
 531
 532     if (lpszDeviceName != NULL)
 533     {
 534         if (!RtlCreateUnicodeStringFromAsciiz(pDeviceName, (PCSZ)lpszDeviceName))
 535         {
 536             SetLastError(ERROR_OUTOFMEMORY);
 537             return DISP_CHANGE_BADPARAM; /* FIXME what to return? */
 538         }
 539     }
 540     else
 541         pDeviceName = NULL;
 542
 543     if (lpDevMode != NULL)
 544     {
 545         LPDEVMODEW pDevModeW;
 546         pDevModeW = GdiConvertToDevmodeW(lpDevMode);
 547         if(pDevModeW)
 548         {
 549             rc = NtUserChangeDisplaySettings(pDeviceName, pDevModeW, dwflags, lParam);
 550             RtlFreeHeap(GetProcessHeap(), 0, pDevModeW);
 551         }
 552         else
 553             rc = DISP_CHANGE_SUCCESSFUL;
 554     }
 555     else
 556         rc = NtUserChangeDisplaySettings(pDeviceName, NULL, dwflags, lParam);
 557
 558     if (lpszDeviceName != NULL)
 559         RtlFreeUnicodeString(&DeviceName);
 560
 561     return rc;
 562 }
 563
 564
 565 /*
 566  * @implemented
 567  */
 568 LONG
 569 WINAPI
 570 ChangeDisplaySettingsA(
 571     LPDEVMODEA lpDevMode,
 572     DWORD dwflags)
 573 {
 574     if(lpDevMode)
 575         lpDevMode->dmDriverExtra = 0;
 576     return ChangeDisplaySettingsExA ( NULL, lpDevMode, NULL, dwflags, 0 );
 577 }
 578
 579
 580 /*
 581  * @implemented
 582  */
 583 LONG
 584 WINAPI
 585 ChangeDisplaySettingsExW(
 586     LPCWSTR lpszDeviceName,
 587     LPDEVMODEW lpDevMode,
 588     HWND hwnd,
 589     DWORD dwflags,
 590     LPVOID lParam)
 591 {
 592     LONG rc;
 593     UNICODE_STRING DeviceName;
 594     PUNICODE_STRING pDeviceName = &DeviceName;
 595
 596     if (lpszDeviceName != NULL)
 597         RtlInitUnicodeString(pDeviceName, lpszDeviceName);
 598     else
 599         pDeviceName = NULL;
 600
 601     rc = NtUserChangeDisplaySettings(pDeviceName, lpDevMode, dwflags, lParam);
 602
 603     return rc;
 604 }
 605
 606
 607 /*
 608  * @implemented
 609  */
 610 LONG
 611 WINAPI
 612 ChangeDisplaySettingsW(
 613     LPDEVMODEW lpDevMode,
 614     DWORD dwflags)
 615 {
 616     if(lpDevMode)
 617         lpDevMode->dmDriverExtra = 0;
 618     return ChangeDisplaySettingsExW(NULL, lpDevMode, NULL, dwflags, 0);
 619 }