Improved CDockAreaTabBar::wheelEvent to use pixelDelta() if available (i.e. on Mac) and fall back to angleDelta() if not

This fix seems to have introduced a regression when _this is deleted before the lambda slot occurred, for example deleting the DockManager (and consequently _this) immediately after the execution of updateTabs function (we encountered this problem in linux)

.gitignore

@@ -9,7 +9,7 @@ ui_*
 Makefile
 *.dll
 *.a
-build-*
+build*
 
 # IDEs
 .idea

CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.5)
-
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 if (POLICY CMP0091)
   cmake_policy(SET CMP0091 NEW)
 endif (POLICY CMP0091)

demo/MainWindow.cpp

@@ -75,18 +75,17 @@
 #endif
 #endif
 
-#include "DockManager.h"
-#include "DockWidget.h"
-#include "DockAreaWidget.h"
-#include "DockAreaTitleBar.h"
 #include "DockAreaTabBar.h"
-#include "FloatingDockContainer.h"
+#include "DockAreaTitleBar.h"
+#include "DockAreaWidget.h"
 #include "DockComponentsFactory.h"
-#include "StatusDialog.h"
+#include "DockManager.h"
 #include "DockSplitter.h"
+#include "DockWidget.h"
+#include "FloatingDockContainer.h"
 #include "ImageViewer.h"
