rtgui/colorboost.cc

   1 /*
   2  *  This file is part of RawTherapee.
   3  *
   4  *  Copyright (c) 2004-2010 Gabor Horvath <hgabor@rawtherapee.com>
   5  *
   6  *  RawTherapee is free software: you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation, either version 3 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  RawTherapee is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with RawTherapee.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19 #include <colorboost.h>
  20 #include <iomanip>
  21 #include <guiutils.h>
  22
  23 using namespace rtengine;
  24 using namespace rtengine::procparams;
  25
  26 ColorBoost::ColorBoost () : ToolPanel(), cbAdd(false) {
  27
  28   colorboost = new Adjuster (M("TP_COLORBOOST_AMOUNT"), -100, 300, 1, 0);
  29
  30   pack_start (*colorboost);
  31   pack_start (*Gtk::manage (new  Gtk::HSeparator()));
  32
  33   avoidclip = Gtk::manage (new Gtk::CheckButton (M("TP_COLORBOOST_AVOIDCOLORCLIP")));
  34
  35   pack_start (*avoidclip);
  36   pack_start (*Gtk::manage (new  Gtk::HSeparator()));
  37
  38   enablelimiter = Gtk::manage (new Gtk::CheckButton (M("TP_COLORBOOST_ENABLESATLIMITER")));
  39   pack_start (*enablelimiter);
  40
  41   saturationlimiter = new Adjuster (M("TP_COLORBOOST_SATLIMIT"), 0, 200, 0.1, 100);
  42   saturationlimiter->show ();
  43   saturationlimiter->reference ();
  44
  45   colorboost->setAdjusterListener (this);
  46   saturationlimiter->setAdjusterListener (this);
  47   acconn = avoidclip->signal_toggled().connect( sigc::mem_fun(*this, &ColorBoost::avoidclip_toggled) );
  48   elconn = enablelimiter->signal_toggled().connect( sigc::mem_fun(*this, &ColorBoost::enablelimiter_toggled) );
  49
  50   show_all_children ();
  51 }
  52
  53 ColorBoost::~ColorBoost () {
  54
  55     delete saturationlimiter;
  56 }
  57
  58 void ColorBoost::read (const ProcParams* pp, const ParamsEdited* pedited) {
  59
  60     disableListener ();
  61
  62     if (pedited) {
  63         colorboost->setEditedState (pedited->colorBoost.amount ? Edited : UnEdited);
  64         saturationlimiter->setEditedState (pedited->colorBoost.saturationlimit ? Edited : UnEdited);
  65         avoidclip->set_inconsistent (!pedited->colorBoost.avoidclip);
  66         enablelimiter->set_inconsistent (!pedited->colorBoost.enable_saturationlimiter);
  67     }
  68
  69     colorboost->setValue (pp->colorBoost.amount);
  70     saturationlimiter->setValue (pp->colorBoost.saturationlimit);
  71     acconn.block (true);
  72     avoidclip->set_active (pp->colorBoost.avoidclip);
  73     acconn.block (false);
  74     elconn.block (true);
  75     enablelimiter->set_active (pp->colorBoost.enable_saturationlimiter);
  76     elconn.block (false);
  77
  78     removeIfThere (this, saturationlimiter, false);
  79     if (enablelimiter->get_active () || enablelimiter->get_inconsistent())
  80         pack_start (*saturationlimiter);
  81
  82     lastACVal = pp->colorBoost.avoidclip;
  83     lastELVal = pp->colorBoost.enable_saturationlimiter;
  84
  85     enableListener ();
  86 }
  87
  88 void ColorBoost::write (ProcParams* pp, ParamsEdited* pedited) {
  89
  90     pp->colorBoost.amount = (int)colorboost->getValue();
  91     pp->colorBoost.avoidclip = avoidclip->get_active ();
  92     pp->colorBoost.enable_saturationlimiter = enablelimiter->get_active ();
  93     pp->colorBoost.saturationlimit = saturationlimiter->getValue ();
  94
  95     if (pedited) {
  96         pedited->colorBoost.amount = colorboost->getEditedState ();
  97         pedited->colorBoost.avoidclip = !avoidclip->get_inconsistent();
  98         pedited->colorBoost.enable_saturationlimiter = !enablelimiter->get_inconsistent();
  99         pedited->colorBoost.saturationlimit = saturationlimiter->getEditedState ();
 100     }
 101 }
 102
 103 void ColorBoost::setDefaults (const ProcParams* defParams, const ParamsEdited* pedited) {
 104
 105     colorboost->setDefault (defParams->colorBoost.amount);
 106     saturationlimiter->setDefault (defParams->colorBoost.saturationlimit);
 107
 108     if (pedited) {
 109         colorboost->setDefaultEditedState (pedited->colorBoost.amount ? Edited : UnEdited);
 110         saturationlimiter->setDefaultEditedState (pedited->colorBoost.saturationlimit ? Edited : UnEdited);
 111     }
 112     else {
 113         colorboost->setDefaultEditedState (Irrelevant);
 114         saturationlimiter->setDefaultEditedState (Irrelevant);
 115     }
 116 }
 117
 118 void ColorBoost::avoidclip_toggled () {
 119
 120     if (batchMode) {
 121         if (avoidclip->get_inconsistent()) {
 122             avoidclip->set_inconsistent (false);
 123             acconn.block (true);
 124             avoidclip->set_active (false);
 125             acconn.block (false);
 126         }
 127         else if (lastACVal)
 128             avoidclip->set_inconsistent (true);
 129
 130         lastACVal = avoidclip->get_active ();
 131     }
 132
 133     if (listener) {
 134         if (avoidclip->get_active ())
 135             listener->panelChanged (EvCBAvoidClip, M("GENERAL_ENABLED"));
 136         else
 137             listener->panelChanged (EvCBAvoidClip, M("GENERAL_DISABLED"));
 138     }
 139 }
 140
 141 void ColorBoost::enablelimiter_toggled () {
 142
 143     if (batchMode) {
 144         if (enablelimiter->get_inconsistent()) {
 145             enablelimiter->set_inconsistent (false);
 146             elconn.block (true);
 147             enablelimiter->set_active (false);
 148             elconn.block (false);
 149         }
 150         else if (lastELVal)
 151             enablelimiter->set_inconsistent (true);
 152
 153         lastELVal = enablelimiter->get_active ();
 154     }
 155
 156     removeIfThere (this, saturationlimiter, false);
 157     if (enablelimiter->get_active () || enablelimiter->get_inconsistent())
 158         pack_start (*saturationlimiter);
 159
 160     if (listener) {
 161         if (enablelimiter->get_active ())
 162             listener->panelChanged (EvCBSatLimiter, M("GENERAL_ENABLED"));
 163         else
 164             listener->panelChanged (EvCBSatLimiter, M("GENERAL_DISABLED"));
 165     }
 166 }
 167
 168 void ColorBoost::adjusterChanged (Adjuster* a, double newval) {
 169
 170     if (listener) {
 171         if (a!=saturationlimiter)
 172             listener->panelChanged (EvCBBoost, Glib::ustring::format ((int)a->getValue()));
 173         else
 174             listener->panelChanged (EvCBSatLimit, Glib::ustring::format (std::setw(2), std::fixed, std::setprecision(1), a->getValue()));
 175     }
 176 }
 177
 178 void ColorBoost::setAdjusterBehavior (bool bcbadd) {
 179
 180     if (!cbAdd && bcbadd || cbAdd && !bcbadd)
 181         colorboost->setLimits (-100, 100, 1, 0);
 182
 183     cbAdd = bcbadd;
 184 }
 185
 186 void ColorBoost::setBatchMode (bool batchMode) {
 187
 188     ToolPanel::setBatchMode (batchMode);
 189     colorboost->showEditedCB ();
 190     saturationlimiter->showEditedCB ();
 191 }