pith/abdlc.c

   1 /*
   2  * ========================================================================
   3  * Copyright 2013-2022 Eduardo Chappa
   4  * Copyright 2006-2007 University of Washington
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * ========================================================================
  13  */
  14
  15 #include "../pith/headers.h"    /* for os-dep and pith defs/includes */
  16 #include "../pith/abdlc.h"
  17 #include "../pith/state.h"
  18 #include "../pith/conf.h"
  19 #include "../pith/status.h"
  20 #include "../pith/ldap.h"
  21 #include "../pith/tempfile.h"
  22
  23
  24 /*
  25  * Internal prototypes
  26  */
  27 void           initialize_dlc_cache(void);
  28 int            dlc_siblings(DL_CACHE_S *, DL_CACHE_S *);
  29 DL_CACHE_S    *dlc_mgr(long, DlMgrOps, DL_CACHE_S *);
  30 void           free_cache_array(DL_CACHE_S **, int);
  31 DL_CACHE_S    *dlc_prev(DL_CACHE_S *, DL_CACHE_S *);
  32 DL_CACHE_S    *dlc_next(DL_CACHE_S *, DL_CACHE_S *);
  33 DL_CACHE_S    *get_global_top_dlc(DL_CACHE_S *);
  34 DL_CACHE_S    *get_global_bottom_dlc(DL_CACHE_S *);
  35 DL_CACHE_S    *get_top_dl_of_adrbk(int, DL_CACHE_S *);
  36 DL_CACHE_S    *get_bottom_dl_of_adrbk(int, DL_CACHE_S *);
  37
  38
  39 #define NO_PERMISSION   _("[ Permission Denied ]")
  40 /* TRANSLATORS: This is a heading referring to something that is readable
  41    but not writeable. */
  42 #define READONLY        _(" (ReadOnly)")
  43 /* TRANSLATORS: Not readable */
  44 #define NOACCESS        _(" (Un-readable)")
  45 /* TRANSLATORS: Directories, as in LDAP Directories. A heading. */
  46 #define OLDSTYLE_DIR_TITLE      _("Directories")
  47
  48
  49 /* data for the display list cache */
  50 static DL_CACHE_S *cache_array = (DL_CACHE_S *)NULL;
  51 static long        valid_low,
  52                    valid_high;
  53 static int         index_of_low,
  54                    size_of_cache,
  55                    n_cached;
  56
  57
  58 void
  59 initialize_dlc_cache(void)
  60 {
  61     dprint((11, "- initialize_dlc_cache -\n"));
  62
  63     (void)dlc_mgr(NO_LINE, Initialize, (DL_CACHE_S *)NULL);
  64 }
  65
  66
  67 void
  68 done_with_dlc_cache(void)
  69 {
  70     dprint((11, "- done_with_dlc_cache -\n"));
  71
  72     (void)dlc_mgr(NO_LINE, DoneWithCache, (DL_CACHE_S *)NULL);
  73 }
  74
  75
  76 /*
  77  * Returns 1 if the dlc's are related to each other, 0 otherwise.
  78  *
  79  * The idea is that if you are going to flush one of these dlcs from the
  80  * cache you should also flush its partners. For example, if you flush one
  81  * Listent from a list you should flush the entire entry including all the
  82  * Listents and the ListHead. If you flush a DlcTitle, you should also
  83  * flush the SubTitle and the TitleBlankTop.
  84  */
  85 int
  86 dlc_siblings(DL_CACHE_S *dlc1, DL_CACHE_S *dlc2)
  87 {
  88     if(!dlc1 || !dlc2 || dlc1->adrbk_num != dlc2->adrbk_num)
  89       return 0;
  90
  91     switch(dlc1->type){
  92
  93       case DlcSimple:
  94       case DlcListHead:
  95       case DlcListBlankTop:
  96       case DlcListBlankBottom:
  97       case DlcListEnt:
  98       case DlcListClickHere:
  99       case DlcListEmpty:
 100         switch(dlc2->type){
 101           case DlcSimple:
 102           case DlcListHead:
 103           case DlcListBlankTop:
 104           case DlcListBlankBottom:
 105           case DlcListEnt:
 106           case DlcListClickHere:
 107           case DlcListEmpty:
 108             return(dlc1->dlcelnum == dlc2->dlcelnum);
 109
 110           default:
 111             return 0;
 112         }
 113
 114         break;
 115
 116       case DlcDirDelim1:
 117       case DlcDirDelim2:
 118         switch(dlc2->type){
 119           case DlcDirDelim1:
 120           case DlcDirDelim2:
 121             return 1;
 122
 123           default:
 124             return 0;
 125         }
 126         break;
 127
 128       case DlcGlobDelim1:
 129       case DlcGlobDelim2:
 130         switch(dlc2->type){
 131           case DlcGlobDelim1:
 132           case DlcGlobDelim2:
 133             return 1;
 134
 135           default:
 136             return 0;
 137         }
 138         break;
 139
 140       case DlcTitle:
 141       case DlcTitleNoPerm:
 142       case DlcSubTitle:
 143       case DlcTitleBlankTop:
 144         switch(dlc2->type){
 145           case DlcTitle:
 146           case DlcTitleNoPerm:
 147           case DlcSubTitle:
 148           case DlcTitleBlankTop:
 149             return 1;
 150
 151           default:
 152             return 0;
 153         }
 154         break;
 155
 156       case DlcDirAccess:
 157       case DlcDirSubTitle:
 158       case DlcDirBlankTop:
 159         switch(dlc2->type){
 160           case DlcDirAccess:
 161           case DlcDirSubTitle:
 162           case DlcDirBlankTop:
 163             return 1;
 164
 165           default:
 166             return 0;
 167         }
 168         break;
 169
 170       case DlcTitleDashTopCmb:
 171       case DlcTitleCmb:
 172       case DlcTitleDashBottomCmb:
 173       case DlcTitleBlankBottomCmb:
 174       case DlcClickHereCmb:
 175       case DlcTitleBlankTopCmb:
 176         switch(dlc2->type){
 177           case DlcTitleDashTopCmb:
 178           case DlcTitleCmb:
 179           case DlcTitleDashBottomCmb:
 180           case DlcTitleBlankBottomCmb:
 181           case DlcClickHereCmb:
 182           case DlcTitleBlankTopCmb:
 183             return 1;
 184
 185           default:
 186             return 0;
 187         }
 188         break;
 189
 190       default:
 191         return 0;
 192     }
 193     /*NOTREACHED*/
 194 }
 195
 196
 197 /*
 198  * Manage the display list cache.
 199  *
 200  * The cache is a circular array of DL_CACHE_S elements.  It always
 201  * contains a contiguous set of display lines.
 202  * The lowest numbered line in the cache is
 203  * valid_low, and the highest is valid_high.  Everything in between is
 204  * also valid.  Index_of_low is where to look
 205  * for the valid_low element in the circular array.
 206  *
 207  * We make calls to dlc_prev and dlc_next to get new entries for the cache.
 208  * We need a starting value before we can do that.
 209  *
 210  * This returns a pointer to a dlc for the desired row.  If you want the
 211  * actual display list line you call dlist(row) instead of dlc_mgr.
 212  */
 213 DL_CACHE_S *
 214 dlc_mgr(long int row, DlMgrOps op, DL_CACHE_S *dlc_start)
 215 {
 216     int                new_index, known_index, next_index = 0;
 217     DL_CACHE_S        *dlc = (DL_CACHE_S *)NULL;
 218     long               next_row = 0L;
 219     long               prev_row = 0L;
 220
 221
 222     if(op == Lookup){
 223
 224         if(row >= valid_low && row <= valid_high){  /* already cached */
 225
 226             new_index = ((row - valid_low) + index_of_low) % size_of_cache;
 227             dlc = &cache_array[new_index];
 228
 229         }
 230         else if(row > valid_high){  /* row is past where we've looked */
 231
 232             known_index =
 233               ((valid_high - valid_low) + index_of_low) % size_of_cache;
 234             next_row    = valid_high + 1L;
 235
 236             /* we'll usually be looking for row = valid_high + 1 */
 237             while(next_row <= row){
 238
 239                 new_index = (known_index + 1) % size_of_cache;
 240
 241                 dlc =
 242                   dlc_next(&cache_array[known_index], &cache_array[new_index]);
 243
 244                 /*
 245                  * This means somebody changed the file out from underneath
 246                  * us.  This would happen if dlc_next needed to ask for an
 247                  * abe to figure out what the type of the next row is, but
 248                  * adrbk_get_ae returned a NULL.  I don't think that can
 249                  * happen, but if it does...
 250                  */
 251                 if(dlc->type == DlcNotSet){
 252                     dprint((1, "dlc_next returned DlcNotSet\n"));
 253                     goto panic_abook_corrupt;
 254                 }
 255
 256                 if(n_cached == size_of_cache){ /* replaced low cache entry */
 257                     valid_low++;
 258                     index_of_low = (index_of_low + 1) % size_of_cache;
 259                 }
 260                 else
 261                   n_cached++;
 262
 263                 valid_high++;
 264
 265                 next_row++;
 266                 known_index = new_index; /* for next time through loop */
 267             }
 268         }
 269         else if(row < valid_low){  /* row is back up the screen */
 270
 271             known_index = index_of_low;
 272             prev_row = valid_low - 1L;
 273
 274             while(prev_row >= row){
 275
 276                 new_index = (known_index - 1 + size_of_cache) % size_of_cache;
 277                 dlc =
 278                   dlc_prev(&cache_array[known_index], &cache_array[new_index]);
 279
 280                 if(dlc->type == DlcNotSet){
 281                     dprint((1, "dlc_prev returned DlcNotSet (1)\n"));
 282                     goto panic_abook_corrupt;
 283                 }
 284
 285                 if(n_cached == size_of_cache) /* replaced high cache entry */
 286                   valid_high--;
 287                 else
 288                   n_cached++;
 289
 290                 valid_low--;
 291                 index_of_low =
 292                             (index_of_low - 1 + size_of_cache) % size_of_cache;
 293
 294                 prev_row--;
 295                 known_index = new_index;
 296             }
 297         }
 298     }
 299     else if(op == Initialize){
 300
 301         n_cached = 0;
 302
 303         if(!cache_array || size_of_cache != 3 * MAX(as.l_p_page,1)){
 304             if(cache_array)
 305               free_cache_array(&cache_array, size_of_cache);
 306
 307             size_of_cache = 3 * MAX(as.l_p_page,1);
 308             cache_array =
 309                 (DL_CACHE_S *)fs_get(size_of_cache * sizeof(DL_CACHE_S));
 310             memset((void *)cache_array, 0, size_of_cache * sizeof(DL_CACHE_S));
 311         }
 312
 313         /* this will return NULL below and the caller should ignore that */
 314     }
 315     /*
 316      * Flush all rows for a particular addrbook entry from the cache, but
 317      * keep the cache alive and anchored in the same place.  The particular
 318      * entry is the one that dlc_start is one of the rows of.
 319      */
 320     else if(op == FlushDlcFromCache){
 321         long low_entry;
 322
 323         next_row = dlc_start->global_row - 1;
 324         for(; next_row >= valid_low; next_row--){
 325             next_index = ((next_row - valid_low) + index_of_low) %
 326                 size_of_cache;
 327             if(!dlc_siblings(dlc_start, &cache_array[next_index]))
 328                 break;
 329         }
 330
 331         low_entry = next_row + 1L;
 332
 333         /*
 334          * If low_entry now points one past a ListBlankBottom, delete that,
 335          * too, since it may not make sense anymore.
 336          */
 337         if(low_entry > valid_low){
 338             next_index = ((low_entry -1L - valid_low) + index_of_low) %
 339                 size_of_cache;
 340             if(cache_array[next_index].type == DlcListBlankBottom)
 341                 low_entry--;
 342         }
 343
 344         if(low_entry > valid_low){ /* invalidate everything >= this */
 345             n_cached -= (valid_high - (low_entry - 1L));
 346             valid_high = low_entry - 1L;
 347         }
 348         else{
 349             /*
 350              * This is the tough case.  That entry was the first thing cached,
 351              * so we need to invalidate the whole cache.  However, we also
 352              * need to keep at least one thing cached for an anchor, so
 353              * we need to get the dlc before this one and it should be a
 354              * dlc not related to this same addrbook entry.
 355              */
 356             known_index = index_of_low;
 357             prev_row = valid_low - 1L;
 358
 359             for(;;){
 360
 361                 new_index = (known_index - 1 + size_of_cache) % size_of_cache;
 362                 dlc =
 363                   dlc_prev(&cache_array[known_index], &cache_array[new_index]);
 364
 365                 if(dlc->type == DlcNotSet){
 366                     dprint((1, "dlc_prev returned DlcNotSet (2)\n"));
 367                     goto panic_abook_corrupt;
 368                 }
 369
 370                 valid_low--;
 371                 index_of_low =
 372                             (index_of_low - 1 + size_of_cache) % size_of_cache;
 373
 374                 if(!dlc_siblings(dlc_start, dlc))
 375                   break;
 376
 377                 known_index = new_index;
 378             }
 379
 380             n_cached = 1;
 381             valid_high = valid_low;
 382         }
 383     }
 384     /*
 385      * We have to anchor ourselves at a first element.
 386      * Here's how we start at the top.
 387      */
 388     else if(op == FirstEntry){
 389         initialize_dlc_cache();
 390         n_cached++;
 391         dlc = &cache_array[0];
 392         dlc = get_global_top_dlc(dlc);
 393         dlc->global_row = row;
 394         index_of_low = 0;
 395         valid_low    = row;
 396         valid_high   = row;
 397     }
 398     /* And here's how we start from the bottom. */
 399     else if(op == LastEntry){
 400         initialize_dlc_cache();
 401         n_cached++;
 402         dlc = &cache_array[0];
 403         dlc = get_global_bottom_dlc(dlc);
 404         dlc->global_row = row;
 405         index_of_low = 0;
 406         valid_low    = row;
 407         valid_high   = row;
 408     }
 409     /*
 410      * And here's how we start from an arbitrary position in the middle.
 411      * We root the cache at display line row, so it helps if row is close
 412      * to where we're going to be starting so that things are easy to find.
 413      * The dl that goes with line row is dl_start from addrbook number
 414      * adrbk_num_start.
 415      */
 416     else if(op == ArbitraryStartingPoint){
 417         AddrScrn_Disp      dl;
 418
 419         initialize_dlc_cache();
 420         n_cached++;
 421         dlc = &cache_array[0];
 422         /*
 423          * Save this in case fill_in_dl_field needs to free the text
 424          * it points to.
 425          */
 426         dl = dlc->dl;
 427         *dlc = *dlc_start;
 428         dlc->dl = dl;
 429         dlc->global_row = row;
 430
 431         index_of_low = 0;
 432         valid_low    = row;
 433         valid_high   = row;
 434     }
 435     else if(op == DoneWithCache){
 436
 437         n_cached = 0;
 438         if(cache_array)
 439           free_cache_array(&cache_array, size_of_cache);
 440     }
 441
 442     return(dlc);
 443
 444 panic_abook_corrupt:
 445     q_status_message(SM_ORDER | SM_DING, 5, 10,
 446         _("Addrbook changed unexpectedly, re-syncing..."));
 447     dprint((1,
 448         _("addrbook changed while we had it open?, re-sync\n")));
 449     dprint((2,
 450         "valid_low=%ld valid_high=%ld index_of_low=%d size_of_cache=%d\n",
 451         valid_low, valid_high, index_of_low, size_of_cache));
 452     dprint((2,
 453         "n_cached=%d new_index=%d known_index=%d next_index=%d\n",
 454         n_cached, new_index, known_index, next_index));
 455     dprint((2,
 456         "next_row=%ld prev_row=%ld row=%ld\n", next_row, prev_row, row));
 457     /* jump back to a safe starting point */
 458     longjmp(addrbook_changed_unexpectedly, 1);
 459     /*NOTREACHED*/
 460 }
 461
 462
 463 void
 464 free_cache_array(DL_CACHE_S **c_array, int size)
 465 {
 466     DL_CACHE_S *dlc;
 467     int i;
 468
 469     for(i = 0; i < size; i++){
 470         dlc = &(*c_array)[i];
 471         /* free any allocated space */
 472         switch(dlc->dl.type){
 473           case Text:
 474           case Title:
 475           case TitleCmb:
 476           case AskServer:
 477             if(dlc->dl.usst)
 478               fs_give((void **)&dlc->dl.usst);
 479
 480             break;
 481           default:
 482             break;
 483         }
 484     }
 485
 486     fs_give((void **)c_array);
 487 }
 488
 489
 490 /*
 491  * Get the dlc element that comes before "old".  The function that calls this
 492  * function is the one that keeps a cache and checks in the cache before
 493  * calling here.  New is a passed in pointer to a buffer where we fill in
 494  * the answer.
 495  */
 496 DL_CACHE_S *
 497 dlc_prev(DL_CACHE_S *old, DL_CACHE_S *new)
 498 {
 499     PerAddrBook  *pab;
 500     AdrBk_Entry  *abe;
 501     adrbk_cntr_t  list_count;
 502
 503     new->adrbk_num  = -2;
 504     new->dlcelnum   = NO_NEXT;
 505     new->dlcoffset  = NO_NEXT;
 506     new->type       = DlcNotSet;
 507     pab = &as.adrbks[old->adrbk_num];
 508
 509     switch(old->type){
 510       case DlcTitle:
 511       case DlcTitleNoPerm:
 512         if(old->adrbk_num == 0 && as.config && as.how_many_personals == 0)
 513           new->type = DlcGlobDelim2;
 514         else if(old->adrbk_num == 0)
 515           new->type = DlcOneBeforeBeginning;
 516         else if(old->adrbk_num == as.how_many_personals)
 517           new->type = DlcGlobDelim2;
 518         else
 519           new->type = DlcTitleBlankTop;
 520
 521         break;
 522
 523       case DlcSubTitle:
 524         if(pab->access == NoAccess)
 525           new->type = DlcTitleNoPerm;
 526         else
 527           new->type = DlcTitle;
 528
 529         break;
 530
 531       case DlcTitleBlankTop:
 532         new->adrbk_num = old->adrbk_num - 1;
 533         new->type = DlcSubTitle;
 534         break;
 535
 536       case DlcEmpty:
 537       case DlcZoomEmpty:
 538       case DlcNoPermission:
 539       case DlcNoAbooks:
 540         if(F_ON(F_CMBND_ABOOK_DISP,ps_global)){
 541             if(as.n_addrbk == 1 && as.n_serv == 0)
 542               new->type = DlcOneBeforeBeginning;
 543             else
 544               new->type = DlcTitleBlankBottomCmb;
 545         }
 546         else
 547           new->type = DlcOneBeforeBeginning;
 548
 549         break;
 550
 551       case DlcSimple:
 552         {
 553         adrbk_cntr_t el;
 554         long i;
 555
 556         i = old->dlcelnum;
 557         i--;
 558         el = old->dlcelnum - 1;
 559         while(i >= 0L){
 560             if(!as.zoomed || entry_is_selected(pab->address_book->selects,
 561                                                (a_c_arg_t)el))
 562               break;
 563
 564             el--;
 565             i--;
 566         }
 567
 568         if(i >= 0){
 569             new->dlcelnum = el;
 570             abe = adrbk_get_ae(pab->address_book, (a_c_arg_t) new->dlcelnum);
 571             if(abe && abe->tag == Single)
 572               new->type = DlcSimple;
 573             else if(abe && abe->tag == List)
 574               new->type = DlcListBlankBottom;
 575         }
 576         else if(F_ON(F_CMBND_ABOOK_DISP,ps_global)){
 577             if(as.n_addrbk == 1 && as.n_serv == 0)
 578               new->type = DlcOneBeforeBeginning;
 579             else
 580               new->type = DlcTitleBlankBottomCmb;
 581         }
 582         else
 583           new->type = DlcOneBeforeBeginning;
 584         }
 585
 586         break;
 587
 588       case DlcListHead:
 589         {
 590         adrbk_cntr_t el;
 591         long i;
 592
 593         i = old->dlcelnum;
 594         i--;
 595         el = old->dlcelnum - 1;
 596         while(i >= 0L){
 597             if(!as.zoomed || entry_is_selected(pab->address_book->selects,
 598                                                (a_c_arg_t)el))
 599               break;
 600
 601             el--;
 602             i--;
 603         }
 604
 605         if(i >= 0){
 606             new->dlcelnum = el;
 607             abe = adrbk_get_ae(pab->address_book, (a_c_arg_t) new->dlcelnum);
 608             if(abe && abe->tag == Single){
 609                 new->type  = DlcListBlankTop;
 610                 new->dlcelnum = old->dlcelnum;
 611             }
 612             else if(abe && abe->tag == List)
 613               new->type  = DlcListBlankBottom;
 614         }
 615         else if(F_ON(F_CMBND_ABOOK_DISP,ps_global)){
 616             if(as.n_addrbk == 1 && as.n_serv == 0)
 617               new->type = DlcOneBeforeBeginning;
 618             else
 619               new->type = DlcTitleBlankBottomCmb;
 620         }
 621         else
 622           new->type = DlcOneBeforeBeginning;
 623         }
 624
 625         break;
 626
 627       case DlcListEnt:
 628         if(old->dlcoffset > 0){
 629             new->type      = DlcListEnt;
 630             new->dlcelnum  = old->dlcelnum;
 631             new->dlcoffset = old->dlcoffset - 1;
 632         }
 633         else{
 634             new->type     = DlcListHead;
 635             new->dlcelnum = old->dlcelnum;
 636         }
 637
 638         break;
 639
 640       case DlcListClickHere:
 641       case DlcListEmpty:
 642         new->type     = DlcListHead;
 643         new->dlcelnum = old->dlcelnum;
 644         break;
 645
 646       case DlcListBlankTop:  /* can only occur between a Simple and a List */
 647         new->type   = DlcSimple;
 648         {
 649         adrbk_cntr_t el;
 650         long i;
 651
 652         i = old->dlcelnum;
 653         i--;
 654         el = old->dlcelnum - 1;
 655         while(i >= 0L){
 656             if(!as.zoomed || entry_is_selected(pab->address_book->selects,
 657                                                (a_c_arg_t)el))
 658               break;
 659
 660             el--;
 661             i--;
 662         }
 663
 664         if(i >= 0)
 665           new->dlcelnum = el;
 666         else{
 667             dprint((1, "Bug in addrbook: case ListBlankTop with no selected entry\n"));
 668             goto oops;
 669         }
 670         }
 671
 672         break;
 673
 674       case DlcListBlankBottom:
 675         new->dlcelnum = old->dlcelnum;
 676         abe = adrbk_get_ae(pab->address_book, (a_c_arg_t) new->dlcelnum);
 677         if(F_ON(F_EXPANDED_DISTLISTS,ps_global)
 678           || exp_is_expanded(pab->address_book->exp, (a_c_arg_t)new->dlcelnum)){
 679             list_count = listmem_count_from_abe(abe);
 680             if(list_count == 0)
 681               new->type = DlcListEmpty;
 682             else{
 683                 new->type      = DlcListEnt;
 684                 new->dlcoffset = list_count - 1;
 685             }
 686         }
 687         else
 688           new->type = DlcListClickHere;
 689
 690         break;
 691
 692       case DlcGlobDelim1:
 693         if(as.how_many_personals == 0)
 694           new->type = DlcPersAdd;
 695         else{
 696             new->adrbk_num = as.how_many_personals - 1;
 697             new->type = DlcSubTitle;
 698         }
 699         break;
 700
 701       case DlcGlobDelim2:
 702         new->type = DlcGlobDelim1;
 703         break;
 704
 705       case DlcPersAdd:
 706         new->type = DlcOneBeforeBeginning;
 707         break;
 708
 709       case DlcGlobAdd:
 710         new->type = DlcGlobDelim2;
 711         break;
 712
 713       case DlcDirAccess:
 714         if(old->adrbk_num == 0 && as.n_addrbk == 0)
 715           new->type = DlcOneBeforeBeginning;
 716         else if(old->adrbk_num == 0)
 717           new->type = DlcDirDelim2;
 718         else
 719           new->type = DlcDirBlankTop;
 720
 721         break;
 722
 723       case DlcDirSubTitle:
 724         new->type = DlcDirAccess;
 725         break;
 726
 727       case DlcDirBlankTop:
 728         new->adrbk_num = old->adrbk_num -1;
 729         new->type = DlcDirSubTitle;
 730         break;
 731
 732       case DlcDirDelim1:
 733         new->adrbk_num = as.n_addrbk - 1;
 734         if(as.n_addrbk == 0)
 735           new->type = DlcNoAbooks;
 736         else
 737           new = get_bottom_dl_of_adrbk(new->adrbk_num, new);
 738
 739         break;
 740
 741       case DlcDirDelim1a:
 742         new->type = DlcDirDelim1;
 743         break;
 744
 745       case DlcDirDelim1b:
 746         new->type = DlcDirDelim1a;
 747         break;
 748
 749       case DlcDirDelim1c:
 750         new->type = DlcDirDelim1b;
 751         break;
 752
 753       case DlcDirDelim2:
 754         if(F_ON(F_CMBND_ABOOK_DISP,ps_global))
 755           new->type = DlcDirDelim1c;
 756         else
 757           new->type = DlcDirDelim1;
 758
 759         break;
 760
 761       case DlcTitleDashTopCmb:
 762         if(old->adrbk_num == 0)
 763           new->type = DlcOneBeforeBeginning;
 764         else
 765           new->type = DlcTitleBlankTopCmb;
 766
 767         break;
 768
 769       case DlcTitleCmb:
 770         new->type = DlcTitleDashTopCmb;
 771         break;
 772
 773       case DlcTitleDashBottomCmb:
 774         new->type = DlcTitleCmb;
 775         break;
 776
 777       case DlcTitleBlankBottomCmb:
 778         new->type = DlcTitleDashBottomCmb;
 779         break;
 780
 781       case DlcClickHereCmb:
 782         if(as.n_addrbk == 1 && as.n_serv == 0)
 783           new->type = DlcOneBeforeBeginning;
 784         else
 785           new->type = DlcTitleBlankBottomCmb;
 786
 787         break;
 788
 789       case DlcTitleBlankTopCmb:
 790         new->adrbk_num = old->adrbk_num - 1;
 791         new = get_bottom_dl_of_adrbk(new->adrbk_num, new);
 792         break;
 793
 794       case DlcBeginning:
 795       case DlcTwoBeforeBeginning:
 796         new->type = DlcBeginning;
 797         break;
 798
 799       case DlcOneBeforeBeginning:
 800         new->type = DlcTwoBeforeBeginning;
 801         break;
 802
 803 oops:
 804       default:
 805         q_status_message(SM_ORDER | SM_DING, 5, 10,
 806             _("Bug in addrbook, not supposed to happen, re-syncing..."));
 807         dprint((1, "Bug in addrbook, impossible case (%d) in dlc_prev, re-sync\n",
 808             old->type));
 809         /* jump back to a safe starting point */
 810         longjmp(addrbook_changed_unexpectedly, 1);
 811         /*NOTREACHED*/
 812     }
 813
 814     new->global_row = old->global_row - 1L;
 815     if(new->adrbk_num == -2)
 816       new->adrbk_num = old->adrbk_num;
 817
 818     return(new);
 819 }
 820
 821
 822 /*
 823  * Get the dlc element that comes after "old".  The function that calls this
 824  * function is the one that keeps a cache and checks in the cache before
 825  * calling here.
 826  */
 827 DL_CACHE_S *
 828 dlc_next(DL_CACHE_S *old, DL_CACHE_S *new)
 829 {
 830     PerAddrBook  *pab;
 831     AdrBk_Entry  *abe;
 832     adrbk_cntr_t  ab_count;
 833     adrbk_cntr_t  list_count;
 834
 835     new->adrbk_num  = -2;
 836     new->dlcelnum   = NO_NEXT;
 837     new->dlcoffset  = NO_NEXT;
 838     new->type       = DlcNotSet;
 839     pab = &as.adrbks[old->adrbk_num];
 840
 841     switch(old->type){
 842       case DlcTitle:
 843       case DlcTitleNoPerm:
 844         new->type = DlcSubTitle;
 845         break;
 846
 847       case DlcSubTitle:
 848         if((old->adrbk_num == as.how_many_personals - 1) &&
 849            (as.config || as.n_addrbk > as.how_many_personals))
 850           new->type = DlcGlobDelim1;
 851         else if(as.n_serv && !as.config &&
 852                 (old->adrbk_num == as.n_addrbk - 1))
 853           new->type = DlcDirDelim1;
 854         else if(old->adrbk_num == as.n_addrbk - 1)
 855           new->type = DlcEnd;
 856         else{
 857             new->adrbk_num = old->adrbk_num + 1;
 858             new->type = DlcTitleBlankTop;
 859         }
 860
 861         break;
 862
 863       case DlcTitleBlankTop:
 864         if(pab->access == NoAccess)
 865           new->type = DlcTitleNoPerm;
 866         else
 867           new->type = DlcTitle;
 868
 869         break;
 870
 871       case DlcEmpty:
 872       case DlcZoomEmpty:
 873       case DlcNoPermission:
 874       case DlcClickHereCmb:
 875         if(F_ON(F_CMBND_ABOOK_DISP,ps_global)){
 876             if(old->adrbk_num < as.n_addrbk - 1){
 877                 new->adrbk_num = old->adrbk_num + 1;
 878                 new->type = DlcTitleBlankTopCmb;
 879             }
 880             else if(as.n_serv)
 881               new->type = DlcDirDelim1;
 882             else
 883               new->type = DlcEnd;
 884         }
 885         else
 886           new->type = DlcEnd;
 887
 888         break;
 889
 890       case DlcNoAbooks:
 891       case DlcGlobAdd:
 892       case DlcEnd:
 893         new->type = DlcEnd;
 894         break;
 895
 896       case DlcSimple:
 897         {
 898         adrbk_cntr_t el;
 899         long i;
 900
 901         ab_count = adrbk_count(pab->address_book);
 902         i = old->dlcelnum;
 903         i++;
 904         el = old->dlcelnum + 1;
 905         while(i < ab_count){
 906             if(!as.zoomed || entry_is_selected(pab->address_book->selects,
 907                                                (a_c_arg_t)el))
 908               break;
 909
 910             el++;
 911             i++;
 912         }
 913
 914         if(i < ab_count){
 915             new->dlcelnum = el;
 916             abe = adrbk_get_ae(pab->address_book, (a_c_arg_t) new->dlcelnum);
 917             if(abe && abe->tag == Single)
 918               new->type = DlcSimple;
 919             else if(abe && abe->tag == List)
 920               new->type = DlcListBlankTop;
 921         }
 922         else if(F_ON(F_CMBND_ABOOK_DISP,ps_global)){
 923             if(old->adrbk_num < as.n_addrbk - 1){
 924                 new->adrbk_num = old->adrbk_num + 1;
 925                 new->type = DlcTitleBlankTopCmb;
 926             }
 927             else if(as.n_serv)
 928               new->type = DlcDirDelim1;
 929             else
 930               new->type = DlcEnd;
 931         }
 932         else
 933           new->type = DlcEnd;
 934         }
 935
 936         break;
 937
 938       case DlcListHead:
 939         new->dlcelnum = old->dlcelnum;
 940         abe = adrbk_get_ae(pab->address_book, (a_c_arg_t) new->dlcelnum);
 941         if(F_ON(F_EXPANDED_DISTLISTS,ps_global)
 942           || exp_is_expanded(pab->address_book->exp, (a_c_arg_t)new->dlcelnum)){
 943             list_count = listmem_count_from_abe(abe);
 944             if(list_count == 0)
 945               new->type = DlcListEmpty;
 946             else{
 947                 new->type      = DlcListEnt;
 948                 new->dlcoffset = 0;
 949             }
 950         }
 951         else
 952           new->type = DlcListClickHere;
 953
 954         break;
 955
 956       case DlcListEnt:
 957         new->dlcelnum = old->dlcelnum;
 958         abe = adrbk_get_ae(pab->address_book, (a_c_arg_t) new->dlcelnum);
 959         list_count = listmem_count_from_abe(abe);
 960         if(old->dlcoffset == list_count - 1){  /* last member of list */
 961             adrbk_cntr_t el;
 962             long i;
 963
 964             ab_count = adrbk_count(pab->address_book);
 965             i = old->dlcelnum;
 966             i++;
 967             el = old->dlcelnum + 1;
 968             while(i < ab_count){
 969                 if(!as.zoomed || entry_is_selected(pab->address_book->selects,
 970                                                    (a_c_arg_t)el))
 971                   break;
 972
 973                 el++;
 974                 i++;
 975             }
 976
 977             if(i < ab_count)
 978               new->type = DlcListBlankBottom;
 979             else if(F_ON(F_CMBND_ABOOK_DISP,ps_global)){
 980                 if(old->adrbk_num < as.n_addrbk - 1){
 981                     new->adrbk_num = old->adrbk_num + 1;
 982                     new->type = DlcTitleBlankTopCmb;
 983                 }
 984                 else if(as.n_serv)
 985                   new->type = DlcDirDelim1;
 986                 else
 987                   new->type = DlcEnd;
 988             }
 989             else
 990               new->type = DlcEnd;
 991         }
 992         else{
 993             new->type      = DlcListEnt;
 994             new->dlcoffset = old->dlcoffset + 1;
 995         }
 996
 997         break;
 998
 999       case DlcListClickHere:
1000       case DlcListEmpty:
1001         {
1002         adrbk_cntr_t el;
1003         long i;
1004
1005         new->dlcelnum = old->dlcelnum;
1006         ab_count = adrbk_count(pab->address_book);
1007         i = old->dlcelnum;
1008         i++;
1009         el = old->dlcelnum + 1;
1010         while(i < ab_count){
1011             if(!as.zoomed || entry_is_selected(pab->address_book->selects,
1012                                                (a_c_arg_t)el))
1013               break;
1014
1015             el++;
1016             i++;
1017         }
1018
1019         if(i < ab_count)
1020           new->type = DlcListBlankBottom;
1021         else if(F_ON(F_CMBND_ABOOK_DISP,ps_global)){
1022             if(old->adrbk_num < as.n_addrbk - 1){
1023                 new->adrbk_num = old->adrbk_num + 1;
1024                 new->type = DlcTitleBlankTopCmb;
1025             }
1026             else if(as.n_serv)
1027               new->type = DlcDirDelim1;
1028             else
1029               new->type = DlcEnd;
1030         }
1031         else
1032           new->type = DlcEnd;
1033         }
1034
1035         break;
1036
1037       case DlcListBlankTop:
1038         new->type   = DlcListHead;
1039         new->dlcelnum  = old->dlcelnum;
1040         break;
1041
1042       case DlcListBlankBottom:
1043         {
1044         adrbk_cntr_t el;
1045         long i;
1046
1047         ab_count = adrbk_count(pab->address_book);
1048         i = old->dlcelnum;
1049         i++;
1050         el = old->dlcelnum + 1;
1051         while(i < ab_count){
1052             if(!as.zoomed || entry_is_selected(pab->address_book->selects,
1053                                                (a_c_arg_t)el))
1054               break;
1055
1056             el++;
1057             i++;
1058         }
1059
1060         if(i < ab_count){
1061             new->dlcelnum = el;
1062             abe = adrbk_get_ae(pab->address_book, (a_c_arg_t) new->dlcelnum);
1063             if(abe && abe->tag == Single)
1064               new->type = DlcSimple;
1065             else if(abe && abe->tag == List)
1066               new->type = DlcListHead;
1067         }
1068         else
1069           /* can't happen */
1070           new->type = DlcEnd;
1071         }
1072
1073         break;
1074
1075       case DlcGlobDelim1:
1076         new->type = DlcGlobDelim2;
1077         break;
1078
1079       case DlcGlobDelim2:
1080         if(as.config && as.how_many_personals == as.n_addrbk)
1081           new->type = DlcGlobAdd;
1082         else{
1083             new->adrbk_num = as.how_many_personals;
1084             pab = &as.adrbks[new->adrbk_num];
1085             if(pab->access == NoAccess)
1086               new->type = DlcTitleNoPerm;
1087             else
1088               new->type = DlcTitle;
1089         }
1090
1091         break;
1092
1093       case DlcDirDelim1:
1094         if(F_ON(F_CMBND_ABOOK_DISP,ps_global))
1095           new->type = DlcDirDelim1a;
1096         else
1097           new->type = DlcDirDelim2;
1098
1099         new->adrbk_num = 0;
1100         break;
1101
1102       case DlcDirDelim1a:
1103         new->type = DlcDirDelim1b;
1104         break;
1105
1106       case DlcDirDelim1b:
1107         new->type = DlcDirDelim1c;
1108         break;
1109
1110       case DlcDirDelim1c:
1111         new->type = DlcDirDelim2;
1112         new->adrbk_num = 0;
1113         break;
1114
1115       case DlcDirDelim2:
1116         new->type = DlcDirAccess;
1117         new->adrbk_num = 0;
1118         break;
1119
1120       case DlcPersAdd:
1121         new->type = DlcGlobDelim1;
1122         break;
1123
1124       case DlcDirAccess:
1125         new->type = DlcDirSubTitle;
1126         break;
1127
1128       case DlcDirSubTitle:
1129         if(old->adrbk_num == as.n_serv - 1)
1130           new->type = DlcEnd;
1131         else{
1132             new->type = DlcDirBlankTop;
1133             new->adrbk_num = old->adrbk_num + 1;
1134         }
1135
1136         break;
1137
1138       case DlcDirBlankTop:
1139         new->type = DlcDirAccess;
1140         break;
1141
1142       case DlcTitleDashTopCmb:
1143         new->type = DlcTitleCmb;
1144         break;
1145
1146       case DlcTitleCmb:
1147         new->type = DlcTitleDashBottomCmb;
1148         break;
1149
1150       case DlcTitleDashBottomCmb:
1151         new->type = DlcTitleBlankBottomCmb;
1152         break;
1153
1154       case DlcTitleBlankBottomCmb:
1155         pab = &as.adrbks[old->adrbk_num];
1156         if(pab->ostatus != Open && pab->access != NoAccess)
1157           new->type = DlcClickHereCmb;
1158         else
1159           new = get_top_dl_of_adrbk(old->adrbk_num, new);
1160
1161         break;
1162
1163       case DlcTitleBlankTopCmb:
1164         new->type = DlcTitleDashTopCmb;
1165         break;
1166
1167       case DlcOneBeforeBeginning:
1168         new = get_global_top_dlc(new);
1169         break;
1170
1171       case DlcTwoBeforeBeginning:
1172         new->type = DlcOneBeforeBeginning;
1173         break;
1174
1175       default:
1176         q_status_message(SM_ORDER | SM_DING, 5, 10,
1177             _("Bug in addrbook, not supposed to happen, re-syncing..."));
1178         dprint((1, "Bug in addrbook, impossible case (%d) in dlc_next, re-sync\n",
1179                 old->type));
1180         /* jump back to a safe starting point */
1181         longjmp(addrbook_changed_unexpectedly, 1);
1182         /*NOTREACHED*/
1183     }
1184
1185     new->global_row = old->global_row + 1L;
1186     if(new->adrbk_num == -2)
1187       new->adrbk_num = old->adrbk_num;
1188
1189     return(new);
1190 }
1191
1192
1193 /*
1194  * Get the display line at the very top of whole addrbook screen display.
1195  */
1196 DL_CACHE_S *
1197 get_global_top_dlc(DL_CACHE_S *new)
1198                       /* fill in answer here */
1199 {
1200     PerAddrBook  *pab;
1201
1202     new->dlcelnum   = NO_NEXT;
1203     new->dlcoffset  = NO_NEXT;
1204     new->type       = DlcNotSet;
1205
1206     if(F_ON(F_CMBND_ABOOK_DISP,ps_global) && !as.config){
1207         new->adrbk_num = 0;
1208         if(as.n_addrbk > 1 || (as.n_serv && as.n_addrbk == 1))
1209           new->type = DlcTitleDashTopCmb;
1210         else if(as.n_addrbk == 1)
1211           new = get_top_dl_of_adrbk(new->adrbk_num, new);
1212         else if(as.n_serv > 0){                         /* 1st directory */
1213             new->type = DlcDirAccess;
1214             new->adrbk_num = 0;
1215         }
1216         else
1217           new->type = DlcNoAbooks;
1218     }
1219     else{
1220         new->adrbk_num = 0;
1221
1222         if(as.config){
1223             if(as.how_many_personals == 0)              /* no personals */
1224               new->type = DlcPersAdd;
1225             else{
1226                 pab = &as.adrbks[new->adrbk_num];       /* 1st personal */
1227                 if(pab->access == NoAccess)
1228                   new->type = DlcTitleNoPerm;
1229                 else
1230                   new->type = DlcTitle;
1231             }
1232         }
1233         else if(any_ab_open()){
1234             new->adrbk_num = as.cur;
1235             new = get_top_dl_of_adrbk(new->adrbk_num, new);
1236         }
1237         else if(as.n_addrbk > 0){                       /* 1st addrbook */
1238             pab = &as.adrbks[new->adrbk_num];
1239             if(pab->access == NoAccess)
1240               new->type = DlcTitleNoPerm;
1241             else
1242               new->type = DlcTitle;
1243         }
1244         else if(as.n_serv > 0){                         /* 1st directory */
1245             new->type = DlcDirAccess;
1246             new->adrbk_num = 0;
1247         }
1248         else
1249           new->type = DlcNoAbooks;
1250     }
1251
1252     return(new);
1253 }
1254
1255
1256 /*
1257  * Get the last display line for the whole address book screen.
1258  * This gives us a way to start at the end and move back up.
1259  */
1260 DL_CACHE_S *
1261 get_global_bottom_dlc(DL_CACHE_S *new)
1262                       /* fill in answer here */
1263 {
1264     new->dlcelnum   = NO_NEXT;
1265     new->dlcoffset  = NO_NEXT;
1266     new->type       = DlcNotSet;
1267
1268     if(F_ON(F_CMBND_ABOOK_DISP,ps_global) && !as.config){
1269         if(as.n_serv){
1270             new->type = DlcDirSubTitle;
1271             new->adrbk_num = as.n_serv - 1;
1272         }
1273         else if(as.n_addrbk > 0){
1274             new->adrbk_num = as.n_addrbk - 1;
1275             new = get_bottom_dl_of_adrbk(new->adrbk_num, new);
1276         }
1277         else
1278           new->type = DlcNoAbooks;
1279     }
1280     else{
1281         new->adrbk_num = MAX(as.n_addrbk - 1, 0);
1282
1283         if(as.config){
1284             if(as.how_many_personals == as.n_addrbk)    /* no globals */
1285               new->type = DlcGlobAdd;
1286             else
1287               new->type = DlcSubTitle;
1288         }
1289         else if(any_ab_open()){
1290             new->adrbk_num = as.cur;
1291             new = get_bottom_dl_of_adrbk(new->adrbk_num, new);
1292         }
1293         else if(as.n_serv){
1294             new->type = DlcDirSubTitle;
1295             new->adrbk_num = as.n_serv - 1;
1296         }
1297         else{                           /* !config && !opened && !n_serv */
1298             if(as.n_addrbk)
1299               new->type = DlcSubTitle;
1300             else
1301               new->type = DlcNoAbooks;
1302         }
1303     }
1304
1305     return(new);
1306 }
1307
1308
1309 /*
1310  * First dl in a particular addrbook, not counting title lines.
1311  * Assumes as.opened.
1312  */
1313 DL_CACHE_S *
1314 get_top_dl_of_adrbk(int adrbk_num, DL_CACHE_S *new)
1315
1316                       /* fill in answer here */
1317 {
1318     PerAddrBook  *pab;
1319     AdrBk_Entry  *abe;
1320     adrbk_cntr_t  ab_count;
1321
1322     pab = &as.adrbks[adrbk_num];
1323     new->adrbk_num = adrbk_num;
1324
1325     if(pab->access == NoAccess)
1326       new->type = DlcNoPermission;
1327     else{
1328         adrbk_cntr_t el;
1329         long i;
1330
1331         ab_count = adrbk_count(pab->address_book);
1332
1333         i = 0L;
1334         el = 0;
1335         /* find first displayed entry */
1336         while(i < ab_count){
1337             if(!as.zoomed || entry_is_selected(pab->address_book->selects,
1338                                                (a_c_arg_t)el))
1339               break;
1340
1341             el++;
1342             i++;
1343         }
1344
1345         if(i < ab_count){
1346             new->dlcelnum = el;
1347             abe = adrbk_get_ae(pab->address_book, (a_c_arg_t) new->dlcelnum);
1348             if(abe && abe->tag == Single)
1349               new->type = DlcSimple;
1350             else if(abe && abe->tag == List)
1351               new->type = DlcListHead;
1352         }
1353         else if(as.zoomed)
1354           new->type = DlcZoomEmpty;
1355         else
1356           new->type = DlcEmpty;
1357     }
1358
1359     return(new);
1360 }
1361
1362
1363 /*
1364  * Find the last display line for addrbook number adrbk_num.
1365  * Assumes as.opened (unless OLD_ABOOK_DISP).
1366  */
1367 DL_CACHE_S *
1368 get_bottom_dl_of_adrbk(int adrbk_num, DL_CACHE_S *new)
1369
1370                       /* fill in answer here */
1371 {
1372     PerAddrBook  *pab;
1373     AdrBk_Entry  *abe;
1374     adrbk_cntr_t  ab_count;
1375     adrbk_cntr_t  list_count;
1376
1377     pab = &as.adrbks[adrbk_num];
1378     new->adrbk_num = adrbk_num;
1379
1380     if(F_ON(F_CMBND_ABOOK_DISP,ps_global) && pab->ostatus != Open){
1381         if(pab->access == NoAccess)
1382           new->type = DlcNoPermission;
1383         else
1384           new->type = DlcClickHereCmb;
1385     }
1386     else if(F_OFF(F_CMBND_ABOOK_DISP,ps_global) && pab->ostatus != Open){
1387         new->type = DlcSubTitle;
1388     }
1389     else{
1390         if(pab->access == NoAccess)
1391           new->type = DlcNoPermission;
1392         else{
1393             adrbk_cntr_t el;
1394             long i;
1395
1396             ab_count = adrbk_count(pab->address_book);
1397             i = ab_count - 1;
1398             el = ab_count - 1;
1399             /* find last displayed entry */
1400             while(i >= 0L){
1401                 if(!as.zoomed || entry_is_selected(pab->address_book->selects,
1402                                                    (a_c_arg_t)el))
1403                   break;
1404
1405                 el--;
1406                 i--;
1407             }
1408
1409             if(i >= 0){
1410                 new->dlcelnum = el;
1411                 abe = adrbk_get_ae(pab->address_book, (a_c_arg_t)new->dlcelnum);
1412                 if(abe && abe->tag == Single)
1413                   new->type = DlcSimple;
1414                 else if(abe && abe->tag == List){
1415                     if(F_ON(F_EXPANDED_DISTLISTS,ps_global)
1416                        || exp_is_expanded(pab->address_book->exp,
1417                                           (a_c_arg_t)new->dlcelnum)){
1418                         list_count = listmem_count_from_abe(abe);
1419                         if(list_count == 0)
1420                           new->type = DlcListEmpty;
1421                         else{
1422                             new->type      = DlcListEnt;
1423                             new->dlcoffset = list_count - 1;
1424                         }
1425                     }
1426                     else
1427                       new->type = DlcListClickHere;
1428                 }
1429             }
1430             else if(as.zoomed)
1431               new->type = DlcZoomEmpty;
1432             else
1433               new->type = DlcEmpty;
1434         }
1435
1436     }
1437
1438     return(new);
1439 }
1440
1441
1442 /*
1443  * This returns the actual dlc instead of the dl within the dlc.
1444  */
1445 DL_CACHE_S *
1446 get_dlc(long int row)
1447 {
1448     dprint((11, "- get_dlc(%ld) -\n", row));
1449
1450     return(dlc_mgr(row, Lookup, (DL_CACHE_S *)NULL));
1451 }
1452
1453
1454 /*
1455  * Move to new_dlc and give it row number row_number_to_assign_it.
1456  * We copy the passed in dlc in case the caller passed us a pointer into
1457  * the cache.
1458  */
1459 void
1460 warp_to_dlc(DL_CACHE_S *new_dlc, long int row_number_to_assign_it)
1461 {
1462     DL_CACHE_S dlc;
1463
1464     dprint((9, "- warp_to_dlc(%ld) -\n", row_number_to_assign_it));
1465
1466     dlc = *new_dlc;
1467
1468     /*
1469      * Make sure we can move forward and backward from these
1470      * types that we may wish to warp to. The caller may not have known
1471      * to set adrbk_num for these types.
1472      */
1473     switch(dlc.type){
1474       case DlcPersAdd:
1475         dlc.adrbk_num = 0;
1476         break;
1477       case DlcGlobAdd:
1478         dlc.adrbk_num = as.n_addrbk;
1479         break;
1480       default:
1481         break;
1482     }
1483
1484     (void)dlc_mgr(row_number_to_assign_it, ArbitraryStartingPoint, &dlc);
1485 }
1486
1487
1488 /*
1489  * Move to first dlc and give it row number 0.
1490  */
1491 void
1492 warp_to_beginning(void)
1493 {
1494     dprint((9, "- warp_to_beginning -\n"));
1495
1496     (void)dlc_mgr(0L, FirstEntry, (DL_CACHE_S *)NULL);
1497 }
1498
1499
1500 /*
1501  * Move to first dlc in abook_num and give it row number 0.
1502  */
1503 void
1504 warp_to_top_of_abook(int abook_num)
1505 {
1506     DL_CACHE_S dlc;
1507
1508     dprint((9, "- warp_to_top_of_abook(%d) -\n", abook_num));
1509
1510     (void)get_top_dl_of_adrbk(abook_num, &dlc);
1511     warp_to_dlc(&dlc, 0L);
1512 }
1513
1514
1515 /*
1516  * Move to last dlc and give it row number 0.
1517  */
1518 void
1519 warp_to_end(void)
1520 {
1521     dprint((9, "- warp_to_end -\n"));
1522
1523     (void)dlc_mgr(0L, LastEntry, (DL_CACHE_S *)NULL);
1524 }
1525
1526
1527 /*
1528  * This flushes all of the cache that is related to this dlc.
1529  */
1530 void
1531 flush_dlc_from_cache(DL_CACHE_S *dlc_to_flush)
1532 {
1533     dprint((11, "- flush_dlc_from_cache -\n"));
1534
1535     (void)dlc_mgr(NO_LINE, FlushDlcFromCache, dlc_to_flush);
1536 }
1537
1538
1539 /*
1540  * Returns 1 if the dlc's match, 0 otherwise.
1541  */
1542 int
1543 matching_dlcs(DL_CACHE_S *dlc1, DL_CACHE_S *dlc2)
1544 {
1545     if(!dlc1 || !dlc2 ||
1546         dlc1->type != dlc2->type ||
1547         dlc1->adrbk_num != dlc2->adrbk_num)
1548         return 0;
1549
1550     switch(dlc1->type){
1551
1552       case DlcSimple:
1553       case DlcListHead:
1554       case DlcListBlankTop:
1555       case DlcListBlankBottom:
1556       case DlcListClickHere:
1557       case DlcListEmpty:
1558         return(dlc1->dlcelnum == dlc2->dlcelnum);
1559
1560       case DlcListEnt:
1561         return(dlc1->dlcelnum  == dlc2->dlcelnum &&
1562                dlc1->dlcoffset == dlc2->dlcoffset);
1563
1564       case DlcTitle:
1565       case DlcSubTitle:
1566       case DlcTitleNoPerm:
1567       case DlcTitleBlankTop:
1568       case DlcEmpty:
1569       case DlcZoomEmpty:
1570       case DlcNoPermission:
1571       case DlcPersAdd:
1572       case DlcGlobAdd:
1573       case DlcGlobDelim1:
1574       case DlcGlobDelim2:
1575       case DlcDirAccess:
1576       case DlcDirDelim1:
1577       case DlcDirDelim2:
1578       case DlcTitleDashTopCmb:
1579       case DlcTitleCmb:
1580       case DlcTitleDashBottomCmb:
1581       case DlcTitleBlankBottomCmb:
1582       case DlcClickHereCmb:
1583       case DlcTitleBlankTopCmb:
1584         return 1;
1585
1586       case DlcNotSet:
1587       case DlcBeginning:
1588       case DlcOneBeforeBeginning:
1589       case DlcTwoBeforeBeginning:
1590       case DlcEnd:
1591       case DlcNoAbooks:
1592         return 0;
1593
1594       default:
1595         break;
1596     }
1597     /*NOTREACHED*/
1598
1599     return 0;
1600 }
1601
1602
1603 /*
1604  * Uses information in new to fill in new->dl.
1605  */
1606 void
1607 fill_in_dl_field(DL_CACHE_S *new)
1608 {
1609     AddrScrn_Disp *dl;
1610     PerAddrBook   *pab;
1611     char buf[6*MAX_SCREEN_COLS + 1];
1612     char buf2[6*1024];
1613     char hostbuf[128];
1614     char *folder;
1615     char *q;
1616     unsigned screen_width = ps_global->ttyo->screen_cols;
1617     unsigned got_width, need_width, cellwidth;
1618
1619     screen_width = MIN(MAX_SCREEN_COLS, screen_width);
1620
1621     dl = &(new->dl);
1622
1623     /* free any previously allocated space */
1624     switch(dl->type){
1625       case Text:
1626       case Title:
1627       case TitleCmb:
1628       case AskServer:
1629         if(dl->usst)
1630           fs_give((void **)&dl->usst);
1631       default:
1632         break;
1633     }
1634
1635     /* set up new dl */
1636     switch(new->type){
1637       case DlcListBlankTop:
1638       case DlcListBlankBottom:
1639       case DlcGlobDelim1:
1640       case DlcGlobDelim2:
1641       case DlcDirDelim1:
1642       case DlcDirDelim2:
1643       case DlcTitleBlankTop:
1644       case DlcDirBlankTop:
1645       case DlcTitleBlankBottomCmb:
1646       case DlcTitleBlankTopCmb:
1647         dl->type = Text;
1648         dl->usst = cpystr("");
1649         break;
1650
1651       case DlcTitleDashTopCmb:
1652       case DlcTitleDashBottomCmb:
1653       case DlcDirDelim1a:
1654       case DlcDirDelim1c:
1655         /* line of dashes in txt field */
1656         dl->type = Text;
1657         memset((void *)buf, '-', screen_width * sizeof(char));
1658         buf[screen_width] = '\0';
1659         dl->usst = cpystr(buf);
1660         break;
1661
1662       case DlcNoPermission:
1663         dl->type = Text;
1664         dl->usst = cpystr(NO_PERMISSION);
1665         break;
1666
1667       case DlcTitle:
1668       case DlcTitleNoPerm:
1669         dl->type = Title;
1670         pab = &as.adrbks[new->adrbk_num];
1671         /* title for this addrbook */
1672         snprintf(buf, sizeof(buf), "    %s", pab->abnick ? pab->abnick : pab->filename);
1673         cellwidth = utf8_width(buf);
1674         if(cellwidth > screen_width)
1675           cellwidth = utf8_truncate(buf, screen_width);
1676
1677         /* add space padding */
1678         if(cellwidth < screen_width)
1679           snprintf(buf+strlen(buf), sizeof(buf)-strlen(buf), "%*.*s",
1680                    screen_width - cellwidth, screen_width - cellwidth, "");
1681
1682         buf[sizeof(buf)-1] = '\0';
1683
1684         if(as.ro_warning && (pab->access == NoAccess || pab->access == ReadOnly)){
1685             char *str;
1686
1687             if(pab->access == NoAccess)
1688               str = NOACCESS;
1689             else
1690               str = READONLY;
1691
1692             need_width = utf8_width(str);
1693
1694             if(screen_width > need_width && (q = utf8_count_back_width(buf, buf+strlen(buf), need_width, &got_width)) != NULL)
1695
1696               (void) utf8_pad_to_width(q, str, sizeof(buf)-(q-buf), need_width, 0);
1697         }
1698
1699         buf[sizeof(buf)-1] = '\0';
1700         dl->usst = cpystr(buf);
1701         break;
1702
1703       case DlcSubTitle:
1704         dl->type = Text;
1705         pab = &as.adrbks[new->adrbk_num];
1706         /* Find a hostname to put in title */
1707         hostbuf[0] = '\0';
1708         folder = NULL;
1709         if(pab->type & REMOTE_VIA_IMAP && pab->filename){
1710             char *start, *end = NULL;
1711
1712             start = strindex(pab->filename, '{');
1713             if(start)
1714               end = strindex(start+1, '}');
1715
1716             if(start && end){
1717                 strncpy(hostbuf, start + 1,
1718                         MIN(end - start - 1, sizeof(hostbuf)-1));
1719                 hostbuf[MIN(end - start - 1, sizeof(hostbuf)-1)] = '\0';
1720                 if(*(end+1))
1721                   folder = end+1;
1722             }
1723         }
1724
1725         if(!folder)
1726           folder = pab->filename;
1727
1728         /*
1729          * Just trying to find the name relative to the home directory
1730          * to display in an OS-independent way.
1731          */
1732         if(folder && in_dir(ps_global->home_dir, folder)){
1733             char *p, *new_folder = NULL, *savep = NULL;
1734             int   l, saveval = 0;
1735
1736             l = strlen(ps_global->home_dir);
1737
1738             while(!new_folder && (p = last_cmpnt(folder)) != NULL){
1739                 if(savep){
1740                     *savep = saveval;
1741                     savep = NULL;
1742                 }
1743
1744                 if(folder + l == p || folder + l + 1 == p)
1745                   new_folder = p;
1746                 else{
1747                     savep = --p;
1748                     saveval = *savep;
1749                     *savep = '\0';
1750                 }
1751             }
1752
1753             if(savep)
1754               *savep = saveval;
1755
1756             if(new_folder)
1757               folder = new_folder;
1758         }
1759
1760         snprintf(buf, sizeof(buf), "        %s AddressBook%s%s in %s",
1761                 (pab->type & GLOBAL) ? "Global" : "Personal",
1762                 (pab->type & REMOTE_VIA_IMAP && *hostbuf) ? " on " : "",
1763                 (pab->type & REMOTE_VIA_IMAP && *hostbuf) ? hostbuf : "",
1764                 (folder && *folder) ? folder : "<?>");
1765         cellwidth = utf8_width(buf);
1766         if(cellwidth > screen_width)
1767           cellwidth = utf8_truncate(buf, screen_width);
1768
1769         /* add space padding */
1770         if(cellwidth < screen_width)
1771           snprintf(buf+strlen(buf), sizeof(buf)-strlen(buf), "%*.*s",
1772                    screen_width - cellwidth, screen_width - cellwidth, "");
1773
1774         buf[sizeof(buf)-1] = '\0';
1775         dl->usst = cpystr(buf);
1776         break;
1777
1778       case DlcTitleCmb:
1779         dl->type = TitleCmb;
1780         pab = &as.adrbks[new->adrbk_num];
1781         /* title for this addrbook */
1782         snprintf(buf, sizeof(buf), "%s AddressBook <%s>",
1783                     (new->adrbk_num < as.how_many_personals) ?
1784                         "Personal" :
1785                         "Global",
1786                     pab->abnick ? pab->abnick : pab->filename);
1787         cellwidth = utf8_width(buf);
1788         if(cellwidth > screen_width)
1789           cellwidth = utf8_truncate(buf, screen_width);
1790
1791         /* add space padding */
1792         if(cellwidth < screen_width)
1793           snprintf(buf+strlen(buf), sizeof(buf)-strlen(buf), "%*.*s",
1794                    screen_width - cellwidth, screen_width - cellwidth, "");
1795
1796         buf[sizeof(buf)-1] = '\0';
1797
1798         if(as.ro_warning && (pab->access == NoAccess || pab->access == ReadOnly)){
1799             char *str;
1800
1801             if(pab->access == NoAccess)
1802               str = NOACCESS;
1803             else
1804               str = READONLY;
1805
1806             need_width = utf8_width(str);
1807
1808             if(screen_width > need_width && (q = utf8_count_back_width(buf, buf+strlen(buf), need_width, &got_width)) != NULL)
1809
1810               (void) utf8_pad_to_width(q, str, sizeof(buf)-(q-buf), need_width, 0);
1811         }
1812
1813         buf[sizeof(buf)-1] = '\0';
1814         dl->usst = cpystr(buf);
1815         break;
1816
1817       case DlcDirDelim1b:
1818         dl->type = Text;
1819         utf8_snprintf(buf, sizeof(buf), "%-*.*w", screen_width, screen_width, OLDSTYLE_DIR_TITLE);
1820         dl->usst = cpystr(buf);
1821         break;
1822
1823       case DlcClickHereCmb:
1824         dl->type  = ClickHereCmb;
1825         break;
1826
1827       case DlcListClickHere:
1828         dl->type  = ListClickHere;
1829         dl->elnum = new->dlcelnum;
1830         break;
1831
1832       case DlcListEmpty:
1833         dl->type  = ListEmpty;
1834         dl->elnum = new->dlcelnum;
1835         break;
1836
1837       case DlcEmpty:
1838         dl->type = Empty;
1839         break;
1840
1841       case DlcZoomEmpty:
1842         dl->type = ZoomEmpty;
1843         break;
1844
1845       case DlcNoAbooks:
1846         dl->type = NoAbooks;
1847         break;
1848
1849       case DlcPersAdd:
1850         dl->type = AddFirstPers;
1851         break;
1852
1853       case DlcGlobAdd:
1854         dl->type = AddFirstGlob;
1855         break;
1856
1857       case DlcDirAccess:
1858         dl->type = AskServer;
1859
1860 #ifdef  ENABLE_LDAP
1861         {
1862         LDAP_SERV_S *info;
1863
1864         info = break_up_ldap_server(ps_global->VAR_LDAP_SERVERS[new->adrbk_num]);
1865         snprintf(buf2, sizeof(buf2), "    %s",
1866                 (info && info->nick && *info->nick) ? info->nick :
1867                   (info && info->serv && *info->serv) ? info->serv :
1868                     comatose(new->adrbk_num + 1));
1869         if(info)
1870           free_ldap_server_info(&info);
1871         }
1872 #else
1873         snprintf(buf2, sizeof(buf2), "    %s", comatose(new->adrbk_num + 1));
1874 #endif
1875
1876         utf8_snprintf(buf, sizeof(buf), "%-*.*w", screen_width, screen_width, buf2);
1877         dl->usst = cpystr(buf);
1878         break;
1879
1880       case DlcDirSubTitle:
1881         dl->type = Text;
1882 #ifdef  ENABLE_LDAP
1883         {
1884         LDAP_SERV_S *info;
1885
1886         info = break_up_ldap_server(ps_global->VAR_LDAP_SERVERS[new->adrbk_num]);
1887         if(info && info->port >= 0)
1888           snprintf(buf2, sizeof(buf2), "        Directory Server on %s:%d",
1889                   (info && info->serv && *info->serv) ? info->serv : "<?>",
1890                   info->port);
1891         else
1892           snprintf(buf2, sizeof(buf2), "        Directory Server on %s",
1893                   (info && info->serv && *info->serv) ? info->serv : "<?>");
1894
1895         if(info)
1896           free_ldap_server_info(&info);
1897         }
1898 #else
1899         snprintf(buf2, sizeof(buf2), "        Directory Server %s",
1900                 comatose(new->adrbk_num + 1));
1901 #endif
1902
1903         utf8_snprintf(buf, sizeof(buf), "%-*.*w", screen_width, screen_width, buf2);
1904         dl->usst = cpystr(buf);
1905         break;
1906
1907       case DlcSimple:
1908         dl->type  = Simple;
1909         dl->elnum = new->dlcelnum;
1910         break;
1911
1912       case DlcListHead:
1913         dl->type  = ListHead;
1914         dl->elnum = new->dlcelnum;
1915         break;
1916
1917       case DlcListEnt:
1918         dl->type     = ListEnt;
1919         dl->elnum    = new->dlcelnum;
1920         dl->l_offset = new->dlcoffset;
1921         break;
1922
1923       case DlcBeginning:
1924       case DlcOneBeforeBeginning:
1925       case DlcTwoBeforeBeginning:
1926         dl->type = Beginning;
1927         break;
1928
1929       case DlcEnd:
1930         dl->type = End;
1931         break;
1932
1933       default:
1934         q_status_message(SM_ORDER | SM_DING, 5, 10,
1935             _("Bug in addrbook, not supposed to happen, re-syncing..."));
1936         dprint((1, "Bug in addrbook, impossible dflt in fill_in_dl (%d)\n",
1937                 new->type));
1938         /* jump back to a safe starting point */
1939         longjmp(addrbook_changed_unexpectedly, 1);
1940         /*NOTREACHED*/
1941     }
1942 }
1943
1944
1945 /*
1946  * Returns a pointer to the member_number'th list member of the list
1947  * associated with this display line.
1948  */
1949 char *
1950 listmem(long int row)
1951 {
1952     PerAddrBook *pab;
1953     AddrScrn_Disp *dl;
1954
1955     dl = dlist(row);
1956     if(dl->type != ListEnt)
1957       return((char *)NULL);
1958
1959     pab = &as.adrbks[adrbk_num_from_lineno(row)];
1960
1961     return(listmem_from_dl(pab->address_book, dl));
1962 }
1963
1964
1965 /*
1966  * Returns a pointer to the list member
1967  * associated with this display line.
1968  */
1969 char *
1970 listmem_from_dl(AdrBk *address_book, AddrScrn_Disp *dl)
1971 {
1972     AdrBk_Entry *abe;
1973     char **p = (char **)NULL;
1974
1975     /* This shouldn't happen */
1976     if(dl->type != ListEnt)
1977       return((char *)NULL);
1978
1979     abe = adrbk_get_ae(address_book, (a_c_arg_t) dl->elnum);
1980
1981     /*
1982      * If we wanted to be more careful, We'd go through the list making sure
1983      * we don't pass the end.  We'll count on the caller being careful
1984      * instead.
1985      */
1986     if(abe && abe->tag == List){
1987         p =  abe->addr.list;
1988         p += dl->l_offset;
1989     }
1990
1991     return((p && *p) ? *p : (char *)NULL);
1992 }
1993
1994
1995 /*
1996  * How many members in list?
1997  */
1998 adrbk_cntr_t
1999 listmem_count_from_abe(AdrBk_Entry *abe)
2000 {
2001     char **p;
2002
2003     if(abe->tag != List)
2004       return 0;
2005
2006     for(p = abe->addr.list; p != NULL && *p != NULL; p++)
2007       ;/* do nothing */
2008
2009     return((adrbk_cntr_t)(p - abe->addr.list));
2010 }
2011
2012
2013 /*
2014  * Return a ptr to the row'th line of the global disp_list.
2015  * Line numbers count up but you can't count on knowing which line number
2016  * goes with the first or the last row.  That is, row 0 is not necessarily
2017  * special.  It could be before the rows that make up the display list, after
2018  * them, or anywhere in between.  You can't tell what the last row is
2019  * numbered, but a dl with type End is returned when you get past the end.
2020  * You can't tell what the number of the first row is, but if you go past
2021  * the first row a dl of type Beginning will be returned.  Row numbers can
2022  * be positive or negative.  Their values have no meaning other than how
2023  * they line up relative to other row numbers.
2024  */
2025 AddrScrn_Disp *
2026 dlist(long int row)
2027 {
2028     DL_CACHE_S *dlc = (DL_CACHE_S *)NULL;
2029
2030     dlc = get_dlc(row);
2031
2032     if(dlc){
2033         fill_in_dl_field(dlc);
2034         return(&dlc->dl);
2035     }
2036     else{
2037         q_status_message(SM_ORDER | SM_DING, 5, 10,
2038                      _("Bug in addrbook, not supposed to happen, re-syncing..."));
2039         dprint((1, "Bug in addrbook (null dlc in dlist(%ld), not supposed to happen\n", row));
2040         /* jump back to a safe starting point */
2041
2042         dprint((1, "dlist: panic: initialized %d, n_addrbk %d, cur_row %d, top_ent %ld, ro_warning %d, no_op_possbl %d\n",
2043                 as.initialized, as.n_addrbk, as.cur_row, as.top_ent, as.ro_warning, as.no_op_possbl));
2044
2045         longjmp(addrbook_changed_unexpectedly, 1);
2046         /*NOTREACHED*/
2047     }
2048 }
2049
2050
2051 /*
2052  * Returns the index of the current address book.
2053  */
2054 int
2055 adrbk_num_from_lineno(long int lineno)
2056 {
2057     DL_CACHE_S *dlc;
2058
2059     dlc = get_dlc(lineno);
2060
2061     return(dlc->adrbk_num);
2062 }