dlls/user32/focus.c

   1 /*
   2  * Focus and activation functions
   3  *
   4  * Copyright 1993 David Metcalfe
   5  * Copyright 1995 Alex Korobka
   6  * Copyright 1994, 2002 Alexandre Julliard
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include <stdarg.h>
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "wingdi.h"
  28 #include "winuser.h"
  29 #include "win.h"
  30 #include "user_private.h"
  31 #include "wine/server.h"
  32 #include "wine/debug.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(win);
  35
  36
  37 /*****************************************************************
  38  *              set_focus_window
  39  *
  40  * Change the focus window, sending the WM_SETFOCUS and WM_KILLFOCUS messages
  41  */
  42 static HWND set_focus_window( HWND hwnd )
  43 {
  44     HWND previous = 0;
  45     BOOL ret;
  46
  47     SERVER_START_REQ( set_focus_window )
  48     {
  49         req->handle = wine_server_user_handle( hwnd );
  50         if ((ret = !wine_server_call_err( req )))
  51             previous = wine_server_ptr_handle( reply->previous );
  52     }
  53     SERVER_END_REQ;
  54     if (!ret) return 0;
  55     if (previous == hwnd) return previous;
  56
  57     if (previous)
  58     {
  59         SendMessageW( previous, WM_KILLFOCUS, (WPARAM)hwnd, 0 );
  60         if (hwnd != GetFocus()) return previous;  /* changed by the message */
  61     }
  62     if (IsWindow(hwnd))
  63     {
  64         USER_Driver->pSetFocus(hwnd);
  65         SendMessageW( hwnd, WM_SETFOCUS, (WPARAM)previous, 0 );
  66     }
  67     return previous;
  68 }
  69
  70
  71 /*******************************************************************
  72  *              set_active_window
  73  */
  74 static BOOL set_active_window( HWND hwnd, HWND *prev, BOOL mouse, BOOL focus )
  75 {
  76     HWND previous = GetActiveWindow();
  77     BOOL ret;
  78     DWORD old_thread, new_thread;
  79     CBTACTIVATESTRUCT cbt;
  80
  81     if (previous == hwnd)
  82     {
  83         if (prev) *prev = hwnd;
  84         return TRUE;
  85     }
  86
  87     /* call CBT hook chain */
  88     cbt.fMouse     = mouse;
  89     cbt.hWndActive = previous;
  90     if (HOOK_CallHooks( WH_CBT, HCBT_ACTIVATE, (WPARAM)hwnd, (LPARAM)&cbt, TRUE )) return FALSE;
  91
  92     if (IsWindow(previous))
  93     {
  94         SendMessageW( previous, WM_NCACTIVATE, FALSE, (LPARAM)hwnd );
  95         SendMessageW( previous, WM_ACTIVATE,
  96                       MAKEWPARAM( WA_INACTIVE, IsIconic(previous) ), (LPARAM)hwnd );
  97     }
  98
  99     SERVER_START_REQ( set_active_window )
 100     {
 101         req->handle = wine_server_user_handle( hwnd );
 102         if ((ret = !wine_server_call_err( req )))
 103             previous = wine_server_ptr_handle( reply->previous );
 104     }
 105     SERVER_END_REQ;
 106     if (!ret) return FALSE;
 107     if (prev) *prev = previous;
 108     if (previous == hwnd) return TRUE;
 109
 110     if (hwnd)
 111     {
 112         /* send palette messages */
 113         if (SendMessageW( hwnd, WM_QUERYNEWPALETTE, 0, 0 ))
 114             SendMessageTimeoutW( HWND_BROADCAST, WM_PALETTEISCHANGING, (WPARAM)hwnd, 0,
 115                                  SMTO_ABORTIFHUNG, 2000, NULL );
 116         if (!IsWindow(hwnd)) return FALSE;
 117     }
 118
 119     old_thread = previous ? GetWindowThreadProcessId( previous, NULL ) : 0;
 120     new_thread = hwnd ? GetWindowThreadProcessId( hwnd, NULL ) : 0;
 121
 122     if (old_thread != new_thread)
 123     {
 124         HWND *list, *phwnd;
 125
 126         if ((list = WIN_ListChildren( GetDesktopWindow() )))
 127         {
 128             if (old_thread)
 129             {
 130                 for (phwnd = list; *phwnd; phwnd++)
 131                 {
 132                     if (GetWindowThreadProcessId( *phwnd, NULL ) == old_thread)
 133                         SendMessageW( *phwnd, WM_ACTIVATEAPP, 0, new_thread );
 134                 }
 135             }
 136             if (new_thread)
 137             {
 138                 for (phwnd = list; *phwnd; phwnd++)
 139                 {
 140                     if (GetWindowThreadProcessId( *phwnd, NULL ) == new_thread)
 141                         SendMessageW( *phwnd, WM_ACTIVATEAPP, 1, old_thread );
 142                 }
 143             }
 144             HeapFree( GetProcessHeap(), 0, list );
 145         }
 146     }
 147
 148     if (IsWindow(hwnd))
 149     {
 150         SendMessageW( hwnd, WM_NCACTIVATE, (hwnd == GetForegroundWindow()), (LPARAM)previous );
 151         SendMessageW( hwnd, WM_ACTIVATE,
 152                       MAKEWPARAM( mouse ? WA_CLICKACTIVE : WA_ACTIVE, IsIconic(hwnd) ),
 153                       (LPARAM)previous );
 154         if (GetAncestor( hwnd, GA_PARENT ) == GetDesktopWindow())
 155             PostMessageW( GetDesktopWindow(), WM_PARENTNOTIFY, WM_NCACTIVATE, (LPARAM)hwnd );
 156     }
 157
 158     /* now change focus if necessary */
 159     if (focus)
 160     {
 161         GUITHREADINFO info;
 162
 163         info.cbSize = sizeof(info);
 164         GetGUIThreadInfo( GetCurrentThreadId(), &info );
 165         /* Do not change focus if the window is no more active */
 166         if (hwnd == info.hwndActive)
 167         {
 168             if (!info.hwndFocus || !hwnd || GetAncestor( info.hwndFocus, GA_ROOT ) != hwnd)
 169                 set_focus_window( hwnd );
 170         }
 171     }
 172
 173     return TRUE;
 174 }
 175
 176
 177 /*******************************************************************
 178  *              set_foreground_window
 179  */
 180 static BOOL set_foreground_window( HWND hwnd, BOOL mouse )
 181 {
 182     BOOL ret, send_msg_old = FALSE, send_msg_new = FALSE;
 183     HWND previous = 0;
 184
 185     SERVER_START_REQ( set_foreground_window )
 186     {
 187         req->handle = wine_server_user_handle( hwnd );
 188         if ((ret = !wine_server_call_err( req )))
 189         {
 190             previous = wine_server_ptr_handle( reply->previous );
 191             send_msg_old = reply->send_msg_old;
 192             send_msg_new = reply->send_msg_new;
 193         }
 194     }
 195     SERVER_END_REQ;
 196
 197     if (ret && previous != hwnd)
 198     {
 199         if (send_msg_old)  /* old window belongs to other thread */
 200             SendNotifyMessageW( previous, WM_WINE_SETACTIVEWINDOW, 0, 0 );
 201         else if (send_msg_new)  /* old window belongs to us but new one to other thread */
 202             ret = set_active_window( 0, NULL, mouse, TRUE );
 203
 204         if (send_msg_new)  /* new window belongs to other thread */
 205             SendNotifyMessageW( hwnd, WM_WINE_SETACTIVEWINDOW, (WPARAM)hwnd, 0 );
 206         else  /* new window belongs to us */
 207             ret = set_active_window( hwnd, NULL, mouse, TRUE );
 208     }
 209     return ret;
 210 }
 211
 212
 213 /*******************************************************************
 214  *              FOCUS_MouseActivate
 215  *
 216  * Activate a window as a result of a mouse click
 217  */
 218 BOOL FOCUS_MouseActivate( HWND hwnd )
 219 {
 220     return set_foreground_window( hwnd, TRUE );
 221 }
 222
 223
 224 /*******************************************************************
 225  *              SetActiveWindow (USER32.@)
 226  */
 227 HWND WINAPI SetActiveWindow( HWND hwnd )
 228 {
 229     HWND prev;
 230
 231     TRACE( "%p\n", hwnd );
 232
 233     if (hwnd)
 234     {
 235         LONG style;
 236
 237         hwnd = WIN_GetFullHandle( hwnd );
 238         if (!IsWindow( hwnd ))
 239         {
 240             SetLastError( ERROR_INVALID_WINDOW_HANDLE );
 241             return 0;
 242         }
 243
 244         style = GetWindowLongW( hwnd, GWL_STYLE );
 245         if ((style & (WS_POPUP|WS_CHILD)) == WS_CHILD)
 246             return GetActiveWindow();  /* Windows doesn't seem to return an error here */
 247     }
 248
 249     if (!set_active_window( hwnd, &prev, FALSE, TRUE )) return 0;
 250     return prev;
 251 }
 252
 253
 254 /*****************************************************************
 255  *              SetFocus  (USER32.@)
 256  */
 257 HWND WINAPI SetFocus( HWND hwnd )
 258 {
 259     HWND hwndTop = hwnd;
 260     HWND previous = GetFocus();
 261
 262     TRACE( "%p prev %p\n", hwnd, previous );
 263
 264     if (hwnd)
 265     {
 266         /* Check if we can set the focus to this window */
 267         hwnd = WIN_GetFullHandle( hwnd );
 268         if (!IsWindow( hwnd ))
 269         {
 270             SetLastError( ERROR_INVALID_WINDOW_HANDLE );
 271             return 0;
 272         }
 273         if (hwnd == previous) return previous;  /* nothing to do */
 274         for (;;)
 275         {
 276             HWND parent;
 277             LONG style = GetWindowLongW( hwndTop, GWL_STYLE );
 278             if (style & (WS_MINIMIZE | WS_DISABLED)) return 0;
 279             if (!(style & WS_CHILD)) break;
 280             parent = GetAncestor( hwndTop, GA_PARENT );
 281             if (!parent || parent == GetDesktopWindow())
 282             {
 283                 if ((style & (WS_POPUP|WS_CHILD)) == WS_CHILD) return 0;
 284                 break;
 285             }
 286             if (parent == get_hwnd_message_parent()) return 0;
 287             hwndTop = parent;
 288         }
 289
 290         /* call hooks */
 291         if (HOOK_CallHooks( WH_CBT, HCBT_SETFOCUS, (WPARAM)hwnd, (LPARAM)previous, TRUE )) return 0;
 292
 293         /* activate hwndTop if needed. */
 294         if (hwndTop != GetActiveWindow())
 295         {
 296             if (!set_active_window( hwndTop, NULL, FALSE, FALSE )) return 0;
 297             if (!IsWindow( hwnd )) return 0;  /* Abort if window destroyed */
 298
 299             /* Do not change focus if the window is no longer active */
 300             if (hwndTop != GetActiveWindow()) return 0;
 301         }
 302     }
 303     else /* NULL hwnd passed in */
 304     {
 305         if (!previous) return 0;  /* nothing to do */
 306         if (HOOK_CallHooks( WH_CBT, HCBT_SETFOCUS, 0, (LPARAM)previous, TRUE )) return 0;
 307     }
 308
 309     /* change focus and send messages */
 310     return set_focus_window( hwnd );
 311 }
 312
 313
 314 /*******************************************************************
 315  *              SetForegroundWindow  (USER32.@)
 316  */
 317 BOOL WINAPI SetForegroundWindow( HWND hwnd )
 318 {
 319     TRACE( "%p\n", hwnd );
 320
 321     hwnd = WIN_GetFullHandle( hwnd );
 322     return set_foreground_window( hwnd, FALSE );
 323 }
 324
 325
 326 /*******************************************************************
 327  *              GetActiveWindow  (USER32.@)
 328  */
 329 HWND WINAPI GetActiveWindow(void)
 330 {
 331     HWND ret = 0;
 332
 333     SERVER_START_REQ( get_thread_input )
 334     {
 335         req->tid = GetCurrentThreadId();
 336         if (!wine_server_call_err( req )) ret = wine_server_ptr_handle( reply->active );
 337     }
 338     SERVER_END_REQ;
 339     return ret;
 340 }
 341
 342
 343 /*****************************************************************
 344  *              GetFocus  (USER32.@)
 345  */
 346 HWND WINAPI GetFocus(void)
 347 {
 348     HWND ret = 0;
 349
 350     SERVER_START_REQ( get_thread_input )
 351     {
 352         req->tid = GetCurrentThreadId();
 353         if (!wine_server_call_err( req )) ret = wine_server_ptr_handle( reply->focus );
 354     }
 355     SERVER_END_REQ;
 356     return ret;
 357 }
 358
 359
 360 /*******************************************************************
 361  *              GetForegroundWindow  (USER32.@)
 362  */
 363 HWND WINAPI GetForegroundWindow(void)
 364 {
 365     HWND ret = 0;
 366
 367     SERVER_START_REQ( get_thread_input )
 368     {
 369         req->tid = 0;
 370         if (!wine_server_call_err( req )) ret = wine_server_ptr_handle( reply->foreground );
 371     }
 372     SERVER_END_REQ;
 373     return ret;
 374 }
 375
 376
 377 /***********************************************************************
 378 *               SetShellWindowEx (USER32.@)
 379 * hwndShell =    Progman[Program Manager]
 380 *                |-> SHELLDLL_DefView
 381 * hwndListView = |   |-> SysListView32
 382 *                |   |   |-> tooltips_class32
 383 *                |   |
 384 *                |   |-> SysHeader32
 385 *                |
 386 *                |-> ProxyTarget
 387 */
 388 BOOL WINAPI SetShellWindowEx(HWND hwndShell, HWND hwndListView)
 389 {
 390     BOOL ret;
 391
 392     if (GetShellWindow())
 393         return FALSE;
 394
 395     if (GetWindowLongW(hwndShell, GWL_EXSTYLE) & WS_EX_TOPMOST)
 396         return FALSE;
 397
 398     if (hwndListView != hwndShell)
 399         if (GetWindowLongW(hwndListView, GWL_EXSTYLE) & WS_EX_TOPMOST)
 400             return FALSE;
 401
 402     if (hwndListView && hwndListView!=hwndShell)
 403         SetWindowPos(hwndListView, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE|SWP_NOACTIVATE);
 404
 405     SetWindowPos(hwndShell, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE|SWP_NOACTIVATE);
 406
 407     SERVER_START_REQ(set_global_windows)
 408     {
 409         req->flags          = SET_GLOBAL_SHELL_WINDOWS;
 410         req->shell_window   = wine_server_user_handle( hwndShell );
 411         req->shell_listview = wine_server_user_handle( hwndListView );
 412         ret = !wine_server_call_err(req);
 413     }
 414     SERVER_END_REQ;
 415
 416     return ret;
 417 }
 418
 419
 420 /*******************************************************************
 421 *               SetShellWindow (USER32.@)
 422 */
 423 BOOL WINAPI SetShellWindow(HWND hwndShell)
 424 {
 425     return SetShellWindowEx(hwndShell, hwndShell);
 426 }
 427
 428
 429 /*******************************************************************
 430 *               GetShellWindow (USER32.@)
 431 */
 432 HWND WINAPI GetShellWindow(void)
 433 {
 434     HWND hwndShell = 0;
 435
 436     SERVER_START_REQ(set_global_windows)
 437     {
 438         req->flags = 0;
 439         if (!wine_server_call_err(req))
 440             hwndShell = wine_server_ptr_handle( reply->old_shell_window );
 441     }
 442     SERVER_END_REQ;
 443
 444     return hwndShell;
 445 }
 446
 447
 448 /***********************************************************************
 449  *              SetProgmanWindow (USER32.@)
 450  */
 451 HWND WINAPI SetProgmanWindow ( HWND hwnd )
 452 {
 453     SERVER_START_REQ(set_global_windows)
 454     {
 455         req->flags          = SET_GLOBAL_PROGMAN_WINDOW;
 456         req->progman_window = wine_server_user_handle( hwnd );
 457         if (wine_server_call_err( req )) hwnd = 0;
 458     }
 459     SERVER_END_REQ;
 460     return hwnd;
 461 }
 462
 463
 464 /***********************************************************************
 465  *              GetProgmanWindow (USER32.@)
 466  */
 467 HWND WINAPI GetProgmanWindow(void)
 468 {
 469     HWND ret = 0;
 470
 471     SERVER_START_REQ(set_global_windows)
 472     {
 473         req->flags = 0;
 474         if (!wine_server_call_err(req))
 475             ret = wine_server_ptr_handle( reply->old_progman_window );
 476     }
 477     SERVER_END_REQ;
 478     return ret;
 479 }
 480
 481
 482 /***********************************************************************
 483  *              SetTaskmanWindow (USER32.@)
 484  * NOTES
 485  *   hwnd = MSTaskSwWClass
 486  *          |-> SysTabControl32
 487  */
 488 HWND WINAPI SetTaskmanWindow ( HWND hwnd )
 489 {
 490     SERVER_START_REQ(set_global_windows)
 491     {
 492         req->flags          = SET_GLOBAL_TASKMAN_WINDOW;
 493         req->taskman_window = wine_server_user_handle( hwnd );
 494         if (wine_server_call_err( req )) hwnd = 0;
 495     }
 496     SERVER_END_REQ;
 497     return hwnd;
 498 }
 499
 500 /***********************************************************************
 501  *              GetTaskmanWindow (USER32.@)
 502  */
 503 HWND WINAPI GetTaskmanWindow(void)
 504 {
 505     HWND ret = 0;
 506
 507     SERVER_START_REQ(set_global_windows)
 508     {
 509         req->flags = 0;
 510         if (!wine_server_call_err(req))
 511             ret = wine_server_ptr_handle( reply->old_taskman_window );
 512     }
 513     SERVER_END_REQ;
 514     return ret;
 515 }