-
+#include "MyDockAreaTitleBar.h"
-
+#include "StatusDialog.h"
 
 /**
  * Returns a random number from 0 to highest - 1
@@ -147,7 +146,7 @@ public:
 	using Super = ads::CDockComponentsFactory;
 	ads::CDockAreaTitleBar* createDockAreaTitleBar(ads::CDockAreaWidget* DockArea) const override
 	{
-		auto TitleBar = new ads::CDockAreaTitleBar(DockArea);
+		auto TitleBar = new MyDockAreaTitleBar(DockArea);
 		auto CustomButton = new QToolButton(DockArea);
 		CustomButton->setToolTip(QObject::tr("Help"));
 		CustomButton->setIcon(svgIcon(":/adsdemo/images/help_outline.svg"));

demo/MyDockAreaTitleBar.h

@@ -0,0 +1,34 @@
+//
+// Created by fuga on 08 nov 2024.
+//
+
+#ifndef QTADS_MYDOCKAREATITLEBAR_H
+#define QTADS_MYDOCKAREATITLEBAR_H
+
+#include <DockAreaTitleBar.h>
+
+class MyDockAreaTitleBar : public ads::CDockAreaTitleBar {
+public:
+    explicit MyDockAreaTitleBar(ads::CDockAreaWidget* parent)
+        : CDockAreaTitleBar(parent)
+    {}
+
+    QMenu* buildContextMenu(QMenu*) override
+    {
+        auto menu = ads::CDockAreaTitleBar::buildContextMenu(nullptr);
+        menu->addSeparator();
+        auto action = menu->addAction(tr("Format HardDrive"));
+        
+        connect(action, &QAction::triggered, this, [this](){
+            QMessageBox msgBox;
+            msgBox.setText("No, just kidding");
+            msgBox.setStandardButtons(QMessageBox::Abort);
+            msgBox.setDefaultButton(QMessageBox::Abort);
+            msgBox.exec();
+        });
+        
+        return menu;
+    }
+};
+
+#endif  // QTADS_MYDOCKAREATITLEBAR_H

doc/user-guide.md

@@ -49,6 +49,7 @@
   - [`AutoHideCloseButtonCollapsesDock`](#autohideclosebuttoncollapsesdock)
   - [`AutoHideHasCloseButton`](#autohidehasclosebutton)
   - [`AutoHideHasMinimizeButton`](#autohidehasminimizebutton)
+  - [`AutoHideOpenOnDragHover`](#autohideopenondraghover)
 - [DockWidget Feature Flags](#dockwidget-feature-flags)
   - [`DockWidgetClosable`](#dockwidgetclosable)
   - [`DockWidgetMovable`](#dockwidgetmovable)
@@ -704,6 +705,15 @@ If this flag is set (disabled by default), then each auto hide widget has a mini
 
 ![AutoHideHasMinimizeButton](cfg_flag_AutoHideHasMinimizeButton.png)
 
+
+### `AutoHideOpenOnDragHover`
+
+If this flag is set (disabled by default), then holding a dragging cursor hover an auto-hide collapsed dock's tab will open said dock:
+
+![AutoHideOpenOnDragHover](cfg_flag_AutoHideOpenOnDragHover.gif)
+
+Said dock must be set to accept drops to hide when cursor leaves its scope. See `AutoHideDragNDropExample` for more details.
+
 ## DockWidget Feature Flags
 
 ### `DockWidgetClosable`

examples/CMakeLists.txt

@@ -6,5 +6,6 @@ add_subdirectory(sidebar)
 add_subdirectory(deleteonclose)
 add_subdirectory(centralwidget)
 add_subdirectory(autohide)
+add_subdirectory(autohidedragndrop)
 add_subdirectory(emptydockarea)
 add_subdirectory(dockindock)

examples/autohidedragndrop/CMakeLists.txt

@@ -0,0 +1,29 @@
+cmake_minimum_required(VERSION 3.5)
+project(ads_example_autohide_dragndrop VERSION ${VERSION_SHORT})
+find_package(QT NAMES Qt6 Qt5 COMPONENTS Core REQUIRED)
+find_package(Qt${QT_VERSION_MAJOR} 5.5 COMPONENTS Core Gui Widgets REQUIRED)
+set(CMAKE_INCLUDE_CURRENT_DIR ON)
+add_executable(AutoHideDragNDropExample WIN32
+    main.cpp
+    mainwindow.cpp
+    mainwindow.ui
+    droppableitem.cpp
+)
+target_include_directories(AutoHideDragNDropExample PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/../../src")
+target_link_libraries(AutoHideDragNDropExample PRIVATE qt${QT_VERSION_MAJOR}advanceddocking)
+target_link_libraries(AutoHideDragNDropExample PUBLIC Qt${QT_VERSION_MAJOR}::Core
+                                                  Qt${QT_VERSION_MAJOR}::Gui
+                                                  Qt${QT_VERSION_MAJOR}::Widgets)
+set_target_properties(AutoHideDragNDropExample PROPERTIES
+    AUTOMOC ON
+    AUTORCC ON
+    AUTOUIC ON
+    CXX_STANDARD 14
+    CXX_STANDARD_REQUIRED ON
+    CXX_EXTENSIONS OFF
+    VERSION ${VERSION_SHORT}
+    EXPORT_NAME "Qt Advanced Docking System Auto Hide With Drag N Drop Example"
+    ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/${ads_PlatformDir}/lib"
+    LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/${ads_PlatformDir}/lib"
+    RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/${ads_PlatformDir}/bin"
+)

examples/autohidedragndrop/autohidedragndrop.pro

@@ -0,0 +1,36 @@
+ADS_OUT_ROOT = $${OUT_PWD}/../..
+
+QT       += core gui widgets
+
+TARGET = AutoHideDragNDropExample
+DESTDIR = $${ADS_OUT_ROOT}/lib
+TEMPLATE = app
+CONFIG += c++14
+CONFIG += debug_and_release
+adsBuildStatic {
+    DEFINES += ADS_STATIC
+}
+
+# The following define makes your compiler emit warnings if you use
+# any Qt feature that has been marked deprecated (the exact warnings
+# depend on your compiler). Please consult the documentation of the
+# deprecated API in order to know how to port your code away from it.
+DEFINES += QT_DEPRECATED_WARNINGS
+
+SOURCES += \
+    main.cpp \
+    mainwindow.cpp \
+    droppableitem.cpp
+
+HEADERS += \
+    mainwindow.h \
+    droppableitem.h
+
+FORMS += \
+    mainwindow.ui
+
+LIBS += -L$${ADS_OUT_ROOT}/lib
+include(../../ads.pri)
+INCLUDEPATH += ../../src
+DEPENDPATH += ../../src
+

examples/autohidedragndrop/droppableitem.cpp

@@ -0,0 +1,38 @@
+#include "droppableitem.h"
+
+#include <QDragEnterEvent>
+#include <QDragLeaveEvent>
+#include <QDropEvent>
+#include <QMimeData>
+#include <qsizepolicy.h>
+
+DroppableItem::DroppableItem(const QString& text, QWidget* parent)
+    : QPushButton(text, parent)
+{
+    setAcceptDrops(true);
+    setSizePolicy(QSizePolicy::Policy::Expanding, QSizePolicy::Policy::Expanding);
+}
+
+void DroppableItem::dragEnterEvent(QDragEnterEvent* event)
+{
+    if (event->mimeData()->hasText())
+    {
+        event->acceptProposedAction();
+        setCursor(Qt::DragMoveCursor);
+    }
+}
+
+void DroppableItem::dragLeaveEvent(QDragLeaveEvent* event)
+{
+	Q_UNUSED(event);
+    unsetCursor();
+}
+
+void DroppableItem::dropEvent(QDropEvent* event)
+{
+    if (event->mimeData()->hasText())
+    {
+        event->acceptProposedAction();
+        setText(event->mimeData()->text());
+    }
+}

examples/autohidedragndrop/droppableitem.h

@@ -0,0 +1,19 @@
+#include <QObject>
+#include <QPushButton>
+
+class QDragEnterEvent;
+class QDragLeaveEvent;
+class QDropEvent;
+
+class DroppableItem : public QPushButton
+{
+    Q_OBJECT;
+
+public:
+    DroppableItem(const QString& text = QString(), QWidget* parent = nullptr);
+
+protected:
+    void dragEnterEvent(QDragEnterEvent* event) override;
+    void dragLeaveEvent(QDragLeaveEvent* event) override;
+    void dropEvent(QDropEvent* event) override;
+};

examples/autohidedragndrop/main.cpp

@@ -0,0 +1,10 @@
+#include <mainwindow.h>
+#include <QApplication>
+
+int main(int argc, char *argv[])
+{
+    QApplication a(argc, argv);
+    CMainWindow w;
+    w.show();
+    return a.exec();
+}

examples/autohidedragndrop/main.py

@@ -0,0 +1,84 @@
+import os
+import sys
+
+from PyQt5 import uic
+from PyQt5.QtCore import Qt, QTimer, QDir, QSignalBlocker
+from PyQt5.QtGui import QCloseEvent, QIcon
+from PyQt5.QtWidgets import (QApplication, QLabel, QCalendarWidget, QFrame, QTreeView,
+                             QTableWidget, QFileSystemModel, QPlainTextEdit, QToolBar,
+                             QWidgetAction, QComboBox, QAction, QSizePolicy, QInputDialog)
+
+import PyQtAds as QtAds
+
+UI_FILE = os.path.join(os.path.dirname(__file__), 'mainwindow.ui')
+MainWindowUI, MainWindowBase = uic.loadUiType(UI_FILE)
+
+class MainWindow(MainWindowUI, MainWindowBase):
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+
+        self.setupUi(self)
+
+        QtAds.CDockManager.setConfigFlag(QtAds.CDockManager.OpaqueSplitterResize, True)
+        QtAds.CDockManager.setConfigFlag(QtAds.CDockManager.XmlCompressionEnabled, False)
+        QtAds.CDockManager.setConfigFlag(QtAds.CDockManager.FocusHighlighting, True)
+        QtAds.CDockManager.setAutoHideConfigFlag(QtAds.CDockManager.AutoHideOpenOnDragHover, True);
+        self.dock_manager = QtAds.CDockManager(self)
+
+        # Set central widget
+        text_edit = QPlainTextEdit()
+        text_edit.setPlaceholderText("This is the central editor. Enter your text here.")
+        central_dock_widget = QtAds.CDockWidget("CentralWidget")
+        central_dock_widget.setWidget(text_edit)
+        central_dock_area = self.dock_manager.setCentralWidget(central_dock_widget)
+        central_dock_area.setAllowedAreas(QtAds.DockWidgetArea.OuterDockAreas)
+
+
+        droppable_item = DroppableItem("Drop text here.")
+        drop_dock_widget = QtAds.CDockWidget("Tab")
+        drop_dock_widget.setWidget(droppable_item)
+        drop_dock_widget.setMinimumSizeHintMode(QtAds.CDockWidget.MinimumSizeHintFromDockWidget)
+        drop_dock_widget.setMinimumSize(200, 150)
+        drop_dock_widget.setAcceptDrops(True)
+        drop_area = self.dock_manager.addDockWidget(QtAds.DockWidgetArea.LeftDockWidgetArea, drop_dock_widget)
+        drop_area.setAcceptDrops(True)
+        self.menuView.addAction(drop_dock_widget.toggleViewAction())
+
+        self.create_perspective_ui()
+
+    def create_perspective_ui(self):
+        save_perspective_action = QAction("Create Perspective", self)
+        save_perspective_action.triggered.connect(self.save_perspective)
+        perspective_list_action = QWidgetAction(self)
+        self.perspective_combobox = QComboBox(self)
+        self.perspective_combobox.setSizeAdjustPolicy(QComboBox.AdjustToContents)
+        self.perspective_combobox.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
+        self.perspective_combobox.activated[str].connect(self.dock_manager.openPerspective)
+        perspective_list_action.setDefaultWidget(self.perspective_combobox)
+        self.toolBar.addSeparator()
+        self.toolBar.addAction(perspective_list_action)
+        self.toolBar.addAction(save_perspective_action)
+
+    def save_perspective(self):
+        perspective_name, ok = QInputDialog.getText(self, "Save Perspective", "Enter Unique name:")
+        if not ok or not perspective_name:
+            return
+
+        self.dock_manager.addPerspective(perspective_name)
+        blocker = QSignalBlocker(self.perspective_combobox)
+        self.perspective_combobox.clear()
+        self.perspective_combobox.addItems(self.dock_manager.perspectiveNames())
+        self.perspective_combobox.setCurrentText(perspective_name)
+
+    def closeEvent(self, event: QCloseEvent):
+        self.dock_manager.deleteLater()
+        super().closeEvent(event)
+
+
+if __name__ == '__main__':
+    app = QApplication(sys.argv)
+
+    w = MainWindow()
+    w.show()
+    app.exec_()

examples/autohidedragndrop/mainwindow.cpp

@@ -0,0 +1,131 @@
+#include "mainwindow.h"
+#include "droppableitem.h"
+
+#include "ui_mainwindow.h"
+
+#include <QWidgetAction>
+#include <QFileSystemModel>
+#include <QTableWidget>
+#include <QHBoxLayout>
+#include <QInputDialog>
+#include <QFileDialog>
+#include <QSettings>
+#include <QPlainTextEdit>
+#include <QToolBar>
+
+#include "AutoHideDockContainer.h"
+#include "DockAreaWidget.h"
+#include "DockAreaTitleBar.h"
+
+using namespace ads;
+
+CMainWindow::CMainWindow(QWidget *parent)
+    : QMainWindow(parent)
+    , ui(new Ui::CMainWindow)
+{
+    ui->setupUi(this);
+    CDockManager::setConfigFlag(CDockManager::OpaqueSplitterResize, true);
+    CDockManager::setConfigFlag(CDockManager::XmlCompressionEnabled, false);
+    CDockManager::setConfigFlag(CDockManager::FocusHighlighting, true);
+    CDockManager::setAutoHideConfigFlags(CDockManager::DefaultAutoHideConfig);
+    CDockManager::setAutoHideConfigFlag(CDockManager::AutoHideOpenOnDragHover, true);
+    CDockManager::setConfigParam(CDockManager::AutoHideOpenOnDragHoverDelay_ms, 500);
+    DockManager = new CDockManager(this);
+
+    // Set central widget
+    QPlainTextEdit* w = new QPlainTextEdit();
+	w->setPlaceholderText("This is the central editor. Enter your text here.");
+    CDockWidget* CentralDockWidget = new CDockWidget("CentralWidget");
+    CentralDockWidget->setWidget(w);
+    auto* CentralDockArea = DockManager->setCentralWidget(CentralDockWidget);
+    CentralDockArea->setAllowedAreas(DockWidgetArea::OuterDockAreas);
+
+    {
+    	DroppableItem* droppableItem = new DroppableItem("Drop text here.");
+		CDockWidget* dropDockWidget = new CDockWidget("Tab 1");
+		dropDockWidget->setWidget(droppableItem);
+		dropDockWidget->setMinimumSizeHintMode(CDockWidget::MinimumSizeHintFromDockWidget);
+		dropDockWidget->setMinimumSize(200,150);
+		dropDockWidget->setAcceptDrops(true);
+		const auto autoHideContainer = DockManager->addAutoHideDockWidget(SideBarLocation::SideBarLeft, dropDockWidget);
+		autoHideContainer->setSize(480);
+		autoHideContainer->setAcceptDrops(true);
+		ui->menuView->addAction(dropDockWidget->toggleViewAction());
+    }
+    {
+    	DroppableItem* droppableItem = new DroppableItem("Drop text here.");
+		CDockWidget* dropDockWidget = new CDockWidget("Tab 2");
+		dropDockWidget->setWidget(droppableItem);
+		dropDockWidget->setMinimumSizeHintMode(CDockWidget::MinimumSizeHintFromDockWidget);
+		dropDockWidget->setMinimumSize(200,150);
+		dropDockWidget->setAcceptDrops(true);
+		const auto autoHideContainer = DockManager->addAutoHideDockWidget(SideBarLocation::SideBarRight, dropDockWidget);
+		autoHideContainer->setSize(480);
+		autoHideContainer->setAcceptDrops(true);
+		ui->menuView->addAction(dropDockWidget->toggleViewAction());
+    }
+
+    QTableWidget* propertiesTable = new QTableWidget();
+    propertiesTable->setColumnCount(3);
+    propertiesTable->setRowCount(10);
+    CDockWidget* PropertiesDockWidget = new CDockWidget("Properties");
+    PropertiesDockWidget->setWidget(propertiesTable);
+    PropertiesDockWidget->setMinimumSizeHintMode(CDockWidget::MinimumSizeHintFromDockWidget);
+    PropertiesDockWidget->resize(250, 150);
+    PropertiesDockWidget->setMinimumSize(200,150);
+    DockManager->addDockWidget(DockWidgetArea::RightDockWidgetArea, PropertiesDockWidget, CentralDockArea);
+    ui->menuView->addAction(PropertiesDockWidget->toggleViewAction());
+
+    createPerspectiveUi();
+}
+
+CMainWindow::~CMainWindow()
+{
+    delete ui;
+}
+
+
+void CMainWindow::createPerspectiveUi()
+{
+	SavePerspectiveAction = new QAction("Create Perspective", this);
+	connect(SavePerspectiveAction, SIGNAL(triggered()), SLOT(savePerspective()));
+	PerspectiveListAction = new QWidgetAction(this);
+	PerspectiveComboBox = new QComboBox(this);
+	PerspectiveComboBox->setSizeAdjustPolicy(QComboBox::AdjustToContents);
+	PerspectiveComboBox->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
+	connect(PerspectiveComboBox, SIGNAL(currentTextChanged(const QString&)),
+		DockManager, SLOT(openPerspective(const QString&)));
+	PerspectiveListAction->setDefaultWidget(PerspectiveComboBox);
+	ui->toolBar->addSeparator();
+	ui->toolBar->addAction(PerspectiveListAction);
+	ui->toolBar->addAction(SavePerspectiveAction);
+}
+
+
+void CMainWindow::savePerspective()
+{
+	QString PerspectiveName = QInputDialog::getText(this, "Save Perspective", "Enter unique name:");
+	if (PerspectiveName.isEmpty())
+	{
+		return;
+	}
+
+	DockManager->addPerspective(PerspectiveName);
+	QSignalBlocker Blocker(PerspectiveComboBox);
+	PerspectiveComboBox->clear();
+	PerspectiveComboBox->addItems(DockManager->perspectiveNames());
+	PerspectiveComboBox->setCurrentText(PerspectiveName);
+}
+
+
+//============================================================================
+void CMainWindow::closeEvent(QCloseEvent* event)
+{
+    // Delete dock manager here to delete all floating widgets. This ensures
+    // that all top level windows of the dock manager are properly closed
+    DockManager->deleteLater();
+	QMainWindow::closeEvent(event);
+}
+
+
+

examples/autohidedragndrop/mainwindow.h

@@ -0,0 +1,43 @@
+#ifndef MAINWINDOW_H
+#define MAINWINDOW_H
+
+#include <QMainWindow>
+#include <QComboBox>
+#include <QWidgetAction>
+
+#include "DockManager.h"
+#include "DockAreaWidget.h"
+#include "DockWidget.h"
+
+QT_BEGIN_NAMESPACE
+namespace Ui { class CMainWindow; }
+QT_END_NAMESPACE
+
+class CMainWindow : public QMainWindow
+{
+    Q_OBJECT
+
+public:
+    CMainWindow(QWidget *parent = nullptr);
+    ~CMainWindow();
+
+protected:
+	virtual void closeEvent(QCloseEvent* event) override;
+
+private:
+	QAction* SavePerspectiveAction = nullptr;
+	QWidgetAction* PerspectiveListAction = nullptr;
+	QComboBox* PerspectiveComboBox = nullptr;
+
+    Ui::CMainWindow *ui;
+
+    ads::CDockManager* DockManager;
+    ads::CDockAreaWidget* StatusDockArea;
+    ads::CDockWidget* TimelineDockWidget;
+
+    void createPerspectiveUi();
+
+private slots:
+	void savePerspective();
+};
+#endif // MAINWINDOW_H

examples/autohidedragndrop/mainwindow.ui

@@ -0,0 +1,47 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>CMainWindow</class>
+ <widget class="QMainWindow" name="CMainWindow">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>1284</width>
+    <height>757</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>MainWindow</string>
+  </property>
+  <widget class="QWidget" name="centralwidget"/>
+  <widget class="QMenuBar" name="menubar">
+   <property name="geometry">
+    <rect>
+     <x>0</x>
+     <y>0</y>
+     <width>1284</width>
+     <height>21</height>
+    </rect>
+   </property>
+   <widget class="QMenu" name="menuView">
+    <property name="title">
+     <string>View</string>
+    </property>
+   </widget>
+   <addaction name="menuView"/>
+  </widget>
+  <widget class="QToolBar" name="toolBar">
+   <property name="windowTitle">
+    <string>toolBar</string>
+   </property>
+   <attribute name="toolBarArea">
+    <enum>TopToolBarArea</enum>
+   </attribute>
+   <attribute name="toolBarBreak">
+    <bool>false</bool>
+   </attribute>
+  </widget>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

examples/configflags/CMakeLists.txt

@@ -0,0 +1,28 @@
+cmake_minimum_required(VERSION 3.5)
+project(ads_example_centralwidget VERSION ${VERSION_SHORT}) 
+find_package(QT NAMES Qt6 Qt5 COMPONENTS Core REQUIRED)
+find_package(Qt${QT_VERSION_MAJOR} 5.5 COMPONENTS Core Gui Widgets REQUIRED)
+set(CMAKE_INCLUDE_CURRENT_DIR ON)
+add_executable(configFlagsExample WIN32 
+    main.cpp
+    mainwindow.cpp
+    mainwindow.ui
+)
+target_include_directories(CentralWidgetExample PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/../../src")
+target_link_libraries(CentralWidgetExample PRIVATE qt${QT_VERSION_MAJOR}advanceddocking)
+target_link_libraries(CentralWidgetExample PUBLIC Qt${QT_VERSION_MAJOR}::Core 
+                                                  Qt${QT_VERSION_MAJOR}::Gui 
+                                                  Qt${QT_VERSION_MAJOR}::Widgets)
+set_target_properties(CentralWidgetExample PROPERTIES 
+    AUTOMOC ON
+    AUTORCC ON
+    AUTOUIC ON
+    CXX_STANDARD 14
+    CXX_STANDARD_REQUIRED ON
+    CXX_EXTENSIONS OFF
+    VERSION ${VERSION_SHORT}
+    EXPORT_NAME "Qt Advanced Docking System Central Widget Example"
+    ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/${ads_PlatformDir}/lib"
+    LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/${ads_PlatformDir}/lib"
+    RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/${ads_PlatformDir}/bin"
+)

examples/configflags/configflags.pro

@@ -0,0 +1,34 @@
+ADS_OUT_ROOT = $${OUT_PWD}/../..
+
+QT       += core gui widgets
+
+TARGET = ConfigFlagsExample
+DESTDIR = $${ADS_OUT_ROOT}/lib
+TEMPLATE = app
+CONFIG += c++14
+CONFIG += debug_and_release
+adsBuildStatic {
+    DEFINES += ADS_STATIC
+}
+
+# The following define makes your compiler emit warnings if you use
+# any Qt feature that has been marked deprecated (the exact warnings
+# depend on your compiler). Please consult the documentation of the
+# deprecated API in order to know how to port your code away from it.
+DEFINES += QT_DEPRECATED_WARNINGS
+
+SOURCES += \
+    main.cpp \
+    mainwindow.cpp
+
+HEADERS += \
+    mainwindow.h
+
+FORMS += \
+    mainwindow.ui
+
+LIBS += -L$${ADS_OUT_ROOT}/lib
+include(../../ads.pri)
+INCLUDEPATH += ../../src
+DEPENDPATH += ../../src
+

examples/configflags/main.cpp

@@ -0,0 +1,10 @@
+#include <mainwindow.h>
+#include <QApplication>
+
+int main(int argc, char *argv[])
+{
+    QApplication a(argc, argv);
+    CMainWindow w;
+    w.show();
+    return a.exec();
+}

examples/configflags/mainwindow.cpp

@@ -0,0 +1,65 @@
+#include "mainwindow.h"
+
+#include "ui_mainwindow.h"
+
+#include <QLabel>
+#include <QToolBar>
+
+#include "DockAreaWidget.h"
+#include "DockAreaTitleBar.h"
+
+
+using namespace ads;
+
+
+CMainWindow::CMainWindow(QWidget *parent) :
+	QMainWindow(parent),
+	ui(new Ui::CMainWindow)
+{
+	ui->setupUi(this);
+
+	// Add the toolbar
+	auto toolbar_ = addToolBar("Top Toolbar");
+
+	// Create the dock manager
+	ads::CDockManager::setConfigFlags(ads::CDockManager::DefaultOpaqueConfig);
+	ads::CDockManager::setConfigFlag(ads::CDockManager::DockAreaHasCloseButton,
+	    false);
+	ads::CDockManager::setConfigFlag(ads::CDockManager::DockAreaHasUndockButton,
+	    false);
+	ads::CDockManager::setConfigFlag(
+	    ads::CDockManager::DockAreaHasTabsMenuButton, false);
+	auto DockManager = new ads::CDockManager(this);
+
+	// Create a dockable widget
+	QLabel *l1 = new QLabel();
+	l1->setWordWrap(true);
+	l1->setAlignment(Qt::AlignTop | Qt::AlignLeft);
+	l1->setText("Docking widget 1");
+	ads::CDockWidget *dockWidget1 = new ads::CDockWidget("Dock 1");
+	dockWidget1->setWidget(l1);
+	DockManager->addDockWidget(ads::LeftDockWidgetArea, dockWidget1);
+
+	QLabel *l2 = new QLabel();
+	l2->setWordWrap(true);
+	l2->setAlignment(Qt::AlignTop | Qt::AlignLeft);
+	l2->setText("Docking widget 2");
+	ads::CDockWidget *dockWidget2 = new ads::CDockWidget("Dock 2");
+	dockWidget2->setWidget(l2);
+	DockManager->addDockWidget(ads::RightDockWidgetArea, dockWidget2);
+
+	// Add menu actions
+	ui->menuView->addAction(dockWidget1->toggleViewAction());
+	ui->menuView->addAction(dockWidget2->toggleViewAction());
+	toolbar_->addAction(dockWidget1->toggleViewAction());
+	toolbar_->addAction(dockWidget2->toggleViewAction());
+}
+
+
+CMainWindow::~CMainWindow()
+{
+    delete ui;
+}
+
+
+

examples/configflags/mainwindow.h

@@ -0,0 +1,27 @@
+#ifndef MAINWINDOW_H
+#define MAINWINDOW_H
+
+#include <QMainWindow>
+#include <QComboBox>
+#include <QWidgetAction>
+
+#include "DockManager.h"
+#include "DockAreaWidget.h"
+#include "DockWidget.h"
+
+QT_BEGIN_NAMESPACE
+namespace Ui { class CMainWindow; }
+QT_END_NAMESPACE
+
+class CMainWindow : public QMainWindow
+{
+    Q_OBJECT
+
+public:
+    CMainWindow(QWidget *parent = nullptr);
+    ~CMainWindow();
+
+private:
+    Ui::CMainWindow *ui;
+};
+#endif // MAINWINDOW_H

examples/configflags/mainwindow.ui

@@ -0,0 +1,47 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>CMainWindow</class>
+ <widget class="QMainWindow" name="CMainWindow">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>1284</width>
+    <height>757</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>MainWindow</string>
+  </property>
+  <widget class="QWidget" name="centralwidget"/>
+  <widget class="QMenuBar" name="menubar">
+   <property name="geometry">
+    <rect>
+     <x>0</x>
+     <y>0</y>
+     <width>1284</width>
+     <height>21</height>
+    </rect>
+   </property>
+   <widget class="QMenu" name="menuView">
+    <property name="title">
+     <string>View</string>
+    </property>
+   </widget>
+   <addaction name="menuView"/>
+  </widget>
+  <widget class="QToolBar" name="toolBar">
+   <property name="windowTitle">
+    <string>toolBar</string>
+   </property>
+   <attribute name="toolBarArea">
+    <enum>TopToolBarArea</enum>
+   </attribute>
+   <attribute name="toolBarBreak">
+    <bool>false</bool>
+   </attribute>
+  </widget>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

examples/examples.pro

@@ -2,10 +2,12 @@ TEMPLATE = subdirs
 
 SUBDIRS = \
     autohide \
+	autohidedragndrop \
     centralwidget \
 	simple \
 	hideshow \
 	sidebar \
 	deleteonclose \
 	emptydockarea \
-	dockindock
+	dockindock \
+	configflags

sip/DockAreaTitleBar.sip

@@ -12,10 +12,14 @@ class CTitleBarButton : QToolButton
     %End
     
 public:
-	CTitleBarButton(bool visible = true, QWidget* parent /TransferThis/ = Q_NULLPTR );
+	CTitleBarButton(bool ShowInTitleBar, bool HideWhenDisabled, TitleBarButton ButtonId,
+		QWidget* /TransferThis/ = Q_NULLPTR );
 	virtual void setVisible(bool);
 	void setShowInTitleBar(bool);
 
+    TitleBarButton buttonId() const;
+	ads::CDockAreaTitleBar* titleBar() const;
+    bool isInAutoHideArea() const;
 
 protected:
 	bool event(QEvent *ev);
@@ -44,13 +48,15 @@ public:
 	ads::CDockAreaTabBar* tabBar() const;
 	ads::CTitleBarButton* button(ads::TitleBarButton which) const;
     ads::CElidingLabel* autoHideTitleLabel() const;
+    ads::CDockAreaWidget* dockAreaWidget() const;
  	void updateDockWidgetActionsButtons();
 	virtual void setVisible(bool Visible);
 	void insertWidget(int index, QWidget *widget /Transfer/ );
 	int indexOf(QWidget *widget) const;
     QString titleBarButtonToolTip(ads::TitleBarButton Button) const;
     void setAreaFloating();
-    
+    void showAutoHideControls(bool Show);
+    bool isAutoHide() const;
 
 signals:
 	void tabBarClicked(int index);

sip/DockAreaWidget.sip

@@ -41,6 +41,7 @@ public:
 	ads::CDockManager* dockManager() const;
 	ads::CDockContainerWidget* dockContainer() const;
     ads::CAutoHideDockContainer* autoHideDockContainer() const;
+    ads::CDockSplitter* parentSplitter() const;
     bool isAutoHide() const;
     void setAutoHideDockContainer(CAutoHideDockContainer*);
 	virtual QSize minimumSizeHint() const;

sip/DockContainerWidget.sip

@@ -20,13 +20,14 @@ class CDockContainerWidget : QFrame
 
 protected:
 	virtual bool event(QEvent *e);
-	QSplitter* rootSplitter() const;
+	ads::CDockSplitter* rootSplitter() const;
     ads::CAutoHideDockContainer* createAndSetupAutoHideContainer(ads::SideBarLocation area, ads::CDockWidget* DockWidget /Transfer/, int TabIndex = -1);
 	void createRootSplitter();
 	void dropFloatingWidget(ads::CFloatingDockContainer* FloatingWidget, const QPoint& TargetPos);
     void dropWidget(QWidget* Widget, DockWidgetArea DropArea, CDockAreaWidget* TargetAreaWidget, int TabIndex = -1);
 	void addDockArea(ads::CDockAreaWidget* DockAreaWidget /Transfer/, ads::DockWidgetArea area = ads::CenterDockWidgetArea);
 	void removeDockArea(ads::CDockAreaWidget* area /TransferBack/);
+    /*QList<QPointer<ads::CDockAreaWidget>> removeAllDockAreas();*/
 	void saveState(QXmlStreamWriter& Stream) const;
 	bool restoreState(CDockingStateReader& Stream, bool Testing);
 	ads::CDockAreaWidget* lastAddedDockAreaWidget(ads::DockWidgetArea area) const;

