Changeset 30087 in vbox for trunk

Timestamp:

Jun 8, 2010 9:43:31 AM (15 years ago)

Author:

vboxsync

Message:

FE/Qt4-OSX: Make the 1 pixel splitter handle easier to catch by surrounding it
with an invisible snap area.

Location:

trunk/src/VBox/Frontends/VirtualBox/src/extensions

Files:

• QISplitter.cpp (modified) (2 diffs)
• QISplitter.h (modified) (1 diff)

trunk/src/VBox/Frontends/VirtualBox/src/extensions/QISplitter.cpp

@@ -110 +110 @@
 #endif /* RT_OS_DARWIN */
 
-QISplitter::QISplitter(QWidget *aParent /* = 0 */)
-    : QSplitter(aParent)
-    , mPolished(false)
+QISplitter::QISplitter(QWidget *pParent /* = 0 */)
+    : QSplitter(pParent)
+    , m_fPolished(false)
     , m_type(Shade)
-{
-    qApp->installEventFilter (this);
+#ifdef Q_WS_MAC
+    , m_fHandleGrabbed(false)
+#endif /* Q_WS_MAC */
+{
+    qApp->installEventFilter(this);
 }
 
 QISplitter::QISplitter(Qt::Orientation orientation /* = Qt::Horizontal */, QWidget *pParent /* = 0 */)
     : QSplitter(orientation, pParent)
-    , mPolished(false)
+    , m_fPolished(false)
     , m_type(Shade)
+#ifdef Q_WS_MAC
+    , m_fHandleGrabbed(false)
+#endif /* Q_WS_MAC */
 {
     qApp->installEventFilter (this);
 }
 
-bool QISplitter::eventFilter(QObject *aWatched, QEvent *aEvent)
-{
-    if (aWatched == handle(1))
-    {
-        switch (aEvent->type())
+bool QISplitter::eventFilter(QObject *pWatched, QEvent *pEvent)
+{
+    if (pWatched == handle(1))
+    {
+        switch (pEvent->type())
         {
             case QEvent::MouseButtonDblClick:
-                restoreState (mBaseState);
+                restoreState(m_baseState);
                 break;
             default:
@@ -139 +145 @@
         }
     }
-
-    return QSplitter::eventFilter(aWatched, aEvent);
-}
-
-void QISplitter::showEvent(QShowEvent *aEvent)
-{
-    if (!mPolished)
-    {
-        mPolished = true;
-        mBaseState = saveState();
-    }
-
-    return QSplitter::showEvent(aEvent);
+#ifdef Q_WS_MAC
+    /* Special handling on the Mac. Cause there the horizontal handle is only 1
+     * pixel wide, its hard to catch. Therefor we make some invisible area
+     * around the handle and forwarding the mouse events to the handle, if the
+     * user presses the left mouse button. */
+    else if (   m_type == Native
+             && orientation() == Qt::Horizontal
+             && count() > 1
+             && qApp->activeWindow() == window())
+    {
+        switch (pEvent->type())
+        {
+            case QEvent::MouseButtonPress:
+            case QEvent::MouseMove:
+            {
+                const int margin = 3;
+                QMouseEvent *pMouseEvent = static_cast<QMouseEvent*>(pEvent);
+                for (int i=1; i < count(); ++i)
+                {
+                    QWidget *pHandle = handle(i);
+                    if (   pHandle
+                        && pHandle != pWatched)
+                    {
+                        /* Create new mouse event with translated mouse positions. */
+                        QMouseEvent newME(pMouseEvent->type(),
+                                          pHandle->mapFromGlobal(pMouseEvent->globalPos()),
+                                          pMouseEvent->button(),
+                                          pMouseEvent->buttons(),
+                                          pMouseEvent->modifiers());
+                        /* Check if we hit the handle */
+                        bool fMarginHit = QRect(pHandle->mapToGlobal(QPoint(0, 0)), pHandle->size()).adjusted(-margin, 0, margin, 0).contains(pMouseEvent->globalPos());
+                        if (pEvent->type() == QEvent::MouseButtonPress)
+                        {
+                            /* If we have a handle position hit and the left
+                             * button is pressed, start the grabbing. */
+                            if (   fMarginHit
+                                && pMouseEvent->buttons().testFlag(Qt::LeftButton))
+                            {
+                                m_fHandleGrabbed = true;
+                                setCursor(Qt::SplitHCursor);
+                                qApp->postEvent(pHandle, new QMouseEvent(newME));
+                                return true;
+                            }
+                        }
+                        else if(pEvent->type() == QEvent::MouseMove)
+                        {
+                            /* If we are in the near of the handle or currently
+                             * dragging, forward the mouse event. */
+                            if (   fMarginHit
+                                || (   m_fHandleGrabbed
+                                    && pMouseEvent->buttons().testFlag(Qt::LeftButton)))
+                            {
+                                setCursor(Qt::SplitHCursor);
+                                qApp->postEvent(pHandle, new QMouseEvent(newME));
+                                return true;
+                            }
+                            else
+                            {
+                                /* If not, reset the state. */
+                                m_fHandleGrabbed = false;
+                                setCursor(Qt::ArrowCursor);
+                            }
+                        }
+                    }
+                }
+                break;
+            }
+            case QEvent::WindowDeactivate:
+            case QEvent::MouseButtonRelease:
+            {
+                m_fHandleGrabbed = false;
+                setCursor(Qt::ArrowCursor);
+                break;
+            }
+            default:
+                break;
+        }
+    }
+#endif /* Q_WS_MAC */
+
+    return QSplitter::eventFilter(pWatched, pEvent);
+}
+
+void QISplitter::showEvent(QShowEvent *pEvent)
+{
+    if (!m_fPolished)
+    {
+        m_fPolished = true;
+        m_baseState = saveState();
+    }
+
+    return QSplitter::showEvent(pEvent);
 }
 

trunk/src/VBox/Frontends/VirtualBox/src/extensions/QISplitter.h

@@ -31 +31 @@
     enum Type { Native, Shade };
 
-    QISplitter(QWidget *aParent = 0);
+    QISplitter(QWidget *pParent = 0);
     QISplitter(Qt::Orientation orientation = Qt::Horizontal, QWidget *pParent = 0);
 
     void setHandleType(Type type) { m_type = type; }
     Type handleType() const { return m_type; }
-private:
 
-    bool eventFilter(QObject *aWatched, QEvent *aEvent);
-    void showEvent(QShowEvent *aEvent);
+protected:
+
+    bool eventFilter(QObject *pWatched, QEvent *pEvent);
+    void showEvent(QShowEvent *pEvent);
 
     QSplitterHandle* createHandle();
 
-    QByteArray mBaseState;
+private:
 
-    bool mPolished;
+    QByteArray m_baseState;
+
+    bool m_fPolished;
     Type m_type;
+#ifdef Q_WS_MAC
+    bool m_fHandleGrabbed;
+#endif /* Q_WS_MAC */
 };