ADS: Cleanup workspace manager workflow

- Add workspace presets
- Add reset button to workspace manager
- Fix last workspace settings save/restore
- Move functionality from DesignModeWidget to DockManager
- Remove factory default workspace
- Cleanup a few if statements

Task-number: QDS-1699
Change-Id: I282dd6162a5a36041f8cd2aacd7407750d54cc22
Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>

8 files changed, 286 insertions, 140 deletions

diff --git a/src/libs/advanceddockingsystem/dockmanager.cpp b/src/libs/advanceddockingsystem/dockmanager.cpp
index 63c71c7a8a..80e4588125 100644
--- a/src/libs/advanceddockingsystem/dockmanager.cpp
+++ b/src/libs/advanceddockingsystem/dockmanager.cpp
@@ -92,10 +92,12 @@ namespace ADS
         QString m_workspaceName;
         bool m_workspaceListDirty = true;
         QStringList m_workspaces;
+        QSet<QString> m_workspacePresets;
         QHash<QString, QDateTime> m_workspaceDateTimes;
         QString m_workspaceToRestoreAtStartup;
         bool m_autorestoreLastWorkspace; // This option is set in the Workspace Manager!
         QSettings *m_settings = nullptr;
+        QString m_workspacePresetsPath;
 
         /**
          * Private data constructor
@@ -127,16 +129,14 @@ namespace ADS
         void hideFloatingWidgets()
         {
             // Hide updates of floating widgets from user
-            for (auto floatingWidget : m_floatingWidgets) { // TODO qAsConst()
+            for (auto floatingWidget : m_floatingWidgets) // TODO qAsConst()
                 floatingWidget->hide();
-            }
         }
 
         void markDockWidgetsDirty()
         {
-            for (auto dockWidget : m_dockWidgetsMap) { // TODO qAsConst()
+            for (auto dockWidget : m_dockWidgetsMap) // TODO qAsConst()
                 dockWidget->setProperty("dirty", true);
-            }
         }
 
         /**
@@ -153,9 +153,8 @@ namespace ADS
 
     bool DockManagerPrivate::restoreContainer(int index, DockingStateReader &stream, bool testing)
     {
-        if (testing) {
+        if (testing)
             index = 0;
-        }
 
         bool result = false;
         if (index >= m_containers.count()) {
@@ -183,22 +182,21 @@ namespace ADS
     {
         Q_UNUSED(version) // TODO version is not needed, why is it in here in the first place?
 
-        if (state.isEmpty()) {
+        if (state.isEmpty())
             return false;
-        }
+
         DockingStateReader stateReader(state);
-        stateReader.readNextStartElement();
         if (!stateReader.readNextStartElement())
             return false;
-        if (stateReader.name() != "QtAdvancedDockingSystem") {
+
+        if (stateReader.name() != "QtAdvancedDockingSystem")
             return false;
-        }
+
         qCInfo(adsLog) << stateReader.attributes().value("version");
         bool ok;
         int v = stateReader.attributes().value("version").toInt(&ok);
-        if (!ok || v > CurrentVersion) {
+        if (!ok || v > CurrentVersion)
             return false;
-        }
 
         stateReader.setFileVersion(v);
         bool result = true;
@@ -210,9 +208,9 @@ namespace ADS
         while (stateReader.readNextStartElement()) {
             if (stateReader.name() == "container") {
                 result = restoreContainer(dockContainerCount, stateReader, testing);
-                if (!result) {
+                if (!result)
                     break;
-                }
+
                 dockContainerCount++;
             }
         }
@@ -265,9 +263,9 @@ namespace ADS
 
                 if (!dockWidget || dockWidget->isClosed()) {
                     int index = dockArea->indexOfFirstOpenDockWidget();
-                    if (index < 0) {
+                    if (index < 0)
                         continue;
-                    }
+
                     dockArea->setCurrentIndex(index);
                 } else {
                     dockArea->internalSetCurrentDockWidget(dockWidget);
@@ -336,25 +334,17 @@ namespace ADS
         d->m_dockAreaOverlay = new DockOverlay(this, DockOverlay::ModeDockAreaOverlay);
         d->m_containerOverlay = new DockOverlay(this, DockOverlay::ModeContainerOverlay);
         d->m_containers.append(this);
-        //d->loadStylesheet();
     }
 
     DockManager::~DockManager()
     {
-        // If the factory default workspace is still loaded, create a default workspace just in case
-        // the layout changed as there is no tracking of layout changes.
-        if (isFactoryDefaultWorkspace(d->m_workspaceName)
-            && !isDefaultWorkspace(d->m_workspaceName)) {
-            createWorkspace(Constants::DEFAULT_NAME);
-            openWorkspace(Constants::DEFAULT_NAME);
-        }
-
         emit aboutToUnloadWorkspace(d->m_workspaceName);
         save();
+        saveStartupWorkspace();
 
-        for (auto floatingWidget : d->m_floatingWidgets) {
+        for (auto floatingWidget : d->m_floatingWidgets)
             delete floatingWidget;
-        }
+
         delete d;
     }
 
@@ -385,6 +375,8 @@ namespace ADS
 
     void DockManager::setSettings(QSettings *settings) { d->m_settings = settings; }
 
+    void DockManager::setWorkspacePresetsPath(const QString &path) { d->m_workspacePresetsPath = path; }
+
     DockAreaWidget *DockManager::addDockWidget(DockWidgetArea area,
                                                DockWidget *dockWidget,
                                                DockAreaWidget *dockAreaWidget)
@@ -393,6 +385,24 @@ namespace ADS
         return DockContainerWidget::addDockWidget(area, dockWidget, dockAreaWidget);
     }
 
+    void DockManager::initialize()
+    {
+        syncWorkspacePresets();
+
+        QString workspace = ADS::Constants::DEFAULT_WORKSPACE;
+
+        // Determine workspace to restore at startup
+        if (autoRestorLastWorkspace()) {
+            QString lastWS = lastWorkspace();
+            if (!lastWS.isEmpty() && workspaces().contains(lastWS))
+                workspace = lastWS;
+            else
+                qDebug() << "Couldn't restore last workspace!";
+        }
+
+        openWorkspace(workspace);
+    }
+
     DockAreaWidget *DockManager::addDockWidgetTab(DockWidgetArea area, DockWidget *dockWidget)
     {
         DockAreaWidget *areaWidget = lastAddedDockAreaWidget(area);
@@ -415,9 +425,8 @@ namespace ADS
     {
         d->m_dockWidgetsMap.insert(dockWidget->objectName(), dockWidget);
         DockAreaWidget *oldDockArea = dockWidget->dockAreaWidget();
-        if (oldDockArea) {
+        if (oldDockArea)
             oldDockArea->removeDockWidget(dockWidget);
-        }
 
         dockWidget->setDockManager(this);
         FloatingDockContainer *floatingWidget = new FloatingDockContainer(dockWidget);
@@ -480,9 +489,8 @@ namespace ADS
         stream.writeStartElement("QtAdvancedDockingSystem");
         stream.writeAttribute("version", QString::number(version));
         stream.writeAttribute("containers", QString::number(d->m_containers.count()));
-        for (auto container : d->m_containers) {
+        for (auto container : d->m_containers)
             container->saveState(stream);
-        }
 
         stream.writeEndElement();
         stream.writeEndDocument();
@@ -493,9 +501,8 @@ namespace ADS
     {
         // Prevent multiple calls as long as state is not restore. This may
         // happen, if QApplication::processEvents() is called somewhere
-        if (d->m_restoringState) {
+        if (d->m_restoringState)
             return false;
-        }
 
         // We hide the complete dock manager here. Restoring the state means
         // that DockWidgets are removed from the DockArea internal stack layout
@@ -506,17 +513,16 @@ namespace ADS
         // events until this function is finished, the user will not see this
         // hiding
         bool isHidden = this->isHidden();
-        if (!isHidden) {
+        if (!isHidden)
             hide();
-        }
+
         d->m_restoringState = true;
         emit restoringState();
         bool result = d->restoreState(state, version);
         d->m_restoringState = false;
         emit stateRestored();
-        if (!isHidden) {
+        if (!isHidden)
             show();
-        }
 
         return result;
     }
@@ -524,13 +530,12 @@ namespace ADS
     void DockManager::showEvent(QShowEvent *event)
     {
         Super::showEvent(event);
-        if (d->m_uninitializedFloatingWidgets.empty()) {
+        if (d->m_uninitializedFloatingWidgets.empty())
             return;
-        }
 
-        for (auto floatingWidget : d->m_uninitializedFloatingWidgets) {
+        for (auto floatingWidget : d->m_uninitializedFloatingWidgets)
             floatingWidget->show();
-        }
+
         d->m_uninitializedFloatingWidgets.clear();
     }
 
@@ -553,8 +558,7 @@ namespace ADS
 
     void DockManager::showWorkspaceMananger()
     {
-        // Save current workspace
-        save();
+        save(); // Save current workspace
 
         WorkspaceDialog workspaceDialog(this, parentWidget());
         workspaceDialog.setAutoLoadWorkspace(autoRestorLastWorkspace());
@@ -565,30 +569,22 @@ namespace ADS
                                 workspaceDialog.autoLoadWorkspace());
     }
 
-    bool DockManager::isFactoryDefaultWorkspace(const QString &workspace) const
+    bool DockManager::isWorkspacePreset(const QString &workspace) const
     {
-        return workspace == QLatin1String(Constants::FACTORY_DEFAULT_NAME);
-    }
-
-    bool DockManager::isDefaultWorkspace(const QString &workspace) const
-    {
-        return workspace == QLatin1String(Constants::DEFAULT_NAME);
+        return d->m_workspacePresets.contains(workspace);
     }
 
     bool DockManager::save()
     {
-        if (isFactoryDefaultWorkspace(activeWorkspace()))
-            return true;
-
         emit aboutToSaveWorkspace();
 
-        bool result = write(saveState(), parentWidget());
+        bool result = write(activeWorkspace(), saveState(), parentWidget());
         if (result) {
             d->m_workspaceDateTimes.insert(activeWorkspace(), QDateTime::currentDateTime());
         } else {
             QMessageBox::warning(parentWidget(),
-                                 tr("Cannot Save Session"),
-                                 tr("Could not save session to file %1")
+                                 tr("Cannot Save Workspace"),
+                                 tr("Could not save workspace to file %1")
                                      .arg(workspaceNameToFileName(d->m_workspaceName)
                                               .toUserOutput()));
         }
@@ -624,15 +620,13 @@ namespace ADS
             QFileInfoList workspaceFiles
                 = workspaceDir.entryInfoList(QStringList() << QLatin1String("*.wrk"),
                                              QDir::NoFilter,
-                                             QDir::Time); // TODO Choose different extension
+                                             QDir::Time);
             for (const QFileInfo &fileInfo : workspaceFiles) {
                 QString filename = fileInfo.completeBaseName();
                 filename.replace("_", " ");
                 d->m_workspaceDateTimes.insert(filename, fileInfo.lastModified());
-                //if (name != QLatin1String(Constants::DEFAULT_NAME))
                 tmp.insert(filename);
             }
-            //d->m_workspaces.prepend(QLatin1String(Constants::DEFAULT_NAME));
 
             d->m_workspaceListDirty = false;
             d->m_workspaces = Utils::toList(tmp);
@@ -640,6 +634,23 @@ namespace ADS
         return d->m_workspaces;
     }
 
+    QSet<QString> DockManager::workspacePresets() const
+    {
+        if (d->m_workspacePresets.isEmpty()) {
+            QDir workspacePresetsDir(d->m_workspacePresetsPath);
+            QFileInfoList workspacePresetsFiles
+                = workspacePresetsDir.entryInfoList(QStringList() << QLatin1String("*.wrk"),
+                                                    QDir::NoFilter,
+                                                    QDir::Time);
+            for (const QFileInfo &fileInfo : workspacePresetsFiles) {
+                QString filename = fileInfo.completeBaseName();
+                filename.replace("_", " ");
+                d->m_workspacePresets.insert(filename);
+            }
+        }
+        return d->m_workspacePresets;
+    }
+
     QDateTime DockManager::workspaceDateTime(const QString &workspace) const
     {
         return d->m_workspaceDateTimes.value(workspace);
@@ -661,12 +672,21 @@ namespace ADS
     {
         if (workspaces().contains(workspace))
             return false;
-        d->m_workspaces.insert(1, workspace);
-        d->m_workspaceDateTimes.insert(workspace, QDateTime::currentDateTime());
 
-        emit workspaceListChanged();
+        bool result = write(workspace, saveState(), parentWidget());
+        if (result) {
+            d->m_workspaces.insert(1, workspace);
+            d->m_workspaceDateTimes.insert(workspace, QDateTime::currentDateTime());
+            emit workspaceListChanged();
+        } else {
+            QMessageBox::warning(parentWidget(),
+                                 tr("Cannot Save Workspace"),
+                                 tr("Could not save workspace to file %1")
+                                     .arg(workspaceNameToFileName(d->m_workspaceName)
+                                              .toUserOutput()));
+        }
 
-        return true;
+        return result;
     }
 
     bool DockManager::openWorkspace(const QString &workspace)
@@ -674,7 +694,7 @@ namespace ADS
         // Do nothing if we have that workspace already loaded, exception if the
         // workspace is the default virgin workspace we still want to be able to
         // load the default workspace.
-        if (workspace == d->m_workspaceName) // && !isFactoryDefaultWorkspace(workspace))
+        if (workspace == d->m_workspaceName && !isWorkspacePreset(workspace))
             return true;
 
         if (!workspaces().contains(workspace))
@@ -684,38 +704,45 @@ namespace ADS
         if (!d->m_workspaceName.isEmpty()) {
             // Allow everyone to set something in the workspace and before saving
             emit aboutToUnloadWorkspace(d->m_workspaceName);
-            if (!save()) {
+            if (!save())
                 return false;
-            }
         }
 
         // Try loading the file
-        QByteArray data;
-        Utils::FilePath fileName = workspaceNameToFileName(workspace);
-        if (fileName.exists()) {
-            QFile file(fileName.toString());
-            if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
-                QMessageBox::warning(parentWidget(),
-                                     tr("Cannot Restore Workspace"),
-                                     tr("Could not restore workspace %1")
-                                         .arg(fileName.toUserOutput()));
-                return false;
-            }
-            data = file.readAll();
-            file.close();
-        }
+        QByteArray data = loadWorkspace(workspace);
+        if (data.isEmpty())
+            return false;
 
         emit openingWorkspace(workspace);
         // If data was loaded from file try to restore its state
-        if (!data.isNull() && !restoreState(data)) {
+        if (!data.isNull() && !restoreState(data))
             return false;
-        }
+
         d->m_workspaceName = workspace;
         emit workspaceLoaded(workspace);
 
         return true;
     }
 
+    bool DockManager::reloadActiveWorkspace()
+    {
+        if (!workspaces().contains(activeWorkspace()))
+            return false;
+
+        // Try loading the file
+        QByteArray data = loadWorkspace(activeWorkspace());
+        if (data.isEmpty())
+            return false;
+
+        // If data was loaded from file try to restore its state
+        if (!data.isNull() && !restoreState(data))
+            return false;
+
+        emit workspaceReloaded(activeWorkspace());
+
+        return true;
+    }
+
     /**
      * \brief Shows a dialog asking the user to confirm deleting the workspace \p workspace
      */
