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