windows/user.c

   1 /*
   2  * Misc. USER functions
   3  *
   4  * Copyright 1993 Robert J. Amstadt
   5  *           1996 Alex Korobka
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 #include <stdarg.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include "wine/winbase16.h"
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "wingdi.h"
  29 #include "winuser.h"
  30 #include "wine/winuser16.h"
  31 #include "winreg.h"
  32 #include "winternl.h"
  33 #include "tlhelp32.h"
  34 #include "user_private.h"
  35 #include "win.h"
  36 #include "controls.h"
  37 #include "cursoricon.h"
  38 #include "message.h"
  39 #include "local.h"
  40 #include "wine/debug.h"
  41
  42 WINE_DEFAULT_DEBUG_CHANNEL(user);
  43
  44 static SYSLEVEL USER_SysLevel;
  45 static CRITICAL_SECTION_DEBUG critsect_debug =
  46 {
  47     0, 0, &USER_SysLevel.crst,
  48     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
  49       0, 0, { 0, (DWORD)(__FILE__ ": USER_SysLevel") }
  50 };
  51 static SYSLEVEL USER_SysLevel = { { &critsect_debug, -1, 0, 0, 0, 0 }, 2 };
  52
  53 /* USER signal proc flags and codes */
  54 /* See UserSignalProc for comments */
  55 #define USIG_FLAGS_WIN32          0x0001
  56 #define USIG_FLAGS_GUI            0x0002
  57 #define USIG_FLAGS_FEEDBACK       0x0004
  58 #define USIG_FLAGS_FAULT          0x0008
  59
  60 #define USIG_DLL_UNLOAD_WIN16     0x0001
  61 #define USIG_DLL_UNLOAD_WIN32     0x0002
  62 #define USIG_FAULT_DIALOG_PUSH    0x0003
  63 #define USIG_FAULT_DIALOG_POP     0x0004
  64 #define USIG_DLL_UNLOAD_ORPHANS   0x0005
  65 #define USIG_THREAD_INIT          0x0010
  66 #define USIG_THREAD_EXIT          0x0020
  67 #define USIG_PROCESS_CREATE       0x0100
  68 #define USIG_PROCESS_INIT         0x0200
  69 #define USIG_PROCESS_EXIT         0x0300
  70 #define USIG_PROCESS_DESTROY      0x0400
  71 #define USIG_PROCESS_RUNNING      0x0500
  72 #define USIG_PROCESS_LOADED       0x0600
  73
  74 /* UserSeeUserDo parameters */
  75 #define USUD_LOCALALLOC        0x0001
  76 #define USUD_LOCALFREE         0x0002
  77 #define USUD_LOCALCOMPACT      0x0003
  78 #define USUD_LOCALHEAP         0x0004
  79 #define USUD_FIRSTCLASS        0x0005
  80
  81 /***********************************************************************
  82  *              GetFreeSystemResources (USER.284)
  83  */
  84 WORD WINAPI GetFreeSystemResources16( WORD resType )
  85 {
  86     HINSTANCE16 gdi_inst;
  87     WORD gdi_heap;
  88     int userPercent, gdiPercent;
  89
  90     if ((gdi_inst = LoadLibrary16( "GDI" )) < 32) return 0;
  91     gdi_heap = gdi_inst | 7;
  92
  93     switch(resType)
  94     {
  95     case GFSR_USERRESOURCES:
  96         userPercent = (int)LOCAL_CountFree( USER_HeapSel ) * 100 /
  97                                LOCAL_HeapSize( USER_HeapSel );
  98         gdiPercent  = 100;
  99         break;
 100
 101     case GFSR_GDIRESOURCES:
 102         gdiPercent  = (int)LOCAL_CountFree( gdi_inst ) * 100 /
 103                                LOCAL_HeapSize( gdi_inst );
 104         userPercent = 100;
 105         break;
 106
 107     case GFSR_SYSTEMRESOURCES:
 108         userPercent = (int)LOCAL_CountFree( USER_HeapSel ) * 100 /
 109                                LOCAL_HeapSize( USER_HeapSel );
 110         gdiPercent  = (int)LOCAL_CountFree( gdi_inst ) * 100 /
 111                                LOCAL_HeapSize( gdi_inst );
 112         break;
 113
 114     default:
 115         userPercent = gdiPercent = 0;
 116         break;
 117     }
 118     FreeLibrary16( gdi_inst );
 119     TRACE("<- userPercent %d, gdiPercent %d\n", userPercent, gdiPercent);
 120     return (WORD)min( userPercent, gdiPercent );
 121 }
 122
 123
 124 /***********************************************************************
 125  *           USER_Lock
 126  */
 127 void USER_Lock(void)
 128 {
 129     _EnterSysLevel( &USER_SysLevel );
 130 }
 131
 132
 133 /***********************************************************************
 134  *           USER_Unlock
 135  */
 136 void USER_Unlock(void)
 137 {
 138     _LeaveSysLevel( &USER_SysLevel );
 139 }
 140
 141
 142 /***********************************************************************
 143  *           USER_CheckNotLock
 144  *
 145  * Make sure that we don't hold the user lock.
 146  */
 147 void USER_CheckNotLock(void)
 148 {
 149     _CheckNotSysLevel( &USER_SysLevel );
 150 }
 151
 152
 153 /***********************************************************************
 154  *           WIN_SuspendWndsLock
 155  *
 156  * Suspend the lock on WND structures.
 157  * Returns the number of locks suspended
 158  * FIXME: should be removed
 159  */
 160 int WIN_SuspendWndsLock( void )
 161 {
 162     int isuspendedLocks = _ConfirmSysLevel( &USER_SysLevel );
 163     int count = isuspendedLocks;
 164
 165     while ( count-- > 0 )
 166         _LeaveSysLevel( &USER_SysLevel );
 167
 168     return isuspendedLocks;
 169 }
 170
 171 /***********************************************************************
 172  *           WIN_RestoreWndsLock
 173  *
 174  * Restore the suspended locks on WND structures
 175  * FIXME: should be removed
 176  */
 177 void WIN_RestoreWndsLock( int ipreviousLocks )
 178 {
 179     while ( ipreviousLocks-- > 0 )
 180         _EnterSysLevel( &USER_SysLevel );
 181 }
 182
 183 /***********************************************************************
 184  *              SignalProc32 (USER.391)
 185  *              UserSignalProc (USER32.@)
 186  *
 187  * The exact meaning of the USER signals is undocumented, but this
 188  * should cover the basic idea:
 189  *
 190  * USIG_DLL_UNLOAD_WIN16
 191  *     This is sent when a 16-bit module is unloaded.
 192  *
 193  * USIG_DLL_UNLOAD_WIN32
 194  *     This is sent when a 32-bit module is unloaded.
 195  *
 196  * USIG_DLL_UNLOAD_ORPHANS
 197  *     This is sent after the last Win3.1 module is unloaded,
 198  *     to allow removal of orphaned menus.
 199  *
 200  * USIG_FAULT_DIALOG_PUSH
 201  * USIG_FAULT_DIALOG_POP
 202  *     These are called to allow USER to prepare for displaying a
 203  *     fault dialog, even though the fault might have happened while
 204  *     inside a USER critical section.
 205  *
 206  * USIG_THREAD_INIT
 207  *     This is called from the context of a new thread, as soon as it
 208  *     has started to run.
 209  *
 210  * USIG_THREAD_EXIT
 211  *     This is called, still in its context, just before a thread is
 212  *     about to terminate.
 213  *
 214  * USIG_PROCESS_CREATE
 215  *     This is called, in the parent process context, after a new process
 216  *     has been created.
 217  *
 218  * USIG_PROCESS_INIT
 219  *     This is called in the new process context, just after the main thread
 220  *     has started execution (after the main thread's USIG_THREAD_INIT has
 221  *     been sent).
 222  *
 223  * USIG_PROCESS_LOADED
 224  *     This is called after the executable file has been loaded into the
 225  *     new process context.
 226  *
 227  * USIG_PROCESS_RUNNING
 228  *     This is called immediately before the main entry point is called.
 229  *
 230  * USIG_PROCESS_EXIT
 231  *     This is called in the context of a process that is about to
 232  *     terminate (but before the last thread's USIG_THREAD_EXIT has
 233  *     been sent).
 234  *
 235  * USIG_PROCESS_DESTROY
 236  *     This is called after a process has terminated.
 237  *
 238  *
 239  * The meaning of the dwFlags bits is as follows:
 240  *
 241  * USIG_FLAGS_WIN32
 242  *     Current process is 32-bit.
 243  *
 244  * USIG_FLAGS_GUI
 245  *     Current process is a (Win32) GUI process.
 246  *
 247  * USIG_FLAGS_FEEDBACK
 248  *     Current process needs 'feedback' (determined from the STARTUPINFO
 249  *     flags STARTF_FORCEONFEEDBACK / STARTF_FORCEOFFFEEDBACK).
 250  *
 251  * USIG_FLAGS_FAULT
 252  *     The signal is being sent due to a fault.
 253  */
 254 WORD WINAPI UserSignalProc( UINT uCode, DWORD dwThreadOrProcessID,
 255                             DWORD dwFlags, HMODULE16 hModule )
 256 {
 257     FIXME("(%04x, %08lx, %04lx, %04x)\n",
 258           uCode, dwThreadOrProcessID, dwFlags, hModule );
 259     /* FIXME: Should chain to GdiSignalProc now. */
 260     return 0;
 261 }
 262
 263 /***********************************************************************
 264  *           USER_GetProcessHandleList(Internal)
 265  */
 266 static HANDLE *USER_GetProcessHandleList(void)
 267 {
 268     DWORD count, i, n;
 269     HANDLE *list;
 270     PROCESSENTRY32 pe;
 271     HANDLE hSnapshot;
 272     BOOL r;
 273
 274     hSnapshot = CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS, 0 );
 275     if (!hSnapshot)
 276     {
 277         ERR("cannot create snapshot\n");
 278         return FALSE;
 279     }
 280
 281     /* count the number of processes plus one */
 282     for (count=0; ;count++)
 283     {
 284         pe.dwSize = sizeof pe;
 285         if (count)
 286             r = Process32Next( hSnapshot, &pe );
 287         else
 288             r = Process32First( hSnapshot, &pe );
 289         if (!r)
 290             break;
 291     }
 292
 293     /* allocate memory make a list of the process handles */
 294     list = HeapAlloc( GetProcessHeap(), 0, (count+1)*sizeof(HANDLE) );
 295     n=0;
 296     for (i=0; i<count; i++)
 297     {
 298         pe.dwSize = sizeof pe;
 299         if (i)
 300             r = Process32Next( hSnapshot, &pe );
 301         else
 302             r = Process32First( hSnapshot, &pe );
 303         if (!r)
 304             break;
 305
 306         /* don't kill outselves */
 307         if (GetCurrentProcessId() == pe.th32ProcessID )
 308             continue;
 309
 310         /* open the process so we don't can track it */
 311         list[n] = OpenProcess( PROCESS_QUERY_INFORMATION|
 312                                   PROCESS_TERMINATE,
 313                                   FALSE, pe.th32ProcessID );
 314
 315         /* check it didn't terminate already */
 316         if( list[n] )
 317             n++;
 318     }
 319     list[n]=0;
 320     CloseHandle( hSnapshot );
 321
 322     if (!r)
 323         ERR("Error enumerating processes\n");
 324
 325     TRACE("return %lu processes\n", n);
 326
 327     return list;
 328 }
 329
 330 /***********************************************************************
 331  *              USER_KillProcesses (Internal)
 332  */
 333 static DWORD USER_KillProcesses(void)
 334 {
 335     DWORD n, r, i;
 336     HANDLE *handles;
 337     const DWORD dwShutdownTimeout = 10000;
 338
 339     TRACE("terminating other processes\n");
 340
 341     /* kill it and add it to our list of object to wait on */
 342     handles = USER_GetProcessHandleList();
 343     for (n=0; handles && handles[n]; n++)
 344         TerminateProcess( handles[n], 0 );
 345
 346     /* wait for processes to exit */
 347     for (i=0; i<n; i+=MAXIMUM_WAIT_OBJECTS)
 348     {
 349         int n_objs = ((n-i)>MAXIMUM_WAIT_OBJECTS) ? MAXIMUM_WAIT_OBJECTS : (n-i);
 350         r = WaitForMultipleObjects( n_objs, &handles[i], TRUE, dwShutdownTimeout );
 351         if (r==WAIT_TIMEOUT)
 352             ERR("wait failed!\n");
 353     }
 354
 355     /* close the handles */
 356     for (i=0; i<n; i++)
 357         CloseHandle( handles[i] );
 358
 359     HeapFree( GetProcessHeap(), 0, handles );
 360
 361     return n;
 362 }
 363
 364 /***********************************************************************
 365  *              USER_DoShutdown (Internal)
 366  */
 367 static void USER_DoShutdown(void)
 368 {
 369     DWORD i, n;
 370     const DWORD nRetries = 10;
 371
 372     for (i=0; i<nRetries; i++)
 373     {
 374         n = USER_KillProcesses();
 375         TRACE("Killed %ld processes, attempt %ld\n", n, i);
 376         if(!n)
 377             break;
 378     }
 379 }
 380
 381 /***********************************************************************
 382  *              USER_StartRebootProcess (Internal)
 383  */
 384 static BOOL USER_StartRebootProcess(void)
 385 {
 386     WCHAR winebootW[] = { 'w','i','n','e','b','o','o','t',0 };
 387     PROCESS_INFORMATION pi;
 388     STARTUPINFOW si;
 389     BOOL r;
 390
 391     memset( &si, 0, sizeof si );
 392     si.cb = sizeof si;
 393
 394     r = CreateProcessW( NULL, winebootW, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi );
 395     if (r)
 396     {
 397         CloseHandle( pi.hProcess );
 398         CloseHandle( pi.hThread );
 399     }
 400     else
 401         MESSAGE("wine: Failed to start wineboot\n");
 402
 403     return r;
 404 }
 405
 406 /***********************************************************************
 407  *              ExitWindowsEx (USER32.@)
 408  */
 409 BOOL WINAPI ExitWindowsEx( UINT flags, DWORD reserved )
 410 {
 411     int i;
 412     BOOL result;
 413     HWND *list, *phwnd;
 414
 415     /* We have to build a list of all windows first, as in EnumWindows */
 416
 417     if (!(list = WIN_ListChildren( GetDesktopWindow() ))) return FALSE;
 418
 419     /* Send a WM_QUERYENDSESSION message to every window */
 420
 421     for (i = 0; list[i]; i++)
 422     {
 423         /* Make sure that the window still exists */
 424         if (!IsWindow( list[i] )) continue;
 425         if (!SendMessageW( list[i], WM_QUERYENDSESSION, 0, 0 )) break;
 426     }
 427     result = !list[i];
 428
 429     /* Now notify all windows that got a WM_QUERYENDSESSION of the result */
 430
 431     for (phwnd = list; i > 0; i--, phwnd++)
 432     {
 433         if (!IsWindow( *phwnd )) continue;
 434         SendMessageW( *phwnd, WM_ENDSESSION, result, 0 );
 435     }
 436     HeapFree( GetProcessHeap(), 0, list );
 437
 438     /* USER_DoShutdown will kill all processes except the current process */
 439     USER_DoShutdown();
 440
 441     if (flags & EWX_REBOOT)
 442         USER_StartRebootProcess();
 443
 444     if (result) ExitKernel16();
 445     return TRUE;
 446 }
 447
 448 /***********************************************************************
 449  *              ChangeDisplaySettingsA (USER32.@)
 450  */
 451 LONG WINAPI ChangeDisplaySettingsA( LPDEVMODEA devmode, DWORD flags )
 452 {
 453   return ChangeDisplaySettingsExA(NULL,devmode,NULL,flags,NULL);
 454 }
 455
 456 /***********************************************************************
 457  *              ChangeDisplaySettingsW (USER32.@)
 458  */
 459 LONG WINAPI ChangeDisplaySettingsW( LPDEVMODEW devmode, DWORD flags )
 460 {
 461   return ChangeDisplaySettingsExW(NULL,devmode,NULL,flags,NULL);
 462 }
 463
 464 /***********************************************************************
 465  *              ChangeDisplaySettingsExA (USER32.@)
 466  */
 467 LONG WINAPI ChangeDisplaySettingsExA(
 468         LPCSTR devname, LPDEVMODEA devmode, HWND hwnd, DWORD flags,
 469         LPVOID lparam
 470 ) {
 471     DEVMODEW devmodeW;
 472     LONG ret;
 473     UNICODE_STRING nameW;
 474
 475     if (devname) RtlCreateUnicodeStringFromAsciiz(&nameW, devname);
 476     else nameW.Buffer = NULL;
 477
 478     if (devmode)
 479     {
 480         devmodeW.dmBitsPerPel       = devmode->dmBitsPerPel;
 481         devmodeW.dmPelsHeight       = devmode->dmPelsHeight;
 482         devmodeW.dmPelsWidth        = devmode->dmPelsWidth;
 483         devmodeW.dmDisplayFlags     = devmode->dmDisplayFlags;
 484         devmodeW.dmDisplayFrequency = devmode->dmDisplayFrequency;
 485         devmodeW.dmFields           = devmode->dmFields;
 486         ret = ChangeDisplaySettingsExW(nameW.Buffer, &devmodeW, hwnd, flags, lparam);
 487     }
 488     else
 489     {
 490         ret = ChangeDisplaySettingsExW(nameW.Buffer, NULL, hwnd, flags, lparam);
 491     }
 492
 493     if (devname) RtlFreeUnicodeString(&nameW);
 494     return ret;
 495 }
 496
 497 /***********************************************************************
 498  *              ChangeDisplaySettingsExW (USER32.@)
 499  */
 500 LONG WINAPI ChangeDisplaySettingsExW( LPCWSTR devname, LPDEVMODEW devmode, HWND hwnd,
 501                                       DWORD flags, LPVOID lparam )
 502 {
 503     /* Pass the request on to the driver */
 504     if (!USER_Driver.pChangeDisplaySettingsExW) return DISP_CHANGE_FAILED;
 505     return USER_Driver.pChangeDisplaySettingsExW( devname, devmode, hwnd, flags, lparam );
 506 }
 507
 508 /***********************************************************************
 509  *              EnumDisplaySettingsW (USER32.@)
 510  *
 511  * RETURNS
 512  *      TRUE if nth setting exists found (described in the LPDEVMODEW struct)
 513  *      FALSE if we do not have the nth setting
 514  */
 515 BOOL WINAPI EnumDisplaySettingsW(
 516         LPCWSTR name,           /* [in] huh? */
 517         DWORD n,                /* [in] nth entry in display settings list*/
 518         LPDEVMODEW devmode      /* [out] devmode for that setting */
 519 ) {
 520     return EnumDisplaySettingsExW(name, n, devmode, 0);
 521 }
 522
 523 /***********************************************************************
 524  *              EnumDisplaySettingsA (USER32.@)
 525  */
 526 BOOL WINAPI EnumDisplaySettingsA(LPCSTR name,DWORD n,LPDEVMODEA devmode)
 527 {
 528     return EnumDisplaySettingsExA(name, n, devmode, 0);
 529 }
 530
 531 /***********************************************************************
 532  *              EnumDisplaySettingsExA (USER32.@)
 533  */
 534 BOOL WINAPI EnumDisplaySettingsExA(LPCSTR lpszDeviceName, DWORD iModeNum,
 535                                    LPDEVMODEA lpDevMode, DWORD dwFlags)
 536 {
 537     DEVMODEW devmodeW;
 538     BOOL ret;
 539     UNICODE_STRING nameW;
 540
 541     if (lpszDeviceName) RtlCreateUnicodeStringFromAsciiz(&nameW, lpszDeviceName);
 542     else nameW.Buffer = NULL;
 543
 544     ret = EnumDisplaySettingsExW(nameW.Buffer,iModeNum,&devmodeW,dwFlags);
 545     if (ret)
 546     {
 547         lpDevMode->dmBitsPerPel       = devmodeW.dmBitsPerPel;
 548         lpDevMode->dmPelsHeight       = devmodeW.dmPelsHeight;
 549         lpDevMode->dmPelsWidth        = devmodeW.dmPelsWidth;
 550         lpDevMode->dmDisplayFlags     = devmodeW.dmDisplayFlags;
 551         lpDevMode->dmDisplayFrequency = devmodeW.dmDisplayFrequency;
 552         lpDevMode->dmFields           = devmodeW.dmFields;
 553     }
 554     if (lpszDeviceName) RtlFreeUnicodeString(&nameW);
 555     return ret;
 556 }
 557
 558 /***********************************************************************
 559  *              EnumDisplaySettingsExW (USER32.@)
 560  */
 561 BOOL WINAPI EnumDisplaySettingsExW(LPCWSTR lpszDeviceName, DWORD iModeNum,
 562                                    LPDEVMODEW lpDevMode, DWORD dwFlags)
 563 {
 564     /* Pass the request on to the driver */
 565     if (!USER_Driver.pEnumDisplaySettingsExW) return FALSE;
 566     return USER_Driver.pEnumDisplaySettingsExW(lpszDeviceName, iModeNum, lpDevMode, dwFlags);
 567 }
 568
 569 /***********************************************************************
 570  *              EnumDisplayDevicesA (USER32.@)
 571  */
 572 BOOL WINAPI EnumDisplayDevicesA(
 573         LPVOID unused,DWORD i,LPDISPLAY_DEVICEA lpDisplayDevice,DWORD dwFlags
 574 ) {
 575         if (i)
 576                 return FALSE;
 577         FIXME("(%p,%ld,%p,0x%08lx), stub!\n",unused,i,lpDisplayDevice,dwFlags);
 578         strcpy(lpDisplayDevice->DeviceName,"X11");
 579         strcpy(lpDisplayDevice->DeviceString,"X 11 Windowing System");
 580         lpDisplayDevice->StateFlags =
 581                         DISPLAY_DEVICE_ATTACHED_TO_DESKTOP      |
 582                         DISPLAY_DEVICE_PRIMARY_DEVICE           |
 583                         DISPLAY_DEVICE_VGA_COMPATIBLE;
 584         return TRUE;
 585 }
 586
 587 /***********************************************************************
 588  *              EnumDisplayDevicesW (USER32.@)
 589  */
 590 BOOL WINAPI EnumDisplayDevicesW(
 591         LPVOID unused,DWORD i,LPDISPLAY_DEVICEW lpDisplayDevice,DWORD dwFlags
 592 ) {
 593         if (i)
 594                 return FALSE;
 595         FIXME("(%p,%ld,%p,0x%08lx), stub!\n",unused,i,lpDisplayDevice,dwFlags);
 596         MultiByteToWideChar( CP_ACP, 0, "X11", -1, lpDisplayDevice->DeviceName,
 597                              sizeof(lpDisplayDevice->DeviceName)/sizeof(WCHAR) );
 598         MultiByteToWideChar( CP_ACP, 0, "X11 Windowing System", -1, lpDisplayDevice->DeviceString,
 599                              sizeof(lpDisplayDevice->DeviceString)/sizeof(WCHAR) );
 600         lpDisplayDevice->StateFlags =
 601                         DISPLAY_DEVICE_ATTACHED_TO_DESKTOP      |
 602                         DISPLAY_DEVICE_PRIMARY_DEVICE           |
 603                         DISPLAY_DEVICE_VGA_COMPATIBLE;
 604         return TRUE;
 605 }
 606
 607 /***********************************************************************
 608  *              UserSeeUserDo (USER.216)
 609  */
 610 DWORD WINAPI UserSeeUserDo16(WORD wReqType, WORD wParam1, WORD wParam2, WORD wParam3)
 611 {
 612     switch (wReqType)
 613     {
 614     case USUD_LOCALALLOC:
 615         return LOCAL_Alloc(USER_HeapSel, wParam1, wParam3);
 616     case USUD_LOCALFREE:
 617         return LOCAL_Free(USER_HeapSel, wParam1);
 618     case USUD_LOCALCOMPACT:
 619         return LOCAL_Compact(USER_HeapSel, wParam3, 0);
 620     case USUD_LOCALHEAP:
 621         return USER_HeapSel;
 622     case USUD_FIRSTCLASS:
 623         FIXME("return a pointer to the first window class.\n");
 624         return (DWORD)-1;
 625     default:
 626         WARN("wReqType %04x (unknown)\n", wReqType);
 627         return (DWORD)-1;
 628     }
 629 }
 630
 631 /***********************************************************************
 632  *              RegisterLogonProcess (USER32.@)
 633  */
 634 DWORD WINAPI RegisterLogonProcess(HANDLE hprocess,BOOL x) {
 635         FIXME("(%p,%d),stub!\n",hprocess,x);
 636         return 1;
 637 }
 638
 639 /***********************************************************************
 640  *              CreateWindowStationW (USER32.@)
 641  */
 642 HWINSTA WINAPI CreateWindowStationW(
 643         LPWSTR winstation,DWORD res1,DWORD desiredaccess,
 644         LPSECURITY_ATTRIBUTES lpsa
 645 ) {
 646         FIXME("(%s,0x%08lx,0x%08lx,%p),stub!\n",debugstr_w(winstation),
 647                 res1,desiredaccess,lpsa
 648         );
 649         return (HWINSTA)0xdeadcafe;
 650 }
 651
 652 /***********************************************************************
 653  *              SetProcessWindowStation (USER32.@)
 654  */
 655 BOOL WINAPI SetProcessWindowStation(HWINSTA hWinSta) {
 656         FIXME("(%p),stub!\n",hWinSta);
 657         return TRUE;
 658 }
 659
 660 /***********************************************************************
 661  *              SetUserObjectSecurity (USER32.@)
 662  */
 663 BOOL WINAPI SetUserObjectSecurity(
 664         HANDLE hObj,
 665         PSECURITY_INFORMATION pSIRequested,
 666         PSECURITY_DESCRIPTOR pSID
 667 ) {
 668         FIXME("(%p,%p,%p),stub!\n",hObj,pSIRequested,pSID);
 669         return TRUE;
 670 }
 671
 672 /***********************************************************************
 673  *              CreateDesktopA (USER32.@)
 674  */
 675 HDESK WINAPI CreateDesktopA(
 676         LPSTR lpszDesktop,LPSTR lpszDevice,LPDEVMODEA pDevmode,
 677         DWORD dwFlags,DWORD dwDesiredAccess,LPSECURITY_ATTRIBUTES lpsa
 678 ) {
 679         FIXME("(%s,%s,%p,0x%08lx,0x%08lx,%p),stub!\n",
 680                 lpszDesktop,lpszDevice,pDevmode,
 681                 dwFlags,dwDesiredAccess,lpsa
 682         );
 683         return (HDESK)0xcafedead;
 684 }
 685
 686 /***********************************************************************
 687  *              CreateDesktopW (USER32.@)
 688  */
 689 HDESK WINAPI CreateDesktopW(
 690         LPWSTR lpszDesktop,LPWSTR lpszDevice,LPDEVMODEW pDevmode,
 691         DWORD dwFlags,DWORD dwDesiredAccess,LPSECURITY_ATTRIBUTES lpsa
 692 ) {
 693         FIXME("(%s,%s,%p,0x%08lx,0x%08lx,%p),stub!\n",
 694                 debugstr_w(lpszDesktop),debugstr_w(lpszDevice),pDevmode,
 695                 dwFlags,dwDesiredAccess,lpsa
 696         );
 697         return (HDESK)0xcafedead;
 698 }
 699
 700 /***********************************************************************
 701  *              EnumDesktopWindows (USER32.@)
 702  */
 703 BOOL WINAPI EnumDesktopWindows( HDESK hDesktop, WNDENUMPROC lpfn, LPARAM lParam ) {
 704   FIXME("(%p, %p, 0x%08lx), stub!\n", hDesktop, lpfn, lParam );
 705   return TRUE;
 706 }
 707
 708
 709 /***********************************************************************
 710  *              CloseWindowStation (USER32.@)
 711  */
 712 BOOL WINAPI CloseWindowStation(HWINSTA hWinSta)
 713 {
 714     FIXME("(%p)\n", hWinSta);
 715     return TRUE;
 716 }
 717
 718 /***********************************************************************
 719  *              CloseDesktop (USER32.@)
 720  */
 721 BOOL WINAPI CloseDesktop(HDESK hDesk)
 722 {
 723     FIXME("(%p)\n", hDesk);
 724     return TRUE;
 725 }
 726
 727 /***********************************************************************
 728  *              SetWindowStationUser (USER32.@)
 729  */
 730 DWORD WINAPI SetWindowStationUser(DWORD x1,DWORD x2) {
 731         FIXME("(0x%08lx,0x%08lx),stub!\n",x1,x2);
 732         return 1;
 733 }
 734
 735 /***********************************************************************
 736  *              SetLogonNotifyWindow (USER32.@)
 737  */
 738 DWORD WINAPI SetLogonNotifyWindow(HWINSTA hwinsta,HWND hwnd) {
 739         FIXME("(%p,%p),stub!\n",hwinsta,hwnd);
 740         return 1;
 741 }
 742
 743 /***********************************************************************
 744  *              LoadLocalFonts (USER32.@)
 745  */
 746 VOID WINAPI LoadLocalFonts(VOID) {
 747         /* are loaded. */
 748         return;
 749 }
 750 /***********************************************************************
 751  *              GetUserObjectInformationA (USER32.@)
 752  */
 753 BOOL WINAPI GetUserObjectInformationA( HANDLE hObj, INT nIndex, LPVOID pvInfo, DWORD nLength, LPDWORD lpnLen )
 754 {       FIXME("(%p %i %p %ld %p),stub!\n", hObj, nIndex, pvInfo, nLength, lpnLen );
 755         return TRUE;
 756 }
 757 /***********************************************************************
 758  *              GetUserObjectInformationW (USER32.@)
 759  */
 760 BOOL WINAPI GetUserObjectInformationW( HANDLE hObj, INT nIndex, LPVOID pvInfo, DWORD nLength, LPDWORD lpnLen )
 761 {       FIXME("(%p %i %p %ld %p),stub!\n", hObj, nIndex, pvInfo, nLength, lpnLen );
 762         return TRUE;
 763 }
 764 /***********************************************************************
 765  *              GetUserObjectSecurity (USER32.@)
 766  */
 767 BOOL WINAPI GetUserObjectSecurity(HANDLE hObj, PSECURITY_INFORMATION pSIRequested,
 768         PSECURITY_DESCRIPTOR pSID, DWORD nLength, LPDWORD lpnLengthNeeded)
 769 {       FIXME("(%p %p %p len=%ld %p),stub!\n",  hObj, pSIRequested, pSID, nLength, lpnLengthNeeded);
 770         return TRUE;
 771 }
 772
 773 /***********************************************************************
 774  *              SetSystemCursor (USER32.@)
 775  */
 776 BOOL WINAPI SetSystemCursor(HCURSOR hcur, DWORD id)
 777 {       FIXME("(%p,%08lx),stub!\n",  hcur, id);
 778         return TRUE;
 779 }
 780
 781 /***********************************************************************
 782  *              RegisterSystemThread (USER32.@)
 783  */
 784 void WINAPI RegisterSystemThread(DWORD flags, DWORD reserved)
 785 {
 786         FIXME("(%08lx, %08lx)\n", flags, reserved);
 787 }
 788
 789 /***********************************************************************
 790  *              RegisterDeviceNotificationA (USER32.@)
 791  *
 792  * See RegisterDeviceNotificationW.
 793  */
 794 HDEVNOTIFY WINAPI RegisterDeviceNotificationA(HANDLE hnd, LPVOID notifyfilter, DWORD flags)
 795 {
 796     FIXME("(hwnd=%p, filter=%p,flags=0x%08lx), STUB!\n", hnd,notifyfilter,flags );
 797     return 0;
 798 }
 799
 800 /***********************************************************************
 801  *              RegisterDeviceNotificationW (USER32.@)
 802  *
 803  * Registers a window with the system so that it will receive
 804  * notifications about a device.
 805  *
 806  * PARAMS
 807  *     hRecepient           [I] Window or service status handle that
 808  *                              will receive notifications.
 809  *     pNotificationFilter  [I] DEV_BROADCAST_HDR followed by some
 810  *                              type-specific data.
 811  *     dwFlags              [I] See notes
 812  *
 813  * RETURNS
 814  *
 815  * A handle to the device notification.
 816  *
 817  * NOTES
 818  *
 819  * The dwFlags parameter can be one of two values:
 820  *| DEVICE_NOTIFY_WINDOW_HANDLE  - hRecepient is a window handle
 821  *| DEVICE_NOTIFY_SERVICE_HANDLE - hRecepient is a service status handle
 822  */
 823 HDEVNOTIFY WINAPI RegisterDeviceNotificationW(HANDLE hRecepient, LPVOID pNotificationFilter, DWORD dwFlags)
 824 {
 825     FIXME("(hwnd=%p, filter=%p,flags=0x%08lx), STUB!\n", hRecepient,pNotificationFilter,dwFlags );
 826     return 0;
 827 }