reactos/win32ss/user/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("(%lu): 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 VOID
  76 WINAPI
  77 LoadLocalFonts ( VOID )
  78 {
  79   UNIMPLEMENTED;
  80 }
  81
  82 /*
  83  * @unimplemented
  84  */
  85 VOID
  86 WINAPI
  87 LoadRemoteFonts ( VOID )
  88 {
  89   UNIMPLEMENTED;
  90 }
  91
  92 /*
  93  * @unimplemented
  94  */
  95 VOID
  96 WINAPI
  97 RegisterSystemThread ( DWORD flags, DWORD reserved )
  98 {
  99   UNIMPLEMENTED;
 100 }
 101
 102
 103 /*
 104  * @implemented
 105  */
 106 UINT
 107 WINAPI
 108 UserRealizePalette ( HDC hDC )
 109 {
 110   return NtUserxRealizePalette(hDC);
 111 }
 112
 113
 114 /*************************************************************************
 115  *              SetSysColorsTemp (USER32.@) (Wine 10/22/2008)
 116  *
 117  * UNDOCUMENTED !!
 118  *
 119  * Called by W98SE desk.cpl Control Panel Applet:
 120  * handle = SetSysColorsTemp(ptr, ptr, nCount);     ("set" call)
 121  * result = SetSysColorsTemp(NULL, NULL, handle);   ("restore" call)
 122  *
 123  * pPens is an array of COLORREF values, which seems to be used
 124  * to indicate the color values to create new pens with.
 125  *
 126  * pBrushes is an array of solid brush handles (returned by a previous
 127  * CreateSolidBrush), which seems to contain the brush handles to set
 128  * for the system colors.
 129  *
 130  * n seems to be used for
 131  *   a) indicating the number of entries to operate on (length of pPens,
 132  *      pBrushes)
 133  *   b) passing the handle that points to the previously used color settings.
 134  *      I couldn't figure out in hell what kind of handle this is on
 135  *      Windows. I just use a heap handle instead. Shouldn't matter anyway.
 136  *
 137  * RETURNS
 138  *     heap handle of our own copy of the current syscolors in case of
 139  *                 "set" call, i.e. pPens, pBrushes != NULL.
 140  *     TRUE (unconditionally !) in case of "restore" call,
 141  *          i.e. pPens, pBrushes == NULL.
 142  *     FALSE in case of either pPens != NULL and pBrushes == NULL
 143  *          or pPens == NULL and pBrushes != NULL.
 144  *
 145  * I'm not sure whether this implementation is 100% correct. [AM]
 146  */
 147
 148 static HPEN SysColorPens[COLOR_MENUBAR + 1];
 149 static HBRUSH SysColorBrushes[COLOR_MENUBAR + 1];
 150
 151 DWORD_PTR
 152 WINAPI
 153 SetSysColorsTemp(const COLORREF *pPens,
 154                  const HBRUSH *pBrushes,
 155                                  DWORD_PTR n)
 156 {
 157     DWORD i;
 158
 159     if (pPens && pBrushes) /* "set" call */
 160     {
 161         /* allocate our structure to remember old colors */
 162         LPVOID pOldCol = HeapAlloc(GetProcessHeap(), 0, sizeof(DWORD)+n*sizeof(HPEN)+n*sizeof(HBRUSH));
 163         LPVOID p = pOldCol;
 164         *(DWORD_PTR *)p = n; p = (char*)p + sizeof(DWORD);
 165         memcpy(p, SysColorPens, n*sizeof(HPEN)); p = (char*)p + n*sizeof(HPEN);
 166         memcpy(p, SysColorBrushes, n*sizeof(HBRUSH)); p = (char*)p + n*sizeof(HBRUSH);
 167
 168         for (i=0; i < n; i++)
 169         {
 170             SysColorPens[i] = CreatePen( PS_SOLID, 1, pPens[i] );
 171             SysColorBrushes[i] = pBrushes[i];
 172         }
 173
 174         return (DWORD_PTR) pOldCol;
 175     }
 176     if (!pPens && !pBrushes) /* "restore" call */
 177     {
 178         LPVOID pOldCol = (LPVOID)n;
 179         LPVOID p = pOldCol;
 180         DWORD nCount = *(DWORD *)p;
 181         p = (char*)p + sizeof(DWORD);
 182
 183         for (i=0; i < nCount; i++)
 184         {
 185             DeleteObject(SysColorPens[i]);
 186             SysColorPens[i] = *(HPEN *)p; p = (char*)p + sizeof(HPEN);
 187         }
 188         for (i=0; i < nCount; i++)
 189         {
 190             SysColorBrushes[i] = *(HBRUSH *)p; p = (char*)p + sizeof(HBRUSH);
 191         }
 192         /* get rid of storage structure */
 193         HeapFree(GetProcessHeap(), 0, pOldCol);
 194
 195         return TRUE;
 196     }
 197     return FALSE;
 198 }
 199
 200 /*
 201  * @unimplemented
 202  */
 203 HDESK
 204 WINAPI
 205 GetInputDesktop ( VOID )
 206 {
 207   UNIMPLEMENTED;
 208   return FALSE;
 209 }
 210
 211 /*
 212  * @unimplemented
 213  */
 214 BOOL
 215 WINAPI
 216 GetAccCursorInfo ( PCURSORINFO pci )
 217 {
 218   UNIMPLEMENTED;
 219   return FALSE;
 220 }
 221
 222 /*
 223  * @unimplemented
 224  */
 225 BOOL
 226 WINAPI
 227 ClientThreadSetup ( VOID )
 228 {
 229   UNIMPLEMENTED;
 230   return FALSE;
 231 }
 232
 233 /*
 234  * @unimplemented
 235  */
 236 UINT
 237 WINAPI
 238 GetRawInputDeviceInfoW(
 239     HANDLE hDevice,
 240     UINT uiCommand,
 241     LPVOID pData,
 242     PUINT pcbSize)
 243 {
 244   UNIMPLEMENTED;
 245   return 0;
 246 }
 247
 248 /*
 249  * @unimplemented
 250  */
 251 LONG
 252 WINAPI
 253 CsrBroadcastSystemMessageExW(
 254     DWORD dwflags,
 255     LPDWORD lpdwRecipients,
 256     UINT uiMessage,
 257     WPARAM wParam,
 258     LPARAM lParam,
 259     PBSMINFO pBSMInfo)
 260 {
 261   UNIMPLEMENTED;
 262   return FALSE;
 263 }
 264
 265 /*
 266  * @unimplemented
 267  */
 268 UINT
 269 WINAPI
 270 GetRawInputDeviceInfoA(
 271     HANDLE hDevice,
 272     UINT uiCommand,
 273     LPVOID pData,
 274     PUINT pcbSize)
 275 {
 276   UNIMPLEMENTED;
 277   return 0;
 278 }
 279
 280 /*
 281  * @unimplemented
 282  */
 283 BOOL
 284 WINAPI
 285 AlignRects(LPRECT rect, DWORD b, DWORD c, DWORD d)
 286 {
 287   UNIMPLEMENTED;
 288   return FALSE;
 289 }
 290
 291 /*
 292  * @implemented
 293  */
 294 LRESULT
 295 WINAPI
 296 DefRawInputProc(
 297     PRAWINPUT* paRawInput,
 298     INT nInput,
 299     UINT cbSizeHeader)
 300 {
 301   if (cbSizeHeader == sizeof(RAWINPUTHEADER))
 302      return S_OK;
 303   return 1;
 304 }
 305
 306 /*
 307  * @unimplemented
 308  */
 309 UINT
 310 WINAPI
 311 GetRawInputBuffer(
 312     PRAWINPUT pData,
 313     PUINT pcbSize,
 314     UINT cbSizeHeader)
 315 {
 316   UNIMPLEMENTED;
 317   return 0;
 318 }
 319
 320 /*
 321  * @unimplemented
 322  */
 323 UINT
 324 WINAPI
 325 GetRawInputData(
 326     HRAWINPUT hRawInput,
 327     UINT uiCommand,
 328     LPVOID pData,
 329     PUINT pcbSize,
 330     UINT cbSizeHeader)
 331 {
 332   UNIMPLEMENTED;
 333   return 0;
 334 }
 335
 336 /*
 337  * @unimplemented
 338  */
 339 UINT
 340 WINAPI
 341 GetRawInputDeviceList(
 342     PRAWINPUTDEVICELIST pRawInputDeviceList,
 343     PUINT puiNumDevices,
 344     UINT cbSize)
 345 {
 346     if(pRawInputDeviceList)
 347         memset(pRawInputDeviceList, 0, sizeof *pRawInputDeviceList);
 348     *puiNumDevices = 0;
 349
 350     UNIMPLEMENTED;
 351     return 0;
 352 }
 353
 354 /*
 355  * @unimplemented
 356  */
 357 UINT
 358 WINAPI
 359 GetRegisteredRawInputDevices(
 360     PRAWINPUTDEVICE pRawInputDevices,
 361     PUINT puiNumDevices,
 362     UINT cbSize)
 363 {
 364   UNIMPLEMENTED;
 365   return 0;
 366 }
 367
 368 /*
 369  * @unimplemented
 370  */
 371 BOOL
 372 WINAPI
 373 RegisterRawInputDevices(
 374     PCRAWINPUTDEVICE pRawInputDevices,
 375     UINT uiNumDevices,
 376     UINT cbSize)
 377 {
 378   UNIMPLEMENTED;
 379   return FALSE;
 380 }
 381
 382 /*
 383  * @unimplemented
 384  */
 385 BOOL WINAPI DisplayExitWindowsWarnings(ULONG flags)
 386 {
 387   UNIMPLEMENTED;
 388   return FALSE;
 389 }
 390
 391 /*
 392  * @unimplemented
 393  */
 394 BOOL WINAPI ReasonCodeNeedsBugID(ULONG reasoncode)
 395 {
 396   UNIMPLEMENTED;
 397   return FALSE;
 398 }
 399
 400 /*
 401  * @unimplemented
 402  */
 403 BOOL WINAPI ReasonCodeNeedsComment(ULONG reasoncode)
 404 {
 405   UNIMPLEMENTED;
 406   return FALSE;
 407 }
 408
 409 /*
 410  * @unimplemented
 411  */
 412 BOOL WINAPI CtxInitUser32(VOID)
 413 {
 414   UNIMPLEMENTED;
 415   return FALSE;
 416 }
 417
 418 /*
 419  * @unimplemented
 420  */
 421 BOOL WINAPI EnterReaderModeHelper(HWND hwnd)
 422 {
 423   UNIMPLEMENTED;
 424   return FALSE;
 425 }
 426
 427 /*
 428  * @unimplemented
 429  */
 430 VOID WINAPI InitializeLpkHooks(FARPROC *hookfuncs)
 431 {
 432   UNIMPLEMENTED;
 433 }
 434
 435 /*
 436  * @unimplemented
 437  */
 438 WORD WINAPI InitializeWin32EntryTable(UCHAR* EntryTablePlus0x1000)
 439 {
 440   UNIMPLEMENTED;
 441   return FALSE;
 442 }
 443
 444 /*
 445  * @unimplemented
 446  */
 447 BOOL WINAPI IsServerSideWindow(HWND wnd)
 448 {
 449   UNIMPLEMENTED;
 450   return FALSE;
 451 }
 452
 453 /*
 454  * @unimplemented
 455  */
 456 HKL WINAPI LoadKeyboardLayoutEx(DWORD unknown,LPCWSTR pwszKLID,UINT Flags) //1st parameter unknown
 457 {
 458   UNIMPLEMENTED;
 459   return FALSE;
 460 }
 461
 462 /*
 463  * @unimplemented
 464  */
 465 VOID WINAPI AllowForegroundActivation(VOID)
 466 {
 467   UNIMPLEMENTED;
 468 }
 469
 470 /*
 471  * @unimplemented
 472  */
 473 VOID WINAPI ShowStartGlass(DWORD unknown)
 474 {
 475   UNIMPLEMENTED;
 476 }
 477
 478 /*
 479  * @unimplemented
 480  */
 481 BOOL WINAPI DdeGetQualityOfService(HWND hWnd, DWORD Reserved, PSECURITY_QUALITY_OF_SERVICE pqosPrev)
 482 {
 483   UNIMPLEMENTED;
 484   return FALSE;
 485 }
 486
 487 /*
 488  * @unimplemented
 489  */
 490 BOOL WINAPI SetProcessDPIAware(VOID)
 491 {
 492     UNIMPLEMENTED;
 493     return TRUE;
 494 }
 495
 496 /*
 497  * @unimplemented
 498  */
 499 BOOL WINAPI CliImmSetHotKey(DWORD dwID, UINT uModifiers, UINT uVirtualKey, HKL hKl)
 500 {
 501   UNIMPLEMENTED;
 502   return FALSE;
 503 }
 504
 505 /*
 506  * @implemented
 507  */
 508 DWORD WINAPI GetMenuIndex(HMENU hMenu, HMENU hSubMenu)
 509 {
 510   return NtUserGetMenuIndex(hMenu, hSubMenu);
 511 }
 512
 513 /*
 514  * @unimplemented
 515  */
 516 DWORD WINAPI UserRegisterWowHandlers(PVOID Unknown1, PVOID Unknown2)
 517 {
 518   UNIMPLEMENTED;
 519   return 0;
 520 }
 521
 522 BOOL
 523 WINAPI
 524 BuildReasonArray(PVOID Pointer)
 525 {
 526     UNIMPLEMENTED;
 527     return FALSE;
 528 }
 529
 530 VOID
 531 WINAPI
 532 CreateSystemThreads(DWORD dwUnknown)
 533 {
 534     NtUserxCreateSystemThreads(dwUnknown);
 535     ExitThread(0);
 536 }
 537
 538 BOOL
 539 WINAPI
 540 DestroyReasons(PVOID Pointer)
 541 {
 542     UNIMPLEMENTED;
 543     return FALSE;
 544 }
 545
 546 BOOL
 547 WINAPI
 548 DeviceEventWorker(DWORD dw1, DWORD dw2, DWORD dw3, DWORD dw4, DWORD dw5)
 549 {
 550     UNIMPLEMENTED;
 551     return FALSE;
 552 }
 553
 554 HCURSOR
 555 WINAPI
 556 GetCursorFrameInfo(HCURSOR hCursor, LPCWSTR name, DWORD istep, PDWORD rate_jiffies, INT *num_steps)
 557 {
 558    if (hCursor) return NtUserGetCursorFrameInfo(hCursor, istep, rate_jiffies, num_steps);
 559
 560    return LoadImageW( NULL, name, IMAGE_CURSOR, 0, 0, LR_DEFAULTSIZE );
 561 }
 562
 563 BOOL
 564 WINAPI
 565 GetReasonTitleFromReasonCode(DWORD dw1, DWORD dw2, DWORD dw3)
 566 {
 567     UNIMPLEMENTED;
 568     return FALSE;
 569 }
 570
 571 BOOL
 572 WINAPI
 573 RecordShutdownReason(DWORD dw0)
 574 {
 575     UNIMPLEMENTED;
 576     return FALSE;
 577 }
 578
 579 BOOL
 580 WINAPI
 581 UserLpkPSMTextOut(DWORD dw1, DWORD dw2, DWORD dw3, DWORD dw4, DWORD dw5, DWORD dw6)
 582 {
 583     UNIMPLEMENTED;
 584     return FALSE;
 585 }
 586
 587 BOOL
 588 WINAPI
 589 UserLpkTabbedTextOut(
 590     DWORD dw1,
 591     DWORD dw2,
 592     DWORD dw3,
 593     DWORD dw4,
 594     DWORD dw5,
 595     DWORD dw6,
 596     DWORD dw7,
 597     DWORD dw8,
 598     DWORD dw9,
 599     DWORD dw10,
 600     DWORD dw11,
 601     DWORD dw12)
 602 {
 603     UNIMPLEMENTED;
 604     return FALSE;
 605 }
 606
 607 BOOL
 608 WINAPI
 609 Win32PoolAllocationStats(DWORD dw1, DWORD dw2, DWORD dw3, DWORD dw4, DWORD dw5)
 610 {
 611     UNIMPLEMENTED;
 612     return FALSE;
 613 }
 614