#include <qfilesystemmodel_p.h>

Inheritance diagram for QFileSystemModelPrivate:

Classes
struct	Fetching

class	QFileSystemNode

Public Functions
void	_q_directoryChanged (const QString &directory, const QStringList &list)
	Performed quick listing and see if any files have been added or removed, then fetch more information on visible files. More...

void	_q_fileSystemChanged (const QString &path, const QList< QPair< QString, QFileInfo > > &)
	The thread has received new information about files, update and emit dataChanged if it has actually changed. More...

void	_q_performDelayedSort ()

void	_q_resolvedName (const QString &fileName, const QString &resolvedName)

QFileSystemNode *	addNode (QFileSystemNode *parentNode, const QString &fileName, const QFileInfo &info)

void	addVisibleFiles (QFileSystemNode *parentNode, const QStringList &newFiles)

void	delayedSort ()

QString	displayName (const QModelIndex &index) const

QString	filePath (const QModelIndex &index) const

bool	filtersAcceptsNode (const QFileSystemNode *node) const

QIcon	icon (const QModelIndex &index) const

QModelIndex	index (const QString &path)

QModelIndex	index (const QFileSystemNode *node) const

void	init ()

bool	isHiddenByFilter (QFileSystemNode *indexNode, const QModelIndex &index) const

QString	name (const QModelIndex &index) const

QFileSystemNode *	node (const QModelIndex &index) const
	Return the QFileSystemNode that goes to index. More...

QFileSystemNode *	node (const QString &path, bool fetch=true) const

bool	passNameFilters (const QFileSystemNode *node) const

	QFileSystemModelPrivate ()

void	removeNode (QFileSystemNode *parentNode, const QString &name)

void	removeVisibleFile (QFileSystemNode *parentNode, int visibleLocation)

QString	size (const QModelIndex &index) const

void	sortChildren (int column, const QModelIndex &parent)

QString	time (const QModelIndex &index) const

int	translateVisibleLocation (QFileSystemNode *parent, int row) const

QString	type (const QModelIndex &index) const

Public Functions inherited from QAbstractItemModelPrivate
bool	allowMove (const QModelIndex &srcParent, int srcFirst, int srcLast, const QModelIndex &destinationParent, int destinationChild, Qt::Orientation orientation)
	Returns whether a move operation is valid. More...

void	columnsAboutToBeInserted (const QModelIndex &parent, int first, int last)

void	columnsAboutToBeRemoved (const QModelIndex &parent, int first, int last)

void	columnsInserted (const QModelIndex &parent, int first, int last)

void	columnsRemoved (const QModelIndex &parent, int first, int last)

QModelIndex	createIndex (int row, int column, void *data=0) const

QModelIndex	createIndex (int row, int column, int id) const

bool	indexValid (const QModelIndex &index) const

void	invalidatePersistentIndex (const QModelIndex &index)

void	invalidatePersistentIndexes ()

void	itemsAboutToBeMoved (const QModelIndex &srcParent, int srcFirst, int srcLast, const QModelIndex &destinationParent, int destinationChild, Qt::Orientation)

void	itemsMoved (const QModelIndex &srcParent, int srcFirst, int srcLast, const QModelIndex &destinationParent, int destinationChild, Qt::Orientation orientation)

void	movePersistentIndexes (QVector< QPersistentModelIndexData *> indexes, int change, const QModelIndex &parent, Qt::Orientation orientation)
	Moves persistent indexes indexes by amount change. More...

	QAbstractItemModelPrivate ()

void	removePersistentIndexData (QPersistentModelIndexData *data)

void	rowsAboutToBeInserted (const QModelIndex &parent, int first, int last)

void	rowsAboutToBeRemoved (const QModelIndex &parent, int first, int last)

void	rowsInserted (const QModelIndex &parent, int first, int last)

void	rowsRemoved (const QModelIndex &parent, int first, int last)

Public Functions inherited from QObjectPrivate
void	_q_reregisterTimers (void *pointer)

void	addConnection (int signal, Connection *c)

void	cleanConnectionLists ()

void	connectNotify (const char *signal)

void	deleteChildren ()

void	disconnectNotify (const char *signal)

bool	isSender (const QObject receiver, const char signal) const

bool	isSignalConnected (uint signalIdx) const
	Returns true if the signal with index signal_index from object sender is connected. More...

void	moveToThread_helper ()

	QObjectPrivate (int version=QObjectPrivateVersion)

QObjectList	receiverList (const char *signal) const

QObjectList	senderList () const

void	setParent_helper (QObject *)

void	setThreadData_helper (QThreadData currentData, QThreadData targetData)

int	signalIndex (const char *signalName) const
	Returns the signal index used in the internal connectionLists vector. More...

virtual	~QObjectPrivate ()

Public Functions inherited from QObjectData
virtual	~QObjectData ()=0

Static Public Functions
static bool	caseInsensitiveLessThan (const QString &s1, const QString &s2)

static QString	myComputer ()

static int	naturalCompare (const QString &s1, const QString &s2, Qt::CaseSensitivity cs)
	Natural number sort, skips spaces. More...

static bool	nodeCaseInsensitiveLessThan (const QFileSystemModelPrivate::QFileSystemNode &s1, const QFileSystemModelPrivate::QFileSystemNode &s2)

static QString	size (qint64 bytes)

Static Public Functions inherited from QAbstractItemModelPrivate
static const QHash< int, QByteArray > &	defaultRoleNames ()

static QAbstractItemModel *	staticEmptyModel ()

static bool	variantLessThan (const QVariant &v1, const QVariant &v2)
	This function is used by our Q{Tree,Widget,Table}WidgetModel classes to sort. More...

Static Public Functions inherited from QObjectPrivate
static void	clearGuards (QObject *)

static QObjectPrivate *	get (QObject *o)

static void	resetCurrentSender (QObject receiver, Sender currentSender, Sender *previousSender)

static Sender *	setCurrentSender (QObject receiver, Sender sender)

static void	signalSignature (const QMetaMethod &signal, QVarLengthArray< char > *result)

Public Variables
QHash< const QFileSystemNode *, bool >	bypassFilters

QTimer	delayedSortTimer

bool	disableRecursiveSort

QBasicTimer	fetchingTimer

QFileInfoGatherer	fileInfoGatherer

QDir::Filters	filters

bool	forceSort

bool	nameFilterDisables

QList< QRegExp >	nameFilters

bool	readOnly

QHash< QString, QString >	resolvedSymLinks

QFileSystemNode	root

QDir	rootDir

bool	setRootPath

int	sortColumn

Qt::SortOrder	sortOrder

QList< Fetching >	toFetch

Public Variables inherited from QAbstractItemModelPrivate
QStack< Change >	changes

struct QAbstractItemModelPrivate::Persistent	persistent

QHash< int, QByteArray >	roleNames

Qt::DropActions	supportedDragActions

Public Variables inherited from QObjectPrivate
union {
QObject * currentChildBeingDeleted

QAbstractDeclarativeData * declarativeData

};

quint32	connectedSignals [2]

QObjectConnectionListVector *	connectionLists

Sender *	currentSender

QList< QPointer< QObject > >	eventFilters

ExtraData *	extraData

QString	objectName

Connection *	senders

QAtomicPointer< QtSharedPointer::ExternalRefCountData >	sharedRefcount

QThreadData *	threadData

void *	unused

Public Variables inherited from QObjectData
uint	blockSig: 1

QObjectList	children

uint	hasGuards: 1

uint	inEventHandler: 1

uint	inThreadChangeEvent: 1

uint	isWidget: 1

QMetaObject *	metaObject

uint	ownObjectName: 1

QObject *	parent

uint	pendTimer: 1

int	postedEvents

QObject *	q_ptr

uint	receiveChildEvents: 1

uint	sendChildEvents: 1

uint	unused: 22

uint	wasDeleted: 1

Additional Inherited Members
Public Types inherited from QObjectPrivate
typedef void(*	StaticMetaCallFunction) (QObject , QMetaObject::Call, int, void *)

Detailed Description

Definition at line 78 of file qfilesystemmodel_p.h.

Constructors and Destructors

◆ QFileSystemModelPrivate()

QFileSystemModelPrivate::QFileSystemModelPrivate ( )

inline

Definition at line 208 of file qfilesystemmodel_p.h.

                               :
             forceSort(true),
             sortColumn(0),
             sortOrder(Qt::AscendingOrder),
             readOnly(true),
             setRootPath(false),
             filters(QDir::AllEntries | QDir::NoDotAndDotDot | QDir::AllDirs),
             nameFilterDisables(true), // false on windows, true on mac and unix
             disableRecursiveSort(false)
     {
         delayedSortTimer.setSingleShot(true);
     }

Functions

◆ _q_directoryChanged()

void QFileSystemModelPrivate::_q_directoryChanged	(	const QString &	directory,
		const QStringList &	files
	)

Performed quick listing and see if any files have been added or removed, then fetch more information on visible files.

Warning: This function is not part of the public interface.

Definition at line 1697 of file qfilesystemmodel.cpp.

 {
     QFileSystemModelPrivate::QFileSystemNode *parentNode = node(directory, false);
     if (parentNode->children.count() == 0)
         return;
     QStringList toRemove;
 #if defined(Q_OS_SYMBIAN)
     // Filename case must be exact in qBinaryFind below, so create a list of all lowercase names.
     QStringList newFiles;
     for(int i = 0; i < files.size(); i++) {
         newFiles << files.at(i).toLower();
     }
 #else
     QStringList newFiles = files;
 #endif
     qSort(newFiles.begin(), newFiles.end());
     QHash<QString, QFileSystemNode*>::const_iterator i = parentNode->children.constBegin();
     while (i != parentNode->children.constEnd()) {
         QStringList::iterator iterator;
         iterator = qBinaryFind(newFiles.begin(), newFiles.end(),
 #if defined(Q_OS_SYMBIAN)
                     i.value()->fileName.toLower());
 #else
                     i.value()->fileName);
 #endif
         if (iterator == newFiles.end()) {
             toRemove.append(i.value()->fileName);
         }
         ++i;
     }
     for (int i = 0 ; i < toRemove.count() ; ++i )
         removeNode(parentNode, toRemove[i]);
 }

◆ _q_fileSystemChanged()

void QFileSystemModelPrivate::_q_fileSystemChanged	(	const QString &	path,
		const QList< QPair< QString, QFileInfo > > &	updates
	)

The thread has received new information about files, update and emit dataChanged if it has actually changed.

Warning: This function is not part of the public interface.

