Changeset 46244 in vbox for trunk/src

Timestamp:

May 23, 2013 4:43:46 PM (12 years ago)

Author:

vboxsync

Message:

FE/Qt: 5978: Runtime UI: Rework mini-toolbar visual representation.

Location:

trunk/src/VBox/Frontends/VirtualBox/src

Files:

• runtime/UIMachineWindow.cpp (modified) (1 diff)
• runtime/fullscreen/UIMachineWindowFullscreen.cpp (modified) (4 diffs)
• runtime/fullscreen/UIMachineWindowFullscreen.h (modified) (2 diffs)
• runtime/seamless/UIMachineWindowSeamless.cpp (modified) (6 diffs)
• runtime/seamless/UIMachineWindowSeamless.h (modified) (3 diffs)
• widgets/UIMiniToolBar.cpp (modified) (3 diffs)
• widgets/UIMiniToolBar.h (modified) (2 diffs)

trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMachineWindow.cpp

@@ -402 +402 @@
     /* Add machine-view into main-layout: */
     m_pMainLayout->addWidget(m_pMachineView, 1, 1, viewAlignment(visualStateType));
+
+    /* Install focus-proxy: */
+    setFocusProxy(m_pMachineView);
 }
 

trunk/src/VBox/Frontends/VirtualBox/src/runtime/fullscreen/UIMachineWindowFullscreen.cpp

@@ -103 +103 @@
     /* Get the mini-toolbar auto-hide feature availability: */
     bool fIsAutoHide = m.GetExtraData(GUI_MiniToolBarAutoHide) != "off";
-    m_pMiniToolBar = new UIMiniToolBar(centralWidget(),
-                                       fIsAtTop ? UIMiniToolBar::AlignTop : UIMiniToolBar::AlignBottom,
-                                       true, fIsAutoHide);
-    m_pMiniToolBar->updateDisplay(true, true);
+    /* Create mini-toolbar: */
+    m_pMiniToolBar = new UIRuntimeMiniToolBar(this,
+                                              fIsAtTop ? Qt::AlignTop : Qt::AlignBottom,
+                                              IntegrationMode_Embedded,
+                                              fIsAutoHide);
     QList<QMenu*> menus;
     QList<QAction*> actions = uisession()->newMenu()->actions();
     for (int i=0; i < actions.size(); ++i)
         menus << actions.at(i)->menu();
-    *m_pMiniToolBar << menus;
-    connect(m_pMiniToolBar, SIGNAL(minimizeAction()), this, SLOT(showMinimized()));
-    connect(m_pMiniToolBar, SIGNAL(exitAction()),
+    m_pMiniToolBar->addMenus(menus);
+    connect(m_pMiniToolBar, SIGNAL(sigMinimizeAction()), this, SLOT(showMinimized()));
+    connect(m_pMiniToolBar, SIGNAL(sigExitAction()),
             gActionPool->action(UIActionIndexRuntime_Toggle_Fullscreen), SLOT(trigger()));
-    connect(m_pMiniToolBar, SIGNAL(closeAction()),
+    connect(m_pMiniToolBar, SIGNAL(sigCloseAction()),
             gActionPool->action(UIActionIndexRuntime_Simple_Close), SLOT(trigger()));
 }
@@ -126 +127 @@
 
     /* Save mini-toolbar settings: */
-    machine().SetExtraData(GUI_MiniToolBarAutoHide, m_pMiniToolBar->isAutoHide() ? QString() : "off");
+    machine().SetExtraData(GUI_MiniToolBarAutoHide, m_pMiniToolBar->autoHide() ? QString() : "off");
     /* Delete mini-toolbar: */
     delete m_pMiniToolBar;
@@ -161 +162 @@
     /* Resize to the appropriate size: */
     resize(workingArea.size());
+    /* Move mini-toolbar into appropriate place: */
+    if (m_pMiniToolBar)
+        m_pMiniToolBar->adjustGeometry();
     /* Process pending move & resize events: */
     qApp->processEvents();
@@ -232 +236 @@
             }
             /* Update mini-toolbar text: */
-            m_pMiniToolBar->setDisplayText(m.GetName() + strSnapshotName);
+            m_pMiniToolBar->setText(m.GetName() + strSnapshotName);
         }
     }

trunk/src/VBox/Frontends/VirtualBox/src/runtime/fullscreen/UIMachineWindowFullscreen.h

@@ -24 +24 @@
 
 /* Forward declarations: */
-class UIMiniToolBar;
+class UIRuntimeMiniToolBar;
 
 /* Fullscreen machine-window implementation: */
@@ -68 +68 @@
     /* Widgets: */
     QMenu *m_pMainMenu;
-    UIMiniToolBar *m_pMiniToolBar;
+    UIRuntimeMiniToolBar *m_pMiniToolBar;
 
     /* Factory support: */

trunk/src/VBox/Frontends/VirtualBox/src/runtime/seamless/UIMachineWindowSeamless.cpp

@@ -73 +73 @@
 }
 
-#ifndef Q_WS_MAC
-void UIMachineWindowSeamless::sltUpdateMiniToolBarMask()
-{
-    if (m_pMiniToolBar && machineView())
-        setMask(qobject_cast<UIMachineViewSeamless*>(machineView())->lastVisibleRegion());
-}
-#endif /* !Q_WS_MAC */
-
 void UIMachineWindowSeamless::prepareMenu()
 {
@@ -127 +119 @@
     /* Get the mini-toolbar auto-hide feature availability: */
     bool fIsAutoHide = m.GetExtraData(GUI_MiniToolBarAutoHide) != "off";
-    m_pMiniToolBar = new UIMiniToolBar(centralWidget(),
-                                       fIsAtTop ? UIMiniToolBar::AlignTop : UIMiniToolBar::AlignBottom,
-                                       true, fIsAutoHide);
-    m_pMiniToolBar->setSeamlessMode(true);
-    m_pMiniToolBar->updateDisplay(true, true);
+    /* Create mini-toolbar: */
+    m_pMiniToolBar = new UIRuntimeMiniToolBar(this,
+                                              fIsAtTop ? Qt::AlignTop : Qt::AlignBottom,
+                                              IntegrationMode_External,
+                                              fIsAutoHide);
+    m_pMiniToolBar->show();
     QList<QMenu*> menus;
     QList<QAction*> actions = uisession()->newMenu()->actions();
     for (int i=0; i < actions.size(); ++i)
         menus << actions.at(i)->menu();
-    *m_pMiniToolBar << menus;
-    connect(m_pMiniToolBar, SIGNAL(minimizeAction()), this, SLOT(showMinimized()));
-    connect(m_pMiniToolBar, SIGNAL(exitAction()),
+    m_pMiniToolBar->addMenus(menus);
+    connect(m_pMiniToolBar, SIGNAL(sigMinimizeAction()), this, SLOT(showMinimized()));
+    connect(m_pMiniToolBar, SIGNAL(sigExitAction()),
             gActionPool->action(UIActionIndexRuntime_Toggle_Seamless), SLOT(trigger()));
-    connect(m_pMiniToolBar, SIGNAL(closeAction()),
+    connect(m_pMiniToolBar, SIGNAL(sigCloseAction()),
             gActionPool->action(UIActionIndexRuntime_Simple_Close), SLOT(trigger()));
-    connect(m_pMiniToolBar, SIGNAL(geometryUpdated()), this, SLOT(sltUpdateMiniToolBarMask()));
 }
 #endif /* !Q_WS_MAC */
@@ -154 +146 @@
 
     /* Save mini-toolbar settings: */
-    machine().SetExtraData(GUI_MiniToolBarAutoHide, m_pMiniToolBar->isAutoHide() ? QString() : "off");
+    machine().SetExtraData(GUI_MiniToolBarAutoHide, m_pMiniToolBar->autoHide() ? QString() : "off");
     /* Delete mini-toolbar: */
     delete m_pMiniToolBar;
@@ -192 +184 @@
     /* Resize to the appropriate size: */
     resize(workingArea.size());
+#ifndef Q_WS_MAC
+    /* Move mini-toolbar into appropriate place: */
+    if (m_pMiniToolBar)
+        m_pMiniToolBar->adjustGeometry();
+#endif /* !Q_WS_MAC */
     /* Process pending move & resize events: */
     qApp->processEvents();
@@ -249 +246 @@
             }
             /* Update mini-toolbar text: */
-            m_pMiniToolBar->setDisplayText(m.GetName() + strSnapshotName);
+            m_pMiniToolBar->setText(m.GetName() + strSnapshotName);
         }
     }
