liz/rawTherapee
liz/rawTherapee
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
rawTherapee/rtgui/locallabtools.cc
Pandagrapher 968e267903 Add possibility to add/remove Locallab tools 
Change:
- Use tools list widget to add a Locallab tool to currently selected
spot. Remove Locallab tool from currently selected spot using cross on
tool title bar

Note:
- Spot parameters list in .pp3 file isn't optimized according to
added/removed Locallab tools
2019-09-09 21:52:06 +02:00

2747 lines
99 KiB
C++
Raw Blame History

/*
* This file is part of RawTherapee.
*
* Copyright (c) 2004-2010 Gabor Horvath <hgabor@rawtherapee.com>frame
*
*
* RawTherapee is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* RawTherapee is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with RawTherapee. If not, see <http://www.gnu.org/licenses/>.
* 2019 Pierre Cabrera <pierre.cab@gmail.com>
*/
#include "locallabtools.h"
#include "options.h"
#include "../rtengine/procparams.h"
#include "locallab.h"
using namespace rtengine;
using namespace procparams;
extern Options options;
/* ==== LocallabTool ==== */
LocallabTool::LocallabTool(Gtk::Box* content, Glib::ustring toolName, Glib::ustring UILabel, bool need11, maskType usemask):
ToolPanel(toolName, need11),
// LocallabTool parameters
useMask(usemask),
isLocActivated(false),
locToolListener(nullptr)
{
const bool showtooltip = options.showtooltip;
// Create expander title bar
Gtk::HBox* const titleBox = Gtk::manage(new Gtk::HBox());
Gtk::Label* const titleLabel = Gtk::manage(new Gtk::Label());
titleLabel->set_markup(Glib::ustring("<b>") + escapeHtmlChars(UILabel) + Glib::ustring("</b>"));
titleLabel->set_alignment(Gtk::ALIGN_START, Gtk::ALIGN_CENTER);
titleBox->pack_start(*titleLabel, Gtk::PACK_EXPAND_WIDGET, 0);
Gtk::EventBox* const removeEvBox = Gtk::manage(new Gtk::EventBox()); // Glue to manage mouse clicking event on remove image
removeEvBox->set_can_focus(false);
removeEvBox->set_above_child(false); // To have priority over expander title bar when mouse clicking on remove image
removeEvBox->signal_button_release_event().connect(sigc::mem_fun(this, &LocallabTool::on_remove_change));
RTImage* const removeImage = Gtk::manage(new RTImage("cancel-small.png"));
removeEvBox->add(*removeImage);
titleBox->pack_end(*removeEvBox, Gtk::PACK_SHRINK, 4);
if (need100Percent) {
RTImage* titleImage = Gtk::manage(new RTImage("one-to-one-small.png"));
if (showtooltip) {
titleImage->set_tooltip_text(M("TP_GENERAL_11SCALE_TOOLTIP"));
}
titleBox->pack_end(*titleImage, Gtk::PACK_SHRINK, 0);
}
exp = Gtk::manage(new MyExpander(true, titleBox));
exp->signal_button_release_event().connect_notify(sigc::mem_fun(this, &LocallabTool::foldThemAll));
enaExpConn = exp->signal_enabled_toggled().connect(sigc::mem_fun(*this, &LocallabTool::enabledChanged));
ToolParamBlock* const totalBox = Gtk::manage(new ToolParamBlock());
// Create panel for specific widget tools
totalBox->pack_start(*content, Gtk::PACK_SHRINK, 0);
// Create mask panel
if (useMask) {
maskExp = Gtk::manage(new MyExpander(false, M("TP_LOCALLAB_SHOW")));
setExpandAlignProperties(maskExp, true, false, Gtk::ALIGN_FILL, Gtk::ALIGN_START);
showMaskMethod = Gtk::manage(new MyComboBoxText());
showMaskMethod->append(M("TP_LOCALLAB_SHOWMNONE"));
showMaskMethod->append(M("TP_LOCALLAB_SHOWMODIF"));
showMaskMethod->append(M("TP_LOCALLAB_SHOWMODIFMASK"));
showMaskMethod->append(M("TP_LOCALLAB_SHOWMASK"));
showMaskMethod->append(M("TP_LOCALLAB_SHOWSTRUC"));
showMaskMethod->append(M("TP_LOCALLAB_PREVIEWSEL"));
showMaskMethod->set_active(0);
if (showtooltip) {
showMaskMethod->set_tooltip_markup(M("TP_LOCALLAB_SHOWMASKCOL_TOOLTIP"));
}
showMaskMethodConn = showMaskMethod->signal_changed().connect(sigc::mem_fun(*this, &LocallabTool::showMaskMethodChanged));
enaMask = Gtk::manage(new Gtk::CheckButton(M("TP_LOCALLAB_ENABLE_MASK")));
enaMaskConn = enaMask->signal_toggled().connect(sigc::mem_fun(*this, &LocallabTool::enaMaskChanged));
if (useMask == MaskWithTrMap) {
enaMaskTrMap = Gtk::manage(new Gtk::CheckButton(M("TP_LOCALLAB_TM_MASK")));
enaMaskTrMapConn = enaMaskTrMap->signal_toggled().connect(sigc::mem_fun(*this, &LocallabTool::enaMaskTrMapChanged));
}
maskCurveEditorG = new CurveEditorGroup(options.lastlocalCurvesDir, M("TP_LOCALLAB_MASK"));
maskCurveEditorG->setCurveListener(this);
CCMaskShape = static_cast<FlatCurveEditor*>(maskCurveEditorG->addCurve(CT_Flat, "C(C)", nullptr, false, false));
CCMaskShape->setIdentityValue(0.);
CCMaskShape->setResetCurve(FlatCurveType(LocallabParams::DEF_MASK_CURVE.at(0)), LocallabParams::DEF_MASK_CURVE);
if (showtooltip) {
CCMaskShape->setTooltip(M("TP_LOCALLAB_CURVEEDITOR_CC_TOOLTIP"));
}
CCMaskShape->setBottomBarColorProvider(this, 1);
std::vector<GradientMilestone> bgGradient;
bgGradient.push_back(GradientMilestone(0., 0., 0., 0.));
bgGradient.push_back(GradientMilestone(1., 1., 1., 1.));
LLMaskShape = static_cast<FlatCurveEditor*>(maskCurveEditorG->addCurve(CT_Flat, "L(L)", nullptr, false, false));
LLMaskShape->setIdentityValue(0.);
LLMaskShape->setResetCurve(FlatCurveType(LocallabParams::DEF_MASK_CURVE.at(0)), LocallabParams::DEF_MASK_CURVE);
if (showtooltip) {
LLMaskShape->setTooltip(M("TP_LOCALLAB_CURVEEDITOR_CC_TOOLTIP"));
}
LLMaskShape->setBottomBarBgGradient(bgGradient);
HHMaskShape = static_cast<FlatCurveEditor *>(maskCurveEditorG->addCurve(CT_Flat, "LC(H)", nullptr, false, true));
HHMaskShape->setIdentityValue(0.);
HHMaskShape->setResetCurve(FlatCurveType(LocallabParams::DEF_MASK_CURVE.at(0)), LocallabParams::DEF_MASK_CURVE);
if (showtooltip) {
HHMaskShape->setTooltip(M("TP_LOCALLAB_CURVEEDITOR_CC_TOOLTIP"));
}
HHMaskShape->setCurveColorProvider(this, 2);
HHMaskShape->setBottomBarColorProvider(this, 2);
maskCurveEditorG->curveListComplete();
blendMask = Gtk::manage(new Adjuster(M("TP_LOCALLAB_BLENDMASKCOL"), -100, 100, 1, 0));
blendMask->setAdjusterListener(this);
radMask = Gtk::manage(new Adjuster(M("TP_LOCALLAB_RADMASKCOL"), 0.0, 100.0, 0.1, 10.));
radMask->setAdjusterListener(this);
chroMask = Gtk::manage(new Adjuster(M("TP_LOCALLAB_CHROMASKCOL"), -100.0, 100.0, 0.1, 0.));
chroMask->setAdjusterListener(this);
gamMask = Gtk::manage(new Adjuster(M("TP_LOCALLAB_GAMMASKCOL"), 0.25, 4.0, 0.01, 1.));
gamMask->setAdjusterListener(this);
sloMask = Gtk::manage(new Adjuster(M("TP_LOCALLAB_SLOMASKCOL"), 0.0, 15.0, 0.1, 0.));
sloMask->setAdjusterListener(this);
ToolParamBlock* const maskBox = Gtk::manage(new ToolParamBlock());
maskBox->pack_start(*showMaskMethod, Gtk::PACK_SHRINK, 4);
maskBox->pack_start(*enaMask, Gtk::PACK_SHRINK, 0);
if (useMask == MaskWithTrMap) {
maskBox->pack_start(*enaMaskTrMap, Gtk::PACK_SHRINK, 0);
}
maskBox->pack_start(*maskCurveEditorG, Gtk::PACK_SHRINK, 4); // Padding is mandatory to correct behavior of curve editor
maskBox->pack_start(*blendMask, Gtk::PACK_SHRINK, 0);
maskBox->pack_start(*radMask, Gtk::PACK_SHRINK, 0);
maskBox->pack_start(*chroMask, Gtk::PACK_SHRINK, 0);
maskBox->pack_start(*gamMask, Gtk::PACK_SHRINK, 0);
maskBox->pack_start(*sloMask, Gtk::PACK_SHRINK, 0);
maskExp->add(*maskBox, false);
totalBox->pack_start(*maskExp, Gtk::PACK_SHRINK, 0);
}
exp->add(*totalBox, false);
}
LocallabTool::~LocallabTool()
{
idle_register.destroy();
if (useMask) {
delete maskCurveEditorG;
}
}
void LocallabTool::addLocallabTool(bool raiseEvent)
{
exp->set_visible(true);
// Raise event if required
if (raiseEvent) {
if (listener) {
listener->panelChanged(EvlocallabToolAdded,
toolName + " (" + escapeHtmlChars(spotName) + ")");
}
}
}
void LocallabTool::removeLocallabTool(bool raiseEvent)
{
exp->set_visible(false);
// Inform LocallabToolListener to update Locallab tools list
if (locToolListener) {
locToolListener->toolRemoved(this);
}
if (exp->getEnabled()) {
// Disable tool while removing it
disableListener();
exp->setEnabled(false);
enableListener();
// Raise event if required refreshing image
if (raiseEvent && listener) {
listener->panelChanged(EvlocallabToolRemovedWithRefresh,
toolName + " (" + escapeHtmlChars(spotName) + ")");
}
} else {
// Raise event if required without refreshing image
if (raiseEvent && listener) {
listener->panelChanged(EvlocallabToolRemovedWithoutRefresh,
toolName + " (" + escapeHtmlChars(spotName) + ")");
}
}
}
bool LocallabTool::isLocallabToolAdded()
{
return exp->get_visible();
}
void LocallabTool::resetMaskView()
{
if (useMask) {
showMaskMethodConn.block(true);
showMaskMethod->set_active(0);
showMaskMethodConn.block(false);
}
}
void LocallabTool::refChanged(const double huer, const double lumar, const double chromar)
{
if (useMask) {
// Hue reference normalization (between 0 and 1)
double normHuer = huer;
float h = Color::huelab_to_huehsv2(normHuer);
h += 1.f / 6.f;
if (h > 1.f) {
h -= 1.f;
}
normHuer = h;
// Luma reference normalization (between 0 and 1)
const double normLumar = lumar / 100.f;
// Chroma reference normalization (between 0 and 1)
const double normChromar = chromar / 137.4f;
// printf("nh=%f nl=%f nc=%f\n", normHuer, normLumar, normChromar);
idle_register.add(
[this, normHuer, normLumar, normChromar]() -> bool {
GThreadLock lock; // All GUI access from idle_add callbacks or separate thread HAVE to be protected
// Update mask background
CCMaskShape->updateLocallabBackground(normChromar);
LLMaskShape->updateLocallabBackground(normLumar);
HHMaskShape->updateLocallabBackground(normHuer);
return false;
}
);
}
}
void LocallabTool::colorForValue(double valX, double valY, enum ColorCaller::ElemType elemType, int callerId, ColorCaller* caller)
{
if (useMask) {
float R = 0.f;
float G = 0.f;
float B = 0.f;
if (elemType == ColorCaller::CCET_VERTICAL_BAR) {
valY = 0.5;
}
switch (callerId) {
case 1: // CCmaskshape
Color::hsv2rgb01(float(valY), float(valX), 0.5f, R, G, B);
break;
case 2: // HHmaskshape
float x = valX - 1.f / 6.f;
if (x < 0.f) {
x += 1.f;
}
x = log2lin(x, 3.f);
Color::hsv2rgb01(x, 0.5f, 0.5f, R, G, B);
}
caller->ccRed = double (R);
caller->ccGreen = double (G);
caller->ccBlue = double (B);
}
}
void LocallabTool::disableListener()
{
ToolPanel::disableListener();
enaExpConn.block(true);
if (useMask) {
enaMaskConn.block(true);
if (useMask == MaskWithTrMap) {
enaMaskTrMapConn.block(true);
}
showMaskMethodConn.block(true);
}
}
void LocallabTool::enableListener()
{
ToolPanel::enableListener();
enaExpConn.block(false);
if (useMask) {
enaMaskConn.block(false);
if (useMask == MaskWithTrMap) {
enaMaskTrMapConn.block(false);
}
showMaskMethodConn.block(false);
}
}
bool LocallabTool::on_remove_change(GdkEventButton* event)
{
if (event->button == GDK_BUTTON_PRIMARY) {
// Remove Locallab tool raising an event
removeLocallabTool(true);
}
return true; // No event propagation further (to avoid closing expander when mouse clicking on remove image)
}
void LocallabTool::foldThemAll(GdkEventButton* event)
{
if (event->button == GDK_BUTTON_SECONDARY) {
if (locToolListener) {
(static_cast<Locallab*>(locToolListener))->foldAllButOne(this);
}
}
}
/* ==== LocallabColor ==== */
LocallabColor::LocallabColor():
LocallabTool(this, M("TP_LOCALLAB_COLOR_TOOLNAME"), M("TP_LOCALLAB_COFR"), false, MaskNormal),
// Color & Light specific widgets
curvactiv(Gtk::manage(new Gtk::CheckButton(M("TP_LOCALLAB_CURV")))),
lightness(Gtk::manage(new Adjuster(M("TP_LOCALLAB_LIGHTNESS"), -100, 100, 1, 0))),
contrast(Gtk::manage(new Adjuster(M("TP_LOCALLAB_CONTRAST"), -100, 100, 1, 0))),
chroma(Gtk::manage(new Adjuster(M("TP_LOCALLAB_CHROMA"), -100, 150, 1, 0))),
gridFrame(Gtk::manage(new Gtk::Frame(M("TP_LOCALLAB_LABGRID")))),
labgrid(Gtk::manage(new LabGrid(EvLocallabLabGridValue, M("TP_LOCALLAB_LABGRID_VALUES")))),
gridMethod(Gtk::manage(new MyComboBoxText())),
strengthgrid(Gtk::manage(new Adjuster(M("TP_LOCALLAB_STRGRID"), 0, 100, 1, 30))),
sensi(Gtk::manage(new Adjuster(M("TP_LOCALLAB_SENSI"), 0, 100, 1, 15))),
structcol(Gtk::manage(new Adjuster(M("TP_LOCALLAB_STRUCCOL"), 0, 100, 1, 0))),
blurcolde(Gtk::manage(new Adjuster(M("TP_LOCALLAB_BLURDE"), 2, 100, 1, 5))),
softradiuscol(Gtk::manage(new Adjuster(M("TP_LOCALLAB_SOFTRADIUSCOL"), 0.0, 100.0, 0.1, 0.))),
labqualcurv(Gtk::manage(new Gtk::Label(M("TP_LOCALLAB_QUALCURV_METHOD") + ":"))),
qualitycurveMethod(Gtk::manage(new MyComboBoxText())),
llCurveEditorG(new CurveEditorGroup(options.lastlocalCurvesDir, M("TP_LOCALLAB_LUM"))),
HCurveEditorG(new CurveEditorGroup(options.lastlocalCurvesDir, M("TP_LOCALLAB_HLH"))),
invers(Gtk::manage(new Gtk::CheckButton(M("TP_LOCALLAB_INVERS"))))
{
float R, G, B;
const bool showtooltip = options.showtooltip;
curvactivConn = curvactiv->signal_toggled().connect(sigc::mem_fun(*this, &LocallabColor::curvactivChanged));
lightness->setAdjusterListener(this);
if (showtooltip) {
lightness->set_tooltip_text(M("TP_LOCALLAB_EXPCOLOR_TOOLTIP"));
}
contrast->setAdjusterListener(this);
chroma->setAdjusterListener(this);
gridMethod->append(M("TP_LOCALLAB_GRIDONE"));
gridMethod->append(M("TP_LOCALLAB_GRIDTWO"));
gridMethod->set_active(0);
gridMethodConn = gridMethod->signal_changed().connect(sigc::mem_fun(*this, &LocallabColor::gridMethodChanged));
strengthgrid->setAdjusterListener(this);
sensi->setAdjusterListener(this);
if (showtooltip) {
sensi->set_tooltip_text(M("TP_LOCALLAB_SENSI_TOOLTIP"));
}
structcol->setAdjusterListener(this);
blurcolde->setAdjusterListener(this);
softradiuscol->setAdjusterListener(this);
qualitycurveMethod->append(M("TP_LOCALLAB_CURVNONE"));
qualitycurveMethod->append(M("TP_LOCALLAB_CURVCURR"));
qualitycurveMethod->set_active(0);
if (showtooltip) {
qualitycurveMethod->set_tooltip_markup(M("TP_LOCALLAB_CURVEMETHOD_TOOLTIP"));
}
qualitycurveMethodConn = qualitycurveMethod->signal_changed().connect(sigc::mem_fun(*this, &LocallabColor::qualitycurveMethodChanged));
llCurveEditorG->setCurveListener(this);
llshape = static_cast<DiagonalCurveEditor*>(llCurveEditorG->addCurve(CT_Diagonal, "L(L)"));
llshape->setResetCurve(DiagonalCurveType(LocallabParams::DEF_COLOR_LCURVE.at(0)), LocallabParams::DEF_COLOR_LCURVE);
if (showtooltip) {
llshape->setTooltip(M("TP_LOCALLAB_CURVEEDITOR_LL_TOOLTIP"));
}
std::vector<GradientMilestone> mllshape;
mllshape.push_back(GradientMilestone(0., 0., 0., 0.));
mllshape.push_back(GradientMilestone(1., 1., 1., 1.));
llshape->setBottomBarBgGradient(mllshape);
llshape->setLeftBarBgGradient(mllshape);
ccshape = static_cast<DiagonalCurveEditor*>(llCurveEditorG->addCurve(CT_Diagonal, "C(C)"));
ccshape->setResetCurve(DiagonalCurveType(LocallabParams::DEF_COLOR_LCURVE.at(0)), LocallabParams::DEF_COLOR_LCURVE);
if (showtooltip) {
ccshape->setTooltip(M("TP_LOCALLAB_CURVEEDITOR_LL_TOOLTIP"));
}
std::vector<GradientMilestone> mccshape;
mccshape.push_back(GradientMilestone(0., 0., 0., 0.));
mccshape.push_back(GradientMilestone(1., 1., 1., 1.));
ccshape->setBottomBarBgGradient(mccshape);
ccshape->setLeftBarBgGradient(mccshape);
// llCurveEditorG->newLine();
llCurveEditorG->curveListComplete();
HCurveEditorG->setCurveListener(this);
LHshape = static_cast<FlatCurveEditor*>(HCurveEditorG->addCurve(CT_Flat, "L(H)", nullptr, false, true));
LHshape->setIdentityValue(0.);
LHshape->setResetCurve(FlatCurveType(LocallabParams::DEF_COLOR_HCURVE.at(0)), LocallabParams::DEF_COLOR_HCURVE);
if (showtooltip) {
LHshape->setTooltip(M("TP_LOCALLAB_CURVEEDITOR_LL_TOOLTIP"));
}
LHshape->setCurveColorProvider(this, 3);
std::vector<GradientMilestone> mLHshape;
for (int i = 0; i < 7; i++) {
float x = float (i) * (1.0f / 6.0);
Color::hsv2rgb01(x, 0.5f, 0.5f, R, G, B);
mLHshape.push_back(GradientMilestone(double (x), double (R), double (G), double (B)));
}
LHshape->setBottomBarBgGradient(mLHshape);
HHshape = static_cast<FlatCurveEditor*>(HCurveEditorG->addCurve(CT_Flat, "H(H)", nullptr, false, true));
HHshape->setIdentityValue(0.);
HHshape->setResetCurve(FlatCurveType(LocallabParams::DEF_COLOR_HCURVE.at(0)), LocallabParams::DEF_COLOR_HCURVE);
if (showtooltip) {
HHshape->setTooltip(M("TP_LOCALLAB_CURVEEDITOR_LL_TOOLTIP"));
}
HHshape->setCurveColorProvider(this, 3);
std::vector<GradientMilestone> mHHshape;
for (int i = 0; i < 7; i++) {
float x = float (i) * (1.0f / 6.0);
Color::hsv2rgb01(x, 0.5f, 0.5f, R, G, B);
mHHshape.push_back(GradientMilestone(double (x), double (R), double (G), double (B)));
}
HHshape->setBottomBarBgGradient(mHHshape);
HCurveEditorG->curveListComplete();
inversConn = invers->signal_toggled().connect(sigc::mem_fun(*this, &LocallabColor::inversChanged));
Gtk::Frame* const superFrame = Gtk::manage(new Gtk::Frame());
superFrame->set_label_align(0.025, 0.5);
superFrame->set_label_widget(*curvactiv);
ToolParamBlock* const superBox = Gtk::manage(new ToolParamBlock());
superBox->pack_start(*lightness);
superBox->pack_start(*contrast);
superBox->pack_start(*chroma);
gridFrame->set_label_align(0.025, 0.5);
ToolParamBlock* const gridBox = Gtk::manage(new ToolParamBlock());
gridBox->pack_start(*labgrid);
gridBox->pack_start(*gridMethod);
gridBox->pack_start(*strengthgrid);
gridFrame->add(*gridBox);
superBox->pack_start(*gridFrame);
superFrame->add(*superBox);
pack_start(*superFrame);
pack_start(*sensi);
pack_start(*structcol);
pack_start(*blurcolde);
pack_start(*softradiuscol);
Gtk::HBox* const qualcurvbox = Gtk::manage(new Gtk::HBox());
qualcurvbox->pack_start(*labqualcurv, Gtk::PACK_SHRINK, 4);
qualcurvbox->pack_start(*qualitycurveMethod);
pack_start(*qualcurvbox);
pack_start(*llCurveEditorG, Gtk::PACK_SHRINK, 4); // Padding is mandatory to correct behavior of curve editor
pack_start(*HCurveEditorG, Gtk::PACK_SHRINK, 4); // Padding is mandatory to correct behavior of curve editor
pack_start(*invers);
}
LocallabColor::~LocallabColor()
{
delete llCurveEditorG;
delete HCurveEditorG;
}
void LocallabColor::setListener(ToolPanelListener* tpl)
{
LocallabTool::setListener(tpl);
labgrid->setListener(tpl);
}
void LocallabColor::getMaskView(int &colorMask, int &expMask, int &shMask, int &softMask, int &tmMask, int &retiMask, int &cbMask)
{
colorMask = showMaskMethod->get_active_row_number();
}
void LocallabColor::colorForValue(double valX, double valY, enum ColorCaller::ElemType elemType, int callerId, ColorCaller* caller)
{
LocallabTool::colorForValue(valX, valY, elemType, callerId, caller); // Mask curves
float R = 0.f;
float G = 0.f;
float B = 0.f;
if (elemType == ColorCaller::CCET_VERTICAL_BAR) {
valY = 0.5;
}
if (callerId == 3) { // LHshape and HHshape curves
Color::hsv2rgb01(float (valX), float (valY), 0.5f, R, G, B);
caller->ccRed = double (R);
caller->ccGreen = double (G);
caller->ccBlue = double (B);
}
}
void LocallabColor::disableListener()
{
LocallabTool::disableListener();
curvactivConn.block(true);
gridMethodConn.block(true);
qualitycurveMethodConn.block(true);
inversConn.block(true);
}
void LocallabColor::enableListener()
{
LocallabTool::enableListener();
curvactivConn.block(false);
gridMethodConn.block(false);
qualitycurveMethodConn.block(false);
inversConn.block(false);
}
void LocallabColor::read(const rtengine::procparams::ProcParams* pp, const ParamsEdited* pedited)
{
// Disable all listeners
disableListener();
// Update GUI to selected spot value
const int index = pp->locallab.selspot;
if (index < (int)pp->locallab.spots.size()) {
spotName = pp->locallab.spots.at(index).name; // Update spot name according to selected spot
exp->set_visible(pp->locallab.spots.at(index).visicolor);
exp->setEnabled(pp->locallab.spots.at(index).expcolor);
curvactiv->set_active(pp->locallab.spots.at(index).curvactiv);
lightness->setValue(pp->locallab.spots.at(index).lightness);
contrast->setValue(pp->locallab.spots.at(index).contrast);
chroma->setValue(pp->locallab.spots.at(index).chroma);
labgrid->setParams(pp->locallab.spots.at(index).labgridALow / LocallabParams::LABGRIDL_CORR_MAX,
pp->locallab.spots.at(index).labgridBLow / LocallabParams::LABGRIDL_CORR_MAX,
pp->locallab.spots.at(index).labgridAHigh / LocallabParams::LABGRIDL_CORR_MAX,
pp->locallab.spots.at(index).labgridBHigh / LocallabParams::LABGRIDL_CORR_MAX,
false);
if (pp->locallab.spots.at(index).gridMethod == "one") {
gridMethod->set_active(0);
} else if (pp->locallab.spots.at(index).gridMethod == "two") {
gridMethod->set_active(1);
}
strengthgrid->setValue(pp->locallab.spots.at(index).strengthgrid);
sensi->setValue(pp->locallab.spots.at(index).sensi);
structcol->setValue(pp->locallab.spots.at(index).structcol);
blurcolde->setValue(pp->locallab.spots.at(index).blurcolde);
softradiuscol->setValue(pp->locallab.spots.at(index).softradiuscol);
if (pp->locallab.spots.at(index).qualitycurveMethod == "none") {
qualitycurveMethod->set_active(0);
} else if (pp->locallab.spots.at(index).qualitycurveMethod == "std") {
qualitycurveMethod->set_active(1);
}
llshape->setCurve(pp->locallab.spots.at(index).llcurve);
ccshape->setCurve(pp->locallab.spots.at(index).cccurve);
LHshape->setCurve(pp->locallab.spots.at(index).LHcurve);
HHshape->setCurve(pp->locallab.spots.at(index).HHcurve);
invers->set_active(pp->locallab.spots.at(index).invers);
enaMask->set_active(pp->locallab.spots.at(index).enaColorMask);
CCMaskShape->setCurve(pp->locallab.spots.at(index).CCmaskcurve);
LLMaskShape->setCurve(pp->locallab.spots.at(index).LLmaskcurve);
HHMaskShape->setCurve(pp->locallab.spots.at(index).HHmaskcurve);
blendMask->setValue(pp->locallab.spots.at(index).blendmaskcol);
radMask->setValue(pp->locallab.spots.at(index).radmaskcol);
chroMask->setValue(pp->locallab.spots.at(index).chromaskcol);
gamMask->setValue(pp->locallab.spots.at(index).gammaskcol);
sloMask->setValue(pp->locallab.spots.at(index).slomaskcol);
}
// Enable all listeners
enableListener();
// Update GUI according to invers button state
updateColorGUI();
// Note: No need to manage pedited as batch mode is deactivated for Locallab
}
void LocallabColor::write(rtengine::procparams::ProcParams* pp, ParamsEdited* pedited)
{
const int index = pp->locallab.selspot;
if (index < (int)pp->locallab.spots.size()) {
pp->locallab.spots.at(index).expcolor = exp->getEnabled();
pp->locallab.spots.at(index).visicolor = exp->get_visible();
pp->locallab.spots.at(index).curvactiv = curvactiv->get_active();
pp->locallab.spots.at(index).lightness = lightness->getIntValue();
pp->locallab.spots.at(index).contrast = contrast->getIntValue();
pp->locallab.spots.at(index).chroma = chroma->getIntValue();
labgrid->getParams(pp->locallab.spots.at(index).labgridALow,
pp->locallab.spots.at(index).labgridBLow,
pp->locallab.spots.at(index).labgridAHigh,
pp->locallab.spots.at(index).labgridBHigh);
pp->locallab.spots.at(index).labgridALow *= LocallabParams::LABGRIDL_CORR_MAX;
pp->locallab.spots.at(index).labgridAHigh *= LocallabParams::LABGRIDL_CORR_MAX;
pp->locallab.spots.at(index).labgridBLow *= LocallabParams::LABGRIDL_CORR_MAX;
pp->locallab.spots.at(index).labgridBHigh *= LocallabParams::LABGRIDL_CORR_MAX;
if (gridMethod->get_active_row_number() == 0) {
pp->locallab.spots.at(pp->locallab.selspot).gridMethod = "one";
} else if (gridMethod->get_active_row_number() == 1) {
pp->locallab.spots.at(pp->locallab.selspot).gridMethod = "two";
}
pp->locallab.spots.at(index).strengthgrid = strengthgrid->getIntValue();
pp->locallab.spots.at(index).sensi = sensi->getIntValue();
pp->locallab.spots.at(index).structcol = structcol->getIntValue();
pp->locallab.spots.at(index).blurcolde = blurcolde->getIntValue();
pp->locallab.spots.at(index).softradiuscol = softradiuscol->getValue();
if (qualitycurveMethod->get_active_row_number() == 0) {
pp->locallab.spots.at(index).qualitycurveMethod = "none";
} else if (qualitycurveMethod->get_active_row_number() == 1) {
pp->locallab.spots.at(index).qualitycurveMethod = "std";
}
pp->locallab.spots.at(index).llcurve = llshape->getCurve();
pp->locallab.spots.at(index).cccurve = ccshape->getCurve();
pp->locallab.spots.at(index).LHcurve = LHshape->getCurve();
pp->locallab.spots.at(index).HHcurve = HHshape->getCurve();
pp->locallab.spots.at(index).invers = invers->get_active();
pp->locallab.spots.at(index).enaColorMask = enaMask->get_active();
pp->locallab.spots.at(index).CCmaskcurve = CCMaskShape->getCurve();
pp->locallab.spots.at(index).LLmaskcurve = LLMaskShape->getCurve();
pp->locallab.spots.at(index).HHmaskcurve = HHMaskShape->getCurve();
pp->locallab.spots.at(index).blendmaskcol = blendMask->getIntValue();
pp->locallab.spots.at(index).radmaskcol = radMask->getValue();
pp->locallab.spots.at(index).chromaskcol = chroMask->getValue();
pp->locallab.spots.at(index).gammaskcol = gamMask->getValue();
pp->locallab.spots.at(index).slomaskcol = sloMask->getValue();
}
// Note: No need to manage pedited as batch mode is deactivated for Locallab
}
void LocallabColor::setDefaults(const rtengine::procparams::ProcParams* defParams, const ParamsEdited* pedited)
{
const int index = defParams->locallab.selspot;
if (index < (int)defParams->locallab.spots.size()) {
const LocallabParams::LocallabSpot defSpot = defParams->locallab.spots.at(index);
// Set default value for adjuster and labgrid widgets
lightness->setDefault((double)defSpot.lightness);
contrast->setDefault((double)defSpot.contrast);
chroma->setDefault((double)defSpot.chroma);
labgrid->setDefault(defSpot.labgridALow / LocallabParams::LABGRIDL_CORR_MAX,
defSpot.labgridBLow / LocallabParams::LABGRIDL_CORR_MAX,
defSpot.labgridAHigh / LocallabParams::LABGRIDL_CORR_MAX,
defSpot.labgridBHigh / LocallabParams::LABGRIDL_CORR_MAX);
strengthgrid->setDefault((double) defSpot.strengthgrid);
sensi->setDefault((double)defSpot.sensi);
structcol->setDefault((double)defSpot.structcol);
blurcolde->setDefault((double)defSpot.blurcolde);
softradiuscol->setDefault(defSpot.softradiuscol);
blendMask->setDefault((double)defSpot.blendmaskcol);
radMask->setDefault(defSpot.radmaskcol);
chroMask->setDefault(defSpot.chromaskcol);
gamMask->setDefault(defSpot.gammaskcol);
sloMask->setDefault(defSpot.slomaskcol);
}
// Note: No need to manage pedited as batch mode is deactivated for Locallab
}
void LocallabColor::adjusterChanged(Adjuster* a, double newval)
{
if (isLocActivated && exp->getEnabled()) {
if (a == lightness) {
if (listener) {
listener->panelChanged(Evlocallablightness,
lightness->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == contrast) {
if (listener) {
listener->panelChanged(Evlocallabcontrast,
contrast->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == chroma) {
if (listener) {
listener->panelChanged(Evlocallabchroma,
chroma->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == strengthgrid) {
if (listener) {
listener->panelChanged(EvLocallabLabstrengthgrid,
strengthgrid->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == sensi) {
if (listener) {
listener->panelChanged(Evlocallabsensi,
sensi->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == structcol) {
if (listener) {
listener->panelChanged(Evlocallabstructcol,
structcol->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == blurcolde) {
if (listener) {
listener->panelChanged(Evlocallabblurcolde,
blurcolde->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == softradiuscol) {
if (listener) {
listener->panelChanged(Evlocallabsoftradiuscol,
softradiuscol->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == blendMask) {
if (listener) {
listener->panelChanged(Evlocallabblendmaskcol,
blendMask->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == radMask) {
if (listener) {
listener->panelChanged(Evlocallabradmaskcol,
radMask->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == chroMask) {
if (listener) {
listener->panelChanged(Evlocallabchromaskcol,
chroMask->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == gamMask) {
if (listener) {
listener->panelChanged(Evlocallabgammaskcol,
gamMask->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == sloMask) {
if (listener) {
listener->panelChanged(Evlocallabslomaskcol,
sloMask->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
}
}
void LocallabColor::curveChanged(CurveEditor* ce)
{
if (isLocActivated && exp->getEnabled()) {
if (ce == llshape) {
if (listener) {
listener->panelChanged(Evlocallabllshape,
M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (ce == ccshape) {
if (listener) {
listener->panelChanged(Evlocallabccshape,
M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (ce == LHshape) {
if (listener) {
listener->panelChanged(EvlocallabLHshape,
M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (ce == HHshape) {
if (listener) {
listener->panelChanged(EvlocallabHHshape,
M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (ce == CCMaskShape) {
if (listener) {
listener->panelChanged(EvlocallabCCmaskshape,
M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (ce == LLMaskShape) {
if (listener) {
listener->panelChanged(EvlocallabLLmaskshape,
M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (ce == HHMaskShape) {
if (listener) {
listener->panelChanged(EvlocallabHHmaskshape,
M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
}
}
}
}
void LocallabColor::enabledChanged()
{
if (isLocActivated) {
if (listener) {
if (exp->getEnabled()) {
listener->panelChanged(EvLocenacolor,
M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
} else {
listener->panelChanged(EvLocenacolor,
M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
}
}
}
}
void LocallabColor::enaMaskChanged()
{
if (isLocActivated && exp->getEnabled()) {
if (listener) {
if (enaMask->get_active()) {
listener->panelChanged(EvLocallabEnaColorMask,
M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
} else {
listener->panelChanged(EvLocallabEnaColorMask,
M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
}
}
}
}
void LocallabColor::showMaskMethodChanged()
{
// If mask preview is activated, deactivate all other tool mask preview
if (locToolListener) {
locToolListener->resetOtherMaskView(this);
}
if (listener) {
listener->panelChanged(EvlocallabshowmaskMethod, "");
}
}
void LocallabColor::curvactivChanged()
{
if (isLocActivated && exp->getEnabled()) {
if (listener) {
if (curvactiv->get_active()) {
listener->panelChanged(Evlocallabcurvactiv,
M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
} else {
listener->panelChanged(Evlocallabcurvactiv,
M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
}
}
}
}
void LocallabColor::inversChanged()
{
updateColorGUI(); // Update GUI according to invers button state
if (isLocActivated && exp->getEnabled()) {
if (listener) {
if (invers->get_active()) {
listener->panelChanged(Evlocallabinvers,
M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
} else {
listener->panelChanged(Evlocallabinvers,
M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
}
}
}
}
void LocallabColor::qualitycurveMethodChanged()
{
if (isLocActivated && exp->getEnabled()) {
if (listener) {
listener->panelChanged(EvlocallabqualitycurveMethod,
qualitycurveMethod->get_active_text() + " (" + escapeHtmlChars(spotName) + ")");
}
}
}
void LocallabColor::gridMethodChanged()
{
if (isLocActivated && exp->getEnabled()) {
if (listener) {
listener->panelChanged(EvLocallabgridMethod,
gridMethod->get_active_text() + " (" + escapeHtmlChars(spotName) + ")");
}
}
}
void LocallabColor::updateColorGUI()
{
if (invers->get_active()) {
sensi->show();
llCurveEditorG->show();
HCurveEditorG->hide();
curvactiv->hide();
qualitycurveMethod->hide();
labqualcurv->hide();
maskExp->hide();
structcol->hide();
blurcolde->show();
gridFrame->hide();
strengthgrid->hide();
softradiuscol->hide();
} else {
sensi->show();
llCurveEditorG->show();
HCurveEditorG->show();
curvactiv->hide();
qualitycurveMethod->show();
labqualcurv->show();
maskExp->show();
structcol->show();
blurcolde->show();
gridFrame->show();
softradiuscol->show();
}
}
/* ==== LocallabExposure ==== */
LocallabExposure::LocallabExposure():
LocallabTool(this, M("TP_LOCALLAB_EXP_TOOLNAME"), M("TP_LOCALLAB_EXPOSE"), false, MaskNormal),
// Exposure specific widgets
expMethod(Gtk::manage(new MyComboBoxText())),
pdeFrame(Gtk::manage(new Gtk::Frame(M("TP_LOCALLAB_PDEFRA")))),
laplacexp(Gtk::manage(new Adjuster(M("TP_LOCALLAB_LAPLACEXP"), 0.0, 100.0, 0.1, 20.))),
linear(Gtk::manage(new Adjuster(M("TP_LOCALLAB_LINEAR"), 0., 1., 0.01, 0.))),
balanexp(Gtk::manage(new Adjuster(M("TP_LOCALLAB_BALANEXP"), 0.2, 1.2, 0.01, 0.8))),
expcomp(Gtk::manage(new Adjuster(M("TP_EXPOSURE_EXPCOMP"), -2.0, 4.0, 0.05, 0.0))),
hlcompr(Gtk::manage(new Adjuster(M("TP_EXPOSURE_COMPRHIGHLIGHTS"), 0, 500, 1, 0))),
hlcomprthresh(Gtk::manage(new Adjuster(M("TP_EXPOSURE_COMPRHIGHLIGHTSTHRESHOLD"), 0, 100, 1, 0))),
black(Gtk::manage(new Adjuster(M("TP_EXPOSURE_BLACKLEVEL"), -16384, 32768, 50, 0))),
shadex(Gtk::manage(new Adjuster(M("TP_LOCALLAB_SHADEX"), 0, 100, 1, 0))),
shcompr(Gtk::manage(new Adjuster(M("TP_LOCALLAB_SHADEXCOMP"), 0, 100, 1, 50))),
expchroma(Gtk::manage(new Adjuster(M("TP_LOCALLAB_EXPCHROMA"), -50, 100, 1, 30))),
warm(Gtk::manage(new Adjuster(M("TP_LOCALLAB_WARM"), -100., 100., 1., 0., Gtk::manage(new RTImage("circle-blue-small.png")), Gtk::manage(new RTImage("circle-orange-small.png"))))),
sensiex(Gtk::manage(new Adjuster(M("TP_LOCALLAB_SENSI"), 0, 100, 1, 15))),
structexp(Gtk::manage(new Adjuster(M("TP_LOCALLAB_STRUCCOL"), 0, 100, 1, 0))),
blurexpde(Gtk::manage(new Adjuster(M("TP_LOCALLAB_BLURDE"), 2, 100, 1, 5))),
softradiusexp(Gtk::manage(new Adjuster(M("TP_LOCALLAB_SOFTRADIUSCOL"), 0.0, 100.0, 0.1, 0.))),
curveEditorG(new CurveEditorGroup(options.lastlocalCurvesDir, M("TP_LOCALLAB_CURVEEDITOR_TONES_LABEL"))),
inversex(Gtk::manage(new Gtk::CheckButton(M("TP_LOCALLAB_INVERS"))))
{
const bool showtooltip = options.showtooltip;
if (showtooltip) {
exp->set_tooltip_text(M("TP_LOCALLAB_EXPOSURE_TOOLTIP"));
}
expMethod->append(M("TP_LOCALLAB_STD"));
expMethod->append(M("TP_LOCALLAB_PDE"));
expMethod->set_active(0);
expMethodConn = expMethod->signal_changed().connect(sigc::mem_fun(*this, &LocallabExposure::expMethodChanged));
if (showtooltip) {
expMethod->set_tooltip_text(M("TP_LOCALLAB_EXPMETHOD_TOOLTIP"));
}
pdeFrame->set_label_align(0.025, 0.5);
laplacexp->setAdjusterListener(this);
linear->setAdjusterListener(this);
balanexp->setAdjusterListener(this);
expcomp->setAdjusterListener(this);
hlcompr->setAdjusterListener(this);
hlcomprthresh->setAdjusterListener(this);
black->setAdjusterListener(this);
shadex->setAdjusterListener(this);
shcompr->setAdjusterListener(this);
expchroma->setAdjusterListener(this);
if (showtooltip) {
warm->set_tooltip_text(M("TP_LOCALLAB_WARM_TOOLTIP"));
}
warm->setAdjusterListener(this);
if (showtooltip) {
sensiex->set_tooltip_text(M("TP_LOCALLAB_SENSI_TOOLTIP"));
}
sensiex->setAdjusterListener(this);
structexp->setAdjusterListener(this);
blurexpde->setAdjusterListener(this);
softradiusexp->setAdjusterListener(this);
curveEditorG->setCurveListener(this);
shapeexpos = static_cast<DiagonalCurveEditor*>(curveEditorG->addCurve(CT_Diagonal, ""));
shapeexpos->setResetCurve(DiagonalCurveType(LocallabParams::DEF_EXP_CURVE.at(0)), LocallabParams::DEF_EXP_CURVE);
if (showtooltip) {
shapeexpos->setTooltip(M("TP_LOCALLAB_CURVEEDITOR_TONES_TOOLTIP"));
}
std::vector<GradientMilestone> mshapeexpos;
mshapeexpos.push_back(GradientMilestone(0., 0., 0., 0.));
mshapeexpos.push_back(GradientMilestone(1., 1., 1., 1.));
shapeexpos->setBottomBarBgGradient(mshapeexpos);
shapeexpos->setLeftBarBgGradient(mshapeexpos);
curveEditorG->curveListComplete();
inversexConn = inversex->signal_toggled().connect(sigc::mem_fun(*this, &LocallabExposure::inversexChanged));
pack_start(*expMethod);
ToolParamBlock* const pdeBox = Gtk::manage(new ToolParamBlock());
pdeBox->pack_start(*laplacexp);
pdeBox->pack_start(*linear);
pdeBox->pack_start(*balanexp);
pdeFrame->add(*pdeBox);
pack_start(*pdeFrame);
pack_start(*expcomp);
pack_start(*hlcompr);
pack_start(*hlcomprthresh);
pack_start(*black);
pack_start(*shadex);
pack_start(*shcompr);
pack_start(*expchroma);
pack_start(*warm);
pack_start(*sensiex);
pack_start(*structexp);
pack_start(*blurexpde);
pack_start(*softradiusexp);
pack_start(*curveEditorG, Gtk::PACK_SHRINK, 4); // Padding is mandatory to correct behavior of curve editor
pack_start(*inversex);
}
LocallabExposure::~LocallabExposure()
{
delete curveEditorG;
}
void LocallabExposure::getMaskView(int &colorMask, int &expMask, int &shMask, int &softMask, int &tmMask, int &retiMask, int &cbMask)
{
expMask = showMaskMethod->get_active_row_number();
}
void LocallabExposure::disableListener()
{
LocallabTool::disableListener();
expMethodConn.block(true);
inversexConn.block(true);
}
void LocallabExposure::enableListener()
{
LocallabTool::enableListener();
expMethodConn.block(false);
inversexConn.block(false);
}
void LocallabExposure::read(const rtengine::procparams::ProcParams* pp, const ParamsEdited* pedited)
{
// Disable all listeners
disableListener();
// Update GUI to selected spot value
const int index = pp->locallab.selspot;
if (index < (int)pp->locallab.spots.size()) {
spotName = pp->locallab.spots.at(index).name; // Update spot name according to selected spot
exp->set_visible(pp->locallab.spots.at(index).visiexpose);
exp->setEnabled(pp->locallab.spots.at(index).expexpose);
if (pp->locallab.spots.at(index).expMethod == "std") {
expMethod->set_active(0);
} else if (pp->locallab.spots.at(index).expMethod == "pde") {
expMethod->set_active(1);
}
laplacexp->setValue(pp->locallab.spots.at(index).laplacexp);
linear->setValue(pp->locallab.spots.at(index).linear);
balanexp->setValue(pp->locallab.spots.at(index).balanexp);
expcomp->setValue(pp->locallab.spots.at(index).expcomp);
hlcompr->setValue(pp->locallab.spots.at(index).hlcompr);
hlcomprthresh->setValue(pp->locallab.spots.at(index).hlcomprthresh);
black->setValue(pp->locallab.spots.at(index).black);
shadex->setValue(pp->locallab.spots.at(index).shadex);
shcompr->setValue(pp->locallab.spots.at(index).shcompr);
expchroma->setValue(pp->locallab.spots.at(index).expchroma);
warm->setValue(pp->locallab.spots.at(index).warm);
sensiex->setValue(pp->locallab.spots.at(index).sensiex);
structexp->setValue(pp->locallab.spots.at(index).structexp);
blurexpde->setValue(pp->locallab.spots.at(index).blurexpde);
shapeexpos->setCurve(pp->locallab.spots.at(index).excurve);
softradiusexp->setValue(pp->locallab.spots.at(index).softradiusexp);
inversex->set_active(pp->locallab.spots.at(index).inversex);
enaMask->set_active(pp->locallab.spots.at(index).enaExpMask);
CCMaskShape->setCurve(pp->locallab.spots.at(index).CCmaskexpcurve);
LLMaskShape->setCurve(pp->locallab.spots.at(index).LLmaskexpcurve);
HHMaskShape->setCurve(pp->locallab.spots.at(index).HHmaskexpcurve);
blendMask->setValue(pp->locallab.spots.at(index).blendmaskexp);
radMask->setValue(pp->locallab.spots.at(index).radmaskexp);
chroMask->setValue(pp->locallab.spots.at(index).chromaskexp);
gamMask->setValue(pp->locallab.spots.at(index).gammaskexp);
sloMask->setValue(pp->locallab.spots.at(index).slomaskexp);
}
// Enable all listeners
enableListener();
// Update shcompr sensitivity according to black and shadex value
updateExposureGUI1();
// Update exposure GUI according to expMethod value
updateExposureGUI2();
// Update exposure GUI according to inversex button state
updateExposureGUI3();
// Note: No need to manage pedited as batch mode is deactivated for Locallab
}
void LocallabExposure::write(rtengine::procparams::ProcParams* pp, ParamsEdited* pedited)
{
const int index = pp->locallab.selspot;
if (index < (int)pp->locallab.spots.size()) {
pp->locallab.spots.at(index).expexpose = exp->getEnabled();
pp->locallab.spots.at(index).visiexpose = exp->get_visible();
if (expMethod->get_active_row_number() == 0) {
pp->locallab.spots.at(index).expMethod = "std";
} else if (expMethod->get_active_row_number() == 1) {
pp->locallab.spots.at(index).expMethod = "pde";
}
pp->locallab.spots.at(index).laplacexp = laplacexp->getValue();
pp->locallab.spots.at(index).linear = linear->getValue();
pp->locallab.spots.at(index).balanexp = balanexp->getValue();
pp->locallab.spots.at(index).expcomp = expcomp->getValue();
pp->locallab.spots.at(index).hlcompr = hlcompr->getIntValue();
pp->locallab.spots.at(index).hlcomprthresh = hlcomprthresh->getIntValue();
pp->locallab.spots.at(index).black = black->getIntValue();
pp->locallab.spots.at(index).shadex = shadex->getIntValue();
pp->locallab.spots.at(index).shcompr = shcompr->getIntValue();
pp->locallab.spots.at(index).expchroma = expchroma->getIntValue();
pp->locallab.spots.at(index).warm = warm->getIntValue();
pp->locallab.spots.at(index).sensiex = sensiex->getIntValue();
pp->locallab.spots.at(index).structexp = structexp->getIntValue();
pp->locallab.spots.at(index).blurexpde = blurexpde->getIntValue();
pp->locallab.spots.at(index).softradiusexp = softradiusexp->getValue();
pp->locallab.spots.at(index).excurve = shapeexpos->getCurve();
pp->locallab.spots.at(index).inversex = inversex->get_active();
pp->locallab.spots.at(index).enaExpMask = enaMask->get_active();
pp->locallab.spots.at(index).LLmaskexpcurve = LLMaskShape->getCurve();
pp->locallab.spots.at(index).CCmaskexpcurve = CCMaskShape->getCurve();
pp->locallab.spots.at(index).HHmaskexpcurve = HHMaskShape->getCurve();
pp->locallab.spots.at(index).blendmaskexp = blendMask->getIntValue();
pp->locallab.spots.at(index).radmaskexp = radMask->getValue();
pp->locallab.spots.at(index).chromaskexp = chroMask->getValue();
pp->locallab.spots.at(index).gammaskexp = gamMask->getValue();
pp->locallab.spots.at(index).slomaskexp = sloMask->getValue();
}
// Note: No need to manage pedited as batch mode is deactivated for Locallab
}
void LocallabExposure::setDefaults(const rtengine::procparams::ProcParams* defParams, const ParamsEdited* pedited)
{
const int index = defParams->locallab.selspot;
if (index < (int)defParams->locallab.spots.size()) {
const LocallabParams::LocallabSpot defSpot = defParams->locallab.spots.at(index);
// Set default values for adjuster widgets
laplacexp->setDefault(defSpot.laplacexp);
linear->setDefault(defSpot.linear);
balanexp->setDefault(defSpot.balanexp);
expcomp->setDefault(defSpot.expcomp);
hlcompr->setDefault((double)defSpot.hlcompr);
hlcomprthresh->setDefault((double)defSpot.hlcomprthresh);
black->setDefault((double)defSpot.black);
shadex->setDefault((double)defSpot.shadex);
shcompr->setDefault((double)defSpot.shcompr);
expchroma->setDefault((double)defSpot.expchroma);
warm->setDefault((double)defSpot.warm);
sensiex->setDefault((double)defSpot.sensiex);
structexp->setDefault((double)defSpot.structexp);
blurexpde->setDefault((double)defSpot.blurexpde);
softradiusexp->setDefault(defSpot.softradiusexp);
blendMask->setDefault((double)defSpot.blendmaskexp);
radMask->setDefault(defSpot.radmaskexp);
chroMask->setDefault(defSpot.chromaskexp);
gamMask->setDefault(defSpot.gammaskexp);
sloMask->setDefault(defSpot.slomaskexp);
}
// Note: No need to manage pedited as batch mode is deactivated for Locallab
}
void LocallabExposure::adjusterChanged(Adjuster* a, double newval)
{
// Update shcompr sensitivity according to black and shadex value
if (a == black || a == shadex) {
updateExposureGUI1();
}
if (isLocActivated && exp->getEnabled()) {
if (a == laplacexp) {
if (listener) {
listener->panelChanged(Evlocallablaplacexp,
laplacexp->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == linear) {
if (listener) {
listener->panelChanged(Evlocallablinear,
linear->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == balanexp) {
if (listener) {
listener->panelChanged(Evlocallabbalanexp,
balanexp->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == expcomp) {
if (listener) {
listener->panelChanged(Evlocallabexpcomp,
expcomp->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == hlcompr) {
if (listener) {
listener->panelChanged(Evlocallabhlcompr,
hlcompr->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == hlcomprthresh) {
if (listener) {
listener->panelChanged(Evlocallabhlcomprthresh,
hlcomprthresh->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == black) {
if (listener) {
listener->panelChanged(Evlocallabblack,
black->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == shadex) {
if (listener) {
listener->panelChanged(Evlocallabshadex,
shadex->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == shcompr) {
if (listener) {
listener->panelChanged(Evlocallabshcompr,
shcompr->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == expchroma) {
if (listener) {
listener->panelChanged(Evlocallabexpchroma,
expchroma->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == warm) {
if (listener) {
listener->panelChanged(Evlocallabwarm,
warm->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == sensiex) {
if (listener) {
listener->panelChanged(Evlocallabsensiex,
sensiex->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == structexp) {
if (listener) {
listener->panelChanged(Evlocallabstructexp,
structexp->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == blurexpde) {
if (listener) {
listener->panelChanged(Evlocallabblurexpde,
blurexpde->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == softradiusexp) {
if (listener) {
listener->panelChanged(Evlocallabsoftradiusexp,
softradiusexp->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == blendMask) {
if (listener) {
listener->panelChanged(Evlocallabblendmaskexp,
blendMask->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == radMask) {
if (listener) {
listener->panelChanged(Evlocallabradmaskexp,
radMask->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == chroMask) {
if (listener) {
listener->panelChanged(Evlocallabchromaskexp,
chroMask->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == gamMask) {
if (listener) {
listener->panelChanged(Evlocallabgammaskexp,
gamMask->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == sloMask) {
if (listener) {
listener->panelChanged(Evlocallabslomaskexp,
sloMask->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
}
}
void LocallabExposure::curveChanged(CurveEditor* ce)
{
if (isLocActivated && exp->getEnabled()) {
if (ce == shapeexpos) {
if (listener) {
listener->panelChanged(Evlocallabshapeexpos,
M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (ce == CCMaskShape) {
if (listener) {
listener->panelChanged(EvlocallabCCmaskexpshape,
M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (ce == LLMaskShape) {
if (listener) {
listener->panelChanged(EvlocallabLLmaskexpshape,
M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (ce == HHMaskShape) {
if (listener) {
listener->panelChanged(EvlocallabHHmaskexpshape,
M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
}
}
}
}
void LocallabExposure::enabledChanged()
{
if (isLocActivated) {
if (listener) {
if (exp->getEnabled()) {
listener->panelChanged(EvLocenaexpose,
M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
} else {
listener->panelChanged(EvLocenaexpose,
M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
}
}
}
}
void LocallabExposure::enaMaskChanged()
{
if (isLocActivated && exp->getEnabled()) {
if (listener) {
if (enaMask->get_active()) {
listener->panelChanged(EvLocallabEnaExpMask,
M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
} else {
listener->panelChanged(EvLocallabEnaExpMask,
M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
}
}
}
}
void LocallabExposure::showMaskMethodChanged()
{
// If mask preview is activated, deactivate all other tool mask preview
if (locToolListener) {
locToolListener->resetOtherMaskView(this);
}
if (listener) {
listener->panelChanged(EvlocallabshowmaskMethod, "");
}
}
void LocallabExposure::expMethodChanged()
{
// Update exposure GUI according to expMethod value
updateExposureGUI2();
if (isLocActivated && exp->getEnabled()) {
if (listener) {
listener->panelChanged(EvlocallabexpMethod,
expMethod->get_active_text() + " (" + escapeHtmlChars(spotName) + ")");
}
}
}
void LocallabExposure::inversexChanged()
{
// Update exposure GUI according to inversex button state
updateExposureGUI3();
if (isLocActivated && exp->getEnabled()) {
if (listener) {
if (inversex->get_active()) {
listener->panelChanged(Evlocallabinversex,
M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
} else {
listener->panelChanged(Evlocallabinversex,
M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
}
}
}
}
void LocallabExposure::updateExposureGUI1()
{
// Update shcompr sensitivity according to black and shadex value
if (black->getIntValue() == 0 && shadex->getIntValue() == 0) {
shcompr->set_sensitive(false);
} else {
shcompr->set_sensitive(true);
}
}
void LocallabExposure::updateExposureGUI2()
{
// Update exposure GUI according to expMethod value
if (expMethod->get_active_row_number() == 0) {
pdeFrame->set_sensitive(false);
laplacexp->set_sensitive(false);
balanexp->set_sensitive(false);
linear->set_sensitive(false);
} else if (expMethod->get_active_row_number() == 1) {
pdeFrame->set_sensitive(true);
laplacexp->set_sensitive(true);
balanexp->set_sensitive(true);
linear->set_sensitive(true);
}
}
void LocallabExposure::updateExposureGUI3()
{
// Update exposure GUI according to inversex button state
if (inversex->get_active()) {
maskExp->hide();
structexp->hide();
softradiusexp->hide();
shadex->hide();
expMethod->hide();
pdeFrame->hide();
} else {
maskExp->show();
structexp->show();
softradiusexp->show();
shadex->show();
expMethod->show();
pdeFrame->show();
}
}
/* ==== LocallabShadow ==== */
LocallabShadow::LocallabShadow():
LocallabTool(this, M("TP_LOCALLAB_SH_TOOLNAME"), M("TP_LOCALLAB_SHADHIGH"), false, MaskNormal),
// Shadow highlight specific widgets
highlights(Gtk::manage(new Adjuster(M("TP_SHADOWSHLIGHTS_HIGHLIGHTS"), 0, 100, 1, 0))),
h_tonalwidth(Gtk::manage(new Adjuster(M("TP_SHADOWSHLIGHTS_HLTONALW"), 10, 100, 1, 70))),
shadows(Gtk::manage(new Adjuster(M("TP_SHADOWSHLIGHTS_SHADOWS"), 0, 100, 1, 0))),
s_tonalwidth(Gtk::manage(new Adjuster(M("TP_SHADOWSHLIGHTS_SHTONALW"), 10, 100, 1, 30))),
sh_radius(Gtk::manage(new Adjuster(M("TP_SHADOWSHLIGHTS_RADIUS"), 0, 100, 1, 40))),
sensihs(Gtk::manage(new Adjuster(M("TP_LOCALLAB_SENSI"), 0, 100, 1, 15))),
blurSHde(Gtk::manage(new Adjuster(M("TP_LOCALLAB_BLURDE"), 2, 100, 1, 5))),
inverssh(Gtk::manage(new Gtk::CheckButton(M("TP_LOCALLAB_INVERS"))))
{
const bool showtooltip = options.showtooltip;
if (showtooltip) {
exp->set_tooltip_text(M("TP_LOCALLAB_SHADOWHIGHLIGHT_TOOLTIP"));
}
highlights->setAdjusterListener(this);
h_tonalwidth->setAdjusterListener(this);
shadows->setAdjusterListener(this);
s_tonalwidth->setAdjusterListener(this);
sh_radius->setAdjusterListener(this);
sensihs->setAdjusterListener(this);
blurSHde->setAdjusterListener(this);
inversshConn = inverssh->signal_toggled().connect(sigc::mem_fun(*this, &LocallabShadow::inversshChanged));
pack_start(*highlights);
pack_start(*h_tonalwidth);
pack_start(*shadows);
pack_start(*s_tonalwidth);
pack_start(*sh_radius);
pack_start(*sensihs);
pack_start(*blurSHde);
pack_start(*inverssh);
}
void LocallabShadow::getMaskView(int &colorMask, int &expMask, int &shMask, int &softMask, int &tmMask, int &retiMask, int &cbMask)
{
shMask = showMaskMethod->get_active_row_number();
}
void LocallabShadow::disableListener()
{
LocallabTool::disableListener();
inversshConn.block(true);
}
void LocallabShadow::enableListener()
{
LocallabTool::enableListener();
inversshConn.block(true);
}
void LocallabShadow::read(const rtengine::procparams::ProcParams* pp, const ParamsEdited* pedited)
{
// Disable all listeners
disableListener();
// Update GUI to selected spot value
const int index = pp->locallab.selspot;
if (index < (int)pp->locallab.spots.size()) {
spotName = pp->locallab.spots.at(index).name; // Update spot name according to selected spot
exp->set_visible(pp->locallab.spots.at(index).visishadhigh);
exp->setEnabled(pp->locallab.spots.at(index).expshadhigh);
highlights->setValue(pp->locallab.spots.at(index).highlights);
h_tonalwidth->setValue(pp->locallab.spots.at(index).h_tonalwidth);
shadows->setValue(pp->locallab.spots.at(index).shadows);
s_tonalwidth->setValue(pp->locallab.spots.at(index).s_tonalwidth);
sh_radius->setValue(pp->locallab.spots.at(index).sh_radius);
sensihs->setValue(pp->locallab.spots.at(index).sensihs);
blurSHde->setValue(pp->locallab.spots.at(index).blurSHde);
inverssh->set_active(pp->locallab.spots.at(index).inverssh);
enaMask->set_active(pp->locallab.spots.at(index).enaSHMask);
CCMaskShape->setCurve(pp->locallab.spots.at(index).CCmaskSHcurve);
LLMaskShape->setCurve(pp->locallab.spots.at(index).LLmaskSHcurve);
HHMaskShape->setCurve(pp->locallab.spots.at(index).HHmaskSHcurve);
blendMask->setValue(pp->locallab.spots.at(index).blendmaskSH);
radMask->setValue(pp->locallab.spots.at(index).radmaskSH);
chroMask->setValue(pp->locallab.spots.at(index).chromaskSH);
gamMask->setValue(pp->locallab.spots.at(index).gammaskSH);
sloMask->setValue(pp->locallab.spots.at(index).slomaskSH);
}
// Enable all listeners
enableListener();
// Update shadow highlight GUI according to inverssh button state
updateShadowGUI();
// Note: No need to manage pedited as batch mode is deactivated for Locallab
}
void LocallabShadow::write(rtengine::procparams::ProcParams* pp, ParamsEdited* pedited)
{
const int index = pp->locallab.selspot;
if (index < (int)pp->locallab.spots.size()) {
pp->locallab.spots.at(index).expshadhigh = exp->getEnabled();
pp->locallab.spots.at(index).visishadhigh = exp->get_visible();
pp->locallab.spots.at(index).highlights = highlights->getIntValue();
pp->locallab.spots.at(index).h_tonalwidth = h_tonalwidth->getIntValue();
pp->locallab.spots.at(index).shadows = shadows->getIntValue();
pp->locallab.spots.at(index).s_tonalwidth = s_tonalwidth->getIntValue();
pp->locallab.spots.at(index).sh_radius = sh_radius->getIntValue();
pp->locallab.spots.at(index).sensihs = sensihs->getIntValue();
pp->locallab.spots.at(index).blurSHde = blurSHde->getIntValue();
pp->locallab.spots.at(index).inverssh = inverssh->get_active();
pp->locallab.spots.at(index).enaSHMask = enaMask->get_active();
pp->locallab.spots.at(index).LLmaskSHcurve = LLMaskShape->getCurve();
pp->locallab.spots.at(index).CCmaskSHcurve = CCMaskShape->getCurve();
pp->locallab.spots.at(index).HHmaskSHcurve = HHMaskShape->getCurve();
pp->locallab.spots.at(index).blendmaskSH = blendMask->getIntValue();
pp->locallab.spots.at(index).radmaskSH = radMask->getValue();
pp->locallab.spots.at(index).chromaskSH = chroMask->getValue();
pp->locallab.spots.at(index).gammaskSH = gamMask->getValue();
pp->locallab.spots.at(index).slomaskSH = sloMask->getValue();
}
// Note: No need to manage pedited as batch mode is deactivated for Locallab
}
void LocallabShadow::setDefaults(const rtengine::procparams::ProcParams* defParams, const ParamsEdited* pedited)
{
const int index = defParams->locallab.selspot;
if (index < (int)defParams->locallab.spots.size()) {
const LocallabParams::LocallabSpot defSpot = defParams->locallab.spots.at(index);
// Set default values for adjuster widgets
highlights->setDefault((double)defSpot.highlights);
h_tonalwidth->setDefault((double)defSpot.h_tonalwidth);
shadows->setDefault((double)defSpot.shadows);
s_tonalwidth->setDefault((double)defSpot.s_tonalwidth);
sh_radius->setDefault((double)defSpot.sh_radius);
sensihs->setDefault((double)defSpot.sensihs);
blurSHde->setDefault((double)defSpot.blurSHde);
blendMask->setDefault((double)defSpot.blendmaskSH);
radMask->setDefault(defSpot.radmaskSH);
chroMask->setDefault(defSpot.chromaskSH);
gamMask->setDefault(defSpot.gammaskSH);
sloMask->setDefault(defSpot.slomaskSH);
}
// Note: No need to manage pedited as batch mode is deactivated for Locallab
}
void LocallabShadow::adjusterChanged(Adjuster* a, double newval)
{
if (isLocActivated && exp->getEnabled()) {
if (a == highlights) {
if (listener) {
listener->panelChanged(Evlocallabhighlights,
highlights->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == h_tonalwidth) {
if (listener) {
listener->panelChanged(Evlocallabh_tonalwidth,
h_tonalwidth->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == shadows) {
if (listener) {
listener->panelChanged(Evlocallabshadows,
shadows->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == s_tonalwidth) {
if (listener) {
listener->panelChanged(Evlocallabs_tonalwidth,
s_tonalwidth->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == sh_radius) {
if (listener) {
listener->panelChanged(Evlocallabsh_radius,
sh_radius->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == sensihs) {
if (listener) {
listener->panelChanged(Evlocallabsensihs,
sensihs->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == blurSHde) {
if (listener) {
listener->panelChanged(EvlocallabblurSHde,
blurSHde->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == blendMask) {
if (listener) {
listener->panelChanged(EvlocallabblendmaskSH,
blendMask->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == radMask) {
if (listener) {
listener->panelChanged(EvlocallabradmaskSH,
radMask->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == chroMask) {
if (listener) {
listener->panelChanged(EvlocallabchromaskSH,
chroMask->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == gamMask) {
if (listener) {
listener->panelChanged(EvlocallabgammaskSH,
gamMask->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == sloMask) {
if (listener) {
listener->panelChanged(EvlocallabslomaskSH,
sloMask->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
}
}
void LocallabShadow::curveChanged(CurveEditor* ce)
{
if (isLocActivated && exp->getEnabled()) {
if (ce == CCMaskShape) {
if (listener) {
listener->panelChanged(EvlocallabCCmaskSHshape,
M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (ce == LLMaskShape) {
if (listener) {
listener->panelChanged(EvlocallabLLmaskSHshape,
M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (ce == HHMaskShape) {
if (listener) {
listener->panelChanged(EvlocallabHHmaskSHshape,
M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
}
}
}
}
void LocallabShadow::enabledChanged()
{
if (isLocActivated) {
if (listener) {
if (exp->getEnabled()) {
listener->panelChanged(EvLocenashadhigh,
M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
} else {
listener->panelChanged(EvLocenashadhigh,
M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
}
}
}
}
void LocallabShadow::enaMaskChanged()
{
if (isLocActivated && exp->getEnabled()) {
if (listener) {
if (enaMask->get_active()) {
listener->panelChanged(EvLocallabEnaSHMask,
M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
} else {
listener->panelChanged(EvLocallabEnaSHMask,
M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
}
}
}
}
void LocallabShadow::showMaskMethodChanged()
{
// If mask preview is activated, deactivate all other tool mask preview
if (locToolListener) {
locToolListener->resetOtherMaskView(this);
}
if (listener) {
listener->panelChanged(EvlocallabshowmaskMethod, "");
}
}
void LocallabShadow::inversshChanged()
{
// Update shadow highlight GUI according to inverssh button state
updateShadowGUI();
if (isLocActivated && exp->getEnabled()) {
if (listener) {
if (inverssh->get_active()) {
listener->panelChanged(Evlocallabinverssh,
M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
} else {
listener->panelChanged(Evlocallabinverssh,
M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
}
}
}
}
void LocallabShadow::updateShadowGUI()
{
// Update shadow highlight GUI according to inverssh button state
if (inverssh->get_active()) {
maskExp->hide();
} else {
maskExp->show();
}
}
/* ==== LocallabVibrance ==== */
LocallabVibrance::LocallabVibrance():
LocallabTool(this, M("TP_LOCALLAB_VIB_TOOLNAME"), M("TP_LOCALLAB_VIBRANCE"), false, MaskNone),
// Vibrance specific widgets
saturated(Gtk::manage(new Adjuster(M("TP_VIBRANCE_SATURATED"), -100., 100., 1., 0.))),
pastels(Gtk::manage(new Adjuster(M("TP_VIBRANCE_PASTELS"), -100., 100., 1., 0.))),
psThreshold(Gtk::manage(new ThresholdAdjuster(M("TP_VIBRANCE_PSTHRESHOLD"), -100., 100., 0., M("TP_VIBRANCE_PSTHRESHOLD_WEIGTHING"), 0, 0., 100., 75., M("TP_VIBRANCE_PSTHRESHOLD_SATTHRESH"), 0, this, false))),
protectSkins(Gtk::manage(new Gtk::CheckButton(M("TP_VIBRANCE_PROTECTSKINS")))),
avoidColorShift(Gtk::manage(new Gtk::CheckButton(M("TP_VIBRANCE_AVOIDCOLORSHIFT")))),
pastSatTog(Gtk::manage(new Gtk::CheckButton(M("TP_VIBRANCE_PASTSATTOG")))),
sensiv(Gtk::manage(new Adjuster(M("TP_LOCALLAB_SENSI"), 0, 100, 1, 15))),
curveEditorGG(new CurveEditorGroup(options.lastlocalCurvesDir, M("TP_VIBRANCE_CURVEEDITOR_SKINTONES_LABEL")))
{
float R, G, B;
const bool showtooltip = options.showtooltip;
saturated->setAdjusterListener(this);
pastels->setAdjusterListener(this);
if (showtooltip) {
psThreshold->set_tooltip_markup(M("TP_VIBRANCE_PSTHRESHOLD_TOOLTIP"));
}
psThreshold->setAdjusterListener(this);
pskinsConn = protectSkins->signal_toggled().connect(sigc::mem_fun(*this, &LocallabVibrance::protectskins_toggled));
ashiftConn = avoidColorShift->signal_toggled().connect(sigc::mem_fun(*this, &LocallabVibrance::avoidcolorshift_toggled));
pastsattogConn = pastSatTog->signal_toggled().connect(sigc::mem_fun(*this, &LocallabVibrance::pastsattog_toggled));
sensiv->setAdjusterListener(this);
curveEditorGG->setCurveListener(this);
skinTonesCurve = static_cast<DiagonalCurveEditor*>(curveEditorGG->addCurve(CT_Diagonal, M("TP_VIBRANCE_CURVEEDITOR_SKINTONES")));
if (showtooltip) {
skinTonesCurve->setTooltip(M("TP_VIBRANCE_CURVEEDITOR_SKINTONES_TOOLTIP"));
}
std::vector<GradientMilestone> mskinTonesCurve;
// -0.1 rad < Hue < 1.6 rad
Color::hsv2rgb01(0.92f, 0.45f, 0.6f, R, G, B);
mskinTonesCurve.push_back(GradientMilestone(0.0, double (R), double (G), double (B)));
Color::hsv2rgb01(0.14056f, 0.45f, 0.6f, R, G, B);
mskinTonesCurve.push_back(GradientMilestone(1.0, double (R), double (G), double (B)));
skinTonesCurve->setBottomBarBgGradient(mskinTonesCurve);
skinTonesCurve->setLeftBarBgGradient(mskinTonesCurve);
skinTonesCurve->setRangeLabels(
M("TP_VIBRANCE_CURVEEDITOR_SKINTONES_RANGE1"), M("TP_VIBRANCE_CURVEEDITOR_SKINTONES_RANGE2"),
M("TP_VIBRANCE_CURVEEDITOR_SKINTONES_RANGE3"), M("TP_VIBRANCE_CURVEEDITOR_SKINTONES_RANGE4")
);
skinTonesCurve->setRangeDefaultMilestones(0.1, 0.4, 0.85);
curveEditorGG->curveListComplete();
pack_start(*saturated, Gtk::PACK_SHRINK, 0);
pack_start(*pastels, Gtk::PACK_SHRINK, 0);
pack_start(*psThreshold, Gtk::PACK_SHRINK, 0);
pack_start(*protectSkins, Gtk::PACK_SHRINK, 0);
pack_start(*avoidColorShift, Gtk::PACK_SHRINK, 0);
pack_start(*pastSatTog, Gtk::PACK_SHRINK, 0);
pack_start(*sensiv, Gtk::PACK_SHRINK, 0);
pack_start(*curveEditorGG, Gtk::PACK_SHRINK, 4); // Padding is mandatory to correct behavior of curve editor
}
LocallabVibrance::~LocallabVibrance()
{
delete curveEditorGG;
}
void LocallabVibrance::disableListener()
{
LocallabTool::disableListener();
pskinsConn.block(true);
ashiftConn.block(true);
pastsattogConn.block(true);
}
void LocallabVibrance::enableListener()
{
LocallabTool::enableListener();
pskinsConn.block(false);
ashiftConn.block(false);
pastsattogConn.block(false);
}
void LocallabVibrance::read(const rtengine::procparams::ProcParams* pp, const ParamsEdited* pedited)
{
// Disable all listeners
disableListener();
// Update GUI to selected spot value
const int index = pp->locallab.selspot;
if (index < (int)pp->locallab.spots.size()) {
spotName = pp->locallab.spots.at(index).name; // Update spot name according to selected spot
exp->set_visible(pp->locallab.spots.at(index).visivibrance);
exp->setEnabled(pp->locallab.spots.at(index).expvibrance);
saturated->setValue(pp->locallab.spots.at(index).saturated);
pastels->setValue(pp->locallab.spots.at(index).pastels);
psThreshold->setValue<int>(pp->locallab.spots.at(index).psthreshold);
protectSkins->set_active(pp->locallab.spots.at(index).protectskins);
avoidColorShift->set_active(pp->locallab.spots.at(index).avoidcolorshift);
pastSatTog->set_active(pp->locallab.spots.at(index).pastsattog);
sensiv->setValue(pp->locallab.spots.at(index).sensiv);
skinTonesCurve->setCurve(pp->locallab.spots.at(index).skintonescurve);
}
// Enable all listeners
enableListener();
// Update vibrance GUI according to pastsattog button state
updateVibranceGUI();
// Note: No need to manage pedited as batch mode is deactivated for Locallab
}
void LocallabVibrance::write(rtengine::procparams::ProcParams* pp, ParamsEdited* pedited)
{
const int index = pp->locallab.selspot;
if (index < (int)pp->locallab.spots.size()) {
pp->locallab.spots.at(index).expvibrance = exp->getEnabled();
pp->locallab.spots.at(index).visivibrance = exp->get_visible();
pp->locallab.spots.at(index).saturated = saturated->getIntValue();
pp->locallab.spots.at(index).pastels = pastels->getIntValue();
pp->locallab.spots.at(index).psthreshold = psThreshold->getValue<int>();
pp->locallab.spots.at(index).protectskins = protectSkins->get_active();
pp->locallab.spots.at(index).avoidcolorshift = avoidColorShift->get_active();
pp->locallab.spots.at(index).pastsattog = pastSatTog->get_active();
pp->locallab.spots.at(index).sensiv = sensiv->getIntValue();
pp->locallab.spots.at(index).skintonescurve = skinTonesCurve->getCurve();
}
// Note: No need to manage pedited as batch mode is deactivated for Locallab
}
void LocallabVibrance::setDefaults(const rtengine::procparams::ProcParams* defParams, const ParamsEdited* pedited)
{
const int index = defParams->locallab.selspot;
if (index < (int)defParams->locallab.spots.size()) {
const LocallabParams::LocallabSpot defSpot = defParams->locallab.spots.at(index);
// Set default values for adjuster and threshold adjuster widgets
saturated->setDefault((double)defSpot.saturated);
pastels->setDefault((double)defSpot.pastels);
psThreshold->setDefault<int>(defSpot.psthreshold);
sensiv->setDefault((double)defSpot.sensiv);
}
// Note: No need to manage pedited as batch mode is deactivated for Locallab
}
void LocallabVibrance::adjusterChanged(Adjuster* a, double newval)
{
// Copy pastels adjuster value to saturated one according to pastSatTog button state
if (a == pastels && pastSatTog->get_active()) {
saturated->setValue(newval);
}
if (isLocActivated && exp->getEnabled()) {
if (a == saturated && !pastSatTog->get_active()) {
if (listener) {
listener->panelChanged(EvlocallabSaturated,
saturated->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == pastels) {
if (listener) {
listener->panelChanged(EvlocallabPastels,
pastels->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == sensiv) {
if (listener) {
listener->panelChanged(Evlocallabsensiv,
sensiv->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
}
}
void LocallabVibrance::adjusterChanged(ThresholdAdjuster* a, int newBottom, int newTop)
{
if (isLocActivated && exp->getEnabled()) {
if (listener) {
listener->panelChanged(EvlocallabPastSatThreshold,
psThreshold->getHistoryString() + " (" + escapeHtmlChars(spotName) + ")");
}
}
}
std::vector<double> LocallabVibrance::getCurvePoints(ThresholdSelector* tAdjuster) const
{
std::vector<double> points;
double threshold, transitionWeighting;
tAdjuster->getPositions<double>(transitionWeighting, threshold); // ( range -100;+100, range 0;+100 )
transitionWeighting /= 100.; // range -1., +1.
threshold /= 100.; // range 0., +1.
// Initial point
points.push_back(0.);
points.push_back(0.);
double p2 = 3.0 * threshold / 4.0; // same one than in ipvibrance.cc
double s0 = threshold + (1.0 - threshold) / 4.0; // same one than in ipvibrance.cc
// point at the beginning of the first linear transition
points.push_back(p2);
points.push_back(0.);
// Y value of the chroma mean point, calculated to get a straight line between p2 and s0
double chromaMean = (threshold / 4.0) / (s0 - p2);
// move chromaMean up or down depending on transitionWeighting
if (transitionWeighting > 0.0) {
// positive values -> give more weight to Saturated
chromaMean = (1.0 - chromaMean) * transitionWeighting + chromaMean;
} else if (transitionWeighting < 0.0) {
// negative values -> give more weight to Pastels
chromaMean = chromaMean * transitionWeighting + chromaMean;
}
// point at the location of the Top cursor, at the end of the first linear transition and the beginning of the second one
points.push_back(threshold);
points.push_back(chromaMean);
if (threshold < 1.0) {
// point at the end of the second linear transition
points.push_back(s0);
points.push_back(1.0);
// end point
points.push_back(1.0);
points.push_back(1.0);
}
return points;
}
void LocallabVibrance::curveChanged(CurveEditor* ce)
{
if (isLocActivated && exp->getEnabled()) {
if (ce == skinTonesCurve) {
if (listener) {
listener->panelChanged(EvlocallabSkinTonesCurve,
M("HISTORY_CUSTOMCURVE") + " (" + escapeHtmlChars(spotName) + ")");
}
}
}
}
void LocallabVibrance::enabledChanged()
{
if (isLocActivated) {
if (listener) {
if (exp->getEnabled()) {
listener->panelChanged(EvLocenavibrance,
M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
} else {
listener->panelChanged(EvLocenashadhigh,
M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
}
}
}
}
void LocallabVibrance::protectskins_toggled()
{
if (isLocActivated && exp->getEnabled()) {
if (listener) {
if (protectSkins->get_active()) {
listener->panelChanged(EvlocallabProtectSkins,
M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
} else {
listener->panelChanged(EvlocallabProtectSkins,
M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
}
}
}
}
void LocallabVibrance::avoidcolorshift_toggled()
{
if (isLocActivated && exp->getEnabled()) {
if (listener) {
if (avoidColorShift->get_active()) {
listener->panelChanged(EvlocallabAvoidColorShift,
M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
} else {
listener->panelChanged(EvlocallabAvoidColorShift,
M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
}
}
}
}
void LocallabVibrance::pastsattog_toggled()
{
// Update vibrance GUI according to pastsattog button state
updateVibranceGUI();
if (isLocActivated && exp->getEnabled()) {
if (listener) {
if (pastSatTog->get_active()) {
listener->panelChanged(EvlocallabPastSatTog,
M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
} else {
listener->panelChanged(EvlocallabPastSatTog,
M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
}
}
}
}
void LocallabVibrance::updateVibranceGUI()
{
// Update vibrance GUI according to pastsattog button state
if (pastSatTog->get_active()) {
// Link both slider, so we set saturated and psThresholds unsensitive
psThreshold->set_sensitive(false);
saturated->set_sensitive(false);
saturated->setValue(pastels->getValue()); // Pastels and Saturated are linked
} else {
// Separate sliders, so we set saturated and psThresholds sensitive again
psThreshold->set_sensitive(true);
saturated->set_sensitive(true);
}
}
/* ==== LocallabSoft ==== */
LocallabSoft::LocallabSoft():
LocallabTool(this, M("TP_LOCALLAB_SOFT_TOOLNAME"), M("TP_LOCALLAB_SOFT"), false, MaskNone),
// Soft light specific widgets
softMethod(Gtk::manage(new MyComboBoxText())),
ctboxsoftmethod(Gtk::manage(new Gtk::HBox())),
showmasksoftMethod(Gtk::manage(new MyComboBoxText())),
streng(Gtk::manage(new Adjuster(M("TP_LOCALLAB_STRENG"), 1, 100, 1, 1))),
laplace(Gtk::manage(new Adjuster(M("TP_LOCALLAB_LAPLACE"), 0., 100., 0.5, 25.))),
sensisf(Gtk::manage(new Adjuster(M("TP_LOCALLAB_SENSI"), 1, 100, 1, 15)))
{
const bool showtooltip = options.showtooltip;
softMethod->append(M("TP_LOCALLAB_SOFTM"));
softMethod->append(M("TP_LOCALLAB_RETIM"));
softMethod->set_active(0);
if (showtooltip) {
softMethod->set_tooltip_markup(M("TP_LOCALLAB_SOFTMETHOD_TOOLTIP"));
}
softMethodConn = softMethod->signal_changed().connect(sigc::mem_fun(*this, &LocallabSoft::softMethodChanged));
showmasksoftMethod->append(M("TP_LOCALLAB_SHOWMNONE"));
showmasksoftMethod->append(M("TP_LOCALLAB_SHOWLAPLACE"));
showmasksoftMethod->append(M("TP_LOCALLAB_SHOWFOURIER"));
showmasksoftMethod->append(M("TP_LOCALLAB_SHOWPOISSON"));
showmasksoftMethod->append(M("TP_LOCALLAB_SHOWNORMAL"));
showmasksoftMethod->set_active(0);
if (showtooltip) {
showmasksoftMethod->set_tooltip_markup(M("TP_LOCALLAB_SHOWMASKSOFT_TOOLTIP"));
}
showmasksoftMethodConn = showmasksoftMethod->signal_changed().connect(sigc::mem_fun(*this, &LocallabSoft::showmasksoftMethodChanged));
streng->setAdjusterListener(this);
laplace->setAdjusterListener(this);
sensisf->setAdjusterListener(this);
pack_start(*softMethod);
Gtk::Label* const labelsoftmethod = Gtk::manage(new Gtk::Label(M("TP_LOCALLAB_SHOWDCT") + ":"));
ctboxsoftmethod->pack_start(*labelsoftmethod, Gtk::PACK_SHRINK, 4);
ctboxsoftmethod->pack_start(*showmasksoftMethod);
pack_start(*ctboxsoftmethod);
pack_start(*streng);
pack_start(*laplace);
pack_start(*sensisf);
}
void LocallabSoft::getMaskView(int &colorMask, int &expMask, int &shMask, int &softMask, int &tmMask, int &retiMask, int &cbMask)
{
softMask = showmasksoftMethod->get_active_row_number();
}
void LocallabSoft::disableListener()
{
LocallabTool::disableListener();
softMethodConn.block(true);
showmasksoftMethodConn.block(true);
}
void LocallabSoft::enableListener()
{
LocallabTool::enableListener();
softMethodConn.block(false);
showmasksoftMethodConn.block(false);
}
void LocallabSoft::read(const rtengine::procparams::ProcParams* pp, const ParamsEdited* pedited)
{
// Disable all listeners
disableListener();
// Update GUI to selected spot value
const int index = pp->locallab.selspot;
if (index < (int)pp->locallab.spots.size()) {
spotName = pp->locallab.spots.at(index).name; // Update spot name according to selected spot
exp->set_visible(pp->locallab.spots.at(index).visisoft);
exp->setEnabled(pp->locallab.spots.at(index).expsoft);
if (pp->locallab.spots.at(index).softMethod == "soft") {
softMethod->set_active(0);
} else if (pp->locallab.spots.at(index).softMethod == "reti") {
softMethod->set_active(1);
}
streng->setValue(pp->locallab.spots.at(index).streng);
sensisf->setValue(pp->locallab.spots.at(index).sensisf);
laplace->setValue(pp->locallab.spots.at(index).laplace);
}
// Enable all listeners
enableListener();
// Update soft light GUI according to softMethod combobox
updateSoftGUI();
// Note: No need to manage pedited as batch mode is deactivated for Locallab
}
void LocallabSoft::write(rtengine::procparams::ProcParams* pp, ParamsEdited* pedited)
{
const int index = pp->locallab.selspot;
if (index < (int)pp->locallab.spots.size()) {
pp->locallab.spots.at(index).expsoft = exp->getEnabled();
pp->locallab.spots.at(index).visisoft = exp->get_visible();
if (softMethod->get_active_row_number() == 0) {
pp->locallab.spots.at(index).softMethod = "soft";
} else if (softMethod->get_active_row_number() == 1) {
pp->locallab.spots.at(index).softMethod = "reti";
}
pp->locallab.spots.at(index).streng = streng->getIntValue();
pp->locallab.spots.at(index).sensisf = sensisf->getIntValue();
pp->locallab.spots.at(index).laplace = laplace->getValue();
}
// Note: No need to manage pedited as batch mode is deactivated for Locallab
}
void LocallabSoft::setDefaults(const rtengine::procparams::ProcParams* defParams, const ParamsEdited* pedited)
{
const int index = defParams->locallab.selspot;
if (index < (int)defParams->locallab.spots.size()) {
const LocallabParams::LocallabSpot defSpot = defParams->locallab.spots.at(index);
// Set default value for adjuster widgets
streng->setDefault((double)defSpot.streng);
laplace->setDefault(defSpot.laplace);
sensisf->setDefault((double)defSpot.sensisf);
}
// Note: No need to manage pedited as batch mode is deactivated for Locallab
}
void LocallabSoft::adjusterChanged(Adjuster* a, double newval)
{
if (isLocActivated && exp->getEnabled()) {
if (a == streng) {
if (listener) {
listener->panelChanged(Evlocallabstreng,
streng->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == sensisf) {
if (listener) {
listener->panelChanged(Evlocallabsensisf,
sensisf->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == laplace) {
if (listener) {
listener->panelChanged(Evlocallablaplace,
laplace->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
}
}
void LocallabSoft::resetMaskView()
{
showmasksoftMethodConn.block(true);
showmasksoftMethod->set_active(0);
showmasksoftMethodConn.block(false);
}
void LocallabSoft::enabledChanged()
{
if (isLocActivated) {
if (listener) {
if (exp->getEnabled()) {
listener->panelChanged(EvLocenasoft,
M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
} else {
listener->panelChanged(EvLocenasoft,
M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
}
}
}
}
void LocallabSoft::softMethodChanged()
{
// Update soft light GUI according to softMethod combobox
updateSoftGUI();
if (isLocActivated && exp->getEnabled()) {
if (listener) {
listener->panelChanged(EvlocallabsoftMethod,
softMethod->get_active_text() + " (" + escapeHtmlChars(spotName) + ")");
}
}
}
void LocallabSoft::showmasksoftMethodChanged()
{
// If mask preview is activated, deactivate all other tool mask preview
if (locToolListener) {
locToolListener->resetOtherMaskView(this);
}
if (listener) {
listener->panelChanged(EvlocallabshowmaskMethod, "");
}
}
void LocallabSoft::updateSoftGUI()
{
// Update soft light GUI according to softMethod combobox
if (softMethod->get_active_row_number() == 0) {
laplace->hide();
ctboxsoftmethod->hide();
} else {
laplace->show();
ctboxsoftmethod->show();
}
}
/* ==== LocallabBlur ==== */
LocallabBlur::LocallabBlur():
LocallabTool(this, M("TP_LOCALLAB_BLUR_TOOLNAME"), M("TP_LOCALLAB_BLUFR"), false, MaskNone),
// Blur & Noise specific widgets
radius(Gtk::manage(new Adjuster(M("TP_LOCALLAB_RADIUS"), 1.0, 100.0, 0.1, 1.0))),
strength(Gtk::manage(new Adjuster(M("TP_LOCALLAB_STRENGTH"), 0, 100, 1, 0))),
sensibn(Gtk::manage(new Adjuster(M("TP_LOCALLAB_SENSIBN"), 0, 100, 1, 40))),
blurMethod(Gtk::manage(new MyComboBoxText())),
activlum(Gtk::manage(new Gtk::CheckButton(M("TP_LOCALLAB_ACTIV"))))
{
const bool showtooltip = options.showtooltip;
radius->setAdjusterListener(this);
strength->setAdjusterListener(this);
if (showtooltip) {
sensibn->set_tooltip_text(M("TP_LOCALLAB_SENSIH_TOOLTIP"));
}
sensibn->setAdjusterListener(this);
blurMethod->append(M("TP_LOCALLAB_BLNORM"));
blurMethod->append(M("TP_LOCALLAB_BLINV"));
blurMethod->set_active(0);
if (showtooltip) {
blurMethod->set_tooltip_markup(M("TP_LOCALLAB_BLMETHOD_TOOLTIP"));
}
blurMethodConn = blurMethod->signal_changed().connect(sigc::mem_fun(*this, &LocallabBlur::blurMethodChanged));
activlumConn = activlum->signal_toggled().connect(sigc::mem_fun(*this, &LocallabBlur::activlumChanged));
pack_start(*radius);
pack_start(*strength);
pack_start(*sensibn);
pack_start(*blurMethod);
pack_start(*activlum);
}
void LocallabBlur::disableListener()
{
LocallabTool::disableListener();
blurMethodConn.block(true);
activlumConn.block(true);
}
void LocallabBlur::enableListener()
{
LocallabTool::enableListener();
blurMethodConn.block(false);
activlumConn.block(false);
}
void LocallabBlur::read(const rtengine::procparams::ProcParams* pp, const ParamsEdited* pedited)
{
// Disable all listeners
disableListener();
// Update GUI to selected spot value
const int index = pp->locallab.selspot;
if (index < (int)pp->locallab.spots.size()) {
spotName = pp->locallab.spots.at(index).name; // Update spot name according to selected spot
exp->set_visible(pp->locallab.spots.at(index).visiblur);
exp->setEnabled(pp->locallab.spots.at(index).expblur);
radius->setValue(pp->locallab.spots.at(index).radius);
strength->setValue(pp->locallab.spots.at(index).strength);
sensibn->setValue(pp->locallab.spots.at(index).sensibn);
if (pp->locallab.spots.at(index).blurMethod == "norm") {
blurMethod->set_active(0);
} else if (pp->locallab.spots.at(index).blurMethod == "inv") {
blurMethod->set_active(1);
}
activlum->set_active(pp->locallab.spots.at(index).activlum);
}
// Enable all listeners
enableListener();
// Note: No need to manage pedited as batch mode is deactivated for Locallab
}
void LocallabBlur::write(rtengine::procparams::ProcParams* pp, ParamsEdited* pedited)
{
const int index = pp->locallab.selspot;
if (index < (int)pp->locallab.spots.size()) {
pp->locallab.spots.at(index).expsoft = exp->getEnabled();
pp->locallab.spots.at(index).visisoft = exp->get_visible();
pp->locallab.spots.at(index).expblur = exp->getEnabled();
pp->locallab.spots.at(index).radius = radius->getValue();
pp->locallab.spots.at(index).strength = strength->getIntValue();
pp->locallab.spots.at(index).sensibn = sensibn->getIntValue();
if (blurMethod->get_active_row_number() == 0) {
pp->locallab.spots.at(index).blurMethod = "norm";
} else if (blurMethod->get_active_row_number() == 1) {
pp->locallab.spots.at(index).blurMethod = "inv";
}
pp->locallab.spots.at(index).activlum = activlum->get_active();
}
// Note: No need to manage pedited as batch mode is deactivated for Locallab
}
void LocallabBlur::setDefaults(const rtengine::procparams::ProcParams* defParams, const ParamsEdited* pedited)
{
const int index = defParams->locallab.selspot;
if (index < (int)defParams->locallab.spots.size()) {
const LocallabParams::LocallabSpot defSpot = defParams->locallab.spots.at(index);
// Set default value for adjuster widgets
radius->setDefault(defSpot.radius);
strength->setDefault((double)defSpot.strength);
sensibn->setDefault((double)defSpot.sensibn);
}
// Note: No need to manage pedited as batch mode is deactivated for Locallab
}
void LocallabBlur::adjusterChanged(Adjuster* a, double newval)
{
if (isLocActivated && exp->getEnabled()) {
if (a == radius) {
if (listener) {
listener->panelChanged(Evlocallabradius,
radius->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == strength) {
if (listener) {
listener->panelChanged(Evlocallabstrength,
strength->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
if (a == sensibn) {
if (listener) {
listener->panelChanged(Evlocallabsensibn,
sensibn->getTextValue() + " (" + escapeHtmlChars(spotName) + ")");
}
}
}
}
void LocallabBlur::enabledChanged()
{
if (isLocActivated) {
if (listener) {
if (exp->getEnabled()) {
listener->panelChanged(EvLocenablur,
M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
} else {
listener->panelChanged(EvLocenablur,
M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
}
}
}
}
void LocallabBlur::blurMethodChanged()
{
if (isLocActivated && exp->getEnabled()) {
if (listener) {
listener->panelChanged(EvlocallabblurMethod,
blurMethod->get_active_text() + " (" + escapeHtmlChars(spotName) + ")");
}
}
}
void LocallabBlur::activlumChanged()
{
if (isLocActivated && exp->getEnabled()) {
if (listener) {
if (activlum->get_active()) {
listener->panelChanged(Evlocallabactivlum,
M("GENERAL_ENABLED") + " (" + escapeHtmlChars(spotName) + ")");
} else {
listener->panelChanged(Evlocallabactivlum,
M("GENERAL_DISABLED") + " (" + escapeHtmlChars(spotName) + ")");
}
}
}
}
Reference in New Issue View Git Blame Copy Permalink