/*
* Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
- * Copyright (C) 1999-2003 Hiroyuki Yamamoto
+ * Copyright (C) 1999-2004 Hiroyuki Yamamoto
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
#include <gtk/gtklabel.h>
#include <gtk/gtkscrolledwindow.h>
#include <gtk/gtktreeview.h>
-#warning FIXME_GTK2
-/* #include <gtk/gtkthemes.h> */
+
#include <gtk/gtkdnd.h>
#include <stdio.h>
#include <stdlib.h>
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,
Compose *compose);
+static void compose_toggle_autowrap_cb (gpointer data,
+ guint action,
+ GtkWidget *widget);
+
#if 0
static void compose_toggle_to_cb (gpointer data,
guint action,
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},
"<control>L", compose_wrap_line, 0, NULL},
{N_("/_Edit/Wrap all long _lines"),
"<control><alt>L", compose_wrap_line_all, 0, 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"),
"<shift><control>X", compose_ext_editor_cb, 0, NULL},
#if USE_ASPELL
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)
compose_entry_mark_default_to(compose, item->prefs->default_to);
}
if (item && item->ret_rcpt) {
- menu_set_toggle(ifactory, "/Message/Request Return Receipt", TRUE);
+ menu_set_active(ifactory, "/Message/Request Return Receipt", TRUE);
}
} else {
if (mailto) {
compose = compose_create(account, COMPOSE_REPLY);
ifactory = gtk_item_factory_from_widget(compose->menubar);
- menu_set_toggle(ifactory, "/Message/Remove references", FALSE);
+ menu_set_active(ifactory, "/Message/Remove references", FALSE);
menu_set_sensitive(ifactory, "/Message/Remove references", TRUE);
compose->replyinfo = procmsg_msginfo_get_full_info(msginfo);
compose->replyinfo = procmsg_msginfo_copy(msginfo);
if (msginfo->folder && msginfo->folder->ret_rcpt)
- menu_set_toggle(ifactory, "/Message/Request Return Receipt", TRUE);
+ menu_set_active(ifactory, "/Message/Request Return Receipt", TRUE);
/* Set save folder */
if (msginfo->folder && msginfo->folder->prefs && msginfo->folder->prefs->save_copy_to_folder) {
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 &&
mark = gtk_text_buffer_get_insert(textbuf);
gtk_text_buffer_get_iter_at_mark(textbuf, &iter, mark);
+ g_signal_handlers_block_by_func(G_OBJECT(textbuf),
+ G_CALLBACK(compose_changed_cb),
+ compose);
+
if ((fp = procmime_get_first_text_content(msginfo)) == NULL)
g_warning("Can't get text part\n");
else {
}
fclose(fp);
}
+
compose_attach_parts(compose, msginfo);
+ g_signal_handlers_unblock_by_func(G_OBJECT(textbuf),
+ G_CALLBACK(compose_changed_cb),
+ compose);
+
gtk_widget_grab_focus(compose->text);
if (prefs_common.auto_exteditor)
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);
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);
mark = gtk_text_buffer_get_insert(buffer);
gtk_text_buffer_get_iter_at_mark(buffer, &iter, mark);
lastp = strchr(p, '\n');
len = lastp ? lastp - p + 1 : -1;
+
gtk_text_buffer_insert(buffer, &iter, p, len);
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);
if (lastp)
p = lastp + 1;
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) {
-#warning FIXME_GTK2
-#if 1 /* FIXME_GTK2 */
const gchar *cur_encoding = conv_get_current_charset_str();
gchar *str = conv_codeset_strdup(buf, cur_encoding, CS_UTF_8);
gtk_text_buffer_insert(buffer, &iter, str, -1);
g_free (str);
-#endif /* FIXME_GTK2 */
}
+ g_signal_handlers_unblock_by_func(G_OBJECT(buffer),
+ G_CALLBACK(text_inserted),
+ compose);
+
fclose(fp);
if (badtxt)
#if 0 /* NEW COMPOSE GUI */
if (!compose->use_attach) {
GtkItemFactory *ifactory;
- GtkWidget *menuitem;
ifactory = gtk_item_factory_from_widget(compose->menubar);
- menuitem = gtk_item_factory_get_item(ifactory,
- "/View/Attachment");
- gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem),
- TRUE);
+ menu_set_active(ifactory, "/View/Attachment", TRUE);
}
#endif
ainfo = g_new0(AttachInfo, 1);
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);
#define SPACE_CHARS " \t"
-#warning FIXME_GTK2
static void compose_wrap_line(Compose *compose)
{
GtkTextView *text = GTK_TEXT_VIEW(compose->text);
return ins_len;
}
+static gboolean is_sig_separator(Compose *compose, GtkTextBuffer *textbuf, guint start_pos)
+{
+ char *text = NULL;
+ GtkTextIter iter;
+ GtkTextIter end_iter;
+ 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);
+
+ if (!strcmp(gtk_text_iter_get_text(&iter, &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);
+ gtk_text_buffer_get_iter_at_offset(textbuf, &end_iter,
+ start_pos+strlen(compose->account->sig_sep)+2);
+
+ if (!strcmp(gtk_text_iter_get_text(&iter, &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,
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;
}
static void compose_wrap_line_all_full(Compose *compose, gboolean autowrap)
{
-#if 0
GtkTextView *text = GTK_TEXT_VIEW(compose->text);
GtkTextBuffer *textbuf = gtk_text_view_get_buffer(text);
GtkTextIter iter, end_iter;
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++) {
/* fix line length for tabs */
if (ch_len == 1 && *cbuf == '\t') {
-#warning FIXME_GTK2
- /* guint tab_width = text->default_tab_width; */
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 */
/* 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))
+ (textbuf, cur_pos + 1, tlen, i_len, autowrap)) {
do_delete = TRUE;
- else
+ } else
do_delete = FALSE;
/* skip delete if it is continuous URL */
/* 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++;
}
dump_text(text, line_pos, tlen, 1);
#endif
/* move beginning of line if we are on LF */
- GET_CHAR(line_pos, cb, clen);
+ 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
#endif
/* force wrapping if it is one long word but not URL */
if (line_pos - p_pos <= i_len)
- if (!gtk_stext_is_uri_string
- (text, line_pos, tlen))
+ 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
- GET_CHAR(line_pos - 1, cbuf, clen);
+ 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 ||
- !gtk_stext_is_uri_string
- (text, line_pos, tlen)) {
- STEXT_FREEZE();
+ !gtkut_text_buffer_is_uri_string
+ (textbuf, line_pos, tlen)) {
/* workaround for correct cursor
position */
if (set_editable_pos == FALSE) {
- editable_pos = gtk_editable_get_position(GTK_EDITABLE(text));
+ 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_stext_set_point(text, line_pos);
- gtk_stext_backward_delete(text, 1);
+ 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--;
/* if it is URL at beginning of line don't wrap */
if (p_pos + i_len == line_pos &&
- gtk_stext_is_uri_string(text, line_pos, tlen)) {
+ gtkut_text_buffer_is_uri_string(textbuf, line_pos, tlen)) {
#ifdef WRAP_DEBUG
g_print("found URL at ");
dump_text(text, line_pos, tlen, 1);
}
/* insert CR */
- STEXT_FREEZE();
- gtk_stext_set_point(text, line_pos);
- gtk_stext_insert(text, NULL, NULL, NULL, "\n", 1);
- gtk_stext_compact_buffer(text);
+ 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 */
/* start over with current line */
is_new_line = TRUE;
line_len = cur_len = 0;
- if (autowrap || i_len > 0)
+ if (autowrap || i_len > 0) {
do_delete = TRUE;
- else
+ } else
do_delete = FALSE;
#ifdef WRAP_DEBUG
g_print("after CR insert ");
/* should we insert quotation ? */
if (linewrap_quote && i_len) {
/* only if line is not already quoted */
- if (!gtk_stext_str_compare
- (text, line_pos, tlen, qfmt)) {
+ 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
- (text, i_len, p_pos,
+ (textbuf, &iter, i_len, p_pos,
tlen, qfmt);
tlen += ins_len;
}
gtk_text_buffer_get_iter_at_offset(textbuf, &iter, editable_pos);
gtk_text_buffer_place_cursor(textbuf, &iter);
}
-#endif
}
#undef GET_CHAR
static void compose_select_account(Compose *compose, PrefsAccount *account,
gboolean init)
{
- GtkWidget *menuitem;
GtkItemFactory *ifactory;
g_return_if_fail(account != NULL);
gtk_table_set_row_spacing(GTK_TABLE(compose->table), 2, 4);
compose->use_newsgroups = TRUE;
- menuitem = gtk_item_factory_get_item(ifactory, "/View/To");
- gtk_check_menu_item_set_active
- (GTK_CHECK_MENU_ITEM(menuitem), FALSE);
- gtk_widget_set_sensitive(menuitem, TRUE);
- menuitem = gtk_item_factory_get_item(ifactory, "/View/Cc");
- gtk_check_menu_item_set_active
- (GTK_CHECK_MENU_ITEM(menuitem), FALSE);
- gtk_widget_set_sensitive(menuitem, TRUE);
-
+ menu_set_active(ifactory, "/View/To", FALSE);
+ menu_set_sensitive(ifactory, "/View/To", TRUE);
+ menu_set_active(ifactory, "/View/Cc", FALSE);
+ menu_set_sensitive(ifactory, "/View/Cc", TRUE);
menu_set_sensitive(ifactory, "/View/Followup to", TRUE);
} else {
gtk_widget_hide(compose->newsgroups_hbox);
gtk_widget_queue_resize(compose->table_vbox);
compose->use_newsgroups = FALSE;
- menuitem = gtk_item_factory_get_item(ifactory, "/View/To");
- gtk_check_menu_item_set_active
- (GTK_CHECK_MENU_ITEM(menuitem), TRUE);
- gtk_widget_set_sensitive(menuitem, FALSE);
- menuitem = gtk_item_factory_get_item(ifactory, "/View/Cc");
- gtk_check_menu_item_set_active
- (GTK_CHECK_MENU_ITEM(menuitem), TRUE);
- gtk_widget_set_sensitive(menuitem, FALSE);
-
- menuitem = gtk_item_factory_get_item(ifactory, "/View/Followup to");
- gtk_check_menu_item_set_active
- (GTK_CHECK_MENU_ITEM(menuitem), FALSE);
- gtk_widget_set_sensitive(menuitem, FALSE);
+ menu_set_active(ifactory, "/View/To", TRUE);
+ menu_set_sensitive(ifactory, "/View/To", FALSE);
+ menu_set_active(ifactory, "/View/Cc", TRUE);
+ menu_set_sensitive(ifactory, "/View/Cc", FALSE);
+ menu_set_active(ifactory, "/View/Followup to", FALSE);
+ menu_set_sensitive(ifactory, "/View/Followup to", FALSE);
}
if (account->set_autocc) {
COMPOSE_ENTRY_REPLY_TO);
}
- menuitem = gtk_item_factory_get_item(ifactory, "/View/Ruler");
- gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem),
- prefs_common.show_ruler);
#endif
#if USE_GPGME
- menuitem = gtk_item_factory_get_item(ifactory, "/Message/Sign");
- gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem),
- account->default_sign);
- menuitem = gtk_item_factory_get_item(ifactory, "/Message/Encrypt");
- gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem),
- account->default_encrypt);
+ if (account->default_sign)
+ menu_set_active(ifactory, "/Message/Sign", TRUE);
+ else
+ menu_set_active(ifactory, "/Message/Sign", FALSE);
+ if (account->default_encrypt)
+ menu_set_active(ifactory, "/Message/Encrypt", TRUE);
+ else
+ menu_set_active(ifactory, "/Message/Encrypt", FALSE);
activate_gnupg_mode(compose, account);
#endif /* USE_GPGME */
{
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 0;
- return val;
+bail:
+ compose_allow_user_actions (compose, TRUE);
+ compose->sending = FALSE;
+
+ return -1;
}
#if 0 /* compose restructure */
}
/* write to temporary file */
- g_snprintf(tmp, sizeof(tmp), "%s%ctmpmsg.%08x",
- get_tmp_dir(), G_DIR_SEPARATOR, (gint)compose);
+ g_snprintf(tmp, sizeof(tmp), "%s%ctmpmsg.%p",
+ get_tmp_dir(), G_DIR_SEPARATOR, compose);
if (prefs_common.linewrap_at_send)
compose_wrap_line_all(compose);
}
}
- /* queue message if failed to send */
- if (ok < 0) {
- if (prefs_common.queue_msg) {
- AlertValue val;
-
- val = alertpanel
- (_("Queueing"),
- _("Error occurred while sending the message.\n"
- "Put this message into queue folder?"),
- _("OK"), _("Cancel"), NULL);
- if (G_ALERTDEFAULT == val) {
- ok = compose_queue(compose, tmp);
- if (ok < 0)
- alertpanel_error(_("Can't queue the message."));
- }
- } else
- alertpanel_error_log(_("Error occurred while sending the message."));
- } else {
+ if (ok == 0) {
if (compose->mode == COMPOSE_REEDIT) {
compose_remove_reedit_target(compose);
}
/* Resent-Message-ID */
if (compose->account->gen_msgid) {
compose_generate_msgid(buf, sizeof(buf));
- fprintf(fp, "Resent-Message-Id: <%s>\n", buf);
+ fprintf(fp, "Resent-Message-ID: <%s>\n", buf);
compose->msgid = g_strdup(buf);
}
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
-#warning FIXME_GTK2
-#if 0 /* FIXME_GTK2 */
- src_codeset = conv_get_current_charset_str();
- /* if current encoding is US-ASCII, set it the same as
- outgoing one to prevent code conversion failure */
- if (!strcasecmp(src_codeset, CS_US_ASCII))
- src_codeset = out_codeset;
-#else /* FIXME_GTK2 */
src_codeset = CS_UTF_8;
-#endif /* FIXME_GTK2 */
debug_print("src encoding = %s, out encoding = %s, transfer encoding = %s\n",
src_codeset, out_codeset, procmime_get_encoding_str(encoding));
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);
gtk_text_buffer_get_end_iter(buffer, &end);
tmp = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
-#warning FIXME_GTK2
-#if 1 /* FIXME_GTK2 */
src_codeset = CS_UTF_8;
dest_codeset = conv_get_current_charset_str();
chars = conv_codeset_strdup(tmp, src_codeset, dest_codeset);
g_free(tmp);
if (!chars) return -1;
-#endif /* FIXME_GTK2 */
/* write body */
len = strlen(chars);
}
/* add queue header */
- tmp = g_strdup_printf("%s%cqueue.%d", g_get_tmp_dir(),
- G_DIR_SEPARATOR, (gint)compose);
+ tmp = g_strdup_printf("%s%cqueue.%p", get_tmp_dir(),
+ G_DIR_SEPARATOR, compose);
if ((fp = fopen(tmp, "wb")) == NULL) {
FILE_OP_ERROR(tmp, "fopen");
g_free(tmp);
if (!g_strcasecmp(trans_hdr, headerentryname)) {
const gchar *entstr = gtk_entry_get_text(GTK_ENTRY(headerentry->entry));
-#warning FIXME_GTK2
-#if 1
- gchar *tmpstr = conv_codeset_strdup(entstr, CS_UTF_8, conv_get_current_charset_str());
-#else
- gchar *tmpstr = strdup(entstr);
-#endif
- 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) {
/* Message-ID */
if (compose->account->gen_msgid) {
compose_generate_msgid(buf, sizeof(buf));
- fprintf(fp, "Message-Id: <%s>\n", buf);
+ fprintf(fp, "Message-ID: <%s>\n", buf);
compose->msgid = g_strdup(buf);
}
#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;
-#warning FIXME_GTK2
-#if 1
- tmpstr = conv_codeset_strdup(src, CS_UTF_8, conv_get_current_charset_str());
-#else
- tmpstr = strdup(src);
-#endif
+ 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();
gtk_widget_show(entry);
gtk_table_attach(GTK_TABLE(compose->header_table), entry, 1, 2, compose->header_nextrow, compose->header_nextrow+1, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
- gtk_signal_connect(GTK_OBJECT(entry), "key-press-event", GTK_SIGNAL_FUNC(compose_headerentry_key_press_event_cb), headerentry);
- gtk_signal_connect(GTK_OBJECT(entry), "changed", GTK_SIGNAL_FUNC(compose_headerentry_changed_cb), headerentry);
- gtk_signal_connect(GTK_OBJECT(entry), "activate", GTK_SIGNAL_FUNC(text_activated), compose);
+ g_signal_connect(G_OBJECT(entry), "key-press-event",
+ G_CALLBACK(compose_headerentry_key_press_event_cb),
+ headerentry);
+ g_signal_connect(G_OBJECT(entry), "changed",
+ G_CALLBACK(compose_headerentry_changed_cb),
+ headerentry);
+ 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);
- gtk_signal_connect(GTK_OBJECT(entry), "button-press-event",
- GTK_SIGNAL_FUNC(compose_headerentry_button_pressed),
- NULL);
+ g_signal_connect(G_OBJECT(entry), "button-press-event",
+ G_CALLBACK(compose_headerentry_button_pressed),
+ NULL);
address_completion_register_entry(GTK_ENTRY(entry));
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);
if (account_get_special_folder(compose->account, F_OUTBOX)) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(savemsg_checkbtn), prefs_common.savemsg);
}
- gtk_signal_connect(GTK_OBJECT(savemsg_checkbtn), "toggled",
- GTK_SIGNAL_FUNC(compose_savemsg_checkbtn_cb), compose);
+ g_signal_connect(G_OBJECT(savemsg_checkbtn), "toggled",
+ G_CALLBACK(compose_savemsg_checkbtn_cb), compose);
savemsg_entry = gtk_entry_new();
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)) {
folderidentifier = folder_item_get_identifier(account_get_special_folder
}
savemsg_select = gtk_button_new_with_label (_("Select ..."));
- gtk_widget_show (savemsg_select);
+ gtk_widget_show(savemsg_select);
gtk_table_attach(GTK_TABLE(table), savemsg_select, 2, 3, rowcount, rowcount + 1, GTK_SHRINK | GTK_FILL, GTK_SHRINK, 0, 0);
- gtk_signal_connect (GTK_OBJECT (savemsg_select), "clicked",
- GTK_SIGNAL_FUNC (compose_savemsg_select_cb),
- compose);
+ g_signal_connect(G_OBJECT(savemsg_select), "clicked",
+ G_CALLBACK(compose_savemsg_select_cb),
+ compose);
rowcount++;
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();
subject_entry = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(subject), subject_entry, TRUE, TRUE, 2);
- gtk_signal_connect(GTK_OBJECT(subject_entry), "activate", GTK_SIGNAL_FUNC(text_activated), compose);
+ 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);
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);
-#warning FIXME_GTK2
- /* GTK_STEXT(text)->default_tab_width = 8; */
-
-#warning FIXME_GTK2
-#if 0
- if (prefs_common.block_cursor) {
- GTK_STEXT(text)->cursor_type = GTK_STEXT_CURSOR_BLOCK;
- }
-#endif
-#warning FIXME_GTK2
-#if 0
- if (prefs_common.smart_wrapping) {
- gtk_stext_set_word_wrap(GTK_STEXT(text), TRUE);
- gtk_stext_set_wrap_rmargin(GTK_STEXT(text), prefs_common.linewrap_len);
- }
-#else
- if (prefs_common.smart_wrapping) {
- gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(text), GTK_WRAP_WORD);
- }
-#endif
-
gtk_container_add(GTK_CONTAINER(scrolledwin), text);
-#warning FIXME_GTK2
-#if 0 /* FIXME_GTK2 */
- g_signal_connect(G_OBJECT(text), "activate",
- G_CALLBACK(text_activated), compose);
-#endif /* FIXME_GTK2 */
-
g_signal_connect_after(G_OBJECT(text), "size_allocate",
G_CALLBACK(compose_edit_size_alloc),
ruler);
style = gtk_widget_get_style(text);
- /* workaround for the slow down of GtkSText when using Pixmap theme */
-#warning FIXME_GTK2
-#if 0 /* FIXME_GTK2 */
- if (style->engine) {
- GtkThemeEngine *engine;
-
- engine = style->engine;
- style->engine = NULL;
- new_style = gtk_style_copy(style);
- style->engine = engine;
- } else
-#endif /* FIXME_GTK2 */
- new_style = gtk_style_copy(style);
+ new_style = gtk_style_copy(style);
if (prefs_common.textfont) {
PangoFontDescription *font_desc;
compose->msgid = NULL;
compose->boundary = NULL;
+ compose->autowrap = prefs_common.autowrap;
+
#if USE_GPGME
compose->use_signing = FALSE;
compose->use_encryption = FALSE;
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"),
compose_select_account(compose, account, TRUE);
+ menu_set_active(ifactory, "/Edit/Auto wrapping", prefs_common.autowrap);
+ menu_set_active(ifactory, "/View/Ruler", prefs_common.show_ruler);
if (account->set_autocc && account->auto_cc && mode != COMPOSE_REEDIT)
compose_entry_append(compose, account->auto_cc, COMPOSE_CC);
pid_t pid;
gint pipe_fds[2];
- tmp = g_strdup_printf("%s%ctmpmsg.%08x", get_tmp_dir(),
- G_DIR_SEPARATOR, (gint)compose);
+ tmp = g_strdup_printf("%s%ctmpmsg.%p", get_tmp_dir(),
+ G_DIR_SEPARATOR, compose);
if (pipe(pipe_fds) < 0) {
perror("pipe");
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);
if (account_get_special_folder(compose->account, F_OUTBOX)) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(compose->savemsg_checkbtn), prefs_common.savemsg);
}
- gtk_signal_connect(GTK_OBJECT(compose->savemsg_checkbtn), "toggled",
- GTK_SIGNAL_FUNC(compose_savemsg_checkbtn_cb), compose);
+ g_signal_connect(G_OBJECT(compose->savemsg_checkbtn), "toggled",
+ G_CALLBACK(compose_savemsg_checkbtn_cb), compose);
gtk_editable_delete_text(GTK_EDITABLE(compose->savemsg_entry), 0, -1);
if (account_get_special_folder(compose->account, F_OUTBOX)) {
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,
lock = TRUE;
- tmp = g_strdup_printf("%s%cdraft.%08x", get_tmp_dir(),
- G_DIR_SEPARATOR, (gint)compose);
+ tmp = g_strdup_printf("%s%cdraft.%p", get_tmp_dir(),
+ G_DIR_SEPARATOR, compose);
if (compose_write_to_file(compose, tmp, TRUE) < 0) {
g_free(tmp);
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"), NULL);
+ 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"), NULL);
+ 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) {
* after the gtk_editable_paste_clipboard) know that
* text is to be inserted as a quotation. implemented
* by using a simple refcount... */
- gint paste_as_quotation = GPOINTER_TO_INT(gtk_object_get_data(
- GTK_OBJECT(compose->focused_editable),
+ gint paste_as_quotation = GPOINTER_TO_INT(g_object_get_data(
+ G_OBJECT(compose->focused_editable),
"paste_as_quotation"));
- gtk_object_set_data(GTK_OBJECT(compose->focused_editable),
+ 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);
}
}
-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)
}
}
+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);
+}
+
#if 0 /* NEW COMPOSE GUI */
static void compose_toggle_to_cb(gpointer data, guint action,
GtkWidget *widget)
/* Override default next focus, and give it to subject_entry
* instead of notebook tabs
*/
- gtk_signal_emit_stop_by_name(GTK_OBJECT(entry), "key-press-event");
+ g_signal_stop_emission_by_name(G_OBJECT(entry), "key-press-event");
gtk_widget_grab_focus(headerentry->compose->subject_entry);
return TRUE;
}
headerentry);
compose_create_header_entry(headerentry->compose);
- gtk_signal_disconnect_by_data
- (GTK_OBJECT(entry), headerentry);
+ g_signal_handlers_disconnect_matched
+ (G_OBJECT(entry), G_SIGNAL_MATCH_DATA,
+ 0, 0, NULL, NULL, headerentry);
/* Automatically scroll down */
compose_show_first_last_header(headerentry->compose, FALSE);
projects / claws.git / blobdiff