kwin/effects/glide/glide.cpp
Vlad Zagorodniy 984727ad93 [effects] Add plasmashell to the blacklist of Glide and Scale effect on Wayland
Summary: Do the same what we do on X11.

Reviewers: #kwin, davidedmundson

Reviewed By: #kwin, davidedmundson

Subscribers: kwin

Tags: #kwin

Differential Revision: https://phabricator.kde.org/D16271
2018-10-18 19:18:03 +03:00

332 lines
10 KiB
C++

/********************************************************************
KWin - the KDE window manager
This file is part of the KDE project.
Copyright (C) 2007 Philip Falkner <philip.falkner@gmail.com>
Copyright (C) 2009 Martin Gräßlin <mgraesslin@kde.org>
Copyright (C) 2010 Alexandre Pereira <pereira.alex@gmail.com>
Copyright (C) 2018 Vlad Zagorodniy <vladzzag@gmail.com>
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/>.
*********************************************************************/
// own
#include "glide.h"
// KConfigSkeleton
#include "glideconfig.h"
// Qt
#include <QMatrix4x4>
#include <QSet>
namespace KWin
{
static const QSet<QString> s_blacklist {
QStringLiteral("ksmserver ksmserver"),
QStringLiteral("ksmserver-logout-greeter ksmserver-logout-greeter"),
QStringLiteral("ksplashqml ksplashqml"),
QStringLiteral("ksplashsimple ksplashsimple"),
QStringLiteral("ksplashx ksplashx")
};
GlideEffect::GlideEffect()
{
initConfig<GlideConfig>();
reconfigure(ReconfigureAll);
connect(effects, &EffectsHandler::windowAdded, this, &GlideEffect::windowAdded);
connect(effects, &EffectsHandler::windowClosed, this, &GlideEffect::windowClosed);
connect(effects, &EffectsHandler::windowDeleted, this, &GlideEffect::windowDeleted);
connect(effects, &EffectsHandler::windowDataChanged, this, &GlideEffect::windowDataChanged);
}
GlideEffect::~GlideEffect() = default;
void GlideEffect::reconfigure(ReconfigureFlags flags)
{
Q_UNUSED(flags)
GlideConfig::self()->read();
m_duration = std::chrono::milliseconds(animationTime<GlideConfig>(160));
m_inParams.edge = static_cast<RotationEdge>(GlideConfig::inRotationEdge());
m_inParams.angle.from = GlideConfig::inRotationAngle();
m_inParams.angle.to = 0.0;
m_inParams.distance.from = GlideConfig::inDistance();
m_inParams.distance.to = 0.0;
m_inParams.opacity.from = GlideConfig::inOpacity();
m_inParams.opacity.to = 1.0;
m_outParams.edge = static_cast<RotationEdge>(GlideConfig::outRotationEdge());
m_outParams.angle.from = 0.0;
m_outParams.angle.to = GlideConfig::outRotationAngle();
m_outParams.distance.from = 0.0;
m_outParams.distance.to = GlideConfig::outDistance();
m_outParams.opacity.from = 1.0;
m_outParams.opacity.to = GlideConfig::outOpacity();
}
void GlideEffect::prePaintScreen(ScreenPrePaintData &data, int time)
{
const std::chrono::milliseconds delta(time);
auto animationIt = m_animations.begin();
while (animationIt != m_animations.end()) {
(*animationIt).update(delta);
++animationIt;
}
data.mask |= PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS;
effects->prePaintScreen(data, time);
}
void GlideEffect::prePaintWindow(EffectWindow *w, WindowPrePaintData &data, int time)
{
if (m_animations.contains(w)) {
data.setTransformed();
w->enablePainting(EffectWindow::PAINT_DISABLED_BY_DELETE);
}
effects->prePaintWindow(w, data, time);
}
void GlideEffect::paintWindow(EffectWindow *w, int mask, QRegion region, WindowPaintData &data)
{
auto animationIt = m_animations.constFind(w);
if (animationIt == m_animations.constEnd()) {
effects->paintWindow(w, mask, region, data);
return;
}
// Perspective projection distorts objects near edges
// of the viewport. This is critical because distortions
// near edges of the viewport are not desired with this effect.
// To fix this, the center of the window will be moved to the origin,
// after applying perspective projection, the center is moved back
// to its "original" projected position. Overall, this is how the window
// will be transformed:
// [move to the origin] -> [rotate] -> [translate] ->
// -> [perspective projection] -> [reverse "move to the origin"]
const QMatrix4x4 oldProjMatrix = data.screenProjectionMatrix();
const QRectF windowGeo = w->geometry();
const QVector3D invOffset = oldProjMatrix.map(QVector3D(windowGeo.center()));
QMatrix4x4 invOffsetMatrix;
invOffsetMatrix.translate(invOffset.x(), invOffset.y());
data.setProjectionMatrix(invOffsetMatrix * oldProjMatrix);
// Move the center of the window to the origin.
const QRectF screenGeo = effects->virtualScreenGeometry();
const QPointF offset = screenGeo.center() - windowGeo.center();
data.translate(offset.x(), offset.y());
const GlideParams params = w->isDeleted() ? m_outParams : m_inParams;
const qreal t = (*animationIt).value();
switch (params.edge) {
case RotationEdge::Top:
data.setRotationAxis(Qt::XAxis);
data.setRotationOrigin(QVector3D(0, 0, 0));
data.setRotationAngle(-interpolate(params.angle.from, params.angle.to, t));
break;
case RotationEdge::Right:
data.setRotationAxis(Qt::YAxis);
data.setRotationOrigin(QVector3D(w->width(), 0, 0));
data.setRotationAngle(-interpolate(params.angle.from, params.angle.to, t));
break;
case RotationEdge::Bottom:
data.setRotationAxis(Qt::XAxis);
data.setRotationOrigin(QVector3D(0, w->height(), 0));
data.setRotationAngle(interpolate(params.angle.from, params.angle.to, t));
break;
case RotationEdge::Left:
data.setRotationAxis(Qt::YAxis);
data.setRotationOrigin(QVector3D(0, 0, 0));
data.setRotationAngle(interpolate(params.angle.from, params.angle.to, t));
break;
default:
// Fallback to Top.
data.setRotationAxis(Qt::XAxis);
data.setRotationOrigin(QVector3D(0, 0, 0));
data.setRotationAngle(-interpolate(params.angle.from, params.angle.to, t));
break;
}
data.setZTranslation(-interpolate(params.distance.from, params.distance.to, t));
data.multiplyOpacity(interpolate(params.opacity.from, params.opacity.to, t));
effects->paintWindow(w, mask, region, data);
}
void GlideEffect::postPaintScreen()
{
auto animationIt = m_animations.begin();
while (animationIt != m_animations.end()) {
if ((*animationIt).done()) {
EffectWindow *w = animationIt.key();
if (w->isDeleted()) {
w->unrefWindow();
}
animationIt = m_animations.erase(animationIt);
} else {
++animationIt;
}
}
effects->addRepaintFull();
effects->postPaintScreen();
}
bool GlideEffect::isActive() const
{
return !m_animations.isEmpty();
}
bool GlideEffect::supported()
{
return effects->isOpenGLCompositing()
&& effects->animationsSupported();
}
void GlideEffect::windowAdded(EffectWindow *w)
{
if (effects->activeFullScreenEffect()) {
return;
}
if (!isGlideWindow(w)) {
return;
}
if (!w->isVisible()) {
return;
}
const void *addGrab = w->data(WindowAddedGrabRole).value<void*>();
if (addGrab && addGrab != this) {
return;
}
w->setData(WindowAddedGrabRole, QVariant::fromValue(static_cast<void*>(this)));
TimeLine &timeLine = m_animations[w];
timeLine.reset();
timeLine.setDirection(TimeLine::Forward);
timeLine.setDuration(m_duration);
timeLine.setEasingCurve(QEasingCurve::InCurve);
effects->addRepaintFull();
}
void GlideEffect::windowClosed(EffectWindow *w)
{
if (effects->activeFullScreenEffect()) {
return;
}
if (!isGlideWindow(w)) {
return;
}
if (!w->isVisible()) {
return;
}
const void *closeGrab = w->data(WindowClosedGrabRole).value<void*>();
if (closeGrab && closeGrab != this) {
return;
}
w->refWindow();
w->setData(WindowClosedGrabRole, QVariant::fromValue(static_cast<void*>(this)));
TimeLine &timeLine = m_animations[w];
timeLine.reset();
timeLine.setDirection(TimeLine::Forward);
timeLine.setDuration(m_duration);
timeLine.setEasingCurve(QEasingCurve::OutCurve);
effects->addRepaintFull();
}
void GlideEffect::windowDeleted(EffectWindow *w)
{
m_animations.remove(w);
}
void GlideEffect::windowDataChanged(EffectWindow *w, int role)
{
if (role != WindowAddedGrabRole && role != WindowClosedGrabRole) {
return;
}
if (w->data(role).value<void*>() == this) {
return;
}
auto animationIt = m_animations.find(w);
if (animationIt == m_animations.end()) {
return;
}
if (w->isDeleted() && role == WindowClosedGrabRole) {
w->unrefWindow();
}
m_animations.erase(animationIt);
}
bool GlideEffect::isGlideWindow(EffectWindow *w) const
{
// We don't want to animate most of plasmashell's windows, yet, some
// of them we want to, for example, Task Manager Settings window.
// The problem is that all those window share single window class.
// So, the only way to decide whether a window should be animated is
// to use a heuristic: if a window has decoration, then it's most
// likely a dialog or a settings window so we have to animate it.
if (w->windowClass() == QLatin1String("plasmashell plasmashell")
|| w->windowClass() == QLatin1String("plasmashell org.kde.plasmashell")) {
return w->hasDecoration();
}
if (s_blacklist.contains(w->windowClass())) {
return false;
}
if (w->hasDecoration()) {
return true;
}
// Don't animate combobox popups, tooltips, popup menus, etc.
if (w->isPopupWindow()) {
return false;
}
// Override-redirect windows are usually used for user interface
// concepts that are not expected to be animated by this effect.
if (w->isX11Client() && !w->isManaged()) {
return false;
}
return w->isNormalWindow()
|| w->isDialog();
}
} // namespace KWin