liz/rawTherapee
liz/rawTherapee
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
rawTherapee/rtgui/whitebalance.cc
Desmis 30cf3f721f
UV photos - Wish from LarsHP Increased green (tint) value from 10 to 100 (#7043) 
* Change limits green to 40 instead of 10

* Publish uvgreen in pre-dev appimage.yml windows.yml

* Change range setLogScale

* Revert change to observer 2 - format

* Set maxgreen 60

* Set maxgreen 100 and minequal 0.5 maxequal 1.8

* Set maxgreen 1000 minequal 0.4 maxequal 2.5

* Set maxgreen 100 minequal 0.5 maxequal 2
2024-04-20 17:11:31 +02:00

1272 lines
47 KiB
C++
Raw Blame History

/*
* This file is part of RawTherapee.
*
* Copyright (c) 2004-2010 Gabor Horvath <hgabor@rawtherapee.com>
*
* 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 <https://www.gnu.org/licenses/>.
*/
#include "whitebalance.h"
#include <iomanip>
#include "rtimage.h"
#include "rtsurface.h"
#include "options.h"
#include "eventmapper.h"
#include "../rtengine/colortemp.h"
#define MINTEMP 1500 //1200
#define MAXTEMP 60000 //12000
#define CENTERTEMP 4750
#define MINGREEN 0.02
#define MAXGREEN 100.0
#define MINEQUAL 0.5
#define MAXEQUAL 2.
using namespace rtengine;
using namespace rtengine::procparams;
const Glib::ustring WhiteBalance::TOOL_NAME = "whitebalance";
static double wbSlider2Temp(double sval)
{
// slider range: 0 - 10000
double temp;
if (sval <= 5000) {
// linear below center-temp
temp = MINTEMP + (sval / 5000.0) * (CENTERTEMP - MINTEMP);
} else {
const double slope = (double)(CENTERTEMP - MINTEMP) / (MAXTEMP - CENTERTEMP);
double x = (sval - 5000) / 5000; // x 0..1
double y = x * slope + (1.0 - slope) * pow(x, 4.0);
//double y = pow(x, 4.0);
temp = CENTERTEMP + y * (MAXTEMP - CENTERTEMP);
}
if (temp < MINTEMP) {
temp = MINTEMP;
}
if (temp > MAXTEMP) {
temp = MAXTEMP;
}
return temp;
}
static double wbTemp2Slider(double temp)
{
double sval;
if (temp <= CENTERTEMP) {
sval = ((temp - MINTEMP) / (CENTERTEMP - MINTEMP)) * 5000.0;
} else {
const double slope = (double)(CENTERTEMP - MINTEMP) / (MAXTEMP - CENTERTEMP);
const double y = (temp - CENTERTEMP) / (MAXTEMP - CENTERTEMP);
double x = pow(y, 0.25); // rough guess of x, will be a little lower
double k = 0.1;
bool add = true;
// the y=f(x) function is a mess to invert, therefore we have this trial-refinement loop instead.
// from tests, worst case is about 20 iterations, ie no problem
for (;;) {
double y1 = x * slope + (1.0 - slope) * pow(x, 4.0);
if (5000 * fabs(y1 - y) < 0.1) {
break;
}
if (y1 < y) {
if (!add) {
k /= 2;
}
x += k;
add = true;
} else {
if (add) {
k /= 2;
}
x -= k;
add = false;
}
}
sval = 5000.0 + x * 5000.0;
}
if (sval < 0) {
sval = 0;
}
if (sval > 10000) {
sval = 10000;
}
return sval;
}
WhiteBalance::WhiteBalance () : FoldableToolPanel(this, TOOL_NAME, M("TP_WBALANCE_LABEL"), true, true), wbp(nullptr), wblistener(nullptr)
{
// Assign icon name to wbIcons
wbIcons[toUnderlying(WBEntry::Type::CAMERA)] = "wb-camera-small";
wbIcons[toUnderlying(WBEntry::Type::AUTO)] = "wb-auto-small";
wbIcons[toUnderlying(WBEntry::Type::DAYLIGHT)] = "wb-sun-small";
wbIcons[toUnderlying(WBEntry::Type::CLOUDY)] = "wb-cloudy-small";
wbIcons[toUnderlying(WBEntry::Type::SHADE)] = "wb-shade-small";
wbIcons[toUnderlying(WBEntry::Type::WATER)] = "wb-water-small";
wbIcons[toUnderlying(WBEntry::Type::TUNGSTEN)] = "wb-tungsten-small";
wbIcons[toUnderlying(WBEntry::Type::FLUORESCENT)] = "wb-fluorescent-small";
wbIcons[toUnderlying(WBEntry::Type::LAMP)] = "wb-lamp-small";
wbIcons[toUnderlying(WBEntry::Type::FLASH)] = "wb-flash-small";
wbIcons[toUnderlying(WBEntry::Type::LED)] = "wb-led-small";
wbIcons[toUnderlying(WBEntry::Type::CUSTOM)] = "wb-custom-small";
Gtk::Grid* methodgrid = Gtk::manage(new Gtk::Grid());
methodgrid->get_style_context()->add_class("grid-spacing");
setExpandAlignProperties(methodgrid, true, false, Gtk::ALIGN_FILL, Gtk::ALIGN_CENTER);
Gtk::Label* lab = Gtk::manage (new Gtk::Label (M("TP_WBALANCE_METHOD") + ":"));
setExpandAlignProperties(lab, false, false, Gtk::ALIGN_START, Gtk::ALIGN_CENTER);
// Create the Tree model
refTreeModel = Gtk::TreeStore::create(methodColumns);
// Create the Combobox
method = Gtk::manage (new MyComboBox ());
setExpandAlignProperties(method, true, false, Gtk::ALIGN_FILL, Gtk::ALIGN_CENTER);
// Assign the model to the Combobox
method->set_model(refTreeModel);
method->clear(); // Clear default cell layout to add custom one
Gtk::CellRendererPixbuf* const renderer_icon = Gtk::manage(new Gtk::CellRendererPixbuf());
renderer_icon->property_stock_size() = Gtk::ICON_SIZE_MENU;
method->pack_start(*renderer_icon, false);
method->add_attribute(*renderer_icon, "icon-name", methodColumns.colIcon);
Gtk::CellRendererText* const renderer_label = Gtk::manage(new Gtk::CellRendererText());
renderer_label->property_ellipsize() = Pango::ELLIPSIZE_MIDDLE;
method->pack_start(*renderer_label, true);
method->add_attribute(*renderer_label, "markup", methodColumns.colLabel);
WBEntry::Type oldType = WBParams::getWbEntries()[0].type;
WBEntry::Type currType;
Gtk::TreeModel::Row row, childrow;
for (unsigned int i = 0; i < WBParams::getWbEntries().size(); i++) {
if (oldType != (currType = WBParams::getWbEntries()[i].type)) {
// New entry type
if (currType == WBEntry::Type::FLUORESCENT) {
// Creating the Fluorescent subcategory header
row = *(refTreeModel->append());
row[methodColumns.colIcon] = wbIcons[toUnderlying(currType)];
row[methodColumns.colLabel] = M("TP_WBALANCE_FLUO_HEADER");
row[methodColumns.colId] = i + 100;
}
if (currType == WBEntry::Type::AUTO) {
// Creating the auto category
row = *(refTreeModel->append());
row[methodColumns.colIcon] = wbIcons[toUnderlying(currType)];
row[methodColumns.colLabel] = M("TP_WBALANCE_AUTO_HEADER");
row[methodColumns.colId] = i + 100;
}
if (currType == WBEntry::Type::WATER) {
// Creating the under water subcategory header
row = *(refTreeModel->append());
row[methodColumns.colIcon] = wbIcons[toUnderlying(currType)];
row[methodColumns.colLabel] = M("TP_WBALANCE_WATER_HEADER");
row[methodColumns.colId] = i + 100;
}
if (currType == WBEntry::Type::LAMP) {
// Creating the Lamp subcategory header
row = *(refTreeModel->append());
row[methodColumns.colIcon] = wbIcons[toUnderlying(currType)];
row[methodColumns.colLabel] = M("TP_WBALANCE_LAMP_HEADER");
row[methodColumns.colId] = i + 100;
}
if (currType == WBEntry::Type::LED) {
// Creating the LED subcategory header
row = *(refTreeModel->append());
row[methodColumns.colIcon] = wbIcons[toUnderlying(currType)];
row[methodColumns.colLabel] = M("TP_WBALANCE_LED_HEADER");
row[methodColumns.colId] = i + 100;
}
if (currType == WBEntry::Type::FLASH) {
// Creating the Flash subcategory header
row = *(refTreeModel->append());
row[methodColumns.colIcon] = wbIcons[toUnderlying(currType)];
row[methodColumns.colLabel] = M("TP_WBALANCE_FLASH_HEADER");
row[methodColumns.colId] = i + 100;
}
}
if (currType == WBEntry::Type::FLUORESCENT
|| currType == WBEntry::Type::LAMP
|| currType == WBEntry::Type::WATER
|| currType == WBEntry::Type::FLASH
|| currType == WBEntry::Type::LED
|| currType == WBEntry::Type::AUTO
) {
childrow = *(refTreeModel->append(row.children()));
childrow[methodColumns.colIcon] = wbIcons[toUnderlying(currType)];
childrow[methodColumns.colLabel] = WBParams::getWbEntries()[i].GUILabel;
childrow[methodColumns.colId] = i;
} else {
row = *(refTreeModel->append());
row[methodColumns.colIcon] = wbIcons[toUnderlying(currType)];
row[methodColumns.colLabel] = WBParams::getWbEntries()[i].GUILabel;
row[methodColumns.colId] = i;
}
oldType = currType;
custom_green = 1.0;
custom_equal = 1.0;
}
auto m = ProcEventMapper::getInstance();
EvWBObserver10 = m->newEvent(WB, "HISTORY_MSG_WBALANCE_OBSERVER10");
EvWBitcwbprim = m->newEvent(WB, "HISTORY_MSG_WBITC_PRIM");
EvWBitcwbalg = m->newEvent(WB, "HISTORY_MSG_WBITC_OBS");
EvWBitcwgreen = m->newEvent(WB, "HISTORY_MSG_WBITC_GREEN");
resetButton = Gtk::manage (new Gtk::Button()); // No label, keep it short
setExpandAlignProperties(resetButton, false, false, Gtk::ALIGN_START, Gtk::ALIGN_CENTER);
resetButton->set_relief(Gtk::RELIEF_NONE);
resetButton->get_style_context()->add_class(GTK_STYLE_CLASS_FLAT);
resetButton->set_image (*Gtk::manage (new RTImage ("undo-small", Gtk::ICON_SIZE_BUTTON)));
method->set_active (0); // Camera
methodgrid->attach (*lab, 0, 0, 1, 1);
methodgrid->attach (*method, 1, 0, 1, 1);
methodgrid->attach (*resetButton, 2, 0, 1, 1);
pack_start (*methodgrid, Gtk::PACK_SHRINK, 0 );
opt = 0;
Gtk::Grid* spotgrid = Gtk::manage(new Gtk::Grid());
spotgrid->get_style_context()->add_class("grid-spacing");
setExpandAlignProperties(spotgrid, true, false, Gtk::ALIGN_FILL, Gtk::ALIGN_CENTER);
spotbutton = Gtk::manage (new Gtk::Button (M("TP_WBALANCE_PICKER")));
setExpandAlignProperties(spotbutton, true, false, Gtk::ALIGN_FILL, Gtk::ALIGN_CENTER);
spotbutton->get_style_context()->add_class("independent");
spotbutton->set_tooltip_text(M("TP_WBALANCE_SPOTWB"));
spotbutton->set_image (*Gtk::manage (new RTImage ("color-picker-small", Gtk::ICON_SIZE_BUTTON)));
Gtk::Label* slab = Gtk::manage (new Gtk::Label (M("TP_WBALANCE_SIZE")));
setExpandAlignProperties(slab, false, false, Gtk::ALIGN_START, Gtk::ALIGN_CENTER);
Gtk::Grid* wbsizehelper = Gtk::manage(new Gtk::Grid());
wbsizehelper->set_name("WB-Size-Helper");
setExpandAlignProperties(wbsizehelper, false, false, Gtk::ALIGN_START, Gtk::ALIGN_CENTER);
spotsize = Gtk::manage (new MyComboBoxText ());
setExpandAlignProperties(spotsize, true, false, Gtk::ALIGN_FILL, Gtk::ALIGN_CENTER);
spotsize->append ("2");
if (options.whiteBalanceSpotSize == 2) {
spotsize->set_active(0);
}
spotsize->append ("4");
if (options.whiteBalanceSpotSize == 4) {
spotsize->set_active(1);
}
spotsize->append ("8");
if (options.whiteBalanceSpotSize == 8) {
spotsize->set_active(2);
}
spotsize->append ("16");
if (options.whiteBalanceSpotSize == 16) {
spotsize->set_active(3);
}
spotsize->append ("32");
if (options.whiteBalanceSpotSize == 32) {
spotsize->set_active(4);
}
wbsizehelper->attach (*spotsize, 0, 0, 1, 1);
spotgrid->attach (*spotbutton, 0, 0, 1, 1);
spotgrid->attach (*slab, 1, 0, 1, 1);
spotgrid->attach (*wbsizehelper, 2, 0, 1, 1);
pack_start (*spotgrid, Gtk::PACK_SHRINK, 0 );
Gtk::Separator *separator = Gtk::manage (new Gtk::Separator(Gtk::ORIENTATION_HORIZONTAL));
separator->get_style_context()->add_class("grid-row-separator");
pack_start (*separator, Gtk::PACK_SHRINK, 0);
Gtk::Image* itempL = Gtk::manage (new RTImage ("circle-blue-small", Gtk::ICON_SIZE_BUTTON));
Gtk::Image* itempR = Gtk::manage (new RTImage ("circle-yellow-small", Gtk::ICON_SIZE_BUTTON));
Gtk::Image* igreenL = Gtk::manage (new RTImage ("circle-magenta-small", Gtk::ICON_SIZE_BUTTON));
Gtk::Image* igreenR = Gtk::manage (new RTImage ("circle-green-small", Gtk::ICON_SIZE_BUTTON));
Gtk::Image* iblueredL = Gtk::manage (new RTImage ("circle-blue-small", Gtk::ICON_SIZE_BUTTON));
Gtk::Image* iblueredR = Gtk::manage (new RTImage ("circle-red-small", Gtk::ICON_SIZE_BUTTON));
Gtk::Image* itempbiasL = Gtk::manage (new RTImage ("circle-blue-small", Gtk::ICON_SIZE_BUTTON));
Gtk::Image* itempbiasR = Gtk::manage (new RTImage ("circle-yellow-small", Gtk::ICON_SIZE_BUTTON));
StudLabel = Gtk::manage(new Gtk::Label("---", Gtk::ALIGN_CENTER));
StudLabel->set_tooltip_text(M("TP_WBALANCE_STUDLABEL_TOOLTIP"));
PatchLabel = Gtk::manage(new Gtk::Label("---", Gtk::ALIGN_CENTER));
PatchLabel->set_tooltip_text(M("TP_WBALANCE_PATCHLABEL_TOOLTIP"));
PatchlevelLabel = Gtk::manage(new Gtk::Label("---", Gtk::ALIGN_CENTER));
PatchlevelLabel->set_tooltip_text(M("TP_WBALANCE_PATCHLEVELLABEL_TOOLTIP"));
mulLabel = Gtk::manage(new Gtk::Label("---", Gtk::ALIGN_CENTER));
mulLabel->set_tooltip_text(M("TP_WBALANCE_MULLABEL_TOOLTIP"));
mulLabel->show();
temp = Gtk::manage (new Adjuster (M("TP_WBALANCE_TEMPERATURE"), MINTEMP, MAXTEMP, 5, CENTERTEMP, itempL, itempR, &wbSlider2Temp, &wbTemp2Slider));
green = Gtk::manage (new Adjuster (M("TP_WBALANCE_GREEN"), MINGREEN, MAXGREEN, 0.001, 1.0, igreenL, igreenR));
equal = Gtk::manage (new Adjuster (M("TP_WBALANCE_EQBLUERED"), MINEQUAL, MAXEQUAL, 0.001, 1.0, iblueredL, iblueredR));
tempBias = Gtk::manage (new Adjuster(M("TP_WBALANCE_TEMPBIAS"), -1.1, 1.1, 0.005, 0.0, itempbiasL, itempbiasR));
observer10 = Gtk::manage(new CheckBox(M("TP_WBALANCE_OBSERVER10"), multiImage));
cache_customTemp (0);
cache_customGreen (0);
cache_customEqual (0);
equal->set_tooltip_markup (M("TP_WBALANCE_EQBLUERED_TOOLTIP"));
tempBias->set_tooltip_markup (M("TP_WBALANCE_TEMPBIAS_TOOLTIP"));
observer10->set_tooltip_text(M("TP_WBALANCE_OBSERVER10_TOOLTIP"));
temp->show ();
green->show ();
equal->show ();
tempBias->show ();
observer10->show();
itcwbFrame = Gtk::manage(new Gtk::Frame(M("TP_WBALANCE_ITCWB_FRA")));
itcwbFrame->set_label_align(0.025, 0.5);
itcwbFrame->set_tooltip_markup (M("PREFERENCES_WBACORR_TOOLTIP"));
ToolParamBlock* const itcwbBox = Gtk::manage(new ToolParamBlock());
itcwb_green = Gtk::manage (new Adjuster (M("TP_WBALANCE_ITCWGREEN"), -0.35, 0.35, 0.005, 0.));
itcwb_green ->set_tooltip_markup (M("TP_WBALANCE_ITCWGREEN_TOOLTIP"));
itcwb_alg = Gtk::manage (new Gtk::CheckButton (M("TP_WBALANCE_ITCWB_ALG")));
itcwb_alg ->set_tooltip_markup (M("TP_WBALANCE_ITCWALG_TOOLTIP"));
itcwb_alg ->set_active (false);
itcwb_prim = Gtk::manage (new MyComboBoxText ());
itcwb_prim->append(M("TP_WBALANCE_ITCWB_PRIM_SRGB"));
itcwb_prim->append(M("TP_WBALANCE_ITCWB_PRIM_BETA"));
itcwb_prim->append(M("TP_WBALANCE_ITCWB_PRIM_XYZCAM"));
itcwb_prim->append(M("TP_WBALANCE_ITCWB_PRIM_JDCMAX"));
itcwb_prim->set_active(1);
itcwb_primconn = itcwb_prim->signal_changed().connect(sigc::mem_fun(*this, &WhiteBalance::itcwb_prim_changed));
itcwb_prim ->set_tooltip_markup (M("TP_WBALANCE_ITCWPRIM_TOOLTIP"));
compatVersionAdjuster.reset(new Adjuster("", 0., procparams::WBParams::CURRENT_COMPAT_VERSION, 1., procparams::WBParams::CURRENT_COMPAT_VERSION));
/* Gtk::Box* boxgreen = Gtk::manage (new Gtk::Box ());
boxgreen->show ();
boxgreen->pack_start(*igreenL);
boxgreen->pack_start(*green);
boxgreen->pack_start(*igreenR);*/
pack_start(*mulLabel);
pack_start(*StudLabel);
pack_start(*PatchLabel);
pack_start(*PatchlevelLabel);
green->setLogScale(MAXGREEN / MINGREEN, MINGREEN);
pack_start (*temp);
//pack_start (*boxgreen);
pack_start (*green);
pack_start (*equal);
pack_start (*tempBias);
pack_start(*observer10);
itcwbBox->pack_start (*itcwb_green);
itcwbBox->pack_start (*itcwb_alg);
itcwbBox->pack_start (*itcwb_prim);
itcwbFrame->add(*itcwbBox);
pack_start(*itcwbFrame);
if(options.rtSettings.itcwb_enable) {
itcwb_green->show();
itcwb_alg->show();
itcwb_prim->show();
itcwbFrame->show();
} else {
itcwb_green->show();
itcwb_alg->hide();
itcwb_prim->hide();
}
temp->setAdjusterListener (this);
green->setAdjusterListener (this);
equal->setAdjusterListener (this);
tempBias->setAdjusterListener (this);
observer10->setCheckBoxListener(this);
itcwb_green->setAdjusterListener (this);
spotbutton->signal_pressed().connect( sigc::mem_fun(*this, &WhiteBalance::spotPressed) );
methconn = method->signal_changed().connect( sigc::mem_fun(*this, &WhiteBalance::optChanged) );
itcwb_algconn = itcwb_alg->signal_toggled().connect( sigc::mem_fun(*this, &WhiteBalance::itcwb_alg_toggled) );
resetButton->signal_pressed().connect( sigc::mem_fun(*this, &WhiteBalance::resetWB) );
spotsize->signal_changed().connect( sigc::mem_fun(*this, &WhiteBalance::spotSizeChanged) );
}
WhiteBalance::~WhiteBalance()
{
idle_register.destroy();
}
void WhiteBalance::enabledChanged()
{
if (listener) {
if (get_inconsistent()) {
listener->panelChanged(EvWBEnabled, M("GENERAL_UNCHANGED"));
} else if (getEnabled()) {
listener->panelChanged(EvWBEnabled, M("GENERAL_ENABLED"));
} else {
listener->panelChanged(EvWBEnabled, M("GENERAL_DISABLED"));
}
}
}
void WhiteBalance::itcwb_prim_changed ()
{
if (listener && getEnabled()) {
listener->panelChanged(EvWBitcwbprim, M("GENERAL_ENABLED"));
}
}
void WhiteBalance::itcwb_alg_toggled ()
{
if (batchMode) {
if (itcwb_alg->get_inconsistent()) {
itcwb_alg->set_inconsistent (false);
itcwb_algconn.block (true);
itcwb_alg->set_active (false);
itcwb_algconn.block (false);
} else if (lastitcwb_alg) {
itcwb_alg->set_inconsistent (true);
}
lastitcwb_alg = itcwb_alg->get_active ();
}
if (listener && getEnabled()) {
if (itcwb_alg->get_active ()) {
listener->panelChanged (EvWBitcwbalg, M("GENERAL_ENABLED"));
} else {
listener->panelChanged (EvWBitcwbalg, M("GENERAL_DISABLED"));
}
}
}
void WhiteBalance::adjusterChanged(Adjuster* a, double newval)
{
int tVal = (int)temp->getValue();
double gVal = green->getValue();
double eVal = equal->getValue();
Gtk::TreeModel::Row row = getActiveMethod();
if (row == refTreeModel->children().end()) {
return;
}
const std::pair<bool, const WBEntry&> ppMethod = findWBEntry (row[methodColumns.colLabel], WBLT_GUI);
const std::pair<bool, const WBEntry&> wbCustom = findWBEntry ("Custom", WBLT_PP);
if (
!ppMethod.first
|| (
ppMethod.second.ppLabel != wbCustom.second.ppLabel
&& !(
(
a == equal
|| a == tempBias
|| a == itcwb_green
)
&& ppMethod.second.type == WBEntry::Type::AUTO
)
)
) {
methconn.block(true);
opt = setActiveMethod(wbCustom.second.GUILabel);
tempBias->set_sensitive(false);
cache_customWB (tVal, gVal);
if (a != equal) {
cache_customEqual(eVal);
}
methconn.block(false);
}
//cache custom WB setting to allow its recall
if (a == temp) {
cache_customTemp (tVal);
} else if (a == green) {
cache_customGreen (gVal);
} else if (a == equal) {
cache_customEqual (eVal);
}
// Recomputing AutoWB if it's the current method will happen in improccoordinator.cc
if (listener && getEnabled()) {
if (a == temp) {
listener->panelChanged (EvWBTemp, Glib::ustring::format ((int)a->getValue()));
itcwbFrame->set_sensitive(false);
} else if (a == green) {
listener->panelChanged (EvWBGreen, Glib::ustring::format (std::setw(4), std::fixed, std::setprecision(3), a->getValue()));
itcwbFrame->set_sensitive(false);
} else if (a == equal) {
listener->panelChanged (EvWBequal, Glib::ustring::format (std::setw(4), std::fixed, std::setprecision(3), a->getValue()));
} else if (a == tempBias) {
listener->panelChanged (EvWBtempBias, Glib::ustring::format (std::setw(4), std::fixed, std::setprecision(2), a->getValue()));
} else if (a == itcwb_green) {
listener->panelChanged (EvWBitcwgreen, Glib::ustring::format (std::setw(4), std::fixed, std::setprecision(2), a->getValue()));
}
}
}
void WhiteBalance::checkBoxToggled(CheckBox* c, CheckValue newval)
{
if (!(getEnabled() && listener)) {
return;
}
if (c == observer10) {
// If camera WB, update the temperature and tint according to observer.
const Gtk::TreeModel::Row row = getActiveMethod();
unsigned int methodId = findWBEntryId(row[methodColumns.colLabel], WBLT_GUI);
const WBEntry &currMethod = WBParams::getWbEntries()[methodId];
if (row[methodColumns.colLabel] != M("GENERAL_UNCHANGED") && currMethod.type == WBEntry::Type::CAMERA && wbp) {
double ctemp, cgreen;
wbp->getCamWB(ctemp, cgreen,
observer10->getValue() == CheckValue::off
? rtengine::StandardObserver::TWO_DEGREES
: rtengine::StandardObserver::TEN_DEGREES);
temp->setValue(temp->getAddMode() ? 0.0 : static_cast<int>(ctemp));
green->setValue(green->getAddMode() ? 0.0 : cgreen);
}
listener->panelChanged(
EvWBObserver10,
c->getValue() == CheckValue::on ? M("GENERAL_ENABLED")
: c->getValue() == CheckValue::off
? M("GENERAL_DISABLED")
: M("GENERAL_UNCHANGED"));
}
}
void WhiteBalance::optChanged ()
{
Gtk::TreeModel::Row row = getActiveMethod();
if (row == refTreeModel->children().end()) {
return;
}
if (row[methodColumns.colId] >= 100) {
// "Header" solutions are trapped ; the combo is then set to the previous value
bool prevState = methconn.block(true);
method->set_active(opt);
methconn.block(prevState);
return;
}
StudLabel->hide();
mulLabel->show();
PatchLabel->hide();
PatchlevelLabel->hide();
if (opt != row[methodColumns.colId]) {
opt = row[methodColumns.colId];
if (row[methodColumns.colLabel] == M("GENERAL_UNCHANGED")) {
temp->setEditedState (UnEdited);
green->setEditedState (UnEdited);
equal->setEditedState (UnEdited);
tempBias->setEditedState (UnEdited);
observer10->setEdited(false);
compatVersionAdjuster->setEditedState(UnEdited);
} else {
unsigned int methodId = findWBEntryId (row[methodColumns.colLabel], WBLT_GUI);
const WBEntry& currMethod = WBParams::getWbEntries()[methodId];
tempBias->set_sensitive(currMethod.type == WBEntry::Type::AUTO);
bool autit = (currMethod.ppLabel == "autitcgreen");
if (autit) {
StudLabel->show();
PatchLabel->show();
PatchlevelLabel->show();
equal->hide();
itcwbFrame->set_sensitive(true);
} else {
StudLabel->hide();
PatchLabel->hide();
PatchlevelLabel->hide();
equal->show();
itcwbFrame->set_sensitive(false);
}
switch (currMethod.type) {
case WBEntry::Type::CAMERA:
if (wbp) {
double ctemp, cgreen;
wbp->getCamWB(ctemp, cgreen,
observer10->getValue() == CheckValue::off
? rtengine::StandardObserver::TWO_DEGREES
: rtengine::StandardObserver::TEN_DEGREES);
temp->setValue (temp->getAddMode() ? 0.0 : (int)ctemp);
green->setValue (green->getAddMode() ? 0.0 : cgreen);
equal->setValue (equal->getAddMode() ? 0.0 : 1.0);
if (batchMode) {
temp->setEditedState (UnEdited);
green->setEditedState (UnEdited);
equal->setEditedState (UnEdited);
observer10->setEdited(false);
}
}
break;
case WBEntry::Type::AUTO:
if (wbp) {
if (batchMode) {
temp->setEditedState (UnEdited);
green->setEditedState (UnEdited);
// equal and observer remain as is
}
// Recomputing AutoWB will happen in improccoordinator.cc
}
break;
case WBEntry::Type::CUSTOM:
if (custom_temp > 0) {
temp->setValue (temp->getAddMode() ? 0.0 : custom_temp);
green->setValue (green->getAddMode() ? 0.0 : custom_green);
equal->setValue (equal->getAddMode() ? 0.0 : custom_equal);
} else {
cache_customTemp (temp->getValue());
cache_customGreen (green->getValue());
cache_customEqual (equal->getValue());
}
if (batchMode) {
temp->setEditedState (Edited);
green->setEditedState (Edited);
equal->setEditedState (Edited);
observer10->setEdited(true);
}
break;
/* All other solution are the default cases
case WBEntry::Type::DAYLIGHT:
case WBEntry::Type::CLOUDY:
case WBEntry::Type::SHADE:
case WBEntry::Type::TUNGSTEN:
case WBEntry::Type::FLUORESCENT:
case WBEntry::Type::LAMP:
case WBEntry::Type::FLASH:
case WBEntry::Type::LED:*/
default:
// recall custom WB settings if it exists, set to 1.0 otherwise
temp->setValue ( temp->getAddMode() ? 0.0 : (double)(currMethod.temperature));
green->setValue (green->getAddMode() ? 0.0 : (double)(currMethod.green));
equal->setValue (equal->getAddMode() ? 0.0 : (double)(currMethod.equal));
if (batchMode) {
temp->setEditedState (Edited);
green->setEditedState (Edited);
equal->setEditedState (Edited);
observer10->setEdited(true);
}
break;
}
if (compatVersionAdjuster->getIntValue() == 1 &&
(!batchMode || currMethod.type != WBEntry::Type::AUTO)) {
// Safe to upgrade version because method changed. In batch
// mode, this method may be called even if there is no change,
// so it's only safe to upgrade if the new method is not auto.
compatVersionAdjuster->setValue(procparams::WBParams::CURRENT_COMPAT_VERSION);
if (batchMode) {
compatVersionAdjuster->setEditedState(Edited);
}
}
}
if (listener && getEnabled()) {
listener->panelChanged (EvWBMethod, row[methodColumns.colLabel]);
}
}
}
void WhiteBalance::spotPressed ()
{
StudLabel->hide();
mulLabel->show();
PatchLabel->hide();
PatchlevelLabel->hide();
if (wblistener) {
wblistener->spotWBRequested (getSize());
}
}
void WhiteBalance::spotSizeChanged ()
{
options.whiteBalanceSpotSize = getSize();
if (wblistener) {
wblistener->spotWBRequested (getSize());
}
}
void WhiteBalance::read (const ProcParams* pp, const ParamsEdited* pedited)
{
disableListener ();
methconn.block (true);
equal->setValue (pp->wb.equal);
observer10->setValue(rtengine::StandardObserver::TEN_DEGREES == pp->wb.observer);
tempBias->setValue (pp->wb.tempBias);
tempBias->set_sensitive(true);
itcwb_algconn.block (true);
itcwb_alg->set_active (pp->wb.itcwb_alg);
itcwb_algconn.block (false);
lastitcwb_alg = pp->wb.itcwb_alg;
itcwb_green->setValue (pp->wb.itcwb_green);
compatVersionAdjuster->setValue(pp->wb.compat_version);
itcwb_primconn.block (true);
if (pp->wb.itcwb_prim == "srgb") {
itcwb_prim->set_active(0);
} else if (pp->wb.itcwb_prim == "beta") {
itcwb_prim->set_active(1);
} else if (pp->wb.itcwb_prim == "XYZcam") {
itcwb_prim->set_active(2);
} else if (pp->wb.itcwb_prim == "jdcmax") {
itcwb_prim->set_active(3);
}
itcwb_primconn.block (false);
if(options.rtSettings.itcwb_enable) {
itcwb_green->show();
itcwb_alg->show();
itcwb_prim->show();
itcwbFrame->show();
} else {
itcwb_green->hide();
itcwb_alg->hide();
itcwb_prim->hide();
itcwbFrame->hide();
}
if (pedited) {
// By default, temperature and green are said "UnEdited", but it may change later
temp->setEditedState (UnEdited);
green->setEditedState (UnEdited);
equal->setEditedState (pedited->wb.equal ? Edited : UnEdited);
tempBias->setEditedState (pedited->wb.tempBias ? Edited : UnEdited);
observer10->setEdited(pedited->wb.observer);
itcwb_alg->set_inconsistent (!pedited->wb.itcwb_alg);
itcwb_green->setEditedState (pedited->wb.itcwb_green ? Edited : UnEdited);
compatVersionAdjuster->setEditedState(pedited->wb.compat_version ? Edited : UnEdited);
}
if (pedited && !pedited->wb.method) {
opt = setActiveMethod(M("GENERAL_UNCHANGED"));
} else {
const WBEntry& wbValues =
[this, pp]() -> const WBEntry&
{
const std::pair<bool, const WBEntry&> res = findWBEntry(pp->wb.method, WBLT_PP);
return
!res.first
? findWBEntry("Camera", WBLT_PP).second
: res.second;
}();
opt = setActiveMethod(wbValues.GUILabel);
// temperature is reset to the associated temperature, or 0.0 if addMode is set.
switch (wbValues.type) {
case WBEntry::Type::CUSTOM:
temp->setValue (temp->getAddMode() ? 0.0 : pp->wb.temperature);
green->setValue (green->getAddMode() ? 0.0 : pp->wb.green);
equal->setValue (equal->getAddMode() ? 0.0 : pp->wb.equal);
tempBias->setValue (tempBias->getAddMode() ? 0.0 : pp->wb.tempBias);
cache_customTemp (pp->wb.temperature);
cache_customGreen (pp->wb.green);
cache_customEqual (pp->wb.equal);
if (pedited) {
// The user may have changed the temperature and green value
temp->setEditedState (pedited->wb.temperature ? Edited : UnEdited);
green->setEditedState (pedited->wb.green ? Edited : UnEdited);
}
break;
case WBEntry::Type::CAMERA:
if (wbp) {
double ctemp = -1.0;
double cgreen = -1.0;
wbp->getCamWB (ctemp, cgreen, pp->wb.observer);
if (ctemp != -1.0) {
// Set the camera's temperature value, or 0.0 if in ADD mode
temp->setValue (temp->getAddMode() ? 0.0 : ctemp);
// Set the camera's green value, or 0.0 if in ADD mode
green->setValue (green->getAddMode() ? 0.0 : cgreen);
equal->setValue (equal->getAddMode() ? 0.0 : 1.);
} else {
temp->setValue (temp->getAddMode() ? 0.0 : pp->wb.temperature);
green->setValue (green->getAddMode() ? 0.0 : pp->wb.green);
equal->setValue (equal->getAddMode() ? 0.0 : pp->wb.equal);
}
tempBias->setValue (equal->getAddMode() ? 0.0 : pp->wb.tempBias);
}
break;
case WBEntry::Type::AUTO:
// the equalizer's value is restored for the AutoWB
equal->setValue (equal->getAddMode() ? 0.0 : pp->wb.equal);
tempBias->setValue (tempBias->getAddMode() ? 0.0 : pp->wb.tempBias);
// set default values first if in ADD mode, otherwise keep the current ones
if (temp->getAddMode() ) {
temp->setValue (0.0);
}
if (green->getAddMode()) {
green->setValue (0.0);
}
// Recomputing AutoWB will happen in improccoordinator.cc
break;
/*
All those types are the "default" case:
case WBEntry::Type::DAYLIGHT:
case WBEntry::Type::CLOUDY:
case WBEntry::Type::SHADE:
case WBEntry::Type::TUNGSTEN:
case WBEntry::Type::FLUORESCENT:
case WBEntry::Type::LAMP:
case WBEntry::Type::FLASH:
case WBEntry::Type::LED:
*/
default:
// Set the associated temperature, or 0.0 if in ADD mode
temp->setValue(temp->getAddMode() ? 0.0 : (double)wbValues.temperature);
// Set the stored temperature, or 0.0 if in ADD mode
green->setValue(green->getAddMode() ? 0.0 : pp->wb.green);
equal->setValue(equal->getAddMode() ? 0.0 : pp->wb.equal);
tempBias->setValue(equal->getAddMode() ? 0.0 : pp->wb.tempBias);
// The user may have changed the green value even for predefined WB values
if (pedited) {
green->setEditedState (pedited->wb.green ? Edited : UnEdited);
equal->setEditedState (pedited->wb.equal ? Edited : UnEdited);
tempBias->setEditedState (pedited->wb.tempBias ? Edited : UnEdited);
}
//cache_customGreen (pp->wb.green);
break;
}
tempBias->set_sensitive(wbValues.type == WBEntry::Type::AUTO);
bool autit = (wbValues.ppLabel == "autitcgreen");
if (autit) {
StudLabel->show();
PatchLabel->show();
PatchlevelLabel->show();
equal->hide();
if(pp->wb.itcwb_sampling) {
tempBias->set_sensitive(false);
}
itcwbFrame->set_sensitive(!pp->wb.itcwb_sampling);
itcwb_prim_changed ();
} else {
StudLabel->hide();
PatchLabel->hide();
PatchlevelLabel->hide();
mulLabel->show();
equal->show();
itcwbFrame->set_sensitive(false);
}
}
setEnabled(pp->wb.enabled);
if (pedited) {
set_inconsistent(multiImage && !pedited->wb.enabled);
}
methconn.block (false);
enableListener ();
}
void WhiteBalance::write (ProcParams* pp, ParamsEdited* pedited)
{
Gtk::TreeModel::Row row = getActiveMethod();
if (pedited) {
pedited->wb.temperature = temp->getEditedState ();
pedited->wb.green = green->getEditedState ();
pedited->wb.equal = equal->getEditedState ();
pedited->wb.tempBias = tempBias->getEditedState ();
pedited->wb.observer = observer10->getEdited();
pedited->wb.itcwb_alg = !itcwb_alg->get_inconsistent();
pedited->wb.method = row[methodColumns.colLabel] != M("GENERAL_UNCHANGED");
pedited->wb.enabled = !get_inconsistent();
pedited->wb.itcwb_prim = itcwb_prim->get_active_text() != M("GENERAL_UNCHANGED");
pedited->wb.itcwb_green = itcwb_green->getEditedState ();
pedited->wb.compat_version = compatVersionAdjuster->getEditedState();
}
pp->wb.enabled = getEnabled();
if (itcwb_prim->get_active_row_number() == 0) {
pp->wb.itcwb_prim = "srgb";
} else if (itcwb_prim->get_active_row_number() == 1){
pp->wb.itcwb_prim = "beta";
} else if (itcwb_prim->get_active_row_number() == 2){
pp->wb.itcwb_prim = "XYZcam";
} else if (itcwb_prim->get_active_row_number() == 3){
pp->wb.itcwb_prim = "jdcmax";
}
const std::pair<bool, const WBEntry&> ppMethod = findWBEntry (row[methodColumns.colLabel], WBLT_GUI);
if (ppMethod.first) {
pp->wb.method = ppMethod.second.ppLabel;
if (pp->wb.method != "autitcgreen") {
// Prepare migration to new ITCWB algorithm.
pp->wb.itcwb_sampling = false;
}
}
pp->wb.temperature = temp->getIntValue ();
pp->wb.green = green->getValue ();
pp->wb.equal = equal->getValue ();
pp->wb.observer =
observer10->getValue() == CheckValue::on
? rtengine::StandardObserver::TEN_DEGREES
: observer10->getValue() == CheckValue::off
? rtengine::StandardObserver::TWO_DEGREES
: pp->wb.observer;
pp->wb.itcwb_alg = itcwb_alg->get_active ();
pp->wb.tempBias = tempBias->getValue ();
pp->wb.itcwb_green = itcwb_green->getValue ();
pp->wb.compat_version = compatVersionAdjuster->getIntValue();
}
void WhiteBalance::setDefaults (const ProcParams* defParams, const ParamsEdited* pedited)
{
equal->setDefault (defParams->wb.equal);
tempBias->setDefault (defParams->wb.tempBias);
itcwb_green->setDefault (defParams->wb.itcwb_green);
if (wbp && defParams->wb.method == "Camera") {
double ctemp;
double cgreen;
wbp->getCamWB (ctemp, cgreen, defParams->wb.observer);
// FIXME: Seems to be always -1.0, called too early? Broken!
if (ctemp != -1.0) {
temp->setDefault (temp->getAddMode() ? 0 : (int)ctemp);
green->setDefault (green->getAddMode() ? 0 : cgreen);
}
} else {
temp->setDefault (defParams->wb.temperature);
green->setDefault (defParams->wb.green);
}
// Recomputing AutoWB if it's the current method will happen in improccoordinator.cc
if (pedited) {
temp->setDefaultEditedState (pedited->wb.temperature ? Edited : UnEdited);
green->setDefaultEditedState (pedited->wb.green ? Edited : UnEdited);
equal->setDefaultEditedState (pedited->wb.equal ? Edited : UnEdited);
tempBias->setDefaultEditedState (pedited->wb.tempBias ? Edited : UnEdited);
itcwb_green->setDefaultEditedState (pedited->wb.itcwb_green ? Edited : UnEdited);
} else {
temp->setDefaultEditedState (Irrelevant);
green->setDefaultEditedState (Irrelevant);
equal->setDefaultEditedState (Irrelevant);
tempBias->setDefaultEditedState (Irrelevant);
itcwb_green->setDefaultEditedState (Irrelevant);
}
}
void WhiteBalance::setBatchMode (bool batchMode)
{
ToolPanel::setBatchMode (batchMode);
temp->showEditedCB ();
green->showEditedCB ();
equal->showEditedCB ();
tempBias->showEditedCB ();
compatVersionAdjuster->showEditedCB();
Gtk::TreeModel::Row row = *(refTreeModel->append());
row[methodColumns.colId] = WBParams::getWbEntries().size();
row[methodColumns.colLabel] = M("GENERAL_UNCHANGED");
}
int WhiteBalance::getSize ()
{
return atoi(spotsize->get_active_text().c_str());
}
void WhiteBalance::setWB (int vtemp, double vgreen)
{
methconn.block(true);
const std::pair<bool, const WBEntry&> wbValues = findWBEntry("Custom", WBLT_PP);
setEnabled(true);
temp->setValue (vtemp);
green->setValue (vgreen);
opt = setActiveMethod(wbValues.second.GUILabel);
cache_customWB (vtemp, vgreen); // sequence in which this call is made is important; must be before "method->set_active (2);"
cache_customEqual(equal->getValue());
temp->setEditedState (Edited);
green->setEditedState (Edited);
methconn.block(false);
if (listener) {
listener->panelChanged (EvWBTemp, Glib::ustring::compose("%1, %2", (int)temp->getValue(), Glib::ustring::format (std::setw(4), std::fixed, std::setprecision(3), green->getValue())));
}
}
void WhiteBalance::resetWB ()
{
setActiveMethod(M("TP_WBALANCE_CAMERA"));
}
void WhiteBalance::setAdjusterBehavior (bool tempadd, bool greenadd, bool equaladd, bool tempbiasadd)
{
temp->setAddMode(tempadd);
green->setAddMode(greenadd);
equal->setAddMode(equaladd);
tempBias->setAddMode(tempbiasadd);
}
void WhiteBalance::trimValues (rtengine::procparams::ProcParams* pp)
{
temp->trimValue(pp->wb.temperature);
green->trimValue(pp->wb.green);
equal->trimValue(pp->wb.equal);
tempBias->trimValue(pp->wb.tempBias);
}
inline void WhiteBalance::cache_customTemp(int temp)
{
custom_temp = temp;
}
void WhiteBalance::cache_customGreen(double green)
{
custom_green = green;
}
void WhiteBalance::cache_customEqual(double equal)
{
custom_equal = equal;
}
void WhiteBalance::cache_customWB(int temp, double green)
{
cache_customTemp (temp);
cache_customGreen (green);
}
unsigned int WhiteBalance::findWBEntryId (const Glib::ustring& label, enum WB_LabelType lblType)
{
for (unsigned int i = 0; i < WBParams::getWbEntries().size(); i++) {
if (label == (lblType == WBLT_GUI ? WBParams::getWbEntries()[i].GUILabel : WBParams::getWbEntries()[i].ppLabel)) {
return i;
}
}
return 0; // default to camera wb
}
std::pair<bool, const WBEntry&> WhiteBalance::findWBEntry(const Glib::ustring& label, enum WB_LabelType lblType)
{
for (unsigned int i = 0; i < WBParams::getWbEntries().size(); ++i) {
if (label == (lblType == WBLT_GUI ? WBParams::getWbEntries()[i].GUILabel : WBParams::getWbEntries()[i].ppLabel)) {
return {true, WBParams::getWbEntries()[i]};
}
}
return {false, WBParams::getWbEntries()[0]};
}
int WhiteBalance::_setActiveMethod(Glib::ustring &label, Gtk::TreeModel::Children &children)
{
int found = -1;
for(Gtk::TreeModel::Children::iterator iter = children.begin(); iter != children.end() && found == -1; ++iter) {
Gtk::TreeModel::Row row = *iter;
if (row[methodColumns.colLabel] == label) {
method->set_active(iter);
found = row[methodColumns.colId];
}
if (found != -1) {
return found;
}
Gtk::TreeModel::Children childs = row.children();
if (childs.size()) {
found = _setActiveMethod(label, childs);
if (found != -1) {
return found;
}
}
}
// Entry not found
return -1;
}
int WhiteBalance::setActiveMethod(Glib::ustring label)
{
Gtk::TreeModel::Children children = refTreeModel->children();
return _setActiveMethod(label, children);
}
inline Gtk::TreeRow WhiteBalance::getActiveMethod ()
{
return *(method->get_active());
}
void WhiteBalance::WBChanged(int met, double temperature, double greenVal, double rw, double gw, double bw, float temp0, float delta, int bia, int dread, float studgood, float minchrom, int kmin, float histmin, float histmax, AWBMode aWBMode)
{
idle_register.add(
[this, met, temperature, greenVal, rw, gw, bw, temp0, delta, bia, dread, studgood, minchrom, kmin, histmin, histmax, aWBMode]() -> bool
{
disableListener();
temp->setValue(temperature);
green->setValue(greenVal);
double stud;
stud = studgood;
if(studgood < 0.0001) {
stud = 0.0001;
}
int bia2 = bia;
mulLabel->set_text(
Glib::ustring::compose(M("TP_WBALANCE_MULLABEL"),
Glib::ustring::format(std::fixed, std::setprecision(4), rw),
Glib::ustring::format(std::fixed, std::setprecision(2), gw),
Glib::ustring::format(std::fixed, std::setprecision(4), bw))
);
if(bia == 3) {
bia2 = bia - 1;
StudLabel->set_text(
Glib::ustring::compose(M("TP_WBALANCE_STUDLABEL"),
Glib::ustring::format(std::fixed, std::setprecision(4), stud),
Glib::ustring::format(std::fixed, std::setprecision(0), bia2),
Glib::ustring::format(std::fixed, std::setprecision(0), temp0))
);
} else if(bia == 2) {
StudLabel->set_text(
Glib::ustring::compose(M("TP_WBALANCE_STUDLABEL1"),
Glib::ustring::format(std::fixed, std::setprecision(4), stud),
Glib::ustring::format(std::fixed, std::setprecision(0), bia),
Glib::ustring::format(std::fixed, std::setprecision(0), temp0))
);
} else {
StudLabel->set_text(
Glib::ustring::compose(M("TP_WBALANCE_STUDLABEL0"),
Glib::ustring::format(std::fixed, std::setprecision(4), stud),
Glib::ustring::format(std::fixed, std::setprecision(0), bia),
Glib::ustring::format(std::fixed, std::setprecision(0), temp0))
);
}
PatchLabel->set_text(
Glib::ustring::compose(M("TP_WBALANCE_PATCHLABEL"),
Glib::ustring::format(std::fixed, std::setprecision(0), dread),
Glib::ustring::format(std::fixed, std::setprecision(4), minchrom),
Glib::ustring::format(std::fixed, std::setprecision(0), kmin))
);
PatchlevelLabel->set_text(
Glib::ustring::compose(M("TP_WBALANCE_PATCHLEVELLABEL"),
Glib::ustring::format(std::fixed, std::setprecision(4), delta),
Glib::ustring::format(std::fixed, std::setprecision(0), histmin),
Glib::ustring::format(std::fixed, std::setprecision(0), histmax))
);
if (aWBMode == AWBMode::TEMP_CORRELATION_RAW) {
itcwb_green->set_sensitive(true);
tempBias->set_sensitive(true);
itcwb_alg->set_sensitive(true);
itcwb_prim->set_sensitive(true);
} else if (aWBMode == AWBMode::RGB_GREY) {
itcwb_green->set_sensitive(false);
tempBias->set_sensitive(true);
itcwb_alg->set_sensitive(false);
itcwb_prim->set_sensitive(false);
} else {
itcwb_green->set_sensitive(false);
tempBias->set_sensitive(false);
itcwb_alg->set_sensitive(false);
itcwb_prim->set_sensitive(false);
}
temp->setDefault(temperature);
green->setDefault(greenVal);
enableListener();
return false;
}
);
}
Reference in New Issue View Git Blame Copy Permalink