diff --git a/kde-base/kdebase/Manifest b/kde-base/kdebase/Manifest
index 6ad54ed..e3095da 100644
--- a/kde-base/kdebase/Manifest
+++ b/kde-base/kdebase/Manifest
@@ -1,17 +1,8 @@
------BEGIN PGP SIGNED MESSAGE-----
-Hash: SHA1
-
 AUX agent-shutdown.sh 320 RMD160 aca937be56a69b274c0756eca91456e00a91442b SHA1 65ce34500d82b2de0168b38058c9b198913d6a21 SHA256 1e53f9fc9155b38d8bb0ac36c8564898dbabc33f9ecaca933216a0ace4e30b33
 AUX agent-startup.sh 550 RMD160 62b38cdc14970db4f8ae09c90d7bc2a388255301 SHA1 86efb56cb6c746fe069e964f5e2e3f521d782a0a SHA256 f43a591922dd5a2649cad7b3d42827ee56aa21c09564e5eebb0cf7fa2eeb5fc4
 AUX gentoo-startkde.patch 2222 RMD160 7646dd205263f4e52cfbc963eaabb26208eb59c1 SHA1 b6d84cb5677061a76b3248a90335d7fc1b49cbb0 SHA256 06926741de14219d9ca8721ef742c585a7c2e38c18964554ca7302c9b2ef5d99
 AUX kdebase-9999.4-pam-optional.patch 979 RMD160 abdb7293c02507dfd0a032e72f3e449405b6d8a0 SHA1 33e2f936f0548f9b19fe541c0f71db06f9daaf63 SHA256 efa4e0132687dbaa68ab5c8a5911c4a08b5d4e9eb4d2a04879f765b8e44ba9ea
-EBUILD kdebase-9999.4.ebuild 8774 RMD160 9151d03eaf8383a06eba090d1428a5a11459a321 SHA1 110a4bd4c77e38841425d44cd4f677f82898e819 SHA256 20f44bf651e0f8c98d3614a5a25461a08bf789e69f4389afd96c367d172099bd
+AUX kwin-wobblywindows.patch 34362 RMD160 01f2d03b7e462e3b80e55d9c134c9a17d9195bcb SHA1 e6cbe484b9afc9ba0b4e16418a2985c55d3dc775 SHA256 74f78f212ad6b4bb0bf97bfef66ed518009c14df00108875bdc72c62e2414ca9
+EBUILD kdebase-9999.4.ebuild 8812 RMD160 a0e9c9952db510b726114503a2781fa8c7c6023a SHA1 b44817b7cd80393d7c5c9a8ed62d49c47318540a SHA256 3da9c3acb8f83797bfe5efd3d309fcfc83fcb2db495e2896873b2f6a8a420454
 MISC ChangeLog 7903 RMD160 563d75ce5c6fa7f08974c2109176f954b0b721d1 SHA1 4aa27ff5595cc7025414eb107bf1720425686dc7 SHA256 46ba224190b224cb87f0813fcf26d7171cb61999153f2d0fad1982ec1df56ceb
 MISC metadata.xml 156 RMD160 ecce3b981f150c45ae1e84e2d208e678d6124259 SHA1 b64f7c0b4e5db816d82ad19848f72118af129d35 SHA256 2f4da28506b9d4185f320f67a6191d30c7a921217ed4447ed46ea0bc4aefc79a
