ResourceImporter Class Reference

#include <ResourceImporter.h>

Inheritance diagram for ResourceImporter:

Public Member Functions
void	importResources (QString startPath="")
	ResourceImporter (QWidget *parent)
	~ResourceImporter () override

Private Types
enum	ImportFailureReason { MimetypeResourceTypeUnknown , ResourceCannotBeLoaded , CancelledByTheUser , StorageAlreadyExists }

Private Member Functions
void	initialize ()
void	prepareModelsMap ()
void	prepareTypesMaps ()

Private Attributes
QStringList	m_allMimetypes
bool	m_isInitialized {false}
QMap< QString, QStringList >	m_mimetypeForResourceType
QMap< QString, KisResourceModel * >	m_resourceModelsForResourceType
QMap< QString, QStringList >	m_resourceTypesForMimetype
QStringList	m_storagesMimetypes
QWidget *	m_widgetParent {0}
QStringList	m_zipMimetypes

Friends
class	FailureReasonsDialog

Detailed Description

Definition at line 18 of file ResourceImporter.h.

Member Enumeration Documentation

ImportFailureReason

enum ResourceImporter::ImportFailureReason

private

Enumerator
MimetypeResourceTypeUnknown
ResourceCannotBeLoaded
CancelledByTheUser
StorageAlreadyExists

Definition at line 39 of file ResourceImporter.h.

    {
        MimetypeResourceTypeUnknown, // when someone tries to import a .foo file
        ResourceCannotBeLoaded,
        CancelledByTheUser, // the user pressed Cancel when asked
        StorageAlreadyExists, // bundle, asl or abr file already exists in that location
    };

Constructor & Destructor Documentation

ResourceImporter()

ResourceImporter::ResourceImporter

(

QWidget *

parent

)

Definition at line 97 of file ResourceImporter.cpp.

    : m_widgetParent(parent)
{
    initialize();
}

References initialize().

~ResourceImporter()

ResourceImporter::~ResourceImporter ( )

override

Definition at line 104 of file ResourceImporter.cpp.

{
    qDeleteAll(m_resourceModelsForResourceType);
}

References m_resourceModelsForResourceType.

Member Function Documentation

importResources()

void ResourceImporter::importResources

(

QString

startPath = ""

)

Definition at line 109 of file ResourceImporter.cpp.

