edit.c

   1
   2 /*
   3  * $Id$
   4  *
   5  * by JH <jheinonen@bigfoot.com>
   6  *
   7  * Copyright (C) Jaakko Heinonen
   8  */
   9
  10 #include <string.h>
  11 #include <stdlib.h>
  12 #include "abook_curses.h"
  13 #include "abook.h"
  14 #include "database.h"
  15 #include "list.h"
  16 #include "edit.h"
  17 #include "misc.h"
  18 #ifdef HAVE_CONFIG_H
  19 #       include "config.h"
  20 #endif
  21
  22 /*
  23  * some extern variables
  24  */
  25
  26 extern struct abook_field abook_fields[];
  27
  28 extern list_item *database;
  29 extern int curitem;
  30 extern int items;
  31
  32 WINDOW *editw;
  33
  34 static void
  35 editor_tab(int tab)
  36 {
  37         int i;
  38         char *tab_names[] = {
  39                 "/ CONTACT \\",
  40                 "/ ADDRESS \\",
  41                 "/  PHONE  \\",
  42                 "/  OTHER  \\"
  43         };
  44
  45         mvwhline(editw, TABLINE+1, 0, ACS_HLINE, EDITW_COLS);
  46
  47         for(i=0; i < TABS; i++)
  48                 mvwaddstr(editw, TABLINE, 16 * i + 3, tab_names[i]);
  49
  50         mvwaddstr(editw, TABLINE+1, 16 * tab + 2, "/           \\");
  51 }
  52
  53 void
  54 get_first_email(char *str, int item)
  55 {
  56         char *tmp;
  57
  58         if(database[item][EMAIL] == NULL) {
  59                 *str = 0;
  60                 return;
  61         }
  62
  63         strncpy(str, database[item][EMAIL], MAX_EMAIL_LEN);
  64         if( (tmp = strchr(str, ',')) )
  65                 *tmp=0;
  66         else
  67                 str[MAX_EMAIL_LEN-1] = 0;
  68 }
  69
  70 static void
  71 roll_emails(int item)
  72 {
  73         char tmp[MAX_EMAILSTR_LEN];
  74         char *p;
  75
  76         strcpy(tmp, database[item][EMAIL]);
  77
  78         if( !(p = strchr(tmp, ',')) )
  79                 return;
  80         else
  81                 *p=0;
  82
  83         strcpy(database[item][EMAIL], p+1);
  84         strcat(database[item][EMAIL], ",");
  85         strcat(database[item][EMAIL], tmp);
  86 }
  87
  88 static void
  89 init_editor()
  90 {
  91         clear();
  92         editw = newwin(EDITW_LINES, EDITW_COLS, EDITW_TOP, EDITW_X);
  93
  94         refresh_statusline();
  95 }
  96
  97 /*
  98  * we have to introduce edit_undo here
  99  */
 100 static void edit_undo(int item, int mode);
 101
 102 enum {
 103         BACKUP_ITEM,
 104         RESTORE_ITEM,
 105         CLEAR_UNDO
 106 };
 107
 108
 109 static void
 110 close_editor()
 111 {
 112         edit_undo(-1, CLEAR_UNDO);
 113         delwin(editw);
 114         refresh_screen();
 115 }
 116
 117 static void
 118 print_editor_header(int item)
 119 {
 120         char *header;
 121         char email[MAX_EMAIL_LEN];
 122         int i, x, len;
 123
 124         if( (header = (char *)malloc(EDITW_COLS)) == NULL )
 125                 return;
 126
 127         get_first_email(email, item);
 128
 129         if( snprintf(header, EDITW_COLS, "%s <%s>", database[item][NAME],
 130                                 email ) ==  -1 || !*database[item][EMAIL] )
 131         if( snprintf(header, EDITW_COLS, "%s", database[item][NAME]) == -1) {
 132                 free(header);
 133                 return;
 134         }
 135
 136         len = strlen(header);
 137         x = (EDITW_COLS - len) / 2;
 138         mvwaddstr(editw, 0, x, header);
 139         for(i = x; i < x + len; i++)
 140                 mvwaddch(editw,1, i, '^');
 141         free(header);
 142 }
 143
 144 static void
 145 editor_print_data(int tab, int item)
 146 {
 147         const int pos_x = EDITW_COLS > 70 ? 8:4;
 148         int i, j;
 149
 150         for(i = 0, j = 1; i < ITEM_FIELDS; i++) {
 151                 if(abook_fields[i].tab != tab)
 152                         continue;
 153
 154                 if(i==EMAIL) { /* special field */
 155                         int k;
 156                         char emails[MAX_EMAILS][MAX_EMAIL_LEN];
 157                         split_emailstr(item, emails);
 158                         mvwaddstr(editw, (LINES > 21 ? 7:6), pos_x, "E-mail addresses:");
 159                         for(k=0; k < MAX_EMAILS; k++)
 160                                 mvwprintw(editw, (LINES > 21 ? 9:7)+k*2, pos_x,
 161                                 "%c -\t\t%s", '2' + k, emails[k] );
 162                         continue;
 163                 }
 164
 165                 mvwprintw(editw, 3+j*2, pos_x, "%d - %s",
 166                                 j,
 167                                 abook_fields[i].name);
 168                 mvwaddch(editw, 3+j*2, 28, ':');
 169                 mvwaddstr(editw, 3+j*2, 30, safe_str(database[item][i]));
 170                 j++;
 171         }
 172 }
 173
 174 /*
 175  * function: change_field
 176  *
 177  * parameters:
 178  *  (char *msg)
 179  *   message to display as a prompt
 180  *  (char **field)
 181  *   a pointer to pointer which will point a new string. if the latter
 182  *   pointer != NULL it will be freed (if user doesn't cancel)
 183  *
 184  * returns (int)
 185  *  a nonzero value if user has cancelled and zero if user has typed a
 186  *  valid string
 187  */
 188
 189 static int
 190 change_field(char *msg, char **field)
 191 {
 192         char tmp[MAX_FIELD_LEN];
 193         int max_len = MAX_FIELD_LEN;
 194         int ret;
 195
 196         if( !strncmp("E-mail", msg, 6) )
 197                 max_len = MAX_EMAIL_LEN;
 198
 199         statusline_addstr(msg);
 200         if( (ret = statusline_getnstr( tmp, max_len - 1, 0 ) ? 1:0 ) ) {
 201                 my_free(*field);
 202                 if( *tmp )
 203                         *field = strdup(tmp);
 204         }
 205
 206         clear_statusline();
 207         refresh_statusline();
 208
 209         return !ret;
 210 }
 211
 212 static void
 213 change_name_field(char **field)
 214 {
 215         char *tmp;
 216
 217         tmp = strdup(*field);
 218         change_field("Name: ", field);
 219
 220         if( *field == NULL || ! **field ) {
 221                 my_free(*field);
 222                 *field = strdup(tmp);
 223         }
 224
 225         my_free(tmp);
 226 }
 227
 228 static void
 229 fix_email_str(char *str)
 230 {
 231         for(; *str; str++ )
 232                 *str = *str == ',' ? '_' : *str;
 233 }
 234
 235 static void
 236 edit_emails(char c, int item)
 237 {
 238         char *field = NULL;
 239         char emails[4][MAX_EMAIL_LEN];
 240         char tmp[MAX_EMAILSTR_LEN] = "";
 241         int i, len;
 242
 243         split_emailstr(item, emails);
 244
 245         if(change_field("E-mail: ", &field)) {
 246 #ifdef DEBUG
 247                 fprintf(stderr, "change_field = TRUE\n");
 248 #endif
 249                 return; /* user cancelled ( C-g ) */
 250         }
 251         if(field) {
 252                 strncpy(emails[c - '2'], field, MAX_EMAIL_LEN);
 253                 fix_email_str(emails[c - '2']);
 254         } else
 255                 *emails[c - '2'] = 0;
 256
 257         my_free(database[item][EMAIL]);
 258
 259         for(i=0; i<4; i++) {
 260                 if( *emails[i] ) {
 261                         strcat(tmp, emails[i]);
 262                         strcat(tmp, ",");
 263                 }
 264         }
 265
 266         len = strlen(tmp);
 267         if(tmp[len -1] == ',')
 268                 tmp[len-1] =0;
 269
 270         database[item][EMAIL] = strdup(tmp);
 271 }
 272
 273 static int
 274 edit_field(int tab, char c, int item)
 275 {
 276         int i, j;
 277         int n = c - '1' + 1;
 278         char *str;
 279
 280         if(n < 1 || n > 6)
 281                 return 0;
 282
 283         edit_undo(item, BACKUP_ITEM);
 284
 285         if(tab == TAB_CONTACT) {
 286                 switch(c) {
 287                         case '1': change_name_field(&database[item][NAME]);
 288                                   break;
 289                         case '2':
 290                         case '3':
 291                         case '4':
 292                         case '5': edit_emails(c, item); break;
 293                         default: return 0;
 294                 }
 295                 return 1;
 296         }
 297
 298         for(i=0, j=0; i< ITEM_FIELDS; i++) {
 299                 if(abook_fields[i].tab == tab)
 300                         j++;
 301                 if(j==n)
 302                         break;
 303         }
 304
 305         if(j!=n)
 306                 return 0;
 307
 308         str = mkstr("%s: ", abook_fields[i].name);
 309         change_field(str, &database[item][i]);
 310
 311         free(str);
 312
 313         return 1;
 314 }
 315
 316 static void
 317 edit_undo(int item, int mode)
 318 {
 319         int i;
 320         static list_item *backup = NULL;
 321
 322         switch(mode) {
 323                 case CLEAR_UNDO:
 324                         if(backup) {
 325                                 free_list_item(backup[0]);
 326                                 my_free(backup);
 327                         }
 328                         break;
 329                 case BACKUP_ITEM:
 330                         if(backup) {
 331                                 free_list_item(backup[0]);
 332                                 my_free(backup);
 333                         }
 334                         backup = abook_malloc(sizeof(list_item));
 335                         for(i = 0; i < ITEM_FIELDS; i++)
 336                                 backup[0][i] = safe_strdup(database[item][i]);
 337                         break;
 338                 case RESTORE_ITEM:
 339                         if(backup) {
 340                                 free_list_item(database[item]);
 341                                 itemcpy(database[item], backup[0]);
 342                                 my_free(backup);
 343                         }
 344                         break;
 345         }
 346 }
 347
 348 static int
 349 edit_loop(int item)
 350 {
 351         static int tab = 0; /* first tab */
 352         int c;
 353
 354         werase(editw);
 355         headerline(EDITOR_HELPLINE);
 356         print_editor_header(item);
 357         editor_tab(tab);
 358         editor_print_data(tab, item);
 359         wmove(editw, EDITW_LINES - 1, EDITW_COLS - 1);
 360
 361         refresh();
 362         wrefresh(editw);
 363
 364         switch( (c = getch()) ) {
 365                 case 'c': tab = TAB_CONTACT; break;
 366                 case 'a': tab = TAB_ADDRESS; break;
 367                 case 'p': tab = TAB_PHONE; break;
 368                 case 'o': tab = TAB_OTHER; break;
 369                 case KEY_LEFT: tab = tab == 0 ? MAX_TAB : tab - 1;
 370                                break;
 371                 case KEY_RIGHT: tab = tab == MAX_TAB ? 0 : tab + 1;
 372                                 break;
 373                 case 'r': roll_emails(item); break;
 374                 case '?': display_editor_help(editw); break;
 375                 case 'u': edit_undo(item, RESTORE_ITEM); break;
 376                 default:  return edit_field(tab, c, item);
 377         }
 378
 379         return 1;
 380 }
 381
 382 void
 383 edit_item(int item)
 384 {
 385         if( item < 0 ) {
 386                 if( curitem < 0 )
 387                         return;
 388                 else
 389                         item = curitem;
 390         }
 391
 392         init_editor();
 393         while( edit_loop(item) )
 394                 ;
 395
 396         close_editor();
 397 }
 398
 399 void
 400 add_item()
 401 {
 402         char *field = NULL;
 403         list_item item;
 404
 405         change_field("Name: ", &field);
 406
 407         if( field == NULL )
 408                 return;
 409
 410         memset(item, 0, sizeof(item));
 411
 412         item[NAME] = field;
 413
 414         add_item2database(item);
 415
 416         curitem = LAST_ITEM;
 417
 418         edit_item(LAST_ITEM);
 419 }
 420