?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* Corrections to pico manual contributed by Dennis Davis.
[alpine.git] / alpine / mailindx.c
blobb89ff299bf9549cc844c9a492ca59382fdc9a6c7
1 #if !defined(lint) && !defined(DOS)
2 static char rcsid[] = "$Id: mailindx.c 1142 2008-08-13 17:22:21Z hubert@u.washington.edu $";
3 #endif
4
5 /*
6 * ========================================================================
7 * Copyright 2013-2016 Eduardo Chappa
8 * Copyright 2006-2008 University of Washington
9 *
10 * Licensed under the Apache License, Version 2.0 (the "License");
11 * you may not use this file except in compliance with the License.
12 * You may obtain a copy of the License at
13 *
14 * http://www.apache.org/licenses/LICENSE-2.0
15 *
16 * ========================================================================
17 */
18
19 #include "headers.h"
20 #include "mailindx.h"
21 #include "mailcmd.h"
22 #include "status.h"
23 #include "context.h"
24 #include "keymenu.h"
25 #include "alpine.h"
26 #include "help.h"
27 #include "radio.h"
28 #include "titlebar.h"
29 #include "../pith/flag.h"
30 #include "../pith/newmail.h"
31 #include "../pith/thread.h"
32 #include "../pith/conf.h"
33 #include "../pith/msgno.h"
34 #include "../pith/icache.h"
35 #include "../pith/state.h"
36 #include "../pith/bitmap.h"
37 #include "../pith/news.h"
38 #include "../pith/strlst.h"
39 #include "../pith/sequence.h"
40 #include "../pith/sort.h"
41 #include "../pith/hist.h"
42 #include "../pith/busy.h"
43 #include "../pith/signal.h"
44
45
46 struct save_thrdinfo {
47 ICE_S *(*format_index_line)(INDEXDATA_S *);
48 void (*setup_header_widths)(MAILSTREAM *);
49 unsigned viewing_a_thread:1;
50 };
51
52
53 static OtherMenu what_keymenu = FirstMenu;
54
55 struct index_state *current_index_state = NULL;
56
57
58 /*
59 * Internal prototypes
60 */
61 void index_index_screen(struct pine *);
62 void thread_index_screen(struct pine *);
63 int update_index(struct pine *, struct index_state *);
64 int index_scroll_up(long);
65 int index_scroll_down(long);
66 int index_scroll_to_pos(long);
67 long top_ent_calc(MAILSTREAM *, MSGNO_S *, long, long);
68 void reset_index_border(void);
69 void redraw_index_body(void);
70 int paint_index_line(ICE_S *, int, long, IndexColType, IndexColType, IndexColType,
71 struct entry_state *, int, int);
72 void pine_imap_envelope(MAILSTREAM *, unsigned long, ENVELOPE *);
73 void index_search(struct pine *, MAILSTREAM *, int, MSGNO_S *);
74 #ifdef _WINDOWS
75 int index_scroll_callback(int,long);
76 int index_gettext_callback(char *, size_t, void **, long *, int *);
77 void index_popup(IndexType style, MAILSTREAM *, MSGNO_S *, int);
78 char *pcpine_help_index(char *);
79 char *pcpine_help_index_simple(char *);
80 #endif
81
82
83
84 /*----------------------------------------------------------------------
85
86
87 ----*/
88 struct key_menu *
89 do_index_border(CONTEXT_S *cntxt, char *folder, MAILSTREAM *stream, MSGNO_S *msgmap,
90 IndexType style, int *which_keys, int flags)
91 {
92 struct key_menu *km = (style == ThreadIndex)
93 ? &thread_keymenu
94 : (ps_global->mail_stream != stream)
95 ? &simple_index_keymenu
96 : &index_keymenu;
97
98 if(flags & INDX_CLEAR)
99 ClearScreen();
100
101 if(flags & INDX_HEADER)
102 set_titlebar((style == ThreadIndex)
103 /* TRANSLATORS: these are some screen titles */
104 ? _("THREAD INDEX")
105 : (stream == ps_global->mail_stream)
106 ? (style == MsgIndex || style == MultiMsgIndex)
107 ? _("MESSAGE INDEX")
108 : _("ZOOMED MESSAGE INDEX")
109 : (!strcmp(folder, INTERRUPTED_MAIL))
110 ? _("COMPOSE: SELECT INTERRUPTED")
111 : (ps_global->VAR_FORM_FOLDER
112 && !strcmp(ps_global->VAR_FORM_FOLDER, folder))
113 ? _("COMPOSE: SELECT FORM LETTER")
114 : _("COMPOSE: SELECT POSTPONED"),
115 stream, cntxt, folder, msgmap, 1,
116 (style == ThreadIndex) ? ThrdIndex
117 : (THREADING()
118 && sp_viewing_a_thread(stream))
119 ? ThrdMsgNum
120 : MessageNumber,
121 0, 0, NULL);
122
123 if(flags & INDX_FOOTER) {
124 bitmap_t bitmap;
125 int cmd;
126
127 setbitmap(bitmap);
128
129 if(km == &index_keymenu){
130 if(THREADING() && sp_viewing_a_thread(stream)){
131 menu_init_binding(km, '<', MC_THRDINDX, "<",
132 N_("ThrdIndex"), BACK_KEY);
133 menu_add_binding(km, ',', MC_THRDINDX);
134 }
135 else{
136 menu_init_binding(km, '<', MC_FOLDERS, "<",
137 N_("FldrList"), BACK_KEY);
138 menu_add_binding(km, ',', MC_FOLDERS);
139 }
140 if(F_OFF(F_ENABLE_PIPE,ps_global))
141 clrbitn(VIEW_PIPE_KEY, bitmap); /* always clear for DOS */
142 if(F_OFF(F_ENABLE_FULL_HDR,ps_global))
143 clrbitn(VIEW_FULL_HEADERS_KEY, bitmap);
144 if(F_OFF(F_ENABLE_BOUNCE,ps_global))
145 clrbitn(BOUNCE_KEY, bitmap);
146 if(F_OFF(F_ENABLE_FLAG,ps_global))
147 clrbitn(FLAG_KEY, bitmap);
148 if(F_OFF(F_ENABLE_AGG_OPS,ps_global)){
149 clrbitn(SELECT_KEY, bitmap);
150 clrbitn(APPLY_KEY, bitmap);
151 clrbitn(SELCUR_KEY, bitmap);
152 if(style != ZoomIndex)
153 clrbitn(ZOOM_KEY, bitmap);
154
155 }
156
157 if(style == MultiMsgIndex){
158 clrbitn(PREVM_KEY, bitmap);
159 clrbitn(NEXTM_KEY, bitmap);
160 }
161 }
162
163 if(km == &index_keymenu || km == &thread_keymenu){
164 if(IS_NEWS(stream)){
165 km->keys[EXCLUDE_KEY].label = N_("eXclude");
166 KS_OSDATASET(&km->keys[EXCLUDE_KEY], KS_NONE);
167 }
168 else {
169 clrbitn(UNEXCLUDE_KEY, bitmap);
170 km->keys[EXCLUDE_KEY].label = N_("eXpunge");
171 KS_OSDATASET(&km->keys[EXCLUDE_KEY], KS_EXPUNGE);
172 }
173 }
174
175 if(km != &simple_index_keymenu && !THRD_COLLAPSE_ENABLE())
176 clrbitn(COLLAPSE_KEY, bitmap);
177
178 menu_clear_binding(km, KEY_LEFT);
179 menu_clear_binding(km, KEY_RIGHT);
180 if(F_ON(F_ARROW_NAV, ps_global)){
181 if((cmd = menu_clear_binding(km, '<')) != MC_UNKNOWN){
182 menu_add_binding(km, '<', cmd);
183 menu_add_binding(km, KEY_LEFT, cmd);
184 }
185
186 if((cmd = menu_clear_binding(km, '>')) != MC_UNKNOWN){
187 menu_add_binding(km, '>', cmd);
188 menu_add_binding(km, KEY_RIGHT, cmd);
189 }
190 }
191
192 if(menu_binding_index(km, MC_JUMP) >= 0){
193 for(cmd = 0; cmd < 10; cmd++)
194 if(F_ON(F_ENABLE_JUMP, ps_global))
195 (void) menu_add_binding(km, '0' + cmd, MC_JUMP);
196 else
197 (void) menu_clear_binding(km, '0' + cmd);
198 }
199
200 draw_keymenu(km, bitmap, ps_global->ttyo->screen_cols,
201 1-FOOTER_ROWS(ps_global), 0, what_keymenu);
202 what_keymenu = SameMenu;
203 if(which_keys)
204 *which_keys = km->which; /* pass back to caller */
205 }
206
207 return(km);
208 }
209
210
211
212 /*----------------------------------------------------------------------
213 Main loop executing commands for the mail index screen
214
215 Args: state -- the pine_state structure for next/prev screen pointers
216 and to pass to the index manager...
217 ----*/
218
219 void
220 mail_index_screen(struct pine *state)
221 {
222 if(!state->mail_stream) {
223 q_status_message(SM_ORDER, 0, 3, _("No folder is currently open"));
224 state->prev_screen = mail_index_screen;
225 state->next_screen = main_menu_screen;
226 return;
227 }
228
229 state->prev_screen = mail_index_screen;
230 state->next_screen = SCREEN_FUN_NULL;
231
232 if(THRD_AUTO_VIEW()
233 && sp_viewing_a_thread(state->mail_stream)
234 && state->view_skipped_index
235 && unview_thread(state, state->mail_stream, state->msgmap)){
236 state->next_screen = mail_index_screen;
237 state->view_skipped_index = 0;
238 state->mangled_screen = 1;
239 }
240
241 adjust_cur_to_visible(state->mail_stream, state->msgmap);
242
243 if(THRD_INDX())
244 thread_index_screen(state);
245 else
246 index_index_screen(state);
247 }
248
249
250 void
251 index_index_screen(struct pine *state)
252 {
253 dprint((1, "\n\n ---- MAIL INDEX ----\n"));
254
255 setup_for_index_index_screen();
256
257 index_lister(state, state->context_current, state->cur_folder,
258 state->mail_stream, state->msgmap);
259 }
260
261
262 void
263 thread_index_screen(struct pine *state)
264 {
265 dprint((1, "\n\n ---- THREAD INDEX ----\n"));
266
267 setup_for_thread_index_screen();
268
269 index_lister(state, state->context_current, state->cur_folder,
270 state->mail_stream, state->msgmap);
271 }
272
273
274 void *
275 stop_threading_temporarily(void)
276 {
277 struct save_thrdinfo *ti;
278
279 ps_global->turn_off_threading_temporarily = 1;
280
281 ti = (struct save_thrdinfo *) fs_get(sizeof(*ti));
282 ti->format_index_line = format_index_line;
283 ti->setup_header_widths = setup_header_widths;
284 ti->viewing_a_thread = sp_viewing_a_thread(ps_global->mail_stream);
285
286 setup_for_index_index_screen();
287
288 return((void *) ti);
289 }
290
291
292 void
293 restore_threading(void **p)
294 {
295 struct save_thrdinfo *ti;
296
297 ps_global->turn_off_threading_temporarily = 0;
298
299 if(p && *p){
300 ti = (struct save_thrdinfo *) (*p);
301 format_index_line = ti->format_index_line;
302 setup_header_widths = ti->setup_header_widths;
303 sp_set_viewing_a_thread(ps_global->mail_stream, ti->viewing_a_thread);
304
305 fs_give(p);
306 }
307 }
308
309
310 /*----------------------------------------------------------------------
311 Main loop executing commands for the mail index screen
312
313 Args: state -- pine_state structure for display flags and such
314 msgmap -- c-client/pine message number mapping struct
315 ----*/
316
317 int
318 index_lister(struct pine *state, CONTEXT_S *cntxt, char *folder, MAILSTREAM *stream, MSGNO_S *msgmap)
319 {
320 UCS ch;
321 int cmd, which_keys, force,
322 cur_row, cur_col, km_popped, paint_status;
323 static int old_day = -1;
324 long i, j, k, old_max_msgno;
325 long lflagged, old_lflagged = 0L;
326 char *utf8str;
327 IndexType style, old_style = MsgIndex;
328 struct index_state id;
329 struct key_menu *km = NULL;
330
331
332 dprint((1, "\n\n ---- INDEX MANAGER ----\n"));
333
334 ch = 'x'; /* For displaying msg 1st time thru */
335 force = 0;
336 km_popped = 0;
337 state->mangled_screen = 1;
338 what_keymenu = FirstMenu;
339 old_max_msgno = mn_get_total(msgmap);
340 memset((void *)&id, 0, sizeof(struct index_state));
341 current_index_state = &id;
342 id.msgmap = msgmap;
343 if(msgmap->top != 0L)
344 id.msg_at_top = msgmap->top;
345
346 id.stream = stream;
347 set_need_format_setup(stream);
348
349 while (1) {
350 ps_global->user_says_cancel = 0;
351
352 if(km_popped){
353 km_popped--;
354 if(km_popped == 0){
355 clearfooter(state);
356 if(!state->mangled_body
357 && id.entry_state
358 && id.lines_per_page > 1){
359 id.entry_state[id.lines_per_page-2].id = 0;
360 id.entry_state[id.lines_per_page-1].id = 0;
361 }
362 else
363 state->mangled_body = 1;
364 }
365 }
366
367 /*------- Check for new mail -------*/
368 new_mail(force, NM_TIMING(ch), NM_STATUS_MSG);
369 force = 0; /* may not need to next time around */
370
371 /*
372 * If the width of the message number field in the display changes
373 * we need to flush the cache and redraw. When the cache is cleared
374 * the widths are recalculated, taking into account the max msgno.
375 */
376
377 if(format_includes_msgno(stream) &&
378 ((old_max_msgno < 1000L && mn_get_total(msgmap) >= 1000L)
379 || (old_max_msgno < 10000L && mn_get_total(msgmap) >= 10000L)
380 || (old_max_msgno < 100000L && mn_get_total(msgmap) >= 100000L))){
381 clear_index_cache(stream, IC_CLEAR_WIDTHS_DONE);
382 state->mangled_body = 1;
383 }
384
385 old_max_msgno = mn_get_total(msgmap);
386
387 /*
388 * If the display includes the SMARTDATE ("Today", "Yesterday", ...)
389 * then when the day changes the date column will change. All of the
390 * Today's will become Yesterday's at midnight. So we have to
391 * clear the cache at midnight.
392 */
393 if(format_includes_smartdate(stream)){
394 char db[200];
395 struct date nnow;
396
397 rfc822_date(db);
398 parse_date(db, &nnow);
399 if(old_day != -1 && nnow.day != old_day){
400 clear_index_cache(stream, 0);
401 state->mangled_body = 1;
402 }
403
404 old_day = nnow.day;
405 }
406
407 if(streams_died())
408 state->mangled_header = 1;
409
410 if(state->mangled_screen){
411 state->mangled_header = 1;
412 state->mangled_body = 1;
413 state->mangled_footer = 1;
414 state->mangled_screen = 0;
415 }
416
417 /*
418 * events may have occured that require us to shift from
419 * mode to another...
420 */
421 style = THRD_INDX()
422 ? ThreadIndex
423 : (any_lflagged(msgmap, MN_HIDE))
424 ? ZoomIndex
425 : (mn_total_cur(msgmap) > 1L) ? MultiMsgIndex : MsgIndex;
426 lflagged = any_lflagged(msgmap, MN_HIDE);
427 if(style != old_style || lflagged < old_lflagged){
428 state->mangled_header = 1;
429 state->mangled_footer = 1;
430 old_style = style;
431 old_lflagged = lflagged;
432 if(!(style == ThreadIndex || old_style == ThreadIndex))
433 id.msg_at_top = 0L;
434 }
435
436 /*------------ Update the title bar -----------*/
437 if(state->mangled_header) {
438 km = do_index_border(cntxt, folder, stream, msgmap,
439 style, NULL, INDX_HEADER);
440 state->mangled_header = 0;
441 paint_status = 0;
442 }
443 else if(mn_get_total(msgmap) > 0) {
444 update_titlebar_message();
445 /*
446 * If flags aren't available to update the status,
447 * defer it until after all the fetches associated
448 * with building index lines are done (no extra rtts!)...
449 */
450 paint_status = !update_titlebar_status();
451 }
452
453 current_index_state = &id;
454
455 /*------------ draw the index body ---------------*/
456 cur_row = update_index(state, &id);
457 if(F_OFF(F_SHOW_CURSOR, state)){
458 cur_row = state->ttyo->screen_rows - FOOTER_ROWS(state);
459 cur_col = 0;
460 }
461 else if(id.status_col >= 0)
462 cur_col = MIN(id.status_col, state->ttyo->screen_cols-1);
463
464 ps_global->redrawer = redraw_index_body;
465
466 if(paint_status)
467 (void) update_titlebar_status();
468
469 /*------------ draw the footer/key menus ---------------*/
470 if(state->mangled_footer) {
471 if(!state->painted_footer_on_startup){
472 if(km_popped){
473 FOOTER_ROWS(state) = 3;
474 clearfooter(state);
475 }
476
477 km = do_index_border(cntxt, folder, stream, msgmap, style,
478 &which_keys, INDX_FOOTER);
479 if(km_popped){
480 FOOTER_ROWS(state) = 1;
481 mark_keymenu_dirty();
482 }
483 }
484
485 state->mangled_footer = 0;
486 }
487
488 state->painted_body_on_startup = 0;
489 state->painted_footer_on_startup = 0;
490
491 /*-- Display any queued message (eg, new mail, command result --*/
492 if(km_popped){
493 FOOTER_ROWS(state) = 3;
494 mark_status_unknown();
495 }
496
497 display_message(ch);
498 if(km_popped){
499 FOOTER_ROWS(state) = 1;
500 mark_status_unknown();
501 }
502
503 if(F_ON(F_SHOW_CURSOR, state) && cur_row < 0){
504 cur_row = state->ttyo->screen_rows - FOOTER_ROWS(state);
505 }
506
507 cur_row = MIN(MAX(cur_row, 0), state->ttyo->screen_rows-1);
508 MoveCursor(cur_row, cur_col);
509
510 /* Let read_command do the fflush(stdout) */
511
512 /*---------- Read command and validate it ----------------*/
513 #ifdef MOUSE
514 mouse_in_content(KEY_MOUSE, -1, -1, 0x5, 0);
515 register_mfunc(mouse_in_content, HEADER_ROWS(ps_global), 0,
516 state->ttyo->screen_rows-(FOOTER_ROWS(ps_global)+1),
517 state->ttyo->screen_cols);
518 #endif
519 #ifdef _WINDOWS
520 mswin_setscrollcallback (index_scroll_callback);
521 mswin_sethelptextcallback((stream == state->mail_stream)
522 ? pcpine_help_index
523 : pcpine_help_index_simple);
524 mswin_setviewinwindcallback(view_in_new_window);
525 #endif
526 ch = READ_COMMAND(&utf8str);
527 #ifdef MOUSE
528 clear_mfunc(mouse_in_content);
529 #endif
530 #ifdef _WINDOWS
531 mswin_setscrollcallback(NULL);
532 mswin_sethelptextcallback(NULL);
533 mswin_setviewinwindcallback(NULL);
534 #endif
535
536 cmd = menu_command(ch, km);
537
538 if(km_popped)
539 switch(cmd){
540 case MC_NONE :
541 case MC_OTHER :
542 case MC_RESIZE :
543 case MC_REPAINT :
544 km_popped++;
545 break;
546
547 default:
548 clearfooter(state);
549 break;
550 }
551
552 /*----------- Execute the command ------------------*/
553 switch(cmd){
554
555 /*---------- Roll keymenu ----------*/
556 case MC_OTHER :
557 if(F_OFF(F_USE_FK, ps_global))
558 warn_other_cmds();
559
560 what_keymenu = NextMenu;
561 state->mangled_footer = 1;
562 break;
563
564
565 /*---------- Scroll line up ----------*/
566 case MC_CHARUP :
567 (void) process_cmd(state, stream, msgmap, MC_PREVITEM,
568 (style == MsgIndex
569 || style == MultiMsgIndex
570 || style == ZoomIndex)
571 ? MsgIndx
572 : (style == ThreadIndex)
573 ? ThrdIndx
574 : View,
575 &force);
576 if(mn_get_cur(msgmap) < (id.msg_at_top + HS_MARGIN(state)))
577 index_scroll_up(1L);
578
579 break;
580
581
582 /*---------- Scroll line down ----------*/
583 case MC_CHARDOWN :
584 /*
585 * Special Page framing handling here. If we
586 * did something that should scroll-by-a-line, frame
587 * the page by hand here rather than leave it to the
588 * page-by-page framing in update_index()...
589 */
590 (void) process_cmd(state, stream, msgmap, MC_NEXTITEM,
591 (style == MsgIndex
592 || style == MultiMsgIndex
593 || style == ZoomIndex)
594 ? MsgIndx
595 : (style == ThreadIndex)
596 ? ThrdIndx
597 : View,
598 &force);
599 for(j = 0L, k = i = id.msg_at_top; ; i++){
600 if(!msgline_hidden(stream, msgmap, i, 0)){
601 k = i;
602 if(j++ >= id.lines_per_page)
603 break;
604 }
605
606 if(i >= mn_get_total(msgmap)){
607 k = 0L; /* don't scroll */
608 break;
609 }
610 }
611
612 if(k && (mn_get_cur(msgmap) + HS_MARGIN(state)) >= k)
613 index_scroll_down(1L);
614
615 break;
616
617
618 /*---------- Scroll page up ----------*/
619 case MC_PAGEUP :
620 j = -1L;
621 for(k = i = id.msg_at_top; ; i--){
622 if(!msgline_hidden(stream, msgmap, i, 0)){
623 k = i;
624 if(++j >= id.lines_per_page){
625 if((id.msg_at_top = i) == 1L)
626 q_status_message(SM_ORDER, 0, 1, _("First Index page"));
627
628 break;
629 }
630 }
631
632 if(i <= 1L){
633 if((!THREADING() && mn_get_cur(msgmap) == 1L)
634 || (THREADING()
635 && mn_get_cur(msgmap) == first_sorted_flagged(F_NONE,
636 stream,
637 0L,
638 FSF_SKIP_CHID)))
639 q_status_message(SM_ORDER, 0, 1,
640 _("Already at start of Index"));
641
642 break;
643 }
644 }
645
646 if(mn_get_total(msgmap) > 0L && mn_total_cur(msgmap) == 1L)
647 mn_set_cur(msgmap, k);
648
649 break;
650
651
652 /*---------- Scroll page forward ----------*/
653 case MC_PAGEDN :
654 j = -1L;
655 for(k = i = id.msg_at_top; ; i++){
656 if(!msgline_hidden(stream, msgmap, i, 0)){
657 k = i;
658 if(++j >= id.lines_per_page){
659 if(i+id.lines_per_page > mn_get_total(msgmap))
660 q_status_message(SM_ORDER, 0, 1, _("Last Index page"));
661
662 id.msg_at_top = i;
663 break;
664 }
665 }
666
667 if(i >= mn_get_total(msgmap)){
668 if(mn_get_cur(msgmap) == k)
669 q_status_message(SM_ORDER,0,1,_("Already at end of Index"));
670
671 break;
672 }
673 }
674
675 if(mn_get_total(msgmap) > 0L && mn_total_cur(msgmap) == 1L)
676 mn_set_cur(msgmap, k);
677
678 break;
679
680
681 /*---------- Scroll to first page ----------*/
682 case MC_HOMEKEY :
683 if((mn_get_total(msgmap) > 0L)
684 && (mn_total_cur(msgmap) <= 1L)){
685 long cur_msg = mn_get_cur(msgmap), selected;
686
687 if(any_lflagged(msgmap, MN_HIDE | MN_CHID)){
688 do {
689 selected = cur_msg;
690 mn_dec_cur(stream, msgmap, MH_NONE);
691 cur_msg = mn_get_cur(msgmap);
692 }
693 while(selected != cur_msg);
694 }
695 else
696 cur_msg = (mn_get_total(msgmap) > 0L) ? 1L : 0L;
697 mn_set_cur(msgmap, cur_msg);
698 q_status_message(SM_ORDER, 0, 3, _("First Index Page"));
699 }
700 break;
701
702 /*---------- Scroll to last page ----------*/
703 case MC_ENDKEY :
704 if((mn_get_total(msgmap) > 0L)
705 && (mn_total_cur(msgmap) <= 1L)){
706 long cur_msg = mn_get_cur(msgmap), selected;
707
708 if(any_lflagged(msgmap, MN_HIDE | MN_CHID)){
709 do {
710 selected = cur_msg;
711 mn_inc_cur(stream, msgmap, MH_NONE);
712 cur_msg = mn_get_cur(msgmap);
713 }
714 while(selected != cur_msg);
715 }
716 else
717 cur_msg = mn_get_total(msgmap);
718 mn_set_cur(msgmap, cur_msg);
719 q_status_message(SM_ORDER, 0, 3, _("Last Index Page"));
720 }
721 break;
722
723 /*---------- Search (where is command) ----------*/
724 case MC_WHEREIS :
725 index_search(state, stream, -FOOTER_ROWS(ps_global), msgmap);
726 state->mangled_footer = 1;
727 break;
728
729
730 /*-------------- jump command -------------*/
731 /* NOTE: preempt the process_cmd() version because
732 * we need to get at the number..
733 */
734 case MC_JUMP :
735 j = jump_to(msgmap, -FOOTER_ROWS(ps_global), ch, NULL,
736 (style == ThreadIndex) ? ThrdIndx : MsgIndx);
737 if(j > 0L){
738 if(style == ThreadIndex){
739 PINETHRD_S *thrd;
740
741 thrd = find_thread_by_number(stream, msgmap, j, NULL);
742
743 if(thrd && thrd->rawno)
744 mn_set_cur(msgmap, mn_raw2m(msgmap, thrd->rawno));
745 }
746 else{
747 /* jump to message */
748 if(mn_total_cur(msgmap) > 1L){
749 mn_reset_cur(msgmap, j);
750 }
751 else{
752 mn_set_cur(msgmap, j);
753 }
754 }
755
756 id.msg_at_top = 0L;
757 }
758
759 state->mangled_footer = 1;
760 break;
761
762
763 case MC_VIEW_ENTRY : /* only happens in thread index */
764
765 /*
766 * If the feature F_THRD_AUTO_VIEW is turned on and there
767 * is only one message in the thread, then we skip the index
768 * view of the thread and go straight to the message view.
769 */
770 view_a_thread:
771 if(THRD_AUTO_VIEW() && style == ThreadIndex){
772 PINETHRD_S *thrd;
773
774 thrd = fetch_thread(stream,
775 mn_m2raw(msgmap, mn_get_cur(msgmap)));
776 if(thrd
777 && (count_lflags_in_thread(stream, thrd,
778 msgmap, MN_NONE) == 1)){
779 if(view_thread(state, stream, msgmap, 1)){
780 state->view_skipped_index = 1;
781 cmd = MC_VIEW_TEXT;
782 goto do_the_default;
783 }
784 }
785 }
786
787 if(view_thread(state, stream, msgmap, 1)){
788 ps_global->next_screen = mail_index_screen;
789 ps_global->redrawer = NULL;
790 current_index_state = NULL;
791 if(id.entry_state)
792 fs_give((void **)&(id.entry_state));
793
794 return(0);
795 }
796
797 break;
798
799
800 case MC_THRDINDX :
801 if(any_lflagged(msgmap, MN_SLCT)){
802 PINETHRD_S *thrd, *topthrd;
803 for(i = 1L; i > 0L && i <= mn_get_total(msgmap);){
804 thrd = fetch_thread(stream, i);
805 if(thrd && thrd->top)
806 topthrd = fetch_thread(stream, thrd->top);
807 if(topthrd){
808 set_thread_lflags(stream, topthrd, msgmap, MN_CHID, 1);
809 set_thread_lflags(stream, topthrd, msgmap, MN_CHID2, 0);
810 set_lflag(stream, msgmap, mn_raw2m(msgmap, topthrd->rawno), MN_CHID, 0);
811 set_lflag(stream, msgmap, mn_raw2m(msgmap, topthrd->rawno), MN_COLL, 1);
812 }
813 i = thrd->nextthd;
814 }
815 }
816 msgmap->top = msgmap->top_after_thrd;
817 if(unview_thread(state, stream, msgmap)){
818 state->next_screen = mail_index_screen;
819 state->view_skipped_index = 0;
820 state->mangled_screen = 1;
821 ps_global->redrawer = NULL;
822 current_index_state = NULL;
823 if(id.entry_state)
824 fs_give((void **)&(id.entry_state));
825
826 return(0);
827 }
828
829 break;
830
831
832 #ifdef MOUSE
833 case MC_MOUSE:
834 {
835 MOUSEPRESS mp;
836 int new_cur;
837
838 mouse_get_last (NULL, &mp);
839 mp.row -= 2;
840
841 for(i = id.msg_at_top;
842 mp.row >= 0 && i <= mn_get_total(msgmap);
843 i++)
844 if(!msgline_hidden(stream, msgmap, i, 0)){
845 mp.row--;
846 new_cur = i;
847 }
848
849 if(mn_get_total(msgmap) && mp.row < 0){
850 switch(mp.button){
851 case M_BUTTON_LEFT :
852 if(mn_total_cur(msgmap) == 1L)
853 mn_set_cur(msgmap, new_cur);
854
855 if(mp.flags & M_KEY_CONTROL){
856 if(F_ON(F_ENABLE_AGG_OPS, ps_global)){
857 (void) select_by_current(state, msgmap, MsgIndx);
858 }
859 }
860 else if(!(mp.flags & M_KEY_SHIFT)){
861 if (THREADING()
862 && mp.col >= 0
863 && mp.col == id.plus_col
864 && style != ThreadIndex){
865 collapse_or_expand(state, stream, msgmap,
866 mn_get_cur(msgmap));
867 }
868 else if (mp.doubleclick){
869 if(mp.button == M_BUTTON_LEFT){
870 if(stream == state->mail_stream){
871 if(THRD_INDX()){
872 cmd = MC_VIEW_ENTRY;
873 goto view_a_thread;
874 }
875 else{
876 cmd = MC_VIEW_TEXT;
877 goto do_the_default;
878 }
879 }
880
881 ps_global->redrawer = NULL;
882 current_index_state = NULL;
883 if(id.entry_state)
884 fs_give((void **)&(id.entry_state));
885
886 return(0);
887 }
888 }
889 }
890
891 break;
892
893 case M_BUTTON_MIDDLE:
894 break;
895
896 case M_BUTTON_RIGHT :
897 #ifdef _WINDOWS
898 if (!mp.doubleclick){
899 if(mn_total_cur(msgmap) == 1L)
900 mn_set_cur(msgmap, new_cur);
901
902 cur_row = update_index(state, &id);
903
904 index_popup(style, stream, msgmap, TRUE);
905 }
906 #endif
907 break;
908 }
909 }
910 else{
911 switch(mp.button){
912 case M_BUTTON_LEFT :
913 break;
914
915 case M_BUTTON_MIDDLE :
916 break;
917
918 case M_BUTTON_RIGHT :
919 #ifdef _WINDOWS
920 index_popup(style, stream, msgmap, FALSE);
921 #endif
922 break;
923 }
924 }
925 }
926
927 break;
928 #endif /* MOUSE */
929
930 /*---------- Resize ----------*/
931 case MC_RESIZE:
932 /*
933 * If we were smarter we could do the
934 * IC_CLEAR_WIDTHS_DONE trick here. The problem is
935 * that entire columns of the format can go away or
936 * appear because the width gets smaller or larger,
937 * so in that case we need to re-do. If we could tell
938 * when that happened or not we could set the flag
939 * selectively.
940 */
941 clear_index_cache(stream, 0);
942 reset_index_border();
943 break;
944
945 case MC_QUOTA:
946 cmd_quota(state);
947
948 /*---------- Redraw ----------*/
949 case MC_REPAINT :
950 force = 1; /* check for new mail! */
951 reset_index_border();
952 break;
953
954
955 /*---------- No op command ----------*/
956 case MC_NONE :
957 break; /* no op check for new mail */
958
959
960 /*--------- keystroke not bound to command --------*/
961 case MC_CHARRIGHT :
962 case MC_CHARLEFT :
963 case MC_GOTOBOL :
964 case MC_GOTOEOL :
965 case MC_UNKNOWN :
966 if(cmd == MC_UNKNOWN && (ch == 'i' || ch == 'I'))
967 q_status_message(SM_ORDER, 0, 1, "Already in Index");
968 else
969 bogus_command(ch, F_ON(F_USE_FK,state) ? "F1" : "?");
970
971 break;
972
973
974 case MC_COLLAPSE :
975 thread_command(state, stream, msgmap, ch, -FOOTER_ROWS(state));
976 break;
977
978 case MC_DELETE :
979 case MC_UNDELETE :
980 case MC_REPLY :
981 case MC_FORWARD :
982 case MC_TAKE :
983 case MC_SAVE :
984 case MC_EXPORT :
985 case MC_BOUNCE :
986 case MC_PIPE :
987 case MC_FLAG :
988 case MC_SELCUR :
989 { int collapsed = 0;
990 unsigned long rawno;
991 PINETHRD_S *thrd = NULL;
992
993 if(THREADING()){
994 rawno = mn_m2raw(msgmap, mn_get_cur(msgmap));
995 if(rawno)
996 thrd = fetch_thread(stream, rawno);
997
998 collapsed = thrd && thrd->next
999 && get_lflag(stream, NULL, rawno, MN_COLL);
1000 }
1001
1002 if(collapsed){
1003 thread_command(state, stream, msgmap,
1004 ch, -FOOTER_ROWS(state));
1005 /* increment current */
1006 if(cmd == MC_DELETE){
1007 advance_cur_after_delete(state, stream, msgmap,
1008 (style == MsgIndex
1009 || style == MultiMsgIndex
1010 || style == ZoomIndex)
1011 ? MsgIndx
1012 : (style == ThreadIndex)
1013 ? ThrdIndx
1014 : View);
1015 }
1016 else if((cmd == MC_SELCUR
1017 && (state->ugly_consider_advancing_bit
1018 || F_OFF(F_UNSELECT_WONT_ADVANCE, state)))
1019 || (state->ugly_consider_advancing_bit
1020 && cmd == MC_SAVE
1021 && F_ON(F_SAVE_ADVANCES, state))){
1022 mn_inc_cur(stream, msgmap, MH_NONE);
1023 }
1024 }
1025 else
1026 goto do_the_default;
1027 }
1028
1029 break;
1030
1031
1032 case MC_UTF8:
1033 bogus_utf8_command(utf8str, NULL);
1034 break;
1035
1036
1037 /*---------- First HELP command with menu hidden ----------*/
1038 case MC_HELP :
1039 if(FOOTER_ROWS(state) == 1 && km_popped == 0){
1040 km_popped = 2;
1041 mark_status_unknown();
1042 mark_keymenu_dirty();
1043 state->mangled_footer = 1;
1044 break;
1045 }
1046 /* else fall thru to normal default */
1047
1048
1049 /*---------- Default -- all other command ----------*/
1050 default:
1051 do_the_default:
1052 if(stream == state->mail_stream){
1053 msgmap->top = id.msg_at_top;
1054 process_cmd(state, stream, msgmap, cmd,
1055 (style == MsgIndex
1056 || style == MultiMsgIndex
1057 || style == ZoomIndex)
1058 ? MsgIndx
1059 : (style == ThreadIndex)
1060 ? ThrdIndx
1061 : View,
1062 &force);
1063 if(state->next_screen != SCREEN_FUN_NULL){
1064 ps_global->redrawer = NULL;
1065 current_index_state = NULL;
1066 if(id.entry_state)
1067 fs_give((void **)&(id.entry_state));
1068
1069 return(0);
1070 }
1071 else{
1072 if(stream != state->mail_stream){
1073 /*
1074 * Must have had an failed open. repair our
1075 * pointers...
1076 */
1077 id.stream = stream = state->mail_stream;
1078 id.msgmap = msgmap = state->msgmap;
1079 }
1080
1081 current_index_state = &id;
1082
1083 if(cmd == MC_ZOOM && THRD_INDX())
1084 id.msg_at_top = 0L;
1085 }
1086 }
1087 else{ /* special processing */
1088 switch(cmd){
1089 case MC_HELP :
1090 helper(h_simple_index,
1091 (!strcmp(folder, INTERRUPTED_MAIL))
1092 ? _("HELP FOR SELECTING INTERRUPTED MSG")
1093 : _("HELP FOR SELECTING POSTPONED MSG"),
1094 HLPD_SIMPLE);
1095 state->mangled_screen = 1;
1096 break;
1097
1098 case MC_DELETE : /* delete */
1099 dprint((3, "Special delete: msg %s\n",
1100 long2string(mn_get_cur(msgmap))));
1101 {
1102 long raw, t;
1103 int del = 0;
1104 MESSAGECACHE *mc;
1105
1106 raw = mn_m2raw(msgmap, mn_get_cur(msgmap));
1107 if(raw > 0L && stream
1108 && raw <= stream->nmsgs
1109 && (mc = mail_elt(stream, raw))
1110 && !mc->deleted){
1111 if((t = mn_get_cur(msgmap)) > 0L)
1112 clear_index_cache_ent(stream, t, 0);
1113
1114 mail_setflag(stream,long2string(raw),"\\DELETED");
1115 update_titlebar_status();
1116 del++;
1117 }
1118
1119 q_status_message1(SM_ORDER, 0, 1,
1120 del ? _("Message %s deleted") : _("Message %s already deleted"),
1121 long2string(mn_get_cur(msgmap)));
1122 }
1123
1124 break;
1125
1126 case MC_UNDELETE : /* UNdelete */
1127 dprint((3, "Special UNdelete: msg %s\n",
1128 long2string(mn_get_cur(msgmap))));
1129 {
1130 long raw, t;
1131 int del = 0;
1132 MESSAGECACHE *mc;
1133
1134 raw = mn_m2raw(msgmap, mn_get_cur(msgmap));
1135 if(raw > 0L && stream
1136 && raw <= stream->nmsgs
1137 && (mc = mail_elt(stream, raw))
1138 && mc->deleted){
1139 if((t = mn_get_cur(msgmap)) > 0L)
1140 clear_index_cache_ent(stream, t, 0);
1141
1142 mail_clearflag(stream, long2string(raw),
1143 "\\DELETED");
1144 update_titlebar_status();
1145 del++;
1146 }
1147
1148 q_status_message1(SM_ORDER, 0, 1,
1149 del ? _("Message %s UNdeleted") : _("Message %s NOT deleted"),
1150 long2string(mn_get_cur(msgmap)));
1151 }
1152
1153 break;
1154
1155 case MC_EXIT : /* exit */
1156 ps_global->redrawer = NULL;
1157 current_index_state = NULL;
1158 if(id.entry_state)
1159 fs_give((void **)&(id.entry_state));
1160
1161 return(1);
1162
1163 case MC_SELECT : /* select */
1164 ps_global->redrawer = NULL;
1165 current_index_state = NULL;
1166 if(id.entry_state)
1167 fs_give((void **)&(id.entry_state));
1168
1169 return(0);
1170
1171 case MC_PREVITEM : /* previous */
1172 mn_dec_cur(stream, msgmap, MH_NONE);
1173 break;
1174
1175 case MC_NEXTITEM : /* next */
1176 mn_inc_cur(stream, msgmap, MH_NONE);
1177 break;
1178
1179 default :
1180 bogus_command(ch, NULL);
1181 break;
1182 }
1183 }
1184 } /* The big switch */
1185 } /* the BIG while loop! */
1186 }
1187
1188
1189
1190 /*----------------------------------------------------------------------
1191 Manage index body painting
1192
1193 Args: state - pine struct containing selected message data
1194 index_state - struct describing what's currently displayed
1195
1196 Returns: screen row number of first highlighted message
1197
1198 The idea is pretty simple. Maintain an array of index line id's that
1199 are displayed and their hilited state. Decide what's to be displayed
1200 and update the screen appropriately. All index screen painting
1201 is done here. Pretty simple, huh?
1202 ----*/
1203 int
1204 update_index(struct pine *state, struct index_state *screen)
1205 {
1206 int i, retval = -1, row, already_fetched = 0;
1207 long n, visible;
1208 PINETHRD_S *thrd = NULL;
1209 int we_cancel = 0;
1210
1211 dprint((7, "--update_index--\n"));
1212
1213 if(!screen)
1214 return(-1);
1215
1216 #ifdef _WINDOWS
1217 mswin_beginupdate();
1218 #endif
1219
1220 /*---- reset the works if necessary ----*/
1221 if(state->mangled_body){
1222 ClearBody();
1223 if(screen->entry_state){
1224 fs_give((void **)&(screen->entry_state));
1225 screen->lines_per_page = 0;
1226 }
1227 }
1228
1229 state->mangled_body = 0;
1230
1231 /*---- make sure we have a place to write state ----*/
1232 if(screen->lines_per_page
1233 != MAX(0, state->ttyo->screen_rows - FOOTER_ROWS(state)
1234 - HEADER_ROWS(state))){
1235 i = screen->lines_per_page;
1236 screen->lines_per_page
1237 = MAX(0, state->ttyo->screen_rows - FOOTER_ROWS(state)
1238 - HEADER_ROWS(state));
1239 if(!i){
1240 size_t len = screen->lines_per_page * sizeof(struct entry_state);
1241 screen->entry_state = (struct entry_state *) fs_get(len);
1242 }
1243 else
1244 fs_resize((void **)&(screen->entry_state),
1245 (size_t)screen->lines_per_page);
1246
1247 for(; i < screen->lines_per_page; i++) /* init new entries */
1248 memset(&screen->entry_state[i], 0, sizeof(struct entry_state));
1249 }
1250
1251 /*---- figure out the first message on the display ----*/
1252 if(screen->msg_at_top < 1L
1253 || msgline_hidden(screen->stream, screen->msgmap, screen->msg_at_top,0)){
1254 screen->msg_at_top = top_ent_calc(screen->stream, screen->msgmap,
1255 screen->msg_at_top,
1256 screen->lines_per_page);
1257 }
1258 else if(mn_get_cur(screen->msgmap) < screen->msg_at_top){
1259 long i, j, k;
1260
1261 /* scroll back a page at a time until current is displayed */
1262 while(mn_get_cur(screen->msgmap) < screen->msg_at_top){
1263 for(i = screen->lines_per_page, j = screen->msg_at_top-1L, k = 0L;
1264 i > 0L && j > 0L;
1265 j--)
1266 if(!msgline_hidden(screen->stream, screen->msgmap, j, 0)){
1267 k = j;
1268 i--;
1269 }
1270
1271 if(i == screen->lines_per_page)
1272 break; /* can't scroll back ? */
1273 else
1274 screen->msg_at_top = k;
1275 }
1276 }
1277 else if(mn_get_cur(screen->msgmap) >= screen->msg_at_top
1278 + screen->lines_per_page){
1279 long i, j, k;
1280
1281 while(1){
1282 for(i = screen->lines_per_page, j = k = screen->msg_at_top;
1283 j <= mn_get_total(screen->msgmap) && i > 0L;
1284 j++)
1285 if(!msgline_hidden(screen->stream, screen->msgmap, j, 0)){
1286 k = j;
1287 i--;
1288 if(mn_get_cur(screen->msgmap) <= k)
1289 break;
1290 }
1291
1292 if(mn_get_cur(screen->msgmap) <= k)
1293 break;
1294 else{
1295 /* set msg_at_top to next displayed message */
1296 for(i = k + 1L; i <= mn_get_total(screen->msgmap); i++)
1297 if(!msgline_hidden(screen->stream, screen->msgmap, i, 0)){
1298 k = i;
1299 break;
1300 }
1301
1302 screen->msg_at_top = k;
1303 }
1304 }
1305 }
1306
1307 #ifdef _WINDOWS
1308 /*
1309 * Set scroll range and position. Note that message numbers start at 1
1310 * while scroll position starts at 0.
1311 */
1312
1313 if(THREADING() && sp_viewing_a_thread(screen->stream)
1314 && mn_get_total(screen->msgmap) > 1L){
1315 long x = 0L, range = 0L, lowest_numbered_msg;
1316
1317 /*
1318 * We know that all visible messages in the thread are marked
1319 * with MN_CHID2.
1320 */
1321 thrd = fetch_thread(screen->stream,
1322 mn_m2raw(screen->msgmap,
1323 mn_get_cur(screen->msgmap)));
1324 if(thrd && thrd->top && thrd->top != thrd->rawno)
1325 thrd = fetch_thread(screen->stream, thrd->top);
1326
1327 if(thrd){
1328 if(mn_get_revsort(screen->msgmap)){
1329 n = mn_raw2m(screen->msgmap, thrd->rawno);
1330 while(n > 1L && get_lflag(screen->stream, screen->msgmap,
1331 n-1L, MN_CHID2))
1332 n--;
1333
1334 lowest_numbered_msg = n;
1335 }
1336 else
1337 lowest_numbered_msg = mn_raw2m(screen->msgmap, thrd->rawno);
1338 }
1339
1340 if(thrd){
1341 n = lowest_numbered_msg;
1342 for(; n <= mn_get_total(screen->msgmap); n++){
1343
1344 if(!get_lflag(screen->stream, screen->msgmap, n, MN_CHID2))
1345 break;
1346
1347 if(!msgline_hidden(screen->stream, screen->msgmap, n, 0)){
1348 range++;
1349 if(n < screen->msg_at_top)
1350 x++;
1351 }
1352 }
1353 }
1354
1355 scroll_setrange(screen->lines_per_page, range-1L);
1356 scroll_setpos(x);
1357 }
1358 else if(THRD_INDX()){
1359 if(any_lflagged(screen->msgmap, MN_HIDE)){
1360 long x = 0L, range;
1361
1362 range = screen->msgmap->visible_threads - 1L;
1363 scroll_setrange(screen->lines_per_page, range);
1364 if(range >= screen->lines_per_page){ /* else not needed */
1365 PINETHRD_S *topthrd;
1366 int thrddir;
1367 long xdir;
1368
1369 /* find top of currently displayed top line */
1370 topthrd = fetch_thread(screen->stream,
1371 mn_m2raw(screen->msgmap,
1372 screen->msg_at_top));
1373 if(topthrd && topthrd->top != topthrd->rawno)
1374 topthrd = fetch_thread(screen->stream, topthrd->top);
1375
1376 if(topthrd){
1377 /*
1378 * Split into two halves to speed up finding scroll pos.
1379 * It's tricky because the thread list always goes from
1380 * past to future but the thrdno's will be reversed if
1381 * the sort is reversed and of course the order on the
1382 * screen will be reversed.
1383 */
1384 if((!mn_get_revsort(screen->msgmap)
1385 && topthrd->thrdno <= screen->msgmap->max_thrdno/2)
1386 ||
1387 (mn_get_revsort(screen->msgmap)
1388 && topthrd->thrdno > screen->msgmap->max_thrdno/2)){
1389
1390 /* start with head of thread list */
1391 if(topthrd && topthrd->head)
1392 thrd = fetch_thread(screen->stream, topthrd->head);
1393 else
1394 thrd = NULL;
1395
1396 thrddir = 1;
1397 }
1398 else{
1399 long tailrawno;
1400
1401 /*
1402 * Start with tail thread and work back.
1403 */
1404 if(mn_get_revsort(screen->msgmap))
1405 tailrawno = mn_m2raw(screen->msgmap, 1L);
1406 else
1407 tailrawno = mn_m2raw(screen->msgmap,
1408 mn_get_total(screen->msgmap));
1409
1410 thrd = fetch_thread(screen->stream, tailrawno);
1411 if(thrd && thrd->top && thrd->top != thrd->rawno)
1412 thrd = fetch_thread(screen->stream, thrd->top);
1413
1414 thrddir = -1;
1415 }
1416
1417 /*
1418 * x is the scroll position. We try to use the fewest
1419 * number of steps to find it, so we start with either
1420 * the beginning or the end.
1421 */
1422 if(topthrd->thrdno <= screen->msgmap->max_thrdno/2){
1423 x = 0L;
1424 xdir = 1L;
1425 }
1426 else{
1427 x = range;
1428 xdir = -1L;
1429 }
1430
1431 while(thrd && thrd != topthrd){
1432 if(!msgline_hidden(screen->stream, screen->msgmap,
1433 mn_raw2m(screen->msgmap,thrd->rawno),
1434 0))
1435 x += xdir;
1436
1437 if(thrddir > 0 && thrd->nextthd)
1438 thrd = fetch_thread(screen->stream, thrd->nextthd);
1439 else if(thrddir < 0 && thrd->prevthd)
1440 thrd = fetch_thread(screen->stream, thrd->prevthd);
1441 else
1442 thrd = NULL;
1443 }
1444 }
1445
1446 scroll_setpos(x);
1447 }
1448 }
1449 else{
1450 /*
1451 * This works for forward or reverse sort because the thrdno's
1452 * will have been reversed.
1453 */
1454 thrd = fetch_thread(screen->stream,
1455 mn_m2raw(screen->msgmap, screen->msg_at_top));
1456 if(thrd){
1457 scroll_setrange(screen->lines_per_page,
1458 screen->msgmap->max_thrdno - 1L);
1459 scroll_setpos(thrd->thrdno - 1L);
1460 }
1461 }
1462 }
1463 else if(n = any_lflagged(screen->msgmap, MN_HIDE | MN_CHID)){
1464 long x, range;
1465
1466 range = mn_get_total(screen->msgmap) - n - 1L;
1467 scroll_setrange(screen->lines_per_page, range);
1468
1469 if(range >= screen->lines_per_page){ /* else not needed */
1470 if(screen->msg_at_top < mn_get_total(screen->msgmap) / 2){
1471 for(n = 1, x = 0; n != screen->msg_at_top; n++)
1472 if(!msgline_hidden(screen->stream, screen->msgmap, n, 0))
1473 x++;
1474 }
1475 else{
1476 for(n = mn_get_total(screen->msgmap), x = range;
1477 n != screen->msg_at_top; n--)
1478 if(!msgline_hidden(screen->stream, screen->msgmap, n, 0))
1479 x--;
1480 }
1481
1482 scroll_setpos(x);
1483 }
1484 }
1485 else{
1486 scroll_setrange(screen->lines_per_page,
1487 mn_get_total(screen->msgmap) - 1L);
1488 scroll_setpos(screen->msg_at_top - 1L);
1489 }
1490 #endif
1491
1492 /*
1493 * Set up c-client call back to tell us about IMAP envelope arrivals
1494 * Can't do it (easily) if single lines on the screen need information
1495 * about more than a single message before they can be drawn.
1496 */
1497 if(F_OFF(F_QUELL_IMAP_ENV_CB, ps_global) && !THRD_INDX()
1498 && !(THREADING() && (sp_viewing_a_thread(screen->stream)
1499 || ps_global->thread_disp_style == THREAD_MUTTLIKE
1500 || any_lflagged(screen->msgmap, MN_COLL))))
1501 mail_parameters(NULL, SET_IMAPENVELOPE, (void *) pine_imap_envelope);
1502
1503 if(THRD_INDX())
1504 visible = screen->msgmap->visible_threads;
1505 else if(THREADING() && sp_viewing_a_thread(screen->stream)){
1506 /*
1507 * We know that all visible messages in the thread are marked
1508 * with MN_CHID2.
1509 */
1510 for(visible = 0L, n = screen->msg_at_top;
1511 visible < (int) screen->lines_per_page
1512 && n <= mn_get_total(screen->msgmap); n++){
1513
1514 if(!get_lflag(screen->stream, screen->msgmap, n, MN_CHID2))
1515 break;
1516
1517 if(!msgline_hidden(screen->stream, screen->msgmap, n, 0))
1518 visible++;
1519 }
1520 }
1521 else
1522 visible = mn_get_total(screen->msgmap)
1523 - any_lflagged(screen->msgmap, MN_HIDE|MN_CHID);
1524
1525 /*---- march thru display lines, painting whatever is needed ----*/
1526 for(i = 0, n = screen->msg_at_top; i < (int) screen->lines_per_page; i++){
1527 if(visible == 0L || n < 1 || n > mn_get_total(screen->msgmap)){
1528 if(screen->entry_state[i].id != LINE_HASH_N){
1529 screen->entry_state[i].hilite = 0;
1530 screen->entry_state[i].bolded = 0;
1531 screen->entry_state[i].msgno = 0L;
1532 screen->entry_state[i].id = LINE_HASH_N;
1533 ClearLine(HEADER_ROWS(state) + i);
1534 }
1535 }
1536 else{
1537 ICE_S *ice;
1538
1539 /*
1540 * This changes status_col as a side effect so it has to be
1541 * executed before next line.
1542 */
1543 ice = build_header_line(state, screen->stream, screen->msgmap,
1544 n, &already_fetched);
1545 if(visible > 0L)
1546 visible--;
1547
1548 if(THRD_INDX()){
1549 unsigned long rawno;
1550
1551 rawno = mn_m2raw(screen->msgmap, n);
1552 if(rawno)
1553 thrd = fetch_thread(screen->stream, rawno);
1554 }
1555
1556 row = paint_index_line(ice, i,
1557 (THRD_INDX() && thrd) ? thrd->thrdno : n,
1558 screen->status_fld, screen->plus_fld,
1559 screen->arrow_fld, &screen->entry_state[i],
1560 mn_is_cur(screen->msgmap, n),
1561 THRD_INDX()
1562 ? (count_lflags_in_thread(screen->stream,
1563 thrd,
1564 screen->msgmap,
1565 MN_SLCT) > 0)
1566 : get_lflag(screen->stream, screen->msgmap,
1567 n, MN_SLCT));
1568 fflush(stdout);
1569 if(row && retval < 0)
1570 retval = row;
1571 }
1572
1573 /*--- increment n ---*/
1574 while((visible == -1L || visible > 0L)
1575 && ++n <= mn_get_total(screen->msgmap)
1576 && msgline_hidden(screen->stream, screen->msgmap, n, 0))
1577 ;
1578 }
1579
1580 if(we_cancel)
1581 cancel_busy_cue(-1);
1582
1583 mail_parameters(NULL, SET_IMAPENVELOPE, (void *) NULL);
1584
1585 #ifdef _WINDOWS
1586 mswin_endupdate();
1587 #endif
1588 fflush(stdout);
1589 dprint((7, "--update_index done\n"));
1590 return(retval);
1591 }
1592
1593
1594
1595 /*----------------------------------------------------------------------
1596 Create a string summarizing the message header for index on screen
1597
1598 Args: stream -- mail stream to fetch envelope info from
1599 msgmap -- message number to pine sort mapping
1600 msgno -- Message number to create line for
1601
1602 Result: returns a malloced string
1603 saves string in a cache for next call for same header
1604 ----*/
1605 ICE_S *
1606 build_header_line(struct pine *state, MAILSTREAM *stream, MSGNO_S *msgmap, long int msgno, int *already_fetched)
1607 {
1608 return(build_header_work(state, stream, msgmap, msgno,
1609 current_index_state->msg_at_top,
1610 current_index_state->lines_per_page,
1611 already_fetched));
1612 }
1613
1614
1615 /*----------------------------------------------------------------------
1616 Paint the given index line
1617
1618
1619 Args: ice -- index cache entry
1620 line -- index line number on screen, starting at 0 for first
1621 visible line, 1, 2, ...
1622 msgno -- for painting the message number field
1623 sfld -- field type of the status field, which is
1624 where we'll put the X for selected if necessary
1625 pfld -- field type where the thread indicator symbol goes
1626 afld -- field type of column which corresponds to the
1627 index-format ARROW token
1628 entry -- cache used to help us decide whether or not we need to
1629 redraw the index line or if we can just leave it alone because
1630 we know it is already correct
1631 cur -- is this the current message?
1632 sel -- is this message in the selected set?
1633
1634 Returns: screen row number if this is current message, else 0
1635 ----*/
1636 int
1637 paint_index_line(ICE_S *argice, int line, long int msgno, IndexColType sfld,
1638 IndexColType pfld, IndexColType afld, struct entry_state *entry,
1639 int cur, int sel)
1640 {
1641 COLOR_PAIR *lastc = NULL, *base_color = NULL;
1642 ICE_S *ice;
1643 IFIELD_S *ifield, *previfield = NULL;
1644 IELEM_S *ielem;
1645 int save_schar1 = -1, save_schar2 = -1, save_pchar = -1, i;
1646 int draw_whole_line = 0, draw_partial_line = 0;
1647 int n = MAX_SCREEN_COLS*6;
1648 char draw[MAX_SCREEN_COLS*6+1], *p;
1649
1650 ice = (THRD_INDX() && argice) ? argice->tice : argice;
1651
1652 /* This better not happen! */
1653 if(!ice){
1654 q_status_message3(SM_ORDER | SM_DING, 5, 5,
1655 "NULL ice in paint_index_line: %s, msgno=%s line=%s",
1656 THRD_INDX() ? "THRD_INDX" : "reg index",
1657 comatose(msgno), comatose(line));
1658 dprint((1, "NULL ice in paint_index_line: %s, msgno=%ld line=%d\n",
1659 THRD_INDX() ? "THRD_INDX" : "reg index",
1660 msgno, line));
1661 return 0;
1662 }
1663
1664 if(entry->msgno != msgno || ice->id == 0 || entry->id != ice->id){
1665 entry->id = 0L;
1666 entry->msgno = 0L;
1667 draw_whole_line = 1;
1668 }
1669 else if((cur != entry->hilite) || (sel != entry->bolded)
1670 || (ice->plus != entry->plus)){
1671 draw_partial_line = 1;
1672 }
1673
1674 if(draw_whole_line || draw_partial_line){
1675
1676 if(F_ON(F_FORCE_LOW_SPEED,ps_global) || ps_global->low_speed){
1677
1678 memset(draw, 0, sizeof(draw));
1679 p = draw;
1680
1681 for(ifield = ice->ifield; ifield && p-draw < n; ifield = ifield->next){
1682
1683 /* space between fields */
1684 if(ifield != ice->ifield && !(previfield && previfield->ctype == iText))
1685 *p++ = ' ';
1686
1687 /* message number string is generated on the fly */
1688 if(ifield->ctype == iMessNo){
1689 ielem = ifield->ielem;
1690 if(ielem && ielem->datalen >= ifield->width){
1691 snprintf(ielem->data, ielem->datalen+1, "%*.ld", ifield->width, msgno);
1692 ielem->data[ifield->width] = '\0';
1693 ielem->data[ielem->datalen] = '\0';
1694 }
1695 }
1696
1697 if(ifield->ctype == sfld){
1698 ielem = ifield->ielem;
1699 if(ielem && ielem->datalen > 0){
1700 if(draw_partial_line)
1701 MoveCursor(HEADER_ROWS(ps_global) + line, utf8_width(draw));
1702
1703 if(ielem->datalen == 1){
1704 save_schar1 = ielem->data[0];
1705 ielem->data[0] = (sel) ? 'X' : (cur && save_schar1 == ' ') ? '-' : save_schar1;
1706 if(draw_partial_line)
1707 Writechar(ielem->data[0], 0);
1708
1709 if(ielem->next && ielem->next->datalen){
1710 save_schar2 = ielem->next->data[0];
1711 if(cur)
1712 ielem->next->data[0] = '>';
1713
1714 if(draw_partial_line)
1715 Writechar(ielem->next->data[0], 0);
1716 }
1717 }
1718 else if(ielem->datalen > 1){
1719 save_schar1 = ielem->data[0];
1720 ielem->data[0] = (sel) ? 'X' : (cur && save_schar1 == ' ') ? '-' : save_schar1;
1721 if(draw_partial_line)
1722 Writechar(ielem->data[0], 0);
1723
1724 save_schar2 = ielem->data[1];
1725 if(cur){
1726 ielem->data[1] = '>';
1727 if(draw_partial_line)
1728 Writechar(ielem->data[1], 0);
1729 }
1730 }
1731 }
1732 }
1733 else if(ifield->ctype == afld){
1734
1735 if(draw_partial_line){
1736 MoveCursor(HEADER_ROWS(ps_global) + line, utf8_width(draw));
1737 for(i = 0; i < ifield->width-1; i++)
1738 Writechar(cur ? '-' : ' ', 0);
1739
1740 Writechar(cur ? '>' : ' ', 0);
1741 }
1742
1743 ielem = ifield->ielem;
1744 if(ielem && ielem->datalen >= ifield->width){
1745 for(i = 0; i < ifield->width-1; i++)
1746 ielem->data[i] = cur ? '-' : ' ';
1747
1748 ielem->data[i] = cur ? '>' : ' ';
1749 }
1750 }
1751 else if(ifield->ctype == pfld){
1752 ielem = ifield->ielem;
1753 if(ielem && ielem->datalen > 0){
1754 save_pchar = ielem->data[0];
1755 ielem->data[0] = ice->plus;
1756
1757 if(draw_partial_line){
1758 MoveCursor(HEADER_ROWS(ps_global) + line, utf8_width(draw));
1759 Writechar(ielem->data[0], 0);
1760 Writechar(' ', 0);
1761 }
1762 }
1763 }
1764
1765 for(ielem = ifield->ielem;
1766 ielem && ielem->print_format && p-draw < n;
1767 ielem = ielem->next){
1768 char *src;
1769 size_t bytes_added;
1770
1771 src = ielem->data;
1772 bytes_added = utf8_pad_to_width(p, src,
1773 ((n+1)-(p-draw)) * sizeof(char),
1774 ielem->wid, ifield->leftadj);
1775 p += bytes_added;
1776 }
1777
1778 draw[n] = '\0';
1779
1780 if(ifield->ctype == sfld){
1781 ielem = ifield->ielem;
1782 if(ielem && ielem->datalen > 0){
1783 if(ielem->datalen == 1){
1784 ielem->data[0] = save_schar1;
1785 if(ielem->next && ielem->next->datalen)
1786 ielem->next->data[0] = save_schar2;
1787 }
1788 else if(ielem->datalen > 1){
1789 ielem->data[0] = save_schar1;
1790 ielem->data[1] = save_schar2;
1791 }
1792 }
1793 }
1794 else if(ifield->ctype == afld){
1795 ielem = ifield->ielem;
1796 if(ielem && ielem->datalen >= ifield->width)
1797 for(i = 0; i < ifield->width; i++)
1798 ielem->data[i] = ' ';
1799 }
1800 else if(ifield->ctype == pfld){
1801 ielem = ifield->ielem;
1802 if(ielem && ielem->datalen > 0)
1803 ielem->data[0] = save_pchar;
1804 }
1805
1806 previfield = ifield;
1807 }
1808
1809 *p = '\0';
1810
1811 if(draw_whole_line)
1812 PutLine0(HEADER_ROWS(ps_global) + line, 0, draw);
1813 }
1814 else{
1815 int uc, ac, do_arrow;
1816 int i, drew_X = 0;
1817 int inverse_hack = 0, need_inverse_hack = 0;
1818 int doing_bold = 0;
1819
1820 /* so we can restore current color at the end */
1821 if((uc=pico_usingcolor()) != 0)
1822 lastc = pico_get_cur_color();
1823
1824 /*
1825 * There are two possible "arrow" cursors. One is the one that
1826 * you get when you are at a slow speed or you turn that slow
1827 * speed one on. It is drawn as part of the status column.
1828 * That one is the one associated with the variable "ac".
1829 * It is always the base_color or the inverse of the base_color.
1830 *
1831 * The other "arrow" cursor is the one you get by including the
1832 * ARROW token in the index-format. It may be configured to
1833 * be colored.
1834 *
1835 * The arrow cursors have two special properties that make
1836 * them different from other sections or fields.
1837 * First, the arrow cursors only show up on the current line.
1838 * Second, the arrow cursors are drawn with generated data, not
1839 * data that is present in the passed in data.
1840 */
1841
1842 /* ac is for the old integrated arrow cursor */
1843 ac = F_ON(F_FORCE_ARROW,ps_global);
1844
1845 /* do_arrow is for the ARROW token in index-format */
1846 do_arrow = (afld != iNothing);
1847
1848 MoveCursor(HEADER_ROWS(ps_global) + line, 0);
1849
1850 /* find the base color for the whole line */
1851 if(cur && !ac && !do_arrow){
1852 /*
1853 * This stanza handles the current line marking in the
1854 * regular, non-arrow-cursor case.
1855 */
1856
1857 /*
1858 * If the current line has a linecolor, apply the
1859 * appropriate reverse transformation to show it is current.
1860 */
1861 if(uc && ice->linecolor && ice->linecolor->fg[0]
1862 && ice->linecolor->bg[0] && pico_is_good_colorpair(ice->linecolor)){
1863 base_color = apply_rev_color(ice->linecolor,
1864 ps_global->index_color_style);
1865
1866 (void)pico_set_colorp(base_color, PSC_NONE);
1867 }
1868 else{
1869 inverse_hack++;
1870 if(uc){
1871 COLOR_PAIR *rev;
1872
1873 if((rev = pico_get_rev_color()) != NULL){
1874 base_color = new_color_pair(rev->fg, rev->bg);
1875 (void)pico_set_colorp(base_color, PSC_NONE);
1876 }
1877 else
1878 base_color = lastc;
1879 }
1880 }
1881 }
1882 else if(uc && ice->linecolor && ice->linecolor->fg[0]
1883 && ice->linecolor->bg[0]
1884 && pico_is_good_colorpair(ice->linecolor)){
1885 (void)pico_set_colorp(ice->linecolor, PSC_NONE);
1886 base_color = ice->linecolor;
1887 }
1888 else
1889 base_color = lastc;
1890
1891 memset(draw, 0, sizeof(draw));
1892 p = draw;
1893
1894 doing_bold = (sel && F_ON(F_SELECTED_SHOWN_BOLD, ps_global) && StartBold());
1895
1896 /* draw each field */
1897 for(ifield = ice->ifield; ifield && p-draw < n; ifield = ifield->next){
1898
1899 drew_X = 0;
1900
1901 /*
1902 * Fix up the data for some special cases.
1903 */
1904
1905 /* message number string is generated on the fly */
1906 if(ifield->ctype == iMessNo){
1907 ielem = ifield->ielem;
1908 if(ielem && ielem->datalen >= ifield->width){
1909 snprintf(ielem->data, ielem->datalen+1, "%*.ld", ifield->width, msgno);
1910 ielem->data[ifield->width] = '\0';
1911 ielem->data[ielem->datalen] = '\0';
1912 }
1913 }
1914
1915 if(ifield->ctype == sfld){
1916 ielem = ifield->ielem;
1917 if(ielem && ielem->datalen > 0){
1918 if(ielem->datalen == 1){
1919 save_schar1 = ielem->data[0];
1920 if(sel && !doing_bold){
1921 ielem->data[0] = 'X';
1922 drew_X++;
1923 }
1924 else if(ac && cur && ielem->data[0] == ' ')
1925 ielem->data[0] = '-';
1926
1927 if(ielem->next && ielem->next->datalen){
1928 save_schar2 = ielem->next->data[0];
1929 if(ac && cur && ielem->next->data[0] != '\0')
1930 ielem->next->data[0] = '>';
1931 }
1932 }
1933 else if(ielem->datalen > 1){
1934 if(sel && !doing_bold){
1935 ielem->data[0] = 'X';
1936 drew_X++;
1937 }
1938 else if(ac && cur && ielem->data[0] == ' ')
1939 ielem->data[0] = '-';
1940
1941 save_schar2 = ielem->data[1];
1942 if(ac && cur && ielem->data[1] != '\0')
1943 ielem->data[1] = '>';
1944 }
1945 }
1946 }
1947 else if(ifield->ctype == afld && do_arrow && cur){
1948
1949 ielem = ifield->ielem;
1950 if(ielem && ielem->datalen >= ifield->width){
1951 for(i = 0; i < ifield->width-1; i++)
1952 ielem->data[i] = cur ? '-' : ' ';
1953
1954 ielem->data[i] = '>';
1955 }
1956 }
1957 else if(ifield->ctype == pfld){
1958 ielem = ifield->ielem;
1959 if(ielem && ielem->datalen > 0){
1960 save_pchar = ielem->data[0];
1961 ielem->data[0] = ice->plus;
1962 }
1963 }
1964
1965 /* space between fields */
1966 if(ifield != ice->ifield && !(previfield && previfield->ctype == iText)){
1967 if(inverse_hack)
1968 StartInverse();
1969
1970 Write_to_screen(" ");
1971 if(inverse_hack)
1972 EndInverse();
1973 }
1974
1975 for(ielem = ifield->ielem; ielem; ielem = ielem->next){
1976 char *src;
1977
1978 src = ielem->data;
1979 utf8_pad_to_width(draw, src, (n+1) * sizeof(char),
1980 ielem->wid, ifield->leftadj);
1981 draw[n] = '\0';
1982
1983 /*
1984 * Switch to color for ielem.
1985 * But don't switch if we drew an X in this column,
1986 * because that overwrites the colored thing, and don't
1987 * switch if this is the ARROW field and this is not
1988 * the current message. ARROW field is only colored for
1989 * the current message.
1990 * And don't switch if current line and type eTypeCol.
1991 */
1992 if(ielem->color && pico_is_good_colorpair(ielem->color)
1993 && !(do_arrow && ifield->ctype == afld && !cur)
1994 && (!drew_X || ielem != ifield->ielem)
1995 && !(cur && ielem->type == eTypeCol)){
1996 need_inverse_hack = 0;
1997 (void) pico_set_colorp(ielem->color, PSC_NORM);
1998 }
1999 else
2000 need_inverse_hack = 1;
2001
2002 if(need_inverse_hack && inverse_hack)
2003 StartInverse();
2004
2005 Write_to_screen(draw);
2006 if(need_inverse_hack && inverse_hack)
2007 EndInverse();
2008
2009 (void) pico_set_colorp(base_color, PSC_NORM);
2010 }
2011
2012 /*
2013 * Restore the data for the special cases.
2014 */
2015
2016 if(ifield->ctype == sfld){
2017 ielem = ifield->ielem;
2018 if(ielem && ielem->datalen > 0){
2019 if(ielem->datalen == 1){
2020 ielem->data[0] = save_schar1;
2021 if(ielem->next && ielem->next->datalen)
2022 ielem->next->data[0] = save_schar2;
2023 }
2024 else if(ielem->datalen > 1){
2025 ielem->data[0] = save_schar1;
2026 ielem->data[1] = save_schar2;
2027 }
2028 }
2029 }
2030 else if(ifield->ctype == afld){
2031 ielem = ifield->ielem;
2032 if(ielem && ielem->datalen >= ifield->width)
2033 for(i = 0; i < ifield->width; i++)
2034 ielem->data[i] = ' ';
2035 }
2036 else if(ifield->ctype == pfld){
2037 ielem = ifield->ielem;
2038 if(ielem && ielem->datalen > 0)
2039 ielem->data[0] = save_pchar;
2040 }
2041
2042 previfield = ifield;
2043 }
2044
2045 if(doing_bold)
2046 EndBold();
2047
2048 if(base_color && base_color != lastc && base_color != ice->linecolor)
2049 free_color_pair(&base_color);
2050
2051 if(lastc){
2052 (void)pico_set_colorp(lastc, PSC_NORM);
2053 free_color_pair(&lastc);
2054 }
2055 }
2056 }
2057
2058 entry->hilite = cur;
2059 entry->bolded = sel;
2060 entry->msgno = msgno;
2061 entry->plus = ice->plus;
2062 entry->id = ice->id;
2063
2064 if(!ice->color_lookup_done && pico_usingcolor())
2065 entry->id = 0;
2066
2067 return(cur ? (line + HEADER_ROWS(ps_global)) : 0);
2068 }
2069
2070 /*
2071 * setup_index_state - hooked onto pith_opt_save_index_state to setup
2072 * current_index_state after setup_{index,thread}_header_widths
2073 */
2074 void
2075 setup_index_state(int threaded)
2076 {
2077 if(current_index_state){
2078 if(threaded){
2079 current_index_state->status_col = 0;
2080 current_index_state->status_fld = iStatus;
2081 current_index_state->plus_fld = iNothing;
2082 current_index_state->arrow_fld = iNothing;
2083 } else {
2084 INDEX_COL_S *cdesc, *prevcdesc = NULL;
2085 IndexColType sfld, altfld, plusfld, arrowfld;
2086 int width, fld, col, pluscol, scol, altcol;
2087
2088 col = 0;
2089 scol = -1;
2090 sfld = iNothing;
2091 altcol = -1;
2092 altfld = iNothing;
2093 /* figure out which field is status field */
2094 for(cdesc = ps_global->index_disp_format, fld = 0;
2095 cdesc->ctype != iNothing;
2096 cdesc++){
2097 width = cdesc->width;
2098 if(width == 0)
2099 continue;
2100
2101 /* space between columns */
2102 if(col > 0 && !(prevcdesc && prevcdesc->ctype == iText))
2103 col++;
2104
2105 if(cdesc->ctype == iStatus){
2106 scol = col;
2107 sfld = cdesc->ctype;
2108 break;
2109 }
2110
2111 if(cdesc->ctype == iFStatus || cdesc->ctype == iIStatus){
2112 scol = col;
2113 sfld = cdesc->ctype;
2114 break;
2115 }
2116
2117 if(cdesc->ctype == iMessNo){
2118 altcol = col;
2119 altfld = cdesc->ctype;
2120 }
2121
2122 col += width;
2123 fld++;
2124 prevcdesc = cdesc;
2125 }
2126
2127 if(sfld == iNothing){
2128 if(altcol == -1){
2129 scol = 0;
2130 }
2131 else{
2132 scol = altcol;
2133 sfld = altfld;
2134 }
2135 }
2136
2137
2138 current_index_state->status_col = scol;
2139 current_index_state->status_fld = sfld;
2140
2141 col = 0;
2142 plusfld = iNothing;
2143 pluscol = -1;
2144 prevcdesc = NULL;
2145 /* figure out which column to use for threading '+' */
2146 if(THREADING()
2147 && ps_global->thread_disp_style != THREAD_NONE
2148 && ps_global->VAR_THREAD_MORE_CHAR[0]
2149 && ps_global->VAR_THREAD_EXP_CHAR[0])
2150 for(cdesc = ps_global->index_disp_format, fld = 0;
2151 cdesc->ctype != iNothing;
2152 cdesc++){
2153 width = cdesc->width;
2154 if(width == 0)
2155 continue;
2156
2157 /* space between columns */
2158 if(col > 0 && !(prevcdesc && prevcdesc->ctype == iText))
2159 col++;
2160
2161 if((cdesc->ctype == iSubject
2162 || cdesc->ctype == iSubjectText
2163 || cdesc->ctype == iSubjKey
2164 || cdesc->ctype == iSubjKeyText
2165 || cdesc->ctype == iSubjKeyInit
2166 || cdesc->ctype == iSubjKeyInitText)
2167 && (ps_global->thread_disp_style == THREAD_STRUCT
2168 || ps_global->thread_disp_style == THREAD_MUTTLIKE
2169 || ps_global->thread_disp_style == THREAD_INDENT_SUBJ1
2170 || ps_global->thread_disp_style == THREAD_INDENT_SUBJ2)){
2171 plusfld = cdesc->ctype;
2172 pluscol = col;
2173 break;
2174 }
2175
2176 if((cdesc->ctype == iFrom
2177 || cdesc->ctype == iFromToNotNews
2178 || cdesc->ctype == iFromTo
2179 || cdesc->ctype == iAddress
2180 || cdesc->ctype == iMailbox)
2181 && (ps_global->thread_disp_style == THREAD_INDENT_FROM1
2182 || ps_global->thread_disp_style == THREAD_INDENT_FROM2
2183 || ps_global->thread_disp_style == THREAD_STRUCT_FROM)){
2184 plusfld = cdesc->ctype;
2185 pluscol = col;
2186 break;
2187 }
2188
2189 col += width;
2190 fld++;
2191 prevcdesc = cdesc;
2192 }
2193
2194 current_index_state->plus_fld = plusfld;
2195 current_index_state->plus_col = pluscol;
2196
2197 arrowfld = iNothing;
2198 /* figure out which field is arrow field, if any */
2199 for(cdesc = ps_global->index_disp_format, fld = 0;
2200 cdesc->ctype != iNothing;
2201 cdesc++){
2202 width = cdesc->width;
2203 if(width == 0)
2204 continue;
2205
2206 if(cdesc->ctype == iArrow){
2207 arrowfld = cdesc->ctype;
2208 break;
2209 }
2210
2211 fld++;
2212 }
2213
2214 current_index_state->arrow_fld = arrowfld;
2215 }
2216 }
2217 }
2218
2219
2220 /*
2221 * insert_condensed_thread_cue - used on pith hook to add decoration to
2222 * subject or from text to show condensed thread info
2223 */
2224 int
2225 condensed_thread_cue(PINETHRD_S *thd, ICE_S *ice,
2226 char **fieldstr, size_t *strsize, int width, int collapsed)
2227 {
2228 if(current_index_state->plus_fld != iNothing && !THRD_INDX() && fieldstr && *fieldstr){
2229 /*
2230 * WARNING!
2231 * There is an unwarranted assumption here that VAR_THREAD_MORE_CHAR[0]
2232 * and VAR_THREAD_EXP_CHAR[0] are ascii.
2233 * Could do something similar to the conversions done with keyword
2234 * initials in key_str.
2235 */
2236 if(ice)
2237 ice->plus = collapsed ? ps_global->VAR_THREAD_MORE_CHAR[0]
2238 : (thd && thd->next)
2239 ? ps_global->VAR_THREAD_EXP_CHAR[0] : ' ';
2240
2241 if(strsize && *strsize > 0 && width != 0){
2242 *(*fieldstr)++ = ' ';
2243 (*strsize)--;
2244 if(width > 0)
2245 width--;
2246 }
2247
2248 if(strsize && *strsize > 0 && width != 0){
2249 *(*fieldstr)++ = ' ';
2250 (*strsize)--;
2251 if(width > 0)
2252 width--;
2253 }
2254 }
2255
2256 return(width);
2257 }
2258
2259
2260 int
2261 truncate_subj_and_from_strings(void)
2262 {
2263 return 1;
2264 }
2265
2266
2267 /*
2268 * paint_index_hline - paint index line given what we got
2269 */
2270 void
2271 paint_index_hline(MAILSTREAM *stream, long int msgno, ICE_S *ice)
2272 {
2273 PINETHRD_S *thrd;
2274
2275 /*
2276 * Trust only what we get back that isn't bogus since
2277 * we were prevented from doing any fetches and such...
2278 */
2279 if((ps_global->redrawer == redraw_index_body
2280 || ps_global->prev_screen == mail_index_screen)
2281 && current_index_state
2282 && current_index_state->stream == stream
2283 && !ps_global->msgmap->hilited){
2284 int line;
2285
2286 /*
2287 * This test isn't right if there are hidden lines. The line will
2288 * fail the test because it seems like it is past the end of the
2289 * screen but since the hidden lines don't take up space the line
2290 * might actually be on the screen. Don't know that it is worth
2291 * it to fix this, though, since you may have to file through
2292 * many hidden lines before finding the visible ones. I'm not sure
2293 * if the logic inside the if is correct when we do pass the
2294 * top-level test. Leave it for now. Hubert - 2002-06-28
2295 */
2296 if((line = (int)(msgno - current_index_state->msg_at_top)) >= 0
2297 && line < current_index_state->lines_per_page){
2298 if(any_lflagged(ps_global->msgmap, MN_HIDE | MN_CHID)){
2299 long n;
2300 long zoomhide, collapsehide;
2301
2302 zoomhide = any_lflagged(ps_global->msgmap, MN_HIDE);
2303 collapsehide = any_lflagged(ps_global->msgmap, MN_CHID);
2304
2305 /*
2306 * Line is visible if it is selected and not hidden due to
2307 * thread collapse, or if there is no zooming happening and
2308 * it is not hidden due to thread collapse.
2309 */
2310 for(line = 0, n = current_index_state->msg_at_top;
2311 n != msgno;
2312 n++)
2313 if((zoomhide
2314 && get_lflag(stream, current_index_state->msgmap,
2315 n, MN_SLCT)
2316 && (!collapsehide
2317 || !get_lflag(stream, current_index_state->msgmap, n,
2318 MN_CHID)))
2319 ||
2320 (!zoomhide
2321 && !get_lflag(stream, current_index_state->msgmap,
2322 n, MN_CHID)))
2323 line++;
2324 }
2325
2326 thrd = NULL;
2327 if(THRD_INDX()){
2328 unsigned long rawno;
2329
2330 rawno = mn_m2raw(current_index_state->msgmap, msgno);
2331 if(rawno)
2332 thrd = fetch_thread(stream, rawno);
2333 }
2334
2335 paint_index_line(ice, line,
2336 (THRD_INDX() && thrd) ? thrd->thrdno : msgno,
2337 current_index_state->status_fld,
2338 current_index_state->plus_fld,
2339 current_index_state->arrow_fld,
2340 &current_index_state->entry_state[line],
2341 mn_is_cur(current_index_state->msgmap, msgno),
2342 THRD_INDX()
2343 ? (count_lflags_in_thread(stream, thrd,
2344 current_index_state->msgmap,
2345 MN_SLCT) > 0)
2346 : get_lflag(stream, current_index_state->msgmap,
2347 msgno, MN_SLCT));
2348 fflush(stdout);
2349 }
2350 }
2351 }
2352
2353
2354
2355
2356 /*
2357 * pine_imap_env -- C-client's telling us an envelope just arrived
2358 * from the server. Use it if we can...
2359 */
2360 void
2361 pine_imap_envelope(MAILSTREAM *stream, long unsigned int rawno, ENVELOPE *env)
2362 {
2363 MESSAGECACHE *mc;
2364
2365 dprint((7, "imap_env(%ld)\n", rawno));
2366 if(stream && !sp_mail_box_changed(stream)
2367 && stream == ps_global->mail_stream
2368 && rawno > 0L && rawno <= stream->nmsgs
2369 && (mc = mail_elt(stream,rawno))
2370 && mc->valid
2371 && mc->rfc822_size
2372 && !get_lflag(stream, NULL, rawno, MN_HIDE | MN_CHID | MN_EXLD)){
2373 INDEXDATA_S idata;
2374 ICE_S *ice;
2375
2376 memset(&idata, 0, sizeof(INDEXDATA_S));
2377 idata.no_fetch = 1;
2378 idata.size = mc->rfc822_size;
2379 idata.rawno = rawno;
2380 idata.msgno = mn_raw2m(sp_msgmap(stream), rawno);
2381 idata.stream = stream;
2382
2383 index_data_env(&idata, env);
2384
2385 /*
2386 * Look for resent-to already in MAILCACHE data
2387 */
2388 if(mc->private.msg.header.text.data){
2389 STRINGLIST *lines;
2390 SIZEDTEXT szt;
2391 static char *linelist[] = {"resent-to" , NULL};
2392
2393 if(mail_match_lines(lines = new_strlst(linelist),
2394 mc->private.msg.lines, 0L)){
2395 idata.valid_resent_to = 1;
2396 memset(&szt, 0, sizeof(SIZEDTEXT));
2397 textcpy(&szt, &mc->private.msg.header.text);
2398 mail_filter((char *) szt.data, szt.size, lines, 0L);
2399 idata.resent_to_us = parsed_resent_to_us((char *) szt.data);
2400 if(szt.data)
2401 fs_give((void **) &szt.data);
2402 }
2403
2404 free_strlst(&lines);
2405 }
2406
2407 ice = (*format_index_line)(&idata);
2408 if(idata.bogus)
2409 clear_ice(&ice);
2410 else
2411 paint_index_hline(stream, idata.msgno, ice);
2412 }
2413 }
2414
2415
2416 /*----------------------------------------------------------------------
2417 Scroll to specified postion.
2418
2419
2420 Args: pos - position to scroll to.
2421
2422 Returns: TRUE - did the scroll operation.
2423 FALSE - was not able to do the scroll operation.
2424 ----*/
2425 int
2426 index_scroll_to_pos (long int pos)
2427 {
2428 static short bad_timing = 0;
2429 long i, j, k;
2430
2431 if(bad_timing)
2432 return (FALSE);
2433
2434 /*
2435 * Put the requested line at the top of the screen...
2436 */
2437
2438 /*
2439 * Starting at msg 'pos' find next visible message.
2440 */
2441 for(i=pos; i <= mn_get_total(current_index_state->msgmap); i++) {
2442 if(!msgline_hidden(current_index_state->stream,
2443 current_index_state->msgmap, i, 0)){
2444 current_index_state->msg_at_top = i;
2445 break;
2446 }
2447 }
2448
2449 /*
2450 * If single selection, move selected message to be on the screen.
2451 */
2452 if (mn_total_cur(current_index_state->msgmap) == 1L) {
2453 if (current_index_state->msg_at_top >
2454 mn_get_cur (current_index_state->msgmap)) {
2455 /* Selection was above screen, move to top of screen. */
2456 mn_set_cur(current_index_state->msgmap,current_index_state->msg_at_top);
2457 }
2458 else {
2459 /* Scan through the screen. If selection found, leave where is.
2460 * Otherwise, move to end of screen */
2461 for( i = current_index_state->msg_at_top,
2462 j = current_index_state->lines_per_page;
2463 i != mn_get_cur(current_index_state->msgmap) &&
2464 i <= mn_get_total(current_index_state->msgmap) &&
2465 j > 0L;
2466 i++) {
2467 if(!msgline_hidden(current_index_state->stream,
2468 current_index_state->msgmap, i, 0)){
2469 j--;
2470 k = i;
2471 }
2472 }
2473 if(j <= 0L)
2474 /* Move to end of screen. */
2475 mn_set_cur(current_index_state->msgmap, k);
2476 }
2477 }
2478
2479 bad_timing = 0;
2480 return (TRUE);
2481 }
2482
2483
2484
2485 /*----------------------------------------------------------------------
2486 Adjust the index display state down a line
2487
2488 Args: scroll_count -- number of lines to scroll
2489
2490 Returns: TRUE - did the scroll operation.
2491 FALSE - was not able to do the scroll operation.
2492 ----*/
2493 int
2494 index_scroll_down(long int scroll_count)
2495 {
2496 static short bad_timing = 0;
2497 long i, j, k;
2498 long cur, total;
2499
2500 if(bad_timing)
2501 return (FALSE);
2502
2503 bad_timing = 1;
2504
2505
2506 j = -1L;
2507 total = mn_get_total (current_index_state->msgmap);
2508 for(k = i = current_index_state->msg_at_top; ; i++){
2509
2510 /* Only examine non-hidden messages. */
2511 if(!msgline_hidden(current_index_state->stream,
2512 current_index_state->msgmap, i, 0)){
2513 /* Remember this message */
2514 k = i;
2515 /* Increment count of lines. */
2516 if (++j >= scroll_count) {
2517 /* Counted enough lines, stop. */
2518 current_index_state->msg_at_top = k;
2519 break;
2520 }
2521 }
2522
2523 /* If at last message, stop. */
2524 if (i >= total){
2525 current_index_state->msg_at_top = k;
2526 break;
2527 }
2528 }
2529
2530 /*
2531 * If not multiple selection, see if selected message visable. if not
2532 * set it to last visable message.
2533 */
2534 if(mn_total_cur(current_index_state->msgmap) == 1L) {
2535 j = 0L;
2536 cur = mn_get_cur (current_index_state->msgmap);
2537 for (i = current_index_state->msg_at_top; i <= total; ++i) {
2538 if(!msgline_hidden(current_index_state->stream,
2539 current_index_state->msgmap, i, 0)){
2540 if (++j >= current_index_state->lines_per_page) {
2541 break;
2542 }
2543 if (i == cur)
2544 break;
2545 }
2546 }
2547 if (i != cur)
2548 mn_set_cur(current_index_state->msgmap,
2549 current_index_state->msg_at_top);
2550 }
2551
2552 bad_timing = 0;
2553 return (TRUE);
2554 }
2555
2556
2557
2558 /*----------------------------------------------------------------------
2559 Adjust the index display state up a line
2560
2561 Args: scroll_count -- number of lines to scroll
2562
2563 Returns: TRUE - did the scroll operation.
2564 FALSE - was not able to do the scroll operation.
2565
2566 ----*/
2567 int
2568 index_scroll_up(long int scroll_count)
2569 {
2570 static short bad_timing = 0;
2571 long i, j, k;
2572 long cur;
2573
2574 if(bad_timing)
2575 return(FALSE);
2576
2577 bad_timing = 1;
2578
2579 j = -1L;
2580 for(k = i = current_index_state->msg_at_top; ; i--){
2581
2582 /* Only examine non-hidden messages. */
2583 if(!msgline_hidden(current_index_state->stream,
2584 current_index_state->msgmap, i, 0)){
2585 /* Remember this message */
2586 k = i;
2587 /* Increment count of lines. */
2588 if (++j >= scroll_count) {
2589 /* Counted enough lines, stop. */
2590 current_index_state->msg_at_top = k;
2591 break;
2592 }
2593 }
2594
2595 /* If at first message, stop */
2596 if (i <= 1L){
2597 current_index_state->msg_at_top = k;
2598 break;
2599 }
2600 }
2601
2602
2603 /*
2604 * If not multiple selection, see if selected message visable. if not
2605 * set it to last visable message.
2606 */
2607 if(mn_total_cur(current_index_state->msgmap) == 1L) {
2608 j = 0L;
2609 cur = mn_get_cur (current_index_state->msgmap);
2610 for ( i = current_index_state->msg_at_top;
2611 i <= mn_get_total(current_index_state->msgmap);
2612 ++i) {
2613 if(!msgline_hidden(current_index_state->stream,
2614 current_index_state->msgmap, i, 0)){
2615 if (++j >= current_index_state->lines_per_page) {
2616 k = i;
2617 break;
2618 }
2619 if (i == cur)
2620 break;
2621 }
2622 }
2623 if (i != cur)
2624 mn_set_cur(current_index_state->msgmap, k);
2625 }
2626
2627
2628 bad_timing = 0;
2629 return (TRUE);
2630 }
2631
2632
2633
2634 /*----------------------------------------------------------------------
2635 Calculate the message number that should be at the top of the display
2636
2637 Args: current - the current message number
2638 lines_per_page - the number of lines for the body of the index only
2639
2640 Returns: -1 if the current message is -1
2641 the message entry for the first message at the top of the screen.
2642
2643 When paging in the index it is always on even page boundies, and the
2644 current message is always on the page thus the top of the page is
2645 completely determined by the current message and the number of lines
2646 on the page.
2647 ----*/
2648 long
2649 top_ent_calc(MAILSTREAM *stream, MSGNO_S *msgs, long int at_top, long int lines_per_page)
2650 {
2651 long current, hidden, lastn;
2652 long n, m = 0L, t = 1L;
2653
2654 current = (mn_total_cur(msgs) <= 1L) ? mn_get_cur(msgs) : at_top;
2655
2656 if(current < 0L)
2657 return(-1);
2658
2659 if(lines_per_page == 0L)
2660 return(current);
2661
2662 if(THRD_INDX_ENABLED()){
2663 long rawno;
2664 PINETHRD_S *thrd = NULL;
2665
2666 rawno = mn_m2raw(msgs, mn_get_cur(msgs));
2667 if(rawno)
2668 thrd = fetch_thread(stream, rawno);
2669
2670 if(THRD_INDX()){
2671
2672 if(any_lflagged(msgs, MN_HIDE)){
2673 PINETHRD_S *is_current_thrd;
2674
2675 is_current_thrd = thrd;
2676 if(is_current_thrd){
2677 if(mn_get_revsort(msgs)){
2678 /* start with top of tail of thread list */
2679 thrd = fetch_thread(stream, mn_m2raw(msgs, 1L));
2680 if(thrd && thrd->top && thrd->top != thrd->rawno)
2681 thrd = fetch_thread(stream, thrd->top);
2682 }
2683 else{
2684 /* start with head of thread list */
2685 thrd = fetch_head_thread(stream);
2686 }
2687
2688 t = 1L;
2689 m = 0L;
2690 if(thrd)
2691 n = mn_raw2m(msgs, thrd->rawno);
2692
2693 while(thrd){
2694 if(!msgline_hidden(stream, msgs, n, 0)
2695 && (++m % lines_per_page) == 1L)
2696 t = n;
2697
2698 if(thrd == is_current_thrd)
2699 break;
2700
2701 if(mn_get_revsort(msgs) && thrd->prevthd)
2702 thrd = fetch_thread(stream, thrd->prevthd);
2703 else if(!mn_get_revsort(msgs) && thrd->nextthd)
2704 thrd = fetch_thread(stream, thrd->nextthd);
2705 else
2706 thrd = NULL;
2707
2708 if(thrd)
2709 n = mn_raw2m(msgs, thrd->rawno);
2710 }
2711 }
2712 }
2713 else{
2714 if(thrd){
2715 n = thrd->thrdno;
2716 m = lines_per_page * ((n - 1L)/ lines_per_page) + 1L;
2717 n = thrd->rawno;
2718 /*
2719 * We want to find the m'th thread and the
2720 * message number that goes with that. We just have
2721 * to back up from where we are to get there.
2722 * If we have a reverse sort backing up is going
2723 * forward through the thread.
2724 */
2725 while(thrd && m < thrd->thrdno){
2726 n = thrd->rawno;
2727 if(mn_get_revsort(msgs) && thrd->nextthd)
2728 thrd = fetch_thread(stream, thrd->nextthd);
2729 else if(!mn_get_revsort(msgs) && thrd->prevthd)
2730 thrd = fetch_thread(stream, thrd->prevthd);
2731 else
2732 thrd = NULL;
2733 }
2734
2735 if(thrd)
2736 n = thrd->rawno;
2737
2738 t = mn_raw2m(msgs, n);
2739 }
2740 }
2741 }
2742 else{ /* viewing a thread */
2743
2744 lastn = mn_get_total(msgs);
2745 t = 1L;
2746
2747 /* get top of thread */
2748 if(thrd && thrd->top && thrd->top != thrd->rawno)
2749 thrd = fetch_thread(stream, thrd->top);
2750
2751 if(thrd){
2752 if(mn_get_revsort(msgs))
2753 lastn = mn_raw2m(msgs, thrd->rawno);
2754 else
2755 t = mn_raw2m(msgs, thrd->rawno);
2756 }
2757
2758 n = 0L;
2759
2760 /* n is the end of this thread */
2761 while(thrd){
2762 n = mn_raw2m(msgs, thrd->rawno);
2763 if(thrd->branch)
2764 thrd = fetch_thread(stream, thrd->branch);
2765 else if(thrd->next)
2766 thrd = fetch_thread(stream, thrd->next);
2767 else
2768 thrd = NULL;
2769 }
2770
2771 if(n){
2772 if(mn_get_revsort(msgs))
2773 t = n;
2774 else
2775 lastn = n;
2776 }
2777
2778 for(m = 0L, n = t; n <= MIN(current, lastn); n++)
2779 if(!msgline_hidden(stream, msgs, n, 0)
2780 && (++m % lines_per_page) == 1L)
2781 t = n;
2782 }
2783
2784 return(t);
2785 }
2786 else if((hidden = any_lflagged(msgs, MN_HIDE | MN_CHID)) != 0){
2787
2788 if(current < mn_get_total(msgs) / 2){
2789 t = 1L;
2790 m = 0L;
2791 for(n = 1L; n <= MIN(current, mn_get_total(msgs)); n++)
2792 if(!msgline_hidden(stream, msgs, n, 0)
2793 && (++m % lines_per_page) == 1L)
2794 t = n;
2795 }
2796 else{
2797 t = current+1L;
2798 m = mn_get_total(msgs)-hidden+1L;
2799 for(n = mn_get_total(msgs); n >= 1L && t > current; n--)
2800 if(!msgline_hidden(stream, msgs, n, 0)
2801 && (--m % lines_per_page) == 1L)
2802 t = n;
2803
2804 if(t > current)
2805 t = 1L;
2806 }
2807
2808 return(t);
2809 }
2810 else
2811 return(lines_per_page * ((current - 1L)/ lines_per_page) + 1L);
2812 }
2813
2814
2815 /*----------------------------------------------------------------------
2816 Clear various bits that make up a healthy display
2817
2818 ----*/
2819 void
2820 reset_index_border(void)
2821 {
2822 mark_status_dirty();
2823 mark_keymenu_dirty();
2824 mark_titlebar_dirty();
2825 ps_global->mangled_screen = 1; /* signal FULL repaint */
2826 }
2827
2828
2829 /*----------------------------------------------------------------------
2830 This redraws the body of the index screen, taking into
2831 account any change in the size of the screen. All the state needed to
2832 repaint is in the static variables so this can be called from
2833 anywhere.
2834 ----*/
2835 void
2836 redraw_index_body(void)
2837 {
2838 int agg;
2839
2840 if((agg = (mn_total_cur(current_index_state->msgmap) > 1L)) != 0)
2841 restore_selected(current_index_state->msgmap);
2842
2843 ps_global->mangled_body = 1;
2844
2845 (void) update_index(ps_global, current_index_state);
2846 if(agg)
2847 pseudo_selected(current_index_state->stream, current_index_state->msgmap);
2848 }
2849
2850
2851 /*----------------------------------------------------------------------
2852 Give hint about Other command being optional. Some people get the idea
2853 that it is required to use the commands on the 2nd and 3rd keymenus.
2854
2855 Args: none
2856
2857 Result: message may be printed to status line
2858 ----*/
2859 void
2860 warn_other_cmds(void)
2861 {
2862 static int other_cmds = 0;
2863
2864 other_cmds++;
2865 if(((ps_global->first_time_user || ps_global->show_new_version) &&
2866 other_cmds % 3 == 0 && other_cmds < 10) || other_cmds % 20 == 0)
2867 q_status_message(SM_ASYNC, 0, 9,
2868 _("Remember the \"O\" command is always optional"));
2869 }
2870
2871
2872 void
2873 thread_command(struct pine *state, MAILSTREAM *stream, MSGNO_S *msgmap,
2874 UCS preloadkeystroke, int q_line)
2875 {
2876 PINETHRD_S *thrd = NULL;
2877 unsigned long rawno, save_branch;
2878 int we_cancel = 0;
2879 int flags = AC_FROM_THREAD;
2880
2881 if(!(stream && msgmap))
2882 return;
2883
2884 rawno = mn_m2raw(msgmap, mn_get_cur(msgmap));
2885 if(rawno)
2886 thrd = fetch_thread(stream, rawno);
2887
2888 if(!thrd)
2889 return;
2890
2891 save_branch = thrd->branch;
2892 thrd->branch = 0L; /* branch is a sibling, not part of thread */
2893
2894 if(!preloadkeystroke){
2895 if(!THRD_INDX()){
2896 if(get_lflag(stream, NULL, rawno, MN_COLL) && thrd->next)
2897 flags |= AC_EXPN;
2898 else
2899 flags |= AC_COLL;
2900 }
2901
2902 if(count_lflags_in_thread(stream, thrd, msgmap, MN_SLCT)
2903 == count_lflags_in_thread(stream, thrd, msgmap, MN_NONE))
2904 flags |= AC_UNSEL;
2905 }
2906
2907 we_cancel = busy_cue(NULL, NULL, 1);
2908
2909 /* save the SLCT flags in STMP for restoring at the bottom */
2910 copy_lflags(stream, msgmap, MN_SLCT, MN_STMP);
2911
2912 /* clear the values from the SLCT flags */
2913 set_lflags(stream, msgmap, MN_SLCT, 0);
2914
2915 /* set SLCT for thrd on down */
2916 set_flags_for_thread(stream, msgmap, MN_SLCT, thrd, 1);
2917 thrd->branch = save_branch;
2918
2919 if(we_cancel)
2920 cancel_busy_cue(0);
2921
2922 (void ) apply_command(state, stream, msgmap, preloadkeystroke, flags,
2923 q_line);
2924
2925 /* restore the original flags */
2926 copy_lflags(stream, msgmap, MN_STMP, MN_SLCT);
2927
2928 if(any_lflagged(msgmap, MN_HIDE) > 0L){
2929 /* if nothing left selected, unhide all */
2930 if(any_lflagged(msgmap, MN_SLCT) == 0L){
2931 (void) unzoom_index(ps_global, stream, msgmap);
2932 dprint((4, "\n\n ---- Exiting ZOOM mode ----\n"));
2933 q_status_message(SM_ORDER,0,2, _("Index Zoom Mode is now off"));
2934 }
2935
2936 /* if current is hidden, adjust */
2937 adjust_cur_to_visible(stream, msgmap);
2938 }
2939 }
2940
2941
2942 /*----------------------------------------------------------------------
2943 Search the message headers as displayed in index
2944
2945 Args: command_line -- The screen line to prompt on
2946 msg -- The current message number to start searching at
2947 max_msg -- The largest message number in the current folder
2948
2949 The headers are searched exactly as they are displayed on the screen. The
2950 search will wrap around to the beginning if not string is not found right
2951 away.
2952 ----*/
2953 void
2954 index_search(struct pine *state, MAILSTREAM *stream, int command_line, MSGNO_S *msgmap)
2955 {
2956 int rc, select_all = 0, flags, prefetch, we_turned_on = 0;
2957 long i, sorted_msg, selected = 0L;
2958 char prompt[MAX_SEARCH+50], new_string[MAX_SEARCH+1];
2959 char buf[MAX_SCREEN_COLS+1], *p;
2960 HelpType help;
2961 char search_string[MAX_SEARCH+1];
2962 ICE_S *ice, *ic;
2963 static HISTORY_S *history = NULL;
2964 static ESCKEY_S header_search_key[] = { {0, 0, NULL, NULL },
2965 {ctrl('Y'), 10, "^Y", N_("First Msg")},
2966 {ctrl('V'), 11, "^V", N_("Last Msg")},
2967 {KEY_UP, 30, "", ""},
2968 {KEY_DOWN, 31, "", ""},
2969 {-1, 0, NULL, NULL} };
2970 #define KU_IS (3) /* index of KEY_UP */
2971 #define PREFETCH_THIS_MANY_LINES (50)
2972
2973 init_hist(&history, HISTSIZE);
2974 search_string[0] = '\0';
2975 if((p = get_prev_hist(history, "", 0, NULL)) != NULL){
2976 strncpy(search_string, p, sizeof(search_string));
2977 search_string[sizeof(search_string)-1] = '\0';
2978 }
2979
2980 dprint((4, "\n - search headers - \n"));
2981
2982 if(!any_messages(msgmap, NULL, "to search")){
2983 return;
2984 }
2985 else if(mn_total_cur(msgmap) > 1L){
2986 q_status_message1(SM_ORDER, 0, 2, "%s msgs selected; Can't search",
2987 comatose(mn_total_cur(msgmap)));
2988 return;
2989 }
2990 else
2991 sorted_msg = mn_get_cur(msgmap);
2992
2993 help = NO_HELP;
2994 new_string[0] = '\0';
2995
2996 while(1) {
2997 snprintf(prompt, sizeof(prompt), _("Word to search for [%s] : "), search_string);
2998
2999 if(F_ON(F_ENABLE_AGG_OPS, ps_global)){
3000 header_search_key[0].ch = ctrl('X');
3001 header_search_key[0].rval = 12;
3002 header_search_key[0].name = "^X";
3003 header_search_key[0].label = N_("Select Matches");
3004 }
3005 else{
3006 header_search_key[0].ch = header_search_key[0].rval = 0;
3007 header_search_key[0].name = header_search_key[0].label = NULL;
3008 }
3009
3010 /*
3011 * 2 is really 1 because there will be one real entry and
3012 * one entry of "" because of the get_prev_hist above.
3013 */
3014 if(items_in_hist(history) > 2){
3015 header_search_key[KU_IS].name = HISTORY_UP_KEYNAME;
3016 header_search_key[KU_IS].label = HISTORY_KEYLABEL;
3017 header_search_key[KU_IS+1].name = HISTORY_DOWN_KEYNAME;
3018 header_search_key[KU_IS+1].label = HISTORY_KEYLABEL;
3019 }
3020 else{
3021 header_search_key[KU_IS].name = "";
3022 header_search_key[KU_IS].label = "";
3023 header_search_key[KU_IS+1].name = "";
3024 header_search_key[KU_IS+1].label = "";
3025 }
3026
3027 flags = OE_APPEND_CURRENT | OE_KEEP_TRAILING_SPACE;
3028
3029 rc = optionally_enter(new_string, command_line, 0, sizeof(new_string),
3030 prompt, header_search_key, help, &flags);
3031
3032 if(rc == 3) {
3033 help = (help != NO_HELP) ? NO_HELP :
3034 F_ON(F_ENABLE_AGG_OPS, ps_global) ? h_os_index_whereis_agg
3035 : h_os_index_whereis;
3036 continue;
3037 }
3038 else if(rc == 10){
3039 q_status_message(SM_ORDER, 0, 3, _("Searched to First Message."));
3040 if(any_lflagged(msgmap, MN_HIDE | MN_CHID)){
3041 do{
3042 selected = sorted_msg;
3043 mn_dec_cur(stream, msgmap, MH_NONE);
3044 sorted_msg = mn_get_cur(msgmap);
3045 }
3046 while(selected != sorted_msg);
3047 }
3048 else
3049 sorted_msg = (mn_get_total(msgmap) > 0L) ? 1L : 0L;
3050
3051 mn_set_cur(msgmap, sorted_msg);
3052 return;
3053 }
3054 else if(rc == 11){
3055 q_status_message(SM_ORDER, 0, 3, _("Searched to Last Message."));
3056 if(any_lflagged(msgmap, MN_HIDE | MN_CHID)){
3057 do{
3058 selected = sorted_msg;
3059 mn_inc_cur(stream, msgmap, MH_NONE);
3060 sorted_msg = mn_get_cur(msgmap);
3061 }
3062 while(selected != sorted_msg);
3063 }
3064 else
3065 sorted_msg = mn_get_total(msgmap);
3066
3067 mn_set_cur(msgmap, sorted_msg);
3068 return;
3069 }
3070 else if(rc == 12){
3071 select_all = 1;
3072 break;
3073 }
3074 else if(rc == 30){
3075 if((p = get_prev_hist(history, new_string, 0, NULL)) != NULL){
3076 strncpy(new_string, p, sizeof(new_string));
3077 new_string[sizeof(new_string)-1] = '\0';
3078 }
3079 else
3080 Writechar(BELL, 0);
3081
3082 continue;
3083 }
3084 else if(rc == 31){
3085 if((p = get_next_hist(history, new_string, 0, NULL)) != NULL){
3086 strncpy(new_string, p, sizeof(new_string));
3087 new_string[sizeof(new_string)-1] = '\0';
3088 }
3089 else
3090 Writechar(BELL, 0);
3091
3092 continue;
3093 }
3094
3095 if(rc != 4){ /* 4 is redraw */
3096 save_hist(history, new_string, 0, NULL);
3097 break;
3098 }
3099 }
3100
3101 if(rc == 1 || (new_string[0] == '\0' && search_string[0] == '\0')) {
3102 cmd_cancelled(_("Search"));
3103 return;
3104 }
3105
3106 if(new_string[0] == '\0'){
3107 strncpy(new_string, search_string, sizeof(new_string));
3108 new_string[sizeof(new_string)-1] = '\0';
3109 }
3110
3111 strncpy(search_string, new_string, sizeof(search_string));
3112 search_string[sizeof(search_string)-1] = '\0';
3113
3114 we_turned_on = intr_handling_on();
3115
3116 prefetch = 0;
3117 for(i = sorted_msg + ((select_all)?0:1);
3118 i <= mn_get_total(msgmap) && !ps_global->intr_pending;
3119 i++){
3120 if(msgline_hidden(stream, msgmap, i, 0))
3121 continue;
3122
3123 if(prefetch <= 0)
3124 prefetch = PREFETCH_THIS_MANY_LINES;
3125
3126 ic = build_header_work(state, stream, msgmap, i, i, prefetch--, NULL);
3127
3128 ice = (ic && THRD_INDX() && ic->tice) ? ic->tice : ic;
3129
3130 if(srchstr(simple_index_line(buf, sizeof(buf), ice, i),
3131 search_string)){
3132 selected++;
3133 if(select_all)
3134 set_lflag(stream, msgmap, i, MN_SLCT, 1);
3135 else
3136 break;
3137 }
3138 }
3139
3140 prefetch = 0;
3141 if(i > mn_get_total(msgmap)){
3142 for(i = 1; i < sorted_msg && !ps_global->intr_pending; i++){
3143 if(msgline_hidden(stream, msgmap, i, 0))
3144 continue;
3145
3146 if(prefetch <= 0)
3147 prefetch = PREFETCH_THIS_MANY_LINES;
3148
3149 ic = build_header_work(state, stream, msgmap, i, i, prefetch--, NULL);
3150
3151 ice = (ic && THRD_INDX() && ic->tice) ? ic->tice : ic;
3152
3153 if(srchstr(simple_index_line(buf, sizeof(buf), ice, i),
3154 search_string)){
3155 selected++;
3156 if(select_all)
3157 set_lflag(stream, msgmap, i, MN_SLCT, 1);
3158 else
3159 break;
3160 }
3161 }
3162 }
3163
3164 /* search current line */
3165 if(!select_all && !selected){
3166 i = sorted_msg;
3167 if(!msgline_hidden(stream, msgmap, i, 0)){
3168
3169 ic = build_header_work(state, stream, msgmap, i, i, 1, NULL);
3170
3171 ice = (ic && THRD_INDX() && ic->tice) ? ic->tice : ic;
3172
3173 if(srchstr(simple_index_line(buf, sizeof(buf), ice, i),
3174 search_string)){
3175 selected++;
3176 }
3177 }
3178 }
3179
3180 if(ps_global->intr_pending){
3181 q_status_message1(SM_ORDER, 0, 3, _("Search cancelled.%s"),
3182 select_all ? _(" Selected set may be incomplete."):"");
3183 }
3184 else if(select_all){
3185 if(selected
3186 && any_lflagged(msgmap, MN_SLCT) > 0L
3187 && !any_lflagged(msgmap, MN_HIDE)
3188 && F_ON(F_AUTO_ZOOM, state))
3189 (void) zoom_index(state, stream, msgmap, MN_SLCT);
3190
3191 q_status_message1(SM_ORDER, 0, 3, _("%s messages found matching word"),
3192 long2string(selected));
3193 }
3194 else if(selected){
3195 q_status_message1(SM_ORDER, 0, 3, _("Word found%s"),
3196 (i < sorted_msg) ? _(". Search wrapped to beginning") :
3197 (i == sorted_msg) ? _(". Current line contains only match") : "");
3198 mn_set_cur(msgmap, i);
3199 }
3200 else
3201 q_status_message(SM_ORDER, 0, 3, _("Word not found"));
3202
3203 if(we_turned_on)
3204 intr_handling_off();
3205 }
3206
3207
3208 /*
3209 * Original idea from Stephen Casner <casner@acm.org>.
3210 *
3211 * Apply the appropriate reverse color transformation to the given
3212 * color pair and return a new color pair. The caller should free the
3213 * color pair.
3214 *
3215 */
3216 COLOR_PAIR *
3217 apply_rev_color(COLOR_PAIR *cp, int style)
3218 {
3219 COLOR_PAIR *rc = pico_get_rev_color();
3220
3221 if(rc){
3222 if(style == IND_COL_REV){
3223 /* just use Reverse color regardless */
3224 return(new_color_pair(rc->fg, rc->bg));
3225 }
3226 else if(style == IND_COL_FG){
3227 /*
3228 * If changing to Rev fg is readable and different
3229 * from what it already is, do it.
3230 */
3231 if(strcmp(rc->fg, cp->bg) && strcmp(rc->fg, cp->fg))
3232 return(new_color_pair(rc->fg, cp->bg));
3233 }
3234 else if(style == IND_COL_BG){
3235 /*
3236 * If changing to Rev bg is readable and different
3237 * from what it already is, do it.
3238 */
3239 if(strcmp(rc->bg, cp->fg) && strcmp(rc->bg, cp->bg))
3240 return(new_color_pair(cp->fg, rc->bg));
3241 }
3242 else if(style == IND_COL_FG_NOAMBIG){
3243 /*
3244 * If changing to Rev fg is readable, different
3245 * from what it already is, and not the same as
3246 * the Rev color, do it.
3247 */
3248 if(strcmp(rc->fg, cp->bg) && strcmp(rc->fg, cp->fg) &&
3249 strcmp(rc->bg, cp->bg))
3250 return(new_color_pair(rc->fg, cp->bg));
3251 }
3252 else if(style == IND_COL_BG_NOAMBIG){
3253 /*
3254 * If changing to Rev bg is readable, different
3255 * from what it already is, and not the same as
3256 * the Rev color, do it.
3257 */
3258 if(strcmp(rc->bg, cp->fg) && strcmp(rc->bg, cp->bg) &&
3259 strcmp(rc->fg, cp->fg))
3260 return(new_color_pair(cp->fg, rc->bg));
3261 }
3262 }
3263
3264 /* come here for IND_COL_FLIP and for the cases which fail the tests */
3265 return(new_color_pair(cp->bg, cp->fg)); /* flip the colors */
3266 }
3267
3268
3269
3270 #ifdef _WINDOWS
3271
3272 /*----------------------------------------------------------------------
3273 Callback to get the text of the current message. Used to display
3274 a message in an alternate window.
3275
3276 Args: cmd - what type of scroll operation.
3277 text - filled with pointer to text.
3278 l - length of text.
3279 style - Returns style of text. Can be:
3280 GETTEXT_TEXT - Is a pointer to text with CRLF deliminated
3281 lines
3282 GETTEXT_LINES - Is a pointer to NULL terminated array of
3283 char *. Each entry points to a line of
3284 text.
3285
3286 this implementation always returns GETTEXT_TEXT.
3287
3288 Returns: TRUE - did the scroll operation.
3289 FALSE - was not able to do the scroll operation.
3290 ----*/
3291 int
3292 index_scroll_callback (cmd, scroll_pos)
3293 int cmd;
3294 long scroll_pos;
3295 {
3296 int paint = TRUE;
3297
3298 switch (cmd) {
3299 case MSWIN_KEY_SCROLLUPLINE:
3300 paint = index_scroll_up (scroll_pos);
3301 break;
3302
3303 case MSWIN_KEY_SCROLLDOWNLINE:
3304 paint = index_scroll_down (scroll_pos);
3305 break;
3306
3307 case MSWIN_KEY_SCROLLUPPAGE:
3308 paint = index_scroll_up (current_index_state->lines_per_page);
3309 break;
3310
3311 case MSWIN_KEY_SCROLLDOWNPAGE:
3312 paint = index_scroll_down (current_index_state->lines_per_page);
3313 break;
3314
3315 case MSWIN_KEY_SCROLLTO:
3316 /* Normalize msgno in zoomed case */
3317 if(any_lflagged(ps_global->msgmap, MN_HIDE | MN_CHID)){
3318 long n, x;
3319
3320 for(n = 1L, x = 0;
3321 x < scroll_pos && n < mn_get_total(ps_global->msgmap);
3322 n++)
3323 if(!msgline_hidden(ps_global->mail_stream, ps_global->msgmap,
3324 n, 0))
3325 x++;
3326
3327 scroll_pos = n - 1; /* list-position --> message number */
3328 }
3329
3330 paint = index_scroll_to_pos (scroll_pos + 1);
3331 break;
3332 }
3333
3334 if(paint){
3335 mswin_beginupdate();
3336 update_titlebar_message();
3337 update_titlebar_status();
3338 redraw_index_body();
3339 mswin_endupdate();
3340 }
3341
3342 return(paint);
3343 }
3344
3345
3346 /*----------------------------------------------------------------------
3347 MSWin scroll callback to get the text of the current message
3348
3349 Args: title - title for new window
3350 text -
3351 l -
3352 style -
3353
3354 Returns: TRUE - got the requested text
3355 FALSE - was not able to get the requested text
3356 ----*/
3357 int
3358 index_gettext_callback(title, titlelen, text, l, style)
3359 char *title;
3360 size_t titlelen;
3361 void **text;
3362 long *l;
3363 int *style;
3364 {
3365 int rv = 0;
3366 ENVELOPE *env;
3367 BODY *body;
3368 STORE_S *so;
3369 gf_io_t pc;
3370
3371 if(mn_get_total(ps_global->msgmap) > 0L
3372 && (so = so_get(CharStar, NULL, WRITE_ACCESS))){
3373 gf_set_so_writec(&pc, so);
3374
3375 if((env = pine_mail_fetchstructure(ps_global->mail_stream,
3376 mn_m2raw(ps_global->msgmap,
3377 mn_get_cur(ps_global->msgmap)),
3378 &body))
3379 && format_message(mn_m2raw(ps_global->msgmap,
3380 mn_get_cur(ps_global->msgmap)),
3381 env, body, NULL, FM_NEW_MESS, pc)){
3382 snprintf(title, titlelen, "Folder %s -- Message %ld of %ld",
3383 strsquish(tmp_20k_buf + 500, SIZEOF_20KBUF-500, ps_global->cur_folder, 50),
3384 mn_get_cur(ps_global->msgmap),
3385 mn_get_total(ps_global->msgmap));
3386 title[titlelen-1] = '\0';
3387 *text = so_text(so);
3388 *l = strlen((char *)so_text(so));
3389 *style = GETTEXT_TEXT;
3390
3391 /* free alloc'd so, but preserve the text passed back to caller */
3392 so->txt = (void *) NULL;
3393 rv = 1;
3394 }
3395
3396 gf_clear_so_writec(so);
3397 so_give(&so);
3398 }
3399
3400 return(rv);
3401 }
3402
3403
3404 /*
3405 *
3406 */
3407 int
3408 index_sort_callback(set, order)
3409 int set;
3410 long order;
3411 {
3412 int i = 0;
3413
3414 if(set){
3415 sort_folder(ps_global->mail_stream, ps_global->msgmap,
3416 order & 0x000000ff,
3417 (order & 0x00000100) != 0, SRT_VRB);
3418 mswin_beginupdate();
3419 update_titlebar_message();
3420 update_titlebar_status();
3421 redraw_index_body();
3422 mswin_endupdate();
3423 flush_status_messages(1);
3424 }
3425 else{
3426 i = (int) mn_get_sort(ps_global->msgmap);
3427 if(mn_get_revsort(ps_global->msgmap))
3428 i |= 0x0100;
3429 }
3430
3431 return(i);
3432 }
3433
3434
3435 /*
3436 *
3437 */
3438 void
3439 index_popup(IndexType style, MAILSTREAM *stream, MSGNO_S *msgmap, int full)
3440 {
3441 int n = 0;
3442 int view_in_new_wind_index = -1;
3443 long rawno;
3444 MESSAGECACHE *mc;
3445 MPopup view_index_popup[32];
3446 struct key_menu *km = (style == ThreadIndex)
3447 ? &thread_keymenu
3448 : (ps_global->mail_stream != stream)
3449 ? &simple_index_keymenu
3450 : &index_keymenu;
3451
3452 /*
3453 * Loosely follow the logic in do_index_border to figure
3454 * out which commands to show.
3455 */
3456
3457 if(full){
3458 if(km != &simple_index_keymenu){
3459 view_index_popup[n].type = tQueue;
3460 view_index_popup[n].label.string = (km == &thread_keymenu)
3461 ? "&View Thread" : "&View";
3462 view_index_popup[n].label.style = lNormal;
3463 view_index_popup[n++].data.val = 'V';
3464 }
3465
3466 if(km == &index_keymenu){
3467 view_in_new_wind_index = n;
3468 view_index_popup[n].type = tIndex;
3469 view_index_popup[n].label.style = lNormal;
3470 view_index_popup[n++].label.string = "View in New Window";
3471 }
3472
3473 if(km != &simple_index_keymenu)
3474 view_index_popup[n++].type = tSeparator;
3475
3476 if(km == &thread_keymenu){
3477 view_index_popup[n].type = tQueue;
3478 view_index_popup[n].label.string = "&Delete Thread";
3479 view_index_popup[n].label.style = lNormal;
3480 view_index_popup[n++].data.val = 'D';
3481
3482 view_index_popup[n].type = tQueue;
3483 view_index_popup[n].label.string = "&UnDelete Thread";
3484 view_index_popup[n].label.style = lNormal;
3485 view_index_popup[n++].data.val = 'U';
3486 }
3487 else{
3488 /* Make "delete/undelete" item sensitive */
3489 mc = ((rawno = mn_m2raw(msgmap, mn_get_cur(msgmap))) > 0L
3490 && stream && rawno <= stream->nmsgs)
3491 ? mail_elt(stream, rawno) : NULL;
3492 view_index_popup[n].type = tQueue;
3493 view_index_popup[n].label.style = lNormal;
3494 if(mc && mc->deleted){
3495 view_index_popup[n].label.string = "&Undelete";
3496 view_index_popup[n++].data.val = 'U';
3497 }
3498 else{
3499 view_index_popup[n].label.string = "&Delete";
3500 view_index_popup[n++].data.val = 'D';
3501 }
3502 }
3503
3504 if(km == &index_keymenu && F_ON(F_ENABLE_FLAG, ps_global)){
3505 view_index_popup[n].type = tSubMenu;
3506 view_index_popup[n].label.string = "Flag";
3507 view_index_popup[n++].data.submenu = flag_submenu(mc);
3508 }
3509
3510 if(km == &simple_index_keymenu){
3511 view_index_popup[n].type = tQueue;
3512 view_index_popup[n].label.style = lNormal;
3513 view_index_popup[n].label.string = "&Select";
3514 view_index_popup[n++].data.val = 'S';
3515 }
3516 else{
3517 view_index_popup[n].type = tQueue;
3518 view_index_popup[n].label.style = lNormal;
3519 view_index_popup[n].label.string = (km == &thread_keymenu)
3520 ? "&Save Thread" : "&Save";
3521 view_index_popup[n++].data.val = 'S';
3522
3523 view_index_popup[n].type = tQueue;
3524 view_index_popup[n].label.style = lNormal;
3525 view_index_popup[n].label.string = (km == &thread_keymenu)
3526 ? "&Export Thread" : "&Export";
3527 view_index_popup[n++].data.val = 'E';
3528
3529 view_index_popup[n].type = tQueue;
3530 view_index_popup[n].label.style = lNormal;
3531 view_index_popup[n].label.string = "Print";
3532 view_index_popup[n++].data.val = '%';
3533
3534 view_index_popup[n].type = tQueue;
3535 view_index_popup[n].label.style = lNormal;
3536 view_index_popup[n].label.string = (km == &thread_keymenu)
3537 ? "&Reply To Thread" : "&Reply";
3538 view_index_popup[n++].data.val = 'R';
3539
3540 view_index_popup[n].type = tQueue;
3541 view_index_popup[n].label.style = lNormal;
3542 view_index_popup[n].label.string = (km == &thread_keymenu)
3543 ? "&Forward Thread" : "&Forward";
3544 view_index_popup[n++].data.val = 'F';
3545
3546 if(F_ON(F_ENABLE_BOUNCE, ps_global)){
3547 view_index_popup[n].type = tQueue;
3548 view_index_popup[n].label.style = lNormal;
3549 view_index_popup[n].label.string = (km == &thread_keymenu)
3550 ? "&Bounce Thread" : "&Bounce";
3551 view_index_popup[n++].data.val = 'B';
3552 }
3553
3554 view_index_popup[n].type = tQueue;
3555 view_index_popup[n].label.style = lNormal;
3556 view_index_popup[n].label.string = "&Take Addresses";
3557 view_index_popup[n++].data.val = 'T';
3558
3559 if(F_ON(F_ENABLE_AGG_OPS, ps_global)){
3560 view_index_popup[n].type = tQueue;
3561 view_index_popup[n].label.style = lNormal;
3562 view_index_popup[n].label.string = "[Un]Select Current";
3563 view_index_popup[n++].data.val = ':';
3564 }
3565 }
3566
3567 view_index_popup[n].type = tQueue;
3568 view_index_popup[n].label.style = lNormal;
3569 view_index_popup[n].label.string = "&WhereIs";
3570 view_index_popup[n++].data.val = 'W';
3571
3572 view_index_popup[n++].type = tSeparator;
3573 }
3574
3575 if(km == &simple_index_keymenu){
3576 view_index_popup[n].type = tQueue;
3577 view_index_popup[n].label.style = lNormal;
3578 view_index_popup[n].label.string = "&Exit Select";
3579 view_index_popup[n++].data.val = 'E';
3580 }
3581 else if(km == &index_keymenu && THREADING() && sp_viewing_a_thread(stream)){
3582 view_index_popup[n].type = tQueue;
3583 view_index_popup[n].label.style = lNormal;
3584 view_index_popup[n].label.string = "Thread Index";
3585 view_index_popup[n++].data.val = '<';
3586 }
3587 else{
3588 view_index_popup[n].type = tQueue;
3589 view_index_popup[n].label.style = lNormal;
3590 view_index_popup[n].label.string = "Folder &List";
3591 view_index_popup[n++].data.val = '<';
3592 }
3593
3594 view_index_popup[n].type = tQueue;
3595 view_index_popup[n].label.style = lNormal;
3596 view_index_popup[n].label.string = "&Main Menu";
3597 view_index_popup[n++].data.val = 'M';
3598
3599 view_index_popup[n].type = tTail;
3600
3601 if(mswin_popup(view_index_popup) == view_in_new_wind_index
3602 && view_in_new_wind_index >= 0)
3603 view_in_new_window();
3604 }
3605
3606
3607 char *
3608 pcpine_help_index(title)
3609 char *title;
3610 {
3611 /*
3612 * Title is size 256 in pico. Put in args.
3613 */
3614 if(title)
3615 strncpy(title, "Alpine MESSAGE INDEX Help", 256);
3616
3617 return(pcpine_help(h_mail_index));
3618 }
3619
3620 char *
3621 pcpine_help_index_simple(title)
3622 char *title;
3623 {
3624 /*
3625 * Title is size 256 in pico. Put in args.
3626 */
3627 if(title)
3628 strncpy(title, "Alpine SELECT MESSAGE Help", 256);
3629
3630 return(pcpine_help(h_simple_index));
3631 }
3632
3633
3634 #include "../pico/osdep/mswin_tw.h"
3635
3636
3637 void
3638 view_in_new_window(void)
3639 {
3640 char title[GETTEXT_TITLELEN+1];
3641 void *text;
3642 long len;
3643 int format;
3644 MSWIN_TEXTWINDOW *mswin_tw = NULL;
3645
3646 /* Launch text in alt window. */
3647 if(index_gettext_callback(title, sizeof (title), &text, &len, &format)){
3648 if(format == GETTEXT_TEXT)
3649 mswin_tw = mswin_displaytext(title, text, (size_t) len, NULL,
3650 NULL, MSWIN_DT_USEALTWINDOW);
3651 else if(format == GETTEXT_LINES)
3652 mswin_tw = mswin_displaytext(title, NULL, 0, text,
3653 NULL, MSWIN_DT_USEALTWINDOW);
3654
3655 if(mswin_tw != NULL)
3656 mswin_set_readonly(mswin_tw, FALSE);
3657 }
3658 }
3659
3660 #endif /* _WINDOWS */
Alpine is a program to manage e-mail