src/compose.c

   1 /*
   2  * Claws Mail -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 1999-2015 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 #ifdef HAVE_CONFIG_H
  21 #  include "config.h"
  22 #include "claws-features.h"
  23 #endif
  24
  25 #include "defs.h"
  26
  27 #ifndef PANGO_ENABLE_ENGINE
  28 #  define PANGO_ENABLE_ENGINE
  29 #endif
  30
  31 #include <glib.h>
  32 #include <glib/gi18n.h>
  33 #include <gdk/gdkkeysyms.h>
  34 #include <gtk/gtk.h>
  35
  36 #include <pango/pango-break.h>
  37 #include <stdio.h>
  38 #include <stdlib.h>
  39 #include <string.h>
  40 #include <ctype.h>
  41 #include <sys/types.h>
  42 #include <sys/stat.h>
  43 #include <unistd.h>
  44 #include <time.h>
  45 #include <stdlib.h>
  46 #if HAVE_SYS_WAIT_H
  47 #  include <sys/wait.h>
  48 #endif
  49 #include <signal.h>
  50 #include <errno.h>
  51 #ifndef G_OS_WIN32  /* fixme we should have a configure test. */
  52 #include <libgen.h>
  53 #endif
  54
  55 #if (HAVE_WCTYPE_H && HAVE_WCHAR_H)
  56 #  include <wchar.h>
  57 #  include <wctype.h>
  58 #endif
  59
  60 #include "claws.h"
  61 #include "main.h"
  62 #include "mainwindow.h"
  63 #include "compose.h"
  64 #ifndef USE_NEW_ADDRBOOK
  65         #include "addressbook.h"
  66 #else
  67         #include "addressbook-dbus.h"
  68         #include "addressadd.h"
  69 #endif
  70 #include "folderview.h"
  71 #include "procmsg.h"
  72 #include "menu.h"
  73 #include "stock_pixmap.h"
  74 #include "send_message.h"
  75 #include "imap.h"
  76 #include "news.h"
  77 #include "customheader.h"
  78 #include "prefs_common.h"
  79 #include "prefs_account.h"
  80 #include "action.h"
  81 #include "account.h"
  82 #include "filesel.h"
  83 #include "procheader.h"
  84 #include "procmime.h"
  85 #include "statusbar.h"
  86 #include "about.h"
  87 #include "quoted-printable.h"
  88 #include "codeconv.h"
  89 #include "utils.h"
  90 #include "gtkutils.h"
  91 #include "gtkshruler.h"
  92 #include "socket.h"
  93 #include "alertpanel.h"
  94 #include "manage_window.h"
  95 #include "folder.h"
  96 #include "folder_item_prefs.h"
  97 #include "addr_compl.h"
  98 #include "quote_fmt.h"
  99 #include "undo.h"
 100 #include "foldersel.h"
 101 #include "toolbar.h"
 102 #include "inc.h"
 103 #include "message_search.h"
 104 #include "combobox.h"
 105 #include "hooks.h"
 106 #include "privacy.h"
 107 #include "timing.h"
 108 #include "autofaces.h"
 109 #include "spell_entry.h"
 110
 111 enum
 112 {
 113         COL_MIMETYPE = 0,
 114         COL_SIZE     = 1,
 115         COL_NAME     = 2,
 116         COL_CHARSET  = 3,
 117         COL_DATA     = 4,
 118         COL_AUTODATA = 5,
 119         N_COL_COLUMNS
 120 };
 121
 122 #define N_ATTACH_COLS   (N_COL_COLUMNS)
 123
 124 typedef enum
 125 {
 126         COMPOSE_CALL_ADVANCED_ACTION_MOVE_BEGINNING_OF_LINE,
 127         COMPOSE_CALL_ADVANCED_ACTION_MOVE_FORWARD_CHARACTER,
 128         COMPOSE_CALL_ADVANCED_ACTION_MOVE_BACKWARD_CHARACTER,
 129         COMPOSE_CALL_ADVANCED_ACTION_MOVE_FORWARD_WORD,
 130         COMPOSE_CALL_ADVANCED_ACTION_MOVE_BACKWARD_WORD,
 131         COMPOSE_CALL_ADVANCED_ACTION_MOVE_END_OF_LINE,
 132         COMPOSE_CALL_ADVANCED_ACTION_MOVE_NEXT_LINE,
 133         COMPOSE_CALL_ADVANCED_ACTION_MOVE_PREVIOUS_LINE,
 134         COMPOSE_CALL_ADVANCED_ACTION_DELETE_FORWARD_CHARACTER,
 135         COMPOSE_CALL_ADVANCED_ACTION_DELETE_BACKWARD_CHARACTER,
 136         COMPOSE_CALL_ADVANCED_ACTION_DELETE_FORWARD_WORD,
 137         COMPOSE_CALL_ADVANCED_ACTION_DELETE_BACKWARD_WORD,
 138         COMPOSE_CALL_ADVANCED_ACTION_DELETE_LINE,
 139         COMPOSE_CALL_ADVANCED_ACTION_DELETE_TO_LINE_END
 140 } ComposeCallAdvancedAction;
 141
 142 typedef enum
 143 {
 144         PRIORITY_HIGHEST = 1,
 145         PRIORITY_HIGH,
 146         PRIORITY_NORMAL,
 147         PRIORITY_LOW,
 148         PRIORITY_LOWEST
 149 } PriorityLevel;
 150
 151 typedef enum
 152 {
 153         COMPOSE_INSERT_SUCCESS,
 154         COMPOSE_INSERT_READ_ERROR,
 155         COMPOSE_INSERT_INVALID_CHARACTER,
 156         COMPOSE_INSERT_NO_FILE
 157 } ComposeInsertResult;
 158
 159 typedef enum
 160 {
 161         COMPOSE_WRITE_FOR_SEND,
 162         COMPOSE_WRITE_FOR_STORE
 163 } ComposeWriteType;
 164
 165 typedef enum
 166 {
 167         COMPOSE_QUOTE_FORCED,
 168         COMPOSE_QUOTE_CHECK,
 169         COMPOSE_QUOTE_SKIP
 170 } ComposeQuoteMode;
 171
 172 typedef enum {
 173     TO_FIELD_PRESENT,
 174     SUBJECT_FIELD_PRESENT,
 175     BODY_FIELD_PRESENT,
 176     NO_FIELD_PRESENT
 177 } MailField;
 178
 179 #define B64_LINE_SIZE           57
 180 #define B64_BUFFSIZE            77
 181
 182 #define MAX_REFERENCES_LEN      999
 183
 184 #define COMPOSE_DRAFT_TIMEOUT_UNSET -1
 185 #define COMPOSE_DRAFT_TIMEOUT_FORBIDDEN -2
 186
 187 static GList *compose_list = NULL;
 188 static GSList *extra_headers = NULL;
 189
 190 static Compose *compose_generic_new                     (PrefsAccount   *account,
 191                                                  const gchar    *to,
 192                                                  FolderItem     *item,
 193                                                  GList          *attach_files,
 194                                                  GList          *listAddress );
 195
 196 static Compose *compose_create                  (PrefsAccount   *account,
 197                                                  FolderItem              *item,
 198                                                  ComposeMode     mode,
 199                                                  gboolean batch);
 200
 201 static void compose_entry_mark_default_to       (Compose          *compose,
 202                                          const gchar      *address);
 203 static Compose *compose_followup_and_reply_to   (MsgInfo        *msginfo,
 204                                          ComposeQuoteMode        quote_mode,
 205                                          gboolean        to_all,
 206                                          gboolean        to_sender,
 207                                          const gchar    *body);
 208 static Compose *compose_forward_multiple        (PrefsAccount   *account,
 209                                          GSList         *msginfo_list);
 210 static Compose *compose_reply                   (MsgInfo        *msginfo,
 211                                          ComposeQuoteMode        quote_mode,
 212                                          gboolean        to_all,
 213                                          gboolean        to_ml,
 214                                          gboolean        to_sender,
 215                                          const gchar    *body);
 216 static Compose *compose_reply_mode              (ComposeMode     mode,
 217                                          GSList         *msginfo_list,
 218                                          gchar          *body);
 219 static void compose_template_apply_fields(Compose *compose, Template *tmpl);
 220 static void compose_update_privacy_systems_menu(Compose *compose);
 221
 222 static GtkWidget *compose_account_option_menu_create
 223                                                 (Compose        *compose);
 224 static void compose_set_out_encoding            (Compose        *compose);
 225 static void compose_set_template_menu           (Compose        *compose);
 226 static void compose_destroy                     (Compose        *compose);
 227
 228 static MailField compose_entries_set            (Compose        *compose,
 229                                                  const gchar    *mailto,
 230                                                  ComposeEntryType to_type);
 231 static gint compose_parse_header                (Compose        *compose,
 232                                                  MsgInfo        *msginfo);
 233 static gint compose_parse_manual_headers        (Compose        *compose,
 234                                                  MsgInfo        *msginfo,
 235                                                  HeaderEntry    *entries);
 236 static gchar *compose_parse_references          (const gchar    *ref,
 237                                                  const gchar    *msgid);
 238
 239 static gchar *compose_quote_fmt                 (Compose        *compose,
 240                                                  MsgInfo        *msginfo,
 241                                                  const gchar    *fmt,
 242                                                  const gchar    *qmark,
 243                                                  const gchar    *body,
 244                                                  gboolean        rewrap,
 245                                                  gboolean        need_unescape,
 246                                                  const gchar *err_msg);
 247
 248 static void compose_reply_set_entry             (Compose        *compose,
 249                                                  MsgInfo        *msginfo,
 250                                                  gboolean        to_all,
 251                                                  gboolean        to_ml,
 252                                                  gboolean        to_sender,
 253                                                  gboolean
 254                                                  followup_and_reply_to);
 255 static void compose_reedit_set_entry            (Compose        *compose,
 256                                                  MsgInfo        *msginfo);
 257
 258 static void compose_insert_sig                  (Compose        *compose,
 259                                                  gboolean        replace);
 260 static ComposeInsertResult compose_insert_file  (Compose        *compose,
 261                                                  const gchar    *file);
 262
 263 static gboolean compose_attach_append           (Compose        *compose,
 264                                                  const gchar    *file,
 265                                                  const gchar    *type,
 266                                                  const gchar    *content_type,
 267                                                  const gchar    *charset);
 268 static void compose_attach_parts                (Compose        *compose,
 269                                                  MsgInfo        *msginfo);
 270
 271 static gboolean compose_beautify_paragraph      (Compose        *compose,
 272                                                  GtkTextIter    *par_iter,
 273                                                  gboolean        force);
 274 static void compose_wrap_all                    (Compose        *compose);
 275 static void compose_wrap_all_full               (Compose        *compose,
 276                                                  gboolean        autowrap);
 277
 278 static void compose_set_title                   (Compose        *compose);
 279 static void compose_select_account              (Compose        *compose,
 280                                                  PrefsAccount   *account,
 281                                                  gboolean        init);
 282
 283 static PrefsAccount *compose_current_mail_account(void);
 284 /* static gint compose_send                     (Compose        *compose); */
 285 static gboolean compose_check_for_valid_recipient
 286                                                 (Compose        *compose);
 287 static gboolean compose_check_entries           (Compose        *compose,
 288                                                  gboolean       check_everything);
 289 static gint compose_write_to_file               (Compose        *compose,
 290                                                  FILE           *fp,
 291                                                  gint            action,
 292                                                  gboolean        attach_parts);
 293 static gint compose_write_body_to_file          (Compose        *compose,
 294                                                  const gchar    *file);
 295 static gint compose_remove_reedit_target        (Compose        *compose,
 296                                                  gboolean        force);
 297 static void compose_remove_draft                        (Compose        *compose);
 298 static gint compose_queue_sub                   (Compose        *compose,
 299                                                  gint           *msgnum,
 300                                                  FolderItem     **item,
 301                                                  gchar          **msgpath,
 302                                                  gboolean       check_subject,
 303                                                  gboolean       remove_reedit_target);
 304 static int compose_add_attachments              (Compose        *compose,
 305                                                  MimeInfo       *parent);
 306 static gchar *compose_get_header                (Compose        *compose);
 307 static gchar *compose_get_manual_headers_info   (Compose        *compose);
 308
 309 static void compose_convert_header              (Compose        *compose,
 310                                                  gchar          *dest,
 311                                                  gint            len,
 312                                                  gchar          *src,
 313                                                  gint            header_len,
 314                                                  gboolean        addr_field);
 315
 316 static void compose_attach_info_free            (AttachInfo     *ainfo);
 317 static void compose_attach_remove_selected      (GtkAction      *action,
 318                                                  gpointer        data);
 319
 320 static void compose_template_apply              (Compose        *compose,
 321                                                  Template       *tmpl,
 322                                                  gboolean        replace);
 323 static void compose_attach_property             (GtkAction      *action,
 324                                                  gpointer        data);
 325 static void compose_attach_property_create      (gboolean       *cancelled);
 326 static void attach_property_ok                  (GtkWidget      *widget,
 327                                                  gboolean       *cancelled);
 328 static void attach_property_cancel              (GtkWidget      *widget,
 329                                                  gboolean       *cancelled);
 330 static gint attach_property_delete_event        (GtkWidget      *widget,
 331                                                  GdkEventAny    *event,
 332                                                  gboolean       *cancelled);
 333 static gboolean attach_property_key_pressed     (GtkWidget      *widget,
 334                                                  GdkEventKey    *event,
 335                                                  gboolean       *cancelled);
 336
 337 static void compose_exec_ext_editor             (Compose        *compose);
 338 #ifdef G_OS_UNIX
 339 static gint compose_exec_ext_editor_real        (const gchar    *file);
 340 static gboolean compose_ext_editor_kill         (Compose        *compose);
 341 static gboolean compose_input_cb                (GIOChannel     *source,
 342                                                  GIOCondition    condition,
 343                                                  gpointer        data);
 344 static void compose_set_ext_editor_sensitive    (Compose        *compose,
 345                                                  gboolean        sensitive);
 346 #endif /* G_OS_UNIX */
 347
 348 static void compose_undo_state_changed          (UndoMain       *undostruct,
 349                                                  gint            undo_state,
 350                                                  gint            redo_state,
 351                                                  gpointer        data);
 352
 353 static void compose_create_header_entry (Compose *compose);
 354 static void compose_add_header_entry    (Compose *compose, const gchar *header,
 355                                          gchar *text, ComposePrefType pref_type);
 356 static void compose_remove_header_entries(Compose *compose);
 357
 358 static void compose_update_priority_menu_item(Compose * compose);
 359 #if USE_ENCHANT
 360 static void compose_spell_menu_changed  (void *data);
 361 static void compose_dict_changed        (void *data);
 362 #endif
 363 static void compose_add_field_list      ( Compose *compose,
 364                                           GList *listAddress );
 365
 366 /* callback functions */
 367
 368 static void compose_notebook_size_alloc (GtkNotebook *notebook,
 369                                          GtkAllocation *allocation,
 370                                          GtkPaned *paned);
 371 static gboolean compose_edit_size_alloc (GtkEditable    *widget,
 372                                          GtkAllocation  *allocation,
 373                                          GtkSHRuler     *shruler);
 374 static void account_activated           (GtkComboBox *optmenu,
 375                                          gpointer        data);
 376 static void attach_selected             (GtkTreeView    *tree_view,
 377                                          GtkTreePath    *tree_path,
 378                                          GtkTreeViewColumn *column,
 379                                          Compose *compose);
 380 static gboolean attach_button_pressed   (GtkWidget      *widget,
 381                                          GdkEventButton *event,
 382                                          gpointer        data);
 383 static gboolean attach_key_pressed      (GtkWidget      *widget,
 384                                          GdkEventKey    *event,
 385                                          gpointer        data);
 386 static void compose_send_cb             (GtkAction      *action, gpointer data);
 387 static void compose_send_later_cb       (GtkAction      *action, gpointer data);
 388
 389 static void compose_save_cb             (GtkAction      *action,
 390                                          gpointer        data);
 391
 392 static void compose_attach_cb           (GtkAction      *action,
 393                                          gpointer        data);
 394 static void compose_insert_file_cb      (GtkAction      *action,
 395                                          gpointer        data);
 396 static void compose_insert_sig_cb       (GtkAction      *action,
 397                                          gpointer        data);
 398 static void compose_replace_sig_cb      (GtkAction      *action,
 399                                          gpointer        data);
 400
 401 static void compose_close_cb            (GtkAction      *action,
 402                                          gpointer        data);
 403 static void compose_print_cb            (GtkAction      *action,
 404                                          gpointer        data);
 405
 406 static void compose_set_encoding_cb     (GtkAction      *action, GtkRadioAction *current, gpointer data);
 407
 408 static void compose_address_cb          (GtkAction      *action,
 409                                          gpointer        data);
 410 static void about_show_cb               (GtkAction      *action,
 411                                          gpointer        data);
 412 static void compose_template_activate_cb(GtkWidget      *widget,
 413                                          gpointer        data);
 414
 415 static void compose_ext_editor_cb       (GtkAction      *action,
 416                                          gpointer        data);
 417
 418 static gint compose_delete_cb           (GtkWidget      *widget,
 419                                          GdkEventAny    *event,
 420                                          gpointer        data);
 421
 422 static void compose_undo_cb             (GtkAction      *action,
 423                                          gpointer        data);
 424 static void compose_redo_cb             (GtkAction      *action,
 425                                          gpointer        data);
 426 static void compose_cut_cb              (GtkAction      *action,
 427                                          gpointer        data);
 428 static void compose_copy_cb             (GtkAction      *action,
 429                                          gpointer        data);
 430 static void compose_paste_cb            (GtkAction      *action,
 431                                          gpointer        data);
 432 static void compose_paste_as_quote_cb   (GtkAction      *action,
 433                                          gpointer        data);
 434 static void compose_paste_no_wrap_cb    (GtkAction      *action,
 435                                          gpointer        data);
 436 static void compose_paste_wrap_cb       (GtkAction      *action,
 437                                          gpointer        data);
 438 static void compose_allsel_cb           (GtkAction      *action,
 439                                          gpointer        data);
 440
 441 static void compose_advanced_action_cb  (GtkAction      *action,
 442                                          gpointer        data);
 443
 444 static void compose_grab_focus_cb       (GtkWidget      *widget,
 445                                          Compose        *compose);
 446
 447 static void compose_changed_cb          (GtkTextBuffer  *textbuf,
 448                                          Compose        *compose);
 449
 450 static void compose_wrap_cb             (GtkAction      *action,
 451                                          gpointer        data);
 452 static void compose_wrap_all_cb         (GtkAction      *action,
 453                                          gpointer        data);
 454 static void compose_find_cb             (GtkAction      *action,
 455                                          gpointer        data);
 456 static void compose_toggle_autowrap_cb  (GtkToggleAction *action,
 457                                          gpointer        data);
 458 static void compose_toggle_autoindent_cb(GtkToggleAction *action,
 459                                          gpointer        data);
 460
 461 static void compose_toggle_ruler_cb     (GtkToggleAction *action,
 462                                          gpointer        data);
 463 static void compose_toggle_sign_cb      (GtkToggleAction *action,
 464                                          gpointer        data);
 465 static void compose_toggle_encrypt_cb   (GtkToggleAction *action,
 466                                          gpointer        data);
 467 static void compose_set_privacy_system_cb(GtkWidget *widget, gpointer data);
 468 static void compose_update_privacy_system_menu_item(Compose * compose, gboolean warn);
 469 static void activate_privacy_system     (Compose *compose,
 470                                          PrefsAccount *account,
 471                                          gboolean warn);
 472 static void compose_use_signing(Compose *compose, gboolean use_signing);
 473 static void compose_use_encryption(Compose *compose, gboolean use_encryption);
 474 static void compose_toggle_return_receipt_cb(GtkToggleAction *action,
 475                                          gpointer        data);
 476 static void compose_toggle_remove_refs_cb(GtkToggleAction *action,
 477                                          gpointer        data);
 478 static void compose_set_priority_cb     (GtkAction *action, GtkRadioAction *current, gpointer data);
 479 static void compose_reply_change_mode   (Compose *compose, ComposeMode action);
 480 static void compose_reply_change_mode_cb(GtkAction *action, GtkRadioAction *current, gpointer data);
 481
 482 static void compose_attach_drag_received_cb (GtkWidget          *widget,
 483                                              GdkDragContext     *drag_context,
 484                                              gint                x,
 485                                              gint                y,
 486                                              GtkSelectionData   *data,
 487                                              guint               info,
 488                                              guint               time,
 489                                              gpointer            user_data);
 490 static void compose_insert_drag_received_cb (GtkWidget          *widget,
 491                                              GdkDragContext     *drag_context,
 492                                              gint                x,
 493                                              gint                y,
 494                                              GtkSelectionData   *data,
 495                                              guint               info,
 496                                              guint               time,
 497                                              gpointer            user_data);
 498 static void compose_header_drag_received_cb (GtkWidget          *widget,
 499                                              GdkDragContext     *drag_context,
 500                                              gint                x,
 501                                              gint                y,
 502                                              GtkSelectionData   *data,
 503                                              guint               info,
 504                                              guint               time,
 505                                              gpointer            user_data);
 506
 507 static gboolean compose_drag_drop           (GtkWidget *widget,
 508                                              GdkDragContext *drag_context,
 509                                              gint x, gint y,
 510                                              guint time, gpointer user_data);
 511 static gboolean completion_set_focus_to_subject
 512                                         (GtkWidget    *widget,
 513                                          GdkEventKey  *event,
 514                                          Compose      *user_data);
 515
 516 static void text_inserted               (GtkTextBuffer  *buffer,
 517                                          GtkTextIter    *iter,
 518                                          const gchar    *text,
 519                                          gint            len,
 520                                          Compose        *compose);
 521 static Compose *compose_generic_reply(MsgInfo *msginfo,
 522                                   ComposeQuoteMode quote_mode,
 523                                   gboolean to_all,
 524                                   gboolean to_ml,
 525                                   gboolean to_sender,
 526                                   gboolean followup_and_reply_to,
 527                                   const gchar *body);
 528
 529 static void compose_headerentry_changed_cb         (GtkWidget          *entry,
 530                                             ComposeHeaderEntry *headerentry);
 531 static gboolean compose_headerentry_key_press_event_cb(GtkWidget               *entry,
 532                                             GdkEventKey        *event,
 533                                             ComposeHeaderEntry *headerentry);
 534 static gboolean compose_headerentry_button_clicked_cb (GtkWidget *button,
 535                                         ComposeHeaderEntry *headerentry);
 536
 537 static void compose_show_first_last_header (Compose *compose, gboolean show_first);
 538
 539 static void compose_allow_user_actions (Compose *compose, gboolean allow);
 540
 541 static void compose_nothing_cb             (GtkAction *action, gpointer data)
 542 {
 543
 544 }
 545
 546 #if USE_ENCHANT
 547 static void compose_check_all              (GtkAction *action, gpointer data);
 548 static void compose_highlight_all          (GtkAction *action, gpointer data);
 549 static void compose_check_backwards        (GtkAction *action, gpointer data);
 550 static void compose_check_forwards_go      (GtkAction *action, gpointer data);
 551 #endif
 552
 553 static PrefsAccount *compose_guess_forward_account_from_msginfo (MsgInfo *msginfo);
 554
 555 static MsgInfo *compose_msginfo_new_from_compose(Compose *compose);
 556
 557 #ifdef USE_ENCHANT
 558 static void compose_set_dictionaries_from_folder_prefs(Compose *compose,
 559                                                 FolderItem *folder_item);
 560 #endif
 561 static void compose_attach_update_label(Compose *compose);
 562 static void compose_set_folder_prefs(Compose *compose, FolderItem *folder,
 563                                      gboolean respect_default_to);
 564 static void compose_subject_entry_activated(GtkWidget *widget, gpointer data);
 565 static void from_name_activate_cb(GtkWidget *widget, gpointer data);
 566
 567 static GtkActionEntry compose_popup_entries[] =
 568 {
 569         {"Compose",                     NULL, "Compose" },
 570         {"Compose/Add",                 NULL, N_("_Add..."), NULL, NULL, G_CALLBACK(compose_attach_cb) },
 571         {"Compose/Remove",                      NULL, N_("_Remove"), NULL, NULL, G_CALLBACK(compose_attach_remove_selected) },
 572         {"Compose/---",                 NULL, "---", NULL, NULL, NULL },
 573         {"Compose/Properties",          NULL, N_("_Properties..."), NULL, NULL, G_CALLBACK(compose_attach_property) },
 574 };
 575
 576 static GtkActionEntry compose_entries[] =
 577 {
 578         {"Menu",                                NULL, "Menu" },
 579 /* menus */
 580         {"Message",                     NULL, N_("_Message") },
 581         {"Edit",                        NULL, N_("_Edit") },
 582 #if USE_ENCHANT
 583         {"Spelling",                    NULL, N_("_Spelling") },
 584 #endif
 585         {"Options",                     NULL, N_("_Options") },
 586         {"Tools",                       NULL, N_("_Tools") },
 587         {"Help",                        NULL, N_("_Help") },
 588 /* Message menu */
 589         {"Message/Send",                NULL, N_("S_end"), "<control>Return", NULL, G_CALLBACK(compose_send_cb) },
 590         {"Message/SendLater",           NULL, N_("Send _later"), "<shift><control>S", NULL, G_CALLBACK(compose_send_later_cb) },
 591         {"Message/---",                 NULL, "---" },
 592
 593         {"Message/AttachFile",          NULL, N_("_Attach file"), "<control>M", NULL, G_CALLBACK(compose_attach_cb) },
 594         {"Message/InsertFile",          NULL, N_("_Insert file"), "<control>I", NULL, G_CALLBACK(compose_insert_file_cb) },
 595         {"Message/InsertSig",           NULL, N_("Insert si_gnature"), "<control>G", NULL, G_CALLBACK(compose_insert_sig_cb) },
 596         {"Message/ReplaceSig",          NULL, N_("_Replace signature"), NULL, NULL, G_CALLBACK(compose_replace_sig_cb) },
 597         /* {"Message/---",              NULL, "---" }, */
 598         {"Message/Save",                NULL, N_("_Save"), "<control>S", NULL, G_CALLBACK(compose_save_cb) }, /*COMPOSE_KEEP_EDITING*/
 599         /* {"Message/---",              NULL, "---" }, */
 600         {"Message/Print",               NULL, N_("_Print"), NULL, NULL, G_CALLBACK(compose_print_cb) },
 601         /* {"Message/---",              NULL, "---" }, */
 602         {"Message/Close",               NULL, N_("_Close"), "<control>W", NULL, G_CALLBACK(compose_close_cb) },
 603
 604 /* Edit menu */
 605         {"Edit/Undo",                   NULL, N_("_Undo"), "<control>Z", NULL, G_CALLBACK(compose_undo_cb) },
 606         {"Edit/Redo",                   NULL, N_("_Redo"), "<control>Y", NULL, G_CALLBACK(compose_redo_cb) },
 607         {"Edit/---",                    NULL, "---" },
 608
 609         {"Edit/Cut",                    NULL, N_("Cu_t"), "<control>X", NULL, G_CALLBACK(compose_cut_cb) },
 610         {"Edit/Copy",                   NULL, N_("_Copy"), "<control>C", NULL, G_CALLBACK(compose_copy_cb) },
 611         {"Edit/Paste",                  NULL, N_("_Paste"), "<control>V", NULL, G_CALLBACK(compose_paste_cb) },
 612
 613         {"Edit/SpecialPaste",           NULL, N_("_Special paste") },
 614         {"Edit/SpecialPaste/AsQuotation",       NULL, N_("As _quotation"), NULL, NULL, G_CALLBACK(compose_paste_as_quote_cb) },
 615         {"Edit/SpecialPaste/Wrapped",   NULL, N_("_Wrapped"), NULL, NULL, G_CALLBACK(compose_paste_wrap_cb) },
 616         {"Edit/SpecialPaste/Unwrapped", NULL, N_("_Unwrapped"), NULL, NULL, G_CALLBACK(compose_paste_no_wrap_cb) },
 617
 618         {"Edit/SelectAll",              NULL, N_("Select _all"), "<control>A", NULL, G_CALLBACK(compose_allsel_cb) },
 619
 620         {"Edit/Advanced",               NULL, N_("A_dvanced") },
 621         {"Edit/Advanced/BackChar",      NULL, N_("Move a character backward"), "<shift><control>B", NULL, G_CALLBACK(compose_advanced_action_cb) }, /*COMPOSE_CALL_ADVANCED_ACTION_MOVE_BACKWARD_CHARACTER*/
 622         {"Edit/Advanced/ForwChar",      NULL, N_("Move a character forward"), "<shift><control>F", NULL, G_CALLBACK(compose_advanced_action_cb) }, /*COMPOSE_CALL_ADVANCED_ACTION_MOVE_FORWARD_CHARACTER*/
 623         {"Edit/Advanced/BackWord",      NULL, N_("Move a word backward"), NULL, NULL, G_CALLBACK(compose_advanced_action_cb) }, /*COMPOSE_CALL_ADVANCED_ACTION_MOVE_BACKWARD_WORD*/
 624         {"Edit/Advanced/ForwWord",      NULL, N_("Move a word forward"), NULL, NULL, G_CALLBACK(compose_advanced_action_cb) }, /*COMPOSE_CALL_ADVANCED_ACTION_MOVE_FORWARD_WORD*/
 625         {"Edit/Advanced/BegLine",       NULL, N_("Move to beginning of line"), NULL, NULL, G_CALLBACK(compose_advanced_action_cb) }, /*COMPOSE_CALL_ADVANCED_ACTION_MOVE_BEGINNING_OF_LINE*/
 626         {"Edit/Advanced/EndLine",       NULL, N_("Move to end of line"), NULL, NULL, G_CALLBACK(compose_advanced_action_cb) }, /*COMPOSE_CALL_ADVANCED_ACTION_MOVE_END_OF_LINE*/
 627         {"Edit/Advanced/PrevLine",      NULL, N_("Move to previous line"), "<control>P", NULL, G_CALLBACK(compose_advanced_action_cb) }, /*COMPOSE_CALL_ADVANCED_ACTION_MOVE_PREVIOUS_LINE*/
 628         {"Edit/Advanced/NextLine",      NULL, N_("Move to next line"), "<control>N", NULL, G_CALLBACK(compose_advanced_action_cb) }, /*COMPOSE_CALL_ADVANCED_ACTION_MOVE_NEXT_LINE*/
 629         {"Edit/Advanced/DelBackChar",   NULL, N_("Delete a character backward"), "<control>H", NULL, G_CALLBACK(compose_advanced_action_cb) }, /*COMPOSE_CALL_ADVANCED_ACTION_DELETE_BACKWARD_CHARACTER*/
 630         {"Edit/Advanced/DelForwChar",   NULL, N_("Delete a character forward"), "<control>D", NULL, G_CALLBACK(compose_advanced_action_cb) }, /*COMPOSE_CALL_ADVANCED_ACTION_DELETE_FORWARD_CHARACTER*/
 631         {"Edit/Advanced/DelBackWord",   NULL, N_("Delete a word backward"), NULL, NULL, G_CALLBACK(compose_advanced_action_cb) }, /*COMPOSE_CALL_ADVANCED_ACTION_DELETE_BACKWARD_WORD*/
 632         {"Edit/Advanced/DelForwWord",   NULL, N_("Delete a word forward"), NULL, NULL, G_CALLBACK(compose_advanced_action_cb) }, /*COMPOSE_CALL_ADVANCED_ACTION_DELETE_FORWARD_WORD*/
 633         {"Edit/Advanced/DelLine",       NULL, N_("Delete line"), "<control>U", NULL, G_CALLBACK(compose_advanced_action_cb) }, /*COMPOSE_CALL_ADVANCED_ACTION_DELETE_LINE*/
 634         {"Edit/Advanced/DelEndLine",    NULL, N_("Delete to end of line"), "<control>K", NULL, G_CALLBACK(compose_advanced_action_cb) }, /*COMPOSE_CALL_ADVANCED_ACTION_DELETE_TO_LINE_END*/
 635
 636         /* {"Edit/---",                 NULL, "---" }, */
 637         {"Edit/Find",           NULL, N_("_Find"), "<control>F", NULL, G_CALLBACK(compose_find_cb) },
 638
 639         /* {"Edit/---",                 NULL, "---" }, */
 640         {"Edit/WrapPara",               NULL, N_("_Wrap current paragraph"), "<control>L", NULL, G_CALLBACK(compose_wrap_cb) }, /* 0 */
 641         {"Edit/WrapAllLines",           NULL, N_("Wrap all long _lines"), "<control><alt>L", NULL, G_CALLBACK(compose_wrap_all_cb) }, /* 1 */
 642         /* {"Edit/---",                 NULL, "---" }, */
 643         {"Edit/ExtEditor",              NULL, N_("Edit with e_xternal editor"), "<shift><control>X", NULL, G_CALLBACK(compose_ext_editor_cb) },
 644 #if USE_ENCHANT
 645 /* Spelling menu */
 646         {"Spelling/CheckAllSel",        NULL, N_("_Check all or check selection"), NULL, NULL, G_CALLBACK(compose_check_all) },
 647         {"Spelling/HighlightAll",       NULL, N_("_Highlight all misspelled words"), NULL, NULL, G_CALLBACK(compose_highlight_all) },
 648         {"Spelling/CheckBackwards",     NULL, N_("Check _backwards misspelled word"), NULL, NULL, G_CALLBACK(compose_check_backwards) },
 649         {"Spelling/ForwardNext",        NULL, N_("_Forward to next misspelled word"), NULL, NULL, G_CALLBACK(compose_check_forwards_go) },
 650
 651         {"Spelling/---",                NULL, "---" },
 652         {"Spelling/Options",            NULL, N_("_Options") },
 653 #endif
 654
 655 /* Options menu */
 656
 657         {"Options/ReplyMode",           NULL, N_("Reply _mode") },
 658         {"Options/---",                 NULL, "---" },
 659         {"Options/PrivacySystem",       NULL, N_("Privacy _System") },
 660         {"Options/PrivacySystem/PlaceHolder",   NULL, "Placeholder", NULL, NULL, G_CALLBACK(compose_nothing_cb) },
 661
 662         /* {"Options/---",              NULL, "---" }, */
 663
 664         {"Options/Priority",            NULL, N_("_Priority") },
 665
 666         {"Options/Encoding",            NULL, N_("Character _encoding") },
 667         {"Options/Encoding/---",        NULL, "---" },
 668 #define ENC_ACTION(cs_char,c_char,string) \
 669         { "Options/Encoding/" cs_char, NULL, N_(string), NULL, NULL, c_char }
 670
 671         {"Options/Encoding/Western",    NULL, N_("Western European") },
 672         {"Options/Encoding/Baltic",     NULL, N_("Baltic") },
 673         {"Options/Encoding/Hebrew",     NULL, N_("Hebrew") },
 674         {"Options/Encoding/Arabic",     NULL, N_("Arabic") },
 675         {"Options/Encoding/Cyrillic",   NULL, N_("Cyrillic") },
 676         {"Options/Encoding/Japanese",   NULL, N_("Japanese") },
 677         {"Options/Encoding/Chinese",    NULL, N_("Chinese") },
 678         {"Options/Encoding/Korean",     NULL, N_("Korean") },
 679         {"Options/Encoding/Thai",       NULL, N_("Thai") },
 680
 681 /* Tools menu */
 682         {"Tools/AddressBook",           NULL, N_("_Address book"), NULL, NULL, G_CALLBACK(compose_address_cb) },
 683
 684         {"Tools/Template",      NULL, N_("_Template") },
 685         {"Tools/Template/PlaceHolder",  NULL, "Placeholder", NULL, NULL, G_CALLBACK(compose_nothing_cb) },
 686         {"Tools/Actions",       NULL, N_("Actio_ns") },
 687         {"Tools/Actions/PlaceHolder",   NULL, "Placeholder", NULL, NULL, G_CALLBACK(compose_nothing_cb) },
 688
 689 /* Help menu */
 690         {"Help/About",          NULL, N_("_About"), NULL, NULL, G_CALLBACK(about_show_cb) },
 691 };
 692
 693 static GtkToggleActionEntry compose_toggle_entries[] =
 694 {
 695         {"Edit/AutoWrap",               NULL, N_("Aut_o wrapping"), "<shift><control>L", NULL, G_CALLBACK(compose_toggle_autowrap_cb) }, /* TOGGLE */
 696         {"Edit/AutoIndent",             NULL, N_("Auto _indent"), NULL, NULL, G_CALLBACK(compose_toggle_autoindent_cb) }, /* TOGGLE */
 697         {"Options/Sign",                NULL, N_("Si_gn"), NULL, NULL, G_CALLBACK(compose_toggle_sign_cb) }, /* Toggle */
 698         {"Options/Encrypt",             NULL, N_("_Encrypt"), NULL, NULL, G_CALLBACK(compose_toggle_encrypt_cb) }, /* Toggle */
 699         {"Options/RequestRetRcpt",      NULL, N_("_Request Return Receipt"), NULL, NULL, G_CALLBACK(compose_toggle_return_receipt_cb) }, /* TOGGLE */
 700         {"Options/RemoveReferences",    NULL, N_("Remo_ve references"), NULL, NULL, G_CALLBACK(compose_toggle_remove_refs_cb) }, /* TOGGLE */
 701         {"Tools/ShowRuler",             NULL, N_("Show _ruler"), NULL, NULL, G_CALLBACK(compose_toggle_ruler_cb) }, /* Toggle */
 702 };
 703
 704 static GtkRadioActionEntry compose_radio_rm_entries[] =
 705 {
 706         {"Options/ReplyMode/Normal",    NULL, N_("_Normal"), NULL, NULL, COMPOSE_REPLY }, /* RADIO compose_reply_change_mode_cb */
 707         {"Options/ReplyMode/All",       NULL, N_("_All"), NULL, NULL, COMPOSE_REPLY_TO_ALL }, /* RADIO compose_reply_change_mode_cb */
 708         {"Options/ReplyMode/Sender",    NULL, N_("_Sender"), NULL, NULL, COMPOSE_REPLY_TO_SENDER }, /* RADIO compose_reply_change_mode_cb */
 709         {"Options/ReplyMode/List",      NULL, N_("_Mailing-list"), NULL, NULL, COMPOSE_REPLY_TO_LIST }, /* RADIO compose_reply_change_mode_cb */
 710 };
 711
 712 static GtkRadioActionEntry compose_radio_prio_entries[] =
 713 {
 714         {"Options/Priority/Highest",    NULL, N_("_Highest"), NULL, NULL, PRIORITY_HIGHEST }, /* RADIO compose_set_priority_cb */
 715         {"Options/Priority/High",       NULL, N_("Hi_gh"), NULL, NULL, PRIORITY_HIGH }, /* RADIO compose_set_priority_cb */
 716         {"Options/Priority/Normal",     NULL, N_("_Normal"), NULL, NULL, PRIORITY_NORMAL }, /* RADIO compose_set_priority_cb */
 717         {"Options/Priority/Low",        NULL, N_("Lo_w"), NULL, NULL, PRIORITY_LOW }, /* RADIO compose_set_priority_cb */
 718         {"Options/Priority/Lowest",     NULL, N_("_Lowest"), NULL, NULL, PRIORITY_LOWEST }, /* RADIO compose_set_priority_cb */
 719 };
 720
 721 static GtkRadioActionEntry compose_radio_enc_entries[] =
 722 {
 723         ENC_ACTION(CS_AUTO, C_AUTO, N_("_Automatic")), /* RADIO compose_set_encoding_cb */
 724         ENC_ACTION(CS_US_ASCII, C_US_ASCII, N_("7bit ASCII (US-ASC_II)")), /* RADIO compose_set_encoding_cb */
 725         ENC_ACTION(CS_UTF_8, C_UTF_8, N_("Unicode (_UTF-8)")), /* RADIO compose_set_encoding_cb */
 726         ENC_ACTION("Western/"CS_ISO_8859_1, C_ISO_8859_1, "ISO-8859-_1"), /* RADIO compose_set_encoding_cb */
 727         ENC_ACTION("Western/"CS_ISO_8859_15, C_ISO_8859_15, "ISO-8859-15"), /* RADIO compose_set_encoding_cb */
 728         ENC_ACTION("Western/"CS_WINDOWS_1252, C_WINDOWS_1252, "Windows-1252"), /* RADIO compose_set_encoding_cb */
 729         ENC_ACTION(CS_ISO_8859_2, C_ISO_8859_2, N_("Central European (ISO-8859-_2)")), /* RADIO compose_set_encoding_cb */
 730         ENC_ACTION("Baltic/"CS_ISO_8859_13, C_ISO_8859_13, "ISO-8859-13"), /* RADIO compose_set_encoding_cb */
 731         ENC_ACTION("Baltic/"CS_ISO_8859_4, C_ISO_8859_14, "ISO-8859-_4"), /* RADIO compose_set_encoding_cb */
 732         ENC_ACTION(CS_ISO_8859_7, C_ISO_8859_7, N_("Greek (ISO-8859-_7)")), /* RADIO compose_set_encoding_cb */
 733         ENC_ACTION("Hebrew/"CS_ISO_8859_8, C_ISO_8859_8, "ISO-8859-_8"), /* RADIO compose_set_encoding_cb */
 734         ENC_ACTION("Hebrew/"CS_WINDOWS_1255, C_WINDOWS_1255, "Windows-1255"), /* RADIO compose_set_encoding_cb */
 735         ENC_ACTION("Arabic/"CS_ISO_8859_6, C_ISO_8859_6, "ISO-8859-_6"), /* RADIO compose_set_encoding_cb */
 736         ENC_ACTION("Arabic/"CS_WINDOWS_1256, C_WINDOWS_1256, "Windows-1256"), /* RADIO compose_set_encoding_cb */
 737         ENC_ACTION(CS_ISO_8859_9, C_ISO_8859_9, N_("Turkish (ISO-8859-_9)")), /* RADIO compose_set_encoding_cb */
 738         ENC_ACTION("Cyrillic/"CS_ISO_8859_5, C_ISO_8859_5, "ISO-8859-_5"), /* RADIO compose_set_encoding_cb */
 739         ENC_ACTION("Cyrillic/"CS_KOI8_R, C_KOI8_R, "KOI8-_R"), /* RADIO compose_set_encoding_cb */
 740         ENC_ACTION("Cyrillic/"CS_MACCYR, C_MACCYR, "_Mac-Cyrillic"), /* RADIO compose_set_encoding_cb */
 741         ENC_ACTION("Cyrillic/"CS_KOI8_U, C_KOI8_U, "KOI8-_U"), /* RADIO compose_set_encoding_cb */
 742         ENC_ACTION("Cyrillic/"CS_WINDOWS_1251, C_WINDOWS_1251, "Windows-1251"), /* RADIO compose_set_encoding_cb */
 743         ENC_ACTION("Japanese/"CS_ISO_2022_JP, C_ISO_2022_JP, "ISO-2022-_JP"), /* RADIO compose_set_encoding_cb */
 744         ENC_ACTION("Japanese/"CS_ISO_2022_JP_2, C_ISO_2022_JP_2, "ISO-2022-JP-_2"), /* RADIO compose_set_encoding_cb */
 745         ENC_ACTION("Japanese/"CS_EUC_JP, C_EUC_JP, "_EUC-JP"), /* RADIO compose_set_encoding_cb */
 746         ENC_ACTION("Japanese/"CS_SHIFT_JIS, C_SHIFT_JIS, "_Shift-JIS"), /* RADIO compose_set_encoding_cb */
 747         ENC_ACTION("Chinese/"CS_GB18030, C_GB18030, "_GB18030"), /* RADIO compose_set_encoding_cb */
 748         ENC_ACTION("Chinese/"CS_GB2312, C_GB2312, "_GB2312"), /* RADIO compose_set_encoding_cb */
 749         ENC_ACTION("Chinese/"CS_GBK, C_GBK, "GB_K"), /* RADIO compose_set_encoding_cb */
 750         ENC_ACTION("Chinese/"CS_BIG5, C_BIG5, "_Big5-JP"), /* RADIO compose_set_encoding_cb */
 751         ENC_ACTION("Chinese/"CS_EUC_TW, C_EUC_TW, "EUC-_TW"), /* RADIO compose_set_encoding_cb */
 752         ENC_ACTION("Korean/"CS_EUC_KR, C_EUC_KR, "_EUC-KR"), /* RADIO compose_set_encoding_cb */
 753         ENC_ACTION("Korean/"CS_ISO_2022_KR, C_ISO_2022_KR, "_ISO-2022-KR"), /* RADIO compose_set_encoding_cb */
 754         ENC_ACTION("Thai/"CS_TIS_620, C_TIS_620, "_TIS-620-KR"), /* RADIO compose_set_encoding_cb */
 755         ENC_ACTION("Thai/"CS_WINDOWS_874, C_WINDOWS_874, "_Windows-874"), /* RADIO compose_set_encoding_cb */
 756 };
 757
 758 static GtkTargetEntry compose_mime_types[] =
 759 {
 760         {"text/uri-list", 0, 0},
 761         {"UTF8_STRING", 0, 0},
 762         {"text/plain", 0, 0}
 763 };
 764
 765 static gboolean compose_put_existing_to_front(MsgInfo *info)
 766 {
 767         const GList *compose_list = compose_get_compose_list();
 768         const GList *elem = NULL;
 769
 770         if (compose_list) {
 771                 for (elem = compose_list; elem != NULL && elem->data != NULL;
 772                      elem = elem->next) {
 773                         Compose *c = (Compose*)elem->data;
 774
 775                         if (!c->targetinfo || !c->targetinfo->msgid ||
 776                             !info->msgid)
 777                                 continue;
 778
 779                         if (!strcmp(c->targetinfo->msgid, info->msgid)) {
 780                                 gtkut_window_popup(c->window);
 781                                 return TRUE;
 782                         }
 783                 }
 784         }
 785         return FALSE;
 786 }
 787
 788 static GdkColor quote_color1 =
 789         {(gulong)0, (gushort)0, (gushort)0, (gushort)0};
 790 static GdkColor quote_color2 =
 791         {(gulong)0, (gushort)0, (gushort)0, (gushort)0};
 792 static GdkColor quote_color3 =
 793         {(gulong)0, (gushort)0, (gushort)0, (gushort)0};
 794
 795 static GdkColor quote_bgcolor1 =
 796         {(gulong)0, (gushort)0, (gushort)0, (gushort)0};
 797 static GdkColor quote_bgcolor2 =
 798         {(gulong)0, (gushort)0, (gushort)0, (gushort)0};
 799 static GdkColor quote_bgcolor3 =
 800         {(gulong)0, (gushort)0, (gushort)0, (gushort)0};
 801
 802 static GdkColor signature_color = {
 803         (gulong)0,
 804         (gushort)0x7fff,
 805         (gushort)0x7fff,
 806         (gushort)0x7fff
 807 };
 808
 809 static GdkColor uri_color = {
 810         (gulong)0,
 811         (gushort)0,
 812         (gushort)0,
 813         (gushort)0
 814 };
 815
 816 static void compose_create_tags(GtkTextView *text, Compose *compose)
 817 {
 818         GtkTextBuffer *buffer;
 819         GdkColor black = {(gulong)0, (gushort)0, (gushort)0, (gushort)0};
 820 #if !GTK_CHECK_VERSION(2, 24, 0)
 821         GdkColormap *cmap;
 822         gboolean success[8];
 823         int i;
 824         GdkColor color[8];
 825 #endif
 826
 827         buffer = gtk_text_view_get_buffer(text);
 828
 829         if (prefs_common.enable_color) {
 830                 /* grab the quote colors, converting from an int to a GdkColor */
 831                 gtkut_convert_int_to_gdk_color(prefs_common.quote_level1_col,
 832                                                &quote_color1);
 833                 gtkut_convert_int_to_gdk_color(prefs_common.quote_level2_col,
 834                                                &quote_color2);
 835                 gtkut_convert_int_to_gdk_color(prefs_common.quote_level3_col,
 836                                                &quote_color3);
 837                 gtkut_convert_int_to_gdk_color(prefs_common.quote_level1_bgcol,
 838                                                &quote_bgcolor1);
 839                 gtkut_convert_int_to_gdk_color(prefs_common.quote_level2_bgcol,
 840                                                &quote_bgcolor2);
 841                 gtkut_convert_int_to_gdk_color(prefs_common.quote_level3_bgcol,
 842                                                &quote_bgcolor3);
 843                 gtkut_convert_int_to_gdk_color(prefs_common.signature_col,
 844                                                &signature_color);
 845                 gtkut_convert_int_to_gdk_color(prefs_common.uri_col,
 846                                                &uri_color);
 847         } else {
 848                 signature_color = quote_color1 = quote_color2 = quote_color3 =
 849                         quote_bgcolor1 = quote_bgcolor2 = quote_bgcolor3 = uri_color = black;
 850         }
 851
 852         if (prefs_common.enable_color && prefs_common.enable_bgcolor) {
 853                 compose->quote0_tag = gtk_text_buffer_create_tag(buffer, "quote0",
 854                                            "foreground-gdk", &quote_color1,
 855                                            "paragraph-background-gdk", &quote_bgcolor1,
 856                                            NULL);
 857                 compose->quote1_tag = gtk_text_buffer_create_tag(buffer, "quote1",
 858                                            "foreground-gdk", &quote_color2,
 859                                            "paragraph-background-gdk", &quote_bgcolor2,
 860                                            NULL);
 861                 compose->quote2_tag = gtk_text_buffer_create_tag(buffer, "quote2",
 862                                            "foreground-gdk", &quote_color3,
 863                                            "paragraph-background-gdk", &quote_bgcolor3,
 864                                            NULL);
 865         } else {
 866                 compose->quote0_tag = gtk_text_buffer_create_tag(buffer, "quote0",
 867                                            "foreground-gdk", &quote_color1,
 868                                            NULL);
 869                 compose->quote1_tag = gtk_text_buffer_create_tag(buffer, "quote1",
 870                                            "foreground-gdk", &quote_color2,
 871                                            NULL);
 872                 compose->quote2_tag = gtk_text_buffer_create_tag(buffer, "quote2",
 873                                            "foreground-gdk", &quote_color3,
 874                                            NULL);
 875         }
 876
 877         compose->signature_tag = gtk_text_buffer_create_tag(buffer, "signature",
 878                                    "foreground-gdk", &signature_color,
 879                                    NULL);
 880
 881         compose->uri_tag = gtk_text_buffer_create_tag(buffer, "link",
 882                                         "foreground-gdk", &uri_color,
 883                                          NULL);
 884         compose->no_wrap_tag = gtk_text_buffer_create_tag(buffer, "no_wrap", NULL);
 885         compose->no_join_tag = gtk_text_buffer_create_tag(buffer, "no_join", NULL);
 886
 887 #if !GTK_CHECK_VERSION(2, 24, 0)
 888         color[0] = quote_color1;
 889         color[1] = quote_color2;
 890         color[2] = quote_color3;
 891         color[3] = quote_bgcolor1;
 892         color[4] = quote_bgcolor2;
 893         color[5] = quote_bgcolor3;
 894         color[6] = signature_color;
 895         color[7] = uri_color;
 896
 897         cmap = gdk_drawable_get_colormap(gtk_widget_get_window(compose->window));
 898         gdk_colormap_alloc_colors(cmap, color, 8, FALSE, TRUE, success);
 899
 900         for (i = 0; i < 8; i++) {
 901                 if (success[i] == FALSE) {
 902                         g_warning("Compose: color allocation failed.\n");
 903                         quote_color1 = quote_color2 = quote_color3 =
 904                                 quote_bgcolor1 = quote_bgcolor2 = quote_bgcolor3 =
 905                                 signature_color = uri_color = black;
 906                 }
 907         }
 908 #endif
 909 }
 910
 911 Compose *compose_new(PrefsAccount *account, const gchar *mailto,
 912                      GList *attach_files)
 913 {
 914         return compose_generic_new(account, mailto, NULL, attach_files, NULL);
 915 }
 916
 917 Compose *compose_new_with_folderitem(PrefsAccount *account, FolderItem *item, const gchar *mailto)
 918 {
 919         return compose_generic_new(account, mailto, item, NULL, NULL);
 920 }
 921
 922 Compose *compose_new_with_list( PrefsAccount *account, GList *listAddress )
 923 {
 924         return compose_generic_new( account, NULL, NULL, NULL, listAddress );
 925 }
 926
 927 #define SCROLL_TO_CURSOR(compose) {                             \
 928         GtkTextMark *cmark = gtk_text_buffer_get_insert(        \
 929                 gtk_text_view_get_buffer(                       \
 930                         GTK_TEXT_VIEW(compose->text)));         \
 931         gtk_text_view_scroll_mark_onscreen(                     \
 932                 GTK_TEXT_VIEW(compose->text),                   \
 933                 cmark);                                         \
 934 }
 935
 936 static void compose_set_save_to(Compose *compose, const gchar *folderidentifier)
 937 {
 938         GtkEditable *entry;
 939         if (folderidentifier) {
 940 #if !GTK_CHECK_VERSION(2, 24, 0)
 941                 combobox_unset_popdown_strings(GTK_COMBO_BOX(compose->savemsg_combo));
 942 #else
 943                 combobox_unset_popdown_strings(GTK_COMBO_BOX_TEXT(compose->savemsg_combo));
 944 #endif
 945                 prefs_common.compose_save_to_history = add_history(
 946                                 prefs_common.compose_save_to_history, folderidentifier);
 947 #if !GTK_CHECK_VERSION(2, 24, 0)
 948                 combobox_set_popdown_strings(GTK_COMBO_BOX(compose->savemsg_combo),
 949                                 prefs_common.compose_save_to_history);
 950 #else
 951                 combobox_set_popdown_strings(GTK_COMBO_BOX_TEXT(compose->savemsg_combo),
 952                                 prefs_common.compose_save_to_history);
 953 #endif
 954         }
 955
 956         entry = GTK_EDITABLE(gtk_bin_get_child(GTK_BIN(compose->savemsg_combo)));
 957         if (folderidentifier)
 958                 gtk_entry_set_text(GTK_ENTRY(entry), folderidentifier);
 959         else
 960                 gtk_entry_set_text(GTK_ENTRY(entry), "");
 961 }
 962
 963 static gchar *compose_get_save_to(Compose *compose)
 964 {
 965         GtkEditable *entry;
 966         gchar *result = NULL;
 967         entry = GTK_EDITABLE(gtk_bin_get_child(GTK_BIN(compose->savemsg_combo)));
 968         result = gtk_editable_get_chars(entry, 0, -1);
 969
 970         if (result) {
 971 #if !GTK_CHECK_VERSION(2, 24, 0)
 972                 combobox_unset_popdown_strings(GTK_COMBO_BOX(compose->savemsg_combo));
 973 #else
 974                 combobox_unset_popdown_strings(GTK_COMBO_BOX_TEXT(compose->savemsg_combo));
 975 #endif
 976                 prefs_common.compose_save_to_history = add_history(
 977                                 prefs_common.compose_save_to_history, result);
 978 #if !GTK_CHECK_VERSION(2, 24, 0)
 979                 combobox_set_popdown_strings(GTK_COMBO_BOX(compose->savemsg_combo),
 980                                 prefs_common.compose_save_to_history);
 981 #else
 982                 combobox_set_popdown_strings(GTK_COMBO_BOX_TEXT(compose->savemsg_combo),
 983                                 prefs_common.compose_save_to_history);
 984 #endif
 985         }
 986         return result;
 987 }
 988
 989 Compose *compose_generic_new(PrefsAccount *account, const gchar *mailto, FolderItem *item,
 990                              GList *attach_files, GList *listAddress )
 991 {
 992         Compose *compose;
 993         GtkTextView *textview;
 994         GtkTextBuffer *textbuf;
 995         GtkTextIter iter;
 996         const gchar *subject_format = NULL;
 997         const gchar *body_format = NULL;
 998         gchar *mailto_from = NULL;
 999         PrefsAccount *mailto_account = NULL;
1000         MsgInfo* dummyinfo = NULL;
1001         gint cursor_pos = -1;
1002         MailField mfield = NO_FIELD_PRESENT;
1003         gchar* buf;
1004         GtkTextMark *mark;
1005
1006         /* check if mailto defines a from */
1007         if (mailto && *mailto != '\0') {
1008                 scan_mailto_url(mailto, &mailto_from, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
1009                 /* mailto defines a from, check if we can get account prefs from it,
1010                    if not, the account prefs will be guessed using other ways, but we'll keep
1011                    the from anyway */
1012                 if (mailto_from) {
1013                         mailto_account = account_find_from_address(mailto_from, TRUE);
1014                         if (mailto_account == NULL) {
1015                                 gchar *tmp_from;
1016                                 Xstrdup_a(tmp_from, mailto_from, return NULL);
1017                                 extract_address(tmp_from);
1018                                 mailto_account = account_find_from_address(tmp_from, TRUE);
1019                         }
1020                 }
1021                 if (mailto_account)
1022                         account = mailto_account;
1023         }
1024
1025         /* if no account prefs set from mailto, set if from folder prefs (if any) */
1026         if (!mailto_account && item && item->prefs && item->prefs->enable_default_account)
1027                 account = account_find_from_id(item->prefs->default_account);
1028
1029         /* if no account prefs set, fallback to the current one */
1030         if (!account) account = cur_account;
1031         cm_return_val_if_fail(account != NULL, NULL);
1032
1033         compose = compose_create(account, item, COMPOSE_NEW, FALSE);
1034
1035         /* override from name if mailto asked for it */
1036         if (mailto_from) {
1037                 gtk_entry_set_text(GTK_ENTRY(compose->from_name), mailto_from);
1038                 g_free(mailto_from);
1039         } else
1040                 /* override from name according to folder properties */
1041                 if (item && item->prefs &&
1042                         item->prefs->compose_with_format &&
1043                         item->prefs->compose_override_from_format &&
1044                         *item->prefs->compose_override_from_format != '\0') {
1045
1046                         gchar *tmp = NULL;
1047                         gchar *buf = NULL;
1048
1049                         dummyinfo = compose_msginfo_new_from_compose(compose);
1050
1051                         /* decode \-escape sequences in the internal representation of the quote format */
1052                         tmp = g_malloc(strlen(item->prefs->compose_override_from_format)+1);
1053                         pref_get_unescaped_pref(tmp, item->prefs->compose_override_from_format);
1054
1055 #ifdef USE_ENCHANT
1056                         quote_fmt_init(dummyinfo, NULL, NULL, FALSE, compose->account, FALSE,
1057                                         compose->gtkaspell);
1058 #else
1059                         quote_fmt_init(dummyinfo, NULL, NULL, FALSE, compose->account, FALSE);
1060 #endif
1061                         quote_fmt_scan_string(tmp);
1062                         quote_fmt_parse();
1063
1064                         buf = quote_fmt_get_buffer();
1065                         if (buf == NULL)
1066                                 alertpanel_error(_("New message From format error."));
1067                         else
1068                                 gtk_entry_set_text(GTK_ENTRY(compose->from_name), buf);
1069                         quote_fmt_reset_vartable();
1070
1071                         g_free(tmp);
1072                 }
1073
1074         compose->replyinfo = NULL;
1075         compose->fwdinfo   = NULL;
1076
1077         textview = GTK_TEXT_VIEW(compose->text);
1078         textbuf = gtk_text_view_get_buffer(textview);
1079         compose_create_tags(textview, compose);
1080
1081         undo_block(compose->undostruct);
1082 #ifdef USE_ENCHANT
1083         compose_set_dictionaries_from_folder_prefs(compose, item);
1084 #endif
1085
1086         if (account->auto_sig)
1087                 compose_insert_sig(compose, FALSE);
1088         gtk_text_buffer_get_start_iter(textbuf, &iter);
1089         gtk_text_buffer_place_cursor(textbuf, &iter);
1090
1091         if (account->protocol != A_NNTP) {
1092                 if (mailto && *mailto != '\0') {
1093                         mfield = compose_entries_set(compose, mailto, COMPOSE_TO);
1094
1095                 } else {
1096                         compose_set_folder_prefs(compose, item, TRUE);
1097                 }
1098                 if (item && item->ret_rcpt) {
1099                         cm_toggle_menu_set_active_full(compose->ui_manager, "Menu/Options/RequestRetRcpt", TRUE);
1100                 }
1101         } else {
1102                 if (mailto && *mailto != '\0') {
1103                         if (!strchr(mailto, '@'))
1104                                 mfield = compose_entries_set(compose, mailto, COMPOSE_NEWSGROUPS);
1105                         else
1106                                 mfield = compose_entries_set(compose, mailto, COMPOSE_TO);
1107                 } else if (item && FOLDER_CLASS(item->folder) == news_get_class()) {
1108                         compose_entry_append(compose, item->path, COMPOSE_NEWSGROUPS, PREF_FOLDER);
1109                         mfield = TO_FIELD_PRESENT;
1110                 }
1111                 /*
1112                  * CLAWS: just don't allow return receipt request, even if the user
1113                  * may want to send an email. simple but foolproof.
1114                  */
1115                 cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Options/RequestRetRcpt", FALSE);
1116         }
1117         compose_add_field_list( compose, listAddress );
1118
1119         if (item && item->prefs && item->prefs->compose_with_format) {
1120                 subject_format = item->prefs->compose_subject_format;
1121                 body_format = item->prefs->compose_body_format;
1122         } else if (account->compose_with_format) {
1123                 subject_format = account->compose_subject_format;
1124                 body_format = account->compose_body_format;
1125         } else if (prefs_common.compose_with_format) {
1126                 subject_format = prefs_common.compose_subject_format;
1127                 body_format = prefs_common.compose_body_format;
1128         }
1129
1130         if (subject_format || body_format) {
1131
1132                 if ( subject_format
1133                          && *subject_format != '\0' )
1134                 {
1135                         gchar *subject = NULL;
1136                         gchar *tmp = NULL;
1137                         gchar *buf = NULL;
1138
1139                         if (!dummyinfo)
1140                                 dummyinfo = compose_msginfo_new_from_compose(compose);
1141
1142                         /* decode \-escape sequences in the internal representation of the quote format */
1143                         tmp = g_malloc(strlen(subject_format)+1);
1144                         pref_get_unescaped_pref(tmp, subject_format);
1145
1146                         subject = gtk_editable_get_chars(GTK_EDITABLE(compose->subject_entry), 0, -1);
1147 #ifdef USE_ENCHANT
1148                         quote_fmt_init(dummyinfo, NULL, subject, FALSE, compose->account, FALSE,
1149                                         compose->gtkaspell);
1150 #else
1151                         quote_fmt_init(dummyinfo, NULL, subject, FALSE, compose->account, FALSE);
1152 #endif
1153                         quote_fmt_scan_string(tmp);
1154                         quote_fmt_parse();
1155
1156                         buf = quote_fmt_get_buffer();
1157                         if (buf == NULL)
1158                                 alertpanel_error(_("New message subject format error."));
1159                         else
1160                                 gtk_entry_set_text(GTK_ENTRY(compose->subject_entry), buf);
1161                         compose_attach_from_list(compose, quote_fmt_get_attachments_list(), FALSE);
1162                         quote_fmt_reset_vartable();
1163
1164                         g_free(subject);
1165                         g_free(tmp);
1166                         mfield = SUBJECT_FIELD_PRESENT;
1167                 }
1168
1169                 if ( body_format
1170                          && *body_format != '\0' )
1171                 {
1172                         GtkTextView *text;
1173                         GtkTextBuffer *buffer;
1174                         GtkTextIter start, end;
1175                         gchar *tmp = NULL;
1176
1177                         if (!dummyinfo)
1178                                 dummyinfo = compose_msginfo_new_from_compose(compose);
1179
1180                         text = GTK_TEXT_VIEW(compose->text);
1181                         buffer = gtk_text_view_get_buffer(text);
1182                         gtk_text_buffer_get_start_iter(buffer, &start);
1183                         gtk_text_buffer_get_iter_at_offset(buffer, &end, -1);
1184                         tmp = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
1185
1186                         compose_quote_fmt(compose, dummyinfo,
1187                                           body_format,
1188                                           NULL, tmp, FALSE, TRUE,
1189                                                   _("The body of the \"New message\" template has an error at line %d."));
1190                         compose_attach_from_list(compose, quote_fmt_get_attachments_list(), FALSE);
1191                         quote_fmt_reset_vartable();
1192
1193                         g_free(tmp);
1194 #ifdef USE_ENCHANT
1195                         if (compose->gtkaspell && compose->gtkaspell->check_while_typing)
1196                                 gtkaspell_highlight_all(compose->gtkaspell);
1197 #endif
1198                         mfield = BODY_FIELD_PRESENT;
1199                 }
1200
1201         }
1202         procmsg_msginfo_free( dummyinfo );
1203
1204         if (attach_files) {
1205                 GList *curr;
1206                 AttachInfo *ainfo;
1207
1208                 for (curr = attach_files ; curr != NULL ; curr = curr->next) {
1209                         ainfo = (AttachInfo *) curr->data;
1210                         compose_attach_append(compose, ainfo->file, ainfo->file,
1211                                         ainfo->content_type, ainfo->charset);
1212                 }
1213         }
1214
1215         compose_show_first_last_header(compose, TRUE);
1216
1217         /* Set save folder */
1218         if (item && item->prefs && item->prefs->save_copy_to_folder) {
1219                 gchar *folderidentifier;
1220
1221                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(compose->savemsg_checkbtn), prefs_common.savemsg);
1222                 folderidentifier = folder_item_get_identifier(item);
1223                 compose_set_save_to(compose, folderidentifier);
1224                 g_free(folderidentifier);
1225         }
1226
1227         /* Place cursor according to provided input (mfield) */
1228         switch (mfield) {
1229                 case NO_FIELD_PRESENT:
1230                         if (compose->header_last)
1231                                 gtk_widget_grab_focus(compose->header_last->entry);
1232                         break;
1233                 case TO_FIELD_PRESENT:
1234                         buf = gtk_editable_get_chars(GTK_EDITABLE(compose->subject_entry), 0, -1);
1235                         if (buf) {
1236                                 gtk_entry_set_text(GTK_ENTRY(compose->subject_entry), buf);
1237                                 g_free(buf);
1238                         }
1239                         gtk_widget_grab_focus(compose->subject_entry);
1240                         break;
1241                 case SUBJECT_FIELD_PRESENT:
1242                         textview = GTK_TEXT_VIEW(compose->text);
1243                         if (!textview)
1244                                 break;
1245                         textbuf = gtk_text_view_get_buffer(textview);
1246                         if (!textbuf)
1247                                 break;
1248                         mark = gtk_text_buffer_get_insert(textbuf);
1249                         gtk_text_buffer_get_iter_at_mark(textbuf, &iter, mark);
1250                         gtk_text_buffer_insert(textbuf, &iter, "", -1);
1251                     /*
1252                      * SUBJECT_FIELD_PRESENT and BODY_FIELD_PRESENT
1253                      * only defers where it comes to the variable body
1254                      * is not null. If no body is present compose->text
1255                      * will be null in which case you cannot place the
1256                      * cursor inside the component so. An empty component
1257                      * is therefore created before placing the cursor
1258                      */
1259                 case BODY_FIELD_PRESENT:
1260                         cursor_pos = quote_fmt_get_cursor_pos();
1261                         if (cursor_pos == -1)
1262                                 gtk_widget_grab_focus(compose->header_last->entry);
1263                         else
1264                                 gtk_widget_grab_focus(compose->text);
1265                         break;
1266         }
1267
1268         undo_unblock(compose->undostruct);
1269
1270         if (prefs_common.auto_exteditor)
1271                 compose_exec_ext_editor(compose);
1272
1273         compose->draft_timeout_tag = COMPOSE_DRAFT_TIMEOUT_UNSET;
1274
1275         SCROLL_TO_CURSOR(compose);
1276
1277         compose->modified = FALSE;
1278         compose_set_title(compose);
1279
1280         hooks_invoke(COMPOSE_CREATED_HOOKLIST, compose);
1281
1282         return compose;
1283 }
1284
1285 static void compose_force_encryption(Compose *compose, PrefsAccount *account,
1286                 gboolean override_pref, const gchar *system)
1287 {
1288         const gchar *privacy = NULL;
1289
1290         cm_return_if_fail(compose != NULL);
1291         cm_return_if_fail(account != NULL);
1292
1293         if (override_pref == FALSE && account->default_encrypt_reply == FALSE)
1294                 return;
1295
1296         if (account->default_privacy_system && strlen(account->default_privacy_system))
1297                 privacy = account->default_privacy_system;
1298         else if (system)
1299                 privacy = system;
1300         else {
1301                 GSList *privacy_avail = privacy_get_system_ids();
1302                 if (privacy_avail && g_slist_length(privacy_avail)) {
1303                         privacy = (gchar *)(privacy_avail->data);
1304                 }
1305         }
1306         if (privacy != NULL) {
1307                 if (system) {
1308                         g_free(compose->privacy_system);
1309                         compose->privacy_system = NULL;
1310                         g_free(compose->encdata);
1311                         compose->encdata = NULL;
1312                 }
1313                 if (compose->privacy_system == NULL)
1314                         compose->privacy_system = g_strdup(privacy);
1315                 else if (*(compose->privacy_system) == '\0') {
1316                         g_free(compose->privacy_system);
1317                         g_free(compose->encdata);
1318                         compose->encdata = NULL;
1319                         compose->privacy_system = g_strdup(privacy);
1320                 }
1321                 compose_update_privacy_system_menu_item(compose, FALSE);
1322                 compose_use_encryption(compose, TRUE);
1323         }
1324 }
1325
1326 static void compose_force_signing(Compose *compose, PrefsAccount *account, const gchar *system)
1327 {
1328         const gchar *privacy = NULL;
1329
1330         if (account->default_privacy_system && strlen(account->default_privacy_system))
1331                 privacy = account->default_privacy_system;
1332         else if (system)
1333                 privacy = system;
1334         else {
1335                 GSList *privacy_avail = privacy_get_system_ids();
1336                 if (privacy_avail && g_slist_length(privacy_avail)) {
1337                         privacy = (gchar *)(privacy_avail->data);
1338                 }
1339         }
1340
1341         if (privacy != NULL) {
1342                 if (system) {
1343                         g_free(compose->privacy_system);
1344                         compose->privacy_system = NULL;
1345                         g_free(compose->encdata);
1346                         compose->encdata = NULL;
1347                 }
1348                 if (compose->privacy_system == NULL)
1349                         compose->privacy_system = g_strdup(privacy);
1350                 compose_update_privacy_system_menu_item(compose, FALSE);
1351                 compose_use_signing(compose, TRUE);
1352         }
1353 }
1354
1355 static Compose *compose_reply_mode(ComposeMode mode, GSList *msginfo_list, gchar *body)
1356 {
1357         MsgInfo *msginfo;
1358         guint list_len;
1359         Compose *compose = NULL;
1360
1361         cm_return_val_if_fail(msginfo_list != NULL, NULL);
1362
1363         msginfo = (MsgInfo*)g_slist_nth_data(msginfo_list, 0);
1364         cm_return_val_if_fail(msginfo != NULL, NULL);
1365
1366         list_len = g_slist_length(msginfo_list);
1367
1368         switch (mode) {
1369         case COMPOSE_REPLY:
1370         case COMPOSE_REPLY_TO_ADDRESS:
1371                 compose = compose_reply(msginfo, COMPOSE_QUOTE_CHECK,
1372                               FALSE, prefs_common.default_reply_list, FALSE, body);
1373                 break;
1374         case COMPOSE_REPLY_WITH_QUOTE:
1375                 compose = compose_reply(msginfo, COMPOSE_QUOTE_FORCED,
1376                         FALSE, prefs_common.default_reply_list, FALSE, body);
1377                 break;
1378         case COMPOSE_REPLY_WITHOUT_QUOTE:
1379                 compose = compose_reply(msginfo, COMPOSE_QUOTE_SKIP,
1380                         FALSE, prefs_common.default_reply_list, FALSE, NULL);
1381                 break;
1382         case COMPOSE_REPLY_TO_SENDER:
1383                 compose = compose_reply(msginfo, COMPOSE_QUOTE_CHECK,
1384                               FALSE, FALSE, TRUE, body);
1385                 break;
1386         case COMPOSE_FOLLOWUP_AND_REPLY_TO:
1387                 compose = compose_followup_and_reply_to(msginfo,
1388                                               COMPOSE_QUOTE_CHECK,
1389                                               FALSE, FALSE, body);
1390                 break;
1391         case COMPOSE_REPLY_TO_SENDER_WITH_QUOTE:
1392                 compose = compose_reply(msginfo, COMPOSE_QUOTE_FORCED,
1393                         FALSE, FALSE, TRUE, body);
1394                 break;
1395         case COMPOSE_REPLY_TO_SENDER_WITHOUT_QUOTE:
1396                 compose = compose_reply(msginfo, COMPOSE_QUOTE_SKIP,
1397                         FALSE, FALSE, TRUE, NULL);
1398                 break;
1399         case COMPOSE_REPLY_TO_ALL:
1400                 compose = compose_reply(msginfo, COMPOSE_QUOTE_CHECK,
1401                         TRUE, FALSE, FALSE, body);
1402                 break;
1403         case COMPOSE_REPLY_TO_ALL_WITH_QUOTE:
1404                 compose = compose_reply(msginfo, COMPOSE_QUOTE_FORCED,
1405                         TRUE, FALSE, FALSE, body);
1406                 break;
1407         case COMPOSE_REPLY_TO_ALL_WITHOUT_QUOTE:
1408                 compose = compose_reply(msginfo, COMPOSE_QUOTE_SKIP,
1409                         TRUE, FALSE, FALSE, NULL);
1410                 break;
1411         case COMPOSE_REPLY_TO_LIST:
1412                 compose = compose_reply(msginfo, COMPOSE_QUOTE_CHECK,
1413                         FALSE, TRUE, FALSE, body);
1414                 break;
1415         case COMPOSE_REPLY_TO_LIST_WITH_QUOTE:
1416                 compose = compose_reply(msginfo, COMPOSE_QUOTE_FORCED,
1417                         FALSE, TRUE, FALSE, body);
1418                 break;
1419         case COMPOSE_REPLY_TO_LIST_WITHOUT_QUOTE:
1420                 compose = compose_reply(msginfo, COMPOSE_QUOTE_SKIP,
1421                         FALSE, TRUE, FALSE, NULL);
1422                 break;
1423         case COMPOSE_FORWARD:
1424                 if (prefs_common.forward_as_attachment) {
1425                         compose = compose_reply_mode(COMPOSE_FORWARD_AS_ATTACH, msginfo_list, body);
1426                         return compose;
1427                 } else {
1428                         compose = compose_reply_mode(COMPOSE_FORWARD_INLINE, msginfo_list, body);
1429                         return compose;
1430                 }
1431                 break;
1432         case COMPOSE_FORWARD_INLINE:
1433                 /* check if we reply to more than one Message */
1434                 if (list_len == 1) {
1435                         compose = compose_forward(NULL, msginfo, FALSE, body, FALSE, FALSE);
1436                         break;
1437                 }
1438                 /* more messages FALL THROUGH */
1439         case COMPOSE_FORWARD_AS_ATTACH:
1440                 compose = compose_forward_multiple(NULL, msginfo_list);
1441                 break;
1442         case COMPOSE_REDIRECT:
1443                 compose = compose_redirect(NULL, msginfo, FALSE);
1444                 break;
1445         default:
1446                 g_warning("compose_reply_mode(): invalid Compose Mode: %d\n", mode);
1447         }
1448
1449         if (compose == NULL) {
1450                 alertpanel_error(_("Unable to reply. The original email probably doesn't exist."));
1451                 return NULL;
1452         }
1453
1454         compose->rmode = mode;
1455         switch (compose->rmode) {
1456         case COMPOSE_REPLY:
1457         case COMPOSE_REPLY_WITH_QUOTE:
1458         case COMPOSE_REPLY_WITHOUT_QUOTE:
1459         case COMPOSE_FOLLOWUP_AND_REPLY_TO:
1460                 debug_print("reply mode Normal\n");
1461                 cm_toggle_menu_set_active_full(compose->ui_manager, "Menu/Options/ReplyMode/Normal", TRUE);
1462                 compose_reply_change_mode(compose, COMPOSE_REPLY); /* force update */
1463                 break;
1464         case COMPOSE_REPLY_TO_SENDER:
1465         case COMPOSE_REPLY_TO_SENDER_WITH_QUOTE:
1466         case COMPOSE_REPLY_TO_SENDER_WITHOUT_QUOTE:
1467                 debug_print("reply mode Sender\n");
1468                 cm_toggle_menu_set_active_full(compose->ui_manager, "Menu/Options/ReplyMode/Sender", TRUE);
1469                 break;
1470         case COMPOSE_REPLY_TO_ALL:
1471         case COMPOSE_REPLY_TO_ALL_WITH_QUOTE:
1472         case COMPOSE_REPLY_TO_ALL_WITHOUT_QUOTE:
1473                 debug_print("reply mode All\n");
1474                 cm_toggle_menu_set_active_full(compose->ui_manager, "Menu/Options/ReplyMode/All", TRUE);
1475                 break;
1476         case COMPOSE_REPLY_TO_LIST:
1477         case COMPOSE_REPLY_TO_LIST_WITH_QUOTE:
1478         case COMPOSE_REPLY_TO_LIST_WITHOUT_QUOTE:
1479                 debug_print("reply mode List\n");
1480                 cm_toggle_menu_set_active_full(compose->ui_manager, "Menu/Options/ReplyMode/List", TRUE);
1481                 break;
1482         case COMPOSE_REPLY_TO_ADDRESS:
1483                 cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Options/ReplyMode", FALSE);
1484                 break;
1485         default:
1486                 break;
1487         }
1488         return compose;
1489 }
1490
1491 static Compose *compose_reply(MsgInfo *msginfo,
1492                                    ComposeQuoteMode quote_mode,
1493                                    gboolean to_all,
1494                                    gboolean to_ml,
1495                                    gboolean to_sender,
1496                                    const gchar *body)
1497 {
1498         return compose_generic_reply(msginfo, quote_mode, to_all, to_ml,
1499                               to_sender, FALSE, body);
1500 }
1501
1502 static Compose *compose_followup_and_reply_to(MsgInfo *msginfo,
1503                                    ComposeQuoteMode quote_mode,
1504                                    gboolean to_all,
1505                                    gboolean to_sender,
1506                                    const gchar *body)
1507 {
1508         return compose_generic_reply(msginfo, quote_mode, to_all, FALSE,
1509                               to_sender, TRUE, body);
1510 }
1511
1512 static void compose_extract_original_charset(Compose *compose)
1513 {
1514         MsgInfo *info = NULL;
1515         if (compose->replyinfo) {
1516                 info = compose->replyinfo;
1517         } else if (compose->fwdinfo) {
1518                 info = compose->fwdinfo;
1519         } else if (compose->targetinfo) {
1520                 info = compose->targetinfo;
1521         }
1522         if (info) {
1523                 MimeInfo *mimeinfo = procmime_scan_message_short(info);
1524                 MimeInfo *partinfo = mimeinfo;
1525                 while (partinfo && partinfo->type != MIMETYPE_TEXT)
1526                         partinfo = procmime_mimeinfo_next(partinfo);
1527                 if (partinfo) {
1528                         compose->orig_charset =
1529                                 g_strdup(procmime_mimeinfo_get_parameter(
1530                                                 partinfo, "charset"));
1531                 }
1532                 procmime_mimeinfo_free_all(mimeinfo);
1533         }
1534 }
1535
1536 #define SIGNAL_BLOCK(buffer) {                                  \
1537         g_signal_handlers_block_by_func(G_OBJECT(buffer),       \
1538                                 G_CALLBACK(compose_changed_cb), \
1539                                 compose);                       \
1540         g_signal_handlers_block_by_func(G_OBJECT(buffer),       \
1541                                 G_CALLBACK(text_inserted),      \
1542                                 compose);                       \
1543 }
1544
1545 #define SIGNAL_UNBLOCK(buffer) {                                \
1546         g_signal_handlers_unblock_by_func(G_OBJECT(buffer),     \
1547                                 G_CALLBACK(compose_changed_cb), \
1548                                 compose);                       \
1549         g_signal_handlers_unblock_by_func(G_OBJECT(buffer),     \
1550                                 G_CALLBACK(text_inserted),      \
1551                                 compose);                       \
1552 }
1553
1554 static Compose *compose_generic_reply(MsgInfo *msginfo,
1555                                   ComposeQuoteMode quote_mode,
1556                                   gboolean to_all, gboolean to_ml,
1557                                   gboolean to_sender,
1558                                   gboolean followup_and_reply_to,
1559                                   const gchar *body)
1560 {
1561         Compose *compose;
1562         PrefsAccount *account = NULL;
1563         GtkTextView *textview;
1564         GtkTextBuffer *textbuf;
1565         gboolean quote = FALSE;
1566         const gchar *qmark = NULL;
1567         const gchar *body_fmt = NULL;
1568         gchar *s_system = NULL;
1569         START_TIMING("");
1570         cm_return_val_if_fail(msginfo != NULL, NULL);
1571         cm_return_val_if_fail(msginfo->folder != NULL, NULL);
1572
1573         account = account_get_reply_account(msginfo, prefs_common.reply_account_autosel);
1574
1575         cm_return_val_if_fail(account != NULL, NULL);
1576
1577         compose = compose_create(account, msginfo->folder, COMPOSE_REPLY, FALSE);
1578
1579         compose->updating = TRUE;
1580
1581         cm_toggle_menu_set_active_full(compose->ui_manager, "Menu/Options/RemoveReferences", FALSE);
1582         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Options/RemoveReferences", TRUE);
1583
1584         compose->replyinfo = procmsg_msginfo_get_full_info(msginfo);
1585         if (!compose->replyinfo)
1586                 compose->replyinfo = procmsg_msginfo_copy(msginfo);
1587
1588         compose_extract_original_charset(compose);
1589
1590         if (msginfo->folder && msginfo->folder->ret_rcpt)
1591                 cm_toggle_menu_set_active_full(compose->ui_manager, "Menu/Options/RequestRetRcpt", TRUE);
1592
1593         /* Set save folder */
1594         if (msginfo->folder && msginfo->folder->prefs && msginfo->folder->prefs->save_copy_to_folder) {
1595                 gchar *folderidentifier;
1596
1597                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(compose->savemsg_checkbtn), TRUE);
1598                 folderidentifier = folder_item_get_identifier(msginfo->folder);
1599                 compose_set_save_to(compose, folderidentifier);
1600                 g_free(folderidentifier);
1601         }
1602
1603         if (compose_parse_header(compose, msginfo) < 0) {
1604                 compose->updating = FALSE;
1605                 compose_destroy(compose);
1606                 return NULL;
1607         }
1608
1609         /* override from name according to folder properties */
1610         if (msginfo->folder && msginfo->folder->prefs &&
1611                 msginfo->folder->prefs->reply_with_format &&
1612                 msginfo->folder->prefs->reply_override_from_format &&
1613                 *msginfo->folder->prefs->reply_override_from_format != '\0') {
1614
1615                 gchar *tmp = NULL;
1616                 gchar *buf = NULL;
1617
1618                 /* decode \-escape sequences in the internal representation of the quote format */
1619                 tmp = g_malloc(strlen(msginfo->folder->prefs->reply_override_from_format)+1);
1620                 pref_get_unescaped_pref(tmp, msginfo->folder->prefs->reply_override_from_format);
1621
1622 #ifdef USE_ENCHANT
1623                 quote_fmt_init(compose->replyinfo, NULL, NULL, FALSE, compose->account, FALSE,
1624                                 compose->gtkaspell);
1625 #else
1626                 quote_fmt_init(compose->replyinfo, NULL, NULL, FALSE, compose->account, FALSE);
1627 #endif
1628                 quote_fmt_scan_string(tmp);
1629                 quote_fmt_parse();
1630
1631                 buf = quote_fmt_get_buffer();
1632                 if (buf == NULL)
1633                         alertpanel_error(_("The \"From\" field of the \"Reply\" template contains an invalid email address."));
1634                 else
1635                         gtk_entry_set_text(GTK_ENTRY(compose->from_name), buf);
1636                 quote_fmt_reset_vartable();
1637
1638                 g_free(tmp);
1639         }
1640
1641         textview = (GTK_TEXT_VIEW(compose->text));
1642         textbuf = gtk_text_view_get_buffer(textview);
1643         compose_create_tags(textview, compose);
1644
1645         undo_block(compose->undostruct);
1646 #ifdef USE_ENCHANT
1647         compose_set_dictionaries_from_folder_prefs(compose, msginfo->folder);
1648         gtkaspell_block_check(compose->gtkaspell);
1649 #endif
1650
1651         if (quote_mode == COMPOSE_QUOTE_FORCED ||
1652                         (quote_mode == COMPOSE_QUOTE_CHECK && prefs_common.reply_with_quote)) {
1653                 /* use the reply format of folder (if enabled), or the account's one
1654                    (if enabled) or fallback to the global reply format, which is always
1655                    enabled (even if empty), and use the relevant quotemark */
1656                 quote = TRUE;
1657                 if (msginfo->folder && msginfo->folder->prefs &&
1658                                 msginfo->folder->prefs->reply_with_format) {
1659                         qmark = msginfo->folder->prefs->reply_quotemark;
1660                         body_fmt = msginfo->folder->prefs->reply_body_format;
1661
1662                 } else if (account->reply_with_format) {
1663                         qmark = account->reply_quotemark;
1664                         body_fmt = account->reply_body_format;
1665
1666                 } else {
1667                         qmark = prefs_common.quotemark;
1668                         if (prefs_common.quotefmt && *prefs_common.quotefmt)
1669                                 body_fmt = gettext(prefs_common.quotefmt);
1670                         else
1671                                 body_fmt = "";
1672                 }
1673         }
1674
1675         if (quote) {
1676                 /* empty quotemark is not allowed */
1677                 if (qmark == NULL || *qmark == '\0')
1678                         qmark = "> ";
1679                 compose_quote_fmt(compose, compose->replyinfo,
1680                                   body_fmt, qmark, body, FALSE, TRUE,
1681                                           _("The body of the \"Reply\" template has an error at line %d."));
1682                 compose_attach_from_list(compose, quote_fmt_get_attachments_list(), FALSE);
1683                 quote_fmt_reset_vartable();
1684         }
1685
1686         if (MSG_IS_ENCRYPTED(compose->replyinfo->flags)) {
1687                 compose_force_encryption(compose, account, FALSE, s_system);
1688         }
1689
1690         privacy_msginfo_get_signed_state(compose->replyinfo, &s_system);
1691         if (MSG_IS_SIGNED(compose->replyinfo->flags) && account->default_sign_reply) {
1692                 compose_force_signing(compose, account, s_system);
1693         }
1694         g_free(s_system);
1695
1696         SIGNAL_BLOCK(textbuf);
1697
1698         if (account->auto_sig)
1699                 compose_insert_sig(compose, FALSE);
1700
1701         compose_wrap_all(compose);
1702
1703 #ifdef USE_ENCHANT
1704         if (compose->gtkaspell && compose->gtkaspell->check_while_typing)
1705                 gtkaspell_highlight_all(compose->gtkaspell);
1706         gtkaspell_unblock_check(compose->gtkaspell);
1707 #endif
1708         SIGNAL_UNBLOCK(textbuf);
1709
1710         gtk_widget_grab_focus(compose->text);
1711
1712         undo_unblock(compose->undostruct);
1713
1714         if (prefs_common.auto_exteditor)
1715                 compose_exec_ext_editor(compose);
1716
1717         compose->modified = FALSE;
1718         compose_set_title(compose);
1719
1720         compose->updating = FALSE;
1721         compose->draft_timeout_tag = COMPOSE_DRAFT_TIMEOUT_UNSET; /* desinhibit auto-drafting after loading */
1722         SCROLL_TO_CURSOR(compose);
1723
1724         if (compose->deferred_destroy) {
1725                 compose_destroy(compose);
1726                 return NULL;
1727         }
1728         END_TIMING();
1729
1730         return compose;
1731 }
1732
1733 #define INSERT_FW_HEADER(var, hdr) \
1734 if (msginfo->var && *msginfo->var) { \
1735         gtk_stext_insert(text, NULL, NULL, NULL, hdr, -1); \
1736         gtk_stext_insert(text, NULL, NULL, NULL, msginfo->var, -1); \
1737         gtk_stext_insert(text, NULL, NULL, NULL, "\n", 1); \
1738 }
1739
1740 Compose *compose_forward(PrefsAccount *account, MsgInfo *msginfo,
1741                          gboolean as_attach, const gchar *body,
1742                          gboolean no_extedit,
1743                          gboolean batch)
1744 {
1745         Compose *compose;
1746         GtkTextView *textview;
1747         GtkTextBuffer *textbuf;
1748         gint cursor_pos = -1;
1749         ComposeMode mode;
1750
1751         cm_return_val_if_fail(msginfo != NULL, NULL);
1752         cm_return_val_if_fail(msginfo->folder != NULL, NULL);
1753
1754         if (!account &&
1755             !(account = compose_guess_forward_account_from_msginfo
1756                                 (msginfo)))
1757                 account = cur_account;
1758
1759         if (!prefs_common.forward_as_attachment)
1760                 mode = COMPOSE_FORWARD_INLINE;
1761         else
1762                 mode = COMPOSE_FORWARD;
1763         compose = compose_create(account, msginfo->folder, mode, batch);
1764
1765         compose->updating = TRUE;
1766         compose->fwdinfo = procmsg_msginfo_get_full_info(msginfo);
1767         if (!compose->fwdinfo)
1768                 compose->fwdinfo = procmsg_msginfo_copy(msginfo);
1769
1770         compose_extract_original_charset(compose);
1771
1772         if (msginfo->subject && *msginfo->subject) {
1773                 gchar *buf, *buf2, *p;
1774
1775                 buf = p = g_strdup(msginfo->subject);
1776                 p += subject_get_prefix_length(p);
1777                 memmove(buf, p, strlen(p) + 1);
1778
1779                 buf2 = g_strdup_printf("Fw: %s", buf);
1780                 gtk_entry_set_text(GTK_ENTRY(compose->subject_entry), buf2);
1781
1782                 g_free(buf);
1783                 g_free(buf2);
1784         }
1785
1786         /* override from name according to folder properties */
1787         if (msginfo->folder && msginfo->folder->prefs &&
1788                 msginfo->folder->prefs->forward_with_format &&
1789                 msginfo->folder->prefs->forward_override_from_format &&
1790                 *msginfo->folder->prefs->forward_override_from_format != '\0') {
1791
1792                 gchar *tmp = NULL;
1793                 gchar *buf = NULL;
1794                 MsgInfo *full_msginfo = NULL;
1795
1796                 if (!as_attach)
1797                         full_msginfo = procmsg_msginfo_get_full_info(msginfo);
1798                 if (!full_msginfo)
1799                         full_msginfo = procmsg_msginfo_copy(msginfo);
1800
1801                 /* decode \-escape sequences in the internal representation of the quote format */
1802                 tmp = g_malloc(strlen(msginfo->folder->prefs->forward_override_from_format)+1);
1803                 pref_get_unescaped_pref(tmp, msginfo->folder->prefs->forward_override_from_format);
1804
1805 #ifdef USE_ENCHANT
1806                 gtkaspell_block_check(compose->gtkaspell);
1807                 quote_fmt_init(full_msginfo, NULL, NULL, FALSE, compose->account, FALSE,
1808                                 compose->gtkaspell);
1809 #else
1810                 quote_fmt_init(full_msginfo, NULL, NULL, FALSE, compose->account, FALSE);
1811 #endif
1812                 quote_fmt_scan_string(tmp);
1813                 quote_fmt_parse();
1814
1815                 buf = quote_fmt_get_buffer();
1816                 if (buf == NULL)
1817                         alertpanel_error(_("The \"From\" field of the \"Forward\" template contains an invalid email address."));
1818                 else
1819                         gtk_entry_set_text(GTK_ENTRY(compose->from_name), buf);
1820                 quote_fmt_reset_vartable();
1821
1822                 g_free(tmp);
1823                 procmsg_msginfo_free(full_msginfo);
1824         }
1825
1826         textview = GTK_TEXT_VIEW(compose->text);
1827         textbuf = gtk_text_view_get_buffer(textview);
1828         compose_create_tags(textview, compose);
1829
1830         undo_block(compose->undostruct);
1831         if (as_attach) {
1832                 gchar *msgfile;
1833
1834                 msgfile = procmsg_get_message_file(msginfo);
1835                 if (!is_file_exist(msgfile))
1836                         g_warning("%s: file not exist\n", msgfile);
1837                 else
1838                         compose_attach_append(compose, msgfile, msgfile,
1839                                               "message/rfc822", NULL);
1840
1841                 g_free(msgfile);
1842         } else {
1843                 const gchar *qmark = NULL;
1844                 const gchar *body_fmt = NULL;
1845                 MsgInfo *full_msginfo;
1846
1847                 full_msginfo = procmsg_msginfo_get_full_info(msginfo);
1848                 if (!full_msginfo)
1849                         full_msginfo = procmsg_msginfo_copy(msginfo);
1850
1851                 /* use the forward format of folder (if enabled), or the account's one
1852                    (if enabled) or fallback to the global forward format, which is always
1853                    enabled (even if empty), and use the relevant quotemark */
1854                 if (msginfo->folder && msginfo->folder->prefs &&
1855                                 msginfo->folder->prefs->forward_with_format) {
1856                         qmark = msginfo->folder->prefs->forward_quotemark;
1857                         body_fmt = msginfo->folder->prefs->forward_body_format;
1858
1859                 } else if (account->forward_with_format) {
1860                         qmark = account->forward_quotemark;
1861                         body_fmt = account->forward_body_format;
1862
1863                 } else {
1864                         qmark = prefs_common.fw_quotemark;
1865                         if (prefs_common.fw_quotefmt && *prefs_common.fw_quotefmt)
1866                                 body_fmt = gettext(prefs_common.fw_quotefmt);
1867                         else
1868                                 body_fmt = "";
1869                 }
1870
1871                 /* empty quotemark is not allowed */
1872                 if (qmark == NULL || *qmark == '\0')
1873                         qmark = "> ";
1874
1875                 compose_quote_fmt(compose, full_msginfo,
1876                                   body_fmt, qmark, body, FALSE, TRUE,
1877                                           _("The body of the \"Forward\" template has an error at line %d."));
1878                 compose_attach_from_list(compose, quote_fmt_get_attachments_list(), FALSE);
1879                 quote_fmt_reset_vartable();
1880                 compose_attach_parts(compose, msginfo);
1881
1882                 procmsg_msginfo_free(full_msginfo);
1883         }
1884
1885         SIGNAL_BLOCK(textbuf);
1886
1887         if (account->auto_sig)
1888                 compose_insert_sig(compose, FALSE);
1889
1890         compose_wrap_all(compose);
1891
1892 #ifdef USE_ENCHANT
1893         if (compose->gtkaspell && compose->gtkaspell->check_while_typing)
1894                 gtkaspell_highlight_all(compose->gtkaspell);
1895         gtkaspell_unblock_check(compose->gtkaspell);
1896 #endif
1897         SIGNAL_UNBLOCK(textbuf);
1898
1899         cursor_pos = quote_fmt_get_cursor_pos();
1900         if (cursor_pos == -1)
1901                 gtk_widget_grab_focus(compose->header_last->entry);
1902         else
1903                 gtk_widget_grab_focus(compose->text);
1904
1905         if (!no_extedit && prefs_common.auto_exteditor)
1906                 compose_exec_ext_editor(compose);
1907
1908         /*save folder*/
1909         if (msginfo->folder && msginfo->folder->prefs && msginfo->folder->prefs->save_copy_to_folder) {
1910                 gchar *folderidentifier;
1911
1912                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(compose->savemsg_checkbtn), TRUE);
1913                 folderidentifier = folder_item_get_identifier(msginfo->folder);
1914                 compose_set_save_to(compose, folderidentifier);
1915                 g_free(folderidentifier);
1916         }
1917
1918         undo_unblock(compose->undostruct);
1919
1920         compose->modified = FALSE;
1921         compose_set_title(compose);
1922
1923         compose->updating = FALSE;
1924         compose->draft_timeout_tag = COMPOSE_DRAFT_TIMEOUT_UNSET; /* desinhibit auto-drafting after loading */
1925         SCROLL_TO_CURSOR(compose);
1926
1927         if (compose->deferred_destroy) {
1928                 compose_destroy(compose);
1929                 return NULL;
1930         }
1931
1932         hooks_invoke(COMPOSE_CREATED_HOOKLIST, compose);
1933
1934         return compose;
1935 }
1936
1937 #undef INSERT_FW_HEADER
1938
1939 static Compose *compose_forward_multiple(PrefsAccount *account, GSList *msginfo_list)
1940 {
1941         Compose *compose;
1942         GtkTextView *textview;
1943         GtkTextBuffer *textbuf;
1944         GtkTextIter iter;
1945         GSList *msginfo;
1946         gchar *msgfile;
1947         gboolean single_mail = TRUE;
1948
1949         cm_return_val_if_fail(msginfo_list != NULL, NULL);
1950
1951         if (g_slist_length(msginfo_list) > 1)
1952                 single_mail = FALSE;
1953
1954         for (msginfo = msginfo_list; msginfo != NULL; msginfo = msginfo->next)
1955                 if (((MsgInfo *)msginfo->data)->folder == NULL)
1956                         return NULL;
1957
1958         /* guess account from first selected message */
1959         if (!account &&
1960             !(account = compose_guess_forward_account_from_msginfo
1961                                 (msginfo_list->data)))
1962                 account = cur_account;
1963
1964         cm_return_val_if_fail(account != NULL, NULL);
1965
1966         for (msginfo = msginfo_list; msginfo != NULL; msginfo = msginfo->next) {
1967                 if (msginfo->data) {
1968                         MSG_UNSET_PERM_FLAGS(((MsgInfo *)msginfo->data)->flags, MSG_REPLIED);
1969                         MSG_SET_PERM_FLAGS(((MsgInfo *)msginfo->data)->flags, MSG_FORWARDED);
1970                 }
1971         }
1972
1973         if (msginfo_list == NULL || msginfo_list->data == NULL) {
1974                 g_warning("no msginfo_list");
1975                 return NULL;
1976         }
1977
1978         compose = compose_create(account, ((MsgInfo *)msginfo_list->data)->folder, COMPOSE_FORWARD, FALSE);
1979
1980         compose->updating = TRUE;
1981
1982         /* override from name according to folder properties */
1983         if (msginfo_list->data) {
1984                 MsgInfo *msginfo = msginfo_list->data;
1985
1986                 if (msginfo->folder && msginfo->folder->prefs &&
1987                         msginfo->folder->prefs->forward_with_format &&
1988                         msginfo->folder->prefs->forward_override_from_format &&
1989                         *msginfo->folder->prefs->forward_override_from_format != '\0') {
1990
1991                         gchar *tmp = NULL;
1992                         gchar *buf = NULL;
1993
1994                         /* decode \-escape sequences in the internal representation of the quote format */
1995                         tmp = g_malloc(strlen(msginfo->folder->prefs->forward_override_from_format)+1);
1996                         pref_get_unescaped_pref(tmp, msginfo->folder->prefs->forward_override_from_format);
1997
1998 #ifdef USE_ENCHANT
1999                         quote_fmt_init(msginfo, NULL, NULL, FALSE, compose->account, FALSE,
2000                                         compose->gtkaspell);
2001 #else
2002                         quote_fmt_init(msginfo, NULL, NULL, FALSE, compose->account, FALSE);
2003 #endif
2004                         quote_fmt_scan_string(tmp);
2005                         quote_fmt_parse();
2006
2007                         buf = quote_fmt_get_buffer();
2008                         if (buf == NULL)
2009                                 alertpanel_error(_("The \"From\" field of the \"Forward\" template contains an invalid email address."));
2010                         else
2011                                 gtk_entry_set_text(GTK_ENTRY(compose->from_name), buf);
2012                         quote_fmt_reset_vartable();
2013
2014                         g_free(tmp);
2015                 }
2016         }
2017
2018         textview = GTK_TEXT_VIEW(compose->text);
2019         textbuf = gtk_text_view_get_buffer(textview);
2020         compose_create_tags(textview, compose);
2021
2022         undo_block(compose->undostruct);
2023         for (msginfo = msginfo_list; msginfo != NULL; msginfo = msginfo->next) {
2024                 msgfile = procmsg_get_message_file((MsgInfo *)msginfo->data);
2025
2026                 if (!is_file_exist(msgfile))
2027                         g_warning("%s: file not exist\n", msgfile);
2028                 else
2029                         compose_attach_append(compose, msgfile, msgfile,
2030                                 "message/rfc822", NULL);
2031                 g_free(msgfile);
2032         }
2033
2034         if (single_mail) {
2035                 MsgInfo *info = (MsgInfo *)msginfo_list->data;
2036                 if (info->subject && *info->subject) {
2037                         gchar *buf, *buf2, *p;
2038
2039                         buf = p = g_strdup(info->subject);
2040                         p += subject_get_prefix_length(p);
2041                         memmove(buf, p, strlen(p) + 1);
2042
2043                         buf2 = g_strdup_printf("Fw: %s", buf);
2044                         gtk_entry_set_text(GTK_ENTRY(compose->subject_entry), buf2);
2045
2046                         g_free(buf);
2047                         g_free(buf2);
2048                 }
2049         } else {
2050                 gtk_entry_set_text(GTK_ENTRY(compose->subject_entry),
2051                         _("Fw: multiple emails"));
2052         }
2053
2054         SIGNAL_BLOCK(textbuf);
2055
2056         if (account->auto_sig)
2057                 compose_insert_sig(compose, FALSE);
2058
2059         compose_wrap_all(compose);
2060
2061         SIGNAL_UNBLOCK(textbuf);
2062
2063         gtk_text_buffer_get_start_iter(textbuf, &iter);
2064         gtk_text_buffer_place_cursor(textbuf, &iter);
2065
2066         gtk_widget_grab_focus(compose->header_last->entry);
2067         undo_unblock(compose->undostruct);
2068         compose->modified = FALSE;
2069         compose_set_title(compose);
2070
2071         compose->updating = FALSE;
2072         compose->draft_timeout_tag = COMPOSE_DRAFT_TIMEOUT_UNSET; /* desinhibit auto-drafting after loading */
2073         SCROLL_TO_CURSOR(compose);
2074
2075         if (compose->deferred_destroy) {
2076                 compose_destroy(compose);
2077                 return NULL;
2078         }
2079
2080         hooks_invoke(COMPOSE_CREATED_HOOKLIST, compose);
2081
2082         return compose;
2083 }
2084
2085 static gboolean compose_is_sig_separator(Compose *compose, GtkTextBuffer *textbuf, GtkTextIter *iter)
2086 {
2087         GtkTextIter start = *iter;
2088         GtkTextIter end_iter;
2089         int start_pos = gtk_text_iter_get_offset(&start);
2090         gchar *str = NULL;
2091         if (!compose->account->sig_sep)
2092                 return FALSE;
2093
2094         gtk_text_buffer_get_iter_at_offset(textbuf, &end_iter,
2095                 start_pos+strlen(compose->account->sig_sep));
2096
2097         /* check sig separator */
2098         str = gtk_text_iter_get_text(&start, &end_iter);
2099         if (!strcmp(str, compose->account->sig_sep)) {
2100                 gchar *tmp = NULL;
2101                 /* check end of line (\n) */
2102                 gtk_text_buffer_get_iter_at_offset(textbuf, &start,
2103                         start_pos+strlen(compose->account->sig_sep));
2104                 gtk_text_buffer_get_iter_at_offset(textbuf, &end_iter,
2105                         start_pos+strlen(compose->account->sig_sep)+1);
2106                 tmp = gtk_text_iter_get_text(&start, &end_iter);
2107                 if (!strcmp(tmp,"\n")) {
2108                         g_free(str);
2109                         g_free(tmp);
2110                         return TRUE;
2111                 }
2112                 g_free(tmp);
2113         }
2114         g_free(str);
2115
2116         return FALSE;
2117 }
2118
2119 static gboolean compose_update_folder_hook(gpointer source, gpointer data)
2120 {
2121         FolderUpdateData *hookdata = (FolderUpdateData *)source;
2122         Compose *compose = (Compose *)data;
2123         FolderItem *old_item = NULL;
2124         FolderItem *new_item = NULL;
2125         gchar *old_id, *new_id;
2126
2127         if (!(hookdata->update_flags & FOLDER_REMOVE_FOLDERITEM)
2128          && !(hookdata->update_flags & FOLDER_MOVE_FOLDERITEM))
2129                 return FALSE;
2130
2131         old_item = hookdata->item;
2132         new_item = hookdata->item2;
2133
2134         old_id = folder_item_get_identifier(old_item);
2135         new_id = new_item ? folder_item_get_identifier(new_item) : g_strdup("NULL");
2136
2137         if (compose->targetinfo && compose->targetinfo->folder == old_item) {
2138                 debug_print("updating targetinfo folder: %s -> %s\n", old_id, new_id);
2139                 compose->targetinfo->folder = new_item;
2140         }
2141
2142         if (compose->replyinfo && compose->replyinfo->folder == old_item) {
2143                 debug_print("updating replyinfo folder: %s -> %s\n", old_id, new_id);
2144                 compose->replyinfo->folder = new_item;
2145         }
2146
2147         if (compose->fwdinfo && compose->fwdinfo->folder == old_item) {
2148                 debug_print("updating fwdinfo folder: %s -> %s\n", old_id, new_id);
2149                 compose->fwdinfo->folder = new_item;
2150         }
2151
2152         g_free(old_id);
2153         g_free(new_id);
2154         return FALSE;
2155 }
2156
2157 static void compose_colorize_signature(Compose *compose)
2158 {
2159         GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(compose->text));
2160         GtkTextIter iter;
2161         GtkTextIter end_iter;
2162         gtk_text_buffer_get_start_iter(buffer, &iter);
2163         while (gtk_text_iter_forward_line(&iter))
2164                 if (compose_is_sig_separator(compose, buffer, &iter)) {
2165                         gtk_text_buffer_get_end_iter(buffer, &end_iter);
2166                         gtk_text_buffer_apply_tag_by_name(buffer,"signature",&iter, &end_iter);
2167                 }
2168 }
2169
2170 #define BLOCK_WRAP() {                                                  \
2171         prev_autowrap = compose->autowrap;                              \
2172         buffer = gtk_text_view_get_buffer(                              \
2173                                         GTK_TEXT_VIEW(compose->text));  \
2174         compose->autowrap = FALSE;                                      \
2175                                                                         \
2176         g_signal_handlers_block_by_func(G_OBJECT(buffer),               \
2177                                 G_CALLBACK(compose_changed_cb),         \
2178                                 compose);                               \
2179         g_signal_handlers_block_by_func(G_OBJECT(buffer),               \
2180                                 G_CALLBACK(text_inserted),              \
2181                                 compose);                               \
2182 }
2183 #define UNBLOCK_WRAP() {                                                        \
2184         compose->autowrap = prev_autowrap;                                      \
2185         if (compose->autowrap) {                                                \
2186                 gint old = compose->draft_timeout_tag;                          \
2187                 compose->draft_timeout_tag = COMPOSE_DRAFT_TIMEOUT_FORBIDDEN;   \
2188                 compose_wrap_all(compose);                                      \
2189                 compose->draft_timeout_tag = old;                               \
2190         }                                                                       \
2191                                                                                 \
2192         g_signal_handlers_unblock_by_func(G_OBJECT(buffer),                     \
2193                                 G_CALLBACK(compose_changed_cb),                 \
2194                                 compose);                                       \
2195         g_signal_handlers_unblock_by_func(G_OBJECT(buffer),                     \
2196                                 G_CALLBACK(text_inserted),                      \
2197                                 compose);                                       \
2198 }
2199
2200 Compose *compose_reedit(MsgInfo *msginfo, gboolean batch)
2201 {
2202         Compose *compose = NULL;
2203         PrefsAccount *account = NULL;
2204         GtkTextView *textview;
2205         GtkTextBuffer *textbuf;
2206         GtkTextMark *mark;
2207         GtkTextIter iter;
2208         FILE *fp;
2209         gchar buf[BUFFSIZE];
2210         gboolean use_signing = FALSE;
2211         gboolean use_encryption = FALSE;
2212         gchar *privacy_system = NULL;
2213         int priority = PRIORITY_NORMAL;
2214         MsgInfo *replyinfo = NULL, *fwdinfo = NULL;
2215         gboolean autowrap = prefs_common.autowrap;
2216         gboolean autoindent = prefs_common.auto_indent;
2217         HeaderEntry *manual_headers = NULL;
2218
2219         cm_return_val_if_fail(msginfo != NULL, NULL);
2220         cm_return_val_if_fail(msginfo->folder != NULL, NULL);
2221
2222         if (compose_put_existing_to_front(msginfo)) {
2223                 return NULL;
2224         }
2225
2226         if (folder_has_parent_of_type(msginfo->folder, F_QUEUE) ||
2227             folder_has_parent_of_type(msginfo->folder, F_DRAFT) ||
2228             folder_has_parent_of_type(msginfo->folder, F_OUTBOX)) {
2229                 gchar queueheader_buf[BUFFSIZE];
2230                 gint id, param;
2231
2232                 /* Select Account from queue headers */
2233                 if (!procheader_get_header_from_msginfo(msginfo, queueheader_buf,
2234                                              sizeof(queueheader_buf), "X-Claws-Account-Id:")) {
2235                         id = atoi(&queueheader_buf[strlen("X-Claws-Account-Id:")]);
2236                         account = account_find_from_id(id);
2237                 }
2238                 if (!procheader_get_header_from_msginfo(msginfo, queueheader_buf,
2239                                              sizeof(queueheader_buf), "X-Sylpheed-Account-Id:")) {
2240                         id = atoi(&queueheader_buf[strlen("X-Sylpheed-Account-Id:")]);
2241                         account = account_find_from_id(id);
2242                 }
2243                 if (!account && !procheader_get_header_from_msginfo(msginfo, queueheader_buf,
2244                                              sizeof(queueheader_buf), "NAID:")) {
2245                         id = atoi(&queueheader_buf[strlen("NAID:")]);
2246                         account = account_find_from_id(id);
2247                 }
2248                 if (!account && !procheader_get_header_from_msginfo(msginfo, queueheader_buf,
2249                                                     sizeof(queueheader_buf), "MAID:")) {
2250                         id = atoi(&queueheader_buf[strlen("MAID:")]);
2251                         account = account_find_from_id(id);
2252                 }
2253                 if (!account && !procheader_get_header_from_msginfo(msginfo, queueheader_buf,
2254                                                                 sizeof(queueheader_buf), "S:")) {
2255                         account = account_find_from_address(queueheader_buf, FALSE);
2256                 }
2257                 if (!procheader_get_header_from_msginfo(msginfo, queueheader_buf,
2258                                              sizeof(queueheader_buf), "X-Claws-Sign:")) {
2259                         param = atoi(&queueheader_buf[strlen("X-Claws-Sign:")]);
2260                         use_signing = param;
2261
2262                 }
2263                 if (!procheader_get_header_from_msginfo(msginfo, queueheader_buf,
2264                                              sizeof(queueheader_buf), "X-Sylpheed-Sign:")) {
2265                         param = atoi(&queueheader_buf[strlen("X-Sylpheed-Sign:")]);
2266                         use_signing = param;
2267
2268                 }
2269                 if (!procheader_get_header_from_msginfo(msginfo, queueheader_buf,
2270                                              sizeof(queueheader_buf), "X-Claws-Encrypt:")) {
2271                         param = atoi(&queueheader_buf[strlen("X-Claws-Encrypt:")]);
2272                         use_encryption = param;
2273                 }
2274                 if (!procheader_get_header_from_msginfo(msginfo, queueheader_buf,
2275                                              sizeof(queueheader_buf), "X-Sylpheed-Encrypt:")) {
2276                         param = atoi(&queueheader_buf[strlen("X-Sylpheed-Encrypt:")]);
2277                         use_encryption = param;
2278                 }
2279                 if (!procheader_get_header_from_msginfo(msginfo, queueheader_buf,
2280                                              sizeof(queueheader_buf), "X-Claws-Auto-Wrapping:")) {
2281                         param = atoi(&queueheader_buf[strlen("X-Claws-Auto-Wrapping:")]);
2282                         autowrap = param;
2283                 }
2284                 if (!procheader_get_header_from_msginfo(msginfo, queueheader_buf,
2285                                              sizeof(queueheader_buf), "X-Claws-Auto-Indent:")) {
2286                         param = atoi(&queueheader_buf[strlen("X-Claws-Auto-Indent:")]);
2287                         autoindent = param;
2288                 }
2289                 if (!procheader_get_header_from_msginfo(msginfo, queueheader_buf,
2290                                             sizeof(queueheader_buf), "X-Claws-Privacy-System:")) {
2291                         privacy_system = g_strdup(&queueheader_buf[strlen("X-Claws-Privacy-System:")]);
2292                 }
2293                 if (!procheader_get_header_from_msginfo(msginfo, queueheader_buf,
2294                                             sizeof(queueheader_buf), "X-Sylpheed-Privacy-System:")) {
2295                         privacy_system = g_strdup(&queueheader_buf[strlen("X-Sylpheed-Privacy-System:")]);
2296                 }
2297                 if (!procheader_get_header_from_msginfo(msginfo, queueheader_buf,
2298                                              sizeof(queueheader_buf), "X-Priority: ")) {
2299                         param = atoi(&queueheader_buf[strlen("X-Priority: ")]); /* mind the space */
2300                         priority = param;
2301                 }
2302                 if (!procheader_get_header_from_msginfo(msginfo, queueheader_buf,
2303                                              sizeof(queueheader_buf), "RMID:")) {
2304                         gchar **tokens = g_strsplit(&queueheader_buf[strlen("RMID:")], "\t", 0);
2305                         if (tokens[0] && tokens[1] && tokens[2]) {
2306                                 FolderItem *orig_item = folder_find_item_from_identifier(tokens[0]);
2307                                 if (orig_item != NULL) {
2308                                         replyinfo = folder_item_get_msginfo_by_msgid(orig_item, tokens[2]);
2309                                 }
2310                         }
2311                         g_strfreev(tokens);
2312                 }
2313                 if (!procheader_get_header_from_msginfo(msginfo, queueheader_buf,
2314                                              sizeof(queueheader_buf), "FMID:")) {
2315                         gchar **tokens = g_strsplit(&queueheader_buf[strlen("FMID:")], "\t", 0);
2316                         if (tokens[0] && tokens[1] && tokens[2]) {
2317                                 FolderItem *orig_item = folder_find_item_from_identifier(tokens[0]);
2318                                 if (orig_item != NULL) {
2319                                         fwdinfo = folder_item_get_msginfo_by_msgid(orig_item, tokens[2]);
2320                                 }
2321                         }
2322                         g_strfreev(tokens);
2323                 }
2324                 /* Get manual headers */
2325                 if (!procheader_get_header_from_msginfo(msginfo, queueheader_buf, sizeof(queueheader_buf), "X-Claws-Manual-Headers:")) {
2326                         gchar *listmh = g_strdup(&queueheader_buf[strlen("X-Claws-Manual-Headers:")]);
2327                         if (*listmh != '\0') {
2328                                 debug_print("Got manual headers: %s\n", listmh);
2329                                 manual_headers = procheader_entries_from_str(listmh);
2330                         }
2331                         g_free(listmh);
2332                 }
2333         } else {
2334                 account = msginfo->folder->folder->account;
2335         }
2336
2337         if (!account && prefs_common.reedit_account_autosel) {
2338                 gchar from[BUFFSIZE];
2339                 if (!procheader_get_header_from_msginfo(msginfo, from, sizeof(from), "FROM:")) {
2340                         extract_address(from);
2341                         account = account_find_from_address(from, FALSE);
2342                 }
2343         }
2344         if (!account) {
2345                 account = cur_account;
2346         }
2347         cm_return_val_if_fail(account != NULL, NULL);
2348
2349         compose = compose_create(account, msginfo->folder, COMPOSE_REEDIT, batch);
2350
2351         cm_toggle_menu_set_active_full(compose->ui_manager, "Menu/Edit/AutoWrap", autowrap);
2352         cm_toggle_menu_set_active_full(compose->ui_manager, "Menu/Edit/AutoIndent", autoindent);
2353         compose->autowrap = autowrap;
2354         compose->replyinfo = replyinfo;
2355         compose->fwdinfo = fwdinfo;
2356
2357         compose->updating = TRUE;
2358         compose->priority = priority;
2359
2360         if (privacy_system != NULL) {
2361                 compose->privacy_system = privacy_system;
2362                 compose_use_signing(compose, use_signing);
2363                 compose_use_encryption(compose, use_encryption);
2364                 compose_update_privacy_system_menu_item(compose, FALSE);
2365         } else {
2366                 activate_privacy_system(compose, account, FALSE);
2367         }
2368
2369         compose->targetinfo = procmsg_msginfo_copy(msginfo);
2370
2371         compose_extract_original_charset(compose);
2372
2373         if (folder_has_parent_of_type(msginfo->folder, F_QUEUE) ||
2374             folder_has_parent_of_type(msginfo->folder, F_DRAFT) ||
2375             folder_has_parent_of_type(msginfo->folder, F_OUTBOX)) {
2376                 gchar queueheader_buf[BUFFSIZE];
2377
2378                 /* Set message save folder */
2379                 if (!procheader_get_header_from_msginfo(msginfo, queueheader_buf, sizeof(queueheader_buf), "SCF:")) {
2380                         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(compose->savemsg_checkbtn), TRUE);
2381                         compose_set_save_to(compose, &queueheader_buf[4]);
2382                 }
2383                 if (!procheader_get_header_from_msginfo(msginfo, queueheader_buf, sizeof(queueheader_buf), "RRCPT:")) {
2384                         gint active = atoi(&queueheader_buf[strlen("RRCPT:")]);
2385                         if (active) {
2386                                 cm_toggle_menu_set_active_full(compose->ui_manager, "Menu/Options/RequestRetRcpt", TRUE);
2387                         }
2388                 }
2389         }
2390
2391         if (compose_parse_header(compose, msginfo) < 0) {
2392                 compose->updating = FALSE;
2393                 compose_destroy(compose);
2394                 return NULL;
2395         }
2396         compose_reedit_set_entry(compose, msginfo);
2397
2398         textview = GTK_TEXT_VIEW(compose->text);
2399         textbuf = gtk_text_view_get_buffer(textview);
2400         compose_create_tags(textview, compose);
2401
2402         mark = gtk_text_buffer_get_insert(textbuf);
2403         gtk_text_buffer_get_iter_at_mark(textbuf, &iter, mark);
2404
2405         g_signal_handlers_block_by_func(G_OBJECT(textbuf),
2406                                         G_CALLBACK(compose_changed_cb),
2407                                         compose);
2408
2409         if (MSG_IS_ENCRYPTED(msginfo->flags)) {
2410                 fp = procmime_get_first_encrypted_text_content(msginfo);
2411                 if (fp) {
2412                         compose_force_encryption(compose, account, TRUE, NULL);
2413                 }
2414         } else {
2415                 fp = procmime_get_first_text_content(msginfo);
2416         }
2417         if (fp == NULL) {
2418                 g_warning("Can't get text part\n");
2419         }
2420
2421         if (fp != NULL) {
2422                 gboolean prev_autowrap;
2423                 GtkTextBuffer *buffer;
2424                 BLOCK_WRAP();
2425                 while (fgets(buf, sizeof(buf), fp) != NULL) {
2426                         strcrchomp(buf);
2427                         gtk_text_buffer_insert(textbuf, &iter, buf, -1);
2428                 }
2429                 UNBLOCK_WRAP();
2430                 fclose(fp);
2431         }
2432
2433         compose_attach_parts(compose, msginfo);
2434
2435         compose_colorize_signature(compose);
2436
2437         g_signal_handlers_unblock_by_func(G_OBJECT(textbuf),
2438                                         G_CALLBACK(compose_changed_cb),
2439                                         compose);
2440
2441         if (manual_headers != NULL) {
2442                 if (compose_parse_manual_headers(compose, msginfo, manual_headers) < 0) {
2443                         procheader_entries_free(manual_headers);
2444                         compose->updating = FALSE;
2445                         compose_destroy(compose);
2446                         return NULL;
2447                 }
2448                 procheader_entries_free(manual_headers);
2449         }
2450
2451         gtk_widget_grab_focus(compose->text);
2452
2453         if (prefs_common.auto_exteditor) {
2454                 compose_exec_ext_editor(compose);
2455         }
2456         compose->modified = FALSE;
2457         compose_set_title(compose);
2458
2459         compose->updating = FALSE;
2460         compose->draft_timeout_tag = COMPOSE_DRAFT_TIMEOUT_UNSET; /* desinhibit auto-drafting after loading */
2461         SCROLL_TO_CURSOR(compose);
2462
2463         if (compose->deferred_destroy) {
2464                 compose_destroy(compose);
2465                 return NULL;
2466         }
2467
2468         compose->sig_str = account_get_signature_str(compose->account);
2469
2470         hooks_invoke(COMPOSE_CREATED_HOOKLIST, compose);
2471
2472         return compose;
2473 }
2474
2475 Compose *compose_redirect(PrefsAccount *account, MsgInfo *msginfo,
2476                                                  gboolean batch)
2477 {
2478         Compose *compose;
2479         gchar *filename;
2480         FolderItem *item;
2481
2482         cm_return_val_if_fail(msginfo != NULL, NULL);
2483
2484         if (!account)
2485                 account = account_get_reply_account(msginfo,
2486                                         prefs_common.reply_account_autosel);
2487         cm_return_val_if_fail(account != NULL, NULL);
2488
2489         compose = compose_create(account, msginfo->folder, COMPOSE_REDIRECT, batch);
2490
2491         compose->updating = TRUE;
2492
2493         compose_create_tags(GTK_TEXT_VIEW(compose->text), compose);
2494         compose->replyinfo = NULL;
2495         compose->fwdinfo = NULL;
2496
2497         compose_show_first_last_header(compose, TRUE);
2498
2499         gtk_widget_grab_focus(compose->header_last->entry);
2500
2501         filename = procmsg_get_message_file(msginfo);
2502
2503         if (filename == NULL) {
2504                 compose->updating = FALSE;
2505                 compose_destroy(compose);
2506
2507                 return NULL;
2508         }
2509
2510         compose->redirect_filename = filename;
2511
2512         /* Set save folder */
2513         item = msginfo->folder;
2514         if (item && item->prefs && item->prefs->save_copy_to_folder) {
2515                 gchar *folderidentifier;
2516
2517                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(compose->savemsg_checkbtn), prefs_common.savemsg);
2518                 folderidentifier = folder_item_get_identifier(item);
2519                 compose_set_save_to(compose, folderidentifier);
2520                 g_free(folderidentifier);
2521         }
2522
2523         compose_attach_parts(compose, msginfo);
2524
2525         if (msginfo->subject)
2526                 gtk_entry_set_text(GTK_ENTRY(compose->subject_entry),
2527                                    msginfo->subject);
2528         gtk_editable_set_editable(GTK_EDITABLE(compose->subject_entry), FALSE);
2529
2530         compose_quote_fmt(compose, msginfo, "%M", NULL, NULL, FALSE, FALSE,
2531                                           _("The body of the \"Redirect\" template has an error at line %d."));
2532         quote_fmt_reset_vartable();
2533         gtk_text_view_set_editable(GTK_TEXT_VIEW(compose->text), FALSE);
2534
2535         compose_colorize_signature(compose);
2536
2537
2538         cm_menu_set_sensitive_full(compose->ui_manager, "Popup/Compose/Add", FALSE);
2539         cm_menu_set_sensitive_full(compose->ui_manager, "Popup/Compose/Remove", FALSE);
2540         cm_menu_set_sensitive_full(compose->ui_manager, "Popup/Compose/Properties", FALSE);
2541
2542         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Message/Save", FALSE);
2543         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Message/InsertFile", FALSE);
2544         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Message/AttachFile", FALSE);
2545         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Message/InsertSig", FALSE);
2546         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Message/ReplaceSig", FALSE);
2547         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Edit", FALSE);
2548         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Options", FALSE);
2549         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Tools/ShowRuler", FALSE);
2550         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Tools/Actions", FALSE);
2551
2552         if (compose->toolbar->draft_btn)
2553                 gtk_widget_set_sensitive(compose->toolbar->draft_btn, FALSE);
2554         if (compose->toolbar->insert_btn)
2555                 gtk_widget_set_sensitive(compose->toolbar->insert_btn, FALSE);
2556         if (compose->toolbar->attach_btn)
2557                 gtk_widget_set_sensitive(compose->toolbar->attach_btn, FALSE);
2558         if (compose->toolbar->sig_btn)
2559                 gtk_widget_set_sensitive(compose->toolbar->sig_btn, FALSE);
2560         if (compose->toolbar->exteditor_btn)
2561                 gtk_widget_set_sensitive(compose->toolbar->exteditor_btn, FALSE);
2562         if (compose->toolbar->linewrap_current_btn)
2563                 gtk_widget_set_sensitive(compose->toolbar->linewrap_current_btn, FALSE);
2564         if (compose->toolbar->linewrap_all_btn)
2565                 gtk_widget_set_sensitive(compose->toolbar->linewrap_all_btn, FALSE);
2566
2567         compose->modified = FALSE;
2568         compose_set_title(compose);
2569         compose->updating = FALSE;
2570         compose->draft_timeout_tag = COMPOSE_DRAFT_TIMEOUT_UNSET; /* desinhibit auto-drafting after loading */
2571         SCROLL_TO_CURSOR(compose);
2572
2573         if (compose->deferred_destroy) {
2574                 compose_destroy(compose);
2575                 return NULL;
2576         }
2577
2578         hooks_invoke(COMPOSE_CREATED_HOOKLIST, compose);
2579
2580         return compose;
2581 }
2582
2583 const GList *compose_get_compose_list(void)
2584 {
2585         return compose_list;
2586 }
2587
2588 void compose_entry_append(Compose *compose, const gchar *address,
2589                           ComposeEntryType type, ComposePrefType pref_type)
2590 {
2591         const gchar *header;
2592         gchar *cur, *begin;
2593         gboolean in_quote = FALSE;
2594         if (!address || *address == '\0') return;
2595
2596         switch (type) {
2597         case COMPOSE_CC:
2598                 header = N_("Cc:");
2599                 break;
2600         case COMPOSE_BCC:
2601                 header = N_("Bcc:");
2602                 break;
2603         case COMPOSE_REPLYTO:
2604                 header = N_("Reply-To:");
2605                 break;
2606         case COMPOSE_NEWSGROUPS:
2607                 header = N_("Newsgroups:");
2608                 break;
2609         case COMPOSE_FOLLOWUPTO:
2610                 header = N_( "Followup-To:");
2611                 break;
2612         case COMPOSE_INREPLYTO:
2613                 header = N_( "In-Reply-To:");
2614                 break;
2615         case COMPOSE_TO:
2616         default:
2617                 header = N_("To:");
2618                 break;
2619         }
2620         header = prefs_common_translated_header_name(header);
2621
2622         cur = begin = (gchar *)address;
2623
2624         /* we separate the line by commas, but not if we're inside a quoted
2625          * string */
2626         while (*cur != '\0') {
2627                 if (*cur == '"')
2628                         in_quote = !in_quote;
2629                 if (*cur == ',' && !in_quote) {
2630                         gchar *tmp = g_strdup(begin);
2631                         gchar *o_tmp = tmp;
2632                         tmp[cur-begin]='\0';
2633                         cur++;
2634                         begin = cur;
2635                         while (*tmp == ' ' || *tmp == '\t')
2636                                 tmp++;
2637                         compose_add_header_entry(compose, header, tmp, pref_type);
2638                         g_free(o_tmp);
2639                         continue;
2640                 }
2641                 cur++;
2642         }
2643         if (begin < cur) {
2644                 gchar *tmp = g_strdup(begin);
2645                 gchar *o_tmp = tmp;
2646                 tmp[cur-begin]='\0';
2647                 while (*tmp == ' ' || *tmp == '\t')
2648                         tmp++;
2649                 compose_add_header_entry(compose, header, tmp, pref_type);
2650                 g_free(o_tmp);
2651         }
2652 }
2653
2654 static void compose_entry_mark_default_to(Compose *compose, const gchar *mailto)
2655 {
2656 #if !GTK_CHECK_VERSION(3, 0, 0)
2657         static GdkColor yellow;
2658         static GdkColor black;
2659         static gboolean yellow_initialised = FALSE;
2660 #else
2661         static GdkColor yellow = { (guint32)0, (guint16)0xf5, (guint16)0xf6, (guint16)0xbe };
2662         static GdkColor black = { (guint32)0, (guint16)0x0, (guint16)0x0, (guint16)0x0 };
2663 #endif
2664         GSList *h_list;
2665         GtkEntry *entry;
2666
2667 #if !GTK_CHECK_VERSION(3, 0, 0)
2668         if (!yellow_initialised) {
2669                 gdk_color_parse("#f5f6be", &yellow);
2670                 gdk_color_parse("#000000", &black);
2671                 yellow_initialised = gdk_colormap_alloc_color(
2672                         gdk_colormap_get_system(), &yellow, FALSE, TRUE);
2673                 yellow_initialised &= gdk_colormap_alloc_color(
2674                         gdk_colormap_get_system(), &black, FALSE, TRUE);
2675         }
2676 #endif
2677
2678         for (h_list = compose->header_list; h_list != NULL; h_list = h_list->next) {
2679                 entry = GTK_ENTRY(((ComposeHeaderEntry *)h_list->data)->entry);
2680                 if (gtk_entry_get_text(entry) &&
2681                     !g_utf8_collate(gtk_entry_get_text(entry), mailto)) {
2682 #if !GTK_CHECK_VERSION(3, 0, 0)
2683                         if (yellow_initialised) {
2684 #endif
2685                                 gtk_widget_modify_base(
2686                                         GTK_WIDGET(((ComposeHeaderEntry *)h_list->data)->entry),
2687                                         GTK_STATE_NORMAL, &yellow);
2688                                 gtk_widget_modify_text(
2689                                         GTK_WIDGET(((ComposeHeaderEntry *)h_list->data)->entry),
2690                                         GTK_STATE_NORMAL, &black);
2691 #if !GTK_CHECK_VERSION(3, 0, 0)
2692                         }
2693 #endif
2694                 }
2695         }
2696 }
2697
2698 void compose_toolbar_cb(gint action, gpointer data)
2699 {
2700         ToolbarItem *toolbar_item = (ToolbarItem*)data;
2701         Compose *compose = (Compose*)toolbar_item->parent;
2702
2703         cm_return_if_fail(compose != NULL);
2704
2705         switch(action) {
2706         case A_SEND:
2707                 compose_send_cb(NULL, compose);
2708                 break;
2709         case A_SENDL:
2710                 compose_send_later_cb(NULL, compose);
2711                 break;
2712         case A_DRAFT:
2713                 compose_draft(compose, COMPOSE_QUIT_EDITING);
2714                 break;
2715         case A_INSERT:
2716                 compose_insert_file_cb(NULL, compose);
2717                 break;
2718         case A_ATTACH:
2719                 compose_attach_cb(NULL, compose);
2720                 break;
2721         case A_SIG:
2722                 compose_insert_sig(compose, FALSE);
2723                 break;
2724         case A_REP_SIG:
2725                 compose_insert_sig(compose, TRUE);
2726                 break;
2727         case A_EXTEDITOR:
2728                 compose_ext_editor_cb(NULL, compose);
2729                 break;
2730         case A_LINEWRAP_CURRENT:
2731                 compose_beautify_paragraph(compose, NULL, TRUE);
2732                 break;
2733         case A_LINEWRAP_ALL:
2734                 compose_wrap_all_full(compose, TRUE);
2735                 break;
2736         case A_ADDRBOOK:
2737                 compose_address_cb(NULL, compose);
2738                 break;
2739 #ifdef USE_ENCHANT
2740         case A_CHECK_SPELLING:
2741                 compose_check_all(NULL, compose);
2742                 break;
2743 #endif
2744         default:
2745                 break;
2746         }
2747 }
2748
2749 static MailField compose_entries_set(Compose *compose, const gchar *mailto, ComposeEntryType to_type)
2750 {
2751         gchar *to = NULL;
2752         gchar *cc = NULL;
2753         gchar *bcc = NULL;
2754         gchar *subject = NULL;
2755         gchar *body = NULL;
2756         gchar *temp = NULL;
2757         gsize  len = 0;
2758         gchar **attach = NULL;
2759         gchar *inreplyto = NULL;
2760         MailField mfield = NO_FIELD_PRESENT;
2761
2762         /* get mailto parts but skip from */
2763         scan_mailto_url(mailto, NULL, &to, &cc, &bcc, &subject, &body, &attach, &inreplyto);
2764
2765         if (to) {
2766                 compose_entry_append(compose, to, to_type, PREF_MAILTO);
2767                 mfield = TO_FIELD_PRESENT;
2768         }
2769         if (cc)
2770                 compose_entry_append(compose, cc, COMPOSE_CC, PREF_MAILTO);
2771         if (bcc)
2772                 compose_entry_append(compose, bcc, COMPOSE_BCC, PREF_MAILTO);
2773         if (subject) {
2774                 if (!g_utf8_validate (subject, -1, NULL)) {
2775                         temp = g_locale_to_utf8 (subject, -1, NULL, &len, NULL);
2776                         gtk_entry_set_text(GTK_ENTRY(compose->subject_entry), temp);
2777                         g_free(temp);
2778                 } else {
2779                         gtk_entry_set_text(GTK_ENTRY(compose->subject_entry), subject);
2780                 }
2781                 mfield = SUBJECT_FIELD_PRESENT;
2782         }
2783         if (body) {
2784                 GtkTextView *text = GTK_TEXT_VIEW(compose->text);
2785                 GtkTextBuffer *buffer = gtk_text_view_get_buffer(text);
2786                 GtkTextMark *mark;
2787                 GtkTextIter iter;
2788                 gboolean prev_autowrap = compose->autowrap;
2789
2790                 compose->autowrap = FALSE;
2791
2792                 mark = gtk_text_buffer_get_insert(buffer);
2793                 gtk_text_buffer_get_iter_at_mark(buffer, &iter, mark);
2794
2795                 if (!g_utf8_validate (body, -1, NULL)) {
2796                         temp = g_locale_to_utf8 (body, -1, NULL, &len, NULL);
2797                         gtk_text_buffer_insert(buffer, &iter, temp, -1);
2798                         g_free(temp);
2799                 } else {
2800                         gtk_text_buffer_insert(buffer, &iter, body, -1);
2801                 }
2802                 gtk_text_buffer_insert(buffer, &iter, "\n", 1);
2803
2804                 compose->autowrap = prev_autowrap;
2805                 if (compose->autowrap)
2806                         compose_wrap_all(compose);
2807                 mfield = BODY_FIELD_PRESENT;
2808         }
2809
2810         if (attach) {
2811                 gint i = 0, att = 0;
2812                 gchar *warn_files = NULL;
2813                 while (attach[i] != NULL) {
2814                         gchar *utf8_filename = conv_filename_to_utf8(attach[i]);
2815                         if (utf8_filename) {
2816                                 if (compose_attach_append(compose, attach[i], utf8_filename, NULL, NULL)) {
2817                                         gchar *tmp = g_strdup_printf("%s%s\n",
2818                                                         warn_files?warn_files:"",
2819                                                         utf8_filename);
2820                                         g_free(warn_files);
2821                                         warn_files = tmp;
2822                                         att++;
2823                                 }
2824                                 g_free(utf8_filename);
2825                         } else {
2826                                 alertpanel_error(_("Couldn't attach a file (charset conversion failed)."));
2827                         }
2828                         i++;
2829                 }
2830                 if (warn_files) {
2831                         alertpanel_notice(ngettext(
2832                         "The following file has been attached: \n%s",
2833                         "The following files have been attached: \n%s", att), warn_files);
2834                         g_free(warn_files);
2835                 }
2836         }
2837         if (inreplyto)
2838                 compose_entry_append(compose, inreplyto, COMPOSE_INREPLYTO, PREF_MAILTO);
2839
2840         g_free(to);
2841         g_free(cc);
2842         g_free(bcc);
2843         g_free(subject);
2844         g_free(body);
2845         g_strfreev(attach);
2846         g_free(inreplyto);
2847
2848         return mfield;
2849 }
2850
2851 static gint compose_parse_header(Compose *compose, MsgInfo *msginfo)
2852 {
2853         static HeaderEntry hentry[] = {{"Reply-To:",    NULL, TRUE},
2854                                        {"Cc:",          NULL, TRUE},
2855                                        {"References:",  NULL, FALSE},
2856                                        {"Bcc:",         NULL, TRUE},
2857                                        {"Newsgroups:",  NULL, TRUE},
2858                                        {"Followup-To:", NULL, TRUE},
2859                                        {"List-Post:",   NULL, FALSE},
2860                                        {"X-Priority:",  NULL, FALSE},
2861                                        {NULL,           NULL, FALSE}};
2862
2863         enum
2864         {
2865                 H_REPLY_TO      = 0,
2866                 H_CC            = 1,
2867                 H_REFERENCES    = 2,
2868                 H_BCC           = 3,
2869                 H_NEWSGROUPS    = 4,
2870                 H_FOLLOWUP_TO   = 5,
2871                 H_LIST_POST     = 6,
2872                 H_X_PRIORITY    = 7
2873         };
2874
2875         FILE *fp;
2876
2877         cm_return_val_if_fail(msginfo != NULL, -1);
2878
2879         if ((fp = procmsg_open_message(msginfo)) == NULL) return -1;
2880         procheader_get_header_fields(fp, hentry);
2881         fclose(fp);
2882
2883         if (hentry[H_REPLY_TO].body != NULL) {
2884                 if (hentry[H_REPLY_TO].body[0] != '\0') {
2885                         compose->replyto =
2886                                 conv_unmime_header(hentry[H_REPLY_TO].body,
2887                                                    NULL, TRUE);
2888                 }
2889                 g_free(hentry[H_REPLY_TO].body);
2890                 hentry[H_REPLY_TO].body = NULL;
2891         }
2892         if (hentry[H_CC].body != NULL) {
2893                 compose->cc = conv_unmime_header(hentry[H_CC].body, NULL, TRUE);
2894                 g_free(hentry[H_CC].body);
2895                 hentry[H_CC].body = NULL;
2896         }
2897         if (hentry[H_REFERENCES].body != NULL) {
2898                 if (compose->mode == COMPOSE_REEDIT)
2899                         compose->references = hentry[H_REFERENCES].body;
2900                 else {
2901                         compose->references = compose_parse_references
2902                                 (hentry[H_REFERENCES].body, msginfo->msgid);
2903                         g_free(hentry[H_REFERENCES].body);
2904                 }
2905                 hentry[H_REFERENCES].body = NULL;
2906         }
2907         if (hentry[H_BCC].body != NULL) {
2908                 if (compose->mode == COMPOSE_REEDIT)
2909                         compose->bcc =
2910                                 conv_unmime_header(hentry[H_BCC].body, NULL, TRUE);
2911                 g_free(hentry[H_BCC].body);
2912                 hentry[H_BCC].body = NULL;
2913         }
2914         if (hentry[H_NEWSGROUPS].body != NULL) {
2915                 compose->newsgroups = hentry[H_NEWSGROUPS].body;
2916                 hentry[H_NEWSGROUPS].body = NULL;
2917         }
2918         if (hentry[H_FOLLOWUP_TO].body != NULL) {
2919                 if (hentry[H_FOLLOWUP_TO].body[0] != '\0') {
2920                         compose->followup_to =
2921                                 conv_unmime_header(hentry[H_FOLLOWUP_TO].body,
2922                                                    NULL, TRUE);
2923                 }
2924                 g_free(hentry[H_FOLLOWUP_TO].body);
2925                 hentry[H_FOLLOWUP_TO].body = NULL;
2926         }
2927         if (hentry[H_LIST_POST].body != NULL) {
2928                 gchar *to = NULL, *start = NULL;
2929
2930                 extract_address(hentry[H_LIST_POST].body);
2931                 if (hentry[H_LIST_POST].body[0] != '\0') {
2932                         start = strstr(hentry[H_LIST_POST].body, "mailto:");
2933
2934                         scan_mailto_url(start ? start : hentry[H_LIST_POST].body,
2935                                         NULL, &to, NULL, NULL, NULL, NULL, NULL, NULL);
2936
2937                         if (to) {
2938                                 g_free(compose->ml_post);
2939                                 compose->ml_post = to;
2940                         }
2941                 }
2942                 g_free(hentry[H_LIST_POST].body);
2943                 hentry[H_LIST_POST].body = NULL;
2944         }
2945
2946         /* CLAWS - X-Priority */
2947         if (compose->mode == COMPOSE_REEDIT)
2948                 if (hentry[H_X_PRIORITY].body != NULL) {
2949                         gint priority;
2950
2951                         priority = atoi(hentry[H_X_PRIORITY].body);
2952                         g_free(hentry[H_X_PRIORITY].body);
2953
2954                         hentry[H_X_PRIORITY].body = NULL;
2955
2956                         if (priority < PRIORITY_HIGHEST ||
2957                             priority > PRIORITY_LOWEST)
2958                                 priority = PRIORITY_NORMAL;
2959
2960                         compose->priority =  priority;
2961                 }
2962
2963         if (compose->mode == COMPOSE_REEDIT) {
2964                 if (msginfo->inreplyto && *msginfo->inreplyto)
2965                         compose->inreplyto = g_strdup(msginfo->inreplyto);
2966                 return 0;
2967         }
2968
2969         if (msginfo->msgid && *msginfo->msgid)
2970                 compose->inreplyto = g_strdup(msginfo->msgid);
2971
2972         if (!compose->references) {
2973                 if (msginfo->msgid && *msginfo->msgid) {
2974                         if (msginfo->inreplyto && *msginfo->inreplyto)
2975                                 compose->references =
2976                                         g_strdup_printf("<%s>\n\t<%s>",
2977                                                         msginfo->inreplyto,
2978                                                         msginfo->msgid);
2979                         else
2980                                 compose->references =
2981                                         g_strconcat("<", msginfo->msgid, ">",
2982                                                     NULL);
2983                 } else if (msginfo->inreplyto && *msginfo->inreplyto) {
2984                         compose->references =
2985                                 g_strconcat("<", msginfo->inreplyto, ">",
2986                                             NULL);
2987                 }
2988         }
2989
2990         return 0;
2991 }
2992
2993 static gint compose_parse_manual_headers(Compose *compose, MsgInfo *msginfo, HeaderEntry *entries)
2994 {
2995         FILE *fp;
2996         HeaderEntry *he;
2997
2998         cm_return_val_if_fail(msginfo != NULL, -1);
2999
3000         if ((fp = procmsg_open_message(msginfo)) == NULL) return -1;
3001         procheader_get_header_fields(fp, entries);
3002         fclose(fp);
3003
3004         he = entries;
3005         while (he != NULL && he->name != NULL) {
3006                 GtkTreeIter iter;
3007                 GtkListStore *model = NULL;
3008
3009                 debug_print("Adding manual header: %s with value %s\n", he->name, he->body);
3010                 model = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(compose->header_last->combo)));
3011                 COMBOBOX_ADD(model, he->name, COMPOSE_TO);
3012                 gtk_combo_box_set_active_iter(GTK_COMBO_BOX(compose->header_last->combo), &iter);
3013                 gtk_entry_set_text(GTK_ENTRY(compose->header_last->entry), he->body);
3014                 ++he;
3015         }
3016
3017         return 0;
3018 }
3019
3020 static gchar *compose_parse_references(const gchar *ref, const gchar *msgid)
3021 {
3022         GSList *ref_id_list, *cur;
3023         GString *new_ref;
3024         gchar *new_ref_str;
3025
3026         ref_id_list = references_list_append(NULL, ref);
3027         if (!ref_id_list) return NULL;
3028         if (msgid && *msgid)
3029                 ref_id_list = g_slist_append(ref_id_list, g_strdup(msgid));
3030
3031         for (;;) {
3032                 gint len = 0;
3033
3034                 for (cur = ref_id_list; cur != NULL; cur = cur->next)
3035                         /* "<" + Message-ID + ">" + CR+LF+TAB */
3036                         len += strlen((gchar *)cur->data) + 5;
3037
3038                 if (len > MAX_REFERENCES_LEN) {
3039                         /* remove second message-ID */
3040                         if (ref_id_list && ref_id_list->next &&
3041                             ref_id_list->next->next) {
3042                                 g_free(ref_id_list->next->data);
3043                                 ref_id_list = g_slist_remove
3044                                         (ref_id_list, ref_id_list->next->data);
3045                         } else {
3046                                 slist_free_strings_full(ref_id_list);
3047                                 return NULL;
3048                         }
3049                 } else
3050                         break;
3051         }
3052
3053         new_ref = g_string_new("");
3054         for (cur = ref_id_list; cur != NULL; cur = cur->next) {
3055                 if (new_ref->len > 0)
3056                         g_string_append(new_ref, "\n\t");
3057                 g_string_append_printf(new_ref, "<%s>", (gchar *)cur->data);
3058         }
3059
3060         slist_free_strings_full(ref_id_list);
3061
3062         new_ref_str = new_ref->str;
3063         g_string_free(new_ref, FALSE);
3064
3065         return new_ref_str;
3066 }
3067
3068 static gchar *compose_quote_fmt(Compose *compose, MsgInfo *msginfo,
3069                                 const gchar *fmt, const gchar *qmark,
3070                                 const gchar *body, gboolean rewrap,
3071                                 gboolean need_unescape,
3072                                 const gchar *err_msg)
3073 {
3074         MsgInfo* dummyinfo = NULL;
3075         gchar *quote_str = NULL;
3076         gchar *buf;
3077         gboolean prev_autowrap;
3078         const gchar *trimmed_body = body;
3079         gint cursor_pos = -1;
3080         GtkTextView *text = GTK_TEXT_VIEW(compose->text);
3081         GtkTextBuffer *buffer = gtk_text_view_get_buffer(text);
3082         GtkTextIter iter;
3083         GtkTextMark *mark;
3084
3085
3086         SIGNAL_BLOCK(buffer);
3087
3088         if (!msginfo) {
3089                 dummyinfo = compose_msginfo_new_from_compose(compose);
3090                 msginfo = dummyinfo;
3091         }
3092
3093         if (qmark != NULL) {
3094 #ifdef USE_ENCHANT
3095                 quote_fmt_init(msginfo, NULL, NULL, FALSE, compose->account, FALSE,
3096                                 compose->gtkaspell);
3097 #else
3098                 quote_fmt_init(msginfo, NULL, NULL, FALSE, compose->account, FALSE);
3099 #endif
3100                 quote_fmt_scan_string(qmark);
3101                 quote_fmt_parse();
3102
3103                 buf = quote_fmt_get_buffer();
3104                 if (buf == NULL)
3105                         alertpanel_error(_("The \"Quotation mark\" of the template is invalid."));
3106                 else
3107                         Xstrdup_a(quote_str, buf, goto error)
3108         }
3109
3110         if (fmt && *fmt != '\0') {
3111
3112                 if (trimmed_body)
3113                         while (*trimmed_body == '\n')
3114                                 trimmed_body++;
3115
3116 #ifdef USE_ENCHANT
3117                 quote_fmt_init(msginfo, quote_str, trimmed_body, FALSE, compose->account, FALSE,
3118                                 compose->gtkaspell);
3119 #else
3120                 quote_fmt_init(msginfo, quote_str, trimmed_body, FALSE, compose->account, FALSE);
3121 #endif
3122                 if (need_unescape) {
3123                         gchar *tmp = NULL;
3124
3125                         /* decode \-escape sequences in the internal representation of the quote format */
3126                         tmp = g_malloc(strlen(fmt)+1);
3127                         pref_get_unescaped_pref(tmp, fmt);
3128                         quote_fmt_scan_string(tmp);
3129                         quote_fmt_parse();
3130                         g_free(tmp);
3131                 } else {
3132                         quote_fmt_scan_string(fmt);
3133                         quote_fmt_parse();
3134                 }
3135
3136                 buf = quote_fmt_get_buffer();
3137                 if (buf == NULL) {
3138                         gint line = quote_fmt_get_line();
3139                         alertpanel_error(err_msg, line);
3140                         goto error;
3141                 }
3142         } else
3143                 buf = "";
3144
3145         prev_autowrap = compose->autowrap;
3146         compose->autowrap = FALSE;
3147
3148         mark = gtk_text_buffer_get_insert(buffer);
3149         gtk_text_buffer_get_iter_at_mark(buffer, &iter, mark);
3150         if (g_utf8_validate(buf, -1, NULL)) {
3151                 gtk_text_buffer_insert(buffer, &iter, buf, -1);
3152         } else {
3153                 gchar *tmpout = NULL;
3154                 tmpout = conv_codeset_strdup
3155                         (buf, conv_get_locale_charset_str_no_utf8(),
3156                          CS_INTERNAL);
3157                 if (!tmpout || !g_utf8_validate(tmpout, -1, NULL)) {
3158                         g_free(tmpout);
3159                         tmpout = g_malloc(strlen(buf)*2+1);
3160                         conv_localetodisp(tmpout, strlen(buf)*2+1, buf);
3161                 }
3162                 gtk_text_buffer_insert(buffer, &iter, tmpout, -1);
3163                 g_free(tmpout);
3164         }
3165
3166         cursor_pos = quote_fmt_get_cursor_pos();
3167         if (cursor_pos == -1)
3168                 cursor_pos = gtk_text_iter_get_offset(&iter);
3169         compose->set_cursor_pos = cursor_pos;
3170
3171         gtk_text_buffer_get_start_iter(buffer, &iter);
3172         gtk_text_buffer_get_iter_at_offset(buffer, &iter, cursor_pos);
3173         gtk_text_buffer_place_cursor(buffer, &iter);
3174
3175         compose->autowrap = prev_autowrap;
3176         if (compose->autowrap && rewrap)
3177                 compose_wrap_all(compose);
3178
3179         goto ok;
3180
3181 error:
3182         buf = NULL;
3183 ok:
3184         SIGNAL_UNBLOCK(buffer);
3185
3186         procmsg_msginfo_free( dummyinfo );
3187
3188         return buf;
3189 }
3190
3191 /* if ml_post is of type addr@host and from is of type
3192  * addr-anything@host, return TRUE
3193  */
3194 static gboolean is_subscription(const gchar *ml_post, const gchar *from)
3195 {
3196         gchar *left_ml = NULL;
3197         gchar *right_ml = NULL;
3198         gchar *left_from = NULL;
3199         gchar *right_from = NULL;
3200         gboolean result = FALSE;
3201
3202         if (!ml_post || !from)
3203                 return FALSE;
3204
3205         left_ml = g_strdup(ml_post);
3206         if (strstr(left_ml, "@")) {
3207                 right_ml = strstr(left_ml, "@")+1;
3208                 *(strstr(left_ml, "@")) = '\0';
3209         }
3210
3211         left_from = g_strdup(from);
3212         if (strstr(left_from, "@")) {
3213                 right_from = strstr(left_from, "@")+1;
3214                 *(strstr(left_from, "@")) = '\0';
3215         }
3216
3217         if (right_ml && right_from
3218         &&  !strncmp(left_from, left_ml, strlen(left_ml))
3219         &&  !strcmp(right_from, right_ml)) {
3220                 result = TRUE;
3221         }
3222         g_free(left_ml);
3223         g_free(left_from);
3224
3225         return result;
3226 }
3227
3228 static void compose_set_folder_prefs(Compose *compose, FolderItem *folder,
3229                                      gboolean respect_default_to)
3230 {
3231         if (!compose)
3232                 return;
3233         if (!folder || !folder->prefs)
3234                 return;
3235
3236         if (respect_default_to && folder->prefs->enable_default_to) {
3237                 compose_entry_append(compose, folder->prefs->default_to,
3238                                         COMPOSE_TO, PREF_FOLDER);
3239                 compose_entry_mark_default_to(compose, folder->prefs->default_to);
3240         }
3241         if (folder->prefs->enable_default_cc)
3242                 compose_entry_append(compose, folder->prefs->default_cc,
3243                                         COMPOSE_CC, PREF_FOLDER);
3244         if (folder->prefs->enable_default_bcc)
3245                 compose_entry_append(compose, folder->prefs->default_bcc,
3246                                         COMPOSE_BCC, PREF_FOLDER);
3247         if (folder->prefs->enable_default_replyto)
3248                 compose_entry_append(compose, folder->prefs->default_replyto,
3249                                         COMPOSE_REPLYTO, PREF_FOLDER);
3250 }
3251
3252 static void compose_reply_set_subject(Compose *compose, MsgInfo *msginfo)
3253 {
3254         gchar *buf, *buf2;
3255         gchar *p;
3256
3257         if (!compose || !msginfo)
3258                 return;
3259
3260         if (msginfo->subject && *msginfo->subject) {
3261                 buf = p = g_strdup(msginfo->subject);
3262                 p += subject_get_prefix_length(p);
3263                 memmove(buf, p, strlen(p) + 1);
3264
3265                 buf2 = g_strdup_printf("Re: %s", buf);
3266                 gtk_entry_set_text(GTK_ENTRY(compose->subject_entry), buf2);
3267
3268                 g_free(buf2);
3269                 g_free(buf);
3270         } else
3271                 gtk_entry_set_text(GTK_ENTRY(compose->subject_entry), "Re: ");
3272 }
3273
3274 static void compose_reply_set_entry(Compose *compose, MsgInfo *msginfo,
3275                                     gboolean to_all, gboolean to_ml,
3276                                     gboolean to_sender,
3277                                     gboolean followup_and_reply_to)
3278 {
3279         GSList *cc_list = NULL;
3280         GSList *cur;
3281         gchar *from = NULL;
3282         gchar *replyto = NULL;
3283         gchar *ac_email = NULL;
3284
3285         gboolean reply_to_ml = FALSE;
3286         gboolean default_reply_to = FALSE;
3287
3288         cm_return_if_fail(compose->account != NULL);
3289         cm_return_if_fail(msginfo != NULL);
3290
3291         reply_to_ml = to_ml && compose->ml_post;
3292
3293         default_reply_to = msginfo->folder &&
3294                 msginfo->folder->prefs->enable_default_reply_to;
3295
3296         if (compose->account->protocol != A_NNTP) {
3297                 compose_set_folder_prefs(compose, msginfo->folder, FALSE);
3298
3299                 if (reply_to_ml && !default_reply_to) {
3300
3301                         gboolean is_subscr = is_subscription(compose->ml_post,
3302                                                              msginfo->from);
3303                         if (!is_subscr) {
3304                                 /* normal answer to ml post with a reply-to */
3305                                 compose_entry_append(compose,
3306                                            compose->ml_post,
3307                                            COMPOSE_TO, PREF_ML);
3308                                 if (compose->replyto)
3309                                         compose_entry_append(compose,
3310                                                 compose->replyto,
3311                                                 COMPOSE_CC, PREF_ML);
3312                         } else {
3313                                 /* answer to subscription confirmation */
3314                                 if (compose->replyto)
3315                                         compose_entry_append(compose,
3316                                                 compose->replyto,
3317                                                 COMPOSE_TO, PREF_ML);
3318                                 else if (msginfo->from)
3319                                         compose_entry_append(compose,
3320                                                 msginfo->from,
3321                                                 COMPOSE_TO, PREF_ML);
3322                         }
3323                 }
3324                 else if (!(to_all || to_sender) && default_reply_to) {
3325                         compose_entry_append(compose,
3326                             msginfo->folder->prefs->default_reply_to,
3327                             COMPOSE_TO, PREF_FOLDER);
3328                         compose_entry_mark_default_to(compose,
3329                                 msginfo->folder->prefs->default_reply_to);
3330                 } else {
3331                         gchar *tmp1 = NULL;
3332                         if (!msginfo->from)
3333                                 return;
3334                         if (to_sender)
3335                                 compose_entry_append(compose, msginfo->from,
3336                                                      COMPOSE_TO, PREF_NONE);
3337                         else if (to_all) {
3338                                 Xstrdup_a(tmp1, msginfo->from, return);
3339                                 extract_address(tmp1);
3340                                 compose_entry_append(compose,
3341                                  (!account_find_from_address(tmp1, FALSE))
3342                                           ? msginfo->from :
3343                                           msginfo->to,
3344                                           COMPOSE_TO, PREF_NONE);
3345                         } else {
3346                                 if (!folder_has_parent_of_type(msginfo->folder, F_QUEUE) &&
3347                                     !folder_has_parent_of_type(msginfo->folder, F_OUTBOX) &&
3348                                     !folder_has_parent_of_type(msginfo->folder, F_DRAFT)) {
3349                                         if (compose->replyto) {
3350                                                 compose_entry_append(compose,
3351                                                         compose->replyto,
3352                                                         COMPOSE_TO, PREF_NONE);
3353                                         } else {
3354                                                 compose_entry_append(compose,
3355                                                           msginfo->from ? msginfo->from : "",
3356                                                           COMPOSE_TO, PREF_NONE);
3357                                         }
3358                                 } else {
3359                                         /* replying to own mail, use original recp */
3360                                         compose_entry_append(compose,
3361                                                   msginfo->to ? msginfo->to : "",
3362                                                   COMPOSE_TO, PREF_NONE);
3363                                         compose_entry_append(compose,
3364                                                   msginfo->cc ? msginfo->cc : "",
3365                                                   COMPOSE_CC, PREF_NONE);
3366                                 }
3367                         }
3368                 }
3369         } else {
3370                 if (to_sender || (compose->followup_to &&
3371                         !strncmp(compose->followup_to, "poster", 6)))
3372                         compose_entry_append
3373                                 (compose,
3374                                  (compose->replyto ? compose->replyto :
3375                                         msginfo->from ? msginfo->from : ""),
3376                                  COMPOSE_TO, PREF_NONE);
3377
3378                 else if (followup_and_reply_to || to_all) {
3379                         compose_entry_append
3380                                 (compose,
3381                                  (compose->replyto ? compose->replyto :
3382                                  msginfo->from ? msginfo->from : ""),
3383                                  COMPOSE_TO, PREF_NONE);
3384
3385                         compose_entry_append
3386                                 (compose,
3387                                  compose->followup_to ? compose->followup_to :
3388                                  compose->newsgroups ? compose->newsgroups : "",
3389                                  COMPOSE_NEWSGROUPS, PREF_NONE);
3390                 }
3391                 else
3392                         compose_entry_append
3393                                 (compose,
3394                                  compose->followup_to ? compose->followup_to :
3395                                  compose->newsgroups ? compose->newsgroups : "",
3396                                  COMPOSE_NEWSGROUPS, PREF_NONE);
3397         }
3398         compose_reply_set_subject(compose, msginfo);
3399
3400         if (to_ml && compose->ml_post) return;
3401         if (!to_all || compose->account->protocol == A_NNTP) return;
3402
3403         if (compose->replyto) {
3404                 Xstrdup_a(replyto, compose->replyto, return);
3405                 extract_address(replyto);
3406         }
3407         if (msginfo->from) {
3408                 Xstrdup_a(from, msginfo->from, return);
3409                 extract_address(from);
3410         }
3411
3412         if (replyto && from)
3413                 cc_list = address_list_append_with_comments(cc_list, from);
3414         if (to_all && msginfo->folder &&
3415             msginfo->folder->prefs->enable_default_reply_to)
3416                 cc_list = address_list_append_with_comments(cc_list,
3417                                 msginfo->folder->prefs->default_reply_to);
3418         cc_list = address_list_append_with_comments(cc_list, msginfo->to);
3419         cc_list = address_list_append_with_comments(cc_list, compose->cc);
3420
3421         ac_email = g_utf8_strdown(compose->account->address, -1);
3422
3423         if (cc_list) {
3424                 for (cur = cc_list; cur != NULL; cur = cur->next) {
3425                         gchar *addr = g_utf8_strdown(cur->data, -1);
3426                         extract_address(addr);
3427
3428                         if (strcmp(ac_email, addr))
3429                                 compose_entry_append(compose, (gchar *)cur->data,
3430                                                      COMPOSE_CC, PREF_NONE);
3431                         else
3432                                 debug_print("Cc address same as compose account's, ignoring\n");
3433
3434                         g_free(addr);
3435                 }
3436
3437                 slist_free_strings_full(cc_list);
3438         }
3439
3440         g_free(ac_email);
3441 }
3442
3443 #define SET_ENTRY(entry, str) \
3444 { \
3445         if (str && *str) \
3446                 gtk_entry_set_text(GTK_ENTRY(compose->entry), str); \
3447 }
3448
3449 #define SET_ADDRESS(type, str) \
3450 { \
3451         if (str && *str) \
3452                 compose_entry_append(compose, str, type, PREF_NONE); \
3453 }
3454
3455 static void compose_reedit_set_entry(Compose *compose, MsgInfo *msginfo)
3456 {
3457         cm_return_if_fail(msginfo != NULL);
3458
3459         SET_ENTRY(subject_entry, msginfo->subject);
3460         SET_ENTRY(from_name, msginfo->from);
3461         SET_ADDRESS(COMPOSE_TO, msginfo->to);
3462         SET_ADDRESS(COMPOSE_CC, compose->cc);
3463         SET_ADDRESS(COMPOSE_BCC, compose->bcc);
3464         SET_ADDRESS(COMPOSE_REPLYTO, compose->replyto);
3465         SET_ADDRESS(COMPOSE_NEWSGROUPS, compose->newsgroups);
3466         SET_ADDRESS(COMPOSE_FOLLOWUPTO, compose->followup_to);
3467
3468         compose_update_priority_menu_item(compose);
3469         compose_update_privacy_system_menu_item(compose, FALSE);
3470         compose_show_first_last_header(compose, TRUE);
3471 }
3472
3473 #undef SET_ENTRY
3474 #undef SET_ADDRESS
3475
3476 static void compose_insert_sig(Compose *compose, gboolean replace)
3477 {
3478         GtkTextView *text = GTK_TEXT_VIEW(compose->text);
3479         GtkTextBuffer *buffer = gtk_text_view_get_buffer(text);
3480         GtkTextMark *mark;
3481         GtkTextIter iter, iter_end;
3482         gint cur_pos, ins_pos;
3483         gboolean prev_autowrap;
3484         gboolean found = FALSE;
3485         gboolean exists = FALSE;
3486
3487         cm_return_if_fail(compose->account != NULL);
3488
3489         BLOCK_WRAP();
3490
3491         g_signal_handlers_block_by_func(G_OBJECT(buffer),
3492                                         G_CALLBACK(compose_changed_cb),
3493                                         compose);
3494
3495         mark = gtk_text_buffer_get_insert(buffer);
3496         gtk_text_buffer_get_iter_at_mark(buffer, &iter, mark);
3497         cur_pos = gtk_text_iter_get_offset (&iter);
3498         ins_pos = cur_pos;
3499
3500         gtk_text_buffer_get_end_iter(buffer, &iter);
3501
3502         exists = (compose->sig_str != NULL);
3503
3504         if (replace) {
3505                 GtkTextIter first_iter, start_iter, end_iter;
3506
3507                 gtk_text_buffer_get_start_iter(buffer, &first_iter);
3508
3509                 if (!exists || compose->sig_str[0] == '\0')
3510                         found = FALSE;
3511                 else
3512                         found = gtk_text_iter_forward_to_tag_toggle(&first_iter,
3513                                         compose->signature_tag);
3514
3515                 if (found) {
3516                         /* include previous \n\n */
3517                         gtk_text_iter_backward_chars(&first_iter, 1);
3518                         start_iter = first_iter;
3519                         end_iter = first_iter;
3520                         /* skip re-start */
3521                         found = gtk_text_iter_forward_to_tag_toggle(&end_iter,
3522                                         compose->signature_tag);
3523                         found &= gtk_text_iter_forward_to_tag_toggle(&end_iter,
3524                                         compose->signature_tag);
3525                         if (found) {
3526                                 gtk_text_buffer_delete(buffer, &start_iter, &end_iter);
3527                                 iter = start_iter;
3528                         }
3529                 }
3530         }
3531
3532         g_free(compose->sig_str);
3533         compose->sig_str = account_get_signature_str(compose->account);
3534
3535         cur_pos = gtk_text_iter_get_offset(&iter);
3536
3537         if (!compose->sig_str || (replace && !compose->account->auto_sig)) {
3538                 g_free(compose->sig_str);
3539                 compose->sig_str = NULL;
3540         } else {
3541                 if (compose->sig_inserted == FALSE)
3542                         gtk_text_buffer_insert(buffer, &iter, "\n", -1);
3543                 compose->sig_inserted = TRUE;
3544
3545                 cur_pos = gtk_text_iter_get_offset(&iter);
3546                 gtk_text_buffer_insert(buffer, &iter, compose->sig_str, -1);
3547                 /* remove \n\n */
3548                 gtk_text_buffer_get_iter_at_offset(buffer, &iter, cur_pos);
3549                 gtk_text_iter_forward_chars(&iter, 1);
3550                 gtk_text_buffer_get_end_iter(buffer, &iter_end);
3551                 gtk_text_buffer_apply_tag_by_name(buffer,"signature",&iter, &iter_end);
3552
3553                 if (cur_pos > gtk_text_buffer_get_char_count (buffer))
3554                         cur_pos = gtk_text_buffer_get_char_count (buffer);
3555         }
3556
3557         /* put the cursor where it should be
3558          * either where the quote_fmt says, either where it was */
3559         if (compose->set_cursor_pos < 0)
3560                 gtk_text_buffer_get_iter_at_offset(buffer, &iter, ins_pos);
3561         else
3562                 gtk_text_buffer_get_iter_at_offset(buffer, &iter,
3563                         compose->set_cursor_pos);
3564
3565         compose->set_cursor_pos = -1;
3566         gtk_text_buffer_place_cursor(buffer, &iter);
3567         g_signal_handlers_unblock_by_func(G_OBJECT(buffer),
3568                                         G_CALLBACK(compose_changed_cb),
3569                                         compose);
3570
3571         UNBLOCK_WRAP();
3572 }
3573
3574 static ComposeInsertResult compose_insert_file(Compose *compose, const gchar *file)
3575 {
3576         GtkTextView *text;
3577         GtkTextBuffer *buffer;
3578         GtkTextMark *mark;
3579         GtkTextIter iter;
3580         const gchar *cur_encoding;
3581         gchar buf[BUFFSIZE];
3582         gint len;
3583         FILE *fp;
3584         gboolean prev_autowrap;
3585         GStatBuf file_stat;
3586         int ret;
3587         GString *file_contents = NULL;
3588         ComposeInsertResult result = COMPOSE_INSERT_SUCCESS;
3589
3590         cm_return_val_if_fail(file != NULL, COMPOSE_INSERT_NO_FILE);
3591
3592         /* get the size of the file we are about to insert */
3593         ret = g_stat(file, &file_stat);
3594         if (ret != 0) {
3595                 gchar *shortfile = g_path_get_basename(file);
3596                 alertpanel_error(_("Could not get size of file '%s'."), shortfile);
3597                 g_free(shortfile);
3598                 return COMPOSE_INSERT_NO_FILE;
3599         } else if (prefs_common.warn_large_insert == TRUE) {
3600
3601                 /* ask user for confirmation if the file is large */
3602                 if (prefs_common.warn_large_insert_size < 0 ||
3603                     file_stat.st_size > (prefs_common.warn_large_insert_size * 1024)) {
3604                         AlertValue aval;
3605                         gchar *msg;
3606
3607                         msg = g_strdup_printf(_("You are about to insert a file of %s "
3608                                                 "in the message body. Are you sure you want to do that?"),
3609                                                 to_human_readable(file_stat.st_size));
3610                         aval = alertpanel_full(_("Are you sure?"), msg, GTK_STOCK_CANCEL,
3611                                         _("+_Insert"), NULL, TRUE, NULL, ALERT_QUESTION, G_ALERTDEFAULT);
3612                         g_free(msg);
3613
3614                         /* do we ask for confirmation next time? */
3615                         if (aval & G_ALERTDISABLE) {
3616                                 /* no confirmation next time, disable feature in preferences */
3617                                 aval &= ~G_ALERTDISABLE;
3618                                 prefs_common.warn_large_insert = FALSE;
3619                         }
3620
3621                         /* abort file insertion if user canceled action */
3622                         if (aval != G_ALERTALTERNATE) {
3623                                 return COMPOSE_INSERT_NO_FILE;
3624                         }
3625                 }
3626         }
3627
3628
3629         if ((fp = g_fopen(file, "rb")) == NULL) {
3630                 FILE_OP_ERROR(file, "fopen");
3631                 return COMPOSE_INSERT_READ_ERROR;
3632         }
3633
3634         prev_autowrap = compose->autowrap;
3635         compose->autowrap = FALSE;
3636
3637         text = GTK_TEXT_VIEW(compose->text);
3638         buffer = gtk_text_view_get_buffer(text);
3639         mark = gtk_text_buffer_get_insert(buffer);
3640         gtk_text_buffer_get_iter_at_mark(buffer, &iter, mark);
3641
3642         g_signal_handlers_block_by_func(G_OBJECT(buffer),
3643                                         G_CALLBACK(text_inserted),
3644                                         compose);
3645
3646         cur_encoding = conv_get_locale_charset_str_no_utf8();
3647
3648         file_contents = g_string_new("");
3649         while (fgets(buf, sizeof(buf), fp) != NULL) {
3650                 gchar *str;
3651
3652                 if (g_utf8_validate(buf, -1, NULL) == TRUE)
3653                         str = g_strdup(buf);
3654                 else {
3655                         codeconv_set_strict(TRUE);
3656                         str = conv_codeset_strdup
3657                                 (buf, cur_encoding, CS_INTERNAL);
3658                         codeconv_set_strict(FALSE);
3659
3660                         if (!str) {
3661                                 result = COMPOSE_INSERT_INVALID_CHARACTER;
3662                                 break;
3663                         }
3664                 }
3665                 if (!str) continue;
3666
3667                 /* strip <CR> if DOS/Windows file,
3668                    replace <CR> with <LF> if Macintosh file. */
3669                 strcrchomp(str);
3670                 len = strlen(str);
3671                 if (len &