Relax dependency from procparams.h

rtengine/FTblockDN.cc

@@ -38,6 +38,7 @@
 #include "cplx_wavelet_dec.h"
 #include "median.h"
 #include "iccstore.h"
+#include "procparams.h"
 #ifdef _OPENMP
 #include <omp.h>
 #endif

rtengine/PF_correct_RT.cc

@@ -36,6 +36,7 @@
 #include "median.h"
 #include "jaggedarray.h"
 #include "StopWatch.h"
+#include "procparams.h"
 
 namespace rtengine
 {

rtengine/ahd_demosaic_RT.cc

@@ -27,6 +27,7 @@
 #include "rtengine.h"
 #include "rawimagesource.h"
 #include "rt_math.h"
+#include "procparams.h"
 #include "../rtgui/multilangmgr.h"
 #include "median.h"
 //#define BENCHMARK
@@ -223,4 +224,4 @@ void RawImageSource::ahd_demosaic()
 }
 #undef TS
 
-}
+}

rtengine/amaze_demosaic_RT.cc

@@ -33,6 +33,7 @@
 #include "sleef.c"
 #include "opthelper.h"
 #include "median.h"
+#include "procparams.h"
 #include "StopWatch.h"
 
 namespace rtengine

rtengine/clutstore.cc

@@ -5,6 +5,7 @@
 #include "iccstore.h"
 #include "imagefloat.h"
 #include "opthelper.h"
+#include "procparams.h"
 #include "rt_math.h"
 #include "stdimagesource.h"
 

rtengine/curves.cc

@@ -37,6 +37,7 @@
 #include "ciecam02.h"
 #include "color.h"
 #include "iccstore.h"
+#include "procparams.h"
 #undef CLIPD
 #define CLIPD(a) ((a)>0.0f?((a)<1.0f?(a):1.0f):0.0f)
 

rtengine/curves.h

@@ -30,7 +30,6 @@
 #include "../rtgui/myflatcurve.h"
 #include "../rtgui/mydiagonalcurve.h"
 #include "color.h"
-#include "procparams.h"
 #include "pipettebuffer.h"
 
 #include "LUT.h"

rtengine/dcrop.cc

@@ -17,9 +17,10 @@
  *  You should have received a copy of the GNU General Public License
  *  along with RawTherapee.  If not, see <http://www.gnu.org/licenses/>.
  */
-#include "dcrop.h"
 #include "curves.h"
+#include "dcrop.h"
 #include "mytime.h"
+#include "procparams.h"
 #include "refreshmap.h"
 #include "rt_math.h"
 
