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 DECLSPEC_HOTPATCH
 301 GetRawInputBuffer(
 302     PRAWINPUT pData,
 303     PUINT pcbSize,
 304     UINT cbSizeHeader)
 305 {
 306   UNIMPLEMENTED;
 307   return 0;
 308 }
 309
 310 /*
 311  * @unimplemented
 312  */
 313 UINT
 314 WINAPI
 315 GetRawInputData(
 316     HRAWINPUT hRawInput,
 317     UINT uiCommand,
 318     LPVOID pData,
 319     PUINT pcbSize,
 320     UINT cbSizeHeader)
 321 {
 322   UNIMPLEMENTED;
 323   return 0;
 324 }
 325
 326 /*
 327  * @unimplemented
 328  */
 329 UINT
 330 WINAPI
 331 GetRawInputDeviceList(
 332     PRAWINPUTDEVICELIST pRawInputDeviceList,
 333     PUINT puiNumDevices,
 334     UINT cbSize)
 335 {
 336     if(pRawInputDeviceList)
 337         memset(pRawInputDeviceList, 0, sizeof *pRawInputDeviceList);
 338     *puiNumDevices = 0;
 339
 340     UNIMPLEMENTED;
 341     return 0;
 342 }
 343
 344 /*
 345  * @unimplemented
 346  */
 347 UINT
 348 WINAPI
 349 DECLSPEC_HOTPATCH
 350 GetRegisteredRawInputDevices(
 351     PRAWINPUTDEVICE pRawInputDevices,
 352     PUINT puiNumDevices,
 353     UINT cbSize)
 354 {
 355   UNIMPLEMENTED;
 356   return 0;
 357 }
 358
 359 /*
 360  * @unimplemented
 361  */
 362 BOOL
 363 WINAPI
 364 DECLSPEC_HOTPATCH
 365 RegisterRawInputDevices(
 366     PCRAWINPUTDEVICE pRawInputDevices,
 367     UINT uiNumDevices,
 368     UINT cbSize)
 369 {
 370   UNIMPLEMENTED;
 371   return FALSE;
 372 }
 373
 374 /*
 375  * @unimplemented
 376  */
 377 BOOL WINAPI DisplayExitWindowsWarnings(ULONG flags)
 378 {
 379   UNIMPLEMENTED;
 380   return FALSE;
 381 }
 382
 383 /*
 384  * @unimplemented
 385  */
 386 BOOL WINAPI ReasonCodeNeedsBugID(ULONG reasoncode)
 387 {
 388   UNIMPLEMENTED;
 389   return FALSE;
 390 }
 391
 392 /*
 393  * @unimplemented
 394  */
 395 BOOL WINAPI ReasonCodeNeedsComment(ULONG reasoncode)
 396 {
 397   UNIMPLEMENTED;
 398   return FALSE;
 399 }
 400
 401 /*
 402  * @unimplemented
 403  */
 404 BOOL WINAPI CtxInitUser32(VOID)
 405 {
 406   UNIMPLEMENTED;
 407   return FALSE;
 408 }
 409
 410 /*
 411  * @unimplemented
 412  */
 413 BOOL WINAPI EnterReaderModeHelper(HWND hwnd)
 414 {
 415   UNIMPLEMENTED;
 416   return FALSE;
 417 }
 418
 419 /*
 420  * @unimplemented
 421  */
 422 VOID WINAPI InitializeLpkHooks(FARPROC *hookfuncs)
 423 {
 424   UNIMPLEMENTED;
 425 }
 426
 427 /*
 428  * @unimplemented
 429  */
 430 WORD WINAPI InitializeWin32EntryTable(UCHAR* EntryTablePlus0x1000)
 431 {
 432   UNIMPLEMENTED;
 433   return FALSE;
 434 }
 435
 436 /*
 437  * @unimplemented
 438  */
 439 BOOL WINAPI IsServerSideWindow(HWND wnd)
 440 {
 441   UNIMPLEMENTED;
 442   return FALSE;
 443 }
 444
 445 /*
 446  * @unimplemented
 447  */
 448 HKL WINAPI LoadKeyboardLayoutEx(DWORD unknown,LPCWSTR pwszKLID,UINT Flags) //1st parameter unknown
 449 {
 450   UNIMPLEMENTED;
 451   return FALSE;
 452 }
 453
 454 /*
 455  * @unimplemented
 456  */
 457 VOID WINAPI AllowForegroundActivation(VOID)
 458 {
 459   UNIMPLEMENTED;
 460 }
 461
 462 /*
 463  * @unimplemented
 464  */
 465 VOID WINAPI ShowStartGlass(DWORD unknown)
 466 {
 467   UNIMPLEMENTED;
 468 }
 469
 470 /*
 471  * @unimplemented
 472  */
 473 BOOL WINAPI DdeGetQualityOfService(HWND hWnd, DWORD Reserved, PSECURITY_QUALITY_OF_SERVICE pqosPrev)
 474 {
 475   UNIMPLEMENTED;
 476   return FALSE;
 477 }
 478
 479 /*
 480  * @unimplemented
 481  */
 482 BOOL WINAPI CliImmSetHotKey(DWORD dwID, UINT uModifiers, UINT uVirtualKey, HKL hKl)
 483 {
 484   UNIMPLEMENTED;
 485   return FALSE;
 486 }
 487
 488 /*
 489  * @implemented
 490  */
 491 DWORD WINAPI GetMenuIndex(HMENU hMenu, HMENU hSubMenu)
 492 {
 493   return NtUserGetMenuIndex(hMenu, hSubMenu);
 494 }
 495
 496 /*
 497  * @unimplemented
 498  */
 499 DWORD WINAPI UserRegisterWowHandlers(PVOID Unknown1, PVOID Unknown2)
 500 {
 501   UNIMPLEMENTED;
 502   return 0;
 503 }
 504
 505 BOOL
 506 WINAPI
 507 BuildReasonArray(PVOID Pointer)
 508 {
 509     UNIMPLEMENTED;
 510     return FALSE;
 511 }
 512
 513 VOID
 514 WINAPI
 515 CreateSystemThreads(DWORD dwUnknown)
 516 {
 517     NtUserxCreateSystemThreads(dwUnknown);
 518     ExitThread(0);
 519 }
 520
 521 BOOL
 522 WINAPI
 523 DestroyReasons(PVOID Pointer)
 524 {
 525     UNIMPLEMENTED;
 526     return FALSE;
 527 }
 528
 529 BOOL
 530 WINAPI
 531 DeviceEventWorker(DWORD dw1, DWORD dw2, DWORD dw3, DWORD dw4, DWORD dw5)
 532 {
 533     UNIMPLEMENTED;
 534     return FALSE;
 535 }
 536
 537 BOOL
 538 WINAPI
 539 GetReasonTitleFromReasonCode(DWORD dw1, DWORD dw2, DWORD dw3)
 540 {
 541     UNIMPLEMENTED;
 542     return FALSE;
 543 }
 544
 545 BOOL
 546 WINAPI
 547 IsSETEnabled(VOID)
 548 {
 549     /*
 550      * Determines whether the Shutdown Event Tracker is enabled.
 551      *
 552      * See http://undoc.airesoft.co.uk/user32.dll/IsSETEnabled.php
 553      * for more information.
 554      */
 555     UNIMPLEMENTED;
 556     return FALSE;
 557 }
 558
 559 BOOL
 560 WINAPI
 561 RecordShutdownReason(DWORD dw0)
 562 {
 563     UNIMPLEMENTED;
 564     return FALSE;
 565 }
 566
 567 BOOL
 568 WINAPI
 569 UserLpkPSMTextOut(DWORD dw1, DWORD dw2, DWORD dw3, DWORD dw4, DWORD dw5, DWORD dw6)
 570 {
 571     UNIMPLEMENTED;
 572     return FALSE;
 573 }
 574
 575 BOOL
 576 WINAPI
 577 UserLpkTabbedTextOut(
 578     DWORD dw1,
 579     DWORD dw2,
 580     DWORD dw3,
 581     DWORD dw4,
 582     DWORD dw5,
 583     DWORD dw6,
 584     DWORD dw7,
 585     DWORD dw8,
 586     DWORD dw9,
 587     DWORD dw10,
 588     DWORD dw11,
 589     DWORD dw12)
 590 {
 591     UNIMPLEMENTED;
 592     return FALSE;
 593 }
 594
 595 BOOL
 596 WINAPI
 597 Win32PoolAllocationStats(DWORD dw1, DWORD dw2, DWORD dw3, DWORD dw4, DWORD dw5)
 598 {
 599     UNIMPLEMENTED;
 600     return FALSE;
 601 }
 602