mail/em-composer-prefs.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  *  Authors: Jeffrey Stedfast <fejj@ximian.com>
   4  *
   5  *  Copyright 2002-2003 Ximian, Inc. (www.ximian.com)
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 59 Temple Street #330, Boston, MA 02111-1307, USA.
  20  *
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26
  27 #include <string.h>
  28 #include <sys/types.h>
  29 #include <sys/stat.h>
  30 #include <unistd.h>
  31 #include <fcntl.h>
  32
  33 #include "e-util/e-signature.h"
  34 #include "e-util/e-signature-list.h"
  35
  36 #include "em-composer-prefs.h"
  37 #include "composer/e-msg-composer.h"
  38
  39 #include <bonobo/bonobo-generic-factory.h>
  40
  41 #include <libedataserver/e-iconv.h>
  42 #include <misc/e-gui-utils.h>
  43
  44 #include <gdk/gdkkeysyms.h>
  45
  46 #include <gtk/gtkentry.h>
  47 #include <gtk/gtktreemodel.h>
  48 #include <gtk/gtkliststore.h>
  49 #include <gtk/gtktreeselection.h>
  50 #include <gtk/gtktreeview.h>
  51 #include <gtk/gtkdialog.h>
  52 #include <gtk/gtkbutton.h>
  53 #include <gtk/gtktogglebutton.h>
  54 #include <gtk/gtkoptionmenu.h>
  55 #include <gtk/gtkcellrenderertoggle.h>
  56 #include <gtk/gtkcellrenderertext.h>
  57 #include <gtk/gtkimage.h>
  58 #include <gtk/gtkstock.h>
  59
  60 #include <gtk/gtkfilechooserbutton.h>
  61 #include <libgnomeui/gnome-color-picker.h>
  62
  63 #include <gtkhtml/gtkhtml.h>
  64
  65 #include <glib/gstdio.h>
  66
  67 #include "misc/e-charset-picker.h"
  68 #include "e-util/e-error.h"
  69 #include "e-util/e-util-private.h"
  70 #include "e-util/e-icon-factory.h"
  71
  72 #include "mail-config.h"
  73 #include "mail-signature-editor.h"
  74 #include "em-config.h"
  75
  76 #define d(x)
  77
  78 static void em_composer_prefs_class_init (EMComposerPrefsClass *class);
  79 static void em_composer_prefs_init       (EMComposerPrefs *dialog);
  80 static void em_composer_prefs_destroy    (GtkObject *obj);
  81 static void em_composer_prefs_finalise   (GObject *obj);
  82
  83
  84 static GtkVBoxClass *parent_class = NULL;
  85
  86
  87 GType
  88 em_composer_prefs_get_type (void)
  89 {
  90         static GType type = 0;
  91
  92         if (!type) {
  93                 static const GTypeInfo info = {
  94                         sizeof (EMComposerPrefsClass),
  95                         NULL, NULL,
  96                         (GClassInitFunc) em_composer_prefs_class_init,
  97                         NULL, NULL,
  98                         sizeof (EMComposerPrefs),
  99                         0,
 100                         (GInstanceInitFunc) em_composer_prefs_init,
 101                 };
 102
 103                 type = g_type_register_static (gtk_vbox_get_type (), "EMComposerPrefs", &info, 0);
 104         }
 105
 106         return type;
 107 }
 108
 109 static void
 110 em_composer_prefs_class_init (EMComposerPrefsClass *klass)
 111 {
 112         GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 113         GtkObjectClass *object_class = GTK_OBJECT_CLASS (klass);
 114
 115         parent_class = g_type_class_ref (gtk_vbox_get_type ());
 116
 117         object_class->destroy = em_composer_prefs_destroy;
 118         gobject_class->finalize = em_composer_prefs_finalise;
 119 }
 120
 121 static void
 122 em_composer_prefs_init (EMComposerPrefs *prefs)
 123 {
 124         prefs->enabled_pixbuf = e_icon_factory_get_icon ("stock_mark", E_ICON_SIZE_MENU);
 125         prefs->sig_hash = g_hash_table_new (g_direct_hash, g_direct_equal);
 126 }
 127
 128 static void
 129 row_free (ESignature *sig, GtkTreeRowReference *row, gpointer user_data)
 130 {
 131         gtk_tree_row_reference_free (row);
 132 }
 133
 134 static void
 135 em_composer_prefs_finalise (GObject *obj)
 136 {
 137         EMComposerPrefs *prefs = (EMComposerPrefs *) obj;
 138
 139         g_object_unref (prefs->gui);
 140         g_object_unref (prefs->enabled_pixbuf);
 141
 142         g_hash_table_foreach (prefs->sig_hash, (GHFunc) row_free, NULL);
 143         g_hash_table_destroy (prefs->sig_hash);
 144
 145         G_OBJECT_CLASS (parent_class)->finalize (obj);
 146 }
 147
 148 static void
 149 em_composer_prefs_destroy (GtkObject *obj)
 150 {
 151         EMComposerPrefs *prefs = (EMComposerPrefs *) obj;
 152         ESignatureList *signatures;
 153
 154         signatures = mail_config_get_signatures ();
 155
 156         if (prefs->sig_added_id != 0) {
 157                 g_signal_handler_disconnect (signatures, prefs->sig_added_id);
 158                 prefs->sig_added_id = 0;
 159         }
 160
 161         if (prefs->sig_removed_id != 0) {
 162                 g_signal_handler_disconnect (signatures, prefs->sig_removed_id);
 163                 prefs->sig_removed_id = 0;
 164         }
 165
 166         if (prefs->sig_changed_id != 0) {
 167                 g_signal_handler_disconnect (signatures, prefs->sig_changed_id);
 168                 prefs->sig_changed_id = 0;
 169         }
 170
 171         GTK_OBJECT_CLASS (parent_class)->destroy (obj);
 172 }
 173
 174
 175 static void
 176 sig_load_preview (EMComposerPrefs *prefs, ESignature *sig)
 177 {
 178         char *str;
 179
 180         if (!sig) {
 181                 gtk_html_load_from_string (GTK_HTML (prefs->sig_preview), " ", 1);
 182                 return;
 183         }
 184
 185         if (sig->script)
 186                 str = mail_config_signature_run_script (sig->filename);
 187         else
 188                 str = e_msg_composer_get_sig_file_content (sig->filename, sig->html);
 189         if (!str)
 190                 str = g_strdup ("");
 191
 192         /* printf ("HTML: %s\n", str); */
 193         if (sig->html) {
 194                 gtk_html_load_from_string (GTK_HTML (prefs->sig_preview), str, strlen (str));
 195         } else {
 196                 GtkHTMLStream *stream;
 197                 int len;
 198
 199                 len = strlen (str);
 200                 stream = gtk_html_begin_content (GTK_HTML (prefs->sig_preview), "text/html; charset=utf-8");
 201                 gtk_html_write (GTK_HTML (prefs->sig_preview), stream, "<PRE>", 5);
 202                 if (len)
 203                         gtk_html_write (GTK_HTML (prefs->sig_preview), stream, str, len);
 204                 gtk_html_write (GTK_HTML (prefs->sig_preview), stream, "</PRE>", 6);
 205                 gtk_html_end (GTK_HTML (prefs->sig_preview), stream, GTK_HTML_STREAM_OK);
 206         }
 207
 208         g_free (str);
 209 }
 210
 211 static void
 212 signature_added (ESignatureList *signatures, ESignature *sig, EMComposerPrefs *prefs)
 213 {
 214         GtkTreeRowReference *row;
 215         GtkTreeModel *model;
 216         GtkTreePath *path;
 217         GtkTreeIter iter;
 218
 219         /* autogen signature is special */
 220         if (sig->autogen)
 221                 return;
 222
 223         model = gtk_tree_view_get_model (prefs->sig_list);
 224         gtk_list_store_append ((GtkListStore *) model, &iter);
 225         gtk_list_store_set ((GtkListStore *) model, &iter, 0, sig->name, 1, sig, -1);
 226
 227         path = gtk_tree_model_get_path (model, &iter);
 228         row = gtk_tree_row_reference_new (model, path);
 229         gtk_tree_path_free (path);
 230
 231         g_hash_table_insert (prefs->sig_hash, sig, row);
 232 }
 233
 234 static void
 235 signature_removed (ESignatureList *signatures, ESignature *sig, EMComposerPrefs *prefs)
 236 {
 237         GtkTreeRowReference *row;
 238         GtkTreeModel *model;
 239         GtkTreePath *path;
 240         GtkTreeIter iter;
 241
 242         if (!(row = g_hash_table_lookup (prefs->sig_hash, sig)))
 243                 return;
 244
 245         g_hash_table_remove (prefs->sig_hash, sig);
 246
 247         model = gtk_tree_view_get_model (prefs->sig_list);
 248         path = gtk_tree_row_reference_get_path (row);
 249         gtk_tree_row_reference_free (row);
 250
 251         if (!gtk_tree_model_get_iter (model, &iter, path)) {
 252                 gtk_tree_path_free (path);
 253                 return;
 254         }
 255
 256         gtk_list_store_remove ((GtkListStore *) model, &iter);
 257 }
 258
 259 static void
 260 signature_changed (ESignatureList *signatures, ESignature *sig, EMComposerPrefs *prefs)
 261 {
 262         GtkTreeSelection *selection;
 263         GtkTreeRowReference *row;
 264         GtkTreeModel *model;
 265         GtkTreePath *path;
 266         GtkTreeIter iter;
 267         ESignature *cur;
 268
 269         if (!(row = g_hash_table_lookup (prefs->sig_hash, sig)))
 270                 return;
 271
 272         model = gtk_tree_view_get_model (prefs->sig_list);
 273         path = gtk_tree_row_reference_get_path (row);
 274
 275         if (!gtk_tree_model_get_iter (model, &iter, path)) {
 276                 gtk_tree_path_free (path);
 277                 return;
 278         }
 279
 280         gtk_tree_path_free (path);
 281
 282         gtk_list_store_set ((GtkListStore *) model, &iter, 0, sig->name, -1);
 283
 284         selection = gtk_tree_view_get_selection (prefs->sig_list);
 285         if (gtk_tree_selection_get_selected (selection, &model, &iter)) {
 286                 gtk_tree_model_get (model, &iter, 1, &cur, -1);
 287                 if (cur == sig)
 288                         sig_load_preview (prefs, sig);
 289         }
 290 }
 291
 292 static void
 293 sig_edit_cb (GtkWidget *widget, EMComposerPrefs *prefs)
 294 {
 295         GtkTreeSelection *selection;
 296         GtkTreeModel *model;
 297         GtkWidget *parent;
 298         GtkTreeIter iter;
 299         ESignature *sig;
 300
 301         selection = gtk_tree_view_get_selection (prefs->sig_list);
 302         if (!gtk_tree_selection_get_selected (selection, &model, &iter))
 303                 return;
 304
 305         gtk_tree_model_get (model, &iter, 1, &sig, -1);
 306
 307         if (!sig->script) {
 308                 /* normal signature */
 309                 if (!sig->filename || *sig->filename == '\0') {
 310                         g_free (sig->filename);
 311                         sig->filename = g_strdup (_("Unnamed"));
 312                 }
 313
 314                 parent = gtk_widget_get_toplevel ((GtkWidget *) prefs);
 315                 parent = GTK_WIDGET_TOPLEVEL (parent) ? parent : NULL;
 316
 317                 mail_signature_editor (sig, (GtkWindow *) parent, FALSE);
 318         } else {
 319                 /* signature script */
 320                 GtkWidget *entry;
 321
 322                 entry = glade_xml_get_widget (prefs->sig_script_gui, "filechooserbutton_add_script");
 323                 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (entry), sig->filename);
 324
 325                 entry = glade_xml_get_widget (prefs->sig_script_gui, "entry_add_script_name");
 326                 gtk_entry_set_text (GTK_ENTRY (entry), sig->name);
 327
 328                 g_object_set_data ((GObject *) entry, "sig", sig);
 329
 330                 gtk_window_present ((GtkWindow *) prefs->sig_script_dialog);
 331         }
 332 }
 333
 334 void
 335 em_composer_prefs_new_signature (GtkWindow *parent, gboolean html)
 336 {
 337         ESignature *sig;
 338
 339         sig = mail_config_signature_new (NULL, FALSE, html);
 340         mail_signature_editor (sig, parent, TRUE);
 341 }
 342
 343 static void
 344 sig_delete_cb (GtkWidget *widget, EMComposerPrefs *prefs)
 345 {
 346         GtkTreeSelection *selection;
 347         GtkTreeModel *model;
 348         GtkTreeIter iter;
 349         ESignature *sig;
 350
 351         selection = gtk_tree_view_get_selection (prefs->sig_list);
 352
 353         if (gtk_tree_selection_get_selected (selection, &model, &iter)) {
 354                 gtk_tree_model_get (model, &iter, 1, &sig, -1);
 355                 mail_config_remove_signature (sig);
 356         }
 357         gtk_widget_grab_focus ((GtkWidget *)prefs->sig_list);
 358 }
 359
 360 static void
 361 sig_add_cb (GtkWidget *widget, EMComposerPrefs *prefs)
 362 {
 363         GConfClient *gconf;
 364         gboolean send_html;
 365         GtkWidget *parent;
 366
 367         gconf = mail_config_get_gconf_client ();
 368         send_html = gconf_client_get_bool (gconf, "/apps/evolution/mail/composer/send_html", NULL);
 369
 370         parent = gtk_widget_get_toplevel ((GtkWidget *) prefs);
 371         parent = GTK_WIDGET_TOPLEVEL (parent) ? parent : NULL;
 372
 373         em_composer_prefs_new_signature ((GtkWindow *) parent, send_html);
 374         gtk_widget_grab_focus ((GtkWidget *)prefs->sig_list);
 375 }
 376
 377 static void
 378 sig_add_script_response (GtkWidget *widget, int button, EMComposerPrefs *prefs)
 379 {
 380         char *script, **argv = NULL;
 381         GtkWidget *entry;
 382         const char *name;
 383         int argc;
 384
 385         if (button == GTK_RESPONSE_ACCEPT) {
 386                 entry = glade_xml_get_widget (prefs->sig_script_gui, "filechooserbutton_add_script");
 387                 script = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (entry));
 388
 389                 entry = glade_xml_get_widget (prefs->sig_script_gui, "entry_add_script_name");
 390                 name = gtk_entry_get_text (GTK_ENTRY (entry));
 391                 if (script && *script && g_shell_parse_argv (script, &argc, &argv, NULL)) {
 392                         struct stat st;
 393
 394                         if (g_stat (argv[0], &st) == 0 && S_ISREG (st.st_mode) && g_access (argv[0], X_OK) == 0) {
 395                                 ESignature *sig;
 396
 397                                 if ((sig = g_object_get_data ((GObject *) entry, "sig"))) {
 398                                         /* we're just editing an existing signature script */
 399                                         g_free (sig->name);
 400                                         sig->name = g_strdup (name);
 401                                         g_free(sig->filename);
 402                                         sig->filename = g_strdup(script);
 403                                         e_signature_list_change (mail_config_get_signatures (), sig);
 404                                 } else {
 405                                         sig = mail_config_signature_new (script, TRUE, TRUE);
 406                                         sig->name = g_strdup (name);
 407
 408                                         e_signature_list_add (mail_config_get_signatures (), sig);
 409                                         g_object_unref (sig);
 410                                 }
 411
 412                                 mail_config_save_signatures();
 413
 414                                 gtk_widget_hide (prefs->sig_script_dialog);
 415                                 g_strfreev (argv);
 416                                 g_free (script);
 417
 418                                 return;
 419                         }
 420                 }
 421
 422                 e_error_run((GtkWindow *)prefs->sig_script_dialog, "mail:signature-notscript", argv ? argv[0] : script, NULL);
 423                 g_strfreev (argv);
 424                 g_free (script);
 425                 return;
 426         }
 427
 428         gtk_widget_hide (widget);
 429 }
 430
 431 static void
 432 sig_add_script_cb (GtkWidget *widget, EMComposerPrefs *prefs)
 433 {
 434         GtkWidget *entry;
 435
 436         entry = glade_xml_get_widget (prefs->sig_script_gui, "entry_add_script_name");
 437         gtk_entry_set_text (GTK_ENTRY (entry), _("Unnamed"));
 438
 439         g_object_set_data ((GObject *) entry, "sig", NULL);
 440
 441         gtk_window_present ((GtkWindow *) prefs->sig_script_dialog);
 442 }
 443
 444 static void
 445 sig_selection_changed (GtkTreeSelection *selection, EMComposerPrefs *prefs)
 446 {
 447         GtkTreeModel *model;
 448         GtkTreeIter iter;
 449         ESignature *sig;
 450         int state;
 451
 452         state = gtk_tree_selection_get_selected (selection, &model, &iter);
 453         if (state) {
 454                 gtk_tree_model_get (model, &iter, 1, &sig, -1);
 455                 sig_load_preview (prefs, sig);
 456         } else
 457                 sig_load_preview (prefs, NULL);
 458
 459         gtk_widget_set_sensitive ((GtkWidget *) prefs->sig_delete, state);
 460         gtk_widget_set_sensitive ((GtkWidget *) prefs->sig_edit, state);
 461 }
 462
 463 static void
 464 sig_fill_list (EMComposerPrefs *prefs)
 465 {
 466         ESignatureList *signatures;
 467         GtkListStore *model;
 468         EIterator *it;
 469
 470         model = (GtkListStore *) gtk_tree_view_get_model (prefs->sig_list);
 471         gtk_list_store_clear (model);
 472
 473         signatures = mail_config_get_signatures ();
 474         it = e_list_get_iterator ((EList *) signatures);
 475
 476         while (e_iterator_is_valid (it)) {
 477                 ESignature *sig;
 478
 479                 sig = (ESignature *) e_iterator_get (it);
 480                 signature_added (signatures, sig, prefs);
 481
 482                 e_iterator_next (it);
 483         }
 484
 485         g_object_unref (it);
 486
 487         gtk_widget_set_sensitive ((GtkWidget *) prefs->sig_edit, FALSE);
 488         gtk_widget_set_sensitive ((GtkWidget *) prefs->sig_delete, FALSE);
 489
 490         prefs->sig_added_id = g_signal_connect (signatures, "signature-added", G_CALLBACK (signature_added), prefs);
 491         prefs->sig_removed_id = g_signal_connect (signatures, "signature-removed", G_CALLBACK (signature_removed), prefs);
 492         prefs->sig_changed_id = g_signal_connect (signatures, "signature-changed", G_CALLBACK (signature_changed), prefs);
 493 }
 494
 495 static void
 496 url_requested (GtkHTML *html, const char *url, GtkHTMLStream *handle)
 497 {
 498         GtkHTMLStreamStatus status;
 499         char buf[128];
 500         ssize_t size;
 501         int fd;
 502         char *filename;
 503
 504         if (!strncmp (url, "file:", 5))
 505                 filename = g_filename_from_uri (url, NULL, NULL);
 506         else
 507                 filename = g_strdup (url);
 508         fd = g_open (filename, O_RDONLY | O_BINARY, 0);
 509         g_free (filename);
 510
 511         status = GTK_HTML_STREAM_OK;
 512         if (fd != -1) {
 513                 while ((size = read (fd, buf, sizeof (buf)))) {
 514                         if (size == -1) {
 515                                 status = GTK_HTML_STREAM_ERROR;
 516                                 break;
 517                         } else
 518                                 gtk_html_write (html, handle, buf, size);
 519                 }
 520         } else
 521                 status = GTK_HTML_STREAM_ERROR;
 522
 523         gtk_html_end (html, handle, status);
 524         if (fd > 0)
 525                 close (fd);
 526 }
 527
 528
 529 /*
 530  *
 531  * Spell checking cut'n'pasted from gnome-spell/capplet/main.c
 532  *
 533  */
 534
 535 #include "Spell.h"
 536
 537 #define GNOME_SPELL_GCONF_DIR "/GNOME/Spell"
 538 #define SPELL_API_VERSION "0.3"
 539
 540 static void
 541 spell_set_ui (EMComposerPrefs *prefs)
 542 {
 543         GHashTable *present;
 544         GtkListStore *model;
 545         GtkTreeIter iter;
 546         GError *err = NULL;
 547         char **strv = NULL;
 548         guint r, g, b;
 549         gboolean go;
 550         char *lang;
 551         int i;
 552
 553         prefs->spell_active = FALSE;
 554
 555         /* setup the language list */
 556         if (!(lang = gconf_client_get_string (prefs->gconf, GNOME_SPELL_GCONF_DIR "/language", &err)) || err) {
 557                 g_free (lang);
 558                 g_clear_error (&err);
 559                 lang = g_strdup (e_iconv_locale_language ());
 560         }
 561
 562         present = g_hash_table_new (g_str_hash, g_str_equal);
 563         if (lang && (strv = g_strsplit (lang, " ", 0))) {
 564                 for (i = 0; strv[i]; i++)
 565                         g_hash_table_insert (present, strv[i], strv[i]);
 566         }
 567
 568         g_free (lang);
 569
 570         model = (GtkListStore *) gtk_tree_view_get_model (prefs->language);
 571         for (go = gtk_tree_model_get_iter_first ((GtkTreeModel *) model, &iter); go;
 572              go = gtk_tree_model_iter_next ((GtkTreeModel *) model, &iter)) {
 573                 char *abbr;
 574
 575                 gtk_tree_model_get ((GtkTreeModel *) model, &iter, 2, &abbr, -1);
 576                 gtk_list_store_set (model, &iter, 0, g_hash_table_lookup (present, abbr) != NULL, -1);
 577         }
 578
 579         g_hash_table_destroy (present);
 580         if (strv != NULL)
 581                 g_strfreev (strv);
 582
 583         r = gconf_client_get_int (prefs->gconf, GNOME_SPELL_GCONF_DIR "/spell_error_color_red", NULL);
 584         g = gconf_client_get_int (prefs->gconf, GNOME_SPELL_GCONF_DIR "/spell_error_color_green", NULL);
 585         b = gconf_client_get_int (prefs->gconf, GNOME_SPELL_GCONF_DIR "/spell_error_color_blue", NULL);
 586
 587         gnome_color_picker_set_i16 (GNOME_COLOR_PICKER (prefs->colour), r, g, b, 0xffff);
 588
 589         prefs->spell_active = TRUE;
 590 }
 591
 592 static void
 593 spell_color_set (GtkWidget *widget, guint r, guint g, guint b, guint a, EMComposerPrefs *prefs)
 594 {
 595         gconf_client_set_int (prefs->gconf, GNOME_SPELL_GCONF_DIR "/spell_error_color_red", r, NULL);
 596         gconf_client_set_int (prefs->gconf, GNOME_SPELL_GCONF_DIR "/spell_error_color_green", g, NULL);
 597         gconf_client_set_int (prefs->gconf, GNOME_SPELL_GCONF_DIR "/spell_error_color_blue", b, NULL);
 598 }
 599
 600 static char *
 601 spell_get_language_str (EMComposerPrefs *prefs)
 602 {
 603         GtkListStore *model;
 604         GtkTreeIter iter;
 605         GString *str;
 606         char *rv;
 607
 608         model = (GtkListStore *) gtk_tree_view_get_model (prefs->language);
 609         if (!gtk_tree_model_get_iter_first ((GtkTreeModel *) model, &iter))
 610                 return NULL;
 611
 612         str = g_string_new ("");
 613
 614         do {
 615                 gboolean state;
 616                 char *abbr;
 617
 618                 gtk_tree_model_get ((GtkTreeModel *) model, &iter, 0, &state, 2, &abbr, -1);
 619
 620                 if (state) {
 621                         if (str->len)
 622                                 g_string_append_c (str, ' ');
 623                         g_string_append (str, abbr);
 624                 }
 625
 626                 if (!gtk_tree_model_iter_next ((GtkTreeModel *) model, &iter))
 627                         break;
 628         } while (1);
 629
 630         rv = str->str;
 631         g_string_free (str, FALSE);
 632
 633         return rv;
 634 }
 635
 636 static void
 637 spell_language_toggled (GtkCellRendererToggle *renderer, const char *path_string, EMComposerPrefs *prefs)
 638 {
 639         GtkTreePath *path = gtk_tree_path_new_from_string (path_string);
 640         GtkTreeModel *model;
 641         GtkTreeIter iter;
 642         gboolean enabled;
 643         char *str;
 644
 645         model = gtk_tree_view_get_model (prefs->language);
 646         gtk_tree_model_get_iter (model, &iter, path);
 647         gtk_tree_model_get (model, &iter, 0, &enabled, -1);
 648         gtk_list_store_set ((GtkListStore *) model, &iter, 0, !enabled, -1);
 649
 650         str = spell_get_language_str (prefs);
 651         gconf_client_set_string (prefs->gconf, GNOME_SPELL_GCONF_DIR "/language", str ? str : "", NULL);
 652         g_free (str);
 653
 654         gtk_tree_path_free (path);
 655 }
 656
 657 static void
 658 spell_setup (EMComposerPrefs *prefs)
 659 {
 660         GtkListStore *model;
 661         GtkTreeIter iter;
 662         GtkWidget *widget;
 663         int i;
 664
 665         model = (GtkListStore *) gtk_tree_view_get_model (prefs->language);
 666
 667         if (prefs->language_seq) {
 668                 for (i = 0; i < prefs->language_seq->_length; i++) {
 669                         gtk_list_store_append (model, &iter);
 670                         gtk_list_store_set (model, &iter,
 671                                             1, _(prefs->language_seq->_buffer[i].name),
 672                                             2, prefs->language_seq->_buffer[i].abbreviation,
 673                                             -1);
 674                 }
 675         }
 676
 677         spell_set_ui (prefs);
 678
 679         widget = glade_xml_get_widget (prefs->gui, "colorpickerSpellCheckColor");
 680         g_signal_connect (widget, "color_set", G_CALLBACK (spell_color_set), prefs);
 681 }
 682
 683 static gboolean
 684 spell_setup_check_options (EMComposerPrefs *prefs)
 685 {
 686         GNOME_Spell_Dictionary dict;
 687         CORBA_Environment ev;
 688         char *dictionary_id;
 689
 690         dictionary_id = "OAFIID:GNOME_Spell_Dictionary:" SPELL_API_VERSION;
 691         dict = bonobo_activation_activate_from_id (dictionary_id, 0, NULL, NULL);
 692         if (dict == CORBA_OBJECT_NIL) {
 693                 g_warning ("Cannot activate %s", dictionary_id);
 694
 695                 return FALSE;
 696         }
 697
 698         CORBA_exception_init (&ev);
 699         prefs->language_seq = GNOME_Spell_Dictionary_getLanguages (dict, &ev);
 700         if (ev._major != CORBA_NO_EXCEPTION)
 701                 prefs->language_seq = NULL;
 702         CORBA_exception_free (&ev);
 703
 704         if (prefs->language_seq == NULL)
 705                 return FALSE;
 706
 707         gconf_client_add_dir (prefs->gconf, GNOME_SPELL_GCONF_DIR, GCONF_CLIENT_PRELOAD_NONE, NULL);
 708
 709         spell_setup (prefs);
 710
 711         return TRUE;
 712 }
 713
 714 /*
 715  * End of Spell checking
 716  */
 717
 718
 719 static void
 720 attach_style_info (GtkWidget *item, gpointer user_data)
 721 {
 722         int *style = user_data;
 723
 724         g_object_set_data ((GObject *) item, "style", GINT_TO_POINTER (*style));
 725
 726         (*style)++;
 727 }
 728
 729 static void
 730 toggle_button_toggled (GtkToggleButton *toggle, EMComposerPrefs *prefs)
 731 {
 732         const char *key;
 733
 734         key = g_object_get_data ((GObject *) toggle, "key");
 735         gconf_client_set_bool (prefs->gconf, key, gtk_toggle_button_get_active (toggle), NULL);
 736 }
 737
 738 static void
 739 style_activate (GtkWidget *item, EMComposerPrefs *prefs)
 740 {
 741         const char *key;
 742         int style;
 743
 744         key = g_object_get_data ((GObject *) item, "key");
 745         style = GPOINTER_TO_INT (g_object_get_data ((GObject *) item, "style"));
 746
 747         gconf_client_set_int (prefs->gconf, key, style, NULL);
 748 }
 749
 750 static void
 751 charset_activate (GtkWidget *item, EMComposerPrefs *prefs)
 752 {
 753         GtkWidget *menu;
 754         char *string;
 755
 756         menu = gtk_option_menu_get_menu (prefs->charset);
 757         if (!(string = e_charset_picker_get_charset (menu)))
 758                 string = g_strdup (e_iconv_locale_charset ());
 759
 760         gconf_client_set_string (prefs->gconf, "/apps/evolution/mail/composer/charset", string, NULL);
 761         g_free (string);
 762 }
 763
 764 static void
 765 option_menu_connect (EMComposerPrefs *prefs, GtkOptionMenu *omenu, GCallback callback, const char *key)
 766 {
 767         GtkWidget *menu, *item;
 768         GList *items;
 769
 770         menu = gtk_option_menu_get_menu (omenu);
 771
 772         items = GTK_MENU_SHELL (menu)->children;
 773         while (items) {
 774                 item = items->data;
 775                 g_object_set_data ((GObject *) item, "key", (void *) key);
 776                 g_signal_connect (item, "activate", callback, prefs);
 777                 items = items->next;
 778         }
 779
 780         if (!gconf_client_key_is_writable (prefs->gconf, key, NULL))
 781                 gtk_widget_set_sensitive ((GtkWidget *) omenu, FALSE);
 782 }
 783
 784 static void
 785 toggle_button_init (EMComposerPrefs *prefs, GtkToggleButton *toggle, int not, const char *key)
 786 {
 787         gboolean bool;
 788
 789         bool = gconf_client_get_bool (prefs->gconf, key, NULL);
 790         gtk_toggle_button_set_active (toggle, not ? !bool : bool);
 791
 792         g_object_set_data ((GObject *) toggle, "key", (void *) key);
 793         g_signal_connect (toggle, "toggled", G_CALLBACK (toggle_button_toggled), prefs);
 794
 795         if (!gconf_client_key_is_writable (prefs->gconf, key, NULL))
 796                 gtk_widget_set_sensitive ((GtkWidget *) toggle, FALSE);
 797 }
 798
 799 static GtkWidget *
 800 emcp_widget_glade(EConfig *ec, EConfigItem *item, struct _GtkWidget *parent, struct _GtkWidget *old, void *data)
 801 {
 802         EMComposerPrefs *prefs = data;
 803
 804         return glade_xml_get_widget(prefs->gui, item->label);
 805 }
 806
 807 /* plugin meta-data */
 808 static EMConfigItem emcp_items[] = {
 809         { E_CONFIG_BOOK, "", "composer_toplevel", emcp_widget_glade },
 810         { E_CONFIG_PAGE, "00.general", "vboxGeneral", emcp_widget_glade },
 811         { E_CONFIG_SECTION, "00.general/00.behavior", "vboxBehavior", emcp_widget_glade },
 812         { E_CONFIG_SECTION, "00.general/10.alerts", "vboxAlerts", emcp_widget_glade },
 813         { E_CONFIG_PAGE, "10.signatures", "vboxSignatures", emcp_widget_glade },
 814         /* signature/signatures and signature/preview parts not usable */
 815
 816         { E_CONFIG_PAGE, "20.spellcheck", "vboxSpellChecking", emcp_widget_glade },
 817         { E_CONFIG_SECTION, "20.spellcheck/00.languages", "vbox178", emcp_widget_glade },
 818         { E_CONFIG_SECTION, "20.spellcheck/00.options", "vboxOptions", emcp_widget_glade },
 819 };
 820
 821 static void
 822 emcp_free(EConfig *ec, GSList *items, void *data)
 823 {
 824         /* the prefs data is freed automagically */
 825
 826         g_slist_free(items);
 827 }
 828
 829 static void
 830 signature_key_press (GtkTreeView *tree_view, GdkEventKey *event, EMComposerPrefs *prefs)
 831 {
 832         /* No need to care about anything other than DEL key */
 833         if (event->keyval == GDK_Delete)
 834                 sig_delete_cb ((GtkWidget *)tree_view, prefs);
 835
 836         return ;
 837 }
 838
 839 static gboolean
 840 sig_tree_event_cb (GtkTreeView *tree_view, GdkEvent *event, EMComposerPrefs *prefs)
 841 {
 842         gboolean ret = FALSE;
 843
 844         if (event->type == GDK_2BUTTON_PRESS) {
 845                 sig_edit_cb ((GtkWidget *)tree_view, prefs);
 846                 ret = TRUE;
 847         }
 848
 849         return ret;
 850 }
 851
 852 static void
 853 em_composer_prefs_construct (EMComposerPrefs *prefs)
 854 {
 855         GtkWidget *toplevel, *widget, *menu, *info_pixmap;
 856         GtkDialog *dialog;
 857         GladeXML *gui;
 858         GtkListStore *model;
 859         GtkTreeSelection *selection;
 860         GtkCellRenderer *cell_renderer;
 861         int style;
 862         char *buf;
 863         EMConfig *ec;
 864         EMConfigTargetPrefs *target;
 865         GSList *l;
 866         int i;
 867         char *gladefile;
 868
 869         prefs->gconf = mail_config_get_gconf_client ();
 870
 871         gladefile = g_build_filename (EVOLUTION_GLADEDIR,
 872                                       "mail-config.glade",
 873                                       NULL);
 874         gui = glade_xml_new (gladefile, "composer_toplevel", NULL);
 875         prefs->gui = gui;
 876         prefs->sig_script_gui = glade_xml_new (gladefile, "vbox_add_script_signature", NULL);
 877         g_free (gladefile);
 878
 879         /** @HookPoint-EMConfig: Mail Composer Preferences
 880          * @Id: org.gnome.evolution.mail.composerPrefs
 881          * @Type: E_CONFIG_BOOK
 882          * @Class: org.gnome.evolution.mail.config:1.0
 883          * @Target: EMConfigTargetPrefs
 884          *
 885          * The mail composer preferences settings page.
 886          */
 887         ec = em_config_new(E_CONFIG_BOOK, "org.gnome.evolution.mail.composerPrefs");
 888         l = NULL;
 889         for (i=0;i<sizeof(emcp_items)/sizeof(emcp_items[0]);i++)
 890                 l = g_slist_prepend(l, &emcp_items[i]);
 891         e_config_add_items((EConfig *)ec, l, NULL, NULL, emcp_free, prefs);
 892
 893         /* General tab */
 894
 895         /* Default Behavior */
 896         prefs->send_html = GTK_TOGGLE_BUTTON (glade_xml_get_widget (gui, "chkSendHTML"));
 897         toggle_button_init (prefs, prefs->send_html, FALSE,
 898                             "/apps/evolution/mail/composer/send_html");
 899
 900         prefs->prompt_empty_subject = GTK_TOGGLE_BUTTON (glade_xml_get_widget (gui, "chkPromptEmptySubject"));
 901         toggle_button_init (prefs, prefs->prompt_empty_subject, FALSE,
 902                             "/apps/evolution/mail/prompts/empty_subject");
 903
 904         prefs->prompt_bcc_only = GTK_TOGGLE_BUTTON (glade_xml_get_widget (gui, "chkPromptBccOnly"));
 905         toggle_button_init (prefs, prefs->prompt_bcc_only, FALSE,
 906                             "/apps/evolution/mail/prompts/only_bcc");
 907
 908         prefs->auto_smileys = GTK_TOGGLE_BUTTON (glade_xml_get_widget (gui, "chkAutoSmileys"));
 909         toggle_button_init (prefs, prefs->auto_smileys, FALSE,
 910                             "/apps/evolution/mail/composer/magic_smileys");
 911
 912         prefs->spell_check = GTK_TOGGLE_BUTTON (glade_xml_get_widget (gui, "chkEnableSpellChecking"));
 913         toggle_button_init (prefs, prefs->spell_check, FALSE,
 914                             "/apps/evolution/mail/composer/inline_spelling");
 915
 916         prefs->charset = GTK_OPTION_MENU (glade_xml_get_widget (gui, "omenuCharset"));
 917         buf = gconf_client_get_string (prefs->gconf, "/apps/evolution/mail/composer/charset", NULL);
 918         menu = e_charset_picker_new (buf && *buf ? buf : e_iconv_locale_charset ());
 919         gtk_option_menu_set_menu (prefs->charset, GTK_WIDGET (menu));
 920         option_menu_connect (prefs, prefs->charset, G_CALLBACK (charset_activate),
 921                              "/apps/evolution/mail/composer/charset");
 922         g_free (buf);
 923
 924         /* Spell Checking: GNOME Spell part */
 925         prefs->colour = GNOME_COLOR_PICKER (glade_xml_get_widget (gui, "colorpickerSpellCheckColor"));
 926         prefs->language = GTK_TREE_VIEW (glade_xml_get_widget (gui, "listSpellCheckLanguage"));
 927         model = gtk_list_store_new (3, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_POINTER);
 928         gtk_tree_view_set_model (prefs->language, (GtkTreeModel *) model);
 929         cell_renderer = gtk_cell_renderer_toggle_new ();
 930         gtk_tree_view_insert_column_with_attributes (prefs->language, -1, _("Enabled"),
 931                                                      cell_renderer,
 932                                                      "active", 0,
 933                                                      NULL);
 934         g_signal_connect (cell_renderer, "toggled", G_CALLBACK (spell_language_toggled), prefs);
 935
 936         gtk_tree_view_insert_column_with_attributes (prefs->language, -1, _("Language(s)"),
 937                                                      gtk_cell_renderer_text_new (),
 938                                                      "text", 1,
 939                                                      NULL);
 940         selection = gtk_tree_view_get_selection (prefs->language);
 941         gtk_tree_selection_set_mode (selection, GTK_SELECTION_NONE);
 942         info_pixmap = glade_xml_get_widget (gui, "pixmapSpellInfo");
 943         gtk_image_set_from_stock (GTK_IMAGE (info_pixmap), GTK_STOCK_DIALOG_INFO, GTK_ICON_SIZE_BUTTON);
 944         if (!spell_setup_check_options (prefs)) {
 945                 gtk_widget_hide (GTK_WIDGET (prefs->colour));
 946                 gtk_widget_hide (GTK_WIDGET (prefs->language));
 947         }
 948
 949         /* Forwards and Replies */
 950         prefs->forward_style = GTK_OPTION_MENU (glade_xml_get_widget (gui, "omenuForwardStyle"));
 951         style = gconf_client_get_int (prefs->gconf, "/apps/evolution/mail/format/forward_style", NULL);
 952         gtk_option_menu_set_history (prefs->forward_style, style);
 953         style = 0;
 954         gtk_container_foreach (GTK_CONTAINER (gtk_option_menu_get_menu (prefs->forward_style)),
 955                                attach_style_info, &style);
 956         option_menu_connect (prefs, prefs->forward_style, G_CALLBACK (style_activate),
 957                              "/apps/evolution/mail/format/forward_style");
 958
 959         prefs->reply_style = GTK_OPTION_MENU (glade_xml_get_widget (gui, "omenuReplyStyle"));
 960         style = gconf_client_get_int (prefs->gconf, "/apps/evolution/mail/format/reply_style", NULL);
 961         gtk_option_menu_set_history (prefs->reply_style, style);
 962         style = 0;
 963         gtk_container_foreach (GTK_CONTAINER (gtk_option_menu_get_menu (prefs->reply_style)),
 964                                attach_style_info, &style);
 965         option_menu_connect (prefs, prefs->reply_style, G_CALLBACK (style_activate),
 966                              "/apps/evolution/mail/format/reply_style");
 967
 968         /* Signatures */
 969         dialog = (GtkDialog *) gtk_dialog_new ();
 970
 971         gtk_widget_realize ((GtkWidget *) dialog);
 972         gtk_container_set_border_width ((GtkContainer *)dialog->action_area, 12);
 973         gtk_container_set_border_width ((GtkContainer *)dialog->vbox, 0);
 974
 975         prefs->sig_script_dialog = (GtkWidget *) dialog;
 976         gtk_dialog_add_buttons (dialog, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
 977                                 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL);
 978         gtk_dialog_set_has_separator (dialog, FALSE);
 979         gtk_window_set_title ((GtkWindow *) dialog, _("Add signature script"));
 980         g_signal_connect (dialog, "response", G_CALLBACK (sig_add_script_response), prefs);
 981         widget = glade_xml_get_widget (prefs->sig_script_gui, "vbox_add_script_signature");
 982         gtk_box_pack_start ((GtkBox *) dialog->vbox, widget, TRUE, TRUE, 0);
 983
 984         prefs->sig_add = GTK_BUTTON (glade_xml_get_widget (gui, "cmdSignatureAdd"));
 985         g_signal_connect (prefs->sig_add, "clicked", G_CALLBACK (sig_add_cb), prefs);
 986
 987         prefs->sig_add_script = GTK_BUTTON (glade_xml_get_widget (gui, "cmdSignatureAddScript"));
 988         g_signal_connect (prefs->sig_add_script, "clicked", G_CALLBACK (sig_add_script_cb), prefs);
 989
 990         prefs->sig_edit = GTK_BUTTON (glade_xml_get_widget (gui, "cmdSignatureEdit"));
 991         g_signal_connect (prefs->sig_edit, "clicked", G_CALLBACK (sig_edit_cb), prefs);
 992
 993         prefs->sig_delete = GTK_BUTTON (glade_xml_get_widget (gui, "cmdSignatureDelete"));
 994         g_signal_connect (prefs->sig_delete, "clicked", G_CALLBACK (sig_delete_cb), prefs);
 995
 996         prefs->sig_list = GTK_TREE_VIEW (glade_xml_get_widget (gui, "listSignatures"));
 997         model = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_POINTER);
 998         gtk_tree_view_set_model (prefs->sig_list, (GtkTreeModel *)model);
 999         gtk_tree_view_insert_column_with_attributes (prefs->sig_list, -1, _("Signature(s)"),
1000                                                      gtk_cell_renderer_text_new (),
1001                                                      "text", 0,
1002                                                      NULL);
1003         selection = gtk_tree_view_get_selection (prefs->sig_list);
1004         gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
1005         g_signal_connect (selection, "changed", G_CALLBACK (sig_selection_changed), prefs);
1006         g_signal_connect (prefs->sig_list, "event", G_CALLBACK (sig_tree_event_cb), prefs);
1007
1008         sig_fill_list (prefs);
1009
1010         /* preview GtkHTML widget */
1011         widget = glade_xml_get_widget (gui, "scrolled-sig");
1012         prefs->sig_preview = (GtkHTML *) gtk_html_new ();
1013         g_signal_connect (prefs->sig_preview, "url_requested", G_CALLBACK (url_requested), NULL);
1014         gtk_widget_show (GTK_WIDGET (prefs->sig_preview));
1015         gtk_container_add (GTK_CONTAINER (widget), GTK_WIDGET (prefs->sig_preview));
1016
1017         /* get our toplevel widget */
1018         target = em_config_target_new_prefs(ec, prefs->gconf);
1019         e_config_set_target((EConfig *)ec, (EConfigTarget *)target);
1020         toplevel = e_config_create_widget((EConfig *)ec);
1021         gtk_container_add (GTK_CONTAINER (prefs), toplevel);
1022
1023         g_signal_connect (prefs->sig_list, "key-press-event", G_CALLBACK(signature_key_press), prefs);
1024 }
1025
1026 GtkWidget *
1027 em_composer_prefs_new (void)
1028 {
1029         EMComposerPrefs *new;
1030
1031         new = (EMComposerPrefs *) g_object_new (em_composer_prefs_get_type (), NULL);
1032         em_composer_prefs_construct (new);
1033
1034         return (GtkWidget *) new;
1035 }