sip/DockManager.sip

@@ -172,6 +172,8 @@ public:
         FloatingContainerForceNativeTitleBar,
         FloatingContainerForceQWidgetTitleBar,
         MiddleMouseButtonClosesTab,
+        DisableTabTextEliding,
+        ShowTabTextOnlyForActiveTab,
         DefaultDockAreaButtons,
 		DefaultBaseConfig,
         DefaultOpaqueConfig,
@@ -188,6 +190,8 @@ public:
 		AutoHideSideBarsIconOnly,
 		AutoHideShowOnMouseOver,
         AutoHideCloseButtonCollapsesDock,
+        AutoHideHasCloseButton,
+        AutoHideHasMinimizeButton,
 		DefaultAutoHideConfig,
 	};
     typedef QFlags<ads::CDockManager::eAutoHideFlag> AutoHideFlags;
@@ -245,6 +249,12 @@ public:
     void setSplitterSizes(ads::CDockAreaWidget *ContainedArea, const QList<int>& sizes);
     static void setFloatingContainersTitle(const QString& Title);
 	static QString floatingContainersTitle();
+    void setDockWidgetToolBarStyle(Qt::ToolButtonStyle Style, ads::CDockWidget::eState State);
+    Qt::ToolButtonStyle dockWidgetToolBarStyle(ads::CDockWidget::eState State) const;
+    void setDockWidgetToolBarIconSize(const QSize& IconSize, ads::CDockWidget::eState State);
+    QSize dockWidgetToolBarIconSize(ads::CDockWidget::eState State) const;
+    ads::CDockWidget::DockWidgetFeatures globallyLockedDockWidgetFeatures() const;
+    void lockDockWidgetFeaturesGlobally(ads::CDockWidget::DockWidgetFeatures Features = ads::CDockWidget::GloballyLockableFeatures);
 
 public slots:
     void endLeavingMinimizedState();

