callisto-debian/evolution
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
e837eb24ea6ae6bcd4d9fc3d6aaa852fe7112fff
evolution/e-util/e-attachment.c
Milan Crha 2f3fbdd6c6 Ignore false GObject property change notifications 
This is related to bug 698275, which did not cover all cases.
The problem here is that the dconf can in certain situation claim
that everything changed (path "/" changed), which GSettingsBinding
propagates to a GObject property unconditionally and GObject's
property setter (g_object_set_property()) also notifies about
the property change unconditionally, despite the real descendant
property setter properly checks for the value change. After all
these false notifications a callback on "notify" signal is called
and possibly an expensive operation is run.

Checking whether the value really changed helps in performance, for
which were added new e-util functions:
   e_signal_connect_notify()
   e_signal_connect_notify_after()
   e_signal_connect_notify_swapped()
   e_signal_connect_notify_object()
which have the same prototype as their GLib counterparts, but they allow
only "notify::..." signals and they test whether the value really changed
before they call the registered callback.
2014-06-04 19:46:25 +02:00

3173 lines
80 KiB
C
Raw Blame History

/*
* e-attachment.c
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program; if not, see <http://www.gnu.org/licenses/>.
*
*
* Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
*
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "e-attachment.h"
#include <errno.h>
#include <glib/gi18n.h>
#include <glib/gstdio.h>
#include <libedataserver/libedataserver.h>
#include "e-attachment-store.h"
#include "e-icon-factory.h"
#include "e-mktemp.h"
#include "e-misc-utils.h"
#define E_ATTACHMENT_GET_PRIVATE(obj) \
(G_TYPE_INSTANCE_GET_PRIVATE \
((obj), E_TYPE_ATTACHMENT, EAttachmentPrivate))
/* Fallback Icon */
#define DEFAULT_ICON_NAME "mail-attachment"
/* Emblems */
#define EMBLEM_CANCELLED "process-stop"
#define EMBLEM_LOADING "emblem-downloads"
#define EMBLEM_SAVING "document-save"
#define EMBLEM_ENCRYPT_WEAK "security-low"
#define EMBLEM_ENCRYPT_STRONG "security-high"
#define EMBLEM_ENCRYPT_UNKNOWN "security-medium"
#define EMBLEM_SIGN_BAD "stock_signature-bad"
#define EMBLEM_SIGN_GOOD "stock_signature-ok"
#define EMBLEM_SIGN_UNKNOWN "stock_signature"
/* Attributes needed for EAttachmentStore columns. */
#define ATTACHMENT_QUERY "standard::*,preview::*,thumbnail::*"
struct _EAttachmentPrivate {
GMutex property_lock;
GFile *file;
GIcon *icon;
GFileInfo *file_info;
GCancellable *cancellable;
CamelMimePart *mime_part;
guint emblem_timeout_id;
gchar *disposition;
gint percent;
gint64 last_percent_notify; /* to avoid excessive notifications */
guint can_show : 1;
guint loading : 1;
guint saving : 1;
guint shown : 1;
camel_cipher_validity_encrypt_t encrypted;
camel_cipher_validity_sign_t signed_;
/* This is a reference to our row in an EAttachmentStore,
* serving as a means of broadcasting "row-changed" signals.
* If we are removed from the store, we lazily free the
* reference when it is found to be to be invalid. */
GtkTreeRowReference *reference;
/* These are IDs for idle callbacks,
* protected by the idle_lock mutex. */
GMutex idle_lock;
guint update_icon_column_idle_id;
guint update_progress_columns_idle_id;
guint update_file_info_columns_idle_id;
};
enum {
PROP_0,
PROP_CAN_SHOW,
PROP_DISPOSITION,
PROP_ENCRYPTED,
PROP_FILE,
PROP_FILE_INFO,
PROP_ICON,
PROP_LOADING,
PROP_MIME_PART,
PROP_PERCENT,
PROP_REFERENCE,
PROP_SAVING,
PROP_SHOWN,
PROP_SIGNED
};
G_DEFINE_TYPE (
EAttachment,
e_attachment,
G_TYPE_OBJECT)
static gboolean
create_system_thumbnail (EAttachment *attachment,
GIcon **icon)
{
GFile *file;
GFile *icon_file;
gchar *file_path = NULL;
gchar *thumbnail = NULL;
gboolean success = FALSE;
g_return_val_if_fail (E_IS_ATTACHMENT (attachment), FALSE);
g_return_val_if_fail (icon != NULL, FALSE);
file = e_attachment_ref_file (attachment);
if (file != NULL)
file_path = g_file_get_path (file);
if (file_path != NULL) {
thumbnail = e_icon_factory_create_thumbnail (file_path);
g_free (file_path);
}
if (thumbnail == NULL)
goto exit;
icon_file = g_file_new_for_path (thumbnail);
if (*icon != NULL)
g_object_unref (*icon);
*icon = g_file_icon_new (icon_file);
g_object_unref (icon_file);
if (file != NULL) {
GFileInfo *file_info;
const gchar *attribute;
file_info = e_attachment_ref_file_info (attachment);
attribute = G_FILE_ATTRIBUTE_THUMBNAIL_PATH;
if (file_info != NULL) {
g_file_info_set_attribute_byte_string (
file_info, attribute, thumbnail);
g_object_unref (file_info);
}
}
g_free (thumbnail);
success = TRUE;
exit:
g_clear_object (&file);
return success;
}
static gchar *
attachment_get_default_charset (void)
{
GSettings *settings;
gchar *charset;
/* XXX This doesn't really belong here. */
settings = g_settings_new ("org.gnome.evolution.mail");
charset = g_settings_get_string (settings, "composer-charset");
if (charset == NULL || *charset == '\0') {
g_free (charset);
/* FIXME This was "/apps/evolution/mail/format/charset",
* not sure it relates to "charset" */
charset = g_settings_get_string (settings, "charset");
if (charset == NULL || *charset == '\0') {
g_free (charset);
charset = NULL;
}
}
g_object_unref (settings);
if (charset == NULL)
charset = g_strdup (camel_iconv_locale_charset ());
if (charset == NULL)
charset = g_strdup ("us-ascii");
return charset;
}
static gboolean
attachment_update_file_info_columns_idle_cb (gpointer weak_ref)
{
EAttachment *attachment;
GtkTreeRowReference *reference;
GtkTreeModel *model;
GtkTreePath *path;
GtkTreeIter iter;
GFileInfo *file_info;
const gchar *content_type;
const gchar *display_name;
gchar *content_desc;
gchar *display_size;
gchar *description;
gchar *caption;
goffset size;
attachment = g_weak_ref_get (weak_ref);
if (attachment == NULL)
goto exit;
g_mutex_lock (&attachment->priv->idle_lock);
attachment->priv->update_file_info_columns_idle_id = 0;
g_mutex_unlock (&attachment->priv->idle_lock);
reference = e_attachment_get_reference (attachment);
if (!gtk_tree_row_reference_valid (reference))
goto exit;
file_info = e_attachment_ref_file_info (attachment);
if (file_info == NULL)
goto exit;
model = gtk_tree_row_reference_get_model (reference);
path = gtk_tree_row_reference_get_path (reference);
gtk_tree_model_get_iter (model, &iter, path);
gtk_tree_path_free (path);
content_type = g_file_info_get_content_type (file_info);
display_name = g_file_info_get_display_name (file_info);
size = g_file_info_get_size (file_info);
content_desc = g_content_type_get_description (content_type);
display_size = g_format_size (size);
description = e_attachment_dup_description (attachment);
if (description == NULL || *description == '\0') {
g_free (description);
description = g_strdup (display_name);
}
if (size > 0)
caption = g_strdup_printf (
"%s\n(%s)", description, display_size);
else
caption = g_strdup (description);
gtk_list_store_set (
GTK_LIST_STORE (model), &iter,
E_ATTACHMENT_STORE_COLUMN_CAPTION, caption,
E_ATTACHMENT_STORE_COLUMN_CONTENT_TYPE, content_desc,
E_ATTACHMENT_STORE_COLUMN_DESCRIPTION, description,
E_ATTACHMENT_STORE_COLUMN_SIZE, size,
-1);
g_free (content_desc);
g_free (display_size);
g_free (description);
g_free (caption);
g_clear_object (&file_info);
exit:
g_clear_object (&attachment);
return FALSE;
}
static void
attachment_update_file_info_columns (EAttachment *attachment)
{
g_mutex_lock (&attachment->priv->idle_lock);
if (attachment->priv->update_file_info_columns_idle_id == 0) {
guint idle_id;
idle_id = g_idle_add_full (
G_PRIORITY_HIGH_IDLE,
attachment_update_file_info_columns_idle_cb,
e_weak_ref_new (attachment),
(GDestroyNotify) e_weak_ref_free);
attachment->priv->update_file_info_columns_idle_id = idle_id;
}
g_mutex_unlock (&attachment->priv->idle_lock);
}
static gboolean
attachment_update_icon_column_idle_cb (gpointer weak_ref)
{
EAttachment *attachment;
GtkTreeRowReference *reference;
GtkTreeModel *model;
GtkTreePath *path;
GtkTreeIter iter;
GFileInfo *file_info;
GCancellable *cancellable;
GIcon *icon = NULL;
const gchar *emblem_name = NULL;
const gchar *thumbnail_path = NULL;
attachment = g_weak_ref_get (weak_ref);
if (attachment == NULL)
goto exit;
g_mutex_lock (&attachment->priv->idle_lock);
attachment->priv->update_icon_column_idle_id = 0;
g_mutex_unlock (&attachment->priv->idle_lock);
reference = e_attachment_get_reference (attachment);
if (!gtk_tree_row_reference_valid (reference))
goto exit;
model = gtk_tree_row_reference_get_model (reference);
path = gtk_tree_row_reference_get_path (reference);
gtk_tree_model_get_iter (model, &iter, path);
gtk_tree_path_free (path);
cancellable = attachment->priv->cancellable;
file_info = e_attachment_ref_file_info (attachment);
if (file_info != NULL) {
icon = g_file_info_get_icon (file_info);
/* add the reference here, thus the create_system_thumbnail() can unref the *icon. */
if (icon)
g_object_ref (icon);
thumbnail_path = g_file_info_get_attribute_byte_string (
file_info, G_FILE_ATTRIBUTE_THUMBNAIL_PATH);
}
/* Prefer the thumbnail if we have one. */
if (thumbnail_path != NULL && *thumbnail_path != '\0') {
GFile *file;
file = g_file_new_for_path (thumbnail_path);
icon = g_file_icon_new (file);
g_object_unref (file);
/* Try the system thumbnailer. */
} else if (create_system_thumbnail (attachment, &icon)) {
/* Nothing to do, just use the icon. */
/* Else use the standard icon for the content type. */
} else if (icon != NULL) {
/* Nothing to do, just use the already reffed icon. */
/* Last ditch fallback. (GFileInfo not yet loaded?) */
} else
icon = g_themed_icon_new (DEFAULT_ICON_NAME);
/* Pick an emblem, limit one. Choices listed by priority. */
if (g_cancellable_is_cancelled (cancellable))
emblem_name = EMBLEM_CANCELLED;
else if (e_attachment_get_loading (attachment))
emblem_name = EMBLEM_LOADING;
else if (e_attachment_get_saving (attachment))
emblem_name = EMBLEM_SAVING;
else if (e_attachment_get_encrypted (attachment))
switch (e_attachment_get_encrypted (attachment)) {
case CAMEL_CIPHER_VALIDITY_ENCRYPT_WEAK:
emblem_name = EMBLEM_ENCRYPT_WEAK;
break;
case CAMEL_CIPHER_VALIDITY_ENCRYPT_ENCRYPTED:
emblem_name = EMBLEM_ENCRYPT_UNKNOWN;
break;
case CAMEL_CIPHER_VALIDITY_ENCRYPT_STRONG:
emblem_name = EMBLEM_ENCRYPT_STRONG;
break;
default:
g_warn_if_reached ();
break;
}
else if (e_attachment_get_signed (attachment))
switch (e_attachment_get_signed (attachment)) {
case CAMEL_CIPHER_VALIDITY_SIGN_GOOD:
emblem_name = EMBLEM_SIGN_GOOD;
break;
case CAMEL_CIPHER_VALIDITY_SIGN_BAD:
emblem_name = EMBLEM_SIGN_BAD;
break;
case CAMEL_CIPHER_VALIDITY_SIGN_UNKNOWN:
case CAMEL_CIPHER_VALIDITY_SIGN_NEED_PUBLIC_KEY:
emblem_name = EMBLEM_SIGN_UNKNOWN;
break;
default:
g_warn_if_reached ();
break;
}
if (emblem_name != NULL) {
GIcon *emblemed_icon;
GEmblem *emblem;
emblemed_icon = g_themed_icon_new (emblem_name);
emblem = g_emblem_new (emblemed_icon);
g_object_unref (emblemed_icon);
emblemed_icon = g_emblemed_icon_new (icon, emblem);
g_object_unref (emblem);
g_object_unref (icon);
icon = emblemed_icon;
}
gtk_list_store_set (
GTK_LIST_STORE (model), &iter,
E_ATTACHMENT_STORE_COLUMN_ICON, icon,
-1);
/* Cache the icon to reuse for things like drag-n-drop. */
if (attachment->priv->icon != NULL)
g_object_unref (attachment->priv->icon);
attachment->priv->icon = icon;
g_object_notify (G_OBJECT (attachment), "icon");
g_clear_object (&file_info);
exit:
g_clear_object (&attachment);
return FALSE;
}
static void
attachment_update_icon_column (EAttachment *attachment)
{
g_mutex_lock (&attachment->priv->idle_lock);
if (attachment->priv->update_icon_column_idle_id == 0) {
guint idle_id;
idle_id = g_idle_add_full (
G_PRIORITY_HIGH_IDLE,
attachment_update_icon_column_idle_cb,
e_weak_ref_new (attachment),
(GDestroyNotify) e_weak_ref_free);
attachment->priv->update_icon_column_idle_id = idle_id;
}
g_mutex_unlock (&attachment->priv->idle_lock);
}
static gboolean
attachment_update_progress_columns_idle_cb (gpointer weak_ref)
{
EAttachment *attachment;
GtkTreeRowReference *reference;
GtkTreeModel *model;
GtkTreePath *path;
GtkTreeIter iter;
gboolean loading;
gboolean saving;
gint percent;
attachment = g_weak_ref_get (weak_ref);
if (attachment == NULL)
goto exit;
g_mutex_lock (&attachment->priv->idle_lock);
attachment->priv->update_progress_columns_idle_id = 0;
g_mutex_unlock (&attachment->priv->idle_lock);
reference = e_attachment_get_reference (attachment);
if (!gtk_tree_row_reference_valid (reference))
goto exit;
model = gtk_tree_row_reference_get_model (reference);
path = gtk_tree_row_reference_get_path (reference);
gtk_tree_model_get_iter (model, &iter, path);
gtk_tree_path_free (path);
/* Don't show progress bars until we have progress to report. */
percent = e_attachment_get_percent (attachment);
loading = e_attachment_get_loading (attachment) && (percent > 0);
saving = e_attachment_get_saving (attachment) && (percent > 0);
gtk_list_store_set (
GTK_LIST_STORE (model), &iter,
E_ATTACHMENT_STORE_COLUMN_LOADING, loading,
E_ATTACHMENT_STORE_COLUMN_PERCENT, percent,
E_ATTACHMENT_STORE_COLUMN_SAVING, saving,
-1);
exit:
g_clear_object (&attachment);
return FALSE;
}
static void
attachment_update_progress_columns (EAttachment *attachment)
{
g_mutex_lock (&attachment->priv->idle_lock);
if (attachment->priv->update_progress_columns_idle_id == 0) {
guint idle_id;
idle_id = g_idle_add_full (
G_PRIORITY_HIGH_IDLE,
attachment_update_progress_columns_idle_cb,
e_weak_ref_new (attachment),
(GDestroyNotify) e_weak_ref_free);
attachment->priv->update_progress_columns_idle_id = idle_id;
}
g_mutex_unlock (&attachment->priv->idle_lock);
}
static void
attachment_set_loading (EAttachment *attachment,
gboolean loading)
{
GtkTreeRowReference *reference;
reference = e_attachment_get_reference (attachment);
attachment->priv->percent = 0;
attachment->priv->loading = loading;
attachment->priv->last_percent_notify = 0;
g_object_freeze_notify (G_OBJECT (attachment));
g_object_notify (G_OBJECT (attachment), "percent");
g_object_notify (G_OBJECT (attachment), "loading");
g_object_thaw_notify (G_OBJECT (attachment));
if (gtk_tree_row_reference_valid (reference)) {
GtkTreeModel *model;
model = gtk_tree_row_reference_get_model (reference);
g_object_notify (G_OBJECT (model), "num-loading");
}
}
static void
attachment_set_saving (EAttachment *attachment,
gboolean saving)
{
attachment->priv->percent = 0;
attachment->priv->saving = saving;
attachment->priv->last_percent_notify = 0;
}
static void
attachment_progress_cb (goffset current_num_bytes,
goffset total_num_bytes,
EAttachment *attachment)
{
gint new_percent;
/* Avoid dividing by zero. */
if (total_num_bytes == 0)
return;
/* do not notify too often, 5 times per second is sufficient */
if (g_get_monotonic_time () - attachment->priv->last_percent_notify < 200000)
return;
attachment->priv->last_percent_notify = g_get_monotonic_time ();
new_percent = (current_num_bytes * 100) / total_num_bytes;
if (new_percent != attachment->priv->percent)
attachment->priv->percent = new_percent;
}
static gboolean
attachment_cancelled_timeout_cb (gpointer user_data)
{
EAttachment *attachment;
attachment = E_ATTACHMENT (user_data);
attachment->priv->emblem_timeout_id = 0;
g_cancellable_reset (attachment->priv->cancellable);
attachment_update_icon_column (attachment);
return FALSE;
}
static void
attachment_cancelled_cb (EAttachment *attachment)
{
/* Reset the GCancellable after one second. This causes a
* cancel emblem to be briefly shown on the attachment icon
* as visual feedback that an operation was cancelled. */
if (attachment->priv->emblem_timeout_id > 0)
g_source_remove (attachment->priv->emblem_timeout_id);
attachment->priv->emblem_timeout_id = e_named_timeout_add_seconds (
1, attachment_cancelled_timeout_cb, attachment);
attachment_update_icon_column (attachment);
}
static void
attachment_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
switch (property_id) {
case PROP_CAN_SHOW:
e_attachment_set_can_show (
E_ATTACHMENT (object),
g_value_get_boolean (value));
return;
case PROP_DISPOSITION:
e_attachment_set_disposition (
E_ATTACHMENT (object),
g_value_get_string (value));
return;
case PROP_ENCRYPTED:
e_attachment_set_encrypted (
E_ATTACHMENT (object),
g_value_get_int (value));
return;
case PROP_FILE:
e_attachment_set_file (
E_ATTACHMENT (object),
g_value_get_object (value));
return;
case PROP_SHOWN:
e_attachment_set_shown (
E_ATTACHMENT (object),
g_value_get_boolean (value));
return;
case PROP_MIME_PART:
e_attachment_set_mime_part (
E_ATTACHMENT (object),
g_value_get_object (value));
return;
case PROP_REFERENCE:
e_attachment_set_reference (
E_ATTACHMENT (object),
g_value_get_boxed (value));
return;
case PROP_SIGNED:
e_attachment_set_signed (
E_ATTACHMENT (object),
g_value_get_int (value));
return;
}
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}
static void
attachment_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
switch (property_id) {
case PROP_CAN_SHOW:
g_value_set_boolean (
value,
e_attachment_get_can_show (
E_ATTACHMENT (object)));
return;
case PROP_DISPOSITION:
g_value_set_string (
value,
e_attachment_get_disposition (
E_ATTACHMENT (object)));
return;
case PROP_ENCRYPTED:
g_value_set_int (
value,
e_attachment_get_encrypted (
E_ATTACHMENT (object)));
return;
case PROP_FILE:
g_value_take_object (
value,
e_attachment_ref_file (
E_ATTACHMENT (object)));
return;
case PROP_FILE_INFO:
g_value_take_object (
value,
e_attachment_ref_file_info (
E_ATTACHMENT (object)));
return;
case PROP_ICON:
g_value_take_object (
value,
e_attachment_ref_icon (
E_ATTACHMENT (object)));
return;
case PROP_SHOWN:
g_value_set_boolean (
value,
e_attachment_get_shown (
E_ATTACHMENT (object)));
return;
case PROP_LOADING:
g_value_set_boolean (
value,
e_attachment_get_loading (
E_ATTACHMENT (object)));
return;
case PROP_MIME_PART:
g_value_take_object (
value,
e_attachment_ref_mime_part (
E_ATTACHMENT (object)));
return;
case PROP_PERCENT:
g_value_set_int (
value,
e_attachment_get_percent (
E_ATTACHMENT (object)));
return;
case PROP_REFERENCE:
g_value_set_boxed (
value,
e_attachment_get_reference (
E_ATTACHMENT (object)));
return;
case PROP_SAVING:
g_value_set_boolean (
value,
e_attachment_get_saving (
E_ATTACHMENT (object)));
return;
case PROP_SIGNED:
g_value_set_int (
value,
e_attachment_get_signed (
E_ATTACHMENT (object)));
return;
}
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}
static void
attachment_dispose (GObject *object)
{
EAttachmentPrivate *priv;
priv = E_ATTACHMENT_GET_PRIVATE (object);
g_clear_object (&priv->file);
g_clear_object (&priv->icon);
g_clear_object (&priv->file_info);
g_clear_object (&priv->cancellable);
g_clear_object (&priv->mime_part);
if (priv->emblem_timeout_id > 0) {
g_source_remove (priv->emblem_timeout_id);
priv->emblem_timeout_id = 0;
}
/* This accepts NULL arguments. */
gtk_tree_row_reference_free (priv->reference);
priv->reference = NULL;
/* Chain up to parent's dispose() method. */
G_OBJECT_CLASS (e_attachment_parent_class)->dispose (object);
}
static void
attachment_finalize (GObject *object)
{
EAttachmentPrivate *priv;
priv = E_ATTACHMENT_GET_PRIVATE (object);
if (priv->update_icon_column_idle_id > 0)
g_source_remove (priv->update_icon_column_idle_id);
if (priv->update_progress_columns_idle_id > 0)
g_source_remove (priv->update_progress_columns_idle_id);
if (priv->update_file_info_columns_idle_id > 0)
g_source_remove (priv->update_file_info_columns_idle_id);
g_mutex_clear (&priv->property_lock);
g_mutex_clear (&priv->idle_lock);
g_free (priv->disposition);
/* Chain up to parent's finalize() method. */
G_OBJECT_CLASS (e_attachment_parent_class)->finalize (object);
}
static void
e_attachment_class_init (EAttachmentClass *class)
{
GObjectClass *object_class;
g_type_class_add_private (class, sizeof (EAttachmentPrivate));
object_class = G_OBJECT_CLASS (class);
object_class->set_property = attachment_set_property;
object_class->get_property = attachment_get_property;
object_class->dispose = attachment_dispose;
object_class->finalize = attachment_finalize;
g_object_class_install_property (
object_class,
PROP_CAN_SHOW,
g_param_spec_boolean (
"can-show",
"Can Show",
NULL,
FALSE,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_object_class_install_property (
object_class,
PROP_DISPOSITION,
g_param_spec_string (
"disposition",
"Disposition",
NULL,
"attachment",
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
/* FIXME Define a GEnumClass for this. */
g_object_class_install_property (
object_class,
PROP_ENCRYPTED,
g_param_spec_int (
"encrypted",
"Encrypted",
NULL,
CAMEL_CIPHER_VALIDITY_ENCRYPT_NONE,
CAMEL_CIPHER_VALIDITY_ENCRYPT_STRONG,
CAMEL_CIPHER_VALIDITY_ENCRYPT_NONE,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_object_class_install_property (
object_class,
PROP_FILE,
g_param_spec_object (
"file",
"File",
NULL,
G_TYPE_FILE,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_object_class_install_property (
object_class,
PROP_FILE_INFO,
g_param_spec_object (
"file-info",
"File Info",
NULL,
G_TYPE_FILE_INFO,
G_PARAM_READABLE));
g_object_class_install_property (
object_class,
PROP_ICON,
g_param_spec_object (
"icon",
"Icon",
NULL,
G_TYPE_ICON,
G_PARAM_READABLE));
g_object_class_install_property (
object_class,
PROP_LOADING,
g_param_spec_boolean (
"loading",
"Loading",
NULL,
FALSE,
G_PARAM_READABLE));
g_object_class_install_property (
object_class,
PROP_MIME_PART,
g_param_spec_object (
"mime-part",
"MIME Part",
NULL,
CAMEL_TYPE_MIME_PART,
G_PARAM_READWRITE));
g_object_class_install_property (
object_class,
PROP_PERCENT,
g_param_spec_int (
"percent",
"Percent",
NULL,
0,
100,
0,
G_PARAM_READABLE));
g_object_class_install_property (
object_class,
PROP_REFERENCE,
g_param_spec_boxed (
"reference",
"Reference",
NULL,
GTK_TYPE_TREE_ROW_REFERENCE,
G_PARAM_READWRITE));
g_object_class_install_property (
object_class,
PROP_SAVING,
g_param_spec_boolean (
"saving",
"Saving",
NULL,
FALSE,
G_PARAM_READABLE));
g_object_class_install_property (
object_class,
PROP_SHOWN,
g_param_spec_boolean (
"shown",
"Shown",
NULL,
FALSE,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
/* FIXME Define a GEnumClass for this. */
g_object_class_install_property (
object_class,
PROP_SIGNED,
g_param_spec_int (
"signed",
"Signed",
NULL,
CAMEL_CIPHER_VALIDITY_SIGN_NONE,
CAMEL_CIPHER_VALIDITY_SIGN_NEED_PUBLIC_KEY,
CAMEL_CIPHER_VALIDITY_SIGN_NONE,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
}
static void
e_attachment_init (EAttachment *attachment)
{
attachment->priv = E_ATTACHMENT_GET_PRIVATE (attachment);
attachment->priv->cancellable = g_cancellable_new ();
attachment->priv->encrypted = CAMEL_CIPHER_VALIDITY_ENCRYPT_NONE;
attachment->priv->signed_ = CAMEL_CIPHER_VALIDITY_SIGN_NONE;
g_mutex_init (&attachment->priv->property_lock);
g_mutex_init (&attachment->priv->idle_lock);
e_signal_connect_notify (
attachment, "notify::encrypted",
G_CALLBACK (attachment_update_icon_column), NULL);
e_signal_connect_notify (
attachment, "notify::file-info",
G_CALLBACK (attachment_update_file_info_columns), NULL);
e_signal_connect_notify (
attachment, "notify::file-info",
G_CALLBACK (attachment_update_icon_column), NULL);
e_signal_connect_notify (
attachment, "notify::loading",
G_CALLBACK (attachment_update_icon_column), NULL);
e_signal_connect_notify (
attachment, "notify::loading",
G_CALLBACK (attachment_update_progress_columns), NULL);
e_signal_connect_notify (
attachment, "notify::percent",
G_CALLBACK (attachment_update_progress_columns), NULL);
e_signal_connect_notify (
attachment, "notify::reference",
G_CALLBACK (attachment_update_file_info_columns), NULL);
e_signal_connect_notify (
attachment, "notify::reference",
G_CALLBACK (attachment_update_icon_column), NULL);
e_signal_connect_notify (
attachment, "notify::reference",
G_CALLBACK (attachment_update_progress_columns), NULL);
e_signal_connect_notify (
attachment, "notify::saving",
G_CALLBACK (attachment_update_icon_column), NULL);
e_signal_connect_notify (
attachment, "notify::saving",
G_CALLBACK (attachment_update_progress_columns), NULL);
e_signal_connect_notify (
attachment, "notify::signed",
G_CALLBACK (attachment_update_icon_column), NULL);
g_signal_connect_swapped (
attachment->priv->cancellable, "cancelled",
G_CALLBACK (attachment_cancelled_cb), attachment);
}
EAttachment *
e_attachment_new (void)
{
return g_object_new (E_TYPE_ATTACHMENT, NULL);
}
EAttachment *
e_attachment_new_for_path (const gchar *path)
{
EAttachment *attachment;
GFile *file;
g_return_val_if_fail (path != NULL, NULL);
file = g_file_new_for_path (path);
attachment = g_object_new (E_TYPE_ATTACHMENT, "file", file, NULL);
g_object_unref (file);
return attachment;
}
EAttachment *
e_attachment_new_for_uri (const gchar *uri)
{
EAttachment *attachment;
GFile *file;
g_return_val_if_fail (uri != NULL, NULL);
file = g_file_new_for_uri (uri);
attachment = g_object_new (E_TYPE_ATTACHMENT, "file", file, NULL);
g_object_unref (file);
return attachment;
}
EAttachment *
e_attachment_new_for_message (CamelMimeMessage *message)
{
CamelDataWrapper *wrapper;
CamelMimePart *mime_part;
EAttachment *attachment;
GString *description;
const gchar *subject;
g_return_val_if_fail (CAMEL_IS_MIME_MESSAGE (message), NULL);
mime_part = camel_mime_part_new ();
camel_mime_part_set_disposition (mime_part, "inline");
subject = camel_mime_message_get_subject (message);
/* To Translators: This text is set as a description of an attached
* message when, for example, attaching it to a composer. When the
* message to be attached has also filled Subject, then this text is
* of form "Attached message - Subject", otherwise it's left as is. */
description = g_string_new (_("Attached message"));
if (subject != NULL)
g_string_append_printf (description, " - %s", subject);
camel_mime_part_set_description (mime_part, description->str);
g_string_free (description, TRUE);
wrapper = CAMEL_DATA_WRAPPER (message);
camel_medium_set_content (CAMEL_MEDIUM (mime_part), wrapper);
camel_mime_part_set_content_type (mime_part, "message/rfc822");
attachment = e_attachment_new ();
e_attachment_set_mime_part (attachment, mime_part);
g_object_unref (mime_part);
return attachment;
}
void
e_attachment_add_to_multipart (EAttachment *attachment,
CamelMultipart *multipart,
const gchar *default_charset)
{
CamelContentType *content_type;
CamelDataWrapper *wrapper;
CamelMimePart *mime_part;
/* XXX EMsgComposer might be a better place for this function. */
g_return_if_fail (E_IS_ATTACHMENT (attachment));
g_return_if_fail (CAMEL_IS_MULTIPART (multipart));
/* Still loading? Too bad. */
mime_part = e_attachment_ref_mime_part (attachment);
if (mime_part == NULL)
return;
content_type = camel_mime_part_get_content_type (mime_part);
wrapper = camel_medium_get_content (CAMEL_MEDIUM (mime_part));
if (CAMEL_IS_MULTIPART (wrapper))
goto exit;
/* For text content, determine the best encoding and character set. */
if (camel_content_type_is (content_type, "text", "*")) {
CamelTransferEncoding encoding;
CamelStream *filtered_stream;
CamelMimeFilter *filter;
CamelStream *stream;
const gchar *charset;
charset = camel_content_type_param (content_type, "charset");
/* Determine the best encoding by writing the MIME
* part to a NULL stream with a "bestenc" filter. */
stream = camel_stream_null_new ();
filtered_stream = camel_stream_filter_new (stream);
filter = camel_mime_filter_bestenc_new (
CAMEL_BESTENC_GET_ENCODING);
camel_stream_filter_add (
CAMEL_STREAM_FILTER (filtered_stream),
CAMEL_MIME_FILTER (filter));
camel_data_wrapper_decode_to_stream_sync (
wrapper, filtered_stream, NULL, NULL);
g_object_unref (filtered_stream);
g_object_unref (stream);
/* Retrieve the best encoding from the filter. */
encoding = camel_mime_filter_bestenc_get_best_encoding (
CAMEL_MIME_FILTER_BESTENC (filter),
CAMEL_BESTENC_8BIT);
camel_mime_part_set_encoding (mime_part, encoding);
g_object_unref (filter);
if (encoding == CAMEL_TRANSFER_ENCODING_7BIT) {
/* The text fits within us-ascii, so this is safe.
* FIXME Check that this isn't iso-2022-jp? */
default_charset = "us-ascii";
} else if (charset == NULL && default_charset == NULL) {
default_charset = attachment_get_default_charset ();
/* FIXME Check that this fits within the
* default_charset and if not, find one
* that does and/or allow the user to
* specify. */
}
if (charset == NULL) {
gchar *type;
camel_content_type_set_param (
content_type, "charset", default_charset);
type = camel_content_type_format (content_type);
camel_mime_part_set_content_type (mime_part, type);
g_free (type);
}
/* Otherwise, unless it's a message/rfc822, Base64 encode it. */
} else if (!CAMEL_IS_MIME_MESSAGE (wrapper))
camel_mime_part_set_encoding (
mime_part, CAMEL_TRANSFER_ENCODING_BASE64);
exit:
camel_multipart_add_part (multipart, mime_part);
g_clear_object (&mime_part);
}
void
e_attachment_cancel (EAttachment *attachment)
{
g_return_if_fail (E_IS_ATTACHMENT (attachment));
g_cancellable_cancel (attachment->priv->cancellable);
}
gboolean
e_attachment_get_can_show (EAttachment *attachment)
{
g_return_val_if_fail (E_IS_ATTACHMENT (attachment), FALSE);
return attachment->priv->can_show;
}
void
e_attachment_set_can_show (EAttachment *attachment,
gboolean can_show)
{
g_return_if_fail (E_IS_ATTACHMENT (attachment));
attachment->priv->can_show = can_show;
g_object_notify (G_OBJECT (attachment), "can-show");
}
const gchar *
e_attachment_get_disposition (EAttachment *attachment)
{
g_return_val_if_fail (E_IS_ATTACHMENT (attachment), NULL);
return attachment->priv->disposition;
}
gchar *
e_attachment_dup_disposition (EAttachment *attachment)
{
const gchar *protected;
gchar *duplicate;
g_return_val_if_fail (E_IS_ATTACHMENT (attachment), NULL);
g_mutex_lock (&attachment->priv->property_lock);
protected = e_attachment_get_disposition (attachment);
duplicate = g_strdup (protected);
g_mutex_unlock (&attachment->priv->property_lock);
return duplicate;
}
void
e_attachment_set_disposition (EAttachment *attachment,
const gchar *disposition)
{
g_return_if_fail (E_IS_ATTACHMENT (attachment));
g_mutex_lock (&attachment->priv->property_lock);
g_free (attachment->priv->disposition);
attachment->priv->disposition = g_strdup (disposition);
g_mutex_unlock (&attachment->priv->property_lock);
g_object_notify (G_OBJECT (attachment), "disposition");
}
GFile *
e_attachment_ref_file (EAttachment *attachment)
{
GFile *file = NULL;
g_return_val_if_fail (E_IS_ATTACHMENT (attachment), NULL);
g_mutex_lock (&attachment->priv->property_lock);
if (attachment->priv->file != NULL)
file = g_object_ref (attachment->priv->file);
g_mutex_unlock (&attachment->priv->property_lock);
return file;
}
void
e_attachment_set_file (EAttachment *attachment,
GFile *file)
{
g_return_if_fail (E_IS_ATTACHMENT (attachment));
if (file != NULL) {
g_return_if_fail (G_IS_FILE (file));
g_object_ref (file);
}
g_mutex_lock (&attachment->priv->property_lock);
g_clear_object (&attachment->priv->file);
attachment->priv->file = file;
g_mutex_unlock (&attachment->priv->property_lock);
g_object_notify (G_OBJECT (attachment), "file");
}
GFileInfo *
e_attachment_ref_file_info (EAttachment *attachment)
{
GFileInfo *file_info = NULL;
g_return_val_if_fail (E_IS_ATTACHMENT (attachment), NULL);
g_mutex_lock (&attachment->priv->property_lock);
if (attachment->priv->file_info != NULL)
file_info = g_object_ref (attachment->priv->file_info);
g_mutex_unlock (&attachment->priv->property_lock);
return file_info;
}
void
e_attachment_set_file_info (EAttachment *attachment,
GFileInfo *file_info)
{
GtkTreeRowReference *reference;
GIcon *icon;
g_return_if_fail (E_IS_ATTACHMENT (attachment));
if (file_info != NULL) {
g_return_if_fail (G_IS_FILE_INFO (file_info));
g_object_ref (file_info);
}
g_mutex_lock (&attachment->priv->property_lock);
g_clear_object (&attachment->priv->file_info);
attachment->priv->file_info = file_info;
/* If the GFileInfo contains a GThemedIcon, append a
* fallback icon name to ensure we display something. */
icon = g_file_info_get_icon (file_info);
if (G_IS_THEMED_ICON (icon))
g_themed_icon_append_name (
G_THEMED_ICON (icon), DEFAULT_ICON_NAME);
g_mutex_unlock (&attachment->priv->property_lock);
g_object_notify (G_OBJECT (attachment), "file-info");
/* Tell the EAttachmentStore its total size changed. */
reference = e_attachment_get_reference (attachment);
if (gtk_tree_row_reference_valid (reference)) {
GtkTreeModel *model;
model = gtk_tree_row_reference_get_model (reference);
g_object_notify (G_OBJECT (model), "total-size");
}
}
/**
* e_attachment_dup_mime_type:
* @attachment: an #EAttachment
*
* Returns the MIME type of @attachment according to its #GFileInfo.
* If the @attachment has no #GFileInfo then the function returns %NULL.
* Free the returned MIME type string with g_free().
*
* Returns: a newly-allocated MIME type string, or %NULL
**/
gchar *
e_attachment_dup_mime_type (EAttachment *attachment)
{
GFileInfo *file_info;
const gchar *content_type = NULL;
gchar *mime_type = NULL;
g_return_val_if_fail (E_IS_ATTACHMENT (attachment), NULL);
file_info = e_attachment_ref_file_info (attachment);
if (file_info != NULL)
content_type = g_file_info_get_content_type (file_info);
if (content_type != NULL)
mime_type = g_content_type_get_mime_type (content_type);
if (mime_type != NULL)
camel_strdown (mime_type);
g_clear_object (&file_info);
return mime_type;
}
GIcon *
e_attachment_ref_icon (EAttachment *attachment)
{
GIcon *icon = NULL;
g_return_val_if_fail (E_IS_ATTACHMENT (attachment), NULL);
g_mutex_lock (&attachment->priv->property_lock);
if (attachment->priv->icon != NULL)
icon = g_object_ref (attachment->priv->icon);
g_mutex_unlock (&attachment->priv->property_lock);
return icon;
}
gboolean
e_attachment_get_loading (EAttachment *attachment)
{
g_return_val_if_fail (E_IS_ATTACHMENT (attachment), FALSE);
return attachment->priv->loading;
}
CamelMimePart *
e_attachment_ref_mime_part (EAttachment *attachment)
{
CamelMimePart *mime_part = NULL;
g_return_val_if_fail (E_IS_ATTACHMENT (attachment), NULL);
g_mutex_lock (&attachment->priv->property_lock);
if (attachment->priv->mime_part != NULL)
mime_part = g_object_ref (attachment->priv->mime_part);
g_mutex_unlock (&attachment->priv->property_lock);
return mime_part;
}
void
e_attachment_set_mime_part (EAttachment *attachment,
CamelMimePart *mime_part)
{
g_return_if_fail (E_IS_ATTACHMENT (attachment));
if (mime_part != NULL) {
g_return_if_fail (CAMEL_IS_MIME_PART (mime_part));
g_object_ref (mime_part);
}
g_mutex_lock (&attachment->priv->property_lock);
g_clear_object (&attachment->priv->mime_part);
attachment->priv->mime_part = mime_part;
g_mutex_unlock (&attachment->priv->property_lock);
g_object_notify (G_OBJECT (attachment), "mime-part");
}
gint
e_attachment_get_percent (EAttachment *attachment)
{
g_return_val_if_fail (E_IS_ATTACHMENT (attachment), 0);
return attachment->priv->percent;
}
GtkTreeRowReference *
e_attachment_get_reference (EAttachment *attachment)
{
g_return_val_if_fail (E_IS_ATTACHMENT (attachment), NULL);
return attachment->priv->reference;
}
void
e_attachment_set_reference (EAttachment *attachment,
GtkTreeRowReference *reference)
{
g_return_if_fail (E_IS_ATTACHMENT (attachment));
if (reference != NULL)
reference = gtk_tree_row_reference_copy (reference);
gtk_tree_row_reference_free (attachment->priv->reference);
attachment->priv->reference = reference;
g_object_notify (G_OBJECT (attachment), "reference");
}
gboolean
e_attachment_get_saving (EAttachment *attachment)
{
g_return_val_if_fail (E_IS_ATTACHMENT (attachment), FALSE);
return attachment->priv->saving;
}
gboolean
e_attachment_get_shown (EAttachment *attachment)
{
g_return_val_if_fail (E_IS_ATTACHMENT (attachment), FALSE);
return attachment->priv->shown;
}
void
e_attachment_set_shown (EAttachment *attachment,
gboolean shown)
{
g_return_if_fail (E_IS_ATTACHMENT (attachment));
attachment->priv->shown = shown;
g_object_notify (G_OBJECT (attachment), "shown");
}
camel_cipher_validity_encrypt_t
e_attachment_get_encrypted (EAttachment *attachment)
{
g_return_val_if_fail (
E_IS_ATTACHMENT (attachment),
CAMEL_CIPHER_VALIDITY_ENCRYPT_NONE);
return attachment->priv->encrypted;
}
void
e_attachment_set_encrypted (EAttachment *attachment,
camel_cipher_validity_encrypt_t encrypted)
{
g_return_if_fail (E_IS_ATTACHMENT (attachment));
attachment->priv->encrypted = encrypted;
g_object_notify (G_OBJECT (attachment), "encrypted");
}
camel_cipher_validity_sign_t
e_attachment_get_signed (EAttachment *attachment)
{
g_return_val_if_fail (
E_IS_ATTACHMENT (attachment),
CAMEL_CIPHER_VALIDITY_SIGN_NONE);
return attachment->priv->signed_;
}
void
e_attachment_set_signed (EAttachment *attachment,
camel_cipher_validity_sign_t signed_)
{
g_return_if_fail (E_IS_ATTACHMENT (attachment));
attachment->priv->signed_ = signed_;
g_object_notify (G_OBJECT (attachment), "signed");
}
gchar *
e_attachment_dup_description (EAttachment *attachment)
{
GFileInfo *file_info;
const gchar *attribute;
const gchar *protected;
gchar *duplicate;
g_return_val_if_fail (E_IS_ATTACHMENT (attachment), NULL);
file_info = e_attachment_ref_file_info (attachment);
if (file_info == NULL)
return NULL;
attribute = G_FILE_ATTRIBUTE_STANDARD_DESCRIPTION;
protected = g_file_info_get_attribute_string (file_info, attribute);
duplicate = g_strdup (protected);
g_object_unref (file_info);
return duplicate;
}
gchar *
e_attachment_dup_thumbnail_path (EAttachment *attachment)
{
GFileInfo *file_info;
const gchar *attribute;
const gchar *protected;
gchar *duplicate;
g_return_val_if_fail (E_IS_ATTACHMENT (attachment), NULL);
file_info = e_attachment_ref_file_info (attachment);
if (file_info == NULL)
return NULL;
attribute = G_FILE_ATTRIBUTE_THUMBNAIL_PATH;
protected = g_file_info_get_attribute_string (file_info, attribute);
duplicate = g_strdup (protected);
g_object_unref (file_info);
return duplicate;
}
gboolean
e_attachment_is_rfc822 (EAttachment *attachment)
{
gchar *mime_type;
gboolean is_rfc822;
g_return_val_if_fail (E_IS_ATTACHMENT (attachment), FALSE);
mime_type = e_attachment_dup_mime_type (attachment);
is_rfc822 =
(mime_type != NULL) &&
(g_ascii_strcasecmp (mime_type, "message/rfc822") == 0);
g_free (mime_type);
return is_rfc822;
}
GList *
e_attachment_list_apps (EAttachment *attachment)
{
GList *app_info_list;
GList *guessed_infos;
GFileInfo *file_info;
const gchar *content_type;
const gchar *display_name;
gboolean type_is_unknown;
gchar *allocated;
g_return_val_if_fail (E_IS_ATTACHMENT (attachment), NULL);
file_info = e_attachment_ref_file_info (attachment);
if (file_info == NULL)
return NULL;
content_type = g_file_info_get_content_type (file_info);
display_name = g_file_info_get_display_name (file_info);
g_return_val_if_fail (content_type != NULL, NULL);
app_info_list = g_app_info_get_all_for_type (content_type);
type_is_unknown = g_content_type_is_unknown (content_type);
if (app_info_list != NULL && !type_is_unknown)
goto exit;
if (display_name == NULL)
goto exit;
allocated = g_content_type_guess (display_name, NULL, 0, NULL);
guessed_infos = g_app_info_get_all_for_type (allocated);
app_info_list = g_list_concat (guessed_infos, app_info_list);
g_free (allocated);
exit:
g_clear_object (&file_info);
return app_info_list;
}
/************************* e_attachment_load_async() *************************/
typedef struct _LoadContext LoadContext;
struct _LoadContext {
EAttachment *attachment;
CamelMimePart *mime_part;
GSimpleAsyncResult *simple;
GInputStream *input_stream;
GOutputStream *output_stream;
GFileInfo *file_info;
goffset total_num_bytes;
gssize bytes_read;
gchar buffer[4096];
};
/* Forward Declaration */
static void
attachment_load_stream_read_cb (GInputStream *input_stream,
GAsyncResult *result,
LoadContext *load_context);
static LoadContext *
attachment_load_context_new (EAttachment *attachment,
GAsyncReadyCallback callback,
gpointer user_data)
{
LoadContext *load_context;
GSimpleAsyncResult *simple;
simple = g_simple_async_result_new (
G_OBJECT (attachment), callback,
user_data, e_attachment_load_async);
load_context = g_slice_new0 (LoadContext);
load_context->attachment = g_object_ref (attachment);
load_context->simple = simple;
attachment_set_loading (load_context->attachment, TRUE);
return load_context;
}
static void
attachment_load_context_free (LoadContext *load_context)
{
g_object_unref (load_context->attachment);
if (load_context->mime_part != NULL)
g_object_unref (load_context->mime_part);
if (load_context->simple)
g_object_unref (load_context->simple);
if (load_context->input_stream != NULL)
g_object_unref (load_context->input_stream);
if (load_context->output_stream != NULL)
g_object_unref (load_context->output_stream);
if (load_context->file_info != NULL)
g_object_unref (load_context->file_info);
g_slice_free (LoadContext, load_context);
}
static gboolean
attachment_load_check_for_error (LoadContext *load_context,
GError *error)
{
GSimpleAsyncResult *simple;
if (error == NULL)
return FALSE;
simple = load_context->simple;
g_simple_async_result_take_error (simple, error);
g_simple_async_result_complete (simple);
attachment_load_context_free (load_context);
return TRUE;
}
static void
attachment_load_finish (LoadContext *load_context)
{
GFileInfo *file_info;
EAttachment *attachment;
GMemoryOutputStream *output_stream;
GSimpleAsyncResult *simple;
CamelDataWrapper *wrapper;
CamelMimePart *mime_part;
CamelStream *stream;
const gchar *attribute;
const gchar *content_type;
const gchar *display_name;
const gchar *description;
const gchar *disposition;
gchar *mime_type;
gpointer data;
gsize size;
simple = load_context->simple;
file_info = load_context->file_info;
attachment = load_context->attachment;
output_stream = G_MEMORY_OUTPUT_STREAM (load_context->output_stream);
if (e_attachment_is_rfc822 (attachment))
wrapper = (CamelDataWrapper *) camel_mime_message_new ();
else
wrapper = camel_data_wrapper_new ();
content_type = g_file_info_get_content_type (file_info);
mime_type = g_content_type_get_mime_type (content_type);
data = g_memory_output_stream_get_data (output_stream);
size = g_memory_output_stream_get_data_size (output_stream);
stream = camel_stream_mem_new_with_buffer (data, size);
camel_data_wrapper_construct_from_stream_sync (
wrapper, stream, NULL, NULL);
camel_data_wrapper_set_mime_type (wrapper, mime_type);
camel_stream_close (stream, NULL, NULL);
g_object_unref (stream);
mime_part = camel_mime_part_new ();
camel_medium_set_content (CAMEL_MEDIUM (mime_part), wrapper);
g_object_unref (wrapper);
g_free (mime_type);
display_name = g_file_info_get_display_name (file_info);
if (display_name != NULL)
camel_mime_part_set_filename (mime_part, display_name);
attribute = G_FILE_ATTRIBUTE_STANDARD_DESCRIPTION;
description = g_file_info_get_attribute_string (file_info, attribute);
if (description != NULL)
camel_mime_part_set_description (mime_part, description);
disposition = e_attachment_get_disposition (attachment);
if (disposition != NULL)
camel_mime_part_set_disposition (mime_part, disposition);
/* Correctly report the size of zero length special files. */
if (g_file_info_get_size (file_info) == 0)
g_file_info_set_size (file_info, size);
load_context->mime_part = mime_part;
g_simple_async_result_set_op_res_gpointer (
simple, load_context,
(GDestroyNotify) attachment_load_context_free);
g_simple_async_result_complete (simple);
/* Make sure it's freed on operation end. */
g_clear_object (&load_context->simple);
}
static void
attachment_load_write_cb (GOutputStream *output_stream,
GAsyncResult *result,
LoadContext *load_context)
{
EAttachment *attachment;
GCancellable *cancellable;
GInputStream *input_stream;
gssize bytes_written;
GError *error = NULL;
bytes_written = g_output_stream_write_finish (
output_stream, result, &error);
if (attachment_load_check_for_error (load_context, error))
return;
attachment = load_context->attachment;
cancellable = attachment->priv->cancellable;
input_stream = load_context->input_stream;
attachment_progress_cb (
g_seekable_tell (G_SEEKABLE (output_stream)),
load_context->total_num_bytes, attachment);
if (bytes_written < load_context->bytes_read) {
memmove (
load_context->buffer,
load_context->buffer + bytes_written,
load_context->bytes_read - bytes_written);
load_context->bytes_read -= bytes_written;
g_output_stream_write_async (
output_stream,
load_context->buffer,
load_context->bytes_read,
G_PRIORITY_DEFAULT, cancellable,
(GAsyncReadyCallback) attachment_load_write_cb,
load_context);
} else
g_input_stream_read_async (
input_stream,
load_context->buffer,
sizeof (load_context->buffer),
G_PRIORITY_DEFAULT, cancellable,
(GAsyncReadyCallback) attachment_load_stream_read_cb,
load_context);
}
static void
attachment_load_stream_read_cb (GInputStream *input_stream,
GAsyncResult *result,
LoadContext *load_context)
{
EAttachment *attachment;
GCancellable *cancellable;
GOutputStream *output_stream;
gssize bytes_read;
GError *error = NULL;
bytes_read = g_input_stream_read_finish (
input_stream, result, &error);
if (attachment_load_check_for_error (load_context, error))
return;
if (bytes_read == 0) {
attachment_load_finish (load_context);
return;
}
attachment = load_context->attachment;
cancellable = attachment->priv->cancellable;
output_stream = load_context->output_stream;
load_context->bytes_read = bytes_read;
g_output_stream_write_async (
output_stream,
load_context->buffer,
load_context->bytes_read,
G_PRIORITY_DEFAULT, cancellable,
(GAsyncReadyCallback) attachment_load_write_cb,
load_context);
}
static void
attachment_load_file_read_cb (GFile *file,
GAsyncResult *result,
LoadContext *load_context)
{
EAttachment *attachment;
GCancellable *cancellable;
GFileInputStream *input_stream;
GOutputStream *output_stream;
GError *error = NULL;
/* Input stream might be NULL, so don't use cast macro. */
input_stream = g_file_read_finish (file, result, &error);
load_context->input_stream = (GInputStream *) input_stream;
if (attachment_load_check_for_error (load_context, error))
return;
/* Load the contents into a GMemoryOutputStream. */
output_stream = g_memory_output_stream_new (
NULL, 0, g_realloc, g_free);
attachment = load_context->attachment;
cancellable = attachment->priv->cancellable;
load_context->output_stream = output_stream;
g_input_stream_read_async (
load_context->input_stream,
load_context->buffer,
sizeof (load_context->buffer),
G_PRIORITY_DEFAULT, cancellable,
(GAsyncReadyCallback) attachment_load_stream_read_cb,
load_context);
}
static void
attachment_load_query_info_cb (GFile *file,
GAsyncResult *result,
LoadContext *load_context)
{
EAttachment *attachment;
GCancellable *cancellable;
GFileInfo *file_info;
GError *error = NULL;
attachment = load_context->attachment;
cancellable = attachment->priv->cancellable;
file_info = g_file_query_info_finish (file, result, &error);
if (attachment_load_check_for_error (load_context, error))
return;
e_attachment_set_file_info (attachment, file_info);
load_context->file_info = file_info;
load_context->total_num_bytes = g_file_info_get_size (file_info);
g_file_read_async (
file, G_PRIORITY_DEFAULT,
cancellable, (GAsyncReadyCallback)
attachment_load_file_read_cb, load_context);
}
#define ATTACHMENT_LOAD_CONTEXT "attachment-load-context-data"
static void
attachment_load_from_mime_part_thread (GSimpleAsyncResult *simple,
GObject *object,
GCancellable *cancellable)
{
LoadContext *load_context;
GFileInfo *file_info;
EAttachment *attachment;
CamelContentType *content_type;
CamelMimePart *mime_part;
const gchar *attribute;
const gchar *string;
gchar *allocated, *decoded_string = NULL;
CamelStream *null;
CamelDataWrapper *dw;
load_context = g_object_get_data (
G_OBJECT (simple), ATTACHMENT_LOAD_CONTEXT);
g_return_if_fail (load_context != NULL);
g_object_set_data (G_OBJECT (simple), ATTACHMENT_LOAD_CONTEXT, NULL);
attachment = load_context->attachment;
mime_part = e_attachment_ref_mime_part (attachment);
file_info = g_file_info_new ();
load_context->file_info = file_info;
content_type = camel_mime_part_get_content_type (mime_part);
allocated = camel_content_type_simple (content_type);
if (allocated != NULL) {
GIcon *icon;
gchar *cp;
/* GIO expects lowercase MIME types. */
for (cp = allocated; *cp != '\0'; cp++)
*cp = g_ascii_tolower (*cp);
/* Swap the MIME type for a content type. */
cp = g_content_type_from_mime_type (allocated);
g_free (allocated);
allocated = cp;
/* Use the MIME part's filename if we have to. */
if (g_content_type_is_unknown (allocated)) {
string = camel_mime_part_get_filename (mime_part);
if (string != NULL) {
g_free (allocated);
allocated = g_content_type_guess (
string, NULL, 0, NULL);
}
}
g_file_info_set_content_type (file_info, allocated);
icon = g_content_type_get_icon (allocated);
if (icon != NULL) {
g_file_info_set_icon (file_info, icon);
g_object_unref (icon);
}
}
g_free (allocated);
/* Strip any path components from the filename. */
string = camel_mime_part_get_filename (mime_part);
if (string == NULL) {
/* Translators: Default attachment filename. */
string = _("attachment.dat");
if (camel_content_type_is (content_type, "message", "rfc822")) {
CamelMimeMessage *msg = NULL;
const gchar *subject = NULL;
if (CAMEL_IS_MIME_MESSAGE (mime_part)) {
msg = CAMEL_MIME_MESSAGE (mime_part);
} else {
CamelDataWrapper *content;
content = camel_medium_get_content (
CAMEL_MEDIUM (mime_part));
if (CAMEL_IS_MIME_MESSAGE (content))
msg = CAMEL_MIME_MESSAGE (content);
}
if (msg != NULL)
subject = camel_mime_message_get_subject (msg);
if (subject != NULL && *subject != '\0')
string = subject;
}
} else {
decoded_string = camel_header_decode_string (string, "UTF-8");
if (decoded_string != NULL &&
*decoded_string != '\0' &&
!g_str_equal (decoded_string, string)) {
string = decoded_string;
} else {
g_free (decoded_string);
decoded_string = NULL;
}
}
allocated = g_path_get_basename (string);
g_file_info_set_display_name (file_info, allocated);
g_free (decoded_string);
g_free (allocated);
attribute = G_FILE_ATTRIBUTE_STANDARD_DESCRIPTION;
string = camel_mime_part_get_description (mime_part);
if (string != NULL)
g_file_info_set_attribute_string (
file_info, attribute, string);
dw = camel_medium_get_content (CAMEL_MEDIUM (mime_part));
null = camel_stream_null_new ();
/* this actually downloads the part and makes it available later */
camel_data_wrapper_decode_to_stream_sync (
dw, null, attachment->priv->cancellable, NULL);
g_file_info_set_size (file_info, CAMEL_STREAM_NULL (null)->written);
g_object_unref (null);
load_context->mime_part = g_object_ref (mime_part);
/* Make sure it's freed on operation end. */
g_clear_object (&load_context->simple);
g_simple_async_result_set_op_res_gpointer (
simple, load_context,
(GDestroyNotify) attachment_load_context_free);
g_clear_object (&mime_part);
}
void
e_attachment_load_async (EAttachment *attachment,
GAsyncReadyCallback callback,
gpointer user_data)
{
LoadContext *load_context;
GCancellable *cancellable;
CamelMimePart *mime_part;
GFile *file;
g_return_if_fail (E_IS_ATTACHMENT (attachment));
if (e_attachment_get_loading (attachment)) {
g_simple_async_report_error_in_idle (
G_OBJECT (attachment), callback, user_data,
G_IO_ERROR, G_IO_ERROR_BUSY,
_("A load operation is already in progress"));
return;
}
if (e_attachment_get_saving (attachment)) {
g_simple_async_report_error_in_idle (
G_OBJECT (attachment), callback, user_data,
G_IO_ERROR, G_IO_ERROR_BUSY,
_("A save operation is already in progress"));
return;
}
file = e_attachment_ref_file (attachment);
mime_part = e_attachment_ref_mime_part (attachment);
g_return_if_fail (file != NULL || mime_part != NULL);
load_context = attachment_load_context_new (
attachment, callback, user_data);
cancellable = attachment->priv->cancellable;
g_cancellable_reset (cancellable);
if (file != NULL) {
g_file_query_info_async (
file, ATTACHMENT_QUERY,
G_FILE_QUERY_INFO_NONE,G_PRIORITY_DEFAULT,
cancellable, (GAsyncReadyCallback)
attachment_load_query_info_cb, load_context);
} else if (mime_part != NULL) {
g_object_set_data (
G_OBJECT (load_context->simple),
ATTACHMENT_LOAD_CONTEXT, load_context);
g_simple_async_result_run_in_thread (
load_context->simple,
attachment_load_from_mime_part_thread,
G_PRIORITY_DEFAULT,
cancellable);
}
g_clear_object (&file);
g_clear_object (&mime_part);
}
gboolean
e_attachment_load_finish (EAttachment *attachment,
GAsyncResult *result,
GError **error)
{
GSimpleAsyncResult *simple;
const LoadContext *load_context;
g_return_val_if_fail (E_IS_ATTACHMENT (attachment), FALSE);
g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (result), FALSE);
simple = G_SIMPLE_ASYNC_RESULT (result);
if (g_simple_async_result_propagate_error (simple, error)) {
attachment_set_loading (attachment, FALSE);
return FALSE;
}
load_context = g_simple_async_result_get_op_res_gpointer (simple);
if (load_context != NULL && load_context->mime_part != NULL) {
const gchar *string;
string = camel_mime_part_get_disposition (
load_context->mime_part);
e_attachment_set_disposition (attachment, string);
e_attachment_set_file_info (
attachment, load_context->file_info);
e_attachment_set_mime_part (
attachment, load_context->mime_part);
}
attachment_set_loading (attachment, FALSE);
return (load_context != NULL);
}
void
e_attachment_load_handle_error (EAttachment *attachment,
GAsyncResult *result,
GtkWindow *parent)
{
GtkWidget *dialog;
GFileInfo *file_info;
GtkTreeRowReference *reference;
const gchar *display_name;
const gchar *primary_text;
GError *error = NULL;
g_return_if_fail (E_IS_ATTACHMENT (attachment));
g_return_if_fail (G_IS_ASYNC_RESULT (result));
g_return_if_fail (!parent || GTK_IS_WINDOW (parent));
if (e_attachment_load_finish (attachment, result, &error))
return;
/* XXX Calling EAttachmentStore functions from here violates
* the abstraction, but for now it's not hurting anything. */
reference = e_attachment_get_reference (attachment);
if (gtk_tree_row_reference_valid (reference)) {
GtkTreeModel *model;
model = gtk_tree_row_reference_get_model (reference);
e_attachment_store_remove_attachment (
E_ATTACHMENT_STORE (model), attachment);
}
/* Ignore cancellations. */
if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
g_error_free (error);
return;
}
file_info = e_attachment_ref_file_info (attachment);
if (file_info != NULL)
display_name = g_file_info_get_display_name (file_info);
else
display_name = NULL;
if (display_name != NULL)
primary_text = g_strdup_printf (
_("Could not load '%s'"), display_name);
else
primary_text = g_strdup_printf (
_("Could not load the attachment"));
g_clear_object (&file_info);
dialog = gtk_message_dialog_new_with_markup (
parent, GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
"<big><b>%s</b></big>", primary_text);
gtk_message_dialog_format_secondary_text (
GTK_MESSAGE_DIALOG (dialog), "%s", error->message);
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
g_error_free (error);
}
gboolean
e_attachment_load (EAttachment *attachment,
GError **error)
{
EAsyncClosure *closure;
GAsyncResult *result;
gboolean success;
g_return_val_if_fail (E_IS_ATTACHMENT (attachment), FALSE);
closure = e_async_closure_new ();
e_attachment_load_async (
attachment, e_async_closure_callback, closure);
result = e_async_closure_wait (closure);
success = e_attachment_load_finish (attachment, result, error);
e_async_closure_free (closure);
return success;
}
/************************* e_attachment_open_async() *************************/
typedef struct _OpenContext OpenContext;
struct _OpenContext {
EAttachment *attachment;
GSimpleAsyncResult *simple;
GAppInfo *app_info;
};
static OpenContext *
attachment_open_context_new (EAttachment *attachment,
GAsyncReadyCallback callback,
gpointer user_data)
{
OpenContext *open_context;
GSimpleAsyncResult *simple;
simple = g_simple_async_result_new (
G_OBJECT (attachment), callback,
user_data, e_attachment_open_async);
open_context = g_slice_new0 (OpenContext);
open_context->attachment = g_object_ref (attachment);
open_context->simple = simple;
return open_context;
}
static void
attachment_open_context_free (OpenContext *open_context)
{
g_object_unref (open_context->attachment);
g_object_unref (open_context->simple);
if (open_context->app_info != NULL)
g_object_unref (open_context->app_info);
g_slice_free (OpenContext, open_context);
}
static gboolean
attachment_open_check_for_error (OpenContext *open_context,
GError *error)
{
GSimpleAsyncResult *simple;
if (error == NULL)
return FALSE;
simple = open_context->simple;
g_simple_async_result_take_error (simple, error);
g_simple_async_result_complete (simple);
attachment_open_context_free (open_context);
return TRUE;
}
static void
attachment_open_file (GFile *file,
OpenContext *open_context)
{
GdkAppLaunchContext *context;
GSimpleAsyncResult *simple;
GdkDisplay *display;
gboolean success;
GError *error = NULL;
simple = open_context->simple;
display = gdk_display_get_default ();
context = gdk_display_get_app_launch_context (display);
if (open_context->app_info != NULL) {
GList *file_list;
file_list = g_list_prepend (NULL, file);
success = g_app_info_launch (
open_context->app_info, file_list,
G_APP_LAUNCH_CONTEXT (context), &error);
g_list_free (file_list);
} else {
gchar *uri;
uri = g_file_get_uri (file);
success = g_app_info_launch_default_for_uri (
uri, G_APP_LAUNCH_CONTEXT (context), &error);
g_free (uri);
}
g_object_unref (context);
g_simple_async_result_set_op_res_gboolean (simple, success);
if (error != NULL)
g_simple_async_result_take_error (simple, error);
g_simple_async_result_complete (simple);
attachment_open_context_free (open_context);
}
static void
attachment_open_save_finished_cb (EAttachment *attachment,
GAsyncResult *result,
OpenContext *open_context)
{
GFile *file;
gchar *path;
GError *error = NULL;
file = e_attachment_save_finish (attachment, result, &error);
if (attachment_open_check_for_error (open_context, error))
return;
/* Make the temporary file read-only.
*
* This step is non-critical, so if an error occurs just
* emit a warning and move on.
*
* XXX I haven't figured out how to do this through GIO.
* Attempting to set the "access::can-write" attribute via
* g_file_set_attribute() returned G_IO_ERROR_NOT_SUPPORTED
* and the only other possibility I see is "unix::mode",
* which is obviously not portable.
*/
path = g_file_get_path (file);
#ifndef G_OS_WIN32
if (g_chmod (path, S_IRUSR | S_IRGRP | S_IROTH) < 0)
g_warning ("%s", g_strerror (errno));
#endif
g_free (path);
attachment_open_file (file, open_context);
g_object_unref (file);
}
static void
attachment_open_save_temporary (OpenContext *open_context)
{
GFile *temp_directory;
gchar *template;
gchar *path;
GError *error = NULL;
errno = 0;
/* Save the file to a temporary directory.
* We use a directory so the files can retain their basenames.
* XXX This could trigger a blocking temp directory cleanup. */
template = g_strdup_printf (PACKAGE "-%s-XXXXXX", g_get_user_name ());
path = e_mkdtemp (template);
g_free (template);
/* XXX Let's hope errno got set properly. */
if (path == NULL)
g_set_error (
&error, G_FILE_ERROR,
g_file_error_from_errno (errno),
"%s", g_strerror (errno));
/* We already know if there's an error, but this does the cleanup. */
if (attachment_open_check_for_error (open_context, error))
return;
temp_directory = g_file_new_for_path (path);
e_attachment_save_async (
open_context->attachment,
temp_directory, (GAsyncReadyCallback)
attachment_open_save_finished_cb, open_context);
g_object_unref (temp_directory);
g_free (path);
}
void
e_attachment_open_async (EAttachment *attachment,
GAppInfo *app_info,
GAsyncReadyCallback callback,
gpointer user_data)
{
OpenContext *open_context;
CamelMimePart *mime_part;
GFile *file;
g_return_if_fail (E_IS_ATTACHMENT (attachment));
file = e_attachment_ref_file (attachment);
mime_part = e_attachment_ref_mime_part (attachment);
g_return_if_fail (file != NULL || mime_part != NULL);
open_context = attachment_open_context_new (
attachment, callback, user_data);
if (G_IS_APP_INFO (app_info))
open_context->app_info = g_object_ref (app_info);
/* If the attachment already references a GFile, we can launch
* the application directly. Otherwise we have to save the MIME
* part to a temporary file and launch the application from that. */
if (file != NULL) {
attachment_open_file (file, open_context);
} else if (mime_part != NULL)
attachment_open_save_temporary (open_context);
g_clear_object (&file);
g_clear_object (&mime_part);
}
gboolean
e_attachment_open_finish (EAttachment *attachment,
GAsyncResult *result,
GError **error)
{
GSimpleAsyncResult *simple;
gboolean success;
g_return_val_if_fail (E_IS_ATTACHMENT (attachment), FALSE);
g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (result), FALSE);
simple = G_SIMPLE_ASYNC_RESULT (result);
success = !g_simple_async_result_propagate_error (simple, error) &&
g_simple_async_result_get_op_res_gboolean (simple);
return success;
}
void
e_attachment_open_handle_error (EAttachment *attachment,
GAsyncResult *result,
GtkWindow *parent)
{
GtkWidget *dialog;
GFileInfo *file_info;
const gchar *display_name;
const gchar *primary_text;
GError *error = NULL;
g_return_if_fail (E_IS_ATTACHMENT (attachment));
g_return_if_fail (G_IS_ASYNC_RESULT (result));
g_return_if_fail (GTK_IS_WINDOW (parent));
if (e_attachment_open_finish (attachment, result, &error))
return;
/* Ignore cancellations. */
if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
return;
file_info = e_attachment_ref_file_info (attachment);
if (file_info != NULL)
display_name = g_file_info_get_display_name (file_info);
else
display_name = NULL;
if (display_name != NULL)
primary_text = g_strdup_printf (
_("Could not open '%s'"), display_name);
else
primary_text = g_strdup_printf (
_("Could not open the attachment"));
g_clear_object (&file_info);
dialog = gtk_message_dialog_new_with_markup (
parent, GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
"<big><b>%s</b></big>", primary_text);
gtk_message_dialog_format_secondary_text (
GTK_MESSAGE_DIALOG (dialog), "%s", error->message);
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
g_error_free (error);
}
gboolean
e_attachment_open (EAttachment *attachment,
GAppInfo *app_info,
GError **error)
{
EAsyncClosure *closure;
GAsyncResult *result;
gboolean success;
g_return_val_if_fail (E_IS_ATTACHMENT (attachment), FALSE);
closure = e_async_closure_new ();
e_attachment_open_async (
attachment, app_info,
e_async_closure_callback, closure);
result = e_async_closure_wait (closure);
success = e_attachment_open_finish (attachment, result, error);
e_async_closure_free (closure);
return success;
}
/************************* e_attachment_save_async() *************************/
typedef struct _SaveContext SaveContext;
struct _SaveContext {
EAttachment *attachment;
GSimpleAsyncResult *simple;
GFile *directory;
GFile *destination;
GInputStream *input_stream;
GOutputStream *output_stream;
goffset total_num_bytes;
gssize bytes_read;
gchar buffer[4096];
gint count;
};
/* Forward Declaration */
static void
attachment_save_read_cb (GInputStream *input_stream,
GAsyncResult *result,
SaveContext *save_context);
static SaveContext *
attachment_save_context_new (EAttachment *attachment,
GAsyncReadyCallback callback,
gpointer user_data)
{
SaveContext *save_context;
GSimpleAsyncResult *simple;
simple = g_simple_async_result_new (
G_OBJECT (attachment), callback,
user_data, e_attachment_save_async);
save_context = g_slice_new0 (SaveContext);
save_context->attachment = g_object_ref (attachment);
save_context->simple = simple;
attachment_set_saving (save_context->attachment, TRUE);
return save_context;
}
static void
attachment_save_context_free (SaveContext *save_context)
{
g_object_unref (save_context->attachment);
g_object_unref (save_context->simple);
if (save_context->directory != NULL)
g_object_unref (save_context->directory);
if (save_context->destination != NULL)
g_object_unref (save_context->destination);
if (save_context->input_stream != NULL)
g_object_unref (save_context->input_stream);
if (save_context->output_stream != NULL)
g_object_unref (save_context->output_stream);
g_slice_free (SaveContext, save_context);
}
static gboolean
attachment_save_check_for_error (SaveContext *save_context,
GError *error)
{
GSimpleAsyncResult *simple;
if (error == NULL)
return FALSE;
simple = save_context->simple;
g_simple_async_result_take_error (simple, error);
g_simple_async_result_complete (simple);
attachment_save_context_free (save_context);
return TRUE;
}
static GFile *
attachment_save_new_candidate (SaveContext *save_context)
{
GFile *candidate;
GFileInfo *file_info;
EAttachment *attachment;
const gchar *display_name = NULL;
gchar *basename;
attachment = save_context->attachment;
file_info = e_attachment_ref_file_info (attachment);
if (file_info != NULL)
display_name = g_file_info_get_display_name (file_info);
if (display_name == NULL)
/* Translators: Default attachment filename. */
display_name = _("attachment.dat");
if (save_context->count == 0)
basename = g_strdup (display_name);
else {
GString *string;
const gchar *ext;
gsize length;
string = g_string_sized_new (strlen (display_name));
ext = g_utf8_strchr (display_name, -1, '.');
if (ext != NULL)
length = ext - display_name;
else
length = strlen (display_name);
g_string_append_len (string, display_name, length);
g_string_append_printf (string, " (%d)", save_context->count);
g_string_append (string, (ext != NULL) ? ext : "");
basename = g_string_free (string, FALSE);
}
save_context->count++;
candidate = g_file_get_child (save_context->directory, basename);
g_free (basename);
g_clear_object (&file_info);
return candidate;
}
static void
attachment_save_write_cb (GOutputStream *output_stream,
GAsyncResult *result,
SaveContext *save_context)
{
EAttachment *attachment;
GCancellable *cancellable;
GInputStream *input_stream;
gssize bytes_written;
GError *error = NULL;
bytes_written = g_output_stream_write_finish (
output_stream, result, &error);
if (attachment_save_check_for_error (save_context, error))
return;
attachment = save_context->attachment;
cancellable = attachment->priv->cancellable;
input_stream = save_context->input_stream;
if (bytes_written < save_context->bytes_read) {
memmove (
save_context->buffer,
save_context->buffer + bytes_written,
save_context->bytes_read - bytes_written);
save_context->bytes_read -= bytes_written;
g_output_stream_write_async (
output_stream,
save_context->buffer,
save_context->bytes_read,
G_PRIORITY_DEFAULT, cancellable,
(GAsyncReadyCallback) attachment_save_write_cb,
save_context);
} else
g_input_stream_read_async (
input_stream,
save_context->buffer,
sizeof (save_context->buffer),
G_PRIORITY_DEFAULT, cancellable,
(GAsyncReadyCallback) attachment_save_read_cb,
save_context);
}
static void
attachment_save_read_cb (GInputStream *input_stream,
GAsyncResult *result,
SaveContext *save_context)
{
EAttachment *attachment;
GCancellable *cancellable;
GOutputStream *output_stream;
gssize bytes_read;
GError *error = NULL;
bytes_read = g_input_stream_read_finish (
input_stream, result, &error);
if (attachment_save_check_for_error (save_context, error))
return;
if (bytes_read == 0) {
GSimpleAsyncResult *simple;
GFile *destination;
/* Steal the destination. */
destination = save_context->destination;
save_context->destination = NULL;
simple = save_context->simple;
g_simple_async_result_set_op_res_gpointer (
simple, destination, (GDestroyNotify) g_object_unref);
g_simple_async_result_complete (simple);
attachment_save_context_free (save_context);
return;
}
attachment = save_context->attachment;
cancellable = attachment->priv->cancellable;
output_stream = save_context->output_stream;
save_context->bytes_read = bytes_read;
attachment_progress_cb (
g_seekable_tell (G_SEEKABLE (input_stream)),
save_context->total_num_bytes, attachment);
g_output_stream_write_async (
output_stream,
save_context->buffer,
save_context->bytes_read,
G_PRIORITY_DEFAULT, cancellable,
(GAsyncReadyCallback) attachment_save_write_cb,
save_context);
}
static void
attachment_save_got_output_stream (SaveContext *save_context)
{
GCancellable *cancellable;
GInputStream *input_stream;
CamelDataWrapper *wrapper;
CamelMimePart *mime_part;
CamelStream *stream;
EAttachment *attachment;
GByteArray *buffer;
attachment = save_context->attachment;
cancellable = attachment->priv->cancellable;
mime_part = e_attachment_ref_mime_part (attachment);
/* Decode the MIME part to an in-memory buffer. We have to do
* this because CamelStream is synchronous-only, and using threads
* is dangerous because CamelDataWrapper is not reentrant. */
buffer = g_byte_array_new ();
stream = camel_stream_mem_new ();
camel_stream_mem_set_byte_array (CAMEL_STREAM_MEM (stream), buffer);
wrapper = camel_medium_get_content (CAMEL_MEDIUM (mime_part));
camel_data_wrapper_decode_to_stream_sync (wrapper, stream, NULL, NULL);
g_object_unref (stream);
/* Load the buffer into a GMemoryInputStream.
* But watch out for zero length MIME parts. */
input_stream = g_memory_input_stream_new ();
if (buffer->len > 0)
g_memory_input_stream_add_data (
G_MEMORY_INPUT_STREAM (input_stream),
buffer->data, (gssize) buffer->len,
(GDestroyNotify) g_free);
save_context->input_stream = input_stream;
save_context->total_num_bytes = (goffset) buffer->len;
g_byte_array_free (buffer, FALSE);
g_input_stream_read_async (
input_stream,
save_context->buffer,
sizeof (save_context->buffer),
G_PRIORITY_DEFAULT, cancellable,
(GAsyncReadyCallback) attachment_save_read_cb,
save_context);
g_clear_object (&mime_part);
}
static void
attachment_save_create_cb (GFile *destination,
GAsyncResult *result,
SaveContext *save_context)
{
EAttachment *attachment;
GCancellable *cancellable;
GFileOutputStream *output_stream;
GError *error = NULL;
/* Output stream might be NULL, so don't use cast macro. */
output_stream = g_file_create_finish (destination, result, &error);
save_context->output_stream = (GOutputStream *) output_stream;
attachment = save_context->attachment;
cancellable = attachment->priv->cancellable;
if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_EXISTS)) {
destination = attachment_save_new_candidate (save_context);
g_file_create_async (
destination, G_FILE_CREATE_NONE,
G_PRIORITY_DEFAULT, cancellable,
(GAsyncReadyCallback) attachment_save_create_cb,
save_context);
g_object_unref (destination);
g_error_free (error);
return;
}
if (attachment_save_check_for_error (save_context, error))
return;
save_context->destination = g_object_ref (destination);
attachment_save_got_output_stream (save_context);
}
static void
attachment_save_replace_cb (GFile *destination,
GAsyncResult *result,
SaveContext *save_context)
{
GFileOutputStream *output_stream;
GError *error = NULL;
/* Output stream might be NULL, so don't use cast macro. */
output_stream = g_file_replace_finish (destination, result, &error);
save_context->output_stream = (GOutputStream *) output_stream;
if (attachment_save_check_for_error (save_context, error))
return;
save_context->destination = g_object_ref (destination);
attachment_save_got_output_stream (save_context);
}
static void
attachment_save_query_info_cb (GFile *destination,
GAsyncResult *result,
SaveContext *save_context)
{
EAttachment *attachment;
GCancellable *cancellable;
GFileInfo *file_info;
GFileType file_type;
GError *error = NULL;
attachment = save_context->attachment;
cancellable = attachment->priv->cancellable;
file_info = g_file_query_info_finish (destination, result, &error);
/* G_IO_ERROR_NOT_FOUND just means we're creating a new file. */
if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND)) {
g_error_free (error);
goto replace;
}
if (attachment_save_check_for_error (save_context, error))
return;
file_type = g_file_info_get_file_type (file_info);
g_object_unref (file_info);
if (file_type == G_FILE_TYPE_DIRECTORY) {
save_context->directory = g_object_ref (destination);
destination = attachment_save_new_candidate (save_context);
g_file_create_async (
destination, G_FILE_CREATE_NONE,
G_PRIORITY_DEFAULT, cancellable,
(GAsyncReadyCallback) attachment_save_create_cb,
save_context);
g_object_unref (destination);
return;
}
replace:
g_file_replace_async (
destination, NULL, FALSE,
G_FILE_CREATE_REPLACE_DESTINATION,
G_PRIORITY_DEFAULT, cancellable,
(GAsyncReadyCallback) attachment_save_replace_cb,
save_context);
}
void
e_attachment_save_async (EAttachment *attachment,
GFile *destination,
GAsyncReadyCallback callback,
gpointer user_data)
{
SaveContext *save_context;
GCancellable *cancellable;
g_return_if_fail (E_IS_ATTACHMENT (attachment));
g_return_if_fail (G_IS_FILE (destination));
if (e_attachment_get_loading (attachment)) {
g_simple_async_report_error_in_idle (
G_OBJECT (attachment), callback, user_data,
G_IO_ERROR, G_IO_ERROR_BUSY,
_("A load operation is already in progress"));
return;
}
if (e_attachment_get_saving (attachment)) {
g_simple_async_report_error_in_idle (
G_OBJECT (attachment), callback, user_data,
G_IO_ERROR, G_IO_ERROR_BUSY,
_("A save operation is already in progress"));
return;
}
/* Just peek, don't reference. */
if (attachment->priv->mime_part == NULL) {
g_simple_async_report_error_in_idle (
G_OBJECT (attachment), callback, user_data,
G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
_("Attachment contents not loaded"));
return;
}
save_context = attachment_save_context_new (
attachment, callback, user_data);
cancellable = attachment->priv->cancellable;
g_cancellable_reset (cancellable);
/* First we need to know if destination is a directory. */
g_file_query_info_async (
destination, G_FILE_ATTRIBUTE_STANDARD_TYPE,
G_FILE_QUERY_INFO_NONE, G_PRIORITY_DEFAULT,
cancellable, (GAsyncReadyCallback)
attachment_save_query_info_cb, save_context);
}
GFile *
e_attachment_save_finish (EAttachment *attachment,
GAsyncResult *result,
GError **error)
{
GSimpleAsyncResult *simple;
GFile *destination;
g_return_val_if_fail (E_IS_ATTACHMENT (attachment), NULL);
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)) {
attachment_set_saving (attachment, FALSE);
return NULL;
}
destination = g_simple_async_result_get_op_res_gpointer (simple);
if (destination != NULL)
g_object_ref (destination);
attachment_set_saving (attachment, FALSE);
return destination;
}
void
e_attachment_save_handle_error (EAttachment *attachment,
GAsyncResult *result,
GtkWindow *parent)
{
GFile *file;
GFileInfo *file_info;
GtkWidget *dialog;
const gchar *display_name;
const gchar *primary_text;
GError *error = NULL;
g_return_if_fail (E_IS_ATTACHMENT (attachment));
g_return_if_fail (G_IS_ASYNC_RESULT (result));
g_return_if_fail (GTK_IS_WINDOW (parent));
file = e_attachment_save_finish (attachment, result, &error);
if (file != NULL) {
g_object_unref (file);
return;
}
/* Ignore cancellations. */
if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
return;
file_info = e_attachment_ref_file_info (attachment);
if (file_info != NULL)
display_name = g_file_info_get_display_name (file_info);
else
display_name = NULL;
if (display_name != NULL)
primary_text = g_strdup_printf (
_("Could not save '%s'"), display_name);
else
primary_text = g_strdup_printf (
_("Could not save the attachment"));
g_clear_object (&file_info);
dialog = gtk_message_dialog_new_with_markup (
parent, GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
"<big><b>%s</b></big>", primary_text);
gtk_message_dialog_format_secondary_text (
GTK_MESSAGE_DIALOG (dialog), "%s", error->message);
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
g_error_free (error);
}
gboolean
e_attachment_save (EAttachment *attachment,
GFile *in_destination,
GFile **out_destination,
GError **error)
{
EAsyncClosure *closure;
GAsyncResult *result;
g_return_val_if_fail (E_IS_ATTACHMENT (attachment), FALSE);
g_return_val_if_fail (out_destination != NULL, FALSE);
closure = e_async_closure_new ();
e_attachment_save_async (
attachment, in_destination,
e_async_closure_callback, closure);
result = e_async_closure_wait (closure);
*out_destination =
e_attachment_save_finish (attachment, result, error);
e_async_closure_free (closure);
return *out_destination != NULL;
}
Reference in New Issue View Git Blame Copy Permalink