/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*-
*
* Copyright (C) 2013,2014,2015 Colin Walters <walters@verbum.org>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published
* by the Free Software Foundation; either version 2 of the licence or (at
* your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General
* Public License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include "glnx-console.h"
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <stdio.h>
#include <errno.h>
#include <sys/ioctl.h>
/* For people with widescreen monitors and maximized terminals, it looks pretty
* bad to have an enormous progress bar. For much the same reason as web pages
* tend to have a maximum width;
* https://ux.stackexchange.com/questions/48982/suggest-good-max-width-for-fluid-width-design
*/
#define MAX_PROGRESSBAR_COLUMNS 20
/* Max updates output per second. On a tty there's no point to rendering
* extremely fast; and for a non-tty we're probably in a Jenkins job
* or whatever and having percentages spam multiple lines there is annoying.
*/
#define MAX_TTY_UPDATE_HZ (5)
#define MAX_NONTTY_UPDATE_HZ (1)
static gboolean locked;
static guint64 last_update_ms; /* monotonic time in millis we last updated */
gboolean
glnx_stdout_is_tty (void)
{
static gsize initialized = 0;
static gboolean stdout_is_tty_v;
if (g_once_init_enter (&initialized))
{
stdout_is_tty_v = isatty (1);
g_once_init_leave (&initialized, 1);
}
return stdout_is_tty_v;
}
static volatile guint cached_columns = 0;
static volatile guint cached_lines = 0;
static int
fd_columns (int fd)
{
struct winsize ws = {};
if (ioctl (fd, TIOCGWINSZ, &ws) < 0)
return -errno;
if (ws.ws_col <= 0)
return -EIO;
return ws.ws_col;
}
/**
* glnx_console_columns:
*
* Returns: The number of columns for terminal output
*/
guint
glnx_console_columns (void)
{
if (G_UNLIKELY (cached_columns == 0))
{
int c;
c = fd_columns (STDOUT_FILENO);
if (c <= 0)
c = 80;
if (c > 256)
c = 256;
cached_columns = c;
}
return cached_columns;
}
static int
fd_lines (int fd)
{
struct winsize ws = {};
if (ioctl (fd, TIOCGWINSZ, &ws) < 0)
return -errno;
if (ws.ws_row <= 0)
return -EIO;
return ws.ws_row;
}
/**
* glnx_console_lines:
*
* Returns: The number of lines for terminal output
*/
guint
glnx_console_lines (void)
{
if (G_UNLIKELY (cached_lines == 0))
{
int l;
l = fd_lines (STDOUT_FILENO);
if (l <= 0)
l = 24;
cached_lines = l;
}
return cached_lines;
}
static void
on_sigwinch (int signum)
{
cached_columns = 0;
cached_lines = 0;
}
void
glnx_console_lock (GLnxConsoleRef *console)
{
static gsize sigwinch_initialized = 0;
g_return_if_fail (!locked);
g_return_if_fail (!console->locked);
console->is_tty = glnx_stdout_is_tty ();
locked = console->locked = TRUE;
if (console->is_tty)
{
if (g_once_init_enter (&sigwinch_initialized))
{
signal (SIGWINCH, on_sigwinch);
g_once_init_leave (&sigwinch_initialized, 1);
}
{ static const char initbuf[] = { 0x1B, 0x37 };
(void) fwrite (initbuf, 1, sizeof (initbuf), stdout);
}
}
}
static void
printpad (const char *padbuf,
guint padbuf_len,
guint n)
{
const guint d = n / padbuf_len;
const guint r = n % padbuf_len;
guint i;
for (i = 0; i < d; i++)
fwrite (padbuf, 1, padbuf_len, stdout);
fwrite (padbuf, 1, r, stdout);
}
static void
text_percent_internal (const char *text,
int percentage)
{
/* Check whether we're trying to render too fast; unless percentage is 100, in
* which case we assume this is the last call, so we always render it.
*/
const guint64 current_ms = g_get_monotonic_time () / 1000;
if (percentage != 100)
{
const guint64 diff_ms = current_ms - last_update_ms;
if (glnx_stdout_is_tty ())
{
if (diff_ms < (1000/MAX_TTY_UPDATE_HZ))
return;
}
else
{
if (diff_ms < (1000/MAX_NONTTY_UPDATE_HZ))
return;
}
}
last_update_ms = current_ms;
static const char equals[] = "====================";
const guint n_equals = sizeof (equals) - 1;
static const char spaces[] = " ";
const guint n_spaces = sizeof (spaces) - 1;
const guint ncolumns = glnx_console_columns ();
const guint bar_min = 10;
if (text && !*text)
text = NULL;
const guint input_textlen = text ? strlen (text) : 0;
if (!glnx_stdout_is_tty ())
{
if (text)
fprintf (stdout, "%s", text);
if (percentage != -1)
{
if (text)
fputc (' ', stdout);
fprintf (stdout, "%u%%", percentage);
}
fputc ('\n', stdout);
fflush (stdout);
return;
}
if (ncolumns < bar_min)
return; /* TODO: spinner */
/* Restore cursor */
{ const char beginbuf[2] = { 0x1B, 0x38 };
(void) fwrite (beginbuf, 1, sizeof (beginbuf), stdout);
}
if (percentage == -1)
{
if (text != NULL)
fwrite (text, 1, input_textlen, stdout);
/* Overwrite remaining space, if any */
if (ncolumns > input_textlen)
printpad (spaces, n_spaces, ncolumns - input_textlen);
}
else
{
const guint textlen = MIN (input_textlen, ncolumns - bar_min);
const guint barlen = MIN (MAX_PROGRESSBAR_COLUMNS, ncolumns - (textlen + 1));
if (textlen > 0)
{
fwrite (text, 1, textlen, stdout);
fputc (' ', stdout);
}
{
const guint nbraces = 2;
const guint textpercent_len = 5;
const guint bar_internal_len = barlen - nbraces - textpercent_len;
const guint eqlen = bar_internal_len * (percentage / 100.0);
const guint spacelen = bar_internal_len - eqlen;
fputc ('[', stdout);
printpad (equals, n_equals, eqlen);
printpad (spaces, n_spaces, spacelen);
fputc (']', stdout);
fprintf (stdout, " %3d%%", percentage);
}
}
fflush (stdout);
}
/**
* glnx_console_progress_text_percent:
* @text: Show this text before the progress bar
* @percentage: An integer in the range of 0 to 100
*
* On a tty, print to the console @text followed by an ASCII art
* progress bar whose percentage is @percentage. If stdout is not a
* tty, a more basic line by line change will be printed.
*
* You must have called glnx_console_lock() before invoking this
* function.
*
*/
void
glnx_console_progress_text_percent (const char *text,
guint percentage)
{
g_return_if_fail (percentage <= 100);
text_percent_internal (text, percentage);
}
/**
* glnx_console_progress_n_items:
* @text: Show this text before the progress bar
* @current: An integer for how many items have been processed
* @total: An integer for how many items there are total
*
* On a tty, print to the console @text followed by [@current/@total],
* then an ASCII art progress bar, like glnx_console_progress_text_percent().
*
* You must have called glnx_console_lock() before invoking this
* function.
*/
void
glnx_console_progress_n_items (const char *text,
guint current,
guint total)
{
g_return_if_fail (current <= total);
g_return_if_fail (total > 0);
g_autofree char *newtext = g_strdup_printf ("%s (%u/%u)", text, current, total);
/* Special case current == total to ensure we end at 100% */
int percentage = (current == total) ? 100 : (((double)current) / total * 100);
glnx_console_progress_text_percent (newtext, percentage);
}
void
glnx_console_text (const char *text)
{
text_percent_internal (text, -1);
}
/**
* glnx_console_unlock:
*
* Print a newline, and reset all cached console progress state.
*
* This function does nothing if stdout is not a tty.
*/
void
glnx_console_unlock (GLnxConsoleRef *console)
{
g_return_if_fail (locked);
g_return_if_fail (console->locked);
if (console->is_tty)
fputc ('\n', stdout);
locked = console->locked = FALSE;
}