diff --git a/CMakeLists.txt b/CMakeLists.txt index 0f727f61d0..7fa1b1f043 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -63,8 +63,8 @@ set(kwin_KDEINIT_SRCS utils.cpp layers.cpp main.cpp - popupinfo.cpp tabbox.cpp + desktopchangeosd.cpp options.cpp plugins.cpp events.cpp diff --git a/desktopchangeosd.cpp b/desktopchangeosd.cpp new file mode 100644 index 0000000000..5beda11981 --- /dev/null +++ b/desktopchangeosd.cpp @@ -0,0 +1,573 @@ +/******************************************************************** + KWin - the KDE window manager + This file is part of the KDE project. + +Copyright (C) 2009 Martin Gräßlin + +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 . +*********************************************************************/ + +#include "desktopchangeosd.h" +#include +#include "workspace.h" + +#include +#include +#include +#include +#include +#include +#include + +namespace KWin +{ + +DesktopChangeOSD::DesktopChangeOSD( Workspace* ws ) + : QGraphicsView() + , m_wspace( ws ) + , m_scene( 0 ) + , m_active( false ) + , m_show( false ) + , m_delayTime( 0 ) + { + setWindowFlags( Qt::X11BypassWindowManagerHint ); + setFrameStyle( QFrame::NoFrame ); + viewport()->setAutoFillBackground( false ); + setHorizontalScrollBarPolicy( Qt::ScrollBarAlwaysOff ); + setVerticalScrollBarPolicy( Qt::ScrollBarAlwaysOff ); + setAttribute( Qt::WA_TranslucentBackground ); + m_frame.setImagePath( "dialogs/background" ); + m_frame.setCacheAllRenderedFrames( true ); + m_frame.setEnabledBorders( Plasma::FrameSvg::AllBorders ); + + m_item_frame.setImagePath( "widgets/pager" ); + m_item_frame.setCacheAllRenderedFrames( true ); + m_item_frame.setEnabledBorders( Plasma::FrameSvg::AllBorders ); + + reconfigure(); + + m_delayedHideTimer.setSingleShot( true ); + connect( &m_delayedHideTimer, SIGNAL(timeout()), this, SLOT(hide()) ); + + m_scene = new QGraphicsScene( 0 ); + setScene( m_scene ); + + m_scene->addItem( new DesktopChangeText( m_wspace ) ); + } + +DesktopChangeOSD::~DesktopChangeOSD() + { + delete m_scene; + } + +void DesktopChangeOSD::reconfigure() + { + KSharedConfigPtr c(KGlobal::config()); + const KConfigGroup cg = c->group( "PopupInfo" ); + m_show = cg.readEntry( "ShowPopup", false ); + m_delayTime = cg.readEntry( "PopupHideDelay", 1500 ); + } + +void DesktopChangeOSD::desktopChanged( int old ) + { + if( !m_show ) + return; + // we have to stop in case the old desktop does not exist anymore + if( old > m_wspace->numberOfDesktops() ) + return; + // calculate where icons have to be shown + QPoint diff = m_wspace->desktopGridCoords( m_wspace->currentDesktop() ) - m_wspace->desktopGridCoords( old ); + QHash< int, DesktopChangeItem::Arrow > hash = QHash< int, DesktopChangeItem::Arrow>(); + int desktop = old; + int target = m_wspace->currentDesktop(); + int x = diff.x(); + int y = diff.y(); + if( y >= 0 ) + { + // first go in x direction, then in y + while( desktop != target ) + { + if( x != 0 ) + { + if( x < 0 ) + { + x++; + hash.insert( desktop, DesktopChangeItem::LEFT ); + desktop = m_wspace->desktopToLeft( desktop ); + } + else + { + x--; + hash.insert( desktop, DesktopChangeItem::RIGHT ); + desktop = m_wspace->desktopToRight( desktop ); + } + continue; + } + y--; + hash.insert( desktop, DesktopChangeItem::DOWN ); + desktop = m_wspace->desktopBelow( desktop ); + } + } + else + { + // first go in y direction, then in x + while( target != desktop ) + { + if( y != 0 ) + { + // only go upward + y++; + hash.insert( desktop, DesktopChangeItem::UP ); + desktop = m_wspace->desktopAbove( desktop ); + continue; + } + if( x != 0 ) + { + if( x < 0 ) + { + x++; + hash.insert( desktop, DesktopChangeItem::LEFT ); + desktop = m_wspace->desktopToLeft( desktop ); + } + else + { + x--; + hash.insert( desktop, DesktopChangeItem::RIGHT ); + desktop = m_wspace->desktopToRight( desktop ); + } + } + } + } + // now we know which desktop has to show an arrow -> set the arrow for each desktop + int numberOfArrows = qAbs( diff.x() ) + qAbs( diff.y() ); + foreach( QGraphicsItem* it, m_scene->items() ) + { + DesktopChangeItem* item = qgraphicsitem_cast< DesktopChangeItem* >( it ); + if( item ) + { + if( hash.contains( item->desktop() ) ) + { + QPoint distance = m_wspace->desktopGridCoords( m_wspace->currentDesktop() ) + - m_wspace->desktopGridCoords( item->desktop() ); + int desktopDistance = numberOfArrows - ( qAbs( distance.x() ) + qAbs( distance.y() ) ); + int start = m_delayTime/numberOfArrows * desktopDistance - m_delayTime*0.15f; + int stop = m_delayTime/numberOfArrows * (desktopDistance + 1) + m_delayTime*0.15f; + start = qMax( start, 0 ); + item->setArrow( hash[ item->desktop() ], start, stop ); + } + else + { + item->setArrow( DesktopChangeItem::NONE, 0, 0 ); + } + if( old != m_wspace->currentDesktop() ) + { + if( item->desktop() == m_wspace->currentDesktop() ) + item->startDesktopHighlightAnimation( m_delayTime * 0.33 ); + if( m_active && item->desktop() == old ) + item->stopDesktopHightlightAnimation( m_delayTime * 0.33 ); + } + } + } + if( m_active ) + { + // already active - just update and reset timer + update(); + } + else + { + m_active = true; + resize(); + show(); + raise(); + } + m_delayedHideTimer.start( m_delayTime ); + } + +void DesktopChangeOSD::hideEvent( QHideEvent* ) + { + m_delayedHideTimer.stop(); + m_active = false; + } + +void DesktopChangeOSD::drawBackground( QPainter* painter, const QRectF& rect ) + { + painter->save(); + painter->setCompositionMode( QPainter::CompositionMode_Source ); + qreal left, top, right, bottom; + m_frame.getMargins( left, top, right, bottom ); + m_frame.paintFrame( painter, rect.adjusted( -left, -top, right, bottom ) ); + painter->restore(); + } + +void DesktopChangeOSD::numberDesktopsChanged() + { + foreach( QGraphicsItem* it, m_scene->items() ) + { + DesktopChangeItem* item = qgraphicsitem_cast(it); + if( item ) + { + m_scene->removeItem( item ); + } + } + + for( int i=1; i<=m_wspace->numberOfDesktops(); i++ ) + { + DesktopChangeItem* item = new DesktopChangeItem( m_wspace, this, i ); + m_scene->addItem( item ); + } + } + +void DesktopChangeOSD::resize() + { + QRect screenRect = m_wspace->clientArea( ScreenArea, m_wspace->activeScreen(), m_wspace->currentDesktop() ); + QRect fullRect = m_wspace->clientArea( FullArea, m_wspace->activeScreen(), m_wspace->currentDesktop() ); + qreal left, top, right, bottom; + m_frame.getMargins( left, top, right, bottom ); + + QSize desktopGridSize = m_wspace->desktopGridSize(); + float itemWidth = fullRect.width()*0.1f; + float itemHeight = fullRect.height()*0.1f; + // 2 px distance between each desktop + each desktop a width of 5 % of full screen + borders + float width = (desktopGridSize.width()-1)*2 + desktopGridSize.width()*itemWidth + left + right; + float height = (desktopGridSize.height()-1)*2 + top + bottom; + + // bound width between ten and 33 percent of active screen + float tempWidth = qBound( screenRect.width()*0.25f, width, screenRect.width()*0.5f ); + if( tempWidth != width ) + { + // have to adjust the height + width = tempWidth; + itemWidth = (width - (desktopGridSize.width()-1)*2 - left - right)/desktopGridSize.width(); + itemHeight = itemWidth*(float)((float)fullRect.height()/(float)fullRect.width()); + } + height += itemHeight*desktopGridSize.height(); + height += fontMetrics().height() + 4; + + // we do not increase height, but it's bound to a third of screen height + float tempHeight = qMin( height, screenRect.height()*0.5f ); + float itemOffset = 0.0f; + if( tempHeight != height ) + { + // have to adjust item width + height = tempHeight; + itemHeight = (height - (fontMetrics().height() + 4) - top - bottom - (desktopGridSize.height()-1)*2)/ + desktopGridSize.height(); + itemOffset = itemWidth; + itemWidth = itemHeight*(float)((float)fullRect.width()/(float)fullRect.height()); + itemOffset -= itemWidth; + itemOffset *= (float)desktopGridSize.width()*0.5f; + } + + QRect rect = QRect( screenRect.x() + (screenRect.width()-width)/2, + screenRect.y() + (screenRect.height()-height)/2, + width, + height ); + setGeometry( rect ); + m_scene->setSceneRect( 0, 0, width, height ); + m_frame.resizeFrame( QSize( width, height ) ); + setMask( m_frame.mask() ); + + // resize item frame + m_item_frame.setElementPrefix( "normal" ); + m_item_frame.resizeFrame( QSize( itemWidth, itemHeight ) ); + m_item_frame.setElementPrefix( "hover" ); + m_item_frame.resizeFrame( QSize( itemWidth, itemHeight ) ); + + // reset the items + foreach( QGraphicsItem* it, m_scene->items() ) + { + DesktopChangeItem* item = qgraphicsitem_cast(it); + if( item ) + { + item->setWidth( itemWidth ); + item->setHeight( itemHeight ); + QPoint coords = m_wspace->desktopGridCoords( item->desktop() ); + item->setPos( left + itemOffset + coords.x()*(itemWidth+2), + top + fontMetrics().height() + 4 + coords.y()*(itemHeight+4) ); + } + DesktopChangeText* text = qgraphicsitem_cast(it); + if( text ) + { + text->setPos( left, top ); + text->setWidth( width - left - right ); + text->setHeight( fontMetrics().height() ); + } + } + } + +//******************************* +// DesktopChangeText +//******************************* +DesktopChangeText::DesktopChangeText( Workspace* ws ) + : QGraphicsItem() + , m_wspace( ws ) + , m_width( 0.0f ) + , m_height( 0.0f ) + { + } + +DesktopChangeText::~DesktopChangeText() + { + } + +QRectF DesktopChangeText::boundingRect() const + { + return QRectF( 0, 0, m_width, m_height ); + } + +void DesktopChangeText::paint( QPainter* painter, const QStyleOptionGraphicsItem* , QWidget* ) + { + painter->setPen( Plasma::Theme::defaultTheme()->color( Plasma::Theme::TextColor ) ); + painter->drawText( boundingRect(), Qt::AlignCenter | Qt:: AlignVCenter, + m_wspace->desktopName( m_wspace->currentDesktop() ) ); + } + +//******************************* +// DesktopChangeItem +//******************************* +DesktopChangeItem::DesktopChangeItem( Workspace* ws, DesktopChangeOSD* parent, int desktop ) + : QGraphicsItem() + , m_wspace( ws ) + , m_parent( parent ) + , m_desktop( desktop ) + , m_width( 0.0f ) + , m_height( 0.0f ) + , m_hightlight_anim_id( 0 ) + , m_fadein_highlight( 0 ) + , m_arrow( NONE ) + , m_arrow_shown( 0 ) + , m_arrow_anim_id( 0 ) + , m_fadein_arrow( 0 ) + , m_arrow_progress( 0.0 ) + { + m_delayed_show_arrow_timer.setSingleShot( true ); + m_delayed_hide_arrow_timer.setSingleShot( true ); + connect( &m_delayed_show_arrow_timer, SIGNAL(timeout()), this, SLOT(showArrow())); + connect( &m_delayed_hide_arrow_timer, SIGNAL(timeout()), this, SLOT(hideArrow())); + connect( Plasma::Animator::self(), SIGNAL(customAnimationFinished(int)), this, SLOT(animationFinished(int))); + } + +DesktopChangeItem::~DesktopChangeItem() + { + } + +QRectF DesktopChangeItem::boundingRect() const + { + return QRectF( 0, 0, m_width, m_height ); + } + +void DesktopChangeItem::setArrow( Arrow arrow, int start_delay, int hide_delay ) + { + // stop timers + m_delayed_show_arrow_timer.stop(); + m_delayed_hide_arrow_timer.stop(); + if( m_arrow_anim_id != 0 ) + { + Plasma::Animator::self()->stopCustomAnimation( m_arrow_anim_id ); + m_arrow_anim_id = 0; + } + m_arrow_shown = false; + m_arrow = arrow; + if( m_arrow != NONE ) + { + m_delayed_show_arrow_timer.start( start_delay ); + m_delayed_hide_arrow_timer.start( hide_delay ); + } + } + +void DesktopChangeItem::showArrow() + { + m_arrow_shown = true; + if( m_arrow_anim_id != 0 ) + { + Plasma::Animator::self()->stopCustomAnimation( m_arrow_anim_id ); + } + m_fadein_arrow = true; + m_arrow_anim_id = Plasma::Animator::self()->customAnimation(40 / (1000 / (m_parent->getDelayTime()*0.15f)), + m_parent->getDelayTime()*0.15f, Plasma::Animator::EaseInCurve, this, "animationUpdate" ); + } + +void DesktopChangeItem::hideArrow() + { + if( m_arrow_anim_id != 0 ) + { + Plasma::Animator::self()->stopCustomAnimation( m_arrow_anim_id ); + } + m_fadein_arrow = false; + m_arrow_anim_id = Plasma::Animator::self()->customAnimation(40 / (1000 / (m_parent->getDelayTime()*0.15f)), + m_parent->getDelayTime()*0.15f, Plasma::Animator::EaseOutCurve, this, "animationUpdate" ); + } + +void DesktopChangeItem::startDesktopHighlightAnimation( int time ) + { + if( m_hightlight_anim_id != 0 ) + { + // stop current animation + Plasma::Animator::self()->stopCustomAnimation( m_hightlight_anim_id ); + } + m_fadein_highlight = true; + m_hightlight_anim_id = Plasma::Animator::self()->customAnimation(40 / (1000 / (qreal)time), + time, Plasma::Animator::EaseInCurve, this, "animationUpdate" ); + } + +void DesktopChangeItem::stopDesktopHightlightAnimation( int time ) + { + if( m_hightlight_anim_id != 0 ) + { + // stop current animation + Plasma::Animator::self()->stopCustomAnimation( m_hightlight_anim_id ); + } + m_fadein_highlight = false; + m_hightlight_anim_id = Plasma::Animator::self()->customAnimation(40 / (1000 / (qreal)time), + time, Plasma::Animator::EaseOutCurve, this, "animationUpdate" ); + } + +void DesktopChangeItem::animationUpdate( qreal progress, int id ) + { + if( id == m_hightlight_anim_id ) + { + if( m_fadein_highlight ) + m_hightlight_progress = progress; + else + m_hightlight_progress = 1.0 - progress; + update(); + } + if( id == m_arrow_anim_id ) + { + if( m_fadein_arrow ) + m_arrow_progress = progress; + else + m_arrow_progress = 1.0 - progress; + update(); + } + } + +void DesktopChangeItem::animationFinished( int id ) + { + if( id == m_hightlight_anim_id ) + { + m_hightlight_anim_id = 0; + update(); + } + if( id == m_arrow_anim_id ) + { + m_arrow_anim_id = 0; + if( !m_fadein_arrow ) + m_arrow_shown = false; + update(); + } + } + +void DesktopChangeItem::paint( QPainter* painter, const QStyleOptionGraphicsItem* , QWidget* ) + { + if( m_wspace->currentDesktop() == m_desktop || m_hightlight_anim_id != 0 ) + { + qreal left, top, right, bottom; + m_parent->itemFrame()->getMargins( left, top, right, bottom ); + if( m_hightlight_anim_id ) + { + // there is an animation - so we use transition from normal to active or vice versa + if( m_fadein_highlight ) + { + m_parent->itemFrame()->setElementPrefix( "normal" ); + QPixmap normal = m_parent->itemFrame()->framePixmap(); + m_parent->itemFrame()->setElementPrefix( "hover" ); + QPixmap result = Plasma::PaintUtils::transition( normal, + m_parent->itemFrame()->framePixmap(), m_hightlight_progress ); + painter->drawPixmap( boundingRect().toRect(), result); + } + else + { + m_parent->itemFrame()->setElementPrefix( "hover" ); + QPixmap normal = m_parent->itemFrame()->framePixmap(); + m_parent->itemFrame()->setElementPrefix( "normal" ); + QPixmap result = Plasma::PaintUtils::transition( normal, + m_parent->itemFrame()->framePixmap(), 1.0 - m_hightlight_progress ); + painter->drawPixmap( boundingRect().toRect(), result); + } + } + else + { + // no animation - just render the active frame + m_parent->itemFrame()->setElementPrefix( "hover" ); + m_parent->itemFrame()->paintFrame( painter, boundingRect() ); + } + + QColor rectColor = Plasma::Theme::defaultTheme()->color( Plasma::Theme::TextColor ); + rectColor.setAlphaF( 0.6 * m_hightlight_progress ); + QBrush rectBrush = QBrush( rectColor ); + painter->fillRect( boundingRect().adjusted( left, top, -right, -bottom ), rectBrush ); + } + else + { + m_parent->itemFrame()->setElementPrefix( "normal" ); + m_parent->itemFrame()->paintFrame( painter, boundingRect() ); + } + + if( !m_arrow_shown ) + return; + // paint the arrow + QPixmap icon; + int iconWidth = 32; + qreal maxsize = qMin( boundingRect().width(), boundingRect().height() ); + if( maxsize > 128.0 ) + iconWidth = 128; + else if( maxsize > 64.0 ) + iconWidth = 64.0; + else if( maxsize > 32.0 ) + iconWidth = 32.0; + else + iconWidth = 16.0; + QRect iconRect = QRect( boundingRect().x() + boundingRect().width()/2 - iconWidth/2, + boundingRect().y() + boundingRect().height()/2 - iconWidth/2, + iconWidth, iconWidth ); + switch( m_arrow ) + { + case UP: + icon = KIconLoader::global()->loadIcon( "go-up", KIconLoader::Desktop, iconWidth ); + break; + case DOWN: + icon = KIconLoader::global()->loadIcon( "go-down", KIconLoader::Desktop, iconWidth ); + break; + case LEFT: + icon = KIconLoader::global()->loadIcon( "go-previous", KIconLoader::Desktop, iconWidth ); + break; + case RIGHT: + icon = KIconLoader::global()->loadIcon( "go-next", KIconLoader::Desktop, iconWidth ); + break; + default: + break; + } + if( m_arrow != NONE ) + { + if( m_arrow_anim_id != 0 ) + { + QPixmap temp( icon.size() ); + temp.fill( Qt::transparent ); + + QPainter p( &temp ); + p.setCompositionMode( QPainter::CompositionMode_Source ); + p.drawPixmap( 0, 0, icon ); + p.setCompositionMode( QPainter::CompositionMode_DestinationIn ); + p.fillRect( temp.rect(), QColor( 0, 0, 0, 255*m_arrow_progress ) ); + p.end(); + + icon = temp; + } + painter->drawPixmap( iconRect, icon ); + } + } +} + +#include "desktopchangeosd.moc" diff --git a/desktopchangeosd.h b/desktopchangeosd.h new file mode 100644 index 0000000000..df3c8e221a --- /dev/null +++ b/desktopchangeosd.h @@ -0,0 +1,142 @@ +/******************************************************************** + KWin - the KDE window manager + This file is part of the KDE project. + +Copyright (C) 2009 Martin Gräßlin + +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 . +*********************************************************************/ + +#ifndef DESKTOPCHANGEOSD_H +#define DESKTOPCHANGEOSD_H + +#include +#include +#include +#include + +class QGraphicsScene; + +namespace KWin +{ +class Workspace; + +class DesktopChangeText : public QGraphicsItem + { + public: + DesktopChangeText( Workspace* ws ); + ~DesktopChangeText(); + + enum { Type = UserType + 2 }; + + inline void setWidth( float width ) { m_width = width;}; + inline void setHeight( float height ) { m_height = height;}; + + virtual QRectF boundingRect() const; + virtual void paint( QPainter* painter, const QStyleOptionGraphicsItem*, QWidget* ); + inline virtual int type() const { return Type; }; + + private: + Workspace* m_wspace; + float m_width; + float m_height; + }; + +class DesktopChangeOSD : public QGraphicsView + { + public: + DesktopChangeOSD( Workspace* ws ); + ~DesktopChangeOSD(); + + void reconfigure(); + void desktopChanged( int old ); + void numberDesktopsChanged(); + + inline Plasma::FrameSvg* itemFrame() { return &m_item_frame;}; + inline int& getDelayTime() { return m_delayTime; }; + + protected: + virtual void hideEvent( QHideEvent* ); + virtual void drawBackground( QPainter* painter, const QRectF& rect ); + + private: + void resize(); + Workspace* m_wspace; + Plasma::FrameSvg m_frame; + Plasma::FrameSvg m_item_frame; + QGraphicsScene* m_scene; + bool m_active; + QTimer m_delayedHideTimer; + bool m_show; + int m_delayTime; + }; + +class DesktopChangeItem : public QObject, public QGraphicsItem + { + Q_OBJECT + public: + DesktopChangeItem( Workspace* ws, DesktopChangeOSD* parent, int desktop ); + ~DesktopChangeItem(); + enum { Type = UserType + 1 }; + void startDesktopHighlightAnimation( int time ); + void stopDesktopHightlightAnimation( int time ); + + inline void setWidth( float width ) { m_width = width;}; + inline void setHeight( float height ) { m_height = height;}; + inline int desktop() const { return m_desktop; }; + + virtual QRectF boundingRect() const; + virtual void paint( QPainter* painter, const QStyleOptionGraphicsItem*, QWidget* ); + inline virtual int type() const { return Type; }; + + enum Arrow + { + NONE, + LEFT, + RIGHT, + UP, + DOWN + }; + void setArrow( Arrow arrow, int start_delay, int hide_delay ); + + public slots: + void animationUpdate( qreal progress, int id ); + void animationFinished( int id ); + + private slots: + void showArrow(); + void hideArrow(); + + private: + Workspace* m_wspace; + DesktopChangeOSD* m_parent; + int m_desktop; + float m_width; + float m_height; + int m_hightlight_anim_id; + bool m_fadein_highlight; + qreal m_hightlight_progress; + QTimer m_delayed_show_arrow_timer; + QTimer m_delayed_hide_arrow_timer; + + Arrow m_arrow; + bool m_arrow_shown; + int m_arrow_anim_id; + bool m_fadein_arrow; + qreal m_arrow_progress; + }; + +} + +#endif // DESKTOPCHANGEOSD_H diff --git a/workspace.cpp b/workspace.cpp index 7a8a41ded8..6643592848 100644 --- a/workspace.cpp +++ b/workspace.cpp @@ -44,8 +44,8 @@ along with this program. If not, see . #include #include "client.h" -#include "popupinfo.h" #include "tabbox.h" +#include "desktopchangeosd.h" #include "atoms.h" #include "placement.h" #include "notifications.h" @@ -117,7 +117,7 @@ Workspace::Workspace( bool restore ) , mouse_emulation( false ) , block_focus( 0 ) , tab_box( 0 ) - , popupinfo( 0 ) + , desktop_change_osd( 0 ) , popup( 0 ) , advanced_popup( 0 ) , trans_popup( 0 ) @@ -227,7 +227,7 @@ Workspace::Workspace( bool restore ) client_keys = new KActionCollection( this ); initShortcuts(); tab_box = new TabBox( this ); - popupinfo = new PopupInfo( this ); + desktop_change_osd = new DesktopChangeOSD( this ); init(); @@ -343,6 +343,7 @@ void Workspace::init() loadDesktopSettings(); updateDesktopLayout(); + desktop_change_osd->numberDesktopsChanged(); // Extra NETRootInfo instance in Client mode is needed to get the values of the properties NETRootInfo client_info( display(), NET::ActiveWindow | NET::CurrentDesktop ); int initial_desktop; @@ -485,7 +486,7 @@ Workspace::~Workspace() ++it ) (*it)->release(); delete tab_box; - delete popupinfo; + delete desktop_change_osd; discardPopup(); XDeleteProperty( display(), rootWindow(), atoms->kwin_running ); @@ -1032,7 +1033,7 @@ void Workspace::slotReconfigure() unsigned long changed = options->updateSettings(); tab_box->reconfigure(); - popupinfo->reconfigure(); + desktop_change_osd->reconfigure(); initPositioning->reinitCascading( 0 ); readShortcuts(); forEachClient( CheckIgnoreFocusStealingProcedure()); @@ -1426,8 +1427,9 @@ bool Workspace::setCurrentDesktop( int new_desktop ) // s += QString::number( desktop_focus_chain[i] ) + ", "; //kDebug( 1212 ) << s << "}\n"; - if( old_desktop != 0 ) // Not for the very first time - popupinfo->showInfo( desktopName( currentDesktop() )); + // Not for the very first time, only if something changed and there are more than 1 desktops + if( old_desktop != 0 && old_desktop != new_desktop && numberOfDesktops() > 1 ) + desktop_change_osd->desktopChanged( old_desktop ); if( effects != NULL && old_desktop != 0 && old_desktop != new_desktop ) static_cast( effects )->desktopChanged( old_desktop ); @@ -1507,6 +1509,9 @@ void Workspace::setNumberOfDesktops( int n ) desktop_focus_chain.resize( n ); for( int i = 0; i < int( desktop_focus_chain.size() ); i++ ) desktop_focus_chain[i] = i+1; + + // reset the desktop change osd + desktop_change_osd->numberDesktopsChanged(); } /** diff --git a/workspace.h b/workspace.h index adc94ce127..e1856bf4de 100644 --- a/workspace.h +++ b/workspace.h @@ -56,7 +56,7 @@ namespace KWin class Client; class TabBox; -class PopupInfo; +class DesktopChangeOSD; class RootInfo; class PluginMgr; class Placement; @@ -793,7 +793,7 @@ class Workspace : public QObject, public KDecorationDefines int block_focus; TabBox* tab_box; - PopupInfo* popupinfo; + DesktopChangeOSD* desktop_change_osd; QMenu* popup; QMenu* advanced_popup;