static void
composer_move_caret (EMsgComposer *composer)
{
EHTMLEditor *editor;
EHTMLEditorView *view;
EHTMLEditorSelection *editor_selection;
GSettings *settings;
gboolean start_bottom, top_signature;
gboolean is_message_from_draft;
gboolean is_message_from_edit_as_new;
gboolean has_paragraphs_in_body = TRUE;
WebKitDOMDocument *document;
WebKitDOMElement *element, *signature;
WebKitDOMHTMLElement *body;
WebKitDOMNodeList *list;
/* When there is an option composer-reply-start-bottom set we have
* to move the caret between reply and signature. */
settings = e_util_ref_settings ("org.gnome.evolution.mail");
start_bottom = g_settings_get_boolean (settings, "composer-reply-start-bottom");
g_object_unref (settings);
editor = e_msg_composer_get_editor (composer);
view = e_html_editor_get_view (editor);
editor_selection = e_html_editor_view_get_selection (view);
is_message_from_draft = e_html_editor_view_is_message_from_draft (view);
is_message_from_edit_as_new =
e_html_editor_view_is_message_from_edit_as_new (view);
top_signature =
use_top_signature (composer) &&
!is_message_from_edit_as_new &&
!composer->priv->is_from_new_message;
document = webkit_web_view_get_dom_document (WEBKIT_WEB_VIEW (view));
body = webkit_dom_document_get_body (document);
webkit_dom_element_set_attribute (
WEBKIT_DOM_ELEMENT (body), "data-message", "", NULL);
/* If editing message as new don't handle with caret */
if (is_message_from_edit_as_new || is_message_from_draft) {
if (is_message_from_edit_as_new)
webkit_dom_element_set_attribute (
WEBKIT_DOM_ELEMENT (body),
"data-edit-as-new",
"",
NULL);
if (is_message_from_edit_as_new && !is_message_from_draft) {
element = WEBKIT_DOM_ELEMENT (body);
e_html_editor_selection_block_selection_changed (editor_selection);
goto move_caret;
} else
e_html_editor_selection_scroll_to_caret (editor_selection);
return;
}
e_html_editor_selection_block_selection_changed (editor_selection);
/* When the new message is written from the beginning - note it into body */
if (composer->priv->is_from_new_message)
webkit_dom_element_set_attribute (
WEBKIT_DOM_ELEMENT (body), "data-new-message", "", NULL);
list = webkit_dom_document_get_elements_by_class_name (document, "-x-evo-paragraph");
signature = webkit_dom_document_query_selector (document, ".-x-evo-signature-wrapper", NULL);
/* Situation when wrapped paragraph is just in signature and not in message body */
if (webkit_dom_node_list_get_length (list) == 1)
if (signature && webkit_dom_element_query_selector (signature, ".-x-evo-paragraph", NULL))
has_paragraphs_in_body = FALSE;
/*
*
* Keeping Signatures in the beginning of composer
* ------------------------------------------------
*
* Purists are gonna blast me for this.
* But there are so many people (read Outlook users) who want this.
* And Evo is an exchange-client, Outlook-replacement etc.
* So Here it goes :(
*
* -- Sankar
*
*/
if (signature && top_signature) {
WebKitDOMElement *spacer;
spacer = prepare_top_signature_spacer (editor_selection, document);
webkit_dom_node_insert_before (
WEBKIT_DOM_NODE (body),
WEBKIT_DOM_NODE (spacer),
webkit_dom_node_get_next_sibling (WEBKIT_DOM_NODE (signature)),
NULL);
}
if (webkit_dom_node_list_get_length (list) == 0)
has_paragraphs_in_body = FALSE;
element = webkit_dom_document_get_element_by_id (document, "-x-evo-input-start");
if (!signature) {
if (start_bottom) {
if (!element) {
element = prepare_paragraph (editor_selection, document);
webkit_dom_node_append_child (
WEBKIT_DOM_NODE (body),
WEBKIT_DOM_NODE (element),
NULL);
}
} else
element = WEBKIT_DOM_ELEMENT (body);
g_object_unref (list);
goto move_caret;
}
if (!has_paragraphs_in_body) {
element = prepare_paragraph (editor_selection, document);
if (top_signature) {
if (start_bottom) {
webkit_dom_node_append_child (
WEBKIT_DOM_NODE (body),
WEBKIT_DOM_NODE (element),
NULL);
} else {
webkit_dom_node_insert_before (
WEBKIT_DOM_NODE (body),
WEBKIT_DOM_NODE (element),
WEBKIT_DOM_NODE (signature),
NULL);
}
} else {
if (start_bottom)
webkit_dom_node_insert_before (
WEBKIT_DOM_NODE (body),
WEBKIT_DOM_NODE (element),
WEBKIT_DOM_NODE (signature),
NULL);
else
element = WEBKIT_DOM_ELEMENT (body);
}
} else {
if (!element && top_signature) {
element = prepare_paragraph (editor_selection, document);
if (start_bottom) {
webkit_dom_node_append_child (
WEBKIT_DOM_NODE (body),
WEBKIT_DOM_NODE (element),
NULL);
} else {
webkit_dom_node_insert_before (
WEBKIT_DOM_NODE (body),
WEBKIT_DOM_NODE (element),
WEBKIT_DOM_NODE (signature),
NULL);
}
} else if (element && top_signature && !start_bottom) {
webkit_dom_node_insert_before (
WEBKIT_DOM_NODE (body),
WEBKIT_DOM_NODE (element),
WEBKIT_DOM_NODE (signature),
NULL);
} else if (element && start_bottom) {
/* Leave it how it is */
} else
element = WEBKIT_DOM_ELEMENT (body);
}
g_object_unref (list);
move_caret:
if (element) {
WebKitDOMDOMSelection *dom_selection;
WebKitDOMDOMWindow *dom_window;
WebKitDOMRange *range;
dom_window = webkit_dom_document_get_default_view (document);
dom_selection = webkit_dom_dom_window_get_selection (dom_window);
range = webkit_dom_document_create_range (document);
webkit_dom_range_select_node_contents (
range, WEBKIT_DOM_NODE (element), NULL);
webkit_dom_range_collapse (range, TRUE, NULL);
webkit_dom_dom_selection_remove_all_ranges (dom_selection);
webkit_dom_dom_selection_add_range (dom_selection, range);
g_clear_object (&dom_selection);
g_clear_object (&dom_window);
g_clear_object (&range);
if (start_bottom)
e_html_editor_selection_scroll_to_caret (editor_selection);
}
if (start_bottom)
g_signal_connect (
view, "size-allocate",
G_CALLBACK (composer_size_allocate_cb), NULL);
e_html_editor_view_force_spell_check_in_viewport (view);
e_html_editor_selection_unblock_selection_changed (editor_selection);
}
gboolean
e_plugin_ui_init (GtkUIManager *manager,
EMsgComposer *composer)
{
EHTMLEditor *editor;
EHTMLEditorView *view;
editor = e_msg_composer_get_editor (composer);
view = e_html_editor_get_view (editor);
/* Add actions to the "composer" action group. */
gtk_action_group_add_actions (
e_html_editor_get_action_group (editor, "composer"),
entries, G_N_ELEMENTS (entries), composer);
g_signal_connect (
view, "key_press_event",
G_CALLBACK (key_press_cb), composer);
g_signal_connect (
view, "delete-event",
G_CALLBACK (delete_cb), composer);
return TRUE;
}
gboolean
e_composer_paste_text (EMsgComposer *composer,
GtkClipboard *clipboard)
{
EHTMLEditor *editor;
EHTMLEditorView *view;
EHTMLEditorSelection *editor_selection;
gchar *text;
g_return_val_if_fail (E_IS_MSG_COMPOSER (composer), FALSE);
g_return_val_if_fail (GTK_IS_CLIPBOARD (clipboard), FALSE);
if (!(text = gtk_clipboard_wait_for_text (clipboard)))
return FALSE;
editor = e_msg_composer_get_editor (composer);
view = e_html_editor_get_view (editor);
editor_selection = e_html_editor_view_get_selection (view);
/* If WebView doesn't have focus, focus it */
if (!gtk_widget_has_focus (GTK_WIDGET (view)))
gtk_widget_grab_focus (GTK_WIDGET (view));
e_html_editor_selection_insert_text (editor_selection, text);
g_free (text);
return TRUE;
}
static void
enable_disable_composer (EMsgComposer *composer,
gboolean enable)
{
EHTMLEditor *editor;
EHTMLEditorView *view;
GtkAction *action;
GtkActionGroup *action_group;
g_return_if_fail (E_IS_MSG_COMPOSER (composer));
editor = e_msg_composer_get_editor (composer);
view = e_html_editor_get_view (editor);
webkit_web_view_set_editable (WEBKIT_WEB_VIEW (view), enable);
action = E_HTML_EDITOR_ACTION_EDIT_MENU (editor);
gtk_action_set_sensitive (action, enable);
action = E_HTML_EDITOR_ACTION_FORMAT_MENU (editor);
gtk_action_set_sensitive (action, enable);
action = E_HTML_EDITOR_ACTION_INSERT_MENU (editor);
gtk_action_set_sensitive (action, enable);
action_group = e_html_editor_get_action_group (editor, "composer");
gtk_action_group_set_sensitive (action_group, enable);
}
static void
composer_setup_charset_menu (EMsgComposer *composer)
{
EHTMLEditor *editor;
GtkUIManager *ui_manager;
const gchar *path;
GList *list;
guint merge_id;
editor = e_msg_composer_get_editor (composer);
ui_manager = e_html_editor_get_ui_manager (editor);
path = "/main-menu/options-menu/charset-menu";
merge_id = gtk_ui_manager_new_merge_id (ui_manager);
list = gtk_action_group_list_actions (composer->priv->charset_actions);
list = g_list_sort (list, (GCompareFunc) e_action_compare_by_label);
while (list != NULL) {
GtkAction *action = list->data;
gtk_ui_manager_add_ui (
ui_manager, merge_id, path,
gtk_action_get_name (action),
gtk_action_get_name (action),
GTK_UI_MANAGER_AUTO, FALSE);
list = g_list_delete_link (list, list);
}
gtk_ui_manager_ensure_update (ui_manager);
}
static void
composer_set_content_editor_changed (EMsgComposer *composer)
{
EHTMLEditor *editor;
EContentEditor *cnt_editor;
editor = e_msg_composer_get_editor (composer);
cnt_editor = e_html_editor_get_content_editor (editor);
e_content_editor_set_changed (cnt_editor, TRUE);
}
static void
action_smime_sign_cb (GtkToggleAction *action,
EMsgComposer *composer)
{
EHTMLEditor *editor;
EHTMLEditorView *view;
editor = e_msg_composer_get_editor (composer);
view = e_html_editor_get_view (editor);
e_html_editor_view_set_changed (view, TRUE);
}
static void
action_save_cb (GtkAction *action,
EMsgComposer *composer)
{
EHTMLEditor *editor;
EHTMLEditorView *view;
const gchar *filename;
gint fd;
GError *error = NULL;
editor = e_msg_composer_get_editor (composer);
filename = e_html_editor_get_filename (editor);
if (filename == NULL) {
gtk_action_activate (ACTION (SAVE_AS));
return;
}
/* Check if the file already exists and we can create it. */
fd = g_open (filename, O_RDONLY | O_CREAT | O_EXCL, 0777);
if (fd < 0) {
gint errno_saved = errno;
if (g_file_test (filename, G_FILE_TEST_IS_REGULAR)) {
gint response;
response = e_alert_run_dialog_for_args (
GTK_WINDOW (composer),
E_ALERT_ASK_FILE_EXISTS_OVERWRITE,
filename, NULL);
if (response != GTK_RESPONSE_OK)
return;
} else {
e_alert_submit (
E_ALERT_SINK (composer),
E_ALERT_NO_SAVE_FILE, filename,
g_strerror (errno_saved), NULL);
return;
}
} else
close (fd);
if (!e_html_editor_save (editor, filename, TRUE, &error)) {
e_alert_submit (
E_ALERT_SINK (composer),
E_ALERT_NO_SAVE_FILE,
filename, error->message, NULL);
g_error_free (error);
return;
}
view = e_html_editor_get_view (editor);
e_html_editor_view_set_changed (view, TRUE);
}
void
e_composer_update_signature (EMsgComposer *composer)
{
EComposerHeaderTable *table;
EMailSignatureComboBox *combo_box;
EHTMLEditor *editor;
EHTMLEditorView *view;
WebKitLoadStatus status;
g_return_if_fail (E_IS_MSG_COMPOSER (composer));
/* Do nothing if we're redirecting a message or we disabled
* the signature on purpose */
if (composer->priv->redirect || composer->priv->disable_signature)
return;
table = e_msg_composer_get_header_table (composer);
combo_box = e_composer_header_table_get_signature_combo_box (table);
editor = e_msg_composer_get_editor (composer);
view = e_html_editor_get_view (editor);
status = webkit_web_view_get_load_status (WEBKIT_WEB_VIEW (view));
/* If document is not loaded, we will wait for him */
if (status != WEBKIT_LOAD_FINISHED) {
/* Disconnect previous handlers */
g_signal_handlers_disconnect_by_func (
WEBKIT_WEB_VIEW (view),
G_CALLBACK (composer_web_view_load_status_changed_cb),
composer);
g_signal_connect (
WEBKIT_WEB_VIEW(view), "notify::load-status",
G_CALLBACK (composer_web_view_load_status_changed_cb),
composer);
return;
}
/* XXX Signature files should be local and therefore load quickly,
* so while we do load them asynchronously we don't allow for
* user cancellation and we keep the composer alive until the
* asynchronous loading is complete. */
e_mail_signature_combo_box_load_selected (
combo_box, G_PRIORITY_DEFAULT, NULL,
(GAsyncReadyCallback) composer_load_signature_cb,
g_object_ref (composer));
}
static void
action_save_as_cb (GtkAction *action,
EMsgComposer *composer)
{
EHTMLEditor *editor;
GtkWidget *dialog;
gchar *filename;
gint response;
dialog = gtk_file_chooser_dialog_new (
_("Save as..."), GTK_WINDOW (composer),
GTK_FILE_CHOOSER_ACTION_SAVE,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_Save"), GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response (
GTK_DIALOG (dialog), GTK_RESPONSE_OK);
gtk_file_chooser_set_local_only (
GTK_FILE_CHOOSER (dialog), FALSE);
gtk_window_set_icon_name (
GTK_WINDOW (dialog), "mail-message-new");
response = gtk_dialog_run (GTK_DIALOG (dialog));
if (response != GTK_RESPONSE_OK)
goto exit;
editor = e_msg_composer_get_editor (composer);
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
e_html_editor_set_filename (editor, filename);
g_free (filename);
gtk_action_activate (ACTION (SAVE));
exit:
gtk_widget_destroy (dialog);
}
/* needed because the new thread needs to call g_idle_add () */
static gboolean
update_composer_text (GArray *array)
{
EMsgComposer *composer;
EHTMLEditor *editor;
EHTMLEditorView *view;
gchar *text;
composer = g_array_index (array, gpointer, 0);
text = g_array_index (array, gpointer, 1);
editor = e_msg_composer_get_editor (composer);
view = e_html_editor_get_view (editor);
e_msg_composer_set_body_text (composer, text, FALSE);
enable_composer (composer);
e_html_editor_view_set_changed (view, TRUE);
g_free (text);
return FALSE;
}
static void
composer_update_gallery_visibility (EMsgComposer *composer)
{
EHTMLEditor *editor;
EHTMLEditorView *view;
GtkToggleAction *toggle_action;
gboolean gallery_active;
gboolean is_html;
editor = e_msg_composer_get_editor (composer);
view = e_html_editor_get_view (editor);
is_html = e_html_editor_view_get_html_mode (view);
toggle_action = GTK_TOGGLE_ACTION (ACTION (PICTURE_GALLERY));
gallery_active = gtk_toggle_action_get_active (toggle_action);
if (is_html && gallery_active) {
gtk_widget_show (composer->priv->gallery_scrolled_window);
gtk_widget_show (composer->priv->gallery_icon_view);
} else {
gtk_widget_hide (composer->priv->gallery_scrolled_window);
gtk_widget_hide (composer->priv->gallery_icon_view);
}
}
static gpointer
external_editor_thread (gpointer user_data)
{
EMsgComposer *composer = user_data;
gchar *filename = NULL;
gint status = 0;
GSettings *settings;
gchar *editor_cmd_line = NULL, *editor_cmd = NULL, *content;
gint fd, position = -1, offset = -1;
EHTMLEditor *editor;
EHTMLEditorView *view;
editor = e_msg_composer_get_editor (composer);
view = e_html_editor_get_view (editor);
/* prefix temp files with evo so .*vimrc can be setup to recognize them */
fd = g_file_open_tmp ("evoXXXXXX", &filename, NULL);
if (fd > 0) {
close (fd);
d (printf ("\n\aTemporary-file Name is : [%s] \n\a", filename));
/* Push the text (if there is one) from the composer to the file */
content = e_html_editor_view_get_text_plain (view);
g_file_set_contents (filename, content, strlen (content), NULL);
} else {
struct run_error_dialog_data *data;
data = g_new0 (struct run_error_dialog_data, 1);
data->composer = composer;
data->text = "org.gnome.evolution.plugins.external-editor:no-temp-file";
g_warning ("Temporary file fd is null");
/* run_error_dialog also calls enable_composer */
g_idle_add ((GSourceFunc) run_error_dialog, data);
goto finished;
}
settings = g_settings_new ("org.gnome.evolution.plugin.external-editor");
editor_cmd = g_settings_get_string (settings, "command");
if (!editor_cmd) {
if (!(editor_cmd = g_strdup (g_getenv ("EDITOR"))) )
/* Make gedit the default external editor,
* if the default schemas are not installed
* and no $EDITOR is set. */
editor_cmd = g_strdup ("gedit");
}
g_object_unref (settings);
if (g_strrstr (editor_cmd, "vim") != NULL &&
((position = get_caret_position (view)) > 0)) {
gchar *tmp = editor_cmd;
gint lineno;
gboolean set_nofork;
set_nofork = g_strrstr (editor_cmd, "gvim") != NULL;
/* Increment 1 so that entering vim insert mode places you
* in the same entry position you were at in the html. */
offset++;
/* calculate the line number that the cursor is in */
lineno = numlines (content, position);
editor_cmd = g_strdup_printf (
"%s \"+call cursor(%d,%d)\"%s%s",
tmp, lineno, offset,
set_nofork ? " " : "",
set_nofork ? "--nofork" : "");
g_free (tmp);
}
g_free (content);
editor_cmd_line = g_strconcat (editor_cmd, " ", filename, NULL);
if (!g_spawn_command_line_sync (editor_cmd_line, NULL, NULL, &status, NULL)) {
struct run_error_dialog_data *data;
g_warning ("Unable to launch %s: ", editor_cmd_line);
data = g_new0 (struct run_error_dialog_data, 1);
data->composer = composer;
data->text = "org.gnome.evolution.plugins.external-editor:editor-not-launchable";
/* run_error_dialog also calls enable_composer */
g_idle_add ((GSourceFunc) run_error_dialog, data);
g_free (filename);
g_free (editor_cmd_line);
g_free (editor_cmd);
goto finished;
}
g_free (editor_cmd_line);
g_free (editor_cmd);
#ifdef HAVE_SYS_WAIT_H
if (WEXITSTATUS (status) != 0) {
#else
if (status) {
#endif
d (printf ("\n\nsome problem here with external editor\n\n"));
g_idle_add ((GSourceFunc) enable_composer, composer);
goto finished;
} else {
gchar *buf;
if (g_file_get_contents (filename, &buf, NULL, NULL)) {
gchar *htmltext;
GArray *array;
htmltext = camel_text_to_html (
buf, CAMEL_MIME_FILTER_TOHTML_PRE, 0);
array = g_array_sized_new (
TRUE, TRUE,
sizeof (gpointer), 2 * sizeof (gpointer));
array = g_array_append_val (array, composer);
array = g_array_append_val (array, htmltext);
g_idle_add ((GSourceFunc) update_composer_text, array);
/* We no longer need that temporary file */
if (g_remove (filename) == -1)
g_warning (
"%s: Failed to remove file '%s': %s",
G_STRFUNC, filename, g_strerror (errno));
g_free (filename);
}
}
finished:
g_mutex_lock (&external_editor_running_lock);
external_editor_running = FALSE;
g_mutex_unlock (&external_editor_running_lock);
return NULL;
}
static void launch_editor (GtkAction *action, EMsgComposer *composer)
{
d (printf ("\n\nexternal_editor plugin is launched \n\n"));
if (editor_running ()) {
d (printf ("not opening editor, because it's still running\n"));
return;
}
disable_composer (composer);
g_mutex_lock (&external_editor_running_lock);
external_editor_running = TRUE;
g_mutex_unlock (&external_editor_running_lock);
editor_thread = g_thread_new (
NULL, external_editor_thread, composer);
g_thread_unref (editor_thread);
}
void
e_composer_actions_init (EMsgComposer *composer)
{
GtkActionGroup *action_group;
GtkAccelGroup *accel_group;
GtkUIManager *ui_manager;
EHTMLEditor *editor;
EContentEditor *cnt_editor;
gboolean visible;
GIcon *gcr_gnupg_icon;
g_return_if_fail (E_IS_MSG_COMPOSER (composer));
editor = e_msg_composer_get_editor (composer);
cnt_editor = e_html_editor_get_content_editor (editor);
ui_manager = e_html_editor_get_ui_manager (editor);
/* Composer Actions */
action_group = composer->priv->composer_actions;
gtk_action_group_set_translation_domain (
action_group, GETTEXT_PACKAGE);
gtk_action_group_add_actions (
action_group, entries,
G_N_ELEMENTS (entries), composer);
gtk_action_group_add_toggle_actions (
action_group, toggle_entries,
G_N_ELEMENTS (toggle_entries), composer);
gtk_ui_manager_insert_action_group (ui_manager, action_group, 0);
/* Asynchronous Actions */
action_group = composer->priv->async_actions;
gtk_action_group_set_translation_domain (
action_group, GETTEXT_PACKAGE);
gtk_action_group_add_actions (
action_group, async_entries,
G_N_ELEMENTS (async_entries), composer);
gtk_ui_manager_insert_action_group (ui_manager, action_group, 0);
/* Character Set Actions */
action_group = composer->priv->charset_actions;
gtk_action_group_set_translation_domain (
action_group, GETTEXT_PACKAGE);
e_charset_add_radio_actions (
action_group, "charset-", composer->priv->charset,
G_CALLBACK (action_charset_cb), composer);
gtk_ui_manager_insert_action_group (ui_manager, action_group, 0);
/* Fine Tuning */
g_object_set (
ACTION (ATTACH), "short-label", _("Attach"), NULL);
g_object_set (
ACTION (PICTURE_GALLERY), "is-important", TRUE, NULL);
g_object_set (
ACTION (SAVE_DRAFT), "short-label", _("Save Draft"), NULL);
#define init_toolbar_option(x, always_visible) \
gtk_action_set_visible (ACTION (TOOLBAR_ ## x), always_visible); \
e_binding_bind_property ( \
ACTION (x), "active", \
ACTION (TOOLBAR_ ## x), "active", \
G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL); \
e_binding_bind_property ( \
ACTION (x), "label", \
ACTION (TOOLBAR_ ## x), "label", \
G_BINDING_SYNC_CREATE); \
e_binding_bind_property ( \
ACTION (x), "tooltip", \
ACTION (TOOLBAR_ ## x), "tooltip", \
G_BINDING_SYNC_CREATE); \
e_binding_bind_property ( \
ACTION (x), "sensitive", \
ACTION (TOOLBAR_ ## x), "sensitive", \
G_BINDING_SYNC_CREATE); \
g_signal_connect (ACTION (TOOLBAR_ ## x), "toggled", \
G_CALLBACK (composer_actions_toolbar_option_toggled_cb), composer);
init_toolbar_option (PGP_SIGN, FALSE);
init_toolbar_option (PGP_ENCRYPT, FALSE);
init_toolbar_option (PRIORITIZE_MESSAGE, TRUE);
init_toolbar_option (REQUEST_READ_RECEIPT, TRUE);
init_toolbar_option (SMIME_SIGN, FALSE);
init_toolbar_option (SMIME_ENCRYPT, FALSE);
#undef init_toolbar_option
/* Borrow a GnuPG icon from gcr to distinguish between GPG and S/MIME Sign/Encrypt actions */
gcr_gnupg_icon = g_themed_icon_new ("gcr-gnupg");
if (gcr_gnupg_icon) {
GIcon *temp_icon;
GIcon *action_icon;
GEmblem *emblem;
GtkAction *action;
emblem = g_emblem_new (gcr_gnupg_icon);
action = ACTION (TOOLBAR_PGP_SIGN);
action_icon = g_themed_icon_new (gtk_action_get_icon_name (action));
temp_icon = g_emblemed_icon_new (action_icon, emblem);
g_object_unref (action_icon);
gtk_action_set_gicon (action, temp_icon);
g_object_unref (temp_icon);
action = ACTION (TOOLBAR_PGP_ENCRYPT);
action_icon = g_themed_icon_new (gtk_action_get_icon_name (action));
temp_icon = g_emblemed_icon_new (action_icon, emblem);
g_object_unref (action_icon);
gtk_action_set_gicon (action, temp_icon);
g_object_unref (temp_icon);
g_object_unref (emblem);
g_object_unref (gcr_gnupg_icon);
}
e_binding_bind_property (
cnt_editor, "html-mode",
ACTION (PICTURE_GALLERY), "sensitive",
G_BINDING_SYNC_CREATE);
e_binding_bind_property (
cnt_editor, "editable",
e_html_editor_get_action (editor, "edit-menu"), "sensitive",
G_BINDING_SYNC_CREATE);
e_binding_bind_property (
cnt_editor, "editable",
e_html_editor_get_action (editor, "format-menu"), "sensitive",
G_BINDING_SYNC_CREATE);
e_binding_bind_property (
cnt_editor, "editable",
e_html_editor_get_action (editor, "insert-menu"), "sensitive",
G_BINDING_SYNC_CREATE);
e_binding_bind_property (
cnt_editor, "editable",
e_html_editor_get_action (editor, "options-menu"), "sensitive",
G_BINDING_SYNC_CREATE);
e_binding_bind_property (
cnt_editor, "editable",
e_html_editor_get_action (editor, "picture-gallery"), "sensitive",
G_BINDING_SYNC_CREATE);
#if defined (ENABLE_SMIME)
visible = TRUE;
#else
visible = FALSE;
#endif
gtk_action_set_visible (ACTION (SMIME_ENCRYPT), visible);
gtk_action_set_visible (ACTION (SMIME_SIGN), visible);
accel_group = gtk_ui_manager_get_accel_group (ui_manager);
g_signal_connect (accel_group, "accel-activate",
G_CALLBACK (composer_actions_accel_activate_cb), composer);
}
void
e_composer_private_constructed (EMsgComposer *composer)
{
EMsgComposerPrivate *priv = composer->priv;
EFocusTracker *focus_tracker;
EComposerHeader *header;
EShell *shell;
EClientCache *client_cache;
EHTMLEditor *editor;
EHTMLEditorView *view;
GtkUIManager *ui_manager;
GtkAction *action;
GtkWidget *container;
GtkWidget *widget;
GtkWidget *send_widget;
GtkWindow *window;
GSettings *settings;
const gchar *path;
gchar *filename, *gallery_path;
gint ii;
GError *error = NULL;
editor = e_msg_composer_get_editor (composer);
ui_manager = e_html_editor_get_ui_manager (editor);
view = e_html_editor_get_view (editor);
settings = e_util_ref_settings ("org.gnome.evolution.mail");
shell = e_msg_composer_get_shell (composer);
client_cache = e_shell_get_client_cache (shell);
/* Each composer window gets its own window group. */
window = GTK_WINDOW (composer);
priv->window_group = gtk_window_group_new ();
gtk_window_group_add_window (priv->window_group, window);
priv->async_actions = gtk_action_group_new ("async");
priv->charset_actions = gtk_action_group_new ("charset");
priv->composer_actions = gtk_action_group_new ("composer");
priv->extra_hdr_names = g_ptr_array_new ();
priv->extra_hdr_values = g_ptr_array_new ();
priv->charset = e_composer_get_default_charset ();
priv->is_from_new_message = FALSE;
priv->set_signature_from_message = FALSE;
priv->disable_signature = FALSE;
priv->busy = FALSE;
priv->saved_editable = FALSE;
priv->drop_occured = FALSE;
priv->dnd_is_uri = FALSE;
priv->check_if_signature_is_changed = FALSE;
priv->ignore_next_signature_change = FALSE;
priv->dnd_history_saved = FALSE;
priv->focused_entry = NULL;
e_composer_actions_init (composer);
filename = e_composer_find_data_file ("evolution-composer.ui");
gtk_ui_manager_add_ui_from_file (ui_manager, filename, &error);
g_free (filename);
/* We set the send button as important to have a label */
path = "/main-toolbar/pre-main-toolbar/send";
send_widget = gtk_ui_manager_get_widget (ui_manager, path);
gtk_tool_item_set_is_important (GTK_TOOL_ITEM (send_widget), TRUE);
composer_setup_charset_menu (composer);
if (error != NULL) {
/* Henceforth, bad things start happening. */
g_critical ("%s", error->message);
g_clear_error (&error);
}
/* Configure an EFocusTracker to manage selection actions. */
focus_tracker = e_focus_tracker_new (GTK_WINDOW (composer));
action = e_html_editor_get_action (editor, "cut");
e_focus_tracker_set_cut_clipboard_action (focus_tracker, action);
action = e_html_editor_get_action (editor, "copy");
e_focus_tracker_set_copy_clipboard_action (focus_tracker, action);
action = e_html_editor_get_action (editor, "paste");
e_focus_tracker_set_paste_clipboard_action (focus_tracker, action);
action = e_html_editor_get_action (editor, "select-all");
e_focus_tracker_set_select_all_action (focus_tracker, action);
action = e_html_editor_get_action (editor, "undo");
e_focus_tracker_set_undo_action (focus_tracker, action);
action = e_html_editor_get_action (editor, "redo");
e_focus_tracker_set_redo_action (focus_tracker, action);
priv->focus_tracker = focus_tracker;
widget = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (composer), widget);
gtk_widget_show (widget);
container = widget;
/* Construct the main menu and toolbar. */
widget = e_html_editor_get_managed_widget (editor, "/main-menu");
gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0);
gtk_widget_show (widget);
widget = e_html_editor_get_managed_widget (editor, "/main-toolbar");
gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0);
gtk_widget_show (widget);
/* Construct the header table. */
widget = e_composer_header_table_new (client_cache);
gtk_container_set_border_width (GTK_CONTAINER (widget), 6);
gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0);
priv->header_table = g_object_ref (widget);
gtk_widget_show (widget);
header = e_composer_header_table_get_header (
E_COMPOSER_HEADER_TABLE (widget),
E_COMPOSER_HEADER_SUBJECT);
e_binding_bind_property (
view, "spell-checker",
header->input_widget, "spell-checker",
G_BINDING_SYNC_CREATE);
/* Construct the editing toolbars. We'll have to reparent
* the embedded EHTMLEditorView a little further down. */
widget = GTK_WIDGET (editor);
gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0);
gtk_widget_show (widget);
/* Construct the attachment paned. */
widget = e_attachment_paned_new ();
gtk_box_pack_start (GTK_BOX (container), widget, TRUE, TRUE, 0);
priv->attachment_paned = g_object_ref_sink (widget);
gtk_widget_show (widget);
e_binding_bind_property (
view, "editable",
widget, "sensitive",
G_BINDING_SYNC_CREATE);
container = e_attachment_paned_get_content_area (
E_ATTACHMENT_PANED (priv->attachment_paned));
widget = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
gtk_box_pack_start (GTK_BOX (container), widget, TRUE, TRUE, 0);
gtk_widget_show (widget);
container = widget;
widget = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (
GTK_SCROLLED_WINDOW (widget),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_set_size_request (widget, -1, GALLERY_INITIAL_HEIGHT);
gtk_paned_pack1 (GTK_PANED (container), widget, FALSE, FALSE);
priv->gallery_scrolled_window = g_object_ref (widget);
gtk_widget_show (widget);
/* Reparent the scrolled window containing the web view
* widget into the content area of the top attachment pane. */
widget = GTK_WIDGET (view);
widget = gtk_widget_get_parent (widget);
gtk_widget_reparent (widget, container);
/* Construct the picture gallery. */
container = priv->gallery_scrolled_window;
/* FIXME This should be an EMsgComposer property. */
gallery_path = g_settings_get_string (
settings, "composer-gallery-path");
widget = e_picture_gallery_new (gallery_path);
gtk_container_add (GTK_CONTAINER (container), widget);
priv->gallery_icon_view = g_object_ref_sink (widget);
g_free (gallery_path);
e_signal_connect_notify_swapped (
view, "notify::mode",
G_CALLBACK (composer_update_gallery_visibility), composer);
g_signal_connect_swapped (
ACTION (PICTURE_GALLERY), "toggled",
G_CALLBACK (composer_update_gallery_visibility), composer);
/* Initial sync */
composer_update_gallery_visibility (composer);
/* Bind headers to their corresponding actions. */
for (ii = 0; ii < E_COMPOSER_NUM_HEADERS; ii++) {
EComposerHeaderTable *table;
EComposerHeader *header;
GtkAction *action;
table = E_COMPOSER_HEADER_TABLE (priv->header_table);
header = e_composer_header_table_get_header (table, ii);
switch (ii) {
case E_COMPOSER_HEADER_FROM:
e_widget_undo_attach (
GTK_WIDGET (e_composer_from_header_get_name_entry (E_COMPOSER_FROM_HEADER (header))),
focus_tracker);
e_widget_undo_attach (
GTK_WIDGET (e_composer_from_header_get_address_entry (E_COMPOSER_FROM_HEADER (header))),
focus_tracker);
action = ACTION (VIEW_FROM_OVERRIDE);
e_binding_bind_property (
header, "override-visible",
action, "active",
G_BINDING_BIDIRECTIONAL |
G_BINDING_SYNC_CREATE);
continue;
case E_COMPOSER_HEADER_BCC:
action = ACTION (VIEW_BCC);
break;
case E_COMPOSER_HEADER_CC:
action = ACTION (VIEW_CC);
break;
case E_COMPOSER_HEADER_REPLY_TO:
action = ACTION (VIEW_REPLY_TO);
e_widget_undo_attach (
GTK_WIDGET (header->input_widget),
focus_tracker);
break;
case E_COMPOSER_HEADER_SUBJECT:
e_widget_undo_attach (
GTK_WIDGET (header->input_widget),
focus_tracker);
continue;
default:
continue;
}
e_binding_bind_property (
header, "sensitive",
action, "sensitive",
G_BINDING_BIDIRECTIONAL |
G_BINDING_SYNC_CREATE);
e_binding_bind_property (
header, "visible",
action, "active",
G_BINDING_BIDIRECTIONAL |
G_BINDING_SYNC_CREATE);
}
/* Disable actions that start asynchronous activities while an
* asynchronous activity is in progress. We enforce this with
* a simple inverted binding to EMsgComposer's "busy" property. */
e_binding_bind_property (
composer, "busy",
priv->async_actions, "sensitive",
G_BINDING_SYNC_CREATE |
G_BINDING_INVERT_BOOLEAN);
e_binding_bind_property (
composer, "busy",
priv->header_table, "sensitive",
G_BINDING_SYNC_CREATE |
G_BINDING_INVERT_BOOLEAN);
g_object_unref (settings);
}
gboolean
e_composer_paste_image (EMsgComposer *composer,
GtkClipboard *clipboard)
{
EHTMLEditor *editor;
EHTMLEditorView *html_editor_view;
EAttachmentStore *store;
EAttachmentView *view;
GdkPixbuf *pixbuf = NULL;
gchar *filename = NULL;
gchar *uri = NULL;
gboolean success = FALSE;
GError *error = NULL;
g_return_val_if_fail (E_IS_MSG_COMPOSER (composer), FALSE);
g_return_val_if_fail (GTK_IS_CLIPBOARD (clipboard), FALSE);
view = e_msg_composer_get_attachment_view (composer);
store = e_attachment_view_get_store (view);
/* Extract the image data from the clipboard. */
pixbuf = gtk_clipboard_wait_for_image (clipboard);
g_return_val_if_fail (pixbuf != NULL, FALSE);
/* Reserve a temporary file. */
filename = e_mktemp (NULL);
if (filename == NULL) {
g_set_error (
&error, G_FILE_ERROR,
g_file_error_from_errno (errno),
"Could not create temporary file: %s",
g_strerror (errno));
goto exit;
}
/* Save the pixbuf as a temporary file in image/png format. */
if (!gdk_pixbuf_save (pixbuf, filename, "png", &error, NULL))
goto exit;
/* Convert the filename to a URI. */
uri = g_filename_to_uri (filename, NULL, &error);
if (uri == NULL)
goto exit;
/* In HTML mode, paste the image into the message body.
* In text mode, add the image to the attachment store. */
editor = e_msg_composer_get_editor (composer);
html_editor_view = e_html_editor_get_view (editor);
if (e_html_editor_view_get_html_mode (html_editor_view)) {
EHTMLEditorSelection *selection;
selection = e_html_editor_view_get_selection (html_editor_view);
e_html_editor_selection_insert_image (selection, uri);
e_html_editor_selection_scroll_to_caret (selection);
} else {
EAttachment *attachment;
attachment = e_attachment_new_for_uri (uri);
e_attachment_store_add_attachment (store, attachment);
e_attachment_load_async (
attachment, (GAsyncReadyCallback)
e_attachment_load_handle_error, composer);
g_object_unref (attachment);
}
success = TRUE;
exit:
if (error != NULL) {
g_warning ("%s", error->message);
g_error_free (error);
}
g_object_unref (pixbuf);
g_free (filename);
g_free (uri);
return success;
}
static void
composer_load_signature_cb (EMailSignatureComboBox *combo_box,
GAsyncResult *result,
EMsgComposer *composer)
{
GString *html_buffer = NULL;
gchar *contents = NULL;
gsize length = 0;
const gchar *active_id;
gboolean top_signature, is_html, html_mode;
gboolean start_bottom, is_message_from_edit_as_new;
GError *error = NULL;
EHTMLEditor *editor;
EHTMLEditorView *view;
WebKitDOMDocument *document;
WebKitDOMElement *element = NULL;
WebKitDOMNodeList *signatures;
gulong list_length, ii;
GSettings *settings;
e_mail_signature_combo_box_load_selected_finish (
combo_box, result, &contents, &length, &is_html, &error);
/* FIXME Use an EAlert here. */
if (error != NULL) {
g_warning ("%s: %s", G_STRFUNC, error->message);
g_error_free (error);
goto exit;
}
if (composer->priv->ignore_next_signature_change) {
composer->priv->ignore_next_signature_change = FALSE;
goto exit;
}
editor = e_msg_composer_get_editor (composer);
view = e_html_editor_get_view (editor);
is_message_from_edit_as_new =
e_html_editor_view_is_message_from_edit_as_new (view);
/* "Edit as New Message" sets is_message_from_edit_as_new.
* Always put the signature at the bottom for that case. */
top_signature =
use_top_signature (composer) &&
!is_message_from_edit_as_new &&
!composer->priv->is_from_new_message;
settings = e_util_ref_settings ("org.gnome.evolution.mail");
start_bottom = g_settings_get_boolean (settings, "composer-reply-start-bottom");
g_object_unref (settings);
document = webkit_web_view_get_dom_document (WEBKIT_WEB_VIEW (view));
html_mode = e_html_editor_view_get_html_mode (view);
if (contents == NULL)
goto insert;
/* If inserting HTML signature in plain text composer we have to convert it. */
if (is_html && !html_mode) {
WebKitDOMElement *tmp_element;
gchar *inner_text;
tmp_element = webkit_dom_document_create_element (document, "div", NULL);
webkit_dom_html_element_set_inner_html (
WEBKIT_DOM_HTML_ELEMENT (tmp_element), contents, NULL);
inner_text = webkit_dom_html_element_get_inner_text (
WEBKIT_DOM_HTML_ELEMENT (tmp_element));
g_free (contents);
contents = inner_text ? g_strstrip (inner_text) : g_strdup ("");
is_html = FALSE;
}
if (!is_html) {
gchar *html;
html = camel_text_to_html (contents, 0, 0);
if (html) {
g_free (contents);
contents = html;
length = strlen (contents);
}
}
/* Generate HTML code for the signature. */
html_buffer = g_string_sized_new (1024);
/* The combo box active ID is the signature's ESource UID. */
active_id = gtk_combo_box_get_active_id (GTK_COMBO_BOX (combo_box));
g_string_append_printf (
html_buffer,
"<SPAN class=\"-x-evo-signature\" id=\"1\" name=\"%s\">",
(active_id != NULL) ? active_id : "");
if (!is_html)
g_string_append (html_buffer, "<PRE>");
/* The signature dash convention ("-- \n") is specified
* in the "Son of RFC 1036", section 4.3.2.
* http://www.chemie.fu-berlin.de/outerspace/netnews/son-of-1036.html
*/
if (add_signature_delimiter (composer)) {
const gchar *delim;
const gchar *delim_nl;
if (is_html) {
delim = "-- <BR>";
delim_nl = "\n-- <BR>";
} else {
delim = "-- \n";
delim_nl = "\n-- \n";
}
/* Skip the delimiter if the signature already has one. */
if (g_ascii_strncasecmp (contents, delim, strlen (delim)) == 0)
; /* skip */
else if (e_util_strstrcase (contents, delim_nl) != NULL)
; /* skip */
else
g_string_append (html_buffer, delim);
}
g_string_append_len (html_buffer, contents, length);
if (!is_html)
g_string_append (html_buffer, "</PRE>");
g_string_append (html_buffer, "</SPAN>");
g_free (contents);
insert:
/* Remove the old signature and insert the new one. */
signatures = webkit_dom_document_get_elements_by_class_name (
document, "-x-evo-signature-wrapper");
list_length = webkit_dom_node_list_get_length (signatures);
for (ii = 0; ii < list_length; ii++) {
WebKitDOMNode *wrapper, *signature;
gchar *id;
wrapper = webkit_dom_node_list_item (signatures, ii);
signature = webkit_dom_node_get_first_child (wrapper);
/* When we are editing a message with signature, we need to unset the
* active signature id as if the signature in the message was edited
* by the user we would discard these changes. */
if (composer->priv->set_signature_from_message &&
(is_message_from_edit_as_new || e_html_editor_view_is_message_from_draft (view))) {
if (composer->priv->check_if_signature_is_changed) {
if (html_buffer && *html_buffer->str) {
gchar *body_signature_text, *signature_text;
element = webkit_dom_document_create_element (document, "div", NULL);
webkit_dom_html_element_set_inner_html (
WEBKIT_DOM_HTML_ELEMENT (element), html_buffer->str, NULL);
body_signature_text = webkit_dom_html_element_get_inner_text (
WEBKIT_DOM_HTML_ELEMENT (signature));
signature_text = webkit_dom_html_element_get_inner_text (
WEBKIT_DOM_HTML_ELEMENT (element));
/* Signature in the body is different than the one with the
* same id, so set the active signature to None and leave
* the signature that is in the body. */
if (g_strcmp0 (body_signature_text, signature_text) != 0) {
gtk_combo_box_set_active (GTK_COMBO_BOX (combo_box), 0);
composer->priv->ignore_next_signature_change = TRUE;
}
g_free (body_signature_text);
g_free (signature_text);
} else {
gtk_combo_box_set_active (GTK_COMBO_BOX (combo_box), 0);
composer->priv->ignore_next_signature_change = TRUE;
}
composer->priv->check_if_signature_is_changed = FALSE;
composer->priv->set_signature_from_message = FALSE;
} else {
gchar *name;
/* Load the signature and check if is it the same
* as the signature in body or the user previously
* changed it. */
name = webkit_dom_element_get_attribute (WEBKIT_DOM_ELEMENT (signature), "name");
gtk_combo_box_set_active_id (GTK_COMBO_BOX (combo_box), name);
g_free (name);
composer->priv->check_if_signature_is_changed = TRUE;
}
g_object_unref (wrapper);
g_object_unref (signatures);
g_object_unref (composer);
return;
}
id = webkit_dom_element_get_id (WEBKIT_DOM_ELEMENT (signature));
if (id && (strlen (id) == 1) && (*id == '1')) {
/* If the top signature was set we have to remove the NL
* that was inserted after it */
if (top_signature) {
WebKitDOMElement *spacer;
spacer = webkit_dom_document_query_selector (
document, ".-x-evo-top-signature-spacer", NULL);
if (spacer)
remove_node_if_empty (WEBKIT_DOM_NODE (spacer));
}
/* We have to remove the div containing the span with signature */
remove_node (wrapper);
g_object_unref (wrapper);
g_free (id);
break;
}
g_object_unref (wrapper);
g_free (id);
}
g_object_unref (signatures);
if (html_buffer != NULL) {
if (*html_buffer->str) {
WebKitDOMHTMLElement *body;
body = webkit_dom_document_get_body (document);
if (!element) {
element = webkit_dom_document_create_element (document, "DIV", NULL);
webkit_dom_html_element_set_inner_html (
WEBKIT_DOM_HTML_ELEMENT (element), html_buffer->str, NULL);
}
webkit_dom_element_set_class_name (element, "-x-evo-signature-wrapper");
if (top_signature) {
WebKitDOMNode *child =
webkit_dom_node_get_first_child (WEBKIT_DOM_NODE (body));
if (start_bottom) {
webkit_dom_node_insert_before (
WEBKIT_DOM_NODE (body),
WEBKIT_DOM_NODE (element),
child,
NULL);
} else {
/* When we are using signature on top the caret
* should be before the signature */
webkit_dom_node_insert_before (
WEBKIT_DOM_NODE (body),
WEBKIT_DOM_NODE (element),
child,
NULL);
}
} else {
webkit_dom_node_append_child (
WEBKIT_DOM_NODE (body),
WEBKIT_DOM_NODE (element),
NULL);
}
}
g_string_free (html_buffer, TRUE);
}
if (is_html && html_mode)
e_html_editor_view_fix_file_uri_images (view);
composer_move_caret (composer);
exit:
/* Make sure the flag will be unset and won't influence user's choice */
composer->priv->set_signature_from_message = FALSE;
g_object_unref (composer);
}
void
e_composer_actions_init (EMsgComposer *composer)
{
GtkActionGroup *action_group;
GtkAccelGroup *accel_group;
GtkUIManager *ui_manager;
EHTMLEditor *editor;
EHTMLEditorView *view;
gboolean visible;
g_return_if_fail (E_IS_MSG_COMPOSER (composer));
editor = e_msg_composer_get_editor (composer);
view = e_html_editor_get_view (editor);
ui_manager = e_html_editor_get_ui_manager (editor);
/* Composer Actions */
action_group = composer->priv->composer_actions;
gtk_action_group_set_translation_domain (
action_group, GETTEXT_PACKAGE);
gtk_action_group_add_actions (
action_group, entries,
G_N_ELEMENTS (entries), composer);
gtk_action_group_add_toggle_actions (
action_group, toggle_entries,
G_N_ELEMENTS (toggle_entries), composer);
gtk_ui_manager_insert_action_group (ui_manager, action_group, 0);
/* Asynchronous Actions */
action_group = composer->priv->async_actions;
gtk_action_group_set_translation_domain (
action_group, GETTEXT_PACKAGE);
gtk_action_group_add_actions (
action_group, async_entries,
G_N_ELEMENTS (async_entries), composer);
gtk_ui_manager_insert_action_group (ui_manager, action_group, 0);
/* Character Set Actions */
action_group = composer->priv->charset_actions;
gtk_action_group_set_translation_domain (
action_group, GETTEXT_PACKAGE);
e_charset_add_radio_actions (
action_group, "charset-", composer->priv->charset,
G_CALLBACK (action_charset_cb), composer);
gtk_ui_manager_insert_action_group (ui_manager, action_group, 0);
/* Fine Tuning */
g_object_set (
ACTION (ATTACH), "short-label", _("Attach"), NULL);
g_object_set (
ACTION (PICTURE_GALLERY), "is-important", TRUE, NULL);
g_object_set (
ACTION (SAVE_DRAFT), "short-label", _("Save Draft"), NULL);
g_object_bind_property (
view, "html-mode",
ACTION (PICTURE_GALLERY), "sensitive",
G_BINDING_SYNC_CREATE);
g_object_bind_property (
view, "editable",
e_html_editor_get_action (editor, "edit-menu"), "sensitive",
G_BINDING_SYNC_CREATE);
g_object_bind_property (
view, "editable",
e_html_editor_get_action (editor, "format-menu"), "sensitive",
G_BINDING_SYNC_CREATE);
g_object_bind_property (
view, "editable",
e_html_editor_get_action (editor, "insert-menu"), "sensitive",
G_BINDING_SYNC_CREATE);
g_object_bind_property (
view, "editable",
e_html_editor_get_action (editor, "options-menu"), "sensitive",
G_BINDING_SYNC_CREATE);
g_object_bind_property (
view, "editable",
e_html_editor_get_action (editor, "picture-gallery"), "sensitive",
G_BINDING_SYNC_CREATE);
#if defined (HAVE_NSS)
visible = TRUE;
#else
visible = FALSE;
#endif
gtk_action_set_visible (ACTION (SMIME_ENCRYPT), visible);
gtk_action_set_visible (ACTION (SMIME_SIGN), visible);
accel_group = gtk_ui_manager_get_accel_group (ui_manager);
g_signal_connect (accel_group, "accel-activate",
G_CALLBACK (composer_actions_accel_activate_cb), composer);
}
