- Add draggable auto hide tab functionality

- Change auto hide tab open from mouse press to mouse release

src/AutoHideDockContainer.cpp

@@ -199,7 +199,7 @@ CAutoHideDockContainer::CAutoHideDockContainer(CDockWidget* DockWidget, SideBarL
 	hide(); // auto hide dock container is initially always hidden
 	d->SideTabBarArea = area;
 	d->SideTab = componentsFactory()->createDockWidgetSideTab(nullptr);
-	connect(d->SideTab, &CAutoHideTab::pressed, this, &CAutoHideDockContainer::toggleCollapseState);
+	connect(d->SideTab, &CAutoHideTab::released, this, &CAutoHideDockContainer::toggleCollapseState);
 	d->DockArea = new CDockAreaWidget(DockWidget->dockManager(), parent);
 	d->DockArea->setObjectName("autoHideDockArea");
 	d->DockArea->setAutoHideDockContainer(this);
@@ -540,7 +540,7 @@ bool CAutoHideDockContainer::eventFilter(QObject* watched, QEvent* event)
 			updateSize();
 		}
 	}
-	else if (event->type() == QEvent::MouseButtonPress)
+	else if (event->type() == QEvent::MouseButtonRelease)
 	{
 		auto widget = qobject_cast<QWidget*>(watched);
 		// Ignore non widget events

src/AutoHideSideBar.cpp

@@ -63,6 +63,7 @@ struct AutoHideSideBarPrivate
     QBoxLayout* TabsLayout;
     Qt::Orientation Orientation;
     SideBarLocation SideTabArea = SideBarLocation::SideBarLeft;
+    CAutoHideTab* PlaceholderTab;
 
     /**
      * Convenience function to check if this is a horizontal side bar
@@ -76,6 +77,16 @@ struct AutoHideSideBarPrivate
      * Called from viewport to forward event handling to this
      */
     void handleViewportEvent(QEvent* e);
+
+    /**
+    * Convenience function to access first tab
+    */
+    CAutoHideTab* firstTab() const {return _this->tab(0);}
+
+    /**
+    * Convenience function to access last tab
+    */
+    CAutoHideTab* lastTab() const {return _this->tab(_this->tabCount() - 1);}
 }; // struct AutoHideSideBarPrivate
 
 
@@ -110,8 +121,10 @@ public:
 
 //============================================================================
 AutoHideSideBarPrivate::AutoHideSideBarPrivate(CAutoHideSideBar* _public) :
-    _this(_public)
+    _this(_public),
+    PlaceholderTab(new CAutoHideTab(_this))
 {
+    PlaceholderTab->hide();
 }
 
 