Definition at line 1868 of file qfilesystemmodel.cpp.

 {
     Q_Q(QFileSystemModel);
     QVector<QString> rowsToUpdate;
     QStringList newFiles;
     QFileSystemModelPrivate::QFileSystemNode *parentNode = node(path, false);
     QModelIndex parentIndex = index(parentNode);
     for (int i = 0; i < updates.count(); ++i) {
         QString fileName = updates.at(i).first;
         Q_ASSERT(!fileName.isEmpty());
         QExtendedInformation info = fileInfoGatherer.getInfo(updates.at(i).second);
         bool previouslyHere = parentNode->children.contains(fileName);
         if (!previouslyHere) {
             addNode(parentNode, fileName, info.fileInfo());
         }
         QFileSystemModelPrivate::QFileSystemNode * node = parentNode->children.value(fileName);
         bool isCaseSensitive = parentNode->caseSensitive();
         if (isCaseSensitive) {
             if (node->fileName != fileName)
                 continue;
         } else {
             if (QString::compare(node->fileName,fileName,Qt::CaseInsensitive) != 0)
                 continue;
         }
         if (isCaseSensitive) {
             Q_ASSERT(node->fileName == fileName);
         } else {
             node->fileName = fileName;
         }
 
         if (info.size() == -1 && !info.isSymLink()) {
             removeNode(parentNode, fileName);
             continue;
         }
         if (*node != info ) {
             node->populate(info);
             bypassFilters.remove(node);
             // brand new information.
             if (filtersAcceptsNode(node)) {
                 if (!node->isVisible) {
                     newFiles.append(fileName);
                 } else {
                     rowsToUpdate.append(fileName);
                 }
             } else {
                 if (node->isVisible) {
                     int visibleLocation = parentNode->visibleLocation(fileName);
                     removeVisibleFile(parentNode, visibleLocation);
                 } else {
                     // The file is not visible, don't do anything
                 }
             }
         }
     }
 
     // bundle up all of the changed signals into as few as possible.
     qSort(rowsToUpdate.begin(), rowsToUpdate.end());
     QString min;
     QString max;
     for (int i = 0; i < rowsToUpdate.count(); ++i) {
         QString value = rowsToUpdate.at(i);
         //##TODO is there a way to bundle signals with QString as the content of the list?
         /*if (min.isEmpty()) {
             min = value;
             if (i != rowsToUpdate.count() - 1)
                 continue;
         }
         if (i != rowsToUpdate.count() - 1) {
             if ((value == min + 1 && max.isEmpty()) || value == max + 1) {
                 max = value;
                 continue;
             }
         }*/
         max = value;
         min = value;
         int visibleMin = parentNode->visibleLocation(min);
         int visibleMax = parentNode->visibleLocation(max);
         if (visibleMin >= 0
             && visibleMin < parentNode->visibleChildren.count()
             && parentNode->visibleChildren.at(visibleMin) == min
             && visibleMax >= 0) {
             QModelIndex bottom = q->index(translateVisibleLocation(parentNode, visibleMin), 0, parentIndex);
             QModelIndex top = q->index(translateVisibleLocation(parentNode, visibleMax), 3, parentIndex);
             emit q->dataChanged(bottom, top);
         }
 
         /*min = QString();
         max = QString();*/
     }
 
     if (newFiles.count() > 0) {
         addVisibleFiles(parentNode, newFiles);
     }
 
     if (newFiles.count() > 0 || (sortColumn != 0 && rowsToUpdate.count() > 0)) {
         forceSort = true;
         delayedSort();
     }
 }

◆ _q_performDelayedSort()

void QFileSystemModelPrivate::_q_performDelayedSort ( )

Warning: This function is not part of the public interface.

Definition at line 1011 of file qfilesystemmodel.cpp.

 {
     Q_Q(QFileSystemModel);
     q->sort(sortColumn, sortOrder);
 }

◆ _q_resolvedName()

void QFileSystemModelPrivate::_q_resolvedName	(	const QString &	fileName,
		const QString &	resolvedName
	)

Warning: This function is not part of the public interface.

Definition at line 1971 of file qfilesystemmodel.cpp.

 {
     resolvedSymLinks[fileName] = resolvedName;
 }

◆ addNode()

QFileSystemModelPrivate::QFileSystemNode * QFileSystemModelPrivate::addNode	(	QFileSystemNode *	parentNode,
		const QString &	fileName,
		const QFileInfo &	info
	)

Warning: This function is not part of the public interface.

Adds a new file to the children of parentNode

WARNING* this will change the count of children

Definition at line 1738 of file qfilesystemmodel.cpp.

Referenced by node().

 {
     // In the common case, itemLocation == count() so check there first
     QFileSystemModelPrivate::QFileSystemNode *node = new QFileSystemModelPrivate::QFileSystemNode(fileName, parentNode);
 #ifndef QT_NO_FILESYSTEMWATCHER
     node->populate(info);
 #endif
 #if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)
     //The parentNode is "" so we are listing the drives
     if (parentNode->fileName.isEmpty()) {
         wchar_t name[MAX_PATH + 1];
         //GetVolumeInformation requires to add trailing backslash
         const QString nodeName = fileName + QLatin1String("\\");
         BOOL success = ::GetVolumeInformation((wchar_t *)(nodeName.utf16()),
                 name, MAX_PATH + 1, NULL, 0, NULL, NULL, 0);
         if (success && name[0])
             node->volumeName = QString::fromWCharArray(name);
     }
 #endif
     parentNode->children.insert(fileName, node);
     return node;
 }

◆ addVisibleFiles()

void QFileSystemModelPrivate::addVisibleFiles	(	QFileSystemNode *	parentNode,
		const QStringList &	newFiles
	)

Warning: This function is not part of the public interface.

File at parentNode->children(itemLocation) was not visible before, but now should be and emit signals if necessary.

WARNING* this will change the visible count

Definition at line 1816 of file qfilesystemmodel.cpp.

Referenced by node().

 {
     Q_Q(QFileSystemModel);
     QModelIndex parent = index(parentNode);
     bool indexHidden = isHiddenByFilter(parentNode, parent);
     if (!indexHidden) {
         q->beginInsertRows(parent, parentNode->visibleChildren.count() , parentNode->visibleChildren.count() + newFiles.count() - 1);
     }
 
     if (parentNode->dirtyChildrenIndex == -1)
         parentNode->dirtyChildrenIndex = parentNode->visibleChildren.count();
 
     for (int i = 0; i < newFiles.count(); ++i) {
             parentNode->visibleChildren.append(newFiles.at(i));
             parentNode->children[newFiles.at(i)]->isVisible = true;
         }
     if (!indexHidden)
       q->endInsertRows();
 }

◆ caseInsensitiveLessThan()

static bool QFileSystemModelPrivate::caseInsensitiveLessThan	(	const QString &	s1,
		const QString &	s2
	)

inlinestatic

Definition at line 272 of file qfilesystemmodel_p.h.

     {
        return QString::compare(s1, s2, Qt::CaseInsensitive) < 0;
     }

◆ delayedSort()

void QFileSystemModelPrivate::delayedSort ( )

inline

Definition at line 267 of file qfilesystemmodel_p.h.

                               {
         if (!delayedSortTimer.isActive())
             delayedSortTimer.start(0);
     }

◆ displayName()

QString QFileSystemModelPrivate::displayName ( const QModelIndex & index ) const

Warning: This function is not part of the public interface.

Definition at line 851 of file qfilesystemmodel.cpp.

 {
 #if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)
     QFileSystemNode *dirNode = node(index);
     if (!dirNode->volumeName.isNull())
         return dirNode->volumeName + QLatin1String(" (") + name(index) + QLatin1Char(')');
 #endif
     return name(index);
 }

