You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
430 lines
16 KiB
430 lines
16 KiB
/******************************************************************** |
|
KWin - the KDE window manager |
|
This file is part of the KDE project. |
|
|
|
Copyright (C) 2009 Michael Zanetti <michael_zanetti@gmx.net> |
|
|
|
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 "slideback.h" |
|
|
|
#include <kconfiggroup.h> |
|
#include <kdebug.h> |
|
|
|
namespace KWin |
|
{ |
|
|
|
KWIN_EFFECT( slideback, SlideBackEffect ) |
|
|
|
SlideBackEffect::SlideBackEffect() |
|
{ |
|
updateStackingOrder(); |
|
disabled = false; |
|
unminimizedWindow = NULL; |
|
} |
|
|
|
void SlideBackEffect::windowActivated( EffectWindow* w ) |
|
{ |
|
if( w == NULL || w->keepAbove()) // plasma popups, yakuake etc... |
|
{ |
|
return; |
|
} |
|
|
|
if( disabled || effects->activeFullScreenEffect() ) // TabBox or PresentWindows/Cube in progress |
|
{ |
|
updateStackingOrder(); |
|
disabled = false; |
|
return; |
|
} |
|
|
|
if( !isWindowUsable( w ) || !stackingOrderChanged() ) // Focus changed but stacking still the same |
|
{ |
|
updateStackingOrder(); |
|
return; |
|
} |
|
|
|
if( unminimizedWindow == w ){ // A window was activated by beeing unminimized. Don't trigger SlideBack. |
|
unminimizedWindow = NULL; |
|
updateStackingOrder(); |
|
return; |
|
} |
|
|
|
// Determine all windows on top of the activated one |
|
bool currentFound = false; |
|
foreach( EffectWindow *tmp, oldStackingOrder ) |
|
{ |
|
if( !currentFound ) |
|
{ |
|
if( tmp == w ) |
|
{ |
|
currentFound = true; |
|
} |
|
} |
|
else |
|
{ |
|
if( isWindowUsable( tmp ) && ( tmp->isOnDesktop( w->desktop() ) || w->isOnAllDesktops() ) ) |
|
{ |
|
// Do we have to move it? |
|
if( intersects( w, tmp->geometry() ) ) |
|
{ |
|
QRect slideRect; |
|
if( w->isModal() ) |
|
{ |
|
QRect modalGroupGeometry = w->geometry(); |
|
foreach( EffectWindow *modalWindow, w->mainWindows() ) |
|
{ |
|
modalGroupGeometry = modalGroupGeometry.united( modalWindow->geometry() ); |
|
} |
|
slideRect = getSlideDestination( modalGroupGeometry, tmp->geometry() ); |
|
} |
|
else |
|
{ |
|
slideRect = getSlideDestination( w->geometry(), tmp->geometry() ); |
|
} |
|
effects->setElevatedWindow( tmp, true ); |
|
elevatedList.append( tmp ); |
|
motionManager.manage( tmp ); |
|
motionManager.moveWindow( tmp, slideRect ); |
|
destinationList.insert( tmp, slideRect ); |
|
coveringWindows.append( tmp ); |
|
} |
|
else |
|
{ |
|
//Does it intersect with a moved (elevated) window and do we have to elevate it too? |
|
foreach( EffectWindow *elevatedWindow, elevatedList ) |
|
{ |
|
if( tmp->geometry().intersects( elevatedWindow->geometry() ) ) |
|
{ |
|
effects->setElevatedWindow( tmp, true ); |
|
elevatedList.append( tmp ); |
|
break; |
|
} |
|
} |
|
|
|
} |
|
} |
|
if( tmp->isDock() || tmp->keepAbove() ) |
|
{ |
|
effects->setElevatedWindow( tmp, true ); |
|
elevatedList.append( tmp ); |
|
} |
|
} |
|
} |
|
// If a window is minimized it could happen that the panels stay elevated without any windows sliding. |
|
// clear all elevation settings |
|
if( !motionManager.managingWindows() ) |
|
{ |
|
foreach( EffectWindow* tmp, elevatedList ) |
|
{ |
|
effects->setElevatedWindow( tmp, false ); |
|
} |
|
} |
|
updateStackingOrder(); |
|
} |
|
|
|
QRect SlideBackEffect::getSlideDestination( const QRect &windowUnderGeometry, const QRect &windowOverGeometry) |
|
{ |
|
// Determine the shortest way: |
|
int leftSlide = windowUnderGeometry.left() - windowOverGeometry.right() - 20; |
|
int rightSlide = windowUnderGeometry.right() - windowOverGeometry.left() + 20; |
|
int upSlide = windowUnderGeometry.top() - windowOverGeometry.bottom() - 20; |
|
int downSlide = windowUnderGeometry.bottom() - windowOverGeometry.top() + 20; |
|
|
|
int horizSlide = leftSlide; |
|
if( qAbs( horizSlide ) > qAbs( rightSlide ) ) |
|
{ |
|
horizSlide = rightSlide; |
|
} |
|
int vertSlide = upSlide; |
|
if( qAbs( vertSlide ) > qAbs( downSlide ) ) |
|
{ |
|
vertSlide = downSlide; |
|
} |
|
|
|
QRect slideRect = windowOverGeometry; |
|
if( qAbs( horizSlide ) < qAbs( vertSlide ) ) |
|
{ |
|
slideRect.moveLeft( slideRect.x() + horizSlide ); |
|
} |
|
else |
|
{ |
|
slideRect.moveTop( slideRect.y() + vertSlide ); |
|
} |
|
return slideRect; |
|
} |
|
|
|
void SlideBackEffect::updateStackingOrder() |
|
{ |
|
usableOldStackingOrder = usableWindows( effects->stackingOrder() ); |
|
oldStackingOrder = effects->stackingOrder(); |
|
} |
|
|
|
void SlideBackEffect::prePaintScreen( ScreenPrePaintData &data, int time ) |
|
{ |
|
if( motionManager.managingWindows() ) |
|
{ |
|
motionManager.calculate( time ); |
|
data.mask |= Effect::PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS; |
|
} |
|
effects->prePaintScreen( data, time ); |
|
} |
|
|
|
void SlideBackEffect::postPaintScreen() |
|
{ |
|
if( motionManager.areWindowsMoving() ) |
|
{ |
|
effects->addRepaintFull(); |
|
} |
|
effects->postPaintScreen(); |
|
} |
|
|
|
void SlideBackEffect::prePaintWindow( EffectWindow *w, WindowPrePaintData &data, int time ) |
|
{ |
|
if( motionManager.isManaging( w ) ) |
|
{ |
|
data.setTransformed(); |
|
} |
|
|
|
effects->prePaintWindow( w, data, time ); |
|
} |
|
|
|
void SlideBackEffect::paintWindow( EffectWindow *w, int mask, QRegion region, WindowPaintData &data ) |
|
{ |
|
if( stackingOrderChanged() && ( w == newTopWindow() ) && !disabled ) |
|
{ |
|
/* This can happen because of two reasons: |
|
- a window has received the focus earlier without beeing raised and is raised now. -> call windowActivated() now |
|
- paintWindow() is called with a new stackingOrder before activateWindow(). Bug? -> don't draw the overlapping content;*/ |
|
foreach( EffectWindow *tmp, oldStackingOrder ) |
|
{ |
|
if( oldStackingOrder.lastIndexOf( tmp ) > oldStackingOrder.lastIndexOf( w ) && isWindowUsable( tmp ) ) |
|
{ |
|
kDebug() << "screw detected. region:" << region << "clipping:" << tmp->geometry() ; |
|
PaintClipper::push( region.subtracted( tmp->geometry() ) ); |
|
clippedRegions.prepend( region.subtracted( tmp->geometry() ) ); |
|
// region = region.subtracted( tmp->geometry() ); |
|
} |
|
} |
|
// Finally call windowActivated in case a already active window is raised. |
|
windowActivated( w ); |
|
} |
|
if( motionManager.isManaging( w ) ) |
|
{ |
|
motionManager.apply( w, data ); |
|
} |
|
effects->paintWindow( w, mask, region, data ); |
|
if( !clippedRegions.isEmpty() ) |
|
{ |
|
foreach( const QRegion ®ion, clippedRegions ) |
|
{ |
|
PaintClipper::pop( region ); |
|
} |
|
clippedRegions.clear(); |
|
} |
|
} |
|
|
|
void SlideBackEffect::postPaintWindow( EffectWindow* w ) |
|
{ |
|
if( motionManager.isManaging( w ) ) |
|
{ |
|
if( destinationList.contains( w ) ) |
|
{ |
|
// has window reched its destination? |
|
if(( qAbs( motionManager.transformedGeometry( w ).x() - destinationList[w].x() ) < 1 ) && |
|
( qAbs( motionManager.transformedGeometry( w ).y() - destinationList[w].y() ) < 1 ) ) |
|
{ |
|
// If we are still intersecting with the activeWindow it is moving. slide to somewhere else |
|
// restore the stacking order of all windows not intersecting any more except panels |
|
if( coveringWindows.contains( w ) ) |
|
{ |
|
EffectWindowList tmpList; |
|
foreach( EffectWindow *tmp, elevatedList ) |
|
{ |
|
QRect elevatedGeometry = tmp->geometry(); |
|
if( motionManager.isManaging( tmp ) ) |
|
{ |
|
elevatedGeometry = motionManager.transformedGeometry( tmp ).toAlignedRect(); |
|
} |
|
if( effects->activeWindow() && !tmp->isDock() && !tmp->keepAbove() && effects->activeWindow()->geometry().intersects( elevatedGeometry ) ) |
|
{ |
|
QRect newDestination; |
|
if( effects->activeWindow()->isModal() ) |
|
{ |
|
QRect modalGroupGeometry = effects->activeWindow()->geometry(); |
|
foreach( EffectWindow *modalWindow, effects->activeWindow()->mainWindows() ) |
|
{ |
|
modalGroupGeometry = modalGroupGeometry.united( modalWindow->geometry() ); |
|
} |
|
newDestination = getSlideDestination( modalGroupGeometry, elevatedGeometry ); |
|
} |
|
else |
|
{ |
|
newDestination = getSlideDestination( effects->activeWindow()->geometry(), elevatedGeometry ); |
|
} |
|
if( !motionManager.isManaging( tmp ) ) |
|
{ |
|
motionManager.manage( tmp ); |
|
} |
|
motionManager.moveWindow( tmp, newDestination ); |
|
destinationList[tmp] = newDestination; |
|
} |
|
else |
|
{ |
|
if( !tmp->isDock() ) |
|
{ |
|
bool keepElevated = false; |
|
foreach( EffectWindow *elevatedWindow, tmpList) |
|
{ |
|
if( tmp->geometry().intersects( elevatedWindow->geometry() ) ) |
|
{ |
|
keepElevated = true; |
|
} |
|
} |
|
if( !keepElevated ) |
|
{ |
|
effects->setElevatedWindow( tmp, false ); |
|
elevatedList.removeAll( tmp ); |
|
} |
|
} |
|
} |
|
tmpList.append(tmp); |
|
} |
|
} |
|
else |
|
{ |
|
// Move the window back where it belongs |
|
motionManager.moveWindow( w, w->geometry() ); |
|
destinationList.remove( w ); |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
// is window back at its original position? |
|
if(( qAbs( motionManager.transformedGeometry( w ).x() - w->geometry().x() ) < 1 ) && |
|
( qAbs( motionManager.transformedGeometry( w ).y() - w->geometry().y() ) < 1 ) ) |
|
{ |
|
motionManager.unmanage( w ); |
|
effects->addRepaintFull(); |
|
} |
|
} |
|
if( coveringWindows.contains( w ) ) |
|
{ |
|
// It could happen that there is no aciveWindow() here if the user clicks the close-button on an inactive window. |
|
// Just skip... the window will be removed in windowDeleted() later |
|
if( effects->activeWindow() && !intersects( effects->activeWindow(), motionManager.transformedGeometry( w ).toAlignedRect() ) ) |
|
{ |
|
coveringWindows.removeAll( w ); |
|
if( coveringWindows.isEmpty() ) |
|
{ |
|
// Restore correct stacking order |
|
foreach( EffectWindow *tmp, elevatedList ) |
|
{ |
|
effects->setElevatedWindow( tmp, false ); |
|
} |
|
elevatedList.clear(); |
|
} |
|
} |
|
} |
|
} |
|
effects->postPaintWindow( w ); |
|
} |
|
|
|
void SlideBackEffect::windowDeleted( EffectWindow* w ) |
|
{ |
|
usableOldStackingOrder.removeAll( w ); |
|
oldStackingOrder.removeAll( w ); |
|
coveringWindows.removeAll( w ); |
|
elevatedList.removeAll( w ); |
|
if( motionManager.isManaging( w ) ) |
|
{ |
|
motionManager.unmanage( w ); |
|
} |
|
} |
|
|
|
void SlideBackEffect::windowAdded( KWin::EffectWindow* w ) |
|
{ |
|
Q_UNUSED( w ); |
|
updateStackingOrder(); |
|
} |
|
|
|
void SlideBackEffect::windowUnminimized( EffectWindow* w) |
|
{ |
|
// SlideBack should not be triggered on an unminimized window. For this we need to store the last unminimized window. |
|
// If a window is unminimized but not on top we need to clear the memory because the windowUnminimized() is not |
|
// followed by a windowActivated(). |
|
if( isWindowOnTop( w ) ) |
|
{ |
|
unminimizedWindow = w; |
|
} |
|
else |
|
{ |
|
unminimizedWindow = NULL; |
|
} |
|
} |
|
|
|
void SlideBackEffect::tabBoxClosed() |
|
{ |
|
disabled = true; |
|
} |
|
|
|
bool SlideBackEffect::isWindowOnTop( EffectWindow* w ) |
|
{ |
|
return usableWindows( effects->stackingOrder() ).last() == w ? true : false; |
|
} |
|
|
|
bool SlideBackEffect::isWindowUsable( EffectWindow* w ) |
|
{ |
|
return w && ( w->isNormalWindow() || w->isDialog() ) && !w->keepAbove() && !w->isDeleted() && !w->isMinimized(); |
|
} |
|
|
|
bool SlideBackEffect::intersects( EffectWindow* windowUnder, const QRect &windowOverGeometry ) |
|
{ |
|
QRect windowUnderGeometry = windowUnder->geometry(); |
|
if( windowUnder->isModal() ) |
|
{ |
|
foreach( EffectWindow *tmp, windowUnder->mainWindows() ) |
|
{ |
|
windowUnderGeometry = windowUnderGeometry.united( tmp->geometry() ); |
|
} |
|
} |
|
return windowUnderGeometry.intersects( windowOverGeometry ); |
|
} |
|
|
|
EffectWindowList SlideBackEffect::usableWindows( const EffectWindowList & allWindows ) |
|
{ |
|
EffectWindowList retList; |
|
foreach( EffectWindow *tmp, allWindows ) |
|
{ |
|
if( isWindowUsable( tmp ) ) |
|
{ |
|
retList.append( tmp ); |
|
} |
|
} |
|
return retList; |
|
} |
|
|
|
bool SlideBackEffect::stackingOrderChanged() |
|
{ |
|
return !( usableOldStackingOrder == usableWindows( effects->stackingOrder() ) ); |
|
} |
|
|
|
EffectWindow* SlideBackEffect::newTopWindow() |
|
{ |
|
EffectWindowList stacking = usableWindows( effects->stackingOrder() ); |
|
return stacking.isEmpty() ? NULL : stacking.last(); |
|
} |
|
|
|
} //Namespace
|
|
|