sip/DockWidget.sip

@@ -39,6 +39,7 @@ public:
         DefaultDockWidgetFeatures,
         AllDockWidgetFeatures,
         DockWidgetAlwaysCloseAndDelete,
+        GloballyLockableFeatures,
 		NoDockWidgetFeatures
 	};
     typedef QFlags<ads::CDockWidget::DockWidgetFeature> DockWidgetFeatures;
@@ -50,6 +51,12 @@ public:
 		StateFloating
 	};
     
+    enum eToolBarStyleSource
+    {
+    	ToolBarStyleFromDockManager,
+    	ToolBarStyleFromDockWidget
+    };
+
 	enum eInsertMode
 	{
 		AutoScrollArea,
@@ -72,7 +79,7 @@ public:
 	};
 
 
-	CDockWidget(const QString &title, QWidget* parent /TransferThis/ = 0);
+	CDockWidget(const QString &title, QWidget* parent /TransferThis/ = Q_NULLPTR);
 	virtual ~CDockWidget();
 	virtual QSize minimumSizeHint() const;
 	void setWidget(QWidget* widget /Transfer/, ads::CDockWidget::eInsertMode InsertMode = AutoScrollArea);
@@ -82,6 +89,7 @@ public:
 	void setFeatures(ads::CDockWidget::DockWidgetFeatures features);
 	void setFeature(ads::CDockWidget::DockWidgetFeature flag, bool on);
 	ads::CDockWidget::DockWidgetFeatures features() const;
