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

262 lines
7.2 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"
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
#include "window.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)
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
, m_activeWindow(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
}
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
void FocusChain::remove(Window *window)
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();
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
it != m_desktopFocusChains.end();
++it) {
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
it.value().removeAll(window);
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
}
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
m_mostRecentlyUsed.removeAll(window);
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
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
}
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
Window *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
}
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
Window *FocusChain::getForActivation(VirtualDesktop *desktop, Output *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);
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
// TODO: move the check into Window
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()
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +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
}
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
void FocusChain::update(Window *window, 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
{
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
if (!window->wantsTabFocus()) {
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
// Doesn't want tab focus, remove
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
remove(window);
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;
}
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
if (window->isOnAllDesktops()) {
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
// 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();
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +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
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
&& (change == MakeFirst || change == MakeLast)) {
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) {
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
makeFirstInChain(window, 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
} else {
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
makeLastInChain(window, 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
}
} else {
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
insertWindowIntoChain(window, 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
}
}
} 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();
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +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();
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
if (window->isOnDesktop(it.key())) {
updateWindowInChain(window, change, 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
} else {
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
chain.removeAll(window);
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 for most recently used chain
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
updateWindowInChain(window, change, m_mostRecentlyUsed);
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
}
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
void FocusChain::updateWindowInChain(Window *window, 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) {
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
makeFirstInChain(window, 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
} else if (change == MakeLast) {
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
makeLastInChain(window, 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
} else {
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
insertWindowIntoChain(window, 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
}
}
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
void FocusChain::insertWindowIntoChain(Window *window, 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
{
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
if (chain.contains(window)) {
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;
}
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
if (m_activeWindow && m_activeWindow != window && !chain.empty() && chain.last() == m_activeWindow) {
// Add it after the active window
chain.insert(chain.size() - 1, window);
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
} else {
// Otherwise add as the first one
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
chain.append(window);
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
}
}
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
void FocusChain::moveAfterWindow(Window *window, Window *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
{
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
if (!window->wantsTabFocus()) {
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;
}
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();
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
it != m_desktopFocusChains.end();
++it) {
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
if (!window->isOnDesktop(it.key())) {
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
continue;
}
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
moveAfterWindowInChain(window, reference, 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
}
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
moveAfterWindowInChain(window, reference, m_mostRecentlyUsed);
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
}
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
void FocusChain::moveAfterWindowInChain(Window *window, Window *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;
}
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
if (Window::belongToSameApplication(reference, window)) {
chain.removeAll(window);
chain.insert(chain.indexOf(reference), window);
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
} else {
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
chain.removeAll(window);
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) {
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
if (Window::belongToSameApplication(reference, chain.at(i))) {
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
chain.insert(i, window);
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
break;
}
}
}
}
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
Window *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();
}
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
Window *FocusChain::nextMostRecentlyUsed(Window *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
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
bool FocusChain::isUsableFocusCandidate(Window *c, Window *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
{
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
return c != prev && !c->isShade() && c->isShown() && c->isOnCurrentDesktop() && c->isOnCurrentActivity() && (!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
}
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
Window *FocusChain::nextForDesktop(Window *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) {
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
auto window = chain.at(i);
if (isUsableFocusCandidate(window, reference)) {
return window;
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
}
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
void FocusChain::makeFirstInChain(Window *window, 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
{
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
chain.removeAll(window);
[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()) {
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
if (window->isMinimized()) { // add it before the first minimized ...
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
for (int i = chain.count() - 1; i >= 0; --i) {
[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 (chain.at(i)->isMinimized()) {
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
chain.insert(i + 1, window);
[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
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
}
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
chain.prepend(window); // ... or at end of chain
[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
} else {
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
chain.append(window);
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 {
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
chain.append(window);
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
}
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
}
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
void FocusChain::makeLastInChain(Window *window, 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
{
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
chain.removeAll(window);
chain.prepend(window);
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
}
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
bool FocusChain::contains(Window *window, 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;
}
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
return it.value().contains(window);
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
Reference in a new issue Copy permalink