◆ filePath()

QString QFileSystemModelPrivate::filePath ( const QModelIndex & index ) const

Definition at line 1329 of file qfilesystemmodel.cpp.

 {
     Q_Q(const QFileSystemModel);
     Q_UNUSED(q);
     if (!index.isValid())
         return QString();
     Q_ASSERT(index.model() == q);
 
     QStringList path;
     QModelIndex idx = index;
     while (idx.isValid()) {
         QFileSystemModelPrivate::QFileSystemNode *dirNode = node(idx);
         if (dirNode)
             path.prepend(dirNode->fileName);
         idx = idx.parent();
     }
     QString fullPath = QDir::fromNativeSeparators(path.join(QDir::separator()));
 #if !defined(Q_OS_WIN) || defined(Q_OS_WINCE)
     if ((fullPath.length() > 2) && fullPath[0] == QLatin1Char('/') && fullPath[1] == QLatin1Char('/'))
         fullPath = fullPath.mid(1);
 #endif
 #if defined(Q_OS_WIN) || defined(Q_OS_SYMBIAN)
     if (fullPath.length() == 2 && fullPath.endsWith(QLatin1Char(':')))
         fullPath.append(QLatin1Char('/'));
 #endif
     return fullPath;
 }

◆ filtersAcceptsNode()

bool QFileSystemModelPrivate::filtersAcceptsNode ( const QFileSystemNode * node ) const

Warning: This function is not part of the public interface.

Returns false if node doesn't pass the filters otherwise true

QDir::Modified is not supported QDir::Drives is not supported

Definition at line 2009 of file qfilesystemmodel.cpp.

 {
     // always accept drives
     if (node->parent == &root || bypassFilters.contains(node))
         return true;
 
     // If we don't know anything yet don't accept it
     if (!node->hasInformation())
         return false;
 
     const bool filterPermissions = ((filters & QDir::PermissionMask)
                                    && (filters & QDir::PermissionMask) != QDir::PermissionMask);
     const bool hideDirs          = !(filters & (QDir::Dirs | QDir::AllDirs));
     const bool hideFiles         = !(filters & QDir::Files);
     const bool hideReadable      = !(!filterPermissions || (filters & QDir::Readable));
     const bool hideWritable      = !(!filterPermissions || (filters & QDir::Writable));
     const bool hideExecutable    = !(!filterPermissions || (filters & QDir::Executable));
     const bool hideHidden        = !(filters & QDir::Hidden);
     const bool hideSystem        = !(filters & QDir::System);
     const bool hideSymlinks      = (filters & QDir::NoSymLinks);
     const bool hideDot           = (filters & QDir::NoDot) || (filters & QDir::NoDotAndDotDot); // ### Qt5: simplify (because NoDotAndDotDot=NoDot|NoDotDot)
     const bool hideDotDot        = (filters & QDir::NoDotDot) || (filters & QDir::NoDotAndDotDot); // ### Qt5: simplify (because NoDotAndDotDot=NoDot|NoDotDot)
 
     // Note that we match the behavior of entryList and not QFileInfo on this and this
     // incompatibility won't be fixed until Qt 5 at least
     bool isDot    = (node->fileName == QLatin1String("."));
     bool isDotDot = (node->fileName == QLatin1String(".."));
     if (   (hideHidden && !(isDot || isDotDot) && node->isHidden())
         || (hideSystem && node->isSystem())
         || (hideDirs && node->isDir())
         || (hideFiles && node->isFile())
         || (hideSymlinks && node->isSymLink())
         || (hideReadable && node->isReadable())
         || (hideWritable && node->isWritable())
         || (hideExecutable && node->isExecutable())
         || (hideDot && isDot)
         || (hideDotDot && isDotDot))
         return false;
 
     return nameFilterDisables || passNameFilters(node);
 }

◆ icon()

QIcon QFileSystemModelPrivate::icon ( const QModelIndex & index ) const

Warning: This function is not part of the public interface.

Definition at line 864 of file qfilesystemmodel.cpp.

 {
     if (!index.isValid())
         return QIcon();
     return node(index)->icon();
 }

◆ index() [1/2]

QModelIndex QFileSystemModelPrivate::index ( const QString & path )

inline

Definition at line 233 of file qfilesystemmodel_p.h.

Referenced by index().

233 { return index(node(path)); }

QFileSystemModelPrivate::node

QFileSystemNode * node(const QModelIndex &index) const

Return the QFileSystemNode that goes to index.

Definition: qfilesystemmodel.cpp:331

QFileSystemModelPrivate::index

QModelIndex index(const QString &path)

Definition: qfilesystemmodel_p.h:233

◆ index() [2/2]

QModelIndex QFileSystemModelPrivate::index ( const QFileSystemNode * node ) const

Definition at line 616 of file qfilesystemmodel.cpp.

 {
     Q_Q(const QFileSystemModel);
     QFileSystemModelPrivate::QFileSystemNode *parentNode = (node ? node->parent : 0);
     if (node == &root || !parentNode)
         return QModelIndex();
 
     // get the parent's row
     Q_ASSERT(node);
     if (!node->isVisible)
         return QModelIndex();
 
     int visualRow = translateVisibleLocation(parentNode, parentNode->visibleLocation(node->fileName));
     return q->createIndex(visualRow, 0, const_cast<QFileSystemNode*>(node));
 }

◆ init()

void QFileSystemModelPrivate::init ( )

Warning: This function is not part of the public interface.

