progress.c File Reference

Progress bar. More...

#include "config.h"
#include <stdarg.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "lib.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.

Data Structures
struct	Progress
	A Progress Bar. More...

Functions
static void	message_bar (struct MuttWindow *win, int percent, const char *fmt,...)
	Draw a colourful progress bar. More...
static size_t	choose_increment (enum ProgressType type)
	Choose the right increment given a ProgressType. More...
static bool	pos_needs_update (const struct Progress *progress, long pos)
	Do we need to update, given the current pos? More...
static bool	time_needs_update (const struct Progress *progress, size_t now)
	Do we need to update, given the current time? More...
void	progress_update (struct Progress *progress, size_t pos, int percent)
	Update the state of the progress bar. More...
void	progress_free (struct Progress **ptr)
	Free a Progress Bar. More...
struct Progress *	progress_new (const char *msg, enum ProgressType type, size_t size)
	Create a new 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 ( struct MuttWindow *  win, int  percent, const char *  fmt,   ...  )

static

Draw a colourful progress bar.

Parameters

win	Window to draw on
percent	age complete
fmt	printf(1)-like formatting string
...	Arguments to formatting string

Definition at line 66 of file progress.c.

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

  va_list ap;
  char buf[256], buf2[256];
  int w = (percent * win->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, win->state.cols - 2, JUSTIFY_LEFT,
                     0, buf, sizeof(buf), false);

  mutt_window_move(win, 0, 0);

  if (mutt_color(MT_COLOR_PROGRESS) == 0)
  {
    mutt_window_addstr(win, buf2);
  }
  else
  {
    if (l < w)
    {
      /* The string fits within the colour bar */
      mutt_curses_set_color(MT_COLOR_PROGRESS);
      mutt_window_addstr(win, buf2);
      w -= l;
      while (w-- > 0)
      {
        mutt_window_addch(win, ' ');
      }
      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(win, buf2);
      buf2[off] = ch;
      mutt_curses_set_color(MT_COLOR_NORMAL);
      mutt_window_addstr(win, &buf2[off]);
    }
  }

  mutt_window_clrtoeol(win);
  mutt_refresh();
}

Here is the call graph for this function:

Here is the caller graph for this function:

choose_increment()

static size_t choose_increment ( enum ProgressType  type )

static

Choose the right increment given a ProgressType.

Parameters

type	ProgressType

Return values

Increment

value

Definition at line 128 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:

pos_needs_update()

static bool 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 143 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:

time_needs_update()

static bool 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 155 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:

progress_update()

void 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 175 of file progress.c.

{
  if (!progress || OptNoCurses)
    return;

  const uint64_t now = mutt_date_epoch_ms();

  const bool update =
      (pos == 0) /* always show the first update */ ||
      (pos_needs_update(progress, pos) && 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(progress->win, percent, "%s %s/%s (%d%%)", progress->msg,
                  posstr, progress->sizestr, percent);
    }
    else
    {
      if (percent > 0)
        message_bar(progress->win, percent, "%s %s (%d%%)", progress->msg, posstr, percent);
      else
        mutt_message("%s %s", progress->msg, posstr);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

progress_free()

void progress_free

(

struct Progress **

ptr

)

Free a Progress Bar.

Parameters

ptr	Progress Bar to free

Definition at line 228 of file progress.c.

{
  if (!ptr || !*ptr)
    return;

  mutt_clear_error();
  // struct Progress *progress = *ptr;

  FREE(ptr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

progress_new()

struct Progress* progress_new	(	const char *	msg,
		enum ProgressType	type,
		size_t	size
	)

Create a new Progress Bar.

Parameters

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

Return values

ptr	New Progress Bar

Definition at line 246 of file progress.c.

{
  if (OptNoCurses)
    return NULL;

  struct Progress *progress = mutt_mem_calloc(1, sizeof(struct Progress));

  /* Initialize Progress structure */
  progress->win = msgwin_get_window();
  mutt_str_copy(progress->msg, msg, sizeof(progress->msg));
  progress->size = size;
  progress->inc = 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 */
    progress_update(progress, 0, 0);
  }
  return progress;
}

Here is the call graph for this function:

Here is the caller graph for this function: