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
bool	canImportStorage (const QString &filename) const
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 (const QString &filename, StorageImportOption importOption) const
bool	importStorageData (const QString &filename, StorageImportOption importOption, const QByteArray &data) 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)
static bool	importStorageInternal (const QString &filename, StorageImportOption importOption, bool dryRun, const QByteArray &data)

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 34 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(), KisResourceLocator::instance(), removeStorage(), resetQuery(), slotStoragesBulkSynchronizationFinished(), KisResourceLocator::storageAdded(), KisResourceLocator::storageRemoved(), KisResourceLocator::storageResynchronized(), storageResynchronized(), and KisResourceLocator::storagesBulkSynchronizationFinished().

~KisStorageModel()

KisStorageModel::~KisStorageModel ( )

override

Definition at line 51 of file KisStorageModel.cpp.

{
}

Member Function Documentation

addStorage

void KisStorageModel::addStorage ( const QString & location )

privateslot

Called whenever a storage is added.

Definition at line 525 of file KisStorageModel.cpp.

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

References d, and rowCount().

canImportStorage()

bool KisStorageModel::canImportStorage

(

const QString &

filename

)

const

Definition at line 433 of file KisStorageModel.cpp.

{
    return importStorageInternal(filename, None, true, QByteArray());
}

References importStorageInternal(), and None.

columnCount()

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

override

Definition at line 64 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 117 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 311 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 73 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 493 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	(	const QString &	filename,
		StorageImportOption	importOption ) const

Definition at line 421 of file KisStorageModel.cpp.

{
    return importStorageInternal(filename, importOption, false, QByteArray());
}

References importStorageInternal().

importStorageData()

bool KisStorageModel::importStorageData	(	const QString &	filename,
		StorageImportOption	importOption,
		const QByteArray &	data ) const

Definition at line 426 of file KisStorageModel.cpp.

{
    return !data.isEmpty() && importStorageInternal(filename, importOption, false, data);
}

References data(), and importStorageInternal().

importStorageInternal()

bool KisStorageModel::importStorageInternal ( const QString & filename, StorageImportOption importOption, bool dryRun, const QByteArray & data )

staticprivate

Definition at line 438 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;
        }
    }
 
    // Don't actually import, just check if we could.
    if (dryRun) {
        return true;
    }
 
    if (data.isEmpty()) {
        QFile::copy(filename, newLocation);
    } else {
        QSaveFile f(newLocation);
        f.setDirectWriteFallback(false);
 
        if (!f.open(QIODevice::WriteOnly) || f.write(data) != data.size() || !f.flush()) {
            qWarning() << "Error writing" << data.size() << "bytes to" << newLocation << "storage:" << f.errorString();
            return false;
        }
 
        f.commit();
    }
 
    // 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(), data(), findUnusedName(), KoResourcePaths::getAppDataLocation(), KisResourceLocator::instance(), KIS_ASSERT, Overwrite, and Rename.

instance()

KisStorageModel * KisStorageModel::instance ( )

static

Definition at line 46 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 532 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 549 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 55 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 272 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 540 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 331 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 319 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 102 of file KisStorageModel.h.

---

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

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