diff --git a/effects/flipswitch.cpp b/effects/flipswitch.cpp
index 483c556b3..e9fb8a358 100644
--- a/effects/flipswitch.cpp
+++ b/effects/flipswitch.cpp
@@ -1,615 +1,617 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
  Copyright (C) 2008 Martin Gräßlin <ubuntu@martin-graesslin.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 "flipswitch.h"
 
 #include <kwinconfig.h>
 #include <QFont>
 #include <kapplication.h>
 #include <kcolorscheme.h>
 #include <kconfiggroup.h>
 
 #include <kwinglutils.h>
 
 #ifdef KWIN_HAVE_OPENGL_COMPOSITING
 #include <GL/gl.h>
 #endif
 
 namespace KWin
 {
 
 KWIN_EFFECT( flipswitch, FlipSwitchEffect )
 
 FlipSwitchEffect::FlipSwitchEffect()
     : mActivated( 0 )
     , animateFlip( false )
     , forward( true )
     , start( false )
     , stop( false )
     , addFullRepaint( false )
     , rearrangeWindows( 0 )
     , stopRequested( false )
     , startRequested( false )
     , twinview( false )
     {
     KConfigGroup conf = effects->effectConfig( "FlipSwitch" );
     mFlipDuration = conf.readEntry( "FlipDuration", 200 );
     mAnimation    = conf.readEntry( "AnimateFlip", true );
     timeLine.setCurveShape( TimeLine::EaseInOutCurve );
     timeLine.setDuration( mFlipDuration );
     }
 
 FlipSwitchEffect::~FlipSwitchEffect()
     {
     }
 
 void FlipSwitchEffect::prePaintScreen( ScreenPrePaintData& data, int time )
     {
     if( mActivated || stopRequested || stop )
         {
          data.mask |= Effect::PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS;
         if( mAnimation )
             timeLine.addTime( (double)time );
         }
     effects->prePaintScreen(data, time);
     }
 
 void FlipSwitchEffect::paintScreen( int mask, QRegion region, ScreenPaintData& data )
     {
     effects->paintScreen( mask, region, data );
     if( mActivated || stopRequested || stop )
         {
 #ifdef KWIN_HAVE_OPENGL_COMPOSITING
         glMatrixMode( GL_PROJECTION );
         glPushMatrix();
         glPushAttrib( GL_CURRENT_BIT | GL_ENABLE_BIT );
         glEnable( GL_BLEND );
         glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
         glLoadIdentity();
         int viewport[4];
         glGetIntegerv( GL_VIEWPORT, viewport );
         int yPos = area.y();
         QRect fullArea = effects->clientArea( FullArea, effects->activeScreen(), effects->currentDesktop());
         if( twinview )
             {
             if( effects->clientArea( FullScreenArea, effects->activeScreen(), effects->currentDesktop()).x() == 0 
                 && effects->clientArea( FullScreenArea, effects->activeScreen()==0?1:0, effects->currentDesktop()).x() == 0 )
                 {
                 // top <-> bottom
                 // have to correct the yPos for top bottom constellation
                 yPos = area.height()-area.y();
                 if( ( area.height() * 2 != fullArea.height() ) ||
                     ( effects->clientArea( FullScreenArea, effects->activeScreen(), effects->currentDesktop()).width() !=  
                     effects->clientArea( FullScreenArea, effects->activeScreen()==0?1:0, effects->currentDesktop()).width() ) )
                     {
                     // different resolutions
                     if( area.y() > 0 )
                         yPos = 0;
                     else
                         yPos = fullArea.height() - area.height();
                     }
                 }
             else
                 {
                 // left <-> right
                 if( ( area.width() * 2 != fullArea.width() ) ||
                     ( effects->clientArea( FullScreenArea, effects->activeScreen(), effects->currentDesktop()).height() !=  
                     effects->clientArea( FullScreenArea, effects->activeScreen()==0?1:0, effects->currentDesktop()).height() ) )
                     {
                     // different resolutions
                     yPos = area.y() + fullArea.height() - area.height();
                     }
                 }
             }
         float left, right, top, bottom;
         left = -area.width() * 0.5f;
         right = area.width() * 0.5f;
         top = area.height()*0.5f;
         bottom = -area.height()*0.5f;
         if( twinview && ( start || stop ) )
             {
             // special handling for start and stop animation in twin view setup
             glViewport( fullArea.x(), fullArea.y(), fullArea.width(), fullArea.height() );
             left = -(area.x() + area.width() * 0.5f);
             right = fullArea.width() + left;
             bottom = -(area.y() + area.height() * 0.5f);
             top = fullArea.height() + bottom;
             }
         else
             {
             glViewport( area.x(), yPos, area.width(), area.height() );
             }
         glFrustum( left, right, top, bottom, 10, 50 );
 
         glMatrixMode( GL_MODELVIEW );
         glLoadIdentity();
         float xOffset = area.width()*0.33f;
         float zOffset = 10.0;
 
         // bring the selected window to the back of the list
         QList< EffectWindow* > tempList = effects->currentTabBoxWindowList();
         int index = tempList.indexOf( effects->currentTabBoxWindow() );
         QList< EffectWindow* > windowList;
         for( int i=index; i<tempList.count(); i++)
             {
             windowList.push_front( tempList[i] );
             }
         for( int i=0; i<index; i++)
             {
             windowList.push_front( tempList[i] );
             }
         // do we have to rearrange the windows as an animation has to follow?
         if( rearrangeWindows != 0 )
             {
             if( rearrangeWindows < 0 )
                 {
                 for( int i=0; i>rearrangeWindows; i-- )
                     {
                     EffectWindow* w = windowList.front();
                     windowList.pop_front();
                     windowList.append( w );
                     }
                 }
             else
                 {
                 for( int i=0; i<rearrangeWindows; i++ )
                     {
                     EffectWindow* w = windowList.back();
                     windowList.pop_back();
                     windowList.prepend( w );
                     }
                 }
             }
 
         // do we have a start or stop animation
         if( ( start || stop ) && mAnimation )
             {
             for( int i=0; i<windowList.count(); i++)
                 {
                 glPushMatrix();
                 EffectWindow *w = windowList[ i ];        
                 // Position of the window in OpenGL
                 float x = w->x()+left;
                 float y = bottom-area.height()+w->y()+w->height();
                 float z = -10.0;
                 if( w->isMinimized() )
                     {
                     // use icon instead of window
                     x = w->iconGeometry().x()+left;
                     y = bottom-area.height()+w->iconGeometry().y()+w->height();
                     }
                 // Position of the window in the stack
                 float stackX = -area.width()*0.25f-(xOffset*windowList.count())+xOffset*(i+1);
                 float stackY = -area.height()*0.5f;
                 float stackZ = (-1*zOffset*windowList.count()) -12.5+zOffset*(i+1);
 
                 float animateXOffset;
                 float animateYOffset;
                 float animateZOffset;
                 float rotation;
                 // if start move to stack, if stop move from stack
                 if( start )
                     {
                     animateXOffset = x+timeLine.value()*(stackX-x);
                     animateYOffset = y+timeLine.value()*(stackY-y);
                     animateZOffset = z+timeLine.value()*(stackZ-z);
                     rotation = timeLine.value()*0.25;
                     }
                 else // = if( stop )
                     {
                     animateXOffset = stackX+timeLine.value()*(x-stackX);
                     animateYOffset = stackY+timeLine.value()*(y-stackY);
                     animateZOffset = stackZ+timeLine.value()*(z-stackZ);
                     rotation = 0.25-timeLine.value()*0.25;
                     }
 
                 // go to current position and rotate by the time based factor
                 glTranslatef(animateXOffset, animateYOffset, animateZOffset );
                 glRotatef(rotation, 0.0, 1.0, 0.0);
 
                 // top most window has to be painted not drawn.
                 if( i<windowList.count()-1 )
                     {
                     paintWindowFlip( windowList[i] );
                     }
                 else paintWindowFlip( windowList[i], false);
                 glPopMatrix();
                 }
             // time elapsed - so no more animation
             if( timeLine.value() == 1.0 )
                 {
                 timeLine.setProgress( 0.0 );
                 if( start )
                     {
                     start = false;
                     // more animations have to follow?
                     if( rearrangeWindows != 0 )
                         {
                         animateFlip = true;
                         if( rearrangeWindows < 0 )
                             {
                             forward = true;
                             rearrangeWindows++;
                             }
                         else
                             {
                             forward = false;
                             rearrangeWindows--;
                             }
                         }
                     else if( stopRequested )
                         {
                         // no more animations but effect has to stop
                         stop = true;
                         stopRequested = false;
                         }
                     }
                 else if( stop )
                     {
                     stop = false;
                     if( startRequested )
                         {
                         // tabbox allready referenced again - so restart
                         start = true;
                         startRequested = false;
                         mActivated = true;
                         }
                     else
                         {
                         mActivated = false;
                         // we need one more FullRepaint
                         addFullRepaint = true;
                         }
                     }
                 }
             }
         // normal behaviour - no start or stop animation
         else
             {
             double localProgress = timeLine.value();
             glPushMatrix();
             glTranslatef(-area.width()*0.25f-(xOffset*windowList.count()),
                 -area.height()*0.5f,
                 (-1*zOffset*windowList.count()) -12.5);
             if( animateFlip && windowList.count() > 1 )
                 {
                 if( timeLine.value() < 1.0 )
                     {
                     float animateXOffset = timeLine.value()*xOffset;
                     float animateZOffset = timeLine.value()*zOffset;
                     if( forward )
                         {
                         if( animateXOffset > xOffset ) animateXOffset = xOffset;
                         if( animateZOffset > zOffset ) animateZOffset = zOffset;
                         glTranslatef(animateXOffset, 0.0, animateZOffset);
                         EffectWindow* w = windowList.front();
                         windowList.pop_front();
                         windowList.append( w );
                         }
                     else
                         {
                         animateXOffset = xOffset - animateXOffset;
                         animateZOffset = zOffset - animateZOffset;
                         if( animateXOffset < 0.0 ) animateXOffset = 0.0;
                         if( animateZOffset < 0.0 ) animateZOffset = 0.0;
                         glTranslatef(animateXOffset, 0.0, animateZOffset);
                         }
                     }
                 else
                     {
                     timeLine.setProgress( 0.0 );
                     if( rearrangeWindows != 0 )
                         {
                         animateFlip = true;
                         if( rearrangeWindows < 0 )
                             {
                             forward = true;
                             rearrangeWindows++;
                             localProgress = 0.0;
                             }
                         else
                             {
                             forward = false;
                             rearrangeWindows--;
                             localProgress = 1.0;
                             }
                         }
                     else
                         {
                         animateFlip = false;
                         if( stopRequested )
                             {
                             stop = true;
                             stopRequested = false;
                             }
                         }
                     }
                 }
             for( int i=0; i<windowList.count(); i++)
                 {
                 glPushMatrix();
                 glTranslatef(xOffset*(i+1), 0.0, zOffset*(i+1));
                 glRotatef(0.25, 0.0, 1.0, 0.0);
                 // top most window has to be painted not drawn.
                 if( i<windowList.count()-1 )
                     {
                     paintWindowFlip( windowList[i] );
                     }
                 else
                     {
                     // last window - change opacity if animated
                     float opacity = 0.8;
                     if( animateFlip && windowList.count() > 1 )
                         {
                         if( forward ) opacity = opacity - localProgress*opacity;
                         else opacity = localProgress*opacity;
                         }
                     paintWindowFlip( windowList[i], false, opacity);
                     }
                 glPopMatrix();
                 }
             glPopMatrix();
             }
         glPopAttrib();
         glMatrixMode( GL_PROJECTION );
         glPopMatrix();
         glMatrixMode( GL_MODELVIEW );
         glViewport( viewport[0], viewport[1], viewport[2], viewport[3] );
 
         // caption of selected window
         QColor color_frame;
         QColor color_text;
         color_frame = KColorScheme( QPalette::Active, KColorScheme::Window ).background().color();
         color_frame.setAlphaF( 0.9 );
         color_text = KColorScheme( QPalette::Active, KColorScheme::Window ).foreground().color();
         if( start )
             {
             color_frame.setAlphaF( 0.9 * timeLine.value() );
             color_text.setAlphaF( timeLine.value() );
             }
         else if( stop )
             {
             color_frame.setAlphaF( 0.9 - 0.9 * timeLine.value() );
             color_text.setAlphaF( 1.0 - timeLine.value() );
             }
         else if( addFullRepaint )
             {
             // special case: timeLine was reset, but actual frame will be painted
             color_frame.setAlphaF( 0.0 );
             color_text.setAlphaF( 0.0 );
             }
         QFont text_font;
         text_font.setBold( true );
         text_font.setPointSize( 20 );
         glPushAttrib( GL_CURRENT_BIT );
         glColor4f( color_frame.redF(), color_frame.greenF(), color_frame.blueF(), color_frame.alphaF());
         QRect frameRect = QRect( area.width()*0.25f + area.x(),
             area.height()*0.9f + area.y(),
             area.width()*0.5f,
             QFontMetrics( text_font ).height() * 1.2 );
         renderRoundBoxWithEdge( frameRect );
         effects->paintText( effects->currentTabBoxWindow()->caption(),
             frameRect.center(),
             frameRect.width() - 100,
             color_text,
             text_font );
         glPopAttrib();
         // icon of selected window
         QPixmap iconPixmap = effects->currentTabBoxWindow()->icon();
         if( start || stop || addFullRepaint )
             {
             int alpha = 255.0f * timeLine.value();
             if( stop )
                 {
                 alpha = 255.0f - alpha;
                 }
             else if( addFullRepaint )
                 {
                 alpha = 0.0f;
                 }
             QPixmap transparency = iconPixmap.copy( iconPixmap.rect() );
             transparency.fill( QColor( 255, 255, 255, alpha ) );
             iconPixmap.setAlphaChannel( transparency.alphaChannel()  );
             }
         GLTexture* icon = new GLTexture( iconPixmap );
         icon->bind();
         glPushAttrib( GL_CURRENT_BIT | GL_ENABLE_BIT );
         icon->bind();
         glEnable( GL_BLEND );
         glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
         // icon takes 80 % of the height of the frame. So each 10 % space left on the top and botton
         QRect iconRect = QRect( frameRect.x() + frameRect.height()*0.1f,
             frameRect.y() + frameRect.height()*0.1f,
             frameRect.height()*0.8f,
             frameRect.height()*0.8f );
         icon->render( region, iconRect);
         icon->unbind();
+        delete icon;
+        glDisable( GL_BLEND );
         glPopAttrib();
 #endif
         }
     }
 
 void FlipSwitchEffect::postPaintScreen()
     {
     if( (mActivated && ( animateFlip || start )) || stopRequested || stop )
         {
         effects->addRepaintFull();
         }
     if( addFullRepaint )
         {
         addFullRepaint = false;
         effects->setActiveFullScreenEffect( 0 );
         effects->addRepaintFull();
         }
     effects->postPaintScreen();
     }
   
 void FlipSwitchEffect::paintWindow( EffectWindow* w, int mask, QRegion region, WindowPaintData& data )
     {
     if( mActivated || stopRequested || stop )
         {
         if( !( mask & PAINT_WINDOW_TRANSFORMED ) && ( !w->isDesktop() ) )
             {
             if( ( start || stop ) && w->isDock() )
                 {
                 data.opacity = 1.0 - timeLine.value();
                 if( stop )
                     data.opacity = timeLine.value();
                 }
             else
                 return;
             }
         }
     effects->paintWindow( w, mask, region, data );
     }
   
 void FlipSwitchEffect::tabBoxAdded( int mode )
     {
     if( effects->activeFullScreenEffect() && effects->activeFullScreenEffect() != this )
         return;
     if( !mActivated )
         {
         // only for windows mode
         if( mode == TabBoxWindowsMode && effects->currentTabBoxWindowList().count() > 0 )
             {
             effects->refTabBox();
             effects->setActiveFullScreenEffect( this );
             selectedWindow = effects->currentTabBoxWindowList().indexOf(effects->currentTabBoxWindow());
             if( !stop && !stopRequested )
                 {
                 mActivated = true;
                 start = true;
                 effects->addRepaintFull();
                 }
             else
                 {
                 // last tabbox effect still running - schedule start effect
                 startRequested = true;
                 }
                 
             // Calculation of correct area
             area = effects->clientArea( FullScreenArea, effects->activeScreen(), effects->currentDesktop());
             QRect fullArea = effects->clientArea( FullArea, effects->activeScreen(), effects->currentDesktop());
             // twinview?
             if( area.height() != fullArea.height() || area.width() != fullArea.width() )
                 twinview = true;
             else
                 twinview = false;
             }
         }
     }
 void FlipSwitchEffect::tabBoxClosed()
     {
     if( mActivated )
         {
         // if animation than deactivate after animation
         mActivated = false;
         effects->unrefTabBox();
         if( mAnimation )
             {
             if( start && rearrangeWindows == 0 )
                 {
                 stop = true;
                 start = false;
                 timeLine.setProgress( 1.0 - timeLine.value() );
                 }
             else if( start || animateFlip )
                 stopRequested = true;
             else
                 {
                 stop = true;
                 effects->addRepaintFull();
                 }
             }
         else
             effects->setActiveFullScreenEffect( 0 );
         }
     }
 
 void FlipSwitchEffect::tabBoxUpdated()
     {
     if( mActivated )
         {
         if( mAnimation && effects->currentTabBoxWindowList().count() > 1 )
             {
             // determine the switch direction
             int index = effects->currentTabBoxWindowList().indexOf(effects->currentTabBoxWindow());
             bool direction = false;
             int windowCount = effects->currentTabBoxWindowList().count();
             if( index > selectedWindow )
                 {
                 if( index == windowCount-1 && selectedWindow == 0 ) forward = false;
                 else direction = true;
                 }
             else if( index == 0 && ( selectedWindow == windowCount-1 ) )
                 {
                 direction = true;
                 }
             else if( index == selectedWindow ) return; // nothing changed
             else
                 {
                 direction = false;
                 }
             selectedWindow = index;
             if( !animateFlip && !start )
                 {
                 forward = direction;
                 animateFlip = true;
                 }
             else
                 {
                 if( direction ) rearrangeWindows--;
                 else rearrangeWindows++;
                 if( rearrangeWindows >= windowCount ) rearrangeWindows = rearrangeWindows % windowCount;
                 else if( (-1*rearrangeWindows) >= windowCount ) rearrangeWindows = -1*((-1*rearrangeWindows) % windowCount);
                 }
             }
         effects->addRepaintFull();
         }
     }
 
 void FlipSwitchEffect::paintWindowFlip( EffectWindow* w, bool draw, float opacity )
     {
     WindowPaintData data( w );
 
     int x = 0;
     int y = area.height() - w->geometry().height();
     QRect thumbnail;
     setPositionTransformations( data,                                             
         thumbnail, w,
         QRect( x, y, w->geometry().width(), w->geometry().height() ),
         Qt::KeepAspectRatio );
 
     data.opacity = opacity;
     thumbnail = infiniteRegion();
     // if paintWindow() is used the window behind the initial selected window is not painted on the stack,
     // but painted when it is selected
     // if drawWindow() is used the front window does not glide through the monitor during animation
     // so use drawWindow() for all windows but the selected and paintWindow() for the selected window
     if( draw )
         effects->drawWindow( w,
             PAINT_WINDOW_TRANSFORMED,
             thumbnail, data );
     else 
         effects->paintWindow( w,
             PAINT_WINDOW_TRANSFORMED,
             thumbnail, data );
     }
 
 } // namespace