From 6454ebb3b77f1e7b86ac3267bb56da3ee0309537 Mon Sep 17 00:00:00 2001 From: Srinivasa Ragavan Date: Mon, 11 Jul 2005 08:44:02 +0000 Subject: Added gnome-vfs-module-2.0 to E_WIDGET_CFLAGS. Added e-attachment-bar.[ch] 2005-07-11 Srinivasa Ragavan * configure.in: Added gnome-vfs-module-2.0 to E_WIDGET_CFLAGS. * Added e-attachment-bar.[ch] e-attachment.[ch] e-attachment.glade to directory structure and the Makefile.am svn path=/trunk/; revision=29708 --- widgets/misc/e-attachment.c | 639 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 639 insertions(+) create mode 100644 widgets/misc/e-attachment.c (limited to 'widgets/misc/e-attachment.c') diff --git a/widgets/misc/e-attachment.c b/widgets/misc/e-attachment.c new file mode 100644 index 0000000000..3e06467578 --- /dev/null +++ b/widgets/misc/e-attachment.c @@ -0,0 +1,639 @@ +/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */ +/* + * Authors: Ettore Perazzoli + * Jeffrey Stedfast + * Srinivasa Ragavan + * + * Copyright 1999-2005 Novell, Inc. (www.novell.com) + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * 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 General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Street #330, Boston, MA 02111-1307, USA. + * + */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include "e-util/e-mktemp.h" + +#include "e-attachment.h" + +enum { + CHANGED, + LAST_SIGNAL +}; +static guint signals[LAST_SIGNAL] = { 0 }; + +static GObjectClass *parent_class = NULL; + +static void +changed (EAttachment *attachment) +{ + g_signal_emit (attachment, signals[CHANGED], 0); +} + + +/* GtkObject methods. */ + +static void +finalise(GObject *object) +{ + EAttachment *attachment; + + attachment = E_ATTACHMENT (object); + + if (attachment->is_available_local) { + camel_object_unref (attachment->body); + if (attachment->pixbuf_cache != NULL) + g_object_unref (attachment->pixbuf_cache); + } else { + if (attachment->handle) + gnome_vfs_async_cancel(attachment->handle); + if (attachment->file_name) + g_free (attachment->file_name); + if (attachment->description) + g_free (attachment->description); + } + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + + +/* Signals. */ + +static void +real_changed (EAttachment *attachment) +{ + g_return_if_fail (E_IS_ATTACHMENT (attachment)); +} + + +static void +class_init (EAttachmentClass *klass) +{ + GObjectClass *object_class; + + object_class = (GObjectClass*) klass; + parent_class = g_type_class_ref (G_TYPE_OBJECT); + + object_class->finalize = finalise; + klass->changed = real_changed; + + signals[CHANGED] = g_signal_new ("changed", + E_TYPE_ATTACHMENT, + G_SIGNAL_RUN_FIRST, + G_STRUCT_OFFSET (EAttachmentClass, changed), + NULL, + NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, 0); +} + +static void +init (EAttachment *attachment) +{ + attachment->editor_gui = NULL; + attachment->body = NULL; + attachment->size = 0; + attachment->pixbuf_cache = NULL; + attachment->index = -1; + attachment->file_name = NULL; + attachment->description = NULL; + attachment->disposition = FALSE; + attachment->sign = CAMEL_CIPHER_VALIDITY_SIGN_NONE; + attachment->encrypt = CAMEL_CIPHER_VALIDITY_ENCRYPT_NONE; +} + +GType +e_attachment_get_type (void) +{ + static GType type = 0; + + if (type == 0) { + static const GTypeInfo info = { + sizeof (EAttachmentClass), + NULL, + NULL, + (GClassInitFunc) class_init, + NULL, + NULL, + sizeof (EAttachment), + 0, + (GInstanceInitFunc) init, + }; + + type = g_type_register_static (G_TYPE_OBJECT, "EAttachment", &info, 0); + } + + return type; +} + +static char * +attachment_guess_mime_type (const char *file_name) +{ + GnomeVFSFileInfo *info; + GnomeVFSResult result; + char *type = NULL; + + info = gnome_vfs_file_info_new (); + result = gnome_vfs_get_file_info (file_name, info, + GNOME_VFS_FILE_INFO_GET_MIME_TYPE | + GNOME_VFS_FILE_INFO_FORCE_SLOW_MIME_TYPE | + GNOME_VFS_FILE_INFO_FOLLOW_LINKS); + if (result == GNOME_VFS_OK) + type = g_strdup (gnome_vfs_file_info_get_mime_type (info)); + + gnome_vfs_file_info_unref (info); + + return type; +} + + +/** + * e_attachment_new: + * @file_name: filename to attach + * @disposition: Content-Disposition of the attachment + * @ex: exception + * + * Return value: the new attachment, or %NULL on error + **/ +EAttachment * +e_attachment_new (const char *file_name, + const char *disposition, + CamelException *ex) +{ + EAttachment *new; + CamelMimePart *part; + CamelDataWrapper *wrapper; + CamelStream *stream; + struct stat statbuf; + char *mime_type; + char *filename; + + g_return_val_if_fail (file_name != NULL, NULL); + + if (stat (file_name, &statbuf) < 0) { + camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, + _("Cannot attach file %s: %s"), + file_name, g_strerror (errno)); + return NULL; + } + + /* return if it's not a regular file */ + if (!S_ISREG (statbuf.st_mode)) { + camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, + _("Cannot attach file %s: not a regular file"), + file_name); + return NULL; + } + + stream = camel_stream_fs_new_with_name (file_name, O_RDONLY, 0); + if (!stream) { + camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, + _("Cannot attach file %s: %s"), + file_name, g_strerror (errno)); + return NULL; + } + + mime_type = attachment_guess_mime_type (file_name); + if (mime_type) { + if (!g_ascii_strcasecmp (mime_type, "message/rfc822")) { + wrapper = (CamelDataWrapper *) camel_mime_message_new (); + } else { + wrapper = camel_data_wrapper_new (); + } + + camel_data_wrapper_construct_from_stream (wrapper, stream); + camel_data_wrapper_set_mime_type (wrapper, mime_type); + g_free (mime_type); + } else { + wrapper = camel_data_wrapper_new (); + camel_data_wrapper_construct_from_stream (wrapper, stream); + camel_data_wrapper_set_mime_type (wrapper, "application/octet-stream"); + } + + camel_object_unref (stream); + + part = camel_mime_part_new (); + camel_medium_set_content_object (CAMEL_MEDIUM (part), wrapper); + camel_object_unref (wrapper); + + camel_mime_part_set_disposition (part, disposition); + filename = g_path_get_basename (file_name); + camel_mime_part_set_filename (part, filename); + g_free (filename); + +#if 0 + /* Note: Outlook 2002 is broken with respect to Content-Ids on + non-multipart/related parts, so as an interoperability + workaround, don't set a Content-Id on these parts. Fixes + bug #10032 */ + /* set the Content-Id */ + content_id = camel_header_msgid_generate (); + camel_mime_part_set_content_id (part, content_id); + g_free (content_id); +#endif + + new = g_object_new (E_TYPE_ATTACHMENT, NULL); + new->editor_gui = NULL; + new->body = part; + new->size = statbuf.st_size; + new->guessed_type = TRUE; + new->handle = NULL; + new->is_available_local = TRUE; + + return new; +} + + +EAttachment * +e_attachment_new_remote_file (const char *file_name, + const char *disposition, + CamelException *ex) +{ + EAttachment *new; + + g_return_val_if_fail (file_name != NULL, NULL); + + new = g_object_new (E_TYPE_ATTACHMENT, NULL); + new->editor_gui = NULL; + new->body = NULL; + new->size = 0; + new->guessed_type = FALSE; + new->handle = NULL; + new->is_available_local = FALSE; + new->file_name = g_path_get_basename(file_name); + + return new; +} + +void +e_attachment_build_remote_file (const char *file_name, + EAttachment *attachment, + const char *disposition, + CamelException *ex) +{ + CamelMimePart *part; + CamelDataWrapper *wrapper; + CamelStream *stream; + struct stat statbuf; + char *mime_type; + char *filename; + + g_return_if_fail (file_name != NULL); + + if (stat (file_name, &statbuf) < 0) { + camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, + _("Cannot attach file %s: %s"), + file_name, g_strerror (errno)); + return; + } + + /* return if it's not a regular file */ + if (!S_ISREG (statbuf.st_mode)) { + camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, + _("Cannot attach file %s: not a regular file"), + file_name); + return; + } + + stream = camel_stream_fs_new_with_name (file_name, O_RDONLY, 0); + if (!stream) { + camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, + _("Cannot attach file %s: %s"), + file_name, g_strerror (errno)); + return; + } + + mime_type = attachment_guess_mime_type (file_name); + if (mime_type) { + if (!g_ascii_strcasecmp (mime_type, "message/rfc822")) { + wrapper = (CamelDataWrapper *) camel_mime_message_new (); + } else { + wrapper = camel_data_wrapper_new (); + } + + camel_data_wrapper_construct_from_stream (wrapper, stream); + camel_data_wrapper_set_mime_type (wrapper, mime_type); + g_free (mime_type); + } else { + wrapper = camel_data_wrapper_new (); + camel_data_wrapper_construct_from_stream (wrapper, stream); + camel_data_wrapper_set_mime_type (wrapper, "application/octet-stream"); + } + + camel_object_unref (stream); + + part = camel_mime_part_new (); + camel_medium_set_content_object (CAMEL_MEDIUM (part), wrapper); + camel_object_unref (wrapper); + + if (attachment->disposition) + camel_mime_part_set_disposition (part, "inline"); + else + camel_mime_part_set_disposition (part, "attachment"); + + if (!attachment->file_name) + filename = g_path_get_basename (file_name); + else + filename = g_path_get_basename (attachment->file_name); + + camel_mime_part_set_filename (part, filename); + g_free (filename); + + if (attachment->description) { + camel_mime_part_set_description (part, attachment->description); + g_free (attachment->description); + attachment->description = NULL; + } + + attachment->editor_gui = NULL; + attachment->body = part; + attachment->size = statbuf.st_size; + attachment->guessed_type = TRUE; + if (attachment->file_name) { + g_free (attachment->file_name); + attachment->file_name = NULL; + } +} + + +/** + * e_attachment_new_from_mime_part: + * @part: a CamelMimePart + * + * Return value: a new EAttachment based on the mime part + **/ +EAttachment * +e_attachment_new_from_mime_part (CamelMimePart *part) +{ + EAttachment *new; + CamelMimePart *mime_part; + CamelStream *stream; + + g_return_val_if_fail (CAMEL_IS_MIME_PART (part), NULL); + + stream = camel_stream_mem_new (); + if (camel_data_wrapper_write_to_stream (CAMEL_DATA_WRAPPER (part), stream) == -1) { + camel_object_unref (stream); + return NULL; + } + + camel_stream_reset (stream); + mime_part = camel_mime_part_new (); + + if (camel_data_wrapper_construct_from_stream (CAMEL_DATA_WRAPPER (mime_part), stream) == -1) { + camel_object_unref (mime_part); + camel_object_unref (stream); + return NULL; + } + + camel_object_unref (stream); + + new = g_object_new (E_TYPE_ATTACHMENT, NULL); + new->editor_gui = NULL; + new->body = mime_part; + new->guessed_type = FALSE; + new->is_available_local = TRUE; + new->size = 0; + + return new; +} + + +/* The attachment property dialog. */ + +typedef struct { + GtkWidget *dialog; + GtkEntry *file_name_entry; + GtkEntry *description_entry; + GtkEntry *mime_type_entry; + GtkToggleButton *disposition_checkbox; + EAttachment *attachment; +} DialogData; + +static void +destroy_dialog_data (DialogData *data) +{ + g_free (data); +} + +/* + * fixme: I am converting EVERYTHING to/from UTF-8, although mime types + * are in ASCII. This is not strictly necessary, but we want to be + * consistent and possibly check for errors somewhere. + */ + +static void +set_entry (GladeXML *xml, const char *widget_name, const char *value) +{ + GtkEntry *entry; + + entry = GTK_ENTRY (glade_xml_get_widget (xml, widget_name)); + if (entry == NULL) + g_warning ("Entry for `%s' not found.", widget_name); + else + gtk_entry_set_text (entry, value ? value : ""); +} + +static void +connect_widget (GladeXML *gui, const char *name, const char *signal_name, + GCallback func, gpointer data) +{ + GtkWidget *widget; + + widget = glade_xml_get_widget (gui, name); + g_signal_connect (widget, signal_name, func, data); +} + +static void +close_cb (GtkWidget *widget, gpointer data) +{ + EAttachment *attachment; + DialogData *dialog_data; + + dialog_data = (DialogData *) data; + attachment = dialog_data->attachment; + + gtk_widget_destroy (dialog_data->dialog); + g_object_unref (attachment->editor_gui); + attachment->editor_gui = NULL; + + g_object_unref (attachment); + + destroy_dialog_data (dialog_data); +} + +static void +ok_cb (GtkWidget *widget, gpointer data) +{ + DialogData *dialog_data; + EAttachment *attachment; + const char *str; + + dialog_data = (DialogData *) data; + attachment = dialog_data->attachment; + + str = gtk_entry_get_text (dialog_data->file_name_entry); + if (attachment->is_available_local) { + camel_mime_part_set_filename (attachment->body, str); + } else { + if (attachment->file_name) + g_free (attachment->file_name); + attachment->file_name = g_strdup (str); + } + + str = gtk_entry_get_text (dialog_data->description_entry); + if (attachment->is_available_local) { + camel_mime_part_set_description (attachment->body, str); + } else { + if (attachment->description) + g_free (attachment->description); + attachment->description = g_strdup (str); + } + + str = gtk_entry_get_text (dialog_data->mime_type_entry); + if (attachment->is_available_local) { + camel_mime_part_set_content_type (attachment->body, str); + camel_data_wrapper_set_mime_type(camel_medium_get_content_object(CAMEL_MEDIUM (attachment->body)), str); + } + + if (attachment->is_available_local) { + switch (gtk_toggle_button_get_active (dialog_data->disposition_checkbox)) { + case 0: + camel_mime_part_set_disposition (attachment->body, "attachment"); + break; + case 1: + camel_mime_part_set_disposition (attachment->body, "inline"); + break; + default: + /* Hmmmm? */ + break; + } + } else { + attachment->disposition = gtk_toggle_button_get_active (dialog_data->disposition_checkbox); + } + + changed (attachment); + close_cb (widget, data); +} + +static void +response_cb (GtkWidget *widget, gint response, gpointer data) +{ + if (response == GTK_RESPONSE_OK) + ok_cb (widget, data); + else + close_cb (widget, data); +} + +void +e_attachment_edit (EAttachment *attachment, GtkWidget *parent) +{ + CamelContentType *content_type; + const char *disposition; + DialogData *dialog_data; + GladeXML *editor_gui; + char *type; + + g_return_if_fail (attachment != NULL); + g_return_if_fail (E_IS_ATTACHMENT (attachment)); + + if (attachment->editor_gui != NULL) { + GtkWidget *window; + + window = glade_xml_get_widget (attachment->editor_gui, + "dialog"); + gdk_window_show (window->window); + return; + } + + editor_gui = glade_xml_new (EVOLUTION_GLADEDIR "/e-attachment.glade", + NULL, NULL); + if (editor_gui == NULL) { + g_warning ("Cannot load `e-attachment.glade'"); + return; + } + + attachment->editor_gui = editor_gui; + + gtk_window_set_transient_for + (GTK_WINDOW (glade_xml_get_widget (editor_gui, "dialog")), + GTK_WINDOW (gtk_widget_get_toplevel (parent))); + + dialog_data = g_new (DialogData, 1); + g_object_ref (attachment); + dialog_data->attachment = attachment; + dialog_data->dialog = glade_xml_get_widget (editor_gui, "dialog"); + dialog_data->file_name_entry = GTK_ENTRY ( + glade_xml_get_widget (editor_gui, "file_name_entry")); + dialog_data->description_entry = GTK_ENTRY ( + glade_xml_get_widget (editor_gui, "description_entry")); + dialog_data->mime_type_entry = GTK_ENTRY ( + glade_xml_get_widget (editor_gui, "mime_type_entry")); + dialog_data->disposition_checkbox = GTK_TOGGLE_BUTTON ( + glade_xml_get_widget (editor_gui, "disposition_checkbox")); + + if (attachment->is_available_local) { + set_entry (editor_gui, "file_name_entry", + camel_mime_part_get_filename (attachment->body)); + set_entry (editor_gui, "description_entry", + camel_mime_part_get_description (attachment->body)); + content_type = camel_mime_part_get_content_type (attachment->body); + type = camel_content_type_simple (content_type); + set_entry (editor_gui, "mime_type_entry", type); + g_free (type); + + disposition = camel_mime_part_get_disposition (attachment->body); + gtk_toggle_button_set_active (dialog_data->disposition_checkbox, + disposition && !g_ascii_strcasecmp (disposition, "inline")); + } else { + set_entry (editor_gui, "file_name_entry", + attachment->file_name); + set_entry (editor_gui, "description_entry", + attachment->description); + type = attachment_guess_mime_type (attachment->file_name); + if (type) { + set_entry (editor_gui, "mime_type_entry", type); + g_free (type); + } else { + set_entry (editor_gui, "mime_type_entry", ""); + } + + gtk_toggle_button_set_active (dialog_data->disposition_checkbox, attachment->disposition); + + } + + connect_widget (editor_gui, "dialog", "response", (GCallback)response_cb, dialog_data); +#warning "signal connect while alive" + /* make sure that when the parent gets hidden/closed that our windows also close */ + parent = gtk_widget_get_toplevel (parent); + gtk_signal_connect_while_alive (GTK_OBJECT (parent), "destroy", (GCallback)close_cb, dialog_data, + GTK_OBJECT (dialog_data->dialog)); + gtk_signal_connect_while_alive (GTK_OBJECT (parent), "hide", (GCallback)close_cb, dialog_data, + GTK_OBJECT (dialog_data->dialog)); +} -- cgit v1.2.3