@@ -282 +279 @@
     if (m_pLeftSpacer->geometry().width() || m_pTopSpacer->geometry().height())
         region.translate(m_pLeftSpacer->geometry().width(), m_pTopSpacer->geometry().height());
-
-    /* Take into account mini tool-bar region: */
-    if (m_pMiniToolBar)
-    {
-        /* Move mini-toolbar region to mini-toolbar position: */
-        QRegion toolBarRegion(m_pMiniToolBar->rect());
-        toolBarRegion.translate(QPoint(m_pMiniToolBar->x(), m_pMiniToolBar->y()));
-        /* Include mini-toolbar region into common one: */
-        region += toolBarRegion;
-    }
 #endif /* !Q_WS_MAC */
 

trunk/src/VBox/Frontends/VirtualBox/src/runtime/seamless/UIMachineWindowSeamless.h

@@ -24 +24 @@
 
 /* Forward declarations: */
-class UIMiniToolBar;
+class UIRuntimeMiniToolBar;
 
 /* Seamless machine-window implementation: */
@@ -48 +48 @@
     /* Popup main menu: */
     void sltPopupMainMenu();
-
-#ifndef RT_OS_DARWIN
-    /* Current Qt on MAC has something broken in moc generation,
-     * so we have to use RT_OS_DARWIN instead of Q_WS_MAC here. */
-    /* Update mini tool-bar mask: */
-    void sltUpdateMiniToolBarMask();
-#endif /* !RT_OS_DARWIN */
 
 private:
@@ -92 +85 @@
     QMenu *m_pMainMenu;
 #ifndef Q_WS_MAC
-    UIMiniToolBar *m_pMiniToolBar;
+    UIRuntimeMiniToolBar *m_pMiniToolBar;
 #endif /* !Q_WS_MAC */
 

trunk/src/VBox/Frontends/VirtualBox/src/widgets/UIMiniToolBar.cpp

@@ -3 +3 @@
  *
  * VBox frontends: Qt GUI ("VirtualBox"):
- * UIMiniToolBar class declaration & implementation. This is the toolbar shown on fullscreen mode.
+ * UIMiniToolBar class implementation.
+ * This is the toolbar shown in fullscreen/seamless modes.
  */
 
 /*
- * Copyright (C) 2009-2011 Oracle Corporation
+ * Copyright (C) 2009-2013 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -18 +19 @@
  */
 
-/* Local includes */
-#include "UIIconPool.h"
-#include "VBoxGlobal.h"
-#include "UIMiniToolBar.h"
-
-/* Global includes */
-#include <QCursor>
+/* Qt includes: */
+#include <QApplication>
+#include <QTimer>
+#include <QMdiArea>
+#include <QMdiSubWindow>
 #include <QDesktopWidget>
 #include <QLabel>
 #include <QMenu>
-#include <QPaintEvent>
+#include <QToolButton>
+#include <QStateMachine>
 #include <QPainter>