@@ -742,6 +769,7 @@ namespace ADS
         // Remove workspace from internal list
         if (!d->m_workspaces.contains(workspace))
             return false;
+
         d->m_workspaces.removeOne(workspace);
 
         emit workspacesRemoved();
@@ -752,8 +780,7 @@ namespace ADS
         if (fi.exists())
             return fi.remove();
 
-        return false; // TODO If we allow temporary workspaces without writing them to file
-        // directly, this needs to be true otherwise in all those cases it will return false.
+        return false;
     }
 
     void DockManager::deleteWorkspaces(const QStringList &workspaces)
@@ -787,36 +814,111 @@ namespace ADS
         return deleteWorkspace(original);
     }
 
-    bool DockManager::write(const QByteArray &data, QString *errorString) const
+    bool DockManager::resetWorkspacePreset(const QString &workspace)
     {
-        Utils::FilePath fileName = workspaceNameToFileName(activeWorkspace());
+        if (!isWorkspacePreset(workspace))
+            return false;
+
+        Utils::FilePath filename = workspaceNameToFileName(workspace);
+
+        if (!QFile::remove(filename.toString()))
+            return false;
+
+        QDir presetsDir(d->m_workspacePresetsPath);
+        QString presetName = workspace;
+        presetName.replace(" ", "_");
+        presetName.append(".wrk");
+
+        bool result = QFile::copy(presetsDir.filePath(presetName), filename.toString());
+        if (result)
+            d->m_workspaceDateTimes.insert(workspace, QDateTime::currentDateTime());
+
+        return result;
+    }
+
+    bool DockManager::write(const QString &workspace, const QByteArray &data, QString *errorString) const
+    {
+        Utils::FilePath filename = workspaceNameToFileName(workspace);
 
         QDir tmp;
-        tmp.mkpath(fileName.toFileInfo().path());
-        Utils::FileSaver fileSaver(fileName.toString(), QIODevice::Text);
-        if (!fileSaver.hasError()) {
+        tmp.mkpath(filename.toFileInfo().path());
+        Utils::FileSaver fileSaver(filename.toString(), QIODevice::Text);
+        if (!fileSaver.hasError())
             fileSaver.write(data);
-        }
+
         bool ok = fileSaver.finalize();
 
-        if (!ok && errorString) {
+        if (!ok && errorString)
             *errorString = fileSaver.errorString();
-        }
 
         return ok;
     }
 
