src/textview.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 1999-2003 Hiroyuki Yamamoto
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #  include "config.h"
  22 #endif
  23
  24 #include "defs.h"
  25
  26 #include <glib.h>
  27 #include <gdk/gdk.h>
  28 #include <gdk/gdkkeysyms.h>
  29 #include <gtk/gtkvbox.h>
  30 #include <gtk/gtkscrolledwindow.h>
  31 #include <gtk/gtksignal.h>
  32 #include <stdio.h>
  33 #include <ctype.h>
  34 #include <string.h>
  35 #include <stdlib.h>
  36
  37 #include "intl.h"
  38 #include "main.h"
  39 #include "summaryview.h"
  40 #include "procheader.h"
  41 #include "prefs_common.h"
  42 #include "codeconv.h"
  43 #include "gtkstext.h"
  44 #include "utils.h"
  45 #include "gtkutils.h"
  46 #include "procmime.h"
  47 #include "html.h"
  48 #include "enriched.h"
  49 #include "compose.h"
  50 #include "addressbook.h"
  51 #include "displayheader.h"
  52 #include "account.h"
  53 #include "mimeview.h"
  54
  55 typedef struct _RemoteURI       RemoteURI;
  56
  57 struct _RemoteURI
  58 {
  59         gchar *uri;
  60
  61         guint start;
  62         guint end;
  63 };
  64
  65 static GdkColor quote_colors[3] = {
  66         {(gulong)0, (gushort)0, (gushort)0, (gushort)0},
  67         {(gulong)0, (gushort)0, (gushort)0, (gushort)0},
  68         {(gulong)0, (gushort)0, (gushort)0, (gushort)0}
  69 };
  70
  71 static GdkColor signature_color = {
  72         (gulong)0,
  73         (gushort)0x7fff,
  74         (gushort)0x7fff,
  75         (gushort)0x7fff
  76 };
  77
  78 static GdkColor uri_color = {
  79         (gulong)0,
  80         (gushort)0,
  81         (gushort)0,
  82         (gushort)0
  83 };
  84
  85 static GdkColor emphasis_color = {
  86         (gulong)0,
  87         (gushort)0,
  88         (gushort)0,
  89         (gushort)0xcfff
  90 };
  91
  92 #if 0
  93 static GdkColor error_color = {
  94         (gulong)0,
  95         (gushort)0xefff,
  96         (gushort)0,
  97         (gushort)0
  98 };
  99 #endif
 100
 101 #if USE_GPGME
 102 static GdkColor good_sig_color = {
 103         (gulong)0,
 104         (gushort)0,
 105         (gushort)0xbfff,
 106         (gushort)0
 107 };
 108
 109 static GdkColor nocheck_sig_color = {
 110         (gulong)0,
 111         (gushort)0,
 112         (gushort)0,
 113         (gushort)0xcfff
 114 };
 115
 116 static GdkColor bad_sig_color = {
 117         (gulong)0,
 118         (gushort)0xefff,
 119         (gushort)0,
 120         (gushort)0
 121 };
 122 #endif
 123
 124 static GdkFont *text_sb_font;
 125 static GdkFont *text_mb_font;
 126 static gint text_sb_font_orig_ascent;
 127 static gint text_sb_font_orig_descent;
 128 static gint text_mb_font_orig_ascent;
 129 static gint text_mb_font_orig_descent;
 130 static GdkFont *spacingfont;
 131
 132 static void textview_show_ertf          (TextView       *textview,
 133                                          FILE           *fp,
 134                                          CodeConverter  *conv);
 135 static void textview_add_part           (TextView       *textview,
 136                                          MimeInfo       *mimeinfo,
 137                                          FILE           *fp);
 138 static void textview_add_parts          (TextView       *textview,
 139                                          MimeInfo       *mimeinfo,
 140                                          FILE           *fp);
 141 static void textview_write_body         (TextView       *textview,
 142                                          MimeInfo       *mimeinfo,
 143                                          FILE           *fp,
 144                                          const gchar    *charset);
 145 static void textview_show_html          (TextView       *textview,
 146                                          FILE           *fp,
 147                                          CodeConverter  *conv);
 148 static void textview_write_line         (TextView       *textview,
 149                                          const gchar    *str,
 150                                          CodeConverter  *conv);
 151 static void textview_write_link         (TextView       *textview,
 152                                          const gchar    *url,
 153                                          const gchar    *str,
 154                                          CodeConverter  *conv);
 155 static GPtrArray *textview_scan_header  (TextView       *textview,
 156                                          FILE           *fp);
 157 static void textview_show_header        (TextView       *textview,
 158                                          GPtrArray      *headers);
 159
 160 static gint textview_key_pressed        (GtkWidget      *widget,
 161                                          GdkEventKey    *event,
 162                                          TextView       *textview);
 163 static gint textview_button_pressed     (GtkWidget      *widget,
 164                                          GdkEventButton *event,
 165                                          TextView       *textview);
 166 static gint textview_button_released    (GtkWidget      *widget,
 167                                          GdkEventButton *event,
 168                                          TextView       *textview);
 169
 170 static void textview_uri_list_remove_all(GSList         *uri_list);
 171
 172 static void textview_smooth_scroll_do           (TextView       *textview,
 173                                                  gfloat          old_value,
 174                                                  gfloat          last_value,
 175                                                  gint            step);
 176 static void textview_smooth_scroll_one_line     (TextView       *textview,
 177                                                  gboolean        up);
 178 static gboolean textview_smooth_scroll_page     (TextView       *textview,
 179                                                  gboolean        up);
 180
 181
 182 TextView *textview_create(void)
 183 {
 184         TextView *textview;
 185         GtkWidget *vbox;
 186         GtkWidget *scrolledwin_sb;
 187         GtkWidget *scrolledwin_mb;
 188         GtkWidget *text_sb;
 189         GtkWidget *text_mb;
 190
 191         debug_print("Creating text view...\n");
 192         textview = g_new0(TextView, 1);
 193
 194         scrolledwin_sb = gtk_scrolled_window_new(NULL, NULL);
 195         scrolledwin_mb = gtk_scrolled_window_new(NULL, NULL);
 196         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin_sb),
 197                                        GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
 198         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin_mb),
 199                                        GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
 200         gtk_widget_set_usize(scrolledwin_sb, prefs_common.mainview_width, -1);
 201         gtk_widget_set_usize(scrolledwin_mb, prefs_common.mainview_width, -1);
 202
 203         /* create GtkSText widgets for single-byte and multi-byte character */
 204         text_sb = gtk_stext_new(NULL, NULL);
 205         text_mb = gtk_stext_new(NULL, NULL);
 206         GTK_STEXT(text_sb)->default_tab_width = 8;
 207         GTK_STEXT(text_mb)->default_tab_width = 8;
 208         gtk_widget_show(text_sb);
 209         gtk_widget_show(text_mb);
 210         gtk_stext_set_word_wrap(GTK_STEXT(text_sb), TRUE);
 211         gtk_stext_set_word_wrap(GTK_STEXT(text_mb), TRUE);
 212         gtk_widget_ensure_style(text_sb);
 213         gtk_widget_ensure_style(text_mb);
 214         if (text_sb->style && text_sb->style->font->type == GDK_FONT_FONTSET) {
 215                 GtkStyle *style;
 216                 GdkFont *font;
 217
 218                 font = gtkut_font_load_from_fontset(prefs_common.normalfont);
 219                 if (font) {
 220                         style = gtk_style_copy(text_sb->style);
 221                         gdk_font_unref(style->font);
 222                         style->font = font;
 223                         gtk_widget_set_style(text_sb, style);
 224                 }
 225         }
 226         if (text_mb->style && text_mb->style->font->type == GDK_FONT_FONT) {
 227                 GtkStyle *style;
 228                 GdkFont *font;
 229
 230                 font = gdk_fontset_load(prefs_common.normalfont);
 231                 if (font) {
 232                         style = gtk_style_copy(text_mb->style);
 233                         gdk_font_unref(style->font);
 234                         style->font = font;
 235                         gtk_widget_set_style(text_mb, style);
 236                 }
 237         }
 238         gtk_widget_ref(scrolledwin_sb);
 239         gtk_widget_ref(scrolledwin_mb);
 240
 241         gtk_container_add(GTK_CONTAINER(scrolledwin_sb), text_sb);
 242         gtk_container_add(GTK_CONTAINER(scrolledwin_mb), text_mb);
 243         gtk_signal_connect(GTK_OBJECT(text_sb), "key_press_event",
 244                            GTK_SIGNAL_FUNC(textview_key_pressed),
 245                            textview);
 246         gtk_signal_connect_after(GTK_OBJECT(text_sb), "button_press_event",
 247                                  GTK_SIGNAL_FUNC(textview_button_pressed),
 248                                  textview);
 249         gtk_signal_connect_after(GTK_OBJECT(text_sb), "button_release_event",
 250                                  GTK_SIGNAL_FUNC(textview_button_released),
 251                                  textview);
 252         gtk_signal_connect(GTK_OBJECT(text_mb), "key_press_event",
 253                            GTK_SIGNAL_FUNC(textview_key_pressed),
 254                            textview);
 255         gtk_signal_connect_after(GTK_OBJECT(text_mb), "button_press_event",
 256                                  GTK_SIGNAL_FUNC(textview_button_pressed),
 257                                  textview);
 258         gtk_signal_connect_after(GTK_OBJECT(text_mb), "button_release_event",
 259                                  GTK_SIGNAL_FUNC(textview_button_released),
 260                                  textview);
 261
 262         gtk_widget_show(scrolledwin_sb);
 263         gtk_widget_show(scrolledwin_mb);
 264
 265         vbox = gtk_vbox_new(FALSE, 0);
 266         gtk_box_pack_start(GTK_BOX(vbox), scrolledwin_sb, TRUE, TRUE, 0);
 267
 268         gtk_widget_show(vbox);
 269
 270         textview->vbox             = vbox;
 271         textview->scrolledwin      = scrolledwin_sb;
 272         textview->scrolledwin_sb   = scrolledwin_sb;
 273         textview->scrolledwin_mb   = scrolledwin_mb;
 274         textview->text             = text_sb;
 275         textview->text_sb          = text_sb;
 276         textview->text_mb          = text_mb;
 277         textview->text_is_mb       = FALSE;
 278         textview->uri_list         = NULL;
 279         textview->body_pos         = 0;
 280         textview->cur_pos          = 0;
 281         textview->show_all_headers = FALSE;
 282         textview->last_buttonpress = GDK_NOTHING;
 283         textview->show_url_msgid   = 0;
 284
 285         return textview;
 286 }
 287
 288 void textview_init(TextView *textview)
 289 {
 290         gtkut_widget_disable_theme_engine(textview->text_sb);
 291         gtkut_widget_disable_theme_engine(textview->text_mb);
 292         textview_update_message_colors();
 293         textview_set_all_headers(textview, FALSE);
 294         textview_set_font(textview, NULL);
 295 }
 296
 297 void textview_update_message_colors(void)
 298 {
 299         GdkColor black = {0, 0, 0, 0};
 300
 301         if (prefs_common.enable_color) {
 302                 /* grab the quote colors, converting from an int to a GdkColor */
 303                 gtkut_convert_int_to_gdk_color(prefs_common.quote_level1_col,
 304                                                &quote_colors[0]);
 305                 gtkut_convert_int_to_gdk_color(prefs_common.quote_level2_col,
 306                                                &quote_colors[1]);
 307                 gtkut_convert_int_to_gdk_color(prefs_common.quote_level3_col,
 308                                                &quote_colors[2]);
 309                 gtkut_convert_int_to_gdk_color(prefs_common.uri_col,
 310                                                &uri_color);
 311                 gtkut_convert_int_to_gdk_color(prefs_common.signature_col,
 312                                                &signature_color);
 313         } else {
 314                 quote_colors[0] = quote_colors[1] = quote_colors[2] =
 315                         uri_color = emphasis_color = signature_color = black;
 316         }
 317 }
 318
 319 void textview_show_message(TextView *textview, MimeInfo *mimeinfo,
 320                            const gchar *file)
 321 {
 322         GtkSText *text;
 323         FILE *fp;
 324         const gchar *charset = NULL;
 325         GPtrArray *headers = NULL;
 326
 327         if ((fp = fopen(file, "rb")) == NULL) {
 328                 FILE_OP_ERROR(file, "fopen");
 329                 return;
 330         }
 331
 332         if (prefs_common.force_charset)
 333                 charset = prefs_common.force_charset;
 334         else if (mimeinfo->charset)
 335                 charset = mimeinfo->charset;
 336         textview_set_font(textview, charset);
 337         textview_clear(textview);
 338
 339         text = GTK_STEXT(textview->text);
 340
 341         gtk_stext_freeze(text);
 342
 343         if (fseek(fp, mimeinfo->fpos, SEEK_SET) < 0) perror("fseek");
 344         headers = textview_scan_header(textview, fp);
 345         if (headers) {
 346                 textview_show_header(textview, headers);
 347                 procheader_header_array_destroy(headers);
 348                 textview->body_pos = gtk_stext_get_length(text);
 349         }
 350
 351         textview_add_parts(textview, mimeinfo, fp);
 352
 353         gtk_stext_thaw(text);
 354
 355         fclose(fp);
 356 }
 357
 358 void textview_show_part(TextView *textview, MimeInfo *mimeinfo, FILE *fp)
 359 {
 360         GtkSText *text;
 361         gchar buf[BUFFSIZE];
 362         const gchar *boundary = NULL;
 363         gint boundary_len = 0;
 364         const gchar *charset = NULL;
 365         GPtrArray *headers = NULL;
 366         gboolean is_rfc822_part = FALSE;
 367
 368         g_return_if_fail(mimeinfo != NULL);
 369         g_return_if_fail(fp != NULL);
 370
 371         if (mimeinfo->mime_type == MIME_MULTIPART) {
 372                 textview_clear(textview);
 373                 textview_add_parts(textview, mimeinfo, fp);
 374                 return;
 375         }
 376
 377         if (mimeinfo->parent && mimeinfo->parent->boundary) {
 378                 boundary = mimeinfo->parent->boundary;
 379                 boundary_len = strlen(boundary);
 380         }
 381
 382         if (!boundary && (mimeinfo->mime_type == MIME_TEXT ||
 383                           mimeinfo->mime_type == MIME_TEXT_HTML ||
 384                           mimeinfo->mime_type == MIME_TEXT_ENRICHED)) {
 385
 386                 if (fseek(fp, mimeinfo->fpos, SEEK_SET) < 0)
 387                         perror("fseek");
 388                 headers = textview_scan_header(textview, fp);
 389         } else {
 390                 if (mimeinfo->mime_type == MIME_TEXT && mimeinfo->parent) {
 391                         glong fpos;
 392                         MimeInfo *parent = mimeinfo->parent;
 393
 394                         while (parent->parent) {
 395                                 if (parent->main &&
 396                                     parent->main->mime_type ==
 397                                         MIME_MESSAGE_RFC822)
 398                                         break;
 399                                 parent = parent->parent;
 400                         }
 401
 402                         if ((fpos = ftell(fp)) < 0)
 403                                 perror("ftell");
 404                         else if (fseek(fp, parent->fpos, SEEK_SET) < 0)
 405                                 perror("fseek");
 406                         else {
 407                                 headers = textview_scan_header(textview, fp);
 408                                 if (fseek(fp, fpos, SEEK_SET) < 0)
 409                                         perror("fseek");
 410                         }
 411                 }
 412                 /* skip MIME part headers */
 413                 while (fgets(buf, sizeof(buf), fp) != NULL)
 414                         if (buf[0] == '\r' || buf[0] == '\n') break;
 415         }
 416
 417         /* display attached RFC822 single text message */
 418         if (mimeinfo->mime_type == MIME_MESSAGE_RFC822) {
 419                 if (headers) procheader_header_array_destroy(headers);
 420                 if (!mimeinfo->sub) {
 421                         textview_clear(textview);
 422                         return;
 423                 }
 424                 headers = textview_scan_header(textview, fp);
 425                 mimeinfo = mimeinfo->sub;
 426                 is_rfc822_part = TRUE;
 427         }
 428
 429         if (prefs_common.force_charset)
 430                 charset = prefs_common.force_charset;
 431         else if (mimeinfo->charset)
 432                 charset = mimeinfo->charset;
 433         textview_set_font(textview, charset);
 434
 435         text = GTK_STEXT(textview->text);
 436
 437         gtk_stext_freeze(text);
 438         textview_clear(textview);
 439
 440         if (headers) {
 441                 textview_show_header(textview, headers);
 442                 procheader_header_array_destroy(headers);
 443                 textview->body_pos = gtk_stext_get_length(text);
 444                 if (!mimeinfo->main)
 445                         gtk_stext_insert(text, NULL, NULL, NULL, "\n", 1);
 446         }
 447
 448         if (mimeinfo->mime_type == MIME_MULTIPART || is_rfc822_part)
 449                 textview_add_parts(textview, mimeinfo, fp);
 450         else
 451                 textview_write_body(textview, mimeinfo, fp, charset);
 452
 453         gtk_stext_thaw(text);
 454 }
 455
 456 static void textview_add_part(TextView *textview, MimeInfo *mimeinfo, FILE *fp)
 457 {
 458         GtkSText *text = GTK_STEXT(textview->text);
 459         gchar buf[BUFFSIZE];
 460         const gchar *boundary = NULL;
 461         gint boundary_len = 0;
 462         const gchar *charset = NULL;
 463         GPtrArray *headers = NULL;
 464
 465         g_return_if_fail(mimeinfo != NULL);
 466         g_return_if_fail(fp != NULL);
 467
 468         if (mimeinfo->mime_type == MIME_MULTIPART) return;
 469
 470         if (!mimeinfo->parent &&
 471             mimeinfo->mime_type != MIME_TEXT &&
 472             mimeinfo->mime_type != MIME_TEXT_HTML &&
 473             mimeinfo->mime_type != MIME_TEXT_ENRICHED)
 474                 return;
 475
 476         if (fseek(fp, mimeinfo->fpos, SEEK_SET) < 0) {
 477                 perror("fseek");
 478                 return;
 479         }
 480
 481         if (mimeinfo->parent && mimeinfo->parent->boundary) {
 482                 boundary = mimeinfo->parent->boundary;
 483                 boundary_len = strlen(boundary);
 484         }
 485
 486         while (fgets(buf, sizeof(buf), fp) != NULL)
 487                 if (buf[0] == '\r' || buf[0] == '\n') break;
 488
 489         if (mimeinfo->mime_type == MIME_MESSAGE_RFC822) {
 490                 headers = textview_scan_header(textview, fp);
 491                 if (headers) {
 492                         gtk_stext_freeze(text);
 493                         gtk_stext_insert(text, NULL, NULL, NULL, "\n", 1);
 494                         textview_show_header(textview, headers);
 495                         procheader_header_array_destroy(headers);
 496                         gtk_stext_thaw(text);
 497                 }
 498                 return;
 499         }
 500
 501         gtk_stext_freeze(text);
 502
 503 #if USE_GPGME
 504         if (mimeinfo->sigstatus)
 505                 g_snprintf(buf, sizeof(buf), "\n[%s (%s)]\n",
 506                            mimeinfo->content_type, mimeinfo->sigstatus);
 507         else
 508 #endif
 509         if (mimeinfo->filename || mimeinfo->name)
 510                 g_snprintf(buf, sizeof(buf), "\n[%s  %s (%d bytes)]\n",
 511                            mimeinfo->filename ? mimeinfo->filename :
 512                            mimeinfo->name,
 513                            mimeinfo->content_type, mimeinfo->size);
 514         else
 515                 g_snprintf(buf, sizeof(buf), "\n[%s (%d bytes)]\n",
 516                            mimeinfo->content_type, mimeinfo->size);
 517
 518 #if USE_GPGME
 519         if (mimeinfo->sigstatus && !mimeinfo->sigstatus_full) {
 520                 gchar *tmp;
 521                 /* use standard font */
 522                 gpointer oldfont = textview->msgfont;
 523                 textview->msgfont = NULL;
 524
 525                 tmp = g_strconcat("pgp: ", _("Check signature"), NULL);
 526                 textview_write_link(textview, tmp, buf, NULL);
 527
 528                 /* put things back */
 529                 textview->msgfont = (GdkFont *)oldfont;
 530                 oldfont = NULL;
 531                 g_free(tmp);
 532         } else if (mimeinfo->sigstatus) {
 533                 GdkColor *color;
 534                 if (!strcmp(mimeinfo->sigstatus, _("Good signature")))
 535                         color = &good_sig_color;
 536                 else if (!strcmp(mimeinfo->sigstatus, _("BAD signature")))
 537                         color = &bad_sig_color;
 538                 else
 539                         color = &nocheck_sig_color;
 540                 gtk_stext_insert(text, NULL, color, NULL, buf, -1);
 541         } else
 542 #endif
 543         if (mimeinfo->mime_type != MIME_TEXT &&
 544             mimeinfo->mime_type != MIME_TEXT_HTML &&
 545             mimeinfo->mime_type != MIME_TEXT_ENRICHED) {
 546                 gtk_stext_insert(text, NULL, NULL, NULL, buf, -1);
 547         } else {
 548                 if (!mimeinfo->main &&
 549                     mimeinfo->parent &&
 550                     mimeinfo->parent->children != mimeinfo)
 551                         gtk_stext_insert(text, NULL, NULL, NULL, buf, -1);
 552                 else if (prefs_common.display_header)
 553                         gtk_stext_insert(text, NULL, NULL, NULL, "\n", 1);
 554                 if (prefs_common.force_charset)
 555                         charset = prefs_common.force_charset;
 556                 else if (mimeinfo->charset)
 557                         charset = mimeinfo->charset;
 558                 textview_write_body(textview, mimeinfo, fp, charset);
 559         }
 560
 561         gtk_stext_thaw(text);
 562 }
 563
 564 static void textview_add_parts(TextView *textview, MimeInfo *mimeinfo, FILE *fp)
 565 {
 566         gint level;
 567
 568         g_return_if_fail(mimeinfo != NULL);
 569         g_return_if_fail(fp != NULL);
 570
 571         level = mimeinfo->level;
 572
 573         for (;;) {
 574                 textview_add_part(textview, mimeinfo, fp);
 575                 if (mimeinfo->parent && mimeinfo->parent->content_type &&
 576                     !strcasecmp(mimeinfo->parent->content_type,
 577                                 "multipart/alternative"))
 578                         mimeinfo = mimeinfo->parent->next;
 579                 else
 580                         mimeinfo = procmime_mimeinfo_next(mimeinfo);
 581                 if (!mimeinfo || mimeinfo->level <= level)
 582                         break;
 583         }
 584 }
 585
 586 #define TEXT_INSERT(str) \
 587         gtk_stext_insert(text, textview->msgfont, NULL, NULL, str, -1)
 588
 589 void textview_show_mime_part(TextView *textview, MimeInfo *partinfo)
 590 {
 591         GtkSText *text;
 592
 593         if (!partinfo) return;
 594
 595         textview_set_font(textview, NULL);
 596         text = GTK_STEXT(textview->text);
 597         textview_clear(textview);
 598
 599         gtk_stext_freeze(text);
 600
 601         TEXT_INSERT(_("To save this part, pop up the context menu with "));
 602         TEXT_INSERT(_("right click and select `Save as...', "));
 603         TEXT_INSERT(_("or press `y' key.\n\n"));
 604
 605         TEXT_INSERT(_("To display this part as a text message, select "));
 606         TEXT_INSERT(_("`Display as text', or press `t' key.\n\n"));
 607
 608         TEXT_INSERT(_("To display this part as an image, select "));
 609         TEXT_INSERT(_("`Display image', or press `i' key.\n\n"));
 610
 611         TEXT_INSERT(_("To open this part with external program, select "));
 612         TEXT_INSERT(_("`Open' or `Open with...', "));
 613         TEXT_INSERT(_("or double-click, or click the center button, "));
 614         TEXT_INSERT(_("or press `l' key."));
 615
 616         gtk_stext_thaw(text);
 617 }
 618
 619 #if USE_GPGME
 620 void textview_show_signature_part(TextView *textview, MimeInfo *partinfo)
 621 {
 622         GtkSText *text;
 623
 624         if (!partinfo) return;
 625
 626         textview_set_font(textview, NULL);
 627         text = GTK_STEXT(textview->text);
 628         textview_clear(textview);
 629
 630         gtk_stext_freeze(text);
 631
 632         if (partinfo->sigstatus_full == NULL) {
 633                 TEXT_INSERT(_("This signature has not been checked yet.\n"));
 634                 TEXT_INSERT(_("To check it, pop up the context menu with\n"));
 635                 TEXT_INSERT(_("right click and select `Check signature'.\n"));
 636         } else {
 637                 TEXT_INSERT(partinfo->sigstatus_full);
 638         }
 639
 640         gtk_stext_thaw(text);
 641 }
 642 #endif /* USE_GPGME */
 643
 644 #undef TEXT_INSERT
 645
 646 static void textview_write_body(TextView *textview, MimeInfo *mimeinfo,
 647                                 FILE *fp, const gchar *charset)
 648 {
 649         FILE *tmpfp;
 650         gchar buf[BUFFSIZE];
 651         CodeConverter *conv;
 652
 653         conv = conv_code_converter_new(charset);
 654
 655         tmpfp = procmime_decode_content(NULL, fp, mimeinfo);
 656
 657         textview->is_in_signature = FALSE;
 658
 659         if (tmpfp) {
 660
 661                 if (mimeinfo->mime_type == MIME_TEXT_HTML)
 662                         textview_show_html(textview, tmpfp, conv);
 663                 else if (mimeinfo->mime_type == MIME_TEXT_ENRICHED)
 664                         textview_show_ertf(textview, tmpfp, conv);
 665                 else
 666                         while (fgets(buf, sizeof(buf), tmpfp) != NULL)
 667                                 textview_write_line(textview, buf, conv);
 668                 fclose(tmpfp);
 669         }
 670
 671         conv_code_converter_destroy(conv);
 672 }
 673
 674 static void textview_show_html(TextView *textview, FILE *fp,
 675                                CodeConverter *conv)
 676 {
 677         HTMLParser *parser;
 678         gchar *str;
 679         gchar* url = NULL;
 680
 681         parser = html_parser_new(fp, conv);
 682         g_return_if_fail(parser != NULL);
 683
 684         while ((str = html_parse(parser)) != NULL) {
 685                 if (parser->state == HTML_HREF) {
 686                         /* first time : get and copy the URL */
 687                         if (url == NULL) {
 688                                 /* ALF - the sylpheed html parser returns an empty string,
 689                                  * if still inside an <a>, but already parsed past HREF */
 690                                 str = strtok(str, " ");
 691                                 if (str) {
 692                                         url = strdup(str);
 693                                         /* the URL may (or not) be followed by the
 694                                          * referenced text */
 695                                         str = strtok(NULL, "");
 696                                 }
 697                         }
 698                         if (str != NULL) {
 699                                 textview_write_link(textview, url, str, NULL);
 700                         }
 701                 } else {
 702                         if (url != NULL) {
 703                                 free(url);
 704                                 url = NULL;
 705                         }
 706                         textview_write_line(textview, str, NULL);
 707                 }
 708         }
 709
 710         html_parser_destroy(parser);
 711 }
 712
 713 static void textview_show_ertf(TextView *textview, FILE *fp,
 714                                CodeConverter *conv)
 715 {
 716         ERTFParser *parser;
 717         gchar *str;
 718
 719         parser = ertf_parser_new(fp, conv);
 720         g_return_if_fail(parser != NULL);
 721
 722         while ((str = ertf_parse(parser)) != NULL) {
 723                 textview_write_line(textview, str, NULL);
 724         }
 725
 726         ertf_parser_destroy(parser);
 727 }
 728
 729 /* get_uri_part() - retrieves a URI starting from scanpos.
 730                     Returns TRUE if succesful */
 731 static gboolean get_uri_part(const gchar *start, const gchar *scanpos,
 732                              const gchar **bp, const gchar **ep)
 733 {
 734         const gchar *ep_;
 735
 736         g_return_val_if_fail(start != NULL, FALSE);
 737         g_return_val_if_fail(scanpos != NULL, FALSE);
 738         g_return_val_if_fail(bp != NULL, FALSE);
 739         g_return_val_if_fail(ep != NULL, FALSE);
 740
 741         *bp = scanpos;
 742
 743         /* find end point of URI */
 744         for (ep_ = scanpos; *ep_ != '\0'; ep_++) {
 745                 if (!isgraph(*ep_) || !isascii(*ep_) || strchr("()<>\"", *ep_))
 746                         break;
 747         }
 748
 749         /* no punctuation at end of string */
 750
 751         /* FIXME: this stripping of trailing punctuations may bite with other URIs.
 752          * should pass some URI type to this function and decide on that whether
 753          * to perform punctuation stripping */
 754
 755 #define IS_REAL_PUNCT(ch)       (ispunct(ch) && ((ch) != '/'))
 756
 757         for (; ep_ - 1 > scanpos + 1 && IS_REAL_PUNCT(*(ep_ - 1)); ep_--)
 758                 ;
 759
 760 #undef IS_REAL_PUNCT
 761
 762         *ep = ep_;
 763
 764         return TRUE;
 765 }
 766
 767 static gchar *make_uri_string(const gchar *bp, const gchar *ep)
 768 {
 769         return g_strndup(bp, ep - bp);
 770 }
 771
 772 /* valid mail address characters */
 773 #define IS_RFC822_CHAR(ch) \
 774         (isascii(ch) && \
 775          (ch) > 32   && \
 776          (ch) != 127 && \
 777          !isspace(ch) && \
 778          !strchr("(),;<>\"", (ch)))
 779
 780 /* alphabet and number within 7bit ASCII */
 781 #define IS_ASCII_ALNUM(ch)      (isascii(ch) && isalnum(ch))
 782 #define IS_QUOTE(ch) ((ch) == '\'' || (ch) == '"')
 783
 784 static GHashTable *create_domain_tab(void)
 785 {
 786         static const gchar *toplvl_domains [] = {
 787             "museum", "aero",
 788             "arpa", "coop", "info", "name", "biz", "com", "edu", "gov",
 789             "int", "mil", "net", "org", "ac", "ad", "ae", "af", "ag",
 790             "ai", "al", "am", "an", "ao", "aq", "ar", "as", "at", "au",
 791             "aw", "az", "ba", "bb", "bd", "be", "bf", "bg", "bh", "bi",
 792             "bj", "bm", "bn", "bo", "br", "bs", "bt", "bv", "bw", "by",
 793             "bz", "ca", "cc", "cd", "cf", "cg", "ch", "ci", "ck", "cl",
 794             "cm", "cn", "co", "cr", "cu", "cv", "cx", "cy", "cz", "de",
 795             "dj", "dk", "dm", "do", "dz", "ec", "ee", "eg", "eh", "er",
 796             "es", "et", "fi", "fj", "fk", "fm", "fo", "fr", "ga", "gd",
 797             "ge", "gf", "gg", "gh", "gi", "gl", "gm", "gn", "gp", "gq",
 798             "gr", "gs", "gt", "gu", "gw", "gy", "hk", "hm", "hn", "hr",
 799             "ht", "hu", "id", "ie", "il", "im", "in", "io", "iq", "ir",
 800             "is", "it", "je", "jm", "jo", "jp", "ke", "kg", "kh", "ki",
 801             "km", "kn", "kp", "kr", "kw", "ky", "kz", "la", "lb", "lc",
 802             "li", "lk", "lr", "ls", "lt", "lu", "lv", "ly", "ma", "mc",
 803             "md", "mg", "mh", "mk", "ml", "mm", "mn", "mo", "mp", "mq",
 804             "mr", "ms", "mt", "mu", "mv", "mw", "mx", "my", "mz", "na",
 805             "nc", "ne", "nf", "ng", "ni", "nl", "no", "np", "nr", "nu",
 806             "nz", "om", "pa", "pe", "pf", "pg", "ph", "pk", "pl", "pm",
 807             "pn", "pr", "ps", "pt", "pw", "py", "qa", "re", "ro", "ru",
 808             "rw", "sa", "sb", "sc", "sd", "se", "sg", "sh", "si", "sj",
 809             "sk", "sl", "sm", "sn", "so", "sr", "st", "sv", "sy", "sz",
 810             "tc", "td", "tf", "tg", "th", "tj", "tk", "tm", "tn", "to",
 811             "tp", "tr", "tt", "tv", "tw", "tz", "ua", "ug", "uk", "um",
 812             "us", "uy", "uz", "va", "vc", "ve", "vg", "vi", "vn", "vu",
 813             "wf", "ws", "ye", "yt", "yu", "za", "zm", "zw"
 814         };
 815         gint n;
 816         GHashTable *htab = g_hash_table_new(g_stricase_hash, g_stricase_equal);
 817
 818         g_return_val_if_fail(htab, NULL);
 819         for (n = 0; n < sizeof toplvl_domains / sizeof toplvl_domains[0]; n++)
 820                 g_hash_table_insert(htab, (gpointer) toplvl_domains[n], (gpointer) toplvl_domains[n]);
 821         return htab;
 822 }
 823
 824 static gboolean is_toplvl_domain(GHashTable *tab, const gchar *first, const gchar *last)
 825 {
 826         const gint MAX_LVL_DOM_NAME_LEN = 6;
 827         gchar buf[MAX_LVL_DOM_NAME_LEN + 1];
 828         const gchar *m = buf + MAX_LVL_DOM_NAME_LEN + 1;
 829         register gchar *p;
 830
 831         if (last - first > MAX_LVL_DOM_NAME_LEN || first > last)
 832                 return FALSE;
 833
 834         for (p = buf; p < m &&  first < last; *p++ = *first++)
 835                 ;
 836         *p = 0;
 837
 838         return g_hash_table_lookup(tab, buf) != NULL;
 839 }
 840
 841 /* get_email_part() - retrieves an email address. Returns TRUE if succesful */
 842 static gboolean get_email_part(const gchar *start, const gchar *scanpos,
 843                                const gchar **bp, const gchar **ep)
 844 {
 845         /* more complex than the uri part because we need to scan back and forward starting from
 846          * the scan position. */
 847         gboolean result = FALSE;
 848         const gchar *bp_ = NULL;
 849         const gchar *ep_ = NULL;
 850         static GHashTable *dom_tab;
 851         const gchar *last_dot = NULL;
 852         const gchar *prelast_dot = NULL;
 853         const gchar *last_tld_char = NULL;
 854
 855         /* the informative part of the email address (describing the name
 856          * of the email address owner) may contain quoted parts. the
 857          * closure stack stores the last encountered quotes. */
 858         gchar closure_stack[128];
 859         gchar *ptr = closure_stack;
 860
 861         g_return_val_if_fail(start != NULL, FALSE);
 862         g_return_val_if_fail(scanpos != NULL, FALSE);
 863         g_return_val_if_fail(bp != NULL, FALSE);
 864         g_return_val_if_fail(ep != NULL, FALSE);
 865
 866         if (!dom_tab)
 867                 dom_tab = create_domain_tab();
 868         g_return_val_if_fail(dom_tab, FALSE);
 869
 870         /* scan start of address */
 871         for (bp_ = scanpos - 1; bp_ >= start && IS_RFC822_CHAR(*bp_); bp_--)
 872                 ;
 873
 874         /* TODO: should start with an alnum? */
 875         bp_++;
 876         for (; bp_ < scanpos && !IS_ASCII_ALNUM(*bp_); bp_++)
 877                 ;
 878
 879         if (bp_ != scanpos) {
 880                 /* scan end of address */
 881                 for (ep_ = scanpos + 1; *ep_ && IS_RFC822_CHAR(*ep_); ep_++)
 882                         if (*ep_ == '.') {
 883                                 prelast_dot = last_dot;
 884                                 last_dot = ep_;
 885                                 if (*(last_dot + 1) == '.') {
 886                                         if (prelast_dot == NULL)
 887                                                 return FALSE;
 888                                         last_dot = prelast_dot;
 889                                         break;
 890                                 }
 891                         }
 892
 893                 /* TODO: really should terminate with an alnum? */
 894                 for (; ep_ > scanpos && !IS_ASCII_ALNUM(*ep_); --ep_)
 895                         ;
 896                 ep_++;
 897
 898                 if (last_dot == NULL)
 899                         return FALSE;
 900                 if (last_dot >= ep_)
 901                         last_dot = prelast_dot;
 902                 if (last_dot == NULL || (scanpos + 1 >= last_dot))
 903                         return FALSE;
 904                 last_dot++;
 905
 906                 for (last_tld_char = last_dot; last_tld_char < ep_; last_tld_char++)
 907                         if (*last_tld_char == '?')
 908                                 break;
 909
 910                 if (is_toplvl_domain(dom_tab, last_dot, last_tld_char))
 911                         result = TRUE;
 912
 913                 *ep = ep_;
 914                 *bp = bp_;
 915         }
 916
 917         if (!result) return FALSE;
 918
 919         /* skip if it's between quotes "'alfons@proteus.demon.nl'" <alfons@proteus.demon.nl> */
 920         if (bp_ - 1 > start && IS_QUOTE(*(bp_ - 1)) && IS_QUOTE(*ep_))
 921                 return FALSE;
 922
 923         /* see if this is <bracketed>; in this case we also scan for the informative part. */
 924         if (bp_ - 1 <= start || *(bp_ - 1) != '<' || *ep_ != '>')
 925                 return TRUE;
 926
 927 #define FULL_STACK()    ((size_t) (ptr - closure_stack) >= sizeof closure_stack)
 928 #define IN_STACK()      (ptr > closure_stack)
 929 /* has underrun check */
 930 #define POP_STACK()     if(IN_STACK()) --ptr
 931 /* has overrun check */
 932 #define PUSH_STACK(c)   if(!FULL_STACK()) *ptr++ = (c); else return TRUE
 933 /* has underrun check */
 934 #define PEEK_STACK()    (IN_STACK() ? *(ptr - 1) : 0)
 935
 936         ep_++;
 937
 938         /* scan for the informative part. */
 939         for (bp_ -= 2; bp_ >= start; bp_--) {
 940                 /* if closure on the stack keep scanning */
 941                 if (PEEK_STACK() == *bp_) {
 942                         POP_STACK();
 943                         continue;
 944                 }
 945                 if (*bp_ == '\'' || *bp_ == '"') {
 946                         PUSH_STACK(*bp_);
 947                         continue;
 948                 }
 949
 950                 /* if nothing in the closure stack, do the special conditions
 951                  * the following if..else expression simply checks whether
 952                  * a token is acceptable. if not acceptable, the clause
 953                  * should terminate the loop with a 'break' */
 954                 if (!PEEK_STACK()) {
 955                         if (*bp_ == '-'
 956                         && (((bp_ - 1) >= start) && isalnum(*(bp_ - 1)))
 957                         && (((bp_ + 1) < ep_)    && isalnum(*(bp_ + 1)))) {
 958                                 /* hyphens are allowed, but only in
 959                                    between alnums */
 960                         } else if (!ispunct(*bp_)) {
 961                                 /* but anything not being a punctiation
 962                                    is ok */
 963                         } else {
 964                                 break; /* anything else is rejected */
 965                         }
 966                 }
 967         }
 968
 969         bp_++;
 970
 971 #undef PEEK_STACK
 972 #undef PUSH_STACK
 973 #undef POP_STACK
 974 #undef IN_STACK
 975 #undef FULL_STACK
 976
 977         /* scan forward (should start with an alnum) */
 978         for (; *bp_ != '<' && isspace(*bp_) && *bp_ != '"'; bp_++)
 979                 ;
 980
 981         *ep = ep_;
 982         *bp = bp_;
 983
 984         return result;
 985 }
 986
 987 #undef IS_QUOTE
 988 #undef IS_RFC822_CHAR
 989
 990 static gchar *make_email_string(const gchar *bp, const gchar *ep)
 991 {
 992         /* returns a mailto: URI; mailto: is also used to detect the
 993          * uri type later on in the button_pressed signal handler */
 994         gchar *tmp;
 995         gchar *result;
 996
 997         tmp = g_strndup(bp, ep - bp);
 998         result = g_strconcat("mailto:", tmp, NULL);
 999         g_free(tmp);
1000
1001         return result;
1002 }
1003
1004 #define ADD_TXT_POS(bp_, ep_, pti_) \
1005         if ((last->next = alloca(sizeof(struct txtpos))) != NULL) { \
1006                 last = last->next; \
1007                 last->bp = (bp_); last->ep = (ep_); last->pti = (pti_); \
1008                 last->next = NULL; \
1009         } else { \
1010                 g_warning("alloc error scanning URIs\n"); \
1011                 gtk_stext_insert(text, textview->msgfont, fg_color, NULL, \
1012                                 linebuf, -1); \
1013                 return; \
1014         }
1015
1016 /* textview_make_clickable_parts() - colorizes clickable parts */
1017 static void textview_make_clickable_parts(TextView *textview,
1018                                           GdkFont *font,
1019                                           GdkColor *fg_color,
1020                                           GdkColor *uri_color,
1021                                           const gchar *linebuf)
1022 {
1023         /* parse table - in order of priority */
1024         struct table {
1025                 const gchar *needle; /* token */
1026
1027                 /* token search function */
1028                 gchar    *(*search)     (const gchar *haystack,
1029                                          const gchar *needle);
1030                 /* part parsing function */
1031                 gboolean  (*parse)      (const gchar *start,
1032                                          const gchar *scanpos,
1033                                          const gchar **bp_,
1034                                          const gchar **ep_);
1035                 /* part to URI function */
1036                 gchar    *(*build_uri)  (const gchar *bp,
1037                                          const gchar *ep);
1038         };
1039
1040         static struct table parser[] = {
1041                 {"http://",  strcasestr, get_uri_part,   make_uri_string},
1042                 {"https://", strcasestr, get_uri_part,   make_uri_string},
1043                 {"ftp://",   strcasestr, get_uri_part,   make_uri_string},
1044                 {"www.",     strcasestr, get_uri_part,   make_uri_string},
1045                 {"mailto:",  strcasestr, get_uri_part,   make_uri_string},
1046                 {"@",        strcasestr, get_email_part, make_email_string}
1047         };
1048         const gint PARSE_ELEMS = sizeof parser / sizeof parser[0];
1049
1050         gint  n;
1051         const gchar *walk, *bp, *ep;
1052
1053         struct txtpos {
1054                 const gchar     *bp, *ep;       /* text position */
1055                 gint             pti;           /* index in parse table */
1056                 struct txtpos   *next;          /* next */
1057         } head = {NULL, NULL, 0,  NULL}, *last = &head;
1058
1059         GtkSText *text = GTK_STEXT(textview->text);
1060
1061         /* parse for clickable parts, and build a list of begin and end positions  */
1062         for (walk = linebuf, n = 0;;) {
1063                 gint last_index = PARSE_ELEMS;
1064                 gchar *scanpos = NULL;
1065
1066                 /* FIXME: this looks phony. scanning for anything in the parse table */
1067                 for (n = 0; n < PARSE_ELEMS; n++) {
1068                         gchar *tmp;
1069
1070                         tmp = parser[n].search(walk, parser[n].needle);
1071                         if (tmp) {
1072                                 if (scanpos == NULL || tmp < scanpos) {
1073                                         scanpos = tmp;
1074                                         last_index = n;
1075                                 }
1076                         }
1077                 }
1078
1079                 if (scanpos) {
1080                         /* check if URI can be parsed */
1081                         if (parser[last_index].parse(walk, scanpos, &bp, &ep)
1082                             && (size_t) (ep - bp - 1) > strlen(parser[last_index].needle)) {
1083                                         ADD_TXT_POS(bp, ep, last_index);
1084                                         walk = ep;
1085                         } else
1086                                 walk = scanpos +
1087                                         strlen(parser[last_index].needle);
1088                 } else
1089                         break;
1090         }
1091
1092         /* colorize this line */
1093         if (head.next) {
1094                 const gchar *normal_text = linebuf;
1095
1096                 /* insert URIs */
1097                 for (last = head.next; last != NULL;
1098                      normal_text = last->ep, last = last->next) {
1099                         RemoteURI *uri;
1100
1101                         uri = g_new(RemoteURI, 1);
1102                         if (last->bp - normal_text > 0)
1103                                 gtk_stext_insert(text, font,
1104                                                 fg_color, NULL,
1105                                                 normal_text,
1106                                                 last->bp - normal_text);
1107                         uri->uri = parser[last->pti].build_uri(last->bp,
1108                                                                last->ep);
1109                         uri->start = gtk_stext_get_point(text);
1110                         gtk_stext_insert(text, font, uri_color,
1111                                         NULL, last->bp, last->ep - last->bp);
1112                         uri->end = gtk_stext_get_point(text);
1113                         textview->uri_list =
1114                                 g_slist_append(textview->uri_list, uri);
1115                 }
1116
1117                 if (*normal_text)
1118                         gtk_stext_insert(text, font, fg_color,
1119                                         NULL, normal_text, -1);
1120         } else
1121                 gtk_stext_insert(text, font, fg_color, NULL, linebuf, -1);
1122 }
1123
1124 #undef ADD_TXT_POS
1125
1126 /* This function writes str as a double-clickable link with the given url. */
1127 static void textview_write_link(TextView *textview, const gchar *url,
1128                                 const gchar *str, CodeConverter *conv)
1129 {
1130     GdkColor *link_color = NULL;
1131     RemoteURI* uri;
1132     GtkSText *text = GTK_STEXT(textview->text);
1133     gchar buf[BUFFSIZE];
1134
1135     /* this part is taken from textview_write_line. Right now the only place
1136      * that calls this function passes NULL for conv, but you never know. */
1137 #if 0
1138     if (!conv)
1139             strncpy2(buf, str, sizeof(buf));
1140     else if (conv_convert(conv, buf, sizeof(buf), str) < 0) {
1141             gtk_stext_insert(text, textview->msgfont,
1142                             prefs_common.enable_color
1143                             ? &error_color : NULL, NULL,
1144                             "*** Warning: code conversion failed ***\n",
1145                             -1);
1146             return;
1147     }
1148 #endif
1149
1150     if (!conv || conv_convert(conv, buf, sizeof(buf), str) < 0)
1151         strncpy2(buf, str, sizeof(buf));
1152
1153     strcrchomp(buf);
1154     gtk_stext_insert(text, textview->msgfont, NULL, NULL, " ", 1);
1155
1156     /* this part is based on the code in make_clickable_parts */
1157     if (prefs_common.enable_color) {
1158         link_color = &uri_color;
1159     }
1160     uri = g_new(RemoteURI, 1);
1161     uri->uri = g_strdup(url);
1162     uri->start = gtk_stext_get_point(text);
1163     gtk_stext_insert(text, textview->msgfont, link_color, NULL, str,
1164                     strlen(str));
1165     uri->end = gtk_stext_get_point(text);
1166     textview->uri_list = g_slist_append(textview->uri_list, uri);
1167 }
1168
1169 static void textview_write_line(TextView *textview, const gchar *str,
1170                                 CodeConverter *conv)
1171 {
1172         GtkSText *text = GTK_STEXT(textview->text);
1173         gchar buf[BUFFSIZE];
1174         GdkColor *fg_color;
1175         gint quotelevel = -1;
1176
1177         if (!conv) {
1178                 if (textview->text_is_mb)
1179                         conv_localetodisp(buf, sizeof(buf), str);
1180                 else
1181                         strncpy2(buf, str, sizeof(buf));
1182         } else if (conv_convert(conv, buf, sizeof(buf), str) < 0)
1183                 conv_localetodisp(buf, sizeof(buf), str);
1184         else if (textview->text_is_mb)
1185                 conv_unreadable_locale(buf);
1186
1187         strcrchomp(buf);
1188         if (prefs_common.conv_mb_alnum) conv_mb_alnum(buf);
1189         fg_color = NULL;
1190
1191         /* change color of quotation
1192            >, foo>, _> ... ok, <foo>, foo bar>, foo-> ... ng
1193            Up to 3 levels of quotations are detected, and each
1194            level is colored using a different color. */
1195         if (prefs_common.enable_color
1196             && line_has_quote_char(buf, prefs_common.quote_chars)) {
1197                 quotelevel = get_quote_level(buf, prefs_common.quote_chars);
1198
1199                 /* set up the correct foreground color */
1200                 if (quotelevel > 2) {
1201                         /* recycle colors */
1202                         if (prefs_common.recycle_quote_colors)
1203                                 quotelevel %= 3;
1204                         else
1205                                 quotelevel = 2;
1206                 }
1207         }
1208
1209         if (quotelevel == -1)
1210                 fg_color = NULL;
1211         else
1212                 fg_color = &quote_colors[quotelevel];
1213
1214         if (prefs_common.enable_color && (strcmp(buf,"-- \n") == 0 || textview->is_in_signature)) {
1215                 fg_color = &signature_color;
1216                 textview->is_in_signature = TRUE;
1217         }
1218
1219         if (prefs_common.head_space && spacingfont && buf[0] != '\n')
1220                 gtk_stext_insert(text, spacingfont, NULL, NULL, " ", 1);
1221
1222         if (prefs_common.enable_color)
1223                 textview_make_clickable_parts(textview, textview->msgfont,
1224                                               fg_color, &uri_color, buf);
1225         else
1226                 textview_make_clickable_parts(textview, textview->msgfont,
1227                                               fg_color, NULL, buf);
1228 }
1229
1230 void textview_clear(TextView *textview)
1231 {
1232         GtkSText *text = GTK_STEXT(textview->text);
1233
1234         gtk_stext_freeze(text);
1235         gtk_stext_set_point(text, 0);
1236         gtk_stext_forward_delete(text, gtk_stext_get_length(text));
1237         gtk_stext_thaw(text);
1238
1239         textview_uri_list_remove_all(textview->uri_list);
1240         textview->uri_list = NULL;
1241
1242         textview->body_pos = 0;
1243         textview->cur_pos  = 0;
1244 }
1245
1246 void textview_destroy(TextView *textview)
1247 {
1248         textview_uri_list_remove_all(textview->uri_list);
1249         textview->uri_list = NULL;
1250
1251         if (!textview->scrolledwin_sb->parent)
1252                 gtk_widget_destroy(textview->scrolledwin_sb);
1253         if (!textview->scrolledwin_mb->parent)
1254                 gtk_widget_destroy(textview->scrolledwin_mb);
1255
1256         if (textview->msgfont)
1257                 gdk_font_unref(textview->msgfont);
1258         if (textview->boldfont)
1259                 gdk_font_unref(textview->boldfont);
1260
1261         g_free(textview);
1262 }
1263
1264 void textview_set_all_headers(TextView *textview, gboolean all_headers)
1265 {
1266         textview->show_all_headers = all_headers;
1267 }
1268
1269 void textview_set_font(TextView *textview, const gchar *codeset)
1270 {
1271         gboolean use_fontset = TRUE;
1272
1273         /* In multi-byte mode, GtkSText can't display 8bit characters
1274            correctly, so it must be single-byte mode. */
1275         if (MB_CUR_MAX > 1) {
1276                 if (codeset && conv_get_current_charset() != C_UTF_8) {
1277                         if (!g_strncasecmp(codeset, "ISO-8859-", 9) ||
1278                             !g_strcasecmp(codeset, "BALTIC"))
1279                                 use_fontset = FALSE;
1280                         else if (conv_get_current_charset() != C_EUC_JP &&
1281                                  (!g_strncasecmp(codeset, "KOI8-", 5) ||
1282                                   !g_strncasecmp(codeset, "CP", 2)    ||
1283                                   !g_strncasecmp(codeset, "WINDOWS-", 8)))
1284                                 use_fontset = FALSE;
1285                 }
1286         } else
1287                 use_fontset = FALSE;
1288
1289         if (textview->text_is_mb && !use_fontset) {
1290                 GtkWidget *parent;
1291
1292                 parent = textview->scrolledwin_mb->parent;
1293                 gtkut_container_remove(GTK_CONTAINER(parent),
1294                                        textview->scrolledwin_mb);
1295                 gtk_container_add(GTK_CONTAINER(parent),
1296                                   textview->scrolledwin_sb);
1297
1298                 textview->text = textview->text_sb;
1299                 textview->text_is_mb = FALSE;
1300         } else if (!textview->text_is_mb && use_fontset) {
1301                 GtkWidget *parent;
1302
1303                 parent = textview->scrolledwin_sb->parent;
1304                 gtkut_container_remove(GTK_CONTAINER(parent),
1305                                        textview->scrolledwin_sb);
1306                 gtk_container_add(GTK_CONTAINER(parent),
1307                                   textview->scrolledwin_mb);
1308
1309                 textview->text = textview->text_mb;
1310                 textview->text_is_mb = TRUE;
1311         }
1312
1313         if (prefs_common.textfont) {
1314                 GdkFont *font;
1315
1316                 if (use_fontset) {
1317                         if (text_mb_font) {
1318                                 text_mb_font->ascent = text_mb_font_orig_ascent;
1319                                 text_mb_font->descent = text_mb_font_orig_descent;
1320                         }
1321                         font = gdk_fontset_load(prefs_common.textfont);
1322                         if (font && text_mb_font != font) {
1323                                 if (text_mb_font)
1324                                         gdk_font_unref(text_mb_font);
1325                                 text_mb_font = font;
1326                                 text_mb_font_orig_ascent = font->ascent;
1327                                 text_mb_font_orig_descent = font->descent;
1328                         }
1329                 } else {
1330                         if (text_sb_font) {
1331                                 text_sb_font->ascent = text_sb_font_orig_ascent;
1332                                 text_sb_font->descent = text_sb_font_orig_descent;
1333                         }
1334                         if (MB_CUR_MAX > 1)
1335                                 font = gdk_font_load("-*-courier-medium-r-normal--14-*-*-*-*-*-iso8859-1");
1336                         else
1337                                 font = gtkut_font_load_from_fontset
1338                                         (prefs_common.textfont);
1339                         if (font && text_sb_font != font) {
1340                                 if (text_sb_font)
1341                                         gdk_font_unref(text_sb_font);
1342                                 text_sb_font = font;
1343                                 text_sb_font_orig_ascent = font->ascent;
1344                                 text_sb_font_orig_descent = font->descent;
1345                         }
1346                 }
1347
1348                 if (font) {
1349                         gint ascent, descent;
1350
1351                         descent = prefs_common.line_space / 2;
1352                         ascent  = prefs_common.line_space - descent;
1353                         font->ascent  += ascent;
1354                         font->descent += descent;
1355
1356                         if (textview->msgfont)
1357                                 gdk_font_unref(textview->msgfont);
1358                         textview->msgfont = font;
1359                         gdk_font_ref(font);
1360                 }
1361         }
1362
1363         if (!textview->boldfont && prefs_common.boldfont)
1364                 textview->boldfont = gtkut_font_load(prefs_common.boldfont);
1365         if (!spacingfont)
1366                 spacingfont = gdk_font_load("-*-*-medium-r-normal--6-*");
1367 }
1368
1369 enum
1370 {
1371         H_DATE          = 0,
1372         H_FROM          = 1,
1373         H_TO            = 2,
1374         H_NEWSGROUPS    = 3,
1375         H_SUBJECT       = 4,
1376         H_CC            = 5,
1377         H_REPLY_TO      = 6,
1378         H_FOLLOWUP_TO   = 7,
1379         H_X_MAILER      = 8,
1380         H_X_NEWSREADER  = 9,
1381         H_USER_AGENT    = 10,
1382         H_ORGANIZATION  = 11,
1383 };
1384
1385 void textview_set_position(TextView *textview, gint pos)
1386 {
1387         if (pos < 0) {
1388                 textview->cur_pos =
1389                         gtk_stext_get_length(GTK_STEXT(textview->text));
1390         } else {
1391                 textview->cur_pos = pos;
1392         }
1393 }
1394
1395 static GPtrArray *textview_scan_header(TextView *textview, FILE *fp)
1396 {
1397         gchar buf[BUFFSIZE];
1398         GPtrArray *headers, *sorted_headers;
1399         GSList *disphdr_list;
1400         Header *header;
1401         gint i;
1402
1403         g_return_val_if_fail(fp != NULL, NULL);
1404
1405         if (textview->show_all_headers)
1406                 return procheader_get_header_array_asis(fp);
1407
1408         if (!prefs_common.display_header) {
1409                 while (fgets(buf, sizeof(buf), fp) != NULL)
1410                         if (buf[0] == '\r' || buf[0] == '\n') break;
1411                 return NULL;
1412         }
1413
1414         headers = procheader_get_header_array_asis(fp);
1415
1416         sorted_headers = g_ptr_array_new();
1417
1418         for (disphdr_list = prefs_common.disphdr_list; disphdr_list != NULL;
1419              disphdr_list = disphdr_list->next) {
1420                 DisplayHeaderProp *dp =
1421                         (DisplayHeaderProp *)disphdr_list->data;
1422
1423                 for (i = 0; i < headers->len; i++) {
1424                         header = g_ptr_array_index(headers, i);
1425
1426                         if (procheader_headername_equal(header->name,
1427                                                         dp->name)) {
1428                                 if (dp->hidden)
1429                                         procheader_header_free(header);
1430                                 else
1431                                         g_ptr_array_add(sorted_headers, header);
1432
1433                                 g_ptr_array_remove_index(headers, i);
1434                                 i--;
1435                         }
1436                 }
1437         }
1438
1439         if (prefs_common.show_other_header) {
1440                 for (i = 0; i < headers->len; i++) {
1441                         header = g_ptr_array_index(headers, i);
1442                         g_ptr_array_add(sorted_headers, header);
1443                 }
1444                 g_ptr_array_free(headers, TRUE);
1445         } else
1446                 procheader_header_array_destroy(headers);
1447
1448         return sorted_headers;
1449 }
1450
1451 static void textview_show_header(TextView *textview, GPtrArray *headers)
1452 {
1453         GtkSText *text = GTK_STEXT(textview->text);
1454         Header *header;
1455         gint i;
1456
1457         g_return_if_fail(headers != NULL);
1458
1459         gtk_stext_freeze(text);
1460
1461         for (i = 0; i < headers->len; i++) {
1462                 header = g_ptr_array_index(headers, i);
1463                 g_return_if_fail(header->name != NULL);
1464
1465                 gtk_stext_insert(text, textview->boldfont, NULL, NULL,
1466                                 header->name, -1);
1467                 if (header->name[strlen(header->name) - 1] != ' ')
1468                         gtk_stext_insert(text, textview->boldfont,
1469                                         NULL, NULL, " ", 1);
1470
1471                 if (procheader_headername_equal(header->name, "Subject") ||
1472                     procheader_headername_equal(header->name, "From")    ||
1473                     procheader_headername_equal(header->name, "To")      ||
1474                     procheader_headername_equal(header->name, "Cc"))
1475                         unfold_line(header->body);
1476
1477                 if (textview->text_is_mb == TRUE)
1478                         conv_unreadable_locale(header->body);
1479
1480                 if (prefs_common.enable_color &&
1481                     (procheader_headername_equal(header->name, "X-Mailer") ||
1482                      procheader_headername_equal(header->name,
1483                                                  "X-Newsreader")) &&
1484                     strstr(header->body, "Sylpheed") != NULL)
1485                         gtk_stext_insert(text, NULL, &emphasis_color, NULL,
1486                                         header->body, -1);
1487                 else if (prefs_common.enable_color) {
1488                         textview_make_clickable_parts(textview,
1489                                                       NULL, NULL, &uri_color,
1490                                                       header->body);
1491                 } else {
1492                         textview_make_clickable_parts(textview,
1493                                                       NULL, NULL, NULL,
1494                                                       header->body);
1495                 }
1496                 gtk_stext_insert(text, textview->msgfont, NULL, NULL, "\n", 1);
1497         }
1498
1499         gtk_stext_thaw(text);
1500 }
1501
1502 gboolean textview_search_string(TextView *textview, const gchar *str,
1503                                 gboolean case_sens)
1504 {
1505         GtkSText *text = GTK_STEXT(textview->text);
1506         gint pos;
1507         wchar_t *wcs;
1508         gint len;
1509         gint text_len;
1510         gboolean found = FALSE;
1511
1512         g_return_val_if_fail(str != NULL, FALSE);
1513
1514         wcs = strdup_mbstowcs(str);
1515         g_return_val_if_fail(wcs != NULL, FALSE);
1516         len = wcslen(wcs);
1517         pos = textview->cur_pos;
1518         if (pos < textview->body_pos)
1519                 pos = textview->body_pos;
1520         text_len = gtk_stext_get_length(text);
1521         if (text_len - pos < len) {
1522                 g_free(wcs);
1523                 return FALSE;
1524         }
1525
1526         for (; pos < text_len; pos++) {
1527                 if (text_len - pos < len) break;
1528                 if (gtk_stext_match_string(text, pos, wcs, len, case_sens)
1529                     == TRUE) {
1530                         gtk_widget_hide(GTK_WIDGET(textview->scrolledwin));
1531                         gtk_editable_set_position(GTK_EDITABLE(text),
1532                                                   pos + len);
1533                         gtk_editable_select_region(GTK_EDITABLE(text),
1534                                                    pos, pos + len);
1535                         gtk_widget_show(GTK_WIDGET(textview->scrolledwin));
1536                         textview_set_position(textview, pos + len);
1537                         found = TRUE;
1538                         break;
1539                 }
1540                 if (text_len - pos == len) break;
1541         }
1542         g_free(wcs);
1543         return found;
1544 }
1545
1546 gboolean textview_search_string_backward(TextView *textview, const gchar *str,
1547                                          gboolean case_sens)
1548 {
1549         GtkSText *text = GTK_STEXT(textview->text);
1550         gint pos;
1551         wchar_t *wcs;
1552         gint len;
1553         gint text_len;
1554         gboolean found = FALSE;
1555
1556         g_return_val_if_fail(str != NULL, FALSE);
1557
1558         wcs = strdup_mbstowcs(str);
1559         g_return_val_if_fail(wcs != NULL, FALSE);
1560         len = wcslen(wcs);
1561         pos = textview->cur_pos;
1562         text_len = gtk_stext_get_length(text);
1563         if (text_len - textview->body_pos < len) {
1564                 g_free(wcs);
1565                 return FALSE;
1566         }
1567         if (pos <= textview->body_pos || text_len - pos < len)
1568                 pos = text_len - len;
1569
1570         for (; pos >= textview->body_pos; pos--) {
1571                 if (gtk_stext_match_string(text, pos, wcs, len, case_sens)
1572                     == TRUE) {
1573                         gtk_editable_set_position(GTK_EDITABLE(text), pos);
1574                         gtk_editable_select_region(GTK_EDITABLE(text),
1575                                                    pos, pos + len);
1576                         textview_set_position(textview, pos - 1);
1577                         found = TRUE;
1578                         break;
1579                 }
1580                 if (pos == textview->body_pos) break;
1581         }
1582
1583         g_free(wcs);
1584         return found;
1585 }
1586
1587 void textview_scroll_one_line(TextView *textview, gboolean up)
1588 {
1589         GtkSText *text = GTK_STEXT(textview->text);
1590         gfloat upper;
1591
1592         if (prefs_common.enable_smooth_scroll) {
1593                 textview_smooth_scroll_one_line(textview, up);
1594                 return;
1595         }
1596
1597         if (!up) {
1598                 upper = text->vadj->upper - text->vadj->page_size;
1599                 if (text->vadj->value < upper) {
1600                         text->vadj->value +=
1601                                 text->vadj->step_increment * 4;
1602                         text->vadj->value =
1603                                 MIN(text->vadj->value, upper);
1604                         gtk_signal_emit_by_name(GTK_OBJECT(text->vadj),
1605                                                 "value_changed");
1606                 }
1607         } else {
1608                 if (text->vadj->value > 0.0) {
1609                         text->vadj->value -=
1610                                 text->vadj->step_increment * 4;
1611                         text->vadj->value =
1612                                 MAX(text->vadj->value, 0.0);
1613                         gtk_signal_emit_by_name(GTK_OBJECT(text->vadj),
1614                                                 "value_changed");
1615                 }
1616         }
1617 }
1618
1619 gboolean textview_scroll_page(TextView *textview, gboolean up)
1620 {
1621         GtkSText *text = GTK_STEXT(textview->text);
1622         gfloat upper;
1623         gfloat page_incr;
1624
1625         if (prefs_common.enable_smooth_scroll)
1626                 return textview_smooth_scroll_page(textview, up);
1627
1628         if (prefs_common.scroll_halfpage)
1629                 page_incr = text->vadj->page_increment / 2;
1630         else
1631                 page_incr = text->vadj->page_increment;
1632
1633         if (!up) {
1634                 upper = text->vadj->upper - text->vadj->page_size;
1635                 if (text->vadj->value < upper) {
1636                         text->vadj->value += page_incr;
1637                         text->vadj->value = MIN(text->vadj->value, upper);
1638                         gtk_signal_emit_by_name(GTK_OBJECT(text->vadj),
1639                                                 "value_changed");
1640                 } else
1641                         return FALSE;
1642         } else {
1643                 if (text->vadj->value > 0.0) {
1644                         text->vadj->value -= page_incr;
1645                         text->vadj->value = MAX(text->vadj->value, 0.0);
1646                         gtk_signal_emit_by_name(GTK_OBJECT(text->vadj),
1647                                                 "value_changed");
1648                 } else
1649                         return FALSE;
1650         }
1651
1652         return TRUE;
1653 }
1654
1655 static void textview_smooth_scroll_do(TextView *textview,
1656                                       gfloat old_value, gfloat last_value,
1657                                       gint step)
1658 {
1659         GtkSText *text = GTK_STEXT(textview->text);
1660         gint change_value;
1661         gboolean up;
1662         gint i;
1663
1664         if (old_value < last_value) {
1665                 change_value = last_value - old_value;
1666                 up = FALSE;
1667         } else {
1668                 change_value = old_value - last_value;
1669                 up = TRUE;
1670         }
1671
1672         gdk_key_repeat_disable();
1673
1674         for (i = step; i <= change_value; i += step) {
1675                 text->vadj->value = old_value + (up ? -i : i);
1676                 gtk_signal_emit_by_name(GTK_OBJECT(text->vadj),
1677                                         "value_changed");
1678         }
1679
1680         text->vadj->value = last_value;
1681         gtk_signal_emit_by_name(GTK_OBJECT(text->vadj), "value_changed");
1682
1683         gdk_key_repeat_restore();
1684 }
1685
1686 static void textview_smooth_scroll_one_line(TextView *textview, gboolean up)
1687 {
1688         GtkSText *text = GTK_STEXT(textview->text);
1689         gfloat upper;
1690         gfloat old_value;
1691         gfloat last_value;
1692
1693         if (!up) {
1694                 upper = text->vadj->upper - text->vadj->page_size;
1695                 if (text->vadj->value < upper) {
1696                         old_value = text->vadj->value;
1697                         last_value = text->vadj->value +
1698                                 text->vadj->step_increment * 4;
1699                         last_value = MIN(last_value, upper);
1700
1701                         textview_smooth_scroll_do(textview, old_value,
1702                                                   last_value,
1703                                                   prefs_common.scroll_step);
1704                 }
1705         } else {
1706                 if (text->vadj->value > 0.0) {
1707                         old_value = text->vadj->value;
1708                         last_value = text->vadj->value -
1709                                 text->vadj->step_increment * 4;
1710                         last_value = MAX(last_value, 0.0);
1711
1712                         textview_smooth_scroll_do(textview, old_value,
1713                                                   last_value,
1714                                                   prefs_common.scroll_step);
1715                 }
1716         }
1717 }
1718
1719 static gboolean textview_smooth_scroll_page(TextView *textview, gboolean up)
1720 {
1721         GtkSText *text = GTK_STEXT(textview->text);
1722         gfloat upper;
1723         gfloat page_incr;
1724         gfloat old_value;
1725         gfloat last_value;
1726
1727         if (prefs_common.scroll_halfpage)
1728                 page_incr = text->vadj->page_increment / 2;
1729         else
1730                 page_incr = text->vadj->page_increment;
1731
1732         if (!up) {
1733                 upper = text->vadj->upper - text->vadj->page_size;
1734                 if (text->vadj->value < upper) {
1735                         old_value = text->vadj->value;
1736                         last_value = text->vadj->value + page_incr;
1737                         last_value = MIN(last_value, upper);
1738
1739                         textview_smooth_scroll_do(textview, old_value,
1740                                                   last_value,
1741                                                   prefs_common.scroll_step);
1742                 } else
1743                         return FALSE;
1744         } else {
1745                 if (text->vadj->value > 0.0) {
1746                         old_value = text->vadj->value;
1747                         last_value = text->vadj->value - page_incr;
1748                         last_value = MAX(last_value, 0.0);
1749
1750                         textview_smooth_scroll_do(textview, old_value,
1751                                                   last_value,
1752                                                   prefs_common.scroll_step);
1753                 } else
1754                         return FALSE;
1755         }
1756
1757         return TRUE;
1758 }
1759
1760 #define KEY_PRESS_EVENT_STOP() \
1761         if (gtk_signal_n_emissions_by_name \
1762                 (GTK_OBJECT(widget), "key_press_event") > 0) { \
1763                 gtk_signal_emit_stop_by_name(GTK_OBJECT(widget), \
1764                                              "key_press_event"); \
1765         }
1766
1767 static gint textview_key_pressed(GtkWidget *widget, GdkEventKey *event,
1768                                  TextView *textview)
1769 {
1770         SummaryView *summaryview = NULL;
1771         MessageView *messageview = textview->messageview;
1772
1773         if (!event) return FALSE;
1774         if (messageview->mainwin)
1775                 summaryview = messageview->mainwin->summaryview;
1776
1777         switch (event->keyval) {
1778         case GDK_Tab:
1779         case GDK_Home:
1780         case GDK_Left:
1781         case GDK_Up:
1782         case GDK_Right:
1783         case GDK_Down:
1784         case GDK_Page_Up:
1785         case GDK_Page_Down:
1786         case GDK_End:
1787         case GDK_Control_L:
1788         case GDK_Control_R:
1789                 break;
1790         case GDK_space:
1791                 if (summaryview)
1792                         summary_pass_key_press_event(summaryview, event);
1793                 else
1794                         textview_scroll_page(textview, FALSE);
1795                 break;
1796         case GDK_BackSpace:
1797                 textview_scroll_page(textview, TRUE);
1798                 break;
1799         case GDK_Return:
1800                 textview_scroll_one_line(textview,
1801                                          (event->state & GDK_MOD1_MASK) != 0);
1802                 break;
1803         case GDK_Delete:
1804                 if (summaryview)
1805                         summary_pass_key_press_event(summaryview, event);
1806                 break;
1807         case GDK_n:
1808         case GDK_N:
1809         case GDK_p:
1810         case GDK_P:
1811         case GDK_y:
1812         case GDK_t:
1813         case GDK_l:
1814                 if (messageview->type == MVIEW_MIME &&
1815                     textview == messageview->mimeview->textview) {
1816                         KEY_PRESS_EVENT_STOP();
1817                         mimeview_pass_key_press_event(messageview->mimeview,
1818                                                       event);
1819                         break;
1820                 }
1821                 /* fall through */
1822         default:
1823                 if (summaryview &&
1824                     event->window != messageview->mainwin->window->window) {
1825                         GdkEventKey tmpev = *event;
1826
1827                         tmpev.window = messageview->mainwin->window->window;
1828                         KEY_PRESS_EVENT_STOP();
1829                         gtk_widget_event(messageview->mainwin->window,
1830                                          (GdkEvent *)&tmpev);
1831                 }
1832                 break;
1833         }
1834
1835         return TRUE;
1836 }
1837
1838 static gint show_url_timeout_cb(gpointer data)
1839 {
1840         TextView *textview = (TextView *)data;
1841
1842         if (textview->messageview->mainwin)
1843                 if (textview->show_url_msgid)
1844                         gtk_statusbar_remove(GTK_STATUSBAR(
1845                                 textview->messageview->mainwin->statusbar),
1846                                 textview->messageview->mainwin->folderview_cid,
1847                                 textview->show_url_msgid);
1848                 return FALSE;
1849 }
1850
1851 static gint textview_button_pressed(GtkWidget *widget, GdkEventButton *event,
1852                                     TextView *textview)
1853 {
1854         if (event)
1855                 textview->last_buttonpress = event->type;
1856         return FALSE;
1857 }
1858
1859 static gint textview_button_released(GtkWidget *widget, GdkEventButton *event,
1860                                     TextView *textview)
1861 {
1862         textview->cur_pos =
1863                 gtk_editable_get_position(GTK_EDITABLE(textview->text));
1864
1865         if (event &&
1866             ((event->button == 1)
1867              || event->button == 2 || event->button == 3)) {
1868                 GSList *cur;
1869
1870                 /* double click seems to set the cursor after the current
1871                  * word. The cursor position needs fixing, otherwise the
1872                  * last word of a clickable zone will not work */
1873                 if (event->button == 1 && textview->last_buttonpress == GDK_2BUTTON_PRESS) {
1874                         textview->cur_pos--;
1875                 }
1876
1877                 for (cur = textview->uri_list; cur != NULL; cur = cur->next) {
1878                         RemoteURI *uri = (RemoteURI *)cur->data;
1879
1880                         if (textview->cur_pos >= uri->start &&
1881                             textview->cur_pos <  uri->end) {
1882                                 /* single click: display url in statusbar */
1883                                 if (event->button == 1 && textview->last_buttonpress != GDK_2BUTTON_PRESS) {
1884                                         if (textview->messageview->mainwin) {
1885                                                 if (textview->show_url_msgid) {
1886                                                         gtk_timeout_remove(textview->show_url_timeout_tag);
1887                                                         gtk_statusbar_remove(GTK_STATUSBAR(
1888                                                                 textview->messageview->mainwin->statusbar),
1889                                                                 textview->messageview->mainwin->folderview_cid,
1890                                                                 textview->show_url_msgid);
1891                                                         textview->show_url_msgid = 0;
1892                                                 }
1893                                                 textview->show_url_msgid = gtk_statusbar_push(
1894                                                                 GTK_STATUSBAR(textview->messageview->mainwin->statusbar),
1895                                                                 textview->messageview->mainwin->folderview_cid,
1896                                                                 uri->uri);
1897                                                 textview->show_url_timeout_tag = gtk_timeout_add( 4000, show_url_timeout_cb, textview );
1898                                                 gtkut_widget_wait_for_draw(textview->messageview->mainwin->hbox_stat);
1899                                         }
1900                                 } else
1901                                 if (!g_strncasecmp(uri->uri, "mailto:", 7)) {
1902                                         if (event->button == 3) {
1903                                                 gchar *fromname, *fromaddress;
1904
1905                                                 /* extract url */
1906                                                 fromaddress = g_strdup(uri->uri + 7);
1907                                                 /* Hiroyuki: please put this function in utils.c! */
1908                                                 fromname = procheader_get_fromname(fromaddress);
1909                                                 extract_address(fromaddress);
1910                                                 g_message("adding from textview %s <%s>", fromname, fromaddress);
1911                                                 /* Add to address book - Match */
1912                                                 addressbook_add_contact( fromname, fromaddress, NULL );
1913
1914                                                 g_free(fromaddress);
1915                                                 g_free(fromname);
1916                                         } else {
1917                                                 PrefsAccount *account = NULL;
1918                                                 FolderItem   *folder_item;
1919
1920                                                 if (textview->messageview && textview->messageview->mainwin
1921                                                 &&  textview->messageview->mainwin->summaryview
1922                                                 &&  textview->messageview->mainwin->summaryview->folder_item) {
1923                                                         folder_item = textview->messageview->mainwin->summaryview->folder_item;
1924                                                         if (folder_item->prefs && folder_item->prefs->enable_default_account)
1925                                                                 account = account_find_from_id(folder_item->prefs->default_account);
1926                                                 }
1927                                                 compose_new(account, uri->uri + 7, NULL);
1928                                         }
1929                                 } else
1930 #if USE_GPGME
1931                                 if (!g_strncasecmp(uri->uri, "pgp:", 4)) {
1932                                         GtkAdjustment *pos = gtk_scrolled_window_get_vadjustment(
1933                                                                 GTK_SCROLLED_WINDOW(textview->scrolledwin));
1934                                         gfloat vpos = pos->value;
1935                                         mimeview_check_signature(textview->messageview->mimeview);
1936                                         /* scroll back where we were */
1937                                         gtk_adjustment_set_value(pos, vpos);
1938                                 } else
1939 #endif
1940                                 {
1941                                         open_uri(uri->uri,
1942                                                  prefs_common.uri_cmd);
1943                                 }
1944                         }
1945                 }
1946         }
1947         if (event)
1948                 textview->last_buttonpress = event->type;
1949         return FALSE;
1950 }
1951
1952 static void textview_uri_list_remove_all(GSList *uri_list)
1953 {
1954         GSList *cur;
1955
1956         for (cur = uri_list; cur != NULL; cur = cur->next) {
1957                 if (cur->data) {
1958                         g_free(((RemoteURI *)cur->data)->uri);
1959                         g_free(cur->data);
1960                 }
1961         }
1962
1963         g_slist_free(uri_list);
1964 }