KisStorageModel Class Reference

#include <KisStorageModel.h>

Inheritance diagram for KisStorageModel:

Classes
struct	Private

Public Types
enum	Columns {   Id = 0 , StorageType , Location , TimeStamp ,   PreInstalled , Active , Thumbnail , DisplayName ,   MetaData }
enum	StorageImportOption { None , Overwrite , Rename }

Signals
void	storageDisabled (const QString &storage)
void	storageEnabled (const QString &storage)
void	storageResynchronized (const QString &storage, bool isBulkResynchronization)
	Emitted when an individual storage is initialized.
void	storagesBulkSynchronizationFinished ()
	Emitted on loading when all the storages are finished initialization.

Public Member Functions
int	columnCount (const QModelIndex &parent=QModelIndex()) const override
QVariant	data (const QModelIndex &index, int role) const override
Qt::ItemFlags	flags (const QModelIndex &index) const override
QVariant	headerData (int section, Qt::Orientation orientation, int role=Qt::DisplayRole) const override
bool	importStorage (QString filename, StorageImportOption importOption) const
	KisStorageModel (QObject *parent=0)
int	rowCount (const QModelIndex &parent=QModelIndex()) const override
bool	setData (const QModelIndex &index, const QVariant &value, int role) override
	Enable and disable the storage represented by index.
KisResourceStorageSP	storageForId (const int storageId) const
KisResourceStorageSP	storageForIndex (const QModelIndex &index) const
	~KisStorageModel () override

Static Public Member Functions
static KisStorageModel *	instance ()

Private Slots
void	addStorage (const QString &location)
	Called whenever a storage is added.
void	removeStorage (const QString &location)
	This is called when a storage really is deleted both from database and anywhere else.
void	slotStoragesBulkSynchronizationFinished ()
	called when storages finished synchronization process

Private Member Functions
void	resetQuery ()

Static Private Member Functions
static QImage	getThumbnailFromQuery (const QSqlQuery &query)

Private Attributes
QScopedPointer< Private >	d

Detailed Description

KisStorageModel provides a model of all registered storages, like the folder storages, the bundle storages or the memory storages. Note that inactive storages are also part of this model.

Definition at line 24 of file KisStorageModel.h.

Member Enumeration Documentation

Columns

enum KisStorageModel::Columns

Enumerator
Id
StorageType
Location
TimeStamp
PreInstalled
Active
Thumbnail
DisplayName
MetaData

Definition at line 29 of file KisStorageModel.h.

                 {
        Id = 0,
        StorageType,
        Location,
        TimeStamp,
        PreInstalled,
        Active,
        Thumbnail,
        DisplayName,
        MetaData
    };

StorageImportOption

enum KisStorageModel::StorageImportOption

Enumerator
None
Overwrite
Rename

Definition at line 41 of file KisStorageModel.h.

                             {
        None,
        Overwrite,
        Rename,
    };

Constructor & Destructor Documentation

KisStorageModel()

KisStorageModel::KisStorageModel

(

QObject *

parent = 0

)

Definition at line 33 of file KisStorageModel.cpp.

    : QAbstractTableModel(parent)
    , d(new Private())
{
    connect(KisResourceLocator::instance(), &KisResourceLocator::storageAdded, this, &KisStorageModel::addStorage);
    connect(KisResourceLocator::instance(), &KisResourceLocator::storageRemoved, this, &KisStorageModel::removeStorage);
    connect(KisResourceLocator::instance(), &KisResourceLocator::storageResynchronized, this, &KisStorageModel::storageResynchronized);
    connect(KisResourceLocator::instance(), &KisResourceLocator::storagesBulkSynchronizationFinished, this, &KisStorageModel::slotStoragesBulkSynchronizationFinished);
 
    resetQuery();
}

References addStorage(), connect(), KisResourceLocator::instance(), removeStorage(), resetQuery(), slotStoragesBulkSynchronizationFinished(), KisResourceLocator::storageAdded(), KisResourceLocator::storageRemoved(), KisResourceLocator::storageResynchronized(), storageResynchronized(), and KisResourceLocator::storagesBulkSynchronizationFinished().

