xref: /minix3/external/bsd/top/dist/display.c (revision b89261ba018da33f0bd8cd05f5a1fe9e7a9c837b)

/*
 * Copyright (c) 1984 through 2008, William LeFebvre
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *
 *     * Redistributions in binary form must reproduce the above
 * copyright notice, this list of conditions and the following disclaimer
 * in the documentation and/or other materials provided with the
 * distribution.
 *
 *     * Neither the name of William LeFebvre nor the names of other
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/*
 *  Top users/processes display for Unix
 *  Version 3
 */

/*
 *  This file contains the routines that display information on the screen.
 *  Each section of the screen has two routines:  one for initially writing
 *  all constant and dynamic text, and one for only updating the text that
 *  changes.  The prefix "i_" is used on all the "initial" routines and the
 *  prefix "u_" is used for all the "updating" routines.
 *
 *  ASSUMPTIONS:
 *        None of the "i_" routines use any of the termcap capabilities.
 *        In this way, those routines can be safely used on terminals that
 *        have minimal (or nonexistant) terminal capabilities.
 *
 *        The routines should be called in this order:  *_loadave, *_uptime,
 *        i_timeofday, *_procstates, *_cpustates, *_memory, *_swap,
 *        *_message, *_header, *_process, *_endscreen.
 */

#include "os.h"
#include <ctype.h>
#include <stdarg.h>
#include <sys/types.h>
#include <sys/uio.h>
#include <unistd.h>

#include "top.h"
#include "machine.h"
#include "screen.h"		/* interface to screen package */
#include "layout.h"		/* defines for screen position layout */
#include "display.h"
#include "boolean.h"
#include "utils.h"

#ifdef ENABLE_COLOR
#include "color.h"
#endif

#define CURSOR_COST 8

#define MESSAGE_DISPLAY_TIME 5

/* imported from screen.c */
extern int overstrike;

static int lmpid = -1;
static int display_width = MAX_COLS;
static int ncpu = 0;

/* cursor positions of key points on the screen are maintained here */
/* layout.h has static definitions, but we may change our minds on some
   of the positions as we make decisions about what needs to be displayed */

static int x_lastpid = X_LASTPID;
static int y_lastpid = Y_LASTPID;
static int x_loadave = X_LOADAVE;
static int y_loadave = Y_LOADAVE;
static int x_minibar = X_MINIBAR;
static int y_minibar = Y_MINIBAR;
static int x_uptime = X_UPTIME;
static int y_uptime = Y_UPTIME;
static int x_procstate = X_PROCSTATE;
static int y_procstate = Y_PROCSTATE;
static int x_cpustates = X_CPUSTATES;
static int y_cpustates = Y_CPUSTATES;
static int x_kernel = X_KERNEL;
static int y_kernel = Y_KERNEL;
static int x_mem = X_MEM;
static int y_mem = Y_MEM;
static int x_swap = X_SWAP;
static int y_swap = Y_SWAP;
static int y_message = Y_MESSAGE;
static int x_header = X_HEADER;
static int y_header = Y_HEADER;
static int x_idlecursor = X_IDLECURSOR;
static int y_idlecursor = Y_IDLECURSOR;
static int y_procs = Y_PROCS;

/* buffer and colormask that describes the content of the screen */
/* these are singly dimensioned arrays -- the row boundaries are
   determined on the fly.
*/
static char *screenbuf = NULL;
static char *colorbuf = NULL;
static char scratchbuf[MAX_COLS];
static int bufsize = 0;
static int multi = 0;

/* lineindex tells us where the beginning of a line is in the buffer */
#define lineindex(l) ((l)*MAX_COLS)

/* screen's cursor */
static int curr_x, curr_y;
static int curr_color;

/* virtual cursor */
static int virt_x, virt_y;

static const char **procstate_names;
static const char **cpustate_names;
static const char **memory_names;
static const char **swap_names;
static const char **kernel_names;

static int num_procstates;
static int num_cpustates;
static int num_memory;
static int num_swap;
static int num_kernel;

static int *lprocstates;
static int *lcpustates;

static int *cpustate_columns;
static int cpustate_total_length;

static int header_status = Yes;

/* pending messages are stored in a circular buffer, where message_first
   is the next one to display, and message_last is the last one
   in the buffer.  Counters wrap around at MAX_MESSAGES.  The buffer is
   empty when message_first == message_last and full when
   message_last + 1 == message_first.  The pointer message_current holds
   the message currently being displayed, or "" if there is none.
*/
#define MAX_MESSAGES 16
static char *message_buf[MAX_MESSAGES];
static int message_first = 0;
static int message_last = 0;
static struct timeval message_time = {0, 0};
static char *message_current = NULL;
static int message_length = 0;
static int message_hold = 1;
static int message_barrier = No;

#ifdef ENABLE_COLOR
static int load_cidx[3];
static int header_cidx;
static int *cpustate_cidx;
static int *memory_cidx;
static int *swap_cidx;
static int *kernel_cidx;
#else
#define memory_cidx NULL
#define swap_cidx NULL
#define kernel_cidx NULL
#endif


/* internal support routines */

/*
 * static int string_count(char **pp)
 *
 * Pointer "pp" points to an array of string pointers, which is
 * terminated by a NULL.  Return the number of string pointers in
 * this array.
 */

static int
string_count(const char **pp)

{
    register int cnt = 0;

    if (pp != NULL)
    {
	while (*pp++ != NULL)
	{
	    cnt++;
	}
    }
    return(cnt);
}

void
display_clear(void)

{
    dprintf("display_clear\n");
    screen_clear();
    memzero(screenbuf, bufsize);
    memzero(colorbuf, bufsize);
    curr_x = curr_y = 0;
}

/*
 * void display_move(int x, int y)
 *
 * Efficiently move the cursor to x, y.  This assumes the cursor is
 * currently located at curr_x, curr_y, and will only use cursor
 * addressing when it is less expensive than overstriking what's
 * already on the screen.
 */

