Merge branch 'master' into fork

2025-03-31 10:22:39 +08:00 · 2025-02-02 17:04:02 +03:00 · 2025-02-02 17:04:02 +03:00 · 463b010de4
commit 463b010de4
parent b940f740b7 a16d17a8bf
50 changed files with 1115 additions and 175 deletions
--- a/.gitignore
+++ b/.gitignore
@ -9,7 +9,7 @@ ui_*
 Makefile
 *.dll
 *.a
-build-*
+build*

 # IDEs
 .idea
--- a/CMakeLists.txt
+++ b/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)
--- a/README.md
+++ b/README.md
@ -462,7 +462,7 @@ MainWindow::MainWindow(QWidget *parent) :
    // Create the dock manager after the ui is setup. Because the
    // parent parameter is a QMainWindow the dock manager registers
    // itself as the central widget as such the ui must be set up first.
-    m_DockManager = new ads::CDockManager(this);
+    DockManager = new ads::CDockManager(this);

    // Create example content label - this can be any application specific
    // widget
@ -473,7 +473,7 @@ MainWindow::MainWindow(QWidget *parent) :

    // Create a dock widget with the title Label 1 and set the created label
    // as the dock widget content
-    ads::CDockWidget* DockWidget = new ads::CDockWidget("Label 1");
+    ads::CDockWidget* DockWidget = DockManager->createDockWidget("Label 1");
    DockWidget->setWidget(l);

    // Add the toggleViewAction of the dock widget to the menu to give
@ -481,7 +481,7 @@ MainWindow::MainWindow(QWidget *parent) :
    ui->menuView->addAction(DockWidget->toggleViewAction());

    // Add the dock widget to the top dock widget area
-    m_DockManager->addDockWidget(ads::TopDockWidgetArea, DockWidget);
+    DockManager->addDockWidget(ads::TopDockWidgetArea, DockWidget);
 }

 MainWindow::~MainWindow()
@ -582,7 +582,7 @@ highlights are:
 - Simple Drag & Drop user interface.
 - Load data from file.
 - Connect to live streaming of data.
- Save the visualization layout and configurations to re-use them later.
+- Save the visualization layout and configurations to reuse them later.
 - Fast OpenGL visualization.
 - Can handle thousands of timeseries and millions of data points.
 - Transform your data using a simple editor: derivative, moving average, integral, etc…
