Honour FloatingWindowFlag::DontUseParentForFloatingWindows

Just so we can share this bit of code without duplicating it

src/DockWidgetBase.cpp

@@ -1040,3 +1040,17 @@ void DockWidgetBase::Private::saveLastFloatingGeometry()
         lastPosition()->setLastFloatingGeometry(q->window()->geometry());
     }
 }
+
+void DockWidgetBase::setFloatingWindowFlags(FloatingWindowFlags flags)
+{
+    if (auto fw = floatingWindow()) {
+        qWarning() << Q_FUNC_INFO << "Call this function only before having a floating window";
+    } else {
+        d->m_flags = flags;
+    }
+}
+
+KDDockWidgets::FloatingWindowFlags DockWidgetBase::floatingWindowFlags() const
+{
+    return d->m_flags;
+}

src/DockWidgetBase.h

@@ -460,6 +460,15 @@ public:
     /// This only applies when using MainWindowOption_HasCentralWidget
     bool isPersistentCentralDockWidget() const;
 
+    /// @brief Sets the desired floating window flags, in case the defaults aren't desired.
+    /// By default KDDW will use the flags specified in KDDockWidgets::Config to influence
+    /// many aspects regarding windows (minimize,maximize support for example).
+    /// You can use this function to override those "global flags" and specify per-dock widget
+    /// flags. Be sure to not call this before the floating window has already been created.
+    /// It's suggested to call it before the dock widget is shown.
+    void setFloatingWindowFlags(FloatingWindowFlags);
+    KDDockWidgets::FloatingWindowFlags floatingWindowFlags() const;
+
 Q_SIGNALS:
 #ifdef KDDOCKWIDGETS_QTWIDGETS
     ///@brief signal emitted when the parent changed

src/FrameworkWidgetFactory.cpp

@@ -85,9 +85,10 @@ Layouting::Separator *DefaultWidgetFactory::createSeparator(Layouting::Widget *p
     return new Layouting::SeparatorWidget(parent);
 }
 
-FloatingWindow *DefaultWidgetFactory::createFloatingWindow(MainWindowBase *parent) const
+FloatingWindow *DefaultWidgetFactory::createFloatingWindow(MainWindowBase *parent,
+                                                           FloatingWindowFlags flags) const
 {
-    return new FloatingWindowWidget(QRect(), parent);
+    return new FloatingWindowWidget(QRect(), parent, flags);
 }
 
 FloatingWindow *DefaultWidgetFactory::createFloatingWindow(Frame *frame, MainWindowBase *parent, QRect suggestedGeometry) const
@@ -159,9 +160,9 @@ TitleBar *DefaultWidgetFactory::createTitleBar(FloatingWindow *fw) const
     return new SeparatorQuick(parent);
 }*/
 
-FloatingWindow *DefaultWidgetFactory::createFloatingWindow(MainWindowBase *parent) const
+FloatingWindow *DefaultWidgetFactory::createFloatingWindow(MainWindowBase *parent, FloatingWindowFlags flags) const
 {
-    return new FloatingWindowQuick(parent);
+    return new FloatingWindowQuick(parent, flags);
 }
 
 FloatingWindow *DefaultWidgetFactory::createFloatingWindow(Frame *frame, MainWindowBase *parent, QRect suggestedGeometry) const

src/FrameworkWidgetFactory.h

@@ -114,7 +114,8 @@ public:
     ///       Override to provide your own FloatingWindow sub-class. If overridden then
     ///       you also need to override the overloads below.
     ///@param parent Just forward to FloatingWindow's constructor.
-    virtual FloatingWindow *createFloatingWindow(MainWindowBase *parent = nullptr) const = 0;
+    virtual FloatingWindow *createFloatingWindow(MainWindowBase *parent = nullptr,
+                                                 FloatingWindowFlags = FloatingWindowFlag::FromGlobalConfig) const = 0;
 
     ///@brief Called internally by the framework to create a FloatingWindow
     ///       Override to provide your own FloatingWindow sub-class. If overridden then