static void
display_move(int x, int y)

{
    char buff[128];
    char *p;
    char *bufp;
    char *colorp;
    int cnt = 0;
    int color = curr_color;

    dprintf("display_move(%d, %d): curr_x %d, curr_y %d\n", x, y, curr_x, curr_y);

    /* are we in a position to do this without cursor addressing? */
    if (curr_y < y || (curr_y == y && curr_x <= x))
    {
	/* start buffering up what it would take to move there by rewriting
	   what's on the screen */
	cnt = CURSOR_COST;
	p = buff;

	/* one newline for every line */
	while (cnt > 0 && curr_y < y)
	{
#ifdef ENABLE_COLOR
	    if (color != 0)
	    {
		p = strcpyend(p, color_setstr(0));
		color = 0;
		cnt -= 5;
	    }
#endif
	    *p++ = '\n';
	    curr_y++;
	    curr_x = 0;
	    cnt--;
	}

	/* write whats in the screenbuf */
	bufp = &screenbuf[lineindex(curr_y) + curr_x];
	colorp = &colorbuf[lineindex(curr_y) + curr_x];
	while (cnt > 0 && curr_x < x)
	{
#ifdef ENABLE_COLOR
	    if (color != *colorp)
	    {
		color = *colorp;
		p = strcpyend(p, color_setstr(color));
		cnt -= 5;
	    }
#endif
	    if ((*p = *bufp) == '\0')
	    {
		/* somwhere on screen we haven't been before */
		*p = *bufp = ' ';
	    }
	    p++;
	    bufp++;
	    colorp++;
	    curr_x++;
	    cnt--;
	}
    }

    /* move the cursor */
    if (cnt > 0)
    {
	/* screen rewrite is cheaper */
	*p = '\0';
	fputs(buff, stdout);
	curr_color = color;
    }
    else
    {
	screen_move(x, y);
    }

    /* update our position */
    curr_x = x;
    curr_y = y;
}

/*
 * display_write(int x, int y, int newcolor, int eol, char *new)
 *
 * Optimized write to the display.  This writes characters to the
 * screen in a way that optimizes the number of characters actually
 * sent, by comparing what is being written to what is already on
 * the screen (according to screenbuf and colorbuf).  The string to
 * write is "new", the first character of "new" should appear at
 * screen position x, y.  If x is -1 then "new" begins wherever the
 * cursor is currently positioned.  The string is written with color
 * "newcolor".  If "eol" is true then the remainder of the line is
 * cleared.  It is expected that "new" will have no newlines and no
 * escape sequences.
 */

static void
display_write(int x, int y, int newcolor, int eol, const char *new)

{
    char *bufp;
    char *colorp;
    int ch;
    int diff;

    dprintf("display_write(%d, %d, %d, %d, \"%s\")\n",
	    x, y, newcolor, eol, new);

    /* dumb terminal handling here */
    if (!smart_terminal)
    {
	if (x != -1)
	{
	    /* make sure we are on the right line */
	    while (curr_y < y)
	    {
		putchar('\n');
		curr_y++;
		curr_x = 0;
	    }

	    /* make sure we are on the right column */
	    while (curr_x < x)
	    {
		putchar(' ');
		curr_x++;
	    }
	}

	/* write */
	fputs(new, stdout);
	curr_x += strlen(new);

	return;
    }

    /* adjust for "here" */
    if (x == -1)
    {
	x = virt_x;
	y = virt_y;
    }
    else
    {
	virt_x = x;
	virt_y = y;
    }

    /* a pointer to where we start */
    bufp = &screenbuf[lineindex(y) + x];
    colorp = &colorbuf[lineindex(y) + x];

    /* main loop */
    while ((ch = *new++) != '\0')
    {
	/* if either character or color are different, an update is needed */
	/* but only when the screen is wide enough */
	if (x < display_width && (ch != *bufp || newcolor != *colorp))
	{
	    /* check cursor */
	    if (y != curr_y || x != curr_x)
	    {
		/* have to move the cursor */
		display_move(x, y);
	    }

	    /* write character */
#ifdef ENABLE_COLOR
	    if (curr_color != newcolor)
	    {
		fputs(color_setstr(newcolor), stdout);
		curr_color = newcolor;
	    }
#endif
	    putchar(ch);
	    *bufp = ch;
	    *colorp = curr_color;
	    curr_x++;
	}

	/* move */
	x++;
	virt_x++;
	bufp++;
	colorp++;
    }

    /* eol handling */
    if (eol && *bufp != '\0')
    {
	dprintf("display_write: clear-eol (bufp = \"%s\")\n", bufp);
	/* make sure we are color 0 */
#ifdef ENABLE_COLOR
	if (curr_color != 0)
	{
	    fputs(color_setstr(0), stdout);
	    curr_color = 0;
	}
#endif

	/* make sure we are at the end */
	if (x != curr_x || y != curr_y)
	{
	    screen_move(x, y);
	    curr_x = x;
	    curr_y = y;
	}

	/* clear to end */
	screen_cleareol(strlen(bufp));

	/* clear out whats left of this line's buffer */
	diff = display_width - x;
	if (diff > 0)
	{
	    memzero(bufp, diff);
	    memzero(colorp, diff);
	}
    }
}

static void
display_fmt(int x, int y, int newcolor, int eol, const char *fmt, ...)

{
    va_list argp;

    va_start(argp, fmt);

    vsnprintf(scratchbuf, MAX_COLS, fmt, argp);
    display_write(x, y, newcolor, eol, scratchbuf);
}

static void
display_cte(void)

