1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtGui module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "qfilesystemmodel_p.h"

    43 #include "qfilesystemmodel.h"

    44 #include <qlocale.h>

    45 #include <qmime.h>

    46 #include <qurl.h>

    47 #include <qdebug.h>

    48 #include <qmessagebox.h>

    49 #include <qapplication.h>

    50 

    51 #ifdef Q_OS_WIN

    52 #include <qt_windows.h>

    53 #endif

    54 

    55 QT_BEGIN_NAMESPACE

    56 

    57 #ifndef QT_NO_FILESYSTEMMODEL

    58 

    59 /*!

    60     \enum QFileSystemModel::Roles

    61     \value FileIconRole

    62     \value FilePathRole

    63     \value FileNameRole

    64     \value FilePermissions

    65 */

    66 

    67 /*!

    68     \class QFileSystemModel

    69     \since 4.4

    70 

    71     \brief The QFileSystemModel class provides a data model for the local filesystem.

    72 

    73     \ingroup model-view

    74 

    75     This class provides access to the local filesystem, providing functions

    76     for renaming and removing files and directories, and for creating new

    77     directories. In the simplest case, it can be used with a suitable display

    78     widget as part of a browser or filter.

    79 

    80     QFileSystemModel will not fetch any files or directories until setRootPath

    81     is called.  This will prevent any unnecessary querying on the file system

    82     until that point such as listing the drives on Windows.

    83 

    84     Unlike the QDirModel, QFileSystemModel uses a separate thread to populate

    85     itself so it will not cause the main thread to hang as the file system

    86     is being queried.  Calls to rowCount() will return 0 until the model

    87     populates a directory.

    88 

    89     QFileSystemModel keeps a cache with file information. The cache is

    90     automatically kept up to date using the QFileSystemWatcher.

    91 

    92     QFileSystemModel can be accessed using the standard interface provided by

    93     QAbstractItemModel, but it also provides some convenience functions that are

    94     specific to a directory model.

    95     The fileInfo(), isDir(), name(), and path() functions provide information

    96     about the underlying files and directories related to items in the model.

    97     Directories can be created and removed using mkdir(), rmdir().

    98 

    99     \note QFileSystemModel requires an instance of a GUI application.

   100 

   101     \sa {Model Classes}

   102 */

   103 

   104 /*!

   105     \fn bool QFileSystemModel::rmdir(const QModelIndex &index) const

   106 

   107     Removes the directory corresponding to the model item \a index in the

   108     file system model and \bold{deletes the corresponding directory from the

   109     file system}, returning true if successful. If the directory cannot be

   110     removed, false is returned.

   111 

   112     \warning This function deletes directories from the file system; it does

   113     \bold{not} move them to a location where they can be recovered.

   114 

   115     \sa remove()

   116 */

   117 

   118 /*!

   119     \fn QIcon QFileSystemModel::fileName(const QModelIndex &index) const

   120 

   121     Returns the file name for the item stored in the model under the given

   122     \a index.

   123 */

   124 

   125 /*!

   126     \fn QIcon QFileSystemModel::fileIcon(const QModelIndex &index) const

   127 

   128     Returns the icon for the item stored in the model under the given

   129     \a index.

   130 */

   131 

   132 /*!

   133     \fn QFileInfo QFileSystemModel::fileInfo(const QModelIndex &index) const

   134 

   135     Returns the QFileInfo for the item stored in the model under the given

   136     \a index.

   137 */

   138 

   139 /*!

   140     \fn void QFileSystemModel::rootPathChanged(const QString &newPath);

   141 

   142     This signal is emitted whenever the root path has been changed to a \a newPath.

   143 */

   144 

   145 /*!

   146     \fn void QFileSystemModel::fileRenamed(const QString &path, const QString &oldName, const QString &newName)

   147 

   148     This signal is emitted whenever a file with the \a oldName is successfully

   149     renamed to \a newName.  The file is located in in the directory \a path.

   150 */

   151 

   152 /*!

   153     \fn bool QFileSystemModel::remove(const QModelIndex &index) const

   154 

   155     Removes the model item \a index from the file system model and \bold{deletes the

   156     corresponding file from the file system}, returning true if successful. If the

   157     item cannot be removed, false is returned.

   158 

   159     \warning This function deletes files from the file system; it does \bold{not}

   160     move them to a location where they can be recovered.

   161 

   162     \sa rmdir()

   163 */

   164 

   165 bool QFileSystemModel::remove(const QModelIndex &aindex) const

   166 {

   167     //### TODO optim

   168     QString path = filePath(aindex);

   169     QFileSystemModelPrivate * d = const_cast<QFileSystemModelPrivate*>(d_func());

   170     d->fileInfoGatherer.removePath(path);

   171     QDirIterator it(path,

   172             QDir::AllDirs | QDir:: Files | QDir::NoDotAndDotDot,

   173             QDirIterator::Subdirectories);

   174     QStringList children;

   175     while (it.hasNext())

   176         children.prepend(it.next());

   177     children.append(path);

   178 

   179     bool error = false;

   180     for (int i = 0; i < children.count(); ++i) {

   181         QFileInfo info(children.at(i));

   182         QModelIndex modelIndex = index(children.at(i));

   183         if (info.isDir()) {

   184             QDir dir;

   185             if (children.at(i) != path)

   186                 error |= remove(modelIndex);

   187             error |= rmdir(modelIndex);

   188         } else {

   189             error |= QFile::remove(filePath(modelIndex));

   190         }

   191     }

   192     return error;

   193 }

   194 

   195 /*!

   196   Constructs a file system model with the given \a parent.

   197 */

   198 QFileSystemModel::QFileSystemModel(QObject *parent)

   199     : QAbstractItemModel(*new QFileSystemModelPrivate, parent)

   200 {

   201     Q_D(QFileSystemModel);

   202     d->init();

   203 }

   204 

   205 /*!

   206     \internal

   207 */

   208 QFileSystemModel::QFileSystemModel(QFileSystemModelPrivate &dd, QObject *parent)

   209     : QAbstractItemModel(dd, parent)

   210 {

   211     Q_D(QFileSystemModel);

   212     d->init();

   213 }

   214 

   215 /*!

   216   Destroys this file system model.

   217 */

   218 QFileSystemModel::~QFileSystemModel()

   219 {

   220 }

   221 

   222 /*!

   223     \reimp

   224 */

   225 QModelIndex QFileSystemModel::index(int row, int column, const QModelIndex &parent) const

   226 {

   227     Q_D(const QFileSystemModel);

   228     if (row < 0 || column < 0 || row >= rowCount(parent) || column >= columnCount(parent))

   229         return QModelIndex();

   230 

   231     // get the parent node

   232     QFileSystemModelPrivate::QFileSystemNode *parentNode = (d->indexValid(parent) ? d->node(parent) :

   233                                                    const_cast<QFileSystemModelPrivate::QFileSystemNode*>(&d->root));

   234     Q_ASSERT(parentNode);

   235 

   236     // now get the internal pointer for the index

   237     QString childName = parentNode->visibleChildren[d->translateVisibleLocation(parentNode, row)];

   238     const QFileSystemModelPrivate::QFileSystemNode *indexNode = parentNode->children.value(childName);

   239     Q_ASSERT(indexNode);

   240 

   241     return createIndex(row, column, const_cast<QFileSystemModelPrivate::QFileSystemNode*>(indexNode));

   242 }

   243 

   244 /*!

   245     \overload

   246 

   247     Returns the model item index for the given \a path and \a column.

   248 */

   249 QModelIndex QFileSystemModel::index(const QString &path, int column) const

   250 {

   251     Q_D(const QFileSystemModel);

   252     QFileSystemModelPrivate::QFileSystemNode *node = d->node(path, false);

   253     QModelIndex idx = d->index(node);

   254     if (idx.column() != column)

   255         idx = idx.sibling(idx.row(), column);

   256     return idx;

   257 }

   258 

   259 /*!

   260     \internal

   261 

   262     Return the QFileSystemNode that goes to index.

   263   */

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

   265 {

   266     if (!index.isValid())

   267         return const_cast<QFileSystemNode*>(&root);

   268     QFileSystemModelPrivate::QFileSystemNode *indexNode = static_cast<QFileSystemModelPrivate::QFileSystemNode*>(index.internalPointer());

   269     Q_ASSERT(indexNode);

   270     return indexNode;

   271 }

   272 

   273 #ifdef Q_OS_WIN

   274 static QString qt_GetLongPathName(const QString &strShortPath)

   275 {

   276     QString longPath;

   277     int i = 0;

   278     if (strShortPath == QLatin1String(".")

   279         || (strShortPath.startsWith(QLatin1String("//")))

   280         || (strShortPath.startsWith(QLatin1String("\\\\")))) // unc

   281         return strShortPath;

   282     QString::const_iterator it = strShortPath.constBegin();

   283     QString::const_iterator constEnd = strShortPath.constEnd();

   284     do {

   285         bool isSep = (*it == QLatin1Char('\\') || *it == QLatin1Char('/'));

   286         if (isSep || it == constEnd) {

   287             QString section = (it == constEnd ? strShortPath : strShortPath.left(i));

   288             // FindFirstFile does not handle volumes ("C:"), so we have to catch that ourselves.

   289             if (section.endsWith(QLatin1Char(':'))) {

   290                 longPath.append(section.toUpper());

   291             } else {

   292                 HANDLE h;

   293 #ifndef Q_OS_WINCE

   294                 //We add the extend length prefix to handle long path

   295                 QString longSection = QLatin1String("\\\\?\\")+QDir::toNativeSeparators(section);

   296 #else

   297                 QString longSection = QDir::toNativeSeparators(section);

   298 #endif

   299                 WIN32_FIND_DATA findData;

   300                 h = ::FindFirstFile((wchar_t*)longSection.utf16(), &findData);

   301                 if (h != INVALID_HANDLE_VALUE) {

   302                     longPath.append(QString::fromWCharArray(findData.cFileName));

   303                     ::FindClose(h);

   304                 } else {

   305                     longPath.append(section);

   306                     break;

   307                 }

   308             }

   309             if (it != constEnd)

   310                 longPath.append(*it);

   311             else

   312                 break;

   313         }

   314         ++it;

   315         if (isSep && it == constEnd)    // break out if the last character is a separator

   316             break;

   317         ++i;

   318     } while (true);

   319     return longPath;

   320 }

   321 #endif

   322 

   323 /*!

   324     \internal

   325 

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

   327 */

   328 QFileSystemModelPrivate::QFileSystemNode *QFileSystemModelPrivate::node(const QString &path, bool fetch) const

   329 {

   330     Q_Q(const QFileSystemModel);

   331     Q_UNUSED(q);

   332     if (path.isEmpty() || path == myComputer() || path.startsWith(QLatin1Char(':')))

   333         return const_cast<QFileSystemModelPrivate::QFileSystemNode*>(&root);

   334 

   335     // Construct the nodes up to the new root path if they need to be built

   336     QString absolutePath;

   337 #ifdef Q_OS_WIN

   338     QString longPath = qt_GetLongPathName(path);

   339 #else

   340     QString longPath = path;

   341 #endif

   342     if (longPath == rootDir.path())

   343         absolutePath = rootDir.absolutePath();

   344     else

   345         absolutePath = QDir(longPath).absolutePath();

   346 

   347     // ### TODO can we use bool QAbstractFileEngine::caseSensitive() const?

   348     QStringList pathElements = absolutePath.split(QLatin1Char('/'), QString::SkipEmptyParts);

   349     if ((pathElements.isEmpty())

   350 #if (!defined(Q_OS_WIN) || defined(Q_OS_WINCE)) && !defined(Q_OS_SYMBIAN)

   351         && QDir::fromNativeSeparators(longPath) != QLatin1String("/")

   352 #endif

   353         )

   354         return const_cast<QFileSystemModelPrivate::QFileSystemNode*>(&root);

   355     QModelIndex index = QModelIndex(); // start with "My Computer"

   356 #if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)

   357     if (absolutePath.startsWith(QLatin1String("//"))) { // UNC path

   358         QString host = QLatin1String("\\\\") + pathElements.first();

   359         if (absolutePath == QDir::fromNativeSeparators(host))

   360             absolutePath.append(QLatin1Char('/'));

   361         if (longPath.endsWith(QLatin1Char('/')) && !absolutePath.endsWith(QLatin1Char('/')))

   362             absolutePath.append(QLatin1Char('/'));

   363         int r = 0;

   364         QFileSystemModelPrivate::QFileSystemNode *rootNode = const_cast<QFileSystemModelPrivate::QFileSystemNode*>(&root);

   365         if (!root.children.contains(host.toLower())) {

   366             if (pathElements.count() == 1 && !absolutePath.endsWith(QLatin1Char('/')))

   367                 return rootNode;

   368             QFileInfo info(host);

   369             if (!info.exists())

   370                 return rootNode;

   371             QFileSystemModelPrivate *p = const_cast<QFileSystemModelPrivate*>(this);

   372             p->addNode(rootNode, host,info);

   373             p->addVisibleFiles(rootNode, QStringList(host));

   374         }

   375         r = rootNode->visibleLocation(host);

   376         r = translateVisibleLocation(rootNode, r);

   377         index = q->index(r, 0, QModelIndex());

   378         pathElements.pop_front();

   379     } else

   380 #endif

   381 

   382 #if (defined(Q_OS_WIN) && !defined(Q_OS_WINCE)) || defined(Q_OS_SYMBIAN)

   383     {

   384         if (!pathElements.at(0).contains(QLatin1String(":"))) {

   385             // The reason we express it like this instead of with anonymous, temporary

   386             // variables, is to workaround a compiler crash with Q_CC_NOKIAX86.

   387             QString rootPath = QDir(longPath).rootPath();

   388             pathElements.prepend(rootPath);

   389         }

   390         if (pathElements.at(0).endsWith(QLatin1Char('/')))

   391             pathElements[0].chop(1);

   392     }

   393 #else

   394     // add the "/" item, since it is a valid path element on Unix

   395     if (absolutePath[0] == QLatin1Char('/'))

   396         pathElements.prepend(QLatin1String("/"));

   397 #endif

   398 

   399     QFileSystemModelPrivate::QFileSystemNode *parent = node(index);

   400 

   401     for (int i = 0; i < pathElements.count(); ++i) {

   402         QString element = pathElements.at(i);

   403 #ifdef Q_OS_WIN

   404         // On Windows, "filename......." and "filename" are equivalent Task #133928

   405         while (element.endsWith(QLatin1Char('.')))

   406             element.chop(1);

   407 #endif

   408         bool alreadyExisted = parent->children.contains(element);

   409 

   410         // we couldn't find the path element, we create a new node since we

   411         // _know_ that the path is valid

   412         if (alreadyExisted) {

   413             if ((parent->children.count() == 0)

   414                 || (parent->caseSensitive()

   415                     && parent->children.value(element)->fileName != element)

   416                 || (!parent->caseSensitive()

   417                     && parent->children.value(element)->fileName.toLower() != element.toLower()))

   418                 alreadyExisted = false;

   419         }

   420 

   421         QFileSystemModelPrivate::QFileSystemNode *node;

   422         if (!alreadyExisted) {

   423             // Someone might call ::index("file://cookie/monster/doesn't/like/veggies"),

   424             // a path that doesn't exists, I.E. don't blindly create directories.

   425             QFileInfo info(absolutePath);

   426             if (!info.exists())

   427                 return const_cast<QFileSystemModelPrivate::QFileSystemNode*>(&root);

   428             QFileSystemModelPrivate *p = const_cast<QFileSystemModelPrivate*>(this);

   429             node = p->addNode(parent, element,info);

   430 #ifndef QT_NO_FILESYSTEMWATCHER

   431             node->populate(fileInfoGatherer.getInfo(info));

   432 #endif

   433         } else {

   434             node = parent->children.value(element);

   435         }

   436 

   437         Q_ASSERT(node);

   438         if (!node->isVisible) {

   439             // It has been filtered out

   440             if (alreadyExisted && node->hasInformation() && !fetch)

   441                 return const_cast<QFileSystemModelPrivate::QFileSystemNode*>(&root);

   442 

   443             QFileSystemModelPrivate *p = const_cast<QFileSystemModelPrivate*>(this);

   444             p->addVisibleFiles(parent, QStringList(element));

   445             if (!p->bypassFilters.contains(node))

   446                 p->bypassFilters[node] = 1;

   447             QString dir = q->filePath(this->index(parent));

   448             if (!node->hasInformation() && fetch) {

   449                 Fetching f;

   450                 f.dir = dir;

   451                 f.file = element;

   452                 f.node = node;

   453                 p->toFetch.append(f);

   454                 p->fetchingTimer.start(0, const_cast<QFileSystemModel*>(q));

   455             }

   456         }

   457         parent = node;

   458     }

   459 

   460     return parent;

   461 }

   462 

   463 /*!

   464     \reimp

   465 */

   466 void QFileSystemModel::timerEvent(QTimerEvent *event)

   467 {

   468     Q_D(QFileSystemModel);

   469     if (event->timerId() == d->fetchingTimer.timerId()) {

   470         d->fetchingTimer.stop();

   471 #ifndef QT_NO_FILESYSTEMWATCHER

   472         for (int i = 0; i < d->toFetch.count(); ++i) {

   473             const QFileSystemModelPrivate::QFileSystemNode *node = d->toFetch.at(i).node;

   474             if (!node->hasInformation()) {

   475                 d->fileInfoGatherer.fetchExtendedInformation(d->toFetch.at(i).dir,

   476                                                  QStringList(d->toFetch.at(i).file));

   477             } else {

   478                 // qDebug() << "yah!, you saved a little gerbil soul";

   479             }

   480         }

   481 #endif

   482         d->toFetch.clear();

   483     }

   484 }

   485 

   486 /*!

   487     Returns true if the model item \a index represents a directory;

   488     otherwise returns false.

   489 */

   490 bool QFileSystemModel::isDir(const QModelIndex &index) const

   491 {

   492     // This function is for public usage only because it could create a file info

   493     Q_D(const QFileSystemModel);

   494     if (!index.isValid())

   495         return true;

   496     QFileSystemModelPrivate::QFileSystemNode *n = d->node(index);

   497     if (n->hasInformation())

   498         return n->isDir();

   499     return fileInfo(index).isDir();

   500 }

   501 

   502 /*!

   503     Returns the size in bytes of \a index. If the file does not exist, 0 is returned.

   504   */

   505 qint64 QFileSystemModel::size(const QModelIndex &index) const

   506 {

   507     Q_D(const QFileSystemModel);

   508     if (!index.isValid())

   509         return 0;

   510     return d->node(index)->size();

   511 }

   512 

   513 /*!

   514     Returns the type of file \a index such as "Directory" or "JPEG file".

   515   */

   516 QString QFileSystemModel::type(const QModelIndex &index) const

   517 {

   518     Q_D(const QFileSystemModel);

   519     if (!index.isValid())

   520         return QString();

   521     return d->node(index)->type();

   522 }

   523 

   524 /*!

   525     Returns the date and time when \a index was last modified.

   526  */

   527 QDateTime QFileSystemModel::lastModified(const QModelIndex &index) const

   528 {

   529     Q_D(const QFileSystemModel);

   530     if (!index.isValid())

   531         return QDateTime();

   532     return d->node(index)->lastModified();

   533 }

   534 

   535 /*!

   536     \reimp

   537 */

   538 QModelIndex QFileSystemModel::parent(const QModelIndex &index) const

   539 {

   540     Q_D(const QFileSystemModel);

   541     if (!d->indexValid(index))

   542         return QModelIndex();

   543 

   544     QFileSystemModelPrivate::QFileSystemNode *indexNode = d->node(index);

   545     Q_ASSERT(indexNode != 0);

   546     QFileSystemModelPrivate::QFileSystemNode *parentNode = (indexNode ? indexNode->parent : 0);

   547     if (parentNode == 0 || parentNode == &d->root)

   548         return QModelIndex();

   549 

   550     // get the parent's row

   551     QFileSystemModelPrivate::QFileSystemNode *grandParentNode = parentNode->parent;

   552     Q_ASSERT(grandParentNode->children.contains(parentNode->fileName));

   553     int visualRow = d->translateVisibleLocation(grandParentNode, grandParentNode->visibleLocation(grandParentNode->children.value(parentNode->fileName)->fileName));

   554     if (visualRow == -1)

   555         return QModelIndex();

   556     return createIndex(visualRow, 0, parentNode);

   557 }

   558 

   559 /*

   560     \internal

   561 

   562     return the index for node

   563 */

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

   565 {

   566     Q_Q(const QFileSystemModel);

   567     QFileSystemModelPrivate::QFileSystemNode *parentNode = (node ? node->parent : 0);

   568     if (node == &root || !parentNode)

   569         return QModelIndex();

   570 

   571     // get the parent's row

   572     Q_ASSERT(node);

   573     if (!node->isVisible)

   574         return QModelIndex();

   575 

   576     int visualRow = translateVisibleLocation(parentNode, parentNode->visibleLocation(node->fileName));

   577     return q->createIndex(visualRow, 0, const_cast<QFileSystemNode*>(node));

   578 }

   579 

   580 /*!

   581     \reimp

   582 */

   583 bool QFileSystemModel::hasChildren(const QModelIndex &parent) const

   584 {

   585     Q_D(const QFileSystemModel);

   586     if (parent.column() > 0)

   587         return false;

   588 

   589     if (!parent.isValid()) // drives

   590         return true;

   591 

   592     const QFileSystemModelPrivate::QFileSystemNode *indexNode = d->node(parent);

   593     Q_ASSERT(indexNode);

   594     return (indexNode->isDir());

   595 }

   596 

   597 /*!

   598     \reimp

   599  */

   600 bool QFileSystemModel::canFetchMore(const QModelIndex &parent) const

   601 {

   602     Q_D(const QFileSystemModel);

   603     const QFileSystemModelPrivate::QFileSystemNode *indexNode = d->node(parent);

   604     return (!indexNode->populatedChildren);

   605 }

   606 

   607 /*!

   608     \reimp

   609  */

   610 void QFileSystemModel::fetchMore(const QModelIndex &parent)

   611 {

   612     Q_D(QFileSystemModel);

   613     if (!d->setRootPath)

   614         return;

   615     QFileSystemModelPrivate::QFileSystemNode *indexNode = d->node(parent);

   616     if (indexNode->populatedChildren)

   617         return;

   618     indexNode->populatedChildren = true;

   619     d->fileInfoGatherer.list(filePath(parent));

   620 }

   621 

   622 /*!

   623     \reimp

   624 */

   625 int QFileSystemModel::rowCount(const QModelIndex &parent) const

   626 {

   627     Q_D(const QFileSystemModel);

   628     if (parent.column() > 0)

   629         return 0;

   630 

   631     if (!parent.isValid())

   632         return d->root.visibleChildren.count();

   633 

   634     const QFileSystemModelPrivate::QFileSystemNode *parentNode = d->node(parent);

   635     return parentNode->visibleChildren.count();

   636 }

   637 

   638 /*!

   639     \reimp

   640 */

   641 int QFileSystemModel::columnCount(const QModelIndex &parent) const

   642 {

   643     return (parent.column() > 0) ? 0 : 4;

   644 }

   645 

   646 /*!

   647     Returns the data stored under the given \a role for the item "My Computer".

   648 

   649     \sa Qt::ItemDataRole

   650  */

   651 QVariant QFileSystemModel::myComputer(int role) const

   652 {

   653     Q_D(const QFileSystemModel);

   654     switch (role) {

   655     case Qt::DisplayRole:

   656         return d->myComputer();

   657     case Qt::DecorationRole:

   658         return d->fileInfoGatherer.iconProvider()->icon(QFileIconProvider::Computer);

   659     }

   660     return QVariant();

   661 }

   662 

   663 /*!

   664     \reimp

   665 */

   666 QVariant QFileSystemModel::data(const QModelIndex &index, int role) const

   667 {

   668     Q_D(const QFileSystemModel);

   669     if (!index.isValid() || index.model() != this)

   670         return QVariant();

   671 

   672     switch (role) {

   673     case Qt::EditRole:

   674     case Qt::DisplayRole:

   675         switch (index.column()) {

   676         case 0: return d->name(index);

   677         case 1: return d->size(index);

   678         case 2: return d->type(index);

   679         case 3: return d->time(index);

   680         default:

   681             qWarning("data: invalid display value column %d", index.column());

   682             break;

   683         }

   684         break;

   685     case FilePathRole:

   686         return filePath(index);

   687     case FileNameRole:

   688         return d->name(index);

   689     case Qt::DecorationRole:

   690         if (index.column() == 0) {

   691             QIcon icon = d->icon(index);

   692             if (icon.isNull()) {

   693                 if (d->node(index)->isDir())

   694                     icon = d->fileInfoGatherer.iconProvider()->icon(QFileIconProvider::Folder);

   695                 else

   696                     icon = d->fileInfoGatherer.iconProvider()->icon(QFileIconProvider::File);

   697             }

   698             return icon;

   699         }

   700         break;

   701     case Qt::TextAlignmentRole:

   702         if (index.column() == 1)

   703             return Qt::AlignRight;

   704         break;

   705     case FilePermissions:

   706         int p = permissions(index);

   707         return p;

   708     }

   709 

   710     return QVariant();

   711 }

   712 

   713 /*!

   714     \internal

   715 */

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

   717 {

   718     if (!index.isValid())

   719         return QString();

   720     const QFileSystemNode *n = node(index);

   721     if (n->isDir()) {

   722 #ifdef Q_OS_MAC

   723         return QLatin1String("--");

   724 #else

   725         return QLatin1String("");

   726 #endif

   727     // Windows   - ""

   728     // OS X      - "--"

   729     // Konqueror - "4 KB"

   730     // Nautilus  - "9 items" (the number of children)

   731     }

   732     return size(n->size());

   733 }

   734 

   735 QString QFileSystemModelPrivate::size(qint64 bytes)

   736 {

   737     // According to the Si standard KB is 1000 bytes, KiB is 1024

   738     // but on windows sizes are calculated by dividing by 1024 so we do what they do.

   739     const qint64 kb = 1024;

   740     const qint64 mb = 1024 * kb;

   741     const qint64 gb = 1024 * mb;

   742     const qint64 tb = 1024 * gb;

   743     if (bytes >= tb)

   744         return QFileSystemModel::tr("%1 TB").arg(QLocale().toString(qreal(bytes) / tb, 'f', 3));

   745     if (bytes >= gb)

   746         return QFileSystemModel::tr("%1 GB").arg(QLocale().toString(qreal(bytes) / gb, 'f', 2));

   747     if (bytes >= mb)

   748         return QFileSystemModel::tr("%1 MB").arg(QLocale().toString(qreal(bytes) / mb, 'f', 1));

   749     if (bytes >= kb)

   750         return QFileSystemModel::tr("%1 KB").arg(QLocale().toString(bytes / kb));

   751     return QFileSystemModel::tr("%1 bytes").arg(QLocale().toString(bytes));

   752 }

   753 

   754 /*!

   755     \internal

   756 */

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

   758 {

   759     if (!index.isValid())

   760         return QString();

   761 #ifndef QT_NO_DATESTRING

   762     return node(index)->lastModified().toString(Qt::SystemLocaleDate);

   763 #else

   764     Q_UNUSED(index);

   765     return QString();

   766 #endif

   767 }

   768 

   769 /*

   770     \internal

   771 */

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

   773 {

   774     if (!index.isValid())

   775         return QString();

   776     return node(index)->type();

   777 }

   778 

   779 /*!

   780     \internal

   781 */

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

   783 {

   784     if (!index.isValid())

   785         return QString();

   786     QFileSystemNode *dirNode = node(index);

   787     if (dirNode->isSymLink() && fileInfoGatherer.resolveSymlinks()) {

   788         QString fullPath = QDir::fromNativeSeparators(filePath(index));

   789         if (resolvedSymLinks.contains(fullPath))

   790             return resolvedSymLinks[fullPath];

   791     }

   792     // ### TODO it would be nice to grab the volume name if dirNode->parent == root

   793     return dirNode->fileName;

   794 }

   795 

   796 /*!

   797     \internal

   798 */

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

   800 {

   801     if (!index.isValid())

   802         return QIcon();

   803     return node(index)->icon();

   804 }

   805 

   806 /*!

   807     \reimp

   808 */

   809 bool QFileSystemModel::setData(const QModelIndex &idx, const QVariant &value, int role)

   810 {

   811     Q_D(QFileSystemModel);

   812     if (!idx.isValid()

   813         || idx.column() != 0

   814         || role != Qt::EditRole

   815         || (flags(idx) & Qt::ItemIsEditable) == 0) {

   816         return false;

   817     }

   818 

   819     QString newName = value.toString();

   820     QString oldName = idx.data().toString();

   821     if (newName == idx.data().toString())

   822         return true;

   823 

   824     if (newName.isEmpty()

   825         || newName.contains(QDir::separator())

   826         || !QDir(filePath(parent(idx))).rename(oldName, newName)) {

   827 #ifndef QT_NO_MESSAGEBOX

   828         QMessageBox::information(0, QFileSystemModel::tr("Invalid filename"),

   829                                 QFileSystemModel::tr("<b>The name \"%1\" can not be used.</b><p>Try using another name, with fewer characters or no punctuations marks.")

   830                                 .arg(newName),

   831                                  QMessageBox::Ok);

   832 #endif // QT_NO_MESSAGEBOX

   833         return false;

   834     } else {

   835         /*

   836             *After re-naming something we don't want the selection to change*

   837             - can't remove rows and later insert

   838             - can't quickly remove and insert

   839             - index pointer can't change because treeview doesn't use persistant index's

   840 

   841             - if this get any more complicated think of changing it to just

   842               use layoutChanged

   843          */

   844 

   845         QFileSystemModelPrivate::QFileSystemNode *indexNode = d->node(idx);

   846         QFileSystemModelPrivate::QFileSystemNode *parentNode = indexNode->parent;

   847         int visibleLocation = parentNode->visibleLocation(parentNode->children.value(indexNode->fileName)->fileName);

   848 

   849         d->addNode(parentNode, newName,indexNode->info->fileInfo());

   850         parentNode->visibleChildren.removeAt(visibleLocation);

   851         QFileSystemModelPrivate::QFileSystemNode * oldValue = parentNode->children.value(oldName);

   852         parentNode->children[newName] = oldValue;

   853         QFileInfo info(d->rootDir, newName);

   854         oldValue->fileName = newName;

   855         oldValue->parent = parentNode;

   856         oldValue->populate(d->fileInfoGatherer.getInfo(info));

   857         oldValue->isVisible = true;

   858 

   859         parentNode->children.remove(oldName);

   860         parentNode->visibleChildren.insert(visibleLocation, newName);

   861 

   862         d->delayedSort();

   863         emit fileRenamed(filePath(idx.parent()), oldName, newName);

   864     }

   865     return true;

   866 }

   867 

   868 /*!

   869     \reimp

   870 */

   871 QVariant QFileSystemModel::headerData(int section, Qt::Orientation orientation, int role) const

   872 {

   873     switch (role) {

   874     case Qt::DecorationRole:

   875         if (section == 0) {

   876             // ### TODO oh man this is ugly and doesn't even work all the way!

   877             // it is still 2 pixels off

   878             QImage pixmap(16, 1, QImage::Format_Mono);

   879             pixmap.fill(0);

   880             pixmap.setAlphaChannel(pixmap.createAlphaMask());

   881             return pixmap;

   882         }

   883         break;

   884     case Qt::TextAlignmentRole:

   885         return Qt::AlignLeft;

   886     }

   887 

   888     if (orientation != Qt::Horizontal || role != Qt::DisplayRole)

   889         return QAbstractItemModel::headerData(section, orientation, role);

   890 

   891     QString returnValue;

   892     switch (section) {

   893     case 0: returnValue = tr("Name");

   894             break;

   895     case 1: returnValue = tr("Size");

   896             break;

   897     case 2: returnValue =

   898 #ifdef Q_OS_MAC

   899                    tr("Kind", "Match OS X Finder");

   900 #else

   901                    tr("Type", "All other platforms");

   902 #endif

   903            break;

   904     // Windows   - Type

   905     // OS X      - Kind

   906     // Konqueror - File Type

   907     // Nautilus  - Type

   908     case 3: returnValue = tr("Date Modified");

   909             break;

   910     default: return QVariant();

   911     }

   912     return returnValue;

   913 }

   914 

   915 /*!

   916     \reimp

   917 */

   918 Qt::ItemFlags QFileSystemModel::flags(const QModelIndex &index) const

   919 {

   920     Q_D(const QFileSystemModel);

   921     Qt::ItemFlags flags = QAbstractItemModel::flags(index);

   922     if (!index.isValid())

   923         return flags;

   924 

   925     QFileSystemModelPrivate::QFileSystemNode *indexNode = d->node(index);

   926     if (d->nameFilterDisables && !d->passNameFilters(indexNode)) {

   927         flags &= ~Qt::ItemIsEnabled;

   928         // ### TODO you shouldn't be able to set this as the current item, task 119433

   929         return flags;

   930     }

   931 

   932     flags |= Qt::ItemIsDragEnabled;

   933     if (d->readOnly)

   934         return flags;

   935     if ((index.column() == 0) && indexNode->permissions() & QFile::WriteUser) {

   936         flags |= Qt::ItemIsEditable;

   937         if (indexNode->isDir())

   938             flags |= Qt::ItemIsDropEnabled;

   939     }

   940     return flags;

   941 }

   942 

   943 /*!

   944     \internal

   945 */

   946 void QFileSystemModelPrivate::_q_performDelayedSort()

   947 {

   948     Q_Q(QFileSystemModel);

   949     q->sort(sortColumn, sortOrder);

   950 }

   951 

   952 static inline QChar getNextChar(const QString &s, int location)

   953 {

   954     return (location < s.length()) ? s.at(location) : QChar();

   955 }

   956 

   957 /*!

   958     Natural number sort, skips spaces.

   959 

   960     Examples:

   961     1, 2, 10, 55, 100

   962     01.jpg, 2.jpg, 10.jpg

   963 

   964     Note on the algorithm:

   965     Only as many characters as necessary are looked at and at most they all

   966     are looked at once.

   967 

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

   969   */

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

   971 {

   972     for (int l1 = 0, l2 = 0; l1 <= s1.count() && l2 <= s2.count(); ++l1, ++l2) {

   973         // skip spaces, tabs and 0's

   974         QChar c1 = getNextChar(s1, l1);

   975         while (c1.isSpace())

   976             c1 = getNextChar(s1, ++l1);

   977         QChar c2 = getNextChar(s2, l2);

   978         while (c2.isSpace())

   979             c2 = getNextChar(s2, ++l2);

   980 

   981         if (c1.isDigit() && c2.isDigit()) {

   982             while (c1.digitValue() == 0)

   983                 c1 = getNextChar(s1, ++l1);

   984             while (c2.digitValue() == 0)

   985                 c2 = getNextChar(s2, ++l2);

   986 

   987             int lookAheadLocation1 = l1;

   988             int lookAheadLocation2 = l2;

   989             int currentReturnValue = 0;

   990             // find the last digit, setting currentReturnValue as we go if it isn't equal

   991             for (

   992                 QChar lookAhead1 = c1, lookAhead2 = c2;

   993                 (lookAheadLocation1 <= s1.length() && lookAheadLocation2 <= s2.length());

   994                 lookAhead1 = getNextChar(s1, ++lookAheadLocation1),

   995                 lookAhead2 = getNextChar(s2, ++lookAheadLocation2)

   996                 ) {

   997                 bool is1ADigit = !lookAhead1.isNull() && lookAhead1.isDigit();

   998                 bool is2ADigit = !lookAhead2.isNull() && lookAhead2.isDigit();

   999                 if (!is1ADigit && !is2ADigit)

  1000                     break;

  1001                 if (!is1ADigit)

  1002                     return -1;

  1003                 if (!is2ADigit)

  1004                     return 1;

  1005                 if (currentReturnValue == 0) {

  1006                     if (lookAhead1 < lookAhead2) {

  1007                         currentReturnValue = -1;

  1008                     } else if (lookAhead1 > lookAhead2) {

  1009                         currentReturnValue = 1;

  1010                     }

  1011                 }

  1012             }

  1013             if (currentReturnValue != 0)

  1014                 return currentReturnValue;

  1015         }

  1016 

  1017         if (cs == Qt::CaseInsensitive) {

  1018             if (!c1.isLower()) c1 = c1.toLower();

  1019             if (!c2.isLower()) c2 = c2.toLower();

  1020         }

  1021         int r = QString::localeAwareCompare(c1, c2);

  1022         if (r < 0)

  1023             return -1;

  1024         if (r > 0)

  1025             return 1;

  1026     }

  1027     // The two strings are the same (02 == 2) so fall back to the normal sort

  1028     return QString::compare(s1, s2, cs);

  1029 }

  1030 

  1031 /*

  1032     \internal

  1033     Helper functor used by sort()

  1034 */

  1035 class QFileSystemModelSorter

  1036 {

  1037 public:

  1038     inline QFileSystemModelSorter(int column) : sortColumn(column) {}

  1039 

  1040     bool compareNodes(const QFileSystemModelPrivate::QFileSystemNode *l,

  1041                     const QFileSystemModelPrivate::QFileSystemNode *r) const

  1042     {

  1043         switch (sortColumn) {

  1044         case 0: {

  1045 #ifndef Q_OS_MAC

  1046             // place directories before files

  1047             bool left = l->isDir();

  1048             bool right = r->isDir();

  1049             if (left ^ right)

  1050                 return left;

  1051 #endif

  1052             return QFileSystemModelPrivate::naturalCompare(l->fileName,

  1053                                                 r->fileName, Qt::CaseInsensitive) < 0;

  1054                 }

  1055         case 1:

  1056             // Directories go first

  1057             if (l->isDir() && !r->isDir())

  1058                 return true;

  1059             return l->size() < r->size();

  1060         case 2:

  1061             return l->type() < r->type();

  1062         case 3:

  1063             return l->lastModified() < r->lastModified();

  1064         }

  1065         Q_ASSERT(false);

  1066         return false;

  1067     }

  1068 

  1069     bool operator()(const QPair<QFileSystemModelPrivate::QFileSystemNode*, int> &l,

  1070                            const QPair<QFileSystemModelPrivate::QFileSystemNode*, int> &r) const

  1071     {

  1072         return compareNodes(l.first, r.first);

  1073     }

  1074 

  1075 

  1076 private:

  1077     int sortColumn;

  1078 };

  1079 

  1080 /*

  1081     \internal

  1082 

  1083     Sort all of the children of parent

  1084 */

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

  1086 {

  1087     Q_Q(QFileSystemModel);

  1088     QFileSystemModelPrivate::QFileSystemNode *indexNode = node(parent);

  1089     if (indexNode->children.count() == 0)

  1090         return;

  1091 

  1092     QList<QPair<QFileSystemModelPrivate::QFileSystemNode*, int> > values;

  1093     QHash<QString, QFileSystemNode *>::const_iterator iterator;

  1094     int i = 0;

  1095     for(iterator = indexNode->children.begin() ; iterator != indexNode->children.end() ; ++iterator) {

  1096         if (filtersAcceptsNode(iterator.value())) {

  1097             values.append(QPair<QFileSystemModelPrivate::QFileSystemNode*, int>((iterator.value()), i));

  1098         } else {

  1099             iterator.value()->isVisible = false;

  1100         }

  1101         i++;

  1102     }

  1103     QFileSystemModelSorter ms(column);

  1104     qStableSort(values.begin(), values.end(), ms);

  1105     // First update the new visible list

  1106     indexNode->visibleChildren.clear();

  1107     //No more dirty item we reset our internal dirty index

  1108     indexNode->dirtyChildrenIndex = -1;

  1109     for (int i = 0; i < values.count(); ++i) {

  1110         indexNode->visibleChildren.append(values.at(i).first->fileName);

  1111         values.at(i).first->isVisible = true;

  1112     }

  1113 

  1114     if (!disableRecursiveSort) {

  1115         for (int i = 0; i < q->rowCount(parent); ++i) {

  1116             const QModelIndex childIndex = q->index(i, 0, parent);

  1117             QFileSystemModelPrivate::QFileSystemNode *indexNode = node(childIndex);

  1118             //Only do a recursive sort on visible nodes

  1119             if (indexNode->isVisible)

  1120                 sortChildren(column, childIndex);

  1121         }

  1122     }

  1123 }

  1124 

  1125 /*!

  1126     \reimp

  1127 */

  1128 void QFileSystemModel::sort(int column, Qt::SortOrder order)

  1129 {

  1130     Q_D(QFileSystemModel);

  1131     if (d->sortOrder == order && d->sortColumn == column && !d->forceSort)

  1132         return;

  1133 

  1134     emit layoutAboutToBeChanged();