- 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

@@ -52,10 +52,10 @@ class CTabsWidget;
  */
 struct AutoHideSideBarPrivate
 {
-	/**
+  /**
-	 * Private data constructor
+   * Private data constructor
-	 */
+   */
-	AutoHideSideBarPrivate(CAutoHideSideBar* _public);
+  AutoHideSideBarPrivate(CAutoHideSideBar* _public);
 
     CAutoHideSideBar* _this;
     CDockContainerWidget* ContainerWidget;
@@ -63,19 +63,30 @@ struct AutoHideSideBarPrivate
     QBoxLayout* TabsLayout;
     Qt::Orientation Orientation;
     SideBarLocation SideTabArea = SideBarLocation::SideBarLeft;
+    CAutoHideTab* PlaceholderTab;
 
     /**
      * Convenience function to check if this is a horizontal side bar
      */
     bool isHorizontal() const
     {
-    	return Qt::Horizontal == Orientation;
+      return Qt::Horizontal == Orientation;
     }
 
     /**
      * 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
 
 
@@ -85,72 +96,74 @@ struct AutoHideSideBarPrivate
 class CTabsWidget : public QWidget
 {
 public:
-	using QWidget::QWidget;
+  using QWidget::QWidget;
-	using Super = QWidget;
+  using Super = QWidget;
-	AutoHideSideBarPrivate* EventHandler;
+  AutoHideSideBarPrivate* EventHandler;
 
-	/**
+  /**
-	 * Returns the size hint as minimum size hint
+   * Returns the size hint as minimum size hint
-	 */
+   */
-	virtual QSize minimumSizeHint() const override
+  virtual QSize minimumSizeHint() const override
-	{
+  {
-		return Super::sizeHint();
+    return Super::sizeHint();
-	}
+  }
 
-	/**
+  /**
-	 * Forward event handling to EventHandler
+   * Forward event handling to EventHandler
-	 */
+   */
-	virtual bool event(QEvent* e) override
+  virtual bool event(QEvent* e) override
-	{
+  {
-		EventHandler->handleViewportEvent(e);
+    EventHandler->handleViewportEvent(e);
-		return Super::event(e);
+    return Super::event(e);
-	}
+  }
 };
 
 
 //============================================================================
 AutoHideSideBarPrivate::AutoHideSideBarPrivate(CAutoHideSideBar* _public) :
-    _this(_public)
+    _this(_public),
+    PlaceholderTab(new CAutoHideTab(_this))
 {
+    PlaceholderTab->hide();
 }
 
 
 //============================================================================
 void AutoHideSideBarPrivate::handleViewportEvent(QEvent* e)
 {
-	switch (e->type())
+  switch (e->type())
-	{
+  {
-	case QEvent::ChildRemoved:
+  case QEvent::ChildRemoved:
-		if (TabsLayout->isEmpty())
+    if (TabsLayout->isEmpty())
-		{
+    {
-			_this->hide();
+      _this->hide();
-		}
+    }
-		break;
+    break;
 
-	case QEvent::Resize:
+  case QEvent::Resize:
-		if (_this->tabCount())
+    if (_this->tabCount())
-		{
+    {
-			auto ev = static_cast<QResizeEvent*>(e);
+      auto ev = static_cast<QResizeEvent*>(e);
-			auto Tab = _this->tabAt(0);
+      auto Tab = _this->tabAt(0);
-			int Size = isHorizontal() ? ev->size().height() : ev->size().width();
+      int Size = isHorizontal() ? ev->size().height() : ev->size().width();
-			int TabSize = isHorizontal() ? Tab->size().height() : Tab->size().width();
+      int TabSize = isHorizontal() ? Tab->size().height() : Tab->size().width();
-			// If the size of the side bar is less than the size of the first tab
+      // If the size of the side bar is less than the size of the first tab
-			// then there are no visible tabs in this side bar. This check will
+      // then there are no visible tabs in this side bar. This check will
-			// fail if someone will force a very big border via CSS!!
+      // fail if someone will force a very big border via CSS!!
-			if (Size < TabSize)
+      if (Size < TabSize)
-			{
+      {
-				_this->hide();
+        _this->hide();
-			}
+      }
-		}
+    }
-		else
+    else
-		{
+    {
-			_this->hide();
+      _this->hide();
-		}
+    }
-		break;
+    break;
 
-	default:
+  default:
-		break;
+    break;
-	}
+  }
 }
 
 