+    void notifyFeaturesChanged();
 	ads::CDockManager* dockManager() const;
 	ads::CDockContainerWidget* dockContainer() const;
     ads::CFloatingDockContainer* floatingDockContainer() const;
@@ -95,6 +103,7 @@ public:
 	bool isInFloatingContainer() const;
 	bool isClosed() const;
 	QAction* toggleViewAction() const;
+    void setToggleViewAction(QAction* action);
 	void setToggleViewActionMode(ads::CDockWidget::eToggleViewActionMode Mode);
 	void setMinimumSizeHintMode(ads::CDockWidget::eMinimumSizeHintMode Mode);
     ads::CDockWidget::eMinimumSizeHintMode minimumSizeHintMode() const;
@@ -104,6 +113,8 @@ public:
 	QToolBar* toolBar() const;
 	QToolBar* createDefaultToolBar();
 	void setToolBar(QToolBar* ToolBar /Transfer/ );
+    void setToolBarStyleSource(ads::CDockWidget::eToolBarStyleSource Source);
+    ads::CDockWidget::eToolBarStyleSource toolBarStyleSource() const;
 	void setToolBarStyle(Qt::ToolButtonStyle Style, ads::CDockWidget::eState State);
 	Qt::ToolButtonStyle toolBarStyle(ads::CDockWidget::eState State) const;
 	void setToolBarIconSize(const QSize& IconSize, ads::CDockWidget::eState State);

sip/ElidingLabel.sip

@@ -17,8 +17,8 @@ protected:
     virtual void mouseDoubleClickEvent( QMouseEvent *ev );
     
 public:
-	CElidingLabel(QWidget* parent /TransferThis/ = 0, Qt::WindowFlags f = 0);
+	CElidingLabel(QWidget* parent /TransferThis/ = Q_NULLPTR, Qt::WindowFlags f = Qt::WindowFlags ());
-	CElidingLabel(const QString& text, QWidget* parent /TransferThis/ = 0, Qt::WindowFlags f = 0);
+	CElidingLabel(const QString& text, QWidget* parent /TransferThis/ = Q_NULLPTR, Qt::WindowFlags f = Qt::WindowFlags ());
 	virtual ~CElidingLabel();
 	Qt::TextElideMode elideMode() const;
 	void setElideMode(Qt::TextElideMode mode);

sip/FloatingDockContainer.sip

@@ -44,6 +44,7 @@ protected:
     void startDragging(const QPoint& DragStartMousePos, const QSize& Size,
         QWidget* MouseEventHandler);
 	virtual void finishDragging();
+    void deleteContent();
 	void initFloatingGeometry(const QPoint& DragStartMousePos, const QSize& Size);
 	void moveFloating();
 	bool restoreState(ads::CDockingStateReader& Stream, bool Testing);
@@ -82,6 +83,7 @@ public:
     bool hasTopLevelDockWidget() const;
     ads::CDockWidget* topLevelDockWidget() const;
     QList<ads::CDockWidget*> dockWidgets() const;
+    void finishDropOperation();
     
     %If (WS_X11)
     void onMaximizeRequest();

sip/ads_globals.sip

@@ -73,7 +73,8 @@ namespace ads
         TitleBarButtonTabsMenu,
         TitleBarButtonUndock,
         TitleBarButtonClose,
-        TitleBarButtonAutoHide
+        TitleBarButtonAutoHide,
+        TitleBarButtonMinimize
     };
 
     enum eDragState

src/AutoHideDockContainer.cpp

@@ -657,6 +657,14 @@ bool CAutoHideDockContainer::event(QEvent* event)
 	return Super::event(event);
 }
 
+//============================================================================
+void CAutoHideDockContainer::dragLeaveEvent(QDragLeaveEvent*)
+{
+    if (CDockManager::testAutoHideConfigFlag(CDockManager::AutoHideOpenOnDragHover))
+    {
+        collapseView(true);
+    }
+}
 
 //============================================================================
 Qt::Orientation CAutoHideDockContainer::orientation() const
@@ -709,4 +717,3 @@ int CAutoHideDockContainer::tabIndex() const
 }
 
 }
-

src/AutoHideDockContainer.h

@@ -65,6 +65,7 @@ protected:
 	virtual void resizeEvent(QResizeEvent* event) override;
 	virtual void leaveEvent(QEvent *event) override;
 	virtual bool event(QEvent* event) override;
