mdw@git.distorted.org.uk Git - dvdrip/blob - multiprogress.c

   1 #define _XOPEN_SOURCE
   2
   3 #include <limits.h>
   4 #include <stdarg.h>
   5 #include <stdlib.h>
   6 #include <string.h>
   7 #include <wchar.h>
   8
   9 #include <unistd.h>
  10 #include <termios.h>
  11 #include <sys/ioctl.h>
  12
  13 #if defined(USE_TERMINFO)
  14 #  include <curses.h>
  15 #  include <term.h>
  16 #elif defined(USE_TERMCAP)
  17 #  include <termcap.h>
  18 #endif
  19
  20 #include "multiprogress.h"
  21
  22 static FILE *dup_stream(int fd)
  23 {
  24   FILE *fp;
  25   int newfd;
  26
  27   newfd = dup(fd); if (newfd < 0) return (0);
  28   fp = fdopen(newfd, "r+"); if (!fp) return (0);
  29   return (fp);
  30 }
  31
  32 int progress_init(struct progress_state *progress)
  33 {
  34 #ifdef USE_TERMCAP
  35   char *term, *capcur;
  36 #endif
  37 #ifdef USE_TERMINFO
  38   int err;
  39 #endif
  40   struct progress_ttyinfo *tty;
  41   const char *t;
  42   int n;
  43
  44   tty = &progress->tty;
  45   tty->fp = 0;
  46   tty->termbuf = tty->capbuf = 0;
  47   tty->cap.f = 0;
  48   tty->cap.cr = tty->cap.up = tty->cap.ce = tty->cap.cd =
  49     tty->cap.mr = tty->cap.md = tty->cap.me =
  50     tty->cap.af = tty->cap.ab = tty->cap.op = 0;
  51
  52   progress->items = progress->end_item = 0;
  53   progress->nitems = 0; progress->last_lines = 0;
  54   progress->tv_update.tv_sec = 0; progress->tv_update.tv_usec = 0;
  55
  56   if (isatty(1)) tty->fp = dup_stream(1);
  57   else if (isatty(2)) tty->fp = dup_stream(2);
  58   else tty->fp = fopen("/dev/tty", "r+");
  59   if (!tty->fp) return (-1);
  60
  61 #define SETDIM(dim, var, getcap, dflt) do {                             \
  62   t = getenv(var); if (t) { n = atoi(t); if (n) { tty->dim = n; break; } } \
  63   n = getcap; if (n > 0) { tty->dim = n; break; }                       \
  64   tty->dim = dflt;                                                      \
  65 } while (0)
  66
  67 #if defined(USE_TERMINFO)
  68
  69   if (setupterm(0, fileno(tty->fp), &err) != OK || err < 1) return (-1);
  70
  71   tty->cap.cr = tigetstr("cr");
  72   tty->cap.nw = tigetstr("nel");
  73   tty->cap.up = tigetstr("cuu1");
  74   tty->cap.ce = tigetstr("el");
  75   tty->cap.cd = tigetstr("ed");
  76
  77   if (tigetnum("xmc") < 1) {
  78     tty->cap.mr = tigetstr("rev");
  79     tty->cap.md = tigetstr("bold");
  80     tty->cap.me = tigetstr("sgr0");
  81
  82     tty->cap.af = tigetstr("setaf");
  83     tty->cap.ab = tigetstr("setab");
  84     tty->cap.op = tigetstr("op");
  85   }
  86
  87   if (tigetflag("bce") > 0) tty->cap.f |= TCF_BCE;
  88
  89   SETDIM(defwd, "COLUMNS", tigetnum("co"), 80);
  90   SETDIM(defht, "LINES", tigetnum("li"), 25);
  91
  92 #elif defined(USE_TERMCAP)
  93
  94   tty->termbuf = malloc(4096); if (!tty->termbuf) return (-1);
  95   tty->capbuf = malloc(4096); if (!tty->capbuf) return (-1);
  96
  97   term = getenv("TERM"); if (!term) return (-1);
  98   if (tgetent(tty->termbuf, term) < 1) return (-1);
  99
 100   capcur = tty->capbuf;
 101   tty->cap.cr = tgetstr("cr", &capcur);
 102   tty->cap.nw = tgetstr("nw", &capcur);
 103   tty->cap.up = tgetstr("up", &capcur);
 104   tty->cap.ce = tgetstr("ce", &capcur);
 105   tty->cap.cd = tgetstr("cd", &capcur);
 106
 107   if (tgetnum("sg") < 1) {
 108     tty->cap.mr = tgetstr("mr", &capcur);
 109     tty->cap.md = tgetstr("md", &capcur);
 110     tty->cap.me = tgetstr("me", &capcur);
 111
 112     tty->cap.af = tgetstr("AF", &capcur);
 113     tty->cap.ab = tgetstr("AB", &capcur);
 114     tty->cap.op = tgetstr("op", &capcur);
 115   }
 116
 117   if (tgetflag("ut") > 0) tty->cap.f |= TCF_BCE;
 118
 119   t = tgetstr("pc", &capcur); tty->cap.pc = t ? *t : 0;
 120
 121   SETDIM(defwd, "COLUMNS", tgetnum("co"), 80);
 122   SETDIM(defht, "LINES", tgetnum("li"), 25);
 123
 124 #else
 125
 126   SETDIM(defwd, "COLUMNS", -1, 80);
 127   SETDIM(defht, "LINES", -1, 25);
 128
 129 #endif
 130
 131 #undef SETDIM
 132
 133   if (!tty->cap.cr) tty->cap.cr = "\r";
 134   if (!tty->cap.nw) tty->cap.nw = "\r\n";
 135   if (!tty->cap.up || !tty->cap.ce || !tty->cap.cd)
 136     { fclose(tty->fp); tty->fp = 0; return (-1); }
 137   if (!tty->cap.af || !tty->cap.ab || !tty->cap.op) tty->cap.op = 0;
 138   if (!tty->cap.me) tty->cap.mr = tty->cap.md = 0;
 139   return (0);
 140 }
 141
 142 void progress_free(struct progress_state *progress)
 143 {
 144   struct progress_ttyinfo *tty = &progress->tty;
 145
 146   if (tty->fp) { fclose(tty->fp); tty->fp = 0; }
 147   free(tty->termbuf); tty->termbuf = 0;
 148   free(tty->capbuf); tty->capbuf = 0;
 149 }
 150
 151 int progress_additem(struct progress_state *progress,
 152                      struct progress_item *item)
 153 {
 154   if (item->parent) return (-1);
 155   item->prev = progress->end_item; item->next = 0;
 156   if (progress->end_item) progress->end_item->next = item;
 157   else progress->items = item;
 158   progress->end_item = item; item->parent = progress;
 159   progress->nitems++;
 160
 161   return (0);
 162 }
 163
 164 int progress_removeitem(struct progress_state *progress,
 165                         struct progress_item *item)
 166 {
 167   if (!item->parent) return (-1);
 168   if (item->next) item->next->prev = item->prev;
 169   else (progress->end_item) = item->prev;
 170   if (item->prev) item->prev->next = item->next;
 171   else (progress->items) = item->next;
 172   progress->nitems--; item->parent = 0;
 173
 174   return (0);
 175 }
 176
 177 static void setup_render_state(struct progress_state *progress,
 178                                struct progress_render_state *render)
 179 {
 180   const struct progress_ttyinfo *tty = &progress->tty;
 181   struct winsize wsz;
 182
 183   render->tty = tty;
 184   render->linebuf = 0; render->linesz = 0;
 185   render->tempbuf = 0; render->tempsz = 0;
 186
 187 #ifdef USE_TERMCAP
 188   render->old_bc = BC; BC = 0;
 189   render->old_up = UP; UP = 0;
 190   render->old_pc = PC; PC = tty->cap.pc;
 191 #endif
 192
 193   if (!ioctl(fileno(tty->fp), TIOCGWINSZ, &wsz))
 194     { render->width = wsz.ws_col; render->height = wsz.ws_row; }
 195   else
 196     { render->width = tty->defwd; render->height = tty->defht; }
 197
 198   if (render->width && !tty->cap.op && !tty->cap.mr) render->width--;
 199 }
 200
 201 static void free_render_state(struct progress_render_state *render)
 202 {
 203   fflush(render->tty->fp);
 204   free(render->linebuf); render->linebuf = 0; render->linesz = 0;
 205   free(render->tempbuf); render->tempbuf = 0; render->tempsz = 0;
 206 #ifdef USE_TERMCAP
 207   UP = render->old_up;
 208   BC = render->old_bc;
 209   PC = render->old_pc;
 210 #endif
 211 }
 212
 213 #define CONV_MORE ((size_t)-2)
 214 #define CONV_BAD ((size_t)-1)
 215
 216 struct measure {
 217   mbstate_t ps;
 218   const char *p; size_t i, sz;
 219   unsigned wd;
 220 };
 221
 222 static void init_measure(struct measure *m, const char *p, size_t sz)
 223 {
 224   m->p = p; m->sz = sz; m->i = 0; m->wd = 0;
 225   memset(&m->ps, 0, sizeof(m->ps));
 226 }
 227
 228 static int advance_measure(struct measure *m)
 229 {
 230   wchar_t wch;
 231   unsigned chwd;
 232   size_t n;
 233
 234   n = mbrtowc(&wch, m->p + m->i, m->sz - m->i, &m->ps);
 235   if (!n) { chwd = 0; n = m->sz - m->i; }
 236   else if (n == CONV_MORE) { chwd = 2; n = m->sz - m->i; }
 237   else if (n == CONV_BAD) { chwd = 2; n = 1; }
 238   else chwd = wcwidth(wch);
 239
 240   m->i += n; m->wd += chwd;
 241   return (m->i < m->sz);
 242 }
 243
 244 static unsigned string_width(const char *p, size_t sz)
 245 {
 246   struct measure m;
 247
 248   init_measure(&m, p, sz);
 249   while (advance_measure(&m));
 250   return (m.wd);
 251 }
 252
 253 static size_t split_string(const char *p, size_t sz,
 254                            unsigned *wd_out, unsigned maxwd)
 255 {
 256   struct measure m;
 257   size_t i; unsigned wd;
 258   int more;
 259
 260   init_measure(&m, p, sz);
 261   for (;;) {
 262     if (!advance_measure(&m)) { *wd_out = m.wd; return (sz); }
 263     if (m.wd >= maxwd) break;
 264   }
 265   wd = m.wd; i = m.i;
 266   for (;;) {
 267     more = advance_measure(&m);
 268     if (m.wd > wd) break;
 269     i = m.i;
 270     if (!more) break;
 271   }
 272   *wd_out = wd; return (i);
 273 }
 274
 275 static int grow_linebuf(struct progress_render_state *render, size_t want)
 276 {
 277   char *newbuf; size_t newsz;
 278
 279   if (want <= render->linesz) return (0);
 280   if (!render->linesz) newsz = 4*render->width + 1;
 281   else newsz = render->linesz;
 282   while (newsz < want) newsz *= 2;
 283   newbuf = malloc(newsz + 1); if (!newbuf) return (-1);
 284   newbuf[newsz] = 0;
 285   if (render->leftsz)
 286     memcpy(newbuf, render->linebuf, render->leftsz);
 287   if (render->rightsz)
 288     memcpy(newbuf + newsz - render->rightsz,
 289            render->linebuf + render->linesz - render->rightsz,
 290            render->rightsz);
 291   free(render->linebuf); render->linebuf = newbuf; render->linesz = newsz;
 292   return (0);
 293 }
 294
 295 static int grow_tempbuf(struct progress_render_state *render, size_t want)
 296 {
 297   char *newbuf; size_t newsz;
 298
 299   if (want <= render->tempsz) return (0);
 300   if (!render->tempsz) newsz = 4*render->width + 1;
 301   else newsz = render->tempsz;
 302   while (newsz < want) newsz *= 2;
 303   newbuf = malloc(newsz + 1); if (!newbuf) return (-1);
 304   newbuf[newsz] = 0;
 305   free(render->tempbuf); render->tempbuf = newbuf; render->tempsz = newsz;
 306   return (0);
 307 }
 308
 309 enum { LEFT, RIGHT };
 310 static int putstr(struct progress_render_state *render, unsigned side,
 311                   const char *p, size_t n)
 312 {
 313   unsigned newwd = string_width(p, n);
 314   size_t want;
 315
 316   if (newwd >= render->width - render->leftwd - render->rightwd) return (-1);
 317   want = render->leftsz + render->rightsz + n;
 318   if (want > render->linesz && grow_linebuf(render, want)) return (-1);
 319   switch (side) {
 320     case LEFT:
 321       memcpy(render->linebuf + render->leftsz, p, n);
 322       render->leftsz += n; render->leftwd += newwd;
 323       break;
 324     case RIGHT:
 325       memcpy(render->linebuf + render->linesz - render->rightsz - n, p, n);
 326       render->rightsz += n; render->rightwd += newwd;
 327       break;
 328     default:
 329       return (-1);
 330   }
 331   return (0);
 332 }
 333
 334 static int vputf(struct progress_render_state *render, unsigned side,
 335                  const char *fmt, va_list ap)
 336 {
 337   va_list bp;
 338   int rc;
 339
 340   if (!render->tempsz && grow_tempbuf(render, 2*strlen(fmt))) return (-1);
 341   for (;;) {
 342     va_copy(bp, ap);
 343     rc = vsnprintf(render->tempbuf, render->tempsz, fmt, bp);
 344     va_end(bp);
 345     if (rc < 0) return (-1);
 346     if (rc <= render->tempsz) break;
 347     if (grow_tempbuf(render, 2*(rc + 1))) return (-1);
 348   }
 349   if (putstr(render, side, render->tempbuf, rc)) return (-1);
 350   return (0);
 351 }
 352
 353 int progress_vputleft(struct progress_render_state *render,
 354                       const char *fmt, va_list ap)
 355   { return (vputf(render, LEFT, fmt, ap)); }
 356
 357 int progress_vputright(struct progress_render_state *render,
 358                        const char *fmt, va_list ap)
 359   { return (vputf(render, RIGHT, fmt, ap)); }
 360
 361 int progress_putleft(struct progress_render_state *render,
 362                      const char *fmt, ...)
 363 {
 364   va_list ap;
 365   int rc;
 366
 367   va_start(ap, fmt); rc = vputf(render, LEFT, fmt, ap); va_end(ap);
 368   return (rc);
 369 }
 370
 371 int progress_putright(struct progress_render_state *render,
 372                       const char *fmt, ...)
 373 {
 374   va_list ap;
 375   int rc;
 376
 377   va_start(ap, fmt); rc = vputf(render, RIGHT, fmt, ap); va_end(ap);
 378   return (rc);
 379 }
 380
 381 #if defined(USE_TERMINFO)
 382 static const struct progress_ttyinfo *curtty = 0;
 383 static int putty(int ch) { return (putc(ch, curtty->fp)); }
 384 static void put_sequence(const struct progress_ttyinfo *tty,
 385                          const char *p, unsigned nlines)
 386   { if (p) { curtty = tty; tputs(p, nlines, putty); } }
 387 static void set_fgcolour(const struct progress_ttyinfo *tty, int colour)
 388   { put_sequence(tty, tgoto(tty->cap.af, -1, colour), 1); }
 389 static void set_bgcolour(const struct progress_ttyinfo *tty, int colour)
 390   { put_sequence(tty, tgoto(tty->cap.ab, -1, colour), 1); }
 391 #elif defined(USE_TERMCAP)
 392 static const struct progress_ttyinfo *curtty = 0;
 393 static int putty(int ch) { return (putc(ch, curtty->fp)); }
 394 static void put_sequence(const struct progress_ttyinfo *tty,
 395                          const char *p, unsigned nlines)
 396   { if (p) { curtty = tty; tputs(p, nlines, putty); } }
 397 static void set_fgcolour(const struct progress_ttyinfo *tty, int colour)
 398   { put_sequence(tty, tgoto(tty->cap.af, -1, colour), 1); }
 399 static void set_bgcolour(const struct progress_ttyinfo *tty, int colour)
 400   { put_sequence(tty, tgoto(tty->cap.ab, -1, colour), 1); }
 401 #else
 402 static void put_sequence(const struct progress_ttyinfo *tty,
 403                          const char *p, unsigned nlines) { ; }
 404 static void set_fgcolour(const struct progress_ttyinfo *tty, int colour)
 405   { ; }
 406 static void set_bgcolour(const struct progress_ttyinfo *tty, int colour)
 407   { ; }
 408 #endif
 409
 410 #define CLRF_ALL 1u
 411 static int clear_progress(struct progress_state *progress,
 412                           struct progress_render_state *render, unsigned f)
 413 {
 414   const struct progress_ttyinfo *tty = &progress->tty;
 415   unsigned ndel, nleave;
 416   unsigned i;
 417
 418   if (!tty->fp) return (-1);
 419
 420   put_sequence(tty, tty->cap.cr, 1);
 421   if (progress->last_lines) {
 422     if (f&CLRF_ALL)
 423       { ndel = progress->last_lines; nleave = 0; }
 424     else {
 425       if (progress->nitems >= progress->last_lines) ndel = 0;
 426       else ndel = progress->last_lines - progress->nitems;
 427       nleave = progress->last_lines - ndel;
 428     }
 429     if (!ndel)
 430       for (i = 0; i < nleave - 1; i++) put_sequence(tty, tty->cap.up, 1);
 431     else {
 432       for (i = 0; i < ndel - 1; i++) put_sequence(tty, tty->cap.up, 1);
 433       put_sequence(tty, tty->cap.cd, ndel);
 434       for (i = 0; i < nleave; i++) put_sequence(tty, tty->cap.up, 1);
 435     }
 436   }
 437   progress->last_lines = 0;
 438   if (ferror(tty->fp)) return (-1);
 439   return (0);
 440 }
 441
 442 int progress_clear(struct progress_state *progress)
 443 {
 444   struct progress_render_state render;
 445
 446   if (!progress->tty.fp) return (-1);
 447   setup_render_state(progress, &render);
 448   clear_progress(progress, &render, CLRF_ALL);
 449   free_render_state(&render);
 450   return (0);
 451 }
 452
 453 int progress_update(struct progress_state *progress)
 454 {
 455   struct progress_render_state render;
 456   const struct progress_ttyinfo *tty = &progress->tty;
 457   struct progress_item *item;
 458   unsigned f = 0;
 459 #define f_any 1u
 460
 461   if (!progress->tty.fp) return (-1);
 462   setup_render_state(progress, &render);
 463   clear_progress(progress, &render, 0);
 464
 465   for (item = progress->items; item; item = item->next) {
 466     if (f&f_any) put_sequence(tty, tty->cap.nw, 1);
 467     render.leftsz = render.rightsz = 0;
 468     render.leftwd = render.rightwd = 0;
 469     item->render(item, &render); progress->last_lines++; f |= f_any;
 470     if (progress->last_lines > render.height) break;
 471   }
 472   if (f&f_any) put_sequence(tty, tty->cap.cr, 1);
 473   free_render_state(&render);
 474   return (0);
 475 }
 476
 477 enum {
 478   LEFT_COLOUR,
 479   LEFT_MONO,
 480   LEFT_SIMPLE,
 481   RIGHT_ANY,
 482   STOP
 483 };
 484
 485 struct bar_state {
 486   const struct progress_render_state *render;
 487   unsigned pos, nextpos, state;
 488 };
 489
 490 static void advance_bar_state(struct bar_state *bar)
 491 {
 492   const struct progress_render_state *render = bar->render;
 493   const struct progress_ttyinfo *tty = render->tty;
 494   size_t here = bar->nextpos;
 495
 496   while (bar->nextpos <= here) {
 497     switch (bar->state) {
 498       case LEFT_COLOUR: set_bgcolour(tty, 3); goto right;
 499       case LEFT_MONO: put_sequence(tty, tty->cap.me, 1); goto right;
 500       case LEFT_SIMPLE: putc('|', tty->fp); goto right;
 501       right: bar->state = RIGHT_ANY; bar->nextpos = render->width; break;
 502       case RIGHT_ANY: bar->state = STOP; bar->nextpos = UINT_MAX; break;
 503     }
 504   }
 505 }
 506
 507 static void put_str(FILE *fp, const char *p, size_t sz)
 508   { while (sz--) putc(*p++, fp); }
 509 static void put_spc(FILE *fp, unsigned n)
 510   { while (n--) putc(' ', fp); }
 511
 512 static void put_barstr(struct bar_state *bar, const char *p, size_t sz)
 513 {
 514   unsigned wd;
 515   size_t n;
 516
 517   for (;;) {
 518     n = split_string(p, sz, &wd, bar->nextpos - bar->pos);
 519     if (n == sz && wd < bar->nextpos - bar->pos) break;
 520     put_str(bar->render->tty->fp, p, n); bar->pos += wd;
 521     advance_bar_state(bar);
 522     p += n; sz -= n;
 523   }
 524   put_str(bar->render->tty->fp, p, sz); bar->pos += wd;
 525 }
 526
 527 static void put_barspc(struct bar_state *bar, unsigned n)
 528 {
 529   unsigned step;
 530
 531   for (;;) {
 532     step = bar->nextpos - bar->pos;
 533     if (n < step) break;
 534     put_spc(bar->render->tty->fp, step); bar->pos += step;
 535     advance_bar_state(bar);
 536     n -= step;
 537   }
 538   put_spc(bar->render->tty->fp, n); bar->pos += n;
 539 }
 540
 541 int progress_showbar(struct progress_render_state *render, double frac)
 542 {
 543   const struct progress_ttyinfo *tty = render->tty;
 544   struct bar_state bar;
 545
 546   if (!tty->fp) return (-1);
 547
 548   bar.render = render; bar.pos = 0; bar.nextpos = frac*render->width + 0.5;
 549
 550   if (tty->cap.op) {
 551     set_fgcolour(tty, 0); bar.state = LEFT_COLOUR;
 552     if (bar.nextpos) set_bgcolour(tty, 2);
 553     else advance_bar_state(&bar);
 554   } else if (tty->cap.mr) {
 555     if (bar.nextpos)
 556       { bar.state = LEFT_MONO; put_sequence(tty, tty->cap.mr, 1); }
 557     else
 558       { bar.state = RIGHT; bar.nextpos = render->width; }
 559   } else
 560     bar.state = LEFT_SIMPLE;
 561
 562   put_barstr(&bar, render->linebuf, render->leftsz);
 563   put_barspc(&bar, render->width - render->leftwd - render->rightwd);
 564   put_barstr(&bar,
 565              render->linebuf + render->linesz - render->rightsz,
 566              render->rightsz);
 567
 568   put_sequence(tty, tty->cap.me, 1);
 569   put_sequence(tty, tty->cap.op, 1);
 570
 571   return (0);
 572 }
 573
 574 int progress_shownotice(struct progress_render_state *render, int bg, int fg)
 575 {
 576   const struct progress_ttyinfo *tty = render->tty;
 577
 578   if (!tty->fp) return (-1);
 579
 580   if (tty->cap.op) { set_fgcolour(tty, fg); set_bgcolour(tty, bg); }
 581   else if (tty->cap.mr) put_sequence(tty, tty->cap.mr, 1);
 582   if (tty->cap.md) put_sequence(tty, tty->cap.md, 1);
 583
 584   put_str(tty->fp, render->linebuf, render->leftsz);
 585   if (!render->rightsz && (tty->cap.f&TCF_BCE) && tty->cap.ce)
 586     put_sequence(tty, tty->cap.ce, 1);
 587   else {
 588     put_spc(tty->fp, render->width - render->leftwd - render->rightwd);
 589     put_str(tty->fp,
 590             render->linebuf + render->linesz - render->rightsz,
 591             render->rightsz);
 592   }
 593
 594   put_sequence(tty, tty->cap.me, 1);
 595   put_sequence(tty, tty->cap.op, 1);
 596
 597   return (0);
 598 }