-#include <QPolygon>
-#include <QRect>
-#include <QRegion>
-#include <QTimer>
-#include <QToolButton>
-
-/* Mini-toolbar constructor */
-UIMiniToolBar::UIMiniToolBar(QWidget *pParent, Alignment alignment, bool fActive, bool fAutoHide)
-    : UIToolBar(pParent)
+
+/* GUI includes: */
+#include "UIMiniToolBar.h"
+#include "UIAnimationFramework.h"
+#include "UIIconPool.h"
+#include "VBoxGlobal.h"
+
+#ifndef Q_WS_X11
+# define VBOX_RUNTIME_UI_WITH_SHAPED_MINI_TOOLBAR
+#endif /* !Q_WS_X11 */
+
+UIRuntimeMiniToolBar::UIRuntimeMiniToolBar(QWidget *pParent,
+                                           Qt::Alignment alignment,
+                                           IntegrationMode integrationMode,
+                                           bool fAutoHide /*= true*/)
+    : QWidget(pParent)
+    /* Variables: General stuff: */
+    , m_alignment(alignment)
+    , m_integrationMode(integrationMode)
+    , m_fAutoHide(fAutoHide)
+    /* Variables: Contents stuff: */
+    , m_pMdiArea(0)
+    , m_pToolbar(0)
+    , m_pEmbeddedToolbar(0)
+    /* Variables: Hover stuff: */
+    , m_fHovered(false)
+    , m_pHoverEnterTimer(0)
+    , m_pHoverLeaveTimer(0)
+    , m_pAnimation(0)
+{
+    /* Prepare: */
+    prepare();
+}
+
+UIRuntimeMiniToolBar::~UIRuntimeMiniToolBar()
+{
+    /* Cleanup: */
+    cleanup();
+}
+
+void UIRuntimeMiniToolBar::setAlignment(Qt::Alignment alignment)
+{
+    /* Make sure alignment really changed: */
+    if (m_alignment == alignment)
+        return;
+
+    /* Update alignment: */
+    m_alignment = alignment;
+
+    /* Re-initialize: */
+    adjustGeometry();
+
+    /* Propagate to child to update shape: */
+    m_pToolbar->setAlignment(m_alignment);
+}
+
+void UIRuntimeMiniToolBar::setIntegrationMode(IntegrationMode integrationMode)
+{
+    /* Make sure integration-mode really changed: */
+    if (m_integrationMode == integrationMode)
+        return;
+
+    /* Update integration-mode: */
+    m_integrationMode = integrationMode;
+
+    /* Re-integrate: */
+    integrate();
+
+    /* Re-initialize: */
+    adjustGeometry();
+
+    /* Propagate to child to update shape: */
+    m_pToolbar->setIntegrationMode(m_integrationMode);
+}
+
+void UIRuntimeMiniToolBar::setAutoHide(bool fAutoHide, bool fPropagateToChild /*= true*/)
+{
+    /* Make sure auto-hide really changed: */
+    if (m_fAutoHide == fAutoHide)
+        return;
+
+    /* Update auto-hide: */
+    m_fAutoHide = fAutoHide;
+
+    /* Re-initialize: */
+    adjustGeometry();
+
+    /* Propagate to child to update action if necessary: */
+    if (fPropagateToChild)
+        m_pToolbar->setAutoHide(m_fAutoHide);
+}
+
+void UIRuntimeMiniToolBar::setText(const QString &strText)
+{
+    /* Propagate to child: */
+    m_pToolbar->setText(strText);
+}
+
+void UIRuntimeMiniToolBar::addMenus(const QList<QMenu*> &menus)
+{
+    /* Propagate to child: */
+    m_pToolbar->addMenus(menus);
+}
+
+void UIRuntimeMiniToolBar::adjustGeometry()
+{
+    /* This method could be called before parent-widget
+     * become visible, we should skip everything in that case: */
+    if (QApplication::desktop()->screenNumber(parentWidget()) == -1)
+        return;
+
+    /* Reset toolbar geometry: */
+    m_pEmbeddedToolbar->move(0, 0);
+    m_pEmbeddedToolbar->resize(m_pEmbeddedToolbar->sizeHint());
+
+    /* Adjust window geometry: */
+    resize(m_pEmbeddedToolbar->size());
+    QRect screenRect;
+    int iX = 0, iY = 0;
+    switch (m_integrationMode)
+    {
+        case IntegrationMode_Embedded:
+        {
+            /* Screen geometry: */
+            screenRect = QApplication::desktop()->screenGeometry(parentWidget());
+            /* Local coordinates, tool-bar is a child of the parent-widget: */
+            iX = screenRect.width() / 2 - width() / 2;
+            switch (m_alignment)
+            {
+                case Qt::AlignTop:
+                    iY = 0;
+                    break;
+                case Qt::AlignBottom:
+                    iY = screenRect.height() - height();
+                    break;
+            }
+            break;
+        }
+        case IntegrationMode_External:
+        {
+            /* Available geometry: */
+            screenRect = vboxGlobal().availableGeometry(QApplication::desktop()->screenNumber(parentWidget()));
+            /* Global coordinates, tool-bar is tool-window aligned according the parent-widget: */
+            iX = screenRect.x() + screenRect.width() / 2 - width() / 2;
+            switch (m_alignment)
+            {
+                case Qt::AlignTop:
+                    iY = screenRect.y();
+                    break;
+                case Qt::AlignBottom:
+                    iY = screenRect.y() + screenRect.height() - height();
+                    break;
+            }
+            break;
+        }
+    }
+    move(iX, iY);
+
+    /* Recalculate auto-hide animation: */
+    updateAutoHideAnimationBounds();
+
+    /* Simulate toolbar auto-hiding: */
+    simulateToolbarAutoHiding();
+
+    /* Due to [probably] Qt bug QMdiSubWindow still
+     * can receive focus even if focus policy is Qt::NoFocus,
+     * We should return the focus to our parent: */
+    parentWidget()->setFocus();
+}
+
+void UIRuntimeMiniToolBar::sltHandleToolbarResize()
+{
+    /* Re-initialize: */
+    adjustGeometry();
+}
+
+void UIRuntimeMiniToolBar::sltAutoHideToggled()
+{
+    /* Propagate from child: */
+    setAutoHide(m_pToolbar->autoHide(), false);
+}
+
+void UIRuntimeMiniToolBar::sltHoverEnter()
+{
+    /* Mark as 'hovered' if necessary: */
+    if (!m_fHovered)
+    {
+        m_fHovered = true;
+        emit sigHoverEnter();
+    }
+}
+
+void UIRuntimeMiniToolBar::sltHoverLeave()
+{
+    /* Mark as 'unhovered' if necessary: */
+    if (m_fHovered)
+    {
+        m_fHovered = false;
+        emit sigHoverLeave();
+    }
+}
+
+void UIRuntimeMiniToolBar::prepare()
+{
+    /* Allow any size: */
+    setMinimumSize(1, 1);
+    /* Make sure we have no focus: */
+    setFocusPolicy(Qt::NoFocus);
+
+    /* Prepare mdi-area: */
+    m_pMdiArea = new QMdiArea;
+    {
+        /* Configure own background: */
+        QPalette pal = m_pMdiArea->palette();
+        pal.setColor(QPalette::Window, QColor(Qt::transparent));
+        m_pMdiArea->setPalette(pal);
+        /* Configure viewport background: */
+        m_pMdiArea->setBackground(QColor(Qt::transparent));
+        /* Layout mdi-area according parent-widget: */
+        QVBoxLayout *pMainLayout = new QVBoxLayout(this);
+        pMainLayout->setContentsMargins(0, 0, 0, 0);
+        pMainLayout->addWidget(m_pMdiArea);
+        /* Make sure we have no focus: */
+        m_pMdiArea->setFocusPolicy(Qt::NoFocus);
+        m_pMdiArea->viewport()->setFocusPolicy(Qt::NoFocus);
+    }
+
+    /* Prepare mini-toolbar: */
+    m_pToolbar = new UIMiniToolBar;
+    {
+        /* Propagate known options to child: */
+        m_pToolbar->setAutoHide(m_fAutoHide);
+        m_pToolbar->setAlignment(m_alignment);
+        m_pToolbar->setIntegrationMode(m_integrationMode);
+        /* Configure own background: */
+        QPalette pal = m_pToolbar->palette();
+        pal.setColor(QPalette::Window, palette().color(QPalette::Window));
+        m_pToolbar->setPalette(pal);
+        /* Configure child connections: */
+        connect(m_pToolbar, SIGNAL(sigResized()), this, SLOT(sltHandleToolbarResize()));
+        connect(m_pToolbar, SIGNAL(sigAutoHideToggled()), this, SLOT(sltAutoHideToggled()));
+        connect(m_pToolbar, SIGNAL(sigMinimizeAction()), this, SIGNAL(sigMinimizeAction()));
+        connect(m_pToolbar, SIGNAL(sigExitAction()), this, SIGNAL(sigExitAction()));
+        connect(m_pToolbar, SIGNAL(sigCloseAction()), this, SIGNAL(sigCloseAction()));
+        /* Add child to mdi-area: */
+        m_pEmbeddedToolbar = m_pMdiArea->addSubWindow(m_pToolbar, Qt::Window | Qt::FramelessWindowHint);
+        /* Make sure we have no focus: */
+        m_pToolbar->setFocusPolicy(Qt::NoFocus);
+        m_pEmbeddedToolbar->setFocusPolicy(Qt::NoFocus);
+    }
+
+    /* Prepare hover-enter/leave timers: */
+    m_pHoverEnterTimer = new QTimer(this);
+    {
+        m_pHoverEnterTimer->setSingleShot(true);
+        m_pHoverEnterTimer->setInterval(50);
+        connect(m_pHoverEnterTimer, SIGNAL(timeout()), this, SLOT(sltHoverEnter()));
+    }
+    m_pHoverLeaveTimer = new QTimer(this);
+    {
+        m_pHoverLeaveTimer->setSingleShot(true);
+        m_pHoverLeaveTimer->setInterval(500);
+        connect(m_pHoverLeaveTimer, SIGNAL(timeout()), this, SLOT(sltHoverLeave()));
+    }
+
+    /* Install 'auto-hide' animation to 'toolbarPosition' property: */
+    m_pAnimation = UIAnimation::installPropertyAnimation(this,
+                                                         "toolbarPosition",
+                                                         "hiddenToolbarPosition", "shownToolbarPosition",
+                                                         SIGNAL(sigHoverEnter()), SIGNAL(sigHoverLeave()),
+                                                         true);
+
+    /* Integrate if necessary: */
+    integrate();
+
+    /* Adjust geometry finally: */
+    adjustGeometry();
+}
+
+void UIRuntimeMiniToolBar::cleanup()
+{
+    /* Stop hover-enter/leave timers: */
+    if (m_pHoverEnterTimer->isActive())
+        m_pHoverEnterTimer->stop();
+    if (m_pHoverLeaveTimer->isActive())
+        m_pHoverLeaveTimer->stop();
+}
+
+void UIRuntimeMiniToolBar::enterEvent(QEvent*)
+{
+    /* Stop the hover-leave timer if necessary: */
+    if (m_pHoverLeaveTimer->isActive())
+        m_pHoverLeaveTimer->stop();
+
+    /* Start the hover-enter timer: */
+    if (m_fAutoHide)
+        m_pHoverEnterTimer->start();
+}
+
+void UIRuntimeMiniToolBar::leaveEvent(QEvent*)
+{
+    /* Stop the hover-enter timer if necessary: */
+    if (m_pHoverEnterTimer->isActive())
+        m_pHoverEnterTimer->stop();
+
+    /* Start the hover-leave timer: */
+    if (m_fAutoHide)
+        m_pHoverLeaveTimer->start();
+}
+
+void UIRuntimeMiniToolBar::updateAutoHideAnimationBounds()
+{
+    /* Update animation: */
+    m_shownToolbarPosition = m_pEmbeddedToolbar->pos();
+    switch (m_alignment)
+    {
+        case Qt::AlignTop:
+            m_hiddenToolbarPosition = m_shownToolbarPosition - QPoint(0, m_pEmbeddedToolbar->height() + 3);
+            break;
+        case Qt::AlignBottom:
+            m_hiddenToolbarPosition = m_shownToolbarPosition + QPoint(0, m_pEmbeddedToolbar->height() - 3);
+            break;
+    }
+    m_pAnimation->update();
+}
+
+void UIRuntimeMiniToolBar::simulateToolbarAutoHiding()
+{
+    /* This simulation helps user to notice
+     * toolbar location, so it will be used only
+     * 1. if toolbar unhovered and
+     * 2. auto-hide feature enabled: */
+    if (m_fHovered || !m_fAutoHide)
+        return;
+
+    /* Simulate hover-leave event: */
+    m_fHovered = true;
+    m_pHoverLeaveTimer->start();
+}
+
+void UIRuntimeMiniToolBar::setToolbarPosition(QPoint point)
+{
+    /* Make sure toolbar exists: */
+    if (!m_pEmbeddedToolbar)
+        return;
+
+    /* Update position: */
+    m_pEmbeddedToolbar->move(point);
+
+#ifdef Q_WS_X11
+    /* The setMask functionality is excessive under Win/Mac hosts
+     * because there is a Qt composition works properly,
+     * Mac host has native translucency support,
+     * Win host allows to enable it through Qt::WA_TranslucentBackground: */
+    setMask(m_pEmbeddedToolbar->geometry());
+#endif /* Q_WS_X11 */
+}
+
+QPoint UIRuntimeMiniToolBar::toolbarPosition() const
+{
+    /* Make sure toolbar exists: */
+    if (!m_pEmbeddedToolbar)
+        return QPoint();
+
+    /* Return position: */
+    return m_pEmbeddedToolbar->pos();
+}
+
+void UIRuntimeMiniToolBar::integrate()
+{
+    /* Reintegrate if necessary: */
+    if (m_integrationMode == IntegrationMode_Embedded && isWindow())
+    {
+        setWindowFlags(Qt::Widget);
+#ifdef VBOX_RUNTIME_UI_WITH_SHAPED_MINI_TOOLBAR
+        setAttribute(Qt::WA_TranslucentBackground, false);
+#endif /* VBOX_RUNTIME_UI_WITH_SHAPED_MINI_TOOLBAR */
+        show();
+    }
+    else if (m_integrationMode == IntegrationMode_External && !isWindow())
+    {
+        setWindowFlags(Qt::Tool | Qt::FramelessWindowHint | Qt::WindowStaysOnTopHint);
+#ifdef VBOX_RUNTIME_UI_WITH_SHAPED_MINI_TOOLBAR
+        setAttribute(Qt::WA_TranslucentBackground, true);
+#endif /* VBOX_RUNTIME_UI_WITH_SHAPED_MINI_TOOLBAR */
+        show();
+    }
+}
+
+
+UIMiniToolBar::UIMiniToolBar()
+    /* Variables: General stuff: */
+    : m_fPolished(false)
+    , m_alignment(Qt::AlignBottom)
+    /* Variables: Contents stuff: */
     , m_pAutoHideAction(0)
