diff --git a/rtgui/CMakeLists.txt b/rtgui/CMakeLists.txt index 629e3890f..05afd9af5 100644 --- a/rtgui/CMakeLists.txt +++ b/rtgui/CMakeLists.txt @@ -229,7 +229,7 @@ if((WIN32) AND NOT(UPPER_CMAKE_BUILD_TYPE STREQUAL "DEBUG")) set_target_properties(rth PROPERTIES LINK_FLAGS "-mwindows") endif() set_target_properties(rth PROPERTIES COMPILE_FLAGS "${CMAKE_CXX_FLAGS}" OUTPUT_NAME rawtherapee) -set_target_properties(rth-cli PROPERTIES COMPILE_FLAGS "${CMAKE_CXX_FLAGS} -DRAWTHERAPEE_CLI" OUTPUT_NAME rawtherapee-cli) +set_target_properties(rth-cli PROPERTIES COMPILE_FLAGS "${CMAKE_CXX_FLAGS}" OUTPUT_NAME rawtherapee-cli) # Add linked libraries dependencies to executables targets target_link_libraries(rth rtengine diff --git a/rtgui/exportpanel.cc b/rtgui/exportpanel.cc index 72cf30fdd..7fdc3ae50 100644 --- a/rtgui/exportpanel.cc +++ b/rtgui/exportpanel.cc @@ -32,193 +32,193 @@ ExportPanel::ExportPanel () : listener (nullptr) 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")) ); + 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); + 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"))); + 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"))); + 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::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); + 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]); + 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); + 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"))); + 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::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); + 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]); + 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); + 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); + 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); + 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); + 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); + 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 (*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); + 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); + 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 (*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); + 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); + 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_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); + 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); + 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); + 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 (*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 (*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_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_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_tooltip_text (M ("EXPORT_PUTTOQUEUEFAST")); btnFastExport->set_image (*Gtk::manage (new RTImage ("processing.png"))); - pack_start(*btnFastExport, Gtk::PACK_SHRINK, 4); + 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); + 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) ); + 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_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_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_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)); + 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(); } @@ -251,39 +251,39 @@ void ExportPanel::SaveSettingsAsDefault() } \ } 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 ()); + 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 ()); + 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 ()); + 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]); + 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]); + 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 ; @@ -295,15 +295,20 @@ void ExportPanel::SaveSettingsAsDefault() // 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_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()); + FE_OPT_STORE_ (options.fastexport_use_fast_pipeline, use_fast_pipeline->get_active()); #undef FE_OPT_STORE_ if (changed) { - Options::save(); + try { + Options::save(); + } catch (Options::Error &e) { + Gtk::MessageDialog msgd (getToplevelWindow (this), e.get_msg(), true, Gtk::MESSAGE_WARNING, Gtk::BUTTONS_CLOSE, true); + msgd.run(); + } } } @@ -323,7 +328,7 @@ void ExportPanel::LoadDefaultSettings() //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_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 ); @@ -332,20 +337,20 @@ void ExportPanel::LoadDefaultSettings() bypass_raw_ff->set_active (options.fastexport_bypass_raw_ff ); // Bayer demosaic method - raw_bayer_method->set_active(procparams::RAWParams::BayerSensor::numMethods); + 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); + 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); + 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); + 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; } @@ -358,14 +363,14 @@ void ExportPanel::LoadDefaultSettings() // 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); + 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); + use_fast_pipeline->set_active (true); + bypass_box->set_sensitive (false); } else { - use_normal_pipeline->set_active(true); + use_normal_pipeline->set_active (true); } } @@ -405,26 +410,26 @@ void ExportPanel::bypassALL_Toggled() 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_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_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_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); @@ -450,7 +455,7 @@ void ExportPanel::bypassALL_Toggled() void ExportPanel::use_fast_pipeline_toggled() { - bypass_box->set_sensitive(!use_fast_pipeline->get_active()); + bypass_box->set_sensitive (!use_fast_pipeline->get_active()); } /* diff --git a/rtgui/main-cli.cc b/rtgui/main-cli.cc index 69c3d8487..7908b9133 100644 --- a/rtgui/main-cli.cc +++ b/rtgui/main-cli.cc @@ -96,14 +96,14 @@ bool fast_export = false; * -1 if there is an error in parameters * -2 if an error occurred during processing * -3 if at least one required procparam file was not found */ -int processLineParams( int argc, char **argv ); +int processLineParams ( int argc, char **argv ); -bool dontLoadCache( int argc, char **argv ); +bool dontLoadCache ( int argc, char **argv ); -int main(int argc, char **argv) +int main (int argc, char **argv) { - setlocale(LC_ALL, ""); - setlocale(LC_NUMERIC, "C"); // to set decimal point to "." + setlocale (LC_ALL, ""); + setlocale (LC_NUMERIC, "C"); // to set decimal point to "." Gio::init (); @@ -116,33 +116,33 @@ int main(int argc, char **argv) #ifdef WIN32 WCHAR exnameU[512] = {0}; GetModuleFileNameW (NULL, exnameU, 511); - WideCharToMultiByte(CP_UTF8, 0, exnameU, -1, exname, 511, 0, 0 ); + WideCharToMultiByte (CP_UTF8, 0, exnameU, -1, exname, 511, 0, 0 ); #else - if (readlink("/proc/self/exe", exname, 511) < 0) { - strncpy(exname, argv[0], 511); + if (readlink ("/proc/self/exe", exname, 511) < 0) { + strncpy (exname, argv[0], 511); } #endif - exePath = Glib::path_get_dirname(exname); + exePath = Glib::path_get_dirname (exname); // set paths - if (Glib::path_is_absolute(DATA_SEARCH_PATH)) { + if (Glib::path_is_absolute (DATA_SEARCH_PATH)) { argv0 = DATA_SEARCH_PATH; } else { - argv0 = Glib::build_filename(exePath, DATA_SEARCH_PATH); + argv0 = Glib::build_filename (exePath, DATA_SEARCH_PATH); } - if (Glib::path_is_absolute(CREDITS_SEARCH_PATH)) { + if (Glib::path_is_absolute (CREDITS_SEARCH_PATH)) { creditsPath = CREDITS_SEARCH_PATH; } else { - creditsPath = Glib::build_filename(exePath, CREDITS_SEARCH_PATH); + creditsPath = Glib::build_filename (exePath, CREDITS_SEARCH_PATH); } - if (Glib::path_is_absolute(LICENCE_SEARCH_PATH)) { + if (Glib::path_is_absolute (LICENCE_SEARCH_PATH)) { licensePath = LICENCE_SEARCH_PATH; } else { - licensePath = Glib::build_filename(exePath, LICENCE_SEARCH_PATH); + licensePath = Glib::build_filename (exePath, LICENCE_SEARCH_PATH); } #else @@ -151,22 +151,24 @@ int main(int argc, char **argv) licensePath = LICENCE_SEARCH_PATH; #endif - bool quickstart = dontLoadCache(argc, argv); + bool quickstart = dontLoadCache (argc, argv); - if (!Options::load (quickstart)) { - printf("Fatal error!\nThe RT_SETTINGS and/or RT_PATH environment variables are set, but use a relative path. The path must be absolute!\n"); + try { + Options::load (quickstart); + } catch (Options::Error &) { + printf ("Fatal error!\nThe RT_SETTINGS and/or RT_PATH environment variables are set, but use a relative path. The path must be absolute!\n"); return -2; } - rtengine::setPaths(options); + rtengine::setPaths (options); - TIFFSetWarningHandler(nullptr); // avoid annoying message boxes + TIFFSetWarningHandler (nullptr); // avoid annoying message boxes #ifndef WIN32 // Move the old path to the new one if the new does not exist - if (Glib::file_test(Glib::build_filename(options.rtdir, "cache"), Glib::FILE_TEST_IS_DIR) && !Glib::file_test(options.cacheBaseDir, Glib::FILE_TEST_IS_DIR)) { - g_rename(Glib::build_filename (options.rtdir, "cache").c_str (), options.cacheBaseDir.c_str ()); + if (Glib::file_test (Glib::build_filename (options.rtdir, "cache"), Glib::FILE_TEST_IS_DIR) && !Glib::file_test (options.cacheBaseDir, Glib::FILE_TEST_IS_DIR)) { + g_rename (Glib::build_filename (options.rtdir, "cache").c_str (), options.cacheBaseDir.c_str ()); } #endif @@ -175,57 +177,58 @@ int main(int argc, char **argv) bool consoleOpened = false; // suppression of annoying error boxes - SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX); + SetErrorMode (SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX); if (argc > 1 || options.rtSettings.verbose) { - Glib::ustring fname(fname_to_utf8 (argv[1])); + Glib::ustring fname (fname_to_utf8 (argv[1])); #if ECLIPSE_ARGS - fname = fname.substr(1, fname.length()-2); + fname = fname.substr (1, fname.length() - 2); #endif + if (options.rtSettings.verbose || ( !Glib::file_test (fname, Glib::FILE_TEST_EXISTS ) && !Glib::file_test (fname, Glib::FILE_TEST_IS_DIR))) { - bool stdoutRedirectedtoFile = (GetFileType(GetStdHandle(STD_OUTPUT_HANDLE)) == 0x0001); - bool stderrRedirectedtoFile = (GetFileType(GetStdHandle(STD_ERROR_HANDLE)) == 0x0001); + bool stdoutRedirectedtoFile = (GetFileType (GetStdHandle (STD_OUTPUT_HANDLE)) == 0x0001); + bool stderrRedirectedtoFile = (GetFileType (GetStdHandle (STD_ERROR_HANDLE)) == 0x0001); // no console, if stdout and stderr both are redirected to file - if( !(stdoutRedirectedtoFile && stderrRedirectedtoFile)) { + if ( ! (stdoutRedirectedtoFile && stderrRedirectedtoFile)) { // check if parameter -w was passed. // We have to do that in this step, because it controls whether to open a console to show the output of following steps bool Console = true; - for(int i = 1; i < argc; i++) - if(!strcmp(argv[i], "-w")) { + for (int i = 1; i < argc; i++) + if (!strcmp (argv[i], "-w")) { Console = false; break; } - if(Console && AllocConsole()) { - AttachConsole( GetCurrentProcessId() ) ; + if (Console && AllocConsole()) { + AttachConsole ( GetCurrentProcessId() ) ; // Don't allow CTRL-C in console to terminate RT - SetConsoleCtrlHandler( NULL, true ); + SetConsoleCtrlHandler ( NULL, true ); // Set title of console char consoletitle[128]; - sprintf(consoletitle, "RawTherapee %s Console", RTVERSION); - SetConsoleTitle(consoletitle); + sprintf (consoletitle, "RawTherapee %s Console", RTVERSION); + SetConsoleTitle (consoletitle); // increase size of screen buffer COORD c; c.X = 200; c.Y = 1000; - SetConsoleScreenBufferSize( GetStdHandle( STD_OUTPUT_HANDLE ), c ); + SetConsoleScreenBufferSize ( GetStdHandle ( STD_OUTPUT_HANDLE ), c ); // Disable console-Cursor CONSOLE_CURSOR_INFO cursorInfo; cursorInfo.dwSize = 100; cursorInfo.bVisible = false; - SetConsoleCursorInfo( GetStdHandle( STD_OUTPUT_HANDLE ), &cursorInfo ); + SetConsoleCursorInfo ( GetStdHandle ( STD_OUTPUT_HANDLE ), &cursorInfo ); - if(!stdoutRedirectedtoFile) { - freopen( "CON", "w", stdout ) ; + if (!stdoutRedirectedtoFile) { + freopen ( "CON", "w", stdout ) ; } - if(!stderrRedirectedtoFile) { - freopen( "CON", "w", stderr ) ; + if (!stderrRedirectedtoFile) { + freopen ( "CON", "w", stderr ) ; } - freopen( "CON", "r", stdin ) ; + freopen ( "CON", "r", stdin ) ; consoleOpened = true; @@ -236,31 +239,34 @@ int main(int argc, char **argv) } } } + #endif int ret = 0; // printing RT's version in all case, particularly useful for the 'verbose' mode, but also for the batch processing std::cout << "RawTherapee, version " << RTVERSION << ", command line" << std::endl; + if (argc > 1) { - ret = processLineParams(argc, argv); - } - else { + ret = processLineParams (argc, argv); + } else { std::cout << "Terminating without anything to do." << std::endl; } #ifdef WIN32 - if(consoleOpened) { - printf("Press any key to exit RawTherapee\n"); - FlushConsoleInputBuffer(GetStdHandle(STD_INPUT_HANDLE)); + + if (consoleOpened) { + printf ("Press any key to exit RawTherapee\n"); + FlushConsoleInputBuffer (GetStdHandle (STD_INPUT_HANDLE)); getch(); } + #endif return ret; } -void deleteProcParams(std::vector &pparams) +void deleteProcParams (std::vector &pparams) { for (unsigned int i = 0; i < pparams.size(); i++) { pparams[i]->deleteInstance(); @@ -272,14 +278,15 @@ void deleteProcParams(std::vector &pparam } -bool dontLoadCache( int argc, char **argv ) +bool dontLoadCache ( int argc, char **argv ) { for (int iArg = 1; iArg < argc; iArg++) { - Glib::ustring currParam(argv[iArg]); + Glib::ustring currParam (argv[iArg]); #if ECLIPSE_ARGS - currParam = currParam.substr(1, currParam.length()-2); + currParam = currParam.substr (1, currParam.length() - 2); #endif - if( currParam.at(0) == '-' && currParam.at(1) == 'q' ) { + + if ( currParam.at (0) == '-' && currParam.at (1) == 'q' ) { return true; } } @@ -287,7 +294,7 @@ bool dontLoadCache( int argc, char **argv ) return false; } -int processLineParams( int argc, char **argv ) +int processLineParams ( int argc, char **argv ) { rtengine::procparams::PartialProfile *rawParams = nullptr, *imgParams = nullptr; std::vector inputFiles; @@ -308,311 +315,316 @@ int processLineParams( int argc, char **argv ) std::string outputType = ""; unsigned errors = 0; - for( int iArg = 1; iArg < argc; iArg++) { - Glib::ustring currParam(argv[iArg]); + for ( int iArg = 1; iArg < argc; iArg++) { + Glib::ustring currParam (argv[iArg]); #if ECLIPSE_ARGS - currParam = currParam.substr(1, currParam.length()-2); -#endif - if( currParam.at(0) == '-' ) { - switch( currParam.at(1) ) { - case 'O': - copyParamsFile = true; - - case 'o': // outputfile or dir - if( iArg + 1 < argc ) { - iArg++; - outputPath = Glib::ustring(fname_to_utf8(argv[iArg])); -#if ECLIPSE_ARGS - outputPath = outputPath.substr(1, outputPath.length()-2); -#endif - if(outputPath.substr(0,9) == "/dev/null") { - outputPath.assign("/dev/null"); // removing any useless chars or filename - outputDirectory = false; - leaveUntouched = true; - } else if(Glib::file_test (outputPath, Glib::FILE_TEST_IS_DIR)) { - outputDirectory = true; - } - } - - break; - - case 'p': // processing parameters for all inputs; all set procparams are required, so - - // RT stop if any of them can't be loaded for any reason. - if( iArg + 1 < argc ) { - iArg++; - Glib::ustring fname(fname_to_utf8(argv[iArg])); -#if ECLIPSE_ARGS - fname = fname.substr(1, fname.length()-2); + currParam = currParam.substr (1, currParam.length() - 2); #endif - if (fname.at(0) == '-') { - std::cerr << "Error: filename missing next to the -p switch" << std::endl; - deleteProcParams(processingParams); - return -3; + if ( currParam.at (0) == '-' ) { + switch ( currParam.at (1) ) { + case 'O': + copyParamsFile = true; + + case 'o': // outputfile or dir + if ( iArg + 1 < argc ) { + iArg++; + outputPath = Glib::ustring (fname_to_utf8 (argv[iArg])); +#if ECLIPSE_ARGS + outputPath = outputPath.substr (1, outputPath.length() - 2); +#endif + + if (outputPath.substr (0, 9) == "/dev/null") { + outputPath.assign ("/dev/null"); // removing any useless chars or filename + outputDirectory = false; + leaveUntouched = true; + } else if (Glib::file_test (outputPath, Glib::FILE_TEST_IS_DIR)) { + outputDirectory = true; + } } - rtengine::procparams::PartialProfile* currentParams = new rtengine::procparams::PartialProfile(true); + break; - if (!(currentParams->load ( fname ))) { - processingParams.push_back(currentParams); + case 'p': // processing parameters for all inputs; all set procparams are required, so + + // RT stop if any of them can't be loaded for any reason. + if ( iArg + 1 < argc ) { + iArg++; + Glib::ustring fname (fname_to_utf8 (argv[iArg])); +#if ECLIPSE_ARGS + fname = fname.substr (1, fname.length() - 2); +#endif + + if (fname.at (0) == '-') { + std::cerr << "Error: filename missing next to the -p switch" << std::endl; + deleteProcParams (processingParams); + return -3; + } + + rtengine::procparams::PartialProfile* currentParams = new rtengine::procparams::PartialProfile (true); + + if (! (currentParams->load ( fname ))) { + processingParams.push_back (currentParams); + } else { + std::cerr << "Error: \"" << fname << "\" not found" << std::endl; + deleteProcParams (processingParams); + return -3; + } + } + + break; + + case 'S': + skipIfNoSidecar = true; + + case 's': // Processing params next to file (file extension appended) + sideProcParams = true; + sideCarFilePos = processingParams.size(); + break; + + case 'd': + useDefault = true; + break; + + case 'q': + break; + + case 'Y': + overwriteFiles = true; + break; + + case 'a': + allExtensions = true; + break; + + case 'j': + if (currParam.length() > 2 && currParam.at (2) == 's') { + if (currParam.length() == 3) { + std::cerr << "Error: the -js switch requires a mandatory value!" << std::endl; + deleteProcParams (processingParams); + return -3; + } + + // looking for the subsampling parameter + subsampling = atoi (currParam.substr (3).c_str()); + + if (subsampling < 1 || subsampling > 3) { + std::cerr << "Error: the value accompanying the -js switch has to be in the [1-3] range!" << std::endl; + deleteProcParams (processingParams); + return -3; + } } else { - std::cerr << "Error: \"" << fname << "\" not found" << std::endl; - deleteProcParams(processingParams); - return -3; + outputType = "jpg"; + compression = atoi (currParam.substr (2).c_str()); + + if (compression < 0 || compression > 100) { + std::cerr << "Error: the value accompanying the -j switch has to be in the [0-100] range!" << std::endl; + deleteProcParams (processingParams); + return -3; + } } - } - break; + break; - case 'S': - skipIfNoSidecar = true; + case 'b': + bits = atoi (currParam.substr (2).c_str()); - case 's': // Processing params next to file (file extension appended) - sideProcParams = true; - sideCarFilePos = processingParams.size(); - break; - - case 'd': - useDefault = true; - break; - - case 'q': - break; - - case 'Y': - overwriteFiles = true; - break; - - case 'a': - allExtensions = true; - break; - - case 'j': - if (currParam.length() > 2 && currParam.at(2) == 's') { - if (currParam.length() == 3) { - std::cerr << "Error: the -js switch requires a mandatory value!" << std::endl; - deleteProcParams(processingParams); + if (bits != 8 && bits != 16) { + std::cerr << "Error: specify -b8 for 8-bit or -b16 for 16-bit output." << std::endl; + deleteProcParams (processingParams); return -3; } - // looking for the subsampling parameter - subsampling = atoi(currParam.substr(3).c_str()); + break; - if (subsampling < 1 || subsampling > 3) { - std::cerr << "Error: the value accompanying the -js switch has to be in the [1-3] range!" << std::endl; - deleteProcParams(processingParams); - return -3; - } - } else { - outputType = "jpg"; - compression = atoi(currParam.substr(2).c_str()); + case 't': + outputType = "tif"; + compression = ((currParam.size() < 3 || currParam.at (2) != 'z') ? 0 : 1); + break; - if (compression < 0 || compression > 100) { - std::cerr << "Error: the value accompanying the -j switch has to be in the [0-100] range!" << std::endl; - deleteProcParams(processingParams); - return -3; - } - } + case 'n': + outputType = "png"; + compression = -1; + break; - break; + case 'f': + fast_export = true; + break; - case 'b': - bits = atoi(currParam.substr(2).c_str()); - - if (bits != 8 && bits != 16) { - std::cerr << "Error: specify -b8 for 8-bit or -b16 for 16-bit output." << std::endl; - deleteProcParams(processingParams); - return -3; - } - - break; - - case 't': - outputType = "tif"; - compression = ((currParam.size() < 3 || currParam.at(2) != 'z') ? 0 : 1); - break; - - case 'n': - outputType = "png"; - compression = -1; - break; - - case 'f': - fast_export = true; - break; - - case 'c': // MUST be last option - while (iArg + 1 < argc) { - iArg++; - Glib::ustring argument(fname_to_utf8(argv[iArg])); + case 'c': // MUST be last option + while (iArg + 1 < argc) { + iArg++; + Glib::ustring argument (fname_to_utf8 (argv[iArg])); #if ECLIPSE_ARGS - argument = argument.substr(1, argument.length()-2); + argument = argument.substr (1, argument.length() - 2); #endif - if (!Glib::file_test (argument, Glib::FILE_TEST_EXISTS)) { - std::cout << "\"" << argument << "\" doesn't exist !" << std::endl; - continue; - } - - if (Glib::file_test (argument, Glib::FILE_TEST_IS_REGULAR)) { - bool notAll = allExtensions && !options.is_parse_extention (argument); - bool notRetained = !allExtensions && !options.has_retained_extention (argument); - if (notAll || notRetained) { - if (notAll) { - std::cout << "\"" << argument << "\" is not one of the file format to process: skipped" << std::endl; - } else if (notRetained) { - std::cout << "\"" << argument << "\" is not one of the retained file format to process: skipped" << std::endl; - } - } - else { - inputFiles.emplace_back (argument); - } - continue; - - } - - if (Glib::file_test (argument, Glib::FILE_TEST_IS_DIR)) { - - auto dir = Gio::File::create_for_path (argument); - if (!dir || !dir->query_exists()) { + if (!Glib::file_test (argument, Glib::FILE_TEST_EXISTS)) { + std::cout << "\"" << argument << "\" doesn't exist !" << std::endl; continue; } - try { - - auto enumerator = dir->enumerate_children("standard::name,standard::type"); - - while (auto file = enumerator->next_file()) { - - const auto fileName = Glib::build_filename(argument, file->get_name()); - bool isDir = file->get_file_type() == Gio::FILE_TYPE_DIRECTORY; - bool notAll = allExtensions && !options.is_parse_extention(fileName); - bool notRetained = !allExtensions && !options.has_retained_extention(fileName); - - if (isDir || notAll || notRetained) { - if (isDir) { - std::cout << "\"" << fileName << "\" is a directory: skipped" << std::endl; - } else if (notAll) { - std::cout << "\"" << fileName << "\" is not one of the file format to process: skipped" << std::endl; - } else if (notRetained) { - std::cout << "\"" << fileName << "\" is not one of the retained file format to process: skipped" << std::endl; - } - continue; + if (Glib::file_test (argument, Glib::FILE_TEST_IS_REGULAR)) { + bool notAll = allExtensions && !options.is_parse_extention (argument); + bool notRetained = !allExtensions && !options.has_retained_extention (argument); + if (notAll || notRetained) { + if (notAll) { + std::cout << "\"" << argument << "\" is not one of the file format to process: skipped" << std::endl; + } else if (notRetained) { + std::cout << "\"" << argument << "\" is not one of the retained file format to process: skipped" << std::endl; } - - if (sideProcParams && skipIfNoSidecar) { - // look for the sidecar proc params - if (!Glib::file_test(fileName + paramFileExtension, Glib::FILE_TEST_EXISTS)) { - std::cout << "\"" << fileName << "\" has no side-car file: image skipped" << std::endl; - continue; - } - } - - inputFiles.emplace_back (fileName); + } else { + inputFiles.emplace_back (argument); } - } catch (Glib::Exception&) {} + continue; - continue; + } + + if (Glib::file_test (argument, Glib::FILE_TEST_IS_DIR)) { + + auto dir = Gio::File::create_for_path (argument); + + if (!dir || !dir->query_exists()) { + continue; + } + + try { + + auto enumerator = dir->enumerate_children ("standard::name,standard::type"); + + while (auto file = enumerator->next_file()) { + + const auto fileName = Glib::build_filename (argument, file->get_name()); + bool isDir = file->get_file_type() == Gio::FILE_TYPE_DIRECTORY; + bool notAll = allExtensions && !options.is_parse_extention (fileName); + bool notRetained = !allExtensions && !options.has_retained_extention (fileName); + + if (isDir || notAll || notRetained) { + if (isDir) { + std::cout << "\"" << fileName << "\" is a directory: skipped" << std::endl; + } else if (notAll) { + std::cout << "\"" << fileName << "\" is not one of the file format to process: skipped" << std::endl; + } else if (notRetained) { + std::cout << "\"" << fileName << "\" is not one of the retained file format to process: skipped" << std::endl; + } + + continue; + + } + + if (sideProcParams && skipIfNoSidecar) { + // look for the sidecar proc params + if (!Glib::file_test (fileName + paramFileExtension, Glib::FILE_TEST_EXISTS)) { + std::cout << "\"" << fileName << "\" has no side-car file: image skipped" << std::endl; + continue; + } + } + + inputFiles.emplace_back (fileName); + } + + } catch (Glib::Exception&) {} + + continue; + } + + std::cerr << "\"" << argument << "\" is neither a regular file nor a directory." << std::endl; } - std::cerr << "\"" << argument << "\" is neither a regular file nor a directory." << std::endl; + break; +#ifdef WIN32 + + case 'w': // This case is handled outside this function + break; +#endif + + case 'h': + case '?': + default: { + Glib::ustring pparamsExt = paramFileExtension.substr (1); + std::cout << " An advanced, cross-platform program for developing raw photos." << std::endl; + std::cout << std::endl; + std::cout << " Website: http://www.rawtherapee.com/" << std::endl; + std::cout << " Documentation: http://rawpedia.rawtherapee.com/" << std::endl; + std::cout << " Forum: https://discuss.pixls.us/c/software/rawtherapee" << std::endl; + std::cout << " Code and bug reports: https://github.com/Beep6581/RawTherapee" << std::endl; + std::cout << std::endl; + std::cout << "Symbols:" << std::endl; + std::cout << " indicate parameters you can change." << std::endl; + std::cout << " [Square brackets] mean the parameter is optional." << std::endl; + std::cout << " The pipe symbol | indicates a choice of one or the other." << std::endl; + std::cout << " The dash symbol - denotes a range of possible values from one to the other." << std::endl; + std::cout << std::endl; + std::cout << "Usage:" << std::endl; + std::cout << " " << Glib::path_get_basename (argv[0]) << " -c | Convert files in batch with default parameters." << std::endl; + std::cout << " " << Glib::path_get_basename (argv[0]) << " -c | Convert files in batch with your own settings." << std::endl; + std::cout << std::endl; +#ifdef WIN32 + std::cout << " -w Do not open the Windows console" << std::endl; + std::cout << std::endl; +#endif + std::cout << "Options:" << std::endl; + std::cout << " " << Glib::path_get_basename (argv[0]) << "[-o |-O ] [-q] [-a] [-s|-S] [-p [-p ...] ] [-d] [ -j[1-100] [-js<1-3>] | [-b<8|16>] [-t[z] | [-n]] ] [-Y] [-f] -c " << std::endl; + std::cout << std::endl; + std::cout << " -c Specify one or more input files or directory." << std::endl; + std::cout << " When specifying directories, Rawtherapee will look for images files that comply with the" << std::endl; + std::cout << " selected extensions (see also '-a')." << std::endl; + std::cout << " -c must be the last option." << std::endl; + std::cout << " -o | Set output file or folder." << std::endl; + std::cout << " Saves output file alongside input file if -o is not specified." << std::endl; + std::cout << " -O | Set output file or folder and copy " << pparamsExt << " file into it." << std::endl; + std::cout << " Saves output file alongside input file if -O is not specified." << std::endl; + std::cout << " -q Quick-start mode. Does not load cached files to speedup start time." << std::endl; + std::cout << " -a Process all supported image file types when specifying a folder, even those" << std::endl; + std::cout << " not currently selected in Preferences > File Browser > Parsed Extensions." << std::endl; + std::cout << " -s Use the existing sidecar file to build the processing parameters," << std::endl; + std::cout << " e.g. for photo.raw there should be a photo.raw." << pparamsExt << " file in the same folder." << std::endl; + std::cout << " If the sidecar file does not exist, neutral values will be used." << std::endl; + std::cout << " -S Like -s but skip if the sidecar file does not exist." << std::endl; + std::cout << " -p Specify processing profile to be used for all conversions." << std::endl; + std::cout << " You can specify as many sets of \"-p \" options as you like," << std::endl; + std::cout << " each will be built on top of the previous one, as explained below." << std::endl; + std::cout << " -d Use the default raw or non-raw processing profile as set in" << std::endl; + std::cout << " Preferences > Image Processing > Default Processing Profile" << std::endl; + std::cout << " -j[1-100] Specify output to be JPEG (default, if -t and -n are not set)." << std::endl; + std::cout << " Optionally, specify compression 1-100 (default value: 92)." << std::endl; + std::cout << " -js<1-3> Specify the JPEG chroma subsampling parameter, where:" << std::endl; + std::cout << " 1 = Best compression: 2x2, 1x1, 1x1 (4:2:0)" << std::endl; + std::cout << " Chroma halved vertically and horizontally." << std::endl; + std::cout << " 2 = Balanced (default): 2x1, 1x1, 1x1 (4:2:2)" << std::endl; + std::cout << " Chroma halved horizontally." << std::endl; + std::cout << " 3 = Best quality: 1x1, 1x1, 1x1 (4:4:4)" << std::endl; + std::cout << " No chroma subsampling." << std::endl; + std::cout << " -b<8|16> Specify bit depth per channel (default value: 16 for TIFF, 8 for PNG)." << std::endl; + std::cout << " Only applies to TIFF and PNG output, JPEG is always 8." << std::endl; + std::cout << " -t[z] Specify output to be TIFF." << std::endl; + std::cout << " Uncompressed by default, or deflate compression with 'z'." << std::endl; + std::cout << " -n Specify output to be compressed PNG." << std::endl; + std::cout << " Compression is hard-coded to 6." << std::endl; + std::cout << " -Y Overwrite output if present." << std::endl; + std::cout << " -f Use the custom fast-export processing pipeline." << std::endl; + std::cout << std::endl; + std::cout << "Your " << pparamsExt << " files can be incomplete, RawTherapee will build the final values as follows:" << std::endl; + std::cout << " 1- A new processing profile is created using neutral values," << std::endl; + std::cout << " 2- If the \"-d\" option is set, the values are overridden by those found in" << std::endl; + std::cout << " the default raw or non-raw processing profile." << std::endl; + std::cout << " 3- If one or more \"-p\" options are set, the values are overridden by those" << std::endl; + std::cout << " found in these processing profiles." << std::endl; + std::cout << " 4- If the \"-s\" or \"-S\" options are set, the values are finally overridden by those" << std::endl; + std::cout << " found in the sidecar files." << std::endl; + std::cout << " The processing profiles are processed in the order specified on the command line." << std::endl; + return -1; } - - break; -#ifdef WIN32 - - case 'w': // This case is handled outside this function - break; -#endif - - case 'h': - case '?': - default: { - Glib::ustring pparamsExt = paramFileExtension.substr(1); - std::cout << " An advanced, cross-platform program for developing raw photos." << std::endl; - std::cout << std::endl; - std::cout << " Website: http://www.rawtherapee.com/" << std::endl; - std::cout << " Documentation: http://rawpedia.rawtherapee.com/" << std::endl; - std::cout << " Forum: https://discuss.pixls.us/c/software/rawtherapee" << std::endl; - std::cout << " Code and bug reports: https://github.com/Beep6581/RawTherapee" << std::endl; - std::cout << std::endl; - std::cout << "Symbols:" << std::endl; - std::cout << " indicate parameters you can change." << std::endl; - std::cout << " [Square brackets] mean the parameter is optional." << std::endl; - std::cout << " The pipe symbol | indicates a choice of one or the other." << std::endl; - std::cout << " The dash symbol - denotes a range of possible values from one to the other." << std::endl; - std::cout << std::endl; - std::cout << "Usage:" << std::endl; - std::cout << " " << Glib::path_get_basename(argv[0]) << " -c | Convert files in batch with default parameters." << std::endl; - std::cout << " " << Glib::path_get_basename(argv[0]) << " -c | Convert files in batch with your own settings." << std::endl; - std::cout << std::endl; -#ifdef WIN32 - std::cout << " -w Do not open the Windows console" << std::endl; - std::cout << std::endl; -#endif - std::cout << "Options:" << std::endl; - std::cout << " " << Glib::path_get_basename(argv[0]) << "[-o |-O ] [-q] [-a] [-s|-S] [-p [-p ...] ] [-d] [ -j[1-100] [-js<1-3>] | [-b<8|16>] [-t[z] | [-n]] ] [-Y] [-f] -c " << std::endl; - std::cout << std::endl; - std::cout << " -c Specify one or more input files or directory." << std::endl; - std::cout << " When specifying directories, Rawtherapee will look for images files that comply with the" << std::endl; - std::cout << " selected extensions (see also '-a')." << std::endl; - std::cout << " -c must be the last option." << std::endl; - std::cout << " -o | Set output file or folder." << std::endl; - std::cout << " Saves output file alongside input file if -o is not specified." << std::endl; - std::cout << " -O | Set output file or folder and copy " << pparamsExt << " file into it." << std::endl; - std::cout << " Saves output file alongside input file if -O is not specified." << std::endl; - std::cout << " -q Quick-start mode. Does not load cached files to speedup start time." << std::endl; - std::cout << " -a Process all supported image file types when specifying a folder, even those" << std::endl; - std::cout << " not currently selected in Preferences > File Browser > Parsed Extensions." << std::endl; - std::cout << " -s Use the existing sidecar file to build the processing parameters," << std::endl; - std::cout << " e.g. for photo.raw there should be a photo.raw." << pparamsExt << " file in the same folder." << std::endl; - std::cout << " If the sidecar file does not exist, neutral values will be used." << std::endl; - std::cout << " -S Like -s but skip if the sidecar file does not exist." << std::endl; - std::cout << " -p Specify processing profile to be used for all conversions." << std::endl; - std::cout << " You can specify as many sets of \"-p \" options as you like," << std::endl; - std::cout << " each will be built on top of the previous one, as explained below." << std::endl; - std::cout << " -d Use the default raw or non-raw processing profile as set in" << std::endl; - std::cout << " Preferences > Image Processing > Default Processing Profile" << std::endl; - std::cout << " -j[1-100] Specify output to be JPEG (default, if -t and -n are not set)." << std::endl; - std::cout << " Optionally, specify compression 1-100 (default value: 92)." << std::endl; - std::cout << " -js<1-3> Specify the JPEG chroma subsampling parameter, where:" << std::endl; - std::cout << " 1 = Best compression: 2x2, 1x1, 1x1 (4:2:0)" << std::endl; - std::cout << " Chroma halved vertically and horizontally." << std::endl; - std::cout << " 2 = Balanced (default): 2x1, 1x1, 1x1 (4:2:2)" << std::endl; - std::cout << " Chroma halved horizontally." << std::endl; - std::cout << " 3 = Best quality: 1x1, 1x1, 1x1 (4:4:4)" << std::endl; - std::cout << " No chroma subsampling." << std::endl; - std::cout << " -b<8|16> Specify bit depth per channel (default value: 16 for TIFF, 8 for PNG)." << std::endl; - std::cout << " Only applies to TIFF and PNG output, JPEG is always 8." << std::endl; - std::cout << " -t[z] Specify output to be TIFF." << std::endl; - std::cout << " Uncompressed by default, or deflate compression with 'z'." << std::endl; - std::cout << " -n Specify output to be compressed PNG." << std::endl; - std::cout << " Compression is hard-coded to 6." << std::endl; - std::cout << " -Y Overwrite output if present." << std::endl; - std::cout << " -f Use the custom fast-export processing pipeline." << std::endl; - std::cout << std::endl; - std::cout << "Your " << pparamsExt << " files can be incomplete, RawTherapee will build the final values as follows:" << std::endl; - std::cout << " 1- A new processing profile is created using neutral values," << std::endl; - std::cout << " 2- If the \"-d\" option is set, the values are overridden by those found in" << std::endl; - std::cout << " the default raw or non-raw processing profile." << std::endl; - std::cout << " 3- If one or more \"-p\" options are set, the values are overridden by those" << std::endl; - std::cout << " found in these processing profiles." << std::endl; - std::cout << " 4- If the \"-s\" or \"-S\" options are set, the values are finally overridden by those" << std::endl; - std::cout << " found in the sidecar files." << std::endl; - std::cout << " The processing profiles are processed in the order specified on the command line." << std::endl; - return -1; - } } } else { - argv1 = Glib::ustring(fname_to_utf8(argv[iArg])); + argv1 = Glib::ustring (fname_to_utf8 (argv[iArg])); #if ECLIPSE_ARGS - argv1 = argv1.substr(1, argv1.length()-2); + argv1 = argv1.substr (1, argv1.length() - 2); #endif - if( outputDirectory ) { + if ( outputDirectory ) { options.savePathFolder = outputPath; options.saveUsePathTemplate = false; } else { @@ -639,41 +651,41 @@ int processLineParams( int argc, char **argv ) } } - if( !argv1.empty() ) { + if ( !argv1.empty() ) { return 1; } - if( inputFiles.empty() ) { + if ( inputFiles.empty() ) { return 2; } if (useDefault) { - rawParams = new rtengine::procparams::PartialProfile(true, true); - Glib::ustring profPath = options.findProfilePath(options.defProfRaw); + rawParams = new rtengine::procparams::PartialProfile (true, true); + Glib::ustring profPath = options.findProfilePath (options.defProfRaw); - if (options.is_defProfRawMissing() || profPath.empty() || (profPath != DEFPROFILE_DYNAMIC && rawParams->load(profPath == DEFPROFILE_INTERNAL ? DEFPROFILE_INTERNAL : Glib::build_filename(profPath, Glib::path_get_basename(options.defProfRaw) + paramFileExtension)))) { + if (options.is_defProfRawMissing() || profPath.empty() || (profPath != DEFPROFILE_DYNAMIC && rawParams->load (profPath == DEFPROFILE_INTERNAL ? DEFPROFILE_INTERNAL : Glib::build_filename (profPath, Glib::path_get_basename (options.defProfRaw) + paramFileExtension)))) { std::cerr << "Error: default raw processing profile not found" << std::endl; rawParams->deleteInstance(); delete rawParams; - deleteProcParams(processingParams); + deleteProcParams (processingParams); return -3; } - imgParams = new rtengine::procparams::PartialProfile(true); - profPath = options.findProfilePath(options.defProfImg); + imgParams = new rtengine::procparams::PartialProfile (true); + profPath = options.findProfilePath (options.defProfImg); - if (options.is_defProfImgMissing() || profPath.empty() || (profPath != DEFPROFILE_DYNAMIC && imgParams->load(profPath == DEFPROFILE_INTERNAL ? DEFPROFILE_INTERNAL : Glib::build_filename(profPath, Glib::path_get_basename(options.defProfImg) + paramFileExtension)))) { + if (options.is_defProfImgMissing() || profPath.empty() || (profPath != DEFPROFILE_DYNAMIC && imgParams->load (profPath == DEFPROFILE_INTERNAL ? DEFPROFILE_INTERNAL : Glib::build_filename (profPath, Glib::path_get_basename (options.defProfImg) + paramFileExtension)))) { std::cerr << "Error: default non-raw processing profile not found" << std::endl; imgParams->deleteInstance(); delete imgParams; rawParams->deleteInstance(); delete rawParams; - deleteProcParams(processingParams); + deleteProcParams (processingParams); return -3; } } - for( size_t iFile = 0; iFile < inputFiles.size(); iFile++) { + for ( size_t iFile = 0; iFile < inputFiles.size(); iFile++) { // Has to be reinstanciated at each profile to have a ProcParams object with default values rtengine::procparams::ProcParams currentParams; @@ -688,34 +700,34 @@ int processLineParams( int argc, char **argv ) Glib::ustring outputFile; - if( outputType.empty() ) { + if ( outputType.empty() ) { outputType = "jpg"; } - if( outputPath.empty() ) { + if ( outputPath.empty() ) { Glib::ustring s = inputFile; - Glib::ustring::size_type ext = s.find_last_of('.'); - outputFile = s.substr(0, ext) + "." + outputType; - } else if( outputDirectory ) { - Glib::ustring s = Glib::path_get_basename( inputFile ); - Glib::ustring::size_type ext = s.find_last_of('.'); - outputFile = Glib::build_filename(outputPath, s.substr(0, ext) + "." + outputType); + Glib::ustring::size_type ext = s.find_last_of ('.'); + outputFile = s.substr (0, ext) + "." + outputType; + } else if ( outputDirectory ) { + Glib::ustring s = Glib::path_get_basename ( inputFile ); + Glib::ustring::size_type ext = s.find_last_of ('.'); + outputFile = Glib::build_filename (outputPath, s.substr (0, ext) + "." + outputType); } else { if (leaveUntouched) { outputFile = outputPath; } else { Glib::ustring s = outputPath; - Glib::ustring::size_type ext = s.find_last_of('.'); - outputFile = s.substr(0, ext) + "." + outputType; + Glib::ustring::size_type ext = s.find_last_of ('.'); + outputFile = s.substr (0, ext) + "." + outputType; } } - if( inputFile == outputFile) { + if ( inputFile == outputFile) { std::cerr << "Cannot overwrite: " << inputFile << std::endl; continue; } - if( !overwriteFiles && Glib::file_test( outputFile , Glib::FILE_TEST_EXISTS ) ) { + if ( !overwriteFiles && Glib::file_test ( outputFile, Glib::FILE_TEST_EXISTS ) ) { std::cerr << outputFile << " already exists: use -Y option to overwrite. This image has been skipped." << std::endl; continue; } @@ -741,18 +753,20 @@ int processLineParams( int argc, char **argv ) if (options.defProfRaw == DEFPROFILE_DYNAMIC) { rawParams->deleteInstance(); delete rawParams; - rawParams = ProfileStore::getInstance()->loadDynamicProfile(ii->getMetaData()); + rawParams = ProfileStore::getInstance()->loadDynamicProfile (ii->getMetaData()); } + std::cout << " Merging default raw processing profile" << std::endl; - rawParams->applyTo(¤tParams); - } else { + rawParams->applyTo (¤tParams); + } else { if (options.defProfImg == DEFPROFILE_DYNAMIC) { imgParams->deleteInstance(); delete imgParams; - imgParams = ProfileStore::getInstance()->loadDynamicProfile(ii->getMetaData()); + imgParams = ProfileStore::getInstance()->loadDynamicProfile (ii->getMetaData()); } + std::cout << " Merging default non-raw processing profile" << std::endl; - imgParams->applyTo(¤tParams); + imgParams->applyTo (¤tParams); } } @@ -766,7 +780,7 @@ int processLineParams( int argc, char **argv ) Glib::ustring sideProcessingParams = inputFile + paramFileExtension; // the "load" method don't reset the procparams values anymore, so values found in the procparam file override the one of currentParams - if( !Glib::file_test( sideProcessingParams, Glib::FILE_TEST_EXISTS ) || currentParams.load ( sideProcessingParams )) { + if ( !Glib::file_test ( sideProcessingParams, Glib::FILE_TEST_EXISTS ) || currentParams.load ( sideProcessingParams )) { std::cerr << "Warning: sidecar file requested but not found for: " << sideProcessingParams << std::endl; } else { sideCarFound = true; @@ -774,15 +788,15 @@ int processLineParams( int argc, char **argv ) } } - if( processingParams.size() > i ) { + if ( processingParams.size() > i ) { std::cout << " Merging procparams #" << i << std::endl; - processingParams[i]->applyTo(¤tParams); + processingParams[i]->applyTo (¤tParams); } i++; } while (i < processingParams.size() + (sideProcParams ? 1 : 0)); - if( sideProcParams && !sideCarFound && skipIfNoSidecar ) { + if ( sideProcParams && !sideCarFound && skipIfNoSidecar ) { delete ii; errors++; std::cerr << "Error: no sidecar procparams found for: " << inputFile << std::endl; @@ -791,7 +805,7 @@ int processLineParams( int argc, char **argv ) job = rtengine::ProcessingJob::create (ii, currentParams, fast_export); - if( !job ) { + if ( !job ) { errors++; std::cerr << "Error creating processing for: " << inputFile << std::endl; ii->decreaseRef(); @@ -801,31 +815,31 @@ int processLineParams( int argc, char **argv ) // Process image rtengine::IImage16* resultImage = rtengine::processImage (job, errorCode, nullptr, options.tunnelMetaData); - if( !resultImage ) { + if ( !resultImage ) { errors++; std::cerr << "Error processing: " << inputFile << std::endl; - rtengine::ProcessingJob::destroy( job ); + rtengine::ProcessingJob::destroy ( job ); continue; } // save image to disk - if( outputType == "jpg" ) { - errorCode = resultImage->saveAsJPEG( outputFile, compression, subsampling ); - } else if( outputType == "tif" ) { - errorCode = resultImage->saveAsTIFF( outputFile, bits, compression == 0 ); - } else if( outputType == "png" ) { - errorCode = resultImage->saveAsPNG( outputFile, compression, bits ); + if ( outputType == "jpg" ) { + errorCode = resultImage->saveAsJPEG ( outputFile, compression, subsampling ); + } else if ( outputType == "tif" ) { + errorCode = resultImage->saveAsTIFF ( outputFile, bits, compression == 0 ); + } else if ( outputType == "png" ) { + errorCode = resultImage->saveAsPNG ( outputFile, compression, bits ); } else { errorCode = resultImage->saveToFile (outputFile); } - if(errorCode) { + if (errorCode) { errors++; std::cerr << "Error saving to: " << outputFile << std::endl; } else { - if( copyParamsFile ) { + if ( copyParamsFile ) { Glib::ustring outputProcessingParams = outputFile + paramFileExtension; - currentParams.save( outputProcessingParams ); + currentParams.save ( outputProcessingParams ); } } @@ -843,7 +857,7 @@ int processLineParams( int argc, char **argv ) delete rawParams; } - deleteProcParams(processingParams); + deleteProcParams (processingParams); return errors > 0 ? -2 : 0; } diff --git a/rtgui/main.cc b/rtgui/main.cc index 731de81cd..f133c1e07 100644 --- a/rtgui/main.cc +++ b/rtgui/main.cc @@ -118,83 +118,89 @@ static void myGdkLockLeave() * -1 if there is an error in parameters * -2 if an error occurred during processing * -3 if at least one required procparam file was not found */ -int processLineParams( int argc, char **argv ) +int processLineParams ( int argc, char **argv ) { - for( int iArg = 1; iArg < argc; iArg++) { - Glib::ustring currParam(argv[iArg]); + for ( int iArg = 1; iArg < argc; iArg++) { + Glib::ustring currParam (argv[iArg]); #if ECLIPSE_ARGS - currParam = currParam.substr(1, currParam.length()-2); + currParam = currParam.substr (1, currParam.length() - 2); #endif - if( currParam.at(0) == '-' ) { - switch( currParam.at(1) ) { + + if ( currParam.at (0) == '-' ) { + switch ( currParam.at (1) ) { #ifdef WIN32 - case 'w': // This case is handled outside this function - break; + case 'w': // This case is handled outside this function + break; #endif - case 'v': - return 0; + + case 'v': + return 0; #ifndef __APPLE__ // TODO agriggio - there seems to be already some "single instance app" support for OSX in rtwindow. Disabling it here until I understand how to merge the two - case 'R': - if (!gimpPlugin) { - remote = true; - } - break; -#endif - - case 'g': - if (currParam == "-gimp") { - gimpPlugin = true; - simpleEditor = true; - remote = false; + + case 'R': + if (!gimpPlugin) { + remote = true; + } + break; - } +#endif + + case 'g': + if (currParam == "-gimp") { + gimpPlugin = true; + simpleEditor = true; + remote = false; + break; + } + // no break here on purpose - case 'h': - case '?': - default: { - Glib::ustring pparamsExt = paramFileExtension.substr(1); - std::cout << " An advanced, cross-platform program for developing raw photos." << std::endl; - std::cout << std::endl; - std::cout << " Website: http://www.rawtherapee.com/" << std::endl; - std::cout << " Documentation: http://rawpedia.rawtherapee.com/" << std::endl; - std::cout << " Forum: https://discuss.pixls.us/c/software/rawtherapee" << std::endl; - std::cout << " Code and bug reports: https://github.com/Beep6581/RawTherapee" << std::endl; - std::cout << std::endl; - std::cout << "Symbols:" << std::endl; - std::cout << " indicate parameters you can change." << std::endl; - //std::cout << " [Square brackets] mean the parameter is optional." << std::endl; - //std::cout << " The pipe symbol | indicates a choice of one or the other." << std::endl; - //std::cout << " The dash symbol - denotes a range of possible values from one to the other." << std::endl; - std::cout << std::endl; - std::cout << "Usage:" << std::endl; - std::cout << " " << Glib::path_get_basename(argv[0]) << " Start File Browser inside folder." << std::endl; - std::cout << " " << Glib::path_get_basename(argv[0]) << " Start Image Editor with file." << std::endl; - std::cout << std::endl; - std::cout << "Options:" << std::endl; + case 'h': + case '?': + default: { + Glib::ustring pparamsExt = paramFileExtension.substr (1); + std::cout << " An advanced, cross-platform program for developing raw photos." << std::endl; + std::cout << std::endl; + std::cout << " Website: http://www.rawtherapee.com/" << std::endl; + std::cout << " Documentation: http://rawpedia.rawtherapee.com/" << std::endl; + std::cout << " Forum: https://discuss.pixls.us/c/software/rawtherapee" << std::endl; + std::cout << " Code and bug reports: https://github.com/Beep6581/RawTherapee" << std::endl; + std::cout << std::endl; + std::cout << "Symbols:" << std::endl; + std::cout << " indicate parameters you can change." << std::endl; + //std::cout << " [Square brackets] mean the parameter is optional." << std::endl; + //std::cout << " The pipe symbol | indicates a choice of one or the other." << std::endl; + //std::cout << " The dash symbol - denotes a range of possible values from one to the other." << std::endl; + std::cout << std::endl; + std::cout << "Usage:" << std::endl; + std::cout << " " << Glib::path_get_basename (argv[0]) << " Start File Browser inside folder." << std::endl; + std::cout << " " << Glib::path_get_basename (argv[0]) << " Start Image Editor with file." << std::endl; + std::cout << std::endl; + std::cout << "Options:" << std::endl; #ifdef WIN32 - std::cout << " -w Do not open the Windows console" << std::endl; + std::cout << " -w Do not open the Windows console" << std::endl; #endif - std::cout << " -v Print RawTherapee version number and exit" << std::endl; + std::cout << " -v Print RawTherapee version number and exit" << std::endl; #ifndef __APPLE__ - std::cout << " -R Raise an already running RawTherapee instance (if available)" << std::endl; + std::cout << " -R Raise an already running RawTherapee instance (if available)" << std::endl; #endif - std::cout << " -h -? Display this help message" << std::endl; - return -1; - } + std::cout << " -h -? Display this help message" << std::endl; + return -1; + } } } else { if (argv1.empty()) { - argv1 = Glib::ustring(fname_to_utf8(argv[iArg])); + argv1 = Glib::ustring (fname_to_utf8 (argv[iArg])); #if ECLIPSE_ARGS - argv1 = argv1.substr(1, argv1.length()-2); + argv1 = argv1.substr (1, argv1.length() - 2); #endif } else if (gimpPlugin) { - argv2 = Glib::ustring(fname_to_utf8(argv[iArg])); + argv2 = Glib::ustring (fname_to_utf8 (argv[iArg])); break; } + if (!gimpPlugin) { break; } @@ -207,22 +213,25 @@ int processLineParams( int argc, char **argv ) bool init_rt() { - if (!Options::load ()) { + try { + Options::load(); + } catch (Options::Error &e) { + std::cout << "ERROR: " << e.get_msg() << std::endl; return false; } extProgStore->init(); SoundManager::init(); - if( !options.rtSettings.verbose ) { - TIFFSetWarningHandler(nullptr); // avoid annoying message boxes + if ( !options.rtSettings.verbose ) { + TIFFSetWarningHandler (nullptr); // avoid annoying message boxes } #ifndef WIN32 // Move the old path to the new one if the new does not exist - if (Glib::file_test(Glib::build_filename(options.rtdir, "cache"), Glib::FILE_TEST_IS_DIR) && !Glib::file_test(options.cacheBaseDir, Glib::FILE_TEST_IS_DIR)) { - g_rename(Glib::build_filename (options.rtdir, "cache").c_str (), options.cacheBaseDir.c_str ()); + if (Glib::file_test (Glib::build_filename (options.rtdir, "cache"), Glib::FILE_TEST_IS_DIR) && !Glib::file_test (options.cacheBaseDir, Glib::FILE_TEST_IS_DIR)) { + g_rename (Glib::build_filename (options.rtdir, "cache").c_str (), options.cacheBaseDir.c_str ()); } #endif @@ -239,11 +248,11 @@ void cleanup_rt() RTWindow *create_rt_window() { - Glib::ustring icon_path = Glib::build_filename(argv0, "images"); + Glib::ustring icon_path = Glib::build_filename (argv0, "images"); Glib::RefPtr defaultIconTheme = Gtk::IconTheme::get_default(); - defaultIconTheme->append_search_path(icon_path); + defaultIconTheme->append_search_path (icon_path); - rtengine::setPaths(options); + rtengine::setPaths (options); MyExpander::init(); // has to stay AFTER rtengine::setPaths // ------- loading theme files @@ -251,8 +260,8 @@ RTWindow *create_rt_window() Glib::RefPtr screen = Gdk::Screen::get_default(); if (screen) { - Gtk::Settings::get_for_screen(screen)->property_gtk_theme_name() = "Adwaita"; - Gtk::Settings::get_for_screen(screen)->property_gtk_application_prefer_dark_theme() = true; + Gtk::Settings::get_for_screen (screen)->property_gtk_theme_name() = "Adwaita"; + Gtk::Settings::get_for_screen (screen)->property_gtk_application_prefer_dark_theme() = true; #if defined(__APPLE__) // This will force screen resolution regarding font, but I don't think it's compliant with Gtk guidelines... @@ -260,7 +269,7 @@ RTWindow *create_rt_window() screen->set_resolution (96.); #endif - Glib::RefPtr regex = Glib::Regex::create(THEMEREGEXSTR, Glib::RegexCompileFlags::REGEX_CASELESS); + Glib::RefPtr regex = Glib::Regex::create (THEMEREGEXSTR, Glib::RegexCompileFlags::REGEX_CASELESS); Glib::ustring filename; Glib::MatchInfo mInfo; bool match = regex->match(options.theme + ".css", mInfo); @@ -286,23 +295,26 @@ RTWindow *create_rt_window() if (!match || !Glib::file_test(filename, Glib::FILE_TEST_EXISTS)) { options.theme = "RawTherapee-GTK"; + // We're not testing GTK_MAJOR_VERSION == 3 here, since this branch requires Gtk3 only if (GTK_MINOR_VERSION < 20) { options.theme = options.theme + "3-_19"; } else { options.theme = options.theme + "3-20_"; } - filename = Glib::build_filename(argv0, "themes", options.theme + ".css"); + + filename = Glib::build_filename (argv0, "themes", options.theme + ".css"); } + cssRT = Gtk::CssProvider::create(); try { cssRT->load_from_path (filename); - Gtk::StyleContext::add_provider_for_screen(screen, cssRT, GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); + Gtk::StyleContext::add_provider_for_screen (screen, cssRT, GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); } catch (Glib::Error &err) { - printf("Error: Can't load css file \"%s\"\nMessage: %s\n", filename.c_str(), err.what().c_str()); + printf ("Error: Can't load css file \"%s\"\nMessage: %s\n", filename.c_str(), err.what().c_str()); } catch (...) { - printf("Error: Can't load css file \"%s\"\n", filename.c_str()); + printf ("Error: Can't load css file \"%s\"\n", filename.c_str()); } // Set the font face and size @@ -311,23 +323,23 @@ RTWindow *create_rt_window() cssForced = Gtk::CssProvider::create(); //GTK318 #if GTK_MAJOR_VERSION == 3 && GTK_MINOR_VERSION < 20 - cssForced->load_from_data (Glib::ustring::compose("* { font-family: %1; font-size: %2px }", options.fontFamily, options.fontSize)); + cssForced->load_from_data (Glib::ustring::compose ("* { font-family: %1; font-size: %2px }", options.fontFamily, options.fontSize)); #else - cssForced->load_from_data (Glib::ustring::compose("* { font-family: %1; font-size: %2pt }", options.fontFamily, options.fontSize)); + cssForced->load_from_data (Glib::ustring::compose ("* { font-family: %1; font-size: %2pt }", options.fontFamily, options.fontSize)); #endif //GTK318 - Gtk::StyleContext::add_provider_for_screen(screen, cssForced, GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); + Gtk::StyleContext::add_provider_for_screen (screen, cssForced, GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); } catch (Glib::Error &err) { - printf("Error: \"%s\"\n", err.what().c_str()); + printf ("Error: \"%s\"\n", err.what().c_str()); } catch (...) { - printf("Error: Can't find the font named \"%s\"\n", options.fontFamily.c_str()); + printf ("Error: Can't find the font named \"%s\"\n", options.fontFamily.c_str()); } } } #ifndef NDEBUG else if (!screen) { - printf("ERROR: Can't get default screen!\n"); + printf ("ERROR: Can't get default screen!\n"); } #endif @@ -339,12 +351,12 @@ RTWindow *create_rt_window() // alerting users if the default raw and image profiles are missing if (options.is_defProfRawMissing()) { - Gtk::MessageDialog msgd (Glib::ustring::compose(M("OPTIONS_DEFRAW_MISSING"), options.defProfRaw), true, Gtk::MESSAGE_ERROR, Gtk::BUTTONS_OK, true); + Gtk::MessageDialog msgd (Glib::ustring::compose (M ("OPTIONS_DEFRAW_MISSING"), options.defProfRaw), true, Gtk::MESSAGE_ERROR, Gtk::BUTTONS_OK, true); msgd.run (); } if (options.is_defProfImgMissing()) { - Gtk::MessageDialog msgd (Glib::ustring::compose(M("OPTIONS_DEFIMG_MISSING"), options.defProfImg), true, Gtk::MESSAGE_ERROR, Gtk::BUTTONS_OK, true); + Gtk::MessageDialog msgd (Glib::ustring::compose (M ("OPTIONS_DEFIMG_MISSING"), options.defProfImg), true, Gtk::MESSAGE_ERROR, Gtk::BUTTONS_OK, true); msgd.run (); } @@ -352,12 +364,13 @@ RTWindow *create_rt_window() } -class RTApplication: public Gtk::Application { +class RTApplication: public Gtk::Application +{ public: RTApplication(): - Gtk::Application("com.rawtherapee.application", - Gio::APPLICATION_HANDLES_OPEN), - rtWindow(nullptr) + Gtk::Application ("com.rawtherapee.application", + Gio::APPLICATION_HANDLES_OPEN), + rtWindow (nullptr) { } @@ -366,6 +379,7 @@ public: if (rtWindow) { delete rtWindow; } + cleanup_rt(); } @@ -375,19 +389,19 @@ private: if (rtWindow) { return true; } - + if (!init_rt()) { Gtk::MessageDialog msgd ("Fatal error!\nThe RT_SETTINGS and/or RT_PATH environment variables are set, but use a relative path. The path must be absolute!", true, Gtk::MESSAGE_ERROR, Gtk::BUTTONS_OK, true); - add_window(msgd); + add_window (msgd); msgd.run (); return false; } else { rtWindow = create_rt_window(); - add_window(*rtWindow); + add_window (*rtWindow); return true; } } - + // Override default signal handlers: void on_activate() override { @@ -395,9 +409,9 @@ private: rtWindow->present(); } } - - void on_open(const Gio::Application::type_vec_files& files, - const Glib::ustring& hint) override + + void on_open (const Gio::Application::type_vec_files& files, + const Glib::ustring& hint) override { if (create_window()) { struct Data { @@ -407,29 +421,30 @@ private: }; Data *d = new Data; d->filecatalog = rtWindow->fpanel->fileCatalog; - + for (const auto &f : files) { - Thumbnail *thm = cacheMgr->getEntry(f->get_path()); + Thumbnail *thm = cacheMgr->getEntry (f->get_path()); + if (thm) { - d->entries.push_back(thm); + d->entries.push_back (thm); d->lastfilename = f->get_path(); } } - + if (!d->entries.empty()) { const auto doit = - [](gpointer data) -> gboolean - { - Data *d = static_cast(data); - d->filecatalog->openRequested(d->entries); - d->filecatalog->selectImage(d->lastfilename, true); - delete d; - return FALSE; - }; - gdk_threads_add_idle(doit, d); + [] (gpointer data) -> gboolean { + Data *d = static_cast (data); + d->filecatalog->openRequested (d->entries); + d->filecatalog->selectImage (d->lastfilename, true); + delete d; + return FALSE; + }; + gdk_threads_add_idle (doit, d); } else { delete d; } + rtWindow->present(); } } @@ -454,10 +469,10 @@ void show_gimp_plugin_info_dialog(Gtk::Window *parent) } // namespace -int main(int argc, char **argv) +int main (int argc, char **argv) { - setlocale(LC_ALL, ""); - setlocale(LC_NUMERIC, "C"); // to set decimal point to "." + setlocale (LC_ALL, ""); + setlocale (LC_NUMERIC, "C"); // to set decimal point to "." simpleEditor = false; gimpPlugin = false; @@ -467,7 +482,7 @@ int main(int argc, char **argv) argv2 = ""; Glib::init(); // called by Gtk::Main, but this may be important for thread handling, so we call it ourselves now - gdk_threads_set_lock_functions(G_CALLBACK(myGdkLockEnter), (G_CALLBACK(myGdkLockLeave))); + gdk_threads_set_lock_functions (G_CALLBACK (myGdkLockEnter), (G_CALLBACK (myGdkLockLeave))); gdk_threads_init(); gtk_init (&argc, &argv); // use the "--g-fatal-warnings" command line flag to make warnings fatal Gio::init (); @@ -480,33 +495,33 @@ int main(int argc, char **argv) #ifdef WIN32 WCHAR exnameU[512] = {0}; GetModuleFileNameW (NULL, exnameU, 511); - WideCharToMultiByte(CP_UTF8, 0, exnameU, -1, exname, 511, 0, 0 ); + WideCharToMultiByte (CP_UTF8, 0, exnameU, -1, exname, 511, 0, 0 ); #else - if (readlink("/proc/self/exe", exname, 511) < 0) { - strncpy(exname, argv[0], 511); + if (readlink ("/proc/self/exe", exname, 511) < 0) { + strncpy (exname, argv[0], 511); } #endif - exePath = Glib::path_get_dirname(exname); + exePath = Glib::path_get_dirname (exname); // set paths - if (Glib::path_is_absolute(DATA_SEARCH_PATH)) { + if (Glib::path_is_absolute (DATA_SEARCH_PATH)) { argv0 = DATA_SEARCH_PATH; } else { - argv0 = Glib::build_filename(exePath, DATA_SEARCH_PATH); + argv0 = Glib::build_filename (exePath, DATA_SEARCH_PATH); } - if (Glib::path_is_absolute(CREDITS_SEARCH_PATH)) { + if (Glib::path_is_absolute (CREDITS_SEARCH_PATH)) { creditsPath = CREDITS_SEARCH_PATH; } else { - creditsPath = Glib::build_filename(exePath, CREDITS_SEARCH_PATH); + creditsPath = Glib::build_filename (exePath, CREDITS_SEARCH_PATH); } - if (Glib::path_is_absolute(LICENCE_SEARCH_PATH)) { + if (Glib::path_is_absolute (LICENCE_SEARCH_PATH)) { licensePath = LICENCE_SEARCH_PATH; } else { - licensePath = Glib::build_filename(exePath, LICENCE_SEARCH_PATH); + licensePath = Glib::build_filename (exePath, LICENCE_SEARCH_PATH); } #else @@ -514,60 +529,61 @@ int main(int argc, char **argv) creditsPath = CREDITS_SEARCH_PATH; licensePath = LICENCE_SEARCH_PATH; #endif - - + + #ifdef WIN32 bool consoleOpened = false; // suppression of annoying error boxes - SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX); + SetErrorMode (SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX); + + if (argc > 1) { + int ret = processLineParams ( argc, argv); - if(argc > 1) { - int ret = processLineParams( argc, argv); if (options.rtSettings.verbose || (!remote && !Glib::file_test (argv1, Glib::FILE_TEST_EXISTS ) && !Glib::file_test (argv1, Glib::FILE_TEST_IS_DIR))) { - bool stdoutRedirectedtoFile = (GetFileType(GetStdHandle(STD_OUTPUT_HANDLE)) == 0x0001); - bool stderrRedirectedtoFile = (GetFileType(GetStdHandle(STD_ERROR_HANDLE)) == 0x0001); + bool stdoutRedirectedtoFile = (GetFileType (GetStdHandle (STD_OUTPUT_HANDLE)) == 0x0001); + bool stderrRedirectedtoFile = (GetFileType (GetStdHandle (STD_ERROR_HANDLE)) == 0x0001); // no console, if stdout and stderr both are redirected to file - if( !(stdoutRedirectedtoFile && stderrRedirectedtoFile)) { + if ( ! (stdoutRedirectedtoFile && stderrRedirectedtoFile)) { // check if parameter -w was passed. // We have to do that in this step, because it controls whether to open a console to show the output of following steps bool Console = true; - for(int i = 1; i < argc; i++) - if(!strcmp(argv[i], "-w")) { + for (int i = 1; i < argc; i++) + if (!strcmp (argv[i], "-w")) { Console = false; break; } - if(Console && AllocConsole()) { - AttachConsole( GetCurrentProcessId() ) ; + if (Console && AllocConsole()) { + AttachConsole ( GetCurrentProcessId() ) ; // Don't allow CTRL-C in console to terminate RT - SetConsoleCtrlHandler( NULL, true ); + SetConsoleCtrlHandler ( NULL, true ); // Set title of console char consoletitle[128]; - sprintf(consoletitle, "RawTherapee %s Console", RTVERSION); - SetConsoleTitle(consoletitle); + sprintf (consoletitle, "RawTherapee %s Console", RTVERSION); + SetConsoleTitle (consoletitle); // increase size of screen buffer COORD c; c.X = 200; c.Y = 1000; - SetConsoleScreenBufferSize( GetStdHandle( STD_OUTPUT_HANDLE ), c ); + SetConsoleScreenBufferSize ( GetStdHandle ( STD_OUTPUT_HANDLE ), c ); // Disable console-Cursor CONSOLE_CURSOR_INFO cursorInfo; cursorInfo.dwSize = 100; cursorInfo.bVisible = false; - SetConsoleCursorInfo( GetStdHandle( STD_OUTPUT_HANDLE ), &cursorInfo ); + SetConsoleCursorInfo ( GetStdHandle ( STD_OUTPUT_HANDLE ), &cursorInfo ); - if(!stdoutRedirectedtoFile) { - freopen( "CON", "w", stdout ) ; + if (!stdoutRedirectedtoFile) { + freopen ( "CON", "w", stdout ) ; } - if(!stderrRedirectedtoFile) { - freopen( "CON", "w", stderr ) ; + if (!stderrRedirectedtoFile) { + freopen ( "CON", "w", stderr ) ; } - freopen( "CON", "r", stdin ) ; + freopen ( "CON", "r", stdin ) ; consoleOpened = true; @@ -578,10 +594,10 @@ int main(int argc, char **argv) } } - if( ret <= 0 ) { - if(consoleOpened) { - printf("Press any key to exit RawTherapee\n"); - FlushConsoleInputBuffer(GetStdHandle(STD_INPUT_HANDLE)); + if ( ret <= 0 ) { + if (consoleOpened) { + printf ("Press any key to exit RawTherapee\n"); + FlushConsoleInputBuffer (GetStdHandle (STD_INPUT_HANDLE)); getch(); } @@ -599,9 +615,9 @@ int main(int argc, char **argv) #endif if (argc > 1) { - int ret = processLineParams( argc, argv); + int ret = processLineParams ( argc, argv); - if( ret <= 0 ) { + if ( ret <= 0 ) { return ret; } } @@ -610,54 +626,59 @@ int main(int argc, char **argv) #endif if (gimpPlugin) { - if (!Glib::file_test(argv1, Glib::FILE_TEST_EXISTS) || Glib::file_test(argv1, Glib::FILE_TEST_IS_DIR)) { - printf("Error: argv1 doesn't exist\n"); + if (!Glib::file_test (argv1, Glib::FILE_TEST_EXISTS) || Glib::file_test (argv1, Glib::FILE_TEST_IS_DIR)) { + printf ("Error: argv1 doesn't exist\n"); return 1; } + if (argv2.empty()) { - printf("Error: -gimp requires two arguments\n"); + printf ("Error: -gimp requires two arguments\n"); return 1; } - } else if (!remote && Glib::file_test(argv1, Glib::FILE_TEST_EXISTS)) { + } else if (!remote && Glib::file_test (argv1, Glib::FILE_TEST_EXISTS)) { simpleEditor = true; } int ret = 0; + if (remote) { - char *app_argv[2] = { const_cast(argv0.c_str()) }; + char *app_argv[2] = { const_cast (argv0.c_str()) }; int app_argc = 1; + if (!argv1.empty()) { app_argc = 2; - app_argv[1] = const_cast(argv1.c_str()); + app_argv[1] = const_cast (argv1.c_str()); } + RTApplication app; - ret = app.run(app_argc, app_argv); + ret = app.run (app_argc, app_argv); } else { if (init_rt()) { - Gtk::Main m(&argc, &argv); + Gtk::Main m (&argc, &argv); gdk_threads_enter(); - const std::unique_ptr rtWindow(create_rt_window()); + const std::unique_ptr rtWindow (create_rt_window()); if (gimpPlugin) { show_gimp_plugin_info_dialog(rtWindow.get()); } - m.run(*rtWindow); + m.run (*rtWindow); gdk_threads_leave(); if (gimpPlugin && - rtWindow->epanel && rtWindow->epanel->isRealized()) { + rtWindow->epanel && rtWindow->epanel->isRealized()) { SaveFormat sf; sf.format = "tif"; sf.tiffBits = 16; sf.tiffUncompressed = true; sf.saveParams = true; - - if (!rtWindow->epanel->saveImmediately(argv2, sf)) { + + if (!rtWindow->epanel->saveImmediately (argv2, sf)) { ret = -2; } } + cleanup_rt(); } else { - Gtk::Main m(&argc, &argv); + Gtk::Main m (&argc, &argv); Gtk::MessageDialog msgd ("Fatal error!\nThe RT_SETTINGS and/or RT_PATH environment variables are set, but use a relative path. The path must be absolute!", true, Gtk::MESSAGE_ERROR, Gtk::BUTTONS_OK, true); msgd.run (); ret = -2; @@ -667,8 +688,8 @@ int main(int argc, char **argv) #ifdef WIN32 if (consoleOpened) { - printf("Press any key to exit RawTherapee\n"); - FlushConsoleInputBuffer(GetStdHandle(STD_INPUT_HANDLE)); + printf ("Press any key to exit RawTherapee\n"); + FlushConsoleInputBuffer (GetStdHandle (STD_INPUT_HANDLE)); getch(); } diff --git a/rtgui/options.cc b/rtgui/options.cc index 7293a3a63..05586208a 100644 --- a/rtgui/options.cc +++ b/rtgui/options.cc @@ -744,14 +744,15 @@ void Options::filterOutParsedExtensions () } } -int Options::readFromFile (Glib::ustring fname) +void Options::readFromFile (Glib::ustring fname) { setlocale (LC_NUMERIC, "C"); // to set decimal point to "." Glib::KeyFile keyFile; if ( !Glib::file_test (fname, Glib::FILE_TEST_EXISTS)) { - return 1; + Glib::ustring msg = Glib::ustring::compose ("Options file %1 does not exist", fname); + throw Error (msg); } try { @@ -1866,21 +1867,26 @@ int Options::readFromFile (Glib::ustring fname) filterOutParsedExtensions (); - return 0; + return; } } catch (Glib::Error &err) { + Glib::ustring msg = Glib::ustring::compose ("Options::readFromFile / Error code %1 while reading values from \"%2\":\n%3", err.code(), fname, err.what()); + if (options.rtSettings.verbose) { - printf ("Options::readFromFile / Error code %d while reading values from \"%s\":\n%s\n", err.code(), fname.c_str(), err.what().c_str()); + printf ("%s\n", msg.c_str()); } + + throw Error (msg); } catch (...) { + Glib::ustring msg = Glib::ustring::compose ("Options::readFromFile / Unknown exception while trying to load \"%1\"!", fname); + if (options.rtSettings.verbose) { - printf ("Options::readFromFile / Unknown exception while trying to load \"%s\"!\n", fname.c_str()); + printf ("%s\n", msg.c_str()); } + + throw Error (msg); } - - return 1; - } bool Options::safeDirGet (const Glib::KeyFile& keyFile, const Glib::ustring& section, @@ -1898,7 +1904,7 @@ bool Options::safeDirGet (const Glib::KeyFile& keyFile, const Glib::ustring& sec return false; } -int Options::saveToFile (Glib::ustring fname) +void Options::saveToFile (Glib::ustring fname) { Glib::ustring keyData; @@ -2229,31 +2235,23 @@ int Options::saveToFile (Glib::ustring fname) keyData = keyFile.to_data (); - } catch (Glib::KeyFileError&) {} - - if (keyData.empty ()) { - return 1; + } catch (Glib::KeyFileError &e) { + throw Error (e.what()); } FILE *f = g_fopen (fname.c_str (), "wt"); if (f == nullptr) { std::cout << "Warning! Unable to save your preferences to: " << fname << std::endl; -#ifndef RAWTHERAPEE_CLI Glib::ustring msg_ = Glib::ustring::compose (M ("MAIN_MSG_WRITEFAILED"), fname.c_str()); - //writeFailed (getToplevelWindow (this), msg_); - Gtk::MessageDialog msgd (msg_, true, Gtk::MESSAGE_WARNING, Gtk::BUTTONS_CLOSE, true); - msgd.run (); -#endif - return 1; + throw Error (msg_); } else { fprintf (f, "%s", keyData.c_str ()); fclose (f); - return 0; } } -bool Options::load (bool lightweight) +void Options::load (bool lightweight) { // Find the application data path @@ -2267,7 +2265,8 @@ bool Options::load (bool lightweight) rtdir = Glib::ustring (path); if (!Glib::path_is_absolute (rtdir)) { - return false; + Glib::ustring msg = Glib::ustring::compose ("Settings path %1 is not absolute", rtdir); + throw Error (msg); } } else { #ifdef WIN32 @@ -2292,7 +2291,11 @@ bool Options::load (bool lightweight) cacheBaseDir = Glib::build_filename (argv0, "cache"); // Read the global option file (the one located in the application's base folder) - options.readFromFile (Glib::build_filename (argv0, "options")); + try { + options.readFromFile (Glib::build_filename (argv0, "options")); + } catch (Options::Error &) { + // ignore errors here + } // Modify the path of the cache folder to the one provided in RT_CACHE environment variable path = g_getenv ("RT_CACHE"); @@ -2301,7 +2304,8 @@ bool Options::load (bool lightweight) cacheBaseDir = Glib::ustring (path); if (!Glib::path_is_absolute (cacheBaseDir)) { - return false; + Glib::ustring msg = Glib::ustring::compose ("Cache base dir %1 is not absolute", cacheBaseDir); + throw Error (msg); } } // No environment variable provided, so falling back to the multi user mode, is enabled @@ -2317,12 +2321,14 @@ bool Options::load (bool lightweight) if (options.multiUser) { // Read the user option file (the one located somewhere in the user's home folder) // Those values supersets those of the global option file - int r = options.readFromFile (Glib::build_filename (rtdir, "options")); - - // If the local option file does not exist or is broken, and the local cache folder does not exist, recreate it - if (r && !g_mkdir_with_parents (rtdir.c_str (), 511)) { - // Save the option file - options.saveToFile (Glib::build_filename (rtdir, "options")); + try { + options.readFromFile (Glib::build_filename (rtdir, "options")); + } catch (Options::Error &) { + // If the local option file does not exist or is broken, and the local cache folder does not exist, recreate it + if (!g_mkdir_with_parents (rtdir.c_str (), 511)) { + // Save the option file + options.saveToFile (Glib::build_filename (rtdir, "options")); + } } #ifdef __APPLE__ @@ -2415,8 +2421,6 @@ bool Options::load (bool lightweight) langMgr.load (localeTranslation, new MultiLangMgr (languageTranslation, new MultiLangMgr (defaultTranslation))); rtengine::init (&options.rtSettings, argv0, rtdir, !lightweight); - - return true; } void Options::save () diff --git a/rtgui/options.h b/rtgui/options.h index 13025ee7c..3f7e2fb94 100644 --- a/rtgui/options.h +++ b/rtgui/options.h @@ -21,6 +21,7 @@ #include #include "../rtengine/rtengine.h" +#include #define STARTUPDIR_CURRENT 0 #define STARTUPDIR_HOME 1 @@ -42,17 +43,16 @@ // Special name for the Dynamic profile #define DEFPROFILE_DYNAMIC "Dynamic" -struct SaveFormat -{ +struct SaveFormat { SaveFormat() : - format("jpg"), - pngBits(8), - pngCompression(6), - jpegQuality(90), - jpegSubSamp(2), - tiffBits(8), - tiffUncompressed(true), - saveParams(true) + format ("jpg"), + pngBits (8), + pngCompression (6), + jpegQuality (90), + jpegSubSamp (2), + tiffBits (8), + tiffUncompressed (true), + saveParams (true) { } @@ -73,14 +73,31 @@ enum prevdemo_t {PD_Sidecar = 1, PD_Fast = 0}; class Options { +public: + class Error: public std::exception + { + public: + Error (const Glib::ustring &msg): msg_ (msg) {} + const char *what() const throw() + { + return msg_.c_str(); + } + const Glib::ustring &get_msg() const throw() + { + return msg_; + } + + private: + Glib::ustring msg_; + }; private: bool defProfRawMissing; bool defProfImgMissing; Glib::ustring userProfilePath; Glib::ustring globalProfilePath; - bool checkProfilePath(Glib::ustring &path); - bool checkDirPath(Glib::ustring &path, Glib::ustring errString); + bool checkProfilePath (Glib::ustring &path); + bool checkDirPath (Glib::ustring &path, Glib::ustring errString); void updatePaths(); int getString (const char* src, char* dst); void error (int line); @@ -95,8 +112,8 @@ private: * @param destination destination variable to store to * @return @c true if @p destination was changed */ - bool safeDirGet(const Glib::KeyFile& keyFile, const Glib::ustring& section, - const Glib::ustring& entryName, Glib::ustring& destination); + bool safeDirGet (const Glib::KeyFile& keyFile, const Glib::ustring& section, + const Glib::ustring& entryName, Glib::ustring& destination); public: @@ -326,10 +343,10 @@ public: Options* copyFrom (Options* other); void filterOutParsedExtensions (); void setDefaults (); - int readFromFile (Glib::ustring fname); - int saveToFile (Glib::ustring fname); - static bool load (bool lightweight = false); - static void save (); + void readFromFile (Glib::ustring fname); + void saveToFile (Glib::ustring fname); + static void load (bool lightweight = false); + static void save(); // if multiUser=false, send back the global profile path Glib::ustring getPreferredProfilePath(); @@ -341,10 +358,10 @@ public: { return globalProfilePath; } - Glib::ustring findProfilePath(Glib::ustring &profName); + Glib::ustring findProfilePath (Glib::ustring &profName); bool is_parse_extention (Glib::ustring fname); bool has_retained_extention (Glib::ustring fname); - bool is_extention_enabled(Glib::ustring ext); + bool is_extention_enabled (Glib::ustring ext); bool is_defProfRawMissing() { return defProfRawMissing; @@ -353,11 +370,11 @@ public: { return defProfImgMissing; } - void setDefProfRawMissing(bool value) + void setDefProfRawMissing (bool value) { defProfRawMissing = value; } - void setDefProfImgMissing(bool value) + void setDefProfImgMissing (bool value) { defProfImgMissing = value; } diff --git a/rtgui/preferences.cc b/rtgui/preferences.cc index f0f35300f..2aa7ef9a9 100644 --- a/rtgui/preferences.cc +++ b/rtgui/preferences.cc @@ -2103,7 +2103,14 @@ void Preferences::okPressed () workflowUpdate(); options.copyFrom (&moptions); options.filterOutParsedExtensions(); - Options::save (); + + try { + Options::save (); + } catch (Options::Error &e) { + Gtk::MessageDialog msgd (getToplevelWindow (this), e.get_msg(), true, Gtk::MESSAGE_WARNING, Gtk::BUTTONS_CLOSE, true); + msgd.run(); + } + dynProfilePanel->save(); hide (); } diff --git a/rtgui/rtwindow.cc b/rtgui/rtwindow.cc index c51d1b7f0..6f6388dd1 100644 --- a/rtgui/rtwindow.cc +++ b/rtgui/rtwindow.cc @@ -32,27 +32,27 @@ static gboolean osx_should_quit_cb (GtkosxApplication *app, gpointer data) { RTWindow *rtWin = (RTWindow *)data; - return rtWin->on_delete_event(0); + return rtWin->on_delete_event (0); } static void osx_will_quit_cb (GtkosxApplication *app, gpointer data) { RTWindow *rtWin = (RTWindow *)data; - rtWin->on_delete_event(0); + rtWin->on_delete_event (0); gtk_main_quit (); } -bool RTWindow::osxFileOpenEvent(Glib::ustring path) +bool RTWindow::osxFileOpenEvent (Glib::ustring path) { CacheManager* cm = CacheManager::getInstance(); - Thumbnail* thm = cm->getEntry( path ); + Thumbnail* thm = cm->getEntry ( path ); - if(thm && fpanel) { + if (thm && fpanel) { std::vector entries; - entries.push_back(thm); - fpanel->fileCatalog->openRequested(entries); + entries.push_back (thm); + fpanel->fileCatalog->openRequested (entries); return true; } @@ -69,25 +69,25 @@ osx_open_file_cb (GtkosxApplication *app, gchar *path_, gpointer data) return false; } - Glib::ustring path = Glib::ustring(path_); - Glib::ustring suffix = path.length() > 4 ? path.substr(path.length() - 3) : ""; + Glib::ustring path = Glib::ustring (path_); + Glib::ustring suffix = path.length() > 4 ? path.substr (path.length() - 3) : ""; suffix = suffix.lowercase(); if (suffix == "pp3") { - path = path.substr(0, path.length() - 4); + path = path.substr (0, path.length() - 4); } - return rtWin->osxFileOpenEvent(path); + return rtWin->osxFileOpenEvent (path); } #endif // __APPLE__ RTWindow::RTWindow () - : mainNB(nullptr) - , bpanel(nullptr) - , splash(nullptr) - , btn_fullscreen(nullptr) - , epanel(nullptr) - , fpanel(nullptr) + : mainNB (nullptr) + , bpanel (nullptr) + , splash (nullptr) + , btn_fullscreen (nullptr) + , epanel (nullptr) + , fpanel (nullptr) { cacheMgr->init (); @@ -95,11 +95,11 @@ RTWindow::RTWindow () ProfilePanel::init (this); Glib::ustring fName = "rt-logo-small.png"; - Glib::ustring fullPath = rtengine::findIconAbsolutePath(fName); + Glib::ustring fullPath = rtengine::findIconAbsolutePath (fName); try { set_default_icon_from_file (fullPath); - } catch(Glib::Exception& ex) { + } catch (Glib::Exception& ex) { printf ("%s\n", ex.what().c_str()); } @@ -122,55 +122,57 @@ RTWindow::RTWindow () #endif versionStr = "RawTherapee " + versionString; - set_title_decorated(""); - set_resizable(true); - set_decorated(true); - set_default_size(options.windowWidth, options.windowHeight); - set_modal(false); + set_title_decorated (""); + set_resizable (true); + set_decorated (true); + set_default_size (options.windowWidth, options.windowHeight); + set_modal (false); Gdk::Rectangle lMonitorRect; - get_screen()->get_monitor_geometry(std::min(options.windowMonitor, Gdk::Screen::get_default()->get_n_monitors() - 1), lMonitorRect); + get_screen()->get_monitor_geometry (std::min (options.windowMonitor, Gdk::Screen::get_default()->get_n_monitors() - 1), lMonitorRect); + if (options.windowMaximized) { - move(lMonitorRect.get_x(), lMonitorRect.get_y()); + move (lMonitorRect.get_x(), lMonitorRect.get_y()); maximize(); } else { unmaximize(); - resize(options.windowWidth, options.windowHeight); - if(options.windowX <= lMonitorRect.get_x() + lMonitorRect.get_width() && options.windowY <= lMonitorRect.get_y() + lMonitorRect.get_height()) { - move(options.windowX, options.windowY); + resize (options.windowWidth, options.windowHeight); + + if (options.windowX <= lMonitorRect.get_x() + lMonitorRect.get_width() && options.windowY <= lMonitorRect.get_y() + lMonitorRect.get_height()) { + move (options.windowX, options.windowY); } else { - move(lMonitorRect.get_x(), lMonitorRect.get_y()); + move (lMonitorRect.get_x(), lMonitorRect.get_y()); } } on_delete_has_run = false; is_fullscreen = false; - property_destroy_with_parent().set_value(false); - signal_window_state_event().connect( sigc::mem_fun(*this, &RTWindow::on_window_state_event) ); - signal_key_press_event().connect( sigc::mem_fun(*this, &RTWindow::keyPressed) ); + property_destroy_with_parent().set_value (false); + signal_window_state_event().connect ( sigc::mem_fun (*this, &RTWindow::on_window_state_event) ); + signal_key_press_event().connect ( sigc::mem_fun (*this, &RTWindow::keyPressed) ); - if(simpleEditor) { - epanel = Gtk::manage( new EditorPanel (nullptr) ); + if (simpleEditor) { + epanel = Gtk::manage ( new EditorPanel (nullptr) ); epanel->setParent (this); - epanel->setParentWindow(this); + epanel->setParentWindow (this); add (*epanel); show_all (); pldBridge = nullptr; // No progress listener CacheManager* cm = CacheManager::getInstance(); - Thumbnail* thm = cm->getEntry( argv1 ); + Thumbnail* thm = cm->getEntry ( argv1 ); - if(thm) { + if (thm) { int error; - rtengine::InitialImage *ii = rtengine::InitialImage::load(argv1, thm->getType() == FT_Raw, &error, nullptr); - epanel->open( thm, ii ); + rtengine::InitialImage *ii = rtengine::InitialImage::load (argv1, thm->getType() == FT_Raw, &error, nullptr); + epanel->open ( thm, ii ); } } else { mainNB = Gtk::manage (new Gtk::Notebook ()); mainNB->set_name ("MainNotebook"); mainNB->set_scrollable (true); - mainNB->signal_switch_page().connect_notify( sigc::mem_fun(*this, &RTWindow::on_mainNB_switch_page) ); + mainNB->signal_switch_page().connect_notify ( sigc::mem_fun (*this, &RTWindow::on_mainNB_switch_page) ); // Editor panel fpanel = new FilePanel () ; @@ -178,20 +180,20 @@ RTWindow::RTWindow () // decorate tab Gtk::Grid* fpanelLabelGrid = Gtk::manage (new Gtk::Grid ()); - setExpandAlignProperties(fpanelLabelGrid, false, false, Gtk::ALIGN_CENTER, Gtk::ALIGN_CENTER); - Gtk::Label* fpl = Gtk::manage (new Gtk::Label( Glib::ustring(" ") + M("MAIN_FRAME_EDITOR") )); + setExpandAlignProperties (fpanelLabelGrid, false, false, Gtk::ALIGN_CENTER, Gtk::ALIGN_CENTER); + Gtk::Label* fpl = Gtk::manage (new Gtk::Label ( Glib::ustring (" ") + M ("MAIN_FRAME_EDITOR") )); if (options.mainNBVertical) { mainNB->set_tab_pos (Gtk::POS_LEFT); fpl->set_angle (90); - fpanelLabelGrid->attach_next_to(*Gtk::manage (new RTImage ("gtk-directory.png")), Gtk::POS_TOP, 1, 1); - fpanelLabelGrid->attach_next_to(*fpl, Gtk::POS_TOP, 1, 1); + fpanelLabelGrid->attach_next_to (*Gtk::manage (new RTImage ("gtk-directory.png")), Gtk::POS_TOP, 1, 1); + fpanelLabelGrid->attach_next_to (*fpl, Gtk::POS_TOP, 1, 1); } else { - fpanelLabelGrid->attach_next_to(*Gtk::manage (new RTImage ("gtk-directory.png")), Gtk::POS_RIGHT, 1, 1); - fpanelLabelGrid->attach_next_to(*fpl, Gtk::POS_RIGHT, 1, 1); + fpanelLabelGrid->attach_next_to (*Gtk::manage (new RTImage ("gtk-directory.png")), Gtk::POS_RIGHT, 1, 1); + fpanelLabelGrid->attach_next_to (*fpl, Gtk::POS_RIGHT, 1, 1); } - fpanelLabelGrid->set_tooltip_markup (M("MAIN_FRAME_FILEBROWSER_TOOLTIP")); + fpanelLabelGrid->set_tooltip_markup (M ("MAIN_FRAME_FILEBROWSER_TOOLTIP")); fpanelLabelGrid->show_all (); mainNB->append_page (*fpanel, *fpanelLabelGrid); @@ -200,16 +202,16 @@ RTWindow::RTWindow () bpanel = Gtk::manage ( new BatchQueuePanel (fpanel->fileCatalog) ); // decorate tab, the label is unimportant since its updated in batchqueuepanel anyway - Gtk::Label* lbq = Gtk::manage ( new Gtk::Label (M("MAIN_FRAME_BATCHQUEUE")) ); + Gtk::Label* lbq = Gtk::manage ( new Gtk::Label (M ("MAIN_FRAME_BATCHQUEUE")) ); if (options.mainNBVertical) { - lbq->set_angle(90); + lbq->set_angle (90); } mainNB->append_page (*bpanel, *lbq); - if(isSingleTabMode()) { + if (isSingleTabMode()) { createSetmEditor(); } @@ -225,46 +227,46 @@ RTWindow::RTWindow () //Gtk::LinkButton* rtWeb = Gtk::manage (new Gtk::LinkButton ("http://rawtherapee.com")); // unused... but fail to be linked anyway !? //Gtk::Button* preferences = Gtk::manage (new Gtk::Button (M("MAIN_BUTTON_PREFERENCES")+"...")); Gtk::Button* preferences = Gtk::manage (new Gtk::Button ()); - setExpandAlignProperties(preferences, false, false, Gtk::ALIGN_CENTER, Gtk::ALIGN_CENTER); - preferences->set_image (*Gtk::manage(new RTImage ("gtk-preferences.png"))); - preferences->set_tooltip_markup (M("MAIN_BUTTON_PREFERENCES")); - preferences->signal_clicked().connect( sigc::mem_fun(*this, &RTWindow::showPreferences) ); + setExpandAlignProperties (preferences, false, false, Gtk::ALIGN_CENTER, Gtk::ALIGN_CENTER); + preferences->set_image (*Gtk::manage (new RTImage ("gtk-preferences.png"))); + preferences->set_tooltip_markup (M ("MAIN_BUTTON_PREFERENCES")); + preferences->signal_clicked().connect ( sigc::mem_fun (*this, &RTWindow::showPreferences) ); //btn_fullscreen = Gtk::manage( new Gtk::Button(M("MAIN_BUTTON_FULLSCREEN"))); - btn_fullscreen = Gtk::manage( new Gtk::Button()); - setExpandAlignProperties(btn_fullscreen, false, false, Gtk::ALIGN_CENTER, Gtk::ALIGN_CENTER); - btn_fullscreen->set_tooltip_markup (M("MAIN_BUTTON_FULLSCREEN")); + btn_fullscreen = Gtk::manage ( new Gtk::Button()); + setExpandAlignProperties (btn_fullscreen, false, false, Gtk::ALIGN_CENTER, Gtk::ALIGN_CENTER); + btn_fullscreen->set_tooltip_markup (M ("MAIN_BUTTON_FULLSCREEN")); btn_fullscreen->set_image (*iFullscreen); - btn_fullscreen->signal_clicked().connect( sigc::mem_fun(*this, &RTWindow::toggle_fullscreen) ); - setExpandAlignProperties(&prProgBar, false, false, Gtk::ALIGN_CENTER, Gtk::ALIGN_CENTER); - prProgBar.set_show_text(true); + btn_fullscreen->signal_clicked().connect ( sigc::mem_fun (*this, &RTWindow::toggle_fullscreen) ); + setExpandAlignProperties (&prProgBar, false, false, Gtk::ALIGN_CENTER, Gtk::ALIGN_CENTER); + prProgBar.set_show_text (true); Gtk::Grid* actionGrid = Gtk::manage (new Gtk::Grid ()); - actionGrid->set_row_spacing(2); - actionGrid->set_column_spacing(2); + actionGrid->set_row_spacing (2); + actionGrid->set_column_spacing (2); - setExpandAlignProperties(actionGrid, false, false, Gtk::ALIGN_CENTER, Gtk::ALIGN_CENTER); + setExpandAlignProperties (actionGrid, false, false, Gtk::ALIGN_CENTER, Gtk::ALIGN_CENTER); if (options.mainNBVertical) { - prProgBar.set_orientation(Gtk::ORIENTATION_VERTICAL); - prProgBar.set_inverted(true); - actionGrid->set_orientation(Gtk::ORIENTATION_VERTICAL); - actionGrid->attach_next_to(prProgBar, Gtk::POS_BOTTOM, 1, 1); - actionGrid->attach_next_to(*preferences, Gtk::POS_BOTTOM, 1, 1); - actionGrid->attach_next_to(*btn_fullscreen, Gtk::POS_BOTTOM, 1, 1); - mainNB->set_action_widget(actionGrid, Gtk::PACK_END); + prProgBar.set_orientation (Gtk::ORIENTATION_VERTICAL); + prProgBar.set_inverted (true); + actionGrid->set_orientation (Gtk::ORIENTATION_VERTICAL); + actionGrid->attach_next_to (prProgBar, Gtk::POS_BOTTOM, 1, 1); + actionGrid->attach_next_to (*preferences, Gtk::POS_BOTTOM, 1, 1); + actionGrid->attach_next_to (*btn_fullscreen, Gtk::POS_BOTTOM, 1, 1); + mainNB->set_action_widget (actionGrid, Gtk::PACK_END); } else { - prProgBar.set_orientation(Gtk::ORIENTATION_HORIZONTAL); - actionGrid->set_orientation(Gtk::ORIENTATION_HORIZONTAL); - actionGrid->attach_next_to(prProgBar, Gtk::POS_RIGHT, 1, 1); - actionGrid->attach_next_to(*preferences, Gtk::POS_RIGHT, 1, 1); - actionGrid->attach_next_to(*btn_fullscreen, Gtk::POS_RIGHT, 1, 1); - mainNB->set_action_widget(actionGrid, Gtk::PACK_END); + prProgBar.set_orientation (Gtk::ORIENTATION_HORIZONTAL); + actionGrid->set_orientation (Gtk::ORIENTATION_HORIZONTAL); + actionGrid->attach_next_to (prProgBar, Gtk::POS_RIGHT, 1, 1); + actionGrid->attach_next_to (*preferences, Gtk::POS_RIGHT, 1, 1); + actionGrid->attach_next_to (*btn_fullscreen, Gtk::POS_RIGHT, 1, 1); + mainNB->set_action_widget (actionGrid, Gtk::PACK_END); } actionGrid->show_all(); - pldBridge = new PLDBridge(static_cast(this)); + pldBridge = new PLDBridge (static_cast (this)); add (*mainNB); show_all (); @@ -272,9 +274,10 @@ RTWindow::RTWindow () bpanel->init (this); if (!argv1.empty() && !remote) { - Thumbnail* thm = cacheMgr->getEntry(argv1); + Thumbnail* thm = cacheMgr->getEntry (argv1); + if (thm) { - fpanel->fileCatalog->openRequested({thm}); + fpanel->fileCatalog->openRequested ({thm}); } } } @@ -282,7 +285,7 @@ RTWindow::RTWindow () RTWindow::~RTWindow() { - if(!simpleEditor) { + if (!simpleEditor) { delete pldBridge; } @@ -300,7 +303,7 @@ void RTWindow::on_realize () { Gtk::Window::on_realize (); - if( fpanel ) { + if ( fpanel ) { fpanel->setAspect(); } @@ -308,19 +311,20 @@ void RTWindow::on_realize () epanel->setAspect(); } - mainWindowCursorManager.init(get_window()); + mainWindowCursorManager.init (get_window()); // Display release notes only if new major version. // Pattern matches "5.1" from "5.1-23-g12345678" std::string vs[] = {versionString, options.version}; - std::regex pat("(^[0-9.]+).*"); + std::regex pat ("(^[0-9.]+).*"); std::smatch sm; std::vector vMajor; + for (const auto &v : vs) { - if (std::regex_match(v, sm, pat)) { + if (std::regex_match (v, sm, pat)) { if (sm.size() == 2) { std::ssub_match smsub = sm[1]; - vMajor.push_back(smsub.str()); + vMajor.push_back (smsub.str()); } } } @@ -333,7 +337,7 @@ void RTWindow::on_realize () splash = new Splash (*this); splash->set_transient_for (*this); - splash->signal_delete_event().connect( sigc::mem_fun(*this, &RTWindow::splashClosed) ); + splash->signal_delete_event().connect ( sigc::mem_fun (*this, &RTWindow::splashClosed) ); if (splash->hasReleaseNotes()) { splash->showReleaseNotes(); @@ -346,38 +350,39 @@ void RTWindow::on_realize () } } -bool RTWindow::on_configure_event(GdkEventConfigure* event) +bool RTWindow::on_configure_event (GdkEventConfigure* event) { if (!is_maximized() && is_visible()) { - get_size(options.windowWidth, options.windowHeight); + get_size (options.windowWidth, options.windowHeight); get_position (options.windowX, options.windowY); } - return Gtk::Widget::on_configure_event(event); + return Gtk::Widget::on_configure_event (event); } -bool RTWindow::on_window_state_event(GdkEventWindowState* event) +bool RTWindow::on_window_state_event (GdkEventWindowState* event) { if (event->changed_mask & GDK_WINDOW_STATE_MAXIMIZED) { options.windowMaximized = event->new_window_state & GDK_WINDOW_STATE_MAXIMIZED; } - return Gtk::Widget::on_window_state_event(event); + + return Gtk::Widget::on_window_state_event (event); } -void RTWindow::on_mainNB_switch_page(Gtk::Widget* widget, guint page_num) +void RTWindow::on_mainNB_switch_page (Gtk::Widget* widget, guint page_num) { - if(!on_delete_has_run) { - if(isEditorPanel(page_num)) { + if (!on_delete_has_run) { + if (isEditorPanel (page_num)) { if (isSingleTabMode() && epanel) { MoveFileBrowserToEditor(); } - EditorPanel *ep = static_cast(mainNB->get_nth_page(page_num)); + EditorPanel *ep = static_cast (mainNB->get_nth_page (page_num)); ep->setAspect(); if (!isSingleTabMode()) { if (filesEdited.size() > 0) { - set_title_decorated(ep->getFileName()); + set_title_decorated (ep->getFileName()); } } } else { @@ -387,7 +392,7 @@ void RTWindow::on_mainNB_switch_page(Gtk::Widget* widget, guint page_num) epanel->saveProfile(); // Moving the FileBrowser only if the user has switched to the FileBrowser tab - if (mainNB->get_nth_page(page_num) == fpanel) { + if (mainNB->get_nth_page (page_num) == fpanel) { MoveFileBrowserToMain(); } } @@ -398,32 +403,32 @@ void RTWindow::on_mainNB_switch_page(Gtk::Widget* widget, guint page_num) void RTWindow::addEditorPanel (EditorPanel* ep, const std::string &name) { if (options.multiDisplayMode > 0) { - EditWindow * wndEdit = EditWindow::getInstance(this); + EditWindow * wndEdit = EditWindow::getInstance (this); wndEdit->show(); - wndEdit->addEditorPanel(ep, name); + wndEdit->addEditorPanel (ep, name); wndEdit->toFront(); } else { ep->setParent (this); - ep->setParentWindow(this); + ep->setParentWindow (this); // construct closeable tab for the image Gtk::Grid* titleGrid = Gtk::manage (new Gtk::Grid ()); titleGrid->set_tooltip_markup (name); - RTImage *closebimg = Gtk::manage(new RTImage ("gtk-close.png")); + RTImage *closebimg = Gtk::manage (new RTImage ("gtk-close.png")); Gtk::Button* closeb = Gtk::manage (new Gtk::Button ()); closeb->set_name ("CloseButton"); closeb->add (*closebimg); closeb->set_relief (Gtk::RELIEF_NONE); closeb->set_focus_on_click (false); - closeb->signal_clicked().connect( sigc::bind (sigc::mem_fun(*this, &RTWindow::remEditorPanel) , ep)); + closeb->signal_clicked().connect ( sigc::bind (sigc::mem_fun (*this, &RTWindow::remEditorPanel), ep)); - titleGrid->attach_next_to(*Gtk::manage (new RTImage ("rtwindow.png")), Gtk::POS_RIGHT, 1, 1); - titleGrid->attach_next_to(*Gtk::manage (new Gtk::Label (Glib::path_get_basename (name))), Gtk::POS_RIGHT, 1, 1); - titleGrid->attach_next_to(*closeb, Gtk::POS_RIGHT, 1, 1); + titleGrid->attach_next_to (*Gtk::manage (new RTImage ("rtwindow.png")), Gtk::POS_RIGHT, 1, 1); + titleGrid->attach_next_to (*Gtk::manage (new Gtk::Label (Glib::path_get_basename (name))), Gtk::POS_RIGHT, 1, 1); + titleGrid->attach_next_to (*closeb, Gtk::POS_RIGHT, 1, 1); titleGrid->show_all (); //GTK318 #if GTK_MAJOR_VERSION == 3 && GTK_MINOR_VERSION < 20 - titleGrid->set_column_spacing(2); + titleGrid->set_column_spacing (2); #endif //GTK318 @@ -432,11 +437,11 @@ void RTWindow::addEditorPanel (EditorPanel* ep, const std::string &name) mainNB->set_current_page (mainNB->page_num (*ep)); mainNB->set_tab_reorderable (*ep, true); - set_title_decorated(name); + set_title_decorated (name); epanels[ name ] = ep; filesEdited.insert ( name ); fpanel->refreshEditedState (filesEdited); - ep->tbTopPanel_1_visible(false); //hide the toggle Top Panel button + ep->tbTopPanel_1_visible (false); //hide the toggle Top Panel button } } @@ -447,8 +452,8 @@ void RTWindow::remEditorPanel (EditorPanel* ep) } if (options.multiDisplayMode > 0) { - EditWindow * wndEdit = EditWindow::getInstance(this); - wndEdit->remEditorPanel(ep); + EditWindow * wndEdit = EditWindow::getInstance (this); + wndEdit->remEditorPanel (ep); } else { bool queueHadFocus = (mainNB->get_current_page() == mainNB->page_num (*bpanel)); epanels.erase (ep->getFileName()); @@ -457,37 +462,37 @@ void RTWindow::remEditorPanel (EditorPanel* ep) mainNB->remove_page (*ep); - if (!isEditorPanel(mainNB->get_current_page())) { - if(!queueHadFocus) { + if (!isEditorPanel (mainNB->get_current_page())) { + if (!queueHadFocus) { mainNB->set_current_page (mainNB->page_num (*fpanel)); } - set_title_decorated(""); + set_title_decorated (""); } else { - EditorPanel* ep = static_cast(mainNB->get_nth_page (mainNB->get_current_page())); - set_title_decorated(ep->getFileName()); + EditorPanel* ep = static_cast (mainNB->get_nth_page (mainNB->get_current_page())); + set_title_decorated (ep->getFileName()); } // TODO: ask what to do: close & apply, close & apply selection, close & revert, cancel } } -bool RTWindow::selectEditorPanel(const std::string &name) +bool RTWindow::selectEditorPanel (const std::string &name) { if (options.multiDisplayMode > 0) { - EditWindow * wndEdit = EditWindow::getInstance(this); + EditWindow * wndEdit = EditWindow::getInstance (this); - if (wndEdit->selectEditorPanel(name)) { - set_title_decorated(name); + if (wndEdit->selectEditorPanel (name)) { + set_title_decorated (name); wndEdit->toFront(); return true; } } else { - std::map::iterator iep = epanels.find(name); + std::map::iterator iep = epanels.find (name); if (iep != epanels.end()) { mainNB->set_current_page (mainNB->page_num (*iep->second)); - set_title_decorated(name); + set_title_decorated (name); return true; } else { //set_title_decorated(name); @@ -521,12 +526,12 @@ bool RTWindow::keyPressed (GdkEventKey* event) #endif if (try_quit) { - if (!on_delete_event(nullptr)) { + if (!on_delete_event (nullptr)) { gtk_main_quit(); } } - if(event->keyval == GDK_KEY_F11) { + if (event->keyval == GDK_KEY_F11) { toggle_fullscreen(); } @@ -537,40 +542,40 @@ bool RTWindow::keyPressed (GdkEventKey* event) }; if (ctrl) { - switch(event->keyval) { - case GDK_KEY_F2: // file browser panel - mainNB->set_current_page (mainNB->page_num (*fpanel)); - return true; - - case GDK_KEY_F3: // batch queue panel - mainNB->set_current_page (mainNB->page_num (*bpanel)); - return true; - - case GDK_KEY_F4: //single tab mode, editor panel - if (isSingleTabMode() && epanel) { - mainNB->set_current_page (mainNB->page_num (*epanel)); - } - - return true; - - case GDK_KEY_w: //multi-tab mode, close editor panel - if (!isSingleTabMode() && - mainNB->get_current_page() != mainNB->page_num(*fpanel) && - mainNB->get_current_page() != mainNB->page_num(*bpanel)) { - - EditorPanel* ep = static_cast(mainNB->get_nth_page (mainNB->get_current_page())); - remEditorPanel (ep); + switch (event->keyval) { + case GDK_KEY_F2: // file browser panel + mainNB->set_current_page (mainNB->page_num (*fpanel)); return true; - } + + case GDK_KEY_F3: // batch queue panel + mainNB->set_current_page (mainNB->page_num (*bpanel)); + return true; + + case GDK_KEY_F4: //single tab mode, editor panel + if (isSingleTabMode() && epanel) { + mainNB->set_current_page (mainNB->page_num (*epanel)); + } + + return true; + + case GDK_KEY_w: //multi-tab mode, close editor panel + if (!isSingleTabMode() && + mainNB->get_current_page() != mainNB->page_num (*fpanel) && + mainNB->get_current_page() != mainNB->page_num (*bpanel)) { + + EditorPanel* ep = static_cast (mainNB->get_nth_page (mainNB->get_current_page())); + remEditorPanel (ep); + return true; + } } } - if (mainNB->get_current_page() == mainNB->page_num(*fpanel)) { + if (mainNB->get_current_page() == mainNB->page_num (*fpanel)) { return fpanel->handleShortcutKey (event); - } else if (mainNB->get_current_page() == mainNB->page_num(*bpanel)) { + } else if (mainNB->get_current_page() == mainNB->page_num (*bpanel)) { return bpanel->handleShortcutKey (event); } else { - EditorPanel* ep = static_cast(mainNB->get_nth_page (mainNB->get_current_page())); + EditorPanel* ep = static_cast (mainNB->get_nth_page (mainNB->get_current_page())); return ep->handleShortcutKey (event); } @@ -581,7 +586,7 @@ void RTWindow::addBatchQueueJob (BatchQueueEntry* bqe, bool head) { std::vector entries; - entries.push_back(bqe); + entries.push_back (bqe); bpanel->addBatchQueueJobs (entries, head); fpanel->queue_draw (); } @@ -593,7 +598,7 @@ void RTWindow::addBatchQueueJobs (std::vector &entries) fpanel->queue_draw (); } -bool RTWindow::on_delete_event(GdkEventAny* event) +bool RTWindow::on_delete_event (GdkEventAny* event) { if (on_delete_has_run) { @@ -608,14 +613,14 @@ bool RTWindow::on_delete_event(GdkEventAny* event) if (isSingleTabMode() || simpleEditor) { isProcessing = epanel->getIsProcessing(); } else if (options.multiDisplayMode > 0) { - editWindow = EditWindow::getInstance(this, false); + editWindow = EditWindow::getInstance (this, false); isProcessing = editWindow->isProcessing(); } else { int pageCount = mainNB->get_n_pages(); for (int i = 0; i < pageCount && !isProcessing; i++) { - if(isEditorPanel(i)) { - isProcessing |= (static_cast(mainNB->get_nth_page(i)))->getIsProcessing(); + if (isEditorPanel (i)) { + isProcessing |= (static_cast (mainNB->get_nth_page (i)))->getIsProcessing(); } } } @@ -624,11 +629,11 @@ bool RTWindow::on_delete_event(GdkEventAny* event) return true; } - if( fpanel ) { + if ( fpanel ) { fpanel->saveOptions (); } - if( bpanel ) { + if ( bpanel ) { bpanel->saveOptions (); } @@ -644,7 +649,7 @@ bool RTWindow::on_delete_event(GdkEventAny* event) // Look at the active panel first, if any, otherwise look at the first one (sorted on the filename) int page = mainNB->get_current_page(); - Gtk::Widget *w = mainNB->get_nth_page(page); + Gtk::Widget *w = mainNB->get_nth_page (page); bool optionsWritten = false; for (std::map::iterator i = epanels.begin(); i != epanels.end(); ++i) { @@ -667,13 +672,19 @@ bool RTWindow::on_delete_event(GdkEventAny* event) ProfilePanel::cleanup(); if (!options.windowMaximized) { - get_size(options.windowWidth, options.windowHeight); + get_size (options.windowWidth, options.windowHeight); get_position (options.windowX, options.windowY); } - options.windowMonitor = get_screen()->get_monitor_at_window(get_window()); + options.windowMonitor = get_screen()->get_monitor_at_window (get_window()); + + try { + Options::save (); + } catch (Options::Error &e) { + Gtk::MessageDialog msgd (getToplevelWindow (this), e.get_msg(), true, Gtk::MESSAGE_WARNING, Gtk::BUTTONS_CLOSE, true); + msgd.run(); + } - Options::save (); hide(); on_delete_has_run = true; @@ -687,11 +698,13 @@ void RTWindow::showPreferences () delete pref; fpanel->optionsChanged (); + if (epanel) { - epanel->defaultMonitorProfileChanged(options.rtSettings.monitorProfile, options.rtSettings.autoMonitorProfile); + epanel->defaultMonitorProfileChanged (options.rtSettings.monitorProfile, options.rtSettings.autoMonitorProfile); } + for (const auto &p : epanels) { - p.second->defaultMonitorProfileChanged(options.rtSettings.monitorProfile, options.rtSettings.autoMonitorProfile); + p.second->defaultMonitorProfileChanged (options.rtSettings.monitorProfile, options.rtSettings.autoMonitorProfile); } } @@ -724,7 +737,7 @@ void RTWindow::toggle_fullscreen () if (btn_fullscreen) { //btn_fullscreen->set_label(M("MAIN_BUTTON_FULLSCREEN")); - btn_fullscreen->set_tooltip_markup(M("MAIN_BUTTON_FULLSCREEN")); + btn_fullscreen->set_tooltip_markup (M ("MAIN_BUTTON_FULLSCREEN")); btn_fullscreen->set_image (*iFullscreen); } } else { @@ -733,7 +746,7 @@ void RTWindow::toggle_fullscreen () if (btn_fullscreen) { //btn_fullscreen->set_label(M("MAIN_BUTTON_UNFULLSCREEN")); - btn_fullscreen->set_tooltip_markup(M("MAIN_BUTTON_UNFULLSCREEN")); + btn_fullscreen->set_tooltip_markup (M ("MAIN_BUTTON_UNFULLSCREEN")); btn_fullscreen->set_image (*iFullscreen_exit); } } @@ -756,50 +769,51 @@ void RTWindow::SetMainCurrent() void RTWindow::MoveFileBrowserToMain() { - if( fpanel->ribbonPane->get_children().empty()) { + if ( fpanel->ribbonPane->get_children().empty()) { FileCatalog *fCatalog = fpanel->fileCatalog; - epanel->catalogPane->remove(*fCatalog); - fpanel->ribbonPane->add(*fCatalog); - fCatalog->enableTabMode(false); - fCatalog->tbLeftPanel_1_visible(true); - fCatalog->tbRightPanel_1_visible(true); + epanel->catalogPane->remove (*fCatalog); + fpanel->ribbonPane->add (*fCatalog); + fCatalog->enableTabMode (false); + fCatalog->tbLeftPanel_1_visible (true); + fCatalog->tbRightPanel_1_visible (true); } } void RTWindow::MoveFileBrowserToEditor() { - if(epanel->catalogPane->get_children().empty() ) { + if (epanel->catalogPane->get_children().empty() ) { FileCatalog *fCatalog = fpanel->fileCatalog; - fpanel->ribbonPane->remove(*fCatalog); + fpanel->ribbonPane->remove (*fCatalog); fCatalog->disableInspector(); - epanel->catalogPane->add(*fCatalog); - epanel->showTopPanel(options.editorFilmStripOpened); - fCatalog->enableTabMode(true); + epanel->catalogPane->add (*fCatalog); + epanel->showTopPanel (options.editorFilmStripOpened); + fCatalog->enableTabMode (true); fCatalog->refreshHeight(); - fCatalog->tbLeftPanel_1_visible(false); - fCatalog->tbRightPanel_1_visible(false); + fCatalog->tbLeftPanel_1_visible (false); + fCatalog->tbRightPanel_1_visible (false); } } -void RTWindow::updateProfiles(const Glib::ustring &printerProfile, rtengine::RenderingIntent printerIntent, bool printerBPC) +void RTWindow::updateProfiles (const Glib::ustring &printerProfile, rtengine::RenderingIntent printerIntent, bool printerBPC) { - if(epanel) { - epanel->updateProfiles(printerProfile, printerIntent, printerBPC); + if (epanel) { + epanel->updateProfiles (printerProfile, printerIntent, printerBPC); } - for(auto panel : epanels) { - panel.second->updateProfiles(printerProfile, printerIntent, printerBPC); + for (auto panel : epanels) { + panel.second->updateProfiles (printerProfile, printerIntent, printerBPC); } } void RTWindow::updateTPVScrollbar (bool hide) { fpanel->updateTPVScrollbar (hide); - if(epanel) { + + if (epanel) { epanel->updateTPVScrollbar (hide); } - for(auto panel : epanels) { + for (auto panel : epanels) { panel.second->updateTPVScrollbar (hide); } } @@ -807,11 +821,12 @@ void RTWindow::updateTPVScrollbar (bool hide) void RTWindow::updateTabsUsesIcons (bool useIcons) { fpanel->updateTabsUsesIcons (useIcons); - if(epanel) { + + if (epanel) { epanel->updateTabsUsesIcons (useIcons); } - for(auto panel : epanels) { + for (auto panel : epanels) { panel.second->updateTabsUsesIcons (useIcons); } } @@ -828,22 +843,23 @@ void RTWindow::updateFBToolBarVisibility (bool showFilmStripToolBar) void RTWindow::updateHistogramPosition (int oldPosition, int newPosition) { - if(epanel) { + if (epanel) { epanel->updateHistogramPosition (oldPosition, newPosition); } - for(auto panel : epanels) { + + for (auto panel : epanels) { panel.second->updateHistogramPosition (oldPosition, newPosition); } } -bool RTWindow::splashClosed(GdkEventAny* event) +bool RTWindow::splashClosed (GdkEventAny* event) { delete splash; splash = nullptr; return true; } -void RTWindow::set_title_decorated(Glib::ustring fname) +void RTWindow::set_title_decorated (Glib::ustring fname) { Glib::ustring subtitle; @@ -851,7 +867,7 @@ void RTWindow::set_title_decorated(Glib::ustring fname) subtitle = " - " + fname; } - set_title(versionStr + subtitle); + set_title (versionStr + subtitle); } void RTWindow::closeOpenEditors() @@ -859,36 +875,36 @@ void RTWindow::closeOpenEditors() std::map::const_iterator itr; itr = epanels.begin(); - while(itr != epanels.end()) { - remEditorPanel((*itr).second); + while (itr != epanels.end()) { + remEditorPanel ((*itr).second); itr = epanels.begin(); } } -bool RTWindow::isEditorPanel(Widget* panel) +bool RTWindow::isEditorPanel (Widget* panel) { return (panel != bpanel) && (panel != fpanel); } -bool RTWindow::isEditorPanel(guint pageNum) +bool RTWindow::isEditorPanel (guint pageNum) { - return isEditorPanel(mainNB->get_nth_page(pageNum)); + return isEditorPanel (mainNB->get_nth_page (pageNum)); } -void RTWindow::setEditorMode(bool tabbedUI) +void RTWindow::setEditorMode (bool tabbedUI) { MoveFileBrowserToMain(); closeOpenEditors(); SetMainCurrent(); - if(tabbedUI) { - mainNB->remove_page(*epanel); + if (tabbedUI) { + mainNB->remove_page (*epanel); epanel = nullptr; - set_title_decorated(""); + set_title_decorated (""); } else { createSetmEditor(); epanel->show_all(); - set_title_decorated(""); + set_title_decorated (""); } } @@ -897,25 +913,25 @@ void RTWindow::createSetmEditor() // Editor panel, single-tab mode only epanel = Gtk::manage ( new EditorPanel (fpanel) ); epanel->setParent (this); - epanel->setParentWindow(this); + epanel->setParentWindow (this); // decorate tab Gtk::Grid* const editorLabelGrid = Gtk::manage (new Gtk::Grid ()); - setExpandAlignProperties(editorLabelGrid, false, false, Gtk::ALIGN_CENTER, Gtk::ALIGN_CENTER); - Gtk::Label* const el = Gtk::manage (new Gtk::Label( Glib::ustring(" ") + M("MAIN_FRAME_EDITOR") )); + setExpandAlignProperties (editorLabelGrid, false, false, Gtk::ALIGN_CENTER, Gtk::ALIGN_CENTER); + Gtk::Label* const el = Gtk::manage (new Gtk::Label ( Glib::ustring (" ") + M ("MAIN_FRAME_EDITOR") )); const auto pos = options.mainNBVertical ? Gtk::POS_TOP : Gtk::POS_RIGHT; if (options.mainNBVertical) { - el->set_angle(90); + el->set_angle (90); } - editorLabelGrid->attach_next_to(*Gtk::manage (new RTImage ("rt-logo-small.png")), pos, 1, 1); - editorLabelGrid->attach_next_to(*el, pos, 1, 1); + editorLabelGrid->attach_next_to (*Gtk::manage (new RTImage ("rt-logo-small.png")), pos, 1, 1); + editorLabelGrid->attach_next_to (*el, pos, 1, 1); - editorLabelGrid->set_tooltip_markup (M("MAIN_FRAME_EDITOR_TOOLTIP")); + editorLabelGrid->set_tooltip_markup (M ("MAIN_FRAME_EDITOR_TOOLTIP")); editorLabelGrid->show_all (); - epanel->tbTopPanel_1_visible(true); //show the toggle Top Panel button + epanel->tbTopPanel_1_visible (true); //show the toggle Top Panel button mainNB->append_page (*epanel, *editorLabelGrid); }