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

108 lines
2.5 KiB
C
Raw Permalink 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.
[kwin/tabbox] Use a QmlComponent instead of a QQuickView for TabBox By not using a QQuickView it becomes possible to just use a PlasmaCore.Dialog or a Quick.Window in the TabBox qml and thus it's possible to simplify the qml code. To support this a new SwitcherItem is introduced and exported to QML. It's a simple QObject providing all the properties which used to be exported to the root context. A declarative TabBox is expected to use one of these items. The C++ side finds the Switcher and for that supports the case that the SwitcherItem is the rootItem or a child item. A declarative TabBox has also to create a QQuickWindow, e.g. a PlasmaCore.Dialog. The visibility of that window should be controlled through the visible property on the SwitcherItem. The underlying C++ implementation assumes that a TabBox only uses one window (it needs to get destroyed once it's hidden and included in highlight windows). Thanks to this change it's no longer needed to reload the TabBox whenever it gets shown or the alternative TabBox gets shown. Instead the same QML script can get reused. Other created switchers are ignored as the visible property won't be changed to true.
2013-12-10 10:14:44 +04:00
Prettify license headers
2020-08-03 01:22:19 +03:00
SPDX-FileCopyrightText: 2013 Martin Gräßlin <mgraesslin@kde.org>
[kwin/tabbox] Use a QmlComponent instead of a QQuickView for TabBox By not using a QQuickView it becomes possible to just use a PlasmaCore.Dialog or a Quick.Window in the TabBox qml and thus it's possible to simplify the qml code. To support this a new SwitcherItem is introduced and exported to QML. It's a simple QObject providing all the properties which used to be exported to the root context. A declarative TabBox is expected to use one of these items. The C++ side finds the Switcher and for that supports the case that the SwitcherItem is the rootItem or a child item. A declarative TabBox has also to create a QQuickWindow, e.g. a PlasmaCore.Dialog. The visibility of that window should be controlled through the visible property on the SwitcherItem. The underlying C++ implementation assumes that a TabBox only uses one window (it needs to get destroyed once it's hidden and included in highlight windows). Thanks to this change it's no longer needed to reload the TabBox whenever it gets shown or the alternative TabBox gets shown. Instead the same QML script can get reused. Other created switchers are ignored as the visible property won't be changed to true.
2013-12-10 10:14:44 +04:00
Prettify license headers
2020-08-03 01:22:19 +03:00
SPDX-License-Identifier: GPL-2.0-or-later
*/
Fix minor EBN issues
2018-08-29 21:02:16 +03:00
#ifndef KWIN_TABBOX_SWITCHERITEM_H
#define KWIN_TABBOX_SWITCHERITEM_H
[kwin/tabbox] Use a QmlComponent instead of a QQuickView for TabBox By not using a QQuickView it becomes possible to just use a PlasmaCore.Dialog or a Quick.Window in the TabBox qml and thus it's possible to simplify the qml code. To support this a new SwitcherItem is introduced and exported to QML. It's a simple QObject providing all the properties which used to be exported to the root context. A declarative TabBox is expected to use one of these items. The C++ side finds the Switcher and for that supports the case that the SwitcherItem is the rootItem or a child item. A declarative TabBox has also to create a QQuickWindow, e.g. a PlasmaCore.Dialog. The visibility of that window should be controlled through the visible property on the SwitcherItem. The underlying C++ implementation assumes that a TabBox only uses one window (it needs to get destroyed once it's hidden and included in highlight windows). Thanks to this change it's no longer needed to reload the TabBox whenever it gets shown or the alternative TabBox gets shown. Instead the same QML script can get reused. Other created switchers are ignored as the visible property won't be changed to true.
2013-12-10 10:14:44 +04:00
#include <QObject>
#include <QRect>
class QAbstractItemModel;
namespace KWin
{
namespace TabBox
{
class SwitcherItem : public QObject
{
Q_OBJECT
Q_PROPERTY(QAbstractItemModel *model READ model NOTIFY modelChanged)
Q_PROPERTY(QRect screenGeometry READ screenGeometry NOTIFY screenGeometryChanged)
Q_PROPERTY(bool visible READ isVisible NOTIFY visibleChanged)
Q_PROPERTY(bool allDesktops READ isAllDesktops NOTIFY allDesktopsChanged)
Q_PROPERTY(int currentIndex READ currentIndex WRITE setCurrentIndex NOTIFY currentIndexChanged)
[tabbox] Expose noModifierGrab to QtQuick Summary: There is a special mode in TabBox which is the noModifierGrab mode. This is Alt+Tab active without a modifier being hold. This mode is entered when being activated through screen edges (either pointer or touch). So far this was not exposed to QtQuick and thus one could not end the mode using pointer or touch. It is possible to select another window, but not to activate it. That required the press of a keyboard key. This setup is rather unfortunate. By exposing the mode to QtQuick we can react from QtQuick side to it and invoke already exposed functionality to select and item and directly activate it - existing left-over from the Plasma Active window switcher. Test Plan: Tested on X11 and Wayland with an adjusted lnf package. It kind of works, but there are additional issues on both X11 and Wayland. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5414
2017-04-12 19:14:37 +03:00
Q_PROPERTY(bool noModifierGrab READ noModifierGrab NOTIFY noModifierGrabChanged)
[kwin/tabbox] Use a QmlComponent instead of a QQuickView for TabBox By not using a QQuickView it becomes possible to just use a PlasmaCore.Dialog or a Quick.Window in the TabBox qml and thus it's possible to simplify the qml code. To support this a new SwitcherItem is introduced and exported to QML. It's a simple QObject providing all the properties which used to be exported to the root context. A declarative TabBox is expected to use one of these items. The C++ side finds the Switcher and for that supports the case that the SwitcherItem is the rootItem or a child item. A declarative TabBox has also to create a QQuickWindow, e.g. a PlasmaCore.Dialog. The visibility of that window should be controlled through the visible property on the SwitcherItem. The underlying C++ implementation assumes that a TabBox only uses one window (it needs to get destroyed once it's hidden and included in highlight windows). Thanks to this change it's no longer needed to reload the TabBox whenever it gets shown or the alternative TabBox gets shown. Instead the same QML script can get reused. Other created switchers are ignored as the visible property won't be changed to true.
2013-12-10 10:14:44 +04:00
/**
* The main QML item that will be displayed in the Dialog
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
*/
[kwin/tabbox] Use a QmlComponent instead of a QQuickView for TabBox By not using a QQuickView it becomes possible to just use a PlasmaCore.Dialog or a Quick.Window in the TabBox qml and thus it's possible to simplify the qml code. To support this a new SwitcherItem is introduced and exported to QML. It's a simple QObject providing all the properties which used to be exported to the root context. A declarative TabBox is expected to use one of these items. The C++ side finds the Switcher and for that supports the case that the SwitcherItem is the rootItem or a child item. A declarative TabBox has also to create a QQuickWindow, e.g. a PlasmaCore.Dialog. The visibility of that window should be controlled through the visible property on the SwitcherItem. The underlying C++ implementation assumes that a TabBox only uses one window (it needs to get destroyed once it's hidden and included in highlight windows). Thanks to this change it's no longer needed to reload the TabBox whenever it gets shown or the alternative TabBox gets shown. Instead the same QML script can get reused. Other created switchers are ignored as the visible property won't be changed to true.
2013-12-10 10:14:44 +04:00
Q_PROPERTY(QObject *item READ item WRITE setItem NOTIFY itemChanged)
Q_CLASSINFO("DefaultProperty", "item")
public:
SwitcherItem(QObject *parent = nullptr);
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
~SwitcherItem() override;
[kwin/tabbox] Use a QmlComponent instead of a QQuickView for TabBox By not using a QQuickView it becomes possible to just use a PlasmaCore.Dialog or a Quick.Window in the TabBox qml and thus it's possible to simplify the qml code. To support this a new SwitcherItem is introduced and exported to QML. It's a simple QObject providing all the properties which used to be exported to the root context. A declarative TabBox is expected to use one of these items. The C++ side finds the Switcher and for that supports the case that the SwitcherItem is the rootItem or a child item. A declarative TabBox has also to create a QQuickWindow, e.g. a PlasmaCore.Dialog. The visibility of that window should be controlled through the visible property on the SwitcherItem. The underlying C++ implementation assumes that a TabBox only uses one window (it needs to get destroyed once it's hidden and included in highlight windows). Thanks to this change it's no longer needed to reload the TabBox whenever it gets shown or the alternative TabBox gets shown. Instead the same QML script can get reused. Other created switchers are ignored as the visible property won't be changed to true.
2013-12-10 10:14:44 +04:00
QAbstractItemModel *model() const;
QRect screenGeometry() const;
bool isVisible() const;
bool isAllDesktops() const;
int currentIndex() const;
void setCurrentIndex(int index);
QObject *item() const;
void setItem(QObject *item);
[tabbox] Expose noModifierGrab to QtQuick Summary: There is a special mode in TabBox which is the noModifierGrab mode. This is Alt+Tab active without a modifier being hold. This mode is entered when being activated through screen edges (either pointer or touch). So far this was not exposed to QtQuick and thus one could not end the mode using pointer or touch. It is possible to select another window, but not to activate it. That required the press of a keyboard key. This setup is rather unfortunate. By exposing the mode to QtQuick we can react from QtQuick side to it and invoke already exposed functionality to select and item and directly activate it - existing left-over from the Plasma Active window switcher. Test Plan: Tested on X11 and Wayland with an adjusted lnf package. It kind of works, but there are additional issues on both X11 and Wayland. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5414
2017-04-12 19:14:37 +03:00
bool noModifierGrab() const {
return m_noModifierGrab;
}
[kwin/tabbox] Use a QmlComponent instead of a QQuickView for TabBox By not using a QQuickView it becomes possible to just use a PlasmaCore.Dialog or a Quick.Window in the TabBox qml and thus it's possible to simplify the qml code. To support this a new SwitcherItem is introduced and exported to QML. It's a simple QObject providing all the properties which used to be exported to the root context. A declarative TabBox is expected to use one of these items. The C++ side finds the Switcher and for that supports the case that the SwitcherItem is the rootItem or a child item. A declarative TabBox has also to create a QQuickWindow, e.g. a PlasmaCore.Dialog. The visibility of that window should be controlled through the visible property on the SwitcherItem. The underlying C++ implementation assumes that a TabBox only uses one window (it needs to get destroyed once it's hidden and included in highlight windows). Thanks to this change it's no longer needed to reload the TabBox whenever it gets shown or the alternative TabBox gets shown. Instead the same QML script can get reused. Other created switchers are ignored as the visible property won't be changed to true.
2013-12-10 10:14:44 +04:00
// for usage from outside
void setModel(QAbstractItemModel *model);
void setAllDesktops(bool all);
void setVisible(bool visible);
[tabbox] Expose noModifierGrab to QtQuick Summary: There is a special mode in TabBox which is the noModifierGrab mode. This is Alt+Tab active without a modifier being hold. This mode is entered when being activated through screen edges (either pointer or touch). So far this was not exposed to QtQuick and thus one could not end the mode using pointer or touch. It is possible to select another window, but not to activate it. That required the press of a keyboard key. This setup is rather unfortunate. By exposing the mode to QtQuick we can react from QtQuick side to it and invoke already exposed functionality to select and item and directly activate it - existing left-over from the Plasma Active window switcher. Test Plan: Tested on X11 and Wayland with an adjusted lnf package. It kind of works, but there are additional issues on both X11 and Wayland. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5414
2017-04-12 19:14:37 +03:00
void setNoModifierGrab(bool set);
[kwin/tabbox] Use a QmlComponent instead of a QQuickView for TabBox By not using a QQuickView it becomes possible to just use a PlasmaCore.Dialog or a Quick.Window in the TabBox qml and thus it's possible to simplify the qml code. To support this a new SwitcherItem is introduced and exported to QML. It's a simple QObject providing all the properties which used to be exported to the root context. A declarative TabBox is expected to use one of these items. The C++ side finds the Switcher and for that supports the case that the SwitcherItem is the rootItem or a child item. A declarative TabBox has also to create a QQuickWindow, e.g. a PlasmaCore.Dialog. The visibility of that window should be controlled through the visible property on the SwitcherItem. The underlying C++ implementation assumes that a TabBox only uses one window (it needs to get destroyed once it's hidden and included in highlight windows). Thanks to this change it's no longer needed to reload the TabBox whenever it gets shown or the alternative TabBox gets shown. Instead the same QML script can get reused. Other created switchers are ignored as the visible property won't be changed to true.
2013-12-10 10:14:44 +04:00
Q_SIGNALS:
void visibleChanged();
void currentIndexChanged(int index);
void modelChanged();
void allDesktopsChanged();
void screenGeometryChanged();
void itemChanged();
[tabbox] Expose noModifierGrab to QtQuick Summary: There is a special mode in TabBox which is the noModifierGrab mode. This is Alt+Tab active without a modifier being hold. This mode is entered when being activated through screen edges (either pointer or touch). So far this was not exposed to QtQuick and thus one could not end the mode using pointer or touch. It is possible to select another window, but not to activate it. That required the press of a keyboard key. This setup is rather unfortunate. By exposing the mode to QtQuick we can react from QtQuick side to it and invoke already exposed functionality to select and item and directly activate it - existing left-over from the Plasma Active window switcher. Test Plan: Tested on X11 and Wayland with an adjusted lnf package. It kind of works, but there are additional issues on both X11 and Wayland. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5414
2017-04-12 19:14:37 +03:00
void noModifierGrabChanged();
[kwin/tabbox] Use a QmlComponent instead of a QQuickView for TabBox By not using a QQuickView it becomes possible to just use a PlasmaCore.Dialog or a Quick.Window in the TabBox qml and thus it's possible to simplify the qml code. To support this a new SwitcherItem is introduced and exported to QML. It's a simple QObject providing all the properties which used to be exported to the root context. A declarative TabBox is expected to use one of these items. The C++ side finds the Switcher and for that supports the case that the SwitcherItem is the rootItem or a child item. A declarative TabBox has also to create a QQuickWindow, e.g. a PlasmaCore.Dialog. The visibility of that window should be controlled through the visible property on the SwitcherItem. The underlying C++ implementation assumes that a TabBox only uses one window (it needs to get destroyed once it's hidden and included in highlight windows). Thanks to this change it's no longer needed to reload the TabBox whenever it gets shown or the alternative TabBox gets shown. Instead the same QML script can get reused. Other created switchers are ignored as the visible property won't be changed to true.
2013-12-10 10:14:44 +04:00
private:
QAbstractItemModel *m_model;
QObject *m_item;
bool m_visible;
bool m_allDesktops;
int m_currentIndex;
QMetaObject::Connection m_selectedIndexConnection;
[tabbox] Expose noModifierGrab to QtQuick Summary: There is a special mode in TabBox which is the noModifierGrab mode. This is Alt+Tab active without a modifier being hold. This mode is entered when being activated through screen edges (either pointer or touch). So far this was not exposed to QtQuick and thus one could not end the mode using pointer or touch. It is possible to select another window, but not to activate it. That required the press of a keyboard key. This setup is rather unfortunate. By exposing the mode to QtQuick we can react from QtQuick side to it and invoke already exposed functionality to select and item and directly activate it - existing left-over from the Plasma Active window switcher. Test Plan: Tested on X11 and Wayland with an adjusted lnf package. It kind of works, but there are additional issues on both X11 and Wayland. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5414
2017-04-12 19:14:37 +03:00
bool m_noModifierGrab = false;
[kwin/tabbox] Use a QmlComponent instead of a QQuickView for TabBox By not using a QQuickView it becomes possible to just use a PlasmaCore.Dialog or a Quick.Window in the TabBox qml and thus it's possible to simplify the qml code. To support this a new SwitcherItem is introduced and exported to QML. It's a simple QObject providing all the properties which used to be exported to the root context. A declarative TabBox is expected to use one of these items. The C++ side finds the Switcher and for that supports the case that the SwitcherItem is the rootItem or a child item. A declarative TabBox has also to create a QQuickWindow, e.g. a PlasmaCore.Dialog. The visibility of that window should be controlled through the visible property on the SwitcherItem. The underlying C++ implementation assumes that a TabBox only uses one window (it needs to get destroyed once it's hidden and included in highlight windows). Thanks to this change it's no longer needed to reload the TabBox whenever it gets shown or the alternative TabBox gets shown. Instead the same QML script can get reused. Other created switchers are ignored as the visible property won't be changed to true.
2013-12-10 10:14:44 +04:00
};
inline QAbstractItemModel *SwitcherItem::model() const
{
return m_model;
}
inline bool SwitcherItem::isVisible() const
{
return m_visible;
}
inline bool SwitcherItem::isAllDesktops() const
{
return m_allDesktops;
}
inline int SwitcherItem::currentIndex() const
{
return m_currentIndex;
}
inline QObject *SwitcherItem::item() const
{
return m_item;
}
} // TabBox
} // KWin
Fix minor EBN issues
2018-08-29 21:02:16 +03:00
#endif // KWIN_TABBOX_SWITCHERITEM_H