void dt_film_set_query(const int32_t id)
{
/* enable film id filter and set film id */
dt_conf_set_int("plugins/lighttable/collect/num_rules", 1);
dt_conf_set_int("plugins/lighttable/collect/item0", 0);
sqlite3_stmt *stmt;
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db),
"SELECT id, folder FROM main.film_rolls WHERE id = ?1", -1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, id);
if(sqlite3_step(stmt) == SQLITE_ROW)
{
dt_conf_set_string("plugins/lighttable/collect/string0", (gchar *)sqlite3_column_text(stmt, 1));
}
sqlite3_finalize(stmt);
dt_collection_update_query(darktable.collection);
}
static void
menuitem_and (GtkMenuItem *menuitem, dt_lib_collect_rule_t *d)
{
// add next row with and operator
const int active = CLAMP(dt_conf_get_int("plugins/lighttable/collect/num_rules"), 1, MAX_RULES);
if(active < 10)
{
char confname[200];
snprintf(confname, 200, "plugins/lighttable/collect/mode%1d", active);
dt_conf_set_int(confname, DT_LIB_COLLECT_MODE_AND);
snprintf(confname, 200, "plugins/lighttable/collect/string%1d", active);
dt_conf_set_string(confname, "");
dt_conf_set_int("plugins/lighttable/collect/num_rules", active+1);
dt_lib_collect_t *c = get_collect(d);
c->active_rule = active;
}
dt_collection_update_query(darktable.collection);
}
static void export_button_clicked(GtkButton *button, gpointer user_data)
{
GDateTime *now = g_date_time_new_now_local();
char *export_filename = g_date_time_format(now, "darktable_tags_%F_%R.txt");
char *last_dirname = dt_conf_get_string("plugins/lighttable/tagging/last_import_export_location");
if(!last_dirname || !*last_dirname)
{
g_free(last_dirname);
last_dirname = g_strdup(g_get_home_dir());
}
GtkWidget *win = dt_ui_main_window(darktable.gui->ui);
GtkWidget *filechooser = gtk_file_chooser_dialog_new(_("Select file to export to"), GTK_WINDOW(win),
GTK_FILE_CHOOSER_ACTION_SAVE,
_("_cancel"), GTK_RESPONSE_CANCEL,
_("_export"), GTK_RESPONSE_ACCEPT, (char *)NULL);
gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(filechooser), TRUE);
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(filechooser), last_dirname);
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(filechooser), export_filename);
if(gtk_dialog_run(GTK_DIALOG(filechooser)) == GTK_RESPONSE_ACCEPT)
{
char *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(filechooser));
char *dirname = g_path_get_dirname(filename);
dt_conf_set_string("plugins/lighttable/tagging/last_import_export_location", dirname);
ssize_t count = dt_tag_export(filename);
if(count < 0)
dt_control_log(_("error exporting tags"));
else
dt_control_log(_("%zd tags exported"), count);
g_free(filename);
g_free(dirname);
}
g_date_time_unref(now);
g_free(last_dirname);
g_free(export_filename);
gtk_widget_destroy(filechooser);
}
static void _piwigo_authenticate(dt_storage_piwigo_gui_data_t *ui)
{
if(!ui->api) ui->api = _piwigo_ctx_init();
ui->api->server = g_strdup(gtk_entry_get_text(ui->server_entry));
ui->api->username = g_strdup(gtk_entry_get_text(ui->user_entry));
ui->api->password = g_strdup(gtk_entry_get_text(ui->pwd_entry));
_piwigo_api_authenticate(ui->api);
ui->api->authenticated = FALSE;
if(ui->api->response && !ui->api->error_occured)
{
ui->api->authenticated = TRUE;
gtk_widget_set_sensitive(GTK_WIDGET(ui->album_list), ui->api->authenticated);
if(ui->api->authenticated)
{
_piwigo_set_status(ui, _("authenticated"), "#7fe07f");
dt_conf_set_string("plugins/imageio/storage/export/piwigo/server", ui->api->server);
_piwigo_set_account(ui);
}
else
{
const gchar *errormessage = json_object_get_string_member(ui->api->response, "message");
fprintf(stderr, "[imageio_storage_piwigo] could not authenticate: `%s'!\n", errormessage);
_piwigo_set_status(ui, _("not authenticated"), "#e07f7f");
_piwigo_ctx_destroy(&ui->api);
}
}
else
{
_piwigo_set_status(ui, _("not authenticated, cannot reach server"), "#e07f7f");
_piwigo_ctx_destroy(&ui->api);
}
}
static void
_add_property_button_clicked (GtkWidget *widget, gpointer user_data)
{
dt_lib_camera_t *lib=(dt_lib_camera_t *)user_data;
const gchar *label = gtk_entry_get_text (GTK_ENTRY (lib->gui.plabel));
const gchar *property = gtk_entry_get_text (GTK_ENTRY (lib->gui.pname));
/* let's try to add property */
if ( label && property )
{
dt_lib_camera_property_t *prop = NULL;
if ((prop=_lib_property_add_new (lib, label,property)) != NULL)
{
GtkBox *hbox = GTK_BOX(gtk_hbox_new(FALSE, 0));
gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (prop->values), TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (prop->osd), FALSE, FALSE, 0);
gtk_box_pack_start (lib->gui.pvbox1, GTK_WIDGET (prop->label), TRUE, TRUE, 0);
gtk_box_pack_start (lib->gui.pvbox2, GTK_WIDGET (hbox), TRUE, TRUE, 0);
g_signal_connect (G_OBJECT (prop->osd), "clicked", G_CALLBACK (_osd_button_clicked), prop);
gchar key[256]= {"plugins/capture/tethering/properties/"};
g_strlcat(key, label, 256);
gchar *p = key;
while( p++<key+strlen(key) ) if(*p==' ') *p='_';
dt_conf_set_string(key,property);
/* clean entries */
gtk_entry_set_text (GTK_ENTRY (lib->gui.plabel),"");
gtk_entry_set_text (GTK_ENTRY (lib->gui.pname),"");
gtk_widget_show_all (GTK_WIDGET (prop->label));
gtk_widget_show_all (GTK_WIDGET (hbox));
}
}
}
void dt_configure_defaults()
{
const int atom_cores = dt_get_num_atom_cores();
const int threads = dt_get_num_threads();
const size_t mem = dt_get_total_memory();
const int bits = (sizeof(void *) == 4) ? 32 : 64;
fprintf(stderr, "[defaults] found a %d-bit system with %zu kb ram and %d cores (%d atom based)\n", bits,
mem, threads, atom_cores);
if(mem > (2u << 20) && threads > 4)
{
fprintf(stderr, "[defaults] setting high quality defaults\n");
dt_conf_set_int("worker_threads", 8);
dt_conf_set_bool("plugins/lighttable/low_quality_thumbnails", FALSE);
}
if(mem < (1u << 20) || threads <= 2 || bits < 64 || atom_cores > 0)
{
fprintf(stderr, "[defaults] setting very conservative defaults\n");
dt_conf_set_int("worker_threads", 1);
dt_conf_set_int("host_memory_limit", 500);
dt_conf_set_int("singlebuffer_limit", 8);
dt_conf_set_string("plugins/darkroom/demosaic/quality", "always bilinear (fast)");
dt_conf_set_bool("plugins/lighttable/low_quality_thumbnails", TRUE);
}
}
static void
set_format_by_name (dt_lib_export_t *d, const char *name)
{
// Find the selected format plugin among all existing plugins
dt_imageio_module_format_t *module = NULL;
GList *it = g_list_first(darktable.imageio->plugins_format);
if( it != NULL )
do
{
if( strcmp( ((dt_imageio_module_format_t *)it->data)->name(),name) == 0 ||
strcmp( ((dt_imageio_module_format_t *)it->data)->plugin_name,name) == 0)
{
module = (dt_imageio_module_format_t*)it->data;
break;
}
}
while( ( it = g_list_next(it) ) );
if(!module) return;
// Store the new format
dt_conf_set_string("plugins/lighttable/export/format_name", module->plugin_name);
GtkWidget *old = gtk_bin_get_child(GTK_BIN(d->format_box));
if(old != module->widget)
{
if(old) gtk_container_remove(d->format_box, old);
if(module->widget) gtk_container_add(d->format_box, module->widget);
}
gtk_widget_show_all(GTK_WIDGET(d->format_box));
if(!darktable.gui->reset && _combo_box_set_active_text( d->format, module->name() ) == FALSE )
gtk_combo_box_set_active( d->format, 0);
// Let's also update combination of storage/format dimension restrictions
_update_dimensions( d );
}
static void _lib_geotagging_gpx_callback(GtkWidget *widget, dt_lib_module_t *self)
{
dt_lib_geotagging_t *d = (dt_lib_geotagging_t *)self->data;
/* bring a filechooser to select the gpx file to apply to selection */
GtkWidget *win = dt_ui_main_window(darktable.gui->ui);
GtkWidget *filechooser = gtk_file_chooser_dialog_new(
_("open GPX file"), GTK_WINDOW(win), GTK_FILE_CHOOSER_ACTION_OPEN, _("_cancel"), GTK_RESPONSE_CANCEL,
_("_open"), GTK_RESPONSE_ACCEPT, (char *)NULL);
char *last_directory = dt_conf_get_string("ui_last/gpx_last_directory");
if(last_directory != NULL)
{
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(filechooser), last_directory);
g_free(last_directory);
}
GtkFileFilter *filter;
filter = GTK_FILE_FILTER(gtk_file_filter_new());
gtk_file_filter_add_custom(filter, GTK_FILE_FILTER_FILENAME | GTK_FILE_FILTER_MIME_TYPE,
_lib_geotagging_filter_gpx, NULL, NULL);
gtk_file_filter_set_name(filter, _("GPS data exchange format"));
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);
// add time zone selection
GtkWidget *extra_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
GtkWidget *label = gtk_label_new(_("camera time zone"));
gtk_widget_set_tooltip_text(label, _("most cameras don't store the time zone in EXIF. "
"give the correct time zone so the GPX data can be correctly matched"));
GtkWidget *tz_selection = gtk_combo_box_text_new();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(tz_selection), "UTC");
gtk_combo_box_set_active(GTK_COMBO_BOX(tz_selection), 0);
GList *iter = d->timezones;
int i = 0;
gchar *old_tz = dt_conf_get_string("plugins/lighttable/geotagging/tz");
if(iter)
{
do
{
i++;
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(tz_selection), (gchar *)iter->data);
if(!strcmp((gchar *)iter->data, old_tz)) gtk_combo_box_set_active(GTK_COMBO_BOX(tz_selection), i);
} while((iter = g_list_next(iter)) != NULL);
}
g_free(old_tz);
gtk_box_pack_start(GTK_BOX(extra_box), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(extra_box), tz_selection, FALSE, FALSE, 0);
gtk_widget_show_all(extra_box);
gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(filechooser), extra_box);
if(gtk_dialog_run(GTK_DIALOG(filechooser)) == GTK_RESPONSE_ACCEPT)
{
gchar *folder = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(filechooser));
dt_conf_set_string("ui_last/gpx_last_directory", folder);
g_free(folder);
gchar *tz = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(tz_selection));
dt_conf_set_string("plugins/lighttable/geotagging/tz", tz);
gchar *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(filechooser));
dt_control_gpx_apply(filename, -1, tz);
g_free(filename);
g_free(tz);
}
gtk_widget_destroy(extra_box);
gtk_widget_destroy(filechooser);
// dt_control_queue_redraw_center();
}
static gboolean _lib_geotagging_offset_key_press(GtkWidget *entry, GdkEventKey *event, dt_lib_module_t *self)
{
dt_lib_geotagging_t *d = (dt_lib_geotagging_t *)self->data;
switch(event->keyval)
{
case GDK_KEY_Escape:
case GDK_KEY_Tab:
{
// reset
gchar *str = dt_conf_get_string("plugins/lighttable/geotagging/offset");
if(_lib_geotagging_parse_offset(str, NULL))
{
gtk_entry_set_text(GTK_ENTRY(d->offset_entry), str);
}
else
{
gtk_entry_set_text(GTK_ENTRY(d->offset_entry), "+00:00:00");
dt_conf_set_string("plugins/lighttable/geotagging/offset", "+00:00:00");
}
g_free(str);
gtk_window_set_focus(GTK_WINDOW(dt_ui_main_window(darktable.gui->ui)), NULL);
return FALSE;
}
case GDK_KEY_Return:
case GDK_KEY_KP_Enter:
{
const gchar *value = gtk_entry_get_text(GTK_ENTRY(d->offset_entry));
if(_lib_geotagging_parse_offset(value, NULL))
{
dt_conf_set_string("plugins/lighttable/geotagging/offset", value);
}
else
{
gtk_entry_set_text(GTK_ENTRY(d->offset_entry), "+00:00:00");
dt_conf_set_string("plugins/lighttable/geotagging/offset", "+00:00:00");
}
gtk_window_set_focus(GTK_WINDOW(dt_ui_main_window(darktable.gui->ui)), NULL);
return FALSE;
}
// allow +, -, :, 0 .. 9, left/right/home/end movement using arrow keys and del/backspace
case GDK_KEY_plus:
case GDK_KEY_KP_Add:
case GDK_KEY_minus:
case GDK_KEY_KP_Subtract:
case GDK_KEY_colon:
case GDK_KEY_0:
case GDK_KEY_KP_0:
case GDK_KEY_1:
case GDK_KEY_KP_1:
case GDK_KEY_2:
case GDK_KEY_KP_2:
case GDK_KEY_3:
case GDK_KEY_KP_3:
case GDK_KEY_4:
case GDK_KEY_KP_4:
case GDK_KEY_5:
case GDK_KEY_KP_5:
case GDK_KEY_6:
case GDK_KEY_KP_6:
case GDK_KEY_7:
case GDK_KEY_KP_7:
case GDK_KEY_8:
case GDK_KEY_KP_8:
case GDK_KEY_9:
case GDK_KEY_KP_9:
case GDK_KEY_Left:
case GDK_KEY_Right:
case GDK_KEY_Home:
case GDK_KEY_KP_Home:
case GDK_KEY_End:
case GDK_KEY_KP_End:
case GDK_KEY_Delete:
case GDK_KEY_KP_Delete:
case GDK_KEY_BackSpace:
return FALSE;
default: // block everything else
return TRUE;
}
}
void gui_reset(dt_imageio_module_storage_t *self)
{
gallery_t *d = (gallery_t *)self->gui_data;
dt_conf_set_string("plugins/imageio/storage/gallery/file_directory", gtk_entry_get_text(d->entry));
dt_conf_set_string("plugins/imageio/storage/gallery/title", gtk_entry_get_text(d->title_entry));
}
static void title_changed_callback(GtkEntry *entry, gpointer user_data)
{
dt_conf_set_string("plugins/imageio/storage/gallery/title", gtk_entry_get_text(entry));
}
static void _lib_import_folder_callback(GtkWidget *widget, gpointer user_data)
{
GtkWidget *win = dt_ui_main_window(darktable.gui->ui);
GtkWidget *filechooser = gtk_file_chooser_dialog_new(
_("import film"), GTK_WINDOW(win), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, _("_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);
}
dt_lib_import_metadata_t metadata;
gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(filechooser),
_lib_import_get_extra_widget(&metadata, TRUE));
// run the dialog
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, TRUE);
char *filename = NULL, *first_filename = NULL;
GSList *list = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(filechooser));
GSList *it = list;
/* reset filter so that view isn't empty */
dt_view_filter_reset(darktable.view_manager, TRUE);
/* for each selected folder add import job */
while(it)
{
filename = (char *)it->data;
dt_film_import(filename);
if(!first_filename)
{
first_filename = g_strdup(filename);
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(metadata.recursive)))
first_filename = dt_util_dstrcat(first_filename, "%%");
}
g_free(filename);
it = g_slist_next(it);
}
/* update collection to view import */
if(first_filename)
{
dt_conf_set_int("plugins/lighttable/collect/num_rules", 1);
dt_conf_set_int("plugins/lighttable/collect/item0", 0);
dt_conf_set_string("plugins/lighttable/collect/string0", first_filename);
dt_collection_update_query(darktable.collection);
g_free(first_filename);
}
g_slist_free(list);
}
gtk_widget_destroy(metadata.frame);
gtk_widget_destroy(filechooser);
gtk_widget_queue_draw(dt_ui_center(darktable.gui->ui));
}
static void callback_string(GtkWidget *widget, pref_element*cur_elt )
{
char pref_name[1024];
get_pref_name(pref_name,1024,cur_elt->script,cur_elt->name);
dt_conf_set_string(pref_name,gtk_entry_get_text(GTK_ENTRY(widget)));
}
static gboolean
changed_callback (GtkEntry *entry, dt_lib_collect_rule_t *dr)
{
// update related list
dt_lib_collect_t *d = get_collect(dr);
sqlite3_stmt *stmt;
GtkTreeIter iter;
GtkTreeView *view = d->view;
GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
g_object_ref(model);
gtk_tree_view_set_model(GTK_TREE_VIEW(view), NULL);
gtk_list_store_clear(GTK_LIST_STORE(model));
char query[1024];
int property = gtk_combo_box_get_active(dr->combo);
const gchar *text = gtk_entry_get_text(GTK_ENTRY(dr->text));
gchar *escaped_text = dt_util_str_replace(text, "'", "''");
char confname[200];
snprintf(confname, 200, "plugins/lighttable/collect/string%1ld", dr->num);
dt_conf_set_string (confname, text);
snprintf(confname, 200, "plugins/lighttable/collect/item%1ld", dr->num);
dt_conf_set_int (confname, property);
switch(property)
{
case 0: // film roll
snprintf(query, 1024, "select distinct folder, id from film_rolls where folder like '%%%s%%' order by id DESC", escaped_text);
break;
case 1: // camera
snprintf(query, 1024, "select distinct maker || ' ' || model as model, 1 from images where maker || ' ' || model like '%%%s%%' order by model", escaped_text);
break;
case 2: // tag
snprintf(query, 1024, "SELECT distinct name, id FROM tags WHERE name LIKE '%%%s%%' ORDER BY UPPER(name)", escaped_text);
break;
case 4: // History, 2 hardcoded alternatives
gtk_list_store_append(GTK_LIST_STORE(model), &iter);
gtk_list_store_set (GTK_LIST_STORE(model), &iter,
DT_LIB_COLLECT_COL_TEXT,_("altered"),
DT_LIB_COLLECT_COL_ID, 0,
DT_LIB_COLLECT_COL_TOOLTIP,_("altered"),
-1);
gtk_list_store_append(GTK_LIST_STORE(model), &iter);
gtk_list_store_set (GTK_LIST_STORE(model), &iter,
DT_LIB_COLLECT_COL_TEXT,_("not altered"),
DT_LIB_COLLECT_COL_ID, 1,
DT_LIB_COLLECT_COL_TOOLTIP,_("not altered"),
-1);
goto entry_key_press_exit;
break;
case 5: // colorlabels
gtk_list_store_append(GTK_LIST_STORE(model), &iter);
gtk_list_store_set (GTK_LIST_STORE(model), &iter,
DT_LIB_COLLECT_COL_TEXT,_("red"),
DT_LIB_COLLECT_COL_ID, 0,
DT_LIB_COLLECT_COL_TOOLTIP, _("red"),
-1);
gtk_list_store_append(GTK_LIST_STORE(model), &iter);
gtk_list_store_set (GTK_LIST_STORE(model), &iter,
DT_LIB_COLLECT_COL_TEXT,_("yellow"),
DT_LIB_COLLECT_COL_ID, 1,
DT_LIB_COLLECT_COL_TOOLTIP, _("yellow"),
-1);
gtk_list_store_append(GTK_LIST_STORE(model), &iter);
gtk_list_store_set (GTK_LIST_STORE(model), &iter,
DT_LIB_COLLECT_COL_TEXT,_("green"),
DT_LIB_COLLECT_COL_ID, 2,
DT_LIB_COLLECT_COL_TOOLTIP, _("green"),
-1);
gtk_list_store_append(GTK_LIST_STORE(model), &iter);
gtk_list_store_set (GTK_LIST_STORE(model), &iter,
DT_LIB_COLLECT_COL_TEXT,_("blue"),
DT_LIB_COLLECT_COL_ID, 3,
DT_LIB_COLLECT_COL_TOOLTIP, _("blue"),
-1);
gtk_list_store_append(GTK_LIST_STORE(model), &iter);
gtk_list_store_set (GTK_LIST_STORE(model), &iter,
DT_LIB_COLLECT_COL_TEXT,_("purple"),
DT_LIB_COLLECT_COL_ID, 4,
DT_LIB_COLLECT_COL_TOOLTIP, _("purple"),
-1);
goto entry_key_press_exit;
break;
// TODO: Add empty string for metadata?
// TODO: Autogenerate this code?
case 6: // title
snprintf(query, 1024, "select distinct value, 1 from meta_data where key = %d and value like '%%%s%%' order by value",
DT_METADATA_XMP_DC_TITLE, escaped_text);
break;
case 7: // description
snprintf(query, 1024, "select distinct value, 1 from meta_data where key = %d and value like '%%%s%%' order by value",
DT_METADATA_XMP_DC_DESCRIPTION, escaped_text);
break;
case 8: // creator
snprintf(query, 1024, "select distinct value, 1 from meta_data where key = %d and value like '%%%s%%' order by value",
DT_METADATA_XMP_DC_CREATOR, escaped_text);
break;
case 9: // publisher
snprintf(query, 1024, "select distinct value, 1 from meta_data where key = %d and value like '%%%s%%' order by value",
DT_METADATA_XMP_DC_PUBLISHER, escaped_text);
break;
case 10: // rights
snprintf(query, 1024, "select distinct value, 1 from meta_data where key = %d and value like '%%%s%%'order by value ",
DT_METADATA_XMP_DC_RIGHTS, escaped_text);
break;
case 11: // lens
snprintf(query, 1024, "select distinct lens, 1 from images where lens like '%%%s%%' order by lens", escaped_text);
break;
case 12: // iso
snprintf(query, 1024, "select distinct cast(iso as integer) as iso, 1 from images where iso like '%%%s%%' order by iso", escaped_text);
break;
case 13: // aperature
snprintf(query, 1024, "select distinct round(aperture,1) as aperture, 1 from images where aperture like '%%%s%%' order by aperture", escaped_text);
break;
case 14: // filename
snprintf(query, 1024, "select distinct filename, 1 from images where filename like '%%%s%%' order by filename", escaped_text);
break;
default: // case 3: // day
snprintf(query, 1024, "SELECT DISTINCT datetime_taken, 1 FROM images WHERE datetime_taken LIKE '%%%s%%' ORDER BY datetime_taken DESC", escaped_text);
break;
}
g_free(escaped_text);
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), query, -1, &stmt, NULL);
while(sqlite3_step(stmt) == SQLITE_ROW)
{
gtk_list_store_append(GTK_LIST_STORE(model), &iter);
const char *folder = (const char*)sqlite3_column_text(stmt, 0);
if(property == 0) // film roll
{
folder = dt_image_film_roll_name(folder);
}
gchar *value = (gchar *)sqlite3_column_text(stmt, 0);
gchar *escaped_text = g_markup_escape_text(value, strlen(value));
gtk_list_store_set (GTK_LIST_STORE(model), &iter,
DT_LIB_COLLECT_COL_TEXT, folder,
DT_LIB_COLLECT_COL_ID, sqlite3_column_int(stmt, 1),
DT_LIB_COLLECT_COL_TOOLTIP, escaped_text,
DT_LIB_COLLECT_COL_PATH, value,
-1);
}
sqlite3_finalize(stmt);
entry_key_press_exit:
gtk_tree_view_set_tooltip_column(GTK_TREE_VIEW(view), DT_LIB_COLLECT_COL_TOOLTIP);
gtk_tree_view_set_model(GTK_TREE_VIEW(view), model);
g_object_unref(model);
return FALSE;
}
void init(dt_view_t *self)
{
self->data = malloc(sizeof(dt_map_t));
memset(self->data,0,sizeof(dt_map_t));
dt_map_t *lib = (dt_map_t *)self->data;
OsmGpsMapSource_t map_source = OSM_GPS_MAP_SOURCE_OPENSTREETMAP;
const gchar *old_map_source = dt_conf_get_string("plugins/map/map_source");
if(old_map_source && old_map_source[0] != '\0')
{
// find the number of the stored map_source
for(int i=0; i<=OSM_GPS_MAP_SOURCE_LAST; i++)
{
const gchar *new_map_source = osm_gps_map_source_get_friendly_name(i);
if(!g_strcmp0(old_map_source, new_map_source))
{
if(osm_gps_map_source_is_valid(i))
map_source = i;
break;
}
}
}
else // open street map should be a nice default ...
dt_conf_set_string("plugins/map/map_source", osm_gps_map_source_get_friendly_name(OSM_GPS_MAP_SOURCE_OPENSTREETMAP));
lib->map = g_object_new (OSM_TYPE_GPS_MAP,
"map-source", map_source,
"proxy-uri",g_getenv("http_proxy"),
NULL);
GtkWidget *parent = gtk_widget_get_parent(dt_ui_center(darktable.gui->ui));
gtk_box_pack_start(GTK_BOX(parent), GTK_WIDGET(lib->map) ,TRUE, TRUE, 0);
lib->osd = g_object_new (OSM_TYPE_GPS_MAP_OSD,
"show-scale",TRUE, "show-coordinates",TRUE, "show-dpad",TRUE, "show-zoom",TRUE, NULL);
if(dt_conf_get_bool("plugins/map/show_map_osd"))
{
osm_gps_map_layer_add(OSM_GPS_MAP(lib->map), lib->osd);
}
/* build the query string */
int max_images_drawn = dt_conf_get_int("plugins/map/max_images_drawn");
if(max_images_drawn == 0)
max_images_drawn = 100;
char *geo_query = g_strdup_printf("select * from (select id from images where \
longitude >= ?1 and longitude <= ?2 and latitude <= ?3 and latitude >= ?4 \
and longitude not NULL and latitude not NULL order by abs(latitude - ?5), abs(longitude - ?6) \
limit 0, %d) order by id", max_images_drawn);
/* prepare the main query statement */
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), geo_query, -1, &lib->statements.main_query, NULL);
g_free(geo_query);
/* allow drag&drop of images from filmstrip */
gtk_drag_dest_set(GTK_WIDGET(lib->map), GTK_DEST_DEFAULT_ALL, target_list_internal, n_targets_internal, GDK_ACTION_COPY);
g_signal_connect(GTK_WIDGET(lib->map), "drag-data-received", G_CALLBACK(drag_and_drop_received), self);
g_signal_connect(GTK_WIDGET(lib->map), "changed", G_CALLBACK(_view_map_changed_callback), self);
g_signal_connect(G_OBJECT(lib->map), "button-press-event", G_CALLBACK(_view_map_button_press_callback), self);
g_signal_connect (G_OBJECT(lib->map), "motion-notify-event", G_CALLBACK(_view_map_motion_notify_callback), self);
/* allow drag&drop of images from the map, too */
g_signal_connect(GTK_WIDGET(lib->map), "drag-data-get", G_CALLBACK(_view_map_dnd_get_callback), self);
g_signal_connect(GTK_WIDGET(lib->map), "drag-failed", G_CALLBACK(_view_map_dnd_failed_callback), self);
}
/** Initializes a new pwstorage context. */
const dt_pwstorage_t* dt_pwstorage_new()
{
dt_pwstorage_t *pwstorage = g_malloc(sizeof(dt_pwstorage_t));
dt_print(DT_DEBUG_PWSTORAGE,"[pwstorage_new] Creating new context %p\n", pwstorage);
if(pwstorage == NULL)
return NULL;
gchar* _backend_str = dt_conf_get_string( "plugins/pwstorage/pwstorage_backend" );
gint _backend = -1;
if (strcmp(_backend_str, "auto") == 0)
{
const gchar *desktop = getenv("XDG_CURRENT_DESKTOP");
if (g_strcmp0(desktop, "KDE") == 0)
_backend = PW_STORAGE_BACKEND_KWALLET;
else if (g_strcmp0(desktop, "GNOME") == 0)
_backend = PW_STORAGE_BACKEND_GNOME_KEYRING;
else if (g_strcmp0(desktop, "Unity") == 0)
_backend = PW_STORAGE_BACKEND_GNOME_KEYRING;
else if (g_strcmp0(desktop, "XFCE") == 0)
_backend = PW_STORAGE_BACKEND_GNOME_KEYRING;
else
_backend = PW_STORAGE_BACKEND_NONE;
dt_print(DT_DEBUG_PWSTORAGE,"[pwstorage_new] autodetected storage backend.\n");
}
else if(strcmp(_backend_str, "none") == 0)
_backend = PW_STORAGE_BACKEND_NONE;
else if(strcmp(_backend_str, "kwallet") == 0)
_backend = PW_STORAGE_BACKEND_KWALLET;
else if(strcmp(_backend_str, "gnome keyring") == 0)
_backend = PW_STORAGE_BACKEND_GNOME_KEYRING;
g_free(_backend_str);
switch(_backend)
{
default:
dt_print(DT_DEBUG_PWSTORAGE,"[pwstorage_new] unknown storage backend. Using none.\n");
case PW_STORAGE_BACKEND_NONE:
pwstorage->pw_storage_backend = PW_STORAGE_BACKEND_NONE;
pwstorage->backend_context = NULL;
dt_print(DT_DEBUG_PWSTORAGE,"[pwstorage_new] no storage backend. not storing username/password. please change in preferences, core tab.\n");
break;
case PW_STORAGE_BACKEND_KWALLET:
dt_print(DT_DEBUG_PWSTORAGE,"[pwstorage_new] using kwallet backend for username/password storage");
pwstorage->backend_context = (void*)dt_pwstorage_kwallet_new();
if(pwstorage->backend_context == NULL)
{
dt_print(DT_DEBUG_PWSTORAGE,"[pwstorage_new] error starting kwallet. using no storage backend.\n");
pwstorage->backend_context = NULL;
pwstorage->pw_storage_backend = PW_STORAGE_BACKEND_NONE;
}
else
{
pwstorage->pw_storage_backend = PW_STORAGE_BACKEND_KWALLET;
}
dt_print(DT_DEBUG_PWSTORAGE," done.\n");
break;
#ifdef HAVE_GKEYRING
case PW_STORAGE_BACKEND_GNOME_KEYRING:
dt_print (DT_DEBUG_PWSTORAGE,"[pwstorage_new] using gnome keyring backend for usersname/password storage.\n");
pwstorage->backend_context = (void*)dt_pwstorage_gkeyring_new ();
if (pwstorage->backend_context == NULL)
{
dt_print (DT_DEBUG_PWSTORAGE,"[pwstorage_new] error starting gnome keyring. using no storage backend.\n");
pwstorage->backend_context = NULL;
pwstorage->pw_storage_backend = PW_STORAGE_BACKEND_NONE;
}
else
pwstorage->pw_storage_backend = PW_STORAGE_BACKEND_GNOME_KEYRING;
#else
dt_print(DT_DEBUG_PWSTORAGE,"[pwstorage_new] gnome keyring storage not available. using no storage backend.\n");
pwstorage->backend_context = NULL;
pwstorage->pw_storage_backend = PW_STORAGE_BACKEND_NONE;
#endif
break;
}
switch(pwstorage->pw_storage_backend)
{
case PW_STORAGE_BACKEND_NONE:
dt_conf_set_string( "plugins/pwstorage/pwstorage_backend", "none" );
break;
case PW_STORAGE_BACKEND_KWALLET:
dt_conf_set_string( "plugins/pwstorage/pwstorage_backend", "kwallet" );
break;
case PW_STORAGE_BACKEND_GNOME_KEYRING:
dt_conf_set_string( "plugins/pwstorage/pwstorage_backend", "gnome keyring" );
break;
}
return pwstorage;
}
void leave(dt_view_t *self)
{
/* disconnect from filmstrip image activate */
dt_control_signal_disconnect(darktable.signals,
G_CALLBACK(_view_darkroom_filmstrip_activate_callback),
(gpointer)self);
/* disconnect from pipe finish signal */
dt_control_signal_disconnect(darktable.signals,
G_CALLBACK(_darkroom_ui_pipe_finish_signal_callback),
(gpointer)self);
// store groups for next time:
dt_conf_set_int("plugins/darkroom/groups", dt_dev_modulegroups_get(darktable.develop));
// store last active plugin:
if(darktable.develop->gui_module)
dt_conf_set_string("plugins/darkroom/active", darktable.develop->gui_module->op);
else
dt_conf_set_string("plugins/darkroom/active", "");
dt_develop_t *dev = (dt_develop_t *)self->data;
// tag image as changed
// TODO: only tag the image when there was a real change.
guint tagid = 0;
dt_tag_new("darktable|changed",&tagid);
dt_tag_attach(tagid, dev->image_storage.id);
// commit image ops to db
dt_dev_write_history(dev);
// be sure light table will regenerate the thumbnail:
// TODO: only if changed!
// if()
{
dt_mipmap_cache_remove(darktable.mipmap_cache, dev->image_storage.id);
// dump new xmp data
dt_image_synch_xmp(dev->image_storage.id);
}
// clear gui.
dev->gui_leaving = 1;
dt_pthread_mutex_lock(&dev->history_mutex);
dt_dev_pixelpipe_cleanup_nodes(dev->pipe);
dt_dev_pixelpipe_cleanup_nodes(dev->preview_pipe);
while(dev->history)
{
dt_dev_history_item_t *hist = (dt_dev_history_item_t *)(dev->history->data);
// printf("removing history item %d - %s, data %f %f\n", hist->module->instance, hist->module->op, *(float *)hist->params, *((float *)hist->params+1));
free(hist->params);
hist->params = NULL;
free(hist);
dev->history = g_list_delete_link(dev->history, dev->history);
}
while(dev->iop)
{
dt_iop_module_t *module = (dt_iop_module_t *)(dev->iop->data);
if (!dt_iop_is_hidden(module))
dt_iop_gui_cleanup_module(module);
dt_dev_cleanup_module_accels(module);
module->accel_closures = NULL;
dt_iop_cleanup_module(module) ;
free(module);
dev->iop = g_list_delete_link(dev->iop, dev->iop);
}
dt_pthread_mutex_unlock(&dev->history_mutex);
dt_print(DT_DEBUG_CONTROL, "[run_job-] 11 %f in darkroom mode\n", dt_get_wtime());
}
static void entry_changed_callback(GtkEntry *entry, gpointer user_data)
{
dt_conf_set_string("plugins/imageio/storage/latex/file_directory", gtk_entry_get_text(entry));
}
static void
_lib_geolocation_gpx_callback(GtkWidget *widget, dt_lib_module_t *self)
{
dt_lib_geolocation_t *d = (dt_lib_geolocation_t*)self->data;
/* bring a filechooser to select the gpx file to apply to selection */
GtkWidget *win = dt_ui_main_window(darktable.gui->ui);
GtkWidget *filechooser = gtk_file_chooser_dialog_new(_("open gpx file"),
GTK_WINDOW (win),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
(char *)NULL);
GtkFileFilter *filter;
filter = GTK_FILE_FILTER(gtk_file_filter_new());
gtk_file_filter_add_pattern(filter, "*.gpx");
gtk_file_filter_set_name(filter, _("GPS Data Exchange Format"));
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);
// add time zone selection
GtkWidget *extra_box = gtk_hbox_new(FALSE, 5);
GtkWidget *label = gtk_label_new("camera time zone");
g_object_set(G_OBJECT(label), "tooltip-text", _("most cameras don't store the time zone in exif. give the correct time zone so the gpx data can be correctly matched"), (char *)NULL);
GtkWidget *tz_selection = gtk_combo_box_text_new();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(tz_selection), "UTC");
gtk_combo_box_set_active(GTK_COMBO_BOX(tz_selection), 0);
GList *iter = d->timezones;
int i = 0;
gchar *old_tz= dt_conf_get_string("plugins/lighttable/geolocation/tz");
if(iter)
{
do
{
i++;
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(tz_selection), (gchar*)iter->data);
if(!strcmp((gchar*)iter->data, old_tz))
gtk_combo_box_set_active(GTK_COMBO_BOX(tz_selection), i);
}
while( (iter = g_list_next(iter)) != NULL);
}
gtk_box_pack_start(GTK_BOX(extra_box), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(extra_box), tz_selection, FALSE, FALSE, 0);
gtk_widget_show_all(extra_box);
gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(filechooser), extra_box);
if(gtk_dialog_run(GTK_DIALOG (filechooser)) == GTK_RESPONSE_ACCEPT)
{
gchar *tz = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(tz_selection));
dt_conf_set_string("plugins/lighttable/geolocation/tz", tz);
gchar *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER (filechooser));
dt_control_gpx_apply(filename, -1, tz);
g_free(filename);
g_free(tz);
}
gtk_widget_destroy(extra_box);
gtk_widget_destroy(filechooser);
// dt_control_queue_redraw_center();
}
static void _lib_import_folder_callback(GtkWidget *widget,gpointer user_data)
{
GtkWidget *win = dt_ui_main_window(darktable.gui->ui);
GtkWidget *filechooser = gtk_file_chooser_dialog_new (_("import film"),
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), 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);
// add extra lines to 'extra'. don't forget to destroy the widgets later.
GtkWidget *extra;
extra = gtk_vbox_new(FALSE, 0);
// recursive opening.
GtkWidget *recursive;
recursive = gtk_check_button_new_with_label (_("import directories recursively"));
g_object_set(recursive, "tooltip-text", _("recursively import subdirectories. each directory goes into a new film roll."), NULL);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (recursive), dt_conf_get_bool("ui_last/import_recursive"));
gtk_widget_show (recursive);
gtk_box_pack_start(GTK_BOX (extra), recursive, FALSE, FALSE, 0);
// ignoring of jpegs. hack while we don't handle raw+jpeg in the same directories.
GtkWidget *ignore_jpeg;
ignore_jpeg = gtk_check_button_new_with_label (_("ignore jpeg files"));
g_object_set(ignore_jpeg, "tooltip-text", _("do not load files with an extension of .jpg or .jpeg. this can be useful when there are raw+jpeg in a directory."), NULL);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (ignore_jpeg), dt_conf_get_bool("ui_last/import_ignore_jpegs"));
gtk_widget_show (ignore_jpeg);
gtk_box_pack_start(GTK_BOX (extra), ignore_jpeg, FALSE, FALSE, 0);
gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filechooser), extra);
if (gtk_dialog_run (GTK_DIALOG (filechooser)) == GTK_RESPONSE_ACCEPT)
{
dt_conf_set_bool("ui_last/import_recursive", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (recursive)));
dt_conf_set_bool("ui_last/import_ignore_jpegs", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (ignore_jpeg)));
dt_conf_set_string("ui_last/import_last_directory", gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER (filechooser)));
char *filename = NULL, *first_filename = NULL;
GSList *list = gtk_file_chooser_get_filenames (GTK_FILE_CHOOSER (filechooser));
GSList *it = list;
/* for each selected folder add import job */
while(it)
{
filename = (char *)it->data;
dt_film_import(filename);
if (!first_filename)
first_filename = dt_util_dstrcat(g_strdup(filename), "%%");
g_free (filename);
it = g_slist_next(it);
}
/* update collection to view import */
if (first_filename)
{
dt_conf_set_int("plugins/lighttable/collect/num_rules", 1);
dt_conf_set_int("plugins/lighttable/collect/item0", 0);
dt_conf_set_string("plugins/lighttable/collect/string0",first_filename);
dt_collection_update_query(darktable.collection);
g_free(first_filename);
}
g_slist_free (list);
}
gtk_widget_destroy(recursive);
gtk_widget_destroy(ignore_jpeg);
gtk_widget_destroy(extra);
gtk_widget_destroy (filechooser);
gtk_widget_queue_draw(dt_ui_center(darktable.gui->ui));
}
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));
}
static void
style_changed (GtkComboBox *widget, dt_lib_export_t *d)
{
gchar *style = gtk_combo_box_get_active_text(d->style);
dt_conf_set_string("plugins/lighttable/export/style", style);
}
/** Initializes a new pwstorage context. */
const dt_pwstorage_t *dt_pwstorage_new()
{
/* add password storage capabilities */
#ifdef HAVE_LIBSECRET
dt_capabilities_add("libsecret");
#endif
#ifdef HAVE_KWALLET
dt_capabilities_add("kwallet");
#endif
dt_pwstorage_t *pwstorage = g_malloc(sizeof(dt_pwstorage_t));
dt_print(DT_DEBUG_PWSTORAGE, "[pwstorage_new] Creating new context %p\n", pwstorage);
if(pwstorage == NULL) return NULL;
gchar *_backend_str = dt_conf_get_string("plugins/pwstorage/pwstorage_backend");
gint _backend = PW_STORAGE_BACKEND_NONE;
if(strcmp(_backend_str, "auto") == 0)
{
const gchar *desktop = getenv("XDG_CURRENT_DESKTOP");
if(g_strcmp0(desktop, "KDE") == 0)
_backend = PW_STORAGE_BACKEND_KWALLET;
else if(g_strcmp0(desktop, "GNOME") == 0)
_backend = PW_STORAGE_BACKEND_LIBSECRET;
else if(g_strcmp0(desktop, "Unity") == 0)
_backend = PW_STORAGE_BACKEND_LIBSECRET;
else if(g_strcmp0(desktop, "XFCE") == 0)
_backend = PW_STORAGE_BACKEND_LIBSECRET;
dt_print(DT_DEBUG_PWSTORAGE, "[pwstorage_new] autodetected storage backend.\n");
}
else if(strcmp(_backend_str, "none") == 0)
_backend = PW_STORAGE_BACKEND_NONE;
#ifdef HAVE_LIBSECRET
else if(strcmp(_backend_str, "libsecret") == 0)
_backend = PW_STORAGE_BACKEND_LIBSECRET;
#endif
#ifdef HAVE_KWALLET
else if(strcmp(_backend_str, "kwallet") == 0)
_backend = PW_STORAGE_BACKEND_KWALLET;
#endif
else if(strcmp(_backend_str, "gnome keyring") == 0)
{
fprintf(stderr, "[pwstorage_new] GNOME Keyring backend is no longer supported.\n");
dt_control_log(_("GNOME Keyring backend is no longer supported. configure a different one"));
_backend = PW_STORAGE_BACKEND_NONE;
}
g_free(_backend_str);
switch(_backend)
{
default:
dt_print(DT_DEBUG_PWSTORAGE, "[pwstorage_new] unknown storage backend. Using none.\n");
case PW_STORAGE_BACKEND_NONE:
pwstorage->pw_storage_backend = PW_STORAGE_BACKEND_NONE;
pwstorage->backend_context = NULL;
dt_print(DT_DEBUG_PWSTORAGE, "[pwstorage_new] no storage backend. not storing username/password. "
"please change in preferences, core tab.\n");
break;
case PW_STORAGE_BACKEND_LIBSECRET:
#ifdef HAVE_LIBSECRET
dt_print(DT_DEBUG_PWSTORAGE, "[pwstorage_new] using libsecret backend for username/password storage");
pwstorage->backend_context = (void *)dt_pwstorage_libsecret_new();
if(pwstorage->backend_context == NULL)
{
dt_print(DT_DEBUG_PWSTORAGE, "[pwstorage_new] error starting libsecret. using no storage backend.\n");
pwstorage->backend_context = NULL;
pwstorage->pw_storage_backend = PW_STORAGE_BACKEND_NONE;
}
else
{
pwstorage->pw_storage_backend = PW_STORAGE_BACKEND_LIBSECRET;
}
break;
#else
dt_print(DT_DEBUG_PWSTORAGE,
"[pwstorage_new] libsecret backend not available. using no storage backend.\n");
pwstorage->backend_context = NULL;
pwstorage->pw_storage_backend = PW_STORAGE_BACKEND_NONE;
#endif
case PW_STORAGE_BACKEND_KWALLET:
#ifdef HAVE_KWALLET
dt_print(DT_DEBUG_PWSTORAGE, "[pwstorage_new] using kwallet backend for username/password storage");
pwstorage->backend_context = (void *)dt_pwstorage_kwallet_new();
if(pwstorage->backend_context == NULL)
{
dt_print(DT_DEBUG_PWSTORAGE, "[pwstorage_new] error starting kwallet. using no storage backend.\n");
pwstorage->backend_context = NULL;
pwstorage->pw_storage_backend = PW_STORAGE_BACKEND_NONE;
}
else
{
pwstorage->pw_storage_backend = PW_STORAGE_BACKEND_KWALLET;
}
dt_print(DT_DEBUG_PWSTORAGE, " done.\n");
break;
#else
dt_print(DT_DEBUG_PWSTORAGE,
"[pwstorage_new] kwallet backend not available. using no storage backend.\n");
pwstorage->backend_context = NULL;
pwstorage->pw_storage_backend = PW_STORAGE_BACKEND_NONE;
#endif
}
switch(pwstorage->pw_storage_backend)
{
case PW_STORAGE_BACKEND_NONE:
dt_conf_set_string("plugins/pwstorage/pwstorage_backend", "none");
break;
case PW_STORAGE_BACKEND_LIBSECRET:
dt_conf_set_string("plugins/pwstorage/pwstorage_backend", "libsecret");
break;
case PW_STORAGE_BACKEND_KWALLET:
dt_conf_set_string("plugins/pwstorage/pwstorage_backend", "kwallet");
break;
}
return pwstorage;
}
static int register_pref(lua_State*L)
{
// to avoid leaks, we need to first get all params (which could raise errors) then alloc and fill the struct
// this is complicated, but needed
pref_element * built_elt = malloc(sizeof(pref_element));
memset(built_elt,0,sizeof(pref_element));
int cur_param =1;
if(!lua_isstring(L,cur_param)) goto error;
built_elt->script = strdup(lua_tostring(L,cur_param));
cur_param++;
if(!lua_isstring(L,cur_param)) goto error;
built_elt->name = strdup(lua_tostring(L,cur_param));
cur_param++;
int i;
const char* type_name = lua_tostring(L,cur_param);
if(!type_name) goto error;
for (i=0; pref_type_name[i]; i++)
if (strcmp(pref_type_name[i], type_name) == 0)
{
built_elt->type =i;
break;
}
if(!pref_type_name[i]) goto error;
cur_param++;
if(!lua_isstring(L,cur_param)) goto error;
built_elt->label = strdup(lua_tostring(L,cur_param));
cur_param++;
if(!lua_isstring(L,cur_param)) goto error;
built_elt->tooltip = strdup(lua_tostring(L,cur_param));
cur_param++;
char pref_name[1024];
get_pref_name(pref_name,1024,built_elt->script,built_elt->name);
switch(built_elt->type)
{
case pref_string:
if(!lua_isstring(L,cur_param)) goto error;
built_elt->string_data.default_value = strdup(lua_tostring(L,cur_param));
cur_param++;
if(!dt_conf_key_exists(pref_name)) dt_conf_set_string(pref_name,built_elt->string_data.default_value);
break;
case pref_bool:
if(!lua_isboolean(L,cur_param)) goto error;
built_elt->bool_data.default_value = lua_toboolean(L,cur_param);
cur_param++;
if(!dt_conf_key_exists(pref_name)) dt_conf_set_bool(pref_name,built_elt->bool_data.default_value);
break;
case pref_int:
if(!lua_isnumber(L,cur_param)) goto error;
built_elt->int_data.default_value = lua_tointeger(L,cur_param);
cur_param++;
if(!lua_isnumber(L,cur_param)) goto error;
built_elt->int_data.min = lua_tointeger(L,cur_param);
cur_param++;
if(!lua_isnumber(L,cur_param)) goto error;
built_elt->int_data.max = lua_tointeger(L,cur_param);
cur_param++;
if(!dt_conf_key_exists(pref_name)) dt_conf_set_int(pref_name,built_elt->int_data.default_value);
break;
}
built_elt->next = pref_list;
pref_list = built_elt;
return 0;
error:
destroy_pref_element(built_elt);
return luaL_argerror(L,cur_param,NULL);
}
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));
}
static void _lib_recentcollection_updated(gpointer instance, gpointer user_data)
{
dt_lib_module_t *self =(dt_lib_module_t *)user_data;
dt_lib_recentcollect_t *d = (dt_lib_recentcollect_t *)self->data;
// serialize, check for recently used
char confname[200];
const int bufsize = 4096;
char buf[bufsize];
if(dt_collection_serialize(buf, bufsize)) return;
// is the current position, i.e. the one to be stored with the old collection (pos0, pos1-to-be)
uint32_t curr_pos = 0;
if(d->inited)
{
curr_pos = dt_view_lighttable_get_position(darktable.view_manager);
dt_conf_set_int("plugins/lighttable/recentcollect/pos0", curr_pos);
}
else
{
curr_pos = dt_conf_get_int("plugins/lighttable/recentcollect/pos0");
d->inited = 1;
}
uint32_t new_pos = 0;
int n = -1;
for(int k=0; k<CLAMPS(dt_conf_get_int("plugins/lighttable/recentcollect/num_items"), 0, NUM_LINES); k++)
{
// is it already in the current list?
snprintf(confname, 200, "plugins/lighttable/recentcollect/line%1d", k);
gchar *line = dt_conf_get_string(confname);
if(!line) continue;
if(!strcmp(line, buf))
{
snprintf(confname, 200, "plugins/lighttable/recentcollect/pos%1d", k);
new_pos = dt_conf_get_int(confname);
n = k;
break;
}
g_free(line);
}
if(n < 0)
{
const int num_items = CLAMPS(dt_conf_get_int("plugins/lighttable/recentcollect/num_items"), 0, NUM_LINES);
if(num_items < NUM_LINES)
{
// new, unused entry
n = num_items;
dt_conf_set_int("plugins/lighttable/recentcollect/num_items", num_items + 1);
}
else
{
// kill least recently used entry:
n = num_items - 1;
}
}
if(n >= 0 && n < NUM_LINES)
{
// sort n to the top
for(int k=n; k>0; k--)
{
snprintf(confname, 200, "plugins/lighttable/recentcollect/line%1d", k-1);
gchar *line1 = dt_conf_get_string(confname);
snprintf(confname, 200, "plugins/lighttable/recentcollect/pos%1d", k-1);
uint32_t pos1 = dt_conf_get_int(confname);
if(line1 && line1[0] != '\0')
{
snprintf(confname, 200, "plugins/lighttable/recentcollect/line%1d", k);
dt_conf_set_string(confname, line1);
snprintf(confname, 200, "plugins/lighttable/recentcollect/pos%1d", k);
dt_conf_set_int(confname, pos1);
}
g_free(line1);
}
dt_conf_set_string("plugins/lighttable/recentcollect/line0", buf);
dt_conf_set_int("plugins/lighttable/recentcollect/pos0", new_pos);
}
// update button descriptions:
for(int k=0; k<NUM_LINES; k++)
{
char str[200] = {0};
char str_cut[200] = {0};
char str_pretty[200] = {0};
snprintf(confname, 200, "plugins/lighttable/recentcollect/line%1d", k);
gchar *buf = dt_conf_get_string(confname);
if(buf && buf[0] != '\0')
{
pretty_print(buf, str);
g_free(buf);
}
g_object_set(G_OBJECT(d->item[k].button), "tooltip-text", str, (char *)NULL);
const int cut = 45;
if (g_utf8_strlen(str, -1) > cut)
{
g_utf8_strncpy(str_cut, str, cut);
snprintf(str_pretty, 200, "%s...", str_cut);
gtk_button_set_label(GTK_BUTTON(d->item[k].button), str_pretty);
}
else
{
gtk_button_set_label(GTK_BUTTON(d->item[k].button), str);
}
gtk_widget_set_no_show_all(d->item[k].button, TRUE);
gtk_widget_set_visible(d->item[k].button, FALSE);
}
for(int k=0; k<CLAMPS(dt_conf_get_int("plugins/lighttable/recentcollect/num_items"), 0, NUM_LINES); k++)
{
gtk_widget_set_no_show_all(d->item[k].button, FALSE);
gtk_widget_set_visible(d->item[k].button, TRUE);
}
dt_view_lighttable_set_position(darktable.view_manager, new_pos);
}
static void
dt_dev_change_image(dt_develop_t *dev, const uint32_t imgid)
{
// stop crazy users from sleeping on key-repeat spacebar:
if(dev->image_loading) return;
// get last active plugin, make sure focus out is called:
gchar *active_plugin = dt_conf_get_string("plugins/darkroom/active");
dt_iop_request_focus(NULL);
// store last active group
dt_conf_set_int("plugins/darkroom/groups", dt_dev_modulegroups_get(dev));
// store last active plugin:
if(darktable.develop->gui_module)
dt_conf_set_string("plugins/darkroom/active", darktable.develop->gui_module->op);
else
dt_conf_set_string("plugins/darkroom/active", "");
g_assert(dev->gui_attached);
// commit image ops to db
dt_dev_write_history(dev);
// be sure light table will update the thumbnail
// TODO: only if image changed!
// if()
{
dt_mipmap_cache_remove(darktable.mipmap_cache, dev->image_storage.id);
dt_image_synch_xmp(dev->image_storage.id);
}
select_this_image(imgid);
while(dev->history)
{
// clear history of old image
free(((dt_dev_history_item_t *)dev->history->data)->params);
free( (dt_dev_history_item_t *)dev->history->data);
dev->history = g_list_delete_link(dev->history, dev->history);
}
// get new image:
dt_dev_reload_image(dev, imgid);
// make sure no signals propagate here:
darktable.gui->reset = 1;
GList *modules = g_list_last(dev->iop);
int nb_iop = g_list_length(dev->iop);
dt_dev_pixelpipe_cleanup_nodes(dev->pipe);
dt_dev_pixelpipe_cleanup_nodes(dev->preview_pipe);
for (int i=nb_iop-1; i>0; i--)
{
dt_iop_module_t *module = (dt_iop_module_t *)(g_list_nth_data(dev->iop,i));
if (module->multi_priority == 0) //if the module is the "base" instance, we keep it
{
dt_iop_reload_defaults(module);
dt_iop_gui_update(module);
}
else //else we delete it and remove it from the panel
{
if (!dt_iop_is_hidden(module))
{
gtk_container_remove (GTK_CONTAINER(dt_ui_get_container(darktable.gui->ui, DT_UI_CONTAINER_PANEL_RIGHT_CENTER)),module->expander);
dt_iop_gui_cleanup_module(module);
}
//we remove the module from the list
dev->iop = g_list_remove_link(dev->iop,g_list_nth(dev->iop,i));
//we cleanup the module
dt_accel_disconnect_list(module->accel_closures);
dt_accel_cleanup_locals_iop(module);
module->accel_closures = NULL;
dt_iop_cleanup_module(module);
free(module);
}
}
dt_dev_pixelpipe_create_nodes(dev->pipe, dev);
dt_dev_pixelpipe_create_nodes(dev->preview_pipe, dev);
dt_dev_read_history(dev);
//we have to init all module instances other than "base" instance
modules = dev->iop;
while(modules)
{
dt_iop_module_t *module = (dt_iop_module_t *)(modules->data);
if(module->multi_priority > 0)
{
if (!dt_iop_is_hidden(module))
{
module->gui_init(module);
dt_iop_reload_defaults(module);
//we search the base iop corresponding
GList *mods = g_list_first(dev->iop);
dt_iop_module_t *base = NULL;
int pos_module = 0;
int pos_base = 0;
int pos = 0;
while (mods)
{
dt_iop_module_t *mod = (dt_iop_module_t *)(mods->data);
if (mod->multi_priority == 0 && mod->instance == module->instance)
{
base = mod;
pos_base = pos;
}
else if (mod == module) pos_module = pos;
mods = g_list_next(mods);
pos++;
}
if (!base) continue;
/* add module to right panel */
GtkWidget *expander = dt_iop_gui_get_expander(module);
dt_ui_container_add_widget(darktable.gui->ui,
DT_UI_CONTAINER_PANEL_RIGHT_CENTER, expander);
GValue gv = { 0, { { 0 } } };
g_value_init(&gv,G_TYPE_INT);
gtk_container_child_get_property(GTK_CONTAINER(dt_ui_get_container(darktable.gui->ui, DT_UI_CONTAINER_PANEL_RIGHT_CENTER)),base->expander,"position",&gv);
gtk_box_reorder_child (dt_ui_get_container(darktable.gui->ui, DT_UI_CONTAINER_PANEL_RIGHT_CENTER),expander,g_value_get_int(&gv)+pos_base-pos_module);
dt_iop_gui_set_expanded(module, TRUE);
dt_iop_gui_update_blending(module);
}
/* setup key accelerators */
module->accel_closures = NULL;
if(module->connect_key_accels)
module->connect_key_accels(module);
dt_iop_connect_common_accels(module);
//we update show params for multi-instances for each other instances
dt_dev_modules_update_multishow(module->dev);
}
modules = g_list_next(modules);
}
dt_dev_pop_history_items(dev, dev->history_end);
if(active_plugin)
{
modules = dev->iop;
while(modules)
{
dt_iop_module_t *module = (dt_iop_module_t *)(modules->data);
if(!strcmp(module->op, active_plugin))
dt_iop_request_focus(module);
modules = g_list_next(modules);
}
g_free(active_plugin);
}
/* last set the group to update visibility of iop modules for new pipe */
dt_dev_modulegroups_set(dev,dt_conf_get_int("plugins/darkroom/groups"));
// make signals work again, but only after focus event,
// to avoid crop/rotate for example to add another history item.
darktable.gui->reset = 0;
// Signal develop initialize
dt_control_signal_raise(darktable.signals, DT_SIGNAL_DEVELOP_IMAGE_CHANGED);
// prefetch next few from first selected image on.
dt_view_filmstrip_prefetch();
}
