diff --git a/plasma/widgets/tooltip.cpp b/plasma/widgets/tooltip.cpp
index 863e4e5f42..900f1b3da7 100644
--- a/plasma/widgets/tooltip.cpp
+++ b/plasma/widgets/tooltip.cpp
@@ -1,311 +1,319 @@
 /*
  *   Copyright 2007 by Dan Meltzer <hydrogen@notyetimplemented.com>
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU Library General Public License as
  *   published by the Free Software Foundation; either version 2, 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 Library General Public
  *   License along with this program; if not, write to the
  *   Free Software Foundation, Inc.,
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 #include "tooltip_p.h"
 
 #include <QBitmap>
 #include <QHBoxLayout>
 #include <QLabel>
 #include <QMouseEvent>
 #include <QPixmap>
 #include <QTimer>
 #include <QGraphicsView>
 #ifdef Q_WS_X11
 #include <QX11Info>
 #endif
 
 #include <kglobal.h>
 #include <kwindowsystem.h>
+#include <plasma/theme.h>
 
 #ifdef Q_WS_X11
 #include <X11/Xlib.h>
 #include <fixx11h.h>
 #endif
 
 #include "plasma/plasma.h"
 
 namespace Plasma {
 
 class ToolTip::Private
 {
     public:
         Private()
         : label(0)
         , imageLabel(0)
         , preview(0)
         , windowToPreview(0)
         , currentWidget(0)
         , isShown(false)
         , showTimer(0)
         , hideTimer(0)
     { }
 
     QLabel *label;
     QLabel *imageLabel;
     WindowPreview *preview;
     WId windowToPreview;
     Plasma::Widget *currentWidget;
     bool isShown;
     QTimer *showTimer;
     QTimer *hideTimer;
 };
 
 class ToolTipSingleton
 {
     public:
         ToolTip self;
 };
 K_GLOBAL_STATIC( ToolTipSingleton, privateInstance )
 
 ToolTip *ToolTip::self()
 {
     return &privateInstance->self;
 }
 
 void ToolTip::show(const QPoint &location, Plasma::Widget *widget)
 {
     d->currentWidget = widget;
     setData(widget->toolTip());
-
+    
+    // Make the tooltip use Plasma's colorscheme
+    QPalette plasmaPalette = QPalette();
+    plasmaPalette.setColor(QPalette::Window, Plasma::Theme::self()->backgroundColor());
+    plasmaPalette.setColor(QPalette::WindowText, Plasma::Theme::self()->textColor());    
+    setAutoFillBackground(true);
+    setPalette(plasmaPalette);
+    
     move(location.x(), location.y());
 
     if (d->isShown) {
         // Don't delay if the tooltip is already shown(i.e. moving from one task to another)
         // Qt doesn't seem to like visible tooltips moving though, so hide it and then
         // immediately show it again
         setVisible(false);
 
         // small delay to prevent unecessary showing when the mouse is moving quickly across items
         // which can be too much for less powerful CPUs to keep up with
         d->showTimer->start(150);
     } else {
         d->showTimer->start(500);
     }
 }
 
 void ToolTip::hide()
 {
     d->currentWidget = 0;
     d->showTimer->stop();  //Mouse out, stop the timer to show the tooltip
     setVisible(false);
     d->hideTimer->start(250);  //250 ms delay before we are officially "gone" to allow for the time to move between widgets
 }
 
 Plasma::Widget *ToolTip::currentWidget() const
 {
     return d->currentWidget;
 }
 
 //PRIVATE FUNCTIONS
 void ToolTip::slotShowToolTip()
 {
     QGraphicsView *v = d->currentWidget->view();
     if (v && v->mouseGrabber()) {
         return;
     }
 
     if( d->windowToPreview != 0 ) {
         // show/hide the preview area
         d->preview->show();
     } else {
         d->preview->hide();
     }
     layout()->activate();
 
     d->isShown = true;  //ToolTip is visible
     setVisible(true);
 }
 
 void ToolTip::slotResetTimer()
 {
     if (!isVisible()) { //One might have moused out and back in again
         d->isShown = false;
     }
 }
 
 void ToolTip::showEvent(QShowEvent *e)
 {
     QWidget::showEvent(e);
     d->preview->setInfo();
 }
 
 void ToolTip::mouseReleaseEvent(QMouseEvent* event)
 {
     if (rect().contains(event->pos())) {
         hide();
     }
 }
 
 ToolTip::ToolTip()
     : QWidget(0)
     , d( new Private )
 {
     setWindowFlags(Qt::ToolTip);
     QGridLayout *l = new QGridLayout;
     d->preview = new WindowPreview;
     d->label = new QLabel;
     d->label->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
     d->label->setWordWrap(true);
     d->imageLabel = new QLabel;
     d->imageLabel->setAlignment(Qt::AlignTop | Qt::AlignLeft);
     l->addWidget(d->preview, 0, 0, 1, 2);
     l->addWidget(d->imageLabel, 1, 0);
     l->addWidget(d->label, 1, 1);
     setLayout(l);
 
     d->showTimer = new QTimer(this);
     d->showTimer->setSingleShot(true);
     d->hideTimer = new QTimer(this);
     d->hideTimer->setSingleShot(true);
 
     connect(d->showTimer, SIGNAL(timeout()), SLOT(slotShowToolTip()));
     connect(d->hideTimer, SIGNAL(timeout()), SLOT(slotResetTimer()));
 }
 
 void ToolTip::setData(const Plasma::ToolTipData &data)
 {
     //reset our size
     d->label->setText("<qt><b>" + data.mainText + "</b><br>" +
                         data.subText + "</qt>");
     d->imageLabel->setPixmap(data.image);
     d->windowToPreview = data.windowToPreview;
     d->preview->setWindowId( d->windowToPreview );
 
     resize(sizeHint());
 }
 
 ToolTip::~ToolTip()
 {
     delete d;
 }
 
 
 // A widget which reserves area for window preview and sets hints on the toplevel
 // tooltip widget that tells KWin to render the preview in this area. This depends
 // on KWin's TaskbarThumbnail compositing effect (which is here detected).
 
 void WindowPreview::setWindowId(WId w)
 {
     if (!previewsAvailable()) {
         id = 0;
         return;
     }
     id = w;
     readWindowSize();
 }
 
 bool WindowPreview::previewsAvailable() const
 {
     if (!KWindowSystem::compositingActive()) {
         return false;
     }
 #ifdef Q_WS_X11
     // hackish way to find out if KWin has the effect enabled,
     // TODO provide proper support
     Display* dpy = QX11Info::display();
     Atom atom = XInternAtom(dpy, "_KDE_WINDOW_PREVIEW", False);
     int cnt;
     Atom* list = XListProperties(dpy, DefaultRootWindow( dpy ), &cnt);
     if (list != NULL) {
         bool ret = ( qFind(list, list + cnt, atom) != list + cnt );
         XFree(list);
         return ret;
     }
 #endif
     return false;
 }
 
 QSize WindowPreview::sizeHint() const
 {
     if (id == 0) {
         return QSize();
     }
     if (!windowSize.isValid()) {
         readWindowSize();
     }
     QSize s = windowSize;
     s.scale(200, 150, Qt::KeepAspectRatio);
     return s;
 }
 
 void WindowPreview::readWindowSize() const
 {
 #ifdef Q_WS_X11
     Window r;
     int x, y;
     unsigned int w, h, b, d;
     if (XGetGeometry(QX11Info::display(), id, &r, &x, &y, &w, &h, &b, &d)) {
         windowSize = QSize( w, h );
     } else {
         windowSize = QSize();
     }
 #else
     windowSize = QSize();
 #endif
 }
 
 void WindowPreview::setInfo()
 {
 #ifdef Q_WS_X11
     Display *dpy = QX11Info::display();
     Atom atom = XInternAtom(dpy, "_KDE_WINDOW_PREVIEW", False);
     if (id == 0) {
         XDeleteProperty(dpy, winId(), atom);
         return;
     }
     if (!windowSize.isValid()) {
         readWindowSize();
     }
     if (!windowSize.isValid()) {
         XDeleteProperty(dpy, winId(), atom);
         return;
     }
     Q_ASSERT( parentWidget()->isWindow()); // parent must be toplevel
     long data[] = { 1, 5, id, x(), y(), width(), height() };
     XChangeProperty(dpy, parentWidget()->winId(), atom, atom, 32, PropModeReplace,
         reinterpret_cast< unsigned char* >( data ), sizeof( data ) / sizeof( data[ 0 ] ));
 #endif
 }
 
 void ToolTip::resizeEvent(QResizeEvent *)
 {
     QBitmap mask(width(), height());
     QPainter painter(&mask);
 
     mask.fill(Qt::white);
 
     painter.setBrush(Qt::black);
     painter.setPen(Qt::black);
 
     painter.drawPath(roundedRectangle(mask.rect(), 10));
     setMask(mask);
 }
 
 void ToolTip::paintEvent(QPaintEvent *)
 {
     QPainter painter(this);
     painter.setRenderHint(QPainter::Antialiasing);
 
     //Stroke border
-    painter.setPen(palette().dark().color());
+    painter.setPen(Plasma::Theme::self()->textColor());
     painter.drawPath(roundedRectangle(rect(), 10));
 }
 
 }
 #include "tooltip_p.moc"
diff --git a/plasma/widgets/widget.cpp b/plasma/widgets/widget.cpp
index 33d5f3cd55..a7c22d3057 100644
--- a/plasma/widgets/widget.cpp
+++ b/plasma/widgets/widget.cpp
@@ -1,655 +1,662 @@
 /*
  *   Copyright 2007 by Alexander Wiedenbruch <mail@wiedenbruch.de>
  *                      and Matias Valdenegro <mvaldenegro@informatica.utem.cl>
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU Library General Public License as
  *   published by the Free Software Foundation; either version 2, 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 Library General Public
  *   License along with this program; if not, write to the
  *   Free Software Foundation, Inc.,
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
 
 #include "widget.h"
 
 #include <cmath>
 #include <limits>
 
 #include <QApplication>
 #include <QGraphicsScene>
 #include <QGraphicsSceneHoverEvent>
 #include <QGraphicsView>
 #include <QHelpEvent>
 #include <QList>
 #include <QPainter>
 #include <QPixmapCache>
 #include <QStyleOptionGraphicsItem>
 #include <QDesktopWidget>
 
 #include <KDebug>
+#include <KGlobalSettings>
 
 #include "layouts/freelayout.h"
 #include "plasma/plasma.h"
 #include "plasma/view.h"
 #include "plasma/containment.h"
 #include "tooltip_p.h"
 
 namespace Plasma
 {
 
 class Widget::Private
 {
     public:
         Private()
             : minimumSize(0,0),
               maximumSize(std::numeric_limits<qreal>::infinity(),
                           std::numeric_limits<qreal>::infinity()),
               opacity(1.0),
               cachePaintMode(Widget::NoCacheMode),
               wasMovable(false)
         { }
         ~Private() { }
 
         QSizeF size;
         QSizeF minimumSize;
         QSizeF maximumSize;
 
         qreal opacity;
 
         // Replace with CacheMode in 4.4
 #if QT_VERSION >= 0x040400
 #warning Replace Plasma::Widget::CachePaintMode with QGraphicsItem::CacheMode
 #endif
         Widget::CachePaintMode cachePaintMode;
         QSize cacheSize;
         QString cacheKey;
         QRectF cacheInvalidated;
 
         bool wasMovable;
 
         bool shouldPaint(QPainter *painter, const QTransform &transform);
         ToolTipData toolTip;
 };
 
 QGraphicsItem* Widget::graphicsItem()
 {
     return this;
 }
 
 QGraphicsView *Widget::view() const
 {
     // It's assumed that we won't be visible on more than one view here.
     // Anything that actually needs view() should only really care about
     // one of them anyway though.
     if (!scene()) {
         return 0;
     }
 
     foreach (QGraphicsView *view, scene()->views()) {
         if (view->sceneRect().intersects(sceneBoundingRect()) ||
                 view->sceneRect().contains(scenePos())) {
             return view;
         }
     }
     return 0;
 }
 
 QRectF Widget::mapFromView(const QGraphicsView *view, const QRect &rect) const
 {
     // TODO: Confirm that adjusted() is needed and is not covering for some
     // issue elsewhere
     return mapFromScene(view->mapToScene(rect)).boundingRect().adjusted(0, 0, 1, 1);
 }
 
 QRect Widget::mapToView(const QGraphicsView *view, const QRectF &rect) const
 {
     // TODO: Confirm that adjusted() is needed and is not covering for some
     // issue elsewhere
     return view->mapFromScene(mapToScene(rect)).boundingRect().adjusted(0, 0, -1, -1);
 }
 
 bool Widget::Private::shouldPaint(QPainter *painter, const QTransform &transform)
 {
     Q_UNUSED(painter)
     Q_UNUSED(transform)
     //qreal zoomLevel = painter->transform().m11() / transform.m11();
     //return (fabs(zoomLevel - scalingFactor(Plasma::DesktopZoom))) < std::numeric_limits<double>::epsilon();
     return true;
 }
 
 Widget::Widget(QGraphicsItem *parent, QObject* parentObject)
   : QObject(parentObject),
     QGraphicsItem(parent),
     d(new Private)
 {
     setFlag(QGraphicsItem::ItemClipsToShape, true);
     setFlag(QGraphicsItem::ItemClipsChildrenToShape, true);
     setCachePaintMode(DeviceCoordinateCacheMode);
 
     Widget *w = dynamic_cast<Widget *>(parent);
     if (w) {
         w->addChild(this);
     }
 }
 
 Widget::~Widget()
 {
     if (ToolTip::self()->currentWidget() == this) {
         ToolTip::self()->hide();
     }
     delete d;
 }
 
 void Widget::setOpacity(qreal opacity)
 {
     d->opacity = opacity;
 }
 
 qreal Widget::opacity() const
 {
     return d->opacity;
 }
 
 void Widget::setCachePaintMode(CachePaintMode mode, const QSize &size)
 {
     d->cachePaintMode = mode;
     if (mode == NoCacheMode) {
         QPixmapCache::remove(d->cacheKey);
         d->cacheKey.clear();
     } else {
         d->cacheKey = QString("%1").arg(long(this));
         if (mode == ItemCoordinateCacheMode) {
             d->cacheSize = size.isNull() ? boundingRect().size().toSize() : size;
         }
     }
 }
 
 Widget::CachePaintMode Widget::cachePaintMode() const
 {
     return d->cachePaintMode;
 }
 
 void Widget::update(const QRectF &rect)
 {
     if (d->cachePaintMode != NoCacheMode) {
         d->cacheInvalidated |= rect.isNull() ? boundingRect() : rect;
     }
     QGraphicsItem::update(rect);
 }
 
 Qt::Orientations Widget::expandingDirections() const
 {
     return Qt::Horizontal | Qt::Vertical;
 }
 
 void Widget::setMinimumSize(const QSizeF& size)
 {
     d->minimumSize = size;
     if (d->size != d->size.expandedTo(size)) {
         d->size = d->size.expandedTo(size);
         updateGeometry();
     }
 }
 
 QSizeF Widget::minimumSize() const
 {
     return d->minimumSize;
 }
 
 void Widget::setMaximumSize(const QSizeF& size)
 {
     d->maximumSize = size;
     if (d->size != d->size.boundedTo(size)) {
         d->size = d->size.boundedTo(size);
         updateGeometry();
     }
 }
 
 QSizeF Widget::maximumSize() const
 {
     return d->maximumSize;
 }
 
 bool Widget::hasHeightForWidth() const
 {
     return false;
 }
 
 qreal Widget::heightForWidth(qreal w) const
 {
     Q_UNUSED(w);
 
     return -1.0;
 }
 
 bool Widget::hasWidthForHeight() const
 {
     return false;
 }
 
 qreal Widget::widthForHeight(qreal h) const
 {
     Q_UNUSED(h);
 
     return -1.0;
 }
 
 QRectF Widget::geometry() const
 {
     return QRectF(pos(), d->size);
 }
 
 #if 0
 QRectF Widget::localGeometry() const
 {
     return QRectF(QPointF(0.0f, 0.0f), boundingRect().size);
 }
 #endif
 
 void Widget::setGeometry(const QRectF& geometry)
 {
     if (geometry.size().width() > 0 && geometry.size().height() > 0 && d->size != geometry.size()) {
         prepareGeometryChange();
         qreal width = qBound(d->minimumSize.width(), geometry.size().width(), d->maximumSize.width());
         qreal height = qBound(d->minimumSize.height(), geometry.size().height(), d->maximumSize.height());
 
         d->size = QSizeF(width, height);
 
         if (layout()) {
             layout()->setGeometry(QRectF(QPointF(0, 0), d->size));
         }
 
         if (managingLayout()) {
             managingLayout()->invalidate();
         }
     }
 
     setPos(geometry.topLeft());
     update();
 }
 
 void Widget::setSize(qreal width, qreal height)
 {
     setSize(QSizeF(width, height));
 }
 
 void Widget::setSize(const QSizeF& size)
 {
     d->size = size;
 }
 
 void Widget::updateGeometry()
 {
     if (managingLayout()) {
         managingLayout()->invalidate();
     } else {
         setGeometry(QRectF(pos(), sizeHint()));
     }
 }
 
 QSizeF Widget::sizeHint() const
 {
     if (layout()) {
         return layout()->sizeHint();
     } else {
         return d->size;
     }
 }
 
 QSizeF Widget::size() const
 {
     return d->size;
 }
 
 QFont Widget::font() const
 {
-    return QApplication::font();
+    if (managingLayout()) {
+        kDebug() << "layout, return taskbarFont()";
+        return KGlobalSettings::taskbarFont();
+    } else {
+        kDebug() << "nolayout, return desktopFont()";
+        return KGlobalSettings::desktopFont();
+    }
 }
 
 /*
 void Widget::setFont(const QFront& font)
 {
 }
 */
 
 QRectF Widget::boundingRect() const
 {
     return QRectF(QPointF(0,0), d->size);
 }
 
 void Widget::resize(const QSizeF& size)
 {
     //FIXME: we need to respect minimum size here i think
     setGeometry(QRectF(pos(), size));
 }
 
 void Widget::resize(qreal w, qreal h)
 {
     resize(QSizeF(w, h));
 }
 
 Widget *Widget::parent() const
 {
     return parent(this);
 }
 
 Widget *Widget::parent(const QGraphicsItem *item)
 {
     Q_ASSERT(item);
     QGraphicsItem *parent = item->parentItem();
 
     while (parent) {
         Widget *parentWidget = dynamic_cast<Widget *>(parent);
 
         if (parentWidget) {
             return parentWidget;
         }
 
         parent = parent->parentItem();
     }
     return 0;
 }
 
 void Widget::addChild(Widget *w)
 {
     if (!w || QGraphicsItem::children().contains(w)) {
         return;
     }
 
     w->setParentItem(this);
 
     //kDebug() << "Added Child Widget" <<  (QObject*)w << "our geom is" << geometry();
 
     if (layout()) {
         layout()->addItem(w);
     }
 
     updateGeometry();
     //kDebug() << "after the item is added our geom is now" << geometry();
 }
 
 void Widget::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
 {
     if (d->opacity < 1.0) {
         painter->setOpacity(painter->opacity() * d->opacity);
     }
 
     /*
 NOTE: put this back if we end up needing to control when things paint due to, e.g. zooming.
     if (!d->shouldPaint(painter, transform())) {
         return;
     }
     */
 
     if (d->cachePaintMode == NoCacheMode) {
         paintWidget(painter, option, widget);
         return;
     }
 
     // Cached painting
     QRectF brect = boundingRect();
 
     // Fetch the off-screen transparent buffer and exposed area info.
     QPixmap pix;
     QPixmapCache::find(d->cacheKey, pix);
     QRectF exposed = d->cacheInvalidated;
 
     // Render using item coodinate cache mode.
     if (d->cachePaintMode == ItemCoordinateCacheMode) {
         // Recreate the pixmap if it's gone.
         if (pix.isNull()) {
             pix = QPixmap(d->cacheSize);
             pix.fill(Qt::transparent);
             exposed = brect;
         }
 
         // Check for newly invalidated areas.
         if (!exposed.isNull()) {
             d->cacheInvalidated = QRectF();
 
             QStyleOptionGraphicsItem cacheOption = *option;
             cacheOption.exposedRect = exposed.toRect(); // <- truncation
 
             QPainter pixmapPainter(&pix);
 
             // Fit the item's bounding rect into the pixmap's coordinates.
             pixmapPainter.scale(pix.width() / brect.width(),
                                 pix.height() / brect.height());
             pixmapPainter.translate(-brect.topLeft());
 
             // erase the exposed area so we don't paint over and over
             pixmapPainter.setCompositionMode(QPainter::CompositionMode_Source);
             pixmapPainter.fillRect(exposed, Qt::transparent);
             pixmapPainter.setCompositionMode(QPainter::CompositionMode_SourceOver);
 
             // Re-render the invalidated areas of the pixmap. Important: don't
             // fool the item into using the widget - pass 0 instead of \a
             // widget.
             paintWidget(&pixmapPainter, &cacheOption, 0);
             pixmapPainter.end();
 
             // Reinsert this pixmap into the cache
             QPixmapCache::insert(d->cacheKey, pix);
         }
 
         // Redraw the exposed area using the transformed painter. Depending on
         // the hardware, this may be a server-side operation, or an expensive
         // qpixmap-image-transform-pixmap roundtrip.
         painter->drawPixmap(brect, pix, QRectF(QPointF(), pix.size()));
         return;
     }
 
     // Render using device coordinate cache mode.
     if (d->cachePaintMode == DeviceCoordinateCacheMode) {
         QTransform transform = painter->worldTransform();
         QRect deviceRect = transform.mapRect(brect).toRect();
 
         if (deviceRect.width() < 1 ||
             deviceRect.height() < 1) {
             // we have nothing to paint!
             return;
         }
 
         // Auto-adjust the pixmap size.
         if (deviceRect.size() != pix.size()) {
             pix = QPixmap(deviceRect.size());
             pix.fill(Qt::transparent);
             exposed = brect;
         }
 
         // Check for newly invalidated areas.
         if (!exposed.isNull()) {
             d->cacheInvalidated = QRectF();
 
             // Construct the new styleoption, reset the exposed rect.
             QStyleOptionGraphicsItem cacheOption = *option;
             cacheOption.exposedRect = exposed.toRect(); // <- truncation
 
             QPointF viewOrigo = transform.map(QPointF(0,  0));
             QPointF offset = viewOrigo - deviceRect.topLeft();
 
             // Transform the painter, and render the item in device coordinates.
             QPainter pixmapPainter(&pix);
 
             pixmapPainter.translate(offset);
             pixmapPainter.setWorldTransform(transform, true);
             pixmapPainter.translate(transform.inverted().map(QPointF(0, 0)));
 
             // erase the exposed area so we don't paint over and over
             pixmapPainter.setCompositionMode(QPainter::CompositionMode_Source);
             pixmapPainter.fillRect(exposed, Qt::transparent);
             pixmapPainter.setCompositionMode(QPainter::CompositionMode_SourceOver);
 
             paintWidget(&pixmapPainter, &cacheOption, 0);
             pixmapPainter.end();
 
             // Reinsert this pixmap into the cache
             QPixmapCache::insert(d->cacheKey, pix);
         }
 
         // Redraw the exposed area using an untransformed painter. This
         // effectively becomes a bitblit that does not transform the cache.
         painter->setWorldTransform(QTransform());
         painter->drawPixmap(deviceRect.topLeft(), pix);
         return;
     }
 }
 
 ToolTipData Widget::toolTip() const
 {
     return d->toolTip;
 }
 
 void Widget::setToolTip(const ToolTipData &tip)
 {
     d->toolTip = tip;
     if (ToolTip::self()->currentWidget() == this) {
         ToolTip::self()->show(popupPosition(ToolTip::self()->sizeHint()), this);
     }
 }
 
 void Widget::paintWidget(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
 {
     Q_UNUSED(painter);
     Q_UNUSED(option);
     Q_UNUSED(widget);
 
     // Replaced by widget's own function
 }
 
 QVariant Widget::itemChange(GraphicsItemChange change, const QVariant &value)
 {
     if (change == QGraphicsItem::ItemChildRemovedChange) {
         if (layout()) {
             layout()->removeItem(dynamic_cast<Plasma::LayoutItem*>(value.value<QGraphicsItem*>()));
             updateGeometry();
         }
     }
 
     return QGraphicsItem::itemChange(change, value);
 }
 
 void Widget::managingLayoutChanged()
 {
     if (managingLayout()) {
         d->wasMovable = flags() & ItemIsMovable;
         if (!dynamic_cast<FreeLayout*>(managingLayout())) {
             setFlag(ItemIsMovable, false);
         }
     } else {
         setFlag(ItemIsMovable, d->wasMovable);
     }
 }
 
 QPoint Widget::popupPosition(const QSize s) const
 {
     QPoint pos = view()->mapFromScene(scenePos());
     pos = view()->mapToGlobal(pos);
     Plasma::View *pv = dynamic_cast<Plasma::View *>(view());
 
     Plasma::Location loc = Floating;
     if (pv) {
         loc = pv->containment()->location();
     }
 
     switch (loc) {
     case BottomEdge:
         pos = QPoint(pos.x(), pos.y() - s.height());
         break;
     case TopEdge:
         pos = QPoint(pos.x(), pos.y() + (int)size().height());
         break;
     case LeftEdge:
         pos = QPoint(pos.x() + (int)size().width(), pos.y());
         break;
     case RightEdge:
         pos = QPoint(pos.x() - s.width(), pos.y());
         break;
     default:
         if (pos.y() - s.height() > 0) {
              pos = QPoint(pos.x(), pos.y() - s.height());
         } else {
              pos = QPoint(pos.x(), pos.y() + (int)size().height());
         }
     }
 
     //are we out of screen?
     QRect screenRect = QApplication::desktop()->screenGeometry(pv->containment()->screen());
 
     if (pos.rx() + s.width() > screenRect.width()) {
         pos.rx() -= ((pos.rx() + s.width()) - screenRect.width());
     }
     if (pos.ry() + s.height() > screenRect.height()) {
         pos.ry() -= ((pos.ry() + s.height()) - screenRect.height());
     }
     pos.rx() = qMax(0, pos.rx());
 
     return pos;
 }
 
 void Widget::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
 {
     // HACK: QGraphicsItem's documentation says that the event will be passed
     // to the parent if it's not handled, but it isn't passed. This can be
     // removed when Qt4.4 becomes a requirement. See Qt bug #176902.
     Widget *parentWidget = parent();
     if (parentWidget) {
         parentWidget->contextMenuEvent(event);
     }
 }
 
 bool Widget::sceneEvent(QEvent *event)
 {
     switch (event->type()) {
     case QEvent::GraphicsSceneHoverMove:
         // If the tooltip isn't visible, run through showing the tooltip again
         // so that it only becomes visible after a stationary hover
         if (ToolTip::self()->isVisible()) {
             break;
         }
 
     case QEvent::GraphicsSceneHoverEnter:
     {
         // Check that there is a tooltip to show
         if (d->toolTip.image.isNull() &&
                 d->toolTip.subText.isEmpty() &&
                 d->toolTip.mainText.isEmpty()) {
             break;
         }
 
         // If the mouse is in the widget's area at the time that it is being
         // created the widget can receive a hover event before it is fully
         // initialized, in which case view() will return 0.
         QGraphicsView *parentView = view();
         if (parentView) {
             ToolTip *tip = ToolTip::self();
             tip->adjustSize();
             tip->show(popupPosition(tip->size()), this);
         }
 
         break;
     }
 
     case QEvent::GraphicsSceneHoverLeave:
     case QEvent::GraphicsSceneMousePress:
     case QEvent::GraphicsSceneWheel:
         ToolTip::self()->hide();
 
     default:
         break;
     }
 
     return QGraphicsItem::sceneEvent(event);
 }
 
 } // Plasma namespace