@@ -217,6 +230,8 @@ void CAutoHideSideBar::insertTab(int Index, CAutoHideTab* SideTab)
 {
     SideTab->setSideBar(this);
     SideTab->installEventFilter(this);
+    connect(SideTab, SIGNAL(moved(QPoint)), this, SLOT(onAutoHideTabMoved(QPoint)));
+    connect(SideTab, SIGNAL(moving(QPoint)), this, SLOT(onAutoHideTabMoving(QPoint)));
     if (Index < 0)
     {
       d->TabsLayout->insertWidget(d->TabsLayout->count() - 1, SideTab);
@@ -392,5 +407,99 @@ CDockContainerWidget* CAutoHideSideBar::dockContainer() const
   return d->ContainerWidget;
 }
 
+
+//===========================================================================
+void CAutoHideSideBar::onAutoHideTabMoved(const QPoint& GlobalPos)
+{
+    auto MovingTab = qobject_cast<CAutoHideTab*>(sender());
+    if (!MovingTab)
+    {
+        return;
+    }
+
+    QSizePolicy sp_retain = d->PlaceholderTab->sizePolicy();
+    sp_retain.setRetainSizeWhenHidden(false);
+    d->PlaceholderTab->setSizePolicy(sp_retain);
+
+    // Swap the placeholder and the moved tab
+    const auto index = d->TabsLayout->indexOf(d->PlaceholderTab);
+    d->TabsLayout->removeWidget(d->PlaceholderTab);
+    d->TabsLayout->insertWidget(index, MovingTab);
+}
+
+
+//===========================================================================
+void CAutoHideSideBar::onAutoHideTabMoving(const QPoint& GlobalPos)
+{
+    auto MovingTab = qobject_cast<CAutoHideTab*>(sender());
+    if (!MovingTab)
+    {
+        return;
+    }
+
+    d->PlaceholderTab->setText(MovingTab->text());
+    d->PlaceholderTab->setOrientation(MovingTab->orientation());
+    QSizePolicy sp_retain = d->PlaceholderTab->sizePolicy();
+    sp_retain.setRetainSizeWhenHidden(true);
+    d->PlaceholderTab->setSizePolicy(sp_retain);
+    d->PlaceholderTab->setGeometry(MovingTab->geometry());
+
+    if (const auto index = d->TabsLayout->indexOf(MovingTab); index > -1)
+    {
+        // First time moving, set the placeholder tab into the moving tab position
+        d->TabsLayout->removeWidget(MovingTab);
+        d->TabsLayout->insertWidget(index, d->PlaceholderTab);
+    }
+
+    int fromIndex = d->TabsLayout->indexOf(d->PlaceholderTab);
+
+    auto MousePos = mapFromGlobal(GlobalPos);
+    MousePos.rx() = qMax(d->firstTab()->geometry().left(), MousePos.x());
+    MousePos.rx() = qMin(d->lastTab()->geometry().right(), MousePos.x());
+    MousePos.ry() = qMax(d->firstTab()->geometry().top(), MousePos.y());
+    MousePos.ry() = qMin(d->lastTab()->geometry().bottom(), MousePos.y());
+
+    int toIndex = -1;
+    // Find tab under mouse
+    for (int i = 0; i < tabCount(); ++i)
+    {
+        CAutoHideTab* DropTab = tab(i);
+        if (DropTab == d->PlaceholderTab || !DropTab->isVisibleTo(this)
+            || !DropTab->geometry().contains(MousePos)
+            )
+        {
+            continue;
+        }
+
+        toIndex = d->TabsLayout->indexOf(DropTab);
+        if (toIndex == fromIndex)
+        {
+            toIndex = -1;
+        }
+        break;
+    }
+
+    if (toIndex > -1)
+    {
+        d->TabsLayout->removeWidget(d->PlaceholderTab);
+        d->TabsLayout->insertWidget(toIndex, d->PlaceholderTab);
+    }
+    else
+    {
+        // Ensure that the moved tab is reset to its start position
+        d->TabsLayout->update();
+    }
+}
+
+
+//===========================================================================
+CAutoHideTab* CAutoHideSideBar::tab(int Index) const
+{
+	if (Index >= tabCount() || Index < 0)
+	{
+		return nullptr;
+	}
+	return qobject_cast<CAutoHideTab*>(d->TabsLayout->itemAt(Index)->widget());
+}
 } // namespace ads
 

src/AutoHideSideBar.h

@@ -68,6 +68,10 @@ private:
 	friend DockContainerWidgetPrivate;
 	friend CDockContainerWidget;
 
+private Q_SLOTS:
+    void onAutoHideTabMoved(const QPoint& GlobalPos);
+    void onAutoHideTabMoving(const QPoint& GlobalPos);
+
 protected:
 	virtual bool eventFilter(QObject *watched, QEvent *event) override;
 
@@ -168,6 +172,11 @@ public:
 	 * Returns the dock container that hosts this sideBar()
 	 */
 	CDockContainerWidget* dockContainer() const;
+
+  /**
+   * Returns the tab with the given index
+   */
+  CAutoHideTab* tab(int Index) const;
 };
 } // namespace ads
 //-----------------------------------------------------------------------------

src/AutoHideTab.cpp

@@ -51,6 +51,10 @@ struct AutoHideTabPrivate
     CAutoHideSideBar* SideBar = nullptr;
     Qt::Orientation Orientation{Qt::Vertical};
     QElapsedTimer TimeSinceHoverMousePress;