-    , m_pDisplayLabel(0)
+    , m_pLabel(0)
     , m_pMinimizeAction(0)
     , m_pRestoreAction(0)
     , m_pCloseAction(0)
-    , m_fActive(fActive)
-    , m_fPolished(false)
-    , m_fSeamless(false)
-    , m_fAutoHide(fAutoHide)
-    , m_fSlideToScreen(true)
-    , m_fHideAfterSlide(false)
-    , m_iAutoHideCounter(0)
-    , m_iPositionX(0)
-    , m_iPositionY(0)
-    , m_pInsertPosition(0)
-    , m_alignment(alignment)
-    , m_fAnimated(true)
-    , m_iScrollDelay(10)
-    , m_iAutoScrollDelay(100)
-    , m_iAutoHideTotalCounter(10)
-{
-    /* Check parent widget presence: */
-    AssertMsg(parentWidget(), ("Parent widget must be set!\n"));
-
-    /* Toolbar options: */
-    setIconSize(QSize(16, 16));
-    setVisible(false);
-
-    /* Add pushpin: */
-    m_pAutoHideAction = new QAction(this);
-    m_pAutoHideAction->setIcon(UIIconPool::iconSet(":/pin_16px.png"));
-    m_pAutoHideAction->setToolTip(tr("Always show the toolbar"));
-    m_pAutoHideAction->setCheckable(true);
-    m_pAutoHideAction->setChecked(!m_fAutoHide);
-    connect(m_pAutoHideAction, SIGNAL(toggled(bool)), this, SLOT(togglePushpin(bool)));
-    addAction(m_pAutoHideAction);
-
-    /* Left menu margin: */
-    m_Spacings << widgetForAction(addWidget(new QWidget(this)));
-
-    /* Right menu margin: */
-    m_pInsertPosition = addWidget(new QWidget(this));
-    m_Spacings << widgetForAction(m_pInsertPosition);
-
-    /* Left label margin: */
-    m_LabelMargins << widgetForAction(addWidget(new QWidget(this)));
-
-    /* Insert a label for VM Name: */
-    m_pDisplayLabel = new QLabel(this);
-    m_pDisplayLabel->setAlignment(Qt::AlignCenter);
-    addWidget(m_pDisplayLabel);
-
-    /* Right label margin: */
-    m_LabelMargins << widgetForAction(addWidget(new QWidget(this)));
-
-    /* Minimize action: */
-    m_pMinimizeAction = new QAction(this);
-    m_pMinimizeAction->setIcon(UIIconPool::iconSet(":/minimize_16px.png"));
-    m_pMinimizeAction->setToolTip(tr("Minimize Window"));
-    connect(m_pMinimizeAction, SIGNAL(triggered()), this, SIGNAL(minimizeAction()));
-    addAction(m_pMinimizeAction);
-
-    /* Exit action: */
-    m_pRestoreAction = new QAction(this);
-    m_pRestoreAction->setIcon(UIIconPool::iconSet(":/restore_16px.png"));
-    m_pRestoreAction->setToolTip(tr("Exit Full Screen or Seamless Mode"));
-    connect(m_pRestoreAction, SIGNAL(triggered()), this, SIGNAL(exitAction()));
-    addAction(m_pRestoreAction);
-
-    /* Close action: */
-    m_pCloseAction = new QAction(this);
-    m_pCloseAction->setIcon(UIIconPool::iconSet(":/close_16px.png"));
-    m_pCloseAction->setToolTip(tr("Close VM"));
-    connect(m_pCloseAction, SIGNAL(triggered()), this, SIGNAL(closeAction()));
-    addAction(m_pCloseAction);
-
-    /* Event-filter for parent widget to control resize: */
-    pParent->installEventFilter(this);
-
-    /* Enable mouse-tracking for this & children allowing to get mouse-move events: */
-    setMouseTrackingEnabled(m_fAutoHide);
-}
-
-/* Appends passed menus into internal menu-list */
-UIMiniToolBar& UIMiniToolBar::operator<<(QList<QMenu*> menus)
-{
+    /* Variables: Menu stuff: */
+    , m_pMenuInsertPosition(0)
+{
+    /* Prepare: */
+    prepare();
+}
+
+void UIMiniToolBar::setAlignment(Qt::Alignment alignment)
+{
+    /* Make sure alignment really changed: */
+    if (m_alignment == alignment)
+        return;
+
+    /* Update alignment: */
+    m_alignment = alignment;
+
+    /* Rebuild shape: */
+    rebuildShape();
+}
+
+void UIMiniToolBar::setIntegrationMode(IntegrationMode integrationMode)
+{
+    /* Make sure integration-mode really changed: */
+    if (m_integrationMode == integrationMode)
+        return;
+
+    /* Update integration-mode: */
+    m_integrationMode = integrationMode;
+
+    /* Rebuild shape: */
+    rebuildShape();
+}
+
+bool UIMiniToolBar::autoHide() const
+{
+    /* Return auto-hide: */
+    return !m_pAutoHideAction->isChecked();
+}
+
+void UIMiniToolBar::setAutoHide(bool fAutoHide)
+{
+    /* Make sure auto-hide really changed: */
+    if (m_pAutoHideAction->isChecked() == !fAutoHide)
+        return;
+
+    /* Update auto-hide: */
+    m_pAutoHideAction->setChecked(!fAutoHide);
+}
+
+void UIMiniToolBar::setText(const QString &strText)
+{
+    /* Make sure text really changed: */
+    if (m_pLabel->text() == strText)
+        return;
+
+    /* Update text: */
+    m_pLabel->setText(strText);
+
+    /* Resize to sizehint: */
+    resize(sizeHint());
+}
+
+void UIMiniToolBar::addMenus(const QList<QMenu*> &menus)
+{
+    /* For each of the passed menu items: */
     for (int i = 0; i < menus.size(); ++i)
     {
+        /* Get corresponding menu-action: */
         QAction *pAction = menus[i]->menuAction();
-        insertAction(m_pInsertPosition, pAction);
+        /* Insert it into corresponding place: */
+        insertAction(m_pMenuInsertPosition, pAction);
+        /* Configure corresponding tool-button: */
         if (QToolButton *pButton = qobject_cast<QToolButton*>(widgetForAction(pAction)))
         {
@@ -134 +507 @@
             pButton->setAutoRaise(true);
         }
+        /* Add some spacing: */
         if (i != menus.size() - 1)
-            m_Spacings << widgetForAction(insertWidget(m_pInsertPosition, new QWidget(this)));
-    }
-    return *this;
-}
-
-/* Seamless mode setter */
-void UIMiniToolBar::setSeamlessMode(bool fSeamless)
-{
-    m_fSeamless = fSeamless;
-}
-
-/* Update the display text, usually the VM Name */
-void UIMiniToolBar::setDisplayText(const QString &strText)
-{
-    /* If text was really changed: */
-    if (m_pDisplayLabel->text() != strText)
-    {
-        /* Update toolbar label: */
-        m_pDisplayLabel->setText(strText);
-
-        /* Reinitialize: */
-        initialize();
-
-        /* Update toolbar if its not hidden: */
-        if (!isHidden())
-            updateDisplay(!m_fAutoHide, false);
-    }
-}
-
-/* Is auto-hide feature enabled? */
-bool UIMiniToolBar::isAutoHide() const
-{
-    return m_fAutoHide;
-}
-
-void UIMiniToolBar::updateDisplay(bool fShow, bool fSetHideFlag)
-{
-    m_iAutoHideCounter = 0;
-
-    setMouseTrackingEnabled(m_fAutoHide);
-
-    if (fShow)
-    {
-        if (isHidden())
-            moveToBase();
-
-        if (m_fAnimated)
-        {
-            if (fSetHideFlag)
-            {
-                m_fHideAfterSlide = false;
-                m_fSlideToScreen = true;
-            }
-            if (m_fActive)
-                show();
-            m_scrollTimer.start(m_iScrollDelay, this);
-        }
-        else if (m_fActive)
-            show();
-
-        if (m_fAutoHide)
-            m_autoScrollTimer.start(m_iAutoScrollDelay, this);
-        else
-            m_autoScrollTimer.stop();
-    }
-    else
-    {
-        if (m_fAnimated)
-        {
-            if (fSetHideFlag)
-            {
-                m_fHideAfterSlide = true;
-                m_fSlideToScreen = false;
-            }
-            m_scrollTimer.start(m_iScrollDelay, this);
-        }
-        else
-            hide();
-
-        if (m_fAutoHide)
-            m_autoScrollTimer.start(m_iAutoScrollDelay, this);
-        else
-            m_autoScrollTimer.stop();
-    }
-}
-
-/* Parent widget event-filter */
-bool UIMiniToolBar::eventFilter(QObject *pObject, QEvent *pEvent)
-{
-    /* If parent widget was resized: */
-    if (pObject == parent() && pEvent->type() == QEvent::Resize)
-    {
-        /* Update toolbar position: */
-        moveToBase();
-        return true;
-    }
-    /* Base-class event-filter: */
-    return UIToolBar::eventFilter(pObject, pEvent);
-}
-
-/* Mouse-move event processor */
-void UIMiniToolBar::mouseMoveEvent(QMouseEvent *pEvent)
-{
-    /* Activate sliding animation on mouse move: */
-    if (!m_fHideAfterSlide)
-    {
-        m_fSlideToScreen = true;
-        m_scrollTimer.start(m_iScrollDelay, this);
-    }
-    /* Base-class mouse-move event processing: */
-    UIToolBar::mouseMoveEvent(pEvent);
-}
-
-/* Timer event processor
- * Handles auto hide feature of the toolbar */
-void UIMiniToolBar::timerEvent(QTimerEvent *pEvent)
-{
-    if (pEvent->timerId() == m_scrollTimer.timerId())
-    {
-        /* Due to X11 async nature, this timer-event could come before parent
-         * VM window become visible, we should ignore those timer-events: */
-        if (QApplication::desktop()->screenNumber(window()) == -1)
-            return;
-
-        /* Update tool-bar position: */
-        QRect screen = m_fSeamless ? vboxGlobal().availableGeometry(QApplication::desktop()->screenNumber(window())) :
-                                     QApplication::desktop()->screenGeometry(window());
-        switch (m_alignment)
-        {
-            case AlignTop:
-            {
-                if (((m_iPositionY == screen.y()) && m_fSlideToScreen) ||
-                    ((m_iPositionY == screen.y() - height() + 1) && !m_fSlideToScreen))
-                {
-                    m_scrollTimer.stop();
-                    if (m_fHideAfterSlide)
-                    {
-                        m_fHideAfterSlide = false;
-                        hide();
-                    }
-                    return;
-                }
-                m_fSlideToScreen ? ++m_iPositionY : --m_iPositionY;
-                break;
-            }
-            case AlignBottom:
-            {
-                if (((m_iPositionY == screen.y() + screen.height() - height()) && m_fSlideToScreen) ||
-                    ((m_iPositionY == screen.y() + screen.height() - 1) && !m_fSlideToScreen))
-                {
-                    m_scrollTimer.stop();
-                    if (m_fHideAfterSlide)
-                    {
-                        m_fHideAfterSlide = false;
-                        hide();
-                    }
-                    return;
-                }
-                m_fSlideToScreen ? --m_iPositionY : ++m_iPositionY;
-                break;
-            }
-            default:
-                break;
-        }
-        move(parentWidget()->mapFromGlobal(QPoint(m_iPositionX, m_iPositionY)));
-        emit geometryUpdated();
-    }
-    else if (pEvent->timerId() == m_autoScrollTimer.timerId())
-    {
-        QRect rect = this->rect();
-        QPoint p = mapFromGlobal(QCursor::pos());
-        if (!rect.contains(p))
-        {
-            ++m_iAutoHideCounter;
-
-            if (m_iAutoHideCounter == m_iAutoHideTotalCounter)
-            {
-                m_fSlideToScreen = false;
-                m_scrollTimer.start(m_iScrollDelay, this);
-            }
-        }
-        else
-            m_iAutoHideCounter = 0;
-    }
-    else
-        QWidget::timerEvent(pEvent);
-}
-
-/* Show event processor */
-void UIMiniToolBar::showEvent(QShowEvent *pEvent)
-{
-    if (!m_fPolished)
-    {
-        /* Tool-bar spacings: */
-        foreach(QWidget *pSpacing, m_Spacings)
-            pSpacing->setMinimumWidth(5);
-
-        /* Title spacings: */
-        foreach(QWidget *pLableMargin, m_LabelMargins)
-            pLableMargin->setMinimumWidth(15);
-
-        /* Initialize: */
-        initialize();
-
-        m_fPolished = true;
-    }
-    /* Base-class show event processing: */
-    UIToolBar::showEvent(pEvent);
-}
-
-/* Show event processor */
-void UIMiniToolBar::paintEvent(QPaintEvent *pEvent)
-{
-    /* Paint background */
-    QPainter painter;
-    painter.begin(this);
-    painter.fillRect(pEvent->rect(), QApplication::palette().color(QPalette::Active, QPalette::Window));
-    painter.end();
-    /* Base-class paint event processing: */
-    UIToolBar::paintEvent(pEvent);
-}
-
-/* Toggle push-pin */
-void UIMiniToolBar::togglePushpin(bool fOn)
-{
-    m_fAutoHide = !fOn;
-    updateDisplay(!m_fAutoHide, false);
-}
-
-/* Initialize mini-toolbar */
-void UIMiniToolBar::initialize()
-{
+            m_spacings << widgetForAction(insertWidget(m_pMenuInsertPosition, new QWidget(this)));
+    }
+
     /* Resize to sizehint: */
     resize(sizeHint());
-
-    /* Update geometry: */
-    moveToBase();
-}
-
-/* Move mini-toolbar to the base location */
-void UIMiniToolBar::moveToBase()
-{
-    QRect screen = m_fSeamless ? vboxGlobal().availableGeometry(QApplication::desktop()->screenNumber(window())) :
-                                 QApplication::desktop()->screenGeometry(window());
-    m_iPositionX = screen.x() + (screen.width() / 2) - (width() / 2);
+}
+
+void UIMiniToolBar::showEvent(QShowEvent *pEvent)
+{
+    /* Make sure we should polish dialog: */
+    if (m_fPolished)
+        return;
+
+    /* Call to polish-event: */
+    polishEvent(pEvent);
+
+    /* Mark dialog as polished: */
+    m_fPolished = true;
+}
+
+void UIMiniToolBar::polishEvent(QShowEvent*)
+{
+    /* Toolbar spacings: */
+    foreach(QWidget *pSpacing, m_spacings)
+        pSpacing->setMinimumWidth(5);
+
+    /* Title spacings: */
+    foreach(QWidget *pLableMargin, m_margins)
+        pLableMargin->setMinimumWidth(15);
+
+    /* Resize to sizehint: */
+    resize(sizeHint());
+}
+
+void UIMiniToolBar::resizeEvent(QResizeEvent*)
+{
+    /* Rebuild shape: */
+    rebuildShape();
+
+    /* Notify listeners: */
+    emit sigResized();
+}
+
+void UIMiniToolBar::paintEvent(QPaintEvent*)
+{
+    /* Prepare painter: */
+    QPainter painter(this);
+
+    /* Fill background: */
+    if (!m_shape.isEmpty())
+    {
+        painter.setRenderHint(QPainter::Antialiasing);
+        painter.setClipPath(m_shape);
+    }
+    QRect backgroundRect = rect();
+    QColor backgroundColor = palette().color(QPalette::Window);
+    QLinearGradient headerGradient(backgroundRect.bottomLeft(), backgroundRect.topLeft());
+    headerGradient.setColorAt(0, backgroundColor.darker(120));
+    headerGradient.setColorAt(1, backgroundColor.darker(90));
+    painter.fillRect(backgroundRect, headerGradient);
+}
+
+void UIMiniToolBar::prepare()
+{
+    /* Configure toolbar: */
+    setIconSize(QSize(16, 16));
+
+#ifdef VBOX_RUNTIME_UI_WITH_SHAPED_MINI_TOOLBAR
+    /* Left margin: */
+    m_spacings << widgetForAction(addWidget(new QWidget));
+#endif /* VBOX_RUNTIME_UI_WITH_SHAPED_MINI_TOOLBAR */
+
+    /* Prepare push-pin: */
+    m_pAutoHideAction = new QAction(this);
+    m_pAutoHideAction->setIcon(UIIconPool::iconSet(":/pin_16px.png"));
+    m_pAutoHideAction->setToolTip(tr("Always show the toolbar"));
+    m_pAutoHideAction->setCheckable(true);
+    connect(m_pAutoHideAction, SIGNAL(toggled(bool)), this, SIGNAL(sigAutoHideToggled()));
+    addAction(m_pAutoHideAction);
+
+    /* Left menu margin: */
+    m_spacings << widgetForAction(addWidget(new QWidget));
+
+    /* Right menu margin: */
+    m_pMenuInsertPosition = addWidget(new QWidget);
+    m_spacings << widgetForAction(m_pMenuInsertPosition);
+
+    /* Left label margin: */
+    m_margins << widgetForAction(addWidget(new QWidget));
+
+    /* Insert a label for VM Name: */
+    m_pLabel = new QLabel;
+    m_pLabel->setAlignment(Qt::AlignCenter);
+    addWidget(m_pLabel);
+
+    /* Right label margin: */
+    m_margins << widgetForAction(addWidget(new QWidget));
+
+    /* Minimize action: */
+    m_pMinimizeAction = new QAction(this);
+    m_pMinimizeAction->setIcon(UIIconPool::iconSet(":/minimize_16px.png"));
+    m_pMinimizeAction->setToolTip(tr("Minimize Window"));
+    connect(m_pMinimizeAction, SIGNAL(triggered()), this, SIGNAL(sigMinimizeAction()));
+    addAction(m_pMinimizeAction);
+
+    /* Exit action: */
+    m_pRestoreAction = new QAction(this);
+    m_pRestoreAction->setIcon(UIIconPool::iconSet(":/restore_16px.png"));
+    m_pRestoreAction->setToolTip(tr("Exit Full Screen or Seamless Mode"));
+    connect(m_pRestoreAction, SIGNAL(triggered()), this, SIGNAL(sigExitAction()));
+    addAction(m_pRestoreAction);
+
+    /* Close action: */
+    m_pCloseAction = new QAction(this);
+    m_pCloseAction->setIcon(UIIconPool::iconSet(":/close_16px.png"));
+    m_pCloseAction->setToolTip(tr("Close VM"));
+    connect(m_pCloseAction, SIGNAL(triggered()), this, SIGNAL(sigCloseAction()));
+    addAction(m_pCloseAction);
+
+#ifdef VBOX_RUNTIME_UI_WITH_SHAPED_MINI_TOOLBAR
+    /* Right margin: */
+    m_spacings << widgetForAction(addWidget(new QWidget));
+#endif /* VBOX_RUNTIME_UI_WITH_SHAPED_MINI_TOOLBAR */
+
+    /* Resize to sizehint: */
+    resize(sizeHint());
+}
+
+void UIMiniToolBar::rebuildShape()
+{
+#ifdef VBOX_RUNTIME_UI_WITH_SHAPED_MINI_TOOLBAR
+    /* Rebuild shape: */
+    QPainterPath shape;
     switch (m_alignment)
     {
-        case AlignTop:
+        case Qt::AlignTop:
         {
-            m_iPositionY = screen.y() - height() + 1;
+            shape.moveTo(0, 0);
+            shape.lineTo(shape.currentPosition().x(), height() - 10);
+            shape.arcTo(QRectF(shape.currentPosition(), QSizeF(20, 20)).translated(0, -10), 180, 90);
+            shape.lineTo(width() - 10, shape.currentPosition().y());
+            shape.arcTo(QRectF(shape.currentPosition(), QSizeF(20, 20)).translated(-10, -20), 270, 90);
+            shape.lineTo(shape.currentPosition().x(), 0);
+            shape.closeSubpath();
             break;
         }
-        case AlignBottom:
+        case Qt::AlignBottom:
         {
-            m_iPositionY = screen.y() + screen.height() - 1;
+            shape.moveTo(0, height());
+            shape.lineTo(shape.currentPosition().x(), 10);
+            shape.arcTo(QRectF(shape.currentPosition(), QSizeF(20, 20)).translated(0, -10), 180, -90);
+            shape.lineTo(width() - 10, shape.currentPosition().y());
+            shape.arcTo(QRectF(shape.currentPosition(), QSizeF(20, 20)).translated(-10, 0), 90, -90);
+            shape.lineTo(shape.currentPosition().x(), height());
+            shape.closeSubpath();
             break;
         }
         default:
-        {
-            m_iPositionY = 0;
             break;
-        }
-    }
-    move(parentWidget()->mapFromGlobal(QPoint(m_iPositionX, m_iPositionY)));
-}
-
-/* Enable/disable mouse-tracking for required widgets */
-void UIMiniToolBar::setMouseTrackingEnabled(bool fEnabled)
-{
-    setMouseTracking(fEnabled);
-    if (m_pDisplayLabel)
-        m_pDisplayLabel->setMouseTracking(fEnabled);
-    if (m_pAutoHideAction && widgetForAction(m_pAutoHideAction))
-        widgetForAction(m_pAutoHideAction)->setMouseTracking(fEnabled);
-    if (m_pMinimizeAction && widgetForAction(m_pMinimizeAction))
-        widgetForAction(m_pMinimizeAction)->setMouseTracking(fEnabled);
-    if (m_pRestoreAction && widgetForAction(m_pRestoreAction))
-        widgetForAction(m_pRestoreAction)->setMouseTracking(fEnabled);
-    if (m_pCloseAction && widgetForAction(m_pCloseAction))
-        widgetForAction(m_pCloseAction)->setMouseTracking(fEnabled);
-}
-
+    }
+    m_shape = shape;
+
+    /* Update: */
+    update();
+#endif /* VBOX_RUNTIME_UI_WITH_SHAPED_MINI_TOOLBAR */
+}
+

