diff --git a/src/ShellProgressBar.Example/Examples/AutomaticEstimatedDurationExample.cs b/src/ShellProgressBar.Example/Examples/AutomaticEstimatedDurationExample.cs new file mode 100644 index 0000000..55ff739 --- /dev/null +++ b/src/ShellProgressBar.Example/Examples/AutomaticEstimatedDurationExample.cs @@ -0,0 +1,36 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading; +using System.Threading.Tasks; + +namespace ShellProgressBar.Example.Examples { + public class AutomaticEstimatedDurationExample : ExampleBase { + protected override Task StartAsync() + { + const int totalTicks = 10; + var options = new ProgressBarOptions + { + ProgressCharacter = '─', + AutomaticEstimatedDuration = true, + ShowEstimatedDuration = true + }; + using (var pbar = new ProgressBar(totalTicks, "It can attempt to automatically calculate the duration as well", options)) + { + var rand = new Random(); + + var initialMessage = pbar.Message; + for (var i = 0; i < totalTicks; i++) + { + pbar.Message = $"Start {i + 1} of {totalTicks}: {initialMessage}"; + Thread.Sleep(rand.Next(400,1200)); + + pbar.Tick( $"End {i + 1} of {totalTicks}: {initialMessage}"); + } + } + + return Task.CompletedTask; + } + } +} diff --git a/src/ShellProgressBar.Example/Examples/MessageBeforeAndAfterExample.cs b/src/ShellProgressBar.Example/Examples/MessageBeforeAndAfterExample.cs index 4280eef..eaaf98e 100644 --- a/src/ShellProgressBar.Example/Examples/MessageBeforeAndAfterExample.cs +++ b/src/ShellProgressBar.Example/Examples/MessageBeforeAndAfterExample.cs @@ -8,7 +8,7 @@ public class MessageBeforeAndAfterExample : ExampleBase protected override Task StartAsync() { Console.WriteLine("This should not be overwritten"); - const int totalTicks = 10; + int totalTicks = Console.WindowHeight; var options = new ProgressBarOptions { ForegroundColor = ConsoleColor.Yellow, @@ -18,9 +18,27 @@ protected override Task StartAsync() }; using (var pbar = new ProgressBar(totalTicks, "showing off styling", options)) { - TickToCompletion(pbar, totalTicks, sleep: 500, i => + TickToCompletion(pbar, totalTicks, sleep: 250, i => { - pbar.WriteErrorLine($"This should appear above:{i}"); + if (i % 5 == 0) + { + // Single line + pbar.WriteErrorLine($"[{i}] This{Environment.NewLine}[{i}] is{Environment.NewLine}[{i}] over{Environment.NewLine}[{i}] 4 lines"); + return; + } + if (i % 4 == 0) + { + // Single line + pbar.WriteErrorLine($"[{i}] This has{Environment.NewLine}[{i}] 2 lines."); + return; + } + if (i % 3 == 0) + { + // Single line + pbar.WriteErrorLine($"[{i}] This is a very long line {new string('.', Console.BufferWidth)} and should be split over 2 lines"); + return; + } + pbar.WriteErrorLine($"[{i}] This should appear above"); }); } diff --git a/src/ShellProgressBar.Example/Program.cs b/src/ShellProgressBar.Example/Program.cs index b947538..ed8b53b 100644 --- a/src/ShellProgressBar.Example/Program.cs +++ b/src/ShellProgressBar.Example/Program.cs @@ -1,6 +1,5 @@ using System; using System.Collections.Generic; -using System.Text; using System.Threading; using System.Threading.Tasks; using ShellProgressBar.Example.Examples; @@ -44,7 +43,8 @@ class Program new DeeplyNestedProgressBarTreeExample(), new EstimatedDurationExample(), new DownloadProgressExample(), - new AlternateFinishedColorExample() + new AlternateFinishedColorExample(), + new AutomaticEstimatedDurationExample() }; public static async Task Main(string[] args) @@ -66,6 +66,9 @@ private static async Task MainAsync(string[] args, CancellationToken token) case "test": await RunTestCases(token); return; + case "scrolltest": + await RunTestCases(token, Console.WindowHeight+5); + return; case "example": var nth = args.Length > 1 ? int.Parse(args[1]) : 0; await RunExample(nth, token); @@ -78,7 +81,9 @@ private static async Task MainAsync(string[] args, CancellationToken token) private static async Task RunExample(int nth, CancellationToken token) { - if (nth > Examples.Count - 1 || nth < 0) + if (nth < 0) + nth = Examples.Count + nth; + if (nth > Examples.Count - 1) { await Console.Error.WriteLineAsync($"There are only {Examples.Count} examples, {nth} is not valid"); } @@ -88,12 +93,16 @@ private static async Task RunExample(int nth, CancellationToken token) await example.Start(token); } - private static async Task RunTestCases(CancellationToken token) + private static async Task RunTestCases(CancellationToken token, int writeNumOfRowBefore = 0) { var i = 0; foreach (var example in TestCases) { if (i > 0) Console.Clear(); //not necessary but for demo/recording purposes. + + for (int r = 0; r< writeNumOfRowBefore; r++) + Console.WriteLine($"Writing output before test. Row {r+1}/{writeNumOfRowBefore}"); + await example.Start(token); i++; } diff --git a/src/ShellProgressBar.Example/ShellProgressBar.Example.csproj b/src/ShellProgressBar.Example/ShellProgressBar.Example.csproj index e4b427d..42a7fde 100644 --- a/src/ShellProgressBar.Example/ShellProgressBar.Example.csproj +++ b/src/ShellProgressBar.Example/ShellProgressBar.Example.csproj @@ -1,8 +1,7 @@  - Exe - net6.0 + net8.0 shellprogressbar-example ShellProgressBar.Example $(CurrentVersion) diff --git a/src/ShellProgressBar/ProgressBar.cs b/src/ShellProgressBar/ProgressBar.cs index a76e525..8a2bed4 100644 --- a/src/ShellProgressBar/ProgressBar.cs +++ b/src/ShellProgressBar/ProgressBar.cs @@ -2,7 +2,6 @@ using System.Collections.Concurrent; using System.Collections.Generic; using System.Linq; -using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Threading; using System.Threading.Tasks; @@ -15,11 +14,10 @@ public class ProgressBar : ProgressBarBase, IProgressBar private readonly ConsoleColor _originalColor; private readonly Func _writeMessageToConsole; - private readonly int _originalWindowTop; - private readonly int _originalWindowHeight; private readonly bool _startedRedirected; private int _originalCursorTop; private int _isDisposed; + private int _lastDrawBottomPos; private Timer _timer; private int _visibleDescendants = 0; @@ -41,8 +39,6 @@ public ProgressBar(int maxTicks, string message, ProgressBarOptions options = nu try { _originalCursorTop = Console.CursorTop; - _originalWindowTop = Console.WindowTop; - _originalWindowHeight = Console.WindowHeight + _originalWindowTop; _originalColor = Console.ForegroundColor; } catch @@ -56,7 +52,7 @@ public ProgressBar(int maxTicks, string message, ProgressBarOptions options = nu if (this.Options.EnableTaskBarProgress) TaskbarProgress.SetState(TaskbarProgress.TaskbarStates.Normal); - if (this.Options.DisplayTimeInRealTime) + if (this.Options.DisplayTimeInRealTime) _timer = new Timer((s) => OnTimerTick(), null, 500, 500); else //draw once _timer = new Timer((s) => @@ -102,18 +98,22 @@ protected override void Grow(ProgressBarHeight direction) private void EnsureMainProgressBarVisible(int extraBars = 0) { + var lastVisibleRow = Console.WindowHeight + Console.WindowTop; + var pbarHeight = this.Options.DenseProgressBar ? 1 : 2; - var neededPadding = Math.Min(_originalWindowHeight - pbarHeight, (1 + extraBars) * pbarHeight); - var difference = _originalWindowHeight - _originalCursorTop; - var write = difference <= neededPadding ? Math.Max(0, Math.Max(neededPadding, difference)) : 0; + var neededPadding = Math.Min(lastVisibleRow - pbarHeight, (1 + extraBars) * pbarHeight); + var difference = lastVisibleRow - _originalCursorTop; + var write = difference <= neededPadding ? Math.Min(Console.WindowHeight, Math.Max(0, Math.Max(neededPadding, difference))) : 0; + + if (write == 0) + return; var written = 0; for (; written < write; written++) Console.WriteLine(); - if (written == 0) return; - Console.CursorTop = _originalWindowHeight - (written); - _originalCursorTop = Console.CursorTop - 1; + Console.CursorTop = Console.WindowHeight + Console.WindowTop - write; + _originalCursorTop = Console.CursorTop -1; } private void GrowDrawingAreaBasedOnChildren() => EnsureMainProgressBarVisible(_visibleDescendants); @@ -181,8 +181,9 @@ private static void ProgressBarBottomHalf(double percentage, DateTime startDate, durationString += $" / {GetDurationString(estimatedDuration)}"; - var column1Width = Console.WindowWidth - durationString.Length - (depth * 2) + 2; - var column2Width = durationString.Length; + int durationStringWidth = durationString.GetColumnWidth(); + //assume: depth char column width + var column1Width = Console.WindowWidth - durationStringWidth - (depth * 2) + 2; if (!string.IsNullOrWhiteSpace(ProgressBarOptions.ProgressMessageEncodingName)) { @@ -194,17 +195,14 @@ private static void ProgressBarBottomHalf(double percentage, DateTime startDate, else DrawBottomHalfPrefix(indentation, depth); - var format = $"{{0, -{column1Width}}}{{1,{column2Width}}}"; - var percentageFormatedString = string.Format(percentageFormat, percentage); - var truncatedMessage = StringExtensions.Excerpt(percentageFormatedString + message, column1Width); - - if (disableBottomPercentage) + if (!disableBottomPercentage) { - truncatedMessage = StringExtensions.Excerpt(message, column1Width); + var percentageFormatedString = string.Format(percentageFormat, percentage); + message = percentageFormatedString + message; + } - var formatted = string.Format(format, truncatedMessage, durationString); - var m = formatted + new string(' ', Math.Max(0, maxCharacterWidth - formatted.Length)); + string m = StringExtensions.TurncatedRightPad(message, column1Width) + durationString; Console.Write(m); } @@ -345,7 +343,12 @@ void TopHalf() DrawChildren(this.Children, indentation, ref cursorTop, Options.PercentageFormat); - ResetToBottom(ref cursorTop); + if (Console.CursorTop < _lastDrawBottomPos) + { + // The bar shrunk. Need to clean the remaining rows + ClearLines(_lastDrawBottomPos - Console.CursorTop); + } + _lastDrawBottomPos = Console.CursorTop; Console.SetCursorPosition(0, _originalCursorTop); Console.ForegroundColor = _originalColor; @@ -355,35 +358,60 @@ void TopHalf() _timer = null; } + private static void ClearLines(int numOfLines) + { + // Use bufferwidth and not only the visible width. (currently identical on all platforms) + Console.Write(new string(' ', Console.BufferWidth * numOfLines)); + } + + private static string _resetString = ""; + private static void ClearCurrentLine() + { + if (_resetString.Length != Console.BufferWidth + 2) + { + // Use buffer width and not only the visible width. (currently identical on all platforms) + _resetString = $"\r{new string(' ', Console.BufferWidth)}\r"; + } + Console.Write(_resetString); + } + private void WriteConsoleLine(ConsoleOutLine m) { - var resetString = new string(' ', Console.WindowWidth); - Console.Write(resetString); - Console.Write("\r"); var foreground = Console.ForegroundColor; var background = Console.BackgroundColor; - var written = _writeMessageToConsole(m); + ClearCurrentLine(); + var moved = _writeMessageToConsole(m); Console.ForegroundColor = foreground; Console.BackgroundColor = background; - _originalCursorTop += written; + _originalCursorTop += moved; } private static int DefaultConsoleWrite(ConsoleOutLine line) { - if (line.Error) Console.Error.WriteLine(line.Line); - else Console.WriteLine(line.Line); - return 1; - } + var fromPos = Console.CursorTop; - private void ResetToBottom(ref int cursorTop) - { - var resetString = new string(' ', Console.WindowWidth); - var windowHeight = _originalWindowHeight; - if (cursorTop >= (windowHeight - 1)) return; - do + // First line was already cleared by WriteConsoleLine(). + // Would be cleaner to do it here, but would break backwards compatibility for those + // who implemented their own writer function. + bool isClearedLine = true; + foreach (var outLine in line.Line.SplitToConsoleLines()) { - Console.Write(resetString); - } while (++cursorTop < (windowHeight - 1)); + // Skip slower line clearing if we scrolled on last write + if (!isClearedLine) + ClearCurrentLine(); + + int lastCursorTop = Console.CursorTop; + if (line.Error) + Console.Error.WriteLine(outLine); + else + Console.WriteLine(outLine); + + // If the cursorTop is still on same position we are at the end of the buffer and scrolling happened. + isClearedLine = lastCursorTop == Console.CursorTop; + } + + // Return how many rows the cursor actually moved by. + return Console.CursorTop - fromPos; } private static void DrawChildren(IEnumerable children, Indentation[] indentation, @@ -392,12 +420,12 @@ private static void DrawChildren(IEnumerable children, Indenta var view = children.Where(c => !c.Collapse).Select((c, i) => new {c, i}).ToList(); if (!view.Any()) return; - var windowHeight = Console.WindowHeight; + var lastVisibleRow = Console.WindowHeight + Console.WindowTop; var lastChild = view.Max(t => t.i); foreach (var tuple in view) { - //Dont bother drawing children that would fall off the screen - if (cursorTop >= (windowHeight - 2)) + // Dont bother drawing children that would fall off the screen and don't want to scroll top out of view + if (cursorTop >= (lastVisibleRow - 2)) return; var child = tuple.c; @@ -500,7 +528,7 @@ public void Dispose() { var pbarHeight = this.Options.DenseProgressBar ? 1 : 2; var openDescendantsPadding = (_visibleDescendants * pbarHeight); - var newCursorTop = Math.Min(_originalWindowHeight, _originalCursorTop + pbarHeight + openDescendantsPadding); + var newCursorTop = Math.Min(Console.WindowHeight+Console.WindowTop, _originalCursorTop + pbarHeight + openDescendantsPadding); Console.CursorVisible = true; Console.SetCursorPosition(0, newCursorTop); } diff --git a/src/ShellProgressBar/ProgressBarBase.cs b/src/ShellProgressBar/ProgressBarBase.cs index c553edb..d64d787 100644 --- a/src/ShellProgressBar/ProgressBarBase.cs +++ b/src/ShellProgressBar/ProgressBarBase.cs @@ -78,9 +78,16 @@ public string Message public TimeSpan EstimatedDuration { - get => _estimatedDuration; + get + { + if (Options.AutomaticEstimatedDuration) + _estimatedDuration = TimeSpan.FromSeconds((DateTime.Now-_startDate).TotalSeconds/(CurrentTick> 0 ? CurrentTick : 1) * MaxTicks ); + return _estimatedDuration; + } set { + if (Options.AutomaticEstimatedDuration) + throw new ArgumentException("Cannot manually set EstimatedDuration when AutomaticEstimatedDuration is enabled"); _estimatedDuration = value; DisplayProgress(); } @@ -90,7 +97,7 @@ public double Percentage { get { - var percentage = Math.Max(0, Math.Min(100, (100.0 / this._maxTicks) * this._currentTick)); + var percentage = Math.Max(0, Math.Min(100, 100.0 * this._currentTick / this._maxTicks)); // Gracefully handle if the percentage is NaN due to division by 0 if (double.IsNaN(percentage) || percentage < 0) percentage = 100; return percentage; @@ -131,35 +138,29 @@ public IndeterminateChildProgressBar SpawnIndeterminate(string message, Progress public abstract void WriteErrorLine(string message); - public void Tick(string message = null) - { - Interlocked.Increment(ref _currentTick); - FinishTick(message); - } - - public void Tick(int newTickCount, string message = null) - { - Interlocked.Exchange(ref _currentTick, newTickCount); - FinishTick(message); - } - - public void Tick(TimeSpan estimatedDuration, string message = null) + public void Tick(string message = null) => _Tick(message:message); + public void Tick(int newTickCount, string message = null) => _Tick(newTickCount:newTickCount,message:message); + public void Tick(TimeSpan estimatedDuration, string message = null) => _Tick(estimatedDuration:estimatedDuration,message:message); + public void Tick(int newTickCount, TimeSpan estimatedDuration, string message = null) => _Tick(newTickCount:newTickCount,estimatedDuration:estimatedDuration,message:message); + /// + /// internal actual tick handler, if newTickCount is not specified it auto increments by one + /// + /// + /// + /// + private void _Tick(TimeSpan? estimatedDuration=null, string message = null,int? newTickCount=null) { - Interlocked.Increment(ref _currentTick); - _estimatedDuration = estimatedDuration; - - FinishTick(message); - } - public void Tick(int newTickCount, TimeSpan estimatedDuration, string message = null) - { - Interlocked.Exchange(ref _currentTick, newTickCount); - _estimatedDuration = estimatedDuration; - - FinishTick(message); - } + if (newTickCount == null) + Interlocked.Increment(ref _currentTick); + else + Interlocked.Exchange(ref _currentTick, newTickCount.Value); + if (estimatedDuration != null) + { + if (Options.AutomaticEstimatedDuration) + throw new ArgumentException("Cannot manually set EstimatedDuration when AutomaticEstimatedDuration is enabled"); + _estimatedDuration = estimatedDuration.Value; + } - private void FinishTick(string message) - { if (message != null) Interlocked.Exchange(ref _message, message); diff --git a/src/ShellProgressBar/ProgressBarOptions.cs b/src/ShellProgressBar/ProgressBarOptions.cs index 0a02c5d..992a996 100644 --- a/src/ShellProgressBar/ProgressBarOptions.cs +++ b/src/ShellProgressBar/ProgressBarOptions.cs @@ -81,6 +81,11 @@ public string MessageEncodingName /// public bool ShowEstimatedDuration { get; set; } + /// + /// Try to calculate the duration for you based on total ticks vs time spent on current ticks + /// + public bool AutomaticEstimatedDuration { get; set; } + /// /// Whether to show the percentage number /// diff --git a/src/ShellProgressBar/ShellProgressBar.csproj b/src/ShellProgressBar/ShellProgressBar.csproj index 0f78459..1720452 100644 --- a/src/ShellProgressBar/ShellProgressBar.csproj +++ b/src/ShellProgressBar/ShellProgressBar.csproj @@ -1,9 +1,8 @@  - ShellProgressBar ShellProgressBar - netstandard1.3;netstandard2.0;net461 + net8.0 true @@ -11,16 +10,5 @@ Cross platform simple and complex progressbars on the command line! Martijn Laarman MIT - https://github.com/Mpdreamz/shellprogressbar - https://raw.github.com/Mpdreamz/shellprogressbar/master/src/nuget-icon.png - console;shell;terminal;progress;progressbar - - - all - runtime; build; native; contentfiles; analyzers; buildtransitive - - - - diff --git a/src/ShellProgressBar/StringExtensions.cs b/src/ShellProgressBar/StringExtensions.cs index bc3071b..d4e9f61 100644 --- a/src/ShellProgressBar/StringExtensions.cs +++ b/src/ShellProgressBar/StringExtensions.cs @@ -1,16 +1,242 @@ -using System; +using System; using System.Collections.Generic; -using System.Text; +using System.Linq; namespace ShellProgressBar { - internal static class StringExtensions - { - public static string Excerpt(string phrase, int length = 60) + internal static class StringExtensions + { + public static string Excerpt(string phrase, int wantColumnWidth = 60) + { + if (string.IsNullOrEmpty(phrase)) + return phrase; + + int phraseColumnWidth = phrase.GetColumnWidth(); + if (phraseColumnWidth <= wantColumnWidth) + return phrase; + + while (phraseColumnWidth > wantColumnWidth - 3 && + phrase.Length > 0) + { + int len = phraseColumnWidth - (wantColumnWidth - 3); + //assume: max width of one char is 2. + phrase = phrase.Substring(0, phrase.Length - Math.Max(len / 2, 1)); + phraseColumnWidth = phrase.GetColumnWidth(); + } + + if (phraseColumnWidth == wantColumnWidth - 4) + return phrase + "... "; + + return phrase + "..."; + } + + public static string WhiteSpace(int n) + { + return new string(' ', n); + } + + //add ' ' to the right of `s` to `wantColumnWidth` width. + //turncated `s` if the column width is too long. + public static string TurncatedRightPad(string s, int wantColumnWidth) + { + int swidth = s.GetColumnWidth(); + if (swidth <= wantColumnWidth) + return s + WhiteSpace(wantColumnWidth - swidth); + s = Excerpt(s, wantColumnWidth); + return s + WhiteSpace(wantColumnWidth - s.GetColumnWidth()); + } + + #region GetColumnWidth + static uint[,] combining = new uint[,] { + { 0x0300, 0x036F }, { 0x0483, 0x0486 }, { 0x0488, 0x0489 }, + { 0x0591, 0x05BD }, { 0x05BF, 0x05BF }, { 0x05C1, 0x05C2 }, + { 0x05C4, 0x05C5 }, { 0x05C7, 0x05C7 }, { 0x0600, 0x0603 }, + { 0x0610, 0x0615 }, { 0x064B, 0x065E }, { 0x0670, 0x0670 }, + { 0x06D6, 0x06E4 }, { 0x06E7, 0x06E8 }, { 0x06EA, 0x06ED }, + { 0x070F, 0x070F }, { 0x0711, 0x0711 }, { 0x0730, 0x074A }, + { 0x07A6, 0x07B0 }, { 0x07EB, 0x07F3 }, { 0x0901, 0x0902 }, + { 0x093C, 0x093C }, { 0x0941, 0x0948 }, { 0x094D, 0x094D }, + { 0x0951, 0x0954 }, { 0x0962, 0x0963 }, { 0x0981, 0x0981 }, + { 0x09BC, 0x09BC }, { 0x09C1, 0x09C4 }, { 0x09CD, 0x09CD }, + { 0x09E2, 0x09E3 }, { 0x0A01, 0x0A02 }, { 0x0A3C, 0x0A3C }, + { 0x0A41, 0x0A42 }, { 0x0A47, 0x0A48 }, { 0x0A4B, 0x0A4D }, + { 0x0A70, 0x0A71 }, { 0x0A81, 0x0A82 }, { 0x0ABC, 0x0ABC }, + { 0x0AC1, 0x0AC5 }, { 0x0AC7, 0x0AC8 }, { 0x0ACD, 0x0ACD }, + { 0x0AE2, 0x0AE3 }, { 0x0B01, 0x0B01 }, { 0x0B3C, 0x0B3C }, + { 0x0B3F, 0x0B3F }, { 0x0B41, 0x0B43 }, { 0x0B4D, 0x0B4D }, + { 0x0B56, 0x0B56 }, { 0x0B82, 0x0B82 }, { 0x0BC0, 0x0BC0 }, + { 0x0BCD, 0x0BCD }, { 0x0C3E, 0x0C40 }, { 0x0C46, 0x0C48 }, + { 0x0C4A, 0x0C4D }, { 0x0C55, 0x0C56 }, { 0x0CBC, 0x0CBC }, + { 0x0CBF, 0x0CBF }, { 0x0CC6, 0x0CC6 }, { 0x0CCC, 0x0CCD }, + { 0x0CE2, 0x0CE3 }, { 0x0D41, 0x0D43 }, { 0x0D4D, 0x0D4D }, + { 0x0DCA, 0x0DCA }, { 0x0DD2, 0x0DD4 }, { 0x0DD6, 0x0DD6 }, + { 0x0E31, 0x0E31 }, { 0x0E34, 0x0E3A }, { 0x0E47, 0x0E4E }, + { 0x0EB1, 0x0EB1 }, { 0x0EB4, 0x0EB9 }, { 0x0EBB, 0x0EBC }, + { 0x0EC8, 0x0ECD }, { 0x0F18, 0x0F19 }, { 0x0F35, 0x0F35 }, + { 0x0F37, 0x0F37 }, { 0x0F39, 0x0F39 }, { 0x0F71, 0x0F7E }, + { 0x0F80, 0x0F84 }, { 0x0F86, 0x0F87 }, { 0x0F90, 0x0F97 }, + { 0x0F99, 0x0FBC }, { 0x0FC6, 0x0FC6 }, { 0x102D, 0x1030 }, + { 0x1032, 0x1032 }, { 0x1036, 0x1037 }, { 0x1039, 0x1039 }, + { 0x1058, 0x1059 }, { 0x1160, 0x11FF }, { 0x135F, 0x135F }, + { 0x1712, 0x1714 }, { 0x1732, 0x1734 }, { 0x1752, 0x1753 }, + { 0x1772, 0x1773 }, { 0x17B4, 0x17B5 }, { 0x17B7, 0x17BD }, + { 0x17C6, 0x17C6 }, { 0x17C9, 0x17D3 }, { 0x17DD, 0x17DD }, + { 0x180B, 0x180D }, { 0x18A9, 0x18A9 }, { 0x1920, 0x1922 }, + { 0x1927, 0x1928 }, { 0x1932, 0x1932 }, { 0x1939, 0x193B }, + { 0x1A17, 0x1A18 }, { 0x1B00, 0x1B03 }, { 0x1B34, 0x1B34 }, + { 0x1B36, 0x1B3A }, { 0x1B3C, 0x1B3C }, { 0x1B42, 0x1B42 }, + { 0x1B6B, 0x1B73 }, { 0x1DC0, 0x1DCA }, { 0x1DFE, 0x1DFF }, + { 0x200B, 0x200F }, { 0x202A, 0x202E }, { 0x2060, 0x2063 }, + { 0x206A, 0x206F }, { 0x20D0, 0x20EF }, { 0x2E9A, 0x2E9A }, + { 0x2EF4, 0x2EFF }, { 0x2FD6, 0x2FEF }, { 0x2FFC, 0x2FFF }, + { 0x31E4, 0x31EF }, { 0x321F, 0x321F }, { 0xA48D, 0xA48F }, + { 0xA806, 0xA806 }, { 0xA80B, 0xA80B }, { 0xA825, 0xA826 }, + { 0xFB1E, 0xFB1E }, { 0xFE00, 0xFE0F }, { 0xFE1A, 0xFE1F }, + { 0xFE20, 0xFE23 }, { 0xFE53, 0xFE53 }, { 0xFE67, 0xFE67 }, + { 0xFEFF, 0xFEFF }, { 0xFFF9, 0xFFFB }, + }; + + static uint[,] combiningWideChars = new uint[,] { + /* Hangul Jamo init. consonants - 0x1100, 0x11ff */ + /* Miscellaneous Technical - 0x2300, 0x23ff */ + /* Hangul Syllables - 0x11a8, 0x11c2 */ + /* CJK Compatibility Ideographs - f900, fad9 */ + /* Vertical forms - fe10, fe19 */ + /* CJK Compatibility Forms - fe30, fe4f */ + /* Fullwidth Forms - ff01, ffee */ + /* Alphabetic Presentation Forms - 0xFB00, 0xFb4f */ + /* Chess Symbols - 0x1FA00, 0x1FA0f */ + + { 0x1100, 0x115f }, { 0x231a, 0x231b }, { 0x2329, 0x232a }, + { 0x23e9, 0x23ec }, { 0x23f0, 0x23f0 }, { 0x23f3, 0x23f3 }, + { 0x25fd, 0x25fe }, { 0x2614, 0x2615 }, { 0x2648, 0x2653 }, + { 0x267f, 0x267f }, { 0x2693, 0x2693 }, { 0x26a1, 0x26a1 }, + { 0x26aa, 0x26ab }, { 0x26bd, 0x26be }, { 0x26c4, 0x26c5 }, + { 0x26ce, 0x26ce }, { 0x26d4, 0x26d4 }, { 0x26ea, 0x26ea }, + { 0x26f2, 0x26f3 }, { 0x26f5, 0x26f5 }, { 0x26fa, 0x26fa }, + { 0x26fd, 0x26fd }, { 0x2705, 0x2705 }, { 0x270a, 0x270b }, + { 0x2728, 0x2728 }, { 0x274c, 0x274c }, { 0x274e, 0x274e }, + { 0x2753, 0x2755 }, { 0x2757, 0x2757 }, { 0x2795, 0x2797 }, + { 0x27b0, 0x27b0 }, { 0x27bf, 0x27bf }, { 0x2b1b, 0x2b1c }, + { 0x2b50, 0x2b50 }, { 0x2b55, 0x2b55 }, { 0x2e80, 0x303e }, + { 0x3041, 0x3096 }, { 0x3099, 0x30ff }, { 0x3105, 0x312f }, + { 0x3131, 0x318e }, { 0x3190, 0x3247 }, { 0x3250, 0x4dbf }, + { 0x4e00, 0xa4c6 }, { 0xa960, 0xa97c }, { 0xac00 ,0xd7a3 }, + { 0xf900, 0xfaff }, { 0xfe10, 0xfe1f }, { 0xfe30 ,0xfe6b }, + { 0xff01, 0xff60 }, { 0xffe0, 0xffe6 }, { 0x10000, 0x10ffff } + }; + + static int bisearch(uint rune, uint[,] table, int max) + { + int min = 0; + int mid; + + if (rune < table[0, 0] || rune > table[max, 1]) + return 0; + while (max >= min) + { + mid = (min + max) / 2; + if (rune > table[mid, 1]) + min = mid + 1; + else if (rune < table[mid, 0]) + max = mid - 1; + else + return 1; + } + + return 0; + } + + /// + /// Check if the rune is a non-spacing character. + /// + /// The rune. + /// True if is a non-spacing character, false otherwise. + static bool IsNonSpacingChar(uint rune) + { + return bisearch(rune, combining, combining.GetLength(0) - 1) != 0; + } + + /// + /// Check if the rune is a wide character. + /// + /// The rune. + /// True if is a wide character, false otherwise. + static bool IsWideChar(uint rune) + { + return bisearch(rune, combiningWideChars, combiningWideChars.GetLength(0) - 1) != 0; + } + + /// + /// Number of column positions of a wide-character code. This is used to measure runes as displayed by text-based terminals. + /// + /// The width in columns, 0 if the argument is the null character, -1 if the value is not printable, otherwise the number of columns that the rune occupies. + /// The rune. + static int ColumnWidth(uint irune) + { + //uint irune = (uint)rune; + if (irune < 0x20 || (irune >= 0x7f && irune < 0xa0)) + return -1; + if (irune < 0x7f) + return 1; + /* binary search in table of non-spacing characters */ + if (bisearch(irune, combining, combining.GetLength(0) - 1) != 0) + return 0; + /* if we arrive here, ucs is not a combining or C0/C1 control character */ + return 1 + + (bisearch(irune, combiningWideChars, combiningWideChars.GetLength(0) - 1) != 0 ? 1 : 0); + } + + public static int GetColumnWidth(this string s) + { + if (s.All(char.IsAscii)) + return s.Length; + + int width = 0; +#if false + + foreach (var c in s.EnumerateRunes()) + { + int w = ColumnWidth((uint)c.Value); + width += w >= 0 ? w : 0; + } +#else + for (int i = 0; i < s.Length; i += char.IsSurrogatePair(s, i) ? 2 : 1) + { + uint codepoint = (uint)char.ConvertToUtf32(s, i); + int w = ColumnWidth(codepoint); + width += w; + } +#endif + return width; + } + #endregion + /// + /// Splits a string into it's indiviudal lines and then again splits these individual lines + /// into multiple lines if they exceed the width of the console. + /// + /// + /// + public static IEnumerable SplitToConsoleLines(this string str) { - if (string.IsNullOrEmpty(phrase) || phrase.Length < length) - return phrase; - return phrase.Substring(0, length - 3) + "..."; + int width = Console.BufferWidth; + var lines = str.Split(new string[] { Environment.NewLine }, StringSplitOptions.None); + + foreach (var line in lines) + { + if (line.Length > width) + { + for (int i = 0; i < line.Length; i += width) + { + yield return line.Substring(i, Math.Min(width, line.Length - i)); + } + } + else + { + yield return line; + } + } } - } + } + } diff --git a/test/ShellProgressBar.Tests/ShellProgressBar.Tests.csproj b/test/ShellProgressBar.Tests/ShellProgressBar.Tests.csproj index ae86f2a..7d2839c 100644 --- a/test/ShellProgressBar.Tests/ShellProgressBar.Tests.csproj +++ b/test/ShellProgressBar.Tests/ShellProgressBar.Tests.csproj @@ -1,21 +1,17 @@ - - - net6.0 - - false - - latest - - - - - - + + net8.0 + false + latest + + + + + runtime; build; native; contentfiles; analyzers; buildtransitive all - + runtime; build; native; contentfiles; analyzers; buildtransitive all