static void
process_current_file (GthPixbufListTask *self)
{
GthFileData *file_data;
GList *singleton;
if (self->priv->current == NULL) {
gth_task_completed (GTH_TASK (self), NULL);
return;
}
_g_object_unref (self->priv->original_pixbuf);
self->priv->original_pixbuf = NULL;
_g_object_unref (self->priv->new_pixbuf);
self->priv->new_pixbuf = NULL;
gth_task_progress (GTH_TASK (self),
NULL,
NULL,
FALSE,
((double) self->priv->n_current + 1) / (self->priv->n_files + 1));
file_data = self->priv->current->data;
singleton = g_list_append (NULL, g_object_ref (file_data->file));
_g_query_all_metadata_async (singleton,
FALSE,
TRUE,
"*",
gth_task_get_cancellable (GTH_TASK (self)),
file_info_ready_cb,
self);
_g_object_list_unref (singleton);
}
static void
ask_authorization_dialog_loaded_cb (OAuthAskAuthorizationDialog *dialog,
gpointer user_data)
{
PicasaWebService *self = user_data;
const char *title;
title = oauth_ask_authorization_dialog_get_title (dialog);
if (title == NULL)
return;
if (g_str_has_prefix (title, PICASA_WEB_REDIRECT_TITLE)) {
const char *authorization_code;
gtk_widget_hide (GTK_WIDGET (dialog));
gth_task_dialog (GTH_TASK (self), FALSE, NULL);
authorization_code = title + strlen (PICASA_WEB_REDIRECT_TITLE);
_picasa_web_service_get_refresh_token (self,
authorization_code,
gth_task_get_cancellable (GTH_TASK (self)),
refresh_token_ready_cb,
self);
}
}
static void
auto_select_account (DialogData *data)
{
gtk_widget_hide (data->dialog);
if (data->conn != NULL)
gth_task_dialog (GTH_TASK (data->conn), FALSE);
if (data->accounts != NULL) {
if (data->email != NULL) {
connect_to_server (data);
}
else if (data->accounts->next == NULL) {
data->email = g_strdup ((char *)data->accounts->data);
connect_to_server (data);
}
else {
GtkWidget *dialog;
gth_task_dialog (GTH_TASK (data->conn), TRUE);
dialog = picasa_account_chooser_dialog_new (data->accounts, data->email);
g_signal_connect (dialog,
"response",
G_CALLBACK (account_chooser_dialog_response_cb),
data);
gtk_window_set_title (GTK_WINDOW (dialog), _("Choose Account"));
gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (data->browser));
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
gtk_window_present (GTK_WINDOW (dialog));
}
}
else
account_properties_dialog (data, NULL);
}
static void
file_buffer_ready_cb (void **buffer,
gsize count,
GError *error,
gpointer user_data)
{
GthPixbufListTask *self = user_data;
GInputStream *istream;
GdkPixbuf *pixbuf;
if (error != NULL) {
gth_task_completed (GTH_TASK (self), error);
return;
}
istream = g_memory_input_stream_new_from_data (*buffer, count, NULL);
pixbuf = gdk_pixbuf_new_from_stream (istream, gth_task_get_cancellable (GTH_TASK (self)), &error);
if (pixbuf != NULL) {
self->priv->original_pixbuf = gdk_pixbuf_apply_embedded_orientation (pixbuf);
g_object_unref (pixbuf);
}
else
self->priv->original_pixbuf = NULL;
g_object_unref (istream);
if (self->priv->original_pixbuf == NULL) {
gth_task_completed (GTH_TASK (self), error);
return;
}
gth_pixbuf_task_set_source (GTH_PIXBUF_TASK (self->priv->task), self->priv->original_pixbuf);
gth_task_exec (self->priv->task, gth_task_get_cancellable (GTH_TASK (self)));
}
static void
organize_files_dialog_response_cb (GtkDialog *dialog,
int response_id,
gpointer user_data)
{
GthOrganizeTask *self = user_data;
if (response_id == GTK_RESPONSE_DELETE_EVENT) {
if (self->priv->organized)
response_id = GTK_RESPONSE_CLOSE;
else
response_id = GTK_RESPONSE_CANCEL;
}
switch (response_id) {
case GTK_RESPONSE_CANCEL:
gth_task_cancel (GTH_TASK (self));
break;
case GTK_RESPONSE_CLOSE:
gth_task_completed (GTH_TASK (self), NULL);
break;
case GTK_RESPONSE_OK:
save_catalogs (self);
break;
}
}
static void
list_albums_ready_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
DialogData *data = user_data;
PicasaWebService *picasaweb = PICASA_WEB_SERVICE (source_object);
GError *error = NULL;
_g_object_list_unref (data->albums);
data->albums = picasa_web_service_list_albums_finish (picasaweb, result, &error);
if (error != NULL) {
gth_task_dialog (GTH_TASK (data->service), TRUE, NULL);
_gtk_error_dialog_from_gerror_show (GTK_WINDOW (data->browser), _("Could not get the album list"), error);
g_clear_error (&error);
gtk_dialog_response (GTK_DIALOG (data->dialog), GTK_RESPONSE_DELETE_EVENT);
return;
}
update_album_list (data);
gth_task_dialog (GTH_TASK (data->service), TRUE, NULL);
gtk_window_set_transient_for (GTK_WINDOW (data->dialog), GTK_WINDOW (data->browser));
gtk_window_set_modal (GTK_WINDOW (data->dialog), FALSE);
gtk_window_present (GTK_WINDOW (data->dialog));
}
static void
pixbuf_saved_cb (GthFileData *file_data,
GError *error,
gpointer user_data)
{
GthPixbufListTask *self = user_data;
GFile *parent;
GList *file_list;
if (error != NULL) {
if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_EXISTS)) {
if (self->priv->overwrite_mode == GTH_OVERWRITE_SKIP) {
process_next_file (self);
}
else {
GthFileData *file_data;
GtkWidget *dialog;
gth_task_dialog (GTH_TASK (self), TRUE);
file_data = self->priv->current->data;
dialog = gth_overwrite_dialog_new (NULL,
self->priv->new_pixbuf,
file_data->file,
GTH_OVERWRITE_RESPONSE_YES,
(self->priv->n_files == 1));
g_signal_connect (dialog,
"response",
G_CALLBACK (overwrite_dialog_response_cb),
self);
gtk_widget_show (dialog);
}
}
else
gth_task_completed (GTH_TASK (self), error);
return;
}
parent = g_file_get_parent (file_data->file);
file_list = g_list_append (NULL, file_data->file);
gth_monitor_folder_changed (gth_main_get_default_monitor (),
parent,
file_list,
GTH_MONITOR_EVENT_CHANGED);
g_list_free (file_list);
g_object_unref (parent);
process_next_file (self);
}
void
facebook_service_get_user_info (FacebookService *self,
const char *fields,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GHashTable *data_set;
SoupMessage *msg;
gth_task_progress (GTH_TASK (self->priv->conn), _("Connecting to the server"), _("Getting account information"), TRUE, 0.0);
data_set = g_hash_table_new (g_str_hash, g_str_equal);
g_hash_table_insert (data_set, "method", "facebook.users.getInfo");
g_hash_table_insert (data_set, "uids", (char *) facebook_connection_get_user_id (self->priv->conn));
g_hash_table_insert (data_set, "fields", (char *) fields);
facebook_connection_add_api_sig (self->priv->conn, data_set);
msg = soup_form_request_new_from_hash ("POST", FACEBOOK_HTTPS_REST_SERVER, data_set);
facebook_connection_send_message (self->priv->conn,
msg,
cancellable,
callback,
user_data,
facebook_service_get_user_info,
get_user_info_ready_cb,
self);
g_hash_table_destroy (data_set);
}
static void
ask_authorization_dialog_response_cb (GtkDialog *dialog,
int response_id,
gpointer user_data)
{
WebService *self = user_data;
switch (response_id) {
case GTK_RESPONSE_DELETE_EVENT:
case GTK_RESPONSE_CANCEL:
gtk_widget_destroy (GTK_WIDGET (dialog));
gtk_dialog_response (GTK_DIALOG (self->priv->dialog), GTK_RESPONSE_DELETE_EVENT);
break;
case GTK_RESPONSE_OK:
gtk_widget_destroy (GTK_WIDGET (dialog));
gth_task_dialog (GTH_TASK (self), FALSE, NULL);
web_service_get_user_info (self,
self->priv->cancellable,
get_user_info_ready_cb,
self);
break;
default:
break;
}
}
static void
show_authentication_error_dialog (WebService *self,
GError **error)
{
GtkWidget *dialog;
if (g_error_matches (*error, WEB_SERVICE_ERROR, WEB_SERVICE_ERROR_TOKEN_EXPIRED)) {
web_service_ask_authorization (self);
return;
}
dialog = _gtk_message_dialog_new (GTK_WINDOW (self->priv->browser),
GTK_DIALOG_MODAL,
GTK_STOCK_DIALOG_ERROR,
_("Could not connect to the server"),
(*error)->message,
_("Choose _Account..."), WEB_AUTHENTICATION_RESPONSE_CHOOSE_ACCOUNT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
NULL);
gth_task_dialog (GTH_TASK (self), TRUE, dialog);
g_signal_connect (dialog,
"delete-event",
G_CALLBACK (gtk_true),
NULL);
g_signal_connect (dialog,
"response",
G_CALLBACK (authentication_error_dialog_response_cb),
self);
gtk_widget_show (dialog);
g_clear_error (error);
}
static void
pixbuf_task_progress_cb (GthTask *task,
const char *description,
const char *details,
gboolean pulse,
double fraction,
gpointer user_data)
{
GthPixbufListTask *self = user_data;
double total_fraction;
double file_fraction;
total_fraction = ((double) self->priv->n_current + 1) / (self->priv->n_files + 1);
if (pulse)
file_fraction = 0.5;
else
file_fraction = fraction;
if (details == NULL) {
GthFileData *file_data;
file_data = self->priv->current->data;
details = g_file_info_get_display_name (file_data->info);
}
gth_task_progress (GTH_TASK (self),
description,
details,
FALSE,
total_fraction + (file_fraction / (self->priv->n_files + 1)));
}
static void
pixbuf_task_dialog_cb (GthTask *task,
gboolean opened,
gpointer user_data)
{
gth_task_dialog (GTH_TASK (user_data), opened);
}
static void
connect_to_server (DialogData *data)
{
if (data->conn == NULL) {
data->conn = google_connection_new (GOOGLE_SERVICE_PICASA_WEB_ALBUM);
data->progress_dialog = gth_progress_dialog_new (GTK_WINDOW (data->browser));
gth_progress_dialog_add_task (GTH_PROGRESS_DIALOG (data->progress_dialog), GTH_TASK (data->conn));
}
#ifdef HAVE_GNOME_KEYRING
if ((data->password == NULL) && gnome_keyring_is_available ()) {
gnome_keyring_find_password (GNOME_KEYRING_NETWORK_PASSWORD,
find_password_cb,
data,
NULL,
"user", data->email,
"server", "picasaweb.google.com",
"protocol", "http",
NULL);
return;
}
#endif
connect_to_server_step2 (data);
}
void
facebook_service_get_albums (FacebookService *self,
const char *user_id,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GHashTable *data_set;
SoupMessage *msg;
g_return_if_fail (user_id != NULL);
gth_task_progress (GTH_TASK (self->priv->conn), _("Getting the album list"), NULL, TRUE, 0.0);
data_set = g_hash_table_new (g_str_hash, g_str_equal);
g_hash_table_insert (data_set, "method", "facebook.photos.getAlbums");
g_hash_table_insert (data_set, "uid", (char *) user_id);
facebook_connection_add_api_sig (self->priv->conn, data_set);
msg = soup_form_request_new_from_hash ("GET", FACEBOOK_HTTPS_REST_SERVER, data_set);
facebook_connection_send_message (self->priv->conn,
msg,
cancellable,
callback,
user_data,
facebook_service_get_albums,
get_albums_ready_cb,
self);
g_hash_table_destroy (data_set);
}
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 void
reorder_done_cb (GObject *object,
GError *error,
gpointer user_data)
{
gth_task_completed (GTH_TASK (user_data), error);
}
static void
upload_photo_wrote_body_data_cb (SoupMessage *msg,
SoupBuffer *chunk,
gpointer user_data)
{
PicasaWebService *self = user_data;
GthFileData *file_data;
char *details;
double current_file_fraction;
if (self->priv->post_photos->current == NULL)
return;
self->priv->post_photos->wrote_body_data_size += chunk->length;
if (self->priv->post_photos->wrote_body_data_size > msg->request_body->length)
return;
file_data = self->priv->post_photos->current->data;
/* Translators: %s is a filename */
details = g_strdup_printf (_("Uploading '%s'"), g_file_info_get_display_name (file_data->info));
current_file_fraction = (double) self->priv->post_photos->wrote_body_data_size / msg->request_body->length;
gth_task_progress (GTH_TASK (self),
NULL,
details,
FALSE,
(double) (self->priv->post_photos->uploaded_size + (g_file_info_get_size (file_data->info) * current_file_fraction)) / self->priv->post_photos->total_size);
g_free (details);
}
static void
photoset_combobox_changed_cb (GtkComboBox *widget,
gpointer user_data)
{
DialogData *data = user_data;
GtkTreeIter iter;
if (! gtk_combo_box_get_active_iter (widget, &iter)) {
gth_file_list_clear (GTH_FILE_LIST (data->file_list), _("No album selected"));
return;
}
_g_object_unref (data->photoset);
gtk_tree_model_get (gtk_combo_box_get_model (widget),
&iter,
PHOTOSET_DATA_COLUMN, &data->photoset,
-1);
gth_import_preferences_dialog_set_event (GTH_IMPORT_PREFERENCES_DIALOG (data->preferences_dialog), data->photoset->title);
gth_task_dialog (GTH_TASK (data->service), FALSE, NULL);
flickr_service_list_photos (data->service,
data->photoset,
"original_format, url_sq, url_t, url_s, url_m, url_z, url_b, url_o",
data->cancellable,
list_photos_ready_cb,
data);
}
static void
export_completed_with_success (DialogData *data)
{
GtkWidget *dialog;
gth_task_dialog (GTH_TASK (data->service), TRUE, NULL);
dialog = _gtk_message_dialog_new (GTK_WINDOW (data->browser),
GTK_DIALOG_MODAL,
NULL,
_("Files successfully uploaded to the server."),
NULL,
_GTK_LABEL_CLOSE, GTK_RESPONSE_CLOSE,
_("_Open in the Browser"), _OPEN_IN_BROWSER_RESPONSE,
NULL);
g_signal_connect (dialog,
"delete-event",
G_CALLBACK (gtk_true),
NULL);
g_signal_connect (dialog,
"response",
G_CALLBACK (completed_messagedialog_response_cb),
data);
gtk_window_present (GTK_WINDOW (dialog));
}
void
picasa_web_service_list_albums (PicasaWebService *self,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
OAuthAccount *account;
SoupMessage *msg;
char *url;
account = web_service_get_current_account (WEB_SERVICE (self));
g_return_if_fail (account != NULL);
gth_task_progress (GTH_TASK (self), _("Getting the album list"), NULL, TRUE, 0.0);
url = g_strconcat ("https://picasaweb.google.com/data/feed/api/user/", account->id, NULL);
msg = soup_message_new ("GET", url);
_picasa_web_service_add_headers (self, msg);
_web_service_send_message (WEB_SERVICE (self),
msg,
cancellable,
callback,
user_data,
picasa_web_service_list_albums,
list_albums_ready_cb,
self);
g_free (url);
}
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
get_request_token_ready_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
OAuthService *self = user_data;
GError *error = NULL;
char *url;
GtkWidget *dialog;
if (! oauth_service_get_request_token_finish (self, result, &error)) {
gth_task_completed (GTH_TASK (self), error);
return;
}
url = self->priv->consumer->get_authorization_url (self);
dialog = oauth_ask_authorization_dialog_new (url);
_gtk_window_resize_to_fit_screen_height (dialog, 1024);
_web_service_set_auth_dialog (WEB_SERVICE (self), GTK_DIALOG (dialog));
g_signal_connect (OAUTH_ASK_AUTHORIZATION_DIALOG (dialog),
"load-request",
G_CALLBACK (ask_authorization_dialog_load_request_cb),
self);
gtk_widget_show (dialog);
g_free (url);
}
static void
album_combobox_changed_cb (GtkComboBox *widget,
gpointer user_data)
{
DialogData *data = user_data;
GtkTreeIter iter;
if (! gtk_combo_box_get_active_iter (widget, &iter)) {
gth_file_list_clear (GTH_FILE_LIST (data->file_list), _("No album selected"));
return;
}
_g_object_unref (data->album);
gtk_tree_model_get (gtk_combo_box_get_model (widget),
&iter,
ALBUM_DATA_COLUMN, &data->album,
-1);
gth_import_preferences_dialog_set_event (GTH_IMPORT_PREFERENCES_DIALOG (data->preferences_dialog), data->album->title);
gth_task_dialog (GTH_TASK (data->service), FALSE, NULL);
picasa_web_service_list_photos (data->service,
data->album,
data->cancellable,
list_photos_ready_cb,
data);
}
static void
photoset_list_ready_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
DialogData *data = user_data;
GError *error = NULL;
GList *scan;
_g_object_list_unref (data->photosets);
data->photosets = flickr_service_list_photosets_finish (FLICKR_SERVICE (source_object), res, &error);
if (error != NULL) {
if (data->service != NULL)
gth_task_dialog (GTH_TASK (data->service), TRUE, NULL);
_gtk_error_dialog_from_gerror_run (GTK_WINDOW (data->browser), _("Could not connect to the server"), error);
g_clear_error (&error);
gtk_dialog_response (GTK_DIALOG (data->dialog), GTK_RESPONSE_DELETE_EVENT);
return;
}
gtk_list_store_clear (GTK_LIST_STORE (GET_WIDGET ("photoset_liststore")));
for (scan = data->photosets; scan; scan = scan->next) {
FlickrPhotoset *photoset = scan->data;
char *n_photos;
GtkTreeIter iter;
n_photos = g_strdup_printf ("(%d)", photoset->n_photos);
gtk_list_store_append (GTK_LIST_STORE (GET_WIDGET ("photoset_liststore")), &iter);
gtk_list_store_set (GTK_LIST_STORE (GET_WIDGET ("photoset_liststore")), &iter,
PHOTOSET_DATA_COLUMN, photoset,
PHOTOSET_ICON_COLUMN, "file-catalog-symbolic",
PHOTOSET_TITLE_COLUMN, photoset->title,
PHOTOSET_N_PHOTOS_COLUMN, n_photos,
-1);
g_free (n_photos);
}
gtk_dialog_set_response_sensitive (GTK_DIALOG (data->dialog), GTK_RESPONSE_OK, TRUE);
gth_task_dialog (GTH_TASK (data->service), TRUE, NULL);
gtk_window_set_transient_for (GTK_WINDOW (data->dialog), GTK_WINDOW (data->browser));
gtk_window_set_modal (GTK_WINDOW (data->dialog), FALSE);
gtk_window_present (GTK_WINDOW (data->dialog));
}
static void
get_albums_ready_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
DialogData *data = user_data;
GError *error = NULL;
GList *scan;
_g_object_list_unref (data->albums);
data->albums = facebook_service_get_albums_finish (data->service, res, &error);
if (error != NULL) {
if (data->service != NULL)
gth_task_dialog (GTH_TASK (data->service), TRUE, NULL);
_gtk_error_dialog_from_gerror_run (GTK_WINDOW (data->browser), _("Could not connect to the server"), error);
g_clear_error (&error);
gtk_widget_destroy (data->dialog);
return;
}
gtk_list_store_clear (GTK_LIST_STORE (GET_WIDGET ("album_liststore")));
for (scan = data->albums; scan; scan = scan->next) {
FacebookAlbum *album = scan->data;
char *n_photos;
GtkTreeIter iter;
n_photos = g_strdup_printf ("(%d)", album->count);
gtk_list_store_append (GTK_LIST_STORE (GET_WIDGET ("album_liststore")), &iter);
gtk_list_store_set (GTK_LIST_STORE (GET_WIDGET ("album_liststore")), &iter,
ALBUM_DATA_COLUMN, album,
ALBUM_ICON_COLUMN, "file-catalog-symbolic",
ALBUM_NAME_COLUMN, album->name,
ALBUM_SIZE_COLUMN, n_photos,
-1);
g_free (n_photos);
}
gth_task_dialog (GTH_TASK (data->service), TRUE, NULL);
gtk_window_set_transient_for (GTK_WINDOW (data->dialog), GTK_WINDOW (data->browser));
gtk_window_set_modal (GTK_WINDOW (data->dialog), FALSE);
gtk_window_present (GTK_WINDOW (data->dialog));
}
static void
connect_to_server_step2 (DialogData *data)
{
if (data->password == NULL) {
gth_task_dialog (GTH_TASK (data->conn), TRUE);
account_properties_dialog (data, data->email);
}
else {
gth_task_dialog (GTH_TASK (data->conn), FALSE);
google_connection_connect (data->conn,
data->email,
data->password,
data->challange,
data->cancellable,
connection_ready_cb,
data);
}
}
static void
list_photos_ready_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
DialogData *data = user_data;
GError *error = NULL;
GList *list;
GList *scan;
gth_task_dialog (GTH_TASK (data->service), TRUE, NULL);
_g_object_list_unref (data->photos);
data->photos = flickr_service_list_photos_finish (data->service, result, &error);
if (error != NULL) {
if (data->service != NULL)
gth_task_dialog (GTH_TASK (data->service), TRUE, NULL);
_gtk_error_dialog_from_gerror_show (GTK_WINDOW (data->browser), _("Could not get the photo list"), error);
g_clear_error (&error);
gtk_widget_destroy (data->dialog);
return;
}
list = NULL;
for (scan = data->photos; scan; scan = scan->next) {
FlickrPhoto *photo = scan->data;
GthFileData *file_data;
if (photo->url[FLICKR_URL_O] == NULL)
continue;
file_data = gth_file_data_new_for_uri (photo->url[FLICKR_URL_O], (photo->mime_type != NULL) ? photo->mime_type : "image/jpeg");
g_file_info_set_file_type (file_data->info, G_FILE_TYPE_REGULAR);
g_file_info_set_size (file_data->info, FAKE_SIZE); /* set a fake size to make the progress dialog work correctly */
g_file_info_set_attribute_object (file_data->info, "flickr::object", G_OBJECT (photo));
list = g_list_prepend (list, file_data);
}
gth_file_list_set_files (GTH_FILE_LIST (data->file_list), list);
update_selection_status (data);
gtk_widget_set_sensitive (GET_WIDGET ("download_button"), list != NULL);
_g_object_list_unref (list);
}
static void
overwrite_dialog_response_cb (GtkDialog *dialog,
gint response_id,
gpointer user_data)
{
GthPixbufListTask *self = user_data;
if (response_id != GTK_RESPONSE_OK)
self->priv->overwrite_response = GTH_OVERWRITE_RESPONSE_UNSPECIFIED;
else
self->priv->overwrite_response = gth_overwrite_dialog_get_response (GTH_OVERWRITE_DIALOG (dialog));
gtk_widget_hide (GTK_WIDGET (dialog));
gth_task_dialog (GTH_TASK (self), FALSE);
switch (self->priv->overwrite_response) {
case GTH_OVERWRITE_RESPONSE_NO:
case GTH_OVERWRITE_RESPONSE_ALWAYS_NO:
case GTH_OVERWRITE_RESPONSE_UNSPECIFIED:
if (self->priv->overwrite_response == GTH_OVERWRITE_RESPONSE_ALWAYS_NO)
self->priv->overwrite_mode = GTH_OVERWRITE_SKIP;
process_next_file (self);
break;
case GTH_OVERWRITE_RESPONSE_YES:
case GTH_OVERWRITE_RESPONSE_ALWAYS_YES:
if (self->priv->overwrite_response == GTH_OVERWRITE_RESPONSE_ALWAYS_YES)
self->priv->overwrite_mode = GTH_OVERWRITE_OVERWRITE;
pixbuf_task_save_current_pixbuf (self, NULL, TRUE);
break;
case GTH_OVERWRITE_RESPONSE_RENAME:
{
GFile *parent;
GFile *new_destination;
if (self->priv->destination_folder != NULL) {
parent = g_object_ref (self->priv->destination_folder);
}
else {
GthFileData *file_data;
file_data = self->priv->current->data;
parent = g_file_get_parent (file_data->file);
}
new_destination = g_file_get_child_for_display_name (parent, gth_overwrite_dialog_get_filename (GTH_OVERWRITE_DIALOG (dialog)), NULL);
pixbuf_task_save_current_pixbuf (self, new_destination, FALSE);
g_object_unref (new_destination);
g_object_unref (parent);
}
break;
}
gtk_widget_destroy (GTK_WIDGET (dialog));
}
static void
post_photos_ready_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
DialogData *data = user_data;
PicasaWebService *picasaweb = PICASA_WEB_SERVICE (source_object);
GError *error = NULL;
gth_task_dialog (GTH_TASK (data->conn), TRUE);
if (! picasa_web_service_post_photos_finish (picasaweb, result, &error)) {
if (data->conn != NULL)
gth_task_dialog (GTH_TASK (data->conn), TRUE);
_gtk_error_dialog_from_gerror_show (GTK_WINDOW (data->browser), _("Could not upload the files"), &error);
return;
}
export_completed_with_success (data);
}
static void
show_export_dialog (DialogData *data)
{
update_account_list (data);
update_album_list (data);
gth_task_dialog (GTH_TASK (data->conn), TRUE);
gtk_window_set_transient_for (GTK_WINDOW (data->dialog), GTK_WINDOW (data->browser));
gtk_window_set_modal (GTK_WINDOW (data->dialog), FALSE);
gtk_window_present (GTK_WINDOW (data->dialog));
}
