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

/** * g_volume_eject_with_operation: * @volume: a #GVolume * @flags: flags affecting the unmount if required for eject * @mount_operation: (allow-none): a #GMountOperation or %NULL to *     avoid user interaction * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore * @callback: (allow-none): a #GAsyncReadyCallback, or %NULL * @user_data: user data passed to @callback * * Ejects a volume. This is an asynchronous operation, and is * finished by calling g_volume_eject_with_operation_finish() with the @volume * and #GAsyncResult data returned in the @callback. * * Since: 2.22 **/voidg_volume_eject_with_operation (GVolume              *volume,                               GMountUnmountFlags   flags,                               GMountOperation     *mount_operation,                               GCancellable        *cancellable,                               GAsyncReadyCallback  callback,                               gpointer             user_data){  GVolumeIface *iface;  g_return_if_fail (G_IS_VOLUME (volume));  iface = G_VOLUME_GET_IFACE (volume);  if (iface->eject == NULL && iface->eject_with_operation == NULL)    {      g_task_report_new_error (volume, callback, user_data,                               g_volume_eject_with_operation,                               G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,                               /* Translators: This is an error                                * message for volume objects that                                * don't implement any of eject or eject_with_operation. */                               _("volume doesn't implement eject or eject_with_operation"));      return;    }  if (iface->eject_with_operation != NULL)    (* iface->eject_with_operation) (volume, flags, mount_operation, cancellable, callback, user_data);  else    (* iface->eject) (volume, flags, cancellable, callback, user_data);}

/** * g_volume_mount: * @volume: a #GVolume * @flags: flags affecting the operation * @mount_operation: (allow-none): a #GMountOperation or %NULL to avoid user interaction * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore * @callback: (allow-none): a #GAsyncReadyCallback, or %NULL * @user_data: user data that gets passed to @callback *  * Mounts a volume. This is an asynchronous operation, and is * finished by calling g_volume_mount_finish() with the @volume * and #GAsyncResult returned in the @callback. * * Virtual: mount_fn */voidg_volume_mount (GVolume             *volume,		GMountMountFlags     flags,                GMountOperation     *mount_operation,                GCancellable        *cancellable,                GAsyncReadyCallback  callback,                gpointer             user_data){  GVolumeIface *iface;  g_return_if_fail (G_IS_VOLUME (volume));  iface = G_VOLUME_GET_IFACE (volume);  if (iface->mount_fn == NULL)    {      g_task_report_new_error (volume, callback, user_data,                               g_volume_mount,                               G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,                               _("volume doesn't implement mount"));      return;    }    (* iface->mount_fn) (volume, flags, mount_operation, cancellable, callback, user_data);}

static voidxfdesktop_volume_icon_changed(GVolume *volume,                              XfdesktopVolumeIcon *volume_icon){    g_return_if_fail(G_IS_VOLUME(volume));    g_return_if_fail(XFDESKTOP_IS_VOLUME_ICON(volume_icon));    DBG("VOLUME CHANGED");    /**     * NOTE: We use a timeout here to check if the volume is      * now mounted (or has been unmounted). This timeout seems     * to be needed because when the "changed" signal is emitted,     * the GMount is always NULL. In a 500ms timeout we check     * at most 5 times for a valid mount until we give up. This     * hopefully is a suitable workaround for most machines and     * drives.      */    /* abort an existing timeout, we may have to run it a few times     * once again for the new event */    if(volume_icon->priv->changed_timeout_id > 0) {        g_source_remove(volume_icon->priv->changed_timeout_id);        volume_icon->priv->changed_timeout_id = 0;    }    /* reset timeout information and start a timeout */    volume_icon->priv->changed_timeout_count = 0;    volume_icon->priv->changed_timeout_id =        g_timeout_add_full(G_PRIORITY_LOW, 500,                            (GSourceFunc) volume_icon_changed_timeout,                            g_object_ref(volume_icon),                           g_object_unref);}

