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

811 lines
25 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>
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_TOPLEVEL_H
#define KWIN_TOPLEVEL_H
Cleanup and reorder includes in toplevel.h REVIEW: 110202
2013-04-26 09:27:30 +00:00
// kwin
Redirect pointer events to the Toplevel InputRedirection keeps track of the Toplevel which is currently the one which should get pointer events. This is determined by checking whether there is an Unmanaged or a Client at the pointer position. At the moment this is still slightly incorrect, e.g. pointer grabs are ignored, unmanaged are not checked whether they are output only and input shapes are not yet tracked. The pointer events are delivered to the Toplevel as: * enter * leave * move * button press * axis event Nevertheless move events are still generated in InputRedirection through xcb test for simplicity. They are still send to the root window, so all windows get mouse move. Button press and axis are generated only in the implementations of the event handlers and delivered directly to the window, so other windows won't see it.
2013-07-01 06:37:59 +00:00
#include "input.h"
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
#include "utils.h"
Move handling of Virtual Desktops into a VirtualDesktopManager The ownership for virtual desktops is moved from Workspace into a new VirtualDesktopManager. The manager is responsible for providing the count of virtual desktops and keeping track of the currently used virtual desktop. All methods related to moving between desktops are also moved from Workspace to the new manager, though all methods related to Clients on Virtual Desktops remain in Workspace for the time being. This is to have the new manager as independent from KWin core as possible. An rather important change for the handling of virtual desktops is that the count and the id of a desktop is now an unsinged integer instead of an integer. The reason for that is that we cannot have a negative count of desktops as well as it is not possible to be on a desktop with a negative identifier. In that regard it is important to remember that a Client can be on a desktop with a negative identifier. The special value for a Client being on all desktops is handled by using -1 as a desktop. For the time being this is not adjusted but instead of comparing the virtual desktop ids one should prefer to use the convenient methods like isOnDesktop and isOnAllDesktops. This would allow in future to internally change the representation for on all desktops.
2012-11-16 07:23:47 +00:00
#include "virtualdesktops.h"
Use Xcb::Window wraper for Toplevel::client Uses the new API to not destroy the window in the dtor. At the same time the variable is renamed to m_client to follow the common naming scheme.
2013-09-10 05:09:44 +00:00
#include "xcbutils.h"
Move RootInfo and WinInfo into an own header and impl file Main motivation for this change is that it's unhandy to have the class definition in workspace.h and client.h while the implementation is in events.cpp although nothing in events.cpp uses it directly. By getting it out of workspace.h we get the header a little bit smaller which should improve compile time given that it's included almost everywhere. In events.cpp the enum usage is changed to NETWinInfo as that's the class where they are defined. RootInfo does no longer hold a workspace pointer. Where it's needed it uses the singleton accessor of Workspace. REVIEW: 110199
2013-04-26 08:41:24 +00:00
// KDE
[kwin] Fix includes of NETWM Used kde4support variant.
2014-03-18 13:32:53 +00:00
#include <NETWM>
Cleanup and reorder includes in toplevel.h REVIEW: 110202
2013-04-26 09:27:30 +00:00
// Qt
#include <QObject>
Specify inputTransformation in Toplevel InputRedirection uses the inputTransformation() to pass to SeatInterface for focused pointer surface. This prepares for proper input transformation including scaling and rotation.
2015-12-07 13:25:08 +00:00
#include <QMatrix4x4>
Cleanup and reorder includes in toplevel.h REVIEW: 110202
2013-04-26 09:27:30 +00:00
// xcb
Change Toplevel::damage_handle to xcb_damage_damage_t Damage handling has already been ported to XCB - no need to keep it on an XLib datatype.
2013-04-26 09:12:52 +00:00
#include <xcb/damage.h>
kwin: Use xcb to optimize damage event handling Use XDamageReportNonEmpty instead of XDamageReportRawRectangles. In XDamageReportNonEmpty mode the server generates a single damage event when the damage state transitions from not-damaged to damaged. When the compositor is ready to paint the screen, it requests the damage region for each window and resets the state to not-damaged. With XCB we can request the damage regions for all windows in a single roundtrip, making this the preferred mode. This should reduce the number of wakeups and the time spent processing damage events between repaints.
2012-03-28 18:29:33 +00:00
#include <xcb/xfixes.h>
[kwin] Add XLib includes where still needed No longer included through netwm.
2013-11-18 12:52:38 +00:00
// XLib
#include <X11/Xlib.h>
#include <fixx11h.h>
Cleanup and reorder includes in toplevel.h REVIEW: 110202
2013-04-26 09:27:30 +00:00
// system
#include <assert.h>
Fix compilation with gcc-4.9 Looks like one needs to include <functional> if one uses std::function. Compilation verified with: * gcc-4.8 * gcc-4.9 * clang-3.2
2014-04-29 05:49:54 +00:00
// c++
#include <functional>
kwin: Use xcb to optimize damage event handling Use XDamageReportNonEmpty instead of XDamageReportRawRectangles. In XDamageReportNonEmpty mode the server generates a single damage event when the damage state transitions from not-damaged to damaged. When the compositor is ready to paint the screen, it requests the damage region for each window and resets the state to not-damaged. With XCB we can request the damage regions for all windows in a single roundtrip, making this the preferred mode. This should reduce the number of wakeups and the time spent processing damage events between repaints.
2012-03-28 18:29:33 +00:00
Composite windows from a QOpenGLFramebufferObject This change introduces a mechanism for internal windows to be rendered to a QOpenGLFramebufferObject to be composited using the texture bound to the FBO. This is useful for in-process rendering (e.g. QtQuick) and at the same time bypassing the windowing system. The OpenGL context of the QOpenGLFramebufferObject needs to be sharing with the compositing OpenGL context.
2015-08-18 12:40:26 +00:00
class QOpenGLFramebufferObject;
[wayland] Add a SurfaceInterface to Toplevel Adds the SurfaceInterface identified by the surface id we get from Xwayland. This allows in an easier way to map a Toplevel to a Wayland surface and will also be useful for Wayland clients.
2015-02-09 15:08:53 +00:00
namespace KWayland
{
namespace Server
{
class SurfaceInterface;
}
}
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
{
Improved resolving whether a window is on local machine Most windows use the hostname in WM_CLIENT_MACHINE, but there are windows using the FQDN (for example libreoffice). So instead of "foo" it is "foo.local.net" or similar. The logic so far has been unable to properly determine whether windows with FQDN are on the local system. In order to solve this problem the handling is split out into an own class which stores the information of hostname and whether it is a local machine. This is to not query multiple times. To determine whether the Client is on the local system getaddrinfo is used for the own hostname and the FQDN provided in WM_CLIENT_MACHINE. If one of the queried names matches, we know that it is on the local machine. The old logic to compare the hostname is still used and getaddrinfo is only a fallback in case hostname does not match. The problem with getaddrinfo is, that it accesses the network and by that could block. To circumvent this problem the calls are moved into threads by using QtConcurrent::run. Obviously this brings disadvantages. When trying to resolve whether a Client is on the local machine and a FQDN is used, the information is initially wrong. The new ClientMachine class emits a signal when the information that the system is local becomes available, but for some things this is just too late: * window rules are already gathered * Session Management has already taken place In both cases this is an acceptable loss. For window rules it just needs a proper matching of the machine in case of localhost (remote hosts are not affected). And the case of session management is very academic as it is unlikely that a restoring session contains remote windows. BUG: 308391 FIXED-IN: 4.11 REVIEW: 108235
2013-01-07 07:07:27 +00:00
class ClientMachine;
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 EffectWindowImpl;
Initial implementation of new Shadows in KWin For a complete documentation of new functionality refer to: http://community.kde.org/KWin/Shadow The current implementation includes a new Shadow class and Toplevel holds a pointer to an instance of this class. The Shadow class reads the data from the X11 Property. There is one extended class located in SceneOpenGL to render the shadow. Compositor is adjusted to include the shadow region into the painting passes. Implementation for XRender still missing and Shadow needs to respond to size changes of the Toplevel to update cached shadow region and WindowQuads.
2011-03-27 10:33:07 +00:00
class Shadow;
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
Try to wait for DESTROY_NOTIFY before releasing an Unmanaged So far the Unmanaged got released after an XCB_UNMAP_NOTIFY. This event gets created after xcb_unmap_window or after xcb_destroy_window. In the latter case the window is already distroyed and any of KWin's cleanup calls will cause a BadWindow (or similar) error. The idea to circumvent these errors is to try to wait for the DESTROY_NOTIFY event. To do so the processing of the release is slightly delayed. If KWin gets the destroy notify before the delay times out the Unamanged gets released immediately but with a Destroy flag. For this a new enum ReleaseToplevel is introduced and Unmanage::release takes this as an argument instead of the bool which indicated OnShutdown. Also this enum is added to Toplevel::finishCompositing so that it can ignore the destroyed case and not generate an error. REVIEW: 117422
2014-04-07 14:23:17 +00:00
/**
* Enum to describe the reason why a Toplevel has to be released.
*/
enum class ReleaseReason {
Release, ///< Normal Release after e.g. an Unmap notify event (window still valid)
Destroyed, ///< Release after an Destroy notify event (window no longer valid)
KWinShutsDown ///< Release on KWin Shutdown (window still valid)
};
[autotest/wayland] Add a test for quick tiling Wayland clients Base test verifies the quick tile positions. No maximization or direct state changes tested yet. Required to have Toplevel and AbstractClient exported. Otherwise we cannot use the SignalSpy.
2015-10-14 07:58:16 +00:00
class KWIN_EXPORT Toplevel
Toplevel does not inherit from KDecorationDefines any more As an intermediate step Client inherits from KDecorationDefines.
2014-12-02 10:31:07 +00:00
: public QObject
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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
Q_OBJECT
[wayland] Set depth in ShellClient depending on whether the Buffer has alpha We need to set the depth in order to properly determine whether the Surface has an alpha channel and whether blending needs to be enabled for rendering. For this a new method is introduced in Toplevel to set the depth. If the depth changed in a way that the Toplevel gained or lost the alpha channel a signal is emitted which implies that the hasAlpha property of Toplevel is no longer constant.
2015-06-01 14:25:21 +00:00
Q_PROPERTY(bool alpha READ hasAlpha NOTIFY hasAlphaChanged)
Adding properties to Client and Toplevel class This will make it possible to access Clients in scripting, deco and effects without the wrapper classes through the property system.
2011-12-18 09:29:32 +00:00
Q_PROPERTY(qulonglong frameId READ frameId)
Q_PROPERTY(QRect geometry READ geometry NOTIFY geometryChanged)
restrict animationeffect repaints REVIEW: 103932
2012-03-24 21:42:29 +00:00
Q_PROPERTY(QRect visibleRect READ visibleRect)
Adding properties to Client and Toplevel class This will make it possible to access Clients in scripting, deco and effects without the wrapper classes through the property system.
2011-12-18 09:29:32 +00:00
Q_PROPERTY(int height READ height)
Q_PROPERTY(qreal opacity READ opacity WRITE setOpacity NOTIFY opacityChanged)
Q_PROPERTY(QPoint pos READ pos)
Introduce a proper screen property in Toplevel Instead of calculating the screen number each time screen() is invoked, the screen number gets stored in a private member variable and evaluated whenever either the screen count changes or the Toplevel's geometry changes. During move/resize the screen property doesn't get updated. The update is delayed till the end of the move/resize operation. REVIEW: 109715
2013-03-26 06:45:08 +00:00
Q_PROPERTY(int screen READ screen NOTIFY screenChanged)
Adding properties to Client and Toplevel class This will make it possible to access Clients in scripting, deco and effects without the wrapper classes through the property system.
2011-12-18 09:29:32 +00:00
Q_PROPERTY(QSize size READ size)
Q_PROPERTY(int width READ width)
Make Toplevel::window() no longer virtual and introduce ::windowId() Summary: Toplevel::window() is the actual X11 window. This makes it difficult to use as the generic identifier for both X11 and Wayland. The Wayland ShellClient already had a windowId() which is now added to Toplevel as a virtual method. On X11 (Toplevel default) it returns the window(). The method window() now returns XCB_WINDOW_NONE for classes without the Toplevel::m_client, such as ShellClient. Thus it allows to properly check whether we are on Wayland or X11. The code is adjusted to use windowId where a generic id is needed and to properly check whether the window is valid before using it where a window() is used. This also fixes at least one additional unknown issue in Workspace::setActiveClient where the windowId of a Wayland client was passed to X11. Reviewers: #plasma Subscribers: plasma-devel Projects: #plasma Differential Revision: https://phabricator.kde.org/D1527
2016-05-02 15:47:39 +00:00
Q_PROPERTY(qulonglong windowId READ windowId CONSTANT)
Adding properties to Client and Toplevel class This will make it possible to access Clients in scripting, deco and effects without the wrapper classes through the property system.
2011-12-18 09:29:32 +00:00
Q_PROPERTY(int x READ x)
Q_PROPERTY(int y READ y)
More properties on Toplevel and Client Mostly exporting the getters used by EffectWindow as Properties. In client some have got a notify signal. REVIEW: 103510
2011-12-29 09:19:36 +00:00
Q_PROPERTY(int desktop READ desktop)
Add property onAllDesktops to Toplevel and Client
2012-06-22 07:29:32 +00:00
/**
* Whether the window is on all desktops. That is desktop is -1.
**/
Q_PROPERTY(bool onAllDesktops READ isOnAllDesktops)
More properties on Toplevel and Client Mostly exporting the getters used by EffectWindow as Properties. In client some have got a notify signal. REVIEW: 103510
2011-12-29 09:19:36 +00:00
Q_PROPERTY(QRect rect READ rect)
Q_PROPERTY(QPoint clientPos READ clientPos)
Q_PROPERTY(QSize clientSize READ clientSize)
Get Toplevel::resourceName() and ::resourceClass() from NETWinInfo It's provided by the NETWinInfo, no need to keep an own implementation. To keep compatibility with existing KWin code using the window class or resource it's always converted to lower. In addition a notify signal Toplevel::windowClassChanged is added and emitted from the event handler whenever the WM2WindowClass property is set. REVIEW: 117496
2014-04-11 06:06:26 +00:00
Q_PROPERTY(QByteArray resourceName READ resourceName NOTIFY windowClassChanged)
Q_PROPERTY(QByteArray resourceClass READ resourceClass NOTIFY windowClassChanged)
Get windowRole from NETWinInfo instead doing it ourself NETWinInfo provides windowRole if NET::WM2WindowRole is added to the properties2. Thus KWin doesn't need to monitor and fetch itself, but can just wrap the data provided by NETWinInfo. In addition a signal is added to Toplevel whenever the window role changes. REVIEW: 117470
2014-04-10 09:12:48 +00:00
Q_PROPERTY(QByteArray windowRole READ windowRole NOTIFY windowRoleChanged)
More properties on Toplevel and Client Mostly exporting the getters used by EffectWindow as Properties. In client some have got a notify signal. REVIEW: 103510
2011-12-29 09:19:36 +00:00
/**
* Returns whether the window is a desktop background window (the one with wallpaper).
* See _NET_WM_WINDOW_TYPE_DESKTOP at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
*/
Q_PROPERTY(bool desktopWindow READ isDesktop)
/**
* Returns whether the window is a dock (i.e. a panel).
* See _NET_WM_WINDOW_TYPE_DOCK at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
*/
Q_PROPERTY(bool dock READ isDock)
/**
* Returns whether the window is a standalone (detached) toolbar window.
* See _NET_WM_WINDOW_TYPE_TOOLBAR at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
*/
Q_PROPERTY(bool toolbar READ isToolbar)
/**
* Returns whether the window is a torn-off menu.
* See _NET_WM_WINDOW_TYPE_MENU at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
*/
Q_PROPERTY(bool menu READ isMenu)
/**
* Returns whether the window is a "normal" window, i.e. an application or any other window
* for which none of the specialized window types fit.
* See _NET_WM_WINDOW_TYPE_NORMAL at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
*/
Q_PROPERTY(bool normalWindow READ isNormalWindow)
/**
* Returns whether the window is a dialog window.
* See _NET_WM_WINDOW_TYPE_DIALOG at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
*/
Q_PROPERTY(bool dialog READ isDialog)
/**
* Returns whether the window is a splashscreen. Note that many (especially older) applications
* do not support marking their splash windows with this type.
* See _NET_WM_WINDOW_TYPE_SPLASH at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
*/
Q_PROPERTY(bool splash READ isSplash)
/**
* Returns whether the window is a utility window, such as a tool window.
* See _NET_WM_WINDOW_TYPE_UTILITY at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
*/
Q_PROPERTY(bool utility READ isUtility)
/**
* Returns whether the window is a dropdown menu (i.e. a popup directly or indirectly open
* from the applications menubar).
* See _NET_WM_WINDOW_TYPE_DROPDOWN_MENU at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
*/
Q_PROPERTY(bool dropdownMenu READ isDropdownMenu)
/**
* Returns whether the window is a popup menu (that is not a torn-off or dropdown menu).
* See _NET_WM_WINDOW_TYPE_POPUP_MENU at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
*/
Q_PROPERTY(bool popupMenu READ isPopupMenu)
/**
* Returns whether the window is a tooltip.
* See _NET_WM_WINDOW_TYPE_TOOLTIP at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
*/
Q_PROPERTY(bool tooltip READ isTooltip)
/**
* Returns whether the window is a window with a notification.
* See _NET_WM_WINDOW_TYPE_NOTIFICATION at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
*/
Q_PROPERTY(bool notification READ isNotification)
Add OnScreenDisplayLayer which is placed even ontop of the active fullscreen window It is to be used for volume change feedback and similar confirmation popups REVIEW: 121300
2015-01-02 11:11:54 +00:00
/**
* Returns whether the window is an On Screen Display.
*/
Q_PROPERTY(bool onScreenDisplay READ isOnScreenDisplay)
More properties on Toplevel and Client Mostly exporting the getters used by EffectWindow as Properties. In client some have got a notify signal. REVIEW: 103510
2011-12-29 09:19:36 +00:00
/**
* Returns whether the window is a combobox popup.
* See _NET_WM_WINDOW_TYPE_COMBO at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
*/
Q_PROPERTY(bool comboBox READ isComboBox)
/**
* Returns whether the window is a Drag&Drop icon.
* See _NET_WM_WINDOW_TYPE_DND at http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
*/
Q_PROPERTY(bool dndIcon READ isDNDIcon)
/**
* Returns the NETWM window type
* See http://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
*/
Q_PROPERTY(int windowType READ windowType)
Adding an activitiesChanged signal to Toplevel Only emitted from Client. REVIEW: 109706 BUG: 317366 FIXED-IN: 4.10.3
2013-03-25 14:18:58 +00:00
Q_PROPERTY(QStringList activities READ activities NOTIFY activitiesChanged)
Turn isManaged and isDeleted into properties on Toplevel Property invokes virtual methods returning false by default. Deleted reimplements the isDeleted and returns true. Client returns true for isClient. Method is not called isManaged as this is already used inside Client.
2012-01-15 09:51:09 +00:00
/**
* Whether this Toplevel is managed by KWin (it has control over its placement and other
* aspects, as opposed to override-redirect windows that are entirely handled by the application).
**/
Q_PROPERTY(bool managed READ isClient CONSTANT)
/**
* Whether this Toplevel represents an already deleted window and only kept for the compositor for animations.
**/
Q_PROPERTY(bool deleted READ isDeleted CONSTANT)
Add property shaped for hasOwnShape method Inclusive notify signal.
2012-01-15 10:03:15 +00:00
/**
* Whether the window has an own shape
**/
Q_PROPERTY(bool shaped READ shape NOTIFY shapedChanged)
Allow windows to specify that they should not get animated on window close By setting the X property _KDE_NET_WM_SKIP_CLOSE_ANIMATION to 1 a window can request to be excluded from any close animation. This property is read in Toplevel, so that it is available to both Client and Unmanaged. If the window has this property set the Scene suppresses the paintWindow loop of the Deleted. Thus no effect needs to be adjusted. But an effect using drawWindow directly would still be able to render the Deleted as there is no suppression. Furthermore the property is passed to the EffectWindow so that an Effect can make use of this functionality and not start the animation in the first place. REVIEW: 115288
2014-01-24 11:34:16 +00:00
/**
* Whether the window does not want to be animated on window close.
* There are legit reasons for this like a screenshot application which does not want it's
* window being captured.
**/
Q_PROPERTY(bool skipsCloseAnimation READ skipsCloseAnimation WRITE setSkipCloseAnimation NOTIFY skipCloseAnimationChanged)
[xwayland] Add support for WL_SURFACE_ID When XWayland associates a Wayland surface with an X window it sends a WL_SURFACE_ID client message to the window manager. KWin listens for this client message in Toplevel and provides it as a member in Toplevel. This requires KWin to actually start a Wayland server (and XWayland) to make proper use of the information.
2015-01-09 10:16:57 +00:00
/**
* The Id of the Wayland Surface associated with this Toplevel.
* On X11 only setups the value is @c 0.
**/
Q_PROPERTY(quint32 surfaceId READ surfaceId NOTIFY surfaceIdChanged)
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
/**
* Interface to the Wayland Surface.
* Relevant only in Wayland, in X11 it will be nullptr
*/
Q_PROPERTY(KWayland::Server::SurfaceInterface *surface READ surface)
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
public:
Remove Workspace pointer from Toplevel Instead have a simple workspace() method returning the pointer.
2013-05-08 11:39:06 +00:00
explicit Toplevel();
Toplevel::frameId() becomes virtual The frameId only makes sense for a Client, in case of Unmanaged the same window id is used as for the window() handle. Client creates the frame and destroys it. Given that it makes sense to let Client manage the frame properly. The ::frameId() is therefore virtual and as base implementation it returns the client id. Client reimplements it and returns the proper frame id. Method is also implemented in Deleted as it used to be passed to deleted.
2013-09-10 06:13:33 +00:00
virtual xcb_window_t frameId() const;
Make Toplevel::window() no longer virtual and introduce ::windowId() Summary: Toplevel::window() is the actual X11 window. This makes it difficult to use as the generic identifier for both X11 and Wayland. The Wayland ShellClient already had a windowId() which is now added to Toplevel as a virtual method. On X11 (Toplevel default) it returns the window(). The method window() now returns XCB_WINDOW_NONE for classes without the Toplevel::m_client, such as ShellClient. Thus it allows to properly check whether we are on Wayland or X11. The code is adjusted to use windowId where a generic id is needed and to properly check whether the window is valid before using it where a window() is used. This also fixes at least one additional unknown issue in Workspace::setActiveClient where the windowId of a Wayland client was passed to X11. Reviewers: #plasma Subscribers: plasma-devel Projects: #plasma Differential Revision: https://phabricator.kde.org/D1527
2016-05-02 15:47:39 +00:00
xcb_window_t window() const;
/**
* @return a unique identifier for the Toplevel. On X11 same as @link {window}
**/
virtual quint32 windowId() const;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
QRect geometry() const;
Add support for resize only borders on Wayland Summary: This change adds support for resizing outside the window decoration (e.g. setting borders to NoSide or None). To support this a new Toplevel::inputGeometry() -> QRect method is added which exposes the geometry adjusted by the margins provided by the decoration. This is checked in InputRedirection when finding a Toplevel at a given position. The logic for figuring out whether the event should go to the decoration or the window already handled the situation correctly, so no further changes are needed. BUG: 364607 FIXED-IN: 5.8.1 Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2787
2016-09-15 09:44:32 +00:00
/**
* The geometry of the Toplevel which accepts input events. This might be larger
* than the actual geometry, e.g. to support resizing outside the window.
*
* Default implementation returns same as geometry.
**/
virtual QRect inputGeometry() const;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
QSize size() const;
QPoint pos() const;
QRect rect() const;
int x() const;
int y() const;
int width() const;
int height() const;
bool isOnScreen(int screen) const; // true if it's at least partially there
Split out screen handling from Workspace into own class Screens Following the approaches of other split out functionality Screens is a singleton class created by Workspace. The class takes over the responsibility for: * screenChanged signal delayed by timer * number of screens * geometry of given screen * active screen * config option for active screen follows mouse The class contains a small abstraction layer and has a concrete subclass wrapping around QDesktopWidget, but the idea is to go more low level and interact with XRandR directly to get more detailed information. All over KWin the usage from QDesktopWidget is ported over to the new Screens class. REVIEW: 109839
2013-04-03 10:19:27 +00:00
bool isOnActiveScreen() const;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
int screen() const; // the screen where the center is
virtual QPoint clientPos() const = 0; // inside of geometry()
Introduce a Toplevel::clientContentPos() -> QPoint This describes an additional offset for the client content. On X11 our client content position matches with the window - the window decoration is part of the overall content coordinate system. On Wayland the content is an own texture starting at 0/0. Thus a mapping to texture coordinates will be required when server side decorations are provided. The new information is used in the scene's to adjust the rendering and generating of quads.
2015-12-08 09:11:26 +00:00
/**
* Describes how the client's content maps to the window geometry including the frame.
* The default implementation is a 1:1 mapping meaning the frame is part of the content.
**/
virtual QPoint clientContentPos() const;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
virtual QSize clientSize() const = 0;
virtual QRect visibleRect() const; // the area the window occupies on the screen
virtual QRect decorationRect() const; // rect including the decoration shadows
virtual QRect transparentRect() const = 0;
Turn isManaged and isDeleted into properties on Toplevel Property invokes virtual methods returning false by default. Deleted reimplements the isDeleted and returns true. Client returns true for isClient. Method is not called isManaged as this is already used inside Client.
2012-01-15 09:51:09 +00:00
virtual bool isClient() const;
virtual bool isDeleted() const;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
// prefer isXXX() instead
// 0 for supported types means default for managed/unmanaged types
Toplevel::windowType becomes a pure virtual function The method windowType needs actually two implementations: * one for Clients * one for Unmanaged as for Clients also the window rules are checked and hacks are applied which is both not needed for Unmanaged windows. To have the Client specific behavior in windowType the function used to perform two dynamic_casts which made this method one of the most expensive during compositing, e.g. for ~1000 frames * called ~43000 times * ~85000 dynamic casts * incl. cost of method: 0.24 * self cost of method: 0.05 * incl. cost of the casts: 0.12 After the change to remove the dynamic casts we have for ~1500 frames in Client::windowType: * called ~31000 times * incl. cost of 0.06 * self cost of 0.02 Calls on Unmanaged and Deleted are so low that we do not need to consider them. BUG: 306384 FIXED-IN: 4.10 REVIEW: 106349
2012-09-06 07:09:31 +00:00
virtual NET::WindowType windowType(bool direct = false, int supported_types = 0) const = 0;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
bool hasNETSupport() const;
bool isDesktop() const;
bool isDock() const;
bool isToolbar() const;
bool isMenu() const;
bool isNormalWindow() const; // normal as in 'NET::Normal or NET::Unknown non-transient'
bool isDialog() const;
bool isSplash() const;
bool isUtility() const;
bool isDropdownMenu() const;
bool isPopupMenu() const; // a context popup, not dropdown, not torn-off
bool isTooltip() const;
bool isNotification() const;
Add OnScreenDisplayLayer which is placed even ontop of the active fullscreen window It is to be used for volume change feedback and similar confirmation popups REVIEW: 121300
2015-01-02 11:11:54 +00:00
bool isOnScreenDisplay() const;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
bool isComboBox() const;
bool isDNDIcon() const;
[wayland] Introduce property to identify lockscreen and inputmethods This introduces Toplevel::isLockScreen() and Toplevel::isInputMethod(), this can be used to allow only lockscreen/inputmethods to get input events and shown when screen is locked.
2015-11-16 10:19:38 +00:00
virtual bool isLockScreen() const;
virtual bool isInputMethod() const;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
virtual int desktop() const = 0;
virtual QStringList activities() const = 0;
bool isOnDesktop(int d) const;
bool isOnActivity(const QString &activity) const;
bool isOnCurrentDesktop() const;
bool isOnCurrentActivity() const;
bool isOnAllDesktops() const;
bool isOnAllActivities() const;
Toplevel::windowRole becomes virtual and is copied to Deleted Toplevel::windowRole accesses WinInfo unconditionally causing crashes if we have a Toplevel subclass which doesn't use WinInfo. So let's make it virtual and copy to Deleted.
2015-03-04 07:53:51 +00:00
virtual QByteArray windowRole() const;
move sync dbus calls to kactivitymanagerd into extra thread to prevent broken dbus chain from blocking the compositor CCBUG: 293104 REVIEW: 104563
2012-04-12 19:52:44 +00:00
QByteArray sessionId() const;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
QByteArray resourceName() const;
QByteArray resourceClass() const;
Revert "Remove saving and loading (and client matching by) WM_COMMAND." This reverts commit 2eac7634cc524bf5e425cf081a639a6b6407e380. Cherry-picked from 5.6. CCBUG: 362671
2016-06-23 17:40:40 +00:00
QByteArray wmCommand();
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
QByteArray wmClientMachine(bool use_localhost) const;
Improved resolving whether a window is on local machine Most windows use the hostname in WM_CLIENT_MACHINE, but there are windows using the FQDN (for example libreoffice). So instead of "foo" it is "foo.local.net" or similar. The logic so far has been unable to properly determine whether windows with FQDN are on the local system. In order to solve this problem the handling is split out into an own class which stores the information of hostname and whether it is a local machine. This is to not query multiple times. To determine whether the Client is on the local system getaddrinfo is used for the own hostname and the FQDN provided in WM_CLIENT_MACHINE. If one of the queried names matches, we know that it is on the local machine. The old logic to compare the hostname is still used and getaddrinfo is only a fallback in case hostname does not match. The problem with getaddrinfo is, that it accesses the network and by that could block. To circumvent this problem the calls are moved into threads by using QtConcurrent::run. Obviously this brings disadvantages. When trying to resolve whether a Client is on the local machine and a FQDN is used, the information is initially wrong. The new ClientMachine class emits a signal when the information that the system is local becomes available, but for some things this is just too late: * window rules are already gathered * Session Management has already taken place In both cases this is an acceptable loss. For window rules it just needs a proper matching of the machine in case of localhost (remote hosts are not affected). And the case of session management is very academic as it is unlikely that a restoring session contains remote windows. BUG: 308391 FIXED-IN: 4.11 REVIEW: 108235
2013-01-07 07:07:27 +00:00
const ClientMachine *clientMachine() const;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
Window wmClientLeader() const;
pid_t pid() const;
static bool resourceMatch(const Toplevel* c1, const Toplevel* c2);
bool readyForPainting() const; // true if the window has been already painted its contents
Toplevel::vis becomes Toplevel::m_visual and is xcb_visualid_t Only usage of the ::vis was the visualid, so have this as the member instead of the XVisual*.
2014-04-25 10:06:39 +00:00
xcb_visualid_t visual() const;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
bool shape() const;
[wayland] Add support for input shape Toplevel provides the input shape forwarded from SurfaceInterface. The shape is evaluated in InputRedirection when finding the Toplevel at a given position.
2015-06-18 21:19:13 +00:00
QRegion inputShape() const;
Toplevel::setOpacity becomes virtual It calls unconditionally into NETWinInfo.
2015-03-16 08:13:19 +00:00
virtual void setOpacity(double opacity);
Make Toplevel::opacity virtual and copy it to Deleted Toplevel::opacity() accesses the WinInfo, but for a Wayland client we won't have the opacity through the WinInfo, so let's have it as a virtual method that a subclass can override. Also it needs to be copied to Deleted to not have a Deleted of a Wayland client crash because it accesses the not existing WinInfo.
2015-03-04 06:56:51 +00:00
virtual double opacity() const;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
int depth() const;
bool hasAlpha() const;
Do not perform setupCompositing on Client if Toplevel is not setup Toplevel::setupCompositing returns a boolean value and returns false in the cases where it has not setup compositing. This is used by the specialization on Client to not perform the Client specific setup if Toplevel has not setup. REVIEW: 104767
2012-04-28 07:39:39 +00:00
virtual bool setupCompositing();
Try to wait for DESTROY_NOTIFY before releasing an Unmanaged So far the Unmanaged got released after an XCB_UNMAP_NOTIFY. This event gets created after xcb_unmap_window or after xcb_destroy_window. In the latter case the window is already distroyed and any of KWin's cleanup calls will cause a BadWindow (or similar) error. The idea to circumvent these errors is to try to wait for the DESTROY_NOTIFY event. To do so the processing of the release is slightly delayed. If KWin gets the destroy notify before the delay times out the Unamanged gets released immediately but with a Destroy flag. For this a new enum ReleaseToplevel is introduced and Unmanage::release takes this as an argument instead of the bool which indicated OnShutdown. Also this enum is added to Toplevel::finishCompositing so that it can ignore the destroyed case and not generate an error. REVIEW: 117422
2014-04-07 14:23:17 +00:00
virtual void finishCompositing(ReleaseReason releaseReason = ReleaseReason::Release);
Use invoke method for addRepaint* methods REVIEW: 103567
2012-01-15 10:39:01 +00:00
Q_INVOKABLE void addRepaint(const QRect& r);
Q_INVOKABLE void addRepaint(const QRegion& r);
Q_INVOKABLE void addRepaint(int x, int y, int w, int h);
kwin: move/resize events shall not force a repaint of all layers This patch adds a new function Toplevel::addLayerRepaint, that in contrast to addWorkspaceRepaint does not invalidate every blur texture cache that overlaps with that region. As the name suggests it rather invalidates the to the window associated layer at that position. This is especially useful in the case of move/resize events in combination with oxygen-transparent, where the altered window is almost always the topmost window and the blur texture cache of the windows underneath are unchanged. For the case of fully opaque windows the behaviour of addLayerRepaint and addWorkspaceRepaint should be same. REVIEW: 103906
2012-02-07 16:01:41 +00:00
Q_INVOKABLE void addLayerRepaint(const QRect& r);
Q_INVOKABLE void addLayerRepaint(const QRegion& r);
Q_INVOKABLE void addLayerRepaint(int x, int y, int w, int h);
Use invoke method for addRepaint* methods REVIEW: 103567
2012-01-15 10:39:01 +00:00
Q_INVOKABLE virtual void addRepaintFull();
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
// these call workspace->addRepaint(), but first transform the damage if needed
void addWorkspaceRepaint(const QRect& r);
void addWorkspaceRepaint(int x, int y, int w, int h);
QRegion repaints() const;
kwin: move/resize events shall not force a repaint of all layers This patch adds a new function Toplevel::addLayerRepaint, that in contrast to addWorkspaceRepaint does not invalidate every blur texture cache that overlaps with that region. As the name suggests it rather invalidates the to the window associated layer at that position. This is especially useful in the case of move/resize events in combination with oxygen-transparent, where the altered window is almost always the topmost window and the blur texture cache of the windows underneath are unchanged. For the case of fully opaque windows the behaviour of addLayerRepaint and addWorkspaceRepaint should be same. REVIEW: 103906
2012-02-07 16:01:41 +00:00
void resetRepaints();
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
QRegion damage() const;
Remove damage argument in Toplevel::resetDamage We always reset with the complete window geometry, so the subtracting doesn't make any sense. We can just always set the damage to an empty region. REVIEW: 110438
2013-05-15 11:07:10 +00:00
void resetDamage();
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
EffectWindowImpl* effectWindow();
Move ownership on Shadow from Toplevel to Scene::Window The Shadow is clearly an aspect of the compositor. Therefore the Shadow has to be owned and controlled by the Scene::Window. Nevertheless Toplevel needs to know about the Shadow cause of reading the property.
2011-04-03 09:31:33 +00:00
const EffectWindowImpl* effectWindow() const;
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
/**
* Window will be temporarily painted as if being at the top of the stack.
* Only available if Compositor is active, if not active, this method is a no-op.
**/
void elevate(bool elevate);
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
Initial implementation of new Shadows in KWin For a complete documentation of new functionality refer to: http://community.kde.org/KWin/Shadow The current implementation includes a new Shadow class and Toplevel holds a pointer to an instance of this class. The Shadow class reads the data from the X11 Property. There is one extended class located in SceneOpenGL to render the shadow. Compositor is adjusted to include the shadow region into the painting passes. Implementation for XRender still missing and Shadow needs to respond to size changes of the Toplevel to update cached shadow region and WindowQuads.
2011-03-27 10:33:07 +00:00
/**
* @returns Whether the Toplevel has a Shadow or not
* @see shadow
**/
bool hasShadow() const;
/**
* Returns the pointer to the Toplevel's Shadow. A Shadow
* is only available if Compositing is enabled and the corresponding X window
* has the Shadow property set.
* If a shadow is available @link hasShadow returns @c true.
* @returns The Shadow belonging to this Toplevel, may be @c NULL.
* @see hasShadow
**/
Move ownership on Shadow from Toplevel to Scene::Window The Shadow is clearly an aspect of the compositor. Therefore the Shadow has to be owned and controlled by the Scene::Window. Nevertheless Toplevel needs to know about the Shadow cause of reading the property.
2011-04-03 09:31:33 +00:00
const Shadow *shadow() const;
Shadow *shadow();
/**
* Updates the Shadow associated with this Toplevel from X11 Property.
* Call this method when the Property changes or Compositing is started.
**/
void getShadow();
Allow Client to disable the rendering of DecorationShadow For maximized and fullscreen windows we don't want the shadow to be renderer at all.
2014-07-24 06:55:57 +00:00
/**
* Whether the Toplevel currently wants the shadow to be rendered. Default
* implementation always returns @c true.
**/
virtual bool wantsShadowToBeRendered() const;
Initial implementation of new Shadows in KWin For a complete documentation of new functionality refer to: http://community.kde.org/KWin/Shadow The current implementation includes a new Shadow class and Toplevel holds a pointer to an instance of this class. The Shadow class reads the data from the X11 Property. There is one extended class located in SceneOpenGL to render the shadow. Compositor is adjusted to include the shadow region into the painting passes. Implementation for XRender still missing and Shadow needs to respond to size changes of the Toplevel to update cached shadow region and WindowQuads.
2011-03-27 10:33:07 +00:00
kwin: implement _KDE_NET_WM_OPAQUE_REGION This patch implements an XProperty named _KDE_NET_WM_OPAQUE_REGION which gives the compositor the information which part of a window is opaque although it is an ARGB visual. The basic ideas are from http://www.mail-archive.com/wm-spec-list@gnome.org/msg00715.html Additionally the patch makes kwin use this information to do a better clipping in Scene::paintSimpleScreen which should result in a higher performance. REVIEW: 102933
2011-10-22 09:02:49 +00:00
/**
* This method returns the area that the Toplevel window reports to be opaque.
Fix typos SVN_SILENT
2012-01-01 08:26:27 +00:00
* It is supposed to only provide valuable information if @link hasAlpha is @c true .
kwin: implement _KDE_NET_WM_OPAQUE_REGION This patch implements an XProperty named _KDE_NET_WM_OPAQUE_REGION which gives the compositor the information which part of a window is opaque although it is an ARGB visual. The basic ideas are from http://www.mail-archive.com/wm-spec-list@gnome.org/msg00715.html Additionally the patch makes kwin use this information to do a better clipping in Scene::paintSimpleScreen which should result in a higher performance. REVIEW: 102933
2011-10-22 09:02:49 +00:00
* @see hasAlpha
**/
const QRegion& opaqueRegion() const;
Move Client::layer() to Toplevel This allows to copy the layer to the deleted window in order to keep the deleted window in the same layer. Additionally a new layer is added for unmanaged windows.
2012-04-07 14:43:27 +00:00
virtual Layer layer() const = 0;
kwin: Use xcb to optimize damage event handling Use XDamageReportNonEmpty instead of XDamageReportRawRectangles. In XDamageReportNonEmpty mode the server generates a single damage event when the damage state transitions from not-damaged to damaged. When the compositor is ready to paint the screen, it requests the damage region for each window and resets the state to not-damaged. With XCB we can request the damage regions for all windows in a single roundtrip, making this the preferred mode. This should reduce the number of wakeups and the time spent processing damage events between repaints.
2012-03-28 18:29:33 +00:00
/**
* Resets the damage state and sends a request for the damage region.
* A call to this function must be followed by a call to getDamageRegionReply(),
* or the reply will be leaked.
*
* Returns true if the window was damaged, and false otherwise.
*/
bool resetAndFetchDamage();
/**
* Gets the reply from a previous call to resetAndFetchDamage().
* Calling this function is a no-op if there is no pending reply.
* Call damage() to return the fetched region.
*/
void getDamageRegionReply();
Allow windows to specify that they should not get animated on window close By setting the X property _KDE_NET_WM_SKIP_CLOSE_ANIMATION to 1 a window can request to be excluded from any close animation. This property is read in Toplevel, so that it is available to both Client and Unmanaged. If the window has this property set the Scene suppresses the paintWindow loop of the Deleted. Thus no effect needs to be adjusted. But an effect using drawWindow directly would still be able to render the Deleted as there is no suppression. Furthermore the property is passed to the EffectWindow so that an Effect can make use of this functionality and not start the animation in the first place. REVIEW: 115288
2014-01-24 11:34:16 +00:00
bool skipsCloseAnimation() const;
void setSkipCloseAnimation(bool set);
[xwayland] Add support for WL_SURFACE_ID When XWayland associates a Wayland surface with an X window it sends a WL_SURFACE_ID client message to the window manager. KWin listens for this client message in Toplevel and provides it as a member in Toplevel. This requires KWin to actually start a Wayland server (and XWayland) to make proper use of the information.
2015-01-09 10:16:57 +00:00
quint32 surfaceId() const;
[wayland] Add a SurfaceInterface to Toplevel Adds the SurfaceInterface identified by the surface id we get from Xwayland. This allows in an easier way to map a Toplevel to a Wayland surface and will also be useful for Wayland clients.
2015-02-09 15:08:53 +00:00
KWayland::Server::SurfaceInterface *surface() const;
void setSurface(KWayland::Server::SurfaceInterface *surface);
[xwayland] Add support for WL_SURFACE_ID When XWayland associates a Wayland surface with an X window it sends a WL_SURFACE_ID client message to the window manager. KWin listens for this client message in Toplevel and provides it as a member in Toplevel. This requires KWin to actually start a Wayland server (and XWayland) to make proper use of the information.
2015-01-09 10:16:57 +00:00
Composite windows from a QOpenGLFramebufferObject This change introduces a mechanism for internal windows to be rendered to a QOpenGLFramebufferObject to be composited using the texture bound to the FBO. This is useful for in-process rendering (e.g. QtQuick) and at the same time bypassing the windowing system. The OpenGL context of the QOpenGLFramebufferObject needs to be sharing with the compositing OpenGL context.
2015-08-18 12:40:26 +00:00
virtual void setInternalFramebufferObject(const QSharedPointer<QOpenGLFramebufferObject> &fbo);
const QSharedPointer<QOpenGLFramebufferObject> &internalFramebufferObject() const;
Specify inputTransformation in Toplevel InputRedirection uses the inputTransformation() to pass to SeatInterface for focused pointer surface. This prepares for proper input transformation including scaling and rotation.
2015-12-07 13:25:08 +00:00
/**
* @returns Transformation to map from global to window coordinates.
*
* Default implementation returns a translation on negative pos().
* @see pos
**/
virtual QMatrix4x4 inputTransformation() const;
[kwin] Use std::find_if and lambda functions for Workspace::findUnmanaged Instead of passing the macro based Predicate to findUnmanaged it now expects a function which can be passed to std::find_if. Existing code like: xcb_window_t window; // our test window Unmanaged *u = findUnmanaged(WindowMatchPredicated(window)); becomes: Unmanaged *u = findUnmanaged([window](const Unmanaged *u) { return u->window() == window; }); In addition an overload is added which takes the window id to cover the common case to search for an Unmanaged by its ID. The above example becomes: Unmanaged *u = findUnmanaged(window); The advantage is that it is way more flexible and has the logic what to check for directly with the code and not hidden in the macro definition.
2014-03-20 06:52:18 +00:00
/**
* @brief Finds the Toplevel matching the condition expressed in @p func in @p list.
*
* The method is templated to operate on either a list of Toplevels or on a list of
* a subclass type of Toplevel.
* @param list The list to search in
* @param func The condition function (compare std::find_if)
* @return T* The found Toplevel or @c null if there is no matching Toplevel
*/
Add Workspace::findToplevel Like findClient and findUnmanaged, just a little bit more generic. Toplevel::findInList got adjusted to support it.
2015-02-09 15:07:30 +00:00
template <class T, class U>
static T *findInList(const QList<T*> &list, std::function<bool (const U*)> func);
[kwin] Use std::find_if and lambda functions for Workspace::findUnmanaged Instead of passing the macro based Predicate to findUnmanaged it now expects a function which can be passed to std::find_if. Existing code like: xcb_window_t window; // our test window Unmanaged *u = findUnmanaged(WindowMatchPredicated(window)); becomes: Unmanaged *u = findUnmanaged([window](const Unmanaged *u) { return u->window() == window; }); In addition an overload is added which takes the window id to cover the common case to search for an Unmanaged by its ID. The above example becomes: Unmanaged *u = findUnmanaged(window); The advantage is that it is way more flexible and has the logic what to check for directly with the code and not hidden in the macro definition.
2014-03-20 06:52:18 +00:00
Use Q_SLOTS and Q_SIGNALS instead of slots and signals Fixes compilation with Qt5/KF5 setup.
2013-07-22 14:07:39 +00:00
Q_SIGNALS:
WindowOpacityChanged becomes a signal
2011-03-06 09:30:23 +00:00
void opacityChanged(KWin::Toplevel* toplevel, qreal oldOpacity);
WindowDamaged becomes a signal
2011-03-12 14:04:22 +00:00
void damaged(KWin::Toplevel* toplevel, const QRect& damage);
PropertyNotify becomes a signal
2011-03-12 18:18:19 +00:00
void propertyNotify(KWin::Toplevel* toplevel, long a);
Update cached Shadow information on size changes In order to notice when the geometry changes a new signal is added to toplevel and both Unmanaged and Client connect all their signals which are emitted whenever the geometry changes in some way to this new signal. Shadow connects to the signal and updates the quads and region whenever the size changes.
2011-04-03 10:43:57 +00:00
void geometryChanged();
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 geometryShapeChanged(KWin::Toplevel* toplevel, const QRect& old);
restrict animationeffect repaints REVIEW: 103932
2012-03-24 21:42:29 +00:00
void paddingChanged(KWin::Toplevel* toplevel, const QRect& old);
Merge signals clientClosed() and unmanagedClosed() to windowClosed() This commit merges the two signals clientClosed() and unmanagedClosed() to windowClosed() which is now provided by Toplevel. The approriate slots in effects.h and effects.cpp were merges as well, since they did the same. The direct method calls of the method windowClosed() in SceneOpenGL and SceneXRender were removed and are now connected to the appropriate signal in windowAdded().
2011-06-21 11:52:25 +00:00
void windowClosed(KWin::Toplevel* toplevel, KWin::Deleted* deleted);
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 windowShown(KWin::Toplevel* toplevel);
Add a signal Toplevel::windowHidden Signal is connected in ScriptingModel together with windowShown.
2015-06-10 15:45:59 +00:00
void windowHidden(KWin::Toplevel* toplevel);
Add property shaped for hasOwnShape method Inclusive notify signal.
2012-01-15 10:03:15 +00:00
/**
* Signal emitted when the window's shape state changed. That is if it did not have a shape
* and received one or if the shape was withdrawn. Think of Chromium enabling/disabling KWin's
* decoration.
**/
void shapedChanged();
Use signals'n'slots instead of deep function call into Compositor For most actions where the compositor needs to perform an action (e.g. scheduling another repaint) signals were already emitted. So it's easier to just connect the signals to the Compositor which in turn makes the code much more readable. All signals are connected from the Workspace when either the Compositor gets constructed or a Toplevel gets created.
2012-08-23 11:42:59 +00:00
/**
* Emitted whenever the state changes in a way, that the Compositor should
* schedule a repaint of the scene.
**/
void needsRepaint();
Adding an activitiesChanged signal to Toplevel Only emitted from Client. REVIEW: 109706 BUG: 317366 FIXED-IN: 4.10.3
2013-03-25 14:18:58 +00:00
void activitiesChanged(KWin::Toplevel* toplevel);
Introduce a proper screen property in Toplevel Instead of calculating the screen number each time screen() is invoked, the screen number gets stored in a private member variable and evaluated whenever either the screen count changes or the Toplevel's geometry changes. During move/resize the screen property doesn't get updated. The update is delayed till the end of the move/resize operation. REVIEW: 109715
2013-03-26 06:45:08 +00:00
/**
* Emitted whenever the Toplevel's screen changes. This can happen either in consequence to
* a screen being removed/added or if the Toplevel's geometry changes.
* @since 4.11
**/
void screenChanged();
Allow windows to specify that they should not get animated on window close By setting the X property _KDE_NET_WM_SKIP_CLOSE_ANIMATION to 1 a window can request to be excluded from any close animation. This property is read in Toplevel, so that it is available to both Client and Unmanaged. If the window has this property set the Scene suppresses the paintWindow loop of the Deleted. Thus no effect needs to be adjusted. But an effect using drawWindow directly would still be able to render the Deleted as there is no suppression. Furthermore the property is passed to the EffectWindow so that an Effect can make use of this functionality and not start the animation in the first place. REVIEW: 115288
2014-01-24 11:34:16 +00:00
void skipCloseAnimationChanged();
Get windowRole from NETWinInfo instead doing it ourself NETWinInfo provides windowRole if NET::WM2WindowRole is added to the properties2. Thus KWin doesn't need to monitor and fetch itself, but can just wrap the data provided by NETWinInfo. In addition a signal is added to Toplevel whenever the window role changes. REVIEW: 117470
2014-04-10 09:12:48 +00:00
/**
* Emitted whenever the window role of the window changes.
* @since 5.0
**/
void windowRoleChanged();
Get Toplevel::resourceName() and ::resourceClass() from NETWinInfo It's provided by the NETWinInfo, no need to keep an own implementation. To keep compatibility with existing KWin code using the window class or resource it's always converted to lower. In addition a notify signal Toplevel::windowClassChanged is added and emitted from the event handler whenever the WM2WindowClass property is set. REVIEW: 117496
2014-04-11 06:06:26 +00:00
/**
* Emitted whenever the window class name or resource name of the window changes.
* @since 5.0
**/
void windowClassChanged();
[xwayland] Add support for WL_SURFACE_ID When XWayland associates a Wayland surface with an X window it sends a WL_SURFACE_ID client message to the window manager. KWin listens for this client message in Toplevel and provides it as a member in Toplevel. This requires KWin to actually start a Wayland server (and XWayland) to make proper use of the information.
2015-01-09 10:16:57 +00:00
/**
* Emitted when a Wayland Surface gets associated with this Toplevel.
* @since 5.3
**/
void surfaceIdChanged(quint32);
[wayland] Set depth in ShellClient depending on whether the Buffer has alpha We need to set the depth in order to properly determine whether the Surface has an alpha channel and whether blending needs to be enabled for rendering. For this a new method is introduced in Toplevel to set the depth. If the depth changed in a way that the Toplevel gained or lost the alpha channel a signal is emitted which implies that the hasAlpha property of Toplevel is no longer constant.
2015-06-01 14:25:21 +00:00
/**
* @since 5.4
**/
void hasAlphaChanged();
Introduce a proper screen property in Toplevel Instead of calculating the screen number each time screen() is invoked, the screen number gets stored in a private member variable and evaluated whenever either the screen count changes or the Toplevel's geometry changes. During move/resize the screen property doesn't get updated. The update is delayed till the end of the move/resize operation. REVIEW: 109715
2013-03-26 06:45:08 +00:00
Update Keyboard focus when the Surface of the active client changes Summary: For XWayland windows the window might be activated before the Wayland Surface is set for it. Thus the keyboard focus is not passed to the window. Only on the next activate after the window got created the window got keyboard focus. This change addresses this problem by emitting a signal from Toplevel when the surface changes. The KeyboardInput listens to this signal for the active client and updates keyboard focus again if the surface changes. Thus keyboard focus is properly passed to XWayland windows. Test Plan: Test case which creates an X11 window is adjusted to verify the condition. Reviewers: #plasma_on_wayland, #kwin Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2009
2016-06-26 13:57:38 +00:00
/**
* Emitted whenever the Surface for this Toplevel changes.
**/
void surfaceChanged();
Introduce a proper screen property in Toplevel Instead of calculating the screen number each time screen() is invoked, the screen number gets stored in a private member variable and evaluated whenever either the screen count changes or the Toplevel's geometry changes. During move/resize the screen property doesn't get updated. The update is delayed till the end of the move/resize operation. REVIEW: 109715
2013-03-26 06:45:08 +00:00
protected Q_SLOTS:
/**
* Checks whether the screen number for this Toplevel changed and updates if needed.
* Any method changing the geometry of the Toplevel should call this method.
**/
void checkScreen();
void setupCheckScreenConnection();
void removeCheckScreenConnection();
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 setReadyForPainting();
WindowOpacityChanged becomes a signal
2011-03-06 09:30:23 +00:00
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
protected:
virtual ~Toplevel();
Toplevel::frameId() becomes virtual The frameId only makes sense for a Client, in case of Unmanaged the same window id is used as for the window() handle. Client creates the frame and destroys it. Given that it makes sense to let Client manage the frame properly. The ::frameId() is therefore virtual and as base implementation it returns the client id. Client reimplements it and returns the proper frame id. Method is also implemented in Deleted as it used to be passed to deleted.
2013-09-10 06:13:33 +00:00
void setWindowHandles(xcb_window_t client);
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
void detectShape(Window id);
Enable property notify event handling in Client and Unmanaged
2013-07-26 11:17:23 +00:00
virtual void propertyNotifyEvent(xcb_property_notify_event_t *e);
Remove XDamageNotifyEvent* argument from Toplevel::damageNotifyEvent It's not used... REVIEW: 110201
2013-04-26 09:00:08 +00:00
virtual void damageNotifyEvent();
[xwayland] Add support for WL_SURFACE_ID When XWayland associates a Wayland surface with an X window it sends a WL_SURFACE_ID client message to the window manager. KWin listens for this client message in Toplevel and provides it as a member in Toplevel. This requires KWin to actually start a Wayland server (and XWayland) to make proper use of the information.
2015-01-09 10:16:57 +00:00
virtual void clientMessageEvent(xcb_client_message_event_t *e);
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
void discardWindowPixmap();
void addDamageFull();
[wayland] Handle damage events from SurfaceInterface On Wayland we get the damage from the SurfaceInterface instead of using a damage handle. This change ensures that the damage handle interaction is only used on platform X11, while on Wayland we get the damage from the SurfaceInterface directly.
2015-02-24 09:54:28 +00:00
virtual void addDamage(const QRegion &damage);
Split Toplevel::getWmClientLeader in two parts First part (fetch) just creates the Xcb::Property while the second part (read) reads the property. This allows to better schedule the commands in Client::manage to reduce the number of roundtrips. This reduces the time spent for fetching the client leader property by about half a millisecond on my system.
2015-01-15 13:33:28 +00:00
Xcb::Property fetchWmClientLeader() const;
void readWmClientLeader(Xcb::Property &p);
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
void getWmClientLeader();
void getWmClientMachine();
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
/**
* @returns Whether there is a compositor and it is active.
**/
bool compositing() const;
kwin: implement _KDE_NET_WM_OPAQUE_REGION This patch implements an XProperty named _KDE_NET_WM_OPAQUE_REGION which gives the compositor the information which part of a window is opaque although it is an ARGB visual. The basic ideas are from http://www.mail-archive.com/wm-spec-list@gnome.org/msg00715.html Additionally the patch makes kwin use this information to do a better clipping in Scene::paintSimpleScreen which should result in a higher performance. REVIEW: 102933
2011-10-22 09:02:49 +00:00
/**
* This function fetches the opaque region from this Toplevel.
* Will only be called on corresponding property changes and for initialization.
**/
void getWmOpaqueRegion();
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
void getResourceClass();
[wayland] Pass appId to PlasmaWindow interface For the appId we use: * wl_shell windowClass for Wayland clients * resourceName from window class for X11 clients This is implemented by sharing the window class implementation in Toplevel. CCMAIL: hein@kde.org
2015-07-20 07:37:36 +00:00
void setResourceClass(const QByteArray &name, const QByteArray &className = QByteArray());
Split Toplevel::getSkipCloseAnimation into two parts
2015-01-15 14:19:04 +00:00
Xcb::Property fetchSkipCloseAnimation() const;
void readSkipCloseAnimation(Xcb::Property &prop);
Allow windows to specify that they should not get animated on window close By setting the X property _KDE_NET_WM_SKIP_CLOSE_ANIMATION to 1 a window can request to be excluded from any close animation. This property is read in Toplevel, so that it is available to both Client and Unmanaged. If the window has this property set the Scene suppresses the paintWindow loop of the Deleted. Thus no effect needs to be adjusted. But an effect using drawWindow directly would still be able to render the Deleted as there is no suppression. Furthermore the property is passed to the EffectWindow so that an Effect can make use of this functionality and not start the animation in the first place. REVIEW: 115288
2014-01-24 11:34:16 +00:00
void getSkipCloseAnimation();
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
virtual void debug(QDebug& stream) const = 0;
void copyToDeleted(Toplevel* c);
void disownDataPassedToDeleted();
friend QDebug& operator<<(QDebug& stream, const Toplevel*);
void deleteEffectWindow();
[wayland] Set depth in ShellClient depending on whether the Buffer has alpha We need to set the depth in order to properly determine whether the Surface has an alpha channel and whether blending needs to be enabled for rendering. For this a new method is introduced in Toplevel to set the depth. If the depth changed in a way that the Toplevel gained or lost the alpha channel a signal is emitted which implies that the hasAlpha property of Toplevel is no longer constant.
2015-06-01 14:25:21 +00:00
void setDepth(int depth);
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
QRect geom;
Toplevel::vis becomes Toplevel::m_visual and is xcb_visualid_t Only usage of the ::vis was the visualid, so have this as the member instead of the XVisual*.
2014-04-25 10:06:39 +00:00
xcb_visualid_t m_visual;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
int bit_depth;
[kwin] NETWinInfo2 becomes NETWinInfo And takes a xcb_connection_t instead of Display. Also our own class is adjusted to no longer need the connection being passed in.
2013-11-18 12:54:30 +00:00
NETWinInfo* info;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
bool ready_for_painting;
QRegion repaints_region; // updating, repaint just requires repaint of that area
kwin: move/resize events shall not force a repaint of all layers This patch adds a new function Toplevel::addLayerRepaint, that in contrast to addWorkspaceRepaint does not invalidate every blur texture cache that overlaps with that region. As the name suggests it rather invalidates the to the window associated layer at that position. This is especially useful in the case of move/resize events in combination with oxygen-transparent, where the altered window is almost always the topmost window and the blur texture cache of the windows underneath are unchanged. For the case of fully opaque windows the behaviour of addLayerRepaint and addWorkspaceRepaint should be same. REVIEW: 103906
2012-02-07 16:01:41 +00:00
QRegion layer_repaints_region;
kwin: Use xcb to optimize damage event handling Use XDamageReportNonEmpty instead of XDamageReportRawRectangles. In XDamageReportNonEmpty mode the server generates a single damage event when the damage state transitions from not-damaged to damaged. When the compositor is ready to paint the screen, it requests the damage region for each window and resets the state to not-damaged. With XCB we can request the damage regions for all windows in a single roundtrip, making this the preferred mode. This should reduce the number of wakeups and the time spent processing damage events between repaints.
2012-03-28 18:29:33 +00:00
protected:
bool m_isDamaged;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
private:
// when adding new data members, check also copyToDeleted()
Use Xcb::Window wraper for Toplevel::client Uses the new API to not destroy the window in the dtor. At the same time the variable is renamed to m_client to follow the common naming scheme.
2013-09-10 05:09:44 +00:00
Xcb::Window m_client;
Change Toplevel::damage_handle to xcb_damage_damage_t Damage handling has already been ported to XCB - no need to keep it on an XLib datatype.
2013-04-26 09:12:52 +00:00
xcb_damage_damage_t damage_handle;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
QRegion damage_region; // damage is really damaged window (XDamage) and texture needs
bool is_shape;
EffectWindowImpl* effect_window;
QByteArray resource_name;
QByteArray resource_class;
Improved resolving whether a window is on local machine Most windows use the hostname in WM_CLIENT_MACHINE, but there are windows using the FQDN (for example libreoffice). So instead of "foo" it is "foo.local.net" or similar. The logic so far has been unable to properly determine whether windows with FQDN are on the local system. In order to solve this problem the handling is split out into an own class which stores the information of hostname and whether it is a local machine. This is to not query multiple times. To determine whether the Client is on the local system getaddrinfo is used for the own hostname and the FQDN provided in WM_CLIENT_MACHINE. If one of the queried names matches, we know that it is on the local machine. The old logic to compare the hostname is still used and getaddrinfo is only a fallback in case hostname does not match. The problem with getaddrinfo is, that it accesses the network and by that could block. To circumvent this problem the calls are moved into threads by using QtConcurrent::run. Obviously this brings disadvantages. When trying to resolve whether a Client is on the local machine and a FQDN is used, the information is initially wrong. The new ClientMachine class emits a signal when the information that the system is local becomes available, but for some things this is just too late: * window rules are already gathered * Session Management has already taken place In both cases this is an acceptable loss. For window rules it just needs a proper matching of the machine in case of localhost (remote hosts are not affected). And the case of session management is very academic as it is unlikely that a restoring session contains remote windows. BUG: 308391 FIXED-IN: 4.11 REVIEW: 108235
2013-01-07 07:07:27 +00:00
ClientMachine *m_clientMachine;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
WId wmClientLeaderWin;
kwin: Use xcb to optimize damage event handling Use XDamageReportNonEmpty instead of XDamageReportRawRectangles. In XDamageReportNonEmpty mode the server generates a single damage event when the damage state transitions from not-damaged to damaged. When the compositor is ready to paint the screen, it requests the damage region for each window and resets the state to not-damaged. With XCB we can request the damage regions for all windows in a single roundtrip, making this the preferred mode. This should reduce the number of wakeups and the time spent processing damage events between repaints.
2012-03-28 18:29:33 +00:00
bool m_damageReplyPending;
kwin: implement _KDE_NET_WM_OPAQUE_REGION This patch implements an XProperty named _KDE_NET_WM_OPAQUE_REGION which gives the compositor the information which part of a window is opaque although it is an ARGB visual. The basic ideas are from http://www.mail-archive.com/wm-spec-list@gnome.org/msg00715.html Additionally the patch makes kwin use this information to do a better clipping in Scene::paintSimpleScreen which should result in a higher performance. REVIEW: 102933
2011-10-22 09:02:49 +00:00
QRegion opaque_region;
kwin: Use xcb to optimize damage event handling Use XDamageReportNonEmpty instead of XDamageReportRawRectangles. In XDamageReportNonEmpty mode the server generates a single damage event when the damage state transitions from not-damaged to damaged. When the compositor is ready to paint the screen, it requests the damage region for each window and resets the state to not-damaged. With XCB we can request the damage regions for all windows in a single roundtrip, making this the preferred mode. This should reduce the number of wakeups and the time spent processing damage events between repaints.
2012-03-28 18:29:33 +00:00
xcb_xfixes_fetch_region_cookie_t m_regionCookie;
Introduce a proper screen property in Toplevel Instead of calculating the screen number each time screen() is invoked, the screen number gets stored in a private member variable and evaluated whenever either the screen count changes or the Toplevel's geometry changes. During move/resize the screen property doesn't get updated. The update is delayed till the end of the move/resize operation. REVIEW: 109715
2013-03-26 06:45:08 +00:00
int m_screen;
Allow windows to specify that they should not get animated on window close By setting the X property _KDE_NET_WM_SKIP_CLOSE_ANIMATION to 1 a window can request to be excluded from any close animation. This property is read in Toplevel, so that it is available to both Client and Unmanaged. If the window has this property set the Scene suppresses the paintWindow loop of the Deleted. Thus no effect needs to be adjusted. But an effect using drawWindow directly would still be able to render the Deleted as there is no suppression. Furthermore the property is passed to the EffectWindow so that an Effect can make use of this functionality and not start the animation in the first place. REVIEW: 115288
2014-01-24 11:34:16 +00:00
bool m_skipCloseAnimation;
[xwayland] Add support for WL_SURFACE_ID When XWayland associates a Wayland surface with an X window it sends a WL_SURFACE_ID client message to the window manager. KWin listens for this client message in Toplevel and provides it as a member in Toplevel. This requires KWin to actually start a Wayland server (and XWayland) to make proper use of the information.
2015-01-09 10:16:57 +00:00
quint32 m_surfaceId = 0;
[wayland] Add a SurfaceInterface to Toplevel Adds the SurfaceInterface identified by the surface id we get from Xwayland. This allows in an easier way to map a Toplevel to a Wayland surface and will also be useful for Wayland clients.
2015-02-09 15:08:53 +00:00
KWayland::Server::SurfaceInterface *m_surface = nullptr;
Composite windows from a QOpenGLFramebufferObject This change introduces a mechanism for internal windows to be rendered to a QOpenGLFramebufferObject to be composited using the texture bound to the FBO. This is useful for in-process rendering (e.g. QtQuick) and at the same time bypassing the windowing system. The OpenGL context of the QOpenGLFramebufferObject needs to be sharing with the compositing OpenGL context.
2015-08-18 12:40:26 +00:00
/**
* An FBO object KWin internal windows might render to.
**/
QSharedPointer<QOpenGLFramebufferObject> m_internalFBO;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
// when adding new data members, check also copyToDeleted()
};
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
Use Xcb::Window wraper for Toplevel::client Uses the new API to not destroy the window in the dtor. At the same time the variable is renamed to m_client to follow the common naming scheme.
2013-09-10 05:09:44 +00:00
inline xcb_window_t Toplevel::window() const
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
Use Xcb::Window wraper for Toplevel::client Uses the new API to not destroy the window in the dtor. At the same time the variable is renamed to m_client to follow the common naming scheme.
2013-09-10 05:09:44 +00:00
return m_client;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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
Toplevel::frameId() becomes virtual The frameId only makes sense for a Client, in case of Unmanaged the same window id is used as for the window() handle. Client creates the frame and destroys it. Given that it makes sense to let Client manage the frame properly. The ::frameId() is therefore virtual and as base implementation it returns the client id. Client reimplements it and returns the proper frame id. Method is also implemented in Deleted as it used to be passed to deleted.
2013-09-10 06:13:33 +00:00
inline void Toplevel::setWindowHandles(xcb_window_t w)
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
Use Xcb::Window wraper for Toplevel::client Uses the new API to not destroy the window in the dtor. At the same time the variable is renamed to m_client to follow the common naming scheme.
2013-09-10 05:09:44 +00:00
assert(!m_client.isValid() && w != XCB_WINDOW_NONE);
m_client.reset(w, false);
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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 QRect Toplevel::geometry() const
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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
return geom;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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 QSize Toplevel::size() const
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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
return geom.size();
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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 QPoint Toplevel::pos() const
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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
return geom.topLeft();
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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 int Toplevel::x() const
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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
return geom.x();
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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 int Toplevel::y() const
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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
return geom.y();
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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 int Toplevel::width() const
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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
return geom.width();
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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 int Toplevel::height() const
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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
return geom.height();
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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 QRect Toplevel::rect() const
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
return QRect(0, 0, width(), height());
}
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
Support for _NET_WM_SYNC_REQUEST, based on a patch by Rayiner Hashem <gtg990h@mail.gatech.edu>. svn path=/trunk/KDE/kdebase/workspace/; revision=679986
2007-06-25 08:51:44 +00:00
inline bool Toplevel::readyForPainting() const
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
Support for _NET_WM_SYNC_REQUEST, based on a patch by Rayiner Hashem <gtg990h@mail.gatech.edu>. svn path=/trunk/KDE/kdebase/workspace/; revision=679986
2007-06-25 08:51:44 +00:00
return ready_for_painting;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
Support for _NET_WM_SYNC_REQUEST, based on a patch by Rayiner Hashem <gtg990h@mail.gatech.edu>. svn path=/trunk/KDE/kdebase/workspace/; revision=679986
2007-06-25 08:51:44 +00:00
Toplevel::vis becomes Toplevel::m_visual and is xcb_visualid_t Only usage of the ::vis was the visualid, so have this as the member instead of the XVisual*.
2014-04-25 10:06:39 +00:00
inline xcb_visualid_t Toplevel::visual() const
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
Toplevel::vis becomes Toplevel::m_visual and is xcb_visualid_t Only usage of the ::vis was the visualid, so have this as the member instead of the XVisual*.
2014-04-25 10:06:39 +00:00
return m_visual;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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 bool Toplevel::isDesktop() const
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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
return windowType() == NET::Desktop;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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 bool Toplevel::isDock() const
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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
return windowType() == NET::Dock;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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 bool Toplevel::isMenu() const
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
Removing TopMenu Since the funtionality of TopMenu did no longer work in KDE4 this feature was removed from Workspace. Every reference to it was removed as well as commentaries and documentation. REVIEW: 101485
2011-06-24 10:19:47 +00:00
return windowType() == NET::Menu;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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 bool Toplevel::isToolbar() const
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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
return windowType() == NET::Toolbar;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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 bool Toplevel::isSplash() const
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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
return windowType() == NET::Splash;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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 bool Toplevel::isUtility() const
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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
return windowType() == NET::Utility;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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 bool Toplevel::isDialog() const
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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
return windowType() == NET::Dialog;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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 bool Toplevel::isNormalWindow() const
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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
return windowType() == NET::Normal;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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 bool Toplevel::isDropdownMenu() const
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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
return windowType() == NET::DropdownMenu;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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 bool Toplevel::isPopupMenu() const
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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
return windowType() == NET::PopupMenu;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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 bool Toplevel::isTooltip() const
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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
return windowType() == NET::Tooltip;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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 bool Toplevel::isNotification() const
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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
return windowType() == NET::Notification;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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
Add OnScreenDisplayLayer which is placed even ontop of the active fullscreen window It is to be used for volume change feedback and similar confirmation popups REVIEW: 121300
2015-01-02 11:11:54 +00:00
inline bool Toplevel::isOnScreenDisplay() const
{
return windowType() == NET::OnScreenDisplay;
}
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 bool Toplevel::isComboBox() const
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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
return windowType() == NET::ComboBox;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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 bool Toplevel::isDNDIcon() const
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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
return windowType() == NET::DNDIcon;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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
[wayland] Introduce property to identify lockscreen and inputmethods This introduces Toplevel::isLockScreen() and Toplevel::isInputMethod(), this can be used to allow only lockscreen/inputmethods to get input events and shown when screen is locked.
2015-11-16 10:19:38 +00:00
inline bool Toplevel::isLockScreen() const
{
return false;
}
inline bool Toplevel::isInputMethod() const
{
return false;
}
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 QRegion Toplevel::damage() const
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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
return damage_region;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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 QRegion Toplevel::repaints() const
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
kwin: move/resize events shall not force a repaint of all layers This patch adds a new function Toplevel::addLayerRepaint, that in contrast to addWorkspaceRepaint does not invalidate every blur texture cache that overlaps with that region. As the name suggests it rather invalidates the to the window associated layer at that position. This is especially useful in the case of move/resize events in combination with oxygen-transparent, where the altered window is almost always the topmost window and the blur texture cache of the windows underneath are unchanged. For the case of fully opaque windows the behaviour of addLayerRepaint and addWorkspaceRepaint should be same. REVIEW: 103906
2012-02-07 16:01:41 +00:00
return repaints_region.translated(pos()) | layer_repaints_region;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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 bool Toplevel::shape() const
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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
return is_shape;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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 int Toplevel::depth() const
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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
return bit_depth;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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 bool Toplevel::hasAlpha() const
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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
return depth() == 32;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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: implement _KDE_NET_WM_OPAQUE_REGION This patch implements an XProperty named _KDE_NET_WM_OPAQUE_REGION which gives the compositor the information which part of a window is opaque although it is an ARGB visual. The basic ideas are from http://www.mail-archive.com/wm-spec-list@gnome.org/msg00715.html Additionally the patch makes kwin use this information to do a better clipping in Scene::paintSimpleScreen which should result in a higher performance. REVIEW: 102933
2011-10-22 09:02:49 +00:00
inline const QRegion& Toplevel::opaqueRegion() const
{
return opaque_region;
}
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
EffectWindowImpl* Toplevel::effectWindow()
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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
return effect_window;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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
Move ownership on Shadow from Toplevel to Scene::Window The Shadow is clearly an aspect of the compositor. Therefore the Shadow has to be owned and controlled by the Scene::Window. Nevertheless Toplevel needs to know about the Shadow cause of reading the property.
2011-04-03 09:31:33 +00:00
inline
const EffectWindowImpl* Toplevel::effectWindow() const
{
return effect_window;
}
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 bool Toplevel::isOnAllDesktops() const
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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
return desktop() == NET::OnAllDesktops;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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
Activity association for windows. ok'd by fredrikh. this code is buggy right now, but I promise to squash the bugs by the 19th :) svn path=/trunk/KDE/kdebase/workspace/; revision=1125614
2010-05-11 20:30:20 +00:00
inline bool Toplevel::isOnAllActivities() const
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
Activity association for windows. ok'd by fredrikh. this code is buggy right now, but I promise to squash the bugs by the 19th :) svn path=/trunk/KDE/kdebase/workspace/; revision=1125614
2010-05-11 20:30:20 +00:00
return activities().isEmpty();
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
Activity association for windows. ok'd by fredrikh. this code is buggy right now, but I promise to squash the bugs by the 19th :) svn path=/trunk/KDE/kdebase/workspace/; revision=1125614
2010-05-11 20:30:20 +00:00
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
inline bool Toplevel::isOnDesktop(int d) const
{
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
return desktop() == d || /*desk == 0 ||*/ isOnAllDesktops();
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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 uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
inline bool Toplevel::isOnActivity(const QString &activity) const
{
Activity association for windows. ok'd by fredrikh. this code is buggy right now, but I promise to squash the bugs by the 19th :) svn path=/trunk/KDE/kdebase/workspace/; revision=1125614
2010-05-11 20:30:20 +00:00
return activities().isEmpty() || activities().contains(activity);
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
Activity association for windows. ok'd by fredrikh. this code is buggy right now, but I promise to squash the bugs by the 19th :) svn path=/trunk/KDE/kdebase/workspace/; revision=1125614
2010-05-11 20:30:20 +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 bool Toplevel::isOnCurrentDesktop() const
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
Move handling of Virtual Desktops into a VirtualDesktopManager The ownership for virtual desktops is moved from Workspace into a new VirtualDesktopManager. The manager is responsible for providing the count of virtual desktops and keeping track of the currently used virtual desktop. All methods related to moving between desktops are also moved from Workspace to the new manager, though all methods related to Clients on Virtual Desktops remain in Workspace for the time being. This is to have the new manager as independent from KWin core as possible. An rather important change for the handling of virtual desktops is that the count and the id of a desktop is now an unsinged integer instead of an integer. The reason for that is that we cannot have a negative count of desktops as well as it is not possible to be on a desktop with a negative identifier. In that regard it is important to remember that a Client can be on a desktop with a negative identifier. The special value for a Client being on all desktops is handled by using -1 as a desktop. For the time being this is not adjusted but instead of comparing the virtual desktop ids one should prefer to use the convenient methods like isOnDesktop and isOnAllDesktops. This would allow in future to internally change the representation for on all desktops.
2012-11-16 07:23:47 +00:00
return isOnDesktop(VirtualDesktopManager::self()->current());
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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 QByteArray Toplevel::resourceName() const
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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
return resource_name; // it is always lowercase
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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 QByteArray Toplevel::resourceClass() const
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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
return resource_class; // it is always lowercase
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +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
Improved resolving whether a window is on local machine Most windows use the hostname in WM_CLIENT_MACHINE, but there are windows using the FQDN (for example libreoffice). So instead of "foo" it is "foo.local.net" or similar. The logic so far has been unable to properly determine whether windows with FQDN are on the local system. In order to solve this problem the handling is split out into an own class which stores the information of hostname and whether it is a local machine. This is to not query multiple times. To determine whether the Client is on the local system getaddrinfo is used for the own hostname and the FQDN provided in WM_CLIENT_MACHINE. If one of the queried names matches, we know that it is on the local machine. The old logic to compare the hostname is still used and getaddrinfo is only a fallback in case hostname does not match. The problem with getaddrinfo is, that it accesses the network and by that could block. To circumvent this problem the calls are moved into threads by using QtConcurrent::run. Obviously this brings disadvantages. When trying to resolve whether a Client is on the local machine and a FQDN is used, the information is initially wrong. The new ClientMachine class emits a signal when the information that the system is local becomes available, but for some things this is just too late: * window rules are already gathered * Session Management has already taken place In both cases this is an acceptable loss. For window rules it just needs a proper matching of the machine in case of localhost (remote hosts are not affected). And the case of session management is very academic as it is unlikely that a restoring session contains remote windows. BUG: 308391 FIXED-IN: 4.11 REVIEW: 108235
2013-01-07 07:07:27 +00:00
inline const ClientMachine *Toplevel::clientMachine() const
{
return m_clientMachine;
}
[xwayland] Add support for WL_SURFACE_ID When XWayland associates a Wayland surface with an X window it sends a WL_SURFACE_ID client message to the window manager. KWin listens for this client message in Toplevel and provides it as a member in Toplevel. This requires KWin to actually start a Wayland server (and XWayland) to make proper use of the information.
2015-01-09 10:16:57 +00:00
inline quint32 Toplevel::surfaceId() const
{
return m_surfaceId;
}
[wayland] Add a SurfaceInterface to Toplevel Adds the SurfaceInterface identified by the surface id we get from Xwayland. This allows in an easier way to map a Toplevel to a Wayland surface and will also be useful for Wayland clients.
2015-02-09 15:08:53 +00:00
inline KWayland::Server::SurfaceInterface *Toplevel::surface() const
{
return m_surface;
}
Composite windows from a QOpenGLFramebufferObject This change introduces a mechanism for internal windows to be rendered to a QOpenGLFramebufferObject to be composited using the texture bound to the FBO. This is useful for in-process rendering (e.g. QtQuick) and at the same time bypassing the windowing system. The OpenGL context of the QOpenGLFramebufferObject needs to be sharing with the compositing OpenGL context.
2015-08-18 12:40:26 +00:00
inline const QSharedPointer<QOpenGLFramebufferObject> &Toplevel::internalFramebufferObject() const
{
return m_internalFBO;
}
Introduce a Toplevel::clientContentPos() -> QPoint This describes an additional offset for the client content. On X11 our client content position matches with the window - the window decoration is part of the overall content coordinate system. On Wayland the content is an own texture starting at 0/0. Thus a mapping to texture coordinates will be required when server side decorations are provided. The new information is used in the scene's to adjust the rendering and generating of quads.
2015-12-08 09:11:26 +00:00
inline QPoint Toplevel::clientContentPos() const
{
return QPoint(0, 0);
}
Add Workspace::findToplevel Like findClient and findUnmanaged, just a little bit more generic. Toplevel::findInList got adjusted to support it.
2015-02-09 15:07:30 +00:00
template <class T, class U>
inline T *Toplevel::findInList(const QList<T*> &list, std::function<bool (const U*)> func)
[kwin] Use std::find_if and lambda functions for Workspace::findUnmanaged Instead of passing the macro based Predicate to findUnmanaged it now expects a function which can be passed to std::find_if. Existing code like: xcb_window_t window; // our test window Unmanaged *u = findUnmanaged(WindowMatchPredicated(window)); becomes: Unmanaged *u = findUnmanaged([window](const Unmanaged *u) { return u->window() == window; }); In addition an overload is added which takes the window id to cover the common case to search for an Unmanaged by its ID. The above example becomes: Unmanaged *u = findUnmanaged(window); The advantage is that it is way more flexible and has the logic what to check for directly with the code and not hidden in the macro definition.
2014-03-20 06:52:18 +00:00
{
Add Workspace::findToplevel Like findClient and findUnmanaged, just a little bit more generic. Toplevel::findInList got adjusted to support it.
2015-02-09 15:07:30 +00:00
static_assert(std::is_base_of<U, T>::value,
"U must be derived from T");
[kwin] Use std::find_if and lambda functions for Workspace::findUnmanaged Instead of passing the macro based Predicate to findUnmanaged it now expects a function which can be passed to std::find_if. Existing code like: xcb_window_t window; // our test window Unmanaged *u = findUnmanaged(WindowMatchPredicated(window)); becomes: Unmanaged *u = findUnmanaged([window](const Unmanaged *u) { return u->window() == window; }); In addition an overload is added which takes the window id to cover the common case to search for an Unmanaged by its ID. The above example becomes: Unmanaged *u = findUnmanaged(window); The advantage is that it is way more flexible and has the logic what to check for directly with the code and not hidden in the macro definition.
2014-03-20 06:52:18 +00:00
const auto it = std::find_if(list.begin(), list.end(), func);
if (it == list.end()) {
return nullptr;
}
return *it;
}
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
QDebug& operator<<(QDebug& stream, const Toplevel*);
QDebug& operator<<(QDebug& stream, const ToplevelList&);
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
Export Toplevel to KWin::Scripts Without the scripting system is not able to handle signals defined on Toplevel instead of Client. REVIEW: 108807
2013-02-06 14:25:02 +00:00
Q_DECLARE_METATYPE(KWin::Toplevel*)
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
#endif
Reference in a new issue Copy permalink