trunk/src/VBox/Frontends/VirtualBox/src/widgets/UIMiniToolBar.h

@@ -2 +2 @@
  *
  * VBox frontends: Qt GUI ("VirtualBox"):
- * UIMiniToolBar class declaration & implementation. This is the toolbar shown on fullscreen mode.
+ * UIMiniToolBar class declaration.
+ * This is the toolbar shown in fullscreen/seamless modes.
  */
 
 /*
- * Copyright (C) 2009-2011 Oracle Corporation
+ * Copyright (C) 2009-2013 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -20 +21 @@
 #define __UIMiniToolBar_h__
 
-/* Global includes */
-#include <QBasicTimer>
-
-/* Local includes */
+/* Qt includes: */
+#include <QMainWindow>
+
+/* GUI includes: */
 #include "UIToolBar.h"
 
-/* Global forwards */
+/* Forward declarations: */
+class QTimer;
 class QLabel;
 class QMenu;
-
-/**
- *  The UIMiniToolBar class is a toolbar shown inside full screen mode or seamless mode.
- *  It supports auto hiding and animated sliding up/down.
- */
+class QMdiArea;
+class UIMiniToolBar;
+class QMdiSubWindow;
+class UIAnimation;
+
+/* IntegrationMode enum: */
+enum IntegrationMode
+{
+    IntegrationMode_Embedded,
+    IntegrationMode_External
+};
+
+/* Runtime mini-toolbar frameless-window prototype: */
+class UIRuntimeMiniToolBar : public QWidget
+{
+    Q_OBJECT;
+    Q_PROPERTY(QPoint toolbarPosition READ toolbarPosition WRITE setToolbarPosition);
+    Q_PROPERTY(QPoint hiddenToolbarPosition READ hiddenToolbarPosition);
+    Q_PROPERTY(QPoint shownToolbarPosition READ shownToolbarPosition);
+
+signals:
+
+    /* Notifiers: Action stuff: */
+    void sigMinimizeAction();
+    void sigExitAction();
+    void sigCloseAction();
+
+    /* Notifiers: Hover stuff: */
+    void sigHoverEnter();
+    void sigHoverLeave();
+
+public:
+
+    /* Constructor/destructor: */
+    UIRuntimeMiniToolBar(QWidget *pParent,
+                         Qt::Alignment alignment,
+                         IntegrationMode integrationMode,
+                         bool fAutoHide = true);
+    ~UIRuntimeMiniToolBar();
+
+    /* API: Alignment stuff: */
+    void setAlignment(Qt::Alignment alignment);
+
+    /* API: Integration mode stuff: */
+    void setIntegrationMode(IntegrationMode integrationMode);
+
+    /* API: Auto-hide stuff: */
+    bool autoHide() const { return m_fAutoHide; }
+    void setAutoHide(bool fAutoHide, bool fPropagateToChild = true);
+
+    /* API: Text stuff: */
+    void setText(const QString &strText);
+
+    /* API: Menu stuff: */
+    void addMenus(const QList<QMenu*> &menus);
+
+    /* API: Geometry stuff: */
+    void adjustGeometry();
+
+private slots:
+
+    /* Handlers: Toolbar stuff: */
+    void sltHandleToolbarResize();
+    void sltAutoHideToggled();
+    void sltHoverEnter();
+    void sltHoverLeave();
+
+private:
+
+    /* Helpers: Prepare/cleanup stuff: */
+    void prepare();
+    void cleanup();
+
+    /* Handlers: Event-processing stuff: */
+    void enterEvent(QEvent *pEvent);
+    void leaveEvent(QEvent *pEvent);
+
+    /* Helper: Hover stuff: */
+    void updateAutoHideAnimationBounds();
+    void simulateToolbarAutoHiding();
+
+    /* Property: Hover stuff: */
+    void setToolbarPosition(QPoint point);
+    QPoint toolbarPosition() const;
+    QPoint hiddenToolbarPosition() const { return m_hiddenToolbarPosition; }
+    QPoint shownToolbarPosition() const { return m_shownToolbarPosition; }
+
+    /* Helper: Integration stuff: */
+    void integrate();
+
+    /* Variables: General stuff: */
+    Qt::Alignment m_alignment;
+    IntegrationMode m_integrationMode;
+    bool m_fAutoHide;
+
+    /* Variables: Contents stuff: */
+    QMdiArea *m_pMdiArea;
+    UIMiniToolBar *m_pToolbar;
+    QMdiSubWindow *m_pEmbeddedToolbar;
+
+    /* Variables: Hover stuff: */
+    bool m_fHovered;
+    QTimer *m_pHoverEnterTimer;
+    QTimer *m_pHoverLeaveTimer;
+    QPoint m_hiddenToolbarPosition;
+    QPoint m_shownToolbarPosition;
+    UIAnimation *m_pAnimation;
+};
+
+/* Mini-toolbar widget prototype: */
 class UIMiniToolBar : public UIToolBar
 {
     Q_OBJECT;
 
+signals:
+
+    /* Notifier: Resize stuff: */
+    void sigResized();
+
+    /* Notifiers: Action stuff: */
+    void sigAutoHideToggled();
+    void sigMinimizeAction();
+    void sigExitAction();
+    void sigCloseAction();
+
 public:
 
-    enum Alignment
-    {
-        AlignTop,
-        AlignBottom
-    };
-
-    UIMiniToolBar(QWidget *pParent, Alignment alignment, bool fActive, bool fAutoHide);
-
-    UIMiniToolBar& operator<<(QList<QMenu*> menus);
-
-    void setSeamlessMode(bool fSeamless);
-    void setDisplayText(const QString &strText);
-
-    bool isAutoHide() const;
-
-    void updateDisplay(bool fShow, bool fSetHideFlag);
-
-signals:
-
-    void minimizeAction();
-    void exitAction();
-    void closeAction();
-    void geometryUpdated();
+    /* Constructor: */
+    UIMiniToolBar();
+
+    /* API: Alignment stuff: */
+    void setAlignment(Qt::Alignment alignment);
+
+    /* API: Integration mode stuff: */
+    void setIntegrationMode(IntegrationMode integrationMode);
+
+    /* API: Auto-hide stuff: */
+    bool autoHide() const;
+    void setAutoHide(bool fAutoHide);
+
+    /* API: Text stuff: */
+    void setText(const QString &strText);
+
+    /* API: Menu aggregator: */
+    void addMenus(const QList<QMenu*> &menus);
 
 protected:
 
-    bool eventFilter(QObject *pObj, QEvent *pEvent);
-    void mouseMoveEvent(QMouseEvent *pEvent);
-    void timerEvent(QTimerEvent *pEvent);
-    void showEvent(QShowEvent *pEvent);
-    void paintEvent(QPaintEvent *pEvent);
-
-private slots:
-
-    void togglePushpin(bool fOn);
+    /* Handlers: Event-processing stuff: */
+    virtual void showEvent(QShowEvent *pEvent);
+    virtual void polishEvent(QShowEvent *pEvent);
+    virtual void resizeEvent(QResizeEvent *pEvent);
+    virtual void paintEvent(QPaintEvent *pEvent);
 
 private:
 
-    void initialize();
-    void moveToBase();
-    void setMouseTrackingEnabled(bool fEnabled);
-
+    /* Helper: Prepare stuff: */
+    void prepare();
+
+    /* Helper: Shape stuff: */
+    void rebuildShape();
+
+    /* Variables: General stuff: */
+    bool m_fPolished;
+    Qt::Alignment m_alignment;
+    IntegrationMode m_integrationMode;
+    QPainterPath m_shape;
+
+    /* Variables: Contents stuff: */
     QAction *m_pAutoHideAction;
-    QLabel *m_pDisplayLabel;
+    QLabel *m_pLabel;
     QAction *m_pMinimizeAction;
     QAction *m_pRestoreAction;
     QAction *m_pCloseAction;
 
-    QBasicTimer m_scrollTimer;
-    QBasicTimer m_autoScrollTimer;
-
-    bool m_fActive;
-    bool m_fPolished;
-    bool m_fSeamless;
-    bool m_fAutoHide;
-    bool m_fSlideToScreen;
-    bool m_fHideAfterSlide;
-
-    int m_iAutoHideCounter;
-    int m_iPositionX;
-    int m_iPositionY;
-
-    /* Lists of used spacers */
-    QList<QWidget*> m_Spacings;
-    QList<QWidget*> m_LabelMargins;
-
-    /* Menu insert position */
-    QAction *m_pInsertPosition;
-
-    /* Tool-bar alignment */
-    Alignment m_alignment;
-
-    /* Whether to animate showing/hiding the toolbar */
-    bool m_fAnimated;
-
-    /* Interval (in milli seconds) for scrolling the toolbar, default is 20 msec */
-    int m_iScrollDelay;
-
-    /* The wait time while the cursor is not over the window after this amount of time (in msec),
-     * the toolbar will auto hide if autohide is on. The default is 100msec. */
-    int m_iAutoScrollDelay;
-
-    /* Number of total steps before hiding. If it is 10 then wait 10 (steps) * 100ms (m_iAutoScrollDelay) = 1000ms delay.
-     * The default is 10. */
-    int m_iAutoHideTotalCounter;
+    /* Variables: Menu stuff: */
+    QAction *m_pMenuInsertPosition;
+
+    /* Variables: Spacers stuff: */
+    QList<QWidget*> m_spacings;
+    QList<QWidget*> m_margins;
 };