File indexing completed on 2024-05-26 04:33:07

 /*
  * KDE. Krita Project.
  *
  * SPDX-FileCopyrightText: 2020 Deif Lou <ginoba@gmail.com>
  *
  * SPDX-License-Identifier: GPL-2.0-or-later
  */
 
 #include <generator/kis_generator.h>
 #include <generator/kis_generator_registry.h>
 #include <KoResourceLoadResult.h>
 
 #include "KisHalftoneFilterConfiguration.h"
 
 KisHalftoneFilterConfiguration::KisHalftoneFilterConfiguration(const QString & name,
                                                                qint32 version,
                                                                KisResourcesInterfaceSP resourcesInterface)
     : KisFilterConfiguration(name, version, resourcesInterface)
 {}
 
 KisHalftoneFilterConfiguration::KisHalftoneFilterConfiguration(const KisHalftoneFilterConfiguration &rhs)
     : KisFilterConfiguration(rhs)
 {
     QHashIterator<QString, KisFilterConfigurationSP> it(rhs.m_generatorConfigurationsCache);
     while (it.hasNext()) {
         it.next();
         m_generatorConfigurationsCache[it.key()] = it.value()->clone();
     }
 }
 
 KisHalftoneFilterConfiguration::~KisHalftoneFilterConfiguration()
 {}
 
 KisFilterConfigurationSP KisHalftoneFilterConfiguration::clone() const
 {
     return new KisHalftoneFilterConfiguration(*this);
 }
 
 void KisHalftoneFilterConfiguration::setResourcesInterface(KisResourcesInterfaceSP resourcesInterface)
 {
     KisFilterConfiguration::setResourcesInterface(resourcesInterface);
 
     if (mode() == HalftoneMode_IndependentChannels) {
         const QString prefix = colorModelId() + "_channel";
         for (int i = 0; i < 4; ++i) {
             const QString fullPrefix = prefix + QString::number(i) + "_";
             KisFilterConfigurationSP generatorConfig = generatorConfiguration(fullPrefix);
             if (generatorConfig) {
                 m_generatorConfigurationsCache[fullPrefix]->setResourcesInterface(resourcesInterface);
             }
         }
     } else {
         const QString prefix = mode() + "_";
         KisFilterConfigurationSP generatorConfig = generatorConfiguration(prefix);
         if (generatorConfig) {
             m_generatorConfigurationsCache[prefix]->setResourcesInterface(resourcesInterface);
         }
     }
 }
 
 QList<KoResourceLoadResult> KisHalftoneFilterConfiguration::linkedResources(KisResourcesInterfaceSP globalResourcesInterface) const
 {
     QList<KoResourceLoadResult> resourcesList;
 
     if (mode() == HalftoneMode_IndependentChannels) {
         const QString prefix = colorModelId() + "_channel";
         for (int i = 0; i < 4; ++i) {
             const QString fullPrefix = prefix + QString::number(i) + "_";
             KisFilterConfigurationSP generatorConfig = generatorConfiguration(fullPrefix);
             if (generatorConfig) {
                 resourcesList += generatorConfig->linkedResources(globalResourcesInterface);
             }
         }
     } else {
         const QString prefix = mode() + "_";
         KisFilterConfigurationSP generatorConfig = generatorConfiguration(prefix);
         if (generatorConfig) {
             resourcesList += generatorConfig->linkedResources(globalResourcesInterface);
         }
     }
 
     return resourcesList;
 }
 
 QList<KoResourceLoadResult> KisHalftoneFilterConfiguration::embeddedResources(KisResourcesInterfaceSP globalResourcesInterface) const
 {
     QList<KoResourceLoadResult> resourcesList;
 
     if (mode() == HalftoneMode_IndependentChannels) {
         const QString prefix = colorModelId() + "_channel";
         for (int i = 0; i < 4; ++i) {
             const QString fullPrefix = prefix + QString::number(i) + "_";
             KisFilterConfigurationSP generatorConfig = generatorConfiguration(fullPrefix);
             if (generatorConfig) {
                 resourcesList += generatorConfig->embeddedResources(globalResourcesInterface);
             }
         }
     } else {
         const QString prefix = mode() + "_";
         KisFilterConfigurationSP generatorConfig = generatorConfiguration(prefix);
         if (generatorConfig) {
             resourcesList += generatorConfig->embeddedResources(globalResourcesInterface);
         }
     }
 
     return resourcesList;
 }
 
 QString KisHalftoneFilterConfiguration::colorModelId() const
 {
     return getString("color_model_id", "");
 }
 
 QString KisHalftoneFilterConfiguration::mode() const
 {
     return getString("mode", "");
 }
 
 QString KisHalftoneFilterConfiguration::generatorId(const QString &prefix) const
 {
     return getString(prefix + "generator", "");
 }
 
 KisFilterConfigurationSP KisHalftoneFilterConfiguration::generatorConfiguration(const QString &prefix) const
 {
     if (m_generatorConfigurationsCache.contains(prefix)) {
         return m_generatorConfigurationsCache[prefix];
     } else {
         QStringList generatorIds = KisGeneratorRegistry::instance()->keys();
         QString generatorId = this->generatorId(prefix);
         if (generatorIds.indexOf(generatorId) != -1) {
             QString fullGeneratorId = prefix + "generator_" + generatorId;
             KisGeneratorSP generator = KisGeneratorRegistry::instance()->get(generatorId);
             KisFilterConfigurationSP generatorConfig = generator->defaultConfiguration(resourcesInterface());
             getPrefixedProperties(fullGeneratorId + "_", generatorConfig);
             m_generatorConfigurationsCache[prefix] = generatorConfig;
             return generatorConfig;
         }
     }
     return nullptr;
 }
 
 qreal KisHalftoneFilterConfiguration::hardness(const QString &prefix) const
 {
     return getDouble(prefix + "hardness", defaultHardness());
 }
 
 bool KisHalftoneFilterConfiguration::invert(const QString &prefix) const
 {
     return getBool(prefix + "invert", defaultInvert());
 }
 
 KoColor KisHalftoneFilterConfiguration::foregroundColor(const QString &prefix) const
 {
     return getColor(prefix + "foreground_color", defaultForegroundColor());
 }
 
 int KisHalftoneFilterConfiguration::foregroundOpacity(const QString &prefix) const
 {
     return getInt(prefix + "foreground_opacity", defaultForegroundOpacity());
 }
 
 KoColor KisHalftoneFilterConfiguration::backgroundColor(const QString &prefix) const
 {
     return getColor(prefix + "background_color", defaultBackgroundColor());
 }
 
 int KisHalftoneFilterConfiguration::backgroundOpacity(const QString &prefix) const
 {
     return getInt(prefix + "background_opacity", defaultForegroundOpacity());
 }
 
 void KisHalftoneFilterConfiguration::setColorModelId(const QString &newColorModelId)
 {
     setProperty("color_model_id", newColorModelId);
 }
 
 void KisHalftoneFilterConfiguration::setMode(const QString &newMode)
 {
     setProperty("mode", newMode);
 }
 
 void KisHalftoneFilterConfiguration::setGeneratorId(const QString &prefix, const QString &id)
 {
     setProperty(prefix + "generator", id);
 }
 
 void KisHalftoneFilterConfiguration::setGeneratorConfiguration(const QString &prefix, KisFilterConfigurationSP config)
 {
     if (!config) {
         return;
     }
 
     QString generatorId = this->generatorId(prefix);
     QString fullGeneratorId = prefix + "generator_" + generatorId;
     setPrefixedProperties(fullGeneratorId + "_", config);
     m_generatorConfigurationsCache[prefix] = config;
 }
 
 void KisHalftoneFilterConfiguration::setHardness(const QString & prefix, qreal newHardness)
 {
     setProperty(prefix + "hardness", newHardness);
 }
 
 void KisHalftoneFilterConfiguration::setInvert(const QString & prefix, bool newInvert)
 {
     setProperty(prefix + "invert", newInvert);
 }
 
 void KisHalftoneFilterConfiguration::setForegroundColor(const QString & prefix, const KoColor & newForegroundColor)
 {
     QVariant v;
     v.setValue(newForegroundColor);
     setProperty(prefix + "foreground_color", v);
 }
 
 void KisHalftoneFilterConfiguration::setForegroundOpacity(const QString & prefix, int newForegroundOpacity)
 {
     setProperty(prefix + "foreground_opacity", newForegroundOpacity);
 }
 void KisHalftoneFilterConfiguration::setBackgroundColor(const QString & prefix, const KoColor & newBackgroundColor)
 {
     QVariant v;
     v.setValue(newBackgroundColor);
     setProperty(prefix + "background_color", v);
 }
 
 void KisHalftoneFilterConfiguration::setBackgroundOpacity(const QString & prefix, int newBackgroundOpacity)
 {
     setProperty(prefix + "background_opacity", newBackgroundOpacity);
 }
 
 void KisHalftoneFilterConfiguration::setProperty(const QString &name, const QVariant &value)
 {
     KisFilterConfiguration::setProperty(name, value);
 
     // The generator configurations are cached, so we need to check if the
     // property name of a property being set represents a property of a
     // generator configuration, and in that case we must remove the cache entry
     // that property belongs to, so that the configuration can be regenerated
     // later. This is an issue mainly when setting the properties directly
     // (through python for example) instead of using the high level methods.
     const QStringList nameParts = name.split('_');
     if (nameParts.size() < 3) {
         return;
     }
     const int generatorKeywordIndex = nameParts[0] == "alpha" || nameParts[0] == "intensity" ? 1 : 2;
     if (nameParts[generatorKeywordIndex] != "generator") {
         return;
     }
     if (generatorKeywordIndex == 1) {
         m_generatorConfigurationsCache.remove(nameParts[0] + "_");
     } else {
         m_generatorConfigurationsCache.remove(nameParts[0] + "_" + nameParts[1] + "_");
     }
 }