[DC-84] feature: implement advanced settings page of wizard (#12221)

* laid out the widgets depending on the vfs mode availability and whether forceVfs is in play
the folder picker works like the old one did
folder validation error reporting still needs work
returning the result is not yet complete either.

* finally got the gui to behave nicely (on windows at least)
errors related to the user defined sync root are now shown in the page, and they are auto-cleared when you start editing the root again
also had to add some special handling as on windows, when you hit enter in the sync root text field, it automatically triggers the finish button. now it will block finish if the last edit was bad, so at least you can see the error, and also see the value was reset to the default sync root.

* added a few extra checks on the sync root path
fixed a couple of typos in folderman

* filter out any non existing directory name from the suggested sync root path when opening the folder picker

* make squish pass

* take care of review feedback

Author: modSpike

src/gui/folderman.cpp

@@ -849,9 +849,9 @@ QString FolderMan::checkPathValidityRecursive(const QString &path, FolderMan::Ne
     Utility::NtfsPermissionLookupRAII ntfs_perm;
 #endif
 
-    auto pathLenghtCheck = Folder::checkPathLength(path);
-    if (!pathLenghtCheck) {
-        return pathLenghtCheck.error();
+    auto pathLengthCheck = Folder::checkPathLength(path);
+    if (!pathLengthCheck) {
+        return pathLengthCheck.error();
     }
 
     const QFileInfo selectedPathInfo(path);
@@ -867,7 +867,7 @@ QString FolderMan::checkPathValidityRecursive(const QString &path, FolderMan::Ne
         return FolderMan::tr("The folder %1 is used in a folder sync connection!").arg(QDir::toNativeSeparators(selectedPathInfo.filePath()));
     }
 
-    // At this point we know there is no syncdb in the parent hyrarchy, check for spaces sync root.
+    // At this point we know there is no syncdb in the parent hierarchy, check for spaces sync root.
 
     if (!selectedPathInfo.isDir()) {
         return FolderMan::tr("The selected path is not a folder!");

src/gui/newaccountwizard/advancedsettingspagecontroller.cpp

@@ -12,15 +12,29 @@
  * for more details.
  */
 #include "advancedsettingspagecontroller.h"
+#include "common/vfs.h"
+#include "folderman.h"
 
+#include "theme.h"
+
+#include <QButtonGroup>
+#include <QFileDialog>
+#include <QHBoxLayout>
+#include <QLabel>
+#include <QLineEdit>
+#include <QPushButton>
+#include <QRadioButton>
+#include <QVBoxLayout>
 #include <QWizardPage>
 
 namespace OCC {
 
+
 AdvancedSettingsPageController::AdvancedSettingsPageController(QWizardPage *page, QObject *parent)
     : QObject{parent}
     , _page(page)
 {
+    gatherSyncInfo();
     buildPage();
 }
 
@@ -29,11 +43,183 @@ void AdvancedSettingsPageController::buildPage()
     if (!_page)
         return;
 
-    _page->setTitle(QStringLiteral("AdvancedSetttingsPage"));
+    _buttonGroup = new QButtonGroup(_page);
+
+    QLabel *titleLabel = new QLabel(tr("Advanced settings"), _page);
+    QFont titleFont = titleLabel->font();
+    titleFont.setPixelSize(20);
+    titleFont.setWeight(QFont::DemiBold);
+    titleLabel->setFont(titleFont);
+    titleLabel->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
+
+    QLabel *syncOptionsLabel = new QLabel(tr("Sync and download options"), _page);
+    QLabel *syncRootLabel = new QLabel(tr("Folder location"));
+    QFont sectionFont = syncOptionsLabel->font();
+    sectionFont.setPixelSize(16);
+    sectionFont.setWeight(QFont::DemiBold);
+    syncOptionsLabel->setFont(sectionFont);
+    syncRootLabel->setFont(sectionFont);
+    syncOptionsLabel->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
+    syncRootLabel->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
+
+
+    QVBoxLayout *layout = new QVBoxLayout();
+    layout->setContentsMargins(50, 0, 50, 0);
+    layout->setSpacing(12);
+    layout->addStretch(1);
+    layout->addWidget(titleLabel, Qt::AlignLeft);
+    layout->addSpacing(8);
+    layout->addWidget(syncOptionsLabel, Qt::AlignLeft);
+
+    if (_vfsIsAvailable) {
+        QRadioButton *vfsButton = new QRadioButton(tr("Only sync and dowload files as you use them to save hard drive space"), _page);
+        vfsButton->setFocusPolicy(Qt::StrongFocus);
+        _buttonGroup->addButton(vfsButton, SyncType::USE_VFS);
+        layout->addWidget(vfsButton, Qt::AlignLeft);
+    }
+    if (!_forceVfs) {
+        QRadioButton *selectiveSyncButton = new QRadioButton(tr("Sync and download specific folders"), _page);
+        selectiveSyncButton->setFocusPolicy(Qt::StrongFocus);
+        QRadioButton *syncAllButton = new QRadioButton(tr("Automatically sync and download all current folders and files"), _page);
+        syncAllButton->setFocusPolicy(Qt::StrongFocus);
+        _buttonGroup->addButton(selectiveSyncButton, SyncType::SELECTIVE_SYNC);
+        _buttonGroup->addButton(syncAllButton, SyncType::SYNC_ALL);
+        layout->addWidget(selectiveSyncButton, Qt::AlignLeft);
+        layout->addWidget(syncAllButton, Qt::AlignLeft);
+    }
+
+    Q_ASSERT(_buttonGroup->button(_defaultSyncType));
+    _buttonGroup->button(_defaultSyncType)->setChecked(true);
+
+    _rootDirEdit = new QLineEdit(_page);
+    _rootDirEdit->setText(_defaultSyncRoot);
+    _rootDirEdit->setFocusPolicy(Qt::StrongFocus);
+    // just clear the error if the user starts typing in the text edit
+    connect(_rootDirEdit, &QLineEdit::textEdited, this, [this] {
+        if (!_errorField->text().isEmpty())
+            _errorField->setText({});
+    });
+    connect(_rootDirEdit, &QLineEdit::editingFinished, this, &AdvancedSettingsPageController::onRootDirFieldEdited);
+
+    QPushButton *folderButton = new QPushButton(tr("Choose..."), _page);
+    folderButton->setFocusPolicy(Qt::StrongFocus);
+    connect(folderButton, &QPushButton::clicked, this, &AdvancedSettingsPageController::showFolderPicker);
+
+    layout->addSpacing(8);
+    layout->addWidget(syncRootLabel, Qt::AlignLeft);
+
+    QHBoxLayout *folderPickerLayout = new QHBoxLayout();
+    folderPickerLayout->addWidget(_rootDirEdit, Qt::AlignLeft);
+    folderPickerLayout->addWidget(folderButton);
+    layout->addLayout(folderPickerLayout);
+
+    _errorField = new QLabel(QString(), _page);
+    QPalette errorPalette = _errorField->palette();
+    errorPalette.setColor(QPalette::Text, Qt::red);
+    _errorField->setPalette(errorPalette);
+    _errorField->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
+    _errorField->setWordWrap(true);
+    _errorField->setAlignment(Qt::AlignLeft);
+    _errorField->setTextInteractionFlags(Qt::TextSelectableByKeyboard | Qt::TextSelectableByMouse);
+    layout->addWidget(_errorField);
+
+    layout->addStretch(1);
+    _page->setLayout(layout);
+}
+
+void AdvancedSettingsPageController::gatherSyncInfo()
+{
+    _vfsIsAvailable = VfsPluginManager::instance().bestAvailableVfsMode() == Vfs::WindowsCfApi;
+    _forceVfs = _vfsIsAvailable && Theme::instance()->forceVirtualFilesOption();
+    if (!_vfsIsAvailable)
+        _defaultSyncType = SyncType::SYNC_ALL;
+    else
+        _defaultSyncType = SyncType::USE_VFS;
+
+    _defaultSyncRoot = FolderMan::suggestSyncFolder(FolderMan::NewFolderType::SpacesSyncRoot, {});
 }
 
 bool AdvancedSettingsPageController::validate()
 {
+    // this is a safety net because for unknown reasons, on windows when you hit enter to commit hand edited text
+    // in the QLineEdit, it ALSO triggers the finish button. No idea but this should block the finish so the user
+    // can see their last choice failed, and that the root has been reset to the default.
+    if (_lastHandEditedRootFailed)
+        return false;
+
+    // normally I don't like taking values directly from the gui but in this case, it would be complete overkill to
+    // create a dedicated model just for these two values that only need to be collected when the user is done.
+    AdvancedSettingsResult result;
+    result._syncRoot = _rootDirEdit->text();
+    result._syncType = static_cast<SyncType>(_buttonGroup->checkedId());
+    Q_EMIT success(result);
     return true;
 }
+
+bool AdvancedSettingsPageController::validateSyncRoot(const QString &rootPath)
+{
+    QString errorMessageTemplate = tr("Invalid local download directory %1: %2");
+
+    if (rootPath == QDir::homePath()) {
+        _errorField->setText(errorMessageTemplate.arg(rootPath, tr("your user directory may not be chosen as the sync root.")));
+        return false;
+    }
+
+    if (Utility::isMac()) {
+        QString filesystemType = FileSystem::fileSystemForPath(rootPath);
+        if (filesystemType != QStringLiteral("apfs")) {
+            _errorField->setText(errorMessageTemplate.arg(rootPath, tr("path is not located on a supported Apple File System.")));
+        }
+    }
+
+    if (!QDir::isAbsolutePath(rootPath)) {
+        _errorField->setText(errorMessageTemplate.arg(rootPath, tr("path must be absolute.")));
+        return false;
+    }
+
+    QString invalidPathErrorMessage = FolderMan::checkPathValidityRecursive(rootPath, FolderMan::NewFolderType::SpacesSyncRoot, {});
+    if (!invalidPathErrorMessage.isEmpty()) {
+        _errorField->setText(errorMessageTemplate.arg(rootPath, invalidPathErrorMessage));
+        return false;
+    }
+
+    // I'm not testing the case that vfs is actually the chosen mode here as if vfs is available we should just block dirs that don't support it,
+    // the idea being that eg if they change the mode in the page after they select the dir, or use selective sync with vfs later, at least we know the default
+    // root they select here will not cause any issues down the road
+    if (_vfsIsAvailable && !FolderMan::instance()->checkVfsAvailability(rootPath)) {
+        _errorField->setText(errorMessageTemplate.arg(rootPath, tr("selected path does not support using virtual file system.")));
+        return false;
+    }
+
+    return true;
+}
+
+void AdvancedSettingsPageController::showFolderPicker()
+{
+    _errorField->setText({});
+    _lastHandEditedRootFailed = false;
+
+    QDir defaultDir(_defaultSyncRoot);
+    while (!defaultDir.exists())
+        defaultDir.cdUp();
+    QString chosenRoot = QFileDialog::getExistingDirectory(_page->parentWidget(), tr("Select sync root"), defaultDir.path());
+
+    if (chosenRoot.isEmpty())
+        return;
+
+    if (validateSyncRoot(chosenRoot))
+        _rootDirEdit->setText(chosenRoot);
+}
+
+void AdvancedSettingsPageController::onRootDirFieldEdited()
+{
+    QString chosenRoot = _rootDirEdit->text();
+    if (!validateSyncRoot(chosenRoot)) {
+        _rootDirEdit->setText(_defaultSyncRoot);
+        _lastHandEditedRootFailed = true;
+    } else {
+        _lastHandEditedRootFailed = false;
+        _errorField->setText({});
+    }
+}
 }

src/gui/newaccountwizard/advancedsettingspagecontroller.h

@@ -17,19 +17,51 @@
 #include <QObject>
 
 class QWizardPage;
+class QButtonGroup;
+class QLineEdit;
+class QLabel;
 
 namespace OCC {
 
+// I am not making this a strongly typed enum class as it's only used to support the radio button ids in the gui.
+// an old fashioned enum does not require casts back and forth, which for this use case is a good thing.
+enum SyncType { NONE, USE_VFS, SYNC_ALL, SELECTIVE_SYNC };
+
+struct AdvancedSettingsResult
+{
+    SyncType _syncType = SyncType::NONE;
+    QString _syncRoot;
+};
+
 class AdvancedSettingsPageController : public QObject, public WizardPageValidator
 {
     Q_OBJECT
+
 public:
     explicit AdvancedSettingsPageController(QWizardPage *page, QObject *parent);
     bool validate() override;
 
+Q_SIGNALS:
+    void success(const AdvancedSettingsResult &result);
+
 private:
+    void gatherSyncInfo();
     void buildPage();
+    void showFolderPicker();
+    void onRootDirFieldEdited();
+    bool validateSyncRoot(const QString &rootPath);
+
+    SyncType _defaultSyncType = SyncType::NONE;
+    QString _defaultSyncRoot;
+    bool _vfsIsAvailable = false;
+    bool _forceVfs = false;
+    bool _lastHandEditedRootFailed = false;
+
+    AdvancedSettingsResult _results;
 
     QWizardPage *_page = nullptr;
+    QButtonGroup *_buttonGroup = nullptr;
+    QLineEdit *_rootDirEdit = nullptr;
+    QLabel *_errorField;
 };
 }