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