a2b88c811d79fa6fad31a3454e6cdd7b50176e86
[apps/madmutt.git] / lib-ui / curs_lib.c
1 /*
2  * Copyright notice from original mutt:
3  * Copyright (C) 1996-2002 Michael R. Elkins <me@mutt.org>
4  * Copyright (C) 2004 g10 Code GmbH
5  *
6  * Parts were written/modified by:
7  * Nico Golde <nico@ngolde.de>
8  *
9  * This file is part of mutt-ng, see http://www.muttng.org/.
10  * It's licensed under the GNU General Public License,
11  * please see the file GPL in the top level source directory.
12  */
13
14 #include <lib-ui/lib-ui.h>
15
16 #include <langinfo.h>
17 #include <termios.h>
18
19 #include <lib-lua/lib-lua.h>
20 #include <lib-sys/unix.h>
21 #include <lib-sys/mutt_signal.h>
22
23 #include "menu.h"
24 #include "enter.h"
25
26 #include "mutt.h"
27 #include "pager.h"
28 #include "charset.h"
29 #include "madtty.h"
30
31 /* not possible to unget more than one char under some curses libs, and it
32  * is impossible to unget function keys in SLang, so roll our own input
33  * buffering routines.
34  */
35 ssize_t UngetCount = 0;
36 static ssize_t UngetBufLen = 0;
37 static event_t *KeyEvent;
38
39 event_t mutt_getch (void)
40 {
41   int ch;
42   event_t err = { -1, OP_NULL }, ret;
43
44   if (!option (OPTUNBUFFEREDINPUT) && UngetCount)
45     return (KeyEvent[--UngetCount]);
46
47   SigInt = 0;
48
49   mutt_allow_interrupt (1);
50   ch = getch();
51   mutt_allow_interrupt (0);
52
53   if (SigInt)
54     mutt_query_exit ();
55
56   if (ch == ERR)
57     return err;
58
59   ret.ch = ch;
60   ret.op = 0;
61   return (ch == ctrl ('G') ? err : ret);
62 }
63
64 #ifndef waddnwstr
65 int waddwch(WINDOW *win, wchar_t wc)
66 {
67     char buf[MB_LEN_MAX * 2];
68     mbstate_t mbstate;
69     ssize_t n1, n2;
70
71     p_clear(&mbstate, 1);
72     if ((n1 = wcrtomb(buf, wc, &mbstate)) == -1
73     ||  (n2 = wcrtomb(buf + n1, 0, &mbstate)) == -1)
74         return -1;                  /* ERR */
75     return waddstr(win, buf);
76 }
77 #endif
78
79
80 int _mutt_get_field ( const char *field, char *buf, ssize_t buflen,
81                      int complete, int multiple, char ***files, int *numfiles)
82 {
83   int ret;
84   int x, y;
85
86   ENTER_STATE *es = mutt_new_enter_state ();
87
88   do {
89     CLEARLINE(stdscr, LINES - 1);
90     waddstr (stdscr, field);
91     mutt_refresh ();
92     getyx (stdscr, y, x);
93     ret = _mutt_enter_string(buf, buflen, y, x, complete, multiple, files,
94                              numfiles, es);
95   } while (ret == 1);
96   CLEARLINE(stdscr, LINES - 1);
97   mutt_free_enter_state (&es);
98
99   return (ret);
100 }
101
102 int mutt_get_field_unbuffered (char *msg, char *buf, ssize_t buflen, int flags)
103 {
104   int rc;
105
106   set_option (OPTUNBUFFEREDINPUT);
107   rc = mutt_get_field (msg, buf, buflen, flags);
108   unset_option (OPTUNBUFFEREDINPUT);
109
110   return (rc);
111 }
112
113 void mutt_clear_error (void)
114 {
115   Errorbuf[0] = 0;
116   if (!option (OPTNOCURSES))
117     CLEARLINE(stdscr, LINES - 1);
118 }
119
120 void mutt_edit_file(const char *data)
121 {
122   char cmd[LONG_STRING];
123
124   mutt_endwin (NULL);
125   m_quotefile_fmt(cmd, sizeof (cmd), mod_core.editor, data);
126   if (mutt_system (cmd) == -1)
127     mutt_error (_("Error running \"%s\"!"), cmd);
128   keypad (stdscr, TRUE);
129   clearok (stdscr, TRUE);
130 }
131
132 int mutt_yesorno (const char *msg, int def)
133 {
134   event_t ch;
135   const char *yes = _("yes");
136   const char *no = _("no");
137   char *answer_string;
138   ssize_t answer_string_len;
139   char *expr;
140   regex_t reyes;
141   regex_t reno;
142   int reyes_ok;
143   int reno_ok;
144   char answer[2];
145
146   answer[1] = 0;
147
148   reyes_ok = (expr = nl_langinfo (YESEXPR)) && expr[0] == '^' &&
149     !regcomp (&reyes, expr, REG_NOSUB | REG_EXTENDED);
150   reno_ok = (expr = nl_langinfo (NOEXPR)) && expr[0] == '^' &&
151     !regcomp (&reno, expr, REG_NOSUB | REG_EXTENDED);
152
153   CLEARLINE(stdscr, LINES - 1);
154
155   /*
156    * In order to prevent the default answer to the question to wrapped
157    * around the screen in the even the question is wider than the screen,
158    * ensure there is enough room for the answer and truncate the question
159    * to fit.
160    */
161   answer_string = p_new(char, getmaxx(stdscr) + 1);
162   snprintf (answer_string, getmaxx(stdscr) + 1, " ([%s]/%s): ", def == M_YES ? yes : no,
163             def == M_YES ? no : yes);
164   answer_string_len = m_strlen(answer_string);
165   wprintw (stdscr, "%.*s%s", getmaxx(stdscr) - answer_string_len, msg, answer_string);
166   p_delete(&answer_string);
167
168   for (;;) {
169     mutt_refresh ();
170     ch = mutt_getch ();
171     if (CI_is_return (ch.ch))
172       break;
173     if (ch.ch == -1) {
174       def = -1;
175       break;
176     }
177
178     answer[0] = ch.ch;
179     if (reyes_ok ? (regexec (&reyes, answer, 0, 0, 0) == 0) : tolower (ch.ch) == *yes)
180     {
181       def = M_YES;
182       break;
183     }
184     else if (
185               reno_ok ? (regexec (&reno, answer, 0, 0, 0) == 0) :
186               (tolower (ch.ch) == *no)) {
187       def = M_NO;
188       break;
189     } else {
190       BEEP ();
191     }
192   }
193
194   if (reyes_ok)
195     regfree (&reyes);
196   if (reno_ok)
197     regfree (&reno);
198
199   if (def != -1) {
200     waddstr (stdscr, (char *) (def == M_YES ? yes : no));
201     mutt_refresh ();
202   }
203   CLEARLINE(stdscr, LINES - 1);
204   return (def);
205 }
206
207 /* this function is called when the user presses the abort key */
208 void mutt_query_exit (void)
209 {
210   mutt_flushinp ();
211   curs_set (1);
212   if (Timeout)
213     wtimeout (stdscr, -1);               /* restore blocking operation */
214   if (mutt_yesorno (_("Exit Madmutt?"), M_YES) == M_YES) {
215     mutt_endwin (NULL);
216     mutt_exit(1);
217   }
218   mutt_clear_error ();
219   mutt_curs_set (-1);
220   SigInt = 0;
221 }
222
223 void mutt_curses_error (const char *fmt, ...)
224 {
225   char TmpErrorbuf[STRING];
226   va_list ap;
227
228   va_start (ap, fmt);
229   vsnprintf (Errorbuf, sizeof (Errorbuf), fmt, ap);
230   va_end (ap);
231
232   mutt_format_string (TmpErrorbuf, sizeof (TmpErrorbuf),
233                       0, getmaxy(stdscr) - 2, 0, 0, Errorbuf, sizeof (Errorbuf), 0);
234   snprintf (Errorbuf, sizeof (Errorbuf), "%s", TmpErrorbuf);    /* overkill */
235
236   if (!option (OPTKEEPQUIET)) {
237     BEEP ();
238     SETCOLOR(stdscr, MT_COLOR_ERROR);
239     mvwaddstr (stdscr, LINES - 1, 0, Errorbuf);
240     wclrtoeol (stdscr);
241     SETCOLOR(stdscr, MT_COLOR_NORMAL);
242     mutt_refresh ();
243   }
244
245   set_option (OPTMSGERR);
246 }
247
248 void mutt_progress_bar (progress_t* progress, long pos) {
249   char posstr[STRING];
250
251   if (!pos) {
252     if (!NetInc)
253       mutt_message (progress->msg);
254     else {
255       if (progress->size)
256         mutt_pretty_size (progress->sizestr, sizeof (progress->sizestr),
257                           progress->size);
258       progress->pos = 0;
259     }
260   }
261
262   if (!NetInc)
263     return;
264
265   if (pos >= progress->pos + (NetInc << 10)) {
266     progress->pos = pos;
267     pos = pos / (NetInc << 10) * (NetInc << 10);
268     mutt_pretty_size (posstr, sizeof (posstr), pos);
269     if (progress->size)
270       mutt_message ("%s %s/%s", progress->msg, posstr, progress->sizestr);
271     else
272       mutt_message ("%s %s", progress->msg, posstr);
273   }
274 }
275
276 void mutt_curses_message (const char *fmt, ...)
277 {
278   char TmpErrorbuf[STRING];
279   va_list ap;
280
281   va_start (ap, fmt);
282   vsnprintf (Errorbuf, sizeof (Errorbuf), fmt, ap);
283   va_end (ap);
284
285   mutt_format_string (TmpErrorbuf, sizeof (TmpErrorbuf),
286                       0, getmaxx(stdscr) - 2, 0, 0, Errorbuf, sizeof (Errorbuf), 0);
287   snprintf (Errorbuf, sizeof (Errorbuf), "%s", TmpErrorbuf);    /* overkill */
288
289   if (!option (OPTKEEPQUIET)) {
290     SETCOLOR(stdscr, MT_COLOR_MESSAGE);
291     mvwaddstr (stdscr, LINES - 1, 0, Errorbuf);
292     wclrtoeol (stdscr);
293     SETCOLOR(stdscr, MT_COLOR_NORMAL);
294     mutt_refresh ();
295   }
296
297   unset_option (OPTMSGERR);
298 }
299
300 void mutt_show_error (void)
301 {
302   if (option (OPTKEEPQUIET))
303     return;
304
305   SETCOLOR(stdscr, option (OPTMSGERR) ? MT_COLOR_ERROR : MT_COLOR_MESSAGE);
306   CLEARLINE(stdscr, LINES - 1);
307   waddstr (stdscr, Errorbuf);
308   SETCOLOR(stdscr, MT_COLOR_NORMAL);
309 }
310
311 void curses_initialize(void)
312 {
313     initscr();
314     if (start_color() == ERR || !has_colors() || COLORS < 8)
315         mutt_exit(-1);
316     madtty_init_colors();
317     ci_start_color();
318     noecho();
319     raw();
320     keypad(stdscr, true);
321     typeahead(-1);
322     meta(stdscr, true);
323     curs_set(0);
324     ESCDELAY = 50;
325 }
326
327 /*
328  * prompts the user to enter a keystroke, and displays the octal value back
329  * to the user.
330  */
331 void mutt_what_key (void)
332 {
333   int ch;
334
335   mvwprintw(stdscr, LINES - 1, 0, _("Enter keys (^G to abort): "));
336   do {
337     ch = getch();
338     if (ch != ERR && ch != ctrl ('G')) {
339       mutt_message (_("Char = %s, Octal = %o, Decimal = %d"),
340                     km_keyname (ch), ch, ch);
341     }
342   }
343   while (ch != ERR && ch != ctrl ('G'));
344
345   mutt_flushinp ();
346 }
347
348 int mutt_any_key_to_continue (const char *s)
349 {
350   struct termios t;
351   struct termios old;
352   int f, ch;
353
354   f = open ("/dev/tty", O_RDONLY);
355   tcgetattr (f, &t);
356   memcpy ((void *) &old, (void *) &t, sizeof (struct termios)); /* save original state */
357   t.c_lflag &= ~(ICANON | ECHO);
358   t.c_cc[VMIN] = 1;
359   t.c_cc[VTIME] = 0;
360   tcsetattr (f, TCSADRAIN, &t);
361   fflush (stdout);
362   if (s)
363     fputs (s, stdout);
364   else
365     fputs (_("Press any key to continue..."), stdout);
366   fflush (stdout);
367   ch = fgetc (stdin);
368   fflush (stdin);
369   tcsetattr (f, TCSADRAIN, &old);
370   close (f);
371   fputs ("\r\n", stdout);
372   mutt_clear_error ();
373   return (ch);
374 }
375
376 int _mutt_enter_fname (const char *prompt, char *buf, ssize_t blen,
377                        int *redraw, int buffy, int multiple, char ***files,
378                        int *numfiles)
379 {
380   event_t ch;
381
382   mvwaddstr(stdscr, LINES - 1, 0, (char *) prompt);
383   waddstr(stdscr, _(" ('?' for list): "));
384   if (buf[0])
385     waddstr (stdscr, buf);
386   wclrtoeol (stdscr);
387   mutt_refresh ();
388
389   ch = mutt_getch ();
390   if (ch.ch == -1) {
391     CLEARLINE(stdscr, LINES - 1);
392     return (-1);
393   }
394   else if (ch.ch == '?') {
395     mutt_refresh ();
396     buf[0] = 0;
397     mutt_select_file (buf, blen, M_SEL_FOLDER | (multiple ? M_SEL_MULTI : 0),
398                       files, numfiles);
399     *redraw = REDRAW_FULL;
400   }
401   else {
402     char *pc = p_new(char, m_strlen(prompt) + 3);
403
404     sprintf(pc, "%s: ", prompt);
405     mutt_ungetch (ch.op ? 0 : ch.ch, ch.op ? ch.op : 0);
406     if (_mutt_get_field
407         (pc, buf, blen, (buffy ? M_EFILE : M_FILE) | M_CLEAR, multiple, files,
408          numfiles)
409         != 0)
410       buf[0] = 0;
411     MAYBE_REDRAW (*redraw);
412     p_delete(&pc);
413   }
414
415   return 0;
416 }
417
418 void mutt_ungetch (int ch, int op)
419 {
420   event_t tmp;
421
422   tmp.ch = ch;
423   tmp.op = op;
424
425   if (UngetCount >= UngetBufLen)
426     p_realloc(&KeyEvent, UngetBufLen += 128);
427
428   KeyEvent[UngetCount++] = tmp;
429 }
430
431 void mutt_flushinp (void)
432 {
433   UngetCount = 0;
434   flushinp ();
435 }
436
437 /* The argument can take 3 values:
438  * -1: restore the value of the last call
439  *  0: make the cursor invisible
440  *  1: make the cursor visible
441  */
442 void mutt_curs_set (int cursor)
443 {
444   static int SavedCursor = 1;
445
446   if (cursor < 0)
447     cursor = SavedCursor;
448   else
449     SavedCursor = cursor;
450
451   if (curs_set (cursor) == ERR) {
452     if (cursor == 1)            /* cnorm */
453       curs_set (2);             /* cvvis */
454   }
455 }
456
457 int mutt_multi_choice (const char *prompt, const char *letters)
458 {
459   event_t ch;
460   int choice;
461   char *p;
462
463   mvwaddstr (stdscr, LINES - 1, 0, prompt);
464   wclrtoeol (stdscr);
465   for (;;) {
466     mutt_refresh ();
467     ch = mutt_getch ();
468     if (ch.ch == -1 || CI_is_return (ch.ch)) {
469       choice = -1;
470       break;
471     }
472     else {
473       p = strchr (letters, ch.ch);
474       if (p) {
475         choice = p - letters + 1;
476         break;
477       }
478       else if (ch.ch <= '9' && ch.ch > '0') {
479         choice = ch.ch - '0';
480         if (choice <= m_strlen(letters))
481           break;
482       }
483     }
484     BEEP ();
485   }
486   CLEARLINE(stdscr, LINES - 1);
487   mutt_refresh ();
488   return choice;
489 }
490
491 ssize_t mutt_pretty_size(char *s, ssize_t len, ssize_t n)
492 {
493     if (n == 0)
494         return m_strcpy(s, len, "0K");
495
496     if (n < 10189)           /* 0.1K - 9.9K */
497         return snprintf(s, len, "%3.1fK", (n < 103) ? 0.1 : n / 1024.0);
498
499     if (n < 1023949)         /* 10K - 999K */
500         /* 51 is magic which causes 10189/10240 to be rounded up to 10 */
501         return snprintf(s, len, "%ldK", (n + 51) / 1024);
502
503     if (n < 10433332)        /* 1.0M - 9.9M */
504         return snprintf(s, len, "%3.1fM", n / 1048576.0);
505
506     /* (10433332 + 52428) / 1048576 = 10 */
507     return snprintf (s, len, "%ldM", (n + 52428) / 1048576);
508 }
509
510 /*
511  * This formats a string, a bit like
512  * snprintf (dest, destlen, "%-*.*s", min_width, max_width, s),
513  * except that the widths refer to the number of character cells
514  * when printed.
515  */
516
517 void mutt_format_string (char *dest, ssize_t destlen,
518                          int min_width, int max_width,
519                          int right_justify, char m_pad_char,
520                          const char *s, ssize_t n, int arboreal)
521 {
522   char *p;
523   wchar_t wc;
524   int w;
525   ssize_t k, k2;
526   char scratch[MB_LEN_MAX];
527   mbstate_t mbstate1, mbstate2;
528
529   p_clear(&mbstate1, 1);
530   p_clear(&mbstate2, 1);
531   --destlen;
532   p = dest;
533   for (; n && (k = mbrtowc (&wc, s, n, &mbstate1)); s += k, n -= k) {
534     if (k == -1 || k == -2) {
535       k = (k == -1) ? 1 : n;
536       wc = CharsetReplacement;
537     }
538     if (arboreal && wc < M_TREE_MAX)
539       w = 1;                    /* hack */
540     else {
541       if (!iswprint(wc))
542         wc = '?';
543       w = wcwidth (wc);
544     }
545     if (w >= 0) {
546       if (w > max_width || (k2 = wcrtomb (scratch, wc, &mbstate2)) > destlen)
547         break;
548       min_width -= w;
549       max_width -= w;
550       m_strncpy(p, destlen, scratch, k2);
551       p += k2;
552       destlen -= k2;
553     }
554   }
555   w = destlen < min_width ? destlen : min_width;
556   if (w <= 0)
557     *p = '\0';
558   else if (right_justify) {
559     p[w] = '\0';
560     while (--p >= dest)
561       p[w] = *p;
562     while (--w >= 0)
563       dest[w] = m_pad_char;
564   }
565   else {
566     while (--w >= 0)
567       *p++ = m_pad_char;
568     *p = '\0';
569   }
570 }
571
572 /*
573  * This formats a string rather like
574  *   snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
575  *   snprintf (dest, destlen, fmt, s);
576  * except that the numbers in the conversion specification refer to
577  * the number of character cells when printed.
578  */
579
580 static void mutt_format_s_x (char *dest, ssize_t destlen,
581                              const char *prefix, const char *s, int arboreal)
582 {
583   int right_justify = 1;
584   char *p;
585   int min_width;
586   int max_width = INT_MAX;
587
588   if (*prefix == '-')
589     ++prefix, right_justify = 0;
590   min_width = strtol (prefix, &p, 10);
591   if (*p == '.') {
592     prefix = p + 1;
593     max_width = strtol (prefix, &p, 10);
594     if (p <= prefix)
595       max_width = INT_MAX;
596   }
597
598   mutt_format_string (dest, destlen, min_width, max_width,
599                       right_justify, ' ', s, m_strlen(s), arboreal);
600 }
601
602 void mutt_format_s (char *dest, ssize_t destlen,
603                     const char *prefix, const char *s)
604 {
605   mutt_format_s_x (dest, destlen, prefix, s, 0);
606 }
607
608 void mutt_format_s_tree (char *dest, ssize_t destlen,
609                          const char *prefix, const char *s)
610 {
611   mutt_format_s_x (dest, destlen, prefix, s, 1);
612 }
613
614 /*
615  * mutt_paddstr (n, s) is almost equivalent to
616  * mutt_format_string (bigbuf, big, n, n, 0, ' ', s, big, 0), waddstr (main_w, bigbuf)
617  */
618
619 void mutt_paddstr(WINDOW *win, int n, const char *s)
620 {
621   wchar_t wc;
622   int w;
623   ssize_t k;
624   ssize_t len = m_strlen(s);
625   mbstate_t mbstate;
626
627   p_clear(&mbstate, 1);
628   for (; len && (k = mbrtowc (&wc, s, len, &mbstate)); s += k, len -= k) {
629     if (k == -1 || k == -2) {
630       k = (k == -1) ? 1 : len;
631       wc = CharsetReplacement;
632     }
633     if (!iswprint(wc))
634       wc = '?';
635     w = wcwidth (wc);
636     if (w >= 0) {
637       if (w > n)
638         break;
639       waddnstr(win, (char *) s, k);
640       n -= w;
641     }
642   }
643   while (n-- > 0)
644     waddch(win, ' ');
645 }