aboutsummaryrefslogblamecommitdiffstats
path: root/composer/e-msg-composer-attachment.c
blob: c7d7fabde43233ede65f33fb728b6f937b2ced5c (plain) (tree)
1
2
3
4
5
6
7
8
9
10
11
                                                                           


                                                 
  
                                                     
  



                                                                        
  



                                                                   
  


                                                                        
  

   
 
                                                                               
                                                                            


                                                                    



                    

                     
                   
                  
 
                        

                                
                          
                                       
                                
 
                            
                                  
 
                           






                                      
                                          
 
                                         

 
           

                                            
                                                        





                         
                         

                                           
        
                                                        




                                                                  







                                                                   

                                                         







                                                              
                                                                                  





                                               
                                   
        
                                             

                                                        
                                          
                                      
        


                                                                        
                                                                                                



                                                                       




                                                      
                                                   
                                             
                                          
                                                     



                                                     

 
     

                                         
                              
        
                        
                                               
                                                             







                                                        
                  

                                                                                                  
         
        





                                 

                                                      
                 

                                                      

                        


                                                       

                                    

                                  
                            
                            
                        
                       
        
                                                       
        



                                                                     
                            
         

                                               



                                                                                     
                            
         

                                                                        



                                                                     
                            
         
        
                                                               
                        
                                                                        
                                                                                 

                                                            

                 
                                                                           

                                                                      


                                                                           
                                                                                       
         
        
                                    
        

                                                                       
                                     
        
                                                            
                                                   

                                                      
        


                                                                      
                                                                   
                        
                                
                                                    

                                                          
      
        
                                                                  

                               
                                    
                                 























                                                                   
        


                   
























































































                                                                                       










                                                                    


                                 
                                                               

















                                                                                                      
                                                                  
                               
                              
                                  
                                       
                      
        





                                      
                



                                    
                                              
                                           
             



                                      


                      





                                                                       
           
                                                                     

                        
        


                                                                     
            
                                                               


           

                                                                         

                          
        
                                                  
                                                           


           
                                           


                                           
        

                                             
        
                                                 
                                                
                                      
        

                                    



                                          
                                        

                                
                                           
                        
        
                                          
                                             
        
                                                                






                                                                     
        
                                                                  






                                                                        
        
                                                                


















                                                                                                                        
         
        

                                

 








                                                             
    
                                                                                      
 

                                       

                                
                   
                        
        

                                                                     
        

                                             
                




                                                                      
        





                                                                        



                                                                            
        
                                            
        


                                                                          
        
                                            
                                  

                                                                          







                                                                           

























                                                                                                          
        


                                                                                                          
        
                                                                                               
                                        

                                                                                             
                                                                                                         
                                                                          
                                                                                                      
                                                                          
 
/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
/*
 *  Authors: Ettore Perazzoli <ettore@ximian.com>
 *           Jeffrey Stedfast <fejj@ximian.com>
 *
 *  Copyright 1999-2002 Ximian, Inc. (www.ximian.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.
 *
 */


/* This is the object representing an email attachment.  It is implemented as a
   GObject to make it easier for the application to handle it.  For example,
   the "changed" signal is emitted whenever something changes in the
   attachment.  Also, this contains the code to let users edit the
   attachment manually. */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <sys/stat.h>
#include <string.h>
#include <errno.h>

#include <camel/camel.h>
#include <gtk/gtknotebook.h>
#include <gtk/gtktogglebutton.h>
#include <gtk/gtkdialog.h>
#include <libgnomevfs/gnome-vfs-mime.h>
#include <libgnome/gnome-i18n.h>

#include "e-util/e-mktemp.h"
#include "e-util/e-util-private.h"

#include "e-msg-composer.h"
#include "e-msg-composer-attachment.h"


enum {
    CHANGED,
    LAST_SIGNAL
};
static guint signals[LAST_SIGNAL] = { 0 };

static GObjectClass *parent_class = NULL;


static void
changed (EMsgComposerAttachment *attachment)
{
    g_signal_emit (attachment, signals[CHANGED], 0);
}


/* GtkObject methods.  */

