File indexing completed on 2023-10-03 03:19:59

0001 /*
0002     This file is part of the KDE project
0003     SPDX-FileCopyrightText: 1999-2006 David Faure <faure@kde.org>
0004 
0005     SPDX-License-Identifier: LGPL-2.0-or-later
0006 */
0007 
0008 #ifndef KFILEITEM_H
0009 #define KFILEITEM_H
0010 
0011 #include "kiocore_export.h"
0012 #include <QDateTime>
0013 #include <QFile>
0014 #include <QUrl>
0015 #include <kacl.h>
0016 #include <kio/global.h>
0017 #include <kio/udsentry.h>
0018 
0019 #include <QList>
0020 #include <QMimeType>
0021 #include <qplatformdefs.h>
0022 
0023 class KFileItemPrivate;
0024 
0025 /**
0026  * @class KFileItem kfileitem.h <KFileItem>
0027  *
0028  * A KFileItem is a generic class to handle a file, local or remote.
0029  * In particular, it makes it easier to handle the result of KIO::listDir
0030  * (UDSEntry isn't very friendly to use).
0031  * It includes many file attributes such as MIME type, icon, text, mode, link...
0032  *
0033  * KFileItem is implicitly shared, i.e. it can be used as a value and copied around at almost no cost.
0034  */
0035 class KIOCORE_EXPORT KFileItem
0036 {
0037     Q_GADGET
0038 
0039     Q_PROPERTY(QUrl url READ url WRITE setUrl)
0040     Q_PROPERTY(QString user READ user)
0041     Q_PROPERTY(QString group READ group)
0042     Q_PROPERTY(bool isLink READ isLink)
0043     Q_PROPERTY(bool isDir READ isDir)
0044     Q_PROPERTY(bool isFile READ isFile)
0045     Q_PROPERTY(bool isReadable READ isReadable)
0046     Q_PROPERTY(bool isWritable READ isWritable)
0047     Q_PROPERTY(bool isHidden READ isHidden)
0048     Q_PROPERTY(bool isSlow READ isSlow)
0049     Q_PROPERTY(bool isDesktopFile READ isDesktopFile)
0050     Q_PROPERTY(QString linkDest READ linkDest)
0051     Q_PROPERTY(QUrl targetUrl READ targetUrl)
0052     Q_PROPERTY(QString localPath READ localPath WRITE setLocalPath)
0053     Q_PROPERTY(bool isLocalFile READ isLocalFile)
0054     Q_PROPERTY(QString text READ text)
0055     Q_PROPERTY(QString name READ name WRITE setName)
0056     Q_PROPERTY(QString mimetype READ mimetype)
0057     Q_PROPERTY(QMimeType determineMimeType READ determineMimeType)
0058     Q_PROPERTY(QMimeType currentMimeType READ currentMimeType)
0059     Q_PROPERTY(bool isFinalIconKnown READ isFinalIconKnown)
0060     Q_PROPERTY(bool isMimeTypeKnown READ isMimeTypeKnown)
0061     Q_PROPERTY(QString mimeComment READ mimeComment)
0062     Q_PROPERTY(QString iconName READ iconName)
0063     Q_PROPERTY(QStringList overlays READ overlays)
0064     Q_PROPERTY(QString comment READ comment)
0065     Q_PROPERTY(QString getStatusBarInfo READ getStatusBarInfo)
0066     Q_PROPERTY(bool isRegularFile READ isRegularFile)
0067 
0068 public:
0069     enum { Unknown = static_cast<mode_t>(-1) };
0070 
0071     /**
0072      * The timestamps associated with a file.
0073      * - ModificationTime: the time the file's contents were last modified
0074      * - AccessTime: the time the file was last accessed (last read or written to)
0075      * - CreationTime: the time the file was created
0076      */
0077     enum FileTimes {
0078         // warning: don't change without looking at the Private class
0079         ModificationTime = 0,
0080         AccessTime = 1,
0081         CreationTime = 2,
0082         // ChangeTime
0083     };
0084     Q_ENUM(FileTimes)
0085 
0086     enum MimeTypeDetermination {
0087         NormalMimeTypeDetermination = 0,
0088         SkipMimeTypeFromContent,
0089     };
0090     Q_ENUM(MimeTypeDetermination)
0091 
0092     /**
0093      * Null KFileItem. Doesn't represent any file, only exists for convenience.
0094      */
0095     KFileItem();
0096 
0097     /**
0098      * Creates an item representing a file, from a UDSEntry.
0099      * This is the preferred constructor when using KIO::listDir().
0100      *
0101      * @param entry the KIO entry used to get the file, contains info about it
0102      * @param itemOrDirUrl the URL of the item or of the directory containing this item (see urlIsDirectory).
0103      * @param delayedMimeTypes specifies if the MIME type of the given
0104      *       URL should be determined immediately or on demand.
0105      *       See the bool delayedMimeTypes in the KDirLister constructor.
0106      * @param urlIsDirectory specifies if the url is just the directory of the
0107      *       fileitem and the filename from the UDSEntry should be used.
0108      *
0109      * When creating KFileItems out of the UDSEntry emitted by a KIO list job,
0110      * use KFileItem(entry, listjob->url(), delayedMimeTypes, true);
0111      */
0112     KFileItem(const KIO::UDSEntry &entry, const QUrl &itemOrDirUrl, bool delayedMimeTypes = false, bool urlIsDirectory = false);
0113 
0114 #if KIOCORE_ENABLE_DEPRECATED_SINCE(5, 0)
0115     /**
0116      * Creates an item representing a file, from all the necessary info for it.
0117      * @param mode the file mode (according to stat() (e.g. S_IFDIR...)
0118      * Set to KFileItem::Unknown if unknown. For local files, KFileItem will use stat().
0119      * @param permissions the access permissions
0120      * If you set both the mode and the permissions, you save a ::stat() for
0121      * local files.
0122      * Set to KFileItem::Unknown if you don't know the mode or the permission.
0123      * @param url the file url
0124      *
0125      * @param delayedMimeTypes specify if the MIME type of the given URL
0126      *       should be determined immediately or on demand
0127      * @deprecated since 5.0. Most callers gave Unknown for mode and permissions,
0128      * so just port to KFileItem(url) and setDelayedMimeTypes(true) if necessary.
0129      */
0130     KIOCORE_DEPRECATED_VERSION(5, 0, "See API docs")
0131     KFileItem(mode_t mode, mode_t permissions, const QUrl &url, bool delayedMimeTypes = false);
0132 #endif
0133 
0134     /**
0135      * Creates an item representing a file, for which the MIME type is already known.
0136      * @param url the file url
0137      * @param mimeType the name of the file's MIME type
0138      * @param mode the mode (S_IFDIR...)
0139      */
0140     KFileItem(const QUrl &url, const QString &mimeType = QString(), mode_t mode = KFileItem::Unknown); // KF6 TODO: explicit!
0141 
0142     /**
0143      * Creates an item representing a file, with the option of skipping MIME type determination.
0144      * @param url the file url
0145      * @param mimeTypeDetermination the mode of determining the MIME type:
0146      *       NormalMimeTypeDetermination by content if local file, i.e. access the file,
0147      *                                   open and read part of it;
0148      *                                   by QMimeDatabase::MatchMode::MatchExtension if not local.
0149      *       SkipMimeTypeFromContent     always by QMimeDatabase::MatchMode::MatchExtension,
0150      *                                   i.e. won't access the file by stat() or opening it;
0151      *                                   only suitable for files, directories won't be recognized.
0152      * @since 5.57
0153      */
0154     KFileItem(const QUrl &url, KFileItem::MimeTypeDetermination mimeTypeDetermination);
0155 
0156     /**
0157      * Copy constructor
0158      */
0159     KFileItem(const KFileItem &);
0160 
0161     /**
0162      * Destructor
0163      */
0164     ~KFileItem();
0165 
0166     /**
0167      * Move constructor
0168      * @since 5.43
0169      */
0170     KFileItem(KFileItem &&);
0171 
0172     /**
0173      * Copy assignment
0174      */
0175     KFileItem &operator=(const KFileItem &);
0176 
0177     /**
0178      * Move assignment
0179      * @since 5.43
0180      */
0181     KFileItem &operator=(KFileItem &&);
0182 
0183     /**
0184      * Throw away and re-read (for local files) all information about the file.
0185      * This is called when the _file_ changes.
0186      */
0187     void refresh();
0188 
0189     /**
0190      * Re-reads MIME type information.
0191      * This is called when the MIME type database changes.
0192      */
0193     void refreshMimeType();
0194 
0195     /**
0196      * Sets MIME type determination to be immediate or on demand.
0197      * Call this after the constructor, and before using any MIME-type-related method.
0198      * @since 5.0
0199      */
0200     void setDelayedMimeTypes(bool b);
0201 
0202     /**
0203      * Returns the url of the file.
0204      * @return the url of the file
0205      */
0206     QUrl url() const;
0207 
0208     /**
0209      * Sets the item's URL. Do not call unless you know what you are doing!
0210      * (used for example when an item got renamed).
0211      * @param url the item's URL
0212      */
0213     void setUrl(const QUrl &url);
0214 
0215     /**
0216      * Sets the item's local path (UDS_LOCAL_PATH). Do not call unless you know what you are doing!
0217      * This won't change the item's name or URL.
0218      * (used for example when an item got renamed).
0219      * @param path the item's local path
0220      * @since 5.20
0221      */
0222     void setLocalPath(const QString &path);
0223 
0224     /**
0225      * Sets the item's name (i.e.\ the filename).
0226      * This is automatically done by setUrl, to set the name from the URL's fileName().
0227      * This method is provided for some special cases like relative paths as names (KFindPart)
0228      * @param name the item's name
0229      */
0230     void setName(const QString &name);
0231 
0232     /**
0233      * Returns the permissions of the file (stat.st_mode containing only permissions).
0234      * @return the permissions of the file
0235      */
0236     mode_t permissions() const;
0237 
0238     /**
0239      * Returns the access permissions for the file as a string.
0240      * @return the access permission as string
0241      */
0242     QString permissionsString() const;
0243 
0244     /**
0245      * Tells if the file has extended access level information ( Posix ACL )
0246      * @return true if the file has extend ACL information or false if it hasn't
0247      */
0248     bool hasExtendedACL() const;
0249 
0250     /**
0251      * Returns the access control list for the file.
0252      * @return the access control list as a KACL
0253      */
0254     KACL ACL() const;
0255 
0256     /**
0257      * Returns the default access control list for the directory.
0258      * @return the default access control list as a KACL
0259      */
0260     KACL defaultACL() const;
0261 
0262     /**
0263      * Returns the file type (stat.st_mode containing only S_IFDIR, S_IFLNK, ...).
0264      * @return the file type
0265      */
0266     mode_t mode() const;
0267 
0268     /**
0269      * Returns the owner of the file.
0270      * @return the file's owner
0271      */
0272     QString user() const;
0273 
0274     /**
0275      * Returns the group of the file.
0276      * @return the file's group
0277      */
0278     QString group() const;
0279 
0280     /**
0281      * Returns true if this item represents a link in the UNIX sense of
0282      * a link.
0283      * @return true if the file is a link
0284      */
0285     bool isLink() const;
0286 
0287     /**
0288      * Returns true if this item represents a directory.
0289      * @return true if the item is a directory
0290      */
0291     bool isDir() const;
0292 
0293     /**
0294      * Returns true if this item represents a file (and not a directory)
0295      * @return true if the item is a file
0296      */
0297     bool isFile() const;
0298 
0299     /**
0300      * Checks whether the file or directory is readable. In some cases
0301      * (remote files), we may return true even though it can't be read.
0302      * @return true if the file can be read - more precisely,
0303      *         false if we know for sure it can't
0304      */
0305     bool isReadable() const;
0306 
0307     /**
0308      * Checks whether the file or directory is writable. In some cases
0309      * (remote files), we may return true even though it can't be written to.
0310      * @return true if the file or directory can be written to - more precisely,
0311      *         false if we know for sure it can't
0312      */
0313     bool isWritable() const;
0314 
0315     /**
0316      * Checks whether the file is hidden.
0317      * @return true if the file is hidden.
0318      */
0319     bool isHidden() const;
0320 
0321     /**
0322      * @return true if the file is a remote URL, or a local file on a network mount.
0323      * It will return false only for really-local file systems.
0324      * @since 4.7.4
0325      */
0326     bool isSlow() const;
0327 
0328     /**
0329      * Checks whether the file is a readable local .desktop file,
0330      * i.e.\ a file whose path can be given to KDesktopFile
0331      * @return true if the file is a desktop file.
0332      * @since 4.1
0333      */
0334     bool isDesktopFile() const;
0335 
0336     /**
0337      * Returns the link destination if isLink() == true.
0338      * @return the link destination. QString() if the item is not a link
0339      */
0340     QString linkDest() const;
0341 
0342     /**
0343      * Returns the target url of the file, which is the same as url()
0344      * in cases where the worker doesn't specify UDS_TARGET_URL
0345      * @return the target url.
0346      * @since 4.1
0347      */
0348     QUrl targetUrl() const;
0349 
0350     /**
0351      * Returns the local path if isLocalFile() == true or the KIO item has
0352      * a UDS_LOCAL_PATH atom.
0353      * @return the item local path, or QString() if not known
0354      */
0355     QString localPath() const;
0356 
0357     /**
0358      * Returns the size of the file, if known.
0359      * @return the file size, or 0 if not known
0360      */
0361     KIO::filesize_t size() const;
0362 
0363     /**
0364      * @brief For folders, its recursive size:
0365      * the size of its files plus the recursiveSize of its folder
0366      *
0367      * Initially only implemented for trash:/
0368      *
0369      * @since 5.70
0370      * @return The recursive size
0371      */
0372     KIO::filesize_t recursiveSize() const;
0373 
0374     /**
0375      * Requests the modification, access or creation time, depending on @p which.
0376      * @param which the timestamp
0377      * @return the time asked for, QDateTime() if not available
0378      * @see timeString()
0379      */
0380     Q_INVOKABLE QDateTime time(FileTimes which) const;
0381 
0382     /**
0383      * Requests the modification, access or creation time as a string, depending
0384      * on @p which.
0385      * @param which the timestamp
0386      * @returns a formatted string of the requested time.
0387      * @see time
0388      */
0389     Q_INVOKABLE QString timeString(FileTimes which = ModificationTime) const;
0390 
0391 #if KIOCORE_ENABLE_DEPRECATED_SINCE(4, 0)
0392     KIOCORE_DEPRECATED_VERSION(4, 0, "Use KFileItem::timeString(FileTimes)")
0393     QString timeString(unsigned int which) const;
0394 #endif
0395 
0396     /**
0397      * Returns true if the file is a local file.
0398      * @return true if the file is local, false otherwise
0399      */
0400     bool isLocalFile() const;
0401 
0402     /**
0403      * Returns the text of the file item.
0404      * It's not exactly the filename since some decoding happens ('%2F'->'/').
0405      * @return the text of the file item
0406      */
0407     QString text() const;
0408 
0409     /**
0410      * Return the name of the file item (without a path).
0411      * Similar to text(), but unencoded, i.e. the original name.
0412      * @param lowerCase if true, the name will be returned in lower case,
0413      * which is useful to speed up sorting by name, case insensitively.
0414      * @return the file's name
0415      */
0416     QString name(bool lowerCase = false) const;
0417 
0418     /**
0419      * Returns the MIME type of the file item.
0420      * If @p delayedMimeTypes was used in the constructor, this will determine
0421      * the MIME type first. Equivalent to determineMimeType()->name()
0422      * @return the MIME type of the file
0423      */
0424     QString mimetype() const;
0425 
0426     /**
0427      * Returns the MIME type of the file item.
0428      * If delayedMimeTypes was used in the constructor, this will determine
0429      * the MIME type first.
0430      * @return the MIME type
0431      */
0432     QMimeType determineMimeType() const;
0433 
0434     /**
0435      * Returns the currently known MIME type of the file item.
0436      * This will not try to determine the MIME type if unknown.
0437      * @return the known MIME type
0438      */
0439     QMimeType currentMimeType() const;
0440 
0441     /**
0442      * @return true if we have determined the final icon of this file already.
0443      * @since 4.10.2
0444      */
0445     bool isFinalIconKnown() const;
0446 
0447     /**
0448      * @return true if we have determined the MIME type of this file already,
0449      * i.e. if determineMimeType() will be fast. Otherwise it will have to
0450      * find what the MIME type is, which is a possibly slow operation; usually
0451      * this is delayed until necessary.
0452      */
0453     bool isMimeTypeKnown() const;
0454 
0455     /**
0456      * Returns the user-readable string representing the type of this file,
0457      * like "OpenDocument Text File".
0458      * @return the type of this KFileItem
0459      */
0460     QString mimeComment() const;
0461 
0462     /**
0463      * Returns the full path name to the icon that represents
0464      * this MIME type.
0465      * @return iconName the name of the file's icon
0466      */
0467     QString iconName() const;
0468 
0469     /**
0470      * Returns the overlays (bitfield of KIconLoader::*Overlay flags) that are used
0471      * for this item's pixmap. Overlays are used to show for example, whether
0472      * a file can be modified.
0473      * @return the overlays of the pixmap
0474      */
0475     QStringList overlays() const;
0476 
0477     /**
0478      * A comment which can contain anything - even rich text. It will
0479      * simply be displayed to the user as is.
0480      *
0481      * @since 4.6
0482      */
0483     QString comment() const;
0484 
0485     /**
0486      * Returns the string to be displayed in the statusbar,
0487      * e.g.\ when the mouse is over this item.
0488      * @return the status bar information
0489      */
0490     QString getStatusBarInfo() const;
0491 
0492 #if KIOCORE_ENABLE_DEPRECATED_SINCE(4, 0)
0493     /**
0494      * Returns true if files can be dropped over this item.
0495      * Contrary to popular belief, not only dirs will return true :)
0496      * Executables, .desktop files, will do so as well.
0497      * @return true if you can drop files over the item
0498      *
0499      * @deprecated Since 4.0. This logic is application-dependent, the behavior described above
0500      * mostly makes sense for file managers only.
0501      * KDirModel has setDropsAllowed for similar (but configurable) logic.
0502      */
0503     KIOCORE_DEPRECATED_VERSION(4, 0, "See API docs")
0504     bool acceptsDrops() const;
0505 #endif
0506 
0507     /**
0508      * Returns the UDS entry. Used by the tree view to access all details
0509      * by position.
0510      * @return the UDS entry
0511      */
0512     KIO::UDSEntry entry() const;
0513 
0514     /**
0515      * Return true if this item is a regular file,
0516      * false otherwise (directory, link, character/block device, fifo, socket)
0517      * @since 4.3
0518      */
0519     bool isRegularFile() const;
0520 
0521     /**
0522      * Somewhat like a comparison operator, but more explicit,
0523      * and it can detect that two fileitems differ if any property of the file item
0524      * has changed (file size, modification date, etc.). Two items are equal if
0525      * all properties are equal. In contrast, operator== only compares URLs.
0526      * @param item the item to compare
0527      * @return true if all values are equal
0528      */
0529     bool cmp(const KFileItem &item) const;
0530 
0531     /**
0532      * Returns true if both items share the same URL.
0533      */
0534     bool operator==(const KFileItem &other) const;
0535 
0536     /**
0537      * Returns true if both items do not share the same URL.
0538      */
0539     bool operator!=(const KFileItem &other) const;
0540 
0541     /**
0542      * Returns true if this item's URL is lexically less than other's URL; otherwise returns false
0543      * @since 5.48
0544      */
0545     bool operator<(const KFileItem &other) const;
0546 
0547     /**
0548      * Returns true if this item's URL is lexically less than url other; otherwise returns false
0549      * @since 5.48
0550      */
0551     bool operator<(const QUrl &other) const;
0552 
0553     /**
0554      * Converts this KFileItem to a QVariant, this allows to use KFileItem
0555      * in QVariant() constructor
0556      */
0557     operator QVariant() const;
0558 
0559 #if KIOCORE_ENABLE_DEPRECATED_SINCE(4, 0)
0560     /**
0561      * @deprecated Since 4.0, simply use '='
0562      */
0563     KIOCORE_DEPRECATED_VERSION(4, 0, "Use KFileItem::operator=(const KFileItem&)")
0564     void assign(const KFileItem &item);
0565 #endif
0566 
0567     /**
0568      * Tries to return a local URL for this file item if possible.
0569      * If @p local is not null, it will be set to @c true if the returned url is local,
0570      * @c false otherwise.
0571      *
0572      * Example:
0573      * @code
0574      * bool isLocal = false;
0575      * KFileItem item;
0576      * const QUrl url = item.mostLocalUrl(&isLocal);
0577      * if (isLocal) {
0578      *    // Use url
0579      * }
0580      * @endcode
0581      *
0582      * @since 4.6
0583      */
0584     QUrl mostLocalUrl(bool *local = nullptr) const;
0585 
0586     struct MostLocalUrlResult {
0587         QUrl url;
0588         bool local;
0589     };
0590 
0591     /**
0592      * Returns a MostLocalUrlResult, with the local Url for this item if possible
0593      * (otherwise an empty Url), and a bool that is set to @c true if this Url
0594      * does represent a local file otherwise @c false.
0595      *
0596      * Basically this is an alternative to mostLocalUrl(bool*), that does not use an
0597      * output parameter.
0598      *
0599      * Example:
0600      * @code
0601      * KFileItem item;
0602      * const MostLocalUrlResult result = item.isMostLocalUrl();
0603      * if (result.local) { // A local file
0604      *    // Use result.url
0605      * }
0606      * @endcode
0607      * @since 5.84
0608      */
0609     MostLocalUrlResult isMostLocalUrl() const;
0610 
0611 #if KIOCORE_ENABLE_DEPRECATED_SINCE(5, 0)
0612     /**
0613      * @deprecated since 5.0 add '&' in front of your boolean argument
0614      */
0615     KIOCORE_DEPRECATED_VERSION(5, 0, "Use KFileItem::mostLocalUrl(bool *)")
0616     QUrl mostLocalUrl(bool &local) const
0617     {
0618         return mostLocalUrl(&local);
0619     }
0620 #endif
0621 
0622     /**
0623      * Return true if default-constructed
0624      */
0625     bool isNull() const;
0626 
0627 private:
0628     QSharedDataPointer<KFileItemPrivate> d;
0629 
0630     /**
0631      * Hides the file.
0632      */
0633     KIOCORE_NO_EXPORT void setHidden();
0634 
0635 private:
0636     KIOCORE_EXPORT friend QDataStream &operator<<(QDataStream &s, const KFileItem &a);
0637     KIOCORE_EXPORT friend QDataStream &operator>>(QDataStream &s, KFileItem &a);
0638 
0639     friend class KFileItemTest;
0640     friend class KCoreDirListerCache;
0641 };
0642 
0643 Q_DECLARE_METATYPE(KFileItem)
0644 Q_DECLARE_TYPEINFO(KFileItem, Q_MOVABLE_TYPE);
0645 
0646 inline uint qHash(const KFileItem &item)
0647 {
0648     return qHash(item.url());
0649 }
0650 
0651 /**
0652  * @class KFileItemList kfileitem.h <KFileItem>
0653  *
0654  * List of KFileItems, which adds a few helper
0655  * methods to QList<KFileItem>.
0656  */
0657 class KIOCORE_EXPORT KFileItemList : public QList<KFileItem>
0658 {
0659 public:
0660     /// Creates an empty list of file items.
0661     KFileItemList();
0662 
0663     /// Creates a new KFileItemList from a QList of file @p items.
0664     KFileItemList(const QList<KFileItem> &items);
0665 
0666     /// Creates a new KFileItemList from an initializer_list of file @p items.
0667     /// @since 5.76
0668     KFileItemList(std::initializer_list<KFileItem> items);
0669 
0670     /**
0671      * Find a KFileItem by name and return it.
0672      * @return the item with the given name, or a null-item if none was found
0673      *         (see KFileItem::isNull())
0674      */
0675     KFileItem findByName(const QString &fileName) const;
0676 
0677     /**
0678      * Find a KFileItem by URL and return it.
0679      * @return the item with the given URL, or a null-item if none was found
0680      *         (see KFileItem::isNull())
0681      */
0682     KFileItem findByUrl(const QUrl &url) const;
0683 
0684     /// @return the list of URLs that those items represent
0685     QList<QUrl> urlList() const;
0686 
0687     /// @return the list of target URLs that those items represent
0688     /// @since 4.2
0689     QList<QUrl> targetUrlList() const;
0690 
0691     // TODO KDE-5 add d pointer here so that we can merge KFileItemListProperties into KFileItemList
0692 };
0693 
0694 KIOCORE_EXPORT QDataStream &operator<<(QDataStream &s, const KFileItem &a);
0695 KIOCORE_EXPORT QDataStream &operator>>(QDataStream &s, KFileItem &a);
0696 
0697 /**
0698  * Support for qDebug() << aFileItem
0699  * \since 4.4
0700  */
0701 KIOCORE_EXPORT QDebug operator<<(QDebug stream, const KFileItem &item);
0702 
0703 #endif