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