static void
photos_selection_toolbar_delete (PhotosSelectionToolbar *self)
{
GList *items = NULL;
GList *selection;
GList *l;
if (!photos_selection_controller_get_selection_mode (self->sel_cntrlr))
return;
selection = photos_selection_controller_get_selection (self->sel_cntrlr);
for (l = selection; l != NULL; l = l->next)
{
PhotosBaseItem *item;
const gchar *urn = (gchar *) l->data;
item = PHOTOS_BASE_ITEM (photos_base_manager_get_object_by_id (self->item_mngr, urn));
items = g_list_prepend (items, g_object_ref (item));
}
/* Removing an item from the item manager changes the selection, so
* we can't use the selection while removing items.
*/
for (l = items; l != NULL; l = l->next)
{
PhotosBaseItem *item = PHOTOS_BASE_ITEM (l->data);
photos_base_manager_remove_object (self->item_mngr, G_OBJECT (item));
}
photos_delete_notification_new (items);
photos_selection_controller_set_selection_mode (self->sel_cntrlr, FALSE);
g_list_free_full (items, g_object_unref);
}
static void
photos_item_manager_changes_pending_foreach (gpointer key, gpointer value, gpointer user_data)
{
PhotosItemManager *self = PHOTOS_ITEM_MANAGER (user_data);
PhotosTrackerChangeEvent *change_event = (PhotosTrackerChangeEvent *) value;
PhotosTrackerChangeEventType change_type;
const gchar *change_urn;
change_type = photos_tracker_change_event_get_type (change_event);
change_urn = photos_tracker_change_event_get_urn (change_event);
if (change_type == PHOTOS_TRACKER_CHANGE_EVENT_CHANGED)
{
GObject *object;
object = photos_base_manager_get_object_by_id (PHOTOS_BASE_MANAGER (self), change_urn);
if (object != NULL)
photos_base_item_refresh (PHOTOS_BASE_ITEM (object));
}
else if (change_type == PHOTOS_TRACKER_CHANGE_EVENT_CREATED)
{
photos_item_manager_item_created (self, change_urn);
}
else if (change_type == PHOTOS_TRACKER_CHANGE_EVENT_DELETED)
{
GObject *object;
object = photos_base_manager_get_object_by_id (PHOTOS_BASE_MANAGER (self), change_urn);
if (object != NULL)
{
photos_base_item_destroy (PHOTOS_BASE_ITEM (object));
photos_base_manager_remove_object_by_id (PHOTOS_BASE_MANAGER (self), change_urn);
}
}
}
static void
photos_selection_toolbar_trash_clicked (GtkButton *button, gpointer user_data)
{
PhotosSelectionToolbar *self = PHOTOS_SELECTION_TOOLBAR (user_data);
PhotosSelectionToolbarPrivate *priv = self->priv;
GList *items = NULL;
GList *selection;
GList *l;
selection = photos_selection_controller_get_selection (priv->sel_cntrlr);
for (l = selection; l != NULL; l = l->next)
{
PhotosBaseItem *item;
const gchar *urn = (gchar *) l->data;
item = PHOTOS_BASE_ITEM (photos_base_manager_get_object_by_id (priv->item_mngr, urn));
items = g_list_prepend (items, g_object_ref (item));
}
/* Removing an item from the item manager changes the selection, so
* we can't use the selection while removing items.
*/
for (l = items; l != NULL; l = l->next)
{
PhotosBaseItem *item = PHOTOS_BASE_ITEM (l->data);
photos_base_manager_remove_object (priv->item_mngr, G_OBJECT (item));
}
photos_delete_notification_new (items);
photos_selection_controller_set_selection_mode (priv->sel_cntrlr, FALSE);
g_list_free_full (items, g_object_unref);
}
static void
photos_view_container_item_activated (PhotosViewContainer *self, const gchar * id, const GtkTreePath *path)
{
PhotosViewContainerPrivate *priv = self->priv;
GObject *object;
priv->current_path = gtk_tree_path_copy (path);
object = photos_base_manager_get_object_by_id (priv->item_mngr, id);
if (!photos_base_item_is_collection (PHOTOS_BASE_ITEM (object)) &&
photos_remote_display_manager_is_active (priv->remote_mngr))
photos_remote_display_manager_render (priv->remote_mngr, PHOTOS_BASE_ITEM (object));
else
photos_base_manager_set_active_object (priv->item_mngr, object);
}
static void
photos_item_manager_add_object (PhotosBaseManager *mngr, GObject *object)
{
PhotosItemManager *self = PHOTOS_ITEM_MANAGER (mngr);
PhotosBaseItem *item;
const gchar *id;
gpointer *old_collection;
g_return_if_fail (PHOTOS_IS_BASE_ITEM (object));
item = PHOTOS_BASE_ITEM (object);
if (!photos_base_item_is_collection (item))
goto end;
id = photos_filterable_get_id (PHOTOS_FILTERABLE (item));
if (id == NULL)
goto end;
old_collection = g_hash_table_lookup (self->collections, id);
if (old_collection != NULL)
goto end;
g_hash_table_insert (self->collections, g_strdup (id), g_object_ref (item));
end:
PHOTOS_BASE_MANAGER_CLASS (photos_item_manager_parent_class)->add_object (mngr, object);
}
static void
photos_item_manager_item_load (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
PhotosItemManager *self = PHOTOS_ITEM_MANAGER (user_data);
GError *error;
GeglNode *node = NULL;
PhotosBaseItem *item = PHOTOS_BASE_ITEM (source_object);
g_clear_object (&self->loader_cancellable);
error = NULL;
node = photos_base_item_load_finish (item, res, &error);
if (error != NULL)
{
if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
g_warning ("Unable to load the item: %s", error->message);
self->load_state = PHOTOS_LOAD_STATE_ERROR;
g_error_free (error);
}
else
{
self->load_state = PHOTOS_LOAD_STATE_FINISHED;
}
g_signal_emit (self, signals[LOAD_FINISHED], 0, item, node);
g_clear_object (&node);
g_object_unref (self);
}
static void
photos_export_dialog_guess_sizes (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
PhotosExportDialog *self;
PhotosBaseItem *item = PHOTOS_BASE_ITEM (source_object);
GError *error;
gchar *size_str;
gsize sizes[2];
error = NULL;
if (!photos_base_item_save_guess_sizes_finish (item, res, &sizes[0], &sizes[1], &error))
{
if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
g_warning ("Unable to guess sizes: %s", error->message);
g_error_free (error);
return;
}
self = PHOTOS_EXPORT_DIALOG (user_data);
size_str = g_format_size ((guint64) sizes[0]);
gtk_label_set_text (GTK_LABEL (self->full_label), size_str);
g_free (size_str);
if (self->reduced_zoom > 0.0)
{
gsize reduced_size;
reduced_size = (gsize) (sizes[1] + (sizes[0] - sizes[1]) * (self->reduced_zoom - 0.5) / (1.0 - 0.5) + 0.5);
size_str = g_format_size ((guint64) reduced_size);
gtk_label_set_text (GTK_LABEL (self->reduced_label), size_str);
g_free (size_str);
}
}
static void
photos_preview_nav_buttons_update_visibility (PhotosPreviewNavButtons *self)
{
PhotosBaseItem *item;
PhotosBaseItem *next_item;
PhotosBaseItem *previous_item;
item = PHOTOS_BASE_ITEM (photos_base_manager_get_active_object (self->item_mngr));
if (self->old_mode == PHOTOS_WINDOW_MODE_NONE || item == NULL || !self->visible)
{
self->enable_prev = FALSE;
self->enable_next = FALSE;
goto out;
}
previous_item = photos_preview_nav_buttons_get_previous_item (self);
self->enable_prev = previous_item != NULL;
next_item = photos_preview_nav_buttons_get_next_item (self);
self->enable_next = next_item != NULL;
out:
if (self->visible_internal && self->enable_next)
photos_preview_nav_buttons_fade_in_button (self, self->next_widget);
else
photos_preview_nav_buttons_fade_out_button (self, self->next_widget);
if (self->visible_internal && self->enable_prev)
photos_preview_nav_buttons_fade_in_button (self, self->prev_widget);
else
photos_preview_nav_buttons_fade_out_button (self, self->prev_widget);
g_simple_action_set_enabled (G_SIMPLE_ACTION (self->load_next), self->enable_next);
g_simple_action_set_enabled (G_SIMPLE_ACTION (self->load_previous), self->enable_prev);
}
static void
photos_preview_nav_buttons_delete (PhotosPreviewNavButtons *self)
{
GList *items = NULL;
PhotosBaseItem *item;
PhotosWindowMode mode;
mode = photos_mode_controller_get_window_mode (self->mode_cntrlr);
if (mode != PHOTOS_WINDOW_MODE_PREVIEW)
return;
item = PHOTOS_BASE_ITEM (photos_base_manager_get_active_object (self->item_mngr));
if (item == NULL)
return;
if (self->enable_next)
g_action_activate (self->load_next, NULL);
else if (self->enable_prev)
g_action_activate (self->load_previous, NULL);
else
photos_mode_controller_go_back (self->mode_cntrlr);
items = g_list_prepend (items, g_object_ref (item));
photos_base_manager_remove_object (self->item_mngr, G_OBJECT (item));
photos_delete_notification_new (items);
g_list_free_full (items, g_object_unref);
}
static void
photos_base_item_create_thumbnail_in_thread_func (gpointer data, gpointer user_data)
{
GTask *task = G_TASK (data);
PhotosBaseItem *self;
GCancellable *cancellable;
GError *error;
gboolean op_res;
self = PHOTOS_BASE_ITEM (g_task_get_source_object (task));
cancellable = g_task_get_cancellable (task);
error = NULL;
op_res = PHOTOS_BASE_ITEM_GET_CLASS (self)->create_thumbnail (self, cancellable, &error);
if (error != NULL)
{
g_task_return_error (task, error);
goto out;
}
g_task_return_boolean (task, op_res);
out:
g_object_unref (task);
}
static void
photos_application_set_bg_download (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
PhotosApplication *self = PHOTOS_APPLICATION (user_data);
PhotosApplicationPrivate *priv = self->priv;
PhotosBaseItem *item = PHOTOS_BASE_ITEM (source_object);
GError *error;
gchar *filename = NULL;
error = NULL;
filename = photos_base_item_download_finish (item, res, &error);
if (error != NULL)
{
const gchar *uri;
uri = photos_base_item_get_uri (item);
g_warning ("Unable to extract the local filename for %s", uri);
g_error_free (error);
goto out;
}
g_settings_set_string (priv->settings, "picture-uri", filename);
g_settings_set_enum (priv->settings, "picture-options", G_DESKTOP_BACKGROUND_STYLE_ZOOM);
g_settings_set_enum (priv->settings, "color-shading-type", G_DESKTOP_BACKGROUND_SHADING_SOLID);
g_settings_set_string (priv->settings, "primary-color", "#000000000000");
g_settings_set_string (priv->settings, "secondary-color", "#000000000000");
out:
g_free (filename);
g_object_unref (self);
}
static void
photos_base_item_download_in_thread_func (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
PhotosBaseItem *self = PHOTOS_BASE_ITEM (source_object);
PhotosBaseItemPrivate *priv = self->priv;
GError *error;
gchar *path;
g_mutex_lock (&priv->mutex_download);
error = NULL;
path = photos_base_item_download (self, cancellable, &error);
if (error != NULL)
{
g_task_return_error (task, error);
goto out;
}
g_task_return_pointer (task, path, g_free);
out:
g_mutex_unlock (&priv->mutex_download);
}
static void
photos_base_item_file_query_info (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
PhotosBaseItem *self = PHOTOS_BASE_ITEM (user_data);
PhotosBaseItemPrivate *priv = self->priv;
GError *error = NULL;
GFile *file = G_FILE (source_object);
GFileInfo *info;
info = g_file_query_info_finish (file, res, &error);
if (error != NULL)
{
g_warning ("Unable to query info for file at %s: %s", priv->uri, error->message);
priv->failed_thumbnailing = TRUE;
photos_base_item_set_failed_icon (self);
g_error_free (error);
goto out;
}
priv->thumb_path = g_file_info_get_attribute_byte_string (info, G_FILE_ATTRIBUTE_THUMBNAIL_PATH);
if (priv->thumb_path != NULL)
photos_base_item_refresh_thumb_path (self);
else
{
photos_base_item_create_thumbnail_async (self,
NULL,
photos_base_item_create_thumbnail_cb,
g_object_ref (file));
}
out:
g_object_unref (self);
}
static void
photos_selection_toolbar_favorite_clicked (GtkButton *button, gpointer user_data)
{
PhotosSelectionToolbar *self = PHOTOS_SELECTION_TOOLBAR (user_data);
PhotosSelectionToolbarPrivate *priv = self->priv;
GList *selection;
GList *l;
if (priv->inside_refresh)
return;
selection = photos_selection_controller_get_selection (priv->sel_cntrlr);
for (l = selection; l != NULL; l = l->next)
{
const gchar *urn = (gchar *) l->data;
PhotosBaseItem *item;
gboolean favorite;
item = PHOTOS_BASE_ITEM (photos_base_manager_get_object_by_id (priv->item_mngr, urn));
favorite = photos_base_item_is_favorite (item);
photos_base_item_set_favorite (item, !favorite);
}
photos_selection_controller_set_selection_mode (priv->sel_cntrlr, FALSE);
}
static void
photos_base_item_load_in_thread_func (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
PhotosBaseItem *self = PHOTOS_BASE_ITEM (source_object);
PhotosBaseItemPrivate *priv = self->priv;
GeglNode *node;
GError *error = NULL;
g_mutex_lock (&priv->mutex);
node = photos_base_item_load (self, cancellable, &error);
if (error != NULL)
{
g_task_return_error (task, error);
goto out;
}
g_task_return_pointer (task, node, g_object_unref);
out:
g_mutex_unlock (&priv->mutex);
}
static void
photos_base_item_refresh_thumb_path_read (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
PhotosBaseItem *self = PHOTOS_BASE_ITEM (user_data);
PhotosBaseItemPrivate *priv = self->priv;
GError *error = NULL;
GFile *file = G_FILE (source_object);
GFileInputStream *stream;
stream = g_file_read_finish (file, res, &error);
if (error != NULL)
{
gchar *uri;
uri = g_file_get_uri (file);
g_warning ("Unable to read file at %s: %s", uri, error->message);
priv->failed_thumbnailing = TRUE;
priv->thumb_path = NULL;
g_file_delete_async (file, G_PRIORITY_DEFAULT, NULL, NULL, NULL);
photos_base_item_set_failed_icon (self);
g_free (uri);
g_error_free (error);
goto out;
}
g_object_set_data_full (G_OBJECT (stream), "file", g_object_ref (file), g_object_unref);
gdk_pixbuf_new_from_stream_async (G_INPUT_STREAM (stream),
NULL,
photos_base_item_refresh_thumb_path_pixbuf,
g_object_ref (self));
g_object_unref (stream);
out:
g_object_unref (self);
}
static void
photos_base_item_print_load (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
PhotosBaseItem *self = PHOTOS_BASE_ITEM (source_object);
GtkWindow *toplevel = GTK_WINDOW (user_data);
GeglNode *node;
GtkPrintOperation *print_op;
node = photos_base_item_load_finish (self, res, NULL);
if (node == NULL)
goto out;
print_op = photos_print_operation_new (self, node);
g_signal_connect_data (print_op,
"done",
G_CALLBACK (photos_base_item_print_operation_done),
g_object_ref (self),
(GClosureNotify) g_object_unref,
G_CONNECT_SWAPPED);
/* It is self managing. */
photos_print_notification_new (print_op);
gtk_print_operation_run (print_op, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG, toplevel, NULL);
out:
g_clear_object (&node);
g_object_unref (toplevel);
}
static void
photos_base_item_create_thumbnail_cb (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
PhotosBaseItem *self = PHOTOS_BASE_ITEM (source_object);
PhotosBaseItemPrivate *priv = self->priv;
GError *error;
GFile *file = G_FILE (user_data);
error = NULL;
photos_base_item_create_thumbnail_finish (self, res, &error);
if (error != NULL)
{
priv->failed_thumbnailing = TRUE;
g_warning ("Unable to create thumbnail: %s", error->message);
photos_base_item_set_failed_icon (self);
g_error_free (error);
goto out;
}
g_file_query_info_async (file,
G_FILE_ATTRIBUTE_THUMBNAIL_PATH,
G_FILE_QUERY_INFO_NONE,
G_PRIORITY_DEFAULT,
NULL,
photos_base_item_thumbnail_path_info,
g_object_ref (self));
out:
g_object_unref (file);
}
static void
photos_import_dialog_collections_popover_search_changed (PhotosImportDialog *self)
{
guint16 text_length;
gtk_container_foreach (GTK_CONTAINER (self->collections_popover_grid), (GtkCallback) gtk_widget_destroy, NULL);
text_length = gtk_entry_get_text_length (GTK_ENTRY (self->collections_popover_search_entry));
if (text_length == 0)
{
GList *l;
for (l = self->recent_collections; l != NULL; l = l->next)
{
GtkWidget *collection_button;
PhotosBaseItem *collection = PHOTOS_BASE_ITEM (l->data);
collection_button = photos_import_dialog_create_collection_button (collection);
gtk_container_add (GTK_CONTAINER (self->collections_popover_grid), collection_button);
gtk_widget_show_all (collection_button);
}
}
else
{
g_autoptr (GArray) matches = NULL;
const gchar *text;
guint i;
text = gtk_entry_get_text (GTK_ENTRY (self->collections_popover_search_entry));
matches = dzl_fuzzy_mutable_index_match (self->index, text, MAX_MATCHES);
for (i = 0; i < matches->len; i++)
{
const DzlFuzzyMutableIndexMatch *match;
GtkWidget *collection_button;
PhotosBaseItem *collection;
match = &g_array_index (matches, DzlFuzzyMutableIndexMatch, i);
collection = PHOTOS_BASE_ITEM (match->value);
collection_button = photos_import_dialog_create_collection_button (collection);
gtk_container_add (GTK_CONTAINER (self->collections_popover_grid), collection_button);
gtk_widget_show_all (collection_button);
}
g_return_if_fail (matches->len <= MAX_MATCHES);
}
}
static void
photos_facebook_item_constructed (GObject *object)
{
PhotosFacebookItem *self = PHOTOS_FACEBOOK_ITEM (object);
G_OBJECT_CLASS (photos_facebook_item_parent_class)->constructed (object);
photos_base_item_set_default_app_name (PHOTOS_BASE_ITEM (self), _("Facebook"));
}
static PhotosBaseItem *
photos_preview_nav_buttons_get_previous_item (PhotosPreviewNavButtons *self)
{
PhotosBaseItem *item;
PhotosBaseItem *previous_item;
PhotosBaseManager *item_mngr_chld;
item = PHOTOS_BASE_ITEM (photos_base_manager_get_active_object (self->item_mngr));
item_mngr_chld = photos_item_manager_get_for_mode (PHOTOS_ITEM_MANAGER (self->item_mngr), self->old_mode);
do
{
previous_item = PHOTOS_BASE_ITEM (photos_base_manager_get_previous_object (item_mngr_chld, G_OBJECT (item)));
item = previous_item;
} while (item != NULL && photos_base_item_is_collection (item));
return previous_item;
}
static gint
photos_base_item_create_thumbnail_sort_func (gconstpointer a, gconstpointer b, gpointer user_data)
{
GTask *task_a = G_TASK (a);
GTask *task_b = G_TASK (b);
PhotosBaseItem *item_a;
PhotosBaseItem *item_b;
gint ret_val = 0;
item_a = PHOTOS_BASE_ITEM (g_task_get_source_object (task_a));
item_b = PHOTOS_BASE_ITEM (g_task_get_source_object (task_b));
if (PHOTOS_IS_LOCAL_ITEM (item_a))
ret_val = -1;
else if (PHOTOS_IS_LOCAL_ITEM (item_b))
ret_val = 1;
return ret_val;
}
static void
photos_base_item_constructed (GObject *object)
{
PhotosBaseItem *self = PHOTOS_BASE_ITEM (object);
PhotosBaseItemPrivate *priv = self->priv;
G_OBJECT_CLASS (photos_base_item_parent_class)->constructed (object);
photos_base_item_populate_from_cursor (self, priv->cursor);
g_clear_object (&priv->cursor); /* We will not need it any more */
}
static void
photos_application_set_bg (PhotosApplication *self)
{
PhotosBaseItem *item;
item = PHOTOS_BASE_ITEM (photos_base_manager_get_active_object (self->priv->item_mngr));
if (item == NULL)
return;
photos_base_item_download_async (item, NULL, photos_application_set_bg_download, g_object_ref (self));
}
static gchar *
photos_collection_manager_get_where (PhotosBaseManager *mngr, gint flags)
{
GObject *collection;
collection = photos_base_manager_get_active_object (mngr);
if (collection == NULL)
return g_strdup ("");
return photos_base_item_get_where (PHOTOS_BASE_ITEM (collection));
}
static void
photos_preview_nav_buttons_active_changed (PhotosPreviewNavButtons *self, GObject *object)
{
PhotosBaseItem *item = PHOTOS_BASE_ITEM (object);
gboolean favorite;
if (object == NULL)
return;
favorite = photos_base_item_is_favorite (item);
photos_preview_nav_buttons_update_favorite (self, favorite);
}
static void
photos_delete_notification_constructed (GObject *object)
{
PhotosDeleteNotification *self = PHOTOS_DELETE_NOTIFICATION (object);
gchar *msg;
GtkWidget *close;
GtkWidget *image;
GtkWidget *label;
GtkWidget *undo;
guint length;
G_OBJECT_CLASS (photos_delete_notification_parent_class)->constructed (object);
length = g_list_length (self->items);
if (length == 1)
{
const gchar *name;
name = photos_base_item_get_name_with_fallback (PHOTOS_BASE_ITEM (self->items->data));
msg = g_strdup_printf (_("“%s” deleted"), name);
}
else
msg = g_strdup_printf (ngettext ("%d item deleted", "%d items deleted", length), length);
label = gtk_label_new (msg);
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_hexpand (label, TRUE);
gtk_container_add (GTK_CONTAINER (self), label);
g_free (msg);
undo = gtk_button_new_with_label (_("Undo"));
gtk_widget_set_valign (undo, GTK_ALIGN_CENTER);
gtk_container_add (GTK_CONTAINER (self), undo);
g_signal_connect_swapped (undo, "clicked", G_CALLBACK (photos_delete_notification_undo_clicked), self);
image = gtk_image_new_from_icon_name (PHOTOS_ICON_WINDOW_CLOSE_SYMBOLIC, GTK_ICON_SIZE_INVALID);
gtk_widget_set_margin_bottom (image, 2);
gtk_widget_set_margin_top (image, 2);
gtk_image_set_pixel_size (GTK_IMAGE (image), 16);
close = gtk_button_new ();
gtk_widget_set_valign (close, GTK_ALIGN_CENTER);
gtk_button_set_focus_on_click (GTK_BUTTON (close), FALSE);
gtk_button_set_relief (GTK_BUTTON (close), GTK_RELIEF_NONE);
gtk_button_set_image (GTK_BUTTON (close), image);
gtk_container_add (GTK_CONTAINER (self), close);
g_signal_connect_swapped (close, "clicked", G_CALLBACK (photos_delete_notification_delete_items), self);
photos_notification_manager_add_notification (PHOTOS_NOTIFICATION_MANAGER (self->ntfctn_mngr),
GTK_WIDGET (self));
self->timeout_id = g_timeout_add_seconds (DELETE_TIMEOUT, photos_delete_notification_timeout, self);
}
static void
photos_application_print_current (PhotosApplication *self)
{
PhotosApplicationPrivate *priv = self->priv;
PhotosBaseItem *item;
item = PHOTOS_BASE_ITEM (photos_base_manager_get_active_object (priv->item_mngr));
if (item == NULL)
return;
photos_base_item_print (item, priv->main_window);
}
static void
photos_export_dialog_guess_sizes (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
PhotosExportDialog *self;
PhotosBaseItem *item = PHOTOS_BASE_ITEM (source_object);
PhotosBaseItemSize full;
PhotosBaseItemSize reduced;
gboolean success;
{
g_autoptr (GError) error = NULL;
success = photos_base_item_guess_save_sizes_finish (item, res, &full, &reduced, &error);
if (error != NULL)
{
if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
goto out;
g_warning ("Unable to guess sizes: %s", error->message);
}
}
self = PHOTOS_EXPORT_DIALOG (user_data);
if (success)
{
{
g_autofree gchar *size_str = NULL;
g_autofree gchar *size_str_markup = NULL;
size_str = photos_export_dialog_create_size_str (full.height, full.width, (guint64) full.bytes);
size_str_markup = g_strdup_printf ("<small>%s</small>", size_str);
gtk_label_set_markup (GTK_LABEL (self->full_label), size_str_markup);
}
self->reduced_zoom = reduced.zoom;
if (self->reduced_zoom > 0.0)
{
g_autofree gchar *size_str = NULL;
g_autofree gchar *size_str_markup = NULL;
size_str = photos_export_dialog_create_size_str (reduced.height, reduced.width, (guint64) reduced.bytes);
size_str_markup = g_strdup_printf ("<small>%s</small>", size_str);
gtk_label_set_markup (GTK_LABEL (self->reduced_label), size_str_markup);
}
}
photos_export_dialog_show_size_options (self, self->reduced_zoom > 0.0, FALSE);
out:
return;
}
static void
photos_base_item_refresh_executed (TrackerSparqlCursor *cursor, gpointer user_data)
{
PhotosBaseItem *self = PHOTOS_BASE_ITEM (user_data);
if (cursor == NULL)
goto out;
photos_base_item_populate_from_cursor (self, cursor);
out:
g_object_unref (self);
}
