src/messageview.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 1999-2001 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 #include "defs.h"
  21
  22 #include <glib.h>
  23 #include <gdk/gdkkeysyms.h>
  24 #include <gtk/gtkvbox.h>
  25 #include <gtk/gtkcontainer.h>
  26 #include <gtk/gtkeditable.h>
  27 #include <gtk/gtkwindow.h>
  28 #include <gtk/gtktext.h>
  29 #include <stdio.h>
  30 #include <ctype.h>
  31 #include <string.h>
  32
  33 #include "intl.h"
  34 #include "main.h"
  35 #include "messageview.h"
  36 #include "headerview.h"
  37 #include "textview.h"
  38 #include "imageview.h"
  39 #include "mimeview.h"
  40 #include "procmsg.h"
  41 #include "procheader.h"
  42 #include "procmime.h"
  43 #include "prefs_common.h"
  44 #include "gtkutils.h"
  45 #include "utils.h"
  46 #include "rfc2015.h"
  47 #include "account.h"
  48 #include "alertpanel.h"
  49 #include "send.h"
  50 #include "pgptext.h"
  51
  52 static void messageview_change_view_type(MessageView    *messageview,
  53                                          MessageType     type);
  54 static void messageview_destroy_cb      (GtkWidget      *widget,
  55                                          MessageView    *messageview);
  56 static void messageview_size_allocate_cb(GtkWidget      *widget,
  57                                          GtkAllocation  *allocation);
  58 static void key_pressed                 (GtkWidget      *widget,
  59                                          GdkEventKey    *event,
  60                                          MessageView    *messageview);
  61
  62 MessageView *messageview_create(void)
  63 {
  64         MessageView *messageview;
  65         GtkWidget *vbox;
  66         HeaderView *headerview;
  67         TextView *textview;
  68         ImageView *imageview;
  69         MimeView *mimeview;
  70
  71         debug_print(_("Creating message view...\n"));
  72         messageview = g_new0(MessageView, 1);
  73
  74         messageview->type = MVIEW_TEXT;
  75
  76         headerview = headerview_create();
  77
  78         textview = textview_create();
  79         textview->messageview = messageview;
  80
  81         imageview = imageview_create();
  82         imageview->messageview = messageview;
  83
  84         mimeview = mimeview_create();
  85         mimeview->textview = textview;
  86         mimeview->imageview = imageview;
  87         mimeview->messageview = messageview;
  88
  89         vbox = gtk_vbox_new(FALSE, 0);
  90         gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET_PTR(headerview),
  91                            FALSE, FALSE, 0);
  92         gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET_PTR(textview),
  93                            TRUE, TRUE, 0);
  94
  95         /* to remove without destroyed */
  96         gtk_widget_ref(GTK_WIDGET_PTR(textview));
  97         gtk_widget_ref(GTK_WIDGET_PTR(imageview));
  98         gtk_widget_ref(GTK_WIDGET_PTR(mimeview));
  99
 100         messageview->vbox       = vbox;
 101         messageview->new_window = FALSE;
 102         messageview->window     = NULL;
 103         messageview->headerview = headerview;
 104         messageview->textview   = textview;
 105         messageview->imageview  = imageview;
 106         messageview->mimeview   = mimeview;
 107
 108         return messageview;
 109 }
 110
 111 MessageView *messageview_create_with_new_window(void)
 112 {
 113         GtkWidget *window;
 114         MessageView *msgview;
 115
 116         window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 117         gtk_window_set_title(GTK_WINDOW(window), _("Sylpheed - Message View"));
 118         gtk_window_set_wmclass(GTK_WINDOW(window), "message_view", "Sylpheed");
 119         gtk_window_set_policy(GTK_WINDOW(window), TRUE, TRUE, FALSE);
 120         gtk_widget_set_usize(window, prefs_common.msgwin_width,
 121                              prefs_common.msgwin_height);
 122
 123         msgview = messageview_create();
 124
 125         gtk_signal_connect(GTK_OBJECT(window), "size_allocate",
 126                            GTK_SIGNAL_FUNC(messageview_size_allocate_cb),
 127                            msgview);
 128         gtk_signal_connect(GTK_OBJECT(window), "destroy",
 129                            GTK_SIGNAL_FUNC(messageview_destroy_cb), msgview);
 130         gtk_signal_connect(GTK_OBJECT(window), "key_press_event",
 131                            GTK_SIGNAL_FUNC(key_pressed), msgview);
 132
 133         gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET_PTR(msgview));
 134         gtk_widget_grab_focus(msgview->textview->text);
 135         gtk_widget_show_all(window);
 136
 137         msgview->new_window = TRUE;
 138         msgview->window = window;
 139
 140         messageview_init(msgview);
 141
 142         return msgview;
 143 }
 144
 145 void messageview_init(MessageView *messageview)
 146 {
 147         headerview_init(messageview->headerview);
 148         textview_init(messageview->textview);
 149         imageview_init(messageview->imageview);
 150         mimeview_init(messageview->mimeview);
 151         /*messageview_set_font(messageview);*/
 152 }
 153
 154 static void notification_convert_header(gchar *dest, gint len, gchar *src,
 155                                         gint header_len)
 156 {
 157         g_return_if_fail(src != NULL);
 158         g_return_if_fail(dest != NULL);
 159
 160         if (len < 1) return;
 161
 162         remove_return(src);
 163
 164         if (is_ascii_str(src)) {
 165                 strncpy2(dest, src, len);
 166                 dest[len - 1] = '\0';
 167                 return;
 168         } else
 169                 conv_encode_header(dest, len, src, header_len);
 170 }
 171
 172 static gint disposition_notification_queue(PrefsAccount * account,
 173                                            gchar * to, const gchar *file)
 174 {
 175         FolderItem *queue;
 176         gchar *tmp, *queue_path;
 177         FILE *fp, *src_fp;
 178         GSList *cur;
 179         gchar buf[BUFFSIZE];
 180         gint num;
 181
 182         debug_print(_("queueing message...\n"));
 183         g_return_val_if_fail(account != NULL, -1);
 184
 185         tmp = g_strdup_printf("%s%cqueue.%d", g_get_tmp_dir(),
 186                               G_DIR_SEPARATOR, (gint)file);
 187         if ((fp = fopen(tmp, "w")) == NULL) {
 188                 FILE_OP_ERROR(tmp, "fopen");
 189                 g_free(tmp);
 190                 return -1;
 191         }
 192         if ((src_fp = fopen(file, "r")) == NULL) {
 193                 FILE_OP_ERROR(file, "fopen");
 194                 fclose(fp);
 195                 unlink(tmp);
 196                 g_free(tmp);
 197                 return -1;
 198         }
 199         if (change_file_mode_rw(fp, tmp) < 0) {
 200                 FILE_OP_ERROR(tmp, "chmod");
 201                 g_warning(_("can't change file mode\n"));
 202         }
 203
 204         /* queueing variables */
 205         fprintf(fp, "AF:\n");
 206         fprintf(fp, "NF:0\n");
 207         fprintf(fp, "PS:10\n");
 208         fprintf(fp, "SRH:1\n");
 209         fprintf(fp, "SFN:\n");
 210         fprintf(fp, "DSR:\n");
 211         fprintf(fp, "MID:\n");
 212         fprintf(fp, "CFG:\n");
 213         fprintf(fp, "PT:0\n");
 214         fprintf(fp, "S:%s\n", account->address);
 215         fprintf(fp, "RQ:\n");
 216         if (account->smtp_server)
 217                 fprintf(fp, "SSV:%s\n", account->smtp_server);
 218         else
 219                 fprintf(fp, "SSV:\n");
 220         if (account->nntp_server)
 221                 fprintf(fp, "NSV:%s\n", account->nntp_server);
 222         else
 223                 fprintf(fp, "NSV:\n");
 224         fprintf(fp, "SSH:\n");
 225         fprintf(fp, "R:<%s>", to);
 226         fprintf(fp, "\n");
 227         fprintf(fp, "\n");
 228
 229         while (fgets(buf, sizeof(buf), src_fp) != NULL) {
 230                 if (fputs(buf, fp) == EOF) {
 231                         FILE_OP_ERROR(tmp, "fputs");
 232                         fclose(fp);
 233                         fclose(src_fp);
 234                         unlink(tmp);
 235                         g_free(tmp);
 236                         return -1;
 237                 }
 238         }
 239
 240         fclose(src_fp);
 241         if (fclose(fp) == EOF) {
 242                 FILE_OP_ERROR(tmp, "fclose");
 243                 unlink(tmp);
 244                 g_free(tmp);
 245                 return -1;
 246         }
 247
 248         queue = folder_get_default_queue();
 249         folder_item_scan(queue);
 250         queue_path = folder_item_get_path(queue);
 251         if (!is_dir_exist(queue_path))
 252                 make_dir_hier(queue_path);
 253         if ((num = folder_item_add_msg(queue, tmp, TRUE)) < 0) {
 254                 g_warning(_("can't queue the message\n"));
 255                 unlink(tmp);
 256                 g_free(tmp);
 257                 g_free(queue_path);
 258                 return -1;
 259         }
 260         g_free(tmp);
 261
 262         if ((fp = procmsg_open_mark_file(queue_path, TRUE)) == NULL)
 263                 g_warning(_("can't open mark file\n"));
 264         else {
 265                 MsgInfo newmsginfo;
 266
 267                 newmsginfo.msgnum = num;
 268                 newmsginfo.flags.perm_flags = newmsginfo.flags.tmp_flags = 0;
 269                 procmsg_write_flags(&newmsginfo, fp);
 270                 fclose(fp);
 271         }
 272         g_free(queue_path);
 273
 274         folder_item_scan(queue);
 275         folderview_update_item(queue, TRUE);
 276
 277         return 0;
 278 }
 279
 280 static gint disposition_notification_send(MsgInfo * msginfo)
 281 {
 282         gchar buf[BUFFSIZE];
 283         gchar tmp[MAXPATHLEN + 1];
 284         FILE *fp;
 285         GSList * to_list;
 286         gint ok;
 287         gchar * to;
 288
 289         if ((!msginfo->returnreceiptto) &&
 290             (!msginfo->dispositionnotificationto))
 291                 return -1;
 292
 293         /* write to temporary file */
 294         g_snprintf(tmp, sizeof(tmp), "%s%ctmpmsg%d",
 295                    get_rc_dir(), G_DIR_SEPARATOR, (gint)msginfo);
 296
 297         if ((fp = fopen(tmp, "w")) == NULL) {
 298                 FILE_OP_ERROR(tmp, "fopen");
 299                 return -1;
 300         }
 301
 302         /* chmod for security */
 303         if (change_file_mode_rw(fp, tmp) < 0) {
 304                 FILE_OP_ERROR(tmp, "chmod");
 305                 g_warning(_("can't change file mode\n"));
 306         }
 307
 308         /* Date */
 309         get_rfc822_date(buf, sizeof(buf));
 310         fprintf(fp, "Date: %s\n", buf);
 311
 312         /* From */
 313         if (cur_account->name && *cur_account->name) {
 314                 notification_convert_header
 315                         (buf, sizeof(buf), cur_account->name,
 316                          strlen("From: "));
 317                 fprintf(fp, "From: %s <%s>\n", buf, cur_account->address);
 318         } else
 319                 fprintf(fp, "From: %s\n", cur_account->address);
 320
 321         /* To */
 322         if (msginfo->dispositionnotificationto)
 323                 to = msginfo->dispositionnotificationto;
 324         else
 325                 to = msginfo->returnreceiptto;
 326         fprintf(fp, "To: %s\n", to);
 327
 328         /* Subject */
 329         notification_convert_header(buf, sizeof(buf), msginfo->subject,
 330                                     strlen("Subject: "));
 331         fprintf(fp, "Subject: Disposition notification: %s\n", buf);
 332
 333         if (fclose(fp) == EOF) {
 334                 FILE_OP_ERROR(tmp, "fclose");
 335                 unlink(tmp);
 336                 return -1;
 337         }
 338
 339         to_list = address_list_append(NULL, msginfo->dispositionnotificationto);
 340         ok = send_message(tmp, cur_account, to_list);
 341
 342         if (ok < 0) {
 343                 if (prefs_common.queue_msg) {
 344                         AlertValue val;
 345
 346                         val = alertpanel
 347                                 (_("Queueing"),
 348                                  _("Error occurred while sending the notification.\n"
 349                                    "Put this notification into queue folder?"),
 350                                  _("OK"), _("Cancel"), NULL);
 351                         if (G_ALERTDEFAULT == val) {
 352                                 ok = disposition_notification_queue(cur_account, to, tmp);
 353                                 if (ok < 0)
 354                                         alertpanel_error(_("Can't queue the notification."));
 355                         }
 356                 } else
 357                         alertpanel_error(_("Error occurred while sending the notification."));
 358         }
 359
 360         if (unlink(tmp) < 0) FILE_OP_ERROR(tmp, "unlink");
 361
 362         return ok;
 363 }
 364
 365 void messageview_show(MessageView *messageview, MsgInfo *msginfo)
 366 {
 367         FILE *fp;
 368         gchar *file;
 369         MimeInfo *mimeinfo;
 370         MsgInfo *tmpmsginfo;
 371
 372         g_return_if_fail(msginfo != NULL);
 373
 374 #if USE_GPGME
 375         for (;;) {
 376                 if ((fp = procmsg_open_message(msginfo)) == NULL) return;
 377                 mimeinfo = procmime_scan_mime_header(fp, MIME_TEXT);
 378                 if (!mimeinfo) break;
 379
 380                 if (!MSG_IS_ENCRYPTED(msginfo->flags) &&
 381                     rfc2015_is_encrypted(mimeinfo)) {
 382                         MSG_SET_TMP_FLAGS(msginfo->flags, MSG_ENCRYPTED);
 383                 }
 384                 if (!MSG_IS_ENCRYPTED(msginfo->flags) &&
 385                     pgptext_is_encrypted(mimeinfo, msginfo)) {
 386                         MSG_SET_TMP_FLAGS(msginfo->flags, MSG_ENCRYPTED);
 387                         /* To avoid trouble with the rfc2015 stuff we go for encryption
 388                          * right here. */
 389                         if (MSG_IS_ENCRYPTED(msginfo->flags) &&
 390                             !msginfo->plaintext_file  &&
 391                             !msginfo->decryption_failed) {
 392                                 /* This is an encrypted message but it has not yet
 393                                  * been decrypted and there was no unsuccessful
 394                                  * decryption attempt */
 395                                 pgptext_decrypt_message(msginfo, mimeinfo, fp);
 396                                 if (msginfo->plaintext_file &&
 397                                     !msginfo->decryption_failed) {
 398                                         fclose(fp);
 399                                         continue;
 400                                 }
 401                         }
 402                 }
 403
 404                 if (MSG_IS_ENCRYPTED(msginfo->flags) &&
 405                     !msginfo->plaintext_file  &&
 406                     !msginfo->decryption_failed) {
 407                         /* This is an encrypted message but it has not yet
 408                          * been decrypted and there was no unsuccessful
 409                          * decryption attempt */
 410                         rfc2015_decrypt_message(msginfo, mimeinfo, fp);
 411                         if (msginfo->plaintext_file &&
 412                             !msginfo->decryption_failed) {
 413                                 fclose(fp);
 414                                 continue;
 415                         }
 416                 }
 417
 418                 break;
 419         }
 420 #else /* !USE_GPGME */
 421         if ((fp = procmsg_open_message(msginfo)) == NULL) return;
 422         mimeinfo = procmime_scan_mime_header(fp, MIME_TEXT);
 423 #endif /* USE_GPGME */
 424         fclose(fp);
 425         if (!mimeinfo) return;
 426
 427         file = procmsg_get_message_file_path(msginfo);
 428         g_return_if_fail(file != NULL);
 429
 430         /* FIXME - doesn't tmpmsginfo->flags have the value
 431          * of msginfo->flags after procheader_parse()???
 432          * in any case, checking tmpmsginfo->flags for MSG_UNREAD
 433          * fixes the return-receipt-request bug */
 434
 435         tmpmsginfo = procheader_parse(file, msginfo->flags, TRUE, TRUE);
 436         if (MSG_IS_MIME(tmpmsginfo->flags))
 437                 MSG_SET_TMP_FLAGS(msginfo->flags, MSG_MIME);
 438
 439         if (prefs_common.return_receipt
 440             && (tmpmsginfo->dispositionnotificationto
 441                 || tmpmsginfo->returnreceiptto)
 442             && (MSG_IS_UNREAD(msginfo->flags))) {
 443                 gint ok;
 444
 445                 if (alertpanel(_("Return Receipt"), _("Send return receipt ?"),
 446                                _("Yes"), _("No"), NULL) == G_ALERTDEFAULT) {
 447                         ok = disposition_notification_send(tmpmsginfo);
 448                         if (ok < 0)
 449                                 alertpanel_error(_("Error occurred while sending notification."));
 450                 }
 451         }
 452
 453         headerview_show(messageview->headerview, tmpmsginfo);
 454         procmsg_msginfo_free(tmpmsginfo);
 455
 456         if (mimeinfo->mime_type != MIME_TEXT) {
 457                 messageview_change_view_type(messageview, MVIEW_MIME);
 458                 mimeview_show_message(messageview->mimeview, mimeinfo, file);
 459         } else {
 460                 messageview_change_view_type(messageview, MVIEW_TEXT);
 461                 textview_show_message(messageview->textview, mimeinfo, file);
 462                 procmime_mimeinfo_free(mimeinfo);
 463         }
 464
 465         g_free(file);
 466 }
 467
 468 static void messageview_change_view_type(MessageView *messageview,
 469                                          MessageType type)
 470 {
 471         TextView *textview = messageview->textview;
 472         ImageView *imageview = messageview->imageview;
 473         MimeView *mimeview = messageview->mimeview;
 474
 475         if (messageview->type == type) return;
 476
 477         if (type == MVIEW_MIME) {
 478                 gtkut_container_remove
 479                         (GTK_CONTAINER(GTK_WIDGET_PTR(messageview)),
 480                          GTK_WIDGET_PTR(textview));
 481                 gtk_box_pack_start(GTK_BOX(messageview->vbox),
 482                                    GTK_WIDGET_PTR(mimeview), TRUE, TRUE, 0);
 483                 gtk_container_add(GTK_CONTAINER(mimeview->vbox),
 484                                   GTK_WIDGET_PTR(textview));
 485                 mimeview->type = MIMEVIEW_TEXT;
 486         } else if (type == MVIEW_TEXT) {
 487                 gtkut_container_remove
 488                         (GTK_CONTAINER(GTK_WIDGET_PTR(messageview)),
 489                          GTK_WIDGET_PTR(mimeview));
 490
 491                 if (mimeview->vbox == GTK_WIDGET_PTR(textview)->parent) {
 492                         gtkut_container_remove(GTK_CONTAINER(mimeview->vbox),
 493                                                GTK_WIDGET_PTR(textview));
 494                 } else {
 495                         gtkut_container_remove(GTK_CONTAINER(mimeview->vbox),
 496                                                GTK_WIDGET_PTR(imageview));
 497                 }
 498
 499                 gtk_box_pack_start(GTK_BOX(messageview->vbox),
 500                                    GTK_WIDGET_PTR(textview), TRUE, TRUE, 0);
 501         } else
 502                 return;
 503
 504         messageview->type = type;
 505 }
 506
 507 void messageview_clear(MessageView *messageview)
 508 {
 509         messageview_change_view_type(messageview, MVIEW_TEXT);
 510         headerview_clear(messageview->headerview);
 511         textview_clear(messageview->textview);
 512 }
 513
 514 void messageview_destroy(MessageView *messageview)
 515 {
 516         GtkWidget *textview  = GTK_WIDGET_PTR(messageview->textview);
 517         GtkWidget *imageview = GTK_WIDGET_PTR(messageview->imageview);
 518         GtkWidget *mimeview  = GTK_WIDGET_PTR(messageview->mimeview);
 519
 520         headerview_destroy(messageview->headerview);
 521         textview_destroy(messageview->textview);
 522         imageview_destroy(messageview->imageview);
 523         mimeview_destroy(messageview->mimeview);
 524
 525         g_free(messageview);
 526
 527         gtk_widget_unref(textview);
 528         gtk_widget_unref(imageview);
 529         gtk_widget_unref(mimeview);
 530 }
 531
 532 void messageview_quote_color_set(void)
 533 {
 534 }
 535
 536 void messageview_set_font(MessageView *messageview)
 537 {
 538         textview_set_font(messageview->textview, NULL);
 539 }
 540
 541 void messageview_copy_clipboard(MessageView *messageview)
 542 {
 543         switch (messageview->type) {
 544         case MVIEW_TEXT:
 545                 gtk_editable_copy_clipboard(GTK_EDITABLE(messageview->textview->text));
 546                 break;
 547         case MVIEW_MIME:
 548                 if (messageview->mimeview->type == MIMEVIEW_TEXT)
 549                         gtk_editable_copy_clipboard(GTK_EDITABLE(messageview->mimeview->textview->text));
 550         default:
 551                 break;
 552         }
 553 }
 554
 555 void messageview_select_all(MessageView *messageview)
 556 {
 557         switch (messageview->type) {
 558         case MVIEW_TEXT:
 559                 gtk_editable_select_region(GTK_EDITABLE(messageview->textview->text), 0, -1);
 560                 break;
 561         case MVIEW_MIME:
 562                 if (messageview->mimeview->type == MIMEVIEW_TEXT)
 563                         gtk_editable_select_region(GTK_EDITABLE(messageview->mimeview->textview->text), 0, -1);
 564         default:
 565                 break;
 566         }
 567 }
 568
 569 void messageview_set_position(MessageView *messageview, gint pos)
 570 {
 571         switch (messageview->type) {
 572         case MVIEW_TEXT:
 573                 textview_set_position(messageview->textview, pos);
 574                 break;
 575         case MVIEW_MIME:
 576                 if (messageview->mimeview->type == MIMEVIEW_TEXT)
 577                         textview_set_position(messageview->mimeview->textview, pos);
 578                 break;
 579         default:
 580                 break;
 581         }
 582 }
 583
 584 gboolean messageview_search_string(MessageView *messageview, const gchar *str,
 585                                    gboolean case_sens)
 586 {
 587         switch (messageview->type) {
 588         case MVIEW_TEXT:
 589                 return textview_search_string(messageview->textview,
 590                                         str, case_sens);
 591         case MVIEW_MIME:
 592                 if (messageview->mimeview->type == MIMEVIEW_TEXT)
 593                         return textview_search_string(messageview->mimeview->textview,
 594                                                 str, case_sens);
 595                 else
 596                         return FALSE;
 597         default:
 598                 return FALSE;
 599         }
 600
 601         return FALSE;
 602 }
 603
 604 gboolean messageview_search_string_backward(MessageView *messageview,
 605                                             const gchar *str,
 606                                             gboolean case_sens)
 607 {
 608         switch (messageview->type) {
 609         case MVIEW_TEXT:
 610                 return textview_search_string_backward(messageview->textview,
 611                                         str, case_sens);
 612         case MVIEW_MIME:
 613                 if (messageview->mimeview->type == MIMEVIEW_TEXT)
 614                         return textview_search_string_backward(messageview->mimeview->textview,
 615                                                 str, case_sens);
 616                 else
 617                         return FALSE;
 618         default:
 619                 return FALSE;
 620         }
 621
 622         return FALSE;
 623
 624 }
 625
 626 GtkWidget *messageview_get_text_widget(MessageView *messageview)
 627 {
 628         return messageview->textview->text;
 629 }
 630
 631 static void messageview_destroy_cb(GtkWidget *widget, MessageView *messageview)
 632 {
 633         messageview_destroy(messageview);
 634 }
 635
 636 static void messageview_size_allocate_cb(GtkWidget *widget,
 637                                          GtkAllocation *allocation)
 638 {
 639         g_return_if_fail(allocation != NULL);
 640
 641         prefs_common.msgwin_width  = allocation->width;
 642         prefs_common.msgwin_height = allocation->height;
 643 }
 644
 645 static void key_pressed(GtkWidget *widget, GdkEventKey *event,
 646                         MessageView *messageview)
 647 {
 648         if (event && event->keyval == GDK_Escape && messageview->window)
 649                 gtk_widget_destroy(messageview->window);
 650 }