@@ -170,7 +171,7 @@ public:
     TabWidget *createTabWidget(Frame *parent, TabWidgetOptions = TabWidgetOption_None) const override;
     TabBar *createTabBar(TabWidget *parent) const override;
     Layouting::Separator *createSeparator(Layouting::Widget *parent = nullptr) const override;
-    FloatingWindow *createFloatingWindow(MainWindowBase *parent = nullptr) const override;
+    FloatingWindow *createFloatingWindow(MainWindowBase *parent = nullptr, FloatingWindowFlags = FloatingWindowFlag::FromGlobalConfig) const override;
     FloatingWindow *createFloatingWindow(Frame *frame, MainWindowBase *parent = nullptr, QRect suggestedGeometry = {}) const override;
     DropIndicatorOverlayInterface *createDropIndicatorOverlay(DropArea *) const override;
     QWidgetOrQuick *createRubberBand(QWidgetOrQuick *parent) const override;

src/KDDockWidgets.h

@@ -288,6 +288,22 @@ enum TabWidgetOption {
 Q_DECLARE_FLAGS(TabWidgetOptions, TabWidgetOption)
 Q_ENUM_NS(TabWidgetOptions)
 
+/// @internal
+enum class FloatingWindowFlag {
+    None = 0,
+    FromGlobalConfig = 1, // KDDockWidgets::Config is used instead
+    TitleBarHasMinimizeButton = 2,
+    TitleBarHasMaximizeButton = 4,
+    KeepAboveIfNotUtilityWindow = 8,
+    NativeTitleBar = 16,
+    HideTitleBarWhenTabsVisible = 32,
+    AlwaysTitleBarWhenFloating = 64,
+    DontUseParentForFloatingWindows = 128,
+    UseQtTool = 256,
+    UseQtWindow = 512
+};
+Q_DECLARE_FLAGS(FloatingWindowFlags, FloatingWindowFlag);
+
 ///@internal
 inline QString locationStr(Location loc)
 {

src/LayoutSaver.cpp

@@ -18,6 +18,7 @@
 
 #include "LayoutSaver.h"
 #include "Config.h"
+#include "KDDockWidgets.h"
 #include "MainWindowBase.h"
 #include "DockWidgetBase.h"
 #include "FrameworkWidgetFactory.h"
@@ -268,7 +269,7 @@ bool LayoutSaver::restoreLayout(const QByteArray &data)
         MainWindowBase *parent = fw.parentIndex == -1 ? nullptr
                                                       : DockRegistry::self()->mainwindows().at(fw.parentIndex);
 
-        auto floatingWindow = Config::self().frameworkWidgetFactory()->createFloatingWindow(parent);
+        auto floatingWindow = Config::self().frameworkWidgetFactory()->createFloatingWindow(parent, static_cast<FloatingWindowFlags>(fw.flags));
         fw.floatingWindowInstance = floatingWindow;
         d->deserializeWindowGeometry(fw, floatingWindow);
         if (!floatingWindow->deserialize(fw)) {
@@ -807,6 +808,7 @@ QVariantMap LayoutSaver::FloatingWindow::toVariantMap() const
     map.insert(QStringLiteral("screenSize"), Layouting::sizeToMap(screenSize));
     map.insert(QStringLiteral("isVisible"), isVisible);
     map.insert(QStringLiteral("windowState"), windowState);
+    map.insert(QStringLiteral("flags"), flags);
 
     if (!affinities.isEmpty())
         map.insert(QStringLiteral("affinities"), stringListToVariant(affinities));
@@ -821,6 +823,7 @@ void LayoutSaver::FloatingWindow::fromVariantMap(const QVariantMap &map)
     geometry = Layouting::mapToRect(map.value(QStringLiteral("geometry")).toMap());
     normalGeometry = Layouting::mapToRect(map.value(QStringLiteral("normalGeometry")).toMap());
     screenIndex = map.value(QStringLiteral("screenIndex")).toInt();
+    flags = map.value(QStringLiteral("flags")).toInt();
     screenSize = Layouting::mapToSize(map.value(QStringLiteral("screenSize")).toMap());
     isVisible = map.value(QStringLiteral("isVisible")).toBool();
     affinities = variantToStringList(map.value(QStringLiteral("affinities")).toList());

src/private/DockWidgetBase_p.h

@@ -155,6 +155,7 @@ public:
     QWidgetOrQuick *widget = nullptr;
     DockWidgetBase *const q;
     DockWidgetBase::Options options;
+    FloatingWindowFlags m_flags = FloatingWindowFlag::FromGlobalConfig;
     const LayoutSaverOptions layoutSaverOptions;
     QAction *const toggleAction;
     QAction *const floatAction;

src/private/FloatingWindow.cpp

@@ -10,6 +10,7 @@
 */
 
 #include "FloatingWindow_p.h"
+#include "KDDockWidgets.h"
 #include "MainWindowBase.h"
 #include "Logging_p.h"
 #include "Frame_p.h"
@@ -46,10 +47,20 @@ using namespace KDDockWidgets;
 /** static */
 Qt::WindowFlags FloatingWindow::s_windowFlagsOverride = {};
 
-static Qt::WindowFlags windowFlagsToUse()
+static Qt::WindowFlags windowFlagsToUse(FloatingWindowFlags requestedFlags)
 {
+    if (requestedFlags & FloatingWindowFlag::UseQtTool) {
+        // User has explicitly chosen Qt::Tool for this FloatingWindow
+        return Qt::Tool;
+    }
+
+    if (requestedFlags & FloatingWindowFlag::UseQtWindow) {
+        // User has explicitly chosen Qt::Window for this FloatingWindow
+        return Qt::Window;
+    }
+
     if (FloatingWindow::s_windowFlagsOverride) {
-        // The user specifically set different flags.
+        // User overridden the default for all FloatingWindows
         return FloatingWindow::s_windowFlagsOverride;
     }
 
@@ -64,6 +75,12 @@ static Qt::WindowFlags windowFlagsToUse()
 
 static MainWindowBase *hackFindParentHarder(Frame *frame, MainWindowBase *candidateParent)
 {
+    const FloatingWindowFlags requestedFlags = frame ? frame->requestedFloatingWindowFlags() : FloatingWindowFlag::FromGlobalConfig;
+    if (requestedFlags & FloatingWindowFlag::DontUseParentForFloatingWindows) {
+        // User explicitly requested no parent for this floating window
+        return nullptr;
+    }
+
     if (Config::self().internalFlags() & Config::InternalFlag_DontUseParentForFloatingWindows) {
         return nullptr;
     }
@@ -103,9 +120,46 @@ MainWindowBase *actualParent(MainWindowBase *candidate)
         : candidate;
 }
 
-FloatingWindow::FloatingWindow(QRect suggestedGeometry, MainWindowBase *parent)
+static FloatingWindowFlags flagsForFloatingWindow(FloatingWindowFlags requestedFlags)
-    : QWidgetAdapter(actualParent(parent), windowFlagsToUse())
+{
+    if (!(requestedFlags & FloatingWindowFlag::FromGlobalConfig)) {
+        // User requested specific flags for this floating window
+        return requestedFlags;
+    }
+
+    // Use from KDDockWidgets::Config instead. This is app-wide and not per window.
+
+    FloatingWindowFlags flags = {};
+
+    if ((Config::self().flags() & Config::Flag_TitleBarHasMinimizeButton) == Config::Flag_TitleBarHasMinimizeButton)
+        flags |= FloatingWindowFlag::TitleBarHasMinimizeButton;
+
+    if (Config::self().flags() & Config::Flag_TitleBarHasMaximizeButton)
+        flags |= FloatingWindowFlag::TitleBarHasMaximizeButton;
+
+    if (Config::self().flags() & Config::Flag_KeepAboveIfNotUtilityWindow)
+        flags |= FloatingWindowFlag::KeepAboveIfNotUtilityWindow;
+
+    if (Config::self().flags() & Config::Flag_NativeTitleBar)
+        flags |= FloatingWindowFlag::NativeTitleBar;
+
+    if (Config::self().flags() & Config::Flag_HideTitleBarWhenTabsVisible)
+        flags |= FloatingWindowFlag::HideTitleBarWhenTabsVisible;
+
+    if (Config::self().flags() & Config::Flag_AlwaysTitleBarWhenFloating)
+        flags |= FloatingWindowFlag::AlwaysTitleBarWhenFloating;
+
+    if (Config::self().internalFlags() & Config::InternalFlag_DontUseParentForFloatingWindows)
+        flags |= FloatingWindowFlag::DontUseParentForFloatingWindows;
+
+    return flags;
+}
+
+FloatingWindow::FloatingWindow(QRect suggestedGeometry, MainWindowBase *parent,
+                               FloatingWindowFlags requestedFlags)
+    : QWidgetAdapter(actualParent(parent), windowFlagsToUse(requestedFlags))
     , Draggable(this, KDDockWidgets::usesNativeDraggingAndResizing()) // FloatingWindow is only draggable when using a native title bar. Otherwise the KDDockWidgets::TitleBar is the draggable
+    , m_flags(flagsForFloatingWindow(requestedFlags))
     , m_dropArea(new DropArea(this))
     , m_titleBar(Config::self().frameworkWidgetFactory()->createTitleBar(this))
 {
@@ -126,7 +180,7 @@ FloatingWindow::FloatingWindow(QRect suggestedGeometry, MainWindowBase *parent)
 
     DockRegistry::self()->registerFloatingWindow(this);
 
-    if (Config::self().flags() & Config::Flag_KeepAboveIfNotUtilityWindow)
+    if (m_flags & FloatingWindowFlag::KeepAboveIfNotUtilityWindow)
         setWindowFlag(Qt::WindowStaysOnTopHint, true);
 
     if (kddwUsesQtWidgets()) {
@@ -144,8 +198,16 @@ FloatingWindow::FloatingWindow(QRect suggestedGeometry, MainWindowBase *parent)
     m_layoutDestroyedConnection = connect(m_dropArea, &QObject::destroyed, this, &FloatingWindow::scheduleDeleteLater);
 }
 
+static FloatingWindowFlags floatingWindowFlagsForFrame(Frame *frame)
+{
+    if (!frame)
+        return FloatingWindowFlag::FromGlobalConfig;
+
+    return frame->requestedFloatingWindowFlags();
+}
+
 FloatingWindow::FloatingWindow(Frame *frame, QRect suggestedGeometry, MainWindowBase *parent)
-    : FloatingWindow(suggestedGeometry, hackFindParentHarder(frame, parent))
+    : FloatingWindow(suggestedGeometry, hackFindParentHarder(frame, parent), floatingWindowFlagsForFrame(frame))
 {
     QScopedValueRollback<bool> guard(m_disableSetVisible, true);
 
@@ -305,7 +367,7 @@ void FloatingWindow::setSuggestedGeometry(QRect suggestedRect, SuggestedGeometry
         suggestedRect.setSize(maxSize.boundedTo(suggestedRect.size()));
 
         if ((hint & SuggestedGeometryHint_GeometryIsFromDocked)
-            && (Config::self().flags() & Config::Flag_NativeTitleBar)) {
+            && (m_flags & FloatingWindowFlag::NativeTitleBar)) {
             const QMargins margins = contentMargins();
             suggestedRect.setHeight(suggestedRect.height() - m_titleBar->height() + margins.top()
                                     + margins.bottom());
@@ -451,8 +513,7 @@ void FloatingWindow::updateTitleBarVisibility()
         frame->updateTitleBarVisibility();
 
     if (KDDockWidgets::usesClientTitleBar()) {
-        const auto flags = Config::self().flags();
+        if ((m_flags & FloatingWindowFlag::HideTitleBarWhenTabsVisible) && !(m_flags & FloatingWindowFlag::AlwaysTitleBarWhenFloating)) {
-        if ((flags & Config::Flag_HideTitleBarWhenTabsVisible) && !(flags & Config::Flag_AlwaysTitleBarWhenFloating)) {
             if (hasSingleFrame()) {
                 visible = !frames().first()->hasTabsVisible();
             }
@@ -534,6 +595,7 @@ LayoutSaver::FloatingWindow FloatingWindow::serialize() const
     fw.screenSize = screenSizeForWidget(this);
     fw.affinities = affinities();
     fw.windowState = windowStateOverride();
+    fw.flags = m_flags;
 
     auto mainWindow = qobject_cast<MainWindowBase *>(parentWidget());
     fw.parentIndex = mainWindow ? DockRegistry::self()->mainwindows().indexOf(mainWindow)
@@ -729,3 +791,13 @@ void FloatingWindow::ensureRectIsOnScreen(QRect &geometry)
         geometry.moveBottom(scrGeom.bottom());
     }
 }
+
+bool FloatingWindow::supportsMinimizeButton() const
+{
+    return m_flags & FloatingWindowFlag::TitleBarHasMinimizeButton;
+}
+
+bool FloatingWindow::supportsMaximizeButton() const
+{
+    return m_flags & FloatingWindowFlag::TitleBarHasMaximizeButton;
+}

src/private/FloatingWindow_p.h

@@ -41,7 +41,8 @@ class DOCKS_EXPORT FloatingWindow
     Q_PROPERTY(KDDockWidgets::TitleBar *titleBar READ titleBar CONSTANT)
     Q_PROPERTY(KDDockWidgets::DropArea *dropArea READ dropArea CONSTANT)
 public:
-    explicit FloatingWindow(QRect suggestedGeometry, MainWindowBase *parent = nullptr);
+    explicit FloatingWindow(QRect suggestedGeometry, MainWindowBase *parent = nullptr,
+                            FloatingWindowFlags requestedFlags = FloatingWindowFlag::FromGlobalConfig);
     explicit FloatingWindow(Frame *frame, QRect suggestedGeometry, MainWindowBase *parent = nullptr);
     ~FloatingWindow() override;
 
@@ -222,6 +223,12 @@ public:
     /// be open ended
     static Qt::WindowFlags s_windowFlagsOverride;
 
+    /// @brief Returns whether this floating window supports showing a minimize button
+    bool supportsMinimizeButton() const;
+
+    /// @brief Returns whether this floating window supports showing a maximize button
+    bool supportsMaximizeButton() const;
+
 Q_SIGNALS:
     void activatedChanged();
     void numFramesChanged();
@@ -237,6 +244,7 @@ protected:
     bool event(QEvent *ev) override;
     void onCloseEvent(QCloseEvent *) override;
 
+    const FloatingWindowFlags m_flags;
     QPointer<DropArea> m_dropArea;
     TitleBar *const m_titleBar;
     Qt::WindowState m_lastWindowManagerState = Qt::WindowNoState;

src/private/Frame.cpp

@@ -918,3 +918,12 @@ WidgetResizeHandler *Frame::resizeHandler() const
 {
     return m_resizeHandler;
 }
+
+FloatingWindowFlags Frame::requestedFloatingWindowFlags() const
+{
+    const auto dockwidgets = this->dockWidgets();
+    if (!dockwidgets.isEmpty())
+        return dockwidgets.first()->floatingWindowFlags();
+
+    return FloatingWindowFlag::FromGlobalConfig;
+}

src/private/Frame_p.h

@@ -312,6 +312,9 @@ public:
     /// @brief Returns the resize handler. Used mostly in MDI mode.
     WidgetResizeHandler *resizeHandler() const;
 
+    /// @brief User requested floating window flags for when this group floats
+    FloatingWindowFlags requestedFloatingWindowFlags() const;
+
 Q_SIGNALS:
     void currentDockWidgetChanged(KDDockWidgets::DockWidgetBase *);
     void numDockWidgetsChanged();

src/private/LayoutSaver_p.h

@@ -256,6 +256,7 @@ struct LayoutSaver::FloatingWindow
     QRect geometry;
     QRect normalGeometry;
     int screenIndex;
+    int flags = -1;
     QSize screenSize; // for relative-size restoring
     bool isVisible = true;
 

src/private/TitleBar.cpp

@@ -306,18 +306,12 @@ bool TitleBar::supportsFloatingButton() const
 
 bool TitleBar::supportsMaximizeButton() const
 {
-    if (!(Config::self().flags() & Config::Flag_TitleBarHasMaximizeButton))
+    return m_floatingWindow && m_floatingWindow->supportsMaximizeButton();
-        return false;
-
-    return m_floatingWindow != nullptr;
 }
 
 bool TitleBar::supportsMinimizeButton() const
 {
-    if ((Config::self().flags() & Config::Flag_TitleBarHasMinimizeButton) != Config::Flag_TitleBarHasMinimizeButton) // this specific flag is not base^2
+    return m_floatingWindow && m_floatingWindow->supportsMinimizeButton();
-        return false;
-
-    return m_floatingWindow != nullptr;
 }
 
 bool TitleBar::supportsAutoHideButton() const

src/private/quick/FloatingWindowQuick.cpp

@@ -104,8 +104,8 @@ QuickView::~QuickView() = default;
 }
 
 
-FloatingWindowQuick::FloatingWindowQuick(MainWindowBase *parent)
+FloatingWindowQuick::FloatingWindowQuick(MainWindowBase *parent, FloatingWindowFlags flags)
-    : FloatingWindow(QRect(), parent)
+    : FloatingWindow(QRect(), parent, flags)
     , m_quickWindow(new QuickView(Config::self().qmlEngine(), this))
 {
     init();

src/private/quick/FloatingWindowQuick_p.h

@@ -22,7 +22,7 @@ class DOCKS_EXPORT FloatingWindowQuick : public FloatingWindow
 {
     Q_OBJECT
 public:
-    explicit FloatingWindowQuick(MainWindowBase *parent = nullptr);
+    explicit FloatingWindowQuick(MainWindowBase *parent = nullptr, FloatingWindowFlags flags = FloatingWindowFlag::FromGlobalConfig);
     explicit FloatingWindowQuick(Frame *frame, QRect suggestedGeometry, MainWindowBase *parent = nullptr);
     ~FloatingWindowQuick();
 

src/private/widgets/FloatingWindowWidget.cpp

@@ -15,6 +15,7 @@
 #include "../Logging_p.h"
 #include "../TitleBar_p.h"
 #include "../Utils_p.h"
+#include "KDDockWidgets.h"
 
 #include <QApplication>
 #include <QPainter>
@@ -24,8 +25,9 @@
 
 using namespace KDDockWidgets;
 
-FloatingWindowWidget::FloatingWindowWidget(QRect suggestedGeometry, MainWindowBase *parent)
+FloatingWindowWidget::FloatingWindowWidget(QRect suggestedGeometry, MainWindowBase *parent,
-    : FloatingWindow(suggestedGeometry, parent)
+                                           FloatingWindowFlags flags)
+    : FloatingWindow(suggestedGeometry, parent, flags)
     , m_vlayout(new QVBoxLayout(this))
 {
     init();

src/private/widgets/FloatingWindowWidget_p.h

@@ -24,7 +24,8 @@ class DOCKS_EXPORT FloatingWindowWidget : public FloatingWindow
 {
     Q_OBJECT
 public:
-    explicit FloatingWindowWidget(QRect suggestedGeometry, MainWindowBase *parent = nullptr);
+    explicit FloatingWindowWidget(QRect suggestedGeometry, MainWindowBase *parent = nullptr,
+                                  FloatingWindowFlags flags = FloatingWindowFlag::FromGlobalConfig);
     explicit FloatingWindowWidget(Frame *frame, QRect suggestedGeometry, MainWindowBase *parent = nullptr);
 
 protected:

tests/tst_docks.cpp

@@ -18,6 +18,8 @@
 #include "DockWidgetBase_p.h"
 #include "DropAreaWithCentralFrame_p.h"
 #include "Frame_p.h"
+#include "KDDockWidgets.h"
+#include "LayoutSaver.h"
 #include "LayoutSaver_p.h"
 #include "MDILayoutWidget_p.h"
 #include "MainWindowMDI.h"
@@ -7852,3 +7854,64 @@ void TestDocks::tst_persistentCentralWidget()
 
     QVERIFY(saver.restoreLayout(saved));
 }
+
+void TestDocks::tst_setFloatingWindowFlags()
+{
+    {
+        EnsureTopLevelsDeleted e;
+        auto dock1 = createDockWidget("1", new QPushButton("1"), {}, {}, false);
+        auto dock2 = createDockWidget("2", new QPushButton("2"), {}, {}, false);
+
+        dock1->setFloatingWindowFlags(FloatingWindowFlag::TitleBarHasMinimizeButton);
+        dock2->setFloatingWindowFlags(FloatingWindowFlag::TitleBarHasMaximizeButton);
+
+        dock1->show();
+        dock2->show();
+
+        QVERIFY(dock1->isFloating());
+        QVERIFY(dock2->isFloating());
+
+        auto tb1 = dock1->titleBar();
+        auto tb2 = dock2->titleBar();
+        QVERIFY(tb1->isVisible());
+        QVERIFY(tb2->isVisible());
+
+        QVERIFY(tb1->supportsMinimizeButton());
+        QVERIFY(!tb1->supportsMaximizeButton());
+        QVERIFY(!tb2->supportsMinimizeButton());
+        QVERIFY(tb2->supportsMaximizeButton());
+
+        LayoutSaver saver;
+        const QByteArray saved = saver.serializeLayout();
+
+        dock1->close();
+        dock2->close();
+
+        saver.restoreLayout(saved);
+
+        tb1 = dock1->titleBar();
+        tb2 = dock2->titleBar();
+        QVERIFY(tb1->isVisible());
+        QVERIFY(tb2->isVisible());
+
+        QVERIFY(tb1->supportsMinimizeButton());
+        QVERIFY(!tb1->supportsMaximizeButton());
+        QVERIFY(!tb2->supportsMinimizeButton());
+        QVERIFY(tb2->supportsMaximizeButton());
+    }
+
+    {
+        EnsureTopLevelsDeleted e;
+        auto dock1 = createDockWidget("1", new QPushButton("1"), {}, {}, false);
+        auto dock2 = createDockWidget("2", new QPushButton("2"), {}, {}, false);
+
+        dock1->setFloatingWindowFlags(FloatingWindowFlag::UseQtWindow);
+        dock2->setFloatingWindowFlags(FloatingWindowFlag::UseQtTool);
+
+        dock1->show();
+        dock2->show();
+
+        QVERIFY(dock1->window()->windowFlags() & Qt::Window);
+        QVERIFY(dock2->window()->windowFlags() & Qt::Tool);
+    }
+}

tests/tst_docks.h

@@ -246,6 +246,7 @@ private Q_SLOTS:
     void tst_addMDIDockWidget();
     void tst_redockToMDIRestoresPosition();
     void tst_persistentCentralWidget();
+    void tst_setFloatingWindowFlags();
 
 #ifdef KDDOCKWIDGETS_QTWIDGETS
     // TODO: Port these to QtQuick