static void
add_file_to_dialog (gpointer data, gpointer user_data)
{
CopyThemeDialogPrivate *priv;
GFile *file;
gchar *basename = NULL, *raw_basename;
priv = COPY_THEME_DIALOG (user_data)->priv;
file = G_FILE (data);
raw_basename = g_file_get_basename (file);
if (g_str_has_suffix (raw_basename, ".desktop"))
{
/* FIXME: validate key file? */
basename = g_strndup (raw_basename,
/* 8 = strlen (".desktop") */
strlen (raw_basename) - 8);
}
g_free (raw_basename);
if (basename)
{
g_object_ref (file);
priv->all_files = g_slist_append (priv->all_files, file);
priv->all_basenames = g_slist_append (priv->all_basenames, basename);
priv->total_files++;
}
else
{
GtkWidget *dialog;
gchar *uri;
dialog = gtk_message_dialog_new (GTK_WINDOW (user_data),
GTK_DIALOG_MODAL,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK,
_("Invalid screensaver theme"));
uri = g_file_get_uri (file);
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
_("%s does not appear to be a valid screensaver theme."),
uri);
g_free (uri);
gtk_window_set_title (GTK_WINDOW (dialog), "");
gtk_window_set_icon_name (GTK_WINDOW (dialog), "preferences-desktop-screensaver");
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
}
}
static void on_file_replace_ready (GObject *object, GAsyncResult *res, gpointer data)
{
GError *error = NULL;
GDownloadable *download = G_DOWNLOADABLE (data);
GioDownload *gio_download = GIO_DOWNLOAD (data);
g_assert (download != NULL);
gio_download->priv->output = g_file_replace_finish (G_FILE(object), res, &error);
// GFileOutputStream *out_stream = g_file_replace_finish (G_FILE(object), res, &error);
// gio_download->priv->output = g_buffered_output_stream_new_sized (G_OUTPUT_STREAM(out_stream),
// CHUNK_BUFF_SIZE);
handle_critical_error (error);
read_input_stream (download);
}
void
fr_file_selector_dialog_set_selected_files (FrFileSelectorDialog *self,
GList *files)
{
GFile *folder;
if (files == NULL)
return;
folder = g_file_get_parent (G_FILE (files->data));
_set_current_folder (self, folder, files);
g_object_unref (folder);
}
static void
photos_thumbnailer_generate_thumbnail_replace (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
GCancellable *cancellable;
GFile *thumbnail_file = G_FILE (source_object);
g_autoptr (GFileOutputStream) stream = NULL;
g_autoptr (GTask) task = G_TASK (user_data);
PhotosThumbnailerGenerateData *data;
const gchar *prgname;
g_autofree gchar *original_height_str = NULL;
g_autofree gchar *original_width_str = NULL;
g_autofree gchar *uri = NULL;
cancellable = g_task_get_cancellable (task);
data = g_task_get_task_data (task);
{
g_autoptr (GError) error = NULL;
stream = g_file_replace_finish (thumbnail_file, res, &error);
if (error != NULL)
{
g_task_return_error (task, g_steal_pointer (&error));
goto out;
}
}
g_assert_null (data->stream);
data->stream = g_object_ref (stream);
original_height_str = g_strdup_printf ("%" G_GINT64_FORMAT, data->original_height);
original_width_str = g_strdup_printf ("%" G_GINT64_FORMAT, data->original_width);
prgname = g_get_prgname ();
uri = g_file_get_uri (data->file);
gdk_pixbuf_save_to_stream_async (data->pixbuf_thumbnail,
G_OUTPUT_STREAM (stream),
"png",
cancellable,
photos_thumbnailer_generate_thumbnail_save_to_stream,
g_object_ref (task),
"tEXt::Software", prgname,
"tEXt::Thumb::URI", uri,
"tEXt::Thumb::Image::Height", original_height_str,
"tEXt::Thumb::Image::Width", original_width_str,
NULL);
out:
return;
}
static void
async_ready_func (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
const gchar *filename = user_data;
GError *error = NULL;
guint64 disk_usage;
guint64 num_dirs;
guint64 num_files;
g_file_measure_disk_usage_finish (G_FILE (source), result, &disk_usage, &num_dirs, &num_files, &error);
print_result (filename, disk_usage, num_dirs, num_files, error, '\n');
outstanding_asyncs--;
}
static void g_file_copy_async_finish_handler(GObject *source_object,
GAsyncResult *res, gpointer user_data)
{
GtkProgressBar *progress_bar = GTK_PROGRESS_BAR(user_data);
COPY_ASYNC_FINISH = g_file_copy_finish(G_FILE(source_object), res, NULL);
gtk_progress_bar_set_show_text(progress_bar,TRUE);
gtk_progress_bar_set_text(progress_bar, "Finished");
gtk_progress_bar_set_fraction(progress_bar, 1.0);
g_debug("_copy_files_async_true Finished");
GtkWidget *parent = gtk_widget_get_parent((GtkWidget *)progress_bar);
gtk_widget_destroy((GtkWidget *)progress_bar);
gtk_widget_destroy(parent);
}
static void
create_thumbnail (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
GFile *file = G_FILE (source_object);
GnomeDesktopThumbnailFactory *factory = NULL;
GError *error = NULL;
GFileInfo *info = NULL;
gchar *uri = NULL;
GdkPixbuf *pixbuf = NULL;
guint64 mtime;
uri = g_file_get_uri (file);
info = g_file_query_info (file, ATTRIBUTES_FOR_THUMBNAIL,
G_FILE_QUERY_INFO_NONE,
NULL, &error);
if (info == NULL)
{
g_task_return_error (task, error);
goto out;
}
mtime = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_TIME_MODIFIED);
factory = gnome_desktop_thumbnail_factory_new (GNOME_DESKTOP_THUMBNAIL_SIZE_LARGE);
pixbuf = gnome_desktop_thumbnail_factory_generate_thumbnail
(factory,
uri, g_file_info_get_content_type (info));
if (pixbuf == NULL)
{
g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_FAILED, "GnomeDesktopThumbnailFactory failed");
goto out;
}
gnome_desktop_thumbnail_factory_save_thumbnail (factory, pixbuf, uri, (time_t) mtime);
g_task_return_boolean (task, TRUE);
out:
g_clear_object (&info);
g_clear_object (&factory);
g_clear_object (&pixbuf);
g_free (uri);
}
static void
copy_finished_cb (GObject *source_object,
GAsyncResult *result,
gpointer pointer)
{
GError *err = NULL;
CcBackgroundPanel *panel = (CcBackgroundPanel *) pointer;
CcBackgroundPanelPrivate *priv = panel->priv;
CcBackgroundItem *item;
if (!g_file_copy_finish (G_FILE (source_object), result, &err))
{
if (err->code != G_IO_ERROR_CANCELLED)
g_warning ("Failed to copy image to cache location: %s", err->message);
g_error_free (err);
}
item = g_object_get_data (source_object, "item");
g_settings_apply (priv->settings);
/* the panel may have been destroyed before the callback is run, so be sure
* to check the widgets are not NULL */
if (priv->spinner)
{
gtk_widget_destroy (GTK_WIDGET (priv->spinner));
priv->spinner = NULL;
}
if (priv->current_background)
cc_background_item_load (priv->current_background, NULL);
if (priv->builder)
{
char *filename;
update_preview (priv, item);
/* Save the source XML if there is one */
filename = get_save_path ();
if (create_save_dir ())
cc_background_xml_save (priv->current_background, filename);
}
/* remove the reference taken when the copy was set up */
g_object_unref (panel);
}
static void on_size_query_ready (GObject * object, GAsyncResult * result, gpointer data)
{
GError *error = NULL;
GFileInfo *info = g_file_query_info_finish (G_FILE(object), result, &error);
GDownloadable *download = G_DOWNLOADABLE(data);
g_assert (download != NULL);
if (error) {
handle_error (error);
g_downloadable_set_status (download, G_DOWNLOADABLE_NETWORK_ERROR);
} else {
download->priv->size = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_STANDARD_SIZE);
g_object_unref (info);
}
}
static void
on_replace_file_ready (GObject *source, GAsyncResult *res, gpointer user_data)
{
GcrCertificateExporter *self = GCR_CERTIFICATE_EXPORTER (user_data);
GFile *file = G_FILE (source);
GFileOutputStream *os;
os = g_file_replace_finish (file, res, &self->pv->error);
if (self->pv->error) {
complete_async_result (self);
return;
}
write_to_outputstream (self, G_OUTPUT_STREAM (os));
}
void TrashLauncherIcon::UpdateTrashIconCb(GObject* source, GAsyncResult* res, gpointer data)
{
auto self = static_cast<TrashLauncherIcon*>(data);
// FIXME: should use the generic LoadIcon function (not taking from the unity theme)
glib::Object<GFileInfo> info(g_file_query_info_finish(G_FILE(source), res, nullptr));
if (info)
{
glib::Object<GIcon> icon(g_file_info_get_icon(info), glib::AddRef());
glib::String icon_string(g_icon_to_string(icon));
self->icon_name = icon_string.Str();
self->empty_ = (self->icon_name == "user-trash");
}
}
static void
copy_wallpaper_ready_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
WallpaperData *wdata = user_data;
GError *error = NULL;
if (! g_file_copy_finish (G_FILE (source_object), res, &error)) {
_gtk_error_dialog_from_gerror_run (GTK_WINDOW (wdata->browser), _("Could not set the desktop background"), error);
g_clear_error (&error);
wallpaper_data_free (wdata);
return;
}
wallpaper_data_set (wdata);
}
static void
find_file_insensitive_exists_callback (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GFileInfo *info;
InsensitiveFileSearchData *data = (InsensitiveFileSearchData *) (user_data);
/* The file exists and can be found with the given path, no need to search. */
if ((info = g_file_query_info_finish (G_FILE (source_object), res, NULL)))
{
GSimpleAsyncResult *simple;
simple = g_simple_async_result_new (G_OBJECT (data->root),
data->callback,
data->user_data,
_g_find_file_insensitive_async);
g_simple_async_result_set_op_res_gpointer (simple, g_object_ref (source_object), g_object_unref);
g_simple_async_result_complete_in_idle (simple);
g_object_unref (simple);
clear_find_file_insensitive_state (data);
g_object_unref (info);
}
else
{
data->split_path = g_strsplit (data->original_path, G_DIR_SEPARATOR_S, -1);
data->index = 0;
data->enumerator = NULL;
data->current_file = g_object_ref (data->root);
/* Skip any empty components due to multiple slashes */
while (data->split_path[data->index] != NULL &&
*data->split_path[data->index] == 0)
data->index++;
g_file_enumerate_children_async (data->current_file,
G_FILE_ATTRIBUTE_STANDARD_NAME,
0, G_PRIORITY_DEFAULT,
data->cancellable,
enumerated_children_callback, data);
}
g_object_unref (source_object);
}
static void
remote_file_copy_cb (GObject *source,
GAsyncResult *res,
gpointer user_data)
{
PdfLoadJob *job = user_data;
GError *error = NULL;
char *uri;
g_file_copy_finish (G_FILE (source), res, &error);
if (error != NULL) {
pdf_load_job_complete_error (job, error);
return;
}
pdf_load_job_cache_set_attributes (job);
}
static gboolean
message_handler (GstBus * bus, GstMessage * message, gpointer user_data)
{
switch (GST_MESSAGE_TYPE (message)) {
case GST_MESSAGE_ELEMENT:{
const GstStructure *s = gst_message_get_structure (message);
const gchar *name = gst_structure_get_name (s);
if (strcmp (name, "not-mounted") == 0) {
GMountOperation *mop = gtk_mount_operation_new (NULL);
GFile *file =
G_FILE (g_value_get_object (gst_structure_get_value (s, "file")));
g_print ("not-mounted\n");
gst_element_set_state (pipeline, GST_STATE_NULL);
gst_bus_set_flushing (bus, TRUE);
g_file_mount_enclosing_volume (file, G_MOUNT_MOUNT_NONE,
mop, NULL, mount_cb, bus);
g_object_unref (mop);
}
break;
}
case GST_MESSAGE_EOS:
g_print ("EOS\n");
gtk_main_quit ();
break;
case GST_MESSAGE_ERROR:{
GError *err = NULL;
gst_message_parse_error (message, &err, NULL);
g_print ("error: %s\n", err->message);
g_clear_error (&err);
gtk_main_quit ();
break;
}
default:
break;
}
return TRUE;
}
static void
enum_child_cb (GObject *obj, GAsyncResult *result, gpointer data)
{
RBAndroidSource *source = RB_ANDROID_SOURCE (data);
RBAndroidSourcePrivate *priv = GET_PRIVATE(source);
GFileEnumerator *e;
GError *error = NULL;
e = g_file_enumerate_children_finish (G_FILE (obj), result, &error);
if (e == NULL) {
rb_debug ("enum error: %s", error->message);
g_clear_error (&error);
music_dirs_done (source);
return;
}
g_file_enumerator_next_files_async (e, 64, G_PRIORITY_DEFAULT, priv->cancel, enum_files_cb, source);
}
static GFile *
_g_find_file_insensitive_finish (GFile *parent,
GAsyncResult *result,
GError **error)
{
GSimpleAsyncResult *simple;
GFile *file;
g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (result), NULL);
simple = G_SIMPLE_ASYNC_RESULT (result);
if (g_simple_async_result_propagate_error (simple, error))
return NULL;
file = G_FILE (g_simple_async_result_get_op_res_gpointer (simple));
return g_object_ref (file);
}
static void
gtr_po_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GtrPo *po = GTR_PO (object);
switch (prop_id)
{
case PROP_LOCATION:
gtr_po_set_location (po, G_FILE (g_value_get_object (value)));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
file_replaced_cb (GObject *source,
GAsyncResult *res,
gpointer user_data)
{
SoupCacheInputStream *istream = SOUP_CACHE_INPUT_STREAM (user_data);
SoupCacheInputStreamPrivate *priv = istream->priv;
GError *error = NULL;
priv->output_stream = (GOutputStream *) g_file_replace_finish (G_FILE (source), res, &error);
if (error)
notify_and_clear (istream, error);
else
try_write_next_buffer (istream);
g_object_unref (istream);
}
static void
mount_done_cb (GObject *object,
GAsyncResult *res,
gpointer user_data)
{
gboolean succeeded;
GError *error = NULL;
succeeded = g_file_mount_enclosing_volume_finish (G_FILE (object), res, &error);
if (!succeeded)
g_printerr (_("Error mounting location: %s\n"), error->message);
outstanding_mounts--;
if (outstanding_mounts == 0)
g_main_loop_quit (main_loop);
}
/* Helper for e_reap_trash_directory() */
static void
reap_trash_directory_thread (GSimpleAsyncResult *simple,
GObject *object,
GCancellable *cancellable)
{
gssize expiry_in_days;
GError *error = NULL;
expiry_in_days = g_simple_async_result_get_op_res_gssize (simple);
e_reap_trash_directory_sync (
G_FILE (object),
(gint) expiry_in_days,
cancellable, &error);
if (error != NULL)
g_simple_async_result_take_error (simple, error);
}
static GFile *
g_resource_file_get_parent (GFile *file)
{
GResourceFile *resource = G_RESOURCE_FILE (file);
GResourceFile *parent;
gchar *end;
end = strrchr (resource->path, '/');
if (end == G_RESOURCE_FILE (file)->path)
return NULL;
parent = g_object_new (G_TYPE_RESOURCE_FILE, NULL);
parent->path = g_strndup (resource->path,
end - resource->path);
return G_FILE (parent);
}
/**
* Called when finishing mount operation. Result of operation is set in
* nsGIOInputStream. This function is called in main thread as an async request
* typically from dbus.
* @param source_object GFile object which requested the mount
* @param res result object
* @param user_data pointer to nsGIOInputStream
*/
static void
mount_enclosing_volume_finished (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GError *error = nullptr;
nsGIOInputStream* istream = static_cast<nsGIOInputStream*>(user_data);
g_file_mount_enclosing_volume_finish(G_FILE (source_object), res, &error);
if (error) {
g_warning("Mount failed: %s %d", error->message, error->code);
istream->SetMountResult(MOUNT_OPERATION_FAILED, error->code);
g_error_free(error);
} else {
istream->SetMountResult(MOUNT_OPERATION_SUCCESS, 0);
}
}
static void
mount_cb (GObject * obj, GAsyncResult * res, gpointer user_data)
{
gboolean ret;
GError *err = NULL;
ret = g_file_mount_enclosing_volume_finish (G_FILE (obj), res, &err);
if (ret) {
g_print ("mounted successfully\n");
gst_bus_set_flushing ((GstBus *) user_data, FALSE);
gst_element_set_state (pipeline, GST_STATE_PLAYING);
} else {
g_print ("mounting failed: %s\n", err->message);
g_clear_error (&err);
gtk_main_quit ();
}
}
static void
enumerate_children_async_cb (GObject *source,
GAsyncResult *res,
gpointer user_data)
{
EnumerateJob *job = user_data;
GFileEnumerator *enumerator;
enumerator = g_file_enumerate_children_finish (G_FILE (source),
res, NULL);
if (!enumerator) {
enumerate_job_finish (job);
return;
}
g_file_enumerator_next_files_async (enumerator, G_MAXINT,
G_PRIORITY_DEFAULT,
NULL, enumerate_next_files_async_cb, job);
}
static void
photos_base_item_refresh_thumb_path_pixbuf (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
PhotosBaseItem *self = PHOTOS_BASE_ITEM (user_data);
PhotosBaseItemPrivate *priv = self->priv;
GApplication *app;
GdkPixbuf *pixbuf = NULL;
GdkPixbuf *scaled_pixbuf = NULL;
GError *error = NULL;
GInputStream *stream = G_INPUT_STREAM (source_object);
gint icon_size;
gint scale;
pixbuf = gdk_pixbuf_new_from_stream_finish (res, &error);
if (error != NULL)
{
GFile *file;
gchar *uri;
file = G_FILE (g_object_get_data (G_OBJECT (stream), "file"));
uri = g_file_get_uri (file);
g_warning ("Unable to create pixbuf from %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;
}
app = g_application_get_default ();
scale = photos_application_get_scale_factor (PHOTOS_APPLICATION (app));
icon_size = photos_utils_get_icon_size_unscaled ();
scaled_pixbuf = photos_utils_downscale_pixbuf_for_scale (pixbuf, icon_size, scale);
photos_base_item_set_original_icon (self, scaled_pixbuf);
out:
g_input_stream_close_async (stream, G_PRIORITY_DEFAULT, NULL, NULL, NULL);
g_clear_object (&scaled_pixbuf);
g_clear_object (&pixbuf);
g_object_unref (self);
}
static void
font_install_finished_cb (GObject *source_object,
GAsyncResult *res,
gpointer data)
{
GError *err = NULL;
g_file_copy_finish (G_FILE (source_object), res, &err);
if (!err) {
gtk_button_set_label (GTK_BUTTON (data), _("Installed"));
}
else {
gtk_button_set_label (GTK_BUTTON (data), _("Install Failed"));
g_debug ("Install failed: %s", err->message);
g_error_free (err);
}
gtk_widget_set_sensitive (GTK_WIDGET (data), FALSE);
}
static void
mount_mountable_done_cb (GObject *object,
GAsyncResult *res,
gpointer user_data)
{
GFile *target;
GError *error = NULL;
target = g_file_mount_mountable_finish (G_FILE (object), res, &error);
if (target == NULL)
g_printerr (_("Error mounting location: %s\n"), error->message);
else
g_object_unref (target);
outstanding_mounts--;
if (outstanding_mounts == 0)
g_main_loop_quit (main_loop);
}
void
dlg_open_with (FrWindow *window,
GList *file_list)
{
OpenData *o_data;
GtkWidget *app_chooser;
o_data = g_new0 (OpenData, 1);
o_data->window = window;
o_data->file_list = file_list;
app_chooser = gtk_app_chooser_dialog_new (GTK_WINDOW (window),
GTK_DIALOG_MODAL,
G_FILE (file_list->data));
g_signal_connect (app_chooser,
"response",
G_CALLBACK (app_chooser_response_cb),
o_data);
gtk_widget_show (app_chooser);
}
static void
file_open_callback (GObject *object,
GAsyncResult *res,
gpointer data)
{
CajaImagePropertiesPage *page;
GFile *file;
GFileInputStream *stream;
GError *error;
page = CAJA_IMAGE_PROPERTIES_PAGE (data);
file = G_FILE (object);
error = NULL;
stream = g_file_read_finish (file, res, &error);
if (stream)
{
page->details->loader = gdk_pixbuf_loader_new ();
page->details->pixbuf_still_loading = TRUE;
page->details->width = 0;
page->details->height = 0;
#ifdef HAVE_EXIF
page->details->exifldr = exif_loader_new ();
#endif /*HAVE_EXIF*/
g_signal_connect (page->details->loader,
"size_prepared",
G_CALLBACK (size_prepared_callback),
page);
g_input_stream_read_async (G_INPUT_STREAM (stream),
page->details->buffer,
sizeof (page->details->buffer),
0,
page->details->cancellable,
file_read_callback,
page);
g_object_unref (stream);
}
}