moved Dialogs to Windows

Terminal.Gui/Core/Application.cs

@@ -0,0 +1,679 @@
+//
+// Core.cs: The core engine for gui.cs
+//
+// Authors:
+//   Miguel de Icaza (miguel@gnome.org)
+//
+// Pending:
+//   - Check for NeedDisplay on the hierarchy and repaint
+//   - Layout support
+//   - "Colors" type or "Attributes" type?
+//   - What to surface as "BackgroundCOlor" when clearing a window, an attribute or colors?
+//
+// Optimziations
+//   - Add rendering limitation to the exposed area
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Threading;
+using System.Linq;
+using NStack;
+using System.ComponentModel;
+
+namespace Terminal.Gui {
+
+	/// <summary>
+	/// The application driver for Terminal.Gui.
+	/// </summary>
+	/// <remarks>
+	///   <para>
+	///     You can hook up to the Iteration event to have your method
+	///     invoked on each iteration of the mainloop.
+	///   </para>
+	///   <para>
+	///     Creates a mainloop to process input events, handle timers and
+	///     other sources of data.   It is accessible via the MainLoop property.
+	///   </para>
+	///   <para>
+	///     When invoked sets the SynchronizationContext to one that is tied
+	///     to the mainloop, allowing user code to use async/await.
+	///   </para>
+	/// </remarks>
+	public static class Application {
+		/// <summary>
+		/// The current <see cref="ConsoleDriver"/> in use.
+		/// </summary>
+		public static ConsoleDriver Driver;
+
+		/// <summary>
+		/// The <see cref="Toplevel"/> object used for the application on startup (<seealso cref="Application.Top"/>)
+		/// </summary>
+		/// <value>The top.</value>
+		public static Toplevel Top { get; private set; }
+
+		/// <summary>
+		/// The current <see cref="Toplevel"/> object. This is updated when <see cref="Application.Run()"/> enters and leaves to point to the current <see cref="Toplevel"/> .
+		/// </summary>
+		/// <value>The current.</value>
+		public static Toplevel Current { get; private set; }
+
+		/// <summary>
+		/// TThe current <see cref="View"/> object being redrawn.
+		/// </summary>
+		/// /// <value>The current.</value>
+		public static View CurrentView { get; set; }
+
+		/// <summary>
+		/// The <see cref="MainLoop"/>  driver for the applicaiton
+		/// </summary>
+		/// <value>The main loop.</value>
+		public static MainLoop MainLoop { get; private set; }
+
+		static Stack<Toplevel> toplevels = new Stack<Toplevel> ();
+
+		/// <summary>
+		///   This event is raised on each iteration of the <see cref="MainLoop"/> 
+		/// </summary>
+		/// <remarks>
+		///   See also <see cref="Timeout"/>
+		/// </remarks>
+		public static event EventHandler Iteration;
+
+		/// <summary>
+		/// Returns a rectangle that is centered in the screen for the provided size.
+		/// </summary>
+		/// <returns>The centered rect.</returns>
+		/// <param name="size">Size for the rectangle.</param>
+		public static Rect MakeCenteredRect (Size size)
+		{
+			return new Rect (new Point ((Driver.Cols - size.Width) / 2, (Driver.Rows - size.Height) / 2), size);
+		}
+
+		//
+		// provides the sync context set while executing code in Terminal.Gui, to let
+		// users use async/await on their code
+		//
+		class MainLoopSyncContext : SynchronizationContext {
+			MainLoop mainLoop;
+
+			public MainLoopSyncContext (MainLoop mainLoop)
+			{
+				this.mainLoop = mainLoop;
+			}
+
+			public override SynchronizationContext CreateCopy ()
+			{
+				return new MainLoopSyncContext (MainLoop);
+			}
+
+			public override void Post (SendOrPostCallback d, object state)
+			{
+				mainLoop.AddIdle (() => {
+					d (state);
+					return false;
+				});
+				//mainLoop.Driver.Wakeup ();
+			}
+
+			public override void Send (SendOrPostCallback d, object state)
+			{
+				mainLoop.Invoke (() => {
+					d (state);
+				});
+			}
+		}
+
+		/// <summary>
+		/// If set, it forces the use of the System.Console-based driver.
+		/// </summary>
+		public static bool UseSystemConsole;
+
+		/// <summary>
+		/// Initializes a new instance of <see cref="Terminal.Gui"/> Application. 
+		/// </summary>
+		/// <remarks>
+		/// <para>
+		/// Call this method once per instance (or after <see cref="Shutdown"/> has been called).
+		/// </para>
+		/// <para>
+		/// Loads the right <see cref="ConsoleDriver"/> for the platform.
+		/// </para>
+		/// <para>
+		/// Creates a <see cref="Toplevel"/> and assigns it to <see cref="Top"/> and <see cref="CurrentView"/>
+		/// </para>
+		/// </remarks>
+		public static void Init () => Init (() => Toplevel.Create ());
+
+		internal static bool _initialized = false;
+
+		/// <summary>
+		/// Initializes the Terminal.Gui application
+		/// </summary>
+		static void Init (Func<Toplevel> topLevelFactory)
+		{
+			if (_initialized) return;
+
+			if (Driver == null) {
+				var p = Environment.OSVersion.Platform;
+				IMainLoopDriver mainLoopDriver;
+
+				if (UseSystemConsole) {
+					mainLoopDriver = new NetMainLoop ();
+					Driver = new NetDriver ();
+				} else if (p == PlatformID.Win32NT || p == PlatformID.Win32S || p == PlatformID.Win32Windows) {
+					var windowsDriver = new WindowsDriver ();
+					mainLoopDriver = windowsDriver;
+					Driver = windowsDriver;
+				} else {
+					mainLoopDriver = new UnixMainLoop ();
+					Driver = new CursesDriver ();
+				}
+				Driver.Init (TerminalResized);
+				MainLoop = new MainLoop (mainLoopDriver);
+				SynchronizationContext.SetSynchronizationContext (new MainLoopSyncContext (MainLoop));
+			}
+			Top = topLevelFactory ();
+			Current = Top;
+			CurrentView = Top;
+			_initialized = true;
+		}
+
+		/// <summary>
+		/// Captures the execution state for the provided <see cref="Toplevel"/>  view.
+		/// </summary>
+		public class RunState : IDisposable {
+			internal bool closeDriver = true;
+
+			internal RunState (Toplevel view)
+			{
+				Toplevel = view;
+			}
+			internal Toplevel Toplevel;
+
+			/// <summary>
+			/// Releases alTop = l resource used by the <see cref="Application.RunState"/> object.
+			/// </summary>
+			/// <remarks>Call <see cref="Dispose()"/> when you are finished using the <see cref="Application.RunState"/>. The
+			/// <see cref="Dispose()"/> method leaves the <see cref="Application.RunState"/> in an unusable state. After
+			/// calling <see cref="Dispose()"/>, you must release all references to the
+			/// <see cref="Application.RunState"/> so the garbage collector can reclaim the memory that the
+			/// <see cref="Application.RunState"/> was occupying.</remarks>
+			public void Dispose ()
+			{
+				Dispose (closeDriver);
+				GC.SuppressFinalize (this);
+			}
+
+			/// <summary>
+			/// Dispose the specified disposing.
+			/// </summary>
+			/// <returns>The dispose.</returns>
+			/// <param name="disposing">If set to <c>true</c> disposing.</param>
+			protected virtual void Dispose (bool disposing)
+			{
+				if (Toplevel != null) {
+					End (Toplevel, disposing);
+					Toplevel = null;
+				}
+			}
+		}
+
+		static void ProcessKeyEvent (KeyEvent ke)
+		{
+
+			var chain = toplevels.ToList ();
+			foreach (var topLevel in chain) {
+				if (topLevel.ProcessHotKey (ke))
+					return;
+				if (topLevel.Modal)
+					break;
+			}
+
+			foreach (var topLevel in chain) {
+				if (topLevel.ProcessKey (ke))
+					return;
+				if (topLevel.Modal)
+					break;
+			}
+
+			foreach (var topLevel in chain) {
+				// Process the key normally
+				if (topLevel.ProcessColdKey (ke))
+					return;
+				if (topLevel.Modal)
+					break;
+			}
+		}
+
+		static void ProcessKeyDownEvent (KeyEvent ke)
+		{
+			var chain = toplevels.ToList ();
+			foreach (var topLevel in chain) {
+				if (topLevel.OnKeyDown (ke))
+					return;
+				if (topLevel.Modal)
+					break;
+			}
+		}
+
+
+		static void ProcessKeyUpEvent (KeyEvent ke)
+		{
+			var chain = toplevels.ToList ();
+			foreach (var topLevel in chain) {
+				if (topLevel.OnKeyUp (ke))
+					return;
+				if (topLevel.Modal)
+					break;
+			}
+		}
+
+		static View FindDeepestView (View start, int x, int y, out int resx, out int resy)
+		{
+			var startFrame = start.Frame;
+
+			if (!startFrame.Contains (x, y)) {
+				resx = 0;
+				resy = 0;
+				return null;
+			}
+
+			if (start.InternalSubviews != null) {
+				int count = start.InternalSubviews.Count;
+				if (count > 0) {
+					var rx = x - startFrame.X;
+					var ry = y - startFrame.Y;
+					for (int i = count - 1; i >= 0; i--) {
+						View v = start.InternalSubviews [i];
+						if (v.Frame.Contains (rx, ry)) {
+							var deep = FindDeepestView (v, rx, ry, out resx, out resy);
+							if (deep == null)
+								return v;
+							return deep;
+						}
+					}
+				}
+			}
+			resx = x - startFrame.X;
+			resy = y - startFrame.Y;
+			return start;
+		}
+
+		internal static View mouseGrabView;
+
+		/// <summary>
+		/// Grabs the mouse, forcing all mouse events to be routed to the specified view until UngrabMouse is called.
+		/// </summary>
+		/// <returns>The grab.</returns>
+		/// <param name="view">View that will receive all mouse events until UngrabMouse is invoked.</param>
+		public static void GrabMouse (View view)
+		{
+			if (view == null)
+				return;
+			mouseGrabView = view;
+			Driver.UncookMouse ();
+		}
+
+		/// <summary>
+		/// Releases the mouse grab, so mouse events will be routed to the view on which the mouse is.
+		/// </summary>
+		public static void UngrabMouse ()
+		{
+			mouseGrabView = null;
+			Driver.CookMouse ();
+		}
+
+		/// <summary>
+		/// Merely a debugging aid to see the raw mouse events
+		/// </summary>
+		public static Action<MouseEvent> RootMouseEvent;
+
+		internal static View wantContinuousButtonPressedView;
+		static View lastMouseOwnerView;
+
+		static void ProcessMouseEvent (MouseEvent me)
+		{
+			var view = FindDeepestView (Current, me.X, me.Y, out int rx, out int ry);
+
+			if (view != null && view.WantContinuousButtonPressed)
+				wantContinuousButtonPressedView = view;
+			else
+				wantContinuousButtonPressedView = null;
+
+			RootMouseEvent?.Invoke (me);
+			if (mouseGrabView != null) {
+				var newxy = mouseGrabView.ScreenToView (me.X, me.Y);
+				var nme = new MouseEvent () {
+					X = newxy.X,
+					Y = newxy.Y,
+					Flags = me.Flags,
+					OfX = me.X - newxy.X,
+					OfY = me.Y - newxy.Y,
+					View = view
+				};
+				if (OutsideFrame (new Point (nme.X, nme.Y), mouseGrabView.Frame))
+					lastMouseOwnerView.OnMouseLeave (me);
+				if (mouseGrabView != null) {
+					mouseGrabView.MouseEvent (nme);
+					return;
+				}
+			}
+
+			if (view != null) {
+				var nme = new MouseEvent () {
+					X = rx,
+					Y = ry,
+					Flags = me.Flags,
+					OfX = rx,
+					OfY = ry,
+					View = view
+				};
+
+				if (lastMouseOwnerView == null) {
+					lastMouseOwnerView = view;
+					view.OnMouseEnter (nme);
+				} else if (lastMouseOwnerView != view) {
+					lastMouseOwnerView.OnMouseLeave (nme);
+					view.OnMouseEnter (nme);
+					lastMouseOwnerView = view;
+				}
+
+				if (!view.WantMousePositionReports && me.Flags == MouseFlags.ReportMousePosition)
+					return;
+
+				if (view.WantContinuousButtonPressed)
+					wantContinuousButtonPressedView = view;
+				else
+					wantContinuousButtonPressedView = null;
+
+				// Should we bubbled up the event, if it is not handled?
+				view.MouseEvent (nme);
+			}
+		}
+
+		static bool OutsideFrame (Point p, Rect r)
+		{
+			return p.X < 0 || p.X > r.Width - 1 || p.Y < 0 || p.Y > r.Height - 1;
+		}
+
+		/// <summary>
+		/// This event is fired once when the application is first loaded. The dimensions of the
+		/// terminal are provided.
+		/// </summary>
+		public static event EventHandler<ResizedEventArgs> Loaded;
+
+		/// <summary>
+		/// Building block API: Prepares the provided <see cref="Toplevel"/>  for execution.
+		/// </summary>
+		/// <returns>The runstate handle that needs to be passed to the <see cref="End(RunState, bool)"/> method upon completion.</returns>
+		/// <param name="toplevel">Toplevel to prepare execution for.</param>
+		/// <remarks>
+		///  This method prepares the provided toplevel for running with the focus,
+		///  it adds this to the list of toplevels, sets up the mainloop to process the
+		///  event, lays out the subviews, focuses the first element, and draws the
+		///  toplevel in the screen. This is usually followed by executing
+		///  the <see cref="RunLoop"/> method, and then the <see cref="End(RunState, bool)"/> method upon termination which will
+		///   undo these changes.
+		/// </remarks>
+		public static RunState Begin (Toplevel toplevel)
+		{
+			if (toplevel == null)
+				throw new ArgumentNullException (nameof (toplevel));
+			var rs = new RunState (toplevel);
+
+			Init ();
+			if (toplevel is ISupportInitializeNotification initializableNotification &&
+			    !initializableNotification.IsInitialized) {
+				initializableNotification.BeginInit ();
+				initializableNotification.EndInit ();
+			} else if (toplevel is ISupportInitialize initializable) {
+				initializable.BeginInit ();
+				initializable.EndInit ();
+			}
+			toplevels.Push (toplevel);
+			Current = toplevel;
+			Driver.PrepareToRun (MainLoop, ProcessKeyEvent, ProcessKeyDownEvent, ProcessKeyUpEvent, ProcessMouseEvent);
+			if (toplevel.LayoutStyle == LayoutStyle.Computed)
+				toplevel.RelativeLayout (new Rect (0, 0, Driver.Cols, Driver.Rows));
+			toplevel.LayoutSubviews ();
+			Loaded?.Invoke (null, new ResizedEventArgs () { Rows = Driver.Rows, Cols = Driver.Cols });
+			toplevel.WillPresent ();
+			Redraw (toplevel);
+			toplevel.PositionCursor ();
+			Driver.Refresh ();
+
+			return rs;
+		}
+
+		/// <summary>
+		/// Building block API: completes the execution of a <see cref="Toplevel"/>  that was started with <see cref="Begin(Toplevel)"/> .
+		/// </summary>
+		/// <param name="runState">The runstate returned by the <see cref="Begin(Toplevel)"/> method.</param>
+		/// <param name="closeDriver"><c>true</c>Closes the application.<c>false</c>Closes the toplevels only.</param>
+		public static void End (RunState runState, bool closeDriver = true)
+		{
+			if (runState == null)
+				throw new ArgumentNullException (nameof (runState));
+
+			runState.closeDriver = closeDriver;
+			runState.Dispose ();
+		}
+
+		/// <summary>
+		/// Shutdown an application initialized with <see cref="Init()"/>
+		/// </summary>
+		/// /// <param name="closeDriver"><c>true</c>Closes the application.<c>false</c>Closes toplevels only.</param>
+		public static void Shutdown (bool closeDriver = true)
+		{
+			// 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;
+			}
+			toplevels.Clear ();
+			Current = null;
+			CurrentView = null;
+			Top = null;
+
+			// Closes the application if it's true.
+			if (closeDriver) {
+				MainLoop = null;
+				Driver.End ();
+			}
+
+			_initialized = false;
+		}
+
+		static void Redraw (View view)
+		{
+			Application.CurrentView = view;
+
+			view.Redraw (view.Bounds);
+			Driver.Refresh ();
+		}
+
+		static void Refresh (View view)
+		{
+			view.Redraw (view.Bounds);
+			Driver.Refresh ();
+		}
+
+		/// <summary>
+		/// Triggers a refresh of the entire display.
+		/// </summary>
+		public static void Refresh ()
+		{
+			Driver.UpdateScreen ();
+			View last = null;
+			foreach (var v in toplevels.Reverse ()) {
+				v.SetNeedsDisplay ();
+				v.Redraw (v.Bounds);
+				last = v;
+			}
+			last?.PositionCursor ();
+			Driver.Refresh ();
+		}
+
+		internal static void End (View view, bool closeDriver = true)
+		{
+			if (toplevels.Peek () != view)
+				throw new ArgumentException ("The view that you end with must be balanced");
+			toplevels.Pop ();
+			if (toplevels.Count == 0)
+				Shutdown (closeDriver);
+			else {
+				Current = toplevels.Peek ();
+				Refresh ();
+			}
+		}
+
+		/// <summary>
+		///   Building block API: Runs the main loop for the created dialog
+		/// </summary>
+		/// <remarks>
+		///   Use the wait parameter to control whether this is a
+		///   blocking or non-blocking call.
+		/// </remarks>
+		/// <param name="state">The state returned by the Begin method.</param>
+		/// <param name="wait">By default this is true which will execute the runloop waiting for events, if you pass false, you can use this method to run a single iteration of the events.</param>
+		public static void RunLoop (RunState state, bool wait = true)
+		{
+			if (state == null)
+				throw new ArgumentNullException (nameof (state));
+			if (state.Toplevel == null)
+				throw new ObjectDisposedException ("state");
+
+			bool firstIteration = true;
+			for (state.Toplevel.Running = true; state.Toplevel.Running;) {
+				if (MainLoop.EventsPending (wait)) {
+					// Notify Toplevel it's ready
+					if (firstIteration) {
+						state.Toplevel.OnReady ();
+					}
+					firstIteration = false;
+
+					MainLoop.MainIteration ();
+					Iteration?.Invoke (null, EventArgs.Empty);
+				} else if (wait == false)
+					return;
+				if (state.Toplevel.NeedDisplay != null && (!state.Toplevel.NeedDisplay.IsEmpty || state.Toplevel.childNeedsDisplay)) {
+					state.Toplevel.Redraw (state.Toplevel.Bounds);
+					if (DebugDrawBounds)
+						DrawBounds (state.Toplevel);
+					state.Toplevel.PositionCursor ();
+					Driver.Refresh ();
+				} else
+					Driver.UpdateCursor ();
+			}
+		}
+
+		internal static bool DebugDrawBounds = false;
+
+		// Need to look into why this does not work properly.
+		static void DrawBounds (View v)
+		{
+			v.DrawFrame (v.Frame, padding: 0, fill: false);
+			if (v.InternalSubviews != null && v.InternalSubviews.Count > 0)
+				foreach (var sub in v.InternalSubviews)
+					DrawBounds (sub);
+		}
+
+		/// <summary>
+		/// Runs the application by calling <see cref="Run(Toplevel, bool)"/> with the value of <see cref="Top"/>
+		/// </summary>
+		public static void Run ()
+		{
+			Run (Top);
+		}
+
+		/// <summary>
+		/// Runs the application by calling <see cref="Run(Toplevel, bool)"/> with a new instance of the specified <see cref="Toplevel"/>-derived class
+		/// </summary>
+		public static void Run<T> () where T : Toplevel, new()
+		{
+			Init (() => new T ());
+			Run (Top);
+		}
+
+		/// <summary>
+		///   Runs the main loop on the given <see cref="Toplevel"/> container.
+		/// </summary>
+		/// <remarks>
+		///   <para>
+		///     This method is used to start processing events
+		///     for the main application, but it is also used to
+		///     run other modal <see cref="View"/>s such as <see cref="Dialog"/> boxes.
+		///   </para>
+		///   <para>
+		///     To make a <see cref="Run(Toplevel, bool)"/> stop execution, call <see cref="Application.RequestStop"/>.
+		///   </para>
+		///   <para>
+		///     Calling <see cref="Run(Toplevel, bool)"/> is equivalent to calling <see cref="Begin(Toplevel)"/>, followed by <see cref="RunLoop(RunState, bool)"/>,
+		///     and then calling <see cref="End(RunState, bool)"/>.
+		///   </para>
+		///   <para>
+		///     Alternatively, to have a program control the main loop and 
+		///     process events manually, call <see cref="Begin(Toplevel)"/> to set things up manually and then
+		///     repeatedly call <see cref="RunLoop(RunState, bool)"/> with the wait parameter set to false.   By doing this
+		///     the <see cref="RunLoop(RunState, bool)"/> method will only process any pending events, timers, idle handlers and
+		///     then return control immediately.
+		///   </para>
+		/// </remarks>
+		public static void Run (Toplevel view, bool closeDriver = true)
+		{
+			var runToken = Begin (view);
+			RunLoop (runToken);
+			End (runToken, closeDriver);
+		}
+
+		/// <summary>
+		/// Stops running the most recent <see cref="Toplevel"/>. 
+		/// </summary>
+		/// <remarks>
+		///   <para>
+		///   This will cause <see cref="Application.Run()"/> to return.
+		///   </para>
+		///   <para>
+		///     Calling <see cref="Application.RequestStop"/> is equivalent to setting the <see cref="Toplevel.Running"/> property on the curently running <see cref="Toplevel"/> to false.
+		///   </para>
+		/// </remarks>
+		public static void RequestStop ()
+		{
+			Current.Running = false;
+		}
+
+		/// <summary>
+		/// Event arguments for the <see cref="Application.Resized"/> event.
+		/// </summary>
+		public class ResizedEventArgs : EventArgs {
+			/// <summary>
+			/// The number of rows in the resized terminal.
+			/// </summary>
+			public int Rows { get; set; }
+			/// <summary>
+			/// The number of columns in the resized terminal.
+			/// </summary>
+			public int Cols { get; set; }
+		}
+
+		/// <summary>
+		/// Invoked when the terminal was resized. The new size of the terminal is provided.
+		/// </summary>
+		public static event EventHandler<ResizedEventArgs> Resized;
+
+		static void TerminalResized ()
+		{
+			var full = new Rect (0, 0, Driver.Cols, Driver.Rows);
+			Resized?.Invoke (null, new ResizedEventArgs () { Cols = full.Width, Rows = full.Height });
+			Driver.Clip = full;
+			foreach (var t in toplevels) {
+				t.PositionToplevels ();
+				t.RelativeLayout (full);
+				t.LayoutSubviews ();
+			}
+			Refresh ();
+		}
+	}
+}