Definition at line 1979 of file qfilesystemmodel.cpp.

 {
     Q_Q(QFileSystemModel);
     qRegisterMetaType<QList<QPair<QString,QFileInfo> > >("QList<QPair<QString,QFileInfo> >");
     q->connect(&fileInfoGatherer, SIGNAL(newListOfFiles(QString,QStringList)),
                q, SLOT(_q_directoryChanged(QString,QStringList)));
     q->connect(&fileInfoGatherer, SIGNAL(updates(QString,QList<QPair<QString,QFileInfo> >)),
             q, SLOT(_q_fileSystemChanged(QString,QList<QPair<QString,QFileInfo> >)));
     q->connect(&fileInfoGatherer, SIGNAL(nameResolved(QString,QString)),
             q, SLOT(_q_resolvedName(QString,QString)));
     q->connect(&fileInfoGatherer, SIGNAL(directoryLoaded(QString)),
                q, SIGNAL(directoryLoaded(QString)));
     q->connect(&delayedSortTimer, SIGNAL(timeout()), q, SLOT(_q_performDelayedSort()), Qt::QueuedConnection);
 
     QHash<int, QByteArray> roles = q->roleNames();
     roles.insertMulti(QFileSystemModel::FileIconRole, "fileIcon"); // == Qt::decoration
     roles.insert(QFileSystemModel::FilePathRole, "filePath");
     roles.insert(QFileSystemModel::FileNameRole, "fileName");
     roles.insert(QFileSystemModel::FilePermissions, "filePermissions");
     q->setRoleNames(roles);
 }

◆ isHiddenByFilter()

bool QFileSystemModelPrivate::isHiddenByFilter	(	QFileSystemNode *	indexNode,
		const QModelIndex &	index
	)		const

inline

Definition at line 227 of file qfilesystemmodel_p.h.

     {
        return (indexNode != &root && !index.isValid());
     }

◆ myComputer()

static QString QFileSystemModelPrivate::myComputer ( )

inlinestatic

Definition at line 255 of file qfilesystemmodel_p.h.

                                        {
         // ### TODO We should query the system to find out what the string should be
         // XP == "My Computer",
         // Vista == "Computer",
         // OS X == "Computer" (sometime user generated) "Benjamin's PowerBook G4"
 #ifdef Q_OS_WIN
         return QFileSystemModel::tr("My Computer");
 #else
         return QFileSystemModel::tr("Computer");
 #endif
     }

◆ name()

QString QFileSystemModelPrivate::name ( const QModelIndex & index ) const

Warning: This function is not part of the public interface.

Definition at line 834 of file qfilesystemmodel.cpp.

 {
     if (!index.isValid())
         return QString();
     QFileSystemNode *dirNode = node(index);
     if (fileInfoGatherer.resolveSymlinks() && !resolvedSymLinks.isEmpty() &&
         dirNode->isSymLink(/* ignoreNtfsSymLinks = */ true)) {
         QString fullPath = QDir::fromNativeSeparators(filePath(index));
         if (resolvedSymLinks.contains(fullPath))
             return resolvedSymLinks[fullPath];
     }
     return dirNode->fileName;
 }

◆ naturalCompare()

int QFileSystemModelPrivate::naturalCompare	(	const QString &	s1,
		const QString &	s2,
		Qt::CaseSensitivity	cs
	)

static

Natural number sort, skips spaces.

Examples: 1, 2, 10, 55, 100 01.jpg, 2.jpg, 10.jpg

Note on the algorithm: Only as many characters as necessary are looked at and at most they all are looked at once.

Slower then QString::compare() (of course)

Definition at line 1035 of file qfilesystemmodel.cpp.

Referenced by QFileSystemModelSorter::compareNodes().

 {
     for (int l1 = 0, l2 = 0; l1 <= s1.count() && l2 <= s2.count(); ++l1, ++l2) {
         // skip spaces, tabs and 0's
         QChar c1 = getNextChar(s1, l1);
         while (c1.isSpace())
             c1 = getNextChar(s1, ++l1);
         QChar c2 = getNextChar(s2, l2);
         while (c2.isSpace())
             c2 = getNextChar(s2, ++l2);
 
         if (c1.isDigit() && c2.isDigit()) {
             while (c1.digitValue() == 0)
                 c1 = getNextChar(s1, ++l1);
             while (c2.digitValue() == 0)
                 c2 = getNextChar(s2, ++l2);
 
             int lookAheadLocation1 = l1;
             int lookAheadLocation2 = l2;
             int currentReturnValue = 0;
             // find the last digit, setting currentReturnValue as we go if it isn't equal
             for (
                 QChar lookAhead1 = c1, lookAhead2 = c2;
                 (lookAheadLocation1 <= s1.length() && lookAheadLocation2 <= s2.length());
                 lookAhead1 = getNextChar(s1, ++lookAheadLocation1),
                 lookAhead2 = getNextChar(s2, ++lookAheadLocation2)
                 ) {
                 bool is1ADigit = !lookAhead1.isNull() && lookAhead1.isDigit();
                 bool is2ADigit = !lookAhead2.isNull() && lookAhead2.isDigit();
                 if (!is1ADigit && !is2ADigit)
                     break;
                 if (!is1ADigit)
                     return -1;
                 if (!is2ADigit)
                     return 1;
                 if (currentReturnValue == 0) {
                     if (lookAhead1 < lookAhead2) {
                         currentReturnValue = -1;
                     } else if (lookAhead1 > lookAhead2) {
                         currentReturnValue = 1;
                     }
                 }
             }
             if (currentReturnValue != 0)
                 return currentReturnValue;
         }
 
         if (cs == Qt::CaseInsensitive) {
             if (!c1.isLower()) c1 = c1.toLower();
             if (!c2.isLower()) c2 = c2.toLower();
         }
         int r = QString::localeAwareCompare(c1, c2);
         if (r < 0)
             return -1;
         if (r > 0)
             return 1;
     }
     // The two strings are the same (02 == 2) so fall back to the normal sort
     return QString::compare(s1, s2, cs);
 }

◆ node() [1/2]

QFileSystemModelPrivate::QFileSystemNode * QFileSystemModelPrivate::node ( const QModelIndex & index ) const

Return the QFileSystemNode that goes to index.

Warning: This function is not part of the public interface.

Definition at line 331 of file qfilesystemmodel.cpp.

 {
     if (!index.isValid())
         return const_cast<QFileSystemNode*>(&root);
     QFileSystemModelPrivate::QFileSystemNode *indexNode = static_cast<QFileSystemModelPrivate::QFileSystemNode*>(index.internalPointer());
     Q_ASSERT(indexNode);
     return indexNode;
 }

◆ node() [2/2]

QFileSystemModelPrivate::QFileSystemNode * QFileSystemModelPrivate::node	(	const QString &	path,
		bool	fetch = `true`
	)		const

