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