src/plugins/qmlprojectmanager/fileformat/filefilteritems.cpp

   1 #include "filefilteritems.h"
   2 #include <qdebug.h>
   3 #include <QtGui/QImageReader>
   4
   5 namespace QmlProjectManager {
   6
   7 FileFilterBaseItem::FileFilterBaseItem(QObject *parent) :
   8         QmlProjectContentItem(parent),
   9         m_recurse(RecurseDefault)
  10 {
  11     m_updateFileListTimer.setSingleShot(true);
  12     m_updateFileListTimer.setInterval(50);
  13     connect(&m_dirWatcher, SIGNAL(directoryChanged(QString)), this, SLOT(updateFileList()));
  14     connect(&m_updateFileListTimer, SIGNAL(timeout()), this, SLOT(updateFileListNow()));
  15 }
  16
  17 QString FileFilterBaseItem::directory() const
  18 {
  19     return m_rootDir;
  20 }
  21
  22 void FileFilterBaseItem::setDirectory(const QString &dirPath)
  23 {
  24     if (m_rootDir == dirPath)
  25         return;
  26     m_rootDir = dirPath;
  27     emit directoryChanged();
  28
  29     updateFileList();
  30 }
  31
  32 void FileFilterBaseItem::setDefaultDirectory(const QString &dirPath)
  33 {
  34     if (m_defaultDir == dirPath)
  35         return;
  36     m_defaultDir = dirPath;
  37
  38     updateFileListNow();
  39 }
  40
  41 QString FileFilterBaseItem::filter() const
  42 {
  43     return m_filter;
  44 }
  45
  46 void FileFilterBaseItem::setFilter(const QString &filter)
  47 {
  48     if (filter == m_filter)
  49         return;
  50     m_filter = filter;
  51
  52     m_regExpList.clear();
  53     m_fileSuffixes.clear();
  54
  55     foreach (const QString &pattern, filter.split(QLatin1Char(';'))) {
  56         if (pattern.isEmpty())
  57             continue;
  58         // decide if it's a canonical pattern like *.x
  59         if (pattern.startsWith(QLatin1String("*."))) {
  60             const QString suffix = pattern.right(pattern.size() - 1);
  61             if (!suffix.contains(QLatin1Char('*'))
  62                     && !suffix.contains(QLatin1Char('?'))
  63                     && !suffix.contains(QLatin1Char('['))) {
  64                 m_fileSuffixes << suffix;
  65                 continue;
  66             }
  67         }
  68         m_regExpList << QRegExp(pattern, Qt::CaseInsensitive, QRegExp::Wildcard);
  69     }
  70
  71     updateFileList();
  72 }
  73
  74 bool FileFilterBaseItem::recursive() const
  75 {
  76     bool recursive;
  77     if (m_recurse == Recurse) {
  78         recursive = true;
  79     } else if (m_recurse == DoNotRecurse) {
  80         recursive = false;
  81     } else {  // RecurseDefault
  82         if (m_explicitFiles.isEmpty()) {
  83             recursive = true;
  84         } else {
  85             recursive = false;
  86         }
  87     }
  88     return recursive;
  89 }
  90
  91 void FileFilterBaseItem::setRecursive(bool recurse)
  92 {
  93     bool oldRecursive = recursive();
  94
  95     if (recurse) {
  96         m_recurse = Recurse;
  97     } else {
  98             m_recurse = DoNotRecurse;
  99     }
 100
 101     if (recurse != oldRecursive)
 102         updateFileList();
 103 }
 104
 105 QStringList FileFilterBaseItem::pathsProperty() const
 106 {
 107     return m_explicitFiles;
 108 }
 109
 110 void FileFilterBaseItem::setPathsProperty(const QStringList &path)
 111 {
 112     m_explicitFiles = path;
 113     updateFileList();
 114 }
 115
 116 QStringList FileFilterBaseItem::files() const
 117 {
 118     return m_files.toList();
 119 }
 120
 121 /**
 122   Check whether filter matches a file path - regardless whether the file already exists or not.
 123
 124   @param filePath: absolute file path
 125   */
 126 bool FileFilterBaseItem::matchesFile(const QString &filePath) const
 127 {
 128     foreach (const QString &explicitFile, m_explicitFiles) {
 129         if (absolutePath(explicitFile) == filePath)
 130             return true;
 131     }
 132
 133     const QString &fileName = QFileInfo(filePath).fileName();
 134
 135     if (!fileMatches(fileName))
 136         return false;
 137
 138     const QDir fileDir = QFileInfo(filePath).absoluteDir();
 139     foreach (const QString &watchedDirectory, m_dirWatcher.directories()) {
 140         if (QDir(watchedDirectory) == fileDir)
 141             return true;
 142     }
 143
 144     return false;
 145 }
 146
 147 QString FileFilterBaseItem::absolutePath(const QString &path) const
 148 {
 149     if (QFileInfo(path).isAbsolute())
 150         return path;
 151     return QDir(absoluteDir()).absoluteFilePath(path);
 152 }
 153
 154 QString FileFilterBaseItem::absoluteDir() const
 155 {
 156     QString absoluteDir;
 157     if (QFileInfo(m_rootDir).isAbsolute()) {
 158         absoluteDir = m_rootDir;
 159     } else if (!m_defaultDir.isEmpty()) {
 160         absoluteDir = m_defaultDir + QLatin1Char('/') + m_rootDir;
 161     }
 162
 163     return absoluteDir;
 164 }
 165
 166 void FileFilterBaseItem::updateFileList()
 167 {
 168     if (!m_updateFileListTimer.isActive())
 169         m_updateFileListTimer.start();
 170 }
 171
 172 void FileFilterBaseItem::updateFileListNow()
 173 {
 174     if (m_updateFileListTimer.isActive())
 175         m_updateFileListTimer.stop();
 176
 177     const QString projectDir = absoluteDir();
 178     if (projectDir.isEmpty())
 179         return;
 180
 181     QSet<QString> dirsToBeWatched;
 182     QSet<QString> newFiles;
 183     foreach (const QString &explicitPath, m_explicitFiles) {
 184         newFiles << absolutePath(explicitPath);
 185     }
 186     if ((!m_fileSuffixes.isEmpty() || !m_regExpList.isEmpty()) && m_explicitFiles.isEmpty())
 187         newFiles += filesInSubTree(QDir(m_defaultDir), QDir(projectDir), &dirsToBeWatched);
 188
 189     if (newFiles != m_files) {
 190         QSet<QString> addedFiles = newFiles;
 191         QSet<QString> removedFiles = m_files;
 192         QSet<QString> unchanged = newFiles;
 193         unchanged.intersect(m_files);
 194         addedFiles.subtract(unchanged);
 195         removedFiles.subtract(unchanged);
 196
 197         m_files = newFiles;
 198         emit filesChanged(addedFiles, removedFiles);
 199     }
 200
 201     // update watched directories
 202     const QSet<QString> oldDirs = m_dirWatcher.directories().toSet();
 203     const QSet<QString> unwatchDirs = oldDirs - dirsToBeWatched;
 204     const QSet<QString> watchDirs = dirsToBeWatched - oldDirs;
 205
 206     if (!unwatchDirs.isEmpty())
 207         m_dirWatcher.removeDirectories(unwatchDirs.toList());
 208     if (!watchDirs.isEmpty())
 209         m_dirWatcher.addDirectories(watchDirs.toList());
 210 }
 211
 212 bool FileFilterBaseItem::fileMatches(const QString &fileName) const
 213 {
 214     foreach (const QString &suffix, m_fileSuffixes) {
 215         if (fileName.endsWith(suffix, Qt::CaseInsensitive)) {
 216             return true;
 217         }
 218     }
 219
 220     foreach (const QRegExp &filter, m_regExpList) {
 221         if (filter.exactMatch(fileName)) {
 222             return true;
 223         }
 224     }
 225
 226     return false;
 227 }
 228
 229 QSet<QString> FileFilterBaseItem::filesInSubTree(const QDir &rootDir, const QDir &dir, QSet<QString> *parsedDirs)
 230 {
 231     QSet<QString> fileSet;
 232
 233     if (parsedDirs)
 234         parsedDirs->insert(dir.absolutePath());
 235
 236     foreach (const QFileInfo &file, dir.entryInfoList(QDir::Files)) {
 237         const QString fileName = file.fileName();
 238
 239         if (fileMatches(fileName))
 240             fileSet.insert(file.absoluteFilePath());
 241     }
 242
 243     if (recursive()) {
 244         foreach (const QFileInfo &subDir, dir.entryInfoList(QDir::Dirs | QDir::NoDotAndDotDot)) {
 245             fileSet += filesInSubTree(rootDir, QDir(subDir.absoluteFilePath()), parsedDirs);
 246         }
 247     }
 248     return fileSet;
 249 }
 250
 251 QmlFileFilterItem::QmlFileFilterItem(QObject *parent)
 252     : FileFilterBaseItem(parent)
 253 {
 254     setFilter(QLatin1String("*.qml"));
 255 }
 256
 257 JsFileFilterItem::JsFileFilterItem(QObject *parent)
 258     : FileFilterBaseItem(parent)
 259 {
 260     setFilter(QLatin1String("*.js"));
 261 }
 262
 263 void JsFileFilterItem::setFilter(const QString &filter)
 264 {
 265     FileFilterBaseItem::setFilter(filter);
 266     emit filterChanged();
 267 }
 268
 269 ImageFileFilterItem::ImageFileFilterItem(QObject *parent)
 270     : FileFilterBaseItem(parent)
 271 {
 272     QString filter;
 273     // supported image formats according to
 274     QList<QByteArray> extensions = QImageReader::supportedImageFormats();
 275     foreach (const QByteArray &extension, extensions) {
 276         filter.append(QString("*.%1;").arg(QString::fromAscii(extension)));
 277     }
 278     setFilter(filter);
 279 }
 280
 281 void ImageFileFilterItem::setFilter(const QString &filter)
 282 {
 283     FileFilterBaseItem::setFilter(filter);
 284     emit filterChanged();
 285 }
 286
 287 CssFileFilterItem::CssFileFilterItem(QObject *parent)
 288     : FileFilterBaseItem(parent)
 289 {
 290     setFilter(QLatin1String("*.css"));
 291 }
 292
 293 void CssFileFilterItem::setFilter(const QString &filter)
 294 {
 295     FileFilterBaseItem::setFilter(filter);
 296     emit filterChanged();
 297 }
 298
 299 } // namespace QmlProjectManager
 300