Warning: This function is not part of the public interface.

Given a path return the matching QFileSystemNode or &root if invalid

Definition at line 380 of file qfilesystemmodel.cpp.

 {
     Q_Q(const QFileSystemModel);
     Q_UNUSED(q);
     if (path.isEmpty() || path == myComputer() || path.startsWith(QLatin1Char(':')))
         return const_cast<QFileSystemModelPrivate::QFileSystemNode*>(&root);
 
     // Construct the nodes up to the new root path if they need to be built
     QString absolutePath;
 #ifdef Q_OS_WIN32
     QString longPath = qt_GetLongPathName(path);
 #else
     QString longPath = path;
 #endif
     if (longPath == rootDir.path())
         absolutePath = rootDir.absolutePath();
     else
         absolutePath = QDir(longPath).absolutePath();
 
     // ### TODO can we use bool QAbstractFileEngine::caseSensitive() const?
     QStringList pathElements = absolutePath.split(QLatin1Char('/'), QString::SkipEmptyParts);
     if ((pathElements.isEmpty())
 #if (!defined(Q_OS_WIN) || defined(Q_OS_WINCE)) && !defined(Q_OS_SYMBIAN)
         && QDir::fromNativeSeparators(longPath) != QLatin1String("/")
 #endif
         )
         return const_cast<QFileSystemModelPrivate::QFileSystemNode*>(&root);
     QModelIndex index = QModelIndex(); // start with "My Computer"
 #if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)
     if (absolutePath.startsWith(QLatin1String("//"))) { // UNC path
         QString host = QLatin1String("\\\\") + pathElements.first();
         if (absolutePath == QDir::fromNativeSeparators(host))
             absolutePath.append(QLatin1Char('/'));
         if (longPath.endsWith(QLatin1Char('/')) && !absolutePath.endsWith(QLatin1Char('/')))
             absolutePath.append(QLatin1Char('/'));
         int r = 0;
         QFileSystemModelPrivate::QFileSystemNode *rootNode = const_cast<QFileSystemModelPrivate::QFileSystemNode*>(&root);
         if (!root.children.contains(host.toLower())) {
             if (pathElements.count() == 1 && !absolutePath.endsWith(QLatin1Char('/')))
                 return rootNode;
             QFileInfo info(host);
             if (!info.exists())
                 return rootNode;
             QFileSystemModelPrivate *p = const_cast<QFileSystemModelPrivate*>(this);
             p->addNode(rootNode, host,info);
             p->addVisibleFiles(rootNode, QStringList(host));
         }
         r = rootNode->visibleLocation(host);
         r = translateVisibleLocation(rootNode, r);
         index = q->index(r, 0, QModelIndex());
         pathElements.pop_front();
     } else
 #endif
 
 #if (defined(Q_OS_WIN) && !defined(Q_OS_WINCE)) || defined(Q_OS_SYMBIAN)
     {
         if (!pathElements.at(0).contains(QLatin1String(":"))) {
             // The reason we express it like this instead of with anonymous, temporary
             // variables, is to workaround a compiler crash with Q_CC_NOKIAX86.
             QString rootPath = QDir(longPath).rootPath();
             pathElements.prepend(rootPath);
         }
         if (pathElements.at(0).endsWith(QLatin1Char('/')))
             pathElements[0].chop(1);
     }
 #else
     // add the "/" item, since it is a valid path element on Unix
     if (absolutePath[0] == QLatin1Char('/'))
         pathElements.prepend(QLatin1String("/"));
 #endif
 
     QFileSystemModelPrivate::QFileSystemNode *parent = node(index);
 
     for (int i = 0; i < pathElements.count(); ++i) {
         QString element = pathElements.at(i);
 #ifdef Q_OS_WIN
         // On Windows, "filename......." and "filename" are equivalent Task #133928
         while (element.endsWith(QLatin1Char('.')))
             element.chop(1);
 #endif
         bool alreadyExisted = parent->children.contains(element);
 
         // we couldn't find the path element, we create a new node since we
         // _know_ that the path is valid
         if (alreadyExisted) {
             if ((parent->children.count() == 0)
                 || (parent->caseSensitive()
                     && parent->children.value(element)->fileName != element)
                 || (!parent->caseSensitive()
                     && parent->children.value(element)->fileName.toLower() != element.toLower()))
                 alreadyExisted = false;
         }
 
         QFileSystemModelPrivate::QFileSystemNode *node;
         if (!alreadyExisted) {
             // Someone might call ::index("file://cookie/monster/doesn't/like/veggies"),
             // a path that doesn't exists, I.E. don't blindly create directories.
             QFileInfo info(absolutePath);
             if (!info.exists())
                 return const_cast<QFileSystemModelPrivate::QFileSystemNode*>(&root);
             QFileSystemModelPrivate *p = const_cast<QFileSystemModelPrivate*>(this);
             node = p->addNode(parent, element,info);
 #ifndef QT_NO_FILESYSTEMWATCHER
             node->populate(fileInfoGatherer.getInfo(info));
 #endif
         } else {
             node = parent->children.value(element);
         }
 
         Q_ASSERT(node);
         if (!node->isVisible) {
             // It has been filtered out
             if (alreadyExisted && node->hasInformation() && !fetch)
                 return const_cast<QFileSystemModelPrivate::QFileSystemNode*>(&root);
 
             QFileSystemModelPrivate *p = const_cast<QFileSystemModelPrivate*>(this);
             p->addVisibleFiles(parent, QStringList(element));
             if (!p->bypassFilters.contains(node))
                 p->bypassFilters[node] = 1;
             QString dir = q->filePath(this->index(parent));
             if (!node->hasInformation() && fetch) {
                 Fetching f;
                 f.dir = dir;
                 f.file = element;
                 f.node = node;
                 p->toFetch.append(f);
                 p->fetchingTimer.start(0, const_cast<QFileSystemModel*>(q));
             }
         }
         parent = node;
     }
 
     return parent;
 }

◆ nodeCaseInsensitiveLessThan()