{
    // TODO: remove debug after finishing the importer
    bool debug = false;
 
    if (startPath.isEmpty()) {
        startPath = QStandardPaths::writableLocation(QStandardPaths::HomeLocation);
    }
 
    KoFileDialog dialog(m_widgetParent, KoFileDialog::OpenFiles, "krita_resources");
    dialog.setDefaultDir(startPath);
    dialog.setCaption(i18nc("Resource Importer file dialog title", "Import Resources and Resource Libraries"));
    dialog.setMimeTypeFilters(m_allMimetypes);
    QStringList filenames = dialog.filenames();
 
 
    if (debug) qCritical() << "All filenames: " << filenames;
 
 
    QMap<QString, QString> troublesomeFiles;
    QStringList troublesomeMimetypes;
 
    QMap<QString, QStringList> troublesomeFilesPerMimetype;
 
 
 
    QMap<QString, QString> resourceTypePerFile;
 
    QStringList successfullyImportedFiles;
    QMap<ImportFailureReason, QStringList> failedFiles;
    failedFiles.insert(StorageAlreadyExists, QStringList());
    failedFiles.insert(MimetypeResourceTypeUnknown, QStringList());
    failedFiles.insert(ResourceCannotBeLoaded, QStringList());
    failedFiles.insert(CancelledByTheUser, QStringList());
 
 
    for (int i = 0; i < filenames.count(); i++) {
        QString mimetype = KisMimeDatabase::mimeTypeForFile(filenames[i]);
        if (m_storagesMimetypes.contains(mimetype)) {
            if (debug) qCritical() << "We're loading a storage here: " << filenames[i];
 
            // import the bundle/asl/abr storage
 
            KisStorageModel::StorageImportOption importMode = KisStorageModel::None;
            if (debug) qCritical() << "checking for storage" << filenames[i] << QFileInfo(filenames[i]).fileName();
            // TODO: three options in case of the same filename: cancel; overwrite; rename;
            // but for now, let's just skip
            bool skip = false;
            if (KisResourceLocator::instance()->hasStorage(QFileInfo(filenames[i]).fileName())) {
                skip = true;
                /*
                if (QMessageBox::warning(m_widgetParent, i18nc("@title:window", "Warning"),
                                         i18n("There is already a resource library with this name installed. Do you want to overwrite it? Resource library name: "),
                                         QMessageBox::Ok | QMessageBox::Cancel) == QMessageBox::Cancel) {
                    importMode = KisStorageModel::Rename;
                }
                else {
                    importMode = KisStorageModel::Overwrite;
                }
                */
            }
            if (skip || !KisStorageModel::instance()->importStorage(filenames[i], importMode)) {
                failedFiles[StorageAlreadyExists] << filenames[i];
            } else {
                successfullyImportedFiles << filenames[i];
            }
 
        } else if (m_zipMimetypes.contains(mimetype)) {
            // TODO: unpack a zip file and then proceed the same way like with others
        } else if (m_resourceTypesForMimetype.contains(mimetype)) {
            bool differentResourceTypes = m_resourceTypesForMimetype.value(mimetype).count() > 1;
            if (differentResourceTypes) {
                if (debug) qCritical() << "We have a difficult situation here!" << filenames[i];
 
                troublesomeFiles.insert(filenames[i], mimetype);
                if (!troublesomeMimetypes.contains(mimetype)) {
                    troublesomeMimetypes.append(mimetype);
                }
 
                if (!troublesomeFilesPerMimetype.contains(mimetype)) {
                    troublesomeFilesPerMimetype.insert(mimetype, QStringList());
                }
                troublesomeFilesPerMimetype[mimetype] = troublesomeFilesPerMimetype[mimetype] << filenames[i];
 
            } else {
                if (debug) qCritical() << "We're loading a" << mimetype << " here: " << filenames[i];
                resourceTypePerFile.insert(filenames[i], m_resourceTypesForMimetype[mimetype][0]);
            }
        } else {
            failedFiles[MimetypeResourceTypeUnknown] << filenames[i];
        }
 
    }
 
    QMap<QString, QStringList> troublesomeResourceTypesPerMimetype;
    for (int i = 0; i < troublesomeMimetypes.size(); i++) {
        troublesomeResourceTypesPerMimetype.insert(troublesomeMimetypes[i], m_resourceTypesForMimetype[troublesomeMimetypes[i]]);
    }
 
    if (troublesomeMimetypes.count() > 0) {
        DlgResourceTypeForFile dlg(m_widgetParent, troublesomeResourceTypesPerMimetype);
        if (dlg.exec() == QDialog::Accepted) {
            for (int i = 0; i < troublesomeMimetypes.count(); i++) {
                QString resourceType = dlg.getResourceTypeForMimetype(troublesomeMimetypes[i]);
                QString mimetype = troublesomeMimetypes[i];
                if (troublesomeFilesPerMimetype.contains(mimetype)) {
                    for (int j = 0; j < troublesomeFilesPerMimetype[mimetype].size(); j++) {
                        resourceTypePerFile.insert(troublesomeFilesPerMimetype[mimetype][j], resourceType);
                    }
                }
            }
        } else {
            for (int i = 0; i < troublesomeMimetypes.count(); i++) {
                for (int j = 0; j < troublesomeFilesPerMimetype[troublesomeMimetypes[i]].size(); j++) {
                    failedFiles[CancelledByTheUser] << troublesomeFilesPerMimetype[troublesomeMimetypes[i]][j];
                }
            }
        }
    }
 
 
 
 
    if (debug) qCritical() <<  "Resource types for mimetype: ";
 
    for (int i = 0; i < m_resourceTypesForMimetype.keys().size(); i++) {
        if (m_resourceTypesForMimetype[m_resourceTypesForMimetype.keys()[i]].size() > 1) {
            if (debug) qCritical() << m_resourceTypesForMimetype.keys()[i] << m_resourceTypesForMimetype[m_resourceTypesForMimetype.keys()[i]];
        }
    }
 
    QString resourceLocationBase = KisResourceLocator::instance()->resourceLocationBase();
 
    QStringList resourceFiles = resourceTypePerFile.keys();
    for (int i = 0; i < resourceFiles.count(); i++) {
        QString resourceType = resourceTypePerFile[resourceFiles[i]];
        if (debug) qCritical() << "Loading " << resourceFiles[i] << "as" << resourceType;
        if (m_resourceModelsForResourceType.contains(resourceType)) {
            if (debug) qCritical() << "We do have a resource model for that!";
            KisResourceModel* model = m_resourceModelsForResourceType[resourceType];
 
            bool allowOverwrite = false;
 
            // first check if we are going to overwrite anything
            if (model->importWillOverwriteResource(resourceFiles[i])) {
                if(!KisResourceUserOperations::userAllowsOverwrite(m_widgetParent, resourceFiles[i])) {
                    continue;
                } else {
                    allowOverwrite = true;
                }
            }
 
            KoResourceSP res = model->importResourceFile(resourceFiles[i], allowOverwrite);
            if (res.isNull()) {
                if (debug) qCritical() << "But the resource is null :( ";
                failedFiles[ResourceCannotBeLoaded] << resourceFiles[i];
            } else {
                if (debug) qCritical() << "The resource isn't null, great!";
                successfullyImportedFiles << resourceFiles[i];
            }
        } else {
            failedFiles[MimetypeResourceTypeUnknown] << resourceFiles[i];
        }
    }
 
    if (debug) qCritical() << "Failed files: " << failedFiles;
    if (debug) qCritical() << "Successfully imported files: " << successfullyImportedFiles;
 
    QList<ImportFailureReason> keys = failedFiles.keys();
    int failedFilesCount = 0;
    for (int i = 0; i < keys.size(); i++) {
        failedFilesCount += failedFiles[keys[i]].size();
    }
    if (failedFilesCount > 0) {
        FailureReasonsDialog dlg(m_widgetParent, failedFiles);
        dlg.exec();
    }
 
}

