claws-mail/src/messageview.c

632 lines
17 KiB
C
Raw Normal View History

2001-04-19 14:21:46 +02:00
/*
* Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
2002-01-29 11:03:33 +01:00
* Copyright (C) 1999-2002 Hiroyuki Yamamoto
2001-04-19 14:21:46 +02:00
*
* 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 Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "defs.h"
#include <glib.h>
#include <gdk/gdkkeysyms.h>
#include <gtk/gtkvbox.h>
#include <gtk/gtkcontainer.h>
#include <gtk/gtkeditable.h>
#include <gtk/gtkwindow.h>
#include <gtk/gtktext.h>
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include "intl.h"
#include "main.h"
#include "messageview.h"
#include "headerview.h"
#include "textview.h"
#include "imageview.h"
#include "mimeview.h"
#include "procmsg.h"
#include "procheader.h"
#include "procmime.h"
#include "prefs_common.h"
#include "gtkutils.h"
#include "utils.h"
#include "rfc2015.h"
2001-05-02 16:16:51 +02:00
#include "account.h"
#include "alertpanel.h"
2001-05-11 01:00:27 +02:00
#include "send.h"
#include "pgptext.h"
2001-04-19 14:21:46 +02:00
static void messageview_change_view_type(MessageView *messageview,
MessageType type);
static void messageview_destroy_cb (GtkWidget *widget,
MessageView *messageview);
static void messageview_size_allocate_cb(GtkWidget *widget,
GtkAllocation *allocation);
static void key_pressed (GtkWidget *widget,
GdkEventKey *event,
MessageView *messageview);
MessageView *messageview_create(void)
{
MessageView *messageview;
GtkWidget *vbox;
HeaderView *headerview;
TextView *textview;
ImageView *imageview;
MimeView *mimeview;
debug_print(_("Creating message view...\n"));
messageview = g_new0(MessageView, 1);
messageview->type = MVIEW_TEXT;
headerview = headerview_create();
textview = textview_create();
textview->messageview = messageview;
imageview = imageview_create();
imageview->messageview = messageview;
mimeview = mimeview_create();
2002-02-25 10:25:17 +01:00
mimeview->textview = textview_create();
mimeview->textview->messageview = messageview;
2001-04-19 14:21:46 +02:00
mimeview->imageview = imageview;
mimeview->messageview = messageview;
vbox = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET_PTR(headerview),
FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET_PTR(textview),
TRUE, TRUE, 0);
/* to remove without destroyed */
gtk_widget_ref(GTK_WIDGET_PTR(textview));
gtk_widget_ref(GTK_WIDGET_PTR(imageview));
gtk_widget_ref(GTK_WIDGET_PTR(mimeview));
2002-02-25 10:25:17 +01:00
gtk_widget_ref(GTK_WIDGET_PTR(mimeview->textview));
2001-04-19 14:21:46 +02:00
messageview->vbox = vbox;
messageview->new_window = FALSE;
messageview->window = NULL;
messageview->headerview = headerview;
messageview->textview = textview;
messageview->imageview = imageview;
messageview->mimeview = mimeview;
return messageview;
}
MessageView *messageview_create_with_new_window(void)
{
GtkWidget *window;
MessageView *msgview;
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), _("Sylpheed - Message View"));
gtk_window_set_wmclass(GTK_WINDOW(window), "message_view", "Sylpheed");
2001-04-19 14:21:46 +02:00
gtk_window_set_policy(GTK_WINDOW(window), TRUE, TRUE, FALSE);
gtk_widget_set_usize(window, prefs_common.msgwin_width,
prefs_common.msgwin_height);
msgview = messageview_create();
gtk_signal_connect(GTK_OBJECT(window), "size_allocate",
GTK_SIGNAL_FUNC(messageview_size_allocate_cb),
msgview);
gtk_signal_connect(GTK_OBJECT(window), "destroy",
GTK_SIGNAL_FUNC(messageview_destroy_cb), msgview);
gtk_signal_connect(GTK_OBJECT(window), "key_press_event",
GTK_SIGNAL_FUNC(key_pressed), msgview);
gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET_PTR(msgview));
gtk_widget_grab_focus(msgview->textview->text);
gtk_widget_show_all(window);
msgview->new_window = TRUE;
msgview->window = window;
msgview->visible = TRUE;
2001-04-19 14:21:46 +02:00
messageview_init(msgview);
return msgview;
}
void messageview_init(MessageView *messageview)
{
headerview_init(messageview->headerview);
textview_init(messageview->textview);
imageview_init(messageview->imageview);
mimeview_init(messageview->mimeview);
/*messageview_set_font(messageview);*/
2001-04-19 14:21:46 +02:00
}
2001-05-02 16:16:51 +02:00
static void notification_convert_header(gchar *dest, gint len, gchar *src,
gint header_len)
{
g_return_if_fail(src != NULL);
g_return_if_fail(dest != NULL);
if (len < 1) return;
remove_return(src);
if (is_ascii_str(src)) {
strncpy2(dest, src, len);
dest[len - 1] = '\0';
return;
} else
conv_encode_header(dest, len, src, header_len);
}
static gint disposition_notification_queue(PrefsAccount * account,
gchar * to, const gchar *file)
{
FolderItem *queue;
gchar *tmp, *queue_path;
FILE *fp, *src_fp;
GSList *cur;
gchar buf[BUFFSIZE];
gint num;
debug_print(_("queueing message...\n"));
g_return_val_if_fail(account != NULL, -1);
tmp = g_strdup_printf("%s%cqueue.%d", g_get_tmp_dir(),
G_DIR_SEPARATOR, (gint)file);
2002-03-14 11:17:32 +01:00
if ((fp = fopen(tmp, "wb")) == NULL) {
FILE_OP_ERROR(tmp, "fopen");
g_free(tmp);
return -1;
}
2002-03-14 11:17:32 +01:00
if ((src_fp = fopen(file, "rb")) == NULL) {
FILE_OP_ERROR(file, "fopen");
fclose(fp);
unlink(tmp);
g_free(tmp);
return -1;
}
if (change_file_mode_rw(fp, tmp) < 0) {
FILE_OP_ERROR(tmp, "chmod");
g_warning(_("can't change file mode\n"));
}
/* queueing variables */
fprintf(fp, "AF:\n");
fprintf(fp, "NF:0\n");
fprintf(fp, "PS:10\n");
fprintf(fp, "SRH:1\n");
fprintf(fp, "SFN:\n");
fprintf(fp, "DSR:\n");
fprintf(fp, "MID:\n");
fprintf(fp, "CFG:\n");
fprintf(fp, "PT:0\n");
fprintf(fp, "S:%s\n", account->address);
fprintf(fp, "RQ:\n");
if (account->smtp_server)
fprintf(fp, "SSV:%s\n", account->smtp_server);
else
fprintf(fp, "SSV:\n");
if (account->nntp_server)
fprintf(fp, "NSV:%s\n", account->nntp_server);
else
fprintf(fp, "NSV:\n");
fprintf(fp, "SSH:\n");
fprintf(fp, "R:<%s>", to);
fprintf(fp, "\n");
fprintf(fp, "\n");
while (fgets(buf, sizeof(buf), src_fp) != NULL) {
if (fputs(buf, fp) == EOF) {
FILE_OP_ERROR(tmp, "fputs");
fclose(fp);
fclose(src_fp);
unlink(tmp);
g_free(tmp);
return -1;
}
}
fclose(src_fp);
if (fclose(fp) == EOF) {
FILE_OP_ERROR(tmp, "fclose");
unlink(tmp);
g_free(tmp);
return -1;
}
queue = folder_get_default_queue();
folder_item_scan(queue);
queue_path = folder_item_get_path(queue);
if (!is_dir_exist(queue_path))
make_dir_hier(queue_path);
if ((num = folder_item_add_msg(queue, tmp, TRUE)) < 0) {
g_warning(_("can't queue the message\n"));
unlink(tmp);
g_free(tmp);
g_free(queue_path);
return -1;
}
g_free(tmp);
if ((fp = procmsg_open_mark_file(queue_path, TRUE)) == NULL)
g_warning(_("can't open mark file\n"));
else {
MsgInfo newmsginfo;
newmsginfo.msgnum = num;
newmsginfo.flags.perm_flags = newmsginfo.flags.tmp_flags = 0;
procmsg_write_flags(&newmsginfo, fp);
fclose(fp);
}
g_free(queue_path);
folder_item_scan(queue);
folderview_update_item(queue, TRUE);
return 0;
}
static gint disposition_notification_send(MsgInfo * msginfo)
2001-05-02 16:16:51 +02:00
{
gchar buf[BUFFSIZE];
gchar tmp[MAXPATHLEN + 1];
FILE *fp;
GSList * to_list;
gint ok;
gchar * to;
2001-05-02 16:16:51 +02:00
if ((!msginfo->returnreceiptto) &&
(!msginfo->dispositionnotificationto))
return -1;
2001-05-02 16:16:51 +02:00
/* write to temporary file */
g_snprintf(tmp, sizeof(tmp), "%s%ctmpmsg%d",
get_rc_dir(), G_DIR_SEPARATOR, (gint)msginfo);
2002-03-14 11:17:32 +01:00
if ((fp = fopen(tmp, "wb")) == NULL) {
2001-05-02 16:16:51 +02:00
FILE_OP_ERROR(tmp, "fopen");
return -1;
}
/* chmod for security */
if (change_file_mode_rw(fp, tmp) < 0) {
FILE_OP_ERROR(tmp, "chmod");
g_warning(_("can't change file mode\n"));
}
/* Date */
get_rfc822_date(buf, sizeof(buf));
fprintf(fp, "Date: %s\n", buf);
/* From */
if (cur_account->name && *cur_account->name) {
notification_convert_header
(buf, sizeof(buf), cur_account->name,
strlen("From: "));
fprintf(fp, "From: %s <%s>\n", buf, cur_account->address);
} else
fprintf(fp, "From: %s\n", cur_account->address);
/* To */
if (msginfo->dispositionnotificationto)
to = msginfo->dispositionnotificationto;
else
to = msginfo->returnreceiptto;
fprintf(fp, "To: %s\n", to);
2001-05-02 16:16:51 +02:00
/* Subject */
notification_convert_header(buf, sizeof(buf), msginfo->subject,
strlen("Subject: "));
fprintf(fp, "Subject: Disposition notification: %s\n", buf);
if (fclose(fp) == EOF) {
FILE_OP_ERROR(tmp, "fclose");
unlink(tmp);
return -1;
}
to_list = address_list_append(NULL, msginfo->dispositionnotificationto);
ok = send_message(tmp, cur_account, to_list);
if (ok < 0) {
if (prefs_common.queue_msg) {
AlertValue val;
val = alertpanel
(_("Queueing"),
_("Error occurred while sending the notification.\n"
"Put this notification into queue folder?"),
_("OK"), _("Cancel"), NULL);
if (G_ALERTDEFAULT == val) {
ok = disposition_notification_queue(cur_account, to, tmp);
if (ok < 0)
alertpanel_error(_("Can't queue the notification."));
}
} else
alertpanel_error(_("Error occurred while sending the notification."));
}
2001-05-02 16:16:51 +02:00
if (unlink(tmp) < 0) FILE_OP_ERROR(tmp, "unlink");
return ok;
}
2002-02-04 10:56:44 +01:00
void messageview_show(MessageView *messageview, MsgInfo *msginfo,
gboolean all_headers)
2001-04-19 14:21:46 +02:00
{
FILE *fp;
gchar *file;
MimeInfo *mimeinfo;
MsgInfo *tmpmsginfo;
g_return_if_fail(msginfo != NULL);
#if USE_GPGME
2002-02-21 15:56:09 +01:00
if ((fp = procmsg_open_message_decrypted(msginfo, &mimeinfo)) == NULL)
return;
2001-04-19 14:21:46 +02:00
#else /* !USE_GPGME */
if ((fp = procmsg_open_message(msginfo)) == NULL) return;
2002-02-21 15:56:09 +01:00
mimeinfo = procmime_scan_mime_header(fp);
2001-04-19 14:21:46 +02:00
#endif /* USE_GPGME */
fclose(fp);
if (!mimeinfo) return;
file = procmsg_get_message_file_path(msginfo);
2002-03-28 08:15:00 +01:00
if (!file) {
g_warning("can't get message file path.\n");
procmime_mimeinfo_free(mimeinfo);
return;
}
2001-04-19 14:21:46 +02:00
/* FIXME - doesn't tmpmsginfo->flags have the value
* of msginfo->flags after procheader_parse()???
* in any case, checking tmpmsginfo->flags for MSG_UNREAD
* fixes the return-receipt-request bug */
2002-06-19 09:31:13 +02:00
tmpmsginfo = procheader_parse_file(file, msginfo->flags, TRUE, TRUE);
if (MSG_IS_MIME(tmpmsginfo->flags))
MSG_SET_TMP_FLAGS(msginfo->flags, MSG_MIME);
2001-05-02 16:16:51 +02:00
if (prefs_common.return_receipt
&& (tmpmsginfo->dispositionnotificationto
|| tmpmsginfo->returnreceiptto)
2002-03-16 09:35:53 +01:00
&& (MSG_IS_UNREAD(tmpmsginfo->flags))
&& (MSG_IS_RETRCPT_PENDING(tmpmsginfo->flags))) {
2001-05-02 16:16:51 +02:00
gint ok;
if (alertpanel(_("Return Receipt"), _("Send return receipt ?"),
_("Yes"), _("No"), NULL) == G_ALERTDEFAULT) {
ok = disposition_notification_send(tmpmsginfo);
2001-05-02 16:16:51 +02:00
if (ok < 0)
alertpanel_error(_("Error occurred while sending notification."));
}
2002-03-16 09:35:53 +01:00
MSG_UNSET_PERM_FLAGS(tmpmsginfo->flags, MSG_RETRCPT_PENDING);
2001-05-02 16:16:51 +02:00
}
2001-04-19 14:21:46 +02:00
headerview_show(messageview->headerview, tmpmsginfo);
procmsg_msginfo_free(tmpmsginfo);
2002-02-04 10:56:44 +01:00
textview_set_all_headers(messageview->textview, all_headers);
2002-03-02 11:02:42 +01:00
textview_set_all_headers(messageview->mimeview->textview, all_headers);
2002-02-04 10:56:44 +01:00
2002-06-23 09:49:25 +02:00
if (mimeinfo->mime_type != MIME_TEXT &&
mimeinfo->mime_type != MIME_TEXT_HTML) {
2001-04-19 14:21:46 +02:00
messageview_change_view_type(messageview, MVIEW_MIME);
mimeview_show_message(messageview->mimeview, mimeinfo, file);
} else {
messageview_change_view_type(messageview, MVIEW_TEXT);
textview_show_message(messageview->textview, mimeinfo, file);
procmime_mimeinfo_free(mimeinfo);
}
g_free(file);
}
static void messageview_change_view_type(MessageView *messageview,
MessageType type)
{
TextView *textview = messageview->textview;
MimeView *mimeview = messageview->mimeview;
if (messageview->type == type) return;
if (type == MVIEW_MIME) {
2002-06-23 09:49:25 +02:00
gtkut_container_remove
(GTK_CONTAINER(GTK_WIDGET_PTR(messageview)),
GTK_WIDGET_PTR(textview));
2001-04-19 14:21:46 +02:00
} else if (type == MVIEW_TEXT) {
2002-06-23 09:49:25 +02:00
gtkut_container_remove
(GTK_CONTAINER(GTK_WIDGET_PTR(messageview)),
GTK_WIDGET_PTR(mimeview));
2002-02-25 10:25:17 +01:00
if (mimeview->vbox == GTK_WIDGET_PTR(textview)->parent)
2001-12-11 10:18:29 +01:00
gtkut_container_remove(GTK_CONTAINER(mimeview->vbox),
GTK_WIDGET_PTR(textview));
2001-04-19 14:21:46 +02:00
gtk_box_pack_start(GTK_BOX(messageview->vbox),
GTK_WIDGET_PTR(textview), TRUE, TRUE, 0);
} else
return;
messageview->type = type;
}
void messageview_clear(MessageView *messageview)
{
messageview_change_view_type(messageview, MVIEW_TEXT);
headerview_clear(messageview->headerview);
textview_clear(messageview->textview);
imageview_clear(messageview->imageview);
2001-04-19 14:21:46 +02:00
}
void messageview_destroy(MessageView *messageview)
{
GtkWidget *textview = GTK_WIDGET_PTR(messageview->textview);
GtkWidget *imageview = GTK_WIDGET_PTR(messageview->imageview);
GtkWidget *mimeview = GTK_WIDGET_PTR(messageview->mimeview);
headerview_destroy(messageview->headerview);
textview_destroy(messageview->textview);
imageview_destroy(messageview->imageview);
mimeview_destroy(messageview->mimeview);
g_free(messageview);
gtk_widget_unref(textview);
gtk_widget_unref(imageview);
gtk_widget_unref(mimeview);
}
void messageview_quote_color_set(void)
{
}
void messageview_set_font(MessageView *messageview)
{
textview_set_font(messageview->textview, NULL);
}
2002-06-22 19:49:39 +02:00
TextView *messageview_get_current_textview(MessageView *messageview)
2001-04-19 14:21:46 +02:00
{
2002-06-22 19:49:39 +02:00
TextView *text = NULL;
2002-05-15 09:47:34 +02:00
if (messageview->type == MVIEW_TEXT)
2002-06-22 19:49:39 +02:00
text = messageview->textview;
2002-05-15 09:47:34 +02:00
else if (messageview->type == MVIEW_MIME) {
if (gtk_notebook_get_current_page
(GTK_NOTEBOOK(messageview->mimeview->notebook)) == 0)
2002-06-22 19:49:39 +02:00
text = messageview->textview;
2002-05-15 09:47:34 +02:00
else if (messageview->mimeview->type == MIMEVIEW_TEXT)
2002-06-22 19:49:39 +02:00
text = messageview->mimeview->textview;
2001-12-12 19:30:35 +01:00
}
2002-05-15 09:47:34 +02:00
2002-06-22 19:49:39 +02:00
return text;
}
void messageview_copy_clipboard(MessageView *messageview)
{
TextView *text;
text = messageview_get_current_textview(messageview);
2002-05-15 09:47:34 +02:00
if (text)
2002-06-22 19:49:39 +02:00
gtk_editable_copy_clipboard(GTK_EDITABLE(text->text));
}
void messageview_select_all(MessageView *messageview)
{
TextView *text;
text = messageview_get_current_textview(messageview);
if (text)
gtk_editable_select_region(GTK_EDITABLE(text->text), 0, -1);
2001-04-19 14:21:46 +02:00
}
2001-09-30 13:07:34 +02:00
void messageview_set_position(MessageView *messageview, gint pos)
{
2002-03-03 10:32:58 +01:00
textview_set_position(messageview->textview, pos);
2001-09-30 13:07:34 +02:00
}
2001-09-24 10:15:52 +02:00
gboolean messageview_search_string(MessageView *messageview, const gchar *str,
gboolean case_sens)
{
2002-03-03 10:32:58 +01:00
return textview_search_string(messageview->textview, str, case_sens);
2001-09-24 10:15:52 +02:00
return FALSE;
}
2001-09-30 13:07:34 +02:00
gboolean messageview_search_string_backward(MessageView *messageview,
const gchar *str,
gboolean case_sens)
{
2002-03-03 10:32:58 +01:00
return textview_search_string_backward(messageview->textview,
str, case_sens);
2001-09-30 13:07:34 +02:00
return FALSE;
}
gboolean messageview_is_visible(MessageView *messageview)
{
return messageview->visible;
}
2001-04-19 14:21:46 +02:00
static void messageview_destroy_cb(GtkWidget *widget, MessageView *messageview)
{
messageview_destroy(messageview);
}
static void messageview_size_allocate_cb(GtkWidget *widget,
GtkAllocation *allocation)
{
g_return_if_fail(allocation != NULL);
prefs_common.msgwin_width = allocation->width;
prefs_common.msgwin_height = allocation->height;
}
static void key_pressed(GtkWidget *widget, GdkEventKey *event,
MessageView *messageview)
{
if (event && event->keyval == GDK_Escape && messageview->window)
gtk_widget_destroy(messageview->window);
}
static void messageview_toggle_view(MessageView *messageview)
{
MainWindow *mainwin = messageview->mainwin;
GtkItemFactory *ifactory;
if (!mainwin) return;
ifactory = gtk_item_factory_from_widget(mainwin->menubar);
menu_toggle_toggle(ifactory, "/View/Expand Summary View");
}
void messageview_toggle_view_real(MessageView *messageview)
{
MainWindow *mainwin = messageview->mainwin;
union CompositeWin *cwin = &mainwin->win;
GtkWidget *vpaned = NULL;
GtkWidget *container = NULL;
GtkItemFactory *ifactory =gtk_item_factory_from_widget(mainwin->menubar);
switch (mainwin->type) {
case SEPARATE_NONE:
vpaned = cwin->sep_none.vpaned;
container = cwin->sep_none.hpaned;
break;
case SEPARATE_FOLDER:
vpaned = cwin->sep_folder.vpaned;
container = mainwin->vbox_body;
break;
case SEPARATE_MESSAGE:
case SEPARATE_BOTH:
return;
}
if (vpaned->parent != NULL) {
gtk_widget_ref(vpaned);
gtkut_container_remove(GTK_CONTAINER(container), vpaned);
gtk_widget_reparent(GTK_WIDGET_PTR(messageview), container);
menu_set_sensitive(ifactory, "/View/Expand Summary View", FALSE);
gtk_widget_grab_focus(GTK_WIDGET(messageview->textview->text));
} else {
gtk_widget_reparent(GTK_WIDGET_PTR(messageview), vpaned);
gtk_container_add(GTK_CONTAINER(container), vpaned);
gtk_widget_unref(vpaned);
menu_set_sensitive(ifactory, "/View/Expand Summary View", TRUE);
gtk_widget_grab_focus(GTK_WIDGET(mainwin->summaryview->ctree));
}
}