Add Advanced Docking System library

This library is a fork of the following repository https://github.com/githubuser0xFFFF/Qt-Advanced-Docking-System Development started from the following commit 1de42a9766134eecd2611c2b4e209d3e0ede74d2 Incorporate all commits until 3ffbbfb6d01ff211d8349027221a19b1419296b5 - Rename variables and files to follow the Qt style guide - General code cleanup (remove goto, fix typos, add overrides, remove explicit slots specifier, replace string-based with functor-based connections, replace dynamic_cast with qobject_cast) - Replace most preprocessor instructions Q_OS_LINUX/Q_OS_MACOS with Utils::HostOsInfo - Remove all QT_VERSION preprocessor instructions below 5.11 - Change loading and storage of workspaces. Store workspaces in separate file instead of a list in the Settings.ini - Add workspace dialog, model and view for managing workspaces - Rename XML tags and use enum/bool instead of ascii art/numbers as attribute values. Use base64 instead of hex for storing geometry info - Remove internal style sheets - Add more build systems (qmake, qbs) - Adapt copyright header - Remove unix specific build rules - Replace ADS_PRINT with QLoggingCategory - Replace Java-style with STL-style iterators Change-Id: Icf8c2fbaccec9680df83c6e2100e3446a090a437 Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
2020-01-24 17:13:32 +01:00
parent 61932b5d4b
commit 8f686e985c
54 changed files with 13152 additions and 0 deletions
--- a/src/libs/advanceddockingsystem/dockwidget.cpp
+++ b/src/libs/advanceddockingsystem/dockwidget.cpp
@@ -0,0 +1,625 @@
+/****************************************************************************
+**
+** Copyright (C) 2020 Uwe Kindler
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of Qt Creator.
+**
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 or (at your option) any later version.
+** The licenses are as published by the Free Software Foundation
+** and appearing in the file LICENSE.LGPLv21 included in the packaging
+** of this file. Please review the following information to ensure
+** the GNU Lesser General Public License version 2.1 requirements
+** will be met: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 or (at your option) any later version
+** approved by the KDE Free Qt Foundation. The licenses are as published by
+** the Free Software Foundation and appearing in the file LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+****************************************************************************/
+
+#include "dockwidget.h"
+
+#include "ads_globals.h"
+#include "dockareawidget.h"
+#include "dockcomponentsfactory.h"
+#include "dockcontainerwidget.h"
+#include "dockmanager.h"
+#include "docksplitter.h"
+#include "dockwidgettab.h"
+#include "floatingdockcontainer.h"
+
+#include <QAction>
+#include <QBoxLayout>
+#include <QEvent>
+#include <QLoggingCategory>
+#include <QPointer>
+#include <QScrollArea>
+#include <QSplitter>
+#include <QStack>
+#include <QTextStream>
+#include <QToolBar>
+#include <QXmlStreamWriter>
+
+static Q_LOGGING_CATEGORY(adsLog, "qtc.qmldesigner.advanceddockingsystem", QtDebugMsg)
+
+namespace ADS
+{
+    /**
+     * Private data class of DockWidget class (pimpl)
+     */
+    struct DockWidgetPrivate
+    {
+        DockWidget *q = nullptr;
+        QBoxLayout *m_layout = nullptr;
+        QWidget *m_widget = nullptr;
+        DockWidgetTab *m_tabWidget = nullptr;
+        DockWidget::DockWidgetFeatures m_features = DockWidget::DefaultDockWidgetFeatures;
+        DockManager *m_dockManager = nullptr;
+        DockAreaWidget *m_dockArea = nullptr;
+        QAction *m_toggleViewAction = nullptr;
+        bool m_closed = false;
+        QScrollArea *m_scrollArea = nullptr;
+        QToolBar *m_toolBar = nullptr;
+        Qt::ToolButtonStyle m_toolBarStyleDocked = Qt::ToolButtonIconOnly;
+        Qt::ToolButtonStyle m_toolBarStyleFloating = Qt::ToolButtonTextUnderIcon;
+        QSize m_toolBarIconSizeDocked = QSize(16, 16);
+        QSize m_toolBarIconSizeFloating = QSize(24, 24);
+        bool m_isFloatingTopLevel = false;
+        QList<QAction *> m_titleBarActions;
+
+        /**
+         * Private data constructor
+         */
+        DockWidgetPrivate(DockWidget *parent);
+
+        /**
+         * Show dock widget
+         */
+        void showDockWidget();
+
+        /**
+         * Hide dock widget.
+         */
+        void hideDockWidget();
+
+        /**
+         * Hides a dock area if all dock widgets in the area are closed.
+         * This function updates the current selected tab and hides the parent
+         * dock area if it is empty
+         */
+        void updateParentDockArea();
+
+        /**
+         * Setup the top tool bar
+         */
+        void setupToolBar();
+
+        /**
+         * Setup the main scroll area
+         */
+        void setupScrollArea();
+    };
+    // struct DockWidgetPrivate
+
+    DockWidgetPrivate::DockWidgetPrivate(DockWidget *parent)
+        : q(parent)
+    {}
+
+    void DockWidgetPrivate::showDockWidget()
+    {
+        if (!m_dockArea) {
+            FloatingDockContainer *floatingWidget = new FloatingDockContainer(q);
+            floatingWidget->resize(q->size());
+            floatingWidget->show();
+        } else {
+            m_dockArea->setCurrentDockWidget(q);
+            m_dockArea->toggleView(true);
+            m_tabWidget->show();
+            QSplitter *splitter = internal::findParent<QSplitter *>(m_dockArea);
+            while (splitter && !splitter->isVisible()) {
+                splitter->show();
+                splitter = internal::findParent<QSplitter *>(splitter);
+            }
+
+            DockContainerWidget *container = m_dockArea->dockContainer();
+            if (container->isFloating()) {
+                FloatingDockContainer *floatingWidget
+                    = internal::findParent<FloatingDockContainer *>(container);
+                floatingWidget->show();
+            }
+        }
+    }
+
+    void DockWidgetPrivate::hideDockWidget()
+    {
+        m_tabWidget->hide();
+        updateParentDockArea();
+    }
+
+    void DockWidgetPrivate::updateParentDockArea()
+    {
+        if (!m_dockArea) {
+            return;
+        }
+
+        auto nextDockWidget = m_dockArea->nextOpenDockWidget(q);
+        if (nextDockWidget) {
+            m_dockArea->setCurrentDockWidget(nextDockWidget);
+        } else {
+            m_dockArea->hideAreaWithNoVisibleContent();
+        }
+    }
+
+    void DockWidgetPrivate::setupToolBar()
+    {
+        m_toolBar = new QToolBar(q);
+        m_toolBar->setObjectName("dockWidgetToolBar");
+        m_layout->insertWidget(0, m_toolBar);
+        m_toolBar->setIconSize(QSize(16, 16));
+        m_toolBar->toggleViewAction()->setEnabled(false);
+        m_toolBar->toggleViewAction()->setVisible(false);
+        QObject::connect(q, &DockWidget::topLevelChanged, q, &DockWidget::setToolbarFloatingStyle);
+    }
+
+    void DockWidgetPrivate::setupScrollArea()
+    {
+        m_scrollArea = new QScrollArea(q);
+        m_scrollArea->setObjectName("dockWidgetScrollArea");
+        m_scrollArea->setWidgetResizable(true);
+        m_layout->addWidget(m_scrollArea);
+    }
+
+    DockWidget::DockWidget(const QString &uniqueId, QWidget *parent)
+        : QFrame(parent)
+        , d(new DockWidgetPrivate(this))
+    {
+        d->m_layout = new QBoxLayout(QBoxLayout::TopToBottom);
+        d->m_layout->setContentsMargins(0, 0, 0, 0);
+        d->m_layout->setSpacing(0);
+        setLayout(d->m_layout);
+        setWindowTitle(uniqueId); // temporarily use unique id as title
+        setObjectName(uniqueId);
+
+        d->m_tabWidget = componentsFactory()->createDockWidgetTab(this);
+        d->m_toggleViewAction = new QAction(uniqueId, this);
+        d->m_toggleViewAction->setCheckable(true);
+        connect(d->m_toggleViewAction, &QAction::triggered, this, &DockWidget::toggleView);
+        setToolbarFloatingStyle(false);
+    }
+
+    DockWidget::~DockWidget()
+    {
+        qCInfo(adsLog) << Q_FUNC_INFO;
+        delete d;
+    }
+
+    void DockWidget::setToggleViewActionChecked(bool checked)
+    {
+        QAction *action = d->m_toggleViewAction;
+        //action->blockSignals(true);
+        action->setChecked(checked);
+        //action->blockSignals(false);
+    }
+
+    void DockWidget::setWidget(QWidget *widget, eInsertMode insertMode)
+    {
+        QScrollArea *scrollAreaWidget = qobject_cast<QScrollArea *>(widget);
+        if (scrollAreaWidget || ForceNoScrollArea == insertMode) {
+            d->m_layout->addWidget(widget);
+            if (scrollAreaWidget && scrollAreaWidget->viewport()) {
+                scrollAreaWidget->viewport()->setProperty("dockWidgetContent", true);
+            }
+        } else {
+            d->setupScrollArea();
+            d->m_scrollArea->setWidget(widget);
+        }
+
+        d->m_widget = widget;
+        d->m_widget->setProperty("dockWidgetContent", true);
+    }
+
+    QWidget *DockWidget::takeWidget()
+    {
+        // TODO Shouldn't m_widget being set to nullptr?!
+        d->m_scrollArea->takeWidget();
+        d->m_layout->removeWidget(d->m_widget);
+        d->m_widget->setParent(nullptr);
+        return d->m_widget;
+    }
+
+    QWidget *DockWidget::widget() const { return d->m_widget; }
+
+    DockWidgetTab *DockWidget::tabWidget() const { return d->m_tabWidget; }
+
+    void DockWidget::setFeatures(DockWidgetFeatures features)
+    {
+        if (d->m_features == features) {
+            return;
+        }
+        d->m_features = features;
+        emit featuresChanged(d->m_features);
+        d->m_tabWidget->onDockWidgetFeaturesChanged();
+    }
+
+    void DockWidget::setFeature(DockWidgetFeature flag, bool on)
+    {
+        auto currentFeatures = features();
+        internal::setFlag(currentFeatures, flag, on);
+        setFeatures(currentFeatures);
+    }
+
+    DockWidget::DockWidgetFeatures DockWidget::features() const { return d->m_features; }
+
+    DockManager *DockWidget::dockManager() const { return d->m_dockManager; }
+
+    void DockWidget::setDockManager(DockManager *dockManager) { d->m_dockManager = dockManager; }
+
+    DockContainerWidget *DockWidget::dockContainer() const
+    {
+        if (d->m_dockArea) {
+            return d->m_dockArea->dockContainer();
+        } else {
+            return nullptr;
+        }
+    }
+
+    DockAreaWidget *DockWidget::dockAreaWidget() const { return d->m_dockArea; }
+
+    bool DockWidget::isFloating() const
+    {
+        if (!isInFloatingContainer()) {
+            return false;
+        }
+
+        return dockContainer()->topLevelDockWidget() == this;
+    }
+
+    bool DockWidget::isInFloatingContainer() const
+    {
+        auto container = dockContainer();
+        if (!container) {
+            return false;
+        }
+
+        if (!container->isFloating()) {
+            return false;
+        }
+
+        return true;
+    }
+
+    bool DockWidget::isClosed() const { return d->m_closed; }
+
+    QAction *DockWidget::toggleViewAction() const { return d->m_toggleViewAction; }
+
+    void DockWidget::setToggleViewActionMode(eToggleViewActionMode mode)
+    {
+        if (ActionModeToggle == mode) {
+            d->m_toggleViewAction->setCheckable(true);
+            d->m_toggleViewAction->setIcon(QIcon());
+        } else {
+            d->m_toggleViewAction->setCheckable(false);
+            d->m_toggleViewAction->setIcon(d->m_tabWidget->icon());
+        }
+    }
+
+    void DockWidget::toggleView(bool open)
+    {
+        // If the toggle view action mode is ActionModeShow, then Open is always
+        // true if the sender is the toggle view action
+        QAction *action = qobject_cast<QAction *>(sender());
+        if (action == d->m_toggleViewAction && !d->m_toggleViewAction->isCheckable()) {
+            open = true;
+        }
+        // If the dock widget state is different, then we really need to toggle
+        // the state. If we are in the right state, then we simply make this
+        // dock widget the current dock widget
+        if (d->m_closed != !open) {
+            toggleViewInternal(open);
+        } else if (open && d->m_dockArea) {
+            d->m_dockArea->setCurrentDockWidget(this);
+        }
+    }
+
+    void DockWidget::toggleViewInternal(bool open)
+    {
+        DockContainerWidget *dockContainerWidget = dockContainer();
+        DockWidget *topLevelDockWidgetBefore = dockContainerWidget
+                                                   ? dockContainerWidget->topLevelDockWidget()
+                                                   : nullptr;
+
+        if (open) {
+            d->showDockWidget();
+        } else {
+            d->hideDockWidget();
+        }
+        d->m_closed = !open;
+        //d->m_toggleViewAction->blockSignals(true);
+        d->m_toggleViewAction->setChecked(open);
+        //d->m_toggleViewAction->blockSignals(false);
+        if (d->m_dockArea) {
+            d->m_dockArea->toggleDockWidgetView(this, open);
+        }
+
+        if (open && topLevelDockWidgetBefore) {
+            DockWidget::emitTopLevelEventForWidget(topLevelDockWidgetBefore, false);
+        }
+
+        // Here we need to call the dockContainer() function again, because if
+        // this dock widget was unassigned before the call to showDockWidget() then
+        // it has a dock container now
+        dockContainerWidget = dockContainer();
+        DockWidget *topLevelDockWidgetAfter = dockContainerWidget
+                                                  ? dockContainerWidget->topLevelDockWidget()
+                                                  : nullptr;
+        DockWidget::emitTopLevelEventForWidget(topLevelDockWidgetAfter, true);
+        FloatingDockContainer *floatingContainer = dockContainerWidget->floatingWidget();
+        if (floatingContainer) {
+            floatingContainer->updateWindowTitle();
+        }
+
+        if (!open) {
+            emit closed();
+        }
+        emit viewToggled(open);
+    }
+
+    void DockWidget::setDockArea(DockAreaWidget *dockArea)
+    {
+        d->m_dockArea = dockArea;
+        d->m_toggleViewAction->setChecked(dockArea != nullptr && !this->isClosed());
+    }
+
+    void DockWidget::saveState(QXmlStreamWriter &stream) const
+    {
+        stream.writeStartElement("widget");
+        stream.writeAttribute("name", objectName());
+        stream.writeAttribute("closed", QVariant::fromValue(d->m_closed).toString());
+        stream.writeEndElement();
+    }
+
+    void DockWidget::flagAsUnassigned()
+    {
+        d->m_closed = true;
+        setParent(d->m_dockManager);
+        setVisible(false);
+        setDockArea(nullptr);
+        tabWidget()->setParent(this);
+    }
+
+    bool DockWidget::event(QEvent *event)
+    {
+        switch (event->type()) {
+        case QEvent::Hide:
+            emit visibilityChanged(false);
+            break;
+
+        case QEvent::Show:
+            emit visibilityChanged(geometry().right() >= 0 && geometry().bottom() >= 0);
+            break;
+
+        case QEvent::WindowTitleChange :
+            {
+                const auto title = windowTitle();
+                if (d->m_tabWidget) {
+                    d->m_tabWidget->setText(title);
+                }
+                if (d->m_toggleViewAction) {
+                    d->m_toggleViewAction->setText(title);
+                }
+                if (d->m_dockArea) {
+                    d->m_dockArea->markTitleBarMenuOutdated(); // update tabs menu
+                }
+                emit titleChanged(title);
+            }
+            break;
+
+        default:
+            break;
+        }
+
+        return Super::event(event);
+    }
+
+#ifndef QT_NO_TOOLTIP
+    void DockWidget::setTabToolTip(const QString &text)
+    {
+        if (d->m_tabWidget) {
+            d->m_tabWidget->setToolTip(text);
+        }
+        if (d->m_toggleViewAction) {
+            d->m_toggleViewAction->setToolTip(text);
+        }
+        if (d->m_dockArea) {
+            d->m_dockArea->markTitleBarMenuOutdated(); //update tabs menu
+        }
+    }
+#endif
+
+    void DockWidget::setIcon(const QIcon &icon)
+    {
+        d->m_tabWidget->setIcon(icon);
+        if (!d->m_toggleViewAction->isCheckable()) {
+            d->m_toggleViewAction->setIcon(icon);
+        }
+    }
+
+    QIcon DockWidget::icon() const { return d->m_tabWidget->icon(); }
+
+    QToolBar *DockWidget::toolBar() const { return d->m_toolBar; }
+
+    QToolBar *DockWidget::createDefaultToolBar()
+    {
+        if (!d->m_toolBar) {
+            d->setupToolBar();
+        }
+
+        return d->m_toolBar;
+    }
+
+    void DockWidget::setToolBar(QToolBar *toolBar)
+    {
+        if (d->m_toolBar) {
+            delete d->m_toolBar;
+        }
+
+        d->m_toolBar = toolBar;
+        d->m_layout->insertWidget(0, d->m_toolBar);
+        connect(this, &DockWidget::topLevelChanged, this, &DockWidget::setToolbarFloatingStyle);
+        setToolbarFloatingStyle(isFloating());
+    }
+
+    void DockWidget::setToolBarStyle(Qt::ToolButtonStyle style, eState state)
+    {
+        if (StateFloating == state) {
+            d->m_toolBarStyleFloating = style;
+        } else {
+            d->m_toolBarStyleDocked = style;
+        }
+
+        setToolbarFloatingStyle(isFloating());
+    }
+
+    Qt::ToolButtonStyle DockWidget::toolBarStyle(eState state) const
+    {
+        if (StateFloating == state) {
+            return d->m_toolBarStyleFloating;
+        } else {
+            return d->m_toolBarStyleDocked;
+        }
+    }
+
+    void DockWidget::setToolBarIconSize(const QSize &iconSize, eState state)
+    {
+        if (StateFloating == state) {
+            d->m_toolBarIconSizeFloating = iconSize;
+        } else {
+            d->m_toolBarIconSizeDocked = iconSize;
+        }
+
+        setToolbarFloatingStyle(isFloating());
+    }
+
+    QSize DockWidget::toolBarIconSize(eState state) const
+    {
+        if (StateFloating == state) {
+            return d->m_toolBarIconSizeFloating;
+        } else {
+            return d->m_toolBarIconSizeDocked;
+        }
+    }
+
+    void DockWidget::setToolbarFloatingStyle(bool floating)
+    {
+        if (!d->m_toolBar) {
+            return;
+        }
+
+        auto iconSize = floating ? d->m_toolBarIconSizeFloating : d->m_toolBarIconSizeDocked;
+        if (iconSize != d->m_toolBar->iconSize()) {
+            d->m_toolBar->setIconSize(iconSize);
+        }
+
+        auto buttonStyle = floating ? d->m_toolBarStyleFloating : d->m_toolBarStyleDocked;
+        if (buttonStyle != d->m_toolBar->toolButtonStyle()) {
+            d->m_toolBar->setToolButtonStyle(buttonStyle);
+        }
+    }
+
+    void DockWidget::emitTopLevelEventForWidget(DockWidget *topLevelDockWidget, bool floating)
+    {
+        if (topLevelDockWidget) {
+            topLevelDockWidget->dockAreaWidget()->updateTitleBarVisibility();
+            topLevelDockWidget->emitTopLevelChanged(floating);
+        }
+    }
+
+    void DockWidget::emitTopLevelChanged(bool floating)
+    {
+        if (floating != d->m_isFloatingTopLevel) {
+            d->m_isFloatingTopLevel = floating;
+            emit topLevelChanged(d->m_isFloatingTopLevel);
+        }
+    }
+
+    void DockWidget::setClosedState(bool closed) { d->m_closed = closed; }
+
+    QSize DockWidget::minimumSizeHint() const { return QSize(60, 40); }
+
+    void DockWidget::setFloating()
+    {
+        if (isClosed()) {
+            return;
+        }
+        d->m_tabWidget->detachDockWidget();
+    }
+
+    void DockWidget::deleteDockWidget()
+    {
+        dockManager()->removeDockWidget(this);
+        deleteLater();
+        d->m_closed = true;
+    }
+
+    void DockWidget::closeDockWidget()
+    {
+        closeDockWidgetInternal(true);
+    }
+
+    bool DockWidget::closeDockWidgetInternal(bool forceClose)
+    {
+        if (!forceClose) {
+            emit closeRequested();
+        }
+
+        if (!forceClose && features().testFlag(DockWidget::CustomCloseHandling)) {
+            return false;
+        }
+
+        if (features().testFlag(DockWidget::DockWidgetDeleteOnClose)) {
+            // If the dock widget is floating, then we check if we also need to
+            // delete the floating widget
+            if (isFloating()) {
+                FloatingDockContainer* floatingWidget = internal::findParent<
+                        FloatingDockContainer *>(this);
+                if (floatingWidget->dockWidgets().count() == 1) {
+                    floatingWidget->deleteLater();
+                } else {
+                    floatingWidget->hide();
+                }
+            }
+            deleteDockWidget();
+        } else {
+            toggleView(false);
+        }
+
+        return true;
+    }
+
+    void DockWidget::setTitleBarActions(QList<QAction *> actions)
+    {
+        d->m_titleBarActions = actions;
+    }
+
+    QList<QAction *> DockWidget::titleBarActions() const
+    {
+        return d->m_titleBarActions;
+    }
+
+} // namespace ADS