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 UINT
 226 WINAPI
 227 GetRawInputDeviceInfoW(
 228     HANDLE hDevice,
 229     UINT uiCommand,
 230     LPVOID pData,
 231     PUINT pcbSize)
 232 {
 233   UNIMPLEMENTED;
 234   return 0;
 235 }
 236
 237 /*
 238  * @unimplemented
 239  */
 240 LONG
 241 WINAPI
 242 CsrBroadcastSystemMessageExW(
 243     DWORD dwflags,
 244     LPDWORD lpdwRecipients,
 245     UINT uiMessage,
 246     WPARAM wParam,
 247     LPARAM lParam,
 248     PBSMINFO pBSMInfo)
 249 {
 250   UNIMPLEMENTED;
 251   return FALSE;
 252 }
 253
 254 /*
 255  * @unimplemented
 256  */
 257 UINT
 258 WINAPI
 259 GetRawInputDeviceInfoA(
 260     HANDLE hDevice,
 261     UINT uiCommand,
 262     LPVOID pData,
 263     PUINT pcbSize)
 264 {
 265   UNIMPLEMENTED;
 266   return 0;
 267 }
 268
 269 /*
 270  * @unimplemented
 271  */
 272 BOOL
 273 WINAPI
 274 AlignRects(LPRECT rect, DWORD b, DWORD c, DWORD d)
 275 {
 276   UNIMPLEMENTED;
 277   return FALSE;
 278 }
 279
 280 /*
 281  * @implemented
 282  */
 283 LRESULT
 284 WINAPI
 285 DefRawInputProc(
 286     PRAWINPUT* paRawInput,
 287     INT nInput,
 288     UINT cbSizeHeader)
 289 {
 290   if (cbSizeHeader == sizeof(RAWINPUTHEADER))
 291      return S_OK;
 292   return 1;
 293 }
 294
 295 /*
 296  * @unimplemented
 297  */
 298 UINT
 299 WINAPI
 300 GetRawInputBuffer(
 301     PRAWINPUT pData,
 302     PUINT pcbSize,
 303     UINT cbSizeHeader)
 304 {
 305   UNIMPLEMENTED;
 306   return 0;
 307 }
 308
 309 /*
 310  * @unimplemented
 311  */
 312 UINT
 313 WINAPI
 314 GetRawInputData(
 315     HRAWINPUT hRawInput,
 316     UINT uiCommand,
 317     LPVOID pData,
 318     PUINT pcbSize,
 319     UINT cbSizeHeader)
 320 {
 321   UNIMPLEMENTED;
 322   return 0;
 323 }
 324
 325 /*
 326  * @unimplemented
 327  */
 328 UINT
 329 WINAPI
 330 GetRawInputDeviceList(
 331     PRAWINPUTDEVICELIST pRawInputDeviceList,
 332     PUINT puiNumDevices,
 333     UINT cbSize)
 334 {
 335     if(pRawInputDeviceList)
 336         memset(pRawInputDeviceList, 0, sizeof *pRawInputDeviceList);
 337     *puiNumDevices = 0;
 338
 339     UNIMPLEMENTED;
 340     return 0;
 341 }
 342
 343 /*
 344  * @unimplemented
 345  */
 346 UINT
 347 WINAPI
 348 GetRegisteredRawInputDevices(
 349     PRAWINPUTDEVICE pRawInputDevices,
 350     PUINT puiNumDevices,
 351     UINT cbSize)
 352 {
 353   UNIMPLEMENTED;
 354   return 0;
 355 }
 356
 357 /*
 358  * @unimplemented
 359  */
 360 BOOL
 361 WINAPI
 362 RegisterRawInputDevices(
 363     PCRAWINPUTDEVICE pRawInputDevices,
 364     UINT uiNumDevices,
 365     UINT cbSize)
 366 {
 367   UNIMPLEMENTED;
 368   return FALSE;
 369 }
 370
 371 /*
 372  * @unimplemented
 373  */
 374 BOOL WINAPI DisplayExitWindowsWarnings(ULONG flags)
 375 {
 376   UNIMPLEMENTED;
 377   return FALSE;
 378 }
 379
 380 /*
 381  * @unimplemented
 382  */
 383 BOOL WINAPI ReasonCodeNeedsBugID(ULONG reasoncode)
 384 {
 385   UNIMPLEMENTED;
 386   return FALSE;
 387 }
 388
 389 /*
 390  * @unimplemented
 391  */
 392 BOOL WINAPI ReasonCodeNeedsComment(ULONG reasoncode)
 393 {
 394   UNIMPLEMENTED;
 395   return FALSE;
 396 }
 397
 398 /*
 399  * @unimplemented
 400  */
 401 BOOL WINAPI CtxInitUser32(VOID)
 402 {
 403   UNIMPLEMENTED;
 404   return FALSE;
 405 }
 406
 407 /*
 408  * @unimplemented
 409  */
 410 BOOL WINAPI EnterReaderModeHelper(HWND hwnd)
 411 {
 412   UNIMPLEMENTED;
 413   return FALSE;
 414 }
 415
 416 /*
 417  * @unimplemented
 418  */
 419 VOID WINAPI InitializeLpkHooks(FARPROC *hookfuncs)
 420 {
 421   UNIMPLEMENTED;
 422 }
 423
 424 /*
 425  * @unimplemented
 426  */
 427 WORD WINAPI InitializeWin32EntryTable(UCHAR* EntryTablePlus0x1000)
 428 {
 429   UNIMPLEMENTED;
 430   return FALSE;
 431 }
 432
 433 /*
 434  * @unimplemented
 435  */
 436 BOOL WINAPI IsServerSideWindow(HWND wnd)
 437 {
 438   UNIMPLEMENTED;
 439   return FALSE;
 440 }
 441
 442 /*
 443  * @unimplemented
 444  */
 445 HKL WINAPI LoadKeyboardLayoutEx(DWORD unknown,LPCWSTR pwszKLID,UINT Flags) //1st parameter unknown
 446 {
 447   UNIMPLEMENTED;
 448   return FALSE;
 449 }
 450
 451 /*
 452  * @unimplemented
 453  */
 454 VOID WINAPI AllowForegroundActivation(VOID)
 455 {
 456   UNIMPLEMENTED;
 457 }
 458
 459 /*
 460  * @unimplemented
 461  */
 462 VOID WINAPI ShowStartGlass(DWORD unknown)
 463 {
 464   UNIMPLEMENTED;
 465 }
 466
 467 /*
 468  * @unimplemented
 469  */
 470 BOOL WINAPI DdeGetQualityOfService(HWND hWnd, DWORD Reserved, PSECURITY_QUALITY_OF_SERVICE pqosPrev)
 471 {
 472   UNIMPLEMENTED;
 473   return FALSE;
 474 }
 475
 476 /*
 477  * @unimplemented
 478  */
 479 BOOL WINAPI SetProcessDPIAware(VOID)
 480 {
 481     UNIMPLEMENTED;
 482     return TRUE;
 483 }
 484
 485 /*
 486  * @unimplemented
 487  */
 488 BOOL WINAPI CliImmSetHotKey(DWORD dwID, UINT uModifiers, UINT uVirtualKey, HKL hKl)
 489 {
 490   UNIMPLEMENTED;
 491   return FALSE;
 492 }
 493
 494 /*
 495  * @implemented
 496  */
 497 DWORD WINAPI GetMenuIndex(HMENU hMenu, HMENU hSubMenu)
 498 {
 499   return NtUserGetMenuIndex(hMenu, hSubMenu);
 500 }
 501
 502 /*
 503  * @unimplemented
 504  */
 505 DWORD WINAPI UserRegisterWowHandlers(PVOID Unknown1, PVOID Unknown2)
 506 {
 507   UNIMPLEMENTED;
 508   return 0;
 509 }
 510
 511 BOOL
 512 WINAPI
 513 BuildReasonArray(PVOID Pointer)
 514 {
 515     UNIMPLEMENTED;
 516     return FALSE;
 517 }
 518
 519 VOID
 520 WINAPI
 521 CreateSystemThreads(DWORD dwUnknown)
 522 {
 523     NtUserxCreateSystemThreads(dwUnknown);
 524     ExitThread(0);
 525 }
 526
 527 BOOL
 528 WINAPI
 529 DestroyReasons(PVOID Pointer)
 530 {
 531     UNIMPLEMENTED;
 532     return FALSE;
 533 }
 534
 535 BOOL
 536 WINAPI
 537 DeviceEventWorker(DWORD dw1, DWORD dw2, DWORD dw3, DWORD dw4, DWORD dw5)
 538 {
 539     UNIMPLEMENTED;
 540     return FALSE;
 541 }
 542
 543 HCURSOR
 544 WINAPI
 545 GetCursorFrameInfo(HCURSOR hCursor, LPCWSTR name, DWORD istep, PDWORD rate_jiffies, INT *num_steps)
 546 {
 547    if (hCursor) return NtUserGetCursorFrameInfo(hCursor, istep, rate_jiffies, num_steps);
 548
 549    return LoadImageW( NULL, name, IMAGE_CURSOR, 0, 0, LR_DEFAULTSIZE );
 550 }
 551
 552 BOOL
 553 WINAPI
 554 GetReasonTitleFromReasonCode(DWORD dw1, DWORD dw2, DWORD dw3)
 555 {
 556     UNIMPLEMENTED;
 557     return FALSE;
 558 }
 559
 560 BOOL
 561 WINAPI
 562 RecordShutdownReason(DWORD dw0)
 563 {
 564     UNIMPLEMENTED;
 565     return FALSE;
 566 }
 567
 568 BOOL
 569 WINAPI
 570 UserLpkPSMTextOut(DWORD dw1, DWORD dw2, DWORD dw3, DWORD dw4, DWORD dw5, DWORD dw6)
 571 {
 572     UNIMPLEMENTED;
 573     return FALSE;
 574 }
 575
 576 BOOL
 577 WINAPI
 578 UserLpkTabbedTextOut(
 579     DWORD dw1,
 580     DWORD dw2,
 581     DWORD dw3,
 582     DWORD dw4,
 583     DWORD dw5,
 584     DWORD dw6,
 585     DWORD dw7,
 586     DWORD dw8,
 587     DWORD dw9,
 588     DWORD dw10,
 589     DWORD dw11,
 590     DWORD dw12)
 591 {
 592     UNIMPLEMENTED;
 593     return FALSE;
 594 }
 595
 596 BOOL
 597 WINAPI
 598 Win32PoolAllocationStats(DWORD dw1, DWORD dw2, DWORD dw3, DWORD dw4, DWORD dw5)
 599 {
 600     UNIMPLEMENTED;
 601     return FALSE;
 602 }
 603