static voideject_cb (GObject *object, GAsyncResult *result, gpointer nothing){	GError *error = NULL;	if (G_IS_VOLUME (object)) {		GVolume *volume = G_VOLUME (object);		rb_debug ("finishing ejection of volume");		g_volume_eject_with_operation_finish (volume, result, &error);	} else if (G_IS_MOUNT (object)) {		GMount *mount = G_MOUNT (object);		rb_debug ("finishing ejection of mount");		g_mount_eject_with_operation_finish (mount, result, &error);	}	if (error != NULL) {		if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_FAILED_HANDLED)) {			rb_error_dialog (NULL, _("Unable to eject"), "%s", error->message);		} else {			rb_debug ("eject failure has already been handled");		}		g_error_free (error);	}}

char *rb_gvolume_get_udi (GVolume *volume, gpointer ctx){	char *udi, *dev, **udis;	int num_udis;	g_return_val_if_fail (volume != NULL, NULL);	g_return_val_if_fail (G_IS_VOLUME (volume), NULL);	g_return_val_if_fail (ctx != NULL, NULL);	udi = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_HAL_UDI);	if (udi != NULL)		return udi;	dev = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE);	udis = libhal_manager_find_device_string_match ((LibHalContext *) ctx,							"block.device", dev,							&num_udis, NULL);	if (udis == NULL || num_udis < 1) {		libhal_free_string_array (udis);		return NULL;	}	udi = g_strdup (udis[0]);	libhal_free_string_array (udis);	return udi;}

/** * g_volume_get_drive: * @volume: a #GVolume *  * Gets the drive for the @volume. *  * Returns: (transfer full): a #GDrive or %NULL if @volume is not *     associated with a drive. The returned object should be unreffed *     with g_object_unref() when no longer needed. */GDrive *g_volume_get_drive (GVolume *volume){  GVolumeIface *iface;  g_return_val_if_fail (G_IS_VOLUME (volume), NULL);  iface = G_VOLUME_GET_IFACE (volume);  return (* iface->get_drive) (volume);}

/** * g_volume_get_mount: * @volume: a #GVolume *  * Gets the mount for the @volume. *  * Returns: (transfer full): a #GMount or %NULL if @volume isn't mounted. *     The returned object should be unreffed with g_object_unref() *     when no longer needed. */GMount *g_volume_get_mount (GVolume *volume){  GVolumeIface *iface;  g_return_val_if_fail (G_IS_VOLUME (volume), NULL);  iface = G_VOLUME_GET_IFACE (volume);  return (* iface->get_mount) (volume);}

/** * g_volume_get_activation_root: * @volume: a #GVolume * * Gets the activation root for a #GVolume if it is known ahead of * mount time. Returns %NULL otherwise. If not %NULL and if @volume * is mounted, then the result of g_mount_get_root() on the * #GMount object obtained from g_volume_get_mount() will always * either be equal or a prefix of what this function returns. In * other words, in code * * |[<!-- language="C" --> *   GMount *mount; *   GFile *mount_root *   GFile *volume_activation_root; * *   mount = g_volume_get_mount (volume); /&ast; mounted, so never NULL &ast;/ *   mount_root = g_mount_get_root (mount); *   volume_activation_root = g_volume_get_activation_root (volume); /&ast; assume not NULL &ast;/ * ]| * then the expression * |[<!-- language="C" --> *   (g_file_has_prefix (volume_activation_root, mount_root) ||      g_file_equal (volume_activation_root, mount_root)) * ]| * will always be %TRUE. * * Activation roots are typically used in #GVolumeMonitor * implementations to find the underlying mount to shadow, see * g_mount_is_shadowed() for more details. * * Returns: (transfer full): the activation root of @volume or %NULL. Use *     g_object_unref() to free. * * Since: 2.18 */GFile *g_volume_get_activation_root (GVolume *volume){  GVolumeIface *iface;  g_return_val_if_fail (G_IS_VOLUME (volume), NULL);  iface = G_VOLUME_GET_IFACE (volume);  if (iface->get_activation_root == NULL)    return NULL;  return (* iface->get_activation_root) (volume);}

voidthunar_notify_eject_finish (GVolume *volume){  NotifyNotification *notification;  g_return_if_fail (G_IS_VOLUME (volume));  notification = g_object_get_data (G_OBJECT (volume), "thunar-notification");  if (notification != NULL)    {      notify_notification_close (notification, NULL);      g_object_set_data (G_OBJECT (volume), "thunar-notification", NULL);    }}

