kwin/abstract_client.cpp

3594 lines
122 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: 2015 Martin Gräßlin <mgraesslin@kde.org>
SPDX-FileCopyrightText: 2019 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
2020-08-02 22:22:19 +00:00
SPDX-License-Identifier: GPL-2.0-or-later
*/
#include "abstract_client.h"
#include "appmenu.h"
#include "decorations/decoratedclient.h"
#include "decorations/decorationpalette.h"
#include "decorations/decorationbridge.h"
#include "effects.h"
#include "focuschain.h"
#include "outline.h"
#include "screens.h"
#ifdef KWIN_BUILD_TABBOX
#include "tabbox.h"
#endif
#include "screenedge.h"
#include "useractions.h"
#include "workspace.h"
#include "wayland_server.h"
#include <KWaylandServer/plasmawindowmanagement_interface.h>
#include <KDecoration2/DecoratedClient>
#include <KDecoration2/Decoration>
#include <KDesktopFile>
#include <QDir>
#include <QMouseEvent>
#include <QStyleHints>
namespace KWin
{
static inline int sign(int v)
{
return (v > 0) - (v < 0);
}
QHash<QString, std::weak_ptr<Decoration::DecorationPalette>> AbstractClient::s_palettes;
std::shared_ptr<Decoration::DecorationPalette> AbstractClient::s_defaultPalette;
AbstractClient::AbstractClient()
: Toplevel()
#ifdef KWIN_BUILD_TABBOX
, m_tabBoxClient(QSharedPointer<TabBox::TabBoxClientImpl>(new TabBox::TabBoxClientImpl(this)))
#endif
, m_colorScheme(QStringLiteral("kdeglobals"))
{
connect(this, &AbstractClient::clientStartUserMovedResized, this, &AbstractClient::moveResizedChanged);
connect(this, &AbstractClient::clientFinishUserMovedResized, this, &AbstractClient::moveResizedChanged);
connect(this, &AbstractClient::clientStartUserMovedResized, this, &AbstractClient::removeCheckScreenConnection);
connect(this, &AbstractClient::clientFinishUserMovedResized, this, &AbstractClient::setupCheckScreenConnection);
connect(this, &AbstractClient::paletteChanged, this, &AbstractClient::triggerDecorationRepaint);
connect(Decoration::DecorationBridge::self(), &QObject::destroyed, this, &AbstractClient::destroyDecoration);
// If the user manually moved the window, don't restore it after the keyboard closes
connect(this, &AbstractClient::clientFinishUserMovedResized, this, [this] () {
m_keyboardGeometryRestore = QRect();
});
connect(this, qOverload<AbstractClient *, bool, bool>(&AbstractClient::clientMaximizedStateChanged), this, [this] () {
m_keyboardGeometryRestore = QRect();
});
connect(this, &AbstractClient::fullScreenChanged, this, [this] () {
m_keyboardGeometryRestore = QRect();
});
// replace on-screen-display on size changes
connect(this, &AbstractClient::frameGeometryChanged, this,
[this] (Toplevel *c, const QRect &old) {
Q_UNUSED(c)
if (isOnScreenDisplay() && !frameGeometry().isEmpty() && old.size() != frameGeometry().size() && isPlaceable()) {
GeometryUpdatesBlocker blocker(this);
const QRect area = workspace()->clientArea(PlacementArea, Screens::self()->current(), desktop());
Placement::self()->place(this, area);
setGeometryRestore(frameGeometry());
}
}
);
connect(this, &AbstractClient::paddingChanged, this, [this]() {
m_visibleRectBeforeGeometryUpdate = visibleRect();
});
connect(ApplicationMenu::self(), &ApplicationMenu::applicationMenuEnabledChanged, this, [this] {
emit hasApplicationMenuChanged(hasApplicationMenu());
});
}
AbstractClient::~AbstractClient()
{
Q_ASSERT(m_blockGeometryUpdates == 0);
Q_ASSERT(m_decoration.decoration == nullptr);
}
void AbstractClient::updateMouseGrab()
{
}
Allow a cross-process check for same applications Summary: Commit 5d9027b110 introduced a regression in TabBox by using the generic framework inside KWin to test for same application. What I did not consider was that the code in TabBox was "broken by design". It didn't use the generic check as that is too strict and considers windows from different processes as not belonging to the same application. But this is not wanted in the case of TabBox. On the other hand the change itself is an improvement to also support Wayland in a better way and not have special handling situations. Thus just reverting would not help. Instead this change addresses the problem by extending the internal API and to allow more adjustements. So far there was already an "active_hack" boolean flag. This is extended to proper flags with an additional flag to allow cross application checks. The checks in Client which would filter out different applications check for this flag and are skipped if set. In addition ShellClient also adds support for this flag and compares for the desktop file name. Thus we get in TabBox the same behavior as before with the advantage of having a better shared code base working on both X11 and Wayland. BUG: 386043 FIXED-IN: 5.11.4 Test Plan: Started two kwrite processes on X11, clicked new in one of them, used Alt+` and verified that there are three windows shown. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D8661
2017-11-05 09:10:17 +00:00
bool AbstractClient::belongToSameApplication(const AbstractClient *c1, const AbstractClient *c2, SameApplicationChecks checks)
{
Allow a cross-process check for same applications Summary: Commit 5d9027b110 introduced a regression in TabBox by using the generic framework inside KWin to test for same application. What I did not consider was that the code in TabBox was "broken by design". It didn't use the generic check as that is too strict and considers windows from different processes as not belonging to the same application. But this is not wanted in the case of TabBox. On the other hand the change itself is an improvement to also support Wayland in a better way and not have special handling situations. Thus just reverting would not help. Instead this change addresses the problem by extending the internal API and to allow more adjustements. So far there was already an "active_hack" boolean flag. This is extended to proper flags with an additional flag to allow cross application checks. The checks in Client which would filter out different applications check for this flag and are skipped if set. In addition ShellClient also adds support for this flag and compares for the desktop file name. Thus we get in TabBox the same behavior as before with the advantage of having a better shared code base working on both X11 and Wayland. BUG: 386043 FIXED-IN: 5.11.4 Test Plan: Started two kwrite processes on X11, clicked new in one of them, used Alt+` and verified that there are three windows shown. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D8661
2017-11-05 09:10:17 +00:00
return c1->belongsToSameApplication(c2, checks);
}
bool AbstractClient::isTransient() const
{
return false;
}
void AbstractClient::setClientShown(bool shown)
{
Q_UNUSED(shown)
}
xcb_timestamp_t AbstractClient::userTime() const
{
return XCB_TIME_CURRENT_TIME;
}
void AbstractClient::setSkipSwitcher(bool set)
{
set = rules()->checkSkipSwitcher(set);
if (set == skipSwitcher())
return;
m_skipSwitcher = set;
doSetSkipSwitcher();
updateWindowRules(Rules::SkipSwitcher);
emit skipSwitcherChanged();
}
void AbstractClient::setSkipPager(bool b)
{
b = rules()->checkSkipPager(b);
if (b == skipPager())
return;
m_skipPager = b;
doSetSkipPager();
updateWindowRules(Rules::SkipPager);
emit skipPagerChanged();
}
void AbstractClient::doSetSkipPager()
{
}
void AbstractClient::setSkipTaskbar(bool b)
{
int was_wants_tab_focus = wantsTabFocus();
if (b == skipTaskbar())
return;
m_skipTaskbar = b;
doSetSkipTaskbar();
updateWindowRules(Rules::SkipTaskbar);
if (was_wants_tab_focus != wantsTabFocus()) {
FocusChain::self()->update(this, isActive() ? FocusChain::MakeFirst : FocusChain::Update);
}
emit skipTaskbarChanged();
}
void AbstractClient::setOriginalSkipTaskbar(bool b)
{
m_originalSkipTaskbar = rules()->checkSkipTaskbar(b);
setSkipTaskbar(m_originalSkipTaskbar);
}
void AbstractClient::doSetSkipTaskbar()
{
}
void AbstractClient::doSetSkipSwitcher()
{
}
void AbstractClient::setIcon(const QIcon &icon)
{
m_icon = icon;
emit iconChanged();
}
void AbstractClient::setActive(bool act)
{
if (isZombie()) {
return;
}
if (m_active == act) {
return;
}
m_active = act;
const int ruledOpacity = m_active
? rules()->checkOpacityActive(qRound(opacity() * 100.0))
: rules()->checkOpacityInactive(qRound(opacity() * 100.0));
setOpacity(ruledOpacity / 100.0);
workspace()->setActiveClient(act ? this : nullptr);
if (!m_active)
cancelAutoRaise();
if (!m_active && shadeMode() == ShadeActivated)
setShade(ShadeNormal);
StackingUpdatesBlocker blocker(workspace());
workspace()->updateClientLayer(this); // active windows may get different layer
auto mainclients = mainClients();
for (auto it = mainclients.constBegin();
it != mainclients.constEnd();
++it)
if ((*it)->isFullScreen()) // fullscreens go high even if their transient is active
workspace()->updateClientLayer(*it);
doSetActive();
emit activeChanged();
updateMouseGrab();
}
void AbstractClient::doSetActive()
{
}
bool AbstractClient::isZombie() const
{
return m_zombie;
}
void AbstractClient::markAsZombie()
{
Q_ASSERT(!m_zombie);
m_zombie = true;
addWorkspaceRepaint(visibleRect());
}
Layer AbstractClient::layer() const
{
if (m_layer == UnknownLayer)
const_cast< AbstractClient* >(this)->m_layer = belongsToLayer();
return m_layer;
}
void AbstractClient::updateLayer()
{
if (layer() == belongsToLayer())
return;
StackingUpdatesBlocker blocker(workspace());
invalidateLayer(); // invalidate, will be updated when doing restacking
for (auto it = transients().constBegin(),
end = transients().constEnd(); it != end; ++it)
(*it)->updateLayer();
}
void AbstractClient::placeIn(const QRect &area)
{
// TODO: Get rid of this method eventually. We need to call setGeometryRestore() because
// checkWorkspacePosition() operates on geometryRestore() and because of quick tiling.
Placement::self()->place(this, area);
setGeometryRestore(frameGeometry());
}
void AbstractClient::invalidateLayer()
{
m_layer = UnknownLayer;
}
Layer AbstractClient::belongsToLayer() const
{
// NOTICE while showingDesktop, desktops move to the AboveLayer
// (interchangeable w/ eg. yakuake etc. which will at first remain visible)
// and the docks move into the NotificationLayer (which is between Above- and
// ActiveLayer, so that active fullscreen windows will still cover everything)
// Since the desktop is also activated, nothing should be in the ActiveLayer, though
if (isInternal())
return UnmanagedLayer;
if (isLockScreen())
return UnmanagedLayer;
if (isInputMethod())
return UnmanagedLayer;
if (isDesktop())
return workspace()->showingDesktop() ? AboveLayer : DesktopLayer;
if (isSplash()) // no damn annoying splashscreens
return NormalLayer; // getting in the way of everything else
if (isDock()) {
if (workspace()->showingDesktop())
return NotificationLayer;
return layerForDock();
}
if (isOnScreenDisplay())
return OnScreenDisplayLayer;
if (isNotification())
return NotificationLayer;
if (isCriticalNotification())
return CriticalNotificationLayer;
if (workspace()->showingDesktop() && belongsToDesktop()) {
return AboveLayer;
}
if (keepBelow())
return BelowLayer;
if (isActiveFullScreen())
return ActiveLayer;
if (keepAbove())
return AboveLayer;
return NormalLayer;
}
bool AbstractClient::belongsToDesktop() const
{
return false;
}
Layer AbstractClient::layerForDock() const
{
// slight hack for the 'allow window to cover panel' Kicker setting
// don't move keepbelow docks below normal window, but only to the same
// layer, so that both may be raised to cover the other
if (keepBelow())
return NormalLayer;
if (keepAbove()) // slight hack for the autohiding panels
return AboveLayer;
return DockLayer;
}
void AbstractClient::setKeepAbove(bool b)
{
b = rules()->checkKeepAbove(b);
if (b && !rules()->checkKeepBelow(false))
setKeepBelow(false);
if (b == keepAbove()) {
return;
}
m_keepAbove = b;
doSetKeepAbove();
workspace()->updateClientLayer(this);
updateWindowRules(Rules::Above);
emit keepAboveChanged(m_keepAbove);
}
void AbstractClient::doSetKeepAbove()
{
}
void AbstractClient::setKeepBelow(bool b)
{
b = rules()->checkKeepBelow(b);
if (b && !rules()->checkKeepAbove(false))
setKeepAbove(false);
if (b == keepBelow()) {
return;
}
m_keepBelow = b;
doSetKeepBelow();
workspace()->updateClientLayer(this);
updateWindowRules(Rules::Below);
emit keepBelowChanged(m_keepBelow);
}
void AbstractClient::doSetKeepBelow()
{
}
void AbstractClient::startAutoRaise()
{
delete m_autoRaiseTimer;
m_autoRaiseTimer = new QTimer(this);
connect(m_autoRaiseTimer, &QTimer::timeout, this, &AbstractClient::autoRaise);
m_autoRaiseTimer->setSingleShot(true);
m_autoRaiseTimer->start(options->autoRaiseInterval());
}
void AbstractClient::cancelAutoRaise()
{
delete m_autoRaiseTimer;
m_autoRaiseTimer = nullptr;
}
void AbstractClient::autoRaise()
{
workspace()->raiseClient(this);
cancelAutoRaise();
}
bool AbstractClient::isMostRecentlyRaised() const
{
// The last toplevel in the unconstrained stacking order is the most recently raised one.
return workspace()->topClientOnDesktop(VirtualDesktopManager::self()->current(), -1, true, false) == this;
}
bool AbstractClient::wantsTabFocus() const
{
return (isNormalWindow() || isDialog()) && wantsInput();
}
bool AbstractClient::isSpecialWindow() const
{
// TODO
return isDesktop() || isDock() || isSplash() || isToolbar() || isNotification() || isOnScreenDisplay() || isCriticalNotification();
}
void AbstractClient::demandAttention(bool set)
{
if (isActive())
set = false;
if (m_demandsAttention == set)
return;
m_demandsAttention = set;
doSetDemandsAttention();
workspace()->clientAttentionChanged(this, set);
emit demandsAttentionChanged();
}
void AbstractClient::doSetDemandsAttention()
{
}
void AbstractClient::setDesktop(int desktop)
{
const int numberOfDesktops = VirtualDesktopManager::self()->count();
if (desktop != NET::OnAllDesktops) // Do range check
desktop = qMax(1, qMin(numberOfDesktops, desktop));
desktop = qMin(numberOfDesktops, rules()->checkDesktop(desktop));
QVector<VirtualDesktop *> desktops;
if (desktop != NET::OnAllDesktops) {
desktops << VirtualDesktopManager::self()->desktopForX11Id(desktop);
}
setDesktops(desktops);
}
void AbstractClient::setDesktops(QVector<VirtualDesktop*> desktops)
{
//on x11 we can have only one desktop at a time
if (kwinApp()->operationMode() == Application::OperationModeX11 && desktops.size() > 1) {
desktops = QVector<VirtualDesktop*>({desktops.last()});
}
if (desktops == m_desktops) {
return;
}
int was_desk = AbstractClient::desktop();
const bool wasOnCurrentDesktop = isOnCurrentDesktop() && was_desk >= 0;
m_desktops = desktops;
if (windowManagementInterface()) {
if (m_desktops.isEmpty()) {
windowManagementInterface()->setOnAllDesktops(true);
} else {
windowManagementInterface()->setOnAllDesktops(false);
auto currentDesktops = windowManagementInterface()->plasmaVirtualDesktops();
for (auto desktop: m_desktops) {
if (!currentDesktops.contains(desktop->id())) {
windowManagementInterface()->addPlasmaVirtualDesktop(desktop->id());
} else {
currentDesktops.removeOne(desktop->id());
}
}
for (auto desktopId: currentDesktops) {
windowManagementInterface()->removePlasmaVirtualDesktop(desktopId);
}
}
}
if (info) {
info->setDesktop(desktop());
}
if ((was_desk == NET::OnAllDesktops) != (desktop() == NET::OnAllDesktops)) {
// onAllDesktops changed
workspace()->updateOnAllDesktopsOfTransients(this);
}
auto transients_stacking_order = workspace()->ensureStackingOrder(transients());
for (auto it = transients_stacking_order.constBegin();
it != transients_stacking_order.constEnd();
++it)
(*it)->setDesktops(desktops);
if (isModal()) // if a modal dialog is moved, move the mainwindow with it as otherwise
// the (just moved) modal dialog will confusingly return to the mainwindow with
// the next desktop change
{
foreach (AbstractClient * c2, mainClients())
c2->setDesktops(desktops);
}
doSetDesktop();
FocusChain::self()->update(this, FocusChain::MakeFirst);
updateWindowRules(Rules::Desktop);
emit desktopChanged();
if (wasOnCurrentDesktop != isOnCurrentDesktop())
emit desktopPresenceChanged(this, was_desk);
emit x11DesktopIdsChanged();
}
void AbstractClient::doSetDesktop()
{
}
void AbstractClient::enterDesktop(VirtualDesktop *virtualDesktop)
{
if (m_desktops.contains(virtualDesktop)) {
return;
}
auto desktops = m_desktops;
desktops.append(virtualDesktop);
setDesktops(desktops);
}
void AbstractClient::leaveDesktop(VirtualDesktop *virtualDesktop)
{
QVector<VirtualDesktop*> currentDesktops;
if (m_desktops.isEmpty()) {
currentDesktops = VirtualDesktopManager::self()->desktops();
} else {
currentDesktops = m_desktops;
}
if (!currentDesktops.contains(virtualDesktop)) {
return;
}
auto desktops = currentDesktops;
desktops.removeOne(virtualDesktop);
setDesktops(desktops);
}
void AbstractClient::setOnAllDesktops(bool b)
{
if ((b && isOnAllDesktops()) ||
(!b && !isOnAllDesktops()))
return;
if (b)
setDesktop(NET::OnAllDesktops);
else
setDesktop(VirtualDesktopManager::self()->current());
}
QVector<uint> AbstractClient::x11DesktopIds() const
{
const auto desks = desktops();
QVector<uint> x11Ids;
x11Ids.reserve(desks.count());
std::transform(desks.constBegin(), desks.constEnd(),
std::back_inserter(x11Ids),
[] (const VirtualDesktop *vd) {
return vd->x11DesktopNumber();
}
);
return x11Ids;
}
ShadeMode AbstractClient::shadeMode() const
{
return m_shadeMode;
}
bool AbstractClient::isShadeable() const
{
return false;
}
void AbstractClient::setShade(bool set)
{
set ? setShade(ShadeNormal) : setShade(ShadeNone);
}
void AbstractClient::setShade(ShadeMode mode)
{
if (!isShadeable())
return;
if (mode == ShadeHover && isMove())
return; // causes geometry breaks and is probably nasty
if (isSpecialWindow() || noBorder())
mode = ShadeNone;
mode = rules()->checkShade(mode);
if (m_shadeMode == mode)
return;
const bool wasShade = isShade();
const ShadeMode previousShadeMode = shadeMode();
m_shadeMode = mode;
if (wasShade == isShade()) {
// Decoration may want to update after e.g. hover-shade changes
emit shadeChanged();
return; // No real change in shaded state
}
Q_ASSERT(isDecorated());
GeometryUpdatesBlocker blocker(this);
doSetShade(previousShadeMode);
discardWindowPixmap();
updateWindowRules(Rules::Shade);
emit shadeChanged();
}
void AbstractClient::doSetShade(ShadeMode previousShadeMode)
{
Q_UNUSED(previousShadeMode)
}
void AbstractClient::shadeHover()
{
setShade(ShadeHover);
cancelShadeHoverTimer();
}
void AbstractClient::shadeUnhover()
{
setShade(ShadeNormal);
cancelShadeHoverTimer();
}
void AbstractClient::startShadeHoverTimer()
{
if (!isShade())
return;
m_shadeHoverTimer = new QTimer(this);
connect(m_shadeHoverTimer, &QTimer::timeout, this, &AbstractClient::shadeHover);
m_shadeHoverTimer->setSingleShot(true);
m_shadeHoverTimer->start(options->shadeHoverInterval());
}
void AbstractClient::startShadeUnhoverTimer()
{
if (m_shadeMode == ShadeHover && !isMoveResize() && !isMoveResizePointerButtonDown()) {
m_shadeHoverTimer = new QTimer(this);
connect(m_shadeHoverTimer, &QTimer::timeout, this, &AbstractClient::shadeUnhover);
m_shadeHoverTimer->setSingleShot(true);
m_shadeHoverTimer->start(options->shadeHoverInterval());
}
}
void AbstractClient::cancelShadeHoverTimer()
{
delete m_shadeHoverTimer;
m_shadeHoverTimer = nullptr;
}
void AbstractClient::toggleShade()
{
// If the mode is ShadeHover or ShadeActive, cancel shade too.
setShade(shadeMode() == ShadeNone ? ShadeNormal : ShadeNone);
}
AbstractClient::Position AbstractClient::titlebarPosition() const
{
// TODO: still needed, remove?
return PositionTop;
}
bool AbstractClient::titlebarPositionUnderMouse() const
{
if (!isDecorated()) {
return false;
}
const auto sectionUnderMouse = decoration()->sectionUnderMouse();
if (sectionUnderMouse == Qt::TitleBarArea) {
return true;
}
// check other sections based on titlebarPosition
switch (titlebarPosition()) {
case AbstractClient::PositionTop:
return (sectionUnderMouse == Qt::TopLeftSection || sectionUnderMouse == Qt::TopSection || sectionUnderMouse == Qt::TopRightSection);
case AbstractClient::PositionLeft:
return (sectionUnderMouse == Qt::TopLeftSection || sectionUnderMouse == Qt::LeftSection || sectionUnderMouse == Qt::BottomLeftSection);
case AbstractClient::PositionRight:
return (sectionUnderMouse == Qt::BottomRightSection || sectionUnderMouse == Qt::RightSection || sectionUnderMouse == Qt::TopRightSection);
case AbstractClient::PositionBottom:
return (sectionUnderMouse == Qt::BottomLeftSection || sectionUnderMouse == Qt::BottomSection || sectionUnderMouse == Qt::BottomRightSection);
default:
// nothing
return false;
}
}
void AbstractClient::setMinimized(bool set)
{
set ? minimize() : unminimize();
}
void AbstractClient::minimize(bool avoid_animation)
{
if (!isMinimizable() || isMinimized())
return;
m_minimized = true;
doMinimize();
updateWindowRules(Rules::Minimize);
if (options->moveMinimizedWindowsToEndOfTabBoxFocusChain()) {
FocusChain::self()->update(this, FocusChain::MakeFirstMinimized);
}
// TODO: merge signal with s_minimized
addWorkspaceRepaint(visibleRect());
emit clientMinimized(this, !avoid_animation);
emit minimizedChanged();
}
void AbstractClient::unminimize(bool avoid_animation)
{
if (!isMinimized())
return;
if (rules()->checkMinimize(false)) {
return;
}
m_minimized = false;
doMinimize();
updateWindowRules(Rules::Minimize);
emit clientUnminimized(this, !avoid_animation);
emit minimizedChanged();
}
void AbstractClient::doMinimize()
{
}
QPalette AbstractClient::palette() const
{
if (!m_palette) {
return QPalette();
}
return m_palette->palette();
}
const Decoration::DecorationPalette *AbstractClient::decorationPalette() const
{
return m_palette.get();
}
QString AbstractClient::preferredColorScheme() const
{
return rules()->checkDecoColor(QString());
}
QString AbstractClient::colorScheme() const
{
return m_colorScheme;
}
void AbstractClient::setColorScheme(const QString &colorScheme)
{
QString requestedColorScheme = colorScheme;
if (requestedColorScheme.isEmpty()) {
requestedColorScheme = QStringLiteral("kdeglobals");
}
if (!m_palette || m_colorScheme != requestedColorScheme) {
m_colorScheme = requestedColorScheme;
if (m_palette) {
disconnect(m_palette.get(), &Decoration::DecorationPalette::changed, this, &AbstractClient::handlePaletteChange);
}
auto it = s_palettes.find(m_colorScheme);
if (it == s_palettes.end() || it->expired()) {
m_palette = std::make_shared<Decoration::DecorationPalette>(m_colorScheme);
if (m_palette->isValid()) {
s_palettes[m_colorScheme] = m_palette;
} else {
if (!s_defaultPalette) {
s_defaultPalette = std::make_shared<Decoration::DecorationPalette>(QStringLiteral("kdeglobals"));
s_palettes[QStringLiteral("kdeglobals")] = s_defaultPalette;
}
m_palette = s_defaultPalette;
}
if (m_colorScheme == QStringLiteral("kdeglobals")) {
s_defaultPalette = m_palette;
}
} else {
m_palette = it->lock();
}
connect(m_palette.get(), &Decoration::DecorationPalette::changed, this, &AbstractClient::handlePaletteChange);
emit paletteChanged(palette());
emit colorSchemeChanged();
}
}
void AbstractClient::updateColorScheme()
{
setColorScheme(preferredColorScheme());
}
void AbstractClient::handlePaletteChange()
{
emit paletteChanged(palette());
}
2015-05-27 09:51:45 +00:00
void AbstractClient::keepInArea(QRect area, bool partial)
{
if (partial) {
// increase the area so that can have only 100 pixels in the area
area.setLeft(qMin(area.left() - width() + 100, area.left()));
area.setTop(qMin(area.top() - height() + 100, area.top()));
area.setRight(qMax(area.right() + width() - 100, area.right()));
area.setBottom(qMax(area.bottom() + height() - 100, area.bottom()));
}
if (!partial) {
// resize to fit into area
if (area.width() < width() || area.height() < height())
resizeWithChecks(size().boundedTo(area.size()));
2015-05-27 09:51:45 +00:00
}
int tx = x(), ty = y();
if (frameGeometry().right() > area.right() && width() <= area.width())
2015-05-27 09:51:45 +00:00
tx = area.right() - width() + 1;
if (frameGeometry().bottom() > area.bottom() && height() <= area.height())
2015-05-27 09:51:45 +00:00
ty = area.bottom() - height() + 1;
if (!area.contains(frameGeometry().topLeft())) {
2015-05-27 09:51:45 +00:00
if (tx < area.x())
tx = area.x();
if (ty < area.y())
ty = area.y();
}
if (tx != x() || ty != y())
move(tx, ty);
}
/**
* Returns the maximum client size, not the maximum frame size.
*/
QSize AbstractClient::maxSize() const
{
return rules()->checkMaxSize(QSize(INT_MAX, INT_MAX));
}
/**
* Returns the minimum client size, not the minimum frame size.
*/
QSize AbstractClient::minSize() const
{
return rules()->checkMinSize(QSize(0, 0));
}
void AbstractClient::blockGeometryUpdates(bool block)
{
if (block) {
if (m_blockGeometryUpdates == 0)
m_pendingGeometryUpdate = PendingGeometryNone;
++m_blockGeometryUpdates;
} else {
if (--m_blockGeometryUpdates == 0) {
if (m_pendingGeometryUpdate != PendingGeometryNone) {
if (isShade())
setFrameGeometry(QRect(pos(), adjustedSize()), NormalGeometrySet);
else
setFrameGeometry(frameGeometry(), NormalGeometrySet);
m_pendingGeometryUpdate = PendingGeometryNone;
}
}
}
}
void AbstractClient::maximize(MaximizeMode m)
{
setMaximize(m & MaximizeVertical, m & MaximizeHorizontal);
}
void AbstractClient::setMaximize(bool vertically, bool horizontally)
{
// changeMaximize() flips the state, so change from set->flip
const MaximizeMode oldMode = requestedMaximizeMode();
changeMaximize(
oldMode & MaximizeHorizontal ? !horizontally : horizontally,
oldMode & MaximizeVertical ? !vertically : vertically,
false);
const MaximizeMode newMode = maximizeMode();
if (oldMode != newMode) {
emit clientMaximizedStateChanged(this, newMode);
emit clientMaximizedStateChanged(this, vertically, horizontally);
}
}
void AbstractClient::move(int x, int y, ForceGeometry_t force)
{
// resuming geometry updates is handled only in setGeometry()
Q_ASSERT(pendingGeometryUpdate() == PendingGeometryNone || areGeometryUpdatesBlocked());
QPoint p(x, y);
if (!areGeometryUpdatesBlocked() && p != rules()->checkPosition(p)) {
qCDebug(KWIN_CORE) << "forced position fail:" << p << ":" << rules()->checkPosition(p);
}
if (force == NormalGeometrySet && m_frameGeometry.topLeft() == p)
return;
m_frameGeometry.moveTopLeft(p);
if (areGeometryUpdatesBlocked()) {
if (pendingGeometryUpdate() == PendingGeometryForced)
{} // maximum, nothing needed
else if (force == ForceGeometrySet)
setPendingGeometryUpdate(PendingGeometryForced);
else
setPendingGeometryUpdate(PendingGeometryNormal);
return;
}
const QRect oldBufferGeometry = bufferGeometryBeforeUpdateBlocking();
const QRect oldClientGeometry = clientGeometryBeforeUpdateBlocking();
const QRect oldFrameGeometry = frameGeometryBeforeUpdateBlocking();
doMove(x, y);
updateGeometryBeforeUpdateBlocking();
updateWindowRules(Rules::Position);
screens()->setCurrent(this);
workspace()->updateStackingOrder();
// client itself is not damaged
emit bufferGeometryChanged(this, oldBufferGeometry);
emit clientGeometryChanged(this, oldClientGeometry);
emit frameGeometryChanged(this, oldFrameGeometry);
addRepaintDuringGeometryUpdates();
}
bool AbstractClient::startMoveResize()
{
Q_ASSERT(!isMoveResize());
Q_ASSERT(QWidget::keyboardGrabber() == nullptr);
Q_ASSERT(QWidget::mouseGrabber() == nullptr);
stopDelayedMoveResize();
if (QApplication::activePopupWidget() != nullptr)
return false; // popups have grab
if (isFullScreen() && (screens()->count() < 2 || !isMovableAcrossScreens()))
return false;
if (!doStartMoveResize()) {
return false;
}
invalidateDecorationDoubleClickTimer();
setMoveResize(true);
workspace()->setMoveResizeClient(this);
const Position mode = moveResizePointerMode();
if (mode != PositionCenter) { // means "isResize()" but moveResizeMode = true is set below
if (maximizeMode() == MaximizeFull) { // partial is cond. reset in finishMoveResize
setGeometryRestore(frameGeometry()); // "restore" to current geometry
setMaximize(false, false);
}
}
if (quickTileMode() != QuickTileMode(QuickTileFlag::None) && mode != PositionCenter) { // Cannot use isResize() yet
// Exit quick tile mode when the user attempts to resize a tiled window
updateQuickTileMode(QuickTileFlag::None); // Do so without restoring original geometry
setGeometryRestore(frameGeometry());
doSetQuickTileMode();
emit quickTileModeChanged();
}
updateHaveResizeEffect();
updateInitialMoveResizeGeometry();
checkUnrestrictedMoveResize();
emit clientStartUserMovedResized(this);
if (ScreenEdges::self()->isDesktopSwitchingMovingClients())
ScreenEdges::self()->reserveDesktopSwitching(true, Qt::Vertical|Qt::Horizontal);
return true;
}
void AbstractClient::finishMoveResize(bool cancel)
{
GeometryUpdatesBlocker blocker(this);
const bool wasResize = isResize(); // store across leaveMoveResize
leaveMoveResize();
doFinishMoveResize();
if (cancel)
setFrameGeometry(initialMoveResizeGeometry());
else {
const QRect &moveResizeGeom = moveResizeGeometry();
if (wasResize) {
const bool restoreH = maximizeMode() == MaximizeHorizontal &&
moveResizeGeom.width() != initialMoveResizeGeometry().width();
const bool restoreV = maximizeMode() == MaximizeVertical &&
moveResizeGeom.height() != initialMoveResizeGeometry().height();
if (restoreH || restoreV) {
changeMaximize(restoreH, restoreV, false);
}
}
setFrameGeometry(moveResizeGeom);
}
checkScreen(); // needs to be done because clientFinishUserMovedResized has not yet re-activated online alignment
if (screen() != moveResizeStartScreen()) {
workspace()->sendClientToScreen(this, screen()); // checks rule validity
if (maximizeMode() != MaximizeRestore) {
checkWorkspacePosition();
}
}
if (isElectricBorderMaximizing()) {
setQuickTileMode(electricBorderMode());
setElectricBorderMaximizing(false);
} else if (!cancel && !isFullScreen()) {
QRect geom_restore = geometryRestore();
if (!(maximizeMode() & MaximizeHorizontal)) {
geom_restore.setX(frameGeometry().x());
geom_restore.setWidth(frameGeometry().width());
}
if (!(maximizeMode() & MaximizeVertical)) {
geom_restore.setY(frameGeometry().y());
geom_restore.setHeight(frameGeometry().height());
}
setGeometryRestore(geom_restore);
}
// FRAME update();
emit clientFinishUserMovedResized(this);
}
// This function checks if it actually makes sense to perform a restricted move/resize.
// If e.g. the titlebar is already outside of the workarea, there's no point in performing
// a restricted move resize, because then e.g. resize would also move the window (#74555).
// NOTE: Most of it is duplicated from handleMoveResize().
void AbstractClient::checkUnrestrictedMoveResize()
{
if (isUnrestrictedMoveResize())
return;
const QRect &moveResizeGeom = moveResizeGeometry();
QRect desktopArea = workspace()->clientArea(WorkArea, moveResizeGeom.center(), desktop());
int left_marge, right_marge, top_marge, bottom_marge, titlebar_marge;
// restricted move/resize - keep at least part of the titlebar always visible
// how much must remain visible when moved away in that direction
left_marge = qMin(100 + borderRight(), moveResizeGeom.width());
right_marge = qMin(100 + borderLeft(), moveResizeGeom.width());
// width/height change with opaque resizing, use the initial ones
titlebar_marge = initialMoveResizeGeometry().height();
top_marge = borderBottom();
bottom_marge = borderTop();
if (isResize()) {
if (moveResizeGeom.bottom() < desktopArea.top() + top_marge)
setUnrestrictedMoveResize(true);
if (moveResizeGeom.top() > desktopArea.bottom() - bottom_marge)
setUnrestrictedMoveResize(true);
if (moveResizeGeom.right() < desktopArea.left() + left_marge)
setUnrestrictedMoveResize(true);
if (moveResizeGeom.left() > desktopArea.right() - right_marge)
setUnrestrictedMoveResize(true);
if (!isUnrestrictedMoveResize() && moveResizeGeom.top() < desktopArea.top()) // titlebar mustn't go out
setUnrestrictedMoveResize(true);
}
if (isMove()) {
if (moveResizeGeom.bottom() < desktopArea.top() + titlebar_marge - 1)
setUnrestrictedMoveResize(true);
// no need to check top_marge, titlebar_marge already handles it
if (moveResizeGeom.top() > desktopArea.bottom() - bottom_marge + 1) // titlebar mustn't go out
setUnrestrictedMoveResize(true);
if (moveResizeGeom.right() < desktopArea.left() + left_marge)
setUnrestrictedMoveResize(true);
if (moveResizeGeom.left() > desktopArea.right() - right_marge)
setUnrestrictedMoveResize(true);
}
}
// When the user pressed mouse on the titlebar, don't activate move immediately,
// since it may be just a click. Activate instead after a delay. Move used to be
// activated only after moving by several pixels, but that looks bad.
void AbstractClient::startDelayedMoveResize()
{
Q_ASSERT(!m_moveResize.delayedTimer);
m_moveResize.delayedTimer = new QTimer(this);
m_moveResize.delayedTimer->setSingleShot(true);
connect(m_moveResize.delayedTimer, &QTimer::timeout, this,
[this]() {
Q_ASSERT(isMoveResizePointerButtonDown());
if (!startMoveResize()) {
setMoveResizePointerButtonDown(false);
}
updateCursor();
stopDelayedMoveResize();
}
);
m_moveResize.delayedTimer->start(QApplication::startDragTime());
}
void AbstractClient::stopDelayedMoveResize()
{
delete m_moveResize.delayedTimer;
m_moveResize.delayedTimer = nullptr;
}
void AbstractClient::updateMoveResize(const QPointF &currentGlobalCursor)
{
handleMoveResize(pos(), currentGlobalCursor.toPoint());
}
void AbstractClient::handleMoveResize(const QPoint &local, const QPoint &global)
{
const QRect oldGeo = frameGeometry();
handleMoveResize(local.x(), local.y(), global.x(), global.y());
if (!isFullScreen() && isMove()) {
if (quickTileMode() != QuickTileMode(QuickTileFlag::None) && oldGeo != frameGeometry()) {
GeometryUpdatesBlocker blocker(this);
setQuickTileMode(QuickTileFlag::None);
const QRect &geom_restore = geometryRestore();
setMoveOffset(QPoint(double(moveOffset().x()) / double(oldGeo.width()) * double(geom_restore.width()),
double(moveOffset().y()) / double(oldGeo.height()) * double(geom_restore.height())));
if (rules()->checkMaximize(MaximizeRestore) == MaximizeRestore)
setMoveResizeGeometry(geom_restore);
handleMoveResize(local.x(), local.y(), global.x(), global.y()); // fix position
} else if (quickTileMode() == QuickTileMode(QuickTileFlag::None) && isResizable()) {
checkQuickTilingMaximizationZones(global.x(), global.y());
}
}
}
void AbstractClient::handleMoveResize(int x, int y, int x_root, int y_root)
{
if (isWaitingForMoveResizeSync())
return; // we're still waiting for the client or the timeout
const Position mode = moveResizePointerMode();
if ((mode == PositionCenter && !isMovableAcrossScreens())
|| (mode != PositionCenter && (isShade() || !isResizable())))
return;
if (!isMoveResize()) {
QPoint p(QPoint(x/* - padding_left*/, y/* - padding_top*/) - moveOffset());
if (p.manhattanLength() >= QApplication::startDragDistance()) {
if (!startMoveResize()) {
setMoveResizePointerButtonDown(false);
updateCursor();
return;
}
updateCursor();
} else
return;
}
// ShadeHover or ShadeActive, ShadeNormal was already avoided above
if (mode != PositionCenter && shadeMode() != ShadeNone)
setShade(ShadeNone);
QPoint globalPos(x_root, y_root);
// these two points limit the geometry rectangle, i.e. if bottomleft resizing is done,
// the bottomleft corner should be at is at (topleft.x(), bottomright().y())
QPoint topleft = globalPos - moveOffset();
QPoint bottomright = globalPos + invertedMoveOffset();
QRect previousMoveResizeGeom = moveResizeGeometry();
// TODO move whole group when moving its leader or when the leader is not mapped?
auto titleBarRect = [this](bool &transposed, int &requiredPixels) -> QRect {
const QRect &moveResizeGeom = moveResizeGeometry();
QRect r(moveResizeGeom);
r.moveTopLeft(QPoint(0,0));
switch (titlebarPosition()) {
default:
case PositionTop:
r.setHeight(borderTop());
break;
case PositionLeft:
r.setWidth(borderLeft());
transposed = true;
break;
case PositionBottom:
r.setTop(r.bottom() - borderBottom());
break;
case PositionRight:
r.setLeft(r.right() - borderRight());
transposed = true;
break;
}
// When doing a restricted move we must always keep 100px of the titlebar
// visible to allow the user to be able to move it again.
requiredPixels = qMin(100 * (transposed ? r.width() : r.height()),
moveResizeGeom.width() * moveResizeGeom.height());
return r;
};
bool update = false;
if (isResize()) {
QRect orig = initialMoveResizeGeometry();
SizeMode sizeMode = SizeModeAny;
auto calculateMoveResizeGeom = [this, &topleft, &bottomright, &orig, &sizeMode, &mode]() {
switch(mode) {
case PositionTopLeft:
setMoveResizeGeometry(QRect(topleft, orig.bottomRight()));
break;
case PositionBottomRight:
setMoveResizeGeometry(QRect(orig.topLeft(), bottomright));
break;
case PositionBottomLeft:
setMoveResizeGeometry(QRect(QPoint(topleft.x(), orig.y()), QPoint(orig.right(), bottomright.y())));
break;
case PositionTopRight:
setMoveResizeGeometry(QRect(QPoint(orig.x(), topleft.y()), QPoint(bottomright.x(), orig.bottom())));
break;
case PositionTop:
setMoveResizeGeometry(QRect(QPoint(orig.left(), topleft.y()), orig.bottomRight()));
sizeMode = SizeModeFixedH; // try not to affect height
break;
case PositionBottom:
setMoveResizeGeometry(QRect(orig.topLeft(), QPoint(orig.right(), bottomright.y())));
sizeMode = SizeModeFixedH;
break;
case PositionLeft:
setMoveResizeGeometry(QRect(QPoint(topleft.x(), orig.top()), orig.bottomRight()));
sizeMode = SizeModeFixedW;
break;
case PositionRight:
setMoveResizeGeometry(QRect(orig.topLeft(), QPoint(bottomright.x(), orig.bottom())));
sizeMode = SizeModeFixedW;
break;
case PositionCenter:
default:
abort();
break;
}
};
// first resize (without checking constrains), then snap, then check bounds, then check constrains
calculateMoveResizeGeom();
// adjust new size to snap to other windows/borders
setMoveResizeGeometry(workspace()->adjustClientSize(this, moveResizeGeometry(), mode));
if (!isUnrestrictedMoveResize()) {
// Make sure the titlebar isn't behind a restricted area. We don't need to restrict
// the other directions. If not visible enough, move the window to the closest valid
// point. We bruteforce this by slowly moving the window back to its previous position
QRegion availableArea(workspace()->clientArea(FullArea, -1, 0)); // On the screen
availableArea -= workspace()->restrictedMoveArea(desktop()); // Strut areas
bool transposed = false;
int requiredPixels;
QRect bTitleRect = titleBarRect(transposed, requiredPixels);
int lastVisiblePixels = -1;
QRect lastTry = moveResizeGeometry();
bool titleFailed = false;
for (;;) {
const QRect titleRect(bTitleRect.translated(moveResizeGeometry().topLeft()));
int visiblePixels = 0;
int realVisiblePixels = 0;
for (const QRect &rect : availableArea) {
const QRect r = rect & titleRect;
realVisiblePixels += r.width() * r.height();
if ((transposed && r.width() == titleRect.width()) || // Only the full size regions...
(!transposed && r.height() == titleRect.height())) // ...prevents long slim areas
visiblePixels += r.width() * r.height();
}
if (visiblePixels >= requiredPixels)
break; // We have reached a valid position
if (realVisiblePixels <= lastVisiblePixels) {
if (titleFailed && realVisiblePixels < lastVisiblePixels)
break; // we won't become better
else {
if (!titleFailed)
setMoveResizeGeometry(lastTry);
titleFailed = true;
}
}
lastVisiblePixels = realVisiblePixels;
QRect moveResizeGeom = moveResizeGeometry();
lastTry = moveResizeGeom;
// Not visible enough, move the window to the closest valid point. We bruteforce
// this by slowly moving the window back to its previous position.
// The geometry changes at up to two edges, the one with the title (if) shall take
// precedence. The opposing edge has no impact on visiblePixels and only one of
// the adjacent can alter at a time, ie. it's enough to ignore adjacent edges
// if the title edge altered
bool leftChanged = previousMoveResizeGeom.left() != moveResizeGeom.left();
bool rightChanged = previousMoveResizeGeom.right() != moveResizeGeom.right();
bool topChanged = previousMoveResizeGeom.top() != moveResizeGeom.top();
bool btmChanged = previousMoveResizeGeom.bottom() != moveResizeGeom.bottom();
auto fixChangedState = [titleFailed](bool &major, bool &counter, bool &ad1, bool &ad2) {
counter = false;
if (titleFailed)
major = false;
if (major)
ad1 = ad2 = false;
};
switch (titlebarPosition()) {
default:
case PositionTop:
fixChangedState(topChanged, btmChanged, leftChanged, rightChanged);
break;
case PositionLeft:
fixChangedState(leftChanged, rightChanged, topChanged, btmChanged);
break;
case PositionBottom:
fixChangedState(btmChanged, topChanged, leftChanged, rightChanged);
break;
case PositionRight:
fixChangedState(rightChanged, leftChanged, topChanged, btmChanged);
break;
}
if (topChanged)
moveResizeGeom.setTop(moveResizeGeom.y() + sign(previousMoveResizeGeom.y() - moveResizeGeom.y()));
else if (leftChanged)
moveResizeGeom.setLeft(moveResizeGeom.x() + sign(previousMoveResizeGeom.x() - moveResizeGeom.x()));
else if (btmChanged)
moveResizeGeom.setBottom(moveResizeGeom.bottom() + sign(previousMoveResizeGeom.bottom() - moveResizeGeom.bottom()));
else if (rightChanged)
moveResizeGeom.setRight(moveResizeGeom.right() + sign(previousMoveResizeGeom.right() - moveResizeGeom.right()));
else
break; // no position changed - that's certainly not good
setMoveResizeGeometry(moveResizeGeom);
}
}
// Always obey size hints, even when in "unrestricted" mode
QSize size = constrainFrameSize(moveResizeGeometry().size(), sizeMode);
// the new topleft and bottomright corners (after checking size constrains), if they'll be needed
topleft = QPoint(moveResizeGeometry().right() - size.width() + 1, moveResizeGeometry().bottom() - size.height() + 1);
bottomright = QPoint(moveResizeGeometry().left() + size.width() - 1, moveResizeGeometry().top() + size.height() - 1);
orig = moveResizeGeometry();
// if aspect ratios are specified, both dimensions may change.
// Therefore grow to the right/bottom if needed.
// TODO it should probably obey gravity rather than always using right/bottom ?
if (sizeMode == SizeModeFixedH)
orig.setRight(bottomright.x());
else if (sizeMode == SizeModeFixedW)
orig.setBottom(bottomright.y());
calculateMoveResizeGeom();
if (moveResizeGeometry().size() != previousMoveResizeGeom.size())
update = true;
} else if (isMove()) {
Q_ASSERT(mode == PositionCenter);
if (!isMovable()) { // isMovableAcrossScreens() must have been true to get here
// Special moving of maximized windows on Xinerama screens
int screen = screens()->number(globalPos);
if (isFullScreen())
setMoveResizeGeometry(workspace()->clientArea(FullScreenArea, screen, 0));
else {
QRect moveResizeGeom = workspace()->clientArea(MaximizeArea, screen, 0);
QSize adjSize = constrainFrameSize(moveResizeGeom.size(), SizeModeMax);
if (adjSize != moveResizeGeom.size()) {
QRect r(moveResizeGeom);
moveResizeGeom.setSize(adjSize);
moveResizeGeom.moveCenter(r.center());
}
setMoveResizeGeometry(moveResizeGeom);
}
} else {
// first move, then snap, then check bounds
QRect moveResizeGeom = moveResizeGeometry();
moveResizeGeom.moveTopLeft(topleft);
moveResizeGeom.moveTopLeft(workspace()->adjustClientPosition(this, moveResizeGeom.topLeft(),
isUnrestrictedMoveResize()));
setMoveResizeGeometry(moveResizeGeom);
if (!isUnrestrictedMoveResize()) {
const QRegion strut = workspace()->restrictedMoveArea(desktop()); // Strut areas
QRegion availableArea(workspace()->clientArea(FullArea, -1, 0)); // On the screen
availableArea -= strut; // Strut areas
bool transposed = false;
int requiredPixels;
QRect bTitleRect = titleBarRect(transposed, requiredPixels);
for (;;) {
QRect moveResizeGeom = moveResizeGeometry();
const QRect titleRect(bTitleRect.translated(moveResizeGeom.topLeft()));
int visiblePixels = 0;
for (const QRect &rect : availableArea) {
const QRect r = rect & titleRect;
if ((transposed && r.width() == titleRect.width()) || // Only the full size regions...
(!transposed && r.height() == titleRect.height())) // ...prevents long slim areas
visiblePixels += r.width() * r.height();
}
if (visiblePixels >= requiredPixels)
break; // We have reached a valid position
// (esp.) if there're more screens with different struts (panels) it the titlebar
// will be movable outside the movearea (covering one of the panels) until it
// crosses the panel "too much" (not enough visiblePixels) and then stucks because
// it's usually only pushed by 1px to either direction
// so we first check whether we intersect suc strut and move the window below it
// immediately (it's still possible to hit the visiblePixels >= titlebarArea break
// by moving the window slightly downwards, but it won't stuck)
// see bug #274466
// and bug #301805 for why we can't just match the titlearea against the screen
if (screens()->count() > 1) { // optimization
// TODO: could be useful on partial screen struts (half-width panels etc.)
int newTitleTop = -1;
for (const QRect &r : strut) {
if (r.top() == 0 && r.width() > r.height() && // "top panel"
r.intersects(moveResizeGeom) && moveResizeGeom.top() < r.bottom()) {
newTitleTop = r.bottom() + 1;
break;
}
}
if (newTitleTop > -1) {
moveResizeGeom.moveTop(newTitleTop); // invalid position, possibly on screen change
setMoveResizeGeometry(moveResizeGeom);
break;
}
}
int dx = sign(previousMoveResizeGeom.x() - moveResizeGeom.x()),
dy = sign(previousMoveResizeGeom.y() - moveResizeGeom.y());
if (visiblePixels && dx) // means there's no full width cap -> favor horizontally
dy = 0;
else if (dy)
dx = 0;
// Move it back
moveResizeGeom.translate(dx, dy);
setMoveResizeGeometry(moveResizeGeom);
if (moveResizeGeom == previousMoveResizeGeom) {
break; // Prevent lockup
}
}
}
}
if (moveResizeGeometry().topLeft() != previousMoveResizeGeom.topLeft())
update = true;
} else
abort();
if (!update)
return;
if (isResize() && !haveResizeEffect()) {
doResizeSync();
} else
performMoveResize();
if (isMove()) {
ScreenEdges::self()->check(globalPos, QDateTime::fromMSecsSinceEpoch(xTime(), Qt::UTC));
}
}
void AbstractClient::performMoveResize()
{
const QRect &moveResizeGeom = moveResizeGeometry();
if (isMove() || (isResize() && !haveResizeEffect())) {
setFrameGeometry(moveResizeGeom);
}
doPerformMoveResize();
positionGeometryTip();
emit clientStepUserMovedResized(this, moveResizeGeom);
}
2020-08-17 13:14:20 +00:00
StrutRect AbstractClient::strutRect(StrutArea area) const
{
Q_UNUSED(area)
return StrutRect();
}
StrutRects AbstractClient::strutRects() const
{
StrutRects region;
region += strutRect(StrutAreaTop);
region += strutRect(StrutAreaRight);
region += strutRect(StrutAreaBottom);
region += strutRect(StrutAreaLeft);
return region;
}
bool AbstractClient::hasStrut() const
{
return false;
}
void AbstractClient::setupWindowManagementInterface()
{
if (m_windowManagementInterface) {
// already setup
return;
}
if (!waylandServer() || !surface()) {
return;
}
if (!waylandServer()->windowManagement()) {
return;
}
using namespace KWaylandServer;
auto w = waylandServer()->windowManagement()->createWindow(waylandServer()->windowManagement(), internalId());
w->setTitle(caption());
w->setVirtualDesktop(isOnAllDesktops() ? 0 : desktop() - 1);
w->setActive(isActive());
w->setFullscreen(isFullScreen());
w->setKeepAbove(keepAbove());
w->setKeepBelow(keepBelow());
w->setMaximized(maximizeMode() == KWin::MaximizeFull);
w->setMinimized(isMinimized());
w->setOnAllDesktops(isOnAllDesktops());
w->setDemandsAttention(isDemandingAttention());
w->setCloseable(isCloseable());
w->setMaximizeable(isMaximizable());
w->setMinimizeable(isMinimizable());
w->setFullscreenable(isFullScreenable());
w->setApplicationMenuPaths(applicationMenuServiceName(), applicationMenuObjectPath());
w->setIcon(icon());
auto updateAppId = [this, w] {
w->setAppId(QString::fromUtf8(m_desktopFileName.isEmpty() ? resourceClass() : m_desktopFileName));
};
updateAppId();
w->setSkipTaskbar(skipTaskbar());
w->setSkipSwitcher(skipSwitcher());
w->setPid(pid());
w->setShadeable(isShadeable());
w->setShaded(isShade());
w->setResizable(isResizable());
w->setMovable(isMovable());
w->setVirtualDesktopChangeable(true); // FIXME Matches X11Client::actionSupported(), but both should be implemented.
w->setParentWindow(transientFor() ? transientFor()->windowManagementInterface() : nullptr);
w->setGeometry(frameGeometry());
connect(this, &AbstractClient::skipTaskbarChanged, w,
[w, this] {
w->setSkipTaskbar(skipTaskbar());
}
);
connect(this, &AbstractClient::skipSwitcherChanged, w,
[w, this] {
w->setSkipSwitcher(skipSwitcher());
}
);
connect(this, &AbstractClient::captionChanged, w, [w, this] { w->setTitle(caption()); });
connect(this, &AbstractClient::activeChanged, w, [w, this] { w->setActive(isActive()); });
connect(this, &AbstractClient::fullScreenChanged, w, [w, this] { w->setFullscreen(isFullScreen()); });
connect(this, &AbstractClient::keepAboveChanged, w, &PlasmaWindowInterface::setKeepAbove);
connect(this, &AbstractClient::keepBelowChanged, w, &PlasmaWindowInterface::setKeepBelow);
connect(this, &AbstractClient::minimizedChanged, w, [w, this] { w->setMinimized(isMinimized()); });
connect(this, static_cast<void (AbstractClient::*)(AbstractClient*,MaximizeMode)>(&AbstractClient::clientMaximizedStateChanged), w,
[w] (KWin::AbstractClient *c, MaximizeMode mode) {
Q_UNUSED(c);
w->setMaximized(mode == KWin::MaximizeFull);
}
);
connect(this, &AbstractClient::demandsAttentionChanged, w, [w, this] { w->setDemandsAttention(isDemandingAttention()); });
connect(this, &AbstractClient::iconChanged, w,
[w, this] {
w->setIcon(icon());
}
);
connect(this, &AbstractClient::windowClassChanged, w, updateAppId);
connect(this, &AbstractClient::desktopFileNameChanged, w, updateAppId);
connect(this, &AbstractClient::shadeChanged, w, [w, this] { w->setShaded(isShade()); });
connect(this, &AbstractClient::transientChanged, w,
[w, this] {
w->setParentWindow(transientFor() ? transientFor()->windowManagementInterface() : nullptr);
}
);
connect(this, &AbstractClient::frameGeometryChanged, w,
[w, this] {
w->setGeometry(frameGeometry());
}
);
connect(this, &AbstractClient::applicationMenuChanged, w,
[w, this] {
w->setApplicationMenuPaths(applicationMenuServiceName(), applicationMenuObjectPath());
}
);
connect(w, &PlasmaWindowInterface::closeRequested, this, [this] { closeWindow(); });
connect(w, &PlasmaWindowInterface::moveRequested, this,
[this] {
Cursors::self()->mouse()->setPos(frameGeometry().center());
performMouseCommand(Options::MouseMove, Cursors::self()->mouse()->pos());
}
);
connect(w, &PlasmaWindowInterface::resizeRequested, this,
[this] {
Cursors::self()->mouse()->setPos(frameGeometry().bottomRight());
performMouseCommand(Options::MouseResize, Cursors::self()->mouse()->pos());
}
);
connect(w, &PlasmaWindowInterface::virtualDesktopRequested, this,
[this] (quint32 desktop) {
workspace()->sendClientToDesktop(this, desktop + 1, true);
}
);
connect(w, &PlasmaWindowInterface::fullscreenRequested, this,
[this] (bool set) {
setFullScreen(set, false);
}
);
connect(w, &PlasmaWindowInterface::minimizedRequested, this,
[this] (bool set) {
if (set) {
minimize();
} else {
unminimize();
}
}
);
connect(w, &PlasmaWindowInterface::maximizedRequested, this,
[this] (bool set) {
maximize(set ? MaximizeFull : MaximizeRestore);
}
);
connect(w, &PlasmaWindowInterface::keepAboveRequested, this,
[this] (bool set) {
setKeepAbove(set);
}
);
connect(w, &PlasmaWindowInterface::keepBelowRequested, this,
[this] (bool set) {
setKeepBelow(set);
}
);
connect(w, &PlasmaWindowInterface::demandsAttentionRequested, this,
[this] (bool set) {
demandAttention(set);
}
);
connect(w, &PlasmaWindowInterface::activeRequested, this,
[this] (bool set) {
if (set) {
workspace()->activateClient(this, true);
}
}
);
connect(w, &PlasmaWindowInterface::shadedRequested, this,
[this] (bool set) {
setShade(set);
}
);
for (const auto vd : m_desktops) {
w->addPlasmaVirtualDesktop(vd->id());
}
//this is only for the legacy
connect(this, &AbstractClient::desktopChanged, w,
[w, this] {
if (isOnAllDesktops()) {
w->setOnAllDesktops(true);
return;
}
w->setVirtualDesktop(desktop() - 1);
w->setOnAllDesktops(false);
}
);
//Plasma Virtual desktop management
//show/hide when the window enters/exits from desktop
connect(w, &PlasmaWindowInterface::enterPlasmaVirtualDesktopRequested, this,
[this] (const QString &desktopId) {
VirtualDesktop *vd = VirtualDesktopManager::self()->desktopForId(desktopId.toUtf8());
if (vd) {
enterDesktop(vd);
}
}
);
connect(w, &PlasmaWindowInterface::enterNewPlasmaVirtualDesktopRequested, this,
[this] () {
VirtualDesktopManager::self()->setCount(VirtualDesktopManager::self()->count() + 1);
enterDesktop(VirtualDesktopManager::self()->desktops().last());
}
);
connect(w, &PlasmaWindowInterface::leavePlasmaVirtualDesktopRequested, this,
[this] (const QString &desktopId) {
VirtualDesktop *vd = VirtualDesktopManager::self()->desktopForId(desktopId.toUtf8());
if (vd) {
leaveDesktop(vd);
}
}
);
m_windowManagementInterface = w;
}
void AbstractClient::destroyWindowManagementInterface()
{
if (m_windowManagementInterface) {
m_windowManagementInterface->unmap();
m_windowManagementInterface = nullptr;
}
}
Options::MouseCommand AbstractClient::getMouseCommand(Qt::MouseButton button, bool *handled) const
{
*handled = false;
if (button == Qt::NoButton) {
return Options::MouseNothing;
}
if (isActive()) {
if (options->isClickRaise() && !isMostRecentlyRaised()) {
*handled = true;
return Options::MouseActivateRaiseAndPassClick;
}
} else {
*handled = true;
switch (button) {
case Qt::LeftButton:
return options->commandWindow1();
case Qt::MiddleButton:
return options->commandWindow2();
case Qt::RightButton:
return options->commandWindow3();
default:
// all other buttons pass Activate & Pass Client
return Options::MouseActivateAndPassClick;
}
}
return Options::MouseNothing;
}
Options::MouseCommand AbstractClient::getWheelCommand(Qt::Orientation orientation, bool *handled) const
{
*handled = false;
if (orientation != Qt::Vertical) {
return Options::MouseNothing;
}
if (!isActive()) {
*handled = true;
return options->commandWindowWheel();
}
return Options::MouseNothing;
}
bool AbstractClient::performMouseCommand(Options::MouseCommand cmd, const QPoint &globalPos)
{
bool replay = false;
switch(cmd) {
case Options::MouseRaise:
workspace()->raiseClient(this);
break;
case Options::MouseLower: {
workspace()->lowerClient(this);
// used to be activateNextClient(this), then topClientOnDesktop
// since this is a mouseOp it's however safe to use the client under the mouse instead
if (isActive() && options->focusPolicyIsReasonable()) {
AbstractClient *next = workspace()->clientUnderMouse(screen());
if (next && next != this)
workspace()->requestFocus(next, false);
}
break;
}
case Options::MouseOperationsMenu:
if (isActive() && options->isClickRaise())
autoRaise();
workspace()->showWindowMenu(QRect(globalPos, globalPos), this);
break;
case Options::MouseToggleRaiseAndLower:
workspace()->raiseOrLowerClient(this);
break;
case Options::MouseActivateAndRaise: {
replay = isActive(); // for clickraise mode
bool mustReplay = !rules()->checkAcceptFocus(acceptsFocus());
if (mustReplay) {
auto it = workspace()->stackingOrder().constEnd(),
begin = workspace()->stackingOrder().constBegin();
while (mustReplay && --it != begin && *it != this) {
AbstractClient *c = qobject_cast<AbstractClient*>(*it);
if (!c || (c->keepAbove() && !keepAbove()) || (keepBelow() && !c->keepBelow()))
continue; // can never raise above "it"
mustReplay = !(c->isOnCurrentDesktop() && c->isOnCurrentActivity() && c->frameGeometry().intersects(frameGeometry()));
}
}
workspace()->takeActivity(this, Workspace::ActivityFocus | Workspace::ActivityRaise);
screens()->setCurrent(globalPos);
replay = replay || mustReplay;
break;
}
case Options::MouseActivateAndLower:
workspace()->requestFocus(this);
workspace()->lowerClient(this);
screens()->setCurrent(globalPos);
replay = replay || !rules()->checkAcceptFocus(acceptsFocus());
break;
case Options::MouseActivate:
replay = isActive(); // for clickraise mode
workspace()->takeActivity(this, Workspace::ActivityFocus);
screens()->setCurrent(globalPos);
replay = replay || !rules()->checkAcceptFocus(acceptsFocus());
break;
case Options::MouseActivateRaiseAndPassClick:
workspace()->takeActivity(this, Workspace::ActivityFocus | Workspace::ActivityRaise);
screens()->setCurrent(globalPos);
replay = true;
break;
case Options::MouseActivateAndPassClick:
workspace()->takeActivity(this, Workspace::ActivityFocus);
screens()->setCurrent(globalPos);
replay = true;
break;
case Options::MouseMaximize:
maximize(MaximizeFull);
break;
case Options::MouseRestore:
maximize(MaximizeRestore);
break;
case Options::MouseMinimize:
minimize();
break;
case Options::MouseAbove: {
StackingUpdatesBlocker blocker(workspace());
if (keepBelow())
setKeepBelow(false);
else
setKeepAbove(true);
break;
}
case Options::MouseBelow: {
StackingUpdatesBlocker blocker(workspace());
if (keepAbove())
setKeepAbove(false);
else
setKeepBelow(true);
break;
}
case Options::MousePreviousDesktop:
workspace()->windowToPreviousDesktop(this);
break;
case Options::MouseNextDesktop:
workspace()->windowToNextDesktop(this);
break;
case Options::MouseOpacityMore:
if (!isDesktop()) // No point in changing the opacity of the desktop
setOpacity(qMin(opacity() + 0.1, 1.0));
break;
case Options::MouseOpacityLess:
if (!isDesktop()) // No point in changing the opacity of the desktop
setOpacity(qMax(opacity() - 0.1, 0.1));
break;
case Options::MouseClose:
closeWindow();
break;
case Options::MouseActivateRaiseAndMove:
case Options::MouseActivateRaiseAndUnrestrictedMove:
workspace()->raiseClient(this);
workspace()->requestFocus(this);
screens()->setCurrent(globalPos);
// fallthrough
case Options::MouseMove:
case Options::MouseUnrestrictedMove: {
if (!isMovableAcrossScreens())
break;
if (isMoveResize())
finishMoveResize(false);
setMoveResizePointerMode(PositionCenter);
setMoveResizePointerButtonDown(true);
setMoveOffset(QPoint(globalPos.x() - x(), globalPos.y() - y())); // map from global
setInvertedMoveOffset(rect().bottomRight() - moveOffset());
setUnrestrictedMoveResize((cmd == Options::MouseActivateRaiseAndUnrestrictedMove
|| cmd == Options::MouseUnrestrictedMove));
if (!startMoveResize())
setMoveResizePointerButtonDown(false);
updateCursor();
break;
}
case Options::MouseResize:
case Options::MouseUnrestrictedResize: {
if (!isResizable() || isShade())
break;
if (isMoveResize())
finishMoveResize(false);
setMoveResizePointerButtonDown(true);
const QPoint moveOffset = QPoint(globalPos.x() - x(), globalPos.y() - y()); // map from global
setMoveOffset(moveOffset);
int x = moveOffset.x(), y = moveOffset.y();
bool left = x < width() / 3;
bool right = x >= 2 * width() / 3;
bool top = y < height() / 3;
bool bot = y >= 2 * height() / 3;
Position mode;
if (top)
mode = left ? PositionTopLeft : (right ? PositionTopRight : PositionTop);
else if (bot)
mode = left ? PositionBottomLeft : (right ? PositionBottomRight : PositionBottom);
else
mode = (x < width() / 2) ? PositionLeft : PositionRight;
setMoveResizePointerMode(mode);
setInvertedMoveOffset(rect().bottomRight() - moveOffset);
setUnrestrictedMoveResize((cmd == Options::MouseUnrestrictedResize));
if (!startMoveResize())
setMoveResizePointerButtonDown(false);
updateCursor();
break;
}
case Options::MouseShade:
toggleShade();
cancelShadeHoverTimer();
break;
case Options::MouseSetShade:
setShade(ShadeNormal);
cancelShadeHoverTimer();
break;
case Options::MouseUnsetShade:
setShade(ShadeNone);
cancelShadeHoverTimer();
break;
case Options::MouseNothing:
default:
replay = true;
break;
}
return replay;
}
void AbstractClient::setTransientFor(AbstractClient *transientFor)
{
if (transientFor == this) {
// cannot be transient for one self
return;
}
if (m_transientFor == transientFor) {
return;
}
m_transientFor = transientFor;
emit transientChanged();
}
const AbstractClient *AbstractClient::transientFor() const
{
return m_transientFor;
}
AbstractClient *AbstractClient::transientFor()
{
return m_transientFor;
}
bool AbstractClient::hasTransientPlacementHint() const
{
return false;
}
QRect AbstractClient::transientPlacement(const QRect &bounds) const
{
Q_UNUSED(bounds);
Q_UNREACHABLE();
return QRect();
}
bool AbstractClient::hasTransient(const AbstractClient *c, bool indirect) const
{
Q_UNUSED(indirect);
return c->transientFor() == this;
}
QList< AbstractClient* > AbstractClient::mainClients() const
{
if (const AbstractClient *t = transientFor()) {
return QList<AbstractClient*>{const_cast< AbstractClient* >(t)};
}
return QList<AbstractClient*>();
}
QList<AbstractClient*> AbstractClient::allMainClients() const
{
auto result = mainClients();
foreach (const auto *cl, result) {
result += cl->allMainClients();
}
return result;
}
void AbstractClient::setModal(bool m)
{
// Qt-3.2 can have even modal normal windows :(
if (m_modal == m)
return;
m_modal = m;
emit modalChanged();
// Changing modality for a mapped window is weird (?)
// _NET_WM_STATE_MODAL should possibly rather be _NET_WM_WINDOW_TYPE_MODAL_DIALOG
}
bool AbstractClient::isModal() const
{
return m_modal;
}
void AbstractClient::addTransient(AbstractClient *cl)
{
Q_ASSERT(!m_transients.contains(cl));
Q_ASSERT(cl != this);
m_transients.append(cl);
}
void AbstractClient::removeTransient(AbstractClient *cl)
{
m_transients.removeAll(cl);
if (cl->transientFor() == this) {
cl->setTransientFor(nullptr);
}
}
void AbstractClient::removeTransientFromList(AbstractClient *cl)
{
m_transients.removeAll(cl);
}
bool AbstractClient::isActiveFullScreen() const
{
if (!isFullScreen())
return false;
const auto ac = workspace()->mostRecentlyActivatedClient(); // instead of activeClient() - avoids flicker
// according to NETWM spec implementation notes suggests
// "focused windows having state _NET_WM_STATE_FULLSCREEN" to be on the highest layer.
// we'll also take the screen into account
return ac && (ac == this || ac->screen() != screen()|| ac->allMainClients().contains(const_cast<AbstractClient*>(this)));
}
#define BORDER(which) \
int AbstractClient::border##which() const \
{ \
return isDecorated() ? decoration()->border##which() : 0; \
}
BORDER(Bottom)
BORDER(Left)
BORDER(Right)
BORDER(Top)
#undef BORDER
void AbstractClient::addRepaintDuringGeometryUpdates()
{
const QRect deco_rect = visibleRect();
addLayerRepaint(m_visibleRectBeforeGeometryUpdate);
addLayerRepaint(deco_rect); // trigger repaint of window's new location
m_visibleRectBeforeGeometryUpdate = deco_rect;
}
QRect AbstractClient::bufferGeometryBeforeUpdateBlocking() const
{
return m_bufferGeometryBeforeUpdateBlocking;
}
QRect AbstractClient::frameGeometryBeforeUpdateBlocking() const
{
return m_frameGeometryBeforeUpdateBlocking;
}
QRect AbstractClient::clientGeometryBeforeUpdateBlocking() const
{
return m_clientGeometryBeforeUpdateBlocking;
}
void AbstractClient::updateGeometryBeforeUpdateBlocking()
{
m_bufferGeometryBeforeUpdateBlocking = bufferGeometry();
m_frameGeometryBeforeUpdateBlocking = frameGeometry();
m_clientGeometryBeforeUpdateBlocking = clientGeometry();
}
void AbstractClient::doMove(int, int)
{
}
void AbstractClient::updateInitialMoveResizeGeometry()
{
m_moveResize.initialGeometry = frameGeometry();
m_moveResize.geometry = m_moveResize.initialGeometry;
m_moveResize.startScreen = screen();
}
void AbstractClient::updateCursor()
{
Position m = moveResizePointerMode();
if (!isResizable() || isShade())
m = PositionCenter;
CursorShape c = Qt::ArrowCursor;
switch(m) {
case PositionTopLeft:
c = KWin::ExtendedCursor::SizeNorthWest;
break;
case PositionBottomRight:
c = KWin::ExtendedCursor::SizeSouthEast;
break;
case PositionBottomLeft:
c = KWin::ExtendedCursor::SizeSouthWest;
break;
case PositionTopRight:
c = KWin::ExtendedCursor::SizeNorthEast;
break;
case PositionTop:
c = KWin::ExtendedCursor::SizeNorth;
break;
case PositionBottom:
c = KWin::ExtendedCursor::SizeSouth;
break;
case PositionLeft:
c = KWin::ExtendedCursor::SizeWest;
break;
case PositionRight:
c = KWin::ExtendedCursor::SizeEast;
break;
default:
if (isMoveResize())
c = Qt::SizeAllCursor;
else
c = Qt::ArrowCursor;
break;
}
if (c == m_moveResize.cursor)
return;
m_moveResize.cursor = c;
emit moveResizeCursorChanged(c);
}
void AbstractClient::leaveMoveResize()
{
workspace()->setMoveResizeClient(nullptr);
setMoveResize(false);
if (ScreenEdges::self()->isDesktopSwitchingMovingClients())
ScreenEdges::self()->reserveDesktopSwitching(false, Qt::Vertical|Qt::Horizontal);
if (isElectricBorderMaximizing()) {
outline()->hide();
elevate(false);
}
}
bool AbstractClient::s_haveResizeEffect = false;
void AbstractClient::updateHaveResizeEffect()
{
s_haveResizeEffect = effects && static_cast<EffectsHandlerImpl*>(effects)->provides(Effect::Resize);
}
bool AbstractClient::doStartMoveResize()
{
return true;
}
void AbstractClient::doFinishMoveResize()
{
}
void AbstractClient::positionGeometryTip()
{
}
void AbstractClient::doPerformMoveResize()
{
}
bool AbstractClient::isWaitingForMoveResizeSync() const
{
return false;
}
void AbstractClient::doResizeSync()
{
}
void AbstractClient::checkQuickTilingMaximizationZones(int xroot, int yroot)
{
QuickTileMode mode = QuickTileFlag::None;
bool innerBorder = false;
for (int i=0; i < screens()->count(); ++i) {
if (!screens()->geometry(i).contains(QPoint(xroot, yroot)))
continue;
auto isInScreen = [i](const QPoint &pt) {
for (int j = 0; j < screens()->count(); ++j) {
if (j == i)
continue;
if (screens()->geometry(j).contains(pt)) {
return true;
}
}
return false;
};
QRect area = workspace()->clientArea(MaximizeArea, QPoint(xroot, yroot), desktop());
if (options->electricBorderTiling()) {
if (xroot <= area.x() + 20) {
mode |= QuickTileFlag::Left;
innerBorder = isInScreen(QPoint(area.x() - 1, yroot));
} else if (xroot >= area.x() + area.width() - 20) {
mode |= QuickTileFlag::Right;
innerBorder = isInScreen(QPoint(area.right() + 1, yroot));
}
}
if (mode != QuickTileMode(QuickTileFlag::None)) {
if (yroot <= area.y() + area.height() * options->electricBorderCornerRatio())
mode |= QuickTileFlag::Top;
else if (yroot >= area.y() + area.height() - area.height() * options->electricBorderCornerRatio())
mode |= QuickTileFlag::Bottom;
} else if (options->electricBorderMaximize() && yroot <= area.y() + 5 && isMaximizable()) {
mode = QuickTileFlag::Maximize;
innerBorder = isInScreen(QPoint(xroot, area.y() - 1));
}
break; // no point in checking other screens to contain this... "point"...
}
if (mode != electricBorderMode()) {
setElectricBorderMode(mode);
if (innerBorder) {
if (!m_electricMaximizingDelay) {
m_electricMaximizingDelay = new QTimer(this);
m_electricMaximizingDelay->setInterval(250);
m_electricMaximizingDelay->setSingleShot(true);
connect(m_electricMaximizingDelay, &QTimer::timeout, [this]() {
if (isMove())
setElectricBorderMaximizing(electricBorderMode() != QuickTileMode(QuickTileFlag::None));
});
}
m_electricMaximizingDelay->start();
} else {
setElectricBorderMaximizing(mode != QuickTileMode(QuickTileFlag::None));
}
}
}
void AbstractClient::keyPressEvent(uint key_code)
{
if (!isMove() && !isResize())
return;
bool is_control = key_code & Qt::CTRL;
bool is_alt = key_code & Qt::ALT;
key_code = key_code & ~Qt::KeyboardModifierMask;
int delta = is_control ? 1 : is_alt ? 32 : 8;
QPoint pos = Cursors::self()->mouse()->pos();
switch(key_code) {
case Qt::Key_Left:
pos.rx() -= delta;
break;
case Qt::Key_Right:
pos.rx() += delta;
break;
case Qt::Key_Up:
pos.ry() -= delta;
break;
case Qt::Key_Down:
pos.ry() += delta;
break;
case Qt::Key_Space:
case Qt::Key_Return:
case Qt::Key_Enter:
setMoveResizePointerButtonDown(false);
[wayland] Don't crash when resizing windows Summary: If you resize a decorated client by using the resize user action(press Alt + F3 > More Actions > Resize), then KWin will crash because it gets stuck in an infinite loop (AbstractClient::performMoveResize <-> ShellClient::setGeometry). Here's how KWin gets stuck in that loop: * when you finish resizing the client, AbstractClient::keyPressEvent will call AbstractClient::finishMoveResize; * the first thing that finishMoveResize does is block geometry updates, then it does some clean up (e.g. reset the value of isMoveResize(), etc), updates the geometry of the client and when it's done, it will emit clientFinishUserMoveResized signal; * when PointerInputRedirection notices that signal, it will call processDecorationMove on the client, which in its turn will indirectly call AbstractClient::startMoveResize; * when it's time to go back to AbstractClient::keyPressEvent, geometry updates are unblocked and if there are any pending geometry updates, then ShellClient::setGeometry will be called; * ShellClient::setGeometry will eventually call ShellClient::doSetGeometry; * ShellClient::doSetGeometry will call AbstractClient::performMoveResize because AbstractClient::processDecorationMove indirectly called AbstractClient::startMoveResize; * AbstractClient::performMoveResize calls ShellClient::setGeometry; * (at this point, KWin got stuck in the infinite loop) This change swaps setMoveResizePointerButtonDown and finishMoveResize, so processDecorationMove won't indirectly call startMoveResize. BUG: 397577 FIXED-IN: 5.14.4 Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D16846
2018-11-12 15:45:14 +00:00
finishMoveResize(false);
updateCursor();
break;
case Qt::Key_Escape:
setMoveResizePointerButtonDown(false);
[wayland] Don't crash when resizing windows Summary: If you resize a decorated client by using the resize user action(press Alt + F3 > More Actions > Resize), then KWin will crash because it gets stuck in an infinite loop (AbstractClient::performMoveResize <-> ShellClient::setGeometry). Here's how KWin gets stuck in that loop: * when you finish resizing the client, AbstractClient::keyPressEvent will call AbstractClient::finishMoveResize; * the first thing that finishMoveResize does is block geometry updates, then it does some clean up (e.g. reset the value of isMoveResize(), etc), updates the geometry of the client and when it's done, it will emit clientFinishUserMoveResized signal; * when PointerInputRedirection notices that signal, it will call processDecorationMove on the client, which in its turn will indirectly call AbstractClient::startMoveResize; * when it's time to go back to AbstractClient::keyPressEvent, geometry updates are unblocked and if there are any pending geometry updates, then ShellClient::setGeometry will be called; * ShellClient::setGeometry will eventually call ShellClient::doSetGeometry; * ShellClient::doSetGeometry will call AbstractClient::performMoveResize because AbstractClient::processDecorationMove indirectly called AbstractClient::startMoveResize; * AbstractClient::performMoveResize calls ShellClient::setGeometry; * (at this point, KWin got stuck in the infinite loop) This change swaps setMoveResizePointerButtonDown and finishMoveResize, so processDecorationMove won't indirectly call startMoveResize. BUG: 397577 FIXED-IN: 5.14.4 Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D16846
2018-11-12 15:45:14 +00:00
finishMoveResize(true);
updateCursor();
break;
default:
return;
}
Cursors::self()->mouse()->setPos(pos);
}
QSize AbstractClient::resizeIncrements() const
{
return QSize(1, 1);
}
void AbstractClient::dontMoveResize()
{
setMoveResizePointerButtonDown(false);
stopDelayedMoveResize();
if (isMoveResize())
finishMoveResize(false);
}
AbstractClient::Position AbstractClient::mousePosition() const
{
if (isDecorated()) {
switch (decoration()->sectionUnderMouse()) {
case Qt::BottomLeftSection:
return PositionBottomLeft;
case Qt::BottomRightSection:
return PositionBottomRight;
case Qt::BottomSection:
return PositionBottom;
case Qt::LeftSection:
return PositionLeft;
case Qt::RightSection:
return PositionRight;
case Qt::TopSection:
return PositionTop;
case Qt::TopLeftSection:
return PositionTopLeft;
case Qt::TopRightSection:
return PositionTopRight;
default:
return PositionCenter;
}
}
return PositionCenter;
}
void AbstractClient::endMoveResize()
{
setMoveResizePointerButtonDown(false);
stopDelayedMoveResize();
if (isMoveResize()) {
finishMoveResize(false);
setMoveResizePointerMode(mousePosition());
}
updateCursor();
}
void AbstractClient::createDecoration(const QRect &oldGeometry)
{
KDecoration2::Decoration *decoration = Decoration::DecorationBridge::self()->createDecoration(this);
if (decoration) {
QMetaObject::invokeMethod(decoration, "update", Qt::QueuedConnection);
connect(decoration, &KDecoration2::Decoration::shadowChanged, this, &Toplevel::updateShadow);
connect(decoration, &KDecoration2::Decoration::bordersChanged,
this, &AbstractClient::updateDecorationInputShape);
connect(decoration, &KDecoration2::Decoration::resizeOnlyBordersChanged,
this, &AbstractClient::updateDecorationInputShape);
connect(decoration, &KDecoration2::Decoration::bordersChanged, this, [this]() {
GeometryUpdatesBlocker blocker(this);
const QRect oldGeometry = frameGeometry();
if (!isShade()) {
checkWorkspacePosition(oldGeometry);
}
emit geometryShapeChanged(this, oldGeometry);
});
connect(decoratedClient()->decoratedClient(), &KDecoration2::DecoratedClient::sizeChanged,
this, &AbstractClient::updateDecorationInputShape);
}
setDecoration(decoration);
setFrameGeometry(QRect(oldGeometry.topLeft(), clientSizeToFrameSize(clientSize())));
updateDecorationInputShape();
emit geometryShapeChanged(this, oldGeometry);
}
void AbstractClient::destroyDecoration()
{
delete m_decoration.decoration;
m_decoration.decoration = nullptr;
m_decoration.inputRegion = QRegion();
}
void AbstractClient::updateDecorationInputShape()
{
if (!isDecorated()) {
return;
}
const QMargins borders = decoration()->borders();
const QMargins resizeBorders = decoration()->resizeOnlyBorders();
const QRect innerRect = QRect(QPoint(borderLeft(), borderTop()), decoratedClient()->size());
const QRect outerRect = innerRect + borders + resizeBorders;
m_decoration.inputRegion = QRegion(outerRect) - innerRect;
}
bool AbstractClient::decorationHasAlpha() const
{
if (!isDecorated() || decoration()->isOpaque()) {
// either no decoration or decoration has alpha disabled
return false;
}
return true;
}
void AbstractClient::triggerDecorationRepaint()
{
if (isDecorated()) {
decoration()->update();
}
}
void AbstractClient::layoutDecorationRects(QRect &left, QRect &top, QRect &right, QRect &bottom) const
{
if (!isDecorated()) {
return;
}
QRect r = decoration()->rect();
top = QRect(r.x(), r.y(), r.width(), borderTop());
bottom = QRect(r.x(), r.y() + r.height() - borderBottom(),
r.width(), borderBottom());
left = QRect(r.x(), r.y() + top.height(),
borderLeft(), r.height() - top.height() - bottom.height());
right = QRect(r.x() + r.width() - borderRight(), r.y() + top.height(),
borderRight(), r.height() - top.height() - bottom.height());
}
void AbstractClient::processDecorationMove(const QPoint &localPos, const QPoint &globalPos)
{
if (isMoveResizePointerButtonDown()) {
handleMoveResize(localPos.x(), localPos.y(), globalPos.x(), globalPos.y());
return;
}
// TODO: handle modifiers
Position newmode = mousePosition();
if (newmode != moveResizePointerMode()) {
setMoveResizePointerMode(newmode);
updateCursor();
}
}
bool AbstractClient::processDecorationButtonPress(QMouseEvent *event, bool ignoreMenu)
{
Options::MouseCommand com = Options::MouseNothing;
bool active = isActive();
if (!wantsInput()) // we cannot be active, use it anyway
active = true;
// check whether it is a double click
if (event->button() == Qt::LeftButton && titlebarPositionUnderMouse()) {
if (m_decoration.doubleClickTimer.isValid()) {
const qint64 interval = m_decoration.doubleClickTimer.elapsed();
m_decoration.doubleClickTimer.invalidate();
if (interval > QGuiApplication::styleHints()->mouseDoubleClickInterval()) {
m_decoration.doubleClickTimer.start(); // expired -> new first click and pot. init
} else {
Workspace::self()->performWindowOperation(this, options->operationTitlebarDblClick());
dontMoveResize();
return false;
}
}
else {
m_decoration.doubleClickTimer.start(); // new first click and pot. init, could be invalidated by release - see below
}
}
if (event->button() == Qt::LeftButton)
com = active ? options->commandActiveTitlebar1() : options->commandInactiveTitlebar1();
else if (event->button() == Qt::MiddleButton)
com = active ? options->commandActiveTitlebar2() : options->commandInactiveTitlebar2();
else if (event->button() == Qt::RightButton)
com = active ? options->commandActiveTitlebar3() : options->commandInactiveTitlebar3();
if (event->button() == Qt::LeftButton
&& com != Options::MouseOperationsMenu // actions where it's not possible to get the matching
&& com != Options::MouseMinimize) // mouse release event
{
setMoveResizePointerMode(mousePosition());
setMoveResizePointerButtonDown(true);
setMoveOffset(event->pos());
setInvertedMoveOffset(rect().bottomRight() - moveOffset());
setUnrestrictedMoveResize(false);
startDelayedMoveResize();
updateCursor();
}
// In the new API the decoration may process the menu action to display an inactive tab's menu.
// If the event is unhandled then the core will create one for the active window in the group.
if (!ignoreMenu || com != Options::MouseOperationsMenu)
performMouseCommand(com, event->globalPos());
return !( // Return events that should be passed to the decoration in the new API
com == Options::MouseRaise ||
com == Options::MouseOperationsMenu ||
com == Options::MouseActivateAndRaise ||
com == Options::MouseActivate ||
com == Options::MouseActivateRaiseAndPassClick ||
com == Options::MouseActivateAndPassClick ||
com == Options::MouseNothing);
}
void AbstractClient::processDecorationButtonRelease(QMouseEvent *event)
{
if (isDecorated()) {
if (event->isAccepted() || !titlebarPositionUnderMouse()) {
invalidateDecorationDoubleClickTimer(); // click was for the deco and shall not init a doubleclick
}
}
if (event->buttons() == Qt::NoButton) {
setMoveResizePointerButtonDown(false);
stopDelayedMoveResize();
if (isMoveResize()) {
finishMoveResize(false);
setMoveResizePointerMode(mousePosition());
}
updateCursor();
}
}
void AbstractClient::startDecorationDoubleClickTimer()
{
m_decoration.doubleClickTimer.start();
}
void AbstractClient::invalidateDecorationDoubleClickTimer()
{
m_decoration.doubleClickTimer.invalidate();
}
bool AbstractClient::providesContextHelp() const
{
return false;
}
void AbstractClient::showContextHelp()
{
}
QPointer<Decoration::DecoratedClientImpl> AbstractClient::decoratedClient() const
{
return m_decoration.client;
}
void AbstractClient::setDecoratedClient(QPointer< Decoration::DecoratedClientImpl > client)
{
m_decoration.client = client;
}
void AbstractClient::enterEvent(const QPoint &globalPos)
{
if (options->isShadeHover()) {
cancelShadeHoverTimer();
startShadeHoverTimer();
}
if (options->focusPolicy() == Options::ClickToFocus || workspace()->userActionsMenu()->isShown())
return;
if (options->isAutoRaise() && !isDesktop() &&
!isDock() && workspace()->focusChangeEnabled() &&
globalPos != workspace()->focusMousePosition() &&
workspace()->topClientOnDesktop(VirtualDesktopManager::self()->current(),
options->isSeparateScreenFocus() ? screen() : -1) != this) {
startAutoRaise();
}
if (isDesktop() || isDock())
return;
// for FocusFollowsMouse, change focus only if the mouse has actually been moved, not if the focus
// change came because of window changes (e.g. closing a window) - #92290
if (options->focusPolicy() != Options::FocusFollowsMouse
|| globalPos != workspace()->focusMousePosition()) {
workspace()->requestDelayFocus(this);
}
}
void AbstractClient::leaveEvent()
{
cancelAutoRaise();
workspace()->cancelDelayFocus();
cancelShadeHoverTimer();
startShadeUnhoverTimer();
// TODO: send hover leave to deco
// TODO: handle Options::FocusStrictlyUnderMouse
}
QRect AbstractClient::iconGeometry() const
{
if (!windowManagementInterface() || !waylandServer()) {
// window management interface is only available if the surface is mapped
return QRect();
}
int minDistance = INT_MAX;
AbstractClient *candidatePanel = nullptr;
QRect candidateGeom;
for (auto i = windowManagementInterface()->minimizedGeometries().constBegin(), end = windowManagementInterface()->minimizedGeometries().constEnd(); i != end; ++i) {
AbstractClient *client = waylandServer()->findClient(i.key());
if (!client) {
continue;
}
const int distance = QPoint(client->pos() - pos()).manhattanLength();
if (distance < minDistance) {
minDistance = distance;
candidatePanel = client;
candidateGeom = i.value();
}
}
if (!candidatePanel) {
return QRect();
}
return candidateGeom.translated(candidatePanel->pos());
}
QRect AbstractClient::inputGeometry() const
{
if (isDecorated()) {
return Toplevel::inputGeometry() + decoration()->resizeOnlyBorders();
}
return Toplevel::inputGeometry();
}
bool AbstractClient::hitTest(const QPoint &point) const
{
if (isDecorated()) {
if (m_decoration.inputRegion.contains(mapToFrame(point))) {
return true;
}
}
return Toplevel::hitTest(point);
}
QRect AbstractClient::virtualKeyboardGeometry() const
{
return m_virtualKeyboardGeometry;
}
void AbstractClient::setVirtualKeyboardGeometry(const QRect &geo)
{
// No keyboard anymore
if (geo.isEmpty() && !m_keyboardGeometryRestore.isEmpty()) {
setFrameGeometry(m_keyboardGeometryRestore);
m_keyboardGeometryRestore = QRect();
} else if (geo.isEmpty()) {
return;
// The keyboard has just been opened (rather than resized) save client geometry for a restore
} else if (m_keyboardGeometryRestore.isEmpty()) {
m_keyboardGeometryRestore = frameGeometry();
}
m_virtualKeyboardGeometry = geo;
// Don't resize Desktop and fullscreen windows
if (isFullScreen() || isDesktop()) {
return;
}
if (!geo.intersects(m_keyboardGeometryRestore)) {
return;
}
const QRect availableArea = workspace()->clientArea(MaximizeArea, this);
QRect newWindowGeometry = m_keyboardGeometryRestore;
newWindowGeometry.moveBottom(geo.top());
newWindowGeometry.setTop(qMax(newWindowGeometry.top(), availableArea.top()));
setFrameGeometry(newWindowGeometry);
}
QRect AbstractClient::keyboardGeometryRestore() const
{
return m_keyboardGeometryRestore;
}
void AbstractClient::setKeyboardGeometryRestore(const QRect &geom)
{
m_keyboardGeometryRestore = geom;
}
bool AbstractClient::dockWantsInput() const
{
return false;
}
void AbstractClient::setDesktopFileName(QByteArray name)
{
name = rules()->checkDesktopFile(name).toUtf8();
if (name == m_desktopFileName) {
return;
}
m_desktopFileName = name;
updateWindowRules(Rules::DesktopFile);
emit desktopFileNameChanged();
}
QString AbstractClient::iconFromDesktopFile() const
{
if (m_desktopFileName.isEmpty()) {
return {};
}
const QString desktopFileName = QString::fromUtf8(m_desktopFileName);
QString desktopFilePath;
if (QDir::isAbsolutePath(desktopFileName)) {
desktopFilePath = desktopFileName;
}
if (desktopFilePath.isEmpty()) {
desktopFilePath = QStandardPaths::locate(QStandardPaths::ApplicationsLocation,
desktopFileName);
}
if (desktopFilePath.isEmpty()) {
desktopFilePath = QStandardPaths::locate(QStandardPaths::ApplicationsLocation,
desktopFileName + QLatin1String(".desktop"));
}
KDesktopFile df(desktopFilePath);
return df.readIcon();
}
bool AbstractClient::hasApplicationMenu() const
{
return ApplicationMenu::self()->applicationMenuEnabled() && !m_applicationMenuServiceName.isEmpty() && !m_applicationMenuObjectPath.isEmpty();
}
void AbstractClient::updateApplicationMenuServiceName(const QString &serviceName)
{
const bool old_hasApplicationMenu = hasApplicationMenu();
m_applicationMenuServiceName = serviceName;
const bool new_hasApplicationMenu = hasApplicationMenu();
emit applicationMenuChanged();
if (old_hasApplicationMenu != new_hasApplicationMenu) {
emit hasApplicationMenuChanged(new_hasApplicationMenu);
}
}
void AbstractClient::updateApplicationMenuObjectPath(const QString &objectPath)
{
const bool old_hasApplicationMenu = hasApplicationMenu();
m_applicationMenuObjectPath = objectPath;
const bool new_hasApplicationMenu = hasApplicationMenu();
emit applicationMenuChanged();
if (old_hasApplicationMenu != new_hasApplicationMenu) {
emit hasApplicationMenuChanged(new_hasApplicationMenu);
}
}
void AbstractClient::setApplicationMenuActive(bool applicationMenuActive)
{
if (m_applicationMenuActive != applicationMenuActive) {
m_applicationMenuActive = applicationMenuActive;
emit applicationMenuActiveChanged(applicationMenuActive);
}
}
void AbstractClient::showApplicationMenu(int actionId)
{
if (isDecorated()) {
decoration()->showApplicationMenu(actionId);
} else {
// we don't know where the application menu button will be, show it in the top left corner instead
Workspace::self()->showApplicationMenu(QRect(), this, actionId);
}
}
bool AbstractClient::unresponsive() const
{
return m_unresponsive;
}
void AbstractClient::setUnresponsive(bool unresponsive)
{
if (m_unresponsive != unresponsive) {
m_unresponsive = unresponsive;
emit unresponsiveChanged(m_unresponsive);
emit captionChanged();
}
}
QString AbstractClient::shortcutCaptionSuffix() const
{
if (shortcut().isEmpty()) {
return QString();
}
return QLatin1String(" {") + shortcut().toString() + QLatin1Char('}');
}
AbstractClient *AbstractClient::findClientWithSameCaption() const
{
auto fetchNameInternalPredicate = [this](const AbstractClient *cl) {
return (!cl->isSpecialWindow() || cl->isToolbar()) && cl != this && cl->captionNormal() == captionNormal() && cl->captionSuffix() == captionSuffix();
};
return workspace()->findAbstractClient(fetchNameInternalPredicate);
}
QString AbstractClient::caption() const
{
QString cap = captionNormal() + captionSuffix();
if (unresponsive()) {
cap += QLatin1String(" ");
cap += i18nc("Application is not responding, appended to window title", "(Not Responding)");
}
return cap;
}
void AbstractClient::removeRule(Rules* rule)
{
m_rules.remove(rule);
}
void AbstractClient::discardTemporaryRules()
{
m_rules.discardTemporary();
}
void AbstractClient::evaluateWindowRules()
{
setupWindowRules(true);
applyWindowRules();
}
void AbstractClient::setOnActivities(QStringList newActivitiesList)
{
Q_UNUSED(newActivitiesList)
}
void AbstractClient::checkNoBorder()
{
setNoBorder(false);
}
bool AbstractClient::groupTransient() const
{
return false;
}
const Group *AbstractClient::group() const
{
return nullptr;
}
Group *AbstractClient::group()
{
return nullptr;
}
bool AbstractClient::isInternal() const
{
return false;
}
bool AbstractClient::supportsWindowRules() const
{
return false;
}
QMargins AbstractClient::frameMargins() const
{
return QMargins(borderLeft(), borderTop(), borderRight(), borderBottom());
}
[x11] Add support for _GTK_FRAME_EXTENTS Summary: KDE is known for having a strong view on the client-side decorations vs server-side decorations issue. The main argument raised against CSD is that desktop will look less consistent when clients start drawing window decorations by themselves, which is somewhat true. It all ties to how well each toolkit is integrated with the desktop environment. KDE doesn't control the desktop market on Linux. Another big "player" is GNOME. Both KDE and GNOME have very polarized views on in which direction desktop should move forward. The KDE community is pushing more toward server-side decorations while the GNOME community is pushing more toward client-side decorations. Both communities have developed great applications and it's not rare to see a GNOME application being used in KDE Plasma. The only problem is that these different views are not left behind the curtain and our users pay the price. Resizing GTK clients in Plasma became practically impossible due to resize borders having small hit area. When a client draws its window decoration, it's more likely that it also draws the drop-shadow around the decoration. The compositor must know the extents of the shadow so things like snapping and so on work as expected. And here lies the problem... While the xdg-shell protocol has a way to specify such things, the NetWM spec doesn't have anything like that. There's _GTK_FRAME_EXTENTS in the wild, however the problem with it is that it's a proprietary atom, which is specific only to GTK apps. Due to that, _GTK_FRAME_EXTENTS wasn't implemented because implementing anything like that would require major changes in how we think about geometry. Recent xdg-shell window geometry patches adjusted geometry abstractions in kwin to such a degree that it's very easy to add support for client side decorated clients on X11. We just have to make sure that the X11Client class provides correct buffer geometry and frame geometry when the gtk frame extents are set. Even though the X11 code is feature frozen, I still think it's worth to have _GTK_FRAME_EXTENTS support in kwin because it will fix the resize issues. Also, because KWin/Wayland is unfortunately far from becoming default, it will help us with testing some implementation bits of the window geometry from xdg-shell. BUG: 390550 FIXED-IN: 5.18.0 Test Plan: Things like quick tiling, maximizing, tiling scripts and so on work as expected with GTK clients. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: cblack, trmdi, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D24660
2019-10-08 08:46:59 +00:00
QPoint AbstractClient::framePosToClientPos(const QPoint &point) const
{
return point + QPoint(borderLeft(), borderTop());
}
QPoint AbstractClient::clientPosToFramePos(const QPoint &point) const
{
return point - QPoint(borderLeft(), borderTop());
}
QSize AbstractClient::frameSizeToClientSize(const QSize &size) const
{
const int width = size.width() - borderLeft() - borderRight();
const int height = size.height() - borderTop() - borderBottom();
return QSize(width, height);
}
QSize AbstractClient::clientSizeToFrameSize(const QSize &size) const
{
const int width = size.width() + borderLeft() + borderRight();
const int height = size.height() + borderTop() + borderBottom();
return QSize(width, height);
}
QRect AbstractClient::frameRectToClientRect(const QRect &rect) const
{
const QPoint position = framePosToClientPos(rect.topLeft());
const QSize size = frameSizeToClientSize(rect.size());
return QRect(position, size);
}
QRect AbstractClient::clientRectToFrameRect(const QRect &rect) const
{
const QPoint position = clientPosToFramePos(rect.topLeft());
const QSize size = clientSizeToFrameSize(rect.size());
return QRect(position, size);
}
void AbstractClient::setElectricBorderMode(QuickTileMode mode)
{
if (mode != QuickTileMode(QuickTileFlag::Maximize)) {
// sanitize the mode, ie. simplify "invalid" combinations
if ((mode & QuickTileFlag::Horizontal) == QuickTileMode(QuickTileFlag::Horizontal))
mode &= ~QuickTileMode(QuickTileFlag::Horizontal);
if ((mode & QuickTileFlag::Vertical) == QuickTileMode(QuickTileFlag::Vertical))
mode &= ~QuickTileMode(QuickTileFlag::Vertical);
}
m_electricMode = mode;
}
void AbstractClient::setElectricBorderMaximizing(bool maximizing)
{
m_electricMaximizing = maximizing;
if (maximizing)
outline()->show(electricBorderMaximizeGeometry(Cursors::self()->mouse()->pos(), desktop()), moveResizeGeometry());
else
outline()->hide();
elevate(maximizing);
}
QRect AbstractClient::electricBorderMaximizeGeometry(QPoint pos, int desktop)
{
if (electricBorderMode() == QuickTileMode(QuickTileFlag::Maximize)) {
if (maximizeMode() == MaximizeFull)
return geometryRestore();
else
return workspace()->clientArea(MaximizeArea, pos, desktop);
}
QRect ret = workspace()->clientArea(MaximizeArea, pos, desktop);
if (electricBorderMode() & QuickTileFlag::Left)
ret.setRight(ret.left()+ret.width()/2 - 1);
else if (electricBorderMode() & QuickTileFlag::Right)
ret.setLeft(ret.right()-(ret.width()-ret.width()/2) + 1);
if (electricBorderMode() & QuickTileFlag::Top)
ret.setBottom(ret.top()+ret.height()/2 - 1);
else if (electricBorderMode() & QuickTileFlag::Bottom)
ret.setTop(ret.bottom()-(ret.height()-ret.height()/2) + 1);
return ret;
}
void AbstractClient::setQuickTileMode(QuickTileMode mode, bool keyboard)
{
// Only allow quick tile on a regular window.
if (!isResizable()) {
return;
}
workspace()->updateFocusMousePosition(Cursors::self()->mouse()->pos()); // may cause leave event
GeometryUpdatesBlocker blocker(this);
if (mode == QuickTileMode(QuickTileFlag::Maximize)) {
m_quickTileMode = int(QuickTileFlag::None);
if (maximizeMode() == MaximizeFull) {
setMaximize(false, false);
} else {
QRect prev_geom_restore = geometryRestore(); // setMaximize() would set moveResizeGeom as geom_restore
m_quickTileMode = int(QuickTileFlag::Maximize);
setMaximize(true, true);
QRect clientArea = workspace()->clientArea(MaximizeArea, this);
if (frameGeometry().top() != clientArea.top()) {
QRect r(frameGeometry());
r.moveTop(clientArea.top());
setFrameGeometry(r);
}
setGeometryRestore(prev_geom_restore);
}
doSetQuickTileMode();
emit quickTileModeChanged();
return;
}
// sanitize the mode, ie. simplify "invalid" combinations
if ((mode & QuickTileFlag::Horizontal) == QuickTileMode(QuickTileFlag::Horizontal))
mode &= ~QuickTileMode(QuickTileFlag::Horizontal);
if ((mode & QuickTileFlag::Vertical) == QuickTileMode(QuickTileFlag::Vertical))
mode &= ~QuickTileMode(QuickTileFlag::Vertical);
setElectricBorderMode(mode); // used by ::electricBorderMaximizeGeometry(.)
// restore from maximized so that it is possible to tile maximized windows with one hit or by dragging
if (maximizeMode() != MaximizeRestore) {
if (mode != QuickTileMode(QuickTileFlag::None)) {
// decorations may turn off some borders when tiled
const ForceGeometry_t geom_mode = isDecorated() ? ForceGeometrySet : NormalGeometrySet;
m_quickTileMode = int(QuickTileFlag::None); // Temporary, so the maximize code doesn't get all confused
setMaximize(false, false);
setFrameGeometry(electricBorderMaximizeGeometry(keyboard ? frameGeometry().center() : Cursors::self()->mouse()->pos(), desktop()), geom_mode);
// Store the mode change
m_quickTileMode = mode;
} else {
m_quickTileMode = mode;
setMaximize(false, false);
}
doSetQuickTileMode();
emit quickTileModeChanged();
return;
}
if (mode != QuickTileMode(QuickTileFlag::None)) {
QPoint whichScreen = keyboard ? frameGeometry().center() : Cursors::self()->mouse()->pos();
// If trying to tile to the side that the window is already tiled to move the window to the next
// screen if it exists, otherwise toggle the mode (set QuickTileFlag::None)
if (quickTileMode() == mode) {
const int numScreens = screens()->count();
const int curScreen = screen();
int nextScreen = curScreen;
QVarLengthArray<QRect> screens(numScreens);
for (int i = 0; i < numScreens; ++i) // Cache
screens[i] = Screens::self()->geometry(i);
for (int i = 0; i < numScreens; ++i) {
if (i == curScreen)
continue;
if (screens[i].bottom() <= screens[curScreen].top() || screens[i].top() >= screens[curScreen].bottom())
continue; // not in horizontal line
const int x = screens[i].center().x();
if ((mode & QuickTileFlag::Horizontal) == QuickTileMode(QuickTileFlag::Left)) {
if (x >= screens[curScreen].center().x() || (curScreen != nextScreen && x <= screens[nextScreen].center().x()))
continue; // not left of current or more left then found next
} else if ((mode & QuickTileFlag::Horizontal) == QuickTileMode(QuickTileFlag::Right)) {
if (x <= screens[curScreen].center().x() || (curScreen != nextScreen && x >= screens[nextScreen].center().x()))
continue; // not right of current or more right then found next
}
nextScreen = i;
}
if (nextScreen == curScreen) {
mode = QuickTileFlag::None; // No other screens, toggle tiling
} else {
// Move to other screen
setFrameGeometry(geometryRestore().translated(screens[nextScreen].topLeft() - screens[curScreen].topLeft()));
whichScreen = screens[nextScreen].center();
// Swap sides
if (mode & QuickTileFlag::Horizontal) {
mode = (~mode & QuickTileFlag::Horizontal) | (mode & QuickTileFlag::Vertical);
}
}
setElectricBorderMode(mode); // used by ::electricBorderMaximizeGeometry(.)
} else if (quickTileMode() == QuickTileMode(QuickTileFlag::None)) {
// Not coming out of an existing tile, not shifting monitors, we're setting a brand new tile.
// Store geometry first, so we can go out of this tile later.
setGeometryRestore(frameGeometry());
}
if (mode != QuickTileMode(QuickTileFlag::None)) {
m_quickTileMode = mode;
// decorations may turn off some borders when tiled
const ForceGeometry_t geom_mode = isDecorated() ? ForceGeometrySet : NormalGeometrySet;
// Temporary, so the maximize code doesn't get all confused
m_quickTileMode = int(QuickTileFlag::None);
setFrameGeometry(electricBorderMaximizeGeometry(whichScreen, desktop()), geom_mode);
}
// Store the mode change
m_quickTileMode = mode;
}
if (mode == QuickTileMode(QuickTileFlag::None)) {
m_quickTileMode = int(QuickTileFlag::None);
// Untiling, so just restore geometry, and we're done.
if (!geometryRestore().isValid()) // invalid if we started maximized and wait for placement
setGeometryRestore(frameGeometry());
// decorations may turn off some borders when tiled
const ForceGeometry_t geom_mode = isDecorated() ? ForceGeometrySet : NormalGeometrySet;
setFrameGeometry(geometryRestore(), geom_mode);
checkWorkspacePosition(); // Just in case it's a different screen
}
doSetQuickTileMode();
emit quickTileModeChanged();
}
void AbstractClient::doSetQuickTileMode()
{
}
void AbstractClient::sendToScreen(int newScreen)
{
newScreen = rules()->checkScreen(newScreen);
if (isActive()) {
screens()->setCurrent(newScreen);
// might impact the layer of a fullscreen window
foreach (AbstractClient *cc, workspace()->allClientList()) {
if (cc->isFullScreen() && cc->screen() == newScreen) {
cc->updateLayer();
}
}
}
if (screen() == newScreen && !isFullScreen()) // Don't use isOnScreen(), that's true even when only partially
return;
GeometryUpdatesBlocker blocker(this);
// operating on the maximized / quicktiled window would leave the old geom_restore behind,
// so we clear the state first
MaximizeMode maxMode = maximizeMode();
QuickTileMode qtMode = quickTileMode();
if (maxMode != MaximizeRestore)
maximize(MaximizeRestore);
if (qtMode != QuickTileMode(QuickTileFlag::None))
setQuickTileMode(QuickTileFlag::None, true);
QRect oldScreenArea = workspace()->clientArea(MaximizeArea, this);
QRect screenArea = workspace()->clientArea(MaximizeArea, newScreen, desktop());
// the window can have its center so that the position correction moves the new center onto
// the old screen, what will tile it where it is. Ie. the screen is not changed
// this happens esp. with electric border quicktiling
if (qtMode != QuickTileMode(QuickTileFlag::None))
keepInArea(oldScreenArea);
QRect oldGeom = frameGeometry();
QRect newGeom = oldGeom;
// move the window to have the same relative position to the center of the screen
// (i.e. one near the middle of the right edge will also end up near the middle of the right edge)
QPoint center = newGeom.center() - oldScreenArea.center();
center.setX(center.x() * screenArea.width() / oldScreenArea.width());
center.setY(center.y() * screenArea.height() / oldScreenArea.height());
center += screenArea.center();
newGeom.moveCenter(center);
setFrameGeometry(newGeom);
// If the window was inside the old screen area, explicitly make sure its inside also the new screen area.
// Calling checkWorkspacePosition() should ensure that, but when moving to a small screen the window could
// be big enough to overlap outside of the new screen area, making struts from other screens come into effect,
// which could alter the resulting geometry.
if (oldScreenArea.contains(oldGeom)) {
keepInArea(screenArea);
}
if (isFullScreen()) {
QRect newFullScreenGeometryRestore = screenArea;
if (!(maximizeMode() & MaximizeVertical)) {
newFullScreenGeometryRestore.setHeight(geometryRestore().height());
}
if (!(maximizeMode() & MaximizeHorizontal)) {
newFullScreenGeometryRestore.setWidth(geometryRestore().width());
}
newFullScreenGeometryRestore.setSize(newFullScreenGeometryRestore.size().boundedTo(screenArea.size()));
QSize move = (screenArea.size() - newFullScreenGeometryRestore.size()) / 2;
newFullScreenGeometryRestore.translate(move.width(), move.height());
QRect newGeometryRestore = QRect(screenArea.topLeft(), geometryRestore().size().boundedTo(screenArea.size()));
move = (screenArea.size() - newGeometryRestore.size()) / 2;
newGeometryRestore.translate(move.width(), move.height());
setFullscreenGeometryRestore(newFullScreenGeometryRestore);
setGeometryRestore(newGeometryRestore);
checkWorkspacePosition(oldGeom);
} else {
// align geom_restore - checkWorkspacePosition operates on it
setGeometryRestore(frameGeometry());
checkWorkspacePosition(oldGeom);
// re-align geom_restore to constrained geometry
setGeometryRestore(frameGeometry());
}
// finally reset special states
// NOTICE that MaximizeRestore/QuickTileFlag::None checks are required.
// eg. setting QuickTileFlag::None would break maximization
if (maxMode != MaximizeRestore)
maximize(maxMode);
if (qtMode != QuickTileMode(QuickTileFlag::None) && qtMode != quickTileMode())
setQuickTileMode(qtMode, true);
auto tso = workspace()->ensureStackingOrder(transients());
for (auto it = tso.constBegin(), end = tso.constEnd(); it != end; ++it)
(*it)->sendToScreen(newScreen);
}
void AbstractClient::checkWorkspacePosition(QRect oldGeometry, int oldDesktop, QRect oldClientGeometry)
{
if (isDock() || isDesktop() || !isPlaceable()) {
return;
}
enum { Left = 0, Top, Right, Bottom };
const int border[4] = { borderLeft(), borderTop(), borderRight(), borderBottom() };
if( !oldGeometry.isValid())
oldGeometry = frameGeometry();
if( oldDesktop == -2 )
oldDesktop = desktop();
if (!oldClientGeometry.isValid())
oldClientGeometry = oldGeometry.adjusted(border[Left], border[Top], -border[Right], -border[Bottom]);
if (isFullScreen()) {
QRect area = workspace()->clientArea(FullScreenArea, fullscreenGeometryRestore().center(), desktop());
if (frameGeometry() != area)
setFrameGeometry(area);
return;
}
if (maximizeMode() != MaximizeRestore) {
GeometryUpdatesBlocker block(this);
changeMaximize(false, false, true); // adjust size
const QRect screenArea = workspace()->clientArea(ScreenArea, this);
QRect geom = frameGeometry();
checkOffscreenPosition(&geom, screenArea);
setFrameGeometry(geom);
return;
}
if (quickTileMode() != QuickTileMode(QuickTileFlag::None)) {
setFrameGeometry(electricBorderMaximizeGeometry(frameGeometry().center(), desktop()));
return;
}
// this can be true only if this window was mapped before KWin
// was started - in such case, don't adjust position to workarea,
// because the window already had its position, and if a window
// with a strut altering the workarea would be managed in initialization
// after this one, this window would be moved
if (!workspace() || workspace()->initializing())
return;
// If the window was touching an edge before but not now move it so it is again.
// Old and new maximums have different starting values so windows on the screen
// edge will move when a new strut is placed on the edge.
QRect oldScreenArea;
if( workspace()->inUpdateClientArea()) {
// we need to find the screen area as it was before the change
oldScreenArea = QRect( 0, 0, workspace()->oldDisplayWidth(), workspace()->oldDisplayHeight());
int distance = INT_MAX;
foreach(const QRect &r, workspace()->previousScreenSizes()) {
int d = r.contains( oldGeometry.center()) ? 0 : ( r.center() - oldGeometry.center()).manhattanLength();
if( d < distance ) {
distance = d;
oldScreenArea = r;
}
}
} else {
oldScreenArea = workspace()->clientArea(ScreenArea, oldGeometry.center(), oldDesktop);
}
const QRect oldGeomTall = QRect(oldGeometry.x(), oldScreenArea.y(), oldGeometry.width(), oldScreenArea.height()); // Full screen height
const QRect oldGeomWide = QRect(oldScreenArea.x(), oldGeometry.y(), oldScreenArea.width(), oldGeometry.height()); // Full screen width
int oldTopMax = oldScreenArea.y();
int oldRightMax = oldScreenArea.x() + oldScreenArea.width();
int oldBottomMax = oldScreenArea.y() + oldScreenArea.height();
int oldLeftMax = oldScreenArea.x();
const QRect screenArea = workspace()->clientArea(ScreenArea, geometryRestore().center(), desktop());
int topMax = screenArea.y();
int rightMax = screenArea.x() + screenArea.width();
int bottomMax = screenArea.y() + screenArea.height();
int leftMax = screenArea.x();
QRect newGeom = geometryRestore(); // geometry();
QRect newClientGeom = newGeom.adjusted(border[Left], border[Top], -border[Right], -border[Bottom]);
const QRect newGeomTall = QRect(newGeom.x(), screenArea.y(), newGeom.width(), screenArea.height()); // Full screen height
const QRect newGeomWide = QRect(screenArea.x(), newGeom.y(), screenArea.width(), newGeom.height()); // Full screen width
// Get the max strut point for each side where the window is (E.g. Highest point for
// the bottom struts bounded by the window's left and right sides).
// These 4 compute old bounds ...
auto moveAreaFunc = workspace()->inUpdateClientArea() ?
&Workspace::previousRestrictedMoveArea : //... the restricted areas changed
&Workspace::restrictedMoveArea; //... when e.g. active desktop or screen changes
for (const QRect &r : (workspace()->*moveAreaFunc)(oldDesktop, StrutAreaTop)) {
QRect rect = r & oldGeomTall;
if (!rect.isEmpty())
oldTopMax = qMax(oldTopMax, rect.y() + rect.height());
}
for (const QRect &r : (workspace()->*moveAreaFunc)(oldDesktop, StrutAreaRight)) {
QRect rect = r & oldGeomWide;
if (!rect.isEmpty())
oldRightMax = qMin(oldRightMax, rect.x());
}
for (const QRect &r : (workspace()->*moveAreaFunc)(oldDesktop, StrutAreaBottom)) {
QRect rect = r & oldGeomTall;
if (!rect.isEmpty())
oldBottomMax = qMin(oldBottomMax, rect.y());
}
for (const QRect &r : (workspace()->*moveAreaFunc)(oldDesktop, StrutAreaLeft)) {
QRect rect = r & oldGeomWide;
if (!rect.isEmpty())
oldLeftMax = qMax(oldLeftMax, rect.x() + rect.width());
}
// These 4 compute new bounds
for (const QRect &r : workspace()->restrictedMoveArea(desktop(), StrutAreaTop)) {
QRect rect = r & newGeomTall;
if (!rect.isEmpty())
topMax = qMax(topMax, rect.y() + rect.height());
}
for (const QRect &r : workspace()->restrictedMoveArea(desktop(), StrutAreaRight)) {
QRect rect = r & newGeomWide;
if (!rect.isEmpty())
rightMax = qMin(rightMax, rect.x());
}
for (const QRect &r : workspace()->restrictedMoveArea(desktop(), StrutAreaBottom)) {
QRect rect = r & newGeomTall;
if (!rect.isEmpty())
bottomMax = qMin(bottomMax, rect.y());
}
for (const QRect &r : workspace()->restrictedMoveArea(desktop(), StrutAreaLeft)) {
QRect rect = r & newGeomWide;
if (!rect.isEmpty())
leftMax = qMax(leftMax, rect.x() + rect.width());
}
// Check if the sides were inside or touching but are no longer
bool keep[4] = {false, false, false, false};
bool save[4] = {false, false, false, false};
int padding[4] = {0, 0, 0, 0};
if (oldGeometry.x() >= oldLeftMax)
save[Left] = newGeom.x() < leftMax;
if (oldGeometry.x() == oldLeftMax)
keep[Left] = newGeom.x() != leftMax;
else if (oldClientGeometry.x() == oldLeftMax && newClientGeom.x() != leftMax) {
padding[0] = border[Left];
keep[Left] = true;
}
if (oldGeometry.y() >= oldTopMax)
save[Top] = newGeom.y() < topMax;
if (oldGeometry.y() == oldTopMax)
keep[Top] = newGeom.y() != topMax;
else if (oldClientGeometry.y() == oldTopMax && newClientGeom.y() != topMax) {
padding[1] = border[Left];
keep[Top] = true;
}
if (oldGeometry.right() <= oldRightMax - 1)
save[Right] = newGeom.right() > rightMax - 1;
if (oldGeometry.right() == oldRightMax - 1)
keep[Right] = newGeom.right() != rightMax - 1;
else if (oldClientGeometry.right() == oldRightMax - 1 && newClientGeom.right() != rightMax - 1) {
padding[2] = border[Right];
keep[Right] = true;
}
if (oldGeometry.bottom() <= oldBottomMax - 1)
save[Bottom] = newGeom.bottom() > bottomMax - 1;
if (oldGeometry.bottom() == oldBottomMax - 1)
keep[Bottom] = newGeom.bottom() != bottomMax - 1;
else if (oldClientGeometry.bottom() == oldBottomMax - 1 && newClientGeom.bottom() != bottomMax - 1) {
padding[3] = border[Bottom];
keep[Bottom] = true;
}
// if randomly touches opposing edges, do not favor either
if (keep[Left] && keep[Right]) {
keep[Left] = keep[Right] = false;
padding[0] = padding[2] = 0;
}
if (keep[Top] && keep[Bottom]) {
keep[Top] = keep[Bottom] = false;
padding[1] = padding[3] = 0;
}
if (save[Left] || keep[Left])
newGeom.moveLeft(qMax(leftMax, screenArea.x()) - padding[0]);
if (padding[0] && screens()->intersecting(newGeom) > 1)
newGeom.moveLeft(newGeom.left() + padding[0]);
if (save[Top] || keep[Top])
newGeom.moveTop(qMax(topMax, screenArea.y()) - padding[1]);
if (padding[1] && screens()->intersecting(newGeom) > 1)
newGeom.moveTop(newGeom.top() + padding[1]);
if (save[Right] || keep[Right])
newGeom.moveRight(qMin(rightMax - 1, screenArea.right()) + padding[2]);
if (padding[2] && screens()->intersecting(newGeom) > 1)
newGeom.moveRight(newGeom.right() - padding[2]);
if (oldGeometry.x() >= oldLeftMax && newGeom.x() < leftMax)
newGeom.setLeft(qMax(leftMax, screenArea.x()));
else if (oldClientGeometry.x() >= oldLeftMax && newGeom.x() + border[Left] < leftMax) {
newGeom.setLeft(qMax(leftMax, screenArea.x()) - border[Left]);
if (screens()->intersecting(newGeom) > 1)
newGeom.setLeft(newGeom.left() + border[Left]);
}
if (save[Bottom] || keep[Bottom])
newGeom.moveBottom(qMin(bottomMax - 1, screenArea.bottom()) + padding[3]);
if (padding[3] && screens()->intersecting(newGeom) > 1)
newGeom.moveBottom(newGeom.bottom() - padding[3]);
if (oldGeometry.y() >= oldTopMax && newGeom.y() < topMax)
newGeom.setTop(qMax(topMax, screenArea.y()));
else if (oldClientGeometry.y() >= oldTopMax && newGeom.y() + border[Top] < topMax) {
newGeom.setTop(qMax(topMax, screenArea.y()) - border[Top]);
if (screens()->intersecting(newGeom) > 1)
newGeom.setTop(newGeom.top() + border[Top]);
}
checkOffscreenPosition(&newGeom, screenArea);
// Obey size hints. TODO: We really should make sure it stays in the right place
if (!isShade())
newGeom.setSize(constrainFrameSize(newGeom.size()));
if (newGeom != frameGeometry())
setFrameGeometry(newGeom);
}
void AbstractClient::checkOffscreenPosition(QRect* geom, const QRect& screenArea)
{
if (geom->left() > screenArea.right()) {
geom->moveLeft(screenArea.right() - screenArea.width()/4);
} else if (geom->right() < screenArea.left()) {
geom->moveRight(screenArea.left() + screenArea.width()/4);
}
if (geom->top() > screenArea.bottom()) {
geom->moveTop(screenArea.bottom() - screenArea.height()/4);
} else if (geom->bottom() < screenArea.top()) {
geom->moveBottom(screenArea.top() + screenArea.width()/4);
}
}
/**
* Returns the appropriate frame size for the current client size.
*
* This is equivalent to clientSizeToFrameSize(constrainClientSize(clientSize())).
*/
QSize AbstractClient::adjustedSize() const
{
return clientSizeToFrameSize(constrainClientSize(clientSize()));
}
/**
* Constrains the client size @p size according to a set of the window's size hints.
*
* Default implementation applies only minimum and maximum size constraints.
*/
QSize AbstractClient::constrainClientSize(const QSize &size, SizeMode mode) const
{
Q_UNUSED(mode)
int width = size.width();
int height = size.height();
// When user is resizing the window, the move resize geometry may have negative width or
// height. In which case, we need to set negative dimensions to reasonable values.
if (width < 1) {
width = 1;
}
if (height < 1) {
height = 1;
}
const QSize minimumSize = minSize();
const QSize maximumSize = maxSize();
width = qBound(minimumSize.width(), width, maximumSize.width());
height = qBound(minimumSize.height(), height, maximumSize.height());
return QSize(width, height);
}
/**
* Constrains the frame size @p size according to a set of the window's size hints.
*/
QSize AbstractClient::constrainFrameSize(const QSize &size, SizeMode mode) const
{
const QSize unconstrainedClientSize = frameSizeToClientSize(size);
const QSize constrainedClientSize = constrainClientSize(unconstrainedClientSize, mode);
return clientSizeToFrameSize(constrainedClientSize);
}
/**
* Returns @c true if the AbstractClient can be shown in full screen mode; otherwise @c false.
*
* Default implementation returns @c false.
*/
bool AbstractClient::isFullScreenable() const
{
return false;
}
/**
* Returns @c true if the AbstractClient is currently being shown in full screen mode; otherwise @c false.
*
* A client in full screen mode occupies the entire screen with no window frame around it.
*
* Default implementation returns @c false.
*/
bool AbstractClient::isFullScreen() const
{
return false;
}
/**
* Returns whether requests initiated by the user to enter or leave full screen mode are honored.
*
* Default implementation returns @c false.
*/
bool AbstractClient::userCanSetFullScreen() const
{
return false;
}
/**
* Asks the AbstractClient to enter or leave full screen mode.
*
* Default implementation does nothing.
*
* @param set @c true if the AbstractClient has to be shown in full screen mode, otherwise @c false
* @param user @c true if the request is initiated by the user, otherwise @c false
*/
void AbstractClient::setFullScreen(bool set, bool user)
{
Q_UNUSED(set)
Q_UNUSED(user)
qCWarning(KWIN_CORE, "%s doesn't support setting fullscreen state", metaObject()->className());
}
/**
* Returns @c true if the AbstractClient can be minimized; otherwise @c false.
*
* Default implementation returns @c false.
*/
bool AbstractClient::isMinimizable() const
{
return false;
}
/**
* Returns @c true if the AbstractClient can be maximized; otherwise @c false.
*
* Default implementation returns @c false.
*/
bool AbstractClient::isMaximizable() const
{
return false;
}
/**
* Returns the currently applied maximize mode.
*
* Default implementation returns MaximizeRestore.
*/
MaximizeMode AbstractClient::maximizeMode() const
{
return MaximizeRestore;
}
/**
* Returns the last requested maximize mode.
*
* On X11, this method always matches maximizeMode(). On Wayland, it is asynchronous.
*
* Default implementation matches maximizeMode().
*/
MaximizeMode AbstractClient::requestedMaximizeMode() const
{
return maximizeMode();
}
/**
* Returns the geometry of the AbstractClient before it was maximized or quick tiled.
*/
QRect AbstractClient::geometryRestore() const
{
return m_maximizeGeometryRestore;
}
/**
* Sets the geometry of the AbstractClient before it was maximized or quick tiled to @p rect.
*/
void AbstractClient::setGeometryRestore(const QRect &rect)
{
m_maximizeGeometryRestore = rect;
}
/**
* Toggles the maximized state along specified dimensions @p horizontal and @p vertical.
*
* If @p adjust is @c true, only frame geometry will be updated to match requestedMaximizeMode().
*
* Default implementation does nothing.
*/
void AbstractClient::changeMaximize(bool horizontal, bool vertical, bool adjust)
{
Q_UNUSED(horizontal)
Q_UNUSED(vertical)
Q_UNUSED(adjust)
qCWarning(KWIN_CORE, "%s doesn't support setting maximized state", metaObject()->className());
}
void AbstractClient::updateDecoration(bool check_workspace_pos, bool force)
{
Q_UNUSED(check_workspace_pos)
Q_UNUSED(force)
qCWarning(KWIN_CORE, "%s doesn't support server side decorations", metaObject()->className());
}
bool AbstractClient::noBorder() const
{
return true;
}
bool AbstractClient::userCanSetNoBorder() const
{
return false;
}
void AbstractClient::setNoBorder(bool set)
{
Q_UNUSED(set)
qCWarning(KWIN_CORE, "%s doesn't support setting decorations", metaObject()->className());
}
void AbstractClient::showOnScreenEdge()
{
qCWarning(KWIN_CORE, "%s doesn't support screen edge activation", metaObject()->className());
}
bool AbstractClient::isPlaceable() const
{
return true;
}
QRect AbstractClient::fullscreenGeometryRestore() const
{
return m_fullscreenGeometryRestore;
}
void AbstractClient::setFullscreenGeometryRestore(const QRect &geom)
{
m_fullscreenGeometryRestore = geom;
}
}