/*
* Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
- * Copyright (C) 1999-2004 Hiroyuki Yamamoto
+ * Copyright (C) 1999-2005 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 "defs.h"
+#ifndef PANGO_ENABLE_ENGINE
+# define PANGO_ENABLE_ENGINE
+#endif
+
#include <glib.h>
+#include <glib/gi18n.h>
#include <gdk/gdkkeysyms.h>
#include <gtk/gtkmain.h>
#include <gtk/gtkmenu.h>
#include <gtk/gtkcheckmenuitem.h>
#include <gtk/gtkoptionmenu.h>
#include <gtk/gtkwidget.h>
-#include <gtk/gtkclist.h>
-#include <gtk/gtkctree.h>
#include <gtk/gtkvpaned.h>
#include <gtk/gtkentry.h>
#include <gtk/gtkeditable.h>
#include <gtk/gtklabel.h>
#include <gtk/gtkscrolledwindow.h>
#include <gtk/gtktreeview.h>
+#include <gtk/gtkliststore.h>
+#include <gtk/gtktreeselection.h>
+#include <gtk/gtktreemodel.h>
#include <gtk/gtkdnd.h>
+#include <gtk/gtkclipboard.h>
+#include <pango/pango-break.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
# include <wctype.h>
#endif
-#include "intl.h"
#include "main.h"
#include "mainwindow.h"
#include "compose.h"
#include "foldersel.h"
#include "toolbar.h"
-typedef enum
+enum
{
COL_MIMETYPE = 0,
COL_SIZE = 1,
- COL_NAME = 2
-} AttachColumnPos;
+ COL_NAME = 2,
+ COL_DATA = 3,
+ COL_AUTODATA = 4,
+ N_COL_COLUMNS
+};
-#define N_ATTACH_COLS 3
+#define N_ATTACH_COLS (N_COL_COLUMNS)
typedef enum
{
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,
gboolean addr_field);
-static void compose_generate_msgid (gchar *buf,
- gint len);
static void compose_attach_info_free (AttachInfo *ainfo);
static void compose_attach_remove_selected (Compose *compose);
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);
GtkSHRuler *shruler);
static void account_activated (GtkMenuItem *menuitem,
gpointer data);
-static void attach_selected (GtkCList *clist,
- gint row,
- gint column,
- GdkEvent *event,
- gpointer data);
+static void attach_selected (GtkTreeView *tree_view,
+ GtkTreePath *tree_path,
+ GtkTreeViewColumn *column,
+ Compose *compose);
static gboolean attach_button_pressed (GtkWidget *widget,
GdkEventButton *event,
gpointer data);
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_advanced_action_cb (Compose *compose,
ComposeCallAdvancedAction action);
-static gboolean compose_grab_focus_cb (GtkWidget *widget,
- Compose *compose);
-static gboolean compose_grab_focus_before_cb (GtkWidget *widget,
+static void compose_grab_focus_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);
static void compose_toggle_encrypt_cb (gpointer data,
guint action,
GtkWidget *widget);
-static void compose_set_privacy_system_cb(gpointer data,
- guint action,
- 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 activate_privacy_system (Compose *compose,
PrefsAccount *account);
guint info,
guint time,
gpointer user_data);
+static void compose_header_drag_received_cb (GtkWidget *widget,
+ GdkDragContext *drag_context,
+ gint x,
+ gint y,
+ GtkSelectionData *data,
+ guint info,
+ guint time,
+ gpointer user_data);
+static gboolean compose_drag_drop (GtkWidget *widget,
+ GdkDragContext *drag_context,
+ gint x, gint y,
+ guint time, gpointer user_data);
#if 0
static void to_activated (GtkWidget *widget,
Compose *compose);
Compose *compose);
#endif
-static void text_activated (GtkWidget *widget,
- Compose *compose);
static void text_inserted (GtkTextBuffer *buffer,
GtkTextIter *iter,
const gchar *text,
static void compose_check_forwards_go (Compose *compose);
#endif
-static gboolean compose_send_control_enter (Compose *compose);
static gint compose_defer_auto_save_draft (Compose *compose);
static PrefsAccount *compose_guess_forward_account_from_msginfo (MsgInfo *msginfo);
+static void compose_close (Compose *compose);
+
static GtkItemFactoryEntry compose_popup_entries[] =
{
{N_("/_Add..."), NULL, compose_attach_cb, 0, NULL},
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"),
NULL, NULL, 0, "<Branch>"},
#endif
{N_("/_Options"), NULL, NULL, 0, "<Branch>"},
- {N_("/_Options/---"), NULL, NULL, 0, "<Separator>"},
{N_("/_Options/Privacy System"), NULL, NULL, 0, "<Branch>"},
- {N_("/_Options/Privacy System/None"), NULL, compose_set_privacy_system_cb, 0, "<RadioItem>"},
+ {N_("/_Options/Privacy System/None"), NULL, NULL, 0, "<RadioItem>"},
{N_("/_Options/Si_gn"), NULL, compose_toggle_sign_cb , 0, "<ToggleItem>"},
{N_("/_Options/_Encrypt"), NULL, compose_toggle_encrypt_cb, 0, "<ToggleItem>"},
{N_("/_Options/---"), NULL, NULL, 0, "<Separator>"},
{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},
static GtkTargetEntry compose_mime_types[] =
{
- {"text/uri-list", 0, 0}
+ {"text/uri-list", 0, 0},
+ {"text/plain", 0, 0},
+ {"STRING", 0, 0}
};
+static gboolean compose_put_existing_to_front(MsgInfo *info)
+{
+ GList *compose_list = compose_get_compose_list();
+ GList *elem = NULL;
+
+ if (compose_list) {
+ for (elem = compose_list; elem != NULL && elem->data != NULL;
+ elem = elem->next) {
+ Compose *c = (Compose*)elem->data;
+
+ if (!c->targetinfo || !c->targetinfo->msgid ||
+ !info->msgid)
+ continue;
+
+ if (!strcmp(c->targetinfo->msgid, info->msgid)) {
+ gtkut_window_popup(c->window);
+ return TRUE;
+ }
+ }
+ }
+ return FALSE;
+}
+
Compose *compose_new(PrefsAccount *account, const gchar *mailto,
GPtrArray *attach_files)
{
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)
-{
- Compose *compose;
-
- 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);
-
- return compose;
-}
-*/
-
void compose_reply_mode(ComposeMode mode, GSList *msginfo_list, gchar *body)
{
MsgInfo *msginfo;
compose = compose_create(account, COMPOSE_REPLY);
ifactory = gtk_item_factory_from_widget(compose->menubar);
- menu_set_active(ifactory, "/Message/Remove references", FALSE);
- menu_set_sensitive(ifactory, "/Message/Remove references", TRUE);
+ menu_set_active(ifactory, "/Options/Remove references", FALSE);
+ menu_set_sensitive(ifactory, "/Options/Remove references", TRUE);
compose->replyinfo = procmsg_msginfo_get_full_info(msginfo);
if (!compose->replyinfo)
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) {
if (account->auto_sig)
compose_insert_sig(compose, FALSE);
- if (quote && prefs_common.linewrap_quote)
- compose_wrap_line_all(compose);
-
cursor_pos = quote_fmt_get_cursor_pos();
gtk_text_buffer_get_start_iter(textbuf, &iter);
gtk_text_buffer_get_iter_at_offset(textbuf, &iter, cursor_pos);
gtk_text_buffer_place_cursor(textbuf, &iter);
-
- if (quote && prefs_common.linewrap_quote) {
- compose_wrap_line_all(compose);
- gtk_text_view_set_editable(GTK_TEXT_VIEW(compose->text), TRUE);
- }
+
+ if (quote && prefs_common.linewrap_quote)
+ 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_return_if_fail(msginfo != NULL);
g_return_if_fail(msginfo->folder != NULL);
+ if (compose_put_existing_to_front(msginfo))
+ return;
+
if (msginfo->folder->stype == F_QUEUE || msginfo->folder->stype == F_DRAFT) {
gchar queueheader_buf[BUFFSIZE];
gint id, param;
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 {
+ 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);
}
gtk_widget_grab_focus(compose->header_last->entry);
- filename = procmsg_get_message_file(msginfo);
+ filename = procmsg_get_message_file_path(msginfo);
if (filename == NULL)
return NULL;
gtk_editable_set_editable(GTK_EDITABLE(compose->subject_entry), FALSE);
compose_quote_fmt(compose, msginfo, "%M", NULL, NULL);
- gtk_text_view_set_editable(GTK_TEXT_VIEW(compose->text), TRUE);
+ gtk_text_view_set_editable(GTK_TEXT_VIEW(compose->text), FALSE);
ifactory = gtk_item_factory_from_widget(compose->popupmenu);
menu_set_sensitive(ifactory, "/Add...", FALSE);
menu_set_sensitive(ifactory, "/Remove", FALSE);
- menu_set_sensitive(ifactory, "/Property...", FALSE);
+ menu_set_sensitive(ifactory, "/Properties...", FALSE);
ifactory = gtk_item_factory_from_widget(compose->menubar);
menu_set_sensitive(ifactory, "/Message/Save", FALSE);
menu_set_sensitive(ifactory, "/Message/Attach file", FALSE);
menu_set_sensitive(ifactory, "/Message/Insert signature", FALSE);
menu_set_sensitive(ifactory, "/Edit", FALSE);
- menu_set_sensitive(ifactory, "/Options/Sign", FALSE);
- menu_set_sensitive(ifactory, "/Options/Encrypt", FALSE);
- menu_set_sensitive(ifactory, "/Options/Priority", FALSE);
- menu_set_sensitive(ifactory, "/Options/Request Return Receipt", FALSE);
+ menu_set_sensitive(ifactory, "/Options", FALSE);
menu_set_sensitive(ifactory, "/Tools/Show ruler", FALSE);
menu_set_sensitive(ifactory, "/Tools/Actions", FALSE);
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)
for (h_list = compose->header_list; h_list != NULL; h_list = h_list->next) {
entry = GTK_ENTRY(((ComposeHeaderEntry *)h_list->data)->entry);
if (gtk_entry_get_text(entry) &&
- !g_strcasecmp(gtk_entry_get_text(entry), mailto)) {
+ !g_utf8_collate(gtk_entry_get_text(entry), mailto)) {
gtk_widget_ensure_style(GTK_WIDGET(entry));
if (!bold_style) {
PangoFontDescription *font_desc = NULL;
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)
- gtk_entry_set_text(GTK_ENTRY(compose->subject_entry), 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);
+ g_free(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);
+ if (!g_utf8_validate (body, -1, NULL)) {
+ temp = g_locale_to_utf8 (body, -1, NULL, &len, NULL);
+ gtk_text_buffer_insert(buffer, &iter, temp, -1);
+ g_free(temp);
+ } else {
+ 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);
}
}
for (cur = ref_id_list; cur != NULL; cur = cur->next) {
if (new_ref->len > 0)
g_string_append(new_ref, "\n\t");
- g_string_sprintfa(new_ref, "<%s>", (gchar *)cur->data);
+ g_string_append_printf(new_ref, "<%s>", (gchar *)cur->data);
}
slist_free_strings(ref_id_list);
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)
GtkTextBuffer *buffer;
GtkTextMark *mark;
GtkTextIter iter;
+ const gchar *cur_encoding;
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_CALLBACK(text_inserted),
compose);
+ cur_encoding = conv_get_locale_charset_str();
+
while (fgets(buf, sizeof(buf), fp) != NULL) {
- const gchar *cur_encoding = conv_get_current_charset_str();
- gchar *str = NULL;
- if (!g_utf8_validate(buf, -1, NULL))
- str = conv_codeset_strdup(buf, cur_encoding, CS_UTF_8);
- else
- str = g_strdup(buf);
+ gchar *str;
+ str = conv_codeset_strdup(buf, cur_encoding, CS_INTERNAL);
if (!str) continue;
/* strip <CR> if DOS/Windows file,
while (--len >= 0)
if (str[len] == '\r') str[len] = '\n';
}
- gtk_text_buffer_insert(buffer, &iter, str, -1);
- g_free (str);
+ gtk_text_buffer_insert(buffer, &iter, str, -1);
+ g_free(str);
}
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);
const gchar *content_type)
{
AttachInfo *ainfo;
- gchar *text[N_ATTACH_COLS];
+ GtkTreeIter iter;
FILE *fp;
off_t size;
- gint row;
+ GAuto *auto_ainfo;
+ gchar *size_text;
+ GtkListStore *store;
+ 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);
}
#endif
ainfo = g_new0(AttachInfo, 1);
+ auto_ainfo = g_auto_pointer_new_with_free
+ (ainfo, (GFreeFunc) compose_attach_info_free);
ainfo->file = g_strdup(file);
if (content_type) {
ainfo->content_type = g_strdup(content_type);
- if (!strcasecmp(content_type, "message/rfc822")) {
+ if (!g_ascii_strcasecmp(content_type, "message/rfc822")) {
MsgInfo *msginfo;
MsgFlags flags = {0, 0};
- const gchar *name;
- if (procmime_get_encoding_for_file(file) == ENC_7BIT)
+ if (procmime_get_encoding_for_text_file(file) == ENC_7BIT)
ainfo->encoding = ENC_7BIT;
else
ainfo->encoding = ENC_8BIT;
msginfo = procheader_parse_file(file, flags, FALSE, FALSE);
if (msginfo && msginfo->subject)
- name = msginfo->subject;
+ name = g_strdup(msginfo->subject);
else
- name = g_basename(filename ? filename : file);
+ name = g_path_get_basename(filename ? filename : file);
ainfo->name = g_strdup_printf(_("Message: %s"), name);
procmsg_msginfo_free(msginfo);
} else {
- if (!g_strncasecmp(content_type, "text", 4))
- ainfo->encoding =
- procmime_get_encoding_for_file(file);
+ if (!g_ascii_strncasecmp(content_type, "text", 4))
+ ainfo->encoding = procmime_get_encoding_for_text_file(file);
else
ainfo->encoding = ENC_BASE64;
- ainfo->name = g_strdup
- (g_basename(filename ? filename : file));
+ name = g_path_get_basename(filename ? filename : file);
+ ainfo->name = g_strdup(name);
}
+ g_free(name);
} else {
ainfo->content_type = procmime_get_mime_type(file);
if (!ainfo->content_type) {
ainfo->content_type =
g_strdup("application/octet-stream");
ainfo->encoding = ENC_BASE64;
- } else if (!g_strncasecmp(ainfo->content_type, "text", 4))
- ainfo->encoding = procmime_get_encoding_for_file(file);
+ } else if (!g_ascii_strncasecmp(ainfo->content_type, "text", 4))
+ ainfo->encoding =
+ procmime_get_encoding_for_text_file(file);
else
ainfo->encoding = ENC_BASE64;
- ainfo->name = g_strdup(g_basename(filename ? filename : file));
+ name = g_path_get_basename(filename ? filename : file);
+ ainfo->name = g_strdup(name);
+ g_free(name);
}
- ainfo->size = size;
- text[COL_MIMETYPE] = ainfo->content_type;
- text[COL_SIZE] = to_human_readable(size);
- text[COL_NAME] = ainfo->name;
+ if (!strcmp(ainfo->content_type, "unknown")) {
+ g_free(ainfo->content_type);
+ ainfo->content_type = g_strdup("application/octet-stream");
+ }
+
+ ainfo->size = size;
+ size_text = to_human_readable(size);
- row = gtk_clist_append(GTK_CLIST(compose->attach_clist), text);
- gtk_clist_set_row_data(GTK_CLIST(compose->attach_clist), row, ainfo);
+ store = GTK_LIST_STORE(gtk_tree_view_get_model
+ (GTK_TREE_VIEW(compose->attach_clist)));
+
+ gtk_list_store_append(store, &iter);
+ gtk_list_store_set(store, &iter,
+ COL_MIMETYPE, ainfo->content_type,
+ COL_SIZE, size_text,
+ COL_NAME, ainfo->name,
+ COL_DATA, ainfo,
+ COL_AUTODATA, auto_ainfo,
+ -1);
+
+ g_auto_pointer_free(auto_ainfo);
}
static void compose_use_signing(Compose *compose, gboolean use_signing)
debug_print("First text part found\n");
} else if (compose->mode == COMPOSE_REEDIT &&
child->type == MIMETYPE_APPLICATION &&
- !strcasecmp(child->subtype, "pgp-encrypted")) {
+ !g_ascii_strcasecmp(child->subtype, "pgp-encrypted")) {
AlertValue val;
val = alertpanel(_("Encrypted message"),
_("Cannot re-edit an encrypted message. \n"
procmime_mimeinfo_free_all(mimeinfo);
}
-
-#define CHAR_BUF_SIZE 8
#undef NEXT_PART_NOT_CHILD
-#define GET_CHAR(iter_p, buf, len) \
-{ \
- GtkTextIter end_iter; \
- gchar *tmp; \
- end_iter = *iter_p; \
- gtk_text_iter_forward_char(&end_iter); \
- tmp = gtk_text_buffer_get_text(textbuf, iter_p, &end_iter, FALSE); \
- if (tmp) { \
- glong items_read, items_witten; \
- GError *error = NULL; \
- gunichar *wide_char; \
- strncpy2(buf, tmp, CHAR_BUF_SIZE); \
- wide_char = g_utf8_to_ucs4(tmp, -1, \
- &items_read, &items_witten, \
- &error); \
- if (error != NULL) { \
- g_warning("%s\n", error->message); \
- g_error_free(error); \
- } \
- len = wide_char && g_unichar_iswide(*wide_char) ? 2 : 1; \
- g_free(wide_char); \
- } else { \
- buf[0] = '\0'; \
- len = 1; \
- } \
- g_free(tmp); \
-}
-
-#define DISP_WIDTH(len) \
- ((len > 2 && conv_get_current_charset() == C_UTF_8) ? 2 : \
- (len == 2 && conv_get_current_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);
-
- /* 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 */
- line_end = FALSE;
- }
- }
- p_end = gtk_text_iter_get_offset(&iter);
- if (p_end >= text_len)
- p_end = text_len;
+typedef enum {
+ WAIT_FOR_INDENT_CHAR,
+ WAIT_FOR_INDENT_CHAR_OR_SPACE,
+} IndentState;
- if (p_start >= p_end)
- return;
+/* 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_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;
+ if (prefs_common.quote_chars == NULL) {
+ return 0 ;
+ }
- gtk_text_buffer_get_iter_at_offset(textbuf, &iter, cur_pos);
+ 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;
- GET_CHAR(&iter, cbuf, ch_len);
+ is_indent = strchr(prefs_common.quote_chars, ch[0]) ? TRUE : FALSE;
+ is_space = g_unichar_isspace(wc);
- if (ch_len < 0) {
- cbuf[0] = '\0';
- ch_len = 1;
+ 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;
+ }
}
- if (ch_len == 1 && isspace(*(guchar *)cbuf))
- space = 1;
+ gtk_text_iter_forward_char(&iter);
+ }
- if (ch_len == 1 && *cbuf == '\n') {
- gboolean replace = FALSE;
- GtkTextIter next_iter = iter;
+ if (quote_len > 0 && space_count > 0)
+ quote_len++;
- gtk_text_iter_forward_char(&next_iter);
+ if (len)
+ *len = quote_len;
- 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 (quote_len > 0) {
+ iter = *start;
+ gtk_text_iter_forward_chars(&iter, quote_len);
+ return gtk_text_buffer_get_text(buffer, start, &iter, FALSE);
+ }
- last_ch_len = ch_len;
- last_ch = *cbuf;
+ return NULL;
+}
- if (space) {
- line_pos = cur_pos + 1;
- line_len = cur_len + ch_len;
- }
+/* return TRUE if the line is itemized */
+static gboolean compose_is_itemized(GtkTextBuffer *buffer,
+ const GtkTextIter *start)
+{
+ GtkTextIter iter = *start;
+ gunichar wc;
+ gchar ch[6];
+ gint clen;
- gtk_text_buffer_get_iter_at_offset(textbuf, &iter, line_pos);
+ if (gtk_text_iter_ends_line(&iter))
+ return FALSE;
- if (cur_len + ch_len > prefs_common.linewrap_len &&
- line_len > 0) {
- gint tlen = ch_len;
- GtkTextIter prev_iter = iter;
+ while (1) {
+ wc = gtk_text_iter_get_char(&iter);
+ if (!g_unichar_isspace(wc))
+ break;
+ gtk_text_iter_forward_char(&iter);
+ if (gtk_text_iter_ends_line(&iter))
+ return FALSE;
+ }
- gtk_text_iter_backward_char(&prev_iter);
+ clen = g_unichar_to_utf8(wc, ch);
+ if (clen != 1)
+ return FALSE;
- 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 (!strchr("*-+", ch[0]))
+ return FALSE;
- if (ch_len > 1) {
- line_pos = cur_pos + 1;
- line_len = cur_len + ch_len;
- }
- cur_len += ch_len;
- }
+ 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;
+
+ return FALSE;
}
-#undef WRAP_DEBUG
-#ifdef WRAP_DEBUG
-/* Darko: used when I debug wrapping */
-void dump_text(GtkTextBuffer textbuf, int pos, int tlen, int breakoncr)
+static gboolean compose_get_line_break_pos(GtkTextBuffer *buffer,
+ const GtkTextIter *start,
+ GtkTextIter *break_pos,
+ gint max_col,
+ gint quote_len)
{
- gint i, 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')
- break;
- fwrite(cbuf, clen, 1, stdout);
- }
- printf("]\n");
-}
-#endif
+ 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;
-typedef enum {
- WAIT_FOR_SPACE,
- WAIT_FOR_INDENT_CHAR,
- WAIT_FOR_INDENT_CHAR_OR_SPACE
-} IndentState;
+ 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);
-/* 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)
-{
- guint i_len = 0;
- guint i, ch_len, alnum_cnt = 0;
- IndentState state = WAIT_FOR_INDENT_CHAR;
- gchar cbuf[CHAR_BUF_SIZE];
- gboolean is_space;
- gboolean is_indent;
+ pango_default_break(str, -1, NULL, attrs, len + 1);
- if (prefs_common.quote_chars == NULL) {
- return 0 ;
- }
+ p = str;
- for (i = start_pos; i < text_len; i++) {
- GtkTextIter iter;
+ /* skip quote and leading spaces */
+ for (i = 0; *p != '\0' && i < len; i++) {
+ gunichar wc;
- gtk_text_buffer_get_iter_at_offset(textbuf, &iter, i);
- GET_CHAR(&iter, cbuf, ch_len);
- if (ch_len > 1)
+ 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++;
+ p = g_utf8_next_char(p);
+ can_break = TRUE;
}
-out:
- if ((i_len > 0) && (state == WAIT_FOR_INDENT_CHAR))
- i_len -= alnum_cnt;
-
- 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;
+ debug_print("compose_get_line_break_pos(): do_break = %d, pos = %d, col = %d\n", do_break, pos, col);
- 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 = TRUE;
- 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(text, 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(text, p_pos, tlen, 1);
- dump_text(text, 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(text, 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(text, line_pos, tlen, 1);
- dump_text(text, 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(text, 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;
+}
+
+static void compose_wrap_all(Compose *compose)
+{
+ compose_wrap_all_full(compose, FALSE);
}
-#undef GET_CHAR
-#undef CHAR_BUF_SIZE
+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)
{
#endif
- if (account->default_sign)
+ if (account->default_sign && compose->mode != COMPOSE_REDIRECT)
menu_set_active(ifactory, "/Options/Sign", TRUE);
else
menu_set_active(ifactory, "/Options/Sign", FALSE);
- if (account->default_encrypt)
+ if (account->default_encrypt && compose->mode != COMPOSE_REDIRECT)
menu_set_active(ifactory, "/Options/Encrypt", TRUE);
else
menu_set_active(ifactory, "/Options/Encrypt", FALSE);
aval = alertpanel(_("Send"),
_("Subject is empty. Send it anyway?"),
- _("Yes"), _("No"), NULL);
+ GTK_STOCK_YES, GTK_STOCK_NO, NULL);
if (aval != G_ALERTDEFAULT)
return FALSE;
}
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;
}
if (prefs_common.send_dialog_mode != SEND_DIALOG_ALWAYS) {
compose->sending = FALSE;
- gtk_widget_destroy(compose->window);
+ compose_close(compose);
/* No more compose access in the normal codepath
* after this point! */
+ compose = NULL;
}
if (msgnum == 0) {
folder_item_remove_msg(folder, msgnum);
folder_item_scan(folder);
if (prefs_common.send_dialog_mode == SEND_DIALOG_ALWAYS)
- gtk_widget_destroy(compose->window);
- }
+ compose_close(compose);
+ } else {
+ alertpanel_error(_("The message was queued but could not be "
+ "sent.\nUse \"Send queued messages\" from "
+ "the main window to retry."));
+ if (prefs_common.send_dialog_mode == SEND_DIALOG_ALWAYS) {
+ compose_allow_user_actions (compose, TRUE);
+ compose->sending = FALSE;
+ }
+ return -1;
+ }
return 0;
static gboolean compose_use_attach(Compose *compose)
{
- return gtk_clist_get_row_data(GTK_CLIST(compose->attach_clist), 0) != NULL;
+ GtkTreeModel *model = gtk_tree_view_get_model
+ (GTK_TREE_VIEW(compose->attach_clist));
+ return gtk_tree_model_iter_n_children(model, NULL) > 0;
}
static gint compose_redirect_write_headers_from_headerlist(Compose *compose,
cc_hdr = prefs_common.trans_hdr ? _("Cc:") : "Cc:";
to_hdr = prefs_common.trans_hdr ? _("To:") : "To:";
- first_to_address = TRUE;
+ first_to_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, 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
+ (compose, buf, sizeof(buf), str,
+ strlen("Resent-To") + 2, TRUE);
+
+ if (first_to_address) {
+ fprintf(fp, "Resent-To: ");
+ first_to_address = FALSE;
+ } else {
+ fprintf(fp, ",");
+ }
+ fprintf(fp, "%s", buf);
+ }
+ }
+ }
+ 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_strcasecmp(headerentryname, cc_hdr) == 0
- || g_strcasecmp(headerentryname, to_hdr) == 0) {
- const gchar *entstr = gtk_entry_get_text(GTK_ENTRY(headerentry->entry));
- Xstrdup_a(str, entstr, return -1);
+ 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
- (buf, sizeof(buf), str,
- strlen("Resent-To") + 2, TRUE);
- if (g_strcasecmp(headerentryname, to_hdr) == 0) {
- if (first_to_address) {
- fprintf(fp, "Resent-To: ");
- first_to_address = FALSE;
- } else {
- fprintf(fp, ",");
- }
- }
- if (g_strcasecmp(headerentryname, cc_hdr) == 0) {
- if (first_cc_address) {
- fprintf(fp, "\n");
- fprintf(fp, "Resent-Cc: ");
- first_cc_address = FALSE;
- } else {
- fprintf(fp, ",");
- }
- }
-
+ (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_address) { */
- fprintf(fp, "\n");
- /* } */
-
+ 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);
}
/* Resent-Message-ID */
if (compose->account->gen_msgid) {
- compose_generate_msgid(buf, sizeof(buf));
+ generate_msgid(buf, sizeof(buf));
fprintf(fp, "Resent-Message-ID: <%s>\n", buf);
compose->msgid = g_strdup(buf);
}
while (procheader_get_one_field_asis(buf, sizeof(buf), fp) != -1) {
/* should filter returnpath, delivered-to */
- if (g_strncasecmp(buf, "Return-Path:",
- strlen("Return-Path:")) == 0 ||
- g_strncasecmp(buf, "Delivered-To:",
- strlen("Delivered-To:")) == 0 ||
- g_strncasecmp(buf, "Received:",
- strlen("Received:")) == 0 ||
- g_strncasecmp(buf, "Subject:",
- strlen("Subject:")) == 0 ||
- g_strncasecmp(buf, "X-UIDL:",
- strlen("X-UIDL:")) == 0)
+ if (g_ascii_strncasecmp(buf, "Return-Path:",
+ strlen("Return-Path:")) == 0 ||
+ g_ascii_strncasecmp(buf, "Delivered-To:",
+ strlen("Delivered-To:")) == 0 ||
+ g_ascii_strncasecmp(buf, "Received:",
+ strlen("Received:")) == 0 ||
+ g_ascii_strncasecmp(buf, "Subject:",
+ strlen("Subject:")) == 0 ||
+ g_ascii_strncasecmp(buf, "X-UIDL:",
+ strlen("X-UIDL:")) == 0)
continue;
if (fputs(buf, fdest) == -1)
goto error;
if (!prefs_common.redirect_keep_from) {
- if (g_strncasecmp(buf, "From:",
+ if (g_ascii_strncasecmp(buf, "From:",
strlen("From:")) == 0) {
fputs(" (by way of ", fdest);
if (compose->account->name
&& *compose->account->name) {
compose_convert_header
- (buf, sizeof(buf),
+ (compose, buf, sizeof(buf),
compose->account->name,
strlen("From: "),
FALSE);
mimemsg->type = MIMETYPE_MESSAGE;
mimemsg->subtype = g_strdup("rfc822");
mimemsg->content = MIMECONTENT_MEM;
- mimemsg->data = compose_get_header(compose);
+ mimemsg->data.mem = compose_get_header(compose);
/* Create text part MimeInfo */
/* get all composed text */
} else {
const gchar *src_codeset;
- out_codeset = conv_get_outgoing_charset_str();
- if (!strcasecmp(out_codeset, CS_US_ASCII))
+ 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 (prefs_common.encoding_method == CTE_BASE64)
else
encoding = procmime_get_encoding_for_charset(out_codeset);
- src_codeset = CS_UTF_8;
+ src_codeset = CS_INTERNAL;
/* 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))
+ if (!g_ascii_strcasecmp(src_codeset, CS_US_ASCII))
src_codeset = out_codeset;
debug_print("src encoding = %s, out encoding = %s, transfer encoding = %s\n",
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 = buf;
+ mimetext->data.mem = buf;
mimetext->type = MIMETYPE_TEXT;
mimetext->subtype = g_strdup("plain");
g_hash_table_insert(mimetext->typeparameters, g_strdup("charset"),
g_strdup(out_codeset));
- /* procmime_encode_content(mimetext, encoding); */
+ /* protect trailing spaces when signing message */
+ if (action == COMPOSE_WRITE_FOR_SEND && compose->use_signing &&
+ 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);
/* append attachment parts */
if (compose_use_attach(compose)) {
} else
g_node_append(mimemsg->node, mimetext->node);
- /* sign message */
- if (compose->use_signing && privacy_system_can_sign(compose->privacy_system))
- if (!privacy_sign(compose->privacy_system, mimemsg))
+ /* sign message if sending */
+ 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;
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");
gtk_text_buffer_get_end_iter(buffer, &end);
tmp = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
- src_codeset = CS_UTF_8;
- dest_codeset = conv_get_current_charset_str();
- chars = conv_codeset_strdup(tmp, src_codeset, dest_codeset);
+ chars = conv_codeset_strdup
+ (tmp, CS_INTERNAL, conv_get_locale_charset_str());
+
g_free(tmp);
if (!chars) return -1;
}
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(),
gchar *encdata;
encdata = privacy_get_encrypt_data(compose->privacy_system, compose->to_list);
- fprintf(fp, "X-Sylpheed-Encrypt-Data:%s\n", encdata);
+ if (encdata != NULL)
+ fprintf(fp, "X-Sylpheed-Encrypt-Data:%s\n",
+ encdata);
g_free(encdata);
}
}
static void compose_add_attachments(Compose *compose, MimeInfo *parent)
{
AttachInfo *ainfo;
- GtkCList *clist = GTK_CLIST(compose->attach_clist);
- gint row;
+ GtkTreeView *tree_view = GTK_TREE_VIEW(compose->attach_clist);
MimeInfo *mimepart;
struct stat statbuf;
gchar *type, *subtype;
+ GtkTreeModel *model;
+ GtkTreeIter iter;
- for (row = 0; (ainfo = gtk_clist_get_row_data(clist, row)) != NULL;
- row++) {
+ model = gtk_tree_view_get_model(tree_view);
+
+ if (!gtk_tree_model_get_iter_first(model, &iter))
+ return;
+ do {
+ gtk_tree_model_get(model, &iter,
+ COL_DATA, &ainfo,
+ -1);
+
mimepart = procmime_mimeinfo_new();
mimepart->content = MIMECONTENT_FILE;
- mimepart->filename = g_strdup(ainfo->file);
+ mimepart->data.filename = g_strdup(ainfo->file);
mimepart->offset = 0;
stat(ainfo->file, &statbuf);
mimepart->length = statbuf.st_size;
type = g_strdup(ainfo->content_type);
+
+ if (!strchr(type, '/')) {
+ g_free(type);
+ type = g_strdup("application/octet-stream");
+ }
+
subtype = strchr(type, '/') + 1;
*(subtype - 1) = '\0';
mimepart->type = procmime_get_media_type(type);
g_free(type);
if (mimepart->type == MIMETYPE_MESSAGE &&
- !g_strcasecmp(mimepart->subtype, "rfc822")) {
+ !g_ascii_strcasecmp(mimepart->subtype, "rfc822")) {
mimepart->disposition = DISPOSITIONTYPE_INLINE;
} else {
g_hash_table_insert(mimepart->typeparameters,
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);
- }
+ } while (gtk_tree_model_iter_next(model, &iter));
}
#define QUOTE_IF_REQUIRED(out, str) \
headerentry = ((ComposeHeaderEntry *)list->data);
headerentryname = gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(headerentry->combo)->entry));
- if (!g_strcasecmp(trans_fieldname, headerentryname)) {
+ if (!g_utf8_collate(trans_fieldname, headerentryname)) {
str = gtk_editable_get_chars(GTK_EDITABLE(headerentry->entry), 0, -1);
g_strstrip(str);
if (str[0] != '\0') {
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_sprintfa(header, "%s: %s\n", fieldname, buf);
+ g_string_append_printf(header, "%s: %s\n", fieldname, buf);
g_free(buf);
}
/* Date */
if (compose->account->add_date) {
get_rfc822_date(buf, sizeof(buf));
- g_string_sprintfa(header, "Date: %s\n", buf);
+ g_string_append_printf(header, "Date: %s\n", 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_sprintfa(header, "From: %s <%s>\n",
+ g_string_append_printf(header, "From: %s <%s>\n",
name, compose->account->address);
} else
- g_string_sprintfa(header, "From: %s\n", compose->account->address);
+ g_string_append_printf(header, "From: %s\n", compose->account->address);
/* To */
compose_add_headerfield_from_headerlist(compose, header, "To", ", ");
compose_add_headerfield_from_headerlist(compose, header, "Bcc", ", ");
/* Subject */
- str = gtk_entry_get_text(GTK_ENTRY(compose->subject_entry));
+ str = gtk_editable_get_chars(GTK_EDITABLE(compose->subject_entry), 0, -1);
if (*str != '\0' && !IS_IN_CUSTOM_HEADER("Subject")) {
- gchar *tmpstr;
-
- tmpstr = g_strdup(str);
- if (tmpstr == NULL) {
- g_string_free(header, TRUE);
- return NULL;
- }
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_sprintfa(header, "Subject: %s\n", buf);
+ g_string_append_printf(header, "Subject: %s\n", buf);
}
- g_free(tmpstr);
}
+ g_free(str);
/* Message-ID */
if (compose->account->gen_msgid) {
- compose_generate_msgid(buf, sizeof(buf));
- g_string_sprintfa(header, "Message-ID: <%s>\n", buf);
+ generate_msgid(buf, sizeof(buf));
+ g_string_append_printf(header, "Message-ID: <%s>\n", buf);
compose->msgid = g_strdup(buf);
}
if (compose->remove_references == FALSE) {
/* In-Reply-To */
if (compose->inreplyto && compose->to_list)
- g_string_sprintfa(header, "In-Reply-To: <%s>\n", compose->inreplyto);
+ g_string_append_printf(header, "In-Reply-To: <%s>\n", compose->inreplyto);
/* References */
if (compose->references)
- g_string_sprintfa(header, "References: %s\n", compose->references);
+ g_string_append_printf(header, "References: %s\n", compose->references);
}
/* Followup-To */
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_sprintfa(header, "Organization: %s\n", buf);
+ g_string_append_printf(header, "Organization: %s\n", buf);
}
/* Program version and system info */
/* uname(&utsbuf); */
if (g_slist_length(compose->to_list) && !IS_IN_CUSTOM_HEADER("X-Mailer") &&
!compose->newsgroup_list) {
- g_string_sprintfa(header, "X-Mailer: %s (GTK+ %d.%d.%d; %s)\n",
+ g_string_append_printf(header, "X-Mailer: %s (GTK+ %d.%d.%d; %s)\n",
prog_version,
gtk_major_version, gtk_minor_version, gtk_micro_version,
TARGET_ALIAS);
/* utsbuf.sysname, utsbuf.release, utsbuf.machine); */
}
if (g_slist_length(compose->newsgroup_list) && !IS_IN_CUSTOM_HEADER("X-Newsreader")) {
- g_string_sprintfa(header, "X-Newsreader: %s (GTK+ %d.%d.%d; %s)\n",
+ g_string_append_printf(header, "X-Newsreader: %s (GTK+ %d.%d.%d; %s)\n",
prog_version,
gtk_major_version, gtk_minor_version, gtk_micro_version,
TARGET_ALIAS);
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_sprintfa(header, "%s: %s\n", chdr->name, buf);
+ g_string_append_printf(header, "%s: %s\n", chdr->name, buf);
}
}
}
/* PRIORITY */
switch (compose->priority) {
- case PRIORITY_HIGHEST: g_string_sprintfa(header, "Importance: high\n"
+ case PRIORITY_HIGHEST: g_string_append_printf(header, "Importance: high\n"
"X-Priority: 1 (Highest)\n");
break;
- case PRIORITY_HIGH: g_string_sprintfa(header, "Importance: high\n"
+ case PRIORITY_HIGH: g_string_append_printf(header, "Importance: high\n"
"X-Priority: 2 (High)\n");
break;
case PRIORITY_NORMAL: break;
- case PRIORITY_LOW: g_string_sprintfa(header, "Importance: low\n"
+ case PRIORITY_LOW: g_string_append_printf(header, "Importance: low\n"
"X-Priority: 4 (Low)\n");
break;
- case PRIORITY_LOWEST: g_string_sprintfa(header, "Importance: low\n"
+ case PRIORITY_LOWEST: g_string_append_printf(header, "Importance: low\n"
"X-Priority: 5 (Lowest)\n");
break;
default: debug_print("compose: priority unknown : %d\n",
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);
- g_string_sprintfa(header, "Disposition-Notification-To: %s <%s>\n", buf, compose->account->address);
+ g_string_append_printf(header, "Disposition-Notification-To: %s <%s>\n", buf, compose->account->address);
} else
- g_string_sprintfa(header, "Disposition-Notification-To: %s\n", compose->account->address);
+ g_string_append_printf(header, "Disposition-Notification-To: %s\n", compose->account->address);
}
}
g_free(tmp);
entry_str = gtk_entry_get_text(GTK_ENTRY(headerentry->entry));
- Xstrdup_a(headervalue, entry_str, return -1);
+ Xstrdup_a(headervalue, entry_str, return NULL);
subst_char(headervalue, '\r', ' ');
subst_char(headervalue, '\n', ' ');
string = std_headers;
string++;
}
if (!standard_header && !IS_IN_CUSTOM_HEADER(headername))
- g_string_sprintfa(header, "%s %s\n", headername_wcolon, headervalue);
+ g_string_append_printf(header, "%s %s\n", headername_wcolon, headervalue);
g_free(headername);
g_free(headername_wcolon);
#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);
}
-static void compose_generate_msgid(gchar *buf, gint len)
-{
- struct tm *lt;
- time_t t;
- gchar *addr;
-
- t = time(NULL);
- lt = localtime(&t);
-
- addr = g_strconcat("@", get_domain_name(), NULL);
-
- g_snprintf(buf, len, "%04d%02d%02d%02d%02d%02d.%08x%s",
- lt->tm_year + 1900, lt->tm_mon + 1,
- lt->tm_mday, lt->tm_hour,
- lt->tm_min, lt->tm_sec,
- (guint)random(), addr);
-
- debug_print("generated Message-ID: %s\n", buf);
-
- g_free(addr);
-}
-
static void compose_create_header_entry(Compose *compose)
{
gchar *headers[] = {"To:", "Cc:", "Bcc:", "Newsgroups:", "Reply-To:", "Followup-To:", NULL};
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), "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);
+
+ /* email dnd */
+ gtk_drag_dest_set(entry, GTK_DEST_DEFAULT_ALL, compose_mime_types,
+ sizeof(compose_mime_types)/sizeof(compose_mime_types[0]),
+ GDK_ACTION_COPY | GDK_ACTION_MOVE);
+ g_signal_connect(G_OBJECT(entry), "drag_data_received",
+ G_CALLBACK(compose_header_drag_received_cb),
+ entry);
+ g_signal_connect(G_OBJECT(entry), "drag-drop",
+ G_CALLBACK(compose_drag_drop),
+ compose);
+
address_completion_register_entry(GTK_ENTRY(entry));
headerentry->compose = compose;
GtkWidget *compose_create_attach(Compose *compose)
{
- gchar *titles[N_ATTACH_COLS];
- gint i;
-
GtkWidget *attach_scrwin;
GtkWidget *attach_clist;
- titles[COL_MIMETYPE] = _("MIME type");
- titles[COL_SIZE] = _("Size");
- titles[COL_NAME] = _("Name");
+ GtkListStore *store;
+ GtkCellRenderer *renderer;
+ GtkTreeViewColumn *column;
+ GtkTreeSelection *selection;
/* attachment list */
attach_scrwin = gtk_scrolled_window_new(NULL, NULL);
GTK_POLICY_AUTOMATIC);
gtk_widget_set_size_request(attach_scrwin, -1, 80);
- attach_clist = gtk_clist_new_with_titles(N_ATTACH_COLS, titles);
- gtk_clist_set_column_justification(GTK_CLIST(attach_clist), COL_SIZE,
- GTK_JUSTIFY_RIGHT);
- gtk_clist_set_column_width(GTK_CLIST(attach_clist), COL_MIMETYPE, 240);
- gtk_clist_set_column_width(GTK_CLIST(attach_clist), COL_SIZE, 64);
- gtk_clist_set_selection_mode(GTK_CLIST(attach_clist),
- GTK_SELECTION_EXTENDED);
- for (i = 0; i < N_ATTACH_COLS; i++)
- GTK_WIDGET_UNSET_FLAGS
- (GTK_CLIST(attach_clist)->column[i].button,
- GTK_CAN_FOCUS);
+ store = gtk_list_store_new(N_ATTACH_COLS,
+ G_TYPE_STRING,
+ G_TYPE_STRING,
+ G_TYPE_STRING,
+ G_TYPE_POINTER,
+ G_TYPE_AUTO_POINTER,
+ -1);
+ attach_clist = GTK_WIDGET(gtk_tree_view_new_with_model
+ (GTK_TREE_MODEL(store)));
gtk_container_add(GTK_CONTAINER(attach_scrwin), attach_clist);
-
- g_signal_connect(G_OBJECT(attach_clist), "select_row",
+ g_object_unref(store);
+
+ renderer = gtk_cell_renderer_text_new();
+ column = gtk_tree_view_column_new_with_attributes
+ (_("Mime type"), renderer, "text",
+ COL_MIMETYPE, NULL);
+ gtk_tree_view_append_column(GTK_TREE_VIEW(attach_clist), column);
+
+ renderer = gtk_cell_renderer_text_new();
+ column = gtk_tree_view_column_new_with_attributes
+ (_("Size"), renderer, "text",
+ COL_SIZE, NULL);
+ gtk_tree_view_append_column(GTK_TREE_VIEW(attach_clist), column);
+
+ renderer = gtk_cell_renderer_text_new();
+ column = gtk_tree_view_column_new_with_attributes
+ (_("Name"), renderer, "text",
+ 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),
+ 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);
+
+ g_signal_connect(G_OBJECT(attach_clist), "row_activated",
G_CALLBACK(attach_selected), compose);
g_signal_connect(G_OBJECT(attach_clist), "button_press_event",
G_CALLBACK(attach_button_pressed), compose);
/* drag and drop */
gtk_drag_dest_set(attach_clist,
- GTK_DEST_DEFAULT_ALL, compose_mime_types, 1,
+ GTK_DEST_DEFAULT_ALL, compose_mime_types,
+ sizeof(compose_mime_types)/sizeof(compose_mime_types[0]),
GDK_ACTION_COPY | GDK_ACTION_MOVE);
g_signal_connect(G_OBJECT(attach_clist), "drag_data_received",
G_CALLBACK(compose_attach_drag_received_cb),
compose);
+ g_signal_connect(G_OBJECT(attach_clist), "drag-drop",
+ G_CALLBACK(compose_drag_drop),
+ compose);
compose->attach_scrwin = attach_scrwin;
compose->attach_clist = attach_clist;
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)) {
gchar *titles[N_ATTACH_COLS];
guint n_menu_entries;
- GtkStyle *style, *new_style;
GdkColormap *cmap;
GdkColor color[1];
gboolean success[1];
GtkItemFactory *ifactory;
GtkWidget *tmpl_menu;
gint n_entries;
+ GtkWidget *menuitem;
#if USE_ASPELL
GtkAspell * gtkaspell = NULL;
}
gtk_window_set_geometry_hints(GTK_WINDOW(window), NULL,
&geometry, GDK_HINT_MAX_SIZE);
+ if (!geometry.min_width) {
+ geometry.min_width = 600;
+ geometry.min_height = 480;
+ }
+ gtk_window_set_geometry_hints(GTK_WINDOW(window), NULL,
+ &geometry, GDK_HINT_MIN_SIZE);
gtk_widget_set_uposition(window, prefs_common.compose_x,
prefs_common.compose_y);
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), "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);
ruler = gtk_shruler_new();
gtk_ruler_set_range(GTK_RULER(ruler), 0.0, 100.0, 1.0, 100.0);
gtk_box_pack_start(GTK_BOX(ruler_hbox), ruler, TRUE, TRUE,
- BORDER_WIDTH + 1);
- gtk_widget_set_size_request(ruler_hbox, 1, -1);
+ BORDER_WIDTH);
/* 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_widget_set_size_request(scrolledwin, prefs_common.compose_width, -1);
text = gtk_text_view_new();
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
+ gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(text), GTK_WRAP_WORD_CHAR);
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);
G_CALLBACK(compose_changed_cb), compose);
g_signal_connect(G_OBJECT(text), "grab_focus",
G_CALLBACK(compose_grab_focus_cb), compose);
- g_signal_connect(G_OBJECT(buffer), "insert-text",
+ g_signal_connect(G_OBJECT(buffer), "insert_text",
G_CALLBACK(text_inserted), compose);
/* drag and drop */
- gtk_drag_dest_set(text, GTK_DEST_DEFAULT_ALL, compose_mime_types, 1,
+ gtk_drag_dest_set(text, GTK_DEST_DEFAULT_ALL, compose_mime_types,
+ sizeof(compose_mime_types)/sizeof(compose_mime_types[0]),
GDK_ACTION_COPY | GDK_ACTION_MOVE);
g_signal_connect(G_OBJECT(text), "drag_data_received",
G_CALLBACK(compose_insert_drag_received_cb),
compose);
+ g_signal_connect(G_OBJECT(text), "drag-drop",
+ G_CALLBACK(compose_drag_drop),
+ compose);
gtk_widget_show_all(vbox);
/* pane between attach clist and text */
gtk_paned_add2(GTK_PANED(paned), edit_vbox);
gtk_widget_show_all(paned);
- style = gtk_widget_get_style(text);
-
- new_style = gtk_style_copy(style);
if (prefs_common.textfont) {
PangoFontDescription *font_desc;
font_desc = pango_font_description_from_string
- (prefs_common.textfont);
+ (prefs_common.textfont);
if (font_desc) {
- if (new_style->font_desc)
- pango_font_description_free
- (new_style->font_desc);
- new_style->font_desc = font_desc;
+ gtk_widget_modify_font(text, font_desc);
+ pango_font_description_free(font_desc);
}
}
- gtk_widget_set_style(text, new_style);
-
color[0] = quote_color;
cmap = gdk_window_get_colormap(window->window);
gdk_colormap_alloc_colors(cmap, color, 1, FALSE, TRUE, success);
if (success[0] == FALSE) {
+ GtkStyle *style;
+
g_warning("Compose: color allocation failed.\n");
style = gtk_widget_get_style(text);
quote_color = style->black;
strcmp(prefs_common.dictionary, _("None"))) {
gtkaspell = gtkaspell_new(prefs_common.aspell_path,
prefs_common.dictionary,
- conv_get_current_charset_str(),
+ conv_get_locale_charset_str(),
prefs_common.misspelled_col,
prefs_common.check_while_typing,
prefs_common.use_alternate,
if (mode != COMPOSE_REDIRECT)
compose_set_template_menu(compose);
else {
- GtkWidget *menuitem;
menuitem = gtk_item_factory_get_item(ifactory, "/Tools/Template");
menu_set_sensitive(ifactory, "/Tools/Template", FALSE);
}
if (!prefs_common.show_ruler)
gtk_widget_hide(ruler_hbox);
+
+ menuitem = gtk_item_factory_get_item(ifactory, "/Tools/Show ruler");
+ gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem),
+ prefs_common.show_ruler);
/* Priority */
compose->priority = PRIORITY_NORMAL;
compose_update_priority_menu_item(compose);
+ compose_set_out_encoding(compose);
+
/* Actions menu */
compose_update_actions_menu(compose);
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem), TRUE);
}
-static void compose_set_privacy_system_cb(gpointer data,
- guint action,
- GtkWidget *widget)
+static void compose_set_privacy_system_cb(GtkWidget *widget, gpointer data)
{
Compose *compose = (Compose *) data;
gchar *systemid;
GtkItemFactory *ifactory;
gboolean can_sign = FALSE, can_encrypt = FALSE;
- systemid = gtk_object_get_data(GTK_OBJECT(widget), "privacy_system");
+ g_return_if_fail(GTK_IS_CHECK_MENU_ITEM(widget));
+
+ if (!GTK_CHECK_MENU_ITEM(widget)->active)
+ return;
+
+ systemid = g_object_get_data(G_OBJECT(widget), "privacy_system");
g_free(compose->privacy_system);
compose->privacy_system = NULL;
if (systemid != NULL) {
can_encrypt = privacy_system_can_encrypt(systemid);
}
+ debug_print("activated privacy system: %s\n", systemid != NULL ? systemid : "None");
+
ifactory = gtk_item_factory_from_widget(compose->menubar);
menu_set_sensitive(ifactory, "/Options/Sign", can_sign);
menu_set_sensitive(ifactory, "/Options/Encrypt", can_encrypt);
while (amenu != NULL) {
GList *alist = amenu->next;
- systemid = gtk_object_get_data(GTK_OBJECT(amenu->data), "privacy_system");
+ systemid = g_object_get_data(G_OBJECT(amenu->data), "privacy_system");
if (systemid != NULL)
if (strcmp(systemid, compose->privacy_system) == 0) {
menuitem = GTK_WIDGET(amenu->data);
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;
static gchar *branch_path = "/Options/Privacy System";
GtkItemFactory *ifactory;
GtkWidget *menuitem;
- gchar *menu_path;
GSList *systems, *cur;
GList *amenu;
- GtkItemFactoryEntry ifentry = {NULL, NULL, NULL, 0, "<Branch>"};
GtkWidget *widget;
+ GtkWidget *system_none;
+ GSList *group;
ifactory = gtk_item_factory_from_widget(compose->menubar);
/* remove old entries */
- ifentry.path = branch_path;
menuitem = gtk_item_factory_get_widget(ifactory, branch_path);
g_return_if_fail(menuitem != NULL);
amenu = alist;
}
- ifentry.accelerator = NULL;
- ifentry.callback_action = 0;
- ifentry.callback = compose_set_privacy_system_cb;
- ifentry.item_type = "/Options/Privacy System/None";
+ system_none = gtk_item_factory_get_widget(ifactory,
+ "/Options/Privacy System/None");
+
+ 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)) {
gchar *systemid = cur->data;
- menu_path = g_strdup_printf("%s/%s", branch_path,
- privacy_system_get_name(systemid));
- ifentry.path = menu_path;
- gtk_item_factory_create_item(ifactory, &ifentry, compose, 1);
- widget = gtk_item_factory_get_widget(ifactory, menu_path);
-
+ group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(system_none));
+ widget = gtk_radio_menu_item_new_with_label(group,
+ privacy_system_get_name(systemid));
g_object_set_data_full(G_OBJECT(widget), "privacy_system",
g_strdup(systemid), g_free);
+ g_signal_connect(G_OBJECT(widget), "activate",
+ G_CALLBACK(compose_set_privacy_system_cb), compose);
+ gtk_menu_append(GTK_MENU(system_none->parent), widget);
+ gtk_widget_show(widget);
g_free(systemid);
- g_free(menu_path);
}
g_slist_free(systems);
}
compose_entry_append(compose, tmpl->bcc, COMPOSE_BCC);
if (replace)
- gtk_text_buffer_set_text(buffer, "\0", 1);
+ gtk_text_buffer_set_text(buffer, "", -1);
mark = gtk_text_buffer_get_insert(buffer);
gtk_text_buffer_get_iter_at_mark(buffer, &iter, mark);
static void compose_destroy(Compose *compose)
{
- gint row;
- GtkCList *clist = GTK_CLIST(compose->attach_clist);
- AttachInfo *ainfo;
+ compose_list = g_list_remove(compose_list, compose);
/* NOTE: address_completion_end() does nothing with the window
* however this may change. */
g_free(compose->exteditor_file);
- for (row = 0; (ainfo = gtk_clist_get_row_data(clist, row)) != NULL;
- row++)
- compose_attach_info_free(ainfo);
-
if (addressbook_get_target_compose() == compose)
addressbook_set_target_compose(NULL);
#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)
{
- GtkCList *clist = GTK_CLIST(compose->attach_clist);
- AttachInfo *ainfo;
- gint row;
+ GtkTreeView *tree_view = GTK_TREE_VIEW(compose->attach_clist);
+ GtkTreeSelection *selection;
+ GList *sel, *cur;
+ GtkTreeModel *model;
+
+ selection = gtk_tree_view_get_selection(tree_view);
+ sel = gtk_tree_selection_get_selected_rows(selection, &model);
+
+ if (!sel)
+ return;
- while (clist->selection != NULL) {
- row = GPOINTER_TO_INT(clist->selection->data);
- ainfo = gtk_clist_get_row_data(clist, row);
- compose_attach_info_free(ainfo);
- gtk_clist_remove(clist, row);
+ for (cur = sel; cur != NULL; cur = cur->next) {
+ GtkTreePath *path = cur->data;
+ GtkTreeRowReference *ref = gtk_tree_row_reference_new
+ (model, cur->data);
+ cur->data = ref;
+ gtk_tree_path_free(path);
}
+
+ for (cur = sel; cur != NULL; cur = cur->next) {
+ GtkTreeRowReference *ref = cur->data;
+ GtkTreePath *path = gtk_tree_row_reference_get_path(ref);
+ GtkTreeIter iter;
+
+ if (gtk_tree_model_get_iter(model, &iter, path))
+ gtk_list_store_remove(GTK_LIST_STORE(model), &iter);
+
+ gtk_tree_path_free(path);
+ gtk_tree_row_reference_free(ref);
+ }
+
+ g_list_free(sel);
}
static struct _AttachProperty
GtkWidget *cancel_btn;
} attach_prop;
+static void gtk_tree_path_free_(gpointer ptr, gpointer data)
+{
+ gtk_tree_path_free((GtkTreePath *)ptr);
+}
+
static void compose_attach_property(Compose *compose)
{
- GtkCList *clist = GTK_CLIST(compose->attach_clist);
+ GtkTreeView *tree_view = GTK_TREE_VIEW(compose->attach_clist);
AttachInfo *ainfo;
- gint row;
GtkOptionMenu *optmenu;
+ GtkTreeSelection *selection;
+ GList *sel;
+ GtkTreeModel *model;
+ GtkTreeIter iter;
+ GtkTreePath *path;
static gboolean cancelled;
- if (!clist->selection) return;
- row = GPOINTER_TO_INT(clist->selection->data);
+ /* only if one selected */
+ selection = gtk_tree_view_get_selection(tree_view);
+ if (gtk_tree_selection_count_selected_rows(selection) != 1)
+ return;
+
+ sel = gtk_tree_selection_get_selected_rows(selection, &model);
+ if (!sel)
+ return;
- ainfo = gtk_clist_get_row_data(clist, row);
- if (!ainfo) return;
+ path = (GtkTreePath *) sel->data;
+ gtk_tree_model_get_iter(model, &iter, path);
+ gtk_tree_model_get(model, &iter, COL_DATA, &ainfo, -1);
+
+ if (!ainfo) {
+ g_list_foreach(sel, gtk_tree_path_free_, NULL);
+ g_list_free(sel);
+ return;
+ }
+ g_list_free(sel);
if (!attach_prop.window)
compose_attach_property_create(&cancelled);
cancelled = FALSE;
gtk_main();
- if (cancelled == TRUE) {
- gtk_widget_hide(attach_prop.window);
+ gtk_widget_hide(attach_prop.window);
+
+ if (cancelled)
break;
- }
entry_text = gtk_entry_get_text(GTK_ENTRY(attach_prop.mimetype_entry));
if (*entry_text != '\0') {
if (size)
ainfo->size = size;
- gtk_clist_set_text(clist, row, COL_MIMETYPE,
- ainfo->content_type);
- gtk_clist_set_text(clist, row, COL_SIZE,
- to_human_readable(ainfo->size));
- gtk_clist_set_text(clist, row, COL_NAME, ainfo->name);
-
- gtk_widget_hide(attach_prop.window);
+ /* update tree store */
+ text = to_human_readable(ainfo->size);
+ gtk_tree_model_get_iter(model, &iter, path);
+ gtk_list_store_set(GTK_LIST_STORE(model), &iter,
+ COL_MIMETYPE, ainfo->content_type,
+ COL_SIZE, text,
+ COL_NAME, ainfo->file,
+ -1);
+
break;
}
+
+ gtk_tree_path_free(path);
}
#define SET_LABEL_AND_ENTRY(str, entry, top) \
SET_LABEL_AND_ENTRY(_("Path"), path_entry, 2);
SET_LABEL_AND_ENTRY(_("File name"), filename_entry, 3);
- gtkut_button_set_create(&hbbox, &ok_btn, _("OK"),
- &cancel_btn, _("Cancel"), NULL, NULL);
+ gtkut_stock_button_set_create(&hbbox, &ok_btn, GTK_STOCK_OK,
+ &cancel_btn, GTK_STOCK_CANCEL,
+ NULL, NULL);
gtk_box_pack_end(GTK_BOX(vbox), hbbox, FALSE, FALSE, 0);
gtk_widget_grab_default(ok_btn);
GtkTextView *text = GTK_TEXT_VIEW(compose->text);
GtkTextBuffer *buffer = gtk_text_view_get_buffer(text);
- gtk_text_buffer_set_text(buffer, "\0", 1);
+ gtk_text_buffer_set_text(buffer, "", -1);
compose_insert_file(compose, compose->exteditor_file);
compose_changed_cb(NULL, compose);
}
}
-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);
}
}
}
-static void attach_selected(GtkCList *clist, gint row, gint column,
- GdkEvent *event, gpointer data)
+static void attach_selected(GtkTreeView *tree_view, GtkTreePath *tree_path,
+ GtkTreeViewColumn *column, Compose *compose)
{
- Compose *compose = (Compose *)data;
-
- if (event && event->type == GDK_2BUTTON_PRESS)
- compose_attach_property(compose);
+ compose_attach_property(compose);
}
static gboolean attach_button_pressed(GtkWidget *widget, GdkEventButton *event,
gpointer data)
{
Compose *compose = (Compose *)data;
- GtkCList *clist = GTK_CLIST(compose->attach_clist);
- gint row, column;
if (!event) return FALSE;
if (event->button == 3) {
- if ((clist->selection && !clist->selection->next) ||
- !clist->selection) {
- gtk_clist_unselect_all(clist);
- if (gtk_clist_get_selection_info(clist,
- event->x, event->y,
- &row, &column)) {
- gtk_clist_select_row(clist, row, column);
- gtkut_clist_set_focus_row(clist, row);
- }
- }
gtk_menu_popup(GTK_MENU(compose->popupmenu), NULL, NULL,
NULL, NULL, event->button, event->time);
+ return TRUE;
}
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)
gint val;
val = compose_queue_sub(compose, NULL, NULL, TRUE);
- if (!val) gtk_widget_destroy(compose->window);
+ if (!val)
+ compose_close(compose);
}
void compose_draft (gpointer data)
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-Gnupg-Mode:%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) {
lock = FALSE;
if (action == COMPOSE_QUIT_EDITING)
- gtk_widget_destroy(compose->window);
+ compose_close(compose);
else {
struct stat s;
gchar *path;
for ( tmp = file_list; tmp; tmp = tmp->next) {
gchar *file = (gchar *) tmp->data;
- compose_attach_append(compose, file, file, NULL);
+ gchar *utf8_filename = conv_filename_to_utf8(file);
+ compose_attach_append(compose, file, utf8_filename, NULL);
compose_changed_cb(NULL, compose);
g_free(file);
+ g_free(utf8_filename);
}
g_list_free(file_list);
}
for ( tmp = file_list; tmp; tmp = tmp->next) {
gchar *file = (gchar *) tmp->data;
gchar *filedup = g_strdup(file);
- const gchar *shortfile = g_basename(filedup);
+ gchar *shortfile = g_path_get_basename(filedup);
ComposeInsertResult res;
res = compose_insert_file(compose, file);
alertpanel_error(_("File '%s' contained invalid characters\n"
"for the current encoding, insertion may be incorrect."), shortfile);
}
+ g_free(shortfile);
g_free(filedup);
g_free(file);
}
if (compose->modified) {
val = alertpanel(_("Discard message"),
_("This message has been modified. discard it?"),
- _("Discard"), _("to Draft"), _("Cancel"));
+ _("Discard"), _("to Draft"), GTK_STOCK_CANCEL);
switch (val) {
case G_ALERTDEFAULT:
}
}
- gtk_widget_destroy(compose->window);
+ 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)
msg = g_strdup_printf(_("Do you want to apply the template `%s' ?"),
tmpl->name);
val = alertpanel(_("Apply template"), msg,
- _("Replace"), _("Insert"), _("Cancel"));
+ _("Replace"), _("Insert"), GTK_STOCK_CANCEL);
g_free(msg);
if (val == G_ALERTDEFAULT)
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 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)
+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;
-
- return TRUE;
}
static void compose_changed_cb(GtkTextBuffer *textbuf, Compose *compose)
}
}
+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,
static void activate_privacy_system(Compose *compose, PrefsAccount *account)
{
- /* TODO
- if (account->default_gnupg_mode)
- compose->gnupg_mode = GNUPG_MODE_INLINE;
- else
- compose->gnupg_mode = GNUPG_MODE_DETACH;
- */
+ g_free(compose->privacy_system);
+ compose->privacy_system = g_strdup(account->default_privacy_system);
compose_update_privacy_system_menu_item(compose);
}
{
Compose *compose = (Compose *)user_data;
GList *list, *tmp;
+
+ if (gdk_atom_name(data->type) && !strcmp(gdk_atom_name(data->type), "text/uri-list")) {
+ list = uri_list_extract_filenames((const gchar *)data->data);
+ for (tmp = list; tmp != NULL; tmp = tmp->next)
+ compose_attach_append
+ (compose, (const gchar *)tmp->data,
+ (const gchar *)tmp->data, NULL);
+ if (list) compose_changed_cb(NULL, compose);
+ list_free_strings(list);
+ g_list_free(list);
+ }
+}
- list = uri_list_extract_filenames((const gchar *)data->data);
- for (tmp = list; tmp != NULL; tmp = tmp->next)
- compose_attach_append
- (compose, (const gchar *)tmp->data,
- (const gchar *)tmp->data, NULL);
- if (list) compose_changed_cb(NULL, compose);
- list_free_strings(list);
- g_list_free(list);
+static gboolean compose_drag_drop(GtkWidget *widget,
+ GdkDragContext *drag_context,
+ gint x, gint y,
+ guint time, gpointer user_data)
+{
+ /* not handling this signal makes compose_insert_drag_received_cb
+ * called twice */
+ return TRUE;
}
static void compose_insert_drag_received_cb (GtkWidget *widget,
Compose *compose = (Compose *)user_data;
GList *list, *tmp;
- list = uri_list_extract_filenames((const gchar *)data->data);
- for (tmp = list; tmp != NULL; tmp = tmp->next)
- compose_insert_file(compose, (const gchar *)tmp->data);
- list_free_strings(list);
- g_list_free(list);
+ /* strangely, testing data->type == gdk_atom_intern("text/uri-list", TRUE)
+ * does not work */
+ if (gdk_atom_name(data->type) && !strcmp(gdk_atom_name(data->type), "text/uri-list")) {
+ list = uri_list_extract_filenames((const gchar *)data->data);
+ for (tmp = list; tmp != NULL; tmp = tmp->next) {
+ compose_insert_file(compose, (const gchar *)tmp->data);
+ }
+ list_free_strings(list);
+ g_list_free(list);
+ gtk_drag_finish(drag_context, TRUE, FALSE, time);
+ return;
+ } else {
+ gchar *tmpfile = get_tmp_file();
+ str_write_to_file((const gchar *)data->data, tmpfile);
+ compose_insert_file(compose, tmpfile);
+ unlink(tmpfile);
+ g_free(tmpfile);
+ gtk_drag_finish(drag_context, TRUE, FALSE, time);
+ return;
+ }
+ gtk_drag_finish(drag_context, TRUE, FALSE, time);
+}
+
+static void compose_header_drag_received_cb (GtkWidget *widget,
+ GdkDragContext *drag_context,
+ gint x,
+ gint y,
+ GtkSelectionData *data,
+ guint info,
+ guint time,
+ gpointer user_data)
+{
+ GtkEditable *entry = (GtkEditable *)user_data;
+ gchar *email = (gchar *)data->data;
+
+ /* strangely, testing data->type == gdk_atom_intern("text/plain", TRUE)
+ * does not work */
+
+ if (!strncmp(email, "mailto:", strlen("mailto:"))) {
+ gchar *decoded=g_new(gchar, strlen(email));
+ int start = 0;
+
+ email += strlen("mailto:");
+ decode_uri(decoded, email); /* will fit */
+ 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);
}
#if 0 /* NEW COMPOSE GUI */
gtk_adjustment_set_value(vadj, (show_first ? vadj->lower : vadj->upper));
}
-static void text_activated(GtkWidget *widget, Compose *compose)
-{
- compose_send_control_enter(compose);
-}
-
static void text_inserted(GtkTextBuffer *buffer, GtkTextIter *iter,
const gchar *text, gint len, Compose *compose)
{
gint paste_as_quotation = GPOINTER_TO_INT(g_object_get_data
(G_OBJECT(compose->text), "paste_as_quotation"));
+ GtkTextMark *mark;
+
+ /* CLAWS: pass to default handler only if not pasting as quotation, and
+ * no autowrap */
+ if (!paste_as_quotation && !compose->autowrap)
+ return;
- g_return_if_fail(text);
+ g_return_if_fail(text != NULL);
g_signal_handlers_block_by_func(G_OBJECT(buffer),
G_CALLBACK(text_inserted),
} else
gtk_text_buffer_insert(buffer, iter, text, len);
- if (prefs_common.autowrap)
- compose_wrap_line_all_full(compose, TRUE);
+ mark = gtk_text_buffer_create_mark(buffer, NULL, iter, FALSE);
+ compose_wrap_all_full(compose, TRUE);
+ gtk_text_buffer_get_iter_at_mark(buffer, iter, mark);
+ gtk_text_buffer_delete_mark(buffer, mark);
g_signal_handlers_unblock_by_func(G_OBJECT(buffer),
G_CALLBACK(text_inserted),
compose->draft_timeout_tag = gtk_timeout_add
(500, (GtkFunction) compose_defer_auto_save_draft, compose);
}
-
static gint compose_defer_auto_save_draft(Compose *compose)
{
compose->draft_timeout_tag = -1;
return FALSE;
}
-static gboolean compose_send_control_enter(Compose *compose)
-{
- GdkEvent *ev;
- GdkEventKey *kev;
- GtkItemFactory *ifactory;
- GtkAccelKey *accel;
- GtkWidget *send_menu;
- GSList *list;
- GdkModifierType ignored_mods =
- (GDK_LOCK_MASK | GDK_MOD2_MASK | GDK_MOD3_MASK |
- GDK_MOD4_MASK | GDK_MOD5_MASK);
-
- ev = gtk_get_current_event();
- if (ev->type != GDK_KEY_PRESS) return FALSE;
-
- kev = (GdkEventKey *)ev;
- if (!(kev->keyval == GDK_Return && (kev->state & GDK_CONTROL_MASK)))
- return FALSE;
-
- if (compose->exteditor_tag != -1)
- return FALSE;
-
- ifactory = gtk_item_factory_from_widget(compose->menubar);
- send_menu = gtk_item_factory_get_widget(ifactory, "/Message/Send");
- list = gtk_accel_groups_from_object(G_OBJECT(send_menu));
- if (!list)
- return FALSE;
-
- accel = (GtkAccelKey *)list->data;
- if (accel && accel->accel_key == kev->keyval &&
- (accel->accel_mods & ~ignored_mods) ==
- (kev->state & ~ignored_mods)) {
- compose_send_cb(compose, 0, NULL);
- return TRUE;
- }
-
- return FALSE;
-}
-
#if USE_ASPELL
static void compose_check_all(Compose *compose)
{
return account;
}
+static void compose_close(Compose *compose)
+{
+ gint x, y;
+
+ g_return_if_fail(compose);
+ gtkut_widget_get_uposition(compose->window, &x, &y);
+ prefs_common.compose_x = x;
+ prefs_common.compose_y = y;
+ compose_destroy(compose);
+}
+
/**
* Add entry field for each address in list.
* \param compose E-Mail composition object.
}
}
+void compose_reply_from_messageview(MessageView *msgview, GSList *msginfo_list,
+ guint action)
+{
+ gchar *body;
+ GSList *new_msglist = NULL;
+ MsgInfo *tmp_msginfo = NULL;
+
+ g_return_if_fail(msgview != NULL);
+
+ g_return_if_fail(msginfo_list != NULL);
+
+ if (g_slist_length(msginfo_list) == 1) {
+ MimeInfo *mimeinfo = messageview_get_selected_mime_part(msgview);
+ MsgInfo *orig_msginfo = (MsgInfo *)msginfo_list->data;
+
+ if (mimeinfo != NULL && mimeinfo->type == MIMETYPE_MESSAGE &&
+ !g_ascii_strcasecmp(mimeinfo->subtype, "rfc822")) {
+
+ tmp_msginfo = procmsg_msginfo_new_from_mimeinfo(
+ orig_msginfo, mimeinfo);
+ if (tmp_msginfo != NULL) {
+ new_msglist = g_slist_append(NULL, tmp_msginfo);
+ }
+ }
+ }
+
+ body = messageview_get_selection(msgview);
+
+ if (new_msglist) {
+ compose_reply_mode((ComposeMode)action, new_msglist, body);
+ procmsg_msginfo_free(tmp_msginfo);
+ g_slist_free(new_msglist);
+ } else
+ compose_reply_mode((ComposeMode)action, msginfo_list, body);
+
+ g_free(body);
+}
+
/*
* End of Source.
*/
-