{
    int len;
    int y;
    char *p;
    int need_clear = 0;

    /* is there anything out there that needs to be cleared? */
    p = &screenbuf[lineindex(virt_y) + virt_x];
    if (*p != '\0')
    {
	need_clear = 1;
    }
    else
    {
	/* this line is clear, what about the rest? */
	y = virt_y;
	while (++y < screen_length)
	{
	    if (screenbuf[lineindex(y)] != '\0')
	    {
		need_clear = 1;
		break;
	    }
	}
    }

    if (need_clear)
    {
	dprintf("display_cte: clearing\n");

	/* we will need this later */
	len = lineindex(virt_y) + virt_x;

	/* move to x and y, then clear to end */
	display_move(virt_x, virt_y);
	if (!screen_cte())
	{
	    /* screen has no clear to end, so do it by hand */
	    p = &screenbuf[len];
	    len = strlen(p);
	    if (len > 0)
	    {
		screen_cleareol(len);
	    }
	    while (++virt_y < screen_length)
	    {
		display_move(0, virt_y);
		p = &screenbuf[lineindex(virt_y)];
		len = strlen(p);
		if (len > 0)
		{
		    screen_cleareol(len);
		}
	    }
	}

	/* clear the screenbuf */
	memzero(&screenbuf[len], bufsize - len);
	memzero(&colorbuf[len], bufsize - len);
    }
}

static void
summary_format(int x, int y, int *numbers, const char **names, int *cidx)

{
    register int num;
    register const char *thisname;
    register const char *lastname = NULL;
    register int color;

    /* format each number followed by its string */
    while ((thisname = *names++) != NULL)
    {
	/* get the number to format */
	num = *numbers++;
	color = 0;

	/* display only non-zero numbers */
	if (num != 0)
	{
	    /* write the previous name */
	    if (lastname != NULL)
	    {
		display_write(-1, -1, 0, 0, lastname);
	    }

#ifdef ENABLE_COLOR
	    if (cidx != NULL)
	    {
		/* choose a color */
		color = color_test(*cidx++, num);
	    }
#endif

	    /* write this number if positive */
	    if (num > 0)
	    {
		display_write(x, y, color, 0, itoa(num));
	    }

	    /* defer writing this name */
	    lastname = thisname;

	    /* next iteration will not start at x, y */
	    x = y = -1;
	}
    }

    /* if the last string has a separator on the end, it has to be
       written with care */
    if (lastname != NULL)
    {
	if ((num = strlen(lastname)) > 1 &&
	    lastname[num-2] == ',' && lastname[num-1] == ' ')
	{
	    display_fmt(-1, -1, 0, 1, "%.*s", num-2, lastname);
	}
	else
	{
	    display_write(-1, -1, 0, 1, lastname);
	}
    }
}

static void
summary_format_memory(int x, int y, long *numbers, const char **names, int *cidx)

{
    register long num;
    register int color;
    register const char *thisname;
    register const char *lastname = NULL;

    /* format each number followed by its string */
    while ((thisname = *names++) != NULL)
    {
	/* get the number to format */
	num = *numbers++;
	color = 0;

	/* display only non-zero numbers */
	if (num != 0)
	{
	    /* write the previous name */
	    if (lastname != NULL)
	    {
		display_write(-1, -1, 0, 0, lastname);
	    }

	    /* defer writing this name */
	    lastname = thisname;

#ifdef ENABLE_COLOR
	    /* choose a color */
	    color = color_test(*cidx++, num);
#endif

	    /* is this number in kilobytes? */
	    if (thisname[0] == 'K')
	    {
		display_write(x, y, color, 0, format_k(num));
		lastname++;
	    }
	    else
	    {
		display_write(x, y, color, 0, itoa((int)num));
	    }

	    /* next iteration will not start at x, y */
	    x = y = -1;
	}
    }

    /* if the last string has a separator on the end, it has to be
       written with care */
    if (lastname != NULL)
    {
	if ((num = strlen(lastname)) > 1 &&
	    lastname[num-2] == ',' && lastname[num-1] == ' ')
	{
	    display_fmt(-1, -1, 0, 1, "%.*s", num-2, lastname);
	}
	else
	{
	    display_write(-1, -1, 0, 1, lastname);
	}
    }
}

/*
 * int display_resize()
 *
 * Reallocate buffer space needed by the display package to accomodate
 * a new screen size.  Must be called whenever the screen's size has
 * changed.  Returns the number of lines available for displaying
 * processes or -1 if there was a problem allocating space.
 */

int
display_resize()

{
    register int top_lines;
    register int newsize;

    /* calculate the current dimensions */
    /* if operating in "dumb" mode, we only need one line */
    top_lines = smart_terminal ? screen_length : 1;

    /* we don't want more than MAX_COLS columns, since the machine-dependent
       modules make static allocations based on MAX_COLS and we don't want
       to run off the end of their buffers */
    display_width = screen_width;
    if (display_width >= MAX_COLS)
    {
	display_width = MAX_COLS - 1;
    }

    /* see how much space we need */
    newsize = top_lines * (MAX_COLS + 1);

    /* reallocate only if we need more than we already have */
    if (newsize > bufsize)
    {
	/* deallocate any previous buffer that may have been there */
	if (screenbuf != NULL)
	{
	    free(screenbuf);
	}
	if (colorbuf != NULL)
	{
	    free(colorbuf);
	}

	/* allocate space for the screen and color buffers */
	bufsize = newsize;
	screenbuf = ecalloc(bufsize, sizeof(char));
	colorbuf = ecalloc(bufsize, sizeof(char));
	if (screenbuf == NULL || colorbuf == NULL)
	{
	    /* oops! */
	    return(-1);
	}
    }
    else
    {
	/* just clear them out */
	memzero(screenbuf, bufsize);
	memzero(colorbuf, bufsize);
    }

    /* for dumb terminals, pretend like we can show any amount */
    if (!smart_terminal)
	return Largest;

    /* adjust total lines on screen to lines available for procs */
    if (top_lines < y_procs)
	top_lines = 0;
    else
	top_lines -= y_procs;

    /* return number of lines available */
    return top_lines;
}

