yukijoou/kwin
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
kwin/effects/flipswitch/flipswitch.cpp
Martin Gräßlin 142aab2e24 Introduce an EffectsHandler::animationsSupported -> bool 
Summary:
A new method to tell the effects system whether the compositor scene
is able to drive animations. E.g. on software emulation (llvmpipe) it's
better to not do any animations at all.

This information can be used by effects to adjust their behavior, e.g.
PresentWindows could skip transitions or effects can use it in their
supported check to completely disable themselves.

As a first step all scripted effects are considered to be unsupported
if animations are not supported. They inherit AnimationEffect and are
all about driving animations.

The information whether animations are supported comes from the Scene.
It's implemented in the following way:
 * XRender: animations are always supported
 * QPainter: animations are never supported
 * OpenGL: animations are supported, except for software emulation

In addition - for easier testing - there is a new env variable
KWIN_EFFECTS_FORCE_ANIMATIONS to overwrite the selection.

Reviewers: #kwin, #plasma

Subscribers: kwin

Tags: #kwin

Differential Revision: https://phabricator.kde.org/D2386
2016-08-15 17:38:33 +02:00

987 lines
38 KiB
C++
Raw Blame History

/********************************************************************
KWin - the KDE window manager
This file is part of the KDE project.
Copyright (C) 2008, 2009 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 "flipswitch.h"
// KConfigSkeleton
#include "flipswitchconfig.h"
#include <QAction>
#include <kwinconfig.h>
#include <QFont>
#include <QKeyEvent>
#include <QMatrix4x4>
#include <QAction>
#include <KGlobalAccel>
#include <KLocalizedString>
#include <kwinglutils.h>
#include <cmath>
namespace KWin
{
FlipSwitchEffect::FlipSwitchEffect()
: m_currentAnimationShape(QTimeLine::EaseInOutCurve)
, m_active(false)
, m_start(false)
, m_stop(false)
, m_animation(false)
, m_hasKeyboardGrab(false)
, m_captionFrame(NULL)
{
reconfigure(ReconfigureAll);
// Caption frame
m_captionFont.setBold(true);
m_captionFont.setPointSize(m_captionFont.pointSize() * 2);
QAction* flipSwitchCurrentAction = new QAction(this);
flipSwitchCurrentAction->setObjectName(QStringLiteral("FlipSwitchCurrent"));
flipSwitchCurrentAction->setText(i18n("Toggle Flip Switch (Current desktop)"));
KGlobalAccel::self()->setShortcut(flipSwitchCurrentAction, QList<QKeySequence>());
m_shortcutCurrent = KGlobalAccel::self()->shortcut(flipSwitchCurrentAction);
effects->registerGlobalShortcut(QKeySequence(), flipSwitchCurrentAction);
connect(flipSwitchCurrentAction, SIGNAL(triggered(bool)), this, SLOT(toggleActiveCurrent()));
QAction* flipSwitchAllAction = new QAction(this);
flipSwitchAllAction->setObjectName(QStringLiteral("FlipSwitchAll"));
flipSwitchAllAction->setText(i18n("Toggle Flip Switch (All desktops)"));
KGlobalAccel::self()->setShortcut(flipSwitchAllAction, QList<QKeySequence>());
effects->registerGlobalShortcut(QKeySequence(), flipSwitchAllAction);
m_shortcutAll = KGlobalAccel::self()->shortcut(flipSwitchAllAction);
connect(flipSwitchAllAction, SIGNAL(triggered(bool)), this, SLOT(toggleActiveAllDesktops()));
connect(KGlobalAccel::self(), &KGlobalAccel::globalShortcutChanged, this, &FlipSwitchEffect::globalShortcutChanged);
connect(effects, SIGNAL(windowAdded(KWin::EffectWindow*)), this, SLOT(slotWindowAdded(KWin::EffectWindow*)));
connect(effects, SIGNAL(windowClosed(KWin::EffectWindow*)), this, SLOT(slotWindowClosed(KWin::EffectWindow*)));
connect(effects, SIGNAL(tabBoxAdded(int)), this, SLOT(slotTabBoxAdded(int)));
connect(effects, SIGNAL(tabBoxClosed()), this, SLOT(slotTabBoxClosed()));
connect(effects, SIGNAL(tabBoxUpdated()), this, SLOT(slotTabBoxUpdated()));
connect(effects, SIGNAL(tabBoxKeyEvent(QKeyEvent*)), this, SLOT(slotTabBoxKeyEvent(QKeyEvent*)));
}
FlipSwitchEffect::~FlipSwitchEffect()
{
delete m_captionFrame;
}
bool FlipSwitchEffect::supported()
{
return effects->isOpenGLCompositing() && effects->animationsSupported();
}
void FlipSwitchEffect::reconfigure(ReconfigureFlags)
{
FlipSwitchConfig::self()->read();
m_tabbox = FlipSwitchConfig::tabBox();
m_tabboxAlternative = FlipSwitchConfig::tabBoxAlternative();
const int duration = animationTime<FlipSwitchConfig>(200);
m_timeLine.setDuration(duration);
m_startStopTimeLine.setDuration(duration);
m_angle = FlipSwitchConfig::angle();
m_xPosition = FlipSwitchConfig::xPosition() / 100.0f;
m_yPosition = FlipSwitchConfig::yPosition() / 100.0f;
m_windowTitle = FlipSwitchConfig::windowTitle();
}
void FlipSwitchEffect::prePaintScreen(ScreenPrePaintData& data, int time)
{
if (m_active) {
data.mask |= PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS;
if (m_start)
m_startStopTimeLine.setCurrentTime(m_startStopTimeLine.currentTime() + time);
if (m_stop && m_scheduledDirections.isEmpty())
m_startStopTimeLine.setCurrentTime(m_startStopTimeLine.currentTime() - time);
if (m_animation)
m_timeLine.setCurrentTime(m_timeLine.currentTime() + time);
}
effects->prePaintScreen(data, time);
}
void FlipSwitchEffect::paintScreen(int mask, QRegion region, ScreenPaintData& data)
{
effects->paintScreen(mask, region, data);
if (m_active) {
EffectWindowList tempList;
if (m_mode == TabboxMode)
tempList = effects->currentTabBoxWindowList();
else {
// we have to setup the list
// using stacking order directly is not possible
// as not each window in stacking order is shown
// TODO: store list instead of calculating in each frame?
foreach (EffectWindow * w, effects->stackingOrder()) {
if (m_windows.contains(w))
tempList.append(w);
}
}
m_flipOrderedWindows.clear();
int index = tempList.indexOf(m_selectedWindow);
int tabIndex = index;
if (m_mode == TabboxMode) {
foreach (SwitchingDirection direction, m_scheduledDirections) { // krazy:exclude=foreach
if (direction == DirectionBackward)
index++;
else
index--;
if (index < 0)
index = tempList.count() + index;
if (index >= tempList.count())
index = index % tempList.count();
}
tabIndex = index;
EffectWindow* w = NULL;
if (!m_scheduledDirections.isEmpty() && m_scheduledDirections.head() == DirectionBackward) {
index--;
if (index < 0)
index = tempList.count() + index;
w = tempList.at(index);
}
for (int i = index - 1; i >= 0; i--)
m_flipOrderedWindows.append(tempList.at(i));
for (int i = effects->currentTabBoxWindowList().count() - 1; i >= index; i--)
m_flipOrderedWindows.append(tempList.at(i));
if (w) {
m_flipOrderedWindows.removeAll(w);
m_flipOrderedWindows.append(w);
}
} else {
foreach (SwitchingDirection direction, m_scheduledDirections) { // krazy:exclude=foreach
if (direction == DirectionForward)
index++;
else
index--;
if (index < 0)
index = tempList.count() - 1;
if (index >= tempList.count())
index = 0;
}
tabIndex = index;
EffectWindow* w = NULL;
if (!m_scheduledDirections.isEmpty() && m_scheduledDirections.head() == DirectionBackward) {
index++;
if (index >= tempList.count())
index = 0;
}
// sort from stacking order
for (int i = index + 1; i < tempList.count(); i++)
m_flipOrderedWindows.append(tempList.at(i));
for (int i = 0; i <= index; i++)
m_flipOrderedWindows.append(tempList.at(i));
if (w) {
m_flipOrderedWindows.removeAll(w);
m_flipOrderedWindows.append(w);
}
}
int winMask = PAINT_WINDOW_TRANSFORMED | PAINT_WINDOW_TRANSLUCENT;
// fade in/out one window at the end of the stack during animation
if (m_animation && !m_scheduledDirections.isEmpty()) {
EffectWindow* w = m_flipOrderedWindows.last();
if (ItemInfo *info = m_windows.value(w,0)) {
WindowPaintData data(w);
if (effects->numScreens() > 1) {
data.setProjectionMatrix(m_projectionMatrix);
data.setModelViewMatrix(m_modelviewMatrix);
}
data.setRotationAxis(Qt::YAxis);
data.setRotationAngle(m_angle * m_startStopTimeLine.currentValue());
data.setOpacity(info->opacity);
data.setBrightness(info->brightness);
data.setSaturation(info->saturation);
int distance = tempList.count() - 1;
float zDistance = 500.0f;
data.translate(- (w->x() - m_screenArea.x() + data.xTranslation()) * m_startStopTimeLine.currentValue());
data.translate(m_screenArea.width() * m_xPosition * m_startStopTimeLine.currentValue(),
(m_screenArea.y() + m_screenArea.height() * m_yPosition - (w->y() + w->height() + data.yTranslation())) * m_startStopTimeLine.currentValue());
data.translate(- (m_screenArea.width() * 0.25f) * distance * m_startStopTimeLine.currentValue(),
- (m_screenArea.height() * 0.10f) * distance * m_startStopTimeLine.currentValue(),
- (zDistance * distance) * m_startStopTimeLine.currentValue());
if (m_scheduledDirections.head() == DirectionForward)
data.multiplyOpacity(0.8 * m_timeLine.currentValue());
else
data.multiplyOpacity(0.8 * (1.0 - m_timeLine.currentValue()));
if (effects->numScreens() > 1) {
adjustWindowMultiScreen(w, data);
}
effects->drawWindow(w, winMask, infiniteRegion(), data);
}
}
foreach (EffectWindow *w, m_flipOrderedWindows) {
ItemInfo *info = m_windows.value(w,0);
if (!info)
continue;
WindowPaintData data(w);
if (effects->numScreens() > 1) {
data.setProjectionMatrix(m_projectionMatrix);
data.setModelViewMatrix(m_modelviewMatrix);
}
data.setRotationAxis(Qt::YAxis);
data.setRotationAngle(m_angle * m_startStopTimeLine.currentValue());
data.setOpacity(info->opacity);
data.setBrightness(info->brightness);
data.setSaturation(info->saturation);
int windowIndex = tempList.indexOf(w);
int distance;
if (m_mode == TabboxMode) {
if (windowIndex < tabIndex)
distance = tempList.count() - (tabIndex - windowIndex);
else if (windowIndex > tabIndex)
distance = windowIndex - tabIndex;
else
distance = 0;
} else {
distance = m_flipOrderedWindows.count() - m_flipOrderedWindows.indexOf(w) - 1;
if (!m_scheduledDirections.isEmpty() && m_scheduledDirections.head() == DirectionBackward) {
distance--;
}
}
if (!m_scheduledDirections.isEmpty() && m_scheduledDirections.head() == DirectionBackward) {
if (w == m_flipOrderedWindows.last()) {
distance = -1;
data.multiplyOpacity(m_timeLine.currentValue());
}
}
float zDistance = 500.0f;
data.translate(- (w->x() - m_screenArea.x() + data.xTranslation()) * m_startStopTimeLine.currentValue());
data.translate(m_screenArea.width() * m_xPosition * m_startStopTimeLine.currentValue(),
(m_screenArea.y() + m_screenArea.height() * m_yPosition - (w->y() + w->height() + data.yTranslation())) * m_startStopTimeLine.currentValue());
data.translate(-(m_screenArea.width() * 0.25f) * distance * m_startStopTimeLine.currentValue(),
-(m_screenArea.height() * 0.10f) * distance * m_startStopTimeLine.currentValue(),
-(zDistance * distance) * m_startStopTimeLine.currentValue());
if (m_animation && !m_scheduledDirections.isEmpty()) {
if (m_scheduledDirections.head() == DirectionForward) {
data.translate((m_screenArea.width() * 0.25f) * m_timeLine.currentValue(),
(m_screenArea.height() * 0.10f) * m_timeLine.currentValue(),
zDistance * m_timeLine.currentValue());
if (distance == 0)
data.multiplyOpacity((1.0 - m_timeLine.currentValue()));
} else {
data.translate(- (m_screenArea.width() * 0.25f) * m_timeLine.currentValue(),
- (m_screenArea.height() * 0.10f) * m_timeLine.currentValue(),
- zDistance * m_timeLine.currentValue());
}
}
data.multiplyOpacity((0.8 + 0.2 * (1.0 - m_startStopTimeLine.currentValue())));
if (effects->numScreens() > 1) {
adjustWindowMultiScreen(w, data);
}
effects->drawWindow(w, winMask, infiniteRegion(), data);
}
if (m_windowTitle) {
// Render the caption frame
if (m_animation) {
m_captionFrame->setCrossFadeProgress(m_timeLine.currentValue());
}
m_captionFrame->render(region, m_startStopTimeLine.currentValue());
}
}
}
void FlipSwitchEffect::postPaintScreen()
{
if (m_active) {
if (m_start && m_startStopTimeLine.currentValue() == 1.0f) {
m_start = false;
if (!m_scheduledDirections.isEmpty()) {
m_animation = true;
m_timeLine.setCurrentTime(0);
if (m_scheduledDirections.count() == 1) {
m_currentAnimationShape = QTimeLine::EaseOutCurve;
m_timeLine.setCurveShape(m_currentAnimationShape);
} else {
m_currentAnimationShape = QTimeLine::LinearCurve;
m_timeLine.setCurveShape(m_currentAnimationShape);
}
}
effects->addRepaintFull();
}
if (m_stop && m_startStopTimeLine.currentValue() == 0.0f) {
m_stop = false;
m_active = false;
m_captionFrame->free();
effects->setActiveFullScreenEffect(0);
effects->addRepaintFull();
qDeleteAll(m_windows);
m_windows.clear();
}
if (m_animation && m_timeLine.currentValue() == 1.0f) {
m_timeLine.setCurrentTime(0);
m_scheduledDirections.dequeue();
if (m_scheduledDirections.isEmpty()) {
m_animation = false;
effects->addRepaintFull();
} else {
if (m_scheduledDirections.count() == 1) {
if (m_stop)
m_currentAnimationShape = QTimeLine::LinearCurve;
else
m_currentAnimationShape = QTimeLine::EaseOutCurve;
} else {
m_currentAnimationShape = QTimeLine::LinearCurve;
}
m_timeLine.setCurveShape(m_currentAnimationShape);
}
}
if (m_start || m_stop || m_animation)
effects->addRepaintFull();
}
effects->postPaintScreen();
}
void FlipSwitchEffect::prePaintWindow(EffectWindow* w, WindowPrePaintData& data, int time)
{
if (m_active) {
if (m_windows.contains(w)) {
data.setTransformed();
data.setTranslucent();
if (!w->isOnCurrentDesktop())
w->enablePainting(EffectWindow::PAINT_DISABLED_BY_DESKTOP);
if (w->isMinimized())
w->enablePainting(EffectWindow::PAINT_DISABLED_BY_MINIMIZE);
if (!w->isCurrentTab())
w->enablePainting(EffectWindow::PAINT_DISABLED_BY_TAB_GROUP);
} else {
if ((m_start || m_stop) && !w->isDesktop() && w->isOnCurrentDesktop())
data.setTranslucent();
else if (!w->isDesktop())
w->disablePainting(EffectWindow::PAINT_DISABLED_BY_DESKTOP);
}
}
effects->prePaintWindow(w, data, time);
}
void FlipSwitchEffect::paintWindow(EffectWindow* w, int mask, QRegion region, WindowPaintData& data)
{
if (m_active) {
ItemInfo *info = m_windows.value(w,0);
if (info) {
info->opacity = data.opacity();
info->brightness = data.brightness();
info->saturation = data.saturation();
}
// fade out all windows not in window list except the desktops
const bool isFader = (m_start || m_stop) && !info && !w->isDesktop();
if (isFader)
data.multiplyOpacity((1.0 - m_startStopTimeLine.currentValue()));
// if not a fader or the desktop, skip painting here to prevent flicker
if (!(isFader || w->isDesktop()))
return;
}
effects->paintWindow(w, mask, region, data);
}
//*************************************************************
// Tabbox handling
//*************************************************************
void FlipSwitchEffect::slotTabBoxAdded(int mode)
{
if (effects->activeFullScreenEffect() && effects->activeFullScreenEffect() != this)
return;
// only for windows mode
effects->setShowingDesktop(false);
if (((mode == TabBoxWindowsMode && m_tabbox) ||
(mode == TabBoxWindowsAlternativeMode && m_tabboxAlternative) ||
(mode == TabBoxCurrentAppWindowsMode && m_tabbox) ||
(mode == TabBoxCurrentAppWindowsAlternativeMode && m_tabboxAlternative))
&& (!m_active || (m_active && m_stop))
&& !effects->currentTabBoxWindowList().isEmpty()) {
setActive(true, TabboxMode);
if (m_active)
effects->refTabBox();
}
}
void FlipSwitchEffect::slotTabBoxClosed()
{
if (m_active) {
setActive(false, TabboxMode);
effects->unrefTabBox();
}
}
void FlipSwitchEffect::slotTabBoxUpdated()
{
if (m_active && !m_stop) {
if (!effects->currentTabBoxWindowList().isEmpty()) {
// determine the switch direction
if (m_selectedWindow != effects->currentTabBoxWindow()) {
if (m_selectedWindow != NULL) {
int old_index = effects->currentTabBoxWindowList().indexOf(m_selectedWindow);
int new_index = effects->currentTabBoxWindowList().indexOf(effects->currentTabBoxWindow());
SwitchingDirection new_direction;
int distance = new_index - old_index;
if (distance > 0)
new_direction = DirectionForward;
if (distance < 0)
new_direction = DirectionBackward;
if (effects->currentTabBoxWindowList().count() == 2) {
new_direction = DirectionForward;
distance = 1;
}
if (distance != 0) {
distance = abs(distance);
int tempDistance = effects->currentTabBoxWindowList().count() - distance;
if (tempDistance < abs(distance)) {
distance = tempDistance;
if (new_direction == DirectionForward)
new_direction = DirectionBackward;
else
new_direction = DirectionForward;
}
scheduleAnimation(new_direction, distance);
}
}
m_selectedWindow = effects->currentTabBoxWindow();
updateCaption();
}
}
effects->addRepaintFull();
}
}
//*************************************************************
// Window adding/removing handling
//*************************************************************
void FlipSwitchEffect::slotWindowAdded(EffectWindow* w)
{
if (m_active && isSelectableWindow(w)) {
m_windows[ w ] = new ItemInfo;
}
}
void FlipSwitchEffect::slotWindowClosed(EffectWindow* w)
{
if (m_selectedWindow == w)
m_selectedWindow = 0;
if (m_active) {
QHash< const EffectWindow*, ItemInfo* >::iterator it = m_windows.find(w);
if (it != m_windows.end()) {
delete *it;
m_windows.erase(it);
}
}
}
//*************************************************************
// Activation
//*************************************************************
void FlipSwitchEffect::setActive(bool activate, FlipSwitchMode mode)
{
if (activate) {
// effect already active, do some sanity checks
if (m_active) {
if (m_stop) {
if (mode != m_mode) {
// only the same mode may reactivate the effect
return;
}
} else {
// active, but not scheduled for closing -> abort
return;
}
}
m_mode = mode;
foreach (EffectWindow * w, effects->stackingOrder()) {
if (isSelectableWindow(w) && !m_windows.contains(w))
m_windows[ w ] = new ItemInfo;
}
if (m_windows.isEmpty())
return;
effects->setActiveFullScreenEffect(this);
m_active = true;
m_start = true;
m_startStopTimeLine.setCurveShape(QTimeLine::EaseInOutCurve);
m_activeScreen = effects->activeScreen();
m_screenArea = effects->clientArea(ScreenArea, m_activeScreen, effects->currentDesktop());
if (effects->numScreens() > 1) {
// unfortunatelly we have to change the projection matrix in dual screen mode
// code is copied from Coverswitch
QRect fullRect = effects->clientArea(FullArea, m_activeScreen, effects->currentDesktop());
float fovy = 60.0f;
float aspect = 1.0f;
float zNear = 0.1f;
float zFar = 100.0f;
float ymax = zNear * std::tan(fovy * M_PI / 360.0f);
float ymin = -ymax;
float xmin = ymin * aspect;
float xmax = ymax * aspect;
if (m_screenArea.width() != fullRect.width()) {
if (m_screenArea.x() == 0) {
// horizontal layout: left screen
xmin *= (float)m_screenArea.width() / (float)fullRect.width();
xmax *= (fullRect.width() - 0.5f * m_screenArea.width()) / (0.5f * fullRect.width());
} else {
// horizontal layout: right screen
xmin *= (fullRect.width() - 0.5f * m_screenArea.width()) / (0.5f * fullRect.width());
xmax *= (float)m_screenArea.width() / (float)fullRect.width();
}
}
if (m_screenArea.height() != fullRect.height()) {
if (m_screenArea.y() == 0) {
// vertical layout: top screen
ymin *= (fullRect.height() - 0.5f * m_screenArea.height()) / (0.5f * fullRect.height());
ymax *= (float)m_screenArea.height() / (float)fullRect.height();
} else {
// vertical layout: bottom screen
ymin *= (float)m_screenArea.height() / (float)fullRect.height();
ymax *= (fullRect.height() - 0.5f * m_screenArea.height()) / (0.5f * fullRect.height());
}
}
m_projectionMatrix = QMatrix4x4();
m_projectionMatrix.frustum(xmin, xmax, ymin, ymax, zNear, zFar);
const float scaleFactor = 1.1f / zNear;
// Create a second matrix that transforms screen coordinates
// to world coordinates.
QMatrix4x4 matrix;
matrix.translate(xmin * scaleFactor, ymax * scaleFactor, -1.1);
matrix.scale( (xmax - xmin) * scaleFactor / fullRect.width(),
-(ymax - ymin) * scaleFactor / fullRect.height(),
0.001);
// Combine the matrices
m_projectionMatrix *= matrix;
m_modelviewMatrix = QMatrix4x4();
m_modelviewMatrix.translate(m_screenArea.x(), m_screenArea.y(), 0.0);
}
if (m_stop) {
// effect is still closing from last usage
m_stop = false;
} else {
// things to do only when there is no closing animation
m_scheduledDirections.clear();
}
switch(m_mode) {
case TabboxMode:
m_selectedWindow = effects->currentTabBoxWindow();
effects->startMouseInterception(this, Qt::ArrowCursor);
break;
case CurrentDesktopMode:
m_selectedWindow = effects->activeWindow();
effects->startMouseInterception(this, Qt::BlankCursor);
m_hasKeyboardGrab = effects->grabKeyboard(this);
break;
case AllDesktopsMode:
m_selectedWindow = effects->activeWindow();
effects->startMouseInterception(this, Qt::BlankCursor);
m_hasKeyboardGrab = effects->grabKeyboard(this);
break;
}
// Setup caption frame geometry
QRect frameRect = QRect(m_screenArea.width() * 0.25f + m_screenArea.x(),
m_screenArea.height() * 0.1f + m_screenArea.y() - QFontMetrics(m_captionFont).height(),
m_screenArea.width() * 0.5f,
QFontMetrics(m_captionFont).height());
if (!m_captionFrame) {
m_captionFrame = effects->effectFrame(EffectFrameStyled);
m_captionFrame->setFont(m_captionFont);
m_captionFrame->enableCrossFade(true);
}
m_captionFrame->setGeometry(frameRect);
m_captionFrame->setIconSize(QSize(frameRect.height(), frameRect.height()));
updateCaption();
effects->addRepaintFull();
} else {
// only deactivate if mode is current mode
if (mode != m_mode)
return;
if (m_start && m_scheduledDirections.isEmpty()) {
m_start = false;
}
m_stop = true;
if (m_animation) {
m_startStopTimeLine.setCurveShape(QTimeLine::EaseOutCurve);
if (m_scheduledDirections.count() == 1) {
if (m_currentAnimationShape == QTimeLine::EaseInOutCurve)
m_currentAnimationShape = QTimeLine::EaseInCurve;
else if (m_currentAnimationShape == QTimeLine::EaseOutCurve)
m_currentAnimationShape = QTimeLine::LinearCurve;
m_timeLine.setCurveShape(m_currentAnimationShape);
}
} else
m_startStopTimeLine.setCurveShape(QTimeLine::EaseInOutCurve);
effects->stopMouseInterception(this);
if (m_hasKeyboardGrab) {
effects->ungrabKeyboard();
m_hasKeyboardGrab = false;
}
effects->addRepaintFull();
}
}
void FlipSwitchEffect::toggleActiveAllDesktops()
{
if (m_active) {
if (m_stop) {
// reactivate if stopping
setActive(true, AllDesktopsMode);
} else {
// deactivate if not stopping
setActive(false, AllDesktopsMode);
}
} else {
setActive(true, AllDesktopsMode);
}
}
void FlipSwitchEffect::toggleActiveCurrent()
{
if (m_active) {
if (m_stop) {
// reactivate if stopping
setActive(true, CurrentDesktopMode);
} else {
// deactivate if not stopping
setActive(false, CurrentDesktopMode);
}
} else {
setActive(true, CurrentDesktopMode);
}
}
//*************************************************************
// Helper function
//*************************************************************
bool FlipSwitchEffect::isSelectableWindow(EffectWindow* w) const
{
// desktop windows might be included
if ((w->isSpecialWindow() && !w->isDesktop()) || w->isUtility())
return false;
if (w->isDesktop())
return (m_mode == TabboxMode && effects->currentTabBoxWindowList().contains(w));
if (w->isDeleted())
return false;
if (!w->acceptsFocus())
return false;
switch(m_mode) {
case TabboxMode:
return effects->currentTabBoxWindowList().contains(w);
case CurrentDesktopMode:
return w->isOnCurrentDesktop();
case AllDesktopsMode:
//nothing special
break;
}
return true;
}
void FlipSwitchEffect::scheduleAnimation(const SwitchingDirection& direction, int distance)
{
if (m_start) {
// start is still active so change the shape to have a nice transition
m_startStopTimeLine.setCurveShape(QTimeLine::EaseInCurve);
}
if (!m_animation && !m_start) {
m_animation = true;
m_scheduledDirections.enqueue(direction);
distance--;
// reset shape just to make sure
m_currentAnimationShape = QTimeLine::EaseInOutCurve;
m_timeLine.setCurveShape(m_currentAnimationShape);
}
for (int i = 0; i < distance; i++) {
if (m_scheduledDirections.count() > 1 && m_scheduledDirections.last() != direction)
m_scheduledDirections.pop_back();
else
m_scheduledDirections.enqueue(direction);
if (m_scheduledDirections.count() == m_windows.count() + 1) {
SwitchingDirection temp = m_scheduledDirections.dequeue();
m_scheduledDirections.clear();
m_scheduledDirections.enqueue(temp);
}
}
if (m_scheduledDirections.count() > 1) {
QTimeLine::CurveShape newShape = QTimeLine::EaseInOutCurve;
switch(m_currentAnimationShape) {
case QTimeLine::EaseInOutCurve:
newShape = QTimeLine::EaseInCurve;
break;
case QTimeLine::EaseOutCurve:
newShape = QTimeLine::LinearCurve;
break;
default:
newShape = m_currentAnimationShape;
}
if (newShape != m_currentAnimationShape) {
m_currentAnimationShape = newShape;
m_timeLine.setCurveShape(m_currentAnimationShape);
}
}
}
void FlipSwitchEffect::adjustWindowMultiScreen(const KWin::EffectWindow* w, WindowPaintData& data)
{
if (effects->numScreens() <= 1)
return;
QRect clientRect = effects->clientArea(FullScreenArea, w->screen(), effects->currentDesktop());
QRect rect = effects->clientArea(ScreenArea, m_activeScreen, effects->currentDesktop());
QRect fullRect = effects->clientArea(FullArea, m_activeScreen, effects->currentDesktop());
if (w->screen() == m_activeScreen) {
if (clientRect.width() != fullRect.width() && clientRect.x() != fullRect.x()) {
data.translate(- clientRect.x());
}
if (clientRect.height() != fullRect.height() && clientRect.y() != fullRect.y()) {
data.translate(0.0, - clientRect.y());
}
} else {
if (clientRect.width() != fullRect.width() && clientRect.x() < rect.x()) {
data.translate(- (m_screenArea.x() - clientRect.x()));
}
if (clientRect.height() != fullRect.height() && clientRect.y() < m_screenArea.y()) {
data.translate(0.0, - (m_screenArea.y() - clientRect.y()));
}
}
}
void FlipSwitchEffect::selectNextOrPreviousWindow(bool forward)
{
if (!m_active || !m_selectedWindow) {
return;
}
const int index = effects->currentTabBoxWindowList().indexOf(m_selectedWindow);
int newIndex = index;
if (forward) {
++newIndex;
} else {
--newIndex;
}
if (newIndex == effects->currentTabBoxWindowList().size()) {
newIndex = 0;
} else if (newIndex < 0) {
newIndex = effects->currentTabBoxWindowList().size() -1;
}
if (index == newIndex) {
return;
}
effects->setTabBoxWindow(effects->currentTabBoxWindowList().at(newIndex));
}
//*************************************************************
// Keyboard handling
//*************************************************************
void FlipSwitchEffect::globalShortcutChanged(QAction *action, QKeySequence shortcut)
{
if (action->objectName() == QStringLiteral("FlipSwitchAll")) {
m_shortcutAll.clear();
m_shortcutAll.append(shortcut);
} else if (action->objectName() == QStringLiteral("FlipSwitchCurrent")) {
m_shortcutCurrent.clear();
m_shortcutCurrent.append(shortcut);
}
}
void FlipSwitchEffect::grabbedKeyboardEvent(QKeyEvent* e)
{
if (e->type() == QEvent::KeyPress) {
// check for global shortcuts
// HACK: keyboard grab disables the global shortcuts so we have to check for global shortcut (bug 156155)
if (m_mode == CurrentDesktopMode && m_shortcutCurrent.contains(e->key() + e->modifiers())) {
toggleActiveCurrent();
return;
}
if (m_mode == AllDesktopsMode && m_shortcutAll.contains(e->key() + e->modifiers())) {
toggleActiveAllDesktops();
return;
}
switch(e->key()) {
case Qt::Key_Escape:
setActive(false, m_mode);
return;
case Qt::Key_Tab: {
// find next window
if (m_windows.isEmpty())
return; // sanity check
bool found = false;
for (int i = effects->stackingOrder().indexOf(m_selectedWindow) - 1; i >= 0; i--) {
if (isSelectableWindow(effects->stackingOrder().at(i))) {
m_selectedWindow = effects->stackingOrder().at(i);
found = true;
break;
}
}
if (!found) {
for (int i = effects->stackingOrder().count() - 1; i > effects->stackingOrder().indexOf(m_selectedWindow); i--) {
if (isSelectableWindow(effects->stackingOrder().at(i))) {
m_selectedWindow = effects->stackingOrder().at(i);
found = true;
break;
}
}
}
if (found) {
updateCaption();
scheduleAnimation(DirectionForward);
}
break;
}
case Qt::Key_Backtab: {
// find previous window
if (m_windows.isEmpty())
return; // sanity check
bool found = false;
for (int i = effects->stackingOrder().indexOf(m_selectedWindow) + 1; i < effects->stackingOrder().count(); i++) {
if (isSelectableWindow(effects->stackingOrder().at(i))) {
m_selectedWindow = effects->stackingOrder().at(i);
found = true;
break;
}
}
if (!found) {
for (int i = 0; i < effects->stackingOrder().indexOf(m_selectedWindow); i++) {
if (isSelectableWindow(effects->stackingOrder().at(i))) {
m_selectedWindow = effects->stackingOrder().at(i);
found = true;
break;
}
}
}
if (found) {
updateCaption();
scheduleAnimation(DirectionBackward);
}
break;
}
case Qt::Key_Return:
case Qt::Key_Enter:
case Qt::Key_Space:
if (m_selectedWindow)
effects->activateWindow(m_selectedWindow);
setActive(false, m_mode);
break;
default:
break;
}
effects->addRepaintFull();
}
}
void FlipSwitchEffect::slotTabBoxKeyEvent(QKeyEvent *event)
{
if (event->type() == QEvent::KeyPress) {
switch (event->key()) {
case Qt::Key_Up:
case Qt::Key_Left:
selectPreviousWindow();
break;
case Qt::Key_Down:
case Qt::Key_Right:
selectNextWindow();
break;
default:
// nothing
break;
}
}
}
bool FlipSwitchEffect::isActive() const
{
return m_active && !effects->isScreenLocked();
}
void FlipSwitchEffect::updateCaption()
{
if (!m_selectedWindow) {
return;
}
if (m_selectedWindow->isDesktop()) {
m_captionFrame->setText(i18nc("Special entry in alt+tab list for minimizing all windows",
"Show Desktop"));
static QPixmap pix = QIcon::fromTheme(QStringLiteral("user-desktop")).pixmap(m_captionFrame->iconSize());
m_captionFrame->setIcon(pix);
} else {
m_captionFrame->setText(m_selectedWindow->caption());
m_captionFrame->setIcon(m_selectedWindow->icon());
}
}
//*************************************************************
// Mouse handling
//*************************************************************
void FlipSwitchEffect::windowInputMouseEvent(QEvent* e)
{
if (e->type() != QEvent::MouseButtonPress)
return;
// we don't want click events during animations
if (m_animation)
return;
QMouseEvent* event = static_cast< QMouseEvent* >(e);
switch (event->button()) {
case Qt::XButton1: // wheel up
selectPreviousWindow();
break;
case Qt::XButton2: // wheel down
selectNextWindow();
break;
case Qt::LeftButton:
case Qt::RightButton:
case Qt::MidButton:
default:
// TODO: Change window on mouse button click
break;
}
}
//*************************************************************
// Item Info
//*************************************************************
FlipSwitchEffect::ItemInfo::ItemInfo()
: deleted(false)
, opacity(0.0)
, brightness(0.0)
, saturation(0.0)
{
}
FlipSwitchEffect::ItemInfo::~ItemInfo()
{
}
} // namespace
Reference in a new issue View git blame Copy permalink