#include <sys/wait.h>
#include <signal.h>
#include <errno.h>
+#include <libgen.h>
#if (HAVE_WCTYPE_H && HAVE_WCHAR_H)
# include <wchar.h>
#include "customheader.h"
#include "prefs_common.h"
#include "prefs_account.h"
-#include "prefs_actions.h"
+#include "action.h"
#include "account.h"
#include "filesel.h"
#include "procheader.h"
PRIORITY_LOWEST
} PriorityLevel;
+typedef enum
+{
+ COMPOSE_INSERT_SUCCESS,
+ COMPOSE_INSERT_READ_ERROR,
+ COMPOSE_INSERT_INVALID_CHARACTER,
+ COMPOSE_INSERT_NO_FILE
+} ComposeInsertResult;
+
#define B64_LINE_SIZE 57
#define B64_BUFFSIZE 77
Compose *compose_generic_new (PrefsAccount *account,
const gchar *to,
FolderItem *item,
- GPtrArray *attach_files);
+ GPtrArray *attach_files,
+ GList *listAddress );
static Compose *compose_create (PrefsAccount *account,
ComposeMode mode);
static void compose_insert_sig (Compose *compose,
gboolean replace);
static gchar *compose_get_signature_str (Compose *compose);
-static void compose_insert_file (Compose *compose,
+static ComposeInsertResult compose_insert_file (Compose *compose,
const gchar *file);
static void compose_attach_append (Compose *compose,
const gchar *file,
static void compose_convert_header (gchar *dest,
gint len,
gchar *src,
- gint header_len);
-static void compose_generate_msgid (Compose *compose,
- gchar *buf,
+ gint header_len,
+ gboolean addr_field);
+static void compose_generate_msgid (gchar *buf,
gint len);
static void compose_attach_info_free (AttachInfo *ainfo);
static void compose_add_header_entry (Compose *compose, gchar *header, gchar *text);
static void compose_update_priority_menu_item(Compose * compose);
+static void compose_add_field_list ( Compose *compose,
+ GList *listAddress );
+
/* callback functions */
static gboolean compose_edit_size_alloc (GtkEditable *widget,
#endif
static void compose_toggle_return_receipt_cb(gpointer data, guint action,
GtkWidget *widget);
+static void compose_toggle_remove_refs_cb(gpointer data, guint action,
+ GtkWidget *widget);
static void compose_set_priority_cb (gpointer data,
guint action,
GtkWidget *widget);
void compose_headerentry_key_press_event_cb(GtkWidget *entry,
GdkEventKey *event,
ComposeHeaderEntry *headerentry);
+static gboolean compose_headerentry_button_pressed (GtkWidget *entry,
+ GdkEventButton *event,
+ gpointer data);
static void compose_show_first_last_header (Compose *compose, gboolean show_first);
#endif
static gboolean compose_send_control_enter (Compose *compose);
+static gint compose_defer_auto_save_draft (Compose *compose);
static GtkItemFactoryEntry compose_popup_entries[] =
{
{N_("/_Message/---"), NULL, NULL, 0, "<Separator>"},
{N_("/_Message/Si_gn"), NULL, compose_toggle_sign_cb , 0, "<ToggleItem>"},
{N_("/_Message/_Encrypt"), NULL, compose_toggle_encrypt_cb, 0, "<ToggleItem>"},
- {N_("/_Message/Mode/MIME"), NULL, compose_set_gnupg_mode_cb, GNUPG_MODE_DETACH, "<RadioItem>"},
+ {N_("/_Message/Mode"), NULL, NULL, 0, "<Branch>"},
+ {N_("/_Message/Mode/MIME"), NULL, compose_set_gnupg_mode_cb, GNUPG_MODE_DETACH, "<RadioItem>"},
{N_("/_Message/Mode/Inline"), NULL, compose_set_gnupg_mode_cb, GNUPG_MODE_INLINE, "/Message/Mode/MIME"},
#endif /* USE_GPGME */
{N_("/_Message/---"), NULL, NULL, 0, "<Separator>"},
{N_("/_Message/Priority/_Lowest"), NULL, compose_set_priority_cb, PRIORITY_LOWEST, "/Message/Priority/Highest"},
{N_("/_Message/---"), NULL, NULL, 0, "<Separator>"},
{N_("/_Message/_Request Return Receipt"), NULL, compose_toggle_return_receipt_cb, 0, "<ToggleItem>"},
+ {N_("/_Message/Remo_ve references"), NULL, compose_toggle_remove_refs_cb, 0, "<ToggleItem>"},
{N_("/_Tools"), NULL, NULL, 0, "<Branch>"},
{N_("/_Tools/Show _ruler"), NULL, compose_toggle_ruler_cb, 0, "<ToggleItem>"},
{N_("/_Tools/_Address book"), "<shift><control>A", compose_address_cb , 0, NULL},
Compose *compose_new(PrefsAccount *account, const gchar *mailto,
GPtrArray *attach_files)
{
- return compose_generic_new(account, mailto, NULL, attach_files);
+ return compose_generic_new(account, mailto, NULL, attach_files, NULL);
}
Compose *compose_new_with_folderitem(PrefsAccount *account, FolderItem *item)
{
- return compose_generic_new(account, NULL, item, NULL);
+ return compose_generic_new(account, NULL, item, NULL, NULL);
+}
+
+Compose *compose_new_with_list( PrefsAccount *account, GList *listAddress )
+{
+ return compose_generic_new( account, NULL, NULL, NULL, listAddress );
}
Compose *compose_generic_new(PrefsAccount *account, const gchar *mailto, FolderItem *item,
- GPtrArray *attach_files)
+ GPtrArray *attach_files, GList *listAddress )
{
Compose *compose;
GtkSText *text;
GtkItemFactory *ifactory;
- gboolean grab_focus_on_last = TRUE;
if (item && item->prefs && item->prefs->enable_default_account)
account = account_find_from_id(item->prefs->default_account);
text = GTK_STEXT(compose->text);
gtk_stext_freeze(text);
+#ifdef USE_ASPELL
+ if (item && item->prefs && item->prefs->enable_default_dictionary &&
+ compose->gtkaspell)
+ gtkaspell_change_dict(compose->gtkaspell,
+ item->prefs->default_dictionary);
+#endif
+
if (account->auto_sig)
compose_insert_sig(compose, FALSE);
gtk_editable_set_position(GTK_EDITABLE(text), 0);
} else if (item && item->prefs->enable_default_to) {
compose_entry_append(compose, item->prefs->default_to, COMPOSE_TO);
- compose_entry_select(compose, item->prefs->default_to);
- grab_focus_on_last = FALSE;
+ compose_entry_mark_default_to(compose, item->prefs->default_to);
}
if (item && item->ret_rcpt) {
menu_set_toggle(ifactory, "/Message/Request Return Receipt", TRUE);
*/
menu_set_sensitive(ifactory, "/Message/Request Return Receipt", FALSE);
}
+ compose_add_field_list( compose, listAddress );
if (attach_files) {
gint i;
g_free(folderidentifier);
}
- /* Grab focus on last header only if no default_to was set */
- if (grab_focus_on_last)
- gtk_widget_grab_focus(compose->header_last->entry);
+ gtk_widget_grab_focus(compose->header_last->entry);
if (prefs_common.auto_exteditor)
compose_exec_ext_editor(compose);
case COMPOSE_FORWARD_INLINE:
/* check if we reply to more than one Message */
if (list_len == 1) {
- compose_forward(NULL, msginfo, FALSE, body);
+ compose_forward(NULL, msginfo, FALSE, body, FALSE);
break;
}
/* more messages FALL THROUGH */
gboolean followup_and_reply_to,
const gchar *body)
{
+ GtkItemFactory *ifactory;
Compose *compose;
PrefsAccount *account = NULL;
PrefsAccount *reply_account;
reply_account = account;
compose = compose_create(account, COMPOSE_REPLY);
+ ifactory = gtk_item_factory_from_widget(compose->menubar);
+
+ menu_set_toggle(ifactory, "/Message/Remove references", FALSE);
+ menu_set_sensitive(ifactory, "/Message/Remove references", TRUE);
compose->replyinfo = procmsg_msginfo_get_full_info(msginfo);
if (!compose->replyinfo)
compose->replyinfo = procmsg_msginfo_copy(msginfo);
- if (msginfo->folder && msginfo->folder->ret_rcpt) {
- GtkItemFactory *ifactory;
-
- ifactory = gtk_item_factory_from_widget(compose->menubar);
+ if (msginfo->folder && msginfo->folder->ret_rcpt)
menu_set_toggle(ifactory, "/Message/Request Return Receipt", TRUE);
- }
/* Set save folder */
if (msginfo->folder && msginfo->folder->prefs && msginfo->folder->prefs->save_copy_to_folder) {
text = GTK_STEXT(compose->text);
gtk_stext_freeze(text);
+#ifdef USE_ASPELL
+ if (msginfo->folder && msginfo->folder->prefs &&
+ msginfo->folder->prefs &&
+ msginfo->folder->prefs->enable_default_dictionary &&
+ compose->gtkaspell)
+ gtkaspell_change_dict(compose->gtkaspell,
+ msginfo->folder->prefs->default_dictionary);
+#endif
+
if (quote) {
gchar *qmark;
- gchar *quote_str;
if (prefs_common.quotemark && *prefs_common.quotemark)
qmark = prefs_common.quotemark;
else
qmark = "> ";
- quote_str = compose_quote_fmt(compose, compose->replyinfo,
- prefs_common.quotefmt,
- qmark, body);
+ compose_quote_fmt(compose, compose->replyinfo,
+ prefs_common.quotefmt,
+ qmark, body);
}
if (account->auto_sig)
compose_insert_sig(compose, FALSE);
- if (quote && prefs_common.linewrap_quote)
- compose_wrap_line_all(compose);
+ /* Must thaw here, otherwise the GtkSTextEdit will become confused
+ * when positioning cursor */
+ gtk_stext_thaw(text);
- gtk_editable_set_position(GTK_EDITABLE(text), 0);
- gtk_stext_set_point(text, 0);
+ gtk_editable_set_position
+ (GTK_EDITABLE(text), quote_fmt_get_cursor_pos());
+ gtk_stext_set_point(text, quote_fmt_get_cursor_pos());
+
+ if (quote && prefs_common.linewrap_quote) {
+ gtk_stext_freeze(text);
+ compose_wrap_line_all(compose);
+ gtk_stext_thaw(text);
+ }
- gtk_stext_thaw(text);
gtk_widget_grab_focus(compose->text);
if (prefs_common.auto_exteditor)
}
Compose *compose_forward(PrefsAccount *account, MsgInfo *msginfo,
- gboolean as_attach, const gchar *body)
+ gboolean as_attach, const gchar *body,
+ gboolean no_extedit)
{
Compose *compose;
GtkSText *text;
if (!account && prefs_common.forward_account_autosel) {
gchar cc[BUFFSIZE];
- if (!get_header_from_msginfo(msginfo,cc,sizeof(cc),"CC:")){ /* Found a CC header */
+ if (!procheader_get_header_from_msginfo(msginfo,cc,sizeof(cc),"CC:")){ /* Found a CC header */
extract_address(cc);
account = account_find_from_address(cc);
}
compose->fwdinfo = procmsg_msginfo_copy(msginfo);
if (msginfo->subject && *msginfo->subject) {
- gtk_entry_set_text(GTK_ENTRY(compose->subject_entry), "Fw: ");
- gtk_entry_append_text(GTK_ENTRY(compose->subject_entry),
- msginfo->subject);
+ gchar *buf, *buf2, *p;
+
+ buf = p = g_strdup(msginfo->subject);
+ p += subject_get_prefix_length(p);
+ memmove(buf, p, strlen(p) + 1);
+
+ buf2 = g_strdup_printf("Fw: %s", buf);
+ gtk_entry_set_text(GTK_ENTRY(compose->subject_entry), buf2);
+
+ g_free(buf);
+ g_free(buf2);
}
text = GTK_STEXT(compose->text);
gtk_stext_freeze(text);
+ if (as_attach) {
+ gchar *msgfile;
- if (as_attach) {
- gchar *msgfile;
-
- msgfile = procmsg_get_message_file_path(msginfo);
- if (!is_file_exist(msgfile))
- g_warning("%s: file not exist\n", msgfile);
- else
- compose_attach_append(compose, msgfile, msgfile,
- "message/rfc822");
+ msgfile = procmsg_get_message_file_path(msginfo);
+ if (!is_file_exist(msgfile))
+ g_warning("%s: file not exist\n", msgfile);
+ else
+ compose_attach_append(compose, msgfile, msgfile,
+ "message/rfc822");
- g_free(msgfile);
- } else {
- gchar *qmark;
- gchar *quote_str;
- MsgInfo *full_msginfo;
+ g_free(msgfile);
+ } else {
+ gchar *qmark;
+ MsgInfo *full_msginfo;
- full_msginfo = procmsg_msginfo_get_full_info(msginfo);
- if (!full_msginfo)
- full_msginfo = procmsg_msginfo_copy(msginfo);
+ full_msginfo = procmsg_msginfo_get_full_info(msginfo);
+ if (!full_msginfo)
+ full_msginfo = procmsg_msginfo_copy(msginfo);
- if (prefs_common.fw_quotemark &&
- *prefs_common.fw_quotemark)
- qmark = prefs_common.fw_quotemark;
- else
- qmark = "> ";
+ if (prefs_common.fw_quotemark &&
+ *prefs_common.fw_quotemark)
+ qmark = prefs_common.fw_quotemark;
+ else
+ qmark = "> ";
- quote_str = compose_quote_fmt(compose, full_msginfo,
- prefs_common.fw_quotefmt,
- qmark, body);
- compose_attach_parts(compose, msginfo);
+ compose_quote_fmt(compose, full_msginfo,
+ prefs_common.fw_quotefmt,
+ qmark, body);
+ compose_attach_parts(compose, msginfo);
- procmsg_msginfo_free(full_msginfo);
- }
+ procmsg_msginfo_free(full_msginfo);
+ }
if (account->auto_sig)
compose_insert_sig(compose, FALSE);
#endif
gtk_widget_grab_focus(compose->header_last->entry);
- if (prefs_common.auto_exteditor)
+ if (!no_extedit && prefs_common.auto_exteditor)
compose_exec_ext_editor(compose);
/*save folder*/
gint id;
/* Select Account from queue headers */
- if (!get_header_from_msginfo(msginfo, queueheader_buf,
+ if (!procheader_get_header_from_msginfo(msginfo, queueheader_buf,
sizeof(queueheader_buf), "X-Sylpheed-Account-Id:")) {
id = atoi(&queueheader_buf[22]);
account = account_find_from_id(id);
}
- if (!account && !get_header_from_msginfo(msginfo, queueheader_buf,
+ if (!account && !procheader_get_header_from_msginfo(msginfo, queueheader_buf,
sizeof(queueheader_buf), "NAID:")) {
id = atoi(&queueheader_buf[5]);
account = account_find_from_id(id);
}
- if (!account && !get_header_from_msginfo(msginfo, queueheader_buf,
+ if (!account && !procheader_get_header_from_msginfo(msginfo, queueheader_buf,
sizeof(queueheader_buf), "MAID:")) {
id = atoi(&queueheader_buf[5]);
account = account_find_from_id(id);
}
- if (!account && !get_header_from_msginfo(msginfo, queueheader_buf,
+ if (!account && !procheader_get_header_from_msginfo(msginfo, queueheader_buf,
sizeof(queueheader_buf), "S:")) {
account = account_find_from_address(queueheader_buf);
}
if (!account && prefs_common.reedit_account_autosel) {
gchar from[BUFFSIZE];
- if (!get_header_from_msginfo(msginfo, from, sizeof(from), "FROM:")){
+ if (!procheader_get_header_from_msginfo(msginfo, from, sizeof(from), "FROM:")){
extract_address(from);
account = account_find_from_address(from);
}
gchar queueheader_buf[BUFFSIZE];
/* Set message save folder */
- if (!get_header_from_msginfo(msginfo, queueheader_buf, sizeof(queueheader_buf), "SCF:")) {
+ if (!procheader_get_header_from_msginfo(msginfo, queueheader_buf, sizeof(queueheader_buf), "SCF:")) {
gint startpos = 0;
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(compose->savemsg_checkbtn), TRUE);
Compose *compose;
gchar *filename;
GtkItemFactory *ifactory;
+ FolderItem *item;
g_return_val_if_fail(msginfo != NULL, NULL);
if (!account)
- account = cur_account;
+ account = account_get_reply_account(msginfo,
+ prefs_common.reply_account_autosel);
g_return_val_if_fail(account != NULL, NULL);
compose = compose_create(account, COMPOSE_REDIRECT);
compose->redirect_filename = filename;
+ /* Set save folder */
+ item = msginfo->folder;
+ if (item && item->prefs && item->prefs->save_copy_to_folder) {
+ gchar *folderidentifier;
+
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(compose->savemsg_checkbtn), prefs_common.savemsg);
+ folderidentifier = folder_item_get_identifier(item);
+ gtk_entry_set_text(GTK_ENTRY(compose->savemsg_entry), folderidentifier);
+ g_free(folderidentifier);
+ }
+
compose_attach_parts(compose, msginfo);
if (msginfo->subject)
gtk_widget_set_sensitive(compose->toolbar->attach_btn, FALSE);
gtk_widget_set_sensitive(compose->toolbar->sig_btn, FALSE);
gtk_widget_set_sensitive(compose->toolbar->exteditor_btn, FALSE);
- gtk_widget_set_sensitive(compose->toolbar->linewrap_btn, FALSE);
+ gtk_widget_set_sensitive(compose->toolbar->linewrap_current_btn, FALSE);
+ gtk_widget_set_sensitive(compose->toolbar->linewrap_all_btn, FALSE);
return compose;
}
compose_add_header_entry(compose, header, (gchar *)address);
}
-void compose_entry_select (Compose *compose, const gchar *mailto)
+void compose_entry_mark_default_to(Compose *compose, const gchar *mailto)
{
- GSList *header_list;
+ static GtkStyle *bold_style = NULL;
+ static GdkColor bold_color;
+ static GdkFont *bold_font = NULL;
+ GSList *h_list;
+ GtkEntry *entry;
- for (header_list = compose->header_list; header_list != NULL; header_list = header_list->next) {
- GtkEntry * entry = GTK_ENTRY(((ComposeHeaderEntry *)header_list->data)->entry);
-
- if (gtk_entry_get_text(entry) && !g_strcasecmp(gtk_entry_get_text(entry), mailto)) {
- gtk_entry_select_region(entry, 0, -1);
- gtk_widget_grab_focus(GTK_WIDGET(entry));
+ for (h_list = compose->header_list; h_list != NULL; h_list = h_list->next) {
+ entry = GTK_ENTRY(((ComposeHeaderEntry *)h_list->data)->entry);
+ if (gtk_entry_get_text(entry) &&
+ !g_strcasecmp(gtk_entry_get_text(entry), mailto)) {
+ gtk_widget_ensure_style(GTK_WIDGET(entry));
+ if (!bold_style) {
+ gtkut_convert_int_to_gdk_color
+ (prefs_common.color_new, &bold_color);
+ bold_style = gtk_style_copy(gtk_widget_get_style
+ (GTK_WIDGET(entry)));
+ if (!bold_font)
+ bold_font = gtkut_font_load
+ (prefs_common.boldfont);
+ if (bold_font)
+ bold_style->font = bold_font;
+ bold_style->fg[GTK_STATE_NORMAL] = bold_color;
+ }
+ gtk_widget_set_style(GTK_WIDGET(entry), bold_style);
}
}
}
case A_EXTEDITOR:
compose_ext_editor_cb(compose, 0, NULL);
break;
- case A_LINEWRAP:
+ case A_LINEWRAP_CURRENT:
compose_wrap_line(compose);
break;
+ case A_LINEWRAP_ALL:
+ compose_wrap_line_all(compose);
+ break;
case A_ADDRBOOK:
compose_address_cb(compose, 0, NULL);
break;
+#ifdef USE_ASPELL
+ case A_CHECK_SPELLING:
+ compose_check_all(compose);
+ break;
+#endif
default:
break;
}
gchar *buf;
gchar *p, *lastp;
gint len;
- gchar *trimmed_body = body;
+ const gchar *trimmed_body = body;
if (!msginfo)
msginfo = &dummyinfo;
}
if (msginfo->subject && *msginfo->subject) {
- gchar *buf, *buf2, *p;
+ gchar *buf, *buf2;
+ guchar *p;
- buf = g_strdup(msginfo->subject);
- while (!strncasecmp(buf, "Re:", 3)) {
- p = buf + 3;
- while (isspace(*p)) p++;
- memmove(buf, p, strlen(p) + 1);
- }
+ buf = p = g_strdup(msginfo->subject);
+ p += subject_get_prefix_length(p);
+ memmove(buf, p, strlen(p) + 1);
buf2 = g_strdup_printf("Re: %s", buf);
gtk_entry_set_text(GTK_ENTRY(compose->subject_entry), buf2);
+
g_free(buf2);
g_free(buf);
} else
if (replyto && from)
cc_list = address_list_append_with_comments(cc_list, from);
+ if (to_all && msginfo->folder &&
+ msginfo->folder->prefs->enable_default_reply_to)
+ cc_list = address_list_append_with_comments(cc_list,
+ msginfo->folder->prefs->default_reply_to);
cc_list = address_list_append_with_comments(cc_list, msginfo->to);
cc_list = address_list_append_with_comments(cc_list, compose->cc);
slist_free_strings(cc_list);
g_slist_free(cc_list);
}
+
}
#define SET_ENTRY(entry, str) \
{
GtkSText *text = GTK_STEXT(compose->text);
gint cur_pos;
+ gint len;
g_return_if_fail(compose->account != NULL);
gtk_stext_freeze(text);
+ if (replace) {
+ len = gtk_stext_get_length(text);
+ gtk_stext_set_point(text, len);
+ }
+
if (replace && compose->sig_str) {
- gchar *tmp;
gint pos;
- gint len;
- if (compose->account->sig_sep)
- tmp = g_strconcat(compose->account->sig_sep, "\n",
- compose->sig_str, NULL);
+ if (compose->sig_str[0] == '\0')
+ pos = -1;
else
- tmp = g_strdup(compose->sig_str);
+ pos = gtkut_stext_find(text, 0, compose->sig_str, TRUE);
- pos = gtkut_stext_find(text, 0, tmp, TRUE);
if (pos != -1) {
- gtk_stext_set_point(text, pos);
- len = get_wcs_len(tmp);
- gtk_stext_forward_delete(text, len);
- } else {
- len = gtk_stext_get_length(text);
- gtk_stext_set_point(text, len);
+ len = get_mbs_len(compose->sig_str);
+ if (len >= 0) {
+ gtk_stext_set_point(text, pos);
+ gtk_stext_forward_delete(text, len);
+ }
}
-
- g_free(tmp);
- } else
- gtk_stext_insert(text, NULL, NULL, NULL, "\n\n", 2);
-
- if (compose->account->sig_sep) {
- gtk_stext_insert(text, NULL, NULL, NULL,
- compose->account->sig_sep, -1);
- gtk_stext_insert(text, NULL, NULL, NULL, "\n", 1);
}
g_free(compose->sig_str);
compose->sig_str = compose_get_signature_str(compose);
+ if (!compose->sig_str || (replace && !compose->account->auto_sig))
+ compose->sig_str = g_strdup("");
gtk_stext_insert(text, NULL, NULL, NULL, compose->sig_str, -1);
static gchar *compose_get_signature_str(Compose *compose)
{
- static gchar *default_sigfile;
- gchar *sig_file = NULL;
+ gchar *sig_body = NULL;
gchar *sig_str = NULL;
g_return_val_if_fail(compose->account != NULL, NULL);
- if (compose->account->sig_type == SIG_FILE) {
- if (compose->account->sig_path)
- sig_file = compose->account->sig_path;
- else {
- if (!default_sigfile)
- default_sigfile = g_strconcat
- (get_home_dir(), G_DIR_SEPARATOR_S,
- DEFAULT_SIGNATURE, NULL);
- sig_file = default_sigfile;
- }
+ if (!compose->account->sig_path)
+ return NULL;
- if (!is_file_or_fifo_exist(sig_file)) {
- g_warning("can't open signature file: %s\n", sig_file);
+ if (compose->account->sig_type == SIG_FILE) {
+ if (!is_file_or_fifo_exist(compose->account->sig_path)) {
+ g_warning("can't open signature file: %s\n",
+ compose->account->sig_path);
return NULL;
}
}
- if (compose->account->sig_type == SIG_COMMAND) {
- if (compose->account->sig_path)
- sig_str = get_command_output
- (compose->account->sig_path);
- } else {
+ if (compose->account->sig_type == SIG_COMMAND)
+ sig_body = get_command_output(compose->account->sig_path);
+ else {
gchar *tmp;
- tmp = file_read_to_str(sig_file);
- sig_str = normalize_newlines(tmp);
+ tmp = file_read_to_str(compose->account->sig_path);
+ if (!tmp)
+ return NULL;
+ sig_body = normalize_newlines(tmp);
g_free(tmp);
}
+ if (compose->account->sig_sep)
+ sig_str = g_strconcat("\n\n", compose->account->sig_sep, "\n", sig_body,
+ NULL);
+ else
+ sig_str = g_strconcat("\n\n", sig_body, NULL);
+
+ g_free(sig_body);
+
return sig_str;
}
-static void compose_insert_file(Compose *compose, const gchar *file)
+static ComposeInsertResult compose_insert_file(Compose *compose, const gchar *file)
{
GtkSText *text = GTK_STEXT(compose->text);
gchar buf[BUFFSIZE];
gint len;
FILE *fp;
+ gboolean badtxt = FALSE;
- g_return_if_fail(file != NULL);
+ g_return_val_if_fail(file != NULL, COMPOSE_INSERT_NO_FILE);
if ((fp = fopen(file, "rb")) == NULL) {
FILE_OP_ERROR(file, "fopen");
- return;
+ return COMPOSE_INSERT_READ_ERROR;
}
gtk_stext_freeze(text);
while (--len >= 0)
if (buf[len] == '\r') buf[len] = '\n';
}
+ if (mbstowcs(NULL, buf, 0) == -1)
+ badtxt = TRUE;
gtk_stext_insert(text, NULL, NULL, NULL, buf, -1);
}
gtk_stext_thaw(text);
fclose(fp);
+
+ if (badtxt)
+ return COMPOSE_INSERT_INVALID_CHARACTER;
+ else
+ return COMPOSE_INSERT_SUCCESS;
}
static void compose_attach_append(Compose *compose, const gchar *file,
if (content_type) {
ainfo->content_type = g_strdup(content_type);
if (!strcasecmp(content_type, "message/rfc822")) {
+ MsgInfo *msginfo;
+ MsgFlags flags = {0, 0};
+ gchar *name;
+
if (procmime_get_encoding_for_file(file) == ENC_7BIT)
ainfo->encoding = ENC_7BIT;
else
ainfo->encoding = ENC_8BIT;
- ainfo->name = g_strdup_printf
- (_("Message: %s"),
- g_basename(filename ? filename : file));
+
+ msginfo = procheader_parse_file(file, flags, FALSE, FALSE);
+ if (msginfo && msginfo->subject)
+ name = msginfo->subject;
+ else
+ name = g_basename(filename ? filename : file);
+
+ ainfo->name = g_strdup_printf(_("Message: %s"), name);
+
+ procmsg_msginfo_free(msginfo);
} else {
if (!g_strncasecmp(content_type, "text", 4))
ainfo->encoding =
gtk_clist_set_row_data(GTK_CLIST(compose->attach_clist), row, ainfo);
}
-#define IS_FIRST_PART_TEXT(info) \
- ((info->mime_type == MIME_TEXT || info->mime_type == MIME_TEXT_HTML || \
- info->mime_type == MIME_TEXT_ENRICHED) || \
- (info->mime_type == MIME_MULTIPART && info->content_type && \
- !strcasecmp(info->content_type, "multipart/alternative") && \
- (info->children && \
- (info->children->mime_type == MIME_TEXT || \
- info->children->mime_type == MIME_TEXT_HTML || \
- info->children->mime_type == MIME_TEXT_ENRICHED))))
+#ifdef USE_GPGME
+static void compose_use_signing(Compose *compose, gboolean use_signing)
+{
+ GtkItemFactory *ifactory;
+ GtkWidget *menuitem = NULL;
+
+ compose->use_signing = use_signing;
+ ifactory = gtk_item_factory_from_widget(compose->menubar);
+ menuitem = gtk_item_factory_get_item
+ (ifactory, "/Message/Sign");
+ gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem),
+ use_signing);
+ compose_update_gnupg_mode_menu_item(compose);
+}
+#endif /* USE_GPGME */
+
+#define NEXT_PART_NOT_CHILD(info) \
+{ \
+ node = info->node; \
+ while (node->children) \
+ node = g_node_last_child(node); \
+ info = procmime_mimeinfo_next((MimeInfo *)node->data); \
+}
static void compose_attach_parts(Compose *compose, MsgInfo *msginfo)
{
MimeInfo *mimeinfo;
MimeInfo *child;
- gchar *infile;
+ MimeInfo *firsttext = NULL;
+ MimeInfo *encrypted = NULL;
+ GNode *node;
gchar *outfile;
+ const gchar *partname = NULL;
mimeinfo = procmime_scan_message(msginfo);
if (!mimeinfo) return;
- /* skip first text (presumably message body) */
- child = mimeinfo->children;
- if (!child || IS_FIRST_PART_TEXT(mimeinfo)) {
+ if (mimeinfo->node->children == NULL) {
procmime_mimeinfo_free_all(mimeinfo);
return;
}
- if (IS_FIRST_PART_TEXT(child))
- child = child->next;
-
- infile = procmsg_get_message_file_path(msginfo);
+ /* find first content part */
+ child = (MimeInfo *) mimeinfo->node->children->data;
+ while (child && child->node->children && (child->type == MIMETYPE_MULTIPART))
+ child = (MimeInfo *)child->node->children->data;
+ if (child->type == MIMETYPE_TEXT) {
+ firsttext = child;
+ debug_print("First text part found\n");
+ } else if (compose->mode == COMPOSE_REEDIT &&
+ child->type == MIMETYPE_APPLICATION &&
+ !strcasecmp(child->subtype, "pgp-encrypted")) {
+ AlertValue val;
+ val = alertpanel(_("Encrypted message"),
+ _("Cannot re-edit an encrypted message. \n"
+ "Discard encrypted part?"),
+ _("Yes"), _("No"), NULL);
+ if (val == G_ALERTDEFAULT)
+ encrypted = (MimeInfo *)child->node->parent->data;
+ }
+
+ child = (MimeInfo *) mimeinfo->node->children->data;
while (child != NULL) {
- if (child->children || child->mime_type == MIME_MULTIPART) {
+ if (child == encrypted) {
+ /* skip this part of tree */
+ NEXT_PART_NOT_CHILD(child);
+ continue;
+ }
+
+ if (child->type == MIMETYPE_MULTIPART) {
+ /* get the actual content */
child = procmime_mimeinfo_next(child);
continue;
}
- if(child->parent && child->parent->parent
- && !strcasecmp(child->parent->parent->content_type, "multipart/signed")
- && child->mime_type == MIME_TEXT) {
- /* this is the main text part of a signed message */
+
+ if (child == firsttext) {
+ child = procmime_mimeinfo_next(child);
+ continue;
+ }
+
+ if ((compose->mode == COMPOSE_REEDIT ||
+ compose->mode == COMPOSE_FORWARD_INLINE ||
+ compose->mode == COMPOSE_FORWARD ) &&
+ (child->type == MIMETYPE_APPLICATION) &&
+ !strcmp(child->subtype, "pgp-signature")) {
+#ifdef USE_GPGME
+ if (compose->mode == COMPOSE_REEDIT) {
+ compose->gnupg_mode = GNUPG_MODE_DETACH;
+ compose_use_signing(compose, TRUE);
+ }
+#endif
child = procmime_mimeinfo_next(child);
continue;
}
outfile = procmime_get_tmp_file_name(child);
- if (procmime_get_part(outfile, infile, child) < 0)
+ if (procmime_get_part(outfile, child) < 0)
g_warning("Can't get the part of multipart message.");
- else if (compose->mode != COMPOSE_REEDIT || strcmp(child->content_type, "application/pgp-signature"))
- compose_attach_append
- (compose, outfile,
- child->filename ? child->filename : child->name,
- child->content_type);
-
- child = child->next;
+ else {
+ gchar *content_type;
+
+ content_type = procmime_get_content_type_str(child->type, child->subtype);
+ partname = procmime_mimeinfo_get_parameter(child, "name");
+ if (partname == NULL)
+ partname = "";
+ compose_attach_append(compose, outfile,
+ partname, content_type);
+ g_free(content_type);
+ }
+ g_free(outfile);
+ NEXT_PART_NOT_CHILD(child);
}
-
- g_free(infile);
procmime_mimeinfo_free_all(mimeinfo);
}
-#undef IS_FIRST_PART_TEXT
+#undef NEXT_PART_NOT_CHILD
#define GET_CHAR(pos, buf, len) \
{ \
((len > 2 && conv_get_current_charset() == C_UTF_8) ? 2 : \
(len == 2 && conv_get_current_charset() == C_UTF_8) ? 1 : len)
-#define INDENT_CHARS ">|#"
#define SPACE_CHARS " \t"
static void compose_wrap_line(Compose *compose)
if (ch_len == 1
&& strchr(prefs_common.quote_chars, *cbuf))
quoted = 1;
- else if (ch_len != 1 || !isspace(*cbuf))
+ else if (ch_len != 1 || !isspace(*(guchar *)cbuf))
quoted = 0;
line_end = 0;
ch_len = 1;
}
- if (ch_len == 1 && isspace(*cbuf))
+ if (ch_len == 1 && isspace(*(guchar *)cbuf))
space = 1;
if (ch_len == 1 && *cbuf == '\n') {
guint replace = 0;
- if (last_ch_len == 1 && !isspace(last_ch)) {
+ if (last_ch_len == 1 && !isspace((guchar)last_ch)) {
if (cur_pos + 1 < p_end) {
GET_CHAR(cur_pos + 1, cbuf, ch_len);
- if (ch_len == 1 && !isspace(*cbuf))
+ if (ch_len == 1 &&
+ !isspace(*(guchar *)cbuf))
replace = 1;
}
}
gint tlen = ch_len;
GET_CHAR(line_pos - 1, cbuf, ch_len);
- if (ch_len == 1 && isspace(*cbuf)) {
+ if (ch_len == 1 && isspace(*(guchar *)cbuf)) {
gtk_stext_set_point(text, line_pos);
gtk_stext_backward_delete(text, 1);
p_end--;
gboolean is_space;
gboolean is_indent;
+ if (prefs_common.quote_chars == NULL) {
+ return 0 ;
+ }
+
for (i = start_pos; i < text_len; i++) {
GET_CHAR(i, cbuf, ch_len);
if (ch_len > 1)
break;
case WAIT_FOR_INDENT_CHAR_OR_SPACE:
if (is_indent == FALSE && is_space == FALSE &&
- !isupper(cbuf[0]))
+ !isupper((guchar)cbuf[0]))
goto out;
if (is_space == TRUE) {
alnum_cnt = 0;
}
break;
case WAIT_FOR_INDENT_CHAR:
- if (is_indent == FALSE && !isupper(cbuf[0]))
+ if (is_indent == FALSE && !isupper((guchar)cbuf[0]))
goto out;
if (is_indent == TRUE) {
if (alnum_cnt > 0
/* insert space if it's alphanumeric */
if ((cur_pos != line_pos) &&
- ((clen > 1) || isalnum(cb[0]))) {
+ ((clen > 1) || isalnum((guchar)cb[0]))) {
gtk_stext_insert(text, NULL, NULL,
NULL, " ", 1);
tlen++;
}
/* possible line break */
- if (ch_len == 1 && isspace(*cbuf)) {
+ if (ch_len == 1 && isspace(*(guchar *)cbuf)) {
line_pos = cur_pos + 1;
line_len = cur_len + ch_len;
}
GET_CHAR(line_pos - 1, cbuf, clen);
/* if next character is space delete it */
- if (clen == 1 && isspace(*cbuf)) {
+ if (clen == 1 && isspace(*(guchar *)cbuf)) {
if (p_pos + i_len != line_pos ||
!gtk_stext_is_uri_string
(text, line_pos, tlen)) {
STEXT_FREEZE();
gtk_stext_set_point(text, line_pos);
gtk_stext_insert(text, NULL, NULL, NULL, "\n", 1);
- /* gtk_stext_compact_buffer(text); */
+ gtk_stext_compact_buffer(text);
tlen++;
line_pos++;
/* for loop will increase it */
activate_gnupg_mode(compose, account);
#endif /* USE_GPGME */
- if (!init && account->auto_sig)
+ if (!init && compose->mode != COMPOSE_REDIRECT)
compose_insert_sig(compose, TRUE);
}
g_free(msgpath);
folder_item_remove_msg(folder, msgnum);
+
+ folder_item_scan(folder);
return val;
}
}
#endif
-static gboolean compose_use_attach(Compose *compose) {
- return(gtk_clist_get_row_data(GTK_CLIST(compose->attach_clist), 0) != NULL);
+static gboolean compose_use_attach(Compose *compose)
+{
+ return gtk_clist_get_row_data(GTK_CLIST(compose->attach_clist), 0) != NULL;
}
static gint compose_redirect_write_headers_from_headerlist(Compose *compose,
{
gchar buf[BUFFSIZE];
gchar *str;
- gboolean first_address;
+ gboolean first_to_address;
+ gboolean first_cc_address;
GSList *list;
ComposeHeaderEntry *headerentry;
gchar *headerentryname;
cc_hdr = prefs_common.trans_hdr ? _("Cc:") : "Cc:";
to_hdr = prefs_common.trans_hdr ? _("To:") : "To:";
- first_address = TRUE;
+ first_to_address = TRUE;
+ first_cc_address = TRUE;
for (list = compose->header_list; list; list = list->next) {
headerentry = ((ComposeHeaderEntry *)list->data);
headerentryname = gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(headerentry->combo)->entry));
if (str[0] != '\0') {
compose_convert_header
(buf, sizeof(buf), str,
- strlen("Resent-To") + 2);
- if (first_address) {
- fprintf(fp, "Resent-To: ");
- first_address = FALSE;
- } else {
- fprintf(fp, ",");
+ strlen("Resent-To") + 2, TRUE);
+ if (g_strcasecmp(headerentryname, to_hdr) == 0) {
+ if (first_to_address) {
+ fprintf(fp, "Resent-To: ");
+ first_to_address = FALSE;
+ } else {
+ fprintf(fp, ",");
+ }
}
+ if (g_strcasecmp(headerentryname, cc_hdr) == 0) {
+ if (first_cc_address) {
+ fprintf(fp, "\n");
+ fprintf(fp, "Resent-Cc: ");
+ first_cc_address = FALSE;
+ } else {
+ fprintf(fp, ",");
+ }
+ }
+
fprintf(fp, "%s", buf);
}
}
if (compose->account->name && *compose->account->name) {
compose_convert_header
(buf, sizeof(buf), compose->account->name,
- strlen("From: "));
+ strlen("From: "), TRUE);
fprintf(fp, "Resent-From: %s <%s>\n",
buf, compose->account->address);
} else
g_strstrip(str);
if (*str != '\0') {
compose_convert_header(buf, sizeof(buf), str,
- strlen("Subject: "));
+ strlen("Subject: "), FALSE);
fprintf(fp, "Subject: %s\n", buf);
}
}
/* Resent-Message-ID */
if (compose->account->gen_msgid) {
- compose_generate_msgid(compose, buf, sizeof(buf));
+ compose_generate_msgid(buf, sizeof(buf));
fprintf(fp, "Resent-Message-Id: <%s>\n", buf);
compose->msgid = g_strdup(buf);
}
g_warning("can't change file mode\n");
}
- while (procheader_get_unfolded_line(buf, sizeof(buf), fp)) {
+ while (procheader_get_one_field_asis(buf, sizeof(buf), fp) != -1) {
/* should filter returnpath, delivered-to */
if (g_strncasecmp(buf, "Return-Path:",
strlen("Return-Path:")) == 0 ||
compose_convert_header
(buf, sizeof(buf),
compose->account->name,
- strlen("From: "));
+ strlen("From: "),
+ FALSE);
fprintf(fdest, "%s <%s>",
buf,
compose->account->address);
/* get all composed text */
chars = gtk_editable_get_chars(GTK_EDITABLE(compose->text), 0, -1);
- len = strlen(chars);
if (is_ascii_str(chars)) {
buf = chars;
chars = NULL;
fprintf(fp, "\n--%s\n", compose->boundary);
fprintf(fp, "Content-Type: text/plain; charset=%s\n",
out_codeset);
+#if USE_GPGME
+ if (compose->use_signing && !compose->gnupg_mode)
+ fprintf(fp, "Content-Disposition: inline\n");
+#endif
fprintf(fp, "Content-Transfer-Encoding: %s\n",
procmime_get_encoding_str(encoding));
fputc('\n', fp);
return -1;
}
folder_item_scan(queue);
- if ((num = folder_item_add_msg(queue, tmp, TRUE)) < 0) {
+ if ((num = folder_item_add_msg(queue, tmp, NULL, TRUE)) < 0) {
g_warning("can't queue the message\n");
unlink(tmp);
g_free(tmp);
fprintf(fp, "Content-Disposition: inline\n");
} else {
compose_convert_header(filename, sizeof(filename),
- ainfo->name, 12);
+ ainfo->name, 12, FALSE);
fprintf(fp, "Content-Type: %s;\n"
" name=\"%s\"\n",
ainfo->content_type, filename);
#define QUOTE_IF_REQUIRED(out, str) \
{ \
- if (*str != '"' && (strchr(str, ',') \
- || strchr(str, '.'))) { \
+ if (*str != '"' && strpbrk(str, ",.[]<>")) { \
gchar *__tmp; \
gint len; \
\
compose->to_list = address_list_append \
(compose->to_list, str); \
compose_convert_header \
- (buf, sizeof(buf), str, strlen(header) + 2); \
+ (buf, sizeof(buf), str, strlen(header) + 2, \
+ TRUE); \
fprintf(fp, "%s: %s\n", header, buf); \
} \
} \
static gint compose_write_headers_from_headerlist(Compose *compose,
FILE *fp,
- gchar *header)
+ const gchar *header,
+ const gchar *seperator)
{
- gchar buf[BUFFSIZE];
gchar *str, *header_w_colon, *trans_hdr;
- gboolean first_address;
+ gboolean write_header = FALSE;
GSList *list;
ComposeHeaderEntry *headerentry;
gchar * headerentryname;
+ GString *headerstr;
if (IS_IN_CUSTOM_HEADER(header)) {
return 0;
debug_print("Writing %s-header\n", header);
+ headerstr = g_string_sized_new(64);
+
header_w_colon = g_strconcat(header, ":", NULL);
trans_hdr = (prefs_common.trans_hdr ? gettext(header_w_colon) : header_w_colon);
- first_address = TRUE;
for (list = compose->header_list; list; list = list->next) {
headerentry = ((ComposeHeaderEntry *)list->data);
headerentryname = gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(headerentry->combo)->entry));
Xstrdup_a(str, str, return -1);
g_strstrip(str);
if (str[0] != '\0') {
- compose_convert_header
- (buf, sizeof(buf), str,
- strlen(header) + 2);
- if (first_address) {
- fprintf(fp, "%s: ", header);
- first_address = FALSE;
- } else {
- fprintf(fp, ",");
- }
- fprintf(fp, "%s", buf);
+ if (write_header)
+ g_string_append(headerstr, seperator);
+ g_string_append(headerstr, str);
+ write_header = TRUE;
}
}
}
- if (!first_address) {
- fprintf(fp, "\n");
+ if (write_header) {
+ gchar *buf;
+
+ buf = g_new0(gchar, headerstr->len * 4 + 256);
+ compose_convert_header
+ (buf, headerstr->len * 4 + 256, headerstr->str,
+ strlen(header) + 2, TRUE);
+ fprintf(fp, "%s: %s\n", header, buf);
+ g_free(buf);
}
g_free(header_w_colon);
+ g_string_free(headerstr, TRUE);
return(0);
}
}
/* From */
- if (!IS_IN_CUSTOM_HEADER("From")) {
- if (compose->account->name && *compose->account->name) {
- compose_convert_header
- (buf, sizeof(buf), compose->account->name,
- strlen("From: "));
- QUOTE_IF_REQUIRED(name, buf);
- fprintf(fp, "From: %s <%s>\n",
- name, compose->account->address);
- } else
- fprintf(fp, "From: %s\n", compose->account->address);
- }
+ if (compose->account->name && *compose->account->name) {
+ compose_convert_header
+ (buf, sizeof(buf), compose->account->name,
+ strlen("From: "), TRUE);
+ QUOTE_IF_REQUIRED(name, buf);
+ fprintf(fp, "From: %s <%s>\n",
+ name, compose->account->address);
+ } else
+ fprintf(fp, "From: %s\n", compose->account->address);
/* To */
- compose_write_headers_from_headerlist(compose, fp, "To");
+ compose_write_headers_from_headerlist(compose, fp, "To", ", ");
#if 0 /* NEW COMPOSE GUI */
if (compose->use_to) {
str = gtk_entry_get_text(GTK_ENTRY(compose->to_entry));
#endif
/* Newsgroups */
- compose_write_headers_from_headerlist(compose, fp, "Newsgroups");
+ compose_write_headers_from_headerlist(compose, fp, "Newsgroups", ",");
#if 0 /* NEW COMPOSE GUI */
if (compose->use_newsgroups) {
str = gtk_entry_get_text(GTK_ENTRY(compose->newsgroups_entry));
newsgroup_list_append
(compose->newsgroup_list, str);
compose_convert_header(buf, sizeof(buf), str,
- strlen("Newsgroups: "));
+ strlen("Newsgroups: "),
+ TRUE);
fprintf(fp, "Newsgroups: %s\n", buf);
}
}
}
#endif
/* Cc */
- compose_write_headers_from_headerlist(compose, fp, "Cc");
+ compose_write_headers_from_headerlist(compose, fp, "Cc", ", ");
#if 0 /* NEW COMPOSE GUI */
if (compose->use_cc) {
str = gtk_entry_get_text(GTK_ENTRY(compose->cc_entry));
}
#endif
/* Bcc */
- compose_write_headers_from_headerlist(compose, fp, "Bcc");
+ compose_write_headers_from_headerlist(compose, fp, "Bcc", ", ");
#if 0 /* NEW COMPOSE GUI */
if (compose->use_bcc) {
str = gtk_entry_get_text(GTK_ENTRY(compose->bcc_entry));
g_strstrip(str);
if (*str != '\0') {
compose_convert_header(buf, sizeof(buf), str,
- strlen("Subject: "));
+ strlen("Subject: "), FALSE);
fprintf(fp, "Subject: %s\n", buf);
}
}
/* Message-ID */
if (compose->account->gen_msgid) {
- compose_generate_msgid(compose, buf, sizeof(buf));
+ compose_generate_msgid(buf, sizeof(buf));
fprintf(fp, "Message-Id: <%s>\n", buf);
compose->msgid = g_strdup(buf);
}
- /* In-Reply-To */
- if (compose->inreplyto && compose->to_list)
- fprintf(fp, "In-Reply-To: <%s>\n", compose->inreplyto);
-
- /* References */
- if (compose->references)
- fprintf(fp, "References: %s\n", compose->references);
+ if (compose->remove_references == FALSE) {
+ /* In-Reply-To */
+ if (compose->inreplyto && compose->to_list)
+ fprintf(fp, "In-Reply-To: <%s>\n", compose->inreplyto);
+
+ /* References */
+ if (compose->references)
+ fprintf(fp, "References: %s\n", compose->references);
+ }
/* Followup-To */
- compose_write_headers_from_headerlist(compose, fp, "Followup-To");
+ compose_write_headers_from_headerlist(compose, fp, "Followup-To", ",");
#if 0 /* NEW COMPOSE GUI */
if (compose->use_followupto && !IS_IN_CUSTOM_HEADER("Followup-To")) {
str = gtk_entry_get_text(GTK_ENTRY(compose->followup_entry));
remove_space(str);
if (*str != '\0') {
compose_convert_header(buf, sizeof(buf), str,
- strlen("Followup-To: "));
+ strlen("Followup-To: "),
+ TRUE);
fprintf(fp, "Followup-To: %s\n", buf);
}
}
}
#endif
/* Reply-To */
- compose_write_headers_from_headerlist(compose, fp, "Reply-To");
+ compose_write_headers_from_headerlist(compose, fp, "Reply-To", ", ");
#if 0 /* NEW COMPOSE GUI */
if (compose->use_replyto && !IS_IN_CUSTOM_HEADER("Reply-To")) {
str = gtk_entry_get_text(GTK_ENTRY(compose->reply_entry));
g_strstrip(str);
if (*str != '\0') {
compose_convert_header(buf, sizeof(buf), str,
- strlen("Reply-To: "));
+ strlen("Reply-To: "),
+ TRUE);
fprintf(fp, "Reply-To: %s\n", buf);
}
}
!IS_IN_CUSTOM_HEADER("Organization")) {
compose_convert_header(buf, sizeof(buf),
compose->account->organization,
- strlen("Organization: "));
+ strlen("Organization: "), FALSE);
fprintf(fp, "Organization: %s\n", buf);
}
cur = cur->next) {
CustomHeader *chdr = (CustomHeader *)cur->data;
- if (strcasecmp(chdr->name, "Date") != 0 &&
- strcasecmp(chdr->name, "From") != 0 &&
- strcasecmp(chdr->name, "To") != 0 &&
- /* strcasecmp(chdr->name, "Sender") != 0 && */
- strcasecmp(chdr->name, "Message-Id") != 0 &&
- strcasecmp(chdr->name, "In-Reply-To") != 0 &&
- strcasecmp(chdr->name, "References") != 0 &&
- strcasecmp(chdr->name, "Mime-Version") != 0 &&
- strcasecmp(chdr->name, "Content-Type") != 0 &&
- strcasecmp(chdr->name, "Content-Transfer-Encoding")
- != 0) {
+ if (custom_header_is_allowed(chdr->name)) {
compose_convert_header
(buf, sizeof(buf),
chdr->value ? chdr->value : "",
- strlen(chdr->name) + 2);
+ strlen(chdr->name) + 2, FALSE);
fprintf(fp, "%s: %s\n", chdr->name, buf);
}
}
/* MIME */
fprintf(fp, "Mime-Version: 1.0\n");
if (compose_use_attach(compose)) {
- get_rfc822_date(buf, sizeof(buf));
- subst_char(buf, ' ', '_');
- subst_char(buf, ',', '_');
- compose->boundary = g_strdup_printf("Multipart_%s_%08x",
- buf, (guint)compose);
+ compose->boundary = generate_mime_boundary(NULL);
fprintf(fp,
"Content-Type: multipart/mixed;\n"
" boundary=\"%s\"\n", compose->boundary);
} else {
fprintf(fp, "Content-Type: text/plain; charset=%s\n", charset);
+#if USE_GPGME
+ if (compose->use_signing && !compose->gnupg_mode)
+ fprintf(fp, "Content-Disposition: inline\n");
+#endif
fprintf(fp, "Content-Transfer-Encoding: %s\n",
procmime_get_encoding_str(encoding));
}
if (compose->return_receipt) {
if (compose->account->name
&& *compose->account->name) {
- compose_convert_header(buf, sizeof(buf), compose->account->name, strlen("Disposition-Notification-To: "));
+ compose_convert_header(buf, sizeof(buf),
+ compose->account->name,
+ strlen("Disposition-Notification-To: "),
+ TRUE);
fprintf(fp, "Disposition-Notification-To: %s <%s>\n", buf, compose->account->address);
} else
fprintf(fp, "Disposition-Notification-To: %s\n", compose->account->address);
headerentry = ((ComposeHeaderEntry *)list->data);
tmp = g_strdup(gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(headerentry->combo)->entry)));
+ if (strchr(tmp, ' ') != NULL || strchr(tmp, '\r') != NULL || strchr(tmp, '\n') != NULL) {
+ g_free(tmp);
+ continue;
+ }
+
if (!strstr(tmp, ":")) {
headername_wcolon = g_strconcat(tmp, ":", NULL);
headername = g_strdup(tmp);
g_free(tmp);
headervalue = gtk_entry_get_text(GTK_ENTRY(headerentry->entry));
+ subst_char(headervalue, '\r', ' ');
+ subst_char(headervalue, '\n', ' ');
string = std_headers;
while (*string != NULL) {
headername_trans = prefs_common.trans_hdr ? gettext(*string) : *string;
fprintf(fp, "%s %s\n", headername_wcolon, headervalue);
g_free(headername);
- g_free(headername_wcolon);
-
+ g_free(headername_wcolon);
}
/* separator between header and body */
#undef IS_IN_CUSTOM_HEADER
static void compose_convert_header(gchar *dest, gint len, gchar *src,
- gint header_len)
+ gint header_len, gboolean addr_field)
{
g_return_if_fail(src != NULL);
g_return_if_fail(dest != NULL);
if (len < 1) return;
+ subst_char(src, '\n', ' ');
+ subst_char(src, '\r', ' ');
g_strchomp(src);
- conv_encode_header(dest, len, src, header_len);
+ conv_encode_header(dest, len, src, header_len, addr_field);
}
-static void compose_generate_msgid(Compose *compose, gchar *buf, gint len)
+static void compose_generate_msgid(gchar *buf, gint len)
{
struct tm *lt;
time_t t;
t = time(NULL);
lt = localtime(&t);
- if (compose->account && compose->account->address &&
- *compose->account->address) {
- if (strchr(compose->account->address, '@'))
- addr = g_strdup(compose->account->address);
- else
- addr = g_strconcat(compose->account->address, "@",
- get_domain_name(), NULL);
- } else
- addr = g_strconcat(g_get_user_name(), "@", get_domain_name(),
- NULL);
+ addr = g_strconcat("@", get_domain_name(), NULL);
- g_snprintf(buf, len, "%04d%02d%02d%02d%02d%02d.%08x.%s",
+ g_snprintf(buf, len, "%04d%02d%02d%02d%02d%02d.%08x%s",
lt->tm_year + 1900, lt->tm_mon + 1,
lt->tm_mday, lt->tm_hour,
lt->tm_min, lt->tm_sec,
gtk_signal_connect(GTK_OBJECT(entry), "key-press-event", GTK_SIGNAL_FUNC(compose_headerentry_key_press_event_cb), headerentry);
gtk_signal_connect(GTK_OBJECT(entry), "changed", GTK_SIGNAL_FUNC(compose_headerentry_changed_cb), headerentry);
gtk_signal_connect(GTK_OBJECT(entry), "activate", GTK_SIGNAL_FUNC(text_activated), compose);
+ gtk_signal_connect(GTK_OBJECT(entry), "button-press-event",
+ GTK_SIGNAL_FUNC(compose_headerentry_button_pressed),
+ NULL);
address_completion_register_entry(GTK_ENTRY(entry));
}
gtk_window_set_geometry_hints(GTK_WINDOW(window), NULL,
&geometry, GDK_HINT_MAX_SIZE);
-
+ gtk_widget_set_uposition(window, prefs_common.compose_x,
+ prefs_common.compose_y);
gtk_signal_connect(GTK_OBJECT(window), "delete_event",
GTK_SIGNAL_FUNC(compose_delete_cb), compose);
gtk_signal_connect(GTK_OBJECT(window), "destroy",
ifactory = gtk_item_factory_from_widget(menubar);
menu_set_sensitive(ifactory, "/Edit/Undo", FALSE);
menu_set_sensitive(ifactory, "/Edit/Redo", FALSE);
+ menu_set_sensitive(ifactory, "/Message/Remove references", FALSE);
tmpl_menu = gtk_item_factory_get_item(ifactory, "/Tools/Template");
#if 0 /* NEW COMPOSE GUI */
}
#endif
- update_compose_actions_menu(ifactory, "/Tools/Actions", compose);
-
-
undostruct = undo_init(text);
undo_set_change_state_func(undostruct, &compose_undo_state_changed,
menubar);
compose->modified = FALSE;
compose->return_receipt = FALSE;
- compose->paste_as_quotation = FALSE;
compose->to_list = NULL;
compose->newsgroup_list = NULL;
compose->exteditor_pid = -1;
compose->exteditor_readdes = -1;
compose->exteditor_tag = -1;
+ compose->draft_timeout_tag = -1;
#if USE_ASPELL
menu_set_sensitive(ifactory, "/Spelling", FALSE);
if (mode != COMPOSE_REDIRECT) {
if (prefs_common.enable_aspell && prefs_common.dictionary &&
strcmp(prefs_common.dictionary, _("None"))) {
- gtkaspell = gtkaspell_new((const gchar*)prefs_common.dictionary,
+ gtkaspell = gtkaspell_new(prefs_common.aspell_path,
+ prefs_common.dictionary,
conv_get_current_charset_str(),
prefs_common.misspelled_col,
prefs_common.check_while_typing,
prefs_common.use_alternate,
GTK_STEXT(text));
if (!gtkaspell) {
- alertpanel_error(_("Spell checker could not be started.\n%s"), gtkaspellcheckers->error_message);
+ alertpanel_error(_("Spell checker could not "
+ "be started.\n%s"),
+ gtkaspell_checkers_strerror());
gtkaspell_checkers_reset_error();
} else {
GtkWidget *menuitem;
- if (!gtkaspell_set_sug_mode(gtkaspell, prefs_common.aspell_sugmode)) {
- debug_print("Aspell: could not set suggestion mode %s\n",
- gtkaspellcheckers->error_message);
+ if (!gtkaspell_set_sug_mode(gtkaspell,
+ prefs_common.aspell_sugmode)) {
+ debug_print("Aspell: could not set "
+ "suggestion mode %s\n",
+ gtkaspell_checkers_strerror());
gtkaspell_checkers_reset_error();
}
- menuitem = gtk_item_factory_get_item(ifactory, "/Spelling/Spelling Configuration");
+ menuitem = gtk_item_factory_get_item(ifactory,
+ "/Spelling/Spelling Configuration");
gtkaspell_populate_submenu(gtkaspell, menuitem);
menu_set_sensitive(ifactory, "/Spelling", TRUE);
- }
+ }
}
}
+ compose->gtkaspell = gtkaspell;
#endif
compose_select_account(compose, account, TRUE);
-#if USE_ASPELL
- compose->gtkaspell = gtkaspell;
-#endif
-
if (account->set_autocc && account->auto_cc && mode != COMPOSE_REEDIT)
compose_entry_append(compose, account->auto_cc, COMPOSE_CC);
gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(compose->header_last->combo)->entry), prefs_common.trans_hdr ? _("Newsgroups:") : "Newsgroups:");
addressbook_set_target_compose(compose);
- update_compose_actions_menu(ifactory, "/Tools/Actions", compose);
if (mode != COMPOSE_REDIRECT)
compose_set_template_menu(compose);
/* Priority */
compose->priority = PRIORITY_NORMAL;
compose_update_priority_menu_item(compose);
-
+
+ /* Actions menu */
+ compose_update_actions_menu(compose);
+
#if USE_GPGME
activate_gnupg_mode(compose, account);
#endif
gtk_menu_item_set_submenu(GTK_MENU_ITEM(compose->tmpl_menu), menu);
}
+void compose_update_actions_menu(Compose *compose)
+{
+ GtkItemFactory *ifactory;
+
+ ifactory = gtk_item_factory_from_widget(compose->menubar);
+ action_update_compose_menu(ifactory, "/Tools/Actions", compose);
+}
+
void compose_reflect_prefs_all(void)
{
GList *cur;
gtk_widget_set_sensitive(compose->toolbar->insert_btn, sensitive);
gtk_widget_set_sensitive(compose->toolbar->sig_btn, sensitive);
gtk_widget_set_sensitive(compose->toolbar->exteditor_btn, sensitive);
- gtk_widget_set_sensitive(compose->toolbar->linewrap_btn, sensitive);
+ gtk_widget_set_sensitive(compose->toolbar->linewrap_current_btn, sensitive);
+ gtk_widget_set_sensitive(compose->toolbar->linewrap_all_btn, sensitive);
}
/**
g_return_if_fail(widget != NULL);
- debug_print("Set_undo. UNDO:%i REDO:%i\n", undo_state, redo_state);
-
ifactory = gtk_item_factory_from_widget(widget);
switch (undo_state) {
case UNDO_STATE_TRUE:
if (!undostruct->undo_state) {
- debug_print ("Set_undo - Testpoint\n");
undostruct->undo_state = TRUE;
menu_set_sensitive(ifactory, "/Edit/Undo", TRUE);
}
Compose *compose = (Compose *)data;
PrefsAccount *ac;
+ gchar *folderidentifier;
ac = account_find_from_id(
GPOINTER_TO_INT(gtk_object_get_user_data(GTK_OBJECT(menuitem))));
if (ac != compose->account)
compose_select_account(compose, ac, FALSE);
+
+ /* Set message save folder */
+ if (account_get_special_folder(compose->account, F_OUTBOX)) {
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(compose->savemsg_checkbtn), prefs_common.savemsg);
+ }
+ gtk_signal_connect(GTK_OBJECT(compose->savemsg_checkbtn), "toggled",
+ GTK_SIGNAL_FUNC(compose_savemsg_checkbtn_cb), compose);
+
+ gtk_editable_delete_text(GTK_EDITABLE(compose->savemsg_entry), 0, -1);
+ if (account_get_special_folder(compose->account, F_OUTBOX)) {
+ folderidentifier = folder_item_get_identifier(account_get_special_folder
+ (compose->account, F_OUTBOX));
+ gtk_entry_set_text(GTK_ENTRY(compose->savemsg_entry), folderidentifier);
+ g_free(folderidentifier);
+ }
}
static void attach_selected(GtkCList *clist, gint row, gint column,
toolbar_comp_set_sensitive(compose, allow);
menu_set_sensitive(ifactory, "/File", allow);
menu_set_sensitive(ifactory, "/Edit", allow);
+#if USE_ASPELL
menu_set_sensitive(ifactory, "/Spelling", allow);
+#endif
menu_set_sensitive(ifactory, "/Message", allow);
menu_set_sensitive(ifactory, "/Tools", allow);
menu_set_sensitive(ifactory, "/Help", allow);
_("Yes"), _("No"), NULL) != G_ALERTDEFAULT)
return;
+ if (compose->draft_timeout_tag != -1) { /* CLAWS: disable draft timeout */
+ gtk_timeout_remove(compose->draft_timeout_tag);
+ compose->draft_timeout_tag = -1;
+ }
+
compose_allow_user_actions (compose, FALSE);
compose->sending = TRUE;
val = compose_send(compose);
FolderItem *draft;
gchar *tmp;
gint msgnum;
+ MsgFlags flag = {0, 0};
static gboolean lock = FALSE;
MsgInfo *newmsginfo;
return;
}
- if ((msgnum = folder_item_add_msg(draft, tmp, TRUE)) < 0) {
+ folder_item_scan(draft);
+ if ((msgnum = folder_item_add_msg(draft, tmp, &flag, TRUE)) < 0) {
unlink(tmp);
g_free(tmp);
lock = FALSE;
procmsg_msginfo_free(newmsginfo);
}
+ folder_item_scan(draft);
+
lock = FALSE;
/* 0: quit editing 1: keep editing 2: keep editing (autosave) */
for ( tmp = file_list; tmp; tmp = tmp->next) {
gchar *file = (gchar *) tmp->data;
- compose_insert_file(compose, file);
+ gchar *filedup = g_strdup(file);
+ gchar *shortfile;
+ ComposeInsertResult res;
+
+ res = compose_insert_file(compose, file);
+ shortfile = g_basename(filedup);
+ if (res == COMPOSE_INSERT_READ_ERROR) {
+ alertpanel_error(_("File '%s' could not be read."), shortfile);
+ } else if (res == COMPOSE_INSERT_INVALID_CHARACTER) {
+ alertpanel_error(_("File '%s' contained invalid characters\n"
+ "for the current encoding, insertion may be incorrect."), shortfile);
+ }
+ g_free(filedup);
g_free(file);
}
g_list_free(file_list);
static gint compose_delete_cb(GtkWidget *widget, GdkEventAny *event,
gpointer data)
{
+ gint x, y;
Compose *compose = (Compose *)data;
+
+ gtkut_widget_get_uposition(widget, &x, &y);
+ prefs_common.compose_x = x;
+ prefs_common.compose_y = y;
+
if (compose->sending)
return TRUE;
compose_close_cb(compose, 0, NULL);
{
Compose *compose = (Compose *)data;
AlertValue val;
-
+
if (compose->exteditor_tag != -1) {
if (!compose_ext_editor_kill(compose))
return;
{
if (compose->focused_editable &&
GTK_WIDGET_HAS_FOCUS(compose->focused_editable)) {
- compose->paste_as_quotation = TRUE;
+ /* let text_insert() (called directly or at a later time
+ * after the gtk_editable_paste_clipboard) know that
+ * text is to be inserted as a quotation. implemented
+ * by using a simple refcount... */
+ gint paste_as_quotation = GPOINTER_TO_INT(gtk_object_get_data(
+ GTK_OBJECT(compose->focused_editable),
+ "paste_as_quotation"));
+ gtk_object_set_data(GTK_OBJECT(compose->focused_editable),
+ "paste_as_quotation",
+ GINT_TO_POINTER(paste_as_quotation + 1));
gtk_editable_paste_clipboard
(GTK_EDITABLE(compose->focused_editable));
- compose->paste_as_quotation = FALSE;
}
}
compose->return_receipt = FALSE;
}
+static void compose_toggle_remove_refs_cb(gpointer data, guint action,
+ GtkWidget *widget)
+{
+ Compose *compose = (Compose *)data;
+
+ if (GTK_CHECK_MENU_ITEM(widget)->active)
+ compose->remove_references = TRUE;
+ else
+ compose->remove_references = FALSE;
+}
+
void compose_headerentry_key_press_event_cb(GtkWidget *entry,
GdkEventKey *event,
ComposeHeaderEntry *headerentry)
}
}
+static gboolean compose_headerentry_button_pressed
+ (GtkWidget *entry, GdkEventButton *event, gpointer data)
+{
+ /* if this is a lclick, grab the focus */
+ if (event->button == 1)
+ gtk_widget_grab_focus(entry);
+ return FALSE;
+}
+
static void compose_show_first_last_header(Compose *compose, gboolean show_first)
{
GtkAdjustment *vadj;
gint length, gint *position, Compose *compose)
{
GtkEditable *editable = GTK_EDITABLE(widget);
+ gint paste_as_quotation = GPOINTER_TO_INT(gtk_object_get_data
+ (GTK_OBJECT(widget), "paste_as_quotation"));
gtk_signal_handler_block_by_func(GTK_OBJECT(widget),
GTK_SIGNAL_FUNC(text_inserted),
compose);
- if (compose->paste_as_quotation) {
+ if (paste_as_quotation) {
gchar *new_text;
gchar *qmark;
gint pos;
gtk_editable_set_position(editable, pos);
*position = pos;
g_free(new_text);
+ gtk_object_set_data(GTK_OBJECT(widget), "paste_as_quotation",
+ GINT_TO_POINTER(paste_as_quotation - 1));
} else
gtk_editable_insert_text(editable, text, length, position);
compose);
gtk_signal_emit_stop_by_name(GTK_OBJECT(editable), "insert_text");
-
if (prefs_common.autosave &&
gtk_stext_get_length(GTK_STEXT(widget)) % prefs_common.autosave_length == 0)
- compose_draft_cb((gpointer)compose, 2, NULL);
+ compose->draft_timeout_tag = gtk_timeout_add
+ (500, (GtkFunction) compose_defer_auto_save_draft, compose);
+}
+
+static gint compose_defer_auto_save_draft(Compose *compose)
+{
+ compose->draft_timeout_tag = -1;
+ compose_draft_cb((gpointer)compose, 2, NULL);
+ return FALSE;
}
static gboolean compose_send_control_enter(Compose *compose)
if (!(kev->keyval == GDK_Return && (kev->state & GDK_CONTROL_MASK)))
return FALSE;
+ if (compose->exteditor_tag != -1)
+ return FALSE;
+
ifactory = gtk_item_factory_from_widget(compose->menubar);
send_menu = gtk_item_factory_get_widget(ifactory, "/Message/Send");
list = gtk_accel_group_entries_from_object(GTK_OBJECT(send_menu));
}
#endif
+/**
+ * Add entry field for each address in list.
+ * \param compose E-Mail composition object.
+ * \param listAddress List of (formatted) E-Mail addresses.
+ */
+static void compose_add_field_list( Compose *compose, GList *listAddress ) {
+ GList *node;
+ gchar *addr;
+ node = listAddress;
+ while( node ) {
+ addr = ( gchar * ) node->data;
+ compose_entry_append( compose, addr, COMPOSE_TO );
+ node = g_list_next( node );
+ }
+}
+
+/*
+ * End of Source.
+ */
+
projects / claws.git / blobdiff