int
display_lines()

{
    return(smart_terminal ? screen_length : Largest);
}

int
display_columns()

{
    return(display_width);
}

/*
 * int display_init(struct statics *statics)
 *
 * Initialize the display system based on information in the statics
 * structure.  Returns the number of lines available for displaying
 * processes or -1 if there was an error.
 */

int
display_setmulti(int m)
{
    int i;
    if (m == multi)
	return 0;
    if ((multi = m) != 0) {
	for (i = 1; i < ncpu; i++)
	{
	    /* adjust screen placements */
	    y_kernel++;
	    y_mem++;
	    y_swap++;
	    y_message++;
	    y_header++;
	    y_idlecursor++;
	    y_procs++;
	}
	return -(ncpu - 1);
    } else {
	for (i = 1; i < ncpu; i++)
	{
	    /* adjust screen placements */
	    y_kernel--;
	    y_mem--;
	    y_swap--;
	    y_message--;
	    y_header--;
	    y_idlecursor--;
	    y_procs--;
	}
	return (ncpu - 1);
    }
}

int
display_init(struct statics *statics, int percpuinfo)

{
    register int top_lines;
    register const char **pp;
    register char *p;
    register int *ip;
    register int i;

    /* certain things may influence the screen layout,
       so look at those first */

    ncpu = statics->ncpu ? statics->ncpu : 1;
    /* a kernel line shifts parts of the display down */
    kernel_names = statics->kernel_names;
    if ((num_kernel = string_count(kernel_names)) > 0)
    {
	/* adjust screen placements */
	y_mem++;
	y_swap++;
	y_message++;
	y_header++;
	y_idlecursor++;
	y_procs++;
    }

    (void)display_setmulti(percpuinfo);

    /* a swap line shifts parts of the display down one */
    swap_names = statics->swap_names;
    if ((num_swap = string_count(swap_names)) > 0)
    {
	/* adjust screen placements */
	y_message++;
	y_header++;
	y_idlecursor++;
	y_procs++;
    }

    /* call resize to do the dirty work */
    top_lines = display_resize();

    /* only do the rest if we need to */
    if (top_lines > -1)
    {
	/* save pointers and allocate space for names */
	procstate_names = statics->procstate_names;
	num_procstates = string_count(procstate_names);
	lprocstates = ecalloc(num_procstates, sizeof(int));

	cpustate_names = statics->cpustate_names;
	num_cpustates = string_count(cpustate_names);
	lcpustates = ecalloc(num_cpustates, sizeof(int) * ncpu);
	cpustate_columns = ecalloc(num_cpustates, sizeof(int));
	memory_names = statics->memory_names;
	num_memory = string_count(memory_names);

	/* calculate starting columns where needed */
	cpustate_total_length = 0;
	pp = cpustate_names;
	ip = cpustate_columns;
	while (*pp != NULL)
	{
	    *ip++ = cpustate_total_length;
	    if ((i = strlen(*pp++)) > 0)
	    {
		cpustate_total_length += i + 8;
	    }
	}
	cpustate_total_length -= 2;
    }

#ifdef ENABLE_COLOR
    /* set up color tags for loadavg */
    load_cidx[0] = color_tag("1min");
    load_cidx[1] = color_tag("5min");
    load_cidx[2] = color_tag("15min");

    /* find header color */
    header_cidx = color_tag("header");

    /* color tags for cpu states */
    cpustate_cidx = emalloc(num_cpustates * sizeof(int));
    i = 0;
    p = strcpyend(scratchbuf, "cpu.");
    while (i < num_cpustates)
    {
	strcpy(p, cpustate_names[i]);
	cpustate_cidx[i++] = color_tag(scratchbuf);
    }

    /* color tags for kernel */
    if (num_kernel > 0)
    {
	kernel_cidx = emalloc(num_kernel * sizeof(int));
	i = 0;
	p = strcpyend(scratchbuf, "kernel.");
	while (i < num_kernel)
	{
	    strcpy(p, homogenize(kernel_names[i]+1));
	    kernel_cidx[i++] = color_tag(scratchbuf);
	}
    }

    /* color tags for memory */
    memory_cidx = emalloc(num_memory * sizeof(int));
    i = 0;
    p = strcpyend(scratchbuf, "memory.");
    while (i < num_memory)
    {
	strcpy(p, homogenize(memory_names[i]+1));
	memory_cidx[i++] = color_tag(scratchbuf);
    }

    /* color tags for swap */
    if (num_swap > 0)
    {
	swap_cidx = emalloc(num_swap * sizeof(int));
	i = 0;
	p = strcpyend(scratchbuf, "swap.");
	while (i < num_swap)
	{
	    strcpy(p, homogenize(swap_names[i]+1));
	    swap_cidx[i++] = color_tag(scratchbuf);
	}
    }
#endif

    /* return number of lines available (or error) */
    return(top_lines);
}

static void
pr_loadavg(double avg, int i)

{
    int color = 0;

#ifdef ENABLE_COLOR
    color = color_test(load_cidx[i], (int)(avg * 100));
#endif
    display_fmt(x_loadave + X_LOADAVEWIDTH * i, y_loadave, color, 0,
		avg < 10.0 ? " %5.2f" : " %5.1f", avg);
    display_write(-1, -1, 0, 0, (i < 2 ? "," : ";"));
}

void
i_loadave(int mpid, double *avenrun)

{
    register int i;

    /* mpid == -1 implies this system doesn't have an _mpid */
    if (mpid != -1)
    {
	display_fmt(0, 0, 0, 0,
		    "last pid: %5d;  load avg:", mpid);
	x_loadave = X_LOADAVE;
    }
    else
    {
	display_write(0, 0, 0, 0, "load averages:");
	x_loadave = X_LOADAVE - X_LASTPIDWIDTH;
    }
    for (i = 0; i < 3; i++)
    {
	pr_loadavg(avenrun[i], i);
    }

    lmpid = mpid;
}

