yukijoou/kwin
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
kwin/src/focuschain.cpp

265 lines
7.5 KiB
C++
Raw Normal View History

Prettify license headers
2020-08-02 22:22:19 +00:00
/*
KWin - the KDE window manager
This file is part of the KDE project.
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
Prettify license headers
2020-08-02 22:22:19 +00:00
SPDX-FileCopyrightText: 2012 Martin Gräßlin <mgraesslin@kde.org>
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
Prettify license headers
2020-08-02 22:22:19 +00:00
SPDX-License-Identifier: GPL-2.0-or-later
*/
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
#include "focuschain.h"
FocusChain operates on AbstractClient instead of Client As external interface it still returns Client* to not force the casts to be done at usages. This will be changed once the users are migrated to AbstractClient*.
2015-03-05 09:24:54 +00:00
#include "abstract_client.h"
Move active output tracking to workspace Active output is a window management concept. It indicates what output new windows have to be placed on if they have no output hint. So Workspace seems to be a better place for it than the Screens class, which is obsolete.
2021-08-28 18:58:29 +00:00
#include "workspace.h"
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
namespace KWin
{
Defines to create the boilerplate code for KWin's singleton classes The define KWIN_SINGLETON adds to a class definition: public: static Foo *create(QObject *parent = 0); static Foo *self() { return s_self; } protected: explicit Foo(QObject *parent = 0); private: static Foo *s_self; There is an additional define KWIN_SINGLETON_VARIABLE to set a different name than s_self. The define KWIN_SINGLETON_FACTORY can be used to generate the create method. It expands to: Foo *Foo::s_self = 0; Foo *Foo::create(QObject *parent) { Q_ASSERT(!s_self); s_self = new Foo(parent); return s_self; } In addition there are defines to again set a different variable name and to create an object of another inheriting class. All the classes currently using this pattern are adjusted to use these new defines. In a few places the name was adjusted. E.g. in Compositor the factory method was called createCompositor instead of create. REVIEW: 109865
2013-04-05 07:41:25 +00:00
KWIN_SINGLETON_FACTORY_VARIABLE(FocusChain, s_manager)
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
FocusChain::FocusChain(QObject *parent)
: QObject(parent)
, m_separateScreenFocus(false)
Use nullptr everywhere Summary: Because KWin is a very old project, we use three kinds of null pointer literals: 0, NULL, and nullptr. Since C++11, it's recommended to use nullptr keyword. This change converts all usages of 0 and NULL literal to nullptr. Even though it breaks git history, we need to do it in order to have consistent code as well to ease code reviews (it's very tempting for some people to add unrelated changes to their patches, e.g. converting NULL to nullptr). Test Plan: Compiles. Reviewers: #kwin, davidedmundson, romangg Reviewed By: #kwin, davidedmundson, romangg Subscribers: romangg, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
, m_activeClient(nullptr)
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
{
}
FocusChain::~FocusChain()
{
Use nullptr everywhere Summary: Because KWin is a very old project, we use three kinds of null pointer literals: 0, NULL, and nullptr. Since C++11, it's recommended to use nullptr keyword. This change converts all usages of 0 and NULL literal to nullptr. Even though it breaks git history, we need to do it in order to have consistent code as well to ease code reviews (it's very tempting for some people to add unrelated changes to their patches, e.g. converting NULL to nullptr). Test Plan: Compiles. Reviewers: #kwin, davidedmundson, romangg Reviewed By: #kwin, davidedmundson, romangg Subscribers: romangg, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
s_manager = nullptr;
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
}
FocusChain operates on AbstractClient instead of Client As external interface it still returns Client* to not force the casts to be done at usages. This will be changed once the users are migrated to AbstractClient*.
2015-03-05 09:24:54 +00:00
void FocusChain::remove(AbstractClient *client)
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
{
Use explicit Chain type in the focus chain Summary: The explicit Chain type makes code more cleaner. Test Plan: Still compiles. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D14431
2018-07-27 19:43:09 +00:00
for (auto it = m_desktopFocusChains.begin();
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
it != m_desktopFocusChains.end();
++it) {
it.value().removeAll(client);
}
m_mostRecentlyUsed.removeAll(client);
}
Port FocusChain to VirtualDesktop
2021-08-16 12:07:43 +00:00
void FocusChain::addDesktop(VirtualDesktop *desktop)
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
{
Port FocusChain to VirtualDesktop
2021-08-16 12:07:43 +00:00
m_desktopFocusChains.insert(desktop, Chain());
}
void FocusChain::removeDesktop(VirtualDesktop *desktop)
{
if (m_currentDesktop == desktop) {
m_currentDesktop = nullptr;
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
}
Port FocusChain to VirtualDesktop
2021-08-16 12:07:43 +00:00
m_desktopFocusChains.remove(desktop);
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
}
Port FocusChain to VirtualDesktop
2021-08-16 12:07:43 +00:00
AbstractClient *FocusChain::getForActivation(VirtualDesktop *desktop) const
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
{
Move active output tracking to workspace Active output is a window management concept. It indicates what output new windows have to be placed on if they have no output hint. So Workspace seems to be a better place for it than the Screens class, which is obsolete.
2021-08-28 18:58:29 +00:00
return getForActivation(desktop, workspace()->activeOutput());
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
}
Port FocusChain to AbstractOutput
2021-08-28 14:48:12 +00:00
AbstractClient *FocusChain::getForActivation(VirtualDesktop *desktop, AbstractOutput *output) const
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
{
Use explicit Chain type in the focus chain Summary: The explicit Chain type makes code more cleaner. Test Plan: Still compiles. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D14431
2018-07-27 19:43:09 +00:00
auto it = m_desktopFocusChains.constFind(desktop);
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
if (it == m_desktopFocusChains.constEnd()) {
Use nullptr everywhere Summary: Because KWin is a very old project, we use three kinds of null pointer literals: 0, NULL, and nullptr. Since C++11, it's recommended to use nullptr keyword. This change converts all usages of 0 and NULL literal to nullptr. Even though it breaks git history, we need to do it in order to have consistent code as well to ease code reviews (it's very tempting for some people to add unrelated changes to their patches, e.g. converting NULL to nullptr). Test Plan: Compiles. Reviewers: #kwin, davidedmundson, romangg Reviewed By: #kwin, davidedmundson, romangg Subscribers: romangg, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
return nullptr;
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
}
FocusChain operates on AbstractClient instead of Client As external interface it still returns Client* to not force the casts to be done at usages. This will be changed once the users are migrated to AbstractClient*.
2015-03-05 09:24:54 +00:00
const auto &chain = it.value();
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
for (int i = chain.size() - 1; i >= 0; --i) {
FocusChain operates on AbstractClient instead of Client As external interface it still returns Client* to not force the casts to be done at usages. This will be changed once the users are migrated to AbstractClient*.
2015-03-05 09:24:54 +00:00
auto tmp = chain.at(i);
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
// TODO: move the check into Client
Remove boolean trap in AbstractClient::isShown() Check shaded state where needed.
2021-11-23 12:13:56 +00:00
if (!tmp->isShade() && tmp->isShown() && tmp->isOnCurrentActivity()
Port FocusChain to AbstractOutput
2021-08-28 14:48:12 +00:00
&& ( !m_separateScreenFocus || tmp->output() == output)) {
Remove remaining Client usage from FocusChain
2015-03-12 12:43:39 +00:00
return tmp;
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
}
}
Use nullptr everywhere Summary: Because KWin is a very old project, we use three kinds of null pointer literals: 0, NULL, and nullptr. Since C++11, it's recommended to use nullptr keyword. This change converts all usages of 0 and NULL literal to nullptr. Even though it breaks git history, we need to do it in order to have consistent code as well to ease code reviews (it's very tempting for some people to add unrelated changes to their patches, e.g. converting NULL to nullptr). Test Plan: Compiles. Reviewers: #kwin, davidedmundson, romangg Reviewed By: #kwin, davidedmundson, romangg Subscribers: romangg, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
return nullptr;
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
}
FocusChain operates on AbstractClient instead of Client As external interface it still returns Client* to not force the casts to be done at usages. This will be changed once the users are migrated to AbstractClient*.
2015-03-05 09:24:54 +00:00
void FocusChain::update(AbstractClient *client, FocusChain::Change change)
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
{
if (!client->wantsTabFocus()) {
// Doesn't want tab focus, remove
remove(client);
return;
}
if (client->isOnAllDesktops()) {
// Now on all desktops, add it to focus chains it is not already in
Use explicit Chain type in the focus chain Summary: The explicit Chain type makes code more cleaner. Test Plan: Still compiles. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D14431
2018-07-27 19:43:09 +00:00
for (auto it = m_desktopFocusChains.begin();
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
it != m_desktopFocusChains.end();
++it) {
FocusChain operates on AbstractClient instead of Client As external interface it still returns Client* to not force the casts to be done at usages. This will be changed once the users are migrated to AbstractClient*.
2015-03-05 09:24:54 +00:00
auto &chain = it.value();
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
// Making first/last works only on current desktop, don't affect all desktops
if (it.key() == m_currentDesktop
&& (change == MakeFirst || change == MakeLast)) {
if (change == MakeFirst) {
makeFirstInChain(client, chain);
} else {
makeLastInChain(client, chain);
}
} else {
insertClientIntoChain(client, chain);
}
}
} else {
// Now only on desktop, remove it anywhere else
Use explicit Chain type in the focus chain Summary: The explicit Chain type makes code more cleaner. Test Plan: Still compiles. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D14431
2018-07-27 19:43:09 +00:00
for (auto it = m_desktopFocusChains.begin();
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
it != m_desktopFocusChains.end();
++it) {
FocusChain operates on AbstractClient instead of Client As external interface it still returns Client* to not force the casts to be done at usages. This will be changed once the users are migrated to AbstractClient*.
2015-03-05 09:24:54 +00:00
auto &chain = it.value();
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
if (client->isOnDesktop(it.key())) {
updateClientInChain(client, change, chain);
} else {
chain.removeAll(client);
}
}
}
// add for most recently used chain
updateClientInChain(client, change, m_mostRecentlyUsed);
}
Use explicit Chain type in the focus chain Summary: The explicit Chain type makes code more cleaner. Test Plan: Still compiles. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D14431
2018-07-27 19:43:09 +00:00
void FocusChain::updateClientInChain(AbstractClient *client, FocusChain::Change change, Chain &chain)
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
{
if (change == MakeFirst) {
makeFirstInChain(client, chain);
} else if (change == MakeLast) {
makeLastInChain(client, chain);
} else {
insertClientIntoChain(client, chain);
}
}
Use explicit Chain type in the focus chain Summary: The explicit Chain type makes code more cleaner. Test Plan: Still compiles. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D14431
2018-07-27 19:43:09 +00:00
void FocusChain::insertClientIntoChain(AbstractClient *client, Chain &chain)
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
{
if (chain.contains(client)) {
return;
}
if (m_activeClient && m_activeClient != client &&
Don't crash if the focus chain is empty() CCMAIL: kwin@kde.org
2013-03-02 11:10:56 +00:00
!chain.empty() && chain.last() == m_activeClient) {
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
// Add it after the active client
chain.insert(chain.size() - 1, client);
} else {
// Otherwise add as the first one
chain.append(client);
}
}
FocusChain operates on AbstractClient instead of Client As external interface it still returns Client* to not force the casts to be done at usages. This will be changed once the users are migrated to AbstractClient*.
2015-03-05 09:24:54 +00:00
void FocusChain::moveAfterClient(AbstractClient *client, AbstractClient *reference)
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
{
if (!client->wantsTabFocus()) {
return;
}
Use explicit Chain type in the focus chain Summary: The explicit Chain type makes code more cleaner. Test Plan: Still compiles. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D14431
2018-07-27 19:43:09 +00:00
for (auto it = m_desktopFocusChains.begin();
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
it != m_desktopFocusChains.end();
++it) {
if (!client->isOnDesktop(it.key())) {
continue;
}
moveAfterClientInChain(client, reference, it.value());
}
moveAfterClientInChain(client, reference, m_mostRecentlyUsed);
}
Use explicit Chain type in the focus chain Summary: The explicit Chain type makes code more cleaner. Test Plan: Still compiles. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D14431
2018-07-27 19:43:09 +00:00
void FocusChain::moveAfterClientInChain(AbstractClient *client, AbstractClient *reference, Chain &chain)
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
{
if (!chain.contains(reference)) {
return;
}
FocusChain operates on AbstractClient instead of Client As external interface it still returns Client* to not force the casts to be done at usages. This will be changed once the users are migrated to AbstractClient*.
2015-03-05 09:24:54 +00:00
if (AbstractClient::belongToSameApplication(reference, client)) {
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
chain.removeAll(client);
chain.insert(chain.indexOf(reference), client);
} else {
chain.removeAll(client);
for (int i = chain.size() - 1; i >= 0; --i) {
FocusChain operates on AbstractClient instead of Client As external interface it still returns Client* to not force the casts to be done at usages. This will be changed once the users are migrated to AbstractClient*.
2015-03-05 09:24:54 +00:00
if (AbstractClient::belongToSameApplication(reference, chain.at(i))) {
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
chain.insert(i, client);
break;
}
}
}
}
FocusChain operates on AbstractClient instead of Client As external interface it still returns Client* to not force the casts to be done at usages. This will be changed once the users are migrated to AbstractClient*.
2015-03-05 09:24:54 +00:00
AbstractClient *FocusChain::firstMostRecentlyUsed() const
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
{
if (m_mostRecentlyUsed.isEmpty()) {
Use nullptr everywhere Summary: Because KWin is a very old project, we use three kinds of null pointer literals: 0, NULL, and nullptr. Since C++11, it's recommended to use nullptr keyword. This change converts all usages of 0 and NULL literal to nullptr. Even though it breaks git history, we need to do it in order to have consistent code as well to ease code reviews (it's very tempting for some people to add unrelated changes to their patches, e.g. converting NULL to nullptr). Test Plan: Compiles. Reviewers: #kwin, davidedmundson, romangg Reviewed By: #kwin, davidedmundson, romangg Subscribers: romangg, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
return nullptr;
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
}
return m_mostRecentlyUsed.first();
}
FocusChain operates on AbstractClient instead of Client As external interface it still returns Client* to not force the casts to be done at usages. This will be changed once the users are migrated to AbstractClient*.
2015-03-05 09:24:54 +00:00
AbstractClient *FocusChain::nextMostRecentlyUsed(AbstractClient *reference) const
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
{
if (m_mostRecentlyUsed.isEmpty()) {
Use nullptr everywhere Summary: Because KWin is a very old project, we use three kinds of null pointer literals: 0, NULL, and nullptr. Since C++11, it's recommended to use nullptr keyword. This change converts all usages of 0 and NULL literal to nullptr. Even though it breaks git history, we need to do it in order to have consistent code as well to ease code reviews (it's very tempting for some people to add unrelated changes to their patches, e.g. converting NULL to nullptr). Test Plan: Compiles. Reviewers: #kwin, davidedmundson, romangg Reviewed By: #kwin, davidedmundson, romangg Subscribers: romangg, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
return nullptr;
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
}
const int index = m_mostRecentlyUsed.indexOf(reference);
step into the focus chain at the beginning if the index is 0, we close the circle, but if the index is -1 (invalid) we're "somewhere" and step into the focus chain - reasonably at the beginning BUG: 340594 REVIEW: 121024
2014-11-06 21:58:53 +00:00
if (index == -1) {
return m_mostRecentlyUsed.first();
}
if (index == 0) {
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
return m_mostRecentlyUsed.last();
}
return m_mostRecentlyUsed.at(index - 1);
}
// copied from activation.cpp
FocusChain operates on AbstractClient instead of Client As external interface it still returns Client* to not force the casts to be done at usages. This will be changed once the users are migrated to AbstractClient*.
2015-03-05 09:24:54 +00:00
bool FocusChain::isUsableFocusCandidate(AbstractClient *c, AbstractClient *prev) const
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
{
return c != prev &&
Remove boolean trap in AbstractClient::isShown() Check shaded state where needed.
2021-11-23 12:13:56 +00:00
!c->isShade() && c->isShown() && c->isOnCurrentDesktop() && c->isOnCurrentActivity() &&
Move active output tracking to workspace Active output is a window management concept. It indicates what output new windows have to be placed on if they have no output hint. So Workspace seems to be a better place for it than the Screens class, which is obsolete.
2021-08-28 18:58:29 +00:00
(!m_separateScreenFocus || c->isOnOutput(prev ? prev->output() : workspace()->activeOutput()));
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
}
Port FocusChain to VirtualDesktop
2021-08-16 12:07:43 +00:00
AbstractClient *FocusChain::nextForDesktop(AbstractClient *reference, VirtualDesktop *desktop) const
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
{
Use explicit Chain type in the focus chain Summary: The explicit Chain type makes code more cleaner. Test Plan: Still compiles. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D14431
2018-07-27 19:43:09 +00:00
auto it = m_desktopFocusChains.constFind(desktop);
if (it == m_desktopFocusChains.constEnd()) {
Use nullptr everywhere Summary: Because KWin is a very old project, we use three kinds of null pointer literals: 0, NULL, and nullptr. Since C++11, it's recommended to use nullptr keyword. This change converts all usages of 0 and NULL literal to nullptr. Even though it breaks git history, we need to do it in order to have consistent code as well to ease code reviews (it's very tempting for some people to add unrelated changes to their patches, e.g. converting NULL to nullptr). Test Plan: Compiles. Reviewers: #kwin, davidedmundson, romangg Reviewed By: #kwin, davidedmundson, romangg Subscribers: romangg, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
return nullptr;
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
}
FocusChain operates on AbstractClient instead of Client As external interface it still returns Client* to not force the casts to be done at usages. This will be changed once the users are migrated to AbstractClient*.
2015-03-05 09:24:54 +00:00
const auto &chain = it.value();
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
for (int i = chain.size() - 1; i >= 0; --i) {
FocusChain operates on AbstractClient instead of Client As external interface it still returns Client* to not force the casts to be done at usages. This will be changed once the users are migrated to AbstractClient*.
2015-03-05 09:24:54 +00:00
auto client = chain.at(i);
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
if (isUsableFocusCandidate(client, reference)) {
Remove remaining Client usage from FocusChain
2015-03-12 12:43:39 +00:00
return client;
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
}
}
Use nullptr everywhere Summary: Because KWin is a very old project, we use three kinds of null pointer literals: 0, NULL, and nullptr. Since C++11, it's recommended to use nullptr keyword. This change converts all usages of 0 and NULL literal to nullptr. Even though it breaks git history, we need to do it in order to have consistent code as well to ease code reviews (it's very tempting for some people to add unrelated changes to their patches, e.g. converting NULL to nullptr). Test Plan: Compiles. Reviewers: #kwin, davidedmundson, romangg Reviewed By: #kwin, davidedmundson, romangg Subscribers: romangg, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
return nullptr;
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
}
Use explicit Chain type in the focus chain Summary: The explicit Chain type makes code more cleaner. Test Plan: Still compiles. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D14431
2018-07-27 19:43:09 +00:00
void FocusChain::makeFirstInChain(AbstractClient *client, Chain &chain)
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
{
chain.removeAll(client);
[focuschain/task switcher] Add hidden option to govern repositioning minimized windows Since some people apparently liked the old behavior of moving minimized windows to the end of the focus chain, let's let them have it if they set a hidden config option: `MoveMinimizedWindowsToEndOfTabBoxFocusChain=true` in the `[TabBox]` group of the kwinrc file. We can add a UI for it later if needed. BUG: 427840 FIXED-IN: 5.21
2020-10-20 20:15:46 +00:00
if (options->moveMinimizedWindowsToEndOfTabBoxFocusChain()) {
if (client->isMinimized()) { // add it before the first minimized ...
for (int i = chain.count()-1; i >= 0; --i) {
if (chain.at(i)->isMinimized()) {
chain.insert(i+1, client);
return;
}
Revert "[focuschain/task switcher] Remove special handling for minimized windows" This reverts commit cc862fa674d3407f516a89b8543acea04aa8b37d. It turns out that some people like this behavior and we've received various user complaints about it.
2020-10-20 20:05:33 +00:00
}
[focuschain/task switcher] Add hidden option to govern repositioning minimized windows Since some people apparently liked the old behavior of moving minimized windows to the end of the focus chain, let's let them have it if they set a hidden config option: `MoveMinimizedWindowsToEndOfTabBoxFocusChain=true` in the `[TabBox]` group of the kwinrc file. We can add a UI for it later if needed. BUG: 427840 FIXED-IN: 5.21
2020-10-20 20:15:46 +00:00
chain.prepend(client); // ... or at end of chain
} else {
chain.append(client);
Revert "[focuschain/task switcher] Remove special handling for minimized windows" This reverts commit cc862fa674d3407f516a89b8543acea04aa8b37d. It turns out that some people like this behavior and we've received various user complaints about it.
2020-10-20 20:05:33 +00:00
}
} else {
chain.append(client);
}
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
}
Use explicit Chain type in the focus chain Summary: The explicit Chain type makes code more cleaner. Test Plan: Still compiles. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D14431
2018-07-27 19:43:09 +00:00
void FocusChain::makeLastInChain(AbstractClient *client, Chain &chain)
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
{
chain.removeAll(client);
chain.prepend(client);
}
Port FocusChain to VirtualDesktop
2021-08-16 12:07:43 +00:00
bool FocusChain::contains(AbstractClient *client, VirtualDesktop *desktop) const
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
{
Use explicit Chain type in the focus chain Summary: The explicit Chain type makes code more cleaner. Test Plan: Still compiles. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D14431
2018-07-27 19:43:09 +00:00
auto it = m_desktopFocusChains.constFind(desktop);
if (it == m_desktopFocusChains.constEnd()) {
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 16:26:50 +00:00
return false;
}
return it.value().contains(client);
}
} // namespace
Reference in a new issue Copy permalink