diff --git a/Example/demo.cs b/Example/demo.cs index 95a5726e6..a2459b6ae 100644 --- a/Example/demo.cs +++ b/Example/demo.cs @@ -2,13 +2,11 @@ using Terminal.Gui; using System; using System.Linq; using System.IO; -using Mono.Terminal; using System.Collections.Generic; using System.Diagnostics; using System.Globalization; using System.Reflection; using NStack; -using System.Text; static class Demo { //class Box10x : View, IScrollView { diff --git a/Terminal.Gui/Drivers/CursesDriver.cs b/Terminal.Gui/ConsoleDrivers/CursesDriver/CursesDriver.cs similarity index 99% rename from Terminal.Gui/Drivers/CursesDriver.cs rename to Terminal.Gui/ConsoleDrivers/CursesDriver/CursesDriver.cs index 95c78cfd0..08eeb4e23 100644 --- a/Terminal.Gui/Drivers/CursesDriver.cs +++ b/Terminal.Gui/ConsoleDrivers/CursesDriver/CursesDriver.cs @@ -8,7 +8,6 @@ using System; using System.Collections.Generic; using System.Runtime.InteropServices; using System.Threading.Tasks; -using Mono.Terminal; using NStack; using Unix.Terminal; @@ -445,7 +444,7 @@ namespace Terminal.Gui { this.mouseHandler = mouseHandler; this.mainLoop = mainLoop; - (mainLoop.Driver as Mono.Terminal.UnixMainLoop).AddWatch (0, Mono.Terminal.UnixMainLoop.Condition.PollIn, x => { + (mainLoop.Driver as UnixMainLoop).AddWatch (0, UnixMainLoop.Condition.PollIn, x => { ProcessInput (keyHandler, keyUpHandler, mouseHandler); return true; }); diff --git a/Terminal.Gui/ConsoleDrivers/CursesDriver/UnixMainLoop.cs b/Terminal.Gui/ConsoleDrivers/CursesDriver/UnixMainLoop.cs new file mode 100644 index 000000000..73e1e2efb --- /dev/null +++ b/Terminal.Gui/ConsoleDrivers/CursesDriver/UnixMainLoop.cs @@ -0,0 +1,222 @@ +// +// mainloop.cs: Simple managed mainloop implementation. +// +// Authors: +// Miguel de Icaza (miguel.de.icaza@gmail.com) +// +// Copyright (C) 2011 Novell (http://www.novell.com) +// +// Permission is hereby granted, free of charge, to any person obtaining +// a copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to +// permit persons to whom the Software is furnished to do so, subject to +// the following conditions: +// +// The above copyright notice and this permission notice shall be +// included in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +// +using System.Collections.Generic; +using System; +using System.Runtime.InteropServices; + +namespace Terminal.Gui { + /// + /// Unix main loop, suitable for using on Posix systems + /// + /// + /// In addition to the general functions of the mainloop, the Unix version + /// can watch file descriptors using the AddWatch methods. + /// + public class UnixMainLoop : IMainLoopDriver { + [StructLayout (LayoutKind.Sequential)] + struct Pollfd { + public int fd; + public short events, revents; + } + + /// + /// Condition on which to wake up from file descriptor activity. These match the Linux/BSD poll definitions. + /// + [Flags] + public enum Condition : short { + /// + /// There is data to read + /// + PollIn = 1, + /// + /// Writing to the specified descriptor will not block + /// + PollOut = 4, + /// + /// There is urgent data to read + /// + PollPri = 2, + /// + /// Error condition on output + /// + PollErr = 8, + /// + /// Hang-up on output + /// + PollHup = 16, + /// + /// File descriptor is not open. + /// + PollNval = 32 + } + + class Watch { + public int File; + public Condition Condition; + public Func Callback; + } + + Dictionary descriptorWatchers = new Dictionary (); + + [DllImport ("libc")] + extern static int poll ([In, Out]Pollfd [] ufds, uint nfds, int timeout); + + [DllImport ("libc")] + extern static int pipe ([In, Out]int [] pipes); + + [DllImport ("libc")] + extern static int read (int fd, IntPtr buf, IntPtr n); + + [DllImport ("libc")] + extern static int write (int fd, IntPtr buf, IntPtr n); + + Pollfd [] pollmap; + bool poll_dirty = true; + int [] wakeupPipes = new int [2]; + static IntPtr ignore = Marshal.AllocHGlobal (1); + MainLoop mainLoop; + + void IMainLoopDriver.Wakeup () + { + write (wakeupPipes [1], ignore, (IntPtr) 1); + } + + void IMainLoopDriver.Setup (MainLoop mainLoop) { + this.mainLoop = mainLoop; + pipe (wakeupPipes); + AddWatch (wakeupPipes [0], Condition.PollIn, ml => { + read (wakeupPipes [0], ignore, (IntPtr)1); + return true; + }); + } + + /// + /// Removes an active watch from the mainloop. + /// + /// + /// The token parameter is the value returned from AddWatch + /// + public void RemoveWatch (object token) + { + var watch = token as Watch; + if (watch == null) + return; + descriptorWatchers.Remove (watch.File); + } + + /// + /// Watches a file descriptor for activity. + /// + /// + /// When the condition is met, the provided callback + /// is invoked. If the callback returns false, the + /// watch is automatically removed. + /// + /// The return value is a token that represents this watch, you can + /// use this token to remove the watch by calling RemoveWatch. + /// + public object AddWatch (int fileDescriptor, Condition condition, Func callback) + { + if (callback == null) + throw new ArgumentNullException (nameof(callback)); + + var watch = new Watch () { Condition = condition, Callback = callback, File = fileDescriptor }; + descriptorWatchers [fileDescriptor] = watch; + poll_dirty = true; + return watch; + } + + void UpdatePollMap () + { + if (!poll_dirty) + return; + poll_dirty = false; + + pollmap = new Pollfd [descriptorWatchers.Count]; + int i = 0; + foreach (var fd in descriptorWatchers.Keys) { + pollmap [i].fd = fd; + pollmap [i].events = (short)descriptorWatchers [fd].Condition; + i++; + } + } + + bool IMainLoopDriver.EventsPending (bool wait) + { + long now = DateTime.UtcNow.Ticks; + + int pollTimeout, n; + if (mainLoop.timeouts.Count > 0) { + pollTimeout = (int)((mainLoop.timeouts.Keys [0] - now) / TimeSpan.TicksPerMillisecond); + if (pollTimeout < 0) + return true; + + } else + pollTimeout = -1; + + if (!wait) + pollTimeout = 0; + + UpdatePollMap (); + + while (true) { + if (wait && pollTimeout == -1) { + pollTimeout = 0; + } + n = poll (pollmap, (uint)pollmap.Length, pollTimeout); + if (pollmap != null) { + break; + } + if (mainLoop.timeouts.Count > 0 || mainLoop.idleHandlers.Count > 0) { + return true; + } + } + int ic; + lock (mainLoop.idleHandlers) + ic = mainLoop.idleHandlers.Count; + return n > 0 || mainLoop.timeouts.Count > 0 && ((mainLoop.timeouts.Keys [0] - DateTime.UtcNow.Ticks) < 0) || ic > 0; + } + + void IMainLoopDriver.MainIteration () + { + if (pollmap != null) { + foreach (var p in pollmap) { + Watch watch; + + if (p.revents == 0) + continue; + + if (!descriptorWatchers.TryGetValue (p.fd, out watch)) + continue; + if (!watch.Callback (this.mainLoop)) + descriptorWatchers.Remove (p.fd); + } + } + } + } +} diff --git a/Terminal.Gui/MonoCurses/UnmanagedLibrary.cs b/Terminal.Gui/ConsoleDrivers/CursesDriver/UnmanagedLibrary.cs similarity index 100% rename from Terminal.Gui/MonoCurses/UnmanagedLibrary.cs rename to Terminal.Gui/ConsoleDrivers/CursesDriver/UnmanagedLibrary.cs diff --git a/Terminal.Gui/MonoCurses/binding.cs b/Terminal.Gui/ConsoleDrivers/CursesDriver/binding.cs similarity index 100% rename from Terminal.Gui/MonoCurses/binding.cs rename to Terminal.Gui/ConsoleDrivers/CursesDriver/binding.cs diff --git a/Terminal.Gui/MonoCurses/constants.cs b/Terminal.Gui/ConsoleDrivers/CursesDriver/constants.cs similarity index 100% rename from Terminal.Gui/MonoCurses/constants.cs rename to Terminal.Gui/ConsoleDrivers/CursesDriver/constants.cs diff --git a/Terminal.Gui/MonoCurses/handles.cs b/Terminal.Gui/ConsoleDrivers/CursesDriver/handles.cs similarity index 100% rename from Terminal.Gui/MonoCurses/handles.cs rename to Terminal.Gui/ConsoleDrivers/CursesDriver/handles.cs diff --git a/Terminal.Gui/Drivers/NetDriver.cs b/Terminal.Gui/ConsoleDrivers/NetDriver.cs similarity index 85% rename from Terminal.Gui/Drivers/NetDriver.cs rename to Terminal.Gui/ConsoleDrivers/NetDriver.cs index 3b7fa188d..aa237b65a 100644 --- a/Terminal.Gui/Drivers/NetDriver.cs +++ b/Terminal.Gui/ConsoleDrivers/NetDriver.cs @@ -5,7 +5,7 @@ // Miguel de Icaza (miguel@gnome.org) // using System; -using Mono.Terminal; +using System.Threading; using NStack; namespace Terminal.Gui { @@ -144,7 +144,7 @@ namespace Terminal.Gui { Colors.Menu.Focus = MakeColor (ConsoleColor.White, ConsoleColor.Black); Colors.Menu.HotNormal = MakeColor (ConsoleColor.Yellow, ConsoleColor.Cyan); Colors.Menu.Normal = MakeColor (ConsoleColor.White, ConsoleColor.Cyan); - Colors.Menu.Disabled = MakeColor(ConsoleColor.DarkGray, ConsoleColor.Cyan); + Colors.Menu.Disabled = MakeColor (ConsoleColor.DarkGray, ConsoleColor.Cyan); Colors.Dialog.Normal = MakeColor (ConsoleColor.Black, ConsoleColor.Gray); Colors.Dialog.Focus = MakeColor (ConsoleColor.Black, ConsoleColor.Cyan); @@ -356,4 +356,71 @@ namespace Terminal.Gui { // } + + /// + /// Mainloop intended to be used with the .NET System.Console API, and can + /// be used on Windows and Unix, it is cross platform but lacks things like + /// file descriptor monitoring. + /// + class NetMainLoop : IMainLoopDriver { + AutoResetEvent keyReady = new AutoResetEvent (false); + AutoResetEvent waitForProbe = new AutoResetEvent (false); + ConsoleKeyInfo? windowsKeyResult = null; + public Action WindowsKeyPressed; + MainLoop mainLoop; + + public NetMainLoop () + { + } + + void WindowsKeyReader () + { + while (true) { + waitForProbe.WaitOne (); + windowsKeyResult = Console.ReadKey (true); + keyReady.Set (); + } + } + + void IMainLoopDriver.Setup (MainLoop mainLoop) + { + this.mainLoop = mainLoop; + Thread readThread = new Thread (WindowsKeyReader); + readThread.Start (); + } + + void IMainLoopDriver.Wakeup () + { + } + + bool IMainLoopDriver.EventsPending (bool wait) + { + long now = DateTime.UtcNow.Ticks; + + int waitTimeout; + if (mainLoop.timeouts.Count > 0) { + waitTimeout = (int)((mainLoop.timeouts.Keys [0] - now) / TimeSpan.TicksPerMillisecond); + if (waitTimeout < 0) + return true; + } else + waitTimeout = -1; + + if (!wait) + waitTimeout = 0; + + windowsKeyResult = null; + waitForProbe.Set (); + keyReady.WaitOne (waitTimeout); + return windowsKeyResult.HasValue; + } + + void IMainLoopDriver.MainIteration () + { + if (windowsKeyResult.HasValue) { + if (WindowsKeyPressed != null) + WindowsKeyPressed (windowsKeyResult.Value); + windowsKeyResult = null; + } + } + } } \ No newline at end of file diff --git a/Terminal.Gui/Drivers/WindowsDriver.cs b/Terminal.Gui/ConsoleDrivers/WindowsDriver.cs similarity index 99% rename from Terminal.Gui/Drivers/WindowsDriver.cs rename to Terminal.Gui/ConsoleDrivers/WindowsDriver.cs index 439f0fea3..1269ae375 100644 --- a/Terminal.Gui/Drivers/WindowsDriver.cs +++ b/Terminal.Gui/ConsoleDrivers/WindowsDriver.cs @@ -26,12 +26,9 @@ // SOFTWARE. // using System; -using System.CodeDom; -using System.Diagnostics; using System.Runtime.InteropServices; using System.Threading; using System.Threading.Tasks; -using Mono.Terminal; using NStack; namespace Terminal.Gui { @@ -425,7 +422,7 @@ namespace Terminal.Gui { } } - internal class WindowsDriver : ConsoleDriver, Mono.Terminal.IMainLoopDriver { + internal class WindowsDriver : ConsoleDriver, IMainLoopDriver { static bool sync = false; ManualResetEventSlim eventReady = new ManualResetEventSlim (false); ManualResetEventSlim waitForProbe = new ManualResetEventSlim (false); @@ -522,9 +519,9 @@ namespace Terminal.Gui { void WindowsInputHandler () { while (true) { - waitForProbe.Wait (); + waitForProbe.Wait (); waitForProbe.Reset (); - + uint numberEventsRead = 0; WindowsConsole.ReadConsoleInput (winConsole.InputHandle, records, 1, out numberEventsRead); @@ -1044,7 +1041,7 @@ namespace Terminal.Gui { SetupColorsAndBorders (); } - + void ResizeScreen () { OutputBuffer = new WindowsConsole.CharInfo [Rows * Cols]; diff --git a/Terminal.Gui/Core/Application.cs b/Terminal.Gui/Core/Application.cs new file mode 100644 index 000000000..80fa4feee --- /dev/null +++ b/Terminal.Gui/Core/Application.cs @@ -0,0 +1,660 @@ +// +// 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.Generic; +using System.Threading; +using System.ComponentModel; +using System.Linq; + +namespace Terminal.Gui { + /// + /// The application driver for Terminal.Gui. + /// + /// + /// + /// You can hook up to the event to have your method + /// invoked on each iteration of the . + /// + /// + /// Creates a instance of to process input events, handle timers and + /// other sources of data. It is accessible via the property. + /// + /// + /// When invoked sets the SynchronizationContext to one that is tied + /// to the mainloop, allowing user code to use async/await. + /// + /// + public static class Application { + /// + /// The current in use. + /// + public static ConsoleDriver Driver; + + /// + /// The object used for the application on startup () + /// + /// The top. + public static Toplevel Top { get; private set; } + + /// + /// The current object. This is updated when enters and leaves to point to the current . + /// + /// The current. + public static Toplevel Current { get; private set; } + + /// + /// TThe current object being redrawn. + /// + /// /// The current. + public static View CurrentView { get; set; } + + /// + /// The driver for the applicaiton + /// + /// The main loop. + public static MainLoop MainLoop { get; private set; } + + static Stack toplevels = new Stack (); + + /// + /// This event is raised on each iteration of the + /// + /// + /// See also + /// + public static event EventHandler Iteration; + + /// + /// Returns a rectangle that is centered in the screen for the provided size. + /// + /// The centered rect. + /// Size for the rectangle. + 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); + }); + } + } + + /// + /// If set, it forces the use of the System.Console-based driver. + /// + public static bool UseSystemConsole; + + /// + /// Initializes a new instance of Application. + /// + /// + /// + /// Call this method once per instance (or after has been called). + /// + /// + /// Loads the right for the platform. + /// + /// + /// Creates a and assigns it to and + /// + /// + public static void Init () => Init (() => Toplevel.Create ()); + + internal static bool _initialized = false; + + /// + /// Initializes the Terminal.Gui application + /// + static void Init (Func topLevelFactory) + { + if (_initialized) return; + + 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; + } + + /// + /// Captures the execution state for the provided view. + /// + public class RunState : IDisposable { + internal RunState (Toplevel view) + { + Toplevel = view; + } + internal Toplevel Toplevel; + + /// + /// Releases alTop = l resource used by the object. + /// + /// Call when you are finished using the . The + /// method leaves the in an unusable state. After + /// calling , you must release all references to the + /// so the garbage collector can reclaim the memory that the + /// was occupying. + public void Dispose () + { + Dispose (true); + GC.SuppressFinalize (this); + } + + /// + /// Dispose the specified disposing. + /// + /// The dispose. + /// If set to true disposing. + protected virtual void Dispose (bool disposing) + { + if (Toplevel != null) { + End (Toplevel); + 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; + + /// + /// Grabs the mouse, forcing all mouse events to be routed to the specified view until UngrabMouse is called. + /// + /// The grab. + /// View that will receive all mouse events until UngrabMouse is invoked. + public static void GrabMouse (View view) + { + if (view == null) + return; + mouseGrabView = view; + Driver.UncookMouse (); + } + + /// + /// Releases the mouse grab, so mouse events will be routed to the view on which the mouse is. + /// + public static void UngrabMouse () + { + mouseGrabView = null; + Driver.CookMouse (); + } + + /// + /// Merely a debugging aid to see the raw mouse events + /// + public static Action 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; + } + + /// + /// This event is fired once when the application is first loaded. The dimensions of the + /// terminal are provided. + /// + public static event EventHandler Loaded; + + /// + /// Building block API: Prepares the provided for execution. + /// + /// The runstate handle that needs to be passed to the method upon completion. + /// Toplevel to prepare execution for. + /// + /// 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 method, and then the method upon termination which will + /// undo these changes. + /// + 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; + } + + /// + /// Building block API: completes the execution of a that was started with . + /// + /// The runstate returned by the method. + public static void End (RunState runState) + { + if (runState == null) + throw new ArgumentNullException (nameof (runState)); + + runState.Dispose (); + runState = null; + } + + /// + /// Shutdown an application initalized with + /// + public static void Shutdown () + { + foreach (var t in toplevels) { + t.Running = false; + } + toplevels.Clear (); + Current = null; + CurrentView = null; + Top = null; + 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 (); + } + + /// + /// Triggers a refresh of the entire display. + /// + 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) + { + if (toplevels.Peek () != view) + throw new ArgumentException ("The view that you end with must be balanced"); + toplevels.Pop (); + if (toplevels.Count == 0) + Shutdown (); + else { + Current = toplevels.Peek (); + Refresh (); + } + } + + /// + /// Building block API: Runs the main loop for the created dialog + /// + /// + /// Use the wait parameter to control whether this is a + /// blocking or non-blocking call. + /// + /// The state returned by the Begin method. + /// 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. + 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); + } + + /// + /// Runs the application by calling with the value of + /// + public static void Run () + { + Run (Top); + } + + /// + /// Runs the application by calling with a new instance of the specified -derived class + /// + public static void Run () where T : Toplevel, new() + { + Init (() => new T ()); + Run (Top); + } + + /// + /// Runs the main loop on the given container. + /// + /// + /// + /// This method is used to start processing events + /// for the main application, but it is also used to + /// run other modal s such as boxes. + /// + /// + /// To make a stop execution, call . + /// + /// + /// Calling is equivalent to calling , followed by , + /// and then calling . + /// + /// + /// Alternatively, to have a program control the main loop and + /// process events manually, call to set things up manually and then + /// repeatedly call with the wait parameter set to false. By doing this + /// the method will only process any pending events, timers, idle handlers and + /// then return control immediately. + /// + /// + public static void Run (Toplevel view) + { + var runToken = Begin (view); + RunLoop (runToken); + End (runToken); + } + + /// + /// Stops running the most recent . + /// + /// + /// + /// This will cause to return. + /// + /// + /// Calling is equivalent to setting the property on the curently running to false. + /// + /// + public static void RequestStop () + { + Current.Running = false; + } + + /// + /// Event arguments for the event. + /// + public class ResizedEventArgs : EventArgs { + /// + /// The number of rows in the resized terminal. + /// + public int Rows { get; set; } + /// + /// The number of columns in the resized terminal. + /// + public int Cols { get; set; } + } + + /// + /// Invoked when the terminal was resized. The new size of the terminal is provided. + /// + public static event EventHandler 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 (); + } + } +} diff --git a/Terminal.Gui/Drivers/ConsoleDriver.cs b/Terminal.Gui/Core/ConsoleDriver.cs similarity index 90% rename from Terminal.Gui/Drivers/ConsoleDriver.cs rename to Terminal.Gui/Core/ConsoleDriver.cs index 232be1c28..ddfccae23 100644 --- a/Terminal.Gui/Drivers/ConsoleDriver.cs +++ b/Terminal.Gui/Core/ConsoleDriver.cs @@ -1,16 +1,12 @@ // -// Driver.cs: Definition for the Console Driver API +// ConsoleDriver.cs: Definition for the Console Driver API // // Authors: // Miguel de Icaza (miguel@gnome.org) // using System; -using System.Collections.Generic; using System.Runtime.CompilerServices; -using System.Runtime.InteropServices; -using Mono.Terminal; using NStack; -using Unix.Terminal; namespace Terminal.Gui { @@ -88,8 +84,8 @@ namespace Terminal.Gui { /// Attributes are used as elements that contain both a foreground and a background or platform specific features /// /// - /// Attributes are needed to map colors to terminal capabilities that might lack colors, on color - /// scenarios, they encode both the foreground and the background color and are used in the ColorScheme + /// s are needed to map colors to terminal capabilities that might lack colors, on color + /// scenarios, they encode both the foreground and the background color and are used in the /// class to define color schemes that can be used in your application. /// public struct Attribute { @@ -103,7 +99,7 @@ namespace Terminal.Gui { /// Value. /// Foreground /// Background - public Attribute (int value, Color foreground = new Color(), Color background = new Color()) + public Attribute (int value, Color foreground = new Color (), Color background = new Color ()) { this.value = value; this.foreground = foreground; @@ -123,21 +119,21 @@ namespace Terminal.Gui { } /// - /// Implicit conversion from an attribute to the underlying Int32 representation + /// Implicit conversion from an to the underlying Int32 representation /// /// The integer value stored in the attribute. /// The attribute to convert public static implicit operator int (Attribute c) => c.value; /// - /// Implicitly convert an integer value into an attribute + /// Implicitly convert an integer value into an /// /// An attribute with the specified integer value. /// value public static implicit operator Attribute (int v) => new Attribute (v); /// - /// Creates an attribute from the specified foreground and background. + /// Creates an from the specified foreground and background. /// /// The make. /// Foreground color to use. @@ -152,7 +148,7 @@ namespace Terminal.Gui { /// /// Color scheme definitions, they cover some common scenarios and are used - /// typically in toplevel containers to set the scheme that is used by all the + /// typically in containers such as and to set the scheme that is used by all the /// views contained inside. /// public class ColorScheme { @@ -190,7 +186,7 @@ namespace Terminal.Gui { bool preparingScheme = false; - Attribute SetAttribute (Attribute attribute, [CallerMemberName]string callerMemberName = null) + Attribute SetAttribute (Attribute attribute, [CallerMemberName] string callerMemberName = null) { if (!Application._initialized && !preparingScheme) return attribute; @@ -318,7 +314,7 @@ namespace Terminal.Gui { } /// - /// The default ColorSchemes for the application. + /// The default s for the application. /// public static class Colors { static ColorScheme _toplevel; @@ -352,81 +348,81 @@ namespace Terminal.Gui { /// public static ColorScheme Error { get { return _error; } set { _error = SetColorScheme (value); } } - static ColorScheme SetColorScheme (ColorScheme colorScheme, [CallerMemberName]string callerMemberName = null) + static ColorScheme SetColorScheme (ColorScheme colorScheme, [CallerMemberName] string callerMemberName = null) { colorScheme.caller = callerMemberName; return colorScheme; } } - /// - /// Special characters that can be drawn with Driver.AddSpecial. - /// - public enum SpecialChar { - /// - /// Horizontal line character. - /// - HLine, + ///// + ///// Special characters that can be drawn with + ///// + //public enum SpecialChar { + // /// + // /// Horizontal line character. + // /// + // HLine, - /// - /// Vertical line character. - /// - VLine, + // /// + // /// Vertical line character. + // /// + // VLine, - /// - /// Stipple pattern - /// - Stipple, + // /// + // /// Stipple pattern + // /// + // Stipple, - /// - /// Diamond character - /// - Diamond, + // /// + // /// Diamond character + // /// + // Diamond, - /// - /// Upper left corner - /// - ULCorner, + // /// + // /// Upper left corner + // /// + // ULCorner, - /// - /// Lower left corner - /// - LLCorner, + // /// + // /// Lower left corner + // /// + // LLCorner, - /// - /// Upper right corner - /// - URCorner, + // /// + // /// Upper right corner + // /// + // URCorner, - /// - /// Lower right corner - /// - LRCorner, + // /// + // /// Lower right corner + // /// + // LRCorner, - /// - /// Left tee - /// - LeftTee, + // /// + // /// Left tee + // /// + // LeftTee, - /// - /// Right tee - /// - RightTee, + // /// + // /// Right tee + // /// + // RightTee, - /// - /// Top tee - /// - TopTee, + // /// + // /// Top tee + // /// + // TopTee, - /// - /// The bottom tee. - /// - BottomTee, - - } + // /// + // /// The bottom tee. + // /// + // BottomTee, + //} /// - /// ConsoleDriver is an abstract class that defines the requirements for a console driver. One implementation if the CursesDriver, and another one uses the .NET Console one. + /// ConsoleDriver is an abstract class that defines the requirements for a console driver. + /// There are currently three implementations: (for Unix and Mac), , and that uses the .NET Console API. /// public abstract class ConsoleDriver { /// @@ -520,7 +516,7 @@ namespace Terminal.Gui { /// Set the handler when the terminal is resized. /// /// - public void SetTerminalResized(Action terminalResized) + public void SetTerminalResized (Action terminalResized) { TerminalResized = terminalResized; } diff --git a/Terminal.Gui/Event.cs b/Terminal.Gui/Core/Event.cs similarity index 97% rename from Terminal.Gui/Event.cs rename to Terminal.Gui/Core/Event.cs index 3ef750738..8c6fd3b2b 100644 --- a/Terminal.Gui/Event.cs +++ b/Terminal.Gui/Core/Event.cs @@ -14,8 +14,8 @@ namespace Terminal.Gui { /// /// /// - /// If the SpecialMask is set, then the value is that of the special mask, - /// otherwise, the value is the one of the lower bits (as extracted by CharMask) + /// If the is set, then the value is that of the special mask, + /// otherwise, the value is the one of the lower bits (as extracted by ) /// /// /// Control keys are the values between 1 and 26 corresponding to Control-A to Control-Z @@ -34,8 +34,8 @@ namespace Terminal.Gui { CharMask = 0xfffff, /// - /// If the SpecialMask is set, then the value is that of the special mask, - /// otherwise, the value is the one of the lower bits (as extracted by CharMask). + /// If the is set, then the value is that of the special mask, + /// otherwise, the value is the one of the lower bits (as extracted by ). /// SpecialMask = 0xfff00000, @@ -369,7 +369,7 @@ namespace Terminal.Gui { } /// - /// Mouse flags reported in MouseEvent. + /// Mouse flags reported in . /// /// /// They just happen to map to the ncurses ones. diff --git a/Terminal.Gui/Core/MainLoop.cs b/Terminal.Gui/Core/MainLoop.cs new file mode 100644 index 000000000..ce9393507 --- /dev/null +++ b/Terminal.Gui/Core/MainLoop.cs @@ -0,0 +1,259 @@ +// +// MainLoop.cs: Simple managed mainloop implementation. +// +// Authors: +// Miguel de Icaza (miguel.de.icaza@gmail.com) +// +// Copyright (C) 2011 Novell (http://www.novell.com) +// +// Permission is hereby granted, free of charge, to any person obtaining +// a copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to +// permit persons to whom the Software is furnished to do so, subject to +// the following conditions: +// +// The above copyright notice and this permission notice shall be +// included in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +// +using System.Collections.Generic; +using System; + +namespace Terminal.Gui { + + /// + /// Interface to create platform specific main loop drivers. + /// + public interface IMainLoopDriver { + /// + /// Initializes the main loop driver, gets the calling main loop for the initialization. + /// + /// Main loop. + void Setup (MainLoop mainLoop); + + /// + /// Wakes up the mainloop that might be waiting on input, must be thread safe. + /// + void Wakeup (); + + /// + /// Must report whether there are any events pending, or even block waiting for events. + /// + /// true, if there were pending events, false otherwise. + /// If set to true wait until an event is available, otherwise return immediately. + bool EventsPending (bool wait); + + /// + /// The interation function. + /// + void MainIteration (); + } + + /// + /// Simple main loop implementation that can be used to monitor + /// file descriptor, run timers and idle handlers. + /// + /// + /// Monitoring of file descriptors is only available on Unix, there + /// does not seem to be a way of supporting this on Windows. + /// + public class MainLoop { + internal class Timeout { + public TimeSpan Span; + public Func Callback; + } + + internal SortedList timeouts = new SortedList (); + internal List> idleHandlers = new List> (); + + IMainLoopDriver driver; + + /// + /// The current IMainLoopDriver in use. + /// + /// The driver. + public IMainLoopDriver Driver => driver; + + /// + /// Creates a new Mainloop, to run it you must provide a driver, and choose + /// one of the implementations UnixMainLoop, NetMainLoop or WindowsMainLoop. + /// + public MainLoop (IMainLoopDriver driver) + { + this.driver = driver; + driver.Setup (this); + } + + /// + /// Runs @action on the thread that is processing events + /// + public void Invoke (Action action) + { + AddIdle (() => { + action (); + return false; + }); + } + + /// + /// Executes the specified @idleHandler on the idle loop. The return value is a token to remove it. + /// + public Func AddIdle (Func idleHandler) + { + lock (idleHandlers) + idleHandlers.Add (idleHandler); + + return idleHandler; + } + + /// + /// Removes the specified idleHandler from processing. + /// + public void RemoveIdle (Func idleHandler) + { + lock (idleHandler) + idleHandlers.Remove (idleHandler); + } + + void AddTimeout (TimeSpan time, Timeout timeout) + { + timeouts.Add ((DateTime.UtcNow + time).Ticks, timeout); + } + + /// + /// Adds a timeout to the mainloop. + /// + /// + /// When time time specified passes, the callback will be invoked. + /// If the callback returns true, the timeout will be reset, repeating + /// the invocation. If it returns false, the timeout will stop. + /// + /// The returned value is a token that can be used to stop the timeout + /// by calling RemoveTimeout. + /// + public object AddTimeout (TimeSpan time, Func callback) + { + if (callback == null) + throw new ArgumentNullException (nameof (callback)); + var timeout = new Timeout () { + Span = time, + Callback = callback + }; + AddTimeout (time, timeout); + return timeout; + } + + /// + /// Removes a previously scheduled timeout + /// + /// + /// The token parameter is the value returned by AddTimeout. + /// + public void RemoveTimeout (object token) + { + var idx = timeouts.IndexOfValue (token as Timeout); + if (idx == -1) + return; + timeouts.RemoveAt (idx); + } + + void RunTimers () + { + long now = DateTime.UtcNow.Ticks; + var copy = timeouts; + timeouts = new SortedList (); + foreach (var k in copy.Keys) { + var timeout = copy [k]; + if (k < now) { + if (timeout.Callback (this)) + AddTimeout (timeout.Span, timeout); + } else + timeouts.Add (k, timeout); + } + } + + void RunIdle () + { + List> iterate; + lock (idleHandlers) { + iterate = idleHandlers; + idleHandlers = new List> (); + } + + foreach (var idle in iterate) { + if (idle ()) + lock (idleHandlers) + idleHandlers.Add (idle); + } + } + + bool running; + + /// + /// Stops the mainloop. + /// + public void Stop () + { + running = false; + driver.Wakeup (); + } + + /// + /// Determines whether there are pending events to be processed. + /// + /// + /// You can use this method if you want to probe if events are pending. + /// Typically used if you need to flush the input queue while still + /// running some of your own code in your main thread. + /// + public bool EventsPending (bool wait = false) + { + return driver.EventsPending (wait); + } + + /// + /// Runs one iteration of timers and file watches + /// + /// + /// You use this to process all pending events (timers, idle handlers and file watches). + /// + /// You can use it like this: + /// while (main.EvensPending ()) MainIteration (); + /// + public void MainIteration () + { + if (timeouts.Count > 0) + RunTimers (); + + driver.MainIteration (); + + lock (idleHandlers) { + if (idleHandlers.Count > 0) + RunIdle (); + } + } + + /// + /// Runs the mainloop. + /// + public void Run () + { + bool prev = running; + running = true; + while (running) { + EventsPending (true); + MainIteration (); + } + running = prev; + } + } +} diff --git a/Terminal.Gui/Types/PosDim.cs b/Terminal.Gui/Core/PosDim.cs similarity index 100% rename from Terminal.Gui/Types/PosDim.cs rename to Terminal.Gui/Core/PosDim.cs diff --git a/Terminal.Gui/Core/Responder.cs b/Terminal.Gui/Core/Responder.cs new file mode 100644 index 000000000..80ad3bd16 --- /dev/null +++ b/Terminal.Gui/Core/Responder.cs @@ -0,0 +1,183 @@ +// +// 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 { + /// + /// Responder base class implemented by objects that want to participate on keyboard and mouse input. + /// + public class Responder { + /// + /// Gets or sets a value indicating whether this can focus. + /// + /// true if can focus; otherwise, false. + public virtual bool CanFocus { get; set; } + + /// + /// Gets or sets a value indicating whether this has focus. + /// + /// true if has focus; otherwise, false. + public virtual bool HasFocus { get; internal set; } + + // Key handling + /// + /// This method can be overwritten by view that + /// want to provide accelerator functionality + /// (Alt-key for example). + /// + /// + /// + /// 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. + /// + /// 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. + /// + /// + + public virtual bool ProcessHotKey (KeyEvent kb) + { + return false; + } + + /// + /// If the view is focused, gives the view a + /// chance to process the keystroke. + /// + /// + /// + /// 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. + /// + /// + /// 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. + /// + /// + /// Contains the details about the key that produced the event. + public virtual bool ProcessKey (KeyEvent keyEvent) + { + return false; + } + + /// + /// This method can be overwritten by views that + /// want to provide accelerator functionality + /// (Alt-key for example), but without + /// interefering with normal ProcessKey behavior. + /// + /// + /// + /// 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. + /// + /// 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. + /// + /// + /// Contains the details about the key that produced the event. + public virtual bool ProcessColdKey (KeyEvent keyEvent) + { + return false; + } + + /// + /// Method invoked when a key is pressed. + /// + /// Contains the details about the key that produced the event. + /// true if the event was handled + public virtual bool OnKeyDown (KeyEvent keyEvent) + { + return false; + } + + /// + /// Method invoked when a key is released. + /// + /// Contains the details about the key that produced the event. + /// true if the event was handled + public virtual bool OnKeyUp (KeyEvent keyEvent) + { + return false; + } + + + /// + /// Method invoked when a mouse event is generated + /// + /// true, if the event was handled, false otherwise. + /// Contains the details about the mouse event. + public virtual bool MouseEvent (MouseEvent mouseEvent) + { + return false; + } + + /// + /// Method invoked when a mouse event is generated for the first time. + /// + /// + /// true, if the event was handled, false otherwise. + public virtual bool OnMouseEnter (MouseEvent mouseEvent) + { + return false; + } + + /// + /// Method invoked when a mouse event is generated for the last time. + /// + /// + /// true, if the event was handled, false otherwise. + public virtual bool OnMouseLeave (MouseEvent mouseEvent) + { + return false; + } + + /// + /// Method invoked when a view gets focus. + /// + /// true, if the event was handled, false otherwise. + public virtual bool OnEnter () + { + return false; + } + + /// + /// Method invoked when a view loses focus. + /// + /// true, if the event was handled, false otherwise. + public virtual bool OnLeave () + { + return false; + } + } +} diff --git a/Terminal.Gui/Core/Toplevel.cs b/Terminal.Gui/Core/Toplevel.cs new file mode 100644 index 000000000..c2fc5d273 --- /dev/null +++ b/Terminal.Gui/Core/Toplevel.cs @@ -0,0 +1,291 @@ +// +// Toplevel.cs: Toplevel views can be modally executed +// +// Authors: +// Miguel de Icaza (miguel@gnome.org) +// +using System; +using System.ComponentModel; + +namespace Terminal.Gui { + /// + /// Toplevel views can be modally executed. + /// + /// + /// + /// Toplevels can be modally executing views, and they return control + /// to the caller when the "Running" property is set to false, or + /// by calling + /// + /// + /// There will be a toplevel created for you on the first time use + /// and can be accessed from the property , + /// but new toplevels can be created and ran on top of it. To run, create the + /// toplevel and then invoke with the + /// new toplevel. + /// + /// + /// TopLevels can also opt-in to more sophisticated initialization + /// by implementing . When they do + /// so, the and + /// methods will be called + /// before running the view. + /// If first-run-only initialization is preferred, the + /// can be implemented too, in which case the + /// methods will only be called if + /// is . 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. + /// + /// + public class Toplevel : View { + /// + /// Gets or sets whether the Mainloop for this is running or not. Setting + /// this property to false will cause the MainLoop to exit. + /// + public bool Running { get; set; } + + /// + /// Fired once the Toplevel's MainLoop has started it's first iteration. + /// Subscribe to this event to perform tasks when the has been laid out and focus has been set. + /// changes. A Ready event handler is a good place to finalize initialization after calling `(topLevel)`. + /// + public event EventHandler Ready; + + /// + /// Called from Application.RunLoop after the has entered it's first iteration of the loop. + /// + internal virtual void OnReady () + { + Ready?.Invoke (this, EventArgs.Empty); + } + + /// + /// Initializes a new instance of the class with the specified absolute layout. + /// + /// Frame. + public Toplevel (Rect frame) : base (frame) + { + Initialize (); + } + + /// + /// Initializes a new instance of the class with Computed layout, defaulting to full screen. + /// + public Toplevel () : base () + { + Initialize (); + Width = Dim.Fill (); + Height = Dim.Fill (); + } + + void Initialize () + { + ColorScheme = Colors.Base; + } + + /// + /// Convenience factory method that creates a new toplevel with the current terminal dimensions. + /// + /// The create. + public static Toplevel Create () + { + return new Toplevel (new Rect (0, 0, Driver.Cols, Driver.Rows)); + } + + /// + /// Gets or sets a value indicating whether this can focus. + /// + /// true if can focus; otherwise, false. + public override bool CanFocus { + get => true; + } + + /// + /// Determines whether the is modal or not. + /// Causes to propagate keys upwards + /// by default unless set to . + /// + public bool Modal { get; set; } + + /// + /// Check id current toplevel has menu bar + /// + public MenuBar MenuBar { get; set; } + + /// + /// Check id current toplevel has status bar + /// + public StatusBar StatusBar { get; set; } + + /// + 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; + } + + /// + 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); + } + + /// + 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); + } + + /// + 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 (); + } + } + } + } + } + } + + /// + 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); + } + + /// + /// 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. + /// + public virtual void WillPresent () + { + FocusFirst (); + } + } +} diff --git a/Terminal.Gui/Core/View.cs b/Terminal.Gui/Core/View.cs new file mode 100644 index 000000000..c4524f316 --- /dev/null +++ b/Terminal.Gui/Core/View.cs @@ -0,0 +1,1311 @@ +// +// 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.Linq; +using NStack; + +namespace Terminal.Gui { + + /// + /// Determines the LayoutStyle for a view, if Absolute, during LayoutSubviews, the + /// value from the Frame will be used, if the value is Computer, then the Frame + /// will be updated from the X, Y Pos objects and the Width and Height Dim objects. + /// + public enum LayoutStyle { + /// + /// The position and size of the view are based on the Frame value. + /// + Absolute, + + /// + /// The position and size of the view will be computed based on the + /// X, Y, Width and Height properties and set on the Frame. + /// + Computed + } + + /// + /// View is the base class for all views on the screen and represents a visible element that can render itself and contains zero or more nested views. + /// + /// + /// + /// The View defines the base functionality for user interface elements in Terminal/gui.cs. Views + /// can contain one or more subviews, can respond to user input and render themselves on the screen. + /// + /// + /// Views can either be created with an absolute position, by calling the constructor that takes a + /// Rect parameter to specify the absolute position and size (the Frame of the View) or by setting the + /// X, Y, Width and Height properties on the view. Both approaches use coordinates that are relative + /// to the container they are being added to. + /// + /// + /// When you do not specify a Rect frame you can use the more flexible + /// Dim and Pos objects that can dynamically update the position of a view. + /// The X and Y properties are of type + /// and you can use either absolute positions, percentages or anchor + /// points. The Width and Height properties are of type + /// and can use absolute position, + /// percentages and anchors. These are useful as they will take + /// care of repositioning your views if your view's frames are resized + /// or if the terminal size changes. + /// + /// + /// When you specify the Rect parameter to a view, you are setting the LayoutStyle to Absolute, and the + /// view will always stay in the position that you placed it. To change the position change the + /// Frame property to the new position. + /// + /// + /// Subviews can be added to a View by calling the Add method. The container of a view is the + /// Superview. + /// + /// + /// Developers can call the SetNeedsDisplay method on the view to flag a region or the entire view + /// as requiring to be redrawn. + /// + /// + /// Views have a ColorScheme property that defines the default colors that subviews + /// should use for rendering. This ensures that the views fit in the context where + /// they are being used, and allows for themes to be plugged in. For example, the + /// default colors for windows and toplevels uses a blue background, while it uses + /// a white background for dialog boxes and a red background for errors. + /// + /// + /// If a ColorScheme is not set on a view, the result of the ColorScheme is the + /// value of the SuperView and the value might only be valid once a view has been + /// added to a SuperView, so your subclasses should not rely on ColorScheme being + /// set at construction time. + /// + /// + /// Using ColorSchemes has the advantage that your application will work both + /// in color as well as black and white displays. + /// + /// + /// Views that are focusable should implement the PositionCursor to make sure that + /// the cursor is placed in a location that makes sense. Unix terminals do not have + /// a way of hiding the cursor, so it can be distracting to have the cursor left at + /// the last focused view. So views should make sure that they place the cursor + /// in a visually sensible place. + /// + /// + /// The metnod LayoutSubviews is invoked when the size or layout of a view has + /// changed. The default processing system will keep the size and dimensions + /// for views that use the LayoutKind.Absolute, and will recompute the + /// frames for the vies that use LayoutKind.Computed. + /// + /// + public class View : Responder, IEnumerable { + internal enum Direction { + Forward, + Backward + } + + View container = null; + View focused = null; + Direction focusDirection; + + /// + /// Event fired when the view get focus. + /// + public event EventHandler Enter; + + /// + /// Event fired when the view lost focus. + /// + public event EventHandler Leave; + + /// + /// Event fired when the view receives the mouse event for the first time. + /// + public event EventHandler MouseEnter; + + /// + /// Event fired when the view loses mouse event for the last time. + /// + public event EventHandler MouseLeave; + + internal Direction FocusDirection { + get => SuperView?.FocusDirection ?? focusDirection; + set { + if (SuperView != null) + SuperView.FocusDirection = value; + else + focusDirection = value; + } + } + + /// + /// Points to the current driver in use by the view, it is a convenience property + /// for simplifying the development of new views. + /// + public static ConsoleDriver Driver { get { return Application.Driver; } } + + static IList empty = new List (0).AsReadOnly (); + + // This is null, and allocated on demand. + List subviews; + + /// + /// This returns a list of the subviews contained by this view. + /// + /// The subviews. + public IList Subviews => subviews == null ? empty : subviews.AsReadOnly (); + + // Internally, we use InternalSubviews rather than subviews, as we do not expect us + // to make the same mistakes our users make when they poke at the Subviews. + internal IList InternalSubviews => subviews ?? empty; + + internal Rect NeedDisplay { get; private set; } = Rect.Empty; + + // The frame for the object + Rect frame; + + /// + /// Gets or sets an identifier for the view; + /// + /// The identifier. + public ustring Id { get; set; } = ""; + + /// + /// Returns a value indicating if this View is currently on Top (Active) + /// + public bool IsCurrentTop { + get { + return Application.Current == this; + } + } + + /// + /// Gets or sets a value indicating whether this want mouse position reports. + /// + /// true if want mouse position reports; otherwise, false. + public virtual bool WantMousePositionReports { get; set; } = false; + + /// + /// Gets or sets a value indicating whether this want continuous button pressed event. + /// + public virtual bool WantContinuousButtonPressed { get; set; } = false; + /// + /// Gets or sets the frame for the view. + /// + /// The frame. + /// + /// Altering the Frame of a view will trigger the redrawing of the + /// view as well as the redrawing of the affected regions in the superview. + /// + public virtual Rect Frame { + get => frame; + set { + if (SuperView != null) { + SuperView.SetNeedsDisplay (frame); + SuperView.SetNeedsDisplay (value); + } + frame = value; + + SetNeedsLayout (); + SetNeedsDisplay (frame); + } + } + + /// + /// Gets an enumerator that enumerates the subviews in this view. + /// + /// The enumerator. + public IEnumerator GetEnumerator () + { + foreach (var v in InternalSubviews) + yield return v; + } + + LayoutStyle layoutStyle; + + /// + /// Controls how the view's Frame is computed during the LayoutSubviews method, if Absolute, then + /// LayoutSubviews does not change the Frame properties, otherwise the Frame is updated from the + /// values in X, Y, Width and Height properties. + /// + /// The layout style. + public LayoutStyle LayoutStyle { + get => layoutStyle; + set { + layoutStyle = value; + SetNeedsLayout (); + } + } + + /// + /// The bounds represent the View-relative rectangle used for this view. Updates to the Bounds update the Frame, and has the same side effects as updating the frame. + /// + /// The bounds. + public Rect Bounds { + get => new Rect (Point.Empty, Frame.Size); + set { + Frame = new Rect (frame.Location, value.Size); + } + } + + Pos x, y; + /// + /// Gets or sets the X position for the view (the column). This is only used when the LayoutStyle is Computed, if the + /// LayoutStyle is set to Absolute, this value is ignored. + /// + /// The X Position. + public Pos X { + get => x; + set { + x = value; + SetNeedsLayout (); + } + } + + /// + /// Gets or sets the Y position for the view (line). This is only used when the LayoutStyle is Computed, if the + /// LayoutStyle is set to Absolute, this value is ignored. + /// + /// The y position (line). + public Pos Y { + get => y; + set { + y = value; + SetNeedsLayout (); + } + } + + Dim width, height; + + /// + /// Gets or sets the width for the view. This is only used when the LayoutStyle is Computed, if the + /// LayoutStyle is set to Absolute, this value is ignored. + /// + /// The width. + public Dim Width { + get => width; + set { + width = value; + SetNeedsLayout (); + } + } + + /// + /// Gets or sets the height for the view. This is only used when the LayoutStyle is Computed, if the + /// LayoutStyle is set to Absolute, this value is ignored. + /// + /// The height. + public Dim Height { + get => height; + set { + height = value; + SetNeedsLayout (); + } + } + + /// + /// Returns the container for this view, or null if this view has not been added to a container. + /// + /// The super view. + public View SuperView => container; + + /// + /// Initializes a new instance of the class with the absolute + /// dimensions specified in the frame. If you want to have Views that can be positioned with + /// Pos and Dim properties on X, Y, Width and Height, use the empty constructor. + /// + /// The region covered by this view. + public View (Rect frame) + { + this.Frame = frame; + CanFocus = false; + LayoutStyle = LayoutStyle.Absolute; + } + + /// + /// Initializes a new instance of the class and sets the + /// view up for Computed layout, which will use the values in X, Y, Width and Height to + /// compute the View's Frame. + /// + public View () + { + CanFocus = false; + LayoutStyle = LayoutStyle.Computed; + } + + /// + /// Invoke to flag that this view needs to be redisplayed, by any code + /// that alters the state of the view. + /// + public void SetNeedsDisplay () + { + SetNeedsDisplay (Bounds); + } + + internal bool layoutNeeded = true; + + internal void SetNeedsLayout () + { + if (layoutNeeded) + return; + layoutNeeded = true; + if (SuperView == null) + return; + SuperView.SetNeedsLayout (); + } + + /// + /// Flags the specified rectangle region on this view as needing to be repainted. + /// + /// The region that must be flagged for repaint. + public void SetNeedsDisplay (Rect region) + { + if (NeedDisplay == null || NeedDisplay.IsEmpty) + NeedDisplay = region; + else { + var x = Math.Min (NeedDisplay.X, region.X); + var y = Math.Min (NeedDisplay.Y, region.Y); + var w = Math.Max (NeedDisplay.Width, region.Width); + var h = Math.Max (NeedDisplay.Height, region.Height); + NeedDisplay = new Rect (x, y, w, h); + } + if (container != null) + container.ChildNeedsDisplay (); + if (subviews == null) + return; + foreach (var view in subviews) + if (view.Frame.IntersectsWith (region)) { + var childRegion = Rect.Intersect (view.Frame, region); + childRegion.X -= view.Frame.X; + childRegion.Y -= view.Frame.Y; + view.SetNeedsDisplay (childRegion); + } + } + + internal bool childNeedsDisplay; + + /// + /// Flags this view for requiring the children views to be repainted. + /// + public void ChildNeedsDisplay () + { + childNeedsDisplay = true; + if (container != null) + container.ChildNeedsDisplay (); + } + + /// + /// Adds a subview to this view. + /// + /// + /// + public virtual void Add (View view) + { + if (view == null) + return; + if (subviews == null) + subviews = new List (); + subviews.Add (view); + view.container = this; + if (view.CanFocus) + CanFocus = true; + SetNeedsLayout (); + SetNeedsDisplay (); + } + + /// + /// Adds the specified views to the view. + /// + /// Array of one or more views (can be optional parameter). + public void Add (params View [] views) + { + if (views == null) + return; + foreach (var view in views) + Add (view); + } + + /// + /// Removes all the widgets from this container. + /// + /// + /// + public virtual void RemoveAll () + { + if (subviews == null) + return; + + while (subviews.Count > 0) { + Remove (subviews [0]); + } + } + + /// + /// Removes a widget from this container. + /// + /// + /// + public virtual void Remove (View view) + { + if (view == null || subviews == null) + return; + + SetNeedsLayout (); + SetNeedsDisplay (); + var touched = view.Frame; + subviews.Remove (view); + view.container = null; + + if (subviews.Count < 1) + this.CanFocus = false; + + foreach (var v in subviews) { + if (v.Frame.IntersectsWith (touched)) + view.SetNeedsDisplay (); + } + } + + void PerformActionForSubview (View subview, Action action) + { + if (subviews.Contains (subview)) { + action (subview); + } + + SetNeedsDisplay (); + subview.SetNeedsDisplay (); + } + + /// + /// Brings the specified subview to the front so it is drawn on top of any other views. + /// + /// The subview to send to the front + /// + /// . + /// + public void BringSubviewToFront (View subview) + { + PerformActionForSubview (subview, x => { + subviews.Remove (x); + subviews.Add (x); + }); + } + + /// + /// Sends the specified subview to the front so it is the first view drawn + /// + /// The subview to send to the front + /// + /// . + /// + public void SendSubviewToBack (View subview) + { + PerformActionForSubview (subview, x => { + subviews.Remove (x); + subviews.Insert (0, subview); + }); + } + + /// + /// Moves the subview backwards in the hierarchy, only one step + /// + /// The subview to send backwards + /// + /// If you want to send the view all the way to the back use SendSubviewToBack. + /// + public void SendSubviewBackwards (View subview) + { + PerformActionForSubview (subview, x => { + var idx = subviews.IndexOf (x); + if (idx > 0) { + subviews.Remove (x); + subviews.Insert (idx - 1, x); + } + }); + } + + /// + /// Moves the subview backwards in the hierarchy, only one step + /// + /// The subview to send backwards + /// + /// If you want to send the view all the way to the back use SendSubviewToBack. + /// + public void BringSubviewForward (View subview) + { + PerformActionForSubview (subview, x => { + var idx = subviews.IndexOf (x); + if (idx + 1 < subviews.Count) { + subviews.Remove (x); + subviews.Insert (idx + 1, x); + } + }); + } + + /// + /// Clears the view region with the current color. + /// + /// + /// + /// This clears the entire region used by this view. + /// + /// + public void Clear () + { + var h = Frame.Height; + var w = Frame.Width; + for (int line = 0; line < h; line++) { + Move (0, line); + for (int col = 0; col < w; col++) + Driver.AddRune (' '); + } + } + + /// + /// Clears the specified rectangular region with the current color + /// + public void Clear (Rect r) + { + var h = r.Height; + var w = r.Width; + for (int line = r.Y; line < r.Y + h; line++) { + Driver.Move (r.X, line); + for (int col = 0; col < w; col++) + Driver.AddRune (' '); + } + } + + /// + /// Converts the (col,row) position from the view into a screen (col,row). The values are clamped to (0..ScreenDim-1) + /// + /// View-based column. + /// View-based row. + /// Absolute column, display relative. + /// Absolute row, display relative. + /// Whether to clip the result of the ViewToScreen method, if set to true, the rcol, rrow values are clamped to the screen dimensions. + internal void ViewToScreen (int col, int row, out int rcol, out int rrow, bool clipped = true) + { + // Computes the real row, col relative to the screen. + rrow = row + frame.Y; + rcol = col + frame.X; + var ccontainer = container; + while (ccontainer != null) { + rrow += ccontainer.frame.Y; + rcol += ccontainer.frame.X; + ccontainer = ccontainer.container; + } + + // The following ensures that the cursor is always in the screen boundaries. + if (clipped) { + rrow = Math.Max (0, Math.Min (rrow, Driver.Rows - 1)); + rcol = Math.Max (0, Math.Min (rcol, Driver.Cols - 1)); + } + } + + /// + /// Converts a point from screen coordinates into the view coordinate space. + /// + /// The mapped point. + /// X screen-coordinate point. + /// Y screen-coordinate point. + public Point ScreenToView (int x, int y) + { + if (SuperView == null) { + return new Point (x - Frame.X, y - frame.Y); + } else { + var parent = SuperView.ScreenToView (x, y); + return new Point (parent.X - frame.X, parent.Y - frame.Y); + } + } + + // Converts a rectangle in view coordinates to screen coordinates. + Rect RectToScreen (Rect rect) + { + ViewToScreen (rect.X, rect.Y, out var x, out var y, clipped: false); + return new Rect (x, y, rect.Width, rect.Height); + } + + // Clips a rectangle in screen coordinates to the dimensions currently available on the screen + Rect ScreenClip (Rect rect) + { + var x = rect.X < 0 ? 0 : rect.X; + var y = rect.Y < 0 ? 0 : rect.Y; + var w = rect.X + rect.Width >= Driver.Cols ? Driver.Cols - rect.X : rect.Width; + var h = rect.Y + rect.Height >= Driver.Rows ? Driver.Rows - rect.Y : rect.Height; + + return new Rect (x, y, w, h); + } + + /// + /// Sets the Console driver's clip region to the current View's Bounds. + /// + /// The existing driver's Clip region, which can be then set by setting the Driver.Clip property. + public Rect ClipToBounds () + { + return SetClip (Bounds); + } + + /// + /// Sets the clipping region to the specified region, the region is view-relative + /// + /// The previous clip region. + /// Rectangle region to clip into, the region is view-relative. + public Rect SetClip (Rect rect) + { + var bscreen = RectToScreen (rect); + var previous = Driver.Clip; + Driver.Clip = ScreenClip (RectToScreen (Bounds)); + return previous; + } + + /// + /// Draws a frame in the current view, clipped by the boundary of this view + /// + /// Rectangular region for the frame to be drawn. + /// The padding to add to the drawn frame. + /// If set to true it fill will the contents. + public void DrawFrame (Rect rect, int padding = 0, bool fill = false) + { + var scrRect = RectToScreen (rect); + var savedClip = Driver.Clip; + Driver.Clip = ScreenClip (RectToScreen (Bounds)); + Driver.DrawFrame (scrRect, padding, fill); + Driver.Clip = savedClip; + } + + /// + /// Utility function to draw strings that contain a hotkey + /// + /// String to display, the underscoore before a letter flags the next letter as the hotkey. + /// Hot color. + /// Normal color. + public void DrawHotString (ustring text, Attribute hotColor, Attribute normalColor) + { + Driver.SetAttribute (normalColor); + foreach (var rune in text) { + if (rune == '_') { + Driver.SetAttribute (hotColor); + continue; + } + Driver.AddRune (rune); + Driver.SetAttribute (normalColor); + } + } + + /// + /// Utility function to draw strings that contains a hotkey using a colorscheme and the "focused" state. + /// + /// String to display, the underscoore before a letter flags the next letter as the hotkey. + /// If set to true this uses the focused colors from the color scheme, otherwise the regular ones. + /// The color scheme to use. + public void DrawHotString (ustring text, bool focused, ColorScheme scheme) + { + if (focused) + DrawHotString (text, scheme.HotFocus, scheme.Focus); + else + DrawHotString (text, scheme.HotNormal, scheme.Normal); + } + + /// + /// This moves the cursor to the specified column and row in the view. + /// + /// The move. + /// Col. + /// Row. + public void Move (int col, int row) + { + ViewToScreen (col, row, out var rcol, out var rrow); + Driver.Move (rcol, rrow); + } + + /// + /// Positions the cursor in the right position based on the currently focused view in the chain. + /// + public virtual void PositionCursor () + { + if (focused != null) + focused.PositionCursor (); + else + Move (frame.X, frame.Y); + } + + /// + public override bool HasFocus { + get { + return base.HasFocus; + } + internal set { + if (base.HasFocus != value) + if (value) + OnEnter (); + else + OnLeave (); + SetNeedsDisplay (); + base.HasFocus = value; + + // Remove focus down the chain of subviews if focus is removed + if (!value && focused != null) { + focused.OnLeave (); + focused.HasFocus = false; + focused = null; + } + } + } + + /// + public override bool OnEnter () + { + Enter?.Invoke (this, new EventArgs ()); + return base.OnEnter (); + } + + /// + public override bool OnLeave () + { + Leave?.Invoke (this, new EventArgs ()); + return base.OnLeave (); + } + + /// + /// Returns the currently focused view inside this view, or null if nothing is focused. + /// + /// The focused. + public View Focused => focused; + + /// + /// Returns the most focused view in the chain of subviews (the leaf view that has the focus). + /// + /// The most focused. + public View MostFocused { + get { + if (Focused == null) + return null; + var most = Focused.MostFocused; + if (most != null) + return most; + return Focused; + } + } + + /// + /// The color scheme for this view, if it is not defined, it returns the parent's + /// color scheme. + /// + public ColorScheme ColorScheme { + get { + if (colorScheme == null) + return SuperView?.ColorScheme; + return colorScheme; + } + set { + colorScheme = value; + } + } + + ColorScheme colorScheme; + + /// + /// Displays the specified character in the specified column and row. + /// + /// Col. + /// Row. + /// Ch. + public void AddRune (int col, int row, Rune ch) + { + if (row < 0 || col < 0) + return; + if (row > frame.Height - 1 || col > frame.Width - 1) + return; + Move (col, row); + Driver.AddRune (ch); + } + + /// + /// Removes the SetNeedsDisplay and the ChildNeedsDisplay setting on this view. + /// + protected void ClearNeedsDisplay () + { + NeedDisplay = Rect.Empty; + childNeedsDisplay = false; + } + + /// + /// Performs a redraw of this view and its subviews, only redraws the views that have been flagged for a re-display. + /// + /// The region to redraw, this is relative to the view itself. + /// + /// + /// Views should set the color that they want to use on entry, as otherwise this will inherit + /// the last color that was set globaly on the driver. + /// + /// + public virtual void Redraw (Rect region) + { + var clipRect = new Rect (Point.Empty, frame.Size); + + if (subviews != null) { + foreach (var view in subviews) { + if (view.NeedDisplay != null && (!view.NeedDisplay.IsEmpty || view.childNeedsDisplay)) { + if (view.Frame.IntersectsWith (clipRect) && view.Frame.IntersectsWith (region)) { + + // FIXED: optimize this by computing the intersection of region and view.Bounds + if (view.layoutNeeded) + view.LayoutSubviews (); + Application.CurrentView = view; + view.Redraw (view.Bounds); + } + view.NeedDisplay = Rect.Empty; + view.childNeedsDisplay = false; + } + } + } + ClearNeedsDisplay (); + } + + /// + /// Focuses the specified sub-view. + /// + /// View. + public void SetFocus (View view) + { + if (view == null) + return; + //Console.WriteLine ($"Request to focus {view}"); + if (!view.CanFocus) + return; + if (focused == view) + return; + + // Make sure that this view is a subview + View c; + for (c = view.container; c != null; c = c.container) + if (c == this) + break; + if (c == null) + throw new ArgumentException ("the specified view is not part of the hierarchy of this view"); + + if (focused != null) + focused.HasFocus = false; + + focused = view; + focused.HasFocus = true; + focused.EnsureFocus (); + + // Send focus upwards + SuperView?.SetFocus (this); + } + + /// + /// Specifies the event arguments for + /// + public class KeyEventEventArgs : EventArgs { + /// + /// Constructs. + /// + /// + public KeyEventEventArgs (KeyEvent ke) => KeyEvent = ke; + /// + /// The for the event. + /// + public KeyEvent KeyEvent { get; set; } + /// + /// Indicates if the current Key event has already been processed and the driver should stop notifying any other event subscriber. + /// Its important to set this value to true specially when updating any View's layout from inside the subscriber method. + /// + public bool Handled { get; set; } = false; + } + + /// + /// Invoked when a character key is pressed and occurs after the key up event. + /// + public event EventHandler KeyPress; + + /// + public override bool ProcessKey (KeyEvent keyEvent) + { + + KeyEventEventArgs args = new KeyEventEventArgs (keyEvent); + KeyPress?.Invoke (this, args); + if (args.Handled) + return true; + if (Focused?.ProcessKey (keyEvent) == true) + return true; + + return false; + } + + /// + public override bool ProcessHotKey (KeyEvent keyEvent) + { + KeyEventEventArgs args = new KeyEventEventArgs (keyEvent); + KeyPress?.Invoke (this, args); + if (args.Handled) + return true; + if (subviews == null || subviews.Count == 0) + return false; + foreach (var view in subviews) + if (view.ProcessHotKey (keyEvent)) + return true; + return false; + } + + /// + public override bool ProcessColdKey (KeyEvent keyEvent) + { + KeyEventEventArgs args = new KeyEventEventArgs (keyEvent); + KeyPress?.Invoke (this, args); + if (args.Handled) + return true; + if (subviews == null || subviews.Count == 0) + return false; + foreach (var view in subviews) + if (view.ProcessColdKey (keyEvent)) + return true; + return false; + } + + /// + /// Invoked when a key is pressed + /// + public event EventHandler KeyDown; + + /// Contains the details about the key that produced the event. + public override bool OnKeyDown (KeyEvent keyEvent) + { + KeyEventEventArgs args = new KeyEventEventArgs (keyEvent); + KeyDown?.Invoke (this, args); + if (args.Handled) + return true; + if (subviews == null || subviews.Count == 0) + return false; + foreach (var view in subviews) + if (view.OnKeyDown (keyEvent)) + return true; + + return false; + } + + /// + /// Invoked when a key is released + /// + public event EventHandler KeyUp; + + /// Contains the details about the key that produced the event. + public override bool OnKeyUp (KeyEvent keyEvent) + { + KeyEventEventArgs args = new KeyEventEventArgs (keyEvent); + KeyUp?.Invoke (this, args); + if (args.Handled) + return true; + if (subviews == null || subviews.Count == 0) + return false; + foreach (var view in subviews) + if (view.OnKeyUp (keyEvent)) + return true; + + return false; + } + + /// + /// Finds the first view in the hierarchy that wants to get the focus if nothing is currently focused, otherwise, it does nothing. + /// + public void EnsureFocus () + { + if (focused == null) + if (FocusDirection == Direction.Forward) + FocusFirst (); + else + FocusLast (); + } + + /// + /// Focuses the first focusable subview if one exists. + /// + public void FocusFirst () + { + if (subviews == null) { + SuperView?.SetFocus (this); + return; + } + + foreach (var view in subviews) { + if (view.CanFocus) { + SetFocus (view); + return; + } + } + } + + /// + /// Focuses the last focusable subview if one exists. + /// + public void FocusLast () + { + if (subviews == null) { + SuperView?.SetFocus (this); + return; + } + + for (int i = subviews.Count; i > 0;) { + i--; + + View v = subviews [i]; + if (v.CanFocus) { + SetFocus (v); + return; + } + } + } + + /// + /// Focuses the previous view. + /// + /// true, if previous was focused, false otherwise. + public bool FocusPrev () + { + FocusDirection = Direction.Backward; + if (subviews == null || subviews.Count == 0) + return false; + + if (focused == null) { + FocusLast (); + return focused != null; + } + int focused_idx = -1; + for (int i = subviews.Count; i > 0;) { + i--; + View w = subviews [i]; + + if (w.HasFocus) { + if (w.FocusPrev ()) + return true; + focused_idx = i; + continue; + } + if (w.CanFocus && focused_idx != -1) { + focused.HasFocus = false; + + if (w != null && w.CanFocus) + w.FocusLast (); + + SetFocus (w); + return true; + } + } + if (focused != null) { + focused.HasFocus = false; + focused = null; + } + return false; + } + + /// + /// Focuses the next view. + /// + /// true, if next was focused, false otherwise. + public bool FocusNext () + { + FocusDirection = Direction.Forward; + if (subviews == null || subviews.Count == 0) + return false; + + if (focused == null) { + FocusFirst (); + return focused != null; + } + int n = subviews.Count; + int focused_idx = -1; + for (int i = 0; i < n; i++) { + View w = subviews [i]; + + if (w.HasFocus) { + if (w.FocusNext ()) + return true; + focused_idx = i; + continue; + } + if (w.CanFocus && focused_idx != -1) { + focused.HasFocus = false; + + if (w != null && w.CanFocus) + w.FocusFirst (); + + SetFocus (w); + return true; + } + } + if (focused != null) { + focused.HasFocus = false; + focused = null; + } + return false; + } + + /// + /// Computes the RelativeLayout for the view, given the frame for its container. + /// + /// The Frame for the host. + internal void RelativeLayout (Rect hostFrame) + { + int w, h, _x, _y; + + if (x is Pos.PosCenter) { + if (width == null) + w = hostFrame.Width; + else + w = width.Anchor (hostFrame.Width); + _x = x.Anchor (hostFrame.Width - w); + } else { + if (x == null) + _x = 0; + else + _x = x.Anchor (hostFrame.Width); + if (width == null) + w = hostFrame.Width; + else + w = width.Anchor (hostFrame.Width - _x); + } + + if (y is Pos.PosCenter) { + if (height == null) + h = hostFrame.Height; + else + h = height.Anchor (hostFrame.Height); + _y = y.Anchor (hostFrame.Height - h); + } else { + if (y == null) + _y = 0; + else + _y = y.Anchor (hostFrame.Height); + if (height == null) + h = hostFrame.Height; + else + h = height.Anchor (hostFrame.Height - _y); + } + Frame = new Rect (_x, _y, w, h); + // layoutNeeded = false; + } + + // https://en.wikipedia.org/wiki/Topological_sorting + List TopologicalSort (HashSet nodes, HashSet<(View From, View To)> edges) + { + var result = new List (); + + // Set of all nodes with no incoming edges + var S = new HashSet (nodes.Where (n => edges.All (e => e.To.Equals (n) == false))); + + while (S.Any ()) { + // remove a node n from S + var n = S.First (); + S.Remove (n); + + // add n to tail of L + if (n != this?.SuperView) + result.Add (n); + + // for each node m with an edge e from n to m do + foreach (var e in edges.Where (e => e.From.Equals (n)).ToArray ()) { + var m = e.To; + + // remove edge e from the graph + edges.Remove (e); + + // if m has no other incoming edges then + if (edges.All (me => me.To.Equals (m) == false) && m != this?.SuperView) { + // insert m into S + S.Add (m); + } + } + } + + // if graph has edges then + if (edges.Any ()) { + // return error (graph has at least one cycle) + return null; + } else { + // return L (a topologically sorted order) + return result; + } + } + + /// + /// This virtual method is invoked when a view starts executing or + /// when the dimensions of the view have changed, for example in + /// response to the container view or terminal resizing. + /// + public virtual void LayoutSubviews () + { + if (!layoutNeeded) + return; + + // Sort out the dependencies of the X, Y, Width, Height properties + var nodes = new HashSet (); + var edges = new HashSet<(View, View)> (); + + foreach (var v in InternalSubviews) { + nodes.Add (v); + if (v.LayoutStyle == LayoutStyle.Computed) { + if (v.X is Pos.PosView vX) + edges.Add ((vX.Target, v)); + if (v.Y is Pos.PosView vY) + edges.Add ((vY.Target, v)); + if (v.Width is Dim.DimView vWidth) + edges.Add ((vWidth.Target, v)); + if (v.Height is Dim.DimView vHeight) + edges.Add ((vHeight.Target, v)); + } + } + + var ordered = TopologicalSort (nodes, edges); + if (ordered == null) + throw new Exception ("There is a recursive cycle in the relative Pos/Dim in the views of " + this); + + foreach (var v in ordered) { + if (v.LayoutStyle == LayoutStyle.Computed) + v.RelativeLayout (Frame); + + v.LayoutSubviews (); + v.layoutNeeded = false; + + } + + if (SuperView == Application.Top && layoutNeeded && ordered.Count == 0 && LayoutStyle == LayoutStyle.Computed) { + RelativeLayout (Frame); + } + + layoutNeeded = false; + } + + /// + public override string ToString () + { + return $"{GetType ().Name}({Id})({Frame})"; + } + + /// + public override bool OnMouseEnter (MouseEvent mouseEvent) + { + if (!base.OnMouseEnter (mouseEvent)) { + MouseEnter?.Invoke (this, mouseEvent); + return false; + } + return true; + } + + /// + public override bool OnMouseLeave (MouseEvent mouseEvent) + { + if (!base.OnMouseLeave (mouseEvent)) { + MouseLeave?.Invoke (this, mouseEvent); + return false; + } + return true; + } + } +} diff --git a/Terminal.Gui/Core/Window.cs b/Terminal.Gui/Core/Window.cs new file mode 100644 index 000000000..f2584479f --- /dev/null +++ b/Terminal.Gui/Core/Window.cs @@ -0,0 +1,250 @@ +// +// Authors: +// Miguel de Icaza (miguel@gnome.org) +// +using System.Collections; +using NStack; + +namespace Terminal.Gui { + /// + /// A that draws a frame around its region and has a "ContentView" subview where the contents are added. + /// + public class Window : Toplevel, IEnumerable { + View contentView; + ustring title; + + /// + /// The title to be displayed for this window. + /// + /// The title. + 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 + } + + /// + /// Initializes a new instance of the class with an optional title and a set frame. + /// + /// Frame. + /// Title. + public Window (Rect frame, ustring title = null) : this (frame, title, padding: 0) + { + } + + /// + /// Initializes a new instance of the class with an optional title. + /// + /// Title. + public Window (ustring title = null) : this (title, padding: 0) + { + } + + int padding; + /// + /// Initializes a new instance of the with + /// the specified frame for its location, with the specified border + /// an optional title. + /// + /// Frame. + /// Number of characters to use for padding of the drawn frame. + /// Title. + 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); + } + + /// + /// Initializes a new instance of the with + /// the specified frame for its location, with the specified border + /// an optional title. + /// + /// Number of characters to use for padding of the drawn frame. + /// Title. + 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); + } + + /// + /// Enumerates the various s in the embedded . + /// + /// The enumerator. + public new IEnumerator GetEnumerator () + { + return contentView.GetEnumerator (); + } + + void DrawFrame (bool fill = true) + { + DrawFrame (new Rect (0, 0, Frame.Width, Frame.Height), padding, fill: fill); + } + + /// + /// Add the specified view to the . + /// + /// View to add to the window. + public override void Add (View view) + { + contentView.Add (view); + if (view.CanFocus) + CanFocus = true; + } + + + /// + /// Removes a widget from this container. + /// + /// + /// + 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; + } + + /// + /// Removes all widgets from this container. + /// + /// + /// + public override void RemoveAll () + { + contentView.RemoveAll (); + } + + /// + public override void Redraw (Rect bounds) + { + Application.CurrentView = this; + + if (NeedDisplay != null && !NeedDisplay.IsEmpty) { + DrawFrameWindow (); + } + contentView.Redraw (contentView.Bounds); + ClearNeedsDisplay (); + DrawFrameWindow (false); + + void DrawFrameWindow (bool fill = true) + { + Driver.SetAttribute (ColorScheme.Normal); + DrawFrame (fill); + if (HasFocus) + Driver.SetAttribute (ColorScheme.HotNormal); + var width = Frame.Width - (padding + 2) * 2; + if (Title != null && width > 4) { + Move (1 + padding, padding); + Driver.AddRune (' '); + var str = Title.Length >= width ? Title [0, width - 2] : Title; + Driver.AddStr (str); + Driver.AddRune (' '); + } + 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; + /// + 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; + } + + } +} diff --git a/Terminal.Gui/MonoCurses/README.md b/Terminal.Gui/MonoCurses/README.md deleted file mode 100644 index 4ea82ddaf..000000000 --- a/Terminal.Gui/MonoCurses/README.md +++ /dev/null @@ -1,13 +0,0 @@ -This directory contains a copy of the MonoCurses binding from: - -http://github.com/mono/mono-curses - -The source code has been exported in a way that the MonoCurses -API is kept private and does not surface to the user, this is -done with the command: - -``` - make publish-to-gui -``` - -In the MonoCurses package diff --git a/Terminal.Gui/MonoCurses/mainloop.cs b/Terminal.Gui/MonoCurses/mainloop.cs deleted file mode 100644 index eda74d73f..000000000 --- a/Terminal.Gui/MonoCurses/mainloop.cs +++ /dev/null @@ -1,518 +0,0 @@ -// -// mainloop.cs: Simple managed mainloop implementation. -// -// Authors: -// Miguel de Icaza (miguel.de.icaza@gmail.com) -// -// Copyright (C) 2011 Novell (http://www.novell.com) -// -// Permission is hereby granted, free of charge, to any person obtaining -// a copy of this software and associated documentation files (the -// "Software"), to deal in the Software without restriction, including -// without limitation the rights to use, copy, modify, merge, publish, -// distribute, sublicense, and/or sell copies of the Software, and to -// permit persons to whom the Software is furnished to do so, subject to -// the following conditions: -// -// The above copyright notice and this permission notice shall be -// included in all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND -// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE -// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION -// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION -// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -// -using System.Collections.Generic; -using System; -using System.Runtime.InteropServices; -using System.Threading; - -namespace Mono.Terminal { - - /// - /// Public interface to create your own platform specific main loop driver. - /// - public interface IMainLoopDriver { - /// - /// Initializes the main loop driver, gets the calling main loop for the initialization. - /// - /// Main loop. - void Setup (MainLoop mainLoop); - - /// - /// Wakes up the mainloop that might be waiting on input, must be thread safe. - /// - void Wakeup (); - - /// - /// Must report whether there are any events pending, or even block waiting for events. - /// - /// true, if there were pending events, false otherwise. - /// If set to true wait until an event is available, otherwise return immediately. - bool EventsPending (bool wait); - - /// - /// The interation function. - /// - void MainIteration (); - } - - /// - /// Unix main loop, suitable for using on Posix systems - /// - /// - /// In addition to the general functions of the mainloop, the Unix version - /// can watch file descriptors using the AddWatch methods. - /// - public class UnixMainLoop : IMainLoopDriver { - [StructLayout (LayoutKind.Sequential)] - struct Pollfd { - public int fd; - public short events, revents; - } - - /// - /// Condition on which to wake up from file descriptor activity. These match the Linux/BSD poll definitions. - /// - [Flags] - public enum Condition : short { - /// - /// There is data to read - /// - PollIn = 1, - /// - /// Writing to the specified descriptor will not block - /// - PollOut = 4, - /// - /// There is urgent data to read - /// - PollPri = 2, - /// - /// Error condition on output - /// - PollErr = 8, - /// - /// Hang-up on output - /// - PollHup = 16, - /// - /// File descriptor is not open. - /// - PollNval = 32 - } - - class Watch { - public int File; - public Condition Condition; - public Func Callback; - } - - Dictionary descriptorWatchers = new Dictionary (); - - [DllImport ("libc")] - extern static int poll ([In, Out]Pollfd [] ufds, uint nfds, int timeout); - - [DllImport ("libc")] - extern static int pipe ([In, Out]int [] pipes); - - [DllImport ("libc")] - extern static int read (int fd, IntPtr buf, IntPtr n); - - [DllImport ("libc")] - extern static int write (int fd, IntPtr buf, IntPtr n); - - Pollfd [] pollmap; - bool poll_dirty = true; - int [] wakeupPipes = new int [2]; - static IntPtr ignore = Marshal.AllocHGlobal (1); - MainLoop mainLoop; - - void IMainLoopDriver.Wakeup () - { - write (wakeupPipes [1], ignore, (IntPtr) 1); - } - - void IMainLoopDriver.Setup (MainLoop mainLoop) { - this.mainLoop = mainLoop; - pipe (wakeupPipes); - AddWatch (wakeupPipes [0], Condition.PollIn, ml => { - read (wakeupPipes [0], ignore, (IntPtr)1); - return true; - }); - } - - /// - /// Removes an active watch from the mainloop. - /// - /// - /// The token parameter is the value returned from AddWatch - /// - public void RemoveWatch (object token) - { - var watch = token as Watch; - if (watch == null) - return; - descriptorWatchers.Remove (watch.File); - } - - /// - /// Watches a file descriptor for activity. - /// - /// - /// When the condition is met, the provided callback - /// is invoked. If the callback returns false, the - /// watch is automatically removed. - /// - /// The return value is a token that represents this watch, you can - /// use this token to remove the watch by calling RemoveWatch. - /// - public object AddWatch (int fileDescriptor, Condition condition, Func callback) - { - if (callback == null) - throw new ArgumentNullException (nameof(callback)); - - var watch = new Watch () { Condition = condition, Callback = callback, File = fileDescriptor }; - descriptorWatchers [fileDescriptor] = watch; - poll_dirty = true; - return watch; - } - - void UpdatePollMap () - { - if (!poll_dirty) - return; - poll_dirty = false; - - pollmap = new Pollfd [descriptorWatchers.Count]; - int i = 0; - foreach (var fd in descriptorWatchers.Keys) { - pollmap [i].fd = fd; - pollmap [i].events = (short)descriptorWatchers [fd].Condition; - i++; - } - } - - bool IMainLoopDriver.EventsPending (bool wait) - { - long now = DateTime.UtcNow.Ticks; - - int pollTimeout, n; - if (mainLoop.timeouts.Count > 0) { - pollTimeout = (int)((mainLoop.timeouts.Keys [0] - now) / TimeSpan.TicksPerMillisecond); - if (pollTimeout < 0) - return true; - - } else - pollTimeout = -1; - - if (!wait) - pollTimeout = 0; - - UpdatePollMap (); - - while (true) { - if (wait && pollTimeout == -1) { - pollTimeout = 0; - } - n = poll (pollmap, (uint)pollmap.Length, pollTimeout); - if (pollmap != null) { - break; - } - if (mainLoop.timeouts.Count > 0 || mainLoop.idleHandlers.Count > 0) { - return true; - } - } - int ic; - lock (mainLoop.idleHandlers) - ic = mainLoop.idleHandlers.Count; - return n > 0 || mainLoop.timeouts.Count > 0 && ((mainLoop.timeouts.Keys [0] - DateTime.UtcNow.Ticks) < 0) || ic > 0; - } - - void IMainLoopDriver.MainIteration () - { - if (pollmap != null) { - foreach (var p in pollmap) { - Watch watch; - - if (p.revents == 0) - continue; - - if (!descriptorWatchers.TryGetValue (p.fd, out watch)) - continue; - if (!watch.Callback (this.mainLoop)) - descriptorWatchers.Remove (p.fd); - } - } - } - } - - /// - /// Mainloop intended to be used with the .NET System.Console API, and can - /// be used on Windows and Unix, it is cross platform but lacks things like - /// file descriptor monitoring. - /// - class NetMainLoop : IMainLoopDriver { - AutoResetEvent keyReady = new AutoResetEvent (false); - AutoResetEvent waitForProbe = new AutoResetEvent (false); - ConsoleKeyInfo? windowsKeyResult = null; - public Action WindowsKeyPressed; - MainLoop mainLoop; - - public NetMainLoop () - { - } - - void WindowsKeyReader () - { - while (true) { - waitForProbe.WaitOne (); - windowsKeyResult = Console.ReadKey (true); - keyReady.Set (); - } - } - - void IMainLoopDriver.Setup (MainLoop mainLoop) - { - this.mainLoop = mainLoop; - Thread readThread = new Thread (WindowsKeyReader); - readThread.Start (); - } - - void IMainLoopDriver.Wakeup () - { - } - - bool IMainLoopDriver.EventsPending (bool wait) - { - long now = DateTime.UtcNow.Ticks; - - int waitTimeout; - if (mainLoop.timeouts.Count > 0) { - waitTimeout = (int)((mainLoop.timeouts.Keys [0] - now) / TimeSpan.TicksPerMillisecond); - if (waitTimeout < 0) - return true; - } else - waitTimeout = -1; - - if (!wait) - waitTimeout = 0; - - windowsKeyResult = null; - waitForProbe.Set (); - keyReady.WaitOne (waitTimeout); - return windowsKeyResult.HasValue; - } - - void IMainLoopDriver.MainIteration () - { - if (windowsKeyResult.HasValue) { - if (WindowsKeyPressed!= null) - WindowsKeyPressed (windowsKeyResult.Value); - windowsKeyResult = null; - } - } - } - - /// - /// Simple main loop implementation that can be used to monitor - /// file descriptor, run timers and idle handlers. - /// - /// - /// Monitoring of file descriptors is only available on Unix, there - /// does not seem to be a way of supporting this on Windows. - /// - public class MainLoop { - internal class Timeout { - public TimeSpan Span; - public Func Callback; - } - - internal SortedList timeouts = new SortedList (); - internal List> idleHandlers = new List> (); - - IMainLoopDriver driver; - - /// - /// The current IMainLoopDriver in use. - /// - /// The driver. - public IMainLoopDriver Driver => driver; - - /// - /// Creates a new Mainloop, to run it you must provide a driver, and choose - /// one of the implementations UnixMainLoop, NetMainLoop or WindowsMainLoop. - /// - public MainLoop (IMainLoopDriver driver) - { - this.driver = driver; - driver.Setup (this); - } - - /// - /// Runs @action on the thread that is processing events - /// - public void Invoke (Action action) - { - AddIdle (()=> { - action (); - return false; - }); - } - - /// - /// Executes the specified @idleHandler on the idle loop. The return value is a token to remove it. - /// - public Func AddIdle (Func idleHandler) - { - lock (idleHandlers) - idleHandlers.Add (idleHandler); - - return idleHandler; - } - - /// - /// Removes the specified idleHandler from processing. - /// - public void RemoveIdle (Func idleHandler) - { - lock (idleHandler) - idleHandlers.Remove (idleHandler); - } - - void AddTimeout (TimeSpan time, Timeout timeout) - { - timeouts.Add ((DateTime.UtcNow + time).Ticks, timeout); - } - - /// - /// Adds a timeout to the mainloop. - /// - /// - /// When time time specified passes, the callback will be invoked. - /// If the callback returns true, the timeout will be reset, repeating - /// the invocation. If it returns false, the timeout will stop. - /// - /// The returned value is a token that can be used to stop the timeout - /// by calling RemoveTimeout. - /// - public object AddTimeout (TimeSpan time, Func callback) - { - if (callback == null) - throw new ArgumentNullException (nameof (callback)); - var timeout = new Timeout () { - Span = time, - Callback = callback - }; - AddTimeout (time, timeout); - return timeout; - } - - /// - /// Removes a previously scheduled timeout - /// - /// - /// The token parameter is the value returned by AddTimeout. - /// - public void RemoveTimeout (object token) - { - var idx = timeouts.IndexOfValue (token as Timeout); - if (idx == -1) - return; - timeouts.RemoveAt (idx); - } - - void RunTimers () - { - long now = DateTime.UtcNow.Ticks; - var copy = timeouts; - timeouts = new SortedList (); - foreach (var k in copy.Keys){ - var timeout = copy [k]; - if (k < now) { - if (timeout.Callback (this)) - AddTimeout (timeout.Span, timeout); - } else - timeouts.Add (k, timeout); - } - } - - void RunIdle () - { - List> iterate; - lock (idleHandlers){ - iterate = idleHandlers; - idleHandlers = new List> (); - } - - foreach (var idle in iterate){ - if (idle ()) - lock (idleHandlers) - idleHandlers.Add (idle); - } - } - - bool running; - - /// - /// Stops the mainloop. - /// - public void Stop () - { - running = false; - driver.Wakeup (); - } - - /// - /// Determines whether there are pending events to be processed. - /// - /// - /// You can use this method if you want to probe if events are pending. - /// Typically used if you need to flush the input queue while still - /// running some of your own code in your main thread. - /// - public bool EventsPending (bool wait = false) - { - return driver.EventsPending (wait); - } - - /// - /// Runs one iteration of timers and file watches - /// - /// - /// You use this to process all pending events (timers, idle handlers and file watches). - /// - /// You can use it like this: - /// while (main.EvensPending ()) MainIteration (); - /// - public void MainIteration () - { - if (timeouts.Count > 0) - RunTimers (); - - driver.MainIteration (); - - lock (idleHandlers){ - if (idleHandlers.Count > 0) - RunIdle(); - } - } - - /// - /// Runs the mainloop. - /// - public void Run () - { - bool prev = running; - running = true; - while (running){ - EventsPending (true); - MainIteration (); - } - running = prev; - } - } -} diff --git a/Terminal.Gui/Terminal.Gui.csproj b/Terminal.Gui/Terminal.Gui.csproj index c6f2656a9..01697a423 100644 --- a/Terminal.Gui/Terminal.Gui.csproj +++ b/Terminal.Gui/Terminal.Gui.csproj @@ -102,15 +102,12 @@ - - - - + diff --git a/Terminal.Gui/Dialogs/Dialog.cs b/Terminal.Gui/Windows/Dialog.cs similarity index 100% rename from Terminal.Gui/Dialogs/Dialog.cs rename to Terminal.Gui/Windows/Dialog.cs diff --git a/Terminal.Gui/Dialogs/FileDialog.cs b/Terminal.Gui/Windows/FileDialog.cs similarity index 100% rename from Terminal.Gui/Dialogs/FileDialog.cs rename to Terminal.Gui/Windows/FileDialog.cs diff --git a/Terminal.Gui/Dialogs/MessageBox.cs b/Terminal.Gui/Windows/MessageBox.cs similarity index 100% rename from Terminal.Gui/Dialogs/MessageBox.cs rename to Terminal.Gui/Windows/MessageBox.cs