/** * g_volume_get_sort_key: * @volume: a #GVolume * * Gets the sort key for @volume, if any. * * Returns: Sorting key for @volume or %NULL if no such key is available * * Since: 2.32 */const gchar *g_volume_get_sort_key (GVolume *volume){  const gchar *ret = NULL;  GVolumeIface *iface;  g_return_val_if_fail (G_IS_VOLUME (volume), NULL);  iface = G_VOLUME_GET_IFACE (volume);  if (iface->get_sort_key != NULL)    ret = iface->get_sort_key (volume);  return ret;}

/** * g_volume_should_automount: * @volume: a #GVolume * * Returns whether the volume should be automatically mounted. *  * Returns: %TRUE if the volume should be automatically mounted */gbooleang_volume_should_automount (GVolume *volume){  GVolumeIface *iface;  g_return_val_if_fail (G_IS_VOLUME (volume), FALSE);  iface = G_VOLUME_GET_IFACE (volume);  if (iface->should_automount == NULL)    return FALSE;  return (* iface->should_automount) (volume);}

/** * g_volume_can_eject: * @volume: a #GVolume *  * Checks if a volume can be ejected. *  * Returns: %TRUE if the @volume can be ejected. %FALSE otherwise */gbooleang_volume_can_eject (GVolume *volume){  GVolumeIface *iface;  g_return_val_if_fail (G_IS_VOLUME (volume), FALSE);  iface = G_VOLUME_GET_IFACE (volume);  if (iface->can_eject == NULL)    return FALSE;  return (* iface->can_eject) (volume);}

/** * g_volume_get_identifier: * @volume: a #GVolume * @kind: the kind of identifier to return * * Gets the identifier of the given kind for @volume.  * See the <link linkend="volume-identifier">introduction</link> * for more information about volume identifiers. * * Returns: a newly allocated string containing the *     requested identfier, or %NULL if the #GVolume *     doesn't have this kind of identifier */char *g_volume_get_identifier (GVolume    *volume,			 const char *kind){  GVolumeIface *iface;  g_return_val_if_fail (G_IS_VOLUME (volume), NULL);  g_return_val_if_fail (kind != NULL, NULL);  iface = G_VOLUME_GET_IFACE (volume);  if (iface->get_identifier == NULL)    return NULL;    return (* iface->get_identifier) (volume, kind);}

/** * g_volume_get_symbolic_icon: * @volume: a #GVolume *  * Gets the symbolic icon for @volume. *  * Returns: (transfer full): a #GIcon. *     The returned object should be unreffed with g_object_unref() *     when no longer needed. * * Since: 2.34 */GIcon *g_volume_get_symbolic_icon (GVolume *volume){  GVolumeIface *iface;  GIcon *ret;  g_return_val_if_fail (G_IS_VOLUME (volume), NULL);  iface = G_VOLUME_GET_IFACE (volume);  if (iface->get_symbolic_icon != NULL)    ret = iface->get_symbolic_icon (volume);  else    ret = g_themed_icon_new_with_default_fallbacks ("folder-remote-symbolic");  return ret;}

/** * g_volume_eject_finish: * @volume: pointer to a #GVolume * @result: a #GAsyncResult * @error: a #GError location to store an error, or %NULL to ignore *  * Finishes ejecting a volume. If any errors occurred during the operation, * @error will be set to contain the errors and %FALSE will be returned. *  * Returns: %TRUE, %FALSE if operation failed * * Deprecated: 2.22: Use g_volume_eject_with_operation_finish() instead. **/gbooleang_volume_eject_finish (GVolume       *volume,                       GAsyncResult  *result,                       GError       **error){  GVolumeIface *iface;  g_return_val_if_fail (G_IS_VOLUME (volume), FALSE);  g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);  if (g_async_result_legacy_propagate_error (result, error))    return FALSE;  if (g_async_result_is_tagged (result, g_volume_eject_with_operation))    return g_task_propagate_boolean (G_TASK (result), error);    iface = G_VOLUME_GET_IFACE (volume);  return (* iface->eject_finish) (volume, result, error);}

