#include "defs.h"
+#ifndef PANGO_ENABLE_ENGINE
+# define PANGO_ENABLE_ENGINE
+#endif
+
#include <glib.h>
#include <glib/gi18n.h>
#include <gdk/gdkkeysyms.h>
#include <gtk/gtkdnd.h>
#include <gtk/gtkclipboard.h>
+#include <pango/pango-break.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
static GtkWidget *compose_account_option_menu_create
(Compose *compose);
+static void compose_set_out_encoding (Compose *compose);
static void compose_set_template_menu (Compose *compose);
static void compose_template_apply (Compose *compose,
Template *tmpl,
followup_and_reply_to);
static void compose_reedit_set_entry (Compose *compose,
MsgInfo *msginfo);
+
static void compose_insert_sig (Compose *compose,
gboolean replace);
static gchar *compose_get_signature_str (Compose *compose);
static ComposeInsertResult compose_insert_file (Compose *compose,
const gchar *file);
+
static void compose_attach_append (Compose *compose,
const gchar *file,
const gchar *type,
const gchar *content_type);
static void compose_attach_parts (Compose *compose,
MsgInfo *msginfo);
-static void compose_wrap_line (Compose *compose);
-static void compose_wrap_line_all (Compose *compose);
-static void compose_wrap_line_all_full (Compose *compose,
+
+static void compose_wrap_paragraph (Compose *compose,
+ GtkTextIter *par_iter);
+static void compose_wrap_all (Compose *compose);
+static void compose_wrap_all_full (Compose *compose,
gboolean autowrap);
+
static void compose_set_title (Compose *compose);
static void compose_select_account (Compose *compose,
PrefsAccount *account,
MimeInfo *parent);
static gchar *compose_get_header (Compose *compose);
-static void compose_convert_header (gchar *dest,
+static void compose_convert_header (Compose *compose,
+ gchar *dest,
gint len,
gchar *src,
gint header_len,
gint redo_state,
gpointer data);
-static gint calc_cursor_xpos (GtkTextView *text,
- gint extra,
- gint char_width);
-
static void compose_create_header_entry (Compose *compose);
static void compose_add_header_entry (Compose *compose, gchar *header, gchar *text);
static void compose_update_priority_menu_item(Compose * compose);
guint action,
GtkWidget *widget);
+static void compose_set_encoding_cb (gpointer data,
+ guint action,
+ GtkWidget *widget);
+
static void compose_address_cb (gpointer data,
guint action,
GtkWidget *widget);
static gint compose_delete_cb (GtkWidget *widget,
GdkEventAny *event,
gpointer data);
-static void compose_destroy_cb (GtkWidget *widget,
- Compose *compose);
static void compose_undo_cb (Compose *compose);
static void compose_redo_cb (Compose *compose);
static void compose_grab_focus_cb (GtkWidget *widget,
Compose *compose);
-static void compose_grab_focus_before_cb(GtkWidget *widget,
- Compose *compose);
static void compose_changed_cb (GtkTextBuffer *textbuf,
Compose *compose);
+static void compose_wrap_cb (gpointer data,
+ guint action,
+ GtkWidget *widget);
static void compose_toggle_autowrap_cb (gpointer data,
guint action,
GtkWidget *widget);
NULL},
{N_("/_Edit/---"), NULL, NULL, 0, "<Separator>"},
{N_("/_Edit/_Wrap current paragraph"),
- "<control>L", compose_wrap_line, 0, NULL},
+ "<control>L", compose_wrap_cb, 0, NULL},
{N_("/_Edit/Wrap all long _lines"),
- "<control><alt>L", compose_wrap_line_all, 0, NULL},
+ "<control><alt>L", compose_wrap_cb, 1, NULL},
{N_("/_Edit/Aut_o wrapping"), "<shift><control>L", compose_toggle_autowrap_cb, 0, "<ToggleItem>"},
{N_("/_Edit/---"), NULL, NULL, 0, "<Separator>"},
{N_("/_Edit/Edit with e_xternal editor"),
{N_("/_Options/Priority/_Lowest"), NULL, compose_set_priority_cb, PRIORITY_LOWEST, "/Options/Priority/Highest"},
{N_("/_Options/---"), NULL, NULL, 0, "<Separator>"},
{N_("/_Options/_Request Return Receipt"), NULL, compose_toggle_return_receipt_cb, 0, "<ToggleItem>"},
+ {N_("/_Options/---"), NULL, NULL, 0, "<Separator>"},
{N_("/_Options/Remo_ve references"), NULL, compose_toggle_remove_refs_cb, 0, "<ToggleItem>"},
+ {N_("/_Options/---"), NULL, NULL, 0, "<Separator>"},
+
+#define ENC_ACTION(action) \
+ NULL, compose_set_encoding_cb, action, \
+ "/Options/Character encoding/Automatic"
+
+ {N_("/_Options/Character _encoding"), NULL, NULL, 0, "<Branch>"},
+ {N_("/_Options/Character _encoding/_Automatic"),
+ NULL, compose_set_encoding_cb, C_AUTO, "<RadioItem>"},
+ {N_("/_Options/Character _encoding/---"), NULL, NULL, 0, "<Separator>"},
+
+ {N_("/_Options/Character _encoding/7bit ascii (US-ASC_II)"),
+ ENC_ACTION(C_US_ASCII)},
+ {N_("/_Options/Character _encoding/Unicode (_UTF-8)"),
+ ENC_ACTION(C_UTF_8)},
+ {N_("/_Options/Character _encoding/---"), NULL, NULL, 0, "<Separator>"},
+
+ {N_("/_Options/Character _encoding/Western European (ISO-8859-_1)"),
+ ENC_ACTION(C_ISO_8859_1)},
+ {N_("/_Options/Character _encoding/Western European (ISO-8859-15)"),
+ ENC_ACTION(C_ISO_8859_15)},
+ {N_("/_Options/Character _encoding/---"), NULL, NULL, 0, "<Separator>"},
+
+ {N_("/_Options/Character _encoding/Central European (ISO-8859-_2)"),
+ ENC_ACTION(C_ISO_8859_2)},
+ {N_("/_Options/Character _encoding/---"), NULL, NULL, 0, "<Separator>"},
+
+ {N_("/_Options/Character _encoding/_Baltic (ISO-8859-13)"),
+ ENC_ACTION(C_ISO_8859_13)},
+ {N_("/_Options/Character _encoding/Baltic (ISO-8859-_4)"),
+ ENC_ACTION(C_ISO_8859_4)},
+ {N_("/_Options/Character _encoding/---"), NULL, NULL, 0, "<Separator>"},
+
+ {N_("/_Options/Character _encoding/Greek (ISO-8859-_7)"),
+ ENC_ACTION(C_ISO_8859_7)},
+ {N_("/_Options/Character _encoding/---"), NULL, NULL, 0, "<Separator>"},
+
+ {N_("/_Options/Character _encoding/Hebrew (ISO-8859-_8)"),
+ ENC_ACTION(C_ISO_8859_8)},
+ {N_("/_Options/Character _encoding/Hebrew (Windows-1255)"),
+ ENC_ACTION(C_WINDOWS_1255)},
+ {N_("/_Options/Character _encoding/---"), NULL, NULL, 0, "<Separator>"},
+
+ {N_("/_Options/Character _encoding/Turkish (ISO-8859-_9)"),
+ ENC_ACTION(C_ISO_8859_9)},
+ {N_("/_Options/Character _encoding/---"), NULL, NULL, 0, "<Separator>"},
+
+ {N_("/_Options/Character _encoding/Cyrillic (ISO-8859-_5)"),
+ ENC_ACTION(C_ISO_8859_5)},
+ {N_("/_Options/Character _encoding/Cyrillic (KOI8-_R)"),
+ ENC_ACTION(C_KOI8_R)},
+ {N_("/_Options/Character _encoding/Cyrillic (KOI8-U)"),
+ ENC_ACTION(C_KOI8_U)},
+ {N_("/_Options/Character _encoding/Cyrillic (Windows-1251)"),
+ ENC_ACTION(C_WINDOWS_1251)},
+ {N_("/_Options/Character _encoding/---"), NULL, NULL, 0, "<Separator>"},
+
+ {N_("/_Options/Character _encoding/Japanese (ISO-2022-_JP)"),
+ ENC_ACTION(C_ISO_2022_JP)},
+ {N_("/_Options/Character _encoding/---"), NULL, NULL, 0, "<Separator>"},
+
+ {N_("/_Options/Character _encoding/Simplified Chinese (_GB2312)"),
+ ENC_ACTION(C_GB2312)},
+ {N_("/_Options/Character _encoding/Simplified Chinese (GBK)"),
+ ENC_ACTION(C_GBK)},
+ {N_("/_Options/Character _encoding/Traditional Chinese (_Big5)"),
+ ENC_ACTION(C_BIG5)},
+ {N_("/_Options/Character _encoding/Traditional Chinese (EUC-_TW)"),
+ ENC_ACTION(C_EUC_TW)},
+ {N_("/_Options/Character _encoding/---"), NULL, NULL, 0, "<Separator>"},
+
+ {N_("/_Options/Character _encoding/Korean (EUC-_KR)"),
+ ENC_ACTION(C_EUC_KR)},
+ {N_("/_Options/Character _encoding/---"), NULL, NULL, 0, "<Separator>"},
+
+ {N_("/_Options/Character _encoding/Thai (TIS-620)"),
+ ENC_ACTION(C_TIS_620)},
+ {N_("/_Options/Character _encoding/Thai (Windows-874)"),
+ ENC_ACTION(C_WINDOWS_874)},
+
{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_entry_mark_default_to(compose, item->prefs->default_to);
}
if (item && item->ret_rcpt) {
- menu_set_active(ifactory, "/Message/Request Return Receipt", TRUE);
+ menu_set_active(ifactory, "/Options/Request Return Receipt", TRUE);
}
} else {
if (mailto) {
* CLAWS: just don't allow return receipt request, even if the user
* may want to send an email. simple but foolproof.
*/
- menu_set_sensitive(ifactory, "/Message/Request Return Receipt", FALSE);
+ menu_set_sensitive(ifactory, "/Options/Request Return Receipt", FALSE);
}
compose_add_field_list( compose, listAddress );
return compose;
}
-/*
-Compose *compose_new_followup_and_replyto(PrefsAccount *account,
- const gchar *followupto, gchar * to)
+static void compose_force_encryption(Compose *compose, PrefsAccount *account,
+ gboolean override_pref)
{
- Compose *compose;
+ gchar *privacy = NULL;
- if (!account) account = cur_account;
- g_return_val_if_fail(account != NULL, NULL);
- g_return_val_if_fail(account->protocol != A_NNTP, NULL);
-
- compose = compose_create(account, COMPOSE_NEW);
-
- if (prefs_common.auto_sig)
- compose_insert_sig(compose);
- gtk_editable_set_position(GTK_EDITABLE(compose->text), 0);
- gtk_stext_set_point(GTK_STEXT(compose->text), 0);
-
- compose_entry_append(compose, to, COMPOSE_TO);
- compose_entry_append(compose, followupto, COMPOSE_NEWSGROUPS);
- gtk_widget_grab_focus(compose->subject_entry);
+ if (override_pref == FALSE && account->default_encrypt_reply == FALSE)
+ return;
- return compose;
-}
-*/
+ if (account->default_privacy_system
+ && strlen(account->default_privacy_system)) {
+ privacy = account->default_privacy_system;
+ } else {
+ GSList *privacy_avail = privacy_get_system_ids();
+ if (privacy_avail && g_slist_length(privacy_avail)) {
+ privacy = (gchar *)(privacy_avail->data);
+ }
+ }
+ if (privacy != NULL) {
+ compose->privacy_system = g_strdup(privacy);
+ compose_update_privacy_system_menu_item(compose);
+ compose_use_encryption(compose, TRUE);
+ }
+}
void compose_reply_mode(ComposeMode mode, GSList *msginfo_list, gchar *body)
{
compose->replyinfo = procmsg_msginfo_copy(msginfo);
if (msginfo->folder && msginfo->folder->ret_rcpt)
- menu_set_active(ifactory, "/Message/Request Return Receipt", TRUE);
+ menu_set_active(ifactory, "/Options/Request Return Receipt", TRUE);
/* Set save folder */
if (msginfo->folder && msginfo->folder->prefs && msginfo->folder->prefs->save_copy_to_folder) {
prefs_common.quotefmt,
qmark, body);
}
+ if (procmime_msginfo_is_encrypted(compose->replyinfo)) {
+ compose_force_encryption(compose, account, FALSE);
+ }
if (account->auto_sig)
compose_insert_sig(compose, FALSE);
gtk_text_buffer_place_cursor(textbuf, &iter);
if (quote && prefs_common.linewrap_quote)
- compose_wrap_line_all(compose);
+ compose_wrap_all(compose);
gtk_widget_grab_focus(compose->text);
compose_insert_sig(compose, FALSE);
if (prefs_common.linewrap_quote)
- compose_wrap_line_all(compose);
+ compose_wrap_all(compose);
gtk_text_buffer_get_start_iter(textbuf, &iter);
gtk_text_buffer_place_cursor(textbuf, &iter);
compose_insert_sig(compose, FALSE);
if (prefs_common.linewrap_quote)
- compose_wrap_line_all(compose);
+ compose_wrap_all(compose);
gtk_text_buffer_get_start_iter(textbuf, &iter);
gtk_text_buffer_place_cursor(textbuf, &iter);
void compose_reedit(MsgInfo *msginfo)
{
- Compose *compose;
+ Compose *compose = NULL;
PrefsAccount *account = NULL;
GtkTextView *textview;
GtkTextBuffer *textbuf;
g_signal_handlers_block_by_func(G_OBJECT(textbuf),
G_CALLBACK(compose_changed_cb),
compose);
-
- if ((fp = procmime_get_first_text_content(msginfo)) == NULL)
+
+ if (procmime_msginfo_is_encrypted(msginfo)) {
+ fp = procmime_get_first_encrypted_text_content(msginfo);
+ if (fp)
+ compose_force_encryption(compose, account, TRUE);
+ } else
+ fp = procmime_get_first_text_content(msginfo);
+ if (fp == NULL)
g_warning("Can't get text part\n");
- else {
+
+ if (fp != NULL) {
+ gboolean prev_autowrap = compose->autowrap;
+
+ compose->autowrap = FALSE;
while (fgets(buf, sizeof(buf), fp) != NULL) {
strcrchomp(buf);
gtk_text_buffer_insert(textbuf, &iter, buf, -1);
}
+ compose->autowrap = prev_autowrap;
fclose(fp);
}
ComposeEntryType type)
{
gchar *header;
-
+ gchar *cur, *begin;
+ gboolean in_quote = FALSE;
if (!address || *address == '\0') return;
-#if 0 /* NEW COMPOSE GUI */
- switch (type) {
- case COMPOSE_CC:
- entry = GTK_ENTRY(compose->cc_entry);
- break;
- case COMPOSE_BCC:
- entry = GTK_ENTRY(compose->bcc_entry);
- break;
- case COMPOSE_NEWSGROUPS:
- entry = GTK_ENTRY(compose->newsgroups_entry);
- break;
- case COMPOSE_TO:
- default:
- entry = GTK_ENTRY(compose->to_entry);
- break;
- }
-
- text = gtk_entry_get_text(entry);
- if (*text != '\0')
- gtk_entry_append_text(entry, ", ");
- gtk_entry_append_text(entry, address);
-#endif
-
switch (type) {
case COMPOSE_CC:
header = N_("Cc:");
break;
}
header = prefs_common.trans_hdr ? gettext(header) : header;
-
- compose_add_header_entry(compose, header, (gchar *)address);
+
+ cur = begin = (gchar *)address;
+
+ /* we separate the line by commas, but not if we're inside a quoted
+ * string */
+ while (*cur != '\0') {
+ if (*cur == '"')
+ in_quote = !in_quote;
+ if (*cur == ',' && !in_quote) {
+ gchar *tmp = g_strdup(begin);
+ gchar *o_tmp = tmp;
+ tmp[cur-begin]='\0';
+ cur++;
+ begin = cur;
+ while (*tmp == ' ')
+ tmp++;
+ compose_add_header_entry(compose, header, tmp);
+ g_free(o_tmp);
+ continue;
+ }
+ cur++;
+ }
+ if (begin < cur) {
+ gchar *tmp = g_strdup(begin);
+ gchar *o_tmp = tmp;
+ tmp[cur-begin]='\0';
+ cur++;
+ begin = cur;
+ while (*tmp == ' ')
+ tmp++;
+ compose_add_header_entry(compose, header, tmp);
+ g_free(o_tmp);
+ }
}
void compose_entry_mark_default_to(Compose *compose, const gchar *mailto)
compose_ext_editor_cb(compose, 0, NULL);
break;
case A_LINEWRAP_CURRENT:
- compose_wrap_line(compose);
+ compose_wrap_paragraph(compose, NULL);
break;
case A_LINEWRAP_ALL:
- compose_wrap_line_all(compose);
+ compose_wrap_all(compose);
break;
case A_ADDRBOOK:
compose_address_cb(compose, 0, NULL);
{
gchar *to = NULL;
gchar *cc = NULL;
- gchar *bcc = NULL;
gchar *subject = NULL;
gchar *body = NULL;
gchar *temp = NULL;
gint len = 0;
- scan_mailto_url(mailto, &to, &cc, &bcc, &subject, &body);
+ scan_mailto_url(mailto, &to, &cc, NULL, &subject, &body);
if (to)
compose_entry_append(compose, to, COMPOSE_TO);
if (cc)
compose_entry_append(compose, cc, COMPOSE_CC);
- if (bcc)
- compose_entry_append(compose, bcc, COMPOSE_BCC);
- if (subject)
+ if (subject) {
if (!g_utf8_validate (subject, -1, NULL)) {
temp = g_locale_to_utf8 (subject, -1, NULL, &len, NULL);
gtk_entry_set_text(GTK_ENTRY(compose->subject_entry), temp);
} else {
gtk_entry_set_text(GTK_ENTRY(compose->subject_entry), subject);
}
+ }
if (body) {
GtkTextView *text = GTK_TEXT_VIEW(compose->text);
GtkTextBuffer *buffer = gtk_text_view_get_buffer(text);
GtkTextMark *mark;
GtkTextIter iter;
+ gboolean prev_autowrap = compose->autowrap;
+
+ compose->autowrap = FALSE;
mark = gtk_text_buffer_get_insert(buffer);
gtk_text_buffer_get_iter_at_mark(buffer, &iter, mark);
gtk_text_buffer_insert(buffer, &iter, body, -1);
}
gtk_text_buffer_insert(buffer, &iter, "\n", 1);
+
+ compose->autowrap = prev_autowrap;
+ if (compose->autowrap)
+ compose_wrap_all(compose);
}
g_free(to);
g_free(cc);
- g_free(bcc);
g_free(subject);
g_free(body);
}
fclose(fp);
if (hentry[H_REPLY_TO].body != NULL) {
- conv_unmime_header_overwrite(hentry[H_REPLY_TO].body);
- compose->replyto = hentry[H_REPLY_TO].body;
+ if (hentry[H_REPLY_TO].body[0] != '\0') {
+ compose->replyto =
+ conv_unmime_header(hentry[H_REPLY_TO].body,
+ NULL);
+ }
+ g_free(hentry[H_REPLY_TO].body);
hentry[H_REPLY_TO].body = NULL;
}
if (hentry[H_CC].body != NULL) {
- conv_unmime_header_overwrite(hentry[H_CC].body);
- compose->cc = hentry[H_CC].body;
+ compose->cc = conv_unmime_header(hentry[H_CC].body, NULL);
+ g_free(hentry[H_CC].body);
hentry[H_CC].body = NULL;
}
if (hentry[H_REFERENCES].body != NULL) {
hentry[H_REFERENCES].body = NULL;
}
if (hentry[H_BCC].body != NULL) {
- if (compose->mode == COMPOSE_REEDIT) {
- conv_unmime_header_overwrite(hentry[H_BCC].body);
- compose->bcc = hentry[H_BCC].body;
- } else
- g_free(hentry[H_BCC].body);
+ if (compose->mode == COMPOSE_REEDIT)
+ compose->bcc =
+ conv_unmime_header(hentry[H_BCC].body, NULL);
+ g_free(hentry[H_BCC].body);
hentry[H_BCC].body = NULL;
}
if (hentry[H_NEWSGROUPS].body != NULL) {
- conv_unmime_header_overwrite(hentry[H_NEWSGROUPS].body);
compose->newsgroups = hentry[H_NEWSGROUPS].body;
hentry[H_NEWSGROUPS].body = NULL;
}
if (hentry[H_FOLLOWUP_TO].body != NULL) {
- conv_unmime_header_overwrite(hentry[H_FOLLOWUP_TO].body);
- compose->followup_to = hentry[H_FOLLOWUP_TO].body;
+ if (hentry[H_FOLLOWUP_TO].body[0] != '\0') {
+ compose->followup_to =
+ conv_unmime_header(hentry[H_FOLLOWUP_TO].body,
+ NULL);
+ }
+ g_free(hentry[H_FOLLOWUP_TO].body);
hentry[H_FOLLOWUP_TO].body = NULL;
}
if (hentry[H_LIST_POST].body != NULL) {
compose->priority = priority;
}
- if (compose->mode == COMPOSE_REEDIT && msginfo->inreplyto)
- compose->inreplyto = g_strdup(msginfo->inreplyto);
- else if (compose->mode != COMPOSE_REEDIT &&
- msginfo->msgid && *msginfo->msgid) {
+ if (compose->mode == COMPOSE_REEDIT) {
+ if (msginfo->inreplyto && *msginfo->inreplyto)
+ compose->inreplyto = g_strdup(msginfo->inreplyto);
+ return 0;
+ }
+
+ if (msginfo->msgid && *msginfo->msgid)
compose->inreplyto = g_strdup(msginfo->msgid);
- if (!compose->references) {
+ if (!compose->references) {
+ if (msginfo->msgid && *msginfo->msgid) {
if (msginfo->inreplyto && *msginfo->inreplyto)
compose->references =
g_strdup_printf("<%s>\n\t<%s>",
compose->references =
g_strconcat("<", msginfo->msgid, ">",
NULL);
+ } else if (msginfo->inreplyto && *msginfo->inreplyto) {
+ compose->references =
+ g_strconcat("<", msginfo->inreplyto, ">",
+ NULL);
}
}
gchar *buf;
gchar *p, *lastp;
gint len;
+ gboolean prev_autowrap;
const gchar *trimmed_body = body;
if (!msginfo)
} else
buf = "";
+ prev_autowrap = compose->autowrap;
+ compose->autowrap = FALSE;
+
for (p = buf; *p != '\0'; ) {
GtkTextView *text = GTK_TEXT_VIEW(compose->text);
GtkTextBuffer *buffer = gtk_text_view_get_buffer(text);
break;
}
+ compose->autowrap = prev_autowrap;
+ if (compose->autowrap)
+ compose_wrap_all(compose);
+
return buf;
}
GtkTextMark *mark;
GtkTextIter iter;
gint cur_pos;
+ gboolean prev_autowrap;
g_return_if_fail(compose->account != NULL);
+ prev_autowrap = compose->autowrap;
+ compose->autowrap = FALSE;
+
g_signal_handlers_block_by_func(G_OBJECT(buffer),
G_CALLBACK(compose_changed_cb),
compose);
if (cur_pos > gtk_text_buffer_get_char_count (buffer))
cur_pos = gtk_text_buffer_get_char_count (buffer);
- gtk_text_buffer_get_iter_at_offset (buffer, &iter, cur_pos);
- gtk_text_buffer_place_cursor (buffer, &iter);
+ gtk_text_buffer_get_iter_at_offset(buffer, &iter, cur_pos);
+ gtk_text_buffer_place_cursor(buffer, &iter);
g_signal_handlers_unblock_by_func(G_OBJECT(buffer),
G_CALLBACK(compose_changed_cb),
compose);
-
+
+ compose->autowrap = prev_autowrap;
+ if (compose->autowrap)
+ compose_wrap_all(compose);
}
static gchar *compose_get_signature_str(Compose *compose)
{
gchar *sig_body = NULL;
gchar *sig_str = NULL;
+ gchar *utf8_sig_str = NULL;
g_return_val_if_fail(compose->account != NULL, NULL);
g_free(tmp);
}
- if (compose->account->sig_sep)
+ if (compose->account->sig_sep) {
sig_str = g_strconcat("\n\n", compose->account->sig_sep, "\n", sig_body,
NULL);
- else
+ g_free(sig_body);
+ } else
sig_str = g_strconcat("\n\n", sig_body, NULL);
- g_free(sig_body);
-
- return sig_str;
+ if (sig_str) {
+ if (!g_utf8_validate(sig_str,1, NULL)) {
+ utf8_sig_str = conv_codeset_strdup
+ (sig_str, conv_get_locale_charset_str(), CS_INTERNAL);
+ g_free(sig_str);
+ } else
+ utf8_sig_str = sig_str;
+ }
+
+ return utf8_sig_str;
}
static ComposeInsertResult compose_insert_file(Compose *compose, const gchar *file)
gchar buf[BUFFSIZE];
gint len;
FILE *fp;
+ gboolean prev_autowrap;
gboolean badtxt = FALSE;
g_return_val_if_fail(file != NULL, COMPOSE_INSERT_NO_FILE);
return COMPOSE_INSERT_READ_ERROR;
}
+ prev_autowrap = compose->autowrap;
+ compose->autowrap = FALSE;
+
text = GTK_TEXT_VIEW(compose->text);
buffer = gtk_text_view_get_buffer(text);
mark = gtk_text_buffer_get_insert(buffer);
g_signal_handlers_unblock_by_func(G_OBJECT(buffer),
G_CALLBACK(text_inserted),
compose);
+ compose->autowrap = prev_autowrap;
+ if (compose->autowrap)
+ compose_wrap_all(compose);
fclose(fp);
gchar *name;
if (!is_file_exist(file)) {
- g_warning("File %s doesn't exist\n", file);
+ g_warning("File %s doesn't exist\n", filename);
return;
}
if ((size = get_file_size(file)) < 0) {
- g_warning("Can't get file size of %s\n", file);
+ g_warning("Can't get file size of %s\n", filename);
return;
}
if (size == 0) {
- alertpanel_notice(_("File %s is empty."), file);
+ alertpanel_notice(_("File %s is empty."), filename);
return;
}
if ((fp = fopen(file, "rb")) == NULL) {
- alertpanel_error(_("Can't read %s."), file);
+ alertpanel_error(_("Can't read %s."), filename);
return;
}
fclose(fp);
} else if (compose->mode == COMPOSE_REEDIT &&
child->type == MIMETYPE_APPLICATION &&
!g_ascii_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;
+ encrypted = (MimeInfo *)child->node->parent->data;
}
child = (MimeInfo *) mimeinfo->node->children->data;
procmime_mimeinfo_free_all(mimeinfo);
}
-
-#define CHAR_BUF_SIZE 8
#undef NEXT_PART_NOT_CHILD
-#define GET_CHAR(iter_p, buf, len) \
-{ \
- gunichar uc; \
- \
- uc = gtk_text_iter_get_char(iter_p); \
- if (uc != 0) \
- len = g_unichar_to_utf8(uc, buf) > 1 ? 2 : 1; \
- else { \
- buf[0] = '\0'; \
- len = 1; \
- } \
-}
-#define DISP_WIDTH(len) \
- ((len > 2 && conv_get_locale_charset() == C_UTF_8) ? 2 : \
- (len == 2 && conv_get_locale_charset() == C_UTF_8) ? 1 : len)
-
-#define SPACE_CHARS " \t"
-
-static void compose_wrap_line(Compose *compose)
-{
- GtkTextView *text = GTK_TEXT_VIEW(compose->text);
- GtkTextBuffer *textbuf = gtk_text_view_get_buffer(text);
- GtkTextMark *mark;
- GtkTextIter insert_iter, iter;
- gint ch_len, last_ch_len;
- gchar cbuf[CHAR_BUF_SIZE], last_ch;
- guint text_len;
- gint p_start, p_end;
- gint line_pos, cur_pos;
- gint line_len, cur_len;
- gboolean line_end, quoted;
-
- text_len = gtk_text_buffer_get_char_count(textbuf);
- mark = gtk_text_buffer_get_insert(textbuf);
- gtk_text_buffer_get_iter_at_mark(textbuf, &insert_iter, mark);
- cur_pos = gtk_text_iter_get_offset(&insert_iter);
- GET_CHAR(&insert_iter, cbuf, ch_len);
- if ((ch_len == 1 && *cbuf == '\n') || cur_pos == text_len) {
- GtkTextIter prev_iter;
- if (cur_pos == 0)
- return; /* on the paragraph mark */
- prev_iter = insert_iter;
- gtk_text_iter_backward_char(&prev_iter);
- GET_CHAR(&prev_iter, cbuf, ch_len);
- if (ch_len == 1 && *cbuf == '\n')
- return; /* on the paragraph mark */
- }
-
- /* find paragraph start. */
- line_end = quoted = FALSE;
- for (iter = insert_iter; gtk_text_iter_backward_char(&iter);) {
- GET_CHAR(&iter, cbuf, ch_len);
- if (ch_len == 1 && *cbuf == '\n') {
- if (quoted)
- return; /* quoted part */
- if (line_end) {
- gtk_text_iter_forward_chars(&iter, 2);
- break;
- }
- line_end = TRUE;
- } else {
- if (ch_len == 1
- && strchr(prefs_common.quote_chars, *cbuf))
- quoted = 1;
- else if (ch_len != 1 || !isspace(*(guchar *)cbuf))
- quoted = 0;
- line_end = FALSE;
- }
- }
- p_start = gtk_text_iter_get_offset(&iter);
+typedef enum {
+ WAIT_FOR_INDENT_CHAR,
+ WAIT_FOR_INDENT_CHAR_OR_SPACE,
+} IndentState;
- /* find paragraph end. */
- line_end = FALSE;
- for (iter = insert_iter; gtk_text_iter_forward_char(&iter);) {
- GET_CHAR(&iter, cbuf, ch_len);
- if (ch_len == 1 && *cbuf == '\n') {
- if (line_end) {
- p_end -= 1;
- gtk_text_iter_backward_char(&iter);
- break;
- }
- line_end = TRUE;
- } else {
- if (line_end && ch_len == 1 &&
- strchr(prefs_common.quote_chars, *cbuf))
- return; /* quoted part */
+/* return indent length, we allow:
+ indent characters followed by indent characters or spaces/tabs,
+ alphabets and numbers immediately followed by indent characters,
+ and the repeating sequences of the above
+ If quote ends with multiple spaces, only the first one is included. */
+static gchar *compose_get_quote_str(GtkTextBuffer *buffer,
+ const GtkTextIter *start, gint *len)
+{
+ GtkTextIter iter = *start;
+ gunichar wc;
+ gchar ch[6];
+ gint clen;
+ IndentState state = WAIT_FOR_INDENT_CHAR;
+ gboolean is_space;
+ gboolean is_indent;
+ gint alnum_count = 0;
+ gint space_count = 0;
+ gint quote_len = 0;
- line_end = FALSE;
- }
+ if (prefs_common.quote_chars == NULL) {
+ return 0 ;
}
- p_end = gtk_text_iter_get_offset(&iter);
-
- if (p_end >= text_len)
- p_end = text_len;
-
- if (p_start >= p_end)
- return;
-
- line_len = cur_len = 0;
- last_ch_len = 0;
- last_ch = '\0';
- line_pos = p_start;
- for (cur_pos = p_start; cur_pos < p_end; cur_pos++) {
- gboolean space = FALSE;
-
- gtk_text_buffer_get_iter_at_offset(textbuf, &iter, cur_pos);
-
- GET_CHAR(&iter, cbuf, ch_len);
- if (ch_len < 0) {
- cbuf[0] = '\0';
- ch_len = 1;
- }
-
- if (ch_len == 1 && isspace(*(guchar *)cbuf))
- space = 1;
-
- if (ch_len == 1 && *cbuf == '\n') {
- gboolean replace = FALSE;
- GtkTextIter next_iter = iter;
+ while (!gtk_text_iter_ends_line(&iter)) {
+ wc = gtk_text_iter_get_char(&iter);
+ if (g_unichar_iswide(wc))
+ break;
+ clen = g_unichar_to_utf8(wc, ch);
+ if (clen != 1)
+ break;
- gtk_text_iter_forward_char(&next_iter);
+ is_indent = strchr(prefs_common.quote_chars, ch[0]) ? TRUE : FALSE;
+ is_space = g_unichar_isspace(wc);
- if (last_ch_len == 1 && !isspace((guchar)last_ch)) {
- if (cur_pos + 1 < p_end) {
- GET_CHAR(&next_iter, cbuf, ch_len);
- if (ch_len == 1 &&
- !isspace(*(guchar *)cbuf))
- replace = TRUE;
- }
- }
- gtk_text_buffer_delete(textbuf, &iter, &next_iter);
- if (replace) {
- gtk_text_buffer_insert(textbuf, &iter, " ", 1);
- space = TRUE;
- }
- else {
- p_end--;
- cur_pos--;
- gtk_text_buffer_get_iter_at_offset
- (textbuf, &iter, cur_pos);
- continue;
+ if (state == WAIT_FOR_INDENT_CHAR) {
+ if (!is_indent && !g_unichar_isalnum(wc))
+ break;
+ if (is_indent) {
+ quote_len += alnum_count + space_count + 1;
+ alnum_count = space_count = 0;
+ state = WAIT_FOR_INDENT_CHAR_OR_SPACE;
+ } else
+ alnum_count++;
+ } else if (state == WAIT_FOR_INDENT_CHAR_OR_SPACE) {
+ if (!is_indent && !is_space && !g_unichar_isalnum(wc))
+ break;
+ if (is_space)
+ space_count++;
+ else if (is_indent) {
+ quote_len += alnum_count + space_count + 1;
+ alnum_count = space_count = 0;
+ } else {
+ alnum_count++;
+ state = WAIT_FOR_INDENT_CHAR;
}
}
- last_ch_len = ch_len;
- last_ch = *cbuf;
-
- if (space) {
- line_pos = cur_pos + 1;
- line_len = cur_len + ch_len;
- }
-
- gtk_text_buffer_get_iter_at_offset(textbuf, &iter, line_pos);
-
- if (cur_len + ch_len > prefs_common.linewrap_len &&
- line_len > 0) {
- gint tlen = ch_len;
- GtkTextIter prev_iter = iter;
+ gtk_text_iter_forward_char(&iter);
+ }
- gtk_text_iter_backward_char(&prev_iter);
+ if (quote_len > 0 && space_count > 0)
+ quote_len++;
- GET_CHAR(&prev_iter, cbuf, ch_len);
- if (ch_len == 1 && isspace(*(guchar *)cbuf)) {
- gtk_text_buffer_delete(textbuf, &prev_iter, &iter);
- iter = prev_iter;
- p_end--;
- cur_pos--;
- line_pos--;
- cur_len--;
- line_len--;
- }
- ch_len = tlen;
-
- gtk_text_buffer_insert(textbuf, &iter, "\n", 1);
- p_end++;
- cur_pos++;
- line_pos++;
- cur_len = cur_len - line_len + ch_len;
- line_len = 0;
- continue;
- }
+ if (len)
+ *len = quote_len;
- if (ch_len > 1) {
- line_pos = cur_pos + 1;
- line_len = cur_len + ch_len;
- }
- cur_len += ch_len;
+ if (quote_len > 0) {
+ iter = *start;
+ gtk_text_iter_forward_chars(&iter, quote_len);
+ return gtk_text_buffer_get_text(buffer, start, &iter, FALSE);
}
+
+ return NULL;
}
-#undef WRAP_DEBUG
-#ifdef WRAP_DEBUG
-/* Darko: used when I debug wrapping */
-void dump_text(GtkTextBuffer *textbuf, int pos, int tlen, int breakoncr)
+/* return TRUE if the line is itemized */
+static gboolean compose_is_itemized(GtkTextBuffer *buffer,
+ const GtkTextIter *start)
{
- GtkTextIter iter, end_iter;
+ GtkTextIter iter = *start;
+ gunichar wc;
+ gchar ch[6];
gint clen;
- gchar cbuf[CHAR_BUF_SIZE];
-
- printf("%d [", pos);
- gtk_text_buffer_get_iter_at_offset(textbuf, &iter, pos);
- gtk_text_buffer_get_iter_at_offset(textbuf, &end_iter, pos + tlen);
- for (; gtk_text_iter_forward_char(&iter) &&
- gtk_text_iter_compare(&iter, &end_iter) < 0; ) {
- GET_CHAR(&iter, cbuf, clen);
- if (clen < 0) break;
- if (breakoncr && clen == 1 && cbuf[0] == '\n')
+
+ if (gtk_text_iter_ends_line(&iter))
+ return FALSE;
+
+ while (1) {
+ wc = gtk_text_iter_get_char(&iter);
+ if (!g_unichar_isspace(wc))
break;
- fwrite(cbuf, clen, 1, stdout);
+ gtk_text_iter_forward_char(&iter);
+ if (gtk_text_iter_ends_line(&iter))
+ return FALSE;
}
- printf("]\n");
-}
-#endif
-typedef enum {
- WAIT_FOR_SPACE,
- WAIT_FOR_INDENT_CHAR,
- WAIT_FOR_INDENT_CHAR_OR_SPACE
-} IndentState;
+ clen = g_unichar_to_utf8(wc, ch);
+ if (clen != 1)
+ return FALSE;
-/* return indent length, we allow:
- > followed by spaces/tabs
- | followed by spaces/tabs
- uppercase characters immediately followed by >,
- and the repeating sequences of the above */
-/* return indent length */
-static guint get_indent_length(GtkTextBuffer *textbuf, guint start_pos,
- guint text_len)
-{
- GtkTextIter iter;
- guint i_len = 0;
- guint ch_len, alnum_cnt = 0;
- IndentState state = WAIT_FOR_INDENT_CHAR;
- gchar cbuf[CHAR_BUF_SIZE];
- gboolean is_space;
- gboolean is_indent;
- gboolean iter_next = TRUE;
+ if (!strchr("*-+", ch[0]))
+ return FALSE;
- if (prefs_common.quote_chars == NULL) {
- return 0 ;
- }
+ gtk_text_iter_forward_char(&iter);
+ if (gtk_text_iter_ends_line(&iter))
+ return FALSE;
+ wc = gtk_text_iter_get_char(&iter);
+ if (g_unichar_isspace(wc))
+ return TRUE;
- gtk_text_buffer_get_iter_at_offset(textbuf, &iter, start_pos);
+ return FALSE;
+}
- while (iter_next == TRUE) {
- GET_CHAR(&iter, cbuf, ch_len);
- if (ch_len > 1)
+static gboolean compose_get_line_break_pos(GtkTextBuffer *buffer,
+ const GtkTextIter *start,
+ GtkTextIter *break_pos,
+ gint max_col,
+ gint quote_len)
+{
+ GtkTextIter iter = *start, line_end = *start;
+ PangoLogAttr *attrs;
+ gchar *str;
+ gchar *p;
+ gint len;
+ gint i;
+ gint col = 0;
+ gint pos = 0;
+ gboolean can_break = FALSE;
+ gboolean do_break = FALSE;
+ gboolean was_white = FALSE;
+
+ gtk_text_iter_forward_to_line_end(&line_end);
+ str = gtk_text_buffer_get_text(buffer, &iter, &line_end, FALSE);
+ len = g_utf8_strlen(str, -1);
+ /* g_print("breaking line: %d: %s (len = %d)\n",
+ gtk_text_iter_get_line(&iter), str, len); */
+ attrs = g_new(PangoLogAttr, len + 1);
+
+ pango_default_break(str, -1, NULL, attrs, len + 1);
+
+ p = str;
+
+ /* skip quote and leading spaces */
+ for (i = 0; *p != '\0' && i < len; i++) {
+ gunichar wc;
+
+ wc = g_utf8_get_char(p);
+ if (i >= quote_len && !g_unichar_isspace(wc))
break;
+ if (g_unichar_iswide(wc))
+ col += 2;
+ else if (*p == '\t')
+ col += 8;
+ else
+ col++;
+ p = g_utf8_next_char(p);
+ }
- if (cbuf[0] == '\n')
- break;
+ for (; *p != '\0' && i < len; i++) {
+ PangoLogAttr *attr = attrs + i;
+ gunichar wc;
+ gint uri_len;
- is_indent = strchr(prefs_common.quote_chars, cbuf[0]) ? TRUE : FALSE;
- is_space = strchr(SPACE_CHARS, cbuf[0]) ? TRUE : FALSE;
+ if (attr->is_line_break && can_break && was_white)
+ pos = i;
+
+ was_white = attr->is_white;
- switch (state) {
- case WAIT_FOR_SPACE:
- if (is_space == FALSE)
- goto out;
- state = WAIT_FOR_INDENT_CHAR_OR_SPACE;
- break;
- case WAIT_FOR_INDENT_CHAR_OR_SPACE:
- if (is_indent == FALSE && is_space == FALSE &&
- !isupper((guchar)cbuf[0]))
- goto out;
- if (is_space == TRUE) {
- alnum_cnt = 0;
- state = WAIT_FOR_INDENT_CHAR_OR_SPACE;
- } else if (is_indent == TRUE) {
- alnum_cnt = 0;
- state = WAIT_FOR_SPACE;
- } else {
- alnum_cnt++;
- state = WAIT_FOR_INDENT_CHAR;
- }
- break;
- case WAIT_FOR_INDENT_CHAR:
- if (is_indent == FALSE && !isupper((guchar)cbuf[0]))
- goto out;
- if (is_indent == TRUE) {
- if (alnum_cnt > 0
- && !strchr(prefs_common.quote_chars, cbuf[0]))
- goto out;
- alnum_cnt = 0;
- state = WAIT_FOR_SPACE;
- } else {
- alnum_cnt++;
+ /* don't wrap URI */
+ if ((uri_len = get_uri_len(p)) > 0) {
+ col += uri_len;
+ if (pos > 0 && col > max_col) {
+ do_break = TRUE;
+ break;
}
+ i += uri_len - 1;
+ p += uri_len;
+ can_break = TRUE;
+ continue;
+ }
+
+ wc = g_utf8_get_char(p);
+ if (g_unichar_iswide(wc))
+ col += 2;
+ else if (*p == '\t')
+ col += 8;
+ else
+ col++;
+ if (pos > 0 && col > max_col) {
+ do_break = TRUE;
break;
}
- i_len++;
- iter_next = gtk_text_iter_forward_char(&iter);
+ p = g_utf8_next_char(p);
+ can_break = TRUE;
}
-out:
- if ((i_len > 0) && (state == WAIT_FOR_INDENT_CHAR))
- i_len -= alnum_cnt;
+ debug_print("compose_get_line_break_pos(): do_break = %d, pos = %d, col = %d\n", do_break, pos, col);
- return i_len;
-}
-
-/* insert quotation string when line was wrapped */
-static guint ins_quote(GtkTextBuffer *textbuf, GtkTextIter *iter,
- guint indent_len,
- guint prev_line_pos, guint text_len,
- gchar *quote_fmt)
-{
- guint ins_len = 0;
-
- if (indent_len) {
- GtkTextIter iter1, iter2;
- gchar *text;
-
- gtk_text_buffer_get_iter_at_offset(textbuf, &iter1,
- prev_line_pos);
- gtk_text_buffer_get_iter_at_offset(textbuf, &iter2,
- prev_line_pos + indent_len);
- text = gtk_text_buffer_get_text(textbuf, &iter1, &iter2, FALSE);
- if (!text) return 0;
-
- gtk_text_buffer_insert(textbuf, iter, text, -1);
- ins_len = g_utf8_strlen(text, -1);
+ g_free(attrs);
+ g_free(str);
- g_free(text);
- }
+ *break_pos = *start;
+ gtk_text_iter_set_line_offset(break_pos, pos);
- return ins_len;
+ return do_break;
}
-static gboolean is_sig_separator(Compose *compose, GtkTextBuffer *textbuf, guint start_pos)
+static gboolean compose_is_sig_separator(Compose *compose, GtkTextBuffer *textbuf, GtkTextIter *iter)
{
- char *text = NULL;
- GtkTextIter iter;
+ GtkTextIter start = *iter;
GtkTextIter end_iter;
+ int start_pos = gtk_text_iter_get_offset(&start);
+
if (!compose->account->sig_sep)
return FALSE;
- gtk_text_buffer_get_iter_at_offset(textbuf, &iter, start_pos+1);
gtk_text_buffer_get_iter_at_offset(textbuf, &end_iter,
- start_pos+strlen(compose->account->sig_sep)+1);
+ start_pos+strlen(compose->account->sig_sep));
- if (!strcmp(gtk_text_iter_get_text(&iter, &end_iter),
+ /* check sig separator */
+ if (!strcmp(gtk_text_iter_get_text(&start, &end_iter),
compose->account->sig_sep)) {
- /* check \n */
- gtk_text_buffer_get_iter_at_offset(textbuf, &iter,
- start_pos+strlen(compose->account->sig_sep)+1);
+ /* check end of line (\n) */
+ gtk_text_buffer_get_iter_at_offset(textbuf, &start,
+ start_pos+strlen(compose->account->sig_sep));
gtk_text_buffer_get_iter_at_offset(textbuf, &end_iter,
- start_pos+strlen(compose->account->sig_sep)+2);
+ start_pos+strlen(compose->account->sig_sep)+1);
- if (!strcmp(gtk_text_iter_get_text(&iter, &end_iter),"\n"));
+ if (!strcmp(gtk_text_iter_get_text(&start, &end_iter),"\n"));
return TRUE;
return FALSE;
}
-/* check if we should join the next line */
-static gboolean join_next_line_is_needed(GtkTextBuffer *textbuf,
- guint start_pos, guint tlen,
- guint prev_ilen, gboolean autowrap)
+static gboolean compose_join_next_line(Compose *compose,
+ GtkTextBuffer *buffer,
+ GtkTextIter *iter,
+ const gchar *quote_str)
{
- guint indent_len, ch_len;
- gboolean do_join = FALSE;
- gchar cbuf[CHAR_BUF_SIZE];
+ GtkTextIter iter_ = *iter, cur, prev, next, end;
+ PangoLogAttr attrs[3];
+ gchar *str;
+ gchar *next_quote_str;
+ gunichar wc1, wc2;
+ gint quote_len;
+ gboolean keep_cursor = FALSE;
- indent_len = get_indent_length(textbuf, start_pos, tlen);
+ if (!gtk_text_iter_forward_line(&iter_) ||
+ gtk_text_iter_ends_line(&iter_))
+ return FALSE;
- if ((autowrap || indent_len > 0) && indent_len == prev_ilen) {
- GtkTextIter iter;
- gtk_text_buffer_get_iter_at_offset(textbuf, &iter,
- start_pos + indent_len);
- GET_CHAR(&iter, cbuf, ch_len);
-
- if (ch_len > 0 && (cbuf[0] != '\n'))
- do_join = TRUE;
+ next_quote_str = compose_get_quote_str(buffer, &iter_, "e_len);
+
+ if ((quote_str || next_quote_str) &&
+ strcmp2(quote_str, next_quote_str) != 0) {
+ g_free(next_quote_str);
+ return FALSE;
}
+ g_free(next_quote_str);
- return do_join;
-}
+ end = iter_;
+ if (quote_len > 0) {
+ gtk_text_iter_forward_chars(&end, quote_len);
+ if (gtk_text_iter_ends_line(&end))
+ return FALSE;
+ }
-static void compose_wrap_line_all(Compose *compose)
-{
- compose_wrap_line_all_full(compose, FALSE);
-}
+ /* don't join itemized lines */
+ if (compose_is_itemized(buffer, &end))
+ return FALSE;
-static void compose_wrap_line_all_full(Compose *compose, gboolean autowrap)
-{
- GtkTextView *text = GTK_TEXT_VIEW(compose->text);
- GtkTextBuffer *textbuf = gtk_text_view_get_buffer(text);
- GtkTextIter iter, end_iter;
- guint tlen;
- guint line_pos = 0, cur_pos = 0, p_pos = 0;
- gint line_len = 0, cur_len = 0;
- gint ch_len;
- gboolean is_new_line = TRUE, do_delete = FALSE;
- guint i_len = 0;
- gboolean linewrap_quote = prefs_common.linewrap_quote;
- gboolean set_editable_pos = FALSE;
- gint editable_pos = 0;
- guint linewrap_len = prefs_common.linewrap_len;
- gchar *qfmt = prefs_common.quotemark;
- gchar cbuf[CHAR_BUF_SIZE];
- GtkTextMark *cursor_mark = gtk_text_buffer_get_insert(textbuf);
-
- tlen = gtk_text_buffer_get_char_count(textbuf);
+ /* don't join signature separator */
+ if (compose_is_sig_separator(compose, buffer, &iter_))
+ return FALSE;
- for (; cur_pos < tlen; cur_pos++) {
- /* mark position of new line - needed for quotation wrap */
- if (is_new_line) {
- if (linewrap_quote)
- i_len = get_indent_length(textbuf, cur_pos, tlen);
+ /* delete quote str */
+ if (quote_len > 0)
+ gtk_text_buffer_delete(buffer, &iter_, &end);
- is_new_line = FALSE;
- p_pos = cur_pos;
- }
+ /* delete linebreak and extra spaces */
+ prev = cur = iter_;
+ while (gtk_text_iter_backward_char(&cur)) {
+ wc1 = gtk_text_iter_get_char(&cur);
+ if (!g_unichar_isspace(wc1))
+ break;
+ prev = cur;
+ }
+ next = cur = iter_;
+ while (!gtk_text_iter_ends_line(&cur)) {
+ wc1 = gtk_text_iter_get_char(&cur);
+ if (!g_unichar_isspace(wc1))
+ break;
+ gtk_text_iter_forward_char(&cur);
+ next = cur;
+ }
+ if (!gtk_text_iter_equal(&prev, &next)) {
+ GtkTextMark *mark;
- gtk_text_buffer_get_iter_at_offset(textbuf, &iter, cur_pos);
- GET_CHAR(&iter, cbuf, ch_len);
+ mark = gtk_text_buffer_get_insert(buffer);
+ gtk_text_buffer_get_iter_at_mark(buffer, &cur, mark);
+ if (gtk_text_iter_equal(&prev, &cur))
+ keep_cursor = TRUE;
+ gtk_text_buffer_delete(buffer, &prev, &next);
+ }
+ iter_ = prev;
+
+ /* insert space if required */
+ gtk_text_iter_backward_char(&prev);
+ wc1 = gtk_text_iter_get_char(&prev);
+ wc2 = gtk_text_iter_get_char(&next);
+ gtk_text_iter_forward_char(&next);
+ str = gtk_text_buffer_get_text(buffer, &prev, &next, FALSE);
+ pango_default_break(str, -1, NULL, attrs, 3);
+ if (!attrs[1].is_line_break ||
+ (!g_unichar_iswide(wc1) || !g_unichar_iswide(wc2))) {
+ gtk_text_buffer_insert(buffer, &iter_, " ", 1);
+ if (keep_cursor) {
+ gtk_text_iter_backward_char(&iter_);
+ gtk_text_buffer_place_cursor(buffer, &iter_);
+ }
+ }
+ g_free(str);
- /* fix line length for tabs */
- if (ch_len == 1 && *cbuf == '\t') {
- guint tab_width = 8;
- guint tab_offset = line_len % tab_width;
+ *iter = iter_;
+ return TRUE;
+}
- line_len += tab_width - tab_offset - 1;
- cur_len = line_len;
- }
+static void compose_wrap_paragraph(Compose *compose, GtkTextIter *par_iter)
+{
+ GtkTextView *text = GTK_TEXT_VIEW(compose->text);
+ GtkTextBuffer *buffer;
+ GtkTextIter iter, break_pos;
+ gchar *quote_str = NULL;
+ gint quote_len;
+ gboolean wrap_quote = prefs_common.linewrap_quote;
+ gboolean prev_autowrap = compose->autowrap;
- /* we have encountered line break */
- if (ch_len == 1 && *cbuf == '\n') {
- gint clen;
- gchar cb[CHAR_BUF_SIZE];
-
- /* should we join the next line */
- if ((autowrap || i_len != cur_len) && do_delete &&
- !is_sig_separator(compose, textbuf, cur_pos+i_len) &&
- join_next_line_is_needed
- (textbuf, cur_pos + 1, tlen, i_len, autowrap)) {
- do_delete = TRUE;
- } else
- do_delete = FALSE;
-
- /* skip delete if it is continuous URL */
- if (do_delete && (line_pos - p_pos <= i_len) &&
- gtkut_text_buffer_is_uri_string(textbuf, line_pos,
- tlen))
- do_delete = FALSE;
-
- /* should we delete to perform smart wrapping */
- if (line_len < linewrap_len && do_delete) {
- /* get rid of newline */
- gtk_text_buffer_get_iter_at_offset(textbuf,
- &iter,
- cur_pos);
- end_iter = iter;
- gtk_text_iter_forward_char(&end_iter);
- gtk_text_buffer_delete(textbuf, &iter, &end_iter);
- tlen--;
-
- /* if text starts with quote fmt or with
- indent string, delete them */
- if (i_len) {
- guint ilen;
- ilen = gtkut_text_buffer_str_compare_n
- (textbuf, cur_pos, p_pos, i_len,
- tlen);
- if (ilen) {
- end_iter = iter;
- gtk_text_iter_forward_chars
- (&end_iter, ilen);
- gtk_text_buffer_delete(textbuf,
- &iter,
- &end_iter);
- tlen -= ilen;
- }
- }
+ compose->autowrap = FALSE;
- gtk_text_buffer_get_iter_at_offset(textbuf,
- &iter,
- cur_pos);
- GET_CHAR(&iter, cb, clen);
-
- /* insert space if it's alphanumeric */
- if ((cur_pos != line_pos) &&
- ((clen > 1) || isalnum((guchar)cb[0]))) {
- GtkTextIter cursor_iter;
- gboolean go_back = FALSE;
- gtk_text_buffer_get_iter_at_mark(textbuf, &cursor_iter, cursor_mark);
- if (gtk_text_iter_get_offset(&iter) ==
- gtk_text_iter_get_offset(&cursor_iter))
- go_back = TRUE;
-
- gtk_text_buffer_insert(textbuf, &iter,
- " ", 1);
- if (go_back) {
- gtk_text_buffer_get_iter_at_mark(textbuf, &cursor_iter, cursor_mark);
- gtk_text_iter_backward_chars(&cursor_iter, 1);
- gtk_text_buffer_place_cursor(textbuf, &cursor_iter);
- }
- tlen++;
- }
+ buffer = gtk_text_view_get_buffer(text);
- /* and start over with current line */
- cur_pos = p_pos - 1;
- line_pos = cur_pos;
- line_len = cur_len = 0;
- do_delete = FALSE;
- is_new_line = TRUE;
-#ifdef WRAP_DEBUG
- g_print("after delete l_pos=");
- dump_text(textbuf, line_pos, tlen, 1);
-#endif
- /* move beginning of line if we are on LF */
- gtk_text_buffer_get_iter_at_offset(textbuf,
- &iter,
- line_pos);
- GET_CHAR(&iter, cb, clen);
- if (clen == 1 && *cb == '\n')
- line_pos++;
-#ifdef WRAP_DEBUG
- g_print("new line_pos=%d\n", line_pos);
-#endif
+ undo_block(compose->undostruct);
+
+ if (par_iter) {
+ iter = *par_iter;
+ } else {
+ GtkTextMark *mark;
+ mark = gtk_text_buffer_get_insert(buffer);
+ gtk_text_buffer_get_iter_at_mark(buffer, &iter, mark);
+ }
- continue;
+ /* move to paragraph start */
+ gtk_text_iter_set_line_offset(&iter, 0);
+ if (gtk_text_iter_ends_line(&iter)) {
+ while (gtk_text_iter_ends_line(&iter) &&
+ gtk_text_iter_forward_line(&iter))
+ ;
+ } else {
+ while (gtk_text_iter_backward_line(&iter)) {
+ if (gtk_text_iter_ends_line(&iter)) {
+ gtk_text_iter_forward_line(&iter);
+ break;
}
-
- /* mark new line beginning */
- line_pos = cur_pos + 1;
- line_len = cur_len = 0;
- do_delete = FALSE;
- is_new_line = TRUE;
- continue;
}
+ }
- if (ch_len < 0) {
- cbuf[0] = '\0';
- ch_len = 1;
+ /* go until paragraph end (empty line) */
+ while (!gtk_text_iter_ends_line(&iter)) {
+ quote_str = compose_get_quote_str(buffer, &iter, "e_len);
+ if (quote_str) {
+ if (!wrap_quote) {
+ gtk_text_iter_forward_line(&iter);
+ g_free(quote_str);
+ continue;
+ }
+ debug_print("compose_wrap_paragraph(): quote_str = '%s'\n", quote_str);
}
- /* possible line break */
- if (ch_len == 1 && isspace(*(guchar *)cbuf)) {
- line_pos = cur_pos + 1;
- line_len = cur_len + ch_len;
- }
+ if (compose_get_line_break_pos(buffer, &iter, &break_pos,
+ prefs_common.linewrap_len,
+ quote_len)) {
+ GtkTextIter prev, next, cur;
- /* are we over wrapping length set in preferences ? */
- if (cur_len + DISP_WIDTH(ch_len) > linewrap_len) {
- gint clen;
+ gtk_text_buffer_insert(buffer, &break_pos, "\n", 1);
-#ifdef WRAP_DEBUG
- g_print("should wrap cur_pos=%d ", cur_pos);
- dump_text(textbuf, p_pos, tlen, 1);
- dump_text(textbuf, line_pos, tlen, 1);
-#endif
- /* force wrapping if it is one long word but not URL */
- if (line_pos - p_pos <= i_len)
- if (!gtkut_text_buffer_is_uri_string
- (textbuf, line_pos, tlen))
- line_pos = cur_pos - 1;
-#ifdef WRAP_DEBUG
- g_print("new line_pos=%d\n", line_pos);
-#endif
+ /* remove trailing spaces */
+ cur = break_pos;
+ gtk_text_iter_backward_char(&cur);
+ prev = next = cur;
+ while (!gtk_text_iter_starts_line(&cur)) {
+ gunichar wc;
- gtk_text_buffer_get_iter_at_offset(textbuf,
- &iter,
- line_pos - 1);
- GET_CHAR(&iter, cbuf, clen);
-
- /* if next character is space delete it */
- if (clen == 1 && isspace(*(guchar *)cbuf)) {
- if (p_pos + i_len != line_pos ||
- !gtkut_text_buffer_is_uri_string
- (textbuf, line_pos, tlen)) {
- /* workaround for correct cursor
- position */
- if (set_editable_pos == FALSE) {
- GtkTextMark *ins = gtk_text_buffer_get_insert(textbuf);
- gtk_text_buffer_get_iter_at_mark(textbuf, &iter, ins);
- editable_pos = gtk_text_iter_get_offset(&iter);
- if (editable_pos == line_pos)
- set_editable_pos = TRUE;
- }
- gtk_text_buffer_get_iter_at_offset(textbuf,
- &iter,
- line_pos-1);
- gtk_text_buffer_get_iter_at_offset(textbuf,
- &end_iter,
- line_pos);
- gtk_text_buffer_delete(textbuf, &iter, &end_iter);
- //gtk_stext_set_point(text, line_pos);
- //gtk_stext_backward_delete(text, 1);
- tlen--;
- cur_pos--;
- line_pos--;
- cur_len--;
- line_len--;
- }
+ gtk_text_iter_backward_char(&cur);
+ wc = gtk_text_iter_get_char(&cur);
+ if (!g_unichar_isspace(wc))
+ break;
+ prev = cur;
}
-
- /* if it is URL at beginning of line don't wrap */
- if (p_pos + i_len == line_pos &&
- gtkut_text_buffer_is_uri_string(textbuf, line_pos, tlen)) {
-#ifdef WRAP_DEBUG
- g_print("found URL at ");
- dump_text(textbuf, line_pos, tlen, 1);
-#endif
- continue;
+ if (!gtk_text_iter_equal(&prev, &next)) {
+ gtk_text_buffer_delete(buffer, &prev, &next);
+ break_pos = next;
+ gtk_text_iter_forward_char(&break_pos);
}
- /* insert CR */
- gtk_text_buffer_get_iter_at_offset(textbuf,
- &iter,
- line_pos);
- gtk_text_buffer_insert(textbuf, &iter, "\n", 1);
- //gtk_stext_set_point(text, line_pos);
- //gtk_stext_insert(text, NULL, NULL, NULL, "\n", 1);
- //gtk_stext_compact_buffer(text);
- tlen++;
- line_pos++;
- /* for loop will increase it */
- cur_pos = line_pos - 1;
- /* start over with current line */
- is_new_line = TRUE;
- line_len = cur_len = 0;
- if (autowrap || i_len > 0) {
- do_delete = TRUE;
- } else
- do_delete = FALSE;
-#ifdef WRAP_DEBUG
- g_print("after CR insert ");
- dump_text(textbuf, line_pos, tlen, 1);
- dump_text(textbuf, cur_pos, tlen, 1);
-#endif
+ if (quote_str)
+ gtk_text_buffer_insert(buffer, &break_pos,
+ quote_str, -1);
- /* should we insert quotation ? */
- if (linewrap_quote && i_len) {
- /* only if line is not already quoted */
- if (!gtkut_text_buffer_str_compare
- (textbuf, line_pos, tlen, qfmt)) {
- guint ins_len;
-
- gtk_text_buffer_get_iter_at_offset(textbuf, &iter, line_pos);
-
- if (line_pos - p_pos > i_len) {
- ins_len = ins_quote
- (textbuf, &iter, i_len, p_pos,
- tlen, qfmt);
- tlen += ins_len;
- }
-#ifdef WRAP_DEBUG
- g_print("after quote insert ");
- dump_text(textbuf, line_pos, tlen, 1);
-#endif
- }
- }
- continue;
- }
+ iter = break_pos;
+ compose_join_next_line(compose, buffer, &iter, quote_str);
- if (ch_len > 1) {
- line_pos = cur_pos + 1;
- line_len = cur_len + ch_len;
+ /* move iter to current line start */
+ gtk_text_iter_set_line_offset(&iter, 0);
+ } else {
+ /* move iter to next line start */
+ iter = break_pos;
+ gtk_text_iter_forward_line(&iter);
}
- /* advance to next character in buffer */
- cur_len += ch_len;
- }
- if (set_editable_pos && editable_pos <= tlen) {
- gtk_text_buffer_get_iter_at_offset(textbuf, &iter, editable_pos);
- gtk_text_buffer_place_cursor(textbuf, &iter);
+ g_free(quote_str);
}
+
+ if (par_iter)
+ *par_iter = iter;
+
+ undo_unblock(compose->undostruct);
+ compose->autowrap = prev_autowrap;
}
-#undef GET_CHAR
-#undef CHAR_BUF_SIZE
+static void compose_wrap_all(Compose *compose)
+{
+ compose_wrap_all_full(compose, FALSE);
+}
+
+static void compose_wrap_all_full(Compose *compose, gboolean autowrap)
+{
+ GtkTextView *text = GTK_TEXT_VIEW(compose->text);
+ GtkTextBuffer *buffer;
+ GtkTextIter iter;
+
+ buffer = gtk_text_view_get_buffer(text);
+
+ undo_block(compose->undostruct);
+
+ gtk_text_buffer_get_start_iter(buffer, &iter);
+ while (!gtk_text_iter_is_end(&iter))
+ compose_wrap_paragraph(compose, &iter);
+
+ undo_unblock(compose->undostruct);
+}
static void compose_set_title(Compose *compose)
{
val = compose_queue(compose, &msgnum, &folder);
if (val) {
- alertpanel_error(_("Could not queue message for sending"));
+ alertpanel_error(_("Could not queue message for sending."));
goto bail;
}
compose_close(compose);
/* No more compose access in the normal codepath
* after this point! */
+ compose = NULL;
}
if (msgnum == 0) {
to_hdr = prefs_common.trans_hdr ? _("To:") : "To:";
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 (g_utf8_collate(headerentryname, cc_hdr) == 0
- || g_utf8_collate(headerentryname, to_hdr) == 0) {
+ if (g_utf8_collate(headerentryname, to_hdr) == 0) {
const gchar *entstr = gtk_entry_get_text(GTK_ENTRY(headerentry->entry));
Xstrdup_a(str, entstr, return -1);
g_strstrip(str);
if (str[0] != '\0') {
compose_convert_header
- (buf, sizeof(buf), str,
+ (compose, buf, sizeof(buf), str,
strlen("Resent-To") + 2, TRUE);
- if (g_utf8_collate(headerentryname, to_hdr) == 0) {
- if (first_to_address) {
- fprintf(fp, "Resent-To: ");
- first_to_address = FALSE;
- } else {
- fprintf(fp, ",");
- }
- }
- if (g_utf8_collate(headerentryname, cc_hdr) == 0) {
- if (first_cc_address) {
- fprintf(fp, "\n");
- fprintf(fp, "Resent-Cc: ");
- first_cc_address = FALSE;
- } else {
- fprintf(fp, ",");
- }
- }
-
+
+ if (first_to_address) {
+ fprintf(fp, "Resent-To: ");
+ first_to_address = FALSE;
+ } else {
+ fprintf(fp, ",");
+ }
fprintf(fp, "%s", buf);
}
}
}
- /* if (!first_address) { */
- fprintf(fp, "\n");
- /* } */
+ if (!first_to_address) {
+ fprintf(fp, "\n");
+ }
+ 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 (g_utf8_collate(headerentryname, cc_hdr) == 0) {
+ const gchar *strg = gtk_entry_get_text(GTK_ENTRY(headerentry->entry));
+ Xstrdup_a(str, strg, return -1);
+ g_strstrip(str);
+ if (str[0] != '\0') {
+ compose_convert_header
+ (compose, buf, sizeof(buf), str,
+ strlen("Resent-Cc") + 2, TRUE);
+
+ if (first_cc_address) {
+ fprintf(fp, "Resent-Cc: ");
+ first_cc_address = FALSE;
+ } else {
+ fprintf(fp, ",");
+ }
+ fprintf(fp, "%s", buf);
+ }
+ }
+ }
+ if (!first_cc_address) {
+ fprintf(fp, "\n");
+ }
+
return(0);
}
/* Resent-From */
if (compose->account->name && *compose->account->name) {
compose_convert_header
- (buf, sizeof(buf), compose->account->name,
+ (compose, buf, sizeof(buf), compose->account->name,
strlen("From: "), TRUE);
fprintf(fp, "Resent-From: %s <%s>\n",
buf, compose->account->address);
Xstrdup_a(str, entstr, return -1);
g_strstrip(str);
if (*str != '\0') {
- compose_convert_header(buf, sizeof(buf), str,
+ compose_convert_header(compose, buf, sizeof(buf), str,
strlen("Subject: "), FALSE);
fprintf(fp, "Subject: %s\n", buf);
}
if (compose->account->name
&& *compose->account->name) {
compose_convert_header
- (buf, sizeof(buf),
+ (compose, buf, sizeof(buf),
compose->account->name,
strlen("From: "),
FALSE);
} else {
const gchar *src_codeset;
- out_codeset = conv_get_outgoing_charset_str();
+ out_codeset = conv_get_charset_str(compose->out_encoding);
+ if (!out_codeset)
+ out_codeset = conv_get_outgoing_charset_str();
+
if (!g_ascii_strcasecmp(out_codeset, CS_US_ASCII))
out_codeset = CS_ISO_8859_1;
if (action == COMPOSE_WRITE_FOR_SEND) {
buf = conv_codeset_strdup(chars, src_codeset, out_codeset);
+
if (!buf) {
AlertValue aval;
gchar *msg;
}
g_free(chars);
+ if (encoding == ENC_8BIT || encoding == ENC_7BIT) {
+ if (!strncmp(buf, "From ", sizeof("From ")-1) ||
+ strstr(buf, "\nFrom ") != NULL) {
+ encoding = ENC_QUOTED_PRINTABLE;
+ }
+ }
+
mimetext = procmime_mimeinfo_new();
mimetext->content = MIMECONTENT_MEM;
mimetext->data.mem = buf;
g_strdup(out_codeset));
/* protect trailing spaces when signing message */
if (action == COMPOSE_WRITE_FOR_SEND && compose->use_signing &&
- privacy_system_can_sign(compose->privacy_system))
+ privacy_system_can_sign(compose->privacy_system)) {
if (encoding == ENC_7BIT)
encoding = ENC_QUOTED_PRINTABLE;
else if (encoding == ENC_8BIT)
encoding = ENC_BASE64;
+ }
if (encoding != ENC_UNKNOWN)
procmime_encode_content(mimetext, encoding);
return -1;
procmime_write_mimeinfo(mimemsg, fp);
+
+ procmime_mimeinfo_free_all(mimemsg);
return 0;
}
FILE *fp;
size_t len;
gchar *chars, *tmp;
- const gchar *src_codeset, *dest_codeset;
if ((fp = fopen(file, "wb")) == NULL) {
FILE_OP_ERROR(file, "fopen");
}
if (prefs_common.linewrap_at_send)
- compose_wrap_line_all(compose);
+ compose_wrap_all(compose);
/* write queue header */
tmp = g_strdup_printf("%s%cqueue.%p", get_tmp_dir(),
mimepart->disposition = DISPOSITIONTYPE_ATTACHMENT;
}
+ if (compose->use_signing) {
+ if (ainfo->encoding == ENC_7BIT)
+ ainfo->encoding = ENC_QUOTED_PRINTABLE;
+ else if (ainfo->encoding == ENC_8BIT)
+ ainfo->encoding = ENC_BASE64;
+ }
+
procmime_encode_content(mimepart, ainfo->encoding);
g_node_append(parent->node, mimepart->node);
buf = g_new0(gchar, fieldstr->len * 4 + 256);
compose_convert_header
- (buf, fieldstr->len * 4 + 256, fieldstr->str,
+ (compose, buf, fieldstr->len * 4 + 256, fieldstr->str,
strlen(fieldname) + 2, TRUE);
g_string_append_printf(header, "%s: %s\n", fieldname, buf);
g_free(buf);
/* From */
if (compose->account->name && *compose->account->name) {
compose_convert_header
- (buf, sizeof(buf), compose->account->name,
+ (compose, buf, sizeof(buf), compose->account->name,
strlen("From: "), TRUE);
QUOTE_IF_REQUIRED(name, buf);
g_string_append_printf(header, "From: %s <%s>\n",
if (*str != '\0' && !IS_IN_CUSTOM_HEADER("Subject")) {
g_strstrip(str);
if (*str != '\0') {
- compose_convert_header(buf, sizeof(buf), str,
+ compose_convert_header(compose, buf, sizeof(buf), str,
strlen("Subject: "), FALSE);
g_string_append_printf(header, "Subject: %s\n", buf);
}
if (compose->account->organization &&
strlen(compose->account->organization) &&
!IS_IN_CUSTOM_HEADER("Organization")) {
- compose_convert_header(buf, sizeof(buf),
+ compose_convert_header(compose, buf, sizeof(buf),
compose->account->organization,
strlen("Organization: "), FALSE);
g_string_append_printf(header, "Organization: %s\n", buf);
if (custom_header_is_allowed(chdr->name)) {
compose_convert_header
- (buf, sizeof(buf),
+ (compose, buf, sizeof(buf),
chdr->value ? chdr->value : "",
strlen(chdr->name) + 2, FALSE);
g_string_append_printf(header, "%s: %s\n", chdr->name, buf);
if (compose->return_receipt) {
if (compose->account->name
&& *compose->account->name) {
- compose_convert_header(buf, sizeof(buf),
+ compose_convert_header(compose, buf, sizeof(buf),
compose->account->name,
strlen("Disposition-Notification-To: "),
TRUE);
#undef IS_IN_CUSTOM_HEADER
-static void compose_convert_header(gchar *dest, gint len, gchar *src,
+static void compose_convert_header(Compose *compose, gchar *dest, gint len, gchar *src,
gint header_len, gboolean addr_field)
{
gchar *tmpstr = NULL;
subst_char(tmpstr, '\r', ' ');
g_strchomp(tmpstr);
- conv_encode_header(dest, len, tmpstr, header_len, addr_field);
+ conv_encode_header_full(dest, len, tmpstr, header_len, addr_field,
+ conv_get_charset_str(compose->out_encoding));
g_free(tmpstr);
}
if (header)
gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(combo)->entry), header);
- g_signal_connect(G_OBJECT(GTK_COMBO(combo)->entry), "grab_focus",
- G_CALLBACK(compose_grab_focus_before_cb), compose);
g_signal_connect_after(G_OBJECT(GTK_COMBO(combo)->entry), "grab_focus",
G_CALLBACK(compose_grab_focus_cb), compose);
g_signal_connect(G_OBJECT(entry), "changed",
G_CALLBACK(compose_headerentry_changed_cb),
headerentry);
- g_signal_connect(G_OBJECT(entry), "grab_focus",
- G_CALLBACK(compose_grab_focus_before_cb), compose);
g_signal_connect_after(G_OBJECT(entry), "grab_focus",
G_CALLBACK(compose_grab_focus_cb), compose);
COL_NAME, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(attach_clist), column);
- gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(attach_clist), TRUE);
+ gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(attach_clist),
+ prefs_common.enable_rules_hint);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(attach_clist));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
gtk_widget_show(savemsg_entry);
gtk_table_attach_defaults(GTK_TABLE(table), savemsg_entry, 1, 2, rowcount, rowcount + 1);
gtk_editable_set_editable(GTK_EDITABLE(savemsg_entry), prefs_common.savemsg);
- g_signal_connect(G_OBJECT(savemsg_entry), "grab_focus",
- G_CALLBACK(compose_grab_focus_before_cb), compose);
g_signal_connect_after(G_OBJECT(savemsg_entry), "grab_focus",
G_CALLBACK(compose_grab_focus_cb), compose);
if (account_get_special_folder(compose->account, F_OUTBOX)) {
g_signal_connect(G_OBJECT(window), "delete_event",
G_CALLBACK(compose_delete_cb), compose);
- g_signal_connect(G_OBJECT(window), "destroy",
- G_CALLBACK(compose_destroy_cb), compose);
MANAGE_WINDOW_SIGNALS_CONNECT(window);
gtk_widget_realize(window);
handlebox = gtk_handle_box_new();
gtk_box_pack_start(GTK_BOX(vbox), handlebox, FALSE, FALSE, 0);
+ gtk_widget_realize(handlebox);
compose->toolbar = toolbar_create(TOOLBAR_COMPOSE, handlebox,
(gpointer)compose);
subject_entry = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(subject), subject_entry, TRUE, TRUE, 2);
- g_signal_connect(G_OBJECT(subject_entry), "grab_focus",
- G_CALLBACK(compose_grab_focus_before_cb), compose);
g_signal_connect_after(G_OBJECT(subject_entry), "grab_focus",
G_CALLBACK(compose_grab_focus_cb), compose);
gtk_widget_show(subject_entry);
/* text widget */
scrolledwin = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),
- GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
+ GTK_POLICY_AUTOMATIC,
+ GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwin),
GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(edit_vbox), scrolledwin, TRUE, TRUE, 0);
gtk_text_view_set_editable(GTK_TEXT_VIEW(text), TRUE);
clipboard = gtk_clipboard_get(GDK_SELECTION_PRIMARY);
gtk_text_buffer_add_selection_clipboard(buffer, clipboard);
- clipboard = gtk_clipboard_get(GDK_SELECTION_SECONDARY);
- gtk_text_buffer_add_selection_clipboard(buffer, clipboard);
- clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
- gtk_text_buffer_add_selection_clipboard(buffer, clipboard);
gtk_container_add(GTK_CONTAINER(scrolledwin), text);
compose->priority = PRIORITY_NORMAL;
compose_update_priority_menu_item(compose);
+ compose_set_out_encoding(compose);
+
/* Actions menu */
compose_update_actions_menu(compose);
menu_set_sensitive(ifactory, "/Options/Encrypt", can_encrypt);
}
+static void compose_set_out_encoding(Compose *compose)
+{
+ GtkItemFactoryEntry *entry;
+ GtkItemFactory *ifactory;
+ CharSet out_encoding;
+ gchar *path, *p, *q;
+ GtkWidget *item;
+
+ out_encoding = conv_get_charset_from_str(prefs_common.outgoing_charset);
+ ifactory = gtk_item_factory_from_widget(compose->menubar);
+
+ for (entry = compose_entries; entry->callback != compose_address_cb;
+ entry++) {
+ if (entry->callback == compose_set_encoding_cb &&
+ (CharSet)entry->callback_action == out_encoding) {
+ p = q = path = g_strdup(entry->path);
+ while (*p) {
+ if (*p == '_') {
+ if (p[1] == '_') {
+ p++;
+ *q++ = '_';
+ }
+ } else
+ *q++ = *p;
+ p++;
+ }
+ *q = '\0';
+ item = gtk_item_factory_get_item(ifactory, path);
+ gtk_widget_activate(item);
+ g_free(path);
+ break;
+ }
+ }
+}
+
static void compose_set_template_menu(Compose *compose)
{
GSList *tmpl_list, *cur;
void compose_update_privacy_systems_menu(Compose *compose)
{
static gchar *branch_path = "/Options/Privacy System";
- static gboolean connected = FALSE;
GtkItemFactory *ifactory;
GtkWidget *menuitem;
GSList *systems, *cur;
system_none = gtk_item_factory_get_widget(ifactory,
"/Options/Privacy System/None");
- if (!connected) {
- g_signal_connect(G_OBJECT(system_none), "activate",
- G_CALLBACK(compose_set_privacy_system_cb), compose);
- connected = TRUE;
- }
+
+ g_signal_connect(G_OBJECT(system_none), "activate",
+ G_CALLBACK(compose_set_privacy_system_cb), compose);
systems = privacy_get_system_ids();
for (cur = systems; cur != NULL; cur = g_slist_next(cur)) {
static void compose_destroy(Compose *compose)
{
+ compose_list = g_list_remove(compose_list, compose);
+
/* NOTE: address_completion_end() does nothing with the window
* however this may change. */
address_completion_end(compose->window);
#if USE_ASPELL
if (compose->gtkaspell) {
gtkaspell_delete(compose->gtkaspell);
+ compose->gtkaspell = NULL;
}
#endif
prefs_common.compose_width = compose->scrolledwin->allocation.width;
prefs_common.compose_height = compose->window->allocation.height;
- gtk_widget_destroy(compose->paned);
+ if (!gtk_widget_get_parent(compose->paned))
+ gtk_widget_destroy(compose->paned);
+ gtk_widget_destroy(compose->popupmenu);
+ gtk_widget_destroy(compose->window);
toolbar_destroy(compose->toolbar);
g_free(compose->toolbar);
g_free(compose);
-
- compose_list = g_list_remove(compose_list, compose);
}
static void compose_attach_info_free(AttachInfo *ainfo)
static void compose_attach_remove_selected(Compose *compose)
{
GtkTreeView *tree_view = GTK_TREE_VIEW(compose->attach_clist);
- AttachInfo *ainfo;
GtkTreeSelection *selection;
GList *sel, *cur;
GtkTreeModel *model;
}
}
-static gint calc_cursor_xpos(GtkTextView *text, gint extra, gint char_width)
-{
-#warning FIXME_GTK2
- return 0;
-}
-
/* callback functions */
/* compose_edit_size_alloc() - called when resized. don't know whether Gtk
/* got the maximum */
gtk_ruler_set_range(GTK_RULER(shruler),
- 0.0, line_width_in_chars,
- calc_cursor_xpos(GTK_TEXT_VIEW(widget),
- allocation->x,
- char_width),
+ 0.0, line_width_in_chars, 0,
/*line_width_in_chars*/ char_width);
}
gpointer data)
{
Compose *compose = (Compose *)data;
- GtkTreeView *tree_view = GTK_TREE_VIEW(compose->attach_clist);
- GtkTreeIter iter;
if (!event) return FALSE;
menu_set_sensitive(ifactory, "/Options", allow);
menu_set_sensitive(ifactory, "/Tools", allow);
menu_set_sensitive(ifactory, "/Help", allow);
+
+ gtk_text_view_set_editable(GTK_TEXT_VIEW(compose->text), allow);
+
}
static void compose_send_cb(gpointer data, guint action, GtkWidget *widget)
fprintf(fp, "SCF:%s\n", savefolderid);
g_free(savefolderid);
}
- fprintf(fp, "X-Sylpheed-Sign:%d\n", compose->use_signing);
- fprintf(fp, "X-Sylpheed-Encrypt:%d\n", compose->use_encryption);
- fprintf(fp, "X-Sylpheed-Privacy-System:%s\n", compose->privacy_system);
+ if (compose->privacy_system) {
+ fprintf(fp, "X-Sylpheed-Sign:%d\n", compose->use_signing);
+ fprintf(fp, "X-Sylpheed-Encrypt:%d\n", compose->use_encryption);
+ fprintf(fp, "X-Sylpheed-Privacy-System:%s\n", compose->privacy_system);
+ }
fprintf(fp, "\n");
if (compose_write_to_file(compose, fp, COMPOSE_WRITE_FOR_STORE) < 0) {
compose_close(compose);
}
+static void compose_set_encoding_cb(gpointer data, guint action,
+ GtkWidget *widget)
+{
+ Compose *compose = (Compose *)data;
+
+ if (GTK_CHECK_MENU_ITEM(widget)->active)
+ compose->out_encoding = (CharSet)action;
+}
+
static void compose_address_cb(gpointer data, guint action, GtkWidget *widget)
{
Compose *compose = (Compose *)data;
compose_exec_ext_editor(compose);
}
-static void compose_destroy_cb(GtkWidget *widget, Compose *compose)
-{
- if (compose->sending)
- return;
- compose_destroy(compose);
-}
-
static void compose_undo_cb(Compose *compose)
{
+ gboolean prev_autowrap = compose->autowrap;
+
+ compose->autowrap = FALSE;
undo_undo(compose->undostruct);
+ compose->autowrap = prev_autowrap;
}
static void compose_redo_cb(Compose *compose)
{
+ gboolean prev_autowrap = compose->autowrap;
+
+ compose->autowrap = FALSE;
undo_redo(compose->undostruct);
+ compose->autowrap = prev_autowrap;
}
static void entry_cut_clipboard(GtkWidget *entry)
else if (GTK_IS_TEXT_VIEW(entry))
gtk_text_buffer_cut_clipboard(
gtk_text_view_get_buffer(GTK_TEXT_VIEW(entry)),
- gtk_clipboard_get(GDK_NONE),
+ gtk_clipboard_get(GDK_SELECTION_CLIPBOARD),
TRUE);
}
else if (GTK_IS_TEXT_VIEW(entry))
gtk_text_buffer_copy_clipboard(
gtk_text_view_get_buffer(GTK_TEXT_VIEW(entry)),
- gtk_clipboard_get(GDK_NONE));
+ gtk_clipboard_get(GDK_SELECTION_CLIPBOARD));
}
static void entry_paste_clipboard(GtkWidget *entry)
else if (GTK_IS_TEXT_VIEW(entry))
gtk_text_buffer_paste_clipboard(
gtk_text_view_get_buffer(GTK_TEXT_VIEW(entry)),
- gtk_clipboard_get(GDK_NONE),
+ gtk_clipboard_get(GDK_SELECTION_CLIPBOARD),
NULL, TRUE);
}
}
}
-
static void compose_cut_cb(Compose *compose)
{
if (compose->focused_editable &&
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
mark = gtk_text_buffer_get_insert(buffer);
gtk_text_buffer_get_iter_at_mark(buffer, &ins, mark);
-#warning FIXME_GTK2 /* should regist current line offset */
offset = gtk_text_iter_get_line_offset(&ins);
if (gtk_text_iter_forward_line(&ins)) {
gtk_text_iter_set_line_offset(&ins, offset);
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
mark = gtk_text_buffer_get_insert(buffer);
gtk_text_buffer_get_iter_at_mark(buffer, &ins, mark);
-#warning FIXME_GTK2 /* should regist current line offset */
offset = gtk_text_iter_get_line_offset(&ins);
if (gtk_text_iter_backward_line(&ins)) {
gtk_text_iter_set_line_offset(&ins, offset);
}
}
-static gchar *cliptext = NULL;
-
-static void compose_grab_focus_before_cb(GtkWidget *widget, Compose *compose)
-{
- gchar *str = NULL;
- GtkClipboard *clip = gtk_clipboard_get(gdk_atom_intern("PRIMARY", FALSE));
- if (cliptext) {
- g_free(cliptext);
- cliptext = NULL;
- }
-
- if (gtk_clipboard_wait_is_text_available(clip))
- cliptext = gtk_clipboard_wait_for_text(clip);
-}
-
static void compose_grab_focus_cb(GtkWidget *widget, Compose *compose)
{
gchar *str = NULL;
- GtkClipboard *clip = gtk_clipboard_get(gdk_atom_intern("PRIMARY", FALSE));
if (GTK_IS_EDITABLE(widget)) {
str = gtk_editable_get_chars(GTK_EDITABLE(widget), 0, -1);
strlen(str));
g_free(str);
}
- if (cliptext)
- gtk_clipboard_set_text(clip, cliptext, -1);
if (GTK_IS_EDITABLE(widget) || GTK_IS_TEXT_VIEW(widget))
compose->focused_editable = widget;
}
}
+static void compose_wrap_cb(gpointer data, guint action, GtkWidget *widget)
+{
+ Compose *compose = (Compose *)data;
+
+ if (action == 1)
+ compose_wrap_all(compose);
+ else
+ compose_wrap_paragraph(compose, NULL);
+}
+
static void compose_toggle_autowrap_cb(gpointer data, guint action,
GtkWidget *widget)
{
Compose *compose = (Compose *)data;
compose->autowrap = GTK_CHECK_MENU_ITEM(widget)->active;
if (compose->autowrap)
- compose_wrap_line_all_full(compose, TRUE);
+ compose_wrap_all_full(compose, TRUE);
}
static void compose_toggle_sign_cb(gpointer data, guint action,
* does not work */
if (!strncmp(email, "mailto:", strlen("mailto:"))) {
- gchar decoded[strlen(email)];
+ gchar *decoded=g_new(gchar, strlen(email));
int start = 0;
email += strlen("mailto:");
gtk_editable_delete_text(entry, 0, -1);
gtk_editable_insert_text(entry, decoded, strlen(decoded), &start);
gtk_drag_finish(drag_context, TRUE, FALSE, time);
+ g_free(decoded);
return;
}
gtk_drag_finish(drag_context, TRUE, FALSE, time);
gtk_text_buffer_insert(buffer, iter, text, len);
mark = gtk_text_buffer_create_mark(buffer, NULL, iter, FALSE);
- compose_wrap_line_all_full(compose, TRUE);
+ compose_wrap_all_full(compose, TRUE);
gtk_text_buffer_get_iter_at_mark(buffer, iter, mark);
gtk_text_buffer_delete_mark(buffer, mark);
gtkut_widget_get_uposition(compose->window, &x, &y);
prefs_common.compose_x = x;
prefs_common.compose_y = y;
- gtk_widget_destroy(compose->window);
+ compose_destroy(compose);
}
/**
projects / claws.git / blobdiff