static gboolean _view_map_motion_notify_callback(GtkWidget *w, GdkEventMotion *e, dt_view_t *self)
{
dt_map_t *lib = (dt_map_t*)self->data;
const int ts = 64;
if(lib->start_drag && lib->selected_image > 0)
{
for(GSList *iter = lib->images; iter != NULL; iter = iter->next)
{
dt_map_image_t *entry = (dt_map_image_t*)iter->data;
OsmGpsMapImage *image = entry->image;
if(entry->imgid == lib->selected_image)
{
osm_gps_map_image_remove(lib->map, image);
break;
}
}
lib->start_drag = FALSE;
GtkTargetList *targets = gtk_target_list_new(target_list_all, n_targets_all);
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, lib->selected_image, mip, DT_MIPMAP_BLOCKING);
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);
GdkDragContext * context = gtk_drag_begin(GTK_WIDGET(lib->map), targets, GDK_ACTION_COPY, 1, (GdkEvent*)e);
gtk_drag_set_icon_pixbuf(context, scaled, 0, 0);
if(source)
g_object_unref(source);
if(scaled)
g_object_unref(scaled);
g_free(rgbbuf);
}
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
gtk_target_list_unref(targets);
return TRUE;
}
return FALSE;
}
static void
_lib_filmstrip_dnd_begin_callback(GtkWidget *widget, GdkDragContext *context, gpointer user_data)
{
const int ts = 64;
dt_lib_module_t *self = (dt_lib_module_t *)user_data;
dt_lib_filmstrip_t *strip = (dt_lib_filmstrip_t *)self->data;
int imgid = strip->mouse_over_id;
// imgid part of selection -> do nothing
// otherwise -> select the current image
strip->select = DT_LIB_FILMSTRIP_SELECT_NONE;
sqlite3_stmt *stmt;
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "select imgid from selected_images where imgid=?1", -1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, imgid);
if(sqlite3_step(stmt) != SQLITE_ROW)
{
dt_selection_select_single(darktable.selection, imgid);
/* redraw filmstrip */
if(darktable.view_manager->proxy.filmstrip.module)
gtk_widget_queue_draw(darktable.view_manager->proxy.filmstrip.module->widget);
}
sqlite3_finalize(stmt);
// if we are dragging a single image -> use the thumbnail of that image
// otherwise use the generic d&d icon
// TODO: have something pretty in the 2nd case, too.
if(dt_collection_get_selected_count(NULL) == 1)
{
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, DT_MIPMAP_BLOCKING);
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);
gtk_drag_set_icon_pixbuf(context, scaled, 0, 0);
if(source)
g_object_unref(source);
if(scaled)
g_object_unref(scaled);
free(scratchmem);
g_free(rgbbuf);
}
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
}
}
int32_t dt_control_indexer_job_run(dt_job_t *job)
{
// if no indexing was requested, bail out:
if(!dt_conf_get_bool("run_similarity_indexer")) return 0;
/*
* First pass run thru ALL images and collect the ones who needs to update
* \TODO in the future lets have a indexer table with ids filed with images
* thats need some kind of reindexing.. all mark dirty functions adds image
* to this table--
*/
// temp memory for uncompressed images:
uint8_t *scratchmem = dt_mipmap_cache_alloc_scratchmem(darktable.mipmap_cache);
GList *images=NULL;
sqlite3_stmt *stmt;
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "select images.id,film_rolls.folder||'/'||images.filename,images.histogram,images.lightmap from images,film_rolls where film_rolls.id = images.film_id", -1, &stmt, NULL);
while(sqlite3_step(stmt) == SQLITE_ROW)
{
_control_indexer_img_t *idximg=g_malloc(sizeof( _control_indexer_img_t));
memset(idximg,0,sizeof(_control_indexer_img_t));
idximg->id = sqlite3_column_int(stmt,0);
/* first check if image file exists on disk */
const char *filename = (const char *)sqlite3_column_text(stmt, 1);
if (filename && !g_file_test(filename, G_FILE_TEST_IS_REGULAR))
idximg->flags |= _INDEXER_IMAGE_FILE_REMOVED;
/* check if histogram should be updated */
if (sqlite3_column_bytes(stmt, 2) != sizeof(dt_similarity_histogram_t))
idximg->flags |= _INDEXER_UPDATE_HISTOGRAM;
/* check if lightmap should be updated */
if (sqlite3_column_bytes(stmt, 3) != sizeof(dt_similarity_lightmap_t))
idximg->flags |= _INDEXER_UPDATE_LIGHTMAP;
/* if image is flagged add to collection */
if (idximg->flags != 0)
images = g_list_append(images, idximg);
else
g_free(idximg);
}
sqlite3_finalize(stmt);
/*
* Second pass, run thru collected images thats
* need reindexing...
*/
GList *imgitem = g_list_first(images);
if(imgitem)
{
char message[512]= {0};
double fraction=0;
int total = g_list_length(images);
guint *jid = NULL;
/* background job plate only if more then one image is reindexed */
if (total > 1)
{
snprintf(message, 512, ngettext ("re-indexing %d image", "re-indexing %d images", total), total );
jid = (guint *)dt_control_backgroundjobs_create(darktable.control, 0, message);
}
do
{
// bail out if we're shutting down:
if(!dt_control_running()) break;
// if indexer was switched off during runtime, respect that as soon as we can:
if(!dt_conf_get_bool("run_similarity_indexer")) break;
/* get the _control_indexer_img_t pointer */
_control_indexer_img_t *idximg = imgitem->data;
/*
* Check if image has been delete from disk
*/
if ((idximg->flags&_INDEXER_IMAGE_FILE_REMOVED))
{
/* file does not exist on disk lets delete image reference from database */
//char query[512]={0};
// \TODO dont delete move to an temp table and let user to revalidate
/*sprintf(query,"delete from history where imgid=%d",idximg->id);
DT_DEBUG_SQLITE3_EXEC(darktable.db, query, NULL, NULL, NULL);
sprintf(query,"delete from tagged_images where imgid=%d",idximg->id);
DT_DEBUG_SQLITE3_EXEC(darktable.db, query, NULL, NULL, NULL);
sprintf(query,"delete from images where id=%d",idximg->id);
DT_DEBUG_SQLITE3_EXEC(darktable.db, query, NULL, NULL, NULL);*/
/* no need to additional work */
continue;
}
/*
* Check if image histogram or lightmap should be updated.
* those indexing that involves a image pipe should fall into this
*/
if ( (idximg->flags&_INDEXER_UPDATE_HISTOGRAM) || (idximg->flags&_INDEXER_UPDATE_LIGHTMAP) )
{
/* get a mipmap of image to analyse */
dt_mipmap_buffer_t buf;
dt_mipmap_cache_read_get(darktable.mipmap_cache, &buf, idximg->id, DT_MIPMAP_2, DT_MIPMAP_BLOCKING);
// pointer owned by the cache or == scratchmem, no need to free this one:
uint8_t *buf_decompressed = dt_mipmap_cache_decompress(&buf, scratchmem);
if (!(buf.width * buf.height))
continue;
/*
* Generate similarity histogram data if requested
*/
if ( (idximg->flags&_INDEXER_UPDATE_HISTOGRAM) )
{
dt_similarity_histogram_t histogram;
float bucketscale = (float)DT_SIMILARITY_HISTOGRAM_BUCKETS/(float)0xff;
for(int j=0; j<(4*buf.width*buf.height); j+=4)
{
/* swap rgb and scale to bucket index */
uint8_t rgb[3];
for(int k=0; k<3; k++)
rgb[k] = (int)((buf_decompressed[j+2-k]/(float)0xff) * bucketscale);
/* distribute rgb into buckets */
for(int k=0; k<3; k++)
histogram.rgbl[rgb[k]][k]++;
/* distribute lum into buckets */
uint8_t lum = MAX(MAX(rgb[0], rgb[1]), rgb[2]);
histogram.rgbl[lum][3]++;
}
for(int k=0; k<DT_SIMILARITY_HISTOGRAM_BUCKETS; k++)
for (int j=0; j<4; j++)
histogram.rgbl[k][j] /= (buf.width*buf.height);
/* store the histogram data */
dt_similarity_histogram_store(idximg->id, &histogram);
}
/*
* Generate scaledowned similarity lightness map if requested
*/
if ( (idximg->flags&_INDEXER_UPDATE_LIGHTMAP) )
{
dt_similarity_lightmap_t lightmap;
memset(&lightmap,0,sizeof(dt_similarity_lightmap_t));
/*
* create a pixbuf out of the image for downscaling
*/
/* first of setup a standard rgb buffer, swap bgr in same routine */
uint8_t *rgbbuf = g_malloc(buf.width*buf.height*3);
for(int j=0; j<(buf.width*buf.height); j++)
for(int k=0; k<3; k++)
rgbbuf[3*j+k] = buf_decompressed[4*j+2-k];
/* then create pixbuf and scale down to lightmap size */
GdkPixbuf *source = gdk_pixbuf_new_from_data(rgbbuf,GDK_COLORSPACE_RGB,FALSE,8,buf.width,buf.height,(buf.width*3),NULL,NULL);
GdkPixbuf *scaled = gdk_pixbuf_scale_simple(source,DT_SIMILARITY_LIGHTMAP_SIZE,DT_SIMILARITY_LIGHTMAP_SIZE,GDK_INTERP_HYPER);
/* copy scaled data into lightmap */
uint8_t min=0xff,max=0;
uint8_t *spixels = gdk_pixbuf_get_pixels(scaled);
for(int j=0; j<(DT_SIMILARITY_LIGHTMAP_SIZE*DT_SIMILARITY_LIGHTMAP_SIZE); j++)
{
/* copy rgb */
for(int k=0; k<3; k++)
lightmap.pixels[4*j+k] = spixels[3*j+k];
/* average intensity into 4th channel */
lightmap.pixels[4*j+3] = (lightmap.pixels[4*j+0]+ lightmap.pixels[4*j+1]+ lightmap.pixels[4*j+2])/3.0;
min = MIN(min, lightmap.pixels[4*j+3]);
max = MAX(max, lightmap.pixels[4*j+3]);
}
/* contrast stretch each channel in lightmap
* TODO: do we want this...
*/
float scale=0;
int range = max-min;
if(range==0)
scale = 1.0;
else
scale = 0xff/range;
for(int j=0; j<(DT_SIMILARITY_LIGHTMAP_SIZE*DT_SIMILARITY_LIGHTMAP_SIZE); j++)
{
for(int k=0; k<4; k++)
lightmap.pixels[4*j+k] = (lightmap.pixels[4*j+k]-min)*scale;
}
/* free some resources */
g_object_unref(scaled);
g_object_unref(source);
g_free(rgbbuf);
/* store the lightmap */
dt_similarity_lightmap_store(idximg->id, &lightmap);
}
/* no use for buffer anymore release the mipmap */
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
}
/* update background progress */
if (jid)
{
fraction+=1.0/total;
dt_control_backgroundjobs_progress(darktable.control, jid, fraction);
}
}
while ((imgitem=g_list_next(imgitem)) && dt_control_job_get_state(job) != DT_JOB_STATE_CANCELLED);
/* cleanup */
if (jid)
dt_control_backgroundjobs_destroy(darktable.control, jid);
}
free(scratchmem);
/*
* Indexing opertions finished, lets reschedule the indexer
* unless control is shutting down...
*/
if(dt_control_running())
dt_control_start_indexer();
return 0;
}
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;
}
void
dt_view_image_expose(
dt_view_image_over_t *image_over,
uint32_t imgid,
cairo_t *cr,
int32_t width,
int32_t height,
int32_t zoom,
int32_t px,
int32_t py)
{
const double start = dt_get_wtime();
// some performance tuning stuff, for your pleasure.
// on my machine with 7 image per row it seems grouping has the largest
// impact from around 400ms -> 55ms per redraw.
#define DRAW_THUMB 1
#define DRAW_COLORLABELS 1
#define DRAW_GROUPING 1
#define DRAW_SELECTED 1
#define DRAW_HISTORY 1
#if DRAW_THUMB == 1
// this function is not thread-safe (gui-thread only), so we
// can safely allocate this leaking bit of memory to decompress thumbnails:
static int first_time = 1;
static uint8_t *scratchmem = NULL;
if(first_time)
{
// scratchmem might still be NULL after this, if compression is off.
scratchmem = dt_mipmap_cache_alloc_scratchmem(darktable.mipmap_cache);
first_time = 0;
}
#endif
cairo_save (cr);
float bgcol = 0.4, fontcol = 0.425, bordercol = 0.1, outlinecol = 0.2;
int selected = 0, altered = 0, imgsel = -1, is_grouped = 0;
// this is a gui thread only thing. no mutex required:
imgsel = darktable.control->global_settings.lib_image_mouse_over_id;
#if DRAW_SELECTED == 1
/* clear and reset statements */
DT_DEBUG_SQLITE3_CLEAR_BINDINGS(darktable.view_manager->statements.is_selected);
DT_DEBUG_SQLITE3_RESET(darktable.view_manager->statements.is_selected);
/* bind imgid to prepared statments */
DT_DEBUG_SQLITE3_BIND_INT(darktable.view_manager->statements.is_selected, 1, imgid);
/* lets check if imgid is selected */
if(sqlite3_step(darktable.view_manager->statements.is_selected) == SQLITE_ROW)
selected = 1;
#endif
#if DRAW_HISTORY == 1
DT_DEBUG_SQLITE3_CLEAR_BINDINGS(darktable.view_manager->statements.have_history);
DT_DEBUG_SQLITE3_RESET(darktable.view_manager->statements.have_history);
DT_DEBUG_SQLITE3_BIND_INT(darktable.view_manager->statements.have_history, 1, imgid);
/* lets check if imgid has history */
if(sqlite3_step(darktable.view_manager->statements.have_history) == SQLITE_ROW)
altered = 1;
#endif
const dt_image_t *img = dt_image_cache_read_testget(darktable.image_cache, imgid);
#if DRAW_GROUPING == 1
DT_DEBUG_SQLITE3_CLEAR_BINDINGS(darktable.view_manager->statements.get_grouped);
DT_DEBUG_SQLITE3_RESET(darktable.view_manager->statements.get_grouped);
DT_DEBUG_SQLITE3_BIND_INT(darktable.view_manager->statements.get_grouped, 1, imgid);
DT_DEBUG_SQLITE3_BIND_INT(darktable.view_manager->statements.get_grouped, 2, imgid);
/* lets check if imgid is in a group */
if(sqlite3_step(darktable.view_manager->statements.get_grouped) == SQLITE_ROW)
is_grouped = 1;
else if(img && darktable.gui->expanded_group_id == img->group_id)
darktable.gui->expanded_group_id = -1;
#endif
if(selected == 1)
{
outlinecol = 0.4;
bgcol = 0.6;
fontcol = 0.5;
}
if(imgsel == imgid)
{
bgcol = 0.8; // mouse over
fontcol = 0.7;
outlinecol = 0.6;
// if the user points at this image, we really want it:
if(!img)
img = dt_image_cache_read_get(darktable.image_cache, imgid);
}
float imgwd = 0.90f;
if(zoom == 1)
{
imgwd = .97f;
// cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE);
}
else
{
double x0 = 1, y0 = 1, rect_width = width-2, rect_height = height-2, radius = 5;
double x1, y1, off, off1;
x1=x0+rect_width;
y1=y0+rect_height;
off=radius*0.666;
off1 = radius-off;
cairo_move_to (cr, x0, y0 + radius);
cairo_curve_to (cr, x0, y0+off1, x0+off1 , y0, x0 + radius, y0);
cairo_line_to (cr, x1 - radius, y0);
cairo_curve_to (cr, x1-off1, y0, x1, y0+off1, x1, y0 + radius);
cairo_line_to (cr, x1 , y1 - radius);
cairo_curve_to (cr, x1, y1-off1, x1-off1, y1, x1 - radius, y1);
cairo_line_to (cr, x0 + radius, y1);
cairo_curve_to (cr, x0+off1, y1, x0, y1-off1, x0, y1- radius);
cairo_close_path (cr);
cairo_set_source_rgb(cr, bgcol, bgcol, bgcol);
cairo_fill_preserve(cr);
cairo_set_line_width(cr, 0.005*width);
cairo_set_source_rgb(cr, outlinecol, outlinecol, outlinecol);
cairo_stroke(cr);
if(img)
{
const char *ext = img->filename + strlen(img->filename);
while(ext > img->filename && *ext != '.') ext--;
ext++;
cairo_set_source_rgb(cr, fontcol, fontcol, fontcol);
cairo_select_font_face (cr, "sans-serif", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_BOLD);
cairo_set_font_size (cr, .25*width);
cairo_text_extents_t text_extends;
cairo_text_extents (cr, ext, &text_extends);
cairo_move_to (cr, .025*width - text_extends.x_bearing, .24*height);
cairo_show_text (cr, ext);
}
}
dt_mipmap_buffer_t buf;
dt_mipmap_size_t mip =
dt_mipmap_cache_get_matching_size(
darktable.mipmap_cache,
imgwd*width, imgwd*height);
dt_mipmap_cache_read_get(
darktable.mipmap_cache,
&buf,
imgid,
mip,
0);
#if DRAW_THUMB == 1
float scale = 1.0;
// decompress image, if necessary. if compression is off, scratchmem will be == NULL,
// so get the real pointer back:
uint8_t *buf_decompressed = dt_mipmap_cache_decompress(&buf, scratchmem);
cairo_surface_t *surface = NULL;
if(buf.buf)
{
const int32_t stride = cairo_format_stride_for_width (CAIRO_FORMAT_RGB24, buf.width);
surface = cairo_image_surface_create_for_data (buf_decompressed, CAIRO_FORMAT_RGB24, buf.width, buf.height, stride);
if(zoom == 1)
{
scale = fminf(
fminf(darktable.thumbnail_width, width) / (float)buf.width,
fminf(darktable.thumbnail_height, height) / (float)buf.height
);
}
else scale = fminf(width*imgwd/(float)buf.width, height*imgwd/(float)buf.height);
}
// draw centered and fitted:
cairo_save(cr);
cairo_translate(cr, width/2.0, height/2.0f);
cairo_scale(cr, scale, scale);
if(buf.buf)
{
cairo_translate(cr, -.5f*buf.width, -.5f*buf.height);
cairo_set_source_surface (cr, surface, 0, 0);
// set filter no nearest:
// in skull mode, we want to see big pixels.
// in 1 iir mode for the right mip, we want to see exactly what the pipe gave us, 1:1 pixel for pixel.
// in between, filtering just makes stuff go unsharp.
if((buf.width <= 8 && buf.height <= 8) || fabsf(scale - 1.0f) < 0.01f)
cairo_pattern_set_filter(cairo_get_source(cr), CAIRO_FILTER_NEAREST);
cairo_rectangle(cr, 0, 0, buf.width, buf.height);
cairo_fill(cr);
cairo_surface_destroy (surface);
cairo_rectangle(cr, 0, 0, buf.width, buf.height);
}
// border around image
const float border = zoom == 1 ? 16/scale : 2/scale;
cairo_set_source_rgb(cr, bordercol, bordercol, bordercol);
if(buf.buf && selected)
{
cairo_set_line_width(cr, 1./scale);
if(zoom == 1)
{
// draw shadow around border
cairo_set_source_rgb(cr, 0.2, 0.2, 0.2);
cairo_stroke(cr);
// cairo_new_path(cr);
cairo_set_fill_rule (cr, CAIRO_FILL_RULE_EVEN_ODD);
float alpha = 1.0f;
for(int k=0; k<16; k++)
{
cairo_rectangle(cr, 0, 0, buf.width, buf.height);
cairo_new_sub_path(cr);
cairo_rectangle(cr, -k/scale, -k/scale, buf.width+2.*k/scale, buf.height+2.*k/scale);
cairo_set_source_rgba(cr, 0, 0, 0, alpha);
alpha *= 0.6f;
cairo_fill(cr);
}
}
else
{
cairo_set_fill_rule (cr, CAIRO_FILL_RULE_EVEN_ODD);
cairo_new_sub_path(cr);
cairo_rectangle(cr, -border, -border, buf.width+2.*border, buf.height+2.*border);
cairo_stroke_preserve(cr);
cairo_set_source_rgb(cr, 1.0-bordercol, 1.0-bordercol, 1.0-bordercol);
cairo_fill(cr);
}
}
else if(buf.buf)
{
cairo_set_line_width(cr, 1);
cairo_stroke(cr);
}
cairo_restore(cr);
#endif
if(buf.buf)
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
const float fscale = fminf(width, height);
if(imgsel == imgid)
{
// draw mouseover hover effects, set event hook for mouse button down!
*image_over = DT_VIEW_DESERT;
cairo_set_line_width(cr, 1.5);
cairo_set_source_rgb(cr, outlinecol, outlinecol, outlinecol);
cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND);
float r1, r2;
if(zoom != 1)
{
r1 = 0.05*width;
r2 = 0.022*width;
}
else
{
r1 = 0.015*fscale;
r2 = 0.007*fscale;
}
float x, y;
if(zoom != 1) y = 0.90*height;
else y = .12*fscale;
gboolean image_is_rejected = (img && ((img->flags & 0x7) == 6));
if(img) for(int k=0; k<5; k++)
{
if(zoom != 1) x = (0.41+k*0.12)*width;
else x = (.08+k*0.04)*fscale;
if(!image_is_rejected) //if rejected: draw no stars
{
dt_view_star(cr, x, y, r1, r2);
if((px - x)*(px - x) + (py - y)*(py - y) < r1*r1)
{
*image_over = DT_VIEW_STAR_1 + k;
cairo_fill(cr);
}
else if((img->flags & 0x7) > k)
{
cairo_fill_preserve(cr);
cairo_set_source_rgb(cr, 1.0-bordercol, 1.0-bordercol, 1.0-bordercol);
cairo_stroke(cr);
cairo_set_source_rgb(cr, outlinecol, outlinecol, outlinecol);
}
else cairo_stroke(cr);
}
}
//Image rejected?
if(zoom !=1) x = 0.11*width;
else x = .04*fscale;
if (image_is_rejected)
cairo_set_source_rgb(cr, 1., 0., 0.);
if((px - x)*(px - x) + (py - y)*(py - y) < r1*r1)
{
*image_over = DT_VIEW_REJECT; //mouse sensitive
cairo_new_sub_path(cr);
cairo_arc(cr, x, y, (r1+r2)*.5, 0, 2.0f*M_PI);
cairo_stroke(cr);
}
if (image_is_rejected)
cairo_set_line_width(cr, 2.5);
//reject cross:
cairo_move_to(cr, x-r2, y-r2);
cairo_line_to(cr, x+r2, y+r2);
cairo_move_to(cr, x+r2, y-r2);
cairo_line_to(cr, x-r2, y+r2);
cairo_close_path(cr);
cairo_stroke(cr);
cairo_set_source_rgb(cr, outlinecol, outlinecol, outlinecol);
cairo_set_line_width(cr, 1.5);
// image part of a group?
if(is_grouped && darktable.gui && darktable.gui->grouping)
{
// draw grouping icon and border if the current group is expanded
// align to the right, left of altered
float s = (r1+r2)*.75;
float _x, _y;
if(zoom != 1)
{
_x = width*0.9 - s*2.5;
_y = height*0.1 - s*.4;
}
else
{
_x = (.04+7*0.04-1.1*.04)*fscale;
_y = y - (.17*.04)*fscale;
}
cairo_save(cr);
if(img && (imgid != img->group_id))
cairo_set_source_rgb(cr, fontcol, fontcol, fontcol);
dtgtk_cairo_paint_grouping(cr, _x, _y, s, s, 23);
cairo_restore(cr);
// mouse is over the grouping icon
if(img && abs(px-_x-.5*s) <= .8*s && abs(py-_y-.5*s) <= .8*s)
*image_over = DT_VIEW_GROUP;
}
// image altered?
if(altered)
{
// align to right
float s = (r1+r2)*.5;
if(zoom != 1)
{
x = width*0.9;
y = height*0.1;
}
else x = (.04+7*0.04)*fscale;
dt_view_draw_altered(cr, x, y, s);
//g_print("px = %d, x = %.4f, py = %d, y = %.4f\n", px, x, py, y);
if(img && abs(px-x) <= 1.2*s && abs(py-y) <= 1.2*s) // mouse hovers over the altered-icon -> history tooltip!
{
darktable.gui->center_tooltip = 1;
}
}
}
// kill all paths, in case img was not loaded yet, or is blocked:
cairo_new_path(cr);
#if DRAW_COLORLABELS == 1
// TODO: make mouse sensitive, just as stars!
// TODO: cache in image struct!
{
// color labels:
const float x = zoom == 1 ? (0.07)*fscale : .21*width;
const float y = zoom == 1 ? 0.17*fscale: 0.1*height;
const float r = zoom == 1 ? 0.01*fscale : 0.03*width;
/* clear and reset prepared statement */
DT_DEBUG_SQLITE3_CLEAR_BINDINGS(darktable.view_manager->statements.get_color);
DT_DEBUG_SQLITE3_RESET(darktable.view_manager->statements.get_color);
/* setup statement and iterate rows */
DT_DEBUG_SQLITE3_BIND_INT(darktable.view_manager->statements.get_color, 1, imgid);
while(sqlite3_step(darktable.view_manager->statements.get_color) == SQLITE_ROW)
{
cairo_save(cr);
int col = sqlite3_column_int(darktable.view_manager->statements.get_color, 0);
// see src/dtgtk/paint.c
dtgtk_cairo_paint_label(cr, x+(3*r*col)-5*r, y-r, r*2, r*2, col);
cairo_restore(cr);
}
}
#endif
if(img && (zoom == 1))
{
// some exif data
cairo_set_source_rgb(cr, .7, .7, .7);
cairo_select_font_face (cr, "sans-serif", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_BOLD);
cairo_set_font_size (cr, .025*fscale);
cairo_move_to (cr, .02*fscale, .04*fscale);
// cairo_show_text(cr, img->filename);
cairo_text_path(cr, img->filename);
char exifline[50];
cairo_move_to (cr, .02*fscale, .08*fscale);
dt_image_print_exif(img, exifline, 50);
cairo_text_path(cr, exifline);
cairo_fill_preserve(cr);
cairo_set_line_width(cr, 1.0);
cairo_set_source_rgb(cr, 0.3, 0.3, 0.3);
cairo_stroke(cr);
}
if(img) dt_image_cache_read_release(darktable.image_cache, img);
cairo_restore(cr);
// if(zoom == 1) cairo_set_antialias(cr, CAIRO_ANTIALIAS_DEFAULT);
const double end = dt_get_wtime();
dt_print(DT_DEBUG_PERF, "[lighttable] image expose took %0.04f sec\n", end-start);
}