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