RyXéo » ryxeo-WebPhotoAlbum

/****************************************************************************

*

* This file is part of qtFM, a simple, fast file manager.

* Copyright (C) 2010,2011 Wittfella

*

* This file is a local adaptation for RyXeo TagFile System

* Copyright (C) 2012 Eric Seigne <eric.seigne@ryxeo.com>

*

* This program is free software; you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation; either version 2 of the License, or

* (at your option) any later version.

*

* This program 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 General Public License for more details.

*

* You should have received a copy of the GNU General Public License

* along with this program.  If not, see <http://www.gnu.org/licenses/>

*

* Contact e-mail: wittfella@qtfm.org

*

****************************************************************************/

#include "mymodel.h"

#include <unistd.h>

#include <sys/ioctl.h>

//---------------------------------------------------------------------------------

myModel::myModel()

{

    mimeGeneric = new QHash<QString,QString>;

    mimeGlob = new QHash<QString,QString>;

    mimeIcons = new QHash<QString,QIcon>;

    folderIcons = new QHash<QString,QIcon>;

    thumbs = new QHash<QString,QByteArray>;

    icons = new QHash<QString,QIcon>;

    QFile fileIcons(QDir::homePath() + "/.config/ryxeo/file.cache");

    fileIcons.open(QIODevice::ReadOnly);

    QDataStream out(&fileIcons);

    out >> *mimeIcons;

    fileIcons.close();

    fileIcons.setFileName(QDir::homePath() + "/.config/ryxeo/folder.cache");

    fileIcons.open(QIODevice::ReadOnly);

    out.setDevice(&fileIcons);

    out >> *folderIcons;

    fileIcons.close();

    rootItem = new myModelItem(QFileInfo("/"),new myModelItem(QFileInfo(),0));

    currentRootPath = "/";

    QDir root("/");

    QFileInfoList drives = root.entryInfoList(QDir::AllEntries | QDir::Files | QDir::NoDotAndDotDot);

    foreach(QFileInfo drive, drives)

        new myModelItem(drive,rootItem);

    rootItem->walked = true;

    rootItem = rootItem->parent();

    iconFactory = new QFileIconProvider();

}

//---------------------------------------------------------------------------------------

myModel::~myModel()

{

    delete rootItem;

    delete iconFactory;

}

//---------------------------------------------------------------------------------------

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

{

    if(parent.isValid() && parent.column() != 0)

        return QModelIndex();

    myModelItem *parentItem = static_cast<myModelItem*>(parent.internalPointer());

    if(!parentItem) parentItem = rootItem;

    myModelItem *childItem = parentItem->childAt(row);

        if(childItem) return createIndex(row, column, childItem);

    return QModelIndex();

}

//---------------------------------------------------------------------------------------

QModelIndex myModel::index(const QString& path) const

{

//    qDebug() << "myModel::index " << path;

    myModelItem *item = rootItem->matchPath(path.split(SEPARATOR),0);

    if(item) return createIndex(item->childNumber(),0,item);

    return QModelIndex();

}

//---------------------------------------------------------------------------------------

QModelIndex myModel::parent(const QModelIndex &index) const

{

    if(!index.isValid()) return QModelIndex();

    myModelItem *childItem = static_cast<myModelItem*>(index.internalPointer());

    if(!childItem) return QModelIndex();

    myModelItem *parentItem = childItem->parent();

    if (!parentItem || parentItem == rootItem) return QModelIndex();

    return createIndex(parentItem->childNumber(), 0, parentItem);

}

//---------------------------------------------------------------------------------------

QFileInfo myModel::fileInfo(const QModelIndex &index)

{

    myModelItem *item = static_cast<myModelItem*>(index.internalPointer());

    if(item) return item->fileInfo();

    return QFileInfo();

}

//---------------------------------------------------------------------------------------

qint64 myModel::size(const QModelIndex &index)

{

    myModelItem *item = static_cast<myModelItem*>(index.internalPointer());

    if(item) return item->fileInfo().size();

    return 0;

}

//---------------------------------------------------------------------------------------

QString myModel::fileName(const QModelIndex &index)

{

    myModelItem *item = static_cast<myModelItem*>(index.internalPointer());

    if(item) return item->fileName();

    return "";

}

//---------------------------------------------------------------------------------------

QString myModel::filePath(const QModelIndex &index)

{

    myModelItem *item = static_cast<myModelItem*>(index.internalPointer());

    if(item) return item->fileInfo().filePath();

    return false;

}

//---------------------------------------------------------------------------------

bool myModel::setRootPath(const QString& path)

