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