/*
 *  This file is part of RawTherapee.
 *
 *  Copyright (c) 2004-2010 Gabor Horvath <hgabor@rawtherapee.com>
 *  Copyright (c) 2012 Michael Ezra <michael@michaelezra.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 "exportpanel.h"
#include "multilangmgr.h"
#include "options.h"
#include "rtimage.h"

using namespace rtengine;
using namespace rtengine::procparams;

ExportPanel::ExportPanel () : listener (nullptr)
{

    /*enabled = Gtk::manage ( new Gtk::CheckButton (M("EXPORT_ENABLE")) );
    pack_start(*enabled, Gtk::PACK_SHRINK, 4);
    pack_start (*Gtk::manage(new Gtk::HSeparator ()), Gtk::PACK_SHRINK, 2);*/

    Gtk::Label* labExportTitle = Gtk::manage ( new Gtk::Label (M("EXPORT_FASTEXPORTOPTIONS")) );
    labExportTitle->set_use_markup (true);
    labExportTitle->set_tooltip_text (M("EXPORT_INSTRUCTIONS"));
    labExportTitle->set_alignment(Gtk::ALIGN_START);
    pack_start(*labExportTitle, Gtk::PACK_SHRINK, 4);

    Gtk::RadioButton::Group pipeline_group;
    use_fast_pipeline       = Gtk::manage ( new Gtk::RadioButton (pipeline_group, M("EXPORT_USE_FAST_PIPELINE")));
    use_normal_pipeline     = Gtk::manage ( new Gtk::RadioButton (pipeline_group, M("EXPORT_USE_NORMAL_PIPELINE")));
    bypass_box = Gtk::manage(new Gtk::VBox());
    bypass_ALL              = Gtk::manage ( new Gtk::CheckButton (M("EXPORT_BYPASS_ALL")));
    use_fast_pipeline->set_tooltip_text(M("EXPORT_USE_FAST_PIPELINE_TIP"));
    bypass_sharpening       = Gtk::manage ( new Gtk::CheckButton (M("EXPORT_BYPASS_SHARPENING")));
    bypass_sharpenEdge      = Gtk::manage ( new Gtk::CheckButton (M("EXPORT_BYPASS_SHARPENEDGE")));
    bypass_sharpenMicro     = Gtk::manage ( new Gtk::CheckButton (M("EXPORT_BYPASS_SHARPENMICRO")));
    //bypass_lumaDenoise      = Gtk::manage ( new Gtk::CheckButton (M("EXPORT_BYPASS_LUMADENOISE")));
    //bypass_colorDenoise     = Gtk::manage ( new Gtk::CheckButton (M("EXPORT_BYPASS_COLORDENOISE")));
    bypass_defringe         = Gtk::manage ( new Gtk::CheckButton (M("EXPORT_BYPASS_DEFRINGE")));
    bypass_dirpyrDenoise    = Gtk::manage ( new Gtk::CheckButton (M("EXPORT_BYPASS_DIRPYRDENOISE")));
    bypass_sh_hq            = Gtk::manage ( new Gtk::CheckButton (M("EXPORT_BYPASS_SH_HQ")));
    bypass_dirpyrequalizer  = Gtk::manage ( new Gtk::CheckButton (M("EXPORT_BYPASS_DIRPYREQUALIZER")));
    bypass_wavelet  = Gtk::manage ( new Gtk::CheckButton (M("EXPORT_BYPASS_EQUALIZER")));
    bypass_raw_ccSteps      = Gtk::manage ( new Gtk::CheckButton (M("EXPORT_BYPASS_RAW_CCSTEPS")));
    bypass_raw_ca           = Gtk::manage ( new Gtk::CheckButton (M("EXPORT_BYPASS_RAW_CA")));
    bypass_raw_df           = Gtk::manage ( new Gtk::CheckButton (M("EXPORT_BYPASS_RAW_DF")));
    bypass_raw_ff           = Gtk::manage ( new Gtk::CheckButton (M("EXPORT_BYPASS_RAW_FF")));

    // ---------------------- Bayer sensor frame -----------------------

    Gtk::Frame *bayerFrame = Gtk::manage( new Gtk::Frame(M("TP_RAW_SENSOR_BAYER")));
    Gtk::VBox* bayerFrameVBox = Gtk::manage (new Gtk::VBox ());

    Gtk::HBox* hb_raw_bayer_method = Gtk::manage (new Gtk::HBox ());
    hb_raw_bayer_method->pack_start (*Gtk::manage (new Gtk::Label ( M("EXPORT_RAW_DMETHOD") + ": ")), Gtk::PACK_SHRINK, 4);
    raw_bayer_method = Gtk::manage (new MyComboBoxText ());

    for( size_t i = 0; i < procparams::RAWParams::BayerSensor::numMethods; i++) {
        raw_bayer_method->append(procparams::RAWParams::BayerSensor::methodstring[i]);
    }

    raw_bayer_method->set_active(0);
    hb_raw_bayer_method->pack_end (*raw_bayer_method, Gtk::PACK_EXPAND_WIDGET, 4);

    //bypass_raw_all_enhance  = Gtk::manage ( new Gtk::CheckButton (M("EXPORT_BYPASS_RAW_ALL_ENHANCE")));
    bypass_raw_bayer_linenoise    = Gtk::manage ( new Gtk::CheckButton (M("EXPORT_BYPASS_RAW_LINENOISE")));
    bypass_raw_bayer_greenthresh  = Gtk::manage ( new Gtk::CheckButton (M("EXPORT_BYPASS_RAW_GREENTHRESH")));
    bypass_raw_bayer_dcb_iterations = Gtk::manage ( new Gtk::CheckButton (M("EXPORT_BYPASS_RAW_DCB_ITERATIONS")));
    bypass_raw_bayer_dcb_enhance    = Gtk::manage ( new Gtk::CheckButton (M("EXPORT_BYPASS_RAW_DCB_ENHANCE")));
    bypass_raw_bayer_lmmse_iterations = Gtk::manage ( new Gtk::CheckButton (M("EXPORT_BYPASS_RAW_LMMSE_ITERATIONS")));

    // ---------------------- Bayer sensor frame -----------------------

    Gtk::Frame *xtransFrame = Gtk::manage( new Gtk::Frame(M("TP_RAW_SENSOR_XTRANS")));
    Gtk::VBox* xtransFrameVBox = Gtk::manage (new Gtk::VBox ());

    Gtk::HBox* hb_raw_xtrans_method = Gtk::manage (new Gtk::HBox ());
    hb_raw_xtrans_method->pack_start (*Gtk::manage (new Gtk::Label ( M("EXPORT_RAW_DMETHOD") + ": ")), Gtk::PACK_SHRINK, 4);
    raw_xtrans_method = Gtk::manage (new MyComboBoxText ());

    for( size_t i = 0; i < procparams::RAWParams::XTransSensor::numMethods; i++) {
        raw_xtrans_method->append(procparams::RAWParams::XTransSensor::methodstring[i]);
    }

    raw_xtrans_method->set_active(0);
    hb_raw_xtrans_method->pack_end (*raw_xtrans_method, Gtk::PACK_EXPAND_WIDGET, 4);

    // ----------------------------------------------------------------

    // start global packing
    Gtk::HBox* lblbox = Gtk::manage (new Gtk::HBox ());
    lblbox->pack_start (*Gtk::manage (new Gtk::Label (M("EXPORT_PIPELINE"))), Gtk::PACK_SHRINK, 4);
    pack_start (*lblbox, Gtk::PACK_SHRINK, 4);
    pack_start(*use_fast_pipeline   , Gtk::PACK_SHRINK, 4);
    pack_start(*use_normal_pipeline   , Gtk::PACK_SHRINK, 4);

    bypass_box->pack_start(*Gtk::manage(new Gtk::HSeparator ()), Gtk::PACK_SHRINK, 4);
    lblbox = Gtk::manage (new Gtk::HBox ());
    lblbox->pack_start (*Gtk::manage (new Gtk::Label (M("EXPORT_BYPASS"))), Gtk::PACK_SHRINK, 4);
    bypass_box->pack_start (*lblbox, Gtk::PACK_SHRINK, 4);
    bypass_box->pack_start(*bypass_ALL          , Gtk::PACK_SHRINK, 4);
    // bypass_box->pack_start(*Gtk::manage(new Gtk::HSeparator ()), Gtk::PACK_SHRINK, 4);
    bypass_box->pack_start(*bypass_sharpening   , Gtk::PACK_SHRINK, 4);
    bypass_box->pack_start(*bypass_sharpenEdge  , Gtk::PACK_SHRINK, 4);
    bypass_box->pack_start(*bypass_sharpenMicro , Gtk::PACK_SHRINK, 4);
    //pack_start(*bypass_lumaDenoise  , Gtk::PACK_SHRINK, 4);
    //pack_start(*bypass_colorDenoise , Gtk::PACK_SHRINK, 4);
    bypass_box->pack_start(*bypass_defringe     , Gtk::PACK_SHRINK, 4);
    bypass_box->pack_start(*bypass_dirpyrDenoise, Gtk::PACK_SHRINK, 4);
    bypass_box->pack_start(*bypass_sh_hq        , Gtk::PACK_SHRINK, 4);
    bypass_box->pack_start(*bypass_dirpyrequalizer , Gtk::PACK_SHRINK, 4);
    bypass_box->pack_start(*bypass_wavelet , Gtk::PACK_SHRINK, 4);

    bayerFrameVBox->pack_start(*hb_raw_bayer_method, Gtk::PACK_SHRINK, 4);
    //bayerFrameVBox->pack_start(*bypass_raw_all_enhance , Gtk::PACK_SHRINK, 4);
    bayerFrameVBox->pack_start(*bypass_raw_bayer_dcb_iterations, Gtk::PACK_SHRINK, 4);
    bayerFrameVBox->pack_start(*bypass_raw_bayer_dcb_enhance   , Gtk::PACK_SHRINK, 4);
    bayerFrameVBox->pack_start(*bypass_raw_bayer_lmmse_iterations, Gtk::PACK_SHRINK, 4);
    bayerFrameVBox->pack_start(*bypass_raw_bayer_linenoise   , Gtk::PACK_SHRINK, 4);
    bayerFrameVBox->pack_start(*bypass_raw_bayer_greenthresh , Gtk::PACK_SHRINK, 4);
    bayerFrame->add(*bayerFrameVBox);

    xtransFrameVBox->pack_start(*hb_raw_xtrans_method, Gtk::PACK_SHRINK, 4);
    xtransFrame->add(*xtransFrameVBox);

    bypass_box->pack_start(*bypass_raw_ccSteps     , Gtk::PACK_SHRINK, 4);
    bypass_box->pack_start(*bypass_raw_ca         , Gtk::PACK_SHRINK, 4);

    bypass_box->pack_start(*bypass_raw_df         , Gtk::PACK_SHRINK, 4);
    bypass_box->pack_start(*bypass_raw_ff         , Gtk::PACK_SHRINK, 4);

    pack_start(*bypass_box, Gtk::PACK_SHRINK);    
    
    pack_start (*Gtk::manage(new Gtk::HSeparator ()), Gtk::PACK_SHRINK, 2);

    // Resize options

    Gtk::HBox* rmbox = Gtk::manage (new Gtk::HBox ());
    rmbox->pack_start (*Gtk::manage (new Gtk::Label (M("TP_RESIZE_LABEL"))), Gtk::PACK_SHRINK, 4);
    pack_start (*rmbox, Gtk::PACK_SHRINK, 4);

    Gtk::HBox* wbox = Gtk::manage (new Gtk::HBox ());
    Gtk::HBox* hbox = Gtk::manage (new Gtk::HBox ());
    MaxWidth = Gtk::manage (new MySpinButton ());
    MaxHeight = Gtk::manage (new MySpinButton ());
    wbox->pack_start (*Gtk::manage (new Gtk::Label (M("EXPORT_MAXWIDTH"))), Gtk::PACK_SHRINK, 4);
    wbox->pack_start (*MaxWidth);
    hbox->pack_start (*Gtk::manage (new Gtk::Label (M("EXPORT_MAXHEIGHT"))), Gtk::PACK_SHRINK, 4);
    hbox->pack_start (*MaxHeight);
    pack_start (*wbox, Gtk::PACK_SHRINK, 4);
    pack_start (*hbox, Gtk::PACK_SHRINK, 4);

    MaxWidth->set_digits (0);
    MaxWidth->set_width_chars(5);
    MaxWidth->set_max_width_chars(5);
    MaxWidth->set_increments (1, 100);
    MaxWidth->set_value (options.fastexport_resize_width);
    MaxWidth->set_range (32, 10000);

    MaxHeight->set_digits (0);
    MaxHeight->set_width_chars(5);
    MaxHeight->set_max_width_chars(5);
    MaxHeight->set_increments (1, 100);
    MaxHeight->set_value (options.fastexport_resize_height);
    MaxHeight->set_range (32, 10000);

    // Buttons
    btnFastExport =  Gtk::manage ( new Gtk::Button () );
    btnFastExport->set_tooltip_text(M("EXPORT_PUTTOQUEUEFAST"));
    btnFastExport->set_image (*Gtk::manage (new RTImage ("processing.png")));
    pack_start(*btnFastExport, Gtk::PACK_SHRINK, 4);


    // add panel ending
    Gtk::VBox* vboxpe = Gtk::manage (new Gtk::VBox ());
    Gtk::HSeparator* hseptpe = Gtk::manage (new Gtk::HSeparator ());
    Gtk::Image* peImg = Gtk::manage (new RTImage("PanelEnding.png"));
    vboxpe->pack_start(*hseptpe, Gtk::PACK_SHRINK, 4);
    vboxpe->pack_start(*peImg);
    pack_start(*vboxpe, Gtk::PACK_SHRINK, 0);


    use_fast_pipeline->signal_toggled().connect(sigc::mem_fun(*this, &ExportPanel::use_fast_pipeline_toggled));
    btnFastExport->signal_clicked().connect( sigc::mem_fun(*this, &ExportPanel::FastExportPressed) );
    //btnExportLoadSettings->signal_clicked().connect( sigc::mem_fun(*this, &ExportPanel::LoadSettings) );
    //btnExportSaveSettings->signal_clicked().connect( sigc::mem_fun(*this, &ExportPanel::SaveSettings) );
    bypass_ALLconn = bypass_ALL->signal_toggled().connect (sigc::mem_fun(*this, &ExportPanel::bypassALL_Toggled));

    bypass_sharpeningConn           = bypass_sharpening->signal_toggled().connect (sigc::bind (sigc::mem_fun(*bypass_ALL, &Gtk::CheckButton::set_inconsistent), true));
    bypass_sharpenEdgeConn          = bypass_sharpenEdge->signal_toggled().connect (sigc::bind (sigc::mem_fun(*bypass_ALL, &Gtk::CheckButton::set_inconsistent), true));
    bypass_sharpenMicroConn         = bypass_sharpenMicro->signal_toggled().connect (sigc::bind (sigc::mem_fun(*bypass_ALL, &Gtk::CheckButton::set_inconsistent), true));
    //bypass_lumaDenoiseConn        = bypass_lumaDenoise->signal_toggled().connect (sigc::bind (sigc::mem_fun(*bypass_ALL, &Gtk::CheckButton::set_inconsistent), true));
    //bypass_colorDenoiseConn       = bypass_colorDenoise->signal_toggled().connect (sigc::bind (sigc::mem_fun(*bypass_ALL, &Gtk::CheckButton::set_inconsistent), true));
    bypass_defringeConn             = bypass_defringe->signal_toggled().connect (sigc::bind (sigc::mem_fun(*bypass_ALL, &Gtk::CheckButton::set_inconsistent), true));
    bypass_dirpyrDenoiseConn        = bypass_dirpyrDenoise->signal_toggled().connect (sigc::bind (sigc::mem_fun(*bypass_ALL, &Gtk::CheckButton::set_inconsistent), true));
    bypass_sh_hqConn                = bypass_sh_hq->signal_toggled().connect (sigc::bind (sigc::mem_fun(*bypass_ALL, &Gtk::CheckButton::set_inconsistent), true));
    bypass_dirpyrequalizerConn      = bypass_dirpyrequalizer->signal_toggled().connect (sigc::bind (sigc::mem_fun(*bypass_ALL, &Gtk::CheckButton::set_inconsistent), true));
    bypass_waveletConn      = bypass_wavelet->signal_toggled().connect (sigc::bind (sigc::mem_fun(*bypass_ALL, &Gtk::CheckButton::set_inconsistent), true));
    //bypass_raw_all_enhanceConn    = bypass_raw_bayer_all_enhance->signal_toggled().connect (sigc::bind (sigc::mem_fun(*bypass_ALL, &Gtk::CheckButton::set_inconsistent), true));
    bypass_raw_bayer_dcb_iterationsConn   = bypass_raw_bayer_dcb_iterations->signal_toggled().connect (sigc::bind (sigc::mem_fun(*bypass_ALL, &Gtk::CheckButton::set_inconsistent), true));
    bypass_raw_bayer_dcb_enhanceConn      = bypass_raw_bayer_dcb_enhance->signal_toggled().connect (sigc::bind (sigc::mem_fun(*bypass_ALL, &Gtk::CheckButton::set_inconsistent), true));
    bypass_raw_bayer_lmmse_iterationsConn = bypass_raw_bayer_lmmse_iterations->signal_toggled().connect (sigc::bind (sigc::mem_fun(*bypass_ALL, &Gtk::CheckButton::set_inconsistent), true));
    bypass_raw_bayer_linenoiseConn        = bypass_raw_bayer_linenoise->signal_toggled().connect (sigc::bind (sigc::mem_fun(*bypass_ALL, &Gtk::CheckButton::set_inconsistent), true));
    bypass_raw_bayer_greenthreshConn      = bypass_raw_bayer_greenthresh->signal_toggled().connect (sigc::bind (sigc::mem_fun(*bypass_ALL, &Gtk::CheckButton::set_inconsistent), true));
    bypass_raw_ccStepsConn          = bypass_raw_ccSteps->signal_toggled().connect (sigc::bind (sigc::mem_fun(*bypass_ALL, &Gtk::CheckButton::set_inconsistent), true));
    bypass_raw_caConn               = bypass_raw_ca->signal_toggled().connect (sigc::bind (sigc::mem_fun(*bypass_ALL, &Gtk::CheckButton::set_inconsistent), true));
    bypass_raw_dfConn               = bypass_raw_df->signal_toggled().connect (sigc::bind (sigc::mem_fun(*bypass_ALL, &Gtk::CheckButton::set_inconsistent), true));
    bypass_raw_ffConn               = bypass_raw_ff->signal_toggled().connect (sigc::bind (sigc::mem_fun(*bypass_ALL, &Gtk::CheckButton::set_inconsistent), true));

    LoadDefaultSettings();
}

