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 int
  22 WINAPI
  23 GetMouseMovePointsEx(
  24   UINT cbSize,
  25   LPMOUSEMOVEPOINT lppt,
  26   LPMOUSEMOVEPOINT lpptBuf,
  27   int nBufPoints,
  28   DWORD resolution)
  29 {
  30     if((cbSize != sizeof(MOUSEMOVEPOINT)) || (nBufPoints < 0) || (nBufPoints > 64))
  31         {
  32         SetLastError(ERROR_INVALID_PARAMETER);
  33         return -1;
  34     }
  35
  36     if(!lppt || !lpptBuf)
  37         {
  38         SetLastError(ERROR_NOACCESS);
  39         return -1;
  40     }
  41
  42     UNIMPLEMENTED;
  43
  44     SetLastError(ERROR_POINT_NOT_FOUND);
  45     return -1;
  46 }
  47
  48
  49 /*
  50  * @implemented
  51  */
  52 BOOL
  53 WINAPI
  54 LockWindowUpdate(
  55   HWND hWndLock)
  56 {
  57     return NtUserLockWindowUpdate(hWndLock);
  58 }
  59
  60
  61 /*
  62  * @unimplemented
  63  */
  64 BOOL
  65 WINAPI
  66 LockWorkStation(VOID)
  67 {
  68   UNIMPLEMENTED;
  69   return FALSE;
  70 }
  71
  72
  73 /*
  74  * @unimplemented
  75  */
  76 DWORD
  77 WINAPI
  78 WaitForInputIdle(
  79   HANDLE hProcess,
  80   DWORD dwMilliseconds)
  81 {
  82 // Need to call NtQueryInformationProcess and send ProcessId not hProcess.
  83   return NtUserWaitForInputIdle(hProcess, dwMilliseconds, FALSE);
  84 }
  85
  86 /******************************************************************************
  87  * SetDebugErrorLevel [USER32.@]
  88  * Sets the minimum error level for generating debugging events
  89  *
  90  * PARAMS
  91  *    dwLevel [I] Debugging error level
  92  *
  93  * @unimplemented
  94  */
  95 VOID
  96 WINAPI
  97 SetDebugErrorLevel( DWORD dwLevel )
  98 {
  99     DbgPrint("(%ld): stub\n", dwLevel);
 100 }
 101
 102
 103 /*
 104  * @implemented
 105  */
 106 DWORD
 107 WINAPI
 108 GetAppCompatFlags(HTASK hTask)
 109 {
 110     PCLIENTINFO pci = GetWin32ClientInfo();
 111
 112     return pci->dwCompatFlags;
 113 }
 114
 115 /*
 116  * @implemented
 117  */
 118 DWORD
 119 WINAPI
 120 GetAppCompatFlags2(HTASK hTask)
 121 {
 122     PCLIENTINFO pci = GetWin32ClientInfo();
 123
 124     return pci->dwCompatFlags2;
 125 }
 126
 127 /*
 128  * @unimplemented
 129  */
 130 UINT
 131 WINAPI
 132 GetInternalWindowPos(
 133                      HWND hwnd,
 134                      LPRECT rectWnd,
 135                      LPPOINT ptIcon
 136                      )
 137 {
 138     WINDOWPLACEMENT wndpl;
 139
 140     if (GetWindowPlacement(hwnd, &wndpl))
 141     {
 142                 if (rectWnd) *rectWnd = wndpl.rcNormalPosition;
 143                 if (ptIcon)  *ptIcon = wndpl.ptMinPosition;
 144                 return wndpl.showCmd;
 145     }
 146     return 0;
 147 }
 148
 149 /*
 150  * @unimplemented
 151  */
 152 VOID
 153 WINAPI
 154 LoadLocalFonts ( VOID )
 155 {
 156   UNIMPLEMENTED;
 157 }
 158
 159 /*
 160  * @unimplemented
 161  */
 162 VOID
 163 WINAPI
 164 LoadRemoteFonts ( VOID )
 165 {
 166   UNIMPLEMENTED;
 167 }
 168
 169 /*
 170  * @unimplemented
 171  */
 172 VOID
 173 WINAPI
 174 SetInternalWindowPos(
 175                      HWND    hwnd,
 176                      UINT    showCmd,
 177                      LPRECT  rect,
 178                      LPPOINT pt
 179                      )
 180 {
 181   UNIMPLEMENTED;
 182 }
 183
 184 /*
 185  * @unimplemented
 186  */
 187 VOID
 188 WINAPI
 189 RegisterSystemThread ( DWORD flags, DWORD reserved )
 190 {
 191   UNIMPLEMENTED;
 192 }
 193
 194 /*
 195  * @unimplemented
 196  */
 197 DWORD
 198 WINAPI
 199 RegisterTasklist ( DWORD x )
 200 {
 201   UNIMPLEMENTED;
 202   return FALSE;
 203 }
 204
 205 /*
 206  * @unimplemented
 207  */
 208 DWORD
 209 WINAPI
 210 DragObject(
 211            HWND    hwnd1,
 212            HWND    hwnd2,
 213            UINT    u1,
 214            ULONG_PTR   dw1,
 215            HCURSOR hc1
 216            )
 217 {
 218   return NtUserDragObject(hwnd1, hwnd2, u1, dw1, hc1);
 219 }
 220
 221
 222
 223
 224 /*
 225  * @implemented
 226  */
 227 UINT
 228 WINAPI
 229 UserRealizePalette ( HDC hDC )
 230 {
 231   return NtUserCallOneParam((DWORD) hDC, ONEPARAM_ROUTINE_REALIZEPALETTE);
 232 }
 233
 234
 235 /*************************************************************************
 236  *              SetSysColorsTemp (USER32.@) (Wine 10/22/2008)
 237  *
 238  * UNDOCUMENTED !!
 239  *
 240  * Called by W98SE desk.cpl Control Panel Applet:
 241  * handle = SetSysColorsTemp(ptr, ptr, nCount);     ("set" call)
 242  * result = SetSysColorsTemp(NULL, NULL, handle);   ("restore" call)
 243  *
 244  * pPens is an array of COLORREF values, which seems to be used
 245  * to indicate the color values to create new pens with.
 246  *
 247  * pBrushes is an array of solid brush handles (returned by a previous
 248  * CreateSolidBrush), which seems to contain the brush handles to set
 249  * for the system colors.
 250  *
 251  * n seems to be used for
 252  *   a) indicating the number of entries to operate on (length of pPens,
 253  *      pBrushes)
 254  *   b) passing the handle that points to the previously used color settings.
 255  *      I couldn't figure out in hell what kind of handle this is on
 256  *      Windows. I just use a heap handle instead. Shouldn't matter anyway.
 257  *
 258  * RETURNS
 259  *     heap handle of our own copy of the current syscolors in case of
 260  *                 "set" call, i.e. pPens, pBrushes != NULL.
 261  *     TRUE (unconditionally !) in case of "restore" call,
 262  *          i.e. pPens, pBrushes == NULL.
 263  *     FALSE in case of either pPens != NULL and pBrushes == NULL
 264  *          or pPens == NULL and pBrushes != NULL.
 265  *
 266  * I'm not sure whether this implementation is 100% correct. [AM]
 267  */
 268
 269 static HPEN SysColorPens[COLOR_MENUBAR + 1];
 270 static HBRUSH SysColorBrushes[COLOR_MENUBAR + 1];
 271
 272 DWORD
 273 WINAPI
 274 SetSysColorsTemp(const COLORREF *pPens,
 275                  const HBRUSH *pBrushes,
 276                                  DWORD n)
 277 {
 278     DWORD i;
 279
 280     if (pPens && pBrushes) /* "set" call */
 281     {
 282         /* allocate our structure to remember old colors */
 283         LPVOID pOldCol = HeapAlloc(GetProcessHeap(), 0, sizeof(DWORD)+n*sizeof(HPEN)+n*sizeof(HBRUSH));
 284         LPVOID p = pOldCol;
 285         *(DWORD *)p = n; p = (char*)p + sizeof(DWORD);
 286         memcpy(p, SysColorPens, n*sizeof(HPEN)); p = (char*)p + n*sizeof(HPEN);
 287         memcpy(p, SysColorBrushes, n*sizeof(HBRUSH)); p = (char*)p + n*sizeof(HBRUSH);
 288
 289         for (i=0; i < n; i++)
 290         {
 291             SysColorPens[i] = CreatePen( PS_SOLID, 1, pPens[i] );
 292             SysColorBrushes[i] = pBrushes[i];
 293         }
 294
 295         return (DWORD) pOldCol; /* FIXME: pointer truncation */
 296     }
 297     if (!pPens && !pBrushes) /* "restore" call */
 298     {
 299         LPVOID pOldCol = (LPVOID)n; /* FIXME: not 64-bit safe */
 300         LPVOID p = pOldCol;
 301         DWORD nCount = *(DWORD *)p;
 302         p = (char*)p + sizeof(DWORD);
 303
 304         for (i=0; i < nCount; i++)
 305         {
 306             DeleteObject(SysColorPens[i]);
 307             SysColorPens[i] = *(HPEN *)p; p = (char*)p + sizeof(HPEN);
 308         }
 309         for (i=0; i < nCount; i++)
 310         {
 311             SysColorBrushes[i] = *(HBRUSH *)p; p = (char*)p + sizeof(HBRUSH);
 312         }
 313         /* get rid of storage structure */
 314         HeapFree(GetProcessHeap(), 0, pOldCol);
 315
 316         return TRUE;
 317     }
 318     return FALSE;
 319 }
 320
 321 /*
 322  * @unimplemented
 323  */
 324 HDESK
 325 WINAPI
 326 GetInputDesktop ( VOID )
 327 {
 328   UNIMPLEMENTED;
 329   return FALSE;
 330 }
 331
 332 /*
 333  * @unimplemented
 334  */
 335 BOOL
 336 WINAPI
 337 GetAccCursorInfo ( PCURSORINFO pci )
 338 {
 339   UNIMPLEMENTED;
 340   return FALSE;
 341 }
 342
 343 /*
 344  * @unimplemented
 345  */
 346 BOOL
 347 WINAPI
 348 ClientThreadSetup ( VOID )
 349 {
 350   UNIMPLEMENTED;
 351   return FALSE;
 352 }
 353
 354 /*
 355  * @unimplemented
 356  */
 357 UINT
 358 WINAPI
 359 GetRawInputDeviceInfoW(
 360     HANDLE hDevice,
 361     UINT uiCommand,
 362     LPVOID pData,
 363     PUINT pcbSize)
 364 {
 365   UNIMPLEMENTED;
 366   return 0;
 367 }
 368
 369 /*
 370  * @unimplemented
 371  */
 372 LONG
 373 WINAPI
 374 CsrBroadcastSystemMessageExW(
 375     DWORD dwflags,
 376     LPDWORD lpdwRecipients,
 377     UINT uiMessage,
 378     WPARAM wParam,
 379     LPARAM lParam,
 380     PBSMINFO pBSMInfo)
 381 {
 382   UNIMPLEMENTED;
 383   return FALSE;
 384 }
 385
 386 /*
 387  * @unimplemented
 388  */
 389 UINT
 390 WINAPI
 391 GetRawInputDeviceInfoA(
 392     HANDLE hDevice,
 393     UINT uiCommand,
 394     LPVOID pData,
 395     PUINT pcbSize)
 396 {
 397   UNIMPLEMENTED;
 398   return 0;
 399 }
 400
 401 /*
 402  * @unimplemented
 403  */
 404 BOOL
 405 WINAPI
 406 AlignRects(LPRECT rect, DWORD b, DWORD c, DWORD d)
 407 {
 408   UNIMPLEMENTED;
 409   return FALSE;
 410 }
 411
 412 /*
 413  * @unimplemented
 414  */
 415 LRESULT
 416 WINAPI
 417 DefRawInputProc(
 418     PRAWINPUT* paRawInput,
 419     INT nInput,
 420     UINT cbSizeHeader)
 421 {
 422   UNIMPLEMENTED;
 423   return 0;
 424 }
 425
 426 /*
 427  * @unimplemented
 428  */
 429 UINT
 430 WINAPI
 431 GetRawInputBuffer(
 432     PRAWINPUT pData,
 433     PUINT pcbSize,
 434     UINT cbSizeHeader)
 435 {
 436   UNIMPLEMENTED;
 437   return 0;
 438 }
 439
 440 /*
 441  * @unimplemented
 442  */
 443 UINT
 444 WINAPI
 445 GetRawInputData(
 446     HRAWINPUT hRawInput,
 447     UINT uiCommand,
 448     LPVOID pData,
 449     PUINT pcbSize,
 450     UINT cbSizeHeader)
 451 {
 452   UNIMPLEMENTED;
 453   return 0;
 454 }
 455
 456 /*
 457  * @unimplemented
 458  */
 459 UINT
 460 WINAPI
 461 GetRawInputDeviceList(
 462     PRAWINPUTDEVICELIST pRawInputDeviceList,
 463     PUINT puiNumDevices,
 464     UINT cbSize)
 465 {
 466     if(pRawInputDeviceList)
 467         memset(pRawInputDeviceList, 0, sizeof *pRawInputDeviceList);
 468     *puiNumDevices = 0;
 469
 470     UNIMPLEMENTED;
 471     return 0;
 472 }
 473
 474 /*
 475  * @unimplemented
 476  */
 477 UINT
 478 WINAPI
 479 GetRegisteredRawInputDevices(
 480     PRAWINPUTDEVICE pRawInputDevices,
 481     PUINT puiNumDevices,
 482     UINT cbSize)
 483 {
 484   UNIMPLEMENTED;
 485   return 0;
 486 }
 487
 488 /*
 489  * @unimplemented
 490  */
 491 BOOL
 492 WINAPI
 493 PrintWindow(
 494     HWND hwnd,
 495     HDC hdcBlt,
 496     UINT nFlags)
 497 {
 498   UNIMPLEMENTED;
 499   return FALSE;
 500 }
 501
 502 /*
 503  * @unimplemented
 504  */
 505 BOOL
 506 WINAPI
 507 RegisterRawInputDevices(
 508     PCRAWINPUTDEVICE pRawInputDevices,
 509     UINT uiNumDevices,
 510     UINT cbSize)
 511 {
 512   UNIMPLEMENTED;
 513   return FALSE;
 514 }
 515
 516 /*
 517  * @unimplemented
 518  */
 519 UINT
 520 WINAPI
 521 WINNLSGetIMEHotkey( HWND hwnd)
 522 {
 523   UNIMPLEMENTED;
 524   return FALSE;
 525 }
 526
 527 /*
 528  * @unimplemented
 529  */
 530 BOOL
 531 WINAPI
 532 WINNLSEnableIME( HWND hwnd, BOOL enable)
 533 {
 534   UNIMPLEMENTED;
 535   return FALSE;
 536 }
 537
 538 /*
 539  * @unimplemented
 540  */
 541 BOOL
 542 WINAPI
 543 WINNLSGetEnableStatus( HWND hwnd)
 544 {
 545   UNIMPLEMENTED;
 546   return FALSE;
 547 }
 548
 549 /*
 550  * @unimplemented
 551  */
 552 BOOL
 553 WINAPI
 554 IMPSetIMEW( HWND hwnd, LPIMEPROW ime)
 555 {
 556   UNIMPLEMENTED;
 557   return FALSE;
 558 }
 559
 560 /*
 561  * @unimplemented
 562  */
 563 BOOL
 564 WINAPI
 565 IMPQueryIMEW( LPIMEPROW ime)
 566 {
 567   UNIMPLEMENTED;
 568   return FALSE;
 569 }
 570
 571 /*
 572  * @unimplemented
 573  */
 574 BOOL
 575 WINAPI
 576 IMPGetIMEW( HWND hwnd, LPIMEPROW ime)
 577 {
 578   UNIMPLEMENTED;
 579   return FALSE;
 580 }
 581
 582 /*
 583  * @unimplemented
 584  */
 585 BOOL
 586 WINAPI
 587 IMPSetIMEA( HWND hwnd, LPIMEPROA ime)
 588 {
 589   UNIMPLEMENTED;
 590   return FALSE;
 591 }
 592
 593 /*
 594  * @unimplemented
 595  */
 596 BOOL
 597 WINAPI
 598 IMPQueryIMEA( LPIMEPROA ime)
 599 {
 600   UNIMPLEMENTED;
 601   return FALSE;
 602 }
 603
 604 /*
 605  * @unimplemented
 606  */
 607 BOOL
 608 WINAPI
 609 IMPGetIMEA( HWND hwnd, LPIMEPROA ime)
 610 {
 611   UNIMPLEMENTED;
 612   return FALSE;
 613 }
 614
 615 /*
 616  * @unimplemented
 617  */
 618 LRESULT
 619 WINAPI
 620 SendIMEMessageExW(HWND hwnd,LPARAM lparam)
 621 {
 622   UNIMPLEMENTED;
 623   return FALSE;
 624 }
 625
 626 /*
 627  * @unimplemented
 628  */
 629 LRESULT
 630 WINAPI
 631 SendIMEMessageExA(HWND hwnd, LPARAM lparam)
 632 {
 633   UNIMPLEMENTED;
 634   return FALSE;
 635 }
 636
 637 /*
 638  * @unimplemented
 639  */
 640 BOOL WINAPI DisplayExitWindowsWarnings(ULONG flags)
 641 {
 642   UNIMPLEMENTED;
 643   return FALSE;
 644 }
 645
 646 /*
 647  * @unimplemented
 648  */
 649 BOOL WINAPI ReasonCodeNeedsBugID(ULONG reasoncode)
 650 {
 651   UNIMPLEMENTED;
 652   return FALSE;
 653 }
 654
 655 /*
 656  * @unimplemented
 657  */
 658 BOOL WINAPI ReasonCodeNeedsComment(ULONG reasoncode)
 659 {
 660   UNIMPLEMENTED;
 661   return FALSE;
 662 }
 663
 664 /*
 665  * @unimplemented
 666  */
 667 BOOL WINAPI CtxInitUser32(VOID)
 668 {
 669   UNIMPLEMENTED;
 670   return FALSE;
 671 }
 672
 673 /*
 674  * @unimplemented
 675  */
 676 BOOL WINAPI EnterReaderModeHelper(HWND hwnd)
 677 {
 678   UNIMPLEMENTED;
 679   return FALSE;
 680 }
 681
 682 /*
 683  * @unimplemented
 684  */
 685 VOID WINAPI InitializeLpkHooks(FARPROC *hookfuncs)
 686 {
 687   UNIMPLEMENTED;
 688 }
 689
 690 /*
 691  * @unimplemented
 692  */
 693 WORD WINAPI InitializeWin32EntryTable(UCHAR* EntryTablePlus0x1000)
 694 {
 695   UNIMPLEMENTED;
 696   return FALSE;
 697 }
 698
 699 /*
 700  * @unimplemented
 701  */
 702 BOOL WINAPI IsServerSideWindow(HWND wnd)
 703 {
 704   UNIMPLEMENTED;
 705   return FALSE;
 706 }
 707
 708 typedef BOOL (CALLBACK *THEME_HOOK_FUNC) (DWORD state,PVOID arg2); //return type and 2nd parameter unknown
 709 /*
 710  * @unimplemented
 711  */
 712 BOOL WINAPI RegisterUserApiHook(HINSTANCE instance,THEME_HOOK_FUNC proc)
 713 {
 714   UNIMPLEMENTED;
 715   return FALSE;
 716 }
 717
 718 /*
 719  * @unimplemented
 720  */
 721 BOOL WINAPI UnregisterUserApiHook(VOID)
 722 {
 723   UNIMPLEMENTED;
 724   return FALSE;
 725 }
 726
 727 /*
 728  * @unimplemented
 729  */
 730 HKL WINAPI LoadKeyboardLayoutEx(DWORD unknown,LPCWSTR pwszKLID,UINT Flags) //1st parameter unknown
 731 {
 732   UNIMPLEMENTED;
 733   return FALSE;
 734 }
 735
 736 /*
 737  * @unimplemented
 738  */
 739 VOID WINAPI AllowForegroundActivation(VOID)
 740 {
 741   UNIMPLEMENTED;
 742 }
 743
 744 /*
 745  * @unimplemented
 746  */
 747 VOID WINAPI ShowStartGlass(DWORD unknown)
 748 {
 749   UNIMPLEMENTED;
 750 }
 751
 752 /*
 753  * @unimplemented
 754  */
 755 BOOL WINAPI DdeGetQualityOfService(HWND hWnd, DWORD Reserved, PSECURITY_QUALITY_OF_SERVICE pqosPrev)
 756 {
 757   UNIMPLEMENTED;
 758   return FALSE;
 759 }
 760
 761
 762 /*
 763  * @unimplemented
 764  */
 765 DWORD WINAPI User32InitializeImmEntryTable(PVOID p)
 766 {
 767   UNIMPLEMENTED;
 768   return 0;
 769 }
 770