src/plugins/managesieve/sieve_editor.c

   1 /*
   2  * Claws Mail -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 2004-2015 the Claws Mail team
   4  * Copyright (C) 2014-2015 Charles Lehner
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  18  *
  19  */
  20
  21 #ifdef HAVE_CONFIG_H
  22 #include "config.h"
  23 #include "claws-features.h"
  24 #endif
  25
  26 #include <gtk/gtk.h>
  27 #include <glib.h>
  28 #include <glib/gi18n.h>
  29
  30 #include "defs.h"
  31 #include "gtk/gtkutils.h"
  32 #include "gtk/combobox.h"
  33 #include "gtk/manage_window.h"
  34 #include "alertpanel.h"
  35 #include "undo.h"
  36 #include "menu.h"
  37 #include "utils.h"
  38 #include "prefs.h"
  39 #include "prefs_common.h"
  40 #include "account.h"
  41 #include "mainwindow.h"
  42 #include "message_search.h"
  43 #include "managesieve.h"
  44 #include "sieve_manager.h"
  45 #include "sieve_editor.h"
  46
  47 GSList *editors = NULL;
  48
  49 static void sieve_editor_destroy(SieveEditorPage *page);
  50
  51 void sieve_editor_set_position(void *obj, gint pos);
  52 gboolean sieve_editor_search_string(void *obj,
  53         const gchar *str, gboolean case_sens);
  54 gboolean sieve_editor_search_string_backward(void *obj,
  55         const gchar *str, gboolean case_sens);
  56 static void sieve_editor_save_cb(GtkAction *action, SieveEditorPage *page);
  57 static void sieve_editor_check_cb(GtkAction *action, SieveEditorPage *page);
  58 static void sieve_editor_changed_cb(GtkTextBuffer *, SieveEditorPage *page);
  59 static void sieve_editor_revert_cb(GtkAction *action, SieveEditorPage *page);
  60 static void sieve_editor_close_cb(GtkAction *action, SieveEditorPage *page);
  61 static void sieve_editor_undo_cb(GtkAction *action, SieveEditorPage *page);
  62 static void sieve_editor_redo_cb(GtkAction *action, SieveEditorPage *page);
  63 static void sieve_editor_cut_cb(GtkAction *action, SieveEditorPage *page);
  64 static void sieve_editor_copy_cb(GtkAction *action, SieveEditorPage *page);
  65 static void sieve_editor_paste_cb(GtkAction *action, SieveEditorPage *page);
  66 static void sieve_editor_allsel_cb(GtkAction *action, SieveEditorPage *page);
  67 static void sieve_editor_find_cb(GtkAction *action, SieveEditorPage *page);
  68 static void sieve_editor_set_modified(SieveEditorPage *page,
  69                 gboolean modified);
  70
  71 static SearchInterface search_interface = {
  72         .set_position = sieve_editor_set_position,
  73         .search_string_backward = sieve_editor_search_string_backward,
  74         .search_string = sieve_editor_search_string,
  75 };
  76
  77 static GtkActionEntry sieve_editor_entries[] =
  78 {
  79         {"Menu",                                NULL, "Menu" },
  80 /* menus */
  81         {"Filter",                      NULL, N_("_Filter") },
  82         {"Edit",                        NULL, N_("_Edit") },
  83 /* Filter menu */
  84
  85         {"Filter/Save",         NULL, N_("_Save"), "<control>S", NULL, G_CALLBACK(sieve_editor_save_cb) },
  86         {"Filter/CheckSyntax",          NULL, N_("Chec_k Syntax"), "<control>K", NULL, G_CALLBACK(sieve_editor_check_cb) },
  87         {"Filter/Revert",               NULL, N_("Re_vert"), NULL, NULL, G_CALLBACK(sieve_editor_revert_cb) },
  88         {"Filter/Close",                NULL, N_("_Close"), "<control>W", NULL, G_CALLBACK(sieve_editor_close_cb) },
  89
  90 /* Edit menu */
  91         {"Edit/Undo",                   NULL, N_("_Undo"), "<control>Z", NULL, G_CALLBACK(sieve_editor_undo_cb) },
  92         {"Edit/Redo",                   NULL, N_("_Redo"), "<control>Y", NULL, G_CALLBACK(sieve_editor_redo_cb) },
  93         /* {"Edit/---",                 NULL, "---" }, */
  94
  95         {"Edit/Cut",                    NULL, N_("Cu_t"), "<control>X", NULL, G_CALLBACK(sieve_editor_cut_cb) },
  96         {"Edit/Copy",                   NULL, N_("_Copy"), "<control>C", NULL, G_CALLBACK(sieve_editor_copy_cb) },
  97         {"Edit/Paste",                  NULL, N_("_Paste"), "<control>V", NULL, G_CALLBACK(sieve_editor_paste_cb) },
  98
  99         {"Edit/SelectAll",              NULL, N_("Select _all"), "<control>A", NULL, G_CALLBACK(sieve_editor_allsel_cb) },
 100
 101         {"Edit/---",                    NULL, "---" },
 102         {"Edit/Find",           NULL, N_("_Find"), "<control>F", NULL, G_CALLBACK(sieve_editor_find_cb) },
 103 };
 104
 105
 106 void sieve_editors_close()
 107 {
 108         if (editors) {
 109                 GSList *list = editors;
 110                 editors = NULL;
 111                 g_slist_free_full(list, (GDestroyNotify)sieve_editor_close);
 112         }
 113 }
 114
 115 void sieve_editor_append_text(SieveEditorPage *page, gchar *text, gint len)
 116 {
 117         GtkTextBuffer *buffer;
 118         GtkTextIter iter;
 119
 120         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(page->text));
 121
 122         g_signal_handlers_block_by_func(G_OBJECT(buffer),
 123                          G_CALLBACK(sieve_editor_changed_cb), page);
 124
 125         undo_block(page->undostruct);
 126         gtk_text_buffer_get_end_iter(buffer, &iter);
 127         gtk_text_buffer_insert(buffer, &iter, text, len);
 128         undo_unblock(page->undostruct);
 129
 130         g_signal_handlers_unblock_by_func(G_OBJECT(buffer),
 131                          G_CALLBACK(sieve_editor_changed_cb), page);
 132 }
 133
 134 static gint sieve_editor_get_text(SieveEditorPage *page, gchar **text)
 135 {
 136         GtkTextBuffer *buffer;
 137         GtkTextIter start, end;
 138
 139         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(page->text));
 140         gtk_text_buffer_get_start_iter(buffer, &start);
 141         gtk_text_buffer_get_end_iter(buffer, &end);
 142         *text = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
 143         return gtk_text_iter_get_offset(&end) - gtk_text_iter_get_offset(&start);
 144 }
 145
 146 static void sieve_editor_set_status(SieveEditorPage *page, const gchar *status)
 147 {
 148         gtk_label_set_text(GTK_LABEL(page->status_text), status);
 149 }
 150
 151 static void sieve_editor_set_status_icon(SieveEditorPage *page, const gchar *img_id)
 152 {
 153         GtkImage *img = GTK_IMAGE(page->status_icon);
 154         if (img_id)
 155                 gtk_image_set_from_stock(img, img_id, GTK_ICON_SIZE_BUTTON);
 156         else
 157                 gtk_image_clear(img);
 158 }
 159
 160 static void sieve_editor_append_status(SieveEditorPage *page,
 161                 const gchar *status)
 162 {
 163         GtkLabel *label = GTK_LABEL(page->status_text);
 164         const gchar *prev_status = gtk_label_get_text(label);
 165         const gchar *sep = prev_status && prev_status[0] ? "\n" : "";
 166         gtk_label_set_text(label, g_strconcat(prev_status, sep, status, NULL));
 167 }
 168
 169 /* Update the status icon and text from a response. */
 170 static void sieve_editor_update_status(SieveEditorPage *page,
 171                 SieveResult *result)
 172 {
 173         if (result->has_status) {
 174                 /* set status icon */
 175                 sieve_editor_set_status_icon(page,
 176                         result->success ? GTK_STOCK_DIALOG_INFO : GTK_STOCK_DIALOG_ERROR);
 177                 /* clear status text */
 178                 sieve_editor_set_status(page, "");
 179         }
 180         if (result->description) {
 181                 /* append to status */
 182                 sieve_editor_append_status(page, result->description);
 183         }
 184 }
 185
 186 /* Edit Menu */
 187
 188 static void sieve_editor_undo_cb(GtkAction *action, SieveEditorPage *page)
 189 {
 190         undo_undo(page->undostruct);
 191 }
 192
 193 static void sieve_editor_redo_cb(GtkAction *action, SieveEditorPage *page)
 194 {
 195         undo_redo(page->undostruct);
 196 }
 197
 198 static void sieve_editor_cut_cb(GtkAction *action, SieveEditorPage *page)
 199 {
 200         GtkTextBuffer *buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(page->text));
 201         GtkClipboard *clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
 202         gtk_text_buffer_cut_clipboard(buf, clipboard, TRUE);
 203 }
 204
 205 static void sieve_editor_copy_cb(GtkAction *action, SieveEditorPage *page)
 206 {
 207         GtkTextBuffer *buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(page->text));
 208         GtkClipboard *clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
 209         gtk_text_buffer_copy_clipboard(buf, clipboard);
 210 }
 211
 212 static void sieve_editor_paste_cb(GtkAction *action, SieveEditorPage *page)
 213 {
 214         if (!gtk_widget_has_focus(page->text))
 215                 return;
 216
 217         GtkTextBuffer *buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(page->text));
 218         GtkClipboard *clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
 219         gchar *contents = gtk_clipboard_wait_for_text(clipboard);
 220         GtkTextMark *start_mark = gtk_text_buffer_get_insert(buf);
 221         GtkTextIter start_iter;
 222
 223         undo_paste_clipboard(GTK_TEXT_VIEW(page->text), page->undostruct);
 224         gtk_text_buffer_delete_selection(buf, FALSE, TRUE);
 225
 226         gtk_text_buffer_get_iter_at_mark(buf, &start_iter, start_mark);
 227         gtk_text_buffer_insert(buf, &start_iter, contents, strlen(contents));
 228 }
 229
 230
 231 static void sieve_editor_allsel_cb(GtkAction *action, SieveEditorPage *page)
 232 {
 233         GtkTextIter start, end;
 234         GtkTextBuffer *buffer;
 235
 236         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(page->text));
 237         gtk_text_buffer_get_start_iter(buffer, &start);
 238         gtk_text_buffer_get_end_iter(buffer, &end);
 239         gtk_text_buffer_select_range(buffer, &start, &end);
 240 }
 241
 242 /* Search */
 243
 244 void sieve_editor_set_position(void *obj, gint pos)
 245 {
 246         SieveEditorPage *page = (SieveEditorPage *)obj;
 247         GtkTextView *text = GTK_TEXT_VIEW(page->text);
 248
 249         gtkut_text_view_set_position(text, pos);
 250 }
 251
 252 gboolean sieve_editor_search_string(void *obj,
 253         const gchar *str, gboolean case_sens)
 254 {
 255         SieveEditorPage *page = (SieveEditorPage *)obj;
 256         GtkTextView *text = GTK_TEXT_VIEW(page->text);
 257
 258         return gtkut_text_view_search_string(text, str, case_sens);
 259 }
 260
 261 gboolean sieve_editor_search_string_backward(void *obj,
 262         const gchar *str, gboolean case_sens)
 263 {
 264         SieveEditorPage *page = (SieveEditorPage *)obj;
 265         GtkTextView *text = GTK_TEXT_VIEW(page->text);
 266
 267         return gtkut_text_view_search_string_backward(text, str, case_sens);
 268 }
 269
 270 static void sieve_editor_search(SieveEditorPage *page)
 271 {
 272         message_search_other(&search_interface, page);
 273 }
 274
 275 /* Actions */
 276
 277 static void got_data_reverting(SieveSession *session, gboolean abort,
 278                 gchar *contents,
 279                 SieveEditorPage *page)
 280 {
 281         if (abort)
 282                 return;
 283         if (contents == NULL) {
 284                 /* end of data */
 285                 undo_unblock(page->undostruct);
 286                 gtk_widget_set_sensitive(page->text, TRUE);
 287                 sieve_editor_set_status(page, "");
 288                 sieve_editor_set_modified(page, FALSE);
 289                 return;
 290         }
 291         if (contents == (void *)-1) {
 292                 /* error */
 293                 sieve_editor_set_status(page, _("Unable to get script contents"));
 294                 sieve_editor_set_status_icon(page, GTK_STOCK_DIALOG_ERROR);
 295                 return;
 296         }
 297
 298         if (page->first_line) {
 299                 GtkTextIter start, end;
 300                 GtkTextBuffer *buffer;
 301
 302                 page->first_line = FALSE;
 303
 304                 /* delete previous data */
 305                 buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(page->text));
 306                 gtk_text_buffer_get_start_iter(buffer, &start);
 307                 gtk_text_buffer_get_end_iter(buffer, &end);
 308                 gtk_text_buffer_delete(buffer, &start, &end);
 309
 310                 /* append data */
 311                 gtk_text_buffer_insert(buffer, &end, contents, strlen(contents));
 312         } else {
 313                 sieve_editor_append_text(page, "\n", 1);
 314                 sieve_editor_append_text(page, contents, strlen(contents));
 315         }
 316 }
 317
 318 static void sieve_editor_revert(SieveEditorPage *page)
 319 {
 320         undo_block(page->undostruct);
 321         page->first_line = TRUE;
 322         gtk_widget_set_sensitive(page->text, FALSE);
 323         sieve_editor_set_status(page, _("Reverting..."));
 324         sieve_editor_set_status_icon(page, NULL);
 325         sieve_session_get_script(page->session, page->script_name,
 326                         (sieve_session_data_cb_fn)got_data_reverting, page);
 327 }
 328
 329 static void sieve_editor_revert_cb(GtkAction *action, SieveEditorPage *page)
 330 {
 331         if (!page->modified ||
 332                         alertpanel(_("Revert script"),
 333                                 _("This script has been modified. Revert the unsaved changes?"),
 334                                 _("_Revert"), NULL, GTK_STOCK_CANCEL) == G_ALERTDEFAULT)
 335                 sieve_editor_revert(page);
 336 }
 337
 338 static void got_data_saved(SieveSession *session, gboolean abort,
 339                 SieveResult *result, SieveEditorPage *page)
 340 {
 341         if (abort)
 342                 return;
 343         if (result->has_status && result->success) {
 344                 sieve_editor_set_modified(page, FALSE);
 345                 if (page->closing) {
 346                         sieve_editor_close(page);
 347                         return;
 348                 }
 349                 /* use nice status message if there are no warnings */
 350                 if (result->code == SIEVE_CODE_NONE) {
 351                         result->description = _("Script saved successfully.");
 352                 }
 353
 354                 if (page->is_new) {
 355                         /* notify manager windows of newly created script */
 356                         page->is_new = FALSE;
 357                         sieve_manager_script_created(session,
 358                                         page->script_name);
 359                 }
 360         }
 361         sieve_editor_update_status(page, result);
 362 }
 363
 364 static void sieve_editor_save(SieveEditorPage *page)
 365 {
 366         gchar *text;
 367         gint len = sieve_editor_get_text(page, &text);
 368         sieve_editor_set_status(page, _("Saving..."));
 369         sieve_editor_set_status_icon(page, NULL);
 370         sieve_session_put_script(page->session, page->script_name, len, text,
 371                         (sieve_session_data_cb_fn)got_data_saved, page);
 372         g_free(text);
 373 }
 374
 375 static void sieve_editor_save_cb(GtkAction *action, SieveEditorPage *page)
 376 {
 377         sieve_editor_save(page);
 378 }
 379
 380 static void sieve_editor_find_cb(GtkAction *action, SieveEditorPage *page)
 381 {
 382         sieve_editor_search(page);
 383 }
 384
 385 static void got_data_checked(SieveSession *session, gboolean abort,
 386                 SieveResult *result, SieveEditorPage *page)
 387 {
 388         if (abort)
 389                 return;
 390         sieve_editor_update_status(page, result);
 391 }
 392
 393 static void sieve_editor_check_cb(GtkAction *action, SieveEditorPage *page)
 394 {
 395         gchar *text;
 396         gint len = sieve_editor_get_text(page, &text);
 397         sieve_editor_set_status(page, _("Checking syntax..."));
 398         sieve_editor_set_status_icon(page, NULL);
 399         sieve_session_check_script(page->session, len, text,
 400                         (sieve_session_data_cb_fn)got_data_checked, page);
 401         g_free(text);
 402 }
 403
 404 static void sieve_editor_changed_cb(GtkTextBuffer *textbuf,
 405                 SieveEditorPage *page)
 406 {
 407         if (!page->modified) {
 408                 sieve_editor_set_modified(page, TRUE);
 409         }
 410 }
 411
 412 static void sieve_editor_destroy(SieveEditorPage *page)
 413 {
 414         gtk_widget_destroy(page->window);
 415         undo_destroy(page->undostruct);
 416         g_free(page);
 417 }
 418
 419 void sieve_editor_close(SieveEditorPage *page)
 420 {
 421         editors = g_slist_remove(editors, (gconstpointer)page);
 422         sieve_editor_destroy(page);
 423         sieve_sessions_discard_callbacks(page);
 424 }
 425
 426 static gboolean sieve_editor_confirm_close(SieveEditorPage *page)
 427 {
 428         if (page->modified) {
 429                 switch (alertpanel(_("Save changes"),
 430                                 _("This script has been modified. Save the latest changes?"),
 431                                 _("_Discard"), _("+_Save"), GTK_STOCK_CANCEL)) {
 432                         case G_ALERTDEFAULT:
 433                                 return TRUE;
 434                         case G_ALERTALTERNATE:
 435                                 page->closing = TRUE;
 436                                 sieve_editor_save(page);
 437                                 return FALSE;
 438                         default:
 439                                 return FALSE;
 440                 }
 441         }
 442         return TRUE;
 443 }
 444
 445 static void sieve_editor_close_cb(GtkAction *action, SieveEditorPage *page)
 446 {
 447         if (sieve_editor_confirm_close(page)) {
 448                 sieve_editor_close(page);
 449         }
 450 }
 451
 452 static gint sieve_editor_delete_cb(GtkWidget *widget, GdkEventAny *event,
 453                 SieveEditorPage *page)
 454 {
 455         sieve_editor_close_cb(NULL, page);
 456         return TRUE;
 457 }
 458
 459 /**
 460  * sieve_editor_undo_state_changed:
 461  *
 462  * Change the sensivity of the menuentries undo and redo
 463  **/
 464 static void sieve_editor_undo_state_changed(UndoMain *undostruct,
 465                 gint undo_state, gint redo_state, gpointer data)
 466 {
 467         SieveEditorPage *page = (SieveEditorPage *)data;
 468
 469         switch (undo_state) {
 470         case UNDO_STATE_TRUE:
 471                 if (!undostruct->undo_state) {
 472                         undostruct->undo_state = TRUE;
 473                         cm_menu_set_sensitive_full(page->ui_manager, "Menu/Edit/Undo", TRUE);
 474                 }
 475                 break;
 476         case UNDO_STATE_FALSE:
 477                 if (undostruct->undo_state) {
 478                         undostruct->undo_state = FALSE;
 479                         cm_menu_set_sensitive_full(page->ui_manager, "Menu/Edit/Undo", FALSE);
 480                 }
 481                 break;
 482         case UNDO_STATE_UNCHANGED:
 483                 break;
 484         case UNDO_STATE_REFRESH:
 485                 cm_menu_set_sensitive_full(page->ui_manager, "Menu/Edit/Undo", undostruct->undo_state);
 486                 break;
 487         default:
 488                 g_warning("Undo state not recognized");
 489                 break;
 490         }
 491
 492         switch (redo_state) {
 493         case UNDO_STATE_TRUE:
 494                 if (!undostruct->redo_state) {
 495                         undostruct->redo_state = TRUE;
 496                         cm_menu_set_sensitive_full(page->ui_manager, "Menu/Edit/Redo", TRUE);
 497                 }
 498                 break;
 499         case UNDO_STATE_FALSE:
 500                 if (undostruct->redo_state) {
 501                         undostruct->redo_state = FALSE;
 502                         cm_menu_set_sensitive_full(page->ui_manager, "Menu/Edit/Redo", FALSE);
 503                 }
 504                 break;
 505         case UNDO_STATE_UNCHANGED:
 506                 break;
 507         case UNDO_STATE_REFRESH:
 508                 cm_menu_set_sensitive_full(page->ui_manager, "Menu/Edit/Redo", undostruct->redo_state);
 509                 break;
 510         default:
 511                 g_warning("Redo state not recognized");
 512                 break;
 513         }
 514 }
 515
 516
 517 SieveEditorPage *sieve_editor_new(SieveSession *session, gchar *script_name)
 518 {
 519         SieveEditorPage *page;
 520         GtkUIManager *ui_manager;
 521         UndoMain *undostruct;
 522         GtkWidget *window;
 523         GtkWidget *menubar;
 524         GtkWidget *vbox, *hbox, *hbox1;
 525         GtkWidget *scrolledwin;
 526         GtkWidget *text;
 527         GtkTextBuffer *buffer;
 528         GtkWidget *check_btn, *save_btn, *close_btn;
 529         GtkWidget *status_text;
 530         GtkWidget *status_icon;
 531
 532         page = g_new0(SieveEditorPage, 1);
 533
 534         /* window */
 535         window = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "sieveeditor");
 536         gtk_window_set_resizable(GTK_WINDOW(window), TRUE);
 537         MANAGE_WINDOW_SIGNALS_CONNECT (window);
 538         g_signal_connect(G_OBJECT(window), "delete_event",
 539                          G_CALLBACK(sieve_editor_delete_cb), page);
 540
 541         vbox = gtk_vbox_new(FALSE, 0);
 542         gtk_container_add(GTK_CONTAINER(window), vbox);
 543
 544         ui_manager = gtk_ui_manager_new();
 545         cm_menu_create_action_group_full(ui_manager,
 546                         "Menu", sieve_editor_entries, G_N_ELEMENTS(sieve_editor_entries),
 547                         page);
 548
 549         MENUITEM_ADDUI_MANAGER(ui_manager, "/", "Menu", NULL, GTK_UI_MANAGER_MENUBAR)
 550
 551         MENUITEM_ADDUI_MANAGER(ui_manager, "/Menu", "Filter", "Filter", GTK_UI_MANAGER_MENU)
 552         MENUITEM_ADDUI_MANAGER(ui_manager, "/Menu", "Edit", "Edit", GTK_UI_MANAGER_MENU)
 553
 554 /* Filter menu */
 555         MENUITEM_ADDUI_MANAGER(ui_manager, "/Menu/Filter", "Save", "Filter/Save", GTK_UI_MANAGER_MENUITEM)
 556 MENUITEM_ADDUI_MANAGER(ui_manager, "/Menu/Filter", "CheckSyntax", "Filter/CheckSyntax", GTK_UI_MANAGER_MENUITEM)
 557 MENUITEM_ADDUI_MANAGER(ui_manager, "/Menu/Filter", "Revert", "Filter/Revert", GTK_UI_MANAGER_MENUITEM)
 558         MENUITEM_ADDUI_MANAGER(ui_manager, "/Menu/Filter", "Close", "Filter/Close", GTK_UI_MANAGER_MENUITEM)
 559
 560 /* Edit menu */
 561         MENUITEM_ADDUI_MANAGER(ui_manager, "/Menu/Edit", "Undo", "Edit/Undo", GTK_UI_MANAGER_MENUITEM)
 562         MENUITEM_ADDUI_MANAGER(ui_manager, "/Menu/Edit", "Redo", "Edit/Redo", GTK_UI_MANAGER_MENUITEM)
 563         MENUITEM_ADDUI_MANAGER(ui_manager, "/Menu/Edit", "Separator1", "Edit/---", GTK_UI_MANAGER_SEPARATOR)
 564
 565         MENUITEM_ADDUI_MANAGER(ui_manager, "/Menu/Edit", "Cut", "Edit/Cut", GTK_UI_MANAGER_MENUITEM)
 566         MENUITEM_ADDUI_MANAGER(ui_manager, "/Menu/Edit", "Copy", "Edit/Copy", GTK_UI_MANAGER_MENUITEM)
 567         MENUITEM_ADDUI_MANAGER(ui_manager, "/Menu/Edit", "Paste", "Edit/Paste", GTK_UI_MANAGER_MENUITEM)
 568
 569         MENUITEM_ADDUI_MANAGER(ui_manager, "/Menu/Edit", "SelectAll", "Edit/SelectAll", GTK_UI_MANAGER_MENUITEM)
 570
 571         MENUITEM_ADDUI_MANAGER(ui_manager, "/Menu/Edit", "Separator2", "Edit/---", GTK_UI_MANAGER_SEPARATOR)
 572
 573         MENUITEM_ADDUI_MANAGER(ui_manager, "/Menu/Edit", "Find", "Edit/Find", GTK_UI_MANAGER_MENUITEM)
 574
 575         menubar = gtk_ui_manager_get_widget(ui_manager, "/Menu");
 576
 577         gtk_window_add_accel_group(GTK_WINDOW(window), gtk_ui_manager_get_accel_group(ui_manager));
 578         gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, TRUE, 0);
 579
 580         cm_menu_set_sensitive_full(ui_manager, "Menu/Edit/Undo", FALSE);
 581         cm_menu_set_sensitive_full(ui_manager, "Menu/Edit/Redo", FALSE);
 582
 583         /* text */
 584         scrolledwin = gtk_scrolled_window_new(NULL, NULL);
 585         gtk_widget_set_size_request (scrolledwin, 660, 408);
 586         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),
 587                                        GTK_POLICY_AUTOMATIC,
 588                                        GTK_POLICY_AUTOMATIC);
 589         gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwin),
 590                                             GTK_SHADOW_IN);
 591         gtk_box_pack_start(GTK_BOX(vbox), scrolledwin, TRUE, TRUE, 0);
 592
 593         text = gtk_text_view_new();
 594         gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(text), GTK_WRAP_WORD_CHAR);
 595         gtk_text_view_set_editable(GTK_TEXT_VIEW(text), TRUE);
 596         gtk_container_add(GTK_CONTAINER(scrolledwin), text);
 597
 598         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
 599         g_signal_connect(G_OBJECT(buffer), "changed",
 600                          G_CALLBACK(sieve_editor_changed_cb), page);
 601
 602         /* set text font */
 603         if (prefs_common_get_prefs()->textfont) {
 604                 PangoFontDescription *font_desc;
 605
 606                 font_desc = pango_font_description_from_string
 607                         (prefs_common_get_prefs()->textfont);
 608                 if (font_desc) {
 609                         gtk_widget_modify_font(text, font_desc);
 610                         pango_font_description_free(font_desc);
 611                 }
 612         }
 613
 614         hbox = gtk_hbox_new (FALSE, 8);
 615         gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
 616         gtk_container_set_border_width (GTK_CONTAINER (hbox), 8);
 617
 618         /* status */
 619         status_icon = gtk_image_new ();
 620         gtk_box_pack_start (GTK_BOX (hbox), status_icon, FALSE, FALSE, 0);
 621         status_text = gtk_label_new ("");
 622         gtk_box_pack_start (GTK_BOX (hbox), status_text, FALSE, FALSE, 0);
 623         gtk_label_set_justify (GTK_LABEL (status_text), GTK_JUSTIFY_LEFT);
 624
 625         /* buttons */
 626         gtkut_stock_with_text_button_set_create(&hbox1,
 627                         &close_btn, GTK_STOCK_CANCEL, _("_Close"),
 628                         &check_btn, GTK_STOCK_OK, _("Chec_k Syntax"),
 629                         &save_btn, GTK_STOCK_SAVE, _("_Save"));
 630         gtk_box_pack_end (GTK_BOX (hbox), hbox1, FALSE, FALSE, 0);
 631         gtk_widget_grab_default (save_btn);
 632         g_signal_connect (G_OBJECT (close_btn), "clicked",
 633                           G_CALLBACK (sieve_editor_close_cb), page);
 634         g_signal_connect (G_OBJECT (check_btn), "clicked",
 635                           G_CALLBACK (sieve_editor_check_cb), page);
 636         g_signal_connect (G_OBJECT (save_btn), "clicked",
 637                           G_CALLBACK (sieve_editor_save_cb), page);
 638
 639         undostruct = undo_init(text);
 640         undo_set_change_state_func(undostruct, &sieve_editor_undo_state_changed,
 641                         page);
 642
 643         page->window = window;
 644         page->ui_manager = ui_manager;
 645         page->text = text;
 646         page->undostruct = undostruct;
 647         page->session = session;
 648         page->script_name = script_name;
 649         page->status_text = status_text;
 650         page->status_icon = status_icon;
 651
 652         editors = g_slist_prepend(editors, page);
 653
 654         sieve_editor_set_modified(page, FALSE);
 655
 656         return page;
 657 }
 658
 659 SieveEditorPage *sieve_editor_get(SieveSession *session, gchar *script_name)
 660 {
 661         GSList *item;
 662         SieveEditorPage *page;
 663         for (item = editors; item; item = item->next) {
 664                 page = (SieveEditorPage *)item->data;
 665                 if (page->session == session &&
 666                                 strcmp(script_name, page->script_name) == 0)
 667                         return page;
 668         }
 669         return NULL;
 670 }
 671
 672 void sieve_editor_present(SieveEditorPage *page)
 673 {
 674         gtk_window_present(GTK_WINDOW(page->window));
 675 }
 676
 677 void sieve_editor_show(SieveEditorPage *page)
 678 {
 679         gtk_widget_show_all(GTK_WIDGET(page->window));
 680 }
 681
 682 static void sieve_editor_set_modified(SieveEditorPage *page,
 683                 gboolean modified)
 684 {
 685         gchar *title;
 686
 687         page->modified = modified;
 688         cm_menu_set_sensitive_full(page->ui_manager, "Menu/Filter/Revert",
 689                         modified);
 690
 691         title = g_strdup_printf(_("%s - Sieve Filter%s"), page->script_name,
 692                         modified ? _(" [Edited]") : "");
 693         gtk_window_set_title (GTK_WINDOW (page->window), title);
 694         g_free(title);
 695
 696         if (modified) {
 697                 sieve_editor_set_status(page, "");
 698                 sieve_editor_set_status_icon(page, NULL);
 699         }
 700 }
 701
 702 static void got_data_loading(SieveSession *session, gboolean aborted,
 703                 gchar *contents, SieveEditorPage *page)
 704 {
 705         if (aborted)
 706                 return;
 707         if (contents == NULL) {
 708                 /* end of data */
 709                 sieve_editor_set_status(page, "");
 710                 return;
 711         }
 712         if (contents == (void *)-1) {
 713                 /* error */
 714                 if (page->first_line) {
 715                         /* no data. show error in manager window */
 716                         if (page->on_load_error)
 717                                 page->on_load_error(session, page->on_load_error_data);
 718                 } else {
 719                         /* partial failure. show error in editor window */
 720                         sieve_editor_set_status(page, _("Unable to get script contents"));
 721                         sieve_editor_set_status_icon(page, GTK_STOCK_DIALOG_ERROR);
 722                 }
 723                 return;
 724         }
 725
 726         if (page->first_line) {
 727                 page->first_line = FALSE;
 728                 sieve_editor_show(page);
 729         } else {
 730                 sieve_editor_append_text(page, "\n", 1);
 731         }
 732         sieve_editor_append_text(page, contents, strlen(contents));
 733 }
 734
 735 /* load the script for this editor */
 736 void sieve_editor_load(SieveEditorPage *page,
 737                 sieve_session_cb_fn on_load_error, gpointer load_error_data)
 738 {
 739         page->first_line = TRUE;
 740         page->on_load_error = on_load_error;
 741         page->on_load_error_data = load_error_data;
 742         sieve_editor_set_status(page, _("Loading..."));
 743         sieve_editor_set_status_icon(page, NULL);
 744         sieve_session_get_script(page->session, page->script_name,
 745                         (sieve_session_data_cb_fn)got_data_loading, page);
 746 }