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(); }