~KisStorageModel()

KisStorageModel::~KisStorageModel ( )

override

Definition at line 50 of file KisStorageModel.cpp.

{
}

Member Function Documentation

addStorage

void KisStorageModel::addStorage ( const QString & location )

privateslot

Called whenever a storage is added.

Definition at line 486 of file KisStorageModel.cpp.

{
    beginInsertRows(QModelIndex(), rowCount(), rowCount());
    d->storages.append(location);
    endInsertRows();
}

References d, and rowCount().

columnCount()

int KisStorageModel::columnCount ( const QModelIndex & parent = QModelIndex() ) const

override

Definition at line 63 of file KisStorageModel.cpp.

{
    if (parent.isValid()) {
        return 0;
    }
 
    return (int)MetaData;
}

References MetaData.

data()

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

override

Definition at line 116 of file KisStorageModel.cpp.

{
    QVariant v;
 
    if (!index.isValid()) return v;
    if (index.row() > rowCount()) return v;
    if (index.column() > (int)MetaData) return v;
 
    if (role == Qt::FontRole) {
        return QFont();
    }
 
    QString location = d->storages.at(index.row());
 
    QSqlQuery query;
 
    bool r = query.prepare(
        "SELECT storages.id as id\n"
        ",      storage_types.name as storage_type\n"
        ",      location\n"
        ",      timestamp\n"
        ",      pre_installed\n"
        ",      active\n"
        "FROM   storages\n"
        ",      storage_types\n"
        "WHERE  storages.storage_type_id = storage_types.id\n"
        "AND    location = :location");
 
    if (!r) {
        qWarning() << "Could not prepare KisStorageModel data query" << query.lastError();
        return v;
    }
 
    query.bindValue(":location", location);
 
    r = query.exec();
 
    if (!r) {
        qWarning() << "Could not execute KisStorageModel data query" << query.lastError() << query.boundValues();
        return v;
    }
 
    if (!query.first()) {
        qWarning() << "KisStorageModel data query did not return anything";
        return v;
    }
 
    if ((role == Qt::DisplayRole || role == Qt::EditRole) && index.column() == Active) {
        return query.value("active");
    } else {
        switch (role) {
        case Qt::DisplayRole:
        {
            switch(index.column()) {
            case Id:
                return query.value("id");
            case StorageType:
                return query.value("storage_type");
            case Location:
                return query.value("location");
            case TimeStamp:
                return QDateTime::fromSecsSinceEpoch(query.value("timestamp").value<int>()).toString();
            case PreInstalled:
                return query.value("pre_installed");
            case Active:
                return query.value("active");
            case Thumbnail:
            {
                return getThumbnailFromQuery(query);
            }
            case DisplayName:
            {
                QMap<QString, QVariant> r = KisResourceLocator::instance()->metaDataForStorage(query.value("location").toString());
                QVariant name = query.value("location");
                if (r.contains(KisResourceStorage::s_meta_name) && !r[KisResourceStorage::s_meta_name].toString().isNull()) {
                    name = r[KisResourceStorage::s_meta_name];
                }
                else if (r.contains(KisResourceStorage::s_meta_title) && !r[KisResourceStorage::s_meta_title].toString().isNull()) {
                    name = r[KisResourceStorage::s_meta_title];
                }
                return name;
            }
            case Qt::UserRole + MetaData:
            {
                QMap<QString, QVariant> r = KisResourceLocator::instance()->metaDataForStorage(query.value("location").toString());
                return r;
            }
            default:
                return v;
            }
        }
        case Qt::CheckStateRole: {
            switch (index.column()) {
            case PreInstalled:
                if (query.value("pre_installed").toInt() == 0) {
                    return Qt::Unchecked;
                } else {
                    return Qt::Checked;
                }
            case Active:
                if (query.value("active").toInt() == 0) {
                    return Qt::Unchecked;
                } else {
                    return Qt::Checked;
                }
            default:
                return {};
            }
        }
        case Qt::DecorationRole: {
            if (index.column() == Thumbnail) {
                return getThumbnailFromQuery(query);
            }
            return {};
        }
        case Qt::UserRole + Id:
            return query.value("id");
        case Qt::UserRole + DisplayName:
        {
            QMap<QString, QVariant> r = KisResourceLocator::instance()->metaDataForStorage(query.value("location").toString());
            QVariant name = query.value("location");
            if (r.contains(KisResourceStorage::s_meta_name) && !r[KisResourceStorage::s_meta_name].toString().isNull()) {
                name = r[KisResourceStorage::s_meta_name];
            }
            else if (r.contains(KisResourceStorage::s_meta_title) && !r[KisResourceStorage::s_meta_title].toString().isNull()) {
                name = r[KisResourceStorage::s_meta_title];
            }
            return name;
        }
        case Qt::UserRole + StorageType:
            return query.value("storage_type");
        case Qt::UserRole + Location:
            return query.value("location");
        case Qt::UserRole + TimeStamp:
            return query.value("timestamp");
        case Qt::UserRole + PreInstalled:
            return query.value("pre_installed");
        case Qt::UserRole + Active:
            return query.value("active");
        case Qt::UserRole + Thumbnail:
            return getThumbnailFromQuery(query);
        case Qt::UserRole + MetaData:
        {
            QMap<QString, QVariant> r = KisResourceLocator::instance()->metaDataForStorage(query.value("location").toString());
            return r;
        }
 
        default:
            ;
        }
    }
 
    return v;
}

