liz/rawTherapee
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Normalized RAW tab and enhanced slider behaviour for the RAW tab

Browse Source
This commit is contained in:
Hombre
2011-02-16 02:33:49 +01:00
parent a8a350bba4
commit 4d1936e008
46 changed files with 1270 additions and 789 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
rtgui/CMakeLists.txt
View File

@@ -26,6 +26,7 @@ set (BASESOURCEFILES
batchqueue.cc lwbutton.cc lwbuttonset.cc
batchqueuebuttonset.cc browserfilter.cc exiffiltersettings.cc
profilestore.cc partialpastedlg.cc rawprocess.cc preprocess.cc
darkframe.cc flatfield.cc rawcacorrection.cc rawexposure.cc
equalizer.cc dirpyrequalizer.cc hsvequalizer.cc defringe.cc
popupcommon.cc popupbutton.cc popuptogglebutton.cc)

16
rtgui/adjuster.cc
View File

@@ -21,17 +21,19 @@
#include <math.h>
#include <multilangmgr.h>
#include <rtengine.h>
#include <options.h>
extern Glib::ustring argv0;
int Adjuster::delay = 1000;
Adjuster::Adjuster (Glib::ustring vlabel, double vmin, double vmax, double vstep, double vdefault, bool editedcb) {
adjusterListener = NULL;
afterReset = false;
blocked = 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 (usefull for the RAW editor tab)
set_border_width (2);
hbox = Gtk::manage (new Gtk::HBox ());
@@ -212,6 +214,16 @@ double Adjuster::getValue () {
return spin->get_value ();
}
int Adjuster::getIntValue () {
return spin->get_value_as_int ();
}
Glib::ustring Adjuster::getTextValue () {
return spin->get_text ();
}
bool Adjuster::notifyListener () {
if (adjusterListener!=NULL && !blocked) {

4
rtgui/adjuster.h
View File

@@ -57,13 +57,15 @@ class Adjuster : public Gtk::VBox {
public:
static int delay;
int delay;
Adjuster (Glib::ustring label, double vmin, double vmax, double vstep, double vdefault, bool editedCheckBox=false);
virtual ~Adjuster ();
void setAdjusterListener (AdjusterListener* alistener);
double getValue ();
int getIntValue ();
Glib::ustring getTextValue ();
void setValue (double a);
void setLimits (double vmin, double vmax, double vstep, double vdefault);
void setEnabled (bool enabled);

148
rtgui/darkframe.cc Normal file
View File

@@ -0,0 +1,148 @@
/*
* 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 <darkframe.h>
#include <options.h>
#include <guiutils.h>
#include <safegtk.h>
#include <sstream>
using namespace rtengine;
using namespace rtengine::procparams;
DarkFrame::DarkFrame () : Gtk::VBox(), FoldableToolPanel(this)
{
hbdf = Gtk::manage(new Gtk::HBox());
darkFrameFile = Gtk::manage(new Gtk::FileChooserButton(M("TP_DARKFRAME_LABEL"), Gtk::FILE_CHOOSER_ACTION_OPEN));
dfLabel = Gtk::manage(new Gtk::Label(M("GENERAL_FILE")));
btnReset = Gtk::manage(new Gtk::Button());
btnReset->set_image (*Gtk::manage(new Gtk::Image (Gtk::StockID("gtk-cancel"), Gtk::ICON_SIZE_BUTTON)));
hbdf->pack_start(*dfLabel, Gtk::PACK_SHRINK, 4);
hbdf->pack_start(*darkFrameFile);
hbdf->pack_start(*btnReset, Gtk::PACK_SHRINK, 4);
dfAuto = Gtk::manage(new Gtk::CheckButton((M("TP_DARKFRAME_AUTOSELECT"))));
dfInfo = Gtk::manage(new Gtk::Label(""));
dfInfo->set_alignment(0,0); //left align
pack_start( *hbdf, Gtk::PACK_SHRINK, 4);
pack_start( *dfAuto, Gtk::PACK_SHRINK, 4);
pack_start( *dfInfo, Gtk::PACK_SHRINK, 4);
dfautoconn = dfAuto->signal_toggled().connect ( sigc::mem_fun(*this, &DarkFrame::dfAutoChanged), true);
dfFile = darkFrameFile->signal_file_set().connect ( sigc::mem_fun(*this, &DarkFrame::darkFrameChanged), true);
btnReset->signal_clicked().connect( sigc::mem_fun(*this, &DarkFrame::darkFrameReset), true );
}
void DarkFrame::read(const rtengine::procparams::ProcParams* pp, const ParamsEdited* pedited)
{
disableListener ();
dfautoconn.block(true);
if(pedited ){
dfAuto->set_inconsistent(!pedited->raw.dfAuto );
}
if (safe_file_test (pp->raw.dark_frame, Glib::FILE_TEST_EXISTS))
darkFrameFile->set_filename (pp->raw.dark_frame);
else if( !options.rtSettings.darkFramesPath.empty() )
darkFrameFile->set_current_folder( options.rtSettings.darkFramesPath );
hbdf->set_sensitive( !pp->raw.df_autoselect );
lastDFauto = pp->raw.df_autoselect;
if( pp->raw.df_autoselect && dfp && !batchMode){
// retrieve the auto-selected df filename
rtengine::RawImage *img = dfp->getDF();
if( img ){
dfInfo->set_text( Glib::ustring::compose("%1: %2ISO %3s", Glib::path_get_basename(img->get_filename()), img->get_ISOspeed(), img->get_shutter()) );
}else{
dfInfo->set_text(Glib::ustring(M("TP_PREPROCESS_NO_FOUND")));
}
}
else dfInfo->set_text("");
dfAuto->set_active( pp->raw.df_autoselect );
dfChanged = false;
dfautoconn.block(false);
enableListener ();
}
void DarkFrame::write( rtengine::procparams::ProcParams* pp, ParamsEdited* pedited)
{
pp->raw.dark_frame = darkFrameFile->get_filename();
pp->raw.df_autoselect = dfAuto->get_active();
if (pedited) {
pedited->raw.darkFrame = dfChanged;
pedited->raw.dfAuto = !dfAuto->get_inconsistent();
}
}
void DarkFrame::dfAutoChanged()
{
if (batchMode) {
if (dfAuto->get_inconsistent()) {
dfAuto->set_inconsistent (false);
dfautoconn.block (true);
dfAuto->set_active (false);
dfautoconn.block (false);
}
else if (lastDFauto)
dfAuto->set_inconsistent (true);
lastDFauto = dfAuto->get_active ();
}
if(dfAuto->get_active() && dfp && !batchMode){
// retrieve the auto-selected df filename
rtengine::RawImage *img = dfp->getDF();
if( img ){
dfInfo->set_text( Glib::ustring::compose("%1: %2ISO %3s", Glib::path_get_basename(img->get_filename()), img->get_ISOspeed(), img->get_shutter()) );
}else{
dfInfo->set_text(Glib::ustring(M("TP_PREPROCESS_NO_FOUND")));
}
}
else{dfInfo->set_text("");}
hbdf->set_sensitive( !dfAuto->get_active() );
if (listener)
listener->panelChanged (EvPreProcessAutoDF, dfAuto->get_active()?M("GENERAL_ENABLED"):M("GENERAL_DISABLED"));
}
void DarkFrame::darkFrameChanged()
{
dfChanged=true;
if (listener)
listener->panelChanged (EvPreProcessDFFile, Glib::path_get_basename(darkFrameFile->get_filename()));
}
void DarkFrame::darkFrameReset()
{
dfChanged=true;
//darkFrameFile->set_current_name("");
darkFrameFile->set_filename ("");
if( !options.rtSettings.darkFramesPath.empty() )
darkFrameFile->set_current_folder( options.rtSettings.darkFramesPath );
dfInfo->set_text("");
if (listener)
listener->panelChanged (EvPreProcessDFFile, M("GENERAL_NONE"));
}

61
rtgui/darkframe.h Normal file
View File

@@ -0,0 +1,61 @@
/*
* 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/>.
*/
#ifndef _DARKFRAME_H_
#define _DARKFRAME_H_
#include <gtkmm.h>
#include <toolpanel.h>
#include <rawimage.h>
class DFProvider {
public:
virtual rtengine::RawImage* getDF() {}
// add other info here
};
class DarkFrame : public Gtk::VBox, public FoldableToolPanel {
protected:
Gtk::ComboBoxText* darkFrameMethod;
Gtk::FileChooserButton *darkFrameFile;
Gtk::HBox *hbdf;
Gtk::Button *btnReset;
Gtk::Label *dfLabel;
Gtk::Label *dfInfo;
Gtk::CheckButton* dfAuto;
bool dfChanged;
bool lastDFauto;
DFProvider *dfp;
sigc::connection dfautoconn, dfFile;
public:
DarkFrame ();
void read (const rtengine::procparams::ProcParams* pp, const ParamsEdited* pedited=NULL);
void write (rtengine::procparams::ProcParams* pp, ParamsEdited* pedited=NULL);
void darkFrameChanged ();
void darkFrameReset ();
void dfAutoChanged ();
void setDFProvider (DFProvider* p) { dfp = p; };
};
#endif

228
rtgui/flatfield.cc Normal file
View File

@@ -0,0 +1,228 @@
/*
* 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 <flatfield.h>
#include <options.h>
#include <guiutils.h>
#include <safegtk.h>
#include <sstream>
using namespace rtengine;
using namespace rtengine::procparams;
FlatField::FlatField () : Gtk::VBox(), FoldableToolPanel(this)
{
hbff = Gtk::manage(new Gtk::HBox());
flatFieldFile = Gtk::manage(new Gtk::FileChooserButton(M("TP_FLATFIELD_LABEL"), Gtk::FILE_CHOOSER_ACTION_OPEN));
ffLabel = Gtk::manage(new Gtk::Label(M("GENERAL_FILE")));
flatFieldFileReset = Gtk::manage(new Gtk::Button());
flatFieldFileReset->set_image (*Gtk::manage(new Gtk::Image (Gtk::StockID("gtk-cancel"), Gtk::ICON_SIZE_BUTTON)));
hbff->pack_start(*ffLabel, Gtk::PACK_SHRINK, 4);
hbff->pack_start(*flatFieldFile);
hbff->pack_start(*flatFieldFileReset, Gtk::PACK_SHRINK, 4);
flatFieldAutoSelect = Gtk::manage(new Gtk::CheckButton((M("TP_FLATFIELD_AUTOSELECT"))));
ffInfo = Gtk::manage(new Gtk::Label(""));
ffInfo->set_alignment(0,0); //left align
flatFieldBlurRadius = Gtk::manage(new Adjuster (M("TP_FLATFIELD_BLURRADIUS"),0,200,2,32));
flatFieldBlurRadius->setAdjusterListener (this);
if (flatFieldBlurRadius->delay < 1000) flatFieldBlurRadius->delay = 1000;
flatFieldBlurRadius->show();
Gtk::HBox* hbffbt = Gtk::manage (new Gtk::HBox ());
hbffbt->pack_start (*Gtk::manage (new Gtk::Label ( M("TP_FLATFIELD_BLURTYPE") +": ")));
flatFieldBlurType = Gtk::manage (new Gtk::ComboBoxText ());
flatFieldBlurType->append_text(M("TP_FLATFIELD_BT_AREA"));
flatFieldBlurType->append_text(M("TP_FLATFIELD_BT_VERTICAL"));
flatFieldBlurType->append_text(M("TP_FLATFIELD_BT_HORIZONTAL"));
flatFieldBlurType->append_text(M("TP_FLATFIELD_BT_VERTHORIZ"));
flatFieldBlurType->set_active(0);
hbffbt->pack_end (*flatFieldBlurType);
pack_start( *hbff, Gtk::PACK_SHRINK, 4);
pack_start( *flatFieldAutoSelect, Gtk::PACK_SHRINK, 4);
pack_start( *ffInfo, Gtk::PACK_SHRINK, 4);
pack_start( *hbffbt, Gtk::PACK_SHRINK, 4);
pack_start( *flatFieldBlurRadius, Gtk::PACK_SHRINK, 4);
flatFieldFileconn = flatFieldFile->signal_file_set().connect ( sigc::mem_fun(*this, &FlatField::flatFieldFileChanged), true);
flatFieldFileReset->signal_clicked().connect( sigc::mem_fun(*this, &FlatField::flatFieldFile_Reset), true );
flatFieldAutoSelectconn = flatFieldAutoSelect->signal_toggled().connect ( sigc::mem_fun(*this, &FlatField::flatFieldAutoSelectChanged), true);
flatFieldBlurTypeconn = flatFieldBlurType->signal_changed().connect( sigc::mem_fun(*this, &FlatField::flatFieldBlurTypeChanged) );
}
void FlatField::read(const rtengine::procparams::ProcParams* pp, const ParamsEdited* pedited)
{
disableListener ();
flatFieldAutoSelectconn.block (true);
flatFieldBlurTypeconn.block (true);
if(pedited ){
flatFieldAutoSelect->set_inconsistent (!pedited->raw.ff_AutoSelect);
flatFieldBlurRadius->setEditedState( pedited->raw.ff_BlurRadius ? Edited : UnEdited );
if( !pedited->raw.ff_BlurType )
flatFieldBlurType->set_active(procparams::RAWParams::numFlatFileBlurTypes); // No name
}
if (safe_file_test (pp->raw.ff_file, Glib::FILE_TEST_EXISTS))
flatFieldFile->set_filename (pp->raw.ff_file);
else if( !options.rtSettings.flatFieldsPath.empty() )
flatFieldFile->set_current_folder( options.rtSettings.flatFieldsPath );
hbff->set_sensitive( !pp->raw.ff_AutoSelect );
lastFFAutoSelect = pp->raw.ff_AutoSelect;
if( pp->raw.ff_AutoSelect && ffp && !batchMode){
// retrieve the auto-selected ff filename
rtengine::RawImage *img = ffp->getFF();
if( img ){
ffInfo->set_text( Glib::ustring::compose("%1: f/%2", Glib::path_get_basename(img->get_filename()), img->get_aperture()) ); // !!! need to add focallength in mm and format aperture to ##.#
}else{
ffInfo->set_text(Glib::ustring(M("TP_PREPROCESS_NO_FOUND")));
}
}
else ffInfo->set_text("");
flatFieldAutoSelect ->set_active(pp->raw.ff_AutoSelect);
flatFieldBlurRadius->setValue (pp->raw.ff_BlurRadius);
flatFieldBlurType->set_active(procparams::RAWParams::numFlatFileBlurTypes);
//flatFieldBlurType
for( size_t i=0; i< procparams::RAWParams::numFlatFileBlurTypes;i++)
if( pp->raw.ff_BlurType == procparams::RAWParams::ff_BlurTypestring[i]){
flatFieldBlurType->set_active(i);
break;
}
flatFieldAutoSelect->set_active (pp->raw.ff_AutoSelect);
flatFieldBlurRadius->setValue (pp->raw.ff_BlurRadius);
ffChanged = false;
flatFieldAutoSelectconn.block (false);
flatFieldBlurTypeconn.block (false);
enableListener ();
}
void FlatField::write( rtengine::procparams::ProcParams* pp, ParamsEdited* pedited)
{
pp->raw.ff_file = flatFieldFile->get_filename();
pp->raw.ff_AutoSelect = flatFieldAutoSelect->get_active();
pp->raw.ff_BlurRadius = flatFieldBlurRadius->getIntValue();
int currentRow = flatFieldBlurType->get_active_row_number();
if( currentRow>=0 && currentRow < procparams::RAWParams::numFlatFileBlurTypes)
pp->raw.ff_BlurType = procparams::RAWParams::ff_BlurTypestring[currentRow];
if (pedited) {
pedited->raw.ff_file = ffChanged;
pedited->raw.ff_AutoSelect = !flatFieldAutoSelect->get_inconsistent();
pedited->raw.ff_BlurRadius = flatFieldBlurRadius->getEditedState ();
pedited->raw.ff_BlurType = flatFieldBlurType->get_active_row_number() != procparams::RAWParams::numFlatFileBlurTypes;
}
}
void FlatField::adjusterChanged (Adjuster* a, double newval)
{
if (listener) {
Glib::ustring value = a->getTextValue();
listener->panelChanged (EvFlatFieldBlurRadius, value );
}
}
void FlatField::setBatchMode(bool batchMode)
{
ToolPanel::setBatchMode (batchMode);
flatFieldBlurRadius->showEditedCB ();
}
void FlatField::setDefaults(const rtengine::procparams::ProcParams* defParams, const ParamsEdited* pedited)
{
flatFieldBlurRadius->setDefault( defParams->raw.ff_BlurRadius);
if (pedited) {
flatFieldBlurRadius->setDefaultEditedState( pedited->raw.ff_BlurRadius ? Edited : UnEdited);
} else {
flatFieldBlurRadius->setDefaultEditedState( Irrelevant );
}
}
void FlatField::flatFieldFileChanged()
{
ffChanged=true;
if (listener)
listener->panelChanged (EvFlatFieldFile, Glib::path_get_basename(flatFieldFile->get_filename()));
}
void FlatField::flatFieldFile_Reset()
{
ffChanged=true;
//flatFieldFile->set_current_name("");
flatFieldFile->set_filename ("");
if( !options.rtSettings.flatFieldsPath.empty() )
flatFieldFile->set_current_folder( options.rtSettings.flatFieldsPath );
ffInfo->set_text("");
if (listener)
listener->panelChanged (EvFlatFieldFile, M("GENERAL_NONE") );
}
void FlatField::flatFieldBlurTypeChanged ()
{
int curSelection = flatFieldBlurType->get_active_row_number();
Glib::ustring s="";
if( curSelection>=0 && curSelection < procparams::RAWParams::numFlatFileBlurTypes)
s = flatFieldBlurType->get_active_text();
if (listener)
listener->panelChanged (EvFlatFieldBlurType, s);
}
void FlatField::flatFieldAutoSelectChanged()
{
if (batchMode) {
if (flatFieldAutoSelect->get_inconsistent()) {
flatFieldAutoSelect->set_inconsistent (false);
flatFieldAutoSelectconn.block (true);
flatFieldAutoSelect->set_active (false);
flatFieldAutoSelectconn.block (false);
}
else if (lastFFAutoSelect)
flatFieldAutoSelect->set_inconsistent (true);
lastFFAutoSelect = flatFieldAutoSelect->get_active ();
}
hbff->set_sensitive( !flatFieldAutoSelect->get_active() );
if( flatFieldAutoSelect->get_active() && ffp && !batchMode){
// retrieve the auto-selected ff filename
rtengine::RawImage *img = ffp->getFF();
if( img ){
ffInfo->set_text( Glib::ustring::compose("%1: f/%2s", Glib::path_get_basename(img->get_filename()), img->get_aperture()) ); // !!! need to add focallength in mm and format aperture to ##.#
}else{
ffInfo->set_text(Glib::ustring(M("TP_PREPROCESS_NO_FOUND")));
}
}
else{ffInfo->set_text("");}
if (listener)
listener->panelChanged (EvFlatFieldAutoSelect, flatFieldAutoSelect->get_active()?M("GENERAL_ENABLED"):M("GENERAL_DISABLED"));
}

67
rtgui/flatfield.h Normal file
View File

@@ -0,0 +1,67 @@
/*
* 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/>.
*/
#ifndef _FLATFIELD_H_
#define _FLATFIELD_H_
#include <gtkmm.h>
#include <adjuster.h>
#include <toolpanel.h>
#include <rawimage.h>
class FFProvider {
public:
virtual rtengine::RawImage* getFF() {}
// add other info here
};
class FlatField : public Gtk::VBox, public AdjusterListener, public FoldableToolPanel {
protected:
Gtk::FileChooserButton *flatFieldFile;
Gtk::Label *ffLabel;
Gtk::Label *ffInfo;
Gtk::Button *flatFieldFileReset;
Gtk::CheckButton* flatFieldAutoSelect;
Adjuster* flatFieldBlurRadius;
Gtk::ComboBoxText* flatFieldBlurType;
Gtk::HBox *hbff;
bool ffChanged;
bool lastFFAutoSelect;
FFProvider *ffp;
sigc::connection flatFieldFileconn, flatFieldAutoSelectconn, flatFieldBlurTypeconn;
public:
FlatField ();
void read (const rtengine::procparams::ProcParams* pp, const ParamsEdited* pedited=NULL);
void write (rtengine::procparams::ProcParams* pp, ParamsEdited* pedited=NULL);
void setBatchMode (bool batchMode);
void setDefaults (const rtengine::procparams::ProcParams* defParams, const ParamsEdited* pedited=NULL);
void adjusterChanged (Adjuster* a, double newval);
void flatFieldFileChanged ();
void flatFieldFile_Reset ();
void flatFieldAutoSelectChanged ();
void flatFieldBlurTypeChanged ();
void setFFProvider (FFProvider* p) { ffp = p; };
};
#endif

6
rtgui/options.cc
View File

@@ -18,7 +18,6 @@
*/
#include <options.h>
#include <stdio.h>
#include <adjuster.h>
#include <glib/gstdio.h>
#include <sstream>
#include <multilangmgr.h>
@@ -59,6 +58,7 @@ void Options::setDefaults () {
defProfRaw = "default";
defProfImg = "neutral";
dateFormat = "%y-%m-%d";
adjusterDelay = 0;
startupDir = 1;
startupPath = "";
profilePath = "profiles";
@@ -182,7 +182,7 @@ if (keyFile.has_group ("General")) {
if (keyFile.has_key ("General", "StartupPath")) startupPath = keyFile.get_string ("General", "StartupPath");
if (keyFile.has_key ("General", "DateFormat")) dateFormat = keyFile.get_string ("General", "DateFormat");
if (keyFile.has_key ("General", "AdjusterDelay")) Adjuster::delay = keyFile.get_integer ("General", "AdjusterDelay");
if (keyFile.has_key ("General", "AdjusterDelay")) adjusterDelay = keyFile.get_integer ("General", "AdjusterDelay");
if (keyFile.has_key ("General", "StoreLastProfile")) savesParamsAtExit = keyFile.get_boolean ("General", "StoreLastProfile");
if (keyFile.has_key ("General", "DualProcSupport")) rtSettings.dualThreadEnabled = keyFile.get_boolean ("General", "DualProcSupport");
if (keyFile.has_key ("General", "MultiUser")) multiUser = keyFile.get_boolean ("General", "MultiUser");
@@ -331,7 +331,7 @@ int Options::saveToFile (Glib::ustring fname) {
keyFile.set_string ("General", "StartupDirectory", "last");
keyFile.set_string ("General", "StartupPath", startupPath);
keyFile.set_string ("General", "DateFormat", dateFormat);
keyFile.set_integer ("General", "AdjusterDelay", Adjuster::delay);
keyFile.set_integer ("General", "AdjusterDelay", adjusterDelay);
keyFile.set_boolean ("General", "DualProcSupport", rtSettings.dualThreadEnabled);
keyFile.set_boolean ("General", "MultiUser", multiUser);
keyFile.set_string ("General", "Language", language);

1
rtgui/options.h
View File

@@ -58,6 +58,7 @@ class Options {
Glib::ustring defProfRaw;
Glib::ustring defProfImg;
Glib::ustring dateFormat;
int adjusterDelay;
int startupDir;
Glib::ustring startupPath;
Glib::ustring profilePath;

450
rtgui/preprocess.cc
View File

@@ -17,7 +17,6 @@
* along with RawTherapee. If not, see <http://www.gnu.org/licenses/>.
*/
#include <preprocess.h>
#include <options.h>
#include <guiutils.h>
#include <safegtk.h>
#include <sstream>
@@ -25,369 +24,100 @@
using namespace rtengine;
using namespace rtengine::procparams;
PreProcess::PreProcess (): Gtk::VBox(), FoldableToolPanel(this)
PreProcess::PreProcess () : Gtk::VBox(), FoldableToolPanel(this)
{
hbdf = Gtk::manage(new Gtk::HBox());
darkFrameFile = Gtk::manage(new Gtk::FileChooserButton(M("TP_PREPROCESS_DARKFRAME"), Gtk::FILE_CHOOSER_ACTION_OPEN));
dfLabel = Gtk::manage(new Gtk::Label(M("TP_PREPROCESS_DARKFRAME")));
btnReset = Gtk::manage(new Gtk::Button());
btnReset->set_image (*Gtk::manage(new Gtk::Image (Gtk::StockID("gtk-cancel"), Gtk::ICON_SIZE_BUTTON)));
hbdf->pack_start(*dfLabel, Gtk::PACK_SHRINK, 4);
hbdf->pack_start(*darkFrameFile);
hbdf->pack_start(*btnReset, Gtk::PACK_SHRINK, 4);
dfAuto = Gtk::manage(new Gtk::CheckButton((M("TP_PREPROCESS_DFAUTOSELECT"))));
dfInfo = Gtk::manage(new Gtk::Label(""));
dfInfo->set_alignment(0,0); //left align
hbff = Gtk::manage(new Gtk::HBox());
flatFieldFile = Gtk::manage(new Gtk::FileChooserButton(M("TP_PREPROCESS_FLATFIELDFILE"), Gtk::FILE_CHOOSER_ACTION_OPEN));
ffLabel = Gtk::manage(new Gtk::Label(M("TP_PREPROCESS_FLATFIELDFILE")));
flatFieldFileReset = Gtk::manage(new Gtk::Button());
flatFieldFileReset->set_image (*Gtk::manage(new Gtk::Image (Gtk::StockID("gtk-cancel"), Gtk::ICON_SIZE_BUTTON)));
hbff->pack_start(*ffLabel, Gtk::PACK_SHRINK, 4);
hbff->pack_start(*flatFieldFile);
hbff->pack_start(*flatFieldFileReset, Gtk::PACK_SHRINK, 4);
flatFieldAutoSelect = Gtk::manage(new Gtk::CheckButton((M("TP_PREPROCESS_FLATFIELDAUTOSELECT"))));
ffInfo = Gtk::manage(new Gtk::Label(""));
ffInfo->set_alignment(0,0); //left align
flatFieldBlurRadius = Gtk::manage(new Adjuster (M("PREFERENCES_FLATFIELDBLURRADIUS"),0,200,2,32));
flatFieldBlurRadius->setAdjusterListener (this);
flatFieldBlurRadius->show();
Gtk::HBox* hbffbt = Gtk::manage (new Gtk::HBox ());
hbffbt->pack_start (*Gtk::manage (new Gtk::Label ( M("PREFERENCES_FLATFIELDBLURTYPE") +": ")));
flatFieldBlurType = Gtk::manage (new Gtk::ComboBoxText ());
for( size_t i=0; i< procparams::RAWParams::numFlatFileBlurTypes;i++)
flatFieldBlurType->append_text(procparams::RAWParams::ff_BlurTypestring[i]);
flatFieldBlurType->set_active(0);
hotDeadPixel = Gtk::manage(new Gtk::CheckButton((M("TP_PREPROCESS_HOTDEADPIXFILT"))));
caAutocorrect = Gtk::manage(new Gtk::CheckButton((M("PREFERENCES_CACORRECTION"))));
caRed = Gtk::manage(new Adjuster (M("PREFERENCES_CARED"),-4.0,4.0,0.1,0));
caRed->setAdjusterListener (this);
caRed->show();
caBlue = Gtk::manage(new Adjuster (M("PREFERENCES_CABLUE"),-4.0,4.0,0.1,0));
caBlue->setAdjusterListener (this);
caBlue->show();
//exposi
/*exPos = Gtk::manage(new Adjuster (M("PREFERENCES_EXPOS"),0.2,4.0,0.1,1));
exPos->setAdjusterListener (this);
exPos->show();
exPreser = Gtk::manage(new Adjuster (M("PREFERENCES_PRESER"),0,2.5,0.1,0));
exPreser->setAdjusterListener (this);
exPreser->show();*/
PexPos = Gtk::manage(new Adjuster (M("PREFERENCES_EXPOS"),0.2,4.0,0.1,1));
PexPos->setAdjusterListener (this);
PexPos->show();
PexPreser = Gtk::manage(new Adjuster (M("PREFERENCES_PRESER"),0,2.5,0.1,0));
PexPreser->setAdjusterListener (this);
PexPreser->show();
hotDeadPixel = Gtk::manage(new Gtk::CheckButton((M("PREFERENCES_HOTDEADPIXFILT"))));
lineDenoise = Gtk::manage(new Adjuster (M("PREFERENCES_LINEDENOISE"),0,1000,1,0));
lineDenoise = Gtk::manage(new Adjuster (M("TP_PREPROCESS_LINEDENOISE"),0,1000,1,0));
lineDenoise->setAdjusterListener (this);
if (lineDenoise->delay < 1000) lineDenoise->delay = 1000;
lineDenoise->show();
greenEqThreshold = Gtk::manage(new Adjuster (M("PREFERENCES_GREENEQUIL"),0,100,1,0));
greenEqThreshold->setAdjusterListener (this);
greenEqThreshold = Gtk::manage(new Adjuster (M("TP_PREPROCESS_GREENEQUIL"),0,100,1,0));
if (greenEqThreshold->delay < 1000) greenEqThreshold->delay = 1000;
greenEqThreshold->show();
pack_start( *hbdf, Gtk::PACK_SHRINK, 4);
pack_start( *dfAuto, Gtk::PACK_SHRINK, 4);
pack_start( *dfInfo, Gtk::PACK_SHRINK, 4);
pack_start( *Gtk::manage (new Gtk::HSeparator()));
pack_start( *lineDenoise, Gtk::PACK_SHRINK, 4);
pack_start( *hbff, Gtk::PACK_SHRINK, 4);
pack_start( *flatFieldAutoSelect, Gtk::PACK_SHRINK, 4);
pack_start( *ffInfo, Gtk::PACK_SHRINK, 4);
hbffbt->pack_end (*flatFieldBlurType);
pack_start( *hbffbt, Gtk::PACK_SHRINK, 4);
pack_start( *flatFieldBlurRadius, Gtk::PACK_SHRINK, 4);
pack_start( *Gtk::manage (new Gtk::HSeparator()));
pack_start( *Gtk::manage (new Gtk::HSeparator()));
pack_start( *hotDeadPixel, Gtk::PACK_SHRINK, 4);
pack_start( *Gtk::manage (new Gtk::HSeparator()));
pack_start( *caAutocorrect, Gtk::PACK_SHRINK, 4);
pack_start( *caRed, Gtk::PACK_SHRINK, 4);
pack_start( *caBlue, Gtk::PACK_SHRINK, 4);
pack_start( *PexPos, Gtk::PACK_SHRINK, 4);//exposi
pack_start( *PexPreser, Gtk::PACK_SHRINK, 4);
pack_start( *Gtk::manage (new Gtk::HSeparator()));
pack_start( *lineDenoise, Gtk::PACK_SHRINK, 4);
pack_start( *Gtk::manage (new Gtk::HSeparator()));
pack_start( *greenEqThreshold, Gtk::PACK_SHRINK, 4);
pack_start( *greenEqThreshold, Gtk::PACK_SHRINK, 4);
caacsconn = caAutocorrect->signal_toggled().connect ( sigc::mem_fun(*this, &PreProcess::caCorrectionChanged), true);
dfautoconn = dfAuto->signal_toggled().connect ( sigc::mem_fun(*this, &PreProcess::dfAutoChanged), true);
hdpixelconn = hotDeadPixel->signal_toggled().connect ( sigc::mem_fun(*this, &PreProcess::hotDeadPixelChanged), true);
dfFile = darkFrameFile->signal_file_set().connect ( sigc::mem_fun(*this, &PreProcess::darkFrameChanged), true);
btnReset->signal_clicked().connect( sigc::mem_fun(*this, &PreProcess::darkFrameReset), true );
flatFieldFileconn = flatFieldFile->signal_file_set().connect ( sigc::mem_fun(*this, &PreProcess::flatFieldFileChanged), true);
flatFieldFileReset->signal_clicked().connect( sigc::mem_fun(*this, &PreProcess::flatFieldFile_Reset), true );
flatFieldAutoSelectconn = flatFieldAutoSelect->signal_toggled().connect ( sigc::mem_fun(*this, &PreProcess::flatFieldAutoSelectChanged), true);
flatFieldBlurTypeconn = flatFieldBlurType->signal_changed().connect( sigc::mem_fun(*this, &PreProcess::flatFieldBlurTypeChanged) );
pack_start( *Gtk::manage (new Gtk::HSeparator()));
pack_start( *hotDeadPixel, Gtk::PACK_SHRINK, 4);
hdpixelconn = hotDeadPixel->signal_toggled().connect ( sigc::mem_fun(*this, &PreProcess::hotDeadPixelChanged), true);
}
void PreProcess::read(const rtengine::procparams::ProcParams* pp, const ParamsEdited* pedited)
{
disableListener ();
caacsconn.block (true);
dfautoconn.block(true);
hdpixelconn.block (true);
flatFieldAutoSelectconn.block (true);
flatFieldBlurTypeconn.block (true);
disableListener ();
hdpixelconn.block (true);
if(pedited ){
dfAuto->set_inconsistent(!pedited->raw.dfAuto );
caAutocorrect->set_inconsistent(!pedited->raw.caCorrection);
caRed->setEditedState( pedited->raw.caRed ? Edited : UnEdited );
caBlue->setEditedState( pedited->raw.caBlue ? Edited : UnEdited );
PexPos->setEditedState( pedited->raw.exPos ? Edited : UnEdited );
PexPreser->setEditedState( pedited->raw.exPreser ? Edited : UnEdited );
//exposure
hotDeadPixel->set_inconsistent (!pedited->raw.hotDeadPixel);
lineDenoise->setEditedState( pedited->raw.linenoise ? Edited : UnEdited );
greenEqThreshold->setEditedState( pedited->raw.greenEq ? Edited : UnEdited );
flatFieldAutoSelect->set_inconsistent (!pedited->raw.ff_AutoSelect);
flatFieldBlurRadius->setEditedState( pedited->raw.ff_BlurRadius ? Edited : UnEdited );
if( !pedited->raw.ff_BlurType )
flatFieldBlurType->set_active(procparams::RAWParams::numFlatFileBlurTypes); // No name
}
if (safe_file_test (pp->raw.dark_frame, Glib::FILE_TEST_EXISTS))
darkFrameFile->set_filename (pp->raw.dark_frame);
else if( !options.rtSettings.darkFramesPath.empty() )
darkFrameFile->set_current_folder( options.rtSettings.darkFramesPath );
hbdf->set_sensitive( !pp->raw.df_autoselect );
if (safe_file_test (pp->raw.ff_file, Glib::FILE_TEST_EXISTS))
flatFieldFile->set_filename (pp->raw.ff_file);
else if( !options.rtSettings.flatFieldsPath.empty() )
flatFieldFile->set_current_folder( options.rtSettings.flatFieldsPath );
hbff->set_sensitive( !pp->raw.ff_AutoSelect );
lastCA = pp->raw.ca_autocorrect;
lastHot = pp->raw.hotdeadpix_filt;
lastDFauto = pp->raw.df_autoselect;
if( pp->raw.df_autoselect && dfp && !batchMode){
// retrieve the auto-selected df filename
rtengine::RawImage *img = dfp->getDF();
if( img ){
std::ostringstream s;
s << Glib::path_get_basename(img->get_filename()) << ": " <<img->get_ISOspeed() << "ISO " << img->get_shutter() << "s";
dfInfo->set_text( s.str() );
}else{
dfInfo->set_text(Glib::ustring(M("TP_PREPROCESS_NO_FOUND")));
}
if(pedited ){
hotDeadPixel->set_inconsistent (!pedited->raw.hotDeadPixel);
lineDenoise->setEditedState( pedited->raw.linenoise ? Edited : UnEdited );
greenEqThreshold->setEditedState( pedited->raw.greenEq ? Edited : UnEdited );
}
else dfInfo->set_text("");
lastFFAutoSelect = pp->raw.ff_AutoSelect;
if( pp->raw.ff_AutoSelect && ffp && !batchMode){
// retrieve the auto-selected ff filename
rtengine::RawImage *img = ffp->getFF();
if( img ){
std::ostringstream s;
s << Glib::path_get_basename(img->get_filename()) << ": " << "f/" << img->get_aperture(); // !!! need to add focallength in mm and format aperture to ##.#
ffInfo->set_text( s.str() );
}else{
ffInfo->set_text(Glib::ustring(M("TP_PREPROCESS_NO_FOUND")));
}
}
else ffInfo->set_text("");
flatFieldAutoSelect ->set_active(pp->raw.ff_AutoSelect);
flatFieldBlurRadius->setValue (pp->raw.ff_BlurRadius);
flatFieldBlurType->set_active(procparams::RAWParams::numFlatFileBlurTypes);
//flatFieldBlurType
for( size_t i=0; i< procparams::RAWParams::numFlatFileBlurTypes;i++)
if( pp->raw.ff_BlurType == procparams::RAWParams::ff_BlurTypestring[i]){
flatFieldBlurType->set_active(i);
break;
}
dfAuto->set_active( pp->raw.df_autoselect );
caAutocorrect->set_active(pp->raw.ca_autocorrect);
caRed->setValue (pp->raw.cared);
caBlue->setValue (pp->raw.cablue);
PexPos->setValue (pp->raw.expos);
PexPreser->setValue (pp->raw.preser);//exposi
hotDeadPixel->set_active (pp->raw.hotdeadpix_filt);
lineDenoise->setValue (pp->raw.linenoise);
greenEqThreshold->setValue (pp->raw.greenthresh);
lastHot = pp->raw.hotdeadpix_filt;
flatFieldAutoSelect->set_active (pp->raw.ff_AutoSelect);
flatFieldBlurRadius->setValue (pp->raw.ff_BlurRadius);
hotDeadPixel->set_active (pp->raw.hotdeadpix_filt);
lineDenoise->setValue (pp->raw.linenoise);
greenEqThreshold->setValue (pp->raw.greenthresh);
dfChanged = false;
ffChanged = false;
caacsconn.block (false);
dfautoconn.block(false);
hdpixelconn.block (false);
flatFieldAutoSelectconn.block (false);
flatFieldBlurTypeconn.block (false);
enableListener ();
hdpixelconn.block (false);
enableListener ();
}
void PreProcess::write( rtengine::procparams::ProcParams* pp, ParamsEdited* pedited)
{
pp->raw.dark_frame = darkFrameFile->get_filename();
pp->raw.df_autoselect = dfAuto->get_active();
pp->raw.ff_file = flatFieldFile->get_filename();
pp->raw.ff_AutoSelect = flatFieldAutoSelect->get_active();
pp->raw.ff_BlurRadius = (int)flatFieldBlurRadius->getValue();
int currentRow = flatFieldBlurType->get_active_row_number();
if( currentRow>=0 && currentRow < procparams::RAWParams::numFlatFileBlurTypes)
pp->raw.ff_BlurType = procparams::RAWParams::ff_BlurTypestring[currentRow];
pp->raw.ca_autocorrect = caAutocorrect->get_active();
pp->raw.cared = (double)caRed->getValue();
pp->raw.cablue = (double)caBlue->getValue();
pp->raw.expos = (double)PexPos->getValue();
pp->raw.preser = (double)PexPreser->getValue();//exposi
pp->raw.hotdeadpix_filt = hotDeadPixel->get_active();
pp->raw.linenoise = (int)lineDenoise->getValue();
pp->raw.greenthresh = (int)greenEqThreshold->getValue();
pp->raw.linenoise = lineDenoise->getIntValue();
pp->raw.greenthresh = greenEqThreshold->getIntValue();
if (pedited) {
pedited->raw.darkFrame = dfChanged;
pedited->raw.dfAuto = !dfAuto->get_inconsistent();
pedited->raw.ff_file = ffChanged;
pedited->raw.ff_AutoSelect = !flatFieldAutoSelect->get_inconsistent();
pedited->raw.ff_BlurRadius = flatFieldBlurRadius->getEditedState ();
pedited->raw.ff_BlurType = flatFieldBlurType->get_active_row_number() != procparams::RAWParams::numFlatFileBlurTypes;
pedited->raw.linenoise = lineDenoise->getEditedState ();
pedited->raw.greenEq= greenEqThreshold->getEditedState ();
pedited->raw.caCorrection = !caAutocorrect->get_inconsistent();
pedited->raw.caRed = caRed->getEditedState ();
pedited->raw.caBlue = caBlue->getEditedState ();
pedited->raw.exPos = PexPos->getEditedState ();
pedited->raw.exPreser = PexPreser->getEditedState ();//exposi
pedited->raw.hotDeadPixel = !hotDeadPixel->get_inconsistent();
}
}
void PreProcess::adjusterChanged (Adjuster* a, double newval)
{
if (listener)
listener->panelChanged (EvPreProcess, Glib::ustring("params") );
if (listener) {
Glib::ustring value = a->getTextValue();
if (a == greenEqThreshold)
listener->panelChanged (EvPreProcessGEquilThresh, value );
else if (a == lineDenoise)
listener->panelChanged (EvPreProcessLineDenoise, value );
}
}
void PreProcess::setBatchMode(bool batchMode)
{
ToolPanel::setBatchMode (batchMode);
caRed->showEditedCB ();
caBlue->showEditedCB ();
PexPos->showEditedCB ();
PexPreser->showEditedCB ();//exposi
lineDenoise->showEditedCB ();
greenEqThreshold->showEditedCB ();
flatFieldBlurRadius->showEditedCB ();
ToolPanel::setBatchMode (batchMode);
lineDenoise->showEditedCB ();
greenEqThreshold->showEditedCB ();
}
void PreProcess::setDefaults(const rtengine::procparams::ProcParams* defParams, const ParamsEdited* pedited)
{
lineDenoise->setDefault( defParams->raw.linenoise);
caRed->setDefault( defParams->raw.cared);
caBlue->setDefault( defParams->raw.cablue);
PexPos->setDefault( defParams->raw.expos);
PexPreser->setDefault( defParams->raw.preser);
greenEqThreshold->setDefault (defParams->raw.greenthresh);
flatFieldBlurRadius->setDefault( defParams->raw.ff_BlurRadius);
if (pedited) {
lineDenoise->setDefaultEditedState( pedited->raw.linenoise ? Edited : UnEdited);
caRed->setDefaultEditedState( pedited->raw.caRed ? Edited : UnEdited);
caBlue->setDefaultEditedState( pedited->raw.caBlue ? Edited : UnEdited);
PexPos->setDefaultEditedState( pedited->raw.exPos ? Edited : UnEdited);
PexPreser->setDefaultEditedState( pedited->raw.exPreser ? Edited : UnEdited);
greenEqThreshold->setDefaultEditedState(pedited->raw.greenEq ? Edited : UnEdited);
flatFieldBlurRadius->setDefaultEditedState( pedited->raw.ff_BlurRadius ? Edited : UnEdited);
}else{
} else {
lineDenoise->setDefaultEditedState( Irrelevant );
caRed->setDefaultEditedState( Irrelevant );
caBlue->setDefaultEditedState( Irrelevant );
PexPos->setDefaultEditedState( Irrelevant );
PexPreser->setDefaultEditedState( Irrelevant );
greenEqThreshold->setDefaultEditedState(Irrelevant );
flatFieldBlurRadius->setDefaultEditedState( Irrelevant );
}
}
void PreProcess::caCorrectionChanged()
{
if (batchMode) {
if (caAutocorrect->get_inconsistent()) {
caAutocorrect->set_inconsistent (false);
caacsconn.block (true);
caAutocorrect->set_active (false);
caacsconn.block (false);
}
else if (lastCA)
caAutocorrect->set_inconsistent (true);
lastCA = caAutocorrect->get_active ();
}
if (listener)
listener->panelChanged (EvPreProcess, Glib::ustring(M("PREFERENCES_CACORRECTION"))+"="+(caAutocorrect->get_active()?"ON":"OFF") );
}
void PreProcess::dfAutoChanged()
{
if (batchMode) {
if (dfAuto->get_inconsistent()) {
dfAuto->set_inconsistent (false);
dfautoconn.block (true);
dfAuto->set_active (false);
dfautoconn.block (false);
}
else if (lastDFauto)
dfAuto->set_inconsistent (true);
lastDFauto = dfAuto->get_active ();
}
if(dfAuto->get_active() && dfp && !batchMode){
// retrieve the auto-selected df filename
rtengine::RawImage *img = dfp->getDF();
if( img ){
std::ostringstream s;
s << Glib::path_get_basename(img->get_filename()) << ": " <<img->get_ISOspeed() << "ISO " << img->get_shutter() << "s";
dfInfo->set_text( s.str() );
}else{
dfInfo->set_text(Glib::ustring(M("TP_PREPROCESS_NO_FOUND")));
}
}
else{dfInfo->set_text("");}
hbdf->set_sensitive( !dfAuto->get_active() );
if (listener)
listener->panelChanged (EvPreProcess, Glib::ustring(M("TP_PREPROCESS_DFAUTOSELECT"))+"="+(dfAuto->get_active()?"ON":"OFF") );
}
void PreProcess::hotDeadPixelChanged ()
{
if (batchMode) {
@@ -403,101 +133,5 @@ void PreProcess::hotDeadPixelChanged ()
lastHot = hotDeadPixel->get_active ();
}
if (listener)
listener->panelChanged (EvPreProcess, Glib::ustring(M("PREFERENCES_HOTDEADPIXFILT"))+"="+(hotDeadPixel->get_active()?"ON":"OFF") );
}
void PreProcess::darkFrameChanged()
{
dfChanged=true;
if (listener)
listener->panelChanged (EvPreProcess, Glib::ustring(M("TP_PREPROCESS_DARKFRAME"))+"="+darkFrameFile->get_filename());
}
void PreProcess::darkFrameReset()
{
dfChanged=true;
//darkFrameFile->set_current_name("");
darkFrameFile->set_filename ("");
if( !options.rtSettings.darkFramesPath.empty() )
darkFrameFile->set_current_folder( options.rtSettings.darkFramesPath );
dfInfo->set_text("");
if (listener)
listener->panelChanged (EvPreProcess, Glib::ustring(M("TP_PREPROCESS_DARKFRAME"))+"=0" );
}
void PreProcess::flatFieldFileChanged()
{
ffChanged=true;
if (listener)
listener->panelChanged (EvFlatFieldFile, Glib::ustring(M("TP_PREPROCESS_FLATFIELDFILE"))+"="+flatFieldFile->get_filename());
}
void PreProcess::flatFieldFile_Reset()
{
ffChanged=true;
//flatFieldFile->set_current_name("");
flatFieldFile->set_filename ("");
if( !options.rtSettings.flatFieldsPath.empty() )
flatFieldFile->set_current_folder( options.rtSettings.flatFieldsPath );
ffInfo->set_text("");
if (listener)
//listener->panelChanged (EvFlatFieldFile, Glib::ustring(M("TP_PREPROCESS_FLATFIELDFILE"))+"=None" );
listener->panelChanged (EvFlatFieldFile, "None" );
}
void PreProcess::flatFieldBlurTypeChanged ()
{
int curSelection = flatFieldBlurType->get_active_row_number();
Glib::ustring s="";
if( curSelection>=0 && curSelection < procparams::RAWParams::numFlatFileBlurTypes)
s = procparams::RAWParams::ff_BlurTypestring[curSelection];
if (listener)
//listener->panelChanged (EvFlatFieldBlurType, Glib::ustring(M("TP_PREPROCESS_FLATFIELDBLURTYPE"))+ "="+ s);
listener->panelChanged (EvFlatFieldBlurType, s);
}
void PreProcess::flatFieldAutoSelectChanged()
{
if (batchMode) {
if (flatFieldAutoSelect->get_inconsistent()) {
flatFieldAutoSelect->set_inconsistent (false);
flatFieldAutoSelectconn.block (true);
flatFieldAutoSelect->set_active (false);
flatFieldAutoSelectconn.block (false);
}
else if (lastFFAutoSelect)
flatFieldAutoSelect->set_inconsistent (true);
lastFFAutoSelect = flatFieldAutoSelect->get_active ();
}
hbff->set_sensitive( !flatFieldAutoSelect->get_active() );
if( flatFieldAutoSelect->get_active() && ffp && !batchMode){
// retrieve the auto-selected ff filename
rtengine::RawImage *img = ffp->getFF();
if( img ){
std::ostringstream s;
s << Glib::path_get_basename(img->get_filename()) << ": " << "f/" << img->get_aperture(); // !!! need to add focallength in mm and format aperture to ##.#
ffInfo->set_text( s.str() );
}else{
ffInfo->set_text(Glib::ustring(M("TP_PREPROCESS_NO_FOUND")));
}
}
else{ffInfo->set_text("");}
if (listener)
//listener->panelChanged (EvFlatFieldAutoSelect, Glib::ustring(M("TP_PREPROCESS_FLATFIELDAUTOSELECT"))+"="+(flatFieldAutoSelect->get_active()?"ON":"OFF") );
listener->panelChanged (EvFlatFieldAutoSelect, (flatFieldAutoSelect->get_active()?"ON":"OFF") );
}
void PreProcess::flatFieldBlurRadiusChanged()
{
//EvFlatFieldBlurRadius
listener->panelChanged (EvPreProcessHotDeadPixel, hotDeadPixel->get_active()?M("GENERAL_ENABLED"):M("GENERAL_DISABLED"));
}

63
rtgui/preprocess.h
View File

@@ -24,56 +24,16 @@
#include <toolpanel.h>
#include <rawimage.h>
class DFProvider {
public:
virtual rtengine::RawImage* getDF() {}
// add other info here
};
class FFProvider {
public:
virtual rtengine::RawImage* getFF() {}
// add other info here
};
class PreProcess : public Gtk::VBox, public AdjusterListener, public FoldableToolPanel{
class PreProcess : public Gtk::VBox, public AdjusterListener, public FoldableToolPanel {
protected:
Gtk::ComboBoxText* darkFrameMethod;
Gtk::FileChooserButton *darkFrameFile;
Gtk::HBox *hbdf;
Gtk::Button *btnReset;
Gtk::Label *dfLabel;
Gtk::Label *dfInfo;
bool dfChanged;
Gtk::FileChooserButton *flatFieldFile;
Gtk::Label *ffLabel;
Gtk::Label *ffInfo;
Gtk::Button *flatFieldFileReset;
Gtk::CheckButton* flatFieldAutoSelect;
Adjuster* flatFieldBlurRadius;
Gtk::ComboBoxText* flatFieldBlurType;
Gtk::HBox *hbff;
bool ffChanged;
Adjuster* caRed;
Adjuster* caBlue;
Adjuster* PexPos;
Adjuster* PexPreser;
Adjuster* lineDenoise;
Adjuster* greenEqThreshold;
Gtk::CheckButton* caAutocorrect;
Gtk::CheckButton* hotDeadPixel;
Gtk::CheckButton* dfAuto;
bool lastCA,lastHot,lastDFauto, lastFFAutoSelect;
DFProvider *dfp;
FFProvider *ffp;
sigc::connection caacsconn,dfautoconn,hdpixelconn,dfFile,flatFieldFileconn,flatFieldAutoSelectconn,flatFieldBlurTypeconn;
Adjuster* greenEqThreshold;
Gtk::CheckButton* hotDeadPixel;
bool lastHot;
sigc::connection hdpixelconn;
public:
@@ -85,20 +45,7 @@ class PreProcess : public Gtk::VBox, public AdjusterListener, public FoldableToo
void setDefaults (const rtengine::procparams::ProcParams* defParams, const ParamsEdited* pedited=NULL);
void adjusterChanged (Adjuster* a, double newval);
void caCorrectionChanged();
void hotDeadPixelChanged();
void darkFrameChanged();
void darkFrameReset();
void dfAutoChanged();
void flatFieldFileChanged();
void flatFieldFile_Reset();
void flatFieldAutoSelectChanged();
void flatFieldBlurRadiusChanged();
void flatFieldBlurTypeChanged();
void setDFProvider (DFProvider* p) { dfp = p; };
void setFFProvider (FFProvider* p) { ffp = p; };
};
#endif

143
rtgui/rawcacorrection.cc Normal file
View File

@@ -0,0 +1,143 @@
/*
* 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 <rawcacorrection.h>
#include <guiutils.h>
#include <safegtk.h>
#include <sstream>
using namespace rtengine;
using namespace rtengine::procparams;
RAWCACorr::RAWCACorr () : Gtk::VBox(), FoldableToolPanel(this)
{
caAutocorrect = Gtk::manage(new Gtk::CheckButton((M("TP_RAWCACORR_AUTO"))));
caRed = Gtk::manage(new Adjuster (M("TP_RAWCACORR_CARED"),-4.0,4.0,0.1,0));
caRed->setAdjusterListener (this);
if (caRed->delay < 1000) caRed->delay = 1000;
caRed->show();
caBlue = Gtk::manage(new Adjuster (M("TP_RAWCACORR_CABLUE"),-4.0,4.0,0.1,0));
caBlue->setAdjusterListener (this);
if (caBlue->delay < 1000) caBlue->delay = 1000;
caBlue->show();
pack_start( *caAutocorrect, Gtk::PACK_SHRINK, 4);
pack_start( *caRed, Gtk::PACK_SHRINK, 4);
pack_start( *caBlue, Gtk::PACK_SHRINK, 4);
caacsconn = caAutocorrect->signal_toggled().connect ( sigc::mem_fun(*this, &RAWCACorr::caCorrectionChanged), true);
}
void RAWCACorr::read(const rtengine::procparams::ProcParams* pp, const ParamsEdited* pedited)
{
disableListener ();
caacsconn.block (true);
if(pedited ){
caAutocorrect->set_inconsistent(!pedited->raw.caCorrection);
caRed->setEditedState( pedited->raw.caRed ? Edited : UnEdited );
caBlue->setEditedState( pedited->raw.caBlue ? Edited : UnEdited );
}
lastCA = pp->raw.ca_autocorrect;
caAutocorrect->set_active(pp->raw.ca_autocorrect);
caRed->setValue (pp->raw.cared);
caBlue->setValue (pp->raw.cablue);
caacsconn.block (false);
enableListener ();
}
void RAWCACorr::write( rtengine::procparams::ProcParams* pp, ParamsEdited* pedited)
{
pp->raw.ca_autocorrect = caAutocorrect->get_active();
pp->raw.cared = caRed->getValue();
pp->raw.cablue = caBlue->getValue();
if (pedited) {
pedited->raw.caCorrection = !caAutocorrect->get_inconsistent();
pedited->raw.caRed = caRed->getEditedState ();
pedited->raw.caBlue = caBlue->getEditedState ();
}
}
void RAWCACorr::adjusterChanged (Adjuster* a, double newval)
{
if (listener) {
Glib::ustring value = a->getTextValue();
if (a == caRed)
listener->panelChanged (EvPreProcessCARed, value );
else if (a == caBlue)
listener->panelChanged (EvPreProcessCABlue, value );
}
}
void RAWCACorr::setBatchMode(bool batchMode)
{
ToolPanel::setBatchMode (batchMode);
caRed->showEditedCB ();
caBlue->showEditedCB ();
}
void RAWCACorr::setDefaults(const rtengine::procparams::ProcParams* defParams, const ParamsEdited* pedited)
{
caRed->setDefault( defParams->raw.cared);
caBlue->setDefault( defParams->raw.cablue);
if (pedited) {
caRed->setDefaultEditedState( pedited->raw.caRed ? Edited : UnEdited);
caBlue->setDefaultEditedState( pedited->raw.caBlue ? Edited : UnEdited);
} else {
caRed->setDefaultEditedState( Irrelevant );
caBlue->setDefaultEditedState( Irrelevant );
}
}
void RAWCACorr::caCorrectionChanged()
{
if (batchMode) {
if (caAutocorrect->get_inconsistent()) {
caAutocorrect->set_inconsistent (false);
caacsconn.block (true);
caAutocorrect->set_active (false);
caacsconn.block (false);
}
else if (lastCA)
caAutocorrect->set_inconsistent (true);
lastCA = caAutocorrect->get_active ();
}
else {
// For non batch mode, we disable the red and blue slider if caAutocorrect is true
if (caAutocorrect->get_active ()) {
caRed->set_sensitive(false);
caBlue->set_sensitive(false);
}
else {
caRed->set_sensitive(true);
caBlue->set_sensitive(true);
}
}
if (listener)
listener->panelChanged (EvPreProcessAutoCA, caAutocorrect->get_active()?M("GENERAL_ENABLED"):M("GENERAL_DISABLED"));
}

49
rtgui/rawcacorrection.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* 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/>.
*/
#ifndef _RAWCACORRECTION_H_
#define _RAWCACORRECTION_H_
#include <gtkmm.h>
#include <adjuster.h>
#include <toolpanel.h>
#include <rawimage.h>
class RAWCACorr : public Gtk::VBox, public AdjusterListener, public FoldableToolPanel {
protected:
Gtk::CheckButton* caAutocorrect;
Adjuster* caRed;
Adjuster* caBlue;
bool lastCA;
sigc::connection caacsconn;
public:
RAWCACorr ();
void read (const rtengine::procparams::ProcParams* pp, const ParamsEdited* pedited=NULL);
void write (rtengine::procparams::ProcParams* pp, ParamsEdited* pedited=NULL);
void setBatchMode (bool batchMode);
void setDefaults (const rtengine::procparams::ProcParams* defParams, const ParamsEdited* pedited=NULL);
void adjusterChanged (Adjuster* a, double newval);
void caCorrectionChanged ();
};
#endif

101
rtgui/rawexposure.cc Normal file
View File

@@ -0,0 +1,101 @@
/*
* 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 <rawexposure.h>
#include <guiutils.h>
#include <safegtk.h>
#include <sstream>
using namespace rtengine;
using namespace rtengine::procparams;
RAWExposure::RAWExposure () : Gtk::VBox(), FoldableToolPanel(this)
{
PexPos = Gtk::manage(new Adjuster (M("TP_RAWEXPOS_LINEAR"),0.2,4.0,0.1,1));
PexPos->setAdjusterListener (this);
if (PexPos->delay < 1000) PexPos->delay = 1000;
PexPos->show();
PexPreser = Gtk::manage(new Adjuster (M("TP_RAWEXPOS_PRESER"),0,2.5,0.1,0));
PexPreser->setAdjusterListener (this);
if (PexPreser->delay < 1000) PexPreser->delay = 1000;
PexPreser->show();
pack_start( *PexPos, Gtk::PACK_SHRINK, 4);//exposi
pack_start( *PexPreser, Gtk::PACK_SHRINK, 4);
}
void RAWExposure::read(const rtengine::procparams::ProcParams* pp, const ParamsEdited* pedited)
{
disableListener ();
if(pedited ){
PexPos->setEditedState( pedited->raw.exPos ? Edited : UnEdited );
PexPreser->setEditedState( pedited->raw.exPreser ? Edited : UnEdited );
}
PexPos->setValue (pp->raw.expos);
PexPreser->setValue (pp->raw.preser);//exposi
enableListener ();
}
void RAWExposure::write( rtengine::procparams::ProcParams* pp, ParamsEdited* pedited)
{
pp->raw.expos = PexPos->getValue();
pp->raw.preser = PexPreser->getValue();//exposi
if (pedited) {
pedited->raw.exPos = PexPos->getEditedState ();
pedited->raw.exPreser = PexPreser->getEditedState ();//exposi
}
}
void RAWExposure::adjusterChanged (Adjuster* a, double newval)
{
if (listener) {
Glib::ustring value = a->getTextValue();
if (a == PexPos)
listener->panelChanged (EvPreProcessExpCorrLinear, value );
else if (a == PexPreser)
listener->panelChanged (EvPreProcessExpCorrPH, value );
}
}
void RAWExposure::setBatchMode(bool batchMode)
{
ToolPanel::setBatchMode (batchMode);
PexPos->showEditedCB ();
PexPreser->showEditedCB ();//exposi
}
void RAWExposure::setDefaults(const rtengine::procparams::ProcParams* defParams, const ParamsEdited* pedited)
{
PexPos->setDefault( defParams->raw.expos);
PexPreser->setDefault( defParams->raw.preser);
if (pedited) {
PexPos->setDefaultEditedState( pedited->raw.exPos ? Edited : UnEdited);
PexPreser->setDefaultEditedState( pedited->raw.exPreser ? Edited : UnEdited);
} else {
PexPos->setDefaultEditedState( Irrelevant );
PexPreser->setDefaultEditedState( Irrelevant );
}
}

45
rtgui/rawexposure.h Normal file
View File

@@ -0,0 +1,45 @@
/*
* 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/>.
*/
#ifndef _RAWEXPOSURE_H_
#define _RAWEXPOSURE_H_
#include <gtkmm.h>
#include <adjuster.h>
#include <toolpanel.h>
#include <rawimage.h>
class RAWExposure : public Gtk::VBox, public AdjusterListener, public FoldableToolPanel {
protected:
Adjuster* PexPos;
Adjuster* PexPreser;
public:
RAWExposure ();
void read (const rtengine::procparams::ProcParams* pp, const ParamsEdited* pedited=NULL);
void write (rtengine::procparams::ProcParams* pp, ParamsEdited* pedited=NULL);
void setBatchMode (bool batchMode);
void setDefaults (const rtengine::procparams::ProcParams* defParams, const ParamsEdited* pedited=NULL);
void adjusterChanged (Adjuster* a, double newval);
};
#endif

30
rtgui/rawprocess.cc
View File

@@ -25,7 +25,7 @@ using namespace rtengine::procparams;
RawProcess::RawProcess () : Gtk::VBox(), FoldableToolPanel(this)
{
Gtk::HBox* hb1 = Gtk::manage (new Gtk::HBox ());
hb1->pack_start (*Gtk::manage (new Gtk::Label ( M("PREFERENCES_DMETHOD") +": ")));
hb1->pack_start (*Gtk::manage (new Gtk::Label ( M("TP_RAW_DMETHOD") +": ")));
dmethod = Gtk::manage (new Gtk::ComboBoxText ());
for( size_t i=0; i< procparams::RAWParams::numMethods;i++)
dmethod->append_text(procparams::RAWParams::methodstring[i]);
@@ -37,10 +37,11 @@ RawProcess::RawProcess () : Gtk::VBox(), FoldableToolPanel(this)
dcbOptions = Gtk::manage (new Gtk::VBox ());
dcbOptions->set_border_width(4);
dcbIterations = Gtk::manage (new Adjuster (M("PREFERENCES_DCBITERATIONS"),0,5,1,2));
dcbIterations ->setAdjusterListener (this);
dcbIterations ->show();
dcbEnhance = Gtk::manage (new Gtk::CheckButton(M("PREFERENCES_DCBENHANCE")));
dcbIterations = Gtk::manage (new Adjuster (M("TP_RAW_DCBITERATIONS"),0,5,1,2));
dcbIterations->setAdjusterListener (this);
if (dcbIterations->delay < 1000) dcbIterations->delay = 1000;
dcbIterations->show();
dcbEnhance = Gtk::manage (new Gtk::CheckButton(M("TP_RAW_DCBENHANCE")));
dcbOptions->pack_start(*dcbIterations);
dcbOptions->pack_start(*dcbEnhance);
pack_start( *dcbOptions, Gtk::PACK_SHRINK, 4);
@@ -48,8 +49,9 @@ RawProcess::RawProcess () : Gtk::VBox(), FoldableToolPanel(this)
ccOptions = Gtk::manage (new Gtk::VBox ());
ccOptions->set_border_width(4);
ccSteps = Gtk::manage (new Adjuster (M("PREFERENCES_FALSECOLOR"),0,5,1,2 ));
ccSteps = Gtk::manage (new Adjuster (M("TP_RAW_FALSECOLOR"),0,5,1,2 ));
ccSteps->setAdjusterListener (this);
if (ccSteps->delay < 1000) ccSteps->delay = 1000;
ccSteps->show();
pack_start( *ccSteps, Gtk::PACK_SHRINK, 4);
@@ -103,8 +105,8 @@ void RawProcess::read(const rtengine::procparams::ProcParams* pp, const ParamsEd
void RawProcess::write( rtengine::procparams::ProcParams* pp, ParamsEdited* pedited)
{
pp->raw.ccSteps = (int)ccSteps->getValue();
pp->raw.dcb_iterations = (int)dcbIterations->getValue();
pp->raw.ccSteps = ccSteps->getIntValue();
pp->raw.dcb_iterations = dcbIterations->getIntValue();
pp->raw.dcb_enhance = dcbEnhance->get_active();
int currentRow = dmethod->get_active_row_number();
@@ -143,8 +145,12 @@ void RawProcess::setDefaults(const rtengine::procparams::ProcParams* defParams,
void RawProcess::adjusterChanged (Adjuster* a, double newval)
{
if (listener)
listener->panelChanged (EvDemosaic, Glib::ustring("params") );
if (listener) {
if (a == dcbIterations)
listener->panelChanged (EvDemosaicDCBIter, a->getTextValue() );
else if (a == ccSteps)
listener->panelChanged (EvDemosaicFalseColorIter, a->getTextValue() );
}
}
void RawProcess::methodChanged ()
@@ -160,7 +166,7 @@ void RawProcess::methodChanged ()
s = procparams::RAWParams::methodstring[curSelection];
if (listener)
listener->panelChanged (EvDemosaic, Glib::ustring(M("PREFERENCES_DMETHOD"))+ "="+ s);
listener->panelChanged (EvDemosaicMethod, s);
}
void RawProcess::dcbEnhanceChanged ()
@@ -178,5 +184,5 @@ void RawProcess::dcbEnhanceChanged ()
lastDCBen = dcbEnhance->get_active ();
}
if (listener)
listener->panelChanged (EvDemosaic, Glib::ustring("params") );
listener->panelChanged (EvDemosaicDCBEnhanced, dcbEnhance->get_active()?M("GENERAL_ENABLED"):M("GENERAL_DISABLED"));
}

16
rtgui/toolpanelcoord.cc
View File

@@ -65,6 +65,10 @@ ToolPanelCoordinator::ToolPanelCoordinator () : ipc(NULL) {
hsvequalizer = Gtk::manage (new HSVEqualizer ());
rawprocess = Gtk::manage (new RawProcess ());
preprocess = Gtk::manage (new PreProcess ());
darkframe = Gtk::manage (new DarkFrame ());
flatfield = Gtk::manage (new FlatField ());
rawcacorrection = Gtk::manage (new RAWCACorr ());
rawexposure = Gtk::manage (new RAWExposure ());
addPanel (colorPanel, whitebalance, M("TP_WBALANCE_LABEL")); toolPanels.push_back (whitebalance);
addPanel (exposurePanel, curve, M("TP_EXPOSURE_LABEL")); toolPanels.push_back (curve);
@@ -92,8 +96,12 @@ ToolPanelCoordinator::ToolPanelCoordinator () : ipc(NULL) {
addPanel (lensgeom->getPackBox(), cacorrection, M("TP_CACORRECTION_LABEL")); toolPanels.push_back (cacorrection);
addPanel (lensgeom->getPackBox(), vignetting, M("TP_VIGNETTING_LABEL")); toolPanels.push_back (vignetting);
addPanel (colorPanel, icm, M("TP_ICM_LABEL")); toolPanels.push_back (icm);
addPanel (rawPanel, rawprocess, M("TP_RAWPANEL_DEMOSAICING")); toolPanels.push_back (rawprocess);
addPanel (rawPanel, preprocess, M("TP_RAWPANEL_PREPROCESSING"));toolPanels.push_back (preprocess);
addPanel (rawPanel, rawprocess, M("TP_RAW_LABEL")); toolPanels.push_back (rawprocess);
addPanel (rawPanel, preprocess, M("TP_PREPROCESS_LABEL")); toolPanels.push_back (preprocess);
addPanel (rawPanel, rawexposure, M("TP_EXPOSCORR_LABEL")); toolPanels.push_back (rawexposure);
addPanel (rawPanel, darkframe, M("TP_DARKFRAME_LABEL")); toolPanels.push_back (darkframe);
addPanel (rawPanel, flatfield, M("TP_FLATFIELD_LABEL")); toolPanels.push_back (flatfield);
addPanel (rawPanel, rawcacorrection, M("TP_CHROMATABERR_LABEL")); toolPanels.push_back (rawcacorrection);
toolPanels.push_back (coarse);
toolPanels.push_back (exifpanel);
@@ -173,8 +181,8 @@ ToolPanelCoordinator::ToolPanelCoordinator () : ipc(NULL) {
whitebalance->setWBProvider (this);
whitebalance->setSpotWBListener (this);
preprocess->setDFProvider (this);
preprocess->setFFProvider (this);
darkframe->setDFProvider (this);
flatfield->setFFProvider (this);
lensgeom->setLensGeomListener (this);
rotate->setLensGeomListener (this);
crop->setCropPanelListener (this);

8
rtgui/toolpanelcoord.h
View File

@@ -59,6 +59,10 @@
#include <hsvequalizer.h>
#include <rawprocess.h>
#include <preprocess.h>
#include <darkframe.h>
#include <flatfield.h>
#include <rawcacorrection.h>
#include <rawexposure.h>
class ImageEditorCoordinator;
@@ -103,6 +107,10 @@ class ToolPanelCoordinator : public ToolPanelListener,
HSVEqualizer * hsvequalizer;
RawProcess* rawprocess;
PreProcess* preprocess;
DarkFrame* darkframe;
FlatField* flatfield;
RAWCACorr* rawcacorrection;
RAWExposure* rawexposure;
std::vector<PParamsChangeListener*> paramcListeners;