------BEGIN PGP SIGNATURE-----
-Version: GnuPG v2.0.7 (GNU/Linux)
-
-iD8DBQFHpi99fxJ68Jl1NeERApOVAKC2/PITr5f/GmnXakrgeA5zAM4XyQCdHr7O
-Ht3wKHYCTyy2ftOSqD4PJyU=
-=eZZK
------END PGP SIGNATURE-----
diff --git a/kde-base/kdebase/files/kwin-wobblywindows.patch b/kde-base/kdebase/files/kwin-wobblywindows.patch
new file mode 100644
index 0000000..b186d00
--- /dev/null
+++ b/kde-base/kdebase/files/kwin-wobblywindows.patch
@@ -0,0 +1,1153 @@
+--- a/kdebase/workspace/kwin/effects/test/CMakeLists.txt	2008-02-10 23:51:00.000000000 +0000
++++ b/kdebase/workspace/kwin/effects/test/CMakeLists.txt	2008-02-10 17:12:00.000000000 +0000
+@@ -42,13 +42,15 @@
+         demo_liquid.cpp
+         demo_showpicture.cpp
+         demo_wavywindows.cpp
+-        test_fbo.cpp
++        demo_wobblywindows.cpp
++	test_fbo.cpp
+         )
+ 
+     install( FILES
+         demo_liquid.desktop
+         demo_showpicture.desktop
+         demo_wavywindows.desktop
++	demo_wobblywindows.desktop
+         test_fbo.desktop
+         DESTINATION ${SERVICES_INSTALL_DIR}/kwin )
+ 
+--- a/kdebase/workspace/kwin/effects/test/demo_wobblywindows.cpp	1970-01-01 01:00:00.000000000 +0100
++++ b/kdebase/workspace/kwin/effects/test/demo_wobblywindows.cpp	2008-02-10 16:51:19.000000000 +0000
+@@ -0,0 +1,987 @@
++/*****************************************************************
++ KWin - the KDE window manager
++ This file is part of the KDE project.
++
++Copyright (C) 2007
++
++You can Freely distribute this program under the GNU General Public
++License. See the file "COPYING" for the exact licensing terms.
++******************************************************************/
++
++
++#include "demo_wobblywindows.h"
++
++#include <kdebug.h>
++#include <math.h>
++
++
++namespace KWin
++{
++
++KWIN_EFFECT(demo_wobblywindows, WobblyWindowsEffect)
++
++WobblyWindowsEffect::WobblyWindowsEffect()
++{
++    raideur = 0.5;
++    velocityThreshold = 0.5;
++    accelerationThreshold = 0.1;
++    amortissement = 0.93;
++    move_factor = 0.01;
++
++    xTesselation = 20.0;
++    yTesselation = 20.0;
++
++    squareRootMasterAcceleration = false;
++
++    velFilter = FourRingLinearMean;
++    accFilter = NoFilter; //FourRingLinearMean;
++}
++
++WobblyWindowsEffect::~WobblyWindowsEffect()
++{
++    if (windows.empty())
++    {
++        // we should be empty at this point...
++        // emit a warning and clean the list.
++        kDebug() << "Windows list not empty. Left items : " << windows.count();
++        QHash< const EffectWindow*,  WindowWobblyInfos >::iterator i;
++        for (i = windows.begin(); i != windows.end(); ++i)
++        {
++            freeWobblyInfo(i.value());
++        }
++    }
++}
++void WobblyWindowsEffect::setVelocityThreshold(qreal velocityThreshold)
++{
++    this->velocityThreshold = velocityThreshold;
++}
++
++void WobblyWindowsEffect::setMoveFactor(qreal factor)
++{
++    move_factor = factor;
++}
++
++void WobblyWindowsEffect::setRaideur(qreal raideur)
++{
++    this->raideur = raideur;
++}
++
++void WobblyWindowsEffect::setVelocityFilter(GridFilter filter)
++{
++    velFilter = filter;
++}
++
++void WobblyWindowsEffect::setAccelerationFilter(GridFilter filter)
++{
++    accFilter = filter;
++}
++
++WobblyWindowsEffect::GridFilter WobblyWindowsEffect::velocityFilter() const
++{
++    return velFilter;
++}
++
++WobblyWindowsEffect::GridFilter WobblyWindowsEffect::accelerationFilter() const
++{
++    return accFilter;
++}
++
++void WobblyWindowsEffect::setAmortissement(qreal amortissement)
++{
++    this->amortissement = amortissement;
++}
++
++void WobblyWindowsEffect::prePaintScreen(ScreenPrePaintData& data, int time)
++{
++    // We need to mark the screen windows as transformed. Otherwise the whole
++    // screen won't be repainted, resulting in artefacts.
++    // Could we just set a subset of the screen to be repainted ?
++    if (windows.count() != 0)
++    {
++        data.mask |= PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS;
++    }
++
++    effects->prePaintScreen(data, time);
++}
++const qreal maxTime = 10.0;
++void WobblyWindowsEffect::prePaintWindow(EffectWindow* w, WindowPrePaintData& data, int time)
++{
++    if (windows.contains(w))
++    {
++        data.setTransformed();
++        data.quads = data.quads.makeGrid((xTesselation>yTesselation) ?
++                                        (w->geometry().width() / xTesselation) :
++                                        (w->geometry().height() / yTesselation));
++        bool stop = false;
++        qreal updateTime = time;
++        //kDebug() << "time " << updateTime;
++        while (!stop && (updateTime > maxTime))
++        {
++            // ouch, I get a deadlock with this debug enabled
++            //kDebug() << "loop time " << updateTime << " " << time;
++            stop = !updateWindowWobblyDatas(w, maxTime);
++            updateTime -= maxTime;
++        }
++        if (!stop && updateTime > 0)
++        {
++            updateWindowWobblyDatas(w, updateTime);
++        }
++    }
++
++    effects->prePaintWindow(w, data, time);
++}
++
++void WobblyWindowsEffect::paintWindow(EffectWindow* w, int mask, QRegion region, WindowPaintData& data)
++{
++    if(windows.contains(w))
++    {
++        WindowWobblyInfos& wwi = windows[w];
++        int tx = w->geometry().x();
++        int ty = w->geometry().y();
++        for (int i = 0; i < data.quads.count(); ++i)
++        {
++            for(int j = 0; j < 4; ++j)
++            {
++                WindowVertex& v = data.quads[i][j];
++                Pair oldPos = {tx + v.x(), ty + v.y()};
++                Pair newPos = computeBezierPoint(wwi, oldPos);
++                v.move(newPos.x - tx, newPos.y - ty);
++            }
++        }
++    }
++
++    // Call the next effect.
++    effects->paintWindow(w, mask, region, data);
++}
++
++void WobblyWindowsEffect::postPaintScreen()
++{
++    if (!windows.isEmpty())
++    {
++        // Repaint the workspace so that everything would be repainted next time
++        effects->addRepaintFull();
++    }
++
++    // Call the next effect.
++    effects->postPaintScreen();
++}
++
++void WobblyWindowsEffect::windowUserMovedResized(EffectWindow* w, bool first, bool last)
++{
++    if (first && !w->isSpecialWindow())
++    {
++        if (!windows.contains(w))
++        {
++            WindowWobblyInfos new_wwi;
++            initWobblyInfo(new_wwi, w->geometry());
++            windows[w] = new_wwi;
++        }
++
++        WindowWobblyInfos& wwi = windows[w];
++        wwi.onConstrain = true;
++        const QRectF& rect = w->geometry();
++
++        qreal x_increment = rect.width() / (wwi.width-1.0);
++        qreal y_increment = rect.height() / (wwi.height-1.0);
++
++        Pair picked = {cursorPos().x(), cursorPos().y()};
++        //{ rect.x() + (rect.width()/2.0), rect.y() + (rect.height()/10.0) }; // TODO: use real picked point.
++        int indx = (picked.x - rect.x()) / x_increment;
++        int indy = (picked.y - rect.y()) / y_increment;
++        wwi.mPickedPointIndex = indy*wwi.width + indx;
++        if (wwi.mPickedPointIndex < 0)
++        {
++            kDebug() << "Picked index == " << wwi.mPickedPointIndex << " with (" << cursorPos().x() << "," << cursorPos().y() << ")";
++            wwi.mPickedPointIndex = 0;
++        }
++        else if (static_cast<unsigned int>(wwi.mPickedPointIndex) > wwi.count - 1)
++        {
++            kDebug() << "Picked index == " << wwi.mPickedPointIndex << " with (" << cursorPos().x() << "," << cursorPos().y() << ")";
++            wwi.mPickedPointIndex = wwi.count - 1;
++        }
++        //kDebug() << "Original Picked point -- x : " << picked.x << " - y : " << picked.y;
++        wwi.mPickedPointTranslation.x = wwi.position[wwi.mPickedPointIndex].x - picked.x;
++        wwi.mPickedPointTranslation.y = wwi.position[wwi.mPickedPointIndex].y - picked.y;
++    }
++    else if (last)
++    {
++        if (windows.contains(w))
++        {
++            WindowWobblyInfos& wwi = windows[w];
++            wwi.onConstrain = false;
++            wwi.mDestination.x = cursorPos().x();
++            wwi.mDestination.y = cursorPos().y();
++        }
++    }
++}
++
++void WobblyWindowsEffect::windowClosed(EffectWindow* w)
++{
++    if(windows.contains(w))
++    {
++        WindowWobblyInfos& wwi = windows[w];
++        freeWobblyInfo(wwi);
++        windows.remove(w);
++    }
++}
++
++void WobblyWindowsEffect::initWobblyInfo(WindowWobblyInfos& wwi, QRect geometry) const
++{
++    wwi.count = 4*4;
++    wwi.width = 4;
++    wwi.height = 4;
++
++    wwi.bezierWidth = xTesselation;
++    wwi.bezierHeight = yTesselation;
++    wwi.bezierCount = xTesselation * yTesselation;
++
++    wwi.origin = new Pair[wwi.count];
++    wwi.position = new Pair[wwi.count];
++    wwi.velocity = new Pair[wwi.count];
++    wwi.acceleration = new Pair[wwi.count];
++    wwi.buffer = new Pair[wwi.count];
++    wwi.bezierSurface = new Pair[wwi.bezierCount];
++
++    wwi.onConstrain = true;
++
++    qreal x = geometry.x(), y = geometry.y();
++    qreal width = geometry.width(), height = geometry.height();
++
++    Pair initValue = {x, y};
++    static const Pair nullPair = {0.0, 0.0};
++
++    qreal x_increment = width / (wwi.width-1.0);
++    qreal y_increment = height / (wwi.height-1.0);
++
++    for (unsigned int j=0; j<4; ++j)
++    {
++        for (unsigned int i=0; i<4; ++i)
++        {
++            unsigned int idx = j*4 + i;
++            wwi.origin[idx] = initValue;
++            wwi.position[idx] = initValue;
++            wwi.velocity[idx] = nullPair;
++            if (i != 4-2) // x grid count - 2, i.e. not the last point
++            {
++                initValue.x += x_increment;
++            }
++            else
++            {
++                initValue.x = width + x;
++            }
++            initValue.x = initValue.x;
++        }
++        initValue.x = x;
++        initValue.x = initValue.x;
++        if (j != 4-2) // y grid count - 2, i.e. not the last point
++        {
++            initValue.y += y_increment;
++        }
++        else
++        {
++            initValue.y = height + y;
++        }
++        initValue.y = initValue.y;
++    }
++}
++
++void WobblyWindowsEffect::freeWobblyInfo(WindowWobblyInfos& wwi) const
++{
++    delete wwi.origin;
++    delete wwi.position;
++    delete wwi.velocity;
++    delete wwi.acceleration;
++    delete wwi.buffer;
++
++    delete wwi.bezierSurface;
++}
++
++#define USE_ASSERT
++
++#ifdef USE_ASSERT
++#define ASSERT1 assert
++#else
++#define ASSERT1
++#endif
++
++WobblyWindowsEffect::Pair WobblyWindowsEffect::computeBezierPoint(const WindowWobblyInfos& wwi, Pair point) const
++{
++    // compute the input value
++    Pair topleft = wwi.origin[0];
++    Pair bottomright = wwi.origin[wwi.count-1];
++
++    ASSERT1(point.x >= topleft.x);
++    ASSERT1(point.y >= topleft.y);
++    ASSERT1(point.x <= bottomright.x);
++    ASSERT1(point.y <= bottomright.y);
++
++    qreal tx = (point.x - topleft.x) / (bottomright.x - topleft.x);
++    qreal ty = (point.y - topleft.y) / (bottomright.y - topleft.y);
++
++    ASSERT1(tx >= 0);
++    ASSERT1(tx <= 1);
++    ASSERT1(ty >= 0);
++    ASSERT1(ty <= 1);
++
++    // compute polinomial coeff
++
++    qreal px[4];
++    px[0] = (1-tx)*(1-tx)*(1-tx);
++    px[1] = 3*(1-tx)*(1-tx)*tx;
++    px[2] = 3*(1-tx)*tx*tx;
++    px[3] = tx*tx*tx;
++
++    qreal py[4];
++    py[0] = (1-ty)*(1-ty)*(1-ty);
++    py[1] = 3*(1-ty)*(1-ty)*ty;
++    py[2] = 3*(1-ty)*ty*ty;
++    py[3] = ty*ty*ty;
++
++    Pair res = {0.0, 0.0};
++
++    for (unsigned int j = 0; j < 4; ++j)
++    {
++        for (unsigned int i = 0; i < 4; ++i)
++        {
++            // this assume the grid is 4*4
++            res.x += px[i] * py[j] * wwi.position[i + j * wwi.width].x;
++            res.y += px[i] * py[j] * wwi.position[i + j * wwi.width].y;
++        }
++    }
++
++    return res;
++}
++
++bool WobblyWindowsEffect::updateWindowWobblyDatas(EffectWindow* w, qreal time)
++{
++    // it is safer for now, I need to find safe constraints on the model's
++    // parameters to ensure it doesn't diverge with too high time steps
++    //kDebug() << "Time elapsed : " << mTimeElapsed;
++    //mTimeElapsed = 1;
++
++    const QRectF& rect = w->geometry();
++    WindowWobblyInfos& wwi = windows[w];
++
++    qreal x_length = rect.width() / (wwi.width-1.0);
++    qreal y_length = rect.height() / (wwi.height-1.0);
++
++    Pair picked;
++    if (wwi.onConstrain)
++    {
++        picked.x = cursorPos().x();
++        picked.y = cursorPos().y();
++    }
++    else
++    {
++        picked = wwi.mDestination;
++    }
++
++    Pair pickedTranslation = wwi.mPickedPointTranslation;
++    picked.x += pickedTranslation.x;
++    picked.y += pickedTranslation.y;
++    Pair on_grid_picked = wwi.position[wwi.mPickedPointIndex];
++    Pair move = {picked.x - on_grid_picked.x, picked.y - on_grid_picked.y};
++
++    //kDebug() << "Picked point -- x : " << picked.x << " - y : " << picked.y;
++    //kDebug() << "On grid point -- x : " << on_grid_picked.x << " - y : " << on_grid_picked.y;
++    //kDebug() << "Move -- x : " << move.x << " - y : " << move.y;
++
++    //kDebug() << "time " << time;
++    Pair origine = {rect.x(), rect.y()};
++
++    //std::cout << "increment x " << x_length << " // y" <<  y_length << std::endl;
++    for (unsigned int j=0; j<wwi.height; ++j)
++    {
++        for (unsigned int i=0; i<wwi.width; ++i)
++        {
++            wwi.origin[wwi.width*j + i] = origine;
++            if (i != wwi.width-2)
++            {
++                origine.x += x_length;
++            }
++            else
++            {
++                origine.x = rect.width() + rect.x();
++            }
++         }
++        //std::cout << "valur for " << j << " : " <<  origine.y << std::endl;
++        origine.x = rect.x();
++        if (j != wwi.height-2)
++        {
++            origine.y += y_length;
++        }
++        else
++        {
++            origine.y = rect.height() + rect.y();
++        }
++    }
++
++
++    Pair acc = {move.x*raideur, move.y*raideur};
++    if (squareRootMasterAcceleration)
++    {
++        if (acc.x < 0.0)
++        {
++            acc.x = -sqrt(-acc.x);
++        }
++        else
++        {
++            acc.x = sqrt(acc.x);
++        }
++
++        if (acc.y < 0.0)
++        {
++            acc.y = -sqrt(-acc.y);
++        }
++        else
++        {
++            acc.y = sqrt(acc.y);
++        }
++    }
++    //kDebug() << "Master acceleration -- x : " << acc.x << " - y : " << acc.y;
++
++    unsigned int fixedIndex = wwi.mPickedPointIndex;
++    Pair neibourgs[4];
++    Pair acceleration;
++
++    qreal acc_sum = 0.0;
++    qreal vel_sum = 0.0;
++
++    // compute acceleration, velocity and position for each point
++
++    // for corners
++
++    // top-left
++
++    // acceleration is acc
++    if (fixedIndex == 0)
++    {
++        wwi.acceleration[0] = acc;
++    }
++    else
++    {
++        Pair& pos = wwi.position[0];
++        neibourgs[0] = wwi.position[1];
++        neibourgs[1] = wwi.position[wwi.width];
++
++        acceleration.x = ((neibourgs[0].x - pos.x) - x_length)*raideur + (neibourgs[1].x - pos.x)*raideur;
++        acceleration.y = ((neibourgs[1].y - pos.y) - y_length)*raideur + (neibourgs[0].y - pos.y)*raideur;
++
++        acceleration.x /= 2;
++        acceleration.y /= 2;
++
++        wwi.acceleration[0] = acceleration;
++    }
++
++    // top-right
++
++    // acceleration is acc
++    if (fixedIndex == wwi.width-1)
++    {
++        wwi.acceleration[wwi.width-1] = acc;
++    }
++    else
++    {
++        Pair& pos = wwi.position[wwi.width-1];
++        neibourgs[0] = wwi.position[wwi.width-2];
++        neibourgs[1] = wwi.position[2*wwi.width-1];
++
++        acceleration.x = (x_length - (pos.x - neibourgs[0].x))*raideur + (neibourgs[1].x - pos.x)*raideur;
++        acceleration.y = ((neibourgs[1].y - pos.y) - y_length)*raideur + (neibourgs[0].y - pos.y)*raideur;
++
++        acceleration.x /= 2;
++        acceleration.y /= 2;
++
++        wwi.acceleration[wwi.width-1] = acceleration;
++    }
++
++    // bottom-left
++
++    // acceleration is acc
++    if (fixedIndex == wwi.width*(wwi.height-1))
++    {
++        wwi.acceleration[wwi.width*(wwi.height-1)] = acc;
++    }
++    else
++    {
++        Pair& pos = wwi.position[wwi.width*(wwi.height-1)];
++        neibourgs[0] = wwi.position[wwi.width*(wwi.height-1)+1];
++        neibourgs[1] = wwi.position[wwi.width*(wwi.height-2)];
++
++        acceleration.x = ((neibourgs[0].x - pos.x) - x_length)*raideur + (neibourgs[1].x - pos.x)*raideur;
++        acceleration.y = (y_length - (pos.y - neibourgs[1].y))*raideur + (neibourgs[0].y - pos.y)*raideur;
++
++        acceleration.x /= 2;
++        acceleration.y /= 2;
++
++        wwi.acceleration[wwi.width*(wwi.height-1)] = acceleration;
++    }
++
++    // bottom-right
++
++    // acceleration is acc
++    if (fixedIndex == wwi.count-1)
++    {
++        wwi.acceleration[wwi.count-1] = acc;
++    }
++    else
++    {
++        Pair& pos = wwi.position[wwi.count-1];
++        neibourgs[0] = wwi.position[wwi.count-2];
++        neibourgs[1] = wwi.position[wwi.width*(wwi.height-1)-1];
++
++        acceleration.x = (x_length - (pos.x - neibourgs[0].x))*raideur + (neibourgs[1].x - pos.x)*raideur;
++        acceleration.y = (y_length - (pos.y - neibourgs[1].y))*raideur + (neibourgs[0].y - pos.y)*raideur;
++
++        acceleration.x /= 2;
++        acceleration.y /= 2;
++
++        wwi.acceleration[wwi.count-1] = acceleration;
++    }
++
++
++    // for borders
++
++    // top border
++    for (unsigned int i=1; i<wwi.width-1; ++i)
++    {
++        // acceleration is acc
++        if (fixedIndex == i)
++        {
++            wwi.acceleration[i] = acc;
++        }
++        else
++        {
++            Pair& pos = wwi.position[i];
++            neibourgs[0] = wwi.position[i-1];
++            neibourgs[1] = wwi.position[i+1];
++            neibourgs[2] = wwi.position[i+wwi.width];
++
++            acceleration.x = (x_length - (pos.x - neibourgs[0].x))*raideur + ((neibourgs[1].x - pos.x) - x_length)*raideur + (neibourgs[2].x - pos.x)*raideur;
++            acceleration.y = ((neibourgs[2].y - pos.y) - y_length)*raideur + (neibourgs[0].y - pos.y)*raideur + (neibourgs[1].y - pos.y)*raideur;
++
++            acceleration.x /= 3;
++            acceleration.y /= 3;
++
++            wwi.acceleration[i] = acceleration;
++        }
++    }
++
++    // bottom border
++    for (unsigned int i=wwi.width*(wwi.height-1)+1; i<wwi.count-1; ++i)
++    {
++        // acceleration is acc
++        if (fixedIndex == i)
++        {
++            wwi.acceleration[i] = acc;
++        }
++        else
++        {
++            Pair& pos = wwi.position[i];
++            neibourgs[0] = wwi.position[i-1];
++            neibourgs[1] = wwi.position[i+1];
++            neibourgs[2] = wwi.position[i-wwi.width];
++
++            acceleration.x = (x_length - (pos.x - neibourgs[0].x))*raideur + ((neibourgs[1].x - pos.x) - x_length)*raideur + (neibourgs[2].x - pos.x)*raideur;
++            acceleration.y = (y_length - (pos.y - neibourgs[2].y))*raideur + (neibourgs[0].y - pos.y)*raideur + (neibourgs[1].y - pos.y)*raideur;
++
++            acceleration.x /= 3;
++            acceleration.y /= 3;
++
++            wwi.acceleration[i] = acceleration;
++        }
++    }
++
++    // left border
++    for (unsigned int i=wwi.width; i<wwi.width*(wwi.height-1); i+=wwi.width)
++    {
++        // acceleration is acc
++        if (fixedIndex == i)
++        {
++            wwi.acceleration[i] = acc;
++        }
++        else
++        {
++            Pair& pos = wwi.position[i];
++            neibourgs[0] = wwi.position[i+1];
++            neibourgs[1] = wwi.position[i-wwi.width];
++            neibourgs[2] = wwi.position[i+wwi.width];
++
++            acceleration.x = ((neibourgs[0].x - pos.x) - x_length)*raideur + (neibourgs[1].x - pos.x)*raideur + (neibourgs[2].x - pos.x)*raideur;
++            acceleration.y = (y_length - (pos.y - neibourgs[1].y))*raideur + ((neibourgs[2].y - pos.y) - y_length)*raideur + (neibourgs[0].y - pos.y)*raideur;
++
++            acceleration.x /= 3;
++            acceleration.y /= 3;
++
++            wwi.acceleration[i] = acceleration;
++        }
++    }
++
++    // right border
++    for (unsigned int i=2*wwi.width-1; i<wwi.count-1; i+=wwi.width)
++    {
++        // acceleration is acc
++        if (fixedIndex == i)
++        {
++            wwi.acceleration[i] = acc;
++        }
++        else
++        {
++            Pair& pos = wwi.position[i];
++            neibourgs[0] = wwi.position[i-1];
++            neibourgs[1] = wwi.position[i-wwi.width];
++            neibourgs[2] = wwi.position[i+wwi.width];
++
++            acceleration.x = (x_length - (pos.x - neibourgs[0].x))*raideur + (neibourgs[1].x - pos.x)*raideur + (neibourgs[2].x - pos.x)*raideur;
++            acceleration.y = (y_length - (pos.y - neibourgs[1].y))*raideur + ((neibourgs[2].y - pos.y) - y_length)*raideur + (neibourgs[0].y - pos.y)*raideur;
++
++            acceleration.x /= 3;
++            acceleration.y /= 3;
++
++            wwi.acceleration[i] = acceleration;
++        }
++    }
++
++    // for the inner points
++    for (unsigned int j=1; j<wwi.height-1; ++j)
++    {
++        for (unsigned int i=1; i<wwi.width-1; ++i)
++        {
++            unsigned int index = i+j*wwi.width;
++
++            // acceleration is acc
++            if (fixedIndex == index)
++            {
++                wwi.acceleration[index] = acc;
++            }
++            else
++            {
++                Pair& pos = wwi.position[index];
++                neibourgs[0] = wwi.position[index-1];
++                neibourgs[1] = wwi.position[index+1];
++                neibourgs[2] = wwi.position[index-wwi.width];
++                neibourgs[3] = wwi.position[index+wwi.width];
++
++                acceleration.x = ((neibourgs[0].x - pos.x) - x_length)*raideur +
++                                 (x_length - (pos.x - neibourgs[1].x))*raideur +
++                                 (neibourgs[2].x - pos.x)*raideur +
++                                 (neibourgs[3].x - pos.x)*raideur;
++                acceleration.y = (y_length - (pos.y - neibourgs[2].y))*raideur +
++                                 ((neibourgs[3].y - pos.y) - y_length)*raideur +
++                                 (neibourgs[0].y - pos.y)*raideur +
++                                 (neibourgs[1].y - pos.y)*raideur;
++
++                acceleration.x /= 4;
++                acceleration.y /= 4;
++
++                wwi.acceleration[index] = acceleration;
++            }
++        }
++    }
++
++    switch (accFilter)
++    {
++    case NoFilter:
++        break;
++
++    case FourRingLinearMean:
++        fourRingLinearMean(&wwi.acceleration, wwi);
++        break;
++
++    case MeanWithMean:
++        meanWithMean(&wwi.acceleration, wwi);
++        break;
++
++    case MeanWithMedian:
++        meanWithMedian(&wwi.acceleration, wwi);
++        break;
++
++    default:
++        ASSERT1(false);
++    }
++
++
++    // compute the new velocity of each vertex.
++    for (unsigned int i = 0; i < wwi.count; ++i)
++    {
++        Pair acc = wwi.acceleration[i];
++        if (fabs(acc.x) < accelerationThreshold)
++        {
++            acc.x = 0;
++        }
++        if (fabs(acc.y) < accelerationThreshold)
++        {
++            acc.y = 0;
++        }
++
++        Pair& vel = wwi.velocity[i];
++        float vit;
++        vit = acc.x*time + vel.x*amortissement;
++        if (fabs(vit) < velocityThreshold)
++        {
++            vit = 0.0;
++        }
++        vel.x = vit;
++
++        vit = acc.y*time + vel.y*amortissement;
++        if (fabs(vit) < velocityThreshold)
++        {
++            vit = 0.0;
++        }
++        vel.y = vit;
++
++        acc_sum += fabs(acc.x) + fabs(acc.y);
++    }
++
++
++    switch (velFilter)
++    {
++    case NoFilter:
++        break;
++
++    case FourRingLinearMean:
++        fourRingLinearMean(&wwi.velocity, wwi);
++        break;
++
++    case MeanWithMean:
++        meanWithMean(&wwi.velocity, wwi);
++        break;
++
++    case MeanWithMedian:
++        meanWithMedian(&wwi.velocity, wwi);
++        break;
++
++    default:
++        ASSERT1(false);
++    }
++
++    // compute the new pos of each vertex.
++    for (unsigned int i = 0; i < wwi.count; ++i)
++    {
++        Pair& pos = wwi.position[i];
++        Pair& vel = wwi.velocity[i];
++
++        pos.x += vel.x*time*move_factor;
++        pos.y += vel.y*time*move_factor;
++
++        vel_sum += fabs(vel.x) + fabs(vel.y);
++
++#if 0
++        if (fixedIndex == i)
++        {
++            kDebug() << "Fixed item ** vel : " << vel.x << "," << vel.y << " ** move : " << vel.x*time << "," << vel.y*time;
++        }
++#endif
++    }
++
++    //kDebug() << "acc : " << acc_sum << "  ***  vel :" << vel_sum;
++    if (!wwi.onConstrain && acc_sum < 10.0 && vel_sum < 5.0)
++    {
++        freeWobblyInfo(wwi);
++        windows.remove(w);
++        return false;
++    }
++    return true;
++}
++
++void WobblyWindowsEffect::fourRingLinearMean(Pair** datas_pointer, WindowWobblyInfos& wwi)
++{
++    Pair* datas = *datas_pointer;
++    Pair neibourgs[4];
++
++    // for corners
++
++    // top-left
++    {
++        Pair& res = wwi.buffer[0];
++        Pair vit = datas[0];
++        neibourgs[0] = datas[1];
++        neibourgs[1] = datas[wwi.width];
++
++        res.x = (neibourgs[0].x + neibourgs[1].x + 2.0*vit.x) / 4.0;
++        res.y = (neibourgs[0].y + neibourgs[1].y + 2.0*vit.y) / 4.0;
++    }
++
++
++    // top-right
++    {
++        Pair& res = wwi.buffer[wwi.width-1];
++        Pair vit = datas[wwi.width-1];
++        neibourgs[0] = datas[wwi.width-2];
++        neibourgs[1] = datas[2*wwi.width-1];
++
++        res.x = (neibourgs[0].x + neibourgs[1].x + 2.0*vit.x) / 4.0;
++        res.y = (neibourgs[0].y + neibourgs[1].y + 2.0*vit.y) / 4.0;
++    }
++
++
++    // bottom-left
++    {
++        Pair& res = wwi.buffer[wwi.width*(wwi.height-1)];
++        Pair vit = datas[wwi.width*(wwi.height-1)];
++        neibourgs[0] = datas[wwi.width*(wwi.height-1)+1];
++        neibourgs[1] = datas[wwi.width*(wwi.height-2)];
++
++        res.x = (neibourgs[0].x + neibourgs[1].x + 2.0*vit.x) / 4.0;
++        res.y = (neibourgs[0].y + neibourgs[1].y + 2.0*vit.y) / 4.0;
++    }
++
++
++    // bottom-right
++    {
++        Pair& res = wwi.buffer[wwi.count-1];
++        Pair vit = datas[wwi.count-1];
++        neibourgs[0] = datas[wwi.count-2];
++        neibourgs[1] = datas[wwi.width*(wwi.height-1)-1];
++
++        res.x = (neibourgs[0].x + neibourgs[1].x + 2.0*vit.x) / 4.0;
++        res.y = (neibourgs[0].y + neibourgs[1].y + 2.0*vit.y) / 4.0;
++    }
++
++
++    // for borders
++
++    // top border
++    for (unsigned int i=1; i<wwi.width-1; ++i)
++    {
++        Pair& res = wwi.buffer[i];
++        Pair vit = datas[i];
++        neibourgs[0] = datas[i-1];
++        neibourgs[1] = datas[i+1];
++        neibourgs[2] = datas[i+wwi.width];
++
++        res.x = (neibourgs[0].x + neibourgs[1].x + neibourgs[2].x + 3.0*vit.x) / 6.0;
++        res.y = (neibourgs[0].y + neibourgs[1].y + neibourgs[2].y + 3.0*vit.y) / 6.0;
++    }
++
++    // bottom border
++    for (unsigned int i=wwi.width*(wwi.height-1)+1; i<wwi.count-1; ++i)
++    {
++        Pair& res = wwi.buffer[i];
++        Pair vit = datas[i];
++        neibourgs[0] = datas[i-1];
++        neibourgs[1] = datas[i+1];
++        neibourgs[2] = datas[i-wwi.width];
++
++        res.x = (neibourgs[0].x + neibourgs[1].x + neibourgs[2].x + 3.0*vit.x) / 6.0;
++        res.y = (neibourgs[0].y + neibourgs[1].y + neibourgs[2].y + 3.0*vit.y) / 6.0;
++    }
++
++    // left border
++    for (unsigned int i=wwi.width; i<wwi.width*(wwi.height-1); i+=wwi.width)
++    {
++        Pair& res = wwi.buffer[i];
++        Pair vit = datas[i];
++        neibourgs[0] = datas[i+1];
++        neibourgs[1] = datas[i-wwi.width];
++        neibourgs[2] = datas[i+wwi.width];
++
++        res.x = (neibourgs[0].x + neibourgs[1].x + neibourgs[2].x + 3.0*vit.x) / 6.0;
++        res.y = (neibourgs[0].y + neibourgs[1].y + neibourgs[2].y + 3.0*vit.y) / 6.0;
++    }
++
++    // right border
++    for (unsigned int i=2*wwi.width-1; i<wwi.count-1; i+=wwi.width)
++    {
++        Pair& res = wwi.buffer[i];
++        Pair vit = datas[i];
++        neibourgs[0] = datas[i-1];
++        neibourgs[1] = datas[i-wwi.width];
++        neibourgs[2] = datas[i+wwi.width];
++
++        res.x = (neibourgs[0].x + neibourgs[1].x + neibourgs[2].x + 3.0*vit.x) / 6.0;
++        res.y = (neibourgs[0].y + neibourgs[1].y + neibourgs[2].y + 3.0*vit.y) / 6.0;
++    }
++
++    // for the rest
++    for (unsigned int j=1; j<wwi.height-1; ++j)
++    {
++        for (unsigned int i=1; i<wwi.width-1; ++i)
++        {
++            unsigned int index = i+j*wwi.width;
++
++            Pair& res = wwi.buffer[index];
++            Pair& vit = datas[index];
++            neibourgs[0] = datas[index-1];
++            neibourgs[1] = datas[index+1];
++            neibourgs[2] = datas[index-wwi.width];
++            neibourgs[3] = datas[index+wwi.width];
++
++            res.x = (neibourgs[0].x + neibourgs[1].x + neibourgs[2].x + neibourgs[3].x + 4.0*vit.x) / 8.0;
++            res.y = (neibourgs[0].y + neibourgs[1].y + neibourgs[2].y + neibourgs[3].y + 4.0*vit.y) / 8.0;
++        }
++    }
++
++    Pair* tmp = datas;
++    *datas_pointer = wwi.buffer;
++    wwi.buffer = tmp;
++}
++
++void WobblyWindowsEffect::meanWithMean(Pair** datas_pointer, WindowWobblyInfos& wwi)
++{
++    Pair* datas = *datas_pointer;
++
++    Pair mean = {0.0, 0.0};
++    for (unsigned int i = 0; i < wwi.count; ++i)
++    {
++        mean.x += datas[i].x;
++        mean.y += datas[i].y;
++    }
++
++    mean.x /= wwi.count;
++    mean.y /= wwi.count;
++
++    for (unsigned int i = 0; i < wwi.count; ++i)
++    {
++        wwi.buffer[i].x = (datas[i].x + mean.x) / 2.0;
++        wwi.buffer[i].y = (datas[i].y + mean.y) / 2.0;
++    }
++
++    Pair* tmp = datas;
++    *datas_pointer = wwi.buffer;
++    wwi.buffer = tmp;
++}
++
++void WobblyWindowsEffect::meanWithMedian(Pair** datas_pointer, WindowWobblyInfos& wwi)
++{
++    Pair* datas = *datas_pointer;
++
++    qreal xmin = datas[0].x, ymin = datas[0].y;
++    qreal xmax = datas[0].x, ymax = datas[0].y;
++    for (unsigned int i = 1; i < wwi.count; ++i)
++    {
++        if (datas[i].x < xmin)
++        {
++            xmin = datas[i].x;
++        }
++        if (datas[i].x > xmax)
++        {
++            xmax = datas[i].x;
++        }
++
++        if (datas[i].y < ymin)
++        {
++            ymin = datas[i].y;
++        }
++        if (datas[i].y > ymax)
++        {
++            ymax = datas[i].y;
++        }
++    }
++
++    Pair median = {(xmin + xmax)/2.0, (ymin + ymax)/2.0};
++
++    for (unsigned int i = 0; i < wwi.count; ++i)
++    {
++        wwi.buffer[i].x = (datas[i].x + median.x) / 2.0;
++        wwi.buffer[i].y = (datas[i].y + median.y) / 2.0;
++    }
++
++    Pair* tmp = datas;
++    *datas_pointer = wwi.buffer;
++    wwi.buffer = tmp;
++}
++
++
++} // namespace
++
+--- a/kdebase/workspace/kwin/effects/test/demo_wobblywindows.h	1970-01-01 01:00:00.000000000 +0100
++++ b/kdebase/workspace/kwin/effects/test/demo_wobblywindows.h	2008-02-10 16:51:19.000000000 +0000
+@@ -0,0 +1,122 @@
++/*****************************************************************
++ KWin - the KDE window manager
++ This file is part of the KDE project.
++
++Copyright (C) 2007
++
++You can Freely distribute this program under the GNU General Public
++License. See the file "COPYING" for the exact licensing terms.
++******************************************************************/
++
++#ifndef DEMO_WOBBLYWINDOWS_H
++#define DEMO_WOBBLYWINDOWS_H
++
++// Include with base class for effects.
++#include <kwineffects.h>
++
++namespace KWin
++{
++
++/**
++ * Demo effect which wobble windows
++ **/
++class WobblyWindowsEffect : public Effect
++{
++    public:
++
++        enum GridFilter
++        {
++            NoFilter,
++            FourRingLinearMean,
++            MeanWithMean,
++            MeanWithMedian
++        };
++
++
++        WobblyWindowsEffect();
++        virtual ~WobblyWindowsEffect();
++
++        virtual void prePaintScreen( ScreenPrePaintData& data, int time );
++        virtual void prePaintWindow( EffectWindow* w, WindowPrePaintData& data, int time );
++        virtual void paintWindow( EffectWindow* w, int mask, QRegion region, WindowPaintData& data );
++        virtual void postPaintScreen();
++        virtual void windowUserMovedResized( EffectWindow* c, bool first, bool last );
++        virtual void windowClosed( EffectWindow* c );
++
++        // Wobbly model parameters
++        void setRaideur(qreal raideur);
++        void setAmortissement(qreal amortissement);
++        void setVelocityThreshold(qreal velocityThreshold);
++        void setMoveFactor(qreal factor);
++
++        void setVelocityFilter(GridFilter filter);
++        void setAccelerationFilter(GridFilter filter);
++        GridFilter velocityFilter() const;
++        GridFilter accelerationFilter() const;
++
++    private:
++
++        bool updateWindowWobblyDatas(EffectWindow* w, qreal time);
++
++        struct Pair
++        {
++            qreal x;
++            qreal y;
++        };
++
++        struct WindowWobblyInfos
++        {
++            Pair* origin;
++            Pair* position;
++            Pair* velocity;
++            Pair* acceleration;
++            Pair* buffer;
++
++            unsigned int width;
++            unsigned int height;
++            unsigned int count;
++
++            int mPickedPointIndex;
++            Pair mPickedPointTranslation;
++            Pair mDestination;
++
++            Pair* bezierSurface;
++            unsigned int bezierWidth;
++            unsigned int bezierHeight;
++            unsigned int bezierCount;
++
++            bool onConstrain;
++        };
++
++        QHash< const EffectWindow*,  WindowWobblyInfos > windows;
++
++        qreal raideur;
++        qreal velocityThreshold;
++        qreal accelerationThreshold;
++        qreal amortissement;
++        qreal move_factor;
++
++        // the default tesselation for windows
++        // use qreal instead of int as I really often need
++        // these values as real to do divisions.
++        qreal xTesselation;
++        qreal yTesselation;
++
++        bool squareRootMasterAcceleration;
++
++        GridFilter velFilter;
++        GridFilter accFilter;
++
++        void initWobblyInfo(WindowWobblyInfos& wwi, QRect geometry) const;
++        void freeWobblyInfo(WindowWobblyInfos& wwi) const;
++
++        WobblyWindowsEffect::Pair computeBezierPoint(const WindowWobblyInfos& wwi, Pair point) const;
++
++        static void fourRingLinearMean(Pair** datas, WindowWobblyInfos& wwi);
++        static void meanWithMean(Pair** datas, WindowWobblyInfos& wwi);
++        static void meanWithMedian(Pair** datas, WindowWobblyInfos& wwi);
++};
++
++} // namespace
++
++#endif // DEMO_WOBBLYWINDOWS_H
+--- a/kdebase/workspace/kwin/effects/test/demo_wobblywindows.desktop	1970-01-01 01:00:00.000000000 +0100
++++ b/kdebase/workspace/kwin/effects/test/demo_wobblywindows.desktop	2008-02-10 16:51:19.000000000 +0000
+@@ -0,0 +1,16 @@
++[Desktop Entry]
++Encoding=UTF-8
++Name=Demo Wobbly Windows
++Icon=kwin-effect-wavywindows
++
++Type=Service
++ServiceTypes=KWin/Effect
++X-KDE-PluginInfo-Author=
++X-KDE-PluginInfo-Email=
++X-KDE-PluginInfo-Name=kwin4_effect_demo_wobblywindows
++X-KDE-PluginInfo-Version=0.1.0
++X-KDE-PluginInfo-Category=Demos
++X-KDE-PluginInfo-Depends=
++X-KDE-PluginInfo-License=GPL
++X-KDE-PluginInfo-EnabledByDefault=false
++X-KDE-Library=kwin4_effect_tests
diff --git a/kde-base/kdebase/kdebase-9999.4.ebuild b/kde-base/kdebase/kdebase-9999.4.ebuild
index 882e7cb..249feb8 100644
--- a/kde-base/kdebase/kdebase-9999.4.ebuild
+++ b/kde-base/kdebase/kdebase-9999.4.ebuild
@@ -109,7 +109,8 @@ PDEPEND="
 #	xscreensaver? ( x11-proto/scrnsaverproto )"
 
 ESVN_PATCHES="${FILESDIR}/gentoo-startkde.patch
-	${FILESDIR}/${P}-pam-optional.patch"
+	${FILESDIR}/${P}-pam-optional.patch
+	${FILESDIR}/kwin-wobblywindows.patch"
 
 pkg_setup() {
 	KDE4_BUILT_WITH_USE_CHECK="--missing false kde-base/kdelibs:${SLOT} alsa semantic-desktop