-#ifdef QT_GUI_LIB
-    bool DockManager::write(const QByteArray &data, QWidget *parent) const
+    bool DockManager::write(const QString &workspace, const QByteArray &data, QWidget *parent) const
     {
         QString errorString;
-        const bool success = write(data, &errorString);
+        const bool success = write(workspace, data, &errorString);
         if (!success)
             QMessageBox::critical(parent,
                                   QCoreApplication::translate("Utils::FileSaverBase", "File Error"),
                                   errorString);
         return success;
     }
-#endif // QT_GUI_LIB
+
+    QByteArray DockManager::loadWorkspace(const QString &workspace) const
+    {
+        QByteArray data;
+        Utils::FilePath fileName = workspaceNameToFileName(workspace);
+        if (fileName.exists()) {
+            QFile file(fileName.toString());
+            if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
+                QMessageBox::warning(parentWidget(),
+                                     tr("Cannot Restore Workspace"),
+                                     tr("Could not restore workspace %1")
+                                         .arg(fileName.toUserOutput()));
+                return data;
+            }
+            data = file.readAll();
+            file.close();
+        }
+        return data;
+    }
+
+    void DockManager::syncWorkspacePresets()
+    {
+        // Get a list of all workspace presets
+        QSet<QString> presets = workspacePresets();
+
+        // Get a list of all available workspaces
+        QSet<QString> availableWorkspaces = Utils::toSet(workspaces());
+        presets.subtract(availableWorkspaces);
+
+        // Copy all missing workspace presets over to the local workspace folder
+        QDir presetsDir(d->m_workspacePresetsPath);
+        QDir workspaceDir(QFileInfo(d->m_settings->fileName()).path() + QLatin1String("/workspaces"));
+
+        for (const auto &preset : presets) {
+            QString filename = preset;
+            filename.replace(" ", "_");
+            filename.append(".wrk");
+
+            QString filePath = presetsDir.filePath(filename);
+            QFile file(filePath);
+
+            if (file.exists()) {
+                file.copy(workspaceDir.filePath(filename));
+                d->m_workspaceListDirty = true;
+            }
+        }
+
+        // After copying over missing workspace presets, update the workspace list
+        workspaces();
+    }
+
+    void DockManager::saveStartupWorkspace()
+    {
+        QTC_ASSERT(d->m_settings, return );
+        d->m_settings->setValue(Constants::STARTUP_WORKSPACE_SETTINGS_KEY, activeWorkspace());
+    }
 
 } // namespace ADS