static bool QFileSystemModelPrivate::nodeCaseInsensitiveLessThan	(	const QFileSystemModelPrivate::QFileSystemNode &	s1,
		const QFileSystemModelPrivate::QFileSystemNode &	s2
	)

inlinestatic

Definition at line 277 of file qfilesystemmodel_p.h.

     {
        return QString::compare(s1.fileName, s2.fileName, Qt::CaseInsensitive) < 0;
     }

◆ passNameFilters()

bool QFileSystemModelPrivate::passNameFilters ( const QFileSystemNode * node ) const

Definition at line 2056 of file qfilesystemmodel.cpp.

 {
 #ifndef QT_NO_REGEXP
     if (nameFilters.isEmpty())
         return true;
 
     // Check the name regularexpression filters
     if (!(node->isDir() && (filters & QDir::AllDirs))) {
         for (int i = 0; i < nameFilters.size(); ++i) {
             if (nameFilters.at(i).exactMatch(node->fileName))
                 return true;
         }
         return false;
     }
 #endif
     return true;
 }

◆ removeNode()

void QFileSystemModelPrivate::removeNode	(	QFileSystemModelPrivate::QFileSystemNode *	parentNode,
		const QString &	name
	)

Warning: This function is not part of the public interface.

File at parentNode->children(itemLocation) has been removed, remove from the lists and emit signals if necessary

WARNING* this will change the count of children and could change visibleChildren

Definition at line 1769 of file qfilesystemmodel.cpp.

 {
     Q_Q(QFileSystemModel);
     QModelIndex parent = index(parentNode);
     bool indexHidden = isHiddenByFilter(parentNode, parent);
 
     int vLocation = parentNode->visibleLocation(name);
     if (vLocation >= 0 && !indexHidden)
         q->beginRemoveRows(parent, translateVisibleLocation(parentNode, vLocation),
                                        translateVisibleLocation(parentNode, vLocation));
     QFileSystemNode * node = parentNode->children.take(name);
     delete node;
     // cleanup sort files after removing rather then re-sorting which is O(n)
     if (vLocation >= 0)
         parentNode->visibleChildren.removeAt(vLocation);
     if (vLocation >= 0 && !indexHidden)
         q->endRemoveRows();
 }

◆ removeVisibleFile()

void QFileSystemModelPrivate::removeVisibleFile	(	QFileSystemNode *	parentNode,
		int	vLocation
	)

Warning: This function is not part of the public interface.

File was visible before, but now should NOT be

WARNING* this will change the visible count

Definition at line 1843 of file qfilesystemmodel.cpp.

 {
     Q_Q(QFileSystemModel);
     if (vLocation == -1)
         return;
     QModelIndex parent = index(parentNode);
     bool indexHidden = isHiddenByFilter(parentNode, parent);
     if (!indexHidden)
         q->beginRemoveRows(parent, translateVisibleLocation(parentNode, vLocation),
                                        translateVisibleLocation(parentNode, vLocation));
     parentNode->children[parentNode->visibleChildren.at(vLocation)]->isVisible = false;
     parentNode->visibleChildren.removeAt(vLocation);
     if (!indexHidden)
         q->endRemoveRows();
 }

◆ size() [1/2]

QString QFileSystemModelPrivate::size ( const QModelIndex & index ) const

Warning: This function is not part of the public interface.

Definition at line 768 of file qfilesystemmodel.cpp.

 {
     if (!index.isValid())
         return QString();
     const QFileSystemNode *n = node(index);
     if (n->isDir()) {
 #ifdef Q_OS_MAC
         return QLatin1String("--");
 #else
         return QLatin1String("");
 #endif
     // Windows   - ""
     // OS X      - "--"
     // Konqueror - "4 KB"
     // Nautilus  - "9 items" (the number of children)
     }
     return size(n->size());
 }

◆ size() [2/2]

QString QFileSystemModelPrivate::size ( qint64 bytes )

static

Definition at line 787 of file qfilesystemmodel.cpp.

 {
     // According to the Si standard KB is 1000 bytes, KiB is 1024
     // but on windows sizes are calculated by dividing by 1024 so we do what they do.
     const qint64 kb = 1024;
     const qint64 mb = 1024 * kb;
     const qint64 gb = 1024 * mb;
     const qint64 tb = 1024 * gb;
     if (bytes >= tb)
         return QFileSystemModel::tr("%1 TB").arg(QLocale().toString(qreal(bytes) / tb, 'f', 3));
     if (bytes >= gb)
         return QFileSystemModel::tr("%1 GB").arg(QLocale().toString(qreal(bytes) / gb, 'f', 2));
     if (bytes >= mb)
         return QFileSystemModel::tr("%1 MB").arg(QLocale().toString(qreal(bytes) / mb, 'f', 1));
     if (bytes >= kb)
         return QFileSystemModel::tr("%1 KB").arg(QLocale().toString(bytes / kb));
     return QFileSystemModel::tr("%1 bytes").arg(QLocale().toString(bytes));
 }

◆ sortChildren()

void QFileSystemModelPrivate::sortChildren	(	int	column,
		const QModelIndex &	parent
	)

Definition at line 1150 of file qfilesystemmodel.cpp.

 {
     Q_Q(QFileSystemModel);
     QFileSystemModelPrivate::QFileSystemNode *indexNode = node(parent);
     if (indexNode->children.count() == 0)
         return;
 
     QList<QPair<QFileSystemModelPrivate::QFileSystemNode*, int> > values;
     QHash<QString, QFileSystemNode *>::const_iterator iterator;
     int i = 0;
     for(iterator = indexNode->children.begin() ; iterator != indexNode->children.end() ; ++iterator) {
         if (filtersAcceptsNode(iterator.value())) {
             values.append(QPair<QFileSystemModelPrivate::QFileSystemNode*, int>((iterator.value()), i));
         } else {
             iterator.value()->isVisible = false;
         }
         i++;
     }
     QFileSystemModelSorter ms(column);
     qStableSort(values.begin(), values.end(), ms);
     // First update the new visible list
     indexNode->visibleChildren.clear();
     //No more dirty item we reset our internal dirty index
     indexNode->dirtyChildrenIndex = -1;
     for (int i = 0; i < values.count(); ++i) {
         indexNode->visibleChildren.append(values.at(i).first->fileName);
         values.at(i).first->isVisible = true;
     }
 
     if (!disableRecursiveSort) {
         for (int i = 0; i < q->rowCount(parent); ++i) {
             const QModelIndex childIndex = q->index(i, 0, parent);
             QFileSystemModelPrivate::QFileSystemNode *indexNode = node(childIndex);
             //Only do a recursive sort on visible nodes
             if (indexNode->isVisible)
                 sortChildren(column, childIndex);
         }
     }
 }

