reactos/dll/win32/user32/misc/display.c

   1 /*
   2  *  ReactOS kernel
   3  *  Copyright (C) 1998, 1999, 2000, 2001 ReactOS Team
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  */
  19 /* $Id$
  20  *
  21  * PROJECT:         ReactOS user32.dll
  22  * FILE:            lib/user32/misc/dde.c
  23  * PURPOSE:         DDE
  24  * PROGRAMMER:      Casper S. Hornstrup (chorns@users.sourceforge.net)
  25  * UPDATE HISTORY:
  26  *      09-05-2001  CSH  Created
  27  */
  28
  29 /* INCLUDES ******************************************************************/
  30
  31 #include <user32.h>
  32
  33 #include <wine/debug.h>
  34 WINE_DEFAULT_DEBUG_CHANNEL(user32);
  35
  36 #define SIZEOF_DEVMODEA_300 124
  37 #define SIZEOF_DEVMODEA_400 148
  38 #define SIZEOF_DEVMODEA_500 156
  39 #define SIZEOF_DEVMODEW_300 188
  40 #define SIZEOF_DEVMODEW_400 212
  41 #define SIZEOF_DEVMODEW_500 220
  42
  43 /* FUNCTIONS *****************************************************************/
  44
  45 /*
  46  * @implemented
  47  */
  48 BOOL WINAPI
  49 EnumDisplayDevicesA(
  50   LPCSTR lpDevice,
  51   DWORD iDevNum,
  52   PDISPLAY_DEVICEA lpDisplayDevice,
  53   DWORD dwFlags)
  54 {
  55   BOOL rc;
  56   UNICODE_STRING Device;
  57   DISPLAY_DEVICEW DisplayDeviceW;
  58
  59   if ( !RtlCreateUnicodeStringFromAsciiz ( &Device, (PCSZ)lpDevice ) )
  60     {
  61       SetLastError ( ERROR_OUTOFMEMORY );
  62       return FALSE;
  63     }
  64
  65   RtlZeroMemory(&DisplayDeviceW, sizeof(DISPLAY_DEVICEW));
  66   DisplayDeviceW.cb = sizeof(DISPLAY_DEVICEW);
  67   rc = NtUserEnumDisplayDevices (
  68     &Device,
  69     iDevNum,
  70     &DisplayDeviceW,
  71     dwFlags );
  72   if (rc)
  73     {
  74       /* Copy result from DisplayDeviceW to lpDisplayDevice */
  75       lpDisplayDevice->StateFlags = DisplayDeviceW.StateFlags;
  76       WideCharToMultiByte(CP_ACP,0,
  77         DisplayDeviceW.DeviceName,wcslen(DisplayDeviceW.DeviceName),
  78         lpDisplayDevice->DeviceName,sizeof(lpDisplayDevice->DeviceName) / sizeof(lpDisplayDevice->DeviceName[0]),
  79         NULL,NULL);
  80       WideCharToMultiByte(CP_ACP,0,
  81         DisplayDeviceW.DeviceString,wcslen(DisplayDeviceW.DeviceString),
  82         lpDisplayDevice->DeviceString,sizeof(lpDisplayDevice->DeviceString) / sizeof(lpDisplayDevice->DeviceString[0]),
  83         NULL,NULL);
  84       WideCharToMultiByte(CP_ACP,0,
  85         DisplayDeviceW.DeviceID,wcslen(DisplayDeviceW.DeviceID),
  86         lpDisplayDevice->DeviceID,sizeof(lpDisplayDevice->DeviceID) / sizeof(lpDisplayDevice->DeviceID[0]),
  87         NULL,NULL);
  88       WideCharToMultiByte(CP_ACP,0,
  89         DisplayDeviceW.DeviceKey,wcslen(DisplayDeviceW.DeviceKey),
  90         lpDisplayDevice->DeviceKey,sizeof(lpDisplayDevice->DeviceKey) / sizeof(lpDisplayDevice->DeviceKey[0]),
  91         NULL,NULL);
  92     }
  93
  94   RtlFreeUnicodeString ( &Device );
  95
  96   return rc;
  97 }
  98
  99
 100 /*
 101  * @implemented
 102  */
 103 BOOL
 104 WINAPI
 105 EnumDisplayDevicesW(
 106   LPCWSTR lpDevice,
 107   DWORD iDevNum,
 108   PDISPLAY_DEVICE lpDisplayDevice,
 109   DWORD dwFlags)
 110 {
 111   UNICODE_STRING Device;
 112   BOOL rc;
 113
 114   RtlInitUnicodeString ( &Device, lpDevice );
 115
 116   rc = NtUserEnumDisplayDevices (
 117     &Device,
 118     iDevNum,
 119     lpDisplayDevice,
 120     dwFlags );
 121
 122   return rc;
 123 }
 124
 125
 126 /*
 127  * @implemented
 128  */
 129 BOOL
 130 WINAPI
 131 EnumDisplayMonitors(
 132   HDC hdc,
 133   LPCRECT lprcClip,
 134   MONITORENUMPROC lpfnEnum,
 135   LPARAM dwData)
 136 {
 137   INT iCount, i;
 138   HMONITOR *hMonitorList;
 139   LPRECT pRectList;
 140   HANDLE hHeap;
 141
 142   /* get list of monitors/rects */
 143   iCount = NtUserEnumDisplayMonitors(hdc, lprcClip, NULL, NULL, 0);
 144   if (iCount < 0)
 145     {
 146       /* FIXME: SetLastError() */
 147       return FALSE;
 148     }
 149   if (iCount == 0)
 150     {
 151       return TRUE;
 152     }
 153
 154   hHeap = GetProcessHeap();
 155   hMonitorList = HeapAlloc(hHeap, 0, sizeof (HMONITOR) * iCount);
 156   if (hMonitorList == NULL)
 157     {
 158       SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 159       return FALSE;
 160     }
 161   pRectList = HeapAlloc(hHeap, 0, sizeof (RECT) * iCount);
 162   if (pRectList == NULL)
 163     {
 164       HeapFree(hHeap, 0, hMonitorList);
 165       SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 166       return FALSE;
 167     }
 168
 169   iCount = NtUserEnumDisplayMonitors(hdc, lprcClip, hMonitorList, pRectList, iCount);
 170   if (iCount <= 0)
 171     {
 172       /* FIXME: SetLastError() */
 173       HeapFree(hHeap, 0, hMonitorList);
 174       HeapFree(hHeap, 0, pRectList);
 175       return FALSE;
 176     }
 177
 178   /* enumerate list */
 179   for (i = 0; i < iCount; i++)
 180     {
 181       HMONITOR hMonitor = hMonitorList[i];
 182       LPRECT pMonitorRect = pRectList + i;
 183       HDC hMonitorDC = NULL;
 184
 185       if (hdc != NULL)
 186         {
 187           /* make monitor DC */
 188           hMonitorDC = hdc;
 189         }
 190
 191       if (!lpfnEnum(hMonitor, hMonitorDC, pMonitorRect, dwData))
 192         break;
 193     }
 194   HeapFree(hHeap, 0, hMonitorList);
 195   HeapFree(hHeap, 0, pRectList);
 196   return TRUE;
 197 }
 198
 199
 200 /*
 201  * @implemented
 202  */
 203 BOOL
 204 WINAPI
 205 EnumDisplaySettingsExA(
 206     LPCSTR lpszDeviceName,
 207     DWORD iModeNum,
 208     LPDEVMODEA lpDevMode,
 209     DWORD dwFlags)
 210 {
 211     NTSTATUS Status;
 212     UNICODE_STRING usDeviceName, *pusDeviceName = NULL;
 213     DEVMODEW DevModeW;
 214
 215     if (lpszDeviceName)
 216     {
 217         if (!RtlCreateUnicodeStringFromAsciiz(&usDeviceName, (PCSZ)lpszDeviceName))
 218         {
 219             SetLastError(ERROR_OUTOFMEMORY);
 220             return FALSE;
 221         }
 222         pusDeviceName = &usDeviceName;
 223     }
 224
 225     memset(&DevModeW,0, sizeof(DEVMODEW));
 226     DevModeW.dmSize = sizeof(DEVMODEW);
 227
 228     Status = NtUserEnumDisplaySettings(pusDeviceName, iModeNum, &DevModeW, dwFlags);
 229
 230     if (pusDeviceName)
 231     {
 232         RtlFreeUnicodeString (&usDeviceName);
 233     }
 234
 235     if (!NT_SUCCESS(Status))
 236     {
 237         return FALSE;
 238     }
 239
 240 #define COPYS(f,len) WideCharToMultiByte( CP_THREAD_ACP, 0, DevModeW.f, len, (LPSTR)lpDevMode->f, len, NULL, NULL )
 241 #define COPYN(f) lpDevMode->f = DevModeW.f
 242     COPYS(dmDeviceName, CCHDEVICENAME );
 243     COPYN(dmSpecVersion);
 244     COPYN(dmDriverVersion);
 245     switch (lpDevMode->dmSize)
 246     {
 247         case SIZEOF_DEVMODEA_300:
 248         case SIZEOF_DEVMODEA_400:
 249         case SIZEOF_DEVMODEA_500:
 250              break;
 251         default:
 252             lpDevMode->dmSize = SIZEOF_DEVMODEA_300;
 253             break;
 254     }
 255     COPYN(dmDriverExtra);
 256     COPYN(dmFields);
 257     COPYN(dmPosition.x);
 258     COPYN(dmPosition.y);
 259     COPYN(dmScale);
 260     COPYN(dmCopies);
 261     COPYN(dmDefaultSource);
 262     COPYN(dmPrintQuality);
 263     COPYN(dmColor);
 264     COPYN(dmDuplex);
 265     COPYN(dmYResolution);
 266     COPYN(dmTTOption);
 267     COPYN(dmCollate);
 268     COPYS(dmFormName,CCHFORMNAME);
 269     COPYN(dmLogPixels);
 270     COPYN(dmBitsPerPel);
 271     COPYN(dmPelsWidth);
 272     COPYN(dmPelsHeight);
 273     COPYN(dmDisplayFlags); // aka dmNup
 274     COPYN(dmDisplayFrequency);
 275
 276     if (lpDevMode->dmSize <= SIZEOF_DEVMODEW_300)
 277         return TRUE; // we're done with 0x300 fields
 278
 279     COPYN(dmICMMethod);
 280     COPYN(dmICMIntent);
 281     COPYN(dmMediaType);
 282     COPYN(dmDitherType);
 283     COPYN(dmReserved1);
 284     COPYN(dmReserved2);
 285
 286     if (lpDevMode->dmSize <= SIZEOF_DEVMODEW_400)
 287         return TRUE; // we're done with 0x400 fields
 288
 289     COPYN(dmPanningWidth);
 290     COPYN(dmPanningHeight);
 291
 292     return TRUE;
 293 }
 294
 295
 296 /*
 297  * @implemented
 298  */
 299 BOOL
 300 WINAPI
 301 EnumDisplaySettingsA(
 302   LPCSTR lpszDeviceName,
 303   DWORD iModeNum,
 304   LPDEVMODEA lpDevMode)
 305 {
 306   return EnumDisplaySettingsExA ( lpszDeviceName, iModeNum, lpDevMode, 0 );
 307 }
 308
 309
 310 /*
 311  * @implemented
 312  */
 313 BOOL
 314 WINAPI
 315 EnumDisplaySettingsExW(
 316     LPCWSTR lpszDeviceName,
 317     DWORD iModeNum,
 318     LPDEVMODEW lpDevMode,
 319     DWORD dwFlags)
 320 {
 321     NTSTATUS Status;
 322     UNICODE_STRING usDeviceName, *pusDeviceName = NULL;
 323
 324     if (lpszDeviceName)
 325     {
 326         RtlInitUnicodeString(&usDeviceName, lpszDeviceName);
 327         pusDeviceName = &usDeviceName;
 328     }
 329
 330     Status = NtUserEnumDisplaySettings(pusDeviceName, iModeNum, lpDevMode, dwFlags);
 331
 332     return NT_SUCCESS(Status);
 333 }
 334
 335
 336 /*
 337  * @implemented
 338  */
 339 BOOL
 340 WINAPI
 341 EnumDisplaySettingsW(
 342   LPCWSTR lpszDeviceName,
 343   DWORD iModeNum,
 344   LPDEVMODEW lpDevMode)
 345 {
 346   return EnumDisplaySettingsExW ( lpszDeviceName, iModeNum, lpDevMode, 0 );
 347 }
 348
 349
 350 /*
 351  * @implemented
 352  */
 353 BOOL
 354 WINAPI
 355 GetMonitorInfoA(
 356   HMONITOR hMonitor,
 357   LPMONITORINFO lpmi)
 358 {
 359   if (lpmi->cbSize == sizeof (MONITORINFO))
 360     {
 361       return NtUserGetMonitorInfo(hMonitor, lpmi);
 362     }
 363   else if (lpmi->cbSize != sizeof (MONITORINFOEXA))
 364     {
 365       SetLastError(ERROR_INVALID_PARAMETER);
 366       return FALSE;
 367     }
 368   else
 369     {
 370       MONITORINFOEXW miExW;
 371       INT res;
 372
 373       miExW.cbSize = sizeof (MONITORINFOEXW);
 374       if (!NtUserGetMonitorInfo(hMonitor, (LPMONITORINFO)&miExW))
 375         {
 376           return FALSE;
 377         }
 378       memcpy(lpmi, &miExW, sizeof (MONITORINFO));
 379       res = WideCharToMultiByte(CP_THREAD_ACP, 0, miExW.szDevice, -1,
 380                                 ((LPMONITORINFOEXA)lpmi)->szDevice, CCHDEVICENAME,
 381                                 NULL, NULL);
 382       if (res == 0)
 383         {
 384           WARN("WideCharToMultiByte() failed!\n");
 385           return FALSE;
 386         }
 387     }
 388
 389   return TRUE;
 390 }
 391
 392
 393 /*
 394  * @implemented
 395  */
 396 BOOL
 397 WINAPI
 398 GetMonitorInfoW(
 399   HMONITOR hMonitor,
 400   LPMONITORINFO lpmi)
 401 {
 402   return NtUserGetMonitorInfo(hMonitor, lpmi);
 403 }
 404
 405
 406 /*
 407  * @implemented
 408  */
 409 HMONITOR
 410 WINAPI
 411 MonitorFromPoint(
 412         IN POINT ptPoint,
 413         IN DWORD dwFlags )
 414 {
 415   return NtUserMonitorFromPoint(ptPoint, dwFlags);
 416 }
 417
 418
 419 /*
 420  * @implemented
 421  */
 422 HMONITOR
 423 WINAPI
 424 MonitorFromRect(
 425         IN LPCRECT lpcRect,
 426         IN DWORD dwFlags )
 427 {
 428   return NtUserMonitorFromRect(lpcRect, dwFlags);
 429 }
 430
 431
 432 /*
 433  * @implemented
 434  */
 435 HMONITOR
 436 WINAPI
 437 MonitorFromWindow(
 438         IN HWND hWnd,
 439         IN DWORD dwFlags )
 440 {
 441   return NtUserMonitorFromWindow(hWnd, dwFlags);
 442 }
 443
 444
 445 /*
 446  * @implemented
 447  */
 448 LONG
 449 WINAPI
 450 ChangeDisplaySettingsExA(
 451   LPCSTR lpszDeviceName,
 452   LPDEVMODEA lpDevMode,
 453   HWND hwnd,
 454   DWORD dwflags,
 455   LPVOID lParam)
 456 {
 457   LONG rc;
 458   UNICODE_STRING DeviceName;
 459   PUNICODE_STRING pDeviceName = &DeviceName;
 460
 461   if (lpszDeviceName != NULL)
 462     {
 463       if ( !RtlCreateUnicodeStringFromAsciiz ( pDeviceName, (PCSZ)lpszDeviceName ) )
 464         {
 465           SetLastError ( ERROR_OUTOFMEMORY );
 466           return DISP_CHANGE_BADPARAM; /* FIXME what to return? */
 467         }
 468     }
 469   else
 470     pDeviceName = NULL;
 471
 472   if (lpDevMode != NULL)
 473   {
 474     LPDEVMODEW pDevModeW;
 475     pDevModeW = GdiConvertToDevmodeW(lpDevMode);
 476     if(pDevModeW)
 477     {
 478       rc = NtUserChangeDisplaySettings ( pDeviceName, pDevModeW, hwnd, dwflags, lParam );
 479       RtlFreeHeap(GetProcessHeap(), 0, pDevModeW);
 480     }
 481     else
 482       rc = DISP_CHANGE_SUCCESSFUL;
 483   }
 484   else
 485     rc = NtUserChangeDisplaySettings ( pDeviceName, NULL, hwnd, dwflags, lParam );
 486
 487   if (lpszDeviceName != NULL)
 488     RtlFreeUnicodeString ( &DeviceName );
 489
 490   return rc;
 491 }
 492
 493
 494 /*
 495  * @implemented
 496  */
 497 LONG
 498 WINAPI
 499 ChangeDisplaySettingsA(
 500   LPDEVMODEA lpDevMode,
 501   DWORD dwflags)
 502 {
 503   if(lpDevMode)
 504     lpDevMode->dmDriverExtra = 0;
 505   return ChangeDisplaySettingsExA ( NULL, lpDevMode, NULL, dwflags, 0 );
 506 }
 507
 508
 509 /*
 510  * @implemented
 511  */
 512 LONG
 513 WINAPI
 514 ChangeDisplaySettingsExW(
 515   LPCWSTR lpszDeviceName,
 516   LPDEVMODEW lpDevMode,
 517   HWND hwnd,
 518   DWORD dwflags,
 519   LPVOID lParam)
 520 {
 521   LONG rc;
 522   UNICODE_STRING DeviceName;
 523   PUNICODE_STRING pDeviceName = &DeviceName;
 524
 525   if (lpszDeviceName != NULL)
 526     RtlInitUnicodeString ( pDeviceName, lpszDeviceName );
 527   else
 528     pDeviceName = NULL;
 529
 530   rc = NtUserChangeDisplaySettings ( pDeviceName, lpDevMode, hwnd, dwflags, lParam );
 531
 532   return rc;
 533 }
 534
 535
 536 /*
 537  * @implemented
 538  */
 539 LONG
 540 WINAPI
 541 ChangeDisplaySettingsW(
 542   LPDEVMODEW lpDevMode,
 543   DWORD dwflags)
 544 {
 545   if(lpDevMode)
 546     lpDevMode->dmDriverExtra = 0;
 547   return ChangeDisplaySettingsExW ( NULL, lpDevMode, NULL, dwflags, 0 );
 548 }