/* Download progress.
- Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007,
- 2008 Free Software Foundation, Inc.
+ Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+ 2010, 2011 Free Software Foundation, Inc.
This file is part of GNU Wget.
#include <stdlib.h>
#include <string.h>
#include <assert.h>
-#ifdef HAVE_UNISTD_H
-# include <unistd.h>
-#endif
+#include <unistd.h>
#include <signal.h>
#ifdef HAVE_WCHAR_H
# include <wchar.h>
bool interactive;
void *(*create) (wgint, wgint);
void (*update) (void *, wgint, double);
+ void (*draw) (void *);
void (*finish) (void *, double);
void (*set_params) (const char *);
};
static void *dot_create (wgint, wgint);
static void dot_update (void *, wgint, double);
static void dot_finish (void *, double);
+static void dot_draw (void *);
static void dot_set_params (const char *);
static void *bar_create (wgint, wgint);
static void bar_update (void *, wgint, double);
+static void bar_draw (void *);
static void bar_finish (void *, double);
static void bar_set_params (const char *);
static struct progress_implementation implementations[] = {
- { "dot", 0, dot_create, dot_update, dot_finish, dot_set_params },
- { "bar", 1, bar_create, bar_update, bar_finish, bar_set_params }
+ { "dot", 0, dot_create, dot_update, dot_draw, dot_finish, dot_set_params },
+ { "bar", 1, bar_create, bar_update, bar_draw, bar_finish, bar_set_params }
};
static struct progress_implementation *current_impl;
static int current_impl_locked;
bool
valid_progress_implementation_p (const char *name)
{
- int i;
+ size_t i;
struct progress_implementation *pi = implementations;
char *colon = strchr (name, ':');
- int namelen = colon ? colon - name : strlen (name);
+ size_t namelen = colon ? (size_t) (colon - name) : strlen (name);
for (i = 0; i < countof (implementations); i++, pi++)
if (!strncmp (pi->name, name, namelen))
void
set_progress_implementation (const char *name)
{
- int i, namelen;
+ size_t i, namelen;
struct progress_implementation *pi = implementations;
const char *colon;
name = DEFAULT_PROGRESS_IMPLEMENTATION;
colon = strchr (name, ':');
- namelen = colon ? colon - name : strlen (name);
+ namelen = colon ? (size_t) (colon - name) : strlen (name);
for (i = 0; i < countof (implementations); i++, pi++)
if (!strncmp (pi->name, name, namelen))
progress_update (void *progress, wgint howmuch, double dltime)
{
current_impl->update (progress, howmuch, dltime);
+ current_impl->draw (progress);
}
/* Tell the progress gauge to clean up. Calling this will free the
int accumulated; /* number of bytes accumulated after
the last printed dot */
+ double dltime; /* download time so far */
int rows; /* number of rows printed so far */
int dots; /* number of dots printed in this row */
static void
dot_update (void *progress, wgint howmuch, double dltime)
+{
+ struct dot_progress *dp = progress;
+ dp->accumulated += howmuch;
+ dp->dltime = dltime;
+}
+
+static void
+dot_draw (void *progress)
{
struct dot_progress *dp = progress;
int dot_bytes = opt.dot_bytes;
log_set_flush (false);
- dp->accumulated += howmuch;
for (; dp->accumulated >= dot_bytes; dp->accumulated -= dot_bytes)
{
if (dp->dots == 0)
++dp->rows;
dp->dots = 0;
- print_row_stats (dp, dltime, false);
+ print_row_stats (dp, dp->dltime, false);
}
}
}
else
fprintf (stderr,
- _("Invalid dot style specification `%s'; leaving unchanged.\n"),
- params);
+ _("Invalid dot style specification %s; leaving unchanged.\n"),
+ quote (params));
}
\f
/* "Thermometer" (bar) progress. */
measured since the beginning of
download. */
+ double dltime; /* download time so far */
int width; /* screen width we're using at the
time the progress gauge was
created. this is different from
bar_update (void *progress, wgint howmuch, double dltime)
{
struct bar_progress *bp = progress;
- bool force_screen_update = false;
+ bp->dltime = dltime;
bp->count += howmuch;
if (bp->total_length > 0
&& bp->count + bp->initial_length > bp->total_length)
bp->total_length = bp->initial_length + bp->count;
update_speed_ring (bp, howmuch, dltime);
+}
+
+static void
+bar_draw (void *progress)
+{
+ bool force_screen_update = false;
+ struct bar_progress *bp = progress;
/* If SIGWINCH (the window size change signal) been received,
determine the new screen size and update the screen. */
received_sigwinch = 0;
}
- if (dltime - bp->last_screen_update < REFRESH_INTERVAL && !force_screen_update)
+ if (bp->dltime - bp->last_screen_update < REFRESH_INTERVAL && !force_screen_update)
/* Don't update more often than five times per second. */
return;
- create_image (bp, dltime, false);
+ create_image (bp, bp->dltime, false);
display_image (bp->buffer);
- bp->last_screen_update = dltime;
+ bp->last_screen_update = bp->dltime;
}
static void
if (bp->stalled)
{
bp->stalled = false;
- /* "recent_age" includes the the entired stalled period, which
+ /* "recent_age" includes the entired stalled period, which
could be very long. Don't update the speed ring with that
value because the current bandwidth would start too small.
Start with an arbitrary (but more reasonable) time value and
}
#if USE_NLS_PROGRESS_BAR
-int
+static int
count_cols (const char *mbs)
{
wchar_t wc;
# define count_cols(mbs) ((int)(strlen(mbs)))
#endif
-const char *
+static const char *
get_eta (int *bcd)
{
- /* Translation note: "ETA" is English-centric, but this must
+ /* TRANSLATORS: "ETA" is English-centric, but this must
be short, ideally 3 chars. Abbreviate if necessary. */
static const char eta_str[] = N_(" eta %s");
static const char *eta_trans;
struct bar_progress_hist *hist = &bp->hist;
/* The progress bar should look like this:
- xx% [=======> ] nn,nnn 12.34K/s eta 36m 51s
+ xx% [=======> ] nn,nnn 12.34KB/s eta 36m 51s
Calculate the geometry. The idea is to assign as much room as
possible to the progress bar. The other idea is to never let
"xx% " or "100%" - percentage - 4 chars
"[]" - progress bar decorations - 2 chars
" nnn,nnn,nnn" - downloaded bytes - 12 chars or very rarely more
- " 12.5K/s" - download rate - 8 chars
+ " 12.5KB/s" - download rate - 9 chars
" eta 36m 51s" - ETA - 14 chars
"=====>..." - progress bar - the rest
*p++ = ' ';
}
- /* " 12.52K/s" */
+ /* " 12.52Kb/s or 12.52KB/s" */
if (hist->total_time > 0 && hist->total_bytes)
{
- static const char *short_units[] = { "B/s", "K/s", "M/s", "G/s" };
+ static const char *short_units[] = { "B/s", "KB/s", "MB/s", "GB/s" };
+ static const char *short_units_bits[] = { "b/s", "Kb/s", "Mb/s", "Gb/s" };
int units = 0;
/* Calculate the download speed using the history ring and
recent data that hasn't made it to the ring yet. */
double dltime = hist->total_time + (dl_total_time - bp->recent_start);
double dlspeed = calc_rate (dlquant, dltime, &units);
sprintf (p, " %4.*f%s", dlspeed >= 99.95 ? 0 : dlspeed >= 9.995 ? 1 : 2,
- dlspeed, short_units[units]);
+ dlspeed, !opt.report_bps ? short_units[units] : short_units_bits[units]);
move_to_end (p);
}
else
else if (secs < 48 * 3600)
sprintf (buf, "%dh%s%dm", secs / 3600, space, (secs / 60) % 60);
else if (secs < 100 * 86400)
- sprintf (buf, "%dd%s%dh", secs / 86400, space, (secs / 3600) % 60);
+ sprintf (buf, "%dd%s%dh", secs / 86400, space, (secs / 3600) % 24);
else
/* even (2^31-1)/86400 doesn't overflow BUF. */
sprintf (buf, "%dd", secs / 86400);