ZDir.h

Go to the documentation of this file.

/*
* Zuble - A run-time system for QML/Javascript applications
* Copyright (C) 2013, 2014  Bob Dinitto
*
* Filename:   ZDir.h
* Created on: 11/9/2014
* Author:     Bob Dinitto
*
* Zuble is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*
*/

#ifndef ZDIR_H
#define ZDIR_H

#include <QObject>
#include <QDir>
#include <QVariant>
#include "zblcore_global.h"
#include "zglobal.h"
#include "ZblException.h"

namespace Zbl
{

class ZBLCORESHARED_EXPORT ZDir : public QObject
{
    Q_OBJECT
    Q_ENUMS(Filter)
    Q_ENUMS(Sort)
    Q_DISABLE_COPY(ZDir)

public:

    // to participate in automatic enum propagation
    // for QML programs we redeclare these QDir enums

    enum Filter {
        Dirs        = QDir::Dirs,
        Files       = QDir::Files,
        Drives      = QDir::Drives,
        NoSymLinks  = QDir::NoSymLinks,
        AllEntries  = QDir::AllEntries,
        TypeMask    = QDir::TypeMask,

        Readable    = QDir::Readable,
        Writable    = QDir::Writable,
        Executable  = QDir::Executable,
        PermissionMask    = QDir::PermissionMask,

        Modified    = QDir::Modified,
        Hidden      = QDir::Hidden,
        System      = QDir::System,

        AccessMask  = QDir::AccessMask,

        AllDirs       = QDir::AllDirs,
        CaseSensitive = QDir::CaseSensitive,
        NoDot         = QDir::NoDot,
        NoDotDot      = QDir::NoDotDot,
        NoDotAndDotDot = QDir::NoDotAndDotDot,

        NoFilter = QDir::NoFilter
    };
    Q_DECLARE_FLAGS(Filters, Filter)


    enum Sort {
        Name        = QDir::Name,
        Time        = QDir::Time,
        Size        = QDir::Size,
        Unsorted    = QDir::Unsorted,
        SortByMask  = QDir::SortByMask,

        DirsFirst   = QDir::DirsFirst,
        Reversed    = QDir::Reversed,
        IgnoreCase  = QDir::IgnoreCase,
        DirsLast    = QDir::DirsLast,
        LocaleAware = QDir::LocaleAware,
        Type        = QDir::Type,
        NoSort = QDir::NoSort
    };
    Q_DECLARE_FLAGS(SortFlags, Sort)

    
    explicit ZDir(QObject *parent = nullptr);

    explicit ZDir(const QDir& dir, QObject *parent = nullptr);

    virtual ~ZDir();

    static void registerType();

    // Properties

    Q_PROPERTY(QVariant tags READ getTags NOTIFY tagsChanged)
    Q_PROPERTY(uint filter READ getFilter WRITE setFilter NOTIFY filterChanged)
    Q_PROPERTY(QString path READ getPath NOTIFY pathChanged)
    Q_PROPERTY(QString absolutePath READ getAbsolutePath NOTIFY pathChanged)
    Q_PROPERTY(QString canonicalPath READ getCanonicalPath NOTIFY pathChanged)
    Q_PROPERTY(QString dirName READ getDirName NOTIFY pathChanged)
    Q_PROPERTY(uint count READ getCount)
    Q_PROPERTY(bool isReadable READ isReadable)
    Q_PROPERTY(bool exists READ exists)
    Q_PROPERTY(bool isRoot READ isRoot)

    // Javascript methods

    Q_INVOKABLE void setPath(const QString & path);
    Q_INVOKABLE void setToCurrentPath();
    Q_INVOKABLE void setToHomePath();
    Q_INVOKABLE bool rename(const QString & oldName, const QString & newName);
    Q_INVOKABLE void swap(QObject* zDir);

    Q_INVOKABLE bool setCurrent(const QString &path);
    Q_INVOKABLE QString currentPath();
    Q_INVOKABLE QString homePath();
    Q_INVOKABLE QString rootPath();
    Q_INVOKABLE QString tempPath();

    Q_INVOKABLE QString filePath(const QString &fileName) const;
    Q_INVOKABLE QString absoluteFilePath(const QString &fileName) const;
    Q_INVOKABLE QString relativeFilePath(const QString &fileName) const;

    Q_INVOKABLE bool cd(const QString &dirName);
    Q_INVOKABLE bool cdUp();

    Q_INVOKABLE QString getChildName(int pos);

    Q_INVOKABLE bool mkdir(const QString &dirName) const;
    Q_INVOKABLE bool rmdir(const QString &dirName) const;
    Q_INVOKABLE bool mkpath(const QString &dirPath) const;
    Q_INVOKABLE bool rmpath(const QString &dirPath) const;

    Q_INVOKABLE bool removeRecursively();


