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

Copyright (C) 2007 Rivo Laks <rivolaks@hot.ee>
Copyright (C) 2008 Lucas Murray <lmurray@undefinedfire.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 "presentwindows.h"

#include <kactioncollection.h>
#include <kaction.h>
#include <klocale.h>
#include <kcolorscheme.h>
#include <kconfiggroup.h>
#include <kdebug.h>

#ifdef KWIN_HAVE_OPENGL_COMPOSITING
#include <kwinglutils.h>
#endif

#include <QMouseEvent>
#include <QtGui/QPainter>
#include <QtGui/QGraphicsLinearLayout>
#include <Plasma/FrameSvg>
#include <Plasma/PushButton>
#include <Plasma/WindowEffects>
#include <netwm_def.h>

#include <math.h>
#include <assert.h>
#include <limits.h>
#include <QTimer>
#include <QVector4D>

namespace KWin
{

KWIN_EFFECT(presentwindows, PresentWindowsEffect)

PresentWindowsEffect::PresentWindowsEffect()
    : m_proxy(this)
    , m_activated(false)
    , m_ignoreMinimized(false)
    , m_decalOpacity(0.0)
    , m_hasKeyboardGrab(false)
    , m_tabBoxEnabled(false)
    , m_mode(ModeCurrentDesktop)
    , m_managerWindow(NULL)
    , m_highlightedWindow(NULL)
    , m_filterFrame(effects->effectFrame(EffectFrameStyled, false))
    , m_closeView(NULL)
{
    m_atomDesktop = XInternAtom(display(), "_KDE_PRESENT_WINDOWS_DESKTOP", False);
    m_atomWindows = XInternAtom(display(), "_KDE_PRESENT_WINDOWS_GROUP", False);
    effects->registerPropertyType(m_atomDesktop, true);
    effects->registerPropertyType(m_atomWindows, true);

    // Announce support by creating a dummy version on the root window
    unsigned char dummy = 0;
    XChangeProperty(display(), rootWindow(), m_atomDesktop, m_atomDesktop, 8, PropModeReplace, &dummy, 1);
    XChangeProperty(display(), rootWindow(), m_atomWindows, m_atomWindows, 8, PropModeReplace, &dummy, 1);

    QFont font;
    font.setPointSize(font.pointSize() * 2);
    font.setBold(true);
    m_filterFrame->setFont(font);

    KActionCollection* actionCollection = new KActionCollection(this);
    KAction* a = (KAction*)actionCollection->addAction("Expose");
    a->setText(i18n("Toggle Present Windows (Current desktop)"));
    a->setGlobalShortcut(KShortcut(Qt::CTRL + Qt::Key_F9));
    shortcut = a->globalShortcut();
    connect(a, SIGNAL(triggered(bool)), this, SLOT(toggleActive()));
    connect(a, SIGNAL(globalShortcutChanged(QKeySequence)), this, SLOT(globalShortcutChanged(QKeySequence)));
    KAction* b = (KAction*)actionCollection->addAction("ExposeAll");
    b->setText(i18n("Toggle Present Windows (All desktops)"));
    b->setGlobalShortcut(KShortcut(Qt::CTRL + Qt::Key_F10));
    shortcutAll = b->globalShortcut();
    connect(b, SIGNAL(triggered(bool)), this, SLOT(toggleActiveAllDesktops()));
    connect(b, SIGNAL(globalShortcutChanged(QKeySequence)), this, SLOT(globalShortcutChangedAll(QKeySequence)));
    KAction* c = (KAction*)actionCollection->addAction("ExposeClass");
    c->setText(i18n("Toggle Present Windows (Window class)"));
    c->setGlobalShortcut(KShortcut(Qt::CTRL + Qt::Key_F7));
    connect(c, SIGNAL(triggered(bool)), this, SLOT(toggleActiveClass()));
    connect(c, SIGNAL(globalShortcutChanged(QKeySequence)), this, SLOT(globalShortcutChangedClass(QKeySequence)));
    shortcutClass = c->globalShortcut();
    reconfigure(ReconfigureAll);
    connect(effects, SIGNAL(windowAdded(EffectWindow*)), this, SLOT(slotWindowAdded(EffectWindow*)));
    connect(effects, SIGNAL(windowClosed(EffectWindow*)), this, SLOT(slotWindowClosed(EffectWindow*)));
    connect(effects, SIGNAL(windowDeleted(EffectWindow*)), this, SLOT(slotWindowDeleted(EffectWindow*)));
    connect(effects, SIGNAL(windowGeometryShapeChanged(EffectWindow*,QRect)), this, SLOT(slotWindowGeometryShapeChanged(EffectWindow*,QRect)));
    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*)));
    connect(effects, SIGNAL(propertyNotify(EffectWindow*,long)), this, SLOT(slotPropertyNotify(EffectWindow*,long)));
}

PresentWindowsEffect::~PresentWindowsEffect()
{
    XDeleteProperty(display(), rootWindow(), m_atomDesktop);
    effects->registerPropertyType(m_atomDesktop, false);
    XDeleteProperty(display(), rootWindow(), m_atomWindows);
    effects->registerPropertyType(m_atomWindows, false);
    foreach (ElectricBorder border, m_borderActivate) {
        effects->unreserveElectricBorder(border);
    }
    foreach (ElectricBorder border, m_borderActivateAll) {
        effects->unreserveElectricBorder(border);
    }
    delete m_filterFrame;
    delete m_closeView;
}

void PresentWindowsEffect::reconfigure(ReconfigureFlags)
{
    KConfigGroup conf = effects->effectConfig("PresentWindows");
    foreach (ElectricBorder border, m_borderActivate) {
        effects->unreserveElectricBorder(border);
    }
    foreach (ElectricBorder border, m_borderActivateAll) {
        effects->unreserveElectricBorder(border);
    }
    m_borderActivate.clear();
    m_borderActivateAll.clear();
    QList<int> borderList = QList<int>();
    borderList.append(int(ElectricNone));
    borderList = conf.readEntry("BorderActivate", borderList);
    foreach (int i, borderList) {
        m_borderActivate.append(ElectricBorder(i));
        effects->reserveElectricBorder(ElectricBorder(i));
    }
    borderList.clear();
    borderList.append(int(ElectricTopLeft));
    borderList = conf.readEntry("BorderActivateAll", borderList);
    foreach (int i, borderList) {
        m_borderActivateAll.append(ElectricBorder(i));
        effects->reserveElectricBorder(ElectricBorder(i));
    }
    m_layoutMode = conf.readEntry("LayoutMode", int(LayoutNatural));
    m_showCaptions = conf.readEntry("DrawWindowCaptions", true);
    m_showIcons = conf.readEntry("DrawWindowIcons", true);
    m_doNotCloseWindows = !conf.readEntry("AllowClosingWindows", true);
    m_tabBoxAllowed = conf.readEntry("TabBox", false);
    m_tabBoxAlternativeAllowed = conf.readEntry("TabBoxAlternative", false);
    m_ignoreMinimized = conf.readEntry("IgnoreMinimized", false);
    m_accuracy = conf.readEntry("Accuracy", 1) * 20;
    m_fillGaps = conf.readEntry("FillGaps", true);
    m_fadeDuration = double(animationTime(150));
    m_showPanel = conf.readEntry("ShowPanel", false);
    m_leftButtonWindow = (WindowMouseAction)conf.readEntry("LeftButtonWindow", (int)WindowActivateAction);
    m_middleButtonWindow = (WindowMouseAction)conf.readEntry("MiddleButtonWindow", (int)WindowNoAction);
    m_rightButtonWindow = (WindowMouseAction)conf.readEntry("RightButtonWindow", (int)WindowExitAction);
    m_leftButtonDesktop = (DesktopMouseAction)conf.readEntry("LeftButtonDesktop", (int)DesktopExitAction);
    m_middleButtonDesktop = (DesktopMouseAction)conf.readEntry("MiddleButtonDesktop", (int)DesktopNoAction);
    m_rightButtonDesktop = (DesktopMouseAction)conf.readEntry("RightButtonDesktop", (int)DesktopNoAction);
}

void* PresentWindowsEffect::proxy()
{
    return &m_proxy;
}

void PresentWindowsEffect::toggleActiveClass()
{
    if (!m_activated) {
        if (!effects->activeWindow())
            return;
        m_mode = ModeWindowClass;
        m_class = effects->activeWindow()->windowClass();
    }
    setActive(!m_activated);
}

//-----------------------------------------------------------------------------
// Screen painting

void PresentWindowsEffect::prePaintScreen(ScreenPrePaintData &data, int time)
{
    m_motionManager.calculate(time);

    // We need to mark the screen as having been transformed otherwise there will be no repainting
    if (m_activated || m_motionManager.managingWindows())
        data.mask |= Effect::PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS;

    if (m_activated)
        m_decalOpacity = qMin(1.0, m_decalOpacity + time / m_fadeDuration);
    else
        m_decalOpacity = qMax(0.0, m_decalOpacity - time / m_fadeDuration);

    effects->prePaintScreen(data, time);
}

