managesieve: fix memory leak
[claws.git] / 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 *new_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         gchar *status = g_strconcat(prev_status, sep, new_status, NULL);
167         gtk_label_set_text(label, status);
168         g_free(status);
169 }
170
171 /* Update the status icon and text from a response. */
172 static void sieve_editor_update_status(SieveEditorPage *page,
173                 SieveResult *result)
174 {
175         if (result->has_status) {
176                 /* set status icon */
177                 sieve_editor_set_status_icon(page,
178                         result->success ? GTK_STOCK_DIALOG_INFO : GTK_STOCK_DIALOG_ERROR);
179                 /* clear status text */
180                 sieve_editor_set_status(page, "");
181         }
182         if (result->description) {
183                 /* append to status */
184                 sieve_editor_append_status(page, result->description);
185         }
186 }
187
188 /* Edit Menu */
189
190 static void sieve_editor_undo_cb(GtkAction *action, SieveEditorPage *page)
191 {
192         undo_undo(page->undostruct);
193 }
194
195 static void sieve_editor_redo_cb(GtkAction *action, SieveEditorPage *page)
196 {
197         undo_redo(page->undostruct);
198 }
199
200 static void sieve_editor_cut_cb(GtkAction *action, SieveEditorPage *page)
201 {
202         GtkTextBuffer *buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(page->text));
203         GtkClipboard *clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
204         gtk_text_buffer_cut_clipboard(buf, clipboard, TRUE);
205 }
206
207 static void sieve_editor_copy_cb(GtkAction *action, SieveEditorPage *page)
208 {
209         GtkTextBuffer *buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(page->text));
210         GtkClipboard *clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
211         gtk_text_buffer_copy_clipboard(buf, clipboard);
212 }
213
214 static void sieve_editor_paste_cb(GtkAction *action, SieveEditorPage *page)
215 {
216         if (!gtk_widget_has_focus(page->text))
217                 return;
218
219         GtkTextBuffer *buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(page->text));
220         GtkClipboard *clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
221         gchar *contents = gtk_clipboard_wait_for_text(clipboard);
222         GtkTextMark *start_mark = gtk_text_buffer_get_insert(buf);
223         GtkTextIter start_iter;
224
225         undo_paste_clipboard(GTK_TEXT_VIEW(page->text), page->undostruct);
226         gtk_text_buffer_delete_selection(buf, FALSE, TRUE);
227
228         gtk_text_buffer_get_iter_at_mark(buf, &start_iter, start_mark);
229         gtk_text_buffer_insert(buf, &start_iter, contents, strlen(contents));
230 }
231
232
233 static void sieve_editor_allsel_cb(GtkAction *action, SieveEditorPage *page)
234 {
235         GtkTextIter start, end;
236         GtkTextBuffer *buffer;
237
238         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(page->text));
239         gtk_text_buffer_get_start_iter(buffer, &start);
240         gtk_text_buffer_get_end_iter(buffer, &end);
241         gtk_text_buffer_select_range(buffer, &start, &end);
242 }
243
244 /* Search */
245
246 void sieve_editor_set_position(void *obj, gint pos)
247 {
248         SieveEditorPage *page = (SieveEditorPage *)obj;
249         GtkTextView *text = GTK_TEXT_VIEW(page->text);
250
251         gtkut_text_view_set_position(text, pos);
252 }
253
254 gboolean sieve_editor_search_string(void *obj,
255         const gchar *str, gboolean case_sens)
256 {
257         SieveEditorPage *page = (SieveEditorPage *)obj;
258         GtkTextView *text = GTK_TEXT_VIEW(page->text);
259
260         return gtkut_text_view_search_string(text, str, case_sens);
261 }
262
263 gboolean sieve_editor_search_string_backward(void *obj,
264         const gchar *str, gboolean case_sens)
265 {
266         SieveEditorPage *page = (SieveEditorPage *)obj;
267         GtkTextView *text = GTK_TEXT_VIEW(page->text);
268
269         return gtkut_text_view_search_string_backward(text, str, case_sens);
270 }
271
272 static void sieve_editor_search(SieveEditorPage *page)
273 {
274         message_search_other(&search_interface, page);
275 }
276
277 /* Actions */
278
279 static void got_data_reverting(SieveSession *session, gboolean abort,
280                 gchar *contents,
281                 SieveEditorPage *page)
282 {
283         if (abort)
284                 return;
285         if (contents == NULL) {
286                 /* end of data */
287                 undo_unblock(page->undostruct);
288                 gtk_widget_set_sensitive(page->text, TRUE);
289                 sieve_editor_set_status(page, "");
290                 sieve_editor_set_modified(page, FALSE);
291                 return;
292         }
293         if (contents == (void *)-1) {
294                 /* error */
295                 sieve_editor_set_status(page, _("Unable to get script contents"));
296                 sieve_editor_set_status_icon(page, GTK_STOCK_DIALOG_ERROR);
297                 return;
298         }
299
300         if (page->first_line) {
301                 GtkTextIter start, end;
302                 GtkTextBuffer *buffer;
303
304                 page->first_line = FALSE;
305
306                 /* delete previous data */
307                 buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(page->text));
308                 gtk_text_buffer_get_start_iter(buffer, &start);
309                 gtk_text_buffer_get_end_iter(buffer, &end);
310                 gtk_text_buffer_delete(buffer, &start, &end);
311
312                 /* append data */
313                 gtk_text_buffer_insert(buffer, &end, contents, strlen(contents));
314         } else {
315                 sieve_editor_append_text(page, "\n", 1);
316                 sieve_editor_append_text(page, contents, strlen(contents));
317         }
318 }
319
320 static void sieve_editor_revert(SieveEditorPage *page)
321 {
322         undo_block(page->undostruct);
323         page->first_line = TRUE;
324         gtk_widget_set_sensitive(page->text, FALSE);
325         sieve_editor_set_status(page, _("Reverting..."));
326         sieve_editor_set_status_icon(page, NULL);
327         sieve_session_get_script(page->session, page->script_name,
328                         (sieve_session_data_cb_fn)got_data_reverting, page);
329 }
330
331 static void sieve_editor_revert_cb(GtkAction *action, SieveEditorPage *page)
332 {
333         if (!page->modified ||
334                         alertpanel(_("Revert script"),
335                                 _("This script has been modified. Revert the unsaved changes?"),
336                                 _("_Revert"), NULL, GTK_STOCK_CANCEL) == G_ALERTDEFAULT)
337                 sieve_editor_revert(page);
338 }
339
340 static void got_data_saved(SieveSession *session, gboolean abort,
341                 SieveResult *result, SieveEditorPage *page)
342 {
343         if (abort)
344                 return;
345         if (result->has_status && result->success) {
346                 sieve_editor_set_modified(page, FALSE);
347                 if (page->closing) {
348                         sieve_editor_close(page);
349                         return;
350                 }
351                 /* use nice status message if there are no warnings */
352                 if (result->code == SIEVE_CODE_NONE) {
353                         result->description = _("Script saved successfully.");
354                 }
355
356                 if (page->is_new) {
357                         /* notify manager windows of newly created script */
358                         page->is_new = FALSE;
359                         sieve_manager_script_created(session,
360                                         page->script_name);
361                 }
362         }
363         sieve_editor_update_status(page, result);
364 }
365
366 static void sieve_editor_save(SieveEditorPage *page)
367 {
368         gchar *text;
369         gint len = sieve_editor_get_text(page, &text);
370         sieve_editor_set_status(page, _("Saving..."));
371         sieve_editor_set_status_icon(page, NULL);
372         sieve_session_put_script(page->session, page->script_name, len, text,
373                         (sieve_session_data_cb_fn)got_data_saved, page);
374         g_free(text);
375 }
376
377 static void sieve_editor_save_cb(GtkAction *action, SieveEditorPage *page)
378 {
379         sieve_editor_save(page);
380 }
381
382 static void sieve_editor_find_cb(GtkAction *action, SieveEditorPage *page)
383 {
384         sieve_editor_search(page);
385 }
386
387 static void got_data_checked(SieveSession *session, gboolean abort,
388                 SieveResult *result, SieveEditorPage *page)
389 {
390         if (abort)
391                 return;
392         sieve_editor_update_status(page, result);
393 }
394
395 static void sieve_editor_check_cb(GtkAction *action, SieveEditorPage *page)
396 {
397         gchar *text;
398         gint len = sieve_editor_get_text(page, &text);
399         sieve_editor_set_status(page, _("Checking syntax..."));
400         sieve_editor_set_status_icon(page, NULL);
401         sieve_session_check_script(page->session, len, text,
402                         (sieve_session_data_cb_fn)got_data_checked, page);
403         g_free(text);
404 }
405
406 static void sieve_editor_changed_cb(GtkTextBuffer *textbuf,
407                 SieveEditorPage *page)
408 {
409         if (!page->modified) {
410                 sieve_editor_set_modified(page, TRUE);
411         }
412 }
413
414 static void sieve_editor_destroy(SieveEditorPage *page)
415 {
416         gtk_widget_destroy(page->window);
417         undo_destroy(page->undostruct);
418         g_free(page);
419 }
420
421 void sieve_editor_close(SieveEditorPage *page)
422 {
423         editors = g_slist_remove(editors, (gconstpointer)page);
424         sieve_editor_destroy(page);
425         sieve_sessions_discard_callbacks(page);
426 }
427
428 static gboolean sieve_editor_confirm_close(SieveEditorPage *page)
429 {
430         if (page->modified) {
431                 switch (alertpanel(_("Save changes"),
432                                 _("This script has been modified. Save the latest changes?"),
433                                 _("_Discard"), _("+_Save"), GTK_STOCK_CANCEL)) {
434                         case G_ALERTDEFAULT:
435                                 return TRUE;
436                         case G_ALERTALTERNATE:
437                                 page->closing = TRUE;
438                                 sieve_editor_save(page);
439                                 return FALSE;
440                         default:
441                                 return FALSE;
442                 }
443         }
444         return TRUE;
445 }
446
447 static void sieve_editor_close_cb(GtkAction *action, SieveEditorPage *page)
448 {
449         if (sieve_editor_confirm_close(page)) {
450                 sieve_editor_close(page);
451         }
452 }
453
454 static gint sieve_editor_delete_cb(GtkWidget *widget, GdkEventAny *event,
455                 SieveEditorPage *page)
456 {
457         sieve_editor_close_cb(NULL, page);
458         return TRUE;
459 }
460
461 /**
462  * sieve_editor_undo_state_changed:
463  *
464  * Change the sensivity of the menuentries undo and redo
465  **/
466 static void sieve_editor_undo_state_changed(UndoMain *undostruct,
467                 gint undo_state, gint redo_state, gpointer data)
468 {
469         SieveEditorPage *page = (SieveEditorPage *)data;
470
471         switch (undo_state) {
472         case UNDO_STATE_TRUE:
473                 if (!undostruct->undo_state) {
474                         undostruct->undo_state = TRUE;
475                         cm_menu_set_sensitive_full(page->ui_manager, "Menu/Edit/Undo", TRUE);
476                 }
477                 break;
478         case UNDO_STATE_FALSE:
479                 if (undostruct->undo_state) {
480                         undostruct->undo_state = FALSE;
481                         cm_menu_set_sensitive_full(page->ui_manager, "Menu/Edit/Undo", FALSE);
482                 }
483                 break;
484         case UNDO_STATE_UNCHANGED:
485                 break;
486         case UNDO_STATE_REFRESH:
487                 cm_menu_set_sensitive_full(page->ui_manager, "Menu/Edit/Undo", undostruct->undo_state);
488                 break;
489         default:
490                 g_warning("Undo state not recognized");
491                 break;
492         }
493
494         switch (redo_state) {
495         case UNDO_STATE_TRUE:
496                 if (!undostruct->redo_state) {
497                         undostruct->redo_state = TRUE;
498                         cm_menu_set_sensitive_full(page->ui_manager, "Menu/Edit/Redo", TRUE);
499                 }
500                 break;
501         case UNDO_STATE_FALSE:
502                 if (undostruct->redo_state) {
503                         undostruct->redo_state = FALSE;
504                         cm_menu_set_sensitive_full(page->ui_manager, "Menu/Edit/Redo", FALSE);
505                 }
506                 break;
507         case UNDO_STATE_UNCHANGED:
508                 break;
509         case UNDO_STATE_REFRESH:
510                 cm_menu_set_sensitive_full(page->ui_manager, "Menu/Edit/Redo", undostruct->redo_state);
511                 break;
512         default:
513                 g_warning("Redo state not recognized");
514                 break;
515         }
516 }
517
518
519 SieveEditorPage *sieve_editor_new(SieveSession *session, gchar *script_name)
520 {
521         SieveEditorPage *page;
522         GtkUIManager *ui_manager;
523         UndoMain *undostruct;
524         GtkWidget *window;
525         GtkWidget *menubar;
526         GtkWidget *vbox, *hbox, *hbox1;
527         GtkWidget *scrolledwin;
528         GtkWidget *text;
529         GtkTextBuffer *buffer;
530         GtkWidget *check_btn, *save_btn, *close_btn;
531         GtkWidget *status_text;
532         GtkWidget *status_icon;
533
534         page = g_new0(SieveEditorPage, 1);
535
536         /* window */
537         window = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "sieveeditor");
538         gtk_window_set_resizable(GTK_WINDOW(window), TRUE);
539         MANAGE_WINDOW_SIGNALS_CONNECT (window);
540         g_signal_connect(G_OBJECT(window), "delete_event",
541                          G_CALLBACK(sieve_editor_delete_cb), page);
542
543         vbox = gtk_vbox_new(FALSE, 0);
544         gtk_container_add(GTK_CONTAINER(window), vbox);
545
546         ui_manager = gtk_ui_manager_new();
547         cm_menu_create_action_group_full(ui_manager,
548                         "Menu", sieve_editor_entries, G_N_ELEMENTS(sieve_editor_entries),
549                         page);
550
551         MENUITEM_ADDUI_MANAGER(ui_manager, "/", "Menu", NULL, GTK_UI_MANAGER_MENUBAR)
552
553         MENUITEM_ADDUI_MANAGER(ui_manager, "/Menu", "Filter", "Filter", GTK_UI_MANAGER_MENU)
554         MENUITEM_ADDUI_MANAGER(ui_manager, "/Menu", "Edit", "Edit", GTK_UI_MANAGER_MENU)
555
556 /* Filter menu */
557         MENUITEM_ADDUI_MANAGER(ui_manager, "/Menu/Filter", "Save", "Filter/Save", GTK_UI_MANAGER_MENUITEM)
558 MENUITEM_ADDUI_MANAGER(ui_manager, "/Menu/Filter", "CheckSyntax", "Filter/CheckSyntax", GTK_UI_MANAGER_MENUITEM)
559 MENUITEM_ADDUI_MANAGER(ui_manager, "/Menu/Filter", "Revert", "Filter/Revert", GTK_UI_MANAGER_MENUITEM)
560         MENUITEM_ADDUI_MANAGER(ui_manager, "/Menu/Filter", "Close", "Filter/Close", GTK_UI_MANAGER_MENUITEM)
561
562 /* Edit menu */
563         MENUITEM_ADDUI_MANAGER(ui_manager, "/Menu/Edit", "Undo", "Edit/Undo", GTK_UI_MANAGER_MENUITEM)
564         MENUITEM_ADDUI_MANAGER(ui_manager, "/Menu/Edit", "Redo", "Edit/Redo", GTK_UI_MANAGER_MENUITEM)
565         MENUITEM_ADDUI_MANAGER(ui_manager, "/Menu/Edit", "Separator1", "Edit/---", GTK_UI_MANAGER_SEPARATOR)
566
567         MENUITEM_ADDUI_MANAGER(ui_manager, "/Menu/Edit", "Cut", "Edit/Cut", GTK_UI_MANAGER_MENUITEM)
568         MENUITEM_ADDUI_MANAGER(ui_manager, "/Menu/Edit", "Copy", "Edit/Copy", GTK_UI_MANAGER_MENUITEM)
569         MENUITEM_ADDUI_MANAGER(ui_manager, "/Menu/Edit", "Paste", "Edit/Paste", GTK_UI_MANAGER_MENUITEM)
570
571         MENUITEM_ADDUI_MANAGER(ui_manager, "/Menu/Edit", "SelectAll", "Edit/SelectAll", GTK_UI_MANAGER_MENUITEM)
572
573         MENUITEM_ADDUI_MANAGER(ui_manager, "/Menu/Edit", "Separator2", "Edit/---", GTK_UI_MANAGER_SEPARATOR)
574
575         MENUITEM_ADDUI_MANAGER(ui_manager, "/Menu/Edit", "Find", "Edit/Find", GTK_UI_MANAGER_MENUITEM)
576
577         menubar = gtk_ui_manager_get_widget(ui_manager, "/Menu");
578
579         gtk_window_add_accel_group(GTK_WINDOW(window), gtk_ui_manager_get_accel_group(ui_manager));
580         gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, TRUE, 0);
581
582         cm_menu_set_sensitive_full(ui_manager, "Menu/Edit/Undo", FALSE);
583         cm_menu_set_sensitive_full(ui_manager, "Menu/Edit/Redo", FALSE);
584
585         /* text */
586         scrolledwin = gtk_scrolled_window_new(NULL, NULL);
587         gtk_widget_set_size_request (scrolledwin, 660, 408);
588         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),
589                                        GTK_POLICY_AUTOMATIC,
590                                        GTK_POLICY_AUTOMATIC);
591         gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwin),
592                                             GTK_SHADOW_IN);
593         gtk_box_pack_start(GTK_BOX(vbox), scrolledwin, TRUE, TRUE, 0);
594
595         text = gtk_text_view_new();
596         gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(text), GTK_WRAP_WORD_CHAR);
597         gtk_text_view_set_editable(GTK_TEXT_VIEW(text), TRUE);
598         gtk_container_add(GTK_CONTAINER(scrolledwin), text);
599
600         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
601         g_signal_connect(G_OBJECT(buffer), "changed",
602                          G_CALLBACK(sieve_editor_changed_cb), page);
603
604         /* set text font */
605         if (prefs_common_get_prefs()->textfont) {
606                 PangoFontDescription *font_desc;
607
608                 font_desc = pango_font_description_from_string
609                         (prefs_common_get_prefs()->textfont);
610                 if (font_desc) {
611                         gtk_widget_modify_font(text, font_desc);
612                         pango_font_description_free(font_desc);
613                 }
614         }
615
616         hbox = gtk_hbox_new (FALSE, 8);
617         gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
618         gtk_container_set_border_width (GTK_CONTAINER (hbox), 8);
619
620         /* status */
621         status_icon = gtk_image_new ();
622         gtk_box_pack_start (GTK_BOX (hbox), status_icon, FALSE, FALSE, 0);
623         status_text = gtk_label_new ("");
624         gtk_box_pack_start (GTK_BOX (hbox), status_text, FALSE, FALSE, 0);
625         gtk_label_set_justify (GTK_LABEL (status_text), GTK_JUSTIFY_LEFT);
626
627         /* buttons */
628         gtkut_stock_with_text_button_set_create(&hbox1,
629                         &close_btn, GTK_STOCK_CANCEL, _("_Close"),
630                         &check_btn, GTK_STOCK_OK, _("Chec_k Syntax"),
631                         &save_btn, GTK_STOCK_SAVE, _("_Save"));
632         gtk_box_pack_end (GTK_BOX (hbox), hbox1, FALSE, FALSE, 0);
633         gtk_widget_grab_default (save_btn);
634         g_signal_connect (G_OBJECT (close_btn), "clicked",
635                           G_CALLBACK (sieve_editor_close_cb), page);
636         g_signal_connect (G_OBJECT (check_btn), "clicked",
637                           G_CALLBACK (sieve_editor_check_cb), page);
638         g_signal_connect (G_OBJECT (save_btn), "clicked",
639                           G_CALLBACK (sieve_editor_save_cb), page);
640
641         undostruct = undo_init(text);
642         undo_set_change_state_func(undostruct, &sieve_editor_undo_state_changed,
643                         page);
644
645         page->window = window;
646         page->ui_manager = ui_manager;
647         page->text = text;
648         page->undostruct = undostruct;
649         page->session = session;
650         page->script_name = script_name;
651         page->status_text = status_text;
652         page->status_icon = status_icon;
653
654         editors = g_slist_prepend(editors, page);
655
656         sieve_editor_set_modified(page, FALSE);
657
658         return page;
659 }
660
661 SieveEditorPage *sieve_editor_get(SieveSession *session, gchar *script_name)
662 {
663         GSList *item;
664         SieveEditorPage *page;
665         for (item = editors; item; item = item->next) {
666                 page = (SieveEditorPage *)item->data;
667                 if (page->session == session &&
668                                 strcmp(script_name, page->script_name) == 0)
669                         return page;
670         }
671         return NULL;
672 }
673
674 void sieve_editor_present(SieveEditorPage *page)
675 {
676         gtk_window_present(GTK_WINDOW(page->window));
677 }
678
679 void sieve_editor_show(SieveEditorPage *page)
680 {
681         gtk_widget_show_all(GTK_WIDGET(page->window));
682 }
683
684 static void sieve_editor_set_modified(SieveEditorPage *page,
685                 gboolean modified)
686 {
687         gchar *title;
688
689         page->modified = modified;
690         cm_menu_set_sensitive_full(page->ui_manager, "Menu/Filter/Revert",
691                         modified);
692
693         title = g_strdup_printf(_("%s - Sieve Filter%s"), page->script_name,
694                         modified ? _(" [Edited]") : "");
695         gtk_window_set_title (GTK_WINDOW (page->window), title);
696         g_free(title);
697
698         if (modified) {
699                 sieve_editor_set_status(page, "");
700                 sieve_editor_set_status_icon(page, NULL);
701         }
702 }
703
704 static void got_data_loading(SieveSession *session, gboolean aborted,
705                 gchar *contents, SieveEditorPage *page)
706 {
707         if (aborted)
708                 return;
709         if (contents == NULL) {
710                 /* end of data */
711                 sieve_editor_set_status(page, "");
712                 return;
713         }
714         if (contents == (void *)-1) {
715                 /* error */
716                 if (page->first_line) {
717                         /* no data. show error in manager window */
718                         if (page->on_load_error)
719                                 page->on_load_error(session, page->on_load_error_data);
720                 } else {
721                         /* partial failure. show error in editor window */
722                         sieve_editor_set_status(page, _("Unable to get script contents"));
723                         sieve_editor_set_status_icon(page, GTK_STOCK_DIALOG_ERROR);
724                 }
725                 return;
726         }
727
728         if (page->first_line) {
729                 page->first_line = FALSE;
730                 sieve_editor_show(page);
731         } else {
732                 sieve_editor_append_text(page, "\n", 1);
733         }
734         sieve_editor_append_text(page, contents, strlen(contents));
735 }
736
737 /* load the script for this editor */
738 void sieve_editor_load(SieveEditorPage *page,
739                 sieve_session_cb_fn on_load_error, gpointer load_error_data)
740 {
741         page->first_line = TRUE;
742         page->on_load_error = on_load_error;
743         page->on_load_error_data = load_error_data;
744         sieve_editor_set_status(page, _("Loading..."));
745         sieve_editor_set_status_icon(page, NULL);
746         sieve_session_get_script(page->session, page->script_name,
747                         (sieve_session_data_cb_fn)got_data_loading, page);
748 }