References CancelledByTheUser, DlgResourceTypeForFile::getResourceTypeForMimetype(), KisResourceModel::importResourceFile(), KisResourceModel::importWillOverwriteResource(), KisResourceLocator::instance(), KisStorageModel::instance(), m_allMimetypes, m_resourceModelsForResourceType, m_resourceTypesForMimetype, m_storagesMimetypes, m_widgetParent, m_zipMimetypes, KisMimeDatabase::mimeTypeForFile(), MimetypeResourceTypeUnknown, KisStorageModel::None, KoFileDialog::OpenFiles, ResourceCannotBeLoaded, KisResourceLocator::resourceLocationBase(), StorageAlreadyExists, and KisResourceUserOperations::userAllowsOverwrite().

initialize()

void ResourceImporter::initialize ( )

private

Definition at line 358 of file ResourceImporter.cpp.

{
    if (!m_isInitialized) {
        prepareTypesMaps();
        prepareModelsMap();
        m_isInitialized = true;
    }
}

References m_isInitialized, prepareModelsMap(), and prepareTypesMaps().

prepareModelsMap()

void ResourceImporter::prepareModelsMap ( )

private

Definition at line 341 of file ResourceImporter.cpp.

{
    KisResourceTypeModel model;
    for (int i = 0; i < model.rowCount(); i++) {
        QModelIndex idx = model.index(i, 0);
        QString resourceType = model.data(idx, Qt::UserRole + KisResourceTypeModel::ResourceType).toString();
        if (!m_resourceModelsForResourceType.contains(resourceType)) {
            KisResourceModel* model = new KisResourceModel(resourceType);
            if (model) {
                m_resourceModelsForResourceType.insert(resourceType, model);
            } else {
                dbgResources << "There is no KisResourceModel available for " << resourceType;
            }
        }
    }
}

References KisResourceTypeModel::data(), dbgResources, m_resourceModelsForResourceType, KisResourceTypeModel::ResourceType, and KisResourceTypeModel::rowCount().

prepareTypesMaps()