void
u_loadave(int mpid, double *avenrun)

{
    register int i;

    if (mpid != -1)
    {
	/* change screen only when value has really changed */
	if (mpid != lmpid)
	{
	    display_fmt(x_lastpid, y_lastpid, 0, 0,
			"%5d", mpid);
	    lmpid = mpid;
	}
    }

    /* display new load averages */
    for (i = 0; i < 3; i++)
    {
	pr_loadavg(avenrun[i], i);
    }
}

static char minibar_buffer[64];
#define MINIBAR_WIDTH 20

void
i_minibar(int (*formatter)(char *, int))
{
    (void)((*formatter)(minibar_buffer, MINIBAR_WIDTH));

    display_write(x_minibar, y_minibar, 0, 0, minibar_buffer);
}

void
u_minibar(int (*formatter)(char *, int))
{
    (void)((*formatter)(minibar_buffer, MINIBAR_WIDTH));

    display_write(x_minibar, y_minibar, 0, 0, minibar_buffer);
}

static int uptime_days;
static int uptime_hours;
static int uptime_mins;
static int uptime_secs;

void
i_uptime(time_t *bt, time_t *tod)

{
    time_t uptime;

    if (*bt != -1)
    {
	uptime = *tod - *bt;
	uptime += 30;
	uptime_days = uptime / 86400;
	uptime %= 86400;
	uptime_hours = uptime / 3600;
	uptime %= 3600;
	uptime_mins = uptime / 60;
	uptime_secs = uptime % 60;

	/*
	 *  Display the uptime.
	 */

	display_fmt(x_uptime, y_uptime, 0, 0,
		    "  up %d+%02d:%02d:%02d",
		    uptime_days, uptime_hours, uptime_mins, uptime_secs);
    }
}

void
u_uptime(time_t *bt, time_t *tod)

{
    i_uptime(bt, tod);
}


void
i_timeofday(time_t *tod)

{
    /*
     *  Display the current time.
     *  "ctime" always returns a string that looks like this:
     *
     *	Sun Sep 16 01:03:52 1973
     *  012345678901234567890123
     *	          1         2
     *
     *  We want indices 11 thru 18 (length 8).
     */

    int x;

    /* where on the screen do we start? */
    x = (smart_terminal ? screen_width : 79) - 8;

    /* but don't bump in to uptime */
    if (x < x_uptime + 19)
    {
	x = x_uptime + 19;
    }

    /* display it */
    display_fmt(x, 0, 0, 1, "%-8.8s", &(ctime(tod)[11]));
}

static int ltotal = 0;
static int lthreads = 0;

/*
 *  *_procstates(total, brkdn, names) - print the process summary line
 */


void
i_procstates(int total, int *brkdn, int threads)

{
    /* write current number of processes and remember the value */
    display_fmt(0, y_procstate, 0, 0,
		"%d %s: ", total, threads ? "threads" : "processes");
    ltotal = total;

    /* remember where the summary starts */
    x_procstate = virt_x;

    if (total > 0)
    {
	/* format and print the process state summary */
	summary_format(-1, -1, brkdn, procstate_names, NULL);

	/* save the numbers for next time */
	memcpy(lprocstates, brkdn, num_procstates * sizeof(int));
	lthreads = threads;
    }
}

void
u_procstates(int total, int *brkdn, int threads)

{
    /* if threads state has changed, do a full update */
    if (lthreads != threads)
    {
	i_procstates(total, brkdn, threads);
	return;
    }

    /* update number of processes only if it has changed */
    if (ltotal != total)
    {
	display_fmt(0, y_procstate, 0, 0,
		    "%d", total);

	/* if number of digits differs, rewrite the label */
	if (digits(total) != digits(ltotal))
	{
	    display_fmt(-1, -1, 0, 0, " %s: ", threads ? "threads" : "processes");
	    x_procstate = virt_x;
	}

	/* save new total */
	ltotal = total;
    }

    /* see if any of the state numbers has changed */
    if (total > 0 && memcmp(lprocstates, brkdn, num_procstates * sizeof(int)) != 0)
    {
	/* format and update the line */
	summary_format(x_procstate, y_procstate, brkdn, procstate_names, NULL);
	memcpy(lprocstates, brkdn, num_procstates * sizeof(int));
    }
}

/*
 *  *_cpustates(states, names) - print the cpu state percentages
 */

/* cpustates_tag() calculates the correct tag to use to label the line */

static char *
cpustates_tag(int c)

{
    unsigned width, u;

    static char fmttag[100];

    const char *short_tag = !multi || ncpu <= 1 ? "CPU: " : "CPU%0*d: ";
    const char *long_tag = !multi || ncpu <= 1 ?
	"CPU states: " : "CPU%0*d states: ";

    for (width = 0, u = ncpu - 1; u > 0; u /= 10) {
	++width;
    }
    /* if length + strlen(long_tag) > screen_width, then we have to
       use the shorter tag */

    snprintf(fmttag, sizeof(fmttag), long_tag, width, c);

    if (cpustate_total_length + (signed)strlen(fmttag)  > screen_width) {
    	snprintf(fmttag, sizeof(fmttag), short_tag, width, c);
    }

    /* set x_cpustates accordingly then return result */
    x_cpustates = strlen(fmttag);
    return(fmttag);
}

void
i_cpustates(int *states)