@@ -159,56 +172,56 @@ CAutoHideSideBar::CAutoHideSideBar(CDockContainerWidget* parent, SideBarLocation
     Super(parent),
     d(new AutoHideSideBarPrivate(this))
 {
-	d->SideTabArea = area;
+  d->SideTabArea = area;
-    d->ContainerWidget = parent;
+  d->ContainerWidget = parent;
-    d->Orientation = (area == SideBarLocation::SideBarBottom || area == SideBarLocation::SideBarTop)
+  d->Orientation = (area == SideBarLocation::SideBarBottom || area == SideBarLocation::SideBarTop)
-    	? Qt::Horizontal : Qt::Vertical;
+  ? Qt::Horizontal : Qt::Vertical;
 
-	setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
+  setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
-	setFrameStyle(QFrame::NoFrame);
+  setFrameStyle(QFrame::NoFrame);
-	setWidgetResizable(true);
+  setWidgetResizable(true);
-	setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+  setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
-	setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+  setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
 
-	d->TabsContainerWidget = new CTabsWidget();
+  d->TabsContainerWidget = new CTabsWidget();
-	d->TabsContainerWidget->EventHandler = d;
+  d->TabsContainerWidget->EventHandler = d;
-	d->TabsContainerWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
+  d->TabsContainerWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
-	d->TabsContainerWidget->setObjectName("sideTabsContainerWidget");
+  d->TabsContainerWidget->setObjectName("sideTabsContainerWidget");
 
 
-    d->TabsLayout = new QBoxLayout(d->Orientation == Qt::Vertical ? QBoxLayout::TopToBottom : QBoxLayout::LeftToRight);
+  d->TabsLayout = new QBoxLayout(d->Orientation == Qt::Vertical ? QBoxLayout::TopToBottom : QBoxLayout::LeftToRight);
-    d->TabsLayout->setContentsMargins(0, 0, 0, 0);
+  d->TabsLayout->setContentsMargins(0, 0, 0, 0);
-    d->TabsLayout->setSpacing(12);
+  d->TabsLayout->setSpacing(12);
-    d->TabsLayout->addStretch(1);
+  d->TabsLayout->addStretch(1);
-    d->TabsContainerWidget->setLayout(d->TabsLayout);
+  d->TabsContainerWidget->setLayout(d->TabsLayout);
-	setWidget(d->TabsContainerWidget);
+  setWidget(d->TabsContainerWidget);
 
     setFocusPolicy(Qt::NoFocus);
-	if (d->isHorizontal())
+  if (d->isHorizontal())
-	{
+  {
-		setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
+    setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
-	}
+  }
-	else
+  else
-	{
+  {
-		setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Expanding);
+    setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Expanding);
-	}
+  }
 
-	hide();
+  hide();
 }
 
 
 //============================================================================
 CAutoHideSideBar::~CAutoHideSideBar() 
 {
-	ADS_PRINT("~CSideTabBar()");
+  ADS_PRINT("~CSideTabBar()");
-	// The SideTabeBar is not the owner of the tabs and to prevent deletion
+  // The SideTabeBar is not the owner of the tabs and to prevent deletion
-	// we set the parent here to nullptr to remove it from the children
+  // we set the parent here to nullptr to remove it from the children
-	auto Tabs = findChildren<CAutoHideTab*>(QString(), Qt::FindDirectChildrenOnly);
+  auto Tabs = findChildren<CAutoHideTab*>(QString(), Qt::FindDirectChildrenOnly);
-	for (auto Tab : Tabs)
+  for (auto Tab : Tabs)
-	{
+  {
-		Tab->setParent(nullptr);
+    Tab->setParent(nullptr);
-	}
+  }
-	delete d;
+  delete d;
 }
 
 
@@ -216,14 +229,16 @@ CAutoHideSideBar::~CAutoHideSideBar()
 void CAutoHideSideBar::insertTab(int Index, CAutoHideTab* SideTab)
 {
     SideTab->setSideBar(this);
-	SideTab->installEventFilter(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);
+      d->TabsLayout->insertWidget(d->TabsLayout->count() - 1, SideTab);
     }
     else
     {
-    	d->TabsLayout->insertWidget(Index, SideTab);
+      d->TabsLayout->insertWidget(Index, SideTab);
     }
     show();
 }
