static void compose_advanced_action_cb (Compose *compose,
ComposeCallAdvancedAction action);
-static void compose_grab_focus_cb (GtkWidget *widget,
+static gboolean compose_grab_focus_cb (GtkWidget *widget,
+ Compose *compose);
+static gboolean compose_grab_focus_before_cb (GtkWidget *widget,
Compose *compose);
static void compose_changed_cb (GtkTextBuffer *textbuf,
static void compose_show_first_last_header (Compose *compose, gboolean show_first);
+static void compose_allow_user_actions (Compose *compose, gboolean allow);
+
#if USE_ASPELL
static void compose_check_all (Compose *compose);
static void compose_highlight_all (Compose *compose);
static GtkItemFactoryEntry compose_entries[] =
{
{N_("/_File"), NULL, NULL, 0, "<Branch>"},
+ {N_("/_File/_Save"),
+ "<control>S", compose_draft_cb, 1, NULL},
+ {N_("/_File/---"), NULL, NULL, 0, "<Separator>"},
{N_("/_File/_Attach file"), "<control>M", compose_attach_cb, 0, NULL},
{N_("/_File/_Insert file"), "<control>I", compose_insert_file_cb, 0, NULL},
{N_("/_File/Insert si_gnature"), "<control>G", compose_insert_sig_cb, 0, NULL},
compose_send_cb, 0, NULL},
{N_("/_Message/Send _later"), "<shift><control>S",
compose_send_later_cb, 0, NULL},
- {N_("/_Message/---"), NULL, NULL, 0, "<Separator>"},
- {N_("/_Message/Save to _draft folder"),
- "<shift><control>D", compose_draft_cb, 0, NULL},
- {N_("/_Message/Save and _keep editing"),
- "<control>S", compose_draft_cb, 1, NULL},
#if 0 /* NEW COMPOSE GUI */
{N_("/_Message/---"), NULL, NULL, 0, "<Separator>"},
{N_("/_Message/_To"), NULL, compose_toggle_to_cb , 0, "<ToggleItem>"},
textview = GTK_TEXT_VIEW(compose->text);
textbuf = gtk_text_view_get_buffer(textview);
+ undo_block(compose->undostruct);
#ifdef USE_ASPELL
if (item && item->prefs && item->prefs->enable_default_dictionary &&
compose->gtkaspell)
textview = (GTK_TEXT_VIEW(compose->text));
textbuf = gtk_text_view_get_buffer(textview);
+ undo_block(compose->undostruct);
#ifdef USE_ASPELL
if (msginfo->folder && msginfo->folder->prefs &&
msginfo->folder->prefs &&
menu_set_sensitive(ifactory, "/Property...", FALSE);
ifactory = gtk_item_factory_from_widget(compose->menubar);
+ menu_set_sensitive(ifactory, "/File/Save", FALSE);
menu_set_sensitive(ifactory, "/File/Insert file", FALSE);
menu_set_sensitive(ifactory, "/File/Attach file", FALSE);
menu_set_sensitive(ifactory, "/File/Insert signature", FALSE);
menu_set_sensitive(ifactory, "/Edit", FALSE);
- menu_set_sensitive(ifactory, "/Message/Save to draft folder", FALSE);
- menu_set_sensitive(ifactory, "/Message/Save and keep editing", FALSE);
#if USE_GPGME
menu_set_sensitive(ifactory, "/Message/Sign", FALSE);
menu_set_sensitive(ifactory, "/Message/Encrypt", FALSE);
mark = gtk_text_buffer_get_insert(buffer);
gtk_text_buffer_get_iter_at_mark(buffer, &iter, mark);
+ g_signal_handlers_block_by_func(G_OBJECT(buffer),
+ G_CALLBACK(text_inserted),
+ compose);
+
while (fgets(buf, sizeof(buf), fp) != NULL) {
const gchar *cur_encoding = conv_get_current_charset_str();
gchar *str = conv_codeset_strdup(buf, cur_encoding, CS_UTF_8);
g_free (str);
}
+ g_signal_handlers_unblock_by_func(G_OBJECT(buffer),
+ G_CALLBACK(text_inserted),
+ compose);
+
fclose(fp);
if (badtxt)
ifactory = gtk_item_factory_from_widget(compose->menubar);
menuitem = gtk_item_factory_get_item
(ifactory, "/Message/Sign");
+
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem),
use_signing);
compose_update_gnupg_mode_menu_item(compose);
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);
for (; cur_pos < tlen; cur_pos++) {
guint tab_width = 8;
guint tab_offset = line_len % tab_width;
- if (tab_offset) {
- line_len += tab_width - tab_offset - 1;
- cur_len = line_len;
- }
+ line_len += tab_width - tab_offset - 1;
+ cur_len = line_len;
}
/* we have encountered line break */
/* 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++;
}
{
gint msgnum;
FolderItem *folder;
- gint val;
+ gint val = -1;
gchar *msgpath;
+ compose_allow_user_actions (compose, FALSE);
+ compose->sending = TRUE;
+
if (compose_check_entries(compose, TRUE) == FALSE)
- return -1;
+ goto bail;
val = compose_queue(compose, &msgnum, &folder);
+
if (val) {
alertpanel_error(_("Could not queue message for sending"));
- return -1;
+ goto bail;
}
+ compose->sending = FALSE;
+ gtk_widget_destroy(compose->window);
+ /* No more compose access in the normal codepath after this point! */
+
if (msgnum == 0) {
- alertpanel_error(_("The message was queued but could not be sent.\nUse \"Send queued messages\" from the main window to retry."));
+ alertpanel_error(_("The message was queued but could not be "
+ "sent.\nUse \"Send queued messages\" from "
+ "the main window to retry."));
return 0;
}
val = procmsg_send_message_queue(msgpath);
g_free(msgpath);
- folder_item_remove_msg(folder, msgnum);
-
- folder_item_scan(folder);
+ if (val == 0) {
+ folder_item_remove_msg(folder, msgnum);
+ folder_item_scan(folder);
+ }
- return val;
+ return 0;
+
+bail:
+ compose_allow_user_actions (compose, TRUE);
+ compose->sending = FALSE;
+
+ return -1;
}
#if 0 /* compose restructure */
gchar *canon_buf;
const gchar *out_codeset;
EncodingType encoding;
+ gboolean already_encoded = FALSE;
if ((fp = fopen(file, "wb")) == NULL) {
FILE_OP_ERROR(file, "fopen");
compose->use_signing && !compose->gnupg_mode &&
encoding == ENC_8BIT)
encoding = ENC_BASE64;
+
+ if (compose->use_encryption && compose->gnupg_mode)
+ encoding = ENC_8BIT; /* this will be encrypted to a 7bit string */
#endif
src_codeset = CS_UTF_8;
buf = conv_codeset_strdup(chars, src_codeset, out_codeset);
if (!buf) {
- AlertValue aval;
+ AlertValue aval = G_ALERTDEFAULT;
gchar *msg;
- msg = g_strdup_printf(_("Can't convert the character encoding of the message from\n"
+ if (!is_draft) {
+ msg = g_strdup_printf(_("Can't convert the character encoding of the message from\n"
"%s to %s.\n"
"Send it anyway?"), src_codeset, out_codeset);
- aval = alertpanel
- (_("Error"), msg, _("Yes"), _("+No"), NULL);
- g_free(msg);
-
+ aval = alertpanel_with_type
+ (_("Error"), msg, _("Yes"), _("+No"), NULL, NULL, ALERT_ERROR);
+ g_free(msg);
+ }
+
if (aval != G_ALERTDEFAULT) {
g_free(chars);
fclose(fp);
#if USE_GPGME
if (!is_draft && compose->use_signing && compose->gnupg_mode) {
+ gchar *outbuf;
+
+ if (encoding == ENC_QUOTED_PRINTABLE) {
+ outbuf = g_malloc(strlen(buf) * 4);
+ qp_encode_line(outbuf, buf);
+ g_free(buf);
+ buf = g_strdup(outbuf);
+ already_encoded = TRUE;
+ g_free(outbuf);
+ }
+
if (compose_clearsign_text(compose, &buf) < 0) {
g_warning("clearsign failed\n");
fclose(fp);
} else if (encoding == ENC_QUOTED_PRINTABLE) {
gchar *outbuf;
size_t outlen;
-
- outbuf = g_malloc(len * 4);
- qp_encode_line(outbuf, buf);
- outlen = strlen(outbuf);
+ if (!already_encoded) {
+ outbuf = g_malloc(len * 4);
+ qp_encode_line(outbuf, buf);
+ outlen = strlen(outbuf);
+ } else {
+ outbuf = g_strdup(buf);
+ outlen = len;
+ }
if (fwrite(outbuf, sizeof(gchar), outlen, fp) != outlen) {
FILE_OP_ERROR(file, "fwrite");
fclose(fp);
if (!g_strcasecmp(trans_hdr, headerentryname)) {
const gchar *entstr = gtk_entry_get_text(GTK_ENTRY(headerentry->entry));
- gchar *tmpstr = conv_codeset_strdup(entstr, CS_UTF_8, conv_get_current_charset_str());
- Xstrdup_a(str, tmpstr, return -1);
+ Xstrdup_a(str, entstr, return -1);
g_strstrip(str);
if (str[0] != '\0') {
if (write_header)
g_string_append(headerstr, str);
write_header = TRUE;
}
- g_free(tmpstr);
}
}
if (write_header) {
#endif
/* Organization */
if (compose->account->organization &&
+ strlen(compose->account->organization) &&
!IS_IN_CUSTOM_HEADER("Organization")) {
compose_convert_header(buf, sizeof(buf),
compose->account->organization,
if (len < 1) return;
- tmpstr = conv_codeset_strdup(src, CS_UTF_8, conv_get_current_charset_str());
+ tmpstr = g_strdup(src);
subst_char(tmpstr, '\n', ' ');
subst_char(tmpstr, '\r', ' ');
}
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);
/* Entry field */
entry = gtk_entry_new();
g_signal_connect(G_OBJECT(entry), "activate",
G_CALLBACK(text_activated), compose);
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);
g_signal_connect(G_OBJECT(entry), "button-press-event",
G_CALLBACK(compose_headerentry_button_pressed),
attach_scrwin = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(attach_scrwin),
GTK_POLICY_AUTOMATIC,
- GTK_POLICY_ALWAYS);
+ GTK_POLICY_AUTOMATIC);
gtk_widget_set_size_request(attach_scrwin, -1, 80);
attach_clist = gtk_clist_new_with_titles(N_ATTACH_COLS, titles);
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)) {
folderidentifier = folder_item_get_identifier(account_get_special_folder
compose->account = account;
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
- gtk_window_set_policy(GTK_WINDOW(window), TRUE, TRUE, FALSE);
+ gtk_window_set_resizable(GTK_WINDOW(window), TRUE);
gtk_widget_set_size_request(window, -1, prefs_common.compose_height);
- gtk_window_set_wmclass(GTK_WINDOW(window), "compose window", "Sylpheed");
if (!geometry.max_width) {
geometry.max_width = gdk_screen_width();
g_signal_connect(G_OBJECT(subject_entry), "activate",
G_CALLBACK(text_activated), compose);
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);
compose->subject_entry = 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_ALWAYS);
+ GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX(edit_vbox), scrolledwin, TRUE, TRUE, 0);
gtk_widget_set_size_request(scrolledwin, prefs_common.compose_width, -1);
clipboard = gtk_clipboard_get(GDK_SELECTION_PRIMARY);
gtk_text_buffer_add_selection_clipboard(buffer, clipboard);
- if (prefs_common.smart_wrapping) {
- gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(text), GTK_WRAP_WORD);
- }
-
gtk_container_add(GTK_CONTAINER(scrolledwin), text);
g_signal_connect_after(G_OBJECT(text), "size_allocate",
prefs_common.misspelled_col,
prefs_common.check_while_typing,
prefs_common.use_alternate,
- GTK_TEXT_VIEW(text));
+ GTK_TEXT_VIEW(text),
+ GTK_WINDOW(compose->window));
if (!gtkaspell) {
alertpanel_error(_("Spell checker could not "
"be started.\n%s"),
menu_set_sensitive(ifactory, "/Message/Send", sensitive);
menu_set_sensitive(ifactory, "/Message/Send later", sensitive);
- menu_set_sensitive(ifactory, "/Message/Save to draft folder",
- sensitive);
menu_set_sensitive(ifactory, "/File/Insert file", sensitive);
menu_set_sensitive(ifactory, "/File/Insert signature", sensitive);
menu_set_sensitive(ifactory, "/Edit/Wrap current paragraph", sensitive);
compose->draft_timeout_tag = -1;
}
- compose_allow_user_actions (compose, FALSE);
- compose->sending = TRUE;
- val = compose_send(compose);
- compose_allow_user_actions (compose, TRUE);
- compose->sending = FALSE;
-
- if (val == 0) gtk_widget_destroy(compose->window);
+ compose_send(compose);
}
static void compose_send_later_cb(gpointer data, guint action,
if (newmsginfo) {
procmsg_msginfo_unset_flags(newmsginfo, ~0, ~0);
procmsg_msginfo_set_flags(newmsginfo, 0, MSG_DRAFT);
+ if (compose_use_attach(compose))
+ procmsg_msginfo_set_flags(newmsginfo, 0, MSG_HAS_ATTACHMENT);
procmsg_msginfo_free(newmsginfo);
}
if (compose->redirect_filename != NULL)
return;
- file_list = filesel_select_multiple_files(_("Select file"));
+ file_list = filesel_select_multiple_files_open(_("Select file"));
if (file_list) {
GList *tmp;
Compose *compose = (Compose *)data;
GList *file_list;
- file_list = filesel_select_multiple_files(_("Select file"));
+ file_list = filesel_select_multiple_files_open(_("Select file"));
if (file_list) {
GList *tmp;
for ( tmp = file_list; tmp; tmp = tmp->next) {
gchar *file = (gchar *) tmp->data;
gchar *filedup = g_strdup(file);
- gchar *shortfile;
+ const gchar *shortfile = g_basename(filedup);
ComposeInsertResult res;
res = compose_insert_file(compose, file);
- shortfile = g_basename(filedup);
if (res == COMPOSE_INSERT_READ_ERROR) {
alertpanel_error(_("File '%s' could not be read."), shortfile);
} else if (res == COMPOSE_INSERT_INVALID_CHARACTER) {
}
}
-static void compose_grab_focus_cb(GtkWidget *widget, Compose *compose)
+static gchar *cliptext = NULL;
+
+static gboolean 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);
+ if (gtk_clipboard_wait_is_text_available(clip))
+ cliptext = gtk_clipboard_wait_for_text(clip);
+
+ return FALSE;
+}
+
+static gboolean 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);
+ gtk_editable_set_position(GTK_EDITABLE(widget),
+ 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;
+
+ return TRUE;
}
static void compose_changed_cb(GtkTextBuffer *textbuf, Compose *compose)
GtkWidget *widget)
{
Compose *compose = (Compose *)data;
-
compose->autowrap = GTK_CHECK_MENU_ITEM(widget)->active;
if (compose->autowrap)
compose_wrap_line_all_full(compose, TRUE);
projects / claws.git / blobdiff