ZDir.cpp

Go to the documentation of this file.

/*
 * Zuble - A run-time system for QML/Javascript applications
 * Copyright (C) 2013, 2014  Bob Dinitto
 *
 * Filename:   ZDir.cpp
 * 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
 *
 */

#include <QtQml>

#include "ZDir.h"
#include "ZblException.h"
#include "ZblThreadErr.h"
#include "ZFileInfo.h"

namespace Zbl

{

QVariant ZDir::m_tags;

ZDir::ZDir(QObject *parent) :
    QObject(parent), m_dir(nullptr)
{
    createTags();
}


ZDir::ZDir(const QDir& dir, QObject *parent) :
    QObject(parent), m_dir(new QDir(dir))
{
    createTags();
}

ZDir::~ZDir()
{
    if(m_dir)
        delete(m_dir);
}

void ZDir::registerType()
{
    qmlRegisterType<ZDir>("org.zuble.qml", 1, 0, "ZDir");
}


void ZDir::createTags()
{
    if(!m_tags.isNull())
        return;

    QVariantMap map;

    map.insert("Dirs", Dirs);
    map.insert("Files", Files);
    map.insert("Drives", Drives);
    map.insert("NoSymLinks", NoSymLinks);
    map.insert("AllEntries", AllEntries);
    map.insert("TypeMask", TypeMask);
    map.insert("Readable", Readable);
    map.insert("Writable", Writable);
    map.insert("Executable", Executable);
    map.insert("PermissionMask", PermissionMask);
    map.insert("Modified", Modified);
    map.insert("Hidden", Hidden);
    map.insert("System", System);
    map.insert("AccessMask", AccessMask);
    map.insert("AllDirs", AllDirs);
    map.insert("CaseSensitive", CaseSensitive);
    map.insert("NoDot", NoDot);
    map.insert("NoDotDot", NoDotDot);
    map.insert("NoDotAndDotDot", NoDotAndDotDot);
    map.insert("NoFilter", NoFilter);

    map.insert("Name", Name);
    map.insert("Time", Time);
    map.insert("Size", Size);
    map.insert("Unsorted", Unsorted);
    map.insert("SortByMask", SortByMask);
    map.insert("DirsFirst", DirsFirst);
    map.insert("Reversed", Reversed);
    map.insert("IgnoreCase", IgnoreCase);
    map.insert("DirsLast", DirsLast);
    map.insert("LocaleAware", LocaleAware);
    map.insert("Type", Type);
    map.insert("NoSort", NoSort);

    m_tags = QVariant::fromValue(map);
}

QVariant ZDir::getTags()
{
    return m_tags;
}


uint ZDir::getFilter() const
{
    ZBL_SLOT_BEGIN_TRY
    validateDir();
    ZBL_SLOT_END_RETURN(static_cast<uint>(m_dir->filter()), 0,
                    Z_FAC_JS, ZDir::getFilter, getFilter failed)
}

void ZDir::setFilter(uint filters)
{
    ZBL_SLOT_BEGIN_TRY
    initDir();
    m_dir->setFilter(QDir::Filters(filters));
    ZBL_SLOT_END_VOID(Z_FAC_JS, ZDir::setFilter, setFilter failed)
}

void ZDir::setPath(const QString& path)
{
    ZBL_SLOT_BEGIN_TRY
    initDir();
    m_dir->setPath(path);
    ZBL_SLOT_END_VOID(Z_FAC_JS, ZDir::setPath, set path failed)
}

void ZDir::setToCurrentPath()
{
    ZBL_SLOT_BEGIN_TRY
    initDir();
    m_dir->setPath(QDir::currentPath());
    ZBL_SLOT_END_VOID(Z_FAC_JS, ZDir::setToCurrentPath, set to current path failed)
}

void ZDir::setToHomePath()
{
    ZBL_SLOT_BEGIN_TRY
    initDir();
    m_dir->setPath(QDir::homePath());
    ZBL_SLOT_END_VOID(Z_FAC_JS, ZDir::setToCurrentPath, set to current path failed)
}

bool ZDir::rename(const QString& oldName, const QString& newName)
{
    ZBL_SLOT_BEGIN_TRY
    initDir();
    ZBL_SLOT_END_RETURN(m_dir->rename(oldName, newName), false,
                        Z_FAC_JS, ZDir::rename, directory rename failed)
}

void ZDir::swap(QObject* zDir)
{
    ZBL_SLOT_BEGIN_TRY

        if(!zDir)
            throw Zbl::ZblException("can't swap NULL object");

    initDir();

    ZDir* inDir = qobject_cast<ZDir*>(zDir);

    if(!inDir)
        throw ZblException("Invalid object passed to ZDir.swap, object must be type Zbl::ZDir");

    m_dir->swap(*inDir->m_dir);

    ZBL_SLOT_END_VOID(Z_FAC_JS, ZDir::swap, directory swap failed)

}


QString ZDir::getPath() const
{
    ZBL_SLOT_BEGIN_TRY
    validateDir();
    ZBL_SLOT_END_RETURN(m_dir->path(), QString(),
                    Z_FAC_JS, ZDir::getPath, getPath failed)
}

QString ZDir::getAbsolutePath() const
{
    ZBL_SLOT_BEGIN_TRY
    validateDir();
    ZBL_SLOT_END_RETURN(m_dir->absolutePath(), QString(),
                     Z_FAC_JS, ZDir::getAbsolutePath, getAbsolutePath failed)
}

QString ZDir::getCanonicalPath() const
{
    ZBL_SLOT_BEGIN_TRY
    validateDir();
    ZBL_SLOT_END_RETURN(m_dir->canonicalPath(), QString(),
                    Z_FAC_JS, ZDir::getCanonicalPath, getCanonicalPath failed)

}

QString ZDir::getDirName() const
{
    ZBL_SLOT_BEGIN_TRY
    validateDir();
    ZBL_SLOT_END_RETURN(m_dir->dirName(), QString(),
                    Z_FAC_JS, ZDir::getDirName, getDirName failed)

}

QString ZDir::filePath(const QString &fileName) const
{
    ZBL_SLOT_BEGIN_TRY
    validateDir();
    ZBL_SLOT_END_RETURN(m_dir->filePath(fileName), QString(),
                    Z_FAC_JS, ZDir::filePath, filePath failed)
}

QString ZDir::absoluteFilePath(const QString &fileName) const
{
    ZBL_SLOT_BEGIN_TRY
    validateDir();
    ZBL_SLOT_END_RETURN(m_dir->absoluteFilePath(fileName), QString(),
                    Z_FAC_JS, ZDir::absoluteFilePath, absoluteFilePath failed)
}

QString ZDir::relativeFilePath(const QString &fileName) const
{
    ZBL_SLOT_BEGIN_TRY
    validateDir();
    ZBL_SLOT_END_RETURN(m_dir->relativeFilePath(fileName), QString(),
                    Z_FAC_JS, ZDir::relativeFilePath, relativeFilePath failed)
}

bool ZDir::cd(const QString &dirName)
{
    ZBL_SLOT_BEGIN_TRY
    validateDir();
    ZBL_SLOT_END_RETURN(m_dir->cd(dirName), false,
                    Z_FAC_JS, ZDir::cd, cd failed)
}

bool ZDir::cdUp()
{
    ZBL_SLOT_BEGIN_TRY
    validateDir();
    ZBL_SLOT_END_RETURN(m_dir->cdUp(), false,
                    Z_FAC_JS, ZDir::cdUp, cdUp failed)
}

uint ZDir::getCount() const
{
    ZBL_SLOT_BEGIN_TRY
    validateDir();
    ZBL_SLOT_END_RETURN(m_dir->count(), 0,
                    Z_FAC_JS, ZDir::getCount, getCount failed)
}

QString ZDir::getChildName(int pos)
{
    ZBL_SLOT_BEGIN_TRY
    validateDir();
    ZBL_SLOT_END_RETURN((*m_dir)[pos],  QString(),
                    Z_FAC_JS, ZDir::getChildName, getChildName failed)
}

