Issue 2134: removed obsolete raw highlight preservation setting from GUI (still left in procparams for backwards compatilibility)

2015-07-10 12:00:36 +02:00
commit d5ca351c20
1751 changed files with 441944 additions and 0 deletions
--- a/rtgui/adjuster.cc
+++ b/rtgui/adjuster.cc
@@ -0,0 +1,495 @@
+/*
+ *  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 "adjuster.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
+
+static double one2one(double val) { return val; }
+
+Adjuster::Adjuster (Glib::ustring vlabel, double vmin, double vmax, double vstep, double vdefault, Gtk::Image *imgIcon1, Gtk::Image *imgIcon2, double2double_fun slider2value_, double2double_fun value2slider_) {
+
+  Gtk::HBox *hbox2=NULL;
+  label = NULL;
+  adjusterListener = NULL;
+  afterReset = false;
+  blocked = false;
+  automatic = NULL;
+  eventPending = false;
+
+  slider2value = slider2value_ ? slider2value_ : one2one;
+  value2slider = value2slider_ ? value2slider_ : one2one;
+  vMin = vmin;
+  vMax = vmax;
+  vStep = vstep;
+  addMode = false;
+
+  // TODO: let the user chose the default value of Adjuster::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_border_width (0);
+  set_spacing (0);
+
+  hbox = Gtk::manage (new Gtk::HBox ());
+  hbox->set_border_width(0);
+  hbox->set_spacing(2);
+
+  editedCheckBox = NULL;
+
+  if (!vlabel.empty()) {
+    adjustmentName = vlabel;
+    label = Gtk::manage (new Gtk::Label (adjustmentName, Gtk::ALIGN_LEFT));
+  }
+
+  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"));
+  reset->set_can_focus(false);
+
+  spin = Gtk::manage (new MySpinButton ());
+  spin->set_has_frame(false);
+  spin->set_name("FramelessSpinButton");
+
+  reset->set_size_request (-1, spin->get_height() > MIN_RESET_BUTTON_HEIGHT ? spin->get_height(): MIN_RESET_BUTTON_HEIGHT);
+
+  slider = Gtk::manage (new MyHScale ());
+  slider->set_draw_value (false);
+
+  pack_start (*hbox, true, true);
+
+  if (vlabel.empty()) {
+    // No label, everything goes in hbox
+    if (imgIcon1) hbox->pack_start (*imgIcon1, Gtk::PACK_SHRINK, 0);
+    hbox->pack_start (*slider, Gtk::PACK_EXPAND_WIDGET, 0);
+    if (imgIcon2) hbox->pack_start (*imgIcon2, Gtk::PACK_SHRINK, 0);
+    hbox->pack_end (*reset, Gtk::PACK_SHRINK, 0); 
+    hbox->pack_end (*spin, Gtk::PACK_SHRINK, 0);
+  }
+  else {
+    // A label is provided, spreading the widgets in 2 rows
+    hbox->pack_start (*label);
+    hbox->pack_end (*reset, Gtk::PACK_SHRINK, 0);
+    hbox->pack_end (*spin, Gtk::PACK_SHRINK, 0);
+    if (!imgIcon1 || !imgIcon2) {
+      pack_start (*slider, true, true);
+    }
+    else {
+      // A second HBox is necessary
+      hbox2 = Gtk::manage (new Gtk::HBox());
+      if (imgIcon1) hbox2->pack_start (*imgIcon1, Gtk::PACK_SHRINK, 0);
+      hbox2->pack_start (*slider, true, true);
+      if (imgIcon2) hbox2->pack_start (*imgIcon2, Gtk::PACK_SHRINK, 0);
+      pack_start (*hbox2, true, true);
+    }
+  }
+
+  setLimits (vmin, vmax, vstep, vdefault);
+  
+  defaultVal = shapeValue (vdefault);
+  ctorDefaultVal = shapeValue (vdefault);
+  editedState = defEditedState = Irrelevant;
+  autoState = Irrelevant;
+
+  sliderChange = slider->signal_value_changed().connect( sigc::mem_fun(*this, &Adjuster::sliderChanged) );
+  spinChange = spin->signal_value_changed().connect ( sigc::mem_fun(*this, &Adjuster::spinChanged), true);
+  reset->signal_button_release_event().connect_notify( sigc::mem_fun(*this, &Adjuster::resetPressed) );
+  slider->set_update_policy (Gtk::UPDATE_CONTINUOUS);
+  
+  show_all ();
+}
+
+Adjuster::~Adjuster () {
+
+    sliderChange.block (true);
+    spinChange.block (true);
+    delayConnection.block (true);
+    adjusterListener = NULL;
+    if (automatic) delete automatic;
+}
+
+void Adjuster::addAutoButton (Glib::ustring tooltip) {
+    if (!automatic) {
+        automatic = new Gtk::CheckButton ();
+        //automatic->add (*Gtk::manage (new RTImage ("processing.png")));
+        automatic->set_border_width (0);
+        automatic->set_tooltip_markup(tooltip.length() ? Glib::ustring::compose("<b>%1</b>\n\n%2", M("GENERAL_AUTO"), tooltip) : M("GENERAL_AUTO"));
+        autoChange = automatic->signal_toggled().connect( sigc::mem_fun(*this, &Adjuster::autoToggled) );
+
+        hbox->pack_end (*automatic, Gtk::PACK_SHRINK, 0);
+        hbox->reorder_child (*automatic, 0);
+    }
+}
+
+void Adjuster::delAutoButton () {
+    if (automatic) {
+        removeIfThere(hbox, automatic);
+        delete automatic;
+        automatic = NULL;
+    }
+}
+
+void Adjuster::throwOnButtonRelease(bool throwOnBRelease) {
+
+    if (throwOnBRelease) {
+        if (!buttonReleaseSlider.connected())
+            buttonReleaseSlider = slider->signal_button_release_event().connect_notify( sigc::mem_fun(*this, &Adjuster::sliderReleased) );
+        if (!buttonReleaseSpin.connected())
+            buttonReleaseSpin = spin->signal_button_release_event().connect_notify( sigc::mem_fun(*this, &Adjuster::spinReleased) ); // Use the same callback hook
+    }
+    else {
+        if (buttonReleaseSlider.connected())
+            buttonReleaseSlider.disconnect();
+        if (buttonReleaseSpin.connected())
+            buttonReleaseSpin.disconnect();
+    }
+    eventPending = false;
+}
+
+void Adjuster::setDefault (double def) {
+
+    defaultVal = shapeValue (def);
+}
+
+void Adjuster::setDefaultEditedState (EditedState eState) {
+
+    defEditedState = eState;
+}
+
+void Adjuster::autoToggled () {
+
+    if (!editedCheckBox) {
+        // If not used in the BatchEditor panel
+        if (automatic->get_active()) {
+            // Disable the slider and spin button
+            spin->set_sensitive(false);
+            slider->set_sensitive(false);
+        }
+        else {
+            // Enable the slider and spin button
+            spin->set_sensitive(true);
+            slider->set_sensitive(true);
+        }
+    }
+
+    if (adjusterListener!=NULL && !blocked) {
+        adjusterListener->adjusterAutoToggled(this, automatic->get_active());
+    }
+}
+
+void Adjuster::sliderReleased (GdkEventButton* event) {
+
+    if ((event != NULL) && (event->button == 1)) {
+        if (delayConnection.connected())
+            delayConnection.disconnect ();
+        notifyListener();
+    }
+}
+
+void Adjuster::spinReleased (GdkEventButton* event) {
+
+    if ((event != NULL) && delay==0) {
+        if (delayConnection.connected())
+            delayConnection.disconnect ();
+        notifyListener();
+    }
+}
+
+void Adjuster::resetValue (bool toInitial) {
+    if (editedState!=Irrelevant) {
+        editedState = defEditedState;
+        if (editedCheckBox) {
+            editedChange.block (true);
+            editedCheckBox->set_active (defEditedState==Edited);
+            editedChange.block (false);
+        }
+        refreshLabelStyle ();
+    }
+    afterReset = true;
+    if (toInitial) {
+        // resetting to the initial editing value, when the image has been loaded
+	slider->set_value (addMode ? defaultVal : value2slider(defaultVal));
+    }
+    else {
+        // resetting to the slider default value
+        if (addMode)
+            slider->set_value (0.);
+        else
+            slider->set_value (value2slider(ctorDefaultVal));
+    }
+}
+
+// Please note that it won't change the "Auto" CheckBox's state, if there
+void Adjuster::resetPressed (GdkEventButton* event) {
+
+    if ((event != NULL) && (event->state & GDK_CONTROL_MASK) && (event->button == 1))
+        resetValue(true);
+    else
+        resetValue(false);
+}
+
+double Adjuster::shapeValue (double a) {
+
+  return round(a*pow(double(10), digits)) / pow(double(10), digits);
+}
+
+void Adjuster::setLimits (double vmin, double vmax, double vstep, double vdefault) {
+
+  sliderChange.block (true);
+  spinChange.block (true);
+  for (digits=0; fabs(vstep*pow(double(10),digits)-floor(vstep*pow(double(10),digits)))>0.000000000001; digits++);
+  spin->set_digits (digits);
+  spin->set_increments (vstep, 2.0*vstep);
+  spin->set_range (vmin, vmax);
+  spin->updateSize();
+  spin->set_value (shapeValue(vdefault));
+  slider->set_digits (digits);
+  slider->set_increments (vstep, 2.0*vstep);
+  slider->set_range (addMode ? vmin : value2slider(vmin), addMode ? vmax : value2slider(vmax));
+  slider->set_value (addMode ? shapeValue(vdefault) : value2slider(shapeValue(vdefault)));
+  //defaultVal = shapeValue (vdefault);
+  sliderChange.block (false);
+  spinChange.block (false);
+}
+
+void Adjuster::setAddMode(bool addM) {
+	if (addM != addMode) {
+		// Switching the Adjuster to the new mode
+		addMode = addM;
+		if (addM) {
+			// Switching to the relative mode
+			double range = -vMin + vMax;
+			if (range < 0.) range = -range;
+			setLimits(-range, range, vStep, 0);
+		}
+		else {
+			// Switching to the absolute mode
+			setLimits(vMin, vMax, vStep, defaultVal);
+		}
+	}
+}
+
+void Adjuster::spinChanged () {
+
+  if (delayConnection.connected())
+    delayConnection.disconnect ();
+
+  sliderChange.block (true);
+  slider->set_value (addMode ? spin->get_value () : value2slider(spin->get_value ()));
+  sliderChange.block (false);
+
+  if (delay==0) {
+    if (adjusterListener && !blocked) {
+        if (!buttonReleaseSlider.connected() || afterReset) {
+            eventPending = false;
+            adjusterListener->adjusterChanged (this, spin->get_value ());
+        }
+        else eventPending = true;
+    }
+  }
+  else {
+    eventPending = true;
+    delayConnection = Glib::signal_timeout().connect (sigc::mem_fun(*this, &Adjuster::notifyListener), delay);
+  }
+
+  if (editedState==UnEdited) {
+    editedState = Edited;
+    if (editedCheckBox) {
+        editedChange.block (true);
+        editedCheckBox->set_active (true);
+        editedChange.block (false);
+    }
+    refreshLabelStyle ();
+  }
+  afterReset = false;
+}
+
+void Adjuster::sliderChanged () {
+  
+  if (delayConnection.connected())
+    delayConnection.disconnect ();
+
+  spinChange.block (true);
+  spin->set_value (addMode ? slider->get_value () : slider2value(slider->get_value ()));
+  spinChange.block (false);
+
+  if (delay==0 || afterReset) {
+    if (adjusterListener && !blocked) {
+      if (!buttonReleaseSlider.connected() || afterReset) {
+        eventPending = false;
+        adjusterListener->adjusterChanged (this, spin->get_value ());
+      }
+      else eventPending = true;
+    }
+  }
+  else {
+    eventPending = true;
+    delayConnection = Glib::signal_timeout().connect (sigc::mem_fun(*this, &Adjuster::notifyListener), delay);
+  }
+
+  if (!afterReset && editedState==UnEdited) {
+    editedState = Edited;
+    if (editedCheckBox) {
+        editedChange.block (true);
+        editedCheckBox->set_active (true);
+        editedChange.block (false);
+    }
+    refreshLabelStyle ();
+  }
+  afterReset = false;
+}
+
+void Adjuster::setValue (double a) {
+
+  spinChange.block (true);
+  sliderChange.block (true);
+  spin->set_value (shapeValue (a));
+  slider->set_value (addMode ? shapeValue(a) : value2slider(shapeValue (a)));
+  sliderChange.block (false);
+  spinChange.block (false);
+  afterReset = false;
+}
+
+void Adjuster::setAutoValue (bool a) {
+    if (automatic) {
+        bool oldVal = autoChange.block(true);
+        automatic->set_active(a);
+        autoChange.block(oldVal);
+        if (!editedCheckBox) {
+            // If not used in the BatchEditor panel
+            if (a) {
+                // Disable the slider and spin button
+                spin->set_sensitive(false);
+                slider->set_sensitive(false);
+            }
+            else {
+                // Enable the slider and spin button
+                spin->set_sensitive(true);
+                slider->set_sensitive(true);
+            }
+        }
+    }
+}
+
+bool Adjuster::notifyListener () {
+
+  if (eventPending && adjusterListener!=NULL && !blocked) {
+    adjusterListener->adjusterChanged (this, spin->get_value ());
+  }
+  eventPending = false;
+
+  return false;
+}
+
+bool Adjuster::notifyListenerAutoToggled () {
+
+  if (adjusterListener!=NULL && !blocked) {
+    adjusterListener->adjusterAutoToggled(this, automatic->get_active());
+  }
+  return false;
+}
+
+void Adjuster::setEnabled (bool enabled) {
+
+    bool autoVal = automatic && !editedCheckBox ? automatic->get_active() : true;
+    spin->set_sensitive (enabled && autoVal);
+    slider->set_sensitive (enabled && autoVal);
+    if (automatic)
+        automatic->set_sensitive (enabled);
+}
+
+void Adjuster::setEditedState (EditedState eState) {
+
+    if (editedState!=eState) {
+        if (editedCheckBox) {
+            editedChange.block (true);
+            editedCheckBox->set_active (eState==Edited);
+            editedChange.block (false);
+        }
+        editedState = eState;
+        refreshLabelStyle ();
+    }
+}
+
+EditedState Adjuster::getEditedState () {
+
+    if (editedState!=Irrelevant && editedCheckBox)
+        editedState = editedCheckBox->get_active () ? Edited : UnEdited;
+    return editedState;
+}
+
+void Adjuster::showEditedCB () {
+
+    if (label)
+        removeIfThere(hbox, label, false);
+
+    if (!editedCheckBox) {
+        editedCheckBox = Gtk::manage(new Gtk::CheckButton (adjustmentName));
+        hbox->pack_start (*editedCheckBox, Gtk::PACK_SHRINK, 2);
+        hbox->reorder_child (*editedCheckBox, 0);
+        editedChange = editedCheckBox->signal_toggled().connect( sigc::mem_fun(*this, &Adjuster::editedToggled) );
+        editedCheckBox->show();
+    }
+}
+
+void Adjuster::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 Adjuster::editedToggled () {
+
+    if (adjusterListener && !blocked) {
+        adjusterListener->adjusterChanged (this, spin->get_value ());
+    }
+    eventPending = false;
+}
+
+double Adjuster::trimValue (double val) {
+
+    if      (val > vMax) val = vMax;  // shapeValue(vMax) ?
+    else if (val < vMin) val = vMin;  // shapeValue(vMin) ?
+    return val;
+}
+
+int Adjuster::trimValue (int val) {
+
+    if      (val > (int)vMax) val = (int)vMax;  // shapeValue(vMax) ?
+    else if (val < (int)vMin) val = (int)vMin;  // shapeValue(vMin) ?
+    return val;
+}
+
+float Adjuster::trimValue (float val) {
+
+    if      (val > (float)vMax) val = (float)vMax;  // shapeValue(vMax) ?
+    else if (val < (float)vMin) val = (float)vMin;  // shapeValue(vMin) ?
+    return val;
+}