/*bool ExportPanel::isEnabled () {

    return enabled->get_active () && is_sensitive();
}*/


void ExportPanel::FastExportPressed ()
{
    // options is the container for making these settings available globally.
    // Therefore, settings must be saved to options before they are used further
    SaveSettingsAsDefault();

    if (listener) {
        listener->exportRequested ();
    }
}

void ExportPanel::SaveSettingsAsDefault()
{
    bool changed = false;
#define FE_OPT_STORE_(n, v) \
    do {                \
        if (n != v) {   \
            n = v;      \
            changed = true;                     \
        }                                       \
    } while (false)
    // Save fast export settings to options
    FE_OPT_STORE_(options.fastexport_bypass_sharpening, bypass_sharpening->get_active        ());
    FE_OPT_STORE_(options.fastexport_bypass_sharpenEdge, bypass_sharpenEdge->get_active       ());
    FE_OPT_STORE_(options.fastexport_bypass_sharpenMicro, bypass_sharpenMicro->get_active      ());
    //options.fastexport_bypass_lumaDenoise        = bypass_lumaDenoise->get_active       ();
    //options.fastexport_bypass_colorDenoise       = bypass_colorDenoise->get_active      ();
    FE_OPT_STORE_(options.fastexport_bypass_defringe, bypass_defringe->get_active          ());
    FE_OPT_STORE_(options.fastexport_bypass_dirpyrDenoise, bypass_dirpyrDenoise->get_active     ());
    FE_OPT_STORE_(options.fastexport_bypass_sh_hq, bypass_sh_hq->get_active             ());
    FE_OPT_STORE_(options.fastexport_bypass_dirpyrequalizer, bypass_dirpyrequalizer->get_active   ());
    FE_OPT_STORE_(options.fastexport_bypass_wavelet, bypass_wavelet->get_active   ());
    //options.fastexport_bypass_raw_bayer_all_enhance    = bypass_raw_all_enhance->get_active           ();
    FE_OPT_STORE_(options.fastexport_bypass_raw_bayer_dcb_iterations, bypass_raw_bayer_dcb_iterations->get_active  ());
    FE_OPT_STORE_(options.fastexport_bypass_raw_bayer_dcb_enhance, bypass_raw_bayer_dcb_enhance->get_active     ());
    FE_OPT_STORE_(options.fastexport_bypass_raw_bayer_lmmse_iterations, bypass_raw_bayer_lmmse_iterations->get_active());
    FE_OPT_STORE_(options.fastexport_bypass_raw_bayer_linenoise, bypass_raw_bayer_linenoise->get_active       ());
    FE_OPT_STORE_(options.fastexport_bypass_raw_bayer_greenthresh, bypass_raw_bayer_greenthresh->get_active     ());
    FE_OPT_STORE_(options.fastexport_bypass_raw_ccSteps, bypass_raw_ccSteps->get_active       ());
    FE_OPT_STORE_(options.fastexport_bypass_raw_ca, bypass_raw_ca->get_active            ());
    FE_OPT_STORE_(options.fastexport_bypass_raw_df, bypass_raw_df->get_active            ());
    FE_OPT_STORE_(options.fastexport_bypass_raw_ff, bypass_raw_ff->get_active            ());

    //saving Bayer demosaic_method
    int currentRow = raw_bayer_method->get_active_row_number();

    if( currentRow >= 0 && currentRow < procparams::RAWParams::BayerSensor::numMethods) {
        FE_OPT_STORE_(options.fastexport_raw_bayer_method, procparams::RAWParams::BayerSensor::methodstring[currentRow]);
    }

    //saving X-Trans demosaic_method
    currentRow = raw_xtrans_method->get_active_row_number();

    if( currentRow >= 0 && currentRow < procparams::RAWParams::XTransSensor::numMethods) {
        FE_OPT_STORE_(options.fastexport_raw_xtrans_method, procparams::RAWParams::XTransSensor::methodstring[currentRow]);
    }

//  options.fastexport_icm_input        = icm_input       ;
//  options.fastexport_icm_working      = icm_working     ;
//  options.fastexport_icm_output       = icm_output      ;
//  options.fastexport_icm_gamma        = icm_gamma       ;
//  options.fastexport_resize_enabled   = resize_enabled  ;
//  options.fastexport_resize_scale     = resize_scale    ;
//  options.fastexport_resize_appliesTo = resize_appliesTo;
//  options.fastexport_resize_dataspec  = resize_dataspec ;

    FE_OPT_STORE_(options.fastexport_resize_method, "Lanczos");
    FE_OPT_STORE_(options.fastexport_resize_width, MaxWidth->get_value_as_int ());
    FE_OPT_STORE_(options.fastexport_resize_height, MaxHeight->get_value_as_int ());

    FE_OPT_STORE_(options.fastexport_use_fast_pipeline, use_fast_pipeline->get_active());
#undef FE_OPT_STORE_

    if (changed) {
        Options::save();
    }
}

