src/messageview.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 1999-2007 Hiroyuki Yamamoto and the Claws Mail team
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 3 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  17  *
  18  */
  19
  20 #include "defs.h"
  21
  22 #include <glib.h>
  23 #include <glib/gi18n.h>
  24 #include <gdk/gdkkeysyms.h>
  25 #include <gtk/gtkvbox.h>
  26 #include <gtk/gtkcontainer.h>
  27 #include <gtk/gtkwindow.h>
  28 #include <gtk/gtktext.h>
  29 #include <gtk/gtkmenu.h>
  30 #include <gtk/gtkmenuitem.h>
  31 #include <stdio.h>
  32 #include <ctype.h>
  33 #include <string.h>
  34
  35 #include "main.h"
  36 #include "messageview.h"
  37 #include "message_search.h"
  38 #include "headerview.h"
  39 #include "summaryview.h"
  40 #include "textview.h"
  41 #include "mimeview.h"
  42 #include "menu.h"
  43 #include "about.h"
  44 #include "filesel.h"
  45 #include "foldersel.h"
  46 #include "sourcewindow.h"
  47 #include "addressbook.h"
  48 #include "alertpanel.h"
  49 #include "inputdialog.h"
  50 #include "mainwindow.h"
  51 #include "manage_window.h"
  52 #include "procmsg.h"
  53 #include "procheader.h"
  54 #include "procmime.h"
  55 #include "account.h"
  56 #include "action.h"
  57 #include "prefs_common.h"
  58 #include "prefs_account.h"
  59 #include "gtkutils.h"
  60 #include "utils.h"
  61 #include "send_message.h"
  62 #include "stock_pixmap.h"
  63 #include "hooks.h"
  64 #include "filtering.h"
  65 #include "partial_download.h"
  66 #include "gedit-print.h"
  67 #include "uri_opener.h"
  68 #include "inc.h"
  69 #include "log.h"
  70 #include "combobox.h"
  71 #include "printing.h"
  72 #include "quoted-printable.h"
  73 #include "version.h"
  74 #include "statusbar.h"
  75
  76 static GList *messageview_list = NULL;
  77
  78 static gint messageview_delete_cb       (GtkWidget              *widget,
  79                                          GdkEventAny            *event,
  80                                          MessageView            *messageview);
  81 static void messageview_size_allocate_cb(GtkWidget      *widget,
  82                                          GtkAllocation  *allocation);
  83 #ifndef MAEMO
  84 static gboolean key_pressed             (GtkWidget      *widget,
  85                                          GdkEventKey    *event,
  86                                          MessageView    *messageview);
  87 #endif
  88 static void return_receipt_show         (NoticeView     *noticeview,
  89                                          MsgInfo        *msginfo);
  90 static void return_receipt_send_clicked (NoticeView     *noticeview,
  91                                          MsgInfo        *msginfo);
  92 static void partial_recv_show           (NoticeView     *noticeview,
  93                                          MsgInfo        *msginfo);
  94 static void partial_recv_dload_clicked  (NoticeView     *noticeview,
  95                                          MsgInfo        *msginfo);
  96 static void partial_recv_del_clicked    (NoticeView     *noticeview,
  97                                          MsgInfo        *msginfo);
  98 static void partial_recv_unmark_clicked (NoticeView     *noticeview,
  99                                          MsgInfo        *msginfo);
 100 static void save_as_cb                  (gpointer        data,
 101                                          guint           action,
 102                                          GtkWidget      *widget);
 103 #if GTK_CHECK_VERSION(2,10,0) && !defined(USE_GNOMEPRINT)
 104 static void page_setup_cb               (gpointer        data,
 105                                          guint           action,
 106                                          GtkWidget      *widget);
 107 #endif
 108 static void print_cb                    (gpointer        data,
 109                                          guint           action,
 110                                          GtkWidget      *widget);
 111 static void close_cb                    (gpointer        data,
 112                                          guint           action,
 113                                          GtkWidget      *widget);
 114 static void copy_cb                     (gpointer        data,
 115                                          guint           action,
 116                                          GtkWidget      *widget);
 117 static void allsel_cb                   (gpointer        data,
 118                                          guint           action,
 119                                          GtkWidget      *widget);
 120 static void search_cb                   (gpointer        data,
 121                                          guint           action,
 122                                          GtkWidget      *widget);
 123
 124 static void prev_cb                     (gpointer        data,
 125                                          guint           action,
 126                                          GtkWidget      *widget);
 127 static void next_cb                     (gpointer        data,
 128                                          guint           action,
 129                                          GtkWidget      *widget);
 130 static void prev_unread_cb              (gpointer        data,
 131                                          guint           action,
 132                                          GtkWidget      *widget);
 133 static void next_unread_cb              (gpointer        data,
 134                                          guint           action,
 135                                          GtkWidget      *widget);
 136 static void prev_new_cb                 (gpointer        data,
 137                                          guint           action,
 138                                          GtkWidget      *widget);
 139 static void next_new_cb                 (gpointer        data,
 140                                          guint           action,
 141                                          GtkWidget      *widget);
 142 static void prev_marked_cb              (gpointer        data,
 143                                          guint           action,
 144                                          GtkWidget      *widget);
 145 static void next_marked_cb              (gpointer        data,
 146                                          guint           action,
 147                                          GtkWidget      *widget);
 148 static void prev_labeled_cb             (gpointer        data,
 149                                          guint           action,
 150                                          GtkWidget      *widget);
 151 static void next_labeled_cb             (gpointer        data,
 152                                          guint           action,
 153                                          GtkWidget      *widget);
 154 static void last_read_cb                (gpointer        data,
 155                                          guint           action,
 156                                          GtkWidget      *widget);
 157 static void parent_cb                   (gpointer        data,
 158                                          guint           action,
 159                                          GtkWidget      *widget);
 160 static void goto_unread_folder_cb       (gpointer        data,
 161                                          guint           action,
 162                                          GtkWidget      *widget);
 163 static void goto_folder_cb              (gpointer        data,
 164                                          guint           action,
 165                                          GtkWidget      *widget);
 166
 167 static void set_charset_cb              (gpointer        data,
 168                                          guint           action,
 169                                          GtkWidget      *widget);
 170 static void set_decode_cb               (gpointer        data,
 171                                          guint           action,
 172                                          GtkWidget      *widget);
 173 static void view_source_cb              (gpointer        data,
 174                                          guint           action,
 175                                          GtkWidget      *widget);
 176 static void show_all_header_cb          (gpointer        data,
 177                                          guint           action,
 178                                          GtkWidget      *widget);
 179 static void msg_hide_quotes_cb          (gpointer        data,
 180                                          guint           action,
 181                                          GtkWidget      *widget);
 182
 183 static void compose_cb                  (gpointer        data,
 184                                          guint           action,
 185                                          GtkWidget      *widget);
 186 static void reply_cb                    (gpointer        data,
 187                                          guint           action,
 188                                          GtkWidget      *widget);
 189
 190 static PrefsAccount *select_account_from_list
 191                                         (GList          *ac_list);
 192 static void addressbook_open_cb         (gpointer        data,
 193                                          guint           action,
 194                                          GtkWidget      *widget);
 195 static void add_address_cb              (gpointer        data,
 196                                          guint           action,
 197                                          GtkWidget      *widget);
 198 static void create_filter_cb            (gpointer        data,
 199                                          guint           action,
 200                                          GtkWidget      *widget);
 201 static void create_processing_cb        (gpointer        data,
 202                                          guint           action,
 203                                          GtkWidget      *widget);
 204 static void open_urls_cb                (gpointer        data,
 205                                          guint           action,
 206                                          GtkWidget      *widget);
 207
 208 static void about_cb                    (gpointer        data,
 209                                          guint           action,
 210                                          GtkWidget      *widget);
 211 static void messageview_update          (MessageView    *msgview,
 212                                          MsgInfo        *old_msginfo);
 213 static gboolean messageview_update_msg  (gpointer source, gpointer data);
 214
 215 static GList *msgview_list = NULL;
 216 static GtkItemFactoryEntry msgview_entries[] =
 217 {
 218         {N_("/_File"),                  NULL, NULL, 0, "<Branch>"},
 219         {N_("/_File/_Save as..."),      "<control>S", save_as_cb, 0, NULL},
 220 #if GTK_CHECK_VERSION(2,10,0) && !defined(USE_GNOMEPRINT)
 221         {N_("/_File/Page setup..."),    NULL, page_setup_cb, 0, NULL},
 222 #endif
 223         {N_("/_File/_Print..."),        "<control>P", print_cb, 0, NULL},
 224         {N_("/_File/---"),              NULL, NULL, 0, "<Separator>"},
 225         {N_("/_File/_Close"),           "<control>W", close_cb, 0, NULL},
 226
 227         {N_("/_Edit"),                  NULL, NULL, 0, "<Branch>"},
 228         {N_("/_Edit/_Copy"),            "<control>C", copy_cb, 0, NULL},
 229         {N_("/_Edit/Select _all"),      "<control>A", allsel_cb, 0, NULL},
 230         {N_("/_Edit/---"),              NULL, NULL, 0, "<Separator>"},
 231         {N_("/_Edit/_Find in current message..."),
 232                                         "<control>F", search_cb, 0, NULL},
 233
 234         {N_("/_View"),                  NULL, NULL, 0, "<Branch>"},
 235         {N_("/_View/_Go to"),                   NULL, NULL, 0, "<Branch>"},
 236         {N_("/_View/_Go to/_Previous message"), "P", prev_cb, 0, NULL},
 237         {N_("/_View/_Go to/_Next message"),     "N", next_cb, 0, NULL},
 238         {N_("/_View/_Go to/---"),               NULL, NULL, 0, "<Separator>"},
 239         {N_("/_View/_Go to/P_revious unread message"),
 240                                                 "<shift>P", prev_unread_cb, 0, NULL},
 241         {N_("/_View/_Go to/N_ext unread message"),
 242                                                 "<shift>N", next_unread_cb, 0, NULL},
 243         {N_("/_View/_Go to/---"),               NULL, NULL, 0, "<Separator>"},
 244         {N_("/_View/_Go to/Previous ne_w message"),     NULL, prev_new_cb, 0, NULL},
 245         {N_("/_View/_Go to/Ne_xt new message"), NULL, next_new_cb, 0, NULL},
 246         {N_("/_View/_Go to/---"),               NULL, NULL, 0, "<Separator>"},
 247         {N_("/_View/_Go to/Previous _marked message"),
 248                                                 NULL, prev_marked_cb, 0, NULL},
 249         {N_("/_View/_Go to/Next m_arked message"),
 250                                                 NULL, next_marked_cb, 0, NULL},
 251         {N_("/_View/_Go to/---"),               NULL, NULL, 0, "<Separator>"},
 252         {N_("/_View/_Go to/Previous _labeled message"),
 253                                                 NULL, prev_labeled_cb, 0, NULL},
 254         {N_("/_View/_Go to/Next la_beled message"),
 255                                                 NULL, next_labeled_cb, 0, NULL},
 256         {N_("/_View/_Go to/---"),               NULL, NULL, 0, "<Separator>"},
 257         {N_("/_View/_Go to/Last read message"),
 258                                                 NULL, last_read_cb, 0, NULL},
 259         {N_("/_View/_Go to/Parent message"),
 260                                                 "<control>Up", parent_cb, 0, NULL},
 261         {N_("/_View/_Go to/---"),               NULL, NULL, 0, "<Separator>"},
 262         {N_("/_View/_Go to/Next unread _folder"),       "<shift>G", goto_unread_folder_cb, 0, NULL},
 263         {N_("/_View/_Go to/_Other folder..."),  "G", goto_folder_cb, 0, NULL},
 264         {N_("/_View/---"),                      NULL, NULL, 0, "<Separator>"},
 265
 266 #define ENC_SEPARATOR \
 267         {N_("/_View/Character _encoding/---"),  NULL, NULL, 0, "<Separator>"}
 268 #define ENC_ACTION(action) \
 269         NULL, set_charset_cb, action, "/View/Character encoding/Auto detect"
 270
 271         {N_("/_View/Character _encoding"),      NULL, NULL, 0, "<Branch>"},
 272         {N_("/_View/Character _encoding/_Auto detect"),
 273                                         NULL, set_charset_cb, C_AUTO, "<RadioItem>"},
 274         ENC_SEPARATOR,
 275         {N_("/_View/Character _encoding/7bit ASCII (US-ASC_II)"),
 276          ENC_ACTION(C_US_ASCII)},
 277
 278         {N_("/_View/Character _encoding/Unicode (_UTF-8)"),
 279          ENC_ACTION(C_UTF_8)},
 280         ENC_SEPARATOR,
 281         {N_("/_View/Character _encoding/Western European (ISO-8859-_1)"),
 282          ENC_ACTION(C_ISO_8859_1)},
 283         {N_("/_View/Character _encoding/Western European (ISO-8859-15)"),
 284          ENC_ACTION(C_ISO_8859_15)},
 285         {N_("/_View/Character _encoding/Western European (Windows-1252)"),
 286          ENC_ACTION(C_WINDOWS_1252)},
 287         ENC_SEPARATOR,
 288         {N_("/_View/Character _encoding/Central European (ISO-8859-_2)"),
 289          ENC_ACTION(C_ISO_8859_2)},
 290         ENC_SEPARATOR,
 291         {N_("/_View/Character _encoding/_Baltic (ISO-8859-13)"),
 292          ENC_ACTION(C_ISO_8859_13)},
 293         {N_("/_View/Character _encoding/Baltic (ISO-8859-_4)"),
 294          ENC_ACTION(C_ISO_8859_4)},
 295         ENC_SEPARATOR,
 296         {N_("/_View/Character _encoding/Greek (ISO-8859-_7)"),
 297          ENC_ACTION(C_ISO_8859_7)},
 298         ENC_SEPARATOR,
 299         {N_("/_View/Character _encoding/Hebrew (ISO-8859-_8)"),
 300          ENC_ACTION(C_ISO_8859_8)},
 301         {N_("/_View/Character _encoding/Hebrew (Windows-1255)"),
 302          ENC_ACTION(C_CP1255)},
 303         ENC_SEPARATOR,
 304         {N_("/_View/Character _encoding/Arabic (ISO-8859-_6)"),
 305          ENC_ACTION(C_ISO_8859_6)},
 306         {N_("/_View/Character _encoding/Arabic (Windows-1256)"),
 307          ENC_ACTION(C_CP1256)},
 308         ENC_SEPARATOR,
 309         {N_("/_View/Character _encoding/Turkish (ISO-8859-_9)"),
 310          ENC_ACTION(C_ISO_8859_9)},
 311         ENC_SEPARATOR,
 312         {N_("/_View/Character _encoding/Cyrillic (ISO-8859-_5)"),
 313          ENC_ACTION(C_ISO_8859_5)},
 314         {N_("/_View/Character _encoding/Cyrillic (KOI8-_R)"),
 315          ENC_ACTION(C_KOI8_R)},
 316         {N_("/_View/Character _encoding/Cyrillic (KOI8-U)"),
 317          ENC_ACTION(C_KOI8_U)},
 318         {N_("/_View/Character _encoding/Cyrillic (Windows-1251)"),
 319          ENC_ACTION(C_CP1251)},
 320         ENC_SEPARATOR,
 321         {N_("/_View/Character _encoding/Japanese (ISO-2022-_JP)"),
 322          ENC_ACTION(C_ISO_2022_JP)},
 323         {N_("/_View/Character _encoding/Japanese (ISO-2022-JP-2)"),
 324          ENC_ACTION(C_ISO_2022_JP_2)},
 325         {N_("/_View/Character _encoding/Japanese (_EUC-JP)"),
 326          ENC_ACTION(C_EUC_JP)},
 327         {N_("/_View/Character _encoding/Japanese (_Shift__JIS)"),
 328          ENC_ACTION(C_SHIFT_JIS)},
 329         ENC_SEPARATOR,
 330         {N_("/_View/Character _encoding/Simplified Chinese (_GB2312)"),
 331          ENC_ACTION(C_GB2312)},
 332         {N_("/_View/Character _encoding/Simplified Chinese (GBK)"),
 333          ENC_ACTION(C_GBK)},
 334         {N_("/_View/Character _encoding/Traditional Chinese (_Big5)"),
 335          ENC_ACTION(C_BIG5)},
 336         {N_("/_View/Character _encoding/Traditional Chinese (EUC-_TW)"),
 337          ENC_ACTION(C_EUC_TW)},
 338         {N_("/_View/Character _encoding/Chinese (ISO-2022-_CN)"),
 339          ENC_ACTION(C_ISO_2022_CN)},
 340         ENC_SEPARATOR,
 341         {N_("/_View/Character _encoding/Korean (EUC-_KR)"),
 342          ENC_ACTION(C_EUC_KR)},
 343         {N_("/_View/Character _encoding/Korean (ISO-2022-KR)"),
 344          ENC_ACTION(C_ISO_2022_KR)},
 345         ENC_SEPARATOR,
 346         {N_("/_View/Character _encoding/Thai (TIS-620)"),
 347          ENC_ACTION(C_TIS_620)},
 348         {N_("/_View/Character _encoding/Thai (Windows-874)"),
 349          ENC_ACTION(C_WINDOWS_874)},
 350
 351 #undef ENC_SEPARATOR
 352 #undef ENC_ACTION
 353
 354 #define DEC_SEPARATOR \
 355         {N_("/_View/Decode/---"),               NULL, NULL, 0, "<Separator>"}
 356 #define DEC_ACTION(action) \
 357          NULL, set_decode_cb, action, "/View/Decode/Auto detect"
 358         {N_("/_View/Decode"),           NULL, NULL, 0, "<Branch>"},
 359         {N_("/_View/Decode/_Auto detect"),
 360          NULL, set_decode_cb, 0, "<RadioItem>"},
 361         {N_("/_View/Decode/---"),               NULL, NULL, 0, "<Separator>"},
 362         {N_("/_View/Decode/_8bit"),             DEC_ACTION(ENC_8BIT)},
 363         {N_("/_View/Decode/_Quoted printable"), DEC_ACTION(ENC_QUOTED_PRINTABLE)},
 364         {N_("/_View/Decode/_Base64"),           DEC_ACTION(ENC_BASE64)},
 365         {N_("/_View/Decode/_Uuencode"),         DEC_ACTION(ENC_X_UUENCODE)},
 366
 367 #undef DEC_SEPARATOR
 368 #undef DEC_ACTION
 369
 370         {N_("/_View/---"),              NULL, NULL, 0, "<Separator>"},
 371         {N_("/_View/Mess_age source"),  "<control>U", view_source_cb, 0, NULL},
 372         {N_("/_View/Show all _headers"),"<control>H", show_all_header_cb, 0, "<ToggleItem>"},
 373         {N_("/_View/Quotes"),                   NULL, NULL, 0, "<Branch>"},
 374         {N_("/_View/Quotes/_Fold all"),         "<control><shift>Q", msg_hide_quotes_cb, 1, "<ToggleItem>"},
 375         {N_("/_View/Quotes/Fold from level _2"),NULL, msg_hide_quotes_cb, 2, "<ToggleItem>"},
 376         {N_("/_View/Quotes/Fold from level _3"),NULL, msg_hide_quotes_cb, 3, "<ToggleItem>"},
 377
 378         {N_("/_Message"),               NULL, NULL, 0, "<Branch>"},
 379         {N_("/_Message/Compose _new message"),
 380                                         "<control>M", compose_cb, 0, NULL},
 381         {N_("/_Message/---"),           NULL, NULL, 0, "<Separator>"},
 382         {N_("/_Message/_Reply"),        "<control>R", reply_cb, COMPOSE_REPLY, NULL},
 383         {N_("/_Message/Repl_y to/_all"),
 384                                         "<control><shift>R", reply_cb, COMPOSE_REPLY_TO_ALL, NULL},
 385         {N_("/_Message/Repl_y to/_sender"),
 386                                         NULL, reply_cb, COMPOSE_REPLY_TO_SENDER, NULL},
 387         {N_("/_Message/Repl_y to/mailing _list"),
 388                                         "<control>L", reply_cb, COMPOSE_REPLY_TO_LIST, NULL},
 389         {N_("/_Message/---"),           NULL, NULL, 0, "<Separator>"},
 390         {N_("/_Message/_Forward"),      "<control><alt>F", reply_cb, COMPOSE_FORWARD_INLINE, NULL},
 391         {N_("/_Message/For_ward as attachment"),
 392                                         NULL, reply_cb, COMPOSE_FORWARD_AS_ATTACH, NULL},
 393         {N_("/_Message/Redirec_t"),     NULL, reply_cb, COMPOSE_REDIRECT, NULL},
 394
 395         {N_("/_Tools"),                 NULL, NULL, 0, "<Branch>"},
 396         {N_("/_Tools/_Address book"),   "<control><shift>A", addressbook_open_cb, 0, NULL},
 397         {N_("/_Tools/Add sender to address boo_k"),
 398                                         NULL, add_address_cb, 0, NULL},
 399         {N_("/_Tools/---"),             NULL, NULL, 0, "<Separator>"},
 400         {N_("/_Tools/_Create filter rule"),
 401                                         NULL, NULL, 0, "<Branch>"},
 402         {N_("/_Tools/_Create filter rule/_Automatically"),
 403                                         NULL, create_filter_cb, FILTER_BY_AUTO, NULL},
 404         {N_("/_Tools/_Create filter rule/by _From"),
 405                                         NULL, create_filter_cb, FILTER_BY_FROM, NULL},
 406         {N_("/_Tools/_Create filter rule/by _To"),
 407                                         NULL, create_filter_cb, FILTER_BY_TO, NULL},
 408         {N_("/_Tools/_Create filter rule/by _Subject"),
 409                                         NULL, create_filter_cb, FILTER_BY_SUBJECT, NULL},
 410         {N_("/_Tools/Create processing rule"),
 411                                         NULL, NULL, 0, "<Branch>"},
 412         {N_("/_Tools/Create processing rule/_Automatically"),
 413                                         NULL, create_processing_cb, FILTER_BY_AUTO, NULL},
 414         {N_("/_Tools/Create processing rule/by _From"),
 415                                         NULL, create_processing_cb, FILTER_BY_FROM, NULL},
 416         {N_("/_Tools/Create processing rule/by _To"),
 417                                         NULL, create_processing_cb, FILTER_BY_TO, NULL},
 418         {N_("/_Tools/Create processing rule/by _Subject"),
 419                                         NULL, create_processing_cb, FILTER_BY_SUBJECT, NULL},
 420         {N_("/_Tools/---"),             NULL, NULL, 0, "<Separator>"},
 421         {N_("/_Tools/List _URLs..."),   "<shift><control>U", open_urls_cb, 0, NULL},
 422         {N_("/_Tools/---"),             NULL, NULL, 0, "<Separator>"},
 423         {N_("/_Tools/Actio_ns"),        NULL, NULL, 0, "<Branch>"},
 424
 425         {N_("/_Help"),                  NULL, NULL, 0, "<Branch>"},
 426         {N_("/_Help/_About"),           NULL, about_cb, 0, NULL}
 427 };
 428
 429 MessageView *messageview_create(MainWindow *mainwin)
 430 {
 431         MessageView *messageview;
 432         GtkWidget *vbox;
 433         HeaderView *headerview;
 434         MimeView *mimeview;
 435         NoticeView *noticeview;
 436
 437         debug_print("Creating message view...\n");
 438         messageview = g_new0(MessageView, 1);
 439
 440         headerview = headerview_create();
 441
 442         noticeview = noticeview_create(mainwin);
 443
 444         mimeview = mimeview_create(mainwin);
 445         mimeview->textview = textview_create();
 446         mimeview->textview->messageview = messageview;
 447         mimeview->messageview = messageview;
 448
 449         vbox = gtk_vbox_new(FALSE, 0);
 450         gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET_PTR(headerview),
 451                            FALSE, FALSE, 0);
 452         gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET_PTR(noticeview),
 453                            FALSE, FALSE, 0);
 454         gtk_box_pack_start(GTK_BOX(vbox),
 455                            GTK_WIDGET_PTR(mimeview), TRUE, TRUE, 0);
 456         gtk_widget_show(vbox);
 457
 458         messageview->vbox        = vbox;
 459         messageview->new_window  = FALSE;
 460         messageview->window      = NULL;
 461         messageview->headerview  = headerview;
 462         messageview->mimeview    = mimeview;
 463         messageview->noticeview = noticeview;
 464         messageview->mainwin    = mainwin;
 465
 466         messageview->statusbar     = NULL;
 467         messageview->statusbar_cid = 0;
 468
 469         messageview->show_full_text= FALSE;
 470
 471         messageview->msginfo_update_callback_id =
 472                 hooks_register_hook(MSGINFO_UPDATE_HOOKLIST, messageview_update_msg, (gpointer) messageview);
 473
 474         return messageview;
 475 }
 476
 477 GList *messageview_get_msgview_list(void)
 478 {
 479         return msgview_list;
 480 }
 481
 482 void messageview_update_actions_menu(MessageView *msgview)
 483 {
 484         GtkItemFactory *ifactory;
 485
 486         /* Messages opened in a new window do not have a menu bar */
 487         if (msgview->menubar == NULL)
 488                 return;
 489         ifactory = gtk_item_factory_from_widget(msgview->menubar);
 490         action_update_msgview_menu(ifactory, "/Tools/Actions", msgview);
 491 }
 492
 493 static void messageview_add_toolbar(MessageView *msgview, GtkWidget *window)
 494 {
 495         GtkWidget *handlebox;
 496         GtkWidget *vbox;
 497         GtkWidget *menubar;
 498 #ifndef MAEMO
 499         GtkWidget *statusbar = NULL;
 500 #endif
 501         guint n_menu_entries;
 502
 503         vbox = gtk_vbox_new(FALSE, 0);
 504         gtk_widget_show(vbox);
 505         gtk_container_add(GTK_CONTAINER(window), vbox);
 506
 507         n_menu_entries = sizeof(msgview_entries) / sizeof(msgview_entries[0]);
 508         menubar = menubar_create(window, msgview_entries,
 509                                  n_menu_entries, "<MessageView>", msgview);
 510         gtk_widget_show(menubar);
 511         gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, TRUE, 0);
 512
 513         if (prefs_common.toolbar_detachable) {
 514                 handlebox = gtk_handle_box_new();
 515         } else {
 516                 handlebox = gtk_hbox_new(FALSE, 0);
 517         }
 518         gtk_box_pack_start(GTK_BOX(vbox), handlebox, FALSE, FALSE, 0);
 519         gtk_widget_realize(handlebox);
 520 #ifdef MAEMO
 521         msgview->toolbar = toolbar_create(TOOLBAR_MSGVIEW, window,
 522                                           (gpointer)msgview);
 523         msgview->statusbar = NULL;
 524         msgview->statusbar_cid = 0;
 525 #else
 526         msgview->toolbar = toolbar_create(TOOLBAR_MSGVIEW, handlebox,
 527                                           (gpointer)msgview);
 528         statusbar = gtk_statusbar_new();
 529         gtk_widget_show(statusbar);
 530         gtk_box_pack_end(GTK_BOX(vbox), statusbar, FALSE, FALSE, 0);
 531         msgview->statusbar = statusbar;
 532         msgview->statusbar_cid = gtk_statusbar_get_context_id
 533                 (GTK_STATUSBAR(statusbar), "Message View");
 534 #endif
 535
 536
 537         msgview->handlebox = handlebox;
 538         msgview->menubar   = menubar;
 539
 540         gtk_container_add(GTK_CONTAINER(vbox),
 541                           GTK_WIDGET_PTR(msgview));
 542
 543         messageview_update_actions_menu(msgview);
 544
 545         msgview_list = g_list_append(msgview_list, msgview);
 546 }
 547
 548 static MessageView *messageview_create_with_new_window_visible(MainWindow *mainwin, gboolean show)
 549 {
 550         MessageView *msgview;
 551         GtkWidget *window;
 552         static GdkGeometry geometry;
 553
 554         window = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "messageview");
 555         gtk_window_set_title(GTK_WINDOW(window), _("Claws Mail - Message View"));
 556         gtk_window_set_resizable(GTK_WINDOW(window), TRUE);
 557
 558         if (!geometry.min_height) {
 559                 geometry.min_width = 320;
 560                 geometry.min_height = 200;
 561         }
 562         gtk_window_set_geometry_hints(GTK_WINDOW(window), NULL, &geometry,
 563                                       GDK_HINT_MIN_SIZE);
 564
 565         gtk_widget_set_size_request(window, prefs_common.msgwin_width,
 566                                     prefs_common.msgwin_height);
 567
 568         msgview = messageview_create(mainwin);
 569
 570         g_signal_connect(G_OBJECT(window), "size_allocate",
 571                          G_CALLBACK(messageview_size_allocate_cb),
 572                          msgview);
 573         g_signal_connect(G_OBJECT(window), "delete_event",
 574                          G_CALLBACK(messageview_delete_cb), msgview);
 575 #ifdef MAEMO
 576         maemo_connect_key_press_to_mainwindow(GTK_WINDOW(window));
 577 #else
 578         g_signal_connect(G_OBJECT(window), "key_press_event",
 579                          G_CALLBACK(key_pressed), msgview);
 580 #endif
 581         messageview_add_toolbar(msgview, window);
 582
 583         if (show) {
 584                 gtk_widget_grab_focus(msgview->mimeview->textview->text);
 585                 gtk_widget_show(window);
 586         } else {
 587                 gtk_widget_realize(window);
 588         }
 589
 590         msgview->new_window = TRUE;
 591         msgview->window = window;
 592         msgview->visible = TRUE;
 593
 594         toolbar_set_style(msgview->toolbar->toolbar, msgview->handlebox,
 595                           prefs_common.toolbar_style);
 596         messageview_init(msgview);
 597
 598         return msgview;
 599 }
 600
 601 MessageView *messageview_create_with_new_window(MainWindow *mainwin)
 602 {
 603         return messageview_create_with_new_window_visible(mainwin, TRUE);
 604 }
 605 void messageview_init(MessageView *messageview)
 606 {
 607         headerview_init(messageview->headerview);
 608         mimeview_init(messageview->mimeview);
 609         /*messageview_set_font(messageview);*/
 610
 611         noticeview_hide(messageview->noticeview);
 612 }
 613
 614 static void notification_convert_header(gchar *dest, gint len,
 615                                         const gchar *src_,
 616                                         gint header_len)
 617 {
 618         char *src;
 619
 620         g_return_if_fail(src_ != NULL);
 621         g_return_if_fail(dest != NULL);
 622
 623         if (len < 1) return;
 624
 625         Xstrndup_a(src, src_, len, return);
 626
 627         remove_return(src);
 628
 629         if (is_ascii_str(src)) {
 630                 strncpy2(dest, src, len);
 631                 dest[len - 1] = '\0';
 632                 return;
 633         } else
 634                 conv_encode_header(dest, len, src, header_len, FALSE);
 635 }
 636
 637 static gint disposition_notification_send(MsgInfo *msginfo)
 638 {
 639         gchar buf[BUFFSIZE];
 640         gchar tmp[MAXPATHLEN + 1];
 641         FILE *fp;
 642         GList *ac_list;
 643         PrefsAccount *account = NULL;
 644         gint ok;
 645         gchar *to;
 646         FolderItem *queue, *outbox;
 647         gint num;
 648         gchar *path;
 649         gchar *addr;
 650         gchar *addrp;
 651         gchar *foo = NULL;
 652         gboolean queued_removed = FALSE;
 653         gchar *boundary = NULL;
 654         gchar *date = NULL;
 655         gchar *orig_to = NULL;
 656         gchar *enc_sub = NULL;
 657
 658         if (!msginfo->extradata)
 659                 return -1;
 660         if (!msginfo->extradata->returnreceiptto &&
 661             !msginfo->extradata->dispositionnotificationto)
 662                 return -1;
 663
 664         /* RFC2298: Test for Return-Path */
 665         if (msginfo->extradata->dispositionnotificationto)
 666                 to = msginfo->extradata->dispositionnotificationto;
 667         else
 668                 to = msginfo->extradata->returnreceiptto;
 669
 670         ok = procheader_get_header_from_msginfo(msginfo, buf, sizeof(buf),
 671                                 "Return-Path:");
 672         if (ok == 0) {
 673                 gchar *to_addr = g_strdup(to);
 674                 extract_address(to_addr);
 675                 extract_address(buf);
 676                 ok = strcasecmp(to_addr, buf);
 677                 g_free(to_addr);
 678         } else {
 679                 strncpy(buf, _("<No Return-Path found>"),
 680                                 sizeof(buf));
 681         }
 682
 683         if (ok != 0) {
 684                 AlertValue val;
 685                 gchar *message;
 686                 message = g_markup_printf_escaped(
 687                   _("The notification address to which the return receipt is\n"
 688                     "to be sent does not correspond to the return path:\n"
 689                     "Notification address: %s\n"
 690                     "Return path: %s\n"
 691                     "It is advised to not to send the return receipt."),
 692                   to, buf);
 693                 val = alertpanel_full(_("Warning"), message,
 694                                 _("_Don't Send"), _("_Send"), NULL, FALSE,
 695                                 NULL, ALERT_WARNING, G_ALERTDEFAULT);
 696                 g_free(message);
 697                 if (val != G_ALERTALTERNATE)
 698                         return -1;
 699         }
 700
 701         ac_list = account_find_all_from_address(NULL, msginfo->to);
 702         ac_list = account_find_all_from_address(ac_list, msginfo->cc);
 703
 704         if (ac_list == NULL) {
 705                 AlertValue val =
 706                 alertpanel_full(_("Warning"),
 707                   _("This message is asking for a return receipt notification\n"
 708                     "but according to its 'To:' and 'CC:' headers it was not\n"
 709                     "officially addressed to you.\n"
 710                     "It is advised to not to send the return receipt."),
 711                   _("_Don't Send"), _("_Send"), NULL, FALSE,
 712                   NULL, ALERT_WARNING, G_ALERTDEFAULT);
 713                 if (val != G_ALERTALTERNATE)
 714                         return -1;
 715         }
 716
 717         if (g_list_length(ac_list) > 1) {
 718                 if ((account = select_account_from_list(ac_list)) == NULL)
 719                         return -1;
 720         }
 721         else if (ac_list != NULL)
 722                 account = (PrefsAccount *) ac_list->data;
 723         g_list_free(ac_list);
 724
 725         if (account == NULL)
 726                 account = account_get_default();
 727         if (!account || account->protocol == A_NNTP) {
 728                 alertpanel_error(_("Account for sending mail is not specified.\n"
 729                                    "Please select a mail account before sending."));
 730                 return -1;
 731         }
 732
 733         /* write to temporary file */
 734         g_snprintf(tmp, sizeof(tmp), "%s%ctmpmsg%p",
 735                    get_rc_dir(), G_DIR_SEPARATOR, msginfo);
 736
 737         if ((fp = g_fopen(tmp, "wb")) == NULL) {
 738                 FILE_OP_ERROR(tmp, "fopen");
 739                 return -1;
 740         }
 741
 742         /* chmod for security */
 743         if (change_file_mode_rw(fp, tmp) < 0) {
 744                 FILE_OP_ERROR(tmp, "chmod");
 745                 g_warning("can't change file mode\n");
 746         }
 747
 748         addr = g_strdup(to);
 749
 750         extract_address(addr);
 751         addrp = addr;
 752
 753         /* write queue headers */
 754         if (fprintf(fp, "AF:\n"
 755                     "NF:0\n"
 756                     "PS:10\n"
 757                     "SRH:1\n"
 758                     "SFN:\n"
 759                     "DSR:\n"
 760                     "MID:\n"
 761                     "CFG:\n"
 762                     "PT:0\n"
 763                     "S:%s\n"
 764                     "RQ:\n"
 765                     "SSV:%s\n"
 766                     "SSH:\n"
 767                     "R:<%s>\n",
 768                     account->address,
 769                     account->smtp_server?account->smtp_server:"",
 770                     addrp) < 0) {
 771                 g_free(addrp);
 772                 fclose(fp);
 773                 claws_unlink(tmp);
 774                 return -1;
 775         }
 776
 777         g_free(addrp);
 778
 779         /* check whether we need to save the message */
 780         outbox = account_get_special_folder(account, F_OUTBOX);
 781         if (folder_get_default_outbox() == outbox && !prefs_common.savemsg)
 782                 outbox = NULL;
 783         if (outbox) {
 784                 path = folder_item_get_identifier(outbox);
 785                 if (fprintf(fp, "SCF:%s\n", path) < 0) {
 786                         g_free(path);
 787                         fclose(fp);
 788                         claws_unlink(tmp);
 789                         return -1;
 790                 }
 791                 g_free(path);
 792         }
 793
 794         if (fprintf(fp, "X-Claws-End-Special-Headers: 1\n") < 0) {
 795                 fclose(fp);
 796                 claws_unlink(tmp);
 797                 return -1;
 798         }
 799
 800         /* Date */
 801         get_rfc822_date(buf, sizeof(buf));
 802         if (fprintf(fp, "Date: %s\n", buf) < 0) {
 803                 fclose(fp);
 804                 claws_unlink(tmp);
 805                 return -1;
 806         }
 807
 808         /* From */
 809         if (account->name && *account->name) {
 810                 notification_convert_header
 811                         (buf, sizeof(buf), account->name,
 812                          strlen("From: "));
 813                 if (fprintf(fp, "From: %s <%s>\n", buf, account->address) < 0) {
 814                         fclose(fp);
 815                         claws_unlink(tmp);
 816                         return -1;
 817                 }
 818         } else
 819                 if (fprintf(fp, "From: %s\n", account->address) < 0) {
 820                         fclose(fp);
 821                         claws_unlink(tmp);
 822                         return -1;
 823                 }
 824
 825
 826         if (fprintf(fp, "To: %s\n", to) < 0) {
 827                 fclose(fp);
 828                 claws_unlink(tmp);
 829                 return -1;
 830         }
 831
 832         /* Subject */
 833         notification_convert_header(buf, sizeof(buf), msginfo->subject,
 834                                     strlen("Subject: "));
 835         if (fprintf(fp, "Subject: Disposition notification: %s\n", buf) < 0) {
 836                 fclose(fp);
 837                 claws_unlink(tmp);
 838                 return -1;
 839         }
 840
 841         /* Message ID */
 842         if (account->set_domain && account->domain) {
 843                 g_snprintf(buf, sizeof(buf), "%s", account->domain);
 844         } else if (!strncmp(get_domain_name(), "localhost", strlen("localhost"))) {
 845                 g_snprintf(buf, sizeof(buf), "%s",
 846                         strchr(account->address, '@') ?
 847                                 strchr(account->address, '@')+1 :
 848                                 account->address);
 849         } else {
 850                 g_snprintf(buf, sizeof(buf), "%s", "");
 851         }
 852
 853         if (account->gen_msgid) {
 854                 generate_msgid(buf, sizeof(buf));
 855
 856                 if (fprintf(fp, "Message-ID: <%s>\n", buf) < 0) {
 857                         fclose(fp);
 858                         claws_unlink(tmp);
 859                         return -1;
 860                 }
 861         }
 862
 863         boundary = generate_mime_boundary("DN");
 864         get_rfc822_date(buf, sizeof(buf));
 865         date = g_strdup(buf);
 866         if (msginfo->to) {
 867                 orig_to = g_strdup(msginfo->to);
 868                 extract_address(orig_to);
 869         }
 870         if (msginfo->subject && *(msginfo->subject)) {
 871                 enc_sub = g_malloc0(strlen(msginfo->subject)*8);
 872                 qp_encode_line(enc_sub, (const guchar *)msginfo->subject);
 873                 g_strstrip(enc_sub);
 874         }
 875         if (fprintf(fp, "MIME-Version: 1.0\n"
 876                         "Content-Type: multipart/report; report-type=disposition-notification;\n"
 877                         "  boundary=\"%s\"\n"
 878                         "\n"
 879                         "--%s\n"
 880                         "Content-Type: text/plain; charset=UTF-8\n"
 881                         "Content-Transfer-Encoding: quoted-printable\n"
 882                         "\n"
 883                         "The message sent on: %s\n"
 884                         "To: %s\n"
 885                         "With subject: \"%s\"\n"
 886                         "has been displayed at %s.\n"
 887                         "\n"
 888                         "There is no guarantee that the message has been read or understood.\n"
 889                         "\n"
 890                         "--%s\n"
 891                         "Content-Type: message/disposition-notification\n"
 892                         "\n"
 893                         "Reporting-UA: %s\n"
 894                         "Original-Recipient: rfc822;%s\n"
 895                         "Final-Recipient: rfc822;%s\n"
 896                         "Original-Message-ID: <%s>\n"
 897                         "Disposition: manual-action/MDN-sent-manually; displayed\n"
 898                         "\n"
 899                         "--%s\n"
 900                         "Content-Type: application/octet-stream\n"
 901                         "Reporting-UA: %s\n"
 902                         "Original-Recipient: rfc822;%s\n"
 903                         "Final-Recipient: rfc822;%s\n"
 904                         "Original-Message-ID: <%s>\n"
 905                         "Disposition: manual-action/MDN-sent-manually; displayed\n"
 906                         "\n"
 907                         "--%s--\n",
 908                         boundary,
 909                         boundary,
 910                         msginfo->date,
 911                         orig_to?orig_to:"No To:",
 912                         enc_sub?enc_sub:"No subject",
 913                         date,
 914                         boundary,
 915                         PROG_VERSION,
 916                         orig_to?orig_to:"No To:",
 917                         account->address,
 918                         msginfo->msgid?msginfo->msgid:"NO MESSAGE ID",
 919                         boundary,
 920                         PROG_VERSION,
 921                         orig_to?orig_to:"No To:",
 922                         account->address,
 923                         msginfo->msgid?msginfo->msgid:"NO MESSAGE ID",
 924                         boundary) < 0) {
 925                 fclose(fp);
 926                 claws_unlink(tmp);
 927                 g_free(boundary);
 928                 return -1;
 929         }
 930
 931         g_free(enc_sub);
 932         g_free(orig_to);
 933         g_free(date);
 934         g_free(boundary);
 935
 936         if (fclose(fp) == EOF) {
 937                 FILE_OP_ERROR(tmp, "fclose");
 938                 claws_unlink(tmp);
 939                 return -1;
 940         }
 941
 942         /* put it in queue */
 943         queue = account_get_special_folder(account, F_QUEUE);
 944         if (!queue) queue = folder_get_default_queue();
 945         if (!queue) {
 946                 g_warning("can't find queue folder\n");
 947                 claws_unlink(tmp);
 948                 return -1;
 949         }
 950         folder_item_scan(queue);
 951         if ((num = folder_item_add_msg(queue, tmp, NULL, TRUE)) < 0) {
 952                 g_warning("can't queue the message\n");
 953                 claws_unlink(tmp);
 954                 return -1;
 955         }
 956
 957         if (prefs_common.work_offline &&
 958             !inc_offline_should_override(TRUE,
 959                 _("Claws Mail needs network access in order "
 960                   "to send this email.")))
 961                 return 0;
 962
 963         /* send it */
 964         path = folder_item_fetch_msg(queue, num);
 965         ok = procmsg_send_message_queue(path, &foo, queue, num, &queued_removed);
 966         g_free(path);
 967         g_free(foo);
 968         if (ok == 0 && !queued_removed)
 969                 folder_item_remove_msg(queue, num);
 970
 971         return ok;
 972 }
 973
 974 static gboolean find_encrypted_func(GNode *node, gpointer data)
 975 {
 976         MimeInfo *mimeinfo = (MimeInfo *) node->data;
 977         MimeInfo **encinfo = (MimeInfo **) data;
 978
 979         if (privacy_mimeinfo_is_encrypted(mimeinfo)) {
 980                 *encinfo = mimeinfo;
 981                 return TRUE;
 982         }
 983
 984         return FALSE;
 985 }
 986
 987 static MimeInfo *find_encrypted_part(MimeInfo *rootinfo)
 988 {
 989         MimeInfo *encinfo = NULL;
 990
 991         g_node_traverse(rootinfo->node, G_IN_ORDER, G_TRAVERSE_ALL, -1,
 992                 find_encrypted_func, &encinfo);
 993
 994         return encinfo;
 995 }
 996
 997 gint messageview_show(MessageView *messageview, MsgInfo *msginfo,
 998                       gboolean all_headers)
 999 {
1000         gchar *file;
1001         MimeInfo *mimeinfo, *encinfo;
1002         gchar *subject = NULL;
1003         g_return_val_if_fail(msginfo != NULL, -1);
1004
1005         if (msginfo != messageview->msginfo)
1006                 messageview->show_full_text = FALSE;
1007
1008         if (messageview->mimeview->textview &&
1009             messageview->mimeview->textview->loading) {
1010                 messageview->mimeview->textview->stop_loading = TRUE;
1011                 return 0;
1012         }
1013
1014         if (messageview->toolbar)
1015                 toolbar_set_learn_button
1016                         (messageview->toolbar,
1017                          MSG_IS_SPAM(msginfo->flags)?LEARN_HAM:LEARN_SPAM);
1018         else
1019                 toolbar_set_learn_button
1020                         (messageview->mainwin->toolbar,
1021                          MSG_IS_SPAM(msginfo->flags)?LEARN_HAM:LEARN_SPAM);
1022
1023         if (messageview->toolbar) {
1024                 if (messageview->toolbar->learn_spam_btn)
1025                         gtk_widget_set_sensitive(
1026                                 messageview->toolbar->learn_spam_btn,
1027                                 procmsg_spam_can_learn());
1028         }
1029
1030         noticeview_hide(messageview->noticeview);
1031         mimeview_clear(messageview->mimeview);
1032         messageview->updating = TRUE;
1033
1034         if (msginfo->size > 1024*1024)
1035                 statuswindow_print_all(_("Fetching message (%s)..."),
1036                         to_human_readable(msginfo->size));
1037
1038         file = procmsg_get_message_file_path(msginfo);
1039
1040         if (msginfo->size > 1024*1024)
1041                 statuswindow_pop_all();
1042
1043         if (!file) {
1044                 g_warning("can't get message file path.\n");
1045                 textview_show_error(messageview->mimeview->textview);
1046                 return -1;
1047         }
1048
1049         if (!folder_has_parent_of_type(msginfo->folder, F_QUEUE) &&
1050             !folder_has_parent_of_type(msginfo->folder, F_DRAFT))
1051                 mimeinfo = procmime_scan_file(file);
1052         else
1053                 mimeinfo = procmime_scan_queue_file(file);
1054
1055         messageview->updating = FALSE;
1056
1057         if (messageview->deferred_destroy) {
1058                 g_free(file);
1059                 messageview_destroy(messageview);
1060                 return 0;
1061         }
1062
1063         if (!mimeinfo) {
1064                 textview_show_error(messageview->mimeview->textview);
1065                 return -1;
1066         }
1067
1068         while ((encinfo = find_encrypted_part(mimeinfo)) != NULL) {
1069                 debug_print("decrypting message part\n");
1070                 if (privacy_mimeinfo_decrypt(encinfo) < 0) {
1071                         alertpanel_error(_("Couldn't decrypt: %s"),
1072                                 privacy_get_error());
1073                         break;
1074                 }
1075         }
1076
1077         if (messageview->msginfo != msginfo) {
1078                 procmsg_msginfo_free(messageview->msginfo);
1079                 messageview->msginfo = NULL;
1080                 messageview_set_menu_sensitive(messageview);
1081                 messageview->msginfo =
1082                         procmsg_msginfo_get_full_info_from_file(msginfo, file);
1083                 if (!messageview->msginfo)
1084                         messageview->msginfo = procmsg_msginfo_copy(msginfo);
1085         } else {
1086                 messageview->msginfo = NULL;
1087                 messageview_set_menu_sensitive(messageview);
1088                 messageview->msginfo = msginfo;
1089         }
1090         headerview_show(messageview->headerview, messageview->msginfo);
1091
1092         messageview_set_position(messageview, 0);
1093
1094         textview_set_all_headers(messageview->mimeview->textview,
1095                         messageview->all_headers);
1096
1097 #ifdef MAEMO
1098         maemo_window_full_screen_if_needed(GTK_WINDOW(messageview->window));
1099 #endif
1100         if (messageview->window) {
1101                 gtk_window_set_title(GTK_WINDOW(messageview->window),
1102                                 _("Claws Mail - Message View"));
1103                 GTK_EVENTS_FLUSH();
1104         }
1105         mimeview_show_message(messageview->mimeview, mimeinfo, file);
1106
1107 #ifndef MAEMO
1108         messageview_set_position(messageview, 0);
1109 #endif
1110
1111         if (messageview->window && msginfo->subject) {
1112                 subject = g_strdup(msginfo->subject);
1113                 if (!g_utf8_validate(subject, -1, NULL)) {
1114                         g_free(subject);
1115                         subject = g_malloc(strlen(msginfo->subject)*2 +1);
1116                         conv_localetodisp(subject, strlen(msginfo->subject)*2 +1,
1117                                 msginfo->subject);
1118                 }
1119                 if (g_utf8_validate(subject, -1, NULL))
1120                         gtk_window_set_title(GTK_WINDOW(messageview->window),
1121                                 subject);
1122                 g_free(subject);
1123         }
1124
1125         if (msginfo && msginfo->folder) {
1126                 msginfo->folder->last_seen = msginfo->msgnum;
1127         }
1128
1129         main_create_mailing_list_menu(messageview->mainwin, messageview->msginfo);
1130
1131         if (messageview->msginfo && messageview->msginfo->extradata
1132             && messageview->msginfo->extradata->partial_recv
1133             && !noticeview_is_visible(messageview->noticeview))
1134                 partial_recv_show(messageview->noticeview,
1135                                   messageview->msginfo);
1136         else if (messageview->msginfo && messageview->msginfo->extradata &&
1137             (messageview->msginfo->extradata->dispositionnotificationto ||
1138              messageview->msginfo->extradata->returnreceiptto) &&
1139             !MSG_IS_RETRCPT_SENT(messageview->msginfo->flags) &&
1140             !prefs_common.never_send_retrcpt &&
1141             !noticeview_is_visible(messageview->noticeview))
1142                 return_receipt_show(messageview->noticeview,
1143                                     messageview->msginfo);
1144
1145         mimeinfo = procmime_mimeinfo_next(mimeinfo);
1146         if (!all_headers && mimeinfo
1147                         && (mimeinfo->type != MIMETYPE_TEXT ||
1148             strcasecmp(mimeinfo->subtype, "plain"))
1149                         && (mimeinfo->type != MIMETYPE_MULTIPART ||
1150             strcasecmp(mimeinfo->subtype, "signed"))) {
1151                 if (strcasecmp(mimeinfo->subtype, "html")) {
1152                         mimeview_show_part(messageview->mimeview,mimeinfo);
1153                         goto done;
1154                 } else if (prefs_common.invoke_plugin_on_html) {
1155                         mimeview_select_mimepart_icon(messageview->mimeview, mimeinfo);
1156                         goto done;
1157                 }
1158         }
1159         if (!all_headers && mimeinfo &&
1160             mimeinfo->type == MIMETYPE_MULTIPART &&
1161             mimeview_has_viewer_for_content_type(messageview->mimeview, "text/calendar")) {
1162                 /* look for a calendar part or it looks really strange */
1163                 while (mimeinfo) {
1164                         if (mimeinfo->type == MIMETYPE_TEXT &&
1165                             !strcasecmp(mimeinfo->subtype, "calendar")) {
1166                                 mimeview_select_mimepart_icon(messageview->mimeview, mimeinfo);
1167                                 goto done;
1168                         }
1169                         mimeinfo = procmime_mimeinfo_next(mimeinfo);
1170                 }
1171         }
1172 done:
1173         g_free(file);
1174
1175         return 0;
1176 }
1177
1178 void messageview_reflect_prefs_pixmap_theme(void)
1179 {
1180         GList *cur;
1181         MessageView *msgview;
1182
1183         for (cur = msgview_list; cur != NULL; cur = cur->next) {
1184                 msgview = (MessageView*)cur->data;
1185                 toolbar_update(TOOLBAR_MSGVIEW, msgview);
1186                 mimeview_update(msgview->mimeview);
1187         }
1188 }
1189
1190 void messageview_clear(MessageView *messageview)
1191 {
1192         if (!messageview)
1193                 return;
1194         procmsg_msginfo_free(messageview->msginfo);
1195         messageview->msginfo = NULL;
1196         messageview->filtered = FALSE;
1197         mimeview_clear(messageview->mimeview);
1198         headerview_clear(messageview->headerview);
1199         noticeview_hide(messageview->noticeview);
1200 }
1201
1202 void messageview_destroy(MessageView *messageview)
1203 {
1204         debug_print("destroy messageview\n");
1205         messageview_list = g_list_remove(messageview_list, messageview);
1206
1207         if (messageview->mainwin->summaryview->messageview == messageview) {
1208                 messageview->mainwin->summaryview->displayed = NULL;
1209                 messageview->mainwin->summaryview->messageview = NULL;
1210         }
1211         if (messageview->mainwin->summaryview->ext_messageview == messageview) {
1212                 messageview->mainwin->summaryview->displayed = NULL;
1213                 messageview->mainwin->summaryview->ext_messageview = NULL;
1214         }
1215         if (!messageview->deferred_destroy) {
1216                 hooks_unregister_hook(MSGINFO_UPDATE_HOOKLIST,
1217                               messageview->msginfo_update_callback_id);
1218         }
1219
1220         if (messageview->updating) {
1221                 debug_print("uh oh, better not touch that now (fetching)\n");
1222                 messageview->deferred_destroy = TRUE;
1223                 gtk_widget_hide(messageview->window);
1224                 return;
1225         }
1226
1227         if (messageview->mimeview->textview
1228         &&  messageview->mimeview->textview->loading) {
1229                 debug_print("uh oh, better not touch that now (loading text)\n");
1230                 messageview->deferred_destroy = TRUE;
1231                 messageview->mimeview->textview->stop_loading = TRUE;
1232                 gtk_widget_hide(messageview->window);
1233                 return;
1234         }
1235
1236         headerview_destroy(messageview->headerview);
1237         mimeview_destroy(messageview->mimeview);
1238         noticeview_destroy(messageview->noticeview);
1239
1240         procmsg_msginfo_free(messageview->msginfo);
1241         toolbar_clear_list(TOOLBAR_MSGVIEW);
1242         if (messageview->toolbar) {
1243                 toolbar_destroy(messageview->toolbar);
1244                 g_free(messageview->toolbar);
1245         }
1246
1247         msgview_list = g_list_remove(msgview_list, messageview);
1248
1249         if (messageview->window)
1250                 gtk_widget_destroy(messageview->window);
1251         g_free(messageview);
1252 }
1253
1254 void messageview_delete(MessageView *msgview)
1255 {
1256         MsgInfo *msginfo = NULL;
1257         FolderItem *trash = NULL;
1258         PrefsAccount *ac = NULL;
1259
1260         if (msgview->msginfo && msgview->mainwin && msgview->mainwin->summaryview)
1261                 msginfo = summary_get_selected_msg(msgview->mainwin->summaryview);
1262
1263         /* need a procmsg_msginfo_equal() */
1264         if (msginfo && msgview->msginfo &&
1265             msginfo->msgnum == msgview->msginfo->msgnum &&
1266             msginfo->folder == msgview->msginfo->folder) {
1267                 summary_delete_trash(msgview->mainwin->summaryview);
1268         } else {
1269                 msginfo = msgview->msginfo;
1270
1271                 g_return_if_fail(msginfo != NULL);
1272
1273                 /* to get the trash folder, we have to choose either
1274                  * the folder's or account's trash default - we prefer
1275                  * the one in the account prefs */
1276                 if (msginfo->folder) {
1277                         if (NULL != (ac = account_find_from_item(msginfo->folder)))
1278                                 trash = account_get_special_folder(ac, F_TRASH);
1279                         if (!trash && msginfo->folder->folder)
1280                                 trash = msginfo->folder->folder->trash;
1281                         /* if still not found, use the default */
1282                         if (!trash)
1283                                 trash = folder_get_default_trash();
1284                 }
1285
1286                 g_return_if_fail(trash != NULL);
1287
1288                 if (prefs_common.immediate_exec)
1289                         /* TODO: Delete from trash */
1290                         folder_item_move_msg(trash, msginfo);
1291                 else {
1292                         procmsg_msginfo_set_to_folder(msginfo, trash);
1293                         procmsg_msginfo_set_flags(msginfo, MSG_DELETED, 0);
1294                         /* NOTE: does not update to next message in summaryview */
1295                 }
1296         }
1297 #ifdef MAEMO
1298         if (msgview->window && !prefs_common.always_show_msg) {
1299                 messageview_destroy(msgview);
1300         }
1301 #endif
1302 }
1303
1304 /*
1305  * \brief update messageview with currently selected message in summaryview
1306  *        leave unchanged if summaryview is empty
1307  * \param pointer to MessageView
1308  */
1309 static void messageview_update(MessageView *msgview, MsgInfo *old_msginfo)
1310 {
1311         SummaryView *summaryview = (SummaryView*)msgview->mainwin->summaryview;
1312
1313         g_return_if_fail(summaryview != NULL);
1314
1315         if (summaryview->selected) {
1316                 MsgInfo *msginfo = summary_get_selected_msg(summaryview);
1317                 if (msginfo == NULL || msginfo == old_msginfo)
1318                         return;
1319
1320                 messageview_show(msgview, msginfo,
1321                                  msgview->all_headers);
1322         }
1323 }
1324
1325 TextView *messageview_get_current_textview(MessageView *messageview)
1326 {
1327         TextView *text = NULL;
1328
1329         text = messageview->mimeview->textview;
1330
1331         return text;
1332 }
1333
1334 MimeInfo *messageview_get_selected_mime_part(MessageView *messageview)
1335 {
1336         return mimeview_get_selected_part(messageview->mimeview);
1337 }
1338
1339 void messageview_copy_clipboard(MessageView *messageview)
1340 {
1341         gchar *text = messageview_get_selection(messageview);
1342         if (text) {
1343                 gtk_clipboard_set_text(
1344                         gtk_clipboard_get(GDK_SELECTION_CLIPBOARD),
1345                         text, -1);
1346         }
1347         g_free(text);
1348 }
1349
1350 void messageview_select_all(MessageView *messageview)
1351 {
1352         TextView *text;
1353
1354         text = messageview_get_current_textview(messageview);
1355         if (text) {
1356                 GtkTextView *textview = GTK_TEXT_VIEW(text->text);
1357                 GtkTextBuffer *buffer;
1358                 GtkTextIter start, end;
1359
1360                 buffer = gtk_text_view_get_buffer(textview);
1361                 gtk_text_buffer_get_bounds(buffer, &start, &end);
1362                 gtk_text_buffer_select_range(buffer, &start, &end);
1363         }
1364 }
1365
1366 void messageview_set_position(MessageView *messageview, gint pos)
1367 {
1368         TextView *text;
1369
1370         text = messageview_get_current_textview(messageview);
1371         if (text)
1372                 textview_set_position(text, pos);
1373 }
1374
1375 gboolean messageview_search_string(MessageView *messageview, const gchar *str,
1376                                    gboolean case_sens)
1377 {
1378         TextView *text;
1379
1380         if (messageview->mimeview->type == MIMEVIEW_VIEWER) {
1381                 MimeViewer *viewer = messageview->mimeview->mimeviewer;
1382                 if (viewer && viewer->text_search) {
1383                         return viewer->text_search(viewer, FALSE, str, case_sens);
1384                 }
1385         }
1386
1387         text = messageview_get_current_textview(messageview);
1388         if (text)
1389                 return textview_search_string(text, str, case_sens);
1390         return FALSE;
1391 }
1392
1393 gboolean messageview_search_string_backward(MessageView *messageview,
1394                                             const gchar *str,
1395                                             gboolean case_sens)
1396 {
1397         TextView *text;
1398
1399         if (messageview->mimeview->type == MIMEVIEW_VIEWER) {
1400                 MimeViewer *viewer = messageview->mimeview->mimeviewer;
1401                 if (viewer && viewer->text_search) {
1402                         return viewer->text_search(viewer, TRUE, str, case_sens);
1403                 }
1404         }
1405
1406         text = messageview_get_current_textview(messageview);
1407         if (text)
1408                 return textview_search_string_backward(text,
1409                                                        str, case_sens);
1410         return FALSE;
1411 }
1412
1413 gboolean messageview_is_visible(MessageView *messageview)
1414 {
1415         if (messageview == NULL)
1416                 return FALSE;
1417         return messageview->visible;
1418 }
1419
1420 static void messageview_save_as(MessageView *messageview)
1421 {
1422         gchar *filename = NULL;
1423         MsgInfo *msginfo;
1424         gchar *src, *dest, *tmp;
1425
1426         if (!messageview->msginfo) return;
1427         msginfo = messageview->msginfo;
1428
1429         if (msginfo->subject) {
1430                 Xstrdup_a(filename, msginfo->subject, return);
1431                 subst_for_filename(filename);
1432         }
1433         if (filename && !g_utf8_validate(filename, -1, NULL)) {
1434                 gchar *oldstr = filename;
1435                 filename = conv_codeset_strdup(filename,
1436                                                conv_get_locale_charset_str(),
1437                                                CS_UTF_8);
1438                 if (!filename) {
1439                         g_warning("messageview_save_as(): failed to convert character set.");
1440                         filename = g_strdup(oldstr);
1441                 }
1442                 dest = filesel_select_file_save(_("Save as"), filename);
1443                 g_free(filename);
1444         } else
1445                 dest = filesel_select_file_save(_("Save as"), filename);
1446         if (!dest) return;
1447         if (is_file_exist(dest)) {
1448                 AlertValue aval;
1449
1450                 aval = alertpanel(_("Overwrite"),
1451                                   _("Overwrite existing file?"),
1452                                   GTK_STOCK_CANCEL, GTK_STOCK_OK, NULL);
1453                 if (G_ALERTALTERNATE != aval) return;
1454         }
1455
1456         src = procmsg_get_message_file(msginfo);
1457         if (copy_file(src, dest, TRUE) < 0) {
1458                 tmp =  g_path_get_basename(dest);
1459                 alertpanel_error(_("Couldn't save the file '%s'."), tmp);
1460                 g_free(tmp);
1461         }
1462         g_free(dest);
1463         g_free(src);
1464 }
1465
1466 static gint messageview_delete_cb(GtkWidget *widget, GdkEventAny *event,
1467                                   MessageView *messageview)
1468 {
1469         messageview_destroy(messageview);
1470         return TRUE;
1471 }
1472
1473 static void messageview_size_allocate_cb(GtkWidget *widget,
1474                                          GtkAllocation *allocation)
1475 {
1476         g_return_if_fail(allocation != NULL);
1477
1478         prefs_common.msgwin_width  = allocation->width;
1479         prefs_common.msgwin_height = allocation->height;
1480 }
1481 #ifndef MAEMO
1482 static gboolean key_pressed(GtkWidget *widget, GdkEventKey *event,
1483                         MessageView *messageview)
1484 {
1485         if (event && event->keyval == GDK_Escape && messageview->window) {
1486                 messageview_destroy(messageview);
1487                 return TRUE;
1488         }
1489
1490         if ((event->state & (GDK_MOD1_MASK|GDK_CONTROL_MASK|GDK_SHIFT_MASK)) != 0)
1491                 return FALSE;
1492
1493         g_signal_stop_emission_by_name(G_OBJECT(widget),
1494                                         "key_press_event");
1495         mimeview_pass_key_press_event(messageview->mimeview, event);
1496         return FALSE;
1497 }
1498 #endif
1499
1500 static void messageview_show_partial_display_cb(NoticeView *noticeview, MessageView *messageview)
1501 {
1502         messageview->show_full_text = TRUE;
1503         main_window_cursor_wait(mainwindow_get_mainwindow());
1504         GTK_EVENTS_FLUSH();
1505         messageview_show(messageview, messageview->msginfo, messageview->all_headers);
1506         main_window_cursor_normal(mainwindow_get_mainwindow());
1507 }
1508
1509 void messageview_show_partial_display(MessageView *messageview, MsgInfo *msginfo,
1510                                              size_t length)
1511 {
1512         gchar *msg = g_strdup_printf(_("Show all %s."), to_human_readable(length));
1513         noticeview_set_icon(messageview->noticeview, STOCK_PIXMAP_NOTICE_WARN);
1514         noticeview_set_text(messageview->noticeview, _("Only the first megabyte of text is shown."));
1515         noticeview_set_button_text(messageview->noticeview, msg);
1516         g_free(msg);
1517         noticeview_set_button_press_callback(messageview->noticeview,
1518                                              G_CALLBACK(messageview_show_partial_display_cb),
1519                                              (gpointer) messageview);
1520         noticeview_show(messageview->noticeview);
1521 }
1522
1523 static void return_receipt_show(NoticeView *noticeview, MsgInfo *msginfo)
1524 {
1525         gchar *addr = NULL;
1526         gboolean from_me = FALSE;
1527         if (msginfo->folder
1528                 && (folder_has_parent_of_type(msginfo->folder, F_QUEUE)
1529                  || folder_has_parent_of_type(msginfo->folder, F_DRAFT)))
1530                 return;
1531
1532         addr = g_strdup(msginfo->from);
1533         if (addr) {
1534                 extract_address(addr);
1535                 if (account_find_from_address(addr, FALSE)) {
1536                         from_me = TRUE;
1537                 }
1538                 g_free(addr);
1539         }
1540
1541         if (from_me) {
1542                 noticeview_set_icon(noticeview, STOCK_PIXMAP_NOTICE_WARN);
1543                 if (MSG_IS_RETRCPT_GOT(msginfo->flags)) {
1544                         noticeview_set_text(noticeview, _("You got a return receipt in this message : "
1545                                                           "it has been displayed by the recipient."));
1546                 } else {
1547                         noticeview_set_text(noticeview, _("You asked for a return receipt in this message."));
1548                 }
1549                 noticeview_set_button_text(noticeview, NULL);
1550                 noticeview_set_button_press_callback(noticeview, NULL, NULL);
1551         } else {
1552                 noticeview_set_icon(noticeview, STOCK_PIXMAP_NOTICE_WARN);
1553                 noticeview_set_text(noticeview, _("This message asks for a return receipt."));
1554                 noticeview_set_button_text(noticeview, _("Send receipt"));
1555                 noticeview_set_button_press_callback(noticeview,
1556                                                      G_CALLBACK(return_receipt_send_clicked),
1557                                                      (gpointer) msginfo);
1558         }
1559         noticeview_show(noticeview);
1560 }
1561
1562 static void return_receipt_send_clicked(NoticeView *noticeview, MsgInfo *msginfo)
1563 {
1564         MsgInfo *tmpmsginfo;
1565         gchar *file;
1566
1567         file = procmsg_get_message_file_path(msginfo);
1568         if (!file) {
1569                 g_warning("can't get message file path.\n");
1570                 return;
1571         }
1572
1573         tmpmsginfo = procheader_parse_file(file, msginfo->flags, TRUE, TRUE);
1574         tmpmsginfo->folder = msginfo->folder;
1575         tmpmsginfo->msgnum = msginfo->msgnum;
1576
1577         if (disposition_notification_send(tmpmsginfo) >= 0) {
1578                 procmsg_msginfo_set_flags(msginfo, MSG_RETRCPT_SENT, 0);
1579                 noticeview_hide(noticeview);
1580         }
1581
1582         procmsg_msginfo_free(tmpmsginfo);
1583         g_free(file);
1584 }
1585
1586 static void partial_recv_show(NoticeView *noticeview, MsgInfo *msginfo)
1587 {
1588         gchar *text = NULL;
1589         gchar *button1 = NULL;
1590         gchar *button2 = NULL;
1591         void  *button1_cb = NULL;
1592         void  *button2_cb = NULL;
1593
1594         if (!msginfo->extradata)
1595                 return;
1596         if (!partial_msg_in_uidl_list(msginfo)) {
1597                 text = g_strdup_printf(_("This message has been partially "
1598                                 "retrieved,\nand has been deleted from the "
1599                                 "server."));
1600         } else {
1601                 switch (msginfo->planned_download) {
1602                 case POP3_PARTIAL_DLOAD_UNKN:
1603                         text = g_strdup_printf(_("This message has been "
1604                                         "partially retrieved;\nit is %s."),
1605                                         to_human_readable(
1606                                                 (off_t)(msginfo->total_size)));
1607                         button1 = _("Mark for download");
1608                         button2 = _("Mark for deletion");
1609                         button1_cb = partial_recv_dload_clicked;
1610                         button2_cb = partial_recv_del_clicked;
1611                         break;
1612                 case POP3_PARTIAL_DLOAD_DLOAD:
1613                         text = g_strdup_printf(_("This message has been "
1614                                         "partially retrieved;\nit is %s and "
1615                                         "will be downloaded."),
1616                                         to_human_readable(
1617                                                 (off_t)(msginfo->total_size)));
1618                         button1 = _("Unmark");
1619                         button1_cb = partial_recv_unmark_clicked;
1620                         button2 = _("Mark for deletion");
1621                         button2_cb = partial_recv_del_clicked;
1622                         break;
1623                 case POP3_PARTIAL_DLOAD_DELE:
1624                         text = g_strdup_printf(_("This message has been "
1625                                         "partially retrieved;\nit is %s and "
1626                                         "will be deleted."),
1627                                         to_human_readable(
1628                                                 (off_t)(msginfo->total_size)));
1629                         button1 = _("Mark for download");
1630                         button1_cb = partial_recv_dload_clicked;
1631                         button2 = _("Unmark");
1632                         button2_cb = partial_recv_unmark_clicked;
1633                         break;
1634                 default:
1635                         return;
1636                 }
1637         }
1638
1639         noticeview_set_icon(noticeview, STOCK_PIXMAP_NOTICE_WARN);
1640         noticeview_set_text(noticeview, text);
1641         g_free(text);
1642         noticeview_set_button_text(noticeview, button1);
1643         noticeview_set_button_press_callback(noticeview,
1644                      G_CALLBACK(button1_cb), (gpointer) msginfo);
1645
1646         noticeview_set_2ndbutton_text(noticeview, button2);
1647         noticeview_set_2ndbutton_press_callback(noticeview,
1648                      G_CALLBACK(button2_cb), (gpointer) msginfo);
1649
1650         noticeview_show(noticeview);
1651 }
1652
1653 static void partial_recv_dload_clicked(NoticeView *noticeview,
1654                                        MsgInfo *msginfo)
1655 {
1656         if (partial_mark_for_download(msginfo) == 0) {
1657                 partial_recv_show(noticeview, msginfo);
1658         }
1659 }
1660
1661 static void partial_recv_del_clicked(NoticeView *noticeview,
1662                                        MsgInfo *msginfo)
1663 {
1664         if (partial_mark_for_delete(msginfo) == 0) {
1665                 partial_recv_show(noticeview, msginfo);
1666         }
1667 }
1668
1669 static void partial_recv_unmark_clicked(NoticeView *noticeview,
1670                                        MsgInfo *msginfo)
1671 {
1672         if (partial_unmark(msginfo) == 0) {
1673                 partial_recv_show(noticeview, msginfo);
1674         }
1675 }
1676
1677 static void select_account_cb(GtkWidget *w, gpointer data)
1678 {
1679         *(gint*)data = combobox_get_active_data(GTK_COMBO_BOX(w));
1680 }
1681
1682 static PrefsAccount *select_account_from_list(GList *ac_list)
1683 {
1684         GtkWidget *optmenu;
1685         gint account_id;
1686
1687         g_return_val_if_fail(ac_list != NULL, NULL);
1688         g_return_val_if_fail(ac_list->data != NULL, NULL);
1689
1690         optmenu = gtkut_account_menu_new(ac_list,
1691                         G_CALLBACK(select_account_cb),
1692                         &account_id);
1693         if (!optmenu)
1694                 return NULL;
1695         account_id = ((PrefsAccount *) ac_list->data)->account_id;
1696         if (alertpanel_with_widget(
1697                                 _("Return Receipt Notification"),
1698                                 _("The message was sent to several of your "
1699                                   "accounts.\n"
1700                                   "Please choose which account do you want to "
1701                                   "use for sending the receipt notification:"),
1702                                 _("_Cancel"), _("_Send Notification"), NULL,
1703                                 FALSE, G_ALERTDEFAULT, optmenu) != G_ALERTALTERNATE)
1704                 return NULL;
1705         return account_find_from_id(account_id);
1706 }
1707
1708 /*
1709  * \brief return selected messageview text, when nothing is
1710  *        selected and message was filtered, return complete text
1711  *
1712  * \param  pointer to Messageview
1713  *
1714  * \return pointer to text (needs to be free'd by calling func)
1715  */
1716 gchar *messageview_get_selection(MessageView *msgview)
1717 {
1718         TextView *textview;
1719         gchar *text = NULL;
1720         GtkTextView *edit = NULL;
1721         GtkTextBuffer *textbuf;
1722         gint body_pos = 0;
1723
1724         g_return_val_if_fail(msgview != NULL, NULL);
1725
1726         if (msgview->mimeview->type == MIMEVIEW_VIEWER) {
1727                 MimeViewer *viewer = msgview->mimeview->mimeviewer;
1728                 if (viewer && viewer->get_selection) {
1729                         text = viewer->get_selection(viewer);
1730                         if (text)
1731                                 return text;
1732                 }
1733         }
1734
1735         textview = messageview_get_current_textview(msgview);
1736         g_return_val_if_fail(textview != NULL, NULL);
1737
1738         edit = GTK_TEXT_VIEW(textview->text);
1739         g_return_val_if_fail(edit != NULL, NULL);
1740         body_pos = textview->body_pos;
1741
1742         textbuf = gtk_text_view_get_buffer(edit);
1743
1744         if (gtk_text_buffer_get_selection_bounds(textbuf, NULL, NULL))
1745                 return gtkut_text_view_get_selection(edit);
1746         else if (msgview->filtered) {
1747                 GtkTextIter start_iter, end_iter;
1748                 gtk_text_buffer_get_iter_at_offset(textbuf, &start_iter, body_pos);
1749                 gtk_text_buffer_get_end_iter(textbuf, &end_iter);
1750                 gtk_text_buffer_get_text(textbuf, &start_iter, &end_iter, FALSE);
1751         } else
1752                 text = NULL;
1753
1754         return text;
1755 }
1756
1757 static void save_as_cb(gpointer data, guint action, GtkWidget *widget)
1758 {
1759         MessageView *messageview = (MessageView *)data;
1760         messageview_save_as(messageview);
1761 }
1762
1763 #if defined(USE_GNOMEPRINT) || GTK_CHECK_VERSION(2,10,0)
1764 static void print_mimeview(MimeView *mimeview, gint sel_start, gint sel_end, gint partnum)
1765 {
1766 #if !defined(USE_GNOMEPRINT) && GTK_CHECK_VERSION(2,10,0)
1767         MainWindow *mainwin;
1768 #endif
1769         if (!mimeview
1770         ||  !mimeview->textview
1771         ||  !mimeview->textview->text)
1772                 alertpanel_warning(_("Cannot print: the message doesn't "
1773                                      "contain text."));
1774         else {
1775                 gtk_widget_realize(mimeview->textview->text);
1776                 if (partnum > 0) {
1777                         mimeview_select_part_num(mimeview, partnum);
1778                 }
1779                 if (mimeview->type == MIMEVIEW_VIEWER) {
1780                         MimeViewer *viewer = mimeview->mimeviewer;
1781                         if (viewer && viewer->print) {
1782                                 viewer->print(viewer);
1783                                 return;
1784                         }
1785                 }
1786                 if (sel_start != -1 && sel_end != -1) {
1787                         GtkTextIter start, end;
1788                         GtkTextView *text = GTK_TEXT_VIEW(mimeview->textview->text);
1789                         GtkTextBuffer *buffer = gtk_text_view_get_buffer(text);
1790
1791                         gtk_text_buffer_get_iter_at_offset(buffer, &start, sel_start);
1792                         gtk_text_buffer_get_iter_at_offset(buffer, &end, sel_end);
1793                         gtk_text_buffer_select_range(buffer, &start, &end);
1794                 }
1795 #if defined(USE_GNOMEPRINT)
1796                 gedit_print(GTK_TEXT_VIEW(mimeview->textview->text));
1797 #else
1798                 /* TODO: Get the real parent window, not the main window */
1799                 mainwin = mainwindow_get_mainwindow();
1800                 printing_print(GTK_TEXT_VIEW(mimeview->textview->text),
1801                                mainwin ? GTK_WINDOW(mainwin->window) : NULL,
1802                                 sel_start, sel_end);
1803 #endif
1804         }
1805 }
1806
1807 void messageview_print(MsgInfo *msginfo, gboolean all_headers,
1808                         gint sel_start, gint sel_end, gint partnum)
1809 {
1810         PangoFontDescription *font_desc = NULL;
1811         MessageView *tmpview = messageview_create_with_new_window_visible(
1812                                 mainwindow_get_mainwindow(), FALSE);
1813
1814         if (prefs_common.use_different_print_font) {
1815                 font_desc = pango_font_description_from_string
1816                                                 (prefs_common.printfont);
1817         } else {
1818                 font_desc = pango_font_description_from_string
1819                                                 (prefs_common.textfont);
1820         }
1821         if (font_desc) {
1822                 gtk_widget_modify_font(tmpview->mimeview->textview->text,
1823                         font_desc);
1824                 pango_font_description_free(font_desc);
1825         }
1826
1827         tmpview->all_headers = all_headers;
1828         if (msginfo && messageview_show(tmpview, msginfo,
1829                 tmpview->all_headers) >= 0) {
1830                         print_mimeview(tmpview->mimeview,
1831                                 sel_start, sel_end, partnum);
1832         }
1833         messageview_destroy(tmpview);
1834 }
1835 #endif
1836
1837 #if GTK_CHECK_VERSION(2,10,0) && !defined(USE_GNOMEPRINT)
1838 static void page_setup_cb(gpointer data, guint action, GtkWidget *widget)
1839 {
1840         MessageView *messageview = (MessageView *)data;
1841         printing_page_setup(messageview ?
1842                             GTK_WINDOW(messageview->window) : NULL);
1843 }
1844 #endif
1845
1846 static void print_cb(gpointer data, guint action, GtkWidget *widget)
1847 {
1848         MessageView *messageview = (MessageView *)data;
1849 #if !defined(USE_GNOMEPRINT) && !GTK_CHECK_VERSION(2,10,0)
1850         gchar *cmdline = NULL;
1851         gchar *p;
1852 #else
1853         gint sel_start = -1, sel_end = -1, partnum = 0;
1854 #endif
1855
1856         if (!messageview->msginfo) return;
1857
1858 #if !defined(USE_GNOMEPRINT) && !GTK_CHECK_VERSION(2,10,0)
1859         cmdline = input_dialog(_("Print"),
1860                                _("Enter the print command line:\n"
1861                                  "('%s' will be replaced with file name)"),
1862                                prefs_common.print_cmd);
1863         if (!cmdline) return;
1864         if (!(p = strchr(cmdline, '%')) || *(p + 1) != 's' ||
1865             strchr(p + 2, '%')) {
1866                 alertpanel_error(_("Print command line is invalid:\n'%s'"),
1867                                  cmdline);
1868                 g_free(cmdline);
1869                 return;
1870         }
1871         procmsg_print_message(messageview->msginfo, cmdline);
1872         g_free(cmdline);
1873 #else
1874         partnum = mimeview_get_selected_part_num(messageview->mimeview);
1875         textview_get_selection_offsets(messageview->mimeview->textview,
1876                 &sel_start, &sel_end);
1877         messageview_print(messageview->msginfo, messageview->all_headers,
1878                 sel_start, sel_end, partnum);
1879 #endif
1880 }
1881
1882 static void close_cb(gpointer data, guint action, GtkWidget *widget)
1883 {
1884         MessageView *messageview = (MessageView *)data;
1885         messageview_destroy(messageview);
1886 }
1887
1888 static void copy_cb(gpointer data, guint action, GtkWidget *widget)
1889 {
1890         MessageView *messageview = (MessageView *)data;
1891         messageview_copy_clipboard(messageview);
1892 }
1893
1894 static void allsel_cb(gpointer data, guint action, GtkWidget *widget)
1895 {
1896         MessageView *messageview = (MessageView *)data;
1897         messageview_select_all(messageview);
1898 }
1899
1900 static void search_cb(gpointer data, guint action, GtkWidget *widget)
1901 {
1902         MessageView *messageview = (MessageView *)data;
1903         message_search(messageview);
1904 }
1905
1906 static void prev_cb(gpointer data, guint action, GtkWidget *widget)
1907 {
1908         MessageView *messageview = (MessageView *)data;
1909         messageview->updating = TRUE;
1910         summary_step(messageview->mainwin->summaryview, GTK_SCROLL_STEP_BACKWARD);
1911         messageview->updating = FALSE;
1912
1913         if (messageview->deferred_destroy) {
1914                 debug_print("messageview got away!\n");
1915                 messageview_destroy(messageview);
1916                 return;
1917         }
1918         if (messageview->mainwin->summaryview->selected) {
1919 #ifndef MAEMO
1920                 MsgInfo * msginfo = summary_get_selected_msg(messageview->mainwin->summaryview);
1921
1922                 if (msginfo)
1923                         messageview_show(messageview, msginfo,
1924                                          messageview->all_headers);
1925 #endif
1926         } else {
1927                 gtk_widget_destroy(messageview->window);
1928         }
1929 }
1930
1931 static void next_cb(gpointer data, guint action, GtkWidget *widget)
1932 {
1933         MessageView *messageview = (MessageView *)data;
1934         messageview->updating = TRUE;
1935         summary_step(messageview->mainwin->summaryview, GTK_SCROLL_STEP_FORWARD);
1936         messageview->updating = FALSE;
1937
1938         if (messageview->deferred_destroy) {
1939                 debug_print("messageview got away!\n");
1940                 messageview_destroy(messageview);
1941                 return;
1942         }
1943         if (messageview->mainwin->summaryview->selected) {
1944 #ifndef MAEMO
1945                 MsgInfo * msginfo = summary_get_selected_msg(messageview->mainwin->summaryview);
1946
1947                 if (msginfo)
1948                         messageview_show(messageview, msginfo,
1949                                          messageview->all_headers);
1950 #endif
1951         } else {
1952                 gtk_widget_destroy(messageview->window);
1953         }
1954 }
1955
1956 static void prev_unread_cb(gpointer data, guint action, GtkWidget *widget)
1957 {
1958         MessageView *messageview = (MessageView *)data;
1959         messageview->updating = TRUE;
1960         summary_select_prev_unread(messageview->mainwin->summaryview);
1961         messageview->updating = FALSE;
1962
1963         if (messageview->deferred_destroy) {
1964                 debug_print("messageview got away!\n");
1965                 messageview_destroy(messageview);
1966                 return;
1967         }
1968         if (messageview->mainwin->summaryview->selected) {
1969 #ifndef MAEMO
1970                 MsgInfo * msginfo = summary_get_selected_msg(messageview->mainwin->summaryview);
1971
1972                 if (msginfo)
1973                         messageview_show(messageview, msginfo,
1974                                          messageview->all_headers);
1975 #endif
1976         } else {
1977                 gtk_widget_destroy(messageview->window);
1978         }
1979 }
1980
1981 static void next_unread_cb(gpointer data, guint action, GtkWidget *widget)
1982 {
1983         MessageView *messageview = (MessageView *)data;
1984         messageview->updating = TRUE;
1985         summary_select_next_unread(messageview->mainwin->summaryview);
1986         messageview->updating = FALSE;
1987
1988         if (messageview->deferred_destroy) {
1989                 debug_print("messageview got away!\n");
1990                 messageview_destroy(messageview);
1991                 return;
1992         }
1993         if (messageview->mainwin->summaryview->selected) {
1994 #ifndef MAEMO
1995                 MsgInfo * msginfo = summary_get_selected_msg(messageview->mainwin->summaryview);
1996
1997                 if (msginfo)
1998                         messageview_show(messageview, msginfo,
1999                                          messageview->all_headers);
2000 #endif
2001         } else {
2002                 gtk_widget_destroy(messageview->window);
2003         }
2004 }
2005
2006 static void prev_new_cb(gpointer data, guint action, GtkWidget *widget)
2007 {
2008         MessageView *messageview = (MessageView *)data;
2009         messageview->updating = TRUE;
2010         summary_select_prev_new(messageview->mainwin->summaryview);
2011         messageview->updating = FALSE;
2012
2013         if (messageview->deferred_destroy) {
2014                 debug_print("messageview got away!\n");
2015                 messageview_destroy(messageview);
2016                 return;
2017         }
2018         if (messageview->mainwin->summaryview->selected) {
2019 #ifndef MAEMO
2020                 MsgInfo * msginfo = summary_get_selected_msg(messageview->mainwin->summaryview);
2021
2022                 if (msginfo)
2023                         messageview_show(messageview, msginfo,
2024                                          messageview->all_headers);
2025 #endif
2026         } else {
2027                 gtk_widget_destroy(messageview->window);
2028         }
2029 }
2030
2031 static void next_new_cb(gpointer data, guint action, GtkWidget *widget)
2032 {
2033         MessageView *messageview = (MessageView *)data;
2034         messageview->updating = TRUE;
2035         summary_select_next_new(messageview->mainwin->summaryview);
2036         messageview->updating = FALSE;
2037
2038         if (messageview->deferred_destroy) {
2039                 debug_print("messageview got away!\n");
2040                 messageview_destroy(messageview);
2041                 return;
2042         }
2043         if (messageview->mainwin->summaryview->selected) {
2044 #ifndef MAEMO
2045                 MsgInfo * msginfo = summary_get_selected_msg(messageview->mainwin->summaryview);
2046
2047                 if (msginfo)
2048                         messageview_show(messageview, msginfo,
2049                                          messageview->all_headers);
2050 #endif
2051         } else {
2052                 gtk_widget_destroy(messageview->window);
2053         }
2054 }
2055
2056 static void prev_marked_cb(gpointer data, guint action, GtkWidget *widget)
2057 {
2058         MessageView *messageview = (MessageView *)data;
2059         messageview->updating = TRUE;
2060         summary_select_prev_marked(messageview->mainwin->summaryview);
2061         messageview->updating = FALSE;
2062
2063         if (messageview->deferred_destroy) {
2064                 debug_print("messageview got away!\n");
2065                 messageview_destroy(messageview);
2066                 return;
2067         }
2068         if (messageview->mainwin->summaryview->selected) {
2069 #ifndef MAEMO
2070                 MsgInfo * msginfo = summary_get_selected_msg(messageview->mainwin->summaryview);
2071
2072                 if (msginfo)
2073                         messageview_show(messageview, msginfo,
2074                                          messageview->all_headers);
2075 #endif
2076         } else {
2077                 gtk_widget_destroy(messageview->window);
2078         }
2079 }
2080
2081 static void next_marked_cb(gpointer data, guint action, GtkWidget *widget)
2082 {
2083         MessageView *messageview = (MessageView *)data;
2084         messageview->updating = TRUE;
2085         summary_select_next_marked(messageview->mainwin->summaryview);
2086         messageview->updating = FALSE;
2087
2088         if (messageview->deferred_destroy) {
2089                 debug_print("messageview got away!\n");
2090                 messageview_destroy(messageview);
2091                 return;
2092         }
2093         if (messageview->mainwin->summaryview->selected) {
2094 #ifndef MAEMO
2095                 MsgInfo * msginfo = summary_get_selected_msg(messageview->mainwin->summaryview);
2096
2097                 if (msginfo)
2098                         messageview_show(messageview, msginfo,
2099                                          messageview->all_headers);
2100 #endif
2101         } else {
2102                 gtk_widget_destroy(messageview->window);
2103         }
2104 }
2105
2106 static void prev_labeled_cb(gpointer data, guint action, GtkWidget *widget)
2107 {
2108         MessageView *messageview = (MessageView *)data;
2109         messageview->updating = TRUE;
2110         summary_select_prev_labeled(messageview->mainwin->summaryview);
2111         messageview->updating = FALSE;
2112
2113         if (messageview->deferred_destroy) {
2114                 debug_print("messageview got away!\n");
2115                 messageview_destroy(messageview);
2116                 return;
2117         }
2118         if (messageview->mainwin->summaryview->selected) {
2119 #ifndef MAEMO
2120                 MsgInfo * msginfo = summary_get_selected_msg(messageview->mainwin->summaryview);
2121
2122                 if (msginfo)
2123                         messageview_show(messageview, msginfo,
2124                                          messageview->all_headers);
2125 #endif
2126         } else {
2127                 gtk_widget_destroy(messageview->window);
2128         }
2129 }
2130
2131 static void next_labeled_cb(gpointer data, guint action, GtkWidget *widget)
2132 {
2133         MessageView *messageview = (MessageView *)data;
2134         messageview->updating = TRUE;
2135         summary_select_next_labeled(messageview->mainwin->summaryview);
2136         messageview->updating = FALSE;
2137
2138         if (messageview->deferred_destroy) {
2139                 debug_print("messageview got away!\n");
2140                 messageview_destroy(messageview);
2141                 return;
2142         }
2143         if (messageview->mainwin->summaryview->selected) {
2144 #ifndef MAEMO
2145                 MsgInfo * msginfo = summary_get_selected_msg(messageview->mainwin->summaryview);
2146
2147                 if (msginfo)
2148                         messageview_show(messageview, msginfo,
2149                                          messageview->all_headers);
2150 #endif
2151         } else {
2152                 gtk_widget_destroy(messageview->window);
2153         }
2154 }
2155
2156 static void last_read_cb(gpointer data, guint action, GtkWidget *widget)
2157 {
2158         MessageView *messageview = (MessageView *)data;
2159         messageview->updating = TRUE;
2160         summary_select_last_read(messageview->mainwin->summaryview);
2161         messageview->updating = FALSE;
2162
2163         if (messageview->deferred_destroy) {
2164                 debug_print("messageview got away!\n");
2165                 messageview_destroy(messageview);
2166                 return;
2167         }
2168         if (messageview->mainwin->summaryview->selected) {
2169 #ifndef MAEMO
2170                 MsgInfo * msginfo = summary_get_selected_msg(messageview->mainwin->summaryview);
2171
2172                 if (msginfo)
2173                         messageview_show(messageview, msginfo,
2174                                          messageview->all_headers);
2175 #endif
2176         } else {
2177                 gtk_widget_destroy(messageview->window);
2178         }
2179 }
2180
2181 static void parent_cb(gpointer data, guint action, GtkWidget *widget)
2182 {
2183         MessageView *messageview = (MessageView *)data;
2184         messageview->updating = TRUE;
2185         summary_select_parent(messageview->mainwin->summaryview);
2186         messageview->updating = FALSE;
2187
2188         if (messageview->deferred_destroy) {
2189                 debug_print("messageview got away!\n");
2190                 messageview_destroy(messageview);
2191                 return;
2192         }
2193         if (messageview->mainwin->summaryview->selected) {
2194 #ifndef MAEMO
2195                 MsgInfo * msginfo = summary_get_selected_msg(messageview->mainwin->summaryview);
2196
2197                 if (msginfo)
2198                         messageview_show(messageview, msginfo,
2199                                          messageview->all_headers);
2200 #endif
2201         } else {
2202                 gtk_widget_destroy(messageview->window);
2203         }
2204 }
2205
2206 static void goto_unread_folder_cb(gpointer data, guint action, GtkWidget *widget)
2207 {
2208         MessageView *messageview = (MessageView *)data;
2209         messageview->updating = TRUE;
2210         folderview_select_next_unread(messageview->mainwin->folderview, FALSE);
2211         messageview->updating = FALSE;
2212
2213         if (messageview->deferred_destroy) {
2214                 debug_print("messageview got away!\n");
2215                 messageview_destroy(messageview);
2216                 return;
2217         }
2218         if (messageview->mainwin->summaryview->selected) {
2219 #ifndef MAEMO
2220                 MsgInfo * msginfo = summary_get_selected_msg(messageview->mainwin->summaryview);
2221
2222                 if (msginfo)
2223                         messageview_show(messageview, msginfo,
2224                                          messageview->all_headers);
2225 #endif
2226         } else {
2227                 gtk_widget_destroy(messageview->window);
2228         }
2229 }
2230
2231 static void goto_folder_cb(gpointer data, guint action, GtkWidget *widget)
2232 {
2233         MessageView *messageview = (MessageView *)data;
2234         messageview->updating = TRUE;
2235         FolderItem *to_folder;
2236         messageview->updating = FALSE;
2237
2238         to_folder = foldersel_folder_sel(NULL, FOLDER_SEL_ALL, NULL, FALSE);
2239
2240         if (to_folder) {
2241                 folderview_select(messageview->mainwin->folderview, to_folder);
2242
2243                 if (messageview->deferred_destroy) {
2244                         debug_print("messageview got away!\n");
2245                         messageview_destroy(messageview);
2246                         return;
2247                 }
2248                 if (messageview->mainwin->summaryview->selected) {
2249 #ifndef MAEMO
2250                         MsgInfo * msginfo = summary_get_selected_msg(messageview->mainwin->summaryview);
2251
2252                         if (msginfo)
2253                                 messageview_show(messageview, msginfo,
2254                                                  messageview->all_headers);
2255 #endif
2256                 } else {
2257                         gtk_widget_destroy(messageview->window);
2258                 }
2259         }
2260 }
2261
2262 static void set_charset_cb(gpointer data, guint action, GtkWidget *widget)
2263 {
2264         MessageView *messageview = (MessageView *)data;
2265         const gchar *charset;
2266
2267         if (GTK_CHECK_MENU_ITEM(widget)->active) {
2268                 charset = conv_get_charset_str((CharSet)action);
2269                 g_free(messageview->forced_charset);
2270                 messageview->forced_charset = g_strdup(charset);
2271                 procmime_force_charset(charset);
2272
2273                 messageview_show(messageview, messageview->msginfo, FALSE);
2274         }
2275 }
2276
2277 static void set_decode_cb(gpointer data, guint action, GtkWidget *widget)
2278 {
2279         MessageView *messageview = (MessageView *)data;
2280         if (GTK_CHECK_MENU_ITEM(widget)->active) {
2281                 messageview->forced_encoding = (EncodingType)action;
2282
2283                 messageview_show(messageview, messageview->msginfo, FALSE);
2284
2285                 debug_print("forced encoding: %d\n", action);
2286         }
2287 }
2288
2289
2290 static void view_source_cb(gpointer data, guint action, GtkWidget *widget)
2291 {
2292         MessageView *messageview = (MessageView *)data;
2293         SourceWindow *srcwin;
2294
2295         if (!messageview->msginfo) return;
2296
2297         srcwin = source_window_create();
2298         source_window_show_msg(srcwin, messageview->msginfo);
2299         source_window_show(srcwin);
2300 }
2301
2302 static void show_all_header_cb(gpointer data, guint action, GtkWidget *widget)
2303 {
2304         MessageView *messageview = (MessageView *)data;
2305         MsgInfo *msginfo = messageview->msginfo;
2306
2307         if (messageview->mimeview->textview &&
2308             messageview->mimeview->textview->loading) {
2309                 return;
2310         }
2311         if (messageview->updating)
2312                 return;
2313
2314         messageview->all_headers =
2315                         GTK_CHECK_MENU_ITEM(widget)->active;
2316         if (!msginfo) return;
2317         messageview->msginfo = NULL;
2318         messageview_show(messageview, msginfo,
2319                          GTK_CHECK_MENU_ITEM(widget)->active);
2320         procmsg_msginfo_free(msginfo);
2321         main_window_set_menu_sensitive(messageview->mainwin);
2322 }
2323
2324 #define SET_CHECK_MENU_ACTIVE(path, active) \
2325 { \
2326         menuitem = gtk_item_factory_get_widget(ifactory, path); \
2327         gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem), active); \
2328 }
2329
2330 static void msg_hide_quotes_cb(gpointer data, guint action, GtkWidget *widget)
2331 {
2332         MessageView *messageview = (MessageView *)data;
2333         MsgInfo *msginfo = messageview->msginfo;
2334         static gboolean updating_menu = FALSE;
2335         GtkItemFactory *ifactory = gtk_item_factory_from_widget(messageview->menubar);
2336         GtkWidget *menuitem;
2337         if (updating_menu)
2338                 return;
2339
2340         prefs_common.hide_quotes =
2341                         GTK_CHECK_MENU_ITEM(widget)->active ? action : 0;
2342
2343         updating_menu=TRUE;
2344         SET_CHECK_MENU_ACTIVE("/View/Quotes/Fold all", FALSE);
2345         SET_CHECK_MENU_ACTIVE("/View/Quotes/Fold from level 2", FALSE);
2346         SET_CHECK_MENU_ACTIVE("/View/Quotes/Fold from level 3", FALSE);
2347         gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(widget), prefs_common.hide_quotes > 0);
2348         updating_menu=FALSE;
2349         if (!msginfo) return;
2350         messageview->msginfo = NULL;
2351         messageview_show(messageview, msginfo,
2352                          messageview->all_headers);
2353         procmsg_msginfo_free(msginfo);
2354
2355         /* update main window */
2356         main_window_set_menu_sensitive(messageview->mainwin);
2357         summary_redisplay_msg(messageview->mainwin->summaryview);
2358 }
2359 #undef SET_CHECK_MENU_ACTIVE
2360
2361 static void compose_cb(gpointer data, guint action, GtkWidget *widget)
2362 {
2363         MessageView *messageview = (MessageView *)data;
2364         PrefsAccount *ac = NULL;
2365         FolderItem *item = NULL;
2366
2367         if (messageview->msginfo)
2368                 item = messageview->msginfo->folder;
2369
2370         if (item) {
2371                 ac = account_find_from_item(item);
2372                 if (ac && ac->protocol == A_NNTP &&
2373                     item->stype == F_NEWS) {
2374                         compose_new(ac, item->path, NULL);
2375                         return;
2376                 }
2377         }
2378
2379         compose_new(ac, NULL, NULL);
2380 }
2381
2382 static void reply_cb(gpointer data, guint action, GtkWidget *widget)
2383 {
2384         MessageView *messageview = (MessageView *)data;
2385         GSList *msginfo_list = NULL;
2386
2387         g_return_if_fail(messageview->msginfo);
2388
2389         msginfo_list = g_slist_append(msginfo_list, messageview->msginfo);
2390         compose_reply_from_messageview(messageview, msginfo_list, action);
2391         g_slist_free(msginfo_list);
2392 }
2393
2394 static void addressbook_open_cb(gpointer data, guint action, GtkWidget *widget)
2395 {
2396         addressbook_open(NULL);
2397 }
2398
2399 static void add_address_cb(gpointer data, guint action, GtkWidget *widget)
2400 {
2401         MessageView *messageview = (MessageView *)data;
2402         MsgInfo *msginfo, *full_msginfo;
2403         gchar *from;
2404         GtkWidget *image = NULL;
2405         GdkPixbuf *picture = NULL;
2406
2407         if (!messageview->msginfo || !messageview->msginfo->from)
2408                 return;
2409
2410         msginfo = messageview->msginfo;
2411         Xstrdup_a(from, msginfo->from, return);
2412         eliminate_address_comment(from);
2413         extract_address(from);
2414
2415         full_msginfo = procmsg_msginfo_get_full_info(msginfo);
2416         if (full_msginfo &&
2417             full_msginfo->extradata &&
2418             full_msginfo->extradata->face) {
2419                 image = face_get_from_header(full_msginfo->extradata->face);
2420         }
2421 #if HAVE_LIBCOMPFACE
2422         else if (full_msginfo &&
2423                  full_msginfo->extradata &&
2424                  full_msginfo->extradata->xface) {
2425                 image = xface_get_from_header(full_msginfo->extradata->xface,
2426                                 &messageview->mainwin->summaryview->ctree->style->white,
2427                                 messageview->window->window);
2428         }
2429 #endif
2430         procmsg_msginfo_free(full_msginfo);
2431         if (image)
2432                 picture = gtk_image_get_pixbuf(GTK_IMAGE(image));
2433
2434         addressbook_add_contact(msginfo->fromname, from, NULL, picture);
2435
2436         if (image)
2437                 gtk_widget_destroy(image);
2438 }
2439
2440 static void create_filter_cb(gpointer data, guint action, GtkWidget *widget)
2441 {
2442         MessageView *messageview = (MessageView *)data;
2443         FolderItem * item;
2444
2445         if (!messageview->msginfo) return;
2446
2447         item = messageview->msginfo->folder;
2448         summary_msginfo_filter_open(item,  messageview->msginfo,
2449                                     (PrefsFilterType)action, 0);
2450 }
2451
2452 static void create_processing_cb(gpointer data, guint action,
2453                                  GtkWidget *widget)
2454 {
2455         MessageView *messageview = (MessageView *)data;
2456         FolderItem * item;
2457
2458         if (!messageview->msginfo) return;
2459
2460         item = messageview->msginfo->folder;
2461         summary_msginfo_filter_open(item,  messageview->msginfo,
2462                                     (PrefsFilterType)action, 1);
2463 }
2464
2465 static void open_urls_cb(gpointer data, guint action, GtkWidget *widget)
2466 {
2467         MessageView *messageview = (MessageView *)data;
2468         messageview_list_urls(messageview);
2469 }
2470
2471 static void about_cb(gpointer data, guint action, GtkWidget *widget)
2472 {
2473         about_show();
2474 }
2475
2476 static gboolean messageview_update_msg(gpointer source, gpointer data)
2477 {
2478         MsgInfoUpdate *msginfo_update = (MsgInfoUpdate *) source;
2479         MessageView *messageview = (MessageView *)data;
2480
2481         if (messageview->msginfo != msginfo_update->msginfo)
2482                 return FALSE;
2483
2484         if (msginfo_update->flags & MSGINFO_UPDATE_DELETED) {
2485                 MsgInfo *old_msginfo = messageview->msginfo;
2486                 messageview_clear(messageview);
2487                 messageview_update(messageview, old_msginfo);
2488         }
2489
2490         return FALSE;
2491 }
2492
2493 void messageview_set_menu_sensitive(MessageView *messageview)
2494 {
2495         GtkItemFactory *ifactory;
2496         GtkWidget *menuitem = NULL;
2497
2498         if (!messageview || !messageview->new_window)
2499                 return;
2500         /* do some smart things */
2501         if (!messageview->menubar) return;
2502         ifactory = gtk_item_factory_from_widget(messageview->menubar);
2503         if (!ifactory) return;
2504
2505         if (prefs_common.hide_quotes) {
2506                 menuitem = NULL;
2507                 if (prefs_common.hide_quotes == 1)
2508                         menuitem = gtk_item_factory_get_widget(ifactory,
2509                                         "/View/Quotes/Fold all");
2510                 if (prefs_common.hide_quotes == 2)
2511                         menuitem = gtk_item_factory_get_widget(ifactory,
2512                                         "/View/Quotes/Fold from level 2");
2513                 if (prefs_common.hide_quotes == 3)
2514                         menuitem = gtk_item_factory_get_widget(ifactory,
2515                                         "/View/Quotes/Fold from level 3");
2516                 gtk_check_menu_item_set_active
2517                         (GTK_CHECK_MENU_ITEM(menuitem),
2518                          TRUE);
2519         }
2520 }
2521
2522 void messageview_learn (MessageView *msgview, gboolean is_spam)
2523 {
2524         if (is_spam) {
2525                 if (procmsg_spam_learner_learn(msgview->msginfo, NULL, TRUE) == 0)
2526                         procmsg_msginfo_set_flags(msgview->msginfo, MSG_SPAM, 0);
2527                 else
2528                         log_error(LOG_PROTOCOL, _("An error happened while learning.\n"));
2529
2530         } else {
2531                 if (procmsg_spam_learner_learn(msgview->msginfo, NULL, FALSE) == 0)
2532                         procmsg_msginfo_unset_flags(msgview->msginfo, MSG_SPAM, 0);
2533                 else
2534                         log_error(LOG_PROTOCOL, _("An error happened while learning.\n"));
2535         }
2536         if (msgview->toolbar)
2537                 toolbar_set_learn_button
2538                         (msgview->toolbar,
2539                          MSG_IS_SPAM(msgview->msginfo->flags)?LEARN_HAM:LEARN_SPAM);
2540         else
2541                 toolbar_set_learn_button
2542                         (msgview->mainwin->toolbar,
2543                          MSG_IS_SPAM(msgview->msginfo->flags)?LEARN_HAM:LEARN_SPAM);
2544 }
2545
2546 void messageview_list_urls (MessageView *msgview)
2547 {
2548         GSList *cur = msgview->mimeview->textview->uri_list;
2549         GSList *newlist = NULL;
2550         GHashTable *uri_hashtable = g_hash_table_new(g_str_hash, g_str_equal);
2551         for (; cur; cur = cur->next) {
2552                 ClickableText *uri = (ClickableText *)cur->data;
2553                 if (uri->uri &&
2554                     (!g_ascii_strncasecmp(uri->uri, "ftp.", 4) ||
2555                      !g_ascii_strncasecmp(uri->uri, "ftp:", 4) ||
2556                      !g_ascii_strncasecmp(uri->uri, "www.", 4) ||
2557                      !g_ascii_strncasecmp(uri->uri, "http:", 5) ||
2558                      !g_ascii_strncasecmp(uri->uri, "https:", 6)))
2559                 {
2560                         if(g_hash_table_lookup(uri_hashtable, uri->uri))
2561                                 continue;
2562
2563                         newlist = g_slist_prepend(newlist, uri);
2564                         g_hash_table_insert(uri_hashtable, uri->uri,
2565                                             GUINT_TO_POINTER(g_str_hash(uri->uri)));
2566                 }
2567         }
2568         newlist = g_slist_reverse(newlist);
2569         uri_opener_open(msgview, newlist);
2570         g_slist_free(newlist);
2571         g_hash_table_destroy(uri_hashtable);
2572 }