+    QPoint GlobalDragStartMousePosition;
+    QPoint DragStartMousePosition;
+    QPoint TabDragStartPosition;
+    eDragState DragState = DraggingInactive;
 
 	/**
 	 * Private data constructor
@@ -82,6 +86,28 @@ struct AutoHideTabPrivate
 			DockContainer->handleAutoHideWidgetEvent(event, _this);
 		}
 	}
+
+	/**
+	 * Saves the drag start position in global and local coordinates
+	 */
+	void saveDragStartMousePosition(const QPoint& GlobalPos)
+	{
+		GlobalDragStartMousePosition = GlobalPos;
+		DragStartMousePosition = _this->mapFromGlobal(GlobalPos);
+	}
+
+	/**
+	 * Test function for current drag state
+	 */
+	bool isDraggingState(eDragState dragState) const
+	{
+		return this->DragState == dragState;
+	}
+
+	/**
+	 * Moves the tab depending on the position in the given mouse event
+	 */
+	void moveTab(QMouseEvent* ev);
 }; // struct DockWidgetTabPrivate
 
 
@@ -110,6 +136,30 @@ void AutoHideTabPrivate::updateOrientation()
 }
 
 
+//============================================================================
+void AutoHideTabPrivate::moveTab(QMouseEvent* ev)
+{
+    ev->accept();
+    QPoint Distance = internal::globalPositionOf(ev) - GlobalDragStartMousePosition;
+	Orientation == Qt::Horizontal ? Distance.setY(0) : Distance.setX(0);
+    auto TargetPos = Distance + TabDragStartPosition;
+
+	if (Orientation == Qt::Horizontal)
+	{
+        TargetPos.rx() = qMax(TargetPos.x(), 0);
+        TargetPos.rx() = qMin(_this->parentWidget()->rect().right() - _this->width() + 1, TargetPos.rx());
+	}
+	else
+	{
+        TargetPos.ry() = qMax(0, TargetPos.y());
+        TargetPos.ry() = qMin(_this->parentWidget()->rect().bottom() - _this->height() + 1, TargetPos.ry());
+	}
+
+    _this->move(TargetPos);
+    _this->raise();
+}
+
+
 //============================================================================
 void CAutoHideTab::setSideBar(CAutoHideSideBar* SideTabBar)
 {
@@ -135,6 +185,7 @@ void CAutoHideTab::removeFromSideBar()
 	{
 		return;
 	}
+	disconnect(d->SideBar);
 	d->SideBar->removeTab(this);
 	setSideBar(nullptr);
 }
@@ -250,9 +301,9 @@ bool CAutoHideTab::event(QEvent* event)
 		 d->forwardEventToDockContainer(event);
 		 break;
 
-	case QEvent::MouseButtonPress:
+	case QEvent::MouseButtonRelease:
 		 // If AutoHideShowOnMouseOver is active, then the showing is triggered
-		 // by a MousePressEvent sent to this tab. To prevent accidental hiding
+		 // by a MousePresRelease sent to this tab. To prevent accidental hiding
 		 // of the tab by a mouse click, we wait at least 500 ms before we accept
 		 // the mouse click
 		 if (!event->spontaneous())
@@ -272,6 +323,86 @@ bool CAutoHideTab::event(QEvent* event)
 	return Super::event(event);
 }
 