Terminal.Gui/Core/Responder.cs

@@ -0,0 +1,185 @@
+//
+// Core.cs: The core engine for gui.cs
+//
+// Authors:
+//   Miguel de Icaza (miguel@gnome.org)
+//
+// Pending:
+//   - Check for NeedDisplay on the hierarchy and repaint
+//   - Layout support
+//   - "Colors" type or "Attributes" type?
+//   - What to surface as "BackgroundCOlor" when clearing a window, an attribute or colors?
+//
+// Optimziations
+//   - Add rendering limitation to the exposed area
+
+namespace Terminal.Gui {
+	/// <summary>
+	/// Responder base class implemented by objects that want to participate on keyboard and mouse input.
+	/// </summary>
+	public class Responder {
+		/// <summary>
+		/// Gets or sets a value indicating whether this <see cref="Responder"/> can focus.
+		/// </summary>
+		/// <value><c>true</c> if can focus; otherwise, <c>false</c>.</value>
+		public virtual bool CanFocus { get; set; }
+
+		/// <summary>
+		/// Gets or sets a value indicating whether this <see cref="Responder"/> has focus.
+		/// </summary>
+		/// <value><c>true</c> if has focus; otherwise, <c>false</c>.</value>
+		public virtual bool HasFocus { get; internal set; }
+
+		// Key handling
+		/// <summary>
+		///   This method can be overwritten by view that
+		///     want to provide accelerator functionality
+		///     (Alt-key for example).
+		/// </summary>
+		/// <remarks>
+		///   <para>
+		///     Before keys are sent to the subview on the
+		///     current view, all the views are
+		///     processed and the key is passed to the widgets
+		///     to allow some of them to process the keystroke
+		///     as a hot-key. </para>
+		///  <para>
+		///     For example, if you implement a button that
+		///     has a hotkey ok "o", you would catch the
+		///     combination Alt-o here.  If the event is
+		///     caught, you must return true to stop the
+		///     keystroke from being dispatched to other
+		///     views.
+		///  </para>
+		/// </remarks>
+
+		public virtual bool ProcessHotKey (KeyEvent kb)
+		{
+			return false;
+		}
+
+		/// <summary>
+		///   If the view is focused, gives the view a
+		///   chance to process the keystroke.
+		/// </summary>
+		/// <remarks>
+		///   <para>
+		///     Views can override this method if they are
+		///     interested in processing the given keystroke.
+		///     If they consume the keystroke, they must
+		///     return true to stop the keystroke from being
+		///     processed by other widgets or consumed by the
+		///     widget engine.    If they return false, the
+		///     keystroke will be passed using the ProcessColdKey
+		///     method to other views to process.
+		///   </para>
+		///   <para>
+		///     The View implementation does nothing but return false,
+		///     so it is not necessary to call base.ProcessKey if you
+		///     derive directly from View, but you should if you derive
+		///     other View subclasses.
+		///   </para>
+		/// </remarks>
+		/// <param name="keyEvent">Contains the details about the key that produced the event.</param>
+		public virtual bool ProcessKey (KeyEvent keyEvent)
+		{
+			return false;
+		}
+
+		/// <summary>
+		///   This method can be overwritten by views that
+		///     want to provide accelerator functionality
+		///     (Alt-key for example), but without
+		///     interefering with normal ProcessKey behavior.
+		/// </summary>
+		/// <remarks>
+		///   <para>
+		///     After keys are sent to the subviews on the
+		///     current view, all the view are
+		///     processed and the key is passed to the views
+		///     to allow some of them to process the keystroke
+		///     as a cold-key. </para>
+		///  <para>
+		///    This functionality is used, for example, by
+		///    default buttons to act on the enter key.
+		///    Processing this as a hot-key would prevent
+		///    non-default buttons from consuming the enter
+		///    keypress when they have the focus.
+		///  </para>
+		/// </remarks>
+		/// <param name="keyEvent">Contains the details about the key that produced the event.</param>
+		public virtual bool ProcessColdKey (KeyEvent keyEvent)
+		{
+			return false;
+		}
+
+		/// <summary>
+		/// Method invoked when a key is pressed.
+		/// </summary>
+		/// <param name="keyEvent">Contains the details about the key that produced the event.</param>
+		/// <returns>true if the event was handled</returns>
+		public virtual bool OnKeyDown (KeyEvent keyEvent)
+		{
+			return false;
+		}
+
+		/// <summary>
+		/// Method invoked when a key is released.
+		/// </summary>
+		/// <param name="keyEvent">Contains the details about the key that produced the event.</param>
+		/// <returns>true if the event was handled</returns>
+		public virtual bool OnKeyUp (KeyEvent keyEvent)
+		{
+			return false;
+		}
+
+
+		/// <summary>
+		/// Method invoked when a mouse event is generated
+		/// </summary>
+		/// <returns><c>true</c>, if the event was handled, <c>false</c> otherwise.</returns>
+		/// <param name="mouseEvent">Contains the details about the mouse event.</param>
+		public virtual bool MouseEvent (MouseEvent mouseEvent)
+		{
+			return false;
+		}
+
+		/// <summary>
+		/// Method invoked when a mouse event is generated for the first time.
+		/// </summary>
+		/// <param name="mouseEvent"></param>
+		/// <returns><c>true</c>, if the event was handled, <c>false</c> otherwise.</returns>
+		public virtual bool OnMouseEnter (MouseEvent mouseEvent)
+		{
+			return false;
+		}
+
+		/// <summary>
+		/// Method invoked when a mouse event is generated for the last time.
+		/// </summary>
+		/// <param name="mouseEvent"></param>
+		/// <returns><c>true</c>, if the event was handled, <c>false</c> otherwise.</returns>
+		public virtual bool OnMouseLeave (MouseEvent mouseEvent)
+		{
+			return false;
+		}
+
+		/// <summary>
+		/// Method invoked when a view gets focus.
+		/// </summary>
+		/// <returns><c>true</c>, if the event was handled, <c>false</c> otherwise.</returns>
+		public virtual bool OnEnter ()
+		{
+			return false;
+		}
+
+		/// <summary>
+		/// Method invoked when a view loses focus.
+		/// </summary>
+		/// <returns><c>true</c>, if the event was handled, <c>false</c> otherwise.</returns>
+		public virtual bool OnLeave ()
+		{
+			return false;
+		}
+	}
+}

