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

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS user32.dll
   4  * FILE:            lib/user32/misc/stubs.c
   5  * PURPOSE:         User32.dll stubs
   6  * PROGRAMMER:      Casper S. Hornstrup (chorns@users.sourceforge.net)
   7  * NOTES:           If you implement a function, remove it from this file
   8  * UPDATE HISTORY:
   9  *      08-F05-2001  CSH  Created
  10  */
  11
  12 #include <user32.h>
  13
  14 #include <wine/debug.h>
  15
  16 WINE_DEFAULT_DEBUG_CHANNEL(user32);
  17
  18 /*
  19  * @unimplemented
  20  */
  21 DWORD
  22 WINAPI
  23 WaitForInputIdle(
  24   HANDLE hProcess,
  25   DWORD dwMilliseconds)
  26 {
  27 // Need to call NtQueryInformationProcess and send ProcessId not hProcess.
  28   return NtUserWaitForInputIdle(hProcess, dwMilliseconds, FALSE);
  29 }
  30
  31 /******************************************************************************
  32  * SetDebugErrorLevel [USER32.@]
  33  * Sets the minimum error level for generating debugging events
  34  *
  35  * PARAMS
  36  *    dwLevel [I] Debugging error level
  37  *
  38  * @unimplemented
  39  */
  40 VOID
  41 WINAPI
  42 SetDebugErrorLevel( DWORD dwLevel )
  43 {
  44     DbgPrint("(%ld): stub\n", dwLevel);
  45 }
  46
  47
  48 /*
  49  * @implemented
  50  */
  51 DWORD
  52 WINAPI
  53 GetAppCompatFlags(HTASK hTask)
  54 {
  55     PCLIENTINFO pci = GetWin32ClientInfo();
  56
  57     return pci->dwCompatFlags;
  58 }
  59
  60 /*
  61  * @implemented
  62  */
  63 DWORD
  64 WINAPI
  65 GetAppCompatFlags2(HTASK hTask)
  66 {
  67     PCLIENTINFO pci = GetWin32ClientInfo();
  68
  69     return pci->dwCompatFlags2;
  70 }
  71
  72 /*
  73  * @unimplemented
  74  */
  75 UINT
  76 WINAPI
  77 GetInternalWindowPos(
  78                      HWND hwnd,
  79                      LPRECT rectWnd,
  80                      LPPOINT ptIcon
  81                      )
  82 {
  83     WINDOWPLACEMENT wndpl;
  84
  85     if (GetWindowPlacement(hwnd, &wndpl))
  86     {
  87                 if (rectWnd) *rectWnd = wndpl.rcNormalPosition;
  88                 if (ptIcon)  *ptIcon = wndpl.ptMinPosition;
  89                 return wndpl.showCmd;
  90     }
  91     return 0;
  92 }
  93
  94 /*
  95  * @unimplemented
  96  */
  97 VOID
  98 WINAPI
  99 LoadLocalFonts ( VOID )
 100 {
 101   UNIMPLEMENTED;
 102 }
 103
 104 /*
 105  * @unimplemented
 106  */
 107 VOID
 108 WINAPI
 109 LoadRemoteFonts ( VOID )
 110 {
 111   UNIMPLEMENTED;
 112 }
 113
 114 /*
 115  * @unimplemented
 116  */
 117 VOID
 118 WINAPI
 119 RegisterSystemThread ( DWORD flags, DWORD reserved )
 120 {
 121   UNIMPLEMENTED;
 122 }
 123
 124
 125 /*
 126  * @implemented
 127  */
 128 UINT
 129 WINAPI
 130 UserRealizePalette ( HDC hDC )
 131 {
 132   return NtUserCallOneParam((DWORD_PTR) hDC, ONEPARAM_ROUTINE_REALIZEPALETTE);
 133 }
 134
 135
 136 /*************************************************************************
 137  *              SetSysColorsTemp (USER32.@) (Wine 10/22/2008)
 138  *
 139  * UNDOCUMENTED !!
 140  *
 141  * Called by W98SE desk.cpl Control Panel Applet:
 142  * handle = SetSysColorsTemp(ptr, ptr, nCount);     ("set" call)
 143  * result = SetSysColorsTemp(NULL, NULL, handle);   ("restore" call)
 144  *
 145  * pPens is an array of COLORREF values, which seems to be used
 146  * to indicate the color values to create new pens with.
 147  *
 148  * pBrushes is an array of solid brush handles (returned by a previous
 149  * CreateSolidBrush), which seems to contain the brush handles to set
 150  * for the system colors.
 151  *
 152  * n seems to be used for
 153  *   a) indicating the number of entries to operate on (length of pPens,
 154  *      pBrushes)
 155  *   b) passing the handle that points to the previously used color settings.
 156  *      I couldn't figure out in hell what kind of handle this is on
 157  *      Windows. I just use a heap handle instead. Shouldn't matter anyway.
 158  *
 159  * RETURNS
 160  *     heap handle of our own copy of the current syscolors in case of
 161  *                 "set" call, i.e. pPens, pBrushes != NULL.
 162  *     TRUE (unconditionally !) in case of "restore" call,
 163  *          i.e. pPens, pBrushes == NULL.
 164  *     FALSE in case of either pPens != NULL and pBrushes == NULL
 165  *          or pPens == NULL and pBrushes != NULL.
 166  *
 167  * I'm not sure whether this implementation is 100% correct. [AM]
 168  */
 169
 170 static HPEN SysColorPens[COLOR_MENUBAR + 1];
 171 static HBRUSH SysColorBrushes[COLOR_MENUBAR + 1];
 172
 173 DWORD_PTR
 174 WINAPI
 175 SetSysColorsTemp(const COLORREF *pPens,
 176                  const HBRUSH *pBrushes,
 177                                  DWORD_PTR n)
 178 {
 179     DWORD i;
 180
 181     if (pPens && pBrushes) /* "set" call */
 182     {
 183         /* allocate our structure to remember old colors */
 184         LPVOID pOldCol = HeapAlloc(GetProcessHeap(), 0, sizeof(DWORD)+n*sizeof(HPEN)+n*sizeof(HBRUSH));
 185         LPVOID p = pOldCol;
 186         *(DWORD_PTR *)p = n; p = (char*)p + sizeof(DWORD);
 187         memcpy(p, SysColorPens, n*sizeof(HPEN)); p = (char*)p + n*sizeof(HPEN);
 188         memcpy(p, SysColorBrushes, n*sizeof(HBRUSH)); p = (char*)p + n*sizeof(HBRUSH);
 189
 190         for (i=0; i < n; i++)
 191         {
 192             SysColorPens[i] = CreatePen( PS_SOLID, 1, pPens[i] );
 193             SysColorBrushes[i] = pBrushes[i];
 194         }
 195
 196         return (DWORD_PTR) pOldCol;
 197     }
 198     if (!pPens && !pBrushes) /* "restore" call */
 199     {
 200         LPVOID pOldCol = (LPVOID)n;
 201         LPVOID p = pOldCol;
 202         DWORD nCount = *(DWORD *)p;
 203         p = (char*)p + sizeof(DWORD);
 204
 205         for (i=0; i < nCount; i++)
 206         {
 207             DeleteObject(SysColorPens[i]);
 208             SysColorPens[i] = *(HPEN *)p; p = (char*)p + sizeof(HPEN);
 209         }
 210         for (i=0; i < nCount; i++)
 211         {
 212             SysColorBrushes[i] = *(HBRUSH *)p; p = (char*)p + sizeof(HBRUSH);
 213         }
 214         /* get rid of storage structure */
 215         HeapFree(GetProcessHeap(), 0, pOldCol);
 216
 217         return TRUE;
 218     }
 219     return FALSE;
 220 }
 221
 222 /*
 223  * @unimplemented
 224  */
 225 HDESK
 226 WINAPI
 227 GetInputDesktop ( VOID )
 228 {
 229   UNIMPLEMENTED;
 230   return FALSE;
 231 }
 232
 233 /*
 234  * @unimplemented
 235  */
 236 BOOL
 237 WINAPI
 238 GetAccCursorInfo ( PCURSORINFO pci )
 239 {
 240   UNIMPLEMENTED;
 241   return FALSE;
 242 }
 243
 244 /*
 245  * @unimplemented
 246  */
 247 BOOL
 248 WINAPI
 249 ClientThreadSetup ( VOID )
 250 {
 251   UNIMPLEMENTED;
 252   return FALSE;
 253 }
 254
 255 /*
 256  * @unimplemented
 257  */
 258 UINT
 259 WINAPI
 260 GetRawInputDeviceInfoW(
 261     HANDLE hDevice,
 262     UINT uiCommand,
 263     LPVOID pData,
 264     PUINT pcbSize)
 265 {
 266   UNIMPLEMENTED;
 267   return 0;
 268 }
 269
 270 /*
 271  * @unimplemented
 272  */
 273 LONG
 274 WINAPI
 275 CsrBroadcastSystemMessageExW(
 276     DWORD dwflags,
 277     LPDWORD lpdwRecipients,
 278     UINT uiMessage,
 279     WPARAM wParam,
 280     LPARAM lParam,
 281     PBSMINFO pBSMInfo)
 282 {
 283   UNIMPLEMENTED;
 284   return FALSE;
 285 }
 286
 287 /*
 288  * @unimplemented
 289  */
 290 UINT
 291 WINAPI
 292 GetRawInputDeviceInfoA(
 293     HANDLE hDevice,
 294     UINT uiCommand,
 295     LPVOID pData,
 296     PUINT pcbSize)
 297 {
 298   UNIMPLEMENTED;
 299   return 0;
 300 }
 301
 302 /*
 303  * @unimplemented
 304  */
 305 BOOL
 306 WINAPI
 307 AlignRects(LPRECT rect, DWORD b, DWORD c, DWORD d)
 308 {
 309   UNIMPLEMENTED;
 310   return FALSE;
 311 }
 312
 313 /*
 314  * @implemented
 315  */
 316 LRESULT
 317 WINAPI
 318 DefRawInputProc(
 319     PRAWINPUT* paRawInput,
 320     INT nInput,
 321     UINT cbSizeHeader)
 322 {
 323   if (cbSizeHeader == sizeof(RAWINPUTHEADER))
 324      return S_OK;
 325   return 1;
 326 }
 327
 328 /*
 329  * @unimplemented
 330  */
 331 UINT
 332 WINAPI
 333 GetRawInputBuffer(
 334     PRAWINPUT pData,
 335     PUINT pcbSize,
 336     UINT cbSizeHeader)
 337 {
 338   UNIMPLEMENTED;
 339   return 0;
 340 }
 341
 342 /*
 343  * @unimplemented
 344  */
 345 UINT
 346 WINAPI
 347 GetRawInputData(
 348     HRAWINPUT hRawInput,
 349     UINT uiCommand,
 350     LPVOID pData,
 351     PUINT pcbSize,
 352     UINT cbSizeHeader)
 353 {
 354   UNIMPLEMENTED;
 355   return 0;
 356 }
 357
 358 /*
 359  * @unimplemented
 360  */
 361 UINT
 362 WINAPI
 363 GetRawInputDeviceList(
 364     PRAWINPUTDEVICELIST pRawInputDeviceList,
 365     PUINT puiNumDevices,
 366     UINT cbSize)
 367 {
 368     if(pRawInputDeviceList)
 369         memset(pRawInputDeviceList, 0, sizeof *pRawInputDeviceList);
 370     *puiNumDevices = 0;
 371
 372     UNIMPLEMENTED;
 373     return 0;
 374 }
 375
 376 /*
 377  * @unimplemented
 378  */
 379 UINT
 380 WINAPI
 381 GetRegisteredRawInputDevices(
 382     PRAWINPUTDEVICE pRawInputDevices,
 383     PUINT puiNumDevices,
 384     UINT cbSize)
 385 {
 386   UNIMPLEMENTED;
 387   return 0;
 388 }
 389
 390 /*
 391  * @unimplemented
 392  */
 393 BOOL
 394 WINAPI
 395 RegisterRawInputDevices(
 396     PCRAWINPUTDEVICE pRawInputDevices,
 397     UINT uiNumDevices,
 398     UINT cbSize)
 399 {
 400   UNIMPLEMENTED;
 401   return FALSE;
 402 }
 403
 404 /*
 405  * @unimplemented
 406  */
 407 BOOL WINAPI DisplayExitWindowsWarnings(ULONG flags)
 408 {
 409   UNIMPLEMENTED;
 410   return FALSE;
 411 }
 412
 413 /*
 414  * @unimplemented
 415  */
 416 BOOL WINAPI ReasonCodeNeedsBugID(ULONG reasoncode)
 417 {
 418   UNIMPLEMENTED;
 419   return FALSE;
 420 }
 421
 422 /*
 423  * @unimplemented
 424  */
 425 BOOL WINAPI ReasonCodeNeedsComment(ULONG reasoncode)
 426 {
 427   UNIMPLEMENTED;
 428   return FALSE;
 429 }
 430
 431 /*
 432  * @unimplemented
 433  */
 434 BOOL WINAPI CtxInitUser32(VOID)
 435 {
 436   UNIMPLEMENTED;
 437   return FALSE;
 438 }
 439
 440 /*
 441  * @unimplemented
 442  */
 443 BOOL WINAPI EnterReaderModeHelper(HWND hwnd)
 444 {
 445   UNIMPLEMENTED;
 446   return FALSE;
 447 }
 448
 449 /*
 450  * @unimplemented
 451  */
 452 VOID WINAPI InitializeLpkHooks(FARPROC *hookfuncs)
 453 {
 454   UNIMPLEMENTED;
 455 }
 456
 457 /*
 458  * @unimplemented
 459  */
 460 WORD WINAPI InitializeWin32EntryTable(UCHAR* EntryTablePlus0x1000)
 461 {
 462   UNIMPLEMENTED;
 463   return FALSE;
 464 }
 465
 466 /*
 467  * @unimplemented
 468  */
 469 BOOL WINAPI IsServerSideWindow(HWND wnd)
 470 {
 471   UNIMPLEMENTED;
 472   return FALSE;
 473 }
 474
 475 /*
 476  * @unimplemented
 477  */
 478 HKL WINAPI LoadKeyboardLayoutEx(DWORD unknown,LPCWSTR pwszKLID,UINT Flags) //1st parameter unknown
 479 {
 480   UNIMPLEMENTED;
 481   return FALSE;
 482 }
 483
 484 /*
 485  * @unimplemented
 486  */
 487 VOID WINAPI AllowForegroundActivation(VOID)
 488 {
 489   UNIMPLEMENTED;
 490 }
 491
 492 /*
 493  * @unimplemented
 494  */
 495 VOID WINAPI ShowStartGlass(DWORD unknown)
 496 {
 497   UNIMPLEMENTED;
 498 }
 499
 500 /*
 501  * @unimplemented
 502  */
 503 BOOL WINAPI DdeGetQualityOfService(HWND hWnd, DWORD Reserved, PSECURITY_QUALITY_OF_SERVICE pqosPrev)
 504 {
 505   UNIMPLEMENTED;
 506   return FALSE;
 507 }
 508
 509 /*
 510  * @unimplemented
 511  */
 512 BOOL WINAPI SetProcessDPIAware(VOID)
 513 {
 514     UNIMPLEMENTED;
 515     return TRUE;
 516 }
 517
 518 /*
 519  * @unimplemented
 520  */
 521 BOOL WINAPI CliImmSetHotKey(DWORD dwID, UINT uModifiers, UINT uVirtualKey, HKL hKl)
 522 {
 523   UNIMPLEMENTED;
 524   return FALSE;
 525 }
 526
 527 /*
 528  * @implemented
 529  */
 530 DWORD WINAPI GetMenuIndex(HMENU hMenu, HMENU hSubMenu)
 531 {
 532   return NtUserGetMenuIndex(hMenu, hSubMenu);
 533 }
 534
 535 /*
 536  * @unimplemented
 537  */
 538 DWORD WINAPI UserRegisterWowHandlers(PVOID Unknown1, PVOID Unknown2)
 539 {
 540   UNIMPLEMENTED;
 541   return 0;
 542 }
 543