{
    int value;
    const char **names;
    const char *thisname;
    int *colp;
    int color = 0;
#ifdef ENABLE_COLOR
    int *cidx;
#endif
    int c, i;

    if (multi == 0 && ncpu > 1)
    {
	for (c = 1; c < ncpu; c++)
	    for (i = 0; i < num_cpustates; i++)
		states[i] += states[c * num_cpustates + i];
	for (i = 0; i < num_cpustates; i++)
	    states[i] /= ncpu;
    }

    for (c = 0; c < (multi ? ncpu : 1); c++)
    {
#ifdef ENABLE_COLOR
    	cidx = cpustate_cidx;
#endif

	/* print tag */
	display_write(0, y_cpustates + c, 0, 0, cpustates_tag(c));
	colp = cpustate_columns;

	/* now walk thru the names and print the line */
	for (i = 0, names = cpustate_names; ((thisname = *names++) != NULL);)
	{
	    if (*thisname != '\0')
	    {
		/* retrieve the value and remember it */
		value = *states;

#ifdef ENABLE_COLOR
		/* determine color number to use */
		color = color_test(*cidx++, value/10);
#endif

		/* if percentage is >= 1000, print it as 100% */
		display_fmt(x_cpustates + *colp, y_cpustates + c,
			    color, 0,
			    (value >= 1000 ? "%4.0f%% %s%s" : "%4.1f%% %s%s"),
			    ((float)value)/10.,
			    thisname,
			    *names != NULL ? ", " : "");

	    }
	    /* increment */
	    colp++;
	    states++;
	}
    }

    /* copy over values into "last" array */
    memcpy(lcpustates, states, num_cpustates * sizeof(int) * ncpu);
}

void
u_cpustates(int *states)

{
    int value;
    const char **names;
    const char *thisname;
    int *lp;
    int *colp;
    int color = 0;
#ifdef ENABLE_COLOR
    int *cidx;
#endif
    int c, i;

    lp = lcpustates;

    if (multi == 0 && ncpu > 1)
    {
	for (c = 1; c < ncpu; c++)
	    for (i = 0; i < num_cpustates; i++)
		states[i] += states[c * num_cpustates + i];
	for (i = 0; i < num_cpustates; i++)
	    states[i] /= ncpu;
    }

    for (c = 0; c < (multi ? ncpu : 1); c++)
    {
#ifdef ENABLE_COLOR
    	cidx = cpustate_cidx;
#endif
	colp = cpustate_columns;
	/* we could be much more optimal about this */
	for (names = cpustate_names; (thisname = *names++) != NULL;)
	{
	    if (*thisname != '\0')
	    {
		/* did the value change since last time? */
		if (*lp != *states)
		{
		    /* yes, change it */
		    /* retrieve value and remember it */
		    value = *states;

#ifdef ENABLE_COLOR
		    /* determine color number to use */
		    color = color_test(*cidx, value/10);
#endif

		    /* if percentage is >= 1000, print it as 100% */
		    display_fmt(x_cpustates + *colp, y_cpustates + c, color, 0,
				(value >= 1000 ? "%4.0f" : "%4.1f"),
				((double)value)/10.);

		    /* remember it for next time */
		    *lp = value;
		}
#ifdef ENABLE_COLOR
		cidx++;
#endif
	    }

	    /* increment and move on */
	    lp++;
	    states++;
	    colp++;
	}
    }
}

void
z_cpustates()

{
    register int i, c;
    register const char **names = cpustate_names;
    register const char *thisname;
    register int *lp;

    /* print tag */
    for (c = 0; c < (multi ? ncpu : 1); c++)
    {
	display_write(0, y_cpustates + c, 0, 0, cpustates_tag(c));

	for (i = 0, names = cpustate_names; (thisname = *names++) != NULL;)
	{
	    if (*thisname != '\0')
	    {
		display_fmt(-1, -1, 0, 0, "%s    %% %s", i++ == 0 ? "" : ", ",
			    thisname);
	    }
	}
    }

    /* fill the "last" array with all -1s, to insure correct updating */
    lp = lcpustates;
    i = num_cpustates * ncpu;
    while (--i >= 0)
    {
	*lp++ = -1;
    }
}

/*
 *  *_kernel(stats) - print "Kernel: " followed by the kernel summary string
 *
 *  Assumptions:  cursor is on "lastline", the previous line
 */

void
i_kernel(int *stats)

{
    if (num_kernel > 0)
    {
	display_write(0, y_kernel, 0, 0, "Kernel: ");

	/* format and print the kernel summary */
	summary_format(x_kernel, y_kernel, stats, kernel_names, kernel_cidx);
    }
}

void
u_kernel(int *stats)

{
    if (num_kernel > 0)
    {
	/* format the new line */
	summary_format(x_kernel, y_kernel, stats, kernel_names, kernel_cidx);
    }
}

/*
 *  *_memory(stats) - print "Memory: " followed by the memory summary string
 *
 *  Assumptions:  cursor is on "lastline", the previous line
 */

void
i_memory(long *stats)

{
    display_write(0, y_mem, 0, 0, "Memory: ");

    /* format and print the memory summary */
    summary_format_memory(x_mem, y_mem, stats, memory_names, memory_cidx);
}

void
u_memory(long *stats)

{
    /* format the new line */
    summary_format_memory(x_mem, y_mem, stats, memory_names, memory_cidx);
}

/*
 *  *_swap(stats) - print "Swap: " followed by the swap summary string
 *
 *  Assumptions:  cursor is on "lastline", the previous line
 *
 *  These functions only print something when num_swap > 0
 */

void
i_swap(long *stats)

{
    if (num_swap > 0)
    {
	/* print the tag */
	display_write(0, y_swap, 0, 0, "Swap: ");

	/* format and print the swap summary */
	summary_format_memory(x_swap, y_swap, stats, swap_names, swap_cidx);
    }
}

void
u_swap(long *stats)

{
    if (num_swap > 0)
    {
	/* format the new line */
	summary_format_memory(x_swap, y_swap, stats, swap_names, swap_cidx);
    }
}

/*
 *  *_message() - print the next pending message line, or erase the one
 *                that is there.
 *
 *  Note that u_message is (currently) the same as i_message.
 *
 *  Assumptions:  lastline is consistent
 */