 bool ZDir::mkdir(const QString &dirName) const
 {
     ZBL_SLOT_BEGIN_TRY
     validateDir();
     ZBL_SLOT_END_RETURN(m_dir->mkdir(dirName),  false,
                     Z_FAC_JS, ZDir::mkdir, mkdir failed)
 }

 bool ZDir::rmdir(const QString &dirName) const
 {
     ZBL_SLOT_BEGIN_TRY
     validateDir();
     ZBL_SLOT_END_RETURN(m_dir->rmdir(dirName),  false,
                     Z_FAC_JS, ZDir::rmdir, rmdir failed)
 }

 bool ZDir::mkpath(const QString &dirPath) const
 {
     ZBL_SLOT_BEGIN_TRY
     validateDir();
     ZBL_SLOT_END_RETURN(m_dir->mkpath(dirPath),  false,
                     Z_FAC_JS, ZDir::mkpath, mkpath failed)
 }

 bool ZDir::rmpath(const QString &dirPath) const
 {
     ZBL_SLOT_BEGIN_TRY
     validateDir();
     ZBL_SLOT_END_RETURN(m_dir->rmpath(dirPath),  false,
                     Z_FAC_JS, ZDir::rmpath, rmpath failed)
 }

 bool ZDir::removeRecursively()
 {
     ZBL_SLOT_BEGIN_TRY
     validateDir();
     ZBL_SLOT_END_RETURN(m_dir->removeRecursively(),  false,
                     Z_FAC_JS, ZDir::removeRecursively, removeRecursively failed)
 }

