void dt_gui_presets_update_tv(const char *name, dt_dev_operation_t op, const int32_t version, const float min,
const float max)
{
sqlite3_stmt *stmt;
DT_DEBUG_SQLITE3_PREPARE_V2(
dt_database_get(darktable.db),
"update presets set exposure_min=?1, exposure_max=?2 where operation=?3 and op_version=?4 and name=?5",
-1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 1, min);
DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 2, max);
DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 3, op, -1, SQLITE_TRANSIENT);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 4, version);
DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 5, name, -1, SQLITE_TRANSIENT);
sqlite3_step(stmt);
sqlite3_finalize(stmt);
}
// drops the write privileges on an image struct.
// this triggers a write-through to sql, and if the setting
// is present, also to xmp sidecar files (safe setting).
void dt_image_cache_write_release(dt_image_cache_t *cache, dt_image_t *img, dt_image_cache_write_mode_t mode)
{
if(img->id <= 0) return;
sqlite3_stmt *stmt;
DT_DEBUG_SQLITE3_PREPARE_V2(
dt_database_get(darktable.db),
"UPDATE main.images SET width = ?1, height = ?2, maker = ?3, model = ?4, "
"lens = ?5, exposure = ?6, aperture = ?7, iso = ?8, focal_length = ?9, "
"focus_distance = ?10, film_id = ?11, datetime_taken = ?12, flags = ?13, "
"crop = ?14, orientation = ?15, raw_parameters = ?16, group_id = ?17, longitude = ?18, "
"latitude = ?19, altitude = ?20, color_matrix = ?21, colorspace = ?22, raw_black = ?23, "
"raw_maximum = ?24 WHERE id = ?25",
-1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, img->width);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, img->height);
DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 3, img->exif_maker, -1, SQLITE_STATIC);
DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 4, img->exif_model, -1, SQLITE_STATIC);
DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 5, img->exif_lens, -1, SQLITE_STATIC);
DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 6, img->exif_exposure);
DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 7, img->exif_aperture);
DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 8, img->exif_iso);
DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 9, img->exif_focal_length);
DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 10, img->exif_focus_distance);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 11, img->film_id);
DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 12, img->exif_datetime_taken, -1, SQLITE_STATIC);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 13, img->flags);
DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 14, img->exif_crop);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 15, img->orientation);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 16, *(uint32_t *)(&img->legacy_flip));
DT_DEBUG_SQLITE3_BIND_INT(stmt, 17, img->group_id);
DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 18, img->longitude);
DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 19, img->latitude);
DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 20, img->elevation);
DT_DEBUG_SQLITE3_BIND_BLOB(stmt, 21, &img->d65_color_matrix, sizeof(img->d65_color_matrix), SQLITE_STATIC);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 22, img->colorspace);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 23, img->raw_black_level);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 24, img->raw_white_point);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 25, img->id);
int rc = sqlite3_step(stmt);
if(rc != SQLITE_DONE) fprintf(stderr, "[image_cache_write_release] sqlite3 error %d\n", rc);
sqlite3_finalize(stmt);
// TODO: make this work in relaxed mode, too.
if(mode == DT_IMAGE_CACHE_SAFE)
{
// rest about sidecars:
// also synch dttags file:
dt_image_write_sidecar_file(img->id);
}
dt_cache_release(&cache->cache, img->cache_entry);
}
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 _view_map_post_expose(cairo_t *cri, int32_t width_i, int32_t height_i,
int32_t pointerx, int32_t pointery, gpointer user_data)
{
const int ts = 64;
OsmGpsMapPoint bb[2], *l=NULL, *center=NULL;
int px,py;
dt_map_t *lib = (dt_map_t *)user_data;
/* get bounding box coords */
osm_gps_map_get_bbox(lib->map, &bb[0], &bb[1]);
float bb_0_lat = 0.0, bb_0_lon = 0.0, bb_1_lat = 0.0, bb_1_lon = 0.0;
osm_gps_map_point_get_degrees(&bb[0], &bb_0_lat, &bb_0_lon);
osm_gps_map_point_get_degrees(&bb[1], &bb_1_lat, &bb_1_lon);
/* make the bounding box a little bigger to the west and south */
float lat0 = 0.0, lon0 = 0.0, lat1 = 0.0, lon1 = 0.0;
OsmGpsMapPoint *pt0 = osm_gps_map_point_new_degrees(0.0, 0.0), *pt1 = osm_gps_map_point_new_degrees(0.0, 0.0);
osm_gps_map_convert_screen_to_geographic(lib->map, 0, 0, pt0);
osm_gps_map_convert_screen_to_geographic(lib->map, 1.5*ts, 1.5*ts, pt1);
osm_gps_map_point_get_degrees(pt0, &lat0, &lon0);
osm_gps_map_point_get_degrees(pt1, &lat1, &lon1);
osm_gps_map_point_free(pt0);
osm_gps_map_point_free(pt1);
double south_border = lat0 - lat1, west_border = lon1 - lon0;
/* get map view state and store */
int zoom = osm_gps_map_get_zoom(lib->map);
center = osm_gps_map_get_center(lib->map);
dt_conf_set_float("plugins/map/longitude", center->rlon);
dt_conf_set_float("plugins/map/latitude", center->rlat);
dt_conf_set_int("plugins/map/zoom", zoom);
osm_gps_map_point_free(center);
/* let's reset and reuse the main_query statement */
DT_DEBUG_SQLITE3_CLEAR_BINDINGS(lib->statements.main_query);
DT_DEBUG_SQLITE3_RESET(lib->statements.main_query);
/* bind bounding box coords for the main query */
DT_DEBUG_SQLITE3_BIND_DOUBLE(lib->statements.main_query, 1, bb_0_lon - west_border);
DT_DEBUG_SQLITE3_BIND_DOUBLE(lib->statements.main_query, 2, bb_1_lon);
DT_DEBUG_SQLITE3_BIND_DOUBLE(lib->statements.main_query, 3, bb_0_lat);
DT_DEBUG_SQLITE3_BIND_DOUBLE(lib->statements.main_query, 4, bb_1_lat - south_border);
/* query collection ids */
while(sqlite3_step(lib->statements.main_query) == SQLITE_ROW)
{
int32_t imgid = sqlite3_column_int(lib->statements.main_query, 0);
cairo_set_source_rgba(cri, 0, 0, 0, 0.4);
/* free l if allocated */
if (l)
osm_gps_map_point_free(l);
/* for each image check if within bbox */
const dt_image_t *cimg = dt_image_cache_read_get(darktable.image_cache, imgid);
double longitude = cimg->longitude;
double latitude = cimg->latitude;
dt_image_cache_read_release(darktable.image_cache, cimg);
if(isnan(latitude) || isnan(longitude))
continue;
l = osm_gps_map_point_new_degrees(latitude, longitude);
/* translate l into screen coords */
osm_gps_map_convert_geographic_to_screen(lib->map, l, &px, &py);
/* dependent on scale draw different overlays */
if (zoom >= 14)
{
dt_mipmap_buffer_t buf;
dt_mipmap_size_t mip = dt_mipmap_cache_get_matching_size(darktable.mipmap_cache, ts, ts);
dt_mipmap_cache_read_get(darktable.mipmap_cache, &buf, imgid, mip, 0);
cairo_surface_t *surface = NULL;
if(buf.buf)
{
float ms = fminf(
ts/(float)buf.width,
ts/(float)buf.height);
#if 0
// this doesn't work since osm-gps-map always gives 0/0 as mouse coords :(
/* find out if the cursor is over the image */
if(pointerx >= px && pointerx <= (px + buf.width*ms + 4) && pointery <= (py - 8) && pointery >= (py - buf.height*ms - 8 - 4))
{
printf("over\n");
cairo_set_source_rgba(cri, 1, 0, 0, 0.7);
}
// else
// printf("%d/%d, %d/%d\n", px, py, pointerx, pointery);
#endif
const int32_t stride = cairo_format_stride_for_width (CAIRO_FORMAT_RGB24, buf.width);
surface = cairo_image_surface_create_for_data (buf.buf, CAIRO_FORMAT_RGB24,
buf.width, buf.height, stride);
cairo_pattern_set_filter(cairo_get_source(cri), CAIRO_FILTER_NEAREST);
cairo_save(cri);
/* first of lets draw a pin */
cairo_move_to(cri, px, py);
cairo_line_to(cri, px+8, py-8);
cairo_line_to(cri, px+4, py-8);
cairo_fill(cri);
/* and the frame around image */
cairo_move_to(cri, px+2, py-8);
cairo_line_to(cri, px+2 + (buf.width*ms) + 4, py-8);
cairo_line_to(cri, px+2 + (buf.width*ms) + 4 , py-8-(buf.height*ms) - 4);
cairo_line_to(cri, px+2 , py-8-(buf.height*ms) - 4);
cairo_fill(cri);
/* draw image*/
cairo_translate(cri, px+4, py - 8 - (buf.height*ms) - 2);
cairo_scale(cri, ms, ms);
cairo_set_source_surface (cri, surface, 0, 0);
cairo_paint(cri);
cairo_restore(cri);
cairo_surface_destroy(surface);
}
}
else
{
/* just draw a patch indicating that there is images at the location */
cairo_rectangle(cri, px-8, py-8, 16, 16);
cairo_fill(cri);
}
}
}
static void _view_map_changed_callback(OsmGpsMap *map, dt_view_t *self)
{
dt_map_t *lib = (dt_map_t *)self->data;
const int ts = 64;
OsmGpsMapPoint bb[2];
/* get bounding box coords */
osm_gps_map_get_bbox(map, &bb[0], &bb[1]);
float bb_0_lat = 0.0, bb_0_lon = 0.0, bb_1_lat = 0.0, bb_1_lon = 0.0;
osm_gps_map_point_get_degrees(&bb[0], &bb_0_lat, &bb_0_lon);
osm_gps_map_point_get_degrees(&bb[1], &bb_1_lat, &bb_1_lon);
/* make the bounding box a little bigger to the west and south */
float lat0 = 0.0, lon0 = 0.0, lat1 = 0.0, lon1 = 0.0;
OsmGpsMapPoint *pt0 = osm_gps_map_point_new_degrees(0.0, 0.0), *pt1 = osm_gps_map_point_new_degrees(0.0, 0.0);
osm_gps_map_convert_screen_to_geographic(map, 0, 0, pt0);
osm_gps_map_convert_screen_to_geographic(map, 1.5*ts, 1.5*ts, pt1);
osm_gps_map_point_get_degrees(pt0, &lat0, &lon0);
osm_gps_map_point_get_degrees(pt1, &lat1, &lon1);
osm_gps_map_point_free(pt0);
osm_gps_map_point_free(pt1);
double south_border = lat0 - lat1, west_border = lon1 - lon0;
/* get map view state and store */
int zoom;
float center_lat, center_lon;
g_object_get(G_OBJECT(map), "zoom", &zoom, "latitude", ¢er_lat, "longitude", ¢er_lon, NULL);
dt_conf_set_float("plugins/map/longitude", center_lon);
dt_conf_set_float("plugins/map/latitude", center_lat);
dt_conf_set_int("plugins/map/zoom", zoom);
/* let's reset and reuse the main_query statement */
DT_DEBUG_SQLITE3_CLEAR_BINDINGS(lib->statements.main_query);
DT_DEBUG_SQLITE3_RESET(lib->statements.main_query);
/* bind bounding box coords for the main query */
DT_DEBUG_SQLITE3_BIND_DOUBLE(lib->statements.main_query, 1, bb_0_lon - west_border);
DT_DEBUG_SQLITE3_BIND_DOUBLE(lib->statements.main_query, 2, bb_1_lon);
DT_DEBUG_SQLITE3_BIND_DOUBLE(lib->statements.main_query, 3, bb_0_lat);
DT_DEBUG_SQLITE3_BIND_DOUBLE(lib->statements.main_query, 4, bb_1_lat - south_border);
DT_DEBUG_SQLITE3_BIND_DOUBLE(lib->statements.main_query, 5, center_lat);
DT_DEBUG_SQLITE3_BIND_DOUBLE(lib->statements.main_query, 6, center_lon);
/* remove the old images */
osm_gps_map_image_remove_all(map);
if(lib->images)
{
g_slist_foreach(lib->images, (GFunc) g_free, NULL);
g_slist_free(lib->images);
lib->images = NULL;
}
/* add all images to the map */
gboolean needs_redraw = FALSE;
dt_mipmap_size_t mip = dt_mipmap_cache_get_matching_size(darktable.mipmap_cache, ts, ts);
while(sqlite3_step(lib->statements.main_query) == SQLITE_ROW)
{
int imgid = sqlite3_column_int(lib->statements.main_query, 0);
dt_mipmap_buffer_t buf;
dt_mipmap_cache_read_get(darktable.mipmap_cache, &buf, imgid, mip, DT_MIPMAP_BEST_EFFORT);
if(buf.buf)
{
uint8_t *scratchmem = dt_mipmap_cache_alloc_scratchmem(darktable.mipmap_cache);
uint8_t *buf_decompressed = dt_mipmap_cache_decompress(&buf, scratchmem);
uint8_t *rgbbuf = g_malloc((buf.width+2)*(buf.height+2)*3);
memset(rgbbuf, 64, (buf.width+2)*(buf.height+2)*3);
for(int i=1; i<=buf.height; i++)
for(int j=1; j<=buf.width; j++)
for(int k=0; k<3; k++)
rgbbuf[(i*(buf.width+2)+j)*3+k] = buf_decompressed[((i-1)*buf.width+j-1)*4+2-k];
int w=ts, h=ts;
if(buf.width < buf.height) w = (buf.width*ts)/buf.height; // portrait
else h = (buf.height*ts)/buf.width; // landscape
GdkPixbuf *source = gdk_pixbuf_new_from_data(rgbbuf, GDK_COLORSPACE_RGB, FALSE, 8, (buf.width+2), (buf.height+2), (buf.width+2)*3, NULL, NULL);
GdkPixbuf *scaled = gdk_pixbuf_scale_simple(source, w, h, GDK_INTERP_HYPER);
//TODO: add back the arrow on the left lower corner of the image, pointing to the location
const dt_image_t *cimg = dt_image_cache_read_get(darktable.image_cache, imgid);
dt_map_image_t *entry = (dt_map_image_t*)g_malloc(sizeof(dt_map_image_t));
entry->imgid = imgid;
entry->image = osm_gps_map_image_add_with_alignment(map, cimg->latitude, cimg->longitude, scaled, 0, 1);
entry->width = w;
entry->height = h;
lib->images = g_slist_prepend(lib->images, entry);
dt_image_cache_read_release(darktable.image_cache, cimg);
if(source)
g_object_unref(source);
if(scaled)
g_object_unref(scaled);
g_free(rgbbuf);
}
else
needs_redraw = TRUE;
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
}
// not exactly thread safe, but should be good enough for updating the display
static int timeout_event_source = 0;
if(needs_redraw && timeout_event_source == 0)
timeout_event_source = g_timeout_add_seconds(1, _view_map_redraw, self); // try again in a second, maybe some pictures have loaded by then
else
timeout_event_source = 0;
}
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);
}
}
}
}
static void edit_preset_response(GtkDialog *dialog, gint response_id, dt_gui_presets_edit_dialog_t *g)
{
gint is_new = 0;
if(response_id == GTK_RESPONSE_ACCEPT)
{
sqlite3_stmt *stmt;
const gchar *name = gtk_entry_get_text(g->name);
if(((g->old_id >= 0) && (strcmp(g->original_name, name) != 0)) || (g->old_id < 0))
{
if(strcmp(_("new preset"), name) == 0 || !(name && *name))
{
// show error dialog
GtkWidget *window = dt_ui_main_window(darktable.gui->ui);
GtkWidget *dlg_changename
= gtk_message_dialog_new(GTK_WINDOW(window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_WARNING,
GTK_BUTTONS_OK, _("please give preset a name"));
gtk_window_set_title(GTK_WINDOW(dlg_changename), _("unnamed preset"));
gtk_dialog_run(GTK_DIALOG(dlg_changename));
gtk_widget_destroy(dlg_changename);
return;
}
// editing existing preset with different name or store new preset -> check for a preset with the same
// name:
DT_DEBUG_SQLITE3_PREPARE_V2(
dt_database_get(darktable.db),
"select name from presets where name = ?1 and operation=?2 and op_version=?3", -1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, name, -1, SQLITE_TRANSIENT);
DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 2, g->module->op, -1, SQLITE_TRANSIENT);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 3, g->module->version());
if(sqlite3_step(stmt) == SQLITE_ROW)
{
sqlite3_finalize(stmt);
// show overwrite question dialog
GtkWidget *window = dt_ui_main_window(darktable.gui->ui);
GtkWidget *dlg_overwrite = gtk_message_dialog_new(
GTK_WINDOW(window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_WARNING, GTK_BUTTONS_YES_NO,
_("preset `%s' already exists.\ndo you want to overwrite?"), name);
gtk_window_set_title(GTK_WINDOW(dlg_overwrite), _("overwrite preset?"));
gint dlg_ret = gtk_dialog_run(GTK_DIALOG(dlg_overwrite));
gtk_widget_destroy(dlg_overwrite);
// if result is BUTTON_NO exit without destroy dialog, to permit other name
if(dlg_ret == GTK_RESPONSE_NO) return;
}
else
{
is_new = 1;
sqlite3_finalize(stmt);
}
}
if(g->old_id >= 0)
{
// now delete old preset:
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db),
"delete from presets where name=?1 and operation=?2 and op_version=?3", -1,
&stmt, NULL);
DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, g->original_name, -1, SQLITE_TRANSIENT);
DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 2, g->module->op, -1, SQLITE_TRANSIENT);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 3, g->module->version());
sqlite3_step(stmt);
sqlite3_finalize(stmt);
}
if(is_new == 0)
{
// delete preset, so we can re-insert the new values:
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db),
"delete from presets where name=?1 and operation=?2 and op_version=?3", -1,
&stmt, NULL);
DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, name, -1, SQLITE_TRANSIENT);
DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 2, g->module->op, -1, SQLITE_TRANSIENT);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 3, g->module->version());
sqlite3_step(stmt);
sqlite3_finalize(stmt);
}
// rename accelerators
char path[1024];
snprintf(path, sizeof(path), "%s/%s", _("preset"), g->original_name);
dt_accel_rename_preset_iop(g->module, path, name);
// commit all the user input fields
DT_DEBUG_SQLITE3_PREPARE_V2(
dt_database_get(darktable.db),
"INSERT INTO presets (name, description, operation, op_version, op_params, enabled, "
"blendop_params, blendop_version, multi_priority, multi_name, "
"model, maker, lens, iso_min, iso_max, exposure_min, exposure_max, aperture_min, aperture_max, "
"focal_length_min, focal_length_max, writeprotect, autoapply, filter, def, format) "
"VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, 0, '', ?9, ?10, ?11, ?12, ?13, ?14, ?15, ?16, ?17, ?18, "
"?19, 0, ?20, ?21, 0, ?22)",
-1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, name, -1, SQLITE_TRANSIENT);
DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 2, gtk_entry_get_text(g->description), -1, SQLITE_TRANSIENT);
DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 3, g->module->op, -1, SQLITE_TRANSIENT);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 4, g->module->version());
DT_DEBUG_SQLITE3_BIND_BLOB(stmt, 5, g->module->params, g->module->params_size, SQLITE_TRANSIENT);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 6, g->module->enabled);
DT_DEBUG_SQLITE3_BIND_BLOB(stmt, 7, g->module->blend_params, sizeof(dt_develop_blend_params_t),
SQLITE_TRANSIENT);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 8, dt_develop_blend_version());
DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 9, gtk_entry_get_text(GTK_ENTRY(g->model)), -1, SQLITE_TRANSIENT);
DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 10, gtk_entry_get_text(GTK_ENTRY(g->maker)), -1, SQLITE_TRANSIENT);
DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 11, gtk_entry_get_text(GTK_ENTRY(g->lens)), -1, SQLITE_TRANSIENT);
DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 12, gtk_spin_button_get_value(GTK_SPIN_BUTTON(g->iso_min)));
DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 13, gtk_spin_button_get_value(GTK_SPIN_BUTTON(g->iso_max)));
DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 14,
dt_gui_presets_exposure_value[dt_bauhaus_combobox_get(g->exposure_min)]);
DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 15,
dt_gui_presets_exposure_value[dt_bauhaus_combobox_get(g->exposure_max)]);
DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 16,
dt_gui_presets_aperture_value[dt_bauhaus_combobox_get(g->aperture_min)]);
DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 17,
dt_gui_presets_aperture_value[dt_bauhaus_combobox_get(g->aperture_max)]);
DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 18, gtk_spin_button_get_value(GTK_SPIN_BUTTON(g->focal_length_min)));
DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 19, gtk_spin_button_get_value(GTK_SPIN_BUTTON(g->focal_length_max)));
DT_DEBUG_SQLITE3_BIND_INT(stmt, 20, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(g->autoapply)));
DT_DEBUG_SQLITE3_BIND_INT(stmt, 21, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(g->filter)));
int format = 0;
for(int k = 0; k < 3; k++)
format += gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(g->format_btn[k])) * dt_gui_presets_format_flag[k];
DT_DEBUG_SQLITE3_BIND_INT(stmt, 22, format);
sqlite3_step(stmt);
sqlite3_finalize(stmt);
dt_gui_store_last_preset(name);
}
gtk_widget_destroy(GTK_WIDGET(dialog));
g_free(g->original_name);
free(g);
}