Merge pull request #540 from tig/progress_invoke_fix

Expanded Progress demo

Terminal.Gui/Core.cs

@@ -2442,6 +2442,10 @@ namespace Terminal.Gui {
 		/// </summary>
 		public static void Shutdown ()
 		{
+			// Shutdown is the bookend for Init. As such it needs to clean up all resources
+			// Init created. Apps that do any threading will need to code defensively for this.
+			// e.g. see Issue #537
+			// TODO: Some of this state is actually related to Begin/End (not Init/Shutdown) and should be moved to `RunState` (#520)
 			foreach (var t in toplevels) {
 				t.Running = false;
 			}
@@ -2449,6 +2453,8 @@ namespace Terminal.Gui {
 			Current = null;
 			CurrentView = null;
 			Top = null;
+
+			// 
 			MainLoop = null;
 
 			Driver.End ();

Terminal.Gui/Views/TextField.cs

@@ -36,8 +36,10 @@ namespace Terminal.Gui {
 		///   Changed event, raised when the text has clicked.
 		/// </summary>
 		/// <remarks>
-		///   Client code can hook up to this event, it is
-		///   raised when the text in the entry changes.
+		///   This event is raised when the <see cref="Text"/> changes. 
+		/// </remarks>
+		/// <remarks>
+		///   The passed <see cref="EventArgs"/> is a <see cref="ustring"/> containing the old value. 
 		/// </remarks>
 		public event EventHandler<ustring> Changed;
 

UICatalog/Scenarios/Progress.cs

@@ -1,6 +1,8 @@
-using System;
+using NStack;
+using System;
 using System.Threading;
 using Terminal.Gui;
+using System.Linq;
 
 namespace UICatalog {
 	// 
@@ -8,102 +10,235 @@ namespace UICatalog {
 	//
 	[ScenarioMetadata (Name: "Progress", Description: "Shows off ProgressBar and Threading")]
 	[ScenarioCategory ("Controls")]
+	[ScenarioCategory ("MainLoop")]
 	[ScenarioCategory ("Threading")]
 	class Progress : Scenario {
 
-		private ProgressBar _activityProgressBar;
-		private ProgressBar _pulseProgressBar;
-		private Timer _timer;
-		private object _timeoutToken = null;
+		class ProgressDemo : FrameView {
+			const int _verticalSpace = 1;
 
+			internal FrameView LeftFrame { get; private set; }
+			internal TextField Speed { get; private set; }
+			internal ProgressBar ActivityProgressBar { get; private set; }
+			internal ProgressBar PulseProgressBar { get; private set; }
+			internal Action StartBtnClick;
+			internal Action StopBtnClick;
+			internal Action PulseBtnClick;
+			private Label _startedLabel;
+			internal bool Started { 
+				get { 
+					return _startedLabel.Text == "Started";
+				} 
+				private set {
+					_startedLabel.Text = value ? "Started" : "Stopped";
+				} 
+			}
+
+			internal ProgressDemo (ustring title) : base (title)
+			{
+				ColorScheme = Colors.Dialog;
+
+				LeftFrame = new FrameView ("Settings") {
+					X = 0,
+					Y = 0,
+					Height = Dim.Percent (100) + 1, // BUGBUG: This +1 should not be needed
+					Width = Dim.Percent (25)
+				};
+				var lbl = new Label (1, 1, "Tick every (ms):");
+				LeftFrame.Add (lbl);
+				Speed = new TextField ("") {
+					X = Pos.Right (lbl) + 1,
+					Y = Pos.Y (lbl),
+					Width = 7,
+				};
+				LeftFrame.Add (Speed);
+
+				Add (LeftFrame);
+
+				var startButton = new Button ("Start Timer") {
+					X = Pos.Right (LeftFrame) + 1,
+					Y = 0,
+					Clicked = () => Start()
+				};
+				var pulseButton = new Button ("Pulse") {
+					X = Pos.Right (startButton) + 2,
+					Y = Pos.Y (startButton),
+					Clicked = () => PulseBtnClick.Invoke ()
+				};
+				var stopbutton = new Button ("Stop Timer") {
+					X = Pos.Right (pulseButton) + 2,
+					Y = Pos.Top (pulseButton),
+					Clicked = () => Stop()
+				};
+
+				Add (startButton);
+				Add (pulseButton);
+				Add (stopbutton);
+
+				ActivityProgressBar = new ProgressBar () {
+					X = Pos.Right (LeftFrame) + 1,
+					Y = Pos.Bottom (startButton) + 1,
+					Width = Dim.Fill (),
+					Height = 1,
+					Fraction = 0.25F,
+					ColorScheme = Colors.Error
+				};
+				Add (ActivityProgressBar);
+
+				PulseProgressBar = new ProgressBar () {
+					X = Pos.Right (LeftFrame) + 1,
+					Y = Pos.Bottom (ActivityProgressBar) + 1,
+					Width = Dim.Fill (),
+					Height = 1,
+					ColorScheme = Colors.Error
+				};
+				Add (PulseProgressBar);
+
+				_startedLabel = new Label ("Stopped") {
+					X = Pos.Right (LeftFrame) + 1,
+					Y = Pos.Bottom (PulseProgressBar),
+				};
+				Add (_startedLabel);
+
+
+				// Set height to height of controls + spacing + frame
+				Height = 2 + _verticalSpace + Dim.Height (startButton) + _verticalSpace + Dim.Height (ActivityProgressBar) + _verticalSpace + Dim.Height (PulseProgressBar) + _verticalSpace;
+			}
+
+			internal void Start ()
+			{
+				Started = true;
+				StartBtnClick?.Invoke ();
+			}
+
+			internal void Stop ()
+			{
+				Started = false;
+				StopBtnClick?.Invoke ();
+			}
+
+			internal void Pulse ()
+			{
+				if (PulseBtnClick != null) {
+					PulseBtnClick?.Invoke ();
+
+				} else {
+					if (ActivityProgressBar.Fraction + 0.01F >= 1) {
+						ActivityProgressBar.Fraction = 0F;
+					} else {
+						ActivityProgressBar.Fraction += 0.01F;
+					}
+					PulseProgressBar.Pulse ();
+				}
+			}
+		}
+
+		private Timer _systemTimer = null;
+		private uint _systemTimerTick = 1000; // ms
+		private object _mainLoopTimeout = null;
+		private uint _mainLooopTimeoutTick = 1000; // ms
 		public override void Setup ()
 		{
-			var pulseButton = new Button ("Pulse") {
+			// Demo #1 - Use System.Timer (and threading)
+			var systemTimerDemo = new ProgressDemo ("System.Timer (threads)") {
+				X = 0,
+				Y = 0,
+				Width = Dim.Percent (100),
+			};
+			systemTimerDemo.StartBtnClick = () => {
+				_systemTimer?.Dispose ();
+				_systemTimer = null;
+
+				systemTimerDemo.ActivityProgressBar.Fraction = 0F;
+				systemTimerDemo.PulseProgressBar.Fraction = 0F;
+
+				_systemTimer = new Timer ((o) => {
+					// Note the check for Mainloop being valid. System.Timers can run after they are Disposed.
+					// This code must be defensive for that. 
+					Application.MainLoop?.Invoke (() => systemTimerDemo.Pulse ());
+				}, null, 0, _systemTimerTick);
+			};
+
+			systemTimerDemo.StopBtnClick = () => {
+				_systemTimer?.Dispose ();
+				_systemTimer = null;
+
+				systemTimerDemo.ActivityProgressBar.Fraction = 1F;
+				systemTimerDemo.PulseProgressBar.Fraction = 1F;
+			};
+			systemTimerDemo.Speed.Text = $"{_systemTimerTick}";
+			systemTimerDemo.Speed.Changed += (sender, a) => {
+				uint result;
+				if (uint.TryParse (systemTimerDemo.Speed.Text.ToString(), out result)) {
+					_systemTimerTick = result;
+					System.Diagnostics.Debug.WriteLine ($"{_systemTimerTick}");
+					if (systemTimerDemo.Started) {
+						systemTimerDemo.Start ();
+					}
+
+				} else {
+					System.Diagnostics.Debug.WriteLine ("bad entry");
+				}
+			};
+			Win.Add (systemTimerDemo);
+
+			// Demo #2 - Use Application.MainLoop.AddTimeout (no threads)
+			var mainLoopTimeoutDemo = new ProgressDemo ("Application.AddTimer (no threads)") {
+				X = 0,
+				Y = Pos.Bottom (systemTimerDemo),
+				Width = Dim.Percent (100),
+			};
+			mainLoopTimeoutDemo.StartBtnClick = () => {
+				mainLoopTimeoutDemo.StopBtnClick ();
+
+				mainLoopTimeoutDemo.ActivityProgressBar.Fraction = 0F;
+				mainLoopTimeoutDemo.PulseProgressBar.Fraction = 0F;
+
+				_mainLoopTimeout = Application.MainLoop.AddTimeout (TimeSpan.FromMilliseconds (_mainLooopTimeoutTick), (loop) => {
+					mainLoopTimeoutDemo.Pulse ();
+					return true;
+				});
+			};
+			mainLoopTimeoutDemo.StopBtnClick = () => {
+				if (_mainLoopTimeout != null) {
+					Application.MainLoop.RemoveTimeout (_mainLoopTimeout);
+					_mainLoopTimeout = null;
+				}
+
+				mainLoopTimeoutDemo.ActivityProgressBar.Fraction = 1F;
+				mainLoopTimeoutDemo.PulseProgressBar.Fraction = 1F;
+			};
+
+			mainLoopTimeoutDemo.Speed.Text = $"{_mainLooopTimeoutTick}";
+			mainLoopTimeoutDemo.Speed.Changed += (sender, a) => {
+				uint result;
+				if (uint.TryParse (mainLoopTimeoutDemo.Speed.Text.ToString (), out result)) {
+					_mainLooopTimeoutTick = result;
+					if (mainLoopTimeoutDemo.Started) {
+						mainLoopTimeoutDemo.Start ();
+					}
+				}
+			};
+			Win.Add (mainLoopTimeoutDemo);
+
+			var startBoth = new Button ("Start Both") {
 				X = Pos.Center (),
-				Y = Pos.Center () - 3,
-				Clicked = () => Pulse ()
+				Y = Pos.AnchorEnd () - 1,
 			};
-
-			var startButton = new Button ("Start Timer") {
-				Y = Pos.Y(pulseButton),
-				Clicked = () => Start ()
+			startBoth.Clicked = () => {
+				systemTimerDemo.Start ();
+				mainLoopTimeoutDemo.Start ();
 			};
+			Win.Add (startBoth);
 
-			var stopbutton = new Button ("Stop Timer") {
-				Y = Pos.Y (pulseButton),
-				Clicked = () => Stop()
-			};
-
-			// Center three buttons with 5 spaces between them
-			// TODO: Use Pos.Width instead of (Right-Left) when implemented (#502)
-			startButton.X = Pos.Left (pulseButton) - (Pos.Right (startButton) - Pos.Left (startButton)) - 5;
-			stopbutton.X = Pos.Right (pulseButton) + 5;
-
-			Win.Add (startButton);
-			Win.Add (pulseButton);
-			Win.Add (stopbutton);
-
-			_activityProgressBar = new ProgressBar () {
-				X = Pos.Center (),
-				// BUGBUG: If you remove the +1 below the control is drawn at top?!?!
-				Y = Pos.Center ()+1,
-				Width = 30,
-				Fraction = 0.25F,
-			};
-			Win.Add (_activityProgressBar);
-
-			_pulseProgressBar = new ProgressBar () {
-				X = Pos.Center (),
-				// BUGBUG: If you remove the +1 below the control is drawn at top?!?!
-				Y = Pos.Center () + 3,
-				Width = 30,
-			};
-			Win.Add (_pulseProgressBar);
 		}
 
 		protected override void Dispose (bool disposing)
 		{
-			_timer?.Dispose ();
-			_timer = null;
-			if (_timeoutToken != null) {
-				Application.MainLoop.RemoveTimeout (_timeoutToken);
+			foreach (var v in Win.Subviews.OfType<ProgressDemo>()) {
+				v?.StopBtnClick ();
 			}
 			base.Dispose (disposing);
 		}
-
-		private void Pulse ()
-		{
-			if (_activityProgressBar.Fraction + 0.01F >= 1) {
-				_activityProgressBar.Fraction = 0F;
-			} else {
-				_activityProgressBar.Fraction += 0.01F;
-			}
-			_pulseProgressBar.Pulse ();
-		}
-
-		private void Start ()
-		{
-			_timer?.Dispose ();
-			_timer = null;
-
-			_activityProgressBar.Fraction = 0F;
-			_pulseProgressBar.Fraction = 0F;
-
-			_timer = new Timer ((o) => {
-				Application.MainLoop.Invoke (() => Pulse ());
-			}, null, 0, 20);
-		}
-
-		private void Stop ()
-		{
-			_timer?.Dispose ();
-			_timer = null;
-			if (_timeoutToken != null) {
-				Application.MainLoop.RemoveTimeout (_timeoutToken);
-			}
-
-			_activityProgressBar.Fraction = 1F;
-			_pulseProgressBar.Fraction = 1F;
-		}
 	}
 }