+2014-05-24 Darshit Shah <darnir@gmail.com>
+
+ * wget.texi: Document noscroll parameter to progress=bar
+
2014-05-01 Darshit Shah <darnir@gmail.com>
* wget.texi: Add documentation for --show-progress
the retrieval by printing dots on the screen, each dot representing a
fixed amount of downloaded data.
-When using the dotted retrieval, you may also set the @dfn{style} by
+The progress @var{type} can also take one or more parameters. The parameters
+vary based on the @var{type} selected. Parameters to @var{type} are passed by
+appending them to the type sperated by a colon (:) like this:
+@samp{--progress=@var{type}:@var{parameter1}:@var{parameter2}}.
+
+When using the dotted retrieval, you may set the @dfn{style} by
specifying the type as @samp{dot:@var{style}}. Different styles assign
different meaning to one dot. With the @code{default} style each dot
represents 1K, there are ten dots in a cluster and 50 dots in a line.
style---each dot represents 1M retrieved, there are eight dots in a
cluster, and 32 dots on each line (so each line contains 32M).
+With @samp{--progress=bar}, there are currently two possible parameters,
+@var{force} and @var{noscroll}.
+
+When the output is not a TTY, the progress bar always falls back to ``dot'',
+even if @samp{--progress=bar} was passed to Wget during invokation. This
+behaviour can be overridden and the ``bar'' output forced by using the ``force''
+parameter as @samp{--progress=bar:force}.
+
+By default, the @samp{bar} style progress bar scroll the name of the file from
+left to right for the file being downloaded if the filename exceeds the maximum
+length allotted for its display. In certain cases, such as with
+@samp{--progress=bar:force}, one may not want the scrolling filename in the
+progress bar. By passing the ``noscroll'' parameter, Wget can be forced to
+display as much of the filename as possible without scrolling through it.
+
Note that you can set the default style using the @code{progress}
command in @file{.wgetrc}. That setting may be overridden from the
-command line. The exception is that, when the output is not a TTY, the
-``dot'' progress will be favored over ``bar''. To force the bar output,
-use @samp{--progress=bar:force}.
+command line. For example, to force the bar output without scrolling,
+use @samp{--progress=bar:force:noscroll}.
@item --show-progress
Force wget to display the progress bar in any verbosity.
+2014-05-20 Darshit Shah <darnir@gmail.com>
+
+ * utils.c (human_readable): Add new parameters, acc and decimals for the
+ function. acc decides the number under which decimal values are shown for a
+ certain value, while decimals decides the number of decimal digits displayed
+ * utils.h (human_readable): Update declartion of the function
+ * ftp.c (print_length): Update call to human_readable
+ * http.c (gethttp): Same
+ * init.c (defaults): Enable scrolling filenames by default
+ * main.c (main): Update call to human_readable
+ * options.h (options): Add new option noscroll
+ * progress.c (create_image): Update the look of the progress bar. Human
+ readable download size by default and add support for noscroll.
+ (dot_set_params, bar_set_params): Change paramter to char * since strtok
+ needs to modify the string.
+ (bar_set_params): Add support for noscroll parameter to bar.
+
+
2014-05-03 Tim Ruehsen <tim.ruehsen@gmx.de>
* ftp-ls.c (ftp_parse_vms_ls): Explicitly typecast strlen's output
{
logprintf (LOG_VERBOSE, _("Length: %s"), number_to_static_string (size));
if (size >= 1024)
- logprintf (LOG_VERBOSE, " (%s)", human_readable (size));
+ logprintf (LOG_VERBOSE, " (%s)", human_readable (size, 10, 1));
if (start > 0)
{
if (size - start >= 1024)
logprintf (LOG_VERBOSE, _(", %s (%s) remaining"),
number_to_static_string (size - start),
- human_readable (size - start));
+ human_readable (size - start, 10, 1));
else
logprintf (LOG_VERBOSE, _(", %s remaining"),
number_to_static_string (size - start));
logputs (LOG_VERBOSE, number_to_static_string (contlen + contrange));
if (contlen + contrange >= 1024)
logprintf (LOG_VERBOSE, " (%s)",
- human_readable (contlen + contrange));
+ human_readable (contlen + contrange, 10, 1));
if (contrange)
{
if (contlen >= 1024)
logprintf (LOG_VERBOSE, _(", %s (%s) remaining"),
number_to_static_string (contlen),
- human_readable (contlen));
+ human_readable (contlen, 10, 1));
else
logprintf (LOG_VERBOSE, _(", %s remaining"),
number_to_static_string (contlen));
/* Use a negative value to mark the absence of --start-pos option */
opt.start_pos = -1;
opt.show_progress = false;
+ opt.noscroll = false;
}
\f
/* Return the user's home directory (strdup-ed), or NULL if none is
datetime_str (time (NULL)),
wall_time,
numurls,
- human_readable (total_downloaded_bytes),
+ human_readable (total_downloaded_bytes, 10, 1),
download_time,
retr_rate (total_downloaded_bytes, total_download_time));
xfree (wall_time);
if (opt.quota && total_downloaded_bytes > opt.quota)
logprintf (LOG_NOTQUIET,
_("Download quota of %s EXCEEDED!\n"),
- human_readable (opt.quota));
+ human_readable (opt.quota, 10, 1));
}
if (opt.cookies_output)
char *base_href;
char *progress_type; /* progress indicator type. */
bool show_progress; /* Show only the progress bar */
+ bool noscroll; /* Don't scroll the filename in the progressbar */
char *proxy_user; /*oli*/
char *proxy_passwd;
void (*update) (void *, wgint, double);
void (*draw) (void *);
void (*finish) (void *, double);
- void (*set_params) (const char *);
+ void (*set_params) (char *);
};
/* Necessary forward declarations. */
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 dot_set_params (char *);
static void *bar_create (const char *, 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 void bar_set_params (char *);
static struct progress_implementation implementations[] = {
{ "dot", 0, dot_create, dot_update, dot_draw, dot_finish, dot_set_params },
{
size_t i, namelen;
struct progress_implementation *pi = implementations;
- const char *colon;
+ char *colon;
if (!name)
name = DEFAULT_PROGRESS_IMPLEMENTATION;
giga. */
static void
-dot_set_params (const char *params)
+dot_set_params (char *params)
{
if (!params || !*params)
params = opt.dot_style;
int orig_filename_len = strlen (bp->f_download);
/* The progress bar should look like this:
- file xx% [=======> ] nn,nnn 12.34KB/s eta 36m 51s
+ file xx% [=======> ] nnn.nnK 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
It would be especially bad for the progress bar to be resized
randomly.
- "file " - Downloaded filename - MAX MAX_FILENAME_LEN chars + 1
+ "file " - Downloaded filename - MAX_FILENAME_LEN chars + 1
"xx% " or "100%" - percentage - 4 chars
"[]" - progress bar decorations - 2 chars
- " nnn,nnn,nnn" - downloaded bytes - 12 chars or very rarely more
- " 12.5KB/s" - download rate - 9 chars
+ " nnn.nnK" - downloaded bytes - 7 chars + 1
+ " 12.5KB/s" - download rate - 8 chars + 1
" eta 36m 51s" - ETA - 14 chars
"=====>..." - progress bar - the rest
*/
- int dlbytes_size = 1 + MAX (size_grouped_len, 11);
- int progress_size = bp->width - (MAX_FILENAME_LEN + 1 + 4 + 2 + dlbytes_size + 8 + 14);
+
+#define PROGRESS_FILENAME_LEN MAX_FILENAME_LEN + 1
+#define PROGRESS_PERCENT_LEN 4
+#define PROGRESS_DECORAT_LEN 2
+#define PROGRESS_FILESIZE_LEN 7 + 1
+#define PROGRESS_DWNLOAD_RATE 8 + 1
+#define PROGRESS_ETA_LEN 14
+
+ int progress_size = bp->width - (PROGRESS_FILENAME_LEN + PROGRESS_PERCENT_LEN +
+ PROGRESS_DECORAT_LEN + PROGRESS_FILESIZE_LEN +
+ PROGRESS_DWNLOAD_RATE + PROGRESS_ETA_LEN);
/* The difference between the number of bytes used,
and the number of columns used. */
{
int offset;
- if (orig_filename_len > MAX_FILENAME_LEN)
+ if (((orig_filename_len > MAX_FILENAME_LEN) && !opt.noscroll) && !done)
offset = ((int) bp->tick) % (orig_filename_len - MAX_FILENAME_LEN);
else
offset = 0;
}
++bp->tick;
- /* " 234,567,890" */
- sprintf (p, " %s", size_grouped);
+ /* " 234.56M" */
+ const char * down_size = human_readable (size, 1000, 2);
+ int cols_diff = 7 - count_cols (down_size);
+ while (cols_diff > 0)
+ {
+ *p++=' ';
+ cols_diff--;
+ }
+ sprintf (p, " %s", down_size);
move_to_end (p);
- /* Pad with spaces to 11 chars for the size_grouped field;
+ /* Pad with spaces to 7 chars for the size_grouped field;
* couldn't use the field width specifier in sprintf, because
* it counts in bytes, not characters. */
- for (size_grouped_pad = 11 - size_grouped_len;
+ for (size_grouped_pad = PROGRESS_FILESIZE_LEN - 7;
size_grouped_pad > 0;
--size_grouped_pad)
{
/* " 12.52Kb/s or 12.52KB/s" */
if (hist->total_time > 0 && hist->total_bytes)
{
- 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" };
+ 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. */
wgint dlquant = hist->total_bytes + bp->recent_bytes;
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,
+ sprintf (p, " %4.*f%s", dlspeed >= 99.95 ? 0 : dlspeed >= 9.995 ? 1 : 2,
dlspeed, !opt.report_bps ? short_units[units] : short_units_bits[units]);
move_to_end (p);
}
else
- APPEND_LITERAL ("--.-KB/s");
+ APPEND_LITERAL (" --.-KB/s");
if (!done)
{
}
static void
-bar_set_params (const char *params)
+bar_set_params (char *params)
{
char *term = getenv ("TERM");
- if (params
- && 0 == strcmp (params, "force"))
- current_impl_locked = 1;
+ if (params)
+ {
+ char *param = strtok (params, ":");
+ do
+ {
+ if (0 == strcmp (param, "force"))
+ current_impl_locked = 1;
+ else if (0 == strcmp (param, "noscroll"))
+ opt.noscroll = true;
+ } while ((param = strtok (NULL, ":")) != NULL);
+ }
if ((opt.lfilename
#ifdef HAVE_ISATTY
some detail. */
char *
-human_readable (HR_NUMTYPE n)
+human_readable (HR_NUMTYPE n, const int acc, const int decimals)
{
/* These suffixes are compatible with those of GNU `ls -lh'. */
static char powers[] =
if ((n / 1024) < 1024 || i == countof (powers) - 1)
{
double val = n / 1024.0;
- /* Print values smaller than 10 with one decimal digits, and
- others without any decimals. */
+ /* Print values smaller than the accuracy level (acc) with (decimal)
+ * decimal digits, and others without any decimals. */
snprintf (buf, sizeof (buf), "%.*f%c",
- val < 10 ? 1 : 0, val, powers[i]);
+ val < acc ? decimals : 0, val, powers[i]);
return buf;
}
n /= 1024;
#else
# define HR_NUMTYPE double
#endif
-char *human_readable (HR_NUMTYPE);
+char *human_readable (HR_NUMTYPE, const int, const int);
int numdigit (wgint);