+
+//============================================================================
+void CAutoHideTab::mousePressEvent(QMouseEvent* ev)
+{
+    if (ev->button() == Qt::LeftButton)
+    {
+        ev->accept();
+        d->saveDragStartMousePosition(internal::globalPositionOf(ev));
+        d->DragState = DraggingMousePressed;
+        Q_EMIT clicked();
+        return;
+    }
+    Super::mousePressEvent(ev);
+}
+
+
+//============================================================================
+void CAutoHideTab::mouseMoveEvent(QMouseEvent* ev)
+{
+	if (!(ev->buttons() & Qt::LeftButton) || d->isDraggingState(DraggingInactive))
+	{
+		d->DragState = DraggingInactive;
+		Super::mouseMoveEvent(ev);
+		return;
+	}
+
+	// move tab
+	if (d->isDraggingState(DraggingTab))
+	{
+		// Moving the tab is always allowed because it does not mean moving the
+		// dock widget around
+		d->moveTab(ev);
+		Q_EMIT moving(internal::globalPositionOf(ev));
+	}
+
+	else if (
+		(internal::globalPositionOf(ev) - d->GlobalDragStartMousePosition).manhattanLength() >= QApplication::startDragDistance()) // Wait a few pixels before start moving 
+	{
+		// If we start dragging the tab, we save its inital position to
+		// restore it later
+		if (DraggingTab != d->DragState)
+		{
+			d->TabDragStartPosition = this->pos();
+		}
+		d->DragState = DraggingTab;
+		return;
+    }
+
+    Super::mouseMoveEvent(ev);
+}
+
+
+//============================================================================
+void CAutoHideTab::mouseReleaseEvent(QMouseEvent* ev)
+{
+	if (ev->button() == Qt::LeftButton)
+	{
+		auto CurrentDragState = d->DragState;
+		d->GlobalDragStartMousePosition = QPoint();
+		d->DragStartMousePosition = QPoint();
+		d->DragState = DraggingInactive;
+
+		switch (CurrentDragState)
+		{
+		case DraggingInactive:
+		case DraggingMousePressed:
+			Q_EMIT released();
+			break;
+		case DraggingTab:
+			// End of tab moving, emit signal
+			ev->accept();
+			Q_EMIT moved(internal::globalPositionOf(ev));
+			break;
+		default:; // do nothing
+		}
+	} 
+
+	Super::mouseReleaseEvent(ev);
+}
+
 //============================================================================
 bool CAutoHideTab::iconOnly() const
 {

src/AutoHideTab.h

@@ -65,11 +65,14 @@ private:
     friend class CDockContainerWidget;
     friend DockContainerWidgetPrivate;
 
-
 protected:
     void setSideBar(CAutoHideSideBar *SideTabBar);
     void removeFromSideBar();
-	virtual bool event(QEvent* event) override;
+    bool event(QEvent* event) override;
+    void mousePressEvent(QMouseEvent* ev) override;
+    void mouseReleaseEvent(QMouseEvent* ev) override;
+    void mouseMoveEvent(QMouseEvent* ev) override;
+
 
 public:
     using Super = CPushButton;
@@ -133,6 +136,10 @@ public:
 	 * not in a side bar
 	 */
 	CAutoHideSideBar* sideBar() const;
+
+Q_SIGNALS:
+	void moved(const QPoint& GlobalPos);
+	void moving(const QPoint& GlobalPos);
 }; // class AutoHideTab
 }
  // namespace ads

src/DockContainerWidget.cpp

@@ -382,7 +382,7 @@ DockContainerWidgetPrivate::DockContainerWidgetPrivate(CDockContainerWidget* _pu
 	DelayedAutoHideTimer.setInterval(500);
 	QObject::connect(&DelayedAutoHideTimer, &QTimer::timeout, [this](){
 		auto GlobalPos = DelayedAutoHideTab->mapToGlobal(QPoint(0, 0));
-		qApp->sendEvent(DelayedAutoHideTab, new QMouseEvent(QEvent::MouseButtonPress,
+		qApp->sendEvent(DelayedAutoHideTab, new QMouseEvent(QEvent::MouseButtonRelease,
 				QPoint(0, 0), GlobalPos, Qt::LeftButton, {Qt::LeftButton}, Qt::NoModifier));
 	});
 }
@@ -2118,7 +2118,7 @@ void CDockContainerWidget::handleAutoHideWidgetEvent(QEvent* e, QWidget* w)
 			 }
 			 break;
 
-		case QEvent::MouseButtonPress:
+		case QEvent::MouseButtonRelease:
 			 d->DelayedAutoHideTimer.stop();
 			 break;