spectre.console/src/Spectre.Console/Widgets/ProgressBar.cs

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using Spectre.Console.Rendering;

namespace Spectre.Console;

internal sealed class ProgressBar : Renderable, IHasCulture
{
    private const int PULSESIZE = 20;
    private const int PULSESPEED = 15;

    public double Value { get; set; }
    public double MaxValue { get; set; } = 100;

    public int? Width { get; set; }
    public bool ShowRemaining { get; set; } = true;
    public char UnicodeBar { get; set; } = '━';
    public char AsciiBar { get; set; } = '-';
    public bool ShowValue { get; set; }
    public bool IsIndeterminate { get; set; }
    public CultureInfo? Culture { get; set; }

    public Style CompletedStyle { get; set; } = new Style(foreground: Color.Yellow);
    public Style FinishedStyle { get; set; } = new Style(foreground: Color.Green);
    public Style RemainingStyle { get; set; } = new Style(foreground: Color.Grey);
    public Style IndeterminateStyle { get; set; } = DefaultPulseStyle;

    internal static Style DefaultPulseStyle { get; } = new Style(foreground: Color.DodgerBlue1, background: Color.Grey23);

    protected override Measurement Measure(RenderContext context, int maxWidth)
    {
        var width = Math.Min(Width ?? maxWidth, maxWidth);
        return new Measurement(4, width);
    }

    protected override IEnumerable<Segment> Render(RenderContext context, int maxWidth)
    {
        var width = Math.Min(Width ?? maxWidth, maxWidth);
        var completedBarCount = Math.Min(MaxValue, Math.Max(0, Value));
        var isCompleted = completedBarCount >= MaxValue;

        if (IsIndeterminate && !isCompleted)
        {
            foreach (var segment in RenderIndeterminate(context, width))
            {
                yield return segment;
            }

            yield break;
        }

        var bar = !context.Unicode ? AsciiBar : UnicodeBar;
        var style = isCompleted ? FinishedStyle : CompletedStyle;
        var barCount = Math.Max(0, (int)(width * (completedBarCount / MaxValue)));

        // Show value?
        var value = completedBarCount.ToString(Culture ?? CultureInfo.InvariantCulture);
        if (ShowValue)
        {
            barCount = barCount - value.Length - 1;
            barCount = Math.Max(0, barCount);
        }

        if (barCount < 0)
        {
            yield break;
        }

        yield return new Segment(new string(bar, barCount), style);

        if (ShowValue)
        {
            yield return barCount == 0
                ? new Segment(value, style)
                : new Segment(" " + value, style);
        }

        // More space available?
        if (barCount < width)
        {
            var diff = width - barCount;
            if (ShowValue)
            {
                diff = diff - value.Length - 1;
                if (diff <= 0)
                {
                    yield break;
                }
            }

            var legacy = context.ColorSystem == ColorSystem.NoColors || context.ColorSystem == ColorSystem.Legacy;
            var remainingToken = ShowRemaining && !legacy ? bar : ' ';
            yield return new Segment(new string(remainingToken, diff), RemainingStyle);
        }
    }

    private IEnumerable<Segment> RenderIndeterminate(RenderContext context, int width)
    {
        var bar = context.Unicode ? UnicodeBar.ToString() : AsciiBar.ToString();
        var style = IndeterminateStyle ?? DefaultPulseStyle;

        IEnumerable<Segment> GetPulseSegments()
        {
            // For 1-bit and 3-bit colors, fall back to
            // a simpler versions with only two colors.
            if (context.ColorSystem == ColorSystem.NoColors ||
                context.ColorSystem == ColorSystem.Legacy)
            {
                // First half of the pulse
                var segments = Enumerable.Repeat(new Segment(bar, new Style(style.Foreground)), PULSESIZE / 2);

                // Second half of the pulse
                var legacy = context.ColorSystem == ColorSystem.NoColors || context.ColorSystem == ColorSystem.Legacy;
                var bar2 = legacy ? " " : bar;
                segments = segments.Concat(Enumerable.Repeat(new Segment(bar2, new Style(style.Background)), PULSESIZE - (PULSESIZE / 2)));

                foreach (var segment in segments)
                {
                    yield return segment;
                }

                yield break;
            }

            for (var index = 0; index < PULSESIZE; index++)
            {
                var position = index / (float)PULSESIZE;
                var fade = 0.5f + ((float)Math.Cos(position * Math.PI * 2) / 2.0f);
                var color = style.Foreground.Blend(style.Background, fade);

                yield return new Segment(bar, new Style(foreground: color));
            }
        }

        // Get the pulse segments
        var pulseSegments = GetPulseSegments();
        pulseSegments = pulseSegments.Repeat((width / PULSESIZE) + 2);

        // Repeat the pulse segments
        var currentTime = (DateTime.Now - DateTime.Today).TotalSeconds;
        var offset = (int)(currentTime * PULSESPEED) % PULSESIZE;

        return pulseSegments.Skip(offset).Take(width);
    }
}