yukijoou/kwin
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
kwin/tabbox/switcheritem.h

119 lines
3.2 KiB
C
Raw Normal View History

[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 06:14:44 +00:00
/********************************************************************
KWin - the KDE window manager
This file is part of the KDE project.
Copyright (C) 2013 Martin Gräßlin <mgraesslin@kde.org>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*********************************************************************/
#ifndef KWIN_TABBOX_ITEM
#define KWIN_TABBOX_ITEM
#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 16:14:37 +00: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 06:14:44 +00:00
/**
* The main QML item that will be displayed in the Dialog
*/
Q_PROPERTY(QObject *item READ item WRITE setItem NOTIFY itemChanged)
Q_CLASSINFO("DefaultProperty", "item")
public:
SwitcherItem(QObject *parent = nullptr);
virtual ~SwitcherItem();
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 16:14:37 +00: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 06:14:44 +00: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 16:14:37 +00: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 06:14:44 +00: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 16:14:37 +00: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 06:14:44 +00: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 16:14:37 +00: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 06:14:44 +00: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
#endif // KWIN_TABBOX_ITEM
Reference in a new issue Copy permalink