progress.c File Reference

Progress bar. More...

#include "config.h"
#include <stdarg.h>
#include <stdbool.h>
#include <string.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "progress.h"
#include "mutt_logging.h"
#include "muttlib.h"
#include "options.h"

Include dependency graph for progress.c:

Go to the source code of this file.

Functions
static void	message_bar (int percent, const char *fmt,...)
	Draw a colourful progress bar. More...
static size_t	progress_choose_increment (enum ProgressType type)
	Choose the right increment given a ProgressType. More...
static bool	progress_pos_needs_update (const struct Progress *progress, long pos)
	Do we need to update, given the current pos? More...
static bool	progress_time_needs_update (const struct Progress *progress, size_t now)
	Do we need to update, given the current time? More...
void	mutt_progress_init (struct Progress *progress, const char *msg, enum ProgressType type, size_t size)
	Set up a progress bar. More...
void	mutt_progress_update (struct Progress *progress, size_t pos, int percent)
	Update the state of the progress bar. More...

Detailed Description

Progress bar.

Authors

• Richard Russon
• Pietro Cerutti

Copyright

This program 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.

This program 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 this program. If not, see http://www.gnu.org/licenses/.

Definition in file progress.c.

Function Documentation

message_bar()

static void message_bar ( int  percent, const char *  fmt,   ...  )

static

Draw a colourful progress bar.

Parameters

percent	age complete
fmt	printf(1)-like formatting string
...	Arguments to formatting string

Definition at line 49 of file progress.c.

{
  if (!fmt || !MessageWindow)
    return;

  va_list ap;
  char buf[256], buf2[256];
  int w = (percent * MessageWindow->state.cols) / 100;
  size_t l;

  va_start(ap, fmt);
  vsnprintf(buf, sizeof(buf), fmt, ap);
  l = mutt_strwidth(buf);
  va_end(ap);

  mutt_simple_format(buf2, sizeof(buf2), 0, MessageWindow->state.cols - 2,
                     JUSTIFY_LEFT, 0, buf, sizeof(buf), false);

  mutt_window_move(MessageWindow, 0, 0);

  if (mutt_color(MT_COLOR_PROGRESS) == 0)
  {
    mutt_window_addstr(buf2);
  }
  else
  {
    if (l < w)
    {
      /* The string fits within the colour bar */
      mutt_curses_set_color(MT_COLOR_PROGRESS);
      mutt_window_addstr(buf2);
      w -= l;
      while (w-- > 0)
      {
        mutt_window_addch(' ');
      }
      mutt_curses_set_color(MT_COLOR_NORMAL);
    }
    else
    {
      /* The string is too long for the colour bar */
      int off = mutt_wstr_trunc(buf2, sizeof(buf2), w, NULL);

      char ch = buf2[off];
      buf2[off] = '\0';
      mutt_curses_set_color(MT_COLOR_PROGRESS);
      mutt_window_addstr(buf2);
      buf2[off] = ch;
      mutt_curses_set_color(MT_COLOR_NORMAL);
      mutt_window_addstr(&buf2[off]);
    }
  }

  clrtoeol();
  mutt_refresh();
}

Here is the call graph for this function:

Here is the caller graph for this function:

progress_choose_increment()

static size_t progress_choose_increment ( enum ProgressType  type )

static

Choose the right increment given a ProgressType.

Parameters

type	ProgressType

Return values

Increment

value

Definition at line 111 of file progress.c.

{
  const short c_read_inc = cs_subset_number(NeoMutt->sub, "read_inc");
  const short c_write_inc = cs_subset_number(NeoMutt->sub, "write_inc");
  const short c_net_inc = cs_subset_number(NeoMutt->sub, "net_inc");
  const short *incs[] = { &c_read_inc, &c_write_inc, &c_net_inc };
  return (type >= mutt_array_size(incs)) ? 0 : *incs[type];
}

Here is the call graph for this function:

Here is the caller graph for this function:

progress_pos_needs_update()

static bool progress_pos_needs_update ( const struct Progress *  progress, long  pos  )

static

Do we need to update, given the current pos?

Parameters

progress	Progress
pos	Current pos

Return values

true	Progress needs an update