References Active, d, DisplayName, getThumbnailFromQuery(), Id, KisResourceLocator::instance(), Location, MetaData, KisResourceLocator::metaDataForStorage(), PreInstalled, rowCount(), KisResourceStorage::s_meta_name, KisResourceStorage::s_meta_title, StorageType, Thumbnail, TimeStamp, and v.

flags()

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

override

Definition at line 310 of file KisStorageModel.cpp.

{
    if (!index.isValid()) {
        return Qt::NoItemFlags;
    }
    return QAbstractTableModel::flags(index) | Qt::ItemIsEditable | Qt::ItemNeverHasChildren;
}

getThumbnailFromQuery()

QImage KisStorageModel::getThumbnailFromQuery ( const QSqlQuery & query )

staticprivate

Definition at line 72 of file KisStorageModel.cpp.

{
    const QString storageLocation = query.value("location").toString();
    const QString storageType = query.value("storage_type").toString();
    const QString storageIdAsString = query.value("id").toString();
 
    QImage img = KisResourceThumbnailCache::instance()->originalImage(storageLocation, storageType, storageIdAsString);
    if (!img.isNull()) {
        return img;
    } else {
        const int storageId = query.value("id").toInt();
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(storageId >= 0, img);
 
        bool result = false;
        QSqlQuery thumbQuery;
        result = thumbQuery.prepare("SELECT thumbnail FROM storages WHERE id = :id");
        if (!result) {
            qWarning() << "Failed to prepare query for thumbnail of" << storageId << thumbQuery.lastError();
            return img;
        }
 
        thumbQuery.bindValue(":id", storageId);
 
        result = thumbQuery.exec();
 
        if (!result) {
            qWarning() << "Failed to execute query for thumbnail of" << storageId << thumbQuery.lastError();
            return img;
        }
 
        if (!thumbQuery.next()) {
            qWarning() << "Failed to find thumbnail of" << storageId;
            return img;
        }
 
        QByteArray ba = thumbQuery.value("thumbnail").toByteArray();
        QBuffer buf(&ba);
        buf.open(QBuffer::ReadOnly);
        img.load(&buf, "PNG");
        KisResourceThumbnailCache::instance()->insert(storageLocation, storageType, storageIdAsString, img);
        return img;
    }
}

