Moved wavelet to its own tab

2015-06-08 16:22:33 +02:00
commit d5fba1ea48
1741 changed files with 437841 additions and 0 deletions
--- a/rtgui/thresholdadjuster.cc
+++ b/rtgui/thresholdadjuster.cc
@@ -0,0 +1,348 @@
+/*
+ *  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 <http://www.gnu.org/licenses/>.
+ */
+#include "thresholdadjuster.h"
+#include <sigc++/class_slot.h>
+#include <cmath>
+#include "multilangmgr.h"
+#include "../rtengine/rtengine.h"
+#include "options.h"
+#include "guiutils.h"
+#include "rtimage.h"
+
+#define MIN_RESET_BUTTON_HEIGHT 17
+
+ThresholdAdjuster::ThresholdAdjuster (Glib::ustring label,
+				double minValueBottom, double maxValueBottom, double defBottom, Glib::ustring labelBottom, unsigned int precisionBottom,
+				double minValueTop,    double maxValueTop,    double defTop,    Glib::ustring labelTop,    unsigned int precisionTop,
+				ThresholdCurveProvider* curveProvider, bool editedCheckBox)
+				: tSelector(minValueBottom, maxValueBottom, defBottom, labelBottom, precisionBottom, minValueTop, maxValueTop, defTop, labelTop, precisionTop, curveProvider)
+
+{
+	initialDefaultVal[ThresholdSelector::TS_BOTTOMLEFT] = defBottom;
+	initialDefaultVal[ThresholdSelector::TS_TOPLEFT] = defTop;
+	initialDefaultVal[ThresholdSelector::TS_BOTTOMRIGHT] = 0.; // unused
+	initialDefaultVal[ThresholdSelector::TS_TOPRIGHT] = 0.;    // unused
+
+	initObject (label, editedCheckBox);
+}
+
+ThresholdAdjuster::ThresholdAdjuster (Glib::ustring label, double minValue, double maxValue, double defBottom,
+		double defTop, unsigned int precision, bool startAtOne, bool editedCheckBox)
+		: tSelector(minValue, maxValue, defBottom, defTop, precision, startAtOne)
+{
+	initialDefaultVal[ThresholdSelector::TS_BOTTOMLEFT] = defBottom;
+	initialDefaultVal[ThresholdSelector::TS_TOPLEFT] = defTop;
+	initialDefaultVal[ThresholdSelector::TS_BOTTOMRIGHT] = maxValue;
+	initialDefaultVal[ThresholdSelector::TS_TOPRIGHT] = maxValue;
+
+	initObject (label, editedCheckBox);
+}
+
+ThresholdAdjuster::ThresholdAdjuster (Glib::ustring label, double minValue, double maxValue,
+		double defBottomLeft, double defTopLeft, double defBottomRight, double defTopRight,
+		unsigned int precision, bool startAtOne, bool editedCheckBox)
+		: tSelector(minValue, maxValue, defBottomLeft, defTopLeft,
+				defBottomRight, defTopRight, precision, startAtOne)
+{
+	initialDefaultVal[ThresholdSelector::TS_BOTTOMLEFT] = defBottomLeft;
+	initialDefaultVal[ThresholdSelector::TS_TOPLEFT] = defTopLeft;
+	initialDefaultVal[ThresholdSelector::TS_BOTTOMRIGHT] = defBottomRight;
+	initialDefaultVal[ThresholdSelector::TS_TOPRIGHT] = defTopRight;
+
+	initObject (label, editedCheckBox);
+}
+
+void ThresholdAdjuster::initObject (Glib::ustring label, bool editedcb) {
+
+	adjusterListener = NULL;
+	afterReset = false;
+	blocked = false;
+
+	addMode = false;
+
+	// TODO: let the user chose the default value of ThresholdAdjuster::delay, for slow machines
+	delay = options.adjusterDelay;		// delay is no more static, so we can set the delay individually (useful for the RAW editor tab)
+
+	set_name("ThresholdAdjuster");
+
+	hbox = Gtk::manage (new Gtk::HBox ());
+
+	this->label = Gtk::manage (new Gtk::Label (label, Gtk::ALIGN_LEFT));
+
+	if (editedcb) {
+		editedCheckBox = Gtk::manage (new Gtk::CheckButton ());
+		editedChange = editedCheckBox->signal_toggled().connect( sigc::mem_fun(*this, &ThresholdAdjuster::editedToggled) );
+		hbox->pack_start (*editedCheckBox);
+	}
+	else
+		editedCheckBox = NULL;
+
+	hbox->pack_start (*this->label);
+
+	reset = Gtk::manage (new Gtk::Button ());
+	reset->add (*Gtk::manage (new RTImage ("gtk-undo-ltr-small.png", "gtk-undo-rtl-small.png")));
+	reset->set_relief (Gtk::RELIEF_NONE);
+	reset->set_border_width (0);
+	reset->set_tooltip_text (M("ADJUSTER_RESET_TO_DEFAULT"));
+
+	hbox->pack_end (*reset, Gtk::PACK_SHRINK, 0);
+
+	reset->set_size_request (-1, this->label->get_height() > MIN_RESET_BUTTON_HEIGHT ? this->label->get_height(): MIN_RESET_BUTTON_HEIGHT);
+
+	pack_start (*hbox, false, false);
+	pack_start (tSelector, false, false);
+
+	editedState = defEditedState = Irrelevant;
+
+	selectorChange = tSelector.signal_value_changed().connect( sigc::mem_fun(*this, &ThresholdAdjuster::selectorChanged) );
+	reset->signal_button_release_event().connect_notify( sigc::mem_fun(*this, &ThresholdAdjuster::resetPressed) );
+
+	show_all ();
+}
+
+ThresholdAdjuster::~ThresholdAdjuster () {
+
+	selectorChange.disconnect();
+	delayConnection.block(true);
+	adjusterListener = NULL;
+}
+
+void ThresholdAdjuster::setDefault (double bottom, double top) {
+
+	selectorChange.block (true);
+	tSelector.setPositions(shapeValue(bottom), shapeValue(top));
+	selectorChange.block (false);
+}
+
+void ThresholdAdjuster::setDefault (double bottomLeft, double topLeft, double bottomRight, double topRight) {
+
+	selectorChange.block (true);
+	tSelector.setPositions(shapeValue(bottomLeft), shapeValue(topLeft), shapeValue(bottomRight), shapeValue(topRight));
+	selectorChange.block (false);
+}
+
+void ThresholdAdjuster::setDefaultEditedState (EditedState eState) {
+
+	defEditedState = eState;
+}
+
+void ThresholdAdjuster::resetPressed (GdkEventButton* event) {
+
+	if (editedState!=Irrelevant) {
+		editedState = defEditedState;
+		if (editedCheckBox) {
+			editedChange.block (true);
+			editedCheckBox->set_active (defEditedState==Edited);
+			editedChange.block (false);
+		}
+		refreshLabelStyle ();
+	}
+	afterReset = true;
+	if ((event != NULL) && (event->state & GDK_CONTROL_MASK) && (event->button == 1))
+		// CTRL pressed : resetting to current default value
+		tSelector.reset();
+	else
+		// no modifier key or addMode=true : resetting to initial default value
+		tSelector.setPositions(initialDefaultVal[ThresholdSelector::TS_BOTTOMLEFT],
+		                       initialDefaultVal[ThresholdSelector::TS_TOPLEFT],
+		                       initialDefaultVal[ThresholdSelector::TS_BOTTOMRIGHT],
+		                       initialDefaultVal[ThresholdSelector::TS_TOPRIGHT]);
+}
+
+double ThresholdAdjuster::shapeValue (double a) {
+
+	unsigned int digit = tSelector.getPrecision();
+	return round(a*pow(double(10), digit)) / pow(double(10), digit);
+}
+
+void ThresholdAdjuster::selectorChanged () {
+
+	if (delayConnection.connected())
+		delayConnection.disconnect ();
+
+	if (delay==0) {
+		if (adjusterListener && !blocked)
+			sendToListener ();
+	}
+	else
+		delayConnection = Glib::signal_timeout().connect (sigc::mem_fun(*this, &ThresholdAdjuster::notifyListener), delay);
+
+	if (!afterReset && editedState==UnEdited) {
+		editedState = Edited;
+		if (editedCheckBox) {
+			editedChange.block (true);
+			editedCheckBox->set_active (true);
+			editedChange.block (false);
+		}
+		refreshLabelStyle ();
+	}
+	afterReset = false;
+}
+
+void ThresholdAdjuster::setValue (double bottom, double top) {
+
+	selectorChange.block (true);
+	tSelector.setPositions(bottom, top);
+	selectorChange.block (false);
+	afterReset = false;
+}
+
+void ThresholdAdjuster::setValue (double bottomLeft, double topLeft, double bottomRight, double topRight) {
+
+	selectorChange.block (true);
+	tSelector.setPositions(bottomLeft, topLeft, bottomRight, topRight);
+	selectorChange.block (false);
+	afterReset = false;
+}
+
+void ThresholdAdjuster::getValue (double& bottom, double& top) {
+	tSelector.getPositions<double> (bottom, top);
+}
+void ThresholdAdjuster::getValue (double& bottomLeft, double& topLeft, double& bottomRight, double& topRight) {
+	tSelector.getPositions<double> (bottomLeft, topLeft, bottomRight, topRight);
+}
+void ThresholdAdjuster::getValue (int& bottom, int& top) {
+	tSelector.getPositions<int> (bottom, top);
+}
+void ThresholdAdjuster::getValue (int& bottomLeft, int& topLeft, int& bottomRight, int& topRight) {
+	tSelector.getPositions<int> (bottomLeft, topLeft, bottomRight, topRight);
+}
+
+void ThresholdAdjuster::getValue (Glib::ustring& bottom, Glib::ustring& top) {
+	tSelector.getPositions (bottom, top);
+}
+
+void ThresholdAdjuster::getValue (Glib::ustring& bottomLeft, Glib::ustring& topLeft, Glib::ustring& bottomRight, Glib::ustring& topRight) {
+	tSelector.getPositions (bottomLeft, topLeft, bottomRight, topRight);
+}
+
+bool ThresholdAdjuster::notifyListener () {
+
+	if (adjusterListener!=NULL && !blocked) {
+		GThreadLock lock;
+		sendToListener();
+	}
+	return false;
+}
+
+void ThresholdAdjuster::setBgCurveProvider (ThresholdCurveProvider* provider) {
+	tSelector.setBgCurveProvider(provider);
+}
+
+
+void ThresholdAdjuster::setEnabled (bool enabled) {
+
+	tSelector.set_sensitive (enabled);
+}
+
+void ThresholdAdjuster::setEditedState (EditedState eState) {
+
+	if (editedState!=eState) {
+		if (editedCheckBox) {
+			editedChange.block (true);
+			editedCheckBox->set_active (eState==Edited);
+			editedChange.block (false);
+		}
+		editedState = eState;
+		refreshLabelStyle ();
+	}
+}
+
+EditedState ThresholdAdjuster::getEditedState () {
+
+	if (editedState!=Irrelevant && editedCheckBox)
+		editedState = editedCheckBox->get_active () ? Edited : UnEdited;
+	return editedState;
+}
+
+void ThresholdAdjuster::showEditedCB () {
+
+	if (!editedCheckBox) {
+		editedCheckBox =  Gtk::manage(new Gtk::CheckButton ());
+		hbox->pack_start (*editedCheckBox, Gtk::PACK_SHRINK, 2);
+		hbox->reorder_child (*editedCheckBox, 0);
+		editedChange = editedCheckBox->signal_toggled().connect( sigc::mem_fun(*this, &ThresholdAdjuster::editedToggled) );
+	}
+}
+
+void ThresholdAdjuster::refreshLabelStyle () {
+
+/*	Glib::RefPtr<Gtk::Style> style = label->get_style ();
+	Pango::FontDescription fd = style->get_font ();
+	fd.set_weight (editedState==Edited ? Pango::WEIGHT_BOLD : Pango::WEIGHT_NORMAL);
+	style->set_font (fd);
+	label->set_style (style);
+	label->queue_draw ();*/
+}
+
+void ThresholdAdjuster::editedToggled () {
+	
+	if (adjusterListener && !blocked)
+		sendToListener ();
+}
+
+void ThresholdAdjuster::sendToListener () {
+	if (tSelector.getPrecision() > 0) {
+		// if precision is >0, then we assume that the listener is waiting for doubles
+		rtengine::procparams::Threshold<double> t = tSelector.getPositions<double>();
+		if (tSelector.isDouble()){
+			adjusterListener->adjusterChanged (this, t.value[0], t.value[1], t.value[2], t.value[3]);
+			adjusterListener->adjusterChanged2 (this, t.value[0], t.value[1], t.value[2], t.value[3]);
+		}
+		else
+			adjusterListener->adjusterChanged (this, t.value[0], t.value[1]);
+	}
+	else {
+		// if precision is equal to 0, then we assume that the listener is waiting for integers
+		rtengine::procparams::Threshold<int> t = tSelector.getPositions<int>();
+		if (tSelector.isDouble()){
+			adjusterListener->adjusterChanged (this, t.value[0], t.value[1], t.value[2], t.value[3]);
+			adjusterListener->adjusterChanged2 (this, t.value[0], t.value[1], t.value[2], t.value[3]);
+		}
+		else
+			adjusterListener->adjusterChanged (this, t.value[0], t.value[1]);
+	}
+}
+
+void ThresholdAdjuster::set_tooltip_markup(const Glib::ustring& markup) {
+	tSelector.set_tooltip_markup(markup);
+}
+
+void ThresholdAdjuster::set_tooltip_text(const Glib::ustring& text) {
+	tSelector.set_tooltip_text(text);
+}
+
+/* For better readability, this method create the history string of the parameter column,
+ * so that the parameters list can be read in a more logical way (i.e. corresponding
+ * to the startAtOne field)
+ *
+ * If separatedMode==true, the top slider is assumed to be the primary slider, then the bottom slider as the second one
+ */
+Glib::ustring ThresholdAdjuster::getHistoryString () {
+	if (tSelector.isDouble()) {
+		Glib::ustring bl, tl, br, tr;
+		tSelector.getPositions(bl, tl, br, tr);
+		return Glib::ustring::compose(tSelector.isStartAtOne()?"%2, %1, %3, %4":"%1, %2, %4, %3", bl, tl, br, tr);
+	}
+	else {
+		Glib::ustring b, t;
+		tSelector.getPositions(b, t);
+		return Glib::ustring::compose(tSelector.isStartAtOne()||separatedMode?"%2, %1":"%1, %2", b, t);
+	}
+}