    Q_INVOKABLE bool remove(const QString &fileName);
    Q_INVOKABLE bool fileExists(const QString &name) const;

    Q_INVOKABLE void refresh() const;

    Q_INVOKABLE bool isRelativePath(const QString &path);
    Q_INVOKABLE bool isAbsolutePath(const QString &path);
    Q_INVOKABLE bool isRelative() const;
    Q_INVOKABLE bool isAbsolute() const;
    Q_INVOKABLE bool makeAbsolute();

    Q_INVOKABLE QString cleanPath(const QString &path);


    Q_INVOKABLE QObject* entryInfoList(
            int filters,
            int sort) const;


    Q_INVOKABLE QStringList entryList(int filters,
                                      int sort) const;

    // Property access methods

    QVariant getTags();
    uint getFilter() const;
    void setFilter(uint filters);

    QString getPath() const;
    QString getAbsolutePath() const;
    QString getCanonicalPath() const;
    QString getDirName() const;
    uint getCount() const;
    bool isReadable() const;
    bool exists() const;
    bool isRoot() const;

#if 0


    //inline void swap(QDir &other)
    //{ qSwap(d_ptr, other.d_ptr); }

    //void setPath(const QString &path);
    //QString path() const;
    //QString absolutePath() const;
    //QString canonicalPath() const;

    static void addResourceSearchPath(const QString &path);

    static void setSearchPaths(const QString &prefix, const QStringList &searchPaths);
    static void addSearchPath(const QString &prefix, const QString &path);
    static QStringList searchPaths(const QString &prefix);

    //QString dirName() const;
    //QString filePath(const QString &fileName) const;
    //QString absoluteFilePath(const QString &fileName) const;
    //QString relativeFilePath(const QString &fileName) const;

    static QString toNativeSeparators(const QString &pathName);
    static QString fromNativeSeparators(const QString &pathName);

    //bool cd(const QString &dirName);
    //bool cdUp();

    QStringList nameFilters() const;
    void setNameFilters(const QStringList &nameFilters);

    //Filters filter() const;
   // void setFilter(Filters filter);
    SortFlags sorting() const;
    void setSorting(SortFlags sort);

    //uint count() const;
    //QString operator[](int) const;

    static QStringList nameFiltersFromString(const QString &nameFilter);

    QStringList entryList(Filters filters = NoFilter, SortFlags sort = NoSort) const;
    QStringList entryList(const QStringList &nameFilters, Filters filters = NoFilter,
                          SortFlags sort = NoSort) const;

    QFileInfoList entryInfoList(Filters filters = NoFilter, SortFlags sort = NoSort) const;
    QFileInfoList entryInfoList(const QStringList &nameFilters, Filters filters = NoFilter,
                                SortFlags sort = NoSort) const;

    //bool mkdir(const QString &dirName) const;
    //bool rmdir(const QString &dirName) const;
    //bool mkpath(const QString &dirPath) const;
    //bool rmpath(const QString &dirPath) const;

    //bool removeRecursively();

    //bool isReadable() const;
    //bool exists() const;
    //bool isRoot() const;

    //static bool isRelativePath(const QString &path);
    //inline static bool isAbsolutePath(const QString &path) { return !isRelativePath(path); }
    //bool isRelative() const;
    //inline bool isAbsolute() const { return !isRelative(); }
    //bool makeAbsolute();

    bool operator==(const QDir &dir) const;
    inline bool operator!=(const QDir &dir) const {  return !operator==(dir); }

    //bool remove(const QString &fileName);
    //bool rename(const QString &oldName, const QString &newName);
   // bool exists(const QString &name) const;

    static QFileInfoList drives();

    static QChar separator();

    //static bool setCurrent(const QString &path);
    //static inline QDir current() { return QDir(currentPath()); }
    //static QString currentPath();

    //static inline QDir home() { return QDir(homePath()); }
    //static QString homePath();
    //static inline QDir root() { return QDir(rootPath()); }
    //static QString rootPath();
    //static inline QDir temp() { return QDir(tempPath()); }
    //static QString tempPath();


    //void refresh() const;


#endif

signals:

    void filterChanged();
    void pathChanged();
    void tagsChanged();

public slots:


protected:

    void initDir();
    void validateDir() const;
    void createTags();

     QDir* m_dir;

     static QVariant m_tags;
};

Q_DECLARE_OPERATORS_FOR_FLAGS(ZDir::Filters)
Q_DECLARE_OPERATORS_FOR_FLAGS(ZDir::SortFlags)


inline void ZDir::initDir()
{
    if(!m_dir)
        m_dir = new QDir();
}

inline void ZDir::validateDir() const
{
    if(!m_dir)
        throw ZblException("Directory object not initialized. Use ZDir.setPath or ZDir.setToCurrentPath methods.");
}


} // Zbl


#endif // ZDIR_H