New on-screen-display for desktop change. It highlights the new desktop and shows arrows from the old to the new desktop. It replaces the popupinfo which only showed the desktop name. Nevertheless keeping popupinfo in svn so if wanted we can add an option to select between osd and popupinfo.

FEATURE: 185799

svn path=/trunk/KDE/kdebase/workspace/; revision=950182

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 

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 <kde@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 "desktopchangeosd.h"
+#include <QTextStream>
+#include "workspace.h"
+
+#include <QHash>
+#include <QGraphicsScene>
+#include <QRect>
+#include <KDE/Plasma/Theme>
+#include <KDE/Plasma/Animator>
+#include <KDE/Plasma/PaintUtils>
+#include <kiconloader.h>
+
+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<DesktopChangeItem*>(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<DesktopChangeItem*>(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<DesktopChangeText*>(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"

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 <kde@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/>.
+*********************************************************************/
+
+#ifndef DESKTOPCHANGEOSD_H
+#define DESKTOPCHANGEOSD_H
+
+#include <QGraphicsView>
+#include <QGraphicsItem>
+#include <QTimer>
+#include <KDE/Plasma/FrameSvg>
+
+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

workspace.cpp

@@ -44,8 +44,8 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include <QtDBus/QtDBus>
 
 #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<EffectsHandlerImpl*>( 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();
     }
 
 /**

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;