src/list_generic.c

   1 /* Copyright (c) 2010
   2  *      Juergen Weigert (jnweiger@immd4.informatik.uni-erlangen.de)
   3  *      Sadrul Habib Chowdhury (sadrul@users.sourceforge.net)
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 3, or (at your option)
   8  * any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program (see the file COPYING); if not, see
  17  * http://www.gnu.org/licenses/, or contact Free Software Foundation, Inc.,
  18  * 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  19  *
  20  ****************************************************************
  21  */
  22
  23 #include "config.h"
  24 #include "screen.h"
  25 #include "list_generic.h"
  26 #include "layer.h"
  27 #include "extern.h"
  28
  29 /* Deals with a generic list display */
  30
  31 extern struct layer *flayer;
  32
  33 static void ListProcess __P((char **, int *));
  34 static void ListAbort __P((void));
  35 static void ListRedisplayLine __P((int, int, int, int));
  36 static void ListClearLine __P((int, int, int, int));
  37 static int  ListRewrite __P((int, int, int, struct mchar *, int));
  38 static int  ListResize __P((int, int));
  39 static void ListRestore __P((void));
  40 static void ListFree __P((void *));
  41
  42 struct LayFuncs ListLf =
  43 {
  44   ListProcess,
  45   ListAbort,
  46   ListRedisplayLine,
  47   ListClearLine,
  48   ListRewrite,
  49   ListResize,
  50   ListRestore,
  51   ListFree
  52 };
  53
  54 /** Returns non-zero on success. */
  55 struct ListData *
  56 glist_display(struct GenericList *list, const char *name)
  57 {
  58   struct ListData *ldata;
  59
  60   if (InitOverlayPage(sizeof(struct ListData), &ListLf, 0))
  61     return NULL;
  62   ldata = flayer->l_data;
  63
  64   ldata->name = name;   /* We do not SaveStr, since the strings should be all static literals */
  65   ldata->list_fn = list;
  66
  67   flayer->l_mode = 1;
  68   flayer->l_x = 0;
  69   flayer->l_y = flayer->l_height - 1;
  70
  71   return ldata;
  72 }
  73
  74 static void
  75 glist_decide_top(struct ListData *ldata)
  76 {
  77   int count = flayer->l_height - 5;     /* 2 for header, 1 for footer */
  78   struct ListRow *top = ldata->selected;
  79   for (; count && top != ldata->root; top = top->prev, count--)
  80     ;
  81   ldata->top = top;
  82 }
  83
  84 static struct ListRow *
  85 glist_search_dir(struct ListData *ldata, struct ListRow *start, int dir)
  86 {
  87   struct ListRow *row = (dir == 1) ? start->next : start->prev;
  88   for (; row; row = (dir == 1) ? row->next : row->prev)
  89     if (ldata->list_fn->gl_matchrow(ldata, row, ldata->search))
  90       return row;
  91
  92   if (dir == 1)
  93     row = ldata->root;
  94   else
  95     {
  96       /* First, go to the end */
  97       if (!start->next)
  98         row = start;
  99       else
 100         for (row = start->next; row->next; row = row->next)
 101           ;
 102     }
 103
 104   for (; row != start; row = (dir == 1) ? row->next : row->prev)
 105     if (ldata->list_fn->gl_matchrow(ldata, row, ldata->search))
 106       break;
 107
 108   return row;
 109 }
 110
 111 static void
 112 glist_search(char *buf, int len, char *data)
 113 {
 114   struct ListData *ldata = (struct ListData *)data;
 115   struct ListRow *row;
 116
 117   if (ldata->search)
 118     Free(ldata->search);
 119   if (len > 0)
 120     ldata->search = SaveStr(buf);
 121   else
 122     return;
 123
 124   for (row = ldata->selected; row; row = row->next)
 125     if (ldata->list_fn->gl_matchrow(ldata, row, ldata->search))
 126       break;
 127
 128   if (!row)
 129     for (row = ldata->root; row != ldata->selected; row = row->next)
 130       if (ldata->list_fn->gl_matchrow(ldata, row, ldata->search))
 131         break;
 132
 133   if (row == ldata->selected)
 134     return;
 135
 136   ldata->selected = row;
 137   if (ldata->selected->y == -1)
 138     glist_decide_top(ldata);
 139   glist_display_all(ldata);
 140 }
 141
 142 static void ListProcess(char **ppbuf, int *plen)
 143 {
 144   struct ListData *ldata = flayer->l_data;
 145   int count = 0;
 146
 147   while (*plen > 0)
 148     {
 149       struct ListRow *old;
 150       unsigned char ch;
 151
 152       if (!flayer->l_mouseevent.start && ldata->list_fn->gl_pinput &&
 153           ldata->list_fn->gl_pinput(ldata, ppbuf, plen))
 154         continue;
 155
 156       ch = **ppbuf;
 157       ++*ppbuf;
 158       --*plen;
 159
 160       if (flayer->l_mouseevent.start)
 161         {
 162           int r = LayProcessMouse(flayer, ch);
 163           if (r == -1)
 164             {
 165               LayProcessMouseSwitch(flayer, 0);
 166               continue;
 167             }
 168           else
 169             {
 170               if (r)
 171                 ch = 0222;
 172               else
 173                 continue;
 174             }
 175         }
 176
 177       if (!ldata->selected)
 178         {
 179           *plen = 0;
 180           break;
 181         }
 182
 183       old = ldata->selected;
 184
 185 processchar:
 186       switch (ch)
 187         {
 188         case ' ':
 189           break;
 190
 191         case '\r':
 192         case '\n':
 193           break;
 194
 195         case 0220:      /* up */
 196         case 16:        /* ^P */
 197         case 'k':
 198           if (!ldata->selected->prev)   /* There's no where to go */
 199             break;
 200           ldata->selected = old->prev;
 201           break;
 202
 203         case 0216:      /* down */
 204         case 14:        /* ^N like emacs */
 205         case 'j':
 206           if (!ldata->selected->next)   /* Nothing to do */
 207             break;
 208           ldata->selected = old->next;
 209           break;
 210
 211         case 033:       /* escape */
 212         case 007:       /* ^G */
 213           ListAbort();
 214           *plen = 0;
 215           return;
 216
 217         case 0201:      /* home */
 218         case 0001:      /* ^A */
 219           ldata->selected = ldata->root;
 220           break;
 221
 222         case 0205:      /* end */
 223         case 0005:      /* ^E */
 224           while (ldata->selected->next)
 225             ldata->selected = ldata->selected->next;
 226           if (ldata->selected->y != -1)
 227             {
 228               /* Both old and current selections are on the screen. So we can just
 229                * redraw these two affected rows. */
 230             }
 231           break;
 232
 233         case 0004:      /* ^D (half-page down) */
 234         case 0006:      /* page-down, ^F */
 235           count = (flayer->l_height - 4) >> (ch == 0004);
 236           for (; ldata->selected->next && --count;
 237               ldata->selected = ldata->selected->next)
 238             ;
 239           break;
 240
 241         case 0025:      /* ^U (half-page up) */
 242         case 0002:      /* page-up, ^B */
 243           count = (flayer->l_height - 4) >> (ch == 0025);
 244           for (; ldata->selected->prev && --count;
 245               ldata->selected = ldata->selected->prev)
 246             ;
 247           break;
 248
 249         case '/':       /* start searching */
 250           if (ldata->list_fn->gl_matchrow)
 251             {
 252               char *s;
 253               Input("Search: ", 80, INP_COOKED, glist_search, (char *)ldata, 0);
 254               if ((s = ldata->search))
 255                 {
 256                   for (; *s; s++)
 257                     {
 258                       char *ss = s;
 259                       int n = 1;
 260                       LayProcess(&ss, &n);
 261                     }
 262                 }
 263             }
 264           break;
 265
 266         /* The following deal with searching. */
 267
 268         case 'n':       /* search next */
 269           if (ldata->list_fn->gl_matchrow && ldata->search)
 270             ldata->selected = glist_search_dir(ldata, ldata->selected, 1);
 271           break;
 272
 273         case 'N':       /* search prev */
 274           if (ldata->list_fn->gl_matchrow && ldata->search)
 275             ldata->selected = glist_search_dir(ldata, ldata->selected, -1);
 276           break;
 277
 278         /* Now, mouse events. */
 279         case 0222:
 280           if (flayer->l_mouseevent.start)
 281             {
 282               int button = flayer->l_mouseevent.buffer[0];
 283               if (button == 'a') /* Scroll down */
 284                 ch = 'j';
 285               else if (button == '`') /* Scroll up */
 286                 ch = 'k';
 287               else if (button == ' ') /* Left click */
 288                 {
 289                   int y = flayer->l_mouseevent.buffer[2];
 290                   struct ListRow *r = ldata->top;
 291                   for (r = ldata->top; r && r->y != -1 && r->y != y; r = r->next)
 292                     ;
 293                   if (r && r->y == y)
 294                     ldata->selected = r;
 295                   ch = 0;
 296                 }
 297               else
 298                 ch = 0;
 299               LayProcessMouseSwitch(flayer, 0);
 300               if (ch)
 301                 goto processchar;
 302             }
 303           else
 304             LayProcessMouseSwitch(flayer, 1);
 305           break;
 306         }
 307
 308       if (old == ldata->selected)       /* The selection didn't change */
 309         continue;
 310
 311       if (ldata->selected->y == -1)
 312         {
 313           /* We need to list all the rows, since we are scrolling down. But first,
 314            * find the top of the visible list. */
 315           glist_decide_top(ldata);
 316           glist_display_all(ldata);
 317         }
 318       else
 319         {
 320           /* just redisplay the two lines. */
 321           ldata->list_fn->gl_printrow(ldata, old);
 322           ldata->list_fn->gl_printrow(ldata, ldata->selected);
 323           flayer->l_y = ldata->selected->y;
 324           LaySetCursor();
 325         }
 326     }
 327 }
 328
 329 static void ListAbort(void)
 330 {
 331   LAY_CALL_UP(LRefreshAll(flayer, 0));
 332   ExitOverlayPage();
 333 }
 334
 335 static void ListFree(void *d)
 336 {
 337   struct ListData *ldata = d;
 338   glist_remove_rows(ldata);
 339   if (ldata->list_fn->gl_free)
 340     ldata->list_fn->gl_free(ldata);
 341   if (ldata->search)
 342     Free(ldata->search);
 343 }
 344
 345 static void ListRedisplayLine(int y, int xs, int xe, int isblank)
 346 {
 347   struct ListData *ldata;
 348   ASSERT(flayer);
 349
 350   ldata = flayer->l_data;
 351   if (y < 0)
 352     {
 353       glist_display_all(ldata);
 354       return;
 355     }
 356
 357   if (!isblank)
 358     LClearArea(flayer, xs, y, xe, y, 0, 0);
 359
 360   if (ldata->top && y < ldata->top->y)
 361     ldata->list_fn->gl_printheader(ldata);
 362   else if (y + 1 == flayer->l_height)
 363     ldata->list_fn->gl_printfooter(ldata);
 364   else
 365     {
 366       struct ListRow *row;
 367       for (row = ldata->top; row && row->y != -1; row = row->next)
 368         if (row->y == y)
 369           {
 370             ldata->list_fn->gl_printrow(ldata, row);
 371             break;
 372           }
 373     }
 374 }
 375
 376 static void ListClearLine(int y, int xs, int xe, int bce)
 377 {
 378   DefClearLine(y, xs, xe, bce);
 379 }
 380
 381 static int  ListRewrite(int y, int xs, int xe, struct mchar *rend, int doit)
 382 {
 383   return EXPENSIVE;
 384 }
 385
 386 static int ListResize (int wi, int he)
 387 {
 388   if (wi < 10 || he < 5)
 389     return -1;
 390
 391   flayer->l_width = wi;
 392   flayer->l_height = he;
 393   flayer->l_y = he - 1;
 394
 395   return 0;
 396 }
 397
 398 static void ListRestore (void)
 399 {
 400   DefRestore();
 401 }
 402
 403 struct ListRow *
 404 glist_add_row(struct ListData *ldata, void *data, struct ListRow *after)
 405 {
 406   struct ListRow *r = calloc(1, sizeof(struct ListRow));
 407   r->data = data;
 408
 409   if (after)
 410     {
 411       r->next = after->next;
 412       r->prev = after;
 413       after->next = r;
 414       if (r->next)
 415         r->next->prev = r;
 416     }
 417   else
 418     {
 419       r->next = ldata->root;
 420       if (ldata->root)
 421         ldata->root->prev = r;
 422       ldata->root = r;
 423     }
 424
 425   return r;
 426 }
 427
 428 void
 429 glist_remove_rows(struct ListData *ldata)
 430 {
 431   struct ListRow *row;
 432   for (row = ldata->root; row; )
 433     {
 434       struct ListRow *r = row;
 435       row = row->next;
 436       ldata->list_fn->gl_freerow(ldata, r);
 437       free(r);
 438     }
 439   ldata->root = ldata->selected = ldata->top = NULL;
 440 }
 441
 442 void
 443 glist_display_all(struct ListData *list)
 444 {
 445   int y;
 446   struct ListRow *row;
 447
 448   LClearAll(flayer, 0);
 449
 450   y = list->list_fn->gl_printheader(list);
 451
 452   if (!list->top)
 453     list->top = list->root;
 454   if (!list->selected)
 455     list->selected = list->root;
 456
 457   for (row = list->root; row != list->top; row = row->next)
 458     row->y = -1;
 459
 460   for (row = list->top; row; row = row->next)
 461     {
 462       row->y = y++;
 463       if (!list->list_fn->gl_printrow(list, row))
 464         {
 465           row->y = -1;
 466           y--;
 467         }
 468       if (y + 1 == flayer->l_height)
 469         break;
 470     }
 471   for (; row; row = row->next)
 472     row->y = -1;
 473
 474   list->list_fn->gl_printfooter(list);
 475   if (list->selected && list->selected->y != -1)
 476     flayer->l_y = list->selected->y;
 477   else
 478     flayer->l_y = flayer->l_height - 1;
 479   LaySetCursor();
 480 }
 481
 482 void glist_abort(void)
 483 {
 484   ListAbort();
 485 }
 486