usage: Print metavariables in SHOUTY letters.

[sw-tools] / src / pres_curses.c

/* -*-c-*-
 *
 * $Id$
 *
 * Curses-based output presentation
 *
 * (c) 1999 EBI
 */

/*----- Licensing notice --------------------------------------------------* 
 *
 * This file is part of sw-tools.
 *
 * sw-tools is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * sw-tools is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with sw-tools; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

/*----- Header files ------------------------------------------------------*/

#include "config.h"
#ifdef HAVE_CURSES

#include <errno.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <sys/types.h>
#include <unistd.h>

#if defined(HAVE_NCURSES_H)
#  include <ncurses.h>
#elif defined(HAVE_NCURSES_NCURSES_H)
#  include <ncurses/ncurses.h>
#elif defined(HAVE_CURSES_H)
#  include <curses.h>
#else
#  error "Where's your <curses.h> header?"
#endif
#include <term.h>

#include <mLib/alloc.h>
#include <mLib/report.h>

#include "sw.h"
#include "sw_arch.h"
#include "pres_curses.h"

#ifndef SIGWINCH
#  undef HAVE_WRESIZE
#endif

/*----- Data structures ---------------------------------------------------*/

typedef struct cwin {
  struct cwin *next;
  WINDOW *w;
  int top;
  int height;
  WINDOW *s;
  archent *e;
} cwin;

/*----- Static variables --------------------------------------------------*/

static cwin *cwins = 0;
static int nwins = 0;

/*----- Main code ---------------------------------------------------------*/

/* --- @sizes@ --- *
 *
 * Arguments:	---
 *
 * Returns:	---
 *
 * Use:		Calculates window sizes for all the windows.  The heights are
 *		determined in a way which doesn't allow rounding errors to be
 *		an issue (although there will be up to a line's height
 *		difference between two windows).  No actual changing of
 *		curses structures is done.
 */

static void sizes(void)
{
  cwin *c;
  int t = 0, h = LINES, w = nwins;

  for (c = cwins; c; c = c->next) {
    int a = h / w;
    c->top = t;
    c->height = a - 1;
    t += a;
    h -= a;
    w--;
  }
}

/* --- @sig_tstp@ --- */

#ifdef SIGTSTP
static void sig_tstp(int s)
{
  int e = errno;
  endwin();
  errno = e;
  raise(SIGSTOP);
}
#endif

/* --- @sig_cont@ --- */

#ifdef SIGTSTP
static void sig_cont(int s)
{
  int e = errno;
  wrefresh(curscr);
  errno = e;
}
#endif

/* --- @sig_winch@ --- */

#ifdef SIGWINCH

static void sig_winch(int s)
{
  int e = errno;

#ifdef HAVE_WRESIZE
  cwin *c;

  endwin();
  wrefresh(curscr);
  sizes();
  for (c = cwins; c; c = c->next) {
    mvwin(c->w, c->top, 0);
    wresize(c->w, c->height, COLS);
    mvwin(c->s, c->top + c->height, 0);
    wnoutrefresh(c->w);
    wnoutrefresh(c->s);
  }
  doupdate();
#else
  endwin();
  wrefresh(curscr);
#endif
  errno = e;
}

#endif

/* --- @curses_ok@ --- */

int curses_ok(void)
{
  if (!isatty(STDOUT_FILENO)) {
    moan("can't use curses: stdout isn't a terminal");
    return (0);
  }
  if (setupterm(0, STDOUT_FILENO, 0) == ERR) {
    moan("can't use curses: couldn't read terminfo");
    return (0);
  }
  if (!tigetstr("cup")) {
    moan("can't use curses: terminal insufficiently winning");
    return (0);
  }
  return (1);
}

/* --- @curses_init@ --- */

int curses_init(archcons *a)
{
  cwin **cc = &cwins, *c;

  /* --- Allocate my window structures --- */

  nwins = 0;
  for (; a; a = a->cdr) {
    archent *e = a->car;
    if (!e->r)
      continue;
    c = xmalloc(sizeof(cwin));
    e->pres = c;
    c->w = 0;
    c->e = e;
    nwins++;
    *cc = c;
    cc = &c->next;
  }
  *cc = 0;

  /* --- Haul curses up by its naughty bits --- */

  initscr();
  keypad(stdscr, TRUE);
  cbreak();
  noecho();
  nonl();
  def_prog_mode();

  /* --- Grind through everything setting up windows --- */

  sizes();
  for (c = cwins; c; c = c->next) {
    if ((c->w = newwin(c->height, COLS, c->top, 0)) == 0 ||
	(c->s = newwin(1, COLS, c->top + c->height, 0)) == 0)
      goto fail_0;
    scrollok(c->w, TRUE);
    leaveok(c->w, TRUE);
    leaveok(c->s, TRUE);
    wbkgd(c->s, A_STANDOUT);
    mvwprintw(c->s, 0, 0, "  %s [running]\n", c->e->arch);
    wnoutrefresh(c->w);
    wnoutrefresh(c->s);
  }
  doupdate();

#ifdef SIGWINCH
  signal(SIGWINCH, sig_winch);
#endif
#ifdef SIGTSTP
  signal(SIGTSTP, sig_tstp);
  signal(SIGCONT, sig_cont);
#endif
  return (0);

fail_0:
  c = cwins;
  while (c) {
    cwin *cc = c->next;
    if (c->w)
      delwin(c->w);
    if (c->s)
      delwin(c->s);
    free(c);
    c = cc;
  }
  endwin();
  return (-1);
}

/* --- @curses_output@ --- */

void curses_output(archent *e, const char *p, size_t sz)
{
  cwin *c = e->pres;
  int y, x;
  while (sz) {
    switch (*p) {
      case '\r':
       getyx(c->w, y, x);
       wmove(c->w, y, 0);
       break;
      case '\n':
       getyx(c->w, y, x);
       if (y < c->height - 1)
         y++;
       else
         scroll(c->w);
       wmove(c->w, y, 0);
       break;
      default:
       waddch(c->w, *p);
       break;
    }
    p++;
    sz--;
  }
  wrefresh(c->w);
}

/* --- @curses_close@ --- */

void curses_close(archent *e, int ok, const char *summ)
{
  cwin *c = e->pres;
  mvwprintw(c->s, 0, 0, "  %s [%s]\n", e->arch, summ);
  wrefresh(c->s);
}

/* --- @curses_done@ --- */

void curses_done(archcons *a)
{
  if (opt_flags & optFlag_beep) {
    beep();
    doupdate();
  }
  wgetch(cwins->w);
  cwins = 0;
  for (; a; a = a->cdr) {
    archent *e = a->car;
    cwin *c = e->pres;
    delwin(c->w);
    delwin(c->s);
    free(c);
  }
  curses_abort(0);
}

/* --- @curses_abort@ --- */

void curses_abort(archcons *a)
{
#ifdef HAVE_WRESIZE
  signal(SIGWINCH, SIG_DFL);
#endif
#ifdef SIGTSTP
  signal(SIGTSTP, SIG_DFL);
  signal(SIGCONT, SIG_DFL);
#endif
  endwin();
}

/*----- That's all, folks -------------------------------------------------*/

#else
  int pres_curses__built = 1;
#endif