/*
 *  i_message is funny because it gets its message asynchronously (with
 *	respect to screen updates).  Messages are taken out of the
 *      circular message_buf and displayed one at a time.
 */

void
i_message(struct timeval *now)

{
    struct timeval my_now;
    int i = 0;

    dprintf("i_message(%08x)\n", now);

    /* if now is NULL we have to get it ourselves */
    if (now == NULL)
    {
	time_get(&my_now);
	now = &my_now;
    }

    /* now that we have been called, messages no longer need to be held */
    message_hold = 0;

    dprintf("i_message: now %d, message_time %d\n",
	    now->tv_sec, message_time.tv_sec);

    if (smart_terminal)
    {
	/* is it time to change the message? */
	if (timercmp(now, &message_time, > ))
	{
	    /* yes, free the current message */
	    dprintf("i_message: timer expired\n");
	    if (message_current != NULL)
	    {
		free(message_current);
		message_current = NULL;
	    }

	    /* is there a new message to be displayed? */
	    if (message_first != message_last)
	    {
		/* move index to next message */
		if (++message_first == MAX_MESSAGES) message_first = 0;

		/* make the next message the current one */
		message_current = message_buf[message_first];

		/* show it */
		dprintf("i_message: showing \"%s\"\n", message_current);
		display_move(0, y_message);
		screen_standout(message_current);
		i = strlen(message_current);

		/* set the expiration timer */
		message_time = *now;
		message_time.tv_sec += MESSAGE_DISPLAY_TIME;

		/* clear the rest of the line */
		screen_cleareol(message_length - i);
		putchar('\r');
		message_length = i;
	    }
	    else
	    {
		/* just clear what was there before, if anything */
		if (message_length > 0)
		{
		    display_move(0, y_message);
		    screen_cleareol(message_length);
		    putchar('\r');
		    message_length = 0;
		}
	    }
	}
    }
}

void
u_message(struct timeval *now)

{
    i_message(now);
}

static int header_length;

/*
 *  *_header(text) - print the header for the process area
 *
 *  Assumptions:  cursor is on the previous line and lastline is consistent
 */

void
i_header(char *text)

{
    int header_color = 0;

#ifdef ENABLE_COLOR
    header_color = color_test(header_cidx, 0);
#endif
    header_length = strlen(text);
    if (header_status)
    {
	display_write(x_header, y_header, header_color, 1, text);
    }
}

/*ARGSUSED*/
void
u_header(char *text)

{
    int header_color = 0;

#ifdef ENABLE_COLOR
    header_color = color_test(header_cidx, 0);
#endif
    display_write(x_header, y_header, header_color, 1,
		  header_status ? text : "");
}

/*
 *  *_process(line, thisline) - print one process line
 *
 *  Assumptions:  lastline is consistent
 */

void
i_process(int line, char *thisline)

{
    /* truncate the line to conform to our current screen width */
    thisline[display_width] = '\0';

    /* write the line out */
    display_write(0, y_procs + line, 0, 1, thisline);
}

void
u_process(int line, char *new_line)

{
    i_process(line, new_line);
}

void
i_endscreen()

{
    if (smart_terminal)
    {
	/* move the cursor to a pleasant place */
	display_move(x_idlecursor, y_idlecursor);
    }
    else
    {
	/* separate this display from the next with some vertical room */
	fputs("\n\n", stdout);
    }
    fflush(stdout);
}

void
u_endscreen()

{
    if (smart_terminal)
    {
	/* clear-to-end the display */
	display_cte();

	/* move the cursor to a pleasant place */
	display_move(x_idlecursor, y_idlecursor);
	fflush(stdout);
    }
    else
    {
	/* separate this display from the next with some vertical room */
	fputs("\n\n", stdout);
    }
}

void
display_header(int t)

{
    header_status = t != 0;
}

void
message_mark(void)

{
    message_barrier = Yes;
}

void
message_expire(void)

{
    message_time.tv_sec = 0;
    message_time.tv_usec = 0;
}

static void
message_flush(void)

{
    message_first = message_last;
    message_time.tv_sec = 0;
    message_time.tv_usec = 0;
}

/*
 * void new_message_v(char *msgfmt, va_list ap)
 *
 * Display a message in the message area.  This function takes a va_list for
 * the arguments.  Safe to call before display_init.  This function only
 * queues a message for display, and allowed for multiple messages to be
 * queued.  The i_message function drains the queue and actually writes the
 * messages on the display.
 */


static void
new_message_v(const char *msgfmt, va_list ap)

{
    int i;
    int empty;
    char msg[MAX_COLS];

    /* if message_barrier is active, remove all pending messages */
    if (message_barrier)
    {
	message_flush();
	message_barrier = No;
    }

    /* first, format the message */
    (void) vsnprintf(msg, sizeof(msg), msgfmt, ap);

    /* where in the buffer will it go? */
    i = message_last + 1;
    if (i >= MAX_MESSAGES) i = 0;

    /* make sure the buffer is not full */
    if (i != message_first)
    {
	/* insert it in to message_buf */
	message_buf[i] = estrdup(msg);
	dprintf("new_message_v: new message inserted in slot %d\n", i);

	/* remember if the buffer is empty and set the index */
	empty = message_last == message_first;
	message_last = i;

	/* is message_buf otherwise empty and have we started displaying? */
	if (empty && !message_hold)
	{
	    /* we can display the message now */
	    i_message(NULL);
	}
    }
}

/*
 * void new_message(int type, char *msgfmt, ...)
 *
 * Display a message in the message area.  It is safe to call this function
 * before display_init.  Messages logged before the display is drawn will be
 * held and displayed later.
 */

void
new_message(const char *msgfmt, ...)

{
    va_list ap;

    va_start(ap, msgfmt);
    new_message_v(msgfmt, ap);
    va_end(ap);
}

