src/gui/fspathedit_p.cpp

   1 /*
   2  * Bittorrent Client using Qt and libtorrent.
   3  * Copyright (C) 2024  Vladimir Golovnev <glassez@yandex.ru>
   4  * Copyright (C) 2022  Mike Tzou (Chocobo1)
   5  * Copyright (C) 2016  Eugene Shalygin
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation; either version 2
  10  * of the License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  20  *
  21  * In addition, as a special exception, the copyright holders give permission to
  22  * link this program with the OpenSSL project's "OpenSSL" library (or with
  23  * modified versions of it that use the same license as the "OpenSSL" library),
  24  * and distribute the linked executables. You must obey the GNU General Public
  25  * License in all respects for all of the code used other than "OpenSSL".  If you
  26  * modify file(s), you may extend this exception to your version of the file(s),
  27  * but you are not obligated to do so. If you do not wish to do so, delete this
  28  * exception statement from your version.
  29  */
  30
  31 #include "fspathedit_p.h"
  32
  33 #include <QCompleter>
  34 #include <QContextMenuEvent>
  35 #include <QDir>
  36 #include <QFileIconProvider>
  37 #include <QFileInfo>
  38 #include <QFileSystemModel>
  39 #include <QMenu>
  40 #include <QStringList>
  41 #include <QStyle>
  42
  43 #include "base/path.h"
  44
  45 // -------------------- FileSystemPathValidator ----------------------------------------
  46 Private::FileSystemPathValidator::FileSystemPathValidator(QObject *parent)
  47     : QValidator(parent)
  48 {
  49 }
  50
  51 bool Private::FileSystemPathValidator::strictMode() const
  52 {
  53     return m_strictMode;
  54 }
  55
  56 void Private::FileSystemPathValidator::setStrictMode(const bool value)
  57 {
  58     m_strictMode = value;
  59 }
  60
  61 bool Private::FileSystemPathValidator::existingOnly() const
  62 {
  63     return m_existingOnly;
  64 }
  65
  66 void Private::FileSystemPathValidator::setExistingOnly(const bool value)
  67 {
  68     m_existingOnly = value;
  69 }
  70
  71 bool Private::FileSystemPathValidator::filesOnly() const
  72 {
  73     return m_filesOnly;
  74 }
  75
  76 void Private::FileSystemPathValidator::setFilesOnly(const bool value)
  77 {
  78     m_filesOnly = value;
  79 }
  80
  81 bool Private::FileSystemPathValidator::directoriesOnly() const
  82 {
  83     return m_directoriesOnly;
  84 }
  85
  86 void Private::FileSystemPathValidator::setDirectoriesOnly(const bool value)
  87 {
  88     m_directoriesOnly = value;
  89 }
  90
  91 bool Private::FileSystemPathValidator::checkReadPermission() const
  92 {
  93     return m_checkReadPermission;
  94 }
  95
  96 void Private::FileSystemPathValidator::setCheckReadPermission(const bool value)
  97 {
  98     m_checkReadPermission = value;
  99 }
 100
 101 bool Private::FileSystemPathValidator::checkWritePermission() const
 102 {
 103     return m_checkWritePermission;
 104 }
 105
 106 void Private::FileSystemPathValidator::setCheckWritePermission(const bool value)
 107 {
 108     m_checkWritePermission = value;
 109 }
 110
 111 Private::FileSystemPathValidator::TestResult
 112 Private::FileSystemPathValidator::testPath(const Path &path) const
 113 {
 114     // `QFileInfo` will cache the query results and avoid excessive querying to filesystem
 115     const QFileInfo info {path.data()};
 116
 117     if (!info.exists())
 118         return existingOnly() ? TestResult::DoesNotExist : TestResult::OK;
 119
 120     if (filesOnly())
 121     {
 122         if (!info.isFile())
 123             return TestResult::NotAFile;
 124     }
 125
 126     if (directoriesOnly())
 127     {
 128         if (!info.isDir())
 129             return TestResult::NotADir;
 130     }
 131
 132     if (checkReadPermission() && !info.isReadable())
 133         return TestResult::CantRead;
 134
 135     if (checkWritePermission() && !info.isWritable())
 136         return TestResult::CantWrite;
 137
 138     return TestResult::OK;
 139 }
 140
 141 Private::FileSystemPathValidator::TestResult Private::FileSystemPathValidator::lastTestResult() const
 142 {
 143     return m_lastTestResult;
 144 }
 145
 146 QValidator::State Private::FileSystemPathValidator::lastValidationState() const
 147 {
 148     return m_lastValidationState;
 149 }
 150
 151 QValidator::State Private::FileSystemPathValidator::validate(QString &input, [[maybe_unused]] int &pos) const
 152 {
 153     // we ignore cursor position and validate the full path anyway
 154
 155     m_lastTestResult = testPath(Path(input));
 156     m_lastValidationState = (m_lastTestResult == TestResult::OK)
 157         ? QValidator::Acceptable
 158         : (strictMode() ? QValidator::Invalid : QValidator::Intermediate);
 159
 160     return m_lastValidationState;
 161 }
 162
 163 Private::FileLineEdit::FileLineEdit(QWidget *parent)
 164     : QLineEdit(parent)
 165 {
 166     setCompleter(new QCompleter(this));
 167     connect(this, &QLineEdit::textChanged, this, &FileLineEdit::validateText);
 168 }
 169
 170 Private::FileLineEdit::~FileLineEdit()
 171 {
 172     delete m_completerModel; // has to be deleted before deleting the m_iconProvider object
 173     delete m_iconProvider;
 174 }
 175
 176 void Private::FileLineEdit::completeDirectoriesOnly(const bool completeDirsOnly)
 177 {
 178     m_completeDirectoriesOnly = completeDirsOnly;
 179     if (m_completerModel)
 180     {
 181         const QDir::Filters filters = QDir::NoDotAndDotDot
 182                 | (completeDirsOnly ? QDir::Dirs : QDir::AllEntries);
 183         m_completerModel->setFilter(filters);
 184     }
 185 }
 186
 187 void Private::FileLineEdit::setFilenameFilters(const QStringList &filters)
 188 {
 189     m_filenameFilters = filters;
 190     if (m_completerModel)
 191         m_completerModel->setNameFilters(m_filenameFilters);
 192 }
 193
 194 void Private::FileLineEdit::setBrowseAction(QAction *action)
 195 {
 196     m_browseAction = action;
 197 }
 198
 199 void Private::FileLineEdit::setValidator(QValidator *validator)
 200 {
 201     QLineEdit::setValidator(validator);
 202 }
 203
 204 Path Private::FileLineEdit::placeholder() const
 205 {
 206     return Path(placeholderText());
 207 }
 208
 209 void Private::FileLineEdit::setPlaceholder(const Path &val)
 210 {
 211     setPlaceholderText(val.toString());
 212 }
 213
 214 QWidget *Private::FileLineEdit::widget()
 215 {
 216     return this;
 217 }
 218
 219 void Private::FileLineEdit::keyPressEvent(QKeyEvent *e)
 220 {
 221     QLineEdit::keyPressEvent(e);
 222
 223     if ((e->key() == Qt::Key_Space) && (e->modifiers() == Qt::CTRL))
 224     {
 225         if (!m_completerModel)
 226         {
 227             m_iconProvider = new QFileIconProvider;
 228             m_iconProvider->setOptions(QFileIconProvider::DontUseCustomDirectoryIcons);
 229
 230             m_completerModel = new QFileSystemModel(this);
 231             m_completerModel->setIconProvider(m_iconProvider);
 232             m_completerModel->setOptions(QFileSystemModel::DontWatchForChanges);
 233             m_completerModel->setNameFilters(m_filenameFilters);
 234             const QDir::Filters filters = QDir::NoDotAndDotDot
 235                     | (m_completeDirectoriesOnly ? QDir::Dirs : QDir::AllEntries);
 236             m_completerModel->setFilter(filters);
 237
 238             completer()->setModel(m_completerModel);
 239         }
 240
 241         m_completerModel->setRootPath(Path(text()).data());
 242         showCompletionPopup();
 243     }
 244 }
 245
 246 void Private::FileLineEdit::contextMenuEvent(QContextMenuEvent *event)
 247 {
 248     QMenu *menu = createStandardContextMenu();
 249     menu->setAttribute(Qt::WA_DeleteOnClose);
 250
 251     if (m_browseAction)
 252     {
 253         menu->addSeparator();
 254         menu->addAction(m_browseAction);
 255     }
 256
 257     menu->popup(event->globalPos());
 258 }
 259
 260 void Private::FileLineEdit::showCompletionPopup()
 261 {
 262     completer()->setCompletionPrefix(text());
 263     completer()->complete();
 264 }
 265
 266 void Private::FileLineEdit::validateText()
 267 {
 268     const auto *validator = qobject_cast<const FileSystemPathValidator *>(this->validator());
 269     if (!validator)
 270         return;
 271
 272     const FileSystemPathValidator::TestResult lastTestResult = validator->lastTestResult();
 273     const QValidator::State lastState = validator->lastValidationState();
 274
 275     if (lastTestResult == FileSystemPathValidator::TestResult::OK)
 276     {
 277         delete m_warningAction;
 278         m_warningAction = nullptr;
 279     }
 280     else
 281     {
 282         if (!m_warningAction)
 283         {
 284             m_warningAction = new QAction(this);
 285             addAction(m_warningAction, QLineEdit::TrailingPosition);
 286         }
 287     }
 288
 289     if (m_warningAction)
 290     {
 291         if (lastState == QValidator::Invalid)
 292             m_warningAction->setIcon(style()->standardIcon(QStyle::SP_MessageBoxCritical));
 293         else if (lastState == QValidator::Intermediate)
 294             m_warningAction->setIcon(style()->standardIcon(QStyle::SP_MessageBoxInformation));
 295         m_warningAction->setToolTip(warningText(lastTestResult));
 296     }
 297 }
 298
 299 QString Private::FileLineEdit::warningText(const FileSystemPathValidator::TestResult result)
 300 {
 301     using TestResult = FileSystemPathValidator::TestResult;
 302     switch (result)
 303     {
 304     case TestResult::DoesNotExist:
 305         return tr("Path does not exist");
 306     case TestResult::NotADir:
 307         return tr("Path does not point to a directory");
 308     case TestResult::NotAFile:
 309         return tr("Path does not point to a file");
 310     case TestResult::CantRead:
 311         return tr("Don't have read permission to path");
 312     case TestResult::CantWrite:
 313         return tr("Don't have write permission to path");
 314     default:
 315         break;
 316     }
 317     return {};
 318 }
 319
 320 Private::FileComboEdit::FileComboEdit(QWidget *parent)
 321     : QComboBox {parent}
 322 {
 323     setEditable(true);
 324     setLineEdit(new FileLineEdit(this));
 325 }
 326
 327 void Private::FileComboEdit::completeDirectoriesOnly(bool completeDirsOnly)
 328 {
 329     static_cast<FileLineEdit *>(lineEdit())->completeDirectoriesOnly(completeDirsOnly);
 330 }
 331
 332 void Private::FileComboEdit::setBrowseAction(QAction *action)
 333 {
 334     static_cast<FileLineEdit *>(lineEdit())->setBrowseAction(action);
 335 }
 336
 337 void Private::FileComboEdit::setValidator(QValidator *validator)
 338 {
 339     lineEdit()->setValidator(validator);
 340 }
 341
 342 Path Private::FileComboEdit::placeholder() const
 343 {
 344     return Path(lineEdit()->placeholderText());
 345 }
 346
 347 void Private::FileComboEdit::setPlaceholder(const Path &val)
 348 {
 349     lineEdit()->setPlaceholderText(val.toString());
 350 }
 351
 352 void Private::FileComboEdit::setFilenameFilters(const QStringList &filters)
 353 {
 354     static_cast<FileLineEdit *>(lineEdit())->setFilenameFilters(filters);
 355 }
 356
 357 QWidget *Private::FileComboEdit::widget()
 358 {
 359     return this;
 360 }
 361
 362 QString Private::FileComboEdit::text() const
 363 {
 364     return currentText();
 365 }