dlls/user32/misc.c

   1 /*
   2  * Misc USER functions
   3  *
   4  * Copyright 1995 Thomas Sandford
   5  * Copyright 1997 Marcus Meissner
   6  * Copyright 1998 Turchanov Sergey
   7  * Copyright 2019 Micah N Gorrell for CodeWeavers
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  */
  23
  24 #include <stdarg.h>
  25
  26 #include "windef.h"
  27 #include "wine/windef16.h"
  28 #include "winbase.h"
  29 #include "wingdi.h"
  30 #include "controls.h"
  31 #include "imm.h"
  32 #include "user_private.h"
  33
  34 #include "wine/debug.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(win);
  37
  38 BOOL WINAPI ImmSetActiveContext(HWND, HIMC, BOOL);
  39
  40 #define IMM_INIT_MAGIC 0x19650412
  41 static LRESULT (WINAPI *imm_ime_wnd_proc)( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam, BOOL ansi);
  42
  43 /* USER signal proc flags and codes */
  44 /* See UserSignalProc for comments */
  45 #define USIG_FLAGS_WIN32          0x0001
  46 #define USIG_FLAGS_GUI            0x0002
  47 #define USIG_FLAGS_FEEDBACK       0x0004
  48 #define USIG_FLAGS_FAULT          0x0008
  49
  50 #define USIG_DLL_UNLOAD_WIN16     0x0001
  51 #define USIG_DLL_UNLOAD_WIN32     0x0002
  52 #define USIG_FAULT_DIALOG_PUSH    0x0003
  53 #define USIG_FAULT_DIALOG_POP     0x0004
  54 #define USIG_DLL_UNLOAD_ORPHANS   0x0005
  55 #define USIG_THREAD_INIT          0x0010
  56 #define USIG_THREAD_EXIT          0x0020
  57 #define USIG_PROCESS_CREATE       0x0100
  58 #define USIG_PROCESS_INIT         0x0200
  59 #define USIG_PROCESS_EXIT         0x0300
  60 #define USIG_PROCESS_DESTROY      0x0400
  61 #define USIG_PROCESS_RUNNING      0x0500
  62 #define USIG_PROCESS_LOADED       0x0600
  63
  64 /***********************************************************************
  65  *              SignalProc32 (USER.391)
  66  *              UserSignalProc (USER32.@)
  67  *
  68  * The exact meaning of the USER signals is undocumented, but this
  69  * should cover the basic idea:
  70  *
  71  * USIG_DLL_UNLOAD_WIN16
  72  *     This is sent when a 16-bit module is unloaded.
  73  *
  74  * USIG_DLL_UNLOAD_WIN32
  75  *     This is sent when a 32-bit module is unloaded.
  76  *
  77  * USIG_DLL_UNLOAD_ORPHANS
  78  *     This is sent after the last Win3.1 module is unloaded,
  79  *     to allow removal of orphaned menus.
  80  *
  81  * USIG_FAULT_DIALOG_PUSH
  82  * USIG_FAULT_DIALOG_POP
  83  *     These are called to allow USER to prepare for displaying a
  84  *     fault dialog, even though the fault might have happened while
  85  *     inside a USER critical section.
  86  *
  87  * USIG_THREAD_INIT
  88  *     This is called from the context of a new thread, as soon as it
  89  *     has started to run.
  90  *
  91  * USIG_THREAD_EXIT
  92  *     This is called, still in its context, just before a thread is
  93  *     about to terminate.
  94  *
  95  * USIG_PROCESS_CREATE
  96  *     This is called, in the parent process context, after a new process
  97  *     has been created.
  98  *
  99  * USIG_PROCESS_INIT
 100  *     This is called in the new process context, just after the main thread
 101  *     has started execution (after the main thread's USIG_THREAD_INIT has
 102  *     been sent).
 103  *
 104  * USIG_PROCESS_LOADED
 105  *     This is called after the executable file has been loaded into the
 106  *     new process context.
 107  *
 108  * USIG_PROCESS_RUNNING
 109  *     This is called immediately before the main entry point is called.
 110  *
 111  * USIG_PROCESS_EXIT
 112  *     This is called in the context of a process that is about to
 113  *     terminate (but before the last thread's USIG_THREAD_EXIT has
 114  *     been sent).
 115  *
 116  * USIG_PROCESS_DESTROY
 117  *     This is called after a process has terminated.
 118  *
 119  *
 120  * The meaning of the dwFlags bits is as follows:
 121  *
 122  * USIG_FLAGS_WIN32
 123  *     Current process is 32-bit.
 124  *
 125  * USIG_FLAGS_GUI
 126  *     Current process is a (Win32) GUI process.
 127  *
 128  * USIG_FLAGS_FEEDBACK
 129  *     Current process needs 'feedback' (determined from the STARTUPINFO
 130  *     flags STARTF_FORCEONFEEDBACK / STARTF_FORCEOFFFEEDBACK).
 131  *
 132  * USIG_FLAGS_FAULT
 133  *     The signal is being sent due to a fault.
 134  */
 135 WORD WINAPI UserSignalProc( UINT uCode, DWORD dwThreadOrProcessID,
 136                             DWORD dwFlags, HMODULE16 hModule )
 137 {
 138     FIXME("(%04x, %08lx, %04lx, %04x)\n",
 139           uCode, dwThreadOrProcessID, dwFlags, hModule );
 140     /* FIXME: Should chain to GdiSignalProc now. */
 141     return 0;
 142 }
 143
 144
 145 /**********************************************************************
 146  * SetLastErrorEx [USER32.@]
 147  *
 148  * Sets the last-error code.
 149  *
 150  * RETURNS
 151  *    None.
 152  */
 153 void WINAPI SetLastErrorEx(
 154     DWORD error, /* [in] Per-thread error code */
 155     DWORD type)  /* [in] Error type */
 156 {
 157     TRACE("(0x%08lx, 0x%08lx)\n", error,type);
 158     switch(type) {
 159         case 0:
 160             break;
 161         case SLE_ERROR:
 162         case SLE_MINORERROR:
 163         case SLE_WARNING:
 164             /* Fall through for now */
 165         default:
 166             FIXME("(error=%08lx, type=%08lx): Unhandled type\n", error,type);
 167             break;
 168     }
 169     SetLastError( error );
 170 }
 171
 172 /******************************************************************************
 173  * GetAltTabInfoA [USER32.@]
 174  */
 175 BOOL WINAPI GetAltTabInfoA(HWND hwnd, int iItem, PALTTABINFO pati, LPSTR pszItemText, UINT cchItemText)
 176 {
 177     FIXME("(%p, 0x%08x, %p, %p, 0x%08x)\n", hwnd, iItem, pati, pszItemText, cchItemText);
 178     return FALSE;
 179 }
 180
 181 /******************************************************************************
 182  * GetAltTabInfoW [USER32.@]
 183  */
 184 BOOL WINAPI GetAltTabInfoW(HWND hwnd, int iItem, PALTTABINFO pati, LPWSTR pszItemText, UINT cchItemText)
 185 {
 186     FIXME("(%p, 0x%08x, %p, %p, 0x%08x)\n", hwnd, iItem, pati, pszItemText, cchItemText);
 187     return FALSE;
 188 }
 189
 190 /******************************************************************************
 191  * SetDebugErrorLevel [USER32.@]
 192  * Sets the minimum error level for generating debugging events
 193  *
 194  * PARAMS
 195  *    dwLevel [I] Debugging error level
 196  *
 197  * RETURNS
 198  *    Nothing.
 199  */
 200 VOID WINAPI SetDebugErrorLevel( DWORD dwLevel )
 201 {
 202     FIXME("(%ld): stub\n", dwLevel);
 203 }
 204
 205
 206 /***********************************************************************
 207  *              SetWindowStationUser (USER32.@)
 208  */
 209 DWORD WINAPI SetWindowStationUser(DWORD x1,DWORD x2)
 210 {
 211     FIXME("(0x%08lx,0x%08lx),stub!\n",x1,x2);
 212     return 1;
 213 }
 214
 215 /***********************************************************************
 216  *              RegisterLogonProcess (USER32.@)
 217  */
 218 DWORD WINAPI RegisterLogonProcess(HANDLE hprocess,BOOL x)
 219 {
 220     FIXME("(%p,%d),stub!\n",hprocess,x);
 221     return 1;
 222 }
 223
 224 /***********************************************************************
 225  *              SetLogonNotifyWindow (USER32.@)
 226  */
 227 DWORD WINAPI SetLogonNotifyWindow(HWINSTA hwinsta,HWND hwnd)
 228 {
 229     FIXME("(%p,%p),stub!\n",hwinsta,hwnd);
 230     return 1;
 231 }
 232
 233 /***********************************************************************
 234  *              RegisterSystemThread (USER32.@)
 235  */
 236 void WINAPI RegisterSystemThread(DWORD flags, DWORD reserved)
 237 {
 238     FIXME("(%08lx, %08lx)\n", flags, reserved);
 239 }
 240
 241 /***********************************************************************
 242  *           RegisterShellHookWindow                    [USER32.@]
 243  */
 244 BOOL WINAPI RegisterShellHookWindow(HWND hWnd)
 245 {
 246     FIXME("(%p): stub\n", hWnd);
 247     return FALSE;
 248 }
 249
 250
 251 /***********************************************************************
 252  *           DeregisterShellHookWindow                  [USER32.@]
 253  */
 254 BOOL WINAPI DeregisterShellHookWindow(HWND hWnd)
 255 {
 256     FIXME("(%p): stub\n", hWnd);
 257     return FALSE;
 258 }
 259
 260
 261 /***********************************************************************
 262  *           RegisterTasklist                           [USER32.@]
 263  */
 264 DWORD WINAPI RegisterTasklist (DWORD x)
 265 {
 266     FIXME("0x%08lx\n",x);
 267     return TRUE;
 268 }
 269
 270 /***********************************************************************
 271  *           GetAppCompatFlags   (USER32.@)
 272  */
 273 DWORD WINAPI GetAppCompatFlags( HTASK hTask )
 274 {
 275     FIXME("(%p) stub\n", hTask);
 276     return 0;
 277 }
 278
 279 /***********************************************************************
 280  *           GetAppCompatFlags2   (USER32.@)
 281  */
 282 DWORD WINAPI GetAppCompatFlags2( HTASK hTask )
 283 {
 284     FIXME("(%p) stub\n", hTask);
 285     return 0;
 286 }
 287
 288
 289 /***********************************************************************
 290  *           AlignRects   (USER32.@)
 291  */
 292 BOOL WINAPI AlignRects(LPRECT rect, DWORD b, DWORD c, DWORD d)
 293 {
 294     FIXME("(%p, %ld, %ld, %ld): stub\n", rect, b, c, d);
 295     if (rect)
 296         FIXME("rect: %s\n", wine_dbgstr_rect(rect));
 297     /* Calls OffsetRect */
 298     return FALSE;
 299 }
 300
 301
 302 /***********************************************************************
 303  *              LoadLocalFonts (USER32.@)
 304  */
 305 VOID WINAPI LoadLocalFonts(VOID)
 306 {
 307     /* are loaded. */
 308     return;
 309 }
 310
 311
 312 /***********************************************************************
 313  *              User32InitializeImmEntryTable
 314  */
 315 BOOL WINAPI User32InitializeImmEntryTable(DWORD magic)
 316 {
 317     HMODULE imm32 = GetModuleHandleW(L"imm32.dll");
 318
 319     TRACE("(%lx)\n", magic);
 320
 321     if (!imm32 || magic != IMM_INIT_MAGIC)
 322         return FALSE;
 323
 324     if (imm_ime_wnd_proc)
 325         return TRUE;
 326
 327     /* this part is not compatible with native imm32.dll */
 328     imm_ime_wnd_proc = (void*)GetProcAddress(imm32, "__wine_ime_wnd_proc");
 329     if (!imm_ime_wnd_proc)
 330         FIXME("native imm32.dll not supported\n");
 331     return TRUE;
 332 }
 333
 334 /**********************************************************************
 335  * WINNLSGetIMEHotkey [USER32.@]
 336  *
 337  */
 338 UINT WINAPI WINNLSGetIMEHotkey(HWND hwnd)
 339 {
 340     FIXME("hwnd %p: stub!\n", hwnd);
 341     return 0; /* unknown */
 342 }
 343
 344 /**********************************************************************
 345  * WINNLSEnableIME [USER32.@]
 346  *
 347  */
 348 BOOL WINAPI WINNLSEnableIME(HWND hwnd, BOOL enable)
 349 {
 350     FIXME("hwnd %p enable %d: stub!\n", hwnd, enable);
 351     return TRUE; /* success (?) */
 352 }
 353
 354 /**********************************************************************
 355  * WINNLSGetEnableStatus [USER32.@]
 356  *
 357  */
 358 BOOL WINAPI WINNLSGetEnableStatus(HWND hwnd)
 359 {
 360     FIXME("hwnd %p: stub!\n", hwnd);
 361     return TRUE; /* success (?) */
 362 }
 363
 364 /**********************************************************************
 365  * SendIMEMessageExA [USER32.@]
 366  *
 367  */
 368 LRESULT WINAPI SendIMEMessageExA(HWND hwnd, LPARAM lparam)
 369 {
 370   FIXME("(%p,%Ix): stub\n", hwnd, lparam);
 371   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 372   return 0;
 373 }
 374
 375 /**********************************************************************
 376  * SendIMEMessageExW [USER32.@]
 377  *
 378  */
 379 LRESULT WINAPI SendIMEMessageExW(HWND hwnd, LPARAM lparam)
 380 {
 381   FIXME("(%p,%Ix): stub\n", hwnd, lparam);
 382   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 383   return 0;
 384 }
 385
 386 /**********************************************************************
 387  * DisableProcessWindowsGhosting [USER32.@]
 388  *
 389  */
 390 VOID WINAPI DisableProcessWindowsGhosting(VOID)
 391 {
 392   FIXME(": stub\n");
 393   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 394   return;
 395 }
 396
 397 /**********************************************************************
 398  * UserHandleGrantAccess [USER32.@]
 399  *
 400  */
 401 BOOL WINAPI UserHandleGrantAccess(HANDLE handle, HANDLE job, BOOL grant)
 402 {
 403     FIXME("(%p,%p,%d): stub\n", handle, job, grant);
 404     return TRUE;
 405 }
 406
 407 /**********************************************************************
 408  * RegisterPowerSettingNotification [USER32.@]
 409  */
 410 HPOWERNOTIFY WINAPI RegisterPowerSettingNotification(HANDLE recipient, const GUID *guid, DWORD flags)
 411 {
 412     FIXME("(%p,%s,%lx): stub\n", recipient, debugstr_guid(guid), flags);
 413     return (HPOWERNOTIFY)0xdeadbeef;
 414 }
 415
 416 /**********************************************************************
 417  * UnregisterPowerSettingNotification [USER32.@]
 418  */
 419 BOOL WINAPI UnregisterPowerSettingNotification(HPOWERNOTIFY handle)
 420 {
 421     FIXME("(%p): stub\n", handle);
 422     return TRUE;
 423 }
 424
 425 /**********************************************************************
 426  * RegisterSuspendResumeNotification (USER32.@)
 427  */
 428 HPOWERNOTIFY WINAPI RegisterSuspendResumeNotification(HANDLE recipient, DWORD flags)
 429 {
 430     FIXME("%p, %#lx: stub.\n", recipient, flags);
 431     return (HPOWERNOTIFY)0xdeadbeef;
 432 }
 433
 434 /**********************************************************************
 435  * UnregisterSuspendResumeNotification (USER32.@)
 436  */
 437 BOOL WINAPI UnregisterSuspendResumeNotification(HPOWERNOTIFY handle)
 438 {
 439     FIXME("%p: stub.\n", handle);
 440     return TRUE;
 441 }
 442
 443 /**********************************************************************
 444  * IsWindowRedirectedForPrint [USER32.@]
 445  */
 446 BOOL WINAPI IsWindowRedirectedForPrint( HWND hwnd )
 447 {
 448     FIXME("(%p): stub\n", hwnd);
 449     return FALSE;
 450 }
 451
 452 /**********************************************************************
 453  * RegisterPointerDeviceNotifications [USER32.@]
 454  */
 455 BOOL WINAPI RegisterPointerDeviceNotifications(HWND hwnd, BOOL notifyrange)
 456 {
 457     FIXME("(%p %d): stub\n", hwnd, notifyrange);
 458     return TRUE;
 459 }
 460
 461 /**********************************************************************
 462  * GetPointerDevices [USER32.@]
 463  */
 464 BOOL WINAPI GetPointerDevices(UINT32 *device_count, POINTER_DEVICE_INFO *devices)
 465 {
 466     FIXME("(%p %p): partial stub\n", device_count, devices);
 467
 468     if (!device_count)
 469         return FALSE;
 470
 471     if (devices)
 472         return FALSE;
 473
 474     *device_count = 0;
 475     return TRUE;
 476 }
 477
 478 /**********************************************************************
 479  * RegisterTouchHitTestingWindow [USER32.@]
 480  */
 481 BOOL WINAPI RegisterTouchHitTestingWindow(HWND hwnd, ULONG value)
 482 {
 483     FIXME("(%p %ld): stub\n", hwnd, value);
 484     return TRUE;
 485 }
 486
 487 /**********************************************************************
 488  * GetPointerType [USER32.@]
 489  */
 490 BOOL WINAPI GetPointerType(UINT32 id, POINTER_INPUT_TYPE *type)
 491 {
 492     FIXME("(%d %p): stub\n", id, type);
 493
 494     if(!id || !type)
 495     {
 496         SetLastError(ERROR_INVALID_PARAMETER);
 497         return FALSE;
 498     }
 499
 500     *type = PT_MOUSE;
 501     return TRUE;
 502 }
 503
 504 BOOL WINAPI GetPointerInfo(UINT32 id, POINTER_INFO *info)
 505 {
 506     FIXME("(%d %p): stub\n", id, info);
 507
 508     SetLastError(ERROR_INVALID_PARAMETER);
 509     return FALSE;
 510 }
 511
 512 LRESULT WINAPI ImeWndProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
 513 {
 514     if (!imm_ime_wnd_proc) return DefWindowProcA(hwnd, msg, wParam, lParam);
 515     return imm_ime_wnd_proc( hwnd, msg, wParam, lParam, TRUE );
 516 }
 517
 518 LRESULT WINAPI ImeWndProcW( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
 519 {
 520     if (!imm_ime_wnd_proc) return DefWindowProcW(hwnd, msg, wParam, lParam);
 521     return imm_ime_wnd_proc( hwnd, msg, wParam, lParam, FALSE );
 522 }