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
 544 BOOL
 545 WINAPI
 546 BuildReasonArray(PVOID Pointer)
 547 {
 548     UNIMPLEMENTED;
 549     return FALSE;
 550 }
 551
 552 VOID
 553 WINAPI
 554 CreateSystemThreads(DWORD dwUnknown)
 555 {
 556     NtUserCallOneParam(dwUnknown, ONEPARAM_ROUTINE_CREATESYSTEMTHREADS);
 557 }
 558
 559 BOOL
 560 WINAPI
 561 DestroyReasons(PVOID Pointer)
 562 {
 563     UNIMPLEMENTED;
 564     return FALSE;
 565 }
 566
 567 BOOL
 568 WINAPI
 569 DeviceEventWorker(DWORD dw1, DWORD dw2, DWORD dw3, DWORD dw4, DWORD dw5)
 570 {
 571     UNIMPLEMENTED;
 572     return FALSE;
 573 }
 574
 575 BOOL
 576 WINAPI
 577 GetCursorFrameInfo(DWORD dw1, DWORD dw2, DWORD dw3, DWORD dw4, DWORD dw5)
 578 {
 579     UNIMPLEMENTED;
 580     return FALSE;
 581 }
 582
 583 BOOL
 584 WINAPI
 585 GetReasonTitleFromReasonCode(DWORD dw1, DWORD dw2, DWORD dw3)
 586 {
 587     UNIMPLEMENTED;
 588     return FALSE;
 589 }
 590
 591 BOOL
 592 WINAPI
 593 RecordShutdownReason(DWORD dw0)
 594 {
 595     UNIMPLEMENTED;
 596     return FALSE;
 597 }
 598
 599 BOOL
 600 WINAPI
 601 UserLpkPSMTextOut(DWORD dw1, DWORD dw2, DWORD dw3, DWORD dw4, DWORD dw5, DWORD dw6)
 602 {
 603     UNIMPLEMENTED;
 604     return FALSE;
 605 }
 606
 607 BOOL
 608 WINAPI
 609 UserLpkTabbedTextOut(
 610     DWORD dw1,
 611     DWORD dw2,
 612     DWORD dw3,
 613     DWORD dw4,
 614     DWORD dw5,
 615     DWORD dw6,
 616     DWORD dw7,
 617     DWORD dw8,
 618     DWORD dw9,
 619     DWORD dw10,
 620     DWORD dw11,
 621     DWORD dw12)
 622 {
 623     UNIMPLEMENTED;
 624     return FALSE;
 625 }
 626
 627 BOOL
 628 WINAPI
 629 Win32PoolAllocationStats(DWORD dw1, DWORD dw2, DWORD dw3, DWORD dw4, DWORD dw5)
 630 {
 631     UNIMPLEMENTED;
 632     return FALSE;
 633 }
 634