--- a/demo/CMakeLists.txt
+++ b/demo/CMakeLists.txt
@ -27,7 +27,7 @@ target_link_libraries(AdvancedDockingSystemDemo PUBLIC Qt${QT_VERSION_MAJOR}::Co
 if(WIN32 AND QT_VERSION_MAJOR LESS 6)
    target_link_libraries(AdvancedDockingSystemDemo PUBLIC Qt${QT_VERSION_MAJOR}::AxContainer)
 endif()
-target_link_libraries(AdvancedDockingSystemDemo PRIVATE qt${QT_VERSION_MAJOR}advanceddocking)
+target_link_libraries(AdvancedDockingSystemDemo PRIVATE qtadvanceddocking-qt${QT_VERSION_MAJOR})
 set_target_properties(AdvancedDockingSystemDemo PROPERTIES 
    AUTOMOC ON
    AUTORCC ON
--- a/demo/MainWindow.cpp
+++ b/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"));
@ -237,7 +236,7 @@ struct MainWindowPrivate
 		m->setRootPath(QDir::currentPath());
 		w->setModel(m);
 		w->setRootIndex(m->index(QDir::currentPath()));
-		ads::CDockWidget* DockWidget = new ads::CDockWidget(QString("Filesystem %1")
+		ads::CDockWidget* DockWidget = DockManager->createDockWidget(QString("Filesystem %1")
 			.arg(FileSystemCount++));
 		DockWidget->setWidget(w);
 		DockWidget->setIcon(svgIcon(":/adsdemo/images/folder_open.svg"));
@ -258,7 +257,7 @@ struct MainWindowPrivate
 	{
 		static int CalendarCount = 0;
 		QCalendarWidget* w = new QCalendarWidget();
-		ads::CDockWidget* DockWidget = new ads::CDockWidget(QString("Calendar %1").arg(CalendarCount++));
+		ads::CDockWidget* DockWidget = DockManager->createDockWidget(QString("Calendar %1").arg(CalendarCount++));
 		// The following lines are for testing the setWidget() and takeWidget()
 		// functionality
 		DockWidget->setWidget(w);
@ -303,7 +302,7 @@ struct MainWindowPrivate
 			.arg(LabelCount)
 			.arg(QTime::currentTime().toString("hh:mm:ss:zzz")));

-		ads::CDockWidget* DockWidget = new ads::CDockWidget(QString("Label %1").arg(LabelCount++));
+		ads::CDockWidget* DockWidget = DockManager->createDockWidget(QString("Label %1").arg(LabelCount++));
 		DockWidget->setWidget(l);
 		DockWidget->setIcon(svgIcon(":/adsdemo/images/font_download.svg"));
 		ui.menuView->addAction(DockWidget->toggleViewAction());
@ -321,7 +320,7 @@ struct MainWindowPrivate
 		w->setPlaceholderText("This is an editor. If you close the editor, it will be "
 			"deleted. Enter your text here.");
 		w->setStyleSheet("border: none");
-		ads::CDockWidget* DockWidget = new ads::CDockWidget(QString("Editor %1").arg(EditorCount++));
+		ads::CDockWidget* DockWidget = DockManager->createDockWidget(QString("Editor %1").arg(EditorCount++));
 		DockWidget->setWidget(w);
 		DockWidget->setIcon(svgIcon(":/adsdemo/images/edit.svg"));
 		DockWidget->setFeature(ads::CDockWidget::CustomCloseHandling, true);
@ -364,7 +363,7 @@ struct MainWindowPrivate

 		auto Result = w->loadFile(FileName);
 		qDebug() << "loadFile result: " << Result;
-		ads::CDockWidget* DockWidget = new ads::CDockWidget(QString("Image Viewer %1").arg(ImageViewerCount++));
+		ads::CDockWidget* DockWidget = DockManager->createDockWidget(QString("Image Viewer %1").arg(ImageViewerCount++));
 		DockWidget->setIcon(svgIcon(":/adsdemo/images/photo.svg"));
 		DockWidget->setWidget(w,ads:: CDockWidget::ForceNoScrollArea);
 		auto ToolBar = DockWidget->createDefaultToolBar();
@ -379,7 +378,7 @@ struct MainWindowPrivate
 	{
 		static int TableCount = 0;
 		auto w = new CMinSizeTableWidget();
-		ads::CDockWidget* DockWidget = new ads::CDockWidget(QString("Table %1").arg(TableCount++));
+		ads::CDockWidget* DockWidget = DockManager->createDockWidget(QString("Table %1").arg(TableCount++));
 		static int colCount = 5;
 		static int rowCount = 30;
 		w->setColumnCount(colCount);
@ -418,7 +417,7 @@ struct MainWindowPrivate
 	ads::CDockWidget *createQQuickWidget()
 	{
 		QQuickWidget *widget = new QQuickWidget();
-		ads::CDockWidget *dockWidget = new ads::CDockWidget("Quick");
+		ads::CDockWidget *dockWidget = DockManager->createDockWidget("Quick");
 		dockWidget->setWidget(widget);
 		return dockWidget;
 	}
@ -433,7 +432,7 @@ struct MainWindowPrivate
 	{
 	   static int ActiveXCount = 0;
 	   QAxWidget* w = new QAxWidget("{6bf52a52-394a-11d3-b153-00c04f79faa6}", parent);
-	   ads::CDockWidget* DockWidget = new ads::CDockWidget(QString("Active X %1").arg(ActiveXCount++));
+	   ads::CDockWidget* DockWidget = DockManager->createDockWidget(QString("Active X %1").arg(ActiveXCount++));
 	   DockWidget->setWidget(w);
 	   ui.menuView->addAction(DockWidget->toggleViewAction());
 	   return DockWidget;
@ -471,12 +470,12 @@ void MainWindowPrivate::createContent()
 	appendFeaturStringToWindowTitle(FileSystemWidget);

 	// Test custom factory - we inject a help button into the title bar
-	ads::CDockComponentsFactory::setFactory(new CCustomComponentsFactory());
+	DockManager->setComponentsFactory(new CCustomComponentsFactory());
 	auto TopDockArea = DockManager->addDockWidget(ads::TopDockWidgetArea, FileSystemWidget);
 	// Uncomment the next line if you would like to test the
 	// HideSingleWidgetTitleBar functionality
 	// TopDockArea->setDockAreaFlag(ads::CDockAreaWidget::HideSingleWidgetTitleBar, true);
-	ads::CDockComponentsFactory::resetDefaultFactory();
+	DockManager->setComponentsFactory(ads::CDockComponentsFactory::factory());

 	// We create a calendar widget and clear all flags to prevent the dock area
 	// from closing
@ -770,6 +769,9 @@ CMainWindow::CMainWindow(QWidget *parent) :
 	// uncomment if you would like to enable dock widget auto hiding
    CDockManager::setAutoHideConfigFlags({CDockManager::DefaultAutoHideConfig});

+    // uncomment if you would like to disable closing auto hide widget with mouse click outside of auto hide container
+    //CDockManager::setAutoHideConfigFlag(CDockManager::AutoHideCloseOnOutsideMouseClick, false);
+
 	// uncomment if you would like to enable an equal distribution of the
 	// available size of a splitter to all contained dock widgets
 	// CDockManager::setConfigFlag(CDockManager::EqualSplitOnInsertion, true);
--- a/demo/MyDockAreaTitleBar.h
+++ b/demo/MyDockAreaTitleBar.h
@ -0,0 +1,58 @@
+#ifndef QTADS_MYDOCKAREATITLEBAR_H
+#define QTADS_MYDOCKAREATITLEBAR_H
+/*******************************************************************************
+** Qt Advanced Docking System
+** Copyright (C) 2017 Uwe Kindler
+**
+** This library is free software; you can redistribute it and/or
+** modify it under the terms of the GNU Lesser General Public
+** License as published by the Free Software Foundation; either
+** version 2.1 of the License, or (at your option) any later version.
+**
+** This library is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+** Lesser General Public License for more details.
+**
+** You should have received a copy of the GNU Lesser General Public
+** License along with this library; If not, see <http://www.gnu.org/licenses/>.
+******************************************************************************/
+
+
+//============================================================================
+//                                   INCLUDES
+//============================================================================
+#include <DockAreaTitleBar.h>
+
+
+/**
+ * Custom DockAreaTitleBar that adds a custom context menu
+ */
+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
--- a/doc/cfg_flag_AutoHideOpenOnDragHover.gif
+++ b/doc/cfg_flag_AutoHideOpenOnDragHover.gif
--- a/doc/user-guide.md
+++ b/doc/user-guide.md
@ -29,8 +29,8 @@
  - [`MiddleMouseButtonClosesTab`](#middlemousebuttonclosestab)
  - [`DisableTabTextEliding`](#disabletabtexteliding)
  - [`ShowTabTextOnlyForActiveTab`](#showtabtextonlyforactivetab)
- [Auto-Hide Configuration Flags](#auto-hide-configuration-flags)
-  - [Auto Hide Dock Widgets](#auto-hide-dock-widgets)
+  - [`DoubleClickUndocksWidget`](#doubleclickundockswidget)
+- [Auto Hide Dock Widgets](#auto-hide-dock-widgets)
  - [Pinning Auto-Hide Widgets to a certain border](#pinning-auto-hide-widgets-to-a-certain-border)
  - [Show / Hide Auto-Hide Widgets via Mouse Over](#show--hide-auto-hide-widgets-via-mouse-over)
  - [Drag \& Drop to Auto-Hide](#drag--drop-to-auto-hide)
@ -39,6 +39,7 @@
  - [Auto-Hide Drag to Float / Dock](#auto-hide-drag-to-float--dock)
  - [Auto-Hide Context Menu](#auto-hide-context-menu)
  - [Adding Auto Hide Widgets](#adding-auto-hide-widgets)
+- [Auto-Hide Configuration Flags](#auto-hide-configuration-flags)
  - [Setting Auto-Hide Flags](#setting-auto-hide-flags)
  - [`AutoHideFeatureEnabled`](#autohidefeatureenabled)
  - [`DockAreaHasAutoHideButton`](#dockareahasautohidebutton)
@ -49,6 +50,8 @@
  - [`AutoHideCloseButtonCollapsesDock`](#autohideclosebuttoncollapsesdock)
  - [`AutoHideHasCloseButton`](#autohidehasclosebutton)
  - [`AutoHideHasMinimizeButton`](#autohidehasminimizebutton)
+  - [`AutoHideOpenOnDragHover`](#autohideopenondraghover)
+  - [`AutoHideCloseOnOutsideMouseClick`](#autohidecloseonoutsidemouseclick)
 - [DockWidget Feature Flags](#dockwidget-feature-flags)
  - [`DockWidgetClosable`](#dockwidgetclosable)
  - [`DockWidgetMovable`](#dockwidgetmovable)
@ -62,6 +65,8 @@
 - [Central Widget](#central-widget)
 - [Empty Dock Area](#empty-dock-area)
 - [Custom Close Handling](#custom-close-handling)
+- [Globally Lock Docking Features](#globally-lock-docking-features)
+- [Dock Widget Size / Minimum Size Handling](#dock-widget-size--minimum-size-handling)
 - [Styling](#styling)
  - [Disabling the Internal Style Sheet](#disabling-the-internal-style-sheet)

@ -150,7 +155,7 @@ This ie enabled by default to minimize the size of the saved data.

 ### `TabCloseButtonIsToolButton`

-If enabled the tab close buttons will be `QToolButtons` instead of `QPushButtons` - 
+If enabled the tab close buttons will be `QToolButtons` instead of `QPushButtons` -
 disabled by default. Normally the default configuration should be ok but if your
 application requires `QToolButtons` instead of `QPushButtons` for styling reasons
 or for any other reasons, then you can enable this flag.
@ -181,7 +186,7 @@ constant, that means, if enabled, the tabs need more space.

 ### `DragPreviewIsDynamic`

-If non-opaque undocking is enabled, this flag defines the behavior of the drag 
+If non-opaque undocking is enabled, this flag defines the behavior of the drag
 preview window. If this flag is enabled, then it will give the user the
 impression, that the floating drag preview is dynamically adjusted to the drop
 area. In order to give the perfect impression, you should disable the flags
@ -197,7 +202,7 @@ CDockManager::setConfigFlag(CDockManager::DragPreviewHasWindowFrame, false);

 ### `DragPreviewShowsContentPixmap`

-If non-opaque undocking is enabled, the created drag preview window shows a 
+If non-opaque undocking is enabled, the created drag preview window shows a
 copy of the content of the dock widget / dock are that is dragged, if this
 flag is enabled (default).

@ -210,7 +215,7 @@ like window without any content.

 ### `DragPreviewHasWindowFrame`

-If non-opaque undocking is enabled, then this flag configures if the drag 
+If non-opaque undocking is enabled, then this flag configures if the drag
 preview is frameless (default) or looks like a real window. If it is enabled,
 then the drag preview is a transparent window with a system window frame.

@ -378,7 +383,7 @@ ads--CDockAreaWidget[focused="true"] ads--CDockAreaTitleBar

 If you have a content widget that does not support focussing for some reason
 (like `QVTKOpenGLStereoWidget` from the [VTK library](https://github.com/Kitware/VTK)),
-then you can manually switch the focus by reacting on mouse events. The 
+then you can manually switch the focus by reacting on mouse events. The
 following code shows, how to install en event filter on the `QVTKOpenGLStereoWidget`
 to properly switch the focus on `QEvent::MouseButtonPress`:

@ -422,7 +427,7 @@ bool CMainWindow::eventFilter(QObject *watched, QEvent *event)
 ### `EqualSplitOnInsertion`

 This flag configures how the space is distributed if a new dock widget is
-inserted into an existing dock area. The flag is disabled by default. If 3 
+inserted into an existing dock area. The flag is disabled by default. If 3
 dock widgets are inserted with the following code

 ```c++
@ -433,7 +438,7 @@ then this is the result, if the flag is disabled:

 ![EqualSplitOnInsertion false](cfg_flag_EqualSplitOnInsertion_false.png)

-If the flag is enabled, then the space is equally distributed to all widgets 
+If the flag is enabled, then the space is equally distributed to all widgets
 in a  splitter:

 ![EqualSplitOnInsertion true](cfg_flag_EqualSplitOnInsertion_true.png)
@ -495,13 +500,16 @@ for active tabs. Inactive tabs only show their icon:

 ![MShowTabTextOnlyForActiveTab true](cfg_flag_ShowTabTextOnlyForActiveTab_true.png)

-## Auto-Hide Configuration Flags
+### `DoubleClickUndocksWidget`

-### Auto Hide Dock Widgets
+If the flag is set (default), a double click on a tab undocks the dock widget.
+If you would like to disable undocking, just clear this flag.
+
+## Auto Hide Dock Widgets

 The Advanced Docking System supports "Auto-Hide" functionality for **all**
 dock containers. The "Auto Hide" feature allows to display more information
-using less screen space by hiding or showing windows pinned to one of the 
+using less screen space by hiding or showing windows pinned to one of the
 four dock container borders.

 Enabling this feature adds a button with a pin icon to each dock area.
@ -563,7 +571,7 @@ That means, you can drag them to a different border or sidebar:

 ### Auto-Hide Tab Sorting

-You can drag Auto-Hide tabs to a new position in the current sidebar 
+You can drag Auto-Hide tabs to a new position in the current sidebar
 to sort them:

 ![Auo-Hide sort tabs](AutoHide_Sort_Tabs.gif)
@ -598,6 +606,8 @@ DockManager->addAutoHideDockWidget(SideBarLeft, TableDockWidget);

 See `autohide` example or the demo application to learn how it works.

+## Auto-Hide Configuration Flags
+
 ### Setting Auto-Hide Flags

 The Advanced Docking System has a number of global configuration flags to
@ -632,7 +642,7 @@ the other Auto-Hide flags will be evaluated.

 ### `DockAreaHasAutoHideButton`

-If this flag is set (default), then each dock area has a pin button in the title 
+If this flag is set (default), then each dock area has a pin button in the title
 bar to toggle Auto-Hide state.

 ![DockAreaHasAutoHideButton true](cfg_flag_DockAreaHasAutoHideButton.png)
@ -676,7 +686,7 @@ works if this feature is enabled.
 Some users don't understand the distinction between closing an auto hide dock and
 collapsing an auto hide dock. This may lead to situations where they press the
 close button (losing the side tab widget) instead of simply clicking outside
-the auto hide dock (collapsing the dock). 
+the auto hide dock (collapsing the dock).

 ![AutoHideCloseButtonCollapsesDock false](cfg_flag_AutoHideCloseButtonCollapsesDock_false.gif)

@ -704,6 +714,20 @@ 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.
+
+### `AutoHideCloseOnOutsideMouseClick`
+
+If this flag is set (default), the auto hide dock container will collapse if the
+user clicks outside of the container. If not set, the auto hide container can be
+closed only via click on auto hide sidebar tab.
+
 ## DockWidget Feature Flags

 ### `DockWidgetClosable`
@ -825,6 +849,93 @@ Normally clicking the close button of a dock widget will just hide the widget an

 When an entire area is closed, the default behavior is to hide the dock widgets it contains regardless of the `DockWidgetDeleteOnClose` flag except if there is only one dock widget. In this special case, the `DockWidgetDeleteOnClose` flag is followed. This behavior can be changed by setting the `DockWidgetForceCloseWithArea` flag to all the dock widgets that needs to be closed with their area.

+## Globally Lock Docking Features
+
+It is possible to globally lock features of all dock widgets to "freeze" the
+current workspace layout. That means, you can now lock your workspace
+to avoid accidentally dragging a docked view. When locking wasn't possible,
+users had to manually dock it back to the desired place after each accidental
+undock.
+
+You can use a combination of the following feature flags to define which features
+shall get locked:
+
+- CDockWidget::DockWidgetClosable
+- CDockWidget::DockWidgetMovable
+- CDockWidget::DockWidgetFloatable
+- CDockWidget::DockWidgetPinable
+
+To clear the locked features, you can use CDockWidget::NoDockWidgetFeatures
+The following code shows how to lock and unlock all dock widget features
+globally.
+
+```c++
+DockManager->lockDockWidgetFeaturesGlobally();
+DockManager->lockDockWidgetFeaturesGlobally(CDockWidget::NoDockWidgetFeatures);
+```
+
+## Dock Widget Size / Minimum Size Handling
+
+There are several `CDockWidget` mode enums to control how a `CDockWidget` is
+resized and how the docking system handles the minimum size of a dockwidget.
+
+The first one is the `eInsertMode` enum:
+
+```c++
+enum eInsertMode
+{
+    AutoScrollArea,
+    ForceScrollArea,
+    ForceNoScrollArea
+};
+```
+
+The InsertMode defines how the widget is inserted into the dock widget, when you 
+call the `CDockWidget::setWidget` method:
+
+```c++
+DockWidget->setWidget(widget, CDockWidget::AutoScrollArea);
+```
+
+The content of a dock widget should be resizable do a very small size to
+prevent the dock widget from blocking the resizing. To ensure, that a
+dock widget can be resized very well, it is better to insert the content
+widget into a scroll area or to provide a widget that is already a scroll
+area or that contains a scroll area (such as an `QAbstractItemView`)
+If the InsertMode is `AutoScrollArea`, the DockWidget tries to automatically
+detect how to insert the given widget. If the widget is derived from
+`QScrollArea` (i.e. an `QAbstractItemView`), then the widget is inserted
+directly. If the given widget is not a scroll area, the widget will be
+inserted into a scroll area.
+
+To force insertion into a scroll area, you can also provide the InsertMode
+`ForceScrollArea`. In this case a scroll area will also be created for content
+widgets that are derived from `QScrollArea` To prevent insertion into a scroll
+area, you can provide the InsertMode `ForceNoScrollArea`. In this case, the
+content widget is always inserted directly.
+
+A second enum, the `eMinimumSizeHintMode` defines, which value will be returned
+from the `CDockWidget::minimumSizeHint()` function:
+
+```c++
+enum eMinimumSizeHintMode
+{
+    MinimumSizeHintFromDockWidget,
+    MinimumSizeHintFromContent,
+    MinimumSizeHintFromDockWidgetMinimumSize,
+    MinimumSizeHintFromContentMinimumSize,
+};
+```
+
+To ensure, that a dock widget does not block resizing, the dock widget
+reimplements `minimumSizeHint()` function to return a very small minimum
+size hint. If you would like to adhere the `minimumSizeHint()` from the
+content widget, then set the `minimumSizeHintMode()` to
+`MinimumSizeHintFromContent`. If you would like to use the `minimumSize()`
+value of the content widget or the dock widget, then you can use the
+`MinimumSizeHintFromDockWidgetMinimumSize` or
+`MinimumSizeHintFromContentMinimumSize` modes.
+
 ## Styling

 The Advanced Docking System supports styling via [Qt Style Sheets](https://doc.qt.io/qt-5/stylesheet.html). All components like splitters, tabs, buttons, titlebar and
--- a/examples/CMakeLists.txt
+++ b/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)
+add_subdirectory(dockindock)
--- a/examples/autohide/CMakeLists.txt
+++ b/examples/autohide/CMakeLists.txt
@ -9,7 +9,7 @@ add_executable(AutoHideExample WIN32
    mainwindow.ui
 )
 target_include_directories(AutoHideExample PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/../../src")
-target_link_libraries(AutoHideExample PRIVATE qt${QT_VERSION_MAJOR}advanceddocking)
+target_link_libraries(AutoHideExample PRIVATE qtadvanceddocking-qt${QT_VERSION_MAJOR})
 target_link_libraries(AutoHideExample PUBLIC Qt${QT_VERSION_MAJOR}::Core 
                                                  Qt${QT_VERSION_MAJOR}::Gui 
                                                  Qt${QT_VERSION_MAJOR}::Widgets)
--- a/examples/autohidedragndrop/CMakeLists.txt
+++ b/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 qtadvanceddocking-qt${QT_VERSION_MAJOR})
+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"
+)
--- a/examples/autohidedragndrop/autohidedragndrop.pro
+++ b/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
+
--- a/examples/autohidedragndrop/droppableitem.cpp
+++ b/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());
+    }
+}
--- a/examples/autohidedragndrop/droppableitem.h
+++ b/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;
+};
--- a/examples/autohidedragndrop/main.cpp
+++ b/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();
+}
--- a/examples/autohidedragndrop/main.py
+++ b/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_()
--- a/examples/autohidedragndrop/mainwindow.cpp
+++ b/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);
+}
+
+
+
--- a/examples/autohidedragndrop/mainwindow.h
+++ b/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
--- a/examples/autohidedragndrop/mainwindow.ui
+++ b/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>
--- a/examples/centralwidget/CMakeLists.txt
+++ b/examples/centralwidget/CMakeLists.txt
@ -9,7 +9,7 @@ add_executable(CentralWidgetExample WIN32
    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 PRIVATE qtadvanceddocking-qt${QT_VERSION_MAJOR})
 target_link_libraries(CentralWidgetExample PUBLIC Qt${QT_VERSION_MAJOR}::Core 
                                                  Qt${QT_VERSION_MAJOR}::Gui 
                                                  Qt${QT_VERSION_MAJOR}::Widgets)
--- a/examples/configflags/CMakeLists.txt
+++ b/examples/configflags/CMakeLists.txt
@ -9,7 +9,7 @@ add_executable(configFlagsExample WIN32
    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 PRIVATE qtadvanceddocking-qt${QT_VERSION_MAJOR})
 target_link_libraries(CentralWidgetExample PUBLIC Qt${QT_VERSION_MAJOR}::Core 
                                                  Qt${QT_VERSION_MAJOR}::Gui 
                                                  Qt${QT_VERSION_MAJOR}::Widgets)
--- a/examples/deleteonclose/CMakeLists.txt
+++ b/examples/deleteonclose/CMakeLists.txt
@ -7,7 +7,7 @@ add_executable(DeleteOnCloseTest WIN32
    main.cpp
 )
 target_include_directories(DeleteOnCloseTest PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/../../src")
-target_link_libraries(DeleteOnCloseTest PRIVATE qt${QT_VERSION_MAJOR}advanceddocking)
+target_link_libraries(DeleteOnCloseTest PRIVATE qtadvanceddocking-qt${QT_VERSION_MAJOR})
 target_link_libraries(DeleteOnCloseTest PUBLIC Qt${QT_VERSION_MAJOR}::Core 
                                               Qt${QT_VERSION_MAJOR}::Gui 
                                               Qt${QT_VERSION_MAJOR}::Widgets)
--- a/examples/dockindock/CMakeLists.txt
+++ b/examples/dockindock/CMakeLists.txt
@ -12,7 +12,7 @@ add_executable(DockInDockExample WIN32
    mainframe.cpp
 )
 target_include_directories(DockInDockExample PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/../../src")
-target_link_libraries(DockInDockExample PRIVATE qt${QT_VERSION_MAJOR}advanceddocking)
+target_link_libraries(DockInDockExample PRIVATE qtadvanceddocking-qt${QT_VERSION_MAJOR})
 target_link_libraries(DockInDockExample PUBLIC Qt${QT_VERSION_MAJOR}::Core 
                                           Qt${QT_VERSION_MAJOR}::Gui 
                                           Qt${QT_VERSION_MAJOR}::Widgets)
--- a/examples/emptydockarea/CMakeLists.txt
+++ b/examples/emptydockarea/CMakeLists.txt
@ -9,7 +9,7 @@ add_executable(EmptyDockAreaExample WIN32
    mainwindow.ui
 )
 target_include_directories(EmptyDockAreaExample PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/../../src")
-target_link_libraries(EmptyDockAreaExample PRIVATE qt${QT_VERSION_MAJOR}advanceddocking)
+target_link_libraries(EmptyDockAreaExample PRIVATE qtadvanceddocking-qt${QT_VERSION_MAJOR})
 target_link_libraries(EmptyDockAreaExample PUBLIC Qt${QT_VERSION_MAJOR}::Core 
                                                  Qt${QT_VERSION_MAJOR}::Gui 
                                                  Qt${QT_VERSION_MAJOR}::Widgets)
--- a/examples/emptydockarea/mainwindow.cpp
+++ b/examples/emptydockarea/mainwindow.cpp
@ -32,9 +32,12 @@ CMainWindow::CMainWindow(QWidget *parent)
    , ui(new Ui::CMainWindow)
 {
    ui->setupUi(this);
-    CDockManager::setConfigFlag(CDockManager::OpaqueSplitterResize, true);
-    CDockManager::setConfigFlag(CDockManager::XmlCompressionEnabled, false);
-    CDockManager::setConfigFlag(CDockManager::FocusHighlighting, true);
+	ads::CDockManager::setConfigFlag( ads::CDockManager::DockAreaHasCloseButton, false );
+	ads::CDockManager::setConfigFlag( ads::CDockManager::AllTabsHaveCloseButton, true );
+	ads::CDockManager::setConfigFlag( ads::CDockManager::DockAreaHasUndockButton, false );
+	ads::CDockManager::setConfigFlag( ads::CDockManager::DockAreaDynamicTabsMenuButtonVisibility, true );
+	ads::CDockManager::setConfigFlag( ads::CDockManager::DisableTabTextEliding, true );
+	ads::CDockManager::setConfigFlag( ads::CDockManager::DoubleClickUndocksWidget, false );
    DockManager = new CDockManager(this);

    // Set central widget
@ -98,8 +101,13 @@ void CMainWindow::createPerspectiveUi()
 	PerspectiveComboBox = new QComboBox(this);
 	PerspectiveComboBox->setSizeAdjustPolicy(QComboBox::AdjustToContents);
 	PerspectiveComboBox->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+	connect(PerspectiveComboBox, &QComboBox::textActivated,
+        DockManager, &CDockManager::openPerspective);
+#else
 	connect(PerspectiveComboBox, SIGNAL(activated(const QString&)),
 		DockManager, SLOT(openPerspective(const QString&)));
+#endif
 	PerspectiveListAction->setDefaultWidget(PerspectiveComboBox);
 	ui->toolBar->addSeparator();
 	ui->toolBar->addAction(PerspectiveListAction);
--- a/examples/examples.pro
+++ b/examples/examples.pro
@ -2,6 +2,7 @@ TEMPLATE = subdirs

 SUBDIRS = \
    autohide \
+	autohidedragndrop \
    centralwidget \
 	simple \
 	hideshow \
--- a/examples/hideshow/CMakeLists.txt
+++ b/examples/hideshow/CMakeLists.txt
@ -9,7 +9,7 @@ add_executable(HideShowExample WIN32
    MainWindow.ui
 )
 target_include_directories(HideShowExample PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/../../src")
-target_link_libraries(HideShowExample PRIVATE qt${QT_VERSION_MAJOR}advanceddocking)
+target_link_libraries(HideShowExample PRIVATE qtadvanceddocking-qt${QT_VERSION_MAJOR})
 target_link_libraries(HideShowExample PUBLIC Qt${QT_VERSION_MAJOR}::Core 
                                             Qt${QT_VERSION_MAJOR}::Gui 
                                             Qt${QT_VERSION_MAJOR}::Widgets)
--- a/examples/sidebar/CMakeLists.txt
+++ b/examples/sidebar/CMakeLists.txt
@ -9,7 +9,7 @@ add_executable(SidebarExample WIN32
    MainWindow.ui
 )
 target_include_directories(SidebarExample PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/../../src")
-target_link_libraries(SidebarExample PRIVATE qt${QT_VERSION_MAJOR}advanceddocking)
+target_link_libraries(SidebarExample PRIVATE qtadvanceddocking-qt${QT_VERSION_MAJOR})
 target_link_libraries(SidebarExample PUBLIC Qt${QT_VERSION_MAJOR}::Core 
                                            Qt${QT_VERSION_MAJOR}::Gui 
                                            Qt${QT_VERSION_MAJOR}::Widgets)
--- a/examples/simple/CMakeLists.txt
+++ b/examples/simple/CMakeLists.txt
@ -9,7 +9,7 @@ add_executable(SimpleExample WIN32
    MainWindow.ui
 )
 target_include_directories(SimpleExample PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/../../src")
-target_link_libraries(SimpleExample PRIVATE qt${QT_VERSION_MAJOR}advanceddocking)
+target_link_libraries(SimpleExample PRIVATE qtadvanceddocking-qt${QT_VERSION_MAJOR})
 target_link_libraries(SimpleExample PUBLIC Qt${QT_VERSION_MAJOR}::Core 
                                           Qt${QT_VERSION_MAJOR}::Gui 
                                           Qt${QT_VERSION_MAJOR}::Widgets)
--- a/src/AutoHideDockContainer.cpp
+++ b/src/AutoHideDockContainer.cpp
@ -124,6 +124,21 @@ struct AutoHideDockContainerPrivate
 	 */
 	AutoHideDockContainerPrivate(CAutoHideDockContainer *_public);

+	/**
+	 * Convenience function to ease access to dock manager components factory
+	 */
+	QSharedPointer<ads::CDockComponentsFactory> componentsFactory() const
+	{
+		if (!DockWidget || !DockWidget->dockManager())
+		{
+			return CDockComponentsFactory::factory();
+		}
+		else
+		{
+			return DockWidget->dockManager()->componentsFactory();
+		}
+    }
+
 	/**
 	 * Convenience function to get a dock widget area
 	 */
@ -199,7 +214,7 @@ CAutoHideDockContainer::CAutoHideDockContainer(CDockWidget* DockWidget, SideBarL
 {
 	hide(); // auto hide dock container is initially always hidden
 	d->SideTabBarArea = area;
-	d->SideTab = componentsFactory()->createDockWidgetSideTab(nullptr);
+	d->SideTab = d->componentsFactory()->createDockWidgetSideTab(nullptr);
 	connect(d->SideTab, &CAutoHideTab::pressed, this, &CAutoHideDockContainer::toggleCollapseState);
 	d->DockArea = new CDockAreaWidget(DockWidget->dockManager(), parent);
 	d->DockArea->setObjectName("autoHideDockArea");
@ -587,8 +602,12 @@ bool CAutoHideDockContainer::eventFilter(QObject* watched, QEvent* event)
 			return Super::eventFilter(watched, event);
 		}

-		// user clicked into container - collapse the auto hide widget
-		collapseView(true);
+		// user clicked outside of autohide container - collapse the auto hide widget
+		if (CDockManager::testAutoHideConfigFlag(
+		    CDockManager::AutoHideCloseOnOutsideMouseClick))
+		{
+			collapseView(true);
+		}
 	}
    else if (event->type() == internal::FloatingWidgetDragStartEvent)
    {
@ -657,6 +676,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 +736,3 @@ int CAutoHideDockContainer::tabIndex() const
 }

 }
-
--- a/src/AutoHideDockContainer.h
+++ b/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
@ -139,7 +140,7 @@ public:

 	/**
 	 * Moves the contents to the parent container widget
-	 * Used before removing this Auto Hide dock container 
+	 * Used before removing this Auto Hide dock container
 	 */
    void moveContentsToParent();

--- a/src/AutoHideTab.cpp
+++ b/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))
-    {
-    	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)
+	if (!(ev->buttons() & Qt::LeftButton)
+	    || d->isDraggingState(DraggingInactive))
 	{
-    	// 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;
+		d->DragState = DraggingInactive;
+		Super::mouseMoveEvent(ev);
+		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)));
+}
+
+
 }
--- a/src/AutoHideTab.h
+++ b/src/AutoHideTab.h
@ -55,7 +55,7 @@ class ADS_EXPORT CAutoHideTab : public CPushButton
 	Q_PROPERTY(bool activeTab READ isActiveTab)
 	Q_PROPERTY(bool iconOnly READ iconOnly)

-private:    
+private:
 	AutoHideTabPrivate* d; ///< private data (pimpl)
    friend struct AutoHideTabPrivate;
 	friend class CDockWidget;
@ -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;
--- a/src/DockAreaTabBar.cpp
+++ b/src/DockAreaTabBar.cpp
@ -160,19 +160,9 @@ CDockAreaTabBar::~CDockAreaTabBar()
 //============================================================================
 void CDockAreaTabBar::wheelEvent(QWheelEvent* Event)
 {
-	Event->accept();
-	const int direction = Event->angleDelta().y();
-	if (direction < 0)
-	{
-		horizontalScrollBar()->setValue(horizontalScrollBar()->value() + 20);
-	}
-	else
-	{
-		horizontalScrollBar()->setValue(horizontalScrollBar()->value() - 20);
-	}
+    QCoreApplication::sendEvent(horizontalScrollBar(), Event);
 }

-
 //============================================================================
 void CDockAreaTabBar::setCurrentIndex(int index)
 {
@ -356,7 +346,7 @@ void CDockAreaTabBar::onCloseOtherTabsRequested()
 				CDockWidget::DockWidgetDeleteOnClose) ? 1 : 0;
 			closeTab(i);

-			// If the the dock widget blocks closing, i.e. if the flag
+			// If the dock widget blocks closing, i.e. if the flag
 			// CustomCloseHandling is set, and the dock widget is still open,
 			// then we do not need to correct the index
 			if (Tab->dockWidget()->isClosed())
@ -473,6 +463,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;
 	}
--- a/src/DockAreaTabBar.h
+++ b/src/DockAreaTabBar.h
@ -65,8 +65,7 @@ private Q_SLOTS:
 	void onTabWidgetMoved(const QPoint& GlobalPos);

 protected:
-	virtual void wheelEvent(QWheelEvent* Event) override;
-
+    virtual void wheelEvent(QWheelEvent* Event) override;

 public:
 	using Super = QScrollArea;
--- a/src/DockAreaTitleBar.cpp
+++ b/src/DockAreaTitleBar.cpp
@ -114,6 +114,14 @@ struct DockAreaTitleBarPrivate
 		return DockArea->dockManager();
 	}

+	/**
+	 * Convenience function for access to dock manager components factory
+	 */
+	QSharedPointer<ads::CDockComponentsFactory> componentsFactory() const
+	{
+        return dockManager()->componentsFactory();
+    }
+
 	/**
 	 * Returns true if the given config flag is set
 	 * Convenience function to ease config flag testing
@ -385,7 +393,10 @@ void CDockAreaTitleBar::resizeEvent(QResizeEvent *event)
 	if (CDockManager::testConfigFlag(CDockManager::DockAreaDynamicTabsMenuButtonVisibility)
 	 && CDockManager::testConfigFlag(CDockManager::DisableTabTextEliding))
 	{
-		markTabsMenuOutdated();
+		// Use queued connection to ensure that the resizing and relayouting has
+		// finished to ensure that the d->TabBar->areTabsOverflowing() function
+		// returns the correct value
+		QMetaObject::invokeMethod(this, "markTabsMenuOutdated", Qt::QueuedConnection);
 	}
 }

@ -730,6 +741,11 @@ void CDockAreaTitleBar::mouseDoubleClickEvent(QMouseEvent *event)
 		return;
 	}

+	if (!CDockManager::testConfigFlag(CDockManager::DoubleClickUndocksWidget))
+	{
+		return;
+	}
+
 	d->makeAreaFloating(event->pos(), DraggingInactive);
 }

@ -765,24 +781,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 (!isTopLevelArea)
+    if (Menu == nullptr)
+    {
+        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);
@ -790,28 +817,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("Close"), this, SLOT(onAutoHideCloseActionTriggered()));
+		Action = Menu->addAction(tr("Minimize"), this, SLOT(minimizeAutoHideContainer()));
+		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)
 {
--- a/src/DockAreaTitleBar.h
+++ b/src/DockAreaTitleBar.h
@ -249,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
--- a/src/DockAreaWidget.cpp
+++ b/src/DockAreaWidget.cpp
@ -34,7 +34,6 @@

 #include <QStackedLayout>
 #include <QScrollBar>
-#include <QWheelEvent>
 #include <QStyle>
 #include <QPushButton>
 #include <QDebug>
@ -270,6 +269,14 @@ struct DockAreaWidgetPrivate
 	 */
 	DockAreaWidgetPrivate(CDockAreaWidget* _public);

+	/**
+	 * Convenience function to ease components factory access
+	 */
+	QSharedPointer<ads::CDockComponentsFactory> componentsFactory() const
+	{
+        return DockManager->componentsFactory();
+    }
+
 	/**
 	 * Creates the layout for top area with tabs and close button
 	 */
@ -372,10 +379,10 @@ void DockAreaWidgetPrivate::updateTitleBarButtonStates()

 	if (_this->isAutoHide())
 	{
-		if (CDockManager::testAutoHideConfigFlag(CDockManager::AutoHideHasCloseButton))
-        {
+		if (CDockManager::testAutoHideConfigFlag(CDockManager::AutoHideHasCloseButton))
+        {
 			TitleBar->button(TitleBarButtonClose)->setEnabled(
-				_this->features().testFlag(CDockWidget::DockWidgetClosable));
+				_this->features().testFlag(CDockWidget::DockWidgetClosable));
        }
 	}
 	else
--- a/src/DockAreaWidget.h
+++ b/src/DockAreaWidget.h
@ -38,6 +38,7 @@

 QT_FORWARD_DECLARE_CLASS(QXmlStreamWriter)
 QT_FORWARD_DECLARE_CLASS(QAbstractButton)
+QT_FORWARD_DECLARE_CLASS(QMenu)

 namespace ads
 {
--- a/src/DockComponentsFactory.cpp
+++ b/src/DockComponentsFactory.cpp
@ -21,7 +21,8 @@

 namespace ads
 {
-static std::unique_ptr<CDockComponentsFactory> DefaultFactory(new CDockComponentsFactory());
+
+static QSharedPointer<ads::CDockComponentsFactory> DefaultFactory;


 //============================================================================
@ -52,9 +53,13 @@ CDockAreaTitleBar* CDockComponentsFactory::createDockAreaTitleBar(CDockAreaWidge


 //============================================================================
-const CDockComponentsFactory* CDockComponentsFactory::factory()
+QSharedPointer<ads::CDockComponentsFactory> CDockComponentsFactory::factory()
 {
-	return DefaultFactory.get();
+	if (!DefaultFactory)
+	{
+		DefaultFactory.reset(new CDockComponentsFactory());
+	}
+	return DefaultFactory;
 }


@ -70,6 +75,7 @@ void CDockComponentsFactory::resetDefaultFactory()
 {
 	DefaultFactory.reset(new CDockComponentsFactory());
 }
+
 } // namespace ads

 //---------------------------------------------------------------------------
--- a/src/DockComponentsFactory.h
+++ b/src/DockComponentsFactory.h
@ -66,9 +66,11 @@ public:
 	virtual CDockAreaTitleBar* createDockAreaTitleBar(CDockAreaWidget* DockArea) const;

 	/**
-	 * Returns the default components factory
+	 * This returns the default dock components factory instance.
+	 * If no components factory is assigned to a specific dock manager, this
+	 * global factory instance will be used.
 	 */
-	static const CDockComponentsFactory* factory();
+    static QSharedPointer<ads::CDockComponentsFactory> factory();

 	/**
 	 * Sets a new default factory for creation of GUI elements.
@ -82,15 +84,6 @@ public:
 	static void resetDefaultFactory();
 };

-
-/**
- * Convenience function to ease factory instance access
- */
-inline const CDockComponentsFactory* componentsFactory()
-{
-	return CDockComponentsFactory::factory();
-}
-
 } // namespace ads

 //---------------------------------------------------------------------------
--- a/src/DockManager.cpp
+++ b/src/DockManager.cpp
@ -48,6 +48,7 @@
 #include <QApplication>
 #include <QWindow>
 #include <QWindowStateChangeEvent>
+#include <QVector>

 #include "FloatingDockContainer.h"
 #include "DockOverlay.h"
@ -59,6 +60,8 @@
 #include "DockAreaTitleBar.h"
 #include "DockFocusController.h"
 #include "DockSplitter.h"
+#include "DockComponentsFactory.h"
+

 #if defined(Q_OS_UNIX) && !defined(Q_OS_MACOS)
 #include "linux/FloatingWidgetTitleBar.h"
@ -94,6 +97,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;

@ -123,6 +127,7 @@ struct DockManagerPrivate
 	QSize ToolBarIconSizeDocked = QSize(16, 16);
 	QSize ToolBarIconSizeFloating = QSize(24, 24);
 	CDockWidget::DockWidgetFeatures LockedDockWidgetFeatures;
+	QSharedPointer<ads::CDockComponentsFactory> ComponentFactory {ads::CDockComponentsFactory::factory()};

 	/**
 	 * Private data constructor
@ -550,7 +555,7 @@ CDockManager::~CDockManager()
 	{
 		if (!area || area->dockManager() != this) continue;

-		// QPointer delete safety - just in case some dock wigdet in destruction
+		// QPointer delete safety - just in case some dock widget in destruction
 		// deletes another related/twin or child dock widget.
 		std::vector<QPointer<QWidget>> deleteWidgets;
 		for ( auto widget : area->dockWidgets() )
@ -579,6 +584,35 @@ CDockManager::~CDockManager()
 	delete d;
 }

+
+//============================================================================
+CDockWidget* CDockManager::createDockWidget(const QString &title, QWidget* parent)
+{
+	return new CDockWidget(this, title, parent);
+}
+
+
+//============================================================================
+QSharedPointer<ads::CDockComponentsFactory> CDockManager::componentsFactory() const
+{
+    return d->ComponentFactory;
+}
+
+
+//============================================================================
+void CDockManager::setComponentsFactory(ads::CDockComponentsFactory* factory)
+{
+    setComponentsFactory(QSharedPointer<ads::CDockComponentsFactory>(factory));
+}
+
+
+//============================================================================
+void CDockManager::setComponentsFactory(QSharedPointer<ads::CDockComponentsFactory> factory)
+{
+    d->ComponentFactory = factory;
+}
+
+
 //============================================================================
 #if defined(Q_OS_UNIX) && !defined(Q_OS_MACOS)
 bool CDockManager::eventFilter(QObject *obj, QEvent *e)
@ -1475,6 +1509,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

 //---------------------------------------------------------------------------
--- a/src/DockManager.h
+++ b/src/DockManager.h
@ -215,6 +215,8 @@ public:
 		MiddleMouseButtonClosesTab = 0x2000000, //! If the flag is set, the user can use the mouse middle button to close the tab under the mouse
 		DisableTabTextEliding =      0x4000000, //! Set this flag to disable eliding of tab texts in dock area tabs
 		ShowTabTextOnlyForActiveTab =0x8000000, //! Set this flag to show label texts in dock area tabs only for active tabs
+		DoubleClickUndocksWidget = 0x10000000, //!< If the flag is set, a double click on a tab undocks the widget
+

        DefaultDockAreaButtons = DockAreaHasCloseButton
 							   | DockAreaHasUndockButton
@ -223,7 +225,8 @@ public:
 		DefaultBaseConfig = DefaultDockAreaButtons
 		                  | ActiveTabHasCloseButton
 		                  | XmlCompressionEnabled
-		                  | FloatingContainerHasWidgetTitle, ///< default base configuration settings
+		                  | FloatingContainerHasWidgetTitle
+		                  | DoubleClickUndocksWidget, ///< default base configuration settings

        DefaultOpaqueConfig = DefaultBaseConfig
 		                    | OpaqueSplitterResize
@ -254,14 +257,26 @@ 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
+        AutoHideCloseOnOutsideMouseClick = 0x400, ///< if this flag is set, the auto hide dock container will collapse if the user clicks outside of the container, if not set, the auto hide container can be closed only via click on sidebar tab

 		DefaultAutoHideConfig = AutoHideFeatureEnabled
 			                  | DockAreaHasAutoHideButton
 			                  | AutoHideHasMinimizeButton
+			                  | AutoHideCloseOnOutsideMouseClick

 	};
    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.
@ -277,6 +292,39 @@ public:
 	 */
 	virtual ~CDockManager() override;

+    /**
+     * Creates a new dock widget with the specified title and optional parent
+     * widget.
+     *
+     * The new dock widget will be managed by the dock manager, and its lifetime
+     * will be tied to the dock manager. If a parent widget is provided, the dock
+     * widget will be created as a child of the parent widget. If no parent widget
+     * is provided, the dock widget will be created as a top-level widget.
+     *
+     * @param title The title of the dock widget.
+     * @param parent The parent widget, if any. Defaults to nullptr.
+     * @return Returns a pointer to the created CDockWidget.
+     */
+    CDockWidget *createDockWidget(const QString &title, QWidget* parent = nullptr);
+
+	/**
+	 * Returns the dock manager specific factory for creating components of
+	 * fock widgets
+	 */
+    QSharedPointer<ads::CDockComponentsFactory> componentsFactory() const;
+
+    /**
+     * Sets a custom factory for creating components of dock widgets.
+     * The pointer is stored internally into a shared pointer so you should not
+     * delete the given factory object as long as it is used by the dock manager.
+     */
+    void setComponentsFactory(ads::CDockComponentsFactory* Factory);
+
+    /**
+     * Sets a custom factory for creating components of dock widgets.
+     */
+    void setComponentsFactory(QSharedPointer<ads::CDockComponentsFactory>);
+
 	/**
 	 * This function returns the global configuration flags
 	 */
@ -323,6 +371,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
--- a/src/DockWidget.cpp
+++ b/src/DockWidget.cpp
@ -102,6 +102,14 @@ struct DockWidgetPrivate
 	 */
 	DockWidgetPrivate(CDockWidget* _public);

+	/**
+	 * Convenience function to ease components factory access
+	 */
+	QSharedPointer<ads::CDockComponentsFactory> componentsFactory() const
+	{
+        return DockManager ? DockManager->componentsFactory() : CDockComponentsFactory::factory();
+    }
+
 	/**
 	 * Show dock widget
 	 */
@ -358,9 +366,17 @@ void DockWidgetPrivate::setToolBarStyleFromDockManager()

 //============================================================================
 CDockWidget::CDockWidget(const QString &title, QWidget *parent) :
-	QFrame(parent),
-	d(new DockWidgetPrivate(this))
+      CDockWidget(nullptr, title, parent)
 {
+}
+
+
+//============================================================================
+CDockWidget::CDockWidget(CDockManager *manager, const QString &title, QWidget* parent)
+	: QFrame(parent),
+	  d(new DockWidgetPrivate(this))
+{
+	d->DockManager = manager;
 	d->Layout = new QBoxLayout(QBoxLayout::TopToBottom);
 	d->Layout->setContentsMargins(0, 0, 0, 0);
 	d->Layout->setSpacing(0);
@ -368,7 +384,7 @@ CDockWidget::CDockWidget(const QString &title, QWidget *parent) :
 	setWindowTitle(title);
 	setObjectName(title);

-	d->TabWidget = componentsFactory()->createDockWidgetTab(this);
+	d->TabWidget = d->componentsFactory()->createDockWidgetTab(this);

 	d->ToggleViewAction = new QAction(title, this);
 	d->ToggleViewAction->setCheckable(true);
@ -382,6 +398,7 @@ CDockWidget::CDockWidget(const QString &title, QWidget *parent) :
 	}
 }

+
 //============================================================================
 CDockWidget::~CDockWidget()
 {
--- a/src/DockWidget.h
+++ b/src/DockWidget.h
@ -256,8 +256,35 @@ public:
     * during runtime, you need to set a unique object name explicitly
     * by calling setObjectName() after construction.
     * Use the layoutFlags to configure the layout of the dock widget.
+     * \note If you would like to use custom TabWidget implementations, you need
+     * to use the constructor with the CDockManager argument.
     */
-    CDockWidget(const QString &title, QWidget* parent = nullptr);
+    Q_DECL_DEPRECATED explicit CDockWidget(const QString &title, QWidget* parent = nullptr);
+
+    /**
+     * This constructor creates a dock widget for the given dock manager with the
+     * provided title.
+     *
+     * @param manager Pointer to the dock manager that owns the dock widget.
+     * @param title The title is the text that is shown in the window title when
+     * the dock widget is floating and it is the title that is shown in the
+     * titlebar or the tab of this dock widget if it is tabified.
+     * @param parent Pointer to the parent widget, defaults to nullptr.
+     *
+     * @note The object name of the dock widget is also set to the title. The
+     * object name is required by the dock manager to properly save and restore
+     * the state of the dock widget. That means, the title needs to be unique. If
+     * the title is not unique or if you would like to change the title during
+     * runtime, you need to set a unique object name explicitly by calling
+     * setObjectName() after construction. Use the layoutFlags to configure the
+     * layout of the dock widget.
+     *
+     * @note this constructor is preferred over the two argument version, especially
+     * when custom factories are in use. Indeed, it will use the Dock Manager factory,
+     * and not the default factory. For this reason, the original constructor should
+     * be deprecated in favour of this version.
+     */
+    CDockWidget(CDockManager *manager, const QString &title, QWidget* parent = nullptr);

    /**
     * Virtual Destructor
--- a/src/DockWidgetTab.cpp
+++ b/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();
-	Action = Menu.addAction(tr("Close"), this, SIGNAL(closeRequested()));
+	Menu->addSeparator();
+	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
 {
@ -692,7 +699,7 @@ QString CDockWidgetTab::text() const
 //============================================================================
 void CDockWidgetTab::mouseDoubleClickEvent(QMouseEvent *event)
 {
-	if (event->button() == Qt::LeftButton) 
+	if (event->button() == Qt::LeftButton && CDockManager::testConfigFlag(CDockManager::DoubleClickUndocksWidget))
 	{
 		// If this is the last dock area in a dock container it does not make
 		// sense to move it to a new floating widget and leave this one
@ -789,6 +796,13 @@ bool CDockWidgetTab::event(QEvent *e)
 }


+//============================================================================
+eDragState CDockWidgetTab::dragState() const
+{
+	return d->DragState;
+}
+
+
 //============================================================================
 void CDockWidgetTab::onDockWidgetFeaturesChanged()
 {
--- a/src/DockWidgetTab.h
+++ b/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;

--- a/src/FloatingDockContainer.h
+++ b/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
@ -149,7 +140,7 @@ protected:
 	/**
 	 * This function deletes all dock widgets in it.
 	 * This functions should be called only from dock manager in its
-	 * destructor before deleting the floating widget
+	 * destructor before deleting the floating widget
     */
 	void deleteContent();

@ -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
--- a/src/ads_globals.cpp
+++ b/src/ads_globals.cpp
@ -283,7 +283,7 @@ QString detectWindowManagerX11()
 	}
 	if(sup_windows.length() == 0)
 	{
-		ADS_PRINT("Failed to get the supporting window on non EWMH comform WM.");
+		ADS_PRINT("Failed to get the supporting window on non EWMH conform WM.");
 		return "UNKNOWN";
 	}
 	support_win = sup_windows[0];
--- a/src/ads_globals.h
+++ b/src/ads_globals.h
@ -236,7 +236,7 @@ SideBarLocation toSideBarLocation(DockWidgetArea Area);


 /**
- * Returns true for the top or bottom side bar ansd false for the
+ * Returns true for the top or bottom side bar and false for the
 * left and right side bar
 */
 bool isHorizontalSideBarLocation(SideBarLocation Location);