+    virtual void dragLeaveEvent(QDragLeaveEvent* ev) override;
 
 	/**
 	 * Updates the size considering the size limits and the resize margins

src/AutoHideSideBar.cpp

@@ -414,7 +414,14 @@ void CAutoHideSideBar::saveState(QXmlStreamWriter& s) const
 QSize CAutoHideSideBar::minimumSizeHint() const
 {
 	QSize Size = sizeHint();
-	Size.setWidth(10);
+	if (d->isHorizontal())
+	{
+		Size.setWidth(0);
+	}
+	else
+	{
+		Size.setHeight(0);
+	}
 	return Size;
 }
 

src/AutoHideTab.cpp

@@ -33,6 +33,8 @@
 #include <QApplication>
 #include <QElapsedTimer>
 #include <QMenu>
+#include <QEvent>
+#include <QTimer>
 
 #include "AutoHideDockContainer.h"
 #include "AutoHideSideBar.h"
@@ -41,6 +43,7 @@
 #include "DockWidget.h"
 #include "FloatingDragPreview.h"
 #include "DockOverlay.h"
+#include "ads_globals.h"
 
 namespace ads
 {
@@ -55,6 +58,7 @@ struct AutoHideTabPrivate
     CAutoHideSideBar* SideBar = nullptr;
 	Qt::Orientation Orientation{Qt::Vertical};
 	QElapsedTimer TimeSinceHoverMousePress;
+	QTimer DragOverTimer;
 	bool MousePressed = false;
 	eDragState DragState = DraggingInactive;
 	QPoint GlobalDragStartMousePosition;
@@ -252,6 +256,14 @@ CAutoHideTab::CAutoHideTab(QWidget* parent) :
 {
 	setAttribute(Qt::WA_NoMousePropagation);
 	setFocusPolicy(Qt::NoFocus);
+    if (CDockManager::testAutoHideConfigFlag(CDockManager::AutoHideOpenOnDragHover)) {
+        setAcceptDrops(true);
+    }
+
+    d->DragOverTimer.setInterval(CDockManager::configParam(
+    	CDockManager::AutoHideOpenOnDragHoverDelay_ms, 500).toInt());
+    d->DragOverTimer.setSingleShot(true);
+	connect(&d->DragOverTimer, &QTimer::timeout, this, &CAutoHideTab::onDragHoverDelayExpired);
 }
 
 
@@ -355,7 +367,6 @@ bool CAutoHideTab::event(QEvent* event)
 	case QEvent::Leave:
 		 d->forwardEventToDockContainer(event);
 		 break;
-
 	default:
 		break;
 	}
@@ -493,48 +504,74 @@ void CAutoHideTab::mouseReleaseEvent(QMouseEvent* ev)
 
 
 //============================================================================
-void CAutoHideTab::mouseMoveEvent(QMouseEvent* ev)
+void CAutoHideTab::mouseMoveEvent(QMouseEvent *ev)
 {
-    if (!(ev->buttons() & Qt::LeftButton) || d->isDraggingState(DraggingInactive))
+	if (!(ev->buttons() & Qt::LeftButton)
-    {
+	    || d->isDraggingState(DraggingInactive))
-    	d->DragState = DraggingInactive;
-        Super::mouseMoveEvent(ev);
-        return;
-    }
-
-    // move floating window
-    if (d->isDraggingState(DraggingFloatingWidget))
-    {
-        d->FloatingWidget->moveFloating();
-        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);
-    }
-
-    auto MappedPos = mapToParent(ev->pos());
-    bool MouseOutsideBar = (MappedPos.x() < 0) || (MappedPos.x() > parentWidget()->rect().right());
-    // Maybe a fixed drag distance is better here ?
-    int DragDistanceY = qAbs(d->GlobalDragStartMousePosition.y() - internal::globalPositionOf(ev).y());
-    if (DragDistanceY >= CDockManager::startDragDistance() || MouseOutsideBar)
 	{
-    	// Floating is only allowed for widgets that are floatable
+		d->DragState = DraggingInactive;
-		// We can create the drag preview if the widget is movable.
+		Super::mouseMoveEvent(ev);
-		auto Features = d->DockWidget->features();
+		return;
-        if (Features.testFlag(CDockWidget::DockWidgetFloatable) || (Features.testFlag(CDockWidget::DockWidgetMovable)))
-        {
-            d->startFloating();
-        }
-    	return;
 	}
 
-    Super::mouseMoveEvent(ev);
+	// move floating window
+	if (d->isDraggingState(DraggingFloatingWidget))
+	{
+		d->FloatingWidget->moveFloating();
+		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);
+	}
+
+	auto MappedPos = mapToParent(ev->pos());
+	bool MouseOutsideBar = (MappedPos.x() < 0)
+	    || (MappedPos.x() > parentWidget()->rect().right());
+	// Maybe a fixed drag distance is better here ?
+	int DragDistanceY = qAbs(
+	    d->GlobalDragStartMousePosition.y()
+	        - internal::globalPositionOf(ev).y());
+	if (DragDistanceY >= CDockManager::startDragDistance() || MouseOutsideBar)
+	{
+		// Floating is only allowed for widgets that are floatable
+		// We can create the drag preview if the widget is movable.
+		auto Features = d->DockWidget->features();
+		if (Features.testFlag(CDockWidget::DockWidgetFloatable)
+		    || (Features.testFlag(CDockWidget::DockWidgetMovable)))
+		{
+			d->startFloating();
+		}
+		return;
+	}
+
+	Super::mouseMoveEvent(ev);
+}
+
+//============================================================================
+void CAutoHideTab::dragEnterEvent(QDragEnterEvent *ev)
+{
+	Q_UNUSED(ev);
+	if (CDockManager::testAutoHideConfigFlag(CDockManager::AutoHideOpenOnDragHover))
+	{
+		d->DragOverTimer.start();
+		ev->accept();
+	}
+}
+
+//============================================================================
+void CAutoHideTab::dragLeaveEvent(QDragLeaveEvent *ev)
+{
+	Q_UNUSED(ev);
+	if (CDockManager::testAutoHideConfigFlag(CDockManager::AutoHideOpenOnDragHover))
+	{
+		d->DragOverTimer.stop();
+	}
 }
 
 
@@ -544,7 +581,6 @@ void CAutoHideTab::requestCloseDockWidget()
 	d->DockWidget->requestCloseDockWidget();
 }
 
-
 //============================================================================
 int CAutoHideTab::tabIndex() const
 {
@@ -557,4 +593,28 @@ int CAutoHideTab::tabIndex() const
 }
 
 
+//============================================================================
+void CAutoHideTab::onDragHoverDelayExpired()
+{
+	static const char* const PropertyId = "ActiveDragOverAutoHideContainer";
+
+	// First we check if there is an active auto hide container that is visible
+	// In this case, we collapse it before we open the new one
+	auto v = d->DockWidget->dockManager()->property(PropertyId);
+	if (v.isValid())
+	{
+		auto ActiveAutoHideContainer = v.value<QPointer<CAutoHideDockContainer>>();
+		if (ActiveAutoHideContainer)
+		{
+			ActiveAutoHideContainer->collapseView(true);
+		}
+	}
+
+	auto AutoHideContainer = d->DockWidget->autoHideDockContainer();
+	AutoHideContainer->collapseView(false);
+	d->DockWidget->dockManager()->setProperty(PropertyId,
+        QVariant::fromValue(QPointer<CAutoHideDockContainer>(AutoHideContainer)));
+}
+
+
 }

src/AutoHideTab.h

@@ -67,6 +67,7 @@ private:
 
 private Q_SLOTS:
 	void onAutoHideToActionClicked();
+	void onDragHoverDelayExpired();
 
 protected:
 	void setSideBar(CAutoHideSideBar *SideTabBar);
@@ -76,6 +77,8 @@ protected:
 	virtual void mousePressEvent(QMouseEvent* ev) override;
 	virtual void mouseReleaseEvent(QMouseEvent* ev) override;
 	virtual void mouseMoveEvent(QMouseEvent* ev) override;
+    virtual void dragEnterEvent(QDragEnterEvent* ev) override;
+    virtual void dragLeaveEvent(QDragLeaveEvent* ev) override;
 
 public:
     using Super = CPushButton;

src/CMakeLists.txt

@@ -1,5 +1,6 @@
 cmake_minimum_required(VERSION 3.5)
 project(QtAdvancedDockingSystem LANGUAGES CXX VERSION ${VERSION_SHORT})
+include(GNUInstallDirs)
 if (${QT_VERSION_MAJOR})
   message(STATUS "Forced to use Qt version ${QT_VERSION_MAJOR}")
   find_package(QT NAMES Qt${QT_VERSION_MAJOR} COMPONENTS Core REQUIRED)

src/DockAreaTabBar.cpp

@@ -111,7 +111,7 @@ void DockAreaTabBarPrivate::updateTabs()
 			// Sometimes the synchronous calculation of the rectangular area fails
 			// Therefore we use QTimer::singleShot here to execute the call
 			// within the event loop - see #520
-			QTimer::singleShot(0, TabWidget, [&, TabWidget]
+			QTimer::singleShot(0, _this, [&, TabWidget]
 			{
 				_this->ensureWidgetVisible(TabWidget);
 			});
@@ -161,15 +161,13 @@ CDockAreaTabBar::~CDockAreaTabBar()
 void CDockAreaTabBar::wheelEvent(QWheelEvent* Event)
 {
 	Event->accept();
-	const int direction = Event->angleDelta().y();
+    int numPixels = Event->pixelDelta().y();
-	if (direction < 0)
+    if (!numPixels)
-	{
+    {
-		horizontalScrollBar()->setValue(horizontalScrollBar()->value() + 20);
+    	numPixels = Event->angleDelta().y() / 5;
-	}
+    }
-	else
+
-	{
+	horizontalScrollBar()->setValue(horizontalScrollBar()->value() - numPixels);
-		horizontalScrollBar()->setValue(horizontalScrollBar()->value() - 20);
-	}
 }
 
 
@@ -390,15 +388,18 @@ void CDockAreaTabBar::onTabWidgetMoved(const QPoint& GlobalPos)
 
 	int fromIndex = d->TabsLayout->indexOf(MovingTab);
 	auto MousePos = mapFromGlobal(GlobalPos);
-	MousePos.rx() = qMax(d->firstTab()->geometry().left(), MousePos.x());
+	MousePos.rx() = qMax(0, MousePos.x());
-	MousePos.rx() = qMin(d->lastTab()->geometry().right(), MousePos.x());
+	MousePos.rx() = qMin(width(), MousePos.x());
 	int toIndex = -1;
 	// Find tab under mouse
 	for (int i = 0; i < count(); ++i)
 	{
 		CDockWidgetTab* DropTab = tab(i);
+		auto TabGeometry = DropTab->geometry();
+		TabGeometry.setTopLeft(d->TabsContainerWidget->mapToParent(TabGeometry.topLeft()));
+		TabGeometry.setBottomRight(d->TabsContainerWidget->mapToParent(TabGeometry.bottomRight()));
 		if (DropTab == MovingTab || !DropTab->isVisibleTo(this)
-		    || !DropTab->geometry().contains(MousePos))
+		    || !TabGeometry.contains(MousePos))
 		{
 			continue;
 		}
@@ -470,6 +471,15 @@ bool CDockAreaTabBar::eventFilter(QObject *watched, QEvent *event)
          updateGeometry();
          break;
 
+    // Manage wheel event
+    case QEvent::Wheel:
+    	// Ignore wheel events if tab is currently dragged
+    	if (Tab->dragState() == DraggingInactive)
+    	{
+    		wheelEvent((QWheelEvent* )event);
+    	}
+        break;
+
 	default:
 		break;
 	}
@@ -545,6 +555,13 @@ int CDockAreaTabBar::tabInsertIndexAt(const QPoint& Pos) const
 	}
 }
 
+
+//===========================================================================
+bool CDockAreaTabBar::areTabsOverflowing() const
+{
+	return d->TabsContainerWidget->width() > width();
+}
+
 } // namespace ads
 
 

src/DockAreaTabBar.h

@@ -153,6 +153,12 @@ public:
 	 */
 	virtual QSize sizeHint() const override;
 
