lib-ui/curs_main.c

   1 /*
   2  * Copyright notice from original mutt:
   3  * Copyright (C) 1996-2000 Michael R. Elkins <me@mutt.org>
   4  *
   5  * Parts were written/modified by:
   6  * Nico Golde <nico@ngolde.de>
   7  *
   8  * This file is part of mutt-ng, see http://www.muttng.org/.
   9  * It's licensed under the GNU General Public License,
  10  * please see the file GPL in the top level source directory.
  11  */
  12
  13 #include <lib-lib/lib-lib.h>
  14
  15 #include <lib-ui/sidebar.h>
  16 #include <lib-mx/mx.h>
  17 #include <lib-crypt/crypt.h>
  18
  19 #include <pop/pop.h>
  20
  21 #include "curses.h"
  22 #include "menu.h"
  23
  24 #include "mutt.h"
  25 #include "pattern.h"
  26 #include "alias.h"
  27 #include "sort.h"
  28 #include "recvattach.h"
  29 #include "buffy.h"
  30 #include "thread.h"
  31
  32 #include <imap/imap_private.h>
  33
  34 #ifdef USE_NNTP
  35 #include <nntp/nntp.h>
  36 #endif
  37
  38 #ifdef USE_SASL
  39 #include "mutt_sasl.h"
  40 #endif
  41
  42 static const char *No_mailbox_is_open = N_("No mailbox is open.");
  43 static const char *There_are_no_messages = N_("There are no messages.");
  44 static const char *Mailbox_is_read_only = N_("Mailbox is read-only.");
  45 static const char *Function_not_permitted_in_attach_message_mode =
  46 N_("Function not permitted in attach-message mode.");
  47 static const char *No_visible = N_("No visible messages.");
  48
  49 #define CHECK_IN_MAILBOX if (!Context) \
  50         { \
  51                 mutt_flushinp (); \
  52                 mutt_error (_(No_mailbox_is_open)); \
  53                 break; \
  54         }
  55
  56 #define CHECK_MSGCOUNT if (!Context) \
  57         { \
  58                 mutt_flushinp (); \
  59                 mutt_error(_(No_mailbox_is_open)); \
  60                 break; \
  61         } \
  62         else if (!Context->msgcount) \
  63         { \
  64                   mutt_flushinp (); \
  65                 mutt_error(_(There_are_no_messages)); \
  66                 break; \
  67         }
  68
  69 #define CHECK_VISIBLE if (Context && menu->current >= Context->vcount) \
  70           {\
  71                   mutt_flushinp (); \
  72                   mutt_error(_(No_visible)); \
  73                   break; \
  74         }
  75
  76
  77 #define CHECK_READONLY if (Context->readonly) \
  78                         { \
  79                                   mutt_flushinp (); \
  80                                 mutt_error(_(Mailbox_is_read_only)); \
  81                                 break; \
  82                         }
  83
  84 #define CHECK_ATTACH if(option(OPTATTACHMSG)) \
  85                      {\
  86                         mutt_flushinp (); \
  87                         mutt_error(_(Function_not_permitted_in_attach_message_mode)); \
  88                         break; \
  89                      }
  90
  91 #define CURHDR Context->hdrs[Context->v2r[menu->current]]
  92 #define OLDHDR Context->hdrs[Context->v2r[menu->oldcurrent]]
  93 #define UNREAD(h) mutt_thread_contains_unread (Context, h)
  94 #define SW              (option(OPTMBOXPANE)?SidebarWidth:0)
  95
  96 extern size_t UngetCount;
  97
  98 void index_make_entry (char *s, ssize_t l, struct menu_t * menu, int num)
  99 {
 100   format_flag flag =
 101     M_FORMAT_MAKEPRINT | M_FORMAT_ARROWCURSOR | M_FORMAT_INDEX;
 102   int edgemsgno, reverse = Sort & SORT_REVERSE;
 103   HEADER *h = Context->hdrs[Context->v2r[num]];
 104   THREAD *tmp;
 105
 106   if ((Sort & SORT_MASK) == SORT_THREADS && h->tree) {
 107     flag |= M_FORMAT_TREE;      /* display the thread tree */
 108     if (h->display_subject)
 109       flag |= M_FORMAT_FORCESUBJ;
 110     else {
 111       if (reverse) {
 112         if (menu->top + menu->pagelen > menu->max)
 113           edgemsgno = Context->v2r[menu->max - 1];
 114         else
 115           edgemsgno = Context->v2r[menu->top + menu->pagelen - 1];
 116       }
 117       else
 118         edgemsgno = Context->v2r[menu->top];
 119
 120       for (tmp = h->thread->parent; tmp; tmp = tmp->parent) {
 121         if (!tmp->message)
 122           continue;
 123
 124         /* if no ancestor is visible on current screen, provisionally force
 125          * subject... */
 126         if (reverse ? tmp->message->msgno > edgemsgno : tmp->message->msgno <
 127             edgemsgno) {
 128           flag |= M_FORMAT_FORCESUBJ;
 129           break;
 130         }
 131         else if (tmp->message->virtual >= 0)
 132           break;
 133       }
 134       if (flag & M_FORMAT_FORCESUBJ) {
 135         for (tmp = h->thread->prev; tmp; tmp = tmp->prev) {
 136           if (!tmp->message)
 137             continue;
 138
 139           /* ...but if a previous sibling is available, don't force it */
 140           if (reverse ? tmp->message->msgno >
 141               edgemsgno : tmp->message->msgno < edgemsgno)
 142             break;
 143           else if (tmp->message->virtual >= 0) {
 144             flag &= ~M_FORMAT_FORCESUBJ;
 145             break;
 146           }
 147         }
 148       }
 149     }
 150   }
 151
 152   _mutt_make_string (s, l, NONULL (HdrFmt), Context, h, flag);
 153 }
 154
 155 int index_color (int index_no)
 156 {
 157   HEADER *h = Context->hdrs[Context->v2r[index_no]];
 158
 159   if (h && h->pair)
 160     return h->pair;
 161
 162   mutt_set_header_color (Context, h);
 163   return h->pair;
 164 }
 165
 166 static int ci_next_undeleted (int msgno)
 167 {
 168   int i;
 169
 170   for (i = msgno + 1; i < Context->vcount; i++)
 171     if (!Context->hdrs[Context->v2r[i]]->deleted)
 172       return (i);
 173   return (-1);
 174 }
 175
 176 static int ci_previous_undeleted (int msgno)
 177 {
 178   int i;
 179
 180   for (i = msgno - 1; i >= 0; i--)
 181     if (!Context->hdrs[Context->v2r[i]]->deleted)
 182       return (i);
 183   return (-1);
 184 }
 185
 186 /* Return the index of the first new message, or failing that, the first
 187  * unread message.
 188  */
 189 static int ci_first_message (void)
 190 {
 191   int old = -1, i;
 192
 193   if (Context && Context->msgcount) {
 194     for (i = 0; i < Context->vcount; i++) {
 195       if (!Context->hdrs[Context->v2r[i]]->read &&
 196           !Context->hdrs[Context->v2r[i]]->deleted) {
 197         if (!Context->hdrs[Context->v2r[i]]->old)
 198           return (i);
 199         else if (old == -1)
 200           old = i;
 201       }
 202     }
 203     if (old != -1)
 204       return (old);
 205
 206     /* If Sort is reverse and not threaded, the latest message is first.
 207      * If Sort is threaded, the latest message is first iff exactly one
 208      * of Sort and SortAux are reverse.
 209      */
 210     if (((Sort & SORT_REVERSE) && (Sort & SORT_MASK) != SORT_THREADS) ||
 211         ((Sort & SORT_MASK) == SORT_THREADS &&
 212          ((Sort ^ SortAux) & SORT_REVERSE)))
 213       return 0;
 214     else
 215       return (Context->vcount ? Context->vcount - 1 : 0);
 216   }
 217   return 0;
 218 }
 219
 220 /* This should be in mx.c, but it only gets used here. */
 221 static int mx_toggle_write (CONTEXT * ctx)
 222 {
 223   if (!ctx)
 224     return -1;
 225
 226   if (ctx->readonly) {
 227     mutt_error (_("Cannot toggle write on a readonly mailbox!"));
 228
 229     return -1;
 230   }
 231
 232   if (ctx->dontwrite) {
 233     ctx->dontwrite = 0;
 234     mutt_message (_("Changes to folder will be written on folder exit."));
 235   }
 236   else {
 237     ctx->dontwrite = 1;
 238     mutt_message (_("Changes to folder will not be written."));
 239   }
 240
 241   return 0;
 242 }
 243
 244 static void update_index (MUTTMENU * menu, CONTEXT * ctx __attribute__ ((unused)), int check,
 245                           int oldcount, int index_hint)
 246 {
 247   /* store pointers to the newly added messages */
 248   HEADER **save_new = NULL;
 249   int j;
 250
 251   /* take note of the current message */
 252   if (oldcount) {
 253     if (menu->current < Context->vcount)
 254       menu->oldcurrent = index_hint;
 255     else
 256       oldcount = 0;             /* invalid message number! */
 257   }
 258
 259   /* We are in a limited view. Check if the new message(s) satisfy
 260    * the limit criteria. If they do, set their virtual msgno so that
 261    * they will be visible in the limited view */
 262   if (Context->pattern) {
 263 #define THIS_BODY Context->hdrs[j]->content
 264     for (j = (check == M_REOPENED) ? 0 : oldcount; j < Context->msgcount; j++) {
 265       if (mutt_pattern_exec
 266           (Context->limit_pattern, M_MATCH_FULL_ADDRESS, Context,
 267             Context->hdrs[j])) {
 268         Context->hdrs[j]->virtual = Context->vcount;
 269         Context->v2r[Context->vcount] = j;
 270         Context->hdrs[j]->limited = 1;
 271         Context->vcount++;
 272         Context->vsize +=
 273           THIS_BODY->length + THIS_BODY->offset - THIS_BODY->hdr_offset;
 274       }
 275     }
 276 #undef THIS_BODY
 277   }
 278
 279   /* save the list of new messages */
 280   if (oldcount && check != M_REOPENED && ((Sort & SORT_MASK) == SORT_THREADS)) {
 281     save_new = p_new(HEADER*, Context->msgcount - oldcount);
 282     for (j = oldcount; j < Context->msgcount; j++)
 283       save_new[j - oldcount] = Context->hdrs[j];
 284   }
 285
 286   /* if the mailbox was reopened, need to rethread from scratch */
 287   mutt_sort_headers (Context, (check == M_REOPENED));
 288
 289   /* uncollapse threads with new mail */
 290   if ((Sort & SORT_MASK) == SORT_THREADS) {
 291     if (check == M_REOPENED) {
 292       THREAD *h, *c;
 293
 294       Context->collapsed = 0;
 295
 296       for (h = Context->tree; h; h = h->next) {
 297         for (c = h; !c->message; c = c->child);
 298         mutt_uncollapse_thread (Context, c->message);
 299       }
 300       mutt_set_virtual (Context);
 301     }
 302     else if (oldcount) {
 303       for (j = 0; j < Context->msgcount - oldcount; j++) {
 304         int k;
 305
 306         for (k = 0; k < Context->msgcount; k++) {
 307           HEADER *h = Context->hdrs[k];
 308
 309           if (h == save_new[j] && (!Context->pattern || h->limited))
 310             mutt_uncollapse_thread (Context, h);
 311         }
 312       }
 313       p_delete(&save_new);
 314       mutt_set_virtual (Context);
 315     }
 316   }
 317
 318   menu->current = -1;
 319   if (oldcount) {
 320     /* restore the current message to the message it was pointing to */
 321     for (j = 0; j < Context->vcount; j++) {
 322       if (Context->hdrs[Context->v2r[j]]->index == menu->oldcurrent) {
 323         menu->current = j;
 324         break;
 325       }
 326     }
 327   }
 328
 329   if (menu->current < 0)
 330     menu->current = ci_first_message ();
 331 }
 332
 333 static void resort_index (MUTTMENU * menu)
 334 {
 335   int i;
 336   HEADER *current = CURHDR;
 337
 338   menu->current = -1;
 339   mutt_sort_headers (Context, 0);
 340   /* Restore the current message */
 341
 342   for (i = 0; i < Context->vcount; i++) {
 343     if (Context->hdrs[Context->v2r[i]] == current) {
 344       menu->current = i;
 345       break;
 346     }
 347   }
 348
 349   if ((Sort & SORT_MASK) == SORT_THREADS && menu->current < 0)
 350     menu->current = mutt_parent_message (Context, current);
 351
 352   if (menu->current < 0)
 353     menu->current = ci_first_message ();
 354
 355   menu->redraw = REDRAW_INDEX | REDRAW_STATUS;
 356 }
 357
 358 struct mapping_t IndexHelp[] = {
 359   {N_("Quit"), OP_QUIT},
 360   {N_("Del"), OP_DELETE},
 361   {N_("Undel"), OP_UNDELETE},
 362   {N_("Save"), OP_SAVE},
 363   {N_("Mail"), OP_MAIL},
 364   {N_("Reply"), OP_REPLY},
 365   {N_("Group"), OP_GROUP_REPLY},
 366   {N_("Help"), OP_HELP},
 367   {NULL, OP_NULL}
 368 };
 369
 370 #ifdef USE_NNTP
 371 struct mapping_t IndexNewsHelp[] = {
 372   {N_("Quit"), OP_QUIT},
 373   {N_("Del"), OP_DELETE},
 374   {N_("Undel"), OP_UNDELETE},
 375   {N_("Save"), OP_SAVE},
 376   {N_("Post"), OP_POST},
 377   {N_("Followup"), OP_FOLLOWUP},
 378   {N_("Catchup"), OP_CATCHUP},
 379   {N_("Help"), OP_HELP},
 380   {NULL, OP_NULL}
 381 };
 382 #endif
 383
 384 /* This function handles the message index window as well as commands returned
 385  * from the pager (MENU_PAGER).
 386  */
 387 int mutt_index_menu (void)
 388 {
 389   char buf[LONG_STRING], helpstr[SHORT_STRING];
 390   int flags;
 391   int op = OP_NULL;
 392   int done = 0;                 /* controls when to exit the "event" loop */
 393   int i = 0, j;
 394   int tag = 0;                  /* has the tag-prefix command been pressed? */
 395   int newcount = -1;
 396   int oldcount = -1;
 397   int rc = -1;
 398   MUTTMENU *menu;
 399   char *cp;                     /* temporary variable. */
 400   int index_hint;               /* used to restore cursor position */
 401   int do_buffy_notify = 1;
 402   int closed = 0;                /* did we OP_QUIT or OP_EXIT out of this menu? */
 403   int attach_msg = option (OPTATTACHMSG);
 404
 405   menu = mutt_new_menu ();
 406   menu->menu = MENU_MAIN;
 407   menu->offset = 1;
 408   menu->pagelen = LINES - 3;
 409   menu->make_entry = (void *) index_make_entry;
 410   menu->color = index_color;
 411   menu->current = ci_first_message ();
 412   menu->help = mutt_compile_help (helpstr, sizeof (helpstr), MENU_MAIN,
 413 #ifdef USE_NNTP
 414                                   (Context
 415                                    && (Context->magic ==
 416                                        M_NNTP)) ? IndexNewsHelp :
 417 #endif
 418                                   IndexHelp);
 419
 420   if (!attach_msg) {
 421     buffy_check (0);       /* force the buffy check after we enter the folder */
 422     /* record folder we open to place sidebar indicator properly */
 423     if (Context && Context->path)
 424       sidebar_set_current (Context->path);
 425   }
 426
 427   for (;;) {
 428     tag = 0;                    /* clear the tag-prefix */
 429
 430     menu->max = Context ? Context->vcount : 0;
 431     oldcount = Context ? Context->msgcount : 0;
 432
 433     /* check if we need to resort the index because just about
 434      * any 'op' below could do mutt_enter_command(), either here or
 435      * from any new menu launched, and change $sort/$sort_aux
 436      */
 437     if (option (OPTNEEDRESORT) && Context && Context->msgcount)
 438       resort_index (menu);
 439
 440     if (option (OPTREDRAWTREE) && Context && Context->msgcount
 441         && (Sort & SORT_MASK) == SORT_THREADS) {
 442       mutt_draw_tree (Context);
 443       menu->redraw |= REDRAW_STATUS;
 444       unset_option (OPTREDRAWTREE);
 445     }
 446
 447     if (Context && !attach_msg) {
 448       int check;
 449
 450       /* check for new mail in the mailbox.  If nonzero, then something has
 451        * changed about the file (either we got new mail or the file was
 452        * modified underneath us.)
 453        */
 454
 455       imap_allow_reopen (Context);
 456
 457       index_hint = (Context->vcount && menu->current >= 0
 458                     && menu->current < Context->vcount) ? CURHDR->index : 0;
 459
 460       if ((check = mx_check_mailbox (Context, &index_hint, 0)) < 0) {
 461         if (!Context->path) {
 462           /* fatal error occurred */
 463           p_delete(&Context);
 464           menu->redraw = REDRAW_FULL;
 465         }
 466         set_option (OPTSEARCHINVALID);
 467       }
 468       else if (check == M_NEW_MAIL || check == M_REOPENED || check == M_FLAGS) {
 469         update_index (menu, Context, check, oldcount, index_hint);
 470
 471         /* notify the user of new mail */
 472         if (check == M_REOPENED)
 473           mutt_error (_
 474                       ("Mailbox was externally modified.  Flags may be wrong."));
 475         else if (check == M_NEW_MAIL) {
 476           /* on new mail: redraw sidebar */
 477           sidebar_draw ();
 478           mutt_message (_("New mail in this mailbox."));
 479
 480           if (option (OPTBEEPNEW))
 481             beep ();
 482         }
 483         else if (check == M_FLAGS)
 484           mutt_message (_("Mailbox was externally modified."));
 485
 486         /* avoid the message being overwritten by buffy */
 487         do_buffy_notify = 0;
 488
 489         menu->redraw = REDRAW_FULL;
 490         menu->max = Context->vcount;
 491
 492         set_option (OPTSEARCHINVALID);
 493       }
 494     }
 495
 496     imap_keepalive ();
 497     imap_disallow_reopen (Context);
 498
 499     if (!attach_msg) {
 500       /* check for new mail in the incoming folders */
 501       oldcount = newcount;
 502       if ((newcount = buffy_check (0)) != oldcount) {
 503         menu->redraw |= REDRAW_STATUS;
 504         menu->redraw |= REDRAW_SIDEBAR;
 505       }
 506       if (do_buffy_notify) {
 507         if (buffy_notify () && option (OPTBEEPNEW))
 508           beep ();
 509       }
 510       else
 511         do_buffy_notify = 1;
 512     }
 513
 514     if (op != -1)
 515       mutt_curs_set (0);
 516     if (menu->redraw & REDRAW_SIDEBAR)
 517       sidebar_draw ();
 518     if (menu->redraw & REDRAW_FULL) {
 519       menu_redraw_full (menu);
 520       sidebar_draw ();
 521       mutt_show_error ();
 522     }
 523
 524     if (menu->menu == MENU_MAIN) {
 525       if (Context && Context->hdrs && !(menu->current >= Context->vcount)) {
 526         menu_check_recenter (menu);
 527
 528         if (menu->redraw & REDRAW_INDEX) {
 529           menu_redraw_index (menu);
 530           menu->redraw |= REDRAW_STATUS;
 531         }
 532         else if (menu->redraw & (REDRAW_MOTION_RESYNCH | REDRAW_MOTION))
 533           menu_redraw_motion (menu);
 534         else if (menu->redraw & REDRAW_CURRENT)
 535           menu_redraw_current (menu);
 536       }
 537
 538       if (menu->redraw & REDRAW_STATUS) {
 539         menu_status_line (buf, sizeof (buf), menu, NONULL (Status));
 540         CLEARLINE (option (OPTSTATUSONTOP) ? 0 : LINES - 2);
 541         sidebar_draw_frames();
 542         SETCOLOR (MT_COLOR_STATUS);
 543         BKGDSET (MT_COLOR_STATUS);
 544         move(option (OPTSTATUSONTOP) ? 0 : LINES - 2,SW);
 545         mutt_paddstr (COLS-SW, buf);
 546         SETCOLOR (MT_COLOR_NORMAL);
 547         BKGDSET (MT_COLOR_NORMAL);
 548         sidebar_set_buffystats (Context);
 549         menu->redraw &= ~REDRAW_STATUS;
 550         if (option (OPTXTERMSETTITLES)) {
 551           menu_status_line(buf, sizeof(buf), menu, NONULL(XtermTitle));
 552           printf("\033]2;%s\007", buf);
 553           menu_status_line(buf, sizeof(buf), menu, NONULL(XtermIcon));
 554           printf("\033]1;%s\007", buf);
 555           fflush(stdout);
 556         }
 557       }
 558
 559       menu->redraw = 0;
 560       if (menu->current < menu->max)
 561         menu->oldcurrent = menu->current;
 562       else
 563         menu->oldcurrent = -1;
 564
 565       if (option (OPTARROWCURSOR))
 566         move (menu->current - menu->top + menu->offset, 2);
 567        else if (option (OPTBRAILLEFRIENDLY))
 568          move (menu->current - menu->top + menu->offset, 0);
 569       else
 570         move (menu->current - menu->top + menu->offset, COLS - 1);
 571       mutt_refresh ();
 572
 573 #if defined (USE_SLANG_CURSES) || defined (HAVE_RESIZETERM)
 574       if (SigWinch) {
 575         mutt_flushinp ();
 576         mutt_resize_screen ();
 577         menu->redraw = REDRAW_FULL;
 578         menu->menu = MENU_MAIN;
 579         SigWinch = 0;
 580         menu->top = 0;          /* so we scroll the right amount */
 581         /*
 582          * force a real complete redraw.  clrtobot() doesn't seem to be able
 583          * to handle every case without this.
 584          */
 585         clearok (stdscr, TRUE);
 586         continue;
 587       }
 588 #endif
 589
 590       op = km_dokey (MENU_MAIN);
 591
 592       if (op == -1)
 593         continue;               /* either user abort or timeout */
 594
 595       mutt_curs_set (1);
 596
 597       /* special handling for the tag-prefix function */
 598       if (op == OP_TAG_PREFIX) {
 599         if (!Context) {
 600           mutt_error (_("No mailbox is open."));
 601
 602           continue;
 603         }
 604
 605         if (!Context->tagged) {
 606           mutt_error (_("No tagged messages."));
 607
 608           continue;
 609         }
 610         tag = 1;
 611
 612         /* give visual indication that the next command is a tag- command */
 613         mvaddstr (LINES - 1, 0, "tag-");
 614         clrtoeol ();
 615
 616         /* get the real command */
 617         if ((op = km_dokey (MENU_MAIN)) == OP_TAG_PREFIX) {
 618           /* abort tag sequence */
 619           CLEARLINE (LINES - 1);
 620           continue;
 621         }
 622       }
 623       else if (option (OPTAUTOTAG) && Context && Context->tagged)
 624         tag = 1;
 625
 626       if (op == OP_TAG_PREFIX_COND) {
 627         if (!Context) {
 628           mutt_error (_("No mailbox is open."));
 629
 630           continue;
 631         }
 632
 633         if (!Context->tagged) {
 634           event_t tmp;
 635
 636           while (UngetCount > 0) {
 637             tmp = mutt_getch ();
 638             if (tmp.op == OP_END_COND)
 639               break;
 640           }
 641           mutt_message (_("Nothing to do."));
 642
 643           continue;
 644         }
 645         tag = 1;
 646
 647         /* give visual indication that the next command is a tag- command */
 648         mvaddstr (LINES - 1, 0, "tag-");
 649         clrtoeol ();
 650
 651         /* get the real command */
 652         if ((op = km_dokey (MENU_MAIN)) == OP_TAG_PREFIX) {
 653           /* abort tag sequence */
 654           CLEARLINE (LINES - 1);
 655           continue;
 656         }
 657       }
 658
 659       mutt_clear_error ();
 660     }
 661     else {
 662       if (menu->current < menu->max)
 663         menu->oldcurrent = menu->current;
 664       else
 665         menu->oldcurrent = -1;
 666
 667       mutt_curs_set (1);        /* fallback from the pager */
 668     }
 669
 670 #ifdef USE_NNTP
 671     unset_option (OPTNEWS);     /* for any case */
 672 #endif
 673
 674     switch (op) {
 675
 676       /* ----------------------------------------------------------------------
 677        * movement commands
 678        */
 679
 680     case OP_BOTTOM_PAGE:
 681       menu_bottom_page (menu);
 682       break;
 683     case OP_FIRST_ENTRY:
 684       menu_first_entry (menu);
 685       break;
 686     case OP_MIDDLE_PAGE:
 687       menu_middle_page (menu);
 688       break;
 689     case OP_HALF_UP:
 690       menu_half_up (menu);
 691       break;
 692     case OP_HALF_DOWN:
 693       menu_half_down (menu);
 694       break;
 695     case OP_NEXT_LINE:
 696       menu_next_line (menu);
 697       break;
 698     case OP_PREV_LINE:
 699       menu_prev_line (menu);
 700       break;
 701     case OP_NEXT_PAGE:
 702       menu_next_page (menu);
 703       break;
 704     case OP_PREV_PAGE:
 705       menu_prev_page (menu);
 706       break;
 707     case OP_LAST_ENTRY:
 708       menu_last_entry (menu);
 709       break;
 710     case OP_TOP_PAGE:
 711       menu_top_page (menu);
 712       break;
 713     case OP_CURRENT_TOP:
 714       menu_current_top (menu);
 715       break;
 716     case OP_CURRENT_MIDDLE:
 717       menu_current_middle (menu);
 718       break;
 719     case OP_CURRENT_BOTTOM:
 720       menu_current_bottom (menu);
 721       break;
 722
 723 #ifdef USE_NNTP
 724     case OP_GET_MESSAGE:
 725     case OP_GET_PARENT:
 726       CHECK_MSGCOUNT;
 727       if (Context->magic == M_NNTP) {
 728         HEADER *h;
 729
 730         if (op == OP_GET_MESSAGE) {
 731           buf[0] = 0;
 732           if (mutt_get_field (_("Enter Message-ID: "), buf, sizeof (buf), 0)
 733               != 0 || !buf[0])
 734             break;
 735         }
 736         else {
 737           string_list_t *ref = CURHDR->env->references;
 738
 739           if (!ref) {
 740             mutt_error (_("Article has no parent reference!"));
 741
 742             break;
 743           }
 744           m_strcpy(buf, sizeof(buf), ref->data);
 745         }
 746         if (!Context->id_hash)
 747           Context->id_hash = mutt_make_id_hash (Context);
 748         if ((h = hash_find (Context->id_hash, buf))) {
 749           if (h->virtual != -1) {
 750             menu->current = h->virtual;
 751             menu->redraw = REDRAW_MOTION_RESYNCH;
 752           }
 753           else if (h->collapsed) {
 754             mutt_uncollapse_thread (Context, h);
 755             mutt_set_virtual (Context);
 756             menu->current = h->virtual;
 757             menu->redraw = REDRAW_MOTION_RESYNCH;
 758           }
 759           else
 760             mutt_error (_("Message not visible in limited view."));
 761         }
 762         else {
 763           if (nntp_check_msgid (Context, buf) == 0) {
 764             h = Context->hdrs[Context->msgcount - 1];
 765             mutt_sort_headers (Context, 0);
 766             menu->current = h->virtual;
 767             menu->redraw = REDRAW_FULL;
 768           }
 769           else
 770             mutt_error (_("Article %s not found on server"), buf);
 771         }
 772       }
 773       break;
 774
 775     case OP_GET_CHILDREN:
 776     case OP_RECONSTRUCT_THREAD:
 777       CHECK_MSGCOUNT;
 778       if (Context->magic == M_NNTP) {
 779         HEADER *h;
 780         int old = CURHDR->index;
 781
 782         if (!CURHDR->env->message_id) {
 783           mutt_error (_("No Message-ID. Unable to perform operation"));
 784
 785           break;
 786         }
 787
 788         if (!Context->id_hash)
 789           Context->id_hash = mutt_make_id_hash (Context);
 790         m_strcpy(buf, sizeof(buf), CURHDR->env->message_id);
 791
 792         if (op == OP_RECONSTRUCT_THREAD) {
 793           string_list_t *ref = CURHDR->env->references;
 794
 795           while (ref) {
 796             nntp_check_msgid (Context, ref->data);
 797             /* the last msgid in References is the root message */
 798             if (!ref->next)
 799               m_strcpy(buf, sizeof(buf), ref->data);
 800             ref = ref->next;
 801           }
 802         }
 803         mutt_message (_("Check for children of message..."));
 804
 805         if (nntp_check_children (Context, buf) == 0) {
 806           mutt_sort_headers (Context, (op == OP_RECONSTRUCT_THREAD));
 807           h = hash_find (Context->id_hash, buf);
 808           /* if the root message was retrieved, move to it */
 809           if (h)
 810             menu->current = h->virtual;
 811           else                  /* try to restore old position */
 812             for (i = 0; i < Context->msgcount; i++)
 813               if (Context->hdrs[i]->index == old) {
 814                 menu->current = Context->hdrs[i]->virtual;
 815                 /* As an added courtesy, recenter the menu
 816                  * with the current entry at the middle of the screen */
 817                 menu_check_recenter (menu);
 818                 menu_current_middle (menu);
 819               }
 820         }
 821         menu->redraw = REDRAW_FULL;
 822         mutt_clear_error ();
 823       }
 824       break;
 825 #endif
 826
 827     case OP_JUMP:
 828
 829       CHECK_MSGCOUNT;
 830       CHECK_VISIBLE;
 831       if (isdigit (LastKey))
 832         mutt_ungetch (LastKey, 0);
 833       buf[0] = 0;
 834       if (mutt_get_field (_("Jump to message: "), buf, sizeof (buf), 0) != 0
 835           || !buf[0])
 836         break;
 837
 838       if (!isdigit ((unsigned char) buf[0])) {
 839         mutt_error (_("Argument must be a message number."));
 840
 841         break;
 842       }
 843
 844       i = atoi (buf);
 845       if (i > 0 && i <= Context->msgcount) {
 846         for (j = i - 1; j < Context->msgcount; j++) {
 847           if (Context->hdrs[j]->virtual != -1)
 848             break;
 849         }
 850         if (j >= Context->msgcount) {
 851           for (j = i - 2; j >= 0; j--) {
 852             if (Context->hdrs[j]->virtual != -1)
 853               break;
 854           }
 855         }
 856
 857         if (j >= 0) {
 858           menu->current = Context->hdrs[j]->virtual;
 859           if (menu->menu == MENU_PAGER) {
 860             op = OP_DISPLAY_MESSAGE;
 861             continue;
 862           }
 863           else
 864             menu->redraw = REDRAW_MOTION;
 865         }
 866         else
 867           mutt_error (_("That message is not visible."));
 868       }
 869       else
 870         mutt_error (_("Invalid message number."));
 871
 872       break;
 873
 874       /* --------------------------------------------------------------------
 875        * `index' specific commands
 876        */
 877
 878     case OP_MAIN_DELETE_PATTERN:
 879
 880       CHECK_MSGCOUNT;
 881       CHECK_VISIBLE;
 882       CHECK_READONLY;
 883
 884       CHECK_MX_ACL (Context, ACL_DELETE, _("Deletion"));
 885
 886       CHECK_ATTACH;
 887       mutt_pattern_func (M_DELETE, _("Delete messages matching: "));
 888       menu->redraw = REDRAW_INDEX | REDRAW_STATUS;
 889       break;
 890
 891     case OP_MAIN_FETCH_MAIL:
 892
 893       CHECK_ATTACH;
 894       pop_fetch_mail ();
 895       menu->redraw = REDRAW_FULL;
 896       break;
 897
 898     case OP_HELP:
 899
 900       mutt_help (MENU_MAIN);
 901       menu->redraw = REDRAW_FULL;
 902       break;
 903
 904     case OP_MAIN_SHOW_LIMIT:
 905       CHECK_IN_MAILBOX;
 906       if (!Context->pattern)
 907         mutt_message (_("No limit pattern is in effect."));
 908
 909       else {
 910         char buffer[STRING];
 911
 912         /* i18n: ask for a limit to apply */
 913         snprintf (buffer, sizeof (buffer), _("Limit: %s"), Context->pattern);
 914         mutt_message ("%s", buffer);
 915       }
 916       break;
 917
 918     case OP_MAIN_LIMIT:
 919     case OP_TOGGLE_READ:
 920
 921       CHECK_IN_MAILBOX;
 922       menu->oldcurrent = (Context->vcount && menu->current >= 0
 923                           && menu->current <
 924                           Context->vcount) ? CURHDR->index : -1;
 925       if (op == OP_TOGGLE_READ) {
 926         char buffer[LONG_STRING];
 927
 928         if (m_strncmp (Context->pattern, "!~R!~D~s", 8) != 0) {
 929           snprintf (buffer, sizeof (buffer), "!~R!~D~s%s",
 930                     Context->pattern ? Context->pattern : ".*");
 931           set_option (OPTHIDEREAD);
 932         }
 933         else {
 934           m_strcpy(buf, sizeof(buf), Context->pattern + 8);
 935           if (m_strncmp (buf, ".*", 2) == 0)
 936             snprintf (buf, sizeof (buf), "~A");
 937           unset_option (OPTHIDEREAD);
 938         }
 939         p_delete(&Context->pattern);
 940         Context->pattern = m_strdup(buf);
 941       }
 942       if ((op == OP_TOGGLE_READ && mutt_pattern_func (M_LIMIT, NULL) == 0) ||
 943           mutt_pattern_func (M_LIMIT, _("Limit to messages matching: ")) == 0)
 944       {
 945         if (menu->oldcurrent >= 0) {
 946           /* try to find what used to be the current message */
 947           menu->current = -1;
 948           for (i = 0; i < Context->vcount; i++)
 949             if (Context->hdrs[Context->v2r[i]]->index == menu->oldcurrent) {
 950               menu->current = i;
 951               break;
 952             }
 953           if (menu->current < 0)
 954             menu->current = 0;
 955         }
 956         else
 957           menu->current = 0;
 958         menu->redraw = REDRAW_INDEX | REDRAW_STATUS;
 959         if (Context->msgcount && (Sort & SORT_MASK) == SORT_THREADS)
 960           mutt_draw_tree (Context);
 961         menu->redraw = REDRAW_FULL;
 962       }
 963       if (Context->pattern)
 964         mutt_message _("To view all messages, limit to \"all\".");
 965       break;
 966
 967     case OP_QUIT:
 968
 969       closed = op;
 970       if (attach_msg) {
 971         done = 1;
 972         break;
 973       }
 974
 975       if (query_quadoption (OPT_QUIT, _("Quit Madmutt?")) == M_YES) {
 976         int check;
 977
 978         oldcount = Context ? Context->msgcount : 0;
 979
 980         if (!Context
 981             || (check = mx_close_mailbox (Context, &index_hint)) == 0)
 982           done = 1;
 983         else {
 984           if (check == M_NEW_MAIL || check == M_REOPENED)
 985             update_index (menu, Context, check, oldcount, index_hint);
 986
 987           menu->redraw = REDRAW_FULL;   /* new mail arrived? */
 988           set_option (OPTSEARCHINVALID);
 989         }
 990       }
 991       break;
 992
 993     case OP_REDRAW:
 994
 995       clearok (stdscr, TRUE);
 996       menu->redraw = REDRAW_FULL;
 997       break;
 998
 999     case OP_SEARCH:
1000     case OP_SEARCH_REVERSE:
1001     case OP_SEARCH_NEXT:
1002     case OP_SEARCH_OPPOSITE:
1003
1004       CHECK_MSGCOUNT;
1005       CHECK_VISIBLE;
1006       if ((menu->current = mutt_search_command (menu->current, op)) == -1)
1007         menu->current = menu->oldcurrent;
1008       else
1009         menu->redraw = REDRAW_MOTION;
1010       break;
1011
1012     case OP_SORT:
1013     case OP_SORT_REVERSE:
1014
1015       if (mutt_select_sort ((op == OP_SORT_REVERSE)) == 0) {
1016         if (Context && Context->msgcount) {
1017           resort_index (menu);
1018           set_option (OPTSEARCHINVALID);
1019         }
1020       }
1021       break;
1022
1023     case OP_TAG:
1024
1025       CHECK_MSGCOUNT;
1026       CHECK_VISIBLE;
1027       if (tag && !option (OPTAUTOTAG)) {
1028         for (j = 0; j < Context->vcount; j++)
1029           mutt_set_flag (Context, Context->hdrs[Context->v2r[j]], M_TAG, 0);
1030         menu->redraw = REDRAW_STATUS | REDRAW_INDEX;
1031       }
1032       else {
1033         mutt_set_flag (Context, CURHDR, M_TAG, !CURHDR->tagged);
1034         Context->last_tag = CURHDR->tagged ? CURHDR :
1035           ((Context->last_tag == CURHDR && !CURHDR->tagged)
1036            ? NULL : Context->last_tag);
1037         menu->redraw = REDRAW_STATUS;
1038         if (option (OPTRESOLVE) && menu->current < Context->vcount - 1) {
1039           menu->current++;
1040           menu->redraw |= REDRAW_MOTION_RESYNCH;
1041         }
1042         else
1043           menu->redraw |= REDRAW_CURRENT;
1044       }
1045       break;
1046
1047     case OP_MAIN_TAG_PATTERN:
1048
1049       CHECK_MSGCOUNT;
1050       CHECK_VISIBLE;
1051       mutt_pattern_func (M_TAG, _("Tag messages matching: "));
1052       menu->redraw = REDRAW_INDEX | REDRAW_STATUS;
1053       break;
1054
1055     case OP_MAIN_UNDELETE_PATTERN:
1056
1057       CHECK_MSGCOUNT;
1058       CHECK_VISIBLE;
1059       CHECK_READONLY;
1060
1061       CHECK_MX_ACL (Context, ACL_DELETE, _("Undeletion"));
1062
1063       if (mutt_pattern_func (M_UNDELETE, _("Undelete messages matching: ")) ==
1064           0)
1065         menu->redraw = REDRAW_INDEX | REDRAW_STATUS;
1066       break;
1067
1068     case OP_MAIN_UNTAG_PATTERN:
1069
1070       CHECK_MSGCOUNT;
1071       CHECK_VISIBLE;
1072       if (mutt_pattern_func (M_UNTAG, _("Untag messages matching: ")) == 0)
1073         menu->redraw = REDRAW_INDEX | REDRAW_STATUS;
1074       break;
1075
1076       /* --------------------------------------------------------------------
1077        * The following operations can be performed inside of the pager.
1078        */
1079
1080     case OP_MAIN_IMAP_FETCH:
1081       if (Context->magic == M_IMAP)
1082         imap_check_mailbox (Context, &index_hint, 1);
1083       break;
1084
1085     case OP_MAIN_SYNC_FOLDER:
1086
1087       if (Context && !Context->msgcount)
1088         break;
1089
1090       CHECK_MSGCOUNT;
1091       CHECK_VISIBLE;
1092       CHECK_READONLY;
1093       {
1094         int oldvcount = Context->vcount;
1095         oldcount = Context->msgcount;
1096         int dcount = 0;
1097         int check;
1098
1099         /* calculate the number of messages _above_ the cursor,
1100          * so we can keep the cursor on the current message
1101          */
1102         for (j = 0; j <= menu->current; j++) {
1103           if (Context->hdrs[Context->v2r[j]]->deleted)
1104             dcount++;
1105         }
1106
1107         if ((check = mx_sync_mailbox (Context, &index_hint)) == 0) {
1108           if (Context->vcount != oldvcount)
1109             menu->current -= dcount;
1110           set_option (OPTSEARCHINVALID);
1111         }
1112         else if (check == M_NEW_MAIL || check == M_REOPENED)
1113           update_index (menu, Context, check, oldcount, index_hint);
1114
1115         /*
1116          * do a sanity check even if mx_sync_mailbox failed.
1117          */
1118
1119         if (menu->current < 0 || menu->current >= Context->vcount)
1120           menu->current = ci_first_message ();
1121       }
1122
1123       /* check for a fatal error, or all messages deleted */
1124       if (!Context->path)
1125         p_delete(&Context);
1126
1127       /* if we were in the pager, redisplay the message */
1128       if (menu->menu == MENU_PAGER) {
1129         op = OP_DISPLAY_MESSAGE;
1130         continue;
1131       }
1132       else
1133         menu->redraw = REDRAW_FULL;
1134       break;
1135
1136     case OP_SIDEBAR_OPEN:
1137     case OP_MAIN_CHANGE_FOLDER:
1138     case OP_MAIN_CHANGE_FOLDER_READONLY:
1139 #ifdef USE_NNTP
1140     case OP_MAIN_CHANGE_GROUP:
1141     case OP_MAIN_CHANGE_GROUP_READONLY:
1142 #endif
1143       if (attach_msg || option (OPTREADONLY) ||
1144 #ifdef USE_NNTP
1145           op == OP_MAIN_CHANGE_GROUP_READONLY ||
1146 #endif
1147           op == OP_MAIN_CHANGE_FOLDER_READONLY)
1148         flags = M_READONLY;
1149       else
1150         flags = 0;
1151
1152       if (flags)
1153         cp = _("Open mailbox in read-only mode");
1154       else
1155         cp = _("Open mailbox");
1156
1157       buf[0] = '\0';
1158 #ifdef USE_NNTP
1159       unset_option (OPTNEWS);
1160       if (op == OP_MAIN_CHANGE_GROUP || op == OP_MAIN_CHANGE_GROUP_READONLY) {
1161         set_option (OPTNEWS);
1162         if (!(CurrentNewsSrv = mutt_select_newsserver (NewsServer)))
1163           break;
1164         if (flags)
1165           cp = _("Open newsgroup in read-only mode");
1166         else
1167           cp = _("Open newsgroup");
1168         nntp_buffy (buf, sizeof (buf));
1169       }
1170       else
1171 #endif
1172       {
1173         if (Context && Context->path)
1174           m_strcpy(buf, sizeof(buf), Context->path);
1175         if (op != OP_SIDEBAR_OPEN)
1176           buffy_next (buf, sizeof (buf));
1177       }
1178
1179       if (op == OP_SIDEBAR_OPEN) {
1180         m_strcpy(buf, sizeof(buf), sidebar_get_current());
1181       }
1182       else if (mutt_enter_fname (cp, buf, sizeof (buf), &menu->redraw, 1) == -1) {
1183         if (menu->menu == MENU_PAGER) {
1184           op = OP_DISPLAY_MESSAGE;
1185           continue;
1186         } else
1187           break;
1188       }
1189       if (!buf[0]) {
1190         CLEARLINE (LINES - 1);
1191         break;
1192       }
1193
1194 #ifdef USE_NNTP
1195       if (option (OPTNEWS)) {
1196         unset_option (OPTNEWS);
1197         nntp_expand_path (buf, sizeof (buf), &CurrentNewsSrv->conn->account);
1198       }
1199       else
1200 #endif
1201         mutt_expand_path (buf, sizeof (buf));
1202       if (mx_get_magic (buf) <= 0) {
1203         mutt_error (_("%s is not a mailbox."), buf);
1204         break;
1205       }
1206       m_strreplace(&CurrentFolder, buf);
1207
1208       if (Context) {
1209         int check;
1210
1211         if (Context->cinfo && Context->realpath)
1212           m_strreplace(&LastFolder, Context->realpath);
1213         else
1214           m_strreplace(&LastFolder, Context->path);
1215         oldcount = Context ? Context->msgcount : 0;
1216
1217         if ((check = mx_close_mailbox (Context, &index_hint)) != 0) {
1218           if (check == M_NEW_MAIL || check == M_REOPENED)
1219             update_index (menu, Context, check, oldcount, index_hint);
1220
1221           set_option (OPTSEARCHINVALID);
1222           menu->redraw = REDRAW_INDEX | REDRAW_STATUS;
1223           break;
1224         }
1225         p_delete(&Context);
1226       }
1227
1228       mutt_sleep (0);
1229
1230       /* Set CurrentMenu to MENU_MAIN before executing any folder
1231        * hooks so that all the index menu functions are available to
1232        * the exec command.
1233        */
1234
1235       CurrentMenu = MENU_MAIN;
1236       mutt_folder_hook (buf);
1237
1238       if ((Context = mx_open_mailbox (buf, flags, NULL)) != NULL) {
1239         menu->current = ci_first_message ();
1240       }
1241       else
1242         menu->current = 0;
1243       sidebar_set_current (buf);
1244
1245 #ifdef USE_NNTP
1246       /* buffy_check() must be done with mail-reader mode! */
1247       menu->help = mutt_compile_help (helpstr, sizeof (helpstr), MENU_MAIN,
1248                                       (Context
1249                                        && (Context->magic ==
1250                                            M_NNTP)) ? IndexNewsHelp :
1251                                       IndexHelp);
1252 #endif
1253       mutt_clear_error ();
1254       buffy_check (0);     /* force the buffy check after we have changed
1255                                    the folder */
1256       menu->redraw = REDRAW_FULL;
1257       set_option (OPTSEARCHINVALID);
1258       break;
1259
1260     case OP_DISPLAY_MESSAGE:
1261     case OP_DISPLAY_HEADERS:   /* don't weed the headers */
1262
1263       CHECK_MSGCOUNT;
1264       CHECK_VISIBLE;
1265       /*
1266        * toggle the weeding of headers so that a user can press the key
1267        * again while reading the message.
1268        */
1269       if (op == OP_DISPLAY_HEADERS)
1270         toggle_option (OPTWEED);
1271
1272       unset_option (OPTNEEDRESORT);
1273
1274       if ((Sort & SORT_MASK) == SORT_THREADS && CURHDR->collapsed) {
1275         mutt_uncollapse_thread (Context, CURHDR);
1276         mutt_set_virtual (Context);
1277         if (option (OPTUNCOLLAPSEJUMP))
1278           menu->current = mutt_thread_next_unread (Context, CURHDR);
1279       }
1280
1281       if (option (OPTPGPAUTODEC) &&
1282           (tag || !(CURHDR->security & PGP_TRADITIONAL_CHECKED)))
1283         mutt_check_traditional_pgp (tag ? NULL : CURHDR, &menu->redraw);
1284
1285       if ((op = mutt_display_message (CURHDR)) == -1) {
1286         unset_option (OPTNEEDRESORT);
1287         break;
1288       }
1289
1290       menu->menu = MENU_PAGER;
1291       menu->oldcurrent = menu->current;
1292       continue;
1293
1294     case OP_EXIT:
1295
1296       closed = op;
1297       if (menu->menu == MENU_MAIN && attach_msg) {
1298         done = 1;
1299         break;
1300       }
1301
1302       if ((menu->menu == MENU_MAIN)
1303           && (query_quadoption (OPT_QUIT,
1304                                 _("Exit Madmutt without saving?")) == M_YES))
1305       {
1306         if (Context) {
1307           mx_fastclose_mailbox (Context);
1308           p_delete(&Context);
1309         }
1310         done = 1;
1311       }
1312       break;
1313
1314     case OP_EDIT_TYPE:
1315
1316       CHECK_MSGCOUNT;
1317       CHECK_VISIBLE;
1318       CHECK_ATTACH;
1319       mutt_edit_content_type (CURHDR, CURHDR->content, NULL);
1320       /* if we were in the pager, redisplay the message */
1321       if (menu->menu == MENU_PAGER) {
1322         op = OP_DISPLAY_MESSAGE;
1323         continue;
1324       }
1325       else
1326         menu->redraw = REDRAW_CURRENT;
1327       break;
1328
1329     case OP_MAIN_BREAK_THREAD:
1330
1331       CHECK_MSGCOUNT;
1332       CHECK_VISIBLE;
1333       CHECK_READONLY;
1334
1335       if ((Sort & SORT_MASK) != SORT_THREADS)
1336         mutt_error (_("Threading is not enabled."));
1337
1338       else {
1339         {
1340           HEADER *oldcur = CURHDR;
1341
1342           mutt_break_thread (CURHDR);
1343           mutt_sort_headers (Context, 1);
1344           menu->current = oldcur->virtual;
1345         }
1346
1347         Context->changed = 1;
1348         mutt_message _("Thread broken");
1349
1350         if (menu->menu == MENU_PAGER) {
1351           op = OP_DISPLAY_MESSAGE;
1352           continue;
1353         }
1354         else
1355           menu->redraw |= REDRAW_INDEX;
1356       }
1357       break;
1358
1359     case OP_MAIN_LINK_THREADS:
1360
1361       CHECK_MSGCOUNT;
1362       CHECK_VISIBLE;
1363       CHECK_READONLY;
1364
1365       if ((Sort & SORT_MASK) != SORT_THREADS)
1366         mutt_error (_("Threading is not enabled."));
1367
1368       else if (!CURHDR->env->message_id)
1369         mutt_error (_("No Message-ID: header available to link thread"));
1370
1371       else if (!tag && (!Context->last_tag || !Context->last_tag->tagged))
1372         mutt_error (_("First, please tag a message to be linked here"));
1373
1374       else {
1375         HEADER *oldcur = CURHDR;
1376
1377         if (mutt_link_threads (CURHDR, tag ? NULL : Context->last_tag,
1378                                Context)) {
1379           mutt_sort_headers (Context, 1);
1380           menu->current = oldcur->virtual;
1381
1382           Context->changed = 1;
1383           mutt_message _("Threads linked");
1384         }
1385         else
1386           mutt_error (_("No thread linked"));
1387       }
1388
1389       if (menu->menu == MENU_PAGER) {
1390         op = OP_DISPLAY_MESSAGE;
1391         continue;
1392       }
1393       else
1394         menu->redraw |= REDRAW_STATUS | REDRAW_INDEX;
1395       break;
1396
1397     case OP_MAIN_NEXT_UNDELETED:
1398
1399       CHECK_MSGCOUNT;
1400       CHECK_VISIBLE;
1401       if (menu->current >= Context->vcount - 1) {
1402         if (menu->menu == MENU_MAIN)
1403           mutt_error (_("You are on the last message."));
1404
1405         break;
1406       }
1407       if ((menu->current = ci_next_undeleted (menu->current)) == -1) {
1408         menu->current = menu->oldcurrent;
1409         if (menu->menu == MENU_MAIN)
1410           mutt_error (_("No undeleted messages."));
1411       }
1412       else if (menu->menu == MENU_PAGER) {
1413         op = OP_DISPLAY_MESSAGE;
1414         continue;
1415       }
1416       else
1417         menu->redraw = REDRAW_MOTION;
1418       break;
1419
1420     case OP_NEXT_ENTRY:
1421
1422       CHECK_MSGCOUNT;
1423       CHECK_VISIBLE;
1424       if (menu->current >= Context->vcount - 1) {
1425         if (menu->menu == MENU_MAIN)
1426           mutt_error (_("You are on the last message."));
1427
1428         break;
1429       }
1430       menu->current++;
1431       if (menu->menu == MENU_PAGER) {
1432         op = OP_DISPLAY_MESSAGE;
1433         continue;
1434       }
1435       else
1436         menu->redraw = REDRAW_MOTION;
1437       break;
1438
1439     case OP_MAIN_PREV_UNDELETED:
1440
1441       CHECK_MSGCOUNT;
1442       CHECK_VISIBLE;
1443       if (menu->current < 1) {
1444         mutt_error (_("You are on the first message."));
1445
1446         break;
1447       }
1448       if ((menu->current = ci_previous_undeleted (menu->current)) == -1) {
1449         menu->current = menu->oldcurrent;
1450         if (menu->menu == MENU_MAIN)
1451           mutt_error (_("No undeleted messages."));
1452       }
1453       else if (menu->menu == MENU_PAGER) {
1454         op = OP_DISPLAY_MESSAGE;
1455         continue;
1456       }
1457       else
1458         menu->redraw = REDRAW_MOTION;
1459       break;
1460
1461     case OP_PREV_ENTRY:
1462
1463       CHECK_MSGCOUNT;
1464       CHECK_VISIBLE;
1465       if (menu->current < 1) {
1466         if (menu->menu == MENU_MAIN)
1467           mutt_error (_("You are on the first message."));
1468
1469         break;
1470       }
1471       menu->current--;
1472       if (menu->menu == MENU_PAGER) {
1473         op = OP_DISPLAY_MESSAGE;
1474         continue;
1475       }
1476       else
1477         menu->redraw = REDRAW_MOTION;
1478       break;
1479
1480     case OP_DECRYPT_COPY:
1481     case OP_DECRYPT_SAVE:
1482     case OP_COPY_MESSAGE:
1483     case OP_SAVE:
1484     case OP_DECODE_COPY:
1485     case OP_DECODE_SAVE:
1486       CHECK_MSGCOUNT;
1487       CHECK_VISIBLE;
1488       if (mutt_save_message (tag ? NULL : CURHDR,
1489                              (op == OP_DECRYPT_SAVE) ||
1490                              (op == OP_SAVE) || (op == OP_DECODE_SAVE),
1491                              (op == OP_DECODE_SAVE) || (op == OP_DECODE_COPY),
1492                              (op == OP_DECRYPT_SAVE)
1493                              || (op == OP_DECRYPT_COPY)
1494                              || 0, &menu->redraw) == 0 && (op == OP_SAVE
1495                                                            || op ==
1496                                                            OP_DECODE_SAVE
1497                                                            || op ==
1498                                                            OP_DECRYPT_SAVE)
1499         ) {
1500         if (tag)
1501           menu->redraw |= REDRAW_INDEX;
1502         else if (option (OPTRESOLVE)) {
1503           if ((menu->current = ci_next_undeleted (menu->current)) == -1) {
1504             menu->current = menu->oldcurrent;
1505             menu->redraw |= REDRAW_CURRENT;
1506           }
1507           else
1508             menu->redraw |= REDRAW_MOTION_RESYNCH;
1509         }
1510         else
1511           menu->redraw |= REDRAW_CURRENT;
1512       }
1513       break;
1514
1515     case OP_MAIN_NEXT_NEW:
1516     case OP_MAIN_NEXT_UNREAD:
1517     case OP_MAIN_PREV_NEW:
1518     case OP_MAIN_PREV_UNREAD:
1519     case OP_MAIN_NEXT_NEW_THEN_UNREAD:
1520     case OP_MAIN_PREV_NEW_THEN_UNREAD:
1521
1522       {
1523         int first_unread = -1;
1524         int first_new = -1;
1525
1526         CHECK_MSGCOUNT;
1527         CHECK_VISIBLE;
1528
1529         i = menu->current;
1530         menu->current = -1;
1531         for (j = 0; j != Context->vcount; j++) {
1532 #define CURHDRi Context->hdrs[Context->v2r[i]]
1533           if (op == OP_MAIN_NEXT_NEW || op == OP_MAIN_NEXT_UNREAD
1534               || op == OP_MAIN_NEXT_NEW_THEN_UNREAD) {
1535             i++;
1536             if (i > Context->vcount - 1) {
1537               mutt_message _("Search wrapped to top.");
1538
1539               i = 0;
1540             }
1541           }
1542           else {
1543             i--;
1544             if (i < 0) {
1545               mutt_message _("Search wrapped to bottom.");
1546
1547               i = Context->vcount - 1;
1548             }
1549           }
1550
1551           if (CURHDRi->collapsed && (Sort & SORT_MASK) == SORT_THREADS) {
1552             if (UNREAD (CURHDRi) && first_unread == -1)
1553               first_unread = i;
1554             if (UNREAD (CURHDRi) == 1 && first_new == -1)
1555               first_new = i;
1556           }
1557           else if ((!CURHDRi->deleted && !CURHDRi->read)) {
1558             if (first_unread == -1)
1559               first_unread = i;
1560             if ((!CURHDRi->old) && first_new == -1)
1561               first_new = i;
1562           }
1563
1564           if ((op == OP_MAIN_NEXT_UNREAD || op == OP_MAIN_PREV_UNREAD) &&
1565               first_unread != -1)
1566             break;
1567           if ((op == OP_MAIN_NEXT_NEW || op == OP_MAIN_PREV_NEW ||
1568                op == OP_MAIN_NEXT_NEW_THEN_UNREAD
1569                || op == OP_MAIN_PREV_NEW_THEN_UNREAD)
1570               && first_new != -1)
1571             break;
1572         }
1573 #undef CURHDRi
1574         if ((op == OP_MAIN_NEXT_NEW || op == OP_MAIN_PREV_NEW ||
1575              op == OP_MAIN_NEXT_NEW_THEN_UNREAD
1576              || op == OP_MAIN_PREV_NEW_THEN_UNREAD)
1577             && first_new != -1)
1578           menu->current = first_new;
1579         else if ((op == OP_MAIN_NEXT_UNREAD || op == OP_MAIN_PREV_UNREAD ||
1580                   op == OP_MAIN_NEXT_NEW_THEN_UNREAD
1581                   || op == OP_MAIN_PREV_NEW_THEN_UNREAD)
1582                  && first_unread != -1)
1583           menu->current = first_unread;
1584
1585         if (menu->current == -1) {
1586           menu->current = menu->oldcurrent;
1587           mutt_error ("%s%s.",
1588                       (op == OP_MAIN_NEXT_NEW
1589                        || op ==
1590                        OP_MAIN_PREV_NEW) ? _("No new messages") :
1591                       _("No unread messages"),
1592                       Context->pattern ? _(" in this limited view") : "");
1593         }
1594         else if (menu->menu == MENU_PAGER) {
1595           op = OP_DISPLAY_MESSAGE;
1596           continue;
1597         }
1598         else
1599           menu->redraw = REDRAW_MOTION;
1600         break;
1601       }
1602     case OP_FLAG_MESSAGE:
1603
1604       CHECK_MSGCOUNT;
1605       CHECK_VISIBLE;
1606       CHECK_READONLY;
1607
1608       CHECK_MX_ACL (Context, ACL_WRITE, _("Flagging"));
1609
1610       if (tag) {
1611         for (j = 0; j < Context->vcount; j++) {
1612           if (Context->hdrs[Context->v2r[j]]->tagged)
1613             mutt_set_flag (Context, Context->hdrs[Context->v2r[j]],
1614                            M_FLAG, !Context->hdrs[Context->v2r[j]]->flagged);
1615         }
1616
1617         menu->redraw |= REDRAW_INDEX;
1618       }
1619       else {
1620         mutt_set_flag (Context, CURHDR, M_FLAG, !CURHDR->flagged);
1621         if (option (OPTRESOLVE)) {
1622           if ((menu->current = ci_next_undeleted (menu->current)) == -1) {
1623             menu->current = menu->oldcurrent;
1624             menu->redraw = REDRAW_CURRENT;
1625           }
1626           else
1627             menu->redraw = REDRAW_MOTION_RESYNCH;
1628         }
1629         else
1630           menu->redraw = REDRAW_CURRENT;
1631       }
1632       menu->redraw |= REDRAW_STATUS;
1633       break;
1634
1635     case OP_TOGGLE_NEW:
1636
1637       CHECK_MSGCOUNT;
1638       CHECK_VISIBLE;
1639       CHECK_READONLY;
1640
1641       CHECK_MX_ACL (Context, ACL_SEEN, _("Toggling"));
1642
1643       if (tag) {
1644         for (j = 0; j < Context->vcount; j++) {
1645           if (Context->hdrs[Context->v2r[j]]->tagged) {
1646             if (Context->hdrs[Context->v2r[j]]->read ||
1647                 Context->hdrs[Context->v2r[j]]->old)
1648               mutt_set_flag (Context, Context->hdrs[Context->v2r[j]], M_NEW,
1649                              1);
1650             else
1651               mutt_set_flag (Context, Context->hdrs[Context->v2r[j]], M_READ,
1652                              1);
1653           }
1654         }
1655         menu->redraw = REDRAW_STATUS | REDRAW_INDEX;
1656       }
1657       else {
1658         if (CURHDR->read || CURHDR->old)
1659           mutt_set_flag (Context, CURHDR, M_NEW, 1);
1660         else
1661           mutt_set_flag (Context, CURHDR, M_READ, 1);
1662
1663         if (option (OPTRESOLVE)) {
1664           if ((menu->current = ci_next_undeleted (menu->current)) == -1) {
1665             menu->current = menu->oldcurrent;
1666             menu->redraw = REDRAW_CURRENT;
1667           }
1668           else
1669             menu->redraw = REDRAW_MOTION_RESYNCH;
1670         }
1671         else
1672           menu->redraw = REDRAW_CURRENT;
1673         menu->redraw |= REDRAW_STATUS;
1674       }
1675       break;
1676
1677     case OP_TOGGLE_WRITE:
1678
1679       CHECK_IN_MAILBOX;
1680       if (mx_toggle_write (Context) == 0)
1681         menu->redraw |= REDRAW_STATUS;
1682       break;
1683
1684     case OP_MAIN_NEXT_THREAD:
1685     case OP_MAIN_NEXT_SUBTHREAD:
1686     case OP_MAIN_PREV_THREAD:
1687     case OP_MAIN_PREV_SUBTHREAD:
1688
1689       CHECK_MSGCOUNT;
1690       CHECK_VISIBLE;
1691       switch (op) {
1692       case OP_MAIN_NEXT_THREAD:
1693         menu->current = mutt_next_thread (CURHDR);
1694         break;
1695
1696       case OP_MAIN_NEXT_SUBTHREAD:
1697         menu->current = mutt_next_subthread (CURHDR);
1698         break;
1699
1700       case OP_MAIN_PREV_THREAD:
1701         menu->current = mutt_previous_thread (CURHDR);
1702         break;
1703
1704       case OP_MAIN_PREV_SUBTHREAD:
1705         menu->current = mutt_previous_subthread (CURHDR);
1706         break;
1707       }
1708
1709       if (menu->current < 0) {
1710         menu->current = menu->oldcurrent;
1711         if (op == OP_MAIN_NEXT_THREAD || op == OP_MAIN_NEXT_SUBTHREAD)
1712           mutt_error (_("No more threads."));
1713
1714         else
1715           mutt_error (_("You are on the first thread."));
1716       }
1717       else if (menu->menu == MENU_PAGER) {
1718         op = OP_DISPLAY_MESSAGE;
1719         continue;
1720       }
1721       else
1722         menu->redraw = REDRAW_MOTION;
1723       break;
1724
1725     case OP_MAIN_PARENT_MESSAGE:
1726
1727       CHECK_MSGCOUNT;
1728       CHECK_VISIBLE;
1729
1730       if ((menu->current = mutt_parent_message (Context, CURHDR)) < 0) {
1731         menu->current = menu->oldcurrent;
1732       }
1733       else if (menu->menu == MENU_PAGER) {
1734         op = OP_DISPLAY_MESSAGE;
1735         continue;
1736       }
1737       else
1738         menu->redraw = REDRAW_MOTION;
1739       break;
1740
1741     case OP_MAIN_SET_FLAG:
1742     case OP_MAIN_CLEAR_FLAG:
1743
1744       CHECK_MSGCOUNT;
1745       CHECK_VISIBLE;
1746       CHECK_READONLY;
1747
1748       if (mutt_change_flag (tag ? NULL : CURHDR, (op == OP_MAIN_SET_FLAG)) ==
1749           0) {
1750         menu->redraw = REDRAW_STATUS;
1751         if (tag)
1752           menu->redraw |= REDRAW_INDEX;
1753         else if (option (OPTRESOLVE)) {
1754           if ((menu->current = ci_next_undeleted (menu->current)) == -1) {
1755             menu->current = menu->oldcurrent;
1756             menu->redraw |= REDRAW_CURRENT;
1757           }
1758           else
1759             menu->redraw |= REDRAW_MOTION_RESYNCH;
1760         }
1761         else
1762           menu->redraw |= REDRAW_CURRENT;
1763       }
1764       break;
1765
1766     case OP_MAIN_COLLAPSE_THREAD:
1767       CHECK_MSGCOUNT;
1768       CHECK_VISIBLE;
1769
1770       if ((Sort & SORT_MASK) != SORT_THREADS) {
1771         mutt_error (_("Threading is not enabled."));
1772
1773         break;
1774       }
1775
1776       if (CURHDR->collapsed) {
1777         menu->current = mutt_uncollapse_thread (Context, CURHDR);
1778         mutt_set_virtual (Context);
1779         if (option (OPTUNCOLLAPSEJUMP))
1780           menu->current = mutt_thread_next_unread (Context, CURHDR);
1781       }
1782       else if (option (OPTCOLLAPSEUNREAD) || !UNREAD (CURHDR)) {
1783         menu->current = mutt_collapse_thread (Context, CURHDR);
1784         mutt_set_virtual (Context);
1785       }
1786       else {
1787         mutt_error (_("Thread contains unread messages."));
1788
1789         break;
1790       }
1791
1792       menu->redraw = REDRAW_INDEX | REDRAW_STATUS;
1793
1794       break;
1795
1796     case OP_MAIN_COLLAPSE_ALL:
1797       CHECK_MSGCOUNT;
1798       CHECK_VISIBLE;
1799
1800       if ((Sort & SORT_MASK) != SORT_THREADS) {
1801         mutt_error (_("Threading is not enabled."));
1802
1803         break;
1804       }
1805
1806       {
1807         HEADER *h, *base;
1808         THREAD *thread, *top;
1809         int final;
1810
1811         if (CURHDR->collapsed)
1812           final = mutt_uncollapse_thread (Context, CURHDR);
1813         else if (option (OPTCOLLAPSEUNREAD) || !UNREAD (CURHDR))
1814           final = mutt_collapse_thread (Context, CURHDR);
1815         else
1816           final = CURHDR->virtual;
1817
1818         base = Context->hdrs[Context->v2r[final]];
1819
1820         top = Context->tree;
1821         Context->collapsed = !Context->collapsed;
1822         while ((thread = top) != NULL) {
1823           while (!thread->message)
1824             thread = thread->child;
1825           h = thread->message;
1826
1827           if (h->collapsed != Context->collapsed) {
1828             if (h->collapsed)
1829               mutt_uncollapse_thread (Context, h);
1830             else if (option (OPTCOLLAPSEUNREAD) || !UNREAD (h))
1831               mutt_collapse_thread (Context, h);
1832           }
1833           top = top->next;
1834         }
1835
1836         mutt_set_virtual (Context);
1837         for (j = 0; j < Context->vcount; j++) {
1838           if (Context->hdrs[Context->v2r[j]]->index == base->index) {
1839             menu->current = j;
1840             break;
1841           }
1842         }
1843
1844         menu->redraw = REDRAW_INDEX | REDRAW_STATUS;
1845       }
1846       break;
1847
1848       /* --------------------------------------------------------------------
1849        * These functions are invoked directly from the internal-pager
1850        */
1851
1852     case OP_BOUNCE_MESSAGE:
1853
1854       CHECK_ATTACH;
1855       CHECK_MSGCOUNT;
1856       CHECK_VISIBLE;
1857       ci_bounce_message (tag ? NULL : CURHDR, &menu->redraw);
1858       break;
1859
1860     case OP_CREATE_ALIAS:
1861
1862       mutt_create_alias (Context
1863                          && Context->vcount ? CURHDR->env : NULL, NULL);
1864       MAYBE_REDRAW (menu->redraw);
1865       menu->redraw |= REDRAW_CURRENT;
1866       break;
1867
1868     case OP_QUERY:
1869       CHECK_ATTACH;
1870       mutt_query_menu (NULL, 0);
1871       MAYBE_REDRAW (menu->redraw);
1872       break;
1873
1874     case OP_PURGE_MESSAGE:
1875     case OP_DELETE:
1876
1877       CHECK_MSGCOUNT;
1878       CHECK_VISIBLE;
1879       CHECK_READONLY;
1880
1881       CHECK_MX_ACL (Context, ACL_DELETE, _("Deletion"));
1882
1883       if (tag) {
1884         mutt_tag_set_flag (M_DELETE, 1);
1885         mutt_tag_set_flag (M_PURGED, (op != OP_PURGE_MESSAGE) ? 0 : 1);
1886         if (option (OPTDELETEUNTAG))
1887           mutt_tag_set_flag (M_TAG, 0);
1888         menu->redraw = REDRAW_INDEX;
1889       }
1890       else {
1891         mutt_set_flag (Context, CURHDR, M_DELETE, 1);
1892         mutt_set_flag (Context, CURHDR, M_PURGED,
1893                        (op != OP_PURGE_MESSAGE) ? 0 : 1);
1894         if (option (OPTDELETEUNTAG))
1895           mutt_set_flag (Context, CURHDR, M_TAG, 0);
1896         if (option (OPTRESOLVE)) {
1897           if ((menu->current = ci_next_undeleted (menu->current)) == -1) {
1898             menu->current = menu->oldcurrent;
1899             menu->redraw = REDRAW_CURRENT;
1900           }
1901           else if (menu->menu == MENU_PAGER) {
1902             op = OP_DISPLAY_MESSAGE;
1903             continue;
1904           }
1905           else
1906             menu->redraw |= REDRAW_MOTION_RESYNCH;
1907         }
1908         else
1909           menu->redraw = REDRAW_CURRENT;
1910       }
1911       menu->redraw |= REDRAW_STATUS;
1912       break;
1913
1914     case OP_DELETE_THREAD:
1915     case OP_DELETE_SUBTHREAD:
1916
1917       CHECK_MSGCOUNT;
1918       CHECK_VISIBLE;
1919       CHECK_READONLY;
1920
1921       CHECK_MX_ACL (Context, ACL_DELETE, _("Deletion"));
1922
1923       rc = mutt_thread_set_flag (CURHDR, M_DELETE, 1,
1924                                  op == OP_DELETE_THREAD ? 0 : 1);
1925
1926       if (rc != -1) {
1927         if (option (OPTDELETEUNTAG))
1928           mutt_thread_set_flag (CURHDR, M_TAG, 0,
1929                                 op == OP_DELETE_THREAD ? 0 : 1);
1930         if (option (OPTRESOLVE))
1931           if ((menu->current = ci_next_undeleted (menu->current)) == -1)
1932             menu->current = menu->oldcurrent;
1933         menu->redraw = REDRAW_INDEX | REDRAW_STATUS;
1934       }
1935       break;
1936
1937 #ifdef USE_NNTP
1938     case OP_CATCHUP:
1939       if (Context && Context->magic == M_NNTP) {
1940         if (mutt_newsgroup_catchup (CurrentNewsSrv,
1941                                     ((NNTP_DATA *) Context->data)->group))
1942           menu->redraw = REDRAW_INDEX | REDRAW_STATUS;
1943       }
1944       break;
1945 #endif
1946
1947     case OP_DISPLAY_ADDRESS:
1948
1949       CHECK_MSGCOUNT;
1950       CHECK_VISIBLE;
1951       mutt_display_address (CURHDR->env);
1952       break;
1953
1954     case OP_ENTER_COMMAND:
1955
1956       CurrentMenu = MENU_MAIN;
1957       mutt_enter_command ();
1958       mutt_check_rescore (Context);
1959       if (option (OPTFORCEREDRAWINDEX))
1960         menu->redraw = REDRAW_FULL;
1961       unset_option (OPTFORCEREDRAWINDEX);
1962       unset_option (OPTFORCEREDRAWPAGER);
1963       break;
1964
1965     case OP_EDIT_MESSAGE:
1966
1967       CHECK_MSGCOUNT;
1968       CHECK_VISIBLE;
1969       CHECK_READONLY;
1970       CHECK_ATTACH;
1971
1972       CHECK_MX_ACL (Context, ACL_INSERT, _("Editing"));
1973
1974       if (option (OPTPGPAUTODEC)
1975           && (tag || !(CURHDR->security & PGP_TRADITIONAL_CHECKED)))
1976         mutt_check_traditional_pgp (tag ? NULL : CURHDR, &menu->redraw);
1977       mutt_edit_message (Context, tag ? NULL : CURHDR);
1978       menu->redraw = REDRAW_FULL;
1979
1980       break;
1981
1982     case OP_FORWARD_MESSAGE:
1983
1984       CHECK_MSGCOUNT;
1985       CHECK_VISIBLE;
1986       CHECK_ATTACH;
1987
1988       if (option (OPTPGPAUTODEC) &&
1989           (tag || !(CURHDR->security & PGP_TRADITIONAL_CHECKED)))
1990         mutt_check_traditional_pgp (tag ? NULL : CURHDR, &menu->redraw);
1991       ci_send_message (SENDFORWARD, NULL, NULL, Context, tag ? NULL : CURHDR);
1992       menu->redraw = REDRAW_FULL;
1993       break;
1994
1995
1996     case OP_FORGET_PASSPHRASE:
1997       crypt_forget_passphrase ();
1998       break;
1999
2000     case OP_GROUP_REPLY:
2001
2002       CHECK_MSGCOUNT;
2003       CHECK_VISIBLE;
2004       CHECK_ATTACH;
2005
2006       if (option (OPTPGPAUTODEC) &&
2007           (tag || !(CURHDR->security & PGP_TRADITIONAL_CHECKED)))
2008         mutt_check_traditional_pgp (tag ? NULL : CURHDR, &menu->redraw);
2009
2010       ci_send_message (SENDREPLY | SENDGROUPREPLY, NULL, NULL, Context,
2011                        tag ? NULL : CURHDR);
2012       menu->redraw = REDRAW_FULL;
2013       break;
2014
2015     case OP_LIST_REPLY:
2016
2017       CHECK_ATTACH;
2018       CHECK_MSGCOUNT;
2019       CHECK_VISIBLE;
2020
2021       if (option (OPTPGPAUTODEC) &&
2022           (tag || !(CURHDR->security & PGP_TRADITIONAL_CHECKED)))
2023         mutt_check_traditional_pgp (tag ? NULL : CURHDR, &menu->redraw);
2024
2025       ci_send_message (SENDREPLY | SENDLISTREPLY, NULL, NULL, Context,
2026                        tag ? NULL : CURHDR);
2027       menu->redraw = REDRAW_FULL;
2028       break;
2029
2030     case OP_MAIL:
2031
2032       CHECK_ATTACH;
2033       ci_send_message (0, NULL, NULL, Context, NULL);
2034       menu->redraw = REDRAW_FULL;
2035       break;
2036
2037     case OP_MAIL_KEY:
2038       CHECK_ATTACH;
2039       ci_send_message (SENDKEY, NULL, NULL, NULL, NULL);
2040       menu->redraw = REDRAW_FULL;
2041       break;
2042
2043
2044     case OP_EXTRACT_KEYS:
2045       CHECK_MSGCOUNT;
2046       CHECK_VISIBLE;
2047       crypt_extract_keys_from_messages (tag ? NULL : CURHDR);
2048       menu->redraw = REDRAW_FULL;
2049       break;
2050
2051
2052     case OP_CHECK_TRADITIONAL:
2053       CHECK_MSGCOUNT;
2054       CHECK_VISIBLE;
2055       if (tag || !(CURHDR->security & PGP_TRADITIONAL_CHECKED))
2056         mutt_check_traditional_pgp (tag ? NULL : CURHDR, &menu->redraw);
2057
2058       if (menu->menu == MENU_PAGER) {
2059         op = OP_DISPLAY_MESSAGE;
2060         continue;
2061       }
2062       break;
2063
2064     case OP_PIPE:
2065
2066       CHECK_MSGCOUNT;
2067       CHECK_VISIBLE;
2068       mutt_pipe_message (tag ? NULL : CURHDR);
2069       /* in an IMAP folder index with imap_peek=no, piping could change
2070        * * new or old messages status to read. Redraw what's needed.
2071        */
2072       if (Context->magic == M_IMAP && !option (OPTIMAPPEEK)) {
2073         menu->redraw = (tag ? REDRAW_INDEX : REDRAW_CURRENT) | REDRAW_STATUS;
2074       }
2075       MAYBE_REDRAW (menu->redraw);
2076       break;
2077
2078     case OP_PRINT:
2079
2080       CHECK_MSGCOUNT;
2081       CHECK_VISIBLE;
2082       mutt_print_message (tag ? NULL : CURHDR);
2083       /* in an IMAP folder index with imap_peek=no, piping could change
2084        * * new or old messages status to read. Redraw what's needed.
2085        */
2086       if (Context->magic == M_IMAP && !option (OPTIMAPPEEK)) {
2087         menu->redraw = (tag ? REDRAW_INDEX : REDRAW_CURRENT) | REDRAW_STATUS;
2088       }
2089       break;
2090
2091     case OP_MAIN_READ_THREAD:
2092     case OP_MAIN_READ_SUBTHREAD:
2093
2094       CHECK_MSGCOUNT;
2095       CHECK_VISIBLE;
2096       CHECK_READONLY;
2097
2098       CHECK_MX_ACL (Context, ACL_SEEN, _("Marking as read"));
2099
2100       rc = mutt_thread_set_flag (CURHDR, M_READ, 1,
2101                                  op == OP_MAIN_READ_THREAD ? 0 : 1);
2102
2103       if (rc != -1) {
2104         if (option (OPTRESOLVE)) {
2105           if ((menu->current = (op == OP_MAIN_READ_THREAD ?
2106                                 mutt_next_thread (CURHDR) :
2107                                 mutt_next_subthread (CURHDR))) == -1)
2108             menu->current = menu->oldcurrent;
2109         }
2110         menu->redraw = REDRAW_INDEX | REDRAW_STATUS;
2111       }
2112       break;
2113
2114     case OP_RECALL_MESSAGE:
2115
2116       CHECK_ATTACH;
2117       ci_send_message (SENDPOSTPONED, NULL, NULL, Context, NULL);
2118       menu->redraw = REDRAW_FULL;
2119       break;
2120
2121     case OP_RESEND:
2122
2123       CHECK_ATTACH;
2124       CHECK_MSGCOUNT;
2125       CHECK_VISIBLE;
2126
2127       if (tag) {
2128         for (j = 0; j < Context->vcount; j++) {
2129           if (Context->hdrs[Context->v2r[j]]->tagged)
2130             mutt_resend_message (NULL, Context,
2131                                  Context->hdrs[Context->v2r[j]]);
2132         }
2133       }
2134       else
2135         mutt_resend_message (NULL, Context, CURHDR);
2136
2137       menu->redraw = REDRAW_FULL;
2138       break;
2139
2140 #ifdef USE_NNTP
2141     case OP_POST:
2142     case OP_FOLLOWUP:
2143     case OP_FORWARD_TO_GROUP:
2144
2145       CHECK_ATTACH;
2146       if ((op == OP_FOLLOWUP || op == OP_FORWARD_TO_GROUP) &&
2147           Context && Context->msgcount == 0) {
2148         mutt_error (_("There are no messages."));
2149         sleep (2);
2150       }
2151       else if (op != OP_FOLLOWUP || !CURHDR->env->followup_to ||
2152                m_strcasecmp(CURHDR->env->followup_to, "poster") ||
2153                query_quadoption (OPT_FOLLOWUPTOPOSTER,
2154                                  _("Reply by mail as poster prefers?")) !=
2155                M_YES) {
2156         if (Context && Context->magic == M_NNTP
2157             && !((NNTP_DATA *) Context->data)->allowed
2158             && query_quadoption (OPT_TOMODERATED,
2159                                  _
2160                                  ("Posting to this group not allowed, may be moderated. Continue?"))
2161             != M_YES)
2162           break;
2163         if (op == OP_POST)
2164           ci_send_message (SENDNEWS, NULL, NULL, Context, NULL);
2165         else {
2166           CHECK_MSGCOUNT;
2167           if (op == OP_FOLLOWUP)
2168             ci_send_message (SENDNEWS | SENDREPLY, NULL, NULL, Context,
2169                              tag ? NULL : CURHDR);
2170           else
2171             ci_send_message (SENDNEWS | SENDFORWARD, NULL, NULL, Context,
2172                              tag ? NULL : CURHDR);
2173         }
2174         menu->redraw = REDRAW_FULL;
2175         break;
2176       }
2177 #endif
2178
2179     case OP_REPLY:
2180
2181       CHECK_ATTACH;
2182       CHECK_MSGCOUNT;
2183       CHECK_VISIBLE;
2184
2185       if (option (OPTPGPAUTODEC) &&
2186           (tag || !(CURHDR->security & PGP_TRADITIONAL_CHECKED)))
2187         mutt_check_traditional_pgp (tag ? NULL : CURHDR, &menu->redraw);
2188
2189       ci_send_message (SENDREPLY, NULL, NULL, Context, tag ? NULL : CURHDR);
2190       menu->redraw = REDRAW_FULL;
2191       break;
2192
2193     case OP_SHELL_ESCAPE:
2194
2195       mutt_shell_escape ();
2196       MAYBE_REDRAW (menu->redraw);
2197       break;
2198
2199     case OP_TAG_THREAD:
2200     case OP_TAG_SUBTHREAD:
2201
2202       CHECK_MSGCOUNT;
2203       CHECK_VISIBLE;
2204       rc = mutt_thread_set_flag (CURHDR, M_TAG, !CURHDR->tagged,
2205                                  op == OP_TAG_THREAD ? 0 : 1);
2206
2207       if (rc != -1) {
2208         if (option (OPTRESOLVE)) {
2209           menu->current = mutt_next_thread (CURHDR);
2210
2211           if (menu->current == -1)
2212             menu->current = menu->oldcurrent;
2213         }
2214         menu->redraw = REDRAW_INDEX | REDRAW_STATUS;
2215       }
2216       break;
2217
2218     case OP_UNDELETE:
2219
2220       CHECK_MSGCOUNT;
2221       CHECK_VISIBLE;
2222       CHECK_READONLY;
2223
2224       CHECK_MX_ACL (Context, ACL_DELETE, _("Undeletion"));
2225
2226       if (tag) {
2227         mutt_tag_set_flag (M_DELETE, 0);
2228         mutt_tag_set_flag (M_PURGED, 0);
2229         menu->redraw = REDRAW_INDEX;
2230       }
2231       else {
2232         mutt_set_flag (Context, CURHDR, M_DELETE, 0);
2233         mutt_set_flag (Context, CURHDR, M_PURGED, 0);
2234         if (option (OPTRESOLVE) && menu->current < Context->vcount - 1) {
2235           menu->current++;
2236           menu->redraw = REDRAW_MOTION_RESYNCH;
2237         }
2238         else
2239           menu->redraw = REDRAW_CURRENT;
2240       }
2241       menu->redraw |= REDRAW_STATUS;
2242       break;
2243
2244     case OP_UNDELETE_THREAD:
2245     case OP_UNDELETE_SUBTHREAD:
2246
2247       CHECK_MSGCOUNT;
2248       CHECK_VISIBLE;
2249       CHECK_READONLY;
2250
2251       CHECK_MX_ACL (Context, ACL_DELETE, _("Undeletion"));
2252
2253       rc = mutt_thread_set_flag (CURHDR, M_DELETE, 0,
2254                                  op == OP_UNDELETE_THREAD ? 0 : 1)
2255         + mutt_thread_set_flag (CURHDR, M_PURGED, 0,
2256                                 op == OP_UNDELETE_THREAD ? 0 : 1);
2257
2258       if (rc > -1) {
2259         if (option (OPTRESOLVE)) {
2260           if (op == OP_UNDELETE_THREAD)
2261             menu->current = mutt_next_thread (CURHDR);
2262           else
2263             menu->current = mutt_next_subthread (CURHDR);
2264
2265           if (menu->current == -1)
2266             menu->current = menu->oldcurrent;
2267         }
2268         menu->redraw = REDRAW_INDEX | REDRAW_STATUS;
2269       }
2270       break;
2271
2272     case OP_VERSION:
2273       mutt_version ();
2274       break;
2275
2276     case OP_BUFFY_LIST:
2277       if (option (OPTFORCEBUFFYCHECK))
2278         buffy_check (1);
2279       buffy_list ();
2280       menu->redraw = REDRAW_FULL;
2281       break;
2282
2283     case OP_VIEW_ATTACHMENTS:
2284       CHECK_MSGCOUNT;
2285       CHECK_VISIBLE;
2286       mutt_view_attachments (CURHDR);
2287       if (CURHDR->attach_del)
2288         Context->changed = 1;
2289       menu->redraw = REDRAW_FULL;
2290       break;
2291
2292     case OP_END_COND:
2293       break;
2294
2295     case OP_WHAT_KEY:
2296       mutt_what_key ();
2297       break;
2298
2299     case OP_REBUILD_CACHE:
2300       mx_rebuild_cache ();
2301       break;
2302
2303     case OP_SIDEBAR_SCROLL_UP:
2304     case OP_SIDEBAR_SCROLL_DOWN:
2305     case OP_SIDEBAR_NEXT:
2306     case OP_SIDEBAR_PREV:
2307     case OP_SIDEBAR_NEXT_NEW:
2308     case OP_SIDEBAR_PREV_NEW:
2309       sidebar_scroll (op);
2310       break;
2311     default:
2312       if (menu->menu == MENU_MAIN)
2313         km_error_key (MENU_MAIN);
2314     }
2315
2316     if (menu->menu == MENU_PAGER) {
2317       menu->menu = MENU_MAIN;
2318       menu->redraw = REDRAW_FULL;
2319     }
2320
2321     if (done)
2322       break;
2323   }
2324
2325   if (!attach_msg) {
2326   /* Close all open IMAP connections */
2327     imap_logout_all ();
2328 #ifdef USE_NNTP
2329   /* Close all open NNTP connections */
2330     nntp_logout_all ();
2331 #endif
2332 #ifdef USE_SASL
2333     mutt_sasl_done ();
2334 #endif
2335   }
2336
2337   mutt_menuDestroy (&menu);
2338   return (closed);
2339 }
2340
2341 void mutt_set_header_color (CONTEXT * ctx, HEADER * curhdr)
2342 {
2343   COLOR_LINE *color;
2344
2345   if (!curhdr)
2346     return;
2347
2348   for (color = ColorIndexList; color; color = color->next)
2349     if (mutt_pattern_exec
2350         (color->color_pattern, M_MATCH_FULL_ADDRESS, ctx, curhdr)) {
2351       curhdr->pair = color->pair;
2352       return;
2353     }
2354   curhdr->pair = ColorDefs[MT_COLOR_NORMAL];
2355 }