diff --git a/libs/image/metadata/kis_exif_info_visitor.h b/libs/image/metadata/kis_exif_info_visitor.h
index e70ddd04e7..998f7a1353 100644
--- a/libs/image/metadata/kis_exif_info_visitor.h
+++ b/libs/image/metadata/kis_exif_info_visitor.h
@@ -1,106 +1,105 @@
 /*
  *  Copyright (c) 2005 Cyrille Berger <cberger@cberger.net>
  *
  *  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, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 #ifndef KIS_EXIF_INFO_VISITOR_H
 #define KIS_EXIF_INFO_VISITOR_H
 
 #include <kis_node_visitor.h>
 #include <metadata/kis_meta_data_store.h>
 #include <metadata/kis_meta_data_filter_registry_model.h>
 #include <kis_paint_layer.h>
 #include <kis_group_layer.h>
 
 /**
  * @brief The KisExifInfoVisitor class looks for a layer with metadata.
  *
  * If there is more than one layer with metadata, the metadata provided
  * by the visitor is the metadata associated with the last layer that
  * had metadata on it. Only use the metadata if only one layer with
  * metadata was found.
  *
  * The metadata pointer is OWNED by the layer.
  *
  */
 class KisExifInfoVisitor : public KisNodeVisitor
 {
 public:
 
-    KisExifInfoVisitor() :
-            m_exifInfo(0),
-            m_countPaintLayer(0) { }
-public:
-
+    KisExifInfoVisitor() { }
 
     bool visit(KisNode*) override {
         return true;
     }
     bool visit(KisCloneLayer*) override {
         return true;
     }
     bool visit(KisFilterMask*) override {
         return true;
     }
     bool visit(KisTransformMask*) override {
         return true;
     }
     bool visit(KisTransparencyMask*) override {
         return true;
     }
     bool visit(KisSelectionMask*) override {
         return true;
     }
     bool visit(KisColorizeMask*) override {
         return true;
     }
     bool visit(KisExternalLayer*) override {
         return true;
     }
     bool visit(KisGeneratorLayer*) override {
         return true;
     }
     bool visit(KisAdjustmentLayer*) override {
         return true;
     }
 
     bool visit(KisPaintLayer* layer) override {
-        m_countPaintLayer++;
         if (!layer->metaData()->empty()) {
+            m_metaDataObjectsEncountered++;
             m_exifInfo = layer->metaData();
         }
         return true;
     }
 
     bool visit(KisGroupLayer* layer) override {
         dbgMetaData << "Visiting on grouplayer" << layer->name() << "";
         return visitAll(layer, true);
     }
 
-
 public:
-    inline uint countPaintLayer() {
-        return m_countPaintLayer;
+    inline uint metaDataCount()
+    {
+        qDebug() << "number of layers with metadata" << m_metaDataObjectsEncountered;
+        return m_metaDataObjectsEncountered;
     }
-    inline KisMetaData::Store* exifInfo() {
+
+    inline KisMetaData::Store* exifInfo()
+    {
         return m_exifInfo;
     }
 private:
-    KisMetaData::Store* m_exifInfo;
-    uint m_countPaintLayer;
+    KisMetaData::Store *m_exifInfo {0};
+    int m_metaDataObjectsEncountered {0};
 };
 
 #endif
diff --git a/plugins/impex/jpeg/kis_jpeg_export.cc b/plugins/impex/jpeg/kis_jpeg_export.cc
index 8de8acbea2..bc9abb6100 100644
--- a/plugins/impex/jpeg/kis_jpeg_export.cc
+++ b/plugins/impex/jpeg/kis_jpeg_export.cc
@@ -1,297 +1,297 @@
 /*
  *  Copyright (c) 2005 Cyrille Berger <cberger@cberger.net>
  *
  *  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, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "kis_jpeg_export.h"
 
 #include <QCheckBox>
 #include <QSlider>
 #include <QColor>
 #include <QString>
 #include <QStringList>
 #include <QApplication>
 #include <QFileInfo>
 #include <QScopedPointer>
 
 #include <kpluginfactory.h>
 
 #include <KoColorSpace.h>
 #include <KoColorProfile.h>
 #include <KoColorSpaceConstants.h>
 #include <KoColorSpaceRegistry.h>
 
 #include <KisImportExportManager.h>
 #include <kis_slider_spin_box.h>
 #include <KisDocument.h>
 #include <KoDocumentInfo.h>
 #include <kis_image.h>
 #include <kis_group_layer.h>
 #include <kis_paint_layer.h>
 #include <kis_paint_device.h>
 #include <kis_properties_configuration.h>
 #include <kis_config.h>
 #include <metadata/kis_meta_data_store.h>
 #include <metadata/kis_meta_data_entry.h>
 #include <metadata/kis_meta_data_value.h>
 #include <metadata/kis_meta_data_schema.h>
 #include <metadata/kis_meta_data_schema_registry.h>
 #include <metadata/kis_meta_data_filter_registry_model.h>
 #include <metadata/kis_exif_info_visitor.h>
 #include <generator/kis_generator_layer.h>
 #include <KisImportExportManager.h>
 #include <KisExportCheckRegistry.h>
 #include "kis_jpeg_converter.h"
 
 class KisExternalLayer;
 
 K_PLUGIN_FACTORY_WITH_JSON(KisJPEGExportFactory, "krita_jpeg_export.json", registerPlugin<KisJPEGExport>();)
 
 KisJPEGExport::KisJPEGExport(QObject *parent, const QVariantList &) : KisImportExportFilter(parent)
 {
 }
 
 KisJPEGExport::~KisJPEGExport()
 {
 }
 
 KisImportExportFilter::ConversionStatus KisJPEGExport::convert(KisDocument *document, QIODevice *io,  KisPropertiesConfigurationSP configuration)
 {
     KisImageSP image = document->savingImage();
     Q_CHECK_PTR(image);
 
     // An extra option to pass to the config widget to set the state correctly, this isn't saved
     const KoColorSpace* cs = image->projection()->colorSpace();
     bool sRGB = cs->profile()->name().contains(QLatin1String("srgb"), Qt::CaseInsensitive);
     configuration->setProperty("is_sRGB", sRGB);
 
     KisJPEGOptions options;
     options.progressive = configuration->getBool("progressive", false);
     options.quality = configuration->getInt("quality", 80);
     options.forceSRGB = configuration->getBool("forceSRGB", false);
     options.saveProfile = configuration->getBool("saveProfile", true);
     options.optimize = configuration->getBool("optimize", true);
     options.smooth = configuration->getInt("smoothing", 0);
     options.baseLineJPEG = configuration->getBool("baseline", true);
     options.subsampling = configuration->getInt("subsampling", 0);
     options.exif = configuration->getBool("exif", true);
     options.iptc = configuration->getBool("iptc", true);
     options.xmp = configuration->getBool("xmp", true);
     KoColor c(KoColorSpaceRegistry::instance()->rgb8());
     c.fromQColor(Qt::white);
     options.transparencyFillColor = configuration->getColor("transparencyFillcolor", c).toQColor();
     KisMetaData::FilterRegistryModel m;
     m.setEnabledFilters(configuration->getString("filters").split(","));
     options.filters = m.enabledFilters();
     options.storeAuthor = configuration->getBool("storeAuthor", false);
     options.storeDocumentMetaData = configuration->getBool("storeMetaData", false);
 
     KisPaintDeviceSP pd = new KisPaintDevice(*image->projection());
 
     KisJPEGConverter kpc(document, batchMode());
     KisPaintLayerSP l = new KisPaintLayer(image, "projection", OPACITY_OPAQUE_U8, pd);
 
     KisExifInfoVisitor exivInfoVisitor;
     exivInfoVisitor.visit(image->rootLayer().data());
 
     QScopedPointer<KisMetaData::Store> metaDataStore;
-    if (exivInfoVisitor.countPaintLayer() == 1) {
+    if (exivInfoVisitor.metaDataCount() == 1) {
         metaDataStore.reset(new KisMetaData::Store(*exivInfoVisitor.exifInfo()));
     }
     else {
         metaDataStore.reset(new KisMetaData::Store());
     }
 
     //add extra meta-data here
     const KisMetaData::Schema* dcSchema = KisMetaData::SchemaRegistry::instance()->schemaFromUri(KisMetaData::Schema::DublinCoreSchemaUri);
     Q_ASSERT(dcSchema);
     if (options.storeDocumentMetaData) {
         QString title = document->documentInfo()->aboutInfo("title");
         if (!title.isEmpty()) {
             if (metaDataStore->containsEntry("title")) {
                 metaDataStore->removeEntry("title");
             }
             metaDataStore->addEntry(KisMetaData::Entry(dcSchema, "title", KisMetaData::Value(QVariant(title))));
         }
         QString description = document->documentInfo()->aboutInfo("subject");
         if (description.isEmpty()) {
             description = document->documentInfo()->aboutInfo("abstract");
         }
         if (!description.isEmpty()) {
             QString keywords = document->documentInfo()->aboutInfo("keyword");
             if (!keywords.isEmpty()) {
                 description = description + " keywords: " + keywords;
             }
             if (metaDataStore->containsEntry("description")) {
                 metaDataStore->removeEntry("description");
             }
             metaDataStore->addEntry(KisMetaData::Entry(dcSchema, "description", KisMetaData::Value(QVariant(description))));
         }
         QString license = document->documentInfo()->aboutInfo("license");
         if (!license.isEmpty()) {
             if (metaDataStore->containsEntry("rights")) {
                 metaDataStore->removeEntry("rights");
             }
             metaDataStore->addEntry(KisMetaData::Entry(dcSchema, "rights", KisMetaData::Value(QVariant(license))));
         }
         QString date = document->documentInfo()->aboutInfo("date");
         if (!date.isEmpty() && !metaDataStore->containsEntry("rights")) {
             metaDataStore->addEntry(KisMetaData::Entry(dcSchema, "date", KisMetaData::Value(QVariant(date))));
         }
     }
     if (options.storeAuthor) {
         QString author = document->documentInfo()->authorInfo("creator");
         if (!author.isEmpty()) {
             if (!document->documentInfo()->authorContactInfo().isEmpty()) {
                 QString contact = document->documentInfo()->authorContactInfo().at(0);
                 if (!contact.isEmpty()) {
                     author = author+"("+contact+")";
                 }
             }
             if (metaDataStore->containsEntry("creator")) {
                 metaDataStore->removeEntry("creator");
             }
             metaDataStore->addEntry(KisMetaData::Entry(dcSchema, "creator", KisMetaData::Value(QVariant(author))));
         }
     }
 
-    KisImageBuilder_Result res = kpc.buildFile(io, l, options, metaDataStore);
+    KisImageBuilder_Result res = kpc.buildFile(io, l, options, metaDataStore.data());
 
     if (res == KisImageBuilder_RESULT_OK) {
         return KisImportExportFilter::OK;
     }
     dbgFile << " Result =" << res;
     return KisImportExportFilter::InternalError;
 }
 
 KisPropertiesConfigurationSP KisJPEGExport::defaultConfiguration(const QByteArray &/*from*/, const QByteArray &/*to*/) const
 {
     KisPropertiesConfigurationSP cfg = new KisPropertiesConfiguration();
     cfg->setProperty("progressive", false);
     cfg->setProperty("quality", 80);
     cfg->setProperty("forceSRGB", false);
     cfg->setProperty("saveProfile", true);
     cfg->setProperty("optimize", true);
     cfg->setProperty("smoothing", 0);
     cfg->setProperty("baseline", true);
     cfg->setProperty("subsampling", 0);
     cfg->setProperty("exif", true);
     cfg->setProperty("iptc", true);
     cfg->setProperty("xmp", true);
     cfg->setProperty("storeAuthor", false);
     cfg->setProperty("storeMetaData", false);
 
     KoColor fill_color(KoColorSpaceRegistry::instance()->rgb8());
     fill_color = KoColor();
     fill_color.fromQColor(Qt::white);
     QVariant v;
     v.setValue(fill_color);
 
     cfg->setProperty("transparencyFillcolor", v);
     cfg->setProperty("filters", "");
 
     return cfg;
 }
 
 KisConfigWidget *KisJPEGExport::createConfigurationWidget(QWidget *parent, const QByteArray &/*from*/, const QByteArray &/*to*/) const
 {
     return new KisWdgOptionsJPEG(parent);
 }
 
 void KisJPEGExport::initializeCapabilities()
 {
     addCapability(KisExportCheckRegistry::instance()->get("sRGBProfileCheck")->create(KisExportCheckBase::SUPPORTED));
     addCapability(KisExportCheckRegistry::instance()->get("ExifCheck")->create(KisExportCheckBase::SUPPORTED));
 
     QList<QPair<KoID, KoID> > supportedColorModels;
     supportedColorModels << QPair<KoID, KoID>()
             << QPair<KoID, KoID>(RGBAColorModelID, Integer8BitsColorDepthID)
             << QPair<KoID, KoID>(GrayAColorModelID, Integer8BitsColorDepthID)
             << QPair<KoID, KoID>(CMYKAColorModelID, Integer8BitsColorDepthID);
     addSupportedColorModels(supportedColorModels, "JPEG");
 }
 
 
 KisWdgOptionsJPEG::KisWdgOptionsJPEG(QWidget *parent)
     : KisConfigWidget(parent)
 {
     setupUi(this);
 
     metaDataFilters->setModel(&m_filterRegistryModel);
     qualityLevel->setRange(0, 100, 0);
     qualityLevel->setSuffix("%");
     smoothLevel->setRange(0, 100, 0);
     smoothLevel->setSuffix("%");
 }
 
 
 void KisWdgOptionsJPEG::setConfiguration(const KisPropertiesConfigurationSP cfg)
 {
     progressive->setChecked(cfg->getBool("progressive", false));
     qualityLevel->setValue(cfg->getInt("quality", 80));
     optimize->setChecked(cfg->getBool("optimize", true));
     smoothLevel->setValue(cfg->getInt("smoothing", 0));
     baseLineJPEG->setChecked(cfg->getBool("baseline", true));
     subsampling->setCurrentIndex(cfg->getInt("subsampling", 0));
     exif->setChecked(cfg->getBool("exif", true));
     iptc->setChecked(cfg->getBool("iptc", true));
     xmp->setChecked(cfg->getBool("xmp", true));
     chkForceSRGB->setVisible(cfg->getBool("is_sRGB"));
     chkForceSRGB->setChecked(cfg->getBool("forceSRGB", false));
     chkSaveProfile->setChecked(cfg->getBool("saveProfile", true));
     KoColor background(KoColorSpaceRegistry::instance()->rgb8());
     background.fromQColor(Qt::white);
     bnTransparencyFillColor->setDefaultColor(background);
     bnTransparencyFillColor->setColor(cfg->getColor("transparencyFillcolor", background));
     chkAuthor->setChecked(cfg->getBool("storeAuthor", false));
     chkMetaData->setChecked(cfg->getBool("storeMetaData", false));
 
     m_filterRegistryModel.setEnabledFilters(cfg->getString("filters").split(','));
 
 }
 
 KisPropertiesConfigurationSP KisWdgOptionsJPEG::configuration() const
 {
     KisPropertiesConfigurationSP cfg = new KisPropertiesConfiguration();
 
     QVariant transparencyFillcolor;
     transparencyFillcolor.setValue(bnTransparencyFillColor->color());
 
     cfg->setProperty("progressive", progressive->isChecked());
     cfg->setProperty("quality", (int)qualityLevel->value());
     cfg->setProperty("forceSRGB", chkForceSRGB->isChecked());
     cfg->setProperty("saveProfile", chkSaveProfile->isChecked());
     cfg->setProperty("optimize", optimize->isChecked());
     cfg->setProperty("smoothing", (int)smoothLevel->value());
     cfg->setProperty("baseline", baseLineJPEG->isChecked());
     cfg->setProperty("subsampling", subsampling->currentIndex());
     cfg->setProperty("exif", exif->isChecked());
     cfg->setProperty("iptc", iptc->isChecked());
     cfg->setProperty("xmp", xmp->isChecked());
     cfg->setProperty("transparencyFillcolor", transparencyFillcolor);
     cfg->setProperty("storeAuthor", chkAuthor->isChecked());
     cfg->setProperty("storeMetaData", chkMetaData->isChecked());
 
     QString enabledFilters;
     Q_FOREACH (const KisMetaData::Filter* filter, m_filterRegistryModel.enabledFilters()) {
         enabledFilters = enabledFilters + filter->id() + ',';
     }
     cfg->setProperty("filters", enabledFilters);
 
     return cfg;
 }
 #include <kis_jpeg_export.moc>
diff --git a/plugins/impex/png/kis_png_export.cc b/plugins/impex/png/kis_png_export.cc
index 73ea449867..56fe0b88f9 100644
--- a/plugins/impex/png/kis_png_export.cc
+++ b/plugins/impex/png/kis_png_export.cc
@@ -1,230 +1,230 @@
 /*
  *  Copyright (c) 2005 Cyrille Berger <cberger@cberger.net>
  *
  *  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, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "kis_png_export.h"
 
 #include <QCheckBox>
 #include <QSlider>
 #include <QApplication>
 
 #include <kpluginfactory.h>
 
 #include <KoColorSpace.h>
 #include <KisImportExportManager.h>
 #include <KoColorProfile.h>
 #include <KoColorModelStandardIds.h>
 #include <KoColorSpaceRegistry.h>
 
 #include <KisExportCheckRegistry.h>
 
 #include <kis_properties_configuration.h>
 #include <kis_paint_device.h>
 #include <KisDocument.h>
 #include <kis_image.h>
 #include <kis_paint_layer.h>
 #include <kis_group_layer.h>
 #include <kis_config.h>
 #include <kis_properties_configuration.h>
 #include <metadata/kis_meta_data_store.h>
 #include <metadata/kis_meta_data_filter_registry_model.h>
 #include <metadata/kis_exif_info_visitor.h>
 #include "kis_png_converter.h"
 #include <kis_iterator_ng.h>
 
 K_PLUGIN_FACTORY_WITH_JSON(KisPNGExportFactory, "krita_png_export.json", registerPlugin<KisPNGExport>();)
 
 KisPNGExport::KisPNGExport(QObject *parent, const QVariantList &) : KisImportExportFilter(parent)
 {
 }
 
 KisPNGExport::~KisPNGExport()
 {
 }
 
 KisImportExportFilter::ConversionStatus KisPNGExport::convert(KisDocument *document, QIODevice *io,  KisPropertiesConfigurationSP configuration)
 {
     KisImageSP image = document->savingImage();
 
     KisPNGOptions options;
 
     options.alpha = configuration->getBool("alpha", true);
     options.interlace = configuration->getBool("interlaced", false);
     options.compression = configuration->getInt("compression", 3);
     options.tryToSaveAsIndexed = configuration->getBool("indexed", false);
     KoColor c(KoColorSpaceRegistry::instance()->rgb8());
     c.fromQColor(Qt::white);
     options.transparencyFillColor = configuration->getColor("transparencyFillcolor", c).toQColor();
     options.saveSRGBProfile = configuration->getBool("saveSRGBProfile", false);
     options.forceSRGB = configuration->getBool("forceSRGB", true);
     options.storeAuthor = configuration->getBool("storeAuthor", false);
     options.storeMetaData = configuration->getBool("storeMetaData", false);
 
     vKisAnnotationSP_it beginIt = image->beginAnnotations();
     vKisAnnotationSP_it endIt = image->endAnnotations();
 
     KisExifInfoVisitor eIV;
     eIV.visit(image->rootLayer().data());
     KisMetaData::Store *eI = 0;
-    if (eIV.countPaintLayer() == 1) {
+    if (eIV.metaDataCount() == 1) {
         eI = eIV.exifInfo();
     }
     if (eI) {
         KisMetaData::Store* copy = new KisMetaData::Store(*eI);
         eI = copy;
     }
 
     KisPNGConverter pngConverter(document);
 
     KisImageBuilder_Result res = pngConverter.buildFile(io, image->bounds(), image->xRes(), image->yRes(), image->projection(), beginIt, endIt, options, eI);
 
     if (res == KisImageBuilder_RESULT_OK) {
         delete eI;
         return KisImportExportFilter::OK;
     }
 
     delete eI;
     dbgFile << " Result =" << res;
     return KisImportExportFilter::InternalError;
 }
 
 KisPropertiesConfigurationSP KisPNGExport::defaultConfiguration(const QByteArray &, const QByteArray &) const
 {
     KisPropertiesConfigurationSP cfg = new KisPropertiesConfiguration();
     cfg->setProperty("alpha", true);
     cfg->setProperty("indexed", false);
     cfg->setProperty("compression", 3);
     cfg->setProperty("interlaced", false);
 
     KoColor fill_color(KoColorSpaceRegistry::instance()->rgb8());
     fill_color = KoColor();
     fill_color.fromQColor(Qt::white);
     QVariant v;
     v.setValue(fill_color);
 
     cfg->setProperty("transparencyFillcolor", v);
     cfg->setProperty("saveSRGBProfile", false);
     cfg->setProperty("forceSRGB", true);
     cfg->setProperty("storeMetaData", false);
     cfg->setProperty("storeAuthor", false);
 
     return cfg;
 }
 
 KisConfigWidget *KisPNGExport::createConfigurationWidget(QWidget *parent, const QByteArray &, const QByteArray &) const
 {
     return new KisWdgOptionsPNG(parent);
 }
 
 void KisPNGExport::initializeCapabilities()
 {
     addCapability(KisExportCheckRegistry::instance()->get("sRGBProfileCheck")->create(KisExportCheckBase::SUPPORTED));
     QList<QPair<KoID, KoID> > supportedColorModels;
     supportedColorModels << QPair<KoID, KoID>()
             << QPair<KoID, KoID>(RGBAColorModelID, Integer8BitsColorDepthID)
             << QPair<KoID, KoID>(RGBAColorModelID, Integer16BitsColorDepthID)
             << QPair<KoID, KoID>(GrayAColorModelID, Integer8BitsColorDepthID)
             << QPair<KoID, KoID>(GrayAColorModelID, Integer16BitsColorDepthID);
     addSupportedColorModels(supportedColorModels, "PNG");
 }
 
 void KisWdgOptionsPNG::setConfiguration(const KisPropertiesConfigurationSP cfg)
 {
     // the export manager should have prepared some info for us!
     KIS_SAFE_ASSERT_RECOVER_NOOP(cfg->hasProperty(KisImportExportFilter::ImageContainsTransparencyTag));
     KIS_SAFE_ASSERT_RECOVER_NOOP(cfg->hasProperty(KisImportExportFilter::ColorModelIDTag));
     KIS_SAFE_ASSERT_RECOVER_NOOP(cfg->hasProperty(KisImportExportFilter::sRGBTag));
 
     const bool isThereAlpha = cfg->getBool(KisImportExportFilter::ImageContainsTransparencyTag);
 
     alpha->setChecked(cfg->getBool("alpha", isThereAlpha));
 
     bnTransparencyFillColor->setEnabled(!alpha->isChecked());
 
     if (cfg->getString(KisImportExportFilter::ColorModelIDTag) == RGBAColorModelID.id()) {
         tryToSaveAsIndexed->setVisible(true);
         if (alpha->isChecked()) {
             tryToSaveAsIndexed->setChecked(false);
         }
         else {
             tryToSaveAsIndexed->setChecked(cfg->getBool("indexed", false));
         }
     }
     else {
         tryToSaveAsIndexed->setVisible(false);
     }
     interlacing->setChecked(cfg->getBool("interlaced", false));
     compressionLevel->setValue(cfg->getInt("compression", 3));
     compressionLevel->setRange(1, 9, 0);
 
     tryToSaveAsIndexed->setVisible(!isThereAlpha);
 
     //const bool sRGB = cfg->getBool(KisImportExportFilter::sRGBTag, false);
 
     //chkSRGB->setEnabled(sRGB);
     chkSRGB->setChecked(cfg->getBool("saveSRGBProfile", true));
 
     //chkForceSRGB->setEnabled(!sRGB);
     chkForceSRGB->setChecked(cfg->getBool("forceSRGB", false));
 
     chkAuthor->setChecked(cfg->getBool("storeAuthor", false));
     chkMetaData->setChecked(cfg->getBool("storeMetaData", false));
 
     KoColor background(KoColorSpaceRegistry::instance()->rgb8());
     background.fromQColor(Qt::white);
     bnTransparencyFillColor->setDefaultColor(background);
     bnTransparencyFillColor->setColor(cfg->getColor("transparencyFillcolor", background));
 }
 
 KisPropertiesConfigurationSP KisWdgOptionsPNG::configuration() const
 {
 
     KisPropertiesConfigurationSP cfg(new KisPropertiesConfiguration());
 
     bool alpha = this->alpha->isChecked();
     bool interlace = interlacing->isChecked();
     int compression = (int)compressionLevel->value();
     bool tryToSaveAsIndexed = this->tryToSaveAsIndexed->isChecked();
     bool saveSRGB = chkSRGB->isChecked();
     bool forceSRGB = chkForceSRGB->isChecked();
     bool storeAuthor = chkAuthor->isChecked();
     bool storeMetaData = chkMetaData->isChecked();
 
     QVariant transparencyFillcolor;
     transparencyFillcolor.setValue(bnTransparencyFillColor->color());
 
     cfg->setProperty("alpha", alpha);
     cfg->setProperty("indexed", tryToSaveAsIndexed);
     cfg->setProperty("compression", compression);
     cfg->setProperty("interlaced", interlace);
     cfg->setProperty("transparencyFillcolor", transparencyFillcolor);
     cfg->setProperty("saveSRGBProfile", saveSRGB);
     cfg->setProperty("forceSRGB", forceSRGB);
     cfg->setProperty("storeAuthor", storeAuthor);
     cfg->setProperty("storeMetaData", storeMetaData);
 
     return cfg;
 }
 
 void KisWdgOptionsPNG::on_alpha_toggled(bool checked)
 {
     bnTransparencyFillColor->setEnabled(!checked);
 }
 
 #include "kis_png_export.moc"