void PresentWindowsEffect::paintScreen(int mask, QRegion region, ScreenPaintData &data)
{
    effects->paintScreen(mask, region, data);

    // Display the filter box
    if (!m_windowFilter.isEmpty())
        m_filterFrame->render(region);
}

void PresentWindowsEffect::postPaintScreen()
{
    if (m_motionManager.areWindowsMoving())
        effects->addRepaintFull();
    else if (!m_activated && m_motionManager.managingWindows()) {
        // We have finished moving them back, stop processing
        m_motionManager.unmanageAll();

        DataHash::iterator i = m_windowData.begin();
        while (i != m_windowData.end()) {
            delete i.value().textFrame;
            delete i.value().iconFrame;
            i++;
        }
        m_windowData.clear();

        foreach (EffectWindow * w, effects->stackingOrder()) {
            if (w->isDock()) {
                w->setData(WindowForceBlurRole, QVariant(false));
            }
        }
        effects->setActiveFullScreenEffect(NULL);
    }

    // Update windows that are changing brightness or opacity
    DataHash::const_iterator i;
    for (i = m_windowData.constBegin(); i != m_windowData.constEnd(); ++i) {
        if (i.value().opacity > 0.0 && i.value().opacity < 1.0)
            i.key()->addRepaintFull();
        if (i.value().highlight > 0.0 && i.value().highlight < 1.0)
            i.key()->addRepaintFull();
    }

    effects->postPaintScreen();
}

//-----------------------------------------------------------------------------
// Window painting

void PresentWindowsEffect::prePaintWindow(EffectWindow *w, WindowPrePaintData &data, int time)
{
    // TODO: We should also check to see if any windows are fading just in case fading takes longer
    //       than moving the windows when the effect is deactivated.
    if ((m_activated || m_motionManager.areWindowsMoving()) && m_windowData.contains(w)) {
        w->enablePainting(EffectWindow::PAINT_DISABLED_BY_MINIMIZE);   // Display always
        w->enablePainting(EffectWindow::PAINT_DISABLED_BY_DESKTOP);
        if (m_windowData[w].visible)
            w->enablePainting(EffectWindow::PAINT_DISABLED_BY_CLIENT_GROUP);

        // Calculate window's opacity
        // TODO: Minimized windows or windows not on the current desktop are only 75% visible?
        if (m_windowData[w].visible) {
            if (m_windowData[w].deleted)
                m_windowData[w].opacity = qMax(0.0, m_windowData[w].opacity - time / m_fadeDuration);
            else
                m_windowData[w].opacity = qMin(/*( w->isMinimized() || !w->isOnCurrentDesktop() ) ? 0.75 :*/ 1.0,
                                          m_windowData[w].opacity + time / m_fadeDuration);
        } else
            m_windowData[w].opacity = qMax(0.0, m_windowData[w].opacity - time / m_fadeDuration);
        if (m_windowData[w].opacity == 0.0) {
            // don't disable painting for panels if show panel is set
            if (!w->isDock() || (w->isDock() && !m_showPanel))
                w->disablePainting(EffectWindow::PAINT_DISABLED);
        } else if (m_windowData[w].opacity != 1.0)
            data.setTranslucent();

        // Calculate window's brightness
        if (w == m_highlightedWindow || w == m_closeWindow || !m_activated)
            m_windowData[w].highlight = qMin(1.0, m_windowData[w].highlight + time / m_fadeDuration);
        else
            m_windowData[w].highlight = qMax(0.0, m_windowData[w].highlight - time / m_fadeDuration);

        // Closed windows
        if (m_windowData[w].deleted) {
            data.setTranslucent();
            if (m_windowData[w].opacity <= 0.0 && m_windowData[w].referenced) {
                // it's possible that another effect has referenced the window
                // we have to keep the window in the list to prevent flickering
                m_windowData[w].referenced = false;
                w->unrefWindow();
            } else
                w->enablePainting(EffectWindow::PAINT_DISABLED_BY_DELETE);
        }

        // desktop windows on other desktops (Plasma activity per desktop) should not be painted
        if (w->isDesktop() && !w->isOnCurrentDesktop())
            w->disablePainting(EffectWindow::PAINT_DISABLED_BY_DESKTOP);

        if (m_motionManager.isManaging(w))
            data.setTransformed(); // We will be moving this window
    }
    effects->prePaintWindow(w, data, time);
}

void PresentWindowsEffect::paintWindow(EffectWindow *w, int mask, QRegion region, WindowPaintData &data)
{
    if ((m_activated || m_motionManager.areWindowsMoving()) && m_windowData.contains(w)) {
        if (w->isDock() && m_showPanel) {
            // in case the panel should be shown just display it without any changes
            effects->paintWindow(w, mask, region, data);
            return;
        }

        // Apply opacity and brightness
        data.opacity *= m_windowData[w].opacity;
        data.brightness *= interpolate(0.7, 1.0, m_windowData[w].highlight);

        if (m_motionManager.isManaging(w)) {
            m_motionManager.apply(w, data);

            if (!m_motionManager.areWindowsMoving()) {
                mask |= PAINT_WINDOW_LANCZOS;
            }
            effects->paintWindow(w, mask, region, data);

            QRect rect = m_motionManager.transformedGeometry(w).toRect();
            if (m_showIcons) {
                QPoint point(rect.x() + rect.width() * 0.95,
                             rect.y() + rect.height() * 0.95);
                m_windowData[w].iconFrame->setPosition(point);
#ifdef KWIN_HAVE_OPENGL_COMPOSITING
                if (effects->compositingType() == KWin::OpenGLCompositing && data.shader) {
                    const float a = 0.9 * data.opacity * m_decalOpacity * 0.75;
                    data.shader->setUniform(GLShader::TextureWidth, 1.0f);
                    data.shader->setUniform(GLShader::TextureHeight, 1.0f);
                    data.shader->setUniform(GLShader::ModulationConstant, QVector4D(a, a, a, a));
                }
#endif
                m_windowData[w].iconFrame->render(region, 0.9 * data.opacity * m_decalOpacity, 0.75);
            }
            if (m_showCaptions) {
                QPoint point(rect.x() + rect.width() / 2,
                             rect.y() + rect.height() / 2);
                m_windowData[w].textFrame->setPosition(point);
#ifdef KWIN_HAVE_OPENGL_COMPOSITING
                if (effects->compositingType() == KWin::OpenGLCompositing && data.shader) {
                    const float a = 0.9 * data.opacity * m_decalOpacity * 0.75;
                    data.shader->setUniform(GLShader::TextureWidth, 1.0f);
                    data.shader->setUniform(GLShader::TextureHeight, 1.0f);
                    data.shader->setUniform(GLShader::ModulationConstant, QVector4D(a, a, a, a));
                }
#endif
                m_windowData[w].textFrame->render(region, 0.9 * data.opacity * m_decalOpacity, 0.75);
            }
        } else
            effects->paintWindow(w, mask, region, data);
    } else
        effects->paintWindow(w, mask, region, data);
}

//-----------------------------------------------------------------------------
// User interaction

void PresentWindowsEffect::slotWindowAdded(EffectWindow *w)
{
    if (!m_activated)
        return;
    m_windowData[w].visible = isVisibleWindow(w);
    m_windowData[w].opacity = 0.0;
    m_windowData[w].highlight = 0.0;
    m_windowData[w].textFrame = effects->effectFrame(EffectFrameUnstyled, false);
    QFont font;
    font.setBold(true);
    font.setPointSize(12);
    m_windowData[w].textFrame->setFont(font);
    m_windowData[w].iconFrame = effects->effectFrame(EffectFrameUnstyled, false);
    m_windowData[w].iconFrame->setAlignment(Qt::AlignRight | Qt::AlignBottom);
    m_windowData[w].iconFrame->setIcon(w->icon());
    if (isSelectableWindow(w)) {
        m_motionManager.manage(w);
        rearrangeWindows();
    }
    if (w == effects->findWindow(m_closeView->winId())) {
        m_windowData[w].visible = true;
        m_windowData[w].highlight = 1.0;
        m_closeWindow = w;
        w->setData(WindowForceBlurRole, QVariant(true));
    }
}

void PresentWindowsEffect::slotWindowClosed(EffectWindow *w)
{
    if (m_managerWindow == w)
        m_managerWindow = NULL;
    if (!m_windowData.contains(w))
        return;
    m_windowData[w].deleted = true;
    m_windowData[w].referenced = true;
    w->refWindow();
    if (m_highlightedWindow == w)
        setHighlightedWindow(findFirstWindow());
    if (m_closeWindow == w) {
        m_closeWindow = 0;
        return; // don't rearrange
    }
    rearrangeWindows();

    foreach (EffectWindow * w, m_motionManager.managedWindows()) {
       DataHash::iterator winData = m_windowData.find( w );
        if (winData != m_windowData.end() && !winData->deleted)
           return; // found one that is not deleted? then we go on
    }
    setActive(false);     //else no need to keep this open
}

void PresentWindowsEffect::slotWindowDeleted(EffectWindow *w)
{
    if (!m_windowData.contains(w))
        return;
    delete m_windowData[w].textFrame;
    delete m_windowData[w].iconFrame;
    m_windowData.remove(w);
    m_motionManager.unmanage(w);
}

