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 "config.h"
  24 #include "wine/port.h"
  25
  26 #include <stdarg.h>
  27
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "winuser.h"
  31 #include "win.h"
  32 #include "user_private.h"
  33 #include "wine/server.h"
  34 #include "wine/debug.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(win);
  37
  38
  39 /*****************************************************************
  40  *              set_focus_window
  41  *
  42  * Change the focus window, sending the WM_SETFOCUS and WM_KILLFOCUS messages
  43  */
  44 static HWND set_focus_window( HWND hwnd )
  45 {
  46     HWND previous = 0;
  47     BOOL ret;
  48
  49     SERVER_START_REQ( set_focus_window )
  50     {
  51         req->handle = wine_server_user_handle( hwnd );
  52         if ((ret = !wine_server_call_err( req )))
  53             previous = wine_server_ptr_handle( reply->previous );
  54     }
  55     SERVER_END_REQ;
  56     if (!ret) return 0;
  57     if (previous == hwnd) return previous;
  58
  59     if (previous)
  60     {
  61         SendMessageW( previous, WM_KILLFOCUS, (WPARAM)hwnd, 0 );
  62         if (hwnd != GetFocus()) return previous;  /* changed by the message */
  63     }
  64     if (IsWindow(hwnd))
  65     {
  66         USER_Driver->pSetFocus(hwnd);
  67         SendMessageW( hwnd, WM_SETFOCUS, (WPARAM)previous, 0 );
  68     }
  69     return previous;
  70 }
  71
  72
  73 /*******************************************************************
  74  *              set_active_window
  75  */
  76 static BOOL set_active_window( HWND hwnd, HWND *prev, BOOL mouse, BOOL focus )
  77 {
  78     HWND previous = GetActiveWindow();
  79     BOOL ret;
  80     DWORD old_thread, new_thread;
  81     CBTACTIVATESTRUCT cbt;
  82
  83     if (previous == hwnd)
  84     {
  85         if (prev) *prev = hwnd;
  86         return TRUE;
  87     }
  88
  89     /* call CBT hook chain */
  90     cbt.fMouse     = mouse;
  91     cbt.hWndActive = previous;
  92     if (HOOK_CallHooks( WH_CBT, HCBT_ACTIVATE, (WPARAM)hwnd, (LPARAM)&cbt, TRUE )) return FALSE;
  93
  94     if (IsWindow(previous))
  95     {
  96         SendMessageW( previous, WM_NCACTIVATE, FALSE, (LPARAM)hwnd );
  97         SendMessageW( previous, WM_ACTIVATE,
  98                       MAKEWPARAM( WA_INACTIVE, IsIconic(previous) ), (LPARAM)hwnd );
  99     }
 100
 101     SERVER_START_REQ( set_active_window )
 102     {
 103         req->handle = wine_server_user_handle( hwnd );
 104         if ((ret = !wine_server_call_err( req )))
 105             previous = wine_server_ptr_handle( reply->previous );
 106     }
 107     SERVER_END_REQ;
 108     if (!ret) return FALSE;
 109     if (prev) *prev = previous;
 110     if (previous == hwnd) return TRUE;
 111
 112     if (hwnd)
 113     {
 114         /* send palette messages */
 115         if (SendMessageW( hwnd, WM_QUERYNEWPALETTE, 0, 0 ))
 116             SendMessageTimeoutW( HWND_BROADCAST, WM_PALETTEISCHANGING, (WPARAM)hwnd, 0,
 117                                  SMTO_ABORTIFHUNG, 2000, NULL );
 118         if (!IsWindow(hwnd)) return FALSE;
 119     }
 120
 121     old_thread = previous ? GetWindowThreadProcessId( previous, NULL ) : 0;
 122     new_thread = hwnd ? GetWindowThreadProcessId( hwnd, NULL ) : 0;
 123
 124     if (old_thread != new_thread)
 125     {
 126         HWND *list, *phwnd;
 127
 128         if ((list = WIN_ListChildren( GetDesktopWindow() )))
 129         {
 130             if (old_thread)
 131             {
 132                 for (phwnd = list; *phwnd; phwnd++)
 133                 {
 134                     if (GetWindowThreadProcessId( *phwnd, NULL ) == old_thread)
 135                         SendMessageW( *phwnd, WM_ACTIVATEAPP, 0, new_thread );
 136                 }
 137             }
 138             if (new_thread)
 139             {
 140                 for (phwnd = list; *phwnd; phwnd++)
 141                 {
 142                     if (GetWindowThreadProcessId( *phwnd, NULL ) == new_thread)
 143                         SendMessageW( *phwnd, WM_ACTIVATEAPP, 1, old_thread );
 144                 }
 145             }
 146             HeapFree( GetProcessHeap(), 0, list );
 147         }
 148     }
 149
 150     if (IsWindow(hwnd))
 151     {
 152         SendMessageW( hwnd, WM_NCACTIVATE, (hwnd == GetForegroundWindow()), (LPARAM)previous );
 153         SendMessageW( hwnd, WM_ACTIVATE,
 154                       MAKEWPARAM( mouse ? WA_CLICKACTIVE : WA_ACTIVE, IsIconic(hwnd) ),
 155                       (LPARAM)previous );
 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 = GetWindowLongW( hwnd, GWL_STYLE );
 236
 237         if ((style & (WS_POPUP|WS_CHILD)) == WS_CHILD)
 238             return GetActiveWindow();  /* Windows doesn't seem to return an error here */
 239
 240         hwnd = WIN_GetFullHandle( hwnd );
 241     }
 242
 243     if (!set_active_window( hwnd, &prev, FALSE, TRUE )) return 0;
 244     return prev;
 245 }
 246
 247
 248 /*****************************************************************
 249  *              SetFocus  (USER32.@)
 250  */
 251 HWND WINAPI SetFocus( HWND hwnd )
 252 {
 253     HWND hwndTop = hwnd;
 254     HWND previous = GetFocus();
 255
 256     TRACE( "%p prev %p\n", hwnd, previous );
 257
 258     if (hwnd)
 259     {
 260         /* Check if we can set the focus to this window */
 261         hwnd = WIN_GetFullHandle( hwnd );
 262         if (hwnd == previous) return previous;  /* nothing to do */
 263         for (;;)
 264         {
 265             HWND parent;
 266             LONG style = GetWindowLongW( hwndTop, GWL_STYLE );
 267             if (style & (WS_MINIMIZE | WS_DISABLED)) return 0;
 268             parent = GetAncestor( hwndTop, GA_PARENT );
 269             if (!parent || parent == GetDesktopWindow())
 270             {
 271                 if ((style & (WS_POPUP|WS_CHILD)) == WS_CHILD) return 0;
 272                 break;
 273             }
 274             if (parent == get_hwnd_message_parent()) return 0;
 275             hwndTop = parent;
 276         }
 277
 278         /* call hooks */
 279         if (HOOK_CallHooks( WH_CBT, HCBT_SETFOCUS, (WPARAM)hwnd, (LPARAM)previous, TRUE )) return 0;
 280
 281         /* activate hwndTop if needed. */
 282         if (hwndTop != GetActiveWindow())
 283         {
 284             if (!set_active_window( hwndTop, NULL, FALSE, FALSE )) return 0;
 285             if (!IsWindow( hwnd )) return 0;  /* Abort if window destroyed */
 286
 287             /* Do not change focus if the window is no longer active */
 288             if (hwndTop != GetActiveWindow()) return 0;
 289         }
 290     }
 291     else /* NULL hwnd passed in */
 292     {
 293         if (!previous) return 0;  /* nothing to do */
 294         if (HOOK_CallHooks( WH_CBT, HCBT_SETFOCUS, 0, (LPARAM)previous, TRUE )) return 0;
 295     }
 296
 297     /* change focus and send messages */
 298     return set_focus_window( hwnd );
 299 }
 300
 301
 302 /*******************************************************************
 303  *              SetForegroundWindow  (USER32.@)
 304  */
 305 BOOL WINAPI SetForegroundWindow( HWND hwnd )
 306 {
 307     TRACE( "%p\n", hwnd );
 308
 309     hwnd = WIN_GetFullHandle( hwnd );
 310     return set_foreground_window( hwnd, FALSE );
 311 }
 312
 313
 314 /*******************************************************************
 315  *              GetActiveWindow  (USER32.@)
 316  */
 317 HWND WINAPI GetActiveWindow(void)
 318 {
 319     HWND ret = 0;
 320
 321     SERVER_START_REQ( get_thread_input )
 322     {
 323         req->tid = GetCurrentThreadId();
 324         if (!wine_server_call_err( req )) ret = wine_server_ptr_handle( reply->active );
 325     }
 326     SERVER_END_REQ;
 327     return ret;
 328 }
 329
 330
 331 /*****************************************************************
 332  *              GetFocus  (USER32.@)
 333  */
 334 HWND WINAPI GetFocus(void)
 335 {
 336     HWND ret = 0;
 337
 338     SERVER_START_REQ( get_thread_input )
 339     {
 340         req->tid = GetCurrentThreadId();
 341         if (!wine_server_call_err( req )) ret = wine_server_ptr_handle( reply->focus );
 342     }
 343     SERVER_END_REQ;
 344     return ret;
 345 }
 346
 347
 348 /*******************************************************************
 349  *              GetForegroundWindow  (USER32.@)
 350  */
 351 HWND WINAPI GetForegroundWindow(void)
 352 {
 353     HWND ret = 0;
 354
 355     SERVER_START_REQ( get_thread_input )
 356     {
 357         req->tid = 0;
 358         if (!wine_server_call_err( req )) ret = wine_server_ptr_handle( reply->foreground );
 359     }
 360     SERVER_END_REQ;
 361     return ret;
 362 }
 363
 364
 365 /***********************************************************************
 366 *               SetShellWindowEx (USER32.@)
 367 * hwndShell =    Progman[Program Manager]
 368 *                |-> SHELLDLL_DefView
 369 * hwndListView = |   |-> SysListView32
 370 *                |   |   |-> tooltips_class32
 371 *                |   |
 372 *                |   |-> SysHeader32
 373 *                |
 374 *                |-> ProxyTarget
 375 */
 376 BOOL WINAPI SetShellWindowEx(HWND hwndShell, HWND hwndListView)
 377 {
 378     BOOL ret;
 379
 380     if (GetShellWindow())
 381         return FALSE;
 382
 383     if (GetWindowLongW(hwndShell, GWL_EXSTYLE) & WS_EX_TOPMOST)
 384         return FALSE;
 385
 386     if (hwndListView != hwndShell)
 387         if (GetWindowLongW(hwndListView, GWL_EXSTYLE) & WS_EX_TOPMOST)
 388             return FALSE;
 389
 390     if (hwndListView && hwndListView!=hwndShell)
 391         SetWindowPos(hwndListView, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE|SWP_NOACTIVATE);
 392
 393     SetWindowPos(hwndShell, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE|SWP_NOACTIVATE);
 394
 395     SERVER_START_REQ(set_global_windows)
 396     {
 397         req->flags          = SET_GLOBAL_SHELL_WINDOWS;
 398         req->shell_window   = wine_server_user_handle( hwndShell );
 399         req->shell_listview = wine_server_user_handle( hwndListView );
 400         ret = !wine_server_call_err(req);
 401     }
 402     SERVER_END_REQ;
 403
 404     return ret;
 405 }
 406
 407
 408 /*******************************************************************
 409 *               SetShellWindow (USER32.@)
 410 */
 411 BOOL WINAPI SetShellWindow(HWND hwndShell)
 412 {
 413     return SetShellWindowEx(hwndShell, hwndShell);
 414 }
 415
 416
 417 /*******************************************************************
 418 *               GetShellWindow (USER32.@)
 419 */
 420 HWND WINAPI GetShellWindow(void)
 421 {
 422     HWND hwndShell = 0;
 423
 424     SERVER_START_REQ(set_global_windows)
 425     {
 426         req->flags = 0;
 427         if (!wine_server_call_err(req))
 428             hwndShell = wine_server_ptr_handle( reply->old_shell_window );
 429     }
 430     SERVER_END_REQ;
 431
 432     return hwndShell;
 433 }
 434
 435
 436 /***********************************************************************
 437  *              SetProgmanWindow (USER32.@)
 438  */
 439 HWND WINAPI SetProgmanWindow ( HWND hwnd )
 440 {
 441     SERVER_START_REQ(set_global_windows)
 442     {
 443         req->flags          = SET_GLOBAL_PROGMAN_WINDOW;
 444         req->progman_window = wine_server_user_handle( hwnd );
 445         if (wine_server_call_err( req )) hwnd = 0;
 446     }
 447     SERVER_END_REQ;
 448     return hwnd;
 449 }
 450
 451
 452 /***********************************************************************
 453  *              GetProgmanWindow (USER32.@)
 454  */
 455 HWND WINAPI GetProgmanWindow(void)
 456 {
 457     HWND ret = 0;
 458
 459     SERVER_START_REQ(set_global_windows)
 460     {
 461         req->flags = 0;
 462         if (!wine_server_call_err(req))
 463             ret = wine_server_ptr_handle( reply->old_progman_window );
 464     }
 465     SERVER_END_REQ;
 466     return ret;
 467 }
 468
 469
 470 /***********************************************************************
 471  *              SetTaskmanWindow (USER32.@)
 472  * NOTES
 473  *   hwnd = MSTaskSwWClass
 474  *          |-> SysTabControl32
 475  */
 476 HWND WINAPI SetTaskmanWindow ( HWND hwnd )
 477 {
 478     SERVER_START_REQ(set_global_windows)
 479     {
 480         req->flags          = SET_GLOBAL_TASKMAN_WINDOW;
 481         req->taskman_window = wine_server_user_handle( hwnd );
 482         if (wine_server_call_err( req )) hwnd = 0;
 483     }
 484     SERVER_END_REQ;
 485     return hwnd;
 486 }
 487
 488 /***********************************************************************
 489  *              GetTaskmanWindow (USER32.@)
 490  */
 491 HWND WINAPI GetTaskmanWindow(void)
 492 {
 493     HWND ret = 0;
 494
 495     SERVER_START_REQ(set_global_windows)
 496     {
 497         req->flags = 0;
 498         if (!wine_server_call_err(req))
 499             ret = wine_server_ptr_handle( reply->old_taskman_window );
 500     }
 501     SERVER_END_REQ;
 502     return ret;
 503 }