static voidxfdesktop_volume_icon_eject_finish(GObject *object,                                   GAsyncResult *result,                                   gpointer user_data){    XfdesktopVolumeIcon *icon = XFDESKTOP_VOLUME_ICON(user_data);    GtkWidget *icon_view = xfdesktop_icon_peek_icon_view(XFDESKTOP_ICON(icon));    GtkWidget *toplevel = icon_view ? gtk_widget_get_toplevel(icon_view) : NULL;    GVolume *volume = G_VOLUME(object);    GError *error = NULL;    gboolean eject_successful;          g_return_if_fail(G_IS_VOLUME(object));    g_return_if_fail(G_IS_ASYNC_RESULT(result));    g_return_if_fail(XFDESKTOP_IS_VOLUME_ICON(icon));    eject_successful = g_volume_eject_with_operation_finish(volume, result, &error);    if(!eject_successful) {        /* ignore GIO errors handled internally */        if(error->domain != G_IO_ERROR || error->code != G_IO_ERROR_FAILED_HANDLED) {            gchar *volume_name = g_volume_get_name(volume);            gchar *primary = g_markup_printf_escaped(_("Failed to eject /"%s/""),                                                      volume_name);            /* display an error dialog to inform the user */            xfce_message_dialog(toplevel ? GTK_WINDOW(toplevel) : NULL,                                _("Eject Failed"), GTK_STOCK_DIALOG_ERROR,                                 primary, error->message,                                GTK_STOCK_CLOSE, GTK_RESPONSE_ACCEPT, NULL);            g_free(primary);            g_free(volume_name);        }        g_error_free(error);    }#ifdef HAVE_LIBNOTIFY    xfdesktop_notify_eject_finish(volume, eject_successful);#endif    g_object_unref(icon);}

/** * g_volume_eject_finish: * @volume: pointer to a #GVolume. * @result: a #GAsyncResult. * @error: a #GError location to store an error, or %NULL to ignore *  * Finishes ejecting a volume. If any errors occurred during the operation, * @error will be set to contain the errors and %FALSE will be returned. *  * Returns: %TRUE, %FALSE if operation failed. * * Deprecated: 2.22: Use g_volume_eject_with_operation_finish() instead. **/gbooleang_volume_eject_finish (GVolume       *volume,                       GAsyncResult  *result,                       GError       **error){  GVolumeIface *iface;  g_return_val_if_fail (G_IS_VOLUME (volume), FALSE);  g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);  if (G_IS_SIMPLE_ASYNC_RESULT (result))    {      GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);      if (g_simple_async_result_propagate_error (simple, error))	return FALSE;    }    iface = G_VOLUME_GET_IFACE (volume);  return (* iface->eject_finish) (volume, result, error);}

static voidcmd_duplicate_cd (GtkAction         	*action,		  RBDiscRecorderPlugin	*pi){	gchar *device;	GVolume *volume;	if (!pi->selected_source)		return;	g_object_get (pi->selected_source, "volume", &volume, NULL);	if (G_IS_VOLUME (volume))		device = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE);	else		device = NULL;	g_object_unref (volume);	rb_disc_recorder_plugin_start_burning (pi, device, TRUE);	g_free (device);}

XfdesktopVolumeIcon *xfdesktop_volume_icon_new(GVolume *volume,                          GdkScreen *screen){    XfdesktopVolumeIcon *volume_icon;    GMount *mount;        g_return_val_if_fail(G_IS_VOLUME(volume), NULL);        volume_icon = g_object_new(XFDESKTOP_TYPE_VOLUME_ICON, NULL);    volume_icon->priv->volume = g_object_ref(G_OBJECT(volume));    volume_icon->priv->gscreen = screen;    mount = g_volume_get_mount(volume);    if(mount) {        volume_icon->priv->file = g_mount_get_root(mount);        volume_icon->priv->file_info = g_file_query_info(volume_icon->priv->file,                                                         XFDESKTOP_FILE_INFO_NAMESPACE,                                                         G_FILE_QUERY_INFO_NONE,                                                         NULL, NULL);        volume_icon->priv->filesystem_info = g_file_query_filesystem_info(volume_icon->priv->file,                                                                          XFDESKTOP_FILESYSTEM_INFO_NAMESPACE,                                                                          NULL, NULL);        g_object_unref(mount);    }    g_signal_connect_swapped(G_OBJECT(gtk_icon_theme_get_for_screen(screen)),                             "changed",                             G_CALLBACK(xfdesktop_icon_invalidate_pixbuf),                             volume_icon);    g_signal_connect(volume, "changed",                      G_CALLBACK(xfdesktop_volume_icon_changed),                      volume_icon);        return volume_icon;}

