src/gui/fspathedit_p.cpp

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