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