void ExportPanel::LoadDefaultSettings()
{
    // Load fast export settings from options
    bypass_sharpening->set_active        (options.fastexport_bypass_sharpening         );
    bypass_sharpenEdge->set_active       (options.fastexport_bypass_sharpenEdge        );
    bypass_sharpenMicro->set_active      (options.fastexport_bypass_sharpenMicro       );
    //bypass_lumaDenoise->set_active     (options.fastexport_bypass_lumaDenoise        );
    //bypass_colorDenoise->set_active    (options.fastexport_bypass_colorDenoise       );
    bypass_defringe->set_active          (options.fastexport_bypass_defringe           );
    bypass_dirpyrDenoise->set_active     (options.fastexport_bypass_dirpyrDenoise      );
    bypass_sh_hq->set_active             (options.fastexport_bypass_sh_hq              );
    bypass_dirpyrequalizer->set_active   (options.fastexport_bypass_dirpyrequalizer    );
    bypass_wavelet->set_active   (options.fastexport_bypass_wavelet    );
    //bypass_raw_bayer_all_enhance->set_active   (options.fastexport_bypass_raw_bayer_all_enhance     );
    bypass_raw_bayer_dcb_iterations->set_active  (options.fastexport_bypass_raw_bayer_dcb_iterations  );
    bypass_raw_bayer_dcb_enhance->set_active     (options.fastexport_bypass_raw_bayer_dcb_enhance     );
    bypass_raw_bayer_lmmse_iterations->set_active(options.fastexport_bypass_raw_bayer_lmmse_iterations);
    bypass_raw_bayer_linenoise->set_active       (options.fastexport_bypass_raw_bayer_linenoise       );
    bypass_raw_bayer_greenthresh->set_active     (options.fastexport_bypass_raw_bayer_greenthresh     );
    bypass_raw_ccSteps->set_active       (options.fastexport_bypass_raw_ccSteps        );
    bypass_raw_ca->set_active            (options.fastexport_bypass_raw_ca             );
    bypass_raw_df->set_active            (options.fastexport_bypass_raw_df             );
    bypass_raw_ff->set_active            (options.fastexport_bypass_raw_ff             );

    // Bayer demosaic method
    raw_bayer_method->set_active(procparams::RAWParams::BayerSensor::numMethods);

    for( size_t i = 0; i < procparams::RAWParams::BayerSensor::numMethods; i++)
        if( options.fastexport_raw_bayer_method == procparams::RAWParams::BayerSensor::methodstring[i]) {
            raw_bayer_method->set_active(i);
            break;
        }

    // X-Trans demosaic method
    raw_xtrans_method->set_active(procparams::RAWParams::XTransSensor::numMethods);

    for( size_t i = 0; i < procparams::RAWParams::XTransSensor::numMethods; i++)
        if( options.fastexport_raw_xtrans_method == procparams::RAWParams::XTransSensor::methodstring[i]) {
            raw_xtrans_method->set_active(i);
            break;
        }

//    icm_input        = options.fastexport_icm_input       ;
//    icm_working      = options.fastexport_icm_working     ;
//    icm_output       = options.fastexport_icm_output      ;
//    icm_gamma        = options.fastexport_icm_gamma       ;
//    resize_enabled   = options.fastexport_resize_enabled  ;
//    resize_scale     = options.fastexport_resize_scale    ;
//    resize_appliesTo = options.fastexport_resize_appliesTo;
//    resize_dataspec  = options.fastexport_resize_dataspec ;

    MaxWidth->set_value(options.fastexport_resize_width);
    MaxHeight->set_value(options.fastexport_resize_height);

    if (options.fastexport_use_fast_pipeline) {
        use_fast_pipeline->set_active(true);
        bypass_box->set_sensitive(false);
    } else {
        use_normal_pipeline->set_active(true);
    }
}

