static int is_ldr_member(lua_State *L)
{
const dt_image_t *my_image = checkreadimage(L, 1);
lua_pushboolean(L, dt_image_is_ldr(my_image));
releasereadimage(L, my_image);
return 1;
}
void gui_update (struct dt_iop_module_t *self)
{
dt_iop_module_t *module = (dt_iop_module_t *)self;
self->request_color_pick = 0;
self->color_picker_box[0] = self->color_picker_box[1] = .25f;
self->color_picker_box[2] = self->color_picker_box[3] = .75f;
self->color_picker_point[0] = self->color_picker_point[1] = 0.5f;
dt_iop_temperature_gui_data_t *g = (dt_iop_temperature_gui_data_t *)self->gui_data;
dt_iop_temperature_params_t *p = (dt_iop_temperature_params_t *)module->params;
dt_iop_temperature_params_t *fp = (dt_iop_temperature_params_t *)module->default_params;
float temp, tint, mul[3];
for(int k=0; k<3; k++) mul[k] = g->daylight_wb[k]/p->coeffs[k];
convert_rgb_to_k(mul, &temp, &tint);
dt_bauhaus_slider_set(g->scale_r, p->coeffs[0]);
dt_bauhaus_slider_set(g->scale_g, p->coeffs[1]);
dt_bauhaus_slider_set(g->scale_b, p->coeffs[2]);
dt_bauhaus_slider_set(g->scale_k, temp);
dt_bauhaus_slider_set(g->scale_tint, tint);
dt_bauhaus_combobox_clear(g->presets);
dt_bauhaus_combobox_add(g->presets, _("camera white balance"));
dt_bauhaus_combobox_add(g->presets, _("spot white balance"));
dt_bauhaus_combobox_add(g->presets, _("passthrough"));
g->preset_cnt = 3;
const char *wb_name = NULL;
char makermodel[1024];
char *model = makermodel;
dt_colorspaces_get_makermodel_split(makermodel, 1024, &model, self->dev->image_storage.exif_maker, self->dev->image_storage.exif_model);
if(!dt_image_is_ldr(&self->dev->image_storage)) for(int i=0; i<wb_preset_count; i++)
{
if(g->preset_cnt >= 50) break;
if(!strcmp(wb_preset[i].make, makermodel) &&
!strcmp(wb_preset[i].model, model))
{
if(!wb_name || strcmp(wb_name, wb_preset[i].name))
{
wb_name = wb_preset[i].name;
dt_bauhaus_combobox_add(g->presets, _(wb_preset[i].name));
g->preset_num[g->preset_cnt++] = i;
}
}
}
if(fabsf(p->coeffs[0]-fp->coeffs[0]) + fabsf(p->coeffs[1]-fp->coeffs[1]) + fabsf(p->coeffs[2]-fp->coeffs[2]) < 0.01)
dt_bauhaus_combobox_set(g->presets, 0);
else
dt_bauhaus_combobox_set(g->presets, -1);
dt_bauhaus_slider_set(g->finetune, 0);
gtk_widget_set_sensitive(g->finetune, 0);
}
static int image_index(lua_State *L)
{
const char* membername = lua_tostring(L, -1);
const dt_image_t * my_image=checkreadimage(L,-2);
if(luaA_struct_has_member_name(L,dt_image_t,membername))
{
const int result = luaA_struct_push_member_name(L, dt_image_t, my_image, membername);
releasereadimage(L,my_image);
return result;
}
switch(luaL_checkoption(L,-1,NULL,image_fields_name))
{
case PATH:
{
sqlite3_stmt *stmt;
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db),
"select folder from images, film_rolls where "
"images.film_id = film_rolls.id and images.id = ?1", -1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, my_image->id);
if(sqlite3_step(stmt) == SQLITE_ROW)
{
lua_pushstring(L,(char *)sqlite3_column_text(stmt, 0));
}
else
{
sqlite3_finalize(stmt);
releasereadimage(L,my_image);
return luaL_error(L,"should never happen");
}
sqlite3_finalize(stmt);
break;
}
case DUP_INDEX:
{
// get duplicate suffix
int version = 0;
sqlite3_stmt *stmt;
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db),
"select count(id) from images where filename in "
"(select filename from images where id = ?1) and film_id in "
"(select film_id from images where id = ?1) and id < ?1",
-1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, my_image->id);
if(sqlite3_step(stmt) == SQLITE_ROW)
version = sqlite3_column_int(stmt, 0);
sqlite3_finalize(stmt);
lua_pushinteger(L,version);
break;
}
case IS_LDR:
lua_pushboolean(L,dt_image_is_ldr(my_image));
break;
case IS_HDR:
lua_pushboolean(L,dt_image_is_hdr(my_image));
break;
case IS_RAW:
lua_pushboolean(L,dt_image_is_raw(my_image));
break;
case RATING:
{
int score = my_image->flags & 0x7;
if(score >6) score=5;
if(score ==6) score=-1;
lua_pushinteger(L,score);
break;
}
case ID:
lua_pushinteger(L,my_image->id);
break;
case FILM:
luaA_push(L,dt_lua_film_t,&my_image->film_id);
break;
case CREATOR:
{
sqlite3_stmt *stmt;
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db),"select value from meta_data where id = ?1 and key = ?2", -1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, my_image->id);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, DT_METADATA_XMP_DC_CREATOR);
if(sqlite3_step(stmt) != SQLITE_ROW)
{
lua_pushstring(L,"");
}
else
{
lua_pushstring(L,(char *)sqlite3_column_text(stmt, 0));
}
sqlite3_finalize(stmt);
break;
}
case PUBLISHER:
{
sqlite3_stmt *stmt;
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db),"select value from meta_data where id = ?1 and key = ?2", -1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, my_image->id);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, DT_METADATA_XMP_DC_PUBLISHER);
if(sqlite3_step(stmt) != SQLITE_ROW)
{
lua_pushstring(L,"");
}
else
{
lua_pushstring(L,(char *)sqlite3_column_text(stmt, 0));
}
sqlite3_finalize(stmt);
break;
}
case TITLE:
{
sqlite3_stmt *stmt;
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db),"select value from meta_data where id = ?1 and key = ?2", -1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, my_image->id);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, DT_METADATA_XMP_DC_TITLE);
if(sqlite3_step(stmt) != SQLITE_ROW)
{
lua_pushstring(L,"");
}
else
{
lua_pushstring(L,(char *)sqlite3_column_text(stmt, 0));
}
sqlite3_finalize(stmt);
break;
}
case DESCRIPTION:
{
sqlite3_stmt *stmt;
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db),"select value from meta_data where id = ?1 and key = ?2", -1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, my_image->id);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, DT_METADATA_XMP_DC_DESCRIPTION);
if(sqlite3_step(stmt) != SQLITE_ROW)
{
lua_pushstring(L,"");
}
else
{
lua_pushstring(L,(char *)sqlite3_column_text(stmt, 0));
}
sqlite3_finalize(stmt);
break;
}
case RIGHTS:
{
sqlite3_stmt *stmt;
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db),"select value from meta_data where id = ?1 and key = ?2", -1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, my_image->id);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, DT_METADATA_XMP_DC_RIGHTS);
if(sqlite3_step(stmt) != SQLITE_ROW)
{
lua_pushstring(L,"");
}
else
{
lua_pushstring(L,(char *)sqlite3_column_text(stmt, 0));
}
sqlite3_finalize(stmt);
break;
}
case GROUP_LEADER:
{
luaA_push(L,dt_lua_image_t,&(my_image->group_id));
break;
}
case APPLY_STYLE:
{
lua_pushcfunction(L,dt_lua_style_apply);
break;
}
case CREATE_STYLE:
{
lua_pushcfunction(L,dt_lua_style_create_from_image);
break;
}
case RESET:
{
lua_pushcfunction(L,history_delete);
break;
}
case MOVE:
{
lua_pushcfunction(L,dt_lua_move_image);
break;
}
case COPY:
{
lua_pushcfunction(L,dt_lua_copy_image);
break;
}
case LOCAL_COPY:
{
lua_pushboolean(L,my_image->flags &DT_IMAGE_LOCAL_COPY);
break;
}
default:
releasereadimage(L,my_image);
return luaL_error(L,"should never happen %s",lua_tostring(L,-1));
}
releasereadimage(L,my_image);
return 1;
}
void gui_init (struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_temperature_gui_data_t));
dt_iop_temperature_gui_data_t *g = (dt_iop_temperature_gui_data_t *)self->gui_data;
dt_iop_temperature_params_t *p = (dt_iop_temperature_params_t*)self->default_params;
self->request_color_pick = 0;
self->widget = gtk_vbox_new(TRUE, DT_BAUHAUS_SPACE);
g_signal_connect(G_OBJECT(self->widget), "expose-event", G_CALLBACK(expose), self);
g->scale_tint = dt_bauhaus_slider_new_with_range(self,0.1, 8.0, .01,1.0,3);
g->scale_k = dt_bauhaus_slider_new_with_range(self,DT_IOP_LOWEST_TEMPERATURE, DT_IOP_HIGHEST_TEMPERATURE, 10.,5000.0,0);
g->scale_k_out = dt_bauhaus_slider_new_with_range(self,DT_IOP_LOWEST_TEMPERATURE, DT_IOP_HIGHEST_TEMPERATURE, 10.,5000.0,0);
g->scale_r = dt_bauhaus_slider_new_with_range(self,0.0, 8.0, .001,p->coeffs[0],3);
g->scale_g = dt_bauhaus_slider_new_with_range(self,0.0, 8.0, .001,p->coeffs[1],3);
g->scale_b = dt_bauhaus_slider_new_with_range(self,0.0, 8.0, .001,p->coeffs[2],3);
dt_bauhaus_slider_set_format(g->scale_k,"%.0fK");
dt_bauhaus_slider_set_format(g->scale_k_out,"%.0fK");
dt_bauhaus_widget_set_label(g->scale_tint,_("tint"));
dt_bauhaus_widget_set_label(g->scale_k,_("temperature in"));
dt_bauhaus_widget_set_label(g->scale_k_out,_("temperature out"));
dt_bauhaus_widget_set_label(g->scale_r,_("red"));
dt_bauhaus_widget_set_label(g->scale_g,_("green"));
dt_bauhaus_widget_set_label(g->scale_b,_("blue"));
gtk_box_pack_start(GTK_BOX(self->widget), g->scale_tint, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), g->scale_k, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), g->scale_k_out, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), g->scale_r, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), g->scale_g, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), g->scale_b, TRUE, TRUE, 0);
g->presets = dt_bauhaus_combobox_new(self);
dt_bauhaus_widget_set_label(g->presets,_("preset"));
dt_bauhaus_combobox_add(g->presets, _("camera white balance"));
dt_bauhaus_combobox_add(g->presets, _("spot white balance"));
dt_bauhaus_combobox_add(g->presets, _("passthrough"));
g->preset_cnt = 3;
const char *wb_name = NULL;
char makermodel[1024];
char *model = makermodel;
dt_colorspaces_get_makermodel_split(makermodel, 1024, &model, self->dev->image_storage.exif_maker, self->dev->image_storage.exif_model);
if(!dt_image_is_ldr(&self->dev->image_storage)) for(int i=0; i<wb_preset_count; i++)
{
if(g->preset_cnt >= 50) break;
if(!strcmp(wb_preset[i].make, makermodel) &&
!strcmp(wb_preset[i].model, model))
{
if(!wb_name || strcmp(wb_name, wb_preset[i].name))
{
wb_name = wb_preset[i].name;
dt_bauhaus_combobox_add(g->presets, _(wb_preset[i].name));
g->preset_num[g->preset_cnt++] = i;
}
}
}
gtk_box_pack_start(GTK_BOX(self->widget), g->presets, TRUE, TRUE, 0);
g_object_set(G_OBJECT(g->presets), "tooltip-text", _("choose white balance preset from camera"), (char *)NULL);
g->finetune = dt_bauhaus_slider_new_with_range(self,-9.0, 9.0, 1.0, 0.0, 0);
dt_bauhaus_widget_set_label(g->finetune, _("finetune"));
dt_bauhaus_slider_set_format(g->finetune, _("%.0f mired"));
// initially doesn't have fine tuning stuff (camera wb)
gtk_widget_set_sensitive(g->finetune, FALSE);
gtk_box_pack_start(GTK_BOX(self->widget), g->finetune, TRUE, TRUE, 0);
g_object_set(G_OBJECT(g->finetune), "tooltip-text", _("fine tune white balance preset"), (char *)NULL);
self->gui_update(self);
g_signal_connect (G_OBJECT (g->scale_tint), "value-changed",
G_CALLBACK (tint_callback), self);
g_signal_connect (G_OBJECT (g->scale_k), "value-changed",
G_CALLBACK (temp_callback), self);
g_signal_connect (G_OBJECT (g->scale_k_out), "value-changed",
G_CALLBACK (temp_out_callback), self);
g_signal_connect (G_OBJECT (g->scale_r), "value-changed",
G_CALLBACK (rgb_callback), self);
g_signal_connect (G_OBJECT (g->scale_g), "value-changed",
G_CALLBACK (rgb_callback), self);
g_signal_connect (G_OBJECT (g->scale_b), "value-changed",
G_CALLBACK (rgb_callback), self);
g_signal_connect (G_OBJECT (g->presets), "value-changed",
G_CALLBACK (presets_changed), self);
g_signal_connect (G_OBJECT (g->finetune), "value-changed",
G_CALLBACK (finetune_changed), self);
}
static void
auto_apply_presets(dt_develop_t *dev)
{
const int imgid = dev->image_storage.id;
if(imgid <= 0) return;
int run = 0;
const dt_image_t *cimg = dt_image_cache_read_get(darktable.image_cache, imgid);
if(!(cimg->flags & DT_IMAGE_AUTO_PRESETS_APPLIED))
run = 1;
// flag was already set? only apply presets once in the lifetime of a history stack.
// (the flag will be cleared when removing it)
if(!run || cimg->id <= 0)
{
dt_image_cache_read_release(darktable.image_cache, cimg);
return;
}
// keep locked, we want to be alone messing with the history of the poor fellow:
dt_image_t *image = dt_image_cache_write_get(darktable.image_cache, cimg);
// be extra sure that we don't mess up history in separate threads:
dt_pthread_mutex_lock(&darktable.db_insert);
// cleanup
DT_DEBUG_SQLITE3_EXEC(dt_database_get(darktable.db),
"delete from memory.history",
NULL, NULL, NULL);
const char *preset_table[2] = {"presets", "legacy_presets"};
const int legacy = (image->flags & DT_IMAGE_NO_LEGACY_PRESETS) ? 0 : 1;
char query[1024];
snprintf(query, 1024,
"insert into memory.history select ?1, 0, op_version, operation, op_params, enabled, blendop_params, blendop_version, multi_priority, multi_name "
"from %s where autoapply=1 and "
"?2 like model and ?3 like maker and ?4 like lens and "
"?5 between iso_min and iso_max and "
"?6 between exposure_min and exposure_max and "
"?7 between aperture_min and aperture_max and "
"?8 between focal_length_min and focal_length_max and "
"(isldr = 0 or isldr=?9) order by writeprotect desc, "
"length(model), length(maker), length(lens)", preset_table[legacy]);
// query for all modules at once:
sqlite3_stmt *stmt;
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), query, -1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, imgid);
DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 2, cimg->exif_model, strlen(cimg->exif_model), SQLITE_TRANSIENT);
DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 3, cimg->exif_maker, strlen(cimg->exif_maker), SQLITE_TRANSIENT);
DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 4, cimg->exif_lens, strlen(cimg->exif_lens), SQLITE_TRANSIENT);
DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 5, fmaxf(0.0f, fminf(1000000, cimg->exif_iso)));
DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 6, fmaxf(0.0f, fminf(1000000, cimg->exif_exposure)));
DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 7, fmaxf(0.0f, fminf(1000000, cimg->exif_aperture)));
DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 8, fmaxf(0.0f, fminf(1000000, cimg->exif_focal_length)));
// 0: dontcare, 1: ldr, 2: raw
DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 9, 2-dt_image_is_ldr(cimg));
if(sqlite3_step(stmt) == SQLITE_DONE)
{
sqlite3_finalize(stmt);
int cnt = 0;
// count what we found:
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db),
"select count(*) from memory.history",
-1, &stmt, NULL);
if(sqlite3_step(stmt) == SQLITE_ROW)
{
// if there is anything..
cnt = sqlite3_column_int(stmt, 0);
sqlite3_finalize(stmt);
// fprintf(stderr, "[auto_apply_presets] imageid %d found %d matching presets (legacy %d)\n", imgid, cnt, legacy);
// advance the current history by that amount:
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db),
"update history set num=num+?1 where imgid=?2",
-1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, cnt);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, imgid);
if(sqlite3_step(stmt) == SQLITE_DONE)
{
// and finally prepend the rest with increasing numbers (starting at 0)
sqlite3_finalize(stmt);
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db),
"insert into history select imgid, rowid-1, module, operation, op_params, enabled, "
"blendop_params, blendop_version, multi_priority, multi_name from memory.history",
-1, &stmt, NULL);
sqlite3_step(stmt);
}
}
}
sqlite3_finalize(stmt);
// first time we are loading the image, try to import lightroom .xmp if any
if (dev->image_loading)
dt_lightroom_import(dev->image_storage.id, dev, TRUE);
image->flags |= DT_IMAGE_AUTO_PRESETS_APPLIED | DT_IMAGE_NO_LEGACY_PRESETS;
dt_pthread_mutex_unlock(&darktable.db_insert);
// make sure these end up in the image_cache + xmp (sync through here if we set the flag)
dt_image_cache_write_release(darktable.image_cache, image, DT_IMAGE_CACHE_SAFE);
dt_image_cache_read_release(darktable.image_cache, cimg);
}
static void dt_gui_presets_popup_menu_show_internal(dt_dev_operation_t op, int32_t version,
dt_iop_params_t *params, int32_t params_size,
dt_develop_blend_params_t *bl_params,
dt_iop_module_t *module, const dt_image_t *image,
void (*pick_callback)(GtkMenuItem *, void *),
void *callback_data)
{
GtkMenu *menu = darktable.gui->presets_popup_menu;
if(menu) gtk_widget_destroy(GTK_WIDGET(menu));
darktable.gui->presets_popup_menu = GTK_MENU(gtk_menu_new());
menu = darktable.gui->presets_popup_menu;
GtkWidget *mi;
int active_preset = -1, cnt = 0, writeprotect = 0; //, selected_default = 0;
sqlite3_stmt *stmt;
// order: get shipped defaults first
if(image)
{
// only matching if filter is on:
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db),
"select name, op_params, writeprotect, description, blendop_params, "
"op_version, enabled from presets where operation=?1 and "
"(filter=0 or ( "
"((?2 like model and ?3 like maker) or (?4 like model and ?5 like maker)) and "
"?6 like lens and "
"?7 between iso_min and iso_max and "
"?8 between exposure_min and exposure_max and "
"?9 between aperture_min and aperture_max and "
"?10 between focal_length_min and focal_length_max and "
"(format = 0 or format&?9!=0)"
" ) )"
"order by writeprotect desc, lower(name), rowid",
-1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, op, -1, SQLITE_TRANSIENT);
DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 2, image->exif_model, -1, SQLITE_TRANSIENT);
DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 3, image->exif_maker, -1, SQLITE_TRANSIENT);
DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 4, image->camera_alias, -1, SQLITE_TRANSIENT);
DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 5, image->camera_maker, -1, SQLITE_TRANSIENT);
DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 6, image->exif_lens, -1, SQLITE_TRANSIENT);
DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 7, image->exif_iso);
DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 8, image->exif_exposure);
DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 9, image->exif_aperture);
DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 10, image->exif_focal_length);
int ldr = dt_image_is_ldr(image) ? FOR_LDR : (dt_image_is_raw(image) ? FOR_RAW : FOR_HDR);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 9, ldr);
}
else
{
// don't know for which image. show all we got:
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "select name, op_params, writeprotect, "
"description, blendop_params, op_version, "
"enabled from presets where operation=?1 "
"order by writeprotect desc, lower(name), rowid",
-1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, op, -1, SQLITE_TRANSIENT);
}
// collect all presets for op from db
int found = 0;
while(sqlite3_step(stmt) == SQLITE_ROW)
{
void *op_params = (void *)sqlite3_column_blob(stmt, 1);
int32_t op_params_size = sqlite3_column_bytes(stmt, 1);
void *blendop_params = (void *)sqlite3_column_blob(stmt, 4);
int32_t bl_params_size = sqlite3_column_bytes(stmt, 4);
int32_t preset_version = sqlite3_column_int(stmt, 5);
int32_t enabled = sqlite3_column_int(stmt, 6);
int32_t isdefault = 0;
int32_t isdisabled = (preset_version == version ? 0 : 1);
const char *name = (char *)sqlite3_column_text(stmt, 0);
if(darktable.gui->last_preset && strcmp(darktable.gui->last_preset, name) == 0) found = 1;
if(module && !memcmp(module->default_params, op_params, MIN(op_params_size, module->params_size))
&& !memcmp(module->default_blendop_params, blendop_params,
MIN(bl_params_size, sizeof(dt_develop_blend_params_t))))
isdefault = 1;
if(module && !memcmp(params, op_params, MIN(op_params_size, params_size))
&& !memcmp(bl_params, blendop_params, MIN(bl_params_size, sizeof(dt_develop_blend_params_t)))
&& module->enabled == enabled)
{
active_preset = cnt;
writeprotect = sqlite3_column_int(stmt, 2);
char *markup;
mi = gtk_menu_item_new_with_label("");
if(isdefault)
{
markup = g_markup_printf_escaped("<span weight=\"bold\">%s %s</span>", name, _("(default)"));
}
else
markup = g_markup_printf_escaped("<span weight=\"bold\">%s</span>", name);
gtk_label_set_markup(GTK_LABEL(gtk_bin_get_child(GTK_BIN(mi))), markup);
g_free(markup);
}
else
{
if(isdefault)
{
char *markup;
mi = gtk_menu_item_new_with_label("");
markup = g_markup_printf_escaped("%s %s", name, _("(default)"));
gtk_label_set_markup(GTK_LABEL(gtk_bin_get_child(GTK_BIN(mi))), markup);
g_free(markup);
}
else
mi = gtk_menu_item_new_with_label((const char *)name);
}
if(isdisabled)
{
gtk_widget_set_sensitive(mi, 0);
gtk_widget_set_tooltip_text(mi, _("disabled: wrong module version"));
}
else
{
if(module)
g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(menuitem_pick_preset), module);
else if(pick_callback)
g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(pick_callback), callback_data);
gtk_widget_set_tooltip_text(mi, (const char *)sqlite3_column_text(stmt, 3));
}
gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi);
cnt++;
}
sqlite3_finalize(stmt);
if(cnt > 0) gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new());
if(module)
{
if(active_preset >= 0 && !writeprotect)
{
mi = gtk_menu_item_new_with_label(_("edit this preset.."));
g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(menuitem_edit_preset), module);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi);
mi = gtk_menu_item_new_with_label(_("delete this preset"));
g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(menuitem_delete_preset), module);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi);
}
else
{
mi = gtk_menu_item_new_with_label(_("store new preset.."));
g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(menuitem_new_preset), module);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi);
if(darktable.gui->last_preset && found)
{
char *markup = g_markup_printf_escaped("%s <span weight=\"bold\">%s</span>", _("update preset"),
darktable.gui->last_preset);
mi = gtk_menu_item_new_with_label("");
gtk_label_set_markup(GTK_LABEL(gtk_bin_get_child(GTK_BIN(mi))), markup);
g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(menuitem_update_preset), module);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi);
g_free(markup);
}
}
}
}
void gui_update(struct dt_iop_module_t *self)
{
dt_iop_module_t *module = (dt_iop_module_t *)self;
self->request_color_pick = DT_REQUEST_COLORPICK_OFF;
self->color_picker_box[0] = self->color_picker_box[1] = .25f;
self->color_picker_box[2] = self->color_picker_box[3] = .75f;
self->color_picker_point[0] = self->color_picker_point[1] = 0.5f;
dt_iop_temperature_gui_data_t *g = (dt_iop_temperature_gui_data_t *)self->gui_data;
dt_iop_temperature_params_t *p = (dt_iop_temperature_params_t *)module->params;
dt_iop_temperature_params_t *fp = (dt_iop_temperature_params_t *)module->default_params;
float temp, tint, mul[3];
for(int k = 0; k < 3; k++) mul[k] = g->daylight_wb[k] / p->coeffs[k];
convert_rgb_to_k(mul, &temp, &tint);
dt_bauhaus_slider_set(g->scale_r, p->coeffs[0]);
dt_bauhaus_slider_set(g->scale_g, p->coeffs[1]);
dt_bauhaus_slider_set(g->scale_b, p->coeffs[2]);
dt_bauhaus_slider_set(g->scale_k, temp);
dt_bauhaus_slider_set(g->scale_tint, tint);
dt_bauhaus_combobox_clear(g->presets);
dt_bauhaus_combobox_add(g->presets, _("camera white balance"));
dt_bauhaus_combobox_add(g->presets, _("spot white balance"));
g->preset_cnt = DT_IOP_NUM_OF_STD_TEMP_PRESETS;
dt_bauhaus_combobox_set(g->presets, -1);
dt_bauhaus_slider_set(g->finetune, 0);
gtk_widget_set_sensitive(g->finetune, 0);
const char *wb_name = NULL;
char makermodel[1024];
char *model = makermodel;
dt_colorspaces_get_makermodel_split(makermodel, sizeof(makermodel), &model,
self->dev->image_storage.exif_maker,
self->dev->image_storage.exif_model);
if(!dt_image_is_ldr(&self->dev->image_storage))
for(int i = 0; i < wb_preset_count; i++)
{
if(g->preset_cnt >= 50) break;
if(!strcmp(wb_preset[i].make, makermodel) && !strcmp(wb_preset[i].model, model))
{
if(!wb_name || strcmp(wb_name, wb_preset[i].name))
{
wb_name = wb_preset[i].name;
dt_bauhaus_combobox_add(g->presets, _(wb_preset[i].name));
g->preset_num[g->preset_cnt++] = i;
}
}
}
if(memcmp(p->coeffs, fp->coeffs, 3 * sizeof(float)) == 0)
dt_bauhaus_combobox_set(g->presets, 0);
else
{
gboolean found = FALSE;
// look through all added presets
for(int j = DT_IOP_NUM_OF_STD_TEMP_PRESETS; !found && (j < g->preset_cnt); j++)
{
// look through all variants of this preset, with different tuning
for(int i = g->preset_num[j];
!found && !strcmp(wb_preset[i].make, makermodel) && !strcmp(wb_preset[i].model, model)
&& !strcmp(wb_preset[i].name, wb_preset[g->preset_num[j]].name);
i++)
{
float coeffs[3];
for(int k = 0; k < 3; k++) coeffs[k] = wb_preset[i].channel[k];
if(memcmp(coeffs, p->coeffs, 3 * sizeof(float)) == 0)
{
// got exact match!
dt_bauhaus_combobox_set(g->presets, j);
gtk_widget_set_sensitive(g->finetune, 1);
dt_bauhaus_slider_set(g->finetune, wb_preset[i].tuning);
found = TRUE;
break;
}
}
}
if(!found)
{
// ok, we haven't found exact match, maybe this was interpolated?
// look through all added presets
for(int j = DT_IOP_NUM_OF_STD_TEMP_PRESETS; !found && (j < g->preset_cnt); j++)
{
// look through all variants of this preset, with different tuning
int i = g->preset_num[j] + 1;
while(!found && !strcmp(wb_preset[i].make, makermodel) && !strcmp(wb_preset[i].model, model)
&& !strcmp(wb_preset[i].name, wb_preset[g->preset_num[j]].name))
{
// let's find gaps
if(wb_preset[i - 1].tuning + 1 == wb_preset[i].tuning)
{
i++;
continue;
}
// we have a gap!
// we do not know what finetuning value was set, we need to bruteforce to find it
for(int tune = wb_preset[i - 1].tuning + 1; !found && (tune < wb_preset[i].tuning); tune++)
{
wb_data interpolated = {.tuning = tune };
dt_wb_preset_interpolate(&wb_preset[i - 1], &wb_preset[i], &interpolated);
float coeffs[3];
for(int k = 0; k < 3; k++) coeffs[k] = interpolated.channel[k];
if(memcmp(coeffs, p->coeffs, 3 * sizeof(float)) == 0)
{
// got exact match!
dt_bauhaus_combobox_set(g->presets, j);
gtk_widget_set_sensitive(g->finetune, 1);
dt_bauhaus_slider_set(g->finetune, tune);
found = TRUE;
break;
}
}
i++;
}
}
}
}
}