◆ time()

QString QFileSystemModelPrivate::time ( const QModelIndex & index ) const

Warning: This function is not part of the public interface.

Definition at line 809 of file qfilesystemmodel.cpp.

 {
     if (!index.isValid())
         return QString();
 #ifndef QT_NO_DATESTRING
     return node(index)->lastModified().toString(Qt::SystemLocaleDate);
 #else
     Q_UNUSED(index);
     return QString();
 #endif
 }

◆ translateVisibleLocation()

int QFileSystemModelPrivate::translateVisibleLocation	(	QFileSystemNode *	parent,
		int	row
	)		const

inline

Definition at line 243 of file qfilesystemmodel_p.h.

                                                                                 {
         if (sortOrder != Qt::AscendingOrder) {
             if (parent->dirtyChildrenIndex == -1)
                 return parent->visibleChildren.count() - row - 1;
 
             if (row < parent->dirtyChildrenIndex)
                 return parent->dirtyChildrenIndex - row - 1;
         }
 
         return row;
     }

◆ type()

QString QFileSystemModelPrivate::type ( const QModelIndex & index ) const

Definition at line 824 of file qfilesystemmodel.cpp.

 {
     if (!index.isValid())
         return QString();
     return node(index)->type();
 }

Properties

◆ bypassFilters

QHash<const QFileSystemNode*, bool> QFileSystemModelPrivate::bypassFilters

Definition at line 309 of file qfilesystemmodel_p.h.

Referenced by node().

◆ delayedSortTimer

QTimer QFileSystemModelPrivate::delayedSortTimer

Definition at line 302 of file qfilesystemmodel_p.h.

◆ disableRecursiveSort

bool QFileSystemModelPrivate::disableRecursiveSort

Definition at line 314 of file qfilesystemmodel_p.h.

◆ fetchingTimer

QBasicTimer QFileSystemModelPrivate::fetchingTimer

Definition at line 323 of file qfilesystemmodel_p.h.

Referenced by node().

◆ fileInfoGatherer

QFileInfoGatherer QFileSystemModelPrivate::fileInfoGatherer

Definition at line 300 of file qfilesystemmodel_p.h.

Referenced by QFileSystemModel::remove(), and QFileSystemModel::rmdir().

◆ filters

QDir::Filters QFileSystemModelPrivate::filters

Definition at line 308 of file qfilesystemmodel_p.h.

◆ forceSort

bool QFileSystemModelPrivate::forceSort

Definition at line 303 of file qfilesystemmodel_p.h.

◆ nameFilterDisables

bool QFileSystemModelPrivate::nameFilterDisables

Definition at line 310 of file qfilesystemmodel_p.h.

◆ nameFilters

QList<QRegExp> QFileSystemModelPrivate::nameFilters

Definition at line 316 of file qfilesystemmodel_p.h.

◆ readOnly

bool QFileSystemModelPrivate::readOnly

Definition at line 306 of file qfilesystemmodel_p.h.

◆ resolvedSymLinks

QHash<QString, QString> QFileSystemModelPrivate::resolvedSymLinks

Definition at line 319 of file qfilesystemmodel_p.h.

◆ root

QFileSystemNode QFileSystemModelPrivate::root

Definition at line 321 of file qfilesystemmodel_p.h.

◆ rootDir

QDir QFileSystemModelPrivate::rootDir

Definition at line 298 of file qfilesystemmodel_p.h.

◆ setRootPath

bool QFileSystemModelPrivate::setRootPath

Definition at line 307 of file qfilesystemmodel_p.h.

◆ sortColumn

int QFileSystemModelPrivate::sortColumn

Definition at line 304 of file qfilesystemmodel_p.h.

◆ sortOrder

Qt::SortOrder QFileSystemModelPrivate::sortOrder

Definition at line 305 of file qfilesystemmodel_p.h.

◆ toFetch

QList<Fetching> QFileSystemModelPrivate::toFetch

Definition at line 329 of file qfilesystemmodel_p.h.

Referenced by node().

The documentation for this class was generated from the following files:

/src/gui/dialogs/qfilesystemmodel_p.h
/src/gui/dialogs/qfilesystemmodel.cpp

Classes

Public Functions

Static Public Functions

Public Variables

Additional Inherited Members

Detailed Description

Constructors and Destructors

◆ QFileSystemModelPrivate()

Functions

◆ _q_directoryChanged()

◆ _q_fileSystemChanged()

◆ _q_performDelayedSort()

◆ _q_resolvedName()

◆ addNode()

◆ addVisibleFiles()

◆ caseInsensitiveLessThan()

◆ delayedSort()

◆ displayName()

◆ filePath()

◆ filtersAcceptsNode()

◆ icon()

◆ index() [1/2]

◆ index() [2/2]

◆ init()

◆ isHiddenByFilter()

◆ myComputer()

◆ name()

◆ naturalCompare()

◆ node() [1/2]

◆ node() [2/2]

◆ nodeCaseInsensitiveLessThan()

◆ passNameFilters()

◆ removeNode()

◆ removeVisibleFile()

◆ size() [1/2]

◆ size() [2/2]

◆ sortChildren()

◆ time()

◆ translateVisibleLocation()

◆ type()

Properties

◆ bypassFilters

◆ delayedSortTimer

◆ disableRecursiveSort

◆ fetchingTimer

◆ fileInfoGatherer

◆ filters

◆ forceSort

◆ nameFilterDisables

◆ nameFilters

◆ readOnly

◆ resolvedSymLinks

◆ root

◆ rootDir

◆ setRootPath

◆ sortColumn

◆ sortOrder

◆ toFetch