621b2e1cde
Even though the frame geometry and the client geometry have a connection between themselves, it doesn't mean that the frame geometry will change if the client geometry has changed and vice versa. For example, it can be the case when the border size changes. The frame geometry won't change, but the client geometry will. In general, similar to the frameGeometryChanged signal, we need another signal that is emitted when the client geometry has been changed that can be used then in DecoratedClientImpl. Unfortunately, 5.19 release is around the corner and I would prefer not to do any geometry-related changes in order to avoid introducing new regressions. In order to fix the propagation of the client size to decorations, this change ports DecoratedClientImpl from frameGeometryChanged to a signal that is emitted whenever geometry of any kind has been changed. BUG: 419080 FIXED-IN: 5.19.0
346 lines
11 KiB
C++
346 lines
11 KiB
C++
/********************************************************************
|
|
KWin - the KDE window manager
|
|
This file is part of the KDE project.
|
|
|
|
Copyright (C) 2014 Martin Gräßlin <mgraesslin@kde.org>
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*********************************************************************/
|
|
#include "decoratedclient.h"
|
|
#include "decorationbridge.h"
|
|
#include "decorationpalette.h"
|
|
#include "decorationrenderer.h"
|
|
#include "abstract_client.h"
|
|
#include "composite.h"
|
|
#include "cursor.h"
|
|
#include "options.h"
|
|
#include "platform.h"
|
|
#include "workspace.h"
|
|
|
|
#include <KDecoration2/DecoratedClient>
|
|
#include <KDecoration2/Decoration>
|
|
|
|
#include <QDebug>
|
|
#include <QStyle>
|
|
#include <QToolTip>
|
|
|
|
namespace KWin
|
|
{
|
|
namespace Decoration
|
|
{
|
|
|
|
DecoratedClientImpl::DecoratedClientImpl(AbstractClient *client, KDecoration2::DecoratedClient *decoratedClient, KDecoration2::Decoration *decoration)
|
|
: QObject()
|
|
, ApplicationMenuEnabledDecoratedClientPrivate(decoratedClient, decoration)
|
|
, m_client(client)
|
|
, m_clientSize(client->clientSize())
|
|
, m_renderer(nullptr)
|
|
{
|
|
createRenderer();
|
|
client->setDecoratedClient(QPointer<DecoratedClientImpl>(this));
|
|
connect(client, &AbstractClient::activeChanged, this,
|
|
[decoratedClient, client]() {
|
|
emit decoratedClient->activeChanged(client->isActive());
|
|
}
|
|
);
|
|
connect(client, &AbstractClient::geometryShapeChanged, this,
|
|
[decoratedClient, this]() {
|
|
if (m_client->clientSize() == m_clientSize) {
|
|
return;
|
|
}
|
|
const auto oldSize = m_clientSize;
|
|
m_clientSize = m_client->clientSize();
|
|
if (oldSize.width() != m_clientSize.width()) {
|
|
emit decoratedClient->widthChanged(m_clientSize.width());
|
|
}
|
|
if (oldSize.height() != m_clientSize.height()) {
|
|
emit decoratedClient->heightChanged(m_clientSize.height());
|
|
}
|
|
emit decoratedClient->sizeChanged(m_clientSize);
|
|
}
|
|
);
|
|
connect(client, &AbstractClient::desktopChanged, this,
|
|
[decoratedClient, client]() {
|
|
emit decoratedClient->onAllDesktopsChanged(client->isOnAllDesktops());
|
|
}
|
|
);
|
|
connect(client, &AbstractClient::captionChanged, this,
|
|
[decoratedClient, client]() {
|
|
emit decoratedClient->captionChanged(client->caption());
|
|
}
|
|
);
|
|
connect(client, &AbstractClient::iconChanged, this,
|
|
[decoratedClient, client]() {
|
|
emit decoratedClient->iconChanged(client->icon());
|
|
}
|
|
);
|
|
connect(client, &AbstractClient::shadeChanged, this,
|
|
&Decoration::DecoratedClientImpl::signalShadeChange);
|
|
connect(client, &AbstractClient::keepAboveChanged, decoratedClient, &KDecoration2::DecoratedClient::keepAboveChanged);
|
|
connect(client, &AbstractClient::keepBelowChanged, decoratedClient, &KDecoration2::DecoratedClient::keepBelowChanged);
|
|
connect(Compositor::self(), &Compositor::aboutToToggleCompositing, this, &DecoratedClientImpl::destroyRenderer);
|
|
m_compositorToggledConnection = connect(Compositor::self(), &Compositor::compositingToggled, this,
|
|
[this, decoration]() {
|
|
createRenderer();
|
|
decoration->update();
|
|
}
|
|
);
|
|
connect(Compositor::self(), &Compositor::aboutToDestroy, this,
|
|
[this] {
|
|
disconnect(m_compositorToggledConnection);
|
|
m_compositorToggledConnection = QMetaObject::Connection();
|
|
}
|
|
);
|
|
connect(client, &AbstractClient::quickTileModeChanged, decoratedClient,
|
|
[this, decoratedClient]() {
|
|
emit decoratedClient->adjacentScreenEdgesChanged(adjacentScreenEdges());
|
|
}
|
|
);
|
|
connect(client, &AbstractClient::closeableChanged, decoratedClient, &KDecoration2::DecoratedClient::closeableChanged);
|
|
connect(client, &AbstractClient::shadeableChanged, decoratedClient, &KDecoration2::DecoratedClient::shadeableChanged);
|
|
connect(client, &AbstractClient::minimizeableChanged, decoratedClient, &KDecoration2::DecoratedClient::minimizeableChanged);
|
|
connect(client, &AbstractClient::maximizeableChanged, decoratedClient, &KDecoration2::DecoratedClient::maximizeableChanged);
|
|
|
|
connect(client, &AbstractClient::paletteChanged, decoratedClient, &KDecoration2::DecoratedClient::paletteChanged);
|
|
|
|
connect(client, &AbstractClient::hasApplicationMenuChanged, decoratedClient, &KDecoration2::DecoratedClient::hasApplicationMenuChanged);
|
|
connect(client, &AbstractClient::applicationMenuActiveChanged, decoratedClient, &KDecoration2::DecoratedClient::applicationMenuActiveChanged);
|
|
|
|
m_toolTipWakeUp.setSingleShot(true);
|
|
connect(&m_toolTipWakeUp, &QTimer::timeout, this,
|
|
[this]() {
|
|
int fallAsleepDelay = QApplication::style()->styleHint(QStyle::SH_ToolTip_FallAsleepDelay);
|
|
this->m_toolTipFallAsleep.setRemainingTime(fallAsleepDelay);
|
|
|
|
QToolTip::showText(Cursors::self()->mouse()->pos(), this->m_toolTipText);
|
|
m_toolTipShowing = true;
|
|
}
|
|
);
|
|
}
|
|
|
|
DecoratedClientImpl::~DecoratedClientImpl()
|
|
{
|
|
if (m_toolTipShowing) {
|
|
requestHideToolTip();
|
|
}
|
|
}
|
|
|
|
void DecoratedClientImpl::signalShadeChange() {
|
|
emit decoratedClient()->shadedChanged(m_client->isShade());
|
|
}
|
|
|
|
#define DELEGATE(type, name, clientName) \
|
|
type DecoratedClientImpl::name() const \
|
|
{ \
|
|
return m_client->clientName(); \
|
|
}
|
|
|
|
#define DELEGATE2(type, name) DELEGATE(type, name, name)
|
|
|
|
DELEGATE2(QString, caption)
|
|
DELEGATE2(bool, isActive)
|
|
DELEGATE2(bool, isCloseable)
|
|
DELEGATE(bool, isMaximizeable, isMaximizable)
|
|
DELEGATE(bool, isMinimizeable, isMinimizable)
|
|
DELEGATE2(bool, isModal)
|
|
DELEGATE(bool, isMoveable, isMovable)
|
|
DELEGATE(bool, isResizeable, isResizable)
|
|
DELEGATE2(bool, isShadeable)
|
|
DELEGATE2(bool, providesContextHelp)
|
|
DELEGATE2(int, desktop)
|
|
DELEGATE2(bool, isOnAllDesktops)
|
|
DELEGATE2(QPalette, palette)
|
|
DELEGATE2(QIcon, icon)
|
|
|
|
#undef DELEGATE2
|
|
#undef DELEGATE
|
|
|
|
#define DELEGATE(type, name, clientName) \
|
|
type DecoratedClientImpl::name() const \
|
|
{ \
|
|
return m_client->clientName(); \
|
|
}
|
|
|
|
DELEGATE(bool, isKeepAbove, keepAbove)
|
|
DELEGATE(bool, isKeepBelow, keepBelow)
|
|
DELEGATE(bool, isShaded, isShade)
|
|
DELEGATE(WId, windowId, windowId)
|
|
DELEGATE(WId, decorationId, frameId)
|
|
|
|
#undef DELEGATE
|
|
|
|
#define DELEGATE(name, op) \
|
|
void DecoratedClientImpl::name() \
|
|
{ \
|
|
Workspace::self()->performWindowOperation(m_client, Options::op); \
|
|
}
|
|
|
|
DELEGATE(requestToggleShade, ShadeOp)
|
|
DELEGATE(requestToggleOnAllDesktops, OnAllDesktopsOp)
|
|
DELEGATE(requestToggleKeepAbove, KeepAboveOp)
|
|
DELEGATE(requestToggleKeepBelow, KeepBelowOp)
|
|
|
|
#undef DELEGATE
|
|
|
|
#define DELEGATE(name, clientName) \
|
|
void DecoratedClientImpl::name() \
|
|
{ \
|
|
m_client->clientName(); \
|
|
}
|
|
|
|
DELEGATE(requestContextHelp, showContextHelp)
|
|
DELEGATE(requestMinimize, minimize)
|
|
|
|
#undef DELEGATE
|
|
|
|
void DecoratedClientImpl::requestClose()
|
|
{
|
|
QMetaObject::invokeMethod(m_client, "closeWindow", Qt::QueuedConnection);
|
|
}
|
|
|
|
QColor DecoratedClientImpl::color(KDecoration2::ColorGroup group, KDecoration2::ColorRole role) const
|
|
{
|
|
auto dp = m_client->decorationPalette();
|
|
if (dp) {
|
|
return dp->color(group, role);
|
|
}
|
|
|
|
return QColor();
|
|
}
|
|
|
|
void DecoratedClientImpl::requestShowToolTip(const QString &text)
|
|
{
|
|
if (!DecorationBridge::self()->showToolTips()) {
|
|
return;
|
|
}
|
|
|
|
m_toolTipText = text;
|
|
|
|
int wakeUpDelay = QApplication::style()->styleHint(QStyle::SH_ToolTip_WakeUpDelay);
|
|
m_toolTipWakeUp.start(m_toolTipFallAsleep.hasExpired() ? wakeUpDelay : 20);
|
|
}
|
|
|
|
void DecoratedClientImpl::requestHideToolTip()
|
|
{
|
|
m_toolTipWakeUp.stop();
|
|
QToolTip::hideText();
|
|
m_toolTipShowing = false;
|
|
}
|
|
|
|
void DecoratedClientImpl::requestShowWindowMenu()
|
|
{
|
|
// TODO: add rect to requestShowWindowMenu
|
|
Workspace::self()->showWindowMenu(QRect(Cursors::self()->mouse()->pos(), Cursors::self()->mouse()->pos()), m_client);
|
|
}
|
|
|
|
void DecoratedClientImpl::requestShowApplicationMenu(const QRect &rect, int actionId)
|
|
{
|
|
Workspace::self()->showApplicationMenu(rect, m_client, actionId);
|
|
}
|
|
|
|
void DecoratedClientImpl::showApplicationMenu(int actionId)
|
|
{
|
|
decoration()->showApplicationMenu(actionId);
|
|
}
|
|
|
|
void DecoratedClientImpl::requestToggleMaximization(Qt::MouseButtons buttons)
|
|
{
|
|
QMetaObject::invokeMethod(this, "delayedRequestToggleMaximization", Qt::QueuedConnection, Q_ARG(Options::WindowOperation, options->operationMaxButtonClick(buttons)));
|
|
}
|
|
|
|
void DecoratedClientImpl::delayedRequestToggleMaximization(Options::WindowOperation operation)
|
|
{
|
|
Workspace::self()->performWindowOperation(m_client, operation);
|
|
}
|
|
|
|
int DecoratedClientImpl::width() const
|
|
{
|
|
return m_clientSize.width();
|
|
}
|
|
|
|
int DecoratedClientImpl::height() const
|
|
{
|
|
return m_clientSize.height();
|
|
}
|
|
|
|
QSize DecoratedClientImpl::size() const
|
|
{
|
|
return m_clientSize;
|
|
}
|
|
|
|
bool DecoratedClientImpl::isMaximizedVertically() const
|
|
{
|
|
return m_client->requestedMaximizeMode() & MaximizeVertical;
|
|
}
|
|
|
|
bool DecoratedClientImpl::isMaximized() const
|
|
{
|
|
return isMaximizedHorizontally() && isMaximizedVertically();
|
|
}
|
|
|
|
bool DecoratedClientImpl::isMaximizedHorizontally() const
|
|
{
|
|
return m_client->requestedMaximizeMode() & MaximizeHorizontal;
|
|
}
|
|
|
|
Qt::Edges DecoratedClientImpl::adjacentScreenEdges() const
|
|
{
|
|
Qt::Edges edges;
|
|
const QuickTileMode mode = m_client->quickTileMode();
|
|
if (mode.testFlag(QuickTileFlag::Left)) {
|
|
edges |= Qt::LeftEdge;
|
|
if (!mode.testFlag(QuickTileFlag::Top) && !mode.testFlag(QuickTileFlag::Bottom)) {
|
|
// using complete side
|
|
edges |= Qt::TopEdge | Qt::BottomEdge;
|
|
}
|
|
}
|
|
if (mode.testFlag(QuickTileFlag::Top)) {
|
|
edges |= Qt::TopEdge;
|
|
}
|
|
if (mode.testFlag(QuickTileFlag::Right)) {
|
|
edges |= Qt::RightEdge;
|
|
if (!mode.testFlag(QuickTileFlag::Top) && !mode.testFlag(QuickTileFlag::Bottom)) {
|
|
// using complete side
|
|
edges |= Qt::TopEdge | Qt::BottomEdge;
|
|
}
|
|
}
|
|
if (mode.testFlag(QuickTileFlag::Bottom)) {
|
|
edges |= Qt::BottomEdge;
|
|
}
|
|
return edges;
|
|
}
|
|
|
|
bool DecoratedClientImpl::hasApplicationMenu() const
|
|
{
|
|
return m_client->hasApplicationMenu();
|
|
}
|
|
|
|
bool DecoratedClientImpl::isApplicationMenuActive() const
|
|
{
|
|
return m_client->applicationMenuActive();
|
|
}
|
|
|
|
void DecoratedClientImpl::createRenderer()
|
|
{
|
|
m_renderer = kwinApp()->platform()->createDecorationRenderer(this);
|
|
}
|
|
|
|
void DecoratedClientImpl::destroyRenderer()
|
|
{
|
|
delete m_renderer;
|
|
m_renderer = nullptr;
|
|
}
|
|
|
|
}
|
|
}
|