void dt_control_delete_images()
{
if(dt_conf_get_bool("ask_before_delete"))
{
GtkWidget *dialog;
GtkWidget *win = dt_ui_main_window(darktable.gui->ui);
int number = dt_collection_get_selected_count(darktable.collection);
// Do not show the dialog if no image is selected:
if(number == 0) return;
dialog = gtk_message_dialog_new(GTK_WINDOW(win),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_QUESTION,
GTK_BUTTONS_YES_NO,
ngettext("do you really want to physically delete %d selected image from disk?",
"do you really want to physically delete %d selected images from disk?", number), number);
gtk_window_set_title(GTK_WINDOW(dialog), _("delete images?"));
gint res = gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
if(res != GTK_RESPONSE_YES) return;
}
dt_job_t j;
dt_control_delete_images_job_init(&j);
dt_control_add_job(darktable.control, &j);
}
static void lua_job_cancelled(dt_progress_t *progress, gpointer user_data)
{
dt_job_t *job = dt_control_job_create(&lua_job_canceled_job, "lua: on background cancel");
if(!job) return;
dt_control_job_set_params(job, progress);
dt_control_add_job(darktable.control, DT_JOB_QUEUE_SYSTEM_BG, job);
}
/** Listener interface for import job */
void _camera_image_downloaded(const dt_camera_t *camera,const char *filename,void *data)
{
// Import downloaded image to import filmroll
dt_camera_import_t *t = (dt_camera_import_t *)data;
dt_film_image_import(t->film,filename, FALSE);
dt_control_log(_("%d/%d imported to %s"), t->import_count+1,g_list_length(t->images), g_path_get_basename(filename));
t->fraction+=1.0/g_list_length(t->images);
dt_control_backgroundjobs_progress(darktable.control, t->bgj, t->fraction );
if( dt_conf_get_bool("plugins/capture/camera/import/backup/enable") == TRUE )
{
// Backup is enable, let's initialize a backup job of imported image...
char *base=dt_conf_get_string("plugins/capture/storage/basedirectory");
char *fixed_base=dt_util_fix_path(base);
dt_variables_expand( t->vp, fixed_base, FALSE );
g_free(base);
const char *sdpart=dt_variables_get_result(t->vp);
if( sdpart )
{
// Initialize a image backup job of file
dt_job_t j;
dt_camera_import_backup_job_init(&j, filename,filename+strlen(sdpart));
dt_control_add_job(darktable.control, &j);
}
}
t->import_count++;
}
void dt_control_delete_images()
{
if(dt_conf_get_bool("ask_before_delete"))
{
GtkWidget *dialog;
GtkWidget *win = dt_ui_main_window(darktable.gui->ui);
sqlite3_stmt *stmt = NULL;
int number = 0;
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "select count(imgid) from selected_images", -1, &stmt, NULL);
if(sqlite3_step(stmt) == SQLITE_ROW)
{
number = sqlite3_column_int(stmt, 0);
}
dialog = gtk_message_dialog_new(GTK_WINDOW(win),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_QUESTION,
GTK_BUTTONS_YES_NO,
ngettext("do you really want to physically delete %d selected image from disk?",
"do you really want to physically delete %d selected images from disk?", number), number);
gtk_window_set_title(GTK_WINDOW(dialog), _("delete images?"));
gint res = gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
if(res != GTK_RESPONSE_YES) return;
}
dt_job_t j;
dt_control_delete_images_job_init(&j);
dt_control_add_job(darktable.control, &j);
}
void dt_control_reset_local_copy_images()
{
dt_job_t j;
dt_control_local_copy_images_job_init(&j);
j.user_data=(void *)0;
dt_control_add_job(darktable.control, &j);
return;
}
static void _camera_capture_image_downloaded(const dt_camera_t *camera, const char *filename, void *data)
{
dt_capture_t *lib = (dt_capture_t *)data;
/* create an import job of downloaded image */
dt_control_add_job(darktable.control, DT_JOB_QUEUE_USER_BG,
dt_image_import_job_create(dt_import_session_film_id(lib->session), filename));
}
void dt_lua_init(lua_State*L,const char *lua_command)
{
/*
Note to reviewers
this is the only place where lua code is run without the lua lock.
At this point, no user script has been called,
so we are completely thread-safe. no need to lock
This is also the only place where lua code is run with the gdk lock
held, but this is not a problem because it is very brief, user calls
are delegated to a secondary job
*/
char tmp_path[PATH_MAX];
// init the lua environment
lua_CFunction* cur_type = init_funcs;
while(*cur_type)
{
(*cur_type)(L);
cur_type++;
}
// build the table containing the configuration info
lua_getglobal(L,"package");
dt_lua_goto_subtable(L,"loaded");
lua_pushstring(L,"darktable");
dt_lua_push_darktable_lib(L);
lua_settable(L,-3);
lua_pop(L,1);
lua_getglobal(L,"package");
lua_getfield(L,-1,"path");
lua_pushstring(L,";");
dt_loc_get_datadir(tmp_path, sizeof(tmp_path));
lua_pushstring(L,tmp_path);
lua_pushstring(L,"/lua/?.lua");
lua_pushstring(L,";");
dt_loc_get_user_config_dir(tmp_path, sizeof(tmp_path));
lua_pushstring(L,tmp_path);
lua_pushstring(L,"/lua/?.lua");
lua_concat(L,7);
lua_setfield(L,-2,"path");
lua_pop(L,1);
dt_job_t *job = dt_control_job_create(&run_early_script, "lua: run initial script");
dt_control_job_set_params(job, g_strdup(lua_command));
if(darktable.gui)
{
dt_control_add_job(darktable.control, DT_JOB_QUEUE_USER_BG, job);
}
else
{
run_early_script(job);
dt_control_job_dispose(job);
}
}
/* Background jobs will be timestamped and added to queue
the queue will then check ts and detect if its background job
and place it on the job_res if its available...
*/
int32_t dt_control_add_background_job(dt_control_t *s, dt_job_t *job, time_t delay)
{
/* setup timestamps */
job->ts_added = time(NULL);
job->ts_execute = job->ts_added+delay;
/* pass the job further to scheduled jobs worker */
return dt_control_add_job(s,job);
}
static void free_params_wrapper (struct dt_imageio_module_storage_t *self, dt_imageio_module_data_t *data)
{
dt_job_t job;
dt_control_job_init(&job, "lua: destroy storage param");
job.execute = &free_param_wrapper_job;
free_param_wrapper_data *t = (free_param_wrapper_data*)job.param;
t->data = (lua_storage_t*)data;
dt_control_add_job(darktable.control, &job);
}
void dt_control_move_images()
{
// Open file chooser dialog
gchar *dir = NULL;
GtkWidget *win = dt_ui_main_window(darktable.gui->ui);
int number = dt_collection_get_selected_count(darktable.collection);
// Do not show the dialog if no image is selected:
if(number == 0) return;
GtkWidget *filechooser = gtk_file_chooser_dialog_new (_("select directory"),
GTK_WINDOW (win),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
(char *)NULL);
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(filechooser), FALSE);
if (gtk_dialog_run (GTK_DIALOG (filechooser)) == GTK_RESPONSE_ACCEPT)
{
dir = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (filechooser));
}
gtk_widget_destroy (filechooser);
if(!dir || !g_file_test(dir, G_FILE_TEST_IS_DIR))
goto abort;
if(dt_conf_get_bool("ask_before_move"))
{
GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(win),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_QUESTION,
GTK_BUTTONS_YES_NO,
ngettext("do you really want to physically move the %d selected image to %s?\n"
"(all unselected duplicates will be moved along)",
"do you really want to physically move %d selected images to %s?\n"
"(all unselected duplicates will be moved along)", number), number, dir);
gtk_window_set_title(GTK_WINDOW(dialog), ngettext("move image?", "move images?", number));
gint res = gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
if(res != GTK_RESPONSE_YES)
goto abort;
}
dt_job_t j;
dt_control_move_images_job_init(&j);
j.user_data = dir;
dt_control_add_job(darktable.control, &j);
return;
abort:
g_free(dir);
return;
}
/** Listener callback from camera control when image are downloaded from camera. */
static void _camera_tethered_downloaded_callback(const dt_camera_t *camera,const char *filename,void *data)
{
dt_job_t j;
int32_t filmid = dt_view_tethering_get_film_id(darktable.view_manager);
if (filmid)
{
dt_captured_image_import_job_init(&j,filmid,filename);
dt_control_add_job(darktable.control, &j);
}
else
g_warning("failed to get filmid from tethering view...");
}
void dt_control_match_similar(dt_similarity_t *data)
{
dt_job_t j;
GList *selected = dt_collection_get_selected(darktable.collection);
if(selected)
{
dt_control_match_similar_job_init(&j, (long int)selected->data, data);
dt_control_add_job(darktable.control, &j);
}
else
dt_control_log(_("select an image as target for search of similar images"));
}
static void free_params_wrapper(struct dt_imageio_module_storage_t *self, dt_imageio_module_data_t *data)
{
dt_job_t *job = dt_control_job_create(&free_param_wrapper_job, "lua: destroy storage param");
if(!job) return;
free_param_wrapper_data *t = (free_param_wrapper_data *)calloc(1, sizeof(free_param_wrapper_data));
if(!t)
{
dt_control_job_dispose(job);
return;
}
dt_control_job_set_params(job, t, free_param_wrapper_destroy);
t->data = (lua_storage_t *)data;
dt_control_add_job(darktable.control, DT_JOB_QUEUE_SYSTEM_BG, job);
}
static gboolean shortcut_callback(GtkAccelGroup *accel_group,
GObject *acceleratable,
guint keyval,
GdkModifierType modifier,
gpointer p)
{
dt_job_t job;
dt_control_job_init(&job, "lua: on export image tmpfile");
job.execute = &shortcut_callback_job;
shortcut_callback_data *t = (shortcut_callback_data*)job.param;
t->name = strdup(p);
dt_control_add_job(darktable.control, &job);
return TRUE;
}
void _camera_capture_image_downloaded(const dt_camera_t *camera,const char *filename,void *data)
{
dt_camera_capture_t *t;
t = (dt_camera_capture_t*)data;
/* create an import job of downloaded image */
dt_control_add_job(darktable.control, DT_JOB_QUEUE_USER_BG, dt_image_import_job_create(dt_import_session_film_id(t->shared.session), filename));
if (--t->total == 0)
{
pthread_mutex_lock(&t->mutex);
pthread_cond_broadcast(&t->done);
pthread_mutex_unlock(&t->mutex);
}
}
void dt_printers_discovery(void (*cb)(dt_printer_info_t *pr, void *user_data), void *user_data)
{
// asynchronously checks for available printers
dt_job_t *job = dt_control_job_create(&_detect_printers_callback, "detect connected printers");
if(job)
{
dt_prtctl_t *prtctl = g_malloc0(sizeof(dt_prtctl_t));
prtctl->cb = cb;
prtctl->user_data = user_data;
dt_control_job_set_params(job, prtctl, g_free);
dt_control_add_job(darktable.control, DT_JOB_QUEUE_SYSTEM_BG, job);
}
}
static void on_image_imported(gpointer instance,uint32_t id, gpointer user_data){
dt_job_t *job = dt_control_job_create(&on_image_imported_callback_job, "lua: on image imported");
if(job)
{
on_image_imported_callback_data_t *t = (on_image_imported_callback_data_t*)calloc(1, sizeof(on_image_imported_callback_data_t));
if(!t)
{
dt_control_job_dispose(job);
}
else
{
dt_control_job_set_params(job, t);
t->imgid = id;
dt_control_add_job(darktable.control, DT_JOB_QUEUE_USER_FG, job);
}
}
}
static void
_capture_button_clicked(GtkWidget *widget, gpointer user_data)
{
dt_lib_camera_t *lib=(dt_lib_camera_t *)user_data;
uint32_t delay = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lib->gui.tb1))==TRUE?(uint32_t)gtk_spin_button_get_value(GTK_SPIN_BUTTON(lib->gui.sb1)):0;
uint32_t count = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lib->gui.tb2))==TRUE?(uint32_t)gtk_spin_button_get_value(GTK_SPIN_BUTTON(lib->gui.sb2)):1;
uint32_t brackets = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lib->gui.tb3))==TRUE?(uint32_t)gtk_spin_button_get_value(GTK_SPIN_BUTTON(lib->gui.sb3)):0;
uint32_t steps = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lib->gui.tb3))==TRUE?(uint32_t)gtk_spin_button_get_value(GTK_SPIN_BUTTON(lib->gui.sb4)):0;
dt_job_t j;
int32_t filmid = dt_view_tethering_get_film_id(darktable.view_manager);
if (filmid)
{
dt_camera_capture_job_init(&j,filmid,delay,count,brackets,steps);
dt_control_add_job(darktable.control, &j);
}
else
g_warning("failed to get filmid from tethering view...");
}
/* show import from camera dialog */
static void _lib_import_from_camera_callback(GtkButton *button,gpointer data)
{
dt_camera_import_dialog_param_t *params=(dt_camera_import_dialog_param_t *)g_malloc(sizeof(dt_camera_import_dialog_param_t));
memset( params, 0, sizeof(dt_camera_import_dialog_param_t));
params->camera = (dt_camera_t*)data;
dt_camera_import_dialog_new(params);
if( params->result )
{
/* initialize a import job and put it on queue.... */
gchar *path = g_build_path(G_DIR_SEPARATOR_S,params->basedirectory,params->subdirectory,(char *)NULL);
dt_job_t j;
dt_camera_import_job_init(&j,params->jobcode,path,params->filenamepattern,params->result,params->camera,params->time_override);
dt_control_add_job(darktable.control, &j);
g_free(path);
}
g_free(params);
}
void dt_control_export(GList *imgid_list,int max_width, int max_height, int format_index, int storage_index, gboolean high_quality,char *style)
{
dt_job_t job;
dt_control_job_init(&job, "export");
job.execute = &dt_control_export_job_run;
dt_control_image_enumerator_t *t = (dt_control_image_enumerator_t *)job.param;
t->index = imgid_list;
dt_control_export_t *data = (dt_control_export_t*)malloc(sizeof(dt_control_export_t));
data->max_width = max_width;
data->max_height = max_height;
data->format_index = format_index;
data->storage_index = storage_index;
data->high_quality = high_quality;
strncpy(data->style,style,128);
t->data = data;
dt_control_signal_raise(darktable.signals,DT_SIGNAL_IMAGE_EXPORT_MULTIPLE,t);
dt_control_add_job(darktable.control, &job);
}
/* show import from camera dialog */
static void _lib_import_from_camera_callback(GtkButton *button, gpointer data)
{
dt_camera_import_dialog_param_t *params
= (dt_camera_import_dialog_param_t *)g_malloc0(sizeof(dt_camera_import_dialog_param_t));
params->camera = (dt_camera_t *)data;
dt_camera_import_dialog_new(params);
if(params->result)
{
/* initialize a import job and put it on queue.... */
dt_control_add_job(
darktable.control, DT_JOB_QUEUE_USER_BG,
dt_camera_import_job_create(params->jobcode, params->result, params->camera, params->time_override));
}
g_free(params->jobcode);
g_list_free(params->result);
g_free(params);
}
void dt_lua_do_chunk_later_internal(const char* function, int line,lua_State *L, int nargs)
{
#ifdef _DEBUG
dt_print(DT_DEBUG_LUA,"LUA DEBUG : %s called from %s %d\n",__FUNCTION__,function,line);
#endif
lua_getfield(L, LUA_REGISTRYINDEX, "dt_lua_bg_threads");
lua_State *new_thread = lua_newthread(L);
const int reference = luaL_ref(L,-2);
lua_pop(L,1);
lua_xmove(L,new_thread,nargs+1);
dt_job_t *job = dt_control_job_create(&do_chunk_later_callback, "lua: later_chunk");
if(job)
{
dt_control_job_set_params(job, GINT_TO_POINTER(reference), NULL);
dt_control_add_job(darktable.control, DT_JOB_QUEUE_USER_FG, job);
}
}
static void on_mouse_over_image_changed(gpointer instance, gpointer user_data)
{
dt_job_t *job = dt_control_job_create(&on_mouse_over_image_changed_callback_job, "lua: on mouse over image changed");
if(job)
{
on_mouse_over_image_changed_callback_data_t *t
= (on_mouse_over_image_changed_callback_data_t *)calloc(1, sizeof(on_mouse_over_image_changed_callback_data_t));
if(!t)
{
dt_control_job_dispose(job);
}
else
{
dt_control_job_set_params(job, t);
t->imgid = dt_control_get_mouse_over_id();
dt_control_add_job(darktable.control, DT_JOB_QUEUE_USER_FG, job);
}
}
}
static void on_view_changed(gpointer instance, dt_view_t *old_view, dt_view_t *new_view, gpointer user_data)
{
dt_job_t *job = dt_control_job_create(&view_changed_callback_job, "lua: on view changed");
if(job)
{
view_changed_callback_data_t *t
= (view_changed_callback_data_t *)calloc(1, sizeof(view_changed_callback_data_t));
if(!t)
{
dt_control_job_dispose(job);
}
else
{
dt_control_job_set_params(job, t);
t->old_view = old_view;
t->new_view = new_view;
dt_control_add_job(darktable.control, DT_JOB_QUEUE_USER_FG, job);
}
}
}
static void _capture_button_clicked(GtkWidget *widget, gpointer user_data)
{
const char *jobcode = NULL;
dt_lib_camera_t *lib = (dt_lib_camera_t *)user_data;
uint32_t delay = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lib->gui.tb1)) == TRUE
? (uint32_t)gtk_spin_button_get_value(GTK_SPIN_BUTTON(lib->gui.sb1))
: 0;
uint32_t count = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lib->gui.tb2)) == TRUE
? (uint32_t)gtk_spin_button_get_value(GTK_SPIN_BUTTON(lib->gui.sb2))
: 1;
uint32_t brackets = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lib->gui.tb3)) == TRUE
? (uint32_t)gtk_spin_button_get_value(GTK_SPIN_BUTTON(lib->gui.sb3))
: 0;
uint32_t steps = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lib->gui.tb3)) == TRUE
? (uint32_t)gtk_spin_button_get_value(GTK_SPIN_BUTTON(lib->gui.sb4))
: 0;
/* create a capture background job */
jobcode = dt_view_tethering_get_job_code(darktable.view_manager);
dt_control_add_job(darktable.control, DT_JOB_QUEUE_USER_FG,
dt_camera_capture_job_create(jobcode, delay, count, brackets, steps));
}
void dt_lua_widget_trigger_callback_async(lua_widget object,const char* name,const char* type_name,...)
{
dt_job_t *job = dt_control_job_create(&widget_callback_job, "lua: widget event");
if(job)
{
widget_callback_data*data = malloc(sizeof(widget_callback_data));
data->object = object;
data->event_name = strdup(name);
data->extra=NULL;
va_list ap;
va_start(ap,type_name);
const char *cur_type = type_name;
while(cur_type ){
data->extra=g_list_append(data->extra,GINT_TO_POINTER(cur_type));
data->extra=g_list_append(data->extra,va_arg(ap,gpointer));
cur_type = va_arg(ap,const char*);
}
va_end(ap);
dt_control_job_set_params(job, data);
dt_control_add_job(darktable.control, DT_JOB_QUEUE_USER_FG, job);
}
}
void dt_lua_do_chunk_async_internal(const char * call_function, int line, lua_CFunction pusher,dt_lua_async_call_arg_type arg_type,...)
{
#ifdef _DEBUG
dt_print(DT_DEBUG_LUA,"LUA DEBUG : %s called from %s %d\n",__FUNCTION__,call_function,line);
#endif
dt_job_t *job = dt_control_job_create(&async_callback_job, "lua: async call");
if(job)
{
async_call_data*data = malloc(sizeof(async_call_data));
data->pusher = pusher;
data->extra=NULL;
va_list ap;
va_start(ap,arg_type);
dt_lua_async_call_arg_type cur_type = arg_type;
while(cur_type != LUA_ASYNC_DONE){
data->extra=g_list_append(data->extra,GINT_TO_POINTER(cur_type));
switch(cur_type) {
case LUA_ASYNC_TYPEID:
data->extra=g_list_append(data->extra,GINT_TO_POINTER(va_arg(ap,luaA_Type)));
data->extra=g_list_append(data->extra,va_arg(ap,gpointer));
break;
case LUA_ASYNC_TYPEID_WITH_FREE:
{
data->extra=g_list_append(data->extra,GINT_TO_POINTER(va_arg(ap,luaA_Type)));
data->extra=g_list_append(data->extra,va_arg(ap,gpointer));
GClosure* closure = va_arg(ap,GClosure*);
g_closure_ref (closure);
g_closure_sink (closure);
g_closure_set_marshal(closure, g_cclosure_marshal_generic);
data->extra=g_list_append(data->extra,closure);
}
break;
case LUA_ASYNC_TYPENAME:
data->extra=g_list_append(data->extra,va_arg(ap,char *));
data->extra=g_list_append(data->extra,va_arg(ap,gpointer));
break;
case LUA_ASYNC_TYPENAME_WITH_FREE:
{
data->extra=g_list_append(data->extra,va_arg(ap,char *));
data->extra=g_list_append(data->extra,va_arg(ap,gpointer));
GClosure* closure = va_arg(ap,GClosure*);
g_closure_ref (closure);
g_closure_sink (closure);
g_closure_set_marshal(closure, g_cclosure_marshal_generic);
data->extra=g_list_append(data->extra,closure);
}
break;
default:
// should never happen
g_assert(false);
break;
}
cur_type = va_arg(ap,dt_lua_async_call_arg_type);
}
va_end(ap);
dt_control_job_set_params(job, data, async_callback_job_destructor);
dt_control_add_job(darktable.control, DT_JOB_QUEUE_USER_FG, job);
}
}
void dt_control_flip_images(const int32_t cw)
{
dt_job_t j;
dt_control_flip_images_job_init(&j, cw);
dt_control_add_job(darktable.control, &j);
}
void dt_control_duplicate_images()
{
dt_job_t j;
dt_control_duplicate_images_job_init(&j);
dt_control_add_job(darktable.control, &j);
}
void dt_control_gpx_apply(const gchar *filename, int32_t filmid, const gchar *tz)
{
dt_job_t j;
dt_control_gpx_apply_job_init(&j, filename, filmid, tz);
dt_control_add_job(darktable.control, &j);
}
