src/code/fmstatic.cpp

0001 #include "fmstatic.h"
0002 #include "placeslist.h"
0003 #include "tagging.h"
0004
0005 #include <QDesktopServices>
0006 #include <QDirIterator>
0007 #include <QFileInfo>
0008 #include <QDateTime>
0009 #include <QDebug>
0010 #include <QSettings>
0011
0012 #include <KLocalizedString>
0013
0014 #if (defined Q_OS_LINUX || defined Q_OS_FREEBSD) && !defined Q_OS_ANDROID
0015 #include <KConfig>
0016 #include <KConfigGroup>
0017 #endif
0018
0019 #ifdef KIO_AVAILABLE
0020 #include <KIO/CopyJob>
0021 #include <KIO/DeleteJob>
0022 #include <KIO/EmptyTrashJob>
0023 #include <KIO/MkdirJob>
0024 #include <KIO/SimpleJob>
0025 #include <KIO/OpenUrlJob>
0026 #include <KApplicationTrader>
0027 #include <KIO/PreviewJob>
0028 #include <KFileItem>
0029 #endif
0030
0031 QString FMStatic::PathTypeLabel(const FMStatic::PATHTYPE_KEY& key)
0032 {
0033     static const QHash<FMStatic::PATHTYPE_KEY, QString> PATHTYPE_LABEL = {{PATHTYPE_KEY::PLACES_PATH, i18n("Places")},
0034                                                                           {PATHTYPE_KEY::BOOKMARKS_PATH, i18n("Bookmarks")},
0035                                                                           {PATHTYPE_KEY::DRIVES_PATH, i18n("Drives")},
0036                                                                           {PATHTYPE_KEY::APPS_PATH, i18n("Apps")},
0037                                                                           {PATHTYPE_KEY::REMOTE_PATH, i18n("Remote")},
0038                                                                           {PATHTYPE_KEY::REMOVABLE_PATH, i18n("Removable")},
0039                                                                           {PATHTYPE_KEY::UNKNOWN_TYPE, i18n("Unknown")},
0040                                                                           {PATHTYPE_KEY::TRASH_PATH, i18n("Trash")},
0041                                                                           {PATHTYPE_KEY::TAGS_PATH, i18n("Tags")},
0042                                                                           {PATHTYPE_KEY::SEARCH_PATH, i18n("Search")},
0043                                                                           {PATHTYPE_KEY::CLOUD_PATH, i18n("Cloud")},
0044                                                                           {PATHTYPE_KEY::FISH_PATH, i18n("Remote")},
0045                                                                           {PATHTYPE_KEY::MTP_PATH, i18n("Drives")},
0046                                                                           {PATHTYPE_KEY::OTHER_PATH, i18n("Others")},
0047                                                                           {PATHTYPE_KEY::QUICK_PATH, i18n("Quick")}};
0048
0049     return PATHTYPE_LABEL[key];
0050 }
0051
0052
0053 FMStatic::FMStatic(QObject *parent)
0054     : QObject(parent)
0055 {}
0056
0057 FMH::MODEL_LIST FMStatic::packItems(const QStringList &items, const QString &type)
0058 {
0059     FMH::MODEL_LIST data;
0060
0061     for (const auto &path : items)
0062     {
0063         if (QUrl(path).isLocalFile() && !FMH::fileExists(QUrl(path)))
0064             continue;
0065
0066         auto model = FMStatic::getFileInfoModel(QUrl(path));
0067         model.insert(FMH::MODEL_KEY::TYPE, type);
0068         data << model;
0069     }
0070
0071     return data;
0072 }
0073
0074 FMH::MODEL_LIST FMStatic::getDefaultPaths()
0075 {
0076     return FMStatic::packItems(FMStatic::defaultPaths, PathTypeLabel(FMStatic::PATHTYPE_KEY::PLACES_PATH));
0077 }
0078
0079 FMH::MODEL_LIST FMStatic::search(const QString &query, const QUrl &path, const bool &hidden, const bool &onlyDirs, const QStringList &filters)
0080 {
0081     FMH::MODEL_LIST content;
0082
0083     if (!path.isLocalFile()) {
0084         qWarning() << "URL recived is not a local file. FM::search" << path;
0085         return content;
0086     }
0087
0088     if (FMStatic::isDir(path)) {
0089         QDir::Filters dirFilter;
0090
0091         dirFilter = (onlyDirs ? QDir::AllDirs | QDir::NoDotDot | QDir::NoDot : QDir::Files | QDir::AllDirs | QDir::NoDotDot | QDir::NoDot);
0092
0093         if (hidden)
0094             dirFilter = dirFilter | QDir::Hidden | QDir::System;
0095
0096         QDirIterator it(path.toLocalFile(), filters, dirFilter, QDirIterator::Subdirectories);
0097         while (it.hasNext()) {
0098             auto url = it.next();
0099             if (it.fileName().contains(query, Qt::CaseInsensitive)) {
0100                 content << FMStatic::getFileInfoModel(QUrl::fromLocalFile(url));
0101             }
0102         }
0103     } else
0104         qWarning() << "Search path does not exists" << path;
0105
0106     qDebug() << content;
0107     return content;
0108 }
0109
0110 FMH::MODEL_LIST FMStatic::getDevices()
0111 {
0112     FMH::MODEL_LIST drives;
0113
0114 #ifdef Q_OS_ANDROID
0115     drives << packItems(MAUIAndroid::sdDirs(), PathTypeLabel(FMStatic::PATHTYPE_KEY::DRIVES_PATH));
0116     return drives;
0117 #endif
0118
0119     return drives;
0120 }
0121
0122 bool FMStatic::isDefaultPath(const QString &path)
0123 {
0124     return FMStatic::defaultPaths.contains(path);
0125 }
0126
0127 QUrl FMStatic::parentDir(const QUrl &path)
0128 {
0129     if (!path.isLocalFile()) {
0130         qWarning() << "URL recived is not a local file, FM::parentDir" << path;
0131         return path;
0132     }
0133
0134     QDir dir(path.toLocalFile());
0135     dir.cdUp();
0136     return QUrl::fromLocalFile(dir.absolutePath());
0137 }
0138
0139 bool FMStatic::isDir(const QUrl &path)
0140 {
0141     if (!path.isLocalFile()) {
0142         //         qWarning() << "URL recived is not a local file. FM::isDir" << path;
0143         return false;
0144     }
0145
0146     const QFileInfo file(path.toLocalFile());
0147     return file.isDir();
0148 }
0149
0150 bool FMStatic::isCloud(const QUrl &path)
0151 {
0152     return path.scheme() == FMStatic::PATHTYPE_SCHEME[FMStatic::PATHTYPE_KEY::CLOUD_PATH];
0153 }
0154
0155 bool FMStatic::fileExists(const QUrl &path)
0156 {
0157     return FMH::fileExists(path);
0158 }
0159
0160 QUrl FMStatic::fileDir(const QUrl &path) // the directory path of the file
0161 {
0162     QUrl res = path;
0163     if (path.isLocalFile()) {
0164         const QFileInfo file(path.toLocalFile());
0165         if (file.isDir())
0166             res = path;
0167         else
0168             res = QUrl::fromLocalFile(file.dir().absolutePath());
0169     } else
0170         qWarning() << "The path is not a local one. FM::fileDir";
0171
0172     return res;
0173 }
0174
0175 QString FMStatic::homePath()
0176 {
0177     return FMStatic::HomePath;
0178 }
0179 #if !defined KIO_AVAILABLE
0180
0181 static bool copyRecursively(QString sourceFolder, QString destFolder)
0182 {
0183     bool success = false;
0184     QDir sourceDir(sourceFolder);
0185
0186     if (!sourceDir.exists())
0187         return false;
0188
0189     QDir destDir(destFolder);
0190     if (!destDir.exists())
0191         destDir.mkdir(destFolder);
0192
0193     QStringList files = sourceDir.entryList(QDir::Files);
0194     for (int i = 0; i < files.count(); i++) {
0195         QString srcName = sourceFolder + QDir::separator() + files[i];
0196         QString destName = destFolder + QDir::separator() + files[i];
0197         success = QFile::copy(srcName, destName);
0198         if (!success)
0199             return false;
0200     }
0201
0202     files.clear();
0203     files = sourceDir.entryList(QDir::AllDirs | QDir::NoDotAndDotDot);
0204     for (int i = 0; i < files.count(); i++) {
0205         QString srcName = sourceFolder + QDir::separator() + files[i];
0206         QString destName = destFolder + QDir::separator() + files[i];
0207         success = copyRecursively(srcName, destName);
0208         if (!success)
0209             return false;
0210     }
0211
0212     return true;
0213 }
0214 #endif
0215
0216 bool FMStatic::copy(const QList<QUrl> &urls, const QUrl &destinationDir)
0217 {
0218 #ifdef KIO_AVAILABLE
0219     auto job = KIO::copy(urls, destinationDir);
0220     job->start();
0221     return true;
0222 #else
0223     for (const auto &url : std::as_const(urls)) {
0224         QFileInfo srcFileInfo(url.toLocalFile());
0225         if (!srcFileInfo.isDir() && srcFileInfo.isFile()) {
0226             const auto _destination = QUrl(destinationDir.toString() + QStringLiteral("/") + FMStatic::getFileInfoModel(url)[FMH::MODEL_KEY::LABEL]);
0227             if (!QFile::copy(url.toLocalFile(), _destination.toLocalFile())) {
0228                 continue;
0229             }
0230         } else {
0231             const auto _destination = QUrl(destinationDir.toString() + QStringLiteral("/") + FMStatic::getFileInfoModel(url)[FMH::MODEL_KEY::LABEL]);
0232             QDir destDir(_destination.toLocalFile());
0233             if (!destDir.exists())
0234                 destDir.mkdir(_destination.toLocalFile());
0235
0236             if (!copyRecursively(url.toLocalFile(), _destination.toLocalFile()))
0237                 continue;
0238         }
0239     }
0240     return true;
0241 #endif
0242 }
0243
0244 bool FMStatic::group(const QList<QUrl>& urls, const QUrl& destinationDir, const QString &name)
0245 {
0246     if(!FMStatic::fileExists(QUrl(destinationDir.toString() + QStringLiteral("/") + name)))
0247     {
0248         QDir(destinationDir.toLocalFile()).mkdir(name);
0249     }
0250
0251     return FMStatic::cut(urls, destinationDir, name);
0252 }
0253
0254
0255 bool FMStatic::cut(const QList<QUrl> &urls, const QUrl &where)
0256 {
0257     return FMStatic::cut(urls, where, QString());
0258 }
0259
0260 bool FMStatic::cut(const QList<QUrl> &urls, const QUrl &where, const QString &name)
0261 {
0262 #ifdef KIO_AVAILABLE
0263     QUrl _where = where;
0264     if (!name.isEmpty())
0265         _where = QUrl(where.toString() + QStringLiteral("/") + name);
0266
0267     auto job = KIO::move(urls, _where, KIO::HideProgressInfo);
0268     job->start();
0269
0270     for (const auto &url : urls) {
0271         QUrl where_ = QUrl(where.toString() + QStringLiteral("/") + FMStatic::getFileInfoModel(url)[FMH::MODEL_KEY::LABEL]);
0272         if (!name.isEmpty())
0273             where_ = QUrl(where.toString() + QStringLiteral("/") + name);
0274
0275         Tagging::getInstance()->updateUrl(url.toString(), where_.toString());
0276     }
0277 #else
0278     for (const auto &url : std::as_const(urls)) {
0279         QUrl _where;
0280         if (name.isEmpty())
0281             _where = QUrl(where.toString() + QStringLiteral("/") + FMStatic::getFileInfoModel(url)[FMH::MODEL_KEY::LABEL]);
0282         else
0283             _where = QUrl(where.toString() + QStringLiteral("/") + name);
0284
0285         QFile file(url.toLocalFile());
0286         file.rename(_where.toLocalFile());
0287
0288         Tagging::getInstance()->updateUrl(url.toString(), _where.toString());
0289     }
0290 #endif
0291
0292     return true;
0293 }
0294
0295 bool FMStatic::removeFiles(const QList<QUrl> &urls)
0296 {
0297     for (const auto &url : std::as_const(urls)) {
0298         Tagging::getInstance()->removeUrl(url.toString());
0299     }
0300
0301 #ifdef KIO_AVAILABLE
0302     auto job = KIO::del(urls);
0303     job->start();
0304     return true;
0305 #else
0306     qDebug() << "ASKED GTO DELETE FILES" << urls;
0307     for (const auto &url : std::as_const(urls)) {
0308         qDebug() << "@ Want to remove files << " << url.toLocalFile();
0309
0310         if (isDir(url)) {
0311             qDebug() << "Want to remove dir << " << url.toLocalFile();
0312             FMStatic::removeDir(url);
0313         } else {
0314             qDebug() << "Want to remove files << " << url.toLocalFile();
0315             QFile::remove(url.toLocalFile());
0316         }
0317     }
0318     return true;
0319 #endif
0320 }
0321
0322 void FMStatic::moveToTrash(const QList<QUrl> &urls)
0323 {
0324 #ifdef KIO_AVAILABLE
0325     auto job = KIO::trash(urls);
0326     job->start();
0327 #else
0328     Q_UNUSED(urls)
0329 #endif
0330 }
0331
0332 void FMStatic::emptyTrash()
0333 {
0334 #ifdef KIO_AVAILABLE
0335     auto job = KIO::emptyTrash();
0336     job->start();
0337 #endif
0338 }
0339
0340 bool FMStatic::removeDir(const QUrl &path)
0341 {
0342     bool result = true;
0343     QDir dir(path.toLocalFile());
0344     qDebug() << "TRYING TO REMOVE DIR" << path << path.toLocalFile();
0345     if (dir.exists())
0346     {
0347         for (const QFileInfo &info : dir.entryInfoList(QDir::NoDotAndDotDot | QDir::System | QDir::Hidden | QDir::AllDirs | QDir::Files, QDir::DirsFirst))
0348         {
0349             if (info.isDir()) {
0350                 result = removeDir(QUrl::fromLocalFile(info.absoluteFilePath()));
0351             } else {
0352                 result = QFile::remove(info.absoluteFilePath());
0353             }
0354
0355             if (!result) {
0356                 return result;
0357             }
0358         }
0359         result = dir.rmdir(path.toLocalFile());
0360     }
0361
0362     return result;
0363 }
0364
0365 bool FMStatic::rename(const QUrl &url, const QString &name)
0366 {
0367     return FMStatic::cut({url}, QUrl(url.toString().left(url.toString().lastIndexOf(QStringLiteral("/")))), name);
0368 }
0369
0370 bool FMStatic::createDir(const QUrl &path, const QString &name)
0371 {
0372 #ifdef KIO_AVAILABLE
0373     auto job = KIO::mkdir(name.isEmpty() ? path : QUrl(path.toString() + QStringLiteral("/") + name));
0374     job->start();
0375     return true;
0376 #else
0377     return QDir(path.toLocalFile()).mkdir(name);
0378 #endif
0379 }
0380
0381 bool FMStatic::createFile(const QUrl &path, const QString &name)
0382 {
0383     QFile file(path.toLocalFile() + QStringLiteral("/") + name);
0384
0385     if (file.open(QIODevice::ReadWrite)) {
0386         file.close();
0387         return true;
0388     }
0389
0390     return false;
0391 }
0392
0393 bool FMStatic::createSymlink(const QUrl &path, const QUrl &where)
0394 {
0395 #ifdef KIO_AVAILABLE
0396     qDebug() << "trying to create symlink" << path << where;
0397     const auto job = KIO::link({path}, where);
0398     job->start();
0399     return true;
0400 #else
0401     return QFile::link(path.toLocalFile(), where.toLocalFile() + QStringLiteral("/") + QFileInfo(path.toLocalFile()).fileName());
0402 #endif
0403 }
0404
0405 void FMStatic::openUrl(const QUrl &url)
0406 {
0407 #ifdef KIO_AVAILABLE
0408     KIO::OpenUrlJob *job = new KIO::OpenUrlJob(url);
0409     job->setRunExecutables(true);
0410     job->start();
0411 #else
0412
0413 #if defined Q_OS_ANDROID
0414     MAUIAndroid::openUrl(url);
0415 #else
0416     QDesktopServices::openUrl(url);
0417 #endif
0418
0419 #endif
0420 }
0421
0422 void FMStatic::openLocation(const QStringList &urls)
0423 {
0424     for (const auto &url : qAsConst(urls))
0425     {
0426         if(isDir(QUrl(url)))
0427         {
0428             QDesktopServices::openUrl(QUrl(url));
0429         }else
0430         {
0431             QDesktopServices::openUrl(fileDir(QUrl(url)));
0432         }
0433     }
0434 }
0435
0436 const QString FMStatic::dirConfIcon(const QUrl &path)
0437 {
0438     QString icon = QStringLiteral("folder");
0439
0440     if (!path.isLocalFile()) {
0441         qWarning() << "URL recived is not a local file" << path;
0442         return icon;
0443     }
0444
0445     if (!fileExists(path))
0446         return icon;
0447
0448
0449 #if defined Q_OS_ANDROID || defined Q_OS_WIN || defined Q_OS_MACOS || defined Q_OS_IOS
0450     QSettings file(path.toLocalFile(), QSettings::Format::NativeFormat);
0451     file.beginGroup(QStringLiteral("Desktop Entry"));
0452     icon = file.value(QStringLiteral("Icon"), icon).toString();
0453     file.endGroup();
0454 #else
0455     KConfig file(path.toLocalFile());
0456     const auto map = file.entryMap(QStringLiteral("Desktop Entry"));
0457     icon = map.isEmpty() ? QStringLiteral("folder") : map.value(QStringLiteral("Icon"));
0458 #endif
0459
0460     return icon;
0461 }
0462
0463 void FMStatic::setDirConf(const QUrl &path, const QString &group, const QString &key, const QVariant &value)
0464 {
0465     if (!path.isLocalFile()) {
0466         qWarning() << "URL recived is not a local file" << path;
0467         return;
0468     }
0469
0470 #if defined Q_OS_ANDROID || defined Q_OS_WIN || defined Q_OS_MACOS || defined Q_OS_IOS
0471     QSettings file(path.toLocalFile(), QSettings::Format::IniFormat);
0472     file.beginGroup(group);
0473     file.setValue(key, value);
0474     file.endGroup();
0475     file.sync();
0476 #else
0477     KConfig file(path.toLocalFile(), KConfig::SimpleConfig);
0478     auto kgroup = file.group(group);
0479     kgroup.writeEntry(key, value);
0480     //      file.reparseConfiguration();
0481     file.sync();
0482 #endif
0483 }
0484
0485 bool FMStatic::checkFileType(const int &type, const QString &mimeTypeName)
0486 {
0487     return FMStatic::checkFileType(static_cast<FMStatic::FILTER_TYPE>(type), mimeTypeName);
0488 }
0489
0490 bool FMStatic::checkFileType(const FMStatic::FILTER_TYPE &type, const QString &mimeTypeName)
0491 {
0492     return SUPPORTED_MIMETYPES[type].contains(mimeTypeName);
0493 }
0494
0495 void FMStatic::bookmark(const QUrl &url)
0496 {
0497     PlacesList::addBookmark(url);
0498 }
0499
0500 QStringList FMStatic::nameFilters(const int &type)
0501 {
0502     return FMStatic::FILTER_LIST[static_cast<FMStatic::FILTER_TYPE>(type)];
0503 }
0504
0505 const QString FMStatic::getMime(const QUrl &path)
0506 {
0507     if (!path.isLocalFile()) {
0508         qWarning() << "URL recived is not a local file, getMime" << path;
0509         return QString();
0510     }
0511
0512     const QMimeDatabase mimedb;
0513     return mimedb.mimeTypeForFile(path.toLocalFile()).name();
0514 }
0515
0516 static const QUrl thumbnailUrl(const QUrl &url, const QString &mimetype)
0517 {
0518 #ifdef KIO_AVAILABLE
0519     if (FMStatic::checkFileType(FMStatic::FILTER_TYPE::FONT, mimetype) || FMStatic::checkFileType(FMStatic::FILTER_TYPE::TEXT, mimetype) || FMStatic::checkFileType(FMStatic::FILTER_TYPE::AUDIO, mimetype) || FMStatic::checkFileType(FMStatic::FILTER_TYPE::DOCUMENT, mimetype) || FMStatic::checkFileType(FMStatic::FILTER_TYPE::VIDEO, mimetype) || url.toString().endsWith(QStringLiteral(".appimage"), Qt::CaseInsensitive)) {
0520         return QUrl(QStringLiteral("image://thumbnailer/") + url.toString());
0521     }
0522
0523     //      if (KIO::PreviewJob::supportedMimeTypes().contains(mimetype)) {
0524     //         return QUrl("image://thumbnailer/" + url.toString());
0525     //     }
0526 #endif
0527
0528     if (FMStatic::checkFileType(FMStatic::FILTER_TYPE::IMAGE, mimetype)) {
0529         return url;
0530     }
0531
0532     return QUrl();
0533 }
0534
0535 #ifdef KIO_AVAILABLE
0536 const FMH::MODEL FMStatic::getFileInfo(const KFileItem &kfile)
0537 {
0538     return FMH::MODEL {
0539         {FMH::MODEL_KEY::LABEL, kfile.name()},
0540         {FMH::MODEL_KEY::NAME, kfile.name()},
0541         {FMH::MODEL_KEY::DATE, kfile.time(KFileItem::FileTimes::CreationTime).toString(Qt::TextDate)},
0542         {FMH::MODEL_KEY::MODIFIED, kfile.time(KFileItem::FileTimes::ModificationTime).toString(Qt::TextDate)},
0543         {FMH::MODEL_KEY::LAST_READ, kfile.time(KFileItem::FileTimes::AccessTime).toString(Qt::TextDate)},
0544         {FMH::MODEL_KEY::PATH, kfile.mostLocalUrl().toString()},
0545         {FMH::MODEL_KEY::URL, kfile.mostLocalUrl().toString()},
0546         {FMH::MODEL_KEY::THUMBNAIL, thumbnailUrl(kfile.mostLocalUrl(), kfile.mimetype()).toString()},
0547         {FMH::MODEL_KEY::SYMLINK, kfile.linkDest()},
0548         {FMH::MODEL_KEY::IS_SYMLINK, QVariant(kfile.isLink()).toString()},
0549         {FMH::MODEL_KEY::HIDDEN, QVariant(kfile.isHidden()).toString()},
0550         {FMH::MODEL_KEY::IS_DIR, QVariant(kfile.isDir()).toString()},
0551         {FMH::MODEL_KEY::IS_FILE, QVariant(kfile.isFile()).toString()},
0552         {FMH::MODEL_KEY::MIME, kfile.mimetype()},
0553         {FMH::MODEL_KEY::ICON, kfile.iconName()},
0554         {FMH::MODEL_KEY::SIZE, QString::number(kfile.size())},
0555         {FMH::MODEL_KEY::COUNT, kfile.isLocalFile() && kfile.isDir() ? QString::number(QDir(kfile.localPath()).count()-2) : QStringLiteral("0")}};
0556         }
0557 #endif
0558
0559         const FMH::MODEL FMStatic::getFileInfoModel(const QUrl &path)
0560         {
0561             FMH::MODEL res;
0562 #ifdef KIO_AVAILABLE
0563             res = FMStatic::getFileInfo(KFileItem(path, KFileItem::MimeTypeDetermination::NormalMimeTypeDetermination));
0564 #else
0565             if(FMStatic::getPathType(path) == FMStatic::PATHTYPE_KEY::TAGS_PATH)
0566             {
0567                 res = FMH::MODEL {
0568                 {FMH::MODEL_KEY::LABEL, path.fileName()},
0569                 {FMH::MODEL_KEY::NAME, path.fileName()},
0570                 {FMH::MODEL_KEY::IS_SYMLINK, QStringLiteral("false")},
0571                 {FMH::MODEL_KEY::IS_FILE, QStringLiteral("false")},
0572                 {FMH::MODEL_KEY::HIDDEN, QStringLiteral("false")},
0573                 {FMH::MODEL_KEY::IS_DIR, QStringLiteral("false")},
0574                 {FMH::MODEL_KEY::SIZE, QStringLiteral("0")}, /*locale.formattedDataSize(file.size())*/
0575                 {FMH::MODEL_KEY::PATH, path.toString()},
0576                 {FMH::MODEL_KEY::URL, path.toString()}};
0577
0578             }else
0579             {
0580                 const QFileInfo file(path.toLocalFile());
0581                 if (!file.exists())
0582                     return FMH::MODEL();
0583
0584                 const auto mime = FMStatic::getMime(path);
0585                 res = FMH::MODEL {
0586                 {FMH::MODEL_KEY::SUFFIX, file.completeSuffix()},
0587                 {FMH::MODEL_KEY::LABEL, path.toString() == HomePath ? QStringLiteral("Home") : file.fileName()},
0588                 {FMH::MODEL_KEY::NAME, file.fileName()},
0589                 {FMH::MODEL_KEY::DATE, file.birthTime().toString(Qt::TextDate)},
0590                 {FMH::MODEL_KEY::MODIFIED, file.lastModified().toString(Qt::TextDate)},
0591                 {FMH::MODEL_KEY::LAST_READ, file.lastRead().toString(Qt::TextDate)},
0592                 {FMH::MODEL_KEY::MIME, mime},
0593                 {FMH::MODEL_KEY::SYMLINK, file.symLinkTarget()},
0594                 {FMH::MODEL_KEY::IS_SYMLINK, QVariant(file.isSymLink()).toString()},
0595                 {FMH::MODEL_KEY::IS_FILE, QVariant(file.isFile()).toString()},
0596                 {FMH::MODEL_KEY::HIDDEN, QVariant(file.isHidden()).toString()},
0597                 {FMH::MODEL_KEY::IS_DIR, QVariant(file.isDir()).toString()},
0598                 {FMH::MODEL_KEY::SIZE, QString::number(file.size()) /*locale.formattedDataSize(file.size())*/},
0599                 {FMH::MODEL_KEY::PATH, path.toString()},
0600                 {FMH::MODEL_KEY::URL, path.toString()},
0601                 {FMH::MODEL_KEY::THUMBNAIL, thumbnailUrl(path, mime).toString()},
0602                 {FMH::MODEL_KEY::COUNT, file.isDir() ? QString::number(QDir(path.toLocalFile()).count()) : QStringLiteral("0")}};
0603         }
0604         #endif
0605
0606
0607                         res[FMH::MODEL_KEY::ICON] = getIconName(path); //to control what icon is shown
0608                         return res;
0609             }
0610
0611
0612                         const QVariantMap FMStatic::getFileInfo(const QUrl &path)
0613                 {
0614                         return FMH::toMap(getFileInfoModel(path));
0615             }
0616
0617                         const QString FMStatic::getIconName(const QUrl &path)
0618                 {
0619                         if(FMStatic::getPathType(path) == FMStatic::PATHTYPE_KEY::TAGS_PATH)
0620                 {
0621                         return QStringLiteral("tag");
0622             }
0623
0624                         if (path.isLocalFile() && QFileInfo(path.toLocalFile()).isDir())
0625                 {
0626                         if (folderIcon.contains(path.toString()))
0627                         return folderIcon[path.toString()];
0628                         else
0629                 {
0630                         return dirConfIcon(QUrl(QString(path.toString() + QStringLiteral("/%1")).arg(QStringLiteral(".directory"))));
0631             }
0632
0633             } else {
0634         #ifdef KIO_AVAILABLE
0635                         KFileItem mime(path);
0636                         return mime.iconName();
0637         #else
0638                         QMimeDatabase mime;
0639                         const auto type = mime.mimeTypeForFile(path.toString());
0640                         return type.iconName();
0641         #endif
0642             }
0643             }
0644
0645             FMStatic::PATHTYPE_KEY FMStatic::getPathType(const QUrl &url)
0646             {
0647                 return FMStatic::PATHTYPE_SCHEME_NAME[url.scheme()];
0648             }