void PresentWindowsEffect::slotWindowGeometryShapeChanged(EffectWindow* w, const QRect& old)
{
    Q_UNUSED(old)
    if (!m_activated)
        return;
    if (!m_windowData.contains(w))
        return;
    rearrangeWindows();
}

bool PresentWindowsEffect::borderActivated(ElectricBorder border)
{
    if (!m_borderActivate.contains(border) && !m_borderActivateAll.contains(border))
        return false;
    if (effects->activeFullScreenEffect() && effects->activeFullScreenEffect() != this)
        return true;
    if (m_borderActivate.contains(border))
        toggleActive();
    else
        toggleActiveAllDesktops();
    return true;
}

void PresentWindowsEffect::windowInputMouseEvent(Window w, QEvent *e)
{
    assert(w == m_input);
    Q_UNUSED(w);

    QMouseEvent* me = static_cast< QMouseEvent* >(e);
    if (m_closeView->geometry().contains(me->pos())) {
        if (!m_closeView->isVisible()) {
            updateCloseWindow();
        }
        if (m_closeView->isVisible()) {
            const QPoint widgetPos = m_closeView->mapFromGlobal(me->pos());
            const QPointF scenePos = m_closeView->mapToScene(widgetPos);
            QMouseEvent event(me->type(), widgetPos, me->pos(), me->button(), me->buttons(), me->modifiers());
            m_closeView->windowInputMouseEvent(&event);
            return;
        }
    }
    // Which window are we hovering over? Always trigger as we don't always get move events before clicking
    // We cannot use m_motionManager.windowAtPoint() as the window might not be visible
    EffectWindowList windows = m_motionManager.managedWindows();
    bool hovering = false;
    for (int i = 0; i < windows.size(); i++) {
        assert(m_windowData.contains(windows.at(i)));
        if (m_motionManager.transformedGeometry(windows.at(i)).contains(cursorPos()) &&
                m_windowData[windows.at(i)].visible && !m_windowData[windows.at(i)].deleted) {
            hovering = true;
            if (windows.at(i) && m_highlightedWindow != windows.at(i))
                setHighlightedWindow(windows.at(i));
            break;
        }
    }
    if (m_highlightedWindow && m_motionManager.transformedGeometry(m_highlightedWindow).contains(me->pos()))
        updateCloseWindow();
    else
        m_closeView->hide();

    if (e->type() != QEvent::MouseButtonPress)
        return;

    if (me->button() == Qt::LeftButton) {
        if (hovering) {
            // mouse is hovering above a window - use MouseActionsWindow
            mouseActionWindow(m_leftButtonWindow);
        } else {
            // mouse is hovering above desktop - use MouseActionsDesktop
            mouseActionDesktop(m_leftButtonDesktop);
        }
    }
    if (me->button() == Qt::MidButton) {
        if (hovering) {
            // mouse is hovering above a window - use MouseActionsWindow
            mouseActionWindow(m_middleButtonWindow);
        } else {
            // mouse is hovering above desktop - use MouseActionsDesktop
            mouseActionDesktop(m_middleButtonDesktop);
        }
    }
    if (me->button() == Qt::RightButton) {
        if (hovering) {
            // mouse is hovering above a window - use MouseActionsWindow
            mouseActionWindow(m_rightButtonWindow);
        } else {
            // mouse is hovering above desktop - use MouseActionsDesktop
            mouseActionDesktop(m_rightButtonDesktop);
        }
    }
}

void PresentWindowsEffect::mouseActionWindow(WindowMouseAction& action)
{
    switch(action) {
    case WindowActivateAction:
        if (m_highlightedWindow)
            effects->activateWindow(m_highlightedWindow);
        setActive(false);
        break;
    case WindowExitAction:
        setActive(false);
        break;
    case WindowToCurrentDesktopAction:
        if (m_highlightedWindow)
            effects->windowToDesktop(m_highlightedWindow, effects->currentDesktop());
        break;
    case WindowToAllDesktopsAction:
        if (m_highlightedWindow) {
            if (m_highlightedWindow->isOnAllDesktops())
                effects->windowToDesktop(m_highlightedWindow, effects->currentDesktop());
            else
                effects->windowToDesktop(m_highlightedWindow, NET::OnAllDesktops);
        }
        break;
    case WindowMinimizeAction:
        if (m_highlightedWindow) {
            if (m_highlightedWindow->isMinimized())
                m_highlightedWindow->unminimize();
            else
                m_highlightedWindow->minimize();
        }
        break;
    case WindowCloseAction:
        if (m_highlightedWindow) {
            m_highlightedWindow->closeWindow();
        }
        break;
    default:
        break;
    }
}

void PresentWindowsEffect::mouseActionDesktop(DesktopMouseAction& action)
{
    switch(action) {
    case DesktopActivateAction:
        if (m_highlightedWindow)
            effects->activateWindow(m_highlightedWindow);
        setActive(false);
        break;
    case DesktopExitAction:
        setActive(false);
        break;
    case DesktopShowDesktopAction:
        effects->setShowingDesktop(true);
        setActive(false);
    default:
        break;
    }
}


void PresentWindowsEffect::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 == ModeCurrentDesktop && shortcut.contains(e->key() + e->modifiers())) {
            toggleActive();
            return;
        }
        if (m_mode == ModeAllDesktops && shortcutAll.contains(e->key() + e->modifiers())) {
            toggleActiveAllDesktops();
            return;
        }
        if (m_mode == ModeWindowClass && shortcutClass.contains(e->key() + e->modifiers())) {
            toggleActiveClass();
            return;
        }

        switch(e->key()) {
            // Wrap only if not auto-repeating
        case Qt::Key_Left:
            if (m_highlightedWindow)
                setHighlightedWindow(relativeWindow(m_highlightedWindow, -1, 0, !e->isAutoRepeat()));
            break;
        case Qt::Key_Right:
            if (m_highlightedWindow)
                setHighlightedWindow(relativeWindow(m_highlightedWindow, 1, 0, !e->isAutoRepeat()));
            break;
        case Qt::Key_Up:
            if (m_highlightedWindow)
                setHighlightedWindow(relativeWindow(m_highlightedWindow, 0, -1, !e->isAutoRepeat()));
            break;
        case Qt::Key_Down:
            if (m_highlightedWindow)
                setHighlightedWindow(relativeWindow(m_highlightedWindow, 0, 1, !e->isAutoRepeat()));
            break;
        case Qt::Key_Home:
            if (m_highlightedWindow)
                setHighlightedWindow(relativeWindow(m_highlightedWindow, -1000, 0, false));
            break;
        case Qt::Key_End:
            if (m_highlightedWindow)
                setHighlightedWindow(relativeWindow(m_highlightedWindow, 1000, 0, false));
            break;
        case Qt::Key_PageUp:
            if (m_highlightedWindow)
                setHighlightedWindow(relativeWindow(m_highlightedWindow, 0, -1000, false));
            break;
        case Qt::Key_PageDown:
            if (m_highlightedWindow)
                setHighlightedWindow(relativeWindow(m_highlightedWindow, 0, 1000, false));
            break;
        case Qt::Key_Backspace:
            if (!m_windowFilter.isEmpty()) {
                m_windowFilter.remove(m_windowFilter.length() - 1, 1);
                updateFilterFrame();
                rearrangeWindows();
            }
            return;
        case Qt::Key_Escape:
            setActive(false);
            return;
        case Qt::Key_Return:
        case Qt::Key_Enter:
            if (m_highlightedWindow)
                effects->activateWindow(m_highlightedWindow);
            setActive(false);
            return;
        case Qt::Key_Tab:
            return; // Nothing at the moment
        case Qt::Key_Delete:
            if (!m_windowFilter.isEmpty()) {
                m_windowFilter.clear();
                updateFilterFrame();
                rearrangeWindows();
            }
            break;
        case 0:
            return; // HACK: Workaround for Qt bug on unbound keys (#178547)
        default:
            if (!e->text().isEmpty()) {
                m_windowFilter.append(e->text());
                updateFilterFrame();
                rearrangeWindows();
                return;
            }
            break;
        }
    }
}

//-----------------------------------------------------------------------------
// Tab box

void PresentWindowsEffect::slotTabBoxAdded(int mode)
{
    if (effects->activeFullScreenEffect() && effects->activeFullScreenEffect() != this)
        return;
    if (m_activated)
        return;
    if (((mode == TabBoxWindowsMode && m_tabBoxAllowed) ||
            (mode == TabBoxWindowsAlternativeMode && m_tabBoxAlternativeAllowed)) &&
            effects->currentTabBoxWindowList().count() > 0) {
        m_tabBoxEnabled = true;
        setActive(true);
        if (m_activated)
            effects->refTabBox();
        else
            m_tabBoxEnabled = false;
    }
}

void PresentWindowsEffect::slotTabBoxClosed()
{
    if (m_activated) {
        effects->unrefTabBox();
        setActive(false, true);
        m_tabBoxEnabled = false;
    }
}

void PresentWindowsEffect::slotTabBoxUpdated()
{
    if (m_activated)
        setHighlightedWindow(effects->currentTabBoxWindow());
}