static void
finalise(GObject *object)
{
    EMsgComposerAttachment *attachment;
    
    attachment = E_MSG_COMPOSER_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 (EMsgComposerAttachment *msg_composer_attachment)
{
    g_return_if_fail (E_IS_MSG_COMPOSER_ATTACHMENT (msg_composer_attachment));
}


static void
class_init (EMsgComposerAttachmentClass *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_MSG_COMPOSER_ATTACHMENT,
                     G_SIGNAL_RUN_FIRST,
                     G_STRUCT_OFFSET (EMsgComposerAttachmentClass, changed),
                     NULL,
                     NULL,
                     g_cclosure_marshal_VOID__VOID,
                     G_TYPE_NONE, 0);
}

static void
init (EMsgComposerAttachment *msg_composer_attachment)
{
    msg_composer_attachment->editor_gui = NULL;
    msg_composer_attachment->body = NULL;
    msg_composer_attachment->size = 0;
    msg_composer_attachment->pixbuf_cache = NULL;
    msg_composer_attachment->index = -1;
    msg_composer_attachment->file_name = NULL;
    msg_composer_attachment->description = NULL;
    msg_composer_attachment->disposition = FALSE;
}

GType
e_msg_composer_attachment_get_type (void)
{
    static GType type = 0;
    
    if (type == 0) {
        static const GTypeInfo info = {
            sizeof (EMsgComposerAttachmentClass),
            NULL,
            NULL,
            (GClassInitFunc) class_init,
            NULL,
            NULL,
            sizeof (EMsgComposerAttachment),
            0,
            (GInstanceInitFunc) init,
        };
        
        type = g_type_register_static (G_TYPE_OBJECT, "EMsgComposerAttachment", &info, 0);
    }
    
    return type;
}


/**
 * e_msg_composer_attachment_new:
 * @file_name: filename to attach
 * @disposition: Content-Disposition of the attachment
 * @ex: exception
 *
 * Return value: the new attachment, or %NULL on error
 **/
EMsgComposerAttachment *
e_msg_composer_attachment_new (const char *file_name,
                   const char *disposition,
                   CamelException *ex)
{
    EMsgComposerAttachment *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 = e_msg_composer_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_MSG_COMPOSER_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;
}


EMsgComposerAttachment *
e_msg_composer_attachment_new_remote_file (const char *file_name,
                           const char *disposition,
                           CamelException *ex)
{
    EMsgComposerAttachment *new;
    
    g_return_val_if_fail (file_name != NULL, NULL);
    
    new = g_object_new (E_TYPE_MSG_COMPOSER_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_msg_composer_attachment_build_remote_file (const char *file_name,
                         EMsgComposerAttachment *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 = e_msg_composer_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_msg_composer_attachment_new_from_mime_part:
 * @part: a CamelMimePart
 * 
 * Return value: a new EMsgComposerAttachment based on the mime part
 **/
EMsgComposerAttachment *
e_msg_composer_attachment_new_from_mime_part (CamelMimePart *part)
{
    EMsgComposerAttachment *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_MSG_COMPOSER_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;
    EMsgComposerAttachment *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)
{
    EMsgComposerAttachment *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;
    EMsgComposerAttachment *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_msg_composer_attachment_edit (EMsgComposerAttachment *attachment, GtkWidget *parent)
{
    CamelContentType *content_type;
    const char *disposition;
    DialogData *dialog_data;
    GladeXML *editor_gui;
    char *type;
    char *gladefile;
    
    g_return_if_fail (attachment != NULL);
    g_return_if_fail (E_IS_MSG_COMPOSER_ATTACHMENT (attachment));
    
    if (attachment->editor_gui != NULL) {
        GtkWidget *window;
        
        window = glade_xml_get_widget (attachment->editor_gui,
                           "dialog");
        gdk_window_show (window->window);
        return;
    }
    
    gladefile = g_build_filename (EVOLUTION_GLADEDIR,
                      "e-msg-composer-attachment.glade",
                      NULL);
    editor_gui = glade_xml_new (gladefile, NULL, NULL);
    g_free (gladefile);

    if (editor_gui == NULL) {
        g_warning ("Cannot load `e-msg-composer-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 = e_msg_composer_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 composer 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));
}