From 6fd05adc597cfcb6cb3ac4375a30301e30f5931e Mon Sep 17 00:00:00 2001 From: Michael Ezra Date: Sun, 29 Jan 2012 16:15:26 -0500 Subject: [PATCH] New feature: Export panel with Fast Export options. Fast Export options provide overrides to bypass time and resource consuming development settings and to run queue processing using the fast export settings instead. This method is recommended for quicker generation of lower resolution images when speed is a priority or when resized output is desired for one or many images without making modifications to their saved development parameters. --- RELEASE_NOTES.txt | 15 +- rtdata/languages/default | 32 ++- rtgui/CMakeLists.txt | 2 +- rtgui/exportpanel.cc | 414 +++++++++++++++++++++++++++++++++++++++ rtgui/exportpanel.h | 114 +++++++++++ rtgui/filebrowser.cc | 23 ++- rtgui/filebrowser.h | 14 +- rtgui/filecatalog.cc | 59 +++++- rtgui/filecatalog.h | 11 +- rtgui/filepanel.cc | 9 + rtgui/filepanel.h | 2 + rtgui/filterpanel.cc | 9 + rtgui/options.cc | 95 +++++++++ rtgui/options.h | 32 +++ 14 files changed, 817 insertions(+), 14 deletions(-) create mode 100644 rtgui/exportpanel.cc create mode 100644 rtgui/exportpanel.h diff --git a/RELEASE_NOTES.txt b/RELEASE_NOTES.txt index 060e1fe30..827d5640e 100644 --- a/RELEASE_NOTES.txt +++ b/RELEASE_NOTES.txt @@ -3,6 +3,7 @@ RAWTHERAPEE 4.0.7 RELEASE NOTES ------------------------------- CAVEATS +------- - Memory requirements Please read http://rawtherapee.com/blog/maximizing-memory-efficiency @@ -24,11 +25,13 @@ The profiles supplied with RawTherapee were changed to be compatible with the ne - The new Exposure Compensation in thumbnail captions and file browser filter requires clearing of Rawtherapee's thumbnail cache (see Preferences > File Browser). If the thubmnail cache is not cleared, exposure compensation values will not be displayed in captions or recognised in filtering *for previously browsed images* only. - NEW FEATURES -- RGB curves, +------------ +- New RGB curves, - New white balance presets for specific spectra, -- Preview modes: red, green, blue, luminosity and focus mask (see which areas are in focus), +- New Preview modes: red, green, blue, luminosity + and Focus Mask (see which areas are in focus), +- New Export Panel with Fast Export Options, - DCRAW updated to 9.12 Support added for these cameras: Canon PowerShot S100 @@ -52,14 +55,17 @@ NEW FEATURES DOCUMENTATION +------------_ http://rawtherapee.com/blog/documentation REPORTING BUGS +-------------- http://rawtherapee.com/forum/viewtopic.php?f=3&t=3639 LIVE CHAT WITH RT USERS +----------------------- Network: freenode Server: chat.freenode.net Channel #rawtherapee @@ -67,7 +73,8 @@ http://webchat.freenode.net/?randomnick=1&channels=rawtherapee&prompt=1 http://rawtherapee.com/forum/viewtopic.php?f=1&t=945 -REVISION HISTORY +REVISION HISTORY +---------------- The complete change log is available at http://code.google.com/p/rawtherapee/source/list diff --git a/rtdata/languages/default b/rtdata/languages/default index 503c38e0e..908b5351e 100644 --- a/rtdata/languages/default +++ b/rtdata/languages/default @@ -52,6 +52,32 @@ EXIFPANEL_RESETALL;Reset All EXIFPANEL_RESETHINT;Reset the selected tags to their original values EXIFPANEL_RESET;Reset EXIFPANEL_SUBDIRECTORY;Subdirectory +EXPORT_BYPASS_ALL;Select / Unselect All +EXPORT_BYPASS_COLORDENOISE;Bypass Color denoise +EXPORT_BYPASS_DEFRINGE;Bypass Defringe +EXPORT_BYPASS_DIRPYRDENOISE;Bypass Noise Reduction +EXPORT_BYPASS_DIRPYREQUALIZER;Bypass Contrast by detail levels +EXPORT_BYPASS_LUMADENOISE;Bypass Luma denoise +EXPORT_BYPASS_RAW_ALL_ENHANCE;Bypass Post demosaic artifact/noise reduction +EXPORT_BYPASS_RAW_CA;Bypass [raw] Chromatic Aberration correction +EXPORT_BYPASS_RAW_CCSTEPS;Bypass [raw] False color suppression +EXPORT_BYPASS_RAW_DCB_ENHANCE;Bypass [raw] DCB enhancement steps +EXPORT_BYPASS_RAW_DCB_ITERATIONS;Bypass [raw] DCB iterations +EXPORT_BYPASS_RAW_DF;Bypass [raw] Dark Frame +EXPORT_BYPASS_RAW_FF;Bypass [raw] Flat Field +EXPORT_BYPASS_RAW_GREENTHRESH;Bypass [raw] Green equilibration +EXPORT_BYPASS_RAW_LINENOISE;Bypass [raw] Line noise filter +EXPORT_BYPASS_SH_HQ;Bypass Shadow/Highlights (high quality) +EXPORT_BYPASS_SHARPENEDGE;Bypass Edge sharpening +EXPORT_BYPASS_SHARPENING;Bypass Sharpening +EXPORT_BYPASS_SHARPENMICRO;Bypass Microcontrast +EXPORT_FASTEXPORTOPTIONS;Fast Export Options +EXPORT_INSTRUCTIONS;Fast Export options provide overrides to bypass time and resource consuming development settings and to run queue processing using the fast export settings instead. This method is recommended for quicker generation of lower resolution images when speed is a priority or when resized output is desired for one or many images without making modifications to their saved development parameters. +EXPORT_MAXHEIGHT;Maximum Height: +EXPORT_MAXWIDTH;Maximum Width: +EXPORT_PUTTOQUEUEFAST; Put to Queue for Fast Export +EXPORT_RAW_DMETHOD;Demosaic method +EXPORT_RESIZEMETHOD;Resize method FILEBROWSER_ADDDELTEMPLATE;Add/Del templates... FILEBROWSER_APPLYPROFILE;Apply profile FILEBROWSER_APPLYPROFILE_PARTIAL;Apply profile (partial) @@ -99,6 +125,7 @@ FILEBROWSER_POPUPMOVEHEAD;Move to head of queue FILEBROWSER_POPUPMOVETO;Move to... FILEBROWSER_POPUPOPEN;Open FILEBROWSER_POPUPPROCESS;Put to Queue +FILEBROWSER_POPUPPROCESSFAST;Put to Queue (Fast export) FILEBROWSER_POPUPPROFILEOPERATIONS;Profile Operations FILEBROWSER_POPUPRANK1;Rank 1 * FILEBROWSER_POPUPRANK2;Rank 2 ** @@ -456,11 +483,12 @@ MAIN_TAB_COLOR;Color MAIN_TAB_COLOR_TOOLTIP;Alt-c MAIN_TAB_DETAIL;Detail MAIN_TAB_DETAIL_TOOLTIP;Alt-d -MAIN_TAB_DEVELOP;Develop +MAIN_TAB_DEVELOP; Develop MAIN_TAB_EXIF;Exif +MAIN_TAB_EXPORT; Export MAIN_TAB_EXPOSURE;Exposure MAIN_TAB_EXPOSURE_TOOLTIP;Alt-e -MAIN_TAB_FILTER;Filter +MAIN_TAB_FILTER; Filter MAIN_TAB_ICM;ICM MAIN_TAB_IPTC;IPTC MAIN_TAB_METADATA;Metadata diff --git a/rtgui/CMakeLists.txt b/rtgui/CMakeLists.txt index 748b3ab08..26be6a17b 100644 --- a/rtgui/CMakeLists.txt +++ b/rtgui/CMakeLists.txt @@ -1,7 +1,7 @@ set (BASESOURCEFILES editwindow.cc batchtoolpanelcoord.cc paramsedited.cc cropwindow.cc previewhandler.cc previewwindow.cc navigator.cc indclippedpanel.cc previewmodepanel.cc filterpanel.cc - cursormanager.cc rtwindow.cc renamedlg.cc recentbrowser.cc placesbrowser.cc filepanel.cc editorpanel.cc batchqueuepanel.cc + exportpanel.cc cursormanager.cc rtwindow.cc renamedlg.cc recentbrowser.cc placesbrowser.cc filepanel.cc editorpanel.cc batchqueuepanel.cc ilabel.cc thumbbrowserbase.cc adjuster.cc filebrowserentry.cc filebrowser.cc filethumbnailbuttonset.cc cachemanager.cc cacheimagedata.cc shcselector.cc perspective.cc clipboard.cc thumbimageupdater.cc bqentryupdater.cc lensgeom.cc diff --git a/rtgui/exportpanel.cc b/rtgui/exportpanel.cc new file mode 100644 index 000000000..aabf59ddc --- /dev/null +++ b/rtgui/exportpanel.cc @@ -0,0 +1,414 @@ +/* + * This file is part of RawTherapee. + * + * Copyright (c) 2004-2010 Gabor Horvath + * Copyright (c) 2012 Michael Ezra + * + * RawTherapee is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * RawTherapee is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with RawTherapee. If not, see . + */ +#include "exportpanel.h" +#include "multilangmgr.h" +#include "options.h" +#include "rtimage.h" + +using namespace rtengine; +using namespace rtengine::procparams; + +ExportPanel::ExportPanel () : listener (NULL) { + + set_border_width (4); + + /*enabled = Gtk::manage ( new Gtk::CheckButton (M("EXPORT_ENABLE")) ); + pack_start(*enabled, Gtk::PACK_SHRINK, 4); + pack_start (*Gtk::manage(new Gtk::HSeparator ()), Gtk::PACK_SHRINK, 2);*/ + + Gtk::Label* labExportTitle = Gtk::manage ( new Gtk::Label (M("EXPORT_FASTEXPORTOPTIONS")) ); + labExportTitle->set_use_markup (true); + labExportTitle->set_alignment(Gtk::ALIGN_LEFT); + pack_start(*labExportTitle, Gtk::PACK_SHRINK, 4); + + Gtk::Label* labInstructions = Gtk::manage ( new Gtk::Label (M("EXPORT_INSTRUCTIONS")) ); + labInstructions->set_use_markup (true); + labInstructions->set_line_wrap (true); + labInstructions->set_alignment(Gtk::ALIGN_LEFT); + Gtk::HBox* hbInstructions = Gtk::manage (new Gtk::HBox ()); + hbInstructions->pack_start(*labInstructions, Gtk::PACK_SHRINK, 4); + pack_start(*hbInstructions, Gtk::PACK_SHRINK, 4); + + bypass_ALL = Gtk::manage ( new Gtk::CheckButton (M("EXPORT_BYPASS_ALL"))); + 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_raw_all_enhance = Gtk::manage ( new Gtk::CheckButton (M("EXPORT_BYPASS_RAW_ALL_ENHANCE"))); + bypass_raw_ccSteps = Gtk::manage ( new Gtk::CheckButton (M("EXPORT_BYPASS_RAW_CCSTEPS"))); + bypass_raw_linenoise = Gtk::manage ( new Gtk::CheckButton (M("EXPORT_BYPASS_RAW_LINENOISE"))); + bypass_raw_greenthresh = Gtk::manage ( new Gtk::CheckButton (M("EXPORT_BYPASS_RAW_GREENTHRESH"))); + 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_raw_dcb_iterations = Gtk::manage ( new Gtk::CheckButton (M("EXPORT_BYPASS_RAW_DCB_ITERATIONS"))); + bypass_raw_dcb_enhance = Gtk::manage ( new Gtk::CheckButton (M("EXPORT_BYPASS_RAW_DCB_ENHANCE"))); + + Gtk::HBox* hb_raw_dmethod = Gtk::manage (new Gtk::HBox ()); + hb_raw_dmethod->pack_start (*Gtk::manage (new Gtk::Label ( M("EXPORT_RAW_DMETHOD") +": ")),Gtk::PACK_SHRINK, 4); + raw_dmethod = Gtk::manage (new MyComboBoxText ()); + for( size_t i=0; i< procparams::RAWParams::numMethods;i++) + raw_dmethod->append_text(procparams::RAWParams::methodstring[i]); + + raw_dmethod->set_active(0); + hb_raw_dmethod->pack_end (*raw_dmethod, Gtk::PACK_EXPAND_WIDGET, 4); + + // start packing + pack_start(*bypass_ALL , Gtk::PACK_SHRINK, 4); + pack_start(*Gtk::manage(new Gtk::HSeparator ()), Gtk::PACK_SHRINK, 4); + pack_start(*bypass_sharpening , Gtk::PACK_SHRINK, 4); + pack_start(*bypass_sharpenEdge , Gtk::PACK_SHRINK, 4); + pack_start(*bypass_sharpenMicro , Gtk::PACK_SHRINK, 4); + //pack_start(*bypass_lumaDenoise , Gtk::PACK_SHRINK, 4); + //pack_start(*bypass_colorDenoise , Gtk::PACK_SHRINK, 4); + pack_start(*bypass_defringe , Gtk::PACK_SHRINK, 4); + pack_start(*bypass_dirpyrDenoise, Gtk::PACK_SHRINK, 4); + pack_start(*bypass_sh_hq , Gtk::PACK_SHRINK, 4); + pack_start(*bypass_dirpyrequalizer , Gtk::PACK_SHRINK, 4); + + pack_start(*hb_raw_dmethod , Gtk::PACK_SHRINK, 4); + pack_start(*bypass_raw_all_enhance , Gtk::PACK_SHRINK, 4); + pack_start(*bypass_raw_ccSteps , Gtk::PACK_SHRINK, 4); + pack_start(*bypass_raw_dcb_iterations, Gtk::PACK_SHRINK, 4); + pack_start(*bypass_raw_dcb_enhance , Gtk::PACK_SHRINK, 4); + pack_start(*bypass_raw_ca , Gtk::PACK_SHRINK, 4); + + pack_start(*bypass_raw_linenoise , Gtk::PACK_SHRINK, 4); + pack_start(*bypass_raw_greenthresh , Gtk::PACK_SHRINK, 4); + pack_start(*bypass_raw_df , Gtk::PACK_SHRINK, 4); + pack_start(*bypass_raw_ff , Gtk::PACK_SHRINK, 4); + + pack_start (*Gtk::manage(new Gtk::HSeparator ()), Gtk::PACK_SHRINK, 2); + + // Resize options + + resize_method = Gtk::manage (new MyComboBoxText ()); + resize_method->append_text (M("TP_RESIZE_NEAREST")); + resize_method->append_text (M("TP_RESIZE_BILINEAR")); + resize_method->append_text (M("TP_RESIZE_BICUBIC")); + resize_method->append_text (M("TP_RESIZE_BICUBICSF")); + resize_method->append_text (M("TP_RESIZE_BICUBICSH")); + resize_method->append_text (M("TP_RESIZE_LANCZOS")); + resize_method->set_active (5); + + Gtk::HBox* rmbox = Gtk::manage (new Gtk::HBox ()); + rmbox->pack_start (*Gtk::manage (new Gtk::Label (M("EXPORT_RESIZEMETHOD"))), Gtk::PACK_SHRINK, 4); + rmbox->pack_start (*resize_method); + pack_start (*rmbox, Gtk::PACK_SHRINK, 4); + + Gtk::HBox* wbox = Gtk::manage (new Gtk::HBox ()); + Gtk::HBox* hbox = Gtk::manage (new Gtk::HBox ()); + MaxWidth = Gtk::manage (new MySpinButton ()); + MaxHeight = Gtk::manage (new MySpinButton ()); + wbox->pack_start (*Gtk::manage (new Gtk::Label (M("EXPORT_MAXWIDTH"))), Gtk::PACK_SHRINK, 4); + wbox->pack_start (*MaxWidth); + hbox->pack_start (*Gtk::manage (new Gtk::Label (M("EXPORT_MAXHEIGHT"))), Gtk::PACK_SHRINK, 4); + hbox->pack_start (*MaxHeight); + pack_start (*wbox, Gtk::PACK_SHRINK, 4); + pack_start (*hbox, Gtk::PACK_SHRINK, 4); + + MaxWidth->set_digits (0); + MaxWidth->set_increments (1,100); + MaxWidth->set_value (options.fastexport_resize_width); + MaxWidth->set_range (32, 3000); + + MaxHeight->set_digits (0); + MaxHeight->set_increments (1,100); + MaxHeight->set_value (options.fastexport_resize_height); + MaxHeight->set_range (32, 3000); + + // Buttons + btnFastExport = Gtk::manage ( new Gtk::Button (M("EXPORT_PUTTOQUEUEFAST")) ); + btnFastExport->set_image (*Gtk::manage (new RTImage ("processing.png"))); + pack_start(*btnFastExport, Gtk::PACK_SHRINK, 4); + + + // add panel ending + Gtk::VBox* vboxpe = Gtk::manage (new Gtk::VBox ()); + Gtk::HSeparator* hseptpe = Gtk::manage (new Gtk::HSeparator ()); + Gtk::Image* peImg = Gtk::manage (new RTImage("PanelEnding.png")); + vboxpe->pack_start(*hseptpe, Gtk::PACK_SHRINK, 4); + vboxpe->pack_start(*peImg); + pack_start(*vboxpe, Gtk::PACK_SHRINK, 0); + + + btnFastExport->signal_clicked().connect( sigc::mem_fun(*this, &ExportPanel::FastExportPressed) ); + //btnExportLoadSettings->signal_clicked().connect( sigc::mem_fun(*this, &ExportPanel::LoadSettings) ); + //btnExportSaveSettings->signal_clicked().connect( sigc::mem_fun(*this, &ExportPanel::SaveSettings) ); + bypass_ALLconn = bypass_ALL->signal_toggled().connect (sigc::mem_fun(*this, &ExportPanel::bypassALL_Toggled)); + + bypass_sharpeningConn = bypass_sharpening->signal_toggled().connect (sigc::bind (sigc::mem_fun(*bypass_ALL, &Gtk::CheckButton::set_inconsistent), true)); + bypass_sharpenEdgeConn = bypass_sharpenEdge->signal_toggled().connect (sigc::bind (sigc::mem_fun(*bypass_ALL, &Gtk::CheckButton::set_inconsistent), true)); + bypass_sharpenMicroConn = bypass_sharpenMicro->signal_toggled().connect (sigc::bind (sigc::mem_fun(*bypass_ALL, &Gtk::CheckButton::set_inconsistent), true)); + bypass_lumaDenoiseConn = bypass_lumaDenoise->signal_toggled().connect (sigc::bind (sigc::mem_fun(*bypass_ALL, &Gtk::CheckButton::set_inconsistent), true)); + bypass_colorDenoiseConn = bypass_colorDenoise->signal_toggled().connect (sigc::bind (sigc::mem_fun(*bypass_ALL, &Gtk::CheckButton::set_inconsistent), true)); + bypass_defringeConn = bypass_defringe->signal_toggled().connect (sigc::bind (sigc::mem_fun(*bypass_ALL, &Gtk::CheckButton::set_inconsistent), true)); + bypass_dirpyrDenoiseConn = bypass_dirpyrDenoise->signal_toggled().connect (sigc::bind (sigc::mem_fun(*bypass_ALL, &Gtk::CheckButton::set_inconsistent), true)); + bypass_sh_hqConn = bypass_sh_hq->signal_toggled().connect (sigc::bind (sigc::mem_fun(*bypass_ALL, &Gtk::CheckButton::set_inconsistent), true)); + bypass_dirpyrequalizerConn = bypass_dirpyrequalizer->signal_toggled().connect (sigc::bind (sigc::mem_fun(*bypass_ALL, &Gtk::CheckButton::set_inconsistent), true)); + bypass_raw_all_enhanceConn = bypass_raw_all_enhance->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_dcb_iterationsConn = bypass_raw_dcb_iterations->signal_toggled().connect (sigc::bind (sigc::mem_fun(*bypass_ALL, &Gtk::CheckButton::set_inconsistent), true)); + bypass_raw_dcb_enhanceConn = bypass_raw_dcb_enhance->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_linenoiseConn = bypass_raw_linenoise->signal_toggled().connect (sigc::bind (sigc::mem_fun(*bypass_ALL, &Gtk::CheckButton::set_inconsistent), true)); + bypass_raw_greenthreshConn = bypass_raw_greenthresh->signal_toggled().connect (sigc::bind (sigc::mem_fun(*bypass_ALL, &Gtk::CheckButton::set_inconsistent), true)); + bypass_raw_dfConn = bypass_raw_df->signal_toggled().connect (sigc::bind (sigc::mem_fun(*bypass_ALL, &Gtk::CheckButton::set_inconsistent), true)); + bypass_raw_ffConn = bypass_raw_ff->signal_toggled().connect (sigc::bind (sigc::mem_fun(*bypass_ALL, &Gtk::CheckButton::set_inconsistent), true)); + + LoadDefaultSettings(); +} + +/*bool ExportPanel::isEnabled () { + + return enabled->get_active () && is_sensitive(); +}*/ + + +void ExportPanel::FastExportPressed (){ + // options is the container for making these settings available globally. + // Therefore, settings must be saved to options before they are used further + SaveSettingsAsDefault(); + + if (listener) + listener->exportRequested (); +} + +void ExportPanel::SaveSettingsAsDefault(){ + // Save fast export settings to options + options.fastexport_bypass_sharpening = bypass_sharpening->get_active (); + options.fastexport_bypass_sharpenEdge = bypass_sharpenEdge->get_active (); + options.fastexport_bypass_sharpenMicro = bypass_sharpenMicro->get_active (); + options.fastexport_bypass_lumaDenoise = bypass_lumaDenoise->get_active (); + options.fastexport_bypass_colorDenoise = bypass_colorDenoise->get_active (); + options.fastexport_bypass_defringe = bypass_defringe->get_active (); + options.fastexport_bypass_dirpyrDenoise = bypass_dirpyrDenoise->get_active (); + options.fastexport_bypass_sh_hq = bypass_sh_hq->get_active (); + options.fastexport_bypass_dirpyrequalizer = bypass_dirpyrequalizer->get_active (); + options.fastexport_bypass_raw_all_enhance = bypass_raw_all_enhance->get_active (); + options.fastexport_bypass_raw_ccSteps = bypass_raw_ccSteps->get_active (); + options.fastexport_bypass_raw_dcb_iterations = bypass_raw_dcb_iterations->get_active(); + options.fastexport_bypass_raw_dcb_enhance = bypass_raw_dcb_enhance->get_active (); + options.fastexport_bypass_raw_ca = bypass_raw_ca->get_active (); + options.fastexport_bypass_raw_linenoise = bypass_raw_linenoise->get_active (); + options.fastexport_bypass_raw_greenthresh = bypass_raw_greenthresh->get_active (); + options.fastexport_bypass_raw_df = bypass_raw_df->get_active (); + options.fastexport_bypass_raw_ff = bypass_raw_ff->get_active (); + + //saving demosaic_method + int currentRow = raw_dmethod->get_active_row_number(); + if( currentRow>=0 && currentRow < procparams::RAWParams::numMethods) + options.fastexport_raw_dmethod = procparams::RAWParams::methodstring[currentRow]; + +// options.fastexport_icm_input = icm_input ; +// options.fastexport_icm_working = icm_working ; +// options.fastexport_icm_output = icm_output ; +// options.fastexport_icm_gamma = icm_gamma ; +// options.fastexport_resize_enabled = resize_enabled ; +// options.fastexport_resize_scale = resize_scale ; +// options.fastexport_resize_appliesTo = resize_appliesTo; +// options.fastexport_resize_dataspec = resize_dataspec ; + + options.fastexport_resize_method = "Lanczos"; + if (resize_method->get_active_row_number() == 0) + options.fastexport_resize_method = "Nearest"; + else if (resize_method->get_active_row_number() == 1) + options.fastexport_resize_method = "Bilinear"; + else if (resize_method->get_active_row_number() == 2) + options.fastexport_resize_method = "Bicubic"; + else if (resize_method->get_active_row_number() == 3) + options.fastexport_resize_method = "Bicubic (Softer)"; + else if (resize_method->get_active_row_number() == 4) + options.fastexport_resize_method = "Bicubic (Sharper)"; + else if (resize_method->get_active_row_number() == 5) + options.fastexport_resize_method = "Lanczos"; + + options.fastexport_resize_width = MaxWidth->get_value_as_int (); + options.fastexport_resize_height = MaxHeight->get_value_as_int (); +} + +void ExportPanel::LoadDefaultSettings(){ + // Load fast export settings from options + bypass_sharpening->set_active (options.fastexport_bypass_sharpening ); + bypass_sharpenEdge->set_active (options.fastexport_bypass_sharpenEdge ); + bypass_sharpenMicro->set_active (options.fastexport_bypass_sharpenMicro ); + bypass_lumaDenoise->set_active (options.fastexport_bypass_lumaDenoise ); + bypass_colorDenoise->set_active (options.fastexport_bypass_colorDenoise ); + bypass_defringe->set_active (options.fastexport_bypass_defringe ); + bypass_dirpyrDenoise->set_active (options.fastexport_bypass_dirpyrDenoise ); + bypass_sh_hq->set_active (options.fastexport_bypass_sh_hq ); + bypass_dirpyrequalizer->set_active (options.fastexport_bypass_dirpyrequalizer ); + bypass_raw_all_enhance->set_active (options.fastexport_bypass_raw_all_enhance ); + bypass_raw_ccSteps->set_active (options.fastexport_bypass_raw_ccSteps ); + bypass_raw_dcb_iterations->set_active(options.fastexport_bypass_raw_dcb_iterations ); + bypass_raw_dcb_enhance->set_active (options.fastexport_bypass_raw_dcb_enhance ); + bypass_raw_ca->set_active (options.fastexport_bypass_raw_ca ); + bypass_raw_linenoise->set_active (options.fastexport_bypass_raw_linenoise ); + bypass_raw_greenthresh->set_active (options.fastexport_bypass_raw_greenthresh ); + bypass_raw_df->set_active (options.fastexport_bypass_raw_df ); + bypass_raw_ff->set_active (options.fastexport_bypass_raw_ff ); + + //demosaic method + raw_dmethod->set_active(procparams::RAWParams::numMethods); + for( size_t i=0; i< procparams::RAWParams::numMethods;i++) + if( options.fastexport_raw_dmethod == procparams::RAWParams::methodstring[i]){ + raw_dmethod->set_active(i); + break; + } + +// icm_input = options.fastexport_icm_input ; +// icm_working = options.fastexport_icm_working ; +// icm_output = options.fastexport_icm_output ; +// icm_gamma = options.fastexport_icm_gamma ; +// resize_enabled = options.fastexport_resize_enabled ; +// resize_scale = options.fastexport_resize_scale ; +// resize_appliesTo = options.fastexport_resize_appliesTo; +// resize_dataspec = options.fastexport_resize_dataspec ; + + resize_method->set_active (2); + if (options.fastexport_resize_method == "Nearest") + resize_method->set_active (0); + else if (options.fastexport_resize_method == "Bilinear") + resize_method->set_active (1); + else if (options.fastexport_resize_method == "Bicubic") + resize_method->set_active (2); + else if (options.fastexport_resize_method == "Bicubic (Softer)") + resize_method->set_active (3); + else if (options.fastexport_resize_method == "Bicubic (Sharper)") + resize_method->set_active (4); + else if (options.fastexport_resize_method == "Lanczos") + resize_method->set_active (5); + else if (options.fastexport_resize_method == "Downscale (Better)" || + options.fastexport_resize_method == "Downscale (Faster)") + { + resize_method->set_active (5); + } + + MaxWidth->set_value(options.fastexport_resize_width); + MaxHeight->set_value(options.fastexport_resize_height); +} + +void ExportPanel::LoadSettings(){ + // load settings from file +} + +void ExportPanel::SaveSettings(){ + // save settings to file + +} + +void ExportPanel::bypassALL_Toggled(){ + bypass_sharpeningConn.block (true); + bypass_sharpenEdgeConn.block (true); + bypass_sharpenMicroConn.block (true); + bypass_lumaDenoiseConn.block (true); + bypass_colorDenoiseConn.block (true); + bypass_defringeConn.block (true); + bypass_dirpyrDenoiseConn.block (true); + bypass_sh_hqConn.block (true); + bypass_dirpyrequalizerConn.block (true); + bypass_raw_all_enhanceConn.block (true); + bypass_raw_ccStepsConn.block (true); + bypass_raw_dcb_iterationsConn.block (true); + bypass_raw_dcb_enhanceConn.block (true); + bypass_raw_caConn.block (true); + bypass_raw_linenoiseConn.block (true); + bypass_raw_greenthreshConn.block (true); + bypass_raw_dfConn.block (true); + bypass_raw_ffConn.block (true); + + bypass_ALL->set_inconsistent (false); + + bypass_sharpening->set_active(bypass_ALL->get_active()); + bypass_sharpenEdge->set_active(bypass_ALL->get_active()); + bypass_sharpenMicro->set_active(bypass_ALL->get_active()); + bypass_lumaDenoise->set_active(bypass_ALL->get_active()); + bypass_colorDenoise->set_active(bypass_ALL->get_active()); + bypass_defringe->set_active(bypass_ALL->get_active()); + bypass_dirpyrDenoise->set_active(bypass_ALL->get_active()); + bypass_sh_hq->set_active(bypass_ALL->get_active()); + bypass_dirpyrequalizer->set_active(bypass_ALL->get_active()); + bypass_raw_all_enhance->set_active(bypass_ALL->get_active()); + bypass_raw_ccSteps->set_active(bypass_ALL->get_active()); + bypass_raw_dcb_iterations->set_active(bypass_ALL->get_active()); + bypass_raw_dcb_enhance->set_active(bypass_ALL->get_active()); + bypass_raw_ca->set_active(bypass_ALL->get_active()); + bypass_raw_linenoise->set_active(bypass_ALL->get_active()); + bypass_raw_greenthresh->set_active(bypass_ALL->get_active()); + bypass_raw_df->set_active(bypass_ALL->get_active()); + bypass_raw_ff->set_active(bypass_ALL->get_active()); + + bypass_sharpeningConn.block (false); + bypass_sharpenEdgeConn.block (false); + bypass_sharpenMicroConn.block (false); + bypass_lumaDenoiseConn.block (false); + bypass_colorDenoiseConn.block (false); + bypass_defringeConn.block (false); + bypass_dirpyrDenoiseConn.block (false); + bypass_sh_hqConn.block (false); + bypass_dirpyrequalizerConn.block (false); + bypass_raw_all_enhanceConn.block (false); + bypass_raw_ccStepsConn.block (false); + bypass_raw_dcb_iterationsConn.block (false); + bypass_raw_dcb_enhanceConn.block (false); + bypass_raw_caConn.block (false); + bypass_raw_linenoiseConn.block (false); + bypass_raw_greenthreshConn.block (false); + bypass_raw_dfConn.block (false); + bypass_raw_ffConn.block (false); +} + +/* +fastexport_bypass_sharpening +fastexport_bypass_sharpenEdge +fastexport_bypass_sharpenMicro +fastexport_bypass_lumaDenoise +fastexport_bypass_colorDenoise +fastexport_bypass_defringe +fastexport_bypass_dirpyrDenoise +fastexport_bypass_sh_hq +fastexport_bypass_dirpyrequalizer +fastexport_bypass_raw_all_enhance +fastexport_bypass_raw_ccSteps +fastexport_bypass_raw_dcb_iterations +fastexport_bypass_raw_dcb_enhance +fastexport_bypass_raw_ca +fastexport_bypass_raw_linenoise +fastexport_bypass_raw_greenthresh +fastexport_bypass_raw_df +fastexport_bypass_raw_ff +fastexport_raw_dmethod +fastexport_icm_input +fastexport_icm_working +fastexport_icm_output +fastexport_icm_gamma +fastexport_resize_enabled +fastexport_resize_scale +fastexport_resize_appliesTo +fastexport_resize_method +fastexport_resize_dataspec +fastexport_resize_width +fastexport_resize_height +*/ diff --git a/rtgui/exportpanel.h b/rtgui/exportpanel.h new file mode 100644 index 000000000..d9cd8661e --- /dev/null +++ b/rtgui/exportpanel.h @@ -0,0 +1,114 @@ +/* + * This file is part of RawTherapee. + * + * Copyright (c) 2004-2012 Gabor Horvath + * Copyright (c) 2012 Michael Ezra + * + * RawTherapee is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * RawTherapee is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with RawTherapee. If not, see . + */ +#ifndef _EXPORTPANEL_ +#define _EXPORTPANEL_ + +#include +#include "guiutils.h" +#include "adjuster.h" + +class ExportPanelListener { + + public: + virtual void exportRequested () {} +}; + +class ExportPanel : public Gtk::VBox { + + protected: + + //Gtk::CheckButton* enabled; + Gtk::CheckButton* bypass_ALL; + Gtk::CheckButton* bypass_sharpenEdge; + Gtk::CheckButton* bypass_sharpenMicro; + Gtk::CheckButton* bypass_sharpening; + Gtk::CheckButton* bypass_lumaDenoise; + Gtk::CheckButton* bypass_colorDenoise; + Gtk::CheckButton* bypass_defringe; + Gtk::CheckButton* bypass_dirpyrDenoise; + Gtk::CheckButton* bypass_sh_hq; + +/* icm_input = "(camera)"; + icm_working = "sRGB"; + icm_output = "RT_sRGB"; + icm_gamma = "default"; +*/ + Gtk::CheckButton* bypass_dirpyrequalizer; // also could leave untouched but disable only small radius adjustments + Gtk::CheckButton* bypass_raw_all_enhance; + + Gtk::CheckButton* bypass_raw_ca; // wraps raw.cared, raw.cablue, raw.ca_autocorrect + Gtk::CheckButton* bypass_raw_df; //wraps raw.dark_frame, raw.df_AutoSelect + Gtk::CheckButton* bypass_raw_ff; //wraps raw.ff_file, raw.ff_AutoSelect + MyComboBoxText* raw_dmethod; + MyComboBoxText* resize_method; + + Gtk::CheckButton* bypass_raw_dcb_iterations; + Gtk::CheckButton* bypass_raw_dcb_enhance; + Gtk::CheckButton* bypass_raw_ccSteps; + Gtk::CheckButton* raw_all_enhance; + Gtk::CheckButton* bypass_raw_linenoise; + Gtk::CheckButton* bypass_raw_greenthresh; + + Gtk::Button* btnFastExport; + Gtk::Button* btnExportLoadSettings; + Gtk::Button* btnExportSaveSettings; + + MySpinButton* MaxWidth; + MySpinButton* MaxHeight; + + sigc::connection enabledconn, bypass_ALLconn, FastExportconn, ExportLoadSettingsconn, ExportSaveSettingsconn; + sigc::connection bypass_sharpeningConn ; + sigc::connection bypass_sharpenEdgeConn ; + sigc::connection bypass_sharpenMicroConn ; + sigc::connection bypass_lumaDenoiseConn ; + sigc::connection bypass_colorDenoiseConn ; + sigc::connection bypass_defringeConn ; + sigc::connection bypass_dirpyrDenoiseConn ; + sigc::connection bypass_sh_hqConn ; + sigc::connection bypass_dirpyrequalizerConn ; + sigc::connection bypass_raw_all_enhanceConn ; + sigc::connection bypass_raw_ccStepsConn ; + sigc::connection bypass_raw_dcb_iterationsConn; + sigc::connection bypass_raw_dcb_enhanceConn ; + sigc::connection bypass_raw_caConn ; + sigc::connection bypass_raw_linenoiseConn ; + sigc::connection bypass_raw_greenthreshConn ; + sigc::connection bypass_raw_dfConn ; + sigc::connection bypass_raw_ffConn ; + + + ExportPanelListener* listener; + + void bypassALL_Toggled(); + void SaveSettingsAsDefault(); + void LoadDefaultSettings(); + void LoadSettings(); + void SaveSettings(); + + public: + ExportPanel (); + + void FastExportPressed (); + //bool isEnabled (); + + void setExportPanelListener (ExportPanelListener* l) { listener = l; } +}; + +#endif diff --git a/rtgui/filebrowser.cc b/rtgui/filebrowser.cc index 93d7bb987..a558572b2 100644 --- a/rtgui/filebrowser.cc +++ b/rtgui/filebrowser.cc @@ -48,6 +48,7 @@ FileBrowser::FileBrowser () pmenu->attach (*Gtk::manage(open = new Gtk::MenuItem (M("FILEBROWSER_POPUPOPEN"))), 0, 1, p, p+1); p++; pmenu->attach (*Gtk::manage(develop = new Gtk::ImageMenuItem (M("FILEBROWSER_POPUPPROCESS"))), 0, 1, p, p+1); p++; develop->set_image(*Gtk::manage(new RTImage ("processing.png"))); + pmenu->attach (*Gtk::manage(developfast = new Gtk::ImageMenuItem (M("FILEBROWSER_POPUPPROCESSFAST"))), 0, 1, p, p+1); p++; pmenu->attach (*Gtk::manage(new Gtk::SeparatorMenuItem ()), 0, 1, p, p+1); p++; pmenu->attach (*Gtk::manage(selall = new Gtk::MenuItem (M("FILEBROWSER_POPUPSELECTALL"))), 0, 1, p, p+1); p++; @@ -196,6 +197,7 @@ FileBrowser::FileBrowser () trash->signal_activate().connect (sigc::bind(sigc::mem_fun(*this, &FileBrowser::menuItemActivated), trash)); untrash->signal_activate().connect (sigc::bind(sigc::mem_fun(*this, &FileBrowser::menuItemActivated), untrash)); develop->signal_activate().connect (sigc::bind(sigc::mem_fun(*this, &FileBrowser::menuItemActivated), develop)); + developfast->signal_activate().connect (sigc::bind(sigc::mem_fun(*this, &FileBrowser::menuItemActivated), developfast)); rename->signal_activate().connect (sigc::bind(sigc::mem_fun(*this, &FileBrowser::menuItemActivated), rename)); remove->signal_activate().connect (sigc::bind(sigc::mem_fun(*this, &FileBrowser::menuItemActivated), remove)); removeInclProc->signal_activate().connect (sigc::bind(sigc::mem_fun(*this, &FileBrowser::menuItemActivated), removeInclProc)); @@ -473,8 +475,12 @@ void FileBrowser::menuItemActivated (Gtk::MenuItem* m) { toTrashRequested (mselected); else if (m==untrash) fromTrashRequested (mselected); + else if (m==develop) - tbl->developRequested (mselected); + tbl->developRequested (mselected, false); + else if (m==developfast) + tbl->developRequested (mselected, true); + else if (m==rename) tbl->renameRequested (mselected); else if (m==selall) { @@ -926,7 +932,7 @@ void FileBrowser::buttonPressed (LWButton* button, int actionCode, void* actionD else if (actionCode==6 && tbl) { // to processing queue std::vector tbe; tbe.push_back ((FileBrowserEntry*)actionData); - tbl->developRequested (tbe); + tbl->developRequested (tbe, false); // not a fast, but a FULL mode } else if (actionCode==7) { // to trash / undelete std::vector tbe; @@ -1020,3 +1026,16 @@ void FileBrowser::redrawNeeded (LWButton* button) { FileBrowser::type_trash_changed FileBrowser::trash_changed () { return m_trash_changed; } + + +// ExportPanel interface +void FileBrowser::exportRequested (){ + FileBrowser::menuItemActivated(developfast); +} + +void FileBrowser::setExportPanel (ExportPanel* expanel) { + + exportPanel = expanel; + exportPanel->set_sensitive (false); + exportPanel->setExportPanelListener (this); +} diff --git a/rtgui/filebrowser.h b/rtgui/filebrowser.h index 7746949ef..cdd38d499 100644 --- a/rtgui/filebrowser.h +++ b/rtgui/filebrowser.h @@ -25,6 +25,7 @@ #include "filebrowserentry.h" #include "browserfilter.h" #include "partialpastedlg.h" +#include "exportpanel.h" class FileBrowser; class FileBrowserEntry; @@ -32,7 +33,7 @@ class FileBrowserListener { public: virtual void openRequested (std::vector tbe) {} - virtual void developRequested (std::vector tbe) {} + virtual void developRequested (std::vector tbe, bool fastmode) {} virtual void renameRequested (std::vector tbe) {} virtual void deleteRequested (std::vector tbe, bool inclBatchProcessed) {} virtual void copyMoveRequested (std::vector tbe, bool moveRequested) {} @@ -49,7 +50,9 @@ struct FileBrowserIdleHelper { /* * Class handling actions common to all thumbnails of the file browser */ -class FileBrowser : public ThumbBrowserBase, public LWButtonListener { +class FileBrowser : public ThumbBrowserBase, + public LWButtonListener, + public ExportPanelListener{ typedef sigc::signal type_trash_changed; @@ -60,6 +63,7 @@ class FileBrowser : public ThumbBrowserBase, public LWButtonListener { Gtk::MenuItem* trash; Gtk::MenuItem* untrash; Gtk::ImageMenuItem* develop; + Gtk::ImageMenuItem* developfast; Gtk::MenuItem* rename; Gtk::MenuItem* remove; Gtk::MenuItem* removeInclProc; @@ -108,6 +112,8 @@ class FileBrowser : public ThumbBrowserBase, public LWButtonListener { void colorlabelRequested (std::vector tbe, int colorlabel); void notifySelectionListener (); + ExportPanel* exportPanel; + type_trash_changed m_trash_changed; public: @@ -149,6 +155,10 @@ class FileBrowser : public ThumbBrowserBase, public LWButtonListener { void selectionChanged (); + void setExportPanel (ExportPanel* expanel); + // exportpanel interface + void exportRequested(); + type_trash_changed trash_changed(); }; diff --git a/rtgui/filecatalog.cc b/rtgui/filecatalog.cc index 1707d662e..339c735af 100644 --- a/rtgui/filecatalog.cc +++ b/rtgui/filecatalog.cc @@ -431,6 +431,9 @@ void FileCatalog::closeDir () { if (filterPanel) filterPanel->set_sensitive (false); + + if (exportPanel) + exportPanel->set_sensitive (false); #ifndef WIN32 if (dirMonitor) @@ -627,6 +630,10 @@ void FileCatalog::previewsFinishedUI () { filterPanel->setFilter ( currentEFS,false ); } } + + if (exportPanel) + exportPanel->set_sensitive (true); + // restart anything that might have been loaded low quality fileBrowser->refreshQuickThumbImages(); fileBrowser->applyFilter (getFilter()); // refresh total image count @@ -843,7 +850,7 @@ void FileCatalog::copyMoveRequested (std::vector tbe, bool m _refreshProgressBar(); } // Gtk::RESPONSE_OK } -void FileCatalog::developRequested (std::vector tbe) { +void FileCatalog::developRequested (std::vector tbe, bool fastmode) { if (listener) { std::vector entries; @@ -851,6 +858,44 @@ void FileCatalog::developRequested (std::vector tbe) { #pragma omp parallel for ordered for (size_t i=0; ithumbnail->getProcParams(); + + // if fast mode is selected, override (disable) prams + // controlling time and resource consuming tasks + // and also those which effect is not pronounced after reducing the image size + // TODO!!! could expose selections below via preferences + if (fastmode){ + if (options.fastexport_bypass_sharpening ) params.sharpening.enabled = false; + if (options.fastexport_bypass_sharpenEdge ) params.sharpenEdge.enabled = false; + if (options.fastexport_bypass_sharpenMicro ) params.sharpenMicro.enabled = false; + if (options.fastexport_bypass_lumaDenoise ) params.lumaDenoise.enabled = false; + if (options.fastexport_bypass_colorDenoise ) params.colorDenoise.enabled = false; + if (options.fastexport_bypass_defringe ) params.defringe.enabled = false; + if (options.fastexport_bypass_dirpyrDenoise ) params.dirpyrDenoise.enabled = false; + if (options.fastexport_bypass_sh_hq ) params.sh.hq = false; + if (options.fastexport_bypass_dirpyrequalizer ) params.dirpyrequalizer.enabled = false; + if (options.fastexport_bypass_raw_all_enhance ) params.raw.all_enhance = false; + if (options.fastexport_bypass_raw_ccSteps ) params.raw.ccSteps = 0; + if (options.fastexport_bypass_raw_dcb_iterations ) params.raw.dcb_iterations = 0; + if (options.fastexport_bypass_raw_dcb_enhance ) params.raw.dcb_enhance = false; + if (options.fastexport_bypass_raw_ca ) {params.raw.ca_autocorrect =false; params.raw.cared=0; params.raw.cablue=0;} + if (options.fastexport_bypass_raw_linenoise ) params.raw.linenoise = 0; + if (options.fastexport_bypass_raw_greenthresh ) params.raw.greenthresh = 0; + if (options.fastexport_bypass_raw_df ) {params.raw.df_autoselect = false; params.raw.dark_frame="";} + if (options.fastexport_bypass_raw_ff ) {params.raw.ff_AutoSelect = false; params.raw.ff_file="";} + params.raw.dmethod = options.fastexport_raw_dmethod ; + params.icm.input = options.fastexport_icm_input ; + params.icm.working = options.fastexport_icm_working ; + params.icm.output = options.fastexport_icm_output ; + params.icm.gamma = options.fastexport_icm_gamma ; + params.resize.enabled = options.fastexport_resize_enabled ; + params.resize.scale = options.fastexport_resize_scale ; + params.resize.appliesTo = options.fastexport_resize_appliesTo; + params.resize.method = options.fastexport_resize_method ; + params.resize.dataspec = options.fastexport_resize_dataspec ; + params.resize.width = options.fastexport_resize_width ; + params.resize.height = options.fastexport_resize_height ; + } + rtengine::ProcessingJob* pjob = rtengine::ProcessingJob::create (tbe[i]->filename, tbe[i]->thumbnail->getType()==FT_Raw, params); double tmpscale; rtengine::IImage8* img = tbe[i]->thumbnail->processThumbImage (params, BatchQueue::calcMaxThumbnailHeight(), tmpscale); @@ -880,6 +925,18 @@ void FileCatalog::developRequested (std::vector tbe) { } } +void FileCatalog::exportRequested (){ + +} + +void FileCatalog::setExportPanel (ExportPanel* expanel) { + + exportPanel = expanel; + exportPanel->set_sensitive (false); + exportPanel->setExportPanelListener (this); + fileBrowser->setExportPanel(expanel); +} + void FileCatalog::renameRequested (std::vector tbe) { bool success; diff --git a/rtgui/filecatalog.h b/rtgui/filecatalog.h index 95b14f7fd..f5b2da436 100644 --- a/rtgui/filecatalog.h +++ b/rtgui/filecatalog.h @@ -33,6 +33,7 @@ #include "coarsepanel.h" #include "toolbar.h" #include "filterpanel.h" +#include "exportpanel.h" #include "previewloader.h" #include "multilangmgr.h" @@ -59,7 +60,8 @@ class FileCatalog : public Gtk::VBox, public DirSelectionListener, public PreviewLoaderListener, public FilterPanelListener, - public FileBrowserListener + public FileBrowserListener, + public ExportPanelListener #ifdef WIN32 , public WinDirChangeListener #endif @@ -133,6 +135,7 @@ class FileCatalog : public Gtk::VBox, bool hasValidCurrentEFS; FilterPanel* filterPanel; + ExportPanel* exportPanel; int previewsToLoad; int previewsLoaded; @@ -177,6 +180,9 @@ class FileCatalog : public Gtk::VBox, // filterpanel interface void exifFilterChanged (); + // exportpanel interface + void exportRequested(); + Glib::ustring lastSelectedDir () { return selectedDirectory; } void setEnabled (bool e); // if not enabled, it does not open image void enableTabMode(bool enable); // sets progress bar @@ -189,7 +195,7 @@ class FileCatalog : public Gtk::VBox, void openRequested (std::vector tbe); void deleteRequested (std::vector tbe, bool inclBatchProcessed); void copyMoveRequested (std::vector tbe, bool moveRequested); - void developRequested (std::vector tbe); + void developRequested (std::vector tbe, bool fastmode); void renameRequested (std::vector tbe); void clearFromCacheRequested(std::vector tbe, bool leavenotrace); void selectionChanged (std::vector tbe); @@ -202,6 +208,7 @@ class FileCatalog : public Gtk::VBox, void setDirBrowserRemoteInterface (DirBrowserRemoteInterface* l) { dirlistener = l; } void setFilterPanel (FilterPanel* fpanel); + void setExportPanel (ExportPanel* expanel); void exifInfoButtonToggled(); void categoryButtonToggled (Gtk::ToggleButton* b); bool capture_event(GdkEventButton* event); diff --git a/rtgui/filepanel.cc b/rtgui/filepanel.cc index 405f8ee1e..4e0863752 100644 --- a/rtgui/filepanel.cc +++ b/rtgui/filepanel.cc @@ -78,7 +78,13 @@ FilePanel::FilePanel () : parent(NULL) { sFilterPanel->add (*filterPanel); sFilterPanel->set_policy(Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC); + Gtk::ScrolledWindow* sExportPanel = Gtk::manage ( new Gtk::ScrolledWindow() ); + exportPanel = Gtk::manage ( new ExportPanel () ); + sExportPanel->add (*exportPanel); + sExportPanel->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC); + fileCatalog->setFilterPanel (filterPanel); + fileCatalog->setExportPanel (exportPanel); fileCatalog->setImageAreaToolListener (tpc); //------------------ @@ -91,6 +97,8 @@ FilePanel::FilePanel () : parent(NULL) { filtLab->set_angle (90); //Gtk::Label* tagLab = Gtk::manage ( new Gtk::Label (M("MAIN_TAB_TAGGING")) ); //tagLab->set_angle (90); + Gtk::Label* exportLab = Gtk::manage ( new Gtk::Label (M("MAIN_TAB_EXPORT")) ); + exportLab->set_angle (90); tpcPaned = Gtk::manage ( new Gtk::VPaned () ); tpcPaned->pack1 (*tpc->toolPanelNotebook, false, true); @@ -99,6 +107,7 @@ FilePanel::FilePanel () : parent(NULL) { rightNotebook->append_page (*tpcPaned, *devLab); rightNotebook->append_page (*sFilterPanel, *filtLab); //rightNotebook->append_page (*taggingBox, *tagLab); commented out: currently the tab is empty ... + rightNotebook->append_page (*sExportPanel, *exportLab); rightBox->pack_start (*rightNotebook); diff --git a/rtgui/filepanel.h b/rtgui/filepanel.h index 041faa7ba..18d1ac59c 100644 --- a/rtgui/filepanel.h +++ b/rtgui/filepanel.h @@ -29,6 +29,7 @@ #include "pparamschangelistener.h" #include "history.h" #include "filterpanel.h" +#include "exportpanel.h" #include "progressconnector.h" class RTWindow; @@ -61,6 +62,7 @@ class FilePanel : public Gtk::HPaned, DirBrowser* dirBrowser; FilterPanel* filterPanel; + ExportPanel* exportPanel; FileCatalog* fileCatalog; Gtk::Paned *ribbonPane; diff --git a/rtgui/filterpanel.cc b/rtgui/filterpanel.cc index 5483d08f5..3f0a03cbb 100644 --- a/rtgui/filterpanel.cc +++ b/rtgui/filterpanel.cc @@ -19,6 +19,7 @@ #include "filterpanel.h" #include "multilangmgr.h" #include "../rtengine/rtengine.h" +#include "rtimage.h" using namespace rtengine; @@ -122,6 +123,14 @@ FilterPanel::FilterPanel () : listener (NULL) { ftvb->pack_start (*sfiletype, Gtk::PACK_SHRINK, 0); pack_start (*ftvb, 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); + conns = 0; sChange[conns++] = fnumberFrom->signal_changed().connect (sigc::mem_fun(*this, &FilterPanel::valueChanged)); sChange[conns++] = fnumberTo->signal_changed().connect (sigc::mem_fun(*this, &FilterPanel::valueChanged)); diff --git a/rtgui/options.cc b/rtgui/options.cc index 2bf862a75..fab5ec2a1 100644 --- a/rtgui/options.cc +++ b/rtgui/options.cc @@ -162,6 +162,37 @@ void Options::setDefaults () { menuGroupFileOperations = true; menuGroupProfileOperations = true; + fastexport_bypass_sharpening = true; + fastexport_bypass_sharpenEdge = true; + fastexport_bypass_sharpenMicro = true; + fastexport_bypass_lumaDenoise = true; + fastexport_bypass_colorDenoise = true; + fastexport_bypass_defringe = true; + fastexport_bypass_dirpyrDenoise = true; + fastexport_bypass_sh_hq = true; + fastexport_bypass_dirpyrequalizer = true; + fastexport_bypass_raw_all_enhance = true; + fastexport_bypass_raw_ccSteps = true; + fastexport_bypass_raw_dcb_iterations = true; + fastexport_bypass_raw_dcb_enhance = true; + fastexport_bypass_raw_ca = true; + fastexport_bypass_raw_linenoise = true; + fastexport_bypass_raw_greenthresh = true; + fastexport_bypass_raw_df = true; + fastexport_bypass_raw_ff = true; + fastexport_raw_dmethod = "fast"; + fastexport_icm_input = "(camera)"; + fastexport_icm_working = "sRGB"; + fastexport_icm_output = "RT_sRGB"; + fastexport_icm_gamma = "default"; + fastexport_resize_enabled = true; + fastexport_resize_scale = 1; + fastexport_resize_appliesTo = "Cropped area"; + fastexport_resize_method = "Lanczos"; + fastexport_resize_dataspec = 3; + fastexport_resize_width = 1000; + fastexport_resize_height = 1000; + cutOverlayBrush = std::vector (4); cutOverlayBrush[3] = 0.667; // :-p @@ -459,6 +490,38 @@ if (keyFile.has_group ("Sounds")) { if (keyFile.has_key ("Sounds", "LngEditProcDoneSecs")) sndLngEditProcDoneSecs = keyFile.get_double ("Sounds", "LngEditProcDoneSecs"); } +if (keyFile.has_group ("Fast Export")) { + if (keyFile.has_key ("Fast Export", "fastexport_bypass_sharpening" )) fastexport_bypass_sharpening = keyFile.get_boolean ("Fast Export", "fastexport_bypass_sharpening" ); + if (keyFile.has_key ("Fast Export", "fastexport_bypass_sharpenEdge" )) fastexport_bypass_sharpenEdge = keyFile.get_boolean ("Fast Export", "fastexport_bypass_sharpenEdge" ); + if (keyFile.has_key ("Fast Export", "fastexport_bypass_sharpenMicro" )) fastexport_bypass_sharpenMicro = keyFile.get_boolean ("Fast Export", "fastexport_bypass_sharpenMicro" ); + if (keyFile.has_key ("Fast Export", "fastexport_bypass_lumaDenoise" )) fastexport_bypass_lumaDenoise = keyFile.get_boolean ("Fast Export", "fastexport_bypass_lumaDenoise" ); + if (keyFile.has_key ("Fast Export", "fastexport_bypass_colorDenoise" )) fastexport_bypass_colorDenoise = keyFile.get_boolean ("Fast Export", "fastexport_bypass_colorDenoise" ); + if (keyFile.has_key ("Fast Export", "fastexport_bypass_defringe" )) fastexport_bypass_defringe = keyFile.get_boolean ("Fast Export", "fastexport_bypass_defringe" ); + if (keyFile.has_key ("Fast Export", "fastexport_bypass_dirpyrDenoise" )) fastexport_bypass_dirpyrDenoise = keyFile.get_boolean ("Fast Export", "fastexport_bypass_dirpyrDenoise" ); + if (keyFile.has_key ("Fast Export", "fastexport_bypass_sh_hq" )) fastexport_bypass_sh_hq = keyFile.get_boolean ("Fast Export", "fastexport_bypass_sh_hq" ); + if (keyFile.has_key ("Fast Export", "fastexport_bypass_dirpyrequalizer" )) fastexport_bypass_dirpyrequalizer = keyFile.get_boolean ("Fast Export", "fastexport_bypass_dirpyrequalizer" ); + if (keyFile.has_key ("Fast Export", "fastexport_bypass_raw_all_enhance" )) fastexport_bypass_raw_all_enhance = keyFile.get_boolean ("Fast Export", "fastexport_bypass_raw_all_enhance" ); + if (keyFile.has_key ("Fast Export", "fastexport_bypass_raw_ccSteps" )) fastexport_bypass_raw_ccSteps = keyFile.get_boolean ("Fast Export", "fastexport_bypass_raw_ccSteps" ); + if (keyFile.has_key ("Fast Export", "fastexport_bypass_raw_dcb_iterations")) fastexport_bypass_raw_dcb_iterations = keyFile.get_boolean ("Fast Export", "fastexport_bypass_raw_dcb_iterations"); + if (keyFile.has_key ("Fast Export", "fastexport_bypass_raw_dcb_enhance" )) fastexport_bypass_raw_dcb_enhance = keyFile.get_boolean ("Fast Export", "fastexport_bypass_raw_dcb_enhance" ); + if (keyFile.has_key ("Fast Export", "fastexport_bypass_raw_ca" )) fastexport_bypass_raw_ca = keyFile.get_boolean ("Fast Export", "fastexport_bypass_raw_ca" ); + if (keyFile.has_key ("Fast Export", "fastexport_bypass_raw_linenoise" )) fastexport_bypass_raw_linenoise = keyFile.get_boolean ("Fast Export", "fastexport_bypass_raw_linenoise" ); + if (keyFile.has_key ("Fast Export", "fastexport_bypass_raw_greenthresh" )) fastexport_bypass_raw_greenthresh = keyFile.get_boolean ("Fast Export", "fastexport_bypass_raw_greenthresh" ); + if (keyFile.has_key ("Fast Export", "fastexport_bypass_raw_df" )) fastexport_bypass_raw_df = keyFile.get_boolean ("Fast Export", "fastexport_bypass_raw_df" ); + if (keyFile.has_key ("Fast Export", "fastexport_bypass_raw_ff" )) fastexport_bypass_raw_ff = keyFile.get_boolean ("Fast Export", "fastexport_bypass_raw_ff" ); + if (keyFile.has_key ("Fast Export", "fastexport_raw_dmethod" )) fastexport_raw_dmethod = keyFile.get_string ("Fast Export", "fastexport_raw_dmethod" ); + if (keyFile.has_key ("Fast Export", "fastexport_icm_input" )) fastexport_icm_input = keyFile.get_string ("Fast Export", "fastexport_icm_input" ); + if (keyFile.has_key ("Fast Export", "fastexport_icm_working" )) fastexport_icm_working = keyFile.get_string ("Fast Export", "fastexport_icm_working" ); + if (keyFile.has_key ("Fast Export", "fastexport_icm_output" )) fastexport_icm_output = keyFile.get_string ("Fast Export", "fastexport_icm_output" ); + if (keyFile.has_key ("Fast Export", "fastexport_icm_gamma" )) fastexport_icm_gamma = keyFile.get_string ("Fast Export", "fastexport_icm_gamma" ); + if (keyFile.has_key ("Fast Export", "fastexport_resize_enabled" )) fastexport_resize_enabled = keyFile.get_boolean ("Fast Export", "fastexport_resize_enabled" ); + if (keyFile.has_key ("Fast Export", "fastexport_resize_scale" )) fastexport_resize_scale = keyFile.get_double ("Fast Export", "fastexport_resize_scale" ); + if (keyFile.has_key ("Fast Export", "fastexport_resize_appliesTo" )) fastexport_resize_appliesTo = keyFile.get_string ("Fast Export", "fastexport_resize_appliesTo" ); + if (keyFile.has_key ("Fast Export", "fastexport_resize_method" )) fastexport_resize_method = keyFile.get_string ("Fast Export", "fastexport_resize_method" ); + if (keyFile.has_key ("Fast Export", "fastexport_resize_dataspec" )) fastexport_resize_dataspec = keyFile.get_integer ("Fast Export", "fastexport_resize_dataspec" ); + if (keyFile.has_key ("Fast Export", "fastexport_resize_width" )) fastexport_resize_width = keyFile.get_integer ("Fast Export", "fastexport_resize_width" ); + if (keyFile.has_key ("Fast Export", "fastexport_resize_height" )) fastexport_resize_height = keyFile.get_integer ("Fast Export", "fastexport_resize_height" ); +} filterOutParsedExtensions (); return 0; @@ -634,6 +697,38 @@ int Options::saveToFile (Glib::ustring fname) { keyFile.set_double ("Sounds", "LngEditProcDoneSecs", sndLngEditProcDoneSecs); + keyFile.set_boolean ("Fast Export", "fastexport_bypass_sharpening" , fastexport_bypass_sharpening ); + keyFile.set_boolean ("Fast Export", "fastexport_bypass_sharpenEdge" , fastexport_bypass_sharpenEdge ); + keyFile.set_boolean ("Fast Export", "fastexport_bypass_sharpenMicro" , fastexport_bypass_sharpenMicro ); + keyFile.set_boolean ("Fast Export", "fastexport_bypass_lumaDenoise" , fastexport_bypass_lumaDenoise ); + keyFile.set_boolean ("Fast Export", "fastexport_bypass_colorDenoise" , fastexport_bypass_colorDenoise ); + keyFile.set_boolean ("Fast Export", "fastexport_bypass_defringe" , fastexport_bypass_defringe ); + keyFile.set_boolean ("Fast Export", "fastexport_bypass_dirpyrDenoise" , fastexport_bypass_dirpyrDenoise ); + keyFile.set_boolean ("Fast Export", "fastexport_bypass_sh_hq" , fastexport_bypass_sh_hq ); + keyFile.set_boolean ("Fast Export", "fastexport_bypass_dirpyrequalizer" , fastexport_bypass_dirpyrequalizer ); + keyFile.set_boolean ("Fast Export", "fastexport_bypass_raw_all_enhance" , fastexport_bypass_raw_all_enhance ); + keyFile.set_boolean ("Fast Export", "fastexport_bypass_raw_ccSteps" , fastexport_bypass_raw_ccSteps ); + keyFile.set_boolean ("Fast Export", "fastexport_bypass_raw_dcb_iterations" , fastexport_bypass_raw_dcb_iterations); + keyFile.set_boolean ("Fast Export", "fastexport_bypass_raw_dcb_enhance" , fastexport_bypass_raw_dcb_enhance ); + keyFile.set_boolean ("Fast Export", "fastexport_bypass_raw_ca" , fastexport_bypass_raw_ca ); + keyFile.set_boolean ("Fast Export", "fastexport_bypass_raw_linenoise" , fastexport_bypass_raw_linenoise ); + keyFile.set_boolean ("Fast Export", "fastexport_bypass_raw_greenthresh" , fastexport_bypass_raw_greenthresh ); + keyFile.set_boolean ("Fast Export", "fastexport_bypass_raw_df" , fastexport_bypass_raw_df ); + keyFile.set_boolean ("Fast Export", "fastexport_bypass_raw_ff" , fastexport_bypass_raw_ff ); + keyFile.set_string ("Fast Export", "fastexport_raw_dmethod" , fastexport_raw_dmethod ); + keyFile.set_string ("Fast Export", "fastexport_icm_input" , fastexport_icm_input ); + keyFile.set_string ("Fast Export", "fastexport_icm_working" , fastexport_icm_working ); + keyFile.set_string ("Fast Export", "fastexport_icm_output" , fastexport_icm_output ); + keyFile.set_string ("Fast Export", "fastexport_icm_gamma" , fastexport_icm_gamma ); + keyFile.set_boolean ("Fast Export", "fastexport_resize_enabled" , fastexport_resize_enabled ); + keyFile.set_double ("Fast Export", "fastexport_resize_scale" , fastexport_resize_scale ); + keyFile.set_string ("Fast Export", "fastexport_resize_appliesTo" , fastexport_resize_appliesTo ); + keyFile.set_string ("Fast Export", "fastexport_resize_method" , fastexport_resize_method ); + keyFile.set_integer ("Fast Export", "fastexport_resize_dataspec" , fastexport_resize_dataspec ); + keyFile.set_integer ("Fast Export", "fastexport_resize_width" , fastexport_resize_width ); + keyFile.set_integer ("Fast Export", "fastexport_resize_height" , fastexport_resize_height ); + + FILE *f = safe_g_fopen (fname, "wt"); if (f==NULL) return 1; diff --git a/rtgui/options.h b/rtgui/options.h index f64b607f6..bb28585ae 100644 --- a/rtgui/options.h +++ b/rtgui/options.h @@ -163,6 +163,38 @@ class Options { bool menuGroupFileOperations; bool menuGroupProfileOperations; + // fast export options + bool fastexport_bypass_sharpening; + bool fastexport_bypass_sharpenEdge; + bool fastexport_bypass_sharpenMicro; + bool fastexport_bypass_lumaDenoise; + bool fastexport_bypass_colorDenoise; + bool fastexport_bypass_defringe; + bool fastexport_bypass_dirpyrDenoise; + bool fastexport_bypass_sh_hq; + bool fastexport_bypass_dirpyrequalizer; + bool fastexport_bypass_raw_all_enhance; + bool fastexport_bypass_raw_ccSteps; + bool fastexport_bypass_raw_dcb_iterations; + bool fastexport_bypass_raw_dcb_enhance; + bool fastexport_bypass_raw_ca; + bool fastexport_bypass_raw_linenoise; + bool fastexport_bypass_raw_greenthresh; + bool fastexport_bypass_raw_df; + bool fastexport_bypass_raw_ff; + Glib::ustring fastexport_raw_dmethod; + Glib::ustring fastexport_icm_input; + Glib::ustring fastexport_icm_working; + Glib::ustring fastexport_icm_output; + Glib::ustring fastexport_icm_gamma; + bool fastexport_resize_enabled; + double fastexport_resize_scale; + Glib::ustring fastexport_resize_appliesTo; + Glib::ustring fastexport_resize_method; + int fastexport_resize_dataspec; + int fastexport_resize_width; + int fastexport_resize_height; + Options (); Options* copyFrom (Options* other);