2007-11-27 22:40:25 +03:00
|
|
|
/********************************************************************
|
2007-04-29 21:35:43 +04:00
|
|
|
KWin - the KDE window manager
|
|
|
|
This file is part of the KDE project.
|
|
|
|
|
|
|
|
Copyright (C) 1999, 2000 Matthias Ettrich <ettrich@kde.org>
|
|
|
|
Copyright (C) 2003 Lubos Lunak <l.lunak@kde.org>
|
|
|
|
|
2007-11-27 22:40:25 +03:00
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*********************************************************************/
|
2007-04-29 21:35:43 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
|
|
|
|
This file contains things relevant to window activation and focus
|
|
|
|
stealing prevention.
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "client.h"
|
2013-02-26 11:45:44 +04:00
|
|
|
#include "cursor.h"
|
2012-11-20 20:26:50 +04:00
|
|
|
#include "focuschain.h"
|
2013-04-26 12:41:24 +04:00
|
|
|
#include "netinfo.h"
|
2007-04-29 21:35:43 +04:00
|
|
|
#include "workspace.h"
|
2013-04-04 18:14:12 +04:00
|
|
|
#ifdef KWIN_BUILD_ACTIVITIES
|
|
|
|
#include "activities.h"
|
|
|
|
#endif
|
2007-04-29 21:35:43 +04:00
|
|
|
|
|
|
|
#include <fixx11h.h>
|
|
|
|
#include <kxerrorhandler.h>
|
|
|
|
#include <kstartupinfo.h>
|
|
|
|
#include <kstringhandler.h>
|
2013-03-07 15:55:39 +04:00
|
|
|
#include <KDE/KLocalizedString>
|
2007-04-29 21:35:43 +04:00
|
|
|
|
|
|
|
#include "atoms.h"
|
|
|
|
#include "group.h"
|
|
|
|
#include "rules.h"
|
2013-04-03 14:19:27 +04:00
|
|
|
#include "screens.h"
|
2012-08-19 14:00:53 +04:00
|
|
|
#include "useractions.h"
|
2007-04-29 21:35:43 +04:00
|
|
|
#include <QX11Info>
|
|
|
|
|
|
|
|
namespace KWin
|
|
|
|
{
|
|
|
|
|
|
|
|
/*
|
|
|
|
Prevention of focus stealing:
|
|
|
|
|
|
|
|
KWin tries to prevent unwanted changes of focus, that would result
|
|
|
|
from mapping a new window. Also, some nasty applications may try
|
|
|
|
to force focus change even in cases when ICCCM 4.2.7 doesn't allow it
|
|
|
|
(e.g. they may try to activate their main window because the user
|
|
|
|
definitely "needs" to see something happened - misusing
|
|
|
|
of QWidget::setActiveWindow() may be such case).
|
|
|
|
|
|
|
|
There are 4 ways how a window may become active:
|
|
|
|
- the user changes the active window (e.g. focus follows mouse, clicking
|
|
|
|
on some window's titlebar) - the change of focus will
|
|
|
|
be done by KWin, so there's nothing to solve in this case
|
|
|
|
- the change of active window will be requested using the _NET_ACTIVE_WINDOW
|
|
|
|
message (handled in RootInfo::changeActiveWindow()) - such requests
|
|
|
|
will be obeyed, because this request is meant mainly for e.g. taskbar
|
|
|
|
asking the WM to change the active window as a result of some user action.
|
|
|
|
Normal applications should use this request only rarely in special cases.
|
|
|
|
See also below the discussion of _NET_ACTIVE_WINDOW_TRANSFER.
|
|
|
|
- the change of active window will be done by performing XSetInputFocus()
|
|
|
|
on a window that's not currently active. ICCCM 4.2.7 describes when
|
|
|
|
the application may perform change of input focus. In order to handle
|
|
|
|
misbehaving applications, KWin will try to detect focus changes to
|
|
|
|
windows that don't belong to currently active application, and restore
|
|
|
|
focus back to the currently active window, instead of activating the window
|
|
|
|
that got focus (unfortunately there's no way to FocusChangeRedirect similar
|
|
|
|
to e.g. SubstructureRedirect, so there will be short time when the focus
|
|
|
|
will be changed). The check itself that's done is
|
|
|
|
Workspace::allowClientActivation() (see below).
|
|
|
|
- a new window will be mapped - this is the most complicated case. If
|
|
|
|
the new window belongs to the currently active application, it may be safely
|
|
|
|
mapped on top and activated. The same if there's no active window,
|
|
|
|
or the active window is the desktop. These checks are done by
|
|
|
|
Workspace::allowClientActivation().
|
|
|
|
Following checks need to compare times. One time is the timestamp
|
|
|
|
of last user action in the currently active window, the other time is
|
|
|
|
the timestamp of the action that originally caused mapping of the new window
|
|
|
|
(e.g. when the application was started). If the first time is newer than
|
|
|
|
the second one, the window will not be activated, as that indicates
|
|
|
|
futher user actions took place after the action leading to this new
|
|
|
|
mapped window. This check is done by Workspace::allowClientActivation().
|
|
|
|
There are several ways how to get the timestamp of action that caused
|
|
|
|
the new mapped window (done in Client::readUserTimeMapTimestamp()) :
|
|
|
|
- the window may have the _NET_WM_USER_TIME property. This way
|
|
|
|
the application may either explicitly request that the window is not
|
|
|
|
activated (by using 0 timestamp), or the property contains the time
|
|
|
|
of last user action in the application.
|
|
|
|
- KWin itself tries to detect time of last user action in every window,
|
|
|
|
by watching KeyPress and ButtonPress events on windows. This way some
|
|
|
|
events may be missed (if they don't propagate to the toplevel window),
|
|
|
|
but it's good as a fallback for applications that don't provide
|
|
|
|
_NET_WM_USER_TIME, and missing some events may at most lead
|
|
|
|
to unwanted focus stealing.
|
|
|
|
- the timestamp may come from application startup notification.
|
|
|
|
Application startup notification, if it exists for the new mapped window,
|
|
|
|
should include time of the user action that caused it.
|
|
|
|
- if there's no timestamp available, it's checked whether the new window
|
|
|
|
belongs to some already running application - if yes, the timestamp
|
|
|
|
will be 0 (i.e. refuse activation)
|
|
|
|
- if the window is from session restored window, the timestamp will
|
|
|
|
be 0 too, unless this application was the active one at the time
|
|
|
|
when the session was saved, in which case the window will be
|
|
|
|
activated if there wasn't any user interaction since the time
|
|
|
|
KWin was started.
|
|
|
|
- as the last resort, the _KDE_NET_USER_CREATION_TIME timestamp
|
|
|
|
is used. For every toplevel window that is created (see CreateNotify
|
|
|
|
handling), this property is set to the at that time current time.
|
|
|
|
Since at this time it's known that the new window doesn't belong
|
|
|
|
to any existing application (better said, the application doesn't
|
|
|
|
have any other window mapped), it is either the very first window
|
2009-02-07 04:12:28 +03:00
|
|
|
of the application, or it is the only window of the application
|
2007-04-29 21:35:43 +04:00
|
|
|
that was hidden before. The latter case is handled by removing
|
|
|
|
the property from windows before withdrawing them, making
|
|
|
|
the timestamp empty for next mapping of the window. In the sooner
|
|
|
|
case, the timestamp will be used. This helps in case when
|
|
|
|
an application is launched without application startup notification,
|
|
|
|
it creates its mainwindow, and starts its initialization (that
|
|
|
|
may possibly take long time). The timestamp used will be older
|
|
|
|
than any user action done after launching this application.
|
|
|
|
- if no timestamp is found at all, the window is activated.
|
|
|
|
The check whether two windows belong to the same application (same
|
|
|
|
process) is done in Client::belongToSameApplication(). Not 100% reliable,
|
|
|
|
but hopefully 99,99% reliable.
|
|
|
|
|
|
|
|
As a somewhat special case, window activation is always enabled when
|
|
|
|
session saving is in progress. When session saving, the session
|
|
|
|
manager allows only one application to interact with the user.
|
|
|
|
Not allowing window activation in such case would result in e.g. dialogs
|
|
|
|
not becoming active, so focus stealing prevention would cause here
|
|
|
|
more harm than good.
|
|
|
|
|
|
|
|
Windows that attempted to become active but KWin prevented this will
|
|
|
|
be marked as demanding user attention. They'll get
|
|
|
|
the _NET_WM_STATE_DEMANDS_ATTENTION state, and the taskbar should mark
|
|
|
|
them specially (blink, etc.). The state will be reset when the window
|
|
|
|
eventually really becomes active.
|
|
|
|
|
|
|
|
There are one more ways how a window can become obstrusive, window stealing
|
|
|
|
focus: By showing above the active window, by either raising itself,
|
|
|
|
or by moving itself on the active desktop.
|
|
|
|
- KWin will refuse raising non-active window above the active one,
|
|
|
|
unless they belong to the same application. Applications shouldn't
|
|
|
|
raise their windows anyway (unless the app wants to raise one
|
|
|
|
of its windows above another of its windows).
|
|
|
|
- KWin activates windows moved to the current desktop (as that seems
|
|
|
|
logical from the user's point of view, after sending the window
|
|
|
|
there directly from KWin, or e.g. using pager). This means
|
|
|
|
applications shouldn't send their windows to another desktop
|
|
|
|
(SELI TODO - but what if they do?)
|
|
|
|
|
|
|
|
Special cases I can think of:
|
|
|
|
- konqueror reusing, i.e. kfmclient tells running Konqueror instance
|
|
|
|
to open new window
|
|
|
|
- without focus stealing prevention - no problem
|
|
|
|
- with ASN (application startup notification) - ASN is forwarded,
|
|
|
|
and because it's newer than the instance's user timestamp,
|
|
|
|
it takes precedence
|
|
|
|
- without ASN - user timestamp needs to be reset, otherwise it would
|
|
|
|
be used, and it's old; moreover this new window mustn't be detected
|
|
|
|
as window belonging to already running application, or it wouldn't
|
|
|
|
be activated - see Client::sameAppWindowRoleMatch() for the (rather ugly)
|
|
|
|
hack
|
|
|
|
- konqueror preloading, i.e. window is created in advance, and kfmclient
|
|
|
|
tells this Konqueror instance to show it later
|
|
|
|
- without focus stealing prevention - no problem
|
|
|
|
- with ASN - ASN is forwarded, and because it's newer than the instance's
|
|
|
|
user timestamp, it takes precedence
|
|
|
|
- without ASN - user timestamp needs to be reset, otherwise it would
|
|
|
|
be used, and it's old; also, creation timestamp is changed to
|
|
|
|
the time the instance starts (re-)initializing the window,
|
|
|
|
this ensures creation timestamp will still work somewhat even in this case
|
|
|
|
- KUniqueApplication - when the window is already visible, and the new instance
|
|
|
|
wants it to activate
|
|
|
|
- without focus stealing prevention - _NET_ACTIVE_WINDOW - no problem
|
|
|
|
- with ASN - ASN is forwarded, and set on the already visible window, KWin
|
|
|
|
treats the window as new with that ASN
|
|
|
|
- without ASN - _NET_ACTIVE_WINDOW as application request is used,
|
|
|
|
and there's no really usable timestamp, only timestamp
|
|
|
|
from the time the (new) application instance was started,
|
|
|
|
so KWin will activate the window *sigh*
|
|
|
|
- the bad thing here is that there's absolutely no chance to recognize
|
|
|
|
the case of starting this KUniqueApp from Konsole (and thus wanting
|
|
|
|
the already visible window to become active) from the case
|
|
|
|
when something started this KUniqueApp without ASN (in which case
|
|
|
|
the already visible window shouldn't become active)
|
|
|
|
- the only solution is using ASN for starting applications, at least silent
|
|
|
|
(i.e. without feedback)
|
|
|
|
- when one application wants to activate another application's window (e.g. KMail
|
|
|
|
activating already running KAddressBook window ?)
|
|
|
|
- without focus stealing prevention - _NET_ACTIVE_WINDOW - no problem
|
|
|
|
- with ASN - can't be here, it's the KUniqueApp case then
|
|
|
|
- without ASN - _NET_ACTIVE_WINDOW as application request should be used,
|
|
|
|
KWin will activate the new window depending on the timestamp and
|
|
|
|
whether it belongs to the currently active application
|
|
|
|
|
|
|
|
_NET_ACTIVE_WINDOW usage:
|
|
|
|
data.l[0]= 1 ->app request
|
|
|
|
= 2 ->pager request
|
|
|
|
= 0 - backwards compatibility
|
|
|
|
data.l[1]= timestamp
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
//****************************************
|
|
|
|
// Workspace
|
|
|
|
//****************************************
|
|
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
Informs the workspace about the active client, i.e. the client that
|
|
|
|
has the focus (or None if no client has the focus). This functions
|
|
|
|
is called by the client itself that gets focus. It has no other
|
|
|
|
effect than fixing the focus chain and the return value of
|
|
|
|
activeClient(). And of course, to propagate the active client to the
|
|
|
|
world.
|
|
|
|
*/
|
2013-04-26 11:47:45 +04:00
|
|
|
void Workspace::setActiveClient(Client* c)
|
2011-01-30 17:34:42 +03:00
|
|
|
{
|
|
|
|
if (active_client == c)
|
2007-04-29 21:35:43 +04:00
|
|
|
return;
|
2011-01-30 17:34:42 +03:00
|
|
|
|
|
|
|
if (active_popup && active_popup_client != c && set_active_client_recursion == 0)
|
2007-04-29 21:35:43 +04:00
|
|
|
closeActivePopup();
|
2012-08-19 14:00:53 +04:00
|
|
|
if (m_userActionsMenu->hasClient() && !m_userActionsMenu->isMenuClient(c) && set_active_client_recursion == 0) {
|
|
|
|
m_userActionsMenu->close();
|
|
|
|
}
|
2011-01-30 17:34:42 +03:00
|
|
|
StackingUpdatesBlocker blocker(this);
|
2007-04-29 21:35:43 +04:00
|
|
|
++set_active_client_recursion;
|
2011-01-30 17:34:42 +03:00
|
|
|
updateFocusMousePosition(cursorPos());
|
|
|
|
if (active_client != NULL) {
|
|
|
|
// note that this may call setActiveClient( NULL ), therefore the recursion counter
|
|
|
|
active_client->setActive(false);
|
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
active_client = c;
|
2011-01-30 17:34:42 +03:00
|
|
|
Q_ASSERT(c == NULL || c->isActive());
|
|
|
|
if (active_client != NULL)
|
2007-04-29 21:35:43 +04:00
|
|
|
last_active_client = active_client;
|
2011-01-30 17:34:42 +03:00
|
|
|
if (active_client) {
|
2012-11-20 20:26:50 +04:00
|
|
|
FocusChain::self()->update(active_client, FocusChain::MakeFirst);
|
2011-01-30 17:34:42 +03:00
|
|
|
active_client->demandAttention(false);
|
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
pending_take_activity = NULL;
|
|
|
|
|
2011-01-30 17:34:42 +03:00
|
|
|
updateToolWindows(false);
|
|
|
|
if (c)
|
|
|
|
disableGlobalShortcutsForClient(c->rules()->checkDisableGlobalShortcuts(false));
|
2007-04-29 21:35:43 +04:00
|
|
|
else
|
2011-01-30 17:34:42 +03:00
|
|
|
disableGlobalShortcutsForClient(false);
|
2007-04-29 21:35:43 +04:00
|
|
|
|
|
|
|
updateStackingOrder(); // e.g. fullscreens have different layer when active/not-active
|
|
|
|
|
2013-04-29 14:17:42 +04:00
|
|
|
rootInfo()->setActiveWindow(active_client ? active_client->window() : 0);
|
2011-02-27 12:05:04 +03:00
|
|
|
|
|
|
|
emit clientActivated(active_client);
|
2007-04-29 21:35:43 +04:00
|
|
|
--set_active_client_recursion;
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
|
|
|
|
/*!
|
|
|
|
Tries to activate the client \a c. This function performs what you
|
|
|
|
expect when clicking the respective entry in a taskbar: showing and
|
|
|
|
raising the client (this may imply switching to the another virtual
|
|
|
|
desktop) and putting the focus onto it. Once X really gave focus to
|
|
|
|
the client window as requested, the client itself will call
|
|
|
|
setActiveClient() and the operation is complete. This may not happen
|
|
|
|
with certain focus policies, though.
|
|
|
|
|
|
|
|
\sa stActiveClient(), requestFocus()
|
|
|
|
*/
|
2011-01-30 17:34:42 +03:00
|
|
|
void Workspace::activateClient(Client* c, bool force)
|
|
|
|
{
|
|
|
|
if (c == NULL) {
|
2007-04-30 15:46:54 +04:00
|
|
|
focusToNull();
|
2013-04-26 11:47:45 +04:00
|
|
|
setActiveClient(NULL);
|
2007-04-29 21:35:43 +04:00
|
|
|
return;
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
|
|
|
raiseClient(c);
|
|
|
|
if (!c->isOnCurrentDesktop()) {
|
2007-04-29 21:35:43 +04:00
|
|
|
++block_focus;
|
2012-11-16 11:23:47 +04:00
|
|
|
VirtualDesktopManager::self()->setCurrent(c->desktop());
|
2007-04-29 21:35:43 +04:00
|
|
|
--block_focus;
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2012-02-26 14:38:16 +04:00
|
|
|
#ifdef KWIN_BUILD_ACTIVITIES
|
2011-01-30 17:34:42 +03:00
|
|
|
if (!c->isOnCurrentActivity()) {
|
2010-05-13 22:53:08 +04:00
|
|
|
++block_focus;
|
|
|
|
//DBUS!
|
2013-04-04 18:14:12 +04:00
|
|
|
Activities::self()->setCurrent(c->activities().first()); //first isn't necessarily best, but it's easiest
|
2010-05-13 22:53:08 +04:00
|
|
|
--block_focus;
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2012-02-26 14:38:16 +04:00
|
|
|
#endif
|
2011-01-30 17:34:42 +03:00
|
|
|
if (c->isMinimized())
|
2007-04-29 21:35:43 +04:00
|
|
|
c->unminimize();
|
|
|
|
|
|
|
|
// TODO force should perhaps allow this only if the window already contains the mouse
|
2011-01-30 17:34:42 +03:00
|
|
|
if (options->focusPolicyIsReasonable() || force)
|
|
|
|
requestFocus(c, force);
|
2007-04-29 21:35:43 +04:00
|
|
|
|
|
|
|
// Don't update user time for clients that have focus stealing workaround.
|
|
|
|
// As they usually belong to the current active window but fail to provide
|
|
|
|
// this information, updating their user time would make the user time
|
|
|
|
// of the currently active window old, and reject further activation for it.
|
|
|
|
// E.g. typing URL in minicli which will show kio_uiserver dialog (with workaround),
|
|
|
|
// and then kdesktop shows dialog about SSL certificate.
|
|
|
|
// This needs also avoiding user creation time in Client::readUserTimeMapTimestamp().
|
2012-03-14 11:03:42 +04:00
|
|
|
c->updateUserTime();
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
|
|
|
|
/*!
|
|
|
|
Tries to activate the client by asking X for the input focus. This
|
|
|
|
function does not perform any show, raise or desktop switching. See
|
|
|
|
Workspace::activateClient() instead.
|
|
|
|
|
|
|
|
\sa Workspace::activateClient()
|
|
|
|
*/
|
2011-01-30 17:34:42 +03:00
|
|
|
void Workspace::requestFocus(Client* c, bool force)
|
|
|
|
{
|
|
|
|
takeActivity(c, ActivityFocus | (force ? ActivityFocusForce : 0), false);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Workspace::takeActivity(Client* c, int flags, bool handled)
|
|
|
|
{
|
|
|
|
// the 'if ( c == active_client ) return;' optimization mustn't be done here
|
|
|
|
if (!focusChangeEnabled() && (c != active_client))
|
2007-04-29 21:35:43 +04:00
|
|
|
flags &= ~ActivityFocus;
|
|
|
|
|
2011-01-30 17:34:42 +03:00
|
|
|
if (!c) {
|
2007-04-29 21:35:43 +04:00
|
|
|
focusToNull();
|
|
|
|
return;
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2011-01-30 17:34:42 +03:00
|
|
|
if (flags & ActivityFocus) {
|
2007-04-29 21:35:43 +04:00
|
|
|
Client* modal = c->findModal();
|
2011-01-30 17:34:42 +03:00
|
|
|
if (modal != NULL && modal != c) {
|
|
|
|
if (!modal->isOnDesktop(c->desktop())) {
|
|
|
|
modal->setDesktop(c->desktop());
|
|
|
|
if (modal->desktop() != c->desktop()) // forced desktop
|
|
|
|
activateClient(modal);
|
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
// if the click was inside the window (i.e. handled is set),
|
|
|
|
// but it has a modal, there's no need to use handled mode, because
|
|
|
|
// the modal doesn't get the click anyway
|
|
|
|
// raising of the original window needs to be still done
|
2011-01-30 17:34:42 +03:00
|
|
|
if (flags & ActivityRaise)
|
|
|
|
raiseClient(c);
|
2007-04-29 21:35:43 +04:00
|
|
|
c = modal;
|
|
|
|
handled = false;
|
|
|
|
}
|
2011-01-30 17:34:42 +03:00
|
|
|
cancelDelayFocus();
|
|
|
|
}
|
2011-06-24 14:19:47 +04:00
|
|
|
if (!(flags & ActivityFocusForce) && (c->isDock() || c->isSplash()))
|
2007-04-29 21:35:43 +04:00
|
|
|
flags &= ~ActivityFocus; // toplevel menus and dock windows don't take focus if not forced
|
2011-01-30 17:34:42 +03:00
|
|
|
if (c->isShade()) {
|
|
|
|
if (c->wantsInput() && (flags & ActivityFocus)) {
|
|
|
|
// client cannot accept focus, but at least the window should be active (window menu, et. al. )
|
|
|
|
c->setActive(true);
|
2007-04-29 21:35:43 +04:00
|
|
|
focusToNull();
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
flags &= ~ActivityFocus;
|
|
|
|
handled = false; // no point, can't get clicks
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2012-01-12 10:42:55 +04:00
|
|
|
if (c->tabGroup() && c->tabGroup()->current() != c)
|
|
|
|
c->tabGroup()->setCurrent(c);
|
2011-01-30 17:34:42 +03:00
|
|
|
if (!c->isShown(true)) { // shouldn't happen, call activateClient() if needed
|
|
|
|
kWarning(1212) << "takeActivity: not shown" ;
|
2007-04-29 21:35:43 +04:00
|
|
|
return;
|
|
|
|
}
|
2013-04-26 11:47:45 +04:00
|
|
|
c->takeActivity(flags, handled);
|
2013-04-03 14:19:27 +04:00
|
|
|
if (!c->isOnActiveScreen())
|
|
|
|
screens()->setCurrent(c->screen());
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2013-04-30 18:01:25 +04:00
|
|
|
void Workspace::handleTakeActivity(KWin::Client *c, xcb_timestamp_t /*timestamp*/, int flags)
|
2011-01-30 17:34:42 +03:00
|
|
|
{
|
|
|
|
if (pending_take_activity != c) // pending_take_activity is reset when doing restack or activation
|
2007-04-29 21:35:43 +04:00
|
|
|
return;
|
2011-01-30 17:34:42 +03:00
|
|
|
if ((flags & ActivityRaise) != 0)
|
|
|
|
raiseClient(c);
|
|
|
|
if ((flags & ActivityFocus) != 0 && c->isShown(false))
|
2013-04-26 11:47:45 +04:00
|
|
|
c->takeFocus();
|
2007-04-29 21:35:43 +04:00
|
|
|
pending_take_activity = NULL;
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
|
|
|
|
/*!
|
|
|
|
Informs the workspace that the client \a c has been hidden. If it
|
|
|
|
was the active client (or to-become the active client),
|
|
|
|
the workspace activates another one.
|
|
|
|
|
|
|
|
\a c may already be destroyed
|
|
|
|
*/
|
2011-01-30 17:34:42 +03:00
|
|
|
void Workspace::clientHidden(Client* c)
|
|
|
|
{
|
|
|
|
assert(!c->isShown(true) || !c->isOnCurrentDesktop() || !c->isOnCurrentActivity());
|
|
|
|
activateNextClient(c);
|
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2012-02-14 02:50:49 +04:00
|
|
|
Client *Workspace::clientUnderMouse(int screen) const
|
|
|
|
{
|
2012-04-08 12:07:35 +04:00
|
|
|
ToplevelList::const_iterator it = stackingOrder().constEnd();
|
2012-02-14 02:50:49 +04:00
|
|
|
while (it != stackingOrder().constBegin()) {
|
2012-04-08 12:07:35 +04:00
|
|
|
Client *client = qobject_cast<Client*>(*(--it));
|
|
|
|
if (!client) {
|
|
|
|
continue;
|
|
|
|
}
|
2012-02-14 02:50:49 +04:00
|
|
|
|
|
|
|
// rule out clients which are not really visible.
|
2012-08-16 10:03:07 +04:00
|
|
|
// the screen test is rather superfluous for xrandr & twinview since the geometry would differ -> TODO: might be dropped
|
2012-02-14 02:50:49 +04:00
|
|
|
if (!(client->isShown(false) && client->isOnCurrentDesktop() &&
|
|
|
|
client->isOnCurrentActivity() && client->isOnScreen(screen)))
|
|
|
|
continue;
|
|
|
|
|
2013-02-26 11:45:44 +04:00
|
|
|
if (client->geometry().contains(Cursor::pos())) {
|
2012-02-14 02:50:49 +04:00
|
|
|
return client;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-04-29 21:35:43 +04:00
|
|
|
// deactivates 'c' and activates next client
|
2011-01-30 17:34:42 +03:00
|
|
|
bool Workspace::activateNextClient(Client* c)
|
|
|
|
{
|
2007-04-29 21:35:43 +04:00
|
|
|
// if 'c' is not the active or the to-become active one, do nothing
|
2011-08-22 15:53:03 +04:00
|
|
|
if (!(c == active_client || (should_get_focus.count() > 0 && c == should_get_focus.last())))
|
2007-04-29 21:35:43 +04:00
|
|
|
return false;
|
2011-08-22 15:53:03 +04:00
|
|
|
|
2007-04-29 21:35:43 +04:00
|
|
|
closeActivePopup();
|
2011-08-22 15:53:03 +04:00
|
|
|
|
2011-01-30 17:34:42 +03:00
|
|
|
if (c != NULL) {
|
|
|
|
if (c == active_client)
|
2013-04-26 11:47:45 +04:00
|
|
|
setActiveClient(NULL);
|
2011-01-30 17:34:42 +03:00
|
|
|
should_get_focus.removeAll(c);
|
|
|
|
}
|
2011-08-22 15:53:03 +04:00
|
|
|
|
|
|
|
// if blocking focus, move focus to the desktop later if needed
|
|
|
|
// in order to avoid flickering
|
|
|
|
if (!focusChangeEnabled()) {
|
|
|
|
focusToNull();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!options->focusPolicyIsReasonable())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
Client* get_focus = NULL;
|
|
|
|
|
2012-11-09 01:26:09 +04:00
|
|
|
// precedence on keeping the current tabgroup active. to the user that's the same window
|
2013-03-02 00:08:16 +04:00
|
|
|
if (c && c->tabGroup() && c->isShown(false)) {
|
2012-11-09 01:26:09 +04:00
|
|
|
if (c == c->tabGroup()->current())
|
|
|
|
c->tabGroup()->activateNext();
|
|
|
|
get_focus = c->tabGroup()->current();
|
|
|
|
if (get_focus == c) // single tab case - should not happen
|
|
|
|
get_focus = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!get_focus && options->isNextFocusPrefersMouse()) {
|
2013-04-03 14:19:27 +04:00
|
|
|
get_focus = clientUnderMouse(c ? c->screen() : screens()->current());
|
2012-02-14 02:50:49 +04:00
|
|
|
if (get_focus && (get_focus == c || get_focus->isDesktop())) {
|
|
|
|
// should rather not happen, but it cannot get the focus. rest of usability is tested above
|
2012-11-09 01:26:09 +04:00
|
|
|
get_focus = NULL;
|
2011-08-22 15:53:03 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-11-16 11:23:47 +04:00
|
|
|
const int desktop = VirtualDesktopManager::self()->current();
|
|
|
|
|
2011-08-22 15:53:03 +04:00
|
|
|
if (!get_focus) { // no suitable window under the mouse -> find sth. else
|
|
|
|
// first try to pass the focus to the (former) active clients leader
|
2012-11-20 20:26:50 +04:00
|
|
|
if (c && (get_focus = c->transientFor()) && FocusChain::self()->isUsableFocusCandidate(get_focus, c)) {
|
2011-08-22 15:53:03 +04:00
|
|
|
raiseClient(get_focus); // also raise - we don't know where it came from
|
|
|
|
} else {
|
|
|
|
// nope, ask the focus chain for the next candidate
|
2012-11-20 20:26:50 +04:00
|
|
|
get_focus = FocusChain::self()->nextForDesktop(c, desktop);
|
2011-08-22 15:53:03 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (get_focus == NULL) // last chance: focus the desktop
|
2012-11-16 11:23:47 +04:00
|
|
|
get_focus = findDesktop(true, desktop);
|
2010-12-20 21:21:46 +03:00
|
|
|
|
2011-08-22 15:53:03 +04:00
|
|
|
if (get_focus != NULL)
|
|
|
|
requestFocus(get_focus);
|
|
|
|
else
|
2007-04-29 21:35:43 +04:00
|
|
|
focusToNull();
|
2011-08-22 15:53:03 +04:00
|
|
|
|
2007-04-29 21:35:43 +04:00
|
|
|
return true;
|
2011-08-22 15:53:03 +04:00
|
|
|
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2011-01-30 17:34:42 +03:00
|
|
|
void Workspace::setCurrentScreen(int new_screen)
|
|
|
|
{
|
2013-04-03 14:19:27 +04:00
|
|
|
if (new_screen < 0 || new_screen >= screens()->count())
|
2007-05-07 17:13:48 +04:00
|
|
|
return;
|
2011-01-30 17:34:42 +03:00
|
|
|
if (!options->focusPolicyIsReasonable())
|
2007-05-07 17:13:48 +04:00
|
|
|
return;
|
|
|
|
closeActivePopup();
|
2012-11-16 11:23:47 +04:00
|
|
|
const int desktop = VirtualDesktopManager::self()->current();
|
2012-11-20 20:26:50 +04:00
|
|
|
Client *get_focus = FocusChain::self()->getForActivation(desktop, new_screen);
|
2011-01-30 17:34:42 +03:00
|
|
|
if (get_focus == NULL)
|
2012-11-16 11:23:47 +04:00
|
|
|
get_focus = findDesktop(true, desktop);
|
2011-01-30 17:34:42 +03:00
|
|
|
if (get_focus != NULL && get_focus != mostRecentlyActivatedClient())
|
|
|
|
requestFocus(get_focus);
|
2013-04-03 14:19:27 +04:00
|
|
|
screens()->setCurrent(new_screen);
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2011-01-30 17:34:42 +03:00
|
|
|
void Workspace::gotFocusIn(const Client* c)
|
|
|
|
{
|
|
|
|
if (should_get_focus.contains(const_cast< Client* >(c))) {
|
|
|
|
// remove also all sooner elements that should have got FocusIn,
|
|
|
|
// but didn't for some reason (and also won't anymore, because they were sooner)
|
|
|
|
while (should_get_focus.first() != c)
|
2007-04-29 21:35:43 +04:00
|
|
|
should_get_focus.pop_front();
|
|
|
|
should_get_focus.pop_front(); // remove 'c'
|
|
|
|
}
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2011-01-30 17:34:42 +03:00
|
|
|
void Workspace::setShouldGetFocus(Client* c)
|
|
|
|
{
|
|
|
|
should_get_focus.append(c);
|
2007-04-29 21:35:43 +04:00
|
|
|
updateStackingOrder(); // e.g. fullscreens have different layer when active/not-active
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
|
|
|
|
// focus_in -> the window got FocusIn event
|
2007-11-29 18:01:30 +03:00
|
|
|
// ignore_desktop - call comes from _NET_ACTIVE_WINDOW message, don't refuse just because of window
|
|
|
|
// is on a different desktop
|
2013-04-30 18:01:25 +04:00
|
|
|
bool Workspace::allowClientActivation(const KWin::Client *c, xcb_timestamp_t time, bool focus_in, bool ignore_desktop)
|
2011-01-30 17:34:42 +03:00
|
|
|
{
|
2007-04-29 21:35:43 +04:00
|
|
|
// options->focusStealingPreventionLevel :
|
|
|
|
// 0 - none - old KWin behaviour, new windows always get focus
|
|
|
|
// 1 - low - focus stealing prevention is applied normally, when unsure, activation is allowed
|
|
|
|
// 2 - normal - focus stealing prevention is applied normally, when unsure, activation is not allowed,
|
|
|
|
// this is the default
|
|
|
|
// 3 - high - new window gets focus only if it belongs to the active application,
|
|
|
|
// or when no window is currently active
|
|
|
|
// 4 - extreme - no window gets focus without user intervention
|
2011-01-30 17:34:42 +03:00
|
|
|
if (time == -1U)
|
2007-04-29 21:35:43 +04:00
|
|
|
time = c->userTime();
|
2012-02-20 13:25:13 +04:00
|
|
|
int level = c->rules()->checkFSP(options->focusStealingPreventionLevel());
|
2011-01-30 17:34:42 +03:00
|
|
|
if (session_saving && level <= 2) { // <= normal
|
2007-04-29 21:35:43 +04:00
|
|
|
return true;
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
Client* ac = mostRecentlyActivatedClient();
|
2011-01-30 17:34:42 +03:00
|
|
|
if (focus_in) {
|
|
|
|
if (should_get_focus.contains(const_cast< Client* >(c)))
|
2007-04-29 21:35:43 +04:00
|
|
|
return true; // FocusIn was result of KWin's action
|
|
|
|
// Before getting FocusIn, the active Client already
|
|
|
|
// got FocusOut, and therefore got deactivated.
|
|
|
|
ac = last_active_client;
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
|
|
|
if (time == 0) // explicitly asked not to get focus
|
2007-04-29 21:35:43 +04:00
|
|
|
return false;
|
2011-01-30 17:34:42 +03:00
|
|
|
if (level == 0) // none
|
2007-04-29 21:35:43 +04:00
|
|
|
return true;
|
2011-01-30 17:34:42 +03:00
|
|
|
if (level == 4) // extreme
|
2007-04-29 21:35:43 +04:00
|
|
|
return false;
|
2011-01-30 17:34:42 +03:00
|
|
|
if (!ignore_desktop && !c->isOnCurrentDesktop())
|
2007-04-29 21:35:43 +04:00
|
|
|
return false; // allow only with level == 0
|
2011-01-30 17:34:42 +03:00
|
|
|
if (ac == NULL || ac->isDesktop()) {
|
|
|
|
kDebug(1212) << "Activation: No client active, allowing";
|
2007-04-29 21:35:43 +04:00
|
|
|
return true; // no active client -> always allow
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
// TODO window urgency -> return true?
|
2011-01-30 17:34:42 +03:00
|
|
|
if (Client::belongToSameApplication(c, ac, true)) {
|
|
|
|
kDebug(1212) << "Activation: Belongs to active application";
|
2007-04-29 21:35:43 +04:00
|
|
|
return true;
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
|
|
|
if (level == 3) // high
|
2007-04-29 21:35:43 +04:00
|
|
|
return false;
|
2011-01-30 17:34:42 +03:00
|
|
|
if (time == -1U) { // no time known
|
|
|
|
kDebug(1212) << "Activation: No timestamp at all";
|
|
|
|
if (level == 1) // low
|
2007-04-29 21:35:43 +04:00
|
|
|
return true;
|
|
|
|
// no timestamp at all, don't activate - because there's also creation timestamp
|
|
|
|
// done on CreateNotify, this case should happen only in case application
|
|
|
|
// maps again already used window, i.e. this won't happen after app startup
|
2011-01-30 17:34:42 +03:00
|
|
|
return false;
|
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
// level == 2 // normal
|
|
|
|
Time user_time = ac->userTime();
|
2011-01-30 17:34:42 +03:00
|
|
|
kDebug(1212) << "Activation, compared:" << c << ":" << time << ":" << user_time
|
|
|
|
<< ":" << (timestampCompare(time, user_time) >= 0) << endl;
|
|
|
|
return timestampCompare(time, user_time) >= 0; // time >= user_time
|
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
|
|
|
|
// basically the same like allowClientActivation(), this time allowing
|
|
|
|
// a window to be fully raised upon its own request (XRaiseWindow),
|
|
|
|
// if refused, it will be raised only on top of windows belonging
|
|
|
|
// to the same application
|
2013-04-30 18:01:25 +04:00
|
|
|
bool Workspace::allowFullClientRaising(const KWin::Client *c, xcb_timestamp_t time)
|
2011-01-30 17:34:42 +03:00
|
|
|
{
|
2012-02-20 13:25:13 +04:00
|
|
|
int level = c->rules()->checkFSP(options->focusStealingPreventionLevel());
|
2011-01-30 17:34:42 +03:00
|
|
|
if (session_saving && level <= 2) { // <= normal
|
2007-04-29 21:35:43 +04:00
|
|
|
return true;
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
Client* ac = mostRecentlyActivatedClient();
|
2011-01-30 17:34:42 +03:00
|
|
|
if (level == 0) // none
|
2007-04-29 21:35:43 +04:00
|
|
|
return true;
|
2011-01-30 17:34:42 +03:00
|
|
|
if (level == 4) // extreme
|
2007-04-29 21:35:43 +04:00
|
|
|
return false;
|
2011-01-30 17:34:42 +03:00
|
|
|
if (ac == NULL || ac->isDesktop()) {
|
|
|
|
kDebug(1212) << "Raising: No client active, allowing";
|
2007-04-29 21:35:43 +04:00
|
|
|
return true; // no active client -> always allow
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
// TODO window urgency -> return true?
|
2011-01-30 17:34:42 +03:00
|
|
|
if (Client::belongToSameApplication(c, ac, true)) {
|
|
|
|
kDebug(1212) << "Raising: Belongs to active application";
|
2007-04-29 21:35:43 +04:00
|
|
|
return true;
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
|
|
|
if (level == 3) // high
|
2007-04-29 21:35:43 +04:00
|
|
|
return false;
|
2013-04-30 18:01:25 +04:00
|
|
|
xcb_timestamp_t user_time = ac->userTime();
|
2011-01-30 17:34:42 +03:00
|
|
|
kDebug(1212) << "Raising, compared:" << time << ":" << user_time
|
|
|
|
<< ":" << (timestampCompare(time, user_time) >= 0) << endl;
|
|
|
|
return timestampCompare(time, user_time) >= 0; // time >= user_time
|
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
|
|
|
|
// called from Client after FocusIn that wasn't initiated by KWin and the client
|
|
|
|
// wasn't allowed to activate
|
|
|
|
void Workspace::restoreFocus()
|
2011-01-30 17:34:42 +03:00
|
|
|
{
|
2007-04-29 21:35:43 +04:00
|
|
|
// this updateXTime() is necessary - as FocusIn events don't have
|
|
|
|
// a timestamp *sigh*, kwin's timestamp would be older than the timestamp
|
|
|
|
// that was used by whoever caused the focus change, and therefore
|
|
|
|
// the attempt to restore the focus would fail due to old timestamp
|
|
|
|
updateXTime();
|
2011-01-30 17:34:42 +03:00
|
|
|
if (should_get_focus.count() > 0)
|
|
|
|
requestFocus(should_get_focus.last());
|
|
|
|
else if (last_active_client)
|
|
|
|
requestFocus(last_active_client);
|
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2011-01-30 17:34:42 +03:00
|
|
|
void Workspace::clientAttentionChanged(Client* c, bool set)
|
|
|
|
{
|
|
|
|
if (set) {
|
|
|
|
attention_chain.removeAll(c);
|
|
|
|
attention_chain.prepend(c);
|
|
|
|
} else
|
|
|
|
attention_chain.removeAll(c);
|
2012-03-09 13:17:19 +04:00
|
|
|
emit clientDemandsAttentionChanged(c, set);
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
|
|
|
|
//********************************************
|
|
|
|
// Client
|
|
|
|
//********************************************
|
|
|
|
|
|
|
|
/*!
|
|
|
|
Updates the user time (time of last action in the active window).
|
|
|
|
This is called inside kwin for every action with the window
|
|
|
|
that qualifies for user interaction (clicking on it, activate it
|
|
|
|
externally, etc.).
|
|
|
|
*/
|
2011-01-30 17:34:42 +03:00
|
|
|
void Client::updateUserTime(Time time)
|
|
|
|
{
|
|
|
|
// copied in Group::updateUserTime
|
|
|
|
if (time == CurrentTime)
|
2007-04-29 21:35:43 +04:00
|
|
|
time = xTime();
|
2011-01-30 17:34:42 +03:00
|
|
|
if (time != -1U
|
|
|
|
&& (user_time == CurrentTime
|
2012-03-14 12:59:41 +04:00
|
|
|
|| timestampCompare(time, user_time) > 0)) { // time > user_time
|
2007-04-29 21:35:43 +04:00
|
|
|
user_time = time;
|
2012-03-14 12:59:41 +04:00
|
|
|
shade_below = NULL; // do not hover re-shade a window after it got interaction
|
|
|
|
}
|
2011-01-30 17:34:42 +03:00
|
|
|
group()->updateUserTime(user_time);
|
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
|
|
|
|
Time Client::readUserCreationTime() const
|
2011-01-30 17:34:42 +03:00
|
|
|
{
|
2007-04-29 21:35:43 +04:00
|
|
|
long result = -1; // Time == -1 means none
|
|
|
|
Atom type;
|
|
|
|
int format, status;
|
|
|
|
unsigned long nitems = 0;
|
|
|
|
unsigned long extra = 0;
|
|
|
|
unsigned char *data = 0;
|
|
|
|
KXErrorHandler handler; // ignore errors?
|
2011-01-30 17:34:42 +03:00
|
|
|
status = XGetWindowProperty(display(), window(),
|
|
|
|
atoms->kde_net_wm_user_creation_time, 0, 10000, false, XA_CARDINAL,
|
|
|
|
&type, &format, &nitems, &extra, &data);
|
|
|
|
if (status == Success) {
|
2007-04-29 21:35:43 +04:00
|
|
|
if (data && nitems > 0)
|
|
|
|
result = *((long*) data);
|
|
|
|
XFree(data);
|
|
|
|
}
|
2011-01-30 17:34:42 +03:00
|
|
|
return result;
|
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2011-01-30 17:34:42 +03:00
|
|
|
void Client::demandAttention(bool set)
|
|
|
|
{
|
|
|
|
if (isActive())
|
2007-04-29 21:35:43 +04:00
|
|
|
set = false;
|
2011-01-30 17:34:42 +03:00
|
|
|
if (demands_attention == set)
|
2007-04-29 21:35:43 +04:00
|
|
|
return;
|
|
|
|
demands_attention = set;
|
2013-04-21 15:03:52 +04:00
|
|
|
info->setState(set ? NET::DemandsAttention : 0, NET::DemandsAttention);
|
2011-01-30 17:34:42 +03:00
|
|
|
workspace()->clientAttentionChanged(this, set);
|
2012-03-09 13:17:19 +04:00
|
|
|
emit demandsAttentionChanged();
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
|
|
|
|
// TODO I probably shouldn't be lazy here and do it without the macro, so that people can read it
|
2011-01-30 17:34:42 +03:00
|
|
|
KWIN_COMPARE_PREDICATE(SameApplicationActiveHackPredicate, Client, const Client*,
|
2011-06-24 14:19:47 +04:00
|
|
|
// ignore already existing splashes, toolbars, utilities and menus,
|
2011-01-30 17:34:42 +03:00
|
|
|
// as the app may show those before the main window
|
2011-06-24 14:19:47 +04:00
|
|
|
!cl->isSplash() && !cl->isToolbar() && !cl->isUtility() && !cl->isMenu()
|
2011-01-30 17:34:42 +03:00
|
|
|
&& Client::belongToSameApplication(cl, value, true) && cl != value);
|
|
|
|
|
|
|
|
Time Client::readUserTimeMapTimestamp(const KStartupInfoId* asn_id, const KStartupInfoData* asn_data,
|
|
|
|
bool session) const
|
|
|
|
{
|
2007-04-29 21:35:43 +04:00
|
|
|
Time time = info->userTime();
|
2011-01-30 17:34:42 +03:00
|
|
|
//kDebug( 1212 ) << "User timestamp, initial:" << time;
|
2010-05-13 22:53:08 +04:00
|
|
|
//^^ this deadlocks kwin --replace sometimes.
|
|
|
|
|
2007-04-29 21:35:43 +04:00
|
|
|
// newer ASN timestamp always replaces user timestamp, unless user timestamp is 0
|
|
|
|
// helps e.g. with konqy reusing
|
2011-01-30 17:34:42 +03:00
|
|
|
if (asn_data != NULL && time != 0) {
|
2007-04-29 21:35:43 +04:00
|
|
|
// prefer timestamp from ASN id (timestamp from data is obsolete way)
|
2011-01-30 17:34:42 +03:00
|
|
|
if (asn_id->timestamp() != 0
|
|
|
|
&& (time == -1U || timestampCompare(asn_id->timestamp(), time) > 0)) {
|
2007-04-29 21:35:43 +04:00
|
|
|
time = asn_id->timestamp();
|
2011-01-30 17:34:42 +03:00
|
|
|
} else if (asn_data->timestamp() != -1U
|
|
|
|
&& (time == -1U || timestampCompare(asn_data->timestamp(), time) > 0)) {
|
2007-04-29 21:35:43 +04:00
|
|
|
time = asn_data->timestamp();
|
|
|
|
}
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
|
|
|
kDebug(1212) << "User timestamp, ASN:" << time;
|
|
|
|
if (time == -1U) {
|
|
|
|
// The window doesn't have any timestamp.
|
|
|
|
// If it's the first window for its application
|
|
|
|
// (i.e. there's no other window from the same app),
|
|
|
|
// use the _KDE_NET_WM_USER_CREATION_TIME trick.
|
|
|
|
// Otherwise, refuse activation of a window
|
|
|
|
// from already running application if this application
|
|
|
|
// is not the active one (unless focus stealing prevention is turned off).
|
2007-04-29 21:35:43 +04:00
|
|
|
Client* act = workspace()->mostRecentlyActivatedClient();
|
2011-01-30 17:34:42 +03:00
|
|
|
if (act != NULL && !belongToSameApplication(act, this, true)) {
|
2007-04-29 21:35:43 +04:00
|
|
|
bool first_window = true;
|
2011-01-30 17:34:42 +03:00
|
|
|
if (isTransient()) {
|
|
|
|
if (act->hasTransient(this, true))
|
2007-04-29 21:35:43 +04:00
|
|
|
; // is transient for currently active window, even though it's not
|
2011-01-30 17:34:42 +03:00
|
|
|
// the same app (e.g. kcookiejar dialog) -> allow activation
|
|
|
|
else if (groupTransient() &&
|
|
|
|
findClientInList(mainClients(), SameApplicationActiveHackPredicate(this)) == NULL)
|
2007-04-29 21:35:43 +04:00
|
|
|
; // standalone transient
|
|
|
|
else
|
|
|
|
first_window = false;
|
2011-01-30 17:34:42 +03:00
|
|
|
} else {
|
|
|
|
if (workspace()->findClient(SameApplicationActiveHackPredicate(this)))
|
2007-04-29 21:35:43 +04:00
|
|
|
first_window = false;
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
// don't refuse if focus stealing prevention is turned off
|
2012-02-20 13:25:13 +04:00
|
|
|
if (!first_window && rules()->checkFSP(options->focusStealingPreventionLevel()) > 0) {
|
2011-01-30 17:34:42 +03:00
|
|
|
kDebug(1212) << "User timestamp, already exists:" << 0;
|
2007-04-29 21:35:43 +04:00
|
|
|
return 0; // refuse activation
|
|
|
|
}
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
// Creation time would just mess things up during session startup,
|
|
|
|
// as possibly many apps are started up at the same time.
|
|
|
|
// If there's no active window yet, no timestamp will be needed,
|
|
|
|
// as plain Workspace::allowClientActivation() will return true
|
|
|
|
// in such case. And if there's already active window,
|
|
|
|
// it's better not to activate the new one.
|
|
|
|
// Unless it was the active window at the time
|
|
|
|
// of session saving and there was no user interaction yet,
|
|
|
|
// this check will be done in manage().
|
2011-01-30 17:34:42 +03:00
|
|
|
if (session)
|
2007-04-29 21:35:43 +04:00
|
|
|
return -1U;
|
2012-03-14 11:03:42 +04:00
|
|
|
time = readUserCreationTime();
|
2007-04-29 21:35:43 +04:00
|
|
|
}
|
2011-01-30 17:34:42 +03:00
|
|
|
kDebug(1212) << "User timestamp, final:" << this << ":" << time;
|
|
|
|
return time;
|
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
|
|
|
|
Time Client::userTime() const
|
2011-01-30 17:34:42 +03:00
|
|
|
{
|
2007-04-29 21:35:43 +04:00
|
|
|
Time time = user_time;
|
2011-01-30 17:34:42 +03:00
|
|
|
if (time == 0) // doesn't want focus after showing
|
2007-04-29 21:35:43 +04:00
|
|
|
return 0;
|
2011-01-30 17:34:42 +03:00
|
|
|
assert(group() != NULL);
|
|
|
|
if (time == -1U
|
|
|
|
|| (group()->userTime() != -1U
|
|
|
|
&& timestampCompare(group()->userTime(), time) > 0))
|
2007-04-29 21:35:43 +04:00
|
|
|
time = group()->userTime();
|
|
|
|
return time;
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
|
|
|
|
/*!
|
|
|
|
Sets the client's active state to \a act.
|
|
|
|
|
|
|
|
This function does only change the visual appearance of the client,
|
|
|
|
it does not change the focus setting. Use
|
|
|
|
Workspace::activateClient() or Workspace::requestFocus() instead.
|
|
|
|
|
|
|
|
If a client receives or looses the focus, it calls setActive() on
|
|
|
|
its own.
|
|
|
|
|
|
|
|
*/
|
2011-01-30 17:34:42 +03:00
|
|
|
void Client::setActive(bool act)
|
|
|
|
{
|
|
|
|
if (active == act)
|
2007-04-29 21:35:43 +04:00
|
|
|
return;
|
|
|
|
active = act;
|
2009-10-03 13:11:05 +04:00
|
|
|
const int ruledOpacity = active
|
2011-01-30 17:34:42 +03:00
|
|
|
? rules()->checkOpacityActive(qRound(opacity() * 100.0))
|
|
|
|
: rules()->checkOpacityInactive(qRound(opacity() * 100.0));
|
|
|
|
setOpacity(ruledOpacity / 100.0);
|
2013-04-26 11:47:45 +04:00
|
|
|
workspace()->setActiveClient(act ? this : NULL);
|
2011-01-30 17:34:42 +03:00
|
|
|
|
|
|
|
if (!active)
|
2007-04-29 21:35:43 +04:00
|
|
|
cancelAutoRaise();
|
|
|
|
|
2011-01-30 17:34:42 +03:00
|
|
|
if (!active && shade_mode == ShadeActivated)
|
|
|
|
setShade(ShadeNormal);
|
|
|
|
|
|
|
|
StackingUpdatesBlocker blocker(workspace());
|
|
|
|
workspace()->updateClientLayer(this); // active windows may get different layer
|
2007-04-29 21:35:43 +04:00
|
|
|
ClientList mainclients = mainClients();
|
2011-01-30 17:34:42 +03:00
|
|
|
for (ClientList::ConstIterator it = mainclients.constBegin();
|
|
|
|
it != mainclients.constEnd();
|
|
|
|
++it)
|
|
|
|
if ((*it)->isFullScreen()) // fullscreens go high even if their transient is active
|
|
|
|
workspace()->updateClientLayer(*it);
|
|
|
|
if (decoration != NULL)
|
2007-04-29 21:35:43 +04:00
|
|
|
decoration->activeChange();
|
2011-12-22 17:39:55 +04:00
|
|
|
emit activeChanged();
|
2007-04-29 21:35:43 +04:00
|
|
|
updateMouseGrab();
|
|
|
|
updateUrgency(); // demand attention again if it's still urgent
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
|
|
|
|
void Client::startupIdChanged()
|
2011-01-30 17:34:42 +03:00
|
|
|
{
|
2007-04-29 21:35:43 +04:00
|
|
|
KStartupInfoId asn_id;
|
|
|
|
KStartupInfoData asn_data;
|
2011-01-30 17:34:42 +03:00
|
|
|
bool asn_valid = workspace()->checkStartupNotification(window(), asn_id, asn_data);
|
|
|
|
if (!asn_valid)
|
2007-04-29 21:35:43 +04:00
|
|
|
return;
|
|
|
|
// If the ASN contains desktop, move it to the desktop, otherwise move it to the current
|
|
|
|
// desktop (since the new ASN should make the window act like if it's a new application
|
|
|
|
// launched). However don't affect the window's desktop if it's set to be on all desktops.
|
2012-11-16 11:23:47 +04:00
|
|
|
int desktop = VirtualDesktopManager::self()->current();
|
2011-01-30 17:34:42 +03:00
|
|
|
if (asn_data.desktop() != 0)
|
2007-04-29 21:35:43 +04:00
|
|
|
desktop = asn_data.desktop();
|
2011-01-30 17:34:42 +03:00
|
|
|
if (!isOnAllDesktops())
|
|
|
|
workspace()->sendClientToDesktop(this, desktop, true);
|
|
|
|
if (asn_data.xinerama() != -1)
|
|
|
|
workspace()->sendClientToScreen(this, asn_data.xinerama());
|
2007-04-29 21:35:43 +04:00
|
|
|
Time timestamp = asn_id.timestamp();
|
2011-01-30 17:34:42 +03:00
|
|
|
if (timestamp == 0 && asn_data.timestamp() != -1U)
|
2007-04-29 21:35:43 +04:00
|
|
|
timestamp = asn_data.timestamp();
|
2011-01-30 17:34:42 +03:00
|
|
|
if (timestamp != 0) {
|
|
|
|
bool activate = workspace()->allowClientActivation(this, timestamp);
|
|
|
|
if (asn_data.desktop() != 0 && !isOnCurrentDesktop())
|
2007-04-29 21:35:43 +04:00
|
|
|
activate = false; // it was started on different desktop than current one
|
2011-01-30 17:34:42 +03:00
|
|
|
if (activate)
|
|
|
|
workspace()->activateClient(this);
|
2007-04-29 21:35:43 +04:00
|
|
|
else
|
|
|
|
demandAttention();
|
|
|
|
}
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
|
|
|
|
void Client::updateUrgency()
|
2011-01-30 17:34:42 +03:00
|
|
|
{
|
|
|
|
if (urgency)
|
2007-04-29 21:35:43 +04:00
|
|
|
demandAttention();
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
|
|
|
|
void Client::shortcutActivated()
|
2011-01-30 17:34:42 +03:00
|
|
|
{
|
2012-11-22 12:12:11 +04:00
|
|
|
workspace()->activateClient(this, true); // force
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
|
|
|
|
//****************************************
|
|
|
|
// Group
|
|
|
|
//****************************************
|
2011-01-30 17:34:42 +03:00
|
|
|
|
2007-04-29 21:35:43 +04:00
|
|
|
void Group::startupIdChanged()
|
2011-01-30 17:34:42 +03:00
|
|
|
{
|
2007-04-29 21:35:43 +04:00
|
|
|
KStartupInfoId asn_id;
|
|
|
|
KStartupInfoData asn_data;
|
2011-01-30 17:34:42 +03:00
|
|
|
bool asn_valid = workspace()->checkStartupNotification(leader_wid, asn_id, asn_data);
|
|
|
|
if (!asn_valid)
|
2007-04-29 21:35:43 +04:00
|
|
|
return;
|
2011-01-30 17:34:42 +03:00
|
|
|
if (asn_id.timestamp() != 0 && user_time != -1U
|
|
|
|
&& timestampCompare(asn_id.timestamp(), user_time) > 0) {
|
2007-04-29 21:35:43 +04:00
|
|
|
user_time = asn_id.timestamp();
|
2011-01-30 17:34:42 +03:00
|
|
|
} else if (asn_data.timestamp() != -1U && user_time != -1U
|
|
|
|
&& timestampCompare(asn_data.timestamp(), user_time) > 0) {
|
2007-04-29 21:35:43 +04:00
|
|
|
user_time = asn_data.timestamp();
|
|
|
|
}
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
|
2011-01-30 17:34:42 +03:00
|
|
|
void Group::updateUserTime(Time time)
|
|
|
|
{
|
|
|
|
// copy of Client::updateUserTime
|
|
|
|
if (time == CurrentTime)
|
2007-04-29 21:35:43 +04:00
|
|
|
time = xTime();
|
2011-01-30 17:34:42 +03:00
|
|
|
if (time != -1U
|
|
|
|
&& (user_time == CurrentTime
|
|
|
|
|| timestampCompare(time, user_time) > 0)) // time > user_time
|
2007-04-29 21:35:43 +04:00
|
|
|
user_time = time;
|
2011-01-30 17:34:42 +03:00
|
|
|
}
|
2007-04-29 21:35:43 +04:00
|
|
|
|
|
|
|
} // namespace
|