{

    qDebug() << "Changement de rootPath " << path;

    currentRootPath = path;

    myModelItem *item = rootItem->matchPath(path.split(SEPARATOR));

    if(item->walked == 0)

    {

        populateItem(item);

        return false;

    }

    else

    if(item->dirty)                         //model is up to date, but view needs to be invalidated

    {

        item->dirty = 0;

        return true;

    }

    return false;

}

void myModel::populateItem(QString nomFichier)

{

//    qDebug() << "populateItem:: " << nomFichier << " :: " << rootItem->absoluteFilePath();

    beginInsertRows(index(rootItem->absoluteFilePath()),rootItem->childCount(),rootItem->childCount());

    new myModelItem(QFileInfo(nomFichier),rootItem);

    endInsertRows();

}

//---------------------------------------------------------------------------------------

void myModel::populateItem(myModelItem *item)

{

//    qDebug() << "myModel::populateItem(1) : " << item->fileInfo().absolutePath() << " (" << currentRootPath << ")";

    item->walked = 1;

    QDir dir(item->absoluteFilePath());

    QFileInfoList all = dir.entryInfoList(QDir::AllEntries | QDir::NoDotAndDotDot | QDir::Hidden | QDir::System);

//    addWatcher(item);

    foreach(QFileInfo one, all)

        new myModelItem(one,item);

//    qDebug() << "myModel::populateItem :" << item->absoluteFilePath();

}

//---------------------------------------------------------------------------------

int myModel::columnCount(const QModelIndex &parent) const

{

    return (parent.column() > 0) ? 0 : 5;

}

//---------------------------------------------------------------------------------------

int myModel::rowCount(const QModelIndex &parent) const

{

    myModelItem *item = static_cast<myModelItem*>(parent.internalPointer());

    if(item) return item->childCount();

    return rootItem->childCount();

}

//---------------------------------------------------------------------------------

void myModel::clear()

{

    beginResetModel();

    rootItem->clearAll();

    endResetModel();

}

//---------------------------------------------------------------------------------

QModelIndex myModel::insertFile(QModelIndex parent)

{

    myModelItem *item = static_cast<myModelItem*>(parent.internalPointer());

    int num = 0;

    QString name;

    do

    {

        num++;

        name = QString("new_file%1").arg(num);

    }

    while (item->hasChild(name));

    QFile temp(currentRootPath + "/" + name);

    if(!temp.open(QIODevice::WriteOnly)) return QModelIndex();

    temp.close();

    beginInsertRows(parent,item->childCount(),item->childCount());

    new myModelItem(QFileInfo(temp),item);

    endInsertRows();

    return index(item->childCount()-1,0,parent);

}

//---------------------------------------------------------------------------------

Qt::DropActions myModel::supportedDropActions() const

{

    return Qt::CopyAction | Qt::MoveAction;

}

//---------------------------------------------------------------------------------

QStringList myModel::mimeTypes() const

{

    return QStringList("text/uri-list");

}

//---------------------------------------------------------------------------------

QMimeData * myModel::mimeData(const QModelIndexList & indexes) const

{

    QMimeData *data = new QMimeData();

    QList<QUrl> files;

    foreach(QModelIndex index, indexes)

    {

        myModelItem *item = static_cast<myModelItem*>(index.internalPointer());

        files.append(QUrl::fromLocalFile(item->absoluteFilePath()));

    }

    data->setUrls(files);

    return data;

}

//---------------------------------------------------------------------------------

void myModel::cacheInfo()

{

    QFile fileIcons(QDir::homePath() + "/.config/ryxeo/file.cache");

    fileIcons.open(QIODevice::WriteOnly);

    QDataStream out(&fileIcons);

    out << *mimeIcons;

    fileIcons.close();

    fileIcons.setFileName(QDir::homePath() + "/.config/ryxeo/folder.cache");

    fileIcons.open(QIODevice::WriteOnly);

    out.setDevice(&fileIcons);

    out << *folderIcons;

    fileIcons.close();

    if(thumbs->count() > thumbCount)

    {

        fileIcons.setFileName(QDir::homePath() + "/.config/ryxeo/thumbs.cache");

        fileIcons.open(QIODevice::WriteOnly);

        out.setDevice(&fileIcons);

        out << *thumbs;

        fileIcons.close();

    }

}

//---------------------------------------------------------------------------------

void myModel::setMode(bool icons)

{

    showThumbs = icons;

}

//---------------------------------------------------------------------------------

void myModel::loadMimeTypes() const

