static void compose_attach_parts (Compose *compose,
MsgInfo *msginfo);
-static void compose_wrap_paragraph (Compose *compose,
+static void compose_beautify_paragraph (Compose *compose,
GtkTextIter *par_iter,
gboolean force);
static void compose_wrap_all (Compose *compose);
static void compose_copy_cb (Compose *compose);
static void compose_paste_cb (Compose *compose);
static void compose_paste_as_quote_cb (Compose *compose);
+static void compose_paste_no_wrap_cb (Compose *compose);
+static void compose_paste_wrap_cb (Compose *compose);
static void compose_allsel_cb (Compose *compose);
static void compose_advanced_action_cb (Compose *compose,
{N_("/_Edit/Cu_t"), "<control>X", compose_cut_cb, 0, NULL},
{N_("/_Edit/_Copy"), "<control>C", compose_copy_cb, 0, NULL},
{N_("/_Edit/_Paste"), "<control>V", compose_paste_cb, 0, NULL},
- {N_("/_Edit/Paste as _quotation"),
+ {N_("/_Edit/Special paste/as _quotation"),
NULL, compose_paste_as_quote_cb, 0, NULL},
+ {N_("/_Edit/Special paste/_wrapped"),
+ NULL, compose_paste_wrap_cb, 0, NULL},
+ {N_("/_Edit/Special paste/_unwrapped"),
+ NULL, compose_paste_no_wrap_cb, 0, NULL},
{N_("/_Edit/Select _all"), "<control>A", compose_allsel_cb, 0, NULL},
{N_("/_Edit/A_dvanced"), NULL, NULL, 0, "<Branch>"},
{N_("/_Edit/A_dvanced/Move a character backward"),
gtk_text_buffer_create_tag(buffer, "link",
"foreground-gdk", &uri_color,
NULL);
+ compose->no_wrap_tag = gtk_text_buffer_create_tag(buffer, "no_wrap", NULL);
}
Compose *compose_new(PrefsAccount *account, const gchar *mailto,
}
}
+static void compose_force_signing(Compose *compose, PrefsAccount *account)
+{
+ gchar *privacy = NULL;
+
+ 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_signing(compose, TRUE);
+ }
+}
+
void compose_reply_mode(ComposeMode mode, GSList *msginfo_list, gchar *body)
{
MsgInfo *msginfo;
return compose;
}
+static gboolean compose_is_sig_separator(Compose *compose, GtkTextBuffer *textbuf, 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, &end_iter,
+ start_pos+strlen(compose->account->sig_sep));
+
+ /* check sig separator */
+ if (!strcmp(gtk_text_iter_get_text(&start, &end_iter),
+ compose->account->sig_sep)) {
+ /* 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)+1);
+
+ if (!strcmp(gtk_text_iter_get_text(&start, &end_iter),"\n"));
+ return TRUE;
+
+
+ }
+
+ return FALSE;
+}
+
+static void compose_colorize_signature(Compose *compose)
+{
+ GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(compose->text));
+ GtkTextIter iter;
+ GtkTextIter end_iter;
+ gtk_text_buffer_get_start_iter(buffer, &iter);
+ while (gtk_text_iter_forward_line(&iter))
+ if (compose_is_sig_separator(compose, buffer, &iter)) {
+ gtk_text_buffer_get_end_iter(buffer, &end_iter);
+ gtk_text_buffer_apply_tag_by_name(buffer,"signature",&iter, &end_iter);
+ }
+}
+
void compose_reedit(MsgInfo *msginfo)
{
Compose *compose = NULL;
strcrchomp(buf);
gtk_text_buffer_insert(textbuf, &iter, buf, -1);
}
+ compose_wrap_all_full(compose, FALSE);
compose->autowrap = prev_autowrap;
fclose(fp);
}
compose_attach_parts(compose, msginfo);
+ compose_colorize_signature(compose);
+
g_signal_handlers_unblock_by_func(G_OBJECT(textbuf),
G_CALLBACK(compose_changed_cb),
compose);
compose_quote_fmt(compose, msginfo, "%M", NULL, NULL);
gtk_text_view_set_editable(GTK_TEXT_VIEW(compose->text), FALSE);
+ compose_colorize_signature(compose);
+
ifactory = gtk_item_factory_from_widget(compose->popupmenu);
menu_set_sensitive(ifactory, "/Add...", FALSE);
menu_set_sensitive(ifactory, "/Remove", FALSE);
!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
(GTK_WIDGET(entry)));
- if (BOLD_FONT)
- font_desc = pango_font_description_from_string
- (BOLD_FONT);
- if (font_desc) {
- if (bold_style->font_desc)
- pango_font_description_free
- (bold_style->font_desc);
- bold_style->font_desc = font_desc;
- }
+ pango_font_description_set_weight
+ (bold_style->font_desc, PANGO_WEIGHT_BOLD);
bold_style->fg[GTK_STATE_NORMAL] = bold_color;
}
gtk_widget_set_style(GTK_WIDGET(entry), bold_style);
compose_ext_editor_cb(compose, 0, NULL);
break;
case A_LINEWRAP_CURRENT:
- compose_wrap_paragraph(compose, NULL, TRUE);
+ compose_beautify_paragraph(compose, NULL, TRUE);
break;
case A_LINEWRAP_ALL:
compose_wrap_all_full(compose, TRUE);
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;
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);
+
+ /* if we meet a pgp signature, we don't attach it, but
+ * we force signing. */
+ if (strcmp(content_type, "application/pgp-signature")) {
+ partname = procmime_mimeinfo_get_parameter(child, "filename");
+ if (partname == NULL)
+ partname = procmime_mimeinfo_get_parameter(child, "name");
+ if (partname == NULL)
+ partname = "";
+ compose_attach_append(compose, outfile,
+ partname, content_type);
+ } else {
+ compose_force_signing(compose, compose->account);
+ }
g_free(content_type);
}
g_free(outfile);
return do_break;
}
-static gboolean compose_is_sig_separator(Compose *compose, GtkTextBuffer *textbuf, 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, &end_iter,
- start_pos+strlen(compose->account->sig_sep));
-
- /* check sig separator */
- if (!strcmp(gtk_text_iter_get_text(&start, &end_iter),
- compose->account->sig_sep)) {
- /* 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)+1);
-
- if (!strcmp(gtk_text_iter_get_text(&start, &end_iter),"\n"));
- return TRUE;
-
-
- }
-
- return FALSE;
-}
-
static gboolean compose_join_next_line(Compose *compose,
GtkTextBuffer *buffer,
GtkTextIter *iter,
g_warning("alloc error scanning URIs\n"); \
}
-static void compose_wrap_paragraph(Compose *compose, GtkTextIter *par_iter, gboolean force)
+static void compose_beautify_paragraph(Compose *compose, GtkTextIter *par_iter, gboolean force)
{
GtkTextView *text = GTK_TEXT_VIEW(compose->text);
GtkTextBuffer *buffer;
const gint PARSE_ELEMS = sizeof parser / sizeof parser[0];
gint last_index = PARSE_ELEMS;
gint n;
- gchar *o_walk, *walk, *bp, *ep;
+ gchar *o_walk = NULL, *walk = NULL, *bp = NULL, *ep = NULL;
gint walk_pos;
+
+ if (gtk_text_iter_has_tag(&iter, compose->no_wrap_tag) && !force)
+ goto colorize;
uri_start = uri_stop = -1;
quote_str = compose_get_quote_str(buffer, &iter, "e_len);
}
goto colorize;
}
- debug_print("compose_wrap_paragraph(): quote_str = '%s'\n", quote_str);
- startq_offset = gtk_text_iter_get_offset(&iter);
+ debug_print("compose_beautify_paragraph(): quote_str = '%s'\n", quote_str);
+ 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);
uri_stop = walk_pos + (ep - o_walk);
}
g_free(o_walk);
+ o_walk = NULL;
gtk_text_iter_forward_line(&iter);
g_free(quote_str);
+ quote_str = NULL;
if (startq_offset != -1) {
GtkTextIter startquote, endquote;
gtk_text_buffer_get_iter_at_offset(
gtk_text_buffer_get_start_iter(buffer, &iter);
while (!gtk_text_iter_is_end(&iter))
- compose_wrap_paragraph(compose, &iter, force);
+ compose_beautify_paragraph(compose, &iter, force);
undo_unblock(compose->undostruct);
}
val = compose_queue(compose, &msgnum, &folder);
if (val) {
- if (val == -2) {
+ if (val == -3) {
+ alertpanel_error(_("Could not queue message for sending:\n\n"
+ "Signature failed."));
+ } else if (val == -2) {
alertpanel_error(_("Could not queue message for sending:\n\n%s."), strerror(errno));
} else {
alertpanel_error(_("Could not queue message for sending."));
}
/* 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 (action == COMPOSE_WRITE_FOR_SEND && compose->use_signing &&
privacy_system_can_sign(compose->privacy_system))
if (!privacy_sign(compose->privacy_system, mimemsg, compose->account))
- return -1;
+ return -2;
procmime_write_mimeinfo(mimemsg, fp);
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);
}
}
return -2;
}
} else {
- if (compose_write_to_file(compose, fp, COMPOSE_WRITE_FOR_SEND) < 0) {
+ gint result = 0;
+ if ((result = compose_write_to_file(compose, fp, COMPOSE_WRITE_FOR_SEND)) < 0) {
lock = FALSE;
fclose(fp);
g_unlink(tmp);
g_free(tmp);
- return -2;
+ return result - 1; /* -2 for a generic error, -3 for signing error */
}
}
/* 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,
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;
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);
}
}
gtk_clipboard_get(GDK_SELECTION_CLIPBOARD));
}
-static void entry_paste_clipboard(GtkWidget *entry)
+static void entry_paste_clipboard(Compose *compose, GtkWidget *entry,
+ gboolean wrap, GdkAtom clip)
{
- if (GTK_IS_EDITABLE(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(clip));
+
+ if (contents == NULL)
+ return;
+
+ gtk_text_buffer_delete_selection(buffer, FALSE, TRUE);
+ gtk_text_buffer_get_iter_at_mark(buffer, &start_iter, mark_start);
+
+ start = gtk_text_iter_get_offset(&start_iter);
+
+ gtk_text_buffer_insert(buffer, &start_iter, contents, strlen(contents));
+
+ if (!wrap) {
+ end = start + strlen(contents);
+ 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));
- 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_SELECTION_CLIPBOARD),
- NULL, TRUE);
+
}
static void entry_allsel(GtkWidget *entry)
static void compose_paste_cb(Compose *compose)
{
+ gint prev_autowrap;
+ GtkTextBuffer *buffer;
+ BLOCK_WRAP();
if (compose->focused_editable &&
GTK_WIDGET_HAS_FOCUS(compose->focused_editable))
- entry_paste_clipboard(compose->focused_editable);
+ entry_paste_clipboard(compose, compose->focused_editable,
+ prefs_common.linewrap_pastes,
+ GDK_SELECTION_CLIPBOARD);
+ UNBLOCK_WRAP();
}
static void compose_paste_as_quote_cb(Compose *compose)
{
+ gint wrap_quote = prefs_common.linewrap_quote;
if (compose->focused_editable &&
GTK_WIDGET_HAS_FOCUS(compose->focused_editable)) {
/* let text_insert() (called directly or at a later time
g_object_set_data(G_OBJECT(compose->focused_editable),
"paste_as_quotation",
GINT_TO_POINTER(paste_as_quotation + 1));
- entry_paste_clipboard(compose->focused_editable);
+ prefs_common.linewrap_quote = prefs_common.linewrap_pastes;
+ entry_paste_clipboard(compose, compose->focused_editable,
+ prefs_common.linewrap_pastes,
+ GDK_SELECTION_CLIPBOARD);
+ prefs_common.linewrap_quote = wrap_quote;
}
}
+static void compose_paste_no_wrap_cb(Compose *compose)
+{
+ gint prev_autowrap;
+ GtkTextBuffer *buffer;
+ BLOCK_WRAP();
+ if (compose->focused_editable &&
+ GTK_WIDGET_HAS_FOCUS(compose->focused_editable))
+ entry_paste_clipboard(compose, compose->focused_editable, FALSE,
+ GDK_SELECTION_CLIPBOARD);
+ UNBLOCK_WRAP();
+}
+
+static void compose_paste_wrap_cb(Compose *compose)
+{
+ gint prev_autowrap;
+ GtkTextBuffer *buffer;
+ BLOCK_WRAP();
+ if (compose->focused_editable &&
+ GTK_WIDGET_HAS_FOCUS(compose->focused_editable))
+ entry_paste_clipboard(compose, compose->focused_editable, TRUE,
+ GDK_SELECTION_CLIPBOARD);
+ UNBLOCK_WRAP();
+}
+
static void compose_allsel_cb(Compose *compose)
{
if (compose->focused_editable &&
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))
if (action == 1)
compose_wrap_all_full(compose, TRUE);
else
- compose_wrap_paragraph(compose, NULL, TRUE);
+ compose_beautify_paragraph(compose, NULL, TRUE);
}
static void compose_toggle_autowrap_cb(gpointer data, guint action,
qmark = prefs_common.quotemark;
else
qmark = "> ";
+
+ mark = gtk_text_buffer_create_mark(buffer, NULL, iter, FALSE);
gtk_text_buffer_place_cursor(buffer, iter);
+
compose_quote_fmt(compose, NULL, "%Q", qmark, new_text);
g_free(new_text);
g_object_set_data(G_OBJECT(compose->text), "paste_as_quotation",
GINT_TO_POINTER(paste_as_quotation - 1));
+
+ gtk_text_buffer_get_iter_at_mark(buffer, iter, mark);
} else
gtk_text_buffer_insert(buffer, iter, text, len);
mark = gtk_text_buffer_create_mark(buffer, NULL, iter, FALSE);
- compose_wrap_all_full(compose, FALSE);
+
+ compose_beautify_paragraph(compose, iter, FALSE);
+
gtk_text_buffer_get_iter_at_mark(buffer, iter, mark);
gtk_text_buffer_delete_mark(buffer, mark);
projects / claws.git / blobdiff