diff --git a/rtgui/controlspotpanel.cc b/rtgui/controlspotpanel.cc
index bdf723992..4bab0da9c 100644
--- a/rtgui/controlspotpanel.cc
+++ b/rtgui/controlspotpanel.cc
@@ -703,6 +703,9 @@ void ControlSpotPanel::on_button_rename()
             row[spots_.name] = newname;
             treeview_->columns_autosize();
             listener->panelChanged(EvLocallabSpotName, newname);
+            if (controlPanelListener) {
+                controlPanelListener->spotNameChanged(newname);
+            }
         }
     }
 }
diff --git a/rtgui/controlspotpanel.h b/rtgui/controlspotpanel.h
index b748df544..3854692fd 100644
--- a/rtgui/controlspotpanel.h
+++ b/rtgui/controlspotpanel.h
@@ -34,6 +34,7 @@ public:
     virtual ~ControlPanelListener() {};
 
     virtual void resetToolMaskView() = 0;
+    virtual void spotNameChanged(const Glib::ustring &newName) = 0;
 };
 
 
diff --git a/rtgui/locallab.cc b/rtgui/locallab.cc
index 6f59d3b0f..40222e4e2 100644
--- a/rtgui/locallab.cc
+++ b/rtgui/locallab.cc
@@ -356,6 +356,7 @@ void Locallab::read(const rtengine::procparams::ProcParams* pp, const ParamsEdit
     // Select active spot
     if (pp->locallab.spots.size() > 0) {
         expsettings->setSelectedSpot(pp->locallab.selspot);
+        spotName = pp->locallab.spots.at(pp->locallab.selspot).name;
     }
 
     // Update each Locallab tools GUI
@@ -542,6 +543,8 @@ void Locallab::write(rtengine::procparams::ProcParams* pp, ParamsEdited* pedited
             // Update Locallab tools GUI with new created spot
             disableListener();
 
+            spotName = pp->locallab.spots.at(pp->locallab.selspot).name;
+
             for (auto tool : locallabTools) {
                 tool->read(pp, pedited);
             }
@@ -598,6 +601,10 @@ void Locallab::write(rtengine::procparams::ProcParams* pp, ParamsEdited* pedited
                     // Update Locallab tools GUI with selected spot
                     disableListener();
 
+                    if (pp->locallab.spots.size() > 0) {
+                        spotName = pp->locallab.spots.at(pp->locallab.selspot).name;
+                    }
+
                     for (auto tool : locallabTools) {
                         tool->read(pp, pedited);
                     }
@@ -638,6 +645,10 @@ void Locallab::write(rtengine::procparams::ProcParams* pp, ParamsEdited* pedited
             expsettings->setSelectedSpot(pp->locallab.selspot);
             disableListener();
 
+            if (pp->locallab.spots.size() > 0) {
+                spotName = pp->locallab.spots.at(pp->locallab.selspot).name;
+            }
+
             for (auto tool : locallabTools) {
                 tool->read(pp, pedited);
             }
@@ -842,6 +853,8 @@ void Locallab::write(rtengine::procparams::ProcParams* pp, ParamsEdited* pedited
             // Update Locallab tools GUI with new created spot
             disableListener();
 
+            spotName = pp->locallab.spots.at(pp->locallab.selspot).name;
+
             for (auto tool : locallabTools) {
                 tool->read(pp, pedited);
             }
@@ -1180,12 +1193,18 @@ void Locallab::updateShowtooltipVisibility(bool showtooltip)
     }
 }
 
+void Locallab::spotNameChanged(const Glib::ustring &newName)
+{
+    spotName = newName;
+}
+
 void Locallab::addTool(Gtk::Box* where, LocallabTool* tool)
 {
     tool->getExpander()->setLevel(3);
     where->pack_start(*tool->getExpander(), false, false);
     locallabTools.push_back(tool);
     tool->setLocallabToolListener(this);
+    tool->setSpotNameSource(&spotName);
 }
 
 void Locallab::setParamEditable(bool cond)
diff --git a/rtgui/locallab.h b/rtgui/locallab.h
index 1c3c06167..ab1c9d7dc 100644
--- a/rtgui/locallab.h
+++ b/rtgui/locallab.h
@@ -128,6 +128,8 @@ private:
     // Other widgets
     Gtk::Button* const resetshowButton;
 
+    Glib::ustring spotName;
+
 public:
     Locallab();
 
@@ -200,6 +202,7 @@ private:
 
     // ControlSpotListener function
     void resetToolMaskView() override;
+    void spotNameChanged(const Glib::ustring &newName) override;
 
     // LocallabToolListener function
     void resetOtherMaskView(LocallabTool* current) override;
diff --git a/rtgui/locallabtools.cc b/rtgui/locallabtools.cc
index 14a3a43c4..8d3c34204 100644
--- a/rtgui/locallabtools.cc
+++ b/rtgui/locallabtools.cc
@@ -184,6 +184,14 @@ LocallabTool::~LocallabTool()
     idle_register.destroy();
 }
 
+Glib::ustring LocallabTool::getSpotName() const
+{
+    if (spotNameSource) {
+        return *spotNameSource;
+    }
+    return "";
+}
+
 void LocallabTool::addLocallabTool(bool raiseEvent)
 {
     exp->set_visible(true);
@@ -218,7 +226,7 @@ void LocallabTool::addLocallabTool(bool raiseEvent)
 
         if (listener) {
             listener->panelChanged(EvlocallabToolAdded,
-                                   toolName + " (" + escapeHtmlChars(spotName) + ")");
+                                   toolName + " (" + escapeHtmlChars(getSpotName()) + ")");
         }
     }
 }
@@ -242,13 +250,13 @@ void LocallabTool::removeLocallabTool(bool raiseEvent)
         // Raise event if required refreshing image
         if (raiseEvent && listener) {
             listener->panelChanged(EvlocallabToolRemovedWithRefresh,
-                                   toolName + " (" + escapeHtmlChars(spotName) + ")");
+                                   toolName + " (" + escapeHtmlChars(getSpotName()) + ")");
         }
     } else {
         // Raise event if required without refreshing image
         if (raiseEvent && listener) {
             listener->panelChanged(EvlocallabToolRemovedWithoutRefresh,
-                                   toolName + " (" + escapeHtmlChars(spotName) + ")");
+                                   toolName + " (" + escapeHtmlChars(getSpotName()) + ")");
         }
     }
 }
@@ -387,7 +395,7 @@ void LocallabTool::complexityModeChanged()
 
         if (listener && isLocActivated) {
             listener->panelChanged(EvlocallabcomplexityWithRefresh,
-                                   M("TP_LOCALLAB_MODE_SIMPLE") + " (" + escapeHtmlChars(spotName) + ")");
+                                   M("TP_LOCALLAB_MODE_SIMPLE") + " (" + escapeHtmlChars(getSpotName()) + ")");
         }
     } else if (complexity->get_active_row_number() == Normal) { // New selected mode is Normal one
         // Convert tool widget parameters
@@ -397,7 +405,7 @@ void LocallabTool::complexityModeChanged()
 
         if (listener && isLocActivated) {
             listener->panelChanged(EvlocallabcomplexityWithRefresh,
-                                   M("TP_LOCALLAB_MODE_NORMAL") + " (" + escapeHtmlChars(spotName) + ")");
+                                   M("TP_LOCALLAB_MODE_NORMAL") + " (" + escapeHtmlChars(getSpotName()) + ")");
         }
     } else if (complexity->get_active_row_number() == Expert) { // New selected mode is Expert one
         // Update GUI based on new mode
@@ -405,7 +413,7 @@ void LocallabTool::complexityModeChanged()
 
         if (listener && isLocActivated) {
             listener->panelChanged(EvlocallabcomplexityWithRefresh,
-                                   M("TP_LOCALLAB_MODE_EXPERT") + " (" + escapeHtmlChars(spotName) + ")");
+                                   M("TP_LOCALLAB_MODE_EXPERT") + " (" + escapeHtmlChars(getSpotName()) + ")");
         }
     }
 }
