// FIXME: needs a rewrite
int dt_film_open_recent(const int num)
{
sqlite3_stmt *stmt;
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db),
"SELECT id FROM main.film_rolls ORDER BY datetime_accessed DESC LIMIT ?1,1", -1,
&stmt, NULL);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, num);
if(sqlite3_step(stmt) == SQLITE_ROW)
{
int id = sqlite3_column_int(stmt, 0);
sqlite3_finalize(stmt);
if(dt_film_open(id)) return 1;
char datetime[20];
dt_gettime(datetime, sizeof(datetime));
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db),
"UPDATE main.film_rolls SET datetime_accessed = ?1 WHERE id = ?2", -1, &stmt,
NULL);
DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, datetime, -1, SQLITE_STATIC);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, id);
sqlite3_step(stmt);
}
sqlite3_finalize(stmt);
// dt_control_update_recent_films();
return 0;
}
static int32_t dt_camera_import_job_run(dt_job_t *job)
{
dt_camera_import_t *params = dt_control_job_get_params(job);
dt_control_log(_("starting to import images from camera"));
if(!dt_import_session_ready(params->shared.session))
{
dt_control_log("Failed to import images from camera.");
return 1;
}
guint total = g_list_length(params->images);
char message[512] = { 0 };
snprintf(message, sizeof(message),
ngettext("importing %d image from camera", "importing %d images from camera", total), total);
dt_control_job_set_progress_message(job, message);
// Switch to new filmroll
dt_film_open(dt_import_session_film_id(params->shared.session));
dt_ctl_switch_mode_to(DT_LIBRARY);
// register listener
dt_camctl_listener_t listener = { 0 };
listener.data = params;
listener.image_downloaded = _camera_import_image_downloaded;
listener.request_image_path = _camera_request_image_path;
listener.request_image_filename = _camera_request_image_filename;
// start download of images
dt_camctl_register_listener(darktable.camctl, &listener);
dt_camctl_import(darktable.camctl, params->camera, params->images);
dt_camctl_unregister_listener(darktable.camctl, &listener);
return 0;
}
// FIXME: needs a rewrite
int dt_film_open_recent(const int num)
{
sqlite3_stmt *stmt;
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db),
"select id from film_rolls order by datetime_accessed desc limit ?1,1",
-1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, num);
if(sqlite3_step(stmt) == SQLITE_ROW)
{
int id = sqlite3_column_int(stmt, 0);
sqlite3_finalize(stmt);
if(dt_film_open(id)) return 1;
char datetime[20];
dt_gettime(datetime);
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db),
"update film_rolls set datetime_accessed = ?1 where id = ?2",
-1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, datetime, strlen(datetime),
SQLITE_STATIC);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, id);
sqlite3_step(stmt);
}
sqlite3_finalize(stmt);
// dt_control_update_recent_films();
return 0;
}
static void _capture_view_set_jobcode(const dt_view_t *view, const char *name)
{
g_assert(view != NULL);
dt_capture_t *cv = (dt_capture_t *)view->data;
dt_import_session_set_name(cv->session, name);
dt_film_open(dt_import_session_film_id(cv->session));
dt_control_log(_("new session initiated '%s'"), name);
}
int32_t dt_camera_import_job_run(dt_job_t *job)
{
dt_camera_import_t *t = (dt_camera_import_t *)job->param;
dt_control_log(_("starting to import images from camera"));
if (!dt_import_session_ready(t->shared.session))
{
dt_control_log("Failed to import images from camera.");
return 1;
}
int total = g_list_length( t->images );
char message[512]= {0};
sprintf(message, ngettext ("importing %d image from camera", "importing %d images from camera", total), total );
t->bgj = dt_control_backgroundjobs_create(darktable.control, 0, message);
// Switch to new filmroll
dt_film_open(dt_import_session_film_id(t->shared.session));
dt_ctl_switch_mode_to(DT_LIBRARY);
// register listener
dt_camctl_listener_t listener= {0};
listener.data=t;
listener.image_downloaded=_camera_import_image_downloaded;
listener.request_image_path=_camera_request_image_path;
listener.request_image_filename=_camera_request_image_filename;
// start download of images
dt_camctl_register_listener(darktable.camctl,&listener);
dt_camctl_import(darktable.camctl,t->camera,t->images);
dt_camctl_unregister_listener(darktable.camctl,&listener);
dt_control_backgroundjobs_destroy(darktable.control, t->bgj);
dt_import_session_destroy(t->shared.session);
return 0;
}
int dt_load_from_string(const gchar* input, gboolean open_image_in_dr)
{
int id = 0;
if(input == NULL || input[0] == '\0')
return 0;
char* filename = dt_make_path_absolute(input);
if(filename == NULL)
{
dt_control_log(_("found strange path `%s'"), input);
return 0;
}
if(g_file_test(filename, G_FILE_TEST_IS_DIR))
{
// import a directory into a film roll
unsigned int last_char = strlen(filename)-1;
if(filename[last_char] == '/')
filename[last_char] = '\0';
id = dt_film_import(filename);
if(id)
{
dt_film_open(id);
dt_ctl_switch_mode_to(DT_LIBRARY);
}
else
{
dt_control_log(_("error loading directory `%s'"), filename);
}
}
else
{
// import a single image
gchar *directory = g_path_get_dirname((const gchar *)filename);
dt_film_t film;
const int filmid = dt_film_new(&film, directory);
id = dt_image_import(filmid, filename, TRUE);
g_free (directory);
if(id)
{
dt_film_open(filmid);
// make sure buffers are loaded (load full for testing)
dt_mipmap_buffer_t buf;
dt_mipmap_cache_read_get(darktable.mipmap_cache, &buf, id, DT_MIPMAP_FULL, DT_MIPMAP_BLOCKING);
if(!buf.buf)
{
id = 0;
dt_control_log(_("file `%s' has unknown format!"), filename);
}
else
{
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
if(open_image_in_dr)
{
dt_control_set_mouse_over_id(id);
dt_ctl_switch_mode_to(DT_DEVELOP);
}
}
}
else
{
dt_control_log(_("error loading file `%s'"), filename);
}
}
g_free(filename);
return id;
}
static void _lib_import_single_image_callback(GtkWidget *widget, gpointer user_data)
{
GtkWidget *win = dt_ui_main_window(darktable.gui->ui);
GtkWidget *filechooser = gtk_file_chooser_dialog_new(
_("import image"), GTK_WINDOW(win), GTK_FILE_CHOOSER_ACTION_OPEN, _("_Cancel"), GTK_RESPONSE_CANCEL,
_("_Open"), GTK_RESPONSE_ACCEPT, (char *)NULL);
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(filechooser), TRUE);
char *last_directory = dt_conf_get_string("ui_last/import_last_directory");
if(last_directory != NULL)
{
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(filechooser), last_directory);
g_free(last_directory);
}
char *cp, **extensions, ext[1024];
GtkFileFilter *filter;
filter = GTK_FILE_FILTER(gtk_file_filter_new());
extensions = g_strsplit(dt_supported_extensions, ",", 100);
for(char **i = extensions; *i != NULL; i++)
{
snprintf(ext, sizeof(ext), "*.%s", *i);
gtk_file_filter_add_pattern(filter, ext);
gtk_file_filter_add_pattern(filter, cp = g_ascii_strup(ext, -1));
g_free(cp);
}
g_strfreev(extensions);
gtk_file_filter_set_name(filter, _("supported images"));
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filechooser), filter);
filter = GTK_FILE_FILTER(gtk_file_filter_new());
gtk_file_filter_add_pattern(filter, "*");
gtk_file_filter_set_name(filter, _("all files"));
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filechooser), filter);
GtkWidget *preview = gtk_image_new();
gtk_file_chooser_set_preview_widget(GTK_FILE_CHOOSER(filechooser), preview);
g_signal_connect(filechooser, "update-preview", G_CALLBACK(_lib_import_update_preview), preview);
dt_lib_import_metadata_t metadata;
gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(filechooser),
_lib_import_get_extra_widget(&metadata, FALSE));
if(gtk_dialog_run(GTK_DIALOG(filechooser)) == GTK_RESPONSE_ACCEPT)
{
dt_conf_set_string("ui_last/import_last_directory",
gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(filechooser)));
_lib_import_evaluate_extra_widget(&metadata, FALSE);
char *filename = NULL;
dt_film_t film;
GSList *list = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(filechooser));
GSList *it = list;
int id = 0;
int filmid = 0;
/* reset filter so that view isn't empty */
dt_view_filter_reset(darktable.view_manager, TRUE);
while(it)
{
filename = (char *)it->data;
gchar *directory = g_path_get_dirname((const gchar *)filename);
filmid = dt_film_new(&film, directory);
id = dt_image_import(filmid, filename, TRUE);
if(!id) dt_control_log(_("error loading file `%s'"), filename);
g_free(filename);
g_free(directory);
it = g_slist_next(it);
}
if(id)
{
dt_film_open(filmid);
// make sure buffers are loaded (load full for testing)
dt_mipmap_buffer_t buf;
dt_mipmap_cache_get(darktable.mipmap_cache, &buf, id, DT_MIPMAP_FULL, DT_MIPMAP_BLOCKING, 'r');
gboolean loaded = (buf.buf != NULL);
dt_mipmap_cache_release(darktable.mipmap_cache, &buf);
if(!loaded)
{
dt_control_log(_("file has unknown format!"));
}
else
{
dt_control_set_mouse_over_id(id);
dt_ctl_switch_mode_to(DT_DEVELOP);
}
}
}
gtk_widget_destroy(metadata.frame);
gtk_widget_destroy(filechooser);
gtk_widget_queue_draw(dt_ui_center(darktable.gui->ui));
}
void _capture_view_set_jobcode(const dt_view_t *view, const char *name)
{
g_assert( view != NULL );
dt_capture_t *cv=(dt_capture_t *)view->data;
/* take care of previous capture filmroll */
if( cv->film )
{
if( dt_film_is_empty(cv->film->id) )
dt_film_remove(cv->film->id );
else
dt_film_cleanup( cv->film );
}
/* lets initialize a new filmroll for the capture... */
cv->film = (dt_film_t*)malloc(sizeof(dt_film_t));
if(!cv->film) return;
dt_film_init(cv->film);
int current_filmroll = dt_conf_get_int("plugins/capture/current_filmroll");
if(current_filmroll >= 0)
{
/* open existing filmroll and import captured images into this roll */
cv->film->id = current_filmroll;
if (dt_film_open2 (cv->film) !=0)
{
/* failed to open the current filmroll, let's reset and create a new one */
dt_conf_set_int ("plugins/capture/current_filmroll",-1);
}
else
cv->path = g_strdup(cv->film->dirname);
}
if (dt_conf_get_int ("plugins/capture/current_filmroll") == -1)
{
if(cv->jobcode)
g_free(cv->jobcode);
cv->jobcode = g_strdup(name);
// Setup variables jobcode...
cv->vp->jobcode = cv->jobcode;
/* reset session sequence number */
dt_variables_reset_sequence (cv->vp);
// Construct the directory for filmroll...
gchar* path = g_build_path(G_DIR_SEPARATOR_S,cv->basedirectory,cv->subdirectory, (char *)NULL);
cv->path = dt_util_fix_path(path);
g_free(path);
dt_variables_expand( cv->vp, cv->path, FALSE );
sprintf(cv->film->dirname,"%s",dt_variables_get_result(cv->vp));
// Create recursive directories, abort if no access
if( g_mkdir_with_parents(cv->film->dirname,0755) == -1 )
{
dt_control_log(_("failed to create session path %s."), cv->film->dirname);
if(cv->film)
{
free( cv->film );
cv->film = NULL;
}
return;
}
if(dt_film_new(cv->film,cv->film->dirname) > 0)
{
// Switch to new filmroll
dt_film_open(cv->film->id);
/* store current filmroll */
dt_conf_set_int("plugins/capture/current_filmroll",cv->film->id);
}
dt_control_log(_("new session initiated '%s'"),cv->jobcode,cv->film->id);
}
}
int32_t dt_camera_import_job_run(dt_job_t *job)
{
dt_camera_import_t *t = (dt_camera_import_t *)job->param;
dt_control_log(_("starting to import images from camera"));
// Setup a new filmroll to import images to....
t->film=(dt_film_t*)g_malloc(sizeof(dt_film_t));
dt_film_init(t->film);
gchar* fixed_path = dt_util_fix_path(t->path);
g_free(t->path);
t->path = fixed_path;
dt_variables_expand( t->vp, t->path, FALSE );
sprintf(t->film->dirname,"%s",dt_variables_get_result(t->vp));
dt_pthread_mutex_lock(&t->film->images_mutex);
t->film->ref++;
dt_pthread_mutex_unlock(&t->film->images_mutex);
// Create recursive directories, abort if no access
if( g_mkdir_with_parents(t->film->dirname,0755) == -1 )
{
dt_control_log(_("failed to create import path `%s', import aborted."), t->film->dirname);
return 1;
}
// Import path is ok, lets actually create the filmroll in database..
if(dt_film_new(t->film,t->film->dirname) > 0)
{
int total = g_list_length( t->images );
char message[512]= {0};
sprintf(message, ngettext ("importing %d image from camera", "importing %d images from camera", total), total );
t->bgj = dt_control_backgroundjobs_create(darktable.control, 0, message);
// Switch to new filmroll
dt_film_open(t->film->id);
dt_ctl_switch_mode_to(DT_LIBRARY);
// register listener
dt_camctl_listener_t listener= {0};
listener.data=t;
listener.image_downloaded=_camera_image_downloaded;
listener.request_image_path=_camera_import_request_image_path;
listener.request_image_filename=_camera_import_request_image_filename;
// start download of images
dt_camctl_register_listener(darktable.camctl,&listener);
dt_camctl_import(darktable.camctl,t->camera,t->images,dt_conf_get_bool("plugins/capture/camera/import/delete_originals"));
dt_camctl_unregister_listener(darktable.camctl,&listener);
dt_control_backgroundjobs_destroy(darktable.control, t->bgj);
dt_variables_params_destroy(t->vp);
}
else
dt_control_log(_("failed to create filmroll for camera import, import aborted."));
dt_pthread_mutex_lock(&t->film->images_mutex);
t->film->ref--;
dt_pthread_mutex_unlock(&t->film->images_mutex);
return 0;
}
static void _lib_import_single_image_callback(GtkWidget *widget,gpointer user_data)
{
GtkWidget *win = dt_ui_main_window(darktable.gui->ui);
GtkWidget *filechooser = gtk_file_chooser_dialog_new (_("import image"),
GTK_WINDOW (win),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
(char *)NULL);
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(filechooser), TRUE);
char *last_directory = dt_conf_get_string("ui_last/import_last_directory");
if(last_directory != NULL)
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (filechooser), last_directory);
char *cp, **extensions, ext[1024];
GtkFileFilter *filter;
filter = GTK_FILE_FILTER(gtk_file_filter_new());
extensions = g_strsplit(dt_supported_extensions, ",", 100);
for(char **i=extensions; *i!=NULL; i++)
{
snprintf(ext, 1024, "*.%s", *i);
gtk_file_filter_add_pattern(filter, ext);
gtk_file_filter_add_pattern(filter, cp=g_ascii_strup(ext, -1));
g_free(cp);
}
g_strfreev(extensions);
gtk_file_filter_set_name(filter, _("supported images"));
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filechooser), filter);
filter = GTK_FILE_FILTER(gtk_file_filter_new());
gtk_file_filter_add_pattern(filter, "*");
gtk_file_filter_set_name(filter, _("all files"));
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filechooser), filter);
if (gtk_dialog_run (GTK_DIALOG (filechooser)) == GTK_RESPONSE_ACCEPT)
{
dt_conf_set_string("ui_last/import_last_directory", gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER (filechooser)));
char *filename = NULL;
dt_film_t film;
GSList *list = gtk_file_chooser_get_filenames (GTK_FILE_CHOOSER (filechooser));
GSList *it = list;
int id = 0;
int filmid = 0;
while(it)
{
filename = (char *)it->data;
gchar *directory = g_path_get_dirname((const gchar *)filename);
filmid = dt_film_new(&film, directory);
id = dt_image_import(filmid, filename, TRUE);
if(!id) dt_control_log(_("error loading file `%s'"), filename);
g_free (filename);
g_free (directory);
it = g_slist_next(it);
}
if(id)
{
dt_film_open(filmid);
// make sure buffers are loaded (load full for testing)
dt_mipmap_buffer_t buf;
dt_mipmap_cache_read_get(darktable.mipmap_cache, &buf, id, DT_MIPMAP_FULL, DT_MIPMAP_BLOCKING);
if(!buf.buf)
{
dt_control_log(_("file has unknown format!"));
}
else
{
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
DT_CTL_SET_GLOBAL(lib_image_mouse_over_id, id);
dt_ctl_switch_mode_to(DT_DEVELOP);
}
}
}
gtk_widget_destroy (filechooser);
gtk_widget_queue_draw(dt_ui_center(darktable.gui->ui));
}