/** * g_volume_eject: * @volume: a #GVolume. * @flags: flags affecting the unmount if required for eject * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore. * @callback: (allow-none): a #GAsyncReadyCallback, or %NULL. * @user_data: user data that gets passed to @callback *  * Ejects a volume. This is an asynchronous operation, and is * finished by calling g_volume_eject_finish() with the @volume * and #GAsyncResult returned in the @callback. * * Deprecated: 2.22: Use g_volume_eject_with_operation() instead. **/voidg_volume_eject (GVolume             *volume,		GMountUnmountFlags   flags,                GCancellable        *cancellable,                GAsyncReadyCallback  callback,                gpointer             user_data){  GVolumeIface *iface;  g_return_if_fail (G_IS_VOLUME (volume));  iface = G_VOLUME_GET_IFACE (volume);  if (iface->eject == NULL)    {      g_simple_async_report_error_in_idle (G_OBJECT (volume), callback, user_data,					   G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,					   _("volume doesn't implement eject"));            return;    }    (* iface->eject) (volume, flags, cancellable, callback, user_data);}

voidthunar_notify_eject (GVolume *volume){  const gchar * const *icon_names;  NotifyNotification  *notification = NULL;  const gchar         *summary;  GFileInfo           *info;  gboolean             read_only = FALSE;  GMount              *mount;  GFile               *icon_file;  GFile               *mount_point;  GIcon               *icon;  gchar               *icon_name = NULL;  gchar               *message;  gchar               *name;  g_return_if_fail (G_IS_VOLUME (volume));  if (!thunar_notify_init ())    return;  mount = g_volume_get_mount (volume);  if (mount != NULL)    {      mount_point = g_mount_get_root (mount);            info = g_file_query_info (mount_point, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE,                                 G_FILE_QUERY_INFO_NONE, NULL, NULL);      if (info != NULL)        {          read_only =            !g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE);          g_object_unref (info);        }      g_object_unref (mount_point);    }  name = g_volume_get_name (volume);  icon = g_volume_get_icon (volume);  if (G_IS_THEMED_ICON (icon))    {      icon_names = g_themed_icon_get_names (G_THEMED_ICON (icon));      if (icon_names != NULL)        icon_name = g_strdup (icon_names[0]);    }  else if (G_IS_FILE_ICON (icon))    {      icon_file = g_file_icon_get_file (G_FILE_ICON (icon));      if (icon_file != NULL)        {          icon_name = g_file_get_path (icon_file);          g_object_unref (icon_file);        }    }  g_object_unref (icon);  if (icon_name == NULL)    icon_name = g_strdup ("drive-removable-media");  if (read_only)    {      summary = _("Ejecting device");      message = g_strdup_printf (_("The device /"%s/" is being ejected. "                                   "This may take some time"), name);    }  else    {      summary = _("Writing data to device");      message = g_strdup_printf (_("There is data that needs to be written to the "                                   "device /"%s/" before it can be removed. Please "                                   "do not remove the media or disconnect the drive"),                                   name);    }#ifdef NOTIFY_CHECK_VERSION#if NOTIFY_CHECK_VERSION (0, 7, 0)  notification = notify_notification_new (summary, message, icon_name);#else  notification = notify_notification_new (summary, message, icon_name, NULL);#endif#else  notification = notify_notification_new (summary, message, icon_name, NULL);#endif  notify_notification_set_urgency (notification, NOTIFY_URGENCY_CRITICAL);  notify_notification_set_timeout (notification, NOTIFY_EXPIRES_NEVER);  notify_notification_show (notification, NULL);  g_object_set_data_full (G_OBJECT (volume), "thunar-notification", notification,                           g_object_unref);  g_free (message);  g_free (icon_name);  g_free (name);}