527 lines
17 KiB
C++
527 lines
17 KiB
C++
/* -*- C++ -*-
|
|
* This file is part of RawTherapee.
|
|
*
|
|
* Copyright (c) 2017 Alberto Griggio
|
|
*
|
|
* RawTherapee is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* RawTherapee is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with RawTherapee. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "dynamicprofilepanel.h"
|
|
#include "multilangmgr.h"
|
|
#include "profilestore.h"
|
|
#include <sstream>
|
|
#include <iomanip>
|
|
|
|
namespace {
|
|
|
|
template <class V>
|
|
Glib::ustring to_str(V n, int precision=1)
|
|
{
|
|
std::ostringstream buf;
|
|
buf << std::setprecision(precision) << std::fixed << n;
|
|
return buf.str();
|
|
}
|
|
|
|
} // namespace
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// DynamicProfilePanel::EditDialog
|
|
//-----------------------------------------------------------------------------
|
|
|
|
DynamicProfilePanel::EditDialog::EditDialog(const Glib::ustring &title,
|
|
Gtk::Window &parent):
|
|
Gtk::Dialog(title, parent)
|
|
{
|
|
profilepath_ = Gtk::manage(new ProfileStoreComboBox());
|
|
Gtk::HBox *hb = Gtk::manage(new Gtk::HBox());
|
|
hb->pack_start(*Gtk::manage(new Gtk::Label(M("DYNPROFILEEDITOR_PROFILE"))),
|
|
false, false, 4);
|
|
hb->pack_start(*profilepath_, true, true, 2);
|
|
get_content_area()->pack_start(*hb, Gtk::PACK_SHRINK, 4);
|
|
|
|
add_optional(M("EXIFFILTER_CAMERA"), has_camera_, camera_);
|
|
add_optional(M("EXIFFILTER_LENS"), has_lens_, lens_);
|
|
|
|
add_range(M("EXIFFILTER_ISO"), iso_min_, iso_max_);
|
|
add_range(M("EXIFFILTER_APERTURE"), fnumber_min_, fnumber_max_);
|
|
add_range(M("EXIFFILTER_FOCALLEN"), focallen_min_, focallen_max_);
|
|
add_range(M("EXIFFILTER_SHUTTER"), shutterspeed_min_, shutterspeed_max_);
|
|
add_range(M("EXIFFILTER_EXPOSURECOMPENSATION"), expcomp_min_, expcomp_max_);
|
|
|
|
add_button(M("GENERAL_OK"), 1);
|
|
add_button(M("GENERAL_CANCEL"), 2);
|
|
|
|
set_ranges();
|
|
|
|
show_all_children();
|
|
}
|
|
|
|
|
|
void DynamicProfilePanel::EditDialog::set_rule(
|
|
const DynamicProfileRule &rule)
|
|
{
|
|
iso_min_->set_value(rule.iso.min);
|
|
iso_max_->set_value(rule.iso.max);
|
|
|
|
fnumber_min_->set_value(rule.fnumber.min);
|
|
fnumber_max_->set_value(rule.fnumber.max);
|
|
|
|
focallen_min_->set_value(rule.focallen.min);
|
|
focallen_max_->set_value(rule.focallen.max);
|
|
|
|
shutterspeed_min_->set_value(rule.shutterspeed.min);
|
|
shutterspeed_max_->set_value(rule.shutterspeed.max);
|
|
|
|
expcomp_min_->set_value(rule.expcomp.min);
|
|
expcomp_max_->set_value(rule.expcomp.max);
|
|
|
|
has_camera_->set_active(rule.camera.enabled);
|
|
camera_->set_text(rule.camera.value);
|
|
|
|
has_lens_->set_active(rule.lens.enabled);
|
|
lens_->set_text(rule.lens.value);
|
|
|
|
profilepath_->updateProfileList();
|
|
if (!profilepath_->setActiveRowFromFullPath(rule.profilepath)) {
|
|
profilepath_->setInternalEntry();
|
|
}
|
|
}
|
|
|
|
|
|
DynamicProfileRule DynamicProfilePanel::EditDialog::get_rule()
|
|
{
|
|
DynamicProfileRule ret;
|
|
ret.iso.min = iso_min_->get_value_as_int();
|
|
ret.iso.max = iso_max_->get_value_as_int();
|
|
|
|
ret.fnumber.min = fnumber_min_->get_value();
|
|
ret.fnumber.max = fnumber_max_->get_value();
|
|
|
|
ret.focallen.min = focallen_min_->get_value();
|
|
ret.focallen.max = focallen_max_->get_value();
|
|
|
|
ret.shutterspeed.min = shutterspeed_min_->get_value();
|
|
ret.shutterspeed.max = shutterspeed_max_->get_value();
|
|
|
|
ret.expcomp.min = expcomp_min_->get_value();
|
|
ret.expcomp.max = expcomp_max_->get_value();
|
|
|
|
ret.camera.enabled = has_camera_->get_active();
|
|
ret.camera.value = camera_->get_text();
|
|
|
|
ret.lens.enabled = has_lens_->get_active();
|
|
ret.lens.value = lens_->get_text();
|
|
|
|
ret.profilepath = profilepath_->getFullPathFromActiveRow();
|
|
|
|
return ret;
|
|
}
|
|
|
|
void DynamicProfilePanel::EditDialog::set_ranges()
|
|
{
|
|
DynamicProfileRule default_rule;
|
|
iso_min_->set_digits(0);
|
|
iso_max_->set_digits(0);
|
|
iso_min_->set_increments(1, 10);
|
|
iso_max_->set_increments(1, 10);
|
|
iso_min_->set_range(default_rule.iso.min, default_rule.iso.max);
|
|
iso_max_->set_range(default_rule.iso.min, default_rule.iso.max);
|
|
iso_min_->set_value(default_rule.iso.min);
|
|
iso_max_->set_value(default_rule.iso.max);
|
|
|
|
#define DOIT_(name) \
|
|
name ## _min_->set_digits(1); \
|
|
name ## _max_->set_digits(1); \
|
|
name ## _min_->set_increments(0.1, 1); \
|
|
name ## _max_->set_increments(0.1, 1); \
|
|
name ## _min_->set_range(default_rule. name .min, \
|
|
default_rule. name .max); \
|
|
name ## _max_->set_range(default_rule. name .min, \
|
|
default_rule. name .max); \
|
|
name ## _min_->set_value(default_rule. name .min); \
|
|
name ## _max_->set_value(default_rule. name .max)
|
|
|
|
DOIT_(fnumber);
|
|
DOIT_(focallen);
|
|
DOIT_(shutterspeed);
|
|
DOIT_(expcomp);
|
|
#undef DOIT_
|
|
shutterspeed_min_->set_digits(4);
|
|
shutterspeed_max_->set_digits(4);
|
|
|
|
profilepath_->setInternalEntry();
|
|
}
|
|
|
|
|
|
void DynamicProfilePanel::EditDialog::add_range(const Glib::ustring &name,
|
|
Gtk::SpinButton *&from, Gtk::SpinButton *&to)
|
|
{
|
|
Gtk::HBox *hb = Gtk::manage(new Gtk::HBox());
|
|
hb->pack_start(*Gtk::manage(new Gtk::Label(name)), false, false, 4);
|
|
from = Gtk::manage(new Gtk::SpinButton());
|
|
to = Gtk::manage(new Gtk::SpinButton());
|
|
from->set_numeric(true);
|
|
to->set_numeric(true);
|
|
hb->pack_start(*from, true, true, 2);
|
|
hb->pack_start(*Gtk::manage(new Gtk::Label(" - ")),
|
|
false, false, 4);
|
|
hb->pack_start(*to, true, true, 2);
|
|
get_content_area()->pack_start(*hb, Gtk::PACK_SHRINK, 4);
|
|
}
|
|
|
|
|
|
void DynamicProfilePanel::EditDialog::add_optional(const Glib::ustring &name,
|
|
Gtk::CheckButton *&check, Gtk::Entry *&field)
|
|
{
|
|
check = Gtk::manage (new Gtk::CheckButton(name));
|
|
Gtk::HBox *hb = Gtk::manage(new Gtk::HBox());
|
|
hb->pack_start(*check, Gtk::PACK_SHRINK, 4);
|
|
field = Gtk::manage(new Gtk::Entry());
|
|
hb->pack_start(*field, true, true, 2);
|
|
get_content_area()->pack_start(*hb, Gtk::PACK_SHRINK, 4);
|
|
field->set_tooltip_text(M("DYNPROFILEEDITOR_ENTRY_TOOLTIP"));
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// DynamicProfilePanel
|
|
//-----------------------------------------------------------------------------
|
|
|
|
DynamicProfilePanel::DynamicProfilePanel():
|
|
vbox_(Gtk::ORIENTATION_VERTICAL),
|
|
button_up_(M("DYNPROFILEEDITOR_MOVE_UP")),
|
|
button_down_(M("DYNPROFILEEDITOR_MOVE_DOWN")),
|
|
button_new_(M("DYNPROFILEEDITOR_NEW")),
|
|
button_edit_(M("DYNPROFILEEDITOR_EDIT")),
|
|
button_delete_(M("DYNPROFILEEDITOR_DELETE"))
|
|
{
|
|
add(vbox_);
|
|
|
|
treeview_.set_grid_lines(Gtk::TREE_VIEW_GRID_LINES_VERTICAL);
|
|
scrolledwindow_.add(treeview_);
|
|
|
|
scrolledwindow_.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
|
|
|
|
vbox_.pack_start(scrolledwindow_);
|
|
vbox_.pack_start(buttonbox_, Gtk::PACK_SHRINK);
|
|
|
|
buttonbox_.pack_start(button_new_, Gtk::PACK_SHRINK);
|
|
buttonbox_.pack_start(button_edit_, Gtk::PACK_SHRINK);
|
|
buttonbox_.pack_start(button_delete_, Gtk::PACK_SHRINK);
|
|
buttonbox_.pack_start(button_up_, Gtk::PACK_SHRINK);
|
|
buttonbox_.pack_start(button_down_, Gtk::PACK_SHRINK);
|
|
buttonbox_.set_border_width(5);
|
|
buttonbox_.set_layout(Gtk::BUTTONBOX_END);
|
|
button_up_.signal_clicked().connect(
|
|
sigc::mem_fun(*this, &DynamicProfilePanel::on_button_up));
|
|
button_down_.signal_clicked().connect(
|
|
sigc::mem_fun(*this, &DynamicProfilePanel::on_button_down));
|
|
button_new_.signal_clicked().connect(
|
|
sigc::mem_fun(*this, &DynamicProfilePanel::on_button_new));
|
|
button_edit_.signal_clicked().connect(
|
|
sigc::mem_fun(*this, &DynamicProfilePanel::on_button_edit));
|
|
button_delete_.signal_clicked().connect(
|
|
sigc::mem_fun(*this, &DynamicProfilePanel::on_button_delete));
|
|
|
|
treemodel_ = Gtk::ListStore::create(columns_);
|
|
treeview_.set_model(treemodel_);
|
|
|
|
auto cell = Gtk::manage(new Gtk::CellRendererText());
|
|
int cols_count = treeview_.append_column(
|
|
M("DYNPROFILEEDITOR_PROFILE"), *cell);
|
|
auto col = treeview_.get_column(cols_count - 1);
|
|
if (col) {
|
|
col->set_cell_data_func(
|
|
*cell, sigc::mem_fun(
|
|
*this, &DynamicProfilePanel::render_profilepath));
|
|
}
|
|
cell = Gtk::manage(new Gtk::CellRendererText());
|
|
cols_count = treeview_.append_column(
|
|
M("EXIFFILTER_CAMERA"), *cell);
|
|
col = treeview_.get_column(cols_count - 1);
|
|
if (col) {
|
|
col->set_cell_data_func(
|
|
*cell, sigc::mem_fun(
|
|
*this, &DynamicProfilePanel::render_camera));
|
|
}
|
|
cell = Gtk::manage(new Gtk::CellRendererText());
|
|
cols_count = treeview_.append_column(M("EXIFFILTER_LENS"), *cell);
|
|
col = treeview_.get_column(cols_count - 1);
|
|
if (col) {
|
|
col->set_cell_data_func(
|
|
*cell, sigc::mem_fun(
|
|
*this, &DynamicProfilePanel::render_lens));
|
|
}
|
|
cell = Gtk::manage(new Gtk::CellRendererText());
|
|
cols_count = treeview_.append_column(M("EXIFFILTER_ISO"), *cell);
|
|
col = treeview_.get_column(cols_count - 1);
|
|
if (col) {
|
|
col->set_cell_data_func(
|
|
*cell, sigc::mem_fun(
|
|
*this, &DynamicProfilePanel::render_iso));
|
|
}
|
|
cell = Gtk::manage(new Gtk::CellRendererText());
|
|
cols_count = treeview_.append_column(M("EXIFFILTER_APERTURE"), *cell);
|
|
col = treeview_.get_column(cols_count - 1);
|
|
if (col) {
|
|
col->set_cell_data_func(
|
|
*cell, sigc::mem_fun(
|
|
*this, &DynamicProfilePanel::render_fnumber));
|
|
}
|
|
cell = Gtk::manage(new Gtk::CellRendererText());
|
|
cols_count = treeview_.append_column(M("EXIFFILTER_FOCALLEN"), *cell);
|
|
col = treeview_.get_column(cols_count - 1);
|
|
if (col) {
|
|
col->set_cell_data_func(
|
|
*cell, sigc::mem_fun(
|
|
*this, &DynamicProfilePanel::render_focallen));
|
|
}
|
|
cell = Gtk::manage(new Gtk::CellRendererText());
|
|
cols_count = treeview_.append_column(M("EXIFFILTER_SHUTTER"), *cell);
|
|
col = treeview_.get_column(cols_count - 1);
|
|
if (col) {
|
|
col->set_cell_data_func(
|
|
*cell, sigc::mem_fun(
|
|
*this, &DynamicProfilePanel::render_shutterspeed));
|
|
}
|
|
cell = Gtk::manage(new Gtk::CellRendererText());
|
|
cols_count = treeview_.append_column(
|
|
M("EXIFFILTER_EXPOSURECOMPENSATION"), *cell);
|
|
col = treeview_.get_column(cols_count - 1);
|
|
if (col) {
|
|
col->set_cell_data_func(
|
|
*cell, sigc::mem_fun(
|
|
*this, &DynamicProfilePanel::render_expcomp));
|
|
}
|
|
|
|
show_all_children();
|
|
|
|
for (auto &r : profileStore.getDynamicProfileRules()) {
|
|
add_rule(r);
|
|
}
|
|
}
|
|
|
|
|
|
void DynamicProfilePanel::update_rule(Gtk::TreeModel::Row row,
|
|
const DynamicProfileRule &rule)
|
|
{
|
|
row[columns_.iso] = rule.iso;
|
|
row[columns_.fnumber] = rule.fnumber;
|
|
row[columns_.focallen] = rule.focallen;
|
|
row[columns_.shutterspeed] = rule.shutterspeed;
|
|
row[columns_.expcomp] = rule.expcomp;
|
|
row[columns_.camera] = rule.camera;
|
|
row[columns_.lens] = rule.lens;
|
|
row[columns_.profilepath] = rule.profilepath;
|
|
}
|
|
|
|
void DynamicProfilePanel::add_rule(const DynamicProfileRule &rule)
|
|
{
|
|
auto row = *(treemodel_->append());
|
|
update_rule(row, rule);
|
|
}
|
|
|
|
|
|
DynamicProfileRule DynamicProfilePanel::to_rule(Gtk::TreeModel::Row row,
|
|
int serial)
|
|
{
|
|
DynamicProfileRule ret;
|
|
ret.serial_number = serial;
|
|
ret.iso = row[columns_.iso];
|
|
ret.fnumber = row[columns_.fnumber];
|
|
ret.focallen = row[columns_.focallen];
|
|
ret.shutterspeed = row[columns_.shutterspeed];
|
|
ret.expcomp = row[columns_.expcomp];
|
|
ret.camera = row[columns_.camera];
|
|
ret.lens = row[columns_.lens];
|
|
ret.profilepath = row[columns_.profilepath];
|
|
return ret;
|
|
}
|
|
|
|
|
|
void DynamicProfilePanel::render_profilepath(
|
|
Gtk::CellRenderer *cell, const Gtk::TreeModel::iterator &iter)
|
|
{
|
|
auto row = *iter;
|
|
Gtk::CellRendererText *ct = static_cast<Gtk::CellRendererText *>(cell);
|
|
auto value = row[columns_.profilepath];
|
|
auto pse = profileStore.findEntryFromFullPath(value);
|
|
if (pse != nullptr) {
|
|
ct->property_text() = pse->label;
|
|
} else {
|
|
ct->property_text() = value;
|
|
}
|
|
}
|
|
|
|
|
|
#define RENDER_RANGE_(tp, name, prec) \
|
|
auto row = *iter; \
|
|
Gtk::CellRendererText *ct = static_cast<Gtk::CellRendererText *>(cell); \
|
|
DynamicProfileRule::Range<tp> r = row[columns_. name]; \
|
|
DynamicProfileRule dflt; \
|
|
if (r.min > dflt.name.min || r.max < dflt.name.max) { \
|
|
auto value = to_str(r.min, prec) + " - " + to_str(r.max, prec); \
|
|
ct->property_text() = value; \
|
|
} else { \
|
|
ct->property_text() = ""; \
|
|
}
|
|
|
|
void DynamicProfilePanel::render_iso(
|
|
Gtk::CellRenderer *cell, const Gtk::TreeModel::iterator &iter)
|
|
{
|
|
RENDER_RANGE_(int, iso, 0);
|
|
}
|
|
|
|
|
|
void DynamicProfilePanel::render_fnumber(
|
|
Gtk::CellRenderer *cell, const Gtk::TreeModel::iterator &iter)
|
|
{
|
|
RENDER_RANGE_(double, fnumber, 1);
|
|
}
|
|
|
|
|
|
void DynamicProfilePanel::render_focallen(
|
|
Gtk::CellRenderer *cell, const Gtk::TreeModel::iterator &iter)
|
|
{
|
|
RENDER_RANGE_(double, focallen, 1);
|
|
}
|
|
|
|
|
|
void DynamicProfilePanel::render_shutterspeed(
|
|
Gtk::CellRenderer *cell, const Gtk::TreeModel::iterator &iter)
|
|
{
|
|
RENDER_RANGE_(double, shutterspeed, 4);
|
|
}
|
|
|
|
|
|
void DynamicProfilePanel::render_expcomp(
|
|
Gtk::CellRenderer *cell, const Gtk::TreeModel::iterator &iter)
|
|
{
|
|
RENDER_RANGE_(double, expcomp, 1);
|
|
}
|
|
|
|
#undef RENDER_RANGE_
|
|
|
|
#define RENDER_OPTIONAL_(name) \
|
|
auto row = *iter; \
|
|
Gtk::CellRendererText *ct = static_cast<Gtk::CellRendererText *>(cell); \
|
|
DynamicProfileRule::Optional o = row[columns_. name]; \
|
|
if (o.enabled) { \
|
|
ct->property_text() = o.value; \
|
|
} else { \
|
|
ct->property_text() = ""; \
|
|
}
|
|
|
|
void DynamicProfilePanel::render_camera(
|
|
Gtk::CellRenderer *cell, const Gtk::TreeModel::iterator &iter)
|
|
{
|
|
RENDER_OPTIONAL_(camera);
|
|
}
|
|
|
|
|
|
void DynamicProfilePanel::render_lens(
|
|
Gtk::CellRenderer *cell, const Gtk::TreeModel::iterator &iter)
|
|
{
|
|
RENDER_OPTIONAL_(lens);
|
|
}
|
|
|
|
#undef RENDER_OPTIONAL_
|
|
|
|
void DynamicProfilePanel::on_button_up()
|
|
{
|
|
auto s = treeview_.get_selection();
|
|
if (!s->count_selected_rows()) {
|
|
return;
|
|
}
|
|
auto it = s->get_selected();
|
|
if (it != treemodel_->children().begin()) {
|
|
auto it2 = it;
|
|
--it2;
|
|
treemodel_->iter_swap(it, it2);
|
|
}
|
|
}
|
|
|
|
void DynamicProfilePanel::on_button_down()
|
|
{
|
|
auto s = treeview_.get_selection();
|
|
if (!s->count_selected_rows()) {
|
|
return;
|
|
}
|
|
auto it = s->get_selected();
|
|
auto it2 = it;
|
|
++it2;
|
|
if (it2 != treemodel_->children().end()) {
|
|
treemodel_->iter_swap(it, it2);
|
|
}
|
|
}
|
|
|
|
|
|
void DynamicProfilePanel::on_button_delete()
|
|
{
|
|
auto s = treeview_.get_selection();
|
|
if (!s->count_selected_rows()) {
|
|
return;
|
|
}
|
|
auto it = s->get_selected();
|
|
treemodel_->erase(it);
|
|
}
|
|
|
|
|
|
void DynamicProfilePanel::on_button_new()
|
|
{
|
|
EditDialog d(M("DYNPROFILEEDITOR_NEW_RULE"),
|
|
static_cast<Gtk::Window &>(*get_toplevel()));
|
|
int status = d.run();
|
|
if (status == 1) {
|
|
DynamicProfileRule rule = d.get_rule();
|
|
add_rule(rule);
|
|
}
|
|
}
|
|
|
|
|
|
void DynamicProfilePanel::on_button_edit()
|
|
{
|
|
auto s = treeview_.get_selection();
|
|
if (!s->count_selected_rows()) {
|
|
return;
|
|
}
|
|
EditDialog d(M("DYNPROFILEEDITOR_EDIT_RULE"),
|
|
static_cast<Gtk::Window &>(*get_toplevel()));
|
|
auto it = s->get_selected();
|
|
Gtk::TreeModel::Row row = *(s->get_selected());
|
|
d.set_rule(to_rule(row));
|
|
int status = d.run();
|
|
if (status == 1) {
|
|
update_rule(row, d.get_rule());
|
|
}
|
|
}
|
|
|
|
|
|
void DynamicProfilePanel::save()
|
|
{
|
|
auto &rules = profileStore.getDynamicProfileRules();
|
|
rules.clear();
|
|
int serial = 1;
|
|
for (auto row : treemodel_->children()) {
|
|
rules.emplace_back(to_rule(row, serial++));
|
|
}
|
|
if (!storeDynamicProfileRules(rules)) {
|
|
printf("Error in saving dynamic profile rules\n");
|
|
rules.clear();
|
|
} else {
|
|
printf("Saved %d dynamic profile rules\n", int(rules.size()));
|
|
}
|
|
}
|