addrbook.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 #if HAVE_CONFIG_H
  11 # include "config.h"
  12 #endif
  13
  14 #include "mutt.h"
  15 #include "mutt_menu.h"
  16 #include "mapping.h"
  17 #include "sort.h"
  18
  19 #include "mutt_idna.h"
  20
  21 #include <string.h>
  22 #include <stdlib.h>
  23 #include <ctype.h>
  24
  25 #define RSORT(x) (SortAlias & SORT_REVERSE) ? -x : x
  26
  27 static struct mapping_t AliasHelp[] = {
  28   {N_("Exit"), OP_EXIT},
  29   {N_("Del"), OP_DELETE},
  30   {N_("Undel"), OP_UNDELETE},
  31   {N_("Select"), OP_GENERIC_SELECT_ENTRY},
  32   {N_("Help"), OP_HELP},
  33   {NULL}
  34 };
  35
  36 static const char *alias_format_str (char *dest, size_t destlen, char op,
  37                                      const char *src, const char *fmt,
  38                                      const char *ifstring,
  39                                      const char *elsestring,
  40                                      unsigned long data, format_flag flags)
  41 {
  42   char tmp[SHORT_STRING], adr[SHORT_STRING];
  43   ALIAS *alias = (ALIAS *) data;
  44
  45   switch (op) {
  46   case 'f':
  47     snprintf (tmp, sizeof (tmp), "%%%ss", fmt);
  48     snprintf (dest, destlen, tmp, alias->del ? "D" : " ");
  49     break;
  50   case 'a':
  51     mutt_format_s (dest, destlen, fmt, alias->name);
  52     break;
  53   case 'r':
  54     adr[0] = 0;
  55     rfc822_write_address (adr, sizeof (adr), alias->addr, 1);
  56     snprintf (tmp, sizeof (tmp), "%%%ss", fmt);
  57     snprintf (dest, destlen, tmp, adr);
  58     break;
  59   case 'n':
  60     snprintf (tmp, sizeof (tmp), "%%%sd", fmt);
  61     snprintf (dest, destlen, tmp, alias->num + 1);
  62     break;
  63   case 't':
  64     dest[0] = alias->tagged ? '*' : ' ';
  65     dest[1] = 0;
  66     break;
  67   }
  68
  69   return (src);
  70 }
  71
  72 static void alias_entry (char *s, size_t slen, MUTTMENU * m, int num)
  73 {
  74   mutt_FormatString (s, slen, NONULL (AliasFmt), alias_format_str,
  75                      (unsigned long) ((ALIAS **) m->data)[num],
  76                      M_FORMAT_ARROWCURSOR);
  77 }
  78
  79 static int alias_tag (MUTTMENU * menu, int n, int m)
  80 {
  81   ALIAS *cur = ((ALIAS **) menu->data)[n];
  82   int ot = cur->tagged;
  83
  84   cur->tagged = (m >= 0 ? m : !cur->tagged);
  85
  86   return cur->tagged - ot;
  87 }
  88
  89 static int alias_SortAlias (const void *a, const void *b)
  90 {
  91   ALIAS *pa = *(ALIAS **) a;
  92   ALIAS *pb = *(ALIAS **) b;
  93   int r = mutt_strcasecmp (pa->name, pb->name);
  94
  95   return (RSORT (r));
  96 }
  97
  98 static int alias_SortAddress (const void *a, const void *b)
  99 {
 100   ADDRESS *pa = (*(ALIAS **) a)->addr;
 101   ADDRESS *pb = (*(ALIAS **) b)->addr;
 102   int r;
 103
 104   if (pa == pb)
 105     r = 0;
 106   else if (pa == NULL)
 107     r = -1;
 108   else if (pb == NULL)
 109     r = 1;
 110   else if (pa->personal) {
 111     if (pb->personal)
 112       r = mutt_strcasecmp (pa->personal, pb->personal);
 113     else
 114       r = 1;
 115   }
 116   else if (pb->personal)
 117     r = -1;
 118   else
 119     r = ascii_strcasecmp (pa->mailbox, pb->mailbox);
 120   return (RSORT (r));
 121 }
 122
 123 void mutt_alias_menu (char *buf, size_t buflen, ALIAS * aliases)
 124 {
 125   ALIAS *aliasp;
 126   MUTTMENU *menu;
 127   ALIAS **AliasTable = NULL;
 128   int t = -1;
 129   int i, done = 0;
 130   int op;
 131   char helpstr[SHORT_STRING];
 132
 133   int omax;
 134
 135   if (!aliases) {
 136     mutt_error _("You have no aliases!");
 137
 138     return;
 139   }
 140
 141   /* tell whoever called me to redraw the screen when I return */
 142   set_option (OPTNEEDREDRAW);
 143
 144   menu = mutt_new_menu ();
 145   menu->make_entry = alias_entry;
 146   menu->tag = alias_tag;
 147   menu->menu = MENU_ALIAS;
 148   menu->title = _("Aliases");
 149   menu->help =
 150     mutt_compile_help (helpstr, sizeof (helpstr), MENU_ALIAS, AliasHelp);
 151
 152 new_aliases:
 153
 154   omax = menu->max;
 155
 156   /* count the number of aliases */
 157   for (aliasp = aliases; aliasp; aliasp = aliasp->next) {
 158     aliasp->self->del = 0;
 159     aliasp->self->tagged = 0;
 160     menu->max++;
 161   }
 162
 163   safe_realloc (&AliasTable, menu->max * sizeof (ALIAS *));
 164   menu->data = AliasTable;
 165
 166   for (i = omax, aliasp = aliases; aliasp; aliasp = aliasp->next, i++) {
 167     AliasTable[i] = aliasp->self;
 168     aliases = aliasp;
 169   }
 170
 171   if ((SortAlias & SORT_MASK) != SORT_ORDER) {
 172     qsort (AliasTable, i, sizeof (ALIAS *),
 173            (SortAlias & SORT_MASK) ==
 174            SORT_ADDRESS ? alias_SortAddress : alias_SortAlias);
 175   }
 176
 177   for (i = 0; i < menu->max; i++)
 178     AliasTable[i]->num = i;
 179
 180   while (!done) {
 181     if (aliases->next) {
 182       menu->redraw |= REDRAW_FULL;
 183       aliases = aliases->next;
 184       goto new_aliases;
 185     }
 186
 187     switch ((op = mutt_menuLoop (menu))) {
 188     case OP_DELETE:
 189     case OP_UNDELETE:
 190       if (menu->tagprefix) {
 191         for (i = 0; i < menu->max; i++)
 192           if (AliasTable[i]->tagged)
 193             AliasTable[i]->del = (op == OP_DELETE) ? 1 : 0;
 194         menu->redraw |= REDRAW_INDEX;
 195       }
 196       else {
 197         AliasTable[menu->current]->self->del = (op == OP_DELETE) ? 1 : 0;
 198         menu->redraw |= REDRAW_CURRENT;
 199         if (option (OPTRESOLVE) && menu->current < menu->max - 1) {
 200           menu->current++;
 201           menu->redraw |= REDRAW_INDEX;
 202         }
 203       }
 204       break;
 205     case OP_GENERIC_SELECT_ENTRY:
 206       t = menu->current;
 207     case OP_EXIT:
 208       done = 1;
 209       break;
 210     }
 211   }
 212
 213   for (i = 0; i < menu->max; i++) {
 214     if (AliasTable[i]->tagged) {
 215       mutt_addrlist_to_local (AliasTable[i]->addr);
 216       rfc822_write_address (buf, buflen, AliasTable[i]->addr, 0);
 217       t = -1;
 218     }
 219   }
 220
 221   if (t != -1) {
 222     mutt_addrlist_to_local (AliasTable[t]->addr);
 223     rfc822_write_address (buf, buflen, AliasTable[t]->addr, 0);
 224   }
 225
 226   mutt_menuDestroy (&menu);
 227   FREE (&AliasTable);
 228
 229 }