自学教程：C++ G_FILE函数代码示例

static voidadd_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);}

voidfr_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 voidphotos_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 voidasync_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 voidcreate_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 voidcopy_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 voidon_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 voidcopy_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 voidfind_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 voidremote_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 gbooleanmessage_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 voidenum_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 voidgtr_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 voidfile_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 voidmount_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 voidreap_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 voidmount_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 voidmount_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 voidenumerate_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 voidphotos_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 voidfont_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 voidmount_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);}

voiddlg_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 voidfile_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);    }}