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 "user_private.h"
  32
  33 #include "wine/debug.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(win);
  36
  37 #define IMM_INIT_MAGIC 0x19650412
  38 static HWND (WINAPI *imm_get_ui_window)(HKL);
  39 BOOL (WINAPI *imm_register_window)(HWND) = NULL;
  40 void (WINAPI *imm_unregister_window)(HWND) = NULL;
  41
  42 /* MSIME messages */
  43 static UINT WM_MSIME_SERVICE;
  44 static UINT WM_MSIME_RECONVERTOPTIONS;
  45 static UINT WM_MSIME_MOUSE;
  46 static UINT WM_MSIME_RECONVERTREQUEST;
  47 static UINT WM_MSIME_RECONVERT;
  48 static UINT WM_MSIME_QUERYPOSITION;
  49 static UINT WM_MSIME_DOCUMENTFEED;
  50
  51 /* USER signal proc flags and codes */
  52 /* See UserSignalProc for comments */
  53 #define USIG_FLAGS_WIN32          0x0001
  54 #define USIG_FLAGS_GUI            0x0002
  55 #define USIG_FLAGS_FEEDBACK       0x0004
  56 #define USIG_FLAGS_FAULT          0x0008
  57
  58 #define USIG_DLL_UNLOAD_WIN16     0x0001
  59 #define USIG_DLL_UNLOAD_WIN32     0x0002
  60 #define USIG_FAULT_DIALOG_PUSH    0x0003
  61 #define USIG_FAULT_DIALOG_POP     0x0004
  62 #define USIG_DLL_UNLOAD_ORPHANS   0x0005
  63 #define USIG_THREAD_INIT          0x0010
  64 #define USIG_THREAD_EXIT          0x0020
  65 #define USIG_PROCESS_CREATE       0x0100
  66 #define USIG_PROCESS_INIT         0x0200
  67 #define USIG_PROCESS_EXIT         0x0300
  68 #define USIG_PROCESS_DESTROY      0x0400
  69 #define USIG_PROCESS_RUNNING      0x0500
  70 #define USIG_PROCESS_LOADED       0x0600
  71
  72 /***********************************************************************
  73  *              SignalProc32 (USER.391)
  74  *              UserSignalProc (USER32.@)
  75  *
  76  * The exact meaning of the USER signals is undocumented, but this
  77  * should cover the basic idea:
  78  *
  79  * USIG_DLL_UNLOAD_WIN16
  80  *     This is sent when a 16-bit module is unloaded.
  81  *
  82  * USIG_DLL_UNLOAD_WIN32
  83  *     This is sent when a 32-bit module is unloaded.
  84  *
  85  * USIG_DLL_UNLOAD_ORPHANS
  86  *     This is sent after the last Win3.1 module is unloaded,
  87  *     to allow removal of orphaned menus.
  88  *
  89  * USIG_FAULT_DIALOG_PUSH
  90  * USIG_FAULT_DIALOG_POP
  91  *     These are called to allow USER to prepare for displaying a
  92  *     fault dialog, even though the fault might have happened while
  93  *     inside a USER critical section.
  94  *
  95  * USIG_THREAD_INIT
  96  *     This is called from the context of a new thread, as soon as it
  97  *     has started to run.
  98  *
  99  * USIG_THREAD_EXIT
 100  *     This is called, still in its context, just before a thread is
 101  *     about to terminate.
 102  *
 103  * USIG_PROCESS_CREATE
 104  *     This is called, in the parent process context, after a new process
 105  *     has been created.
 106  *
 107  * USIG_PROCESS_INIT
 108  *     This is called in the new process context, just after the main thread
 109  *     has started execution (after the main thread's USIG_THREAD_INIT has
 110  *     been sent).
 111  *
 112  * USIG_PROCESS_LOADED
 113  *     This is called after the executable file has been loaded into the
 114  *     new process context.
 115  *
 116  * USIG_PROCESS_RUNNING
 117  *     This is called immediately before the main entry point is called.
 118  *
 119  * USIG_PROCESS_EXIT
 120  *     This is called in the context of a process that is about to
 121  *     terminate (but before the last thread's USIG_THREAD_EXIT has
 122  *     been sent).
 123  *
 124  * USIG_PROCESS_DESTROY
 125  *     This is called after a process has terminated.
 126  *
 127  *
 128  * The meaning of the dwFlags bits is as follows:
 129  *
 130  * USIG_FLAGS_WIN32
 131  *     Current process is 32-bit.
 132  *
 133  * USIG_FLAGS_GUI
 134  *     Current process is a (Win32) GUI process.
 135  *
 136  * USIG_FLAGS_FEEDBACK
 137  *     Current process needs 'feedback' (determined from the STARTUPINFO
 138  *     flags STARTF_FORCEONFEEDBACK / STARTF_FORCEOFFFEEDBACK).
 139  *
 140  * USIG_FLAGS_FAULT
 141  *     The signal is being sent due to a fault.
 142  */
 143 WORD WINAPI UserSignalProc( UINT uCode, DWORD dwThreadOrProcessID,
 144                             DWORD dwFlags, HMODULE16 hModule )
 145 {
 146     FIXME("(%04x, %08x, %04x, %04x)\n",
 147           uCode, dwThreadOrProcessID, dwFlags, hModule );
 148     /* FIXME: Should chain to GdiSignalProc now. */
 149     return 0;
 150 }
 151
 152
 153 /**********************************************************************
 154  * SetLastErrorEx [USER32.@]
 155  *
 156  * Sets the last-error code.
 157  *
 158  * RETURNS
 159  *    None.
 160  */
 161 void WINAPI SetLastErrorEx(
 162     DWORD error, /* [in] Per-thread error code */
 163     DWORD type)  /* [in] Error type */
 164 {
 165     TRACE("(0x%08x, 0x%08x)\n", error,type);
 166     switch(type) {
 167         case 0:
 168             break;
 169         case SLE_ERROR:
 170         case SLE_MINORERROR:
 171         case SLE_WARNING:
 172             /* Fall through for now */
 173         default:
 174             FIXME("(error=%08x, type=%08x): Unhandled type\n", error,type);
 175             break;
 176     }
 177     SetLastError( error );
 178 }
 179
 180 /******************************************************************************
 181  * GetAltTabInfoA [USER32.@]
 182  */
 183 BOOL WINAPI GetAltTabInfoA(HWND hwnd, int iItem, PALTTABINFO pati, LPSTR pszItemText, UINT cchItemText)
 184 {
 185     FIXME("(%p, 0x%08x, %p, %p, 0x%08x)\n", hwnd, iItem, pati, pszItemText, cchItemText);
 186     return FALSE;
 187 }
 188
 189 /******************************************************************************
 190  * GetAltTabInfoW [USER32.@]
 191  */
 192 BOOL WINAPI GetAltTabInfoW(HWND hwnd, int iItem, PALTTABINFO pati, LPWSTR pszItemText, UINT cchItemText)
 193 {
 194     FIXME("(%p, 0x%08x, %p, %p, 0x%08x)\n", hwnd, iItem, pati, pszItemText, cchItemText);
 195     return FALSE;
 196 }
 197
 198 /******************************************************************************
 199  * SetDebugErrorLevel [USER32.@]
 200  * Sets the minimum error level for generating debugging events
 201  *
 202  * PARAMS
 203  *    dwLevel [I] Debugging error level
 204  *
 205  * RETURNS
 206  *    Nothing.
 207  */
 208 VOID WINAPI SetDebugErrorLevel( DWORD dwLevel )
 209 {
 210     FIXME("(%d): stub\n", dwLevel);
 211 }
 212
 213
 214 /***********************************************************************
 215  *              SetWindowStationUser (USER32.@)
 216  */
 217 DWORD WINAPI SetWindowStationUser(DWORD x1,DWORD x2)
 218 {
 219     FIXME("(0x%08x,0x%08x),stub!\n",x1,x2);
 220     return 1;
 221 }
 222
 223 /***********************************************************************
 224  *              RegisterLogonProcess (USER32.@)
 225  */
 226 DWORD WINAPI RegisterLogonProcess(HANDLE hprocess,BOOL x)
 227 {
 228     FIXME("(%p,%d),stub!\n",hprocess,x);
 229     return 1;
 230 }
 231
 232 /***********************************************************************
 233  *              SetLogonNotifyWindow (USER32.@)
 234  */
 235 DWORD WINAPI SetLogonNotifyWindow(HWINSTA hwinsta,HWND hwnd)
 236 {
 237     FIXME("(%p,%p),stub!\n",hwinsta,hwnd);
 238     return 1;
 239 }
 240
 241 /***********************************************************************
 242  *              RegisterSystemThread (USER32.@)
 243  */
 244 void WINAPI RegisterSystemThread(DWORD flags, DWORD reserved)
 245 {
 246     FIXME("(%08x, %08x)\n", flags, reserved);
 247 }
 248
 249 /***********************************************************************
 250  *           RegisterShellHookWindow                    [USER32.@]
 251  */
 252 BOOL WINAPI RegisterShellHookWindow(HWND hWnd)
 253 {
 254     FIXME("(%p): stub\n", hWnd);
 255     return FALSE;
 256 }
 257
 258
 259 /***********************************************************************
 260  *           DeregisterShellHookWindow                  [USER32.@]
 261  */
 262 BOOL WINAPI DeregisterShellHookWindow(HWND hWnd)
 263 {
 264     FIXME("(%p): stub\n", hWnd);
 265     return FALSE;
 266 }
 267
 268
 269 /***********************************************************************
 270  *           RegisterTasklist                           [USER32.@]
 271  */
 272 DWORD WINAPI RegisterTasklist (DWORD x)
 273 {
 274     FIXME("0x%08x\n",x);
 275     return TRUE;
 276 }
 277
 278 /***********************************************************************
 279  *           GetAppCompatFlags   (USER32.@)
 280  */
 281 DWORD WINAPI GetAppCompatFlags( HTASK hTask )
 282 {
 283     FIXME("(%p) stub\n", hTask);
 284     return 0;
 285 }
 286
 287 /***********************************************************************
 288  *           GetAppCompatFlags2   (USER32.@)
 289  */
 290 DWORD WINAPI GetAppCompatFlags2( HTASK hTask )
 291 {
 292     FIXME("(%p) stub\n", hTask);
 293     return 0;
 294 }
 295
 296
 297 /***********************************************************************
 298  *           AlignRects   (USER32.@)
 299  */
 300 BOOL WINAPI AlignRects(LPRECT rect, DWORD b, DWORD c, DWORD d)
 301 {
 302     FIXME("(%p, %d, %d, %d): stub\n", rect, b, c, d);
 303     if (rect)
 304         FIXME("rect: %s\n", wine_dbgstr_rect(rect));
 305     /* Calls OffsetRect */
 306     return FALSE;
 307 }
 308
 309
 310 /***********************************************************************
 311  *              LoadLocalFonts (USER32.@)
 312  */
 313 VOID WINAPI LoadLocalFonts(VOID)
 314 {
 315     /* are loaded. */
 316     return;
 317 }
 318
 319
 320 /***********************************************************************
 321  *              User32InitializeImmEntryTable
 322  */
 323 BOOL WINAPI User32InitializeImmEntryTable(DWORD magic)
 324 {
 325     HMODULE imm32 = GetModuleHandleW(L"imm32.dll");
 326
 327     TRACE("(%x)\n", magic);
 328
 329     if (!imm32 || magic != IMM_INIT_MAGIC)
 330         return FALSE;
 331
 332     if (imm_get_ui_window)
 333         return TRUE;
 334
 335     WM_MSIME_SERVICE = RegisterWindowMessageA("MSIMEService");
 336     WM_MSIME_RECONVERTOPTIONS = RegisterWindowMessageA("MSIMEReconvertOptions");
 337     WM_MSIME_MOUSE = RegisterWindowMessageA("MSIMEMouseOperation");
 338     WM_MSIME_RECONVERTREQUEST = RegisterWindowMessageA("MSIMEReconvertRequest");
 339     WM_MSIME_RECONVERT = RegisterWindowMessageA("MSIMEReconvert");
 340     WM_MSIME_QUERYPOSITION = RegisterWindowMessageA("MSIMEQueryPosition");
 341     WM_MSIME_DOCUMENTFEED = RegisterWindowMessageA("MSIMEDocumentFeed");
 342
 343     /* this part is not compatible with native imm32.dll */
 344     imm_get_ui_window = (void*)GetProcAddress(imm32, "__wine_get_ui_window");
 345     imm_register_window = (void*)GetProcAddress(imm32, "__wine_register_window");
 346     imm_unregister_window = (void*)GetProcAddress(imm32, "__wine_unregister_window");
 347     if (!imm_get_ui_window)
 348         FIXME("native imm32.dll not supported\n");
 349     return TRUE;
 350 }
 351
 352 /**********************************************************************
 353  * WINNLSGetIMEHotkey [USER32.@]
 354  *
 355  */
 356 UINT WINAPI WINNLSGetIMEHotkey(HWND hwnd)
 357 {
 358     FIXME("hwnd %p: stub!\n", hwnd);
 359     return 0; /* unknown */
 360 }
 361
 362 /**********************************************************************
 363  * WINNLSEnableIME [USER32.@]
 364  *
 365  */
 366 BOOL WINAPI WINNLSEnableIME(HWND hwnd, BOOL enable)
 367 {
 368     FIXME("hwnd %p enable %d: stub!\n", hwnd, enable);
 369     return TRUE; /* success (?) */
 370 }
 371
 372 /**********************************************************************
 373  * WINNLSGetEnableStatus [USER32.@]
 374  *
 375  */
 376 BOOL WINAPI WINNLSGetEnableStatus(HWND hwnd)
 377 {
 378     FIXME("hwnd %p: stub!\n", hwnd);
 379     return TRUE; /* success (?) */
 380 }
 381
 382 /**********************************************************************
 383  * SendIMEMessageExA [USER32.@]
 384  *
 385  */
 386 LRESULT WINAPI SendIMEMessageExA(HWND hwnd, LPARAM lparam)
 387 {
 388   FIXME("(%p,%lx): stub\n", hwnd, lparam);
 389   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 390   return 0;
 391 }
 392
 393 /**********************************************************************
 394  * SendIMEMessageExW [USER32.@]
 395  *
 396  */
 397 LRESULT WINAPI SendIMEMessageExW(HWND hwnd, LPARAM lparam)
 398 {
 399   FIXME("(%p,%lx): stub\n", hwnd, lparam);
 400   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 401   return 0;
 402 }
 403
 404 /**********************************************************************
 405  * DisableProcessWindowsGhosting [USER32.@]
 406  *
 407  */
 408 VOID WINAPI DisableProcessWindowsGhosting(VOID)
 409 {
 410   FIXME(": stub\n");
 411   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 412   return;
 413 }
 414
 415 /**********************************************************************
 416  * UserHandleGrantAccess [USER32.@]
 417  *
 418  */
 419 BOOL WINAPI UserHandleGrantAccess(HANDLE handle, HANDLE job, BOOL grant)
 420 {
 421     FIXME("(%p,%p,%d): stub\n", handle, job, grant);
 422     return TRUE;
 423 }
 424
 425 /**********************************************************************
 426  * RegisterPowerSettingNotification [USER32.@]
 427  */
 428 HPOWERNOTIFY WINAPI RegisterPowerSettingNotification(HANDLE recipient, const GUID *guid, DWORD flags)
 429 {
 430     FIXME("(%p,%s,%x): stub\n", recipient, debugstr_guid(guid), flags);
 431     return (HPOWERNOTIFY)0xdeadbeef;
 432 }
 433
 434 /**********************************************************************
 435  * UnregisterPowerSettingNotification [USER32.@]
 436  */
 437 BOOL WINAPI UnregisterPowerSettingNotification(HPOWERNOTIFY handle)
 438 {
 439     FIXME("(%p): stub\n", handle);
 440     return TRUE;
 441 }
 442
 443 /*****************************************************************************
 444  * GetGestureConfig (USER32.@)
 445  */
 446 BOOL WINAPI GetGestureConfig( HWND hwnd, DWORD reserved, DWORD flags, UINT *count, GESTURECONFIG *config, UINT size )
 447 {
 448     FIXME("(%p %08x %08x %p %p %u): stub\n", hwnd, reserved, flags, count, config, size);
 449     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 450     return FALSE;
 451 }
 452
 453 /**********************************************************************
 454  * SetGestureConfig [USER32.@]
 455  */
 456 BOOL WINAPI SetGestureConfig( HWND hwnd, DWORD reserved, UINT id, PGESTURECONFIG config, UINT size )
 457 {
 458     FIXME("(%p %08x %u %p %u): stub\n", hwnd, reserved, id, config, size);
 459     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 460     return FALSE;
 461 }
 462
 463 /**********************************************************************
 464  * IsTouchWindow [USER32.@]
 465  */
 466 BOOL WINAPI IsTouchWindow( HWND hwnd, PULONG flags )
 467 {
 468     FIXME("(%p %p): stub\n", hwnd, flags);
 469     return FALSE;
 470 }
 471
 472 /**********************************************************************
 473  * IsWindowRedirectedForPrint [USER32.@]
 474  */
 475 BOOL WINAPI IsWindowRedirectedForPrint( HWND hwnd )
 476 {
 477     FIXME("(%p): stub\n", hwnd);
 478     return FALSE;
 479 }
 480
 481 /**********************************************************************
 482  * RegisterPointerDeviceNotifications [USER32.@]
 483  */
 484 BOOL WINAPI RegisterPointerDeviceNotifications(HWND hwnd, BOOL notifyrange)
 485 {
 486     FIXME("(%p %d): stub\n", hwnd, notifyrange);
 487     return TRUE;
 488 }
 489
 490 /**********************************************************************
 491  * GetPointerDevices [USER32.@]
 492  */
 493 BOOL WINAPI GetPointerDevices(UINT32 *device_count, POINTER_DEVICE_INFO *devices)
 494 {
 495     FIXME("(%p %p): partial stub\n", device_count, devices);
 496
 497     if (!device_count)
 498         return FALSE;
 499
 500     if (devices)
 501         return FALSE;
 502
 503     *device_count = 0;
 504     return TRUE;
 505 }
 506
 507 /**********************************************************************
 508  * RegisterTouchHitTestingWindow [USER32.@]
 509  */
 510 BOOL WINAPI RegisterTouchHitTestingWindow(HWND hwnd, ULONG value)
 511 {
 512     FIXME("(%p %d): stub\n", hwnd, value);
 513     return TRUE;
 514 }
 515
 516 /**********************************************************************
 517  * GetPointerType [USER32.@]
 518  */
 519 BOOL WINAPI GetPointerType(UINT32 id, POINTER_INPUT_TYPE *type)
 520 {
 521     FIXME("(%d %p): stub\n", id, type);
 522
 523     if(!id || !type)
 524     {
 525         SetLastError(ERROR_INVALID_PARAMETER);
 526         return FALSE;
 527     }
 528
 529     *type = PT_MOUSE;
 530     return TRUE;
 531 }
 532
 533 const struct builtin_class_descr IME_builtin_class =
 534 {
 535     L"IME",             /* name */
 536     0,                  /* style  */
 537     WINPROC_IME,        /* proc */
 538     2*sizeof(LONG_PTR), /* extra */
 539     IDC_ARROW,          /* cursor */
 540     0                   /* brush */
 541 };
 542
 543 static BOOL is_ime_ui_msg( UINT msg )
 544 {
 545     switch(msg) {
 546     case WM_IME_STARTCOMPOSITION:
 547     case WM_IME_ENDCOMPOSITION:
 548     case WM_IME_COMPOSITION:
 549     case WM_IME_SETCONTEXT:
 550     case WM_IME_NOTIFY:
 551     case WM_IME_CONTROL:
 552     case WM_IME_COMPOSITIONFULL:
 553     case WM_IME_SELECT:
 554     case WM_IME_CHAR:
 555     case WM_IME_REQUEST:
 556     case WM_IME_KEYDOWN:
 557     case WM_IME_KEYUP:
 558         return TRUE;
 559     default:
 560         if ((msg == WM_MSIME_RECONVERTOPTIONS) ||
 561                 (msg == WM_MSIME_SERVICE) ||
 562                 (msg == WM_MSIME_MOUSE) ||
 563                 (msg == WM_MSIME_RECONVERTREQUEST) ||
 564                 (msg == WM_MSIME_RECONVERT) ||
 565                 (msg == WM_MSIME_QUERYPOSITION) ||
 566                 (msg == WM_MSIME_DOCUMENTFEED))
 567             return TRUE;
 568
 569         return FALSE;
 570     }
 571 }
 572
 573 LRESULT WINAPI ImeWndProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
 574 {
 575     HWND uiwnd;
 576
 577     if (msg==WM_CREATE)
 578         return TRUE;
 579
 580     if (imm_get_ui_window && is_ime_ui_msg(msg))
 581     {
 582         if ((uiwnd = imm_get_ui_window(GetKeyboardLayout(0))))
 583             return SendMessageA(uiwnd, msg, wParam, lParam);
 584         return FALSE;
 585     }
 586
 587     return DefWindowProcA(hwnd, msg, wParam, lParam);
 588 }
 589
 590 LRESULT WINAPI ImeWndProcW( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
 591 {
 592     HWND uiwnd;
 593
 594     if (msg==WM_CREATE)
 595         return TRUE;
 596
 597     if (imm_get_ui_window && is_ime_ui_msg(msg))
 598     {
 599         if ((uiwnd = imm_get_ui_window(GetKeyboardLayout(0))))
 600             return SendMessageW(uiwnd, msg, wParam, lParam);
 601         return FALSE;
 602     }
 603
 604     return DefWindowProcW(hwnd, msg, wParam, lParam);
 605 }