void ExportPanel::LoadSettings()
{
    // load settings from file
}

void ExportPanel::SaveSettings()
{
    // save settings to file

}

void ExportPanel::bypassALL_Toggled()
{
    bypass_sharpeningConn.block         (true);
    bypass_sharpenEdgeConn.block        (true);
    bypass_sharpenMicroConn.block       (true);
    //bypass_lumaDenoiseConn.block        (true);
    //bypass_colorDenoiseConn.block       (true);
    bypass_defringeConn.block           (true);
    bypass_dirpyrDenoiseConn.block      (true);
    bypass_sh_hqConn.block              (true);
    bypass_dirpyrequalizerConn.block    (true);
    bypass_waveletConn.block    (true);
    //bypass_raw_bayer_all_enhanceConn.block    (true);
    bypass_raw_bayer_dcb_iterationsConn.block   (true);
    bypass_raw_bayer_dcb_enhanceConn.block      (true);
    bypass_raw_bayer_lmmse_iterationsConn.block (true);
    bypass_raw_bayer_linenoiseConn.block        (true);
    bypass_raw_bayer_greenthreshConn.block      (true);
    bypass_raw_ccStepsConn.block        (true);
    bypass_raw_caConn.block             (true);
    bypass_raw_dfConn.block             (true);
    bypass_raw_ffConn.block             (true);

    bypass_ALL->set_inconsistent (false);

    bypass_sharpening->set_active(bypass_ALL->get_active());
    bypass_sharpenEdge->set_active(bypass_ALL->get_active());
    bypass_sharpenMicro->set_active(bypass_ALL->get_active());
    //bypass_lumaDenoise->set_active(bypass_ALL->get_active());
    //bypass_colorDenoise->set_active(bypass_ALL->get_active());
    bypass_defringe->set_active(bypass_ALL->get_active());
    bypass_dirpyrDenoise->set_active(bypass_ALL->get_active());
    bypass_sh_hq->set_active(bypass_ALL->get_active());
    bypass_dirpyrequalizer->set_active(bypass_ALL->get_active());
    bypass_wavelet->set_active(bypass_ALL->get_active());
    //bypass_raw_bayer_all_enhance->set_active(bypass_ALL->get_active());
    bypass_raw_bayer_dcb_iterations->set_active(bypass_ALL->get_active());
    bypass_raw_bayer_dcb_enhance->set_active(bypass_ALL->get_active());
    bypass_raw_bayer_lmmse_iterations->set_active(bypass_ALL->get_active());
    bypass_raw_bayer_linenoise->set_active(bypass_ALL->get_active());
    bypass_raw_bayer_greenthresh->set_active(bypass_ALL->get_active());
    bypass_raw_ccSteps->set_active(bypass_ALL->get_active());
    bypass_raw_ca->set_active(bypass_ALL->get_active());
    bypass_raw_df->set_active(bypass_ALL->get_active());
    bypass_raw_ff->set_active(bypass_ALL->get_active());

    bypass_sharpeningConn.block           (false);
    bypass_sharpenEdgeConn.block          (false);
    bypass_sharpenMicroConn.block         (false);
    //bypass_lumaDenoiseConn.block        (false);
    //bypass_colorDenoiseConn.block       (false);
    bypass_defringeConn.block             (false);
    bypass_dirpyrDenoiseConn.block        (false);
    bypass_sh_hqConn.block                (false);
    bypass_dirpyrequalizerConn.block      (false);
    bypass_waveletConn.block      (false);
    //bypass_raw_bayer_all_enhanceConn.block    (false);
    bypass_raw_bayer_dcb_iterationsConn.block   (false);
    bypass_raw_bayer_dcb_enhanceConn.block      (false);
    bypass_raw_bayer_lmmse_iterationsConn.block (false);
    bypass_raw_bayer_linenoiseConn.block        (false);
    bypass_raw_bayer_greenthreshConn.block      (false);
    bypass_raw_ccStepsConn.block          (false);
    bypass_raw_caConn.block               (false);
    bypass_raw_dfConn.block               (false);
    bypass_raw_ffConn.block               (false);
}

