Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdebase@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 1643 insertions, 0 deletions

diff --git a/kicker/taskbar/taskcontainer.cpp b/kicker/taskbar/taskcontainer.cpp
new file mode 100644
index 000000000..7025d643a
--- /dev/null
+++ b/kicker/taskbar/taskcontainer.cpp
@@ -0,0 +1,1643 @@
+/*****************************************************************
+
+Copyright (c) 2001 Matthias Elter <elter@kde.org>
+Copyright (c) 2002 John Firebaugh <jfirebaugh@kde.org>
+Copyright (c) 2005 Aaron Seigo <aseigo@kde.org>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.#
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+******************************************************************/
+
+#include <assert.h>
+
+#include <qbitmap.h>
+#include <qcolor.h>
+#include <qcursor.h>
+#include <qimage.h>
+#include <qpainter.h>
+#include <qpixmap.h>
+#include <qstyle.h>
+#include <qstylesheet.h>
+#include <qtooltip.h>
+
+#include <kapplication.h>
+#include <kdebug.h>
+#include <kglobalsettings.h>
+#include <klocale.h>
+#include <kiconeffect.h>
+#include <kiconloader.h>
+#include <kimageeffect.h>
+
+#include "global.h"
+#include "kickerSettings.h"
+#include "paneldrag.h"
+#include "taskbar.h"
+#include "taskbarsettings.h"
+#include "tasklmbmenu.h"
+#include "taskrmbmenu.h"
+
+#include "taskcontainer.h"
+#include "taskcontainer.moc"
+
+TaskContainer::TaskContainer(Task::Ptr task, TaskBar* bar,
+                             QWidget *parent, const char *name)
+    : QToolButton(parent, name),
+      currentFrame(0),
+      attentionState(-1),
+      lastActivated(0),
+      m_menu(0),
+      m_startup(0),
+      arrowType(Qt::UpArrow),
+      taskBar(bar),
+      discardNextMouseEvent(false),
+      aboutToActivate(false),
+      m_mouseOver(false),
+      m_paintEventCompression(false)
+{
+    init();
+    setAcceptDrops(true); // Always enabled to activate task during drag&drop.
+
+    add(task);
+
+    // we abuse this timer once to get shown
+    // no point in having another timer just for this, and
+    // a single shot won't do because we need to stop the timer
+    // in case our task is deleted out from under us
+    dragSwitchTimer.start(0, true);
+}
+
+TaskContainer::TaskContainer(Startup::Ptr startup, PixmapList& startupFrames,
+                             TaskBar* bar, QWidget *parent, const char *name)
+    : QToolButton(parent, name),
+      currentFrame(0),
+      frames(startupFrames),
+      attentionState(-1),
+      lastActivated(0),
+      m_menu(0),
+      m_startup(startup),
+      arrowType(Qt::LeftArrow),
+      taskBar(bar),
+      discardNextMouseEvent(false),
+      aboutToActivate(false),
+      m_mouseOver(false),
+      m_paintEventCompression(false)
+{
+    init();
+    setEnabled(false);
+
+    sid = m_startup->bin();
+
+    connect(m_startup, SIGNAL(changed()), SLOT(update()));
+
+    dragSwitchTimer.start(333, true);
+}
+
+void TaskContainer::init()
+{
+    setWFlags(WNoAutoErase);
+    setBackgroundMode(NoBackground);
+    animBg = QPixmap(16, 16);
+
+    installEventFilter(KickerTip::the());
+
+    connect(&animationTimer, SIGNAL(timeout()), SLOT(animationTimerFired()));
+    connect(&dragSwitchTimer, SIGNAL(timeout()), SLOT(showMe()));
+    connect(&attentionTimer, SIGNAL(timeout()), SLOT(attentionTimerFired()));
+    connect(&m_paintEventCompressionTimer, SIGNAL(timeout()), SLOT(updateNow()));
+}
+
+TaskContainer::~TaskContainer()
+{
+    if (m_menu)
+    {
+        delete m_menu;
+        m_menu = 0;
+    }
+
+    stopTimers();
+}
+
+void TaskContainer::showMe()
+{
+    if(!frames.isEmpty() && taskBar->showIcon())
+        animationTimer.start(100);
+
+    emit showMe(this);
+    disconnect(&dragSwitchTimer, SIGNAL(timeout()), this, SLOT(showMe()));
+    connect(&dragSwitchTimer, SIGNAL(timeout()), SLOT(dragSwitch()));
+}
+
+void TaskContainer::stopTimers()
+{
+    animationTimer.stop();
+    dragSwitchTimer.stop();
+    attentionTimer.stop();
+}
+
+void TaskContainer::taskChanged(bool geometryOnlyChange)
+{
+    if (geometryOnlyChange)
+    {
+        // we really don't care about those changes, which we may be getting
+        // thanks to the pager, for instance, turning it on in taskmanager.
+        // // let's ignore them so we don't end up with tons of processing going on
+        return;
+    }
+
+    const QObject* source = sender();
+    Task::Ptr task = 0;
+    Task::List::const_iterator itEnd = tasks.constEnd();
+    for (Task::List::const_iterator it = tasks.constBegin(); it != itEnd; ++it)
+    {
+        if (*it == source)
+        {
+            task = *it;
+            break;
+        }
+    }
+
+    if (task)
+    {
+        checkAttention(task);
+    }
+
+    KickerTip::Client::updateKickerTip();
+    update();
+}
+
+void TaskContainer::iconChanged()
+{
+    const QObject* source = sender();
+    Task::Ptr task = 0;
+    Task::List::const_iterator itEnd = tasks.constEnd();
+    for (Task::List::const_iterator it = tasks.constBegin(); it != itEnd; ++it)
+    {
+        if (*it == source)
+        {
+            task = *it;
+            break;
+        }
+    }
+
+    if (task && !m_filteredTasks.empty() && task != m_filteredTasks.first())
+    {
+        if (m_menu)
+        {
+            m_menu->update();
+        }
+        return;
+    }
+    
+    KickerTip::Client::updateKickerTip();
+    QToolButton::update();
+}
+
+void TaskContainer::setLastActivated()
+{
+    Task::List::const_iterator itEnd = m_filteredTasks.constEnd();
+    for (Task::List::const_iterator it = m_filteredTasks.constBegin(); it != itEnd; ++it)
+    {
+        Task::Ptr t = *it;
+        if ( t->isActive() )
+        {
+            lastActivated = t;
+            return;
+        }
+    }
+    lastActivated = 0L;
+}
+
+
+void TaskContainer::animationTimerFired()
+{
+    if (!frames.isEmpty() && taskBar->showIcon() && frames.at(currentFrame) != frames.end())
+    {
+        QPixmap *pm = *frames.at(currentFrame);
+
+        // draw pixmap
+        if ( pm && !pm->isNull() ) {
+	    // we only have to redraw the background for frames 0, 8 and 9
+	    if ( currentFrame == 0 || currentFrame > 7 ) {
+		// double buffered painting
+		QPixmap composite( animBg );
+		bitBlt( &composite, 0, 0, pm );
+		bitBlt( this, iconRect.x(), iconRect.y(), &composite );
+    	    }
+	    else
+		bitBlt( this, iconRect.x(), iconRect.y(), pm );
+	}
+
+        // increment frame counter
+        if ( currentFrame >= 9)
+	    currentFrame = 0;
+        else
+	    currentFrame++;
+    }
+}
+
+void TaskContainer::checkAttention(const Task::Ptr t)
+{
+    bool attention = t ? t->demandsAttention() : false;
+    if (attention && attentionState == -1) // was activated
+    {
+        attentionState = 0;
+        attentionTimer.start(500);
+    }
+    else if(!attention && attentionState >= 0)
+    { // need to check all
+        Task::List::iterator itEnd = tasks.end();
+        for (Task::List::iterator it = tasks.begin(); it != itEnd; ++it)
+        {
+            if ((*it)->demandsAttention())
+            {
+                attention = true;
+                break;
+            }
+        }
+
+        if (!attention)
+        {
+            attentionTimer.stop();
+            attentionState = -1;
+        }
+    }
+}
+
+void TaskContainer::attentionTimerFired()
+{
+    assert( attentionState != -1 );
+    if (attentionState < TaskBarSettings::attentionBlinkIterations()*2)
+    {
+        ++attentionState;
+    }
+    else if (TaskBarSettings::attentionBlinkIterations() < 1000)
+    {
+        attentionTimer.stop();
+    }
+    else
+    {
+        // we have a "forever" blinker (attentionBlinkIterations > 999) and have reached
+        // the upper limit. so we need to decrement the attentionState to make it blink
+        --attentionState;
+    }
+    update();
+}
+
+QSizePolicy TaskContainer::sizePolicy() const
+{
+    return QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding );
+}
+
+void TaskContainer::resizeEvent( QResizeEvent * )
+{
+    // calculate the icon rect
+    QRect br( style().subRect( QStyle::SR_PushButtonContents, this ) );
+    iconRect = QStyle::visualRect( QRect(br.x() + 2, (height() - 16) / 2, 16, 16), this );
+}
+
+void TaskContainer::add(Task::Ptr task)
+{
+    if (!task)
+    {
+        return;
+    }
+
+    tasks.append(task);
+
+    if (sid.isEmpty())
+    {
+        sid = task->classClass();
+    }
+
+    updateFilteredTaskList();
+    checkAttention(task);
+
+    KickerTip::Client::updateKickerTip();
+    update();
+
+    connect(task, SIGNAL(changed(bool)), SLOT(taskChanged(bool)));
+    connect(task, SIGNAL(iconChanged()), SLOT(iconChanged()));
+    connect(task, SIGNAL(activated()), SLOT(setLastActivated()));
+}
+
+void TaskContainer::remove(Task::Ptr task)
+{
+    if (!task)
+    {
+        return;
+    }
+
+    task->publishIconGeometry(QRect());
+    for (Task::List::Iterator it = tasks.begin(); it != tasks.end(); ++it)
+    {
+        if ((*it) == task)
+        {
+            tasks.erase(it);
+            break;
+        }
+    }
+
+    updateFilteredTaskList();
+
+    if (isEmpty())
+    {
+        stopTimers();
+        return;
+    }
+
+    checkAttention();
+    KickerTip::Client::updateKickerTip();
+    update();
+}
+
+void TaskContainer::remove(Startup::Ptr startup)
+{
+    if (!startup || startup != m_startup)
+    {
+        return;
+    }
+
+    m_startup = 0;
+    animationTimer.stop();
+    frames.clear();
+
+    if (!tasks.isEmpty())
+    {
+        setEnabled(true);
+    }
+}
+
+bool TaskContainer::contains(Task::Ptr task)
+{
+    if (!task)
+    {
+        return false;
+    }
+
+    for (Task::List::Iterator it = tasks.begin(); it != tasks.end(); ++it)
+    {
+        if ((*it) == task)
+        {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool TaskContainer::contains(Startup::Ptr startup)
+{
+    return startup && (m_startup == startup);
+}
+
+bool TaskContainer::contains(WId win)
+{
+    Task::List::iterator itEnd = tasks.end();
+    for (Task::List::iterator it = tasks.begin(); it != itEnd; ++it)
+    {
+        if ((*it)->window() == win)
+        {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool TaskContainer::isEmpty()
+{
+    return (tasks.isEmpty() && !m_startup);
+}
+
+QString TaskContainer::id()
+{
+    return sid;
+}
+
+void TaskContainer::updateNow()
+{
+    m_paintEventCompression = true;
+    update();
+}
+
+void TaskContainer::setBackground()
+{
+    updateNow();
+}
+
+void TaskContainer::paintEvent( QPaintEvent* )
+{
+    if (!m_paintEventCompression)
+    {
+        if (!m_paintEventCompressionTimer.isActive())
+        {
+            m_paintEventCompressionTimer.start(30, true);
+        }
+        return;
+    }
+
+    m_paintEventCompression = false;
+    QPixmap* pm = new QPixmap(size());
+
+    const QPixmap* background = taskBar->backgroundPixmap();
+
+    if (background)
+    {
+        QPoint pt = mapTo(taskBar, QPoint(0, 0)) + taskBar->backgroundOffset();
+        QPainter p(pm);
+        p.drawTiledPixmap(0, 0, width(), height(), *background, pt.x(), pt.y());
+        p.end();
+    }
+    else
+    {
+        pm->fill(taskBar->paletteBackgroundColor());
+    }
+
+    QPainter p;
+    p.begin(pm ,this);
+    drawButton(&p);
+    p.end();
+
+    bitBlt(this, 0, 0, pm);
+    delete pm;
+}
+
+void TaskContainer::drawButton(QPainter *p)
+{
+    if (isEmpty())
+    {
+        return;
+    }
+
+    // get a pointer to the pixmap we're drawing on
+    QPixmap *pm((QPixmap*)p->device());
+    QPixmap pixmap; // icon
+    Task::Ptr task = 0;
+    bool iconified = !TaskBarSettings::showOnlyIconified();
+    bool halo = TaskBarSettings::haloText();
+    bool alwaysDrawButtons = TaskBarSettings::drawButtons();
+    bool drawButton = alwaysDrawButtons ||
+                      (m_mouseOver && !halo && isEnabled() &&
+                       TaskBarSettings::showButtonOnHover());
+    QFont font(KGlobalSettings::taskbarFont());
+
+    // draw sunken if we contain the active task
+    bool active = false;
+    bool demandsAttention = false;
+    Task::List::iterator itEnd = m_filteredTasks.end();
+    for (Task::List::iterator it = m_filteredTasks.begin(); it != itEnd; ++it)
+    {
+        task = *it;
+        if (iconified && !task->isIconified())
+        {
+            iconified = false;
+        }
+
+        if (task->isActive())
+        {
+            active = true;
+        }
+
+        if (task->demandsAttention())
+        {
+            demandsAttention = attentionState == TaskBarSettings::attentionBlinkIterations() ||
+                               attentionState % 2 == 0;
+        }
+    }
+
+    font.setBold(active);
+
+    QColorGroup colors = palette().active();
+    
+    if (TaskBarSettings::useCustomColors())
+    {
+        colors.setColor( QColorGroup::Button, TaskBarSettings::taskBackgroundColor());
+        colors.setColor( QColorGroup::Background, TaskBarSettings::taskBackgroundColor() );
+        colors.setColor( QColorGroup::ButtonText, TaskBarSettings::inactiveTaskTextColor() );
+        colors.setColor( QColorGroup::Text, TaskBarSettings::inactiveTaskTextColor() );
+    }
+    
+    if (demandsAttention)
+    {
+        if (!drawButton)
+        {
+            halo = true;
+
+            QRect r = rect();
+            QColor line = colors.highlight();
+            r.addCoords(2, 2, -2, -2);
+            p->fillRect(r, line);
+            for (int i = 0; i < 2; ++i)
+            {
+                line = KickerLib::blendColors(line, colors.background());
+                p->setPen(QPen(line, 1, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));
+                r.addCoords(-1, -1, 1, 1);
+                p->drawRect(r);
+            }
+        }
+
+        // blink until blink timeout, then display differently without blinking
+        colors.setColor( QColorGroup::Button,     colors.highlight() );
+        colors.setColor( QColorGroup::Background, colors.highlight() );
+        colors.setColor( QColorGroup::ButtonText, colors.highlightedText() );
+        colors.setColor( QColorGroup::Text,       colors.highlightedText() );
+    }
+
+    if (active || aboutToActivate)
+    {
+        colors.setColor(QColorGroup::Button, colors.button().dark(110));
+    }
+
+    // get the task icon
+    if (task)
+    {
+        pixmap = task->pixmap();
+    }
+
+    bool sunken = isDown() || (alwaysDrawButtons && (active || aboutToActivate));
+    bool reverse = QApplication::reverseLayout();
+    QRect br(style().subRect(QStyle::SR_PushButtonContents, this));
+    QPoint shift = QPoint(style().pixelMetric(QStyle::PM_ButtonShiftHorizontal),
+                          style().pixelMetric(QStyle::PM_ButtonShiftVertical));
+
+    // draw button background
+    if (drawButton)
+    {
+        style().drawPrimitive(QStyle::PE_HeaderSection, p,
+                              QRect(0, 0, width(), height()),
+                              colors);
+    }
+
+    // shift button label on sunken buttons
+    if (sunken)
+    {
+        p->translate(shift.x(), shift.y());
+    }
+
+    if (taskBar->showIcon())
+    {
+        if (pixmap.isNull() && m_startup)
+        {
+            pixmap = SmallIcon(m_startup->icon());
+        }
+
+        if ( !pixmap.isNull() )
+        {
+            // make sure it is no larger than 16x16
+            if ( pixmap.width() > 16 || pixmap.height() > 16 )
+            {
+                QImage tmp = pixmap.convertToImage();
+                pixmap.convertFromImage( tmp.smoothScale( 16, 16 ) );
+            }
+
+            // fade out the icon when minimized
+            if (iconified)
+            {
+                KIconEffect::semiTransparent( pixmap );
+            }
+
+            // draw icon
+            QRect pmr(0, 0, pixmap.width(), pixmap.height());
+            pmr.moveCenter(iconRect.center());
+            p->drawPixmap(pmr, pixmap);
+        }
+    }
+
+    // find text
+    QString text = name();
+
+    // modified overlay
+    static QString modStr = "[" + i18n( "modified" ) + "]";
+    int modStrPos = text.find( modStr );
+    int textPos = ( taskBar->showIcon() && (!pixmap.isNull() || m_startup)) ? 2 + 16 + 2 : 0;
+
+    if (modStrPos >= 0)
+    {
+        // +1 because we include a space after the closing brace.
+        text.remove(modStrPos, modStr.length() + 1);
+        QPixmap modPixmap = SmallIcon("modified");
+
+        // draw modified overlay
+        if (!modPixmap.isNull())
+        {
+            QRect r = QStyle::visualRect(QRect(br.x() + textPos,
+                                               (height() - 16) / 2, 16, 16),
+                                         this);
+
+            if (iconified)
+            {
+                KIconEffect::semiTransparent(modPixmap);
+            }
+
+            p->drawPixmap(r, modPixmap);
+            textPos += 16 + 2;
+        }
+    }
+
+    // draw text
+    if (!text.isEmpty())
+    {
+        QRect tr = QStyle::visualRect(QRect(br.x() + textPos + 1, 0,
+                                            width() - textPos, height()),
+                                      this);
+        int textFlags = AlignVCenter | SingleLine;
+        textFlags |= reverse ? AlignRight : AlignLeft;
+        QPen textPen;
+
+        // get the color for the text label
+        if (iconified)
+        {
+            textPen = QPen(KickerLib::blendColors(colors.button(), colors.buttonText()));
+        }
+        else if (!active)
+        {
+            textPen = QPen(colors.buttonText());
+        }
+        else // hack for the dotNET style and others
+        {
+            if (TaskBarSettings::useCustomColors())
+            {
+                textPen = QPen(TaskBarSettings::activeTaskTextColor());
+            }
+            else
+            {
+                textPen = p->pen();
+            }
+        }
+
+        int availableWidth = width() - (br.x() * 2) - textPos;
+        if (m_filteredTasks.count() > 1)
+        {
+            availableWidth -= 8;
+        }
+
+        if (QFontMetrics(font).width(text) > availableWidth)
+        {
+            // draw text into overlay pixmap
+            QPixmap tpm(*pm);
+            QPainter tp(&tpm);
+
+            if (sunken)
+            {
+                tp.translate(shift.x(), shift.y());
+            }
+
+            tp.setFont(font);
+            tp.setPen(textPen);
+
+            if (halo)
+            {
+                taskBar->textShadowEngine()->drawText(tp, tr, textFlags, text, size());
+            }
+            else
+            {
+                tp.drawText(tr, textFlags, text);
+            }
+
+            // blend text into background image
+            QImage img = pm->convertToImage();
+            QImage timg = tpm.convertToImage();
+            KImageEffect::blend(img, timg, *taskBar->blendGradient(size()), KImageEffect::Red);
+            pm->convertFromImage(img);
+        }
+        else
+        {
+            p->setFont(font);
+            p->setPen(textPen);
+
+            if (halo)
+            {
+                taskBar->textShadowEngine()->drawText(*p, tr, textFlags, text, size());
+            }
+            else
+            {
+                p->drawText(tr, textFlags, text);
+            }
+        }
+    }
+
+    if (!frames.isEmpty() && m_startup && frames.at(currentFrame) != frames.end())
+    {
+        QPixmap *anim = *frames.at(currentFrame);
+
+        if (anim && !anim->isNull())
+        {
+            // save the background for the other frames
+            bitBlt(&animBg, QPoint(0,0), pm, iconRect);
+            // draw the animation frame
+            bitBlt(pm, iconRect.x(), iconRect.y(), anim);
+        }
+    }
+
+    if (sunken)
+    {
+        // Change the painter back so the arrow, etc gets drawn in the right location
+        p->translate(-shift.x(), -shift.y());
+    }
+
+    // draw popup arrow
+    if (m_filteredTasks.count() > 1)
+    {
+        QStyle::PrimitiveElement e = QStyle::PE_ArrowLeft;
+
+        switch (arrowType)
+        {
+            case Qt::LeftArrow:  e = QStyle::PE_ArrowLeft;  break;
+            case Qt::RightArrow: e = QStyle::PE_ArrowRight; break;
+            case Qt::UpArrow:    e = QStyle::PE_ArrowUp;    break;
+            case Qt::DownArrow:  e = QStyle::PE_ArrowDown;  break;
+        }
+
+        int flags = QStyle::Style_Enabled;
+        QRect ar = QStyle::visualRect(QRect(br.x() + br.width() - 8 - 2,
+                                            br.y(), 8, br.height()), this);
+        if (sunken)
+        {
+            flags |= QStyle::Style_Down;
+        }
+
+        style().drawPrimitive(e, p, ar, colors, flags);
+    }
+    
+    // draw mouse over frame in transparent mode
+    if (m_mouseOver && halo)
+        KickerLib::drawBlendedRect(p, QRect(0, 0, width(), height()), colorGroup().foreground());
+
+    if (aboutToActivate)
+    {
+        aboutToActivate = false;
+    }
+}
+
+QString TaskContainer::name()
+{
+    // default to container id
+    QString text;
+
+    // single task -> use mainwindow caption
+    if (m_filteredTasks.count() == 1)
+    {
+        text = m_filteredTasks.first()->visibleName();
+    }
+    else if (m_filteredTasks.count() > 1)
+    {
+        // multiple tasks -> use the common part of all captions
+        // if it is more descriptive than the class name
+        const QString match = m_filteredTasks.first()->visibleName();
+        unsigned int maxLength = match.length();
+        unsigned int i = 0;
+        bool stop = false;
+
+        // what we do is find the right-most letter than the names do NOT have
+        // in common, and then use everything UP TO that as the name in the button
+        while (i < maxLength)
+        {
+            QChar check = match.at(i).lower();
+            Task::List::iterator itEnd = m_filteredTasks.end();
+            for (Task::List::iterator it = m_filteredTasks.begin(); it != itEnd; ++it)
+            {
+                // we're doing a lot of Utf8 -> QString conversions here
+                // by repeatedly calling visibleIconicName() =/
+                if (check != (*it)->visibleName().at(i).lower())
+                {
+                    if (i > 0)
+                    {
+                        --i;
+                    }
+                    stop = true;
+                    break;
+                }
+            }
+
+            if (stop)
+            {
+                break;
+            }
+
+            ++i;
+        }
+
+        // strip trailing crap
+        while (i > 0 && !match.at(i).isLetterOrNumber())
+        {
+            --i;
+        }
+
+        // more descriptive than id()?
+        if (i > 0 && (i + 1) >= id().length())
+        {
+            text = match.left(i + 1);
+        }
+    }
+    else if (m_startup && !m_startup->text().isEmpty())
+    {
+        // fall back to startup name
+        text = m_startup->text();
+    }
+
+    if (text.isEmpty())
+    {
+        text = id();
+
+        // Upper case first letter: seems to be the right thing to do for most cases
+        text[0] = text[0].upper();
+    }
+
+    if (m_filteredTasks.count() > 1)
+    {
+        // this is faster than (" [%1]").arg() or +
+        // and it's as fast as using append, but cleaner looking
+        text += " [";
+        text += QString::number(m_filteredTasks.count());
+        text += "]";
+    }
+
+    return text;
+}
+
+void TaskContainer::mousePressEvent( QMouseEvent* e )
+{
+    if (discardNextMouseEvent)
+    {
+        discardNextMouseEvent = false;
+        return;
+    }
+
+    if (e->button() == LeftButton)
+    {
+        m_dragStartPos = e->pos();
+    }
+    else
+    {
+        m_dragStartPos = QPoint();
+    }
+
+    int buttonAction = 0;
+
+    // On left button, only do actions that invoke a menu.
+    // Other actions will be handled in mouseReleaseEvent
+    switch (e->button())
+    {
+        case LeftButton:
+            buttonAction = TaskBarSettings::action(TaskBarSettings::LeftButton);
+            break;
+        case MidButton:
+            buttonAction = TaskBarSettings::action(TaskBarSettings::MiddleButton);
+            break;
+        case RightButton:
+        default:
+            buttonAction = TaskBarSettings::action(TaskBarSettings::RightButton);
+            break;
+    }
+
+    if ((buttonAction == TaskBarSettings::ShowTaskList &&
+          m_filteredTasks.count() > 1) ||
+        buttonAction == TaskBarSettings::ShowOperationsMenu)
+    {
+        performAction(buttonAction);
+    }
+}
+
+void TaskContainer::mouseReleaseEvent(QMouseEvent *e)
+{
+    m_dragStartPos = QPoint();
+
+    if (!TaskBarSettings::drawButtons())
+    {
+        setDown(false);
+    }
+
+    // This is to avoid the flicker caused by redrawing the
+    // button as unpressed just before it's activated.
+    if (!rect().contains(e->pos()))
+    {
+        QToolButton::mouseReleaseEvent(e);
+        return;
+    }
+
+    int buttonAction = 0;
+
+    switch (e->button())
+    {
+        case LeftButton:
+            buttonAction = TaskBarSettings::action(TaskBarSettings::LeftButton);
+            break;
+        case MidButton:
+            buttonAction = TaskBarSettings::action(TaskBarSettings::MiddleButton);
+            break;
+        case RightButton:
+        default:
+            buttonAction = TaskBarSettings::action(TaskBarSettings::RightButton);
+            break;
+    }
+
+    if ((buttonAction == TaskBarSettings::ShowTaskList &&
+         m_filteredTasks.count() > 1) ||
+        buttonAction == TaskBarSettings::ShowOperationsMenu)
+    {
+        return;
+    }
+
+    if (buttonAction == TaskBarSettings::ActivateRaiseOrMinimize ||
+        buttonAction == TaskBarSettings::Activate)
+    {
+        aboutToActivate = true;
+    }
+
+    performAction( buttonAction );
+    QTimer::singleShot(0, this, SLOT(update()));
+}
+
+void TaskContainer::performAction(int action)
+{
+    if (m_filteredTasks.isEmpty())
+    {
+        return;
+    }
+
+    switch( action ) {
+    case TaskBarSettings::ShowTaskList:
+    // If there is only one task, the correct behavior is
+    // to activate, raise, or iconify it, not show the task menu.
+    if( m_filteredTasks.count() > 1 ) {
+                popupMenu( TaskBarSettings::ShowTaskList );
+    } else {
+                performAction( TaskBarSettings::ActivateRaiseOrMinimize );
+    }
+    break;
+    case TaskBarSettings::ShowOperationsMenu:
+        popupMenu( TaskBarSettings::ShowOperationsMenu );
+    break;
+    case TaskBarSettings::ActivateRaiseOrMinimize:
+    if (m_filteredTasks.isEmpty())
+    {
+        break;
+    }
+    if (m_filteredTasks.count() == 1)
+    {
+        m_filteredTasks.first()->activateRaiseOrIconify();
+    }
+    else
+    {
+        // multiple tasks -> cycle list
+        bool hasLastActivated = false;
+        Task::List::iterator itEnd = m_filteredTasks.end();
+        for (Task::List::iterator it = m_filteredTasks.begin(); it != itEnd; ++it)
+        {
+            if ((*it) == lastActivated)
+            {
+                hasLastActivated = true;
+            }
+
+            if ((*it)->isActive())
+            {
+                // activate next
+                ++it;
+                if (it == itEnd)
+                {
+                    it = m_filteredTasks.begin();
+                }
+                (*it)->activateRaiseOrIconify();
+                return;
+            }
+        }
+
+        if (hasLastActivated)
+        {
+            lastActivated->activateRaiseOrIconify();
+        }
+        else
+        {
+            m_filteredTasks[0]->activateRaiseOrIconify();
+        }
+    }
+    break;
+    case TaskBarSettings::Activate:
+        m_filteredTasks.first()->activate();
+    break;
+    case TaskBarSettings::Raise:
+        m_filteredTasks.first()->raise();
+    break;
+    case TaskBarSettings::Lower:
+        m_filteredTasks.first()->lower();
+    break;
+    case TaskBarSettings::Minimize:
+        m_filteredTasks.first()->toggleIconified();
+    break;
+    case TaskBarSettings::Close:
+        m_filteredTasks.first()->close();
+    break;
+    case TaskBarSettings::ToCurrentDesktop:
+        m_filteredTasks.first()->toCurrentDesktop();
+    break;
+    default:
+        kdWarning(1210) << "Unknown taskbar action!" << endl;
+        break;
+    }
+}
+
+// forcenext == true means the last entry in the previous
+// taskcontainer was active -> activate first
+bool TaskContainer::activateNextTask(bool forward, bool& forcenext)
+{
+    if (forcenext)
+    {
+        if (m_filteredTasks.isEmpty())
+        {
+            return false;
+        }
+
+        if (forward)
+        {
+            m_filteredTasks.first()->activate();
+        }
+        else
+        {
+            m_filteredTasks.last()->activate();
+        }
+
+        forcenext = false;
+        return true;
+    }
+
+    Task::List::iterator itEnd = m_filteredTasks.end();
+    for (Task::List::iterator it = m_filteredTasks.begin();
+         it != itEnd;
+         ++it)
+    {
+        if ((*it)->isActive())
+        {
+            if (forward)
+            {
+                ++it;
+                if (it == itEnd)
+                {
+                    forcenext = true;
+                    return false;
+                }
+
+                (*it)->activate();
+                return true;
+            }
+            else if (it == m_filteredTasks.begin())
+            {
+                forcenext = true;
+                return false;
+            }
+
+            --it;
+            (*it)->activate();
+            return true;
+        }
+    }
+
+    return false;
+}
+
+void TaskContainer::popupMenu(int action)
+{
+    if (action == TaskBarSettings::ShowTaskList )
+    {
+        m_menu = new TaskLMBMenu(m_filteredTasks);
+    }
+    else if (action == TaskBarSettings::ShowOperationsMenu)
+    {
+        if (!kapp->authorizeKAction("kwin_rmb"))
+        {
+            return;
+        }
+
+        m_menu = new TaskRMBMenu(m_filteredTasks, taskBar->showAllWindows());
+    }
+    else
+    {
+        return;
+    }
+
+    // calc popup menu position
+    QPoint pos(mapToGlobal(QPoint(0, 0)));
+
+    switch( arrowType )
+    {
+        case RightArrow:
+            pos.setX(pos.x() + width());
+            break;
+        case LeftArrow:
+            pos.setX(pos.x() - m_menu->sizeHint().width());
+            break;
+        case DownArrow:
+            if ( QApplication::reverseLayout() )
+                pos.setX( pos.x() + width() - m_menu->sizeHint().width() );
+            pos.setY( pos.y() + height() );
+            break;
+        case UpArrow:
+            if ( QApplication::reverseLayout() )
+                pos.setX( pos.x() + width() - m_menu->sizeHint().width() );
+            pos.setY(pos.y() - m_menu->sizeHint().height());
+            break;
+        default:
+            break;
+    }
+    m_menu->installEventFilter( this );
+    m_menu->exec( pos );
+
+    delete m_menu;
+    m_menu = 0;
+}
+
+void TaskContainer::mouseMoveEvent( QMouseEvent* e )
+{
+    kdDebug() << "regular move" << endl;
+    if (!m_dragStartPos.isNull())
+    {
+        startDrag(e->pos());
+    }
+
+    QToolButton::mouseMoveEvent(e);
+}
+
+bool TaskContainer::startDrag(const QPoint& pos)
+{
+    if (m_filteredTasks.count() != 1)
+    {
+        return false;
+    }
+
+    int delay = KGlobalSettings::dndEventDelay();
+
+    if ((m_dragStartPos - pos).manhattanLength() > delay)
+    {
+        if (!m_filteredTasks.first()->isActive())
+        {
+            setDown(false);
+        }
+
+        TaskDrag* drag = new TaskDrag(m_filteredTasks, this);
+
+        if (!m_filteredTasks.isEmpty())
+        {
+            kdDebug() << m_filteredTasks.first()->name() << endl;
+            drag->setPixmap(m_filteredTasks.first()->pixmap());
+        }
+
+        drag->dragMove();
+        return true;
+    }
+
+    return false;
+}
+
+// This is the code that gives us the proper behavior
+// when a popup menu is displayed and we are clicked:
+// close the menu, and don't reopen it immediately.
+// It's copied from QToolButton. Unfortunately Qt is lame
+// as usual and makes interesting stuff private or
+// non-virtual, so we have to copy code.
+bool TaskContainer::eventFilter(QObject *o, QEvent *e)
+{
+    switch ( e->type() )
+    {
+        case QEvent::MouseButtonPress:
+        case QEvent::MouseButtonDblClick:
+        {
+            QMouseEvent *me = (QMouseEvent*)e;
+            QPoint p = me->globalPos();
+            if ( QApplication::widgetAt( p, true ) == this )
+            {
+                if (me->type() == QEvent::MouseButtonPress &&
+                    me->button() == LeftButton)
+                {
+                    m_dragStartPos = mapFromGlobal(p);
+                }
+
+                discardNextMouseEvent = true;
+            }
+            break;
+        }
+        case QEvent::MouseButtonRelease:
+        {
+            m_dragStartPos = QPoint();
+            break;
+        }
+        case QEvent::MouseMove:
+        {
+            if (!m_dragStartPos.isNull())
+            {
+                QMouseEvent* me = static_cast<QMouseEvent*>(e);
+                QPoint p(me->globalPos());
+
+                if (me->state() & LeftButton &&
+                    QApplication::widgetAt(p, true) == this)
+                {
+                    kdDebug() << "event move" << endl;
+                    if (startDrag(mapFromGlobal(p)))
+                    {
+                        QPopupMenu* menu = dynamic_cast<QPopupMenu*>(o);
+
+                        if (menu)
+                        {
+                            menu->hide();
+                        }
+                    }
+                }
+            }
+            break;
+        }
+
+        default:
+        break;
+    }
+
+    return QToolButton::eventFilter( o, e );
+}
+
+void TaskContainer::setArrowType( Qt::ArrowType at )
+{
+    if (arrowType == at)
+    {
+        return;
+    }
+
+    arrowType = at;
+    update();
+}
+
+void TaskContainer::publishIconGeometry( QPoint global )
+{
+    QPoint p = global + geometry().topLeft();
+
+    Task::List::const_iterator itEnd = tasks.constEnd();
+    for (Task::List::const_iterator it = tasks.constBegin(); it != itEnd; ++it)
+    {
+        Task::Ptr t = *it;
+        t->publishIconGeometry(QRect(p.x(), p.y(), width(), height()));
+    }
+}
+
+void TaskContainer::dragEnterEvent( QDragEnterEvent* e )
+{
+    // ignore task drags and applet drags
+    if (TaskDrag::canDecode(e) || PanelDrag::canDecode(e))
+    {
+        return;
+    }
+
+    // if a dragitem is held for over a taskbutton for two seconds,
+    // activate corresponding window
+    if (m_filteredTasks.isEmpty())
+    {
+        return;
+    }
+
+    if (!m_filteredTasks.first()->isActive() ||
+        m_filteredTasks.count() > 1)
+    {
+        dragSwitchTimer.start(1000, true);
+    }
+
+    QToolButton::dragEnterEvent( e );
+}
+
+void TaskContainer::dragLeaveEvent( QDragLeaveEvent* e )
+{
+    dragSwitchTimer.stop();
+
+    QToolButton::dragLeaveEvent( e );
+}
+
+void TaskContainer::enterEvent(QEvent* e)
+{
+    QToolTip::remove(this);
+    m_mouseOver = true;
+    updateNow();
+
+    if (tasks.isEmpty())
+    {
+        QToolButton::enterEvent(e);
+        return;
+    }
+
+    if (!KickerSettings::showMouseOverEffects())
+    {
+        QString tooltip = "<qt>" + QStyleSheet::escape(name()) + "</qt>";
+        QToolTip::add(this, tooltip);
+        return;
+    }
+}
+
+void TaskContainer::leaveEvent(QEvent*)
+{
+    m_mouseOver = false;
+    updateNow();
+}
+
+void TaskContainer::dragSwitch()
+{
+    if (m_filteredTasks.isEmpty())
+    {
+        return;
+    }
+
+    if (m_filteredTasks.count() == 1)
+    {
+        m_filteredTasks.first()->activate();
+    }
+    else
+    {
+        popupMenu(TaskBarSettings::ShowTaskList);
+    }
+}
+
+int TaskContainer::desktop()
+{
+    if ( tasks.isEmpty() )
+        return TaskManager::the()->currentDesktop();
+
+    if ( tasks.count() > 1 )
+        return TaskManager::the()->numberOfDesktops();
+
+    return tasks.first()->desktop();
+}
+
+bool TaskContainer::onCurrentDesktop()
+{
+    if (m_startup)
+    {
+        return true;
+    }
+
+    Task::List::const_iterator itEnd = tasks.constEnd();
+    for (Task::List::const_iterator it = tasks.constBegin(); it != itEnd; ++it)
+    {
+        Task::Ptr t = *it;
+        if (t->isOnCurrentDesktop())
+        {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool TaskContainer::isOnScreen()
+{
+    if (isEmpty())
+    {
+        return false;
+    }
+
+    int screen = taskBar->showScreen();
+    if ((tasks.isEmpty() && m_startup) || screen == -1)
+    {
+        return true;
+    }
+
+    Task::List::iterator itEnd = tasks.end();
+    for (Task::List::iterator it = tasks.begin(); it != itEnd; ++it)
+    {
+        if ((*it)->isOnScreen( screen ))
+        {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool TaskContainer::isIconified()
+{
+    if (isEmpty())
+    {
+        return false;
+    }
+
+    if (tasks.isEmpty() && m_startup)
+    {
+        return true;
+    }
+
+    Task::List::const_iterator itEnd = tasks.constEnd();
+    for (Task::List::const_iterator it = tasks.constBegin(); it != itEnd; ++it)
+    {
+        if ((*it)->isIconified())
+        {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+void TaskContainer::updateFilteredTaskList()
+{
+    m_filteredTasks.clear();
+
+    Task::List::const_iterator itEnd = tasks.constEnd();
+    for (Task::List::const_iterator it = tasks.constBegin(); it != itEnd; ++it)
+    {
+        Task::Ptr t = *it;
+        if ((taskBar->showAllWindows() || t->isOnCurrentDesktop()) &&
+            (!TaskBarSettings::showOnlyIconified() || t->isIconified()))
+        {
+            m_filteredTasks.append(t);
+        }
+        else
+        {
+            t->publishIconGeometry( QRect());
+        }
+    }
+
+    // sort container list by desktop
+    if (taskBar->sortByDesktop() && m_filteredTasks.count() > 1)
+    {
+        QValueVector<QPair<int, Task::Ptr> > sorted;
+        sorted.resize(m_filteredTasks.count());
+        int i = 0;
+
+        Task::List::const_iterator itEnd = m_filteredTasks.constEnd();
+        for (Task::List::const_iterator it = m_filteredTasks.constBegin(); it != itEnd; ++it)
+        {
+            Task::Ptr t = *it;
+            sorted[i] = (qMakePair(t->desktop(), t));
+            ++i;
+        }
+
+        qHeapSort(sorted);
+
+        m_filteredTasks.clear();
+        for (QValueVector<QPair<int, Task::Ptr> >::iterator it = sorted.begin();
+             it != sorted.end();
+             ++it)
+        {
+            m_filteredTasks.append((*it).second);
+        }
+    }
+}
+
+void TaskContainer::desktopChanged(int)
+{
+    updateFilteredTaskList();
+    KickerTip::Client::updateKickerTip();
+    update();
+}
+
+void TaskContainer::windowChanged(Task::Ptr)
+{
+    updateFilteredTaskList();
+    KickerTip::Client::updateKickerTip();
+    update();
+}
+
+void TaskContainer::settingsChanged()
+{
+    updateFilteredTaskList();
+    KickerTip::Client::updateKickerTip();
+    update();
+}
+
+void TaskContainer::updateKickerTip(KickerTip::Data& data)
+{
+    if (m_startup)
+    {
+        data.message = m_startup->text();
+        data.duration = 4000;
+        data.subtext = i18n("Loading application ...");
+        data.icon = KGlobal::iconLoader()->loadIcon(m_startup->icon(),
+                                                    KIcon::Small,
+                                                    KIcon::SizeMedium,
+                                                    KIcon::DefaultState,
+                                                    0, true);
+        return;
+    }
+
+    QPixmap pixmap;
+    QString name;
+    QString details;
+    
+    if (m_filteredTasks.count() > 0)
+    {
+        if (TaskBarSettings::showThumbnails() &&
+            m_filteredTasks.count() == 1)
+        {
+            Task::Ptr t = m_filteredTasks.first();
+    
+            pixmap = t->thumbnail(TaskBarSettings::thumbnailMaxDimension());
+        }
+    
+        if (pixmap.isNull() && tasks.count())
+        {
+            // try to load icon via net_wm
+            pixmap = KWin::icon(tasks.last()->window(),
+                                KIcon::SizeMedium,
+                                KIcon::SizeMedium,
+                                true);
+        }
+    
+        // Collect all desktops the tasks are on. Sort naturally.
+        QMap<int, QString> desktopMap;
+        bool demandsAttention = false;
+        bool modified = false;
+        bool allDesktops = false;
+        Task::List::const_iterator itEnd = m_filteredTasks.constEnd();
+        for (Task::List::const_iterator it = m_filteredTasks.constBegin(); it != itEnd; ++it)
+        {
+            Task::Ptr t = *it;
+            if (t->demandsAttention())
+            {
+                demandsAttention = true;
+            }
+    
+            if (t->isModified())
+            {
+                modified = true;
+            }
+    
+            if (t->isOnAllDesktops())
+            {
+                allDesktops = true;
+                desktopMap.clear();
+            }
+            else if (!allDesktops)
+            {
+                desktopMap.insert(t->desktop(),
+                                TaskManager::the()->desktopName(t->desktop()));
+            }
+        }
+    
+        if (TaskBarSettings::showAllWindows() && KWin::numberOfDesktops() > 1)
+        {
+            if (desktopMap.isEmpty())
+            {
+                details.append(i18n("On all desktops"));
+            }
+            else
+            {
+                QStringList desktopNames = desktopMap.values();
+                details.append(i18n("On %1").arg(QStyleSheet::escape(desktopNames.join(", "))) + "<br>");
+            }
+        }
+    
+        if (demandsAttention)
+        {
+            details.append(i18n("Requesting attention") + "<br>");
+        }
+    
+        name = this->name();
+        if (modified)
+        {
+            details.append(i18n("Has unsaved changes"));
+    
+            static QString modStr = "[" + i18n( "modified" ) + "]";
+            int modStrPos = name.find(modStr);
+    
+            if (modStrPos >= 0)
+            {
+                // +1 because we include a space after the closing brace.
+                name.remove(modStrPos, modStr.length() + 1);
+            }
+        }
+    }
+
+    data.message = QStyleSheet::escape(name);
+    data.subtext = details;
+    data.icon = pixmap;
+    data.direction = KickerLib::arrowToDirection(arrowType);
+}
+
+void TaskContainer::finish()
+{
+    // Disconnect all signal/slot connections to avoid triggering a popupMenu() call,
+    // whose event loop is the root of all (or at least much) evil.
+    // Unfortunately, we can't just do "disconnect()", because that gets us a bunch
+    // of dangling QGuardedPtr objects (most notably in QTipManager.) (kling)
+
+    animationTimer.disconnect();
+    dragSwitchTimer.disconnect();
+    attentionTimer.disconnect();
+
+    if (m_startup)
+        m_startup->disconnect(this);
+
+    for (Task::List::Iterator it = tasks.begin(); it != tasks.end(); ++it)
+    {
+        (*it)->disconnect(this);
+    }
+
+    if (m_menu)
+        m_menu->close();
+}