@@ -1124,8 +1132,6 @@ void LocallabColor::read(const rtengine::procparams::ProcParams* pp, const Param
     if (index < (int)pp->locallab.spots.size()) {
         const LocallabParams::LocallabSpot& spot = pp->locallab.spots.at(index);
 
-        spotName = spot.name; // Update spot name according to selected spot
-
         exp->set_visible(spot.visicolor);
         exp->setEnabled(spot.expcolor);
         complexity->set_active(spot.complexcolor);
@@ -1525,63 +1531,63 @@ void LocallabColor::adjusterChanged(Adjuster* a, double newval)
         if (a == lightness) {
             if (listener) {
                 listener->panelChanged(Evlocallablightness,
-                                       lightness->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       lightness->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == reparcol) {
             if (listener) {
                 listener->panelChanged(Evlocallabreparcol,
-                                       reparcol->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       reparcol->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == contrast) {
             if (listener) {
                 listener->panelChanged(Evlocallabcontrast,
-                                       contrast->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       contrast->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == chroma) {
             if (listener) {
                 listener->panelChanged(Evlocallabchroma,
-                                       chroma->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       chroma->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == strengthgrid) {
             if (listener) {
                 listener->panelChanged(EvLocallabLabstrengthgrid,
-                                       strengthgrid->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       strengthgrid->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == sensi) {
             if (listener) {
                 listener->panelChanged(Evlocallabsensi,
-                                       sensi->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       sensi->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == structcol) {
             if (listener) {
                 listener->panelChanged(Evlocallabstructcol,
-                                       structcol->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       structcol->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == blurcolde) {
             if (listener) {
                 listener->panelChanged(Evlocallabblurcolde,
-                                       blurcolde->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       blurcolde->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == softradiuscol) {
             if (listener) {
                 listener->panelChanged(Evlocallabsoftradiuscol,
-                                       softradiuscol->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       softradiuscol->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
@@ -1589,28 +1595,28 @@ void LocallabColor::adjusterChanged(Adjuster* a, double newval)
             
             if (listener) {
                 listener->panelChanged(Evlocallabrecothresc,
-                                       recothresc->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       recothresc->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == lowthresc) {
             if (listener) {
                 listener->panelChanged(Evlocallablowthresc,
-                                       lowthresc->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       lowthresc->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == higthresc) {
             if (listener) {
                 listener->panelChanged(Evlocallabhigthresc,
-                                       higthresc->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       higthresc->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == decayc) {
             if (listener) {
                 listener->panelChanged(Evlocallabdecayc,
-                                       decayc->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       decayc->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
@@ -1618,126 +1624,126 @@ void LocallabColor::adjusterChanged(Adjuster* a, double newval)
         if (a == strcol) {
             if (listener) {
                 listener->panelChanged(Evlocallabstrcol,
-                                       strcol->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       strcol->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == strcolab) {
             if (listener) {
                 listener->panelChanged(Evlocallabstrcolab,
-                                       strcolab->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       strcolab->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == strcolh) {
             if (listener) {
                 listener->panelChanged(Evlocallabstrcolh,
-                                       strcolh->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       strcolh->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == angcol) {
             if (listener) {
                 listener->panelChanged(Evlocallabangcol,
-                                       angcol->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       angcol->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == mercol) {
             if (listener) {
                 listener->panelChanged(Evlocallabmercol,
-                                       mercol->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       mercol->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == opacol) {
             if (listener) {
                 listener->panelChanged(Evlocallabopacol,
-                                       opacol->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       opacol->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == conthrcol) {
             if (listener) {
                 listener->panelChanged(Evlocallabconthrcol,
-                                       conthrcol->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       conthrcol->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == merlucol) {
             if (listener) {
                 listener->panelChanged(Evlocallabmerlucol,
-                                       merlucol->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       merlucol->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == strumaskcol) {
             if (listener) {
                 listener->panelChanged(Evlocallabstrumaskcol,
-                                       strumaskcol->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       strumaskcol->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == contcol) {
             if (listener) {
                 listener->panelChanged(Evlocallabcontcol,
-                                       contcol->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       contcol->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == blurcol) {
             if (listener) {
                 listener->panelChanged(Evlocallabblurcol,
-                                       blurcol->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       blurcol->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == blendmaskcol) {
             if (listener) {
                 listener->panelChanged(Evlocallabblendmaskcol,
-                                       blendmaskcol->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       blendmaskcol->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == radmaskcol) {
             if (listener) {
                 listener->panelChanged(Evlocallabradmaskcol,
-                                       radmaskcol->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       radmaskcol->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == lapmaskcol) {
             if (listener) {
                 listener->panelChanged(Evlocallablapmaskcol,
-                                       lapmaskcol->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       lapmaskcol->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == chromaskcol) {
             if (listener) {
                 listener->panelChanged(Evlocallabchromaskcol,
-                                       chromaskcol->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       chromaskcol->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == gammaskcol) {
             if (listener) {
                 listener->panelChanged(Evlocallabgammaskcol,
-                                       gammaskcol->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       gammaskcol->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == slomaskcol) {
             if (listener) {
                 listener->panelChanged(Evlocallabslomaskcol,
-                                       slomaskcol->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       slomaskcol->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == shadmaskcol) {
             if (listener) {
                 listener->panelChanged(Evlocallabshadmaskcol,
-                                       shadmaskcol->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       shadmaskcol->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -1749,7 +1755,7 @@ void LocallabColor::adjusterChanged2(ThresholdAdjuster* a, int newBottomL, int n
         if (a == csThresholdcol) {
             if (listener) {
                 listener->panelChanged(EvlocallabcsThresholdcol,
-                                       csThresholdcol->getHistoryString() + " (" + escapeHtmlChars(spotName) + ")");
+                                       csThresholdcol->getHistoryString() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -1761,98 +1767,98 @@ void LocallabColor::curveChanged(CurveEditor* ce)
         if (ce == llshape) {
             if (listener) {
                 listener->panelChanged(Evlocallabllshape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == ccshape) {
             if (listener) {
                 listener->panelChanged(Evlocallabccshape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == clshape) {
             if (listener) {
                 listener->panelChanged(Evlocallabclshape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == lcshape) {
             if (listener) {
                 listener->panelChanged(Evlocallablcshape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == LHshape) {
             if (listener) {
                 listener->panelChanged(EvlocallabLHshape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == CHshape) {
             if (listener) {
                 listener->panelChanged(EvlocallabCHshape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == HHshape) {
             if (listener) {
                 listener->panelChanged(EvlocallabHHshape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == rgbshape) {
             if (listener) {
                 listener->panelChanged(Evlocallabrgbshape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == CCmaskshape) {
             if (listener) {
                 listener->panelChanged(EvlocallabCCmaskshape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == LLmaskshape) {
             if (listener) {
                 listener->panelChanged(EvlocallabLLmaskshape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == HHmaskshape) {
             if (listener) {
                 listener->panelChanged(EvlocallabHHmaskshape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == HHhmaskshape) {
             if (listener) {
                 listener->panelChanged(EvlocallabHHhmaskshape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == Lmaskshape) {
             if (listener) {
                 listener->panelChanged(EvlocallabLmaskshape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == LLmaskcolshapewav) {
             if (listener) {
                 listener->panelChanged(EvlocallabLLmaskcolshapewav,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -1864,10 +1870,10 @@ void LocallabColor::enabledChanged()
         if (listener) {
             if (exp->getEnabled()) {
                 listener->panelChanged(EvLocenacolor,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(EvLocenacolor,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -2180,10 +2186,10 @@ void LocallabColor::curvactivChanged()
         if (listener) {
             if (curvactiv->get_active()) {
                 listener->panelChanged(Evlocallabcurvactiv,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(Evlocallabcurvactiv,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -2194,7 +2200,7 @@ void LocallabColor::gridMethodChanged()
     if (isLocActivated && exp->getEnabled()) {
         if (listener) {
             listener->panelChanged(EvLocallabgridMethod,
-                                   gridMethod->get_active_text() + " (" + escapeHtmlChars(spotName) + ")");
+                                   gridMethod->get_active_text() + " (" + escapeHtmlChars(getSpotName()) + ")");
         }
     }
 }
@@ -2217,10 +2223,10 @@ void LocallabColor::inversChanged()
         if (listener) {
             if (invers->get_active()) {
                 listener->panelChanged(Evlocallabinvers,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(Evlocallabinvers,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -2231,7 +2237,7 @@ void LocallabColor::qualitycurveMethodChanged()
     if (isLocActivated && exp->getEnabled()) {
         if (listener) {
             listener->panelChanged(EvlocallabqualitycurveMethod,
-                                   qualitycurveMethod->get_active_text() + " (" + escapeHtmlChars(spotName) + ")");
+                                   qualitycurveMethod->get_active_text() + " (" + escapeHtmlChars(getSpotName()) + ")");
         }
     }
 }
@@ -2241,7 +2247,7 @@ void LocallabColor::toneMethodChanged()
     if (isLocActivated && exp->getEnabled()) {
         if (listener) {
             listener->panelChanged(EvLocallabtoneMethod,
-                                   toneMethod->get_active_text() + " (" + escapeHtmlChars(spotName) + ")");
+                                   toneMethod->get_active_text() + " (" + escapeHtmlChars(getSpotName()) + ")");
         }
     }
 }
@@ -2252,10 +2258,10 @@ void LocallabColor::specialChanged()
         if (listener) {
             if (special->get_active()) {
                 listener->panelChanged(EvLocallabspecial,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(EvLocallabspecial,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -2268,7 +2274,7 @@ void LocallabColor::merMethodChanged()
     if (isLocActivated && exp->getEnabled()) {
         if (listener) {
             listener->panelChanged(EvLocallabmerMethod,
-                                   merMethod->get_active_text() + " (" + escapeHtmlChars(spotName) + ")");
+                                   merMethod->get_active_text() + " (" + escapeHtmlChars(getSpotName()) + ")");
         }
     }
 }
@@ -2278,7 +2284,7 @@ void LocallabColor::mergecolMethodChanged()
     if (isLocActivated && exp->getEnabled()) {
         if (listener) {
             listener->panelChanged(EvLocallabmergecolMethod,
-                                   mergecolMethod->get_active_text() + " (" + escapeHtmlChars(spotName) + ")");
+                                   mergecolMethod->get_active_text() + " (" + escapeHtmlChars(getSpotName()) + ")");
         }
     }
 }
@@ -2334,10 +2340,10 @@ void LocallabColor::enaColorMaskChanged()
         if (listener) {
             if (enaColorMask->get_active()) {
                 listener->panelChanged(EvLocallabEnaColorMask,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(EvLocallabEnaColorMask,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -2349,10 +2355,10 @@ void LocallabColor::toolcolChanged()
         if (listener) {
             if (toolcol->get_active()) {
                 listener->panelChanged(EvLocallabtoolcol,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(EvLocallabtoolcol,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -2366,10 +2372,10 @@ void LocallabColor::fftColorMaskChanged()
         if (listener) {
             if (fftColorMask->get_active()) {
                 listener->panelChanged(EvLocallabfftColorMask,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(EvLocallabfftColorMask,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -2963,8 +2969,6 @@ void LocallabExposure::read(const rtengine::procparams::ProcParams* pp, const Pa
     if (index < (int)pp->locallab.spots.size()) {
         const LocallabParams::LocallabSpot& spot = pp->locallab.spots.at(index);
 
-        spotName = spot.name; // Update spot name according to selected spot
-
         exp->set_visible(spot.visiexpose);
         exp->setEnabled(spot.expexpose);
         complexity->set_active(spot.complexexpose);
@@ -3182,238 +3186,238 @@ void LocallabExposure::adjusterChanged(Adjuster* a, double newval)
         if (a == laplacexp) {
             if (listener) {
                 listener->panelChanged(Evlocallablaplacexp,
-                                       laplacexp->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       laplacexp->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == reparexp) {
             if (listener) {
                 listener->panelChanged(Evlocallabreparexp,
-                                       reparexp->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       reparexp->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == linear) {
             if (listener) {
                 listener->panelChanged(Evlocallablinear,
-                                       linear->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       linear->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == balanexp) {
             if (listener) {
                 listener->panelChanged(Evlocallabbalanexp,
-                                       balanexp->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       balanexp->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == gamm) {
             if (listener) {
                 listener->panelChanged(Evlocallabgamm,
-                                       gamm->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       gamm->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == fatamount) {
             if (listener) {
                 listener->panelChanged(Evlocallabfatamount,
-                                       fatamount->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       fatamount->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == fatdetail) {
             if (listener) {
                 listener->panelChanged(Evlocallabfatdetail,
-                                       fatdetail->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       fatdetail->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == fatlevel) {
             if (listener) {
                 listener->panelChanged(Evlocallabfatlevel,
-                                       fatlevel->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       fatlevel->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == fatanchor) {
             if (listener) {
                 listener->panelChanged(Evlocallabfatanchor,
-                                       fatanchor->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       fatanchor->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == recothrese) {
             if (listener) {
                 listener->panelChanged(Evlocallabrecothrese,
-                                       recothrese->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       recothrese->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == lowthrese) {
             if (listener) {
                 listener->panelChanged(Evlocallablowthrese,
-                                       lowthrese->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       lowthrese->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == higthrese) {
             if (listener) {
                 listener->panelChanged(Evlocallabhigthrese,
-                                       higthrese->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       higthrese->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == decaye) {
             if (listener) {
                 listener->panelChanged(Evlocallabdecaye,
-                                       decaye->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       decaye->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == sensiex) {
             if (listener) {
                 listener->panelChanged(Evlocallabsensiex,
-                                       sensiex->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       sensiex->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == structexp) {
             if (listener) {
                 listener->panelChanged(Evlocallabstructexp,
-                                       structexp->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       structexp->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == blurexpde) {
             if (listener) {
                 listener->panelChanged(Evlocallabblurexpde,
-                                       blurexpde->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       blurexpde->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == expcomp) {
             if (listener) {
                 listener->panelChanged(Evlocallabexpcomp,
-                                       expcomp->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       expcomp->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == black) {
             if (listener) {
                 listener->panelChanged(Evlocallabblack,
-                                       black->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       black->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == hlcompr) {
             if (listener) {
                 listener->panelChanged(Evlocallabhlcompr,
-                                       hlcompr->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       hlcompr->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == hlcomprthresh) {
             if (listener) {
                 listener->panelChanged(Evlocallabhlcomprthresh,
-                                       hlcomprthresh->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       hlcomprthresh->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == shadex) {
             if (listener) {
                 listener->panelChanged(Evlocallabshadex,
-                                       shadex->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       shadex->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == shcompr) {
             if (listener) {
                 listener->panelChanged(Evlocallabshcompr,
-                                       shcompr->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       shcompr->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == expchroma) {
             if (listener) {
                 listener->panelChanged(Evlocallabexpchroma,
-                                       expchroma->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       expchroma->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == strexp) {
             if (listener) {
                 listener->panelChanged(Evlocallabstrexp,
-                                       strexp->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       strexp->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == angexp) {
             if (listener) {
                 listener->panelChanged(Evlocallabangexp,
-                                       angexp->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       angexp->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == softradiusexp) {
             if (listener) {
                 listener->panelChanged(Evlocallabsoftradiusexp,
-                                       softradiusexp->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       softradiusexp->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == blendmaskexp) {
             if (listener) {
                 listener->panelChanged(Evlocallabblendmaskexp,
-                                       blendmaskexp->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       blendmaskexp->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == radmaskexp) {
             if (listener) {
                 listener->panelChanged(Evlocallabradmaskexp,
-                                       radmaskexp->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       radmaskexp->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == lapmaskexp) {
             if (listener) {
                 listener->panelChanged(Evlocallablapmaskexp,
-                                       lapmaskexp->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       lapmaskexp->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == chromaskexp) {
             if (listener) {
                 listener->panelChanged(Evlocallabchromaskexp,
-                                       chromaskexp->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       chromaskexp->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == gammaskexp) {
             if (listener) {
                 listener->panelChanged(Evlocallabgammaskexp,
-                                       gammaskexp->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       gammaskexp->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == slomaskexp) {
             if (listener) {
                 listener->panelChanged(Evlocallabslomaskexp,
-                                       slomaskexp->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       slomaskexp->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == strmaskexp) {
             if (listener) {
                 listener->panelChanged(Evlocallabstrmaskexp,
-                                       strmaskexp->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       strmaskexp->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == angmaskexp) {
             if (listener) {
                 listener->panelChanged(Evlocallabangmaskexp,
-                                       angmaskexp->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       angmaskexp->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -3425,35 +3429,35 @@ void LocallabExposure::curveChanged(CurveEditor* ce)
         if (ce == shapeexpos) {
             if (listener) {
                 listener->panelChanged(Evlocallabshapeexpos,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == CCmaskexpshape) {
             if (listener) {
                 listener->panelChanged(EvlocallabCCmaskexpshape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == LLmaskexpshape) {
             if (listener) {
                 listener->panelChanged(EvlocallabLLmaskexpshape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == HHmaskexpshape) {
             if (listener) {
                 listener->panelChanged(EvlocallabHHmaskexpshape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == Lmaskexpshape) {
             if (listener) {
                 listener->panelChanged(EvlocallabLmaskexpshape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -3465,10 +3469,10 @@ void LocallabExposure::enabledChanged()
         if (listener) {
             if (exp->getEnabled()) {
                 listener->panelChanged(EvLocenaexpose,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(EvLocenaexpose,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -3649,7 +3653,7 @@ void LocallabExposure::expMethodChanged()
     if (isLocActivated && exp->getEnabled()) {
         if (listener) {
             listener->panelChanged(EvlocallabexpMethod,
-                                   expMethod->get_active_text() + " (" + escapeHtmlChars(spotName) + ")");
+                                   expMethod->get_active_text() + " (" + escapeHtmlChars(getSpotName()) + ")");
         }
     }
 }
@@ -3659,7 +3663,7 @@ void LocallabExposure::exnoiseMethodChanged()
     if (isLocActivated && exp->getEnabled()) {
         if (listener) {
             listener->panelChanged(EvlocallabexnoiseMethod,
-                                   exnoiseMethod->get_active_text() + " (" + escapeHtmlChars(spotName) + ")");
+                                   exnoiseMethod->get_active_text() + " (" + escapeHtmlChars(getSpotName()) + ")");
         }
     }
 }
@@ -3671,10 +3675,10 @@ void LocallabExposure::normChanged()
         if (listener) {
             if (norm->get_active()) {
                 listener->panelChanged(Evlocallabnorm,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(Evlocallabnorm,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -3699,10 +3703,10 @@ void LocallabExposure::inversexChanged()
         if (listener) {
             if (inversex->get_active()) {
                 listener->panelChanged(Evlocallabinversex,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(Evlocallabinversex,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -3760,10 +3764,10 @@ void LocallabExposure::enaExpMaskChanged()
         if (listener) {
             if (enaExpMask->get_active()) {
                 listener->panelChanged(EvLocallabEnaExpMask,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(EvLocallabEnaExpMask,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -3775,10 +3779,10 @@ void LocallabExposure::enaExpMaskaftChanged()
         if (listener) {
             if (enaExpMaskaft->get_active()) {
                 listener->panelChanged(EvLocallabEnaExpMaskaft,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(EvLocallabEnaExpMaskaft,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -4273,8 +4277,6 @@ void LocallabShadow::read(const rtengine::procparams::ProcParams* pp, const Para
     if (index < (int)pp->locallab.spots.size()) {
         const LocallabParams::LocallabSpot& spot = pp->locallab.spots.at(index);
 
-        spotName = spot.name; // Update spot name according to selected spot
-
         exp->set_visible(spot.visishadhigh);
         exp->setEnabled(spot.expshadhigh);
         complexity->set_active(spot.complexshadhigh);
@@ -4447,56 +4449,56 @@ void LocallabShadow::adjusterChanged(Adjuster* a, double newval)
                                                Glib::ustring::format(std::fixed, std::setprecision(2), multipliersh[1]->getIntValue()),
                                                Glib::ustring::format(std::fixed, std::setprecision(2), multipliersh[2]->getIntValue()),
                                                Glib::ustring::format(std::fixed, std::setprecision(2), multipliersh[3]->getIntValue()),
-                                               Glib::ustring::format(std::fixed, std::setprecision(2), multipliersh[4]->getIntValue())) + " (" + escapeHtmlChars(spotName) + ")");
+                                               Glib::ustring::format(std::fixed, std::setprecision(2), multipliersh[4]->getIntValue())) + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == detailSH) {
             if (listener) {
                 listener->panelChanged(EvlocallabdetailSH,
-                                       detailSH->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       detailSH->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == reparsh) {
             if (listener) {
                 listener->panelChanged(Evlocallabreparsh,
-                                       reparsh->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       reparsh->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == highlights) {
             if (listener) {
                 listener->panelChanged(Evlocallabhighlights,
-                                       highlights->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       highlights->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == h_tonalwidth) {
             if (listener) {
                 listener->panelChanged(Evlocallabh_tonalwidth,
-                                       h_tonalwidth->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       h_tonalwidth->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == shadows) {
             if (listener) {
                 listener->panelChanged(Evlocallabshadows,
-                                       shadows->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       shadows->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == s_tonalwidth) {
             if (listener) {
                 listener->panelChanged(Evlocallabs_tonalwidth,
-                                       s_tonalwidth->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       s_tonalwidth->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == sh_radius) {
             if (listener) {
                 listener->panelChanged(Evlocallabsh_radius,
-                                       sh_radius->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       sh_radius->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
@@ -4504,28 +4506,28 @@ void LocallabShadow::adjusterChanged(Adjuster* a, double newval)
             
             if (listener) {
                 listener->panelChanged(Evlocallabrecothress,
-                                       recothress->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       recothress->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == lowthress) {
             if (listener) {
                 listener->panelChanged(Evlocallablowthress,
-                                       lowthress->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       lowthress->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == higthress) {
             if (listener) {
                 listener->panelChanged(Evlocallabhigthress,
-                                       higthress->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       higthress->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == decays) {
             if (listener) {
                 listener->panelChanged(Evlocallabdecays,
-                                       decays->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       decays->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
@@ -4533,91 +4535,91 @@ void LocallabShadow::adjusterChanged(Adjuster* a, double newval)
         if (a == sensihs) {
             if (listener) {
                 listener->panelChanged(Evlocallabsensihs,
-                                       sensihs->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       sensihs->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == blurSHde) {
             if (listener) {
                 listener->panelChanged(EvlocallabblurSHde,
-                                       blurSHde->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       blurSHde->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == gamSH) {
             if (listener) {
                 listener->panelChanged(EvlocallabgamSH,
-                                       gamSH->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       gamSH->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == sloSH) {
             if (listener) {
                 listener->panelChanged(EvlocallabsloSH,
-                                       sloSH->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       sloSH->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == strSH) {
             if (listener) {
                 listener->panelChanged(EvlocallabstrSH,
-                                       strSH->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       strSH->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == angSH) {
             if (listener) {
                 listener->panelChanged(EvlocallabangSH,
-                                       angSH->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       angSH->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == blendmaskSH) {
             if (listener) {
                 listener->panelChanged(EvlocallabblendmaskSH,
-                                       blendmaskSH->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       blendmaskSH->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == radmaskSH) {
             if (listener) {
                 listener->panelChanged(EvlocallabradmaskSH,
-                                       radmaskSH->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       radmaskSH->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == lapmaskSH) {
             if (listener) {
                 listener->panelChanged(EvlocallablapmaskSH,
-                                       lapmaskSH->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       lapmaskSH->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == chromaskSH) {
             if (listener) {
                 listener->panelChanged(EvlocallabchromaskSH,
-                                       chromaskSH->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       chromaskSH->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == gammaskSH) {
             if (listener) {
                 listener->panelChanged(EvlocallabgammaskSH,
-                                       gammaskSH->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       gammaskSH->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == slomaskSH) {
             if (listener) {
                 listener->panelChanged(EvlocallabslomaskSH,
-                                       slomaskSH->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       slomaskSH->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == fatamountSH) {
             if (listener) {
                 listener->panelChanged(EvlocallabfatamountSH,
-                                       fatamountSH->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       fatamountSH->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
@@ -4625,7 +4627,7 @@ void LocallabShadow::adjusterChanged(Adjuster* a, double newval)
         if (a == fatanchorSH) {
             if (listener) {
                 listener->panelChanged(EvlocallabfatanchorSH,
-                                       fatanchorSH->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       fatanchorSH->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -4637,28 +4639,28 @@ void LocallabShadow::curveChanged(CurveEditor* ce)
         if (ce == CCmaskSHshape) {
             if (listener) {
                 listener->panelChanged(EvlocallabCCmaskSHshape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == LLmaskSHshape) {
             if (listener) {
                 listener->panelChanged(EvlocallabLLmaskSHshape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == HHmaskSHshape) {
             if (listener) {
                 listener->panelChanged(EvlocallabHHmaskSHshape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == LmaskSHshape) {
             if (listener) {
                 listener->panelChanged(EvlocallabLmaskSHshape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -4670,10 +4672,10 @@ void LocallabShadow::enabledChanged()
         if (listener) {
             if (exp->getEnabled()) {
                 listener->panelChanged(EvLocenashadhigh,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(EvLocenashadhigh,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -4837,7 +4839,7 @@ void LocallabShadow::shMethodChanged()
     if (isLocActivated && exp->getEnabled()) {
         if (listener) {
             listener->panelChanged(EvlocallabshMethod,
-                                   shMethod->get_active_text() + " (" + escapeHtmlChars(spotName) + ")");
+                                   shMethod->get_active_text() + " (" + escapeHtmlChars(getSpotName()) + ")");
         }
     }
 }
@@ -4860,10 +4862,10 @@ void LocallabShadow::inversshChanged()
         if (listener) {
             if (inverssh->get_active()) {
                 listener->panelChanged(Evlocallabinverssh,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(Evlocallabinverssh,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -4922,10 +4924,10 @@ void LocallabShadow::enaSHMaskChanged()
         if (listener) {
             if (enaSHMask->get_active()) {
                 listener->panelChanged(EvLocallabEnaSHMask,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(EvLocallabEnaSHMask,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -5333,8 +5335,6 @@ void LocallabVibrance::read(const rtengine::procparams::ProcParams* pp, const Pa
     if (index < (int)pp->locallab.spots.size()) {
         const LocallabParams::LocallabSpot& spot = pp->locallab.spots.at(index);
 
-        spotName = spot.name; // Update spot name according to selected spot
-
         exp->set_visible(spot.visivibrance);
         exp->setEnabled(spot.expvibrance);
         complexity->set_active(spot.complexvibrance);
@@ -5468,28 +5468,28 @@ void LocallabVibrance::adjusterChanged(Adjuster* a, double newval)
         if (a == saturated && !pastSatTog->get_active()) {
             if (listener) {
                 listener->panelChanged(EvlocallabSaturated,
-                                       saturated->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       saturated->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == pastels) {
             if (listener) {
                 listener->panelChanged(EvlocallabPastels,
-                                       pastels->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       pastels->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == warm) {
             if (listener) {
                 listener->panelChanged(Evlocallabwarm,
-                                       warm->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       warm->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == sensiv) {
             if (listener) {
                 listener->panelChanged(Evlocallabsensiv,
-                                       sensiv->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       sensiv->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
@@ -5497,98 +5497,98 @@ void LocallabVibrance::adjusterChanged(Adjuster* a, double newval)
             
             if (listener) {
                 listener->panelChanged(Evlocallabrecothresv,
-                                       recothresv->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       recothresv->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == lowthresv) {
             if (listener) {
                 listener->panelChanged(Evlocallablowthresv,
-                                       lowthresv->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       lowthresv->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == higthresv) {
             if (listener) {
                 listener->panelChanged(Evlocallabhigthresv,
-                                       higthresv->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       higthresv->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == decayv) {
             if (listener) {
                 listener->panelChanged(Evlocallabdecayv,
-                                       decayv->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       decayv->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == strvib) {
             if (listener) {
                 listener->panelChanged(Evlocallabstrvib,
-                                       strvib->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       strvib->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == strvibab) {
             if (listener) {
                 listener->panelChanged(Evlocallabstrvibab,
-                                       strvibab->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       strvibab->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == strvibh) {
             if (listener) {
                 listener->panelChanged(Evlocallabstrvibh,
-                                       strvibh->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       strvibh->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == angvib) {
             if (listener) {
                 listener->panelChanged(Evlocallabangvib,
-                                       angvib->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       angvib->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == blendmaskvib) {
             if (listener) {
                 listener->panelChanged(Evlocallabblendmaskvi,
-                                       blendmaskvib->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       blendmaskvib->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == radmaskvib) {
             if (listener) {
                 listener->panelChanged(Evlocallabradmaskvib,
-                                       radmaskvib->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       radmaskvib->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == lapmaskvib) {
             if (listener) {
                 listener->panelChanged(Evlocallablapmaskvib,
-                                       lapmaskvib->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       lapmaskvib->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == chromaskvib) {
             if (listener) {
                 listener->panelChanged(Evlocallabchromaskvib,
-                                       chromaskvib->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       chromaskvib->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == gammaskvib) {
             if (listener) {
                 listener->panelChanged(Evlocallabgammaskvib,
-                                       gammaskvib->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       gammaskvib->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == slomaskvib) {
             if (listener) {
                 listener->panelChanged(Evlocallabslomaskvib,
-                                       slomaskvib->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       slomaskvib->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -5599,7 +5599,7 @@ void LocallabVibrance::adjusterChanged(ThresholdAdjuster* a, int newBottom, int
     if (isLocActivated && exp->getEnabled()) {
         if (listener) {
             listener->panelChanged(EvlocallabPastSatThreshold,
-                                   psThreshold->getHistoryString() + " (" + escapeHtmlChars(spotName) + ")");
+                                   psThreshold->getHistoryString() + " (" + escapeHtmlChars(getSpotName()) + ")");
         }
     }
 }
@@ -5658,35 +5658,35 @@ void LocallabVibrance::curveChanged(CurveEditor* ce)
         if (ce == skinTonesCurve) {
             if (listener) {
                 listener->panelChanged(EvlocallabSkinTonesCurve,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == CCmaskvibshape) {
             if (listener) {
                 listener->panelChanged(EvlocallabCCmaskvibshape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == LLmaskvibshape) {
             if (listener) {
                 listener->panelChanged(EvlocallabLLmaskvibshape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == HHmaskvibshape) {
             if (listener) {
                 listener->panelChanged(EvlocallabHHmaskvibshape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == Lmaskvibshape) {
             if (listener) {
                 listener->panelChanged(EvlocallabLmaskvibshape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -5698,10 +5698,10 @@ void LocallabVibrance::enabledChanged()
         if (listener) {
             if (exp->getEnabled()) {
                 listener->panelChanged(EvLocenavibrance,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(EvLocenashadhigh,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -5867,10 +5867,10 @@ void LocallabVibrance::protectskins_toggled()
         if (listener) {
             if (protectSkins->get_active()) {
                 listener->panelChanged(EvlocallabProtectSkins,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(EvlocallabProtectSkins,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -5882,10 +5882,10 @@ void LocallabVibrance::avoidcolorshift_toggled()
         if (listener) {
             if (avoidColorShift->get_active()) {
                 listener->panelChanged(EvlocallabAvoidColorShift,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(EvlocallabAvoidColorShift,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -5900,10 +5900,10 @@ void LocallabVibrance::pastsattog_toggled()
         if (listener) {
             if (pastSatTog->get_active()) {
                 listener->panelChanged(EvlocallabPastSatTog,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(EvlocallabPastSatTog,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -5938,10 +5938,10 @@ void LocallabVibrance::enavibMaskChanged()
         if (listener) {
             if (enavibMask->get_active()) {
                 listener->panelChanged(EvLocallabEnavibMask,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(EvLocallabEnavibMask,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -6070,8 +6070,6 @@ void LocallabSoft::read(const rtengine::procparams::ProcParams* pp, const Params
     if (index < (int)pp->locallab.spots.size()) {
         const LocallabParams::LocallabSpot& spot = pp->locallab.spots.at(index);
 
-        spotName = spot.name; // Update spot name according to selected spot
-
         exp->set_visible(spot.visisoft);
         exp->setEnabled(spot.expsoft);
         complexity->set_active(spot.complexsoft);
@@ -6146,21 +6144,21 @@ void LocallabSoft::adjusterChanged(Adjuster* a, double newval)
         if (a == streng) {
             if (listener) {
                 listener->panelChanged(Evlocallabstreng,
-                                       streng->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       streng->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == sensisf) {
             if (listener) {
                 listener->panelChanged(Evlocallabsensisf,
-                                       sensisf->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       sensisf->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == laplace) {
             if (listener) {
                 listener->panelChanged(Evlocallablaplace,
-                                       laplace->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       laplace->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -6186,7 +6184,7 @@ void LocallabSoft::complexityModeChanged()
 
         if (listener && isLocActivated) {
             listener->panelChanged(EvlocallabcomplexityWithRefresh,
-                                   M("TP_LOCALLAB_MODE_SIMPLE") + " (" + escapeHtmlChars(spotName) + ")");
+                                   M("TP_LOCALLAB_MODE_SIMPLE") + " (" + escapeHtmlChars(getSpotName()) + ")");
         }
     } else if (complexity->get_active_row_number() == Normal) { // New selected mode is Normal one
         const bool maskPreviewActivated = isMaskViewActive();
@@ -6205,7 +6203,7 @@ void LocallabSoft::complexityModeChanged()
 
         if (listener && isLocActivated) {
             listener->panelChanged(EvlocallabcomplexityWithRefresh,
-                                   M("TP_LOCALLAB_MODE_NORMAL") + " (" + escapeHtmlChars(spotName) + ")");
+                                   M("TP_LOCALLAB_MODE_NORMAL") + " (" + escapeHtmlChars(getSpotName()) + ")");
         }
     } else if (complexity->get_active_row_number() == Expert) { // New selected mode is Expert one
         // Update GUI based on new mode
@@ -6213,7 +6211,7 @@ void LocallabSoft::complexityModeChanged()
 
         if (listener && isLocActivated) {
             listener->panelChanged(EvlocallabcomplexityWithRefresh,
-                                   M("TP_LOCALLAB_MODE_EXPERT") + " (" + escapeHtmlChars(spotName) + ")");
+                                   M("TP_LOCALLAB_MODE_EXPERT") + " (" + escapeHtmlChars(getSpotName()) + ")");
         }
     }
 }
@@ -6224,10 +6222,10 @@ void LocallabSoft::enabledChanged()
         if (listener) {
             if (exp->getEnabled()) {
                 listener->panelChanged(EvLocenasoft,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(EvLocenasoft,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -6314,7 +6312,7 @@ void LocallabSoft::softMethodChanged()
     if (isLocActivated && exp->getEnabled()) {
         if (listener) {
             listener->panelChanged(EvlocallabsoftMethod,
-                                   softMethod->get_active_text() + " (" + escapeHtmlChars(spotName) + ")");
+                                   softMethod->get_active_text() + " (" + escapeHtmlChars(getSpotName()) + ")");
         }
     }
 }
@@ -7103,8 +7101,6 @@ void LocallabBlur::read(const rtengine::procparams::ProcParams* pp, const Params
     if (index < (int)pp->locallab.spots.size()) {
         const LocallabParams::LocallabSpot& spot = pp->locallab.spots.at(index);
 
-        spotName = spot.name; // Update spot name according to selected spot
-
         exp->set_visible(spot.visiblur);
         exp->setEnabled(spot.expblur);
         complexity->set_active(spot.complexblur);
@@ -7455,63 +7451,63 @@ void LocallabBlur::adjusterChanged(Adjuster* a, double newval)
         if (a == radius) {
             if (listener) {
                 listener->panelChanged(Evlocallabradius,
-                                       radius->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       radius->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == strength) {
             if (listener) {
                 listener->panelChanged(Evlocallabstrength,
-                                       strength->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       strength->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == isogr) {
             if (listener) {
                 listener->panelChanged(Evlocallabisogr,
-                                       isogr->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       isogr->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == strengr) {
             if (listener) {
                 listener->panelChanged(Evlocallabstrengr,
-                                       strengr->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       strengr->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == scalegr) {
             if (listener) {
                 listener->panelChanged(Evlocallabscalegr,
-                                       scalegr->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       scalegr->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == divgr) {
             if (listener) {
                 listener->panelChanged(Evlocallabdivgr,
-                                       divgr->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       divgr->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == itera) {
             if (listener) {
                 listener->panelChanged(Evlocallabitera,
-                                       itera->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       itera->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == guidbl) {
             if (listener) {
                 listener->panelChanged(Evlocallabguidbl,
-                                       guidbl->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       guidbl->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == strbl) {
             if (listener) {
                 listener->panelChanged(Evlocallabstrbl,
-                                       strbl->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       strbl->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
@@ -7524,21 +7520,21 @@ void LocallabBlur::adjusterChanged(Adjuster* a, double newval)
             
             if (listener) {
                 listener->panelChanged(Evlocallabrecothres,
-                                       recothres->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       recothres->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == lowthres) {
             if (listener) {
                 listener->panelChanged(Evlocallablowthres,
-                                       lowthres->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       lowthres->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == higthres) {
             if (listener) {
                 listener->panelChanged(Evlocallabhigthres,
-                                       higthres->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       higthres->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
@@ -7551,105 +7547,105 @@ void LocallabBlur::adjusterChanged(Adjuster* a, double newval)
             
             if (listener) {
                 listener->panelChanged(Evlocallabrecothresd,
-                                       recothresd->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       recothresd->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == lowthresd) {
             if (listener) {
                 listener->panelChanged(Evlocallablowthresd,
-                                       lowthresd->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       lowthresd->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == midthresd) {
             if (listener) {
                 listener->panelChanged(Evlocallabmidthresd,
-                                       midthresd->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       midthresd->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == midthresdch) {
             if (listener) {
                 listener->panelChanged(Evlocallabmidthresdch,
-                                       midthresdch->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       midthresdch->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == higthresd) {
             if (listener) {
                 listener->panelChanged(Evlocallabhigthresd,
-                                       higthresd->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       higthresd->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == decayd) {
             if (listener) {
                 listener->panelChanged(Evlocallabdecayd,
-                                       decayd->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       decayd->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == epsbl) {
             if (listener) {
                 listener->panelChanged(Evlocallabepsbl,
-                                       epsbl->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       epsbl->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == sensibn) {
             if (listener) {
                 listener->panelChanged(Evlocallabsensibn,
-                                       sensibn->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       sensibn->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == noiselumf0) {
             if (listener) {
                 listener->panelChanged(Evlocallabnoiselumf0,
-                                       noiselumf0->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       noiselumf0->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == noiselumf) {
             if (listener) {
                 listener->panelChanged(Evlocallabnoiselumf,
-                                       noiselumf->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       noiselumf->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == noiselumf2) {
             if (listener) {
                 listener->panelChanged(Evlocallabnoiselumf2,
-                                       noiselumf2->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       noiselumf2->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == noiselumc) {
             if (listener) {
                 listener->panelChanged(Evlocallabnoiselumc,
-                                       noiselumc->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       noiselumc->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == noiselumdetail) {
             if (listener) {
                 listener->panelChanged(Evlocallabnoiselumdetail,
-                                       noiselumdetail->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       noiselumdetail->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == noiselequal) {
             if (listener) {
                 listener->panelChanged(Evlocallabnoiselequal,
-                                       noiselequal->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       noiselequal->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == levelthr) {
             if (listener) {
                 listener->panelChanged(Evlocallablevelthr,
-                                       levelthr->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       levelthr->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
@@ -7661,168 +7657,168 @@ void LocallabBlur::adjusterChanged(Adjuster* a, double newval)
             }
             if (listener) {
                 listener->panelChanged(Evlocallablnoiselow,
-                                       lnoiselow->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       lnoiselow->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == levelthrlow) {
             if (listener) {
                 listener->panelChanged(Evlocallablevelthrlow,
-                                       levelthrlow->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       levelthrlow->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == noisechrof) {
             if (listener) {
                 listener->panelChanged(Evlocallabnoisechrof,
-                                       noisechrof->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       noisechrof->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == noisechroc) {
             if (listener) {
                 listener->panelChanged(Evlocallabnoisechroc,
-                                       noisechroc->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       noisechroc->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == noisechrodetail) {
             if (listener) {
                 listener->panelChanged(Evlocallabnoisechrodetail,
-                                       noisechrodetail->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       noisechrodetail->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == detailthr) {
             if (listener) {
                 listener->panelChanged(Evlocallabdetailthr,
-                                       detailthr->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       detailthr->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == adjblur) {
             if (listener) {
                 listener->panelChanged(Evlocallabadjblur,
-                                       adjblur->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       adjblur->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == bilateral) {
             if (listener) {
                 listener->panelChanged(Evlocallabbilateral,
-                                       bilateral->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       bilateral->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == nlstr) {
             if (listener) {
                 listener->panelChanged(Evlocallabnlstr,
-                                       nlstr->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       nlstr->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == nldet) {
             if (listener) {
                 listener->panelChanged(Evlocallabnldet,
-                                       nldet->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       nldet->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == nlpat) {
             if (listener) {
                 listener->panelChanged(Evlocallabnlpat,
-                                       nlpat->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       nlpat->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == nlrad) {
             if (listener) {
                 listener->panelChanged(Evlocallabnlrad,
-                                       nlrad->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       nlrad->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == nlgam) {
             if (listener) {
                 listener->panelChanged(Evlocallabnlgam,
-                                       nlgam->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       nlgam->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == sensiden) {
             if (listener) {
                 listener->panelChanged(Evlocallabsensiden,
-                                       sensiden->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       sensiden->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == reparden) {
             if (listener) {
                 listener->panelChanged(Evlocallabreparden,
-                                       reparden->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       reparden->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == strumaskbl) {
             if (listener) {
                 listener->panelChanged(Evlocallabstrumaskbl,
-                                       strumaskbl->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       strumaskbl->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == blendmaskbl) {
             if (listener) {
                 listener->panelChanged(Evlocallabblendmaskbl,
-                                       blendmaskbl->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       blendmaskbl->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == radmaskbl) {
             if (listener) {
                 listener->panelChanged(Evlocallabradmaskbl,
-                                       radmaskbl->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       radmaskbl->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == lapmaskbl) {
             if (listener) {
                 listener->panelChanged(Evlocallablapmaskbl,
-                                       lapmaskbl->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       lapmaskbl->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == chromaskbl) {
             if (listener) {
                 listener->panelChanged(Evlocallabchromaskbl,
-                                       chromaskbl->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       chromaskbl->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == gammaskbl) {
             if (listener) {
                 listener->panelChanged(Evlocallabgammaskbl,
-                                       gammaskbl->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       gammaskbl->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == slomaskbl) {
             if (listener) {
                 listener->panelChanged(Evlocallabslomaskbl,
-                                       slomaskbl->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       slomaskbl->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == shadmaskbl) {
             if (listener) {
                 listener->panelChanged(Evlocallabshadmaskbl,
-                                       shadmaskbl->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       shadmaskbl->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == shadmaskblsha) {
             if (listener) {
                 listener->panelChanged(Evlocallabshadmaskblsha,
-                                       shadmaskblsha->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       shadmaskblsha->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
@@ -7836,7 +7832,7 @@ void LocallabBlur::adjusterChanged2(ThresholdAdjuster* a, int newBottomL, int ne
     if (isLocActivated && exp->getEnabled()) {
         if (listener) {
             listener->panelChanged(EvlocallabcsThresholdblur,
-                                   csThresholdblur->getHistoryString() + " (" + escapeHtmlChars(spotName) + ")");
+                                   csThresholdblur->getHistoryString() + " (" + escapeHtmlChars(getSpotName()) + ")");
         }
     }
 }
@@ -7847,49 +7843,49 @@ void LocallabBlur::curveChanged(CurveEditor* ce)
         if (ce == wavshapeden) {
             if (listener) {
                 listener->panelChanged(EvlocallabwavCurveden,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == wavhue) {
             if (listener) {
                 listener->panelChanged(EvlocallabwavCurvehue,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == CCmaskblshape) {
             if (listener) {
                 listener->panelChanged(EvlocallabCCmaskblshape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == LLmaskblshape) {
             if (listener) {
                 listener->panelChanged(EvlocallabLLmaskblshape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == HHmaskblshape) {
             if (listener) {
                 listener->panelChanged(EvlocallabHHmaskblshape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == Lmaskblshape) {
             if (listener) {
                 listener->panelChanged(EvlocallabLmaskblshape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == LLmaskblshapewav) {
             if (listener) {
                 listener->panelChanged(EvlocallabLLmaskblshapewav,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -7901,10 +7897,10 @@ void LocallabBlur::enabledChanged()
         if (listener) {
             if (exp->getEnabled()) {
                 listener->panelChanged(EvLocenablur,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(EvLocenablur,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -8194,7 +8190,7 @@ void LocallabBlur::blMethodChanged()
     if (isLocActivated && exp->getEnabled()) {
         if (listener) {
             listener->panelChanged(EvlocallabblMethod,
-                                   blMethod->get_active_text() + " (" + escapeHtmlChars(spotName) + ")");
+                                   blMethod->get_active_text() + " (" + escapeHtmlChars(getSpotName()) + ")");
         }
     }
 }
@@ -8205,10 +8201,10 @@ void LocallabBlur::fftwblChanged()
         if (listener) {
             if (fftwbl->get_active()) {
                 listener->panelChanged(Evlocallabfftwbl,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(Evlocallabfftwbl,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -8220,10 +8216,10 @@ void LocallabBlur::usemaskChanged()
         if (listener) {
             if (usemask->get_active()) {
                 listener->panelChanged(Evlocallabusemask1,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(Evlocallabusemask1,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -8235,10 +8231,10 @@ void LocallabBlur::invmaskdChanged()
         if (listener) {
             if (invmaskd->get_active()) {
                 listener->panelChanged(Evlocallabinvmaskd,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(Evlocallabinvmaskd,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -8250,10 +8246,10 @@ void LocallabBlur::invmaskChanged()
         if (listener) {
             if (invmask->get_active()) {
                 listener->panelChanged(Evlocallabinvmask,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(Evlocallabinvmask,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -8281,10 +8277,10 @@ void LocallabBlur::invblChanged()
         if (listener) {
             if (invbl->get_active()) {
                 listener->panelChanged(Evlocallabinvbl,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(Evlocallabinvbl,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -8295,7 +8291,7 @@ void LocallabBlur::medMethodChanged()
     if (isLocActivated && exp->getEnabled()) {
         if (listener) {
             listener->panelChanged(EvlocallabmedMethod,
-                                   medMethod->get_active_text() + " (" + escapeHtmlChars(spotName) + ")");
+                                   medMethod->get_active_text() + " (" + escapeHtmlChars(getSpotName()) + ")");
         }
     }
 }
@@ -8305,7 +8301,7 @@ void LocallabBlur::blurMethodChanged()
     if (isLocActivated && exp->getEnabled()) {
         if (listener) {
             listener->panelChanged(EvlocallabblurMethod,
-                                   blurMethod->get_active_text() + " (" + escapeHtmlChars(spotName) + ")");
+                                   blurMethod->get_active_text() + " (" + escapeHtmlChars(getSpotName()) + ")");
         }
     }
 }
@@ -8315,7 +8311,7 @@ void LocallabBlur::chroMethodChanged()
     if (isLocActivated && exp->getEnabled()) {
         if (listener) {
             listener->panelChanged(EvlocallabchroMethod,
-                                   chroMethod->get_active_text() + " (" + escapeHtmlChars(spotName) + ")");
+                                   chroMethod->get_active_text() + " (" + escapeHtmlChars(getSpotName()) + ")");
         }
     }
 }
@@ -8325,7 +8321,7 @@ void LocallabBlur::quamethodChanged()
     if (isLocActivated && exp->getEnabled()) {
         if (listener) {
             listener->panelChanged(EvlocallabquaMethod,
-                                   quamethod->get_active_text() + " (" + escapeHtmlChars(spotName) + ")");
+                                   quamethod->get_active_text() + " (" + escapeHtmlChars(getSpotName()) + ")");
         }
     }
 }
@@ -8337,10 +8333,10 @@ void LocallabBlur::activlumChanged()
         if (listener) {
             if (activlum->get_active()) {
                 listener->panelChanged(Evlocallabactivlum,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(Evlocallabactivlum,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -8383,7 +8379,7 @@ void LocallabBlur::showmaskblMethodtypChanged()
 
     if (listener) {
         listener->panelChanged(EvlocallabshowmasktypMethod,
-                               showmaskblMethodtyp->get_active_text() + " (" + escapeHtmlChars(spotName) + ")");
+                               showmaskblMethodtyp->get_active_text() + " (" + escapeHtmlChars(getSpotName()) + ")");
     }
 }
 
@@ -8409,10 +8405,10 @@ void LocallabBlur::enablMaskChanged()
         if (listener) {
             if (enablMask->get_active()) {
                 listener->panelChanged(EvLocallabEnablMask,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(EvLocallabEnablMask,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -8424,10 +8420,10 @@ void LocallabBlur::toolblChanged()
         if (listener) {
             if (toolbl->get_active()) {
                 listener->panelChanged(Evlocallabtoolbl,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(Evlocallabtoolbl,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
diff --git a/rtgui/locallabtools.h b/rtgui/locallabtools.h
index 2acafa826..82dd8ee31 100644
--- a/rtgui/locallabtools.h
+++ b/rtgui/locallabtools.h
@@ -59,7 +59,7 @@ protected:
     // LocallabTool parameters
     bool needMode;
     bool isLocActivated;
-    Glib::ustring spotName;
+    const Glib::ustring *spotNameSource;
     LocallabToolListener* locToolListener;
 
     // LocallabTool generic widgets
@@ -70,6 +70,8 @@ protected:
 
     IdleRegister idle_register;
 
+    Glib::ustring getSpotName() const;
+
 public:
     // Locallab tool constructor/destructor
     LocallabTool(Gtk::Box* content, Glib::ustring toolName, Glib::ustring UILabel, bool need11 = false, bool needMode = true);
@@ -98,10 +100,10 @@ public:
         isLocActivated = cond;
     }
 
-    // Setter for spot name
-    void setSpotName(const Glib::ustring &spotname)
+    // Setter for spot name source
+    void setSpotNameSource(const Glib::ustring *source)
     {
-        spotName = spotname;
+        spotNameSource = source;
     }
 
     // Setter for Locallab tool listener
diff --git a/rtgui/locallabtools2.cc b/rtgui/locallabtools2.cc
index a4bce7301..55cd98680 100644
--- a/rtgui/locallabtools2.cc
+++ b/rtgui/locallabtools2.cc
@@ -401,8 +401,6 @@ void LocallabTone::read(const rtengine::procparams::ProcParams* pp, const Params
     if (index < (int)pp->locallab.spots.size()) {
         const LocallabParams::LocallabSpot& spot = pp->locallab.spots.at(index);
 
-        spotName = spot.name; // Update spot name according to selected spot
-
         exp->set_visible(spot.visitonemap);
         exp->setEnabled(spot.exptonemap);
         complexity->set_active(spot.complextonemap);
@@ -524,7 +522,7 @@ void LocallabTone::setDefaults(const rtengine::procparams::ProcParams* defParams
 void LocallabTone::adjusterChanged(Adjuster* a, double newval)
 {
     if (isLocActivated && exp->getEnabled() && listener) {
-        const auto spName = " (" + escapeHtmlChars(spotName) + ")";
+        const auto spName = " (" + escapeHtmlChars(getSpotName()) + ")";
 
         if (a == amount) {
             listener->panelChanged(Evlocallabamount, amount->getTextValue() + spName);
@@ -573,7 +571,7 @@ void LocallabTone::adjusterChanged(Adjuster* a, double newval)
 void LocallabTone::curveChanged(CurveEditor* ce)
 {
     if (isLocActivated && exp->getEnabled() && listener) {
-        const auto spName = M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")";
+        const auto spName = M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")";
 
         if (ce == CCmasktmshape) {
             listener->panelChanged(EvlocallabCCmasktmshape, spName);
@@ -591,7 +589,7 @@ void LocallabTone::enabledChanged()
 {
     if (isLocActivated && listener) {
         listener->panelChanged(EvLocenatonemap, (exp->getEnabled() ? M("GENERAL_ENABLED") : M("GENERAL_DISABLED"))
-                               + " (" + escapeHtmlChars(spotName) + ")");
+                               + " (" + escapeHtmlChars(getSpotName()) + ")");
     }
 }
 
@@ -725,10 +723,10 @@ void LocallabTone::equiltmChanged()
         if (listener) {
             if (equiltm->get_active()) {
                 listener->panelChanged(Evlocallabequiltm,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(Evlocallabequiltm,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -762,10 +760,10 @@ void LocallabTone::enatmMaskChanged()
         if (listener) {
             if (enatmMask->get_active()) {
                 listener->panelChanged(EvLocallabEnatmMask,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(EvLocallabEnatmMask,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -777,10 +775,10 @@ void LocallabTone::enatmMaskaftChanged()
         if (listener) {
             if (enatmMaskaft->get_active()) {
                 listener->panelChanged(EvLocallabEnatmMaskaft,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(EvLocallabEnatmMaskaft,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -1239,8 +1237,6 @@ void LocallabRetinex::read(const rtengine::procparams::ProcParams* pp, const Par
     if (index < (int)pp->locallab.spots.size()) {
         const LocallabParams::LocallabSpot& spot = pp->locallab.spots.at(index);
 
-        spotName = spot.name; // Update spot name according to selected spot
-
         exp->set_visible(spot.visireti);
         exp->setEnabled(spot.expreti);
         complexity->set_active(spot.complexreti);
@@ -1428,105 +1424,105 @@ void LocallabRetinex::adjusterChanged(Adjuster* a, double newval)
         if (a == dehaz) {
             if (listener) {
                 listener->panelChanged(Evlocallabdehaz,
-                                       dehaz->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       dehaz->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == dehazeSaturation) {
             if (listener) {
                 listener->panelChanged(EvlocallabdehazeSaturation,
-                                       dehazeSaturation->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       dehazeSaturation->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == depth) {
             if (listener) {
                 listener->panelChanged(Evlocallabdepth,
-                                       depth->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       depth->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == str) {
             if (listener) {
                 listener->panelChanged(Evlocallabstr,
-                                       str->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       str->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == sensih) {
             if (listener) {
                 listener->panelChanged(Evlocallabsensih,
-                                       sensih->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       sensih->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == neigh) {
             if (listener) {
                 listener->panelChanged(Evlocallabneigh,
-                                       neigh->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       neigh->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == vart) {
             if (listener) {
                 listener->panelChanged(Evlocallabvart,
-                                       vart->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       vart->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == scalereti) {
             if (listener) {
                 listener->panelChanged(Evlocallabscalereti,
-                                       scalereti->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       scalereti->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == limd) {
             if (listener) {
                 listener->panelChanged(Evlocallablimd,
-                                       limd->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       limd->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == offs) {
             if (listener) {
                 listener->panelChanged(Evlocallaboffs,
-                                       offs->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       offs->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == chrrt) {
             if (listener) {
                 listener->panelChanged(Evlocallabchrrt,
-                                       chrrt->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       chrrt->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == darkness) {
             if (listener) {
                 listener->panelChanged(Evlocallabdarkness,
-                                       darkness->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       darkness->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == lightnessreti) {
             if (listener) {
                 listener->panelChanged(Evlocallablightnessreti,
-                                       lightnessreti->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       lightnessreti->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == cliptm) {
             if (listener) {
                 listener->panelChanged(Evlocallabcliptm,
-                                       cliptm->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       cliptm->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == softradiusret) {
             if (listener) {
                 listener->panelChanged(Evlocallabsoftradiusret,
-                                       softradiusret->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       softradiusret->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
@@ -1534,70 +1530,70 @@ void LocallabRetinex::adjusterChanged(Adjuster* a, double newval)
             
             if (listener) {
                 listener->panelChanged(Evlocallabrecothresr,
-                                       recothresr->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       recothresr->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == lowthresr) {
             if (listener) {
                 listener->panelChanged(Evlocallablowthresr,
-                                       lowthresr->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       lowthresr->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == higthresr) {
             if (listener) {
                 listener->panelChanged(Evlocallabhigthresr,
-                                       higthresr->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       higthresr->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == decayr) {
             if (listener) {
                 listener->panelChanged(Evlocallabdecayr,
-                                       decayr->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       decayr->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == blendmaskreti) {
             if (listener) {
                 listener->panelChanged(Evlocallabblendmaskreti,
-                                       blendmaskreti->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       blendmaskreti->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == radmaskreti) {
             if (listener) {
                 listener->panelChanged(Evlocallabradmaskreti,
-                                       radmaskreti->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       radmaskreti->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == lapmaskreti) {
             if (listener) {
                 listener->panelChanged(Evlocallablapmaskreti,
-                                       lapmaskreti->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       lapmaskreti->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == chromaskreti) {
             if (listener) {
                 listener->panelChanged(Evlocallabchromaskreti,
-                                       chromaskreti->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       chromaskreti->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == gammaskreti) {
             if (listener) {
                 listener->panelChanged(Evlocallabgammaskreti,
-                                       gammaskreti->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       gammaskreti->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == slomaskreti) {
             if (listener) {
                 listener->panelChanged(Evlocallabslomaskreti,
-                                       slomaskreti->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       slomaskreti->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -1609,42 +1605,42 @@ void LocallabRetinex::curveChanged(CurveEditor* ce)
         if (ce == cTtransshape) {
             if (listener) {
                 listener->panelChanged(EvlocallabCTtransCurve,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == cTgainshape) {
             if (listener) {
                 listener->panelChanged(EvlocallabCTgainCurve,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == CCmaskretishape) {
             if (listener) {
                 listener->panelChanged(EvlocallabCCmaskretishape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == LLmaskretishape) {
             if (listener) {
                 listener->panelChanged(EvlocallabLLmaskretishape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == HHmaskretishape) {
             if (listener) {
                 listener->panelChanged(EvlocallabHHmaskretishape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == Lmaskretishape) {
             if (listener) {
                 listener->panelChanged(EvlocallabLmaskretishape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -1656,10 +1652,10 @@ void LocallabRetinex::enabledChanged()
         if (listener) {
             if (exp->getEnabled()) {
                 listener->panelChanged(EvLocenareti,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(EvLocenareti,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -1810,10 +1806,10 @@ void LocallabRetinex::loglinChanged()
         if (listener) {
             if (loglin->get_active()) {
                 listener->panelChanged(Evlocallabloglin,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(Evlocallabloglin,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -1824,7 +1820,7 @@ void LocallabRetinex::retinexMethodChanged()
     if (isLocActivated && exp->getEnabled()) {
         if (listener) {
             listener->panelChanged(EvlocallabretinexMethod,
-                                   retinexMethod->get_active_text() + " (" + escapeHtmlChars(spotName) + ")");
+                                   retinexMethod->get_active_text() + " (" + escapeHtmlChars(getSpotName()) + ")");
         }
     }
 }
@@ -1835,10 +1831,10 @@ void LocallabRetinex::fftwretiChanged()
         if (listener) {
             if (fftwreti->get_active()) {
                 listener->panelChanged(Evlocallabfftwreti,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(Evlocallabfftwreti,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -1850,10 +1846,10 @@ void LocallabRetinex::equilretChanged()
         if (listener) {
             if (inversret->get_active()) {
                 listener->panelChanged(Evlocallabequilret,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(Evlocallabequilret,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -1888,10 +1884,10 @@ void LocallabRetinex::enaretiMaskChanged()
         if (listener) {
             if (enaretiMask->get_active()) {
                 listener->panelChanged(EvLocallabEnaretiMask,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(EvLocallabEnaretiMask,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -1903,10 +1899,10 @@ void LocallabRetinex::enaretiMasktmapChanged()
         if (listener) {
             if (enaretiMasktmap->get_active()) {
                 listener->panelChanged(EvLocallabEnaretiMasktmap,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(EvLocallabEnaretiMasktmap,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -1930,10 +1926,10 @@ void LocallabRetinex::inversretChanged()
         if (listener) {
             if (inversret->get_active()) {
                 listener->panelChanged(Evlocallabinversret,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(Evlocallabinversret,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -2091,8 +2087,6 @@ void LocallabSharp::read(const rtengine::procparams::ProcParams* pp, const Param
     if (index < (int)pp->locallab.spots.size()) {
         const LocallabParams::LocallabSpot& spot = pp->locallab.spots.at(index);
 
-        spotName = spot.name; // Update spot name according to selected spot
-
         exp->set_visible(spot.visisharp);
         exp->setEnabled(spot.expsharp);
         complexity->set_active(spot.complexsharp);
@@ -2166,49 +2160,49 @@ void LocallabSharp::adjusterChanged(Adjuster* a, double newval)
         if (a == sharcontrast) {
             if (listener) {
                 listener->panelChanged(Evlocallabsharcontrast,
-                                       sharcontrast->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       sharcontrast->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == sharradius) {
             if (listener) {
                 listener->panelChanged(Evlocallabsharradius,
-                                       sharradius->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       sharradius->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == sharamount) {
             if (listener) {
                 listener->panelChanged(Evlocallabsharamount,
-                                       sharamount->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       sharamount->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == shardamping) {
             if (listener) {
                 listener->panelChanged(Evlocallabshardamping,
-                                       shardamping->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       shardamping->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == shariter) {
             if (listener) {
                 listener->panelChanged(Evlocallabshariter,
-                                       shariter->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       shariter->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == sharblur) {
             if (listener) {
                 listener->panelChanged(Evlocallabsharblur,
-                                       sharblur->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       sharblur->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == sensisha) {
             if (listener) {
                 listener->panelChanged(Evlocallabsensis,
-                                       sensisha->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       sensisha->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -2220,10 +2214,10 @@ void LocallabSharp::enabledChanged()
         if (listener) {
             if (exp->getEnabled()) {
                 listener->panelChanged(EvLocenasharp,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(EvLocenasharp,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -2306,10 +2300,10 @@ void LocallabSharp::inversshaChanged()
         if (listener) {
             if (inverssha->get_active()) {
                 listener->panelChanged(Evlocallabinverssha,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(Evlocallabinverssha,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -3108,8 +3102,6 @@ void LocallabContrast::read(const rtengine::procparams::ProcParams* pp, const Pa
     if (index < (int)pp->locallab.spots.size()) {
         const LocallabParams::LocallabSpot& spot = pp->locallab.spots.at(index);
 
-        spotName = spot.name; // Update spot name according to selected spot
-
         exp->set_visible(spot.visicontrast);
         exp->setEnabled(spot.expcontrast);
         complexity->set_active(spot.complexcontrast);
@@ -3409,259 +3401,259 @@ void LocallabContrast::adjusterChanged(Adjuster* a, double newval)
         if (a == lcradius) {
             if (listener) {
                 listener->panelChanged(Evlocallablcradius,
-                                       lcradius->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       lcradius->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == lcamount) {
             if (listener) {
                 listener->panelChanged(Evlocallablcamount,
-                                       lcamount->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       lcamount->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == lcdarkness) {
             if (listener) {
                 listener->panelChanged(Evlocallablcdarkness,
-                                       lcdarkness->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       lcdarkness->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == lclightness) {
             if (listener) {
                 listener->panelChanged(Evlocallablclightness,
-                                       lclightness->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       lclightness->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == sigmalc) {
             if (listener) {
                 listener->panelChanged(Evlocallabsigmalc,
-                                       sigmalc->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       sigmalc->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == levelwav) {
             if (listener) {
                 listener->panelChanged(Evlocallablevelwav,
-                                       levelwav->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       levelwav->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == residcont) {
             if (listener) {
                 listener->panelChanged(Evlocallabresidcont,
-                                       residcont->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       residcont->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == residchro) {
             if (listener) {
                 listener->panelChanged(Evlocallabresidchro,
-                                       residchro->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       residchro->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == residsha) {
             if (listener) {
                 listener->panelChanged(Evlocallabresidsha,
-                                       residsha->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       residsha->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == residshathr) {
             if (listener) {
                 listener->panelChanged(Evlocallabresidshathr,
-                                       residshathr->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       residshathr->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == residhi) {
             if (listener) {
                 listener->panelChanged(Evlocallabresidhi,
-                                       residhi->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       residhi->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == residhithr) {
             if (listener) {
                 listener->panelChanged(Evlocallabresidhithr,
-                                       residhithr->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       residhithr->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == sensilc) {
             if (listener) {
                 listener->panelChanged(Evlocallabsensilc,
-                                       sensilc->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       sensilc->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == reparw) {
             if (listener) {
                 listener->panelChanged(Evlocallabreparw,
-                                       reparw->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       reparw->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == clarilres) {
             if (listener) {
                 listener->panelChanged(Evlocallabclarilres,
-                                       clarilres->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       clarilres->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == claricres) {
             if (listener) {
                 listener->panelChanged(Evlocallabclaricres,
-                                       claricres->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       claricres->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == clarisoft) {
             if (listener) {
                 listener->panelChanged(Evlocallabclarisoft,
-                                       clarisoft->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       clarisoft->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == sigmalc2) {
             if (listener) {
                 listener->panelChanged(Evlocallabsigmalc2,
-                                       sigmalc2->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       sigmalc2->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == strwav) {
             if (listener) {
                 listener->panelChanged(Evlocallabstrwav,
-                                       strwav->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       strwav->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == angwav) {
             if (listener) {
                 listener->panelChanged(Evlocallabangwav,
-                                       angwav->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       angwav->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == strengthw) {
             if (listener) {
                 listener->panelChanged(Evlocallabstrengthw,
-                                       strengthw->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       strengthw->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == sigmaed) {
             if (listener) {
                 listener->panelChanged(Evlocallabsigmaed,
-                                       sigmaed->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       sigmaed->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == gradw) {
             if (listener) {
                 listener->panelChanged(Evlocallabgradw,
-                                       gradw->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       gradw->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == radiusw) {
             if (listener) {
                 listener->panelChanged(Evlocallabradiusw,
-                                       radiusw->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       radiusw->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == detailw) {
             if (listener) {
                 listener->panelChanged(Evlocallabdetailw,
-                                       detailw->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       detailw->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == tloww) {
             if (listener) {
                 listener->panelChanged(Evlocallabtloww,
-                                       tloww->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       tloww->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == thigw) {
             if (listener) {
                 listener->panelChanged(Evlocallabthigw,
-                                       thigw->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       thigw->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == edgw) {
             if (listener) {
                 listener->panelChanged(Evlocallabedgw,
-                                       edgw->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       edgw->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == basew) {
             if (listener) {
                 listener->panelChanged(Evlocallabbasew,
-                                       basew->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       basew->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == levelblur) {
             if (listener) {
                 listener->panelChanged(Evlocallablevelblur,
-                                       levelblur->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       levelblur->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == sigmabl) {
             if (listener) {
                 listener->panelChanged(Evlocallabsigmabl,
-                                       sigmabl->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       sigmabl->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == chromablu) {
             if (listener) {
                 listener->panelChanged(Evlocallabchromablu,
-                                       chromablu->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       chromablu->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == residblur) {
             if (listener) {
                 listener->panelChanged(Evlocallabresidblur,
-                                       residblur->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       residblur->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == sigma) {
             if (listener) {
                 listener->panelChanged(Evlocallabsigma,
-                                       sigma->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       sigma->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == offset) {
             if (listener) {
                 listener->panelChanged(Evlocallaboffset,
-                                       offset->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       offset->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == chromalev) {
             if (listener) {
                 listener->panelChanged(Evlocallabchromalev,
-                                       chromalev->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       chromalev->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == sigmadr) {
             if (listener) {
                 listener->panelChanged(Evlocallabsigmadr,
-                                       sigmadr->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       sigmadr->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
@@ -3669,35 +3661,35 @@ void LocallabContrast::adjusterChanged(Adjuster* a, double newval)
         if (a == threswav) {
             if (listener) {
                 listener->panelChanged(Evlocallabthreswav,
-                                       threswav->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       threswav->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == residcomp) {
             if (listener) {
                 listener->panelChanged(Evlocallabresidcomp,
-                                       residcomp->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       residcomp->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == sigmadc) {
             if (listener) {
                 listener->panelChanged(Evlocallabsigmadc,
-                                       sigmadc->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       sigmadc->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == deltad) {
             if (listener) {
                 listener->panelChanged(Evlocallabdeltad,
-                                       deltad->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       deltad->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == fatres) {
             if (listener) {
                 listener->panelChanged(Evlocallabfatres,
-                                       fatres->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       fatres->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
@@ -3705,49 +3697,49 @@ void LocallabContrast::adjusterChanged(Adjuster* a, double newval)
             
             if (listener) {
                 listener->panelChanged(Evlocallabrecothresw,
-                                       recothresw->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       recothresw->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == lowthresw) {
             if (listener) {
                 listener->panelChanged(Evlocallablowthresw,
-                                       lowthresw->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       lowthresw->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == higthresw) {
             if (listener) {
                 listener->panelChanged(Evlocallabhigthresw,
-                                       higthresw->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       higthresw->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == decayw) {
             if (listener) {
                 listener->panelChanged(Evlocallabdecayw,
-                                       decayw->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       decayw->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == blendmasklc) {
             if (listener) {
                 listener->panelChanged(Evlocallabblendmasklc,
-                                       blendmasklc->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       blendmasklc->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == radmasklc) {
             if (listener) {
                 listener->panelChanged(Evlocallabradmasklc,
-                                       radmasklc->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       radmasklc->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == chromasklc) {
             if (listener) {
                 listener->panelChanged(Evlocallabchromasklc,
-                                       chromasklc->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       chromasklc->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -3758,7 +3750,7 @@ void LocallabContrast::adjusterChanged2(ThresholdAdjuster* a, int newBottomL, in
     if (isLocActivated && exp->getEnabled()) {
         if (listener) {
             listener->panelChanged(EvlocallabcsThreshold,
-                                   csThreshold->getHistoryString() + " (" + escapeHtmlChars(spotName) + ")");
+                                   csThreshold->getHistoryString() + " (" + escapeHtmlChars(getSpotName()) + ")");
         }
     }
 }
@@ -3769,70 +3761,70 @@ void LocallabContrast::curveChanged(CurveEditor* ce)
         if (ce == wavshape) {
             if (listener) {
                 listener->panelChanged(EvlocallabwavCurve,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == wavshapeedg) {
             if (listener) {
                 listener->panelChanged(EvlocallabwavCurveedg,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == wavshapelev) {
             if (listener) {
                 listener->panelChanged(EvlocallabwavCurvelev,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == wavshapecon) {
             if (listener) {
                 listener->panelChanged(EvlocallabwavCurvecon,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == wavshapecompre) {
             if (listener) {
                 listener->panelChanged(EvlocallabwavCurvecompre,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == wavshapecomp) {
             if (listener) {
                 listener->panelChanged(EvlocallabwavCurvecomp,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == CCmasklcshape) {
             if (listener) {
                 listener->panelChanged(EvlocallabCCmasklcshape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == LLmasklcshape) {
             if (listener) {
                 listener->panelChanged(EvlocallabLLmasklcshape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == HHmasklcshape) {
             if (listener) {
                 listener->panelChanged(EvlocallabHHmasklcshape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == Lmasklcshape) {
             if (listener) {
                 listener->panelChanged(EvlocallabLmasklcshape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -3844,10 +3836,10 @@ void LocallabContrast::enabledChanged()
         if (listener) {
             if (exp->getEnabled()) {
                 listener->panelChanged(EvLocenacontrast,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(EvLocenacontrast,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -4060,7 +4052,7 @@ void LocallabContrast::localcontMethodChanged()
     if (isLocActivated && exp->getEnabled()) {
         if (listener) {
             listener->panelChanged(EvlocallablocalcontMethod,
-                                   localcontMethod->get_active_text() + " (" + escapeHtmlChars(spotName) + ")");
+                                   localcontMethod->get_active_text() + " (" + escapeHtmlChars(getSpotName()) + ")");
         }
     }
 }
@@ -4071,10 +4063,10 @@ void LocallabContrast::origlcChanged()
         if (listener) {
             if (origlc->get_active()) {
                 listener->panelChanged(Evlocallaboriglc,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(Evlocallaboriglc,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -4086,10 +4078,10 @@ void LocallabContrast::wavgradlChanged()
         if (listener) {
             if (wavgradl->get_active()) {
                 listener->panelChanged(Evlocallabwavgradl,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(Evlocallabwavgradl,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -4101,10 +4093,10 @@ void LocallabContrast::wavedgChanged()
         if (listener) {
             if (wavedg->get_active()) {
                 listener->panelChanged(Evlocallabwavedg,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(Evlocallabwavedg,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -4115,7 +4107,7 @@ void LocallabContrast::localedgMethodChanged()
     if (isLocActivated && exp->getEnabled()) {
         if (listener) {
             listener->panelChanged(EvlocallablocaledgMethod,
-                                   localedgMethod->get_active_text() + " (" + escapeHtmlChars(spotName) + ")");
+                                   localedgMethod->get_active_text() + " (" + escapeHtmlChars(getSpotName()) + ")");
         }
     }
 }
@@ -4129,10 +4121,10 @@ void LocallabContrast::waveshowChanged()
         if (listener) {
             if (waveshow->get_active()) {
                 listener->panelChanged(Evlocallabwaveshow,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(Evlocallabwaveshow,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -4143,7 +4135,7 @@ void LocallabContrast::localneiMethodChanged()
     if (isLocActivated && exp->getEnabled()) {
         if (listener) {
             listener->panelChanged(EvlocallablocalneiMethod,
-                                   localneiMethod->get_active_text() + " (" + escapeHtmlChars(spotName) + ")");
+                                   localneiMethod->get_active_text() + " (" + escapeHtmlChars(getSpotName()) + ")");
         }
     }
 }
@@ -4154,10 +4146,10 @@ void LocallabContrast::wavblurChanged()
         if (listener) {
             if (wavblur->get_active()) {
                 listener->panelChanged(Evlocallabwavblur,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(Evlocallabwavblur,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -4169,10 +4161,10 @@ void LocallabContrast::blurlcChanged()
         if (listener) {
             if (blurlc->get_active()) {
                 listener->panelChanged(Evlocallabblurlc,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(Evlocallabblurlc,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -4184,10 +4176,10 @@ void LocallabContrast::wavcontChanged()
         if (listener) {
             if (wavcont->get_active()) {
                 listener->panelChanged(Evlocallabwavcont,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(Evlocallabwavcont,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -4199,10 +4191,10 @@ void LocallabContrast::wavcompreChanged()
         if (listener) {
             if (wavcompre->get_active()) {
                 listener->panelChanged(Evlocallabwavcompre,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(Evlocallabwavcompre,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -4214,10 +4206,10 @@ void LocallabContrast::wavcompChanged()
         if (listener) {
             if (wavcomp->get_active()) {
                 listener->panelChanged(Evlocallabwavcomp,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(Evlocallabwavcomp,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -4232,10 +4224,10 @@ void LocallabContrast::fftwlcChanged()
         if (listener) {
             if (fftwlc->get_active()) {
                 listener->panelChanged(Evlocallabfftwlc,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(Evlocallabfftwlc,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -4270,10 +4262,10 @@ void LocallabContrast::enalcMaskChanged()
         if (listener) {
             if (enalcMask->get_active()) {
                 listener->panelChanged(EvLocallabEnalcMask,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(EvLocallabEnalcMask,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -4666,8 +4658,6 @@ void LocallabCBDL::read(const rtengine::procparams::ProcParams* pp, const Params
     if (index < (int)pp->locallab.spots.size()) {
         const LocallabParams::LocallabSpot& spot = pp->locallab.spots.at(index);
 
-        spotName = spot.name; // Update spot name according to selected spot
-
         exp->set_visible(spot.visicbdl);
         exp->setEnabled(spot.expcbdl);
         complexity->set_active(spot.complexcbdl);
@@ -4795,49 +4785,49 @@ void LocallabCBDL::adjusterChanged(Adjuster* a, double newval)
                                                Glib::ustring::format(std::fixed, std::setprecision(2), multiplier[3]->getValue()),
                                                Glib::ustring::format(std::fixed, std::setprecision(2), multiplier[4]->getValue()),
                                                Glib::ustring::format(std::fixed, std::setprecision(2), multiplier[5]->getValue()))
-                                       + " (" + escapeHtmlChars(spotName) + ")");
+                                       + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == chromacbdl) {
             if (listener) {
                 listener->panelChanged(Evlocallabchromacbdl,
-                                       chromacbdl->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       chromacbdl->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == threshold) {
             if (listener) {
                 listener->panelChanged(EvlocallabThresho,
-                                       threshold->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       threshold->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == clarityml) {
             if (listener) {
                 listener->panelChanged(EvLocallabclarityml,
-                                       clarityml->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       clarityml->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == contresid) {
             if (listener) {
                 listener->panelChanged(EvLocallabcontresid,
-                                       contresid->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       contresid->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == softradiuscb) {
             if (listener) {
                 listener->panelChanged(Evlocallabsoftradiuscb,
-                                       softradiuscb->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       softradiuscb->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == sensicb) {
             if (listener) {
                 listener->panelChanged(Evlocallabsensicb,
-                                       sensicb->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       sensicb->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
@@ -4845,70 +4835,70 @@ void LocallabCBDL::adjusterChanged(Adjuster* a, double newval)
             
             if (listener) {
                 listener->panelChanged(Evlocallabrecothrescb,
-                                       recothrescb->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       recothrescb->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == lowthrescb) {
             if (listener) {
                 listener->panelChanged(Evlocallablowthrescb,
-                                       lowthrescb->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       lowthrescb->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == higthrescb) {
             if (listener) {
                 listener->panelChanged(Evlocallabhigthrescb,
-                                       higthrescb->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       higthrescb->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == decaycb) {
             if (listener) {
                 listener->panelChanged(Evlocallabdecaycb,
-                                       decaycb->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       decaycb->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == blendmaskcb) {
             if (listener) {
                 listener->panelChanged(Evlocallabblendmaskcb,
-                                       blendmaskcb->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       blendmaskcb->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == radmaskcb) {
             if (listener) {
                 listener->panelChanged(Evlocallabradmaskcb,
-                                       radmaskcb->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       radmaskcb->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == lapmaskcb) {
             if (listener) {
                 listener->panelChanged(Evlocallablapmaskcb,
-                                       lapmaskcb->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       lapmaskcb->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == chromaskcb) {
             if (listener) {
                 listener->panelChanged(Evlocallabchromaskcb,
-                                       chromaskcb->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       chromaskcb->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == gammaskcb) {
             if (listener) {
                 listener->panelChanged(Evlocallabgammaskcb,
-                                       gammaskcb->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       gammaskcb->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == slomaskcb) {
             if (listener) {
                 listener->panelChanged(Evlocallabslomaskcb,
-                                       slomaskcb->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       slomaskcb->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -4920,28 +4910,28 @@ void LocallabCBDL::curveChanged(CurveEditor* ce)
         if (ce == CCmaskcbshape) {
             if (listener) {
                 listener->panelChanged(EvlocallabCCmaskcbshape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == LLmaskcbshape) {
             if (listener) {
                 listener->panelChanged(EvlocallabLLmaskcbshape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == HHmaskcbshape) {
             if (listener) {
                 listener->panelChanged(EvlocallabHHmaskcbshape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == Lmaskcbshape) {
             if (listener) {
                 listener->panelChanged(EvlocallabLmaskcbshape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -4953,10 +4943,10 @@ void LocallabCBDL::enabledChanged()
         if (listener) {
             if (exp->getEnabled()) {
                 listener->panelChanged(EvLocenacbdl,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(EvLocenacbdl,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -5102,10 +5092,10 @@ void LocallabCBDL::enacbMaskChanged()
         if (listener) {
             if (enacbMask->get_active()) {
                 listener->panelChanged(EvLocallabEnacbMask,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(EvLocallabEnacbMask,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -5607,8 +5597,6 @@ void LocallabLog::read(const rtengine::procparams::ProcParams* pp, const ParamsE
     if (index < (int)pp->locallab.spots.size()) {
         const LocallabParams::LocallabSpot& spot = pp->locallab.spots.at(index);
 
-        spotName = spot.name; // Update spot name according to selected spot
-
         exp->set_visible(spot.visilog);
         exp->setEnabled(spot.explog);
         complexity->set_active(spot.complexlog);
@@ -5781,10 +5769,10 @@ void LocallabLog::enaLMaskChanged()
         if (listener) {
             if (enaLMask->get_active()) {
                 listener->panelChanged(EvLocallabEnaLMask,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(EvLocallabEnaLMask,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -5961,35 +5949,35 @@ void LocallabLog::curveChanged(CurveEditor* ce)
         if (ce == HHmaskshapeL) {
             if (listener) {
                 listener->panelChanged(EvlocallabHHmaskshapeL,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == LLmaskshapeL) {
             if (listener) {
                 listener->panelChanged(EvlocallabLLmaskshapeL,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == CCmaskshapeL) {
             if (listener) {
                 listener->panelChanged(EvlocallabCCmaskshapeL,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == LmaskshapeL) {
             if (listener) {
                 listener->panelChanged(EvlocallabLmaskshapeL,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == LshapeL) {
             if (listener) {
                 listener->panelChanged(EvlocallabLshapeL,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
@@ -6046,84 +6034,84 @@ void LocallabLog::adjusterChanged(Adjuster* a, double newval)
         if (a == repar) {
             if (listener) {
                 listener->panelChanged(Evlocallabrepar,
-                                       repar->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       repar->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == blackEv) {
             if (listener) {
                 listener->panelChanged(EvlocallabblackEv,
-                                       blackEv->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       blackEv->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == whiteEv) {
             if (listener) {
                 listener->panelChanged(EvlocallabwhiteEv,
-                                       whiteEv->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       whiteEv->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == sourceGray) {
             if (listener) {
                 listener->panelChanged(EvlocallabsourceGray,
-                                       sourceGray->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       sourceGray->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == sourceabs) {
             if (listener) {
                 listener->panelChanged(Evlocallabsourceabs,
-                                       sourceabs->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       sourceabs->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == targabs) {
             if (listener) {
                 listener->panelChanged(Evlocallabtargabs,
-                                       targabs->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       targabs->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == targetGray) {
             if (listener) {
                 listener->panelChanged(EvlocallabtargetGray,
-                                       targetGray->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       targetGray->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == catad) {
             if (listener) {
                 listener->panelChanged(Evlocallabcatad,
-                                       catad->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       catad->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == saturl) {
             if (listener) {
                 listener->panelChanged(Evlocallabsaturl,
-                                       saturl->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       saturl->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == chroml) {
             if (listener) {
                 listener->panelChanged(Evlocallabchroml,
-                                       chroml->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       chroml->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == lightl) {
             if (listener) {
                 listener->panelChanged(Evlocallablightl,
-                                       lightl->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       lightl->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == lightq) {
             if (listener) {
                 listener->panelChanged(Evlocallablightq,
-                                       lightq->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       lightq->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
@@ -6131,42 +6119,42 @@ void LocallabLog::adjusterChanged(Adjuster* a, double newval)
         if (a == contl) {
             if (listener) {
                 listener->panelChanged(Evlocallabcontl,
-                                       contl->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       contl->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == contthres) {
             if (listener) {
                 listener->panelChanged(Evlocallabcontthres,
-                                       contthres->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       contthres->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == contq) {
             if (listener) {
                 listener->panelChanged(Evlocallabcontq,
-                                       contq->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       contq->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == colorfl) {
             if (listener) {
                 listener->panelChanged(Evlocallabcolorfl,
-                                       colorfl->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       colorfl->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == detail) {
             if (listener) {
                 listener->panelChanged(Evlocallabdetail,
-                                       detail->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       detail->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == baselog) {
             if (listener) {
                 listener->panelChanged(Evlocallabbaselog,
-                                       baselog->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       baselog->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
@@ -6174,28 +6162,28 @@ void LocallabLog::adjusterChanged(Adjuster* a, double newval)
             
             if (listener) {
                 listener->panelChanged(Evlocallabrecothresl,
-                                       recothresl->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       recothresl->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == lowthresl) {
             if (listener) {
                 listener->panelChanged(Evlocallablowthresl,
-                                       lowthresl->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       lowthresl->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == higthresl) {
             if (listener) {
                 listener->panelChanged(Evlocallabhigthresl,
-                                       higthresl->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       higthresl->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == decayl) {
             if (listener) {
                 listener->panelChanged(Evlocallabdecayl,
-                                       decayl->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       decayl->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
@@ -6203,42 +6191,42 @@ void LocallabLog::adjusterChanged(Adjuster* a, double newval)
         if (a == sensilog) {
             if (listener) {
                 listener->panelChanged(Evlocallabsensilog,
-                                       sensilog->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       sensilog->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == strlog) {
             if (listener) {
                 listener->panelChanged(Evlocallabstrlog,
-                                       strlog->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       strlog->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == anglog) {
             if (listener) {
                 listener->panelChanged(Evlocallabanglog,
-                                       anglog->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       anglog->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
         
         if (a == blendmaskL) {
             if (listener) {
                 listener->panelChanged(EvLocallabblendmaskL,
-                                       blendmaskL->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       blendmaskL->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == radmaskL) {
             if (listener) {
                 listener->panelChanged(EvLocallabradmaskL,
-                                       radmaskL->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       radmaskL->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == chromaskL) {
             if (listener) {
                 listener->panelChanged(EvLocallabchromaskL,
-                                       chromaskL->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       chromaskL->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
@@ -6274,10 +6262,10 @@ void LocallabLog::enabledChanged()
         if (listener) {
             if (exp->getEnabled()) {
                 listener->panelChanged(EvLocenalog,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(EvLocenalog,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -6288,7 +6276,7 @@ void LocallabLog::sursourChanged()
     if (isLocActivated && exp->getEnabled()) {
         if (listener) {
             listener->panelChanged(Evlocallabsursour,
-                                   sursour->get_active_text() + " (" + escapeHtmlChars(spotName) + ")");
+                                   sursour->get_active_text() + " (" + escapeHtmlChars(getSpotName()) + ")");
         }
     }
 }
@@ -6299,7 +6287,7 @@ void LocallabLog::surroundChanged()
     if (isLocActivated && exp->getEnabled()) {
         if (listener) {
             listener->panelChanged(Evlocallabsurround,
-                                   surround->get_active_text() + " (" + escapeHtmlChars(spotName) + ")");
+                                   surround->get_active_text() + " (" + escapeHtmlChars(getSpotName()) + ")");
         }
     }
 }
@@ -6313,10 +6301,10 @@ void LocallabLog::autocomputeToggled()
         if (listener) {
             if (autocompute->get_active()) {
                 listener->panelChanged(EvLocallabAuto,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(EvLocallabAuto,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -6354,10 +6342,10 @@ void LocallabLog::ciecamChanged()
         if (listener) {
             if (ciecam->get_active()) {
                 listener->panelChanged(Evlocallabciecam,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(Evlocallabciecam,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -6370,10 +6358,10 @@ void LocallabLog::fullimageChanged()
         if (listener) {
             if (fullimage->get_active()) {
                 listener->panelChanged(Evlocallabfullimage,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(Evlocallabfullimage,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -6404,10 +6392,10 @@ void LocallabLog::AutograyChanged()
         if (listener) {
             if (Autogray->get_active()) {
                 listener->panelChanged(EvlocallabAutogray,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(EvlocallabAutogray,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -6773,8 +6761,6 @@ void LocallabMask::read(const rtengine::procparams::ProcParams* pp, const Params
     if (index < (int)pp->locallab.spots.size()) {
         const LocallabParams::LocallabSpot& spot = pp->locallab.spots.at(index);
 
-        spotName = spot.name; // Update spot name according to selected spot
-
         exp->set_visible(spot.visimask);
         exp->setEnabled(spot.expmask);
         complexity->set_active(spot.complexmask);
@@ -6895,105 +6881,105 @@ void LocallabMask::adjusterChanged(Adjuster* a, double newval)
         if (a == sensimask) {
             if (listener) {
                 listener->panelChanged(Evlocallabsensimask,
-                                       sensimask->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       sensimask->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == blendmask) {
             if (listener) {
                 listener->panelChanged(Evlocallabblendmask,
-                                       blendmask->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       blendmask->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == blendmaskab) {
             if (listener) {
                 listener->panelChanged(Evlocallabblendmaskab,
-                                       blendmaskab->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       blendmaskab->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == softradiusmask) {
             if (listener) {
                 listener->panelChanged(Evlocallabsoftradiusmask,
-                                       softradiusmask->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       softradiusmask->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == strumaskmask) {
             if (listener) {
                 listener->panelChanged(Evlocallabstrumaskmask,
-                                       strumaskmask->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       strumaskmask->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == contmask) {
             if (listener) {
                 listener->panelChanged(Evlocallabcontmask,
-                                       contmask->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       contmask->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == blurmask) {
             if (listener) {
                 listener->panelChanged(Evlocallabblurmask,
-                                       blurmask->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       blurmask->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == radmask) {
             if (listener) {
                 listener->panelChanged(Evlocallabradmask,
-                                       radmask->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       radmask->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == lapmask) {
             if (listener) {
                 listener->panelChanged(Evlocallablapmask,
-                                       lapmask->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       lapmask->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == chromask) {
             if (listener) {
                 listener->panelChanged(Evlocallabchromask,
-                                       chromask->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       chromask->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == gammask) {
             if (listener) {
                 listener->panelChanged(Evlocallabgammask,
-                                       gammask->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       gammask->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == slopmask) {
             if (listener) {
                 listener->panelChanged(Evlocallabslopmask,
-                                       slopmask->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       slopmask->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == shadmask) {
             if (listener) {
                 listener->panelChanged(Evlocallabshadmask,
-                                       shadmask->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       shadmask->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == str_mask) {
             if (listener) {
                 listener->panelChanged(Evlocallabstr_mask,
-                                       str_mask->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       str_mask->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (a == ang_mask) {
             if (listener) {
                 listener->panelChanged(Evlocallabang_mask,
-                                       ang_mask->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
+                                       ang_mask->getTextValue() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
@@ -7006,7 +6992,7 @@ void LocallabMask::adjusterChanged2(ThresholdAdjuster* a, int newBottomL, int ne
         if (a == csThresholdmask) {
             if (listener) {
                 listener->panelChanged(EvlocallabcsThresholdmask,
-                                       csThresholdmask->getHistoryString() + " (" + escapeHtmlChars(spotName) + ")");
+                                       csThresholdmask->getHistoryString() + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -7018,42 +7004,42 @@ void LocallabMask::curveChanged(CurveEditor* ce)
         if (ce == CCmask_shape) {
             if (listener) {
                 listener->panelChanged(EvlocallabCCmask_shape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == LLmask_shape) {
             if (listener) {
                 listener->panelChanged(EvlocallabLLmask_shape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == HHmask_shape) {
             if (listener) {
                 listener->panelChanged(EvlocallabHHmask_shape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == HHhmask_shape) {
             if (listener) {
                 listener->panelChanged(EvlocallabHHhmask_shape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == Lmask_shape) {
             if (listener) {
                 listener->panelChanged(EvlocallabLmask_shape,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
         if (ce == LLmask_shapewav) {
             if (listener) {
                 listener->panelChanged(EvlocallabLLmask_shapewav,
-                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
 
@@ -7071,7 +7057,7 @@ void LocallabMask::complexityModeChanged()
 
         if (listener && isLocActivated) {
             listener->panelChanged(EvlocallabcomplexityWithRefresh,
-                                   M("TP_LOCALLAB_MODE_SIMPLE") + " (" + escapeHtmlChars(spotName) + ")");
+                                   M("TP_LOCALLAB_MODE_SIMPLE") + " (" + escapeHtmlChars(getSpotName()) + ")");
         }
     } else if (complexity->get_active_row_number() == Normal) { // New selected mode is Normal one
         // Convert tool widget parameters
@@ -7081,7 +7067,7 @@ void LocallabMask::complexityModeChanged()
 
         if (listener && isLocActivated) {
             listener->panelChanged(EvlocallabcomplexityWithRefresh,
-                                   M("TP_LOCALLAB_MODE_NORMAL") + " (" + escapeHtmlChars(spotName) + ")");
+                                   M("TP_LOCALLAB_MODE_NORMAL") + " (" + escapeHtmlChars(getSpotName()) + ")");
         }
     } else if (complexity->get_active_row_number() == Expert) { // New selected mode is Expert one
         // Update GUI based on new mode
@@ -7089,7 +7075,7 @@ void LocallabMask::complexityModeChanged()
 
         if (listener && isLocActivated) {
             listener->panelChanged(EvlocallabcomplexityWithRefresh,
-                                   M("TP_LOCALLAB_MODE_EXPERT") + " (" + escapeHtmlChars(spotName) + ")");
+                                   M("TP_LOCALLAB_MODE_EXPERT") + " (" + escapeHtmlChars(getSpotName()) + ")");
         }
     }
 }
@@ -7100,10 +7086,10 @@ void LocallabMask::enabledChanged()
         if (listener) {
             if (exp->getEnabled()) {
                 listener->panelChanged(EvLocena_mask,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(EvLocena_mask,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -7251,10 +7237,10 @@ void LocallabMask::enamaskChanged()
         if (listener) {
             if (enamask->get_active()) {
                 listener->panelChanged(EvLocallabEnaMask,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(EvLocallabEnaMask,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -7266,10 +7252,10 @@ void LocallabMask::toolmaskChanged()
         if (listener) {
             if (toolmask->get_active()) {
                 listener->panelChanged(EvLocallabtoolmask,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(EvLocallabtoolmask,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }
@@ -7284,10 +7270,10 @@ void LocallabMask::fftmaskChanged()
         if (listener) {
             if (fftmask->get_active()) {
                 listener->panelChanged(EvLocallabfftmask,
-                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_ENABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             } else {
                 listener->panelChanged(EvLocallabfftmask,
-                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
+                                       M("GENERAL_DISABLED") + " (" + escapeHtmlChars(getSpotName()) + ")");
             }
         }
     }