static void
_blendop_blendif_pick_toggled(GtkToggleButton *togglebutton, dt_iop_module_t *module)
{
if(darktable.gui->reset) return;
/* if module itself already requested color pick (positive value in request_color_pick),
don't tamper with it. A module color picker takes precedence. */
if(module->request_color_pick > 0)
{
gtk_toggle_button_set_active(togglebutton, 0);
return;
}
/* we put a negative value into request_color_pick to later see if color picker was
requested by blendif. A module color picker may overwrite this. This is fine, blendif
will use the color picker data, but not deactivate it. */
module->request_color_pick = (gtk_toggle_button_get_active(togglebutton) ? -1 : 0);
/* set the area sample size */
if (module->request_color_pick)
{
dt_lib_colorpicker_set_point(darktable.lib, 0.5, 0.5);
dt_dev_reprocess_all(module->dev);
}
else
dt_control_queue_redraw();
if(module->off) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(module->off), 1);
dt_iop_request_focus(module);
}
void scrolled(dt_view_t *self, double x, double y, int up, int state)
{
const int32_t capwd = darktable.thumbnail_width;
const int32_t capht = darktable.thumbnail_height;
dt_develop_t *dev = (dt_develop_t *)self->data;
const int32_t width_i = self->width;
const int32_t height_i = self->height;
if(width_i > capwd) x += (capwd-width_i) *.5f;
if(height_i > capht) y += (capht-height_i)*.5f;
int handled = 0;
if(dev->gui_module && dev->gui_module->scrolled) handled = dev->gui_module->scrolled(dev->gui_module, x, y, up, state);
if(handled) return;
// free zoom
dt_dev_zoom_t zoom;
int closeup, procw, proch;
float zoom_x, zoom_y;
DT_CTL_GET_GLOBAL(zoom, dev_zoom);
DT_CTL_GET_GLOBAL(closeup, dev_closeup);
DT_CTL_GET_GLOBAL(zoom_x, dev_zoom_x);
DT_CTL_GET_GLOBAL(zoom_y, dev_zoom_y);
dt_dev_get_processed_size(dev, &procw, &proch);
float scale = dt_dev_get_zoom_scale(dev, zoom, closeup ? 2.0 : 1.0, 0);
const float minscale = dt_dev_get_zoom_scale(dev, DT_ZOOM_FIT, 1.0, 0);
// offset from center now (current zoom_{x,y} points there)
float mouse_off_x = x - .5*dev->width, mouse_off_y = y - .5*dev->height;
zoom_x += mouse_off_x/(procw*scale);
zoom_y += mouse_off_y/(proch*scale);
zoom = DT_ZOOM_FREE;
closeup = 0;
if(up)
{
if (scale == 1.0f) return;
else scale += .1f*(1.0f - minscale);
}
else
{
if (scale == minscale) return;
else scale -= .1f*(1.0f - minscale);
}
DT_CTL_SET_GLOBAL(dev_zoom_scale, scale);
if(scale > 0.99) zoom = DT_ZOOM_1;
if(scale < minscale + 0.01) zoom = DT_ZOOM_FIT;
if(zoom != DT_ZOOM_1)
{
zoom_x -= mouse_off_x/(procw*scale);
zoom_y -= mouse_off_y/(proch*scale);
}
dt_dev_check_zoom_bounds(dev, &zoom_x, &zoom_y, zoom, closeup, NULL, NULL);
DT_CTL_SET_GLOBAL(dev_zoom, zoom);
DT_CTL_SET_GLOBAL(dev_closeup, closeup);
if(zoom != DT_ZOOM_1)
{
DT_CTL_SET_GLOBAL(dev_zoom_x, zoom_x);
DT_CTL_SET_GLOBAL(dev_zoom_y, zoom_y);
}
dt_dev_invalidate(dev);
dt_control_queue_redraw();
}
static void _view_print_settings(const dt_view_t *view, dt_print_info_t *pinfo)
{
dt_print_t *prt = (dt_print_t *)view->data;
prt->pinfo = pinfo;
dt_control_queue_redraw();
}
static void
autoexp_callback (GtkToggleButton *button, gpointer user_data)
{
dt_iop_module_t *self = (dt_iop_module_t *)user_data;
dt_iop_exposure_gui_data_t *g = (dt_iop_exposure_gui_data_t *)self->gui_data;
if(self->dt->gui->reset) return;
deflicker_disable(self);
self->request_color_pick = gtk_toggle_button_get_active(button);
dt_iop_request_focus(self);
if (self->request_color_pick > 0)
{
dt_lib_colorpicker_set_area(darktable.lib, 0.99);
dt_dev_reprocess_all(self->dev);
}
else
dt_control_queue_redraw();
gtk_widget_set_sensitive(GTK_WIDGET(g->autoexpp), gtk_toggle_button_get_active(button));
dt_dev_add_history_item(darktable.develop, self, TRUE);
}
int dt_lua_do_chunk(lua_State *L,int nargs,int nresults)
{
int result;
lua_pushcfunction(L,dump_error);
lua_insert(L,lua_gettop(L)-(nargs+1));
result = lua_gettop(L)-(nargs+1); // remember the stack size to findout the number of results in case of multiret
if(lua_pcall(L, nargs, nresults,result))
{
dt_print(DT_DEBUG_LUA,"LUA ERROR %s\n",lua_tostring(L,-1));
lua_pop(L,2);
if(nresults !=LUA_MULTRET)
{
for(int i= 0 ; i < nresults; i++)
{
lua_pushnil(L);
}
}
} else {
lua_remove(L,result); // remove the error handler
}
result= lua_gettop(L) -result;
lua_gc(L,LUA_GCCOLLECT,0);
if(darktable.gui!=NULL) dt_control_queue_redraw();
return result;
}
void border_scrolled(dt_view_t *view, double x, double y, int which, int up)
{
dt_develop_t *dev = (dt_develop_t *)view->data;
dt_dev_zoom_t zoom;
int closeup;
float zoom_x, zoom_y;
DT_CTL_GET_GLOBAL(zoom, dev_zoom);
DT_CTL_GET_GLOBAL(closeup, dev_closeup);
DT_CTL_GET_GLOBAL(zoom_x, dev_zoom_x);
DT_CTL_GET_GLOBAL(zoom_y, dev_zoom_y);
if(which > 1)
{
if(up) zoom_x -= 0.02;
else zoom_x += 0.02;
}
else
{
if(up) zoom_y -= 0.02;
else zoom_y += 0.02;
}
dt_dev_check_zoom_bounds(dev, &zoom_x, &zoom_y, zoom, closeup, NULL, NULL);
DT_CTL_SET_GLOBAL(dev_zoom_x, zoom_x);
DT_CTL_SET_GLOBAL(dev_zoom_y, zoom_y);
dt_dev_invalidate(dev);
dt_control_queue_redraw();
}
static void dt_iop_levels_pick_general_handler(GtkToggleButton *togglebutton, dt_iop_module_t *self, double xpick, double ypick, dt_iop_levels_pick_t picklevel)
{
dt_iop_levels_gui_data_t *c = (dt_iop_levels_gui_data_t *)self->gui_data;
darktable.gui->reset = 1;
// we do not require the callback if we deactivate it here
if (c->activeToggleButton != NULL) gtk_toggle_button_set_active(c->activeToggleButton, FALSE);
darktable.gui->reset = 0;
gboolean toggle = gtk_toggle_button_get_active(togglebutton);
if(darktable.gui->reset) return;
if (TRUE == toggle)
{
self->request_color_pick = TRUE;
dt_lib_colorpicker_set_point(darktable.lib, xpick, ypick);
dt_iop_request_focus(self);
c->activeToggleButton = togglebutton;
c->current_pick = picklevel;
}
else
{
self->request_color_pick = FALSE;
dt_iop_request_focus(self);
c->activeToggleButton = NULL;
c->current_pick = NONE;
gtk_widget_queue_draw(self->widget);
}
if(self->off) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(self->off), TRUE);
dt_control_queue_redraw();
}
static gboolean _lib_filmstrip_ratings_key_accel_callback(GtkAccelGroup *accel_group,
GObject *aceeleratable, guint keyval,
GdkModifierType modifier, gpointer data)
{
int num = GPOINTER_TO_INT(data);
switch (num)
{
case DT_VIEW_DESERT:
case DT_VIEW_REJECT:
case DT_VIEW_STAR_1:
case DT_VIEW_STAR_2:
case DT_VIEW_STAR_3:
case DT_VIEW_STAR_4:
case DT_VIEW_STAR_5:
case 666:
{
int32_t mouse_over_id;
DT_CTL_GET_GLOBAL(mouse_over_id, lib_image_mouse_over_id);
if (mouse_over_id <= 0) return FALSE;
/* get image from cache */
int32_t activated_image = -1;
activated_image = darktable.view_manager->proxy.filmstrip.activated_image(darktable.view_manager->proxy.filmstrip.module);
int offset = 0;
if(mouse_over_id == activated_image)
offset = dt_collection_image_offset(mouse_over_id);
const dt_image_t *cimg = dt_image_cache_read_get(darktable.image_cache, mouse_over_id);
dt_image_t *image = dt_image_cache_write_get(darktable.image_cache, cimg);
if (num == 666)
image->flags &= ~0xf;
else if (num == DT_VIEW_STAR_1 && ((image->flags & 0x7) == 1))
image->flags &= ~0x7;
else if(num == DT_VIEW_REJECT && ((image->flags & 0x7) == 6)) image->flags &= ~0x7;
else
{
image->flags &= ~0x7;
image->flags |= num;
}
dt_image_cache_write_release(darktable.image_cache, image, DT_IMAGE_CACHE_SAFE);
dt_image_cache_read_release(darktable.image_cache, image);
dt_collection_hint_message(darktable.collection); // More than this, we need to redraw all
if(mouse_over_id == activated_image)
if(_lib_filmstrip_imgid_in_collection(darktable.collection, mouse_over_id) == 0)
dt_view_filmstrip_scroll_relative(0, offset);
/* redraw all */
dt_control_queue_redraw();
break;
}
default:
break;
}
return TRUE;
}
void
dt_import_session_import(struct dt_import_session_t *self)
{
int id = dt_image_import(self->film->id, self->current_filename, TRUE);
if(id)
{
dt_view_filmstrip_set_active_image(darktable.view_manager,id);
dt_control_queue_redraw();
}
}
void dt_lua_redraw_screen()
{
if(darktable.gui != NULL)
{
dt_lua_unlock(false);
dt_control_signal_raise(darktable.signals, DT_SIGNAL_FILMROLLS_CHANGED); // just for good measure
dt_control_queue_redraw();
dt_lua_lock();
}
}
void dt_lib_gui_set_expanded(dt_lib_module_t *module, gboolean expanded)
{
if(!module->expander) return;
/* update expander arrow state */
GtkWidget *icon;
GtkWidget *header = gtk_bin_get_child(GTK_BIN(g_list_nth_data(gtk_container_get_children(GTK_CONTAINER(module->expander)),0)));
gint flags = CPF_DIRECTION_DOWN;
int c = module->container();
if ( (c == DT_UI_CONTAINER_PANEL_LEFT_TOP) ||
(c == DT_UI_CONTAINER_PANEL_LEFT_CENTER) ||
(c == DT_UI_CONTAINER_PANEL_LEFT_BOTTOM) )
{
icon = g_list_nth_data(gtk_container_get_children(GTK_CONTAINER(header)),0);
if(!expanded)
flags=CPF_DIRECTION_RIGHT;
}
else
{
icon = g_list_last(gtk_container_get_children(GTK_CONTAINER(header)))->data;
if(!expanded)
flags=CPF_DIRECTION_LEFT;
}
dtgtk_icon_set_paint(icon, dtgtk_cairo_paint_solid_arrow, flags);
/* show / hide plugin widget */
if(expanded)
{
gtk_widget_show_all(module->widget);
/* register to receive draw events */
darktable.lib->gui_module = module;
/* focus the current module */
for(int k=0; k<DT_UI_CONTAINER_SIZE; k++)
dt_ui_container_focus_widget(darktable.gui->ui, k, GTK_WIDGET(module->expander));
}
else
{
gtk_widget_hide_all(module->widget);
if(darktable.lib->gui_module == module)
{
darktable.lib->gui_module = NULL;
dt_control_queue_redraw();
}
}
/* store expanded state of module */
char var[1024];
snprintf(var, 1024, "plugins/lighttable/%s/expanded", module->plugin_name);
dt_conf_set_bool(var, gtk_widget_get_visible(module->widget));
}
void dt_lib_gui_set_expanded(dt_lib_module_t *module, gboolean expanded)
{
if(!module->expander) return;
dtgtk_expander_set_expanded(DTGTK_EXPANDER(module->expander), expanded);
/* update expander arrow state */
GtkWidget *icon;
GtkWidget *header = dtgtk_expander_get_header(DTGTK_EXPANDER(module->expander));
gint flags = CPF_DIRECTION_DOWN;
int c = module->container(module);
GList *header_childs = gtk_container_get_children(GTK_CONTAINER(header));
if((c == DT_UI_CONTAINER_PANEL_LEFT_TOP) || (c == DT_UI_CONTAINER_PANEL_LEFT_CENTER)
|| (c == DT_UI_CONTAINER_PANEL_LEFT_BOTTOM))
{
icon = g_list_nth_data(header_childs, 0);
if(!expanded) flags = CPF_DIRECTION_RIGHT;
}
else
{
icon = g_list_last(header_childs)->data;
if(!expanded) flags = CPF_DIRECTION_LEFT;
}
g_list_free(header_childs);
dtgtk_icon_set_paint(icon, dtgtk_cairo_paint_solid_arrow, flags);
/* show / hide plugin widget */
if(expanded)
{
/* register to receive draw events */
darktable.lib->gui_module = module;
/* focus the current module */
for(int k = 0; k < DT_UI_CONTAINER_SIZE; k++)
dt_ui_container_focus_widget(darktable.gui->ui, k, GTK_WIDGET(module->expander));
}
else
{
if(darktable.lib->gui_module == module)
{
darktable.lib->gui_module = NULL;
dt_control_queue_redraw();
}
}
/* store expanded state of module */
char var[1024];
const dt_view_t *current_view = dt_view_manager_get_current_view(darktable.view_manager);
snprintf(var, sizeof(var), "plugins/%s/%s/expanded", current_view->module_name, module->plugin_name);
dt_conf_set_bool(var, expanded);
}
static void
film_strip_activated(const int imgid, void *data)
{
// switch images in darkroom mode:
dt_view_t *self = (dt_view_t *)data;
dt_develop_t *dev = (dt_develop_t *)self->data;
dt_dev_change_image(dev, imgid);
dt_view_filmstrip_scroll_to_image(darktable.view_manager, imgid, FALSE);
// force redraw
dt_control_queue_redraw();
}
static void
pick_toggled(GtkToggleButton *togglebutton, dt_iop_module_t *self)
{
self->request_color_pick = gtk_toggle_button_get_active(togglebutton);
if(darktable.gui->reset) return;
/* set the area sample size*/
if (self->request_color_pick)
dt_lib_colorpicker_set_point(darktable.lib, 0.5, 0.5);
else
dt_control_queue_redraw();
if(self->off) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(self->off), 1);
dt_iop_request_focus(self);
}
void border_scrolled(dt_view_t *view, double x, double y, int which, int up)
{
dt_library_t *lib = (dt_library_t *)view->data;
if(which == 0 || which == 1)
{
if(up) lib->track = -DT_LIBRARY_MAX_ZOOM;
else lib->track = DT_LIBRARY_MAX_ZOOM;
}
else if(which == 2 || which == 3)
{
if(up) lib->track = -1;
else lib->track = 1;
}
dt_control_queue_redraw();
}
static void _zoom_preset_change(int val)
{
// dt_lib_module_t *self = (dt_lib_module_t *)user_data;
dt_develop_t *dev = darktable.develop;
if(!dev) return;
dt_dev_zoom_t zoom;
int closeup, procw, proch;
float zoom_x, zoom_y;
zoom = dt_control_get_dev_zoom();
closeup = dt_control_get_dev_closeup();
zoom_x = dt_control_get_dev_zoom_x();
zoom_y = dt_control_get_dev_zoom_y();
dt_dev_get_processed_size(dev, &procw, &proch);
float scale = 0;
zoom_x = 0.0f; //+= (1.0/scale)*(x - .5f*dev->width )/procw;
zoom_y = 0.0f; //+= (1.0/scale)*(y - .5f*dev->height)/proch;
if(val == 0)
{
scale = 0.5 * dt_dev_get_zoom_scale(dev, DT_ZOOM_FIT, 1.0, 0);
zoom = DT_ZOOM_FREE;
}
else if(val == 1)
{
zoom = DT_ZOOM_FIT;
scale = dt_dev_get_zoom_scale(dev, DT_ZOOM_FIT, 1.0, 0);
}
else if(val == 2)
{
scale = dt_dev_get_zoom_scale(dev, DT_ZOOM_1, 1.0, 0);
zoom = DT_ZOOM_1;
}
else if(val == 3)
{
scale = 2.0f;
zoom = DT_ZOOM_FREE;
}
dt_dev_check_zoom_bounds(dev, &zoom_x, &zoom_y, zoom, closeup, NULL, NULL);
dt_control_set_dev_zoom_scale(scale);
dt_control_set_dev_zoom(zoom);
dt_control_set_dev_closeup(closeup);
dt_control_set_dev_zoom_x(zoom_x);
dt_control_set_dev_zoom_y(zoom_y);
dt_dev_invalidate(dev);
dt_control_queue_redraw();
}
static gboolean _lib_filmstrip_ratings_key_accel_callback(GtkAccelGroup *accel_group, GObject *aceeleratable,
guint keyval, GdkModifierType modifier,
gpointer data)
{
int num = GPOINTER_TO_INT(data);
switch(num)
{
case DT_VIEW_DESERT:
case DT_VIEW_REJECT:
case DT_VIEW_STAR_1:
case DT_VIEW_STAR_2:
case DT_VIEW_STAR_3:
case DT_VIEW_STAR_4:
case DT_VIEW_STAR_5:
case 666:
{
int32_t mouse_over_id = dt_control_get_mouse_over_id();
if(mouse_over_id <= 0) return FALSE;
/* get image from cache */
int32_t activated_image = -1;
activated_image = darktable.view_manager->proxy.filmstrip.activated_image(
darktable.view_manager->proxy.filmstrip.module);
int offset = 0;
if(mouse_over_id == activated_image) offset = dt_collection_image_offset(mouse_over_id);
dt_ratings_apply_to_image(mouse_over_id, num);
dt_collection_hint_message(darktable.collection); // More than this, we need to redraw all
if(mouse_over_id == activated_image)
if(_lib_filmstrip_imgid_in_collection(darktable.collection, mouse_over_id) == 0)
dt_view_filmstrip_scroll_relative(0, offset);
/* redraw all */
dt_control_queue_redraw();
break;
}
default:
break;
}
return TRUE;
}
static void
request_pick_toggled(GtkToggleButton *togglebutton, dt_iop_module_t *self)
{
if(darktable.gui->reset) return;
self->request_color_pick = (gtk_toggle_button_get_active(togglebutton) ? 1 : 0);
if(self->request_color_pick)
{
dt_lib_colorpicker_set_point(darktable.lib, 0.5, 0.5);
dt_dev_reprocess_all(self->dev);
}
else
dt_control_queue_redraw();
if(self->off) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(self->off), 1);
dt_iop_request_focus(self);
}
static void request_pick_toggled(GtkToggleButton *togglebutton, dt_iop_module_t *self)
{
if(darktable.gui->reset) return;
self->request_color_pick
= (gtk_toggle_button_get_active(togglebutton) ? DT_REQUEST_COLORPICK_MODULE : DT_REQUEST_COLORPICK_OFF);
if(self->request_color_pick != DT_REQUEST_COLORPICK_OFF)
{
dt_lib_colorpicker_set_area(darktable.lib, 0.99);
dt_dev_reprocess_all(self->dev);
}
else
dt_control_queue_redraw();
if(self->off) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(self->off), 1);
dt_iop_request_focus(self);
}
static void _picker_button_toggled(GtkToggleButton *button, gpointer p)
{
dt_lib_colorpicker_t *data = ((dt_lib_module_t *)p)->data;
gtk_widget_set_sensitive(GTK_WIDGET(data->add_sample_button), gtk_toggle_button_get_active(button));
if(darktable.gui->reset) return;
dt_iop_module_t *module = get_colorout_module();
if(module)
{
dt_iop_request_focus(module);
module->request_color_pick = gtk_toggle_button_get_active(button) ? DT_REQUEST_COLORPICK_MODULE
: DT_REQUEST_COLORPICK_OFF;
dt_dev_invalidate_from_gui(darktable.develop);
}
else
{
dt_iop_request_focus(NULL);
}
dt_control_queue_redraw();
}
static void picker_callback(GtkWidget *button, gpointer user_data)
{
dt_iop_module_t *self = (dt_iop_module_t *)user_data;
if(darktable.gui->reset) return;
if(self->request_color_pick == DT_REQUEST_COLORPICK_OFF)
self->request_color_pick = DT_REQUEST_COLORPICK_MODULE;
else
self->request_color_pick = DT_REQUEST_COLORPICK_OFF;
dt_iop_request_focus(self);
if(self->request_color_pick != DT_REQUEST_COLORPICK_OFF)
dt_dev_reprocess_all(self->dev);
else
dt_control_queue_redraw();
if(self->off) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(self->off), 1);
}
static void _film_strip_activated(const int imgid, void *data)
{
const dt_view_t *self = (dt_view_t *)data;
dt_print_t *prt = (dt_print_t *)self->data;
prt->image_id = imgid;
prt->iwidth = prt->iheight = 0;
// guess the image orientation
_set_orientation(prt);
dt_view_filmstrip_scroll_to_image(darktable.view_manager, imgid, FALSE);
// record the imgid to display when going back to lighttable
dt_view_lighttable_set_position(darktable.view_manager, dt_collection_image_offset(imgid));
// force redraw
dt_control_queue_redraw();
}
static gboolean _lib_filmstrip_ratings_key_accel_callback(GtkAccelGroup *accel_group,
GObject *aceeleratable, guint keyval,
GdkModifierType modifier, gpointer data)
{
long int num = (long int)data;
switch (num)
{
case DT_VIEW_DESERT:
case DT_VIEW_REJECT:
case DT_VIEW_STAR_1:
case DT_VIEW_STAR_2:
case DT_VIEW_STAR_3:
case DT_VIEW_STAR_4:
case DT_VIEW_STAR_5:
case 666:
{
int32_t mouse_over_id;
DT_CTL_GET_GLOBAL(mouse_over_id, lib_image_mouse_over_id);
if (mouse_over_id <= 0) return FALSE;
/* get image from cache */
const dt_image_t *cimg = dt_image_cache_read_get(darktable.image_cache, mouse_over_id);
dt_image_t *image = dt_image_cache_write_get(darktable.image_cache, cimg);
if (num == 666)
image->flags &= ~0xf;
else if (num == DT_VIEW_STAR_1 && ((image->flags & 0x7) == 1))
image->flags &= ~0x7;
else
{
image->flags &= ~0x7;
image->flags |= num;
}
dt_image_cache_write_release(darktable.image_cache, image, DT_IMAGE_CACHE_SAFE);
dt_image_cache_read_release(darktable.image_cache, image);
/* redraw all */
dt_control_queue_redraw();
break;
}
default:
break;
}
return TRUE;
}
static void
picker_callback (GtkDarktableToggleButton *button, gpointer user_data)
{
dt_iop_module_t *self = (dt_iop_module_t *)user_data;
if(darktable.gui->reset) return;
self->request_color_pick = (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (button)) ? 1 : 0);
/* set the area sample size*/
if (self->request_color_pick)
{
dt_lib_colorpicker_set_point(darktable.lib, 0.5, 0.5);
dt_dev_reprocess_all(self->dev);
}
else
dt_control_queue_redraw();
if(self->off) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(self->off), 1);
dt_iop_request_focus(self);
}
static void _lib_duplicate_thumb_press_callback(GtkWidget *widget, GdkEventButton *event, dt_lib_module_t *self)
{
dt_lib_duplicate_t *d = (dt_lib_duplicate_t *)self->data;
int imgid = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget),"imgid"));
if(event->button == 1)
{
if(event->type == GDK_BUTTON_PRESS)
{
dt_develop_t *dev = darktable.develop;
if(!dev) return;
dt_dev_zoom_t zoom;
int closeup;
float zoom_x, zoom_y;
closeup = dt_control_get_dev_closeup();
float scale = 0;
zoom = DT_ZOOM_FIT;
scale = dt_dev_get_zoom_scale(dev, DT_ZOOM_FIT, 1.0, 0);
dt_dev_check_zoom_bounds(dev, &zoom_x, &zoom_y, zoom, closeup, NULL, NULL);
dt_control_set_dev_zoom_scale(scale);
dt_control_set_dev_zoom(zoom);
dt_control_set_dev_closeup(closeup);
dt_control_set_dev_zoom_x(zoom_x);
dt_control_set_dev_zoom_y(zoom_y);
dt_dev_invalidate(dev);
dt_control_queue_redraw();
dt_dev_invalidate(darktable.develop);
d->imgid = imgid;
dt_control_queue_redraw_center();
}
else if(event->type == GDK_2BUTTON_PRESS)
{
// to select the duplicate, we reuse the filmstrip proxy
_do_select(imgid);
}
}
}
int32_t dt_captured_image_import_job_run(dt_job_t *job)
{
dt_captured_image_import_t *t = (dt_captured_image_import_t *)job->param;
char message[512]= {0};
snprintf(message, 512, _("importing image %s"), t->filename);
const guint *jid = dt_control_backgroundjobs_create(darktable.control, 0, message );
int id = dt_image_import(t->film_id, t->filename, TRUE);
if(id)
{
//dt_film_open(1);
dt_view_filmstrip_set_active_image(darktable.view_manager,id);
dt_control_queue_redraw();
//dt_ctl_switch_mode_to(DT_DEVELOP);
}
dt_control_backgroundjobs_progress(darktable.control, jid, 1.0);
dt_control_backgroundjobs_destroy(darktable.control, jid);
return 0;
}
static void picker_callback(GtkToggleButton *button, gpointer user_data)
{
dt_iop_module_t *self = (dt_iop_module_t *)user_data;
if(darktable.gui->reset) return;
self->request_color_pick
= (gtk_toggle_button_get_active(button) ? DT_REQUEST_COLORPICK_MODULE : DT_REQUEST_COLORPICK_OFF);
if(self->request_color_pick == DT_REQUEST_COLORPICK_MODULE)
{
dt_lib_colorpicker_set_area(darktable.lib, 0.99);
dt_dev_reprocess_all(self->dev);
}
else
dt_control_queue_redraw();
// only activate if the color picker is selected, this is becasue the monochrome module as a draw signal.
if (self->request_color_pick == DT_REQUEST_COLORPICK_MODULE)
{
if(self->off) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(self->off), 1);
dt_iop_request_focus(self);
}
}
int32_t dt_image_import_job_run(dt_job_t *job)
{
int id;
char message[512];
dt_image_import_t *t;
const guint *jid;
t = (dt_image_import_t *)job->param;
message[0] = 0;
snprintf(message, 512, _("importing image %s"), t->filename);
jid = dt_control_backgroundjobs_create(darktable.control, 0, message );
id = dt_image_import(t->film_id, t->filename, TRUE);
if(id)
{
dt_view_filmstrip_set_active_image(darktable.view_manager, id);
dt_control_queue_redraw();
}
dt_control_backgroundjobs_progress(darktable.control, jid, 1.0);
dt_control_backgroundjobs_destroy(darktable.control, jid);
return 0;
}
static int32_t dt_image_import_job_run(dt_job_t *job)
{
int id;
char message[512];
dt_image_import_t *params;
params = dt_control_job_get_params(job);
message[0] = 0;
snprintf(message, sizeof(message), _("importing image %s"), params->filename);
dt_progress_t *progress = dt_control_progress_create(darktable.control, TRUE, message);
id = dt_image_import(params->film_id, params->filename, TRUE);
if(id)
{
dt_view_filmstrip_set_active_image(darktable.view_manager, id);
dt_control_queue_redraw();
}
dt_control_progress_set_progress(darktable.control, progress, 1.0);
dt_control_progress_destroy(darktable.control, progress);
free(params);
return 0;
}
void dt_dev_process_image_job(dt_develop_t *dev)
{
dt_pthread_mutex_lock(&dev->pipe_mutex);
dt_control_log_busy_enter();
// let gui know to draw preview instead of us, if it's there:
dev->image_dirty = 1;
dt_mipmap_buffer_t buf;
dt_times_t start;
dt_get_times(&start);
dt_mipmap_cache_read_get(darktable.mipmap_cache, &buf, dev->image_storage.id, DT_MIPMAP_FULL, DT_MIPMAP_BLOCKING);
dt_show_times(&start, "[dev]", "to load the image.");
// copy over image now that width and height are sure to be correct:
const dt_image_t *img = dt_image_cache_read_get(darktable.image_cache, dev->image_storage.id);
dev->image_storage = *img;
// but don't lock the real thing, as that would avoid any writers to change stuff.
// (such as raw loading or star rating changes)
dt_image_cache_read_release(darktable.image_cache, img);
// failed to load raw?
if(!buf.buf)
{
dt_control_log_busy_leave();
dt_pthread_mutex_unlock(&dev->pipe_mutex);
return;
}
dt_dev_pixelpipe_set_input(dev->pipe, dev, (float *)buf.buf, buf.width, buf.height, 1.0);
if(dev->image_loading)
{
// init pixel pipeline
dt_dev_pixelpipe_cleanup_nodes(dev->pipe);
dt_dev_pixelpipe_create_nodes(dev->pipe, dev);
if(dev->image_force_reload) dt_dev_pixelpipe_flush_caches(dev->pipe);
dev->image_dirty = 1;
dev->image_force_reload = 0;
if(dev->gui_attached)
{
// during load, a mipf update could have been issued.
dev->preview_input_changed = 1;
dev->preview_dirty = 1;
dev->gui_synch = 1; // notify gui thread we want to synch (call gui_update in the modules)
dev->preview_pipe->changed |= DT_DEV_PIPE_SYNCH;
}
dev->pipe->changed |= DT_DEV_PIPE_SYNCH;
}
dt_dev_zoom_t zoom;
float zoom_x, zoom_y, scale;
int x, y;
// adjust pipeline according to changed flag set by {add,pop}_history_item.
restart:
if(dev->gui_leaving)
{
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
dt_control_log_busy_leave();
dt_pthread_mutex_unlock(&dev->pipe_mutex);
return;
}
dev->pipe->input_timestamp = dev->timestamp;
// this locks dev->history_mutex.
dt_dev_pixelpipe_change(dev->pipe, dev);
// determine scale according to new dimensions
DT_CTL_GET_GLOBAL(zoom, dev_zoom);
DT_CTL_GET_GLOBAL(zoom_x, dev_zoom_x);
DT_CTL_GET_GLOBAL(zoom_y, dev_zoom_y);
scale = dt_dev_get_zoom_scale(dev, zoom, 1.0f, 0);
dev->capwidth = MIN(MIN(dev->width, dev->pipe->processed_width *scale), darktable.thumbnail_width);
dev->capheight = MIN(MIN(dev->height, dev->pipe->processed_height*scale), darktable.thumbnail_height);
x = MAX(0, scale*dev->pipe->processed_width *(.5+zoom_x)-dev->capwidth/2);
y = MAX(0, scale*dev->pipe->processed_height*(.5+zoom_y)-dev->capheight/2);
dt_get_times(&start);
if(dt_dev_pixelpipe_process(dev->pipe, dev, x, y, dev->capwidth, dev->capheight, scale))
{
// interrupted because image changed?
if(dev->image_force_reload)
{
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
dt_control_log_busy_leave();
dt_pthread_mutex_unlock(&dev->pipe_mutex);
return;
}
// or because the pipeline changed?
else goto restart;
}
dt_show_times(&start, "[dev_process_image] pixel pipeline processing", NULL);
dt_dev_average_delay_update(&start, &dev->average_delay);
// maybe we got zoomed/panned in the meantime?
if(dev->pipe->changed != DT_DEV_PIPE_UNCHANGED) goto restart;
// cool, we got a new image!
dev->image_dirty = 0;
dev->image_loading = 0;
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
// redraw the whole thing, to also update color picker values and histograms etc.
if(dev->gui_attached)
dt_control_queue_redraw();
dt_control_log_busy_leave();
dt_pthread_mutex_unlock(&dev->pipe_mutex);
}