Terminal.Gui/Core/Toplevel.cs

@@ -0,0 +1,299 @@
+//
+// Core.cs: The core engine for gui.cs
+//
+// Authors:
+//   Miguel de Icaza (miguel@gnome.org)
+//
+// Pending:
+//   - Check for NeedDisplay on the hierarchy and repaint
+//   - Layout support
+//   - "Colors" type or "Attributes" type?
+//   - What to surface as "BackgroundCOlor" when clearing a window, an attribute or colors?
+//
+// Optimziations
+//   - Add rendering limitation to the exposed area
+using System;
+using System.ComponentModel;
+
+namespace Terminal.Gui {
+	/// <summary>
+	/// Toplevel views can be modally executed.
+	/// </summary>
+	/// <remarks>
+	///   <para>
+	///     Toplevels can be modally executing views, and they return control
+	///     to the caller when the "Running" property is set to false, or
+	///     by calling <see cref="M:Terminal.Gui.Application.RequestStop()"/>
+	///   </para>
+	///   <para>
+	///     There will be a toplevel created for you on the first time use
+	///     and can be accessed from the property <see cref="P:Terminal.Gui.Application.Top"/>,
+	///     but new toplevels can be created and ran on top of it.   To run, create the
+	///     toplevel and then invoke <see cref="M:Terminal.Gui.Application.Run"/> with the
+	///     new toplevel.
+	///   </para>
+	///   <para>
+	///     TopLevels can also opt-in to more sophisticated initialization
+	///     by implementing <see cref="ISupportInitialize"/>. When they do
+	///     so, the <see cref="ISupportInitialize.BeginInit"/> and
+	///     <see cref="ISupportInitialize.EndInit"/> methods will be called
+	///     before running the view.
+	///     If first-run-only initialization is preferred, the <see cref="ISupportInitializeNotification"/>
+	///     can be implemented too, in which case the <see cref="ISupportInitialize"/>
+	///     methods will only be called if <see cref="ISupportInitializeNotification.IsInitialized"/>
+	///     is <see langword="false"/>. This allows proper View inheritance hierarchies
+	///     to override base class layout code optimally by doing so only on first run,
+	///     instead of on every run.
+	///   </para>
+	/// </remarks>
+	public class Toplevel : View {
+		/// <summary>
+		/// Gets or sets whether the Mainloop for this <see cref="Toplevel"/> is running or not. Setting
+		/// this property to false will cause the MainLoop to exit. 
+		/// </summary>
+		public bool Running { get; set; }
+
+		/// <summary>
+		/// Fired once the Toplevel's MainLoop has started it's first iteration. 
+		/// Subscribe to this event to perform tasks when the <see cref="Toplevel"/> has been laid out and focus has been set.
+		/// changes. A Ready event handler is a good place to finalize initialization after calling `<see cref="Application.Run()"/>(topLevel)`. 
+		/// </summary>
+		public event EventHandler Ready;
+
+		/// <summary>
+		/// Called from Application.RunLoop after the <see cref="Toplevel"/> has entered it's first iteration of the loop. 
+		/// </summary>
+		internal virtual void OnReady ()
+		{
+			Ready?.Invoke (this, EventArgs.Empty);
+		}
+
+		/// <summary>
+		/// Initializes a new instance of the <see cref="Toplevel"/> class with the specified absolute layout.
+		/// </summary>
+		/// <param name="frame">Frame.</param>
+		public Toplevel (Rect frame) : base (frame)
+		{
+			Initialize ();
+		}
+
+		/// <summary>
+		/// Initializes a new instance of the <see cref="Toplevel"/> class with Computed layout, defaulting to <see langword="async"/> full screen.
+		/// </summary>
+		public Toplevel () : base ()
+		{
+			Initialize ();
+			Width = Dim.Fill ();
+			Height = Dim.Fill ();
+		}
+
+		void Initialize ()
+		{
+			ColorScheme = Colors.Base;
+		}
+
+		/// <summary>
+		/// Convenience factory method that creates a new toplevel with the current terminal dimensions.
+		/// </summary>
+		/// <returns>The create.</returns>
+		public static Toplevel Create ()
+		{
+			return new Toplevel (new Rect (0, 0, Driver.Cols, Driver.Rows));
+		}
+
+		/// <summary>
+		/// Gets or sets a value indicating whether this <see cref="Toplevel"/> can focus.
+		/// </summary>
+		/// <value><c>true</c> if can focus; otherwise, <c>false</c>.</value>
+		public override bool CanFocus {
+			get => true;
+		}
+
+		/// <summary>
+		/// Determines whether the <see cref="Toplevel"/> is modal or not.
+		/// Causes <see cref="ProcessKey(KeyEvent)"/> to propagate keys upwards
+		/// by default unless set to <see langword="true"/>.
+		/// </summary>
+		public bool Modal { get; set; }
+
+		/// <summary>
+		/// Check id current toplevel has menu bar
+		/// </summary>
+		public MenuBar MenuBar { get; set; }
+
+		/// <summary>
+		/// Check id current toplevel has status bar
+		/// </summary>
+		public StatusBar StatusBar { get; set; }
+
+		///<inheritdoc cref="ProcessKey"/>
+		public override bool ProcessKey (KeyEvent keyEvent)
+		{
+			if (base.ProcessKey (keyEvent))
+				return true;
+
+			switch (keyEvent.Key) {
+			case Key.ControlQ:
+				// FIXED: stop current execution of this container
+				Application.RequestStop ();
+				break;
+			case Key.ControlZ:
+				Driver.Suspend ();
+				return true;
+
+#if false
+			case Key.F5:
+				Application.DebugDrawBounds = !Application.DebugDrawBounds;
+				SetNeedsDisplay ();
+				return true;
+#endif
+			case Key.Tab:
+			case Key.CursorRight:
+			case Key.CursorDown:
+			case Key.ControlI: // Unix
+				var old = Focused;
+				if (!FocusNext ())
+					FocusNext ();
+				if (old != Focused) {
+					old?.SetNeedsDisplay ();
+					Focused?.SetNeedsDisplay ();
+				}
+				return true;
+			case Key.CursorLeft:
+			case Key.CursorUp:
+			case Key.BackTab:
+				old = Focused;
+				if (!FocusPrev ())
+					FocusPrev ();
+				if (old != Focused) {
+					old?.SetNeedsDisplay ();
+					Focused?.SetNeedsDisplay ();
+				}
+				return true;
+
+			case Key.ControlL:
+				Application.Refresh ();
+				return true;
+			}
+			return false;
+		}
+
+		///<inheritdoc cref="Add"/>
+		public override void Add (View view)
+		{
+			if (this == Application.Top) {
+				if (view is MenuBar)
+					MenuBar = view as MenuBar;
+				if (view is StatusBar)
+					StatusBar = view as StatusBar;
+			}
+			base.Add (view);
+		}
+
+		///<inheritdoc cref="Remove"/>
+		public override void Remove (View view)
+		{
+			if (this == Application.Top) {
+				if (view is MenuBar)
+					MenuBar = null;
+				if (view is StatusBar)
+					StatusBar = null;
+			}
+			base.Remove (view);
+		}
+
+		///<inheritdoc cref="RemoveAll"/>
+		public override void RemoveAll ()
+		{
+			if (this == Application.Top) {
+				MenuBar = null;
+				StatusBar = null;
+			}
+			base.RemoveAll ();
+		}
+
+		internal void EnsureVisibleBounds (Toplevel top, int x, int y, out int nx, out int ny)
+		{
+			nx = Math.Max (x, 0);
+			nx = nx + top.Frame.Width > Driver.Cols ? Math.Max (Driver.Cols - top.Frame.Width, 0) : nx;
+			bool m, s;
+			if (SuperView == null || SuperView.GetType () != typeof (Toplevel))
+				m = Application.Top.MenuBar != null;
+			else
+				m = ((Toplevel)SuperView).MenuBar != null;
+			int l = m ? 1 : 0;
+			ny = Math.Max (y, l);
+			if (SuperView == null || SuperView.GetType () != typeof (Toplevel))
+				s = Application.Top.StatusBar != null;
+			else
+				s = ((Toplevel)SuperView).StatusBar != null;
+			l = s ? Driver.Rows - 1 : Driver.Rows;
+			ny = Math.Min (ny, l);
+			ny = ny + top.Frame.Height > l ? Math.Max (l - top.Frame.Height, m ? 1 : 0) : ny;
+		}
+
+		internal void PositionToplevels ()
+		{
+			if (this != Application.Top) {
+				EnsureVisibleBounds (this, Frame.X, Frame.Y, out int nx, out int ny);
+				if ((nx != Frame.X || ny != Frame.Y) && LayoutStyle != LayoutStyle.Computed) {
+					X = nx;
+					Y = ny;
+				}
+			} else {
+				foreach (var top in Subviews) {
+					if (top is Toplevel) {
+						EnsureVisibleBounds ((Toplevel)top, top.Frame.X, top.Frame.Y, out int nx, out int ny);
+						if ((nx != top.Frame.X || ny != top.Frame.Y) && top.LayoutStyle != LayoutStyle.Computed) {
+							top.X = nx;
+							top.Y = ny;
+						}
+						if (StatusBar != null) {
+							if (ny + top.Frame.Height > Driver.Rows - 1) {
+								if (top.Height is Dim.DimFill)
+									top.Height = Dim.Fill () - 1;
+							}
+							if (StatusBar.Frame.Y != Driver.Rows - 1) {
+								StatusBar.Y = Driver.Rows - 1;
+								SetNeedsDisplay ();
+							}
+						}
+					}
+				}
+			}
+		}
+
+		///<inheritdoc cref="Redraw"/>
+		public override void Redraw (Rect region)
+		{
+			Application.CurrentView = this;
+
+			if (IsCurrentTop) {
+				if (NeedDisplay != null && !NeedDisplay.IsEmpty) {
+					Driver.SetAttribute (Colors.TopLevel.Normal);
+					Clear (region);
+					Driver.SetAttribute (Colors.Base.Normal);
+				}
+				foreach (var view in Subviews) {
+					if (view.Frame.IntersectsWith (region)) {
+						view.SetNeedsLayout ();
+						view.SetNeedsDisplay (view.Bounds);
+					}
+				}
+
+				ClearNeedsDisplay ();
+			}
+
+			base.Redraw (base.Bounds);
+		}
+
+		/// <summary>
+		/// This method is invoked by Application.Begin as part of the Application.Run after
+		/// the views have been laid out, and before the views are drawn for the first time.
+		/// </summary>
+		public virtual void WillPresent ()
+		{
+			FocusFirst ();
+		}
+	}
+}