void PresentWindowsEffect::slotTabBoxKeyEvent(QKeyEvent* event)
{
    if (!m_activated)
        return;
    // not using the "normal" grabbedKeyboardEvent as we don't want to filter in tabbox
    if (event->type() == QEvent::KeyPress) {
        switch(event->key()) {
            // Wrap only if not auto-repeating
        case Qt::Key_Left:
            setHighlightedWindow(relativeWindow(m_highlightedWindow, -1, 0, !event->isAutoRepeat()));
            break;
        case Qt::Key_Right:
            setHighlightedWindow(relativeWindow(m_highlightedWindow, 1, 0, !event->isAutoRepeat()));
            break;
        case Qt::Key_Up:
            setHighlightedWindow(relativeWindow(m_highlightedWindow, 0, -1, !event->isAutoRepeat()));
            break;
        case Qt::Key_Down:
            setHighlightedWindow(relativeWindow(m_highlightedWindow, 0, 1, !event->isAutoRepeat()));
            break;
        case Qt::Key_Home:
            setHighlightedWindow(relativeWindow(m_highlightedWindow, -1000, 0, false));
            break;
        case Qt::Key_End:
            setHighlightedWindow(relativeWindow(m_highlightedWindow, 1000, 0, false));
            break;
        case Qt::Key_PageUp:
            setHighlightedWindow(relativeWindow(m_highlightedWindow, 0, -1000, false));
            break;
        case Qt::Key_PageDown:
            setHighlightedWindow(relativeWindow(m_highlightedWindow, 0, 1000, false));
            break;
        default:
            // nothing
            break;
        }
    }
}

//-----------------------------------------------------------------------------
// Atom handling
void PresentWindowsEffect::slotPropertyNotify(EffectWindow* w, long a)
{
    if (!w || (a != m_atomDesktop && a != m_atomWindows))
        return; // Not our atom

    if (a == m_atomDesktop) {
        QByteArray byteData = w->readProperty(m_atomDesktop, m_atomDesktop, 32);
        if (byteData.length() < 1) {
            // Property was removed, end present windows
            setActive(false);
            return;
        }
        long* data = reinterpret_cast<long*>(byteData.data());

        if (!data[0]) {
            // Purposely ending present windows by issuing a NULL target
            setActive(false);
            return;
        }
        // present windows is active so don't do anything
        if (m_activated)
            return;

        int desktop = data[0];
        if (desktop > effects->numberOfDesktops())
            return;
        if (desktop == -1)
            toggleActiveAllDesktops();
        else {
            m_mode = ModeSelectedDesktop;
            m_desktop = desktop;
            m_managerWindow = w;
            setActive(true);
        }
    } else if (a == m_atomWindows) {
        QByteArray byteData = w->readProperty(m_atomWindows, m_atomWindows, 32);
        if (byteData.length() < 1) {
            // Property was removed, end present windows
            setActive(false);
            return;
        }
        long* data = reinterpret_cast<long*>(byteData.data());

        if (!data[0]) {
            // Purposely ending present windows by issuing a NULL target
            setActive(false);
            return;
        }
        // present windows is active so don't do anything
        if (m_activated)
            return;

        // for security clear selected windows
        m_selectedWindows.clear();
        int length = byteData.length() / sizeof(data[0]);
        for (int i = 0; i < length; i++) {
            EffectWindow* foundWin = effects->findWindow(data[i]);
            if (!foundWin) {
                kDebug(1212) << "Invalid window targetted for present windows. Requested:" << data[i];
                continue;
            }
            m_selectedWindows.append(foundWin);
        }
        m_mode = ModeWindowGroup;
        m_managerWindow = w;
        setActive(true);
    }
}

//-----------------------------------------------------------------------------
// Window rearranging

void PresentWindowsEffect::rearrangeWindows()
{
    if (!m_activated)
        return;

    effects->addRepaintFull(); // Trigger the first repaint
    m_closeView->hide();

    // Work out which windows are on which screens
    EffectWindowList windowlist;
    QList<EffectWindowList> windowlists;
    for (int i = 0; i < effects->numScreens(); i++)
        windowlists.append(EffectWindowList());

    if (m_windowFilter.isEmpty()) {
        if (m_tabBoxEnabled)
            // Assume we correctly set things up, should be identical to
            // m_motionManager except just in a slightly different order.
            windowlist = effects->currentTabBoxWindowList();
        else
            windowlist = m_motionManager.managedWindows();
        foreach (EffectWindow * w, m_motionManager.managedWindows()) {
            if (m_windowData[w].deleted)
                continue; // don't include closed windows
            windowlists[w->screen()].append(w);
            assert(m_windowData.contains(w));
            m_windowData[w].visible = true;
        }
    } else {
        // Can we move this filtering somewhere else?
        foreach (EffectWindow * w, m_motionManager.managedWindows()) {
            assert(m_windowData.contains(w));
            if (m_windowData[w].deleted)
                continue; // don't include closed windows
            if (w->caption().contains(m_windowFilter, Qt::CaseInsensitive) ||
                    w->windowClass().contains(m_windowFilter, Qt::CaseInsensitive) ||
                    w->windowRole().contains(m_windowFilter, Qt::CaseInsensitive)) {
                windowlist.append(w);
                windowlists[w->screen()].append(w);
                m_windowData[w].visible = true;
            } else
                m_windowData[w].visible = false;
        }
    }
    if (windowlist.isEmpty()) {
        setHighlightedWindow(NULL);   // TODO: Having a NULL highlighted window isn't really safe
        return;
    }

    // We filtered out the highlighted window
    if (m_highlightedWindow) {
        assert(m_windowData.contains(m_highlightedWindow));
        if (m_windowData[m_highlightedWindow].visible == false)
            setHighlightedWindow(findFirstWindow());
    } else if (m_tabBoxEnabled)
        setHighlightedWindow(effects->currentTabBoxWindow());
    else
        setHighlightedWindow(findFirstWindow());

    int screens = m_tabBoxEnabled ? 1 : effects->numScreens();
    for (int screen = 0; screen < screens; screen++) {
        EffectWindowList windows;
        if (m_tabBoxEnabled) {
            // Kind of cheating here
            screen = effects->activeScreen();
            windows = windowlist;
        } else
            windows = windowlists[screen];

        // Don't rearrange if the grid is the same size as what it was before to prevent
        // windows moving to a better spot if one was filtered out.
        if (m_layoutMode == LayoutRegularGrid &&
                m_gridSizes[screen].columns * m_gridSizes[screen].rows &&
                windows.size() < m_gridSizes[screen].columns * m_gridSizes[screen].rows &&
                windows.size() > (m_gridSizes[screen].columns - 1) * m_gridSizes[screen].rows &&
                windows.size() > m_gridSizes[screen].columns *(m_gridSizes[screen].rows - 1) &&
                !m_tabBoxEnabled)
            continue;

        // No point continuing if there is no windows to process
        if (!windows.count())
            continue;

        calculateWindowTransformations(windows, screen, m_motionManager);
    }

    // Resize text frames if required
    QFontMetrics* metrics = NULL; // All fonts are the same
    foreach (EffectWindow * w, m_motionManager.managedWindows()) {
        if (!metrics)
            metrics = new QFontMetrics(m_windowData[w].textFrame->font());
        QRect geom = m_motionManager.targetGeometry(w).toRect();
        QString string = metrics->elidedText(w->caption(), Qt::ElideRight, geom.width() * 0.9);
        if (string != m_windowData[w].textFrame->text())
            m_windowData[w].textFrame->setText(string);
    }
    delete metrics;
}

void PresentWindowsEffect::calculateWindowTransformations(EffectWindowList windowlist, int screen,
        WindowMotionManager& motionManager, bool external)
{
    if (m_layoutMode == LayoutRegularGrid || m_tabBoxEnabled)   // Force the grid for window switching
        calculateWindowTransformationsClosest(windowlist, screen, motionManager);
    else if (m_layoutMode == LayoutFlexibleGrid)
        calculateWindowTransformationsKompose(windowlist, screen, motionManager);
    else
        calculateWindowTransformationsNatural(windowlist, screen, motionManager);

    // If called externally we don't need to remember this data
    if (external)
        m_windowData.clear();
}

