void
facebook_service_upload_photos (FacebookService *self,
FacebookAlbum *album,
GList *file_list, /* GFile list */
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
gth_task_progress (GTH_TASK (self->priv->conn), _("Uploading the files to the server"), NULL, TRUE, 0.0);
post_photos_data_free (self->priv->post_photos);
self->priv->post_photos = g_new0 (PostPhotosData, 1);
self->priv->post_photos->album = _g_object_ref (album);
self->priv->post_photos->cancellable = _g_object_ref (cancellable);
self->priv->post_photos->callback = callback;
self->priv->post_photos->user_data = user_data;
self->priv->post_photos->total_size = 0;
self->priv->post_photos->n_files = 0;
_g_query_all_metadata_async (file_list,
FALSE,
TRUE,
"*",
self->priv->post_photos->cancellable,
upload_photos_info_ready_cb,
self);
}
static GthImageSaveData *
_gth_image_save_to_buffer_common (GthImage *image,
const char *mime_type,
GthFileData *file_data,
GCancellable *cancellable,
GError **p_error)
{
GthImageSaver *saver;
char *buffer;
gsize buffer_size;
GError *error = NULL;
GthImageSaveData *save_data = NULL;
saver = gth_main_get_image_saver (mime_type);
if (saver == NULL) {
if (p_error != NULL)
*p_error = g_error_new (GTH_ERROR, GTH_ERROR_GENERIC, _("Could not find a suitable module to save the image as \"%s\""), mime_type);
return NULL;
}
if (gth_image_saver_save_image (saver,
image,
&buffer,
&buffer_size,
mime_type,
cancellable,
&error))
{
save_data = g_new0 (GthImageSaveData, 1);
save_data->file_data = _g_object_ref (file_data);
save_data->image = gth_image_copy (image);
save_data->mime_type = mime_type;
save_data->buffer = buffer;
save_data->buffer_size = buffer_size;
save_data->files = NULL;
save_data->error = NULL;
save_data->cancellable = _g_object_ref (cancellable);
if (save_data->file_data != NULL)
gth_hook_invoke ("save-image", save_data);
if ((save_data->error != NULL) && (p_error != NULL))
*p_error = g_error_copy (*save_data->error);
}
else {
if (p_error != NULL)
*p_error = error;
else
_g_error_free (error);
}
g_object_unref (saver);
return save_data;
}
void
gth_pixbuf_list_task_set_destination (GthPixbufListTask *self,
GFile *folder)
{
_g_object_unref (self->priv->destination_folder);
self->priv->destination_folder = _g_object_ref (folder);
}
static void
copy_from_menu_item_activate_cb (GtkMenuItem *menu_item,
gpointer user_data)
{
GthContactSheetThemeDialog *self = user_data;
char *display_name;
GFile *file;
GthContactSheetTheme *theme;
if ((self->priv->theme != NULL) && (self->priv->theme->file != NULL))
file = g_file_dup (self->priv->theme->file);
else
file = NULL;
display_name = g_strdup (gtk_entry_get_text (GTK_ENTRY (GET_WIDGET ("name_entry"))));
theme = g_object_get_data (G_OBJECT (menu_item), "theme");
if (theme != NULL)
update_controls_from_theme (self, theme);
gtk_entry_set_text (GTK_ENTRY (GET_WIDGET ("name_entry")), display_name);
_g_object_unref (self->priv->theme->file);
self->priv->theme->file = _g_object_ref (file);
g_free (display_name);
_g_object_unref (file);
}
void
fetch_cover_image_from_name (GooWindow *window,
const char *album,
const char *artist,
GCancellable *cancellable)
{
FetchData *data;
char *url;
GFile *file;
data = g_new0 (FetchData, 1);
data->window = window;
data->cancellable = _g_object_ref (cancellable);
url = get_query (album, artist);
file = g_file_new_for_uri (url);
g_load_file_async (file,
G_PRIORITY_DEFAULT,
data->cancellable,
query_ready_cb,
data);
g_object_unref (file);
g_free (url);
}
void
gth_image_save_to_file (GthImage *image,
const char *mime_type,
GthFileData *file_data,
gboolean replace,
GCancellable *cancellable,
GthFileDataFunc ready_func,
gpointer user_data)
{
SaveArguments *arguments;
g_return_if_fail (image != NULL);
g_return_if_fail (file_data != NULL);
arguments = g_new0 (SaveArguments, 1);
arguments->file_data = g_object_ref (file_data);
arguments->replace = replace;
arguments->cancellable = _g_object_ref (cancellable);
arguments->ready_func = ready_func;
arguments->user_data = user_data;
gth_image_save_to_buffer_async (image,
mime_type,
file_data,
cancellable,
save_to_buffer_ready_cb,
arguments);
}
void
gth_browser_activate_import_folder (GSimpleAction *action,
GVariant *parameter,
gpointer user_data)
{
GthBrowser *browser = GTH_BROWSER (user_data);
GtkWidget *chooser;
GFile *folder;
chooser = gtk_file_chooser_dialog_new (_("Choose a folder"),
GTK_WINDOW (browser),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
_GTK_LABEL_CANCEL, GTK_RESPONSE_CANCEL,
_("Import"), GTK_RESPONSE_OK,
NULL);
_gtk_dialog_add_class_to_response (GTK_DIALOG (chooser), GTK_RESPONSE_OK, GTK_STYLE_CLASS_SUGGESTED_ACTION);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (chooser), FALSE);
folder = NULL;
if (GTH_IS_FILE_SOURCE_VFS (gth_browser_get_location_source (browser)))
folder = _g_object_ref (gth_browser_get_location (browser));
if (folder == NULL)
folder = g_file_new_for_uri (get_home_uri ());
gtk_file_chooser_set_file (GTK_FILE_CHOOSER (chooser), folder, NULL);
g_signal_connect (chooser,
"response",
G_CALLBACK (folder_chooser_response_cb),
browser);
gtk_widget_show (chooser);
_g_object_unref (folder);
}
void
picasa_web_service_post_photos (PicasaWebService *self,
PicasaWebAlbum *album,
GList *file_list, /* GFile list */
int max_width,
int max_height,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_return_if_fail (album != NULL);
g_return_if_fail (self->priv->post_photos == NULL);
gth_task_progress (GTH_TASK (self),
_("Uploading the files to the server"),
"",
TRUE,
0.0);
self->priv->post_photos = g_new0 (PostPhotosData, 1);
self->priv->post_photos->album = g_object_ref (album);
self->priv->post_photos->max_width = max_width;
self->priv->post_photos->max_height = max_height;
self->priv->post_photos->cancellable = _g_object_ref (cancellable);
self->priv->post_photos->callback = callback;
self->priv->post_photos->user_data = user_data;
_g_query_all_metadata_async (file_list,
GTH_LIST_DEFAULT,
"*",
self->priv->post_photos->cancellable,
post_photos_info_ready_cb,
self);
}
static void
installer_data_free (InstallerData *idata)
{
g_object_unref (idata->window);
_g_object_ref (idata->cancellable);
g_free (idata);
}
static LoadData *
load_data_new (FrFileSelectorDialog *dialog,
GFile *folder)
{
LoadData *load_data;
load_data = g_slice_new0 (LoadData);
load_data->dialog = g_object_ref (dialog);
load_data->folder = _g_object_ref (folder);
load_data->cancellable = g_cancellable_new ();
load_data->files = NULL;
return load_data;
}
static void
picasa_web_service_get_user_info (WebService *base,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
PicasaWebService *self = PICASA_WEB_SERVICE (base);
OAuthAccount *account;
GHashTable *data_set;
SoupMessage *msg;
account = web_service_get_current_account (WEB_SERVICE (self));
if (account != NULL) {
_g_strset (&self->priv->refresh_token, account->token_secret);
_g_strset (&self->priv->access_token, account->token);
}
data_set = g_hash_table_new (g_str_hash, g_str_equal);
if (self->priv->access_token != NULL) {
msg = soup_form_request_new_from_hash ("GET", "https://www.googleapis.com/oauth2/v2/userinfo", data_set);
_picasa_web_service_add_headers (self, msg);
_web_service_send_message (WEB_SERVICE (self),
msg,
cancellable,
callback,
user_data,
picasa_web_service_get_user_info,
picasa_web_service_get_user_info_ready_cb,
self);
}
else {
/* Get the access token from the refresh token */
AccessTokenData *data;
data = g_new0 (AccessTokenData, 1);
data->service = self;
data->cancellable = _g_object_ref (cancellable);
data->callback = callback;
data->user_data = user_data;
_picasa_web_service_get_access_token (self,
self->priv->refresh_token,
cancellable,
access_token_ready_cb,
data);
}
g_hash_table_destroy (data_set);
}
void
fetch_cover_image_from_album_info (GooWindow *window,
AlbumInfo *album,
FetchCoverStage after_stage,
GCancellable *cancellable)
{
if ((cancellable != NULL) && g_cancellable_is_cancelled (cancellable))
return;
#if HAVE_LIBCOVERART
if ((FETCH_COVER_STAGE_AFTER_LIBCOVERART > after_stage)
&& (album != NULL)
&& (album->id != NULL))
{
CoverArtData *data;
data = g_new0 (CoverArtData, 1);
data->window = g_object_ref (window);
data->album = album_info_ref (album);
data->cancellable = _g_object_ref (cancellable);
metadata_get_coverart (data->window,
data->album,
data->cancellable,
metadata_get_coverart_cb,
data);
return;
}
#endif
if ((FETCH_COVER_STAGE_AFTER_ASIN > after_stage)
&& (album != NULL)
&& (album->asin != NULL))
{
fetch_cover_image_from_asin (window, album->asin, cancellable);
return;
}
if ((FETCH_COVER_STAGE_AFTER_WEB_SEARCH > after_stage)
&& (album != NULL)
&& (album->title != NULL)
&& (album->artist != NULL))
{
fetch_cover_image_from_name (window, album->title, album->artist, cancellable);
}
}
void
fr_process_execute (FrProcess *process,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
ExecuteData *exec_data;
g_return_if_fail (! process->priv->running);
execute_data_free (process->priv->exec_data);
process->priv->exec_data = exec_data = g_new0 (ExecuteData, 1);
exec_data->process = g_object_ref (process);
exec_data->cancellable = _g_object_ref (cancellable);
exec_data->cancel_id = 0;
exec_data->result = g_simple_async_result_new (G_OBJECT (process),
callback,
user_data,
fr_process_execute);
g_simple_async_result_set_op_res_gpointer (exec_data->result, exec_data, NULL);
if (! process->restart)
process->priv->current_charset = -1;
if (cancellable != NULL) {
GError *error = NULL;
if (g_cancellable_set_error_if_cancelled (cancellable, &error)) {
exec_data->error = fr_error_new (FR_ERROR_STOPPED, 0, error);
_fr_process_execute_complete_in_idle (exec_data);
g_error_free (error);
return;
}
exec_data->cancel_id = g_cancellable_connect (cancellable,
G_CALLBACK (execute_cancelled_cb),
exec_data,
NULL);
}
_fr_process_start (exec_data);
}
GthImageData *
gth_image_data_new (GthImage *image,
int requested_size,
gboolean unsaved)
{
GthImageData *idata;
g_return_val_if_fail (image != NULL, NULL);
idata = g_new0 (GthImageData, 1);
idata->ref = 1;
idata->image = _g_object_ref (image);
idata->requested_size = requested_size;
idata->unsaved = unsaved;
return idata;
}
void
dlg_package_installer (FrWindow *window,
GFile *file,
FrAction action,
GCancellable *cancellable)
{
InstallerData *idata;
idata = g_new0 (InstallerData, 1);
idata->window = g_object_ref (window);
idata->action = action;
idata->cancellable = _g_object_ref (cancellable);
_g_file_load_buffer_async (file,
BUFFER_SIZE_FOR_PRELOAD,
cancellable,
file_buffer_ready_cb,
idata);
}
void
_web_service_send_message (WebService *self,
SoupMessage *msg,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data,
gpointer source_tag,
SoupSessionCallback soup_session_cb,
gpointer soup_session_cb_data)
{
if (self->priv->session == NULL) {
self->priv->session = soup_session_new ();
#ifdef DEBUG_WEB_CONNECTION
{
SoupLogger *logger;
logger = soup_logger_new (SOUP_LOGGER_LOG_BODY, -1);
soup_session_add_feature (self->priv->session, SOUP_SESSION_FEATURE (logger));
g_object_unref (logger);
}
#endif
}
_g_object_unref (self->priv->cancellable);
self->priv->cancellable = _g_object_ref (cancellable);
_g_object_unref (self->priv->result);
self->priv->result = g_simple_async_result_new (G_OBJECT (self),
callback,
user_data,
source_tag);
self->priv->msg = msg;
g_object_add_weak_pointer (G_OBJECT (msg), (gpointer *) &self->priv->msg);
soup_session_queue_message (self->priv->session,
msg,
soup_session_cb,
soup_session_cb_data);
}
void
dlg_batch_add_files (FrWindow *window,
GList *file_list)
{
GFile *first_file;
GFile *parent;
char *filename;
GtkWidget *dialog;
g_return_if_fail (file_list != NULL);
first_file = G_FILE (file_list->data);
parent = _g_object_ref (fr_window_get_add_default_dir (window));
if (parent == NULL)
parent = g_file_get_parent (first_file);
filename = NULL;
if (file_list->next == NULL)
filename = g_file_get_basename (first_file);
else
filename = g_file_get_basename (parent);
if (! _g_file_check_permissions (parent, R_OK | W_OK)) {
g_object_unref (parent);
parent = g_object_ref (_g_file_get_home ());
}
dialog = fr_new_archive_dialog_new (_("Compress"),
NULL,
((file_list->next == NULL) ? FR_NEW_ARCHIVE_ACTION_NEW_SINGLE_FILE : FR_NEW_ARCHIVE_ACTION_NEW_MANY_FILES),
parent,
filename);
g_signal_connect (dialog,
"response",
G_CALLBACK (dialog_response_cb),
window);
gtk_window_present (GTK_WINDOW (dialog));
g_object_unref (parent);
g_free (filename);
}
void
fetch_cover_image_from_asin (GooWindow *window,
const char *asin,
GCancellable *cancellable)
{
FetchData *data;
char *url;
GFile *file;
data = g_new0 (FetchData, 1);
data->window = window;
data->cancellable = _g_object_ref (cancellable);
url = g_strdup_printf ("http://images.amazon.com/images/P/%s.01._SCLZZZZZZZ_.jpg", asin);
file = g_file_new_for_uri (url);
g_load_file_async (file,
G_PRIORITY_DEFAULT,
data->cancellable,
image_data_ready_for_asin_cb,
data);
g_object_unref (file);
g_free (url);
}
GFile *
fr_file_selector_dialog_get_current_folder (FrFileSelectorDialog *self)
{
return _g_object_ref (self->priv->current_folder);
}
static void
dlg_photo_importer (GthBrowser *browser,
GFile *source,
DlgImporterSourceType selector_type)
{
DialogData *data;
GtkCellRenderer *renderer;
GthFileDataSort *sort_type;
GList *tests, *scan;
char *general_filter;
int i, active_filter;
int i_general;
if (gth_browser_get_dialog (browser, "photo_importer") != NULL) {
gtk_window_present (GTK_WINDOW (gth_browser_get_dialog (browser, "photo_importer")));
return;
}
data = g_new0 (DialogData, 1);
data->browser = browser;
data->builder = gtk_builder_new_from_resource ("/org/gnome/gThumb/photo_importer/data/ui/photo-importer.ui");
data->settings = g_settings_new (GTHUMB_PHOTO_IMPORTER_SCHEMA);
data->selector_type = selector_type;
data->source = _g_object_ref (source);
data->cancellable = g_cancellable_new ();
data->vfs_source = g_object_new (GTH_TYPE_FILE_SOURCE_VFS, NULL);
gth_file_source_monitor_entry_points (GTH_FILE_SOURCE (data->vfs_source));
/* Get the widgets. */
data->dialog = _gtk_builder_get_widget (data->builder, "photo_importer_dialog");
_gtk_window_resize_to_fit_screen_height (data->dialog, 580);
gth_browser_set_dialog (browser, "photo_importer", data->dialog);
g_object_set_data (G_OBJECT (data->dialog), "dialog_data", data);
if (data->selector_type == DLG_IMPORTER_SOURCE_TYPE_DEVICE) {
gtk_window_set_title (GTK_WINDOW (data->dialog), _("Import from Removable Device"));
data->device_list_store = gtk_list_store_new (SOURCE_LIST_COLUMNS, G_TYPE_OBJECT, G_TYPE_ICON, G_TYPE_STRING);
data->device_chooser = gtk_combo_box_new_with_model (GTK_TREE_MODEL (data->device_list_store));
gtk_widget_show (data->device_chooser);
gtk_box_pack_start (GTK_BOX (GET_WIDGET ("source_box")), data->device_chooser, TRUE, TRUE, 0);
gtk_label_set_mnemonic_widget (GTK_LABEL (GET_WIDGET ("source_label")), data->device_chooser);
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (data->device_chooser), renderer, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (data->device_chooser),
renderer,
"gicon", SOURCE_LIST_COLUMN_ICON,
NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (data->device_chooser), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (data->device_chooser),
renderer,
"text", SOURCE_LIST_COLUMN_NAME,
NULL);
g_object_unref (data->device_list_store);
}
else {
if (data->source == NULL) {
if (GTH_IS_FILE_SOURCE_VFS (gth_browser_get_location_source (browser)))
data->source = _g_object_ref (gth_browser_get_location (browser));
if (data->source == NULL)
data->source = g_file_new_for_uri (get_home_uri ());
}
gtk_window_set_title (GTK_WINDOW (data->dialog), _("Import from Folder"));
data->folder_chooser = gtk_file_chooser_button_new (_("Choose a folder"), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
gtk_label_set_mnemonic_widget (GTK_LABEL (GET_WIDGET ("source_label")), data->folder_chooser);
gtk_file_chooser_set_file (GTK_FILE_CHOOSER (data->folder_chooser), data->source, NULL);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (data->folder_chooser), FALSE);
gtk_widget_show (data->folder_chooser);
gtk_box_pack_start (GTK_BOX (GET_WIDGET ("source_box")), data->folder_chooser, TRUE, TRUE, 0);
}
data->file_list = gth_file_list_new (gth_grid_view_new (), GTH_FILE_LIST_MODE_NORMAL, FALSE);
sort_type = gth_main_get_sort_type ("file::mtime");
gth_file_list_set_sort_func (GTH_FILE_LIST (data->file_list), sort_type->cmp_func, FALSE);
gth_file_list_enable_thumbs (GTH_FILE_LIST (data->file_list), TRUE);
gth_file_list_set_ignore_hidden (GTH_FILE_LIST (data->file_list), TRUE);
gth_file_list_set_thumb_size (GTH_FILE_LIST (data->file_list), 128);
gth_file_list_set_caption (GTH_FILE_LIST (data->file_list), "standard::display-name,gth::file::display-size");
gtk_widget_show (data->file_list);
gtk_box_pack_start (GTK_BOX (GET_WIDGET ("filelist_box")), data->file_list, TRUE, TRUE, 0);
tests = gth_main_get_registered_objects_id (GTH_TYPE_TEST);
general_filter = "file::type::is_media"; /* default value */
active_filter = 0;
data->filter_combobox = gtk_combo_box_text_new ();
for (i = 0, i_general = -1, scan = tests; scan; scan = scan->next, i++) {
const char *registered_test_id = scan->data;
GthTest *test;
if (strncmp (registered_test_id, "file::type::", 12) != 0)
continue;
i_general += 1;
test = gth_main_get_registered_object (GTH_TYPE_TEST, registered_test_id);
if (strcmp (registered_test_id, general_filter) == 0) {
active_filter = i_general;
gth_file_list_set_filter (GTH_FILE_LIST (data->file_list), test);
}
data->general_tests = g_list_prepend (data->general_tests, g_strdup (gth_test_get_id (test)));
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (data->filter_combobox),
gth_test_get_display_name (test));
g_object_unref (test);
}
data->general_tests = g_list_reverse (data->general_tests);
gtk_combo_box_set_active (GTK_COMBO_BOX (data->filter_combobox), active_filter);
gtk_widget_show (data->filter_combobox);
gtk_container_add (GTK_CONTAINER (GET_WIDGET ("filter_box")), data->filter_combobox);
gtk_label_set_mnemonic_widget (GTK_LABEL (GET_WIDGET ("filter_label")), data->filter_combobox);
gtk_label_set_use_underline (GTK_LABEL (GET_WIDGET ("filter_label")), TRUE);
_g_string_list_free (tests);
data->tags_entry = gth_tags_entry_new (GTH_TAGS_ENTRY_MODE_POPUP);
gtk_widget_show (data->tags_entry);
gtk_box_pack_start (GTK_BOX (GET_WIDGET ("tags_entry_box")), data->tags_entry, TRUE, TRUE, 0);
gtk_label_set_mnemonic_widget (GTK_LABEL (GET_WIDGET ("tags_label")), data->tags_entry);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("delete_checkbutton")),
g_settings_get_boolean (data->settings, PREF_PHOTO_IMPORTER_DELETE_FROM_DEVICE));
data->preferences_dialog = gth_import_preferences_dialog_new ();
gtk_window_set_transient_for (GTK_WINDOW (data->preferences_dialog), GTK_WINDOW (data->dialog));
gtk_box_pack_start (GTK_BOX (GET_WIDGET ("destination_button_box")),
gth_import_destination_button_new (GTH_IMPORT_PREFERENCES_DIALOG (data->preferences_dialog)),
TRUE,
TRUE,
0);
gtk_widget_show_all (GET_WIDGET ("destination_button_box"));
/* Set the signals handlers. */
g_signal_connect (G_OBJECT (data->dialog),
"delete-event",
G_CALLBACK (dialog_delete_event_cb),
data);
g_signal_connect (GET_WIDGET ("ok_button"),
"clicked",
G_CALLBACK (ok_clicked_cb),
data);
g_signal_connect (GET_WIDGET ("cancel_button"),
"clicked",
G_CALLBACK (close_dialog),
data);
if (data->selector_type == DLG_IMPORTER_SOURCE_TYPE_DEVICE)
g_signal_connect (data->device_chooser,
"changed",
G_CALLBACK (device_chooser_changed_cb),
data);
else
g_signal_connect (data->folder_chooser,
"selection-changed",
G_CALLBACK (folder_chooser_file_set_cb),
data);
g_signal_connect (data->filter_combobox,
"changed",
G_CALLBACK (filter_combobox_changed_cb),
data);
g_signal_connect (gth_file_view_get_model (GTH_FILE_VIEW (gth_file_list_get_view (GTH_FILE_LIST (data->file_list)))),
"visibility_changed",
G_CALLBACK (file_store_changed_cb),
data);
g_signal_connect (gth_file_list_get_view (GTH_FILE_LIST (data->file_list)),
"file-selection-changed",
G_CALLBACK (file_view_selection_changed_cb),
data);
data->entry_points_changed_id = g_signal_connect (gth_main_get_default_monitor (),
"entry-points-changed",
G_CALLBACK (entry_points_changed_cb),
data);
g_signal_connect_after (GET_WIDGET ("event_entry"),
"changed",
G_CALLBACK (event_entry_changed_cb),
data);
/* Run dialog. */
gtk_window_set_transient_for (GTK_WINDOW (data->dialog), GTK_WINDOW (browser));
gtk_window_set_modal (GTK_WINDOW (data->dialog), FALSE);
gtk_widget_show (data->dialog);
gth_import_preferences_dialog_set_event (GTH_IMPORT_PREFERENCES_DIALOG (data->preferences_dialog),
gtk_entry_get_text (GTK_ENTRY (GET_WIDGET ("event_entry"))));
if (data->selector_type == DLG_IMPORTER_SOURCE_TYPE_DEVICE)
update_device_source_list (data);
else
load_file_list (data);
}