@@ -232,55 +247,55 @@ void CAutoHideSideBar::insertTab(int Index, CAutoHideTab* SideTab)
 //============================================================================
 CAutoHideDockContainer* CAutoHideSideBar::insertDockWidget(int Index, CDockWidget* DockWidget)
 {
-	auto AutoHideContainer = new CAutoHideDockContainer(DockWidget, d->SideTabArea, d->ContainerWidget);
+  auto AutoHideContainer = new CAutoHideDockContainer(DockWidget, d->SideTabArea, d->ContainerWidget);
-	DockWidget->dockManager()->dockFocusController()->clearDockWidgetFocus(DockWidget);
+  DockWidget->dockManager()->dockFocusController()->clearDockWidgetFocus(DockWidget);
-	auto Tab = AutoHideContainer->autoHideTab();
+  auto Tab = AutoHideContainer->autoHideTab();
-	DockWidget->setSideTabWidget(Tab);
+  DockWidget->setSideTabWidget(Tab);
-	insertTab(Index, Tab);
+  insertTab(Index, Tab);
-	return AutoHideContainer;
+  return AutoHideContainer;
 }
 
 
 //============================================================================
 void CAutoHideSideBar::removeAutoHideWidget(CAutoHideDockContainer* AutoHideWidget)
 {
-	AutoHideWidget->autoHideTab()->removeFromSideBar();
+  AutoHideWidget->autoHideTab()->removeFromSideBar();
-	auto DockContainer = AutoHideWidget->dockContainer();
+  auto DockContainer = AutoHideWidget->dockContainer();
-	if (DockContainer)
+  if (DockContainer)
-	{
+  {
-		DockContainer->removeAutoHideWidget(AutoHideWidget);
+    DockContainer->removeAutoHideWidget(AutoHideWidget);
-	}
+  }
-	AutoHideWidget->setParent(nullptr);
+  AutoHideWidget->setParent(nullptr);
 }
 
 //============================================================================
 void CAutoHideSideBar::addAutoHideWidget(CAutoHideDockContainer* AutoHideWidget)
 {
-	auto SideBar = AutoHideWidget->autoHideTab()->sideBar();
+  auto SideBar = AutoHideWidget->autoHideTab()->sideBar();
-	if (SideBar == this)
+  if (SideBar == this)
-	{
+  {
-		return;
+    return;
-	}
+  }
 
-	if (SideBar)
+  if (SideBar)
-	{
+  {
-		SideBar->removeAutoHideWidget(AutoHideWidget);
+    SideBar->removeAutoHideWidget(AutoHideWidget);
-	}
+  }
-	AutoHideWidget->setParent(d->ContainerWidget);
+  AutoHideWidget->setParent(d->ContainerWidget);
-	AutoHideWidget->setSideBarLocation(d->SideTabArea);
+  AutoHideWidget->setSideBarLocation(d->SideTabArea);
-	d->ContainerWidget->registerAutoHideWidget(AutoHideWidget);
+  d->ContainerWidget->registerAutoHideWidget(AutoHideWidget);
-	insertTab(-1, AutoHideWidget->autoHideTab());
+  insertTab(-1, AutoHideWidget->autoHideTab());
 }
 
 
 //============================================================================
 void CAutoHideSideBar::removeTab(CAutoHideTab* SideTab)
 {
-	SideTab->removeEventFilter(this);
+    SideTab->removeEventFilter(this);
     d->TabsLayout->removeWidget(SideTab);
     if (d->TabsLayout->isEmpty())
     {
-    	hide();
+      hide();
     }
 }
 
@@ -288,18 +303,18 @@ void CAutoHideSideBar::removeTab(CAutoHideTab* SideTab)
 //============================================================================
 bool CAutoHideSideBar::eventFilter(QObject *watched, QEvent *event)
 {
-	if (event->type() != QEvent::ShowToParent)
+    if (event->type() != QEvent::ShowToParent)
-	{
+    {
-		return false;
+        return false;
-	}
+    }
 
-	// As soon as on tab is shown, we need to show the side tab bar
+    // As soon as on tab is shown, we need to show the side tab bar
-	auto Tab = qobject_cast<CAutoHideTab*>(watched);
+    auto Tab = qobject_cast<CAutoHideTab*>(watched);
-	if (Tab)
+    if (Tab)
-	{
+    {
-		show();
+        show();
-	}
+    }
-	return false;
+    return false;
 }
 
 //============================================================================