void PresentWindowsEffect::calculateWindowTransformationsClosest(EffectWindowList windowlist, int screen,
        WindowMotionManager& motionManager)
{
    // This layout mode requires at least one window visible
    if (windowlist.count() == 0)
        return;

    QRect area = effects->clientArea(ScreenArea, screen, effects->currentDesktop());
    if (m_showPanel)   // reserve space for the panel
        area = effects->clientArea(MaximizeArea, screen, effects->currentDesktop());
    int columns = int(ceil(sqrt(double(windowlist.count()))));
    int rows = int(ceil(windowlist.count() / double(columns)));

    // Remember the size for later
    // If we are using this layout externally we don't need to remember m_gridSizes.
    if (m_gridSizes.size() != 0) {
        m_gridSizes[screen].columns = columns;
        m_gridSizes[screen].rows = rows;
    }

    // Assign slots
    foreach (EffectWindow * w, windowlist)
    m_windowData[w].slot = -1;
    if (m_tabBoxEnabled) {
        // Rearrange in the correct order. As rearrangeWindows() is only ever
        // called once so we can use effects->currentTabBoxWindow() here.
        int selectedWindow = qMax(0, windowlist.indexOf(effects->currentTabBoxWindow()));
        int slot = 0;
        for (int i = selectedWindow; i < windowlist.count(); i++)
            m_windowData[windowlist[i]].slot = slot++;
        for (int i = selectedWindow - 1; i >= 0; i--)
            m_windowData[windowlist[i]].slot = slot++;
    } else {
        for (;;) {
            // Assign each window to the closest available slot
            assignSlots(windowlist, area, columns, rows);
            // Leave only the closest window in each slot, remove further conflicts
            getBestAssignments(windowlist);
            bool allAssigned = true;
            foreach (EffectWindow * w, windowlist)
            if (m_windowData[w].slot == -1) {
                allAssigned = false;
                break;
            }
            if (allAssigned)
                break;
        }
    }

    int slotWidth = area.width() / columns;
    int slotHeight = area.height() / rows;
    foreach (EffectWindow * w, windowlist) {
        assert(m_windowData[w].slot != -1);

        // Work out where the slot is
        QRect target(
            area.x() + (m_windowData[w].slot % columns) * slotWidth,
            area.y() + (m_windowData[w].slot / columns) * slotHeight,
            slotWidth, slotHeight);
        target.adjust(10, 10, -10, -10);   // Borders
        double scale;
        if (target.width() / double(w->width()) < target.height() / double(w->height())) {
            // Center vertically
            scale = target.width() / double(w->width());
            target.moveTop(target.top() + (target.height() - int(w->height() * scale)) / 2);
            target.setHeight(int(w->height() * scale));
        } else {
            // Center horizontally
            scale = target.height() / double(w->height());
            target.moveLeft(target.left() + (target.width() - int(w->width() * scale)) / 2);
            target.setWidth(int(w->width() * scale));
        }
        // Don't scale the windows too much
        if (scale > 2.0 || (scale > 1.0 && (w->width() > 300 || w->height() > 300))) {
            scale = (w->width() > 300 || w->height() > 300) ? 1.0 : 2.0;
            target = QRect(
                         target.center().x() - int(w->width() * scale) / 2,
                         target.center().y() - int(w->height() * scale) / 2,
                         scale * w->width(), scale * w->height());
        }
        motionManager.moveWindow(w, target);
    }
}

void PresentWindowsEffect::calculateWindowTransformationsKompose(EffectWindowList windowlist, int screen,
        WindowMotionManager& motionManager)
{
    // This layout mode requires at least one window visible
    if (windowlist.count() == 0)
        return;

    QRect availRect = effects->clientArea(ScreenArea, screen, effects->currentDesktop());
    if (m_showPanel)   // reserve space for the panel
        availRect = effects->clientArea(MaximizeArea, screen, effects->currentDesktop());
    qSort(windowlist);   // The location of the windows should not depend on the stacking order

    // Following code is taken from Kompose 0.5.4, src/komposelayout.cpp

    int spacing = 10;
    int rows, columns;
    double parentRatio = availRect.width() / (double)availRect.height();
    // Use more columns than rows when parent's width > parent's height
    if (parentRatio > 1) {
        columns = (int)ceil(sqrt((double)windowlist.count()));
        rows = (int)ceil((double)windowlist.count() / (double)columns);
    } else {
        rows = (int)ceil(sqrt((double)windowlist.count()));
        columns = (int)ceil((double)windowlist.count() / (double)rows);
    }
    //kDebug(1212) << "Using " << rows << " rows & " << columns << " columns for " << windowlist.count() << " clients";

    // Calculate width & height
    int w = (availRect.width() - (columns + 1) * spacing) / columns;
    int h = (availRect.height() - (rows + 1) * spacing) / rows;

    EffectWindowList::iterator it(windowlist.begin());
    QList<QRect> geometryRects;
    QList<int> maxRowHeights;
    // Process rows
    for (int i = 0; i < rows; ++i) {
        int xOffsetFromLastCol = 0;
        int maxHeightInRow = 0;
        // Process columns
        for (int j = 0; j < columns; ++j) {
            EffectWindow* window;

            // Check for end of List
            if (it == windowlist.end())
                break;
            window = *it;

            // Calculate width and height of widget
            double ratio = aspectRatio(window);

            int widgetw = 100;
            int widgeth = 100;
            int usableW = w;
            int usableH = h;

            // use width of two boxes if there is no right neighbour
            if (window == windowlist.last() && j != columns - 1) {
                usableW = 2 * w;
            }
            ++it; // We need access to the neighbour in the following
            // expand if right neighbour has ratio < 1
            if (j != columns - 1 && it != windowlist.end() && aspectRatio(*it) < 1) {
                int addW = w - widthForHeight(*it, h);
                if (addW > 0) {
                    usableW = w + addW;
                }
            }

            if (ratio == -1) {
                widgetw = w;
                widgeth = h;
            } else {
                double widthByHeight = widthForHeight(window, usableH);
                double heightByWidth = heightForWidth(window, usableW);
                if ((ratio >= 1.0 && heightByWidth <= usableH) ||
                        (ratio < 1.0 && widthByHeight > usableW)) {
                    widgetw = usableW;
                    widgeth = (int)heightByWidth;
                } else if ((ratio < 1.0 && widthByHeight <= usableW) ||
                          (ratio >= 1.0 && heightByWidth > usableH)) {
                    widgeth = usableH;
                    widgetw = (int)widthByHeight;
                }
                // Don't upscale large-ish windows
                if (widgetw > window->width() && (window->width() > 300 || window->height() > 300)) {
                    widgetw = window->width();
                    widgeth = window->height();
                }
            }

            // Set the Widget's size

            int alignmentXoffset = 0;
            int alignmentYoffset = 0;
            if (i == 0 && h > widgeth)
                alignmentYoffset = h - widgeth;
            if (j == 0 && w > widgetw)
                alignmentXoffset = w - widgetw;
            QRect geom(availRect.x() + j *(w + spacing) + spacing + alignmentXoffset + xOffsetFromLastCol,
                       availRect.y() + i *(h + spacing) + spacing + alignmentYoffset,
                       widgetw, widgeth);
            geometryRects.append(geom);

            // Set the x offset for the next column
            if (alignmentXoffset == 0)
                xOffsetFromLastCol += widgetw - w;
            if (maxHeightInRow < widgeth)
                maxHeightInRow = widgeth;
        }
        maxRowHeights.append(maxHeightInRow);
    }

    int topOffset = 0;
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < columns; j++) {
            int pos = i * columns + j;
            if (pos >= windowlist.count())
                break;

            EffectWindow* window = windowlist[pos];
            QRect target = geometryRects[pos];
            target.setY(target.y() + topOffset);
            m_windowData[window].slot = pos;
            motionManager.moveWindow(window, target);

            //kDebug(1212) << "Window '" << window->caption() << "' gets moved to (" <<
            //        mWindowData[window].area.left() << "; " << mWindowData[window].area.right() <<
            //        "), scale: " << mWindowData[window].scale << endl;
        }
        if (maxRowHeights[i] - h > 0)
            topOffset += maxRowHeights[i] - h;
    }
}

