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

676 lines
23 KiB
C
Raw Normal View History

License cleanup - add headers where missing, be explicit about GPL being v2+ (right now it says just GPL, which according to GPL itself means any GPL). Decoration clients will come later. CCMAIL: kwin@kde.org svn path=/trunk/KDE/kdebase/workspace/; revision=742302
2007-11-27 19:40:25 +00:00
/********************************************************************
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
KWin - the KDE window manager
This file is part of the KDE project.
Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
Update copyright I really should start to add myself to the copyright when I commit large chunks to the files...
2011-03-16 18:39:10 +00:00
Copyright (C) 2010, 2011 Martin Gräßlin <mgraesslin@kde.org>
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
License cleanup - add headers where missing, be explicit about GPL being v2+ (right now it says just GPL, which according to GPL itself means any GPL). Decoration clients will come later. CCMAIL: kwin@kde.org svn path=/trunk/KDE/kdebase/workspace/; revision=742302
2007-11-27 19:40:25 +00:00
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/>.
*********************************************************************/
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
#ifndef KWIN_EFFECTSIMPL_H
#define KWIN_EFFECTSIMPL_H
#include "kwineffects.h"
#include "scene.h"
Store the custom data in a QHash instead of a QMap, since QHash should be faster. svn path=/trunk/KDE/kdebase/workspace/; revision=1130551
2010-05-25 16:56:23 +00:00
#include <QHash>
Drop dependency to libplasma from kwineffects library Since the EffectFrames have been moved into KWin core nothing in the Effects lib actually used Plasma. The only remaining method is moved to core as it's not used in the Effects. The Effects itself still link against Plasma, so nothing changes for them. The Plasma includes in the kwineffects header seemed to pull in quite some additional headers, so the includes in some effects have to be adjusted (most often KConfigGroup). This should speed up the compilation of the library and the effects.
2011-02-17 18:35:08 +00:00
#include <Plasma/FrameSvg>
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
Clean up includes Summary: * effects.h includes client.h and forward declares Client, both at the same time. Thus, delete the include; * the blur effect includes effects.h. That, most likely, is a leftover after 3f5bf65a9ec8fa413ca59dd07df267c8b765329c. Test Plan: Compiles. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D15191
2018-08-31 18:28:22 +00:00
#include <memory>
Plasma::Theme does no longer provide a global static theme Need to hold a pointer instead.
2013-07-22 14:10:47 +00:00
namespace Plasma {
class Theme;
}
Use the kwayland blur protocol in the blur effect use the new blur protocol to fetch information about the region of blur behind to apply to windows like Plasma::Dialog REVIEW:125017
2015-08-31 13:47:01 +00:00
namespace KWayland
{
namespace Server
{
class Display;
}
}
Notify effects when the screen gets locked EffectsHandlerImpl starts to monitor DBus for the screen being locked and provides this information to the Effect system by allowing them to ask whether the screen is currently locked and by emitting a signal when the screen gets locked/unlocked. This information is needed to ensure that no private data is shown on the screen. The following effects are adjusted: * taskbar thumbnails * thumbnail aside * mouse mark * screen shot BUG: 255712 FIXED-IN: 4.11 REVIEW: 108670
2013-01-30 12:07:59 +00:00
class QDBusPendingCallWatcher;
class QDBusServiceWatcher;
Add support for effect ordering. Effects can now have e.g. X-Ordering=10 field in their .desktop file. The bigger the number, the later the effect comes. svn path=/trunk/KDE/kdebase/workspace/; revision=684272
2007-07-06 12:38:41 +00:00
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
namespace KWin
{
Refactoring: break out a base class for ThumbnailItem Everything that has nothing to do with rendering the window thumbnail goes into an AbstractThumbnailItem. This is a preparation step for adding a DesktopThumbnailItem.
2012-03-29 13:32:41 +00:00
class AbstractThumbnailItem;
Adding a DesktopThumbnailItem declarative item Similar to WindowThumbnailItem for rendering a desktop thumbnail. Uses the new paintDesktop hook. FEATURE: 296067 FIXED-IN: 4.11.0 REVIEW: 104441
2012-03-29 18:17:57 +00:00
class DesktopThumbnailItem;
Rename ThumbnailItem to WindowThumbnailItem This is for discrimination from the to be added DesktopThumbnailItem. The name for QML is unchanged to keep the public API stable.
2012-03-29 13:46:53 +00:00
class WindowThumbnailItem;
Window Thumbnail support for QML A new QML item "ThumbnailItem" is registered to the TabBox. The C++ implementation finds the EffectWindow of the TabBox and adds itself to the EffectWindow. While rendering the EffectWindow the information for all registered ThumbnailItems are extracted and the thumbnail is rendered on top of the EffectWindow. This has obvious limitations like you cannot put other QML items on top of the thumbnail. Nevertheless it works well enough to be a possible replacement for e.g. BoxSwitch effect. When compositing is disabled an icon is rendered instead of the Thumbnail. One TabBox Layout inspired by BoxSwitch Effect is added. For the KCM small pre-rendered items are used. REVIEW: 103039
2011-11-10 13:28:06 +00:00
Clean up includes Summary: * effects.h includes client.h and forward declares Client, both at the same time. Thus, delete the include; * the blur effect includes effects.h. That, most likely, is a leftover after 3f5bf65a9ec8fa413ca59dd07df267c8b765329c. Test Plan: Compiles. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D15191
2018-08-31 18:28:22 +00:00
class AbstractClient;
Pass Compositor to EffectsHandlerImpl Obsoletes the need to go through the Workspace object to get to the Compositor. TODO for future: make the Compositor being the parent object for the EffectsHandlerImpl. Closing Review and bug from this commit, which is the top most of the patch series. REVIEW: 106060 BUG: 299277 FIXED-IN: 4.10
2012-08-23 16:04:36 +00:00
class Compositor;
EffectsHandler emits windowDeleted signal Workspace emits a deletedRemoved signal which the EffectsHandlerImpl translates into a windowDeleted signal.
2011-02-27 09:47:42 +00:00
class Deleted;
Keep KWin responsive while loading all effects Loading all effects during startup can take some time[1] and during that time the screen is frozen as the loading blocks the compositor. This change doesn't load effects directly but puts them into a queue. The loading is controlled by invoking the dequeue through a queued connection. Thus we get a firing compositing timer in between and can ensure that a frame is rendered when needed and also react to X events during the loading. [1] On my high-end system the set of effects I use take about 200 msec to load. REVIEW: 115297
2014-01-24 14:42:40 +00:00
class EffectLoader;
Clean up includes Summary: * effects.h includes client.h and forward declares Client, both at the same time. Thus, delete the include; * the blur effect includes effects.h. That, most likely, is a leftover after 3f5bf65a9ec8fa413ca59dd07df267c8b765329c. Test Plan: Compiles. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D15191
2018-08-31 18:28:22 +00:00
class Toplevel;
EffectsHandler emits windowAdded signal All previously existing windowAdded methods are renamed to slotWindowAdded. EffectsHandlerImpl is connected to Workspace's clientAdded signal, which is emitted a little bit earlier than the previous direct method call. This might change behavior. Another signal is added to Workspace to signal that an unmanaged is added.
2011-02-25 21:06:02 +00:00
class Unmanaged;
Add a dedicated X11EventFilter for forwarding property events to the effect system Summary: So far both Workspace and Toplevel emitted signals for every property notify event on the root window and the respective Toplevel windows. The signals were only used in EffectsHandlerImpl to forward to the effect system in case the property which changed is registered by an effect. This change introduces a dedicated event filter for this which is only created in EffectsHandlerImpl in case an X11 connection is available. It supports a restart of the X11 system. The signals used so far are removed from Workspace and Toplevel. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D7853
2017-09-16 17:25:33 +00:00
class WindowPropertyNotifyX11Filter;
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 08:48:08 +00:00
class X11Client;
EffectsHandler emits windowAdded signal All previously existing windowAdded methods are renamed to slotWindowAdded. EffectsHandlerImpl is connected to Workspace's clientAdded signal, which is emitted a little bit earlier than the previous direct method call. This might change behavior. Another signal is added to Workspace to signal that an unmanaged is added.
2011-02-25 21:06:02 +00:00
[wayland] Unload all effects prior to destroying Xwayland connection Some effects do X11 calls in their cleanup code through external libraries (e.g. KSelectionOwner). As we cannot control that we need to ensure the effects are unloaded prior to destroying the Xwayland connection.
2015-11-12 10:29:56 +00:00
class KWIN_EXPORT EffectsHandlerImpl : public EffectsHandler
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
{
EffectsHandler emits desktopChanged signal The first signal used between EffectsHandler and Effects. The signal is actually emitted by the EffectsHandlerImpl and only the interested effects connect to this signal. EffectsHandlerImpl itself is also notified by a signal from Workspace, allowing to remove one of the many if (effects) checks.
2011-02-25 19:41:10 +00:00
Q_OBJECT
Splitting up of KWin's global D-Bus interface Two new interfaces are introduced: * org.kde.kwin.Compositing * org.kde.kwin.Effects The Compositing interface is generated from scriptable elements on the KWin::Compositor class and the Compositor is exported as /Compositor. It provides the general Compositing related D-Bus methods like whether the compositor is active and toggling and so on. The Effects interface is generated from scriptable elements on the KWin::EffectsHandlerImpl class and the instance is exported as /Effects. It provides all the effects related D-Bus methods like loading an effect or the list of all effects. This removes the need to have all these methods provided on the global org.kde.KWin interface. For backwards compatibility they are kept, but no longer provided by the Workspace class. Instead a new DBusInterface is generated which wrapps the calls and delegates it to one of our three related Singleton objects: * Workspace * Compositor * EffectsHandlerImpl
2012-08-30 06:20:26 +00:00
Q_CLASSINFO("D-Bus Interface", "org.kde.kwin.Effects")
Q_PROPERTY(QStringList activeEffects READ activeEffects)
Q_PROPERTY(QStringList loadedEffects READ loadedEffects)
Q_PROPERTY(QStringList listOfEffects READ listOfEffects)
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
public:
Pass Compositor to EffectsHandlerImpl Obsoletes the need to go through the Workspace object to get to the Compositor. TODO for future: make the Compositor being the parent object for the EffectsHandlerImpl. Closing Review and bug from this commit, which is the top most of the patch series. REVIEW: 106060 BUG: 299277 FIXED-IN: 4.10
2012-08-23 16:04:36 +00:00
EffectsHandlerImpl(Compositor *compositor, Scene *scene);
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 16:52:26 +00:00
~EffectsHandlerImpl() override;
[kwin] Add override to methods in EffectsHandlerImpl In exchange the virtual keyword is removed. Note: there are several virtual methods which do not override any method in EffectsHandler.
2014-02-27 10:57:59 +00:00
void prePaintScreen(ScreenPrePaintData& data, int time) override;
Add some const & Summary: Won't make things go much faster since everything that was being passed by value is refcounted but still const & is a bit faster than refcounting For shared pointers instead of adding const & we move them into the destination variable saving some cpu usage but at the same time making clear the pointer is being stored by not being const & Reviewers: zzag Reviewed By: zzag Subscribers: zzag, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D25022
2019-10-29 22:04:15 +00:00
void paintScreen(int mask, const QRegion &region, ScreenPaintData& data) override;
Effects Hook to paint a desktop A specialised paintScreen method to render all windows of one desktop. It's intended to be called during an already started paintScreen process to get e.g. a thumbnail of a desktop. Currently not yet exported to the Effects.
2012-03-29 18:12:34 +00:00
/**
* Special hook to perform a paintScreen but just with the windows on @p desktop.
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 18:58:33 +00:00
*/
Effects Hook to paint a desktop A specialised paintScreen method to render all windows of one desktop. It's intended to be called during an already started paintScreen process to get e.g. a thumbnail of a desktop. Currently not yet exported to the Effects.
2012-03-29 18:12:34 +00:00
void paintDesktop(int desktop, int mask, QRegion region, ScreenPaintData& data);
[kwin] Add override to methods in EffectsHandlerImpl In exchange the virtual keyword is removed. Note: there are several virtual methods which do not override any method in EffectsHandler.
2014-02-27 10:57:59 +00:00
void postPaintScreen() override;
void prePaintWindow(EffectWindow* w, WindowPrePaintData& data, int time) override;
Add some const & Summary: Won't make things go much faster since everything that was being passed by value is refcounted but still const & is a bit faster than refcounting For shared pointers instead of adding const & we move them into the destination variable saving some cpu usage but at the same time making clear the pointer is being stored by not being const & Reviewers: zzag Reviewed By: zzag Subscribers: zzag, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D25022
2019-10-29 22:04:15 +00:00
void paintWindow(EffectWindow* w, int mask, const QRegion &region, WindowPaintData& data) override;
[kwin] Add override to methods in EffectsHandlerImpl In exchange the virtual keyword is removed. Note: there are several virtual methods which do not override any method in EffectsHandler.
2014-02-27 10:57:59 +00:00
void postPaintWindow(EffectWindow* w) override;
Add some const & Summary: Won't make things go much faster since everything that was being passed by value is refcounted but still const & is a bit faster than refcounting For shared pointers instead of adding const & we move them into the destination variable saving some cpu usage but at the same time making clear the pointer is being stored by not being const & Reviewers: zzag Reviewed By: zzag Subscribers: zzag, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D25022
2019-10-29 22:04:15 +00:00
void paintEffectFrame(EffectFrame* frame, const QRegion &region, double opacity, double frameOpacity) override;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
add screen inversion through XF86VidModeSetGammaRamp or XRRSetCrtcGamma use opengl invert effect as fallback REVIEW: 104371
2012-03-23 01:06:46 +00:00
Effect *provides(Effect::Feature ef);
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
Add some const & Summary: Won't make things go much faster since everything that was being passed by value is refcounted but still const & is a bit faster than refcounting For shared pointers instead of adding const & we move them into the destination variable saving some cpu usage but at the same time making clear the pointer is being stored by not being const & Reviewers: zzag Reviewed By: zzag Subscribers: zzag, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D25022
2019-10-29 22:04:15 +00:00
void drawWindow(EffectWindow* w, int mask, const QRegion &region, WindowPaintData& data) override;
[kwin] Add override to methods in EffectsHandlerImpl In exchange the virtual keyword is removed. Note: there are several virtual methods which do not override any method in EffectsHandler.
2014-02-27 10:57:59 +00:00
void buildQuads(EffectWindow* w, WindowQuadList& quadList) override;
void activateWindow(EffectWindow* c) override;
EffectWindow* activeWindow() const override;
void moveWindow(EffectWindow* w, const QPoint& pos, bool snap = false, double snapAdjust = 1.0) override;
void windowToDesktop(EffectWindow* w, int desktop) override;
void windowToScreen(EffectWindow* w, int screen) override;
void setShowingDesktop(bool showing) override;
QString currentActivity() const override;
int currentDesktop() const override;
int numberOfDesktops() const override;
void setCurrentDesktop(int desktop) override;
void setNumberOfDesktops(int desktops) override;
QSize desktopGridSize() const override;
int desktopGridWidth() const override;
int desktopGridHeight() const override;
int workspaceWidth() const override;
int workspaceHeight() const override;
int desktopAtCoords(QPoint coords) const override;
QPoint desktopGridCoords(int id) const override;
QPoint desktopCoords(int id) const override;
int desktopAbove(int desktop = 0, bool wrap = true) const override;
int desktopToRight(int desktop = 0, bool wrap = true) const override;
int desktopBelow(int desktop = 0, bool wrap = true) const override;
int desktopToLeft(int desktop = 0, bool wrap = true) const override;
QString desktopName(int desktop) const override;
bool optionRollOverDesktops() const override;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
[kwin] Add override to methods in EffectsHandlerImpl In exchange the virtual keyword is removed. Note: there are several virtual methods which do not override any method in EffectsHandler.
2014-02-27 10:57:59 +00:00
QPoint cursorPos() const override;
bool grabKeyboard(Effect* effect) override;
void ungrabKeyboard() override;
Change the way how effects can get mouse events With the removal of BoxSwitch all effects which want mouse events use the fullscreen input window. The available functionality is too complex both in EffectsHandler and in the Effects. With this change only fullscreen input windows are supported and all effects share the input window. This means there is at maximum one input window. This simplifies the code in the Effects as they don't have to keep track of the window they created any more. In EffectsHandler it means that only one window needs to be created, destroyed and raised. Also it means that we can properly react on screen size changes which had been ignored in the past. Also quite some roundtrips to X are no longer needed as we do not need to query the window geometry when creating the input window. REVIEW: 110156
2013-04-24 14:51:04 +00:00
// not performing XGrabPointer
[kwin] Add override to methods in EffectsHandlerImpl In exchange the virtual keyword is removed. Note: there are several virtual methods which do not override any method in EffectsHandler.
2014-02-27 10:57:59 +00:00
void startMouseInterception(Effect *effect, Qt::CursorShape shape) override;
void stopMouseInterception(Effect *effect) override;
Rework cursor image handling for Wayland So far updating the cursor image was not really defined. It was possible to use the cursor image from the wayland seat or have a custom set cursor image. But there are no rules in place to decide which one to use when. With this change a dedicated CursorImage class is introduced which tracks the cursor image changes on the seat, on the decoration, in the effects and so on. In addition it tracks which is the current source for the image, that is whether e.g. the cursor from the seat or from effects override should be used. Whenever the cursor image changes a signal is emitted, which is connected to the signal in AbstractBackend. Based on that the backends can directly show the image. The existing code in the backends to install a cursor shape or to install the cursor from the server is completely dropped. For the backend it's irrelevant from where the image comes from. A new feature added is that the cursor image is marked as rendered. This is then passed on to the frame rendered in the Surface and thus animated cursors are finally working. Unfortunately animated cursors are broken in Qt (see https://bugreports.qt.io/browse/QTBUG-48181 ).
2016-02-23 11:29:05 +00:00
bool isMouseInterception() const;
Add registerGlobalShortcut method to kwineffects Implemented in KWin core to forward to new global shortcut system. This method should be extended/changed once we go to Qt5/KF5 to make the usage easier (no more KAction). Each global shortcut in the effects makes use of this new method.
2013-07-10 10:26:50 +00:00
void registerGlobalShortcut(const QKeySequence &shortcut, QAction *action) override;
Export global pointer shortcuts to effect system and use it for cube Used in cube effect as an example with hard coded ctrl+alt+left click. BUG: 163121
2013-07-14 20:58:30 +00:00
void registerPointerShortcut(Qt::KeyboardModifiers modifiers, Qt::MouseButton pointerButtons, QAction *action) override;
Export Pointer Axis shortcuts to the effect system
2013-07-15 10:04:13 +00:00
void registerAxisShortcut(Qt::KeyboardModifiers modifiers, PointerAxisDirection axis, QAction *action) override;
Add support for global touchpad swipe gestures Summary: This change adds global touchpad swipe gestures to the GlobalShortcutsManager and hooks up the swipe gestures as defined at the Plasma Affenfels sprint: * swipe up: Desktop Grid * swipe down: Present Windows * swipe left: previous virtual desktop * swipe right: next virtual desktop The main work is handled by two new classes: SwipeGesture and GestureRecognizer. This is implemented in a way that it can be extended to also recognize touch screen gestures and pinch gestures. The SwipeGesture defines what is required for the gesture to trigger. Currently this includes the minimum and maximum number of fingers participating in the gesture and the direction. The gesture gets registered in the GestureRecognizer. The events for the gesture are fed into the GestureRecognizer. It evaluates which gestures could trigger and tracks them for every update of the gesture. In the process of the gesture tracking the GestureRecognizer emits signals on the Gesture: * started: when the Gesture gets considered for a sequence * cancelled: the Gesture no longer matches the sequence * triggered: the sequence ended and the Gesture still matches The remaining changes are related to hook up the existing shortcut framework with the new touchpad gestures. The GlobalShortcutManager gained support for it, InputRedirection and EffectsHandler offer methods to register a QAction. VirtualDesktopManager, PresentWindows and DesktopGrid are adjusted to support the gesture. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel Tags: #plasma_on_wayland Differential Revision: https://phabricator.kde.org/D5097
2017-03-18 10:00:30 +00:00
void registerTouchpadSwipeShortcut(SwipeDirection direction, QAction *action) override;
[kwin] Add override to methods in EffectsHandlerImpl In exchange the virtual keyword is removed. Note: there are several virtual methods which do not override any method in EffectsHandler.
2014-02-27 10:57:59 +00:00
void* getProxy(QString name) override;
void startMousePolling() override;
void stopMousePolling() override;
EffectWindow* findWindow(WId id) const override;
support the slide protocol take and apply thhe informations from the wayland slide protocol in the sliding popups effect REVIEW:125120
2015-09-14 14:39:39 +00:00
EffectWindow* findWindow(KWayland::Server::SurfaceInterface *surf) const override;
Add windowsystem plugin for KWin's qpa Summary: KWindowSystem provides a plugin interface to have platform specific implementations. So far KWin relied on the implementation in KWayland-integration repository. This is something I find unsuited, for the following reasons: * any test in KWin for functionality set through the plugin would fail * it's not clear what's going on where * in worst case some code could deadlock * KWin shouldn't use KWindowSystem and only a small subset is allowed to be used The last point needs some further explanation. KWin internally does not and cannot use KWindowSystem. KWindowSystem (especially KWindowInfo) is exposing information which KWin sets. It's more than weird if KWin asks KWindowSystem for the state of a window it set itself. On X11 it's just slow, on Wayland it can result in roundtrips to KWin itself which is dangerous. But due to using Plasma components we have a few areas where we use KWindowSystem. E.g. a Plasma::Dialog sets a window type, the slide in direction, blur and background contrast. This we want to support and need to support. Other API elements we do not want, like for examples the available windows. KWin internal windows either have direct access to KWin or a scripting interface exposed providing (limited) access - there is just no need to have this in KWindowSystem. To make it more clear what KWin supports as API of KWindowSystem for internal windows this change implements a stripped down version of the kwayland-integration plugin. The main difference is that it does not use KWayland at all, but a QWindow internal side channel. To support this EffectWindow provides an accessor for internalWindow and the three already mentioned effects are adjusted to read from the internal QWindow and it's dynamic properties. This change is a first step for a further refactoring. I plan to split the internal window out of ShellClient into a dedicated class. I think there are nowadays too many special cases. If it moves out there is the question whether we really want to use Wayland for the internal windows or whether this is just historic ballast (after all we used to use qwayland for that in the beginning). As the change could introduce regressions I'm targetting 5.16. Test Plan: new test case for window type, manual testing using Alt+Tab for the effects integration. Sliding popups, blur and contrast worked fine. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D18228
2019-01-13 16:50:32 +00:00
EffectWindow *findWindow(QWindow *w) const override;
Switch ThumbnailItem to internal uuid instead of WId Summary: So far the ThumbnailItem in TabBox mode used the window id for finding the window it should render a thumbnail on. In the Wayland world this is not unique. The window id could be either an X11 window or a wayland window. We don't guarantee that there are no conflicting ids. With the internal id we have a way to properly identify the windows, so this element should use them. To support this the property changed the type to QUuid and the clientmodel also provides the QUuid. As in TabBox the way to get the window is through the model this should be compatible for all themes. It's tested and verified with the Breeze switcher. For declarative KWin scripts the ThumbnailItem also provides the AbstractClient as a property, so there should not be any script which uses wid. If it does, this could break, but well the script should use the intended API. Test Plan: ctest passes, manual testing of Breeze alt-tab switcher Reviewers: #kwin Differential Revision: https://phabricator.kde.org/D18405
2019-01-20 13:04:13 +00:00
EffectWindow *findWindow(const QUuid &id) const override;
[kwin] Add override to methods in EffectsHandlerImpl In exchange the virtual keyword is removed. Note: there are several virtual methods which do not override any method in EffectsHandler.
2014-02-27 10:57:59 +00:00
EffectWindowList stackingOrder() const override;
make window elevation scriptable
2015-03-28 23:13:41 +00:00
void setElevatedWindow(KWin::EffectWindow* w, bool set) override;
[kwin] Add override to methods in EffectsHandlerImpl In exchange the virtual keyword is removed. Note: there are several virtual methods which do not override any method in EffectsHandler.
2014-02-27 10:57:59 +00:00
void setTabBoxWindow(EffectWindow*) override;
void setTabBoxDesktop(int) override;
EffectWindowList currentTabBoxWindowList() const override;
void refTabBox() override;
void unrefTabBox() override;
void closeTabBox() override;
QList< int > currentTabBoxDesktopList() const override;
int currentTabBoxDesktop() const override;
EffectWindow* currentTabBoxWindow() const override;
void setActiveFullScreenEffect(Effect* e) override;
Effect* activeFullScreenEffect() const override;
[libkwineffects] Expose getting/setting activeFullScript to scripted effects Summary: Getter is exposed as a property on scripted effect in a way that hides pointers from the scripting side. Setter is implicitly handled as a property of newly created animations and holds the activeFullScreenEffect whilst any of them are active. Like existing effects it remains up to the effect author to avoid the problems of multiple full screen effects. The RAII lock pattern is somewhat overkill currently, but it's the direction I hope we can take EffectsHandler in next API break. BUG: 396790 -- This patch is against the QJSEngine port, though it's not conceptually a requirement. Test Plan: Unit test Reviewers: #kwin, zzag Reviewed By: #kwin, zzag Subscribers: zzag, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D14688
2018-10-03 00:11:59 +00:00
bool hasActiveFullScreenEffect() const override;
[kwin] Add override to methods in EffectsHandlerImpl In exchange the virtual keyword is removed. Note: there are several virtual methods which do not override any method in EffectsHandler.
2014-02-27 10:57:59 +00:00
void addRepaintFull() override;
void addRepaint(const QRect& r) override;
void addRepaint(const QRegion& r) override;
void addRepaint(int x, int y, int w, int h) override;
int activeScreen() const override;
int numScreens() const override;
int screenNumber(const QPoint& pos) const override;
QRect clientArea(clientAreaOption, int screen, int desktop) const override;
QRect clientArea(clientAreaOption, const EffectWindow* c) const override;
QRect clientArea(clientAreaOption, const QPoint& p, int desktop) const override;
[kwin] Introduce Screens::size and Screens::geometry Screens provides a size which is constructed from the size of the bounding geometry of all screens and provides an overload taking an int to return the size of a specified screen. For geometry() a new ovload is added without an argument, which is just a convenient wrapper for QRect(QPoint(0, 0), size()). Both new methods are exported to effects and scripting as new properties there called virtualScreenSize and virtualScreenGeometry. The (virtual) size gets cached in screens and is updated whenever the count or geometry changes. Construction of Screens is slightly changed by moving the init code from ctor into a virtual method init(). Reason is that we ended in a loop with accessing the singleton pointer before it was set. REVIEW: 116114
2014-02-27 08:55:45 +00:00
QSize virtualScreenSize() const override;
QRect virtualScreenGeometry() const override;
[kwin] Add override to methods in EffectsHandlerImpl In exchange the virtual keyword is removed. Note: there are several virtual methods which do not override any method in EffectsHandler.
2014-02-27 10:57:59 +00:00
double animationTimeFactor() const override;
WindowQuadType newWindowQuadType() override;
void defineCursor(Qt::CursorShape shape) override;
Pass pointer events through the effect system InputRedirection forwards pointer events (currently motion, press and release) through the EffectsHandlerImpl for the case that an effect has intercepted pointer events. If the KWin operation mode is not X11 only, the window for intercepting the mouse events is no longer created.
2013-06-26 09:40:30 +00:00
bool checkInputWindowEvent(QMouseEvent *e);
Add bool checkInputWindowEvent(QWheelEvent *e) to EffectsHandlerImpl Allows to also pass through some QWheelEvents.
2016-03-04 13:14:44 +00:00
bool checkInputWindowEvent(QWheelEvent *e);
[kwin] EffectsHandlerImpl::checkInputWindowStacking is not virtual
2014-02-27 11:04:15 +00:00
void checkInputWindowStacking();
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
[kwin] Add override to methods in EffectsHandlerImpl In exchange the virtual keyword is removed. Note: there are several virtual methods which do not override any method in EffectsHandler.
2014-02-27 10:57:59 +00:00
void reserveElectricBorder(ElectricBorder border, Effect *effect) override;
void unreserveElectricBorder(ElectricBorder border, Effect *effect) override;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
Add callback functionality for touch screen swipe gestures Summary: This is implemented through QActions following the general approach inside KWin and not the older approach used by ScreenEdges for pointer callback activation. Test Plan: Extended auto test Reviewers: #kwin, #plasma Subscribers: plasma-devel Tags: #plasma Differential Revision: https://phabricator.kde.org/D5263
2017-03-31 05:41:21 +00:00
void registerTouchBorder(ElectricBorder border, QAction *action) override;
void unregisterTouchBorder(ElectricBorder border, QAction *action) override;
[kwin] Add override to methods in EffectsHandlerImpl In exchange the virtual keyword is removed. Note: there are several virtual methods which do not override any method in EffectsHandler.
2014-02-27 10:57:59 +00:00
unsigned long xrenderBufferPicture() override;
QPainter* scenePainter() override;
void reconfigure() override;
QByteArray readRootProperty(long atom, long type, int format) const override;
xcb_atom_t announceSupportProperty(const QByteArray& propertyName, Effect* effect) override;
void removeSupportProperty(const QByteArray& propertyName, Effect* effect) override;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
[kwin] Add override to methods in EffectsHandlerImpl In exchange the virtual keyword is removed. Note: there are several virtual methods which do not override any method in EffectsHandler.
2014-02-27 10:57:59 +00:00
bool hasDecorationShadows() const override;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
[kwin] Add override to methods in EffectsHandlerImpl In exchange the virtual keyword is removed. Note: there are several virtual methods which do not override any method in EffectsHandler.
2014-02-27 10:57:59 +00:00
bool decorationsHaveAlpha() const override;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
[kwin] Add override to methods in EffectsHandlerImpl In exchange the virtual keyword is removed. Note: there are several virtual methods which do not override any method in EffectsHandler.
2014-02-27 10:57:59 +00:00
bool decorationSupportsBlurBehind() const override;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
[kwin] Add override to methods in EffectsHandlerImpl In exchange the virtual keyword is removed. Note: there are several virtual methods which do not override any method in EffectsHandler.
2014-02-27 10:57:59 +00:00
EffectFrame* effectFrame(EffectFrameStyle style, bool staticSize, const QPoint& position, Qt::Alignment alignment) const override;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
[kwin] Add override to methods in EffectsHandlerImpl In exchange the virtual keyword is removed. Note: there are several virtual methods which do not override any method in EffectsHandler.
2014-02-27 10:57:59 +00:00
QVariant kwinOption(KWinOption kwopt) override;
bool isScreenLocked() const override;
fix close button side for present windows effect BUG: 262543 pint desktop as background when including desktop in switcher BUG: 262137 zoom windows as hover/selection indicaton (1/8 of the screen or 105%) BUG: 215348 CCBUG: 175521 no closer on "show desktop" desktop show closer immediately but have it disabled for a short time to allow the user realize it REVIEW: 101318
2011-04-25 15:04:04 +00:00
[kwin] Add override to methods in EffectsHandlerImpl In exchange the virtual keyword is removed. Note: there are several virtual methods which do not override any method in EffectsHandler.
2014-02-27 10:57:59 +00:00
bool makeOpenGLContextCurrent() override;
void doneOpenGLContextCurrent() override;
Better handling for making the compositing OpenGL context current With QtQuick2 it's possible that the scene graph rendering context either lives in an own thread or uses the main GUI thread. In the latter case it's the same thread as our compositing OpenGL context lives in. This means our basic assumption that between two rendering passes the context stays current does not hold. The code already ensured that before we start a rendering pass the context is made current, but there are many more possible cases. If we use OpenGL in areas not triggered by the rendering loop but in response to other events the context needs to be made current. This includes the loading and unloading of effects (some effects use OpenGL in the static effect check, in the ctor and dtor), background loading of texture data, lazy loading after first usage invoked by shortcut, etc. etc. To properly handle these cases new methods are added to EffectsHandler to make the compositing OpenGL context current. These calls delegate down into the scene. On non-OpenGL scenes they are noop, but on OpenGL they go into the backend and make the context current. In addition they ensure that Qt doesn't think that it's QOpenGLContext is current by calling doneCurrent() on the QOpenGLContext::currentContext(). This unfortunately causes an additional call to makeCurrent with a null context, but there is no other way to tell Qt - it doesn't notice when a different context is made current with low level API calls. In the multi-threaded architecture this doesn't matter as ::currentContext() returns null. A short evaluation showed that a transition to QOpenGLContext doesn't seem feasible. Qt only supports either GLX or EGL while KWin supports both and when entering the transition phase for Wayland, it would become extremely tricky if our native platform is X11, but we want a Wayland EGL context. A future solution might be to have a "KWin-QPA plugin" which uses either xcb or Wayland and hides everything from Qt. The API documentation is extended to describe when the effects-framework ensures that an OpenGL context is current. The effects are changed to make the context current in cases where it's not guaranteed. This has been done by looking for creation or deletion of GLTextures and Shaders. If there are other OpenGL usages outside the rendering loop, ctor/dtor this needs to be changed, too.
2013-11-22 14:05:36 +00:00
[effects] Get xcb_connection_t* and rootWindow through EffectsHandler API So far the effects could just use the connection() and rootWindow() provided by kwinglobals. Thus an internal detail from KWin core is accessed directly. To be more consistent with the rest of the API it's wrapped through the EffectsHandler and with a convenient method in Effect. The connection() is provided as xcbConnection() to free the very generic name connection which could create confusion once we provide a wayland connection to the Effects. The rootWindow() is provided as x11RootWindow() to indicate that it is for the X11 world. REVIEW: 117597
2014-04-16 13:58:06 +00:00
xcb_connection_t *xcbConnection() const override;
xcb_window_t x11RootWindow() const override;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
// internal (used by kwin core or compositing code)
void startPaint();
void grabbedKeyboardEvent(QKeyEvent* e);
bool hasKeyboardGrab() const;
change geometry w/o compositor restart This possibly fails on some (older?) ati chip/driver combos -> Waiting for bugreports REVIEW: 103246
2011-11-26 15:15:46 +00:00
void desktopResized(const QSize &size);
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
[kwin] Add override to methods in EffectsHandlerImpl In exchange the virtual keyword is removed. Note: there are several virtual methods which do not override any method in EffectsHandler.
2014-02-27 10:57:59 +00:00
void reloadEffect(Effect *effect) override;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
QStringList loadedEffects() const;
QStringList listOfEffects() const;
[wayland] Unload all effects prior to destroying Xwayland connection Some effects do X11 calls in their cleanup code through external libraries (e.g. KSelectionOwner). As we cannot control that we need to ensure the effects are unloaded prior to destroying the Xwayland connection.
2015-11-12 10:29:56 +00:00
void unloadAllEffects();
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
QList<EffectWindow*> elevatedWindows() const;
add dbus debug "activeEffects" REVIEW: 103572 CCBUG: 288948 CCBUG: 290025
2011-12-29 22:33:45 +00:00
QStringList activeEffects() const;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
Effects Hook to paint a desktop A specialised paintScreen method to render all windows of one desktop. It's intended to be called during an already started paintScreen process to get e.g. a thumbnail of a desktop. Currently not yet exported to the Effects.
2012-03-29 18:12:34 +00:00
/**
* @returns Whether we are currently in a desktop rendering process triggered by paintDesktop hook
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 18:58:33 +00:00
*/
Effects Hook to paint a desktop A specialised paintScreen method to render all windows of one desktop. It's intended to be called during an already started paintScreen process to get e.g. a thumbnail of a desktop. Currently not yet exported to the Effects.
2012-03-29 18:12:34 +00:00
bool isDesktopRendering() const {
return m_desktopRendering;
}
/**
* @returns the desktop currently being rendered in the paintDesktop hook.
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 18:58:33 +00:00
*/
Effects Hook to paint a desktop A specialised paintScreen method to render all windows of one desktop. It's intended to be called during an already started paintScreen process to get e.g. a thumbnail of a desktop. Currently not yet exported to the Effects.
2012-03-29 18:12:34 +00:00
int currentRenderedDesktop() const {
return m_currentRenderedDesktop;
}
Use the kwayland blur protocol in the blur effect use the new blur protocol to fetch information about the region of blur behind to apply to windows like Plasma::Dialog REVIEW:125017
2015-08-31 13:47:01 +00:00
KWayland::Server::Display *waylandDisplay() const override;
Introduce an EffectsHandler::animationsSupported -> bool Summary: A new method to tell the effects system whether the compositor scene is able to drive animations. E.g. on software emulation (llvmpipe) it's better to not do any animations at all. This information can be used by effects to adjust their behavior, e.g. PresentWindows could skip transitions or effects can use it in their supported check to completely disable themselves. As a first step all scripted effects are considered to be unsupported if animations are not supported. They inherit AnimationEffect and are all about driving animations. The information whether animations are supported comes from the Scene. It's implemented in the following way: * XRender: animations are always supported * QPainter: animations are never supported * OpenGL: animations are supported, except for software emulation In addition - for easier testing - there is a new env variable KWIN_EFFECTS_FORCE_ANIMATIONS to overwrite the selection. Reviewers: #kwin, #plasma Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D2386
2016-08-10 07:24:53 +00:00
bool animationsSupported() const override;
Add a PlatformCursorImage to Platform and EffectsHandler Summary: There are several effects (screenshot, zoom) which need access to the cursor image and cursor hotspot. So far these effects used X11 unconditionally to get the cursor which obviously does not work on Wayland. This change adds a new class PlatformCursorImage to kwinglobals which wraps what a cursor is (image and hotspot) and adds a new virtual method to Platform to provide such a PlatformCursorImage. By default it's the cursor image the Platform tracks. On X11/standalone platform this new virtual method is overriden and provides a PlatformCursorImage from X11 using the code previously used in screenshot effect. Screenshot effect and zoom are adjusted to use the new API instead of X11. Test Plan: Zoom effect tested on Wayland, now gets the proper cursor icon. X11 functionality not yet tested. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3093
2016-10-17 14:12:21 +00:00
PlatformCursorImage cursorImage() const override;
[kwineffects] Add hide/show cursor to EffectsHandler Summary: The implementation delegates to the Platform to perform the actual show/hide of the cursor image. This replaces the implementation in the zoom effect which so far directly interacted with xfixes to show/hide the cursor. This is now provided by the x11/standalone platform. And due to this change the zoom effect can now properly hide the cursor on platform DRM (wayland) as well. Test Plan: Zoom effect on Wayland hides the cursor Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3120
2016-10-20 08:25:37 +00:00
void hideCursor() override;
void showCursor() override;
[effects] Add interactive window selection mode to ScreenshotEffect Summary: EffectsHandler gains a new method to startInteractiveWindowSelection which just delegates to the one in Platform. That way a window can be selected and returned to an Effect. The screenshot effect makes use of this new functionality and provides an interactive window screenshot mode which saves to a temporary file. Note that this is not yet the variant intended for use in spectacle. Test Plan: Took a screenshot on Wayland Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3367
2016-11-15 14:40:30 +00:00
void startInteractiveWindowSelection(std::function<void(KWin::EffectWindow*)> callback) override;
Add interactive position selection to screenshot screen under cursor Summary: A second interactive selection mode gets added to select a position on the screen. This is handled by the same input event filter as for the window selection. Just that instead of returning a window, it returns a QPoint. This allows to pick a point on the screen which we need to screenshot the screen under the mouse cursor and in future for color picking. The screenshot effect provides two new dbus methods to (interactively) select a screen or fullscreen. This allows spectacle to screenshot the (full) screen with still having the user in control. Reviewers: #kwin, #plasma_on_wayland, bgupta Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3475
2016-11-23 14:53:17 +00:00
void startInteractivePositionSelection(std::function<void(const QPoint &)> callback) override;
[effects] Add interactive window selection mode to ScreenshotEffect Summary: EffectsHandler gains a new method to startInteractiveWindowSelection which just delegates to the one in Platform. That way a window can be selected and returned to an Effect. The screenshot effect makes use of this new functionality and provides an interactive window screenshot mode which saves to a temporary file. Note that this is not yet the variant intended for use in spectacle. Test Plan: Took a screenshot on Wayland Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3367
2016-11-15 14:40:30 +00:00
Add support for on-screen-message to kwineffects Summary: This adds support for the new on-screen-message support to the kwineffects API and makes use of it in the colorpicker effect. Not yet added to screenshot effect as for that we need support for skip close animation on the on-screen-message window. Reviewers: #plasma, #kwin Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D3803
2016-12-23 16:39:12 +00:00
void showOnScreenMessage(const QString &message, const QString &iconName = QString()) override;
Add support for skip close animation to OnScreenMessage Summary: This change adds support for marking the OnScreenMessage as it should skip close animation. The screenshot effect is adjusted to use the on screen message instead of the custom effect frame. Test Plan: Message window is not captured when taking screenshot Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D4091
2017-01-11 19:14:36 +00:00
void hideOnScreenMessage(OnScreenMessageHideFlags flags = OnScreenMessageHideFlags()) override;
Add support for on-screen-message to kwineffects Summary: This adds support for the new on-screen-message support to the kwineffects API and makes use of it in the colorpicker effect. Not yet added to screenshot effect as for that we need support for skip close animation on the on-screen-message window. Reviewers: #plasma, #kwin Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D3803
2016-12-23 16:39:12 +00:00
[effects] Use arg="true" in the kcfg files Summary: By changing all kcfg to have arg="true" we can pass in the same KSharedConfigPtr into all effects. This allows to have fake config in the tests and in the planned effect demo mode. Also it means that we don't have to hardcode the name kwinrc into the files. In the configs - where we cannot access the effectshandler - we use the define KWIN_CONFIG which gets generated based on the compile time arguments. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D3571
2016-12-02 19:27:43 +00:00
KSharedConfigPtr config() const override;
Add a KSharedConfigPtr for kcminputrc to KWin::Application Summary: There are a few places where KWin needs to read values from kcminputrc. As I need to add yet another one it makes more sense to properly structure it like in other cases and have only one kcminputrc hold in the application. This also allows to better mock the config values in the integration tests. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5540
2017-04-19 15:00:02 +00:00
KSharedConfigPtr inputConfig() const override;
[effects] Use arg="true" in the kcfg files Summary: By changing all kcfg to have arg="true" we can pass in the same KSharedConfigPtr into all effects. This allows to have fake config in the tests and in the planned effect demo mode. Also it means that we don't have to hardcode the name kwinrc into the files. In the configs - where we cannot access the effectshandler - we use the define KWIN_CONFIG which gets generated based on the compile time arguments. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D3571
2016-12-02 19:27:43 +00:00
[kwineffects] Pass screen projection matrix to EffectFrame Exposes the current screen projection matrix in the render pass of the EffectFrame, so that effects can make use of it.
2015-12-03 08:50:40 +00:00
Scene *scene() const {
return m_scene;
}
Be consistent about touch point id type: use qint32 Summary: There is no point in using quint32 and casting back and forth in numerous places. Fix a bunch of compiler warnings that we implicitly cast between signed and unsigned. This makes things consistent with what we get from libinput. Reviewers: #kwin, romangg Reviewed By: #kwin, romangg Subscribers: zzag, romangg, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D23086
2019-08-11 19:57:45 +00:00
bool touchDown(qint32 id, const QPointF &pos, quint32 time);
bool touchMotion(qint32 id, const QPointF &pos, quint32 time);
bool touchUp(qint32 id, quint32 time);
Add support for touch events in the Effect system Summary: The Effect class is extended by three new virtual methods: * touchDown * touchMotion * touchUp The methods return a boolean value so that the events can be filtered out. E.g. an effect which has also a mouse grab installed wants to filter out all events, other effects don't need the events exclusively. This is a difference to how e.g. keyboard and pointer events are handled. But is more close to how KWin's internal input event passing works and makes it easier to get touch event: one does not explicitly has to grab the events. It's also closer to Wayland where all input events are available. As a first example the Present Windows effect is adjusted and allows to activate windows through the touch screen. As much code as possible is shared with pointer input. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2450
2016-08-15 13:44:10 +00:00
Support highlighting windows through EffectsHandlerImpl Summary: So far TabBox used highlight windows by passing window ids around through an X property. This doesn't work on Wayland where we don't have window ids for our TabBox and the Wayland windows. This change introduces a new Effect::Feature for HighlightWindows which the HighlightWindowsEffect provides. The EffectsHandlerImpl has a new method to highlightWindows which it delegates to that effect if it is loaded by invoking a new performFeature method. The TabBoxHandler now passes the highlighting to the effects system instead of updating the x11 property. Thus this works on Wayland and at the same time improves the X11 side by no longer having to go through the property protocol. Test Plan: Verified that Alt+Tab highlights the windows on Wayland correctly. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2630
2016-08-30 13:50:31 +00:00
void highlightWindows(const QVector<EffectWindow *> &windows);
Add a dedicated X11EventFilter for forwarding property events to the effect system Summary: So far both Workspace and Toplevel emitted signals for every property notify event on the root window and the respective Toplevel windows. The signals were only used in EffectsHandlerImpl to forward to the effect system in case the property which changed is registered by an effect. This change introduces a dedicated event filter for this which is only created in EffectsHandlerImpl in case an X11 connection is available. It supports a restart of the X11 system. The signals used so far are removed from Workspace and Toplevel. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D7853
2017-09-16 17:25:33 +00:00
bool isPropertyTypeRegistered(xcb_atom_t atom) const {
return registered_atoms.contains(atom);
}
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 16:52:26 +00:00
void windowToDesktops(EffectWindow *w, const QVector<uint> &desktops) override;
[wayland] add enter/leave virtual desktop API Summary: As setDesktop was changed to "move" this left unSetDesktop non-symetric. This replaces it with explicit API to enter/leave. This also moves new API to the new object based API rather than still using ints. Where numbers are used it has been tidied up so that desktop IDs are uint, which should be used when we have a list of desktops. int is used only when we have either a desktop ID or NET::OnAllDesktops (-1) Effects API cleared up to use this and use a set of x11 IDs, which avoids any potential complications of handling add and removes any ambiguity with what happens if you leave all desktops and such. Test Plan: testVirtualDesktops passes (with pending kwayland patch) Moving a window in the desktop grid on X11 behaves Moving a window in the desktop grid on wayland behaves Reviewers: #kwin, zzag Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D16704
2018-11-13 16:18:46 +00:00
Make sure that effect windows outlive effects Summary: Compositing is suspended/finished in a very hard way fashion, effect windows are destroyed without notifying effects about it. AnimationEffect tries gracefully release deleted windows, but because in some cases(like when suspending compositing) a deleted window can be already destroyed, a segmentation fault can happen. This change adjusts the order in which effect windows and effects are destroyed, so AnimationEffect (and other effects) cannot access dangling pointers. BUG: 400788 FIXED-IN: 5.15.0 Reviewers: #kwin, graesslin Reviewed By: #kwin, graesslin Subscribers: graesslin, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D17311
2018-12-01 16:23:37 +00:00
/**
* Finds an effect with the given name.
*
* @param name The name of the effect.
* @returns The effect with the given name @p name, or nullptr if there
* is no such effect loaded.
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 18:58:33 +00:00
*/
Make sure that effect windows outlive effects Summary: Compositing is suspended/finished in a very hard way fashion, effect windows are destroyed without notifying effects about it. AnimationEffect tries gracefully release deleted windows, but because in some cases(like when suspending compositing) a deleted window can be already destroyed, a segmentation fault can happen. This change adjusts the order in which effect windows and effects are destroyed, so AnimationEffect (and other effects) cannot access dangling pointers. BUG: 400788 FIXED-IN: 5.15.0 Reviewers: #kwin, graesslin Reviewed By: #kwin, graesslin Subscribers: graesslin, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D17311
2018-12-01 16:23:37 +00:00
Effect *findEffect(const QString &name) const;
[libkwineffects] Introduce API to easily show a QtQuick scene in an effect Summary: EffectQuickView/Scene is a convenient class to render a QtQuick scenegraph into an effect. Current methods (such as present windows) involve creating an underlying platform window which is expensive, causes a headache to filter out again in the rest of the code, and only works as an overlay. The new class exposes things more natively to an effect where we don't mess with real windows, we can perform the painting anywhere in the view and we don't have issues with hiding/closing. QtQuick has both software and hardware accelerated modes, and kwin also has 3 render backends. Every combination is supported. * When used in OpenGL mode for both, we render into an FBO export the texture ID then it's up to the effect to render that into a scene. * When using software QtQuick rendering we blit into an image, upload that into a KWinGLTexture which serves as an abstraction layer and render that into the scene. * When using GL for QtQuick and XRender/QPainter in kwin everything is rendered into the internal FBO, blit and exported as an image. * When using software rendering for both an image gets passed directly. Mouse and keyboard events can be forwarded, only if the effect intercepts them. The class is meant to be generic enough that we can remove all the QtQuick code from Aurorae. The intention is also to replace EffectFrameImpl using this backend and we can kill all of the EffectFrame code throughout the scenes. The close button in present windows will also be ported to this, simplifiying that code base. Classes that handle the rendering and handling QML are intentionally split so that in the future we can have a declarative effects API create overlays from within the same context. Similar to how one can instantiate windows from a typical QML scene. Notes: I don't like how I pass the kwin GL context from the backends into the effect, but I need something that works with the library separation. It also currently has wayland problem if I create a QOpenGLContext before the QPA is set up with a scene - but I don't have anything better? I know for the EffectFrame we need an API to push things through the effects stack to handle blur/invert etc. Will deal with that when we port the EffectFrame. Test Plan: Used in an effect Reviewers: #kwin, zzag Reviewed By: #kwin, zzag Subscribers: zzag, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D24215
2019-09-27 15:06:37 +00:00
void renderEffectQuickView(EffectQuickView *effectQuickView) const override;
[effects] Add effect to hold the desktop window static after plasmashell quits Summary: When a plasma session quits, the order of plasmashell and clients quitting is undetermined. This looks bad as our desktop background disappears quite early. Rather than changing the real order, we can have kwin reference the last pixmap of any desktop and hold on to it. Lasting till the compositor quits means it stays on the X frontbuffer till X quits and the experience is seamless. Test Plan: Logged out (with relevant other ksmserver patches) Reviewers: #kwin, zzag Reviewed By: #kwin, zzag Subscribers: zzag, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D24864
2019-11-01 17:14:55 +00:00
SessionState sessionState() const override;
Signal for windowUserMovedResize In core a new signal is added for maximizedState change of client. Other function calls remain as direct calls for the moment.
2011-02-28 20:03:13 +00:00
public Q_SLOTS:
fix tabbing BUG: 290959 BUG: 265160 BUG: 229292 BUG: 238279 BUG: 290758 BUG: 222831 BUG: 278275 BUG: 245747 BUG: 230000 BUG: 253697 BUG: 230570 BUG: 265977 BUG: 225337 BUG: 225339 REVIEW: 103855
2012-01-12 06:42:55 +00:00
void slotCurrentTabAboutToChange(EffectWindow* from, EffectWindow* to);
void slotTabAdded(EffectWindow* from, EffectWindow* to);
void slotTabRemoved(EffectWindow* c, EffectWindow* newActiveWindow);
Signal for windowUserMovedResize In core a new signal is added for maximizedState change of client. Other function calls remain as direct calls for the moment.
2011-02-28 20:03:13 +00:00
Splitting up of KWin's global D-Bus interface Two new interfaces are introduced: * org.kde.kwin.Compositing * org.kde.kwin.Effects The Compositing interface is generated from scriptable elements on the KWin::Compositor class and the Compositor is exported as /Compositor. It provides the general Compositing related D-Bus methods like whether the compositor is active and toggling and so on. The Effects interface is generated from scriptable elements on the KWin::EffectsHandlerImpl class and the instance is exported as /Effects. It provides all the effects related D-Bus methods like loading an effect or the list of all effects. This removes the need to have all these methods provided on the global org.kde.KWin interface. For backwards compatibility they are kept, but no longer provided by the Workspace class. Instead a new DBusInterface is generated which wrapps the calls and delegates it to one of our three related Singleton objects: * Workspace * Compositor * EffectsHandlerImpl
2012-08-30 06:20:26 +00:00
// slots for D-Bus interface
Q_SCRIPTABLE void reconfigureEffect(const QString& name);
[kwin] Add a new EffectLoader The EffectLoader is a subclass of AbstractEffectLoader delegating all methods to instances of: * BuiltInEffectLoader * ScriptedEffectLoader * PluginEffectLoader It's used by the EffectsHandlerImpl and replaces the complete Effect loading mechanism we so far found in it. This also means that KLibrary is no longer needed to load the Effects as the PluginEffectLoader uses the KPluginTrader, which removes lots of deprecated functionality. REVIEW: 117054
2014-03-25 12:43:56 +00:00
Q_SCRIPTABLE bool loadEffect(const QString& name);
Splitting up of KWin's global D-Bus interface Two new interfaces are introduced: * org.kde.kwin.Compositing * org.kde.kwin.Effects The Compositing interface is generated from scriptable elements on the KWin::Compositor class and the Compositor is exported as /Compositor. It provides the general Compositing related D-Bus methods like whether the compositor is active and toggling and so on. The Effects interface is generated from scriptable elements on the KWin::EffectsHandlerImpl class and the instance is exported as /Effects. It provides all the effects related D-Bus methods like loading an effect or the list of all effects. This removes the need to have all these methods provided on the global org.kde.KWin interface. For backwards compatibility they are kept, but no longer provided by the Workspace class. Instead a new DBusInterface is generated which wrapps the calls and delegates it to one of our three related Singleton objects: * Workspace * Compositor * EffectsHandlerImpl
2012-08-30 06:20:26 +00:00
Q_SCRIPTABLE void toggleEffect(const QString& name);
Q_SCRIPTABLE void unloadEffect(const QString& name);
Q_SCRIPTABLE bool isEffectLoaded(const QString& name) const;
[kwin] Add isEffectSupported method to Effects DBus interface EffectsHandlerImpl::isEffectsSupported performs the check whether the effect with the given name is supported by the current compositor. The check is the following: * if effect is already loaded, it is supported * if the effect cannot be found, it is not supported * if it's a scripted effect, it's always supported * if it's a built-in effect, we ask BuiltInEffects::supported * for all other effects we resolve the library and the supported method The idea behind providing this functionality in the DBus interface is to allow filtering in the effects KCM for the effects which are supported by the current compositor. In addition a areEffectsSupported method is added which takes a list of names and returns a list of bools. REVIEW: 116665
2014-03-09 08:12:09 +00:00
Q_SCRIPTABLE bool isEffectSupported(const QString& name);
Q_SCRIPTABLE QList<bool> areEffectsSupported(const QStringList &names);
Splitting up of KWin's global D-Bus interface Two new interfaces are introduced: * org.kde.kwin.Compositing * org.kde.kwin.Effects The Compositing interface is generated from scriptable elements on the KWin::Compositor class and the Compositor is exported as /Compositor. It provides the general Compositing related D-Bus methods like whether the compositor is active and toggling and so on. The Effects interface is generated from scriptable elements on the KWin::EffectsHandlerImpl class and the instance is exported as /Effects. It provides all the effects related D-Bus methods like loading an effect or the list of all effects. This removes the need to have all these methods provided on the global org.kde.KWin interface. For backwards compatibility they are kept, but no longer provided by the Workspace class. Instead a new DBusInterface is generated which wrapps the calls and delegates it to one of our three related Singleton objects: * Workspace * Compositor * EffectsHandlerImpl
2012-08-30 06:20:26 +00:00
Q_SCRIPTABLE QString supportInformation(const QString& name) const;
add effect debug interface and dbus export allows for effect specific debugging details REVIEW: 107063
2012-10-27 21:35:19 +00:00
Q_SCRIPTABLE QString debug(const QString& name, const QString& parameter = QString()) const;
Splitting up of KWin's global D-Bus interface Two new interfaces are introduced: * org.kde.kwin.Compositing * org.kde.kwin.Effects The Compositing interface is generated from scriptable elements on the KWin::Compositor class and the Compositor is exported as /Compositor. It provides the general Compositing related D-Bus methods like whether the compositor is active and toggling and so on. The Effects interface is generated from scriptable elements on the KWin::EffectsHandlerImpl class and the instance is exported as /Effects. It provides all the effects related D-Bus methods like loading an effect or the list of all effects. This removes the need to have all these methods provided on the global org.kde.KWin interface. For backwards compatibility they are kept, but no longer provided by the Workspace class. Instead a new DBusInterface is generated which wrapps the calls and delegates it to one of our three related Singleton objects: * Workspace * Compositor * EffectsHandlerImpl
2012-08-30 06:20:26 +00:00
EffectsHandler emits desktopChanged signal The first signal used between EffectsHandler and Effects. The signal is actually emitted by the EffectsHandlerImpl and only the interested effects connect to this signal. EffectsHandlerImpl itself is also notified by a signal from Workspace, allowing to remove one of the many if (effects) checks.
2011-02-25 19:41:10 +00:00
protected Q_SLOTS:
Delay added signal and other signal bindings for synced windows until the window is actually visually shown Makes animations of showing windows run completely and thus appear smoother REVIEW: 103742
2012-01-24 16:00:40 +00:00
void slotClientShown(KWin::Toplevel*);
Rename ShellClient to XdgShellClient Summary: Rename ShellClient to XdgShellClient in order to reflect that it represents only xdg-shell clients. Test Plan: Compiles, tests still pass. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D23589
2019-08-30 21:36:58 +00:00
void slotXdgShellClientShown(KWin::Toplevel*);
delay adding Unmanaged clients by 50ms This provides some sort of synthetic XSYNC support for unmanaged clients and allows them to do an initial update after mapping and before being painted (prevent flicker) Also it helps with Unmanaged clients performing quick map/unmap/map cycles what also seems to induce the black window issue on the nvidia blob. CCBUG: 284888 BUG: 319184 FIXED-IN: 4.11 REVIEW: 111292
2013-06-28 12:23:22 +00:00
void slotUnmanagedShown(KWin::Toplevel*);
Only emit EffectsHandler::windowClosed if Deleted got created Ensures that Effects cannot ref a window during tear down and then abort because there is no Deleted for the EffectWindow.
2015-11-09 15:27:15 +00:00
void slotWindowClosed(KWin::Toplevel *c, KWin::Deleted *d);
Move clientMaximizedStateChanged signal from Client to AbstractClient
2015-06-07 01:17:34 +00:00
void slotClientMaximized(KWin::AbstractClient *c, MaximizeMode maxMode);
WindowOpacityChanged becomes a signal
2011-03-06 09:30:23 +00:00
void slotOpacityChanged(KWin::Toplevel *t, qreal oldOpacity);
Hook modalChanged signal for DialogParent script Eg. gtk+ alters the modality after mapping and before unmapping the window. Therfore the former implementation ahd a wrong idea about the modality until the window was activated and again had a wrong idea when the dialog closed, keeping the main client dimmed. Modality changes at runtime are uncommon but legal and can happen anytime. BUG: 321340 FIXED-IN: 4.11 REVIEW: 111154
2013-06-19 14:26:55 +00:00
void slotClientModalityChanged();
Make mothod windowGeometryShapeChanged() a slot The method windowGeometryShapeChanged() from the class Scene is now a slot. It is now connected to the signal geometryShapeChanged() which is sent from Toplevel instances Client and Unmanaged. All direct method calls were deleted.
2011-06-19 20:07:19 +00:00
void slotGeometryShapeChanged(KWin::Toplevel *t, const QRect &old);
restrict animationeffect repaints REVIEW: 103932
2012-03-24 21:42:29 +00:00
void slotPaddingChanged(KWin::Toplevel *t, const QRect &old);
WindowDamaged becomes a signal
2011-03-12 14:04:22 +00:00
void slotWindowDamaged(KWin::Toplevel *t, const QRect& r);
EffectsHandler emits desktopChanged signal The first signal used between EffectsHandler and Effects. The signal is actually emitted by the EffectsHandlerImpl and only the interested effects connect to this signal. EffectsHandlerImpl itself is also notified by a signal from Workspace, allowing to remove one of the many if (effects) checks.
2011-02-25 19:41:10 +00:00
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
protected:
forward cursorshape changes to effectshandler CCBUG: 322088 REVIEW: 122468
2015-02-07 16:12:53 +00:00
void connectNotify(const QMetaMethod &signal) override;
void disconnectNotify(const QMetaMethod &signal) override;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
void effectsChanged();
Merge setting up client and shell client connections in EffectsHandlerImpl The signals operate on AbstractClient nowadays, so we can have one implementation for both Client and ShellClient. Only X specific connections are only done for Client.
2015-10-26 09:43:36 +00:00
void setupAbstractClientConnections(KWin::AbstractClient *c);
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 08:48:08 +00:00
void setupClientConnections(KWin::X11Client *c);
Move connection code to Client and unmanged into own method --Code Duplication
2011-03-06 10:13:11 +00:00
void setupUnmanagedConnections(KWin::Unmanaged *u);
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
Move X11-only specific part of EffectsHandlerImpl to x11 platform plugin Summary: The Platform API is extended by a call to create the EffectsHandler. In X11 standalone Platform a new EffectsHandlerImplX11 is added which contains the X11 only parts of the EffectsHandler, such as grabbing the X keyboard and the X11 mouse interception window. The EffectsHandlerImpl gains some virtual methods for the parts which are now done in the X11 specific implementation. In return we get rid of lots of if-else structures checking for the operation mode. Test Plan: Only compile tested. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D7955
2017-09-23 18:21:26 +00:00
/**
* Default implementation does nothing and returns @c true.
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 18:58:33 +00:00
*/
Move X11-only specific part of EffectsHandlerImpl to x11 platform plugin Summary: The Platform API is extended by a call to create the EffectsHandler. In X11 standalone Platform a new EffectsHandlerImplX11 is added which contains the X11 only parts of the EffectsHandler, such as grabbing the X keyboard and the X11 mouse interception window. The EffectsHandlerImpl gains some virtual methods for the parts which are now done in the X11 specific implementation. In return we get rid of lots of if-else structures checking for the operation mode. Test Plan: Only compile tested. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D7955
2017-09-23 18:21:26 +00:00
virtual bool doGrabKeyboard();
/**
* Default implementation does nothing.
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 18:58:33 +00:00
*/
Move X11-only specific part of EffectsHandlerImpl to x11 platform plugin Summary: The Platform API is extended by a call to create the EffectsHandler. In X11 standalone Platform a new EffectsHandlerImplX11 is added which contains the X11 only parts of the EffectsHandler, such as grabbing the X keyboard and the X11 mouse interception window. The EffectsHandlerImpl gains some virtual methods for the parts which are now done in the X11 specific implementation. In return we get rid of lots of if-else structures checking for the operation mode. Test Plan: Only compile tested. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D7955
2017-09-23 18:21:26 +00:00
virtual void doUngrabKeyboard();
/**
* Default implementation sets Effects override cursor on the PointerInputRedirection.
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 18:58:33 +00:00
*/
Move X11-only specific part of EffectsHandlerImpl to x11 platform plugin Summary: The Platform API is extended by a call to create the EffectsHandler. In X11 standalone Platform a new EffectsHandlerImplX11 is added which contains the X11 only parts of the EffectsHandler, such as grabbing the X keyboard and the X11 mouse interception window. The EffectsHandlerImpl gains some virtual methods for the parts which are now done in the X11 specific implementation. In return we get rid of lots of if-else structures checking for the operation mode. Test Plan: Only compile tested. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D7955
2017-09-23 18:21:26 +00:00
virtual void doStartMouseInterception(Qt::CursorShape shape);
/**
* Default implementation removes the Effects override cursor on the PointerInputRedirection.
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 18:58:33 +00:00
*/
Move X11-only specific part of EffectsHandlerImpl to x11 platform plugin Summary: The Platform API is extended by a call to create the EffectsHandler. In X11 standalone Platform a new EffectsHandlerImplX11 is added which contains the X11 only parts of the EffectsHandler, such as grabbing the X keyboard and the X11 mouse interception window. The EffectsHandlerImpl gains some virtual methods for the parts which are now done in the X11 specific implementation. In return we get rid of lots of if-else structures checking for the operation mode. Test Plan: Only compile tested. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D7955
2017-09-23 18:21:26 +00:00
virtual void doStopMouseInterception();
/**
* Default implementation does nothing
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 18:58:33 +00:00
*/
Move X11-only specific part of EffectsHandlerImpl to x11 platform plugin Summary: The Platform API is extended by a call to create the EffectsHandler. In X11 standalone Platform a new EffectsHandlerImplX11 is added which contains the X11 only parts of the EffectsHandler, such as grabbing the X keyboard and the X11 mouse interception window. The EffectsHandlerImpl gains some virtual methods for the parts which are now done in the X11 specific implementation. In return we get rid of lots of if-else structures checking for the operation mode. Test Plan: Only compile tested. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D7955
2017-09-23 18:21:26 +00:00
virtual void doCheckInputWindowStacking();
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
Effect* keyboard_grab_effect;
Effect* fullscreen_effect;
QList<EffectWindow*> elevated_windows;
QMultiMap< int, EffectPair > effect_order;
QHash< long, int > registered_atoms;
int next_window_quad_type;
Only call active effects in the effect chain Each effect is able to declare itself as currently being active, that is transforming windows or painting or screen or doing anything during the current rendered frame. This change eliminates the hottest path inside KWin identified by callgrind. REVIEW: 102449
2011-08-27 09:21:31 +00:00
private:
[libkwineffects] Remove EffectsHandler::registerPropertyType Summary: There is no effect using this method. As it's X11 specific it should be removed. Internally the EffectsHandlerImpl still requires the method. Thus it's moved into the private part. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3297
2016-11-07 14:57:00 +00:00
void registerPropertyType(long atom, bool reg);
[effects] Make current OpenGL context per each unloaded effect Summary: Some effects may release the current context when they tear down, so we have to make the current context per each unloaded effect. BUG: 396830 FIXED-IN: 5.15.0 Test Plan: No longer able to reproduce bug 396830. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: davidedmundson, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D17716
2018-12-19 14:44:06 +00:00
void destroyEffect(Effect *effect);
Use QVector instead of QList for the list of active effects We only append to the list, so the advantage of insertion into QList does not matter. Thanks to Milian Wolff to point this out in his Akademy talk [1] and for pointing me to Marc Mutz blog post [2] discussing this topic and recommending the usage of QVector over QList. [1] http://milianw.de/files/apps-on-speed-akademy2013/index.html [2] http://marcmutz.wordpress.com/effective-qt/containers/ REVIEW: 111597
2013-07-19 09:46:42 +00:00
typedef QVector< Effect*> EffectsList;
Use const_iterators for our Effect iterators We never modify the list, so we don't need the mutuable iterator. This ensures that the data doesn't get detached.
2013-07-19 09:34:01 +00:00
typedef EffectsList::const_iterator EffectsIterator;
Use QVector instead of QList for the list of active effects We only append to the list, so the advantage of insertion into QList does not matter. Thanks to Milian Wolff to point this out in his Akademy talk [1] and for pointing me to Marc Mutz blog post [2] discussing this topic and recommending the usage of QVector over QList. [1] http://milianw.de/files/apps-on-speed-akademy2013/index.html [2] http://marcmutz.wordpress.com/effective-qt/containers/ REVIEW: 111597
2013-07-19 09:46:42 +00:00
EffectsList m_activeEffects;
Use const_iterators for our Effect iterators We never modify the list, so we don't need the mutuable iterator. This ensures that the data doesn't get detached.
2013-07-19 09:34:01 +00:00
EffectsIterator m_currentDrawWindowIterator;
EffectsIterator m_currentPaintWindowIterator;
EffectsIterator m_currentPaintEffectFrameIterator;
EffectsIterator m_currentPaintScreenIterator;
EffectsIterator m_currentBuildQuadsIterator;
Common way to announce support for specific effects through X11 Instead of each effect, which needs to announce support, having custom code to create a property and set it on the root window, there is now a common API in EffectsHandler to take care of this. The methods takes care of creating the atom if it has not already done and set the property on the root window. Furthermore it allows multiple effects to announce the same property without getting in conflict with each other. As a further convenience the property is automatically removed when the effect is unloaded, so less things an effect author has to care about. REVIEW: 107815
2012-12-13 23:09:47 +00:00
typedef QHash< QByteArray, QList< Effect*> > PropertyEffectMap;
PropertyEffectMap m_propertiesForEffects;
QHash<QByteArray, qulonglong> m_managedProperties;
Pass Compositor to EffectsHandlerImpl Obsoletes the need to go through the Workspace object to get to the Compositor. TODO for future: make the Compositor being the parent object for the EffectsHandlerImpl. Closing Review and bug from this commit, which is the top most of the patch series. REVIEW: 106060 BUG: 299277 FIXED-IN: 4.10
2012-08-23 16:04:36 +00:00
Compositor *m_compositor;
Make the Scene owned by the Compositor The Scene has always been created and destroyed inside what is now the split out compositor. Which means it is actually owned by the Compositor. The static pointer has never been needed inside KWin core. Access to the Scene is not required for the Window Manager. The only real usage is in the EffectsHandlerImpl and in utils.h to provide a convenient way to figure out whether compositing is currently active (scene != NULL). The EffectsHandlerImpl gets also created by the Compositor after the Scene is created and gets deleted just before the Scene gets deleted. This allows to inject the Scene into the EffectsHandlerImpl to resolve the static access in this class. The convenient way to access the compositing() in utils.h had to go. To provide the same feature the Compositor provides a hasScene() access which has the same behavior as the old method. In order to keep the code changes small in Workspace and Toplevel a new method compositing() is defined which properly resolves the state. A disadvantage is that this can no longer be inlined and consists of several method calls and pointer checks.
2012-08-16 19:19:54 +00:00
Scene *m_scene;
Effects Hook to paint a desktop A specialised paintScreen method to render all windows of one desktop. It's intended to be called during an already started paintScreen process to get e.g. a thumbnail of a desktop. Currently not yet exported to the Effects.
2012-03-29 18:12:34 +00:00
bool m_desktopRendering;
int m_currentRenderedDesktop;
Change the way how effects can get mouse events With the removal of BoxSwitch all effects which want mouse events use the fullscreen input window. The available functionality is too complex both in EffectsHandler and in the Effects. With this change only fullscreen input windows are supported and all effects share the input window. This means there is at maximum one input window. This simplifies the code in the Effects as they don't have to keep track of the window they created any more. In EffectsHandler it means that only one window needs to be created, destroyed and raised. Also it means that we can properly react on screen size changes which had been ignored in the past. Also quite some roundtrips to X are no longer needed as we do not need to query the window geometry when creating the input window. REVIEW: 110156
2013-04-24 14:51:04 +00:00
QList<Effect*> m_grabbedMouseEffects;
Keep KWin responsive while loading all effects Loading all effects during startup can take some time[1] and during that time the screen is frozen as the loading blocks the compositor. This change doesn't load effects directly but puts them into a queue. The loading is controlled by invoking the dequeue through a queued connection. Thus we get a firing compositing timer in between and can ensure that a frame is rendered when needed and also react to X events during the loading. [1] On my high-end system the set of effects I use take about 200 msec to load. REVIEW: 115297
2014-01-24 14:42:40 +00:00
EffectLoader *m_effectLoader;
forward cursorshape changes to effectshandler CCBUG: 322088 REVIEW: 122468
2015-02-07 16:12:53 +00:00
int m_trackingCursorChanges;
Add a dedicated X11EventFilter for forwarding property events to the effect system Summary: So far both Workspace and Toplevel emitted signals for every property notify event on the root window and the respective Toplevel windows. The signals were only used in EffectsHandlerImpl to forward to the effect system in case the property which changed is registered by an effect. This change introduces a dedicated event filter for this which is only created in EffectsHandlerImpl in case an X11 connection is available. It supports a restart of the X11 system. The signals used so far are removed from Workspace and Toplevel. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D7853
2017-09-16 17:25:33 +00:00
std::unique_ptr<WindowPropertyNotifyX11Filter> m_x11WindowPropertyNotify;
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
};
EffectWindow becomes a QObject
2011-12-29 09:31:37 +00:00
class EffectWindowImpl : public EffectWindow
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
{
Window Thumbnail support for QML A new QML item "ThumbnailItem" is registered to the TabBox. The C++ implementation finds the EffectWindow of the TabBox and adds itself to the EffectWindow. While rendering the EffectWindow the information for all registered ThumbnailItems are extracted and the thumbnail is rendered on top of the EffectWindow. This has obvious limitations like you cannot put other QML items on top of the thumbnail. Nevertheless it works well enough to be a possible replacement for e.g. BoxSwitch effect. When compositing is disabled an icon is rendered instead of the Thumbnail. One TabBox Layout inspired by BoxSwitch Effect is added. For the KCM small pre-rendered items are used. REVIEW: 103039
2011-11-10 13:28:06 +00:00
Q_OBJECT
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
public:
Mark most ctors as explicit as reported by Krazy2 checker
2012-12-29 06:34:38 +00:00
explicit EffectWindowImpl(Toplevel *toplevel);
[libkwineffects] Replace property name lookup with calling the virtual methods Summary: EffectWindow proxies its properties from the client/deleted's properties. QObject::property(char*) is a slow string search. It's a loop of string comparisons not a hash lookup! QML's use of properties is different, there's a property cache. It's fetched multiple times for every window in every paint of some effects (such as blur). Hotspot shows this as a significant amount of the render pass (X11) with nothing in kwin animating. This patch replaces the macro that does parent()->property("propertyName") with a macro calling the relevant function directly without metaobjects. This also improves type safety for future changes. Test Plan: Existing unit tests Ran it for a bit Reviewers: #kwin, graesslin Subscribers: graesslin, zzag, broulik, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D16602
2018-11-30 09:58:45 +00:00
~EffectWindowImpl() override;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
[kwin] Add override to virtual methods in EffectWindow(Group)Impl In exchange the virtual keyword is removed - we don't need both.
2014-02-27 11:07:41 +00:00
void enablePainting(int reason) override;
void disablePainting(int reason) override;
bool isPaintingEnabled() override;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
[libkwineffects] Port the remaining bits of API to dynamic dispatch Summary: 7834bec52a6770b16087be07a94cca6a165482a6 missed to port minimize and unminimize to dynamic dispatch. In addition to that, we don't benefit from QMetaObject::invokeMethod so port addRepaint and addLayerRepaint to dynamic dispatch as well. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: davidedmundson, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D18049
2019-01-07 16:29:00 +00:00
void addRepaint(const QRect &r) override;
void addRepaint(int x, int y, int w, int h) override;
void addRepaintFull() override;
void addLayerRepaint(const QRect &r) override;
void addLayerRepaint(int x, int y, int w, int h) override;
[kwin] Add override to virtual methods in EffectWindow(Group)Impl In exchange the virtual keyword is removed - we don't need both.
2014-02-27 11:07:41 +00:00
void refWindow() override;
void unrefWindow() override;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
[kwin] Add override to virtual methods in EffectWindow(Group)Impl In exchange the virtual keyword is removed - we don't need both.
2014-02-27 11:07:41 +00:00
const EffectWindowGroup* group() const override;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
[libkwineffects] Replace property name lookup with calling the virtual methods Summary: EffectWindow proxies its properties from the client/deleted's properties. QObject::property(char*) is a slow string search. It's a loop of string comparisons not a hash lookup! QML's use of properties is different, there's a property cache. It's fetched multiple times for every window in every paint of some effects (such as blur). Hotspot shows this as a significant amount of the render pass (X11) with nothing in kwin animating. This patch replaces the macro that does parent()->property("propertyName") with a macro calling the relevant function directly without metaobjects. This also improves type safety for future changes. Test Plan: Existing unit tests Ran it for a bit Reviewers: #kwin, graesslin Subscribers: graesslin, zzag, broulik, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D16602
2018-11-30 09:58:45 +00:00
bool isDeleted() const override;
bool isMinimized() const override;
double opacity() const override;
bool hasAlpha() const override;
QStringList activities() const override;
int desktop() const override;
QVector<uint> desktops() const override;
int x() const override;
int y() const override;
int width() const override;
int height() const override;
QSize basicUnit() const override;
QRect geometry() const override;
QString caption() const override;
QRect expandedGeometry() const override;
[kwin] Add override to virtual methods in EffectWindow(Group)Impl In exchange the virtual keyword is removed - we don't need both.
2014-02-27 11:07:41 +00:00
QRegion shape() const override;
[libkwineffects] Replace property name lookup with calling the virtual methods Summary: EffectWindow proxies its properties from the client/deleted's properties. QObject::property(char*) is a slow string search. It's a loop of string comparisons not a hash lookup! QML's use of properties is different, there's a property cache. It's fetched multiple times for every window in every paint of some effects (such as blur). Hotspot shows this as a significant amount of the render pass (X11) with nothing in kwin animating. This patch replaces the macro that does parent()->property("propertyName") with a macro calling the relevant function directly without metaobjects. This also improves type safety for future changes. Test Plan: Existing unit tests Ran it for a bit Reviewers: #kwin, graesslin Subscribers: graesslin, zzag, broulik, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D16602
2018-11-30 09:58:45 +00:00
int screen() const override;
bool hasOwnShape() const override; // only for shadow effect, for now
QPoint pos() const override;
QSize size() const override;
QRect rect() const override;
bool isMovable() const override;
bool isMovableAcrossScreens() const override;
bool isUserMove() const override;
bool isUserResize() const override;
QRect iconGeometry() const override;
bool isDesktop() const override;
bool isDock() const override;
bool isToolbar() const override;
bool isMenu() const override;
bool isNormalWindow() const override;
bool isSpecialWindow() const override;
bool isDialog() const override;
bool isSplash() const override;
bool isUtility() const override;
bool isDropdownMenu() const override;
bool isPopupMenu() const override;
bool isTooltip() const override;
bool isNotification() const override;
Support CriticalNotification type and place it in a CriticalNotificationLayer Differential Revision: https://phabricator.kde.org/D20629
2019-05-02 08:29:38 +00:00
bool isCriticalNotification() const override;
[libkwineffects] Replace property name lookup with calling the virtual methods Summary: EffectWindow proxies its properties from the client/deleted's properties. QObject::property(char*) is a slow string search. It's a loop of string comparisons not a hash lookup! QML's use of properties is different, there's a property cache. It's fetched multiple times for every window in every paint of some effects (such as blur). Hotspot shows this as a significant amount of the render pass (X11) with nothing in kwin animating. This patch replaces the macro that does parent()->property("propertyName") with a macro calling the relevant function directly without metaobjects. This also improves type safety for future changes. Test Plan: Existing unit tests Ran it for a bit Reviewers: #kwin, graesslin Subscribers: graesslin, zzag, broulik, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D16602
2018-11-30 09:58:45 +00:00
bool isOnScreenDisplay() const override;
bool isComboBox() const override;
bool isDNDIcon() const override;
bool skipsCloseAnimation() const override;
bool acceptsFocus() const override;
bool keepAbove() const override;
bool keepBelow() const override;
bool isModal() const override;
bool isPopupWindow() 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;
[libkwineffects] Replace property name lookup with calling the virtual methods Summary: EffectWindow proxies its properties from the client/deleted's properties. QObject::property(char*) is a slow string search. It's a loop of string comparisons not a hash lookup! QML's use of properties is different, there's a property cache. It's fetched multiple times for every window in every paint of some effects (such as blur). Hotspot shows this as a significant amount of the render pass (X11) with nothing in kwin animating. This patch replaces the macro that does parent()->property("propertyName") with a macro calling the relevant function directly without metaobjects. This also improves type safety for future changes. Test Plan: Existing unit tests Ran it for a bit Reviewers: #kwin, graesslin Subscribers: graesslin, zzag, broulik, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D16602
2018-11-30 09:58:45 +00:00
KWayland::Server::SurfaceInterface *surface() const override;
bool isFullScreen() const override;
bool isUnresponsive() const override;
QRect contentsRect() const override;
bool decorationHasAlpha() const override;
QIcon icon() const override;
QString windowClass() const override;
NET::WindowType windowType() const override;
bool isSkipSwitcher() const override;
bool isCurrentTab() const override;
QString windowRole() const override;
bool isManaged() const override;
bool isWaylandClient() const override;
bool isX11Client() const override;
[EffectWindow] Expose PID to effects Differential Revision: https://phabricator.kde.org/D24222
2019-09-26 12:54:33 +00:00
pid_t pid() const override;
[kwin] Add override to virtual methods in EffectWindow(Group)Impl In exchange the virtual keyword is removed - we don't need both.
2014-02-27 11:07:41 +00:00
QRect decorationInnerRect() const override;
QByteArray readProperty(long atom, long type, int format) const override;
void deleteProperty(long atom) const override;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
[kwin] Add override to virtual methods in EffectWindow(Group)Impl In exchange the virtual keyword is removed - we don't need both.
2014-02-27 11:07:41 +00:00
EffectWindow* findModal() override;
EffectWindowList mainWindows() const override;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
[kwin] Add override to virtual methods in EffectWindow(Group)Impl In exchange the virtual keyword is removed - we don't need both.
2014-02-27 11:07:41 +00:00
WindowQuadList buildQuads(bool force = false) const override;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
[libkwineffects] Port the remaining bits of API to dynamic dispatch Summary: 7834bec52a6770b16087be07a94cca6a165482a6 missed to port minimize and unminimize to dynamic dispatch. In addition to that, we don't benefit from QMetaObject::invokeMethod so port addRepaint and addLayerRepaint to dynamic dispatch as well. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: davidedmundson, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D18049
2019-01-07 16:29:00 +00:00
void minimize() override;
void unminimize() override;
void closeWindow() override;
[kwin] Add override to virtual methods in EffectWindow(Group)Impl In exchange the virtual keyword is removed - we don't need both.
2014-02-27 11:07:41 +00:00
void referencePreviousWindowPixmap() override;
void unreferencePreviousWindowPixmap() override;
Introduce cross-fading with previous pixmap Cross fading with previous pixmap is achieved by referencing the old window pixmap. WindowPaintData has a cross-fade-factor which interpolates between 0.0 (completely old pixmap) to 1.0 (completely new pixmap). If a cross fading factor is set and a previous pixmap is valid this one is rendered on top of the current pixmap with opacity adjusted. This results in a smoother fading. To simplify the setup the AnimationEffect is extended and also takes care about correctly (un)referencing the previous window pixmap. The maximize effect is adjusted to make use of this new capabilities. Unfortunately this setup has a huge problem with the case that the window decoration gets smaller (e.g. from normal to maximized state). In this situation it can happen that the old window is rendered with parts outside the content resulting in video garbage being shown. To prevent this a set of new WindowQuads is generated with normalized texture coordinates in the safe area which contains real content. For OpenGL2Window a PreviousContentLeaf is added which is only set up in case the crass fading factor is set. REVIEW: 110578
2013-05-13 06:17:28 +00:00
Add windowsystem plugin for KWin's qpa Summary: KWindowSystem provides a plugin interface to have platform specific implementations. So far KWin relied on the implementation in KWayland-integration repository. This is something I find unsuited, for the following reasons: * any test in KWin for functionality set through the plugin would fail * it's not clear what's going on where * in worst case some code could deadlock * KWin shouldn't use KWindowSystem and only a small subset is allowed to be used The last point needs some further explanation. KWin internally does not and cannot use KWindowSystem. KWindowSystem (especially KWindowInfo) is exposing information which KWin sets. It's more than weird if KWin asks KWindowSystem for the state of a window it set itself. On X11 it's just slow, on Wayland it can result in roundtrips to KWin itself which is dangerous. But due to using Plasma components we have a few areas where we use KWindowSystem. E.g. a Plasma::Dialog sets a window type, the slide in direction, blur and background contrast. This we want to support and need to support. Other API elements we do not want, like for examples the available windows. KWin internal windows either have direct access to KWin or a scripting interface exposed providing (limited) access - there is just no need to have this in KWindowSystem. To make it more clear what KWin supports as API of KWindowSystem for internal windows this change implements a stripped down version of the kwayland-integration plugin. The main difference is that it does not use KWayland at all, but a QWindow internal side channel. To support this EffectWindow provides an accessor for internalWindow and the three already mentioned effects are adjusted to read from the internal QWindow and it's dynamic properties. This change is a first step for a further refactoring. I plan to split the internal window out of ShellClient into a dedicated class. I think there are nowadays too many special cases. If it moves out there is the question whether we really want to use Wayland for the internal windows or whether this is just historic ballast (after all we used to use qwayland for that in the beginning). As the change could introduce regressions I'm targetting 5.16. Test Plan: new test case for window type, manual testing using Alt+Tab for the effects integration. Sliding popups, blur and contrast worked fine. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D18228
2019-01-13 16:50:32 +00:00
QWindow *internalWindow() const override;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
const Toplevel* window() const;
Toplevel* window();
void setWindow(Toplevel* w); // internal
void setSceneWindow(Scene::Window* w); // internal
const Scene::Window* sceneWindow() const; // internal
Scene::Window* sceneWindow(); // internal
Add an elevate() method to Toplevel Shortcut to set an elevated window without the need to check whether effects pointer is valid and retrieving EffectWindow etc. REVIEW: 110147
2013-04-24 08:46:34 +00:00
void elevate(bool elevate);
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 16:52:26 +00:00
void setData(int role, const QVariant &data) override;
QVariant data(int role) const override;
Window Thumbnail support for QML A new QML item "ThumbnailItem" is registered to the TabBox. The C++ implementation finds the EffectWindow of the TabBox and adds itself to the EffectWindow. While rendering the EffectWindow the information for all registered ThumbnailItems are extracted and the thumbnail is rendered on top of the EffectWindow. This has obvious limitations like you cannot put other QML items on top of the thumbnail. Nevertheless it works well enough to be a possible replacement for e.g. BoxSwitch effect. When compositing is disabled an icon is rendered instead of the Thumbnail. One TabBox Layout inspired by BoxSwitch Effect is added. For the KCM small pre-rendered items are used. REVIEW: 103039
2011-11-10 13:28:06 +00:00
Refactoring: break out a base class for ThumbnailItem Everything that has nothing to do with rendering the window thumbnail goes into an AbstractThumbnailItem. This is a preparation step for adding a DesktopThumbnailItem.
2012-03-29 13:32:41 +00:00
void registerThumbnail(AbstractThumbnailItem *item);
Remove usage of QWeakPointer for QObject for thumbnails Summary: This usage of QWeakPointer has been deprecated since Qt 5.0, since it leads to really confusing API - usually you must never dereference a QWeakPointer directly, but always go through QSharedPointer, except in this one case, where it's permissible. The thumbnails are only referenced in one place, this change is straight-forward. Reviewers: #kwin, romangg Reviewed By: #kwin, romangg Subscribers: romangg, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D23070
2019-08-10 11:31:49 +00:00
QHash<WindowThumbnailItem*, QPointer<EffectWindowImpl> > const &thumbnails() const {
Window Thumbnail support for QML A new QML item "ThumbnailItem" is registered to the TabBox. The C++ implementation finds the EffectWindow of the TabBox and adds itself to the EffectWindow. While rendering the EffectWindow the information for all registered ThumbnailItems are extracted and the thumbnail is rendered on top of the EffectWindow. This has obvious limitations like you cannot put other QML items on top of the thumbnail. Nevertheless it works well enough to be a possible replacement for e.g. BoxSwitch effect. When compositing is disabled an icon is rendered instead of the Thumbnail. One TabBox Layout inspired by BoxSwitch Effect is added. For the KCM small pre-rendered items are used. REVIEW: 103039
2011-11-10 13:28:06 +00:00
return m_thumbnails;
}
Adding a DesktopThumbnailItem declarative item Similar to WindowThumbnailItem for rendering a desktop thumbnail. Uses the new paintDesktop hook. FEATURE: 296067 FIXED-IN: 4.11.0 REVIEW: 104441
2012-03-29 18:17:57 +00:00
QList<DesktopThumbnailItem*> const &desktopThumbnails() const {
return m_desktopThumbnails;
}
[libkwineffects] Replace property name lookup with calling the virtual methods Summary: EffectWindow proxies its properties from the client/deleted's properties. QObject::property(char*) is a slow string search. It's a loop of string comparisons not a hash lookup! QML's use of properties is different, there's a property cache. It's fetched multiple times for every window in every paint of some effects (such as blur). Hotspot shows this as a significant amount of the render pass (X11) with nothing in kwin animating. This patch replaces the macro that does parent()->property("propertyName") with a macro calling the relevant function directly without metaobjects. This also improves type safety for future changes. Test Plan: Existing unit tests Ran it for a bit Reviewers: #kwin, graesslin Subscribers: graesslin, zzag, broulik, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D16602
2018-11-30 09:58:45 +00:00
Window Thumbnail support for QML A new QML item "ThumbnailItem" is registered to the TabBox. The C++ implementation finds the EffectWindow of the TabBox and adds itself to the EffectWindow. While rendering the EffectWindow the information for all registered ThumbnailItems are extracted and the thumbnail is rendered on top of the EffectWindow. This has obvious limitations like you cannot put other QML items on top of the thumbnail. Nevertheless it works well enough to be a possible replacement for e.g. BoxSwitch effect. When compositing is disabled an icon is rendered instead of the Thumbnail. One TabBox Layout inspired by BoxSwitch Effect is added. For the KCM small pre-rendered items are used. REVIEW: 103039
2011-11-10 13:28:06 +00:00
private Q_SLOTS:
void thumbnailDestroyed(QObject *object);
void thumbnailTargetChanged();
Adding a DesktopThumbnailItem declarative item Similar to WindowThumbnailItem for rendering a desktop thumbnail. Uses the new paintDesktop hook. FEATURE: 296067 FIXED-IN: 4.11.0 REVIEW: 104441
2012-03-29 18:17:57 +00:00
void desktopThumbnailDestroyed(QObject *object);
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
private:
Rename ThumbnailItem to WindowThumbnailItem This is for discrimination from the to be added DesktopThumbnailItem. The name for QML is unchanged to keep the public API stable.
2012-03-29 13:46:53 +00:00
void insertThumbnail(WindowThumbnailItem *item);
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
Toplevel* toplevel;
Scene::Window* sw; // This one is used only during paint pass.
QHash<int, QVariant> dataMap;
Remove usage of QWeakPointer for QObject for thumbnails Summary: This usage of QWeakPointer has been deprecated since Qt 5.0, since it leads to really confusing API - usually you must never dereference a QWeakPointer directly, but always go through QSharedPointer, except in this one case, where it's permissible. The thumbnails are only referenced in one place, this change is straight-forward. Reviewers: #kwin, romangg Reviewed By: #kwin, romangg Subscribers: romangg, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D23070
2019-08-10 11:31:49 +00:00
QHash<WindowThumbnailItem*, QPointer<EffectWindowImpl> > m_thumbnails;
Adding a DesktopThumbnailItem declarative item Similar to WindowThumbnailItem for rendering a desktop thumbnail. Uses the new paintDesktop hook. FEATURE: 296067 FIXED-IN: 4.11.0 REVIEW: 104441
2012-03-29 18:17:57 +00:00
QList<DesktopThumbnailItem*> m_desktopThumbnails;
[libkwineffects] Replace property name lookup with calling the virtual methods Summary: EffectWindow proxies its properties from the client/deleted's properties. QObject::property(char*) is a slow string search. It's a loop of string comparisons not a hash lookup! QML's use of properties is different, there's a property cache. It's fetched multiple times for every window in every paint of some effects (such as blur). Hotspot shows this as a significant amount of the render pass (X11) with nothing in kwin animating. This patch replaces the macro that does parent()->property("propertyName") with a macro calling the relevant function directly without metaobjects. This also improves type safety for future changes. Test Plan: Existing unit tests Ran it for a bit Reviewers: #kwin, graesslin Subscribers: graesslin, zzag, broulik, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D16602
2018-11-30 09:58:45 +00:00
bool managed = false;
bool waylandClient;
bool x11Client;
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
};
class EffectWindowGroupImpl
: public EffectWindowGroup
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
public:
Mark most ctors as explicit as reported by Krazy2 checker
2012-12-29 06:34:38 +00:00
explicit EffectWindowGroupImpl(Group* g);
[kwin] Add override to virtual methods in EffectWindow(Group)Impl In exchange the virtual keyword is removed - we don't need both.
2014-02-27 11:07:41 +00:00
EffectWindowList members() const override;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
private:
Group* group;
};
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
Move SceneXRender into a plugin Summary: First step for loading the compositor Scenes through plugins. The general idea is that we currently needlessly pull in all the Scenes although only one will be used. E.g. on X11 we pull in QPainter, although they are not compatible. On Wayland we pull in XRender although they are not compatible. Furthermore our current Scene creation strategy is not really fault tolerant and can create situations where we don't get a compositor. E.g on fbdev backend the default settings won't work as it does not support OpenGL. Long term I want to tackle those conceptional problems together: we try to load all plugins supported by the current platform till we have a scene which works. Thus on Wayland we don't end up in a situation where we don't have a working compositor because the configuration is bad. To make this possible the switch statement in the Scene needs to go and needs to be replaced by a for loop iterating over all the available scenes on the platform. If we go there it makes sense to replace it directly with a plugin based approach. So this is a change which tackles the problem by first introducing the plugin loading. The xrender based scene (as it's the most simple one) is moved into a plugin. It is first tried to find a scene plugin and only if there is none the existing code is used. Test Plan: Tested all scenes Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D7232
2017-08-10 16:13:42 +00:00
class KWIN_EXPORT EffectFrameImpl
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
: public QObject, public EffectFrame
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
Q_OBJECT
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
public:
explicit EffectFrameImpl(EffectFrameStyle style, bool staticSize = true, QPoint position = QPoint(-1, -1),
Qt::Alignment alignment = Qt::AlignCenter);
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 16:52:26 +00:00
~EffectFrameImpl() override;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
[kwin] Add override to all virtual methods in EffectFrameImpl In exchange virtual keyword is removed.
2014-02-27 11:10:18 +00:00
void free() override;
Add some const & Summary: Won't make things go much faster since everything that was being passed by value is refcounted but still const & is a bit faster than refcounting For shared pointers instead of adding const & we move them into the destination variable saving some cpu usage but at the same time making clear the pointer is being stored by not being const & Reviewers: zzag Reviewed By: zzag Subscribers: zzag, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D25022
2019-10-29 22:04:15 +00:00
void render(const QRegion &region = infiniteRegion(), double opacity = 1.0, double frameOpacity = 1.0) override;
[kwin] Add override to all virtual methods in EffectFrameImpl In exchange virtual keyword is removed.
2014-02-27 11:10:18 +00:00
Qt::Alignment alignment() const override;
void setAlignment(Qt::Alignment alignment) override;
const QFont& font() const override;
void setFont(const QFont& font) override;
const QRect& geometry() const override;
void setGeometry(const QRect& geometry, bool force = false) override;
const QIcon& icon() const override;
void setIcon(const QIcon& icon) override;
const QSize& iconSize() const override;
void setIconSize(const QSize& size) override;
void setPosition(const QPoint& point) override;
const QString& text() const override;
void setText(const QString& text) override;
EffectFrameStyle style() const override {
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
return m_style;
};
Plasma::FrameSvg& frame() {
return m_frame;
}
bool isStatic() const {
return m_static;
Refactoring of EffectFrame: EffectFrame becomes an interface just like EffectsHandler and EffectWindow and a concrete EffectFrameImpl in core. Rendering of the EffectFrame is moved into the scene as Scene::EffectFrame with a concrete implementation in SceneXrender and SceneOpenGL. A factory method for an EffectFrame is added to the EffectsHandler, which is used by the effects. Next step: pass the EffectFrame through all effects, so that effects can transform, blur, invert whatever it. svn path=/trunk/KDE/kdebase/workspace/; revision=1151271
2010-07-18 16:32:37 +00:00
};
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
void finalRender(QRegion region, double opacity, double frameOpacity) const;
[kwin] Add override to all virtual methods in EffectFrameImpl In exchange virtual keyword is removed.
2014-02-27 11:10:18 +00:00
void setShader(GLShader* shader) override {
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
m_shader = shader;
}
[kwin] Add override to all virtual methods in EffectFrameImpl In exchange virtual keyword is removed.
2014-02-27 11:10:18 +00:00
GLShader* shader() const override {
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
return m_shader;
}
[kwin] Add override to all virtual methods in EffectFrameImpl In exchange virtual keyword is removed.
2014-02-27 11:10:18 +00:00
void setSelection(const QRect& selection) override;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
const QRect& selection() const {
return m_selectionGeometry;
}
Plasma::FrameSvg& selectionFrame() {
return m_selection;
}
Drop dependency to libplasma from kwineffects library Since the EffectFrames have been moved into KWin core nothing in the Effects lib actually used Plasma. The only remaining method is moved to core as it's not used in the Effects. The Effects itself still link against Plasma, so nothing changes for them. The Plasma includes in the kwineffects header seemed to pull in quite some additional headers, so the includes in some effects have to be adjusted (most often KConfigGroup). This should speed up the compilation of the library and the effects.
2011-02-17 18:35:08 +00:00
/**
* The foreground text color as specified by the default Plasma theme.
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 18:58:33 +00:00
*/
Plasma::Theme does no longer provide a global static theme Need to hold a pointer instead.
2013-07-22 14:10:47 +00:00
QColor styledTextColor();
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
private Q_SLOTS:
void plasmaThemeChanged();
private:
Q_DISABLE_COPY(EffectFrameImpl) // As we need to use Qt slots we cannot copy this class
void align(QRect &geometry); // positions geometry around m_point respecting m_alignment
void autoResize(); // Auto-resize if not a static size
EffectFrameStyle m_style;
Plasma::FrameSvg m_frame; // TODO: share between all EffectFrames
Plasma::FrameSvg m_selection;
// Position
bool m_static;
QPoint m_point;
Qt::Alignment m_alignment;
QRect m_geometry;
// Contents
QString m_text;
QFont m_font;
[kwin] Use a QIcon in Client for the icons instead of Pixmaps Client used to have dedicated methods for different icon sizes instead of combining all pixmaps into one QIcon. This resulted in various parts of KWin having different access to the icons: * effects only got one pixmap of size 32x32 * decorations only got the 16x16 and 32x32 pixmaps combined into a QIcon * tabbox could request all icon sizes, but only as pixmap Now all sizes are available in one QIcon allowing to easily access the best fitting icon in a given UI.
2013-12-06 13:41:23 +00:00
QIcon m_icon;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
QSize m_iconSize;
QRect m_selectionGeometry;
Scene::EffectFrame* m_sceneFrame;
GLShader* m_shader;
Plasma::Theme does no longer provide a global static theme Need to hold a pointer instead.
2013-07-22 14:10:47 +00:00
Plasma::Theme *m_theme;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
};
Support for keeping a window temporarily at the very top, desktop grid effect raises the window being moved this way. svn path=/trunk/KDE/kdebase/workspace/; revision=667944
2007-05-24 14:41:56 +00:00
inline
Make elevatedWindows() return list of EffectWindow pointers instead of Toplevel ones. This makes it independant of the Toplevel objects and fixes a crash when an elevated window is closed. svn path=/trunk/KDE/kdebase/workspace/; revision=760802
2008-01-13 13:00:15 +00:00
QList<EffectWindow*> EffectsHandlerImpl::elevatedWindows() const
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
ignore elevation list while screen is locked elevated windows would appear above the locker pot. leaking information BUG: 347466
2015-05-10 09:15:16 +00:00
if (isScreenLocked())
return QList<EffectWindow*>();
Support for keeping a window temporarily at the very top, desktop grid effect raises the window being moved this way. svn path=/trunk/KDE/kdebase/workspace/; revision=667944
2007-05-24 14:41:56 +00:00
return elevated_windows;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
Support for keeping a window temporarily at the very top, desktop grid effect raises the window being moved this way. svn path=/trunk/KDE/kdebase/workspace/; revision=667944
2007-05-24 14:41:56 +00:00
[effects] Get xcb_connection_t* and rootWindow through EffectsHandler API So far the effects could just use the connection() and rootWindow() provided by kwinglobals. Thus an internal detail from KWin core is accessed directly. To be more consistent with the rest of the API it's wrapped through the EffectsHandler and with a convenient method in Effect. The connection() is provided as xcbConnection() to free the very generic name connection which could create confusion once we provide a wayland connection to the Effects. The rootWindow() is provided as x11RootWindow() to indicate that it is for the X11 world. REVIEW: 117597
2014-04-16 13:58:06 +00:00
inline
xcb_window_t EffectsHandlerImpl::x11RootWindow() const
{
return rootWindow();
}
inline
xcb_connection_t *EffectsHandlerImpl::xcbConnection() const
{
return connection();
}
Support for keeping a window temporarily at the very top, desktop grid effect raises the window being moved this way. svn path=/trunk/KDE/kdebase/workspace/; revision=667944
2007-05-24 14:41:56 +00:00
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
inline
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
EffectWindowGroupImpl::EffectWindowGroupImpl(Group* g)
: group(g)
{
}
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
EffectWindow* effectWindow(Toplevel* w);
EffectWindow* effectWindow(Scene::Window* w);
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
Make WindowPaintData ctor require an EffectWindow argument, which is used to fill it in. Makes thumbnails work again. svn path=/trunk/KDE/kdebase/workspace/; revision=697961
2007-08-08 14:42:06 +00:00
inline
const Scene::Window* EffectWindowImpl::sceneWindow() const
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
Make WindowPaintData ctor require an EffectWindow argument, which is used to fill it in. Makes thumbnails work again. svn path=/trunk/KDE/kdebase/workspace/; revision=697961
2007-08-08 14:42:06 +00:00
return sw;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
Make WindowPaintData ctor require an EffectWindow argument, which is used to fill it in. Makes thumbnails work again. svn path=/trunk/KDE/kdebase/workspace/; revision=697961
2007-08-08 14:42:06 +00:00
inline
Scene::Window* EffectWindowImpl::sceneWindow()
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
Make WindowPaintData ctor require an EffectWindow argument, which is used to fill it in. Makes thumbnails work again. svn path=/trunk/KDE/kdebase/workspace/; revision=697961
2007-08-08 14:42:06 +00:00
return sw;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
Make WindowPaintData ctor require an EffectWindow argument, which is used to fill it in. Makes thumbnails work again. svn path=/trunk/KDE/kdebase/workspace/; revision=697961
2007-08-08 14:42:06 +00:00
inline
const Toplevel* EffectWindowImpl::window() const
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
Make WindowPaintData ctor require an EffectWindow argument, which is used to fill it in. Makes thumbnails work again. svn path=/trunk/KDE/kdebase/workspace/; revision=697961
2007-08-08 14:42:06 +00:00
return toplevel;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
Make WindowPaintData ctor require an EffectWindow argument, which is used to fill it in. Makes thumbnails work again. svn path=/trunk/KDE/kdebase/workspace/; revision=697961
2007-08-08 14:42:06 +00:00
inline
Toplevel* EffectWindowImpl::window()
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
Make WindowPaintData ctor require an EffectWindow argument, which is used to fill it in. Makes thumbnails work again. svn path=/trunk/KDE/kdebase/workspace/; revision=697961
2007-08-08 14:42:06 +00:00
return toplevel;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
Make WindowPaintData ctor require an EffectWindow argument, which is used to fill it in. Makes thumbnails work again. svn path=/trunk/KDE/kdebase/workspace/; revision=697961
2007-08-08 14:42:06 +00:00
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
} // namespace
#endif
Reference in a new issue Copy permalink