--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/gui/dialogs/qfileinfogatherer.cpp Mon Jan 11 14:00:40 2010 +0000
@@ -0,0 +1,372 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qfileinfogatherer_p.h"
+#include <qdebug.h>
+#include <qfsfileengine.h>
+#include <qdiriterator.h>
+#ifndef Q_OS_WIN
+# include <unistd.h>
+# include <sys/types.h>
+#endif
+#if defined(Q_OS_VXWORKS)
+# include "qplatformdefs.h"
+#endif
+
+QT_BEGIN_NAMESPACE
+
+#ifndef QT_NO_FILESYSTEMMODEL
+
+bool QFileInfoGatherer::fetchedRoot = false;
+
+/*!
+ Creates thread
+*/
+QFileInfoGatherer::QFileInfoGatherer(QObject *parent)
+ : QThread(parent), abort(false),
+#ifndef QT_NO_FILESYSTEMWATCHER
+ watcher(0),
+#endif
+ m_resolveSymlinks(false), m_iconProvider(&defaultProvider)
+{
+#ifndef Q_OS_WIN
+ userId = getuid();
+ groupId = getgid();
+#else
+ m_resolveSymlinks = true;
+#endif
+#ifndef QT_NO_FILESYSTEMWATCHER
+ watcher = new QFileSystemWatcher(this);
+ connect(watcher, SIGNAL(directoryChanged(const QString &)), this, SLOT(list(const QString &)));
+ connect(watcher, SIGNAL(fileChanged(const QString &)), this, SLOT(updateFile(const QString &)));
+#endif
+ start(LowPriority);
+}
+
+/*!
+ Destroys thread
+*/
+QFileInfoGatherer::~QFileInfoGatherer()
+{
+ QMutexLocker locker(&mutex);
+ abort = true;
+ condition.wakeOne();
+ locker.unlock();
+ wait();
+}
+
+void QFileInfoGatherer::setResolveSymlinks(bool enable)
+{
+ Q_UNUSED(enable);
+#ifdef Q_OS_WIN
+ QMutexLocker locker(&mutex);
+ m_resolveSymlinks = enable;
+#endif
+}
+
+bool QFileInfoGatherer::resolveSymlinks() const
+{
+ return m_resolveSymlinks;
+}
+
+void QFileInfoGatherer::setIconProvider(QFileIconProvider *provider)
+{
+ QMutexLocker locker(&mutex);
+ m_iconProvider = provider;
+}
+
+QFileIconProvider *QFileInfoGatherer::iconProvider() const
+{
+ return m_iconProvider;
+}
+
+/*!
+ Fetch extended information for all \a files in \a path
+
+ \sa updateFile(), update(), resolvedName()
+*/
+void QFileInfoGatherer::fetchExtendedInformation(const QString &path, const QStringList &files)
+{
+ QMutexLocker locker(&mutex);
+ // See if we already have this dir/file in our que
+ int loc = this->path.lastIndexOf(path);
+ while (loc > 0) {
+ if (this->files.at(loc) == files) {
+ return;
+ }
+ loc = this->path.lastIndexOf(path, loc - 1);
+ }
+ this->path.push(path);
+ this->files.push(files);
+ condition.wakeAll();
+}
+
+/*!
+ Fetch extended information for all \a filePath
+
+ \sa fetchExtendedInformation()
+*/
+void QFileInfoGatherer::updateFile(const QString &filePath)
+{
+ QString dir = filePath.mid(0, filePath.lastIndexOf(QDir::separator()));
+ QString fileName = filePath.mid(dir.length() + 1);
+ fetchExtendedInformation(dir, QStringList(fileName));
+}
+
+/*
+ List all files in \a directoryPath
+
+ \sa listed()
+*/
+void QFileInfoGatherer::clear()
+{
+#ifndef QT_NO_FILESYSTEMWATCHER
+ QMutexLocker locker(&mutex);
+ watcher->removePaths(watcher->files());
+ watcher->removePaths(watcher->directories());
+#endif
+}
+
+/*
+ Remove a \a path from the watcher
+
+ \sa listed()
+*/
+void QFileInfoGatherer::removePath(const QString &path)
+{
+#ifndef QT_NO_FILESYSTEMWATCHER
+ QMutexLocker locker(&mutex);
+ watcher->removePath(path);
+#endif
+}
+
+/*
+ List all files in \a directoryPath
+
+ \sa listed()
+*/
+void QFileInfoGatherer::list(const QString &directoryPath)
+{
+ fetchExtendedInformation(directoryPath, QStringList());
+}
+
+/*
+ Until aborted wait to fetch a directory or files
+*/
+void QFileInfoGatherer::run()
+{
+ forever {
+ bool updateFiles = false;
+ QMutexLocker locker(&mutex);
+ if (abort) {
+ return;
+ }
+ if (this->path.isEmpty())
+ condition.wait(&mutex);
+ QString path;
+ QStringList list;
+ if (!this->path.isEmpty()) {
+ path = this->path.first();
+ list = this->files.first();
+ this->path.pop_front();
+ this->files.pop_front();
+ updateFiles = true;
+ }
+ locker.unlock();
+ if (updateFiles)
+ getFileInfos(path, list);
+ }
+}
+
+/*
+ QFileInfo::permissions is different depending upon your platform.
+
+ "normalize this" so they can mean the same to us.
+*/
+QFile::Permissions QFileInfoGatherer::translatePermissions(const QFileInfo &fileInfo) const {
+ QFile::Permissions permissions = fileInfo.permissions();
+#ifdef Q_OS_WIN
+ return permissions;
+#else
+ QFile::Permissions p = permissions;
+ p &= ~(QFile::ReadUser|QFile::WriteUser|QFile::ExeUser);
+ if ( permissions & QFile::ReadOther
+ || (fileInfo.ownerId() == userId && permissions & QFile::ReadOwner)
+ || (fileInfo.groupId() == groupId && permissions & QFile::ReadGroup))
+ p |= QFile::ReadUser;
+
+ if ( permissions & QFile::WriteOther
+ || (fileInfo.ownerId() == userId && permissions & QFile::WriteOwner)
+ || (fileInfo.groupId() == groupId && permissions & QFile::WriteGroup))
+ p |= QFile::WriteUser;
+
+ if ( permissions & QFile::ExeOther
+ || (fileInfo.ownerId() == userId && permissions & QFile::ExeOwner)
+ || (fileInfo.groupId() == groupId && permissions & QFile::ExeGroup))
+ p |= QFile::ExeUser;
+ return p;
+#endif
+}
+
+QExtendedInformation QFileInfoGatherer::getInfo(const QFileInfo &fileInfo) const
+{
+ QExtendedInformation info(fileInfo);
+ info.icon = m_iconProvider->icon(fileInfo);
+ info.setPermissions(translatePermissions(fileInfo));
+ info.displayType = m_iconProvider->type(fileInfo);
+#ifndef QT_NO_FILESYSTEMWATCHER
+ // ### Not ready to listen all modifications
+ #if 0
+ // Enable the next two commented out lines to get updates when the file sizes change...
+ if (!fileInfo.exists() && !fileInfo.isSymLink()) {
+ info.size = -1;
+ //watcher->removePath(fileInfo.absoluteFilePath());
+ } else {
+ if (!fileInfo.absoluteFilePath().isEmpty() && fileInfo.exists() && fileInfo.isReadable()
+ && !watcher->files().contains(fileInfo.absoluteFilePath())) {
+ //watcher->addPath(fileInfo.absoluteFilePath());
+ }
+ }
+ #endif
+#endif
+
+ if (fileInfo.isSymLink() && m_resolveSymlinks) {
+ QFileInfo resolvedInfo(fileInfo.symLinkTarget());
+ resolvedInfo = resolvedInfo.canonicalFilePath();
+ if (resolvedInfo.exists()) {
+ emit nameResolved(fileInfo.filePath(), resolvedInfo.fileName());
+ }
+ }
+ return info;
+}
+
+QString QFileInfoGatherer::translateDriveName(const QFileInfo &drive) const
+{
+ QString driveName = drive.absoluteFilePath();
+#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)
+ if (driveName.startsWith(QLatin1Char('/'))) // UNC host
+ return drive.fileName();
+#endif
+#if (defined(Q_OS_WIN) && !defined(Q_OS_WINCE)) || defined(Q_OS_SYMBIAN)
+ if (driveName.endsWith(QLatin1Char('/')))
+ driveName.chop(1);
+#endif
+ return driveName;
+}
+
+/*
+ Get specific file info's, batch the files so update when we have 100
+ items and every 200ms after that
+ */
+void QFileInfoGatherer::getFileInfos(const QString &path, const QStringList &files)
+{
+#ifndef QT_NO_FILESYSTEMWATCHER
+ if (files.isEmpty()
+ && !watcher->directories().contains(path)
+ && !path.isEmpty()
+ && !path.startsWith(QLatin1String("//")) /*don't watch UNC path*/) {
+ watcher->addPath(path);
+ }
+#endif
+
+ // List drives
+ if (path.isEmpty()) {
+#if defined Q_AUTOTEST_EXPORT
+ fetchedRoot = true;
+#endif
+ QFileInfoList infoList;
+ if (files.isEmpty()) {
+ infoList = QDir::drives();
+ } else {
+ for (int i = 0; i < files.count(); ++i)
+ infoList << QFileInfo(files.at(i));
+ }
+ for (int i = infoList.count() - 1; i >= 0; --i) {
+ QString driveName = translateDriveName(infoList.at(i));
+ QList<QPair<QString,QFileInfo> > updatedFiles;
+ updatedFiles.append(QPair<QString,QFileInfo>(driveName, infoList.at(i)));
+ emit updates(path, updatedFiles);
+ }
+ return;
+ }
+
+ QTime base = QTime::currentTime();
+ QFileInfo fileInfo;
+ bool firstTime = true;
+ QList<QPair<QString, QFileInfo> > updatedFiles;
+ QStringList filesToCheck = files;
+
+ QString itPath = QDir::fromNativeSeparators(files.isEmpty() ? path : QLatin1String(""));
+ QDirIterator dirIt(itPath, QDir::AllEntries | QDir::System | QDir::Hidden);
+ QStringList allFiles;
+ while(!abort && dirIt.hasNext()) {
+ dirIt.next();
+ fileInfo = dirIt.fileInfo();
+ allFiles.append(fileInfo.fileName());
+ fetch(fileInfo, base, firstTime, updatedFiles, path);
+ }
+ if (!allFiles.isEmpty())
+ emit newListOfFiles(path, allFiles);
+
+ QStringList::const_iterator filesIt = filesToCheck.constBegin();
+ while(!abort && filesIt != filesToCheck.constEnd()) {
+ fileInfo.setFile(path + QDir::separator() + *filesIt);
+ ++filesIt;
+ fetch(fileInfo, base, firstTime, updatedFiles, path);
+ }
+ if (!updatedFiles.isEmpty())
+ emit updates(path, updatedFiles);
+}
+
+void QFileInfoGatherer::fetch(const QFileInfo &fileInfo, QTime &base, bool &firstTime, QList<QPair<QString, QFileInfo> > &updatedFiles, const QString &path) {
+ updatedFiles.append(QPair<QString, QFileInfo>(fileInfo.fileName(), fileInfo));
+ QTime current = QTime::currentTime();
+ if ((firstTime && updatedFiles.count() > 100) || base.msecsTo(current) > 1000) {
+ emit updates(path, updatedFiles);
+ updatedFiles.clear();
+ base = current;
+ firstTime = false;
+ }
+}
+
+#endif // QT_NO_FILESYSTEMMODEL
+
+QT_END_NAMESPACE