Definition at line 126 of file progress.c.

{
  const unsigned shift = progress->is_bytes ? 10 : 0;
  return pos >= (progress->pos + (progress->inc << shift));
}

Here is the caller graph for this function:

progress_time_needs_update()

static bool progress_time_needs_update ( const struct Progress *  progress, size_t  now  )

static

Do we need to update, given the current time?

Parameters

progress	Progress
now	Current time

Return values

true	Progress needs an update

Definition at line 138 of file progress.c.

{
  const size_t elapsed = (now - progress->timestamp);
  const short c_time_inc = cs_subset_number(NeoMutt->sub, "time_inc");
  return (c_time_inc == 0) || (now < progress->timestamp) || (c_time_inc < elapsed);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_progress_init()

void mutt_progress_init	(	struct Progress *	progress,
		const char *	msg,
		enum ProgressType	type,
		size_t	size
	)

Set up a progress bar.

Parameters

progress	Progress bar
msg	Message to display; this is copied into the Progress object
type	Type, e.g. MUTT_PROGRESS_READ
size	Total size of expected file / traffic

Definition at line 152 of file progress.c.

{
  if (!progress || OptNoCurses)
    return;

  /* Initialize Progress structure */
  memset(progress, 0, sizeof(struct Progress));
  mutt_str_copy(progress->msg, msg, sizeof(progress->msg));
  progress->size = size;
  progress->inc = progress_choose_increment(type);
  progress->is_bytes = (type == MUTT_PROGRESS_NET);

  /* Generate the size string, if a total size was specified */
  if (progress->size != 0)
  {
    if (progress->is_bytes)
    {
      mutt_str_pretty_size(progress->sizestr, sizeof(progress->sizestr),
                           progress->size);
    }
    else
    {
      snprintf(progress->sizestr, sizeof(progress->sizestr), "%zu", progress->size);
    }
  }

  if (progress->inc == 0)
  {
    /* This progress bar does not increment - write the initial message */
    if (progress->size == 0)
    {
      mutt_message(progress->msg);
    }
    else
    {
      mutt_message("%s (%s)", progress->msg, progress->sizestr);
    }
  }
  else
  {
    /* This progress bar does increment - perform the initial update */
    mutt_progress_update(progress, 0, 0);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_progress_update()

void mutt_progress_update	(	struct Progress *	progress,
		size_t	pos,
		int	percent
	)

Update the state of the progress bar.

Parameters

progress	Progress bar
pos	Position, or count
percent	Percentage complete

If percent is -1, then the percentage will be calculated using pos and the size in progress.

If percent is positive, it is displayed as percentage, otherwise percentage is calculated from progress->size and pos if progress was initialized with positive size, otherwise no percentage is shown

Definition at line 211 of file progress.c.

{
  if (OptNoCurses)
    return;

  const uint64_t now = mutt_date_epoch_ms();

  const bool update = (pos == 0) /* always show the first update */ ||
                      (progress_pos_needs_update(progress, pos) &&
                       progress_time_needs_update(progress, now));

  if (progress->inc != 0 && update)
  {
    progress->pos = pos;
    progress->timestamp = now;

    char posstr[128];
    if (progress->is_bytes)
    {
      const size_t round_pos =
          (progress->pos / (progress->inc << 10)) * (progress->inc << 10);
      mutt_str_pretty_size(posstr, sizeof(posstr), round_pos);
    }
    else
    {
      snprintf(posstr, sizeof(posstr), "%zu", progress->pos);
    }

    mutt_debug(LL_DEBUG4, "updating progress: %s\n", posstr);

    if (progress->size != 0)
    {
      if (percent < 0)
      {
        percent = 100.0 * progress->pos / progress->size;
      }
      message_bar(percent, "%s %s/%s (%d%%)", progress->msg, posstr,
                  progress->sizestr, percent);
    }
    else
    {
      if (percent > 0)
        message_bar(percent, "%s %s (%d%%)", progress->msg, posstr, percent);
      else
        mutt_message("%s %s", progress->msg, posstr);
    }
  }

  if (progress->pos >= progress->size)
    mutt_clear_error();
}

Here is the call graph for this function:

Here is the caller graph for this function: