kwin/src/screenedge.cpp

1511 lines
47 KiB
C++
Raw Normal View History

2020-08-02 22:22:19 +00:00
/*
KWin - the KDE window manager
This file is part of the KDE project.
2020-08-02 22:22:19 +00:00
SPDX-FileCopyrightText: 2011 Arthur Arlt <a.arlt@stud.uni-heidelberg.de>
SPDX-FileCopyrightText: 2013 Martin Gräßlin <mgraesslin@kde.org>
2020-08-02 22:22:19 +00:00
Since the functionality provided in this class has been moved from
class Workspace, it is not clear who exactly has written the code.
The list below contains the copyright holders of the class Workspace.
2020-08-02 22:22:19 +00:00
SPDX-FileCopyrightText: 1999, 2000 Matthias Ettrich <ettrich@kde.org>
SPDX-FileCopyrightText: 2003 Lubos Lunak <l.lunak@kde.org>
SPDX-FileCopyrightText: 2009 Lucas Murray <lmurray@undefinedfire.com>
2020-08-02 22:22:19 +00:00
SPDX-License-Identifier: GPL-2.0-or-later
*/
#include "screenedge.h"
// KWin
2021-08-28 12:35:13 +00:00
#include "abstract_output.h"
#include "gestures.h"
#include <x11client.h>
#include "cursor.h"
#include "main.h"
#include "platform.h"
#include "utils.h"
#include <workspace.h>
#include "virtualdesktops.h"
// DBus generated
#include "screenlocker_interface.h"
// frameworks
#include <KConfigGroup>
// Qt
#include <QAction>
#include <QMouseEvent>
#include <QSharedPointer>
#include <QTimer>
#include <QTextStream>
#include <QDBusInterface>
#include <QDBusPendingCall>
#include <QWidget>
namespace KWin {
// Mouse should not move more than this many pixels
static const int DISTANCE_RESET = 30;
Edge::Edge(ScreenEdges *parent)
: QObject(parent)
, m_edges(parent)
, m_border(ElectricNone)
, m_action(ElectricActionNone)
, m_reserved(0)
, m_approaching(false)
, m_lastApproachingFactor(0)
, m_blocked(false)
, m_pushBackBlocked(false)
Screenedge show support for Clients This provides a new protocol intended to be used by auto-hiding panels to make use of the centralized screen edges. To use it a Client can set an X11 property of type _KDE_NET_WM_SCREEN_EDGE_SHOW to KWin. As value it takes: * 0: top edge * 1: right edge * 2: bottom edge * 3: left edge KWin will hide the Client (hide because unmap or minimize would break it) and create an Edge. If that Edge gets triggered the Client is shown again and the property gets deleted. If the Client doesn't border the specified screen edge the Client gets shown immediately so that we never end in a situation that we cannot unhide the auto-hidden panel again. The exact process is described in the documentation of ScreenEdges. The Client can request to be shown again by deleting the property. If KWin gets restarted the state is read from the property and it is tried to create the edge as described. As this is a KWin specific extension we need to discuss what it means for Clients using this feature with other WMs: it does nothing. As the Client gets hidden by KWin and not by the Client, it just doesn't get hidden if the WM doesn't provide the feature. In case of an auto-hiding panel this seems like a good solution given that we don't want to hide it if we cannot unhide it. Of course there's the option for the Client to provide that feature itself and if that's wanted we would need to announce the feature in the _NET_SUPPORTED atom. At the moment that doesn't sound like being needed as Plasma doesn't want to provide an own implementation. The implementation comes with a small test application showing how the feature is intended to be used. REVIEW: 115910
2014-02-20 11:39:23 +00:00
, m_client(nullptr)
, m_gesture(new SwipeGesture(this))
{
m_gesture->setMinimumFingerCount(1);
m_gesture->setMaximumFingerCount(1);
connect(m_gesture, &Gesture::triggered, this,
[this] {
stopApproaching();
if (m_client) {
m_client->showOnScreenEdge();
unreserve();
return;
}
handleTouchAction();
handleTouchCallback();
}, Qt::QueuedConnection
);
connect(m_gesture, &SwipeGesture::started, this, &Edge::startApproaching);
connect(m_gesture, &SwipeGesture::cancelled, this, &Edge::stopApproaching);
connect(m_gesture, &SwipeGesture::progress, this,
[this] (qreal progress) {
int factor = progress * 256.0f;
if (m_lastApproachingFactor != factor) {
m_lastApproachingFactor = factor;
Q_EMIT approaching(border(), m_lastApproachingFactor/256.0f, m_approachGeometry);
}
}
);
connect(this, &Edge::activatesForTouchGestureChanged, this,
[this] {
if (isReserved()) {
if (activatesForTouchGesture()) {
m_edges->gestureRecognizer()->registerGesture(m_gesture);
} else {
m_edges->gestureRecognizer()->unregisterGesture(m_gesture);
}
}
}
);
}
Edge::~Edge()
{
}
void Edge::reserve()
{
m_reserved++;
if (m_reserved == 1) {
// got activated
activate();
}
}
void Edge::reserve(QObject *object, const char *slot)
{
connect(object, &QObject::destroyed, this, qOverload<QObject *>(&Edge::unreserve));
m_callBacks.insert(object, QByteArray(slot));
reserve();
}
void Edge::reserveTouchCallBack(QAction *action)
{
if (m_touchActions.contains(action)) {
return;
}
connect(action, &QAction::destroyed, this,
[this, action] {
unreserveTouchCallBack(action);
}
);
m_touchActions << action;
reserve();
}
void Edge::unreserveTouchCallBack(QAction *action)
{
auto it = std::find_if(m_touchActions.begin(), m_touchActions.end(), [action] (QAction *a) { return a == action; });
if (it != m_touchActions.end()) {
m_touchActions.erase(it);
unreserve();
}
}
void Edge::unreserve()
{
m_reserved--;
if (m_reserved == 0) {
// got deactivated
Screenedge show support for Clients This provides a new protocol intended to be used by auto-hiding panels to make use of the centralized screen edges. To use it a Client can set an X11 property of type _KDE_NET_WM_SCREEN_EDGE_SHOW to KWin. As value it takes: * 0: top edge * 1: right edge * 2: bottom edge * 3: left edge KWin will hide the Client (hide because unmap or minimize would break it) and create an Edge. If that Edge gets triggered the Client is shown again and the property gets deleted. If the Client doesn't border the specified screen edge the Client gets shown immediately so that we never end in a situation that we cannot unhide the auto-hidden panel again. The exact process is described in the documentation of ScreenEdges. The Client can request to be shown again by deleting the property. If KWin gets restarted the state is read from the property and it is tried to create the edge as described. As this is a KWin specific extension we need to discuss what it means for Clients using this feature with other WMs: it does nothing. As the Client gets hidden by KWin and not by the Client, it just doesn't get hidden if the WM doesn't provide the feature. In case of an auto-hiding panel this seems like a good solution given that we don't want to hide it if we cannot unhide it. Of course there's the option for the Client to provide that feature itself and if that's wanted we would need to announce the feature in the _NET_SUPPORTED atom. At the moment that doesn't sound like being needed as Plasma doesn't want to provide an own implementation. The implementation comes with a small test application showing how the feature is intended to be used. REVIEW: 115910
2014-02-20 11:39:23 +00:00
stopApproaching();
deactivate();
}
}
void Edge::unreserve(QObject *object)
{
if (m_callBacks.contains(object)) {
m_callBacks.remove(object);
disconnect(object, &QObject::destroyed, this, qOverload<QObject *>(&Edge::unreserve));
unreserve();
}
}
bool Edge::activatesForPointer() const
{
if (m_client) {
return true;
}
if (m_edges->isDesktopSwitching()) {
return true;
}
if (m_edges->isDesktopSwitchingMovingClients()) {
auto c = Workspace::self()->moveResizeClient();
if (c && !c->isInteractiveResize()) {
return true;
}
}
if (!m_callBacks.isEmpty()) {
return true;
}
if (m_action != ElectricActionNone) {
return true;
}
return false;
}
bool Edge::activatesForTouchGesture() const
{
if (!isScreenEdge()) {
return false;
}
if (m_blocked) {
return false;
}
if (m_client) {
return true;
}
if (m_touchAction != ElectricActionNone) {
return true;
}
if (!m_touchActions.isEmpty()) {
return true;
}
return false;
}
bool Edge::triggersFor(const QPoint &cursorPos) const
{
if (isBlocked()) {
return false;
}
if (!activatesForPointer()) {
return false;
}
if (!m_geometry.contains(cursorPos)) {
return false;
}
if (isLeft() && cursorPos.x() != m_geometry.x()) {
return false;
}
if (isRight() && cursorPos.x() != (m_geometry.x() + m_geometry.width() -1)) {
return false;
}
if (isTop() && cursorPos.y() != m_geometry.y()) {
return false;
}
if (isBottom() && cursorPos.y() != (m_geometry.y() + m_geometry.height() -1)) {
return false;
}
return true;
}
Screenedge show support for Clients This provides a new protocol intended to be used by auto-hiding panels to make use of the centralized screen edges. To use it a Client can set an X11 property of type _KDE_NET_WM_SCREEN_EDGE_SHOW to KWin. As value it takes: * 0: top edge * 1: right edge * 2: bottom edge * 3: left edge KWin will hide the Client (hide because unmap or minimize would break it) and create an Edge. If that Edge gets triggered the Client is shown again and the property gets deleted. If the Client doesn't border the specified screen edge the Client gets shown immediately so that we never end in a situation that we cannot unhide the auto-hidden panel again. The exact process is described in the documentation of ScreenEdges. The Client can request to be shown again by deleting the property. If KWin gets restarted the state is read from the property and it is tried to create the edge as described. As this is a KWin specific extension we need to discuss what it means for Clients using this feature with other WMs: it does nothing. As the Client gets hidden by KWin and not by the Client, it just doesn't get hidden if the WM doesn't provide the feature. In case of an auto-hiding panel this seems like a good solution given that we don't want to hide it if we cannot unhide it. Of course there's the option for the Client to provide that feature itself and if that's wanted we would need to announce the feature in the _NET_SUPPORTED atom. At the moment that doesn't sound like being needed as Plasma doesn't want to provide an own implementation. The implementation comes with a small test application showing how the feature is intended to be used. REVIEW: 115910
2014-02-20 11:39:23 +00:00
bool Edge::check(const QPoint &cursorPos, const QDateTime &triggerTime, bool forceNoPushBack)
{
if (!triggersFor(cursorPos)) {
Screenedge show support for Clients This provides a new protocol intended to be used by auto-hiding panels to make use of the centralized screen edges. To use it a Client can set an X11 property of type _KDE_NET_WM_SCREEN_EDGE_SHOW to KWin. As value it takes: * 0: top edge * 1: right edge * 2: bottom edge * 3: left edge KWin will hide the Client (hide because unmap or minimize would break it) and create an Edge. If that Edge gets triggered the Client is shown again and the property gets deleted. If the Client doesn't border the specified screen edge the Client gets shown immediately so that we never end in a situation that we cannot unhide the auto-hidden panel again. The exact process is described in the documentation of ScreenEdges. The Client can request to be shown again by deleting the property. If KWin gets restarted the state is read from the property and it is tried to create the edge as described. As this is a KWin specific extension we need to discuss what it means for Clients using this feature with other WMs: it does nothing. As the Client gets hidden by KWin and not by the Client, it just doesn't get hidden if the WM doesn't provide the feature. In case of an auto-hiding panel this seems like a good solution given that we don't want to hide it if we cannot unhide it. Of course there's the option for the Client to provide that feature itself and if that's wanted we would need to announce the feature in the _NET_SUPPORTED atom. At the moment that doesn't sound like being needed as Plasma doesn't want to provide an own implementation. The implementation comes with a small test application showing how the feature is intended to be used. REVIEW: 115910
2014-02-20 11:39:23 +00:00
return false;
}
if (m_lastTrigger.isValid() && // still in cooldown
m_lastTrigger.msecsTo(triggerTime) < edges()->reActivationThreshold() - edges()->timeThreshold()) {
return false;
}
// no pushback so we have to activate at once
bool directActivate = forceNoPushBack || edges()->cursorPushBackDistance().isNull() || m_client;
if (directActivate || canActivate(cursorPos, triggerTime)) {
Screenedge show support for Clients This provides a new protocol intended to be used by auto-hiding panels to make use of the centralized screen edges. To use it a Client can set an X11 property of type _KDE_NET_WM_SCREEN_EDGE_SHOW to KWin. As value it takes: * 0: top edge * 1: right edge * 2: bottom edge * 3: left edge KWin will hide the Client (hide because unmap or minimize would break it) and create an Edge. If that Edge gets triggered the Client is shown again and the property gets deleted. If the Client doesn't border the specified screen edge the Client gets shown immediately so that we never end in a situation that we cannot unhide the auto-hidden panel again. The exact process is described in the documentation of ScreenEdges. The Client can request to be shown again by deleting the property. If KWin gets restarted the state is read from the property and it is tried to create the edge as described. As this is a KWin specific extension we need to discuss what it means for Clients using this feature with other WMs: it does nothing. As the Client gets hidden by KWin and not by the Client, it just doesn't get hidden if the WM doesn't provide the feature. In case of an auto-hiding panel this seems like a good solution given that we don't want to hide it if we cannot unhide it. Of course there's the option for the Client to provide that feature itself and if that's wanted we would need to announce the feature in the _NET_SUPPORTED atom. At the moment that doesn't sound like being needed as Plasma doesn't want to provide an own implementation. The implementation comes with a small test application showing how the feature is intended to be used. REVIEW: 115910
2014-02-20 11:39:23 +00:00
markAsTriggered(cursorPos, triggerTime);
handle(cursorPos);
Screenedge show support for Clients This provides a new protocol intended to be used by auto-hiding panels to make use of the centralized screen edges. To use it a Client can set an X11 property of type _KDE_NET_WM_SCREEN_EDGE_SHOW to KWin. As value it takes: * 0: top edge * 1: right edge * 2: bottom edge * 3: left edge KWin will hide the Client (hide because unmap or minimize would break it) and create an Edge. If that Edge gets triggered the Client is shown again and the property gets deleted. If the Client doesn't border the specified screen edge the Client gets shown immediately so that we never end in a situation that we cannot unhide the auto-hidden panel again. The exact process is described in the documentation of ScreenEdges. The Client can request to be shown again by deleting the property. If KWin gets restarted the state is read from the property and it is tried to create the edge as described. As this is a KWin specific extension we need to discuss what it means for Clients using this feature with other WMs: it does nothing. As the Client gets hidden by KWin and not by the Client, it just doesn't get hidden if the WM doesn't provide the feature. In case of an auto-hiding panel this seems like a good solution given that we don't want to hide it if we cannot unhide it. Of course there's the option for the Client to provide that feature itself and if that's wanted we would need to announce the feature in the _NET_SUPPORTED atom. At the moment that doesn't sound like being needed as Plasma doesn't want to provide an own implementation. The implementation comes with a small test application showing how the feature is intended to be used. REVIEW: 115910
2014-02-20 11:39:23 +00:00
return true;
} else {
pushCursorBack(cursorPos);
Screenedge show support for Clients This provides a new protocol intended to be used by auto-hiding panels to make use of the centralized screen edges. To use it a Client can set an X11 property of type _KDE_NET_WM_SCREEN_EDGE_SHOW to KWin. As value it takes: * 0: top edge * 1: right edge * 2: bottom edge * 3: left edge KWin will hide the Client (hide because unmap or minimize would break it) and create an Edge. If that Edge gets triggered the Client is shown again and the property gets deleted. If the Client doesn't border the specified screen edge the Client gets shown immediately so that we never end in a situation that we cannot unhide the auto-hidden panel again. The exact process is described in the documentation of ScreenEdges. The Client can request to be shown again by deleting the property. If KWin gets restarted the state is read from the property and it is tried to create the edge as described. As this is a KWin specific extension we need to discuss what it means for Clients using this feature with other WMs: it does nothing. As the Client gets hidden by KWin and not by the Client, it just doesn't get hidden if the WM doesn't provide the feature. In case of an auto-hiding panel this seems like a good solution given that we don't want to hide it if we cannot unhide it. Of course there's the option for the Client to provide that feature itself and if that's wanted we would need to announce the feature in the _NET_SUPPORTED atom. At the moment that doesn't sound like being needed as Plasma doesn't want to provide an own implementation. The implementation comes with a small test application showing how the feature is intended to be used. REVIEW: 115910
2014-02-20 11:39:23 +00:00
m_triggeredPoint = cursorPos;
}
Screenedge show support for Clients This provides a new protocol intended to be used by auto-hiding panels to make use of the centralized screen edges. To use it a Client can set an X11 property of type _KDE_NET_WM_SCREEN_EDGE_SHOW to KWin. As value it takes: * 0: top edge * 1: right edge * 2: bottom edge * 3: left edge KWin will hide the Client (hide because unmap or minimize would break it) and create an Edge. If that Edge gets triggered the Client is shown again and the property gets deleted. If the Client doesn't border the specified screen edge the Client gets shown immediately so that we never end in a situation that we cannot unhide the auto-hidden panel again. The exact process is described in the documentation of ScreenEdges. The Client can request to be shown again by deleting the property. If KWin gets restarted the state is read from the property and it is tried to create the edge as described. As this is a KWin specific extension we need to discuss what it means for Clients using this feature with other WMs: it does nothing. As the Client gets hidden by KWin and not by the Client, it just doesn't get hidden if the WM doesn't provide the feature. In case of an auto-hiding panel this seems like a good solution given that we don't want to hide it if we cannot unhide it. Of course there's the option for the Client to provide that feature itself and if that's wanted we would need to announce the feature in the _NET_SUPPORTED atom. At the moment that doesn't sound like being needed as Plasma doesn't want to provide an own implementation. The implementation comes with a small test application showing how the feature is intended to be used. REVIEW: 115910
2014-02-20 11:39:23 +00:00
return false;
}
void Edge::markAsTriggered(const QPoint &cursorPos, const QDateTime &triggerTime)
{
m_lastTrigger = triggerTime;
m_lastReset = QDateTime(); // invalidate
m_triggeredPoint = cursorPos;
}
bool Edge::canActivate(const QPoint &cursorPos, const QDateTime &triggerTime)
{
2018-08-29 18:02:16 +00:00
// we check whether either the timer has explicitly been invalidated (successful trigger) or is
// bigger than the reactivation threshold (activation "aborted", usually due to moving away the cursor
2018-08-29 18:02:16 +00:00
// from the corner after successful activation)
// either condition means that "this is the first event in a new attempt"
if (!m_lastReset.isValid() || m_lastReset.msecsTo(triggerTime) > edges()->reActivationThreshold()) {
m_lastReset = triggerTime;
return false;
}
if (m_lastTrigger.isValid() && m_lastTrigger.msecsTo(triggerTime) < edges()->reActivationThreshold() - edges()->timeThreshold()) {
return false;
}
if (m_lastReset.msecsTo(triggerTime) < edges()->timeThreshold()) {
return false;
}
// does the check on position make any sense at all?
if ((cursorPos - m_triggeredPoint).manhattanLength() > DISTANCE_RESET) {
return false;
}
return true;
}
void Edge::handle(const QPoint &cursorPos)
{
AbstractClient *movingClient = Workspace::self()->moveResizeClient();
if ((edges()->isDesktopSwitchingMovingClients() && movingClient && !movingClient->isInteractiveResize()) ||
(edges()->isDesktopSwitching() && isScreenEdge())) {
// always switch desktops in case:
// moving a Client and option for switch on client move is enabled
// or switch on screen edge is enabled
switchDesktop(cursorPos);
return;
}
if (movingClient) {
// if we are moving a window we don't want to trigger the actions. This just results in
// problems, e.g. Desktop Grid activated or screen locker activated which just cannot
// work as we hold a grab.
return;
}
if (m_client) {
pushCursorBack(cursorPos);
m_client->showOnScreenEdge();
unreserve();
return;
}
if (handlePointerAction() || handleByCallback()) {
pushCursorBack(cursorPos);
return;
}
if (edges()->isDesktopSwitching() && isCorner()) {
// try again desktop switching for the corner
switchDesktop(cursorPos);
}
}
bool Edge::handleAction(ElectricBorderAction action)
{
switch (action) {
case ElectricActionShowDesktop: {
Workspace::self()->setShowingDesktop(!Workspace::self()->showingDesktop());
return true;
}
case ElectricActionLockScreen: { // Lock the screen
OrgFreedesktopScreenSaverInterface interface(QStringLiteral("org.freedesktop.ScreenSaver"),
QStringLiteral("/ScreenSaver"),
QDBusConnection::sessionBus());
if (interface.isValid()) {
interface.Lock();
}
return true;
}
case ElectricActionKRunner: { // open krunner
QDBusConnection::sessionBus().asyncCall(
QDBusMessage::createMethodCall(QStringLiteral("org.kde.krunner"),
QStringLiteral("/App"),
QStringLiteral("org.kde.krunner.App"),
QStringLiteral("display")
)
);
return true;
}
case ElectricActionActivityManager: { // open activity manager
QDBusConnection::sessionBus().asyncCall(
QDBusMessage::createMethodCall(QStringLiteral("org.kde.plasmashell"),
QStringLiteral("/PlasmaShell"),
QStringLiteral("org.kde.PlasmaShell"),
QStringLiteral("toggleActivityManager")
)
);
return true;
}
case ElectricActionApplicationLauncher: {
QDBusConnection::sessionBus().asyncCall(
QDBusMessage::createMethodCall(QStringLiteral("org.kde.plasmashell"),
QStringLiteral("/PlasmaShell"),
QStringLiteral("org.kde.PlasmaShell"),
QStringLiteral("activateLauncherMenu")
)
);
return true;
}
default:
return false;
}
}
bool Edge::handleByCallback()
{
if (m_callBacks.isEmpty()) {
return false;
}
for (QHash<QObject *, QByteArray>::iterator it = m_callBacks.begin();
it != m_callBacks.end();
++it) {
bool retVal = false;
QMetaObject::invokeMethod(it.key(), it.value().constData(), Q_RETURN_ARG(bool, retVal), Q_ARG(ElectricBorder, m_border));
if (retVal) {
return true;
}
}
return false;
}
void Edge::handleTouchCallback()
{
if (m_touchActions.isEmpty()) {
return;
}
m_touchActions.first()->trigger();
}
void Edge::switchDesktop(const QPoint &cursorPos)
{
QPoint pos(cursorPos);
VirtualDesktopManager *vds = VirtualDesktopManager::self();
VirtualDesktop *oldDesktop = vds->currentDesktop();
VirtualDesktop *desktop = oldDesktop;
const int OFFSET = 2;
if (isLeft()) {
const VirtualDesktop *interimDesktop = desktop;
desktop = vds->toLeft(desktop, vds->isNavigationWrappingAround());
if (desktop != interimDesktop) {
2021-08-31 07:19:43 +00:00
pos.setX(workspace()->geometry().width() - 1 - OFFSET);
}
} else if (isRight()) {
const VirtualDesktop *interimDesktop = desktop;
desktop = vds->toRight(desktop, vds->isNavigationWrappingAround());
if (desktop != interimDesktop) {
pos.setX(OFFSET);
}
}
if (isTop()) {
const VirtualDesktop *interimDesktop = desktop;
desktop = vds->above(desktop, vds->isNavigationWrappingAround());
if (desktop != interimDesktop) {
2021-08-31 07:19:43 +00:00
pos.setY(workspace()->geometry().height() - 1 - OFFSET);
}
} else if (isBottom()) {
const VirtualDesktop *interimDesktop = desktop;
desktop = vds->below(desktop, vds->isNavigationWrappingAround());
if (desktop != interimDesktop) {
pos.setY(OFFSET);
}
}
#ifndef KWIN_UNIT_TEST
if (AbstractClient *c = Workspace::self()->moveResizeClient()) {
const QVector<VirtualDesktop *> desktops{desktop};
if (c->rules()->checkDesktops(desktops) != desktops) {
// user attempts to move a client to another desktop where it is ruleforced to not be
return;
}
}
#endif
vds->setCurrent(desktop);
if (vds->currentDesktop() != oldDesktop) {
m_pushBackBlocked = true;
Cursors::self()->mouse()->setPos(pos);
QSharedPointer<QMetaObject::Connection> me(new QMetaObject::Connection);
*me = QObject::connect(QCoreApplication::eventDispatcher(),
&QAbstractEventDispatcher::aboutToBlock, this,
[this, me](){
QObject::disconnect(*me);
const_cast<QSharedPointer<QMetaObject::Connection>*>(&me)->reset(nullptr);
m_pushBackBlocked = false;
}
);
}
}
void Edge::pushCursorBack(const QPoint &cursorPos)
{
if (m_pushBackBlocked)
return;
int x = cursorPos.x();
int y = cursorPos.y();
const QSize &distance = edges()->cursorPushBackDistance();
if (isLeft()) {
x += distance.width();
}
if (isRight()) {
x -= distance.width();
}
if (isTop()) {
y += distance.height();
}
if (isBottom()) {
y -= distance.height();
}
Cursors::self()->mouse()->setPos(x, y);
}
void Edge::setGeometry(const QRect &geometry)
{
if (m_geometry == geometry) {
return;
}
m_geometry = geometry;
int x = m_geometry.x();
int y = m_geometry.y();
int width = m_geometry.width();
int height = m_geometry.height();
const int size = m_edges->cornerOffset();
if (isCorner()) {
if (isRight()) {
x = x - size +1;
}
if (isBottom()) {
y = y - size +1;
}
width = size;
height = size;
} else {
if (isLeft()) {
y += size + 1;
width = size;
height = height - size * 2;
} else if (isRight()) {
x = x - size + 1;
y += size;
width = size;
height = height - size * 2;
} else if (isTop()) {
x += size;
width = width - size * 2;
height = size;
} else if (isBottom()) {
x += size;
y = y - size +1;
width = width - size * 2;
height = size;
}
}
m_approachGeometry = QRect(x, y, width, height);
doGeometryUpdate();
if (isScreenEdge()) {
2021-08-28 12:35:13 +00:00
const AbstractOutput *output = kwinApp()->platform()->outputAt(m_geometry.center());
m_gesture->setStartGeometry(m_geometry);
2021-08-28 12:35:13 +00:00
m_gesture->setMinimumDelta(output->geometry().size() * 0.2);
}
}
void Edge::checkBlocking()
{
if (isCorner()) {
return;
}
bool newValue = false;
if (AbstractClient *client = Workspace::self()->activeClient()) {
newValue = client->isFullScreen() && client->frameGeometry().contains(m_geometry.center());
}
if (newValue == m_blocked) {
return;
}
const bool wasTouch = activatesForTouchGesture();
m_blocked = newValue;
if (wasTouch != activatesForTouchGesture()) {
Q_EMIT activatesForTouchGestureChanged();
}
doUpdateBlocking();
}
void Edge::doUpdateBlocking()
{
}
void Edge::doGeometryUpdate()
{
}
void Edge::activate()
{
if (activatesForTouchGesture()) {
m_edges->gestureRecognizer()->registerGesture(m_gesture);
}
doActivate();
}
void Edge::doActivate()
{
}
void Edge::deactivate()
{
m_edges->gestureRecognizer()->unregisterGesture(m_gesture);
doDeactivate();
}
void Edge::doDeactivate()
{
}
void Edge::startApproaching()
{
if (m_approaching) {
return;
}
m_approaching = true;
doStartApproaching();
m_lastApproachingFactor = 0;
Q_EMIT approaching(border(), 0.0, m_approachGeometry);
}
void Edge::doStartApproaching()
{
}
void Edge::stopApproaching()
{
if (!m_approaching) {
return;
}
m_approaching = false;
doStopApproaching();
m_lastApproachingFactor = 0;
Q_EMIT approaching(border(), 0.0, m_approachGeometry);
}
void Edge::doStopApproaching()
{
}
void Edge::updateApproaching(const QPoint &point)
{
if (approachGeometry().contains(point)) {
int factor = 0;
const int edgeDistance = m_edges->cornerOffset();
auto cornerDistance = [=](const QPoint &corner) {
return qMax(qAbs(corner.x() - point.x()), qAbs(corner.y() - point.y()));
};
switch (border()) {
case ElectricTopLeft:
factor = (cornerDistance(approachGeometry().topLeft())<<8) / edgeDistance;
break;
case ElectricTopRight:
factor = (cornerDistance(approachGeometry().topRight())<<8) / edgeDistance;
break;
case ElectricBottomRight:
factor = (cornerDistance(approachGeometry().bottomRight())<<8) / edgeDistance;
break;
case ElectricBottomLeft:
factor = (cornerDistance(approachGeometry().bottomLeft())<<8) / edgeDistance;
break;
case ElectricTop:
factor = (qAbs(point.y() - approachGeometry().y())<<8) / edgeDistance;
break;
case ElectricRight:
factor = (qAbs(point.x() - approachGeometry().right())<<8) / edgeDistance;
break;
case ElectricBottom:
factor = (qAbs(point.y() - approachGeometry().bottom())<<8) / edgeDistance;
break;
case ElectricLeft:
factor = (qAbs(point.x() - approachGeometry().x())<<8) / edgeDistance;
break;
default:
break;
}
factor = 256 - factor;
if (m_lastApproachingFactor != factor) {
m_lastApproachingFactor = factor;
Q_EMIT approaching(border(), m_lastApproachingFactor/256.0f, m_approachGeometry);
}
} else {
stopApproaching();
}
}
quint32 Edge::window() const
{
return 0;
}
quint32 Edge::approachWindow() const
{
return 0;
}
void Edge::setBorder(ElectricBorder border)
{
m_border = border;
switch (m_border) {
case ElectricTop:
m_gesture->setDirection(SwipeGesture::Direction::Down);
break;
case ElectricRight:
m_gesture->setDirection(SwipeGesture::Direction::Left);
break;
case ElectricBottom:
m_gesture->setDirection(SwipeGesture::Direction::Up);
break;
case ElectricLeft:
m_gesture->setDirection(SwipeGesture::Direction::Right);
break;
default:
break;
}
}
void Edge::setTouchAction(ElectricBorderAction action) {
const bool wasTouch = activatesForTouchGesture();
m_touchAction = action;
if (wasTouch != activatesForTouchGesture()) {
Q_EMIT activatesForTouchGestureChanged();
}
}
void Edge::setClient(AbstractClient *client)
{
const bool wasTouch = activatesForTouchGesture();
m_client = client;
if (wasTouch != activatesForTouchGesture()) {
Q_EMIT activatesForTouchGestureChanged();
}
}
/**********************************************************
* ScreenEdges
*********************************************************/
KWIN_SINGLETON_FACTORY(ScreenEdges)
ScreenEdges::ScreenEdges(QObject *parent)
: QObject(parent)
, m_desktopSwitching(false)
, m_desktopSwitchingMovingClients(false)
, m_timeThreshold(0)
, m_reactivateThreshold(0)
2019-12-30 05:54:08 +00:00
, m_virtualDesktopLayout({})
, m_actionTopLeft(ElectricActionNone)
, m_actionTop(ElectricActionNone)
, m_actionTopRight(ElectricActionNone)
, m_actionRight(ElectricActionNone)
, m_actionBottomRight(ElectricActionNone)
, m_actionBottom(ElectricActionNone)
, m_actionBottomLeft(ElectricActionNone)
, m_actionLeft(ElectricActionNone)
, m_gestureRecognizer(new GestureRecognizer(this))
{
2021-08-31 07:19:43 +00:00
// TODO: Maybe calculate the corner offset based on font metrics instead?
const auto outputs = kwinApp()->platform()->enabledOutputs();
if (!outputs.isEmpty()) {
const QSize size = outputs[0]->geometry().size();
const QSizeF physicalSize = outputs[0]->physicalSize();
const int physicalDpiX = size.width() / physicalSize.width() * qreal(25.4);
const int physicalDpiY = size.height() / physicalSize.height() * qreal(25.4);
m_cornerOffset = (physicalDpiX + physicalDpiY + 5) / 6;
}
Screenedge show support for Clients This provides a new protocol intended to be used by auto-hiding panels to make use of the centralized screen edges. To use it a Client can set an X11 property of type _KDE_NET_WM_SCREEN_EDGE_SHOW to KWin. As value it takes: * 0: top edge * 1: right edge * 2: bottom edge * 3: left edge KWin will hide the Client (hide because unmap or minimize would break it) and create an Edge. If that Edge gets triggered the Client is shown again and the property gets deleted. If the Client doesn't border the specified screen edge the Client gets shown immediately so that we never end in a situation that we cannot unhide the auto-hidden panel again. The exact process is described in the documentation of ScreenEdges. The Client can request to be shown again by deleting the property. If KWin gets restarted the state is read from the property and it is tried to create the edge as described. As this is a KWin specific extension we need to discuss what it means for Clients using this feature with other WMs: it does nothing. As the Client gets hidden by KWin and not by the Client, it just doesn't get hidden if the WM doesn't provide the feature. In case of an auto-hiding panel this seems like a good solution given that we don't want to hide it if we cannot unhide it. Of course there's the option for the Client to provide that feature itself and if that's wanted we would need to announce the feature in the _NET_SUPPORTED atom. At the moment that doesn't sound like being needed as Plasma doesn't want to provide an own implementation. The implementation comes with a small test application showing how the feature is intended to be used. REVIEW: 115910
2014-02-20 11:39:23 +00:00
connect(workspace(), &Workspace::clientRemoved, this, &ScreenEdges::deleteEdgeForClient);
}
ScreenEdges::~ScreenEdges()
{
s_self = nullptr;
}
void ScreenEdges::init()
{
reconfigure();
updateLayout();
recreateEdges();
}
static ElectricBorderAction electricBorderAction(const QString& name)
{
QString lowerName = name.toLower();
if (lowerName == QStringLiteral("showdesktop")) {
return ElectricActionShowDesktop;
} else if (lowerName == QStringLiteral("lockscreen")) {
return ElectricActionLockScreen;
} else if (lowerName == QLatin1String("krunner")) {
return ElectricActionKRunner;
} else if (lowerName == QLatin1String("activitymanager")) {
return ElectricActionActivityManager;
} else if (lowerName == QLatin1String("applicationlauncher")) {
return ElectricActionApplicationLauncher;
}
return ElectricActionNone;
}
void ScreenEdges::reconfigure()
{
if (!m_config) {
return;
}
// TODO: migrate settings to a group ScreenEdges
KConfigGroup windowsConfig = m_config->group("Windows");
setTimeThreshold(windowsConfig.readEntry("ElectricBorderDelay", 150));
setReActivationThreshold(qMax(timeThreshold() + 50, windowsConfig.readEntry("ElectricBorderCooldown", 350)));
int desktopSwitching = windowsConfig.readEntry("ElectricBorders", static_cast<int>(ElectricDisabled));
if (desktopSwitching == ElectricDisabled) {
setDesktopSwitching(false);
setDesktopSwitchingMovingClients(false);
} else if (desktopSwitching == ElectricMoveOnly) {
setDesktopSwitching(false);
setDesktopSwitchingMovingClients(true);
} else if (desktopSwitching == ElectricAlways) {
setDesktopSwitching(true);
setDesktopSwitchingMovingClients(true);
}
const int pushBack = windowsConfig.readEntry("ElectricBorderPushbackPixels", 1);
m_cursorPushBackDistance = QSize(pushBack, pushBack);
KConfigGroup borderConfig = m_config->group("ElectricBorders");
setActionForBorder(ElectricTopLeft, &m_actionTopLeft,
electricBorderAction(borderConfig.readEntry("TopLeft", "None")));
setActionForBorder(ElectricTop, &m_actionTop,
electricBorderAction(borderConfig.readEntry("Top", "None")));
setActionForBorder(ElectricTopRight, &m_actionTopRight,
electricBorderAction(borderConfig.readEntry("TopRight", "None")));
setActionForBorder(ElectricRight, &m_actionRight,
electricBorderAction(borderConfig.readEntry("Right", "None")));
setActionForBorder(ElectricBottomRight, &m_actionBottomRight,
electricBorderAction(borderConfig.readEntry("BottomRight", "None")));
setActionForBorder(ElectricBottom, &m_actionBottom,
electricBorderAction(borderConfig.readEntry("Bottom", "None")));
setActionForBorder(ElectricBottomLeft, &m_actionBottomLeft,
electricBorderAction(borderConfig.readEntry("BottomLeft", "None")));
setActionForBorder(ElectricLeft, &m_actionLeft,
electricBorderAction(borderConfig.readEntry("Left", "None")));
borderConfig = m_config->group("TouchEdges");
setActionForTouchBorder(ElectricTop, electricBorderAction(borderConfig.readEntry("Top", "None")));
setActionForTouchBorder(ElectricRight, electricBorderAction(borderConfig.readEntry("Right", "None")));
setActionForTouchBorder(ElectricBottom, electricBorderAction(borderConfig.readEntry("Bottom", "None")));
setActionForTouchBorder(ElectricLeft, electricBorderAction(borderConfig.readEntry("Left", "None")));
}
void ScreenEdges::setActionForBorder(ElectricBorder border, ElectricBorderAction *oldValue, ElectricBorderAction newValue)
{
if (*oldValue == newValue) {
return;
}
if (*oldValue == ElectricActionNone) {
// have to reserve
for (auto it = m_edges.begin(); it != m_edges.end(); ++it) {
if ((*it)->border() == border) {
(*it)->reserve();
}
}
}
if (newValue == ElectricActionNone) {
// have to unreserve
for (auto it = m_edges.begin(); it != m_edges.end(); ++it) {
if ((*it)->border() == border) {
(*it)->unreserve();
}
}
}
*oldValue = newValue;
// update action on all Edges for given border
for (auto it = m_edges.begin(); it != m_edges.end(); ++it) {
if ((*it)->border() == border) {
(*it)->setAction(newValue);
}
}
}
void ScreenEdges::setActionForTouchBorder(ElectricBorder border, ElectricBorderAction newValue)
{
auto it = m_touchActions.find(border);
ElectricBorderAction oldValue = ElectricActionNone;
if (it != m_touchActions.end()) {
oldValue = it.value();
}
if (oldValue == newValue) {
return;
}
if (oldValue == ElectricActionNone) {
// have to reserve
for (auto it = m_edges.begin(); it != m_edges.end(); ++it) {
if ((*it)->border() == border) {
(*it)->reserve();
}
}
}
if (newValue == ElectricActionNone) {
// have to unreserve
for (auto it = m_edges.begin(); it != m_edges.end(); ++it) {
if ((*it)->border() == border) {
(*it)->unreserve();
}
}
m_touchActions.erase(it);
} else {
m_touchActions.insert(border, newValue);
}
// update action on all Edges for given border
for (auto it = m_edges.begin(); it != m_edges.end(); ++it) {
if ((*it)->border() == border) {
(*it)->setTouchAction(newValue);
}
}
}
void ScreenEdges::updateLayout()
{
const QSize desktopMatrix = VirtualDesktopManager::self()->grid().size();
Qt::Orientations newLayout = {};
if (desktopMatrix.width() > 1) {
newLayout |= Qt::Horizontal;
}
if (desktopMatrix.height() > 1) {
newLayout |= Qt::Vertical;
}
if (newLayout == m_virtualDesktopLayout) {
return;
}
if (isDesktopSwitching()) {
reserveDesktopSwitching(false, m_virtualDesktopLayout);
}
m_virtualDesktopLayout = newLayout;
if (isDesktopSwitching()) {
reserveDesktopSwitching(true, m_virtualDesktopLayout);
}
}
static bool isLeftScreen(const QRect &screen, const QRect &fullArea)
{
2021-08-31 07:19:43 +00:00
const auto outputs = kwinApp()->platform()->enabledOutputs();
if (outputs.count() == 1) {
return true;
}
if (screen.x() == fullArea.x()) {
return true;
}
// the screen is also on the left in case of a vertical layout with a second screen
// more to the left. In that case no screen ends left of screen's x coord
2021-08-31 07:19:43 +00:00
for (const AbstractOutput *output : outputs) {
const QRect otherGeo = output->geometry();
if (otherGeo == screen) {
// that's our screen to test
continue;
}
if (otherGeo.x() + otherGeo.width() <= screen.x()) {
// other screen is completely in the left
return false;
}
}
// did not find a screen left of our current screen, so it is the left most
return true;
}
static bool isRightScreen(const QRect &screen, const QRect &fullArea)
{
2021-08-31 07:19:43 +00:00
const auto outputs = kwinApp()->platform()->enabledOutputs();
if (outputs.count() == 1) {
return true;
}
if (screen.x() + screen.width() == fullArea.x() + fullArea.width()) {
return true;
}
// the screen is also on the right in case of a vertical layout with a second screen
// more to the right. In that case no screen starts right of this screen
2021-08-31 07:19:43 +00:00
for (const AbstractOutput *output : outputs) {
const QRect otherGeo = output->geometry();
if (otherGeo == screen) {
// that's our screen to test
continue;
}
if (otherGeo.x() >= screen.x() + screen.width()) {
// other screen is completely in the right
return false;
}
}
// did not find a screen right of our current screen, so it is the right most
return true;
}
static bool isTopScreen(const QRect &screen, const QRect &fullArea)
{
2021-08-31 07:19:43 +00:00
const auto outputs = kwinApp()->platform()->enabledOutputs();
if (outputs.count() == 1) {
return true;
}
if (screen.y() == fullArea.y()) {
return true;
}
// the screen is also top most in case of a horizontal layout with a second screen
// more to the top. In that case no screen ends above screen's y coord
2021-08-31 07:19:43 +00:00
for (const AbstractOutput *output : outputs) {
const QRect otherGeo = output->geometry();
if (otherGeo == screen) {
// that's our screen to test
continue;
}
if (otherGeo.y() + otherGeo.height() <= screen.y()) {
// other screen is completely above
return false;
}
}
// did not find a screen above our current screen, so it is the top most
return true;
}
static bool isBottomScreen(const QRect &screen, const QRect &fullArea)
{
2021-08-31 07:19:43 +00:00
const auto outputs = kwinApp()->platform()->enabledOutputs();
if (outputs.count() == 1) {
return true;
}
if (screen.y() + screen.height() == fullArea.y() + fullArea.height()) {
return true;
}
// the screen is also bottom most in case of a horizontal layout with a second screen
// more below. In that case no screen starts below screen's y coord + height
2021-08-31 07:19:43 +00:00
for (const AbstractOutput *output : outputs) {
const QRect otherGeo = output->geometry();
if (otherGeo == screen) {
// that's our screen to test
continue;
}
if (otherGeo.y() >= screen.y() + screen.height()) {
// other screen is completely below
return false;
}
}
// did not find a screen below our current screen, so it is the bottom most
return true;
}
void ScreenEdges::recreateEdges()
{
QList<Edge*> oldEdges(m_edges);
m_edges.clear();
2021-08-31 07:19:43 +00:00
const QRect fullArea = workspace()->geometry();
QRegion processedRegion;
2021-08-31 07:19:43 +00:00
const auto outputs = kwinApp()->platform()->enabledOutputs();
for (const AbstractOutput *output : outputs) {
const QRegion screen = QRegion(output->geometry()).subtracted(processedRegion);
processedRegion += screen;
for (const QRect &screenPart : screen) {
if (isLeftScreen(screenPart, fullArea)) {
// left most screen
createVerticalEdge(ElectricLeft, screenPart, fullArea);
}
if (isRightScreen(screenPart, fullArea)) {
// right most screen
createVerticalEdge(ElectricRight, screenPart, fullArea);
}
if (isTopScreen(screenPart, fullArea)) {
// top most screen
createHorizontalEdge(ElectricTop, screenPart, fullArea);
}
if (isBottomScreen(screenPart, fullArea)) {
// bottom most screen
createHorizontalEdge(ElectricBottom, screenPart, fullArea);
}
}
}
// copy over the effect/script reservations from the old edges
for (auto it = m_edges.begin(); it != m_edges.end(); ++it) {
Edge *edge = *it;
for (auto oldIt = oldEdges.constBegin();
oldIt != oldEdges.constEnd();
++oldIt) {
Edge *oldEdge = *oldIt;
Screenedge show support for Clients This provides a new protocol intended to be used by auto-hiding panels to make use of the centralized screen edges. To use it a Client can set an X11 property of type _KDE_NET_WM_SCREEN_EDGE_SHOW to KWin. As value it takes: * 0: top edge * 1: right edge * 2: bottom edge * 3: left edge KWin will hide the Client (hide because unmap or minimize would break it) and create an Edge. If that Edge gets triggered the Client is shown again and the property gets deleted. If the Client doesn't border the specified screen edge the Client gets shown immediately so that we never end in a situation that we cannot unhide the auto-hidden panel again. The exact process is described in the documentation of ScreenEdges. The Client can request to be shown again by deleting the property. If KWin gets restarted the state is read from the property and it is tried to create the edge as described. As this is a KWin specific extension we need to discuss what it means for Clients using this feature with other WMs: it does nothing. As the Client gets hidden by KWin and not by the Client, it just doesn't get hidden if the WM doesn't provide the feature. In case of an auto-hiding panel this seems like a good solution given that we don't want to hide it if we cannot unhide it. Of course there's the option for the Client to provide that feature itself and if that's wanted we would need to announce the feature in the _NET_SUPPORTED atom. At the moment that doesn't sound like being needed as Plasma doesn't want to provide an own implementation. The implementation comes with a small test application showing how the feature is intended to be used. REVIEW: 115910
2014-02-20 11:39:23 +00:00
if (oldEdge->client()) {
// show the client again and don't recreate the edge
oldEdge->client()->showOnScreenEdge();
continue;
}
if (oldEdge->border() != edge->border()) {
continue;
}
const QHash<QObject *, QByteArray> &callbacks = oldEdge->callBacks();
for (QHash<QObject *, QByteArray>::const_iterator callback = callbacks.begin();
callback != callbacks.end();
++callback) {
edge->reserve(callback.key(), callback.value().constData());
}
const auto touchCallBacks = oldEdge->touchCallBacks();
for (auto a : touchCallBacks) {
edge->reserveTouchCallBack(a);
}
}
}
qDeleteAll(oldEdges);
}
void ScreenEdges::createVerticalEdge(ElectricBorder border, const QRect &screen, const QRect &fullArea)
{
if (border != ElectricRight && border != KWin::ElectricLeft) {
return;
}
int y = screen.y();
int height = screen.height();
const int x = (border == ElectricLeft) ? screen.x() : screen.x() + screen.width() -1;
if (isTopScreen(screen, fullArea)) {
// also top most screen
height -= m_cornerOffset;
y += m_cornerOffset;
// create top left/right edge
const ElectricBorder edge = (border == ElectricLeft) ? ElectricTopLeft : ElectricTopRight;
m_edges << createEdge(edge, x, screen.y(), 1, 1);
}
if (isBottomScreen(screen, fullArea)) {
// also bottom most screen
height -= m_cornerOffset;
// create bottom left/right edge
const ElectricBorder edge = (border == ElectricLeft) ? ElectricBottomLeft : ElectricBottomRight;
m_edges << createEdge(edge, x, screen.y() + screen.height() -1, 1, 1);
}
if (height <= m_cornerOffset) {
// An overlap with another output is near complete. We ignore this border.
return;
}
m_edges << createEdge(border, x, y, 1, height);
}
void ScreenEdges::createHorizontalEdge(ElectricBorder border, const QRect &screen, const QRect &fullArea)
{
if (border != ElectricTop && border != ElectricBottom) {
return;
}
int x = screen.x();
int width = screen.width();
if (isLeftScreen(screen, fullArea)) {
// also left most - adjust only x and width
x += m_cornerOffset;
width -= m_cornerOffset;
}
if (isRightScreen(screen, fullArea)) {
// also right most edge
width -= m_cornerOffset;
}
if (width <= m_cornerOffset) {
// An overlap with another output is near complete. We ignore this border.
return;
}
const int y = (border == ElectricTop) ? screen.y() : screen.y() + screen.height() - 1;
m_edges << createEdge(border, x, y, width, 1);
}
Edge *ScreenEdges::createEdge(ElectricBorder border, int x, int y, int width, int height, bool createAction)
{
Edge *edge = kwinApp()->platform()->createScreenEdge(this);
// Edges can not have negative size.
Q_ASSERT(width >= 0);
Q_ASSERT(height >= 0);
edge->setBorder(border);
edge->setGeometry(QRect(x, y, width, height));
Screenedge show support for Clients This provides a new protocol intended to be used by auto-hiding panels to make use of the centralized screen edges. To use it a Client can set an X11 property of type _KDE_NET_WM_SCREEN_EDGE_SHOW to KWin. As value it takes: * 0: top edge * 1: right edge * 2: bottom edge * 3: left edge KWin will hide the Client (hide because unmap or minimize would break it) and create an Edge. If that Edge gets triggered the Client is shown again and the property gets deleted. If the Client doesn't border the specified screen edge the Client gets shown immediately so that we never end in a situation that we cannot unhide the auto-hidden panel again. The exact process is described in the documentation of ScreenEdges. The Client can request to be shown again by deleting the property. If KWin gets restarted the state is read from the property and it is tried to create the edge as described. As this is a KWin specific extension we need to discuss what it means for Clients using this feature with other WMs: it does nothing. As the Client gets hidden by KWin and not by the Client, it just doesn't get hidden if the WM doesn't provide the feature. In case of an auto-hiding panel this seems like a good solution given that we don't want to hide it if we cannot unhide it. Of course there's the option for the Client to provide that feature itself and if that's wanted we would need to announce the feature in the _NET_SUPPORTED atom. At the moment that doesn't sound like being needed as Plasma doesn't want to provide an own implementation. The implementation comes with a small test application showing how the feature is intended to be used. REVIEW: 115910
2014-02-20 11:39:23 +00:00
if (createAction) {
const ElectricBorderAction action = actionForEdge(edge);
if (action != KWin::ElectricActionNone) {
edge->reserve();
edge->setAction(action);
}
const ElectricBorderAction touchAction = actionForTouchEdge(edge);
if (touchAction != KWin::ElectricActionNone) {
edge->reserve();
edge->setTouchAction(touchAction);
}
}
if (isDesktopSwitching()) {
if (edge->isCorner()) {
edge->reserve();
} else {
if ((m_virtualDesktopLayout & Qt::Horizontal) && (edge->isLeft() || edge->isRight())) {
edge->reserve();
}
if ((m_virtualDesktopLayout & Qt::Vertical) && (edge->isTop() || edge->isBottom())) {
edge->reserve();
}
}
}
connect(edge, &Edge::approaching, this, &ScreenEdges::approaching);
if (edge->isScreenEdge()) {
connect(this, &ScreenEdges::checkBlocking, edge, &Edge::checkBlocking);
}
return edge;
}
ElectricBorderAction ScreenEdges::actionForEdge(Edge *edge) const
{
switch (edge->border()) {
case ElectricTopLeft:
return m_actionTopLeft;
case ElectricTop:
return m_actionTop;
case ElectricTopRight:
return m_actionTopRight;
case ElectricRight:
return m_actionRight;
case ElectricBottomRight:
return m_actionBottomRight;
case ElectricBottom:
return m_actionBottom;
case ElectricBottomLeft:
return m_actionBottomLeft;
case ElectricLeft:
return m_actionLeft;
default:
// fall through
break;
}
return ElectricActionNone;
}
ElectricBorderAction ScreenEdges::actionForTouchEdge(Edge *edge) const
{
auto it = m_touchActions.find(edge->border());
if (it != m_touchActions.end()) {
return it.value();
}
return ElectricActionNone;
}
void ScreenEdges::reserveDesktopSwitching(bool isToReserve, Qt::Orientations o)
{
if (!o)
return;
for (auto it = m_edges.begin(); it != m_edges.end(); ++it) {
Edge *edge = *it;
if (edge->isCorner()) {
isToReserve ? edge->reserve() : edge->unreserve();
} else {
if ((m_virtualDesktopLayout & Qt::Horizontal) && (edge->isLeft() || edge->isRight())) {
isToReserve ? edge->reserve() : edge->unreserve();
}
if ((m_virtualDesktopLayout & Qt::Vertical) && (edge->isTop() || edge->isBottom())) {
isToReserve ? edge->reserve() : edge->unreserve();
}
}
}
}
void ScreenEdges::reserve(ElectricBorder border, QObject *object, const char *slot)
{
for (auto it = m_edges.begin(); it != m_edges.end(); ++it) {
if ((*it)->border() == border) {
(*it)->reserve(object, slot);
}
}
}
void ScreenEdges::unreserve(ElectricBorder border, QObject *object)
{
for (auto it = m_edges.begin(); it != m_edges.end(); ++it) {
if ((*it)->border() == border) {
(*it)->unreserve(object);
}
}
}
void ScreenEdges::reserve(AbstractClient *client, ElectricBorder border)
Screenedge show support for Clients This provides a new protocol intended to be used by auto-hiding panels to make use of the centralized screen edges. To use it a Client can set an X11 property of type _KDE_NET_WM_SCREEN_EDGE_SHOW to KWin. As value it takes: * 0: top edge * 1: right edge * 2: bottom edge * 3: left edge KWin will hide the Client (hide because unmap or minimize would break it) and create an Edge. If that Edge gets triggered the Client is shown again and the property gets deleted. If the Client doesn't border the specified screen edge the Client gets shown immediately so that we never end in a situation that we cannot unhide the auto-hidden panel again. The exact process is described in the documentation of ScreenEdges. The Client can request to be shown again by deleting the property. If KWin gets restarted the state is read from the property and it is tried to create the edge as described. As this is a KWin specific extension we need to discuss what it means for Clients using this feature with other WMs: it does nothing. As the Client gets hidden by KWin and not by the Client, it just doesn't get hidden if the WM doesn't provide the feature. In case of an auto-hiding panel this seems like a good solution given that we don't want to hide it if we cannot unhide it. Of course there's the option for the Client to provide that feature itself and if that's wanted we would need to announce the feature in the _NET_SUPPORTED atom. At the moment that doesn't sound like being needed as Plasma doesn't want to provide an own implementation. The implementation comes with a small test application showing how the feature is intended to be used. REVIEW: 115910
2014-02-20 11:39:23 +00:00
{
bool hadBorder = false;
Screenedge show support for Clients This provides a new protocol intended to be used by auto-hiding panels to make use of the centralized screen edges. To use it a Client can set an X11 property of type _KDE_NET_WM_SCREEN_EDGE_SHOW to KWin. As value it takes: * 0: top edge * 1: right edge * 2: bottom edge * 3: left edge KWin will hide the Client (hide because unmap or minimize would break it) and create an Edge. If that Edge gets triggered the Client is shown again and the property gets deleted. If the Client doesn't border the specified screen edge the Client gets shown immediately so that we never end in a situation that we cannot unhide the auto-hidden panel again. The exact process is described in the documentation of ScreenEdges. The Client can request to be shown again by deleting the property. If KWin gets restarted the state is read from the property and it is tried to create the edge as described. As this is a KWin specific extension we need to discuss what it means for Clients using this feature with other WMs: it does nothing. As the Client gets hidden by KWin and not by the Client, it just doesn't get hidden if the WM doesn't provide the feature. In case of an auto-hiding panel this seems like a good solution given that we don't want to hide it if we cannot unhide it. Of course there's the option for the Client to provide that feature itself and if that's wanted we would need to announce the feature in the _NET_SUPPORTED atom. At the moment that doesn't sound like being needed as Plasma doesn't want to provide an own implementation. The implementation comes with a small test application showing how the feature is intended to be used. REVIEW: 115910
2014-02-20 11:39:23 +00:00
auto it = m_edges.begin();
while (it != m_edges.end()) {
if ((*it)->client() == client) {
hadBorder = true;
delete *it;
it = m_edges.erase(it);
Screenedge show support for Clients This provides a new protocol intended to be used by auto-hiding panels to make use of the centralized screen edges. To use it a Client can set an X11 property of type _KDE_NET_WM_SCREEN_EDGE_SHOW to KWin. As value it takes: * 0: top edge * 1: right edge * 2: bottom edge * 3: left edge KWin will hide the Client (hide because unmap or minimize would break it) and create an Edge. If that Edge gets triggered the Client is shown again and the property gets deleted. If the Client doesn't border the specified screen edge the Client gets shown immediately so that we never end in a situation that we cannot unhide the auto-hidden panel again. The exact process is described in the documentation of ScreenEdges. The Client can request to be shown again by deleting the property. If KWin gets restarted the state is read from the property and it is tried to create the edge as described. As this is a KWin specific extension we need to discuss what it means for Clients using this feature with other WMs: it does nothing. As the Client gets hidden by KWin and not by the Client, it just doesn't get hidden if the WM doesn't provide the feature. In case of an auto-hiding panel this seems like a good solution given that we don't want to hide it if we cannot unhide it. Of course there's the option for the Client to provide that feature itself and if that's wanted we would need to announce the feature in the _NET_SUPPORTED atom. At the moment that doesn't sound like being needed as Plasma doesn't want to provide an own implementation. The implementation comes with a small test application showing how the feature is intended to be used. REVIEW: 115910
2014-02-20 11:39:23 +00:00
} else {
it++;
}
}
if (border != ElectricNone) {
createEdgeForClient(client, border);
} else {
if (hadBorder) // show again
client->showOnScreenEdge();
}
Screenedge show support for Clients This provides a new protocol intended to be used by auto-hiding panels to make use of the centralized screen edges. To use it a Client can set an X11 property of type _KDE_NET_WM_SCREEN_EDGE_SHOW to KWin. As value it takes: * 0: top edge * 1: right edge * 2: bottom edge * 3: left edge KWin will hide the Client (hide because unmap or minimize would break it) and create an Edge. If that Edge gets triggered the Client is shown again and the property gets deleted. If the Client doesn't border the specified screen edge the Client gets shown immediately so that we never end in a situation that we cannot unhide the auto-hidden panel again. The exact process is described in the documentation of ScreenEdges. The Client can request to be shown again by deleting the property. If KWin gets restarted the state is read from the property and it is tried to create the edge as described. As this is a KWin specific extension we need to discuss what it means for Clients using this feature with other WMs: it does nothing. As the Client gets hidden by KWin and not by the Client, it just doesn't get hidden if the WM doesn't provide the feature. In case of an auto-hiding panel this seems like a good solution given that we don't want to hide it if we cannot unhide it. Of course there's the option for the Client to provide that feature itself and if that's wanted we would need to announce the feature in the _NET_SUPPORTED atom. At the moment that doesn't sound like being needed as Plasma doesn't want to provide an own implementation. The implementation comes with a small test application showing how the feature is intended to be used. REVIEW: 115910
2014-02-20 11:39:23 +00:00
}
void ScreenEdges::reserveTouch(ElectricBorder border, QAction *action)
{
for (auto it = m_edges.begin(); it != m_edges.end(); ++it) {
if ((*it)->border() == border) {
(*it)->reserveTouchCallBack(action);
}
}
}
void ScreenEdges::unreserveTouch(ElectricBorder border, QAction *action)
{
for (auto it = m_edges.begin(); it != m_edges.end(); ++it) {
if ((*it)->border() == border) {
(*it)->unreserveTouchCallBack(action);
}
}
}
void ScreenEdges::createEdgeForClient(AbstractClient *client, ElectricBorder border)
Screenedge show support for Clients This provides a new protocol intended to be used by auto-hiding panels to make use of the centralized screen edges. To use it a Client can set an X11 property of type _KDE_NET_WM_SCREEN_EDGE_SHOW to KWin. As value it takes: * 0: top edge * 1: right edge * 2: bottom edge * 3: left edge KWin will hide the Client (hide because unmap or minimize would break it) and create an Edge. If that Edge gets triggered the Client is shown again and the property gets deleted. If the Client doesn't border the specified screen edge the Client gets shown immediately so that we never end in a situation that we cannot unhide the auto-hidden panel again. The exact process is described in the documentation of ScreenEdges. The Client can request to be shown again by deleting the property. If KWin gets restarted the state is read from the property and it is tried to create the edge as described. As this is a KWin specific extension we need to discuss what it means for Clients using this feature with other WMs: it does nothing. As the Client gets hidden by KWin and not by the Client, it just doesn't get hidden if the WM doesn't provide the feature. In case of an auto-hiding panel this seems like a good solution given that we don't want to hide it if we cannot unhide it. Of course there's the option for the Client to provide that feature itself and if that's wanted we would need to announce the feature in the _NET_SUPPORTED atom. At the moment that doesn't sound like being needed as Plasma doesn't want to provide an own implementation. The implementation comes with a small test application showing how the feature is intended to be used. REVIEW: 115910
2014-02-20 11:39:23 +00:00
{
int y = 0;
int x = 0;
int width = 0;
int height = 0;
const QRect geo = client->frameGeometry();
2021-08-31 07:19:43 +00:00
const QRect fullArea = workspace()->geometry();
const auto outputs = kwinApp()->platform()->enabledOutputs();
for (const AbstractOutput *output : outputs) {
const QRect screen = output->geometry();
Screenedge show support for Clients This provides a new protocol intended to be used by auto-hiding panels to make use of the centralized screen edges. To use it a Client can set an X11 property of type _KDE_NET_WM_SCREEN_EDGE_SHOW to KWin. As value it takes: * 0: top edge * 1: right edge * 2: bottom edge * 3: left edge KWin will hide the Client (hide because unmap or minimize would break it) and create an Edge. If that Edge gets triggered the Client is shown again and the property gets deleted. If the Client doesn't border the specified screen edge the Client gets shown immediately so that we never end in a situation that we cannot unhide the auto-hidden panel again. The exact process is described in the documentation of ScreenEdges. The Client can request to be shown again by deleting the property. If KWin gets restarted the state is read from the property and it is tried to create the edge as described. As this is a KWin specific extension we need to discuss what it means for Clients using this feature with other WMs: it does nothing. As the Client gets hidden by KWin and not by the Client, it just doesn't get hidden if the WM doesn't provide the feature. In case of an auto-hiding panel this seems like a good solution given that we don't want to hide it if we cannot unhide it. Of course there's the option for the Client to provide that feature itself and if that's wanted we would need to announce the feature in the _NET_SUPPORTED atom. At the moment that doesn't sound like being needed as Plasma doesn't want to provide an own implementation. The implementation comes with a small test application showing how the feature is intended to be used. REVIEW: 115910
2014-02-20 11:39:23 +00:00
if (!screen.contains(geo)) {
// ignoring Clients having a geometry overlapping with multiple screens
// this would make the code more complex. If it's needed in future it can be added
continue;
}
const bool bordersTop = (screen.y() == geo.y());
const bool bordersLeft = (screen.x() == geo.x());
const bool bordersBottom = (screen.y() + screen.height() == geo.y() + geo.height());
const bool bordersRight = (screen.x() + screen.width() == geo.x() + geo.width());
if (bordersTop && border == ElectricTop) {
if (!isTopScreen(screen, fullArea)) {
continue;
}
y = geo.y();
x = geo.x();
height = 1;
width = geo.width();
break;
}
if (bordersBottom && border == ElectricBottom) {
if (!isBottomScreen(screen, fullArea)) {
continue;
}
y = geo.y() + geo.height() - 1;
x = geo.x();
height = 1;
width = geo.width();
break;
}
if (bordersLeft && border == ElectricLeft) {
if (!isLeftScreen(screen, fullArea)) {
continue;
}
x = geo.x();
y = geo.y();
width = 1;
height = geo.height();
break;
}
if (bordersRight && border == ElectricRight) {
if (!isRightScreen(screen, fullArea)) {
continue;
}
x = geo.x() + geo.width() - 1;
y = geo.y();
width = 1;
height = geo.height();
break;
}
}
if (width > 0 && height > 0) {
Edge *edge = createEdge(border, x, y, width, height, false);
Screenedge show support for Clients This provides a new protocol intended to be used by auto-hiding panels to make use of the centralized screen edges. To use it a Client can set an X11 property of type _KDE_NET_WM_SCREEN_EDGE_SHOW to KWin. As value it takes: * 0: top edge * 1: right edge * 2: bottom edge * 3: left edge KWin will hide the Client (hide because unmap or minimize would break it) and create an Edge. If that Edge gets triggered the Client is shown again and the property gets deleted. If the Client doesn't border the specified screen edge the Client gets shown immediately so that we never end in a situation that we cannot unhide the auto-hidden panel again. The exact process is described in the documentation of ScreenEdges. The Client can request to be shown again by deleting the property. If KWin gets restarted the state is read from the property and it is tried to create the edge as described. As this is a KWin specific extension we need to discuss what it means for Clients using this feature with other WMs: it does nothing. As the Client gets hidden by KWin and not by the Client, it just doesn't get hidden if the WM doesn't provide the feature. In case of an auto-hiding panel this seems like a good solution given that we don't want to hide it if we cannot unhide it. Of course there's the option for the Client to provide that feature itself and if that's wanted we would need to announce the feature in the _NET_SUPPORTED atom. At the moment that doesn't sound like being needed as Plasma doesn't want to provide an own implementation. The implementation comes with a small test application showing how the feature is intended to be used. REVIEW: 115910
2014-02-20 11:39:23 +00:00
edge->setClient(client);
m_edges.append(edge);
edge->reserve();
Screenedge show support for Clients This provides a new protocol intended to be used by auto-hiding panels to make use of the centralized screen edges. To use it a Client can set an X11 property of type _KDE_NET_WM_SCREEN_EDGE_SHOW to KWin. As value it takes: * 0: top edge * 1: right edge * 2: bottom edge * 3: left edge KWin will hide the Client (hide because unmap or minimize would break it) and create an Edge. If that Edge gets triggered the Client is shown again and the property gets deleted. If the Client doesn't border the specified screen edge the Client gets shown immediately so that we never end in a situation that we cannot unhide the auto-hidden panel again. The exact process is described in the documentation of ScreenEdges. The Client can request to be shown again by deleting the property. If KWin gets restarted the state is read from the property and it is tried to create the edge as described. As this is a KWin specific extension we need to discuss what it means for Clients using this feature with other WMs: it does nothing. As the Client gets hidden by KWin and not by the Client, it just doesn't get hidden if the WM doesn't provide the feature. In case of an auto-hiding panel this seems like a good solution given that we don't want to hide it if we cannot unhide it. Of course there's the option for the Client to provide that feature itself and if that's wanted we would need to announce the feature in the _NET_SUPPORTED atom. At the moment that doesn't sound like being needed as Plasma doesn't want to provide an own implementation. The implementation comes with a small test application showing how the feature is intended to be used. REVIEW: 115910
2014-02-20 11:39:23 +00:00
} else {
// we could not create an edge window, so don't allow the window to hide
client->showOnScreenEdge();
}
}
void ScreenEdges::deleteEdgeForClient(AbstractClient* c)
Screenedge show support for Clients This provides a new protocol intended to be used by auto-hiding panels to make use of the centralized screen edges. To use it a Client can set an X11 property of type _KDE_NET_WM_SCREEN_EDGE_SHOW to KWin. As value it takes: * 0: top edge * 1: right edge * 2: bottom edge * 3: left edge KWin will hide the Client (hide because unmap or minimize would break it) and create an Edge. If that Edge gets triggered the Client is shown again and the property gets deleted. If the Client doesn't border the specified screen edge the Client gets shown immediately so that we never end in a situation that we cannot unhide the auto-hidden panel again. The exact process is described in the documentation of ScreenEdges. The Client can request to be shown again by deleting the property. If KWin gets restarted the state is read from the property and it is tried to create the edge as described. As this is a KWin specific extension we need to discuss what it means for Clients using this feature with other WMs: it does nothing. As the Client gets hidden by KWin and not by the Client, it just doesn't get hidden if the WM doesn't provide the feature. In case of an auto-hiding panel this seems like a good solution given that we don't want to hide it if we cannot unhide it. Of course there's the option for the Client to provide that feature itself and if that's wanted we would need to announce the feature in the _NET_SUPPORTED atom. At the moment that doesn't sound like being needed as Plasma doesn't want to provide an own implementation. The implementation comes with a small test application showing how the feature is intended to be used. REVIEW: 115910
2014-02-20 11:39:23 +00:00
{
auto it = m_edges.begin();
while (it != m_edges.end()) {
if ((*it)->client() == c) {
delete *it;
it = m_edges.erase(it);
} else {
it++;
}
}
}
void ScreenEdges::check(const QPoint &pos, const QDateTime &now, bool forceNoPushBack)
{
Screenedge show support for Clients This provides a new protocol intended to be used by auto-hiding panels to make use of the centralized screen edges. To use it a Client can set an X11 property of type _KDE_NET_WM_SCREEN_EDGE_SHOW to KWin. As value it takes: * 0: top edge * 1: right edge * 2: bottom edge * 3: left edge KWin will hide the Client (hide because unmap or minimize would break it) and create an Edge. If that Edge gets triggered the Client is shown again and the property gets deleted. If the Client doesn't border the specified screen edge the Client gets shown immediately so that we never end in a situation that we cannot unhide the auto-hidden panel again. The exact process is described in the documentation of ScreenEdges. The Client can request to be shown again by deleting the property. If KWin gets restarted the state is read from the property and it is tried to create the edge as described. As this is a KWin specific extension we need to discuss what it means for Clients using this feature with other WMs: it does nothing. As the Client gets hidden by KWin and not by the Client, it just doesn't get hidden if the WM doesn't provide the feature. In case of an auto-hiding panel this seems like a good solution given that we don't want to hide it if we cannot unhide it. Of course there's the option for the Client to provide that feature itself and if that's wanted we would need to announce the feature in the _NET_SUPPORTED atom. At the moment that doesn't sound like being needed as Plasma doesn't want to provide an own implementation. The implementation comes with a small test application showing how the feature is intended to be used. REVIEW: 115910
2014-02-20 11:39:23 +00:00
bool activatedForClient = false;
for (auto it = m_edges.begin(); it != m_edges.end(); ++it) {
if (!(*it)->isReserved()) {
continue;
}
if (!(*it)->activatesForPointer()) {
continue;
}
if ((*it)->approachGeometry().contains(pos)) {
(*it)->startApproaching();
}
Screenedge show support for Clients This provides a new protocol intended to be used by auto-hiding panels to make use of the centralized screen edges. To use it a Client can set an X11 property of type _KDE_NET_WM_SCREEN_EDGE_SHOW to KWin. As value it takes: * 0: top edge * 1: right edge * 2: bottom edge * 3: left edge KWin will hide the Client (hide because unmap or minimize would break it) and create an Edge. If that Edge gets triggered the Client is shown again and the property gets deleted. If the Client doesn't border the specified screen edge the Client gets shown immediately so that we never end in a situation that we cannot unhide the auto-hidden panel again. The exact process is described in the documentation of ScreenEdges. The Client can request to be shown again by deleting the property. If KWin gets restarted the state is read from the property and it is tried to create the edge as described. As this is a KWin specific extension we need to discuss what it means for Clients using this feature with other WMs: it does nothing. As the Client gets hidden by KWin and not by the Client, it just doesn't get hidden if the WM doesn't provide the feature. In case of an auto-hiding panel this seems like a good solution given that we don't want to hide it if we cannot unhide it. Of course there's the option for the Client to provide that feature itself and if that's wanted we would need to announce the feature in the _NET_SUPPORTED atom. At the moment that doesn't sound like being needed as Plasma doesn't want to provide an own implementation. The implementation comes with a small test application showing how the feature is intended to be used. REVIEW: 115910
2014-02-20 11:39:23 +00:00
if ((*it)->client() != nullptr && activatedForClient) {
(*it)->markAsTriggered(pos, now);
continue;
}
if ((*it)->check(pos, now, forceNoPushBack)) {
if ((*it)->client()) {
activatedForClient = true;
}
}
}
}
bool ScreenEdges::isEntered(QMouseEvent *event)
{
if (event->type() != QEvent::MouseMove) {
return false;
}
bool activated = false;
bool activatedForClient = false;
for (auto it = m_edges.begin(); it != m_edges.end(); ++it) {
Edge *edge = *it;
if (!edge->isReserved()) {
continue;
}
if (!edge->activatesForPointer()) {
continue;
}
if (edge->approachGeometry().contains(event->globalPos())) {
if (!edge->isApproaching()) {
edge->startApproaching();
} else {
edge->updateApproaching(event->globalPos());
}
} else {
if (edge->isApproaching()) {
edge->stopApproaching();
}
}
if (edge->geometry().contains(event->globalPos())) {
if (edge->check(event->globalPos(), QDateTime::fromMSecsSinceEpoch(event->timestamp(), Qt::UTC))) {
if (edge->client()) {
activatedForClient = true;
}
}
}
}
if (activatedForClient) {
for (auto it = m_edges.constBegin(); it != m_edges.constEnd(); ++it) {
if ((*it)->client()) {
(*it)->markAsTriggered(event->globalPos(), QDateTime::fromMSecsSinceEpoch(event->timestamp(), Qt::UTC));
}
}
}
return activated;
}
bool ScreenEdges::handleEnterNotifiy(xcb_window_t window, const QPoint &point, const QDateTime &timestamp)
{
Screenedge show support for Clients This provides a new protocol intended to be used by auto-hiding panels to make use of the centralized screen edges. To use it a Client can set an X11 property of type _KDE_NET_WM_SCREEN_EDGE_SHOW to KWin. As value it takes: * 0: top edge * 1: right edge * 2: bottom edge * 3: left edge KWin will hide the Client (hide because unmap or minimize would break it) and create an Edge. If that Edge gets triggered the Client is shown again and the property gets deleted. If the Client doesn't border the specified screen edge the Client gets shown immediately so that we never end in a situation that we cannot unhide the auto-hidden panel again. The exact process is described in the documentation of ScreenEdges. The Client can request to be shown again by deleting the property. If KWin gets restarted the state is read from the property and it is tried to create the edge as described. As this is a KWin specific extension we need to discuss what it means for Clients using this feature with other WMs: it does nothing. As the Client gets hidden by KWin and not by the Client, it just doesn't get hidden if the WM doesn't provide the feature. In case of an auto-hiding panel this seems like a good solution given that we don't want to hide it if we cannot unhide it. Of course there's the option for the Client to provide that feature itself and if that's wanted we would need to announce the feature in the _NET_SUPPORTED atom. At the moment that doesn't sound like being needed as Plasma doesn't want to provide an own implementation. The implementation comes with a small test application showing how the feature is intended to be used. REVIEW: 115910
2014-02-20 11:39:23 +00:00
bool activated = false;
bool activatedForClient = false;
for (auto it = m_edges.begin(); it != m_edges.end(); ++it) {
Edge *edge = *it;
if (!edge || edge->window() == XCB_WINDOW_NONE) {
continue;
}
if (!edge->isReserved()) {
continue;
}
if (!edge->activatesForPointer()) {
continue;
}
if (edge->window() == window) {
Screenedge show support for Clients This provides a new protocol intended to be used by auto-hiding panels to make use of the centralized screen edges. To use it a Client can set an X11 property of type _KDE_NET_WM_SCREEN_EDGE_SHOW to KWin. As value it takes: * 0: top edge * 1: right edge * 2: bottom edge * 3: left edge KWin will hide the Client (hide because unmap or minimize would break it) and create an Edge. If that Edge gets triggered the Client is shown again and the property gets deleted. If the Client doesn't border the specified screen edge the Client gets shown immediately so that we never end in a situation that we cannot unhide the auto-hidden panel again. The exact process is described in the documentation of ScreenEdges. The Client can request to be shown again by deleting the property. If KWin gets restarted the state is read from the property and it is tried to create the edge as described. As this is a KWin specific extension we need to discuss what it means for Clients using this feature with other WMs: it does nothing. As the Client gets hidden by KWin and not by the Client, it just doesn't get hidden if the WM doesn't provide the feature. In case of an auto-hiding panel this seems like a good solution given that we don't want to hide it if we cannot unhide it. Of course there's the option for the Client to provide that feature itself and if that's wanted we would need to announce the feature in the _NET_SUPPORTED atom. At the moment that doesn't sound like being needed as Plasma doesn't want to provide an own implementation. The implementation comes with a small test application showing how the feature is intended to be used. REVIEW: 115910
2014-02-20 11:39:23 +00:00
if (edge->check(point, timestamp)) {
if ((*it)->client()) {
activatedForClient = true;
}
}
activated = true;
break;
}
if (edge->approachWindow() == window) {
edge->startApproaching();
// TODO: if it's a corner, it should also trigger for other windows
return true;
}
}
Screenedge show support for Clients This provides a new protocol intended to be used by auto-hiding panels to make use of the centralized screen edges. To use it a Client can set an X11 property of type _KDE_NET_WM_SCREEN_EDGE_SHOW to KWin. As value it takes: * 0: top edge * 1: right edge * 2: bottom edge * 3: left edge KWin will hide the Client (hide because unmap or minimize would break it) and create an Edge. If that Edge gets triggered the Client is shown again and the property gets deleted. If the Client doesn't border the specified screen edge the Client gets shown immediately so that we never end in a situation that we cannot unhide the auto-hidden panel again. The exact process is described in the documentation of ScreenEdges. The Client can request to be shown again by deleting the property. If KWin gets restarted the state is read from the property and it is tried to create the edge as described. As this is a KWin specific extension we need to discuss what it means for Clients using this feature with other WMs: it does nothing. As the Client gets hidden by KWin and not by the Client, it just doesn't get hidden if the WM doesn't provide the feature. In case of an auto-hiding panel this seems like a good solution given that we don't want to hide it if we cannot unhide it. Of course there's the option for the Client to provide that feature itself and if that's wanted we would need to announce the feature in the _NET_SUPPORTED atom. At the moment that doesn't sound like being needed as Plasma doesn't want to provide an own implementation. The implementation comes with a small test application showing how the feature is intended to be used. REVIEW: 115910
2014-02-20 11:39:23 +00:00
if (activatedForClient) {
for (auto it = m_edges.constBegin(); it != m_edges.constEnd(); ++it) {
if ((*it)->client()) {
(*it)->markAsTriggered(point, timestamp);
}
}
}
return activated;
}
bool ScreenEdges::handleDndNotify(xcb_window_t window, const QPoint &point)
{
for (auto it = m_edges.begin(); it != m_edges.end(); ++it) {
Edge *edge = *it;
if (!edge || edge->window() == XCB_WINDOW_NONE) {
continue;
}
if (edge->isReserved() && edge->window() == window) {
updateXTime();
edge->check(point, QDateTime::fromMSecsSinceEpoch(xTime(), Qt::UTC), true);
return true;
}
}
return false;
}
void ScreenEdges::ensureOnTop()
{
Xcb::restackWindowsWithRaise(windows());
}
QVector< xcb_window_t > ScreenEdges::windows() const
{
QVector<xcb_window_t> wins;
for (auto it = m_edges.constBegin();
it != m_edges.constEnd();
++it) {
Edge *edge = *it;
xcb_window_t w = edge->window();
if (w != XCB_WINDOW_NONE) {
wins.append(w);
}
// TODO: lambda
w = edge->approachWindow();
if (w != XCB_WINDOW_NONE) {
wins.append(w);
}
}
return wins;
}
} //namespace