/*
 * void message_error(char *msgfmt, ...)
 *
 * Put an error message in the message area.  It is safe to call this function
 * before display_init.  Messages logged before the display is drawn will be
 * held and displayed later.
 */

void
message_error(const char *msgfmt, ...)

{
    va_list ap;

    va_start(ap, msgfmt);
    new_message_v(msgfmt, ap);
    fflush(stdout);
    va_end(ap);
}

/*
 * void message_clear()
 *
 * Clear message area and flush all pending messages.
 */

void
message_clear()

{
    /* remove any existing message */
    if (message_current != NULL)
    {
	display_move(0, y_message);
	screen_cleareol(message_length);
	free(message_current);
	message_current = 0;
    }

    /* flush all pending messages */
    message_flush();
}

/*
 * void message_prompt_v(int so, char *msgfmt, va_list ap)
 *
 * Place a prompt in the message area.  A prompt is different from a
 * message as follows: it is displayed immediately, overwriting any
 * message that may already be there, it may be highlighted in standout
 * mode (if "so" is true), the cursor is left to rest at the end of the
 * prompt.  This call causes all pending messages to be flushed.
 */

static void
message_prompt_v(int so, const char *msgfmt, va_list ap)

{
    char msg[MAX_COLS];
    int i;

    /* clear out the message buffer */
    message_flush();

    /* format the message */
    i = vsnprintf(msg, sizeof(msg), msgfmt, ap);

    /* this goes over any existing message */
    display_move(0, y_message);

    /* clear the entire line */
    screen_cleareol(message_length);

    /* show the prompt */
    if (so)
    {
	screen_standout(msg);
    }
    else
    {
	fputs(msg, stdout);
    }

    /* make it all visible */
    fflush(stdout);

    /* even though we dont keep a copy of the prompt, track its length */
    message_length = i < MAX_COLS ? i : MAX_COLS;
}

/*
 * void message_prompt(char *msgfmt, ...)
 *
 * Place a prompt in the message area (see message_prompt_v).
 */

void
message_prompt(const char *msgfmt, ...)

{
    va_list ap;

    va_start(ap, msgfmt);
    message_prompt_v(Yes, msgfmt, ap);
    va_end(ap);
}

void
message_prompt_plain(const char *msgfmt, ...)

{
    va_list ap;

    va_start(ap, msgfmt);
    message_prompt_v(No, msgfmt, ap);
    va_end(ap);
}

/*
 * int readline(char *buffer, int size, int numeric)
 *
 * Read a line of input from the terminal.  The line is placed in
 * "buffer" not to exceed "size".  If "numeric" is true then the input
 * can only consist of digits.  This routine handles all character
 * editing while keeping the terminal in cbreak mode.  If "numeric"
 * is true then the number entered is returned.  Otherwise the number
 * of character read in to "buffer" is returned.
 */

int
readline(char *buffer, int size, int numeric)

{
    register char *ptr = buffer;
    register char ch;
    register char cnt = 0;

    /* allow room for null terminator */
    size -= 1;

    /* read loop */
    while ((fflush(stdout), read(0, ptr, 1) > 0))
    {
	/* newline or return means we are done */
	if ((ch = *ptr) == '\n' || ch == '\r')
	{
	    break;
	}

	/* handle special editing characters */
	if (ch == ch_kill)
	{
	    /* return null string */
	    *buffer = '\0';
	    putchar('\r');
	    return(-1);
	}
	else if (ch == ch_werase)
	{
	    /* erase previous word */
	    if (cnt <= 0)
	    {
		/* none to erase! */
		putchar('\7');
	    }
	    else
	    {
		/*
		 * First: remove all spaces till the first-non-space
		 * Second: remove all non-spaces till the first-space
		 */
		while(cnt > 0 && ptr[-1] == ' ')
		{
		    fputs("\b \b", stdout);
		    ptr--;
		    cnt--;
		}
		while(cnt > 0 && ptr[-1] != ' ')
		{
		    fputs("\b \b", stdout);
		    ptr--;
		    cnt--;
		}
	    }
	}
	else if (ch == ch_erase)
	{
	    /* erase previous character */
	    if (cnt <= 0)
	    {
		/* none to erase! */
		putchar('\7');
	    }
	    else
	    {
		fputs("\b \b", stdout);
		ptr--;
		cnt--;
	    }
	}
	/* check for character validity and buffer overflow */
	else if (cnt == size || (numeric && !isdigit((int)ch)) ||
		!isprint((int)ch))
	{
	    /* not legal */
	    putchar('\7');
	}
	else
	{
	    /* echo it and store it in the buffer */
	    putchar(ch);
	    ptr++;
	    cnt++;
	}
    }

    /* all done -- null terminate the string */
    *ptr = '\0';

    /* add response length to message_length */
    message_length += cnt;

    /* return either inputted number or string length */
    putchar('\r');
    return(cnt == 0 ? -1 : numeric ? atoi(buffer) : cnt);
}

void
display_pagerstart()

{
    display_clear();
}

void
display_pagerend()

{
    char ch;

    screen_standout("Hit any key to continue: ");
    fflush(stdout);
    (void) read(0, &ch, 1);
}

void
display_pager(const char *fmt, ...)

{
    va_list ap;

    int ch;
    char readch;
    char buffer[MAX_COLS];
    char *data;

    /* format into buffer */
    va_start(ap, fmt);
    (void) vsnprintf(buffer, MAX_COLS, fmt, ap);
    va_end(ap);
    data = buffer;

    while ((ch = *data++) != '\0')
    {
	putchar(ch);
	if (ch == '\n')
	{
	    if (++curr_y >= screen_length - 1)
	    {
		screen_standout("...More...");
		fflush(stdout);
		(void) read(0, &readch, 1);
		putchar('\r');
		switch(readch)
		{
		case '\r':
		case '\n':
		    curr_y--;
		    break;

		case 'q':
		    return;

		default:
		    curr_y = 0;
		}
	    }
	}
    }
}