vitalif
/
kwin
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
kwin/focuschain.h

243 lines
9.5 KiB
C
Raw Normal View History

Prettify license headers
2020-08-03 01:22:19 +03: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 20:26:50 +04:00
Prettify license headers
2020-08-03 01:22:19 +03: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 20:26:50 +04:00
Prettify license headers
2020-08-03 01:22:19 +03: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 20:26:50 +04:00
#ifndef KWIN_FOCUS_CHAIN_H
#define KWIN_FOCUS_CHAIN_H
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 11:41:25 +04:00
// KWin
#include <kwinglobals.h>
// Qt
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 20:26:50 +04:00
#include <QObject>
#include <QHash>
namespace KWin
{
// forward declarations
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 12:24:54 +03:00
class AbstractClient;
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 20:26:50 +04:00
/**
* @brief Singleton class to handle the various focus chains.
*
* A focus chain is a list of Clients containing information on which Client should be activated.
*
* Internally this FocusChain holds multiple independent chains. There is one chain of most recently
* used Clients which is primarily used by TabBox to build up the list of Clients for navigation.
* The chains are organized as a normal QList of Clients with the most recently used Client being the
* last item of the list, that is a LIFO like structure.
*
* In addition there is one chain for each virtual desktop which is used to determine which Client
* should get activated when the user switches to another virtual desktop.
*
* Furthermore this class contains various helper methods for the two different kind of chains.
Use more traditional doxygen style Summary: So far we were following a bit unique and rare doxygen comment style: /** * Contents of the comment. **/ Doxygen comments with this style look balanced and neat, but many people that contribute to KWin don't follow this style. Instead, they prefer more traditional doxygen comment style, i.e. /** * Contents of the comment. */ Reviewing such changes has been a bit frustrating for me (so selfish!) and for other contributors. This change switches doxygen comment style in KWin to a more traditional style. The main reason for doing this is to make code review process easier for new contributors as well us. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D22812
2019-07-29 21:58:33 +03: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 20:26:50 +04:00
class FocusChain : public QObject
{
Q_OBJECT
public:
enum Change {
MakeFirst,
MakeLast,
[focuschain/task switcher] Remove special handling for minimized windows Right now KWin moves minimized windows to the end of the task switcher's ordering. However this is a rather confusing and undocumented behavior that explicitly overrides the user's chosen sort ordering, be it "Recently used" or "Stacking order". This makes it a hidden magic behavior of the type that is at risk of being more annoying than useful. This commit removes the special handling and lets minimized windows live in the appropriate order in the task switcher.
2020-08-02 04:55:56 +03:00
Update
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 20:26:50 +04:00
};
Run clang-tidy with modernize-use-override check Summary: Currently code base of kwin can be viewed as two pieces. One is very ancient, and the other one is more modern, which uses new C++ features. The main problem with the ancient code is that it was written before C++11 era. So, no override or final keywords, lambdas, etc. Quite recently, KDE compiler settings were changed to show a warning if a virtual method has missing override keyword. As you might have already guessed, this fired back at us because of that ancient code. We had about 500 new compiler warnings. A "solution" was proposed to that problem - disable -Wno-suggest-override and the other similar warning for clang. It's hard to call a solution because those warnings are disabled not only for the old code, but also for new. This is not what we want! The main argument for not actually fixing the problem was that git history will be screwed as well because of human factor. While good git history is a very important thing, we should not go crazy about it and block every change that somehow alters git history. git blame allows to specify starting revision for a reason. The other argument (human factor) can be easily solved by using tools such as clang-tidy. clang-tidy is a clang-based linter for C++. It can be used for various things, e.g. fixing coding style(e.g. add missing braces to if statements, readability-braces-around-statements check), or in our case add missing override keywords. Test Plan: Compiles. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: davidedmundson, apol, romangg, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D22371
2019-07-22 19:52:26 +03:00
~FocusChain() override;
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 20:26:50 +04:00
/**
* @brief Updates the position of the @p client according to the requested @p change in the
* focus chain.
*
* This method affects both the most recently used focus chain and the per virtual desktop focus
* chain.
*
* In case the client does no longer want to get focus, it is removed from all chains. In case
* the client is on all virtual desktops it is ensured that it is present in each of the virtual
* desktops focus chain. In case it's on exactly one virtual desktop it is ensured that it is only
* in the focus chain for that virtual desktop.
*
* Depending on @p change the Client is inserted at different positions in the focus chain. In case
* of @c MakeFirst it is moved to the first position of the chain, in case of
* @c MakeLast it is moved to the last position of the chain. In all other cases it
* depends on whether the @p client is the currently active Client. If it is the active Client it
* becomes the first Client in the chain, otherwise it is inserted at the second position that is
* directly after the currently active Client.
*
* @param client The Client which should be moved inside the chains.
* @param change Where to move the Client
* @return void
Use more traditional doxygen style Summary: So far we were following a bit unique and rare doxygen comment style: /** * Contents of the comment. **/ Doxygen comments with this style look balanced and neat, but many people that contribute to KWin don't follow this style. Instead, they prefer more traditional doxygen comment style, i.e. /** * Contents of the comment. */ Reviewing such changes has been a bit frustrating for me (so selfish!) and for other contributors. This change switches doxygen comment style in KWin to a more traditional style. The main reason for doing this is to make code review process easier for new contributors as well us. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D22812
2019-07-29 21:58:33 +03: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 12:24:54 +03:00
void update(AbstractClient *client, 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 20:26:50 +04:00
/**
* @brief Moves @p client behind the @p reference Client in all focus chains.
*
* @param client The Client to move in the chains
* @param reference The Client behind which the @p client should be moved
* @return void
Use more traditional doxygen style Summary: So far we were following a bit unique and rare doxygen comment style: /** * Contents of the comment. **/ Doxygen comments with this style look balanced and neat, but many people that contribute to KWin don't follow this style. Instead, they prefer more traditional doxygen comment style, i.e. /** * Contents of the comment. */ Reviewing such changes has been a bit frustrating for me (so selfish!) and for other contributors. This change switches doxygen comment style in KWin to a more traditional style. The main reason for doing this is to make code review process easier for new contributors as well us. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D22812
2019-07-29 21:58:33 +03: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 12:24:54 +03:00
void moveAfterClient(AbstractClient *client, AbstractClient *reference);
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 20:26:50 +04:00
/**
* @brief Finds the best Client to become the new active Client in the focus chain for the given
* virtual @p desktop.
*
* In case that separate screen focus is used only Clients on the current screen are considered.
* If no Client for activation is found @c null is returned.
*
* @param desktop The virtual desktop to look for a Client for activation
Rename Client to X11Client Summary: Currently each managed X11 client is represented with an instance of Client class, however the name of that class is very generic and the only reason why it's called that way is because historically kwin was created as an x11 window manager, so "Client" was a sensible choice. With introduction of wayland support, things had changed and therefore Client needs to be renamed to X11Client in order to better reflect what that class stands for. Renaming of Client to X11Client was agreed upon during the last KWin sprint. Test Plan: Compiles, the test suite is still green. Reviewers: #kwin, romangg Reviewed By: #kwin, romangg Subscribers: romangg, davidedmundson, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D24184
2019-09-24 11:48:08 +03:00
* @return :X11Client *The Client which could be activated or @c null if there is none.
Use more traditional doxygen style Summary: So far we were following a bit unique and rare doxygen comment style: /** * Contents of the comment. **/ Doxygen comments with this style look balanced and neat, but many people that contribute to KWin don't follow this style. Instead, they prefer more traditional doxygen comment style, i.e. /** * Contents of the comment. */ Reviewing such changes has been a bit frustrating for me (so selfish!) and for other contributors. This change switches doxygen comment style in KWin to a more traditional style. The main reason for doing this is to make code review process easier for new contributors as well us. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D22812
2019-07-29 21:58:33 +03:00
*/
Remove remaining Client usage from FocusChain
2015-03-12 15:43:39 +03:00
AbstractClient *getForActivation(uint 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 20:26:50 +04:00
/**
* @brief Finds the best Client to become the new active Client in the focus chain for the given
* virtual @p desktop on the given @p screen.
*
* This method makes only sense to use if separate screen focus is used. If separate screen focus
* is disabled the @p screen is ignored.
* If no Client for activation is found @c null is returned.
*
* @param desktop The virtual desktop to look for a Client for activation
* @param screen The screen to constrain the search on with separate screen focus
Rename Client to X11Client Summary: Currently each managed X11 client is represented with an instance of Client class, however the name of that class is very generic and the only reason why it's called that way is because historically kwin was created as an x11 window manager, so "Client" was a sensible choice. With introduction of wayland support, things had changed and therefore Client needs to be renamed to X11Client in order to better reflect what that class stands for. Renaming of Client to X11Client was agreed upon during the last KWin sprint. Test Plan: Compiles, the test suite is still green. Reviewers: #kwin, romangg Reviewed By: #kwin, romangg Subscribers: romangg, davidedmundson, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D24184
2019-09-24 11:48:08 +03:00
* @return :X11Client *The Client which could be activated or @c null if there is none.
Use more traditional doxygen style Summary: So far we were following a bit unique and rare doxygen comment style: /** * Contents of the comment. **/ Doxygen comments with this style look balanced and neat, but many people that contribute to KWin don't follow this style. Instead, they prefer more traditional doxygen comment style, i.e. /** * Contents of the comment. */ Reviewing such changes has been a bit frustrating for me (so selfish!) and for other contributors. This change switches doxygen comment style in KWin to a more traditional style. The main reason for doing this is to make code review process easier for new contributors as well us. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D22812
2019-07-29 21:58:33 +03:00
*/
Remove remaining Client usage from FocusChain
2015-03-12 15:43:39 +03:00
AbstractClient *getForActivation(uint desktop, int screen) 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 20:26:50 +04:00
/**
* @brief Checks whether the most recently used focus chain contains the given @p client.
*
* Does not consider the per-desktop focus chains.
* @param client The Client to look for.
* @return bool @c true if the most recently used focus chain contains @p client, @c false otherwise.
Use more traditional doxygen style Summary: So far we were following a bit unique and rare doxygen comment style: /** * Contents of the comment. **/ Doxygen comments with this style look balanced and neat, but many people that contribute to KWin don't follow this style. Instead, they prefer more traditional doxygen comment style, i.e. /** * Contents of the comment. */ Reviewing such changes has been a bit frustrating for me (so selfish!) and for other contributors. This change switches doxygen comment style in KWin to a more traditional style. The main reason for doing this is to make code review process easier for new contributors as well us. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D22812
2019-07-29 21:58:33 +03: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 12:24:54 +03:00
bool contains(AbstractClient *client) 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 20:26:50 +04:00
/**
* @brief Checks whether the focus chain for the given @p desktop contains the given @p client.
*
* Does not consider the most recently used focus chain.
*
* @param client The Client to look for.
* @param desktop The virtual desktop whose focus chain should be used
* @return bool @c true if the focus chain for @p desktop contains @p client, @c false otherwise.
Use more traditional doxygen style Summary: So far we were following a bit unique and rare doxygen comment style: /** * Contents of the comment. **/ Doxygen comments with this style look balanced and neat, but many people that contribute to KWin don't follow this style. Instead, they prefer more traditional doxygen comment style, i.e. /** * Contents of the comment. */ Reviewing such changes has been a bit frustrating for me (so selfish!) and for other contributors. This change switches doxygen comment style in KWin to a more traditional style. The main reason for doing this is to make code review process easier for new contributors as well us. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D22812
2019-07-29 21:58:33 +03: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 12:24:54 +03:00
bool contains(AbstractClient *client, uint 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 20:26:50 +04:00
/**
* @brief Queries the most recently used focus chain for the next Client after the given
* @p reference Client.
*
* The navigation wraps around the borders of the chain. That is if the @p reference Client is
* the last item of the focus chain, the first Client will be returned.
*
* If the @p reference Client cannot be found in the focus chain, the first element of the focus
* chain is returned.
*
* @param reference The start point in the focus chain to search
Rename Client to X11Client Summary: Currently each managed X11 client is represented with an instance of Client class, however the name of that class is very generic and the only reason why it's called that way is because historically kwin was created as an x11 window manager, so "Client" was a sensible choice. With introduction of wayland support, things had changed and therefore Client needs to be renamed to X11Client in order to better reflect what that class stands for. Renaming of Client to X11Client was agreed upon during the last KWin sprint. Test Plan: Compiles, the test suite is still green. Reviewers: #kwin, romangg Reviewed By: #kwin, romangg Subscribers: romangg, davidedmundson, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D24184
2019-09-24 11:48:08 +03:00
* @return :X11Client *The relatively next Client in the most recently used chain.
Use more traditional doxygen style Summary: So far we were following a bit unique and rare doxygen comment style: /** * Contents of the comment. **/ Doxygen comments with this style look balanced and neat, but many people that contribute to KWin don't follow this style. Instead, they prefer more traditional doxygen comment style, i.e. /** * Contents of the comment. */ Reviewing such changes has been a bit frustrating for me (so selfish!) and for other contributors. This change switches doxygen comment style in KWin to a more traditional style. The main reason for doing this is to make code review process easier for new contributors as well us. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D22812
2019-07-29 21:58:33 +03: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 12:24:54 +03:00
AbstractClient *nextMostRecentlyUsed(AbstractClient *reference) const;
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 20:26:50 +04:00
/**
* @brief Queries the focus chain for @p desktop for the next Client in relation to the given
* @p reference Client.
*
* The method finds the first usable Client which is not the @p reference Client. If no Client
* can be found @c null is returned
*
* @param reference The reference Client which should not be returned
* @param desktop The virtual desktop whose focus chain should be used
Rename Client to X11Client Summary: Currently each managed X11 client is represented with an instance of Client class, however the name of that class is very generic and the only reason why it's called that way is because historically kwin was created as an x11 window manager, so "Client" was a sensible choice. With introduction of wayland support, things had changed and therefore Client needs to be renamed to X11Client in order to better reflect what that class stands for. Renaming of Client to X11Client was agreed upon during the last KWin sprint. Test Plan: Compiles, the test suite is still green. Reviewers: #kwin, romangg Reviewed By: #kwin, romangg Subscribers: romangg, davidedmundson, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D24184
2019-09-24 11:48:08 +03:00
* @return :X11Client *The next usable Client or @c null if none can be found.
Use more traditional doxygen style Summary: So far we were following a bit unique and rare doxygen comment style: /** * Contents of the comment. **/ Doxygen comments with this style look balanced and neat, but many people that contribute to KWin don't follow this style. Instead, they prefer more traditional doxygen comment style, i.e. /** * Contents of the comment. */ Reviewing such changes has been a bit frustrating for me (so selfish!) and for other contributors. This change switches doxygen comment style in KWin to a more traditional style. The main reason for doing this is to make code review process easier for new contributors as well us. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D22812
2019-07-29 21:58:33 +03:00
*/
Remove remaining Client usage from FocusChain
2015-03-12 15:43:39 +03:00
AbstractClient *nextForDesktop(AbstractClient *reference, uint 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 20:26:50 +04:00
/**
* @brief Returns the first Client in the most recently used focus chain. First Client in this
* case means really the first Client in the chain and not the most recently used Client.
*
Rename Client to X11Client Summary: Currently each managed X11 client is represented with an instance of Client class, however the name of that class is very generic and the only reason why it's called that way is because historically kwin was created as an x11 window manager, so "Client" was a sensible choice. With introduction of wayland support, things had changed and therefore Client needs to be renamed to X11Client in order to better reflect what that class stands for. Renaming of Client to X11Client was agreed upon during the last KWin sprint. Test Plan: Compiles, the test suite is still green. Reviewers: #kwin, romangg Reviewed By: #kwin, romangg Subscribers: romangg, davidedmundson, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D24184
2019-09-24 11:48:08 +03:00
* @return :X11Client *The first Client in the most recently used chain.
Use more traditional doxygen style Summary: So far we were following a bit unique and rare doxygen comment style: /** * Contents of the comment. **/ Doxygen comments with this style look balanced and neat, but many people that contribute to KWin don't follow this style. Instead, they prefer more traditional doxygen comment style, i.e. /** * Contents of the comment. */ Reviewing such changes has been a bit frustrating for me (so selfish!) and for other contributors. This change switches doxygen comment style in KWin to a more traditional style. The main reason for doing this is to make code review process easier for new contributors as well us. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D22812
2019-07-29 21:58:33 +03: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 12:24:54 +03:00
AbstractClient *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 20:26:50 +04:00
Use Q_SLOTS and Q_SIGNALS instead of slots and signals Fixes compilation with Qt5/KF5 setup.
2013-07-22 18:07:39 +04:00
public Q_SLOTS:
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 20:26:50 +04:00
/**
* @brief Resizes the per virtual desktop focus chains from @p previousSize to @p newSize.
* This means that for each virtual desktop between previous and new size a new focus chain is
* created and in case the number is reduced the focus chains are destroyed.
*
* @param previousSize The previous number of virtual desktops
* @param newSize The new number of virtual desktops
* @return void
Use more traditional doxygen style Summary: So far we were following a bit unique and rare doxygen comment style: /** * Contents of the comment. **/ Doxygen comments with this style look balanced and neat, but many people that contribute to KWin don't follow this style. Instead, they prefer more traditional doxygen comment style, i.e. /** * Contents of the comment. */ Reviewing such changes has been a bit frustrating for me (so selfish!) and for other contributors. This change switches doxygen comment style in KWin to a more traditional style. The main reason for doing this is to make code review process easier for new contributors as well us. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D22812
2019-07-29 21:58:33 +03: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 20:26:50 +04:00
void resize(uint previousSize, uint newSize);
/**
* @brief Removes @p client from all focus chains.
*
* @param client The Client to remove from all focus chains.
* @return void
Use more traditional doxygen style Summary: So far we were following a bit unique and rare doxygen comment style: /** * Contents of the comment. **/ Doxygen comments with this style look balanced and neat, but many people that contribute to KWin don't follow this style. Instead, they prefer more traditional doxygen comment style, i.e. /** * Contents of the comment. */ Reviewing such changes has been a bit frustrating for me (so selfish!) and for other contributors. This change switches doxygen comment style in KWin to a more traditional style. The main reason for doing this is to make code review process easier for new contributors as well us. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D22812
2019-07-29 21:58:33 +03: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 12:24:54 +03:00
void remove(KWin::AbstractClient *client);
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 20:26:50 +04:00
void setSeparateScreenFocus(bool enabled);
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 12:24:54 +03:00
void setActiveClient(KWin::AbstractClient *client);
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 20:26:50 +04:00
void setCurrentDesktop(uint previous, uint newDesktop);
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 12:24:54 +03:00
bool isUsableFocusCandidate(AbstractClient *c, AbstractClient *prev) const;
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 20:26:50 +04:00
private:
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 22:43:09 +03:00
using Chain = QList<AbstractClient*>;
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 20:26:50 +04:00
/**
* @brief Makes @p client the first Client in the given focus @p chain.
*
* This means the existing position of @p client is dropped and @p client is appended to the
* @p chain which makes it the first item.
*
* @param client The Client to become the first in @p chain
* @param chain The focus chain to operate on
* @return void
Use more traditional doxygen style Summary: So far we were following a bit unique and rare doxygen comment style: /** * Contents of the comment. **/ Doxygen comments with this style look balanced and neat, but many people that contribute to KWin don't follow this style. Instead, they prefer more traditional doxygen comment style, i.e. /** * Contents of the comment. */ Reviewing such changes has been a bit frustrating for me (so selfish!) and for other contributors. This change switches doxygen comment style in KWin to a more traditional style. The main reason for doing this is to make code review process easier for new contributors as well us. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D22812
2019-07-29 21:58:33 +03: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 22:43:09 +03:00
void makeFirstInChain(AbstractClient *client, Chain &chain);
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 20:26:50 +04:00
/**
* @brief Makes @p client the last Client in the given focus @p chain.
*
* This means the existing position of @p client is dropped and @p client is prepended to the
* @p chain which makes it the last item.
*
* @param client The Client to become the last in @p chain
* @param chain The focus chain to operate on
* @return void
Use more traditional doxygen style Summary: So far we were following a bit unique and rare doxygen comment style: /** * Contents of the comment. **/ Doxygen comments with this style look balanced and neat, but many people that contribute to KWin don't follow this style. Instead, they prefer more traditional doxygen comment style, i.e. /** * Contents of the comment. */ Reviewing such changes has been a bit frustrating for me (so selfish!) and for other contributors. This change switches doxygen comment style in KWin to a more traditional style. The main reason for doing this is to make code review process easier for new contributors as well us. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D22812
2019-07-29 21:58:33 +03: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 22:43:09 +03:00
void makeLastInChain(AbstractClient *client, Chain &chain);
void moveAfterClientInChain(AbstractClient *client, AbstractClient *reference, Chain &chain);
void updateClientInChain(AbstractClient *client, Change change, Chain &chain);
void insertClientIntoChain(AbstractClient *client, Chain &chain);
Chain m_mostRecentlyUsed;
QHash<uint, Chain> m_desktopFocusChains;
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 20:26:50 +04:00
bool m_separateScreenFocus;
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 12:24:54 +03:00
AbstractClient *m_activeClient;
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 20:26:50 +04:00
uint m_currentDesktop;
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 11:41:25 +04:00
KWIN_SINGLETON_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 20:26:50 +04:00
};
inline
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 12:24:54 +03:00
bool FocusChain::contains(AbstractClient *client) 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 20:26:50 +04:00
{
return m_mostRecentlyUsed.contains(client);
}
inline
void FocusChain::setSeparateScreenFocus(bool enabled)
{
m_separateScreenFocus = enabled;
}
inline
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 12:24:54 +03:00
void FocusChain::setActiveClient(AbstractClient *client)
Split out handling of focus chain into an own class The new class FocusChain manages two different kind of focus chains. First of all there is a most recently used focus chain which is primarily used for TabBox. Then there is one focus chain per virtual desktop. These chains are used to determine which Client needs to be activated when e.g. switching to a virtual desktop. The individual chains are implemented as a simple QList of Client* with the most recently used Client as the last element. That way one can see it as a LIFO like structure. The desktop focus chains are internally represented as a hash with the id of the virtual desktop as the key and a list as described as the value. FocusChain is a singleton which provides some methods to manipulate the chains and to get a specific Client for a task (e.g. TabBox). While splitting out the code some unused code inside TabBox got removed as well as some activities related code (windows cannot be moved while switching activities). REVIEW: 107494
2012-11-20 20:26:50 +04:00
{
m_activeClient = client;
}
inline
void FocusChain::setCurrentDesktop(uint previous, uint newDesktop)
{
Q_UNUSED(previous)
m_currentDesktop = newDesktop;
}
} // namespace
#endif // KWIN_FOCUS_CHAIN_H