References KisResourceThumbnailCache::insert(), KisResourceThumbnailCache::instance(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, and KisResourceThumbnailCache::originalImage().

headerData()

QVariant KisStorageModel::headerData ( int section, Qt::Orientation orientation, int role = Qt::DisplayRole ) const

override

Definition at line 454 of file KisStorageModel.cpp.

{
    QVariant v = QVariant();
    if (role != Qt::DisplayRole) {
        return v;
    }
    if (orientation == Qt::Horizontal) {
        switch(section) {
        case Id:
            return i18n("Id");
        case StorageType:
            return i18n("Type");
        case Location:
            return i18n("Location");
        case TimeStamp:
            return i18n("Creation Date");
        case PreInstalled:
            return i18n("Preinstalled");
        case Active:
            return i18n("Active");
        case Thumbnail:
            return i18n("Thumbnail");
        case DisplayName:
            return i18n("Name");
        default:
            v = QString::number(section);
        }
        return v;
    }
    return QAbstractTableModel::headerData(section, orientation, role);
}

References Active, DisplayName, Id, Location, PreInstalled, StorageType, Thumbnail, TimeStamp, and v.

importStorage()

bool KisStorageModel::importStorage	(	QString	filename,
		StorageImportOption	importOption ) const

Definition at line 420 of file KisStorageModel.cpp.

{
    // 1. Copy the bundle/storage to the resource folder
    QFileInfo oldFileInfo(filename);
    QString newDir = KoResourcePaths::getAppDataLocation();
    QString newName = oldFileInfo.fileName();
    QString newLocation = newDir + '/' + newName;
 
    QFileInfo newFileInfo(newLocation);
    if (newFileInfo.exists()) {
        if (importOption == Overwrite) {
            //QFile::remove(newLocation);
            return false;
        } else if (importOption == Rename) {
            newName = findUnusedName(newDir, newName);
            newLocation = newDir + '/' + newName;
            newFileInfo = QFileInfo(newLocation);
        } else { // importOption == None
            return false;
        }
    }
    QFile::copy(filename, newLocation);
 
    // 2. Add the bundle as a storage/update database
    KisResourceStorageSP storage = QSharedPointer<KisResourceStorage>::create(newLocation);
    KIS_ASSERT(!storage.isNull());
    if (storage.isNull()) { return false; }
    if (!KisResourceLocator::instance()->addStorage(newLocation, storage)) {
        qWarning() << "Could not add bundle to the storages" << newLocation;
        return false;
    }
    return true;
}

References addStorage(), findUnusedName(), KoResourcePaths::getAppDataLocation(), KisResourceLocator::instance(), KIS_ASSERT, Overwrite, and Rename.

instance()

KisStorageModel * KisStorageModel::instance ( )

static

Definition at line 45 of file KisStorageModel.cpp.

{
    return s_instance;
}

removeStorage

void KisStorageModel::removeStorage ( const QString & location )

privateslot

This is called when a storage really is deleted both from database and anywhere else.

Definition at line 493 of file KisStorageModel.cpp.

{
    int row = d->storages.indexOf(QFileInfo(location).fileName());
    beginRemoveRows(QModelIndex(), row, row);
    d->storages.removeAt(row);
    endRemoveRows();
}

References d.

resetQuery()

void KisStorageModel::resetQuery ( )

private

Definition at line 510 of file KisStorageModel.cpp.

{
    QSqlQuery query;
 
    bool r = query.prepare(
        "SELECT location\n"
        "FROM   storages\n"
        "ORDER BY id");
    if (!r) {
        qWarning() << "Could not prepare KisStorageModel query" << query.lastError();
    }
 
    r = query.exec();
 
    if (!r) {
        qWarning() << "Could not execute KisStorageModel query" << query.lastError();
    }
 
    d->storages.clear();
    while (query.next()) {
        d->storages << query.value(0).toString();
    }
}

References d.

rowCount()

int KisStorageModel::rowCount ( const QModelIndex & parent = QModelIndex() ) const

override

Definition at line 54 of file KisStorageModel.cpp.

{
    if (parent.isValid()) {
        return 0;
    }
    return d->storages.size();
 
}

References d.

setData()

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

override

Enable and disable the storage represented by index.

Definition at line 271 of file KisStorageModel.cpp.

{
    if (index.isValid()) {
 
        if (role == Qt::CheckStateRole) {
            QSqlQuery query;
            bool r = query.prepare("UPDATE storages\n"
                                   "SET    active = :active\n"
                                   "WHERE  id = :id\n");
            query.bindValue(":active", value);
            query.bindValue(":id", index.data(Qt::UserRole + Id));
 
            if (!r) {
                qWarning() << "Could not prepare KisStorageModel update query" << query.lastError();
                return false;
            }
 
            r = query.exec();
 
            if (!r) {
                qWarning() << "Could not execute KisStorageModel update query" << query.lastError();
                return false;
            }
 
        }
 
        Q_EMIT dataChanged(index, index, {role});
 
        if (value.toBool()) {
            Q_EMIT storageEnabled(data(index, Qt::UserRole + Location).toString());
        }
        else {
            Q_EMIT storageDisabled(data(index, Qt::UserRole + Location).toString());
        }
 
    }
    return true;
}

References data(), Id, Location, storageDisabled(), storageEnabled(), and value().

slotStoragesBulkSynchronizationFinished

void KisStorageModel::slotStoragesBulkSynchronizationFinished ( )

privateslot

called when storages finished synchronization process

Definition at line 501 of file KisStorageModel.cpp.

{
    beginResetModel();
    resetQuery();
    endResetModel();
 
    Q_EMIT storagesBulkSynchronizationFinished();
}

References resetQuery(), and storagesBulkSynchronizationFinished().

storageDisabled

void KisStorageModel::storageDisabled ( const QString & storage )

signal

storageEnabled

void KisStorageModel::storageEnabled ( const QString & storage )

signal

storageForId()

KisResourceStorageSP KisStorageModel::storageForId

(

const int

storageId

)

const

Definition at line 330 of file KisStorageModel.cpp.

{
    QSqlQuery query;
 
    bool r = query.prepare("SELECT location\n"
                           "FROM   storages\n"
                           "WHERE  storages.id = :storageId");
 
    if (!r) {
        qWarning() << "Could not prepare KisStorageModel data query" << query.lastError();
        return 0;
    }
 
    query.bindValue(":storageId", storageId);
 
    r = query.exec();
 
    if (!r) {
        qWarning() << "Could not execute KisStorageModel data query" << query.lastError() << query.boundValues();
        return 0;
    }
 
    if (!query.first()) {
        qWarning() << "KisStorageModel data query did not return anything";
        return 0;
    }
 
    return KisResourceLocator::instance()->storageByLocation(KisResourceLocator::instance()->makeStorageLocationAbsolute(query.value("location").toString()));
}

References KisResourceLocator::instance(), and KisResourceLocator::storageByLocation().

storageForIndex()

KisResourceStorageSP KisStorageModel::storageForIndex

(

const QModelIndex &

index

)

const

Definition at line 318 of file KisStorageModel.cpp.

{
 
    if (!index.isValid()) return 0;
    if (index.row() > rowCount()) return 0;
    if (index.column() > (int)MetaData) return 0;
 
    QString location = d->storages.at(index.row());
 
    return KisResourceLocator::instance()->storageByLocation(KisResourceLocator::instance()->makeStorageLocationAbsolute(location));
}

References d, KisResourceLocator::instance(), MetaData, rowCount(), and KisResourceLocator::storageByLocation().

storageResynchronized

void KisStorageModel::storageResynchronized ( const QString & storage, bool isBulkResynchronization )

signal

Emitted when an individual storage is initialized.

storagesBulkSynchronizationFinished

void KisStorageModel::storagesBulkSynchronizationFinished ( )

signal

Emitted on loading when all the storages are finished initialization.

Member Data Documentation

d

QScopedPointer<Private> KisStorageModel::d

private

Definition at line 95 of file KisStorageModel.h.

---

The documentation for this class was generated from the following files:

• libs/resources/KisStorageModel.h
• libs/resources/KisStorageModel.cpp