{

    QFile mimeInfo("/usr/share/mime/globs");

    mimeInfo.open(QIODevice::ReadOnly);

    QTextStream out(&mimeInfo);

    do

    {

        QStringList line = out.readLine().split(":");

        if(line.count() == 2)

        {

            QString suffix = line.at(1);

            suffix.remove("*.");

            QString mimeName = line.at(0);

            mimeName.replace("/","-");

            mimeGlob->insert(suffix,mimeName);

        }

    }

    while (!out.atEnd());

    mimeInfo.close();

    mimeInfo.setFileName("/usr/share/mime/generic-icons");

    mimeInfo.open(QIODevice::ReadOnly);

    out.setDevice(&mimeInfo);

    do

    {

        QStringList line = out.readLine().split(":");

        if(line.count() == 2)

        {

            QString mimeName = line.at(0);

            mimeName.replace("/","-");

            QString icon = line.at(1);

            mimeGeneric->insert(mimeName,icon);

        }

    }

    while (!out.atEnd());

    mimeInfo.close();

}

//---------------------------------------------------------------------------

void myModel::loadThumbsQSL(QStringList indexes)

{

//    qDebug() << "myModel::loadThumbsQSL (1)" << indexes;

    QStringList files,types;

    types << "jpg" << "jpeg" << "png" << "bmp" << "ico" << "svg" << "gif";

    foreach(QString item,indexes) {

        if(types.contains(QFileInfo(item).suffix(),Qt::CaseInsensitive)) {

            files.append(item);

        }

    }

//    qDebug() << "loadThumbs pour " << files;

    if(files.count())

    {

        if(thumbs->count() == 0)

        {

            QFile fileIcons(QDir::homePath() + "/.config/ryxeo/thumbs.cache");

            fileIcons.open(QIODevice::ReadOnly);

            QDataStream out(&fileIcons);

            out >> *thumbs;

            fileIcons.close();

            thumbCount = thumbs->count();

        }

        foreach(QString item, files)

        {

            if(!thumbs->contains(item)) thumbs->insert(item,getThumb(item));

            emit thumbUpdate(index(item));

        }

    }

}

//---------------------------------------------------------------------------

QByteArray myModel::getThumb(QString item)

{

    qDebug() << "Creation du thumbnail pour " << item;

    QImage theThumb, background;

    QImageReader pic(item);

    int w,h,target;

    w = pic.size().width();

    h = pic.size().height();

    if( w > 128 || h > 128)

    {

        target = 114;

        background.load(":/images/background.jpg");

    }

    else

    {

        target = 64;

        background = QImage(128,128,QImage::Format_ARGB32);

        background.fill(QApplication::palette().color(QPalette::Base).rgb());

    }

    if(w > h)

    {

        int newHeight = h * target / w;

        pic.setScaledSize(QSize(target,newHeight));

    }

    else

    {

        int newWidth = w * target / h;

        pic.setScaledSize(QSize(newWidth,target));

    }

    theThumb = pic.read();

    int thumbWidth = theThumb.width();

    int thumbHeight = theThumb.height();

    QPainter painter(&background);

    painter.drawImage(QPoint((128-thumbWidth)/2,(128 - thumbHeight)/2),theThumb);

    QBuffer buffer;

    QImageWriter writer(&buffer,"jpg");

    writer.setQuality(50);

    writer.write(background);

    return buffer.buffer();

}

//---------------------------------------------------------------------------------

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