void PresentWindowsEffect::calculateWindowTransformationsNatural(EffectWindowList windowlist, int screen,
        WindowMotionManager& motionManager)
{
    // If windows do not overlap they scale into nothingness, fix by resetting. To reproduce
    // just have a single window on a Xinerama screen or have two windows that do not touch.
    // TODO: Work out why this happens, is most likely a bug in the manager.
    foreach (EffectWindow * w, windowlist)
    if (motionManager.transformedGeometry(w) == w->geometry())
        motionManager.reset(w);

    if (windowlist.count() == 1) {
        // Just move the window to its original location to save time
        if (effects->clientArea(FullScreenArea, windowlist[0]).contains(windowlist[0]->geometry())) {
            motionManager.moveWindow(windowlist[0], windowlist[0]->geometry());
            return;
        }
    }

    // As we are using pseudo-random movement (See "slot") we need to make sure the list
    // is always sorted the same way no matter which window is currently active.
    qSort(windowlist);

    QRect area = effects->clientArea(ScreenArea, screen, effects->currentDesktop());
    if (m_showPanel)   // reserve space for the panel
        area = effects->clientArea(MaximizeArea, screen, effects->currentDesktop());
    QRect bounds = area;
    int direction = 0;
    QHash<EffectWindow*, QRect> targets;
    QHash<EffectWindow*, int> directions;
    foreach (EffectWindow * w, windowlist) {
        bounds = bounds.united(w->geometry());
        targets[w] = w->geometry();
        // Reuse the unused "slot" as a preferred direction attribute. This is used when the window
        // is on the edge of the screen to try to use as much screen real estate as possible.
        directions[w] = direction;
        direction++;
        if (direction == 4)
            direction = 0;
    }

    // Iterate over all windows, if two overlap push them apart _slightly_ as we try to
    // brute-force the most optimal positions over many iterations.
    bool overlap;
    do {
        overlap = false;
        foreach (EffectWindow * w, windowlist) {
            foreach (EffectWindow * e, windowlist) {
                if (w != e && targets[w].adjusted(-5, -5, 5, 5).intersects(
                            targets[e].adjusted(-5, -5, 5, 5))) {
                    overlap = true;

                    // Determine pushing direction
                    QPoint diff(targets[e].center() - targets[w].center());
                    // Prevent dividing by zero and non-movement
                    if (diff.x() == 0 && diff.y() == 0)
                        diff.setX(1);
                    // Try to keep screen aspect ratio
                    //if ( bounds.height() / bounds.width() > area.height() / area.width() )
                    //    diff.setY( diff.y() / 2 );
                    //else
                    //    diff.setX( diff.x() / 2 );
                    // Approximate a vector of between 10px and 20px in magnitude in the same direction
                    diff *= m_accuracy / double(diff.manhattanLength());
                    // Move both windows apart
                    targets[w].translate(-diff);
                    targets[e].translate(diff);

                    // Try to keep the bounding rect the same aspect as the screen so that more
                    // screen real estate is utilised. We do this by splitting the screen into nine
                    // equal sections, if the window center is in any of the corner sections pull the
                    // window towards the outer corner. If it is in any of the other edge sections
                    // alternate between each corner on that edge. We don't want to determine it
                    // randomly as it will not produce consistant locations when using the filter.
                    // Only move one window so we don't cause large amounts of unnecessary zooming
                    // in some situations. We need to do this even when expanding later just in case
                    // all windows are the same size.
                    // (We are using an old bounding rect for this, hopefully it doesn't matter)
                    int xSection = (targets[w].x() - bounds.x()) / (bounds.width() / 3);
                    int ySection = (targets[w].y() - bounds.y()) / (bounds.height() / 3);
                    diff = QPoint(0, 0);
                    if (xSection != 1 || ySection != 1) { // Remove this if you want the center to pull as well
                        if (xSection == 1)
                            xSection = (directions[w] / 2 ? 2 : 0);
                        if (ySection == 1)
                            ySection = (directions[w] % 2 ? 2 : 0);
                    }
                    if (xSection == 0 && ySection == 0)
                        diff = QPoint(bounds.topLeft() - targets[w].center());
                    if (xSection == 2 && ySection == 0)
                        diff = QPoint(bounds.topRight() - targets[w].center());
                    if (xSection == 2 && ySection == 2)
                        diff = QPoint(bounds.bottomRight() - targets[w].center());
                    if (xSection == 0 && ySection == 2)
                        diff = QPoint(bounds.bottomLeft() - targets[w].center());
                    if (diff.x() != 0 || diff.y() != 0) {
                        diff *= m_accuracy / double(diff.manhattanLength());
                        targets[w].translate(diff);
                    }

                    // Update bounding rect
                    bounds = bounds.united(targets[w]);
                    bounds = bounds.united(targets[e]);
                }
            }
        }
    } while (overlap);

    // Work out scaling by getting the most top-left and most bottom-right window coords.
    // The 20's and 10's are so that the windows don't touch the edge of the screen.
    double scale;
    if (bounds == area)
        scale = 1.0; // Don't add borders to the screen
    else if (area.width() / double(bounds.width()) < area.height() / double(bounds.height()))
        scale = (area.width() - 20) / double(bounds.width());
    else
        scale = (area.height() - 20) / double(bounds.height());
    // Make bounding rect fill the screen size for later steps
    bounds = QRect(
                 bounds.x() - (area.width() - 20 - bounds.width() * scale) / 2 - 10 / scale,
                 bounds.y() - (area.height() - 20 - bounds.height() * scale) / 2 - 10 / scale,
                 area.width() / scale,
                 area.height() / scale
             );

    // Move all windows back onto the screen and set their scale
    foreach (EffectWindow * w, windowlist)
    targets[w] = QRect(
                     (targets[w].x() - bounds.x()) * scale + area.x(),
                     (targets[w].y() - bounds.y()) * scale + area.y(),
                     targets[w].width() * scale,
                     targets[w].height() * scale
                 );

    // Try to fill the gaps by enlarging windows if they have the space
    if (m_fillGaps) {
        // Don't expand onto or over the border
        QRegion borderRegion(area.adjusted(-200, -200, 200, 200));
        borderRegion ^= area.adjusted(10 / scale, 10 / scale, -10 / scale, -10 / scale);

        bool moved;
        do {
            moved = false;
            foreach (EffectWindow * w, windowlist) {
                QRect oldRect;
                // This may cause some slight distortion if the windows are enlarged a large amount
                int widthDiff = m_accuracy;
                int heightDiff = heightForWidth(w, targets[w].width() + widthDiff) - targets[w].height();
                int xDiff = widthDiff / 2;  // Also move a bit in the direction of the enlarge, allows the
                int yDiff = heightDiff / 2; // center windows to be enlarged if there is gaps on the side.

                // Attempt enlarging to the top-right
                oldRect = targets[w];
                targets[w] = QRect(
                                 targets[w].x() + xDiff,
                                 targets[w].y() - yDiff - heightDiff,
                                 targets[w].width() + widthDiff,
                                 targets[w].height() + heightDiff
                             );
                if (isOverlappingAny(w, targets, borderRegion))
                    targets[w] = oldRect;
                else
                    moved = true;

                // Attempt enlarging to the bottom-right
                oldRect = targets[w];
                targets[w] = QRect(
                                 targets[w].x() + xDiff,
                                 targets[w].y() + yDiff,
                                 targets[w].width() + widthDiff,
                                 targets[w].height() + heightDiff
                             );
                if (isOverlappingAny(w, targets, borderRegion))
                    targets[w] = oldRect;
                else
                    moved = true;

                // Attempt enlarging to the bottom-left
                oldRect = targets[w];
                targets[w] = QRect(
                                 targets[w].x() - xDiff - widthDiff,
                                 targets[w].y() + yDiff,
                                 targets[w].width() + widthDiff,
                                 targets[w].height() + heightDiff
                             );
                if (isOverlappingAny(w, targets, borderRegion))
                    targets[w] = oldRect;
                else
                    moved = true;

                // Attempt enlarging to the top-left
                oldRect = targets[w];
                targets[w] = QRect(
                                 targets[w].x() - xDiff - widthDiff,
                                 targets[w].y() - yDiff - heightDiff,
                                 targets[w].width() + widthDiff,
                                 targets[w].height() + heightDiff
                             );
                if (isOverlappingAny(w, targets, borderRegion))
                    targets[w] = oldRect;
                else
                    moved = true;
            }
        } while (moved);

        // The expanding code above can actually enlarge windows over 1.0/2.0 scale, we don't like this
        // We can't add this to the loop above as it would cause a never-ending loop so we have to make
        // do with the less-than-optimal space usage with using this method.
        foreach (EffectWindow * w, windowlist) {
            double scale = targets[w].width() / double(w->width());
            if (scale > 2.0 || (scale > 1.0 && (w->width() > 300 || w->height() > 300))) {
                scale = (w->width() > 300 || w->height() > 300) ? 1.0 : 2.0;
                targets[w] = QRect(
                                 targets[w].center().x() - int(w->width() * scale) / 2,
                                 targets[w].center().y() - int(w->height() * scale) / 2,
                                 w->width() * scale,
                                 w->height() * scale);
            }
        }
    }

    // Notify the motion manager of the targets
    foreach (EffectWindow * w, windowlist)
    motionManager.moveWindow(w, targets[w]);
}

//-----------------------------------------------------------------------------
// Helper functions for window rearranging

void PresentWindowsEffect::assignSlots(EffectWindowList windowlist, const QRect &area, int columns, int rows)
{
    QVector< bool > taken;
    taken.fill(false, columns * rows);
    foreach (EffectWindow * w, windowlist)
    if (m_windowData[w].slot != -1)
        taken[ m_windowData[w].slot ] = true;
    int slotWidth = area.width() / columns;
    int slotHeight = area.height() / rows;
    foreach (EffectWindow * w, windowlist) {
        WindowData *wData = &m_windowData[w];
        if (wData->slot != -1)
            continue; // it already has a slot
        QPoint pos = w->geometry().center();
        if (pos.x() < area.left())
            pos.setX(area.left());
        if (pos.x() > area.right())
            pos.setX(area.right());
        if (pos.y() < area.top())
            pos.setY(area.top());
        if (pos.y() > area.bottom())
            pos.setY(area.bottom());
        int distance = INT_MAX;
        for (int x = 0; x < columns; x++)
            for (int y = 0; y < rows; y++) {
                int slot = x + y * columns;
                if (taken[slot])
                    continue;
                int xdiff = pos.x() - (area.x() + slotWidth * x + slotWidth / 2);
                int ydiff = pos.y() - (area.y() + slotHeight * y + slotHeight / 2);
                int dist = int(sqrt(double(xdiff * xdiff + ydiff * ydiff)));
                if (dist < distance) {
                    distance = dist;
                    wData->slot = slot;
                    wData->slot_distance = distance;
                }
            }
    }
}