@@ -326,71 +341,165 @@ int CAutoHideSideBar::tabCount() const
 //============================================================================
 SideBarLocation CAutoHideSideBar::sideBarLocation() const
 {
-	return d->SideTabArea;
+  return d->SideTabArea;
 }
 
 
 //============================================================================
 void CAutoHideSideBar::saveState(QXmlStreamWriter& s) const
 {
-	if (!tabCount())
+  if (!tabCount())
-	{
+  {
-		return;
+    return;
-	}
+  }
 
-	s.writeStartElement("SideBar");
+  s.writeStartElement("SideBar");
-	s.writeAttribute("Area", QString::number(sideBarLocation()));
+  s.writeAttribute("Area", QString::number(sideBarLocation()));
-	s.writeAttribute("Tabs", QString::number(tabCount()));
+  s.writeAttribute("Tabs", QString::number(tabCount()));
 
-	for (auto i = 0; i < tabCount(); ++i)
+  for (auto i = 0; i < tabCount(); ++i)
-	{
+  {
-		auto Tab = tabAt(i);
+    auto Tab = tabAt(i);
-		if (!Tab)
+    if (!Tab)
-		{
+    {
-			continue;
+      continue;
-		}
+    }
 
-		Tab->dockWidget()->autoHideDockContainer()->saveState(s);
+    Tab->dockWidget()->autoHideDockContainer()->saveState(s);
-	}
+  }
 
-	s.writeEndElement();
+  s.writeEndElement();
 }
 
 //===========================================================================
 QSize CAutoHideSideBar::minimumSizeHint() const
 {
-	QSize Size = sizeHint();
+  QSize Size = sizeHint();
-	Size.setWidth(10);
+  Size.setWidth(10);
-	return Size;
+  return Size;
 }
 
 
 //===========================================================================
 QSize CAutoHideSideBar::sizeHint() const
 {
-	return d->TabsContainerWidget->sizeHint();
+  return d->TabsContainerWidget->sizeHint();
 }
 
 
 //===========================================================================
 int CAutoHideSideBar::spacing() const
 {
-	return d->TabsLayout->spacing();
+  return d->TabsLayout->spacing();
 }
 
 
 //===========================================================================
 void CAutoHideSideBar::setSpacing(int Spacing)
 {
-	d->TabsLayout->setSpacing(Spacing);
+  d->TabsLayout->setSpacing(Spacing);
 }
 
 
 //===========================================================================
 CDockContainerWidget* CAutoHideSideBar::dockContainer() const
 {
-	return d->ContainerWidget;
+  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

@@ -49,8 +49,12 @@ struct AutoHideTabPrivate
     CAutoHideTab* _this;
     CDockWidget* DockWidget = nullptr;
     CAutoHideSideBar* SideBar = nullptr;
-	Qt::Orientation Orientation{Qt::Vertical};
+    Qt::Orientation Orientation{Qt::Vertical};
-	QElapsedTimer TimeSinceHoverMousePress;
+    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,8 +185,9 @@ void CAutoHideTab::removeFromSideBar()
 	{
 		return;
 	}
+	disconnect(d->SideBar);
 	d->SideBar->removeTab(this);
-    setSideBar(nullptr);
+	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

@@ -52,24 +52,27 @@ class ADS_EXPORT CAutoHideTab : public CPushButton
 
     Q_PROPERTY(int sideBarLocation READ sideBarLocation)
     Q_PROPERTY(Qt::Orientation orientation READ orientation)
-	Q_PROPERTY(bool activeTab READ isActiveTab)
+    Q_PROPERTY(bool activeTab READ isActiveTab)
-	Q_PROPERTY(bool iconOnly READ iconOnly)
+    Q_PROPERTY(bool iconOnly READ iconOnly)
 
 private:    
-	AutoHideTabPrivate* d; ///< private data (pimpl)
+    AutoHideTabPrivate* d; ///< private data (pimpl)
     friend struct AutoHideTabPrivate;
-	friend class CDockWidget;
+    friend class CDockWidget;
-	friend class CAutoHideDockContainer;
+    friend class CAutoHideDockContainer;
-	friend class CAutoHideSideBar;
+    friend class CAutoHideSideBar;
-	friend class CDockAreaWidget;
+    friend class CDockAreaWidget;
-	friend class CDockContainerWidget;
+    friend class CDockContainerWidget;
-	friend DockContainerWidgetPrivate;
+    friend DockContainerWidgetPrivate;
-
 
 protected:
-	void setSideBar(CAutoHideSideBar *SideTabBar);
+    void setSideBar(CAutoHideSideBar *SideTabBar);
-	void removeFromSideBar();
+    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;