void ResourceImporter::prepareTypesMaps ( )

private

Definition at line 289 of file ResourceImporter.cpp.

{
    m_storagesMimetypes = QStringList() << "application/x-krita-bundle"
                                        << "image/x-adobe-brushlibrary"
                                        << "application/x-photoshop-style-library";
 
    m_zipMimetypes = QStringList(); // << "application/zip"; // TODO: implement for zip archives
 
    QStringList resourceTypes;
    KisResourceTypeModel model;
    for (int i = 0; i < model.rowCount(); i++) {
        QModelIndex idx = model.index(i, 0);
        resourceTypes << model.data(idx, Qt::UserRole + KisResourceTypeModel::ResourceType).toString();
    }
    qCritical() << "resource types = " << resourceTypes;
 
    m_mimetypeForResourceType.clear();
    m_resourceTypesForMimetype.clear();
 
    QStringList mimetypes;
    for (int i = 0; i < resourceTypes.count(); i++) {
        QStringList mime = KisResourceLoaderRegistry::instance()->mimeTypes(resourceTypes[i]);
 
        // remove mypaint brushes for now, because we'd need to figure out an UX for them
        // probably 1) remove all the _prev.png files from a list to import as patterns or brush tips
        // and 2) when importing a .myb file, find a proper .png file alongside it to import together
        mime.removeAll("application/x-mypaint-brush");
 
        m_mimetypeForResourceType.insert(resourceTypes[i], mime);
        mimetypes << mime;
        for (int j = 0; j < mime.count(); j++) {
            if (m_resourceTypesForMimetype.contains(mime[j])) {
                if (!m_resourceTypesForMimetype[mime[j]].contains(resourceTypes[i])) {
                    m_resourceTypesForMimetype[mime[j]].append(resourceTypes[i]);
                }
            } else {
                m_resourceTypesForMimetype.insert(mime[j], QStringList() << resourceTypes[i]);
            }
        }
    }
 
    m_allMimetypes << m_storagesMimetypes;
    m_allMimetypes << m_zipMimetypes;
    m_allMimetypes << mimetypes;
 
 
    m_allMimetypes.removeDuplicates();
 
 
 
}

References KisResourceTypeModel::data(), KisResourceLoaderRegistry::instance(), m_allMimetypes, m_mimetypeForResourceType, m_resourceTypesForMimetype, m_storagesMimetypes, m_zipMimetypes, KisResourceLoaderRegistry::mimeTypes(), KisResourceTypeModel::ResourceType, and KisResourceTypeModel::rowCount().

Friends And Related Symbol Documentation

FailureReasonsDialog

friend class FailureReasonsDialog

friend

Definition at line 49 of file ResourceImporter.h.

Member Data Documentation

m_allMimetypes

QStringList ResourceImporter::m_allMimetypes

private

Definition at line 56 of file ResourceImporter.h.

m_isInitialized

bool ResourceImporter::m_isInitialized {false}

private

Definition at line 59 of file ResourceImporter.h.

{false};

m_mimetypeForResourceType

QMap<QString, QStringList> ResourceImporter::m_mimetypeForResourceType

private

Definition at line 53 of file ResourceImporter.h.

m_resourceModelsForResourceType

QMap<QString, KisResourceModel*> ResourceImporter::m_resourceModelsForResourceType

private

Definition at line 51 of file ResourceImporter.h.

m_resourceTypesForMimetype

QMap<QString, QStringList> ResourceImporter::m_resourceTypesForMimetype

private

Definition at line 52 of file ResourceImporter.h.

m_storagesMimetypes

QStringList ResourceImporter::m_storagesMimetypes

private

Definition at line 54 of file ResourceImporter.h.

m_widgetParent

QWidget* ResourceImporter::m_widgetParent {0}

private

Definition at line 57 of file ResourceImporter.h.

{0};

m_zipMimetypes

QStringList ResourceImporter::m_zipMimetypes

private

Definition at line 55 of file ResourceImporter.h.

---

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

• plugins/extensions/resourcemanager/ResourceImporter.h
• plugins/extensions/resourcemanager/ResourceImporter.cpp