void ExportPanel::use_fast_pipeline_toggled()
{
    bypass_box->set_sensitive(!use_fast_pipeline->get_active());
}

/*
fastexport_bypass_sharpening
fastexport_bypass_sharpenEdge
fastexport_bypass_sharpenMicro
fastexport_bypass_lumaDenoise
fastexport_bypass_colorDenoise
fastexport_bypass_defringe
fastexport_bypass_dirpyrDenoise
fastexport_bypass_sh_hq
fastexport_bypass_dirpyrequalizer
fastexport_raw_bayer_method
fastexport_bypass_raw_bayer_all_enhance
fastexport_bypass_raw_bayer_dcb_iterations
fastexport_bypass_raw_bayer_dcb_enhance
fastexport_bypass_raw_bayer_linenoise
fastexport_bypass_raw_bayer_greenthresh
fastexport_raw_xtrans_method
fastexport_bypass_raw_ccSteps
fastexport_bypass_raw_ca
fastexport_bypass_raw_df
fastexport_bypass_raw_ff
fastexport_icm_input
fastexport_icm_working
fastexport_icm_output
fastexport_icm_gamma
fastexport_resize_enabled
fastexport_resize_scale
fastexport_resize_appliesTo
fastexport_resize_method
fastexport_resize_dataspec
fastexport_resize_width
fastexport_resize_height
*/
