mod_query/listing.c

   1 /*
   2  * ion/mod_query/listing.c
   3  *
   4  * Copyright (c) Tuomo Valkonen 1999-2009.
   5  *
   6  * See the included file LICENSE for details.
   7  */
   8
   9 #include <string.h>
  10 #include <limits.h>
  11
  12 #include <ioncore/common.h>
  13 #include <ioncore/global.h>
  14 #include <ioncore/gr.h>
  15 #include <ioncore/strings.h>
  16 #include "listing.h"
  17
  18
  19 #define COL_SPACING 16
  20 #define CONT_INDENT "xx"
  21 #define CONT_INDENT_LEN 2
  22 #define ITEMROWS(L, R) ((L)->iteminfos==NULL ? 1 : (L)->iteminfos[R].n_parts)
  23
  24
  25 static int strings_maxw(GrBrush *brush, char **strs, int nstrs)
  26 {
  27     int maxw=0, w, i;
  28
  29     for(i=0; i<nstrs; i++){
  30         w=grbrush_get_text_width(brush, strs[i], strlen(strs[i]));
  31         if(w>maxw)
  32             maxw=w;
  33     }
  34
  35     return maxw;
  36 }
  37
  38
  39 static int getbeg(GrBrush *brush, int maxw, char *str, int l, int *wret)
  40 {
  41     int n=0, nprev=0, w;
  42     GrFontExtents fnte;
  43
  44     if(maxw<=0){
  45         *wret=0;
  46         return 0;
  47     }
  48
  49     grbrush_get_font_extents(brush, &fnte);
  50
  51     if(fnte.max_width!=0){
  52         /* Do an initial skip. */
  53         int n2=maxw/fnte.max_width;
  54
  55         n=0;
  56         while(n2>0){
  57             n+=str_nextoff(str, n);
  58             n2--;
  59         }
  60     }
  61
  62     w=grbrush_get_text_width(brush, str, n);
  63     nprev=n;
  64     *wret=w;
  65
  66     while(w<=maxw){
  67         *wret=w;
  68         nprev=n;
  69         n+=str_nextoff(str, n);
  70         if(n==nprev)
  71             break;
  72         w=grbrush_get_text_width(brush, str, n);
  73     }
  74
  75     return nprev;
  76 }
  77
  78
  79 static void reset_iteminfo(WListingItemInfo *iinf)
  80 {
  81     iinf->n_parts=1;
  82     if(iinf->part_lens!=NULL){
  83         free(iinf->part_lens);
  84         iinf->part_lens=NULL;
  85     }
  86 }
  87
  88
  89 static void string_do_calc_parts(GrBrush *brush, int maxw, char *str, int l,
  90                                  WListingItemInfo *iinf,
  91                                  int wrapw, int ciw)
  92 {
  93     int i=iinf->n_parts, l2=l, w;
  94     int rmaxw=maxw-(i==0 ? 0 : ciw);
  95
  96     iinf->n_parts++;
  97
  98     w=grbrush_get_text_width(brush, str, l);
  99
 100     if(w>rmaxw){
 101         l2=getbeg(brush, rmaxw-wrapw, str, l, &w);
 102         if(l2<=0)
 103             l2=1;
 104     }
 105
 106     if(l2<l){
 107         string_do_calc_parts(brush, maxw, str+l2, l-l2, iinf, wrapw, ciw);
 108     }else{
 109         int *p=(int*)realloc(iinf->part_lens, iinf->n_parts*sizeof(int));
 110         if(p==NULL){
 111             reset_iteminfo(iinf);
 112         }else{
 113             iinf->part_lens=p;
 114         }
 115     }
 116
 117     if(iinf->part_lens!=NULL)
 118         iinf->part_lens[i]=l2;
 119 }
 120
 121
 122 static void string_calc_parts(GrBrush *brush, int maxw, char *str,
 123                               WListingItemInfo *iinf)
 124 {
 125     int wrapw=grbrush_get_text_width(brush, "\\", 1);
 126     int ciw=grbrush_get_text_width(brush, CONT_INDENT, CONT_INDENT_LEN);
 127
 128     iinf->n_parts=0;
 129     iinf->len=strlen(str);
 130
 131     if(maxw<=0)
 132         reset_iteminfo(iinf);
 133     else
 134         string_do_calc_parts(brush, maxw, str, iinf->len, iinf, wrapw, ciw);
 135 }
 136
 137
 138 static void draw_multirow(GrBrush *brush, int x, int y, int h,
 139                           char *str, WListingItemInfo *iinf,
 140                           int maxw, int ciw, int wrapw)
 141 {
 142     int i, l;
 143
 144     if(iinf==NULL){
 145         grbrush_draw_string(brush, x, y, str, strlen(str), TRUE);
 146         return;
 147     }
 148
 149     assert(iinf->n_parts>=1);
 150     if(iinf->part_lens==NULL){
 151         assert(iinf->n_parts==1);
 152         l=iinf->len;
 153     }else{
 154         l=iinf->part_lens[0];
 155     }
 156
 157     grbrush_draw_string(brush, x, y, str, l, TRUE);
 158
 159     for(i=1; i<iinf->n_parts; i++){
 160         grbrush_draw_string(brush, x+maxw-wrapw, y, "\\", 1, TRUE);
 161
 162         y+=h;
 163         str+=l;
 164         if(i==1){
 165             x+=ciw;
 166             maxw-=ciw;
 167         }
 168         l=iinf->part_lens[i];
 169
 170         grbrush_draw_string(brush, x, y, str, l, TRUE);
 171     }
 172 }
 173
 174
 175 static int col_fit(int w, int itemw, int spacing)
 176 {
 177     int ncol=1;
 178     int tmp=w-itemw;
 179     itemw+=spacing;
 180
 181     if(tmp>0)
 182         ncol+=tmp/itemw;
 183
 184     return ncol;
 185 }
 186
 187 static bool one_row_up(WListing *l, int *ip, int *rp)
 188 {
 189     int i=*ip, r=*rp;
 190
 191     if(r>0){
 192         (*rp)--;
 193         return TRUE;
 194     }
 195
 196     if(i==0)
 197         return FALSE;
 198
 199     (*ip)--;
 200     *rp=ITEMROWS(l, i-1)-1;
 201     return TRUE;
 202 }
 203
 204
 205 static bool one_row_down(WListing *l, int *ip, int *rp)
 206 {
 207     int i=*ip, r=*rp;
 208     int ir=ITEMROWS(l, i);
 209
 210     if(r<ir-1){
 211         (*rp)++;
 212         return TRUE;
 213     }
 214
 215     if(i==l->nitemcol-1)
 216         return FALSE;
 217
 218     (*ip)++;
 219     *rp=0;
 220     return TRUE;
 221 }
 222
 223
 224 void setup_listing(WListing *l, char **strs, int nstrs, bool onecol)
 225 {
 226     if(l->strs!=NULL)
 227         deinit_listing(l);
 228
 229     l->iteminfos=ALLOC_N(WListingItemInfo, nstrs);
 230     l->strs=strs;
 231     l->nstrs=nstrs;
 232     l->onecol=onecol;
 233     l->selected_str=-1;
 234 }
 235
 236
 237 void fit_listing(GrBrush *brush, const WRectangle *geom, WListing *l)
 238 {
 239     int ncol, nrow=0, visrow=INT_MAX;
 240     int i, maxw, w, h;
 241     GrFontExtents fnte;
 242     GrBorderWidths bdw;
 243
 244     grbrush_get_font_extents(brush, &fnte);
 245     grbrush_get_border_widths(brush, &bdw);
 246
 247     w=geom->w-bdw.left-bdw.right;
 248     h=geom->h-bdw.top-bdw.bottom;
 249
 250     maxw=strings_maxw(brush, l->strs, l->nstrs);
 251     l->itemw=maxw+COL_SPACING;
 252     l->itemh=fnte.max_height;
 253
 254     if(l->onecol)
 255         ncol=1;
 256     else
 257         ncol=col_fit(w, l->itemw-COL_SPACING, COL_SPACING);
 258
 259     if(l->iteminfos!=NULL){
 260         for(i=0; i<l->nstrs; i++){
 261             if(ncol!=1){
 262                 reset_iteminfo(&(l->iteminfos[i]));
 263                 l->iteminfos[i].len=strlen(l->strs[i]);
 264             }else{
 265                 string_calc_parts(brush, w, l->strs[i], &(l->iteminfos[i]));
 266             }
 267             nrow+=l->iteminfos[i].n_parts;
 268         }
 269     }else{
 270         nrow=l->nstrs;
 271     }
 272
 273     if(ncol>1){
 274         nrow=l->nstrs/ncol+(l->nstrs%ncol ? 1 : 0);
 275         l->nitemcol=nrow;
 276     }else{
 277         l->nitemcol=l->nstrs;
 278     }
 279
 280     if(l->itemh>0)
 281         visrow=h/l->itemh;
 282
 283     if(visrow>nrow)
 284         visrow=nrow;
 285
 286     l->ncol=ncol;
 287     l->nrow=nrow;
 288     l->visrow=visrow;
 289     l->toth=visrow*l->itemh;
 290
 291 #if 0
 292     l->firstitem=l->nitemcol-1;
 293     l->firstoff=ITEMROWS(l, l->nitemcol-1)-1;
 294     for(i=1; i<visrow; i++)
 295         one_row_up(l, &(l->firstitem), &(l->firstoff));
 296 #else
 297     l->firstitem=0;
 298     l->firstoff=0;
 299 #endif
 300
 301 }
 302
 303
 304 void deinit_listing(WListing *l)
 305 {
 306     if(l->strs==NULL)
 307         return;
 308
 309     while(l->nstrs--){
 310         free(l->strs[l->nstrs]);
 311         if(l->iteminfos!=NULL)
 312             reset_iteminfo(&(l->iteminfos[l->nstrs]));
 313     }
 314
 315     free(l->strs);
 316     l->strs=NULL;
 317
 318     if(l->iteminfos!=NULL){
 319         free(l->iteminfos);
 320         l->iteminfos=NULL;
 321     }
 322 }
 323
 324
 325 void init_listing(WListing *l)
 326 {
 327     l->nstrs=0;
 328     l->strs=NULL;
 329     l->iteminfos=NULL;
 330     l->nstrs=0;
 331     l->selected_str=-1;
 332     l->onecol=TRUE;
 333     l->itemw=0;
 334     l->itemh=0;
 335     l->ncol=0;
 336     l->nrow=0;
 337     l->nitemcol=0;
 338     l->visrow=0;
 339     l->toth=0;
 340 }
 341
 342
 343 static void do_draw_listing(GrBrush *brush, const WRectangle *geom,
 344                             WListing *l, GrAttr selattr, int mode)
 345 {
 346     int wrapw=grbrush_get_text_width(brush, "\\", 1);
 347     int ciw=grbrush_get_text_width(brush, CONT_INDENT, CONT_INDENT_LEN);
 348     int r, c, i, x, y;
 349     GrFontExtents fnte;
 350
 351     if(l->nitemcol==0 || l->visrow==0)
 352         return;
 353
 354     grbrush_get_font_extents(brush, &fnte);
 355
 356     x=0;
 357     c=0;
 358     while(1){
 359         y=geom->y+fnte.baseline;
 360         i=l->firstitem+c*l->nitemcol;
 361         r=-l->firstoff;
 362         y+=r*l->itemh;
 363         while(r<l->visrow){
 364             if(i>=l->nstrs)
 365                 return;
 366
 367             if(mode>=0 ||
 368                l->selected_str==i ||
 369                LISTING_DRAW_GET_SELECTED(mode)==i){
 370
 371                 if(i==l->selected_str)
 372                     grbrush_set_attr(brush, selattr);
 373
 374                 draw_multirow(brush, geom->x+x, y, l->itemh, l->strs[i],
 375                               (l->iteminfos!=NULL ? &(l->iteminfos[i]) : NULL),
 376                               geom->w-x, ciw, wrapw);
 377
 378                 if(i==l->selected_str)
 379                     grbrush_unset_attr(brush, selattr);
 380             }
 381
 382             y+=l->itemh*ITEMROWS(l, i);
 383             r+=ITEMROWS(l, i);
 384             i++;
 385         }
 386         x+=l->itemw;
 387         c++;
 388     }
 389 }
 390
 391
 392 static int prevsel=-1;
 393
 394 static bool filteridx_sel(WListing *l, int i)
 395 {
 396     return (i==prevsel || i==l->selected_str);
 397 }
 398
 399
 400 void draw_listing(GrBrush *brush, const WRectangle *geom,
 401                   WListing *l, int mode, GrAttr selattr)
 402 {
 403     WRectangle geom2;
 404     GrBorderWidths bdw;
 405
 406     grbrush_begin(brush, geom, GRBRUSH_AMEND|GRBRUSH_KEEP_ATTR
 407                                |GRBRUSH_NEED_CLIP);
 408
 409     if(mode==LISTING_DRAW_COMPLETE)
 410         grbrush_clear_area(brush, geom);
 411
 412     grbrush_draw_border(brush, geom);
 413
 414     grbrush_get_border_widths(brush, &bdw);
 415
 416     geom2.x=geom->x+bdw.left;
 417     geom2.y=geom->y+bdw.top;
 418     geom2.w=geom->w-bdw.left-bdw.right;
 419     geom2.h=geom->h-bdw.top-bdw.bottom;
 420
 421     do_draw_listing(brush, &geom2, l, selattr, mode);
 422
 423     grbrush_end(brush);
 424 }
 425
 426
 427 static bool do_scrollup_listing(WListing *l, int n)
 428 {
 429     int i=l->firstitem;
 430     int r=l->firstoff;
 431     bool ret=FALSE;
 432
 433     while(n>0){
 434         if(!one_row_up(l, &i, &r))
 435             break;
 436         ret=TRUE;
 437         n--;
 438     }
 439
 440     l->firstitem=i;
 441     l->firstoff=r;
 442
 443     return ret;
 444 }
 445
 446
 447 static bool do_scrolldown_listing(WListing *l, int n)
 448 {
 449     int i=l->firstitem;
 450     int r=l->firstoff;
 451     int br=r, bi=i;
 452     int bc=l->visrow;
 453     bool ret=FALSE;
 454
 455     while(--bc>0)
 456         one_row_down(l, &bi, &br);
 457
 458     while(n>0){
 459         if(!one_row_down(l, &bi, &br))
 460             break;
 461         one_row_down(l, &i, &r);
 462         ret=TRUE;
 463         n--;
 464     }
 465
 466     l->firstitem=i;
 467     l->firstoff=r;
 468
 469     return ret;
 470 }
 471
 472
 473 bool scrollup_listing(WListing *l)
 474 {
 475     return do_scrollup_listing(l, l->visrow);
 476 }
 477
 478
 479 bool scrolldown_listing(WListing *l)
 480 {
 481     return do_scrolldown_listing(l, l->visrow);
 482 }
 483
 484
 485 static int listing_first_row_of_item(WListing *l, int i)
 486 {
 487     int fci=i%l->nitemcol, j;
 488     int r=0;
 489
 490     for(j=0; j<fci; j++)
 491         r+=ITEMROWS(l, j);
 492
 493     return r;
 494 }
 495
 496
 497 static int listing_first_visible_row(WListing *l)
 498 {
 499     return listing_first_row_of_item(l, l->firstitem)+l->firstoff;
 500 }
 501
 502
 503 int listing_select(WListing *l, int i)
 504 {
 505     int irow, frow, lrow;
 506     int redraw;
 507
 508     redraw=LISTING_DRAW_SELECTED(l->selected_str);
 509
 510     if(i<0){
 511         l->selected_str=-1;
 512         return redraw;
 513     }
 514
 515     assert(i<l->nstrs);
 516
 517     l->selected_str=i;
 518
 519     /* Adjust visible area */
 520
 521     irow=listing_first_row_of_item(l, i);
 522     frow=listing_first_visible_row(l);
 523
 524     while(irow<frow){
 525         one_row_up(l, &(l->firstitem), &(l->firstoff));
 526         frow--;
 527         redraw=LISTING_DRAW_COMPLETE;
 528     }
 529
 530     irow+=ITEMROWS(l, i)-1;
 531     lrow=frow+l->visrow-1;
 532
 533     while(irow>lrow){
 534         one_row_down(l, &(l->firstitem), &(l->firstoff));
 535         lrow++;
 536         redraw=LISTING_DRAW_COMPLETE;
 537     }
 538
 539     return redraw;
 540 }
 541