@@ -131,7 +132,7 @@ void Crop::update(int todo)
 {
     MyMutex::MyLock cropLock(cropMutex);
 
-    ProcParams& params = parent->params;
+    ProcParams& params = *parent->params;
 //       CropGUIListener* cropgl;
 
     // No need to update todo here, since it has already been changed in ImprocCoordinator::updatePreviewImage,
@@ -1116,7 +1117,7 @@ void Crop::freeAll()
 namespace
 {
 
-bool check_need_larger_crop_for_lcp_distortion(int fw, int fh, int x, int y, int w, int h, const ProcParams &params)
+bool check_need_larger_crop_for_lcp_distortion(int fw, int fh, int x, int y, int w, int h, const procparams::ProcParams &params)
 {
     if (x == 0 && y == 0 && w == fw && h == fh) {
         return false;
@@ -1177,7 +1178,7 @@ bool Crop::setCropSizes(int rcx, int rcy, int rcw, int rch, int skip, bool inter
 
     parent->ipf.transCoord(parent->fw, parent->fh, bx1, by1, bw, bh, orx, ory, orw, orh);
 
-    if (check_need_larger_crop_for_lcp_distortion(parent->fw, parent->fh, orx, ory, orw, orh, parent->params)) {
+    if (check_need_larger_crop_for_lcp_distortion(parent->fw, parent->fh, orx, ory, orw, orh, *parent->params)) {
         // TODO - this is an estimate of the max distortion relative to the image size. ATM it is hardcoded to be 15%, which seems enough. If not, need to revise
         int dW = int (double (parent->fw) * 0.15 / (2 * skip));
         int dH = int (double (parent->fh) * 0.15 / (2 * skip));

rtengine/dual_demosaic_RT.cc

@@ -27,6 +27,7 @@
 #include "rtengine.h"
 #include "rawimagesource.h"
 #include "rt_math.h"
+#include "procparams.h"
 //#define BENCHMARK
 #include "StopWatch.h"
 #include "rt_algo.h"

rtengine/gamutwarning.h

@@ -31,6 +31,8 @@
 
 namespace rtengine {
 
+enum RenderingIntent : int;
+
 class GamutWarning: public NonCopyable {
 public:
     GamutWarning(cmsHPROFILE iprof, cmsHPROFILE gamutprof, RenderingIntent intent, bool bpc);

rtengine/histmatching.cc

@@ -24,6 +24,7 @@
 #include "color.h"
 #include "rt_math.h"
 #include "iccstore.h"
+#include "procparams.h"
 #include "../rtgui/mydiagonalcurve.h"
 #include "improcfun.h"
 //#define BENCHMARK
@@ -248,7 +249,7 @@ void RawImageSource::getAutoMatchedToneCurve(const ColorManagementParams &cp, st
                     && a.dcpIlluminant == b.dcpIlluminant);
         };
 
-    if (!histMatchingCache.empty() && same_profile(histMatchingParams, cp)) {
+    if (!histMatchingCache.empty() && same_profile(*histMatchingParams, cp)) {
         if (settings->verbose) {
             std::cout << "tone curve found in cache" << std::endl;
         }
@@ -286,14 +287,14 @@ void RawImageSource::getAutoMatchedToneCurve(const ColorManagementParams &cp, st
                 std::cout << "histogram matching: no thumbnail found, generating a neutral curve" << std::endl;
             }
             histMatchingCache = outCurve;
-            histMatchingParams = cp;
+            *histMatchingParams = cp;
             return;
         } else if (w * 10 < fw) {
             if (settings->verbose) {
                 std::cout << "histogram matching: the embedded thumbnail is too small: " << w << "x" << h << std::endl;
             }
             histMatchingCache = outCurve;
-            histMatchingParams = cp;
+            *histMatchingParams = cp;
             return;
         }
         skip = LIM(skip * fh / h, 6, 10); // adjust the skip factor -- the larger the thumbnail, the less we should skip to get a good match
@@ -316,7 +317,7 @@ void RawImageSource::getAutoMatchedToneCurve(const ColorManagementParams &cp, st
                 std::cout << "histogram matching: raw decoding failed, generating a neutral curve" << std::endl;
             }
             histMatchingCache = outCurve;
-            histMatchingParams = cp;
+            *histMatchingParams = cp;
             return;
         }
         target.reset(thumb->processImage(neutral, sensor_type, fh / skip, TI_Nearest, getMetaData(), scale, false, true));
@@ -388,7 +389,7 @@ void RawImageSource::getAutoMatchedToneCurve(const ColorManagementParams &cp, st
     }
 
     histMatchingCache = outCurve;
-    histMatchingParams = cp;
+    *histMatchingParams = cp;
 }
 
 } // namespace rtengine

rtengine/hphd_demosaic_RT.cc

@@ -23,6 +23,7 @@
 #include "jaggedarray.h"
 #include "rawimage.h"
 #include "rt_math.h"
+#include "procparams.h"
 #include "../rtgui/multilangmgr.h"
 #include "opthelper.h"
 //#define BENCHMARK

rtengine/iimage.cc

@@ -17,6 +17,7 @@
  *  along with RawTherapee.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "procparams.h"
 #include "rtengine.h"
 
 const char rtengine::sImage8[] =     "Image8";

rtengine/iimage.h

@@ -26,7 +26,6 @@
 #include "imagedimensions.h"
 #include "LUT.h"
 #include "coord2d.h"
-#include "procparams.h"
 #include "color.h"
 #include "../rtgui/threadutils.h"
 
@@ -43,12 +42,21 @@
 namespace rtengine
 {
 
+namespace procparams
+{
+
+    class CoarseTransformParams;
+
+}
+
+class ProgressListener;
+class Color;
+
 extern const char sImage8[];
 extern const char sImage16[];
 extern const char sImagefloat[];
-int getCoarseBitMask( const procparams::CoarseTransformParams &coarse);
+
-class ProgressListener;
+int getCoarseBitMask(const procparams::CoarseTransformParams& coarse);
-class Color;
 
 enum TypeInterpolation { TI_Nearest, TI_Bilinear };
 

rtengine/imagedata.cc

@@ -25,6 +25,8 @@
 #include "iptcpairs.h"
 #include "imagesource.h"
 #include "rt_math.h"
+#include "procparams.h"
+
 #pragma GCC diagnostic warning "-Wextra"
 #define PRINT_HDR_PS_DETECTION 0
 

rtengine/imagedata.h

@@ -25,7 +25,6 @@
 #include <string>
 #include <glibmm.h>
 #include "../rtexif/rtexif.h"
-#include "procparams.h"
 #include <libiptcdata/iptc-data.h>
 #include "rtengine.h"
 

rtengine/imagefloat.cc

@@ -27,6 +27,7 @@
 #include "alignedbuffer.h"
 #include "rt_math.h"
 #include "color.h"
+#include "procparams.h"
 
 using namespace rtengine;
 

rtengine/imageio.cc

@@ -26,6 +26,7 @@
 #include <fcntl.h>
 #include <libiptcdata/iptc-jpeg.h>
 #include "rt_math.h"
+#include "procparams.h"
 #include "../rtgui/options.h"
 #include "../rtgui/version.h"
 
@@ -103,8 +104,8 @@ void ImageIO::setMetadata (const rtexif::TagDirectory* eroot, const rtengine::pr
 {
 
     // store exif info
-    exifChange.clear();
+    exifChange->clear();
-    exifChange = exif;
+    *exifChange = exif;
 
     if (exifRoot != nullptr) {
         delete exifRoot;
@@ -185,6 +186,22 @@ void ImageIO::setOutputProfile  (const char* pdata, int plen)
     profileLength = plen;
 }
 
+ImageIO::ImageIO() :
+    pl(nullptr),
+    embProfile(nullptr),
+    profileData(nullptr),
+    profileLength(0),
+    loadedProfileData(nullptr),
+    loadedProfileDataJpg(false),
+    loadedProfileLength(0),
+    exifChange(new procparams::ExifPairs),
+    iptc(nullptr),
+    exifRoot(nullptr),
+    sampleFormat(IIOSF_UNKNOWN),
+    sampleArrangement(IIOSA_UNKNOWN)
+{
+}
+
 ImageIO::~ImageIO ()
 {
 
@@ -1055,7 +1072,7 @@ int ImageIO::savePNG  (const Glib::ustring &fname, int bps) const
             iptcdata = nullptr;
         }
 
-        int size = rtexif::ExifManager::createPNGMarker(exifRoot, exifChange, width, height, bps, (char*)iptcdata, iptclen, buffer, bufferSize);
+        int size = rtexif::ExifManager::createPNGMarker(exifRoot, *exifChange, width, height, bps, (char*)iptcdata, iptclen, buffer, bufferSize);
 
         if (iptcdata) {
             iptc_data_free_buf (iptc, iptcdata);
@@ -1205,7 +1222,7 @@ int ImageIO::saveJPEG (const Glib::ustring &fname, int quality, int subSamp) con
 
     // assemble and write exif marker
     if (exifRoot) {
-        int size = rtexif::ExifManager::createJPEGMarker (exifRoot, exifChange, cinfo.image_width, cinfo.image_height, buffer);
+        int size = rtexif::ExifManager::createJPEGMarker (exifRoot, *exifChange, cinfo.image_width, cinfo.image_height, buffer);
 
         if (size > 0 && size < 65530) {
             jpeg_write_marker(&cinfo, JPEG_APP0 + 1, buffer, size);
@@ -1361,7 +1378,7 @@ int ImageIO::saveTIFF (const Glib::ustring &fname, int bps, bool isFloat, bool u
 
         // ------------------ Apply list of change -----------------
 
-        for (auto currExifChange : exifChange) {
+        for (auto currExifChange : *exifChange) {
             cl->applyChange (currExifChange.first, currExifChange.second);
         }
 

rtengine/imageio.h

@@ -28,11 +28,12 @@
 #define IMIO_FILETYPENOTSUPPORTED  6
 #define IMIO_CANNOTWRITEFILE       7
 
+#include <memory>
+
 #include <glibmm.h>
 #include <libiptcdata/iptc-data.h>
 #include "rtengine.h"
 #include "imageformat.h"
-#include "procparams.h"
 #include "../rtexif/rtexif.h"
 #include "imagedimensions.h"
 #include "iimage.h"
@@ -55,7 +56,7 @@ protected:
     char* loadedProfileData;
     bool loadedProfileDataJpg;
     int loadedProfileLength;
-    procparams::ExifPairs exifChange;
+    std::unique_ptr<procparams::ExifPairs> exifChange;
     IptcData* iptc;
     const rtexif::TagDirectory* exifRoot;
     MyMutex imutex;
@@ -68,11 +69,8 @@ private:
 public:
     static Glib::ustring errorMsg[6];
 
-    ImageIO () : pl (nullptr), embProfile(nullptr), profileData(nullptr), profileLength(0), loadedProfileData(nullptr), loadedProfileDataJpg(false),
+    ImageIO();
-        loadedProfileLength(0), iptc(nullptr), exifRoot (nullptr), sampleFormat(IIOSF_UNKNOWN),
+    ~ImageIO() override;
-        sampleArrangement(IIOSA_UNKNOWN) {}
-
-    ~ImageIO () override;
 
     void setProgressListener (ProgressListener* l);
     void setSampleFormat(IIOSampleFormat sFormat);

rtengine/imagesource.h

@@ -23,7 +23,6 @@
 #include <vector>
 #include "rtengine.h"
 #include "colortemp.h"
-#include "procparams.h"
 #include "coord2d.h"
 #include "dcp.h"
 #include "LUT.h"
@@ -35,7 +34,17 @@
 namespace rtengine
 {
 
-using namespace procparams;
+namespace procparams
+{
+
+struct CoarseTransformParams;
+struct ColorManagementParams;
+struct LensProfParams;
+struct RAWParams;
+struct RetinexParams;
+struct ToneCurveParams;
+
+}
 
 class ImageMatrices
 {
@@ -67,14 +76,14 @@ public:
 
     ~ImageSource            () override {}
     virtual int         load        (const Glib::ustring &fname) = 0;
-    virtual void        preprocess  (const RAWParams &raw, const LensProfParams &lensProf, const CoarseTransformParams& coarse, bool prepareDenoise = true) {};
+    virtual void        preprocess  (const procparams::RAWParams &raw, const procparams::LensProfParams &lensProf, const procparams::CoarseTransformParams& coarse, bool prepareDenoise = true) {};
-    virtual void        demosaic    (const RAWParams &raw, bool autoContrast, double &contrastThreshold) {};
+    virtual void        demosaic    (const procparams::RAWParams &raw, bool autoContrast, double &contrastThreshold) {};
-    virtual void        retinex       (const ColorManagementParams& cmp, const RetinexParams &deh, const ToneCurveParams& Tc, LUTf & cdcurve, LUTf & mapcurve, const RetinextransmissionCurve & dehatransmissionCurve, const RetinexgaintransmissionCurve & dehagaintransmissionCurve, multi_array2D<float, 4> &conversionBuffer, bool dehacontlutili, bool mapcontlutili, bool useHsl, float &minCD, float &maxCD, float &mini, float &maxi, float &Tmean, float &Tsigma, float &Tmin, float &Tmax, LUTu &histLRETI) {};
+    virtual void        retinex       (const procparams::ColorManagementParams& cmp, const procparams::RetinexParams &deh, const procparams::ToneCurveParams& Tc, LUTf & cdcurve, LUTf & mapcurve, const RetinextransmissionCurve & dehatransmissionCurve, const RetinexgaintransmissionCurve & dehagaintransmissionCurve, multi_array2D<float, 4> &conversionBuffer, bool dehacontlutili, bool mapcontlutili, bool useHsl, float &minCD, float &maxCD, float &mini, float &maxi, float &Tmean, float &Tsigma, float &Tmin, float &Tmax, LUTu &histLRETI) {};
-    virtual void        retinexPrepareCurves       (const RetinexParams &retinexParams, LUTf &cdcurve, LUTf &mapcurve, RetinextransmissionCurve &retinextransmissionCurve, RetinexgaintransmissionCurve &retinexgaintransmissionCurve, bool &retinexcontlutili, bool &mapcontlutili, bool &useHsl, LUTu & lhist16RETI, LUTu & histLRETI) {};
+    virtual void        retinexPrepareCurves       (const procparams::RetinexParams &retinexParams, LUTf &cdcurve, LUTf &mapcurve, RetinextransmissionCurve &retinextransmissionCurve, RetinexgaintransmissionCurve &retinexgaintransmissionCurve, bool &retinexcontlutili, bool &mapcontlutili, bool &useHsl, LUTu & lhist16RETI, LUTu & histLRETI) {};
-    virtual void        retinexPrepareBuffers      (const ColorManagementParams& cmp, const RetinexParams &retinexParams, multi_array2D<float, 4> &conversionBuffer, LUTu &lhist16RETI) {};
+    virtual void        retinexPrepareBuffers      (const procparams::ColorManagementParams& cmp, const procparams::RetinexParams &retinexParams, multi_array2D<float, 4> &conversionBuffer, LUTu &lhist16RETI) {};
     virtual void        flushRawData       () {};
     virtual void        flushRGB           () {};
-    virtual void        HLRecovery_Global  (const ToneCurveParams &hrp) {};
+    virtual void        HLRecovery_Global  (const procparams::ToneCurveParams &hrp) {};
     virtual void        HLRecovery_inpaint (float** red, float** green, float** blue) {};
 
     virtual bool        isRGBSourceModified () const = 0; // tracks whether cached rgb output of demosaic has been modified
@@ -86,7 +95,7 @@ public:
 
 
     // use right after demosaicing image, add coarse transformation and put the result in the provided Imagefloat*
-    virtual void        getImage    (const ColorTemp &ctemp, int tran, Imagefloat* image, const PreviewProps &pp, const ToneCurveParams &hlp, const RAWParams &raw) = 0;
+    virtual void        getImage    (const ColorTemp &ctemp, int tran, Imagefloat* image, const PreviewProps &pp, const procparams::ToneCurveParams &hlp, const RAWParams &raw) = 0;
     virtual eSensorType getSensorType () const = 0;
     virtual bool        isMono () const = 0;
     // true is ready to provide the AutoWB, i.e. when the image has been demosaiced for RawImageSource
@@ -111,7 +120,7 @@ public:
 
     virtual ImageMatrices* getImageMatrices () = 0;
     virtual bool           isRAW () const = 0;
-    virtual DCPProfile*    getDCP (const ColorManagementParams &cmp, DCPProfile::ApplyState &as)
+    virtual DCPProfile*    getDCP (const procparams::ColorManagementParams &cmp, DCPProfile::ApplyState &as)
     {
         return nullptr;
     };
@@ -140,7 +149,7 @@ public:
     }
 
     // for RAW files, compute a tone curve using histogram matching on the embedded thumbnail
-    virtual void getAutoMatchedToneCurve(const ColorManagementParams &cp, std::vector<double> &outCurve)
+    virtual void getAutoMatchedToneCurve(const procparams::ColorManagementParams &cp, std::vector<double> &outCurve)
     {
         outCurve = { 0.0 };
     }

rtengine/improccoordinator.h

@@ -19,6 +19,8 @@
 #ifndef _IMPROCCOORDINATOR_H_
 #define _IMPROCCOORDINATOR_H_
 
+#include <memory>
+
 #include "rtengine.h"
 #include "improcfun.h"
 #include "image8.h"
@@ -70,8 +72,6 @@ protected:
     double lastAwbEqual;
     double lastAwbTempBias;
 
-    ImProcFunctions ipf;
-
     Glib::ustring monitorProfile;
     RenderingIntent monitorIntent;
     bool softProof;
@@ -185,7 +185,7 @@ protected:
     void updatePreviewImage (int todo, bool panningRelatedChange);
 
     MyMutex mProcessing;
-    ProcParams params;
+    std::unique_ptr<ProcParams> params;
 
     // for optimization purpose, the output profile, output rendering intent and
     // output BPC will trigger a regeneration of the profile on parameter change only
@@ -200,7 +200,7 @@ protected:
     MyMutex paramsUpdateMutex;
     int  changeSinceLast;
     bool updaterRunning;
-    ProcParams nextParams;
+    std::unique_ptr<ProcParams> nextParams;
     bool destroying;
     bool utili;
     bool autili;
@@ -217,16 +217,16 @@ protected:
     bool highQualityComputed;
     cmsHTRANSFORM customTransformIn;
     cmsHTRANSFORM customTransformOut;
+
+    ImProcFunctions ipf;
+
 public:
 
     ImProcCoordinator ();
     ~ImProcCoordinator () override;
     void assign     (ImageSource* imgsrc);
 
-    void        getParams (procparams::ProcParams* dst) override
+    void        getParams (procparams::ProcParams* dst) override;
-    {
-        *dst = params;
-    }
 
     void        startProcessing (int changeCode) override;
     ProcParams* beginUpdateParams () override;

rtengine/improcfun.cc

@@ -41,6 +41,7 @@
 #include "clutstore.h"
 #include "ciecam02.h"
 #include "StopWatch.h"
+#include "procparams.h"
 #include "../rtgui/ppversion.h"
 #include "../rtgui/guiutils.h"
 
@@ -205,33 +206,33 @@ void proPhotoBlue(float *rtemp, float *gtemp, float *btemp, int istart, int tH,
     }
 }
 
-void customToneCurve(const ToneCurve &customToneCurve, ToneCurveParams::TcMode curveMode, float *rtemp, float *gtemp, float *btemp, int istart, int tH, int jstart, int tW, int tileSize, PerceptualToneCurveState ptcApplyState) {
+void customToneCurve(const ToneCurve &customToneCurve, ToneCurveMode curveMode, float *rtemp, float *gtemp, float *btemp, int istart, int tH, int jstart, int tW, int tileSize, PerceptualToneCurveState ptcApplyState) {
 
-    if (curveMode == ToneCurveParams::TcMode::STD) { // Standard
+    if (curveMode == ToneCurveMode::STD) { // Standard
         const StandardToneCurve& userToneCurve = static_cast<const StandardToneCurve&> (customToneCurve);
         for (int i = istart, ti = 0; i < tH; i++, ti++) {
             userToneCurve.BatchApply(0, tW - jstart, &rtemp[ti * tileSize], &gtemp[ti * tileSize], &btemp[ti * tileSize]);
         }
-    } else if (curveMode == ToneCurveParams::TcMode::FILMLIKE) { // Adobe like
+    } else if (curveMode == ToneCurveMode::FILMLIKE) { // Adobe like
         const AdobeToneCurve& userToneCurve = static_cast<const AdobeToneCurve&> (customToneCurve);
         for (int i = istart, ti = 0; i < tH; i++, ti++) {
             for (int j = jstart, tj = 0; j < tW; j++, tj++) {
                 userToneCurve.Apply(rtemp[ti * tileSize + tj], gtemp[ti * tileSize + tj], btemp[ti * tileSize + tj]);
             }
         }
-    } else if (curveMode == ToneCurveParams::TcMode::SATANDVALBLENDING) { // apply the curve on the saturation and value channels
+    } else if (curveMode == ToneCurveMode::SATANDVALBLENDING) { // apply the curve on the saturation and value channels
         const SatAndValueBlendingToneCurve& userToneCurve = static_cast<const SatAndValueBlendingToneCurve&> (customToneCurve);
         for (int i = istart, ti = 0; i < tH; i++, ti++) {
             for (int j = jstart, tj = 0; j < tW; j++, tj++) {
                 userToneCurve.Apply(rtemp[ti * tileSize + tj], gtemp[ti * tileSize + tj], btemp[ti * tileSize + tj]);
             }
         }
-    } else if (curveMode == ToneCurveParams::TcMode::WEIGHTEDSTD) { // apply the curve to the rgb channels, weighted
+    } else if (curveMode == ToneCurveMode::WEIGHTEDSTD) { // apply the curve to the rgb channels, weighted
         const WeightedStdToneCurve& userToneCurve = static_cast<const WeightedStdToneCurve&> (customToneCurve);
         for (int i = istart, ti = 0; i < tH; i++, ti++) {
             userToneCurve.BatchApply(0, tW - jstart, &rtemp[ti * tileSize], &gtemp[ti * tileSize], &btemp[ti * tileSize]);
         }
-    } else if (curveMode == ToneCurveParams::TcMode::LUMINANCE) { // apply the curve to the luminance channel
+    } else if (curveMode == ToneCurveMode::LUMINANCE) { // apply the curve to the luminance channel
         const LuminanceToneCurve& userToneCurve = static_cast<const LuminanceToneCurve&> (customToneCurve);
 
         for (int i = istart, ti = 0; i < tH; i++, ti++) {
@@ -239,7 +240,7 @@ void customToneCurve(const ToneCurve &customToneCurve, ToneCurveParams::TcMode c
                 userToneCurve.Apply(rtemp[ti * tileSize + tj], gtemp[ti * tileSize + tj], btemp[ti * tileSize + tj]);
             }
         }
-    } else if (curveMode == ToneCurveParams::TcMode::PERCEPTUAL) { // apply curve while keeping color appearance constant
+    } else if (curveMode == ToneCurveMode::PERCEPTUAL) { // apply curve while keeping color appearance constant
         const PerceptualToneCurve& userToneCurve = static_cast<const PerceptualToneCurve&> (customToneCurve);
         for (int i = istart, ti = 0; i < tH; i++, ti++) {
             userToneCurve.BatchApply(0, tW - jstart, &rtemp[ti * tileSize], &gtemp[ti * tileSize], &btemp[ti * tileSize], ptcApplyState);
@@ -322,7 +323,7 @@ void ImProcFunctions::updateColorProfiles (const Glib::ustring& monitorProfile,
                 if (settings->printerBPC) {
                     flags |= cmsFLAGS_BLACKPOINTCOMPENSATION;
                 }
-                outIntent = settings->printerIntent;
+                outIntent = RenderingIntent(settings->printerIntent);
             } else {
                 oprof = ICCStore::getInstance()->getProfile(params->icm.outputProfile);
                 if (params->icm.outputBPC) {
@@ -2225,8 +2226,8 @@ void ImProcFunctions::rgbProc (Imagefloat* working, LabImage* lab, PipetteBuffer
     const float hlrange = 65536.0 - shoulder;
     const bool isProPhoto = (params->icm.workingProfile == "ProPhoto");
     // extracting datas from 'params' to avoid cache flush (to be confirmed)
-    ToneCurveParams::TcMode curveMode = params->toneCurve.curveMode;
+    ToneCurveMode curveMode = params->toneCurve.curveMode;
-    ToneCurveParams::TcMode curveMode2 = params->toneCurve.curveMode2;
+    ToneCurveMode curveMode2 = params->toneCurve.curveMode2;
     bool highlight = params->toneCurve.hrenabled;//Get the value if "highlight reconstruction" is activated
     bool hasToneCurve1 = bool (customToneCurve1);
     bool hasToneCurve2 = bool (customToneCurve2);
@@ -2238,12 +2239,12 @@ void ImProcFunctions::rgbProc (Imagefloat* working, LabImage* lab, PipetteBuffer
 
     PerceptualToneCurveState ptc1ApplyState, ptc2ApplyState;
 
-    if (hasToneCurve1 && curveMode == ToneCurveParams::TcMode::PERCEPTUAL) {
+    if (hasToneCurve1 && curveMode == ToneCurveMode::PERCEPTUAL) {
         const PerceptualToneCurve& userToneCurve = static_cast<const PerceptualToneCurve&> (customToneCurve1);
         userToneCurve.initApplyState (ptc1ApplyState, params->icm.workingProfile);
     }
 
-    if (hasToneCurve2 && curveMode2 == ToneCurveParams::TcMode::PERCEPTUAL) {
+    if (hasToneCurve2 && curveMode2 == ToneCurveMode::PERCEPTUAL) {
         const PerceptualToneCurve& userToneCurve = static_cast<const PerceptualToneCurve&> (customToneCurve2);
         userToneCurve.initApplyState (ptc2ApplyState, params->icm.workingProfile);
     }

rtengine/improcfun.h

@@ -22,7 +22,6 @@
 #include "imagefloat.h"
 #include "image16.h"
 #include "image8.h"
-#include "procparams.h"
 #include "shmap.h"
 #include "coord2d.h"
 #include "color.h"
@@ -39,12 +38,22 @@
 namespace rtengine
 {
 
-using namespace procparams;
+namespace procparams
+{
+
+class ProcParams;
+
+struct DirPyrDenoiseParams;
+struct SharpeningParams;
+struct VignettingParams;
+struct WaveletParams;
+
+}
+
+enum RenderingIntent : int;
 
 class ImProcFunctions
 {
-
-
     cmsHTRANSFORM monitorTransform;
     std::unique_ptr<GamutWarning> gamutWarning;
 
@@ -52,7 +61,7 @@ class ImProcFunctions
     double scale;
     bool multiThread;
 
-    void calcVignettingParams(int oW, int oH, const VignettingParams& vignetting, double &w2, double &h2, double& maxRadius, double &v, double &b, double &mul);
+    void calcVignettingParams(int oW, int oH, const procparams::VignettingParams& vignetting, double &w2, double &h2, double& maxRadius, double &v, double &b, double &mul);
 
     void transformLuminanceOnly(Imagefloat* original, Imagefloat* transformed, int cx, int cy, int oW, int oH, int fW, int fH);
     void transformGeneral(bool highQuality, Imagefloat *original, Imagefloat *transformed, int cx, int cy, int sx, int sy, int oW, int oH, int fW, int fH, const LensCorrection *pLCPMap);
@@ -203,7 +212,7 @@ public:
     bool needsTransform();
     bool needsPCVignetting();
 
-    void firstAnalysis(const Imagefloat* const working, const ProcParams &params, LUTu & vhist16);
+    void firstAnalysis(const Imagefloat* const working, const procparams::ProcParams &params, LUTu & vhist16);
     void updateColorProfiles(const Glib::ustring& monitorProfile, RenderingIntent monitorIntent, bool softProof, bool gamutCheck);
     void rgbProc(Imagefloat* working, LabImage* lab, PipetteBuffer *pipetteBuffer, LUTf & hltonecurve, LUTf & shtonecurve, LUTf & tonecurve,
                            int sat, LUTf & rCurve, LUTf & gCurve, LUTf & bCurve, float satLimit, float satLimitOpacity, const ColorGradientCurve & ctColorCurve, const OpacityCurve & ctOpacityCurve, bool opautili, LUTf & clcurve, LUTf & cl2curve, const ToneCurve & customToneCurve1, const ToneCurve & customToneCurve2,
@@ -230,7 +239,7 @@ public:
     void chromiLuminanceCurve(PipetteBuffer *pipetteBuffer, int pW, LabImage* lold, LabImage* lnew, LUTf &acurve, LUTf &bcurve, LUTf & satcurve, LUTf & satclcurve, LUTf &clcurve, LUTf &curve, bool utili, bool autili, bool butili, bool ccutili, bool cclutili, bool clcutili, LUTu &histCCurve, LUTu &histLurve);
     void vibrance(LabImage* lab);         //Jacques' vibrance
 //    void colorCurve       (LabImage* lold, LabImage* lnew);
-    void sharpening(LabImage* lab, const SharpeningParams &sharpenParam, bool showMask = false);
+    void sharpening(LabImage* lab, const procparams::SharpeningParams &sharpenParam, bool showMask = false);
     void sharpeningcam(CieImage* ncie, float** buffer, bool showMask = false);
     void transform(Imagefloat* original, Imagefloat* transformed, int cx, int cy, int sx, int sy, int oW, int oH, int fW, int fH, const FramesMetaData *metadata, int rawRotationDeg, bool fullImage);
     float resizeScale(const ProcParams* params, int fw, int fh, int &imw, int &imh);
@@ -239,7 +248,7 @@ public:
     void Lanczos(const LabImage* src, LabImage* dst, float scale);
     void Lanczos(const Imagefloat* src, Imagefloat* dst, float scale);
 
-    void deconvsharpening(float** luminance, float** buffer, int W, int H, const SharpeningParams &sharpenParam);
+    void deconvsharpening(float** luminance, float** buffer, int W, int H, const procparams::SharpeningParams &sharpenParam);
     void MLsharpen(LabImage* lab); // Manuel's clarity / sharpening
     void MLmicrocontrast(float** luminance, int W, int H);   //Manuel's microcontrast
     void MLmicrocontrast(LabImage* lab);   //Manuel's microcontrast
@@ -262,7 +271,7 @@ public:
     void EPDToneMapCIE(CieImage *ncie, float a_w, float c_, int Wid, int Hei, float minQ, float maxQ, unsigned int Iterates = 0, int skip = 1);
 
     // pyramid denoise
-    procparams::DirPyrDenoiseParams dnparams;
+//    procparams::DirPyrDenoiseParams dnparams;
     void dirpyr(LabImage* data_fine, LabImage* data_coarse, int level, LUTf &rangefn_L, LUTf &rangefn_ab,
                 int pitch, int scale, const int luma, int chroma);
     void idirpyr(LabImage* data_coarse, LabImage* data_fine, int level, LUTf &rangefn_L, LUTf & nrwt_l, LUTf & nrwt_ab,

rtengine/init.cc

@@ -32,6 +32,7 @@
 #include "profilestore.h"
 #include "../rtgui/threadutils.h"
 #include "rtlensfun.h"
+#include "procparams.h"
 
 namespace rtengine
 {

rtengine/ipdehaze.cc

@@ -28,13 +28,15 @@
  *
  */  
 
-#include "improcfun.h"
-#include "guidedfilter.h"
-#include "rt_math.h"
-#include "rt_algo.h"
 #include <iostream>
 #include <queue>
 
+#include "guidedfilter.h"
+#include "improcfun.h"
+#include "procparams.h"
+#include "rt_algo.h"
+#include "rt_math.h"
+
 extern Options options;
 
 namespace rtengine {

rtengine/iplab2rgb.cc

@@ -26,6 +26,8 @@
 #include "curves.h"
 #include "alignedbuffer.h"
 #include "color.h"
+#include "procparams.h"
+
 namespace rtengine
 {
 

rtengine/iplabregions.cc

@@ -24,6 +24,7 @@
 
 #include "improcfun.h"
 #include "guidedfilter.h"
+#include "procparams.h"
 //#define BENCHMARK
 #include "StopWatch.h"
 #include "sleef.c"

rtengine/iplocalcontrast.cc

@@ -26,9 +26,10 @@
 #include <omp.h>
 #endif
 
-#include "improcfun.h"
-#include "gauss.h"
 #include "array2D.h"
+#include "gauss.h"
+#include "improcfun.h"
+#include "procparams.h"
 
 namespace rtengine {
 

rtengine/ipresize.cc

@@ -22,6 +22,7 @@
 #include "alignedbuffer.h"
 #include "opthelper.h"
 #include "rt_math.h"
+#include "procparams.h"
 #include "sleef.c"
 
 //#define PROFILE

rtengine/ipretinex.cc

@@ -36,16 +36,18 @@
 
 */
 
-#include <cstdlib>
-#include <cstdio>
 #include <cmath>
+#include <cstdio>
+#include <cstdlib>
 #include <cstring>
-#include "rtengine.h"
+
 #include "gauss.h"
-#include "rawimagesource.h"
 #include "improcfun.h"
-#include "opthelper.h"
 #include "median.h"
+#include "opthelper.h"
+#include "procparams.h"
+#include "rawimagesource.h"
+#include "rtengine.h"
 #include "StopWatch.h"
 
 #define clipretinex( val, minv, maxv )    (( val = (val < minv ? minv : val ) ) > maxv ? maxv : val )

rtengine/ipshadowshighlights.cc

@@ -19,10 +19,12 @@
  */
 
 #include "improcfun.h"
+
 #include "gauss.h"
-#include "sleef.c"
-#include "opthelper.h"
 #include "guidedfilter.h"
+#include "opthelper.h"
+#include "procparams.h"
+#include "sleef.c"
 
 namespace rtengine {
 

rtengine/ipsharpen.cc

@@ -22,6 +22,7 @@
 #include "bilateral2.h"
 #include "jaggedarray.h"
 #include "rt_math.h"
+#include "procparams.h"
 #include "sleef.c"
 #include "opthelper.h"
 //#define BENCHMARK

rtengine/ipsoftlight.cc

@@ -24,6 +24,8 @@
 
 #include "improcfun.h"
 
+#include "procparams.h"
+
 namespace rtengine {
 
 namespace {

rtengine/iptransform.cc

@@ -18,6 +18,7 @@
  */
 #include "rtengine.h"
 #include "improcfun.h"
+#include "procparams.h"
 #ifdef _OPENMP
 #include <omp.h>
 #endif

rtengine/ipwavelet.cc

@@ -40,6 +40,7 @@
 #include "median.h"
 #include "EdgePreservingDecomposition.h"
 #include "iccstore.h"
+#include "procparams.h"
 
 #ifdef _OPENMP
 #include <omp.h>

rtengine/lcp.cc

@@ -29,6 +29,7 @@
 
 #include "lcp.h"
 
+#include "procparams.h"
 #include "settings.h"
 
 namespace rtengine

rtengine/previewimage.cc

@@ -18,11 +18,13 @@
  */
 
 #include "previewimage.h"
+
 #include "iimage.h"
-#include "utils.h"
 #include "iimage.h"
-#include "rtthumbnail.h"
+#include "procparams.h"
 #include "rawimagesource.h"
+#include "rtthumbnail.h"
+#include "utils.h"
 
 using namespace rtengine;
 using namespace procparams;

rtengine/processingjob.h

@@ -20,6 +20,7 @@
 #define _PROCESSINGJOB_
 
 #include "rtengine.h"
+#include "procparams.h"
 
 namespace rtengine
 {

rtengine/procparams.cc

@@ -315,8 +315,8 @@ ToneCurveParams::ToneCurveParams() :
     curve2{
         DCT_Linear
     },
-    curveMode(ToneCurveParams::TcMode::STD),
+    curveMode(ToneCurveMode::STD),
-    curveMode2(ToneCurveParams::TcMode::STD),
+    curveMode2(ToneCurveMode::STD),
     brightness(0),
     black(0),
     contrast(0),
@@ -2875,13 +2875,13 @@ int ProcParams::save(const Glib::ustring& fname, const Glib::ustring& fname2, bo
         saveToKeyfile(!pedited || pedited->toneCurve.hrenabled, "HLRecovery", "Enabled", toneCurve.hrenabled, keyFile);
         saveToKeyfile(!pedited || pedited->toneCurve.method, "HLRecovery", "Method", toneCurve.method, keyFile);
 
-        const std::map<ToneCurveParams::TcMode, const char*> tc_mapping = {
+        const std::map<ToneCurveMode, const char*> tc_mapping = {
-            {ToneCurveParams::TcMode::STD, "Standard"},
+            {ToneCurveMode::STD, "Standard"},
-            {ToneCurveParams::TcMode::FILMLIKE, "FilmLike"},
+            {ToneCurveMode::FILMLIKE, "FilmLike"},
-            {ToneCurveParams::TcMode::SATANDVALBLENDING, "SatAndValueBlending"},
+            {ToneCurveMode::SATANDVALBLENDING, "SatAndValueBlending"},
-            {ToneCurveParams::TcMode::WEIGHTEDSTD, "WeightedStd"},
+            {ToneCurveMode::WEIGHTEDSTD, "WeightedStd"},
-            {ToneCurveParams::TcMode::LUMINANCE, "Luminance"},
+            {ToneCurveMode::LUMINANCE, "Luminance"},
-            {ToneCurveParams::TcMode::PERCEPTUAL, "Perceptual"}
+            {ToneCurveMode::PERCEPTUAL, "Perceptual"}
         };
 
         saveToKeyfile(!pedited || pedited->toneCurve.curveMode, "Exposure", "CurveMode", tc_mapping, toneCurve.curveMode, keyFile);
@@ -3659,13 +3659,13 @@ int ProcParams::load(const Glib::ustring& fname, ParamsEdited* pedited)
                 toneCurve.shcompr = 100; // older pp3 files can have values above 100.
             }
 
-            const std::map<std::string, ToneCurveParams::TcMode> tc_mapping = {
+            const std::map<std::string, ToneCurveMode> tc_mapping = {
-                {"Standard", ToneCurveParams::TcMode::STD},
+                {"Standard", ToneCurveMode::STD},
-                {"FilmLike", ToneCurveParams::TcMode::FILMLIKE},
+                {"FilmLike", ToneCurveMode::FILMLIKE},
-                {"SatAndValueBlending", ToneCurveParams::TcMode::SATANDVALBLENDING},
+                {"SatAndValueBlending", ToneCurveMode::SATANDVALBLENDING},
-                {"WeightedStd", ToneCurveParams::TcMode::WEIGHTEDSTD},
+                {"WeightedStd", ToneCurveMode::WEIGHTEDSTD},
-                {"Luminance", ToneCurveParams::TcMode::LUMINANCE},
+                {"Luminance", ToneCurveMode::LUMINANCE},
-                {"Perceptual", ToneCurveParams::TcMode::PERCEPTUAL}
+                {"Perceptual", ToneCurveMode::PERCEPTUAL}
             };
 
             assignFromKeyfile(keyFile, "Exposure", "CurveMode", pedited, tc_mapping, toneCurve.curveMode, pedited->toneCurve.curveMode);

rtengine/procparams.h

@@ -44,7 +44,7 @@ class WavOpacityCurveRG;
 class WavOpacityCurveW;
 class WavOpacityCurveWL;
 
-enum RenderingIntent {
+enum RenderingIntent : int {
     RI_PERCEPTUAL = INTENT_PERCEPTUAL,
     RI_RELATIVE = INTENT_RELATIVE_COLORIMETRIC,
     RI_SATURATION = INTENT_SATURATION,
@@ -249,35 +249,35 @@ private:
     bool is_double;
 };
 
+enum class ToneCurveMode : int {
+    STD,               // Standard modes, the curve is applied on all component individually
+    WEIGHTEDSTD,       // Weighted standard mode
+    FILMLIKE,          // Film-like mode, as defined in Adobe's reference code
+    SATANDVALBLENDING, // Modify the Saturation and Value channel
+    LUMINANCE,         // Modify the Luminance channel with coefficients from Rec 709's
+    PERCEPTUAL         // Keep color appearance constant using perceptual modeling
+};
+
 /**
   * Parameters of the tone curve
   */
 struct ToneCurveParams {
-    enum class TcMode {
+    bool autoexp;
-        STD,               // Standard modes, the curve is applied on all component individually
+    double clip;
-        WEIGHTEDSTD,       // Weighted standard mode
+    bool hrenabled; // Highlight Reconstruction enabled
-        FILMLIKE,          // Film-like mode, as defined in Adobe's reference code
+    Glib::ustring method; // Highlight Reconstruction's method
-        SATANDVALBLENDING, // Modify the Saturation and Value channel
+    double expcomp;
-        LUMINANCE,         // Modify the Luminance channel with coefficients from Rec 709's
+    std::vector<double> curve;
-        PERCEPTUAL         // Keep color appearance constant using perceptual modeling
+    std::vector<double> curve2;
-    };
+    ToneCurveMode curveMode;
-
+    ToneCurveMode curveMode2;
-    bool        autoexp;
+    int brightness;
-    double      clip;
+    int black;
-    bool        hrenabled;  // Highlight Reconstruction enabled
+    int contrast;
-    Glib::ustring method;   // Highlight Reconstruction's method
+    int saturation;
-    double      expcomp;
+    int shcompr;
-    std::vector<double>   curve;
+    int hlcompr; // Highlight Recovery's compression
-    std::vector<double>   curve2;
+    int hlcomprthresh; // Highlight Recovery's threshold
-    TcMode   curveMode;
-    TcMode   curveMode2;
-    int         brightness;
-    int         black;
-    int         contrast;
-    int         saturation;
-    int         shcompr;
-    int         hlcompr;        // Highlight Recovery's compression
-    int         hlcomprthresh;  // Highlight Recovery's threshold
     bool histmatching; // histogram matching
     bool fromHistMatching;
     bool clampOOG; // clamp out of gamut colours
@@ -1076,14 +1076,89 @@ struct MetaDataParams {
 
 
 /**
-  * Typedef for representing a key/value for the exif metadata information
+  * Minimal wrapper allowing forward declaration for representing a key/value for the exif metadata information
   */
-typedef std::map<Glib::ustring, Glib::ustring> ExifPairs;
+class ExifPairs final
+{
+public:
+    using const_iterator = std::map<Glib::ustring, Glib::ustring>::const_iterator;
+
+    const_iterator begin() const
+    {
+        return pairs.begin();
+    }
+
+    const_iterator end() const
+    {
+        return pairs.end();
+    }
+
+    void clear()
+    {
+        pairs.clear();
+    }
+
+    Glib::ustring& operator[](const Glib::ustring& key)
+    {
+        return pairs[key];
+    }
+
+    bool operator ==(const ExifPairs& other) const
+    {
+        return pairs == other.pairs;
+    }
+
+private:
+    std::map<Glib::ustring, Glib::ustring> pairs;
+};
 
 /**
   * The IPTC key/value pairs
   */
-typedef std::map<Glib::ustring, std::vector<Glib::ustring>> IPTCPairs;
+class IPTCPairs final
+{
+public:
+    using iterator = std::map<Glib::ustring, std::vector<Glib::ustring>>::iterator;
+    using const_iterator = std::map<Glib::ustring, std::vector<Glib::ustring>>::const_iterator;
+
+    iterator find(const Glib::ustring& key)
+    {
+        return pairs.find(key);
+    }
+
+    const_iterator begin() const
+    {
+        return pairs.begin();
+    }
+
+    const_iterator end() const
+    {
+        return pairs.end();
+    }
+
+    bool empty() const
+    {
+        return pairs.empty();
+    }
+
+    void clear()
+    {
+        pairs.clear();
+    }
+
+    std::vector<Glib::ustring>& operator[](const Glib::ustring& key)
+    {
+        return pairs[key];
+    }
+
+    bool operator ==(const IPTCPairs& other) const
+    {
+        return pairs == other.pairs;
+    }
+
+private:
+    std::map<Glib::ustring, std::vector<Glib::ustring>> pairs;
+};
 
 struct WaveletParams {
     std::vector<double> ccwcurve;

rtengine/profilestore.cc

@@ -19,6 +19,8 @@
 #include "profilestore.h"
 
 #include "dynamicprofile.h"
+#include "procparams.h"
+
 #include "../rtgui/options.h"
 #include "../rtgui/multilangmgr.h"
 

rtengine/profilestore.h

@@ -27,8 +27,20 @@
 #include "noncopyable.h"
 #include "dynamicprofile.h"
 
-
 // forward decl
+namespace rtengine
+{
+
+namespace procparams
+{
+
+class AutoPartialProfile;
+class PartialProfile;
+
+}
+
+}
+
 class DynamicProfileRule;
 class DynamicProfileRules;
 

rtengine/rawimagesource.cc

@@ -36,6 +36,7 @@
 #include "rtlensfun.h"
 #include "pdaflinesfilter.h"
 #include "camconst.h"
+#include "procparams.h"
 #ifdef _OPENMP
 #include <omp.h>
 #endif
@@ -452,6 +453,7 @@ RawImageSource::RawImageSource ()
     , red(0, 0)
     , blue(0, 0)
     , rawDirty(true)
+    , histMatchingParams(new procparams::ColorManagementParams)
 {
     camProfile = nullptr;
     embProfile = nullptr;

rtengine/rawimagesource.h

@@ -19,13 +19,16 @@
 #ifndef _RAWIMAGESOURCE_
 #define _RAWIMAGESOURCE_
 
-#include "imagesource.h"
-#include "dcp.h"
-#include "array2D.h"
-#include "curves.h"
-#include "color.h"
-#include "iimage.h"
 #include <iostream>
+#include <memory>
+
+#include "array2D.h"
+#include "color.h"
+#include "curves.h"
+#include "dcp.h"
+#include "iimage.h"
+#include "imagesource.h"
+
 #define HR_SCALE 2
 
 namespace rtengine
@@ -39,7 +42,7 @@ private:
     static DiagonalCurve *phaseOneIccCurveInv;
     static LUTf invGrad;  // for fast_demosaic
     static LUTf initInvGrad ();
-    static void colorSpaceConversion_ (Imagefloat* im, const ColorManagementParams& cmp, const ColorTemp &wb, double pre_mul[3], cmsHPROFILE embedded, cmsHPROFILE camprofile, double cam[3][3], const std::string &camName);
+    static void colorSpaceConversion_ (Imagefloat* im, const procparams::ColorManagementParams& cmp, const ColorTemp &wb, double pre_mul[3], cmsHPROFILE embedded, cmsHPROFILE camprofile, double cam[3][3], const std::string &camName);
     int  defTransform        (int tran);
 
 protected:
@@ -91,7 +94,7 @@ protected:
     float psBlueBrightness[4];
 
     std::vector<double> histMatchingCache;
-    ColorManagementParams histMatchingParams;
+    std::unique_ptr<procparams::ColorManagementParams> histMatchingParams;
 
     void processFalseColorCorrectionThread (Imagefloat* im, array2D<float> &rbconv_Y, array2D<float> &rbconv_I, array2D<float> &rbconv_Q, array2D<float> &rbout_I, array2D<float> &rbout_Q, const int row_from, const int row_to);
     void hlRecovery          (const std::string &method, float* red, float* green, float* blue, int width, float* hlmax);
@@ -112,14 +115,14 @@ public:
 
     int load(const Glib::ustring &fname) override { return load(fname, false); }
     int load(const Glib::ustring &fname, bool firstFrameOnly);
-    void        preprocess  (const RAWParams &raw, const LensProfParams &lensProf, const CoarseTransformParams& coarse, bool prepareDenoise = true) override;
+    void        preprocess  (const procparams::RAWParams &raw, const procparams::LensProfParams &lensProf, const procparams::CoarseTransformParams& coarse, bool prepareDenoise = true) override;
-    void        demosaic    (const RAWParams &raw, bool autoContrast, double &contrastThreshold) override;
+    void        demosaic    (const procparams::RAWParams &raw, bool autoContrast, double &contrastThreshold) override;
-    void        retinex       (const ColorManagementParams& cmp, const RetinexParams &deh, const ToneCurveParams& Tc, LUTf & cdcurve, LUTf & mapcurve, const RetinextransmissionCurve & dehatransmissionCurve, const RetinexgaintransmissionCurve & dehagaintransmissionCurve, multi_array2D<float, 4> &conversionBuffer, bool dehacontlutili, bool mapcontlutili, bool useHsl, float &minCD, float &maxCD, float &mini, float &maxi, float &Tmean, float &Tsigma, float &Tmin, float &Tmax, LUTu &histLRETI) override;
+    void        retinex       (const procparams::ColorManagementParams& cmp, const procparams::RetinexParams &deh, const procparams::ToneCurveParams& Tc, LUTf & cdcurve, LUTf & mapcurve, const RetinextransmissionCurve & dehatransmissionCurve, const RetinexgaintransmissionCurve & dehagaintransmissionCurve, multi_array2D<float, 4> &conversionBuffer, bool dehacontlutili, bool mapcontlutili, bool useHsl, float &minCD, float &maxCD, float &mini, float &maxi, float &Tmean, float &Tsigma, float &Tmin, float &Tmax, LUTu &histLRETI) override;
-    void        retinexPrepareCurves       (const RetinexParams &retinexParams, LUTf &cdcurve, LUTf &mapcurve, RetinextransmissionCurve &retinextransmissionCurve, RetinexgaintransmissionCurve &retinexgaintransmissionCurve, bool &retinexcontlutili, bool &mapcontlutili, bool &useHsl, LUTu & lhist16RETI, LUTu & histLRETI) override;
+    void        retinexPrepareCurves       (const procparams::RetinexParams &retinexParams, LUTf &cdcurve, LUTf &mapcurve, RetinextransmissionCurve &retinextransmissionCurve, RetinexgaintransmissionCurve &retinexgaintransmissionCurve, bool &retinexcontlutili, bool &mapcontlutili, bool &useHsl, LUTu & lhist16RETI, LUTu & histLRETI) override;
-    void        retinexPrepareBuffers      (const ColorManagementParams& cmp, const RetinexParams &retinexParams, multi_array2D<float, 4> &conversionBuffer, LUTu &lhist16RETI) override;
+    void        retinexPrepareBuffers      (const procparams::ColorManagementParams& cmp, const procparams::RetinexParams &retinexParams, multi_array2D<float, 4> &conversionBuffer, LUTu &lhist16RETI) override;
     void        flushRawData      () override;
     void        flushRGB          () override;
-    void        HLRecovery_Global (const ToneCurveParams &hrp) override;
+    void        HLRecovery_Global (const procparams::ToneCurveParams &hrp) override;
     void        refinement_lassus (int PassCount);
     void        refinement(int PassCount);
     void        setBorder(unsigned int rawBorder) override {border = rawBorder;}
@@ -133,7 +136,7 @@ public:
     void        cfaboxblur  (RawImage *riFlatFile, float* cfablur, int boxH, int boxW);
     void        scaleColors (int winx, int winy, int winw, int winh, const RAWParams &raw, array2D<float> &rawData); // raw for cblack
 
-    void        getImage    (const ColorTemp &ctemp, int tran, Imagefloat* image, const PreviewProps &pp, const ToneCurveParams &hrp, const RAWParams &raw) override;
+    void        getImage    (const ColorTemp &ctemp, int tran, Imagefloat* image, const PreviewProps &pp, const procparams::ToneCurveParams &hrp, const procparams::RAWParams &raw) override;
     eSensorType getSensorType () const override
     {
         return ri != nullptr ? ri->getSensorType() : ST_NONE;
@@ -180,10 +183,10 @@ public:
     }
     void        getAutoExpHistogram (LUTu & histogram, int& histcompr) override;
     void        getRAWHistogram (LUTu & histRedRaw, LUTu & histGreenRaw, LUTu & histBlueRaw) override;
-    void getAutoMatchedToneCurve(const ColorManagementParams &cp, std::vector<double> &outCurve) override;
+    void getAutoMatchedToneCurve(const procparams::ColorManagementParams &cp, std::vector<double> &outCurve) override;
-    DCPProfile *getDCP(const ColorManagementParams &cmp, DCPProfile::ApplyState &as) override;
+    DCPProfile *getDCP(const procparams::ColorManagementParams &cmp, DCPProfile::ApplyState &as) override;
 
-    void convertColorSpace(Imagefloat* image, const ColorManagementParams &cmp, const ColorTemp &wb) override;
+    void convertColorSpace(Imagefloat* image, const procparams::ColorManagementParams &cmp, const ColorTemp &wb) override;
     static bool findInputProfile(Glib::ustring inProfile, cmsHPROFILE embedded, std::string camName, DCPProfile **dcpProf, cmsHPROFILE& in);
     static void colorSpaceConversion   (Imagefloat* im, const ColorManagementParams& cmp, const ColorTemp &wb, double pre_mul[3], cmsHPROFILE embedded, cmsHPROFILE camprofile, double cam[3][3], const std::string &camName)
     {

rtengine/rcd_demosaic.cc

@@ -20,6 +20,7 @@
 
 #include "rawimagesource.h"
 #include "rt_math.h"
+#include "procparams.h"
 #include "../rtgui/multilangmgr.h"
 #include "opthelper.h"
 #include "StopWatch.h"

rtengine/rtengine.h

@@ -21,7 +21,6 @@
 
 #include "imageformat.h"
 #include "rt_math.h"
-#include "procparams.h"
 #include "procevents.h"
 #include <lcms2.h>
 #include <string>
@@ -45,6 +44,22 @@ class EditDataProvider;
 namespace rtengine
 {
 
+enum RenderingIntent : int;
+
+namespace procparams
+{
+
+class ProcParams;
+class IPTCPairs;
+
+struct RAWParams;
+struct ColorManagementParams;
+struct CropParams;
+
+enum class ToneCurveMode : int;
+
+}
+
 class IImage8;
 class IImage16;
 class IImagefloat;
@@ -315,7 +330,7 @@ public:
       * @param hlrecons set to true if HighLight Reconstruction is enabled */
     virtual void autoExpChanged(double brightness, int bright, int contrast, int black, int hlcompr, int hlcomprthresh, bool hlrecons) = 0;
 
-    virtual void autoMatchedToneCurveChanged(procparams::ToneCurveParams::TcMode curveMode, const std::vector<double>& curve) = 0;
+    virtual void autoMatchedToneCurveChanged(procparams::ToneCurveMode curveMode, const std::vector<double>& curve) = 0;
 };
 
 class AutoCamListener

rtengine/rtlensfun.cc

@@ -19,6 +19,7 @@
  */
 
 #include "rtlensfun.h"
+#include "procparams.h"
 #include "settings.h"
 #include <iostream>
 

rtengine/rtlensfun.h

@@ -29,10 +29,16 @@
 
 #include "lcp.h"
 #include "noncopyable.h"
-#include "procparams.h"
 
 namespace rtengine {
 
+namespace procparams
+{
+
+struct LensProfParams;
+
+}
+
 class LFModifier final :
     public LensCorrection,
     public NonCopyable
@@ -113,7 +119,7 @@ public:
     LFCamera findCamera(const Glib::ustring &make, const Glib::ustring &model) const;
     LFLens findLens(const LFCamera &camera, const Glib::ustring &name) const;
 
-    static std::unique_ptr<LFModifier> findModifier(const LensProfParams &lensProf, const FramesMetaData *idata, int width, int height, const CoarseTransformParams &coarse, int rawRotationDeg);
+    static std::unique_ptr<LFModifier> findModifier(const procparams::LensProfParams &lensProf, const FramesMetaData *idata, int width, int height, const CoarseTransformParams &coarse, int rawRotationDeg);
 
 private:
     std::unique_ptr<LFModifier> getModifier(const LFCamera &camera, const LFLens &lens,

rtengine/rtthumbnail.cc

@@ -37,6 +37,7 @@
 #include "../rtgui/ppversion.h"
 #include "improccoordinator.h"
 #include "settings.h"
+#include "procparams.h"
 #include <locale.h>
 #include "StopWatch.h"
 #include "median.h"
@@ -1220,7 +1221,7 @@ IImage8* Thumbnail::processImage (const procparams::ProcParams& params, eSensorT
 
     ImProcFunctions ipf (&params, forHistogramMatching); // enable multithreading when forHistogramMatching is true
     ipf.setScale (sqrt (double (fw * fw + fh * fh)) / sqrt (double (thumbImg->getWidth() * thumbImg->getWidth() + thumbImg->getHeight() * thumbImg->getHeight()))*scale);
-    ipf.updateColorProfiles (ICCStore::getInstance()->getDefaultMonitorProfileName(), options.rtSettings.monitorIntent, false, false);
+    ipf.updateColorProfiles (ICCStore::getInstance()->getDefaultMonitorProfileName(), RenderingIntent(options.rtSettings.monitorIntent), false, false);
 
     LUTu hist16 (65536);
 

rtengine/rtthumbnail.h

@@ -20,7 +20,6 @@
 #define _THUMBPROCESSINGPARAMETERS_
 
 #include "rawmetadatalocation.h"
-#include "procparams.h"
 #include <glibmm.h>
 #include <lcms2.h>
 #include "image8.h"

rtengine/settings.h

@@ -19,8 +19,6 @@
 #ifndef _RTSETTINGS_
 #define _RTSETTINGS_
 
-#include "procparams.h"
-
 namespace rtengine
 {
 
@@ -39,10 +37,10 @@ public:
     int             leveldnautsimpl;        // STD or EXPERT
 
     Glib::ustring   printerProfile;         ///< ICC profile name used for soft-proofing a printer output
-    RenderingIntent printerIntent;          ///< Colorimetric intent used with the above profile
+    int             printerIntent;          ///< Colorimetric intent used with the above profile
     bool            printerBPC;             ///< Black Point Compensation for the Labimage->Printer->Monitor transform
     Glib::ustring   monitorProfile;         ///< ICC profile name used for the monitor
-    RenderingIntent monitorIntent;          ///< Colorimetric intent used with the above profile
+    int             monitorIntent;          ///< Colorimetric intent used with the above profile
     bool            monitorBPC;             ///< Black Point Compensation for the Labimage->Monitor transform (directly, i.e. not soft-proofing and no WCS in between)
     bool            autoMonitorProfile;     ///< Try to auto-determine the correct monitor color profile
     bool            autocielab;

rtengine/simpleprocess.cc

@@ -24,6 +24,7 @@
 #include "iccstore.h"
 #include "clutstore.h"
 #include "processingjob.h"
+#include "procparams.h"
 #include <glibmm.h>
 #include "../rtgui/options.h"
 #include "rawimagesource.h"
@@ -768,7 +769,7 @@ private:
             }
 
             params.toneCurve.autoexp = false;
-            params.toneCurve.curveMode = ToneCurveParams::TcMode::FILMLIKE;
+            params.toneCurve.curveMode = ToneCurveMode::FILMLIKE;
             params.toneCurve.curve2 = { 0 };
             params.toneCurve.brightness = 0;
             params.toneCurve.contrast = 0;

rtengine/stdimagesource.cc

@@ -17,11 +17,13 @@
  *  along with RawTherapee.  If not, see <http://www.gnu.org/licenses/>.
  */
 #include "stdimagesource.h"
-#include "mytime.h"
+
+#include "color.h"
+#include "curves.h"
 #include "iccstore.h"
 #include "imageio.h"
-#include "curves.h"
+#include "mytime.h"
-#include "color.h"
+#include "procparams.h"
 
 #undef THREAD_PRIORITY_NORMAL
 

rtengine/tmo_fattal02.cc

@@ -74,6 +74,7 @@
 #include "opthelper.h"
 #include "rt_algo.h"
 #include "rescale.h"
+#include "procparams.h"
 
 namespace rtengine
 {

rtengine/vng4_demosaic_RT.cc

@@ -22,6 +22,7 @@
 
 #include "rtengine.h"
 #include "rawimagesource.h"
+#include "procparams.h"
 #include "../rtgui/multilangmgr.h"
 //#define BENCHMARK
 #include "StopWatch.h"

rtexif/rtexif.cc

@@ -32,6 +32,8 @@
 
 #include "rtexif.h"
 
+#include "../rtengine/procparams.h"
+
 #include "../rtgui/cacheimagedata.h"
 #include "../rtgui/version.h"
 #include "../rtgui/ppversion.h"

rtexif/rtexif.h

@@ -32,10 +32,19 @@
 
 #include <glibmm.h>
 
-#include "../rtengine/procparams.h"
 #include "../rtengine/noncopyable.h"
 #include "../rtengine/rawmetadatalocation.h"
 
+namespace rtengine
+{
+
+namespace procparams
+{
+    class ExifPairs;
+}
+
+}
+
 class CacheImageData;
 
 namespace rtexif

rtgui/batchqueue.cc

@@ -197,7 +197,7 @@ void BatchQueue::addEntries (const std::vector<BatchQueueEntry*>& entries, bool
             // recovery save
             const auto tempFile = getTempFilenameForParams (entry->filename);
 
-            if (!entry->params.save (tempFile))
+            if (!entry->params->save (tempFile))
                 entry->savedParamsFile = tempFile;
 
             entry->selected = false;
@@ -642,7 +642,7 @@ void BatchQueue::error(const Glib::ustring& descr)
         bqbs->setButtonListener (this);
         processing->addButtonSet (bqbs);
         processing->processing = false;
-        processing->job = rtengine::ProcessingJob::create(processing->filename, processing->thumbnail->getType() == FT_Raw, processing->params);
+        processing->job = rtengine::ProcessingJob::create(processing->filename, processing->thumbnail->getType() == FT_Raw, *processing->params);
         processing = nullptr;
         redraw ();
     }
@@ -706,7 +706,7 @@ rtengine::ProcessingJob* BatchQueue::imageReady(rtengine::IImagefloat* img)
             // We keep the extension to avoid overwriting the profile when we have
             // the same output filename with different extension
             //processing->params.save (removeExtension(fname) + paramFileExtension);
-            processing->params.save (fname + ".out" + paramFileExtension);
+            processing->params->save (fname + ".out" + paramFileExtension);
         }
 
         if (processing->thumbnail) {

rtgui/batchqueueentry.cc

@@ -26,6 +26,8 @@
 #include "multilangmgr.h"
 #include "thumbbrowserbase.h"
 
+#include "../rtengine/procparams.h"
+
 bool BatchQueueEntry::iconsLoaded(false);
 Glib::RefPtr<Gdk::Pixbuf> BatchQueueEntry::savedAsIcon;
 
@@ -36,7 +38,7 @@ BatchQueueEntry::BatchQueueEntry (rtengine::ProcessingJob* pjob, const rtengine:
     origph(prevh),
     opreviewDone(false),
     job(pjob),
-    params(pparams),
+    params(new rtengine::procparams::ProcParams(pparams)),
     progress(0),
     outFileName(""),
     sequence(0),
@@ -93,7 +95,7 @@ void BatchQueueEntry::refreshThumbnailImage ()
         // creating the image buffer first
         //if (!opreview) opreview = new guint8[(origpw+1) * origph * 3];
         // this will asynchronously compute the original preview and land at this.updateImage
-        batchQueueEntryUpdater.process (nullptr, origpw, origph, preh, this, &params, thumbnail);
+        batchQueueEntryUpdater.process (nullptr, origpw, origph, preh, this, params.get(), thumbnail);
     } else {
         // this will asynchronously land at this.updateImage
         batchQueueEntryUpdater.process (opreview, origpw, origph, preh, this);

rtgui/batchqueueentry.h

@@ -19,6 +19,8 @@
 #ifndef _BATCHQUEUEENTRY_
 #define _BATCHQUEUEENTRY_
 
+#include <memory>
+
 #include <gtkmm.h>
 #include "../rtengine/rtengine.h"
 #include "thumbbrowserentrybase.h"
@@ -46,7 +48,7 @@ public:
     static Glib::RefPtr<Gdk::Pixbuf> savedAsIcon;
 
     rtengine::ProcessingJob* job;
-    rtengine::procparams::ProcParams params;
+    std::unique_ptr<rtengine::procparams::ProcParams> params;
     Glib::ustring savedParamsFile;
     double progress;
     Glib::ustring outFileName;

rtgui/cacheimagedata.cc

@@ -22,6 +22,8 @@
 #include "version.h"
 #include <locale.h>
 
+#include "../rtengine/procparams.h"
+
 CacheImageData::CacheImageData ()
     : md5(""), supported(false), format(FT_Invalid), rankOld(-1), inTrashOld(false), recentlySaved(false),
       timeValid(false), year(0), month(0), day(0), hour(0), min(0), sec(0), exifValid(false), frameCount(1),
@@ -301,3 +303,7 @@ int CacheImageData::save (const Glib::ustring& fname)
     }
 }
 
+rtengine::procparams::IPTCPairs CacheImageData::getIPTCData(unsigned int frame) const
+{
+    return {};
+}

rtgui/cacheimagedata.h

@@ -94,7 +94,7 @@ public:
     rtexif::TagDirectory* getFrameExifData (unsigned int frame = 0) const override { return nullptr; }
     rtexif::TagDirectory* getBestExifData (rtengine::ImageSource *imgSource, rtengine::procparams::RAWParams *rawParams) const override { return nullptr; }
     bool hasIPTC (unsigned int frame = 0) const override { return false; }
-    rtengine::procparams::IPTCPairs getIPTCData (unsigned int frame = 0) const override { return rtengine::procparams::IPTCPairs(); }
+    rtengine::procparams::IPTCPairs getIPTCData (unsigned int frame = 0) const override;
     tm getDateTime (unsigned int frame = 0) const override { return tm{}; }
     time_t getDateTimeAsTS(unsigned int frame = 0) const override { return time_t(-1); }
     int getISOSpeed (unsigned int frame = 0) const override { return iso; }

rtgui/crophandler.cc

@@ -23,13 +23,17 @@
 #include "guiutils.h"
 #include "cropwindow.h"
 #include "imagearea.h"
+
 #include "../rtengine/dcrop.h"
+#include "../rtengine/procparams.h"
 #include "../rtengine/refreshmap.h"
 #include "../rtengine/rt_math.h"
 
 using namespace rtengine;
 
 CropHandler::CropHandler() :
+    cropParams(new procparams::CropParams),
+    colorParams(new procparams::ColorManagementParams),
     zoom(100),
     ww(0),
     wh(0),
@@ -123,8 +127,8 @@ bool CropHandler::isFullDisplay ()
 
 double CropHandler::getFitCropZoom ()
 {
-    double z1 = (double) wh / cropParams.h;
+    double z1 = (double) wh / cropParams->h;
-    double z2 = (double) ww / cropParams.w;
+    double z2 = (double) ww / cropParams->w;
     return z1 < z2 ? z1 : z2;
 }
 
@@ -312,8 +316,8 @@ void CropHandler::setDetailedCrop(
 
     cimg.lock ();
 
-    cropParams = cp;
+    *cropParams = cp;
-    colorParams = cmp;
+    *colorParams = cmp;
 
     if (!cropimg.empty()) {
         cropimg.clear();

rtgui/crophandler.h

@@ -21,6 +21,7 @@
 
 #include <atomic>
 #include <vector>
+#include <memory>
 
 #include <gtkmm.h>
 
@@ -105,8 +106,8 @@ public:
     void    update  ();
 
 
-    rtengine::procparams::CropParams cropParams;
+    std::unique_ptr<rtengine::procparams::CropParams> cropParams;
-    rtengine::procparams::ColorManagementParams colorParams;
+    std::unique_ptr<rtengine::procparams::ColorManagementParams> colorParams;
     Glib::RefPtr<Gdk::Pixbuf> cropPixbuf;     // image displayed on monitor, using the monitor profile (i.e. lab to monitor profile)
     Glib::RefPtr<Gdk::Pixbuf> cropPixbuftrue; // internal image in output color space for analysis (i.e. lab to either Working profile or Output profile, depending on options.rtSettings.HistogramWorking)
 

rtgui/cropwindow.cc

@@ -16,21 +16,22 @@
  *  You should have received a copy of the GNU General Public License
  *  along with RawTherapee.  If not, see <http://www.gnu.org/licenses/>.
  */
-#include "cropwindow.h"
-
 #include <iomanip>
 
-#include "../rtengine/mytime.h"
+#include "cropwindow.h"
-#include "../rtengine/rt_math.h"
-#include "../rtengine/dcrop.h"
 
-#include "guiutils.h"
-#include "threadutils.h"
-#include "rtimage.h"
 #include "cursormanager.h"
-#include "options.h"
+#include "guiutils.h"
 #include "imagearea.h"
 #include "lockablecolorpicker.h"
+#include "options.h"
+#include "rtimage.h"
+#include "threadutils.h"
+
+#include "../rtengine/dcrop.h"
+#include "../rtengine/mytime.h"
+#include "../rtengine/procparams.h"
+#include "../rtengine/rt_math.h"
 
 using namespace rtengine;
 
@@ -352,8 +353,8 @@ void CropWindow::buttonPress (int button, int type, int bstate, int x, int y)
             } else {
                 if (onArea (CropImage, x, y)) {  // events inside of the image domain
                     crop_custom_ratio = 0.f;
-                    if ((bstate & GDK_SHIFT_MASK) && cropHandler.cropParams.w > 0 && cropHandler.cropParams.h > 0) {
+                    if ((bstate & GDK_SHIFT_MASK) && cropHandler.cropParams->w > 0 && cropHandler.cropParams->h > 0) {
-                        crop_custom_ratio = float(cropHandler.cropParams.w) / float(cropHandler.cropParams.h);
+                        crop_custom_ratio = float(cropHandler.cropParams->w) / float(cropHandler.cropParams->h);
                     }
 
                     if (iarea->getToolMode () == TMColorPicker) {
@@ -373,7 +374,7 @@ void CropWindow::buttonPress (int button, int type, int bstate, int x, int y)
                             // Add a new Color Picker
                             rtengine::Coord imgPos;
                             screenCoordToImage(x, y, imgPos.x, imgPos.y);
-                            LockableColorPicker *newPicker = new LockableColorPicker(this, &cropHandler.colorParams.outputProfile, &cropHandler.colorParams.workingProfile);
+                            LockableColorPicker *newPicker = new LockableColorPicker(this, &cropHandler.colorParams->outputProfile, &cropHandler.colorParams->workingProfile);
                             colorPickers.push_back(newPicker);
                             hoveredPicker = newPicker;
                             updateHoveredPicker(&imgPos);
@@ -387,49 +388,49 @@ void CropWindow::buttonPress (int button, int type, int bstate, int x, int y)
                     } else if (onArea (CropTopLeft, x, y)) {
                         state = SResizeTL;
                         press_x = x;
-                        action_x = cropHandler.cropParams.x;
+                        action_x = cropHandler.cropParams->x;
                         press_y = y;
-                        action_y = cropHandler.cropParams.y;
+                        action_y = cropHandler.cropParams->y;
                     } else if (onArea (CropTopRight, x, y)) {
                         state = SResizeTR;
                         press_x = x;
-                        action_x = cropHandler.cropParams.w;
+                        action_x = cropHandler.cropParams->w;
                         press_y = y;
-                        action_y = cropHandler.cropParams.y;
+                        action_y = cropHandler.cropParams->y;
                     } else if (onArea (CropBottomLeft, x, y)) {
                         state = SResizeBL;
                         press_x = x;
-                        action_x = cropHandler.cropParams.x;
+                        action_x = cropHandler.cropParams->x;
                         press_y = y;
-                        action_y = cropHandler.cropParams.h;
+                        action_y = cropHandler.cropParams->h;
                     } else if (onArea (CropBottomRight, x, y)) {
                         state = SResizeBR;
                         press_x = x;
-                        action_x = cropHandler.cropParams.w;
+                        action_x = cropHandler.cropParams->w;
                         press_y = y;
-                        action_y = cropHandler.cropParams.h;
+                        action_y = cropHandler.cropParams->h;
                     } else if (onArea (CropTop, x, y)) {
                         state = SResizeH1;
                         press_y = y;
-                        action_y = cropHandler.cropParams.y;
+                        action_y = cropHandler.cropParams->y;
                     } else if (onArea (CropBottom, x, y)) {
                         state = SResizeH2;
                         press_y = y;
-                        action_y = cropHandler.cropParams.h;
+                        action_y = cropHandler.cropParams->h;
                     } else if (onArea (CropLeft, x, y)) {
                         state = SResizeW1;
                         press_x = x;
-                        action_x = cropHandler.cropParams.x;
+                        action_x = cropHandler.cropParams->x;
                     } else if (onArea (CropRight, x, y)) {
                         state = SResizeW2;
                         press_x = x;
-                        action_x = cropHandler.cropParams.w;
+                        action_x = cropHandler.cropParams->w;
                     } else if ((bstate & GDK_SHIFT_MASK) && onArea (CropInside, x, y)) {
                         state = SCropMove;
                         press_x = x;
                         press_y = y;
-                        action_x = cropHandler.cropParams.x;
+                        action_x = cropHandler.cropParams->x;
-                        action_y = cropHandler.cropParams.y;
+                        action_y = cropHandler.cropParams->y;
                     } else if (onArea (CropObserved, x, y)) {
                         state = SObservedMove;
                         press_x = x;
@@ -450,11 +451,11 @@ void CropWindow::buttonPress (int button, int type, int bstate, int x, int y)
                     } else if (iarea->getToolMode () == TMCropSelect && cropgl) {
                         state = SCropSelecting;
                         screenCoordToImage (x, y, press_x, press_y);
-                        cropHandler.cropParams.enabled = true;
+                        cropHandler.cropParams->enabled = true;
-                        cropHandler.cropParams.x = press_x;
+                        cropHandler.cropParams->x = press_x;
-                        cropHandler.cropParams.y = press_y;
+                        cropHandler.cropParams->y = press_y;
-                        cropHandler.cropParams.w = cropHandler.cropParams.h = 1;
+                        cropHandler.cropParams->w = cropHandler.cropParams->h = 1;
-                        cropgl->cropInit (cropHandler.cropParams.x, cropHandler.cropParams.y, cropHandler.cropParams.w, cropHandler.cropParams.h);
+                        cropgl->cropInit (cropHandler.cropParams->x, cropHandler.cropParams->y, cropHandler.cropParams->w, cropHandler.cropParams->h);
                     } else if (iarea->getToolMode () == TMHand) {
                         if (editSubscriber) {
                             if ((cropgl && cropgl->inImageArea(iarea->posImage.x, iarea->posImage.y) && (editSubscriber->getEditingType() == ET_PIPETTE && (bstate & GDK_CONTROL_MASK))) || editSubscriber->getEditingType() == ET_OBJECTS) {
@@ -827,57 +828,57 @@ void CropWindow::pointerMoved (int bstate, int x, int y)
         action_y = y;
         iarea->redraw ();
     } else if (state == SResizeH1 && cropgl) {
-        int oy = cropHandler.cropParams.y;
+        int oy = cropHandler.cropParams->y;
-        cropHandler.cropParams.y = action_y + (y - press_y) / zoomSteps[cropZoom].zoom;
+        cropHandler.cropParams->y = action_y + (y - press_y) / zoomSteps[cropZoom].zoom;
-        cropHandler.cropParams.h += oy - cropHandler.cropParams.y;
+        cropHandler.cropParams->h += oy - cropHandler.cropParams->y;
-        cropgl->cropHeight1Resized (cropHandler.cropParams.x, cropHandler.cropParams.y, cropHandler.cropParams.w, cropHandler.cropParams.h, crop_custom_ratio);
+        cropgl->cropHeight1Resized (cropHandler.cropParams->x, cropHandler.cropParams->y, cropHandler.cropParams->w, cropHandler.cropParams->h, crop_custom_ratio);
         iarea->redraw ();
     } else if (state == SResizeH2 && cropgl) {
-        cropHandler.cropParams.h = action_y + (y - press_y) / zoomSteps[cropZoom].zoom;
+        cropHandler.cropParams->h = action_y + (y - press_y) / zoomSteps[cropZoom].zoom;
-        cropgl->cropHeight2Resized (cropHandler.cropParams.x, cropHandler.cropParams.y, cropHandler.cropParams.w, cropHandler.cropParams.h, crop_custom_ratio);
+        cropgl->cropHeight2Resized (cropHandler.cropParams->x, cropHandler.cropParams->y, cropHandler.cropParams->w, cropHandler.cropParams->h, crop_custom_ratio);
         iarea->redraw ();
     } else if (state == SResizeW1 && cropgl) {
-        int ox = cropHandler.cropParams.x;
+        int ox = cropHandler.cropParams->x;
-        cropHandler.cropParams.x = action_x + (x - press_x) / zoomSteps[cropZoom].zoom;
+        cropHandler.cropParams->x = action_x + (x - press_x) / zoomSteps[cropZoom].zoom;
-        cropHandler.cropParams.w += ox - cropHandler.cropParams.x;
+        cropHandler.cropParams->w += ox - cropHandler.cropParams->x;
-        cropgl->cropWidth1Resized (cropHandler.cropParams.x, cropHandler.cropParams.y, cropHandler.cropParams.w, cropHandler.cropParams.h, crop_custom_ratio);
+        cropgl->cropWidth1Resized (cropHandler.cropParams->x, cropHandler.cropParams->y, cropHandler.cropParams->w, cropHandler.cropParams->h, crop_custom_ratio);
         iarea->redraw ();
     } else if (state == SResizeW2 && cropgl) {
-        cropHandler.cropParams.w = action_x + (x - press_x) / zoomSteps[cropZoom].zoom;
+        cropHandler.cropParams->w = action_x + (x - press_x) / zoomSteps[cropZoom].zoom;
-        cropgl->cropWidth2Resized (cropHandler.cropParams.x, cropHandler.cropParams.y, cropHandler.cropParams.w, cropHandler.cropParams.h, crop_custom_ratio);
+        cropgl->cropWidth2Resized (cropHandler.cropParams->x, cropHandler.cropParams->y, cropHandler.cropParams->w, cropHandler.cropParams->h, crop_custom_ratio);
         iarea->redraw ();
     } else if (state == SResizeTL && cropgl) {
-        int ox = cropHandler.cropParams.x;
+        int ox = cropHandler.cropParams->x;
-        cropHandler.cropParams.x = action_x + (x - press_x) / zoomSteps[cropZoom].zoom;
+        cropHandler.cropParams->x = action_x + (x - press_x) / zoomSteps[cropZoom].zoom;
-        cropHandler.cropParams.w += ox - cropHandler.cropParams.x;
+        cropHandler.cropParams->w += ox - cropHandler.cropParams->x;
-        int oy = cropHandler.cropParams.y;
+        int oy = cropHandler.cropParams->y;
-        cropHandler.cropParams.y = action_y + (y - press_y) / zoomSteps[cropZoom].zoom;
+        cropHandler.cropParams->y = action_y + (y - press_y) / zoomSteps[cropZoom].zoom;
-        cropHandler.cropParams.h += oy - cropHandler.cropParams.y;
+        cropHandler.cropParams->h += oy - cropHandler.cropParams->y;
-        cropgl->cropTopLeftResized (cropHandler.cropParams.x, cropHandler.cropParams.y, cropHandler.cropParams.w, cropHandler.cropParams.h, crop_custom_ratio);
+        cropgl->cropTopLeftResized (cropHandler.cropParams->x, cropHandler.cropParams->y, cropHandler.cropParams->w, cropHandler.cropParams->h, crop_custom_ratio);
         iarea->redraw ();
     } else if (state == SResizeTR && cropgl) {
-        cropHandler.cropParams.w = action_x + (x - press_x) / zoomSteps[cropZoom].zoom;
+        cropHandler.cropParams->w = action_x + (x - press_x) / zoomSteps[cropZoom].zoom;
-        int oy = cropHandler.cropParams.y;
+        int oy = cropHandler.cropParams->y;
-        cropHandler.cropParams.y = action_y + (y - press_y) / zoomSteps[cropZoom].zoom;
+        cropHandler.cropParams->y = action_y + (y - press_y) / zoomSteps[cropZoom].zoom;
-        cropHandler.cropParams.h += oy - cropHandler.cropParams.y;
+        cropHandler.cropParams->h += oy - cropHandler.cropParams->y;
-        cropgl->cropTopRightResized (cropHandler.cropParams.x, cropHandler.cropParams.y, cropHandler.cropParams.w, cropHandler.cropParams.h, crop_custom_ratio);
+        cropgl->cropTopRightResized (cropHandler.cropParams->x, cropHandler.cropParams->y, cropHandler.cropParams->w, cropHandler.cropParams->h, crop_custom_ratio);
         iarea->redraw ();
     } else if (state == SResizeBL && cropgl) {
-        int ox = cropHandler.cropParams.x;
+        int ox = cropHandler.cropParams->x;
-        cropHandler.cropParams.x = action_x + (x - press_x) / zoomSteps[cropZoom].zoom;
+        cropHandler.cropParams->x = action_x + (x - press_x) / zoomSteps[cropZoom].zoom;
-        cropHandler.cropParams.w += ox - cropHandler.cropParams.x;
+        cropHandler.cropParams->w += ox - cropHandler.cropParams->x;
-        cropHandler.cropParams.h = action_y + (y - press_y) / zoomSteps[cropZoom].zoom;
+        cropHandler.cropParams->h = action_y + (y - press_y) / zoomSteps[cropZoom].zoom;
-        cropgl->cropBottomLeftResized (cropHandler.cropParams.x, cropHandler.cropParams.y, cropHandler.cropParams.w, cropHandler.cropParams.h, crop_custom_ratio);
+        cropgl->cropBottomLeftResized (cropHandler.cropParams->x, cropHandler.cropParams->y, cropHandler.cropParams->w, cropHandler.cropParams->h, crop_custom_ratio);
         iarea->redraw ();
     } else if (state == SResizeBR && cropgl) {
-        cropHandler.cropParams.w = action_x + (x - press_x) / zoomSteps[cropZoom].zoom;
+        cropHandler.cropParams->w = action_x + (x - press_x) / zoomSteps[cropZoom].zoom;
-        cropHandler.cropParams.h = action_y + (y - press_y) / zoomSteps[cropZoom].zoom;
+        cropHandler.cropParams->h = action_y + (y - press_y) / zoomSteps[cropZoom].zoom;
-        cropgl->cropBottomRightResized (cropHandler.cropParams.x, cropHandler.cropParams.y, cropHandler.cropParams.w, cropHandler.cropParams.h, crop_custom_ratio);
+        cropgl->cropBottomRightResized (cropHandler.cropParams->x, cropHandler.cropParams->y, cropHandler.cropParams->w, cropHandler.cropParams->h, crop_custom_ratio);
         iarea->redraw ();
     } else if (state == SCropMove && cropgl) {
-        cropHandler.cropParams.x = action_x + (x - press_x) / zoomSteps[cropZoom].zoom;
+        cropHandler.cropParams->x = action_x + (x - press_x) / zoomSteps[cropZoom].zoom;
-        cropHandler.cropParams.y = action_y + (y - press_y) / zoomSteps[cropZoom].zoom;
+        cropHandler.cropParams->y = action_y + (y - press_y) / zoomSteps[cropZoom].zoom;
-        cropgl->cropMoved (cropHandler.cropParams.x, cropHandler.cropParams.y, cropHandler.cropParams.w, cropHandler.cropParams.h);
+        cropgl->cropMoved (cropHandler.cropParams->x, cropHandler.cropParams->y, cropHandler.cropParams->w, cropHandler.cropParams->h);
         iarea->redraw ();
     } else if (state == SCropSelecting && cropgl) {
         screenCoordToImage (x, y, action_x, action_y);
@@ -886,19 +887,19 @@ void CropWindow::pointerMoved (int bstate, int x, int y)
         cropgl->cropResized (cx1, cy1, cx2, cy2);
 
         if (cx2 > cx1) {
-            cropHandler.cropParams.x = cx1;
+            cropHandler.cropParams->x = cx1;
-            cropHandler.cropParams.w = cx2 - cx1 + 1;
+            cropHandler.cropParams->w = cx2 - cx1 + 1;
         } else {
-            cropHandler.cropParams.x = cx2;
+            cropHandler.cropParams->x = cx2;
-            cropHandler.cropParams.w = cx1 - cx2 + 1;
+            cropHandler.cropParams->w = cx1 - cx2 + 1;
         }
 
         if (cy2 > cy1) {
-            cropHandler.cropParams.y = cy1;
+            cropHandler.cropParams->y = cy1;
-            cropHandler.cropParams.h = cy2 - cy1 + 1;
+            cropHandler.cropParams->h = cy2 - cy1 + 1;
         } else {
-            cropHandler.cropParams.y = cy2;
+            cropHandler.cropParams->y = cy2;
-            cropHandler.cropParams.h = cy1 - cy2 + 1;
+            cropHandler.cropParams->h = cy1 - cy2 + 1;
         }
 
         iarea->redraw ();
@@ -1018,17 +1019,17 @@ void CropWindow::pointerMoved (int bstate, int x, int y)
 
         if (!onArea (CropImage, x, y) || !cropHandler.cropPixbuftrue) {
             cropHandler.getFullImageSize(mx, my);
-            //    pmlistener->pointerMoved (false, cropHandler.colorParams.working, mx, my, -1, -1, -1);
+            //    pmlistener->pointerMoved (false, cropHandler.colorParams->working, mx, my, -1, -1, -1);
-            //   if (pmhlistener) pmhlistener->pointerMoved (false, cropHandler.colorParams.working, mx, my, -1, -1, -1);
+            //   if (pmhlistener) pmhlistener->pointerMoved (false, cropHandler.colorParams->working, mx, my, -1, -1, -1);
             /*    Glib::ustring outputProfile;
-                outputProfile =cropHandler.colorParams.output ;
+                outputProfile =cropHandler.colorParams->output ;
                 printf("Using \"%s\" output\n", outputProfile.c_str());
                 if(outputProfile==options.rtSettings.srgb) printf("OK SRGB2");
             */
-            pmlistener->pointerMoved (false, cropHandler.colorParams.outputProfile, cropHandler.colorParams.workingProfile, mx, my, -1, -1, -1);
+            pmlistener->pointerMoved (false, cropHandler.colorParams->outputProfile, cropHandler.colorParams->workingProfile, mx, my, -1, -1, -1);
 
             if (pmhlistener) {
-                pmhlistener->pointerMoved (false, cropHandler.colorParams.outputProfile, cropHandler.colorParams.workingProfile, mx, my, -1, -1, -1);
+                pmhlistener->pointerMoved (false, cropHandler.colorParams->outputProfile, cropHandler.colorParams->workingProfile, mx, my, -1, -1, -1);
             }
 
         } else {
@@ -1075,11 +1076,11 @@ void CropWindow::pointerMoved (int bstate, int x, int y)
 
                 // Updates the Navigator
                 // TODO: possible double color conversion if rval, gval, bval come from cropHandler.cropPixbuftrue ? see issue #4583
-                pmlistener->pointerMoved (true, cropHandler.colorParams.outputProfile, cropHandler.colorParams.workingProfile, mx, my, rval, gval, bval, isRaw);
+                pmlistener->pointerMoved (true, cropHandler.colorParams->outputProfile, cropHandler.colorParams->workingProfile, mx, my, rval, gval, bval, isRaw);
 
                 if (pmhlistener) {
                     // Updates the HistogramRGBArea
-                    pmhlistener->pointerMoved (true, cropHandler.colorParams.outputProfile, cropHandler.colorParams.workingProfile, mx, my, rval, gval, bval);
+                    pmhlistener->pointerMoved (true, cropHandler.colorParams->outputProfile, cropHandler.colorParams->workingProfile, mx, my, rval, gval, bval);
                 }
             }
         }
@@ -1119,87 +1120,87 @@ bool CropWindow::onArea (CursorArea a, int x, int y)
 
     case CropTopLeft:
         screenCoordToImage (x, y, x1, y1);
-        return cropHandler.cropParams.enabled &&
+        return cropHandler.cropParams->enabled &&
-               y1 >= cropHandler.cropParams.y - CROPRESIZEBORDER &&
+               y1 >= cropHandler.cropParams->y - CROPRESIZEBORDER &&
-               y1 <= cropHandler.cropParams.y + CROPRESIZEBORDER &&
+               y1 <= cropHandler.cropParams->y + CROPRESIZEBORDER &&
                y >= ypos + imgY &&
-               x1 >= cropHandler.cropParams.x - CROPRESIZEBORDER &&
+               x1 >= cropHandler.cropParams->x - CROPRESIZEBORDER &&
-               x1 <= cropHandler.cropParams.x + CROPRESIZEBORDER &&
+               x1 <= cropHandler.cropParams->x + CROPRESIZEBORDER &&
                x >= xpos + imgX;
 
     case CropTopRight:
         screenCoordToImage (x, y, x1, y1);
-        return cropHandler.cropParams.enabled &&
+        return cropHandler.cropParams->enabled &&
-               y1 >= cropHandler.cropParams.y - CROPRESIZEBORDER &&
+               y1 >= cropHandler.cropParams->y - CROPRESIZEBORDER &&
-               y1 <= cropHandler.cropParams.y + CROPRESIZEBORDER &&
+               y1 <= cropHandler.cropParams->y + CROPRESIZEBORDER &&
                y >= ypos + imgY &&
-               x1 >= cropHandler.cropParams.x + cropHandler.cropParams.w - 1 - CROPRESIZEBORDER &&
+               x1 >= cropHandler.cropParams->x + cropHandler.cropParams->w - 1 - CROPRESIZEBORDER &&
-               x1 <= cropHandler.cropParams.x + cropHandler.cropParams.w - 1 + CROPRESIZEBORDER &&
+               x1 <= cropHandler.cropParams->x + cropHandler.cropParams->w - 1 + CROPRESIZEBORDER &&
                x < xpos + imgX + imgW;
 
     case CropBottomLeft:
         screenCoordToImage (x, y, x1, y1);
-        return cropHandler.cropParams.enabled &&
+        return cropHandler.cropParams->enabled &&
-               y1 >= cropHandler.cropParams.y + cropHandler.cropParams.h - 1 - CROPRESIZEBORDER &&
+               y1 >= cropHandler.cropParams->y + cropHandler.cropParams->h - 1 - CROPRESIZEBORDER &&
-               y1 <= cropHandler.cropParams.y + cropHandler.cropParams.h - 1 + CROPRESIZEBORDER &&
+               y1 <= cropHandler.cropParams->y + cropHandler.cropParams->h - 1 + CROPRESIZEBORDER &&
                y < ypos + imgY + imgH &&
-               x1 >= cropHandler.cropParams.x - CROPRESIZEBORDER &&
+               x1 >= cropHandler.cropParams->x - CROPRESIZEBORDER &&
-               x1 <= cropHandler.cropParams.x + CROPRESIZEBORDER &&
+               x1 <= cropHandler.cropParams->x + CROPRESIZEBORDER &&
                x >= xpos + imgX;
 
     case CropBottomRight:
         screenCoordToImage (x, y, x1, y1);
-        return cropHandler.cropParams.enabled &&
+        return cropHandler.cropParams->enabled &&
-               y1 >= cropHandler.cropParams.y + cropHandler.cropParams.h - 1 - CROPRESIZEBORDER &&
+               y1 >= cropHandler.cropParams->y + cropHandler.cropParams->h - 1 - CROPRESIZEBORDER &&
-               y1 <= cropHandler.cropParams.y + cropHandler.cropParams.h - 1 + CROPRESIZEBORDER &&
+               y1 <= cropHandler.cropParams->y + cropHandler.cropParams->h - 1 + CROPRESIZEBORDER &&
                y < ypos + imgY + imgH &&
-               x1 >= cropHandler.cropParams.x + cropHandler.cropParams.w - 1 - CROPRESIZEBORDER &&
+               x1 >= cropHandler.cropParams->x + cropHandler.cropParams->w - 1 - CROPRESIZEBORDER &&
-               x1 <= cropHandler.cropParams.x + cropHandler.cropParams.w - 1 + CROPRESIZEBORDER &&
+               x1 <= cropHandler.cropParams->x + cropHandler.cropParams->w - 1 + CROPRESIZEBORDER &&
                x < xpos + imgX + imgW;
 
     case CropTop:
         screenCoordToImage (x, y, x1, y1);
-        return cropHandler.cropParams.enabled &&
+        return cropHandler.cropParams->enabled &&
-               x1 > cropHandler.cropParams.x + CROPRESIZEBORDER &&
+               x1 > cropHandler.cropParams->x + CROPRESIZEBORDER &&
-               x1 < cropHandler.cropParams.x + cropHandler.cropParams.w - 1 - CROPRESIZEBORDER &&
+               x1 < cropHandler.cropParams->x + cropHandler.cropParams->w - 1 - CROPRESIZEBORDER &&
-               y1 > cropHandler.cropParams.y - CROPRESIZEBORDER &&
+               y1 > cropHandler.cropParams->y - CROPRESIZEBORDER &&
-               y1 < cropHandler.cropParams.y + CROPRESIZEBORDER &&
+               y1 < cropHandler.cropParams->y + CROPRESIZEBORDER &&
                y >= ypos + imgY;
 
     case CropBottom:
         screenCoordToImage (x, y, x1, y1);
-        return cropHandler.cropParams.enabled &&
+        return cropHandler.cropParams->enabled &&
-               x1 > cropHandler.cropParams.x + CROPRESIZEBORDER &&
+               x1 > cropHandler.cropParams->x + CROPRESIZEBORDER &&
-               x1 < cropHandler.cropParams.x + cropHandler.cropParams.w - 1 - CROPRESIZEBORDER &&
+               x1 < cropHandler.cropParams->x + cropHandler.cropParams->w - 1 - CROPRESIZEBORDER &&
-               y1 > cropHandler.cropParams.y + cropHandler.cropParams.h - 1 - CROPRESIZEBORDER &&
+               y1 > cropHandler.cropParams->y + cropHandler.cropParams->h - 1 - CROPRESIZEBORDER &&
-               y1 < cropHandler.cropParams.y + cropHandler.cropParams.h - 1 + CROPRESIZEBORDER &&
+               y1 < cropHandler.cropParams->y + cropHandler.cropParams->h - 1 + CROPRESIZEBORDER &&
                y < ypos + imgY + imgH;
 
     case CropLeft:
         screenCoordToImage (x, y, x1, y1);
-        return cropHandler.cropParams.enabled &&
+        return cropHandler.cropParams->enabled &&
-               y1 > cropHandler.cropParams.y + CROPRESIZEBORDER &&
+               y1 > cropHandler.cropParams->y + CROPRESIZEBORDER &&
-               y1 < cropHandler.cropParams.y + cropHandler.cropParams.h - 1 - CROPRESIZEBORDER &&
+               y1 < cropHandler.cropParams->y + cropHandler.cropParams->h - 1 - CROPRESIZEBORDER &&
-               x1 > cropHandler.cropParams.x - CROPRESIZEBORDER &&
+               x1 > cropHandler.cropParams->x - CROPRESIZEBORDER &&
-               x1 < cropHandler.cropParams.x + CROPRESIZEBORDER &&
+               x1 < cropHandler.cropParams->x + CROPRESIZEBORDER &&
                x >= xpos + imgX;
 
     case CropRight:
         screenCoordToImage (x, y, x1, y1);
-        return cropHandler.cropParams.enabled &&
+        return cropHandler.cropParams->enabled &&
-               y1 > cropHandler.cropParams.y + CROPRESIZEBORDER &&
+               y1 > cropHandler.cropParams->y + CROPRESIZEBORDER &&
-               y1 < cropHandler.cropParams.y + cropHandler.cropParams.h - 1 - CROPRESIZEBORDER &&
+               y1 < cropHandler.cropParams->y + cropHandler.cropParams->h - 1 - CROPRESIZEBORDER &&
-               x1 > cropHandler.cropParams.x + cropHandler.cropParams.w - 1 - CROPRESIZEBORDER &&
+               x1 > cropHandler.cropParams->x + cropHandler.cropParams->w - 1 - CROPRESIZEBORDER &&
-               x1 < cropHandler.cropParams.x + cropHandler.cropParams.w - 1 + CROPRESIZEBORDER &&
+               x1 < cropHandler.cropParams->x + cropHandler.cropParams->w - 1 + CROPRESIZEBORDER &&
                x < xpos + imgX + imgW;
 
     case CropInside:
         screenCoordToImage (x, y, x1, y1);
-        return cropHandler.cropParams.enabled &&
+        return cropHandler.cropParams->enabled &&
-               y1 > cropHandler.cropParams.y &&
+               y1 > cropHandler.cropParams->y &&
-               y1 < cropHandler.cropParams.y + cropHandler.cropParams.h - 1 &&
+               y1 < cropHandler.cropParams->y + cropHandler.cropParams->h - 1 &&
-               x1 > cropHandler.cropParams.x &&
+               x1 > cropHandler.cropParams->x &&
-               x1 < cropHandler.cropParams.x + cropHandler.cropParams.w - 1;
+               x1 < cropHandler.cropParams->x + cropHandler.cropParams->w - 1;
 
     case CropResize:
         return decorated && x >= xpos + width - 16 && y >= ypos + height - 16 && x < xpos + width && y < ypos + height;
@@ -1367,7 +1368,7 @@ void CropWindow::expose (Cairo::RefPtr<Cairo::Context> cr)
             Gdk::Cairo::set_source_pixbuf(cr, rough, posX, posY);
             cr->rectangle(posX, posY, rtengine::min (rough->get_width (), imgAreaW-imgX), rtengine::min (rough->get_height (), imgAreaH-imgY));
             cr->fill();
-//            if (cropHandler.cropParams.enabled)
+//            if (cropHandler.cropParams->enabled)
 //                drawCrop (cr, x+imgX, y+imgY, imgW, imgH, cropX, cropY, zoomSteps[cropZoom].zoom, cropHandler.cropParams);
         }
 
@@ -1375,7 +1376,7 @@ void CropWindow::expose (Cairo::RefPtr<Cairo::Context> cr)
             drawObservedFrame (cr);
         }
     } else {
-        CropParams cropParams = cropHandler.cropParams;
+        CropParams cropParams = *cropHandler.cropParams;
         if (state == SNormal) {
             switch (options.cropGuides) {
             case Options::CROP_GUIDE_NONE:
@@ -1805,7 +1806,7 @@ void CropWindow::expose (Cairo::RefPtr<Cairo::Context> cr)
                 cr->fill();
             }
 
-            if (cropHandler.cropParams.enabled) {
+            if (cropHandler.cropParams->enabled) {
                 int cropX, cropY;
                 cropHandler.getPosition (cropX, cropY);
                 drawCrop (cr, x + imgAreaX + imgX, y + imgAreaY + imgY, imgW, imgH, cropX, cropY, zoomSteps[cropZoom].zoom, cropParams, (this == iarea->mainCropWindow), useBgColor, cropHandler.isFullDisplay ());
@@ -1888,7 +1889,7 @@ void CropWindow::expose (Cairo::RefPtr<Cairo::Context> cr)
                 cr->rectangle(posX, posY, rtengine::min (rough->get_width (), imgAreaW-imgX), rtengine::min (rough->get_height (), imgAreaH-imgY));
                 cr->fill();
 
-                if (cropHandler.cropParams.enabled) {
+                if (cropHandler.cropParams->enabled) {
                     drawCrop (cr, x + imgAreaX + imgX, y + imgAreaY + imgY, rough->get_width(), rough->get_height(), cropX, cropY, zoomSteps[cropZoom].zoom, cropParams, (this == iarea->mainCropWindow), useBgColor, cropHandler.isFullDisplay ());
                 }
 
@@ -1947,9 +1948,9 @@ void CropWindow::zoomIn (bool toCursor, int cursorX, int cursorY)
         y = cursorY;
     } else {
         if (zoomSteps[cropZoom].zoom <= cropHandler.getFitZoom()) {
-            if (cropHandler.cropParams.enabled) {
+            if (cropHandler.cropParams->enabled) {
-                x = cropHandler.cropParams.x + cropHandler.cropParams.w / 2;
+                x = cropHandler.cropParams->x + cropHandler.cropParams->w / 2;
-                y = cropHandler.cropParams.y + cropHandler.cropParams.h / 2;
+                y = cropHandler.cropParams->y + cropHandler.cropParams->h / 2;
             } else {
                 int fw, fh;
                 cropHandler.getFullImageSize(fw, fh);
@@ -1961,11 +1962,11 @@ void CropWindow::zoomIn (bool toCursor, int cursorX, int cursorY)
         } else if (zoomVersion != exposeVersion) {
             screenCoordToImage(xpos + imgX + imgW / 2, ypos + imgY + imgH / 2, x, y);
 
-            if (cropHandler.cropParams.enabled) {
+            if (cropHandler.cropParams->enabled) {
                 // add some gravity towards crop center
-                int x1 = cropHandler.cropParams.x + cropHandler.cropParams.w / 2;
+                int x1 = cropHandler.cropParams->x + cropHandler.cropParams->w / 2;
-                int y1 = cropHandler.cropParams.y + cropHandler.cropParams.h / 2;
+                int y1 = cropHandler.cropParams->y + cropHandler.cropParams->h / 2;
-                double cropd = sqrt(cropHandler.cropParams.h * cropHandler.cropParams.h + cropHandler.cropParams.w * cropHandler.cropParams.w) * zoomSteps[cropZoom].zoom;
+                double cropd = sqrt(cropHandler.cropParams->h * cropHandler.cropParams->h + cropHandler.cropParams->w * cropHandler.cropParams->w) * zoomSteps[cropZoom].zoom;
                 double imd = sqrt(imgW * imgW + imgH * imgH);
                 double d;
 
@@ -2023,9 +2024,9 @@ void CropWindow::zoom11 (bool notify)
     int y = -1;
 
     if (zoomSteps[cropZoom].zoom <= cropHandler.getFitZoom()) {
-        if (cropHandler.cropParams.enabled) {
+        if (cropHandler.cropParams->enabled) {
-            x = cropHandler.cropParams.x + cropHandler.cropParams.w / 2;
+            x = cropHandler.cropParams->x + cropHandler.cropParams->w / 2;
-            y = cropHandler.cropParams.y + cropHandler.cropParams.h / 2;
+            y = cropHandler.cropParams->y + cropHandler.cropParams->h / 2;
         } else {
             int fw, fh;
             cropHandler.getFullImageSize(fw, fh);
@@ -2114,7 +2115,7 @@ void CropWindow::zoomFit ()
 
 void CropWindow::zoomFitCrop ()
 {
-    if(cropHandler.cropParams.enabled) {
+    if(cropHandler.cropParams->enabled) {
         double z = cropHandler.getFitCropZoom ();
         int cz = int(zoomSteps.size())-1;
 
@@ -2129,8 +2130,8 @@ void CropWindow::zoomFitCrop ()
 
         zoomVersion = exposeVersion;
         int centerX, centerY;
-        centerX = cropHandler.cropParams.x + cropHandler.cropParams.w / 2;
+        centerX = cropHandler.cropParams->x + cropHandler.cropParams->w / 2;
-        centerY = cropHandler.cropParams.y + cropHandler.cropParams.h / 2;
+        centerY = cropHandler.cropParams->y + cropHandler.cropParams->h / 2;
         setCropAnchorPosition(centerX, centerY);
         changeZoom (cz, true, centerX, centerY);
         fitZoom = options.cropAutoFit;

rtgui/exifpanel.cc

@@ -684,7 +684,7 @@ void ExifPanel::updateChangeList ()
 void ExifPanel::applyChangeList ()
 {
 
-    for (rtengine::procparams::ExifPairs::iterator i = changeList.begin(); i != changeList.end(); ++i) {
+    for (rtengine::procparams::ExifPairs::const_iterator i = changeList.begin(); i != changeList.end(); ++i) {
         editTag (exifTreeModel->children(), i->first, i->second);
     }
 }

rtgui/exportpanel.cc

@@ -22,6 +22,8 @@
 #include "options.h"
 #include "rtimage.h"
 
+#include "../rtengine/procparams.h"
+
 using namespace rtengine;
 using namespace rtengine::procparams;
 

rtgui/filebrowserentry.cc

@@ -18,15 +18,17 @@
  */
 #include "filebrowserentry.h"
 
-#include <iomanip>
 #include <cstring>
+#include <iomanip>
 
-#include "guiutils.h"
-#include "threadutils.h"
-#include "rtimage.h"
 #include "cursormanager.h"
-#include "thumbbrowserbase.h"
+#include "guiutils.h"
 #include "inspector.h"
+#include "rtimage.h"
+#include "threadutils.h"
+#include "thumbbrowserbase.h"
+
+#include "../rtengine/procparams.h"
 
 #define CROPRESIZEBORDER 4
 
@@ -40,7 +42,7 @@ Glib::RefPtr<Gdk::Pixbuf> FileBrowserEntry::hdr;
 Glib::RefPtr<Gdk::Pixbuf> FileBrowserEntry::ps;
 
 FileBrowserEntry::FileBrowserEntry (Thumbnail* thm, const Glib::ustring& fname)
-    : ThumbBrowserEntryBase (fname), wasInside(false), iatlistener(nullptr), press_x(0), press_y(0), action_x(0), action_y(0), rot_deg(0.0), landscape(true), cropgl(nullptr), state(SNormal), crop_custom_ratio(0.f)
+    : ThumbBrowserEntryBase (fname), wasInside(false), iatlistener(nullptr), press_x(0), press_y(0), action_x(0), action_y(0), rot_deg(0.0), landscape(true), cropParams(new rtengine::procparams::CropParams), cropgl(nullptr), state(SNormal), crop_custom_ratio(0.f)
 {
     thumbnail = thm;
 
@@ -163,9 +165,9 @@ std::vector<Glib::RefPtr<Gdk::Pixbuf> > FileBrowserEntry::getSpecificityIconsOnI
 
 void FileBrowserEntry::customBackBufferUpdate (Cairo::RefPtr<Cairo::Context> c)
 {
-    if(scale != 1.0 && cropParams.enabled) { // somewhere in pipeline customBackBufferUpdate is called when scale == 1.0, which is nonsense for a thumb
+    if(scale != 1.0 && cropParams->enabled) { // somewhere in pipeline customBackBufferUpdate is called when scale == 1.0, which is nonsense for a thumb
         if (state == SCropSelecting || state == SResizeH1 || state == SResizeH2 || state == SResizeW1 || state == SResizeW2 || state == SResizeTL || state == SResizeTR || state == SResizeBL || state == SResizeBR || state == SCropMove) {
-            drawCrop (c, prex, prey, prew, preh, 0, 0, scale, cropParams, true, false);
+            drawCrop (c, prex, prey, prew, preh, 0, 0, scale, *cropParams, true, false);
         } else {
             rtengine::procparams::CropParams cparams = thumbnail->getProcParams().crop;
             switch (options.cropGuides) {
@@ -246,7 +248,7 @@ void FileBrowserEntry::_updateImage(rtengine::IImage8* img, double s, const rten
 
     redrawRequests--;
     scale = s;
-    this->cropParams = cropParams;
+    *this->cropParams = cropParams;
 
     bool newLandscape = img->getWidth() > img->getHeight();
     bool rotated = false;
@@ -319,65 +321,65 @@ bool FileBrowserEntry::motionNotify (int x, int y)
         action_y = y;
         parent->redrawNeeded (this);
     } else if (state == SResizeH1 && cropgl) {
-        int oy = cropParams.y;
+        int oy = cropParams->y;
-        cropParams.y = action_y + (y - press_y) / scale;
+        cropParams->y = action_y + (y - press_y) / scale;
-        cropParams.h += oy - cropParams.y;
+        cropParams->h += oy - cropParams->y;
-        cropgl->cropHeight1Resized (cropParams.x, cropParams.y, cropParams.w, cropParams.h, crop_custom_ratio);
+        cropgl->cropHeight1Resized (cropParams->x, cropParams->y, cropParams->w, cropParams->h, crop_custom_ratio);
         updateBackBuffer ();
         parent->redrawNeeded (this);
     } else if (state == SResizeH2 && cropgl) {
-        cropParams.h = action_y + (y - press_y) / scale;
+        cropParams->h = action_y + (y - press_y) / scale;
-        cropgl->cropHeight2Resized (cropParams.x, cropParams.y, cropParams.w, cropParams.h, crop_custom_ratio);
+        cropgl->cropHeight2Resized (cropParams->x, cropParams->y, cropParams->w, cropParams->h, crop_custom_ratio);
         updateBackBuffer ();
         parent->redrawNeeded (this);
     } else if (state == SResizeW1 && cropgl) {
-        int ox = cropParams.x;
+        int ox = cropParams->x;
-        cropParams.x = action_x + (x - press_x) / scale;
+        cropParams->x = action_x + (x - press_x) / scale;
-        cropParams.w += ox - cropParams.x;
+        cropParams->w += ox - cropParams->x;
-        cropgl->cropWidth1Resized (cropParams.x, cropParams.y, cropParams.w, cropParams.h, crop_custom_ratio);
+        cropgl->cropWidth1Resized (cropParams->x, cropParams->y, cropParams->w, cropParams->h, crop_custom_ratio);
         updateBackBuffer ();
         parent->redrawNeeded (this);
     } else if (state == SResizeW2 && cropgl) {
-        cropParams.w = action_x + (x - press_x) / scale;
+        cropParams->w = action_x + (x - press_x) / scale;
-        cropgl->cropWidth2Resized (cropParams.x, cropParams.y, cropParams.w, cropParams.h, crop_custom_ratio);
+        cropgl->cropWidth2Resized (cropParams->x, cropParams->y, cropParams->w, cropParams->h, crop_custom_ratio);
         updateBackBuffer ();
         parent->redrawNeeded (this);
     } else if (state == SResizeTL && cropgl) {
-        int ox = cropParams.x;
+        int ox = cropParams->x;
-        cropParams.x = action_x + (x - press_x) / scale;
+        cropParams->x = action_x + (x - press_x) / scale;
-        cropParams.w += ox - cropParams.x;
+        cropParams->w += ox - cropParams->x;
-        int oy = cropParams.y;
+        int oy = cropParams->y;
-        cropParams.y = action_y + (y - press_y) / scale;
+        cropParams->y = action_y + (y - press_y) / scale;
-        cropParams.h += oy - cropParams.y;
+        cropParams->h += oy - cropParams->y;
-        cropgl->cropTopLeftResized (cropParams.x, cropParams.y, cropParams.w, cropParams.h, crop_custom_ratio);
+        cropgl->cropTopLeftResized (cropParams->x, cropParams->y, cropParams->w, cropParams->h, crop_custom_ratio);
         updateBackBuffer ();
         parent->redrawNeeded (this);
     } else if (state == SResizeTR && cropgl) {
-        cropParams.w = action_x + (x - press_x) / scale;
+        cropParams->w = action_x + (x - press_x) / scale;
-        int oy = cropParams.y;
+        int oy = cropParams->y;
-        cropParams.y = action_y + (y - press_y) / scale;
+        cropParams->y = action_y + (y - press_y) / scale;
-        cropParams.h += oy - cropParams.y;
+        cropParams->h += oy - cropParams->y;
-        cropgl->cropTopRightResized (cropParams.x, cropParams.y, cropParams.w, cropParams.h, crop_custom_ratio);
+        cropgl->cropTopRightResized (cropParams->x, cropParams->y, cropParams->w, cropParams->h, crop_custom_ratio);
         updateBackBuffer ();
         parent->redrawNeeded (this);
     } else if (state == SResizeBL && cropgl) {
-        int ox = cropParams.x;
+        int ox = cropParams->x;
-        cropParams.x = action_x + (x - press_x) / scale;
+        cropParams->x = action_x + (x - press_x) / scale;
-        cropParams.w += ox - cropParams.x;
+        cropParams->w += ox - cropParams->x;
-        cropParams.h = action_y + (y - press_y) / scale;
+        cropParams->h = action_y + (y - press_y) / scale;
-        cropgl->cropBottomLeftResized (cropParams.x, cropParams.y, cropParams.w, cropParams.h, crop_custom_ratio);
+        cropgl->cropBottomLeftResized (cropParams->x, cropParams->y, cropParams->w, cropParams->h, crop_custom_ratio);
         updateBackBuffer ();
         parent->redrawNeeded (this);
     } else if (state == SResizeBR && cropgl) {
-        cropParams.w = action_x + (x - press_x) / scale;
+        cropParams->w = action_x + (x - press_x) / scale;
-        cropParams.h = action_y + (y - press_y) / scale;
+        cropParams->h = action_y + (y - press_y) / scale;
-        cropgl->cropBottomRightResized (cropParams.x, cropParams.y, cropParams.w, cropParams.h, crop_custom_ratio);
+        cropgl->cropBottomRightResized (cropParams->x, cropParams->y, cropParams->w, cropParams->h, crop_custom_ratio);
         updateBackBuffer ();
         parent->redrawNeeded (this);
     } else if (state == SCropMove && cropgl) {
-        cropParams.x = action_x + (x - press_x) / scale;
+        cropParams->x = action_x + (x - press_x) / scale;
-        cropParams.y = action_y + (y - press_y) / scale;
+        cropParams->y = action_y + (y - press_y) / scale;
-        cropgl->cropMoved (cropParams.x, cropParams.y, cropParams.w, cropParams.h);
+        cropgl->cropMoved (cropParams->x, cropParams->y, cropParams->w, cropParams->h);
         updateBackBuffer ();
         parent->redrawNeeded (this);
     } else if (state == SCropSelecting && cropgl) {
@@ -386,19 +388,19 @@ bool FileBrowserEntry::motionNotify (int x, int y)
         cropgl->cropResized (cx1, cy1, cx2, cy2);
 
         if (cx2 > cx1) {
-            cropParams.x = cx1;
+            cropParams->x = cx1;
-            cropParams.w = cx2 - cx1 + 1;
+            cropParams->w = cx2 - cx1 + 1;
         } else {
-            cropParams.x = cx2;
+            cropParams->x = cx2;
-            cropParams.w = cx1 - cx2 + 1;
+            cropParams->w = cx1 - cx2 + 1;
         }
 
         if (cy2 > cy1) {
-            cropParams.y = cy1;
+            cropParams->y = cy1;
-            cropParams.h = cy2 - cy1 + 1;
+            cropParams->h = cy2 - cy1 + 1;
         } else {
-            cropParams.y = cy2;
+            cropParams->y = cy2;
-            cropParams.h = cy1 - cy2 + 1;
+            cropParams->h = cy1 - cy2 + 1;
         }
 
         updateBackBuffer ();
@@ -429,71 +431,71 @@ bool FileBrowserEntry::pressNotify   (int button, int type, int bstate, int x, i
 
     if (!b && selected && inside (x, y)) {
         if (button == 1 && type == GDK_BUTTON_PRESS && state == SNormal) {
-            if ((bstate & GDK_SHIFT_MASK) && cropParams.w > 0 && cropParams.h > 0) {
+            if ((bstate & GDK_SHIFT_MASK) && cropParams->w > 0 && cropParams->h > 0) {
-                crop_custom_ratio = float(cropParams.w) / float(cropParams.h);
+                crop_custom_ratio = float(cropParams->w) / float(cropParams->h);
             }
             if (onArea (CropTopLeft, ix, iy)) {
                 state = SResizeTL;
                 press_x = x;
-                action_x = cropParams.x;
+                action_x = cropParams->x;
                 press_y = y;
-                action_y = cropParams.y;
+                action_y = cropParams->y;
                 cropgl = iatlistener->startCropEditing (thumbnail);
                 b = true;
             } else if (onArea (CropTopRight, ix, iy)) {
                 state = SResizeTR;
                 press_x = x;
-                action_x = cropParams.w;
+                action_x = cropParams->w;
                 press_y = y;
-                action_y = cropParams.y;
+                action_y = cropParams->y;
                 cropgl = iatlistener->startCropEditing (thumbnail);
                 b = true;
             } else if (onArea (CropBottomLeft, ix, iy)) {
                 state = SResizeBL;
                 press_x = x;
-                action_x = cropParams.x;
+                action_x = cropParams->x;
                 press_y = y;
-                action_y = cropParams.h;
+                action_y = cropParams->h;
                 cropgl = iatlistener->startCropEditing (thumbnail);
                 b = true;
             } else if (onArea (CropBottomRight, ix, iy)) {
                 state = SResizeBR;
                 press_x = x;
-                action_x = cropParams.w;
+                action_x = cropParams->w;
                 press_y = y;
-                action_y = cropParams.h;
+                action_y = cropParams->h;
                 cropgl = iatlistener->startCropEditing (thumbnail);
                 b = true;
             } else if (onArea (CropTop, ix, iy)) {
                 state = SResizeH1;
                 press_y = y;
-                action_y = cropParams.y;
+                action_y = cropParams->y;
                 cropgl = iatlistener->startCropEditing (thumbnail);
                 b = true;
             } else if (onArea (CropBottom, ix, iy)) {
                 state = SResizeH2;
                 press_y = y;
-                action_y = cropParams.h;
+                action_y = cropParams->h;
                 cropgl = iatlistener->startCropEditing (thumbnail);
                 b = true;
             } else if (onArea (CropLeft, ix, iy)) {
                 state = SResizeW1;
                 press_x = x;
-                action_x = cropParams.x;
+                action_x = cropParams->x;
                 cropgl = iatlistener->startCropEditing (thumbnail);
                 b = true;
             } else if (onArea (CropRight, ix, iy)) {
                 state = SResizeW2;
                 press_x = x;
-                action_x = cropParams.w;
+                action_x = cropParams->w;
                 cropgl = iatlistener->startCropEditing (thumbnail);
                 b = true;
             } else if ((bstate & GDK_SHIFT_MASK) && onArea (CropInside, ix, iy)) {
                 state = SCropMove;
                 press_x = x;
                 press_y = y;
-                action_x = cropParams.x;
+                action_x = cropParams->x;
-                action_y = cropParams.y;
+                action_y = cropParams->y;
                 cropgl = iatlistener->startCropEditing (thumbnail);
                 b = true;
             } else if (onArea (CropImage, ix, iy)) {
@@ -513,10 +515,10 @@ bool FileBrowserEntry::pressNotify   (int button, int type, int bstate, int x, i
 
                     if (cropgl) {
                         state = SCropSelecting;
-                        press_x = cropParams.x = (ix - prex) / scale;
+                        press_x = cropParams->x = (ix - prex) / scale;
-                        press_y = cropParams.y = (iy - prey) / scale;
+                        press_y = cropParams->y = (iy - prey) / scale;
-                        cropParams.w = cropParams.h = 1;
+                        cropParams->w = cropParams->h = 1;
-                        cropgl->cropInit (cropParams.x, cropParams.y, cropParams.w, cropParams.h);
+                        cropgl->cropInit (cropParams->x, cropParams->y, cropParams->w, cropParams->h);
                         b = true;
                     }
                 }
@@ -582,67 +584,67 @@ bool FileBrowserEntry::onArea (CursorArea a, int x, int y)
         return x >= prex && x < prex + prew && y >= prey && y < prey + preh;
 
     case CropTopLeft:
-        return cropParams.enabled &&
+        return cropParams->enabled &&
-               y1 >= cropParams.y - cropResizeBorder &&
+               y1 >= cropParams->y - cropResizeBorder &&
-               y1 <= cropParams.y + cropResizeBorder &&
+               y1 <= cropParams->y + cropResizeBorder &&
-               x1 >= cropParams.x - cropResizeBorder &&
+               x1 >= cropParams->x - cropResizeBorder &&
-               x1 <= cropParams.x + cropResizeBorder;
+               x1 <= cropParams->x + cropResizeBorder;
 
     case CropTopRight:
-        return cropParams.enabled &&
+        return cropParams->enabled &&
-               y1 >= cropParams.y - cropResizeBorder &&
+               y1 >= cropParams->y - cropResizeBorder &&
-               y1 <= cropParams.y + cropResizeBorder &&
+               y1 <= cropParams->y + cropResizeBorder &&
-               x1 >= cropParams.x + cropParams.w - 1 - cropResizeBorder &&
+               x1 >= cropParams->x + cropParams->w - 1 - cropResizeBorder &&
-               x1 <= cropParams.x + cropParams.w - 1 + cropResizeBorder;
+               x1 <= cropParams->x + cropParams->w - 1 + cropResizeBorder;
 
     case CropBottomLeft:
-        return cropParams.enabled &&
+        return cropParams->enabled &&
-               y1 >= cropParams.y + cropParams.h - 1 - cropResizeBorder &&
+               y1 >= cropParams->y + cropParams->h - 1 - cropResizeBorder &&
-               y1 <= cropParams.y + cropParams.h - 1 + cropResizeBorder &&
+               y1 <= cropParams->y + cropParams->h - 1 + cropResizeBorder &&
-               x1 >= cropParams.x - cropResizeBorder &&
+               x1 >= cropParams->x - cropResizeBorder &&
-               x1 <= cropParams.x + cropResizeBorder;
+               x1 <= cropParams->x + cropResizeBorder;
 
     case CropBottomRight:
-        return cropParams.enabled &&
+        return cropParams->enabled &&
-               y1 >= cropParams.y + cropParams.h - 1 - cropResizeBorder &&
+               y1 >= cropParams->y + cropParams->h - 1 - cropResizeBorder &&
-               y1 <= cropParams.y + cropParams.h - 1 + cropResizeBorder &&
+               y1 <= cropParams->y + cropParams->h - 1 + cropResizeBorder &&
-               x1 >= cropParams.x + cropParams.w - 1 - cropResizeBorder &&
+               x1 >= cropParams->x + cropParams->w - 1 - cropResizeBorder &&
-               x1 <= cropParams.x + cropParams.w - 1 + cropResizeBorder;
+               x1 <= cropParams->x + cropParams->w - 1 + cropResizeBorder;
 
     case CropTop:
-        return cropParams.enabled &&
+        return cropParams->enabled &&
-               x1 > cropParams.x + cropResizeBorder &&
+               x1 > cropParams->x + cropResizeBorder &&
-               x1 < cropParams.x + cropParams.w - 1 - cropResizeBorder &&
+               x1 < cropParams->x + cropParams->w - 1 - cropResizeBorder &&
-               y1 > cropParams.y - cropResizeBorder &&
+               y1 > cropParams->y - cropResizeBorder &&
-               y1 < cropParams.y + cropResizeBorder;
+               y1 < cropParams->y + cropResizeBorder;
 
     case CropBottom:
-        return cropParams.enabled &&
+        return cropParams->enabled &&
-               x1 > cropParams.x + cropResizeBorder &&
+               x1 > cropParams->x + cropResizeBorder &&
-               x1 < cropParams.x + cropParams.w - 1 - cropResizeBorder &&
+               x1 < cropParams->x + cropParams->w - 1 - cropResizeBorder &&
-               y1 > cropParams.y + cropParams.h - 1 - cropResizeBorder &&
+               y1 > cropParams->y + cropParams->h - 1 - cropResizeBorder &&
-               y1 < cropParams.y + cropParams.h - 1 + cropResizeBorder;
+               y1 < cropParams->y + cropParams->h - 1 + cropResizeBorder;
 
     case CropLeft:
-        return cropParams.enabled &&
+        return cropParams->enabled &&
-               y1 > cropParams.y + cropResizeBorder &&
+               y1 > cropParams->y + cropResizeBorder &&
-               y1 < cropParams.y + cropParams.h - 1 - cropResizeBorder &&
+               y1 < cropParams->y + cropParams->h - 1 - cropResizeBorder &&
-               x1 > cropParams.x - cropResizeBorder &&
+               x1 > cropParams->x - cropResizeBorder &&
-               x1 < cropParams.x + cropResizeBorder;
+               x1 < cropParams->x + cropResizeBorder;
 
     case CropRight:
-        return cropParams.enabled &&
+        return cropParams->enabled &&
-               y1 > cropParams.y + cropResizeBorder &&
+               y1 > cropParams->y + cropResizeBorder &&
-               y1 < cropParams.y + cropParams.h - 1 - cropResizeBorder &&
+               y1 < cropParams->y + cropParams->h - 1 - cropResizeBorder &&
-               x1 > cropParams.x + cropParams.w - 1 - cropResizeBorder &&
+               x1 > cropParams->x + cropParams->w - 1 - cropResizeBorder &&
-               x1 < cropParams.x + cropParams.w - 1 + cropResizeBorder;
+               x1 < cropParams->x + cropParams->w - 1 + cropResizeBorder;
 
     case CropInside:
-        return cropParams.enabled &&
+        return cropParams->enabled &&
-               y1 > cropParams.y &&
+               y1 > cropParams->y &&
-               y1 < cropParams.y + cropParams.h - 1 &&
+               y1 < cropParams->y + cropParams->h - 1 &&
-               x1 > cropParams.x &&
+               x1 > cropParams->x &&
-               x1 < cropParams.x + cropParams.w - 1;
+               x1 < cropParams->x + cropParams->w - 1;
     default: /* do nothing */ ;
     }
 

rtgui/filebrowserentry.h

@@ -20,6 +20,7 @@
 #define _FILEBROWSERENTRY_
 
 #include <atomic>
+#include <memory>
 
 #include <gtkmm.h>
 
@@ -55,7 +56,7 @@ class FileBrowserEntry : public ThumbBrowserEntryBase,
     int press_x, press_y, action_x, action_y;
     double rot_deg;
     bool landscape;
-    rtengine::procparams::CropParams cropParams;
+    std::unique_ptr<rtengine::procparams::CropParams> cropParams;
     CropGUIListener* cropgl;
     FileBrowserEntryIdleHelper* feih;
 

rtgui/filecatalog.cc

@@ -1187,7 +1187,7 @@ void FileCatalog::developRequested(const std::vector<FileBrowserEntry*>& tbe, bo
                     params.icm.inputProfile = options.fastexport_icm_input_profile;
                     params.icm.workingProfile = options.fastexport_icm_working_profile;
                     params.icm.outputProfile = options.fastexport_icm_output_profile;
-                    params.icm.outputIntent = options.fastexport_icm_outputIntent;
+                    params.icm.outputIntent = rtengine::RenderingIntent(options.fastexport_icm_outputIntent);
                     params.icm.outputBPC = options.fastexport_icm_outputBPC;
                 }
 

rtgui/guiutils.cc

@@ -23,6 +23,7 @@
 #include "../rtengine/rt_math.h"
 #include "../rtengine/utils.h"
 #include "../rtengine/icons.h"
+#include "../rtengine/procparams.h"
 #include "rtimage.h"
 #include "multilangmgr.h"
 

rtgui/imagearea.cc

@@ -23,6 +23,7 @@
 #include "multilangmgr.h"
 #include "cropwindow.h"
 #include "../rtengine/refreshmap.h"
+#include "../rtengine/procparams.h"
 #include "options.h"
 
 ImageArea::ImageArea (ImageAreaPanel* p) : parent(p), fullImageWidth(0), fullImageHeight(0)
@@ -659,7 +660,7 @@ void ImageArea::initialImageArrived ()
             } else {
                 mainCropWindow->zoomFit();
             }
-        } else if ((options.cropAutoFit || options.bgcolor != 0) && mainCropWindow->cropHandler.cropParams.enabled) {
+        } else if ((options.cropAutoFit || options.bgcolor != 0) && mainCropWindow->cropHandler.cropParams->enabled) {
             mainCropWindow->zoomFitCrop();
         }
         fullImageWidth = w;

rtgui/iptcpanel.cc

@@ -623,7 +623,7 @@ void IPTCPanel::applyChangeList ()
     keyword->get_entry()->set_text ("");
     suppCategory->get_entry()->set_text ("");
 
-    for (rtengine::procparams::IPTCPairs::iterator i = changeList.begin(); i != changeList.end(); ++i) {
+    for (rtengine::procparams::IPTCPairs::const_iterator i = changeList.begin(); i != changeList.end(); ++i) {
         if (i->first == "Caption" && !i->second.empty()) {
             captionText->set_text (i->second.at(0));
         } else if (i->first == "CaptionWriter" && !i->second.empty()) {

rtgui/options.cc

@@ -25,6 +25,8 @@
 #include "guiutils.h"
 #include "version.h"
 
+#include "../rtengine/procparams.h"
+
 #ifdef _OPENMP
 #include <omp.h>
 #endif

rtgui/options.h

@@ -363,7 +363,7 @@ public:
     Glib::ustring fastexport_icm_input_profile;
     Glib::ustring fastexport_icm_working_profile;
     Glib::ustring fastexport_icm_output_profile;
-    rtengine::RenderingIntent fastexport_icm_outputIntent;
+    int fastexport_icm_outputIntent;
     bool          fastexport_icm_outputBPC;
     Glib::ustring fastexport_icm_custom_output_profile;
     bool          fastexport_resize_enabled;

rtgui/partialpastedlg.h

@@ -22,6 +22,8 @@
 #include <gtkmm.h>
 #include "../rtengine/rtengine.h"
 
+class ParamsEdited;
+
 class PartialPasteDlg : public Gtk::Dialog
 {
 

rtgui/preferences.cc

@@ -2384,7 +2384,7 @@ void Preferences::workflowUpdate ()
             || moptions.rtSettings.printerBPC     != options.rtSettings.printerBPC
             || moptions.rtSettings.printerIntent  != options.rtSettings.printerIntent) {
         // Update the position of the Histogram
-        parent->updateProfiles (moptions.rtSettings.printerProfile, moptions.rtSettings.printerIntent, moptions.rtSettings.printerBPC);
+        parent->updateProfiles (moptions.rtSettings.printerProfile, rtengine::RenderingIntent(moptions.rtSettings.printerIntent), moptions.rtSettings.printerBPC);
     }
 
 }

rtgui/previewhandler.cc

@@ -19,11 +19,15 @@
 #include "previewhandler.h"
 #include <gtkmm.h>
 #include "../rtengine/rtengine.h"
+#include "../rtengine/procparams.h"
 
 using namespace rtengine;
 using namespace rtengine::procparams;
 
-PreviewHandler::PreviewHandler () : image(nullptr), previewScale(1.)
+PreviewHandler::PreviewHandler () :
+    image(nullptr),
+    cropParams(new procparams::CropParams),
+    previewScale(1.)
 {
 
     pih = new PreviewHandlerIdleHelper;
@@ -72,7 +76,7 @@ void PreviewHandler::setImage(rtengine::IImage8* i, double scale, const rtengine
                 pih->phandler->image = i;
             }
 
-            pih->phandler->cropParams = cp;
+            *pih->phandler->cropParams = cp;
             pih->phandler->previewScale = scale;
             --pih->pending;
 
@@ -139,7 +143,7 @@ void PreviewHandler::imageReady(const rtengine::procparams::CropParams& cp)
             pih->phandler->previewImg = Gdk::Pixbuf::create_from_data(pih->phandler->image->getData(), Gdk::COLORSPACE_RGB, false, 8, pih->phandler->image->getWidth(), pih->phandler->image->getHeight(), 3 * pih->phandler->image->getWidth());
             pih->phandler->previewImgMutex.unlock ();
 
-            pih->phandler->cropParams = cp;
+            *pih->phandler->cropParams = cp;
             pih->phandler->previewImageChanged ();
             --pih->pending;
 
@@ -204,3 +208,8 @@ void PreviewHandler::previewImageChanged ()
         (*i)->previewImageChanged ();
     }
 }
+
+rtengine::procparams::CropParams PreviewHandler::getCropParams()
+{
+    return *cropParams;
+}

rtgui/previewhandler.h

@@ -20,6 +20,7 @@
 #define _PREVIEWHANDLER_
 
 #include <list>
+#include <memory>
 
 #include <gtkmm.h>
 
@@ -54,7 +55,7 @@ private:
 
 protected:
     rtengine::IImage8* image;
-    rtengine::procparams::CropParams cropParams;
+    std::unique_ptr<rtengine::procparams::CropParams> cropParams;
     double previewScale;
     PreviewHandlerIdleHelper* pih;
     std::list<PreviewListener*> listeners;
@@ -82,10 +83,7 @@ public:
     // with this function it is possible to ask for a rough approximation of a (possibly zoomed) crop of the image
     Glib::RefPtr<Gdk::Pixbuf>           getRoughImage (int x, int y, int w, int h, double zoom);
     Glib::RefPtr<Gdk::Pixbuf>           getRoughImage (int desiredW, int desiredH, double& zoom);
-    rtengine::procparams::CropParams    getCropParams ()
+    rtengine::procparams::CropParams    getCropParams ();
-    {
-        return cropParams;
-    }
 };
 
 #endif

rtgui/previewwindow.cc

@@ -21,6 +21,8 @@
 #include "imagearea.h"
 #include "cursormanager.h"
 
+#include "../rtengine/procparams.h"
+
 PreviewWindow::PreviewWindow () : previewHandler(nullptr), mainCropWin(nullptr), imageArea(nullptr), imgX(0), imgY(0), imgW(0), imgH(0),
     zoom(0.0), press_x(0), press_y(0), isMoving(false), needsUpdate(false), cursor_type(CSUndefined)
 

rtgui/thumbimageupdater.cc

@@ -27,6 +27,8 @@
 #include "guiutils.h"
 #include "threadutils.h"
 
+#include "../rtengine/procparams.h"
+
 #ifdef _OPENMP
 #include <omp.h>
 #endif

rtgui/thumbnail.cc

@@ -25,6 +25,7 @@
 #include <cstdlib>
 #include <glibmm.h>
 #include "../rtengine/imagedata.h"
+#include "../rtengine/procparams.h"
 #include <glib/gstdio.h>
 
 #include "../rtengine/dynamicprofile.h"
@@ -38,7 +39,7 @@ using namespace rtengine::procparams;
 
 Thumbnail::Thumbnail (CacheManager* cm, const Glib::ustring& fname, CacheImageData* cf)
     : fname(fname), cfs(*cf), cachemgr(cm), ref(1), enqueueNumber(0), tpp(nullptr),
-      pparamsValid(false), imageLoading(false), lastImg(nullptr),
+      pparamsValid(false), pparams(new ProcParams), imageLoading(false), lastImg(nullptr),
       lastW(0), lastH(0), lastScale(0), initial_(false)
 {
 
@@ -66,7 +67,7 @@ Thumbnail::Thumbnail (CacheManager* cm, const Glib::ustring& fname, CacheImageDa
 
 Thumbnail::Thumbnail (CacheManager* cm, const Glib::ustring& fname, const std::string& md5)
     : fname(fname), cachemgr(cm), ref(1), enqueueNumber(0), tpp(nullptr), pparamsValid(false),
-      imageLoading(false), lastImg(nullptr),
+      pparams(new ProcParams), imageLoading(false), lastImg(nullptr),
       lastW(0), lastH(0), lastScale(0.0), initial_(true)
 {
 
@@ -107,20 +108,20 @@ void Thumbnail::_generateThumbnailImage ()
 
     if (ext.lowercase() == "jpg" || ext.lowercase() == "jpeg") {
         infoFromImage (fname);
-        tpp = rtengine::Thumbnail::loadFromImage (fname, tw, th, 1, pparams.wb.equal);
+        tpp = rtengine::Thumbnail::loadFromImage (fname, tw, th, 1, pparams->wb.equal);
 
         if (tpp) {
             cfs.format = FT_Jpeg;
         }
     } else if (ext.lowercase() == "png") {
-        tpp = rtengine::Thumbnail::loadFromImage (fname, tw, th, 1, pparams.wb.equal);
+        tpp = rtengine::Thumbnail::loadFromImage (fname, tw, th, 1, pparams->wb.equal);
 
         if (tpp) {
             cfs.format = FT_Png;
         }
     } else if (ext.lowercase() == "tif" || ext.lowercase() == "tiff") {
         infoFromImage (fname);
-        tpp = rtengine::Thumbnail::loadFromImage (fname, tw, th, 1, pparams.wb.equal);
+        tpp = rtengine::Thumbnail::loadFromImage (fname, tw, th, 1, pparams->wb.equal);
 
         if (tpp) {
             cfs.format = FT_Tiff;
@@ -141,7 +142,7 @@ void Thumbnail::_generateThumbnailImage ()
 
         if ( tpp == nullptr ) {
             quick = false;
-            tpp = rtengine::Thumbnail::loadFromRaw (fname, ri, sensorType, tw, th, 1, pparams.wb.equal, TRUE);
+            tpp = rtengine::Thumbnail::loadFromRaw (fname, ri, sensorType, tw, th, 1, pparams->wb.equal, TRUE);
         }
 
         cfs.sensortype = sensorType;
@@ -178,22 +179,22 @@ const ProcParams& Thumbnail::getProcParams ()
 const ProcParams& Thumbnail::getProcParamsU ()
 {
     if (pparamsValid) {
-        return pparams;
+        return *pparams;
     } else {
-        pparams = *(ProfileStore::getInstance()->getDefaultProcParams (getType() == FT_Raw));
+        *pparams = *(ProfileStore::getInstance()->getDefaultProcParams (getType() == FT_Raw));
 
-        if (pparams.wb.method == "Camera") {
+        if (pparams->wb.method == "Camera") {
             double ct;
-            getCamWB (ct, pparams.wb.green);
+            getCamWB (ct, pparams->wb.green);
-            pparams.wb.temperature = ct;
+            pparams->wb.temperature = ct;
-        } else if (pparams.wb.method == "Auto") {
+        } else if (pparams->wb.method == "Auto") {
             double ct;
-            getAutoWB (ct, pparams.wb.green, pparams.wb.equal, pparams.wb.tempBias);
+            getAutoWB (ct, pparams->wb.green, pparams->wb.equal, pparams->wb.tempBias);
-            pparams.wb.temperature = ct;
+            pparams->wb.temperature = ct;
         }
     }
 
-    return pparams; // there is no valid pp to return, but we have to return something
+    return *pparams; // there is no valid pp to return, but we have to return something
 }
 
 /** @brief  Create default params on demand and returns a new updatable object
@@ -320,27 +321,27 @@ void Thumbnail::loadProcParams ()
     MyMutex::MyLock lock(mutex);
 
     pparamsValid = false;
-    pparams.setDefaults();
+    pparams->setDefaults();
     const PartialProfile *defaultPP = ProfileStore::getInstance()->getDefaultPartialProfile(getType() == FT_Raw);
-    defaultPP->applyTo(&pparams);
+    defaultPP->applyTo(pparams.get());
 
     if (options.paramsLoadLocation == PLL_Input) {
         // try to load it from params file next to the image file
-        int ppres = pparams.load (fname + paramFileExtension);
+        int ppres = pparams->load (fname + paramFileExtension);
-        pparamsValid = !ppres && pparams.ppVersion >= 220;
+        pparamsValid = !ppres && pparams->ppVersion >= 220;
 
         // if no success, try to load the cached version of the procparams
         if (!pparamsValid) {
-            pparamsValid = !pparams.load (getCacheFileName ("profiles", paramFileExtension));
+            pparamsValid = !pparams->load (getCacheFileName ("profiles", paramFileExtension));
         }
     } else {
         // try to load it from cache
-        pparamsValid = !pparams.load (getCacheFileName ("profiles", paramFileExtension));
+        pparamsValid = !pparams->load (getCacheFileName ("profiles", paramFileExtension));
 
         // if no success, try to load it from params file next to the image file
         if (!pparamsValid) {
-            int ppres = pparams.load (fname + paramFileExtension);
+            int ppres = pparams->load (fname + paramFileExtension);
-            pparamsValid = !ppres && pparams.ppVersion >= 220;
+            pparamsValid = !ppres && pparams->ppVersion >= 220;
         }
     }
 }
@@ -373,7 +374,7 @@ void Thumbnail::clearProcParams (int whoClearedIt)
         // probably not as this is the only option to set param values to default
 
         // reset the params to defaults
-        pparams.setDefaults();
+        pparams->setDefaults();
 
         // and restore rank and inTrash
         setRank(rank);
@@ -422,42 +423,42 @@ void Thumbnail::setProcParams (const ProcParams& pp, ParamsEdited* pe, int whoCh
 {
     const bool needsReprocessing =
            resetToDefault
-        || pparams.toneCurve != pp.toneCurve
+        || pparams->toneCurve != pp.toneCurve
-        || pparams.labCurve != pp.labCurve
+        || pparams->labCurve != pp.labCurve
-        || pparams.localContrast != pp.localContrast
+        || pparams->localContrast != pp.localContrast
-        || pparams.rgbCurves != pp.rgbCurves
+        || pparams->rgbCurves != pp.rgbCurves
-        || pparams.colorToning != pp.colorToning
+        || pparams->colorToning != pp.colorToning
-        || pparams.vibrance != pp.vibrance
+        || pparams->vibrance != pp.vibrance
-        || pparams.wb != pp.wb
+        || pparams->wb != pp.wb
-        || pparams.colorappearance != pp.colorappearance
+        || pparams->colorappearance != pp.colorappearance
-        || pparams.epd != pp.epd
+        || pparams->epd != pp.epd
-        || pparams.fattal != pp.fattal
+        || pparams->fattal != pp.fattal
-        || pparams.sh != pp.sh
+        || pparams->sh != pp.sh
-        || pparams.crop != pp.crop
+        || pparams->crop != pp.crop
-        || pparams.coarse != pp.coarse
+        || pparams->coarse != pp.coarse
-        || pparams.commonTrans != pp.commonTrans
+        || pparams->commonTrans != pp.commonTrans
-        || pparams.rotate != pp.rotate
+        || pparams->rotate != pp.rotate
-        || pparams.distortion != pp.distortion
+        || pparams->distortion != pp.distortion
-        || pparams.lensProf != pp.lensProf
+        || pparams->lensProf != pp.lensProf
-        || pparams.perspective != pp.perspective
+        || pparams->perspective != pp.perspective
-        || pparams.gradient != pp.gradient
+        || pparams->gradient != pp.gradient
-        || pparams.pcvignette != pp.pcvignette
+        || pparams->pcvignette != pp.pcvignette
-        || pparams.cacorrection != pp.cacorrection
+        || pparams->cacorrection != pp.cacorrection
-        || pparams.vignetting != pp.vignetting
+        || pparams->vignetting != pp.vignetting
-        || pparams.chmixer != pp.chmixer
+        || pparams->chmixer != pp.chmixer
-        || pparams.blackwhite != pp.blackwhite
+        || pparams->blackwhite != pp.blackwhite
-        || pparams.icm != pp.icm
+        || pparams->icm != pp.icm
-        || pparams.hsvequalizer != pp.hsvequalizer
+        || pparams->hsvequalizer != pp.hsvequalizer
-        || pparams.filmSimulation != pp.filmSimulation
+        || pparams->filmSimulation != pp.filmSimulation
-        || pparams.softlight != pp.softlight
+        || pparams->softlight != pp.softlight
-        || pparams.dehaze != pp.dehaze
+        || pparams->dehaze != pp.dehaze
         || whoChangedIt == FILEBROWSER
         || whoChangedIt == BATCHEDITOR;
 
     {
         MyMutex::MyLock lock(mutex);
 
-        if (pparams != pp) {
+        if (*pparams != pp) {
             cfs.recentlySaved = false;
         } else if (pparamsValid && !updateCacheNow) {
             // nothing to do
@@ -470,9 +471,9 @@ void Thumbnail::setProcParams (const ProcParams& pp, ParamsEdited* pe, int whoCh
         const int inTrash = getStage();
 
         if (pe) {
-            pe->combine(pparams, pp, true);
+            pe->combine(*pparams, pp, true);
         } else {
-            pparams = pp;
+            *pparams = pp;
         }
 
         pparamsValid = true;
@@ -506,7 +507,7 @@ void Thumbnail::imageDeveloped ()
     cfs.save (getCacheFileName ("data", ".txt"));
 
     if (options.saveParamsCache) {
-        pparams.save (getCacheFileName ("profiles", paramFileExtension));
+        pparams->save (getCacheFileName ("profiles", paramFileExtension));
     }
 }
 
@@ -574,7 +575,7 @@ void Thumbnail::getThumbnailSize (int &w, int &h, const rtengine::procparams::Pr
             ppCoarse -= 180;
         }
 
-        int thisCoarse = this->pparams.coarse.rotate;
+        int thisCoarse = this->pparams->coarse.rotate;
 
         if (thisCoarse >= 180) {
             thisCoarse -= 180;
@@ -948,7 +949,7 @@ void Thumbnail::updateCache (bool updatePParams, bool updateCacheImageData)
 {
 
     if (updatePParams && pparamsValid) {
-        pparams.save (
+        pparams->save (
             options.saveParamsFile  ? fname + paramFileExtension : "",
             options.saveParamsCache ? getCacheFileName ("profiles", paramFileExtension) : "",
             true
@@ -981,6 +982,45 @@ void Thumbnail::setFileName (const Glib::ustring &fn)
     cfs.md5 = cachemgr->getMD5 (fname);
 }
 
+int Thumbnail::getRank  () const
+{
+    return pparams->rank;
+}
+
+void Thumbnail::setRank  (int rank)
+{
+    if (pparams->rank != rank) {
+        pparams->rank = rank;
+        pparamsValid = true;
+    }
+}
+
+int Thumbnail::getColorLabel  () const
+{
+    return pparams->colorlabel;
+}
+
+void Thumbnail::setColorLabel  (int colorlabel)
+{
+    if (pparams->colorlabel != colorlabel) {
+        pparams->colorlabel = colorlabel;
+        pparamsValid = true;
+    }
+}
+
+int Thumbnail::getStage () const
+{
+    return pparams->inTrash;
+}
+
+void Thumbnail::setStage (bool stage)
+{
+    if (pparams->inTrash != stage) {
+        pparams->inTrash = stage;
+        pparamsValid = true;
+    }
+}
+
 void Thumbnail::addThumbnailListener (ThumbnailListener* tnl)
 {
 

rtgui/thumbnail.h

@@ -19,7 +19,9 @@
 #ifndef _THUMBNAIL_
 #define _THUMBNAIL_
 
+#include <memory>
 #include <string>
+
 #include <glibmm.h>
 #include "cachemanager.h"
 #include "options.h"
@@ -30,6 +32,8 @@
 #include "threadutils.h"
 
 class CacheManager;
+class ParamsEdited;
+
 class Thumbnail
 {
 
@@ -47,7 +51,7 @@ class Thumbnail
     float           imgRatio;           // hack to avoid rounding error
 //        double          scale;            // portion of the sizes of the processed thumbnail image and the full scale image
 
-    rtengine::procparams::ProcParams      pparams;
+    std::unique_ptr<rtengine::procparams::ProcParams>      pparams;
     bool            pparamsValid;
     bool            imageLoading;
 
@@ -160,41 +164,14 @@ public:
         return cfs.md5;
     }
 
-    int             getRank  () const
+    int             getRank  () const;
-    {
+    void            setRank  (int rank);
-        return pparams.rank;
-    }
-    void            setRank  (int rank)
-    {
-        if (pparams.rank != rank) {
-            pparams.rank = rank;
-            pparamsValid = true;
-        }
-    }
 
-    int             getColorLabel  () const
+    int             getColorLabel  () const;
-    {
+    void            setColorLabel  (int colorlabel);
-        return pparams.colorlabel;
-    }
-    void            setColorLabel  (int colorlabel)
-    {
-        if (pparams.colorlabel != colorlabel) {
-            pparams.colorlabel = colorlabel;
-            pparamsValid = true;
-        }
-    }
 
-    int             getStage () const
+    int             getStage () const;
-    {
+    void            setStage (bool stage);
-        return pparams.inTrash;
-    }
-    void            setStage (bool stage)
-    {
-        if (pparams.inTrash != stage) {
-            pparams.inTrash = stage;
-            pparamsValid = true;
-        }
-    }
 
     void            addThumbnailListener (ThumbnailListener* tnl);
     void            removeThumbnailListener (ThumbnailListener* tnl);

rtgui/tonecurve.cc

@@ -347,33 +347,33 @@ void ToneCurve::write (ProcParams* pp, ParamsEdited* pedited)
     int tcMode = toneCurveMode->get_active_row_number();
 
     if      (tcMode == 0) {
-        pp->toneCurve.curveMode = ToneCurveParams::TcMode::STD;
+        pp->toneCurve.curveMode = ToneCurveMode::STD;
     } else if (tcMode == 1) {
-        pp->toneCurve.curveMode = ToneCurveParams::TcMode::WEIGHTEDSTD;
+        pp->toneCurve.curveMode = ToneCurveMode::WEIGHTEDSTD;
     } else if (tcMode == 2) {
-        pp->toneCurve.curveMode = ToneCurveParams::TcMode::FILMLIKE;
+        pp->toneCurve.curveMode = ToneCurveMode::FILMLIKE;
     } else if (tcMode == 3) {
-        pp->toneCurve.curveMode = ToneCurveParams::TcMode::SATANDVALBLENDING;
+        pp->toneCurve.curveMode = ToneCurveMode::SATANDVALBLENDING;
     } else if (tcMode == 4) {
-        pp->toneCurve.curveMode = ToneCurveParams::TcMode::LUMINANCE;
+        pp->toneCurve.curveMode = ToneCurveMode::LUMINANCE;
     } else if (tcMode == 5) {
-        pp->toneCurve.curveMode = ToneCurveParams::TcMode::PERCEPTUAL;
+        pp->toneCurve.curveMode = ToneCurveMode::PERCEPTUAL;
     }
 
     tcMode = toneCurveMode2->get_active_row_number();
 
     if      (tcMode == 0) {
-        pp->toneCurve.curveMode2 = ToneCurveParams::TcMode::STD;
+        pp->toneCurve.curveMode2 = ToneCurveMode::STD;
     } else if (tcMode == 1) {
-        pp->toneCurve.curveMode2 = ToneCurveParams::TcMode::WEIGHTEDSTD;
+        pp->toneCurve.curveMode2 = ToneCurveMode::WEIGHTEDSTD;
     } else if (tcMode == 2) {
-        pp->toneCurve.curveMode2 = ToneCurveParams::TcMode::FILMLIKE;
+        pp->toneCurve.curveMode2 = ToneCurveMode::FILMLIKE;
     } else if (tcMode == 3) {
-        pp->toneCurve.curveMode2 = ToneCurveParams::TcMode::SATANDVALBLENDING;
+        pp->toneCurve.curveMode2 = ToneCurveMode::SATANDVALBLENDING;
     } else if (tcMode == 4) {
-        pp->toneCurve.curveMode2 = ToneCurveParams::TcMode::LUMINANCE;
+        pp->toneCurve.curveMode2 = ToneCurveMode::LUMINANCE;
     } else if (tcMode == 5) {
-        pp->toneCurve.curveMode2 = ToneCurveParams::TcMode::PERCEPTUAL;
+        pp->toneCurve.curveMode2 = ToneCurveMode::PERCEPTUAL;
     }
 
     pp->toneCurve.histmatching = histmatching->get_active();
@@ -979,7 +979,7 @@ void ToneCurve::autoExpChanged(double expcomp, int bright, int contr, int black,
     );
 }
 
-void ToneCurve::autoMatchedToneCurveChanged(rtengine::procparams::ToneCurveParams::TcMode curveMode, const std::vector<double>& curve)
+void ToneCurve::autoMatchedToneCurveChanged(rtengine::procparams::ToneCurveMode curveMode, const std::vector<double>& curve)
 {
     nextToneCurveMode = curveMode;
     nextToneCurve = curve;

rtgui/tonecurve.h

@@ -81,7 +81,7 @@ protected:
     int nextHlcompr;
     int nextHlcomprthresh;
     bool nextHLRecons;
-    rtengine::procparams::ToneCurveParams::TcMode nextToneCurveMode;
+    rtengine::procparams::ToneCurveMode nextToneCurveMode;
     std::vector<double> nextToneCurve;
 
     void setHistmatching(bool enabled);
@@ -132,7 +132,7 @@ public:
     void histmatchingToggled();
 
     void autoExpChanged(double expcomp, int bright, int contr, int black, int hlcompr, int hlcomprthresh, bool hlrecons) override;
-    void autoMatchedToneCurveChanged(rtengine::procparams::ToneCurveParams::TcMode curveMode, const std::vector<double>& curve) override;
+    void autoMatchedToneCurveChanged(rtengine::procparams::ToneCurveMode curveMode, const std::vector<double>& curve) override;
 
     void setRaw (bool raw);