+	/**
+	 * This function returns true, if the tabs need more space than the size
+	 * of the tab bar.
+	 */
+	bool areTabsOverflowing() const;
+
 public Q_SLOTS:
 	/**
 	 * This property sets the index of the tab bar's visible tab

src/DockAreaTitleBar.cpp

@@ -377,27 +377,48 @@ CDockAreaTabBar* CDockAreaTitleBar::tabBar() const
 	return d->TabBar;
 }
 
+
+//============================================================================
+void CDockAreaTitleBar::resizeEvent(QResizeEvent *event)
+{
+	Super::resizeEvent(event);
+	if (CDockManager::testConfigFlag(CDockManager::DockAreaDynamicTabsMenuButtonVisibility)
+	 && CDockManager::testConfigFlag(CDockManager::DisableTabTextEliding))
+	{
+		markTabsMenuOutdated();
+	}
+}
+
+
 //============================================================================
 void CDockAreaTitleBar::markTabsMenuOutdated()
 {
-	if(DockAreaTitleBarPrivate::testConfigFlag(CDockManager::DockAreaDynamicTabsMenuButtonVisibility))
+	if (CDockManager::testConfigFlag(CDockManager::DockAreaDynamicTabsMenuButtonVisibility))
 	{
-		bool hasElidedTabTitle = false;
+		bool TabsMenuButtonVisible = false;
-		for (int i = 0; i < d->TabBar->count(); ++i)
+		if (CDockManager::testConfigFlag(CDockManager::DisableTabTextEliding))
 		{
-			if (!d->TabBar->isTabOpen(i))
+			TabsMenuButtonVisible = d->TabBar->areTabsOverflowing();
-			{
-				continue;
-			}
-			CDockWidgetTab* Tab = d->TabBar->tab(i);
-			if(Tab->isTitleElided())
-			{
-				hasElidedTabTitle = true;
-				break;
-			}
 		}
-		bool visible = (hasElidedTabTitle && (d->TabBar->count() > 1));
+		else
-		QMetaObject::invokeMethod(d->TabsMenuButton, "setVisible", Qt::QueuedConnection, Q_ARG(bool, visible));
+		{
+			bool hasElidedTabTitle = false;
+			for (int i = 0; i < d->TabBar->count(); ++i)
+			{
+				if (!d->TabBar->isTabOpen(i))
+				{
+					continue;
+				}
+				CDockWidgetTab* Tab = d->TabBar->tab(i);
+				if(Tab->isTitleElided())
+				{
+					hasElidedTabTitle = true;
+					break;
+				}
+			}
+			TabsMenuButtonVisible = (hasElidedTabTitle && (d->TabBar->count() > 1));
+		}
+		QMetaObject::invokeMethod(d->TabsMenuButton, "setVisible", Qt::QueuedConnection, Q_ARG(bool, TabsMenuButtonVisible));
 	}
 	d->MenuOutdated = true;
 }
@@ -744,24 +765,35 @@ void CDockAreaTitleBar::contextMenuEvent(QContextMenuEvent* ev)
 		return;
 	}
 
-	const bool isAutoHide = d->DockArea->isAutoHide();
+    auto Menu = buildContextMenu(nullptr);
+	Menu->exec(ev->globalPos());
+    delete Menu;
+}
+
+QMenu* CDockAreaTitleBar::buildContextMenu(QMenu *Menu)
+{
+    const bool isAutoHide = d->DockArea->isAutoHide();
 	const bool isTopLevelArea = d->DockArea->isTopLevelArea();
 	QAction* Action;
-	QMenu Menu(this);
+    if (Menu == nullptr)
-	if (!isTopLevelArea)
+    {
+        Menu = new QMenu(this);
+    }
+    
+    if (!isTopLevelArea)
 	{
-		Action = Menu.addAction(isAutoHide ? tr("Detach") : tr("Detach Group"),
+		Action = Menu->addAction(isAutoHide ? tr("Detach") : tr("Detach Group"),
 			this, SLOT(onUndockButtonClicked()));
 		Action->setEnabled(d->DockArea->features().testFlag(CDockWidget::DockWidgetFloatable));
 		if (CDockManager::testAutoHideConfigFlag(CDockManager::AutoHideFeatureEnabled))
 		{
-			Action = Menu.addAction(isAutoHide ? tr("Unpin (Dock)") : tr("Pin Group"), this, SLOT(onAutoHideDockAreaActionClicked()));
+			Action = Menu->addAction(isAutoHide ? tr("Unpin (Dock)") : tr("Pin Group"), this, SLOT(onAutoHideDockAreaActionClicked()));
 			auto AreaIsPinnable = d->DockArea->features().testFlag(CDockWidget::DockWidgetPinnable);
 			Action->setEnabled(AreaIsPinnable);
 
 			if (!isAutoHide)
 			{
-				auto menu = Menu.addMenu(tr("Pin Group To..."));
+				auto menu = Menu->addMenu(tr("Pin Group To..."));
 				menu->setEnabled(AreaIsPinnable);
 				d->createAutoHideToAction(tr("Top"), SideBarTop, menu);
 				d->createAutoHideToAction(tr("Left"), SideBarLeft, menu);
@@ -769,28 +801,27 @@ void CDockAreaTitleBar::contextMenuEvent(QContextMenuEvent* ev)
 				d->createAutoHideToAction(tr("Bottom"), SideBarBottom, menu);
 			}
 		}
-		Menu.addSeparator();
+		Menu->addSeparator();
 	}
 
 	if (isAutoHide)
 	{
-		Action = Menu.addAction(tr("Minimize"), this, SLOT(minimizeAutoHideContainer()));
+		Action = Menu->addAction(tr("Minimize"), this, SLOT(minimizeAutoHideContainer()));
-		Action = Menu.addAction(tr("Close"), this, SLOT(onAutoHideCloseActionTriggered()));
+		Action = Menu->addAction(tr("Close"), this, SLOT(onAutoHideCloseActionTriggered()));
 	}
 	else
 	{
-		Action = Menu.addAction(isAutoHide ? tr("Close") : tr("Close Group"), this, SLOT(onCloseButtonClicked()));
+		Action = Menu->addAction(isAutoHide ? tr("Close") : tr("Close Group"), this, SLOT(onCloseButtonClicked()));
 	}
 
 	Action->setEnabled(d->DockArea->features().testFlag(CDockWidget::DockWidgetClosable));
 	if (!isAutoHide && !isTopLevelArea)
 	{
-		Action = Menu.addAction(tr("Close Other Groups"), d->DockArea, SLOT(closeOtherAreas()));
+		Action = Menu->addAction(tr("Close Other Groups"), d->DockArea, SLOT(closeOtherAreas()));
 	}
-	Menu.exec(ev->globalPos());
+    return Menu;
 }
 
-
 //============================================================================
 void CDockAreaTitleBar::insertWidget(int index, QWidget *widget)
 {

src/DockAreaTitleBar.h

@@ -152,6 +152,11 @@ protected:
 	 */
 	virtual void contextMenuEvent(QContextMenuEvent *event) override;
 
+	/**
+	 * Handle resize events
+	 */
+	virtual void resizeEvent(QResizeEvent *event) override;
+
 public Q_SLOTS:
 	/**
 	 * Call this slot to tell the title bar that it should update the tabs menu
@@ -244,6 +249,20 @@ public:
 	 */
 	bool isAutoHide() const;
 