Terminal.Gui/Core/Window.cs

@@ -0,0 +1,250 @@
+//
+// Core.cs: The core engine for gui.cs
+//
+// Authors:
+//   Miguel de Icaza (miguel@gnome.org)
+//
+// Pending:
+//   - Check for NeedDisplay on the hierarchy and repaint
+//   - Layout support
+//   - "Colors" type or "Attributes" type?
+//   - What to surface as "BackgroundCOlor" when clearing a window, an attribute or colors?
+//
+// Optimziations
+//   - Add rendering limitation to the exposed area
+using System.Collections;
+using System.Linq;
+using NStack;
+
+namespace Terminal.Gui {
+	/// <summary>
+	/// A <see cref="Toplevel"/> <see cref="View"/> that draws a frame around its region and has a "ContentView" subview where the contents are added.
+	/// </summary>
+	public class Window : Toplevel, IEnumerable {
+		View contentView;
+		ustring title;
+
+		/// <summary>
+		/// The title to be displayed for this window.
+		/// </summary>
+		/// <value>The title.</value>
+		public ustring Title {
+			get => title;
+			set {
+				title = value;
+				SetNeedsDisplay ();
+			}
+		}
+
+		class ContentView : View {
+			public ContentView (Rect frame) : base (frame) { }
+			public ContentView () : base () { }
+#if false
+			public override void Redraw (Rect region)
+			{
+				Driver.SetAttribute (ColorScheme.Focus);
+
+				for (int y = 0; y < Frame.Height; y++) {
+					Move (0, y);
+					for (int x = 0; x < Frame.Width; x++) {
+
+						Driver.AddRune ('x');
+					}
+				}
+			}
+#endif
+		}
+
+		/// <summary>
+		/// Initializes a new instance of the <see cref="Gui.Window"/> class with an optional title and a set frame.
+		/// </summary>
+		/// <param name="frame">Frame.</param>
+		/// <param name="title">Title.</param>
+		public Window (Rect frame, ustring title = null) : this (frame, title, padding: 0)
+		{
+		}
+
+		/// <summary>
+		/// Initializes a new instance of the <see cref="Window"/> class with an optional title.
+		/// </summary>
+		/// <param name="title">Title.</param>
+		public Window (ustring title = null) : this (title, padding: 0)
+		{
+		}
+
+		int padding;
+		/// <summary>
+		/// Initializes a new instance of the <see cref="Window"/> with
+		/// the specified frame for its location, with the specified border
+		/// an optional title.
+		/// </summary>
+		/// <param name="frame">Frame.</param>
+		/// <param name="padding">Number of characters to use for padding of the drawn frame.</param>
+		/// <param name="title">Title.</param>
+		public Window (Rect frame, ustring title = null, int padding = 0) : base (frame)
+		{
+			this.Title = title;
+			int wb = 2 * (1 + padding);
+			this.padding = padding;
+			var cFrame = new Rect (1 + padding, 1 + padding, frame.Width - wb, frame.Height - wb);
+			contentView = new ContentView (cFrame);
+			base.Add (contentView);
+		}
+
+		/// <summary>
+		/// Initializes a new instance of the <see cref="Window"/> with
+		/// the specified frame for its location, with the specified border
+		/// an optional title.
+		/// </summary>
+		/// <param name="padding">Number of characters to use for padding of the drawn frame.</param>
+		/// <param name="title">Title.</param>
+		public Window (ustring title = null, int padding = 0) : base ()
+		{
+			this.Title = title;
+			int wb = 1 + padding;
+			this.padding = padding;
+			contentView = new ContentView () {
+				X = wb,
+				Y = wb,
+				Width = Dim.Fill (wb),
+				Height = Dim.Fill (wb)
+			};
+			base.Add (contentView);
+		}
+
+		/// <summary>
+		/// Enumerates the various <see cref="View"/>s in the embedded <see cref="ContentView"/>.
+		/// </summary>
+		/// <returns>The enumerator.</returns>
+		public new IEnumerator GetEnumerator ()
+		{
+			return contentView.GetEnumerator ();
+		}
+
+		/// <summary>
+		/// Add the specified view to the <see cref="ContentView"/>.
+		/// </summary>
+		/// <param name="view">View to add to the window.</param>
+		public override void Add (View view)
+		{
+			contentView.Add (view);
+			if (view.CanFocus)
+				CanFocus = true;
+		}
+
+
+		/// <summary>
+		///   Removes a widget from this container.
+		/// </summary>
+		/// <remarks>
+		/// </remarks>
+		public override void Remove (View view)
+		{
+			if (view == null)
+				return;
+
+			SetNeedsDisplay ();
+			var touched = view.Frame;
+			contentView.Remove (view);
+
+			if (contentView.InternalSubviews.Count < 1)
+				this.CanFocus = false;
+		}
+
+		/// <summary>
+		///   Removes all widgets from this container.
+		/// </summary>
+		/// <remarks>
+		/// </remarks>
+		public override void RemoveAll ()
+		{
+			contentView.RemoveAll ();
+		}
+
+		///<inheritdoc cref="Redraw"/>
+		public override void Redraw (Rect bounds)
+		{
+			Application.CurrentView = this;
+			var scrRect = RectToScreen (new Rect (0, 0, Frame.Width, Frame.Height));
+			var savedClip = Driver.Clip;
+			Driver.Clip = ScreenClip (RectToScreen (Bounds));
+
+			if (NeedDisplay != null && !NeedDisplay.IsEmpty) {
+				Driver.SetAttribute (ColorScheme.Normal);
+				Driver.DrawFrame (scrRect, padding, true);
+			}
+			contentView.Redraw (contentView.Bounds);
+			ClearNeedsDisplay ();
+			Driver.SetAttribute (ColorScheme.Normal);
+			Driver.DrawFrame (scrRect, padding, false);
+
+			if (HasFocus)
+				Driver.SetAttribute (ColorScheme.HotNormal);
+			Driver.DrawWindowTitle (scrRect, Title, padding, padding, padding, padding);
+			Driver.Clip = savedClip;
+			Driver.SetAttribute (ColorScheme.Normal);
+		}
+
+		//
+		// FIXED:It does not look like the event is raised on clicked-drag
+		// need to figure that out.
+		//
+		internal static Point? dragPosition;
+		Point start;
+		///<inheritdoc cref="MouseEvent(Gui.MouseEvent)"/>
+		public override bool MouseEvent (MouseEvent mouseEvent)
+		{
+			// FIXED:The code is currently disabled, because the
+			// Driver.UncookMouse does not seem to have an effect if there is
+			// a pending mouse event activated.
+
+			int nx, ny;
+			if ((mouseEvent.Flags == (MouseFlags.Button1Pressed | MouseFlags.ReportMousePosition) ||
+				mouseEvent.Flags == MouseFlags.Button3Pressed)) {
+				if (dragPosition.HasValue) {
+					if (SuperView == null) {
+						Application.Top.SetNeedsDisplay (Frame);
+						Application.Top.Redraw (Frame);
+					} else {
+						SuperView.SetNeedsDisplay (Frame);
+					}
+					EnsureVisibleBounds (this, mouseEvent.X + mouseEvent.OfX - start.X,
+						mouseEvent.Y + mouseEvent.OfY, out nx, out ny);
+
+					dragPosition = new Point (nx, ny);
+					Frame = new Rect (nx, ny, Frame.Width, Frame.Height);
+					X = nx;
+					Y = ny;
+					//Demo.ml2.Text = $"{dx},{dy}";
+
+					// FIXED: optimize, only SetNeedsDisplay on the before/after regions.
+					SetNeedsDisplay ();
+					return true;
+				} else {
+					// Only start grabbing if the user clicks on the title bar.
+					if (mouseEvent.Y == 0) {
+						start = new Point (mouseEvent.X, mouseEvent.Y);
+						dragPosition = new Point ();
+						nx = mouseEvent.X - mouseEvent.OfX;
+						ny = mouseEvent.Y - mouseEvent.OfY;
+						dragPosition = new Point (nx, ny);
+						Application.GrabMouse (this);
+					}
+
+					//Demo.ml2.Text = $"Starting at {dragPosition}";
+					return true;
+				}
+			}
+
+			if (mouseEvent.Flags == MouseFlags.Button1Released && dragPosition.HasValue) {
+				Application.UngrabMouse ();
+				Driver.UncookMouse ();
+				dragPosition = null;
+			}
+
+			//Demo.ml.Text = me.ToString ();
+			return false;
+		}
+
+	}
+}