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[SHORT_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[SHORT_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[SHORT_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(Tempdir), 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         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 }