src/gui/fspathedit_p.cpp

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