 bool ZDir::isReadable() const
 {
     ZBL_SLOT_BEGIN_TRY
     validateDir();
     ZBL_SLOT_END_RETURN(m_dir->isReadable(),  false,
                     Z_FAC_JS, ZDir::isReadable, isReadable failed) }

 bool ZDir::exists() const
 {
     ZBL_SLOT_BEGIN_TRY
     validateDir();
     ZBL_SLOT_END_RETURN(m_dir->exists(),  false,
                     Z_FAC_JS, ZDir::exists, exists failed)
 }

 bool ZDir::isRoot() const
 {
     ZBL_SLOT_BEGIN_TRY
     validateDir();
     ZBL_SLOT_END_RETURN(m_dir->isRoot(),  false,
                     Z_FAC_JS, ZDir::isRoot, isRoot failed)
 }

 bool ZDir::remove(const QString &fileName)
 {
     ZBL_SLOT_BEGIN_TRY
     validateDir();
     ZBL_SLOT_END_RETURN(m_dir->remove(fileName),  false,
                     Z_FAC_JS, ZDir::remove, remove failed)
 }

 bool ZDir::fileExists(const QString &name) const
 {
     ZBL_SLOT_BEGIN_TRY
     validateDir();
     ZBL_SLOT_END_RETURN(m_dir->exists(name),  false,
                     Z_FAC_JS, ZDir::exists, exists failed)
 }

 void ZDir::refresh() const
 {
     ZBL_SLOT_BEGIN_TRY
     validateDir();
     m_dir->refresh();
     ZBL_SLOT_END_VOID(Z_FAC_JS, ZDir::refresh, refresh failed)
 }


 bool ZDir::isRelativePath(const QString &path)
 {
     ZBL_SLOT_BEGIN_TRY
     ZBL_SLOT_END_RETURN(QDir::isRelativePath(path),  false,
                     Z_FAC_JS, ZDir::isRelativePath, isRelativePath failed)
 }

