src/compose.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 1999-2011 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 #endif
  23
  24 #include "defs.h"
  25
  26 #ifndef PANGO_ENABLE_ENGINE
  27 #  define PANGO_ENABLE_ENGINE
  28 #endif
  29
  30 #include <glib.h>
  31 #include <glib/gi18n.h>
  32 #include <gdk/gdkkeysyms.h>
  33 #include <gtk/gtk.h>
  34
  35 #include <pango/pango-break.h>
  36 #include <stdio.h>
  37 #include <stdlib.h>
  38 #include <string.h>
  39 #include <ctype.h>
  40 #include <sys/types.h>
  41 #include <sys/stat.h>
  42 #include <unistd.h>
  43 #include <time.h>
  44 #include <stdlib.h>
  45 #if HAVE_SYS_WAIT_H
  46 #  include <sys/wait.h>
  47 #endif
  48 #include <signal.h>
  49 #include <errno.h>
  50 #ifndef G_OS_WIN32  /* fixme we should have a configure test. */
  51 #include <libgen.h>
  52 #endif
  53
  54 #if (HAVE_WCTYPE_H && HAVE_WCHAR_H)
  55 #  include <wchar.h>
  56 #  include <wctype.h>
  57 #endif
  58
  59 #include "claws.h"
  60 #include "main.h"
  61 #include "mainwindow.h"
  62 #include "compose.h"
  63 #include "addressbook.h"
  64 #include "folderview.h"
  65 #include "procmsg.h"
  66 #include "menu.h"
  67 #include "stock_pixmap.h"
  68 #include "send_message.h"
  69 #include "imap.h"
  70 #include "news.h"
  71 #include "customheader.h"
  72 #include "prefs_common.h"
  73 #include "prefs_account.h"
  74 #include "action.h"
  75 #include "account.h"
  76 #include "filesel.h"
  77 #include "procheader.h"
  78 #include "procmime.h"
  79 #include "statusbar.h"
  80 #include "about.h"
  81 #include "base64.h"
  82 #include "quoted-printable.h"
  83 #include "codeconv.h"
  84 #include "utils.h"
  85 #include "gtkutils.h"
  86 #include "socket.h"
  87 #include "alertpanel.h"
  88 #include "manage_window.h"
  89 #if !GTK_CHECK_VERSION(2, 24, 0)
  90 #include "gtkshruler.h"
  91 #endif
  92 #include "folder.h"
  93 #include "addr_compl.h"
  94 #include "quote_fmt.h"
  95 #include "undo.h"
  96 #include "foldersel.h"
  97 #include "toolbar.h"
  98 #include "inc.h"
  99 #include "message_search.h"
 100 #include "combobox.h"
 101 #include "hooks.h"
 102 #include "privacy.h"
 103 #include "timing.h"
 104 #include "autofaces.h"
 105 #include "spell_entry.h"
 106
 107 enum
 108 {
 109         COL_MIMETYPE = 0,
 110         COL_SIZE     = 1,
 111         COL_NAME     = 2,
 112         COL_CHARSET  = 3,
 113         COL_DATA     = 4,
 114         COL_AUTODATA = 5,
 115         N_COL_COLUMNS
 116 };
 117
 118 #define N_ATTACH_COLS   (N_COL_COLUMNS)
 119
 120 typedef enum
 121 {
 122         COMPOSE_CALL_ADVANCED_ACTION_MOVE_BEGINNING_OF_LINE,
 123         COMPOSE_CALL_ADVANCED_ACTION_MOVE_FORWARD_CHARACTER,
 124         COMPOSE_CALL_ADVANCED_ACTION_MOVE_BACKWARD_CHARACTER,
 125         COMPOSE_CALL_ADVANCED_ACTION_MOVE_FORWARD_WORD,
 126         COMPOSE_CALL_ADVANCED_ACTION_MOVE_BACKWARD_WORD,
 127         COMPOSE_CALL_ADVANCED_ACTION_MOVE_END_OF_LINE,
 128         COMPOSE_CALL_ADVANCED_ACTION_MOVE_NEXT_LINE,
 129         COMPOSE_CALL_ADVANCED_ACTION_MOVE_PREVIOUS_LINE,
 130         COMPOSE_CALL_ADVANCED_ACTION_DELETE_FORWARD_CHARACTER,
 131         COMPOSE_CALL_ADVANCED_ACTION_DELETE_BACKWARD_CHARACTER,
 132         COMPOSE_CALL_ADVANCED_ACTION_DELETE_FORWARD_WORD,
 133         COMPOSE_CALL_ADVANCED_ACTION_DELETE_BACKWARD_WORD,
 134         COMPOSE_CALL_ADVANCED_ACTION_DELETE_LINE,
 135         COMPOSE_CALL_ADVANCED_ACTION_DELETE_TO_LINE_END
 136 } ComposeCallAdvancedAction;
 137
 138 typedef enum
 139 {
 140         PRIORITY_HIGHEST = 1,
 141         PRIORITY_HIGH,
 142         PRIORITY_NORMAL,
 143         PRIORITY_LOW,
 144         PRIORITY_LOWEST
 145 } PriorityLevel;
 146
 147 typedef enum
 148 {
 149         COMPOSE_INSERT_SUCCESS,
 150         COMPOSE_INSERT_READ_ERROR,
 151         COMPOSE_INSERT_INVALID_CHARACTER,
 152         COMPOSE_INSERT_NO_FILE
 153 } ComposeInsertResult;
 154
 155 typedef enum
 156 {
 157         COMPOSE_WRITE_FOR_SEND,
 158         COMPOSE_WRITE_FOR_STORE
 159 } ComposeWriteType;
 160
 161 typedef enum
 162 {
 163         COMPOSE_QUOTE_FORCED,
 164         COMPOSE_QUOTE_CHECK,
 165         COMPOSE_QUOTE_SKIP
 166 } ComposeQuoteMode;
 167
 168 typedef enum {
 169     TO_FIELD_PRESENT,
 170     SUBJECT_FIELD_PRESENT,
 171     BODY_FIELD_PRESENT,
 172     NO_FIELD_PRESENT
 173 } MailField;
 174
 175 #define B64_LINE_SIZE           57
 176 #define B64_BUFFSIZE            77
 177
 178 #define MAX_REFERENCES_LEN      999
 179
 180 static GList *compose_list = NULL;
 181
 182 static Compose *compose_generic_new                     (PrefsAccount   *account,
 183                                                  const gchar    *to,
 184                                                  FolderItem     *item,
 185                                                  GPtrArray      *attach_files,
 186                                                  GList          *listAddress );
 187
 188 static Compose *compose_create                  (PrefsAccount   *account,
 189                                                  FolderItem              *item,
 190                                                  ComposeMode     mode,
 191                                                  gboolean batch);
 192
 193 static void compose_entry_mark_default_to       (Compose          *compose,
 194                                          const gchar      *address);
 195 static Compose *compose_followup_and_reply_to   (MsgInfo        *msginfo,
 196                                          ComposeQuoteMode        quote_mode,
 197                                          gboolean        to_all,
 198                                          gboolean        to_sender,
 199                                          const gchar    *body);
 200 static Compose *compose_forward_multiple        (PrefsAccount   *account,
 201                                          GSList         *msginfo_list);
 202 static Compose *compose_reply                   (MsgInfo        *msginfo,
 203                                          ComposeQuoteMode        quote_mode,
 204                                          gboolean        to_all,
 205                                          gboolean        to_ml,
 206                                          gboolean        to_sender,
 207                                          const gchar    *body);
 208 static Compose *compose_reply_mode              (ComposeMode     mode,
 209                                          GSList         *msginfo_list,
 210                                          gchar          *body);
 211 static void compose_template_apply_fields(Compose *compose, Template *tmpl);
 212 static void compose_update_privacy_systems_menu(Compose *compose);
 213
 214 static GtkWidget *compose_account_option_menu_create
 215                                                 (Compose        *compose);
 216 static void compose_set_out_encoding            (Compose        *compose);
 217 static void compose_set_template_menu           (Compose        *compose);
 218 static void compose_destroy                     (Compose        *compose);
 219
 220 static MailField compose_entries_set            (Compose        *compose,
 221                                                  const gchar    *mailto,
 222                                                  ComposeEntryType to_type);
 223 static gint compose_parse_header                (Compose        *compose,
 224                                                  MsgInfo        *msginfo);
 225 static gchar *compose_parse_references          (const gchar    *ref,
 226                                                  const gchar    *msgid);
 227
 228 static gchar *compose_quote_fmt                 (Compose        *compose,
 229                                                  MsgInfo        *msginfo,
 230                                                  const gchar    *fmt,
 231                                                  const gchar    *qmark,
 232                                                  const gchar    *body,
 233                                                  gboolean        rewrap,
 234                                                  gboolean        need_unescape,
 235                                                  const gchar *err_msg);
 236
 237 static void compose_reply_set_entry             (Compose        *compose,
 238                                                  MsgInfo        *msginfo,
 239                                                  gboolean        to_all,
 240                                                  gboolean        to_ml,
 241                                                  gboolean        to_sender,
 242                                                  gboolean
 243                                                  followup_and_reply_to);
 244 static void compose_reedit_set_entry            (Compose        *compose,
 245                                                  MsgInfo        *msginfo);
 246
 247 static void compose_insert_sig                  (Compose        *compose,
 248                                                  gboolean        replace);
 249 static ComposeInsertResult compose_insert_file  (Compose        *compose,
 250                                                  const gchar    *file);
 251
 252 static gboolean compose_attach_append           (Compose        *compose,
 253                                                  const gchar    *file,
 254                                                  const gchar    *type,
 255                                                  const gchar    *content_type,
 256                                                  const gchar    *charset);
 257 static void compose_attach_parts                (Compose        *compose,
 258                                                  MsgInfo        *msginfo);
 259
 260 static gboolean compose_beautify_paragraph      (Compose        *compose,
 261                                                  GtkTextIter    *par_iter,
 262                                                  gboolean        force);
 263 static void compose_wrap_all                    (Compose        *compose);
 264 static void compose_wrap_all_full               (Compose        *compose,
 265                                                  gboolean        autowrap);
 266
 267 static void compose_set_title                   (Compose        *compose);
 268 static void compose_select_account              (Compose        *compose,
 269                                                  PrefsAccount   *account,
 270                                                  gboolean        init);
 271
 272 static PrefsAccount *compose_current_mail_account(void);
 273 /* static gint compose_send                     (Compose        *compose); */
 274 static gboolean compose_check_for_valid_recipient
 275                                                 (Compose        *compose);
 276 static gboolean compose_check_entries           (Compose        *compose,
 277                                                  gboolean       check_everything);
 278 static gint compose_write_to_file               (Compose        *compose,
 279                                                  FILE           *fp,
 280                                                  gint            action,
 281                                                  gboolean        attach_parts);
 282 static gint compose_write_body_to_file          (Compose        *compose,
 283                                                  const gchar    *file);
 284 static gint compose_remove_reedit_target        (Compose        *compose,
 285                                                  gboolean        force);
 286 static void compose_remove_draft                        (Compose        *compose);
 287 static gint compose_queue_sub                   (Compose        *compose,
 288                                                  gint           *msgnum,
 289                                                  FolderItem     **item,
 290                                                  gchar          **msgpath,
 291                                                  gboolean       check_subject,
 292                                                  gboolean       remove_reedit_target);
 293 static int compose_add_attachments              (Compose        *compose,
 294                                                  MimeInfo       *parent);
 295 static gchar *compose_get_header                (Compose        *compose);
 296
 297 static void compose_convert_header              (Compose        *compose,
 298                                                  gchar          *dest,
 299                                                  gint            len,
 300                                                  gchar          *src,
 301                                                  gint            header_len,
 302                                                  gboolean        addr_field);
 303
 304 static void compose_attach_info_free            (AttachInfo     *ainfo);
 305 static void compose_attach_remove_selected      (GtkAction      *action,
 306                                                  gpointer        data);
 307
 308 static void compose_template_apply              (Compose        *compose,
 309                                                  Template       *tmpl,
 310                                                  gboolean        replace);
 311 static void compose_attach_property             (GtkAction      *action,
 312                                                  gpointer        data);
 313 static void compose_attach_property_create      (gboolean       *cancelled);
 314 static void attach_property_ok                  (GtkWidget      *widget,
 315                                                  gboolean       *cancelled);
 316 static void attach_property_cancel              (GtkWidget      *widget,
 317                                                  gboolean       *cancelled);
 318 static gint attach_property_delete_event        (GtkWidget      *widget,
 319                                                  GdkEventAny    *event,
 320                                                  gboolean       *cancelled);
 321 static gboolean attach_property_key_pressed     (GtkWidget      *widget,
 322                                                  GdkEventKey    *event,
 323                                                  gboolean       *cancelled);
 324
 325 static void compose_exec_ext_editor             (Compose        *compose);
 326 #ifdef G_OS_UNIX
 327 static gint compose_exec_ext_editor_real        (const gchar    *file);
 328 static gboolean compose_ext_editor_kill         (Compose        *compose);
 329 static gboolean compose_input_cb                (GIOChannel     *source,
 330                                                  GIOCondition    condition,
 331                                                  gpointer        data);
 332 static void compose_set_ext_editor_sensitive    (Compose        *compose,
 333                                                  gboolean        sensitive);
 334 #endif /* G_OS_UNIX */
 335
 336 static void compose_undo_state_changed          (UndoMain       *undostruct,
 337                                                  gint            undo_state,
 338                                                  gint            redo_state,
 339                                                  gpointer        data);
 340
 341 static void compose_create_header_entry (Compose *compose);
 342 static void compose_add_header_entry    (Compose *compose, const gchar *header,
 343                                          gchar *text, ComposePrefType pref_type);
 344 static void compose_remove_header_entries(Compose *compose);
 345
 346 static void compose_update_priority_menu_item(Compose * compose);
 347 #if USE_ENCHANT
 348 static void compose_spell_menu_changed  (void *data);
 349 static void compose_dict_changed        (void *data);
 350 #endif
 351 static void compose_add_field_list      ( Compose *compose,
 352                                           GList *listAddress );
 353
 354 /* callback functions */
 355
 356 #if !GTK_CHECK_VERSION(2, 24, 0)
 357 static gboolean compose_edit_size_alloc (GtkEditable    *widget,
 358                                          GtkAllocation  *allocation,
 359                                          GtkSHRuler     *shruler);
 360 #endif
 361 static void account_activated           (GtkComboBox *optmenu,
 362                                          gpointer        data);
 363 static void attach_selected             (GtkTreeView    *tree_view,
 364                                          GtkTreePath    *tree_path,
 365                                          GtkTreeViewColumn *column,
 366                                          Compose *compose);
 367 static gboolean attach_button_pressed   (GtkWidget      *widget,
 368                                          GdkEventButton *event,
 369                                          gpointer        data);
 370 static gboolean attach_key_pressed      (GtkWidget      *widget,
 371                                          GdkEventKey    *event,
 372                                          gpointer        data);
 373 static void compose_send_cb             (GtkAction      *action, gpointer data);
 374 static void compose_send_later_cb       (GtkAction      *action, gpointer data);
 375
 376 static void compose_save_cb             (GtkAction      *action,
 377                                          gpointer        data);
 378
 379 static void compose_attach_cb           (GtkAction      *action,
 380                                          gpointer        data);
 381 static void compose_insert_file_cb      (GtkAction      *action,
 382                                          gpointer        data);
 383 static void compose_insert_sig_cb       (GtkAction      *action,
 384                                          gpointer        data);
 385
 386 static void compose_close_cb            (GtkAction      *action,
 387                                          gpointer        data);
 388
 389 static void compose_set_encoding_cb     (GtkAction      *action, GtkRadioAction *current, gpointer data);
 390
 391 static void compose_address_cb          (GtkAction      *action,
 392                                          gpointer        data);
 393 static void about_show_cb               (GtkAction      *action,
 394                                          gpointer        data);
 395 static void compose_template_activate_cb(GtkWidget      *widget,
 396                                          gpointer        data);
 397
 398 static void compose_ext_editor_cb       (GtkAction      *action,
 399                                          gpointer        data);
 400
 401 static gint compose_delete_cb           (GtkWidget      *widget,
 402                                          GdkEventAny    *event,
 403                                          gpointer        data);
 404
 405 static void compose_undo_cb             (GtkAction      *action,
 406                                          gpointer        data);
 407 static void compose_redo_cb             (GtkAction      *action,
 408                                          gpointer        data);
 409 static void compose_cut_cb              (GtkAction      *action,
 410                                          gpointer        data);
 411 static void compose_copy_cb             (GtkAction      *action,
 412                                          gpointer        data);
 413 static void compose_paste_cb            (GtkAction      *action,
 414                                          gpointer        data);
 415 static void compose_paste_as_quote_cb   (GtkAction      *action,
 416                                          gpointer        data);
 417 static void compose_paste_no_wrap_cb    (GtkAction      *action,
 418                                          gpointer        data);
 419 static void compose_paste_wrap_cb       (GtkAction      *action,
 420                                          gpointer        data);
 421 static void compose_allsel_cb           (GtkAction      *action,
 422                                          gpointer        data);
 423
 424 static void compose_advanced_action_cb  (GtkAction      *action,
 425                                          gpointer        data);
 426
 427 static void compose_grab_focus_cb       (GtkWidget      *widget,
 428                                          Compose        *compose);
 429
 430 static void compose_changed_cb          (GtkTextBuffer  *textbuf,
 431                                          Compose        *compose);
 432
 433 static void compose_wrap_cb             (GtkAction      *action,
 434                                          gpointer        data);
 435 static void compose_wrap_all_cb         (GtkAction      *action,
 436                                          gpointer        data);
 437 static void compose_find_cb             (GtkAction      *action,
 438                                          gpointer        data);
 439 static void compose_toggle_autowrap_cb  (GtkToggleAction *action,
 440                                          gpointer        data);
 441 static void compose_toggle_autoindent_cb(GtkToggleAction *action,
 442                                          gpointer        data);
 443
 444 #if !GTK_CHECK_VERSION(2, 24, 0)
 445 static void compose_toggle_ruler_cb     (GtkToggleAction *action,
 446                                          gpointer        data);
 447 #endif
 448 static void compose_toggle_sign_cb      (GtkToggleAction *action,
 449                                          gpointer        data);
 450 static void compose_toggle_encrypt_cb   (GtkToggleAction *action,
 451                                          gpointer        data);
 452 static void compose_set_privacy_system_cb(GtkWidget *widget, gpointer data);
 453 static void compose_update_privacy_system_menu_item(Compose * compose, gboolean warn);
 454 static void activate_privacy_system     (Compose *compose,
 455                                          PrefsAccount *account,
 456                                          gboolean warn);
 457 static void compose_use_signing(Compose *compose, gboolean use_signing);
 458 static void compose_use_encryption(Compose *compose, gboolean use_encryption);
 459 static void compose_toggle_return_receipt_cb(GtkToggleAction *action,
 460                                          gpointer        data);
 461 static void compose_toggle_remove_refs_cb(GtkToggleAction *action,
 462                                          gpointer        data);
 463 static void compose_set_priority_cb     (GtkAction *action, GtkRadioAction *current, gpointer data);
 464 static void compose_reply_change_mode   (Compose *compose, ComposeMode action);
 465 static void compose_reply_change_mode_cb(GtkAction *action, GtkRadioAction *current, gpointer data);
 466
 467 static void compose_attach_drag_received_cb (GtkWidget          *widget,
 468                                              GdkDragContext     *drag_context,
 469                                              gint                x,
 470                                              gint                y,
 471                                              GtkSelectionData   *data,
 472                                              guint               info,
 473                                              guint               time,
 474                                              gpointer            user_data);
 475 static void compose_insert_drag_received_cb (GtkWidget          *widget,
 476                                              GdkDragContext     *drag_context,
 477                                              gint                x,
 478                                              gint                y,
 479                                              GtkSelectionData   *data,
 480                                              guint               info,
 481                                              guint               time,
 482                                              gpointer            user_data);
 483 static void compose_header_drag_received_cb (GtkWidget          *widget,
 484                                              GdkDragContext     *drag_context,
 485                                              gint                x,
 486                                              gint                y,
 487                                              GtkSelectionData   *data,
 488                                              guint               info,
 489                                              guint               time,
 490                                              gpointer            user_data);
 491
 492 static gboolean compose_drag_drop           (GtkWidget *widget,
 493                                              GdkDragContext *drag_context,
 494                                              gint x, gint y,
 495                                              guint time, gpointer user_data);
 496
 497 static void text_inserted               (GtkTextBuffer  *buffer,
 498                                          GtkTextIter    *iter,
 499                                          const gchar    *text,
 500                                          gint            len,
 501                                          Compose        *compose);
 502 static Compose *compose_generic_reply(MsgInfo *msginfo,
 503                                   ComposeQuoteMode quote_mode,
 504                                   gboolean to_all,
 505                                   gboolean to_ml,
 506                                   gboolean to_sender,
 507                                   gboolean followup_and_reply_to,
 508                                   const gchar *body);
 509
 510 static void compose_headerentry_changed_cb         (GtkWidget          *entry,
 511                                             ComposeHeaderEntry *headerentry);
 512 static gboolean compose_headerentry_key_press_event_cb(GtkWidget               *entry,
 513                                             GdkEventKey        *event,
 514                                             ComposeHeaderEntry *headerentry);
 515 static gboolean compose_headerentry_button_clicked_cb (GtkWidget *button,
 516                                         ComposeHeaderEntry *headerentry);
 517
 518 static void compose_show_first_last_header (Compose *compose, gboolean show_first);
 519
 520 static void compose_allow_user_actions (Compose *compose, gboolean allow);
 521
 522 static void compose_nothing_cb             (GtkAction *action, gpointer data)
 523 {
 524
 525 }
 526
 527 #if USE_ENCHANT
 528 static void compose_check_all              (GtkAction *action, gpointer data);
 529 static void compose_highlight_all          (GtkAction *action, gpointer data);
 530 static void compose_check_backwards        (GtkAction *action, gpointer data);
 531 static void compose_check_forwards_go      (GtkAction *action, gpointer data);
 532 #endif
 533
 534 static PrefsAccount *compose_guess_forward_account_from_msginfo (MsgInfo *msginfo);
 535
 536 static MsgInfo *compose_msginfo_new_from_compose(Compose *compose);
 537
 538 #ifdef USE_ENCHANT
 539 static void compose_set_dictionaries_from_folder_prefs(Compose *compose,
 540                                                 FolderItem *folder_item);
 541 #endif
 542 static void compose_attach_update_label(Compose *compose);
 543 static void compose_set_folder_prefs(Compose *compose, FolderItem *folder,
 544                                      gboolean respect_default_to);
 545
 546 static GtkActionEntry compose_popup_entries[] =
 547 {
 548         {"Compose",                     NULL, "Compose" },
 549         {"Compose/Add",                 NULL, N_("_Add..."), NULL, NULL, G_CALLBACK(compose_attach_cb) },
 550         {"Compose/Remove",                      NULL, N_("_Remove"), NULL, NULL, G_CALLBACK(compose_attach_remove_selected) },
 551         {"Compose/---",                 NULL, "---", NULL, NULL, NULL },
 552         {"Compose/Properties",          NULL, N_("_Properties..."), NULL, NULL, G_CALLBACK(compose_attach_property) },
 553 };
 554
 555 static GtkActionEntry compose_entries[] =
 556 {
 557         {"Menu",                                NULL, "Menu" },
 558 /* menus */
 559         {"Message",                     NULL, N_("_Message") },
 560         {"Edit",                        NULL, N_("_Edit") },
 561 #if USE_ENCHANT
 562         {"Spelling",                    NULL, N_("_Spelling") },
 563 #endif
 564         {"Options",                     NULL, N_("_Options") },
 565         {"Tools",                       NULL, N_("_Tools") },
 566         {"Help",                        NULL, N_("_Help") },
 567 /* Message menu */
 568         {"Message/Send",                NULL, N_("S_end"), "<control>Return", NULL, G_CALLBACK(compose_send_cb) },
 569         {"Message/SendLater",           NULL, N_("Send _later"), "<shift><control>S", NULL, G_CALLBACK(compose_send_later_cb) },
 570         {"Message/---",                 NULL, "---" },
 571
 572         {"Message/AttachFile",          NULL, N_("_Attach file"), "<control>M", NULL, G_CALLBACK(compose_attach_cb) },
 573         {"Message/InsertFile",          NULL, N_("_Insert file"), "<control>I", NULL, G_CALLBACK(compose_insert_file_cb) },
 574         {"Message/InsertSig",           NULL, N_("Insert si_gnature"), "<control>G", NULL, G_CALLBACK(compose_insert_sig_cb) },
 575         /* {"Message/---",              NULL, "---" }, */
 576         {"Message/Save",                NULL, N_("_Save"), "<control>S", NULL, G_CALLBACK(compose_save_cb) }, /*COMPOSE_KEEP_EDITING*/
 577         /* {"Message/---",              NULL, "---" }, */
 578         {"Message/Close",               NULL, N_("_Close"), "<control>W", NULL, G_CALLBACK(compose_close_cb) },
 579
 580 /* Edit menu */
 581         {"Edit/Undo",                   NULL, N_("_Undo"), "<control>Z", NULL, G_CALLBACK(compose_undo_cb) },
 582         {"Edit/Redo",                   NULL, N_("_Redo"), "<control>Y", NULL, G_CALLBACK(compose_redo_cb) },
 583         {"Edit/---",                    NULL, "---" },
 584
 585         {"Edit/Cut",                    NULL, N_("Cu_t"), "<control>X", NULL, G_CALLBACK(compose_cut_cb) },
 586         {"Edit/Copy",                   NULL, N_("_Copy"), "<control>C", NULL, G_CALLBACK(compose_copy_cb) },
 587         {"Edit/Paste",                  NULL, N_("_Paste"), "<control>V", NULL, G_CALLBACK(compose_paste_cb) },
 588
 589         {"Edit/SpecialPaste",           NULL, N_("Special paste") },
 590         {"Edit/SpecialPaste/AsQuotation",       NULL, N_("as _quotation"), NULL, NULL, G_CALLBACK(compose_paste_as_quote_cb) },
 591         {"Edit/SpecialPaste/Wrapped",   NULL, N_("_wrapped"), NULL, NULL, G_CALLBACK(compose_paste_wrap_cb) },
 592         {"Edit/SpecialPaste/Unwrapped", NULL, N_("_unwrapped"), NULL, NULL, G_CALLBACK(compose_paste_no_wrap_cb) },
 593
 594         {"Edit/SelectAll",              NULL, N_("Select _all"), "<control>A", NULL, G_CALLBACK(compose_allsel_cb) },
 595
 596         {"Edit/Advanced",               NULL, N_("A_dvanced") },
 597         {"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*/
 598         {"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*/
 599         {"Edit/Advanced/BackWord",      NULL, N_("Move a word backward"), NULL, NULL, G_CALLBACK(compose_advanced_action_cb) }, /*COMPOSE_CALL_ADVANCED_ACTION_MOVE_BACKWARD_WORD*/
 600         {"Edit/Advanced/ForwWord",      NULL, N_("Move a word forward"), NULL, NULL, G_CALLBACK(compose_advanced_action_cb) }, /*COMPOSE_CALL_ADVANCED_ACTION_MOVE_FORWARD_WORD*/
 601         {"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*/
 602         {"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*/
 603         {"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*/
 604         {"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*/
 605         {"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*/
 606         {"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*/
 607         {"Edit/Advanced/DelBackWord",   NULL, N_("Delete a word backward"), NULL, NULL, G_CALLBACK(compose_advanced_action_cb) }, /*COMPOSE_CALL_ADVANCED_ACTION_DELETE_BACKWARD_WORD*/
 608         {"Edit/Advanced/DelForwWord",   NULL, N_("Delete a word forward"), NULL, NULL, G_CALLBACK(compose_advanced_action_cb) }, /*COMPOSE_CALL_ADVANCED_ACTION_DELETE_FORWARD_WORD*/
 609         {"Edit/Advanced/DelLine",       NULL, N_("Delete line"), "<control>U", NULL, G_CALLBACK(compose_advanced_action_cb) }, /*COMPOSE_CALL_ADVANCED_ACTION_DELETE_LINE*/
 610         {"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*/
 611
 612         /* {"Edit/---",                 NULL, "---" }, */
 613         {"Edit/Find",           NULL, N_("_Find"), "<control>F", NULL, G_CALLBACK(compose_find_cb) },
 614
 615         /* {"Edit/---",                 NULL, "---" }, */
 616         {"Edit/WrapPara",               NULL, N_("_Wrap current paragraph"), "<control>L", NULL, G_CALLBACK(compose_wrap_cb) }, /* 0 */
 617         {"Edit/WrapAllLines",           NULL, N_("Wrap all long _lines"), "<control><alt>L", NULL, G_CALLBACK(compose_wrap_all_cb) }, /* 1 */
 618         /* {"Edit/---",                 NULL, "---" }, */
 619         {"Edit/ExtEditor",              NULL, N_("Edit with e_xternal editor"), "<shift><control>X", NULL, G_CALLBACK(compose_ext_editor_cb) },
 620 #if USE_ENCHANT
 621 /* Spelling menu */
 622         {"Spelling/CheckAllSel",        NULL, N_("_Check all or check selection"), NULL, NULL, G_CALLBACK(compose_check_all) },
 623         {"Spelling/HighlightAll",       NULL, N_("_Highlight all misspelled words"), NULL, NULL, G_CALLBACK(compose_highlight_all) },
 624         {"Spelling/CheckBackwards",     NULL, N_("Check _backwards misspelled word"), NULL, NULL, G_CALLBACK(compose_check_backwards) },
 625         {"Spelling/ForwardNext",        NULL, N_("_Forward to next misspelled word"), NULL, NULL, G_CALLBACK(compose_check_forwards_go) },
 626
 627         {"Spelling/---",                NULL, "---" },
 628         {"Spelling/Options",            NULL, N_("_Options") },
 629 #endif
 630
 631 /* Options menu */
 632
 633         {"Options/ReplyMode",           NULL, N_("Reply _mode") },
 634         {"Options/---",                 NULL, "---" },
 635         {"Options/PrivacySystem",       NULL, N_("Privacy _System") },
 636         {"Options/PrivacySystem/PlaceHolder",   NULL, "Placeholder", NULL, NULL, G_CALLBACK(compose_nothing_cb) },
 637
 638         /* {"Options/---",              NULL, "---" }, */
 639
 640         {"Options/Priority",            NULL, N_("_Priority") },
 641
 642         {"Options/Encoding",            NULL, N_("Character _encoding") },
 643         {"Options/Encoding/---",        NULL, "---" },
 644 #define ENC_ACTION(cs_char,c_char,string) \
 645         { "Options/Encoding/" cs_char, NULL, N_(string), NULL, NULL, c_char }
 646
 647         {"Options/Encoding/Western",    NULL, N_("Western European") },
 648         {"Options/Encoding/Baltic",     NULL, N_("Baltic") },
 649         {"Options/Encoding/Hebrew",     NULL, N_("Hebrew") },
 650         {"Options/Encoding/Arabic",     NULL, N_("Arabic") },
 651         {"Options/Encoding/Cyrillic",   NULL, N_("Cyrillic") },
 652         {"Options/Encoding/Japanese",   NULL, N_("Japanese") },
 653         {"Options/Encoding/Chinese",    NULL, N_("Chinese") },
 654         {"Options/Encoding/Korean",     NULL, N_("Korean") },
 655         {"Options/Encoding/Thai",       NULL, N_("Thai") },
 656
 657 /* Tools menu */
 658         {"Tools/AddressBook",           NULL, N_("_Address book"), NULL, NULL, G_CALLBACK(compose_address_cb) },
 659
 660         {"Tools/Template",      NULL, N_("_Template") },
 661         {"Tools/Template/PlaceHolder",  NULL, "Placeholder", NULL, NULL, G_CALLBACK(compose_nothing_cb) },
 662         {"Tools/Actions",       NULL, N_("Actio_ns") },
 663         {"Tools/Actions/PlaceHolder",   NULL, "Placeholder", NULL, NULL, G_CALLBACK(compose_nothing_cb) },
 664
 665 /* Help menu */
 666         {"Help/About",          NULL, N_("_About"), NULL, NULL, G_CALLBACK(about_show_cb) },
 667 };
 668
 669 static GtkToggleActionEntry compose_toggle_entries[] =
 670 {
 671         {"Edit/AutoWrap",               NULL, N_("Aut_o wrapping"), "<shift><control>L", NULL, G_CALLBACK(compose_toggle_autowrap_cb) }, /* TOGGLE */
 672         {"Edit/AutoIndent",             NULL, N_("Auto _indent"), NULL, NULL, G_CALLBACK(compose_toggle_autoindent_cb) }, /* TOGGLE */
 673         {"Options/Sign",                NULL, N_("Si_gn"), NULL, NULL, G_CALLBACK(compose_toggle_sign_cb) }, /* Toggle */
 674         {"Options/Encrypt",             NULL, N_("_Encrypt"), NULL, NULL, G_CALLBACK(compose_toggle_encrypt_cb) }, /* Toggle */
 675         {"Options/RequestRetRcpt",      NULL, N_("_Request Return Receipt"), NULL, NULL, G_CALLBACK(compose_toggle_return_receipt_cb) }, /* TOGGLE */
 676         {"Options/RemoveReferences",    NULL, N_("Remo_ve references"), NULL, NULL, G_CALLBACK(compose_toggle_remove_refs_cb) }, /* TOGGLE */
 677 #if !GTK_CHECK_VERSION(2, 24, 0)
 678         {"Tools/ShowRuler",             NULL, N_("Show _ruler"), NULL, NULL, G_CALLBACK(compose_toggle_ruler_cb) }, /* Toggle */
 679 #endif
 680 };
 681
 682 static GtkRadioActionEntry compose_radio_rm_entries[] =
 683 {
 684         {"Options/ReplyMode/Normal",    NULL, N_("_Normal"), NULL, NULL, COMPOSE_REPLY }, /* RADIO compose_reply_change_mode_cb */
 685         {"Options/ReplyMode/All",       NULL, N_("_All"), NULL, NULL, COMPOSE_REPLY_TO_ALL }, /* RADIO compose_reply_change_mode_cb */
 686         {"Options/ReplyMode/Sender",    NULL, N_("_Sender"), NULL, NULL, COMPOSE_REPLY_TO_SENDER }, /* RADIO compose_reply_change_mode_cb */
 687         {"Options/ReplyMode/List",      NULL, N_("_Mailing-list"), NULL, NULL, COMPOSE_REPLY_TO_LIST }, /* RADIO compose_reply_change_mode_cb */
 688 };
 689
 690 static GtkRadioActionEntry compose_radio_prio_entries[] =
 691 {
 692         {"Options/Priority/Highest",    NULL, N_("_Highest"), NULL, NULL, PRIORITY_HIGHEST }, /* RADIO compose_set_priority_cb */
 693         {"Options/Priority/High",       NULL, N_("Hi_gh"), NULL, NULL, PRIORITY_HIGH }, /* RADIO compose_set_priority_cb */
 694         {"Options/Priority/Normal",     NULL, N_("_Normal"), NULL, NULL, PRIORITY_NORMAL }, /* RADIO compose_set_priority_cb */
 695         {"Options/Priority/Low",        NULL, N_("Lo_w"), NULL, NULL, PRIORITY_LOW }, /* RADIO compose_set_priority_cb */
 696         {"Options/Priority/Lowest",     NULL, N_("_Lowest"), NULL, NULL, PRIORITY_LOWEST }, /* RADIO compose_set_priority_cb */
 697 };
 698
 699 static GtkRadioActionEntry compose_radio_enc_entries[] =
 700 {
 701         ENC_ACTION(CS_AUTO, C_AUTO, N_("_Automatic")), /* RADIO compose_set_encoding_cb */
 702         ENC_ACTION(CS_US_ASCII, C_US_ASCII, N_("7bit ASCII (US-ASC_II)")), /* RADIO compose_set_encoding_cb */
 703         ENC_ACTION(CS_UTF_8, C_UTF_8, N_("Unicode (_UTF-8)")), /* RADIO compose_set_encoding_cb */
 704         ENC_ACTION("Western/"CS_ISO_8859_1, C_ISO_8859_1, "ISO-8859-_1"), /* RADIO compose_set_encoding_cb */
 705         ENC_ACTION("Western/"CS_ISO_8859_15, C_ISO_8859_15, "ISO-8859-15"), /* RADIO compose_set_encoding_cb */
 706         ENC_ACTION("Western/"CS_WINDOWS_1252, C_WINDOWS_1252, "Windows-1252"), /* RADIO compose_set_encoding_cb */
 707         ENC_ACTION(CS_ISO_8859_2, C_ISO_8859_2, N_("Central European (ISO-8859-_2)")), /* RADIO compose_set_encoding_cb */
 708         ENC_ACTION("Baltic/"CS_ISO_8859_13, C_ISO_8859_13, "ISO-8859-13"), /* RADIO compose_set_encoding_cb */
 709         ENC_ACTION("Baltic/"CS_ISO_8859_4, C_ISO_8859_14, "ISO-8859-_4"), /* RADIO compose_set_encoding_cb */
 710         ENC_ACTION(CS_ISO_8859_7, C_ISO_8859_7, N_("Greek (ISO-8859-_7)")), /* RADIO compose_set_encoding_cb */
 711         ENC_ACTION("Hebrew/"CS_ISO_8859_8, C_ISO_8859_8, "ISO-8859-_8"), /* RADIO compose_set_encoding_cb */
 712         ENC_ACTION("Hebrew/"CS_WINDOWS_1255, C_WINDOWS_1255, "Windows-1255"), /* RADIO compose_set_encoding_cb */
 713         ENC_ACTION("Arabic/"CS_ISO_8859_6, C_ISO_8859_6, "ISO-8859-_6"), /* RADIO compose_set_encoding_cb */
 714         ENC_ACTION("Arabic/"CS_WINDOWS_1256, C_WINDOWS_1256, "Windows-1256"), /* RADIO compose_set_encoding_cb */
 715         ENC_ACTION(CS_ISO_8859_9, C_ISO_8859_9, N_("Turkish (ISO-8859-_9)")), /* RADIO compose_set_encoding_cb */
 716         ENC_ACTION("Cyrillic/"CS_ISO_8859_5, C_ISO_8859_5, "ISO-8859-_5"), /* RADIO compose_set_encoding_cb */
 717         ENC_ACTION("Cyrillic/"CS_KOI8_R, C_KOI8_R, "KOI8-_R"), /* RADIO compose_set_encoding_cb */
 718         ENC_ACTION("Cyrillic/"CS_KOI8_U, C_KOI8_U, "KOI8-_U"), /* RADIO compose_set_encoding_cb */
 719         ENC_ACTION("Cyrillic/"CS_WINDOWS_1251, C_WINDOWS_1251, "Windows-1251"), /* RADIO compose_set_encoding_cb */
 720         ENC_ACTION("Japanese/"CS_ISO_2022_JP, C_ISO_2022_JP, "ISO-2022-_JP"), /* RADIO compose_set_encoding_cb */
 721         ENC_ACTION("Japanese/"CS_ISO_2022_JP_2, C_ISO_2022_JP_2, "ISO-2022-JP-_2"), /* RADIO compose_set_encoding_cb */
 722         ENC_ACTION("Japanese/"CS_EUC_JP, C_EUC_JP, "_EUC-JP"), /* RADIO compose_set_encoding_cb */
 723         ENC_ACTION("Japanese/"CS_SHIFT_JIS, C_SHIFT_JIS, "_Shift-JIS"), /* RADIO compose_set_encoding_cb */
 724         ENC_ACTION("Chinese/"CS_GB18030, C_GB18030, "_GB18030"), /* RADIO compose_set_encoding_cb */
 725         ENC_ACTION("Chinese/"CS_GB2312, C_GB2312, "_GB2312"), /* RADIO compose_set_encoding_cb */
 726         ENC_ACTION("Chinese/"CS_GBK, C_GBK, "GB_K"), /* RADIO compose_set_encoding_cb */
 727         ENC_ACTION("Chinese/"CS_BIG5, C_BIG5, "_Big5-JP"), /* RADIO compose_set_encoding_cb */
 728         ENC_ACTION("Chinese/"CS_EUC_TW, C_EUC_TW, "EUC-_TW"), /* RADIO compose_set_encoding_cb */
 729         ENC_ACTION("Korean/"CS_EUC_KR, C_EUC_KR, "_EUC-KR"), /* RADIO compose_set_encoding_cb */
 730         ENC_ACTION("Korean/"CS_ISO_2022_KR, C_ISO_2022_KR, "_ISO-2022-KR"), /* RADIO compose_set_encoding_cb */
 731         ENC_ACTION("Thai/"CS_TIS_620, C_TIS_620, "_TIS-620-KR"), /* RADIO compose_set_encoding_cb */
 732         ENC_ACTION("Thai/"CS_WINDOWS_874, C_WINDOWS_874, "_Windows-874"), /* RADIO compose_set_encoding_cb */
 733 };
 734
 735 static GtkTargetEntry compose_mime_types[] =
 736 {
 737         {"text/uri-list", 0, 0},
 738         {"UTF8_STRING", 0, 0},
 739         {"text/plain", 0, 0}
 740 };
 741
 742 static gboolean compose_put_existing_to_front(MsgInfo *info)
 743 {
 744         GList *compose_list = compose_get_compose_list();
 745         GList *elem = NULL;
 746
 747         if (compose_list) {
 748                 for (elem = compose_list; elem != NULL && elem->data != NULL;
 749                      elem = elem->next) {
 750                         Compose *c = (Compose*)elem->data;
 751
 752                         if (!c->targetinfo || !c->targetinfo->msgid ||
 753                             !info->msgid)
 754                                 continue;
 755
 756                         if (!strcmp(c->targetinfo->msgid, info->msgid)) {
 757                                 gtkut_window_popup(c->window);
 758                                 return TRUE;
 759                         }
 760                 }
 761         }
 762         return FALSE;
 763 }
 764
 765 static GdkColor quote_color1 =
 766         {(gulong)0, (gushort)0, (gushort)0, (gushort)0};
 767 static GdkColor quote_color2 =
 768         {(gulong)0, (gushort)0, (gushort)0, (gushort)0};
 769 static GdkColor quote_color3 =
 770         {(gulong)0, (gushort)0, (gushort)0, (gushort)0};
 771
 772 static GdkColor quote_bgcolor1 =
 773         {(gulong)0, (gushort)0, (gushort)0, (gushort)0};
 774 static GdkColor quote_bgcolor2 =
 775         {(gulong)0, (gushort)0, (gushort)0, (gushort)0};
 776 static GdkColor quote_bgcolor3 =
 777         {(gulong)0, (gushort)0, (gushort)0, (gushort)0};
 778
 779 static GdkColor signature_color = {
 780         (gulong)0,
 781         (gushort)0x7fff,
 782         (gushort)0x7fff,
 783         (gushort)0x7fff
 784 };
 785
 786 static GdkColor uri_color = {
 787         (gulong)0,
 788         (gushort)0,
 789         (gushort)0,
 790         (gushort)0
 791 };
 792
 793 static void compose_create_tags(GtkTextView *text, Compose *compose)
 794 {
 795         GtkTextBuffer *buffer;
 796         GdkColor black = {(gulong)0, (gushort)0, (gushort)0, (gushort)0};
 797 #if !GTK_CHECK_VERSION(2, 24, 0)
 798         GdkColormap *cmap;
 799         gboolean success[8];
 800 #endif
 801         GdkColor color[8];
 802         int i;
 803
 804         buffer = gtk_text_view_get_buffer(text);
 805
 806         if (prefs_common.enable_color) {
 807                 /* grab the quote colors, converting from an int to a GdkColor */
 808                 gtkut_convert_int_to_gdk_color(prefs_common.quote_level1_col,
 809                                                &quote_color1);
 810                 gtkut_convert_int_to_gdk_color(prefs_common.quote_level2_col,
 811                                                &quote_color2);
 812                 gtkut_convert_int_to_gdk_color(prefs_common.quote_level3_col,
 813                                                &quote_color3);
 814                 gtkut_convert_int_to_gdk_color(prefs_common.quote_level1_bgcol,
 815                                                &quote_bgcolor1);
 816                 gtkut_convert_int_to_gdk_color(prefs_common.quote_level2_bgcol,
 817                                                &quote_bgcolor2);
 818                 gtkut_convert_int_to_gdk_color(prefs_common.quote_level3_bgcol,
 819                                                &quote_bgcolor3);
 820                 gtkut_convert_int_to_gdk_color(prefs_common.signature_col,
 821                                                &signature_color);
 822                 gtkut_convert_int_to_gdk_color(prefs_common.uri_col,
 823                                                &uri_color);
 824         } else {
 825                 signature_color = quote_color1 = quote_color2 = quote_color3 =
 826                         quote_bgcolor1 = quote_bgcolor2 = quote_bgcolor3 = uri_color = black;
 827         }
 828
 829         if (prefs_common.enable_color && prefs_common.enable_bgcolor) {
 830                 compose->quote0_tag = gtk_text_buffer_create_tag(buffer, "quote0",
 831                                            "foreground-gdk", &quote_color1,
 832                                            "paragraph-background-gdk", &quote_bgcolor1,
 833                                            NULL);
 834                 compose->quote1_tag = gtk_text_buffer_create_tag(buffer, "quote1",
 835                                            "foreground-gdk", &quote_color2,
 836                                            "paragraph-background-gdk", &quote_bgcolor2,
 837                                            NULL);
 838                 compose->quote2_tag = gtk_text_buffer_create_tag(buffer, "quote2",
 839                                            "foreground-gdk", &quote_color3,
 840                                            "paragraph-background-gdk", &quote_bgcolor3,
 841                                            NULL);
 842         } else {
 843                 compose->quote0_tag = gtk_text_buffer_create_tag(buffer, "quote0",
 844                                            "foreground-gdk", &quote_color1,
 845                                            NULL);
 846                 compose->quote1_tag = gtk_text_buffer_create_tag(buffer, "quote1",
 847                                            "foreground-gdk", &quote_color2,
 848                                            NULL);
 849                 compose->quote2_tag = gtk_text_buffer_create_tag(buffer, "quote2",
 850                                            "foreground-gdk", &quote_color3,
 851                                            NULL);
 852         }
 853
 854         compose->signature_tag = gtk_text_buffer_create_tag(buffer, "signature",
 855                                    "foreground-gdk", &signature_color,
 856                                    NULL);
 857
 858         compose->uri_tag = gtk_text_buffer_create_tag(buffer, "link",
 859                                         "foreground-gdk", &uri_color,
 860                                          NULL);
 861         compose->no_wrap_tag = gtk_text_buffer_create_tag(buffer, "no_wrap", NULL);
 862         compose->no_join_tag = gtk_text_buffer_create_tag(buffer, "no_join", NULL);
 863
 864         color[0] = quote_color1;
 865         color[1] = quote_color2;
 866         color[2] = quote_color3;
 867         color[3] = quote_bgcolor1;
 868         color[4] = quote_bgcolor2;
 869         color[5] = quote_bgcolor3;
 870         color[6] = signature_color;
 871         color[7] = uri_color;
 872 #if !GTK_CHECK_VERSION(2, 24, 0)
 873         cmap = gdk_drawable_get_colormap(gtk_widget_get_window(compose->window));
 874         gdk_colormap_alloc_colors(cmap, color, 8, FALSE, TRUE, success);
 875
 876         for (i = 0; i < 8; i++) {
 877                 if (success[i] == FALSE) {
 878                         GtkStyle *style;
 879
 880                         g_warning("Compose: color allocation failed.\n");
 881                         style = gtk_widget_get_style(GTK_WIDGET(text));
 882                         quote_color1 = quote_color2 = quote_color3 =
 883                                 quote_bgcolor1 = quote_bgcolor2 = quote_bgcolor3 =
 884                                 signature_color = uri_color = black;
 885                 }
 886         }
 887 #endif
 888 }
 889
 890 Compose *compose_new(PrefsAccount *account, const gchar *mailto,
 891                      GPtrArray *attach_files)
 892 {
 893         return compose_generic_new(account, mailto, NULL, attach_files, NULL);
 894 }
 895
 896 Compose *compose_new_with_folderitem(PrefsAccount *account, FolderItem *item, const gchar *mailto)
 897 {
 898         return compose_generic_new(account, mailto, item, NULL, NULL);
 899 }
 900
 901 Compose *compose_new_with_list( PrefsAccount *account, GList *listAddress )
 902 {
 903         return compose_generic_new( account, NULL, NULL, NULL, listAddress );
 904 }
 905
 906 #define SCROLL_TO_CURSOR(compose) {                             \
 907         GtkTextMark *cmark = gtk_text_buffer_get_insert(        \
 908                 gtk_text_view_get_buffer(                       \
 909                         GTK_TEXT_VIEW(compose->text)));         \
 910         gtk_text_view_scroll_mark_onscreen(                     \
 911                 GTK_TEXT_VIEW(compose->text),                   \
 912                 cmark);                                         \
 913 }
 914
 915 static void compose_set_save_to(Compose *compose, const gchar *folderidentifier)
 916 {
 917         GtkEditable *entry;
 918         if (folderidentifier) {
 919                 combobox_unset_popdown_strings(GTK_COMBO_BOX(compose->savemsg_combo));
 920                 prefs_common.compose_save_to_history = add_history(
 921                                 prefs_common.compose_save_to_history, folderidentifier);
 922                 combobox_set_popdown_strings(GTK_COMBO_BOX(compose->savemsg_combo),
 923                                 prefs_common.compose_save_to_history);
 924         }
 925
 926         entry = GTK_EDITABLE(gtk_bin_get_child(GTK_BIN(compose->savemsg_combo)));
 927         if (folderidentifier)
 928                 gtk_entry_set_text(GTK_ENTRY(entry), folderidentifier);
 929         else
 930                 gtk_entry_set_text(GTK_ENTRY(entry), "");
 931 }
 932
 933 static gchar *compose_get_save_to(Compose *compose)
 934 {
 935         GtkEditable *entry;
 936         gchar *result = NULL;
 937         entry = GTK_EDITABLE(gtk_bin_get_child(GTK_BIN(compose->savemsg_combo)));
 938         result = gtk_editable_get_chars(entry, 0, -1);
 939
 940         if (result) {
 941                 combobox_unset_popdown_strings(GTK_COMBO_BOX(compose->savemsg_combo));
 942                 prefs_common.compose_save_to_history = add_history(
 943                                 prefs_common.compose_save_to_history, result);
 944                 combobox_set_popdown_strings(GTK_COMBO_BOX(compose->savemsg_combo),
 945                                 prefs_common.compose_save_to_history);
 946         }
 947         return result;
 948 }
 949
 950 Compose *compose_generic_new(PrefsAccount *account, const gchar *mailto, FolderItem *item,
 951                              GPtrArray *attach_files, GList *listAddress )
 952 {
 953         Compose *compose;
 954         GtkTextView *textview;
 955         GtkTextBuffer *textbuf;
 956         GtkTextIter iter;
 957         const gchar *subject_format = NULL;
 958         const gchar *body_format = NULL;
 959         gchar *mailto_from = NULL;
 960         PrefsAccount *mailto_account = NULL;
 961         MsgInfo* dummyinfo = NULL;
 962         gint cursor_pos = -1;
 963         MailField mfield = NO_FIELD_PRESENT;
 964         gchar* buf;
 965         GtkTextMark *mark;
 966
 967         /* check if mailto defines a from */
 968         if (mailto && *mailto != '\0') {
 969                 scan_mailto_url(mailto, &mailto_from, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 970                 /* mailto defines a from, check if we can get account prefs from it,
 971                    if not, the account prefs will be guessed using other ways, but we'll keep
 972                    the from anyway */
 973                 if (mailto_from)
 974                         mailto_account = account_find_from_address(mailto_from, TRUE);
 975                 if (mailto_account)
 976                         account = mailto_account;
 977         }
 978
 979         /* if no account prefs set from mailto, set if from folder prefs (if any) */
 980         if (!mailto_account && item && item->prefs && item->prefs->enable_default_account)
 981                 account = account_find_from_id(item->prefs->default_account);
 982
 983         /* if no account prefs set, fallback to the current one */
 984         if (!account) account = cur_account;
 985         cm_return_val_if_fail(account != NULL, NULL);
 986
 987         compose = compose_create(account, item, COMPOSE_NEW, FALSE);
 988
 989         /* override from name if mailto asked for it */
 990         if (mailto_from) {
 991                 gtk_entry_set_text(GTK_ENTRY(compose->from_name), mailto_from);
 992                 g_free(mailto_from);
 993         } else
 994                 /* override from name according to folder properties */
 995                 if (item && item->prefs &&
 996                         item->prefs->compose_with_format &&
 997                         item->prefs->compose_override_from_format &&
 998                         *item->prefs->compose_override_from_format != '\0') {
 999
1000                         gchar *tmp = NULL;
1001                         gchar *buf = NULL;
1002
1003                         dummyinfo = compose_msginfo_new_from_compose(compose);
1004
1005                         /* decode \-escape sequences in the internal representation of the quote format */
1006                         tmp = g_malloc(strlen(item->prefs->compose_override_from_format)+1);
1007                         pref_get_unescaped_pref(tmp, item->prefs->compose_override_from_format);
1008
1009 #ifdef USE_ENCHANT
1010                         quote_fmt_init(dummyinfo, NULL, NULL, FALSE, compose->account, FALSE,
1011                                         compose->gtkaspell);
1012 #else
1013                         quote_fmt_init(dummyinfo, NULL, NULL, FALSE, compose->account, FALSE);
1014 #endif
1015                         quote_fmt_scan_string(tmp);
1016                         quote_fmt_parse();
1017
1018                         buf = quote_fmt_get_buffer();
1019                         if (buf == NULL)
1020                                 alertpanel_error(_("New message From format error."));
1021                         else
1022                                 gtk_entry_set_text(GTK_ENTRY(compose->from_name), buf);
1023                         quote_fmt_reset_vartable();
1024
1025                         g_free(tmp);
1026                 }
1027
1028         compose->replyinfo = NULL;
1029         compose->fwdinfo   = NULL;
1030
1031         textview = GTK_TEXT_VIEW(compose->text);
1032         textbuf = gtk_text_view_get_buffer(textview);
1033         compose_create_tags(textview, compose);
1034
1035         undo_block(compose->undostruct);
1036 #ifdef USE_ENCHANT
1037         compose_set_dictionaries_from_folder_prefs(compose, item);
1038 #endif
1039
1040         if (account->auto_sig)
1041                 compose_insert_sig(compose, FALSE);
1042         gtk_text_buffer_get_start_iter(textbuf, &iter);
1043         gtk_text_buffer_place_cursor(textbuf, &iter);
1044
1045         if (account->protocol != A_NNTP) {
1046                 if (mailto && *mailto != '\0') {
1047                         mfield = compose_entries_set(compose, mailto, COMPOSE_TO);
1048
1049                 } else {
1050                         compose_set_folder_prefs(compose, item, TRUE);
1051                 }
1052                 if (item && item->ret_rcpt) {
1053                         cm_toggle_menu_set_active_full(compose->ui_manager, "Menu/Options/RequestRetRcpt", TRUE);
1054                 }
1055         } else {
1056                 if (mailto && *mailto != '\0') {
1057                         if (!strchr(mailto, '@'))
1058                                 mfield = compose_entries_set(compose, mailto, COMPOSE_NEWSGROUPS);
1059                         else
1060                                 mfield = compose_entries_set(compose, mailto, COMPOSE_TO);
1061                 } else if (item && FOLDER_CLASS(item->folder) == news_get_class()) {
1062                         compose_entry_append(compose, item->path, COMPOSE_NEWSGROUPS, PREF_FOLDER);
1063                         mfield = TO_FIELD_PRESENT;
1064                 }
1065                 /*
1066                  * CLAWS: just don't allow return receipt request, even if the user
1067                  * may want to send an email. simple but foolproof.
1068                  */
1069                 cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Options/RequestRetRcpt", FALSE);
1070         }
1071         compose_add_field_list( compose, listAddress );
1072
1073         if (item && item->prefs && item->prefs->compose_with_format) {
1074                 subject_format = item->prefs->compose_subject_format;
1075                 body_format = item->prefs->compose_body_format;
1076         } else if (account->compose_with_format) {
1077                 subject_format = account->compose_subject_format;
1078                 body_format = account->compose_body_format;
1079         } else if (prefs_common.compose_with_format) {
1080                 subject_format = prefs_common.compose_subject_format;
1081                 body_format = prefs_common.compose_body_format;
1082         }
1083
1084         if (subject_format || body_format) {
1085
1086                 if ( subject_format
1087                          && *subject_format != '\0' )
1088                 {
1089                         gchar *subject = NULL;
1090                         gchar *tmp = NULL;
1091                         gchar *buf = NULL;
1092
1093                         if (!dummyinfo)
1094                                 dummyinfo = compose_msginfo_new_from_compose(compose);
1095
1096                         /* decode \-escape sequences in the internal representation of the quote format */
1097                         tmp = g_malloc(strlen(subject_format)+1);
1098                         pref_get_unescaped_pref(tmp, subject_format);
1099
1100                         subject = gtk_editable_get_chars(GTK_EDITABLE(compose->subject_entry), 0, -1);
1101 #ifdef USE_ENCHANT
1102                         quote_fmt_init(dummyinfo, NULL, subject, FALSE, compose->account, FALSE,
1103                                         compose->gtkaspell);
1104 #else
1105                         quote_fmt_init(dummyinfo, NULL, subject, FALSE, compose->account, FALSE);
1106 #endif
1107                         quote_fmt_scan_string(tmp);
1108                         quote_fmt_parse();
1109
1110                         buf = quote_fmt_get_buffer();
1111                         if (buf == NULL)
1112                                 alertpanel_error(_("New message subject format error."));
1113                         else
1114                                 gtk_entry_set_text(GTK_ENTRY(compose->subject_entry), buf);
1115                         compose_attach_from_list(compose, quote_fmt_get_attachments_list(), FALSE);
1116                         quote_fmt_reset_vartable();
1117
1118                         g_free(subject);
1119                         g_free(tmp);
1120                         mfield = SUBJECT_FIELD_PRESENT;
1121                 }
1122
1123                 if ( body_format
1124                          && *body_format != '\0' )
1125                 {
1126                         GtkTextView *text;
1127                         GtkTextBuffer *buffer;
1128                         GtkTextIter start, end;
1129                         gchar *tmp = NULL;
1130
1131                         if (!dummyinfo)
1132                                 dummyinfo = compose_msginfo_new_from_compose(compose);
1133
1134                         text = GTK_TEXT_VIEW(compose->text);
1135                         buffer = gtk_text_view_get_buffer(text);
1136                         gtk_text_buffer_get_start_iter(buffer, &start);
1137                         gtk_text_buffer_get_iter_at_offset(buffer, &end, -1);
1138                         tmp = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
1139
1140                         compose_quote_fmt(compose, dummyinfo,
1141                                           body_format,
1142                                           NULL, tmp, FALSE, TRUE,
1143                                                   _("The body of the \"New message\" template has an error at line %d."));
1144                         compose_attach_from_list(compose, quote_fmt_get_attachments_list(), FALSE);
1145                         quote_fmt_reset_vartable();
1146
1147                         g_free(tmp);
1148 #ifdef USE_ENCHANT
1149                         if (compose->gtkaspell && compose->gtkaspell->check_while_typing)
1150                                 gtkaspell_highlight_all(compose->gtkaspell);
1151 #endif
1152                         mfield = BODY_FIELD_PRESENT;
1153                 }
1154
1155         }
1156         procmsg_msginfo_free( dummyinfo );
1157
1158         if (attach_files) {
1159                 gint i;
1160                 gchar *file;
1161
1162                 for (i = 0; i < attach_files->len; i++) {
1163                         file = g_ptr_array_index(attach_files, i);
1164                         compose_attach_append(compose, file, file, NULL, NULL);
1165                 }
1166         }
1167
1168         compose_show_first_last_header(compose, TRUE);
1169
1170         /* Set save folder */
1171         if (item && item->prefs && item->prefs->save_copy_to_folder) {
1172                 gchar *folderidentifier;
1173
1174                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(compose->savemsg_checkbtn), prefs_common.savemsg);
1175                 folderidentifier = folder_item_get_identifier(item);
1176                 compose_set_save_to(compose, folderidentifier);
1177                 g_free(folderidentifier);
1178         }
1179
1180         /* Place cursor according to provided input (mfield) */
1181         switch (mfield) {
1182                 case NO_FIELD_PRESENT:
1183                         if (compose->header_last)
1184                                 gtk_widget_grab_focus(compose->header_last->entry);
1185                         break;
1186                 case TO_FIELD_PRESENT:
1187                         buf = gtk_editable_get_chars(GTK_EDITABLE(compose->subject_entry), 0, -1);
1188                         if (buf) {
1189                                 gtk_entry_set_text(GTK_ENTRY(compose->subject_entry), buf);
1190                                 g_free(buf);
1191                         }
1192                         gtk_widget_grab_focus(compose->subject_entry);
1193                         break;
1194                 case SUBJECT_FIELD_PRESENT:
1195                         textview = GTK_TEXT_VIEW(compose->text);
1196                         if (!textview)
1197                                 break;
1198                         textbuf = gtk_text_view_get_buffer(textview);
1199                         if (!textbuf)
1200                                 break;
1201                         mark = gtk_text_buffer_get_insert(textbuf);
1202                         gtk_text_buffer_get_iter_at_mark(textbuf, &iter, mark);
1203                         gtk_text_buffer_insert(textbuf, &iter, "", -1);
1204                     /*
1205                      * SUBJECT_FIELD_PRESENT and BODY_FIELD_PRESENT
1206                      * only defers where it comes to the variable body
1207                      * is not null. If no body is present compose->text
1208                      * will be null in which case you cannot place the
1209                      * cursor inside the component so. An empty component
1210                      * is therefore created before placing the cursor
1211                      */
1212                 case BODY_FIELD_PRESENT:
1213                         cursor_pos = quote_fmt_get_cursor_pos();
1214                         if (cursor_pos == -1)
1215                                 gtk_widget_grab_focus(compose->header_last->entry);
1216                         else
1217                                 gtk_widget_grab_focus(compose->text);
1218                         break;
1219         }
1220
1221         undo_unblock(compose->undostruct);
1222
1223         if (prefs_common.auto_exteditor)
1224                 compose_exec_ext_editor(compose);
1225
1226         compose->draft_timeout_tag = -1;
1227         SCROLL_TO_CURSOR(compose);
1228
1229         compose->modified = FALSE;
1230         compose_set_title(compose);
1231
1232         hooks_invoke(COMPOSE_CREATED_HOOKLIST, compose);
1233
1234         return compose;
1235 }
1236
1237 static void compose_force_encryption(Compose *compose, PrefsAccount *account,
1238                 gboolean override_pref, const gchar *system)
1239 {
1240         const gchar *privacy = NULL;
1241
1242         cm_return_if_fail(compose != NULL);
1243         cm_return_if_fail(account != NULL);
1244
1245         if (override_pref == FALSE && account->default_encrypt_reply == FALSE)
1246                 return;
1247
1248         if (system)
1249                 privacy = system;
1250         else if (account->default_privacy_system
1251         &&  strlen(account->default_privacy_system)) {
1252                 privacy = account->default_privacy_system;
1253         } else {
1254                 GSList *privacy_avail = privacy_get_system_ids();
1255                 if (privacy_avail && g_slist_length(privacy_avail)) {
1256                         privacy = (gchar *)(privacy_avail->data);
1257                 }
1258         }
1259         if (privacy != NULL) {
1260                 if (system) {
1261                         g_free(compose->privacy_system);
1262                         compose->privacy_system = NULL;
1263                 }
1264                 if (compose->privacy_system == NULL)
1265                         compose->privacy_system = g_strdup(privacy);
1266                 else if (*(compose->privacy_system) == '\0') {
1267                         g_free(compose->privacy_system);
1268                         compose->privacy_system = g_strdup(privacy);
1269                 }
1270                 compose_update_privacy_system_menu_item(compose, FALSE);
1271                 compose_use_encryption(compose, TRUE);
1272         }
1273 }
1274
1275 static void compose_force_signing(Compose *compose, PrefsAccount *account, const gchar *system)
1276 {
1277         const gchar *privacy = NULL;
1278
1279         if (system)
1280                 privacy = system;
1281         else if (account->default_privacy_system
1282         &&  strlen(account->default_privacy_system)) {
1283                 privacy = account->default_privacy_system;
1284         } else {
1285                 GSList *privacy_avail = privacy_get_system_ids();
1286                 if (privacy_avail && g_slist_length(privacy_avail)) {
1287                         privacy = (gchar *)(privacy_avail->data);
1288                 }
1289         }
1290
1291         if (privacy != NULL) {
1292                 if (system) {
1293                         g_free(compose->privacy_system);
1294                         compose->privacy_system = NULL;
1295                 }
1296                 if (compose->privacy_system == NULL)
1297                         compose->privacy_system = g_strdup(privacy);
1298                 compose_update_privacy_system_menu_item(compose, FALSE);
1299                 compose_use_signing(compose, TRUE);
1300         }
1301 }
1302
1303 static Compose *compose_reply_mode(ComposeMode mode, GSList *msginfo_list, gchar *body)
1304 {
1305         MsgInfo *msginfo;
1306         guint list_len;
1307         Compose *compose = NULL;
1308
1309         cm_return_val_if_fail(msginfo_list != NULL, NULL);
1310
1311         msginfo = (MsgInfo*)g_slist_nth_data(msginfo_list, 0);
1312         cm_return_val_if_fail(msginfo != NULL, NULL);
1313
1314         list_len = g_slist_length(msginfo_list);
1315
1316         switch (mode) {
1317         case COMPOSE_REPLY:
1318         case COMPOSE_REPLY_TO_ADDRESS:
1319                 compose = compose_reply(msginfo, COMPOSE_QUOTE_CHECK,
1320                               FALSE, prefs_common.default_reply_list, FALSE, body);
1321                 break;
1322         case COMPOSE_REPLY_WITH_QUOTE:
1323                 compose = compose_reply(msginfo, COMPOSE_QUOTE_FORCED,
1324                         FALSE, prefs_common.default_reply_list, FALSE, body);
1325                 break;
1326         case COMPOSE_REPLY_WITHOUT_QUOTE:
1327                 compose = compose_reply(msginfo, COMPOSE_QUOTE_SKIP,
1328                         FALSE, prefs_common.default_reply_list, FALSE, NULL);
1329                 break;
1330         case COMPOSE_REPLY_TO_SENDER:
1331                 compose = compose_reply(msginfo, COMPOSE_QUOTE_CHECK,
1332                               FALSE, FALSE, TRUE, body);
1333                 break;
1334         case COMPOSE_FOLLOWUP_AND_REPLY_TO:
1335                 compose = compose_followup_and_reply_to(msginfo,
1336                                               COMPOSE_QUOTE_CHECK,
1337                                               FALSE, FALSE, body);
1338                 break;
1339         case COMPOSE_REPLY_TO_SENDER_WITH_QUOTE:
1340                 compose = compose_reply(msginfo, COMPOSE_QUOTE_FORCED,
1341                         FALSE, FALSE, TRUE, body);
1342                 break;
1343         case COMPOSE_REPLY_TO_SENDER_WITHOUT_QUOTE:
1344                 compose = compose_reply(msginfo, COMPOSE_QUOTE_SKIP,
1345                         FALSE, FALSE, TRUE, NULL);
1346                 break;
1347         case COMPOSE_REPLY_TO_ALL:
1348                 compose = compose_reply(msginfo, COMPOSE_QUOTE_CHECK,
1349                         TRUE, FALSE, FALSE, body);
1350                 break;
1351         case COMPOSE_REPLY_TO_ALL_WITH_QUOTE:
1352                 compose = compose_reply(msginfo, COMPOSE_QUOTE_FORCED,
1353                         TRUE, FALSE, FALSE, body);
1354                 break;
1355         case COMPOSE_REPLY_TO_ALL_WITHOUT_QUOTE:
1356                 compose = compose_reply(msginfo, COMPOSE_QUOTE_SKIP,
1357                         TRUE, FALSE, FALSE, NULL);
1358                 break;
1359         case COMPOSE_REPLY_TO_LIST:
1360                 compose = compose_reply(msginfo, COMPOSE_QUOTE_CHECK,
1361                         FALSE, TRUE, FALSE, body);
1362                 break;
1363         case COMPOSE_REPLY_TO_LIST_WITH_QUOTE:
1364                 compose = compose_reply(msginfo, COMPOSE_QUOTE_FORCED,
1365                         FALSE, TRUE, FALSE, body);
1366                 break;
1367         case COMPOSE_REPLY_TO_LIST_WITHOUT_QUOTE:
1368                 compose = compose_reply(msginfo, COMPOSE_QUOTE_SKIP,
1369                         FALSE, TRUE, FALSE, NULL);
1370                 break;
1371         case COMPOSE_FORWARD:
1372                 if (prefs_common.forward_as_attachment) {
1373                         compose = compose_reply_mode(COMPOSE_FORWARD_AS_ATTACH, msginfo_list, body);
1374                         return compose;
1375                 } else {
1376                         compose = compose_reply_mode(COMPOSE_FORWARD_INLINE, msginfo_list, body);
1377                         return compose;
1378                 }
1379                 break;
1380         case COMPOSE_FORWARD_INLINE:
1381                 /* check if we reply to more than one Message */
1382                 if (list_len == 1) {
1383                         compose = compose_forward(NULL, msginfo, FALSE, body, FALSE, FALSE);
1384                         break;
1385                 }
1386                 /* more messages FALL THROUGH */
1387         case COMPOSE_FORWARD_AS_ATTACH:
1388                 compose = compose_forward_multiple(NULL, msginfo_list);
1389                 break;
1390         case COMPOSE_REDIRECT:
1391                 compose = compose_redirect(NULL, msginfo, FALSE);
1392                 break;
1393         default:
1394                 g_warning("compose_reply_mode(): invalid Compose Mode: %d\n", mode);
1395         }
1396
1397         if (compose == NULL) {
1398                 alertpanel_error(_("Unable to reply. The original email probably doesn't exist."));
1399                 return NULL;
1400         }
1401
1402         compose->rmode = mode;
1403         switch (compose->rmode) {
1404         case COMPOSE_REPLY:
1405         case COMPOSE_REPLY_WITH_QUOTE:
1406         case COMPOSE_REPLY_WITHOUT_QUOTE:
1407         case COMPOSE_FOLLOWUP_AND_REPLY_TO:
1408                 debug_print("reply mode Normal\n");
1409                 cm_toggle_menu_set_active_full(compose->ui_manager, "Menu/Options/ReplyMode/Normal", TRUE);
1410                 compose_reply_change_mode(compose, COMPOSE_REPLY); /* force update */
1411                 break;
1412         case COMPOSE_REPLY_TO_SENDER:
1413         case COMPOSE_REPLY_TO_SENDER_WITH_QUOTE:
1414         case COMPOSE_REPLY_TO_SENDER_WITHOUT_QUOTE:
1415                 debug_print("reply mode Sender\n");
1416                 cm_toggle_menu_set_active_full(compose->ui_manager, "Menu/Options/ReplyMode/Sender", TRUE);
1417                 break;
1418         case COMPOSE_REPLY_TO_ALL:
1419         case COMPOSE_REPLY_TO_ALL_WITH_QUOTE:
1420         case COMPOSE_REPLY_TO_ALL_WITHOUT_QUOTE:
1421                 debug_print("reply mode All\n");
1422                 cm_toggle_menu_set_active_full(compose->ui_manager, "Menu/Options/ReplyMode/All", TRUE);
1423                 break;
1424         case COMPOSE_REPLY_TO_LIST:
1425         case COMPOSE_REPLY_TO_LIST_WITH_QUOTE:
1426         case COMPOSE_REPLY_TO_LIST_WITHOUT_QUOTE:
1427                 debug_print("reply mode List\n");
1428                 cm_toggle_menu_set_active_full(compose->ui_manager, "Menu/Options/ReplyMode/List", TRUE);
1429                 break;
1430         case COMPOSE_REPLY_TO_ADDRESS:
1431                 cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Options/ReplyMode", FALSE);
1432                 break;
1433         default:
1434                 break;
1435         }
1436         return compose;
1437 }
1438
1439 static Compose *compose_reply(MsgInfo *msginfo,
1440                                    ComposeQuoteMode quote_mode,
1441                                    gboolean to_all,
1442                                    gboolean to_ml,
1443                                    gboolean to_sender,
1444                                    const gchar *body)
1445 {
1446         return compose_generic_reply(msginfo, quote_mode, to_all, to_ml,
1447                               to_sender, FALSE, body);
1448 }
1449
1450 static Compose *compose_followup_and_reply_to(MsgInfo *msginfo,
1451                                    ComposeQuoteMode quote_mode,
1452                                    gboolean to_all,
1453                                    gboolean to_sender,
1454                                    const gchar *body)
1455 {
1456         return compose_generic_reply(msginfo, quote_mode, to_all, FALSE,
1457                               to_sender, TRUE, body);
1458 }
1459
1460 static void compose_extract_original_charset(Compose *compose)
1461 {
1462         MsgInfo *info = NULL;
1463         if (compose->replyinfo) {
1464                 info = compose->replyinfo;
1465         } else if (compose->fwdinfo) {
1466                 info = compose->fwdinfo;
1467         } else if (compose->targetinfo) {
1468                 info = compose->targetinfo;
1469         }
1470         if (info) {
1471                 MimeInfo *mimeinfo = procmime_scan_message_short(info);
1472                 MimeInfo *partinfo = mimeinfo;
1473                 while (partinfo && partinfo->type != MIMETYPE_TEXT)
1474                         partinfo = procmime_mimeinfo_next(partinfo);
1475                 if (partinfo) {
1476                         compose->orig_charset =
1477                                 g_strdup(procmime_mimeinfo_get_parameter(
1478                                                 partinfo, "charset"));
1479                 }
1480                 procmime_mimeinfo_free_all(mimeinfo);
1481         }
1482 }
1483
1484 #define SIGNAL_BLOCK(buffer) {                                  \
1485         g_signal_handlers_block_by_func(G_OBJECT(buffer),       \
1486                                 G_CALLBACK(compose_changed_cb), \
1487                                 compose);                       \
1488         g_signal_handlers_block_by_func(G_OBJECT(buffer),       \
1489                                 G_CALLBACK(text_inserted),      \
1490                                 compose);                       \
1491 }
1492
1493 #define SIGNAL_UNBLOCK(buffer) {                                \
1494         g_signal_handlers_unblock_by_func(G_OBJECT(buffer),     \
1495                                 G_CALLBACK(compose_changed_cb), \
1496                                 compose);                       \
1497         g_signal_handlers_unblock_by_func(G_OBJECT(buffer),     \
1498                                 G_CALLBACK(text_inserted),      \
1499                                 compose);                       \
1500 }
1501
1502 static Compose *compose_generic_reply(MsgInfo *msginfo,
1503                                   ComposeQuoteMode quote_mode,
1504                                   gboolean to_all, gboolean to_ml,
1505                                   gboolean to_sender,
1506                                   gboolean followup_and_reply_to,
1507                                   const gchar *body)
1508 {
1509         Compose *compose;
1510         PrefsAccount *account = NULL;
1511         GtkTextView *textview;
1512         GtkTextBuffer *textbuf;
1513         gboolean quote = FALSE;
1514         const gchar *qmark = NULL;
1515         const gchar *body_fmt = NULL;
1516         gchar *s_system = NULL;
1517         START_TIMING("");
1518         cm_return_val_if_fail(msginfo != NULL, NULL);
1519         cm_return_val_if_fail(msginfo->folder != NULL, NULL);
1520
1521         account = account_get_reply_account(msginfo, prefs_common.reply_account_autosel);
1522
1523         cm_return_val_if_fail(account != NULL, NULL);
1524
1525         compose = compose_create(account, msginfo->folder, COMPOSE_REPLY, FALSE);
1526
1527         compose->updating = TRUE;
1528
1529         cm_toggle_menu_set_active_full(compose->ui_manager, "Menu/Options/RemoveReferences", FALSE);
1530         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Options/RemoveReferences", TRUE);
1531
1532         compose->replyinfo = procmsg_msginfo_get_full_info(msginfo);
1533         if (!compose->replyinfo)
1534                 compose->replyinfo = procmsg_msginfo_copy(msginfo);
1535
1536         compose_extract_original_charset(compose);
1537
1538         if (msginfo->folder && msginfo->folder->ret_rcpt)
1539                 cm_toggle_menu_set_active_full(compose->ui_manager, "Menu/Options/RequestRetRcpt", TRUE);
1540
1541         /* Set save folder */
1542         if (msginfo->folder && msginfo->folder->prefs && msginfo->folder->prefs->save_copy_to_folder) {
1543                 gchar *folderidentifier;
1544
1545                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(compose->savemsg_checkbtn), TRUE);
1546                 folderidentifier = folder_item_get_identifier(msginfo->folder);
1547                 compose_set_save_to(compose, folderidentifier);
1548                 g_free(folderidentifier);
1549         }
1550
1551         if (compose_parse_header(compose, msginfo) < 0) {
1552                 compose->updating = FALSE;
1553                 compose_destroy(compose);
1554                 return NULL;
1555         }
1556
1557         /* override from name according to folder properties */
1558         if (msginfo->folder && msginfo->folder->prefs &&
1559                 msginfo->folder->prefs->reply_with_format &&
1560                 msginfo->folder->prefs->reply_override_from_format &&
1561                 *msginfo->folder->prefs->reply_override_from_format != '\0') {
1562
1563                 gchar *tmp = NULL;
1564                 gchar *buf = NULL;
1565
1566                 /* decode \-escape sequences in the internal representation of the quote format */
1567                 tmp = g_malloc(strlen(msginfo->folder->prefs->reply_override_from_format)+1);
1568                 pref_get_unescaped_pref(tmp, msginfo->folder->prefs->reply_override_from_format);
1569
1570 #ifdef USE_ENCHANT
1571                 quote_fmt_init(compose->replyinfo, NULL, NULL, FALSE, compose->account, FALSE,
1572                                 compose->gtkaspell);
1573 #else
1574                 quote_fmt_init(compose->replyinfo, NULL, NULL, FALSE, compose->account, FALSE);
1575 #endif
1576                 quote_fmt_scan_string(tmp);
1577                 quote_fmt_parse();
1578
1579                 buf = quote_fmt_get_buffer();
1580                 if (buf == NULL)
1581                         alertpanel_error(_("The \"From\" field of the \"Reply\" template contains an invalid email address."));
1582                 else
1583                         gtk_entry_set_text(GTK_ENTRY(compose->from_name), buf);
1584                 quote_fmt_reset_vartable();
1585
1586                 g_free(tmp);
1587         }
1588
1589         textview = (GTK_TEXT_VIEW(compose->text));
1590         textbuf = gtk_text_view_get_buffer(textview);
1591         compose_create_tags(textview, compose);
1592
1593         undo_block(compose->undostruct);
1594 #ifdef USE_ENCHANT
1595                 compose_set_dictionaries_from_folder_prefs(compose, msginfo->folder);
1596 #endif
1597
1598         if (quote_mode == COMPOSE_QUOTE_FORCED ||
1599                         (quote_mode == COMPOSE_QUOTE_CHECK && prefs_common.reply_with_quote)) {
1600                 /* use the reply format of folder (if enabled), or the account's one
1601                    (if enabled) or fallback to the global reply format, which is always
1602                    enabled (even if empty), and use the relevant quotemark */
1603                 quote = TRUE;
1604                 if (msginfo->folder && msginfo->folder->prefs &&
1605                                 msginfo->folder->prefs->reply_with_format) {
1606                         qmark = msginfo->folder->prefs->reply_quotemark;
1607                         body_fmt = msginfo->folder->prefs->reply_body_format;
1608
1609                 } else if (account->reply_with_format) {
1610                         qmark = account->reply_quotemark;
1611                         body_fmt = account->reply_body_format;
1612
1613                 } else {
1614                         qmark = prefs_common.quotemark;
1615                         if (prefs_common.quotefmt && *prefs_common.quotefmt)
1616                                 body_fmt = gettext(prefs_common.quotefmt);
1617                         else
1618                                 body_fmt = "";
1619                 }
1620         }
1621
1622         if (quote) {
1623                 /* empty quotemark is not allowed */
1624                 if (qmark == NULL || *qmark == '\0')
1625                         qmark = "> ";
1626                 compose_quote_fmt(compose, compose->replyinfo,
1627                                   body_fmt, qmark, body, FALSE, TRUE,
1628                                           _("The body of the \"Reply\" template has an error at line %d."));
1629                 compose_attach_from_list(compose, quote_fmt_get_attachments_list(), FALSE);
1630                 quote_fmt_reset_vartable();
1631 #ifdef USE_ENCHANT
1632                 if (compose->gtkaspell && compose->gtkaspell->check_while_typing)
1633                         gtkaspell_highlight_all(compose->gtkaspell);
1634 #endif
1635         }
1636
1637         if (MSG_IS_ENCRYPTED(compose->replyinfo->flags)) {
1638                 compose_force_encryption(compose, account, FALSE, s_system);
1639         }
1640
1641         privacy_msginfo_get_signed_state(compose->replyinfo, &s_system);
1642         if (MSG_IS_SIGNED(compose->replyinfo->flags) && account->default_sign_reply) {
1643                 compose_force_signing(compose, account, s_system);
1644         }
1645         g_free(s_system);
1646
1647         SIGNAL_BLOCK(textbuf);
1648
1649         if (account->auto_sig)
1650                 compose_insert_sig(compose, FALSE);
1651
1652         compose_wrap_all(compose);
1653
1654         SIGNAL_UNBLOCK(textbuf);
1655
1656         gtk_widget_grab_focus(compose->text);
1657
1658         undo_unblock(compose->undostruct);
1659
1660         if (prefs_common.auto_exteditor)
1661                 compose_exec_ext_editor(compose);
1662
1663         compose->modified = FALSE;
1664         compose_set_title(compose);
1665
1666         compose->updating = FALSE;
1667         compose->draft_timeout_tag = -1; /* desinhibit auto-drafting after loading */
1668         SCROLL_TO_CURSOR(compose);
1669
1670         if (compose->deferred_destroy) {
1671                 compose_destroy(compose);
1672                 return NULL;
1673         }
1674         END_TIMING();
1675
1676         return compose;
1677 }
1678
1679 #define INSERT_FW_HEADER(var, hdr) \
1680 if (msginfo->var && *msginfo->var) { \
1681         gtk_stext_insert(text, NULL, NULL, NULL, hdr, -1); \
1682         gtk_stext_insert(text, NULL, NULL, NULL, msginfo->var, -1); \
1683         gtk_stext_insert(text, NULL, NULL, NULL, "\n", 1); \
1684 }
1685
1686 Compose *compose_forward(PrefsAccount *account, MsgInfo *msginfo,
1687                          gboolean as_attach, const gchar *body,
1688                          gboolean no_extedit,
1689                          gboolean batch)
1690 {
1691         Compose *compose;
1692         GtkTextView *textview;
1693         GtkTextBuffer *textbuf;
1694         gint cursor_pos = -1;
1695         ComposeMode mode;
1696
1697         cm_return_val_if_fail(msginfo != NULL, NULL);
1698         cm_return_val_if_fail(msginfo->folder != NULL, NULL);
1699
1700         if (!account &&
1701             !(account = compose_guess_forward_account_from_msginfo
1702                                 (msginfo)))
1703                 account = cur_account;
1704
1705         if (!prefs_common.forward_as_attachment)
1706                 mode = COMPOSE_FORWARD_INLINE;
1707         else
1708                 mode = COMPOSE_FORWARD;
1709         compose = compose_create(account, msginfo->folder, mode, batch);
1710
1711         compose->updating = TRUE;
1712         compose->fwdinfo = procmsg_msginfo_get_full_info(msginfo);
1713         if (!compose->fwdinfo)
1714                 compose->fwdinfo = procmsg_msginfo_copy(msginfo);
1715
1716         compose_extract_original_charset(compose);
1717
1718         if (msginfo->subject && *msginfo->subject) {
1719                 gchar *buf, *buf2, *p;
1720
1721                 buf = p = g_strdup(msginfo->subject);
1722                 p += subject_get_prefix_length(p);
1723                 memmove(buf, p, strlen(p) + 1);
1724
1725                 buf2 = g_strdup_printf("Fw: %s", buf);
1726                 gtk_entry_set_text(GTK_ENTRY(compose->subject_entry), buf2);
1727
1728                 g_free(buf);
1729                 g_free(buf2);
1730         }
1731
1732         /* override from name according to folder properties */
1733         if (msginfo->folder && msginfo->folder->prefs &&
1734                 msginfo->folder->prefs->forward_with_format &&
1735                 msginfo->folder->prefs->forward_override_from_format &&
1736                 *msginfo->folder->prefs->forward_override_from_format != '\0') {
1737
1738                 gchar *tmp = NULL;
1739                 gchar *buf = NULL;
1740                 MsgInfo *full_msginfo = NULL;
1741
1742                 if (!as_attach)
1743                         full_msginfo = procmsg_msginfo_get_full_info(msginfo);
1744                 if (!full_msginfo)
1745                         full_msginfo = procmsg_msginfo_copy(msginfo);
1746
1747                 /* decode \-escape sequences in the internal representation of the quote format */
1748                 tmp = g_malloc(strlen(msginfo->folder->prefs->forward_override_from_format)+1);
1749                 pref_get_unescaped_pref(tmp, msginfo->folder->prefs->forward_override_from_format);
1750
1751 #ifdef USE_ENCHANT
1752                 quote_fmt_init(full_msginfo, NULL, NULL, FALSE, compose->account, FALSE,
1753                                 compose->gtkaspell);
1754 #else
1755                 quote_fmt_init(full_msginfo, NULL, NULL, FALSE, compose->account, FALSE);
1756 #endif
1757                 quote_fmt_scan_string(tmp);
1758                 quote_fmt_parse();
1759
1760                 buf = quote_fmt_get_buffer();
1761                 if (buf == NULL)
1762                         alertpanel_error(_("The \"From\" field of the \"Forward\" template contains an invalid email address."));
1763                 else
1764                         gtk_entry_set_text(GTK_ENTRY(compose->from_name), buf);
1765                 quote_fmt_reset_vartable();
1766
1767                 g_free(tmp);
1768                 procmsg_msginfo_free(full_msginfo);
1769         }
1770
1771         textview = GTK_TEXT_VIEW(compose->text);
1772         textbuf = gtk_text_view_get_buffer(textview);
1773         compose_create_tags(textview, compose);
1774
1775         undo_block(compose->undostruct);
1776         if (as_attach) {
1777                 gchar *msgfile;
1778
1779                 msgfile = procmsg_get_message_file(msginfo);
1780                 if (!is_file_exist(msgfile))
1781                         g_warning("%s: file not exist\n", msgfile);
1782                 else
1783                         compose_attach_append(compose, msgfile, msgfile,
1784                                               "message/rfc822", NULL);
1785
1786                 g_free(msgfile);
1787         } else {
1788                 const gchar *qmark = NULL;
1789                 const gchar *body_fmt = NULL;
1790                 MsgInfo *full_msginfo;
1791
1792                 if (prefs_common.fw_quotefmt && *prefs_common.fw_quotefmt)
1793                         body_fmt = gettext(prefs_common.fw_quotefmt);
1794                 else
1795                         body_fmt = "";
1796
1797                 full_msginfo = procmsg_msginfo_get_full_info(msginfo);
1798                 if (!full_msginfo)
1799                         full_msginfo = procmsg_msginfo_copy(msginfo);
1800
1801                 /* use the forward format of folder (if enabled), or the account's one
1802                    (if enabled) or fallback to the global forward format, which is always
1803                    enabled (even if empty), and use the relevant quotemark */
1804                 if (msginfo->folder && msginfo->folder->prefs &&
1805                                 msginfo->folder->prefs->forward_with_format) {
1806                         qmark = msginfo->folder->prefs->forward_quotemark;
1807                         body_fmt = msginfo->folder->prefs->forward_body_format;
1808
1809                 } else if (account->forward_with_format) {
1810                         qmark = account->forward_quotemark;
1811                         body_fmt = account->forward_body_format;
1812
1813                 } else {
1814                         qmark = prefs_common.fw_quotemark;
1815                         if (prefs_common.fw_quotefmt && *prefs_common.fw_quotefmt)
1816                                 body_fmt = gettext(prefs_common.fw_quotefmt);
1817                         else
1818                                 body_fmt = "";
1819                 }
1820
1821                 /* empty quotemark is not allowed */
1822                 if (qmark == NULL || *qmark == '\0')
1823                         qmark = "> ";
1824
1825                 compose_quote_fmt(compose, full_msginfo,
1826                                   body_fmt, qmark, body, FALSE, TRUE,
1827                                           _("The body of the \"Forward\" template has an error at line %d."));
1828                 compose_attach_from_list(compose, quote_fmt_get_attachments_list(), FALSE);
1829                 quote_fmt_reset_vartable();
1830                 compose_attach_parts(compose, msginfo);
1831
1832                 procmsg_msginfo_free(full_msginfo);
1833 #ifdef USE_ENCHANT
1834                 if (compose->gtkaspell && compose->gtkaspell->check_while_typing)
1835                         gtkaspell_highlight_all(compose->gtkaspell);
1836 #endif
1837         }
1838
1839         SIGNAL_BLOCK(textbuf);
1840
1841         if (account->auto_sig)
1842                 compose_insert_sig(compose, FALSE);
1843
1844         compose_wrap_all(compose);
1845
1846         SIGNAL_UNBLOCK(textbuf);
1847
1848         cursor_pos = quote_fmt_get_cursor_pos();
1849         if (cursor_pos == -1)
1850                 gtk_widget_grab_focus(compose->header_last->entry);
1851         else
1852                 gtk_widget_grab_focus(compose->text);
1853
1854         if (!no_extedit && prefs_common.auto_exteditor)
1855                 compose_exec_ext_editor(compose);
1856
1857         /*save folder*/
1858         if (msginfo->folder && msginfo->folder->prefs && msginfo->folder->prefs->save_copy_to_folder) {
1859                 gchar *folderidentifier;
1860
1861                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(compose->savemsg_checkbtn), TRUE);
1862                 folderidentifier = folder_item_get_identifier(msginfo->folder);
1863                 compose_set_save_to(compose, folderidentifier);
1864                 g_free(folderidentifier);
1865         }
1866
1867         undo_unblock(compose->undostruct);
1868
1869         compose->modified = FALSE;
1870         compose_set_title(compose);
1871
1872         compose->updating = FALSE;
1873         compose->draft_timeout_tag = -1; /* desinhibit auto-drafting after loading */
1874         SCROLL_TO_CURSOR(compose);
1875
1876         if (compose->deferred_destroy) {
1877                 compose_destroy(compose);
1878                 return NULL;
1879         }
1880
1881         hooks_invoke(COMPOSE_CREATED_HOOKLIST, compose);
1882
1883         return compose;
1884 }
1885
1886 #undef INSERT_FW_HEADER
1887
1888 static Compose *compose_forward_multiple(PrefsAccount *account, GSList *msginfo_list)
1889 {
1890         Compose *compose;
1891         GtkTextView *textview;
1892         GtkTextBuffer *textbuf;
1893         GtkTextIter iter;
1894         GSList *msginfo;
1895         gchar *msgfile;
1896         gboolean single_mail = TRUE;
1897
1898         cm_return_val_if_fail(msginfo_list != NULL, NULL);
1899
1900         if (g_slist_length(msginfo_list) > 1)
1901                 single_mail = FALSE;
1902
1903         for (msginfo = msginfo_list; msginfo != NULL; msginfo = msginfo->next)
1904                 if (((MsgInfo *)msginfo->data)->folder == NULL)
1905                         return NULL;
1906
1907         /* guess account from first selected message */
1908         if (!account &&
1909             !(account = compose_guess_forward_account_from_msginfo
1910                                 (msginfo_list->data)))
1911                 account = cur_account;
1912
1913         cm_return_val_if_fail(account != NULL, NULL);
1914
1915         for (msginfo = msginfo_list; msginfo != NULL; msginfo = msginfo->next) {
1916                 if (msginfo->data) {
1917                         MSG_UNSET_PERM_FLAGS(((MsgInfo *)msginfo->data)->flags, MSG_REPLIED);
1918                         MSG_SET_PERM_FLAGS(((MsgInfo *)msginfo->data)->flags, MSG_FORWARDED);
1919                 }
1920         }
1921
1922         if (msginfo_list == NULL || msginfo_list->data == NULL) {
1923                 g_warning("no msginfo_list");
1924                 return NULL;
1925         }
1926
1927         compose = compose_create(account, ((MsgInfo *)msginfo_list->data)->folder, COMPOSE_FORWARD, FALSE);
1928
1929         compose->updating = TRUE;
1930
1931         /* override from name according to folder properties */
1932         if (msginfo_list->data) {
1933                 MsgInfo *msginfo = msginfo_list->data;
1934
1935                 if (msginfo->folder && msginfo->folder->prefs &&
1936                         msginfo->folder->prefs->forward_with_format &&
1937                         msginfo->folder->prefs->forward_override_from_format &&
1938                         *msginfo->folder->prefs->forward_override_from_format != '\0') {
1939
1940                         gchar *tmp = NULL;
1941                         gchar *buf = NULL;
1942
1943                         /* decode \-escape sequences in the internal representation of the quote format */
1944                         tmp = g_malloc(strlen(msginfo->folder->prefs->forward_override_from_format)+1);
1945                         pref_get_unescaped_pref(tmp, msginfo->folder->prefs->forward_override_from_format);
1946
1947 #ifdef USE_ENCHANT
1948                         quote_fmt_init(msginfo, NULL, NULL, FALSE, compose->account, FALSE,
1949                                         compose->gtkaspell);
1950 #else
1951                         quote_fmt_init(msginfo, NULL, NULL, FALSE, compose->account, FALSE);
1952 #endif
1953                         quote_fmt_scan_string(tmp);
1954                         quote_fmt_parse();
1955
1956                         buf = quote_fmt_get_buffer();
1957                         if (buf == NULL)
1958                                 alertpanel_error(_("The \"From\" field of the \"Forward\" template contains an invalid email address."));
1959                         else
1960                                 gtk_entry_set_text(GTK_ENTRY(compose->from_name), buf);
1961                         quote_fmt_reset_vartable();
1962
1963                         g_free(tmp);
1964                 }
1965         }
1966
1967         textview = GTK_TEXT_VIEW(compose->text);
1968         textbuf = gtk_text_view_get_buffer(textview);
1969         compose_create_tags(textview, compose);
1970
1971         undo_block(compose->undostruct);
1972         for (msginfo = msginfo_list; msginfo != NULL; msginfo = msginfo->next) {
1973                 msgfile = procmsg_get_message_file((MsgInfo *)msginfo->data);
1974
1975                 if (!is_file_exist(msgfile))
1976                         g_warning("%s: file not exist\n", msgfile);
1977                 else
1978                         compose_attach_append(compose, msgfile, msgfile,
1979                                 "message/rfc822", NULL);
1980                 g_free(msgfile);
1981         }
1982
1983         if (single_mail) {
1984                 MsgInfo *info = (MsgInfo *)msginfo_list->data;
1985                 if (info->subject && *info->subject) {
1986                         gchar *buf, *buf2, *p;
1987
1988                         buf = p = g_strdup(info->subject);
1989                         p += subject_get_prefix_length(p);
1990                         memmove(buf, p, strlen(p) + 1);
1991
1992                         buf2 = g_strdup_printf("Fw: %s", buf);
1993                         gtk_entry_set_text(GTK_ENTRY(compose->subject_entry), buf2);
1994
1995                         g_free(buf);
1996                         g_free(buf2);
1997                 }
1998         } else {
1999                 gtk_entry_set_text(GTK_ENTRY(compose->subject_entry),
2000                         _("Fw: multiple emails"));
2001         }
2002
2003         SIGNAL_BLOCK(textbuf);
2004
2005         if (account->auto_sig)
2006                 compose_insert_sig(compose, FALSE);
2007
2008         compose_wrap_all(compose);
2009
2010         SIGNAL_UNBLOCK(textbuf);
2011
2012         gtk_text_buffer_get_start_iter(textbuf, &iter);
2013         gtk_text_buffer_place_cursor(textbuf, &iter);
2014
2015         gtk_widget_grab_focus(compose->header_last->entry);
2016         undo_unblock(compose->undostruct);
2017         compose->modified = FALSE;
2018         compose_set_title(compose);
2019
2020         compose->updating = FALSE;
2021         compose->draft_timeout_tag = -1; /* desinhibit auto-drafting after loading */
2022         SCROLL_TO_CURSOR(compose);
2023
2024         if (compose->deferred_destroy) {
2025                 compose_destroy(compose);
2026                 return NULL;
2027         }
2028
2029         hooks_invoke(COMPOSE_CREATED_HOOKLIST, compose);
2030
2031         return compose;
2032 }
2033
2034 static gboolean compose_is_sig_separator(Compose *compose, GtkTextBuffer *textbuf, GtkTextIter *iter)
2035 {
2036         GtkTextIter start = *iter;
2037         GtkTextIter end_iter;
2038         int start_pos = gtk_text_iter_get_offset(&start);
2039         gchar *str = NULL;
2040         if (!compose->account->sig_sep)
2041                 return FALSE;
2042
2043         gtk_text_buffer_get_iter_at_offset(textbuf, &end_iter,
2044                 start_pos+strlen(compose->account->sig_sep));
2045
2046         /* check sig separator */
2047         str = gtk_text_iter_get_text(&start, &end_iter);
2048         if (!strcmp(str, compose->account->sig_sep)) {
2049                 gchar *tmp = NULL;
2050                 /* check end of line (\n) */
2051                 gtk_text_buffer_get_iter_at_offset(textbuf, &start,
2052                         start_pos+strlen(compose->account->sig_sep));
2053                 gtk_text_buffer_get_iter_at_offset(textbuf, &end_iter,
2054                         start_pos+strlen(compose->account->sig_sep)+1);
2055                 tmp = gtk_text_iter_get_text(&start, &end_iter);
2056                 if (!strcmp(tmp,"\n")) {
2057                         g_free(str);
2058                         g_free(tmp);
2059                         return TRUE;
2060                 }
2061                 g_free(tmp);
2062         }
2063         g_free(str);
2064
2065         return FALSE;
2066 }
2067
2068 static void compose_colorize_signature(Compose *compose)
2069 {
2070         GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(compose->text));
2071         GtkTextIter iter;
2072         GtkTextIter end_iter;
2073         gtk_text_buffer_get_start_iter(buffer, &iter);
2074         while (gtk_text_iter_forward_line(&iter))
2075                 if (compose_is_sig_separator(compose, buffer, &iter)) {
2076                         gtk_text_buffer_get_end_iter(buffer, &end_iter);
2077                         gtk_text_buffer_apply_tag_by_name(buffer,"signature",&iter, &end_iter);
2078                 }
2079 }
2080
2081 #define BLOCK_WRAP() {                                                  \
2082         prev_autowrap = compose->autowrap;                              \
2083         buffer = gtk_text_view_get_buffer(                              \
2084                                         GTK_TEXT_VIEW(compose->text));  \
2085         compose->autowrap = FALSE;                                      \
2086                                                                         \
2087         g_signal_handlers_block_by_func(G_OBJECT(buffer),               \
2088                                 G_CALLBACK(compose_changed_cb),         \
2089                                 compose);                               \
2090         g_signal_handlers_block_by_func(G_OBJECT(buffer),               \
2091                                 G_CALLBACK(text_inserted),              \
2092                                 compose);                               \
2093 }
2094 #define UNBLOCK_WRAP() {                                                \
2095         compose->autowrap = prev_autowrap;                              \
2096         if (compose->autowrap) {                                        \
2097                 gint old = compose->draft_timeout_tag;                  \
2098                 compose->draft_timeout_tag = -2;                        \
2099                 compose_wrap_all(compose);                              \
2100                 compose->draft_timeout_tag = old;                       \
2101         }                                                               \
2102                                                                         \
2103         g_signal_handlers_unblock_by_func(G_OBJECT(buffer),             \
2104                                 G_CALLBACK(compose_changed_cb),         \
2105                                 compose);                               \
2106         g_signal_handlers_unblock_by_func(G_OBJECT(buffer),             \
2107                                 G_CALLBACK(text_inserted),              \
2108                                 compose);                               \
2109 }
2110
2111 Compose *compose_reedit(MsgInfo *msginfo, gboolean batch)
2112 {
2113         Compose *compose = NULL;
2114         PrefsAccount *account = NULL;
2115         GtkTextView *textview;
2116         GtkTextBuffer *textbuf;
2117         GtkTextMark *mark;
2118         GtkTextIter iter;
2119         FILE *fp;
2120         gchar buf[BUFFSIZE];
2121         gboolean use_signing = FALSE;
2122         gboolean use_encryption = FALSE;
2123         gchar *privacy_system = NULL;
2124         int priority = PRIORITY_NORMAL;
2125         MsgInfo *replyinfo = NULL, *fwdinfo = NULL;
2126         gboolean autowrap = prefs_common.autowrap;
2127         gboolean autoindent = prefs_common.auto_indent;
2128
2129         cm_return_val_if_fail(msginfo != NULL, NULL);
2130         cm_return_val_if_fail(msginfo->folder != NULL, NULL);
2131
2132         if (compose_put_existing_to_front(msginfo)) {
2133                 return NULL;
2134         }
2135
2136         if (folder_has_parent_of_type(msginfo->folder, F_QUEUE) ||
2137             folder_has_parent_of_type(msginfo->folder, F_DRAFT) ||
2138             folder_has_parent_of_type(msginfo->folder, F_OUTBOX)) {
2139                 gchar queueheader_buf[BUFFSIZE];
2140                 gint id, param;
2141
2142                 /* Select Account from queue headers */
2143                 if (!procheader_get_header_from_msginfo(msginfo, queueheader_buf,
2144                                              sizeof(queueheader_buf), "X-Claws-Account-Id:")) {
2145                         id = atoi(&queueheader_buf[strlen("X-Claws-Account-Id:")]);
2146                         account = account_find_from_id(id);
2147                 }
2148                 if (!procheader_get_header_from_msginfo(msginfo, queueheader_buf,
2149                                              sizeof(queueheader_buf), "X-Sylpheed-Account-Id:")) {
2150                         id = atoi(&queueheader_buf[strlen("X-Sylpheed-Account-Id:")]);
2151                         account = account_find_from_id(id);
2152                 }
2153                 if (!account && !procheader_get_header_from_msginfo(msginfo, queueheader_buf,
2154                                              sizeof(queueheader_buf), "NAID:")) {
2155                         id = atoi(&queueheader_buf[strlen("NAID:")]);
2156                         account = account_find_from_id(id);
2157                 }
2158                 if (!account && !procheader_get_header_from_msginfo(msginfo, queueheader_buf,
2159                                                     sizeof(queueheader_buf), "MAID:")) {
2160                         id = atoi(&queueheader_buf[strlen("MAID:")]);
2161                         account = account_find_from_id(id);
2162                 }
2163                 if (!account && !procheader_get_header_from_msginfo(msginfo, queueheader_buf,
2164                                                                 sizeof(queueheader_buf), "S:")) {
2165                         account = account_find_from_address(queueheader_buf, FALSE);
2166                 }
2167                 if (!procheader_get_header_from_msginfo(msginfo, queueheader_buf,
2168                                              sizeof(queueheader_buf), "X-Claws-Sign:")) {
2169                         param = atoi(&queueheader_buf[strlen("X-Claws-Sign:")]);
2170                         use_signing = param;
2171
2172                 }
2173                 if (!procheader_get_header_from_msginfo(msginfo, queueheader_buf,
2174                                              sizeof(queueheader_buf), "X-Sylpheed-Sign:")) {
2175                         param = atoi(&queueheader_buf[strlen("X-Sylpheed-Sign:")]);
2176                         use_signing = param;
2177
2178                 }
2179                 if (!procheader_get_header_from_msginfo(msginfo, queueheader_buf,
2180                                              sizeof(queueheader_buf), "X-Claws-Encrypt:")) {
2181                         param = atoi(&queueheader_buf[strlen("X-Claws-Encrypt:")]);
2182                         use_encryption = param;
2183                 }
2184                 if (!procheader_get_header_from_msginfo(msginfo, queueheader_buf,
2185                                              sizeof(queueheader_buf), "X-Sylpheed-Encrypt:")) {
2186                         param = atoi(&queueheader_buf[strlen("X-Sylpheed-Encrypt:")]);
2187                         use_encryption = param;
2188                 }
2189                 if (!procheader_get_header_from_msginfo(msginfo, queueheader_buf,
2190                                              sizeof(queueheader_buf), "X-Claws-Auto-Wrapping:")) {
2191                         param = atoi(&queueheader_buf[strlen("X-Claws-Auto-Wrapping:")]);
2192                         autowrap = param;
2193                 }
2194                 if (!procheader_get_header_from_msginfo(msginfo, queueheader_buf,
2195                                              sizeof(queueheader_buf), "X-Claws-Auto-Indent:")) {
2196                         param = atoi(&queueheader_buf[strlen("X-Claws-Auto-Indent:")]);
2197                         autoindent = param;
2198                 }
2199                 if (!procheader_get_header_from_msginfo(msginfo, queueheader_buf,
2200                                             sizeof(queueheader_buf), "X-Claws-Privacy-System:")) {
2201                         privacy_system = g_strdup(&queueheader_buf[strlen("X-Claws-Privacy-System:")]);
2202                 }
2203                 if (!procheader_get_header_from_msginfo(msginfo, queueheader_buf,
2204                                             sizeof(queueheader_buf), "X-Sylpheed-Privacy-System:")) {
2205                         privacy_system = g_strdup(&queueheader_buf[strlen("X-Sylpheed-Privacy-System:")]);
2206                 }
2207                 if (!procheader_get_header_from_msginfo(msginfo, queueheader_buf,
2208                                              sizeof(queueheader_buf), "X-Priority: ")) {
2209                         param = atoi(&queueheader_buf[strlen("X-Priority: ")]); /* mind the space */
2210                         priority = param;
2211                 }
2212                 if (!procheader_get_header_from_msginfo(msginfo, queueheader_buf,
2213                                              sizeof(queueheader_buf), "RMID:")) {
2214                         gchar **tokens = g_strsplit(&queueheader_buf[strlen("RMID:")], "\t", 0);
2215                         if (tokens[0] && tokens[1] && tokens[2]) {
2216                                 FolderItem *orig_item = folder_find_item_from_identifier(tokens[0]);
2217                                 if (orig_item != NULL) {
2218                                         replyinfo = folder_item_get_msginfo_by_msgid(orig_item, tokens[2]);
2219                                 }
2220                         }
2221                         g_strfreev(tokens);
2222                 }
2223                 if (!procheader_get_header_from_msginfo(msginfo, queueheader_buf,
2224                                              sizeof(queueheader_buf), "FMID:")) {
2225                         gchar **tokens = g_strsplit(&queueheader_buf[strlen("FMID:")], "\t", 0);
2226                         if (tokens[0] && tokens[1] && tokens[2]) {
2227                                 FolderItem *orig_item = folder_find_item_from_identifier(tokens[0]);
2228                                 if (orig_item != NULL) {
2229                                         fwdinfo = folder_item_get_msginfo_by_msgid(orig_item, tokens[2]);
2230                                 }
2231                         }
2232                         g_strfreev(tokens);
2233                 }
2234         } else {
2235                 account = msginfo->folder->folder->account;
2236         }
2237
2238         if (!account && prefs_common.reedit_account_autosel) {
2239                 gchar from[BUFFSIZE];
2240                 if (!procheader_get_header_from_msginfo(msginfo, from, sizeof(from), "FROM:")) {
2241                         extract_address(from);
2242                         account = account_find_from_address(from, FALSE);
2243                 }
2244         }
2245         if (!account) {
2246                 account = cur_account;
2247         }
2248         cm_return_val_if_fail(account != NULL, NULL);
2249
2250         compose = compose_create(account, msginfo->folder, COMPOSE_REEDIT, batch);
2251
2252         cm_toggle_menu_set_active_full(compose->ui_manager, "Menu/Edit/AutoWrap", autowrap);
2253         cm_toggle_menu_set_active_full(compose->ui_manager, "Menu/Edit/AutoIndent", autoindent);
2254         compose->autowrap = autowrap;
2255         compose->replyinfo = replyinfo;
2256         compose->fwdinfo = fwdinfo;
2257
2258         compose->updating = TRUE;
2259         compose->priority = priority;
2260
2261         if (privacy_system != NULL) {
2262                 compose->privacy_system = privacy_system;
2263                 compose_use_signing(compose, use_signing);
2264                 compose_use_encryption(compose, use_encryption);
2265                 compose_update_privacy_system_menu_item(compose, FALSE);
2266         } else {
2267                 activate_privacy_system(compose, account, FALSE);
2268         }
2269
2270         compose->targetinfo = procmsg_msginfo_copy(msginfo);
2271
2272         compose_extract_original_charset(compose);
2273
2274         if (folder_has_parent_of_type(msginfo->folder, F_QUEUE) ||
2275             folder_has_parent_of_type(msginfo->folder, F_DRAFT) ||
2276             folder_has_parent_of_type(msginfo->folder, F_OUTBOX)) {
2277                 gchar queueheader_buf[BUFFSIZE];
2278
2279                 /* Set message save folder */
2280                 if (!procheader_get_header_from_msginfo(msginfo, queueheader_buf, sizeof(queueheader_buf), "SCF:")) {
2281                         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(compose->savemsg_checkbtn), TRUE);
2282                         compose_set_save_to(compose, &queueheader_buf[4]);
2283                 }
2284                 if (!procheader_get_header_from_msginfo(msginfo, queueheader_buf, sizeof(queueheader_buf), "RRCPT:")) {
2285                         gint active = atoi(&queueheader_buf[strlen("RRCPT:")]);
2286                         if (active) {
2287                                 cm_toggle_menu_set_active_full(compose->ui_manager, "Menu/Options/RequestRetRcpt", TRUE);
2288                         }
2289                 }
2290         }
2291
2292         if (compose_parse_header(compose, msginfo) < 0) {
2293                 compose->updating = FALSE;
2294                 compose_destroy(compose);
2295                 return NULL;
2296         }
2297         compose_reedit_set_entry(compose, msginfo);
2298
2299         textview = GTK_TEXT_VIEW(compose->text);
2300         textbuf = gtk_text_view_get_buffer(textview);
2301         compose_create_tags(textview, compose);
2302
2303         mark = gtk_text_buffer_get_insert(textbuf);
2304         gtk_text_buffer_get_iter_at_mark(textbuf, &iter, mark);
2305
2306         g_signal_handlers_block_by_func(G_OBJECT(textbuf),
2307                                         G_CALLBACK(compose_changed_cb),
2308                                         compose);
2309
2310         if (MSG_IS_ENCRYPTED(msginfo->flags)) {
2311                 fp = procmime_get_first_encrypted_text_content(msginfo);
2312                 if (fp) {
2313                         compose_force_encryption(compose, account, TRUE, NULL);
2314                 }
2315         } else {
2316                 fp = procmime_get_first_text_content(msginfo);
2317         }
2318         if (fp == NULL) {
2319                 g_warning("Can't get text part\n");
2320         }
2321
2322         if (fp != NULL) {
2323                 gboolean prev_autowrap = compose->autowrap;
2324                 GtkTextBuffer *buffer = textbuf;
2325                 BLOCK_WRAP();
2326                 while (fgets(buf, sizeof(buf), fp) != NULL) {
2327                         strcrchomp(buf);
2328                         gtk_text_buffer_insert(textbuf, &iter, buf, -1);
2329                 }
2330                 UNBLOCK_WRAP();
2331                 fclose(fp);
2332         }
2333
2334         compose_attach_parts(compose, msginfo);
2335
2336         compose_colorize_signature(compose);
2337
2338         g_signal_handlers_unblock_by_func(G_OBJECT(textbuf),
2339                                         G_CALLBACK(compose_changed_cb),
2340                                         compose);
2341
2342         gtk_widget_grab_focus(compose->text);
2343
2344         if (prefs_common.auto_exteditor) {
2345                 compose_exec_ext_editor(compose);
2346         }
2347         compose->modified = FALSE;
2348         compose_set_title(compose);
2349
2350         compose->updating = FALSE;
2351         compose->draft_timeout_tag = -1; /* desinhibit auto-drafting after loading */
2352         SCROLL_TO_CURSOR(compose);
2353
2354         if (compose->deferred_destroy) {
2355                 compose_destroy(compose);
2356                 return NULL;
2357         }
2358
2359         compose->sig_str = account_get_signature_str(compose->account);
2360
2361         hooks_invoke(COMPOSE_CREATED_HOOKLIST, compose);
2362
2363         return compose;
2364 }
2365
2366 Compose *compose_redirect(PrefsAccount *account, MsgInfo *msginfo,
2367                                                  gboolean batch)
2368 {
2369         Compose *compose;
2370         gchar *filename;
2371         FolderItem *item;
2372
2373         cm_return_val_if_fail(msginfo != NULL, NULL);
2374
2375         if (!account)
2376                 account = account_get_reply_account(msginfo,
2377                                         prefs_common.reply_account_autosel);
2378         cm_return_val_if_fail(account != NULL, NULL);
2379
2380         compose = compose_create(account, msginfo->folder, COMPOSE_REDIRECT, batch);
2381
2382         compose->updating = TRUE;
2383
2384         compose_create_tags(GTK_TEXT_VIEW(compose->text), compose);
2385         compose->replyinfo = NULL;
2386         compose->fwdinfo = NULL;
2387
2388         compose_show_first_last_header(compose, TRUE);
2389
2390         gtk_widget_grab_focus(compose->header_last->entry);
2391
2392         filename = procmsg_get_message_file(msginfo);
2393
2394         if (filename == NULL) {
2395                 compose->updating = FALSE;
2396                 compose_destroy(compose);
2397
2398                 return NULL;
2399         }
2400
2401         compose->redirect_filename = filename;
2402
2403         /* Set save folder */
2404         item = msginfo->folder;
2405         if (item && item->prefs && item->prefs->save_copy_to_folder) {
2406                 gchar *folderidentifier;
2407
2408                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(compose->savemsg_checkbtn), prefs_common.savemsg);
2409                 folderidentifier = folder_item_get_identifier(item);
2410                 compose_set_save_to(compose, folderidentifier);
2411                 g_free(folderidentifier);
2412         }
2413
2414         compose_attach_parts(compose, msginfo);
2415
2416         if (msginfo->subject)
2417                 gtk_entry_set_text(GTK_ENTRY(compose->subject_entry),
2418                                    msginfo->subject);
2419         gtk_editable_set_editable(GTK_EDITABLE(compose->subject_entry), FALSE);
2420
2421         compose_quote_fmt(compose, msginfo, "%M", NULL, NULL, FALSE, FALSE,
2422                                           _("The body of the \"Redirect\" template has an error at line %d."));
2423         quote_fmt_reset_vartable();
2424         gtk_text_view_set_editable(GTK_TEXT_VIEW(compose->text), FALSE);
2425
2426         compose_colorize_signature(compose);
2427
2428
2429         cm_menu_set_sensitive_full(compose->ui_manager, "Popup/Compose/Add", FALSE);
2430         cm_menu_set_sensitive_full(compose->ui_manager, "Popup/Compose/Remove", FALSE);
2431         cm_menu_set_sensitive_full(compose->ui_manager, "Popup/Compose/Properties", FALSE);
2432
2433         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Message/Save", FALSE);
2434         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Message/InsertFile", FALSE);
2435         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Message/AttachFile", FALSE);
2436         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Message/InsertSig", FALSE);
2437         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Edit", FALSE);
2438         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Options", FALSE);
2439 #if !GTK_CHECK_VERSION(2, 24, 0)
2440         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Tools/ShowRuler", FALSE);
2441 #endif
2442         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Tools/Actions", FALSE);
2443
2444         if (compose->toolbar->draft_btn)
2445                 gtk_widget_set_sensitive(compose->toolbar->draft_btn, FALSE);
2446         if (compose->toolbar->insert_btn)
2447                 gtk_widget_set_sensitive(compose->toolbar->insert_btn, FALSE);
2448         if (compose->toolbar->attach_btn)
2449                 gtk_widget_set_sensitive(compose->toolbar->attach_btn, FALSE);
2450         if (compose->toolbar->sig_btn)
2451                 gtk_widget_set_sensitive(compose->toolbar->sig_btn, FALSE);
2452         if (compose->toolbar->exteditor_btn)
2453                 gtk_widget_set_sensitive(compose->toolbar->exteditor_btn, FALSE);
2454         if (compose->toolbar->linewrap_current_btn)
2455                 gtk_widget_set_sensitive(compose->toolbar->linewrap_current_btn, FALSE);
2456         if (compose->toolbar->linewrap_all_btn)
2457                 gtk_widget_set_sensitive(compose->toolbar->linewrap_all_btn, FALSE);
2458
2459         compose->modified = FALSE;
2460         compose_set_title(compose);
2461         compose->updating = FALSE;
2462         compose->draft_timeout_tag = -1; /* desinhibit auto-drafting after loading */
2463         SCROLL_TO_CURSOR(compose);
2464
2465         if (compose->deferred_destroy) {
2466                 compose_destroy(compose);
2467                 return NULL;
2468         }
2469
2470         hooks_invoke(COMPOSE_CREATED_HOOKLIST, compose);
2471
2472         return compose;
2473 }
2474
2475 GList *compose_get_compose_list(void)
2476 {
2477         return compose_list;
2478 }
2479
2480 void compose_entry_append(Compose *compose, const gchar *address,
2481                           ComposeEntryType type, ComposePrefType pref_type)
2482 {
2483         const gchar *header;
2484         gchar *cur, *begin;
2485         gboolean in_quote = FALSE;
2486         if (!address || *address == '\0') return;
2487
2488         switch (type) {
2489         case COMPOSE_CC:
2490                 header = N_("Cc:");
2491                 break;
2492         case COMPOSE_BCC:
2493                 header = N_("Bcc:");
2494                 break;
2495         case COMPOSE_REPLYTO:
2496                 header = N_("Reply-To:");
2497                 break;
2498         case COMPOSE_NEWSGROUPS:
2499                 header = N_("Newsgroups:");
2500                 break;
2501         case COMPOSE_FOLLOWUPTO:
2502                 header = N_( "Followup-To:");
2503                 break;
2504         case COMPOSE_INREPLYTO:
2505                 header = N_( "In-Reply-To:");
2506                 break;
2507         case COMPOSE_TO:
2508         default:
2509                 header = N_("To:");
2510                 break;
2511         }
2512         header = prefs_common_translated_header_name(header);
2513
2514         cur = begin = (gchar *)address;
2515
2516         /* we separate the line by commas, but not if we're inside a quoted
2517          * string */
2518         while (*cur != '\0') {
2519                 if (*cur == '"')
2520                         in_quote = !in_quote;
2521                 if (*cur == ',' && !in_quote) {
2522                         gchar *tmp = g_strdup(begin);
2523                         gchar *o_tmp = tmp;
2524                         tmp[cur-begin]='\0';
2525                         cur++;
2526                         begin = cur;
2527                         while (*tmp == ' ' || *tmp == '\t')
2528                                 tmp++;
2529                         compose_add_header_entry(compose, header, tmp, pref_type);
2530                         g_free(o_tmp);
2531                         continue;
2532                 }
2533                 cur++;
2534         }
2535         if (begin < cur) {
2536                 gchar *tmp = g_strdup(begin);
2537                 gchar *o_tmp = tmp;
2538                 tmp[cur-begin]='\0';
2539                 cur++;
2540                 begin = cur;
2541                 while (*tmp == ' ' || *tmp == '\t')
2542                         tmp++;
2543                 compose_add_header_entry(compose, header, tmp, pref_type);
2544                 g_free(o_tmp);
2545         }
2546 }
2547
2548 static void compose_entry_mark_default_to(Compose *compose, const gchar *mailto)
2549 {
2550 #if !GTK_CHECK_VERSION(2, 24, 0)
2551         static GdkColor yellow;
2552         static GdkColor black;
2553         static gboolean yellow_initialised = FALSE;
2554 #else
2555         static GdkColor yellow = { (guint32)0, (guint16)0xf5, (guint16)0xf6, (guint16)0xbe };
2556         static GdkColor black = { (guint32)0, (guint16)0x0, (guint16)0x0, (guint16)0x0 };
2557 #endif
2558         GSList *h_list;
2559         GtkEntry *entry;
2560
2561 #if !GTK_CHECK_VERSION(2, 24, 0)
2562         if (!yellow_initialised) {
2563                 gdk_color_parse("#f5f6be", &yellow);
2564                 gdk_color_parse("#000000", &black);
2565                 yellow_initialised = gdk_colormap_alloc_color(
2566                         gdk_colormap_get_system(), &yellow, FALSE, TRUE);
2567                 yellow_initialised &= gdk_colormap_alloc_color(
2568                         gdk_colormap_get_system(), &black, FALSE, TRUE);
2569         }
2570 #endif
2571
2572         for (h_list = compose->header_list; h_list != NULL; h_list = h_list->next) {
2573                 entry = GTK_ENTRY(((ComposeHeaderEntry *)h_list->data)->entry);
2574                 if (gtk_entry_get_text(entry) &&
2575                     !g_utf8_collate(gtk_entry_get_text(entry), mailto)) {
2576 #if !GTK_CHECK_VERSION(2, 24, 0)
2577                         if (yellow_initialised) {
2578 #endif
2579                                 gtk_widget_modify_base(
2580                                         GTK_WIDGET(((ComposeHeaderEntry *)h_list->data)->entry),
2581                                         GTK_STATE_NORMAL, &yellow);
2582                                 gtk_widget_modify_text(
2583                                         GTK_WIDGET(((ComposeHeaderEntry *)h_list->data)->entry),
2584                                         GTK_STATE_NORMAL, &black);
2585 #if !GTK_CHECK_VERSION(2, 24, 0)
2586                         }
2587 #endif
2588                 }
2589         }
2590 }
2591
2592 void compose_toolbar_cb(gint action, gpointer data)
2593 {
2594         ToolbarItem *toolbar_item = (ToolbarItem*)data;
2595         Compose *compose = (Compose*)toolbar_item->parent;
2596
2597         cm_return_if_fail(compose != NULL);
2598
2599         switch(action) {
2600         case A_SEND:
2601                 compose_send_cb(NULL, compose);
2602                 break;
2603         case A_SENDL:
2604                 compose_send_later_cb(NULL, compose);
2605                 break;
2606         case A_DRAFT:
2607                 compose_draft(compose, COMPOSE_QUIT_EDITING);
2608                 break;
2609         case A_INSERT:
2610                 compose_insert_file_cb(NULL, compose);
2611                 break;
2612         case A_ATTACH:
2613                 compose_attach_cb(NULL, compose);
2614                 break;
2615         case A_SIG:
2616                 compose_insert_sig(compose, FALSE);
2617                 break;
2618         case A_EXTEDITOR:
2619                 compose_ext_editor_cb(NULL, compose);
2620                 break;
2621         case A_LINEWRAP_CURRENT:
2622                 compose_beautify_paragraph(compose, NULL, TRUE);
2623                 break;
2624         case A_LINEWRAP_ALL:
2625                 compose_wrap_all_full(compose, TRUE);
2626                 break;
2627         case A_ADDRBOOK:
2628                 compose_address_cb(NULL, compose);
2629                 break;
2630 #ifdef USE_ENCHANT
2631         case A_CHECK_SPELLING:
2632                 compose_check_all(NULL, compose);
2633                 break;
2634 #endif
2635         default:
2636                 break;
2637         }
2638 }
2639
2640 static MailField compose_entries_set(Compose *compose, const gchar *mailto, ComposeEntryType to_type)
2641 {
2642         gchar *to = NULL;
2643         gchar *cc = NULL;
2644         gchar *bcc = NULL;
2645         gchar *subject = NULL;
2646         gchar *body = NULL;
2647         gchar *temp = NULL;
2648         gsize  len = 0;
2649         gchar **attach = NULL;
2650         gchar *inreplyto = NULL;
2651         MailField mfield = NO_FIELD_PRESENT;
2652
2653         /* get mailto parts but skip from */
2654         scan_mailto_url(mailto, NULL, &to, &cc, &bcc, &subject, &body, &attach, &inreplyto);
2655
2656         if (to) {
2657                 compose_entry_append(compose, to, to_type, PREF_MAILTO);
2658                 mfield = TO_FIELD_PRESENT;
2659         }
2660         if (cc)
2661                 compose_entry_append(compose, cc, COMPOSE_CC, PREF_MAILTO);
2662         if (bcc)
2663                 compose_entry_append(compose, bcc, COMPOSE_BCC, PREF_MAILTO);
2664         if (subject) {
2665                 if (!g_utf8_validate (subject, -1, NULL)) {
2666                         temp = g_locale_to_utf8 (subject, -1, NULL, &len, NULL);
2667                         gtk_entry_set_text(GTK_ENTRY(compose->subject_entry), temp);
2668                         g_free(temp);
2669                 } else {
2670                         gtk_entry_set_text(GTK_ENTRY(compose->subject_entry), subject);
2671                 }
2672                 mfield = SUBJECT_FIELD_PRESENT;
2673         }
2674         if (body) {
2675                 GtkTextView *text = GTK_TEXT_VIEW(compose->text);
2676                 GtkTextBuffer *buffer = gtk_text_view_get_buffer(text);
2677                 GtkTextMark *mark;
2678                 GtkTextIter iter;
2679                 gboolean prev_autowrap = compose->autowrap;
2680
2681                 compose->autowrap = FALSE;
2682
2683                 mark = gtk_text_buffer_get_insert(buffer);
2684                 gtk_text_buffer_get_iter_at_mark(buffer, &iter, mark);
2685
2686                 if (!g_utf8_validate (body, -1, NULL)) {
2687                         temp = g_locale_to_utf8 (body, -1, NULL, &len, NULL);
2688                         gtk_text_buffer_insert(buffer, &iter, temp, -1);
2689                         g_free(temp);
2690                 } else {
2691                         gtk_text_buffer_insert(buffer, &iter, body, -1);
2692                 }
2693                 gtk_text_buffer_insert(buffer, &iter, "\n", 1);
2694
2695                 compose->autowrap = prev_autowrap;
2696                 if (compose->autowrap)
2697                         compose_wrap_all(compose);
2698                 mfield = BODY_FIELD_PRESENT;
2699         }
2700
2701         if (attach) {
2702                 gint i = 0, att = 0;
2703                 gchar *warn_files = NULL;
2704                 while (attach[i] != NULL) {
2705                         gchar *utf8_filename = conv_filename_to_utf8(attach[i]);
2706                         if (utf8_filename) {
2707                                 if (compose_attach_append(compose, attach[i], utf8_filename, NULL, NULL)) {
2708                                         gchar *tmp = g_strdup_printf("%s%s\n",
2709                                                         warn_files?warn_files:"",
2710                                                         utf8_filename);
2711                                         g_free(warn_files);
2712                                         warn_files = tmp;
2713                                         att++;
2714                                 }
2715                                 g_free(utf8_filename);
2716                         } else {
2717                                 alertpanel_error(_("Couldn't attach a file (charset conversion failed)."));
2718                         }
2719                         i++;
2720                 }
2721                 if (warn_files) {
2722                         alertpanel_notice(ngettext(
2723                         "The following file has been attached: \n%s",
2724                         "The following files have been attached: \n%s", att), warn_files);
2725                         g_free(warn_files);
2726                 }
2727         }
2728         if (inreplyto)
2729                 compose_entry_append(compose, inreplyto, COMPOSE_INREPLYTO, PREF_MAILTO);
2730
2731         g_free(to);
2732         g_free(cc);
2733         g_free(bcc);
2734         g_free(subject);
2735         g_free(body);
2736         g_strfreev(attach);
2737         g_free(inreplyto);
2738
2739         return mfield;
2740 }
2741
2742 static gint compose_parse_header(Compose *compose, MsgInfo *msginfo)
2743 {
2744         static HeaderEntry hentry[] = {{"Reply-To:",    NULL, TRUE},
2745                                        {"Cc:",          NULL, TRUE},
2746                                        {"References:",  NULL, FALSE},
2747                                        {"Bcc:",         NULL, TRUE},
2748                                        {"Newsgroups:",  NULL, TRUE},
2749                                        {"Followup-To:", NULL, TRUE},
2750                                        {"List-Post:",   NULL, FALSE},
2751                                        {"X-Priority:",  NULL, FALSE},
2752                                        {NULL,           NULL, FALSE}};
2753
2754         enum
2755         {
2756                 H_REPLY_TO      = 0,
2757                 H_CC            = 1,
2758                 H_REFERENCES    = 2,
2759                 H_BCC           = 3,
2760                 H_NEWSGROUPS    = 4,
2761                 H_FOLLOWUP_TO   = 5,
2762                 H_LIST_POST     = 6,
2763                 H_X_PRIORITY    = 7
2764         };
2765
2766         FILE *fp;
2767
2768         cm_return_val_if_fail(msginfo != NULL, -1);
2769
2770         if ((fp = procmsg_open_message(msginfo)) == NULL) return -1;
2771         procheader_get_header_fields(fp, hentry);
2772         fclose(fp);
2773
2774         if (hentry[H_REPLY_TO].body != NULL) {
2775                 if (hentry[H_REPLY_TO].body[0] != '\0') {
2776                         compose->replyto =
2777                                 conv_unmime_header(hentry[H_REPLY_TO].body,
2778                                                    NULL, TRUE);
2779                 }
2780                 g_free(hentry[H_REPLY_TO].body);
2781                 hentry[H_REPLY_TO].body = NULL;
2782         }
2783         if (hentry[H_CC].body != NULL) {
2784                 compose->cc = conv_unmime_header(hentry[H_CC].body, NULL, TRUE);
2785                 g_free(hentry[H_CC].body);
2786                 hentry[H_CC].body = NULL;
2787         }
2788         if (hentry[H_REFERENCES].body != NULL) {
2789                 if (compose->mode == COMPOSE_REEDIT)
2790                         compose->references = hentry[H_REFERENCES].body;
2791                 else {
2792                         compose->references = compose_parse_references
2793                                 (hentry[H_REFERENCES].body, msginfo->msgid);
2794                         g_free(hentry[H_REFERENCES].body);
2795                 }
2796                 hentry[H_REFERENCES].body = NULL;
2797         }
2798         if (hentry[H_BCC].body != NULL) {
2799                 if (compose->mode == COMPOSE_REEDIT)
2800                         compose->bcc =
2801                                 conv_unmime_header(hentry[H_BCC].body, NULL, TRUE);
2802                 g_free(hentry[H_BCC].body);
2803                 hentry[H_BCC].body = NULL;
2804         }
2805         if (hentry[H_NEWSGROUPS].body != NULL) {
2806                 compose->newsgroups = hentry[H_NEWSGROUPS].body;
2807                 hentry[H_NEWSGROUPS].body = NULL;
2808         }
2809         if (hentry[H_FOLLOWUP_TO].body != NULL) {
2810                 if (hentry[H_FOLLOWUP_TO].body[0] != '\0') {
2811                         compose->followup_to =
2812                                 conv_unmime_header(hentry[H_FOLLOWUP_TO].body,
2813                                                    NULL, TRUE);
2814                 }
2815                 g_free(hentry[H_FOLLOWUP_TO].body);
2816                 hentry[H_FOLLOWUP_TO].body = NULL;
2817         }
2818         if (hentry[H_LIST_POST].body != NULL) {
2819                 gchar *to = NULL, *start = NULL;
2820
2821                 extract_address(hentry[H_LIST_POST].body);
2822                 if (hentry[H_LIST_POST].body[0] != '\0') {
2823                         start = strstr(hentry[H_LIST_POST].body, "mailto:");
2824
2825                         scan_mailto_url(start ? start : hentry[H_LIST_POST].body,
2826                                         NULL, &to, NULL, NULL, NULL, NULL, NULL, NULL);
2827
2828                         if (to) {
2829                                 g_free(compose->ml_post);
2830                                 compose->ml_post = to;
2831                         }
2832                 }
2833                 g_free(hentry[H_LIST_POST].body);
2834                 hentry[H_LIST_POST].body = NULL;
2835         }
2836
2837         /* CLAWS - X-Priority */
2838         if (compose->mode == COMPOSE_REEDIT)
2839                 if (hentry[H_X_PRIORITY].body != NULL) {
2840                         gint priority;
2841
2842                         priority = atoi(hentry[H_X_PRIORITY].body);
2843                         g_free(hentry[H_X_PRIORITY].body);
2844
2845                         hentry[H_X_PRIORITY].body = NULL;
2846
2847                         if (priority < PRIORITY_HIGHEST ||
2848                             priority > PRIORITY_LOWEST)
2849                                 priority = PRIORITY_NORMAL;
2850
2851                         compose->priority =  priority;
2852                 }
2853
2854         if (compose->mode == COMPOSE_REEDIT) {
2855                 if (msginfo->inreplyto && *msginfo->inreplyto)
2856                         compose->inreplyto = g_strdup(msginfo->inreplyto);
2857                 return 0;
2858         }
2859
2860         if (msginfo->msgid && *msginfo->msgid)
2861                 compose->inreplyto = g_strdup(msginfo->msgid);
2862
2863         if (!compose->references) {
2864                 if (msginfo->msgid && *msginfo->msgid) {
2865                         if (msginfo->inreplyto && *msginfo->inreplyto)
2866                                 compose->references =
2867                                         g_strdup_printf("<%s>\n\t<%s>",
2868                                                         msginfo->inreplyto,
2869                                                         msginfo->msgid);
2870                         else
2871                                 compose->references =
2872                                         g_strconcat("<", msginfo->msgid, ">",
2873                                                     NULL);
2874                 } else if (msginfo->inreplyto && *msginfo->inreplyto) {
2875                         compose->references =
2876                                 g_strconcat("<", msginfo->inreplyto, ">",
2877                                             NULL);
2878                 }
2879         }
2880
2881         return 0;
2882 }
2883
2884 static gchar *compose_parse_references(const gchar *ref, const gchar *msgid)
2885 {
2886         GSList *ref_id_list, *cur;
2887         GString *new_ref;
2888         gchar *new_ref_str;
2889
2890         ref_id_list = references_list_append(NULL, ref);
2891         if (!ref_id_list) return NULL;
2892         if (msgid && *msgid)
2893                 ref_id_list = g_slist_append(ref_id_list, g_strdup(msgid));
2894
2895         for (;;) {
2896                 gint len = 0;
2897
2898                 for (cur = ref_id_list; cur != NULL; cur = cur->next)
2899                         /* "<" + Message-ID + ">" + CR+LF+TAB */
2900                         len += strlen((gchar *)cur->data) + 5;
2901
2902                 if (len > MAX_REFERENCES_LEN) {
2903                         /* remove second message-ID */
2904                         if (ref_id_list && ref_id_list->next &&
2905                             ref_id_list->next->next) {
2906                                 g_free(ref_id_list->next->data);
2907                                 ref_id_list = g_slist_remove
2908                                         (ref_id_list, ref_id_list->next->data);
2909                         } else {
2910                                 slist_free_strings(ref_id_list);
2911                                 g_slist_free(ref_id_list);
2912                                 return NULL;
2913                         }
2914                 } else
2915                         break;
2916         }
2917
2918         new_ref = g_string_new("");
2919         for (cur = ref_id_list; cur != NULL; cur = cur->next) {
2920                 if (new_ref->len > 0)
2921                         g_string_append(new_ref, "\n\t");
2922                 g_string_append_printf(new_ref, "<%s>", (gchar *)cur->data);
2923         }
2924
2925         slist_free_strings(ref_id_list);
2926         g_slist_free(ref_id_list);
2927
2928         new_ref_str = new_ref->str;
2929         g_string_free(new_ref, FALSE);
2930
2931         return new_ref_str;
2932 }
2933
2934 static gchar *compose_quote_fmt(Compose *compose, MsgInfo *msginfo,
2935                                 const gchar *fmt, const gchar *qmark,
2936                                 const gchar *body, gboolean rewrap,
2937                                 gboolean need_unescape,
2938                                 const gchar *err_msg)
2939 {
2940         MsgInfo* dummyinfo = NULL;
2941         gchar *quote_str = NULL;
2942         gchar *buf;
2943         gboolean prev_autowrap;
2944         const gchar *trimmed_body = body;
2945         gint cursor_pos = -1;
2946         GtkTextView *text = GTK_TEXT_VIEW(compose->text);
2947         GtkTextBuffer *buffer = gtk_text_view_get_buffer(text);
2948         GtkTextIter iter;
2949         GtkTextMark *mark;
2950
2951
2952         SIGNAL_BLOCK(buffer);
2953
2954         if (!msginfo) {
2955                 dummyinfo = compose_msginfo_new_from_compose(compose);
2956                 msginfo = dummyinfo;
2957         }
2958
2959         if (qmark != NULL) {
2960 #ifdef USE_ENCHANT
2961                 quote_fmt_init(msginfo, NULL, NULL, FALSE, compose->account, FALSE,
2962                                 compose->gtkaspell);
2963 #else
2964                 quote_fmt_init(msginfo, NULL, NULL, FALSE, compose->account, FALSE);
2965 #endif
2966                 quote_fmt_scan_string(qmark);
2967                 quote_fmt_parse();
2968
2969                 buf = quote_fmt_get_buffer();
2970                 if (buf == NULL)
2971                         alertpanel_error(_("The \"Quotation mark\" of the template is invalid."));
2972                 else
2973                         Xstrdup_a(quote_str, buf, goto error)
2974         }
2975
2976         if (fmt && *fmt != '\0') {
2977
2978                 if (trimmed_body)
2979                         while (*trimmed_body == '\n')
2980                                 trimmed_body++;
2981
2982 #ifdef USE_ENCHANT
2983                 quote_fmt_init(msginfo, quote_str, trimmed_body, FALSE, compose->account, FALSE,
2984                                 compose->gtkaspell);
2985 #else
2986                 quote_fmt_init(msginfo, quote_str, trimmed_body, FALSE, compose->account, FALSE);
2987 #endif
2988                 if (need_unescape) {
2989                         gchar *tmp = NULL;
2990
2991                         /* decode \-escape sequences in the internal representation of the quote format */
2992                         tmp = g_malloc(strlen(fmt)+1);
2993                         pref_get_unescaped_pref(tmp, fmt);
2994                         quote_fmt_scan_string(tmp);
2995                         quote_fmt_parse();
2996                         g_free(tmp);
2997                 } else {
2998                         quote_fmt_scan_string(fmt);
2999                         quote_fmt_parse();
3000                 }
3001
3002                 buf = quote_fmt_get_buffer();
3003                 if (buf == NULL) {
3004                         gint line = quote_fmt_get_line();
3005                         alertpanel_error(err_msg, line);
3006                         goto error;
3007                 }
3008         } else
3009                 buf = "";
3010
3011         prev_autowrap = compose->autowrap;
3012         compose->autowrap = FALSE;
3013
3014         mark = gtk_text_buffer_get_insert(buffer);
3015         gtk_text_buffer_get_iter_at_mark(buffer, &iter, mark);
3016         if (g_utf8_validate(buf, -1, NULL)) {
3017                 gtk_text_buffer_insert(buffer, &iter, buf, -1);
3018         } else {
3019                 gchar *tmpout = NULL;
3020                 tmpout = conv_codeset_strdup
3021                         (buf, conv_get_locale_charset_str_no_utf8(),
3022                          CS_INTERNAL);
3023                 if (!tmpout || !g_utf8_validate(tmpout, -1, NULL)) {
3024                         g_free(tmpout);
3025                         tmpout = g_malloc(strlen(buf)*2+1);
3026                         conv_localetodisp(tmpout, strlen(buf)*2+1, buf);
3027                 }
3028                 gtk_text_buffer_insert(buffer, &iter, tmpout, -1);
3029                 g_free(tmpout);
3030         }
3031
3032         cursor_pos = quote_fmt_get_cursor_pos();
3033         if (cursor_pos == -1)
3034                 cursor_pos = gtk_text_iter_get_offset(&iter);
3035         compose->set_cursor_pos = cursor_pos;
3036
3037         gtk_text_buffer_get_start_iter(buffer, &iter);
3038         gtk_text_buffer_get_iter_at_offset(buffer, &iter, cursor_pos);
3039         gtk_text_buffer_place_cursor(buffer, &iter);
3040
3041         compose->autowrap = prev_autowrap;
3042         if (compose->autowrap && rewrap)
3043                 compose_wrap_all(compose);
3044
3045         goto ok;
3046
3047 error:
3048         buf = NULL;
3049 ok:
3050         SIGNAL_UNBLOCK(buffer);
3051
3052         procmsg_msginfo_free( dummyinfo );
3053
3054         return buf;
3055 }
3056
3057 /* if ml_post is of type addr@host and from is of type
3058  * addr-anything@host, return TRUE
3059  */
3060 static gboolean is_subscription(const gchar *ml_post, const gchar *from)
3061 {
3062         gchar *left_ml = NULL;
3063         gchar *right_ml = NULL;
3064         gchar *left_from = NULL;
3065         gchar *right_from = NULL;
3066         gboolean result = FALSE;
3067
3068         if (!ml_post || !from)
3069                 return FALSE;
3070
3071         left_ml = g_strdup(ml_post);
3072         if (strstr(left_ml, "@")) {
3073                 right_ml = strstr(left_ml, "@")+1;
3074                 *(strstr(left_ml, "@")) = '\0';
3075         }
3076
3077         left_from = g_strdup(from);
3078         if (strstr(left_from, "@")) {
3079                 right_from = strstr(left_from, "@")+1;
3080                 *(strstr(left_from, "@")) = '\0';
3081         }
3082
3083         if (left_ml && left_from && right_ml && right_from
3084         &&  !strncmp(left_from, left_ml, strlen(left_ml))
3085         &&  !strcmp(right_from, right_ml)) {
3086                 result = TRUE;
3087         }
3088         g_free(left_ml);
3089         g_free(left_from);
3090
3091         return result;
3092 }
3093
3094 static void compose_set_folder_prefs(Compose *compose, FolderItem *folder,
3095                                      gboolean respect_default_to)
3096 {
3097         if (!compose)
3098                 return;
3099         if (!folder || !folder->prefs)
3100                 return;
3101
3102         if (respect_default_to && folder->prefs->enable_default_to) {
3103                 compose_entry_append(compose, folder->prefs->default_to,
3104                                         COMPOSE_TO, PREF_FOLDER);
3105                 compose_entry_mark_default_to(compose, folder->prefs->default_to);
3106         }
3107         if (folder->prefs->enable_default_cc)
3108                 compose_entry_append(compose, folder->prefs->default_cc,
3109                                         COMPOSE_CC, PREF_FOLDER);
3110         if (folder->prefs->enable_default_bcc)
3111                 compose_entry_append(compose, folder->prefs->default_bcc,
3112                                         COMPOSE_BCC, PREF_FOLDER);
3113         if (folder->prefs->enable_default_replyto)
3114                 compose_entry_append(compose, folder->prefs->default_replyto,
3115                                         COMPOSE_REPLYTO, PREF_FOLDER);
3116 }
3117
3118 static void compose_reply_set_subject(Compose *compose, MsgInfo *msginfo)
3119 {
3120         gchar *buf, *buf2;
3121         gchar *p;
3122
3123         if (!compose || !msginfo)
3124                 return;
3125
3126         if (msginfo->subject && *msginfo->subject) {
3127                 buf = p = g_strdup(msginfo->subject);
3128                 p += subject_get_prefix_length(p);
3129                 memmove(buf, p, strlen(p) + 1);
3130
3131                 buf2 = g_strdup_printf("Re: %s", buf);
3132                 gtk_entry_set_text(GTK_ENTRY(compose->subject_entry), buf2);
3133
3134                 g_free(buf2);
3135                 g_free(buf);
3136         } else
3137                 gtk_entry_set_text(GTK_ENTRY(compose->subject_entry), "Re: ");
3138 }
3139
3140 static void compose_reply_set_entry(Compose *compose, MsgInfo *msginfo,
3141                                     gboolean to_all, gboolean to_ml,
3142                                     gboolean to_sender,
3143                                     gboolean followup_and_reply_to)
3144 {
3145         GSList *cc_list = NULL;
3146         GSList *cur;
3147         gchar *from = NULL;
3148         gchar *replyto = NULL;
3149         gchar *ac_email = NULL;
3150
3151         gboolean reply_to_ml = FALSE;
3152         gboolean default_reply_to = FALSE;
3153
3154         cm_return_if_fail(compose->account != NULL);
3155         cm_return_if_fail(msginfo != NULL);
3156
3157         reply_to_ml = to_ml && compose->ml_post;
3158
3159         default_reply_to = msginfo->folder &&
3160                 msginfo->folder->prefs->enable_default_reply_to;
3161
3162         if (compose->account->protocol != A_NNTP) {
3163                 compose_set_folder_prefs(compose, msginfo->folder, FALSE);
3164
3165                 if (reply_to_ml && !default_reply_to) {
3166
3167                         gboolean is_subscr = is_subscription(compose->ml_post,
3168                                                              msginfo->from);
3169                         if (!is_subscr) {
3170                                 /* normal answer to ml post with a reply-to */
3171                                 compose_entry_append(compose,
3172                                            compose->ml_post,
3173                                            COMPOSE_TO, PREF_ML);
3174                                 if (compose->replyto)
3175                                         compose_entry_append(compose,
3176                                                 compose->replyto,
3177                                                 COMPOSE_CC, PREF_ML);
3178                         } else {
3179                                 /* answer to subscription confirmation */
3180                                 if (compose->replyto)
3181                                         compose_entry_append(compose,
3182                                                 compose->replyto,
3183                                                 COMPOSE_TO, PREF_ML);
3184                                 else if (msginfo->from)
3185                                         compose_entry_append(compose,
3186                                                 msginfo->from,
3187                                                 COMPOSE_TO, PREF_ML);
3188                         }
3189                 }
3190                 else if (!(to_all || to_sender) && default_reply_to) {
3191                         compose_entry_append(compose,
3192                             msginfo->folder->prefs->default_reply_to,
3193                             COMPOSE_TO, PREF_FOLDER);
3194                         compose_entry_mark_default_to(compose,
3195                                 msginfo->folder->prefs->default_reply_to);
3196                 } else {
3197                         gchar *tmp1 = NULL;
3198                         if (!msginfo->from)
3199                                 return;
3200                         Xstrdup_a(tmp1, msginfo->from, return);
3201                         extract_address(tmp1);
3202                         if (to_all || to_sender ||
3203                             !account_find_from_address(tmp1, FALSE))
3204                                 compose_entry_append(compose,
3205                                  (compose->replyto && !to_sender)
3206                                           ? compose->replyto :
3207                                           msginfo->from ? msginfo->from : "",
3208                                           COMPOSE_TO, PREF_NONE);
3209                         else if (!to_all && !to_sender) {
3210                                 if (!folder_has_parent_of_type(msginfo->folder, F_QUEUE) &&
3211                                     !folder_has_parent_of_type(msginfo->folder, F_OUTBOX) &&
3212                                     !folder_has_parent_of_type(msginfo->folder, F_DRAFT)) {
3213                                         if (compose->replyto) {
3214                                                 compose_entry_append(compose,
3215                                                         compose->replyto,
3216                                                         COMPOSE_TO, PREF_NONE);
3217                                         } else {
3218                                                 compose_entry_append(compose,
3219                                                           msginfo->from ? msginfo->from : "",
3220                                                           COMPOSE_TO, PREF_NONE);
3221                                         }
3222                                 } else {
3223                                         /* replying to own mail, use original recp */
3224                                         compose_entry_append(compose,
3225                                                   msginfo->to ? msginfo->to : "",
3226                                                   COMPOSE_TO, PREF_NONE);
3227                                         compose_entry_append(compose,
3228                                                   msginfo->cc ? msginfo->cc : "",
3229                                                   COMPOSE_CC, PREF_NONE);
3230                                 }
3231                         }
3232                 }
3233         } else {
3234                 if (to_sender || (compose->followup_to &&
3235                         !strncmp(compose->followup_to, "poster", 6)))
3236                         compose_entry_append
3237                                 (compose,
3238                                  (compose->replyto ? compose->replyto :
3239                                         msginfo->from ? msginfo->from : ""),
3240                                  COMPOSE_TO, PREF_NONE);
3241
3242                 else if (followup_and_reply_to || to_all) {
3243                         compose_entry_append
3244                                 (compose,
3245                                  (compose->replyto ? compose->replyto :
3246                                  msginfo->from ? msginfo->from : ""),
3247                                  COMPOSE_TO, PREF_NONE);
3248
3249                         compose_entry_append
3250                                 (compose,
3251                                  compose->followup_to ? compose->followup_to :
3252                                  compose->newsgroups ? compose->newsgroups : "",
3253                                  COMPOSE_NEWSGROUPS, PREF_NONE);
3254                 }
3255                 else
3256                         compose_entry_append
3257                                 (compose,
3258                                  compose->followup_to ? compose->followup_to :
3259                                  compose->newsgroups ? compose->newsgroups : "",
3260                                  COMPOSE_NEWSGROUPS, PREF_NONE);
3261         }
3262         compose_reply_set_subject(compose, msginfo);
3263
3264         if (to_ml && compose->ml_post) return;
3265         if (!to_all || compose->account->protocol == A_NNTP) return;
3266
3267         if (compose->replyto) {
3268                 Xstrdup_a(replyto, compose->replyto, return);
3269                 extract_address(replyto);
3270         }
3271         if (msginfo->from) {
3272                 Xstrdup_a(from, msginfo->from, return);
3273                 extract_address(from);
3274         }
3275
3276         if (replyto && from)
3277                 cc_list = address_list_append_with_comments(cc_list, from);
3278         if (to_all && msginfo->folder &&
3279             msginfo->folder->prefs->enable_default_reply_to)
3280                 cc_list = address_list_append_with_comments(cc_list,
3281                                 msginfo->folder->prefs->default_reply_to);
3282         cc_list = address_list_append_with_comments(cc_list, msginfo->to);
3283         cc_list = address_list_append_with_comments(cc_list, compose->cc);
3284
3285         ac_email = g_utf8_strdown(compose->account->address, -1);
3286
3287         if (cc_list) {
3288                 for (cur = cc_list; cur != NULL; cur = cur->next) {
3289                         gchar *addr = g_utf8_strdown(cur->data, -1);
3290                         extract_address(addr);
3291
3292                         if (strcmp(ac_email, addr))
3293                                 compose_entry_append(compose, (gchar *)cur->data,
3294                                                      COMPOSE_CC, PREF_NONE);
3295                         else
3296                                 debug_print("Cc address same as compose account's, ignoring\n");
3297
3298                         g_free(addr);
3299                 }
3300
3301                 slist_free_strings(cc_list);
3302                 g_slist_free(cc_list);
3303         }
3304
3305         g_free(ac_email);
3306 }
3307
3308 #define SET_ENTRY(entry, str) \
3309 { \
3310         if (str && *str) \
3311                 gtk_entry_set_text(GTK_ENTRY(compose->entry), str); \
3312 }
3313
3314 #define SET_ADDRESS(type, str) \
3315 { \
3316         if (str && *str) \
3317                 compose_entry_append(compose, str, type, PREF_NONE); \
3318 }
3319
3320 static void compose_reedit_set_entry(Compose *compose, MsgInfo *msginfo)
3321 {
3322         cm_return_if_fail(msginfo != NULL);
3323
3324         SET_ENTRY(subject_entry, msginfo->subject);
3325         SET_ENTRY(from_name, msginfo->from);
3326         SET_ADDRESS(COMPOSE_TO, msginfo->to);
3327         SET_ADDRESS(COMPOSE_CC, compose->cc);
3328         SET_ADDRESS(COMPOSE_BCC, compose->bcc);
3329         SET_ADDRESS(COMPOSE_REPLYTO, compose->replyto);
3330         SET_ADDRESS(COMPOSE_NEWSGROUPS, compose->newsgroups);
3331         SET_ADDRESS(COMPOSE_FOLLOWUPTO, compose->followup_to);
3332
3333         compose_update_priority_menu_item(compose);
3334         compose_update_privacy_system_menu_item(compose, FALSE);
3335         compose_show_first_last_header(compose, TRUE);
3336 }
3337
3338 #undef SET_ENTRY
3339 #undef SET_ADDRESS
3340
3341 static void compose_insert_sig(Compose *compose, gboolean replace)
3342 {
3343         GtkTextView *text = GTK_TEXT_VIEW(compose->text);
3344         GtkTextBuffer *buffer = gtk_text_view_get_buffer(text);
3345         GtkTextMark *mark;
3346         GtkTextIter iter, iter_end;
3347         gint cur_pos, ins_pos;
3348         gboolean prev_autowrap;
3349         gboolean found = FALSE;
3350         gboolean exists = FALSE;
3351
3352         cm_return_if_fail(compose->account != NULL);
3353
3354         BLOCK_WRAP();
3355
3356         g_signal_handlers_block_by_func(G_OBJECT(buffer),
3357                                         G_CALLBACK(compose_changed_cb),
3358                                         compose);
3359
3360         mark = gtk_text_buffer_get_insert(buffer);
3361         gtk_text_buffer_get_iter_at_mark(buffer, &iter, mark);
3362         cur_pos = gtk_text_iter_get_offset (&iter);
3363         ins_pos = cur_pos;
3364
3365         gtk_text_buffer_get_end_iter(buffer, &iter);
3366
3367         exists = (compose->sig_str != NULL);
3368
3369         if (replace) {
3370                 GtkTextIter first_iter, start_iter, end_iter;
3371
3372                 gtk_text_buffer_get_start_iter(buffer, &first_iter);
3373
3374                 if (!exists || compose->sig_str[0] == '\0')
3375                         found = FALSE;
3376                 else
3377                         found = gtk_text_iter_forward_to_tag_toggle(&first_iter,
3378                                         compose->signature_tag);
3379
3380                 if (found) {
3381                         /* include previous \n\n */
3382                         gtk_text_iter_backward_chars(&first_iter, 1);
3383                         start_iter = first_iter;
3384                         end_iter = first_iter;
3385                         /* skip re-start */
3386                         found = gtk_text_iter_forward_to_tag_toggle(&end_iter,
3387                                         compose->signature_tag);
3388                         found &= gtk_text_iter_forward_to_tag_toggle(&end_iter,
3389                                         compose->signature_tag);
3390                         if (found) {
3391                                 gtk_text_buffer_delete(buffer, &start_iter, &end_iter);
3392                                 iter = start_iter;
3393                         }
3394                 }
3395         }
3396
3397         g_free(compose->sig_str);
3398         compose->sig_str = account_get_signature_str(compose->account);
3399
3400         cur_pos = gtk_text_iter_get_offset(&iter);
3401
3402         if (!compose->sig_str || (replace && !compose->account->auto_sig)) {
3403                 g_free(compose->sig_str);
3404                 compose->sig_str = NULL;
3405         } else {
3406                 if (compose->sig_inserted == FALSE)
3407                         gtk_text_buffer_insert(buffer, &iter, "\n", -1);
3408                 compose->sig_inserted = TRUE;
3409
3410                 cur_pos = gtk_text_iter_get_offset(&iter);
3411                 gtk_text_buffer_insert(buffer, &iter, compose->sig_str, -1);
3412                 /* remove \n\n */
3413                 gtk_text_buffer_get_iter_at_offset(buffer, &iter, cur_pos);
3414                 gtk_text_iter_forward_chars(&iter, 1);
3415                 gtk_text_buffer_get_end_iter(buffer, &iter_end);
3416                 gtk_text_buffer_apply_tag_by_name(buffer,"signature",&iter, &iter_end);
3417
3418                 if (cur_pos > gtk_text_buffer_get_char_count (buffer))
3419                         cur_pos = gtk_text_buffer_get_char_count (buffer);
3420         }
3421
3422         /* put the cursor where it should be
3423          * either where the quote_fmt says, either where it was */
3424         if (compose->set_cursor_pos < 0)
3425                 gtk_text_buffer_get_iter_at_offset(buffer, &iter, ins_pos);
3426         else
3427                 gtk_text_buffer_get_iter_at_offset(buffer, &iter,
3428                         compose->set_cursor_pos);
3429
3430         compose->set_cursor_pos = -1;
3431         gtk_text_buffer_place_cursor(buffer, &iter);
3432         g_signal_handlers_unblock_by_func(G_OBJECT(buffer),
3433                                         G_CALLBACK(compose_changed_cb),
3434                                         compose);
3435
3436         UNBLOCK_WRAP();
3437 }
3438
3439 static ComposeInsertResult compose_insert_file(Compose *compose, const gchar *file)
3440 {
3441         GtkTextView *text;
3442         GtkTextBuffer *buffer;
3443         GtkTextMark *mark;
3444         GtkTextIter iter;
3445         const gchar *cur_encoding;
3446         gchar buf[BUFFSIZE];
3447         gint len;
3448         FILE *fp;
3449         gboolean prev_autowrap;
3450         gboolean badtxt = FALSE;
3451         struct stat file_stat;
3452         int ret;
3453
3454         cm_return_val_if_fail(file != NULL, COMPOSE_INSERT_NO_FILE);
3455
3456         /* get the size of the file we are about to insert */
3457         ret = g_stat(file, &file_stat);
3458         if (ret != 0) {
3459                 gchar *shortfile = g_path_get_basename(file);
3460                 alertpanel_error(_("Could not get size of file '%s'."), shortfile);
3461                 g_free(shortfile);
3462                 return COMPOSE_INSERT_NO_FILE;
3463         } else if (prefs_common.warn_large_insert == TRUE) {
3464
3465                 /* ask user for confirmation if the file is large */
3466                 if (prefs_common.warn_large_insert_size < 0 ||
3467                     file_stat.st_size > (prefs_common.warn_large_insert_size * 1024)) {
3468                         AlertValue aval;
3469                         gchar *msg;
3470
3471                         msg = g_strdup_printf(_("You are about to insert a file of %s "
3472                                                 "in the message body. Are you sure you want to do that?"),
3473                                                 to_human_readable(file_stat.st_size));
3474                         aval = alertpanel_full(_("Are you sure?"), msg, GTK_STOCK_CANCEL,
3475                                         _("+_Insert"), NULL, TRUE, NULL, ALERT_QUESTION, G_ALERTDEFAULT);
3476                         g_free(msg);
3477
3478                         /* do we ask for confirmation next time? */
3479                         if (aval & G_ALERTDISABLE) {
3480                                 /* no confirmation next time, disable feature in preferences */
3481                                 aval &= ~G_ALERTDISABLE;
3482                                 prefs_common.warn_large_insert = FALSE;
3483                         }
3484
3485                         /* abort file insertion if user canceled action */
3486                         if (aval != G_ALERTALTERNATE) {
3487                                 return COMPOSE_INSERT_NO_FILE;
3488                         }
3489                 }
3490         }
3491
3492
3493         if ((fp = g_fopen(file, "rb")) == NULL) {
3494                 FILE_OP_ERROR(file, "fopen");
3495                 return COMPOSE_INSERT_READ_ERROR;
3496         }
3497
3498         prev_autowrap = compose->autowrap;
3499         compose->autowrap = FALSE;
3500
3501         text = GTK_TEXT_VIEW(compose->text);
3502         buffer = gtk_text_view_get_buffer(text);
3503         mark = gtk_text_buffer_get_insert(buffer);
3504         gtk_text_buffer_get_iter_at_mark(buffer, &iter, mark);
3505
3506         g_signal_handlers_block_by_func(G_OBJECT(buffer),
3507                                         G_CALLBACK(text_inserted),
3508                                         compose);
3509
3510         cur_encoding = conv_get_locale_charset_str_no_utf8();
3511
3512         while (fgets(buf, sizeof(buf), fp) != NULL) {
3513                 gchar *str;
3514
3515                 if (g_utf8_validate(buf, -1, NULL) == TRUE)
3516                         str = g_strdup(buf);
3517                 else
3518                         str = conv_codeset_strdup
3519                                 (buf, cur_encoding, CS_INTERNAL);
3520                 if (!str) continue;
3521
3522                 /* strip <CR> if DOS/Windows file,
3523                    replace <CR> with <LF> if Macintosh file. */
3524                 strcrchomp(str);
3525                 len = strlen(str);
3526                 if (len > 0 && str[len - 1] != '\n') {
3527                         while (--len >= 0)
3528                                 if (str[len] == '\r') str[len] = '\n';
3529                 }
3530
3531                 gtk_text_buffer_insert(buffer, &iter, str, -1);
3532                 g_free(str);
3533         }
3534
3535         g_signal_handlers_unblock_by_func(G_OBJECT(buffer),
3536                                           G_CALLBACK(text_inserted),
3537                                           compose);
3538         compose->autowrap = prev_autowrap;
3539         if (compose->autowrap)
3540                 compose_wrap_all(compose);
3541
3542         fclose(fp);
3543
3544         if (badtxt)
3545                 return COMPOSE_INSERT_INVALID_CHARACTER;
3546         else
3547                 return COMPOSE_INSERT_SUCCESS;
3548 }
3549
3550 static gboolean compose_attach_append(Compose *compose, const gchar *file,
3551                                   const gchar *filename,
3552                                   const gchar *content_type,
3553                                   const gchar *charset)
3554 {
3555         AttachInfo *ainfo;
3556         GtkTreeIter iter;
3557         FILE *fp;
3558         off_t size;
3559         GAuto *auto_ainfo;
3560         gchar *size_text;
3561         GtkListStore *store;
3562         gchar *name;
3563         gboolean has_binary = FALSE;
3564
3565         if (!is_file_exist(file)) {
3566                 gchar *file_from_uri = g_filename_from_uri(file, NULL, NULL);
3567                 gboolean result = FALSE;
3568                 if (file_from_uri && is_file_exist(file_from_uri)) {
3569                         result = compose_attach_append(
3570                                                 compose, file_from_uri,
3571                                                 filename, content_type,
3572                                                 charset);
3573                 }
3574                 g_free(file_from_uri);
3575                 if (result)
3576                         return TRUE;
3577                 alertpanel_error("File %s doesn't exist\n", filename);
3578                 return FALSE;
3579         }
3580         if ((size = get_file_size(file)) < 0) {
3581                 alertpanel_error("Can't get file size of %s\n", filename);
3582                 return FALSE;
3583         }
3584         if (size == 0) {
3585                 alertpanel_error(_("File %s is empty."), filename);
3586                 return FALSE;
3587         }
3588         if ((fp = g_fopen(file, "rb")) == NULL) {
3589                 alertpanel_error(_("Can't read %s."), filename);
3590                 return FALSE;
3591         }
3592         fclose(fp);
3593
3594         ainfo = g_new0(AttachInfo, 1);
3595         auto_ainfo = g_auto_pointer_new_with_free
3596                         (ainfo, (GFreeFunc) compose_attach_info_free);
3597         ainfo->file = g_strdup(file);
3598
3599         if (content_type) {
3600                 ainfo->content_type = g_strdup(content_type);
3601                 if (!g_ascii_strcasecmp(content_type, "message/rfc822")) {
3602                         MsgInfo *msginfo;
3603                         MsgFlags flags = {0, 0};
3604
3605                         if (procmime_get_encoding_for_text_file(file, &has_binary) == ENC_7BIT)
3606                                 ainfo->encoding = ENC_7BIT;
3607                         else
3608                                 ainfo->encoding = ENC_8BIT;
3609
3610                         msginfo = procheader_parse_file(file, flags, FALSE, FALSE);
3611                         if (msginfo && msginfo->subject)
3612                                 name = g_strdup(msginfo->subject);
3613                         else
3614                                 name = g_path_get_basename(filename ? filename : file);
3615
3616                         ainfo->name = g_strdup_printf(_("Message: %s"), name);
3617
3618                         procmsg_msginfo_free(msginfo);
3619                 } else {
3620                         if (!g_ascii_strncasecmp(content_type, "text/", 5)) {
3621                                 ainfo->charset = g_strdup(charset);
3622                                 ainfo->encoding = procmime_get_encoding_for_text_file(file, &has_binary);
3623                         } else {
3624                                 ainfo->encoding = ENC_BASE64;
3625                         }
3626                         name = g_path_get_basename(filename ? filename : file);
3627                         ainfo->name = g_strdup(name);
3628                 }
3629                 g_free(name);
3630         } else {
3631                 ainfo->content_type = procmime_get_mime_type(file);
3632                 if (!ainfo->content_type) {
3633                         ainfo->content_type =
3634                                 g_strdup("application/octet-stream");
3635                         ainfo->encoding = ENC_BASE64;
3636                 } else if (!g_ascii_strncasecmp(ainfo->content_type, "text/", 5))
3637                         ainfo->encoding =
3638                                 procmime_get_encoding_for_text_file(file, &has_binary);
3639                 else
3640                         ainfo->encoding = ENC_BASE64;
3641                 name = g_path_get_basename(filename ? filename : file);
3642                 ainfo->name = g_strdup(name);
3643                 g_free(name);
3644         }
3645
3646         if (ainfo->name != NULL
3647         &&  !strcmp(ainfo->name, ".")) {
3648                 g_free(ainfo->name);
3649                 ainfo->name = NULL;
3650         }
3651
3652         if (!strcmp(ainfo->content_type, "unknown") || has_binary) {
3653                 g_free(ainfo->content_type);
3654                 ainfo->content_type = g_strdup("application/octet-stream");
3655                 g_free(ainfo->charset);
3656                 ainfo->charset = NULL;
3657         }
3658
3659         ainfo->size = (goffset)size;
3660         size_text = to_human_readable((goffset)size);
3661
3662         store = GTK_LIST_STORE(gtk_tree_view_get_model
3663                         (GTK_TREE_VIEW(compose->attach_clist)));
3664
3665         gtk_list_store_append(store, &iter);
3666         gtk_list_store_set(store, &iter,
3667                            COL_MIMETYPE, ainfo->content_type,
3668                            COL_SIZE, size_text,
3669                            COL_NAME, ainfo->name,
3670                            COL_CHARSET, ainfo->charset,
3671                            COL_DATA, ainfo,
3672                            COL_AUTODATA, auto_ainfo,
3673                            -1);
3674
3675         g_auto_pointer_free(auto_ainfo);
3676         compose_attach_update_label(compose);
3677         return TRUE;
3678 }
3679
3680 static void compose_use_signing(Compose *compose, gboolean use_signing)
3681 {
3682         compose->use_signing = use_signing;
3683         cm_toggle_menu_set_active_full(compose->ui_manager, "Menu/Options/Sign", use_signing);
3684 }
3685
3686 static void compose_use_encryption(Compose *compose, gboolean use_encryption)
3687 {
3688         compose->use_encryption = use_encryption;
3689         cm_toggle_menu_set_active_full(compose->ui_manager, "Menu/Options/Encrypt", use_encryption);
3690 }
3691
3692 #define NEXT_PART_NOT_CHILD(info)  \
3693 {  \
3694         node = info->node;  \
3695         while (node->children)  \
3696                 node = g_node_last_child(node);  \
3697         info = procmime_mimeinfo_next((MimeInfo *)node->data);  \
3698 }
3699
3700 static void compose_attach_parts(Compose *compose, MsgInfo *msginfo)
3701 {
3702         MimeInfo *mimeinfo;
3703         MimeInfo *child;
3704         MimeInfo *firsttext = NULL;
3705         MimeInfo *encrypted = NULL;
3706         GNode    *node;
3707         gchar *outfile;
3708         const gchar *partname = NULL;
3709
3710         mimeinfo = procmime_scan_message(msginfo);
3711         if (!mimeinfo) return;
3712
3713         if (mimeinfo->node->children == NULL) {
3714                 procmime_mimeinfo_free_all(mimeinfo);
3715                 return;
3716         }
3717
3718         /* find first content part */
3719         child = (MimeInfo *) mimeinfo->node->children->data;
3720         while (child && child->node->children && (child->type == MIMETYPE_MULTIPART))
3721                 child = (MimeInfo *)child->node->children->data;
3722
3723         if (child) {
3724                 if (child->type == MIMETYPE_TEXT) {
3725                         firsttext = child;
3726                         debug_print("First text part found\n");
3727                 } else if (compose->mode == COMPOSE_REEDIT &&
3728                          child->type == MIMETYPE_APPLICATION &&
3729                          !g_ascii_strcasecmp(child->subtype, "pgp-encrypted")) {
3730                         encrypted = (MimeInfo *)child->node->parent->data;
3731                 }
3732         }
3733         child = (MimeInfo *) mimeinfo->node->children->data;
3734         while (child != NULL) {
3735                 gint err;
3736
3737                 if (child == encrypted) {
3738                         /* skip this part of tree */
3739                         NEXT_PART_NOT_CHILD(child);
3740                         continue;
3741                 }
3742
3743                 if (child->type == MIMETYPE_MULTIPART) {
3744                         /* get the actual content */
3745                         child = procmime_mimeinfo_next(child);
3746                         continue;
3747                 }
3748
3749                 if (child == firsttext) {
3750                         child = procmime_mimeinfo_next(child);
3751                         continue;
3752                 }
3753
3754                 outfile = procmime_get_tmp_file_name(child);
3755                 if ((err = procmime_get_part(outfile, child)) < 0)
3756                         g_warning("Can't get the part of multipart message. (%s)", strerror(-err));
3757                 else {
3758                         gchar *content_type;
3759
3760                         content_type = procmime_get_content_type_str(child->type, child->subtype);
3761
3762                         /* if we meet a pgp signature, we don't attach it, but
3763                          * we force signing. */
3764                         if ((strcmp(content_type, "application/pgp-signature") &&
3765                             strcmp(content_type, "application/pkcs7-signature") &&
3766                             strcmp(content_type, "application/x-pkcs7-signature"))
3767                             || compose->mode == COMPOSE_REDIRECT) {
3768                                 partname = procmime_mimeinfo_get_parameter(child, "filename");
3769                                 if (partname == NULL)
3770                                         partname = procmime_mimeinfo_get_parameter(child, "name");
3771                                 if (partname == NULL)
3772                                         partname = "";
3773                                 compose_attach_append(compose, outfile,
3774                                                       partname, content_type,
3775                                                       procmime_mimeinfo_get_parameter(child, "charset"));
3776                         } else {
3777                                 compose_force_signing(compose, compose->account, NULL);
3778                         }
3779                         g_free(content_type);
3780                 }
3781                 g_free(outfile);
3782                 NEXT_PART_NOT_CHILD(child);
3783         }
3784         procmime_mimeinfo_free_all(mimeinfo);
3785 }
3786
3787 #undef NEXT_PART_NOT_CHILD
3788
3789
3790
3791 typedef enum {
3792         WAIT_FOR_INDENT_CHAR,
3793         WAIT_FOR_INDENT_CHAR_OR_SPACE,
3794 } IndentState;
3795
3796 /* return indent length, we allow:
3797    indent characters followed by indent characters or spaces/tabs,
3798    alphabets and numbers immediately followed by indent characters,
3799    and the repeating sequences of the above
3800    If quote ends with multiple spaces, only the first one is included. */
3801 static gchar *compose_get_quote_str(GtkTextBuffer *buffer,
3802                                     const GtkTextIter *start, gint *len)
3803 {
3804         GtkTextIter iter = *start;
3805         gunichar wc;
3806         gchar ch[6];
3807         gint clen;
3808         IndentState state = WAIT_FOR_INDENT_CHAR;
3809         gboolean is_space;
3810         gboolean is_indent;
3811         gint alnum_count = 0;
3812         gint space_count = 0;
3813         gint quote_len = 0;
3814
3815         if (prefs_common.quote_chars == NULL) {
3816                 return 0 ;
3817         }
3818
3819         while (!gtk_text_iter_ends_line(&iter)) {
3820                 wc = gtk_text_iter_get_char(&iter);
3821                 if (g_unichar_iswide(wc))
3822                         break;
3823                 clen = g_unichar_to_utf8(wc, ch);
3824                 if (clen != 1)
3825                         break;
3826
3827                 is_indent = strchr(prefs_common.quote_chars, ch[0]) ? TRUE : FALSE;
3828                 is_space = g_unichar_isspace(wc);
3829
3830                 if (state == WAIT_FOR_INDENT_CHAR) {
3831                         if (!is_indent && !g_unichar_isalnum(wc))
3832                                 break;
3833                         if (is_indent) {
3834                                 quote_len += alnum_count + space_count + 1;
3835                                 alnum_count = space_count = 0;
3836                                 state = WAIT_FOR_INDENT_CHAR_OR_SPACE;
3837                         } else
3838                                 alnum_count++;
3839                 } else if (state == WAIT_FOR_INDENT_CHAR_OR_SPACE) {
3840                         if (!is_indent && !is_space && !g_unichar_isalnum(wc))
3841                                 break;
3842                         if (is_space)
3843                                 space_count++;
3844                         else if (is_indent) {
3845                                 quote_len += alnum_count + space_count + 1;
3846                                 alnum_count = space_count = 0;
3847                         } else {
3848                                 alnum_count++;
3849                                 state = WAIT_FOR_INDENT_CHAR;
3850                         }
3851                 }
3852
3853                 gtk_text_iter_forward_char(&iter);
3854         }
3855
3856         if (quote_len > 0 && space_count > 0)
3857                 quote_len++;
3858
3859         if (len)
3860                 *len = quote_len;
3861
3862         if (quote_len > 0) {
3863                 iter = *start;
3864                 gtk_text_iter_forward_chars(&iter, quote_len);
3865                 return gtk_text_buffer_get_text(buffer, start, &iter, FALSE);
3866         }
3867
3868         return NULL;
3869 }
3870
3871 /* return >0 if the line is itemized */
3872 static int compose_itemized_length(GtkTextBuffer *buffer,
3873                                     const GtkTextIter *start)
3874 {
3875         GtkTextIter iter = *start;
3876         gunichar wc;
3877         gchar ch[6];
3878         gint clen;
3879         gint len = 0;
3880         if (gtk_text_iter_ends_line(&iter))
3881                 return 0;
3882
3883         while (1) {
3884                 len++;
3885                 wc = gtk_text_iter_get_char(&iter);
3886                 if (!g_unichar_isspace(wc))
3887                         break;
3888                 gtk_text_iter_forward_char(&iter);
3889                 if (gtk_text_iter_ends_line(&iter))
3890                         return 0;
3891         }
3892
3893         clen = g_unichar_to_utf8(wc, ch);
3894         if (clen != 1)
3895                 return 0;
3896
3897         if (!strchr("*-+", ch[0]))
3898                 return 0;
3899
3900         gtk_text_iter_forward_char(&iter);
3901         if (gtk_text_iter_ends_line(&iter))
3902                 return 0;
3903         wc = gtk_text_iter_get_char(&iter);
3904         if (g_unichar_isspace(wc)) {
3905                 return len+1;
3906         }
3907         return 0;
3908 }
3909
3910 /* return the string at the start of the itemization */
3911 static gchar * compose_get_itemized_chars(GtkTextBuffer *buffer,
3912                                     const GtkTextIter *start)
3913 {
3914         GtkTextIter iter = *start;
3915         gunichar wc;
3916         gint len = 0;
3917         GString *item_chars = g_string_new("");
3918         gchar *str = NULL;
3919
3920         if (gtk_text_iter_ends_line(&iter))
3921                 return NULL;
3922
3923         while (1) {
3924                 len++;
3925                 wc = gtk_text_iter_get_char(&iter);
3926                 if (!g_unichar_isspace(wc))
3927                         break;
3928                 gtk_text_iter_forward_char(&iter);
3929                 if (gtk_text_iter_ends_line(&iter))
3930                         break;
3931                 g_string_append_unichar(item_chars, wc);
3932         }
3933
3934         str = item_chars->str;
3935         g_string_free(item_chars, FALSE);
3936         return str;
3937 }
3938
3939 /* return the number of spaces at a line's start */
3940 static int compose_left_offset_length(GtkTextBuffer *buffer,
3941                                     const GtkTextIter *start)
3942 {
3943         GtkTextIter iter = *start;
3944         gunichar wc;
3945         gint len = 0;
3946         if (gtk_text_iter_ends_line(&iter))
3947                 return 0;
3948
3949         while (1) {
3950                 wc = gtk_text_iter_get_char(&iter);
3951                 if (!g_unichar_isspace(wc))
3952                         break;
3953                 len++;
3954                 gtk_text_iter_forward_char(&iter);
3955                 if (gtk_text_iter_ends_line(&iter))
3956                         return 0;
3957         }
3958
3959         gtk_text_iter_forward_char(&iter);
3960         if (gtk_text_iter_ends_line(&iter))
3961                 return 0;
3962         return len;
3963 }
3964
3965 static gboolean compose_get_line_break_pos(GtkTextBuffer *buffer,
3966                                            const GtkTextIter *start,
3967                                            GtkTextIter *break_pos,
3968                                            gint max_col,
3969                                            gint quote_len)
3970 {
3971         GtkTextIter iter = *start, line_end = *start;
3972         PangoLogAttr *attrs;
3973         gchar *str;
3974         gchar *p;
3975         gint len;
3976         gint i;
3977         gint col = 0;
3978         gint pos = 0;
3979         gboolean can_break = FALSE;
3980         gboolean do_break = FALSE;
3981         gboolean was_white = FALSE;
3982         gboolean prev_dont_break = FALSE;
3983
3984         gtk_text_iter_forward_to_line_end(&line_end);
3985         str = gtk_text_buffer_get_text(buffer, &iter, &line_end, FALSE);
3986         len = g_utf8_strlen(str, -1);
3987
3988         if (len == 0) {
3989                 g_free(str);
3990                 g_warning("compose_get_line_break_pos: len = 0!\n");
3991                 return FALSE;
3992         }
3993
3994         /* g_print("breaking line: %d: %s (len = %d)\n",
3995                 gtk_text_iter_get_line(&iter), str, len); */
3996
3997         attrs = g_new(PangoLogAttr, len + 1);
3998
3999         pango_default_break(str, -1, NULL, attrs, len + 1);
4000
4001         p = str;
4002
4003         /* skip quote and leading spaces */
4004         for (i = 0; *p != '\0' && i < len; i++) {
4005                 gunichar wc;
4006
4007                 wc = g_utf8_get_char(p);
4008                 if (i >= quote_len && !g_unichar_isspace(wc))
4009                         break;
4010                 if (g_unichar_iswide(wc))
4011                         col += 2;
4012                 else if (*p == '\t')
4013                         col += 8;
4014                 else
4015                         col++;
4016                 p = g_utf8_next_char(p);
4017         }
4018
4019         for (; *p != '\0' && i < len; i++) {
4020                 PangoLogAttr *attr = attrs + i;
4021                 gunichar wc;
4022                 gint uri_len;
4023
4024                 if (attr->is_line_break && can_break && was_white && !prev_dont_break)
4025                         pos = i;
4026
4027                 was_white = attr->is_white;
4028
4029                 /* don't wrap URI */
4030                 if ((uri_len = get_uri_len(p)) > 0) {
4031                         col += uri_len;
4032                         if (pos > 0 && col > max_col) {
4033                                 do_break = TRUE;
4034                                 break;
4035                         }
4036                         i += uri_len - 1;
4037                         p += uri_len;
4038                         can_break = TRUE;
4039                         continue;
4040                 }
4041
4042                 wc = g_utf8_get_char(p);
4043                 if (g_unichar_iswide(wc)) {
4044                         col += 2;
4045                         if (prev_dont_break && can_break && attr->is_line_break)
4046                                 pos = i;
4047                 } else if (*p == '\t')
4048                         col += 8;
4049                 else
4050                         col++;
4051                 if (pos > 0 && col > max_col) {
4052                         do_break = TRUE;
4053                         break;
4054                 }
4055
4056                 if (*p == '-' || *p == '/')
4057                         prev_dont_break = TRUE;
4058                 else
4059                         prev_dont_break = FALSE;
4060
4061                 p = g_utf8_next_char(p);
4062                 can_break = TRUE;
4063         }
4064
4065 //      debug_print("compose_get_line_break_pos(): do_break = %d, pos = %d, col = %d\n", do_break, pos, col);
4066
4067         g_free(attrs);
4068         g_free(str);
4069
4070         *break_pos = *start;
4071         gtk_text_iter_set_line_offset(break_pos, pos);
4072
4073         return do_break;
4074 }
4075
4076 static gboolean compose_join_next_line(Compose *compose,
4077                                        GtkTextBuffer *buffer,
4078                                        GtkTextIter *iter,
4079                                        const gchar *quote_str)
4080 {
4081         GtkTextIter iter_ = *iter, cur, prev, next, end;
4082         PangoLogAttr attrs[3];
4083         gchar *str;
4084         gchar *next_quote_str;
4085         gunichar wc1, wc2;
4086         gint quote_len;
4087         gboolean keep_cursor = FALSE;
4088
4089         if (!gtk_text_iter_forward_line(&iter_) ||
4090             gtk_text_iter_ends_line(&iter_)) {
4091                 return FALSE;
4092         }
4093         next_quote_str = compose_get_quote_str(buffer, &iter_, &quote_len);
4094
4095         if ((quote_str || next_quote_str) &&
4096             strcmp2(quote_str, next_quote_str) != 0) {
4097                 g_free(next_quote_str);
4098                 return FALSE;
4099         }
4100         g_free(next_quote_str);
4101
4102         end = iter_;
4103         if (quote_len > 0) {
4104                 gtk_text_iter_forward_chars(&end, quote_len);
4105                 if (gtk_text_iter_ends_line(&end)) {
4106                         return FALSE;
4107                 }
4108         }
4109
4110         /* don't join itemized lines */
4111         if (compose_itemized_length(buffer, &end) > 0) {
4112                 return FALSE;
4113         }
4114
4115         /* don't join signature separator */
4116         if (compose_is_sig_separator(compose, buffer, &iter_)) {
4117                 return FALSE;
4118         }
4119         /* delete quote str */
4120         if (quote_len > 0)
4121                 gtk_text_buffer_delete(buffer, &iter_, &end);
4122
4123         /* don't join line breaks put by the user */
4124         prev = cur = iter_;
4125         gtk_text_iter_backward_char(&cur);
4126         if (gtk_text_iter_has_tag(&cur, compose->no_join_tag)) {
4127                 gtk_text_iter_forward_char(&cur);
4128                 *iter = cur;
4129                 return FALSE;
4130         }
4131         gtk_text_iter_forward_char(&cur);
4132         /* delete linebreak and extra spaces */
4133         while (gtk_text_iter_backward_char(&cur)) {
4134                 wc1 = gtk_text_iter_get_char(&cur);
4135                 if (!g_unichar_isspace(wc1))
4136                         break;
4137                 prev = cur;
4138         }
4139         next = cur = iter_;
4140         while (!gtk_text_iter_ends_line(&cur)) {
4141                 wc1 = gtk_text_iter_get_char(&cur);
4142                 if (!g_unichar_isspace(wc1))
4143                         break;
4144                 gtk_text_iter_forward_char(&cur);
4145                 next = cur;
4146         }
4147         if (!gtk_text_iter_equal(&prev, &next)) {
4148                 GtkTextMark *mark;
4149
4150                 mark = gtk_text_buffer_get_insert(buffer);
4151                 gtk_text_buffer_get_iter_at_mark(buffer, &cur, mark);
4152                 if (gtk_text_iter_equal(&prev, &cur))
4153                         keep_cursor = TRUE;
4154                 gtk_text_buffer_delete(buffer, &prev, &next);
4155         }
4156         iter_ = prev;
4157
4158         /* insert space if required */
4159         gtk_text_iter_backward_char(&prev);
4160         wc1 = gtk_text_iter_get_char(&prev);
4161         wc2 = gtk_text_iter_get_char(&next);
4162         gtk_text_iter_forward_char(&next);
4163         str = gtk_text_buffer_get_text(buffer, &prev, &next, FALSE);
4164         pango_default_break(str, -1, NULL, attrs, 3);
4165         if (!attrs[1].is_line_break ||
4166             (!g_unichar_iswide(wc1) || !g_unichar_iswide(wc2))) {
4167                 gtk_text_buffer_insert(buffer, &iter_, " ", 1);
4168                 if (keep_cursor) {
4169                         gtk_text_iter_backward_char(&iter_);
4170                         gtk_text_buffer_place_cursor(buffer, &iter_);
4171                 }
4172         }
4173         g_free(str);
4174
4175         *iter = iter_;
4176         return TRUE;
4177 }
4178
4179 #define ADD_TXT_POS(bp_, ep_, pti_) \
4180         if ((last->next = alloca(sizeof(struct txtpos))) != NULL) { \
4181                 last = last->next; \
4182                 last->bp = (bp_); last->ep = (ep_); last->pti = (pti_); \
4183                 last->next = NULL; \
4184         } else { \
4185                 g_warning("alloc error scanning URIs\n"); \
4186         }
4187
4188 static gboolean compose_beautify_paragraph(Compose *compose, GtkTextIter *par_iter, gboolean force)
4189 {
4190         GtkTextView *text = GTK_TEXT_VIEW(compose->text);
4191         GtkTextBuffer *buffer;
4192         GtkTextIter iter, break_pos, end_of_line;
4193         gchar *quote_str = NULL;
4194         gint quote_len;
4195         gboolean wrap_quote = prefs_common.linewrap_quote;
4196         gboolean prev_autowrap = compose->autowrap;
4197         gint startq_offset = -1, noq_offset = -1;
4198         gint uri_start = -1, uri_stop = -1;
4199         gint nouri_start = -1, nouri_stop = -1;
4200         gint num_blocks = 0;
4201         gint quotelevel = -1;
4202         gboolean modified = force;
4203         gboolean removed = FALSE;
4204         gboolean modified_before_remove = FALSE;
4205         gint lines = 0;
4206         gboolean start = TRUE;
4207         gint itemized_len = 0, rem_item_len = 0;
4208         gchar *itemized_chars = NULL;
4209         gboolean item_continuation = FALSE;
4210
4211         if (force) {
4212                 modified = TRUE;
4213         }
4214         if (compose->draft_timeout_tag == -2) {
4215                 modified = TRUE;
4216         }
4217
4218         compose->autowrap = FALSE;
4219
4220         buffer = gtk_text_view_get_buffer(text);
4221         undo_wrapping(compose->undostruct, TRUE);
4222         if (par_iter) {
4223                 iter = *par_iter;
4224         } else {
4225                 GtkTextMark *mark;
4226                 mark = gtk_text_buffer_get_insert(buffer);
4227                 gtk_text_buffer_get_iter_at_mark(buffer, &iter, mark);
4228         }
4229
4230
4231         if (compose->draft_timeout_tag == -2) {
4232                 if (gtk_text_iter_ends_line(&iter)) {
4233                         while (gtk_text_iter_ends_line(&iter) &&
4234                                gtk_text_iter_forward_line(&iter))
4235                                 ;
4236                 } else {
4237                         while (gtk_text_iter_backward_line(&iter)) {
4238                                 if (gtk_text_iter_ends_line(&iter)) {
4239                                         gtk_text_iter_forward_line(&iter);
4240                                         break;
4241                                 }
4242                         }
4243                 }
4244         } else {
4245                 /* move to line start */
4246                 gtk_text_iter_set_line_offset(&iter, 0);
4247         }
4248
4249         itemized_len = compose_itemized_length(buffer, &iter);
4250
4251         if (!itemized_len) {
4252                 itemized_len = compose_left_offset_length(buffer, &iter);
4253                 item_continuation = TRUE;
4254         }
4255
4256         if (itemized_len)
4257                 itemized_chars = compose_get_itemized_chars(buffer, &iter);
4258
4259         /* go until paragraph end (empty line) */
4260         while (start || !gtk_text_iter_ends_line(&iter)) {
4261                 gchar *scanpos = NULL;
4262                 /* parse table - in order of priority */
4263                 struct table {
4264                         const gchar *needle; /* token */
4265
4266                         /* token search function */
4267                         gchar    *(*search)     (const gchar *haystack,
4268                                                  const gchar *needle);
4269                         /* part parsing function */
4270                         gboolean  (*parse)      (const gchar *start,
4271                                                  const gchar *scanpos,
4272                                                  const gchar **bp_,
4273                                                  const gchar **ep_,
4274                                                  gboolean hdr);
4275                         /* part to URI function */
4276                         gchar    *(*build_uri)  (const gchar *bp,
4277                                                  const gchar *ep);
4278                 };
4279
4280                 static struct table parser[] = {
4281                         {"http://",  strcasestr, get_uri_part,   make_uri_string},
4282                         {"https://", strcasestr, get_uri_part,   make_uri_string},
4283                         {"ftp://",   strcasestr, get_uri_part,   make_uri_string},
4284                         {"sftp://",  strcasestr, get_uri_part,   make_uri_string},
4285                         {"gopher://",strcasestr, get_uri_part,   make_uri_string},
4286                         {"www.",     strcasestr, get_uri_part,   make_http_string},
4287                         {"mailto:",  strcasestr, get_uri_part,   make_uri_string},
4288                         {"@",        strcasestr, get_email_part, make_email_string}
4289                 };
4290                 const gint PARSE_ELEMS = sizeof parser / sizeof parser[0];
4291                 gint last_index = PARSE_ELEMS;
4292                 gint  n;
4293                 gchar *o_walk = NULL, *walk = NULL, *bp = NULL, *ep = NULL;
4294                 gint walk_pos;
4295
4296                 start = FALSE;
4297                 if (!prev_autowrap && num_blocks == 0) {
4298                         num_blocks++;
4299                         g_signal_handlers_block_by_func(G_OBJECT(buffer),
4300                                         G_CALLBACK(text_inserted),
4301                                         compose);
4302                 }
4303                 if (gtk_text_iter_has_tag(&iter, compose->no_wrap_tag) && !force)
4304                         goto colorize;
4305
4306                 uri_start = uri_stop = -1;
4307                 quote_len = 0;
4308                 quote_str = compose_get_quote_str(buffer, &iter, &quote_len);
4309
4310                 if (quote_str) {
4311 //                      debug_print("compose_beautify_paragraph(): quote_str = '%s'\n", quote_str);
4312                         if (startq_offset == -1)
4313                                 startq_offset = gtk_text_iter_get_offset(&iter);
4314                         quotelevel = get_quote_level(quote_str, prefs_common.quote_chars);
4315                         if (quotelevel > 2) {
4316                                 /* recycle colors */
4317                                 if (prefs_common.recycle_quote_colors)
4318                                         quotelevel %= 3;
4319                                 else
4320                                         quotelevel = 2;
4321                         }
4322                         if (!wrap_quote) {
4323                                 goto colorize;
4324                         }
4325                 } else {
4326                         if (startq_offset == -1)
4327                                 noq_offset = gtk_text_iter_get_offset(&iter);
4328                         quotelevel = -1;
4329                 }
4330
4331                 if (prev_autowrap == FALSE && !force && !wrap_quote) {
4332                         goto colorize;
4333                 }
4334                 if (gtk_text_iter_ends_line(&iter)) {
4335                         goto colorize;
4336                 } else if (compose_get_line_break_pos(buffer, &iter, &break_pos,
4337                                                prefs_common.linewrap_len,
4338                                                quote_len)) {
4339                         GtkTextIter prev, next, cur;
4340                         if (prev_autowrap != FALSE || force) {
4341                                 compose->automatic_break = TRUE;
4342                                 modified = TRUE;
4343                                 gtk_text_buffer_insert(buffer, &break_pos, "\n", 1);
4344                                 compose->automatic_break = FALSE;
4345                                 if (itemized_len && compose->autoindent) {
4346                                         gtk_text_buffer_insert(buffer, &break_pos, itemized_chars, -1);
4347                                         if (!item_continuation)
4348                                                 gtk_text_buffer_insert(buffer, &break_pos, "  ", 2);
4349                                 }
4350                         } else if (quote_str && wrap_quote) {
4351                                 compose->automatic_break = TRUE;
4352                                 modified = TRUE;
4353                                 gtk_text_buffer_insert(buffer, &break_pos, "\n", 1);
4354                                 compose->automatic_break = FALSE;
4355                                 if (itemized_len && compose->autoindent) {
4356                                         gtk_text_buffer_insert(buffer, &break_pos, itemized_chars, -1);
4357                                         if (!item_continuation)
4358                                                 gtk_text_buffer_insert(buffer, &break_pos, "  ", 2);
4359                                 }
4360                         } else
4361                                 goto colorize;
4362                         /* remove trailing spaces */
4363                         cur = break_pos;
4364                         rem_item_len = itemized_len;
4365                         while (compose->autoindent && rem_item_len-- > 0)
4366                                 gtk_text_iter_backward_char(&cur);
4367                         gtk_text_iter_backward_char(&cur);
4368
4369                         prev = next = cur;
4370                         while (!gtk_text_iter_starts_line(&cur)) {
4371                                 gunichar wc;
4372
4373                                 gtk_text_iter_backward_char(&cur);
4374                                 wc = gtk_text_iter_get_char(&cur);
4375                                 if (!g_unichar_isspace(wc))
4376                                         break;
4377                                 prev = cur;
4378                         }
4379                         if (!gtk_text_iter_equal(&prev, &next)) {
4380                                 gtk_text_buffer_delete(buffer, &prev, &next);
4381                                 break_pos = next;
4382                                 gtk_text_iter_forward_char(&break_pos);
4383                         }
4384
4385                         if (quote_str)
4386                                 gtk_text_buffer_insert(buffer, &break_pos,
4387                                                        quote_str, -1);
4388
4389                         iter = break_pos;
4390                         modified |= compose_join_next_line(compose, buffer, &iter, quote_str);
4391
4392                         /* move iter to current line start */
4393                         gtk_text_iter_set_line_offset(&iter, 0);
4394                         if (quote_str) {
4395                                 g_free(quote_str);
4396                                 quote_str = NULL;
4397                         }
4398                         continue;
4399                 } else {
4400                         /* move iter to next line start */
4401                         iter = break_pos;
4402                         lines++;
4403                 }
4404
4405 colorize:
4406                 if (!prev_autowrap && num_blocks > 0) {
4407                         num_blocks--;
4408                         g_signal_handlers_unblock_by_func(G_OBJECT(buffer),
4409                                         G_CALLBACK(text_inserted),
4410                                         compose);
4411                 }
4412                 end_of_line = iter;
4413                 while (!gtk_text_iter_ends_line(&end_of_line)) {
4414                         gtk_text_iter_forward_char(&end_of_line);
4415                 }
4416                 o_walk = walk = gtk_text_buffer_get_text(buffer, &iter, &end_of_line, FALSE);
4417
4418                 nouri_start = gtk_text_iter_get_offset(&iter);
4419                 nouri_stop = gtk_text_iter_get_offset(&end_of_line);
4420
4421                 walk_pos = gtk_text_iter_get_offset(&iter);
4422                 /* FIXME: this looks phony. scanning for anything in the parse table */
4423                 for (n = 0; n < PARSE_ELEMS; n++) {
4424                         gchar *tmp;
4425
4426                         tmp = parser[n].search(walk, parser[n].needle);
4427                         if (tmp) {
4428                                 if (scanpos == NULL || tmp < scanpos) {
4429                                         scanpos = tmp;
4430                                         last_index = n;
4431                                 }
4432                         }
4433                 }
4434
4435                 bp = ep = 0;
4436                 if (scanpos) {
4437                         /* check if URI can be parsed */
4438                         if (parser[last_index].parse(walk, scanpos, (const gchar **)&bp,
4439                                         (const gchar **)&ep, FALSE)
4440                             && (size_t) (ep - bp - 1) > strlen(parser[last_index].needle)) {
4441                                         walk = ep;
4442                         } else
4443                                 walk = scanpos +
4444                                         strlen(parser[last_index].needle);
4445                 }
4446                 if (bp && ep) {
4447                         uri_start = walk_pos + (bp - o_walk);
4448                         uri_stop  = walk_pos + (ep - o_walk);
4449                 }
4450                 g_free(o_walk);
4451                 o_walk = NULL;
4452                 gtk_text_iter_forward_line(&iter);
4453                 g_free(quote_str);
4454                 quote_str = NULL;
4455                 if (startq_offset != -1) {
4456                         GtkTextIter startquote, endquote;
4457                         gtk_text_buffer_get_iter_at_offset(
4458                                 buffer, &startquote, startq_offset);
4459                         endquote = iter;
4460
4461                         switch (quotelevel) {
4462                         case 0:
4463                                 if (!gtk_text_iter_has_tag(&startquote, compose->quote0_tag) ||
4464                                     !gtk_text_iter_has_tag(&end_of_line, compose->quote0_tag)) {
4465                                         gtk_text_buffer_apply_tag_by_name(
4466                                                 buffer, "quote0", &startquote, &endquote);
4467                                         gtk_text_buffer_remove_tag_by_name(
4468                                                 buffer, "quote1", &startquote, &endquote);
4469                                         gtk_text_buffer_remove_tag_by_name(
4470                                                 buffer, "quote2", &startquote, &endquote);
4471                                         modified = TRUE;
4472                                 }
4473                                 break;
4474                         case 1:
4475                                 if (!gtk_text_iter_has_tag(&startquote, compose->quote1_tag) ||
4476                                     !gtk_text_iter_has_tag(&end_of_line, compose->quote1_tag)) {
4477                                         gtk_text_buffer_apply_tag_by_name(
4478                                                 buffer, "quote1", &startquote, &endquote);
4479                                         gtk_text_buffer_remove_tag_by_name(
4480                                                 buffer, "quote0", &startquote, &endquote);
4481                                         gtk_text_buffer_remove_tag_by_name(
4482                                                 buffer, "quote2", &startquote, &endquote);
4483                                         modified = TRUE;
4484                                 }
4485                                 break;
4486                         case 2:
4487                                 if (!gtk_text_iter_has_tag(&startquote, compose->quote2_tag) ||
4488                                     !gtk_text_iter_has_tag(&end_of_line, compose->quote2_tag)) {
4489                                         gtk_text_buffer_apply_tag_by_name(
4490                                                 buffer, "quote2", &startquote, &endquote);
4491                                         gtk_text_buffer_remove_tag_by_name(
4492                                                 buffer, "quote0", &startquote, &endquote);
4493                                         gtk_text_buffer_remove_tag_by_name(
4494                                                 buffer, "quote1", &startquote, &endquote);
4495                                         modified = TRUE;
4496                                 }
4497                                 break;
4498                         }
4499                         startq_offset = -1;
4500                 } else if (noq_offset != -1) {
4501                         GtkTextIter startnoquote, endnoquote;
4502                         gtk_text_buffer_get_iter_at_offset(
4503                                 buffer, &startnoquote, noq_offset);
4504                         endnoquote = iter;
4505
4506                         if ((gtk_text_iter_has_tag(&startnoquote, compose->quote0_tag)
4507                           && gtk_text_iter_has_tag(&end_of_line, compose->quote0_tag)) ||
4508                             (gtk_text_iter_has_tag(&startnoquote, compose->quote1_tag)
4509                           && gtk_text_iter_has_tag(&end_of_line, compose->quote1_tag)) ||
4510                             (gtk_text_iter_has_tag(&startnoquote, compose->quote2_tag)
4511                           && gtk_text_iter_has_tag(&end_of_line, compose->quote2_tag))) {
4512                                 gtk_text_buffer_remove_tag_by_name(
4513                                         buffer, "quote0", &startnoquote, &endnoquote);
4514                                 gtk_text_buffer_remove_tag_by_name(
4515                                         buffer, "quote1", &startnoquote, &endnoquote);
4516                                 gtk_text_buffer_remove_tag_by_name(
4517                                         buffer, "quote2", &startnoquote, &endnoquote);
4518                                 modified = TRUE;
4519                         }
4520                         noq_offset = -1;
4521                 }
4522
4523                 if (uri_start != nouri_start && uri_stop != nouri_stop) {
4524                         GtkTextIter nouri_start_iter, nouri_end_iter;
4525                         gtk_text_buffer_get_iter_at_offset(
4526                                 buffer, &nouri_start_iter, nouri_start);
4527                         gtk_text_buffer_get_iter_at_offset(
4528                                 buffer, &nouri_end_iter, nouri_stop);
4529                         if (gtk_text_iter_has_tag(&nouri_start_iter, compose->uri_tag) &&
4530                             gtk_text_iter_has_tag(&nouri_end_iter, compose->uri_tag)) {
4531                                 gtk_text_buffer_remove_tag_by_name(
4532                                         buffer, "link", &nouri_start_iter, &nouri_end_iter);
4533                                 modified_before_remove = modified;
4534                                 modified = TRUE;
4535                                 removed = TRUE;
4536                         }
4537                 }
4538                 if (uri_start >= 0 && uri_stop > 0) {
4539                         GtkTextIter uri_start_iter, uri_end_iter, back;
4540                         gtk_text_buffer_get_iter_at_offset(
4541                                 buffer, &uri_start_iter, uri_start);
4542                         gtk_text_buffer_get_iter_at_offset(
4543                                 buffer, &uri_end_iter, uri_stop);
4544                         back = uri_end_iter;
4545                         gtk_text_iter_backward_char(&back);
4546                         if (!gtk_text_iter_has_tag(&uri_start_iter, compose->uri_tag) ||
4547                             !gtk_text_iter_has_tag(&back, compose->uri_tag)) {
4548                                 gtk_text_buffer_apply_tag_by_name(
4549                                         buffer, "link", &uri_start_iter, &uri_end_iter);
4550                                 modified = TRUE;
4551                                 if (removed && !modified_before_remove) {
4552                                         modified = FALSE;
4553                                 }
4554                         }
4555                 }
4556                 if (!modified) {
4557 //                      debug_print("not modified, out after %d lines\n", lines);
4558                         goto end;
4559                 }
4560         }
4561 //      debug_print("modified, out after %d lines\n", lines);
4562 end:
4563         g_free(itemized_chars);
4564         if (par_iter)
4565                 *par_iter = iter;
4566         undo_wrapping(compose->undostruct, FALSE);
4567         compose->autowrap = prev_autowrap;
4568
4569         return modified;
4570 }
4571
4572 void compose_action_cb(void *data)
4573 {
4574         Compose *compose = (Compose *)data;
4575         compose_wrap_all(compose);
4576 }
4577
4578 static void compose_wrap_all(Compose *compose)
4579 {
4580         compose_wrap_all_full(compose, FALSE);
4581 }
4582
4583 static void compose_wrap_all_full(Compose *compose, gboolean force)
4584 {
4585         GtkTextView *text = GTK_TEXT_VIEW(compose->text);
4586         GtkTextBuffer *buffer;
4587         GtkTextIter iter;
4588         gboolean modified = TRUE;
4589
4590         buffer = gtk_text_view_get_buffer(text);
4591
4592         gtk_text_buffer_get_start_iter(buffer, &iter);
4593         while (!gtk_text_iter_is_end(&iter) && modified)
4594                 modified = compose_beautify_paragraph(compose, &iter, force);
4595
4596 }
4597
4598 static void compose_set_title(Compose *compose)
4599 {
4600         gchar *str;
4601         gchar *edited;
4602         gchar *subject;
4603
4604         edited = compose->modified ? _(" [Edited]") : "";
4605
4606         subject = gtk_editable_get_chars(
4607                         GTK_EDITABLE(compose->subject_entry), 0, -1);
4608
4609 #ifndef GENERIC_UMPC
4610         if (subject && strlen(subject))
4611                 str = g_strdup_printf(_("%s - Compose message%s"),
4612                                       subject, edited);
4613         else
4614                 str = g_strdup_printf(_("[no subject] - Compose message%s"), edited);
4615 #else
4616         str = g_strdup(_("Compose message"));
4617 #endif
4618
4619         gtk_window_set_title(GTK_WINDOW(compose->window), str);
4620         g_free(str);
4621         g_free(subject);
4622 }
4623
4624 /**
4625  * compose_current_mail_account:
4626  *
4627  * Find a current mail account (the currently selected account, or the
4628  * default account, if a news account is currently selected).  If a
4629  * mail account cannot be found, display an error message.
4630  *
4631  * Return value: Mail account, or NULL if not found.
4632  **/
4633 static PrefsAccount *
4634 compose_current_mail_account(void)
4635 {
4636         PrefsAccount *ac;
4637
4638         if (cur_account && cur_account->protocol != A_NNTP)
4639                 ac = cur_account;
4640         else {
4641                 ac = account_get_default();
4642                 if (!ac || ac->protocol == A_NNTP) {
4643                         alertpanel_error(_("Account for sending mail is not specified.\n"
4644                                            "Please select a mail account before sending."));
4645                         return NULL;
4646                 }
4647         }
4648         return ac;
4649 }
4650
4651 #define QUOTE_IF_REQUIRED(out, str)                                     \
4652 {                                                                       \
4653         if (*str != '"' && strpbrk(str, ",.[]<>")) {                    \
4654                 gchar *__tmp;                                           \
4655                 gint len;                                               \
4656                                                                         \
4657                 len = strlen(str) + 3;                                  \
4658                 if ((__tmp = alloca(len)) == NULL) {                    \
4659                         g_warning("can't allocate memory\n");           \
4660                         g_string_free(header, TRUE);                    \
4661                         return NULL;                                    \
4662                 }                                                       \
4663                 g_snprintf(__tmp, len, "\"%s\"", str);                  \
4664                 out = __tmp;                                            \
4665         } else {                                                        \
4666                 gchar *__tmp;                                           \
4667                                                                         \
4668                 if ((__tmp = alloca(strlen(str) + 1)) == NULL) {        \
4669                         g_warning("can't allocate memory\n");           \
4670                         g_string_free(header, TRUE);                    \
4671                         return NULL;                                    \
4672                 } else                                                  \
4673                         strcpy(__tmp, str);                             \
4674                                                                         \
4675                 out = __tmp;                                            \
4676         }                                                               \
4677 }
4678
4679 #define QUOTE_IF_REQUIRED_NORMAL(out, str, errret)                      \
4680 {                                                                       \
4681         if (*str != '"' && strpbrk(str, ",.[]<>")) {                    \
4682                 gchar *__tmp;                                           \
4683                 gint len;                                               \
4684                                                                         \
4685                 len = strlen(str) + 3;                                  \
4686                 if ((__tmp = alloca(len)) == NULL) {                    \
4687                         g_warning("can't allocate memory\n");           \
4688                         errret;                                         \
4689                 }                                                       \
4690                 g_snprintf(__tmp, len, "\"%s\"", str);                  \
4691                 out = __tmp;                                            \
4692         } else {                                                        \
4693                 gchar *__tmp;                                           \
4694                                                                         \
4695                 if ((__tmp = alloca(strlen(str) + 1)) == NULL) {        \
4696                         g_warning("can't allocate memory\n");           \
4697                         errret;                                         \
4698                 } else                                                  \
4699                         strcpy(__tmp, str);                             \
4700                                                                         \
4701                 out = __tmp;                                            \
4702         }                                                               \
4703 }
4704
4705 static void compose_select_account(Compose *compose, PrefsAccount *account,
4706                                    gboolean init)
4707 {
4708         gchar *from = NULL, *header;
4709         ComposeHeaderEntry *header_entry;
4710
4711         cm_return_if_fail(account != NULL);
4712
4713         compose->account = account;
4714         if (account->name && *account->name) {
4715                 gchar *buf;
4716                 QUOTE_IF_REQUIRED_NORMAL(buf, account->name, return);
4717                 from = g_strdup_printf("%s <%s>",
4718                                        buf, account->address);
4719                 gtk_entry_set_text(GTK_ENTRY(compose->from_name), from);
4720         } else {
4721                 from = g_strdup_printf("<%s>",
4722                                        account->address);
4723                 gtk_entry_set_text(GTK_ENTRY(compose->from_name), from);
4724         }
4725
4726         g_free(from);
4727
4728         compose_set_title(compose);
4729
4730         if (account->default_sign && compose->mode != COMPOSE_REDIRECT)
4731                 cm_toggle_menu_set_active_full(compose->ui_manager, "Menu/Options/Sign", TRUE);
4732         else
4733                 cm_toggle_menu_set_active_full(compose->ui_manager, "Menu/Options/Sign", FALSE);
4734         if (account->default_encrypt && compose->mode != COMPOSE_REDIRECT)
4735                 cm_toggle_menu_set_active_full(compose->ui_manager, "Menu/Options/Encrypt", TRUE);
4736         else
4737                 cm_toggle_menu_set_active_full(compose->ui_manager, "Menu/Options/Encrypt", FALSE);
4738
4739         activate_privacy_system(compose, account, FALSE);
4740
4741         if (!init && compose->mode != COMPOSE_REDIRECT) {
4742                 undo_block(compose->undostruct);
4743                 compose_insert_sig(compose, TRUE);
4744                 undo_unblock(compose->undostruct);
4745         }
4746
4747         header_entry = (ComposeHeaderEntry *) compose->header_list->data;
4748         header = gtk_combo_box_get_active_text(GTK_COMBO_BOX(header_entry->combo));
4749
4750         if (header && !strlen(gtk_entry_get_text(GTK_ENTRY(header_entry->entry)))) {
4751                 if (account->protocol == A_NNTP) {
4752                         if (!strcmp(header, _("To:")))
4753                                 combobox_select_by_text(
4754                                         GTK_COMBO_BOX(header_entry->combo),
4755                                         _("Newsgroups:"));
4756                 } else {
4757                         if (!strcmp(header, _("Newsgroups:")))
4758                                 combobox_select_by_text(
4759                                         GTK_COMBO_BOX(header_entry->combo),
4760                                         _("To:"));
4761                 }
4762
4763         }
4764         g_free(header);
4765
4766 #ifdef USE_ENCHANT
4767         /* use account's dict info if set */
4768         if (compose->gtkaspell) {
4769                 if (account->enable_default_dictionary)
4770                         gtkaspell_change_dict(compose->gtkaspell,
4771                                         account->default_dictionary, FALSE);
4772                 if (account->enable_default_alt_dictionary)
4773                         gtkaspell_change_alt_dict(compose->gtkaspell,
4774                                         account->default_alt_dictionary);
4775                 if (account->enable_default_dictionary
4776                         || account->enable_default_alt_dictionary)
4777                         compose_spell_menu_changed(compose);
4778         }
4779 #endif
4780 }
4781
4782 gboolean compose_check_for_valid_recipient(Compose *compose) {
4783         gchar *recipient_headers_mail[] = {"To:", "Cc:", "Bcc:", NULL};
4784         gchar *recipient_headers_news[] = {"Newsgroups:", NULL};
4785         gboolean recipient_found = FALSE;
4786         GSList *list;
4787         gchar **strptr;
4788
4789         /* free to and newsgroup list */
4790         slist_free_strings(compose->to_list);
4791         g_slist_free(compose->to_list);
4792         compose->to_list = NULL;
4793
4794         slist_free_strings(compose->newsgroup_list);
4795         g_slist_free(compose->newsgroup_list);
4796         compose->newsgroup_list = NULL;
4797
4798         /* search header entries for to and newsgroup entries */
4799         for (list = compose->header_list; list; list = list->next) {
4800                 gchar *header;
4801                 gchar *entry;
4802                 header = gtk_editable_get_chars(GTK_EDITABLE(gtk_bin_get_child(GTK_BIN((((ComposeHeaderEntry *)list->data)->combo)))), 0, -1);
4803                 entry = gtk_editable_get_chars(GTK_EDITABLE(((ComposeHeaderEntry *)list->data)->entry), 0, -1);
4804                 g_strstrip(entry);
4805                 g_strstrip(header);
4806                 if (entry[0] != '\0') {
4807                         for (strptr = recipient_headers_mail; *strptr != NULL; strptr++) {
4808                                 if (!g_ascii_strcasecmp(header, prefs_common_translated_header_name(*strptr))) {
4809                                         compose->to_list = address_list_append(compose->to_list, entry);
4810                                         recipient_found = TRUE;
4811                                 }
4812                         }
4813                         for (strptr = recipient_headers_news; *strptr != NULL; strptr++) {
4814                                 if (!g_ascii_strcasecmp(header, prefs_common_translated_header_name(*strptr))) {
4815                                         compose->newsgroup_list = newsgroup_list_append(compose->newsgroup_list, entry);
4816                                         recipient_found = TRUE;
4817                                 }
4818                         }
4819                 }
4820                 g_free(header);
4821                 g_free(entry);
4822         }
4823         return recipient_found;
4824 }
4825
4826 static gboolean compose_check_for_set_recipients(Compose *compose)
4827 {
4828         if (compose->account->set_autocc && compose->account->auto_cc) {
4829                 gboolean found_other = FALSE;
4830                 GSList *list;
4831                 /* search header entries for to and newsgroup entries */
4832                 for (list = compose->header_list; list; list = list->next) {
4833                         gchar *entry;
4834                         gchar *header;
4835                         entry = gtk_editable_get_chars(GTK_EDITABLE(((ComposeHeaderEntry *)list->data)->entry), 0, -1);
4836                         header = gtk_editable_get_chars(GTK_EDITABLE(gtk_bin_get_child(GTK_BIN((((ComposeHeaderEntry *)list->data)->combo)))), 0, -1);
4837                         g_strstrip(entry);
4838                         g_strstrip(header);
4839                         if (strcmp(entry, compose->account->auto_cc)
4840                         ||  strcmp(header, prefs_common_translated_header_name("Cc:"))) {
4841                                 found_other = TRUE;
4842                                 g_free(entry);
4843                                 break;
4844                         }
4845                         g_free(entry);
4846                         g_free(header);
4847                 }
4848                 if (!found_other) {
4849                         AlertValue aval;
4850                         if (compose->batch) {
4851                                 gtk_widget_show_all(compose->window);
4852                         }
4853                         aval = alertpanel(_("Send"),
4854                                           _("The only recipient is the default CC address. Send anyway?"),
4855                                           GTK_STOCK_CANCEL, _("+_Send"), NULL);
4856                         if (aval != G_ALERTALTERNATE)
4857                                 return FALSE;
4858                 }
4859         }
4860         if (compose->account->set_autobcc && compose->account->auto_bcc) {
4861                 gboolean found_other = FALSE;
4862                 GSList *list;
4863                 /* search header entries for to and newsgroup entries */
4864                 for (list = compose->header_list; list; list = list->next) {
4865                         gchar *entry;
4866                         gchar *header;
4867                         entry = gtk_editable_get_chars(GTK_EDITABLE(((ComposeHeaderEntry *)list->data)->entry), 0, -1);
4868                         header = gtk_editable_get_chars(GTK_EDITABLE(gtk_bin_get_child(GTK_BIN((((ComposeHeaderEntry *)list->data)->combo)))), 0, -1);
4869                         g_strstrip(entry);
4870                         g_strstrip(header);
4871                         if (strcmp(entry, compose->account->auto_bcc)
4872                         ||  strcmp(header, prefs_common_translated_header_name("Bcc:"))) {
4873                                 found_other = TRUE;
4874                                 g_free(entry);
4875                                 break;
4876                         }
4877                         g_free(entry);
4878                         g_free(header);
4879                 }
4880                 if (!found_other) {
4881                         AlertValue aval;
4882                         if (compose->batch) {
4883                                 gtk_widget_show_all(compose->window);
4884                         }
4885                         aval = alertpanel(_("Send"),
4886                                           _("The only recipient is the default BCC address. Send anyway?"),
4887                                           GTK_STOCK_CANCEL, _("+_Send"), NULL);
4888                         if (aval != G_ALERTALTERNATE)
4889                                 return FALSE;
4890                 }
4891         }
4892         return TRUE;
4893 }
4894
4895 static gboolean compose_check_entries(Compose *compose, gboolean check_everything)
4896 {
4897         const gchar *str;
4898
4899         if (compose_check_for_valid_recipient(compose) == FALSE) {
4900                 if (compose->batch) {
4901                         gtk_widget_show_all(compose->window);
4902                 }
4903                 alertpanel_error(_("Recipient is not specified."));
4904                 return FALSE;
4905         }
4906
4907         if (compose_check_for_set_recipients(compose) == FALSE) {
4908                 return FALSE;
4909         }
4910
4911         if (!compose->batch) {
4912                 str = gtk_entry_get_text(GTK_ENTRY(compose->subject_entry));
4913                 if (*str == '\0' && check_everything == TRUE &&
4914                     compose->mode != COMPOSE_REDIRECT) {
4915                         AlertValue aval;
4916                         gchar *button_label;
4917                         gchar *message;
4918
4919                         if (compose->sending)
4920                                 button_label = _("+_Send");
4921                         else
4922                                 button_label = _("+_Queue");
4923                         message = g_strdup_printf(_("Subject is empty. %s"),
4924                                         compose->sending?_("Send it anyway?"):
4925                                         _("Queue it anyway?"));
4926
4927                         aval = alertpanel(compose->sending?_("Send"):_("Send later"), message,
4928                                           GTK_STOCK_CANCEL, button_label, NULL);
4929                         g_free(message);
4930                         if (aval != G_ALERTALTERNATE)
4931                                 return FALSE;
4932                 }
4933         }
4934
4935         if (check_everything && hooks_invoke(COMPOSE_CHECK_BEFORE_SEND_HOOKLIST, compose))
4936                 return FALSE;
4937
4938         return TRUE;
4939 }
4940
4941 gint compose_send(Compose *compose)
4942 {
4943         gint msgnum;
4944         FolderItem *folder = NULL;
4945         gint val = -1;
4946         gchar *msgpath = NULL;
4947         gboolean discard_window = FALSE;
4948         gchar *errstr = NULL;
4949         gchar *tmsgid = NULL;
4950         MainWindow *mainwin = mainwindow_get_mainwindow();
4951         gboolean queued_removed = FALSE;
4952
4953         if (prefs_common.send_dialog_invisible
4954                         || compose->batch == TRUE)
4955                 discard_window = TRUE;
4956
4957         compose_allow_user_actions (compose, FALSE);
4958         compose->sending = TRUE;
4959
4960         if (compose_check_entries(compose, TRUE) == FALSE) {
4961                 if (compose->batch) {
4962                         gtk_widget_show_all(compose->window);
4963                 }
4964                 goto bail;
4965         }
4966
4967         inc_lock();
4968         val = compose_queue(compose, &msgnum, &folder, &msgpath, TRUE);
4969
4970         if (val) {
4971                 if (compose->batch) {
4972                         gtk_widget_show_all(compose->window);
4973                 }
4974                 if (val == -4) {
4975                         alertpanel_error(_("Could not queue message for sending:\n\n"
4976                                            "Charset conversion failed."));
4977                 } else if (val == -5) {
4978                         alertpanel_error(_("Could not queue message for sending:\n\n"
4979                                            "Couldn't get recipient encryption key."));
4980                 } else if (val == -6) {
4981                         /* silent error */
4982                 } else if (val == -3) {
4983                         if (privacy_peek_error())
4984                         alertpanel_error(_("Could not queue message for sending:\n\n"
4985                                            "Signature failed: %s"), privacy_get_error());
4986                 } else if (val == -2 && errno != 0) {
4987                         alertpanel_error(_("Could not queue message for sending:\n\n%s."), strerror(errno));
4988                 } else {
4989                         alertpanel_error(_("Could not queue message for sending."));
4990                 }
4991                 goto bail;
4992         }
4993
4994         tmsgid = compose->msgid ? g_strdup(compose->msgid) : NULL;
4995         if (discard_window) {
4996                 compose->sending = FALSE;
4997                 compose_close(compose);
4998                 /* No more compose access in the normal codepath
4999                  * after this point! */
5000                 compose = NULL;
5001         }
5002
5003         if (msgnum == 0) {
5004                 alertpanel_error(_("The message was queued but could not be "
5005                                    "sent.\nUse \"Send queued messages\" from "
5006                                    "the main window to retry."));
5007                 if (!discard_window) {
5008                         goto bail;
5009                 }
5010                 inc_unlock();
5011                 g_free(tmsgid);
5012                 return -1;
5013         }
5014         if (msgpath == NULL) {
5015                 msgpath = folder_item_fetch_msg(folder, msgnum);
5016                 val = procmsg_send_message_queue(msgpath, &errstr, folder, msgnum, &queued_removed);
5017                 g_free(msgpath);
5018         } else {
5019                 val = procmsg_send_message_queue(msgpath, &errstr, folder, msgnum, &queued_removed);
5020                 claws_unlink(msgpath);
5021                 g_free(msgpath);
5022         }
5023         if (!discard_window) {
5024                 if (val != 0) {
5025                         if (!queued_removed)
5026                                 folder_item_remove_msg(folder, msgnum);
5027                         folder_item_scan(folder);
5028                         if (tmsgid) {
5029                                 /* make sure we delete that */
5030                                 MsgInfo *tmp = folder_item_get_msginfo_by_msgid(folder, tmsgid);
5031                                 if (tmp) {
5032                                         debug_print("removing %d via %s\n", tmp->msgnum, tmsgid);
5033                                         folder_item_remove_msg(folder, tmp->msgnum);
5034                                         procmsg_msginfo_free(tmp);
5035                                 }
5036                         }
5037                 }
5038         }
5039
5040         if (val == 0) {
5041                 if (!queued_removed)
5042                         folder_item_remove_msg(folder, msgnum);
5043                 folder_item_scan(folder);
5044                 if (tmsgid) {
5045                         /* make sure we delete that */
5046                         MsgInfo *tmp = folder_item_get_msginfo_by_msgid(folder, tmsgid);
5047                         if (tmp) {
5048                                 debug_print("removing %d via %s\n", tmp->msgnum, tmsgid);
5049                                 folder_item_remove_msg(folder, tmp->msgnum);
5050                                 procmsg_msginfo_free(tmp);
5051                         }
5052                 }
5053                 if (!discard_window) {
5054                         compose->sending = FALSE;
5055                         compose_allow_user_actions (compose, TRUE);
5056                         compose_close(compose);
5057                 }
5058         } else {
5059                 if (errstr) {
5060                         alertpanel_error_log(_("%s\nUse \"Send queued messages\" from "
5061                                    "the main window to retry."), errstr);
5062                         g_free(errstr);
5063                 } else {
5064                         alertpanel_error_log(_("The message was queued but could not be "
5065                                    "sent.\nUse \"Send queued messages\" from "
5066                                    "the main window to retry."));
5067                 }
5068                 if (!discard_window) {
5069                         goto bail;
5070                 }
5071                 inc_unlock();
5072                 g_free(tmsgid);
5073                 return -1;
5074         }
5075         g_free(tmsgid);
5076         inc_unlock();
5077         toolbar_main_set_sensitive(mainwin);
5078         main_window_set_menu_sensitive(mainwin);
5079         return 0;
5080
5081 bail:
5082         inc_unlock();
5083         g_free(tmsgid);
5084         compose_allow_user_actions (compose, TRUE);
5085         compose->sending = FALSE;
5086         compose->modified = TRUE;
5087         toolbar_main_set_sensitive(mainwin);
5088         main_window_set_menu_sensitive(mainwin);
5089
5090         return -1;
5091 }
5092
5093 static gboolean compose_use_attach(Compose *compose)
5094 {
5095         GtkTreeModel *model = gtk_tree_view_get_model
5096                                 (GTK_TREE_VIEW(compose->attach_clist));
5097         return gtk_tree_model_iter_n_children(model, NULL) > 0;
5098 }
5099
5100 static gint compose_redirect_write_headers_from_headerlist(Compose *compose,
5101                                                            FILE *fp)
5102 {
5103         gchar buf[BUFFSIZE];
5104         gchar *str;
5105         gboolean first_to_address;
5106         gboolean first_cc_address;
5107         GSList *list;
5108         ComposeHeaderEntry *headerentry;
5109         const gchar *headerentryname;
5110         const gchar *cc_hdr;
5111         const gchar *to_hdr;
5112         gboolean err = FALSE;
5113
5114         debug_print("Writing redirect header\n");
5115
5116         cc_hdr = prefs_common_translated_header_name("Cc:");
5117         to_hdr = prefs_common_translated_header_name("To:");
5118
5119         first_to_address = TRUE;
5120         for (list = compose->header_list; list; list = list->next) {
5121                 headerentry = ((ComposeHeaderEntry *)list->data);
5122                 headerentryname = gtk_entry_get_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN((headerentry->combo)))));
5123
5124                 if (g_utf8_collate(headerentryname, to_hdr) == 0) {
5125                         const gchar *entstr = gtk_entry_get_text(GTK_ENTRY(headerentry->entry));
5126                         Xstrdup_a(str, entstr, return -1);
5127                         g_strstrip(str);
5128                         if (str[0] != '\0') {
5129                                 compose_convert_header
5130                                         (compose, buf, sizeof(buf), str,
5131                                         strlen("Resent-To") + 2, TRUE);
5132
5133                                 if (first_to_address) {
5134                                         err |= (fprintf(fp, "Resent-To: ") < 0);
5135                                         first_to_address = FALSE;
5136                                 } else {
5137                                         err |= (fprintf(fp, ",") < 0);
5138                                 }
5139                                 err |= (fprintf(fp, "%s", buf) < 0);
5140                         }
5141                 }
5142         }
5143         if (!first_to_address) {
5144                 err |= (fprintf(fp, "\n") < 0);
5145         }
5146
5147         first_cc_address = TRUE;
5148         for (list = compose->header_list; list; list = list->next) {
5149                 headerentry = ((ComposeHeaderEntry *)list->data);
5150                 headerentryname = gtk_entry_get_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN((headerentry->combo)))));
5151
5152                 if (g_utf8_collate(headerentryname, cc_hdr) == 0) {
5153                         const gchar *strg = gtk_entry_get_text(GTK_ENTRY(headerentry->entry));
5154                         Xstrdup_a(str, strg, return -1);
5155                         g_strstrip(str);
5156                         if (str[0] != '\0') {
5157                                 compose_convert_header
5158                                         (compose, buf, sizeof(buf), str,
5159                                         strlen("Resent-Cc") + 2, TRUE);
5160
5161                                 if (first_cc_address) {
5162                                         err |= (fprintf(fp, "Resent-Cc: ") < 0);
5163                                         first_cc_address = FALSE;
5164                                 } else {
5165                                         err |= (fprintf(fp, ",") < 0);
5166                                 }
5167                                 err |= (fprintf(fp, "%s", buf) < 0);
5168                         }
5169                 }
5170         }
5171         if (!first_cc_address) {
5172                 err |= (fprintf(fp, "\n") < 0);
5173         }
5174
5175         return (err ? -1:0);
5176 }
5177
5178 static gint compose_redirect_write_headers(Compose *compose, FILE *fp)
5179 {
5180         gchar buf[BUFFSIZE];
5181         gchar *str;
5182         const gchar *entstr;
5183         /* struct utsname utsbuf; */
5184         gboolean err = FALSE;
5185
5186         cm_return_val_if_fail(fp != NULL, -1);
5187         cm_return_val_if_fail(compose->account != NULL, -1);
5188         cm_return_val_if_fail(compose->account->address != NULL, -1);
5189
5190         /* Resent-Date */
5191         get_rfc822_date(buf, sizeof(buf));
5192         err |= (fprintf(fp, "Resent-Date: %s\n", buf) < 0);
5193
5194         /* Resent-From */
5195         if (compose->account->name && *compose->account->name) {
5196                 compose_convert_header
5197                         (compose, buf, sizeof(buf), compose->account->name,
5198                          strlen("From: "), TRUE);
5199                 err |= (fprintf(fp, "Resent-From: %s <%s>\n",
5200                         buf, compose->account->address) < 0);
5201         } else
5202                 err |= (fprintf(fp, "Resent-From: %s\n", compose->account->address) < 0);
5203
5204         /* Subject */
5205         entstr = gtk_entry_get_text(GTK_ENTRY(compose->subject_entry));
5206         if (*entstr != '\0') {
5207                 Xstrdup_a(str, entstr, return -1);
5208                 g_strstrip(str);
5209                 if (*str != '\0') {
5210                         compose_convert_header(compose, buf, sizeof(buf), str,
5211                                                strlen("Subject: "), FALSE);
5212                         err |= (fprintf(fp, "Subject: %s\n", buf) < 0);
5213                 }
5214         }
5215
5216         /* Resent-Message-ID */
5217         if (compose->account->set_domain && compose->account->domain) {
5218                 g_snprintf(buf, sizeof(buf), "%s", compose->account->domain);
5219         } else if (!strncmp(get_domain_name(), "localhost", strlen("localhost"))) {
5220                 g_snprintf(buf, sizeof(buf), "%s",
5221                         strchr(compose->account->address, '@') ?
5222                                 strchr(compose->account->address, '@')+1 :
5223                                 compose->account->address);
5224         } else {
5225                 g_snprintf(buf, sizeof(buf), "%s", "");
5226         }
5227
5228         if (compose->account->gen_msgid) {
5229                 gchar *addr = NULL;
5230                 if (compose->account->msgid_with_addr) {
5231                         addr = compose->account->address;
5232                 }
5233                 generate_msgid(buf, sizeof(buf), addr);
5234                 err |= (fprintf(fp, "Resent-Message-ID: <%s>\n", buf) < 0);
5235                 compose->msgid = g_strdup(buf);
5236         } else {
5237                 compose->msgid = NULL;
5238         }
5239
5240         if (compose_redirect_write_headers_from_headerlist(compose, fp))
5241                 return -1;
5242
5243         /* separator between header and body */
5244         err |= (fputs("\n", fp) == EOF);
5245
5246         return (err ? -1:0);
5247 }
5248
5249 static gint compose_redirect_write_to_file(Compose *compose, FILE *fdest)
5250 {
5251         FILE *fp;
5252         size_t len;
5253         gchar buf[BUFFSIZE];
5254         int i = 0;
5255         gboolean skip = FALSE;
5256         gboolean err = FALSE;
5257         gchar *not_included[]={
5258                 "Return-Path:",         "Delivered-To:",        "Received:",
5259                 "Subject:",             "X-UIDL:",              "AF:",
5260                 "NF:",                  "PS:",                  "SRH:",
5261                 "SFN:",                 "DSR:",                 "MID:",
5262                 "CFG:",                 "PT:",                  "S:",
5263                 "RQ:",                  "SSV:",                 "NSV:",
5264                 "SSH:",                 "R:",                   "MAID:",
5265                 "NAID:",                "RMID:",                "FMID:",
5266                 "SCF:",                 "RRCPT:",               "NG:",
5267                 "X-Claws-Privacy",      "X-Claws-Sign:",        "X-Claws-Encrypt",
5268                 "X-Claws-End-Special-Headers:",                 "X-Claws-Account-Id:",
5269                 "X-Sylpheed-Privacy",   "X-Sylpheed-Sign:",     "X-Sylpheed-Encrypt",
5270                 "X-Sylpheed-End-Special-Headers:",              "X-Sylpheed-Account-Id:",
5271                 "X-Claws-Auto-Wrapping:", "X-Claws-Auto-Indent:",
5272                 NULL
5273                 };
5274         if ((fp = g_fopen(compose->redirect_filename, "rb")) == NULL) {
5275                 FILE_OP_ERROR(compose->redirect_filename, "fopen");
5276                 return -1;
5277         }
5278
5279         while (procheader_get_one_field_asis(buf, sizeof(buf), fp) != -1) {
5280                 skip = FALSE;
5281                 for (i = 0; not_included[i] != NULL; i++) {
5282                         if (g_ascii_strncasecmp(buf, not_included[i],
5283                                                 strlen(not_included[i])) == 0) {
5284                                 skip = TRUE;
5285                                 break;
5286                         }
5287                 }
5288                 if (skip)
5289                         continue;
5290                 if (fputs(buf, fdest) == -1)
5291                         goto error;
5292
5293                 if (!prefs_common.redirect_keep_from) {
5294                         if (g_ascii_strncasecmp(buf, "From:",
5295                                           strlen("From:")) == 0) {
5296                                 err |= (fputs(" (by way of ", fdest) == EOF);
5297                                 if (compose->account->name
5298                                     && *compose->account->name) {
5299                                         compose_convert_header
5300                                                 (compose, buf, sizeof(buf),
5301                                                  compose->account->name,
5302                                                  strlen("From: "),
5303                                                  FALSE);
5304                                         err |= (fprintf(fdest, "%s <%s>",
5305                                                 buf,
5306                                                 compose->account->address) < 0);
5307                                 } else
5308                                         err |= (fprintf(fdest, "%s",
5309                                                 compose->account->address) < 0);
5310                                 err |= (fputs(")", fdest) == EOF);
5311                         }
5312                 }
5313
5314                 if (fputs("\n", fdest) == -1)
5315                         goto error;
5316         }
5317
5318         if (err)
5319                 goto error;
5320
5321         if (compose_redirect_write_headers(compose, fdest))
5322                 goto error;
5323
5324         while ((len = fread(buf, sizeof(gchar), sizeof(buf), fp)) > 0) {
5325                 if (fwrite(buf, sizeof(gchar), len, fdest) != len)
5326                         goto error;
5327         }
5328
5329         fclose(fp);
5330
5331         return 0;
5332 error:
5333         fclose(fp);
5334
5335         return -1;
5336 }
5337
5338 static gint compose_write_to_file(Compose *compose, FILE *fp, gint action, gboolean attach_parts)
5339 {
5340         GtkTextBuffer *buffer;
5341         GtkTextIter start, end;
5342         gchar *chars;
5343         gchar *buf;
5344         const gchar *out_codeset;
5345         EncodingType encoding = ENC_UNKNOWN;
5346         MimeInfo *mimemsg, *mimetext;
5347         gint line;
5348         const gchar *src_codeset = CS_INTERNAL;
5349         gchar *from_addr = NULL;
5350         gchar *from_name = NULL;
5351
5352         if (action == COMPOSE_WRITE_FOR_SEND)
5353                 attach_parts = TRUE;
5354
5355         /* create message MimeInfo */
5356         mimemsg = procmime_mimeinfo_new();
5357         mimemsg->type = MIMETYPE_MESSAGE;
5358         mimemsg->subtype = g_strdup("rfc822");
5359         mimemsg->content = MIMECONTENT_MEM;
5360         mimemsg->tmp = TRUE; /* must free content later */
5361         mimemsg->data.mem = compose_get_header(compose);
5362
5363         /* Create text part MimeInfo */
5364         /* get all composed text */
5365         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(compose->text));
5366         gtk_text_buffer_get_start_iter(buffer, &start);
5367         gtk_text_buffer_get_end_iter(buffer, &end);
5368         chars = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
5369
5370         out_codeset = conv_get_charset_str(compose->out_encoding);
5371
5372         if (!out_codeset && is_ascii_str(chars)) {
5373                 out_codeset = CS_US_ASCII;
5374         } else if (prefs_common.outgoing_fallback_to_ascii &&
5375                    is_ascii_str(chars)) {
5376                 out_codeset = CS_US_ASCII;
5377                 encoding = ENC_7BIT;
5378         }
5379
5380         if (!out_codeset) {
5381                 gchar *test_conv_global_out = NULL;
5382                 gchar *test_conv_reply = NULL;
5383
5384                 /* automatic mode. be automatic. */
5385                 codeconv_set_strict(TRUE);
5386
5387                 out_codeset = conv_get_outgoing_charset_str();
5388                 if (out_codeset) {
5389                         debug_print("trying to convert to %s\n", out_codeset);
5390                         test_conv_global_out = conv_codeset_strdup(chars, src_codeset, out_codeset);
5391                 }
5392
5393                 if (!test_conv_global_out && compose->orig_charset
5394                 &&  strcmp(compose->orig_charset, CS_US_ASCII)) {
5395                         out_codeset = compose->orig_charset;
5396                         debug_print("failure; trying to convert to %s\n", out_codeset);
5397                         test_conv_reply = conv_codeset_strdup(chars, src_codeset, out_codeset);
5398                 }
5399
5400                 if (!test_conv_global_out && !test_conv_reply) {
5401                         /* we're lost */
5402                         out_codeset = CS_INTERNAL;
5403                         debug_print("failure; finally using %s\n", out_codeset);
5404                 }
5405                 g_free(test_conv_global_out);
5406                 g_free(test_conv_reply);
5407                 codeconv_set_strict(FALSE);
5408         }
5409
5410         if (encoding == ENC_UNKNOWN) {
5411                 if (prefs_common.encoding_method == CTE_BASE64)
5412                         encoding = ENC_BASE64;
5413                 else if (prefs_common.encoding_method == CTE_QUOTED_PRINTABLE)
5414                         encoding = ENC_QUOTED_PRINTABLE;
5415                 else if (prefs_common.encoding_method == CTE_8BIT)
5416                         encoding = ENC_8BIT;
5417                 else
5418                         encoding = procmime_get_encoding_for_charset(out_codeset);
5419         }
5420
5421         debug_print("src encoding = %s, out encoding = %s, transfer encoding = %s\n",
5422                     src_codeset, out_codeset, procmime_get_encoding_str(encoding));
5423
5424         if (action == COMPOSE_WRITE_FOR_SEND) {
5425                 codeconv_set_strict(TRUE);
5426                 buf = conv_codeset_strdup(chars, src_codeset, out_codeset);
5427                 codeconv_set_strict(FALSE);
5428
5429                 if (!buf) {
5430                         AlertValue aval;
5431                         gchar *msg;
5432
5433                         msg = g_strdup_printf(_("Can't convert the character encoding of the message \n"
5434                                                 "to the specified %s charset.\n"
5435                                                 "Send it as %s?"), out_codeset, src_codeset);
5436                         aval = alertpanel_full(_("Error"), msg, GTK_STOCK_CANCEL, _("+_Send"), NULL, FALSE,
5437                                               NULL, ALERT_ERROR, G_ALERTDEFAULT);
5438                         g_free(msg);
5439
5440                         if (aval != G_ALERTALTERNATE) {
5441                                 g_free(chars);
5442                                 return -3;
5443                         } else {
5444                                 buf = chars;
5445                                 out_codeset = src_codeset;
5446                                 chars = NULL;
5447                         }
5448                 }
5449         } else {
5450                 buf = chars;
5451                 out_codeset = src_codeset;
5452                 chars = NULL;
5453         }
5454         g_free(chars);
5455
5456         if (encoding == ENC_8BIT || encoding == ENC_7BIT) {
5457                 if (!strncmp(buf, "From ", sizeof("From ")-1) ||
5458                     strstr(buf, "\nFrom ") != NULL) {
5459                         encoding = ENC_QUOTED_PRINTABLE;
5460                 }
5461         }
5462
5463         mimetext = procmime_mimeinfo_new();
5464         mimetext->content = MIMECONTENT_MEM;
5465         mimetext->tmp = TRUE; /* must free content later */
5466         /* dup'ed because procmime_encode_content can turn it into a tmpfile
5467          * and free the data, which we need later. */
5468         mimetext->data.mem = g_strdup(buf);
5469         mimetext->type = MIMETYPE_TEXT;
5470         mimetext->subtype = g_strdup("plain");
5471         g_hash_table_insert(mimetext->typeparameters, g_strdup("charset"),
5472                             g_strdup(out_codeset));
5473
5474         /* protect trailing spaces when signing message */
5475         if (action == COMPOSE_WRITE_FOR_SEND && compose->use_signing &&
5476             privacy_system_can_sign(compose->privacy_system)) {
5477                 encoding = ENC_QUOTED_PRINTABLE;
5478         }
5479
5480         debug_print("main text: %zd bytes encoded as %s in %d\n",
5481                 strlen(buf), out_codeset, encoding);
5482
5483         /* check for line length limit */
5484         if (action == COMPOSE_WRITE_FOR_SEND &&
5485             encoding != ENC_QUOTED_PRINTABLE && encoding != ENC_BASE64 &&
5486             check_line_length(buf, 1000, &line) < 0) {
5487                 AlertValue aval;
5488                 gchar *msg;
5489
5490                 msg = g_strdup_printf
5491                         (_("Line %d exceeds the line length limit (998 bytes).\n"
5492                            "The contents of the message might be broken on the way to the delivery.\n"
5493                            "\n"
5494                            "Send it anyway?"), line + 1);
5495                 aval = alertpanel(_("Warning"), msg, GTK_STOCK_CANCEL, GTK_STOCK_OK, NULL);
5496                 g_free(msg);
5497                 if (aval != G_ALERTALTERNATE) {
5498                         g_free(buf);
5499                         return -1;
5500                 }
5501         }
5502
5503         if (encoding != ENC_UNKNOWN)
5504                 procmime_encode_content(mimetext, encoding);
5505
5506         /* append attachment parts */
5507         if (compose_use_attach(compose) && attach_parts) {
5508                 MimeInfo *mimempart;
5509                 gchar *boundary = NULL;
5510                 mimempart = procmime_mimeinfo_new();
5511                 mimempart->content = MIMECONTENT_EMPTY;
5512                 mimempart->type = MIMETYPE_MULTIPART;
5513                 mimempart->subtype = g_strdup("mixed");
5514
5515                 do {
5516                         g_free(boundary);
5517                         boundary = generate_mime_boundary(NULL);
5518                 } while (strstr(buf, boundary) != NULL);
5519
5520                 g_hash_table_insert(mimempart->typeparameters, g_strdup("boundary"),
5521                                     boundary);
5522
5523                 mimetext->disposition = DISPOSITIONTYPE_INLINE;
5524
5525                 g_node_append(mimempart->node, mimetext->node);
5526                 g_node_append(mimemsg->node, mimempart->node);
5527
5528                 if (compose_add_attachments(compose, mimempart) < 0)
5529                         return -1;
5530         } else
5531                 g_node_append(mimemsg->node, mimetext->node);
5532
5533         g_free(buf);
5534
5535         if (strlen(gtk_entry_get_text(GTK_ENTRY(compose->from_name))) != 0) {
5536                 gchar *spec = gtk_editable_get_chars(GTK_EDITABLE(compose->from_name), 0, -1);
5537                 /* extract name and address */
5538                 if (strstr(spec, " <") && strstr(spec, ">")) {
5539                         from_addr = g_strdup(strrchr(spec, '<')+1);
5540                         *(strrchr(from_addr, '>')) = '\0';
5541                         from_name = g_strdup(spec);
5542                         *(strrchr(from_name, '<')) = '\0';
5543                 } else {
5544                         from_name = NULL;
5545                         from_addr = NULL;
5546                 }
5547                 g_free(spec);
5548         }
5549         /* sign message if sending */
5550         if (action == COMPOSE_WRITE_FOR_SEND && compose->use_signing &&
5551             privacy_system_can_sign(compose->privacy_system))
5552                 if (!privacy_sign(compose->privacy_system, mimemsg,
5553                         compose->account, from_addr)) {
5554                         g_free(from_name);
5555                         g_free(from_addr);
5556                         return -2;
5557         }
5558         g_free(from_name);
5559         g_free(from_addr);
5560         procmime_write_mimeinfo(mimemsg, fp);
5561
5562         procmime_mimeinfo_free_all(mimemsg);
5563
5564         return 0;
5565 }
5566
5567 static gint compose_write_body_to_file(Compose *compose, const gchar *file)
5568 {
5569         GtkTextBuffer *buffer;
5570         GtkTextIter start, end;
5571         FILE *fp;
5572         size_t len;
5573         gchar *chars, *tmp;
5574
5575         if ((fp = g_fopen(file, "wb")) == NULL) {
5576                 FILE_OP_ERROR(file, "fopen");
5577                 return -1;
5578         }
5579
5580         /* chmod for security */
5581         if (change_file_mode_rw(fp, file) < 0) {
5582                 FILE_OP_ERROR(file, "chmod");
5583                 g_warning("can't change file mode\n");
5584         }
5585
5586         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(compose->text));
5587         gtk_text_buffer_get_start_iter(buffer, &start);
5588         gtk_text_buffer_get_end_iter(buffer, &end);
5589         tmp = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
5590
5591         chars = conv_codeset_strdup
5592                 (tmp, CS_INTERNAL, conv_get_locale_charset_str());
5593
5594         g_free(tmp);
5595         if (!chars) return -1;
5596
5597         /* write body */
5598         len = strlen(chars);
5599         if (fwrite(chars, sizeof(gchar), len, fp) != len) {
5600                 FILE_OP_ERROR(file, "fwrite");
5601                 g_free(chars);
5602                 fclose(fp);
5603                 claws_unlink(file);
5604                 return -1;
5605         }
5606
5607         g_free(chars);
5608
5609         if (fclose(fp) == EOF) {
5610                 FILE_OP_ERROR(file, "fclose");
5611                 claws_unlink(file);
5612                 return -1;
5613         }
5614         return 0;
5615 }
5616
5617 static gint compose_remove_reedit_target(Compose *compose, gboolean force)
5618 {
5619         FolderItem *item;
5620         MsgInfo *msginfo = compose->targetinfo;
5621
5622         cm_return_val_if_fail(compose->mode == COMPOSE_REEDIT, -1);
5623         if (!msginfo) return -1;
5624
5625         if (!force && MSG_IS_LOCKED(msginfo->flags))
5626                 return 0;
5627
5628         item = msginfo->folder;
5629         cm_return_val_if_fail(item != NULL, -1);
5630
5631         if (procmsg_msg_exist(msginfo) &&
5632             (folder_has_parent_of_type(item, F_QUEUE) ||
5633              folder_has_parent_of_type(item, F_DRAFT)
5634              || msginfo == compose->autosaved_draft)) {
5635                 if (folder_item_remove_msg(item, msginfo->msgnum) < 0) {
5636                         g_warning("can't remove the old message\n");
5637                         return -1;
5638                 } else {
5639                         debug_print("removed reedit target %d\n", msginfo->msgnum);
5640                 }
5641         }
5642
5643         return 0;
5644 }
5645
5646 static void compose_remove_draft(Compose *compose)
5647 {
5648         FolderItem *drafts;
5649         MsgInfo *msginfo = compose->targetinfo;
5650         drafts = account_get_special_folder(compose->account, F_DRAFT);
5651
5652         if (procmsg_msg_exist(msginfo)) {
5653                 folder_item_remove_msg(drafts, msginfo->msgnum);
5654         }
5655
5656 }
5657
5658 gint compose_queue(Compose *compose, gint *msgnum, FolderItem **item, gchar **msgpath,
5659                    gboolean remove_reedit_target)
5660 {
5661         return compose_queue_sub (compose, msgnum, item, msgpath, FALSE, remove_reedit_target);
5662 }
5663
5664 static gboolean compose_warn_encryption(Compose *compose)
5665 {
5666         const gchar *warning = privacy_get_encrypt_warning(compose->privacy_system);
5667         AlertValue val = G_ALERTALTERNATE;
5668
5669         if (warning == NULL)
5670                 return TRUE;
5671
5672         val = alertpanel_full(_("Encryption warning"), warning,
5673                   GTK_STOCK_CANCEL, _("+C_ontinue"), NULL,
5674                   TRUE, NULL, ALERT_WARNING, G_ALERTALTERNATE);
5675         if (val & G_ALERTDISABLE) {
5676                 val &= ~G_ALERTDISABLE;
5677                 if (val == G_ALERTALTERNATE)
5678                         privacy_inhibit_encrypt_warning(compose->privacy_system,
5679                                 TRUE);
5680         }
5681
5682         if (val == G_ALERTALTERNATE) {
5683                 return TRUE;
5684         } else {
5685                 return FALSE;
5686         }
5687 }
5688
5689 static gint compose_queue_sub(Compose *compose, gint *msgnum, FolderItem **item,
5690                               gchar **msgpath, gboolean check_subject,
5691                               gboolean remove_reedit_target)
5692 {
5693         FolderItem *queue;
5694         gchar *tmp;
5695         FILE *fp;
5696         GSList *cur;
5697         gint num;
5698         static gboolean lock = FALSE;
5699         PrefsAccount *mailac = NULL, *newsac = NULL;
5700         gboolean err = FALSE;
5701
5702         debug_print("queueing message...\n");
5703         cm_return_val_if_fail(compose->account != NULL, -1);
5704
5705         lock = TRUE;
5706
5707         if (compose_check_entries(compose, check_subject) == FALSE) {
5708                 lock = FALSE;
5709                 if (compose->batch) {
5710                         gtk_widget_show_all(compose->window);
5711                 }
5712                 return -1;
5713         }
5714
5715         if (!compose->to_list && !compose->newsgroup_list) {
5716                 g_warning("can't get recipient list.");
5717                 lock = FALSE;
5718                 return -1;
5719         }
5720
5721         if (compose->to_list) {
5722                 if (compose->account->protocol != A_NNTP)
5723                         mailac = compose->account;
5724                 else if (cur_account && cur_account->protocol != A_NNTP)
5725                         mailac = cur_account;
5726                 else if (!(mailac = compose_current_mail_account())) {
5727                         lock = FALSE;
5728                         alertpanel_error(_("No account for sending mails available!"));
5729                         return -1;
5730                 }
5731         }
5732
5733         if (compose->newsgroup_list) {
5734                 if (compose->account->protocol == A_NNTP)
5735                         newsac = compose->account;
5736                 else {
5737                         lock = FALSE;
5738                         alertpanel_error(_("Selected account isn't NNTP: Posting is impossible."));
5739                         return -1;
5740                 }
5741         }
5742
5743         /* write queue header */
5744         tmp = g_strdup_printf("%s%cqueue.%p%08x", get_tmp_dir(),
5745                               G_DIR_SEPARATOR, compose, (guint) rand());
5746         debug_print("queuing to %s\n", tmp);
5747         if ((fp = g_fopen(tmp, "wb")) == NULL) {
5748                 FILE_OP_ERROR(tmp, "fopen");
5749                 g_free(tmp);
5750                 lock = FALSE;
5751                 return -2;
5752         }
5753
5754         if (change_file_mode_rw(fp, tmp) < 0) {
5755                 FILE_OP_ERROR(tmp, "chmod");
5756                 g_warning("can't change file mode\n");
5757         }
5758
5759         /* queueing variables */
5760         err |= (fprintf(fp, "AF:\n") < 0);
5761         err |= (fprintf(fp, "NF:0\n") < 0);
5762         err |= (fprintf(fp, "PS:10\n") < 0);
5763         err |= (fprintf(fp, "SRH:1\n") < 0);
5764         err |= (fprintf(fp, "SFN:\n") < 0);
5765         err |= (fprintf(fp, "DSR:\n") < 0);
5766         if (compose->msgid)
5767                 err |= (fprintf(fp, "MID:<%s>\n", compose->msgid) < 0);
5768         else
5769                 err |= (fprintf(fp, "MID:\n") < 0);
5770         err |= (fprintf(fp, "CFG:\n") < 0);
5771         err |= (fprintf(fp, "PT:0\n") < 0);
5772         err |= (fprintf(fp, "S:%s\n", compose->account->address) < 0);
5773         err |= (fprintf(fp, "RQ:\n") < 0);
5774         if (mailac)
5775                 err |= (fprintf(fp, "SSV:%s\n", mailac->smtp_server) < 0);
5776         else
5777                 err |= (fprintf(fp, "SSV:\n") < 0);
5778         if (newsac)
5779                 err |= (fprintf(fp, "NSV:%s\n", newsac->nntp_server) < 0);
5780         else
5781                 err |= (fprintf(fp, "NSV:\n") < 0);
5782         err |= (fprintf(fp, "SSH:\n") < 0);
5783         /* write recepient list */
5784         if (compose->to_list) {
5785                 err |= (fprintf(fp, "R:<%s>", (gchar *)compose->to_list->data) < 0);
5786                 for (cur = compose->to_list->next; cur != NULL;
5787                      cur = cur->next)
5788                         err |= (fprintf(fp, ",<%s>", (gchar *)cur->data) < 0);
5789                 err |= (fprintf(fp, "\n") < 0);
5790         }
5791         /* write newsgroup list */
5792         if (compose->newsgroup_list) {
5793                 err |= (fprintf(fp, "NG:") < 0);
5794                 err |= (fprintf(fp, "%s", (gchar *)compose->newsgroup_list->data) < 0);
5795                 for (cur = compose->newsgroup_list->next; cur != NULL; cur = cur->next)
5796                         err |= (fprintf(fp, ",%s", (gchar *)cur->data) < 0);
5797                 err |= (fprintf(fp, "\n") < 0);
5798         }
5799         /* Sylpheed account IDs */
5800         if (mailac)
5801                 err |= (fprintf(fp, "MAID:%d\n", mailac->account_id) < 0);
5802         if (newsac)
5803                 err |= (fprintf(fp, "NAID:%d\n", newsac->account_id) < 0);
5804
5805
5806         if (compose->privacy_system != NULL) {
5807                 err |= (fprintf(fp, "X-Claws-Privacy-System:%s\n", compose->privacy_system) < 0);
5808                 err |= (fprintf(fp, "X-Claws-Sign:%d\n", compose->use_signing) < 0);
5809                 if (compose->use_encryption) {
5810                         gchar *encdata;
5811                         if (!compose_warn_encryption(compose)) {
5812                                 lock = FALSE;
5813                                 fclose(fp);
5814                                 claws_unlink(tmp);
5815                                 g_free(tmp);
5816                                 return -6;
5817                         }
5818                         if (mailac && mailac->encrypt_to_self) {
5819                                 GSList *tmp_list = g_slist_copy(compose->to_list);
5820                                 tmp_list = g_slist_append(tmp_list, compose->account->address);
5821                                 encdata = privacy_get_encrypt_data(compose->privacy_system, tmp_list);
5822                                 g_slist_free(tmp_list);
5823                         } else {
5824                                 encdata = privacy_get_encrypt_data(compose->privacy_system, compose->to_list);
5825                         }
5826                         if (encdata != NULL) {
5827                                 if (strcmp(encdata, "_DONT_ENCRYPT_")) {
5828                                         err |= (fprintf(fp, "X-Claws-Encrypt:%d\n", compose->use_encryption) < 0);
5829                                         err |= (fprintf(fp, "X-Claws-Encrypt-Data:%s\n",
5830                                                 encdata) < 0);
5831                                 } /* else we finally dont want to encrypt */
5832                         } else {
5833                                 err |= (fprintf(fp, "X-Claws-Encrypt:%d\n", compose->use_encryption) < 0);
5834                                 /* and if encdata was null, it means there's been a problem in
5835                                  * key selection */
5836                                 lock = FALSE;
5837                                 fclose(fp);
5838                                 claws_unlink(tmp);
5839                                 g_free(tmp);
5840                                 return -5;
5841                         }
5842                         g_free(encdata);
5843                 }
5844         }
5845
5846         /* Save copy folder */
5847         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(compose->savemsg_checkbtn))) {
5848                 gchar *savefolderid;
5849
5850                 savefolderid = compose_get_save_to(compose);
5851                 err |= (fprintf(fp, "SCF:%s\n", savefolderid) < 0);
5852                 g_free(savefolderid);
5853         }
5854         /* Save copy folder */
5855         if (compose->return_receipt) {
5856                 err |= (fprintf(fp, "RRCPT:1\n") < 0);
5857         }
5858         /* Message-ID of message replying to */
5859         if ((compose->replyinfo != NULL) && (compose->replyinfo->msgid != NULL)) {
5860                 gchar *folderid;
5861
5862                 folderid = folder_item_get_identifier(compose->replyinfo->folder);
5863                 err |= (fprintf(fp, "RMID:%s\t%d\t%s\n", folderid, compose->replyinfo->msgnum, compose->replyinfo->msgid) < 0);
5864                 g_free(folderid);
5865         }
5866         /* Message-ID of message forwarding to */
5867         if ((compose->fwdinfo != NULL) && (compose->fwdinfo->msgid != NULL)) {
5868                 gchar *folderid;
5869
5870                 folderid = folder_item_get_identifier(compose->fwdinfo->folder);
5871                 err |= (fprintf(fp, "FMID:%s\t%d\t%s\n", folderid, compose->fwdinfo->msgnum, compose->fwdinfo->msgid) < 0);
5872                 g_free(folderid);
5873         }
5874
5875         err |= (fprintf(fp, "X-Claws-Auto-Wrapping:%d\n", compose->autowrap) < 0);
5876         err |= (fprintf(fp, "X-Claws-Auto-Indent:%d\n", compose->autoindent) < 0);
5877
5878         /* end of headers */
5879         err |= (fprintf(fp, "X-Claws-End-Special-Headers: 1\n") < 0);
5880
5881         if (compose->redirect_filename != NULL) {
5882                 if (compose_redirect_write_to_file(compose, fp) < 0) {
5883                         lock = FALSE;
5884                         fclose(fp);
5885                         claws_unlink(tmp);
5886                         g_free(tmp);
5887                         return -2;
5888                 }
5889         } else {
5890                 gint result = 0;
5891                 if ((result = compose_write_to_file(compose, fp, COMPOSE_WRITE_FOR_SEND, TRUE)) < 0) {
5892                         lock = FALSE;
5893                         fclose(fp);
5894                         claws_unlink(tmp);
5895                         g_free(tmp);
5896                         return result - 1; /* -2 for a generic error, -3 for signing error, -4 for encoding */
5897                 }
5898         }
5899         if (err == TRUE) {
5900                 g_warning("failed to write queue message\n");
5901                 fclose(fp);
5902                 claws_unlink(tmp);
5903                 g_free(tmp);
5904                 lock = FALSE;
5905                 return -2;
5906         }
5907         if (fclose(fp) == EOF) {
5908                 FILE_OP_ERROR(tmp, "fclose");
5909                 claws_unlink(tmp);
5910                 g_free(tmp);
5911                 lock = FALSE;
5912                 return -2;
5913         }
5914
5915         if (item && *item) {
5916                 queue = *item;
5917         } else {
5918                 queue = account_get_special_folder(compose->account, F_QUEUE);
5919         }
5920         if (!queue) {
5921                 g_warning("can't find queue folder\n");
5922                 claws_unlink(tmp);
5923                 g_free(tmp);
5924                 lock = FALSE;
5925                 return -1;
5926         }
5927         folder_item_scan(queue);
5928         if ((num = folder_item_add_msg(queue, tmp, NULL, FALSE)) < 0) {
5929                 g_warning("can't queue the message\n");
5930                 claws_unlink(tmp);
5931                 g_free(tmp);
5932                 lock = FALSE;
5933                 return -1;
5934         }
5935
5936         if (msgpath == NULL) {
5937                 claws_unlink(tmp);
5938                 g_free(tmp);
5939         } else
5940                 *msgpath = tmp;
5941
5942         if (compose->mode == COMPOSE_REEDIT && remove_reedit_target) {
5943                 compose_remove_reedit_target(compose, FALSE);
5944         }
5945
5946         if ((msgnum != NULL) && (item != NULL)) {
5947                 *msgnum = num;
5948                 *item = queue;
5949         }
5950
5951         return 0;
5952 }
5953
5954 static int compose_add_attachments(Compose *compose, MimeInfo *parent)
5955 {
5956         AttachInfo *ainfo;
5957         GtkTreeView *tree_view = GTK_TREE_VIEW(compose->attach_clist);
5958         MimeInfo *mimepart;
5959         struct stat statbuf;
5960         gchar *type, *subtype;
5961         GtkTreeModel *model;
5962         GtkTreeIter iter;
5963
5964         model = gtk_tree_view_get_model(tree_view);
5965
5966         if (!gtk_tree_model_get_iter_first(model, &iter))
5967                 return 0;
5968         do {
5969                 gtk_tree_model_get(model, &iter,
5970                                    COL_DATA, &ainfo,
5971                                    -1);
5972
5973                 if (!is_file_exist(ainfo->file)) {
5974                         gchar *msg = g_strdup_printf(_("Attachment %s doesn't exist anymore. Ignore?"), ainfo->file);
5975                         AlertValue val = alertpanel_full(_("Warning"), msg, _("Cancel sending"), _("Ignore attachment"),
5976                                       NULL, FALSE, NULL, ALERT_WARNING, G_ALERTDEFAULT);
5977                         g_free(msg);
5978                         if (val == G_ALERTDEFAULT) {
5979                                 return -1;
5980                         }
5981                         continue;
5982                 }
5983                 mimepart = procmime_mimeinfo_new();
5984                 mimepart->content = MIMECONTENT_FILE;
5985                 mimepart->data.filename = g_strdup(ainfo->file);
5986                 mimepart->tmp = FALSE; /* or we destroy our attachment */
5987                 mimepart->offset = 0;
5988
5989                 g_stat(ainfo->file, &statbuf);
5990                 mimepart->length = statbuf.st_size;
5991
5992                 type = g_strdup(ainfo->content_type);
5993
5994                 if (!strchr(type, '/')) {
5995                         g_free(type);
5996                         type = g_strdup("application/octet-stream");
5997                 }
5998
5999                 subtype = strchr(type, '/') + 1;
6000                 *(subtype - 1) = '\0';
6001                 mimepart->type = procmime_get_media_type(type);
6002                 mimepart->subtype = g_strdup(subtype);
6003                 g_free(type);
6004
6005                 if (mimepart->type == MIMETYPE_MESSAGE &&
6006                     !g_ascii_strcasecmp(mimepart->subtype, "rfc822")) {
6007                         mimepart->disposition = DISPOSITIONTYPE_INLINE;
6008                 } else if (mimepart->type == MIMETYPE_TEXT) {
6009                         if (!ainfo->name && compose->mode == COMPOSE_FORWARD_INLINE) {
6010                                 /* Text parts with no name come from multipart/alternative
6011                                 * forwards. Make sure the recipient won't look at the
6012                                 * original HTML part by mistake. */
6013                                 mimepart->disposition = DISPOSITIONTYPE_ATTACHMENT;
6014                                 ainfo->name = g_strdup_printf(_("Original %s part"),
6015                                                                 mimepart->subtype);
6016                         }
6017                         if (ainfo->charset)
6018                                 g_hash_table_insert(mimepart->typeparameters,
6019                                                     g_strdup("charset"), g_strdup(ainfo->charset));
6020                 }
6021                 if (ainfo->name && mimepart->type != MIMETYPE_MESSAGE) {
6022                         if (mimepart->type == MIMETYPE_APPLICATION &&
6023                            !strcmp2(mimepart->subtype, "octet-stream"))
6024                                 g_hash_table_insert(mimepart->typeparameters,
6025                                                 g_strdup("name"), g_strdup(ainfo->name));
6026                         g_hash_table_insert(mimepart->dispositionparameters,
6027                                         g_strdup("filename"), g_strdup(ainfo->name));
6028                         mimepart->disposition = DISPOSITIONTYPE_ATTACHMENT;
6029                 }
6030
6031                 if (mimepart->type == MIMETYPE_MESSAGE
6032                     || mimepart->type == MIMETYPE_MULTIPART)
6033                         ainfo->encoding = ENC_BINARY;
6034                 else if (compose->use_signing) {
6035                         if (ainfo->encoding == ENC_7BIT)
6036                                 ainfo->encoding = ENC_QUOTED_PRINTABLE;
6037                         else if (ainfo->encoding == ENC_8BIT)
6038                                 ainfo->encoding = ENC_BASE64;
6039                 }
6040
6041
6042
6043                 procmime_encode_content(mimepart, ainfo->encoding);
6044
6045                 g_node_append(parent->node, mimepart->node);
6046         } while (gtk_tree_model_iter_next(model, &iter));
6047
6048         return 0;
6049 }
6050
6051 #define IS_IN_CUSTOM_HEADER(header) \
6052         (compose->account->add_customhdr && \
6053          custom_header_find(compose->account->customhdr_list, header) != NULL)
6054
6055 static void compose_add_headerfield_from_headerlist(Compose *compose,
6056                                                     GString *header,
6057                                                     const gchar *fieldname,
6058                                                     const gchar *seperator)
6059 {
6060         gchar *str, *fieldname_w_colon;
6061         gboolean add_field = FALSE;
6062         GSList *list;
6063         ComposeHeaderEntry *headerentry;
6064         const gchar *headerentryname;
6065         const gchar *trans_fieldname;
6066         GString *fieldstr;
6067
6068         if (IS_IN_CUSTOM_HEADER(fieldname))
6069                 return;
6070
6071         debug_print("Adding %s-fields\n", fieldname);
6072
6073         fieldstr = g_string_sized_new(64);
6074
6075         fieldname_w_colon = g_strconcat(fieldname, ":", NULL);
6076         trans_fieldname = prefs_common_translated_header_name(fieldname_w_colon);
6077
6078         for (list = compose->header_list; list; list = list->next) {
6079                 headerentry = ((ComposeHeaderEntry *)list->data);
6080                 headerentryname = gtk_entry_get_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN((headerentry->combo)))));
6081
6082                 if (!g_utf8_collate(trans_fieldname, headerentryname)) {
6083                         str = gtk_editable_get_chars(GTK_EDITABLE(headerentry->entry), 0, -1);
6084                         g_strstrip(str);
6085                         if (str[0] != '\0') {
6086                                 if (add_field)
6087                                         g_string_append(fieldstr, seperator);
6088                                 g_string_append(fieldstr, str);
6089                                 add_field = TRUE;
6090                         }
6091                         g_free(str);
6092                 }
6093         }
6094         if (add_field) {
6095                 gchar *buf;
6096
6097                 buf = g_new0(gchar, fieldstr->len * 4 + 256);
6098                 compose_convert_header
6099                         (compose, buf, fieldstr->len * 4  + 256, fieldstr->str,
6100                         strlen(fieldname) + 2, TRUE);
6101                 g_string_append_printf(header, "%s: %s\n", fieldname, buf);
6102                 g_free(buf);
6103         }
6104
6105         g_free(fieldname_w_colon);
6106         g_string_free(fieldstr, TRUE);
6107
6108         return;
6109 }
6110
6111 static gchar *compose_get_header(Compose *compose)
6112 {
6113         gchar buf[BUFFSIZE];
6114         const gchar *entry_str;
6115         gchar *str;
6116         gchar *name;
6117         GSList *list;
6118         gchar *std_headers[] = {"To:", "Cc:", "Bcc:", "Newsgroups:", "Reply-To:", "Followup-To:", NULL};
6119         GString *header;
6120         gchar *from_name = NULL, *from_address = NULL;
6121         gchar *tmp;
6122
6123         cm_return_val_if_fail(compose->account != NULL, NULL);
6124         cm_return_val_if_fail(compose->account->address != NULL, NULL);
6125
6126         header = g_string_sized_new(64);
6127
6128         /* Date */
6129         get_rfc822_date(buf, sizeof(buf));
6130         g_string_append_printf(header, "Date: %s\n", buf);
6131
6132         /* From */
6133
6134         if (compose->account->name && *compose->account->name) {
6135                 gchar *buf;
6136                 QUOTE_IF_REQUIRED(buf, compose->account->name);
6137                 tmp = g_strdup_printf("%s <%s>",
6138                         buf, compose->account->address);
6139         } else {
6140                 tmp = g_strdup_printf("%s",
6141                         compose->account->address);
6142         }
6143         if (!strcmp(gtk_entry_get_text(GTK_ENTRY(compose->from_name)), tmp)
6144         ||  strlen(gtk_entry_get_text(GTK_ENTRY(compose->from_name))) == 0) {
6145                 /* use default */
6146                 from_name = compose->account->name ? g_strdup(compose->account->name):NULL;
6147                 from_address = g_strdup(compose->account->address);
6148         } else {
6149                 gchar *spec = gtk_editable_get_chars(GTK_EDITABLE(compose->from_name), 0, -1);
6150                 /* extract name and address */
6151                 if (strstr(spec, " <") && strstr(spec, ">")) {
6152                         from_address = g_strdup(strrchr(spec, '<')+1);
6153                         *(strrchr(from_address, '>')) = '\0';
6154                         from_name = g_strdup(spec);
6155                         *(strrchr(from_name, '<')) = '\0';
6156                 } else {
6157                         from_name = NULL;
6158                         from_address = g_strdup(spec);
6159                 }
6160                 g_free(spec);
6161         }
6162         g_free(tmp);
6163
6164
6165         if (from_name && *from_name) {
6166                 compose_convert_header
6167                         (compose, buf, sizeof(buf), from_name,
6168                          strlen("From: "), TRUE);
6169                 QUOTE_IF_REQUIRED(name, buf);
6170
6171                 g_string_append_printf(header, "From: %s <%s>\n",
6172                         name, from_address);
6173         } else
6174                 g_string_append_printf(header, "From: %s\n", from_address);
6175
6176         g_free(from_name);
6177         g_free(from_address);
6178
6179         /* To */
6180         compose_add_headerfield_from_headerlist(compose, header, "To", ", ");
6181
6182         /* Newsgroups */
6183         compose_add_headerfield_from_headerlist(compose, header, "Newsgroups", ",");
6184
6185         /* Cc */
6186         compose_add_headerfield_from_headerlist(compose, header, "Cc", ", ");
6187
6188         /* Bcc */
6189         /*
6190          * If this account is a NNTP account remove Bcc header from
6191          * message body since it otherwise will be publicly shown
6192          */
6193         if (compose->account->protocol != A_NNTP)
6194                 compose_add_headerfield_from_headerlist(compose, header, "Bcc", ", ");
6195
6196         /* Subject */
6197         str = gtk_editable_get_chars(GTK_EDITABLE(compose->subject_entry), 0, -1);
6198
6199         if (*str != '\0' && !IS_IN_CUSTOM_HEADER("Subject")) {
6200                 g_strstrip(str);
6201                 if (*str != '\0') {
6202                         compose_convert_header(compose, buf, sizeof(buf), str,
6203                                                strlen("Subject: "), FALSE);
6204                         g_string_append_printf(header, "Subject: %s\n", buf);
6205                 }
6206         }
6207         g_free(str);
6208
6209         /* Message-ID */
6210         if (compose->account->set_domain && compose->account->domain) {
6211                 g_snprintf(buf, sizeof(buf), "%s", compose->account->domain);
6212         } else if (!strncmp(get_domain_name(), "localhost", strlen("localhost"))) {
6213                 g_snprintf(buf, sizeof(buf), "%s",
6214                         strchr(compose->account->address, '@') ?
6215                                 strchr(compose->account->address, '@')+1 :
6216                                 compose->account->address);
6217         } else {
6218                 g_snprintf(buf, sizeof(buf), "%s", "");
6219         }
6220
6221         if (compose->account->gen_msgid) {
6222                 gchar *addr = NULL;
6223                 if (compose->account->msgid_with_addr) {
6224                         addr = compose->account->address;
6225                 }
6226                 generate_msgid(buf, sizeof(buf), addr);
6227                 g_string_append_printf(header, "Message-ID: <%s>\n", buf);
6228                 compose->msgid = g_strdup(buf);
6229         } else {
6230                 compose->msgid = NULL;
6231         }
6232
6233         if (compose->remove_references == FALSE) {
6234                 /* In-Reply-To */
6235                 if (compose->inreplyto && compose->to_list)
6236                         g_string_append_printf(header, "In-Reply-To: <%s>\n", compose->inreplyto);
6237
6238                 /* References */
6239                 if (compose->references)
6240                         g_string_append_printf(header, "References: %s\n", compose->references);
6241         }
6242
6243         /* Followup-To */
6244         compose_add_headerfield_from_headerlist(compose, header, "Followup-To", ",");
6245
6246         /* Reply-To */
6247         compose_add_headerfield_from_headerlist(compose, header, "Reply-To", ", ");
6248
6249         /* Organization */
6250         if (compose->account->organization &&
6251             strlen(compose->account->organization) &&
6252             !IS_IN_CUSTOM_HEADER("Organization")) {
6253                 compose_convert_header(compose, buf, sizeof(buf),
6254                                        compose->account->organization,
6255                                        strlen("Organization: "), FALSE);
6256                 g_string_append_printf(header, "Organization: %s\n", buf);
6257         }
6258
6259         /* Program version and system info */
6260         if (compose->account->gen_xmailer &&
6261             g_slist_length(compose->to_list) && !IS_IN_CUSTOM_HEADER("X-Mailer") &&
6262             !compose->newsgroup_list) {
6263                 g_string_append_printf(header, "X-Mailer: %s (GTK+ %d.%d.%d; %s)\n",
6264                         prog_version,
6265                         gtk_major_version, gtk_minor_version, gtk_micro_version,
6266                         TARGET_ALIAS);
6267         }
6268         if (g_slist_length(compose->newsgroup_list) && !IS_IN_CUSTOM_HEADER("X-Newsreader")) {
6269                 g_string_append_printf(header, "X-Newsreader: %s (GTK+ %d.%d.%d; %s)\n",
6270                         prog_version,
6271                         gtk_major_version, gtk_minor_version, gtk_micro_version,
6272                         TARGET_ALIAS);
6273         }
6274
6275         /* custom headers */
6276         if (compose->account->add_customhdr) {
6277                 GSList *cur;
6278
6279                 for (cur = compose->account->customhdr_list; cur != NULL;
6280                      cur = cur->next) {
6281                         CustomHeader *chdr = (CustomHeader *)cur->data;
6282
6283                         if (custom_header_is_allowed(chdr->name)
6284                             && chdr->value != NULL
6285                             && *(chdr->value) != '\0') {
6286                                 compose_convert_header
6287                                         (compose, buf, sizeof(buf),
6288                                          chdr->value,
6289                                          strlen(chdr->name) + 2, FALSE);
6290                                 g_string_append_printf(header, "%s: %s\n", chdr->name, buf);
6291                         }
6292                 }
6293         }
6294
6295         /* Automatic Faces and X-Faces */
6296         if (get_account_xface (buf, sizeof(buf), compose->account->account_name) == 0) {
6297                 g_string_append_printf(header, "X-Face: %s\n", buf);
6298         }
6299         else if (get_default_xface (buf, sizeof(buf)) == 0) {
6300                 g_string_append_printf(header, "X-Face: %s\n", buf);
6301         }
6302         if (get_account_face (buf, sizeof(buf), compose->account->account_name) == 0) {
6303                 g_string_append_printf(header, "Face: %s\n", buf);
6304         }
6305         else if (get_default_face (buf, sizeof(buf)) == 0) {
6306                 g_string_append_printf(header, "Face: %s\n", buf);
6307         }
6308
6309         /* PRIORITY */
6310         switch (compose->priority) {
6311                 case PRIORITY_HIGHEST: g_string_append_printf(header, "Importance: high\n"
6312                                                    "X-Priority: 1 (Highest)\n");
6313                         break;
6314                 case PRIORITY_HIGH: g_string_append_printf(header, "Importance: high\n"
6315                                                 "X-Priority: 2 (High)\n");
6316                         break;
6317                 case PRIORITY_NORMAL: break;
6318                 case PRIORITY_LOW: g_string_append_printf(header, "Importance: low\n"
6319                                                "X-Priority: 4 (Low)\n");
6320                         break;
6321                 case PRIORITY_LOWEST: g_string_append_printf(header, "Importance: low\n"
6322                                                   "X-Priority: 5 (Lowest)\n");
6323                         break;
6324                 default: debug_print("compose: priority unknown : %d\n",
6325                                      compose->priority);
6326         }
6327
6328         /* Request Return Receipt */
6329         if (!IS_IN_CUSTOM_HEADER("Disposition-Notification-To")) {
6330                 if (compose->return_receipt) {
6331                         if (compose->account->name
6332                             && *compose->account->name) {
6333                                 compose_convert_header(compose, buf, sizeof(buf),
6334                                                        compose->account->name,
6335                                                        strlen("Disposition-Notification-To: "),
6336                                                        TRUE);
6337                                 g_string_append_printf(header, "Disposition-Notification-To: %s <%s>\n", buf, compose->account->address);
6338                         } else
6339                                 g_string_append_printf(header, "Disposition-Notification-To: %s\n", compose->account->address);
6340                 }
6341         }
6342
6343         /* get special headers */
6344         for (list = compose->header_list; list; list = list->next) {
6345                 ComposeHeaderEntry *headerentry;
6346                 gchar *tmp;
6347                 gchar *headername;
6348                 gchar *headername_wcolon;
6349                 const gchar *headername_trans;
6350                 gchar *headervalue;
6351                 gchar **string;
6352                 gboolean standard_header = FALSE;
6353
6354                 headerentry = ((ComposeHeaderEntry *)list->data);
6355
6356                 tmp = g_strdup(gtk_entry_get_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN((headerentry->combo))))));
6357                 g_strstrip(tmp);
6358                 if (*tmp == '\0' || strchr(tmp, ' ') != NULL || strchr(tmp, '\r') != NULL || strchr(tmp, '\n') != NULL) {
6359                         g_free(tmp);
6360                         continue;
6361                 }
6362
6363                 if (!strstr(tmp, ":")) {
6364                         headername_wcolon = g_strconcat(tmp, ":", NULL);
6365                         headername = g_strdup(tmp);
6366                 } else {
6367                         headername_wcolon = g_strdup(tmp);
6368                         headername = g_strdup(strtok(tmp, ":"));
6369                 }
6370                 g_free(tmp);
6371
6372                 entry_str = gtk_entry_get_text(GTK_ENTRY(headerentry->entry));
6373                 Xstrdup_a(headervalue, entry_str, return NULL);
6374                 subst_char(headervalue, '\r', ' ');
6375                 subst_char(headervalue, '\n', ' ');
6376                 string = std_headers;
6377                 while (*string != NULL) {
6378                         headername_trans = prefs_common_translated_header_name(*string);
6379                         if (!strcmp(headername_trans, headername_wcolon))
6380                                 standard_header = TRUE;
6381                         string++;
6382                 }
6383                 if (!standard_header && !IS_IN_CUSTOM_HEADER(headername))
6384                         g_string_append_printf(header, "%s %s\n", headername_wcolon, headervalue);
6385
6386                 g_free(headername);
6387                 g_free(headername_wcolon);
6388         }
6389
6390         str = header->str;
6391         g_string_free(header, FALSE);
6392
6393         return str;
6394 }
6395
6396 #undef IS_IN_CUSTOM_HEADER
6397
6398 static void compose_convert_header(Compose *compose, gchar *dest, gint len, gchar *src,
6399                                    gint header_len, gboolean addr_field)
6400 {
6401         gchar *tmpstr = NULL;
6402         const gchar *out_codeset = NULL;
6403
6404         cm_return_if_fail(src != NULL);
6405         cm_return_if_fail(dest != NULL);
6406
6407         if (len < 1) return;
6408
6409         tmpstr = g_strdup(src);
6410
6411         subst_char(tmpstr, '\n', ' ');
6412         subst_char(tmpstr, '\r', ' ');
6413         g_strchomp(tmpstr);
6414
6415         if (!g_utf8_validate(tmpstr, -1, NULL)) {
6416                 gchar *mybuf = g_malloc(strlen(tmpstr)*2 +1);
6417                 conv_localetodisp(mybuf, strlen(tmpstr)*2 +1, tmpstr);
6418                 g_free(tmpstr);
6419                 tmpstr = mybuf;
6420         }
6421
6422         codeconv_set_strict(TRUE);
6423         conv_encode_header_full(dest, len, tmpstr, header_len, addr_field,
6424                 conv_get_charset_str(compose->out_encoding));
6425         codeconv_set_strict(FALSE);
6426
6427         if (!dest || *dest == '\0') {
6428                 gchar *test_conv_global_out = NULL;
6429                 gchar *test_conv_reply = NULL;
6430
6431                 /* automatic mode. be automatic. */
6432                 codeconv_set_strict(TRUE);
6433
6434                 out_codeset = conv_get_outgoing_charset_str();
6435                 if (out_codeset) {
6436                         debug_print("trying to convert to %s\n", out_codeset);
6437                         test_conv_global_out = conv_codeset_strdup(src, CS_INTERNAL, out_codeset);
6438                 }
6439
6440                 if (!test_conv_global_out && compose->orig_charset
6441                 &&  strcmp(compose->orig_charset, CS_US_ASCII)) {
6442                         out_codeset = compose->orig_charset;
6443                         debug_print("failure; trying to convert to %s\n", out_codeset);
6444                         test_conv_reply = conv_codeset_strdup(src, CS_INTERNAL, out_codeset);
6445                 }
6446
6447                 if (!test_conv_global_out && !test_conv_reply) {
6448                         /* we're lost */
6449                         out_codeset = CS_INTERNAL;
6450                         debug_print("finally using %s\n", out_codeset);
6451                 }
6452                 g_free(test_conv_global_out);
6453                 g_free(test_conv_reply);
6454                 conv_encode_header_full(dest, len, tmpstr, header_len, addr_field,
6455                                         out_codeset);
6456                 codeconv_set_strict(FALSE);
6457         }
6458         g_free(tmpstr);
6459 }
6460
6461 static void compose_add_to_addressbook_cb(GtkMenuItem *menuitem, gpointer user_data)
6462 {
6463         gchar *address;
6464
6465         cm_return_if_fail(user_data != NULL);
6466
6467         address = g_strdup(gtk_entry_get_text(GTK_ENTRY(user_data)));
6468         g_strstrip(address);
6469         if (*address != '\0') {
6470                 gchar *name = procheader_get_fromname(address);
6471                 extract_address(address);
6472                 addressbook_add_contact(name, address, NULL, NULL);
6473         }
6474         g_free(address);
6475 }
6476
6477 static void compose_entry_popup_extend(GtkEntry *entry, GtkMenu *menu, gpointer user_data)
6478 {
6479         GtkWidget *menuitem;
6480         gchar *address;
6481
6482         cm_return_if_fail(menu != NULL);
6483         cm_return_if_fail(GTK_IS_MENU_SHELL(menu));
6484
6485         menuitem = gtk_separator_menu_item_new();
6486         gtk_menu_shell_prepend(GTK_MENU_SHELL(menu), menuitem);
6487         gtk_widget_show(menuitem);
6488
6489         menuitem = gtk_menu_item_new_with_mnemonic(_("Add to address _book"));
6490         gtk_menu_shell_prepend(GTK_MENU_SHELL(menu), menuitem);
6491
6492         address = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry)));
6493         g_strstrip(address);
6494         if (*address == '\0') {
6495                 gtk_widget_set_sensitive(GTK_WIDGET(menuitem), FALSE);
6496         }
6497
6498         g_signal_connect(G_OBJECT(menuitem), "activate",
6499                          G_CALLBACK(compose_add_to_addressbook_cb), entry);
6500         gtk_widget_show(menuitem);
6501 }
6502
6503 static void compose_create_header_entry(Compose *compose)
6504 {
6505         gchar *headers[] = {"To:", "Cc:", "Bcc:", "Newsgroups:", "Reply-To:", "Followup-To:", NULL};
6506
6507         GtkWidget *combo;
6508         GtkWidget *entry;
6509         GtkWidget *button;
6510         GtkWidget *hbox;
6511         gchar **string;
6512         const gchar *header = NULL;
6513         ComposeHeaderEntry *headerentry;
6514         gboolean standard_header = FALSE;
6515         GtkListStore *model;
6516         GtkTreeIter iter;
6517 #if !(GTK_CHECK_VERSION(2,12,0))
6518         GtkTooltips *tips = compose->tooltips;
6519 #endif
6520
6521         headerentry = g_new0(ComposeHeaderEntry, 1);
6522
6523         /* Combo box */
6524         model = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_INT, G_TYPE_BOOLEAN);
6525         combo = gtk_combo_box_entry_new_with_model(GTK_TREE_MODEL(model), 0);
6526         COMBOBOX_ADD(model, prefs_common_translated_header_name("To:"),
6527                         COMPOSE_TO);
6528         COMBOBOX_ADD(model, prefs_common_translated_header_name("Cc:"),
6529                         COMPOSE_CC);
6530         COMBOBOX_ADD(model, prefs_common_translated_header_name("Bcc:"),
6531                         COMPOSE_BCC);
6532         COMBOBOX_ADD(model, prefs_common_translated_header_name("Newsgroups:"),
6533                         COMPOSE_NEWSGROUPS);
6534         COMBOBOX_ADD(model, prefs_common_translated_header_name("Reply-To:"),
6535                         COMPOSE_REPLYTO);
6536         COMBOBOX_ADD(model, prefs_common_translated_header_name("Followup-To:"),
6537                         COMPOSE_FOLLOWUPTO);
6538
6539         gtk_combo_box_set_active(GTK_COMBO_BOX(combo), 0);
6540         g_signal_connect(G_OBJECT(gtk_bin_get_child(GTK_BIN((combo)))), "grab_focus",
6541                          G_CALLBACK(compose_grab_focus_cb), compose);
6542         gtk_widget_show(combo);
6543         gtk_table_attach(GTK_TABLE(compose->header_table), combo, 0, 1,
6544                         compose->header_nextrow, compose->header_nextrow+1,
6545                         GTK_SHRINK, GTK_FILL, 0, 0);
6546         if (compose->header_last && (compose->draft_timeout_tag != -2)) {
6547                 const gchar *last_header_entry = gtk_entry_get_text(
6548                                 GTK_ENTRY(gtk_bin_get_child(GTK_BIN((compose->header_last->combo)))));
6549                 string = headers;
6550                 while (*string != NULL) {
6551                         if (!strcmp(prefs_common_translated_header_name(*string), last_header_entry))
6552                                 standard_header = TRUE;
6553                         string++;
6554                 }
6555                 if (standard_header)
6556                         header = gtk_entry_get_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN((compose->header_last->combo)))));
6557         }
6558         if (!compose->header_last || !standard_header) {
6559                 switch(compose->account->protocol) {
6560                         case A_NNTP:
6561                                 header = prefs_common_translated_header_name("Newsgroups:");
6562                                 break;
6563                         default:
6564                                 header = prefs_common_translated_header_name("To:");
6565                                 break;
6566                 }
6567         }
6568         if (header)
6569                 gtk_entry_set_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN((combo)))), header);
6570
6571         g_signal_connect_after(G_OBJECT(gtk_bin_get_child(GTK_BIN((combo)))), "grab_focus",
6572                          G_CALLBACK(compose_grab_focus_cb), compose);
6573
6574         /* Entry field with cleanup button */
6575         button = gtk_button_new();
6576         gtk_button_set_image(GTK_BUTTON(button),
6577                         gtk_image_new_from_stock(GTK_STOCK_CLEAR, GTK_ICON_SIZE_MENU));
6578         gtk_widget_show(button);
6579         CLAWS_SET_TIP(button,
6580                 _("Delete entry contents"));
6581         entry = gtk_entry_new();
6582         gtk_widget_show(entry);
6583         CLAWS_SET_TIP(entry,
6584                 _("Use <tab> to autocomplete from addressbook"));
6585         hbox = gtk_hbox_new (FALSE, 0);
6586         gtk_widget_show(hbox);
6587         gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
6588         gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
6589         gtk_table_attach(GTK_TABLE(compose->header_table), hbox, 1, 2,
6590                         compose->header_nextrow, compose->header_nextrow+1,
6591                         GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
6592
6593         g_signal_connect(G_OBJECT(entry), "key-press-event",
6594                          G_CALLBACK(compose_headerentry_key_press_event_cb),
6595                          headerentry);
6596         g_signal_connect(G_OBJECT(entry), "changed",
6597                          G_CALLBACK(compose_headerentry_changed_cb),
6598                          headerentry);
6599         g_signal_connect_after(G_OBJECT(entry), "grab_focus",
6600                          G_CALLBACK(compose_grab_focus_cb), compose);
6601
6602         g_signal_connect(G_OBJECT(button), "clicked",
6603                          G_CALLBACK(compose_headerentry_button_clicked_cb),
6604                          headerentry);
6605
6606         /* email dnd */
6607         gtk_drag_dest_set(entry, GTK_DEST_DEFAULT_ALL, compose_mime_types,
6608                           sizeof(compose_mime_types)/sizeof(compose_mime_types[0]),
6609                           GDK_ACTION_COPY | GDK_ACTION_MOVE);
6610         g_signal_connect(G_OBJECT(entry), "drag_data_received",
6611                          G_CALLBACK(compose_header_drag_received_cb),
6612                          entry);
6613         g_signal_connect(G_OBJECT(entry), "drag-drop",
6614                          G_CALLBACK(compose_drag_drop),
6615                          compose);
6616         g_signal_connect(G_OBJECT(entry), "populate-popup",
6617                          G_CALLBACK(compose_entry_popup_extend),
6618                          NULL);
6619
6620         address_completion_register_entry(GTK_ENTRY(entry), TRUE);
6621
6622         headerentry->compose = compose;
6623         headerentry->combo = combo;
6624         headerentry->entry = entry;
6625         headerentry->button = button;
6626         headerentry->hbox = hbox;
6627         headerentry->headernum = compose->header_nextrow;
6628         headerentry->type = PREF_NONE;
6629
6630         compose->header_nextrow++;
6631         compose->header_last = headerentry;
6632         compose->header_list =
6633                 g_slist_append(compose->header_list,
6634                                headerentry);
6635 }
6636
6637 static void compose_add_header_entry(Compose *compose, const gchar *header,
6638                                 gchar *text, ComposePrefType pref_type)
6639 {
6640         ComposeHeaderEntry *last_header = compose->header_last;
6641         gchar *tmp = g_strdup(text), *email;
6642         gboolean replyto_hdr;
6643
6644         replyto_hdr = (!strcasecmp(header,
6645                                 prefs_common_translated_header_name("Reply-To:")) ||
6646                         !strcasecmp(header,
6647                                 prefs_common_translated_header_name("Followup-To:")) ||
6648                         !strcasecmp(header,
6649                                 prefs_common_translated_header_name("In-Reply-To:")));
6650
6651         extract_address(tmp);
6652         email = g_utf8_strdown(tmp, -1);
6653
6654         if (replyto_hdr == FALSE &&
6655             g_hash_table_lookup(compose->email_hashtable, email) != NULL)
6656         {
6657                 debug_print("Ignoring duplicate address - %s %s, pref_type: %d\n",
6658                                 header, text, (gint) pref_type);
6659                 g_free(email);
6660                 g_free(tmp);
6661                 return;
6662         }
6663
6664         if (!strcasecmp(header, prefs_common_translated_header_name("In-Reply-To:")))
6665                 gtk_entry_set_text(GTK_ENTRY(
6666                         gtk_bin_get_child(GTK_BIN(last_header->combo))), header);
6667         else
6668                 combobox_select_by_text(GTK_COMBO_BOX(last_header->combo), header);
6669         gtk_entry_set_text(GTK_ENTRY(last_header->entry), text);
6670         last_header->type = pref_type;
6671
6672         if (replyto_hdr == FALSE)
6673                 g_hash_table_insert(compose->email_hashtable, email,
6674                                     GUINT_TO_POINTER(1));
6675         else
6676                 g_free(email);
6677
6678         g_free(tmp);
6679 }
6680
6681 static void compose_destroy_headerentry(Compose *compose,
6682                                         ComposeHeaderEntry *headerentry)
6683 {
6684         gchar *text = gtk_editable_get_chars(GTK_EDITABLE(headerentry->entry), 0, -1);
6685         gchar *email;
6686
6687         extract_address(text);
6688         email = g_utf8_strdown(text, -1);
6689         g_hash_table_remove(compose->email_hashtable, email);
6690         g_free(text);
6691         g_free(email);
6692
6693         gtk_widget_destroy(headerentry->combo);
6694         gtk_widget_destroy(headerentry->entry);
6695         gtk_widget_destroy(headerentry->button);
6696         gtk_widget_destroy(headerentry->hbox);
6697         g_free(headerentry);
6698 }
6699
6700 static void compose_remove_header_entries(Compose *compose)
6701 {
6702         GSList *list;
6703         for (list = compose->header_list; list; list = list->next)
6704                 compose_destroy_headerentry(compose, (ComposeHeaderEntry *)list->data);
6705
6706         compose->header_last = NULL;
6707         g_slist_free(compose->header_list);
6708         compose->header_list = NULL;
6709         compose->header_nextrow = 1;
6710         compose_create_header_entry(compose);
6711 }
6712
6713 static GtkWidget *compose_create_header(Compose *compose)
6714 {
6715         GtkWidget *from_optmenu_hbox;
6716         GtkWidget *header_scrolledwin;
6717         GtkWidget *header_table;
6718
6719         gint count = 0;
6720
6721         /* header labels and entries */
6722         header_scrolledwin = gtk_scrolled_window_new(NULL, NULL);
6723         gtk_widget_show(header_scrolledwin);
6724         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(header_scrolledwin), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
6725
6726         header_table = gtk_table_new(2, 2, FALSE);
6727         gtk_widget_show(header_table);
6728         gtk_container_set_border_width(GTK_CONTAINER(header_table), BORDER_WIDTH);
6729         gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(header_scrolledwin), header_table);
6730         gtk_viewport_set_shadow_type(GTK_VIEWPORT(gtk_bin_get_child(GTK_BIN((header_scrolledwin)))), GTK_SHADOW_NONE);
6731         count = 0;
6732
6733         /* option menu for selecting accounts */
6734         from_optmenu_hbox = compose_account_option_menu_create(compose);
6735         gtk_table_attach(GTK_TABLE(header_table), from_optmenu_hbox,
6736                                   0, 2, count, count + 1, GTK_EXPAND | GTK_FILL, GTK_SHRINK, 0, 0);
6737         count++;
6738
6739         compose->header_table = header_table;
6740         compose->header_list = NULL;
6741         compose->header_nextrow = count;
6742
6743         compose_create_header_entry(compose);
6744
6745         compose->table            = NULL;
6746
6747         return header_scrolledwin ;
6748 }
6749
6750 static gboolean popup_attach_button_pressed(GtkWidget *widget, gpointer data)
6751 {
6752         Compose *compose = (Compose *)data;
6753         GdkEventButton event;
6754
6755         event.button = 3;
6756         event.time = gtk_get_current_event_time();
6757
6758         return attach_button_pressed(compose->attach_clist, &event, compose);
6759 }
6760
6761 static GtkWidget *compose_create_attach(Compose *compose)
6762 {
6763         GtkWidget *attach_scrwin;
6764         GtkWidget *attach_clist;
6765
6766         GtkListStore *store;
6767         GtkCellRenderer *renderer;
6768         GtkTreeViewColumn *column;
6769         GtkTreeSelection *selection;
6770
6771         /* attachment list */
6772         attach_scrwin = gtk_scrolled_window_new(NULL, NULL);
6773         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(attach_scrwin),
6774                                        GTK_POLICY_AUTOMATIC,
6775                                        GTK_POLICY_AUTOMATIC);
6776         gtk_widget_set_size_request(attach_scrwin, -1, 80);
6777
6778         store = gtk_list_store_new(N_ATTACH_COLS,
6779                                    G_TYPE_STRING,
6780                                    G_TYPE_STRING,
6781                                    G_TYPE_STRING,
6782                                    G_TYPE_STRING,
6783                                    G_TYPE_POINTER,
6784                                    G_TYPE_AUTO_POINTER,
6785                                    -1);
6786         attach_clist = GTK_WIDGET(gtk_tree_view_new_with_model
6787                                         (GTK_TREE_MODEL(store)));
6788         gtk_container_add(GTK_CONTAINER(attach_scrwin), attach_clist);
6789         g_object_unref(store);
6790
6791         renderer = gtk_cell_renderer_text_new();
6792         column = gtk_tree_view_column_new_with_attributes
6793                         (_("Mime type"), renderer, "text",
6794                          COL_MIMETYPE, NULL);
6795         gtk_tree_view_append_column(GTK_TREE_VIEW(attach_clist), column);
6796
6797         renderer = gtk_cell_renderer_text_new();
6798         column = gtk_tree_view_column_new_with_attributes
6799                         (_("Size"), renderer, "text",
6800                          COL_SIZE, NULL);
6801         gtk_tree_view_append_column(GTK_TREE_VIEW(attach_clist), column);
6802
6803         renderer = gtk_cell_renderer_text_new();
6804         column = gtk_tree_view_column_new_with_attributes
6805                         (_("Name"), renderer, "text",
6806                          COL_NAME, NULL);
6807         gtk_tree_view_append_column(GTK_TREE_VIEW(attach_clist), column);
6808
6809         gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(attach_clist),
6810                                      prefs_common.use_stripes_everywhere);
6811         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(attach_clist));
6812         gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
6813
6814         g_signal_connect(G_OBJECT(attach_clist), "row_activated",
6815                          G_CALLBACK(attach_selected), compose);
6816         g_signal_connect(G_OBJECT(attach_clist), "button_press_event",
6817                          G_CALLBACK(attach_button_pressed), compose);
6818 #ifndef MAEMO
6819         g_signal_connect(G_OBJECT(attach_clist), "popup-menu",
6820                          G_CALLBACK(popup_attach_button_pressed), compose);
6821 #else
6822         gtk_widget_tap_and_hold_setup(GTK_WIDGET(attach_clist), NULL, NULL,
6823                         GTK_TAP_AND_HOLD_NONE | GTK_TAP_AND_HOLD_NO_INTERNALS);
6824         g_signal_connect(G_OBJECT(attach_clist), "tap-and-hold",
6825                          G_CALLBACK(popup_attach_button_pressed), compose);
6826 #endif
6827         g_signal_connect(G_OBJECT(attach_clist), "key_press_event",
6828                          G_CALLBACK(attach_key_pressed), compose);
6829
6830         /* drag and drop */
6831         gtk_drag_dest_set(attach_clist,
6832                           GTK_DEST_DEFAULT_ALL, compose_mime_types,
6833                           sizeof(compose_mime_types)/sizeof(compose_mime_types[0]),
6834                           GDK_ACTION_COPY | GDK_ACTION_MOVE);
6835         g_signal_connect(G_OBJECT(attach_clist), "drag_data_received",
6836                          G_CALLBACK(compose_attach_drag_received_cb),
6837                          compose);
6838         g_signal_connect(G_OBJECT(attach_clist), "drag-drop",
6839                          G_CALLBACK(compose_drag_drop),
6840                          compose);
6841
6842         compose->attach_scrwin = attach_scrwin;
6843         compose->attach_clist  = attach_clist;
6844
6845         return attach_scrwin;
6846 }
6847
6848 static void compose_savemsg_checkbtn_cb(GtkWidget *widget, Compose *compose);
6849 static void compose_savemsg_select_cb(GtkWidget *widget, Compose *compose);
6850
6851 static GtkWidget *compose_create_others(Compose *compose)
6852 {
6853         GtkWidget *table;
6854         GtkWidget *savemsg_checkbtn;
6855         GtkWidget *savemsg_combo;
6856         GtkWidget *savemsg_select;
6857
6858         guint rowcount = 0;
6859         gchar *folderidentifier;
6860
6861         /* Table for settings */
6862         table = gtk_table_new(3, 1, FALSE);
6863         gtk_container_set_border_width(GTK_CONTAINER(table), BORDER_WIDTH);
6864         gtk_widget_show(table);
6865         gtk_table_set_row_spacings(GTK_TABLE(table), VSPACING_NARROW);
6866         rowcount = 0;
6867
6868         /* Save Message to folder */
6869         savemsg_checkbtn = gtk_check_button_new_with_label(_("Save Message to "));
6870         gtk_widget_show(savemsg_checkbtn);
6871         gtk_table_attach(GTK_TABLE(table), savemsg_checkbtn, 0, 1, rowcount, rowcount + 1, GTK_SHRINK | GTK_FILL, GTK_SHRINK, 0, 0);
6872         if (account_get_special_folder(compose->account, F_OUTBOX)) {
6873                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(savemsg_checkbtn), prefs_common.savemsg);
6874         }
6875         g_signal_connect(G_OBJECT(savemsg_checkbtn), "toggled",
6876                          G_CALLBACK(compose_savemsg_checkbtn_cb), compose);
6877
6878         savemsg_combo = gtk_combo_box_entry_new_text();
6879         compose->savemsg_checkbtn = savemsg_checkbtn;
6880         compose->savemsg_combo = savemsg_combo;
6881         gtk_widget_show(savemsg_combo);
6882
6883         if (prefs_common.compose_save_to_history)
6884                 combobox_set_popdown_strings(GTK_COMBO_BOX(savemsg_combo),
6885                                 prefs_common.compose_save_to_history);
6886
6887         gtk_table_attach(GTK_TABLE(table), savemsg_combo, 1, 2, rowcount, rowcount + 1, GTK_FILL|GTK_EXPAND, GTK_SHRINK, 0, 0);
6888         gtk_widget_set_sensitive(GTK_WIDGET(savemsg_combo), prefs_common.savemsg);
6889         g_signal_connect_after(G_OBJECT(savemsg_combo), "grab_focus",
6890                          G_CALLBACK(compose_grab_focus_cb), compose);
6891         if (account_get_special_folder(compose->account, F_OUTBOX)) {
6892                 folderidentifier = folder_item_get_identifier(account_get_special_folder
6893                                   (compose->account, F_OUTBOX));
6894                 compose_set_save_to(compose, folderidentifier);
6895                 g_free(folderidentifier);
6896         }
6897
6898         savemsg_select = gtkut_get_browse_file_btn(_("_Browse"));
6899         gtk_widget_show(savemsg_select);
6900         gtk_table_attach(GTK_TABLE(table), savemsg_select, 2, 3, rowcount, rowcount + 1, GTK_SHRINK | GTK_FILL, GTK_SHRINK, 0, 0);
6901         g_signal_connect(G_OBJECT(savemsg_select), "clicked",
6902                          G_CALLBACK(compose_savemsg_select_cb),
6903                          compose);
6904
6905         rowcount++;
6906
6907         return table;
6908 }
6909
6910 static void compose_savemsg_checkbtn_cb(GtkWidget *widget, Compose *compose)
6911 {
6912         gtk_widget_set_sensitive(GTK_WIDGET(compose->savemsg_combo),
6913                 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(compose->savemsg_checkbtn)));
6914 }
6915
6916 static void compose_savemsg_select_cb(GtkWidget *widget, Compose *compose)
6917 {
6918         FolderItem *dest;
6919         gchar * path;
6920
6921         dest = foldersel_folder_sel(NULL, FOLDER_SEL_COPY, NULL, FALSE);
6922         if (!dest) return;
6923
6924         path = folder_item_get_identifier(dest);
6925
6926         compose_set_save_to(compose, path);
6927         g_free(path);
6928 }
6929
6930 static void entry_paste_clipboard(Compose *compose, GtkWidget *entry, gboolean wrap,
6931                                   GdkAtom clip, GtkTextIter *insert_place);
6932
6933
6934 static gboolean text_clicked(GtkWidget *text, GdkEventButton *event,
6935                                        Compose *compose)
6936 {
6937         gint prev_autowrap;
6938         GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
6939 #if USE_ENCHANT
6940         if (event->button == 3) {
6941                 GtkTextIter iter;
6942                 GtkTextIter sel_start, sel_end;
6943                 gboolean stuff_selected;
6944                 gint x, y;
6945                 /* move the cursor to allow GtkAspell to check the word
6946                  * under the mouse */
6947                 if (event->x && event->y) {
6948                         gtk_text_view_window_to_buffer_coords(GTK_TEXT_VIEW(text),
6949                                 GTK_TEXT_WINDOW_TEXT, event->x, event->y,
6950                                 &x, &y);
6951                         gtk_text_view_get_iter_at_location (GTK_TEXT_VIEW(text),
6952                                 &iter, x, y);
6953                 } else {
6954                         GtkTextMark *mark = gtk_text_buffer_get_insert(buffer);
6955                         gtk_text_buffer_get_iter_at_mark(buffer, &iter, mark);
6956                 }
6957                 /* get selection */
6958                 stuff_selected = gtk_text_buffer_get_selection_bounds(
6959                                 buffer,
6960                                 &sel_start, &sel_end);
6961
6962                 gtk_text_buffer_place_cursor (buffer, &iter);
6963                 /* reselect stuff */
6964                 if (stuff_selected
6965                 && gtk_text_iter_in_range(&iter, &sel_start, &sel_end)) {
6966                         gtk_text_buffer_select_range(buffer,
6967                                 &sel_start, &sel_end);
6968                 }
6969                 return FALSE; /* pass the event so that the right-click goes through */
6970         }
6971 #endif
6972         if (event->button == 2) {
6973                 GtkTextIter iter;
6974                 gint x, y;
6975                 BLOCK_WRAP();
6976
6977                 /* get the middle-click position to paste at the correct place */
6978                 gtk_text_view_window_to_buffer_coords(GTK_TEXT_VIEW(text),
6979                         GTK_TEXT_WINDOW_TEXT, event->x, event->y,
6980                         &x, &y);
6981                 gtk_text_view_get_iter_at_location (GTK_TEXT_VIEW(text),
6982                         &iter, x, y);
6983
6984                 entry_paste_clipboard(compose, text,
6985                                 prefs_common.linewrap_pastes,
6986                                 GDK_SELECTION_PRIMARY, &iter);
6987                 UNBLOCK_WRAP();
6988                 return TRUE;
6989         }
6990         return FALSE;
6991 }
6992
6993 #if USE_ENCHANT
6994 static void compose_spell_menu_changed(void *data)
6995 {
6996         Compose *compose = (Compose *)data;
6997         GSList *items;
6998         GtkWidget *menuitem;
6999         GtkWidget *parent_item;
7000         GtkMenu *menu = GTK_MENU(gtk_menu_new());
7001         GSList *spell_menu;
7002
7003         if (compose->gtkaspell == NULL)
7004                 return;
7005
7006         parent_item = gtk_ui_manager_get_widget(compose->ui_manager,
7007                         "/Menu/Spelling/Options");
7008
7009         /* setting the submenu removes /Spelling/Options from the factory
7010          * so we need to save it */
7011
7012         if (parent_item == NULL) {
7013                 parent_item = compose->aspell_options_menu;
7014                 gtk_menu_item_set_submenu(GTK_MENU_ITEM(parent_item), NULL);
7015         } else
7016                 compose->aspell_options_menu = parent_item;
7017
7018         spell_menu = gtkaspell_make_config_menu(compose->gtkaspell);
7019
7020         spell_menu = g_slist_reverse(spell_menu);
7021         for (items = spell_menu;
7022              items; items = items->next) {
7023                 menuitem = GTK_WIDGET(GTK_MENU_ITEM(items->data));
7024                 gtk_menu_shell_prepend(GTK_MENU_SHELL(menu), GTK_WIDGET(menuitem));
7025                 gtk_widget_show(GTK_WIDGET(menuitem));
7026         }
7027         g_slist_free(spell_menu);
7028
7029         gtk_menu_item_set_submenu(GTK_MENU_ITEM(parent_item), GTK_WIDGET(menu));
7030         gtk_widget_show(parent_item);
7031 }
7032
7033 static void compose_dict_changed(void *data)
7034 {
7035         Compose *compose = (Compose *) data;
7036
7037         if(compose->gtkaspell &&
7038            compose->gtkaspell->recheck_when_changing_dict == FALSE)
7039                 return;
7040
7041         gtkaspell_highlight_all(compose->gtkaspell);
7042         claws_spell_entry_recheck_all(CLAWS_SPELL_ENTRY(compose->subject_entry));
7043 }
7044 #endif
7045
7046 static gboolean compose_popup_menu(GtkWidget *widget, gpointer data)
7047 {
7048         Compose *compose = (Compose *)data;
7049         GdkEventButton event;
7050
7051         event.button = 3;
7052         event.time = gtk_get_current_event_time();
7053         event.x = 0;
7054         event.y = 0;
7055
7056         return text_clicked(compose->text, &event, compose);
7057 }
7058
7059 static gboolean compose_force_window_origin = TRUE;
7060 static Compose *compose_create(PrefsAccount *account,
7061                                                  FolderItem *folder,
7062                                                  ComposeMode mode,
7063                                                  gboolean batch)
7064 {
7065         Compose   *compose;
7066         GtkWidget *window;
7067         GtkWidget *vbox;
7068         GtkWidget *menubar;
7069         GtkWidget *handlebox;
7070
7071         GtkWidget *notebook;
7072
7073         GtkWidget *attach_hbox;
7074         GtkWidget *attach_lab1;
7075         GtkWidget *attach_lab2;
7076
7077         GtkWidget *vbox2;
7078
7079         GtkWidget *label;
7080         GtkWidget *subject_hbox;
7081         GtkWidget *subject_frame;
7082         GtkWidget *subject_entry;
7083         GtkWidget *subject;
7084         GtkWidget *paned;
7085
7086         GtkWidget *edit_vbox;
7087 #if !GTK_CHECK_VERSION(2, 24, 0)
7088         GtkWidget *ruler_hbox;
7089         GtkWidget *ruler;
7090 #endif
7091         GtkWidget *scrolledwin;
7092         GtkWidget *text;
7093         GtkTextBuffer *buffer;
7094         GtkClipboard *clipboard;
7095         CLAWS_TIP_DECL();
7096
7097         UndoMain *undostruct;
7098
7099         gchar *titles[N_ATTACH_COLS];
7100         GtkWidget *popupmenu;
7101         GtkWidget *tmpl_menu;
7102         GtkActionGroup *action_group = NULL;
7103
7104 #if USE_ENCHANT
7105         GtkAspell * gtkaspell = NULL;
7106 #endif
7107
7108         static GdkGeometry geometry;
7109
7110         cm_return_val_if_fail(account != NULL, NULL);
7111
7112         debug_print("Creating compose window...\n");
7113         compose = g_new0(Compose, 1);
7114
7115         titles[COL_MIMETYPE] = _("MIME type");
7116         titles[COL_SIZE]     = _("Size");
7117         titles[COL_NAME]     = _("Name");
7118         titles[COL_CHARSET]  = _("Charset");
7119
7120         compose->batch = batch;
7121         compose->account = account;
7122         compose->folder = folder;
7123
7124         compose->mutex = g_mutex_new();
7125         compose->set_cursor_pos = -1;
7126
7127 #if !(GTK_CHECK_VERSION(2,12,0))
7128         compose->tooltips = tips;
7129 #endif
7130
7131         window = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "compose");
7132
7133         gtk_window_set_resizable(GTK_WINDOW(window), TRUE);
7134         gtk_widget_set_size_request(window, -1, prefs_common.compose_height);
7135
7136         if (!geometry.max_width) {
7137                 geometry.max_width = gdk_screen_width();
7138                 geometry.max_height = gdk_screen_height();
7139         }
7140
7141         gtk_window_set_geometry_hints(GTK_WINDOW(window), NULL,
7142                                       &geometry, GDK_HINT_MAX_SIZE);
7143         if (!geometry.min_width) {
7144                 geometry.min_width = 600;
7145                 geometry.min_height = 440;
7146         }
7147         gtk_window_set_geometry_hints(GTK_WINDOW(window), NULL,
7148                                       &geometry, GDK_HINT_MIN_SIZE);
7149
7150 #ifndef GENERIC_UMPC
7151         if (compose_force_window_origin)
7152                 gtk_window_move(GTK_WINDOW(window), prefs_common.compose_x,
7153                                  prefs_common.compose_y);
7154 #endif
7155         g_signal_connect(G_OBJECT(window), "delete_event",
7156                          G_CALLBACK(compose_delete_cb), compose);
7157         MANAGE_WINDOW_SIGNALS_CONNECT(window);
7158         gtk_widget_realize(window);
7159
7160         gtkut_widget_set_composer_icon(window);
7161
7162         vbox = gtk_vbox_new(FALSE, 0);
7163         gtk_container_add(GTK_CONTAINER(window), vbox);
7164
7165         compose->ui_manager = gtk_ui_manager_new();
7166         action_group = cm_menu_create_action_group_full(compose->ui_manager,"Menu", compose_entries,
7167                         G_N_ELEMENTS(compose_entries), (gpointer)compose);
7168         gtk_action_group_add_toggle_actions(action_group, compose_toggle_entries,
7169                         G_N_ELEMENTS(compose_toggle_entries), (gpointer)compose);
7170         gtk_action_group_add_radio_actions(action_group, compose_radio_rm_entries,
7171                         G_N_ELEMENTS(compose_radio_rm_entries), COMPOSE_REPLY, G_CALLBACK(compose_reply_change_mode_cb), (gpointer)compose);
7172         gtk_action_group_add_radio_actions(action_group, compose_radio_prio_entries,
7173                         G_N_ELEMENTS(compose_radio_prio_entries), PRIORITY_NORMAL, G_CALLBACK(compose_set_priority_cb), (gpointer)compose);
7174         gtk_action_group_add_radio_actions(action_group, compose_radio_enc_entries,
7175                         G_N_ELEMENTS(compose_radio_enc_entries), C_AUTO, G_CALLBACK(compose_set_encoding_cb), (gpointer)compose);
7176
7177 #ifndef MAEMO
7178         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/", "Menu", NULL, GTK_UI_MANAGER_MENUBAR)
7179 #else
7180         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/", "Menu", NULL, GTK_UI_MANAGER_POPUP)
7181 #endif
7182
7183         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu", "Message", "Message", GTK_UI_MANAGER_MENU)
7184         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu", "Edit", "Edit", GTK_UI_MANAGER_MENU)
7185 #ifdef USE_ENCHANT
7186         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu", "Spelling", "Spelling", GTK_UI_MANAGER_MENU)
7187 #endif
7188         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu", "Options", "Options", GTK_UI_MANAGER_MENU)
7189         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu", "Tools", "Tools", GTK_UI_MANAGER_MENU)
7190         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu", "Help", "Help", GTK_UI_MANAGER_MENU)
7191
7192 /* Compose menu */
7193         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Message", "Send", "Message/Send", GTK_UI_MANAGER_MENUITEM)
7194         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Message", "SendLater", "Message/SendLater", GTK_UI_MANAGER_MENUITEM)
7195         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Message", "Separator1", "Message/---", GTK_UI_MANAGER_SEPARATOR)
7196         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Message", "AttachFile", "Message/AttachFile", GTK_UI_MANAGER_MENUITEM)
7197         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Message", "InsertFile", "Message/InsertFile", GTK_UI_MANAGER_MENUITEM)
7198         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Message", "InsertSig", "Message/InsertSig", GTK_UI_MANAGER_MENUITEM)
7199         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Message", "Separator2", "Message/---", GTK_UI_MANAGER_SEPARATOR)
7200         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Message", "Save", "Message/Save", GTK_UI_MANAGER_MENUITEM)
7201         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Message", "Separator3", "Message/---", GTK_UI_MANAGER_SEPARATOR)
7202         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Message", "Close", "Message/Close", GTK_UI_MANAGER_MENUITEM)
7203
7204 /* Edit menu */
7205         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Edit", "Undo", "Edit/Undo", GTK_UI_MANAGER_MENUITEM)
7206         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Edit", "Redo", "Edit/Redo", GTK_UI_MANAGER_MENUITEM)
7207         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Edit", "Separator1", "Edit/---", GTK_UI_MANAGER_SEPARATOR)
7208
7209         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Edit", "Cut", "Edit/Cut", GTK_UI_MANAGER_MENUITEM)
7210         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Edit", "Copy", "Edit/Copy", GTK_UI_MANAGER_MENUITEM)
7211         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Edit", "Paste", "Edit/Paste", GTK_UI_MANAGER_MENUITEM)
7212
7213         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Edit", "SpecialPaste", "Edit/SpecialPaste", GTK_UI_MANAGER_MENU)
7214         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Edit/SpecialPaste", "AsQuotation", "Edit/SpecialPaste/AsQuotation", GTK_UI_MANAGER_MENUITEM)
7215         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Edit/SpecialPaste", "Wrapped", "Edit/SpecialPaste/Wrapped", GTK_UI_MANAGER_MENUITEM)
7216         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Edit/SpecialPaste", "Unwrapped", "Edit/SpecialPaste/Unwrapped", GTK_UI_MANAGER_MENUITEM)
7217
7218         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Edit", "SelectAll", "Edit/SelectAll", GTK_UI_MANAGER_MENUITEM)
7219
7220         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Edit", "Advanced", "Edit/Advanced", GTK_UI_MANAGER_MENU)
7221         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Edit/Advanced", "BackChar", "Edit/Advanced/BackChar", GTK_UI_MANAGER_MENUITEM)
7222         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Edit/Advanced", "ForwChar", "Edit/Advanced/ForwChar", GTK_UI_MANAGER_MENUITEM)
7223         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Edit/Advanced", "BackWord", "Edit/Advanced/BackWord", GTK_UI_MANAGER_MENUITEM)
7224         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Edit/Advanced", "ForwWord", "Edit/Advanced/ForwWord", GTK_UI_MANAGER_MENUITEM)
7225         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Edit/Advanced", "BegLine", "Edit/Advanced/BegLine", GTK_UI_MANAGER_MENUITEM)
7226         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Edit/Advanced", "EndLine", "Edit/Advanced/EndLine", GTK_UI_MANAGER_MENUITEM)
7227         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Edit/Advanced", "PrevLine", "Edit/Advanced/PrevLine", GTK_UI_MANAGER_MENUITEM)
7228         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Edit/Advanced", "NextLine", "Edit/Advanced/NextLine", GTK_UI_MANAGER_MENUITEM)
7229         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Edit/Advanced", "DelBackChar", "Edit/Advanced/DelBackChar", GTK_UI_MANAGER_MENUITEM)
7230         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Edit/Advanced", "DelForwChar", "Edit/Advanced/DelForwChar", GTK_UI_MANAGER_MENUITEM)
7231         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Edit/Advanced", "DelBackWord", "Edit/Advanced/DelBackWord", GTK_UI_MANAGER_MENUITEM)
7232         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Edit/Advanced", "DelForwWord", "Edit/Advanced/DelForwWord", GTK_UI_MANAGER_MENUITEM)
7233         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Edit/Advanced", "DelLine", "Edit/Advanced/DelLine", GTK_UI_MANAGER_MENUITEM)
7234         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Edit/Advanced", "DelEndLine", "Edit/Advanced/DelEndLine", GTK_UI_MANAGER_MENUITEM)
7235
7236         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Edit", "Separator2", "Edit/---", GTK_UI_MANAGER_SEPARATOR)
7237
7238         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Edit", "Find", "Edit/Find", GTK_UI_MANAGER_MENUITEM)
7239         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Edit", "WrapPara", "Edit/WrapPara", GTK_UI_MANAGER_MENUITEM)
7240         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Edit", "WrapAllLines", "Edit/WrapAllLines", GTK_UI_MANAGER_MENUITEM)
7241         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Edit", "AutoWrap", "Edit/AutoWrap", GTK_UI_MANAGER_MENUITEM)
7242         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Edit", "AutoIndent", "Edit/AutoIndent", GTK_UI_MANAGER_MENUITEM)
7243
7244         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Edit", "Separator3", "Edit/---", GTK_UI_MANAGER_SEPARATOR)
7245
7246         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Edit", "ExtEditor", "Edit/ExtEditor", GTK_UI_MANAGER_MENUITEM)
7247
7248 #if USE_ENCHANT
7249 /* Spelling menu */
7250         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Spelling", "CheckAllSel", "Spelling/CheckAllSel", GTK_UI_MANAGER_MENUITEM)
7251         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Spelling", "HighlightAll", "Spelling/HighlightAll", GTK_UI_MANAGER_MENUITEM)
7252         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Spelling", "CheckBackwards", "Spelling/CheckBackwards", GTK_UI_MANAGER_MENUITEM)
7253         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Spelling", "ForwardNext", "Spelling/ForwardNext", GTK_UI_MANAGER_MENUITEM)
7254         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Spelling", "Separator1", "Spelling/---", GTK_UI_MANAGER_SEPARATOR)
7255         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Spelling", "Options", "Spelling/Options", GTK_UI_MANAGER_MENU)
7256 #endif
7257
7258 /* Options menu */
7259         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options", "ReplyMode", "Options/ReplyMode", GTK_UI_MANAGER_MENU)
7260         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/ReplyMode", "Normal", "Options/ReplyMode/Normal", GTK_UI_MANAGER_MENUITEM)
7261         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/ReplyMode", "All", "Options/ReplyMode/All", GTK_UI_MANAGER_MENUITEM)
7262         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/ReplyMode", "Sender", "Options/ReplyMode/Sender", GTK_UI_MANAGER_MENUITEM)
7263         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/ReplyMode", "List", "Options/ReplyMode/List", GTK_UI_MANAGER_MENUITEM)
7264
7265         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options", "Separator1", "Options/---", GTK_UI_MANAGER_SEPARATOR)
7266         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options", "PrivacySystem", "Options/PrivacySystem", GTK_UI_MANAGER_MENU)
7267         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/PrivacySystem", "PlaceHolder", "Options/PrivacySystem/PlaceHolder", GTK_UI_MANAGER_MENUITEM)
7268         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options", "Sign", "Options/Sign", GTK_UI_MANAGER_MENUITEM)
7269         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options", "Encrypt", "Options/Encrypt", GTK_UI_MANAGER_MENUITEM)
7270
7271
7272         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options", "Separator2", "Options/---", GTK_UI_MANAGER_SEPARATOR)
7273         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options", "Priority", "Options/Priority", GTK_UI_MANAGER_MENU)
7274         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Priority", "Highest", "Options/Priority/Highest", GTK_UI_MANAGER_MENUITEM)
7275         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Priority", "High", "Options/Priority/High", GTK_UI_MANAGER_MENUITEM)
7276         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Priority", "Normal", "Options/Priority/Normal", GTK_UI_MANAGER_MENUITEM)
7277         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Priority", "Low", "Options/Priority/Low", GTK_UI_MANAGER_MENUITEM)
7278         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Priority", "Lowest", "Options/Priority/Lowest", GTK_UI_MANAGER_MENUITEM)
7279
7280         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options", "Separator3", "Options/---", GTK_UI_MANAGER_SEPARATOR)
7281         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options", "RequestRetRcpt", "Options/RequestRetRcpt", GTK_UI_MANAGER_MENUITEM)
7282         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options", "Separator4", "Options/---", GTK_UI_MANAGER_SEPARATOR)
7283         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options", "RemoveReferences", "Options/RemoveReferences", GTK_UI_MANAGER_MENUITEM)
7284         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options", "Separator5", "Options/---", GTK_UI_MANAGER_SEPARATOR)
7285
7286         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options", "Encoding", "Options/Encoding", GTK_UI_MANAGER_MENU)
7287
7288         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding", CS_AUTO, "Options/Encoding/"CS_AUTO, GTK_UI_MANAGER_MENUITEM)
7289         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding", "Separator1", "Options/Encoding/---", GTK_UI_MANAGER_SEPARATOR)
7290         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding", CS_US_ASCII, "Options/Encoding/"CS_US_ASCII, GTK_UI_MANAGER_MENUITEM)
7291         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding", CS_UTF_8, "Options/Encoding/"CS_UTF_8, GTK_UI_MANAGER_MENUITEM)
7292         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding", "Separator2", "Options/Encoding/---", GTK_UI_MANAGER_SEPARATOR)
7293
7294         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding", "Western", "Options/Encoding/Western", GTK_UI_MANAGER_MENU)
7295         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding/Western", CS_ISO_8859_1, "Options/Encoding/Western/"CS_ISO_8859_1, GTK_UI_MANAGER_MENUITEM)
7296         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding/Western", CS_ISO_8859_15, "Options/Encoding/Western/"CS_ISO_8859_15, GTK_UI_MANAGER_MENUITEM)
7297         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding/Western", CS_WINDOWS_1252, "Options/Encoding/Western/"CS_WINDOWS_1252, GTK_UI_MANAGER_MENUITEM)
7298
7299         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding", CS_ISO_8859_2, "Options/Encoding/"CS_ISO_8859_2, GTK_UI_MANAGER_MENUITEM)
7300
7301         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding", "Baltic", "Options/Encoding/Baltic", GTK_UI_MANAGER_MENU)
7302         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding/Baltic", CS_ISO_8859_13, "Options/Encoding/Baltic/"CS_ISO_8859_13, GTK_UI_MANAGER_MENUITEM)
7303         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding/Baltic", CS_ISO_8859_4, "Options/Encoding/Baltic/"CS_ISO_8859_4, GTK_UI_MANAGER_MENUITEM)
7304
7305         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding", CS_ISO_8859_7, "Options/Encoding/"CS_ISO_8859_7, GTK_UI_MANAGER_MENUITEM)
7306
7307         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding", "Hebrew", "Options/Encoding/Hebrew", GTK_UI_MANAGER_MENU)
7308         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding/Hebrew", CS_ISO_8859_8, "Options/Encoding/Hebrew/"CS_ISO_8859_8, GTK_UI_MANAGER_MENUITEM)
7309         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding/Hebrew", CS_WINDOWS_1255, "Options/Encoding/Hebrew/"CS_WINDOWS_1255, GTK_UI_MANAGER_MENUITEM)
7310
7311         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding", "Arabic", "Options/Encoding/Arabic", GTK_UI_MANAGER_MENU)
7312         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding/Arabic", CS_ISO_8859_6, "Options/Encoding/Arabic/"CS_ISO_8859_6, GTK_UI_MANAGER_MENUITEM)
7313         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding/Arabic", CS_WINDOWS_1256, "Options/Encoding/Arabic/"CS_WINDOWS_1256, GTK_UI_MANAGER_MENUITEM)
7314
7315         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding", CS_ISO_8859_9, "Options/Encoding/"CS_ISO_8859_9, GTK_UI_MANAGER_MENUITEM)
7316
7317         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding", "Cyrillic", "Options/Encoding/Cyrillic", GTK_UI_MANAGER_MENU)
7318         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding/Cyrillic", CS_ISO_8859_5, "Options/Encoding/Cyrillic/"CS_ISO_8859_5, GTK_UI_MANAGER_MENUITEM)
7319         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding/Cyrillic", CS_KOI8_R, "Options/Encoding/Cyrillic/"CS_KOI8_R, GTK_UI_MANAGER_MENUITEM)
7320         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding/Cyrillic", CS_KOI8_U, "Options/Encoding/Cyrillic/"CS_KOI8_U, GTK_UI_MANAGER_MENUITEM)
7321         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding/Cyrillic", CS_WINDOWS_1251, "Options/Encoding/Cyrillic/"CS_WINDOWS_1251, GTK_UI_MANAGER_MENUITEM)
7322
7323         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding", "Japanese", "Options/Encoding/Japanese", GTK_UI_MANAGER_MENU)
7324         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding/Japanese", CS_ISO_2022_JP, "Options/Encoding/Japanese/"CS_ISO_2022_JP, GTK_UI_MANAGER_MENUITEM)
7325         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding/Japanese", CS_ISO_2022_JP_2, "Options/Encoding/Japanese/"CS_ISO_2022_JP_2, GTK_UI_MANAGER_MENUITEM)
7326         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding/Japanese", CS_EUC_JP, "Options/Encoding/Japanese/"CS_EUC_JP, GTK_UI_MANAGER_MENUITEM)
7327         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding/Japanese", CS_SHIFT_JIS, "Options/Encoding/Japanese/"CS_SHIFT_JIS, GTK_UI_MANAGER_MENUITEM)
7328
7329         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding", "Chinese", "Options/Encoding/Chinese", GTK_UI_MANAGER_MENU)
7330         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding/Chinese", CS_GB18030, "Options/Encoding/Chinese/"CS_GB18030, GTK_UI_MANAGER_MENUITEM)
7331         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding/Chinese", CS_GB2312, "Options/Encoding/Chinese/"CS_GB2312, GTK_UI_MANAGER_MENUITEM)
7332         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding/Chinese", CS_GBK, "Options/Encoding/Chinese/"CS_GBK, GTK_UI_MANAGER_MENUITEM)
7333         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding/Chinese", CS_BIG5, "Options/Encoding/Chinese/"CS_BIG5, GTK_UI_MANAGER_MENUITEM)
7334         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding/Chinese", CS_EUC_TW, "Options/Encoding/Chinese/"CS_EUC_TW, GTK_UI_MANAGER_MENUITEM)
7335
7336         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding", "Korean", "Options/Encoding/Korean", GTK_UI_MANAGER_MENU)
7337         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding/Korean", CS_EUC_KR, "Options/Encoding/Korean/"CS_EUC_KR, GTK_UI_MANAGER_MENUITEM)
7338         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding/Korean", CS_ISO_2022_KR, "Options/Encoding/Korean/"CS_ISO_2022_KR, GTK_UI_MANAGER_MENUITEM)
7339
7340         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding", "Thai", "Options/Encoding/Thai", GTK_UI_MANAGER_MENU)
7341         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding/Thai", CS_TIS_620, "Options/Encoding/Thai/"CS_TIS_620, GTK_UI_MANAGER_MENUITEM)
7342         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Options/Encoding/Thai", CS_WINDOWS_874, "Options/Encoding/Thai/"CS_WINDOWS_874, GTK_UI_MANAGER_MENUITEM)
7343 /* phew. */
7344
7345 /* Tools menu */
7346 #if !GTK_CHECK_VERSION(2, 24, 0)
7347         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Tools", "ShowRuler", "Tools/ShowRuler", GTK_UI_MANAGER_MENUITEM)
7348 #endif
7349         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Tools", "AddressBook", "Tools/AddressBook", GTK_UI_MANAGER_MENUITEM)
7350         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Tools", "Template", "Tools/Template", GTK_UI_MANAGER_MENU)
7351         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Tools/Template", "PlaceHolder", "Tools/Template/PlaceHolder", GTK_UI_MANAGER_MENUITEM)
7352         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Tools", "Actions", "Tools/Actions", GTK_UI_MANAGER_MENU)
7353         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Tools/Actions", "PlaceHolder", "Tools/Actions/PlaceHolder", GTK_UI_MANAGER_MENUITEM)
7354
7355 /* Help menu */
7356         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Menu/Help", "About", "Help/About", GTK_UI_MANAGER_MENUITEM)
7357
7358         menubar = gtk_ui_manager_get_widget(compose->ui_manager, "/Menu");
7359         gtk_widget_show_all(menubar);
7360
7361         gtk_window_add_accel_group(GTK_WINDOW(window), gtk_ui_manager_get_accel_group(compose->ui_manager));
7362 #ifndef MAEMO
7363         gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, TRUE, 0);
7364 #else
7365         hildon_window_set_menu(HILDON_WINDOW(window), GTK_MENU(menubar));
7366 #endif
7367
7368         if (prefs_common.toolbar_detachable) {
7369                 handlebox = gtk_handle_box_new();
7370         } else {
7371                 handlebox = gtk_hbox_new(FALSE, 0);
7372         }
7373         gtk_box_pack_start(GTK_BOX(vbox), handlebox, FALSE, FALSE, 0);
7374
7375         gtk_widget_realize(handlebox);
7376 #ifdef MAEMO
7377         compose->toolbar = toolbar_create(TOOLBAR_COMPOSE, window,
7378                                           (gpointer)compose);
7379 #else
7380         compose->toolbar = toolbar_create(TOOLBAR_COMPOSE, handlebox,
7381                                           (gpointer)compose);
7382 #endif
7383
7384         vbox2 = gtk_vbox_new(FALSE, 2);
7385         gtk_box_pack_start(GTK_BOX(vbox), vbox2, TRUE, TRUE, 0);
7386         gtk_container_set_border_width(GTK_CONTAINER(vbox2), 0);
7387
7388         /* Notebook */
7389         notebook = gtk_notebook_new();
7390         gtk_widget_set_size_request(notebook, -1, 130);
7391         gtk_widget_show(notebook);
7392
7393         /* header labels and entries */
7394         gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
7395                         compose_create_header(compose),
7396                         gtk_label_new_with_mnemonic(_("Hea_der")));
7397         /* attachment list */
7398         attach_hbox = gtk_hbox_new(FALSE, 0);
7399         gtk_widget_show(attach_hbox);
7400
7401         attach_lab1 = gtk_label_new_with_mnemonic(_("_Attachments"));
7402         gtk_widget_show(attach_lab1);
7403         gtk_box_pack_start(GTK_BOX(attach_hbox), attach_lab1, TRUE, TRUE, 0);
7404
7405         attach_lab2 = gtk_label_new("");
7406         gtk_widget_show(attach_lab2);
7407         gtk_box_pack_start(GTK_BOX(attach_hbox), attach_lab2, FALSE, FALSE, 0);
7408
7409         gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
7410                         compose_create_attach(compose),
7411                         attach_hbox);
7412         /* Others Tab */
7413         gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
7414                         compose_create_others(compose),
7415                         gtk_label_new_with_mnemonic(_("Othe_rs")));
7416
7417         /* Subject */
7418         subject_hbox = gtk_hbox_new(FALSE, 0);
7419         gtk_widget_show(subject_hbox);
7420
7421         subject_frame = gtk_frame_new(NULL);
7422         gtk_frame_set_shadow_type(GTK_FRAME(subject_frame), GTK_SHADOW_NONE);
7423         gtk_box_pack_start(GTK_BOX(subject_hbox), subject_frame, TRUE, TRUE, 0);
7424         gtk_widget_show(subject_frame);
7425
7426         subject = gtk_hbox_new(FALSE, HSPACING_NARROW);
7427         gtk_container_set_border_width(GTK_CONTAINER(subject), 0);
7428         gtk_widget_show(subject);
7429
7430         label = gtk_label_new(_("Subject:"));
7431         gtk_box_pack_start(GTK_BOX(subject), label, FALSE, FALSE, 0);
7432         gtk_widget_show(label);
7433
7434 #ifdef USE_ENCHANT
7435         subject_entry = claws_spell_entry_new();
7436 #else
7437         subject_entry = gtk_entry_new();
7438 #endif
7439         gtk_box_pack_start(GTK_BOX(subject), subject_entry, TRUE, TRUE, 0);
7440         g_signal_connect_after(G_OBJECT(subject_entry), "grab_focus",
7441                          G_CALLBACK(compose_grab_focus_cb), compose);
7442         gtk_widget_show(subject_entry);
7443         compose->subject_entry = subject_entry;
7444         gtk_container_add(GTK_CONTAINER(subject_frame), subject);
7445
7446         edit_vbox = gtk_vbox_new(FALSE, 0);
7447
7448         gtk_box_pack_start(GTK_BOX(edit_vbox), subject_hbox, FALSE, FALSE, 0);
7449
7450 #if !GTK_CHECK_VERSION(2, 24, 0)
7451         /* ruler */
7452         ruler_hbox = gtk_hbox_new(FALSE, 0);
7453         gtk_box_pack_start(GTK_BOX(edit_vbox), ruler_hbox, FALSE, FALSE, 0);
7454
7455         ruler = gtk_shruler_new();
7456         gtk_ruler_set_range(GTK_RULER(ruler), 0.0, 100.0, 1.0, 100.0);
7457         gtk_box_pack_start(GTK_BOX(ruler_hbox), ruler, TRUE, TRUE,
7458                            BORDER_WIDTH);
7459 #endif
7460
7461         /* text widget */
7462         scrolledwin = gtk_scrolled_window_new(NULL, NULL);
7463         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),
7464                                        GTK_POLICY_AUTOMATIC,
7465                                        GTK_POLICY_AUTOMATIC);
7466         gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwin),
7467                                             GTK_SHADOW_IN);
7468         gtk_box_pack_start(GTK_BOX(edit_vbox), scrolledwin, TRUE, TRUE, 0);
7469         gtk_widget_set_size_request(scrolledwin, prefs_common.compose_width, -1);
7470
7471         text = gtk_text_view_new();
7472         if (prefs_common.show_compose_margin) {
7473                 gtk_text_view_set_left_margin(GTK_TEXT_VIEW(text), 6);
7474                 gtk_text_view_set_right_margin(GTK_TEXT_VIEW(text), 6);
7475         }
7476         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
7477         gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(text), GTK_WRAP_WORD_CHAR);
7478         gtk_text_view_set_editable(GTK_TEXT_VIEW(text), TRUE);
7479         clipboard = gtk_clipboard_get(GDK_SELECTION_PRIMARY);
7480         gtk_text_buffer_add_selection_clipboard(buffer, clipboard);
7481
7482         gtk_container_add(GTK_CONTAINER(scrolledwin), text);
7483 #if !GTK_CHECK_VERSION(2, 24, 0)
7484         g_signal_connect_after(G_OBJECT(text), "size_allocate",
7485                                G_CALLBACK(compose_edit_size_alloc),
7486                                ruler);
7487 #endif
7488         g_signal_connect(G_OBJECT(buffer), "changed",
7489                          G_CALLBACK(compose_changed_cb), compose);
7490         g_signal_connect(G_OBJECT(text), "grab_focus",
7491                          G_CALLBACK(compose_grab_focus_cb), compose);
7492         g_signal_connect(G_OBJECT(buffer), "insert_text",
7493                          G_CALLBACK(text_inserted), compose);
7494         g_signal_connect(G_OBJECT(text), "button_press_event",
7495                          G_CALLBACK(text_clicked), compose);
7496 #ifndef MAEMO
7497         g_signal_connect(G_OBJECT(text), "popup-menu",
7498                          G_CALLBACK(compose_popup_menu), compose);
7499 #else
7500         gtk_widget_tap_and_hold_setup(GTK_WIDGET(text), NULL, NULL,
7501                         GTK_TAP_AND_HOLD_NONE | GTK_TAP_AND_HOLD_NO_INTERNALS);
7502         g_signal_connect(G_OBJECT(text), "tap-and-hold",
7503                          G_CALLBACK(compose_popup_menu), compose);
7504 #endif
7505         g_signal_connect(G_OBJECT(subject_entry), "changed",
7506                          G_CALLBACK(compose_changed_cb), compose);
7507
7508         /* drag and drop */
7509         gtk_drag_dest_set(text, GTK_DEST_DEFAULT_ALL, compose_mime_types,
7510                           sizeof(compose_mime_types)/sizeof(compose_mime_types[0]),
7511                           GDK_ACTION_COPY | GDK_ACTION_MOVE);
7512         g_signal_connect(G_OBJECT(text), "drag_data_received",
7513                          G_CALLBACK(compose_insert_drag_received_cb),
7514                          compose);
7515         g_signal_connect(G_OBJECT(text), "drag-drop",
7516                          G_CALLBACK(compose_drag_drop),
7517                          compose);
7518         gtk_widget_show_all(vbox);
7519
7520         /* pane between attach clist and text */
7521         paned = gtk_vpaned_new();
7522         gtk_container_add(GTK_CONTAINER(vbox2), paned);
7523 #ifdef MAEMO
7524         if( maemo_mainwindow_is_fullscreen(mainwindow_get_mainwindow()->window) )
7525                 gtk_widget_set_size_request(edit_vbox, -1, mode == COMPOSE_NEW ? 300 : 280);
7526         else
7527                 gtk_widget_set_size_request(edit_vbox, -1, mode == COMPOSE_NEW ? 250 : 230);
7528 #endif
7529         gtk_paned_add1(GTK_PANED(paned), notebook);
7530         gtk_paned_add2(GTK_PANED(paned), edit_vbox);
7531         gtk_widget_show_all(paned);
7532
7533
7534         if (prefs_common.textfont) {
7535                 PangoFontDescription *font_desc;
7536
7537                 font_desc = pango_font_description_from_string
7538                         (prefs_common.textfont);
7539                 if (font_desc) {
7540                         gtk_widget_modify_font(text, font_desc);
7541                         pango_font_description_free(font_desc);
7542                 }
7543         }
7544
7545         gtk_action_group_add_actions(action_group, compose_popup_entries,
7546                         G_N_ELEMENTS(compose_popup_entries), (gpointer)compose);
7547         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/", "Popup", NULL, GTK_UI_MANAGER_MENUBAR)
7548         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Popup", "Compose", "Compose", GTK_UI_MANAGER_MENU)
7549         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Popup/Compose", "Add", "Compose/Add", GTK_UI_MANAGER_MENUITEM)
7550         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Popup/Compose", "Remove", "Compose/Remove", GTK_UI_MANAGER_MENUITEM)
7551         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Popup/Compose", "Separator1", "Compose/---", GTK_UI_MANAGER_SEPARATOR)
7552         MENUITEM_ADDUI_MANAGER(compose->ui_manager, "/Popup/Compose", "Properties", "Compose/Properties", GTK_UI_MANAGER_MENUITEM)
7553
7554         popupmenu = gtk_menu_item_get_submenu(GTK_MENU_ITEM(gtk_ui_manager_get_widget(compose->ui_manager, "/Popup/Compose")));
7555
7556         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Edit/Undo", FALSE);
7557         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Edit/Redo", FALSE);
7558         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Options/RemoveReferences", FALSE);
7559
7560         tmpl_menu = gtk_ui_manager_get_widget(compose->ui_manager, "/Menu/Tools/Template");
7561
7562         undostruct = undo_init(text);
7563         undo_set_change_state_func(undostruct, &compose_undo_state_changed,
7564                                    compose);
7565
7566         address_completion_start(window);
7567
7568         compose->window        = window;
7569         compose->vbox          = vbox;
7570         compose->menubar       = menubar;
7571         compose->handlebox     = handlebox;
7572
7573         compose->vbox2         = vbox2;
7574
7575         compose->paned = paned;
7576
7577         compose->attach_label  = attach_lab2;
7578
7579         compose->notebook      = notebook;
7580         compose->edit_vbox     = edit_vbox;
7581 #if !GTK_CHECK_VERSION(2, 24, 0)
7582         compose->ruler_hbox    = ruler_hbox;
7583         compose->ruler         = ruler;
7584 #endif
7585         compose->scrolledwin   = scrolledwin;
7586         compose->text          = text;
7587
7588         compose->focused_editable = NULL;
7589
7590         compose->popupmenu    = popupmenu;
7591
7592         compose->tmpl_menu = tmpl_menu;
7593
7594         compose->mode = mode;
7595         compose->rmode = mode;
7596
7597         compose->targetinfo = NULL;
7598         compose->replyinfo  = NULL;
7599         compose->fwdinfo    = NULL;
7600
7601         compose->email_hashtable = g_hash_table_new_full(g_str_hash,
7602                                 g_str_equal, (GDestroyNotify) g_free, NULL);
7603
7604         compose->replyto     = NULL;
7605         compose->cc          = NULL;
7606         compose->bcc         = NULL;
7607         compose->followup_to = NULL;
7608
7609         compose->ml_post     = NULL;
7610
7611         compose->inreplyto   = NULL;
7612         compose->references  = NULL;
7613         compose->msgid       = NULL;
7614         compose->boundary    = NULL;
7615
7616         compose->autowrap       = prefs_common.autowrap;
7617         compose->autoindent     = prefs_common.auto_indent;
7618         compose->use_signing    = FALSE;
7619         compose->use_encryption = FALSE;
7620         compose->privacy_system = NULL;
7621
7622         compose->modified = FALSE;
7623
7624         compose->return_receipt = FALSE;
7625
7626         compose->to_list        = NULL;
7627         compose->newsgroup_list = NULL;
7628
7629         compose->undostruct = undostruct;
7630
7631         compose->sig_str = NULL;
7632
7633         compose->exteditor_file    = NULL;
7634         compose->exteditor_pid     = -1;
7635         compose->exteditor_tag     = -1;
7636         compose->draft_timeout_tag = -2; /* inhibit auto-drafting while loading */
7637
7638 #if USE_ENCHANT
7639         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Spelling", FALSE);
7640         if (mode != COMPOSE_REDIRECT) {
7641                 if (prefs_common.enable_aspell && prefs_common.dictionary &&
7642                     strcmp(prefs_common.dictionary, "")) {
7643                         gtkaspell = gtkaspell_new(prefs_common.dictionary,
7644                                                   prefs_common.alt_dictionary,
7645                                                   conv_get_locale_charset_str(),
7646                                                   prefs_common.misspelled_col,
7647                                                   prefs_common.check_while_typing,
7648                                                   prefs_common.recheck_when_changing_dict,
7649                                                   prefs_common.use_alternate,
7650                                                   prefs_common.use_both_dicts,
7651                                                   GTK_TEXT_VIEW(text),
7652                                                   GTK_WINDOW(compose->window),
7653                                                   compose_dict_changed,
7654                                                   compose_spell_menu_changed,
7655                                                   compose);
7656                         if (!gtkaspell) {
7657                                 alertpanel_error(_("Spell checker could not "
7658                                                 "be started.\n%s"),
7659                                                 gtkaspell_checkers_strerror());
7660                                 gtkaspell_checkers_reset_error();
7661                         } else {
7662                                 cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Spelling", TRUE);
7663                         }
7664                 }
7665         }
7666         compose->gtkaspell = gtkaspell;
7667         compose_spell_menu_changed(compose);
7668         claws_spell_entry_set_gtkaspell(CLAWS_SPELL_ENTRY(subject_entry), gtkaspell);
7669 #endif
7670
7671         compose_select_account(compose, account, TRUE);
7672
7673         cm_toggle_menu_set_active_full(compose->ui_manager, "Menu/Edit/AutoWrap", prefs_common.autowrap);
7674         cm_toggle_menu_set_active_full(compose->ui_manager, "Menu/Edit/AutoIndent", prefs_common.auto_indent);
7675
7676         if (account->set_autocc && account->auto_cc && mode != COMPOSE_REEDIT)
7677                 compose_entry_append(compose, account->auto_cc, COMPOSE_CC, PREF_ACCOUNT);
7678
7679         if (account->set_autobcc && account->auto_bcc && mode != COMPOSE_REEDIT)
7680                 compose_entry_append(compose, account->auto_bcc, COMPOSE_BCC, PREF_ACCOUNT);
7681
7682         if (account->set_autoreplyto && account->auto_replyto && mode != COMPOSE_REEDIT)
7683                 compose_entry_append(compose, account->auto_replyto, COMPOSE_REPLYTO, PREF_ACCOUNT);
7684
7685         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Options/ReplyMode", compose->mode == COMPOSE_REPLY);
7686         if (account->protocol != A_NNTP)
7687                 gtk_entry_set_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN((compose->header_last->combo)))),
7688                                 prefs_common_translated_header_name("To:"));
7689         else
7690                 gtk_entry_set_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN((compose->header_last->combo)))),
7691                                 prefs_common_translated_header_name("Newsgroups:"));
7692
7693         addressbook_set_target_compose(compose);
7694
7695         if (mode != COMPOSE_REDIRECT)
7696                 compose_set_template_menu(compose);
7697         else {
7698                 cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Tools/Template", FALSE);
7699         }
7700
7701         compose_list = g_list_append(compose_list, compose);
7702
7703 #if !GTK_CHECK_VERSION(2, 24, 0)
7704         if (!prefs_common.show_ruler)
7705                 gtk_widget_hide(ruler_hbox);
7706
7707         cm_toggle_menu_set_active_full(compose->ui_manager, "Menu/Tools/ShowRuler", prefs_common.show_ruler);
7708 #endif
7709
7710         /* Priority */
7711         compose->priority = PRIORITY_NORMAL;
7712         compose_update_priority_menu_item(compose);
7713
7714         compose_set_out_encoding(compose);
7715
7716         /* Actions menu */
7717         compose_update_actions_menu(compose);
7718
7719         /* Privacy Systems menu */
7720         compose_update_privacy_systems_menu(compose);
7721
7722         activate_privacy_system(compose, account, TRUE);
7723         toolbar_set_style(compose->toolbar->toolbar, compose->handlebox, prefs_common.toolbar_style);
7724         if (batch) {
7725                 gtk_widget_realize(window);
7726         } else {
7727                 gtk_widget_show(window);
7728 #ifdef MAEMO
7729                 maemo_window_full_screen_if_needed(GTK_WINDOW(window));
7730                 maemo_connect_key_press_to_mainwindow(GTK_WINDOW(window));
7731 #endif
7732         }
7733
7734         return compose;
7735 }
7736
7737 static GtkWidget *compose_account_option_menu_create(Compose *compose)
7738 {
7739         GList *accounts;
7740         GtkWidget *hbox;
7741         GtkWidget *optmenu;
7742         GtkWidget *optmenubox;
7743         GtkListStore *menu;
7744         GtkTreeIter iter;
7745         GtkWidget *from_name = NULL;
7746 #if !(GTK_CHECK_VERSION(2,12,0))
7747         GtkTooltips *tips = compose->tooltips;
7748 #endif
7749
7750         gint num = 0, def_menu = 0;
7751
7752         accounts = account_get_list();
7753         cm_return_val_if_fail(accounts != NULL, NULL);
7754
7755         optmenubox = gtk_event_box_new();
7756         optmenu = gtkut_sc_combobox_create(optmenubox, FALSE);
7757         menu = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(optmenu)));
7758
7759         hbox = gtk_hbox_new(FALSE, 6);
7760         from_name = gtk_entry_new();
7761
7762         g_signal_connect_after(G_OBJECT(from_name), "grab_focus",
7763                          G_CALLBACK(compose_grab_focus_cb), compose);
7764
7765         for (; accounts != NULL; accounts = accounts->next, num++) {
7766                 PrefsAccount *ac = (PrefsAccount *)accounts->data;
7767                 gchar *name, *from = NULL;
7768
7769                 if (ac == compose->account) def_menu = num;
7770
7771                 name = g_markup_printf_escaped(_("From: <i>%s</i>"),
7772                                        ac->account_name);
7773
7774                 if (ac == compose->account) {
7775                         if (ac->name && *ac->name) {
7776                                 gchar *buf;
7777                                 QUOTE_IF_REQUIRED_NORMAL(buf, ac->name, return NULL);
7778                                 from = g_strdup_printf("%s <%s>",
7779                                                        buf, ac->address);
7780                                 gtk_entry_set_text(GTK_ENTRY(from_name), from);
7781                         } else {
7782                                 from = g_strdup_printf("%s",
7783                                                        ac->address);
7784                                 gtk_entry_set_text(GTK_ENTRY(from_name), from);
7785                         }
7786                 }
7787                 COMBOBOX_ADD(menu, name, ac->account_id);
7788                 g_free(name);
7789                 g_free(from);
7790         }
7791
7792         gtk_combo_box_set_active(GTK_COMBO_BOX(optmenu), def_menu);
7793
7794         g_signal_connect(G_OBJECT(optmenu), "changed",
7795                         G_CALLBACK(account_activated),
7796                         compose);
7797         g_signal_connect(G_OBJECT(from_name), "populate-popup",
7798                          G_CALLBACK(compose_entry_popup_extend),
7799                          NULL);
7800
7801         gtk_box_pack_start(GTK_BOX(hbox), optmenubox, FALSE, FALSE, 0);
7802         gtk_box_pack_start(GTK_BOX(hbox), from_name, TRUE, TRUE, 0);
7803
7804         CLAWS_SET_TIP(optmenubox,
7805                 _("Account to use for this email"));
7806         CLAWS_SET_TIP(from_name,
7807                 _("Sender address to be used"));
7808
7809         compose->account_combo = optmenu;
7810         compose->from_name = from_name;
7811
7812         return hbox;
7813 }
7814
7815 static void compose_set_priority_cb(GtkAction *action, GtkRadioAction *current, gpointer data)
7816 {
7817         gboolean active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (current));
7818         gint value = gtk_radio_action_get_current_value (GTK_RADIO_ACTION (current));
7819         Compose *compose = (Compose *) data;
7820         if (active) {
7821                 compose->priority = value;
7822         }
7823 }
7824
7825 static void compose_reply_change_mode(Compose *compose,
7826                                     ComposeMode action)
7827 {
7828         gboolean was_modified = compose->modified;
7829
7830         gboolean all = FALSE, ml = FALSE, sender = FALSE, followup = FALSE;
7831
7832         cm_return_if_fail(compose->replyinfo != NULL);
7833
7834         if (action == COMPOSE_REPLY && prefs_common.default_reply_list)
7835                 ml = TRUE;
7836         if (action == COMPOSE_REPLY && compose->rmode == COMPOSE_FOLLOWUP_AND_REPLY_TO)
7837                 followup = TRUE;
7838         if (action == COMPOSE_REPLY_TO_ALL)
7839                 all = TRUE;
7840         if (action == COMPOSE_REPLY_TO_SENDER)
7841                 sender = TRUE;
7842         if (action == COMPOSE_REPLY_TO_LIST)
7843                 ml = TRUE;
7844
7845         compose_remove_header_entries(compose);
7846         compose_reply_set_entry(compose, compose->replyinfo, all, ml, sender, followup);
7847         if (compose->account->set_autocc && compose->account->auto_cc)
7848                 compose_entry_append(compose, compose->account->auto_cc, COMPOSE_CC, PREF_ACCOUNT);
7849
7850         if (compose->account->set_autobcc && compose->account->auto_bcc)
7851                 compose_entry_append(compose, compose->account->auto_bcc, COMPOSE_BCC, PREF_ACCOUNT);
7852
7853         if (compose->account->set_autoreplyto && compose->account->auto_replyto)
7854                 compose_entry_append(compose, compose->account->auto_replyto, COMPOSE_REPLYTO, PREF_ACCOUNT);
7855         compose_show_first_last_header(compose, TRUE);
7856         compose->modified = was_modified;
7857         compose_set_title(compose);
7858 }
7859
7860 static void compose_reply_change_mode_cb(GtkAction *action, GtkRadioAction *current, gpointer data)
7861 {
7862         gboolean active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (current));
7863         gint value = gtk_radio_action_get_current_value (GTK_RADIO_ACTION (current));
7864         Compose *compose = (Compose *) data;
7865
7866         if (active)
7867                 compose_reply_change_mode(compose, value);
7868 }
7869
7870 static void compose_update_priority_menu_item(Compose * compose)
7871 {
7872         GtkWidget *menuitem = NULL;
7873         switch (compose->priority) {
7874                 case PRIORITY_HIGHEST:
7875                         menuitem = gtk_ui_manager_get_widget
7876                                 (compose->ui_manager, "/Menu/Options/Priority/Highest");
7877                         break;
7878                 case PRIORITY_HIGH:
7879                         menuitem = gtk_ui_manager_get_widget
7880                                 (compose->ui_manager, "/Menu/Options/Priority/High");
7881                         break;
7882                 case PRIORITY_NORMAL:
7883                         menuitem = gtk_ui_manager_get_widget
7884                                 (compose->ui_manager, "/Menu/Options/Priority/Normal");
7885                         break;
7886                 case PRIORITY_LOW:
7887                         menuitem = gtk_ui_manager_get_widget
7888                                 (compose->ui_manager, "/Menu/Options/Priority/Low");
7889                         break;
7890                 case PRIORITY_LOWEST:
7891                         menuitem = gtk_ui_manager_get_widget
7892                                 (compose->ui_manager, "/Menu/Options/Priority/Lowest");
7893                         break;
7894         }
7895         gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem), TRUE);
7896 }
7897
7898 static void compose_set_privacy_system_cb(GtkWidget *widget, gpointer data)
7899 {
7900         Compose *compose = (Compose *) data;
7901         gchar *systemid;
7902         gboolean can_sign = FALSE, can_encrypt = FALSE;
7903
7904         cm_return_if_fail(GTK_IS_CHECK_MENU_ITEM(widget));
7905
7906         if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget)))
7907                 return;
7908
7909         systemid = g_object_get_data(G_OBJECT(widget), "privacy_system");
7910         g_free(compose->privacy_system);
7911         compose->privacy_system = NULL;
7912         if (systemid != NULL) {
7913                 compose->privacy_system = g_strdup(systemid);
7914
7915                 can_sign = privacy_system_can_sign(systemid);
7916                 can_encrypt = privacy_system_can_encrypt(systemid);
7917         }
7918
7919         debug_print("activated privacy system: %s\n", systemid != NULL ? systemid : "None");
7920
7921         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Options/Sign", can_sign);
7922         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Options/Encrypt", can_encrypt);
7923 }
7924
7925 static void compose_update_privacy_system_menu_item(Compose * compose, gboolean warn)
7926 {
7927         static gchar *branch_path = "/Menu/Options/PrivacySystem";
7928         GtkWidget *menuitem = NULL;
7929         GList *children, *amenu;
7930         gboolean can_sign = FALSE, can_encrypt = FALSE;
7931         gboolean found = FALSE;
7932
7933         if (compose->privacy_system != NULL) {
7934                 gchar *systemid;
7935                 menuitem = gtk_menu_item_get_submenu(GTK_MENU_ITEM(
7936                                 gtk_ui_manager_get_widget(compose->ui_manager, branch_path)));
7937                 cm_return_if_fail(menuitem != NULL);
7938
7939                 children = gtk_container_get_children(GTK_CONTAINER(GTK_MENU_SHELL(menuitem)));
7940                 amenu = children;
7941                 menuitem = NULL;
7942                 while (amenu != NULL) {
7943                         systemid = g_object_get_data(G_OBJECT(amenu->data), "privacy_system");
7944                         if (systemid != NULL) {
7945                                 if (strcmp(systemid, compose->privacy_system) == 0 &&
7946                                     GTK_IS_CHECK_MENU_ITEM(amenu->data)) {
7947                                         menuitem = GTK_WIDGET(amenu->data);
7948
7949                                         can_sign = privacy_system_can_sign(systemid);
7950                                         can_encrypt = privacy_system_can_encrypt(systemid);
7951                                         found = TRUE;
7952                                         break;
7953                                 }
7954                         } else if (strlen(compose->privacy_system) == 0 &&
7955                                    GTK_IS_CHECK_MENU_ITEM(amenu->data)) {
7956                                         menuitem = GTK_WIDGET(amenu->data);
7957
7958                                         can_sign = FALSE;
7959                                         can_encrypt = FALSE;
7960                                         found = TRUE;
7961                                         break;
7962                         }
7963
7964                         amenu = amenu->next;
7965                 }
7966                 g_list_free(children);
7967                 if (menuitem != NULL)
7968                         gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem), TRUE);
7969
7970                 if (warn && !found && strlen(compose->privacy_system)) {
7971                         alertpanel_warning(_("The privacy system '%s' cannot be loaded. You "
7972                                   "will not be able to sign or encrypt this message."),
7973                                   compose->privacy_system);
7974                 }
7975         }
7976
7977         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Options/Sign", can_sign);
7978         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Options/Encrypt", can_encrypt);
7979 }
7980
7981 static void compose_set_out_encoding(Compose *compose)
7982 {
7983         CharSet out_encoding;
7984         const gchar *branch = NULL;
7985         out_encoding = conv_get_charset_from_str(prefs_common.outgoing_charset);
7986
7987         switch(out_encoding) {
7988                 case C_AUTO: branch = "Menu/Options/Encoding/" CS_AUTO; break;
7989                 case C_US_ASCII: branch = "Menu/Options/Encoding/" CS_US_ASCII; break;
7990                 case C_UTF_8: branch = "Menu/Options/Encoding/" CS_UTF_8; break;
7991                 case C_ISO_8859_2: branch = "Menu/Options/Encoding/" CS_ISO_8859_2; break;
7992                 case C_ISO_8859_7: branch = "Menu/Options/Encoding/" CS_ISO_8859_7; break;
7993                 case C_ISO_8859_9: branch = "Menu/Options/Encoding/" CS_ISO_8859_9; break;
7994                 case C_ISO_8859_1: branch = "Menu/Options/Encoding/Western/" CS_ISO_8859_1; break;
7995                 case C_ISO_8859_15: branch = "Menu/Options/Encoding/Western/" CS_ISO_8859_15; break;
7996                 case C_WINDOWS_1252: branch = "Menu/Options/Encoding/Western/" CS_WINDOWS_1252; break;
7997                 case C_ISO_8859_13: branch = "Menu/Options/Encoding/Baltic/" CS_ISO_8859_13; break;
7998                 case C_ISO_8859_4: branch = "Menu/Options/Encoding/Baltic" CS_ISO_8859_4; break;
7999                 case C_ISO_8859_8: branch = "Menu/Options/Encoding/Hebrew/" CS_ISO_8859_8; break;
8000                 case C_WINDOWS_1255: branch = "Menu/Options/Encoding/Hebrew/" CS_WINDOWS_1255; break;
8001                 case C_ISO_8859_6: branch = "Menu/Options/Encoding/Arabic/" CS_ISO_8859_6; break;
8002                 case C_WINDOWS_1256: branch = "Menu/Options/Encoding/Arabic/" CS_WINDOWS_1256; break;
8003                 case C_ISO_8859_5: branch = "Menu/Options/Encoding/Cyrillic/" CS_ISO_8859_5; break;
8004                 case C_KOI8_R: branch = "Menu/Options/Encoding/Cyrillic/" CS_KOI8_R; break;
8005                 case C_KOI8_U: branch = "Menu/Options/Encoding/Cyrillic/" CS_KOI8_U; break;
8006                 case C_WINDOWS_1251: branch = "Menu/Options/Encoding/Cyrillic/" CS_WINDOWS_1251; break;
8007                 case C_ISO_2022_JP: branch = "Menu/Options/Encoding/Japanese/" CS_ISO_2022_JP; break;
8008                 case C_ISO_2022_JP_2: branch = "Menu/Options/Encoding/Japanese/" CS_ISO_2022_JP_2; break;
8009                 case C_EUC_JP: branch = "Menu/Options/Encoding/Japanese/" CS_EUC_JP; break;
8010                 case C_SHIFT_JIS: branch = "Menu/Options/Encoding/Japanese/" CS_SHIFT_JIS; break;
8011                 case C_GB18030: branch = "Menu/Options/Encoding/Chinese/" CS_GB18030; break;
8012                 case C_GB2312: branch = "Menu/Options/Encoding/Chinese/" CS_GB2312; break;
8013                 case C_GBK: branch = "Menu/Options/Encoding/Chinese/" CS_GBK; break;
8014                 case C_BIG5: branch = "Menu/Options/Encoding/Chinese/" CS_BIG5; break;
8015                 case C_EUC_TW: branch = "Menu/Options/Encoding/Chinese/" CS_EUC_TW; break;
8016                 case C_EUC_KR: branch = "Menu/Options/Encoding/Korean/" CS_EUC_KR; break;
8017                 case C_ISO_2022_KR: branch = "Menu/Options/Encoding/Korean/" CS_ISO_2022_KR; break;
8018                 case C_TIS_620: branch = "Menu/Options/Encoding/Thai/" CS_TIS_620; break;
8019                 case C_WINDOWS_874: branch = "Menu/Options/Encoding/Thai/" CS_WINDOWS_874; break;
8020                 default: branch = "Menu/Options/Encoding/" CS_AUTO; break;
8021         }
8022         cm_toggle_menu_set_active_full(compose->ui_manager, (gchar *)branch, TRUE);
8023 }
8024
8025 static void compose_set_template_menu(Compose *compose)
8026 {
8027         GSList *tmpl_list, *cur;
8028         GtkWidget *menu;
8029         GtkWidget *item;
8030
8031         tmpl_list = template_get_config();
8032
8033         menu = gtk_menu_new();
8034
8035         gtk_menu_set_accel_group (GTK_MENU (menu),
8036                 gtk_ui_manager_get_accel_group(compose->ui_manager));
8037         for (cur = tmpl_list; cur != NULL; cur = cur->next) {
8038                 Template *tmpl = (Template *)cur->data;
8039                 gchar *accel_path = NULL;
8040                 item = gtk_menu_item_new_with_label(tmpl->name);
8041                 gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
8042                 g_signal_connect(G_OBJECT(item), "activate",
8043                                  G_CALLBACK(compose_template_activate_cb),
8044                                  compose);
8045                 g_object_set_data(G_OBJECT(item), "template", tmpl);
8046                 gtk_widget_show(item);
8047                 accel_path = g_strconcat("<ComposeTemplates>" , "/", tmpl->name, NULL);
8048                 gtk_menu_item_set_accel_path(GTK_MENU_ITEM(item), accel_path);
8049                 g_free(accel_path);
8050         }
8051
8052         gtk_widget_show(menu);
8053         gtk_menu_item_set_submenu(GTK_MENU_ITEM(compose->tmpl_menu), menu);
8054 }
8055
8056 void compose_update_actions_menu(Compose *compose)
8057 {
8058         action_update_compose_menu(compose->ui_manager, "/Menu/Tools/Actions", compose);
8059 }
8060
8061 static void compose_update_privacy_systems_menu(Compose *compose)
8062 {
8063         static gchar *branch_path = "/Menu/Options/PrivacySystem";
8064         GSList *systems, *cur;
8065         GtkWidget *widget;
8066         GtkWidget *system_none;
8067         GSList *group;
8068         GtkWidget *privacy_menuitem = gtk_ui_manager_get_widget(compose->ui_manager, branch_path);
8069         GtkWidget *privacy_menu = gtk_menu_new();
8070
8071         system_none = gtk_radio_menu_item_new_with_mnemonic(NULL, _("_None"));
8072         g_object_set_data_full(G_OBJECT(system_none), "privacy_system", NULL, NULL);
8073
8074         g_signal_connect(G_OBJECT(system_none), "activate",
8075                 G_CALLBACK(compose_set_privacy_system_cb), compose);
8076
8077         gtk_menu_shell_append(GTK_MENU_SHELL(privacy_menu), system_none);
8078         gtk_widget_show(system_none);
8079
8080         systems = privacy_get_system_ids();
8081         for (cur = systems; cur != NULL; cur = g_slist_next(cur)) {
8082                 gchar *systemid = cur->data;
8083
8084                 group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(system_none));
8085                 widget = gtk_radio_menu_item_new_with_label(group,
8086                         privacy_system_get_name(systemid));
8087                 g_object_set_data_full(G_OBJECT(widget), "privacy_system",
8088                                        g_strdup(systemid), g_free);
8089                 g_signal_connect(G_OBJECT(widget), "activate",
8090                         G_CALLBACK(compose_set_privacy_system_cb), compose);
8091
8092                 gtk_menu_shell_append(GTK_MENU_SHELL(privacy_menu), widget);
8093                 gtk_widget_show(widget);
8094                 g_free(systemid);
8095         }
8096         g_slist_free(systems);
8097         gtk_menu_item_set_submenu(GTK_MENU_ITEM(privacy_menuitem), privacy_menu);
8098         gtk_widget_show_all(privacy_menu);
8099         gtk_widget_show_all(privacy_menuitem);
8100 }
8101
8102 void compose_reflect_prefs_all(void)
8103 {
8104         GList *cur;
8105         Compose *compose;
8106
8107         for (cur = compose_list; cur != NULL; cur = cur->next) {
8108                 compose = (Compose *)cur->data;
8109                 compose_set_template_menu(compose);
8110         }
8111 }
8112
8113 void compose_reflect_prefs_pixmap_theme(void)
8114 {
8115         GList *cur;
8116         Compose *compose;
8117
8118         for (cur = compose_list; cur != NULL; cur = cur->next) {
8119                 compose = (Compose *)cur->data;
8120                 toolbar_update(TOOLBAR_COMPOSE, compose);
8121         }
8122 }
8123
8124 static const gchar *compose_quote_char_from_context(Compose *compose)
8125 {
8126         const gchar *qmark = NULL;
8127
8128         cm_return_val_if_fail(compose != NULL, NULL);
8129
8130         switch (compose->mode) {
8131                 /* use forward-specific quote char */
8132                 case COMPOSE_FORWARD:
8133                 case COMPOSE_FORWARD_AS_ATTACH:
8134                 case COMPOSE_FORWARD_INLINE:
8135                         if (compose->folder && compose->folder->prefs &&
8136                                         compose->folder->prefs->forward_with_format)
8137                                 qmark = compose->folder->prefs->forward_quotemark;
8138                         else if (compose->account->forward_with_format)
8139                                 qmark = compose->account->forward_quotemark;
8140                         else
8141                                 qmark = prefs_common.fw_quotemark;
8142                         break;
8143
8144                 /* use reply-specific quote char in all other modes */
8145                 default:
8146                         if (compose->folder && compose->folder->prefs &&
8147                                         compose->folder->prefs->reply_with_format)
8148                                 qmark = compose->folder->prefs->reply_quotemark;
8149                         else if (compose->account->reply_with_format)
8150                                 qmark = compose->account->reply_quotemark;
8151                         else
8152                                 qmark = prefs_common.quotemark;
8153                         break;
8154         }
8155
8156         if (qmark == NULL || *qmark == '\0')
8157                 qmark = "> ";
8158
8159         return qmark;
8160 }
8161
8162 static void compose_template_apply(Compose *compose, Template *tmpl,
8163                                    gboolean replace)
8164 {
8165         GtkTextView *text;
8166         GtkTextBuffer *buffer;
8167         GtkTextMark *mark;
8168         GtkTextIter iter;
8169         const gchar *qmark;
8170         gchar *parsed_str = NULL;
8171         gint cursor_pos = 0;
8172         const gchar *err_msg = _("The body of the template has an error at line %d.");
8173         if (!tmpl) return;
8174
8175         /* process the body */
8176
8177         text = GTK_TEXT_VIEW(compose->text);
8178         buffer = gtk_text_view_get_buffer(text);
8179
8180         if (tmpl->value) {
8181                 qmark = compose_quote_char_from_context(compose);
8182
8183                 if (compose->replyinfo != NULL) {
8184
8185                         if (replace)
8186                                 gtk_text_buffer_set_text(buffer, "", -1);
8187                         mark = gtk_text_buffer_get_insert(buffer);
8188                         gtk_text_buffer_get_iter_at_mark(buffer, &iter, mark);
8189
8190                         parsed_str = compose_quote_fmt(compose, compose->replyinfo,
8191                                                    tmpl->value, qmark, NULL, FALSE, FALSE, err_msg);
8192
8193                 } else if (compose->fwdinfo != NULL) {
8194
8195                         if (replace)
8196                                 gtk_text_buffer_set_text(buffer, "", -1);
8197                         mark = gtk_text_buffer_get_insert(buffer);
8198                         gtk_text_buffer_get_iter_at_mark(buffer, &iter, mark);
8199
8200                         parsed_str = compose_quote_fmt(compose, compose->fwdinfo,
8201                                                    tmpl->value, qmark, NULL, FALSE, FALSE, err_msg);
8202
8203                 } else {
8204                         MsgInfo* dummyinfo = compose_msginfo_new_from_compose(compose);
8205
8206                         GtkTextIter start, end;
8207                         gchar *tmp = NULL;
8208
8209                         gtk_text_buffer_get_start_iter(buffer, &start);
8210                         gtk_text_buffer_get_iter_at_offset(buffer, &end, -1);
8211                         tmp = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
8212
8213                         /* clear the buffer now */
8214                         if (replace)
8215                                 gtk_text_buffer_set_text(buffer, "", -1);
8216
8217                         parsed_str = compose_quote_fmt(compose, dummyinfo,
8218                                                            tmpl->value, qmark, tmp, FALSE, FALSE, err_msg);
8219                         procmsg_msginfo_free( dummyinfo );
8220
8221                         g_free( tmp );
8222                 }
8223         } else {
8224                 if (replace)
8225                         gtk_text_buffer_set_text(buffer, "", -1);
8226                 mark = gtk_text_buffer_get_insert(buffer);
8227                 gtk_text_buffer_get_iter_at_mark(buffer, &iter, mark);
8228         }
8229
8230         if (replace && parsed_str && compose->account->auto_sig)
8231                 compose_insert_sig(compose, FALSE);
8232
8233         if (replace && parsed_str) {
8234                 gtk_text_buffer_get_start_iter(buffer, &iter);
8235                 gtk_text_buffer_place_cursor(buffer, &iter);
8236         }
8237
8238         if (parsed_str) {
8239                 cursor_pos = quote_fmt_get_cursor_pos();
8240                 compose->set_cursor_pos = cursor_pos;
8241                 if (cursor_pos == -1)
8242                         cursor_pos = 0;
8243                 gtk_text_buffer_get_start_iter(buffer, &iter);
8244                 gtk_text_buffer_get_iter_at_offset(buffer, &iter, cursor_pos);
8245                 gtk_text_buffer_place_cursor(buffer, &iter);
8246         }
8247
8248         /* process the other fields */
8249
8250         compose_template_apply_fields(compose, tmpl);
8251         compose_attach_from_list(compose, quote_fmt_get_attachments_list(), FALSE);
8252         quote_fmt_reset_vartable();
8253         compose_changed_cb(NULL, compose);
8254
8255 #ifdef USE_ENCHANT
8256         if (compose->gtkaspell && compose->gtkaspell->check_while_typing)
8257                 gtkaspell_highlight_all(compose->gtkaspell);
8258 #endif
8259 }
8260
8261 static void compose_template_apply_fields(Compose *compose, Template *tmpl)
8262 {
8263         MsgInfo* dummyinfo = NULL;
8264         MsgInfo *msginfo = NULL;
8265         gchar *buf = NULL;
8266
8267         if (compose->replyinfo != NULL)
8268                 msginfo = compose->replyinfo;
8269         else if (compose->fwdinfo != NULL)
8270                 msginfo = compose->fwdinfo;
8271         else {
8272                 dummyinfo = compose_msginfo_new_from_compose(compose);
8273                 msginfo = dummyinfo;
8274         }
8275
8276         if (tmpl->from && *tmpl->from != '\0') {
8277 #ifdef USE_ENCHANT
8278                 quote_fmt_init(msginfo, NULL, NULL, FALSE, compose->account, FALSE,
8279                                 compose->gtkaspell);
8280 #else
8281                 quote_fmt_init(msginfo, NULL, NULL, FALSE, compose->account, FALSE);
8282 #endif
8283                 quote_fmt_scan_string(tmpl->from);
8284                 quote_fmt_parse();
8285
8286                 buf = quote_fmt_get_buffer();
8287                 if (buf == NULL) {
8288                         alertpanel_error(_("Template From format error."));
8289                 } else {
8290                         gtk_entry_set_text(GTK_ENTRY(compose->from_name), buf);
8291                 }
8292         }
8293
8294         if (tmpl->to && *tmpl->to != '\0') {
8295 #ifdef USE_ENCHANT
8296                 quote_fmt_init(msginfo, NULL, NULL, FALSE, compose->account, FALSE,
8297                                 compose->gtkaspell);
8298 #else
8299                 quote_fmt_init(msginfo, NULL, NULL, FALSE, compose->account, FALSE);
8300 #endif
8301                 quote_fmt_scan_string(tmpl->to);
8302                 quote_fmt_parse();
8303
8304                 buf = quote_fmt_get_buffer();
8305                 if (buf == NULL) {
8306                         alertpanel_error(_("Template To format error."));
8307                 } else {
8308                         compose_entry_append(compose, buf, COMPOSE_TO, PREF_TEMPLATE);
8309                 }
8310         }
8311
8312         if (tmpl->cc && *tmpl->cc != '\0') {
8313 #ifdef USE_ENCHANT
8314                 quote_fmt_init(msginfo, NULL, NULL, FALSE, compose->account, FALSE,
8315                                 compose->gtkaspell);
8316 #else
8317                 quote_fmt_init(msginfo, NULL, NULL, FALSE, compose->account, FALSE);
8318 #endif
8319                 quote_fmt_scan_string(tmpl->cc);
8320                 quote_fmt_parse();
8321
8322                 buf = quote_fmt_get_buffer();
8323                 if (buf == NULL) {
8324                         alertpanel_error(_("Template Cc format error."));
8325                 } else {
8326                         compose_entry_append(compose, buf, COMPOSE_CC, PREF_TEMPLATE);
8327                 }
8328         }
8329
8330         if (tmpl->bcc && *tmpl->bcc != '\0') {
8331 #ifdef USE_ENCHANT
8332                 quote_fmt_init(msginfo, NULL, NULL, FALSE, compose->account, FALSE,
8333                                 compose->gtkaspell);
8334 #else
8335                 quote_fmt_init(msginfo, NULL, NULL, FALSE, compose->account, FALSE);
8336 #endif
8337                 quote_fmt_scan_string(tmpl->bcc);
8338                 quote_fmt_parse();
8339
8340                 buf = quote_fmt_get_buffer();
8341                 if (buf == NULL) {
8342                         alertpanel_error(_("Template Bcc format error."));
8343                 } else {
8344                         compose_entry_append(compose, buf, COMPOSE_BCC, PREF_TEMPLATE);
8345                 }
8346         }
8347
8348         /* process the subject */
8349         if (tmpl->subject && *tmpl->subject != '\0') {
8350 #ifdef USE_ENCHANT
8351                 quote_fmt_init(msginfo, NULL, NULL, FALSE, compose->account, FALSE,
8352                                 compose->gtkaspell);
8353 #else
8354                 quote_fmt_init(msginfo, NULL, NULL, FALSE, compose->account, FALSE);
8355 #endif
8356                 quote_fmt_scan_string(tmpl->subject);
8357                 quote_fmt_parse();
8358
8359                 buf = quote_fmt_get_buffer();
8360                 if (buf == NULL) {
8361                         alertpanel_error(_("Template subject format error."));
8362                 } else {
8363                         gtk_entry_set_text(GTK_ENTRY(compose->subject_entry), buf);
8364                 }
8365         }
8366
8367         procmsg_msginfo_free( dummyinfo );
8368 }
8369
8370 static void compose_destroy(Compose *compose)
8371 {
8372         GtkAllocation allocation;
8373         GtkTextBuffer *buffer;
8374         GtkClipboard *clipboard;
8375
8376         compose_list = g_list_remove(compose_list, compose);
8377
8378         if (compose->updating) {
8379                 debug_print("danger, not destroying anything now\n");
8380                 compose->deferred_destroy = TRUE;
8381                 return;
8382         }
8383         /* NOTE: address_completion_end() does nothing with the window
8384          * however this may change. */
8385         address_completion_end(compose->window);
8386
8387         slist_free_strings(compose->to_list);
8388         g_slist_free(compose->to_list);
8389         slist_free_strings(compose->newsgroup_list);
8390         g_slist_free(compose->newsgroup_list);
8391         slist_free_strings(compose->header_list);
8392         g_slist_free(compose->header_list);
8393
8394         compose->header_list = compose->newsgroup_list = compose->to_list = NULL;
8395
8396         g_hash_table_destroy(compose->email_hashtable);
8397
8398         procmsg_msginfo_free(compose->targetinfo);
8399         procmsg_msginfo_free(compose->replyinfo);
8400         procmsg_msginfo_free(compose->fwdinfo);
8401
8402         g_free(compose->replyto);
8403         g_free(compose->cc);
8404         g_free(compose->bcc);
8405         g_free(compose->newsgroups);
8406         g_free(compose->followup_to);
8407
8408         g_free(compose->ml_post);
8409
8410         g_free(compose->inreplyto);
8411         g_free(compose->references);
8412         g_free(compose->msgid);
8413         g_free(compose->boundary);
8414
8415         g_free(compose->redirect_filename);
8416         if (compose->undostruct)
8417                 undo_destroy(compose->undostruct);
8418
8419         g_free(compose->sig_str);
8420
8421         g_free(compose->exteditor_file);
8422
8423         g_free(compose->orig_charset);
8424
8425         g_free(compose->privacy_system);
8426
8427         if (addressbook_get_target_compose() == compose)
8428                 addressbook_set_target_compose(NULL);
8429
8430 #if USE_ENCHANT
8431         if (compose->gtkaspell) {
8432                 gtkaspell_delete(compose->gtkaspell);
8433                 compose->gtkaspell = NULL;
8434         }
8435 #endif
8436
8437         if (!compose->batch) {
8438                 gtk_widget_get_allocation(compose->scrolledwin, &allocation);
8439                 prefs_common.compose_width = allocation.width;
8440                 prefs_common.compose_height = allocation.height;
8441         }
8442
8443         if (!gtk_widget_get_parent(compose->paned))
8444                 gtk_widget_destroy(compose->paned);
8445         gtk_widget_destroy(compose->popupmenu);
8446
8447         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(compose->text));
8448         clipboard = gtk_clipboard_get(GDK_SELECTION_PRIMARY);
8449         gtk_text_buffer_remove_selection_clipboard(buffer, clipboard);
8450
8451         gtk_widget_destroy(compose->window);
8452         toolbar_destroy(compose->toolbar);
8453         g_free(compose->toolbar);
8454         g_mutex_free(compose->mutex);
8455         g_free(compose);
8456 }
8457
8458 static void compose_attach_info_free(AttachInfo *ainfo)
8459 {
8460         g_free(ainfo->file);
8461         g_free(ainfo->content_type);
8462         g_free(ainfo->name);
8463         g_free(ainfo->charset);
8464         g_free(ainfo);
8465 }
8466
8467 static void compose_attach_update_label(Compose *compose)
8468 {
8469         GtkTreeIter iter;
8470         gint i = 1;
8471         gchar *text;
8472         GtkTreeModel *model;
8473
8474         if(compose == NULL)
8475                 return;
8476
8477         model = gtk_tree_view_get_model(GTK_TREE_VIEW(compose->attach_clist));
8478         if(!gtk_tree_model_get_iter_first(model, &iter)) {
8479                 gtk_label_set_text(GTK_LABEL(compose->attach_label), "");
8480                 return;
8481         }
8482
8483         while(gtk_tree_model_iter_next(model, &iter))
8484                 i++;
8485
8486         text = g_strdup_printf("(%d)", i);
8487         gtk_label_set_text(GTK_LABEL(compose->attach_label), text);
8488         g_free(text);
8489 }
8490
8491 static void compose_attach_remove_selected(GtkAction *action, gpointer data)
8492 {
8493         Compose *compose = (Compose *)data;
8494         GtkTreeView *tree_view = GTK_TREE_VIEW(compose->attach_clist);
8495         GtkTreeSelection *selection;
8496         GList *sel, *cur;
8497         GtkTreeModel *model;
8498
8499         selection = gtk_tree_view_get_selection(tree_view);
8500         sel = gtk_tree_selection_get_selected_rows(selection, &model);
8501
8502         if (!sel)
8503                 return;
8504
8505         for (cur = sel; cur != NULL; cur = cur->next) {
8506                 GtkTreePath *path = cur->data;
8507                 GtkTreeRowReference *ref = gtk_tree_row_reference_new
8508                                                 (model, cur->data);
8509                 cur->data = ref;
8510                 gtk_tree_path_free(path);
8511         }
8512
8513         for (cur = sel; cur != NULL; cur = cur->next) {
8514                 GtkTreeRowReference *ref = cur->data;
8515                 GtkTreePath *path = gtk_tree_row_reference_get_path(ref);
8516                 GtkTreeIter iter;
8517
8518                 if (gtk_tree_model_get_iter(model, &iter, path))
8519                         gtk_list_store_remove(GTK_LIST_STORE(model), &iter);
8520
8521                 gtk_tree_path_free(path);
8522                 gtk_tree_row_reference_free(ref);
8523         }
8524
8525         g_list_free(sel);
8526         compose_attach_update_label(compose);
8527 }
8528
8529 static struct _AttachProperty
8530 {
8531         GtkWidget *window;
8532         GtkWidget *mimetype_entry;
8533         GtkWidget *encoding_optmenu;
8534         GtkWidget *path_entry;
8535         GtkWidget *filename_entry;
8536         GtkWidget *ok_btn;
8537         GtkWidget *cancel_btn;
8538 } attach_prop;
8539
8540 static void gtk_tree_path_free_(gpointer ptr, gpointer data)
8541 {
8542         gtk_tree_path_free((GtkTreePath *)ptr);
8543 }
8544
8545 static void compose_attach_property(GtkAction *action, gpointer data)
8546 {
8547         Compose *compose = (Compose *)data;
8548         GtkTreeView *tree_view = GTK_TREE_VIEW(compose->attach_clist);
8549         AttachInfo *ainfo;
8550         GtkComboBox *optmenu;
8551         GtkTreeSelection *selection;
8552         GList *sel;
8553         GtkTreeModel *model;
8554         GtkTreeIter iter;
8555         GtkTreePath *path;
8556         static gboolean cancelled;
8557
8558         /* only if one selected */
8559         selection = gtk_tree_view_get_selection(tree_view);
8560         if (gtk_tree_selection_count_selected_rows(selection) != 1)
8561                 return;
8562
8563         sel = gtk_tree_selection_get_selected_rows(selection, &model);
8564         if (!sel)
8565                 return;
8566
8567         path = (GtkTreePath *) sel->data;
8568         gtk_tree_model_get_iter(model, &iter, path);
8569         gtk_tree_model_get(model, &iter, COL_DATA, &ainfo, -1);
8570
8571         if (!ainfo) {
8572                 g_list_foreach(sel, gtk_tree_path_free_, NULL);
8573                 g_list_free(sel);
8574                 return;
8575         }
8576         g_list_free(sel);
8577
8578         if (!attach_prop.window)
8579                 compose_attach_property_create(&cancelled);
8580         gtk_window_set_modal(GTK_WINDOW(attach_prop.window), TRUE);
8581         gtk_widget_grab_focus(attach_prop.ok_btn);
8582         gtk_widget_show(attach_prop.window);
8583         manage_window_set_transient(GTK_WINDOW(attach_prop.window));
8584
8585         optmenu = GTK_COMBO_BOX(attach_prop.encoding_optmenu);
8586         if (ainfo->encoding == ENC_UNKNOWN)
8587                 combobox_select_by_data(optmenu, ENC_BASE64);
8588         else
8589                 combobox_select_by_data(optmenu, ainfo->encoding);
8590
8591         gtk_entry_set_text(GTK_ENTRY(attach_prop.mimetype_entry),
8592                            ainfo->content_type ? ainfo->content_type : "");
8593         gtk_entry_set_text(GTK_ENTRY(attach_prop.path_entry),
8594                            ainfo->file ? ainfo->file : "");
8595         gtk_entry_set_text(GTK_ENTRY(attach_prop.filename_entry),
8596                            ainfo->name ? ainfo->name : "");
8597
8598         for (;;) {
8599                 const gchar *entry_text;
8600                 gchar *text;
8601                 gchar *cnttype = NULL;
8602                 gchar *file = NULL;
8603                 off_t size = 0;
8604
8605                 cancelled = FALSE;
8606                 gtk_main();
8607
8608                 gtk_widget_hide(attach_prop.window);
8609                 gtk_window_set_modal(GTK_WINDOW(attach_prop.window), FALSE);
8610
8611                 if (cancelled)
8612                         break;
8613
8614                 entry_text = gtk_entry_get_text(GTK_ENTRY(attach_prop.mimetype_entry));
8615                 if (*entry_text != '\0') {
8616                         gchar *p;
8617
8618                         text = g_strstrip(g_strdup(entry_text));
8619                         if ((p = strchr(text, '/')) && !strchr(p + 1, '/')) {
8620                                 cnttype = g_strdup(text);
8621                                 g_free(text);
8622                         } else {
8623                                 alertpanel_error(_("Invalid MIME type."));
8624                                 g_free(text);
8625                                 continue;
8626                         }
8627                 }
8628
8629                 ainfo->encoding = combobox_get_active_data(optmenu);
8630
8631                 entry_text = gtk_entry_get_text(GTK_ENTRY(attach_prop.path_entry));
8632                 if (*entry_text != '\0') {
8633                         if (is_file_exist(entry_text) &&
8634                             (size = get_file_size(entry_text)) > 0)
8635                                 file = g_strdup(entry_text);
8636                         else {
8637                                 alertpanel_error
8638                                         (_("File doesn't exist or is empty."));
8639                                 g_free(cnttype);
8640                                 continue;
8641                         }
8642                 }
8643
8644                 entry_text = gtk_entry_get_text(GTK_ENTRY(attach_prop.filename_entry));
8645                 if (*entry_text != '\0') {
8646                         g_free(ainfo->name);
8647                         ainfo->name = g_strdup(entry_text);
8648                 }
8649
8650                 if (cnttype) {
8651                         g_free(ainfo->content_type);
8652                         ainfo->content_type = cnttype;
8653                 }
8654                 if (file) {
8655                         g_free(ainfo->file);
8656                         ainfo->file = file;
8657                 }
8658                 if (size)
8659                         ainfo->size = (goffset)size;
8660
8661                 /* update tree store */
8662                 text = to_human_readable(ainfo->size);
8663                 gtk_tree_model_get_iter(model, &iter, path);
8664                 gtk_list_store_set(GTK_LIST_STORE(model), &iter,
8665                                    COL_MIMETYPE, ainfo->content_type,
8666                                    COL_SIZE, text,
8667                                    COL_NAME, ainfo->name,
8668                                    COL_CHARSET, ainfo->charset,
8669                                    -1);
8670
8671                 break;
8672         }
8673
8674         gtk_tree_path_free(path);
8675 }
8676
8677 #define SET_LABEL_AND_ENTRY(str, entry, top) \
8678 { \
8679         label = gtk_label_new(str); \
8680         gtk_table_attach(GTK_TABLE(table), label, 0, 1, top, (top + 1), \
8681                          GTK_FILL, 0, 0, 0); \
8682         gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); \
8683  \
8684         entry = gtk_entry_new(); \
8685         gtk_table_attach(GTK_TABLE(table), entry, 1, 2, top, (top + 1), \
8686                          GTK_EXPAND|GTK_SHRINK|GTK_FILL, 0, 0, 0); \
8687 }
8688
8689 static void compose_attach_property_create(gboolean *cancelled)
8690 {
8691         GtkWidget *window;
8692         GtkWidget *vbox;
8693         GtkWidget *table;
8694         GtkWidget *label;
8695         GtkWidget *mimetype_entry;
8696         GtkWidget *hbox;
8697         GtkWidget *optmenu;
8698         GtkListStore *optmenu_menu;
8699         GtkWidget *path_entry;
8700         GtkWidget *filename_entry;
8701         GtkWidget *hbbox;
8702         GtkWidget *ok_btn;
8703         GtkWidget *cancel_btn;
8704         GList     *mime_type_list, *strlist;
8705         GtkTreeIter iter;
8706
8707         debug_print("Creating attach_property window...\n");
8708
8709         window = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "compose_attach_property");
8710         gtk_widget_set_size_request(window, 480, -1);
8711         gtk_container_set_border_width(GTK_CONTAINER(window), 8);
8712         gtk_window_set_title(GTK_WINDOW(window), _("Properties"));
8713         gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
8714         g_signal_connect(G_OBJECT(window), "delete_event",
8715                          G_CALLBACK(attach_property_delete_event),
8716                          cancelled);
8717         g_signal_connect(G_OBJECT(window), "key_press_event",
8718                          G_CALLBACK(attach_property_key_pressed),
8719                          cancelled);
8720
8721         vbox = gtk_vbox_new(FALSE, 8);
8722         gtk_container_add(GTK_CONTAINER(window), vbox);
8723
8724         table = gtk_table_new(4, 2, FALSE);
8725         gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0);
8726         gtk_table_set_row_spacings(GTK_TABLE(table), 8);
8727         gtk_table_set_col_spacings(GTK_TABLE(table), 8);
8728
8729         label = gtk_label_new(_("MIME type"));
8730         gtk_table_attach(GTK_TABLE(table), label, 0, 1, 0, (0 + 1),
8731                          GTK_FILL, 0, 0, 0);
8732         gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
8733         mimetype_entry = gtk_combo_box_entry_new_text();
8734         gtk_table_attach(GTK_TABLE(table), mimetype_entry, 1, 2, 0, (0 + 1),
8735                          GTK_EXPAND|GTK_SHRINK|GTK_FILL, 0, 0, 0);
8736
8737         /* stuff with list */
8738         mime_type_list = procmime_get_mime_type_list();
8739         strlist = NULL;
8740         for (; mime_type_list != NULL; mime_type_list = mime_type_list->next) {
8741                 MimeType *type = (MimeType *) mime_type_list->data;
8742                 gchar *tmp;
8743
8744                 tmp = g_strdup_printf("%s/%s", type->type, type->sub_type);
8745
8746                 if (g_list_find_custom(strlist, tmp, (GCompareFunc)strcmp2))
8747                         g_free(tmp);
8748                 else
8749                         strlist = g_list_insert_sorted(strlist, (gpointer)tmp,
8750                                         (GCompareFunc)strcmp2);
8751         }
8752
8753         for (mime_type_list = strlist; mime_type_list != NULL;
8754                 mime_type_list = mime_type_list->next) {
8755                 gtk_combo_box_append_text(GTK_COMBO_BOX(mimetype_entry), mime_type_list->data);
8756                 g_free(mime_type_list->data);
8757         }
8758         g_list_free(strlist);
8759         gtk_combo_box_set_active(GTK_COMBO_BOX(mimetype_entry), 0);
8760         mimetype_entry = gtk_bin_get_child(GTK_BIN((mimetype_entry)));
8761
8762         label = gtk_label_new(_("Encoding"));
8763         gtk_table_attach(GTK_TABLE(table), label, 0, 1, 1, 2,
8764                          GTK_FILL, 0, 0, 0);
8765         gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
8766
8767         hbox = gtk_hbox_new(FALSE, 0);
8768         gtk_table_attach(GTK_TABLE(table), hbox, 1, 2, 1, 2,
8769                          GTK_EXPAND|GTK_SHRINK|GTK_FILL, 0, 0, 0);
8770
8771         optmenu = gtkut_sc_combobox_create(NULL, TRUE);
8772         optmenu_menu = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(optmenu)));
8773
8774         COMBOBOX_ADD(optmenu_menu, "7bit", ENC_7BIT);
8775         COMBOBOX_ADD(optmenu_menu, "8bit", ENC_8BIT);
8776         COMBOBOX_ADD(optmenu_menu, "quoted-printable",  ENC_QUOTED_PRINTABLE);
8777         COMBOBOX_ADD(optmenu_menu, "base64", ENC_BASE64);
8778         gtk_combo_box_set_active(GTK_COMBO_BOX(optmenu), 0);
8779
8780         gtk_box_pack_start(GTK_BOX(hbox), optmenu, TRUE, TRUE, 0);
8781
8782         SET_LABEL_AND_ENTRY(_("Path"),      path_entry,     2);
8783         SET_LABEL_AND_ENTRY(_("File name"), filename_entry, 3);
8784
8785         gtkut_stock_button_set_create(&hbbox, &cancel_btn, GTK_STOCK_CANCEL,
8786                                       &ok_btn, GTK_STOCK_OK,
8787                                       NULL, NULL);
8788         gtk_box_pack_end(GTK_BOX(vbox), hbbox, FALSE, FALSE, 0);
8789         gtk_widget_grab_default(ok_btn);
8790
8791         g_signal_connect(G_OBJECT(ok_btn), "clicked",
8792                          G_CALLBACK(attach_property_ok),
8793                          cancelled);
8794         g_signal_connect(G_OBJECT(cancel_btn), "clicked",
8795                          G_CALLBACK(attach_property_cancel),
8796                          cancelled);
8797
8798         gtk_widget_show_all(vbox);
8799
8800         attach_prop.window           = window;
8801         attach_prop.mimetype_entry   = mimetype_entry;
8802         attach_prop.encoding_optmenu = optmenu;
8803         attach_prop.path_entry       = path_entry;
8804         attach_prop.filename_entry   = filename_entry;
8805         attach_prop.ok_btn           = ok_btn;
8806         attach_prop.cancel_btn       = cancel_btn;
8807 }
8808
8809 #undef SET_LABEL_AND_ENTRY
8810
8811 static void attach_property_ok(GtkWidget *widget, gboolean *cancelled)
8812 {
8813         *cancelled = FALSE;
8814         gtk_main_quit();
8815 }
8816
8817 static void attach_property_cancel(GtkWidget *widget, gboolean *cancelled)
8818 {
8819         *cancelled = TRUE;
8820         gtk_main_quit();
8821 }
8822
8823 static gint attach_property_delete_event(GtkWidget *widget, GdkEventAny *event,
8824                                          gboolean *cancelled)
8825 {
8826         *cancelled = TRUE;
8827         gtk_main_quit();
8828
8829         return TRUE;
8830 }
8831
8832 static gboolean attach_property_key_pressed(GtkWidget *widget,
8833                                             GdkEventKey *event,
8834                                             gboolean *cancelled)
8835 {
8836         if (event && event->keyval == GDK_KEY_Escape) {
8837                 *cancelled = TRUE;
8838                 gtk_main_quit();
8839         }
8840         if (event && event->keyval == GDK_KEY_Return) {
8841                 *cancelled = FALSE;
8842                 gtk_main_quit();
8843                 return TRUE;
8844         }
8845         return FALSE;
8846 }
8847
8848 static void compose_exec_ext_editor(Compose *compose)
8849 {
8850 #ifdef G_OS_UNIX
8851         gchar *tmp;
8852         pid_t pid;
8853         gint pipe_fds[2];
8854
8855         tmp = g_strdup_printf("%s%ctmpmsg.%p", get_tmp_dir(),
8856                               G_DIR_SEPARATOR, compose);
8857
8858         if (pipe(pipe_fds) < 0) {
8859                 perror("pipe");
8860                 g_free(tmp);
8861                 return;
8862         }
8863
8864         if ((pid = fork()) < 0) {
8865                 perror("fork");
8866                 g_free(tmp);
8867                 return;
8868         }
8869
8870         if (pid != 0) {
8871                 /* close the write side of the pipe */
8872                 close(pipe_fds[1]);
8873
8874                 compose->exteditor_file    = g_strdup(tmp);
8875                 compose->exteditor_pid     = pid;
8876
8877                 compose_set_ext_editor_sensitive(compose, FALSE);
8878
8879 #ifndef G_OS_WIN32
8880                 compose->exteditor_ch = g_io_channel_unix_new(pipe_fds[0]);
8881 #else
8882                 compose->exteditor_ch = g_io_channel_win32_new_fd(pipe_fds[0]);
8883 #endif
8884                 compose->exteditor_tag = g_io_add_watch(compose->exteditor_ch,
8885                                                         G_IO_IN,
8886                                                         compose_input_cb,
8887                                                         compose);
8888         } else {        /* process-monitoring process */
8889                 pid_t pid_ed;
8890
8891                 if (setpgid(0, 0))
8892                         perror("setpgid");
8893
8894                 /* close the read side of the pipe */
8895                 close(pipe_fds[0]);
8896
8897                 if (compose_write_body_to_file(compose, tmp) < 0) {
8898                         fd_write_all(pipe_fds[1], "2\n", 2);
8899                         _exit(1);
8900                 }
8901
8902                 pid_ed = compose_exec_ext_editor_real(tmp);
8903                 if (pid_ed < 0) {
8904                         fd_write_all(pipe_fds[1], "1\n", 2);
8905                         _exit(1);
8906                 }
8907
8908                 /* wait until editor is terminated */
8909                 waitpid(pid_ed, NULL, 0);
8910
8911                 fd_write_all(pipe_fds[1], "0\n", 2);
8912
8913                 close(pipe_fds[1]);
8914                 _exit(0);
8915         }
8916
8917         g_free(tmp);
8918 #endif /* G_OS_UNIX */
8919 }
8920
8921 #ifdef G_OS_UNIX
8922 static gint compose_exec_ext_editor_real(const gchar *file)
8923 {
8924         gchar buf[1024];
8925         gchar *p;
8926         gchar **cmdline;
8927         pid_t pid;
8928
8929         cm_return_val_if_fail(file != NULL, -1);
8930
8931         if ((pid = fork()) < 0) {
8932                 perror("fork");
8933                 return -1;
8934         }
8935
8936         if (pid != 0) return pid;
8937
8938         /* grandchild process */
8939
8940         if (setpgid(0, getppid()))
8941                 perror("setpgid");
8942
8943         if (prefs_common_get_ext_editor_cmd() &&
8944             (p = strchr(prefs_common_get_ext_editor_cmd(), '%')) &&
8945             *(p + 1) == 's' && !strchr(p + 2, '%')) {
8946                 g_snprintf(buf, sizeof(buf), prefs_common_get_ext_editor_cmd(), file);
8947         } else {
8948                 if (prefs_common_get_ext_editor_cmd())
8949                         g_warning("External editor command-line is invalid: '%s'\n",
8950                                   prefs_common_get_ext_editor_cmd());
8951                 g_snprintf(buf, sizeof(buf), DEFAULT_EDITOR_CMD, file);
8952         }
8953
8954         cmdline = strsplit_with_quote(buf, " ", 1024);
8955         execvp(cmdline[0], cmdline);
8956
8957         perror("execvp");
8958         g_strfreev(cmdline);
8959
8960         _exit(1);
8961 }
8962
8963 static gboolean compose_ext_editor_kill(Compose *compose)
8964 {
8965         pid_t pgid = compose->exteditor_pid * -1;
8966         gint ret;
8967
8968         ret = kill(pgid, 0);
8969
8970         if (ret == 0 || (ret == -1 && EPERM == errno)) {
8971                 AlertValue val;
8972                 gchar *msg;
8973
8974                 msg = g_strdup_printf
8975                         (_("The external editor is still working.\n"
8976                            "Force terminating the process?\n"
8977                            "process group id: %d"), -pgid);
8978                 val = alertpanel_full(_("Notice"), msg, GTK_STOCK_NO, GTK_STOCK_YES,
8979                                       NULL, FALSE, NULL, ALERT_WARNING, G_ALERTDEFAULT);
8980
8981                 g_free(msg);
8982
8983                 if (val == G_ALERTALTERNATE) {
8984                         g_source_remove(compose->exteditor_tag);
8985                         g_io_channel_shutdown(compose->exteditor_ch,
8986                                               FALSE, NULL);
8987                         g_io_channel_unref(compose->exteditor_ch);
8988
8989                         if (kill(pgid, SIGTERM) < 0) perror("kill");
8990                         waitpid(compose->exteditor_pid, NULL, 0);
8991
8992                         g_warning("Terminated process group id: %d", -pgid);
8993                         g_warning("Temporary file: %s",
8994                                   compose->exteditor_file);
8995
8996                         compose_set_ext_editor_sensitive(compose, TRUE);
8997
8998                         g_free(compose->exteditor_file);
8999                         compose->exteditor_file    = NULL;
9000                         compose->exteditor_pid     = -1;
9001                         compose->exteditor_ch      = NULL;
9002                         compose->exteditor_tag     = -1;
9003                 } else
9004                         return FALSE;
9005         }
9006
9007         return TRUE;
9008 }
9009
9010 static gboolean compose_input_cb(GIOChannel *source, GIOCondition condition,
9011                                  gpointer data)
9012 {
9013         gchar buf[3] = "3";
9014         Compose *compose = (Compose *)data;
9015         gsize bytes_read;
9016
9017         debug_print("Compose: input from monitoring process\n");
9018
9019         g_io_channel_read_chars(source, buf, sizeof(buf), &bytes_read, NULL);
9020
9021         g_io_channel_shutdown(source, FALSE, NULL);
9022         g_io_channel_unref(source);
9023
9024         waitpid(compose->exteditor_pid, NULL, 0);
9025
9026         if (buf[0] == '0') {            /* success */
9027                 GtkTextView *text = GTK_TEXT_VIEW(compose->text);
9028                 GtkTextBuffer *buffer = gtk_text_view_get_buffer(text);
9029
9030                 gtk_text_buffer_set_text(buffer, "", -1);
9031                 compose_insert_file(compose, compose->exteditor_file);
9032                 compose_changed_cb(NULL, compose);
9033                 compose_draft((gpointer)compose, COMPOSE_AUTO_SAVE);
9034
9035                 if (claws_unlink(compose->exteditor_file) < 0)
9036                         FILE_OP_ERROR(compose->exteditor_file, "unlink");
9037         } else if (buf[0] == '1') {     /* failed */
9038                 g_warning("Couldn't exec external editor\n");
9039                 if (claws_unlink(compose->exteditor_file) < 0)
9040                         FILE_OP_ERROR(compose->exteditor_file, "unlink");
9041         } else if (buf[0] == '2') {
9042                 g_warning("Couldn't write to file\n");
9043         } else if (buf[0] == '3') {
9044                 g_warning("Pipe read failed\n");
9045         }
9046
9047         compose_set_ext_editor_sensitive(compose, TRUE);
9048
9049         g_free(compose->exteditor_file);
9050         compose->exteditor_file    = NULL;
9051         compose->exteditor_pid     = -1;
9052         compose->exteditor_ch      = NULL;
9053         compose->exteditor_tag     = -1;
9054
9055         return FALSE;
9056 }
9057
9058 static void compose_set_ext_editor_sensitive(Compose *compose,
9059                                              gboolean sensitive)
9060 {
9061         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Message/Send", sensitive);
9062         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Message/SendLater", sensitive);
9063         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Message/InsertFile", sensitive);
9064         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Message/InsertSig", sensitive);
9065         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Edit/WrapPara", sensitive);
9066         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Edit/WrapAllLines", sensitive);
9067         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Edit/ExtEditor", sensitive);
9068
9069         gtk_widget_set_sensitive(compose->text,                       sensitive);
9070         if (compose->toolbar->send_btn)
9071                 gtk_widget_set_sensitive(compose->toolbar->send_btn,      sensitive);
9072         if (compose->toolbar->sendl_btn)
9073                 gtk_widget_set_sensitive(compose->toolbar->sendl_btn,     sensitive);
9074         if (compose->toolbar->draft_btn)
9075                 gtk_widget_set_sensitive(compose->toolbar->draft_btn,     sensitive);
9076         if (compose->toolbar->insert_btn)
9077                 gtk_widget_set_sensitive(compose->toolbar->insert_btn,    sensitive);
9078         if (compose->toolbar->sig_btn)
9079                 gtk_widget_set_sensitive(compose->toolbar->sig_btn,       sensitive);
9080         if (compose->toolbar->exteditor_btn)
9081                 gtk_widget_set_sensitive(compose->toolbar->exteditor_btn, sensitive);
9082         if (compose->toolbar->linewrap_current_btn)
9083                 gtk_widget_set_sensitive(compose->toolbar->linewrap_current_btn, sensitive);
9084         if (compose->toolbar->linewrap_all_btn)
9085                 gtk_widget_set_sensitive(compose->toolbar->linewrap_all_btn, sensitive);
9086 }
9087 #endif /* G_OS_UNIX */
9088
9089 /**
9090  * compose_undo_state_changed:
9091  *
9092  * Change the sensivity of the menuentries undo and redo
9093  **/
9094 static void compose_undo_state_changed(UndoMain *undostruct, gint undo_state,
9095                                        gint redo_state, gpointer data)
9096 {
9097         Compose *compose = (Compose *)data;
9098
9099         switch (undo_state) {
9100         case UNDO_STATE_TRUE:
9101                 if (!undostruct->undo_state) {
9102                         undostruct->undo_state = TRUE;
9103                         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Edit/Undo", TRUE);
9104                 }
9105                 break;
9106         case UNDO_STATE_FALSE:
9107                 if (undostruct->undo_state) {
9108                         undostruct->undo_state = FALSE;
9109                         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Edit/Undo", FALSE);
9110                 }
9111                 break;
9112         case UNDO_STATE_UNCHANGED:
9113                 break;
9114         case UNDO_STATE_REFRESH:
9115                 cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Edit/Undo", undostruct->undo_state);
9116                 break;
9117         default:
9118                 g_warning("Undo state not recognized");
9119                 break;
9120         }
9121
9122         switch (redo_state) {
9123         case UNDO_STATE_TRUE:
9124                 if (!undostruct->redo_state) {
9125                         undostruct->redo_state = TRUE;
9126                         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Edit/Redo", TRUE);
9127                 }
9128                 break;
9129         case UNDO_STATE_FALSE:
9130                 if (undostruct->redo_state) {
9131                         undostruct->redo_state = FALSE;
9132                         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Edit/Redo", FALSE);
9133                 }
9134                 break;
9135         case UNDO_STATE_UNCHANGED:
9136                 break;
9137         case UNDO_STATE_REFRESH:
9138                 cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Edit/Redo", undostruct->redo_state);
9139                 break;
9140         default:
9141                 g_warning("Redo state not recognized");
9142                 break;
9143         }
9144 }
9145
9146 /* callback functions */
9147
9148 /* compose_edit_size_alloc() - called when resized. don't know whether Gtk
9149  * includes "non-client" (windows-izm) in calculation, so this calculation
9150  * may not be accurate.
9151  */
9152 #if !GTK_CHECK_VERSION(2, 24, 0)
9153 static gboolean compose_edit_size_alloc(GtkEditable *widget,
9154                                         GtkAllocation *allocation,
9155                                         GtkSHRuler *shruler)
9156 {
9157         if (prefs_common.show_ruler) {
9158                 gint char_width = 0, char_height = 0;
9159                 gint line_width_in_chars;
9160
9161                 gtkut_get_font_size(GTK_WIDGET(widget),
9162                                     &char_width, &char_height);
9163                 line_width_in_chars =
9164                         (allocation->width - allocation->x) / char_width;
9165
9166                 /* got the maximum */
9167                 gtk_ruler_set_range(GTK_RULER(shruler),
9168                                     0.0, line_width_in_chars, 0,
9169                                     /*line_width_in_chars*/ char_width);
9170         }
9171
9172         return TRUE;
9173 }
9174 #endif
9175
9176 typedef struct {
9177         gchar                   *header;
9178         gchar                   *entry;
9179         ComposePrefType         type;
9180         gboolean                entry_marked;
9181 } HeaderEntryState;
9182
9183 static void account_activated(GtkComboBox *optmenu, gpointer data)
9184 {
9185         Compose *compose = (Compose *)data;
9186
9187         PrefsAccount *ac;
9188         gchar *folderidentifier;
9189         gint account_id = 0;
9190         GtkTreeModel *menu;
9191         GtkTreeIter iter;
9192         GSList *list, *saved_list = NULL;
9193         HeaderEntryState *state;
9194         GtkRcStyle *style = NULL;
9195         static GdkColor yellow;
9196         static gboolean color_set = FALSE;
9197
9198         /* Get ID of active account in the combo box */
9199         menu = gtk_combo_box_get_model(optmenu);
9200         gtk_combo_box_get_active_iter(optmenu, &iter);
9201         gtk_tree_model_get(menu, &iter, 1, &account_id, -1);
9202
9203         ac = account_find_from_id(account_id);
9204         cm_return_if_fail(ac != NULL);
9205
9206         if (ac != compose->account) {
9207                 compose_select_account(compose, ac, FALSE);
9208
9209                 for (list = compose->header_list; list; list = list->next) {
9210                         ComposeHeaderEntry *hentry=(ComposeHeaderEntry *)list->data;
9211
9212                         if (hentry->type == PREF_ACCOUNT || !list->next) {
9213                                 compose_destroy_headerentry(compose, hentry);
9214                                 continue;
9215                         }
9216
9217                         state = g_malloc0(sizeof(HeaderEntryState));
9218                         state->header = gtk_editable_get_chars(GTK_EDITABLE(
9219                                         gtk_bin_get_child(GTK_BIN(hentry->combo))), 0, -1);
9220                         state->entry = gtk_editable_get_chars(
9221                                         GTK_EDITABLE(hentry->entry), 0, -1);
9222                         state->type = hentry->type;
9223
9224                         if (!color_set) {
9225                                 gdk_color_parse("#f5f6be", &yellow);
9226                                 color_set = gdk_colormap_alloc_color(
9227                                                         gdk_colormap_get_system(),
9228                                                         &yellow, FALSE, TRUE);
9229                         }
9230
9231                         style = gtk_widget_get_modifier_style(hentry->entry);
9232                         state->entry_marked = gdk_color_equal(&yellow,
9233                                                 &style->base[GTK_STATE_NORMAL]);
9234
9235                         saved_list = g_slist_append(saved_list, state);
9236                         compose_destroy_headerentry(compose, hentry);
9237                 }
9238
9239                 compose->header_last = NULL;
9240                 g_slist_free(compose->header_list);
9241                 compose->header_list = NULL;
9242                 compose->header_nextrow = 1;
9243                 compose_create_header_entry(compose);
9244
9245                 if (ac->set_autocc && ac->auto_cc)
9246                         compose_entry_append(compose, ac->auto_cc,
9247                                                 COMPOSE_CC, PREF_ACCOUNT);
9248
9249                 if (ac->set_autobcc && ac->auto_bcc)
9250                         compose_entry_append(compose, ac->auto_bcc,
9251                                                 COMPOSE_BCC, PREF_ACCOUNT);
9252
9253                 if (ac->set_autoreplyto && ac->auto_replyto)
9254                         compose_entry_append(compose, ac->auto_replyto,
9255                                                 COMPOSE_REPLYTO, PREF_ACCOUNT);
9256
9257                 for (list = saved_list; list; list = list->next) {
9258                         state = (HeaderEntryState *) list->data;
9259
9260                         compose_add_header_entry(compose, state->header,
9261                                                 state->entry, state->type);
9262                         if (state->entry_marked)
9263                                 compose_entry_mark_default_to(compose, state->entry);
9264
9265                         g_free(state->header);
9266                         g_free(state->entry);
9267                         g_free(state);
9268                 }
9269                 g_slist_free(saved_list);
9270
9271                 combobox_select_by_data(GTK_COMBO_BOX(compose->header_last->combo),
9272                                         (ac->protocol == A_NNTP) ?
9273                                         COMPOSE_NEWSGROUPS : COMPOSE_TO);
9274         }
9275
9276         /* Set message save folder */
9277         if (account_get_special_folder(compose->account, F_OUTBOX)) {
9278                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(compose->savemsg_checkbtn), prefs_common.savemsg);
9279         }
9280         g_signal_connect(G_OBJECT(compose->savemsg_checkbtn), "toggled",
9281                          G_CALLBACK(compose_savemsg_checkbtn_cb), compose);
9282
9283         compose_set_save_to(compose, NULL);
9284         if (account_get_special_folder(compose->account, F_OUTBOX)) {
9285                 folderidentifier = folder_item_get_identifier(account_get_special_folder
9286                                   (compose->account, F_OUTBOX));
9287                 compose_set_save_to(compose, folderidentifier);
9288                 g_free(folderidentifier);
9289         }
9290 }
9291
9292 static void attach_selected(GtkTreeView *tree_view, GtkTreePath *tree_path,
9293                             GtkTreeViewColumn *column, Compose *compose)
9294 {
9295         compose_attach_property(NULL, compose);
9296 }
9297
9298 static gboolean attach_button_pressed(GtkWidget *widget, GdkEventButton *event,
9299                                       gpointer data)
9300 {
9301         Compose *compose = (Compose *)data;
9302         GtkTreeSelection *attach_selection;
9303         gint attach_nr_selected;
9304
9305         if (!event) return FALSE;
9306
9307         if (event->button == 3) {
9308                 attach_selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widget));
9309                 attach_nr_selected = gtk_tree_selection_count_selected_rows(attach_selection);
9310
9311                 if (attach_nr_selected > 0)
9312                 {
9313                         cm_menu_set_sensitive_full(compose->ui_manager, "Popup/Compose/Remove", TRUE);
9314                         cm_menu_set_sensitive_full(compose->ui_manager, "Popup/Compose/Properties", TRUE);
9315                 } else {
9316                         cm_menu_set_sensitive_full(compose->ui_manager, "Popup/Compose/Remove", FALSE);
9317                         cm_menu_set_sensitive_full(compose->ui_manager, "Popup/Compose/Properties", FALSE);
9318                 }
9319
9320                 gtk_menu_popup(GTK_MENU(compose->popupmenu), NULL, NULL,
9321                                NULL, NULL, event->button, event->time);
9322                 return TRUE;
9323         }
9324
9325         return FALSE;
9326 }
9327
9328 static gboolean attach_key_pressed(GtkWidget *widget, GdkEventKey *event,
9329                                    gpointer data)
9330 {
9331         Compose *compose = (Compose *)data;
9332
9333         if (!event) return FALSE;
9334
9335         switch (event->keyval) {
9336         case GDK_KEY_Delete:
9337                 compose_attach_remove_selected(NULL, compose);
9338                 break;
9339         }
9340         return FALSE;
9341 }
9342
9343 static void compose_allow_user_actions (Compose *compose, gboolean allow)
9344 {
9345         toolbar_comp_set_sensitive(compose, allow);
9346         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Message", allow);
9347         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Edit", allow);
9348 #if USE_ENCHANT
9349         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Spelling", allow);
9350 #endif
9351         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Options", allow);
9352         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Tools", allow);
9353         cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Help", allow);
9354
9355         gtk_text_view_set_editable(GTK_TEXT_VIEW(compose->text), allow);
9356
9357 }
9358
9359 static void compose_send_cb(GtkAction *action, gpointer data)
9360 {
9361         Compose *compose = (Compose *)data;
9362
9363         if (prefs_common.work_offline &&
9364             !inc_offline_should_override(TRUE,
9365                 _("Claws Mail needs network access in order "
9366                   "to send this email.")))
9367                 return;
9368
9369         if (compose->draft_timeout_tag >= 0) { /* CLAWS: disable draft timeout */
9370                 g_source_remove(compose->draft_timeout_tag);
9371                 compose->draft_timeout_tag = -1;
9372         }
9373
9374         compose_send(compose);
9375 }
9376
9377 static void compose_send_later_cb(GtkAction *action, gpointer data)
9378 {
9379         Compose *compose = (Compose *)data;
9380         gint val;
9381
9382         inc_lock();
9383         compose_allow_user_actions(compose, FALSE);
9384         val = compose_queue_sub(compose, NULL, NULL, NULL, TRUE, TRUE);
9385         compose_allow_user_actions(compose, TRUE);
9386         inc_unlock();
9387
9388         if (!val) {
9389                 compose_close(compose);
9390         } else if (val == -1) {
9391                 alertpanel_error(_("Could not queue message."));
9392         } else if (val == -2) {
9393                 alertpanel_error(_("Could not queue message:\n\n%s."), strerror(errno));
9394         } else if (val == -3) {
9395                 if (privacy_peek_error())
9396                 alertpanel_error(_("Could not queue message for sending:\n\n"
9397                                    "Signature failed: %s"), privacy_get_error());
9398         } else if (val == -4) {
9399                 alertpanel_error(_("Could not queue message for sending:\n\n"
9400                                    "Charset conversion failed."));
9401         } else if (val == -5) {
9402                 alertpanel_error(_("Could not queue message for sending:\n\n"
9403                                    "Couldn't get recipient encryption key."));
9404         } else if (val == -6) {
9405                 /* silent error */
9406         }
9407         toolbar_main_set_sensitive(mainwindow_get_mainwindow());
9408 }
9409
9410 #define DRAFTED_AT_EXIT "drafted_at_exit"
9411 static void compose_register_draft(MsgInfo *info)
9412 {
9413         gchar *filepath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
9414                                       DRAFTED_AT_EXIT, NULL);
9415         FILE *fp = g_fopen(filepath, "ab");
9416
9417         if (fp) {
9418                 fprintf(fp, "%s\t%d\n", folder_item_get_identifier(info->folder),
9419                                 info->msgnum);
9420                 fclose(fp);
9421         }
9422
9423         g_free(filepath);
9424 }
9425
9426 gboolean compose_draft (gpointer data, guint action)
9427 {
9428         Compose *compose = (Compose *)data;
9429         FolderItem *draft;
9430         gchar *tmp;
9431         gint msgnum;
9432         MsgFlags flag = {0, 0};
9433         static gboolean lock = FALSE;
9434         MsgInfo *newmsginfo;
9435         FILE *fp;
9436         gboolean target_locked = FALSE;
9437         gboolean err = FALSE;
9438
9439         if (lock) return FALSE;
9440
9441         if (compose->sending)
9442                 return TRUE;
9443
9444         draft = account_get_special_folder(compose->account, F_DRAFT);
9445         cm_return_val_if_fail(draft != NULL, FALSE);
9446
9447         if (!g_mutex_trylock(compose->mutex)) {
9448                 /* we don't want to lock the mutex once it's available,
9449                  * because as the only other part of compose.c locking
9450                  * it is compose_close - which means once unlocked,
9451                  * the compose struct will be freed */
9452                 debug_print("couldn't lock mutex, probably sending\n");
9453                 return FALSE;
9454         }
9455
9456         lock = TRUE;
9457
9458         tmp = g_strdup_printf("%s%cdraft.%p", get_tmp_dir(),
9459                               G_DIR_SEPARATOR, compose);
9460         if ((fp = g_fopen(tmp, "wb")) == NULL) {
9461                 FILE_OP_ERROR(tmp, "fopen");
9462                 goto warn_err;
9463         }
9464
9465         /* chmod for security */
9466         if (change_file_mode_rw(fp, tmp) < 0) {
9467                 FILE_OP_ERROR(tmp, "chmod");
9468                 g_warning("can't change file mode\n");
9469         }
9470
9471         /* Save draft infos */
9472         err |= (fprintf(fp, "X-Claws-Account-Id:%d\n", compose->account->account_id) < 0);
9473         err |= (fprintf(fp, "S:%s\n", compose->account->address) < 0);
9474
9475         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(compose->savemsg_checkbtn))) {
9476                 gchar *savefolderid;
9477
9478                 savefolderid = compose_get_save_to(compose);
9479                 err |= (fprintf(fp, "SCF:%s\n", savefolderid) < 0);
9480                 g_free(savefolderid);
9481         }
9482         if (compose->return_receipt) {
9483                 err |= (fprintf(fp, "RRCPT:1\n") < 0);
9484         }
9485         if (compose->privacy_system) {
9486                 err |= (fprintf(fp, "X-Claws-Sign:%d\n", compose->use_signing) < 0);
9487                 err |= (fprintf(fp, "X-Claws-Encrypt:%d\n", compose->use_encryption) < 0);
9488                 err |= (fprintf(fp, "X-Claws-Privacy-System:%s\n", compose->privacy_system) < 0);
9489         }
9490
9491         /* Message-ID of message replying to */
9492         if ((compose->replyinfo != NULL) && (compose->replyinfo->msgid != NULL)) {
9493                 gchar *folderid;
9494
9495                 folderid = folder_item_get_identifier(compose->replyinfo->folder);
9496                 err |= (fprintf(fp, "RMID:%s\t%d\t%s\n", folderid, compose->replyinfo->msgnum, compose->replyinfo->msgid) < 0);
9497                 g_free(folderid);
9498         }
9499         /* Message-ID of message forwarding to */
9500         if ((compose->fwdinfo != NULL) && (compose->fwdinfo->msgid != NULL)) {
9501                 gchar *folderid;
9502
9503                 folderid = folder_item_get_identifier(compose->fwdinfo->folder);
9504                 err |= (fprintf(fp, "FMID:%s\t%d\t%s\n", folderid, compose->fwdinfo->msgnum, compose->fwdinfo->msgid) < 0);
9505                 g_free(folderid);
9506         }
9507
9508         err |= (fprintf(fp, "X-Claws-Auto-Wrapping:%d\n", compose->autowrap) < 0);
9509         err |= (fprintf(fp, "X-Claws-Auto-Indent:%d\n", compose->autoindent) < 0);
9510
9511         /* end of headers */
9512         err |= (fprintf(fp, "X-Claws-End-Special-Headers: 1\n") < 0);
9513
9514         if (err) {
9515                 fclose(fp);
9516                 goto warn_err;
9517         }
9518
9519         if (compose_write_to_file(compose, fp, COMPOSE_WRITE_FOR_STORE, action != COMPOSE_AUTO_SAVE) < 0) {
9520                 fclose(fp);
9521                 goto warn_err;
9522         }
9523         if (fclose(fp) == EOF) {
9524                 goto warn_err;
9525         }
9526
9527         if (compose->targetinfo) {
9528                 target_locked = MSG_IS_LOCKED(compose->targetinfo->flags);
9529                 flag.perm_flags = target_locked?MSG_LOCKED:0;
9530         }
9531         flag.tmp_flags = MSG_DRAFT;
9532
9533         folder_item_scan(draft);
9534         if ((msgnum = folder_item_add_msg(draft, tmp, &flag, TRUE)) < 0) {
9535                 MsgInfo *tmpinfo = NULL;
9536                 debug_print("didn't get msgnum after adding draft [%s]\n", compose->msgid?compose->msgid:"no msgid");
9537                 if (compose->msgid) {
9538                         tmpinfo = folder_item_get_msginfo_by_msgid(draft, compose->msgid);
9539                 }
9540                 if (tmpinfo) {
9541                         msgnum = tmpinfo->msgnum;
9542                         procmsg_msginfo_free(tmpinfo);
9543                         debug_print("got draft msgnum %d from scanning\n", msgnum);
9544                 } else {
9545                         debug_print("didn't get draft msgnum after scanning\n");
9546                 }
9547         } else {
9548                 debug_print("got draft msgnum %d from adding\n", msgnum);
9549         }
9550         if (msgnum < 0) {
9551 warn_err:
9552                 claws_unlink(tmp);
9553                 g_free(tmp);
9554                 if (action != COMPOSE_AUTO_SAVE) {
9555                         if (action != COMPOSE_DRAFT_FOR_EXIT)
9556                                 alertpanel_error(_("Could not save draft."));
9557                         else {
9558                                 AlertValue val;
9559                                 gtkut_window_popup(compose->window);
9560                                 val = alertpanel_full(_("Could not save draft"),
9561                                         _("Could not save draft.\n"
9562                                         "Do you want to cancel exit or discard this email?"),
9563                                           _("_Cancel exit"), _("_Discard email"), NULL,
9564                                           FALSE, NULL, ALERT_QUESTION, G_ALERTDEFAULT);
9565                                 if (val == G_ALERTALTERNATE) {
9566                                         lock = FALSE;
9567                                         g_mutex_unlock(compose->mutex); /* must be done before closing */
9568                                         compose_close(compose);
9569                                         return TRUE;
9570                                 } else {
9571                                         lock = FALSE;
9572                                         g_mutex_unlock(compose->mutex); /* must be done before closing */
9573                                         return FALSE;
9574                                 }
9575                         }
9576                 }
9577                 goto unlock;
9578         }
9579         g_free(tmp);
9580
9581         if (compose->mode == COMPOSE_REEDIT) {
9582                 compose_remove_reedit_target(compose, TRUE);
9583         }
9584
9585         newmsginfo = folder_item_get_msginfo(draft, msgnum);
9586
9587         if (newmsginfo) {
9588                 procmsg_msginfo_unset_flags(newmsginfo, ~0, ~0);
9589                 if (target_locked)
9590                         procmsg_msginfo_set_flags(newmsginfo, MSG_LOCKED, MSG_DRAFT);
9591                 else
9592                         procmsg_msginfo_set_flags(newmsginfo, 0, MSG_DRAFT);
9593                 if (compose_use_attach(compose) && action != COMPOSE_AUTO_SAVE)
9594                         procmsg_msginfo_set_flags(newmsginfo, 0,
9595                                                   MSG_HAS_ATTACHMENT);
9596
9597                 if (action == COMPOSE_DRAFT_FOR_EXIT) {
9598                         compose_register_draft(newmsginfo);
9599                 }
9600                 procmsg_msginfo_free(newmsginfo);
9601         }
9602
9603         folder_item_scan(draft);
9604
9605         if (action == COMPOSE_QUIT_EDITING || action == COMPOSE_DRAFT_FOR_EXIT) {
9606                 lock = FALSE;
9607                 g_mutex_unlock(compose->mutex); /* must be done before closing */
9608                 compose_close(compose);
9609                 return TRUE;
9610         } else {
9611                 struct stat s;
9612                 gchar *path;
9613
9614                 path = folder_item_fetch_msg(draft, msgnum);
9615                 if (path == NULL) {
9616                         debug_print("can't fetch %s:%d\n", draft->path, msgnum);
9617                         goto unlock;
9618                 }
9619                 if (g_stat(path, &s) < 0) {
9620                         FILE_OP_ERROR(path, "stat");
9621                         g_free(path);
9622                         goto unlock;
9623                 }
9624                 g_free(path);
9625
9626                 procmsg_msginfo_free(compose->targetinfo);
9627                 compose->targetinfo = procmsg_msginfo_new();
9628                 compose->targetinfo->msgnum = msgnum;
9629                 compose->targetinfo->size = (goffset)s.st_size;
9630                 compose->targetinfo->mtime = s.st_mtime;
9631                 compose->targetinfo->folder = draft;
9632                 if (target_locked)
9633                         procmsg_msginfo_set_flags(compose->targetinfo, MSG_LOCKED, 0);
9634                 compose->mode = COMPOSE_REEDIT;
9635
9636                 if (action == COMPOSE_AUTO_SAVE) {
9637                         compose->autosaved_draft = compose->targetinfo;
9638                 }
9639                 compose->modified = FALSE;
9640                 compose_set_title(compose);
9641         }
9642 unlock:
9643         lock = FALSE;
9644         g_mutex_unlock(compose->mutex);
9645         return TRUE;
9646 }
9647
9648 void compose_clear_exit_drafts(void)
9649 {
9650         gchar *filepath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
9651                                       DRAFTED_AT_EXIT, NULL);
9652         if (is_file_exist(filepath))
9653                 claws_unlink(filepath);
9654
9655         g_free(filepath);
9656 }
9657
9658 void compose_reopen_exit_drafts(void)
9659 {
9660         gchar *filepath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
9661                                       DRAFTED_AT_EXIT, NULL);
9662         FILE *fp = g_fopen(filepath, "rb");
9663         gchar buf[1024];
9664
9665         if (fp) {
9666                 while (fgets(buf, sizeof(buf), fp)) {
9667                         gchar **parts = g_strsplit(buf, "\t", 2);
9668                         const gchar *folder = parts[0];
9669                         int msgnum = parts[1] ? atoi(parts[1]):-1;
9670
9671                         if (folder && *folder && msgnum > -1) {
9672                                 FolderItem *item = folder_find_item_from_identifier(folder);
9673                                 MsgInfo *info = folder_item_get_msginfo(item, msgnum);
9674                                 if (info)
9675                                         compose_reedit(info, FALSE);
9676                         }
9677                         g_strfreev(parts);
9678                 }
9679                 fclose(fp);
9680         }
9681         g_free(filepath);
9682         compose_clear_exit_drafts();
9683 }
9684
9685 static void compose_save_cb(GtkAction *action, gpointer data)
9686 {
9687         Compose *compose = (Compose *)data;
9688         compose_draft(compose, COMPOSE_KEEP_EDITING);
9689         compose->rmode = COMPOSE_REEDIT;
9690 }
9691
9692 void compose_attach_from_list(Compose *compose, GList *file_list, gboolean free_data)
9693 {
9694         if (compose && file_list) {
9695                 GList *tmp;
9696
9697                 for ( tmp = file_list; tmp; tmp = tmp->next) {
9698                         gchar *file = (gchar *) tmp->data;
9699                         gchar *utf8_filename = conv_filename_to_utf8(file);
9700                         compose_attach_append(compose, file, utf8_filename, NULL, NULL);
9701                         compose_changed_cb(NULL, compose);
9702                         if (free_data) {
9703                         g_free(file);
9704                                 tmp->data = NULL;
9705                         }
9706                         g_free(utf8_filename);
9707                 }
9708         }
9709 }
9710
9711 static void compose_attach_cb(GtkAction *action, gpointer data)
9712 {
9713         Compose *compose = (Compose *)data;
9714         GList *file_list;
9715
9716         if (compose->redirect_filename != NULL)
9717                 return;
9718
9719         file_list = filesel_select_multiple_files_open(_("Select file"));
9720
9721         if (file_list) {
9722                 compose_attach_from_list(compose, file_list, TRUE);
9723                 g_list_free(file_list);
9724         }
9725 }
9726
9727 static void compose_insert_file_cb(GtkAction *action, gpointer data)
9728 {
9729         Compose *compose = (Compose *)data;
9730         GList *file_list;
9731         gint files_inserted = 0;
9732
9733         file_list = filesel_select_multiple_files_open(_("Select file"));
9734
9735         if (file_list) {
9736                 GList *tmp;
9737
9738                 for ( tmp = file_list; tmp; tmp = tmp->next) {
9739                         gchar *file = (gchar *) tmp->data;
9740                         gchar *filedup = g_strdup(file);
9741                         gchar *shortfile = g_path_get_basename(filedup);
9742                         ComposeInsertResult res;
9743                         /* insert the file if the file is short or if the user confirmed that
9744                            he/she wants to insert the large file */
9745                         res = compose_insert_file(compose, file);
9746                         if (res == COMPOSE_INSERT_READ_ERROR) {
9747                                 alertpanel_error(_("File '%s' could not be read."), shortfile);
9748                         } else if (res == COMPOSE_INSERT_INVALID_CHARACTER) {
9749                                 alertpanel_error(_("File '%s' contained invalid characters\n"
9750                                                         "for the current encoding, insertion may be incorrect."),
9751                                                         shortfile);
9752                         } else if (res == COMPOSE_INSERT_SUCCESS)
9753                                 files_inserted++;
9754
9755                         g_free(shortfile);
9756                         g_free(filedup);
9757                         g_free(file);
9758                 }
9759                 g_list_free(file_list);
9760         }
9761
9762 #ifdef USE_ENCHANT
9763         if (files_inserted > 0 && compose->gtkaspell &&
9764             compose->gtkaspell->check_while_typing)
9765                 gtkaspell_highlight_all(compose->gtkaspell);
9766 #endif
9767 }
9768
9769 static void compose_insert_sig_cb(GtkAction *action, gpointer data)
9770 {
9771         Compose *compose = (Compose *)data;
9772
9773         compose_insert_sig(compose, FALSE);
9774 }
9775
9776 static gint compose_delete_cb(GtkWidget *widget, GdkEventAny *event,
9777                               gpointer data)
9778 {
9779         gint x, y;
9780         Compose *compose = (Compose *)data;
9781
9782         gtkut_widget_get_uposition(widget, &x, &y);
9783         if (!compose->batch) {
9784                 prefs_common.compose_x = x;
9785                 prefs_common.compose_y = y;
9786         }
9787         if (compose->sending || compose->updating)
9788                 return TRUE;
9789         compose_close_cb(NULL, compose);
9790         return TRUE;
9791 }
9792
9793 void compose_close_toolbar(Compose *compose)
9794 {
9795         compose_close_cb(NULL, compose);
9796 }
9797
9798 static void compose_close_cb(GtkAction *action, gpointer data)
9799 {
9800         Compose *compose = (Compose *)data;
9801         AlertValue val;
9802
9803 #ifdef G_OS_UNIX
9804         if (compose->exteditor_tag != -1) {
9805                 if (!compose_ext_editor_kill(compose))
9806                         return;
9807         }
9808 #endif
9809
9810         if (compose->modified) {
9811                 gboolean reedit = (compose->rmode == COMPOSE_REEDIT);
9812                 if (!g_mutex_trylock(compose->mutex)) {
9813                         /* we don't want to lock the mutex once it's available,
9814                          * because as the only other part of compose.c locking
9815                          * it is compose_close - which means once unlocked,
9816                          * the compose struct will be freed */
9817                         debug_print("couldn't lock mutex, probably sending\n");
9818                         return;
9819                 }
9820                 if (!reedit) {
9821                         val = alertpanel(_("Discard message"),
9822                                  _("This message has been modified. Discard it?"),
9823                                  _("_Discard"), _("_Save to Drafts"), GTK_STOCK_CANCEL);
9824                 } else {
9825                         val = alertpanel(_("Save changes"),
9826                                  _("This message has been modified. Save the latest changes?"),
9827                                  _("_Don't save"), _("+_Save to Drafts"), GTK_STOCK_CANCEL);
9828                 }
9829                 g_mutex_unlock(compose->mutex);
9830                 switch (val) {
9831                 case G_ALERTDEFAULT:
9832                         if (prefs_common.autosave && !reedit)
9833                                 compose_remove_draft(compose);
9834                         break;
9835                 case G_ALERTALTERNATE:
9836                         compose_draft(data, COMPOSE_QUIT_EDITING);
9837                         return;
9838                 default:
9839                         return;
9840                 }
9841         }
9842
9843         compose_close(compose);
9844 }
9845
9846 static void compose_set_encoding_cb(GtkAction *action, GtkRadioAction *current, gpointer data)
9847 {
9848         gboolean active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (current));
9849         gint value = gtk_radio_action_get_current_value (GTK_RADIO_ACTION (current));
9850         Compose *compose = (Compose *) data;
9851
9852         if (active)
9853                 compose->out_encoding = (CharSet)value;
9854 }
9855
9856 static void compose_address_cb(GtkAction *action, gpointer data)
9857 {
9858         Compose *compose = (Compose *)data;
9859
9860         addressbook_open(compose);
9861 }
9862
9863 static void about_show_cb(GtkAction *action, gpointer data)
9864 {
9865         about_show();
9866 }
9867
9868 static void compose_template_activate_cb(GtkWidget *widget, gpointer data)
9869 {
9870         Compose *compose = (Compose *)data;
9871         Template *tmpl;
9872         gchar *msg;
9873         AlertValue val;
9874
9875         tmpl = g_object_get_data(G_OBJECT(widget), "template");
9876         cm_return_if_fail(tmpl != NULL);
9877
9878         msg = g_strdup_printf(_("Do you want to apply the template '%s' ?"),
9879                               tmpl->name);
9880         val = alertpanel(_("Apply template"), msg,
9881                          _("_Replace"), _("_Insert"), GTK_STOCK_CANCEL);
9882         g_free(msg);
9883
9884         if (val == G_ALERTDEFAULT)
9885                 compose_template_apply(compose, tmpl, TRUE);
9886         else if (val == G_ALERTALTERNATE)
9887                 compose_template_apply(compose, tmpl, FALSE);
9888 }
9889
9890 static void compose_ext_editor_cb(GtkAction *action, gpointer data)
9891 {
9892         Compose *compose = (Compose *)data;
9893
9894         compose_exec_ext_editor(compose);
9895 }
9896
9897 static void compose_undo_cb(GtkAction *action, gpointer data)
9898 {
9899         Compose *compose = (Compose *)data;
9900         gboolean prev_autowrap = compose->autowrap;
9901
9902         compose->autowrap = FALSE;
9903         undo_undo(compose->undostruct);
9904         compose->autowrap = prev_autowrap;
9905 }
9906
9907 static void compose_redo_cb(GtkAction *action, gpointer data)
9908 {
9909         Compose *compose = (Compose *)data;
9910         gboolean prev_autowrap = compose->autowrap;
9911
9912         compose->autowrap = FALSE;
9913         undo_redo(compose->undostruct);
9914         compose->autowrap = prev_autowrap;
9915 }
9916
9917 static void entry_cut_clipboard(GtkWidget *entry)
9918 {
9919         if (GTK_IS_EDITABLE(entry))
9920                 gtk_editable_cut_clipboard (GTK_EDITABLE(entry));
9921         else if (GTK_IS_TEXT_VIEW(entry))
9922                 gtk_text_buffer_cut_clipboard(
9923                         gtk_text_view_get_buffer(GTK_TEXT_VIEW(entry)),
9924                         gtk_clipboard_get(GDK_SELECTION_CLIPBOARD),
9925                         TRUE);
9926 }
9927
9928 static void entry_copy_clipboard(GtkWidget *entry)
9929 {
9930         if (GTK_IS_EDITABLE(entry))
9931                 gtk_editable_copy_clipboard (GTK_EDITABLE(entry));
9932         else if (GTK_IS_TEXT_VIEW(entry))
9933                 gtk_text_buffer_copy_clipboard(
9934                         gtk_text_view_get_buffer(GTK_TEXT_VIEW(entry)),
9935                         gtk_clipboard_get(GDK_SELECTION_CLIPBOARD));
9936 }
9937
9938 static void entry_paste_clipboard(Compose *compose, GtkWidget *entry,
9939                                   gboolean wrap, GdkAtom clip, GtkTextIter *insert_place)
9940 {
9941         if (GTK_IS_TEXT_VIEW(entry)) {
9942                 GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(entry));
9943                 GtkTextMark *mark_start = gtk_text_buffer_get_insert(buffer);
9944                 GtkTextIter start_iter, end_iter;
9945                 gint start, end;
9946                 gchar *contents = gtk_clipboard_wait_for_text(gtk_clipboard_get(clip));
9947
9948                 if (contents == NULL)
9949                         return;
9950
9951                 /* we shouldn't delete the selection when middle-click-pasting, or we
9952                  * can't mid-click-paste our own selection */
9953                 if (clip != GDK_SELECTION_PRIMARY) {
9954                         undo_paste_clipboard(GTK_TEXT_VIEW(compose->text), compose->undostruct);
9955                         gtk_text_buffer_delete_selection(buffer, FALSE, TRUE);
9956                 }
9957
9958                 if (insert_place == NULL) {
9959                         /* if insert_place isn't specified, insert at the cursor.
9960                          * used for Ctrl-V pasting */
9961                         gtk_text_buffer_get_iter_at_mark(buffer, &start_iter, mark_start);
9962                         start = gtk_text_iter_get_offset(&start_iter);
9963                         gtk_text_buffer_insert(buffer, &start_iter, contents, strlen(contents));
9964                 } else {
9965                         /* if insert_place is specified, paste here.
9966                          * used for mid-click-pasting */
9967                         start = gtk_text_iter_get_offset(insert_place);
9968                         gtk_text_buffer_insert(buffer, insert_place, contents, strlen(contents));
9969                         if (prefs_common.primary_paste_unselects)
9970                                 gtk_text_buffer_select_range(buffer, insert_place, insert_place);
9971                 }
9972
9973                 if (!wrap) {
9974                         /* paste unwrapped: mark the paste so it's not wrapped later */
9975                         end = start + strlen(contents);
9976                         gtk_text_buffer_get_iter_at_offset(buffer, &start_iter, start);
9977                         gtk_text_buffer_get_iter_at_offset(buffer, &end_iter, end);
9978                         gtk_text_buffer_apply_tag_by_name(buffer, "no_wrap", &start_iter, &end_iter);
9979                 } else if (wrap && clip == GDK_SELECTION_PRIMARY) {
9980                         /* rewrap paragraph now (after a mid-click-paste) */
9981                         mark_start = gtk_text_buffer_get_insert(buffer);
9982                         gtk_text_buffer_get_iter_at_mark(buffer, &start_iter, mark_start);
9983                         gtk_text_iter_backward_char(&start_iter);
9984                         compose_beautify_paragraph(compose, &start_iter, TRUE);
9985                 }
9986         } else if (GTK_IS_EDITABLE(entry))
9987                 gtk_editable_paste_clipboard (GTK_EDITABLE(entry));
9988
9989         compose->modified = TRUE;
9990 }
9991
9992 static void entry_allsel(GtkWidget *entry)
9993 {
9994         if (GTK_IS_EDITABLE(entry))
9995                 gtk_editable_select_region(GTK_EDITABLE(entry), 0, -1);
9996         else if (GTK_IS_TEXT_VIEW(entry)) {
9997                 GtkTextIter startiter, enditer;
9998                 GtkTextBuffer *textbuf;
9999
10000                 textbuf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(entry));
10001                 gtk_text_buffer_get_start_iter(textbuf, &startiter);
10002                 gtk_text_buffer_get_end_iter(textbuf, &enditer);
10003
10004                 gtk_text_buffer_move_mark_by_name(textbuf,
10005                         "selection_bound", &startiter);
10006                 gtk_text_buffer_move_mark_by_name(textbuf,
10007                         "insert", &enditer);
10008         }
10009 }
10010
10011 static void compose_cut_cb(GtkAction *action, gpointer data)
10012 {
10013         Compose *compose = (Compose *)data;
10014         if (compose->focused_editable
10015 #ifndef GENERIC_UMPC
10016             && gtkut_widget_has_focus(compose->focused_editable)
10017 #endif
10018             )
10019                 entry_cut_clipboard(compose->focused_editable);
10020 }
10021
10022 static void compose_copy_cb(GtkAction *action, gpointer data)
10023 {
10024         Compose *compose = (Compose *)data;
10025         if (compose->focused_editable
10026 #ifndef GENERIC_UMPC
10027             && gtkut_widget_has_focus(compose->focused_editable)
10028 #endif
10029             )
10030                 entry_copy_clipboard(compose->focused_editable);
10031 }
10032
10033 static void compose_paste_cb(GtkAction *action, gpointer data)
10034 {
10035         Compose *compose = (Compose *)data;
10036         gint prev_autowrap;
10037         GtkTextBuffer *buffer;
10038         BLOCK_WRAP();
10039         if (compose->focused_editable &&
10040             gtkut_widget_has_focus(compose->focused_editable))
10041                 entry_paste_clipboard(compose, compose->focused_editable,
10042                                 prefs_common.linewrap_pastes,
10043                                 GDK_SELECTION_CLIPBOARD, NULL);
10044         UNBLOCK_WRAP();
10045
10046 #ifdef USE_ENCHANT
10047         if (gtkut_widget_has_focus(compose->text) &&
10048             compose->gtkaspell &&
10049             compose->gtkaspell->check_while_typing)
10050                 gtkaspell_highlight_all(compose->gtkaspell);
10051 #endif
10052 }
10053
10054 static void compose_paste_as_quote_cb(GtkAction *action, gpointer data)
10055 {
10056         Compose *compose = (Compose *)data;
10057         gint wrap_quote = prefs_common.linewrap_quote;
10058         if (compose->focused_editable
10059 #ifndef GENERIC_UMPC
10060             && gtkut_widget_has_focus(compose->focused_editable)
10061 #endif
10062             ) {
10063                 /* let text_insert() (called directly or at a later time
10064                  * after the gtk_editable_paste_clipboard) know that
10065                  * text is to be inserted as a quotation. implemented
10066                  * by using a simple refcount... */
10067                 gint paste_as_quotation = GPOINTER_TO_INT(g_object_get_data(
10068                                                 G_OBJECT(compose->focused_editable),
10069                                                 "paste_as_quotation"));
10070                 g_object_set_data(G_OBJECT(compose->focused_editable),
10071                                     "paste_as_quotation",
10072                                     GINT_TO_POINTER(paste_as_quotation + 1));
10073                 prefs_common.linewrap_quote = prefs_common.linewrap_pastes;
10074                 entry_paste_clipboard(compose, compose->focused_editable,
10075                                 prefs_common.linewrap_pastes,
10076                                 GDK_SELECTION_CLIPBOARD, NULL);
10077                 prefs_common.linewrap_quote = wrap_quote;
10078         }
10079 }
10080
10081 static void compose_paste_no_wrap_cb(GtkAction *action, gpointer data)
10082 {
10083         Compose *compose = (Compose *)data;
10084         gint prev_autowrap;
10085         GtkTextBuffer *buffer;
10086         BLOCK_WRAP();
10087         if (compose->focused_editable
10088 #ifndef GENERIC_UMPC
10089             && gtkut_widget_has_focus(compose->focused_editable)
10090 #endif
10091             )
10092                 entry_paste_clipboard(compose, compose->focused_editable, FALSE,
10093                         GDK_SELECTION_CLIPBOARD, NULL);
10094         UNBLOCK_WRAP();
10095
10096 #ifdef USE_ENCHANT
10097         if (gtkut_widget_has_focus(compose->text) &&
10098             compose->gtkaspell &&
10099             compose->gtkaspell->check_while_typing)
10100                 gtkaspell_highlight_all(compose->gtkaspell);
10101 #endif
10102 }
10103
10104 static void compose_paste_wrap_cb(GtkAction *action, gpointer data)
10105 {
10106         Compose *compose = (Compose *)data;
10107         gint prev_autowrap;
10108         GtkTextBuffer *buffer;
10109         BLOCK_WRAP();
10110         if (compose->focused_editable
10111 #ifndef GENERIC_UMPC
10112             && gtkut_widget_has_focus(compose->focused_editable)
10113 #endif
10114             )
10115                 entry_paste_clipboard(compose, compose->focused_editable, TRUE,
10116                         GDK_SELECTION_CLIPBOARD, NULL);
10117         UNBLOCK_WRAP();
10118
10119 #ifdef USE_ENCHANT
10120         if (gtkut_widget_has_focus(compose->text) &&
10121             compose->gtkaspell &&
10122             compose->gtkaspell->check_while_typing)
10123                 gtkaspell_highlight_all(compose->gtkaspell);
10124 #endif
10125 }
10126
10127 static void compose_allsel_cb(GtkAction *action, gpointer data)
10128 {
10129         Compose *compose = (Compose *)data;
10130         if (compose->focused_editable
10131 #ifndef GENERIC_UMPC
10132             && gtkut_widget_has_focus(compose->focused_editable)
10133 #endif
10134             )
10135                 entry_allsel(compose->focused_editable);
10136 }
10137
10138 static void textview_move_beginning_of_line (GtkTextView *text)
10139 {
10140         GtkTextBuffer *buffer;
10141         GtkTextMark *mark;
10142         GtkTextIter ins;
10143
10144         cm_return_if_fail(GTK_IS_TEXT_VIEW(text));
10145
10146         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
10147         mark = gtk_text_buffer_get_insert(buffer);
10148         gtk_text_buffer_get_iter_at_mark(buffer, &ins, mark);
10149         gtk_text_iter_set_line_offset(&ins, 0);
10150         gtk_text_buffer_place_cursor(buffer, &ins);
10151 }
10152
10153 static void textview_move_forward_character (GtkTextView *text)
10154 {
10155         GtkTextBuffer *buffer;
10156         GtkTextMark *mark;
10157         GtkTextIter ins;
10158
10159         cm_return_if_fail(GTK_IS_TEXT_VIEW(text));
10160
10161         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
10162         mark = gtk_text_buffer_get_insert(buffer);
10163         gtk_text_buffer_get_iter_at_mark(buffer, &ins, mark);
10164         if (gtk_text_iter_forward_cursor_position(&ins))
10165                 gtk_text_buffer_place_cursor(buffer, &ins);
10166 }
10167
10168 static void textview_move_backward_character (GtkTextView *text)
10169 {
10170         GtkTextBuffer *buffer;
10171         GtkTextMark *mark;
10172         GtkTextIter ins;
10173
10174         cm_return_if_fail(GTK_IS_TEXT_VIEW(text));
10175
10176         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
10177         mark = gtk_text_buffer_get_insert(buffer);
10178         gtk_text_buffer_get_iter_at_mark(buffer, &ins, mark);
10179         if (gtk_text_iter_backward_cursor_position(&ins))
10180                 gtk_text_buffer_place_cursor(buffer, &ins);
10181 }
10182
10183 static void textview_move_forward_word (GtkTextView *text)
10184 {
10185         GtkTextBuffer *buffer;
10186         GtkTextMark *mark;
10187         GtkTextIter ins;
10188         gint count;
10189
10190         cm_return_if_fail(GTK_IS_TEXT_VIEW(text));
10191
10192         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
10193         mark = gtk_text_buffer_get_insert(buffer);
10194         gtk_text_buffer_get_iter_at_mark(buffer, &ins, mark);
10195         count = gtk_text_iter_inside_word (&ins) ? 2 : 1;
10196         if (gtk_text_iter_forward_word_ends(&ins, count)) {
10197                 gtk_text_iter_backward_word_start(&ins);
10198                 gtk_text_buffer_place_cursor(buffer, &ins);
10199         }
10200 }
10201
10202 static void textview_move_backward_word (GtkTextView *text)
10203 {
10204         GtkTextBuffer *buffer;
10205         GtkTextMark *mark;
10206         GtkTextIter ins;
10207         gint count;
10208
10209         cm_return_if_fail(GTK_IS_TEXT_VIEW(text));
10210
10211         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
10212         mark = gtk_text_buffer_get_insert(buffer);
10213         gtk_text_buffer_get_iter_at_mark(buffer, &ins, mark);
10214         count = gtk_text_iter_inside_word (&ins) ? 2 : 1;
10215         if (gtk_text_iter_backward_word_starts(&ins, 1))
10216                 gtk_text_buffer_place_cursor(buffer, &ins);
10217 }
10218
10219 static void textview_move_end_of_line (GtkTextView *text)
10220 {
10221         GtkTextBuffer *buffer;
10222         GtkTextMark *mark;
10223         GtkTextIter ins;
10224
10225         cm_return_if_fail(GTK_IS_TEXT_VIEW(text));
10226
10227         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
10228         mark = gtk_text_buffer_get_insert(buffer);
10229         gtk_text_buffer_get_iter_at_mark(buffer, &ins, mark);
10230         if (gtk_text_iter_forward_to_line_end(&ins))
10231                 gtk_text_buffer_place_cursor(buffer, &ins);
10232 }
10233
10234 static void textview_move_next_line (GtkTextView *text)
10235 {
10236         GtkTextBuffer *buffer;
10237         GtkTextMark *mark;
10238         GtkTextIter ins;
10239         gint offset;
10240
10241         cm_return_if_fail(GTK_IS_TEXT_VIEW(text));
10242
10243         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
10244         mark = gtk_text_buffer_get_insert(buffer);
10245         gtk_text_buffer_get_iter_at_mark(buffer, &ins, mark);
10246         offset = gtk_text_iter_get_line_offset(&ins);
10247         if (gtk_text_iter_forward_line(&ins)) {
10248                 gtk_text_iter_set_line_offset(&ins, offset);
10249                 gtk_text_buffer_place_cursor(buffer, &ins);
10250         }
10251 }
10252
10253 static void textview_move_previous_line (GtkTextView *text)
10254 {
10255         GtkTextBuffer *buffer;
10256         GtkTextMark *mark;
10257         GtkTextIter ins;
10258         gint offset;
10259
10260         cm_return_if_fail(GTK_IS_TEXT_VIEW(text));
10261
10262         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
10263         mark = gtk_text_buffer_get_insert(buffer);
10264         gtk_text_buffer_get_iter_at_mark(buffer, &ins, mark);
10265         offset = gtk_text_iter_get_line_offset(&ins);
10266         if (gtk_text_iter_backward_line(&ins)) {
10267                 gtk_text_iter_set_line_offset(&ins, offset);
10268                 gtk_text_buffer_place_cursor(buffer, &ins);
10269         }
10270 }
10271
10272 static void textview_delete_forward_character (GtkTextView *text)
10273 {
10274         GtkTextBuffer *buffer;
10275         GtkTextMark *mark;
10276         GtkTextIter ins, end_iter;
10277
10278         cm_return_if_fail(GTK_IS_TEXT_VIEW(text));
10279
10280         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
10281         mark = gtk_text_buffer_get_insert(buffer);
10282         gtk_text_buffer_get_iter_at_mark(buffer, &ins, mark);
10283         end_iter = ins;
10284         if (gtk_text_iter_forward_char(&end_iter)) {
10285                 gtk_text_buffer_delete(buffer, &ins, &end_iter);
10286         }
10287 }
10288
10289 static void textview_delete_backward_character (GtkTextView *text)
10290 {
10291         GtkTextBuffer *buffer;
10292         GtkTextMark *mark;
10293         GtkTextIter ins, end_iter;
10294
10295         cm_return_if_fail(GTK_IS_TEXT_VIEW(text));
10296
10297         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
10298         mark = gtk_text_buffer_get_insert(buffer);
10299         gtk_text_buffer_get_iter_at_mark(buffer, &ins, mark);
10300         end_iter = ins;
10301         if (gtk_text_iter_backward_char(&end_iter)) {
10302                 gtk_text_buffer_delete(buffer, &end_iter, &ins);
10303         }
10304 }
10305
10306 static void textview_delete_forward_word (GtkTextView *text)
10307 {
10308         GtkTextBuffer *buffer;
10309         GtkTextMark *mark;
10310         GtkTextIter ins, end_iter;
10311
10312         cm_return_if_fail(GTK_IS_TEXT_VIEW(text));
10313
10314         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
10315         mark = gtk_text_buffer_get_insert(buffer);
10316         gtk_text_buffer_get_iter_at_mark(buffer, &ins, mark);
10317         end_iter = ins;
10318         if (gtk_text_iter_forward_word_end(&end_iter)) {
10319                 gtk_text_buffer_delete(buffer, &ins, &end_iter);
10320         }
10321 }
10322
10323 static void textview_delete_backward_word (GtkTextView *text)
10324 {
10325         GtkTextBuffer *buffer;
10326         GtkTextMark *mark;
10327         GtkTextIter ins, end_iter;
10328
10329         cm_return_if_fail(GTK_IS_TEXT_VIEW(text));
10330
10331         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
10332         mark = gtk_text_buffer_get_insert(buffer);
10333         gtk_text_buffer_get_iter_at_mark(buffer, &ins, mark);
10334         end_iter = ins;
10335         if (gtk_text_iter_backward_word_start(&end_iter)) {
10336                 gtk_text_buffer_delete(buffer, &end_iter, &ins);
10337         }
10338 }
10339
10340 static void textview_delete_line (GtkTextView *text)
10341 {
10342         GtkTextBuffer *buffer;
10343         GtkTextMark *mark;
10344         GtkTextIter ins, start_iter, end_iter;
10345
10346         cm_return_if_fail(GTK_IS_TEXT_VIEW(text));
10347
10348         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
10349         mark = gtk_text_buffer_get_insert(buffer);
10350         gtk_text_buffer_get_iter_at_mark(buffer, &ins, mark);
10351
10352         start_iter = ins;
10353         gtk_text_iter_set_line_offset(&start_iter, 0);
10354
10355         end_iter = ins;
10356         if (gtk_text_iter_ends_line(&end_iter)){
10357                 if (!gtk_text_iter_forward_char(&end_iter))
10358                         gtk_text_iter_backward_char(&start_iter);
10359         }
10360         else
10361                 gtk_text_iter_forward_to_line_end(&end_iter);
10362         gtk_text_buffer_delete(buffer, &start_iter, &end_iter);
10363 }
10364
10365 static void textview_delete_to_line_end (GtkTextView *text)
10366 {
10367         GtkTextBuffer *buffer;
10368         GtkTextMark *mark;
10369         GtkTextIter ins, end_iter;
10370
10371         cm_return_if_fail(GTK_IS_TEXT_VIEW(text));
10372
10373         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
10374         mark = gtk_text_buffer_get_insert(buffer);
10375         gtk_text_buffer_get_iter_at_mark(buffer, &ins, mark);
10376         end_iter = ins;
10377         if (gtk_text_iter_ends_line(&end_iter))
10378                 gtk_text_iter_forward_char(&end_iter);
10379         else
10380                 gtk_text_iter_forward_to_line_end(&end_iter);
10381         gtk_text_buffer_delete(buffer, &ins, &end_iter);
10382 }
10383
10384 #define DO_ACTION(name, act) {                                          \
10385         if(!strcmp(name, a_name)) {                                     \
10386                 return act;                                             \
10387         }                                                               \
10388 }
10389 static ComposeCallAdvancedAction compose_call_advanced_action_from_path(GtkAction *action)
10390 {
10391         const gchar *a_name = gtk_action_get_name(action);
10392         DO_ACTION("Edit/Advanced/BackChar", COMPOSE_CALL_ADVANCED_ACTION_MOVE_BACKWARD_CHARACTER);
10393         DO_ACTION("Edit/Advanced/ForwChar", COMPOSE_CALL_ADVANCED_ACTION_MOVE_FORWARD_CHARACTER);
10394         DO_ACTION("Edit/Advanced/BackWord", COMPOSE_CALL_ADVANCED_ACTION_MOVE_BACKWARD_WORD);
10395         DO_ACTION("Edit/Advanced/ForwWord", COMPOSE_CALL_ADVANCED_ACTION_MOVE_FORWARD_WORD);
10396         DO_ACTION("Edit/Advanced/BegLine", COMPOSE_CALL_ADVANCED_ACTION_MOVE_BEGINNING_OF_LINE);
10397         DO_ACTION("Edit/Advanced/EndLine", COMPOSE_CALL_ADVANCED_ACTION_MOVE_END_OF_LINE);
10398         DO_ACTION("Edit/Advanced/PrevLine", COMPOSE_CALL_ADVANCED_ACTION_MOVE_PREVIOUS_LINE);
10399         DO_ACTION("Edit/Advanced/NextLine", COMPOSE_CALL_ADVANCED_ACTION_MOVE_NEXT_LINE);
10400         DO_ACTION("Edit/Advanced/DelBackChar", COMPOSE_CALL_ADVANCED_ACTION_DELETE_BACKWARD_CHARACTER);
10401         DO_ACTION("Edit/Advanced/DelForwChar", COMPOSE_CALL_ADVANCED_ACTION_DELETE_FORWARD_CHARACTER);
10402         DO_ACTION("Edit/Advanced/DelBackWord", COMPOSE_CALL_ADVANCED_ACTION_DELETE_BACKWARD_WORD);
10403         DO_ACTION("Edit/Advanced/DelForwWord", COMPOSE_CALL_ADVANCED_ACTION_DELETE_FORWARD_WORD);
10404         DO_ACTION("Edit/Advanced/DelLine", COMPOSE_CALL_ADVANCED_ACTION_DELETE_LINE);
10405         DO_ACTION("Edit/Advanced/DelEndLine", COMPOSE_CALL_ADVANCED_ACTION_DELETE_TO_LINE_END);
10406         return -1;
10407 }
10408
10409 static void compose_advanced_action_cb(GtkAction *gaction, gpointer data)
10410 {
10411         Compose *compose = (Compose *)data;
10412         GtkTextView *text = GTK_TEXT_VIEW(compose->text);
10413         ComposeCallAdvancedAction action = -1;
10414
10415         action = compose_call_advanced_action_from_path(gaction);
10416
10417         static struct {
10418                 void (*do_action) (GtkTextView *text);
10419         } action_table[] = {
10420                 {textview_move_beginning_of_line},
10421                 {textview_move_forward_character},
10422                 {textview_move_backward_character},
10423                 {textview_move_forward_word},
10424                 {textview_move_backward_word},
10425                 {textview_move_end_of_line},
10426                 {textview_move_next_line},
10427                 {textview_move_previous_line},
10428                 {textview_delete_forward_character},
10429                 {textview_delete_backward_character},
10430                 {textview_delete_forward_word},
10431                 {textview_delete_backward_word},
10432                 {textview_delete_line},
10433                 {textview_delete_to_line_end}
10434         };
10435
10436         if (!gtkut_widget_has_focus(GTK_WIDGET(text))) return;
10437
10438         if (action >= COMPOSE_CALL_ADVANCED_ACTION_MOVE_BEGINNING_OF_LINE &&
10439             action <= COMPOSE_CALL_ADVANCED_ACTION_DELETE_TO_LINE_END) {
10440                 if (action_table[action].do_action)
10441                         action_table[action].do_action(text);
10442                 else
10443                         g_warning("Not implemented yet.");
10444         }
10445 }
10446
10447 static void compose_grab_focus_cb(GtkWidget *widget, Compose *compose)
10448 {
10449         GtkAllocation allocation;
10450         GtkWidget *parent;
10451         gchar *str = NULL;
10452
10453         if (GTK_IS_EDITABLE(widget)) {
10454                 str = gtk_editable_get_chars(GTK_EDITABLE(widget), 0, -1);
10455                 gtk_editable_set_position(GTK_EDITABLE(widget),
10456                         strlen(str));
10457                 g_free(str);
10458                 if ((parent = gtk_widget_get_parent(widget))
10459                  && (parent = gtk_widget_get_parent(parent))
10460                  && (parent = gtk_widget_get_parent(parent))) {
10461                         if (GTK_IS_SCROLLED_WINDOW(parent)) {
10462                                 gtk_widget_get_allocation(widget, &allocation);
10463                                 gint y = allocation.y;
10464                                 gint height = allocation.height;
10465                                 GtkAdjustment *shown = gtk_scrolled_window_get_vadjustment
10466                                         (GTK_SCROLLED_WINDOW(parent));
10467
10468                                 gfloat value = gtk_adjustment_get_value(shown);
10469                                 gfloat upper = gtk_adjustment_get_upper(shown);
10470                                 gfloat page_size = gtk_adjustment_get_page_size(shown);
10471                                 if (y < (int)value) {
10472                                         gtk_adjustment_set_value(shown, y - 1);
10473                                 }
10474                                 if ((y + height) > ((int)value + (int)page_size)) {
10475                                         if ((y - height - 1) < ((int)upper - (int)page_size)) {
10476                                                 gtk_adjustment_set_value(shown,
10477                                                         y + height - (int)page_size - 1);
10478                                         } else {
10479                                                 gtk_adjustment_set_value(shown,
10480                                                         (int)upper - (int)page_size - 1);
10481                                         }
10482                                 }
10483                         }
10484                 }
10485         }
10486
10487         if (GTK_IS_EDITABLE(widget) || GTK_IS_TEXT_VIEW(widget))
10488                 compose->focused_editable = widget;
10489
10490 #ifdef GENERIC_UMPC
10491         if (GTK_IS_TEXT_VIEW(widget)
10492             && gtk_paned_get_child1(GTK_PANED(compose->paned)) != compose->edit_vbox) {
10493                 g_object_ref(compose->notebook);
10494                 g_object_ref(compose->edit_vbox);
10495                 gtk_container_remove(GTK_CONTAINER(compose->paned), compose->notebook);
10496                 gtk_container_remove(GTK_CONTAINER(compose->paned), compose->edit_vbox);
10497                 gtk_paned_add1(GTK_PANED(compose->paned), compose->edit_vbox);
10498                 gtk_paned_add2(GTK_PANED(compose->paned), compose->notebook);
10499                 g_object_unref(compose->notebook);
10500                 g_object_unref(compose->edit_vbox);
10501                 g_signal_handlers_block_by_func(G_OBJECT(widget),
10502                                         G_CALLBACK(compose_grab_focus_cb),
10503                                         compose);
10504                 gtk_widget_grab_focus(widget);
10505                 g_signal_handlers_unblock_by_func(G_OBJECT(widget),
10506                                         G_CALLBACK(compose_grab_focus_cb),
10507                                         compose);
10508         } else if (!GTK_IS_TEXT_VIEW(widget)
10509                    && gtk_paned_get_child1(GTK_PANED(compose->paned)) != compose->notebook) {
10510                 g_object_ref(compose->notebook);
10511                 g_object_ref(compose->edit_vbox);
10512                 gtk_container_remove(GTK_CONTAINER(compose->paned), compose->notebook);
10513                 gtk_container_remove(GTK_CONTAINER(compose->paned), compose->edit_vbox);
10514                 gtk_paned_add1(GTK_PANED(compose->paned), compose->notebook);
10515                 gtk_paned_add2(GTK_PANED(compose->paned), compose->edit_vbox);
10516                 g_object_unref(compose->notebook);
10517                 g_object_unref(compose->edit_vbox);
10518                 g_signal_handlers_block_by_func(G_OBJECT(widget),
10519                                         G_CALLBACK(compose_grab_focus_cb),
10520                                         compose);
10521                 gtk_widget_grab_focus(widget);
10522                 g_signal_handlers_unblock_by_func(G_OBJECT(widget),
10523                                         G_CALLBACK(compose_grab_focus_cb),
10524                                         compose);
10525         }
10526 #endif
10527 }
10528
10529 static void compose_changed_cb(GtkTextBuffer *textbuf, Compose *compose)
10530 {
10531         compose->modified = TRUE;
10532 //      compose_beautify_paragraph(compose, NULL, TRUE);
10533 #ifndef GENERIC_UMPC
10534         compose_set_title(compose);
10535 #endif
10536 }
10537
10538 static void compose_wrap_cb(GtkAction *action, gpointer data)
10539 {
10540         Compose *compose = (Compose *)data;
10541         compose_beautify_paragraph(compose, NULL, TRUE);
10542 }
10543
10544 static void compose_wrap_all_cb(GtkAction *action, gpointer data)
10545 {
10546         Compose *compose = (Compose *)data;
10547         compose_wrap_all_full(compose, TRUE);
10548 }
10549
10550 static void compose_find_cb(GtkAction *action, gpointer data)
10551 {
10552         Compose *compose = (Compose *)data;
10553
10554         message_search_compose(compose);
10555 }
10556
10557 static void compose_toggle_autowrap_cb(GtkToggleAction *action,
10558                                          gpointer        data)
10559 {
10560         Compose *compose = (Compose *)data;
10561         compose->autowrap = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
10562         if (compose->autowrap)
10563                 compose_wrap_all_full(compose, TRUE);
10564         compose->autowrap = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
10565 }
10566
10567 static void compose_toggle_autoindent_cb(GtkToggleAction *action,
10568                                          gpointer        data)
10569 {
10570         Compose *compose = (Compose *)data;
10571         compose->autoindent = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
10572 }
10573
10574 static void compose_toggle_sign_cb(GtkToggleAction *action, gpointer data)
10575 {
10576         Compose *compose = (Compose *)data;
10577
10578         compose->use_signing = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
10579 }
10580
10581 static void compose_toggle_encrypt_cb(GtkToggleAction *action, gpointer data)
10582 {
10583         Compose *compose = (Compose *)data;
10584
10585         compose->use_encryption = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
10586 }
10587
10588 static void activate_privacy_system(Compose *compose, PrefsAccount *account, gboolean warn)
10589 {
10590         g_free(compose->privacy_system);
10591
10592         compose->privacy_system = g_strdup(account->default_privacy_system);
10593         compose_update_privacy_system_menu_item(compose, warn);
10594 }
10595
10596 #if !GTK_CHECK_VERSION(2, 24, 0)
10597 static void compose_toggle_ruler_cb(GtkToggleAction *action, gpointer data)
10598 {
10599         Compose *compose = (Compose *)data;
10600
10601         if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action))) {
10602                 gtk_widget_show(compose->ruler_hbox);
10603                 prefs_common.show_ruler = TRUE;
10604         } else {
10605                 gtk_widget_hide(compose->ruler_hbox);
10606                 gtk_widget_queue_resize(compose->edit_vbox);
10607                 prefs_common.show_ruler = FALSE;
10608         }
10609 }
10610 #endif
10611
10612 static void compose_attach_drag_received_cb (GtkWidget          *widget,
10613                                              GdkDragContext     *context,
10614                                              gint                x,
10615                                              gint                y,
10616                                              GtkSelectionData   *data,
10617                                              guint               info,
10618                                              guint               time,
10619                                              gpointer            user_data)
10620 {
10621         Compose *compose = (Compose *)user_data;
10622         GList *list, *tmp;
10623         GdkAtom type;
10624
10625         type = gtk_selection_data_get_data_type(data);
10626         if (((gdk_atom_name(type) && !strcmp(gdk_atom_name(type), "text/uri-list"))
10627 #ifdef G_OS_WIN32
10628          || (gdk_atom_name(type) && !strcmp(gdk_atom_name(type), "DROPFILES_DND"))
10629 #endif
10630            ) && gtk_drag_get_source_widget(context) !=
10631                 summary_get_main_widget(mainwindow_get_mainwindow()->summaryview)) {
10632                 list = uri_list_extract_filenames(
10633                         (const gchar *)gtk_selection_data_get_data(data));
10634                 for (tmp = list; tmp != NULL; tmp = tmp->next) {
10635                         gchar *utf8_filename = conv_filename_to_utf8((const gchar *)tmp->data);
10636                         compose_attach_append
10637                                 (compose, (const gchar *)tmp->data,
10638                                  utf8_filename, NULL, NULL);
10639                         g_free(utf8_filename);
10640                 }
10641                 if (list) compose_changed_cb(NULL, compose);
10642                 list_free_strings(list);
10643                 g_list_free(list);
10644         } else if (gtk_drag_get_source_widget(context)
10645                    == summary_get_main_widget(mainwindow_get_mainwindow()->summaryview)) {
10646                 /* comes from our summaryview */
10647                 SummaryView * summaryview = NULL;
10648                 GSList * list = NULL, *cur = NULL;
10649
10650                 if (mainwindow_get_mainwindow())
10651                         summaryview = mainwindow_get_mainwindow()->summaryview;
10652
10653                 if (summaryview)
10654                         list = summary_get_selected_msg_list(summaryview);
10655
10656                 for (cur = list; cur; cur = cur->next) {
10657                         MsgInfo *msginfo = (MsgInfo *)cur->data;
10658                         gchar *file = NULL;
10659                         if (msginfo)
10660                                 file = procmsg_get_message_file_full(msginfo,
10661                                         TRUE, TRUE);
10662                         if (file) {
10663                                 compose_attach_append(compose, (const gchar *)file,
10664                                         (const gchar *)file, "message/rfc822", NULL);
10665                                 g_free(file);
10666                         }
10667                 }
10668                 g_slist_free(list);
10669         }
10670 }
10671
10672 static gboolean compose_drag_drop(GtkWidget *widget,
10673                                   GdkDragContext *drag_context,
10674                                   gint x, gint y,
10675                                   guint time, gpointer user_data)
10676 {
10677         /* not handling this signal makes compose_insert_drag_received_cb
10678          * called twice */
10679         return TRUE;
10680 }
10681
10682 static void compose_insert_drag_received_cb (GtkWidget          *widget,
10683                                              GdkDragContext     *drag_context,
10684                                              gint                x,
10685                                              gint                y,
10686                                              GtkSelectionData   *data,
10687                                              guint               info,
10688                                              guint               time,
10689                                              gpointer            user_data)
10690 {
10691         Compose *compose = (Compose *)user_data;
10692         GList *list, *tmp;
10693         GdkAtom type;
10694
10695         /* strangely, testing data->type == gdk_atom_intern("text/uri-list", TRUE)
10696          * does not work */
10697         type = gtk_selection_data_get_data_type(data);
10698 #ifndef G_OS_WIN32
10699         if (gdk_atom_name(type) && !strcmp(gdk_atom_name(type), "text/uri-list")) {
10700 #else
10701         if (gdk_atom_name(type) && !strcmp(gdk_atom_name(type), "DROPFILES_DND")) {
10702 #endif
10703                 AlertValue val = G_ALERTDEFAULT;
10704                 const gchar* ddata = (const gchar *)gtk_selection_data_get_data(data);
10705
10706                 list = uri_list_extract_filenames(ddata);
10707                 if (list == NULL && strstr(ddata, "://")) {
10708                         /* Assume a list of no files, and data has ://, is a remote link */
10709                         gchar *tmpdata = g_strstrip(g_strdup(ddata));
10710                         gchar *tmpfile = get_tmp_file();
10711                         str_write_to_file(tmpdata, tmpfile);
10712                         g_free(tmpdata);
10713                         compose_insert_file(compose, tmpfile);
10714                         claws_unlink(tmpfile);
10715                         g_free(tmpfile);
10716                         gtk_drag_finish(drag_context, TRUE, FALSE, time);
10717                         compose_beautify_paragraph(compose, NULL, TRUE);
10718                         return;
10719                 }
10720                 switch (prefs_common.compose_dnd_mode) {
10721                         case COMPOSE_DND_ASK:
10722                                 val = alertpanel_full(_("Insert or attach?"),
10723                                          _("Do you want to insert the contents of the file(s) "
10724                                            "into the message body, or attach it to the email?"),
10725                                           GTK_STOCK_CANCEL, _("+_Insert"), _("_Attach"),
10726                                           TRUE, NULL, ALERT_QUESTION, G_ALERTALTERNATE);
10727                                 break;
10728                         case COMPOSE_DND_INSERT:
10729                                 val = G_ALERTALTERNATE;
10730                                 break;
10731                         case COMPOSE_DND_ATTACH:
10732                                 val = G_ALERTOTHER;
10733                                 break;
10734                         default:
10735                                 /* unexpected case */
10736                                 g_warning("error: unexpected compose_dnd_mode option value in compose_insert_drag_received_cb()");
10737                 }
10738
10739                 if (val & G_ALERTDISABLE) {
10740                         val &= ~G_ALERTDISABLE;
10741                         /* remember what action to perform by default, only if we don't click Cancel */
10742                         if (val == G_ALERTALTERNATE)
10743                                 prefs_common.compose_dnd_mode = COMPOSE_DND_INSERT;
10744                         else if (val == G_ALERTOTHER)
10745                                         prefs_common.compose_dnd_mode = COMPOSE_DND_ATTACH;
10746                 }
10747
10748                 if (val == G_ALERTDEFAULT || val == G_ALERTCANCEL) {
10749                         gtk_drag_finish(drag_context, FALSE, FALSE, time);
10750                         list_free_strings(list);
10751                         g_list_free(list);
10752                         return;
10753                 } else if (val == G_ALERTOTHER) {
10754                         compose_attach_drag_received_cb(widget, drag_context, x, y, data, info, time, user_data);
10755                         list_free_strings(list);
10756                         g_list_free(list);
10757                         return;
10758                 }
10759
10760                 for (tmp = list; tmp != NULL; tmp = tmp->next) {
10761                         compose_insert_file(compose, (const gchar *)tmp->data);
10762                 }
10763                 list_free_strings(list);
10764                 g_list_free(list);
10765                 gtk_drag_finish(drag_context, TRUE, FALSE, time);
10766                 return;
10767         } else {
10768                 return;
10769         }
10770         gtk_drag_finish(drag_context, TRUE, FALSE, time);
10771 }
10772
10773 static void compose_header_drag_received_cb (GtkWidget          *widget,
10774                                              GdkDragContext     *drag_context,
10775                                              gint                x,
10776                                              gint                y,
10777                                              GtkSelectionData   *data,
10778                                              guint               info,
10779                                              guint               time,
10780                                              gpointer            user_data)
10781 {
10782         GtkEditable *entry = (GtkEditable *)user_data;
10783         const gchar *email = (const gchar *)gtk_selection_data_get_data(data);
10784
10785         /* strangely, testing data->type == gdk_atom_intern("text/plain", TRUE)
10786          * does not work */
10787
10788         if (!strncmp(email, "mailto:", strlen("mailto:"))) {
10789                 gchar *decoded=g_new(gchar, strlen(email));
10790                 int start = 0;
10791
10792                 decode_uri(decoded, email + strlen("mailto:")); /* will fit */
10793                 gtk_editable_delete_text(entry, 0, -1);
10794                 gtk_editable_insert_text(entry, decoded, strlen(decoded), &start);
10795                 gtk_drag_finish(drag_context, TRUE, FALSE, time);
10796                 g_free(decoded);
10797                 return;
10798         }
10799         gtk_drag_finish(drag_context, TRUE, FALSE, time);
10800 }
10801
10802 static void compose_toggle_return_receipt_cb(GtkToggleAction *action, gpointer data)
10803 {
10804         Compose *compose = (Compose *)data;
10805
10806         if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)))
10807                 compose->return_receipt = TRUE;
10808         else
10809                 compose->return_receipt = FALSE;
10810 }
10811
10812 static void compose_toggle_remove_refs_cb(GtkToggleAction *action, gpointer data)
10813 {
10814         Compose *compose = (Compose *)data;
10815
10816         if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)))
10817                 compose->remove_references = TRUE;
10818         else
10819                 compose->remove_references = FALSE;
10820 }
10821
10822 static gboolean compose_headerentry_button_clicked_cb (GtkWidget *button,
10823                                         ComposeHeaderEntry *headerentry)
10824 {
10825         gtk_entry_set_text(GTK_ENTRY(headerentry->entry), "");
10826         return FALSE;
10827 }
10828
10829 static gboolean compose_headerentry_key_press_event_cb(GtkWidget *entry,
10830                                             GdkEventKey *event,
10831                                             ComposeHeaderEntry *headerentry)
10832 {
10833         if ((g_slist_length(headerentry->compose->header_list) > 0) &&
10834             ((headerentry->headernum + 1) != headerentry->compose->header_nextrow) &&
10835             !(event->state & GDK_MODIFIER_MASK) &&
10836             (event->keyval == GDK_KEY_BackSpace) &&
10837             (strlen(gtk_entry_get_text(GTK_ENTRY(entry))) == 0)) {
10838                 gtk_container_remove
10839                         (GTK_CONTAINER(headerentry->compose->header_table),
10840                          headerentry->combo);
10841                 gtk_container_remove
10842                         (GTK_CONTAINER(headerentry->compose->header_table),
10843                          headerentry->entry);
10844                 headerentry->compose->header_list =
10845                         g_slist_remove(headerentry->compose->header_list,
10846                                        headerentry);
10847                 g_free(headerentry);
10848         } else  if (event->keyval == GDK_KEY_Tab) {
10849                 if (headerentry->compose->header_last == headerentry) {
10850                         /* Override default next focus, and give it to subject_entry
10851                          * instead of notebook tabs
10852                          */
10853                         g_signal_stop_emission_by_name(G_OBJECT(entry), "key-press-event");
10854                         gtk_widget_grab_focus(headerentry->compose->subject_entry);
10855                         return TRUE;
10856                 }
10857         }
10858         return FALSE;
10859 }
10860
10861 static gboolean scroll_postpone(gpointer data)
10862 {
10863         Compose *compose = (Compose *)data;
10864
10865         cm_return_val_if_fail(!compose->batch, FALSE);
10866
10867         GTK_EVENTS_FLUSH();
10868         compose_show_first_last_header(compose, FALSE);
10869         return FALSE;
10870 }
10871
10872 static void compose_headerentry_changed_cb(GtkWidget *entry,
10873                                     ComposeHeaderEntry *headerentry)
10874 {
10875         if (strlen(gtk_entry_get_text(GTK_ENTRY(entry))) != 0) {
10876                 compose_create_header_entry(headerentry->compose);
10877                 g_signal_handlers_disconnect_matched
10878                         (G_OBJECT(entry), G_SIGNAL_MATCH_DATA,
10879                          0, 0, NULL, NULL, headerentry);
10880
10881                 if (!headerentry->compose->batch)
10882                         g_timeout_add(0, scroll_postpone, headerentry->compose);
10883         }
10884 }
10885
10886 static gboolean compose_defer_auto_save_draft(Compose *compose)
10887 {
10888         compose->draft_timeout_tag = -1;
10889         compose_draft((gpointer)compose, COMPOSE_AUTO_SAVE);
10890         return FALSE;
10891 }
10892
10893 static void compose_show_first_last_header(Compose *compose, gboolean show_first)
10894 {
10895         GtkAdjustment *vadj;
10896
10897         cm_return_if_fail(compose);
10898         cm_return_if_fail(!compose->batch);
10899         cm_return_if_fail(GTK_IS_WIDGET(compose->header_table));
10900         cm_return_if_fail(GTK_IS_VIEWPORT(gtk_widget_get_parent(compose->header_table)));
10901         vadj = gtk_viewport_get_vadjustment(GTK_VIEWPORT(
10902                                 gtk_widget_get_parent(compose->header_table)));
10903         gtk_adjustment_set_value(vadj, (show_first ?
10904                                 gtk_adjustment_get_lower(vadj) :
10905                                 (gtk_adjustment_get_upper(vadj) -
10906                                 gtk_adjustment_get_page_size(vadj))));
10907         gtk_adjustment_changed(vadj);
10908 }
10909
10910 static void text_inserted(GtkTextBuffer *buffer, GtkTextIter *iter,
10911                           const gchar *text, gint len, Compose *compose)
10912 {
10913         gint paste_as_quotation = GPOINTER_TO_INT(g_object_get_data
10914                                 (G_OBJECT(compose->text), "paste_as_quotation"));
10915         GtkTextMark *mark;
10916
10917         cm_return_if_fail(text != NULL);
10918
10919         g_signal_handlers_block_by_func(G_OBJECT(buffer),
10920                                         G_CALLBACK(text_inserted),
10921                                         compose);
10922         if (paste_as_quotation) {
10923                 gchar *new_text;
10924                 const gchar *qmark;
10925                 guint pos = 0;
10926                 GtkTextIter start_iter;
10927
10928                 if (len < 0)
10929                         len = strlen(text);
10930
10931                 new_text = g_strndup(text, len);
10932
10933                 qmark = compose_quote_char_from_context(compose);
10934
10935                 mark = gtk_text_buffer_create_mark(buffer, NULL, iter, FALSE);
10936                 gtk_text_buffer_place_cursor(buffer, iter);
10937
10938                 pos = gtk_text_iter_get_offset(iter);
10939
10940                 compose_quote_fmt(compose, NULL, "%Q", qmark, new_text, TRUE, FALSE,
10941                                                   _("Quote format error at line %d."));
10942                 quote_fmt_reset_vartable();
10943                 g_free(new_text);
10944                 g_object_set_data(G_OBJECT(compose->text), "paste_as_quotation",
10945                                   GINT_TO_POINTER(paste_as_quotation - 1));
10946
10947                 gtk_text_buffer_get_iter_at_mark(buffer, iter, mark);
10948                 gtk_text_buffer_place_cursor(buffer, iter);
10949                 gtk_text_buffer_delete_mark(buffer, mark);
10950
10951                 gtk_text_buffer_get_iter_at_offset(buffer, &start_iter, pos);
10952                 mark = gtk_text_buffer_create_mark(buffer, NULL, &start_iter, FALSE);
10953                 compose_beautify_paragraph(compose, &start_iter, FALSE);
10954                 gtk_text_buffer_get_iter_at_mark(buffer, &start_iter, mark);
10955                 gtk_text_buffer_delete_mark(buffer, mark);
10956         } else {
10957                 if (strcmp(text, "\n") || compose->automatic_break
10958                 || gtk_text_iter_starts_line(iter)) {
10959                         GtkTextIter before_ins;
10960                         gtk_text_buffer_insert(buffer, iter, text, len);
10961                         if (!strstr(text, "\n") && gtk_text_iter_has_tag(iter, compose->no_join_tag)) {
10962                                 before_ins = *iter;
10963                                 gtk_text_iter_backward_chars(&before_ins, len);
10964                                 gtk_text_buffer_remove_tag_by_name(buffer, "no_join", &before_ins, iter);
10965                         }
10966                 } else {
10967                         /* check if the preceding is just whitespace or quote */
10968                         GtkTextIter start_line;
10969                         gchar *tmp = NULL, *quote = NULL;
10970                         gint quote_len = 0, is_normal = 0;
10971                         start_line = *iter;
10972                         gtk_text_iter_set_line_offset(&start_line, 0);
10973                         tmp = gtk_text_buffer_get_text(buffer, &start_line, iter, FALSE);
10974                         g_strstrip(tmp);
10975
10976                         if (*tmp == '\0') {
10977                                 is_normal = 1;
10978                         } else {
10979                                 quote = compose_get_quote_str(buffer, &start_line, &quote_len);
10980                                 if (quote)
10981                                         is_normal = 1;
10982                                 g_free(quote);
10983                         }
10984                         g_free(tmp);
10985
10986                         if (is_normal) {
10987                                 gtk_text_buffer_insert(buffer, iter, text, len);
10988                         } else {
10989                                 gtk_text_buffer_insert_with_tags_by_name(buffer,
10990                                         iter, text, len, "no_join", NULL);
10991                         }
10992                 }
10993         }
10994
10995         if (!paste_as_quotation) {
10996                 mark = gtk_text_buffer_create_mark(buffer, NULL, iter, FALSE);
10997                 compose_beautify_paragraph(compose, iter, FALSE);
10998                 gtk_text_buffer_get_iter_at_mark(buffer, iter, mark);
10999                 gtk_text_buffer_delete_mark(buffer, mark);
11000         }
11001
11002         g_signal_handlers_unblock_by_func(G_OBJECT(buffer),
11003                                           G_CALLBACK(text_inserted),
11004                                           compose);
11005         g_signal_stop_emission_by_name(G_OBJECT(buffer), "insert-text");
11006
11007         if (prefs_common.autosave &&
11008             gtk_text_buffer_get_char_count(buffer) % prefs_common.autosave_length == 0 &&
11009             compose->draft_timeout_tag != -2 /* disabled while loading */)
11010                 compose->draft_timeout_tag = g_timeout_add
11011                         (500, (GSourceFunc) compose_defer_auto_save_draft, compose);
11012 }
11013
11014 #if USE_ENCHANT
11015 static void compose_check_all(GtkAction *action, gpointer data)
11016 {
11017         Compose *compose = (Compose *)data;
11018         if (!compose->gtkaspell)
11019                 return;
11020
11021         if (gtkut_widget_has_focus(compose->subject_entry))
11022                 claws_spell_entry_check_all(
11023                         CLAWS_SPELL_ENTRY(compose->subject_entry));
11024         else
11025                 gtkaspell_check_all(compose->gtkaspell);
11026 }
11027
11028 static void compose_highlight_all(GtkAction *action, gpointer data)
11029 {
11030         Compose *compose = (Compose *)data;
11031         if (compose->gtkaspell) {
11032                 claws_spell_entry_recheck_all(
11033                         CLAWS_SPELL_ENTRY(compose->subject_entry));
11034                 gtkaspell_highlight_all(compose->gtkaspell);
11035         }
11036 }
11037
11038 static void compose_check_backwards(GtkAction *action, gpointer data)
11039 {
11040         Compose *compose = (Compose *)data;
11041         if (!compose->gtkaspell) {
11042                 cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Spelling", FALSE);
11043                 return;
11044         }
11045
11046         if (gtkut_widget_has_focus(compose->subject_entry))
11047                 claws_spell_entry_check_backwards(
11048                         CLAWS_SPELL_ENTRY(compose->subject_entry));
11049         else
11050                 gtkaspell_check_backwards(compose->gtkaspell);
11051 }
11052
11053 static void compose_check_forwards_go(GtkAction *action, gpointer data)
11054 {
11055         Compose *compose = (Compose *)data;
11056         if (!compose->gtkaspell) {
11057                 cm_menu_set_sensitive_full(compose->ui_manager, "Menu/Spelling", FALSE);
11058                 return;
11059         }
11060
11061         if (gtkut_widget_has_focus(compose->subject_entry))
11062                 claws_spell_entry_check_forwards_go(
11063                         CLAWS_SPELL_ENTRY(compose->subject_entry));
11064         else
11065                 gtkaspell_check_forwards_go(compose->gtkaspell);
11066 }
11067 #endif
11068
11069 /*!
11070  *\brief        Guess originating forward account from MsgInfo and several
11071  *              "common preference" settings. Return NULL if no guess.
11072  */
11073 static PrefsAccount *compose_guess_forward_account_from_msginfo(MsgInfo *msginfo)
11074 {
11075         PrefsAccount *account = NULL;
11076
11077         cm_return_val_if_fail(msginfo, NULL);
11078         cm_return_val_if_fail(msginfo->folder, NULL);
11079         cm_return_val_if_fail(msginfo->folder->prefs, NULL);
11080
11081         if (msginfo->folder->prefs->enable_default_account)
11082                 account = account_find_from_id(msginfo->folder->prefs->default_account);
11083
11084         if (!account)
11085                 account = msginfo->folder->folder->account;
11086
11087         if (!account && msginfo->to && prefs_common.forward_account_autosel) {
11088                 gchar *to;
11089                 Xstrdup_a(to, msginfo->to, return NULL);
11090                 extract_address(to);
11091                 account = account_find_from_address(to, FALSE);
11092         }
11093
11094         if (!account && prefs_common.forward_account_autosel) {
11095                 gchar cc[BUFFSIZE];
11096                 if (!procheader_get_header_from_msginfo
11097                         (msginfo, cc,sizeof cc , "Cc:")) {
11098                         gchar *buf = cc + strlen("Cc:");
11099                         extract_address(buf);
11100                         account = account_find_from_address(buf, FALSE);
11101                 }
11102         }
11103
11104         if (!account && prefs_common.forward_account_autosel) {
11105                 gchar deliveredto[BUFFSIZE];
11106                 if (!procheader_get_header_from_msginfo
11107                         (msginfo, deliveredto,sizeof deliveredto , "Delivered-To:")) {
11108                         gchar *buf = deliveredto + strlen("Delivered-To:");
11109                         extract_address(buf);
11110                         account = account_find_from_address(buf, FALSE);
11111                 }
11112         }
11113
11114         return account;
11115 }
11116
11117 gboolean compose_close(Compose *compose)
11118 {
11119         gint x, y;
11120
11121         if (!g_mutex_trylock(compose->mutex)) {
11122                 /* we have to wait for the (possibly deferred by auto-save)
11123                  * drafting to be done, before destroying the compose under
11124                  * it. */
11125                 debug_print("waiting for drafting to finish...\n");
11126                 compose_allow_user_actions(compose, FALSE);
11127                 g_timeout_add (500, (GSourceFunc) compose_close, compose);
11128                 return FALSE;
11129         }
11130         cm_return_val_if_fail(compose, FALSE);
11131         gtkut_widget_get_uposition(compose->window, &x, &y);
11132         if (!compose->batch) {
11133                 prefs_common.compose_x = x;
11134                 prefs_common.compose_y = y;
11135         }
11136         g_mutex_unlock(compose->mutex);
11137         compose_destroy(compose);
11138         return FALSE;
11139 }
11140
11141 /**
11142  * Add entry field for each address in list.
11143  * \param compose     E-Mail composition object.
11144  * \param listAddress List of (formatted) E-Mail addresses.
11145  */
11146 static void compose_add_field_list( Compose *compose, GList *listAddress ) {
11147         GList *node;
11148         gchar *addr;
11149         node = listAddress;
11150         while( node ) {
11151                 addr = ( gchar * ) node->data;
11152                 compose_entry_append( compose, addr, COMPOSE_TO, PREF_NONE );
11153                 node = g_list_next( node );
11154         }
11155 }
11156
11157 static void compose_reply_from_messageview_real(MessageView *msgview, GSList *msginfo_list,
11158                                     guint action, gboolean opening_multiple)
11159 {
11160         gchar *body = NULL;
11161         GSList *new_msglist = NULL;
11162         MsgInfo *tmp_msginfo = NULL;
11163         gboolean originally_enc = FALSE;
11164         gboolean originally_sig = FALSE;
11165         Compose *compose = NULL;
11166         gchar *s_system = NULL;
11167
11168         cm_return_if_fail(msgview != NULL);
11169
11170         cm_return_if_fail(msginfo_list != NULL);
11171
11172         if (g_slist_length(msginfo_list) == 1 && !opening_multiple) {
11173                 MimeInfo *mimeinfo = messageview_get_selected_mime_part(msgview);
11174                 MsgInfo *orig_msginfo = (MsgInfo *)msginfo_list->data;
11175
11176                 if (mimeinfo != NULL && mimeinfo->type == MIMETYPE_MESSAGE &&
11177                     !g_ascii_strcasecmp(mimeinfo->subtype, "rfc822")) {
11178                         tmp_msginfo = procmsg_msginfo_new_from_mimeinfo(
11179                                                 orig_msginfo, mimeinfo);
11180                         if (tmp_msginfo != NULL) {
11181                                 new_msglist = g_slist_append(NULL, tmp_msginfo);
11182
11183                                 originally_enc = MSG_IS_ENCRYPTED(orig_msginfo->flags);
11184                                 privacy_msginfo_get_signed_state(orig_msginfo, &s_system);
11185                                 originally_sig = MSG_IS_SIGNED(orig_msginfo->flags);
11186
11187                                 tmp_msginfo->folder = orig_msginfo->folder;
11188                                 tmp_msginfo->msgnum = orig_msginfo->msgnum;
11189                                 if (orig_msginfo->tags) {
11190                                         tmp_msginfo->tags = g_slist_copy(orig_msginfo->tags);
11191                                         tmp_msginfo->folder->tags_dirty = TRUE;
11192                                 }
11193                         }
11194                 }
11195         }
11196
11197         if (!opening_multiple)
11198                 body = messageview_get_selection(msgview);
11199
11200         if (new_msglist) {
11201                 compose = compose_reply_mode((ComposeMode)action, new_msglist, body);
11202                 procmsg_msginfo_free(tmp_msginfo);
11203                 g_slist_free(new_msglist);
11204         } else
11205                 compose = compose_reply_mode((ComposeMode)action, msginfo_list, body);
11206
11207         if (compose && originally_enc) {
11208                 compose_force_encryption(compose, compose->account, FALSE, s_system);
11209         }
11210
11211         if (compose && originally_sig && compose->account->default_sign_reply) {
11212                 compose_force_signing(compose, compose->account, s_system);
11213         }
11214         g_free(s_system);
11215         g_free(body);
11216         hooks_invoke(COMPOSE_CREATED_HOOKLIST, compose);
11217 }
11218
11219 void compose_reply_from_messageview(MessageView *msgview, GSList *msginfo_list,
11220                                     guint action)
11221 {
11222         if ((!prefs_common.forward_as_attachment || action != COMPOSE_FORWARD)
11223         &&  action != COMPOSE_FORWARD_AS_ATTACH && g_slist_length(msginfo_list) > 1) {
11224                 GSList *cur = msginfo_list;
11225                 gchar *msg = g_strdup_printf(_("You are about to reply to %d "
11226                                                "messages. Opening the windows "
11227                                                "could take some time. Do you "
11228                                                "want to continue?"),
11229                                                g_slist_length(msginfo_list));
11230                 if (g_slist_length(msginfo_list) > 9
11231                 &&  alertpanel(_("Warning"), msg, GTK_STOCK_CANCEL, "+" GTK_STOCK_YES, NULL)
11232                     != G_ALERTALTERNATE) {
11233                         g_free(msg);
11234                         return;
11235                 }
11236                 g_free(msg);
11237                 /* We'll open multiple compose windows */
11238                 /* let the WM place the next windows */
11239                 compose_force_window_origin = FALSE;
11240                 for (; cur; cur = cur->next) {
11241                         GSList tmplist;
11242                         tmplist.data = cur->data;
11243                         tmplist.next = NULL;
11244                         compose_reply_from_messageview_real(msgview, &tmplist, action, TRUE);
11245                 }
11246                 compose_force_window_origin = TRUE;
11247         } else {
11248                 /* forwarding multiple mails as attachments is done via a
11249                  * single compose window */
11250                 compose_reply_from_messageview_real(msgview, msginfo_list, action, FALSE);
11251         }
11252 }
11253
11254 void compose_check_for_email_account(Compose *compose)
11255 {
11256         PrefsAccount *ac = NULL, *curr = NULL;
11257         GList *list;
11258
11259         if (!compose)
11260                 return;
11261
11262         if (compose->account && compose->account->protocol == A_NNTP) {
11263                 ac = account_get_cur_account();
11264                 if (ac->protocol == A_NNTP) {
11265                         list = account_get_list();
11266
11267                         for( ; list != NULL ; list = g_list_next(list)) {
11268                                 curr = (PrefsAccount *) list->data;
11269                                 if (curr->protocol != A_NNTP) {
11270                                         ac = curr;
11271                                         break;
11272                                 }
11273                         }
11274                 }
11275                 combobox_select_by_data(GTK_COMBO_BOX(compose->account_combo),
11276                                         ac->account_id);
11277         }
11278 }
11279
11280 void compose_reply_to_address(MessageView *msgview, MsgInfo *msginfo,
11281                                 const gchar *address)
11282 {
11283         GSList *msginfo_list = NULL;
11284         gchar *body =  messageview_get_selection(msgview);
11285         Compose *compose;
11286
11287         msginfo_list = g_slist_prepend(msginfo_list, msginfo);
11288
11289         compose = compose_reply_mode(COMPOSE_REPLY_TO_ADDRESS, msginfo_list, body);
11290         compose_check_for_email_account(compose);
11291         compose_set_folder_prefs(compose, msginfo->folder, FALSE);
11292         compose_entry_append(compose, address, COMPOSE_TO, PREF_NONE);
11293         compose_reply_set_subject(compose, msginfo);
11294
11295         g_free(body);
11296         hooks_invoke(COMPOSE_CREATED_HOOKLIST, compose);
11297 }
11298
11299 void compose_set_position(Compose *compose, gint pos)
11300 {
11301         GtkTextView *text = GTK_TEXT_VIEW(compose->text);
11302
11303         gtkut_text_view_set_position(text, pos);
11304 }
11305
11306 gboolean compose_search_string(Compose *compose,
11307                                 const gchar *str, gboolean case_sens)
11308 {
11309         GtkTextView *text = GTK_TEXT_VIEW(compose->text);
11310
11311         return gtkut_text_view_search_string(text, str, case_sens);
11312 }
11313
11314 gboolean compose_search_string_backward(Compose *compose,
11315                                 const gchar *str, gboolean case_sens)
11316 {
11317         GtkTextView *text = GTK_TEXT_VIEW(compose->text);
11318
11319         return gtkut_text_view_search_string_backward(text, str, case_sens);
11320 }
11321
11322 /* allocate a msginfo structure and populate its data from a compose data structure */
11323 static MsgInfo *compose_msginfo_new_from_compose(Compose *compose)
11324 {
11325         MsgInfo *newmsginfo;
11326         GSList *list;
11327         gchar buf[BUFFSIZE];
11328
11329         cm_return_val_if_fail( compose != NULL, NULL );
11330
11331         newmsginfo = procmsg_msginfo_new();
11332
11333         /* date is now */
11334         get_rfc822_date(buf, sizeof(buf));
11335         newmsginfo->date = g_strdup(buf);
11336
11337         /* from */
11338         if (compose->from_name) {
11339                 newmsginfo->from = gtk_editable_get_chars(GTK_EDITABLE(compose->from_name), 0, -1);
11340                 newmsginfo->fromname = procheader_get_fromname(newmsginfo->from);
11341         }
11342
11343         /* subject */
11344         if (compose->subject_entry)
11345                 newmsginfo->subject = gtk_editable_get_chars(GTK_EDITABLE(compose->subject_entry), 0, -1);
11346
11347         /* to, cc, reply-to, newsgroups */
11348         for (list = compose->header_list; list; list = list->next) {
11349                 gchar *header = gtk_editable_get_chars(
11350                                                                 GTK_EDITABLE(
11351                                                                 gtk_bin_get_child(GTK_BIN((((ComposeHeaderEntry *)list->data)->combo)))), 0, -1);
11352                 gchar *entry = gtk_editable_get_chars(
11353                                                                 GTK_EDITABLE(((ComposeHeaderEntry *)list->data)->entry), 0, -1);
11354
11355                 if ( strcasecmp(header, prefs_common_translated_header_name("To:")) == 0 ) {
11356                         if ( newmsginfo->to == NULL ) {
11357                                 newmsginfo->to = g_strdup(entry);
11358                         } else if (entry && *entry) {
11359                                 gchar *tmp = g_strconcat(newmsginfo->to, ", ", entry, NULL);
11360                                 g_free(newmsginfo->to);
11361                                 newmsginfo->to = tmp;
11362                         }
11363                 } else
11364                 if ( strcasecmp(header, prefs_common_translated_header_name("Cc:")) == 0 ) {
11365                         if ( newmsginfo->cc == NULL ) {
11366                                 newmsginfo->cc = g_strdup(entry);
11367                         } else if (entry && *entry) {
11368                                 gchar *tmp = g_strconcat(newmsginfo->cc, ", ", entry, NULL);
11369                                 g_free(newmsginfo->cc);
11370                                 newmsginfo->cc = tmp;
11371                         }
11372                 } else
11373                 if ( strcasecmp(header,
11374                                                 prefs_common_translated_header_name("Newsgroups:")) == 0 ) {
11375                         if ( newmsginfo->newsgroups == NULL ) {
11376                                 newmsginfo->newsgroups = g_strdup(entry);
11377                         } else if (entry && *entry) {
11378                                 gchar *tmp = g_strconcat(newmsginfo->newsgroups, ", ", entry, NULL);
11379                                 g_free(newmsginfo->newsgroups);
11380                                 newmsginfo->newsgroups = tmp;
11381                         }
11382                 }
11383
11384                 g_free(header);
11385                 g_free(entry);
11386         }
11387
11388         /* other data is unset */
11389
11390         return newmsginfo;
11391 }
11392
11393 #ifdef USE_ENCHANT
11394 /* update compose's dictionaries from folder dict settings */
11395 static void compose_set_dictionaries_from_folder_prefs(Compose *compose,
11396                                                 FolderItem *folder_item)
11397 {
11398         cm_return_if_fail(compose != NULL);
11399
11400         if (compose->gtkaspell && folder_item && folder_item->prefs) {
11401                 FolderItemPrefs *prefs = folder_item->prefs;
11402
11403                 if (prefs->enable_default_dictionary)
11404                         gtkaspell_change_dict(compose->gtkaspell,
11405                                         prefs->default_dictionary, FALSE);
11406                 if (folder_item->prefs->enable_default_alt_dictionary)
11407                         gtkaspell_change_alt_dict(compose->gtkaspell,
11408                                         prefs->default_alt_dictionary);
11409                 if (prefs->enable_default_dictionary
11410                         || prefs->enable_default_alt_dictionary)
11411                         compose_spell_menu_changed(compose);
11412         }
11413 }
11414 #endif
11415
11416 /*
11417  * End of Source.
11418  */