void PresentWindowsEffect::getBestAssignments(EffectWindowList windowlist)
{
    foreach (EffectWindow * w1, windowlist) {
        WindowData *windowData1 = &m_windowData[w1];
        foreach (EffectWindow * w2, windowlist) {
            WindowData *windowData2 = &m_windowData[w2];
            if (w1 != w2 && windowData1->slot == windowData2->slot &&
                    windowData1->slot_distance >= windowData2->slot_distance)
                windowData1->slot = -1;
        }
    }
}

bool PresentWindowsEffect::isOverlappingAny(EffectWindow *w, const QHash<EffectWindow*, QRect> &targets, const QRegion &border)
{
    if (border.intersects(targets[w]))
        return true;
    // Is there a better way to do this?
    QHash<EffectWindow*, QRect>::const_iterator i;
    for (i = targets.constBegin(); i != targets.constEnd(); ++i) {
        if (w == i.key())
            continue;
        if (targets[w].adjusted(-5, -5, 5, 5).intersects(
                    i.value().adjusted(-5, -5, 5, 5)))
            return true;
    }
    return false;
}

//-----------------------------------------------------------------------------
// Activation

void PresentWindowsEffect::setActive(bool active, bool closingTab)
{
    if (effects->activeFullScreenEffect() && effects->activeFullScreenEffect() != this)
        return;
    if (m_activated == active)
        return;
    if (m_activated && m_tabBoxEnabled && !closingTab) {
        effects->closeTabBox();
        return;
    }
    m_activated = active;
    if (m_activated) {
        m_decalOpacity = 0.0;
        m_highlightedWindow = NULL;
        m_windowFilter.clear();

        m_closeView = new CloseWindowView();
        connect(m_closeView, SIGNAL(close()), SLOT(closeWindow()));

        // Add every single window to m_windowData (Just calling [w] creates it)
        foreach (EffectWindow * w, effects->stackingOrder()) {
            if (m_windowData.contains(w))    // Happens if we reactivate before the ending animation finishes
                continue;
            m_windowData[w].visible = isVisibleWindow(w);
            m_windowData[w].deleted = false;
            m_windowData[w].referenced = false;
            m_windowData[w].opacity = 0.0;
            if (w->isOnCurrentDesktop() && !w->isMinimized())
                m_windowData[w].opacity = 1.0;
            m_windowData[w].highlight = 1.0;
            m_windowData[w].textFrame = effects->effectFrame(EffectFrameUnstyled, false);
            QFont font;
            font.setBold(true);
            font.setPointSize(12);
            m_windowData[w].textFrame->setFont(font);
            m_windowData[w].iconFrame = effects->effectFrame(EffectFrameUnstyled, false);
            m_windowData[w].iconFrame->setAlignment(Qt::AlignRight | Qt::AlignBottom);
            m_windowData[w].iconFrame->setIcon(w->icon());
        }

        if (m_tabBoxEnabled) {
            foreach (EffectWindow * w, effects->currentTabBoxWindowList()) {
                if (!w)
                    continue;
                m_motionManager.manage(w);
                assert(m_windowData.contains(w));
                m_windowData[w].visible = effects->currentTabBoxWindowList().contains(w);
            }
            // Hide windows not in the list
            foreach (EffectWindow * w, effects->stackingOrder())
            m_windowData[w].visible = isVisibleWindow(w) &&
                                      (!isSelectableWindow(w) || effects->currentTabBoxWindowList().contains(w));
        } else {
            // Filter out special windows such as panels and taskbars
            foreach (EffectWindow * w, effects->stackingOrder())
            if (isSelectableWindow(w))
                m_motionManager.manage(w);
        }
        if (m_motionManager.managedWindows().isEmpty() ||
                ((m_motionManager.managedWindows().count() == 1) && m_motionManager.managedWindows().first()->isOnCurrentDesktop()  &&
                 (m_ignoreMinimized || !m_motionManager.managedWindows().first()->isMinimized()))) {
            // No point triggering if there is nothing to do
            m_activated = false;

            DataHash::iterator i = m_windowData.begin();
            while (i != m_windowData.end()) {
                delete i.value().textFrame;
                delete i.value().iconFrame;
                i++;
            }
            m_windowData.clear();

            m_motionManager.unmanageAll();
            return;
        }

        // Create temporary input window to catch mouse events
        m_input = effects->createFullScreenInputWindow(this, Qt::PointingHandCursor);
        m_hasKeyboardGrab = effects->grabKeyboard(this);
        effects->setActiveFullScreenEffect(this);

        m_gridSizes.clear();
        for (int i = 0; i < effects->numScreens(); i++)
            m_gridSizes.append(GridSize());

        rearrangeWindows();
        if (m_tabBoxEnabled)
            setHighlightedWindow(effects->currentTabBoxWindow());
        else
            setHighlightedWindow(effects->activeWindow());

        foreach (EffectWindow * w, effects->stackingOrder()) {
            if (w->isDock()) {
                w->setData(WindowForceBlurRole, QVariant(true));
            }
        }
    } else {
        // Fade in/out all windows
        EffectWindow *activeWindow = effects->activeWindow();
        if (m_tabBoxEnabled)
            activeWindow = effects->currentTabBoxWindow();
        int desktop = effects->currentDesktop();
        if (activeWindow && !activeWindow->isOnAllDesktops())
            desktop = activeWindow->desktop();
        foreach (EffectWindow * w, effects->stackingOrder()) {
            assert(m_windowData.contains(w));
            m_windowData[w].visible = (w->isOnDesktop(desktop) || w->isOnAllDesktops()) &&
                                      !w->isMinimized() && (w->visibleInClientGroup() || m_windowData[w].visible);
        }
        delete m_closeView;
        m_closeView = 0;

        // Move all windows back to their original position
        foreach (EffectWindow * w, m_motionManager.managedWindows())
        m_motionManager.moveWindow(w, w->geometry());
        m_filterFrame->free();
        m_windowFilter.clear();
        m_selectedWindows.clear();

        effects->destroyInputWindow(m_input);
        if (m_hasKeyboardGrab)
            effects->ungrabKeyboard();
        m_hasKeyboardGrab = false;

        // destroy atom on manager window
        if (m_managerWindow) {
            if (m_mode == ModeSelectedDesktop)
                m_managerWindow->deleteProperty(m_atomDesktop);
            else if (m_mode == ModeWindowGroup)
                m_managerWindow->deleteProperty(m_atomWindows);
            m_managerWindow = NULL;
        }
    }
    effects->addRepaintFull(); // Trigger the first repaint
}

//-----------------------------------------------------------------------------
// Filter box

void PresentWindowsEffect::updateFilterFrame()
{
    QRect area = effects->clientArea(ScreenArea, effects->activeScreen(), effects->currentDesktop());
    m_filterFrame->setPosition(QPoint(area.x() + area.width() / 2, area.y() + area.height() / 2));
    m_filterFrame->setText(i18n("Filter:\n%1", m_windowFilter));
}

//-----------------------------------------------------------------------------
// Helper functions

bool PresentWindowsEffect::isSelectableWindow(EffectWindow *w)
{
    if (w->isSpecialWindow() || w->isUtility())
        return false;
    if (w->isDeleted())
        return false;
    if (!w->acceptsFocus())
        return false;
    if (!w->visibleInClientGroup())
        return false;
    if (w->isSkipSwitcher())
        return false;
    if (w == effects->findWindow(m_closeView->winId()))
        return false;
    if (m_tabBoxEnabled)
        return true;
    if (m_ignoreMinimized && w->isMinimized())
        return false;
    switch(m_mode) {
    default:
    case ModeAllDesktops:
        return true;
    case ModeCurrentDesktop:
        return w->isOnCurrentDesktop();
    case ModeSelectedDesktop:
        return w->isOnDesktop(m_desktop);
    case ModeWindowGroup:
        return m_selectedWindows.contains(w);
    case ModeWindowClass:
        return m_class == w->windowClass();
    }
}

bool PresentWindowsEffect::isVisibleWindow(EffectWindow *w)
{
    if (w->isDesktop())
        return true;
    return isSelectableWindow(w);
}

void PresentWindowsEffect::setHighlightedWindow(EffectWindow *w)
{
    if (w == m_highlightedWindow || (w != NULL && !m_motionManager.isManaging(w)))
        return;

    m_closeView->hide();
    if (m_highlightedWindow)
        m_highlightedWindow->addRepaintFull(); // Trigger the first repaint
    m_highlightedWindow = w;
    if (m_highlightedWindow)
        m_highlightedWindow->addRepaintFull(); // Trigger the first repaint

    if (m_tabBoxEnabled && m_highlightedWindow)
        effects->setTabBoxWindow(w);
    updateCloseWindow();
}

void PresentWindowsEffect::updateCloseWindow()
{
    if (m_doNotCloseWindows)
        return;
    if (m_closeView->isVisible())
        return;
    if (!m_highlightedWindow) {
        m_closeView->hide();
        return;
    }
    const QRectF rect = m_motionManager.targetGeometry(m_highlightedWindow);
    m_closeView->setGeometry(rect.x() + rect.width() - m_closeView->sceneRect().width(), rect.y(),
                             m_closeView->sceneRect().width(), m_closeView->sceneRect().height());
    if (rect.contains(effects->cursorPos()))
        m_closeView->delayedShow();
    else
        m_closeView->hide();
}

