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

104 lines
3.6 KiB
C
Raw Normal View History

Prettify license headers
2020-08-02 22:22:19 +00:00
/*
KWin - the KDE window manager
This file is part of the KDE project.
Split out a dedicated InternalClient class Summary: Most of the functionality which is special to internal clients is moved from ShellClient to InternalClient. As KWin's qpa is still bound to the Wayland protocol InternalClient inherits from ShellClient. Due to that some aspects in ShellClient are "weird". ShellClient still detects whether it's an internal client and uses the variable m_internal to capture the state. This is required as we cannot use the isInternal method. Most of m_internal usage is in init which is called from constructor of ShellClient. Thus it's not possible to call into virtual methods of InternalClient. Also some of the code is duplicated and some methods are temporarily marked as virtual. The next step will be to remove ShmBuffer for internal windows which should decouple the two implementations further with the long term goal of having InternalClient inherit AbstractClient directly. Test Plan: Run nested KWin, triggered outline (OpenGL case) and debug console (shm case). InternalWindow unit test still passes. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D18569
2019-01-27 19:48:00 +00:00
Prettify license headers
2020-08-02 22:22:19 +00:00
SPDX-FileCopyrightText: 2019 Martin Flöser <mgraesslin@kde.org>
SPDX-FileCopyrightText: 2019 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
Split out a dedicated InternalClient class Summary: Most of the functionality which is special to internal clients is moved from ShellClient to InternalClient. As KWin's qpa is still bound to the Wayland protocol InternalClient inherits from ShellClient. Due to that some aspects in ShellClient are "weird". ShellClient still detects whether it's an internal client and uses the variable m_internal to capture the state. This is required as we cannot use the isInternal method. Most of m_internal usage is in init which is called from constructor of ShellClient. Thus it's not possible to call into virtual methods of InternalClient. Also some of the code is duplicated and some methods are temporarily marked as virtual. The next step will be to remove ShmBuffer for internal windows which should decouple the two implementations further with the long term goal of having InternalClient inherit AbstractClient directly. Test Plan: Run nested KWin, triggered outline (OpenGL case) and debug console (shm case). InternalWindow unit test still passes. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D18569
2019-01-27 19:48:00 +00:00
Prettify license headers
2020-08-02 22:22:19 +00:00
SPDX-License-Identifier: GPL-2.0-or-later
*/
Split out a dedicated InternalClient class Summary: Most of the functionality which is special to internal clients is moved from ShellClient to InternalClient. As KWin's qpa is still bound to the Wayland protocol InternalClient inherits from ShellClient. Due to that some aspects in ShellClient are "weird". ShellClient still detects whether it's an internal client and uses the variable m_internal to capture the state. This is required as we cannot use the isInternal method. Most of m_internal usage is in init which is called from constructor of ShellClient. Thus it's not possible to call into virtual methods of InternalClient. Also some of the code is duplicated and some methods are temporarily marked as virtual. The next step will be to remove ShmBuffer for internal windows which should decouple the two implementations further with the long term goal of having InternalClient inherit AbstractClient directly. Test Plan: Run nested KWin, triggered outline (OpenGL case) and debug console (shm case). InternalWindow unit test still passes. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D18569
2019-01-27 19:48:00 +00:00
#pragma once
Port QPA away from Wayland Summary: So far wayland was used by internal clients to submit raster buffers and position themselves on the screen. While we didn't have issues with submitting raster buffers, there were some problems with positioning task switchers. Mostly, because we had effectively two paths that may alter geometry. A better approach to deal with internal clients is to let our QPA use kwin core api directly. This way we can eliminate unnecessary roundtrips as well make geometry handling much easier and comprehensible. The last missing piece is shadows. Both Plasma::Dialog and Breeze widget style use platform-specific APIs to set and unset shadows. We need to add shadows API to KWindowSystem. Even though some internal clients lack drop-shadows at the moment, I don't consider it to be a blocker. We can add shadows back later on. CCBUG: 386304 Reviewers: #kwin, davidedmundson, romangg Reviewed By: #kwin, romangg Subscribers: romangg, kwin Tags: #kwin Maniphest Tasks: T9600 Differential Revision: https://phabricator.kde.org/D22810
2019-08-26 07:44:04 +00:00
#include "abstract_client.h"
Split out a dedicated InternalClient class Summary: Most of the functionality which is special to internal clients is moved from ShellClient to InternalClient. As KWin's qpa is still bound to the Wayland protocol InternalClient inherits from ShellClient. Due to that some aspects in ShellClient are "weird". ShellClient still detects whether it's an internal client and uses the variable m_internal to capture the state. This is required as we cannot use the isInternal method. Most of m_internal usage is in init which is called from constructor of ShellClient. Thus it's not possible to call into virtual methods of InternalClient. Also some of the code is duplicated and some methods are temporarily marked as virtual. The next step will be to remove ShmBuffer for internal windows which should decouple the two implementations further with the long term goal of having InternalClient inherit AbstractClient directly. Test Plan: Run nested KWin, triggered outline (OpenGL case) and debug console (shm case). InternalWindow unit test still passes. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D18569
2019-01-27 19:48:00 +00:00
namespace KWin
{
Port QPA away from Wayland Summary: So far wayland was used by internal clients to submit raster buffers and position themselves on the screen. While we didn't have issues with submitting raster buffers, there were some problems with positioning task switchers. Mostly, because we had effectively two paths that may alter geometry. A better approach to deal with internal clients is to let our QPA use kwin core api directly. This way we can eliminate unnecessary roundtrips as well make geometry handling much easier and comprehensible. The last missing piece is shadows. Both Plasma::Dialog and Breeze widget style use platform-specific APIs to set and unset shadows. We need to add shadows API to KWindowSystem. Even though some internal clients lack drop-shadows at the moment, I don't consider it to be a blocker. We can add shadows back later on. CCBUG: 386304 Reviewers: #kwin, davidedmundson, romangg Reviewed By: #kwin, romangg Subscribers: romangg, kwin Tags: #kwin Maniphest Tasks: T9600 Differential Revision: https://phabricator.kde.org/D22810
2019-08-26 07:44:04 +00:00
class KWIN_EXPORT InternalClient : public AbstractClient
Split out a dedicated InternalClient class Summary: Most of the functionality which is special to internal clients is moved from ShellClient to InternalClient. As KWin's qpa is still bound to the Wayland protocol InternalClient inherits from ShellClient. Due to that some aspects in ShellClient are "weird". ShellClient still detects whether it's an internal client and uses the variable m_internal to capture the state. This is required as we cannot use the isInternal method. Most of m_internal usage is in init which is called from constructor of ShellClient. Thus it's not possible to call into virtual methods of InternalClient. Also some of the code is duplicated and some methods are temporarily marked as virtual. The next step will be to remove ShmBuffer for internal windows which should decouple the two implementations further with the long term goal of having InternalClient inherit AbstractClient directly. Test Plan: Run nested KWin, triggered outline (OpenGL case) and debug console (shm case). InternalWindow unit test still passes. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D18569
2019-01-27 19:48:00 +00:00
{
Q_OBJECT
Port QPA away from Wayland Summary: So far wayland was used by internal clients to submit raster buffers and position themselves on the screen. While we didn't have issues with submitting raster buffers, there were some problems with positioning task switchers. Mostly, because we had effectively two paths that may alter geometry. A better approach to deal with internal clients is to let our QPA use kwin core api directly. This way we can eliminate unnecessary roundtrips as well make geometry handling much easier and comprehensible. The last missing piece is shadows. Both Plasma::Dialog and Breeze widget style use platform-specific APIs to set and unset shadows. We need to add shadows API to KWindowSystem. Even though some internal clients lack drop-shadows at the moment, I don't consider it to be a blocker. We can add shadows back later on. CCBUG: 386304 Reviewers: #kwin, davidedmundson, romangg Reviewed By: #kwin, romangg Subscribers: romangg, kwin Tags: #kwin Maniphest Tasks: T9600 Differential Revision: https://phabricator.kde.org/D22810
2019-08-26 07:44:04 +00:00
Split out a dedicated InternalClient class Summary: Most of the functionality which is special to internal clients is moved from ShellClient to InternalClient. As KWin's qpa is still bound to the Wayland protocol InternalClient inherits from ShellClient. Due to that some aspects in ShellClient are "weird". ShellClient still detects whether it's an internal client and uses the variable m_internal to capture the state. This is required as we cannot use the isInternal method. Most of m_internal usage is in init which is called from constructor of ShellClient. Thus it's not possible to call into virtual methods of InternalClient. Also some of the code is duplicated and some methods are temporarily marked as virtual. The next step will be to remove ShmBuffer for internal windows which should decouple the two implementations further with the long term goal of having InternalClient inherit AbstractClient directly. Test Plan: Run nested KWin, triggered outline (OpenGL case) and debug console (shm case). InternalWindow unit test still passes. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D18569
2019-01-27 19:48:00 +00:00
public:
Port QPA away from Wayland Summary: So far wayland was used by internal clients to submit raster buffers and position themselves on the screen. While we didn't have issues with submitting raster buffers, there were some problems with positioning task switchers. Mostly, because we had effectively two paths that may alter geometry. A better approach to deal with internal clients is to let our QPA use kwin core api directly. This way we can eliminate unnecessary roundtrips as well make geometry handling much easier and comprehensible. The last missing piece is shadows. Both Plasma::Dialog and Breeze widget style use platform-specific APIs to set and unset shadows. We need to add shadows API to KWindowSystem. Even though some internal clients lack drop-shadows at the moment, I don't consider it to be a blocker. We can add shadows back later on. CCBUG: 386304 Reviewers: #kwin, davidedmundson, romangg Reviewed By: #kwin, romangg Subscribers: romangg, kwin Tags: #kwin Maniphest Tasks: T9600 Differential Revision: https://phabricator.kde.org/D22810
2019-08-26 07:44:04 +00:00
explicit InternalClient(QWindow *window);
Split out a dedicated InternalClient class Summary: Most of the functionality which is special to internal clients is moved from ShellClient to InternalClient. As KWin's qpa is still bound to the Wayland protocol InternalClient inherits from ShellClient. Due to that some aspects in ShellClient are "weird". ShellClient still detects whether it's an internal client and uses the variable m_internal to capture the state. This is required as we cannot use the isInternal method. Most of m_internal usage is in init which is called from constructor of ShellClient. Thus it's not possible to call into virtual methods of InternalClient. Also some of the code is duplicated and some methods are temporarily marked as virtual. The next step will be to remove ShmBuffer for internal windows which should decouple the two implementations further with the long term goal of having InternalClient inherit AbstractClient directly. Test Plan: Run nested KWin, triggered outline (OpenGL case) and debug console (shm case). InternalWindow unit test still passes. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D18569
2019-01-27 19:48:00 +00:00
~InternalClient() override;
bool eventFilter(QObject *watched, QEvent *event) override;
[wayland] Implement window geometry more properly Summary: So far the window geometry from xdg-shell wasn't implemented as it should be. A toplevel must have two geometries assigned to it - frame and buffer. The frame geometry describes bounds of the client excluding server-side and client-side drop-shadows. The buffer geometry specifies rectangle on the screen occupied by the main surface. State and geometry handling in XdgShellClient is still a bit broken. This change doesn't intend to fix that, it must be done in another patch asap. Test Plan: New tests pass. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: davidedmundson, romangg, kwin Tags: #kwin Maniphest Tasks: T10867 Differential Revision: https://phabricator.kde.org/D24455
2019-10-03 19:43:28 +00:00
QRect bufferGeometry() const override;
Port QPA away from Wayland Summary: So far wayland was used by internal clients to submit raster buffers and position themselves on the screen. While we didn't have issues with submitting raster buffers, there were some problems with positioning task switchers. Mostly, because we had effectively two paths that may alter geometry. A better approach to deal with internal clients is to let our QPA use kwin core api directly. This way we can eliminate unnecessary roundtrips as well make geometry handling much easier and comprehensible. The last missing piece is shadows. Both Plasma::Dialog and Breeze widget style use platform-specific APIs to set and unset shadows. We need to add shadows API to KWindowSystem. Even though some internal clients lack drop-shadows at the moment, I don't consider it to be a blocker. We can add shadows back later on. CCBUG: 386304 Reviewers: #kwin, davidedmundson, romangg Reviewed By: #kwin, romangg Subscribers: romangg, kwin Tags: #kwin Maniphest Tasks: T9600 Differential Revision: https://phabricator.kde.org/D22810
2019-08-26 07:44:04 +00:00
QStringList activities() const override;
void blockActivityUpdates(bool b = true) override;
qreal bufferScale() const override;
QString captionNormal() const override;
QString captionSuffix() const override;
QPoint clientContentPos() const override;
Honor minimum and maximum size of InternalClient Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D26831
2020-02-12 10:44:10 +00:00
QSize minSize() const override;
QSize maxSize() const override;
Port QPA away from Wayland Summary: So far wayland was used by internal clients to submit raster buffers and position themselves on the screen. While we didn't have issues with submitting raster buffers, there were some problems with positioning task switchers. Mostly, because we had effectively two paths that may alter geometry. A better approach to deal with internal clients is to let our QPA use kwin core api directly. This way we can eliminate unnecessary roundtrips as well make geometry handling much easier and comprehensible. The last missing piece is shadows. Both Plasma::Dialog and Breeze widget style use platform-specific APIs to set and unset shadows. We need to add shadows API to KWindowSystem. Even though some internal clients lack drop-shadows at the moment, I don't consider it to be a blocker. We can add shadows back later on. CCBUG: 386304 Reviewers: #kwin, davidedmundson, romangg Reviewed By: #kwin, romangg Subscribers: romangg, kwin Tags: #kwin Maniphest Tasks: T9600 Differential Revision: https://phabricator.kde.org/D22810
2019-08-26 07:44:04 +00:00
void debug(QDebug &stream) const override;
QRect transparentRect() const override;
Split out a dedicated InternalClient class Summary: Most of the functionality which is special to internal clients is moved from ShellClient to InternalClient. As KWin's qpa is still bound to the Wayland protocol InternalClient inherits from ShellClient. Due to that some aspects in ShellClient are "weird". ShellClient still detects whether it's an internal client and uses the variable m_internal to capture the state. This is required as we cannot use the isInternal method. Most of m_internal usage is in init which is called from constructor of ShellClient. Thus it's not possible to call into virtual methods of InternalClient. Also some of the code is duplicated and some methods are temporarily marked as virtual. The next step will be to remove ShmBuffer for internal windows which should decouple the two implementations further with the long term goal of having InternalClient inherit AbstractClient directly. Test Plan: Run nested KWin, triggered outline (OpenGL case) and debug console (shm case). InternalWindow unit test still passes. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D18569
2019-01-27 19:48:00 +00:00
NET::WindowType windowType(bool direct = false, int supported_types = 0) const override;
Port QPA away from Wayland Summary: So far wayland was used by internal clients to submit raster buffers and position themselves on the screen. While we didn't have issues with submitting raster buffers, there were some problems with positioning task switchers. Mostly, because we had effectively two paths that may alter geometry. A better approach to deal with internal clients is to let our QPA use kwin core api directly. This way we can eliminate unnecessary roundtrips as well make geometry handling much easier and comprehensible. The last missing piece is shadows. Both Plasma::Dialog and Breeze widget style use platform-specific APIs to set and unset shadows. We need to add shadows API to KWindowSystem. Even though some internal clients lack drop-shadows at the moment, I don't consider it to be a blocker. We can add shadows back later on. CCBUG: 386304 Reviewers: #kwin, davidedmundson, romangg Reviewed By: #kwin, romangg Subscribers: romangg, kwin Tags: #kwin Maniphest Tasks: T9600 Differential Revision: https://phabricator.kde.org/D22810
2019-08-26 07:44:04 +00:00
double opacity() const override;
void setOpacity(double opacity) override;
Split out a dedicated InternalClient class Summary: Most of the functionality which is special to internal clients is moved from ShellClient to InternalClient. As KWin's qpa is still bound to the Wayland protocol InternalClient inherits from ShellClient. Due to that some aspects in ShellClient are "weird". ShellClient still detects whether it's an internal client and uses the variable m_internal to capture the state. This is required as we cannot use the isInternal method. Most of m_internal usage is in init which is called from constructor of ShellClient. Thus it's not possible to call into virtual methods of InternalClient. Also some of the code is duplicated and some methods are temporarily marked as virtual. The next step will be to remove ShmBuffer for internal windows which should decouple the two implementations further with the long term goal of having InternalClient inherit AbstractClient directly. Test Plan: Run nested KWin, triggered outline (OpenGL case) and debug console (shm case). InternalWindow unit test still passes. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D18569
2019-01-27 19:48:00 +00:00
void killWindow() override;
bool isPopupWindow() const override;
Port QPA away from Wayland Summary: So far wayland was used by internal clients to submit raster buffers and position themselves on the screen. While we didn't have issues with submitting raster buffers, there were some problems with positioning task switchers. Mostly, because we had effectively two paths that may alter geometry. A better approach to deal with internal clients is to let our QPA use kwin core api directly. This way we can eliminate unnecessary roundtrips as well make geometry handling much easier and comprehensible. The last missing piece is shadows. Both Plasma::Dialog and Breeze widget style use platform-specific APIs to set and unset shadows. We need to add shadows API to KWindowSystem. Even though some internal clients lack drop-shadows at the moment, I don't consider it to be a blocker. We can add shadows back later on. CCBUG: 386304 Reviewers: #kwin, davidedmundson, romangg Reviewed By: #kwin, romangg Subscribers: romangg, kwin Tags: #kwin Maniphest Tasks: T9600 Differential Revision: https://phabricator.kde.org/D22810
2019-08-26 07:44:04 +00:00
QByteArray windowRole() const override;
Split out a dedicated InternalClient class Summary: Most of the functionality which is special to internal clients is moved from ShellClient to InternalClient. As KWin's qpa is still bound to the Wayland protocol InternalClient inherits from ShellClient. Due to that some aspects in ShellClient are "weird". ShellClient still detects whether it's an internal client and uses the variable m_internal to capture the state. This is required as we cannot use the isInternal method. Most of m_internal usage is in init which is called from constructor of ShellClient. Thus it's not possible to call into virtual methods of InternalClient. Also some of the code is duplicated and some methods are temporarily marked as virtual. The next step will be to remove ShmBuffer for internal windows which should decouple the two implementations further with the long term goal of having InternalClient inherit AbstractClient directly. Test Plan: Run nested KWin, triggered outline (OpenGL case) and debug console (shm case). InternalWindow unit test still passes. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D18569
2019-01-27 19:48:00 +00:00
void closeWindow() override;
bool isCloseable() const override;
bool isMovable() const override;
bool isMovableAcrossScreens() const override;
bool isResizable() const override;
bool noBorder() const override;
bool userCanSetNoBorder() const override;
bool wantsInput() const override;
bool isInternal() const override;
bool isLockScreen() const override;
bool isInputMethod() const override;
[wayland] Make sure that only the fading popups effect animates outline Summary: Window open/close animation effects should not animate the outline because the end result is a bit awkward. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D19886
2019-03-19 14:01:29 +00:00
bool isOutline() const override;
Split out a dedicated InternalClient class Summary: Most of the functionality which is special to internal clients is moved from ShellClient to InternalClient. As KWin's qpa is still bound to the Wayland protocol InternalClient inherits from ShellClient. Due to that some aspects in ShellClient are "weird". ShellClient still detects whether it's an internal client and uses the variable m_internal to capture the state. This is required as we cannot use the isInternal method. Most of m_internal usage is in init which is called from constructor of ShellClient. Thus it's not possible to call into virtual methods of InternalClient. Also some of the code is duplicated and some methods are temporarily marked as virtual. The next step will be to remove ShmBuffer for internal windows which should decouple the two implementations further with the long term goal of having InternalClient inherit AbstractClient directly. Test Plan: Run nested KWin, triggered outline (OpenGL case) and debug console (shm case). InternalWindow unit test still passes. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D18569
2019-01-27 19:48:00 +00:00
quint32 windowId() const override;
Port QPA away from Wayland Summary: So far wayland was used by internal clients to submit raster buffers and position themselves on the screen. While we didn't have issues with submitting raster buffers, there were some problems with positioning task switchers. Mostly, because we had effectively two paths that may alter geometry. A better approach to deal with internal clients is to let our QPA use kwin core api directly. This way we can eliminate unnecessary roundtrips as well make geometry handling much easier and comprehensible. The last missing piece is shadows. Both Plasma::Dialog and Breeze widget style use platform-specific APIs to set and unset shadows. We need to add shadows API to KWindowSystem. Even though some internal clients lack drop-shadows at the moment, I don't consider it to be a blocker. We can add shadows back later on. CCBUG: 386304 Reviewers: #kwin, davidedmundson, romangg Reviewed By: #kwin, romangg Subscribers: romangg, kwin Tags: #kwin Maniphest Tasks: T9600 Differential Revision: https://phabricator.kde.org/D22810
2019-08-26 07:44:04 +00:00
bool isShown(bool shaded_is_shown) const override;
bool isHiddenInternal() const override;
void hideClient(bool hide) override;
Remove overloads on virtual methods Summary: Prefer virtual methods that take QRect and QSize rather than multi-int versions. Makes for clearer API and reduces the amount of code that was taking all of the components and turn it into a class. Reviewers: #kwin, zzag Reviewed By: #kwin, zzag Subscribers: zzag, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28283
2020-03-25 15:15:23 +00:00
void resizeWithChecks(const QSize &size, ForceGeometry_t force = NormalGeometrySet) override;
void setFrameGeometry(const QRect &rect, ForceGeometry_t force = NormalGeometrySet) override;
[wayland] Apply window rules only to xdg-shell clients Summary: There are rules that have to be applied only once, e.g. every Remember and Apply Initially rule, as well rules that need to configure the client, e.g. size, etc. In the best scenario the compositor would evaluate such rules when the client is about to be mapped. This change limits window rules only to xdg-shell clients because right now only this protocol lets compositors to intervene in the client initialization process. Also, it makes things a bit easier for us on the compositor side. xdg-shell protocol satisfies most of ours requirements to implement window rules, but not all of them. If the client is about to be mapped for the second time and its size is forced by a rule, then compositor may need to configure it. Currently, xdg-shell protocol doesn't have any mechanism that a client could use to notify the compositor about its intent to map. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: fmonteiro, davidedmundson, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D19411
2019-07-09 11:58:57 +00:00
bool supportsWindowRules() const override;
Port QPA away from Wayland Summary: So far wayland was used by internal clients to submit raster buffers and position themselves on the screen. While we didn't have issues with submitting raster buffers, there were some problems with positioning task switchers. Mostly, because we had effectively two paths that may alter geometry. A better approach to deal with internal clients is to let our QPA use kwin core api directly. This way we can eliminate unnecessary roundtrips as well make geometry handling much easier and comprehensible. The last missing piece is shadows. Both Plasma::Dialog and Breeze widget style use platform-specific APIs to set and unset shadows. We need to add shadows API to KWindowSystem. Even though some internal clients lack drop-shadows at the moment, I don't consider it to be a blocker. We can add shadows back later on. CCBUG: 386304 Reviewers: #kwin, davidedmundson, romangg Reviewed By: #kwin, romangg Subscribers: romangg, kwin Tags: #kwin Maniphest Tasks: T9600 Differential Revision: https://phabricator.kde.org/D22810
2019-08-26 07:44:04 +00:00
AbstractClient *findModal(bool allow_itself = false) override;
void setOnAllActivities(bool set) override;
Check if we successfully restored input focus In rare cases, Workspace::restoreFocus() may fail, for example when the most recently activated client is about to be destroyed or unmapped. If it happens that we cannot restore the focus, then mark the window in FocusIn event as active. CCBUG: 424223
2020-07-22 11:00:11 +00:00
bool takeFocus() override;
Port QPA away from Wayland Summary: So far wayland was used by internal clients to submit raster buffers and position themselves on the screen. While we didn't have issues with submitting raster buffers, there were some problems with positioning task switchers. Mostly, because we had effectively two paths that may alter geometry. A better approach to deal with internal clients is to let our QPA use kwin core api directly. This way we can eliminate unnecessary roundtrips as well make geometry handling much easier and comprehensible. The last missing piece is shadows. Both Plasma::Dialog and Breeze widget style use platform-specific APIs to set and unset shadows. We need to add shadows API to KWindowSystem. Even though some internal clients lack drop-shadows at the moment, I don't consider it to be a blocker. We can add shadows back later on. CCBUG: 386304 Reviewers: #kwin, davidedmundson, romangg Reviewed By: #kwin, romangg Subscribers: romangg, kwin Tags: #kwin Maniphest Tasks: T9600 Differential Revision: https://phabricator.kde.org/D22810
2019-08-26 07:44:04 +00:00
void setNoBorder(bool set) override;
void updateDecoration(bool check_workspace_pos, bool force = false) override;
void updateColorScheme() override;
void showOnScreenEdge() override;
Introduce AbstractClient::destroyClient() Summary: The new method provides a generic way for destructing clients. Notice that we can't just delete clients because we may need to discard temporary window rules, which is usually done in destroyClient(). Test Plan: Compiles. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D27821
2020-02-19 15:22:23 +00:00
void destroyClient() override;
Port QPA away from Wayland Summary: So far wayland was used by internal clients to submit raster buffers and position themselves on the screen. While we didn't have issues with submitting raster buffers, there were some problems with positioning task switchers. Mostly, because we had effectively two paths that may alter geometry. A better approach to deal with internal clients is to let our QPA use kwin core api directly. This way we can eliminate unnecessary roundtrips as well make geometry handling much easier and comprehensible. The last missing piece is shadows. Both Plasma::Dialog and Breeze widget style use platform-specific APIs to set and unset shadows. We need to add shadows API to KWindowSystem. Even though some internal clients lack drop-shadows at the moment, I don't consider it to be a blocker. We can add shadows back later on. CCBUG: 386304 Reviewers: #kwin, davidedmundson, romangg Reviewed By: #kwin, romangg Subscribers: romangg, kwin Tags: #kwin Maniphest Tasks: T9600 Differential Revision: https://phabricator.kde.org/D22810
2019-08-26 07:44:04 +00:00
void present(const QSharedPointer<QOpenGLFramebufferObject> fbo);
void present(const QImage &image, const QRegion &damage);
QWindow *internalWindow() const;
Split out a dedicated InternalClient class Summary: Most of the functionality which is special to internal clients is moved from ShellClient to InternalClient. As KWin's qpa is still bound to the Wayland protocol InternalClient inherits from ShellClient. Due to that some aspects in ShellClient are "weird". ShellClient still detects whether it's an internal client and uses the variable m_internal to capture the state. This is required as we cannot use the isInternal method. Most of m_internal usage is in init which is called from constructor of ShellClient. Thus it's not possible to call into virtual methods of InternalClient. Also some of the code is duplicated and some methods are temporarily marked as virtual. The next step will be to remove ShmBuffer for internal windows which should decouple the two implementations further with the long term goal of having InternalClient inherit AbstractClient directly. Test Plan: Run nested KWin, triggered outline (OpenGL case) and debug console (shm case). InternalWindow unit test still passes. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D18569
2019-01-27 19:48:00 +00:00
protected:
bool acceptsFocus() const override;
Port QPA away from Wayland Summary: So far wayland was used by internal clients to submit raster buffers and position themselves on the screen. While we didn't have issues with submitting raster buffers, there were some problems with positioning task switchers. Mostly, because we had effectively two paths that may alter geometry. A better approach to deal with internal clients is to let our QPA use kwin core api directly. This way we can eliminate unnecessary roundtrips as well make geometry handling much easier and comprehensible. The last missing piece is shadows. Both Plasma::Dialog and Breeze widget style use platform-specific APIs to set and unset shadows. We need to add shadows API to KWindowSystem. Even though some internal clients lack drop-shadows at the moment, I don't consider it to be a blocker. We can add shadows back later on. CCBUG: 386304 Reviewers: #kwin, davidedmundson, romangg Reviewed By: #kwin, romangg Subscribers: romangg, kwin Tags: #kwin Maniphest Tasks: T9600 Differential Revision: https://phabricator.kde.org/D22810
2019-08-26 07:44:04 +00:00
bool belongsToSameApplication(const AbstractClient *other, SameApplicationChecks checks) const override;
Split out a dedicated InternalClient class Summary: Most of the functionality which is special to internal clients is moved from ShellClient to InternalClient. As KWin's qpa is still bound to the Wayland protocol InternalClient inherits from ShellClient. Due to that some aspects in ShellClient are "weird". ShellClient still detects whether it's an internal client and uses the variable m_internal to capture the state. This is required as we cannot use the isInternal method. Most of m_internal usage is in init which is called from constructor of ShellClient. Thus it's not possible to call into virtual methods of InternalClient. Also some of the code is duplicated and some methods are temporarily marked as virtual. The next step will be to remove ShmBuffer for internal windows which should decouple the two implementations further with the long term goal of having InternalClient inherit AbstractClient directly. Test Plan: Run nested KWin, triggered outline (OpenGL case) and debug console (shm case). InternalWindow unit test still passes. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D18569
2019-01-27 19:48:00 +00:00
void doMove(int x, int y) override;
void doResizeSync() override;
Port QPA away from Wayland Summary: So far wayland was used by internal clients to submit raster buffers and position themselves on the screen. While we didn't have issues with submitting raster buffers, there were some problems with positioning task switchers. Mostly, because we had effectively two paths that may alter geometry. A better approach to deal with internal clients is to let our QPA use kwin core api directly. This way we can eliminate unnecessary roundtrips as well make geometry handling much easier and comprehensible. The last missing piece is shadows. Both Plasma::Dialog and Breeze widget style use platform-specific APIs to set and unset shadows. We need to add shadows API to KWindowSystem. Even though some internal clients lack drop-shadows at the moment, I don't consider it to be a blocker. We can add shadows back later on. CCBUG: 386304 Reviewers: #kwin, davidedmundson, romangg Reviewed By: #kwin, romangg Subscribers: romangg, kwin Tags: #kwin Maniphest Tasks: T9600 Differential Revision: https://phabricator.kde.org/D22810
2019-08-26 07:44:04 +00:00
void updateCaption() override;
Split out a dedicated InternalClient class Summary: Most of the functionality which is special to internal clients is moved from ShellClient to InternalClient. As KWin's qpa is still bound to the Wayland protocol InternalClient inherits from ShellClient. Due to that some aspects in ShellClient are "weird". ShellClient still detects whether it's an internal client and uses the variable m_internal to capture the state. This is required as we cannot use the isInternal method. Most of m_internal usage is in init which is called from constructor of ShellClient. Thus it's not possible to call into virtual methods of InternalClient. Also some of the code is duplicated and some methods are temporarily marked as virtual. The next step will be to remove ShmBuffer for internal windows which should decouple the two implementations further with the long term goal of having InternalClient inherit AbstractClient directly. Test Plan: Run nested KWin, triggered outline (OpenGL case) and debug console (shm case). InternalWindow unit test still passes. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D18569
2019-01-27 19:48:00 +00:00
private:
Port QPA away from Wayland Summary: So far wayland was used by internal clients to submit raster buffers and position themselves on the screen. While we didn't have issues with submitting raster buffers, there were some problems with positioning task switchers. Mostly, because we had effectively two paths that may alter geometry. A better approach to deal with internal clients is to let our QPA use kwin core api directly. This way we can eliminate unnecessary roundtrips as well make geometry handling much easier and comprehensible. The last missing piece is shadows. Both Plasma::Dialog and Breeze widget style use platform-specific APIs to set and unset shadows. We need to add shadows API to KWindowSystem. Even though some internal clients lack drop-shadows at the moment, I don't consider it to be a blocker. We can add shadows back later on. CCBUG: 386304 Reviewers: #kwin, davidedmundson, romangg Reviewed By: #kwin, romangg Subscribers: romangg, kwin Tags: #kwin Maniphest Tasks: T9600 Differential Revision: https://phabricator.kde.org/D22810
2019-08-26 07:44:04 +00:00
void requestGeometry(const QRect &rect);
void commitGeometry(const QRect &rect);
void setCaption(const QString &caption);
void markAsMapped();
Split out a dedicated InternalClient class Summary: Most of the functionality which is special to internal clients is moved from ShellClient to InternalClient. As KWin's qpa is still bound to the Wayland protocol InternalClient inherits from ShellClient. Due to that some aspects in ShellClient are "weird". ShellClient still detects whether it's an internal client and uses the variable m_internal to capture the state. This is required as we cannot use the isInternal method. Most of m_internal usage is in init which is called from constructor of ShellClient. Thus it's not possible to call into virtual methods of InternalClient. Also some of the code is duplicated and some methods are temporarily marked as virtual. The next step will be to remove ShmBuffer for internal windows which should decouple the two implementations further with the long term goal of having InternalClient inherit AbstractClient directly. Test Plan: Run nested KWin, triggered outline (OpenGL case) and debug console (shm case). InternalWindow unit test still passes. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D18569
2019-01-27 19:48:00 +00:00
void syncGeometryToInternalWindow();
Port QPA away from Wayland Summary: So far wayland was used by internal clients to submit raster buffers and position themselves on the screen. While we didn't have issues with submitting raster buffers, there were some problems with positioning task switchers. Mostly, because we had effectively two paths that may alter geometry. A better approach to deal with internal clients is to let our QPA use kwin core api directly. This way we can eliminate unnecessary roundtrips as well make geometry handling much easier and comprehensible. The last missing piece is shadows. Both Plasma::Dialog and Breeze widget style use platform-specific APIs to set and unset shadows. We need to add shadows API to KWindowSystem. Even though some internal clients lack drop-shadows at the moment, I don't consider it to be a blocker. We can add shadows back later on. CCBUG: 386304 Reviewers: #kwin, davidedmundson, romangg Reviewed By: #kwin, romangg Subscribers: romangg, kwin Tags: #kwin Maniphest Tasks: T9600 Differential Revision: https://phabricator.kde.org/D22810
2019-08-26 07:44:04 +00:00
void updateInternalWindowGeometry();
Split out a dedicated InternalClient class Summary: Most of the functionality which is special to internal clients is moved from ShellClient to InternalClient. As KWin's qpa is still bound to the Wayland protocol InternalClient inherits from ShellClient. Due to that some aspects in ShellClient are "weird". ShellClient still detects whether it's an internal client and uses the variable m_internal to capture the state. This is required as we cannot use the isInternal method. Most of m_internal usage is in init which is called from constructor of ShellClient. Thus it's not possible to call into virtual methods of InternalClient. Also some of the code is duplicated and some methods are temporarily marked as virtual. The next step will be to remove ShmBuffer for internal windows which should decouple the two implementations further with the long term goal of having InternalClient inherit AbstractClient directly. Test Plan: Run nested KWin, triggered outline (OpenGL case) and debug console (shm case). InternalWindow unit test still passes. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D18569
2019-01-27 19:48:00 +00:00
Port QPA away from Wayland Summary: So far wayland was used by internal clients to submit raster buffers and position themselves on the screen. While we didn't have issues with submitting raster buffers, there were some problems with positioning task switchers. Mostly, because we had effectively two paths that may alter geometry. A better approach to deal with internal clients is to let our QPA use kwin core api directly. This way we can eliminate unnecessary roundtrips as well make geometry handling much easier and comprehensible. The last missing piece is shadows. Both Plasma::Dialog and Breeze widget style use platform-specific APIs to set and unset shadows. We need to add shadows API to KWindowSystem. Even though some internal clients lack drop-shadows at the moment, I don't consider it to be a blocker. We can add shadows back later on. CCBUG: 386304 Reviewers: #kwin, davidedmundson, romangg Reviewed By: #kwin, romangg Subscribers: romangg, kwin Tags: #kwin Maniphest Tasks: T9600 Differential Revision: https://phabricator.kde.org/D22810
2019-08-26 07:44:04 +00:00
QWindow *m_internalWindow = nullptr;
QString m_captionNormal;
QString m_captionSuffix;
double m_opacity = 1.0;
Split out a dedicated InternalClient class Summary: Most of the functionality which is special to internal clients is moved from ShellClient to InternalClient. As KWin's qpa is still bound to the Wayland protocol InternalClient inherits from ShellClient. Due to that some aspects in ShellClient are "weird". ShellClient still detects whether it's an internal client and uses the variable m_internal to capture the state. This is required as we cannot use the isInternal method. Most of m_internal usage is in init which is called from constructor of ShellClient. Thus it's not possible to call into virtual methods of InternalClient. Also some of the code is duplicated and some methods are temporarily marked as virtual. The next step will be to remove ShmBuffer for internal windows which should decouple the two implementations further with the long term goal of having InternalClient inherit AbstractClient directly. Test Plan: Run nested KWin, triggered outline (OpenGL case) and debug console (shm case). InternalWindow unit test still passes. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D18569
2019-01-27 19:48:00 +00:00
NET::WindowType m_windowType = NET::Normal;
quint32 m_windowId = 0;
Qt::WindowFlags m_internalWindowFlags = Qt::WindowFlags();
Port QPA away from Wayland Summary: So far wayland was used by internal clients to submit raster buffers and position themselves on the screen. While we didn't have issues with submitting raster buffers, there were some problems with positioning task switchers. Mostly, because we had effectively two paths that may alter geometry. A better approach to deal with internal clients is to let our QPA use kwin core api directly. This way we can eliminate unnecessary roundtrips as well make geometry handling much easier and comprehensible. The last missing piece is shadows. Both Plasma::Dialog and Breeze widget style use platform-specific APIs to set and unset shadows. We need to add shadows API to KWindowSystem. Even though some internal clients lack drop-shadows at the moment, I don't consider it to be a blocker. We can add shadows back later on. CCBUG: 386304 Reviewers: #kwin, davidedmundson, romangg Reviewed By: #kwin, romangg Subscribers: romangg, kwin Tags: #kwin Maniphest Tasks: T9600 Differential Revision: https://phabricator.kde.org/D22810
2019-08-26 07:44:04 +00:00
bool m_userNoBorder = false;
Q_DISABLE_COPY(InternalClient)
Split out a dedicated InternalClient class Summary: Most of the functionality which is special to internal clients is moved from ShellClient to InternalClient. As KWin's qpa is still bound to the Wayland protocol InternalClient inherits from ShellClient. Due to that some aspects in ShellClient are "weird". ShellClient still detects whether it's an internal client and uses the variable m_internal to capture the state. This is required as we cannot use the isInternal method. Most of m_internal usage is in init which is called from constructor of ShellClient. Thus it's not possible to call into virtual methods of InternalClient. Also some of the code is duplicated and some methods are temporarily marked as virtual. The next step will be to remove ShmBuffer for internal windows which should decouple the two implementations further with the long term goal of having InternalClient inherit AbstractClient directly. Test Plan: Run nested KWin, triggered outline (OpenGL case) and debug console (shm case). InternalWindow unit test still passes. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D18569
2019-01-27 19:48:00 +00:00
};
}
Reference in a new issue Copy permalink