addrbook.c

   1 /*
   2  * Copyright (C) 1996-2000,2007 Michael R. Elkins <me@mutt.org>
   3  *
   4  *     This program is free software; you can redistribute it and/or modify
   5  *     it under the terms of the GNU General Public License as published by
   6  *     the Free Software Foundation; either version 2 of the License, or
   7  *     (at your option) any later version.
   8  *
   9  *     This program is distributed in the hope that it will be useful,
  10  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  *     GNU General Public License for more details.
  13  *
  14  *     You should have received a copy of the GNU General Public License
  15  *     along with this program; if not, write to the Free Software
  16  *     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  17  */
  18
  19 #if HAVE_CONFIG_H
  20 # include "config.h"
  21 #endif
  22
  23 #include "mutt.h"
  24 #include "mutt_menu.h"
  25 #include "mapping.h"
  26 #include "sort.h"
  27
  28 #include "mutt_idna.h"
  29
  30 #include <string.h>
  31 #include <stdlib.h>
  32 #include <ctype.h>
  33
  34 #define RSORT(x) (SortAlias & SORT_REVERSE) ? -x : x
  35
  36 static struct mapping_t AliasHelp[] = {
  37   { N_("Exit"),   OP_EXIT },
  38   { N_("Del"),    OP_DELETE },
  39   { N_("Undel"),  OP_UNDELETE },
  40   { N_("Select"), OP_GENERIC_SELECT_ENTRY },
  41   { N_("Help"),   OP_HELP },
  42   { NULL,         0 }
  43 };
  44
  45 static const char *
  46 alias_format_str (char *dest, size_t destlen, size_t col, char op, const char *src,
  47                   const char *fmt, const char *ifstring, const char *elsestring,
  48                   unsigned long data, format_flag flags)
  49 {
  50   char tmp[SHORT_STRING], adr[SHORT_STRING];
  51   ALIAS *alias = (ALIAS *) data;
  52
  53   switch (op)
  54   {
  55     case 'f':
  56       snprintf (tmp, sizeof (tmp), "%%%ss", fmt);
  57       snprintf (dest, destlen, tmp, alias->del ? "D" : " ");
  58       break;
  59     case 'a':
  60       mutt_format_s (dest, destlen, fmt, alias->name);
  61       break;
  62     case 'r':
  63       adr[0] = 0;
  64       rfc822_write_address (adr, sizeof (adr), alias->addr, 1);
  65       snprintf (tmp, sizeof (tmp), "%%%ss", fmt);
  66       snprintf (dest, destlen, tmp, adr);
  67       break;
  68     case 'n':
  69       snprintf (tmp, sizeof (tmp), "%%%sd", fmt);
  70       snprintf (dest, destlen, tmp, alias->num + 1);
  71       break;
  72     case 't':
  73       dest[0] = alias->tagged ? '*' : ' ';
  74       dest[1] = 0;
  75       break;
  76   }
  77
  78   return (src);
  79 }
  80
  81 static void alias_entry (char *s, size_t slen, MUTTMENU *m, int num)
  82 {
  83   mutt_FormatString (s, slen, 0, NONULL (AliasFmt), alias_format_str, (unsigned long) ((ALIAS **) m->data)[num], M_FORMAT_ARROWCURSOR);
  84 }
  85
  86 static int alias_tag (MUTTMENU *menu, int n, int m)
  87 {
  88   ALIAS *cur = ((ALIAS **) menu->data)[n];
  89   int ot = cur->tagged;
  90
  91   cur->tagged = (m >= 0 ? m : !cur->tagged);
  92
  93   return cur->tagged - ot;
  94 }
  95
  96 static int alias_SortAlias (const void *a, const void *b)
  97 {
  98   ALIAS *pa = *(ALIAS **) a;
  99   ALIAS *pb = *(ALIAS **) b;
 100   int r = mutt_strcasecmp (pa->name, pb->name);
 101
 102   return (RSORT (r));
 103 }
 104
 105 static int alias_SortAddress (const void *a, const void *b)
 106 {
 107   ADDRESS *pa = (*(ALIAS **) a)->addr;
 108   ADDRESS *pb = (*(ALIAS **) b)->addr;
 109   int r;
 110
 111   if (pa == pb)
 112     r = 0;
 113   else if (pa == NULL)
 114     r = -1;
 115   else if (pb == NULL)
 116     r = 1;
 117   else if (pa->personal)
 118   {
 119     if (pb->personal)
 120       r = mutt_strcasecmp (pa->personal, pb->personal);
 121     else
 122       r = 1;
 123   }
 124   else if (pb->personal)
 125     r = -1;
 126   else
 127     r = ascii_strcasecmp (pa->mailbox, pb->mailbox);
 128   return (RSORT (r));
 129 }
 130
 131 void mutt_alias_menu (char *buf, size_t buflen, ALIAS *aliases)
 132 {
 133   ALIAS *aliasp;
 134   MUTTMENU *menu;
 135   ALIAS **AliasTable = NULL;
 136   int t = -1;
 137   int i, done = 0;
 138   int op;
 139   char helpstr[LONG_STRING];
 140
 141   int omax;
 142
 143   if (!aliases)
 144   {
 145     mutt_error _("You have no aliases!");
 146     return;
 147   }
 148
 149   /* tell whoever called me to redraw the screen when I return */
 150   set_option (OPTNEEDREDRAW);
 151
 152   menu = mutt_new_menu (MENU_ALIAS);
 153   menu->make_entry = alias_entry;
 154   menu->tag = alias_tag;
 155   menu->title = _("Aliases");
 156   menu->help = mutt_compile_help (helpstr, sizeof (helpstr), MENU_ALIAS, AliasHelp);
 157
 158 new_aliases:
 159
 160   omax = menu->max;
 161
 162   /* count the number of aliases */
 163   for (aliasp = aliases; aliasp; aliasp = aliasp->next)
 164   {
 165     aliasp->self->del    = 0;
 166     aliasp->self->tagged = 0;
 167     menu->max++;
 168   }
 169
 170   safe_realloc (&AliasTable, menu->max * sizeof (ALIAS *));
 171   menu->data = AliasTable;
 172
 173   for (i = omax, aliasp = aliases; aliasp; aliasp = aliasp->next, i++)
 174   {
 175     AliasTable[i] = aliasp->self;
 176     aliases       = aliasp;
 177   }
 178
 179   if ((SortAlias & SORT_MASK) != SORT_ORDER)
 180   {
 181     qsort (AliasTable, i, sizeof (ALIAS *),
 182          (SortAlias & SORT_MASK) == SORT_ADDRESS ? alias_SortAddress : alias_SortAlias);
 183   }
 184
 185   for (i=0; i<menu->max; i++) AliasTable[i]->num = i;
 186
 187   while (!done)
 188   {
 189     if (aliases->next)
 190     {
 191       menu->redraw |= REDRAW_FULL;
 192       aliases       = aliases->next;
 193       goto new_aliases;
 194     }
 195
 196     switch ((op = mutt_menuLoop (menu)))
 197     {
 198       case OP_DELETE:
 199       case OP_UNDELETE:
 200         if (menu->tagprefix)
 201         {
 202           for (i = 0; i < menu->max; i++)
 203             if (AliasTable[i]->tagged)
 204               AliasTable[i]->del = (op == OP_DELETE) ? 1 : 0;
 205           menu->redraw |= REDRAW_INDEX;
 206         }
 207         else
 208         {
 209           AliasTable[menu->current]->self->del = (op == OP_DELETE) ? 1 : 0;
 210           menu->redraw |= REDRAW_CURRENT;
 211           if (option (OPTRESOLVE) && menu->current < menu->max - 1)
 212           {
 213             menu->current++;
 214             menu->redraw |= REDRAW_INDEX;
 215           }
 216         }
 217         break;
 218       case OP_GENERIC_SELECT_ENTRY:
 219         t = menu->current;
 220       case OP_EXIT:
 221         done = 1;
 222         break;
 223     }
 224   }
 225
 226   for (i = 0; i < menu->max; i++)
 227   {
 228     if (AliasTable[i]->tagged)
 229     {
 230       mutt_addrlist_to_local (AliasTable[i]->addr);
 231       rfc822_write_address (buf, buflen, AliasTable[i]->addr, 0);
 232       t = -1;
 233     }
 234   }
 235
 236   if(t != -1)
 237   {
 238       mutt_addrlist_to_local (AliasTable[t]->addr);
 239     rfc822_write_address (buf, buflen, AliasTable[t]->addr, 0);
 240   }
 241
 242   mutt_menuDestroy (&menu);
 243   FREE (&AliasTable);
 244
 245 }