diff --git a/src/libs/advanceddockingsystem/dockmanager.h b/src/libs/advanceddockingsystem/dockmanager.h
index 721f7e7602..e52646437f 100644
--- a/src/libs/advanceddockingsystem/dockmanager.h
+++ b/src/libs/advanceddockingsystem/dockmanager.h
@@ -60,8 +60,7 @@ QT_END_NAMESPACE
 namespace ADS {
 
 namespace Constants {
-const char FACTORY_DEFAULT_NAME[] = "factorydefault";
-const char DEFAULT_NAME[] = "default";
+const char DEFAULT_WORKSPACE[] = "Essentials"; // This needs to align with a name of the shipped presets
 const char STARTUP_WORKSPACE_SETTINGS_KEY[] = "QML/Designer/StartupWorkspace";
 const char AUTO_RESTORE_WORKSPACE_SETTINGS_KEY[] = "QML/Designer/AutoRestoreLastWorkspace";
 } // namespace Constants
@@ -272,6 +271,13 @@ public:
     void setSettings(QSettings *settings);
 
     /**
+     * Set the path to the workspace presets folder.
+     */
+    void setWorkspacePresetsPath(const QString &path);
+
+    void initialize();
+
+    /**
      * Adds dockwidget into the given area.
      * If DockAreaWidget is not null, then the area parameter indicates the area
      * into the DockAreaWidget. If DockAreaWidget is null, the Dockwidget will
@@ -445,12 +451,14 @@ public:
     QString lastWorkspace() const;
     bool autoRestorLastWorkspace() const;
     QStringList workspaces();
+    QSet<QString> workspacePresets() const;
     QDateTime workspaceDateTime(const QString &workspace) const;
     Utils::FilePath workspaceNameToFileName(const QString &workspaceName) const;
 
     bool createWorkspace(const QString &workspace);
 
     bool openWorkspace(const QString &workspace);
+    bool reloadActiveWorkspace();
 
     bool confirmWorkspaceDelete(const QStringList &workspaces);
     bool deleteWorkspace(const QString &workspace);
@@ -459,22 +467,28 @@ public:
     bool cloneWorkspace(const QString &original, const QString &clone);
     bool renameWorkspace(const QString &original, const QString &newName);
 
+    bool resetWorkspacePreset(const QString &workspace);
+
     bool save();
 
-    bool isFactoryDefaultWorkspace(const QString &workspace) const;
-    bool isDefaultWorkspace(const QString &workspace) const;
+    bool isWorkspacePreset(const QString &workspace) const;
 
 signals:
     void aboutToUnloadWorkspace(QString workspaceName);
     void aboutToLoadWorkspace(QString workspaceName);
     void workspaceLoaded(QString workspaceName);
+    void workspaceReloaded(QString workspaceName);
     void aboutToSaveWorkspace();
 
 private:
-    bool write(const QByteArray &data, QString *errorString) const;
-#ifdef QT_GUI_LIB
-    bool write(const QByteArray &data, QWidget *parent) const;
-#endif
+    bool write(const QString &workspace, const QByteArray &data, QString *errorString) const;
+    bool write(const QString &workspace, const QByteArray &data, QWidget *parent) const;
+
+    QByteArray loadWorkspace(const QString &workspace) const;
+
+    void syncWorkspacePresets();
+
+    void saveStartupWorkspace();
 }; // class DockManager
 
 } // namespace ADS
diff --git a/src/libs/advanceddockingsystem/workspacedialog.cpp b/src/libs/advanceddockingsystem/workspacedialog.cpp
index ec4d6a23e7..a458940aa0 100644
--- a/src/libs/advanceddockingsystem/workspacedialog.cpp
+++ b/src/libs/advanceddockingsystem/workspacedialog.cpp
@@ -64,9 +64,9 @@ QValidator::State WorkspaceValidator::validate(QString &input, int &pos) const
 {
     Q_UNUSED(pos)
 
-    if (input.contains(QLatin1Char('/')) || input.contains(QLatin1Char(':'))
-        || input.contains(QLatin1Char('\\')) || input.contains(QLatin1Char('?'))
-        || input.contains(QLatin1Char('*')) || input.contains(QLatin1Char('_')))
+    static QRegExp rx("[a-zA-Z0-9 ()\\-]*");
+
+    if (!rx.exactMatch(input))
         return QValidator::Invalid;
 
     if (m_workspaces.contains(input))
@@ -158,15 +158,22 @@ WorkspaceDialog::WorkspaceDialog(DockManager *manager, QWidget *parent)
             &QAbstractButton::clicked,
             m_ui.workspaceView,
             &WorkspaceView::renameCurrentWorkspace);
+    connect(m_ui.btReset,
+            &QAbstractButton::clicked,
+            m_ui.workspaceView,
+            &WorkspaceView::resetCurrentWorkspace);
     connect(m_ui.workspaceView,
             &WorkspaceView::activated,
             m_ui.workspaceView,
             &WorkspaceView::switchToCurrentWorkspace);
-
-    connect(m_ui.workspaceView, &WorkspaceView::selected, this, &WorkspaceDialog::updateActions);
-    connect(m_ui.workspaceView, &WorkspaceView::workspaceSwitched, this, &QDialog::reject);
+    connect(m_ui.workspaceView,
+            &WorkspaceView::selected,
+            this,
+            &WorkspaceDialog::updateActions);
 
     m_ui.whatsAWorkspaceLabel->setOpenExternalLinks(true);
+
+   updateActions(m_ui.workspaceView->selectedWorkspaces());
 }
 
 void WorkspaceDialog::setAutoLoadWorkspace(bool check)
@@ -190,16 +197,20 @@ void WorkspaceDialog::updateActions(const QStringList &workspaces)
         m_ui.btDelete->setEnabled(false);
         m_ui.btRename->setEnabled(false);
         m_ui.btClone->setEnabled(false);
+        m_ui.btReset->setEnabled(false);
         m_ui.btSwitch->setEnabled(false);
         return;
     }
-    const bool defaultIsSelected = workspaces.contains("default"); // TODO use const var
+    const bool presetIsSelected = Utils::anyOf(workspaces, [this](const QString &workspace) {
+        return m_manager->isWorkspacePreset(workspace);
+    });
     const bool activeIsSelected = Utils::anyOf(workspaces, [this](const QString &workspace) {
         return workspace == m_manager->activeWorkspace();
     });
-    m_ui.btDelete->setEnabled(!defaultIsSelected && !activeIsSelected);
-    m_ui.btRename->setEnabled(workspaces.size() == 1 && !defaultIsSelected);
+    m_ui.btDelete->setEnabled(!activeIsSelected && !presetIsSelected);
+    m_ui.btRename->setEnabled(workspaces.size() == 1 && !presetIsSelected);
     m_ui.btClone->setEnabled(workspaces.size() == 1);
+    m_ui.btReset->setEnabled(presetIsSelected);
     m_ui.btSwitch->setEnabled(workspaces.size() == 1);
 }
 
diff --git a/src/libs/advanceddockingsystem/workspacedialog.ui b/src/libs/advanceddockingsystem/workspacedialog.ui
index db38f9fa92..93e40aeefc 100644
--- a/src/libs/advanceddockingsystem/workspacedialog.ui
+++ b/src/libs/advanceddockingsystem/workspacedialog.ui
@@ -61,6 +61,13 @@
       </widget>
      </item>
      <item>
+      <widget class="QPushButton" name="btReset">
+       <property name="text">
+        <string>Reset</string>
+       </property>
+      </widget>
+     </item>
+     <item>
       <widget class="QPushButton" name="btSwitch">
        <property name="text">
         <string>&amp;Switch To</string>
diff --git a/src/libs/advanceddockingsystem/workspacemodel.cpp b/src/libs/advanceddockingsystem/workspacemodel.cpp
index 4a0b20b746..08d1296673 100644
--- a/src/libs/advanceddockingsystem/workspacemodel.cpp
+++ b/src/libs/advanceddockingsystem/workspacemodel.cpp
@@ -50,6 +50,7 @@ namespace ADS {
 WorkspaceModel::WorkspaceModel(DockManager *manager, QObject *parent)
     : QAbstractTableModel(parent)
     , m_manager(manager)
+    , m_currentSortColumn(0)
 {
     m_sortedWorkspaces = m_manager->workspaces();
     connect(m_manager, &DockManager::workspaceLoaded, this, &WorkspaceModel::resetWorkspaces);
@@ -134,19 +135,18 @@ QVariant WorkspaceModel::data(const QModelIndex &index, int role) const
             break;
         case Qt::FontRole: {
             QFont font;
-            if (m_manager->isDefaultWorkspace(workspaceName))
+            if (m_manager->isWorkspacePreset(workspaceName))
                 font.setItalic(true);
             else
                 font.setItalic(false);
-            if (m_manager->activeWorkspace() == workspaceName
-                && !m_manager->isFactoryDefaultWorkspace(workspaceName))
+            if (m_manager->activeWorkspace() == workspaceName)
                 font.setBold(true);
             else
                 font.setBold(false);
             result = font;
         } break;
-        case DefaultWorkspaceRole:
-            result = m_manager->isDefaultWorkspace(workspaceName);
+        case PresetWorkspaceRole:
+            result = m_manager->isWorkspacePreset(workspaceName);
             break;
         case LastWorkspaceRole:
             result = m_manager->lastWorkspace() == workspaceName;
@@ -163,7 +163,7 @@ QVariant WorkspaceModel::data(const QModelIndex &index, int role) const
 QHash<int, QByteArray> WorkspaceModel::roleNames() const
 {
     static QHash<int, QByteArray> extraRoles{{Qt::DisplayRole, "workspaceName"},
-                                             {DefaultWorkspaceRole, "defaultWorkspace"},
+                                             {PresetWorkspaceRole, "presetWorkspace"},
                                              {LastWorkspaceRole, "activeWorkspace"},
                                              {ActiveWorkspaceRole, "lastWorkspace"}};
     return QAbstractTableModel::roleNames().unite(extraRoles);
@@ -171,6 +171,9 @@ QHash<int, QByteArray> WorkspaceModel::roleNames() const
 
 void WorkspaceModel::sort(int column, Qt::SortOrder order)
 {
+    m_currentSortColumn = column;
+    m_currentSortOrder = order;
+
     beginResetModel();
     const auto cmp = [this, column, order](const QString &s1, const QString &s2) {
         bool isLess;
@@ -186,16 +189,10 @@ void WorkspaceModel::sort(int column, Qt::SortOrder order)
     endResetModel();
 }
 
-bool WorkspaceModel::isDefaultVirgin() const
-{
-    return false; //m_manager->isFactoryDefaultWorkspace(); // TODO
-}
-
 void WorkspaceModel::resetWorkspaces()
 {
-    beginResetModel();
     m_sortedWorkspaces = m_manager->workspaces();
-    endResetModel();
+    sort(m_currentSortColumn, m_currentSortOrder);
 }
 
 void WorkspaceModel::newWorkspace(QWidget *parent)
@@ -225,9 +222,10 @@ void WorkspaceModel::deleteWorkspaces(const QStringList &workspaces)
 {
     if (!m_manager->confirmWorkspaceDelete(workspaces))
         return;
-    beginResetModel();
+
     m_manager->deleteWorkspaces(workspaces);
-    endResetModel();
+    m_sortedWorkspaces = m_manager->workspaces();
+    sort(m_currentSortColumn, m_currentSortOrder);
 }
 
 void WorkspaceModel::renameWorkspace(QWidget *parent, const QString &workspace)
@@ -242,6 +240,12 @@ void WorkspaceModel::renameWorkspace(QWidget *parent, const QString &workspace)
     });
 }
 
+void WorkspaceModel::resetWorkspace(const QString &workspace)
+{
+    if (m_manager->resetWorkspacePreset(workspace) && workspace == m_manager->activeWorkspace())
+        m_manager->reloadActiveWorkspace();
+}
+
 void WorkspaceModel::switchToWorkspace(const QString &workspace)
 {
     m_manager->openWorkspace(workspace);
@@ -255,13 +259,14 @@ void WorkspaceModel::runWorkspaceNameInputDialog(WorkspaceNameInputDialog *works
         QString newWorkspace = workspaceInputDialog->value();
         if (newWorkspace.isEmpty() || m_manager->workspaces().contains(newWorkspace))
             return;
-        beginResetModel();
+
         createWorkspace(newWorkspace);
         m_sortedWorkspaces = m_manager->workspaces();
-        endResetModel();
+        sort(m_currentSortColumn, m_currentSortOrder);
 
         if (workspaceInputDialog->isSwitchToRequested())
             switchToWorkspace(newWorkspace);
+
         emit workspaceCreated(newWorkspace);
     }
 }
diff --git a/src/libs/advanceddockingsystem/workspacemodel.h b/src/libs/advanceddockingsystem/workspacemodel.h
index ac4abae37f..3ccd70db92 100644
--- a/src/libs/advanceddockingsystem/workspacemodel.h
+++ b/src/libs/advanceddockingsystem/workspacemodel.h
@@ -49,7 +49,7 @@ class WorkspaceModel : public QAbstractTableModel
     Q_OBJECT
 
 public:
-    enum { DefaultWorkspaceRole = Qt::UserRole + 1, LastWorkspaceRole, ActiveWorkspaceRole };
+    enum { PresetWorkspaceRole = Qt::UserRole + 1, LastWorkspaceRole, ActiveWorkspaceRole };
 
     explicit WorkspaceModel(DockManager *manager, QObject *parent = nullptr);
 
@@ -64,8 +64,6 @@ public:
     QHash<int, QByteArray> roleNames() const override;
     void sort(int column, Qt::SortOrder order = Qt::AscendingOrder) override;
 
-    Q_SCRIPTABLE bool isDefaultVirgin() const;
-
 signals:
     void workspaceSwitched();
     void workspaceCreated(const QString &workspaceName);
@@ -76,6 +74,7 @@ public:
     void cloneWorkspace(QWidget *parent, const QString &workspace);
     void deleteWorkspaces(const QStringList &workspaces);
     void renameWorkspace(QWidget *parent, const QString &workspace);
+    void resetWorkspace(const QString &workspace);
     void switchToWorkspace(const QString &workspace);
 
 private:
@@ -84,6 +83,8 @@ private:
 
     QStringList m_sortedWorkspaces;
     DockManager *m_manager;
+    int m_currentSortColumn;
+    Qt::SortOrder m_currentSortOrder = Qt::AscendingOrder;
 };
 
 } // namespace ADS
diff --git a/src/libs/advanceddockingsystem/workspaceview.cpp b/src/libs/advanceddockingsystem/workspaceview.cpp
index 3a5182011b..383aa2d0a5 100644
--- a/src/libs/advanceddockingsystem/workspaceview.cpp
+++ b/src/libs/advanceddockingsystem/workspaceview.cpp
@@ -84,7 +84,7 @@ WorkspaceView::WorkspaceView(QWidget *parent)
 {
     setItemDelegate(new RemoveItemFocusDelegate(this));
     setSelectionBehavior(QAbstractItemView::SelectRows);
-    setSelectionMode(QAbstractItemView::ExtendedSelection);
+    setSelectionMode(QAbstractItemView::SingleSelection);
     setWordWrap(false);
     setRootIsDecorated(false);
     setSortingEnabled(true);
@@ -145,6 +145,11 @@ void WorkspaceView::renameCurrentWorkspace()
     m_workspaceModel.renameWorkspace(this, currentWorkspace());
 }
 
+void WorkspaceView::resetCurrentWorkspace()
+{
+    m_workspaceModel.resetWorkspace(currentWorkspace());
+}
+
 void WorkspaceView::switchToCurrentWorkspace()
 {
     m_workspaceModel.switchToWorkspace(currentWorkspace());
@@ -187,10 +192,9 @@ void WorkspaceView::keyPressEvent(QKeyEvent *event)
         return;
     }
     const QStringList workspaces = selectedWorkspaces();
-    if (!workspaces.contains("default")
-        && !Utils::anyOf(workspaces, [this](const QString &workspace) {
-               return workspace == m_manager->activeWorkspace();
-           })) {
+    if (!Utils::anyOf(workspaces, [this](const QString &workspace) {
+            return workspace == m_manager->activeWorkspace();
+        })) {
         deleteWorkspaces(workspaces);
     }
 }
diff --git a/src/libs/advanceddockingsystem/workspaceview.h b/src/libs/advanceddockingsystem/workspaceview.h
index 7edde4d62e..428c0cbd1d 100644
--- a/src/libs/advanceddockingsystem/workspaceview.h
+++ b/src/libs/advanceddockingsystem/workspaceview.h
@@ -57,6 +57,7 @@ public:
     void deleteSelectedWorkspaces();
     void cloneCurrentWorkspace();
     void renameCurrentWorkspace();
+    void resetCurrentWorkspace();
     void switchToCurrentWorkspace();
 
     QString currentWorkspace();
@@ -64,6 +65,8 @@ public:
     void selectActiveWorkspace();
     void selectWorkspace(const QString &workspaceName);
 
+    QStringList selectedWorkspaces() const;
+
 signals:
     void activated(const QString &workspace);
     void selected(const QStringList &workspaces);
@@ -74,7 +77,6 @@ private:
     void keyPressEvent(QKeyEvent *event) override;
 
     void deleteWorkspaces(const QStringList &workspaces);
-    QStringList selectedWorkspaces() const;
 
     static WorkspaceDialog *castToWorkspaceDialog(QWidget *widget);