 bool ZDir::isAbsolutePath(const QString &path)
 {
     ZBL_SLOT_BEGIN_TRY
      ZBL_SLOT_END_RETURN(QDir::isAbsolutePath(path),  false,
                     Z_FAC_JS, ZDir::isAbsolutePath, isAbsolutePath failed)
 }

 bool ZDir::isRelative() const
 {
     ZBL_SLOT_BEGIN_TRY
     validateDir();
     ZBL_SLOT_END_RETURN(m_dir->isRelative(),  false,
                     Z_FAC_JS, ZDir::isRelative, isRelative failed)
 }

 bool ZDir::isAbsolute() const
 {
     ZBL_SLOT_BEGIN_TRY
     validateDir();
     ZBL_SLOT_END_RETURN(m_dir->isAbsolute(),  false,
                     Z_FAC_JS, ZDir::isAbsolute, isAbsolute failed)
 }

 bool ZDir::makeAbsolute()
 {
     ZBL_SLOT_BEGIN_TRY
     validateDir();
     ZBL_SLOT_END_RETURN(m_dir->makeAbsolute(),  false,
                     Z_FAC_JS, ZDir::makeAbsolute, makeAbsolute failed)
 }


 bool ZDir::setCurrent(const QString &path)
 {
     ZBL_SLOT_BEGIN_TRY
     ZBL_SLOT_END_RETURN(QDir::setCurrent(path),  false,
                     Z_FAC_JS, ZDir::setCurrent, setCurrent failed)
 }

 QString ZDir::currentPath()
 {
     ZBL_SLOT_BEGIN_TRY
     ZBL_SLOT_END_RETURN(QDir::currentPath(),  QString(),
             Z_FAC_JS, ZDir::currentPath, currentPath failed)
 }

 QString ZDir::homePath()
 {
     ZBL_SLOT_BEGIN_TRY
     ZBL_SLOT_END_RETURN(QDir::homePath(),  QString(),
                     Z_FAC_JS, ZDir::homePath, homePath failed)
 }

 QString ZDir::rootPath()
 {
     ZBL_SLOT_BEGIN_TRY
     ZBL_SLOT_END_RETURN(QDir::rootPath(),  QString(),
                     Z_FAC_JS, ZDir::rootPath, rootPath failed)
 }

 QString ZDir::tempPath()
 {
     ZBL_SLOT_BEGIN_TRY
     ZBL_SLOT_END_RETURN(QDir::tempPath(),  QString(),
                     Z_FAC_JS, ZDir::tempPath, tempPath failed)
 }


 QString ZDir::cleanPath(const QString &path)
 {
     ZBL_SLOT_BEGIN_TRY
     ZBL_SLOT_END_RETURN(QDir::cleanPath(path),  QString(),
                     Z_FAC_JS, ZDir::cleanPath, tempPath cleanPath)
 }



 QObject* ZDir::entryInfoList(int filters, int sort) const
 {
     //Q_UNUSED(filters)
     //Q_UNUSED(sort)

     qDebug("ZDir::entryInfoList -- filters = %x, sort = %x", filters, sort);

     ZFileInfo* info = nullptr;


     ZBL_SLOT_BEGIN_TRY
     validateDir();
     info = new ZFileInfo();

     info->setInfoList(m_dir->entryInfoList(static_cast<QDir::Filter>(filters),
                                            static_cast<QDir::SortFlags>(sort)));

     ZBL_SLOT_END_RETURN(info,  NULL,
                     Z_FAC_JS, ZDir::entryInfoList, entryInfoList failed)

 }

 QStringList ZDir::entryList(int filters, int sort) const
 {

     qDebug("ZDir::entryList -- filters = %x, sort = %x", filters, sort);

     QStringList info;


     ZBL_SLOT_BEGIN_TRY
     validateDir();

     info = m_dir->entryList(static_cast<QDir::Filter>(filters),
                                            static_cast<QDir::SortFlags>(sort));

     ZBL_SLOT_END_RETURN(info,  info,
                     Z_FAC_JS, ZDir::entryList, entryList failed)

 }

} // Zbl