kwin/effects/_test/slidetabs/slidetabs.cpp

/********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.

Copyright (C) 2009 Jorge Mata <matamax123@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/>.
*********************************************************************/

#include "slidetabs.h"

#include <cmath>
#include <QPoint>

namespace KWin
{

KWIN_EFFECT(slidetabs, SlideTabsEffect)

SlideTabsEffect::SlideTabsEffect()
{
    reconfigure(ReconfigureAll);
}

void SlideTabsEffect::reconfigure(ReconfigureFlags)
{
    KConfigGroup conf = EffectsHandler::effectConfig("SlideTabs");
    switching = conf.readEntry("SlideSwitching", true);
    grouping = conf.readEntry("SlideGrouping", true);
    totalTime = conf.readEntry("SlideDuration", 500);
}

void SlideTabsEffect::prePaintWindow(EffectWindow *w, WindowPrePaintData &data, int time)
{
    if (motionManager.isManaging(w)) {
        data.setTransformed();
        w->enablePainting(EffectWindow::PAINT_DISABLED);
        timeLine.addTime(time);
    }
    effects->prePaintWindow(w, data, time);
}

void SlideTabsEffect::paintWindow(EffectWindow* w, int mask, QRegion region, WindowPaintData& data)
{
    if (motionManager.isManaging(w) && w == inMove)
        motionManager.apply(w, data);
    effects->paintWindow(w, mask, region, data);
}

void SlideTabsEffect::postPaintWindow(EffectWindow* w)
{
    if (motionManager.isManaging(w)) {
        if (w == inMove) {
            QRect moving = calculateNextMove();
            motionManager.moveWindow(w, moving);
            if (direction && timeLine.progress() >= 0.5) {
                moving = target;
                target = source;
                source = moving;
                direction = false;
                effects->setElevatedWindow(notMoving, false);
                effects->setElevatedWindow(w, true);
            } else if (timeLine.progress() >= 1.0) {
                effects->setElevatedWindow(notMoving, false);
                effects->setElevatedWindow(inMove, false);
                motionManager.unmanage(notMoving);
                motionManager.unmanage(inMove);
                notMoving = NULL;
                inMove = NULL;
                wasD = false;
                effects->addRepaintFull();
            }
        } else if (w == notMoving && !direction && target != w->geometry() && !wasD) {
            target = w->geometry();
        }
        w->addRepaintFull();
    }
    effects->postPaintWindow(w);
}

void SlideTabsEffect::prePaintScreen(ScreenPrePaintData &data, int time)
{
    if (motionManager.managingWindows()) {
        motionManager.calculate(time);
        data.mask |= Effect::PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS;
    }
    effects->prePaintScreen(data, time);
}

void SlideTabsEffect::postPaintScreen()
{
    if (motionManager.managingWindows())
        effects->addRepaintFull();
    effects->postPaintScreen();
}

void SlideTabsEffect::clientGroupItemSwitched(EffectWindow* from, EffectWindow* to)
{
    if (!switching)
        return;
    inMove = to;
    notMoving = from;
    source = notMoving->geometry();
    QRect window = notMoving->geometry();
    int leftSpace = window.x(), rightSpace = displayWidth() - (window.x() + window.width()),
        upSpace = window.y(), downSpace = displayHeight() - (window.y() + window.height());

    if (leftSpace >= rightSpace && leftSpace >= upSpace && leftSpace >= downSpace)
        target = QRect(source.x() - (1.2 * source.width()), source.y(), source.width(), source.height());
    else if (rightSpace >= leftSpace && rightSpace >= upSpace && rightSpace >= downSpace)
        target = QRect(source.x() + (1.2 * source.width()), source.y(), source.width(), source.height());
    else if (upSpace >= leftSpace && upSpace >= rightSpace && upSpace >= downSpace)
        target = QRect(source.x(), source.y() - (1.2 * source.height()), source.width(), source.height());
    else
        target = QRect(source.x(), source.y() + (1.2 * source.height()), source.width(), source.height());

    timeLine.setCurveShape(TimeLine::LinearCurve);
    timeLine.setDuration(animationTime(totalTime));
    timeLine.setProgress(0.0f);
    motionManager.manage(inMove);
    motionManager.manage(notMoving);
    distance = sqrt(((source.x() - target.x()) * (source.x() - target.x())) + ((source.y() - target.y()) * (source.y() - target.y())));
    effects->setElevatedWindow(notMoving, true);
    direction = wasD = true;

    QRect moving = calculateNextMove();
    motionManager.moveWindow(inMove, moving);
}

void SlideTabsEffect::clientGroupItemAdded(EffectWindow* from, EffectWindow* to)
{
    if (!grouping || from->desktop() != to->desktop() || from->isMinimized() || to->isMinimized())
        return;
    timeLine.setCurveShape(TimeLine::LinearCurve);
    timeLine.setDuration(animationTime(totalTime));
    timeLine.setProgress(0.0f);
    inMove = from;
    notMoving = to;
    source = inMove->geometry();
    target = notMoving->geometry();
    distance = sqrt(((source.x() - target.x()) * (source.x() - target.x())) + ((source.y() - target.y()) * (source.y() - target.y())));
    motionManager.manage(inMove);
    motionManager.manage(notMoving);
    QRect moving = calculateNextMove();
    motionManager.moveWindow(inMove, moving);
    effects->setElevatedWindow(notMoving, true);
    direction = wasD = false;
}

QPoint SlideTabsEffect::calculatePointTarget(const QPoint &a, const QPoint &b)
{
    double dy, dx, x, y, k;
    k = direction ? (2.0 * timeLine.progress()) : (wasD ? ((timeLine.progress() - 0.5) * 2) : timeLine.progress());
    dx = fabs(a.x() - b.x());
    dy = fabs(a.y() - b.y());
    y = k * dy;
    x = k * dx;
    if (a.x() > b.x())
        x = -x;
    if (a.y() > b.y())
        y = -y;
    return QPoint(a.x() + x, a.y() + y);
}

QRect SlideTabsEffect::calculateNextMove()
{
    QPoint topLeft, bottomRight;
    int mw = source.width(), mh = source.height(), tw = target.width(), th = target.height();
    topLeft = calculatePointTarget(QPoint(source.x(), source.y()), QPoint(target.x(), target.y()));
    bottomRight = calculatePointTarget(QPoint(source.x() + mw, source.y() + mh), QPoint(target.x() + tw, target.y() + th));
    return QRect(topLeft.x(), topLeft.y(), bottomRight.x() - topLeft.x(), bottomRight.y() - topLeft.y());
}

}