void PresentWindowsEffect::closeWindow()
{
    if (m_highlightedWindow)
        m_highlightedWindow->closeWindow();
}

EffectWindow* PresentWindowsEffect::relativeWindow(EffectWindow *w, int xdiff, int ydiff, bool wrap) const
{
    // TODO: Is it possible to select hidden windows?
    EffectWindow* next;
    QRect area = effects->clientArea(FullArea, 0, effects->currentDesktop());
    QRect detectRect;

    // Detect across the width of the desktop
    if (xdiff != 0) {
        if (xdiff > 0) {
            // Detect right
            for (int i = 0; i < xdiff; i++) {
                QRectF wArea = m_motionManager.transformedGeometry(w);
                detectRect = QRect(0, wArea.y(), area.width(), wArea.height());
                next = NULL;
                foreach (EffectWindow * e, m_motionManager.managedWindows()) {
                    if (!m_windowData[e].visible)
                        continue;
                    QRectF eArea = m_motionManager.transformedGeometry(e);
                    if (eArea.intersects(detectRect) &&
                            eArea.x() > wArea.x()) {
                        if (next == NULL)
                            next = e;
                        else {
                            QRectF nArea = m_motionManager.transformedGeometry(next);
                            if (eArea.x() < nArea.x())
                                next = e;
                        }
                    }
                }
                if (next == NULL) {
                    if (wrap)   // We are at the right-most window, now get the left-most one to wrap
                        return relativeWindow(w, -1000, 0, false);
                    break; // No more windows to the right
                }
                w = next;
            }
            return w;
        } else {
            // Detect left
            for (int i = 0; i < -xdiff; i++) {
                QRectF wArea = m_motionManager.transformedGeometry(w);
                detectRect = QRect(0, wArea.y(), area.width(), wArea.height());
                next = NULL;
                foreach (EffectWindow * e, m_motionManager.managedWindows()) {
                    if (!m_windowData[e].visible)
                        continue;
                    QRectF eArea = m_motionManager.transformedGeometry(e);
                    if (eArea.intersects(detectRect) &&
                            eArea.x() + eArea.width() < wArea.x() + wArea.width()) {
                        if (next == NULL)
                            next = e;
                        else {
                            QRectF nArea = m_motionManager.transformedGeometry(next);
                            if (eArea.x() + eArea.width() > nArea.x() + nArea.width())
                                next = e;
                        }
                    }
                }
                if (next == NULL) {
                    if (wrap)   // We are at the left-most window, now get the right-most one to wrap
                        return relativeWindow(w, 1000, 0, false);
                    break; // No more windows to the left
                }
                w = next;
            }
            return w;
        }
    }

    // Detect across the height of the desktop
    if (ydiff != 0) {
        if (ydiff > 0) {
            // Detect down
            for (int i = 0; i < ydiff; i++) {
                QRectF wArea = m_motionManager.transformedGeometry(w);
                detectRect = QRect(wArea.x(), 0, wArea.width(), area.height());
                next = NULL;
                foreach (EffectWindow * e, m_motionManager.managedWindows()) {
                    if (!m_windowData[e].visible)
                        continue;
                    QRectF eArea = m_motionManager.transformedGeometry(e);
                    if (eArea.intersects(detectRect) &&
                            eArea.y() > wArea.y()) {
                        if (next == NULL)
                            next = e;
                        else {
                            QRectF nArea = m_motionManager.transformedGeometry(next);
                            if (eArea.y() < nArea.y())
                                next = e;
                        }
                    }
                }
                if (next == NULL) {
                    if (wrap)   // We are at the bottom-most window, now get the top-most one to wrap
                        return relativeWindow(w, 0, -1000, false);
                    break; // No more windows to the bottom
                }
                w = next;
            }
            return w;
        } else {
            // Detect up
            for (int i = 0; i < -ydiff; i++) {
                QRectF wArea = m_motionManager.transformedGeometry(w);
                detectRect = QRect(wArea.x(), 0, wArea.width(), area.height());
                next = NULL;
                foreach (EffectWindow * e, m_motionManager.managedWindows()) {
                    if (!m_windowData[e].visible)
                        continue;
                    QRectF eArea = m_motionManager.transformedGeometry(e);
                    if (eArea.intersects(detectRect) &&
                            eArea.y() + eArea.height() < wArea.y() + wArea.height()) {
                        if (next == NULL)
                            next = e;
                        else {
                            QRectF nArea = m_motionManager.transformedGeometry(next);
                            if (eArea.y() + eArea.height() > nArea.y() + nArea.height())
                                next = e;
                        }
                    }
                }
                if (next == NULL) {
                    if (wrap)   // We are at the top-most window, now get the bottom-most one to wrap
                        return relativeWindow(w, 0, 1000, false);
                    break; // No more windows to the top
                }
                w = next;
            }
            return w;
        }
    }

    abort(); // Should never get here
}

EffectWindow* PresentWindowsEffect::findFirstWindow() const
{
    EffectWindow *topLeft = NULL;
    QRectF topLeftGeometry;
    foreach (EffectWindow * w, m_motionManager.managedWindows()) {
        QRectF geometry = m_motionManager.transformedGeometry(w);
        if (m_windowData[w].visible == false)
            continue; // Not visible
        if (m_windowData[w].deleted)
            continue; // Window has been closed
        if (topLeft == NULL) {
            topLeft = w;
            topLeftGeometry = geometry;
        } else if (geometry.x() < topLeftGeometry.x() || geometry.y() < topLeftGeometry.y()) {
            topLeft = w;
            topLeftGeometry = geometry;
        }
    }
    return topLeft;
}

void PresentWindowsEffect::globalShortcutChanged(const QKeySequence& seq)
{
    shortcut = KShortcut(seq);
}

void PresentWindowsEffect::globalShortcutChangedAll(const QKeySequence& seq)
{
    shortcutAll = KShortcut(seq);
}

void PresentWindowsEffect::globalShortcutChangedClass(const QKeySequence& seq)
{
    shortcutClass = KShortcut(seq);
}

/************************************************
* CloseWindowView
************************************************/
CloseWindowView::CloseWindowView(QWidget* parent)
    : QGraphicsView(parent)
    , m_delayedShowTimer(new QTimer(this))
{
    setWindowFlags(Qt::X11BypassWindowManagerHint);
    setAttribute(Qt::WA_TranslucentBackground);
    setFrameShape(QFrame::NoFrame);
    QPalette pal = palette();
    pal.setColor(backgroundRole(), Qt::transparent);
    setPalette(pal);
    setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
    setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);

    // setup the scene
    QGraphicsScene* scene = new QGraphicsScene(this);
    m_closeButton = new Plasma::PushButton();
    m_closeButton->setIcon(KIcon("window-close"));
    scene->addItem(m_closeButton);
    connect(m_closeButton, SIGNAL(clicked()), SIGNAL(close()));

    QGraphicsLinearLayout *layout = new QGraphicsLinearLayout;
    layout->addItem(m_closeButton);

    QGraphicsWidget *form = new QGraphicsWidget;
    form->setLayout(layout);
    form->setGeometry(0, 0, 32, 32);
    scene->addItem(form);

    m_frame = new Plasma::FrameSvg(this);
    m_frame->setImagePath("dialogs/background");
    m_frame->setCacheAllRenderedFrames(true);
    m_frame->setEnabledBorders(Plasma::FrameSvg::AllBorders);
    qreal left, top, right, bottom;
    m_frame->getMargins(left, top, right, bottom);
    qreal width = form->size().width() + left + right;
    qreal height = form->size().height() + top + bottom;
    m_frame->resizeFrame(QSizeF(width, height));
    Plasma::WindowEffects::enableBlurBehind(winId(), true, m_frame->mask());
    Plasma::WindowEffects::overrideShadow(winId(), true);
    form->setPos(left, top);
    scene->setSceneRect(QRectF(QPointF(0, 0), QSizeF(width, height)));
    setScene(scene);

    // setup the timer
    m_delayedShowTimer->setSingleShot(true);
    m_delayedShowTimer->setInterval(500);
    connect(m_delayedShowTimer, SIGNAL(timeout()), SLOT(show()));
}

void CloseWindowView::windowInputMouseEvent(QMouseEvent* e)
{
    if (m_delayedShowTimer->isActive())
        return;
    if (e->type() == QEvent::MouseMove) {
        mouseMoveEvent(e);
    } else if (e->type() == QEvent::MouseButtonPress) {
        mousePressEvent(e);
    } else if (e->type() == QEvent::MouseButtonDblClick) {
        mouseDoubleClickEvent(e);
    } else if (e->type() == QEvent::MouseButtonRelease) {
        mouseReleaseEvent(e);
    }
}

void CloseWindowView::drawBackground(QPainter* painter, const QRectF& rect)
{
    Q_UNUSED(rect)
    painter->setRenderHint(QPainter::Antialiasing);
    m_frame->paintFrame(painter);
}

void CloseWindowView::hide()
{
    m_delayedShowTimer->stop();
    QWidget::hide();
}

void CloseWindowView::delayedShow()
{
    if (isVisible() || m_delayedShowTimer->isActive())
        return;
    m_delayedShowTimer->start();
}


} // namespace

#include "presentwindows.moc"