GNU Wget 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.
+(at your option) any later version.
GNU Wget is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
struct progress_implementation {
char *name;
void *(*create) (long, long);
- void (*update) (void *, long);
- void (*finish) (void *);
+ void (*update) (void *, long, long);
+ void (*finish) (void *, long);
void (*set_params) (const char *);
};
/* Necessary forward declarations. */
static void *dot_create PARAMS ((long, long));
-static void dot_update PARAMS ((void *, long));
-static void dot_finish PARAMS ((void *));
+static void dot_update PARAMS ((void *, long, long));
+static void dot_finish PARAMS ((void *, long));
static void dot_set_params PARAMS ((const char *));
static void *bar_create PARAMS ((long, long));
-static void bar_update PARAMS ((void *, long));
-static void bar_finish PARAMS ((void *));
+static void bar_update PARAMS ((void *, long, long));
+static void bar_finish PARAMS ((void *, long));
static void bar_set_params PARAMS ((const char *));
static struct progress_implementation implementations[] = {
};
static struct progress_implementation *current_impl;
-/* Default progress implementation should be something that works
+/* Progress implementation used by default. Can be overriden in
+ wgetrc or by the fallback one. */
+
+#define DEFAULT_PROGRESS_IMPLEMENTATION "bar"
+
+/* Fallnback progress implementation should be something that works
under all display types. If you put something other than "dot"
here, remember that bar_set_params tries to switch to this if we're
not running on a TTY. So changing this to "bar" could cause
infloop. */
-#define DEFAULT_PROGRESS_IMPLEMENTATION "dot"
+#define FALLBACK_PROGRESS_IMPLEMENTATION "dot"
/* Return non-zero if NAME names a valid progress bar implementation.
The characters after the first : will be ignored. */
return current_impl->create (initial, total);
}
-/* Inform the progress gauge of newly received bytes. */
+/* Inform the progress gauge of newly received bytes. DLTIME is the
+ time in milliseconds since the beginning of the download. */
void
-progress_update (void *progress, long howmuch)
+progress_update (void *progress, long howmuch, long dltime)
{
- current_impl->update (progress, howmuch);
+ current_impl->update (progress, howmuch, dltime);
}
/* Tell the progress gauge to clean up. Calling this will free the
PROGRESS object, the further use of which is not allowed. */
void
-progress_finish (void *progress)
+progress_finish (void *progress, long dltime)
{
- current_impl->finish (progress);
+ current_impl->finish (progress, dltime);
}
\f
/* Dot-printing. */
int rows; /* number of rows printed so far */
int dots; /* number of dots printed in this row */
-
- struct wget_timer *timer; /* timer used to measure per-row
- download rates. */
long last_timer_value;
};
dp->initial_length = initial;
dp->total_length = total;
- dp->timer = wtimer_new ();
if (dp->initial_length)
{
/* Align the [ skipping ... ] line with the dots. To do
that, insert the number of spaces equal to the number of
digits in the skipped amount in K. */
- logprintf (LOG_VERBOSE, "\n%*s%s",
- 2 + skipped_k_len, "", _("[ skipping %dK ]"));
+ logprintf (LOG_VERBOSE, _("\n%*s[ skipping %dK ]"),
+ 2 + skipped_k_len, "", skipped_k);
}
logprintf (LOG_VERBOSE, "\n%5ldK", skipped / 1024);
}
static void
-print_download_speed (struct dot_progress *dp, long bytes)
+print_download_speed (struct dot_progress *dp, long bytes, long dltime)
{
- long timer_value = wtimer_elapsed (dp->timer);
logprintf (LOG_VERBOSE, " %s",
- retr_rate (bytes, timer_value - dp->last_timer_value, 1));
- dp->last_timer_value = timer_value;
+ retr_rate (bytes, dltime - dp->last_timer_value, 1));
+ dp->last_timer_value = dltime;
}
/* Dot-progress backend for progress_update. */
static void
-dot_update (void *progress, long howmuch)
+dot_update (void *progress, long howmuch, long dltime)
{
struct dot_progress *dp = progress;
int dot_bytes = opt.dot_bytes;
++dp->dots;
if (dp->dots >= opt.dots_in_line)
{
+ long row_qty = row_bytes;
+ if (dp->rows == dp->initial_length / row_bytes)
+ row_qty -= dp->initial_length % row_bytes;
+
++dp->rows;
dp->dots = 0;
if (dp->total_length)
print_percentage (dp->rows * row_bytes, dp->total_length);
-
- print_download_speed (dp,
- row_bytes - (dp->initial_length % row_bytes));
+ print_download_speed (dp, row_qty, dltime);
}
}
/* Dot-progress backend for progress_finish. */
static void
-dot_finish (void *progress)
+dot_finish (void *progress, long dltime)
{
struct dot_progress *dp = progress;
int dot_bytes = opt.dot_bytes;
log_set_flush (0);
+ if (dp->dots == 0)
+ logprintf (LOG_VERBOSE, "\n%5ldK", dp->rows * row_bytes / 1024);
for (i = dp->dots; i < opt.dots_in_line; i++)
{
if (i % opt.dot_spacing == 0)
dp->total_length);
}
- print_download_speed (dp, dp->dots * dot_bytes
- + dp->accumulated
- - dp->initial_length % row_bytes);
- logputs (LOG_VERBOSE, "\n\n");
+ {
+ long row_qty = dp->dots * dot_bytes + dp->accumulated;
+ if (dp->rows == dp->initial_length / row_bytes)
+ row_qty -= dp->initial_length % row_bytes;
+ print_download_speed (dp, row_qty, dltime);
+ }
+ logputs (LOG_VERBOSE, "\n\n");
log_set_flush (0);
- wtimer_delete (dp->timer);
xfree (dp);
}
/* This function interprets the progress "parameters". For example,
- if Wget is invoked with --progress=bar:mega, it will set the
+ if Wget is invoked with --progress=dot:mega, it will set the
"dot-style" to "mega". Valid styles are default, binary, mega, and
giga. */
static void
dot_set_params (const char *params)
{
+ if (!params || !*params)
+ params = opt.dot_style;
+
if (!params)
return;
download finishes */
long count; /* bytes downloaded so far */
- struct wget_timer *timer; /* timer used to measure the download
- rates. */
long last_update; /* time of the last screen update. */
int width; /* screen width at the time the
bp->initial_length = initial;
bp->total_length = total;
- bp->timer = wtimer_new ();
bp->width = screen_width;
bp->buffer = xmalloc (bp->width + 1);
}
static void
-bar_update (void *progress, long howmuch)
+bar_update (void *progress, long howmuch, long dltime)
{
struct bar_progress *bp = progress;
int force_update = 0;
- long dltime = wtimer_elapsed (bp->timer);
bp->count += howmuch;
if (bp->total_length > 0
}
static void
-bar_finish (void *progress)
+bar_finish (void *progress, long dltime)
{
struct bar_progress *bp = progress;
- long elapsed = wtimer_elapsed (bp->timer);
- if (elapsed == 0)
+ if (dltime == 0)
/* If the download was faster than the granularity of the timer,
fake some output so that we don't get the ugly "----.--" rate
at the download finish. */
- elapsed = 1;
+ dltime = 1;
- create_image (bp, elapsed);
+ create_image (bp, dltime);
display_image (bp->buffer);
logputs (LOG_VERBOSE, "\n\n");
xfree (bp->buffer);
- wtimer_delete (bp->timer);
xfree (bp);
}
/* We're not printing to a TTY, so revert to the fallback
display. #### We're recursively calling
set_progress_implementation here, which is slightly kludgy.
- It would be nicer if that function could resolve this problem
- itself. */
- set_progress_implementation (NULL);
+ It would be nicer if we provided that function a return value
+ indicating a failure of some sort. */
+ set_progress_implementation (FALLBACK_PROGRESS_IMPLEMENTATION);
return;
}
projects / wget / blobdiff