+    /**
+     * Fills the provided menu with standard entries. If a nullptr is passed, a
+     * new menu is created and filled with standard entries.
+     * This function is called from the actual version of contextMenuEvent, but
+     * can be called from any code. Caller is responsible of deleting the created
+     * object.
+     *
+     * @param menu The QMenu to fill with standard entries. If nullptr, a new
+     * QMenu will be created.
+     * @return The filled QMenu, either the provided one or a newly created one if
+     * nullptr was passed.
+     */
+    virtual QMenu *buildContextMenu(QMenu *);
+
 Q_SIGNALS:
 	/**
 	 * This signal is emitted if a tab in the tab bar is clicked by the user

src/DockAreaWidget.cpp

@@ -34,7 +34,6 @@
 
 #include <QStackedLayout>
 #include <QScrollBar>
-#include <QWheelEvent>
 #include <QStyle>
 #include <QPushButton>
 #include <QDebug>

src/DockAreaWidget.h

@@ -38,6 +38,7 @@
 
 QT_FORWARD_DECLARE_CLASS(QXmlStreamWriter)
 QT_FORWARD_DECLARE_CLASS(QAbstractButton)
+QT_FORWARD_DECLARE_CLASS(QMenu)
 
 namespace ads
 {

src/DockManager.cpp

@@ -48,6 +48,7 @@
 #include <QApplication>
 #include <QWindow>
 #include <QWindowStateChangeEvent>
+#include <QVector>
 
 #include "FloatingDockContainer.h"
 #include "DockOverlay.h"
@@ -94,6 +95,7 @@ enum eStateFileVersion
 
 static CDockManager::ConfigFlags StaticConfigFlags = CDockManager::DefaultNonOpaqueConfig;
 static CDockManager::AutoHideFlags StaticAutoHideConfigFlags; // auto hide feature is disabled by default
+static QVector<QVariant> StaticConfigParams(CDockManager::ConfigParamCount);
 
 static QString FloatingContainersTitle;
 
@@ -1475,6 +1477,20 @@ CDockWidget::DockWidgetFeatures CDockManager::globallyLockedDockWidgetFeatures()
 }
 
 
+//===========================================================================
+void CDockManager::setConfigParam(CDockManager::eConfigParam Param, QVariant Value)
+{
+	StaticConfigParams[Param] = Value;
+}
+
+
+//===========================================================================
+QVariant CDockManager::configParam(eConfigParam Param, QVariant Default)
+{
+	return StaticConfigParams[Param].isValid() ? StaticConfigParams[Param] : Default;
+}
+
+
 } // namespace ads
 
 //---------------------------------------------------------------------------

src/DockManager.h

@@ -254,6 +254,7 @@ public:
 		AutoHideCloseButtonCollapsesDock = 0x40, ///< Close button of an auto hide container collapses the dock instead of hiding it completely
 		AutoHideHasCloseButton = 0x80, //< If the flag is set an auto hide title bar has a close button
 		AutoHideHasMinimizeButton = 0x100, ///< if this flag is set, the auto hide title bar has a minimize button to collapse the dock widget
+        AutoHideOpenOnDragHover = 0x200,  ///< if this flag is set, dragging hover the tab bar will open the dock
 
 		DefaultAutoHideConfig = AutoHideFeatureEnabled
 			                  | DockAreaHasAutoHideButton
@@ -262,6 +263,15 @@ public:
 	};
     Q_DECLARE_FLAGS(AutoHideFlags, eAutoHideFlag)
 
+	/**
+	 * Global configuration parameters that you can set via setConfigParam()
+	 */
+	enum eConfigParam
+	{
+    	AutoHideOpenOnDragHoverDelay_ms, ///< Delay in ms before the dock opens on drag hover if AutoHideOpenOnDragHover flag is set
+    	ConfigParamCount // just a delimiter to count number of config params
+	};
+
 
 	/**
 	 * Default Constructor.
@@ -323,6 +333,17 @@ public:
 	 */
 	static bool testAutoHideConfigFlag(eAutoHideFlag Flag);
 
+	/**
+	 * Sets the value for the given config parameter
+	 */
+	static void setConfigParam(eConfigParam Param, QVariant Value);
+
+	/**
+	 * Returns the value for the given config parameter or the default value
+	 * if the parameter is not set.
+	 */
+	static QVariant configParam(eConfigParam Param, QVariant Default);
+
 	/**
 	 * Returns the global icon provider.
 	 * The icon provider enables the use of custom icons in case using

src/DockWidgetTab.cpp

@@ -529,26 +529,34 @@ void CDockWidgetTab::contextMenuEvent(QContextMenuEvent* ev)
 		return;
 	}
 
+    auto Menu = buildContextMenu(nullptr);
 	d->saveDragStartMousePosition(ev->globalPos());
+	Menu->exec(ev->globalPos());
+}
+
+QMenu* CDockWidgetTab::buildContextMenu(QMenu *Menu)
+{
+    if (Menu == nullptr) {
+        Menu = new QMenu(this);
+    }
     
     const bool isFloatable = d->DockWidget->features().testFlag(CDockWidget::DockWidgetFloatable);
     const bool isNotOnlyTabInContainer =  !d->DockArea->dockContainer()->hasTopLevelDockWidget();
     const bool isTopLevelArea = d->DockArea->isTopLevelArea();
     const bool isDetachable = isFloatable && isNotOnlyTabInContainer;
 	QAction* Action;
-	QMenu Menu(this);
 
     if (!isTopLevelArea)
     {
-		Action = Menu.addAction(tr("Detach"), this, SLOT(detachDockWidget()));
+		Action = Menu->addAction(tr("Detach"), this, SLOT(detachDockWidget()));
 		Action->setEnabled(isDetachable);
 		if (CDockManager::testAutoHideConfigFlag(CDockManager::AutoHideFeatureEnabled))
 		{
-			Action = Menu.addAction(tr("Pin"), this, SLOT(autoHideDockWidget()));
+			Action = Menu->addAction(tr("Pin"), this, SLOT(autoHideDockWidget()));
 			auto IsPinnable = d->DockWidget->features().testFlag(CDockWidget::DockWidgetPinnable);
 			Action->setEnabled(IsPinnable);
 
-			auto menu = Menu.addMenu(tr("Pin To..."));
+			auto menu = Menu->addMenu(tr("Pin To..."));
 			menu->setEnabled(IsPinnable);
 			d->createAutoHideToAction(tr("Top"), SideBarTop, menu);
 			d->createAutoHideToAction(tr("Left"), SideBarLeft, menu);
@@ -557,17 +565,16 @@ void CDockWidgetTab::contextMenuEvent(QContextMenuEvent* ev)
 		}
     }
 
-	Menu.addSeparator();
+	Menu->addSeparator();
-	Action = Menu.addAction(tr("Close"), this, SIGNAL(closeRequested()));
+	Action = Menu->addAction(tr("Close"), this, SIGNAL(closeRequested()));
 	Action->setEnabled(isClosable());
 	if (d->DockArea->openDockWidgetsCount() > 1)
 	{
-		Action = Menu.addAction(tr("Close Others"), this, SIGNAL(closeOtherTabsRequested()));
+		Action = Menu->addAction(tr("Close Others"), this, SIGNAL(closeOtherTabsRequested()));
 	}
-	Menu.exec(ev->globalPos());
+
+    return Menu;
 }
-
-
 //============================================================================
 bool CDockWidgetTab::isActiveTab() const
 {
@@ -789,6 +796,13 @@ bool CDockWidgetTab::event(QEvent *e)
 }
 
 
+//============================================================================
+eDragState CDockWidgetTab::dragState() const
+{
+	return d->DragState;
+}
+
+
 //============================================================================
 void CDockWidgetTab::onDockWidgetFeaturesChanged()
 {

src/DockWidgetTab.h

@@ -35,6 +35,8 @@
 
 #include "ads_globals.h"
 
+QT_FORWARD_DECLARE_CLASS(QMenu)
+
 namespace ads
 {
 class CDockWidget;
@@ -178,6 +180,26 @@ public:
 	 */
 	void setIconSize(const QSize& Size);
 
+	/**
+	 * Returns the current drag state of this tab.
+	 * Use this function to determine if the tab is currently being dragged
+	 */
+	eDragState dragState() const;
+
+    /**
+     * Fills the provided menu with standard entries. If a nullptr is passed, a
+     * new menu is created and filled with standard entries.
+     * This function is called from the actual version of contextMenuEvent, but
+     * can be called from any code. Caller is responsible of deleting the created
+     * object.
+     *
+     * @param menu The QMenu to fill with standard entries. If nullptr, a new
+     * QMenu will be created.
+     * @return The filled QMenu, either the provided one or a newly created one if
+     * nullptr was passed.
+     */
+    virtual QMenu *buildContextMenu(QMenu *);
+
 public Q_SLOTS:
 	virtual void setVisible(bool visible) override;
 

src/FloatingDockContainer.cpp

@@ -1331,7 +1331,8 @@ void CFloatingDockContainer::onMaximizeRequest()
 //============================================================================
 void CFloatingDockContainer::showNormal(bool fixGeometry)
 {
-	if (windowState() == Qt::WindowMaximized)
+    if ( (windowState() & Qt::WindowMaximized) != 0 ||
+         (windowState() & Qt::WindowFullScreen) != 0)
 	{
 		QRect oldNormal = normalGeometry();
 		Super::showNormal();

src/FloatingDockContainer.h

@@ -131,15 +131,6 @@ protected:
 	virtual void startFloating(const QPoint& DragStartMousePos, const QSize& Size,
         eDragState DragState, QWidget* MouseEventHandler) override;
 
-	/**
-	 * Call this function to start dragging the floating widget
-	 */
-    void startDragging(const QPoint& DragStartMousePos, const QSize& Size,
-        QWidget* MouseEventHandler)
-	{
-        startFloating(DragStartMousePos, Size, DraggingFloatingWidget, MouseEventHandler);
-	}
-
 	/**
 	 * Call this function if you explicitly want to signal that dragging has
 	 * finished
@@ -236,6 +227,15 @@ public:
 	 */
 	CDockContainerWidget* dockContainer() const;
 
+	/**
+	 * Call this function to start dragging the floating widget
+	 */
+    void startDragging(const QPoint& DragStartMousePos, const QSize& Size,
+        QWidget* MouseEventHandler)
+	{
+        startFloating(DragStartMousePos, Size, DraggingFloatingWidget, MouseEventHandler);
+	}
+
 	/**
 	 * This function returns true, if it can be closed.
 	 * It can be closed, if all dock widgets in all dock areas can be closed

src/ads_globals.h

@@ -158,7 +158,7 @@ enum SideBarLocation
 	SideBarBottom,
 	SideBarNone
 };
-Q_ENUMS(SideBarLocation);
+Q_ENUMS(SideBarLocation)
 
 
 namespace internal