wibble
[apps/madmutt.git] / help.c
1 /*
2  * Copyright notice from original mutt:
3  * Copyright (C) 1996-2000 Michael R. Elkins <me@mutt.org>
4  *
5  * This file is part of mutt-ng, see http://www.muttng.org/.
6  * It's licensed under the GNU General Public License,
7  * please see the file GPL in the top level source directory.
8  */
9
10 #define HELP_C
11
12 #include <lib-lib/lib-lib.h>
13
14 #include <lib-ui/curses.h>
15
16 #include "mutt.h"
17 #include "charset.h"
18 #include "keymap.h"
19 #include "pager.h"
20
21 static struct binding_t *help_lookupFunction (int op, int menu)
22 {
23   int i;
24   struct binding_t *map;
25
26   if (menu != MENU_PAGER) {
27     /* first look in the generic map for the function */
28     for (i = 0; OpGeneric[i].name; i++)
29       if (OpGeneric[i].op == op)
30         return (&OpGeneric[i]);
31   }
32
33   if ((map = km_get_table (menu))) {
34     for (i = 0; map[i].name; i++)
35       if (map[i].op == op)
36         return (&map[i]);
37   }
38
39   return (NULL);
40 }
41
42 void mutt_make_help (char *d, ssize_t dlen, char *txt, int menu, int op)
43 {
44   char buf[STRING];
45
46   if (km_expand_key (buf, sizeof (buf), km_find_func (menu, op)) ||
47       km_expand_key (buf, sizeof (buf), km_find_func (MENU_GENERIC, op)))
48     snprintf (d, dlen, "%s:%s", buf, txt);
49   else
50     d[0] = 0;
51 }
52
53 char *mutt_compile_help (char *buf, ssize_t buflen, int menu,
54                          struct mapping_t *items)
55 {
56   int i;
57   ssize_t len;
58   char *pbuf = buf;
59
60   for (i = 0; items[i].name && buflen > 2; i++) {
61     if (i) {
62       *pbuf++ = ' ';
63       *pbuf++ = ' ';
64       buflen -= 2;
65     }
66     mutt_make_help (pbuf, buflen, _(items[i].name), menu, items[i].value);
67     len = m_strlen(pbuf);
68     pbuf += len;
69     buflen -= len;
70   }
71   return buf;
72 }
73
74 static int print_macro (FILE * f, int maxwidth, const char **macro)
75 {
76   int n = maxwidth;
77   wchar_t wc;
78   int w;
79   ssize_t k;
80   ssize_t len = m_strlen(*macro);
81   mbstate_t mbstate1, mbstate2;
82
83   p_clear(&mbstate1, 1);
84   p_clear(&mbstate2, 1);
85   for (; len && (k = mbrtowc (&wc, *macro, len, &mbstate1));
86        *macro += k, len -= k) {
87     if (k == -1 || k == -2) {
88       k = (k == -1) ? 1 : len;
89       wc = CharsetReplacement;
90     }
91     /* glibc-2.1.3's wcwidth() returns 1 for unprintable chars! */
92     if (iswprint(wc) && (w = wcwidth (wc)) >= 0) {
93       if (w > n)
94         break;
95       n -= w;
96       {
97         char buf[MB_LEN_MAX * 2];
98         ssize_t n1, n2;
99
100         if ((n1 = wcrtomb(buf, wc, &mbstate2)) != -1 &&
101             (n2 = wcrtomb(buf + n1, 0, &mbstate2)) != -1)
102           fputs (buf, f);
103       }
104     }
105     else if (wc < 0x20 || wc == 0x7f) {
106       if (2 > n)
107         break;
108       n -= 2;
109       if (wc == '\033')
110         fprintf (f, "\\e");
111       else if (wc == '\n')
112         fprintf (f, "\\n");
113       else if (wc == '\r')
114         fprintf (f, "\\r");
115       else if (wc == '\t')
116         fprintf (f, "\\t");
117       else
118         fprintf (f, "^%c", (char) ((wc + '@') & 0x7f));
119     }
120     else {
121       if (1 > n)
122         break;
123       n -= 1;
124       fprintf (f, "?");
125     }
126   }
127   return (maxwidth - n);
128 }
129
130 static int pad (FILE * f, int col, int i)
131 {
132   char fmt[8];
133
134   if (col < i) {
135     snprintf (fmt, sizeof (fmt), "%%-%ds", i - col);
136     fprintf (f, fmt, "");
137     return (i);
138   }
139   fputc (' ', f);
140   return (col + 1);
141 }
142
143 static void format_line (FILE * f, int ismacro,
144                          const char *t1, const char *t2, const char *t3)
145 {
146   int col;
147   int col_a, col_b;
148   int split;
149   int n;
150
151   fputs (t1, f);
152
153   /* don't try to press string into one line with less than 40 characters.
154      The double paranthesis avoid a gcc warning, sigh ... */
155   if ((split = COLS < 40)) {
156     col_a = col = 0;
157     col_b = LONG_STRING;
158     fputc ('\n', f);
159   }
160   else {
161     col_a = COLS > 83 ? (COLS - 32) >> 2 : 12;
162     col_b = COLS > 49 ? (COLS - 10) >> 1 : 19;
163     col = pad (f, m_strlen(t1), col_a);
164   }
165
166   if (ismacro > 0) {
167     if (!m_strcmp(Pager, "builtin"))
168       fputs ("_\010", f);
169     fputs ("M ", f);
170     col += 2;
171
172     if (!split) {
173       col += print_macro (f, col_b - col - 4, &t2);
174       if (m_strlen(t2) > col_b - col)
175         t2 = "...";
176     }
177   }
178
179   col += print_macro (f, col_b - col - 1, &t2);
180   if (split)
181     fputc ('\n', f);
182   else
183     col = pad (f, col, col_b);
184
185   if (split) {
186     print_macro (f, LONG_STRING, &t3);
187     fputc ('\n', f);
188   }
189   else {
190     while (*t3) {
191       n = COLS - col;
192
193       if (ismacro >= 0) {
194         t3 = vskipspaces(t3);
195
196         /* FIXME: this is completely wrong */
197         if ((n = m_strlen(t3)) > COLS - col) {
198           n = COLS - col;
199           for (col_a = n; col_a > 0 && t3[col_a] != ' '; col_a--);
200           if (col_a)
201             n = col_a;
202         }
203       }
204
205       print_macro (f, n, &t3);
206
207       if (*t3) {
208         if (m_strcmp(Pager, "builtin")) {
209           fputc ('\n', f);
210           n = 0;
211         }
212         else {
213           n += col - COLS;
214           if (option (OPTMARKERS))
215             ++n;
216         }
217         col = pad (f, n, col_b);
218       }
219     }
220   }
221
222   fputc ('\n', f);
223 }
224
225 static void dump_menu (FILE * f, int menu)
226 {
227   struct keymap_t *map;
228   struct binding_t *b;
229   char buf[STRING];
230
231   /* browse through the keymap table */
232   for (map = Keymaps[menu]; map; map = map->next) {
233     if (map->op != OP_NULL) {
234       km_expand_key (buf, sizeof (buf), map);
235
236       if (map->op == OP_MACRO) {
237         if (map->descr == NULL)
238           format_line (f, -1, buf, "macro", map->macro);
239         else
240           format_line (f, 1, buf, map->macro, map->descr);
241       }
242       else {
243         b = help_lookupFunction (map->op, menu);
244         format_line (f, 0, buf, b ? b->name : "UNKNOWN",
245                      b ? _(HelpStrings[b->op]) :
246                      _("ERROR: please report this bug"));
247       }
248     }
249   }
250 }
251
252 static int is_bound (struct keymap_t *map, int op)
253 {
254   for (; map; map = map->next)
255     if (map->op == op)
256       return 1;
257   return 0;
258 }
259
260 static void dump_unbound (FILE * f,
261                           struct binding_t *funcs,
262                           struct keymap_t *map, struct keymap_t *aux)
263 {
264   int i;
265
266   for (i = 0; funcs[i].name; i++) {
267     if (!is_bound (map, funcs[i].op) &&
268         (!aux || !is_bound (aux, funcs[i].op)))
269       format_line (f, 0, funcs[i].name, "", _(HelpStrings[funcs[i].op]));
270   }
271 }
272
273 void mutt_help (int menu)
274 {
275     char tmp[_POSIX_PATH_MAX];
276     char buf[STRING];
277     const char *desc;
278     FILE *f;
279     struct binding_t *funcs;
280
281     funcs = km_get_table (menu);
282     desc = mutt_getnamebyvalue (menu, Menus);
283     if (!desc)
284         desc = _("<UNKNOWN>");
285
286     do {
287         f = m_tempfile(tmp, sizeof(tmp), NONULL(MCore.tmpdir), NULL);
288         if (!f) {
289             mutt_perror(tmp);
290             return;
291         }
292
293         dump_menu(f, menu);
294         if (menu != MENU_EDITOR && menu != MENU_PAGER) {
295             fputs(_("\nGeneric bindings:\n\n"), f);
296             dump_menu(f, MENU_GENERIC);
297         }
298
299         fputs(_("\nUnbound functions:\n\n"), f);
300         if (funcs)
301             dump_unbound(f, funcs, Keymaps[menu], NULL);
302
303         if (menu != MENU_PAGER)
304             dump_unbound (f, OpGeneric, Keymaps[MENU_GENERIC], Keymaps[menu]);
305
306         m_fclose(&f);
307
308         snprintf(buf, sizeof (buf), _("Help for %s"), desc);
309     } while (mutt_do_pager(buf, tmp,
310                            M_PAGER_RETWINCH | M_PAGER_MARKER | M_PAGER_NSKIP,
311                            NULL) == OP_REFORMAT_WINCH);
312 }