{

    myModelItem *item = static_cast<myModelItem*>(index.internalPointer());

    if(role == Qt::ForegroundRole)

    {

        QFileInfo type(item->fileInfo());

        if(cutItems.contains(type.filePath())) return QBrush(QColor(Qt::lightGray));

        if(type.isHidden()) return QBrush(QColor(Qt::darkGray));

        if(type.isSymLink()) return QBrush(QColor(Qt::blue));

        if(type.isDir()) return QBrush(QColor(Qt::black));

        if(type.isExecutable()) return QBrush(QColor(Qt::darkGreen));

    }

    else

    if(role == Qt::TextAlignmentRole)

    {

        if(index.column() == 1) return Qt::AlignRight + Qt::AlignVCenter;

    }

    else

    if(role == Qt::DisplayRole)

    {

        QVariant data;

        switch(index.column())

        {

            case 0:

                data = item->fileName();

                break;

            case 1:

                if(item->fileInfo().isDir()) data = "";

                else data = formatSize(item->fileInfo().size());

                break;

            case 2:

                if(item->fileInfo().isDir()) data = "folder";

                else data = item->fileInfo().suffix();

                if(data == "") data = "file";

                break;

            case 3:

                data = item->fileInfo().lastModified().toString(Qt::LocalDate);

                break;

            case 4:

                {

                    QString str;

                    QFlags<QFile::Permissions> perms = item->fileInfo().permissions();

                    if(perms.testFlag(QFile::ReadOwner)) str.append("r"); else str.append(("-"));

                    if(perms.testFlag(QFile::WriteOwner)) str.append("w"); else str.append(("-"));

                    if(perms.testFlag(QFile::ExeOwner)) str.append("x"); else str.append(("-"));

                    if(perms.testFlag(QFile::ReadGroup)) str.append("r"); else str.append(("-"));

                    if(perms.testFlag(QFile::WriteGroup)) str.append("w"); else str.append(("-"));

                    if(perms.testFlag(QFile::ExeGroup)) str.append("x"); else str.append(("-"));

                    if(perms.testFlag(QFile::ReadOther)) str.append("r"); else str.append(("-"));

                    if(perms.testFlag(QFile::WriteOther)) str.append("w"); else str.append(("-"));

                    if(perms.testFlag(QFile::ExeOther)) str.append("x"); else str.append(("-"));

                    str.append(" " + item->fileInfo().owner() + " " + item->fileInfo().group());

                    return str;

                }

            default:

                data = "";

                break;

        }

        return data;

    }

    else

    if(role == Qt::DecorationRole)

    {

        if(index.column() != 0) return QVariant();

        QFileInfo type(item->fileInfo());

        if(type.isDir())

        {

            if(folderIcons->contains(type.fileName())) return folderIcons->value(type.fileName());

            return iconFactory->icon(type);

        }

        else

        {

            if(showThumbs)

            {

                if(icons->contains(item->absoluteFilePath())) return icons->value(item->absoluteFilePath());

                else

                    if(thumbs->contains(type.filePath()))

                    {

                        QPixmap pic;

                        pic.loadFromData(thumbs->value(item->absoluteFilePath()));

                        icons->insert(item->absoluteFilePath(),QIcon(pic));

                        return icons->value(item->absoluteFilePath());

                    }

            }

            QString suffix = type.suffix();

            if(mimeIcons->contains(suffix)) return mimeIcons->value(suffix);

            QIcon theIcon;

            if(suffix.isEmpty())

            {

                if(type.isExecutable()) suffix = "exec";

                else suffix = "none";

                if(mimeIcons->contains(suffix)) return mimeIcons->value(suffix);

                if(suffix == "exec") theIcon = QIcon::fromTheme("application-x-executable");

                else theIcon = QIcon(qApp->style()->standardIcon(QStyle::SP_FileIcon));

             }

            else

            {

                if(mimeGlob->count() == 0) loadMimeTypes();

                //try mimeType as it is

                QString mimeType = mimeGlob->value(type.suffix().toLower());

                if(QIcon::hasThemeIcon(mimeType)) theIcon = QIcon::fromTheme(mimeType);

                else

                {

                    //try matching generic icon

                    if(QIcon::hasThemeIcon(mimeGeneric->value(mimeType))) theIcon = QIcon::fromTheme(mimeGeneric->value(mimeType));

                    else

                    {

                        //last resort try adding "-x-generic" to base type

                        if(QIcon::hasThemeIcon(mimeType.split("-").at(0) + "-x-generic")) theIcon = QIcon::fromTheme(mimeType.split("-").at(0) + "-x-generic");

                        else theIcon = QIcon(qApp->style()->standardIcon(QStyle::SP_FileIcon));

                    }

                }

            }

            mimeIcons->insert(suffix,theIcon);

            return theIcon;

        }

    }

    else

    if(role == Qt::EditRole)

    {

        return item->fileName();

    }

//    if(role == Qt::StatusTipRole)

//    {

//        return item->fileName();

//    }

    return QVariant();

}

//---------------------------------------------------------------------------------

bool myModel::setData(const QModelIndex & index, const QVariant & value, int role)

{

    //can only set the filename

    myModelItem *item = static_cast<myModelItem*>(index.internalPointer());

    //physically change the name on disk

    bool ok = QFile::rename(item->absoluteFilePath(),item->parent()->absoluteFilePath() + SEPARATOR + value.toString());

    //change the details in the modelItem

    if(ok)

    {

        item->changeName(value.toString());

        emit dataChanged(index,index);

    }

    return ok;

}

//---------------------------------------------------------------------------------

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

{

    if(role == Qt::DisplayRole)

        switch(section)

        {

        case 0: return tr("Name");

        case 1: return tr("Size");

        case 2: return tr("Type");

        case 4: return tr("Owner");

        case 3: return tr("Date Modified");

            default: return QVariant();

        }

    return QVariant();

}

//---------------------------------------------------------------------------------------

Qt::ItemFlags myModel::flags(const QModelIndex &index) const

{

    if(!index.isValid()) return 0;

    return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled;

}