#include "undo.h"
#include "foldersel.h"
#include "toolbar.h"
-
+#include "inc.h"
enum
{
COL_MIMETYPE = 0,
GtkWidget *widget);
static void compose_set_privacy_system_cb(GtkWidget *widget,
gpointer data);
-static void compose_update_privacy_system_menu_item(Compose * compose);
+static void compose_update_privacy_system_menu_item(Compose * compose, gboolean warn);
static void activate_privacy_system (Compose *compose,
- PrefsAccount *account);
+ PrefsAccount *account,
+ gboolean warn);
static void compose_use_signing(Compose *compose, gboolean use_signing);
static void compose_use_encryption(Compose *compose, gboolean use_encryption);
static void compose_toggle_return_receipt_cb(gpointer data, guint action,
(gushort)0
};
-static GtkTextTag *no_wrap_tag = NULL;
-
static void compose_create_tags(GtkTextView *text, Compose *compose)
{
GtkTextBuffer *buffer;
gtk_text_buffer_create_tag(buffer, "link",
"foreground-gdk", &uri_color,
NULL);
- no_wrap_tag = gtk_text_buffer_create_tag(buffer, "no_wrap", NULL);
+ compose->no_wrap_tag = gtk_text_buffer_create_tag(buffer, "no_wrap", NULL);
}
Compose *compose_new(PrefsAccount *account, const gchar *mailto,
}
if (privacy != NULL) {
compose->privacy_system = g_strdup(privacy);
- compose_update_privacy_system_menu_item(compose);
+ compose_update_privacy_system_menu_item(compose, FALSE);
compose_use_encryption(compose, TRUE);
}
}
}
if (privacy != NULL) {
compose->privacy_system = g_strdup(privacy);
- compose_update_privacy_system_menu_item(compose);
+ compose_update_privacy_system_menu_item(compose, FALSE);
compose_use_signing(compose, TRUE);
}
}
compose->privacy_system = privacy_system;
compose_use_signing(compose, use_signing);
compose_use_encryption(compose, use_encryption);
- compose_update_privacy_system_menu_item(compose);
+ compose_update_privacy_system_menu_item(compose, FALSE);
} else {
- activate_privacy_system(compose, account);
+ activate_privacy_system(compose, account, FALSE);
}
compose->targetinfo = procmsg_msginfo_copy(msginfo);
strcrchomp(buf);
gtk_text_buffer_insert(textbuf, &iter, buf, -1);
}
+ compose_wrap_all_full(compose, FALSE);
compose->autowrap = prev_autowrap;
fclose(fp);
}
!g_utf8_collate(gtk_entry_get_text(entry), mailto)) {
gtk_widget_ensure_style(GTK_WIDGET(entry));
if (!bold_style) {
- PangoFontDescription *font_desc = NULL;
gtkut_convert_int_to_gdk_color
(prefs_common.color_new, &bold_color);
bold_style = gtk_style_copy(gtk_widget_get_style
lastp = strchr(p, '\n');
len = lastp ? lastp - p + 1 : -1;
- gtk_text_buffer_insert(buffer, &iter, p, len);
+ if (g_utf8_validate(p, -1, NULL)) {
+ gtk_text_buffer_insert(buffer, &iter, p, len);
+ } else {
+ gchar *tmpin = g_strdup(p);
+ gchar *tmpout = NULL;
+ tmpin[len] = '\0';
+ tmpout = conv_codeset_strdup
+ (tmpin, conv_get_locale_charset_str(),
+ CS_INTERNAL);
+ gtk_text_buffer_insert(buffer, &iter, tmpout, -1);
+ g_free(tmpin);
+ g_free(tmpout);
+ }
if (lastp)
p = lastp + 1;
SET_ADDRESS(COMPOSE_FOLLOWUPTO, compose->followup_to);
compose_update_priority_menu_item(compose);
- compose_update_privacy_system_menu_item(compose);
+ compose_update_privacy_system_menu_item(compose, FALSE);
compose_show_first_last_header(compose, TRUE);
}
gchar *o_walk = NULL, *walk = NULL, *bp = NULL, *ep = NULL;
gint walk_pos;
- if (gtk_text_iter_has_tag(&iter, no_wrap_tag) && !force)
+ if (gtk_text_iter_has_tag(&iter, compose->no_wrap_tag) && !force)
goto colorize;
uri_start = uri_stop = -1;
goto colorize;
}
debug_print("compose_beautify_paragraph(): quote_str = '%s'\n", quote_str);
- startq_offset = gtk_text_iter_get_offset(&iter);
+ if (startq_offset == -1)
+ startq_offset = gtk_text_iter_get_offset(&iter);
} else {
if (startq_offset == -1)
noq_offset = gtk_text_iter_get_offset(&iter);
}
- if (prev_autowrap == FALSE && !force) {
+ if (prev_autowrap == FALSE && !force && !wrap_quote) {
goto colorize;
}
if (compose_get_line_break_pos(buffer, &iter, &break_pos,
prefs_common.linewrap_len,
quote_len)) {
GtkTextIter prev, next, cur;
-
- gtk_text_buffer_insert(buffer, &break_pos, "\n", 1);
+ if (prev_autowrap != FALSE || force)
+ gtk_text_buffer_insert(buffer, &break_pos, "\n", 1);
+ else if (quote_str && wrap_quote)
+ gtk_text_buffer_insert(buffer, &break_pos, "\n", 1);
+ else
+ goto colorize;
/* remove trailing spaces */
cur = break_pos;
gtk_text_iter_backward_char(&cur);
else
menu_set_active(ifactory, "/Options/Encrypt", FALSE);
- activate_privacy_system(compose, account);
+ activate_privacy_system(compose, account, FALSE);
if (!init && compose->mode != COMPOSE_REDIRECT)
compose_insert_sig(compose, TRUE);
}
/* check for line length limit */
- if (encoding != ENC_QUOTED_PRINTABLE && encoding != ENC_BASE64 &&
+ if (action == COMPOSE_WRITE_FOR_SEND &&
+ encoding != ENC_QUOTED_PRINTABLE && encoding != ENC_BASE64 &&
check_line_length(buf, 1000, &line) < 0) {
AlertValue aval;
gchar *msg;
"\n"
"Send it anyway?"), line + 1);
aval = alertpanel(_("Warning"), msg, GTK_STOCK_OK, GTK_STOCK_CANCEL, NULL);
+ g_free(msg);
if (aval != G_ALERTDEFAULT) {
- g_free(msg);
- fclose(fp);
- g_free(buf);
return -1;
}
}
if (compose->privacy_system != NULL) {
fprintf(fp, "X-Sylpheed-Privacy-System:%s\n", compose->privacy_system);
fprintf(fp, "X-Sylpheed-Sign:%d\n", compose->use_signing);
- fprintf(fp, "X-Sylpheed-Encrypt:%d\n", compose->use_encryption);
if (compose->use_encryption) {
gchar *encdata;
encdata = privacy_get_encrypt_data(compose->privacy_system, compose->to_list);
- if (encdata != NULL)
- fprintf(fp, "X-Sylpheed-Encrypt-Data:%s\n",
- encdata);
+ if (encdata != NULL) {
+ if (strcmp(encdata, "_DONT_ENCRYPT_")) {
+ fprintf(fp, "X-Sylpheed-Encrypt:%d\n", compose->use_encryption);
+ fprintf(fp, "X-Sylpheed-Encrypt-Data:%s\n",
+ encdata);
+ } /* else we finally dont want to encrypt */
+ } else {
+ fprintf(fp, "X-Sylpheed-Encrypt:%d\n", compose->use_encryption);
+ /* and if encdata was null, it means there's been a problem in
+ * key selection */
+ }
g_free(encdata);
}
}
/* Subject */
str = gtk_editable_get_chars(GTK_EDITABLE(compose->subject_entry), 0, -1);
+
if (*str != '\0' && !IS_IN_CUSTOM_HEADER("Subject")) {
g_strstrip(str);
if (*str != '\0') {
subst_char(tmpstr, '\r', ' ');
g_strchomp(tmpstr);
+ if (!g_utf8_validate(tmpstr, -1, NULL)) {
+ gchar *mybuf = g_malloc(strlen(tmpstr)*2 +1);
+ conv_localetodisp(mybuf, strlen(tmpstr)*2 +1, tmpstr);
+ g_free(tmpstr);
+ tmpstr = mybuf;
+ }
conv_encode_header_full(dest, len, tmpstr, header_len, addr_field,
conv_get_charset_str(compose->out_encoding));
g_free(tmpstr);
g_free(path);
}
+static void entry_paste_clipboard(Compose *compose, GtkWidget *entry, gboolean wrap,
+ GdkAtom clip);
+
+#define BLOCK_WRAP() { \
+ prev_autowrap = compose->autowrap; \
+ buffer = gtk_text_view_get_buffer( \
+ GTK_TEXT_VIEW(compose->text)); \
+ compose->autowrap = FALSE; \
+ \
+ g_signal_handlers_block_by_func(G_OBJECT(buffer), \
+ G_CALLBACK(compose_changed_cb), \
+ compose); \
+ g_signal_handlers_block_by_func(G_OBJECT(buffer), \
+ G_CALLBACK(text_inserted), \
+ compose); \
+}
+#define UNBLOCK_WRAP() { \
+ compose->autowrap = prev_autowrap; \
+ if (compose->autowrap) \
+ compose_wrap_all(compose); \
+ \
+ g_signal_handlers_unblock_by_func(G_OBJECT(buffer), \
+ G_CALLBACK(compose_changed_cb), \
+ compose); \
+ g_signal_handlers_unblock_by_func(G_OBJECT(buffer), \
+ G_CALLBACK(text_inserted), \
+ compose); \
+}
+
+
+static gboolean text_clicked(GtkWidget *text, GdkEventButton *event,
+ Compose *compose)
+{
+ gint prev_autowrap;
+ GtkTextBuffer *buffer;
+ if (event->button == 2) {
+ BLOCK_WRAP();
+ entry_paste_clipboard(compose, compose->focused_editable,
+ prefs_common.linewrap_pastes,
+ GDK_SELECTION_PRIMARY);
+ UNBLOCK_WRAP();
+ return TRUE;
+ }
+ return FALSE;
+}
+
static Compose *compose_create(PrefsAccount *account, ComposeMode mode)
{
Compose *compose;
geometry.max_width = gdk_screen_width();
geometry.max_height = gdk_screen_height();
}
+
gtk_window_set_geometry_hints(GTK_WINDOW(window), NULL,
&geometry, GDK_HINT_MAX_SIZE);
if (!geometry.min_width) {
G_CALLBACK(compose_grab_focus_cb), compose);
g_signal_connect(G_OBJECT(buffer), "insert_text",
G_CALLBACK(text_inserted), compose);
+ g_signal_connect(G_OBJECT(text), "button_press_event",
+ G_CALLBACK(text_clicked), compose);
/* drag and drop */
gtk_drag_dest_set(text, GTK_DEST_DEFAULT_ALL, compose_mime_types,
/* Privacy Systems menu */
compose_update_privacy_systems_menu(compose);
- activate_privacy_system(compose, account);
+ activate_privacy_system(compose, account, TRUE);
toolbar_set_style(compose->toolbar->toolbar, compose->handlebox, prefs_common.toolbar_style);
gtk_widget_show(window);
menu_set_sensitive(ifactory, "/Options/Encrypt", can_encrypt);
}
-static void compose_update_privacy_system_menu_item(Compose * compose)
+static void compose_update_privacy_system_menu_item(Compose * compose, gboolean warn)
{
static gchar *branch_path = "/Options/Privacy System";
GtkItemFactory *ifactory;
GtkWidget *menuitem = NULL;
GList *amenu;
gboolean can_sign = FALSE, can_encrypt = FALSE;
+ gboolean found = FALSE;
ifactory = gtk_item_factory_from_widget(compose->menubar);
can_sign = privacy_system_can_sign(systemid);
can_encrypt = privacy_system_can_encrypt(systemid);
-
+ found = TRUE;
break;
}
}
if (menuitem != NULL)
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem), TRUE);
+
+ if (warn && !found && strlen(compose->privacy_system)) {
+ gchar *tmp = g_strdup_printf(
+ _("The privacy system '%s' cannot be loaded. You "
+ "will not be able to sign or encrypt this message."),
+ compose->privacy_system);
+ alertpanel_warning(tmp);
+ g_free(tmp);
+ }
}
menu_set_sensitive(ifactory, "/Options/Sign", can_sign);
GtkTextIter iter;
gchar *qmark;
gchar *parsed_str;
-
+ gint cursor_pos = 0;
if (!tmpl || !tmpl->value) return;
text = GTK_TEXT_VIEW(compose->text);
gtk_text_buffer_get_start_iter(buffer, &iter);
gtk_text_buffer_place_cursor(buffer, &iter);
}
+
+ if (parsed_str) {
+ cursor_pos = quote_fmt_get_cursor_pos();
+ gtk_text_buffer_get_start_iter(buffer, &iter);
+ gtk_text_buffer_get_iter_at_offset(buffer, &iter, cursor_pos);
+ gtk_text_buffer_place_cursor(buffer, &iter);
+ }
if (parsed_str)
compose_changed_cb(NULL, compose);
gpointer data)
{
Compose *compose = (Compose *)data;
-
+ GtkTreeSelection *attach_selection;
+ gint attach_nr_selected;
+ GtkItemFactory *ifactory;
+
if (!event) return FALSE;
if (event->button == 3) {
+ attach_selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(widget));
+ attach_nr_selected = gtk_tree_selection_count_selected_rows(attach_selection);
+ ifactory = gtk_item_factory_from_widget(compose->popupmenu);
+
+ if (attach_nr_selected > 0)
+ {
+ menu_set_sensitive(ifactory, "/Remove", TRUE);
+ menu_set_sensitive(ifactory, "/Properties...", TRUE);
+ } else {
+ menu_set_sensitive(ifactory, "/Remove", FALSE);
+ menu_set_sensitive(ifactory, "/Properties...", FALSE);
+ }
+
gtk_menu_popup(GTK_MENU(compose->popupmenu), NULL, NULL,
NULL, NULL, event->button, event->time);
return TRUE;
{
Compose *compose = (Compose *)data;
- if (prefs_common.work_offline)
- if (alertpanel(_("Offline warning"),
- _("You're working offline. Override?"),
- GTK_STOCK_YES, GTK_STOCK_NO, NULL) != G_ALERTDEFAULT)
- return;
+ if (prefs_common.work_offline && !inc_offline_should_override())
+ return;
if (compose->draft_timeout_tag != -1) { /* CLAWS: disable draft timeout */
gtk_timeout_remove(compose->draft_timeout_tag);
g_unlink(tmp);
g_free(tmp);
lock = FALSE;
+ if (action != COMPOSE_AUTO_SAVE)
+ alertpanel_error(_("Could not save draft."));
return;
}
g_free(tmp);
if (action == COMPOSE_AUTO_SAVE) {
compose->autosaved_draft = compose->targetinfo;
}
+ compose->modified = FALSE;
+ compose_set_title(compose);
}
}
if (compose->modified) {
val = alertpanel(_("Discard message"),
- _("This message has been modified. discard it?"),
- _("Discard"), _("to Draft"), GTK_STOCK_CANCEL);
+ _("This message has been modified. Discard it?"),
+ _("Discard"), _("Save to Drafts"), GTK_STOCK_CANCEL);
switch (val) {
case G_ALERTDEFAULT:
gtk_clipboard_get(GDK_SELECTION_CLIPBOARD));
}
-static void entry_paste_clipboard(GtkWidget *entry, gboolean wrap)
+static void entry_paste_clipboard(Compose *compose, GtkWidget *entry,
+ gboolean wrap, GdkAtom clip)
{
- if (GTK_IS_EDITABLE(entry))
- gtk_editable_paste_clipboard (GTK_EDITABLE(entry));
- else if (GTK_IS_TEXT_VIEW(entry)) {
+ if (GTK_IS_TEXT_VIEW(entry)) {
GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(entry));
GtkTextMark *mark_start = gtk_text_buffer_get_insert(buffer);
GtkTextIter start_iter, end_iter;
gint start, end;
- gchar *contents = gtk_clipboard_wait_for_text(gtk_clipboard_get(GDK_SELECTION_CLIPBOARD));
+ gchar *contents = gtk_clipboard_wait_for_text(gtk_clipboard_get(clip));
if (contents == NULL)
return;
gtk_text_buffer_get_iter_at_offset(buffer, &start_iter, start);
gtk_text_buffer_get_iter_at_offset(buffer, &end_iter, end);
gtk_text_buffer_apply_tag_by_name(buffer, "no_wrap", &start_iter, &end_iter);
+ } else if (wrap && clip == GDK_SELECTION_PRIMARY) {
+ mark_start = gtk_text_buffer_get_insert(buffer);
+ gtk_text_buffer_get_iter_at_mark(buffer, &start_iter, mark_start);
+ gtk_text_iter_backward_char(&start_iter);
+ compose_beautify_paragraph(compose, &start_iter, TRUE);
}
- }
+ } else if (GTK_IS_EDITABLE(entry))
+ gtk_editable_paste_clipboard (GTK_EDITABLE(entry));
+
}
static void entry_allsel(GtkWidget *entry)
entry_copy_clipboard(compose->focused_editable);
}
-#define BLOCK_WRAP() { \
- prev_autowrap = compose->autowrap; \
- buffer = gtk_text_view_get_buffer( \
- GTK_TEXT_VIEW(compose->text)); \
- compose->autowrap = FALSE; \
- \
- g_signal_handlers_block_by_func(G_OBJECT(buffer), \
- G_CALLBACK(compose_changed_cb), \
- compose); \
- g_signal_handlers_block_by_func(G_OBJECT(buffer), \
- G_CALLBACK(text_inserted), \
- compose); \
-}
-#define UNBLOCK_WRAP() { \
- compose->autowrap = prev_autowrap; \
- if (compose->autowrap) \
- compose_wrap_all(compose); \
- \
- g_signal_handlers_unblock_by_func(G_OBJECT(buffer), \
- G_CALLBACK(compose_changed_cb), \
- compose); \
- g_signal_handlers_unblock_by_func(G_OBJECT(buffer), \
- G_CALLBACK(text_inserted), \
- compose); \
-}
-
static void compose_paste_cb(Compose *compose)
{
gint prev_autowrap;
BLOCK_WRAP();
if (compose->focused_editable &&
GTK_WIDGET_HAS_FOCUS(compose->focused_editable))
- entry_paste_clipboard(compose->focused_editable, prefs_common.linewrap_pastes);
+ entry_paste_clipboard(compose, compose->focused_editable,
+ prefs_common.linewrap_pastes,
+ GDK_SELECTION_CLIPBOARD);
UNBLOCK_WRAP();
}
"paste_as_quotation",
GINT_TO_POINTER(paste_as_quotation + 1));
prefs_common.linewrap_quote = prefs_common.linewrap_pastes;
- entry_paste_clipboard(compose->focused_editable, prefs_common.linewrap_pastes);
+ entry_paste_clipboard(compose, compose->focused_editable,
+ prefs_common.linewrap_pastes,
+ GDK_SELECTION_CLIPBOARD);
prefs_common.linewrap_quote = wrap_quote;
}
}
BLOCK_WRAP();
if (compose->focused_editable &&
GTK_WIDGET_HAS_FOCUS(compose->focused_editable))
- entry_paste_clipboard(compose->focused_editable, FALSE);
+ entry_paste_clipboard(compose, compose->focused_editable, FALSE,
+ GDK_SELECTION_CLIPBOARD);
UNBLOCK_WRAP();
}
BLOCK_WRAP();
if (compose->focused_editable &&
GTK_WIDGET_HAS_FOCUS(compose->focused_editable))
- entry_paste_clipboard(compose->focused_editable, TRUE);
+ entry_paste_clipboard(compose, compose->focused_editable, TRUE,
+ GDK_SELECTION_CLIPBOARD);
UNBLOCK_WRAP();
}
gtk_editable_set_position(GTK_EDITABLE(widget),
strlen(str));
g_free(str);
+ if (widget->parent && widget->parent->parent
+ && widget->parent->parent->parent) {
+ if (GTK_IS_SCROLLED_WINDOW(widget->parent->parent->parent)) {
+ gint y = widget->allocation.y;
+ gint height = widget->allocation.height;
+ GtkAdjustment *shown = gtk_scrolled_window_get_vadjustment
+ (GTK_SCROLLED_WINDOW(widget->parent->parent->parent));
+
+ if (y < (int)shown->value) {
+ gtk_adjustment_set_value(GTK_ADJUSTMENT(shown), y - 1);
+ }
+ if (y + height > (int)shown->value + (int)shown->page_size) {
+ if (y - height - 1 < (int)shown->upper - (int)shown->page_size) {
+ gtk_adjustment_set_value(GTK_ADJUSTMENT(shown),
+ y + height - (int)shown->page_size - 1);
+ } else {
+ gtk_adjustment_set_value(GTK_ADJUSTMENT(shown),
+ (int)shown->upper - (int)shown->page_size - 1);
+ }
+ }
+ }
+ }
}
if (GTK_IS_EDITABLE(widget) || GTK_IS_TEXT_VIEW(widget))
compose->use_encryption = FALSE;
}
-static void activate_privacy_system(Compose *compose, PrefsAccount *account)
+static void activate_privacy_system(Compose *compose, PrefsAccount *account, gboolean warn)
{
g_free(compose->privacy_system);
compose->privacy_system = g_strdup(account->default_privacy_system);
- compose_update_privacy_system_menu_item(compose);
+ compose_update_privacy_system_menu_item(compose, warn);
}
static void compose_toggle_ruler_cb(gpointer data, guint action,