diff --git a/Terminal.Gui/Core/Graphs/LineCanvas.cs b/Terminal.Gui/Core/Graphs/LineCanvas.cs
new file mode 100644
index 000000000..04583518e
--- /dev/null
+++ b/Terminal.Gui/Core/Graphs/LineCanvas.cs
@@ -0,0 +1,514 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Terminal.Gui.Graphs {
+
+
+ ///
+ /// Facilitates box drawing and line intersection detection
+ /// and rendering. Does not support diagonal lines.
+ ///
+ public class LineCanvas {
+
+
+ private List lines = new List ();
+
+ ///
+ /// Add a new line to the canvas starting at .
+ /// Use positive for Right and negative for Left
+ /// when is .
+ /// Use positive for Down and negative for Up
+ /// when is .
+ ///
+ /// Starting point.
+ /// Length of line. 0 for a dot.
+ /// Positive for Down/Right. Negative for Up/Left.
+ /// Direction of the line.
+ /// The style of line to use
+ public void AddLine (Point from, int length, Orientation orientation, BorderStyle style)
+ {
+ lines.Add (new StraightLine (from, length, orientation, style));
+ }
+ ///
+ /// Evaluate all currently defined lines that lie within
+ /// and generate a 'bitmap' that
+ /// shows what characters (if any) should be rendered at each
+ /// point so that all lines connect up correctly with appropriate
+ /// intersection symbols.
+ ///
+ ///
+ ///
+ /// Map as 2D array where first index is rows and second is column
+ public Rune? [,] GenerateImage (Rect inArea)
+ {
+ Rune? [,] canvas = new Rune? [inArea.Height, inArea.Width];
+
+ // walk through each pixel of the bitmap
+ for (int y = 0; y < inArea.Height; y++) {
+ for (int x = 0; x < inArea.Width; x++) {
+
+ var intersects = lines
+ .Select (l => l.Intersects (x, y))
+ .Where (i => i != null)
+ .ToArray ();
+
+ // TODO: use Driver and LineStyle to map
+ canvas [y, x] = GetRuneForIntersects (Application.Driver, intersects);
+
+ }
+ }
+
+ return canvas;
+ }
+
+ ///
+ /// Draws all the lines that lie within the onto
+ /// the client area. This method should be called from
+ /// .
+ ///
+ ///
+ ///
+ public void Draw (View view, Rect bounds)
+ {
+ var runes = GenerateImage (bounds);
+
+ for (int y = bounds.Y; y < bounds.Height; y++) {
+ for (int x = bounds.X; x < bounds.Width; x++) {
+ var rune = runes [y, x];
+
+ if (rune.HasValue) {
+ view.AddRune (x, y, rune.Value);
+ }
+ }
+ }
+ }
+
+ private Rune? GetRuneForIntersects (ConsoleDriver driver, IntersectionDefinition [] intersects)
+ {
+ if (!intersects.Any ())
+ return null;
+
+ var runeType = GetRuneTypeForIntersects (intersects);
+ var useDouble = intersects.Any (i => i.Line.Style == BorderStyle.Double && i.Line.Length != 0);
+ var useRounded = intersects.Any (i => i.Line.Style == BorderStyle.Rounded && i.Line.Length != 0);
+
+ switch (runeType) {
+ case IntersectionRuneType.None:
+ return null;
+ case IntersectionRuneType.Dot:
+ return (Rune)'.';
+ case IntersectionRuneType.ULCorner:
+ return useDouble ? driver.ULDCorner : useRounded ? driver.ULRCorner : driver.ULCorner;
+ case IntersectionRuneType.URCorner:
+ return useDouble ? driver.URDCorner : useRounded ? driver.URRCorner : driver.URCorner;
+ case IntersectionRuneType.LLCorner:
+ return useDouble ? driver.LLDCorner : useRounded ? driver.LLRCorner : driver.LLCorner;
+ case IntersectionRuneType.LRCorner:
+ return useDouble ? driver.LRDCorner : useRounded ? driver.LRRCorner : driver.LRCorner;
+ case IntersectionRuneType.TopTee:
+ return useDouble ? '╦' : driver.TopTee;
+ case IntersectionRuneType.BottomTee:
+ return useDouble ? '╩' : driver.BottomTee;
+ case IntersectionRuneType.RightTee:
+ return useDouble ? '╣' : driver.RightTee;
+ case IntersectionRuneType.LeftTee:
+ return useDouble ? '╠' : driver.LeftTee;
+ case IntersectionRuneType.Crosshair:
+ return useDouble ? '╬' : '┼';
+ case IntersectionRuneType.HLine:
+ return useDouble ? driver.HDLine : driver.HLine;
+ case IntersectionRuneType.VLine:
+ return useDouble ? driver.VDLine : driver.VLine;
+ default: throw new ArgumentOutOfRangeException (nameof (runeType));
+ }
+
+ }
+
+
+ private IntersectionRuneType GetRuneTypeForIntersects (IntersectionDefinition [] intersects)
+ {
+ if(intersects.All(i=>i.Line.Length == 0)) {
+ return IntersectionRuneType.Dot;
+ }
+
+ // ignore dots
+ intersects = intersects.Where (i => i.Type != IntersectionType.Dot).ToArray ();
+
+ var set = new HashSet (intersects.Select (i => i.Type));
+
+ #region Crosshair Conditions
+ if (Has (set,
+ IntersectionType.PassOverHorizontal,
+ IntersectionType.PassOverVertical
+ )) {
+ return IntersectionRuneType.Crosshair;
+ }
+
+ if (Has (set,
+ IntersectionType.PassOverVertical,
+ IntersectionType.StartLeft,
+ IntersectionType.StartRight
+ )) {
+ return IntersectionRuneType.Crosshair;
+ }
+
+ if (Has (set,
+ IntersectionType.PassOverHorizontal,
+ IntersectionType.StartUp,
+ IntersectionType.StartDown
+ )) {
+ return IntersectionRuneType.Crosshair;
+ }
+
+
+ if (Has (set,
+ IntersectionType.StartLeft,
+ IntersectionType.StartRight,
+ IntersectionType.StartUp,
+ IntersectionType.StartDown)) {
+ return IntersectionRuneType.Crosshair;
+ }
+ #endregion
+
+
+ #region Corner Conditions
+ if (Exactly (set,
+ IntersectionType.StartRight,
+ IntersectionType.StartDown)) {
+ return IntersectionRuneType.ULCorner;
+ }
+
+ if (Exactly (set,
+ IntersectionType.StartLeft,
+ IntersectionType.StartDown)) {
+ return IntersectionRuneType.URCorner;
+ }
+
+ if (Exactly (set,
+ IntersectionType.StartUp,
+ IntersectionType.StartLeft)) {
+ return IntersectionRuneType.LRCorner;
+ }
+
+ if (Exactly (set,
+ IntersectionType.StartUp,
+ IntersectionType.StartRight)) {
+ return IntersectionRuneType.LLCorner;
+ }
+ #endregion Corner Conditions
+
+ #region T Conditions
+ if (Has (set,
+ IntersectionType.PassOverHorizontal,
+ IntersectionType.StartDown)) {
+ return IntersectionRuneType.TopTee;
+ }
+ if (Has (set,
+ IntersectionType.StartRight,
+ IntersectionType.StartLeft,
+ IntersectionType.StartDown)) {
+ return IntersectionRuneType.TopTee;
+ }
+
+ if (Has (set,
+ IntersectionType.PassOverHorizontal,
+ IntersectionType.StartUp)) {
+ return IntersectionRuneType.BottomTee;
+ }
+ if (Has (set,
+ IntersectionType.StartRight,
+ IntersectionType.StartLeft,
+ IntersectionType.StartUp)) {
+ return IntersectionRuneType.BottomTee;
+ }
+
+
+ if (Has (set,
+ IntersectionType.PassOverVertical,
+ IntersectionType.StartRight)) {
+ return IntersectionRuneType.LeftTee;
+ }
+ if (Has (set,
+ IntersectionType.StartRight,
+ IntersectionType.StartDown,
+ IntersectionType.StartUp)) {
+ return IntersectionRuneType.LeftTee;
+ }
+
+
+ if (Has (set,
+ IntersectionType.PassOverVertical,
+ IntersectionType.StartLeft)) {
+ return IntersectionRuneType.RightTee;
+ }
+ if (Has (set,
+ IntersectionType.StartLeft,
+ IntersectionType.StartDown,
+ IntersectionType.StartUp)) {
+ return IntersectionRuneType.RightTee;
+ }
+ #endregion
+
+ if (All (intersects, Orientation.Horizontal)) {
+ return IntersectionRuneType.HLine;
+ }
+
+ if (All (intersects, Orientation.Vertical)) {
+ return IntersectionRuneType.VLine;
+ }
+
+ return IntersectionRuneType.Dot;
+ }
+
+ private bool All (IntersectionDefinition [] intersects, Orientation orientation)
+ {
+ return intersects.All (i => i.Line.Orientation == orientation);
+ }
+
+ ///
+ /// Returns true if the collection has all the
+ /// specified (i.e. AND).
+ ///
+ ///
+ ///
+ ///
+ private bool Has (HashSet intersects, params IntersectionType [] types)
+ {
+ return types.All (t => intersects.Contains (t));
+ }
+
+ ///
+ /// Returns true if all requested appear in
+ /// and there are no additional
+ ///
+ ///
+ ///
+ ///
+ private bool Exactly (HashSet intersects, params IntersectionType [] types)
+ {
+ return intersects.SetEquals (types);
+ }
+
+ class IntersectionDefinition {
+ ///
+ /// The point at which the intersection happens
+ ///
+ public Point Point { get; }
+
+ ///
+ /// Defines how position relates
+ /// to .
+ ///
+ public IntersectionType Type { get; }
+
+ ///
+ /// The line that intersects
+ ///
+ public StraightLine Line { get; }
+
+ public IntersectionDefinition (Point point, IntersectionType type, StraightLine line)
+ {
+ Point = point;
+ Type = type;
+ Line = line;
+ }
+ }
+
+ ///
+ /// The type of Rune that we will use before considering
+ /// double width, curved borders etc
+ ///
+ enum IntersectionRuneType {
+ None,
+ Dot,
+ ULCorner,
+ URCorner,
+ LLCorner,
+ LRCorner,
+ TopTee,
+ BottomTee,
+ RightTee,
+ LeftTee,
+ Crosshair,
+ HLine,
+ VLine,
+ }
+
+ enum IntersectionType {
+ ///
+ /// There is no intersection
+ ///
+ None,
+
+ ///
+ /// A line passes directly over this point traveling along
+ /// the horizontal axis
+ ///
+ PassOverHorizontal,
+
+ ///
+ /// A line passes directly over this point traveling along
+ /// the vertical axis
+ ///
+ PassOverVertical,
+
+ ///
+ /// A line starts at this point and is traveling up
+ ///
+ StartUp,
+
+ ///
+ /// A line starts at this point and is traveling right
+ ///
+ StartRight,
+
+ ///
+ /// A line starts at this point and is traveling down
+ ///
+ StartDown,
+
+ ///
+ /// A line starts at this point and is traveling left
+ ///
+ StartLeft,
+
+ ///
+ /// A line exists at this point who has 0 length
+ ///
+ Dot
+ }
+
+ class StraightLine {
+ public Point Start { get; }
+ public int Length { get; }
+ public Orientation Orientation { get; }
+ public BorderStyle Style { get; }
+
+ public StraightLine (Point start, int length, Orientation orientation, BorderStyle style)
+ {
+ this.Start = start;
+ this.Length = length;
+ this.Orientation = orientation;
+ this.Style = style;
+ }
+
+ internal IntersectionDefinition Intersects (int x, int y)
+ {
+ if (IsDot ()) {
+ if (StartsAt (x, y)) {
+ return new IntersectionDefinition (Start, IntersectionType.Dot, this);
+ } else {
+ return null;
+ }
+ }
+
+ switch (Orientation) {
+ case Orientation.Horizontal: return IntersectsHorizontally (x, y);
+ case Orientation.Vertical: return IntersectsVertically (x, y);
+ default: throw new ArgumentOutOfRangeException (nameof (Orientation));
+ }
+
+ }
+
+ private IntersectionDefinition IntersectsHorizontally (int x, int y)
+ {
+ if (Start.Y != y) {
+ return null;
+ } else {
+ if (StartsAt (x, y)) {
+
+ return new IntersectionDefinition (
+ Start,
+ Length < 0 ? IntersectionType.StartLeft : IntersectionType.StartRight,
+ this
+ );
+
+ }
+
+ if (EndsAt (x, y)) {
+
+ return new IntersectionDefinition (
+ Start,
+ Length < 0 ? IntersectionType.StartRight : IntersectionType.StartLeft,
+ this
+ );
+
+ } else {
+ var xmin = Math.Min (Start.X, Start.X + Length);
+ var xmax = Math.Max (Start.X, Start.X + Length);
+
+ if (xmin < x && xmax > x) {
+ return new IntersectionDefinition (
+ new Point (x, y),
+ IntersectionType.PassOverHorizontal,
+ this
+ );
+ }
+ }
+
+ return null;
+ }
+ }
+
+ private IntersectionDefinition IntersectsVertically (int x, int y)
+ {
+ if (Start.X != x) {
+ return null;
+ } else {
+ if (StartsAt (x, y)) {
+
+ return new IntersectionDefinition (
+ Start,
+ Length < 0 ? IntersectionType.StartUp : IntersectionType.StartDown,
+ this
+ );
+
+ }
+
+ if (EndsAt (x, y)) {
+
+ return new IntersectionDefinition (
+ Start,
+ Length < 0 ? IntersectionType.StartDown : IntersectionType.StartUp,
+ this
+ );
+
+ } else {
+ var ymin = Math.Min (Start.Y, Start.Y + Length);
+ var ymax = Math.Max (Start.Y, Start.Y + Length);
+
+ if (ymin < y && ymax > y) {
+ return new IntersectionDefinition (
+ new Point (x, y),
+ IntersectionType.PassOverVertical,
+ this
+ );
+ }
+ }
+
+ return null;
+ }
+ }
+
+ private bool EndsAt (int x, int y)
+ {
+ if (Orientation == Orientation.Horizontal) {
+ return Start.X + Length == x && Start.Y == y;
+ }
+
+ return Start.X == x && Start.Y + Length == y;
+ }
+
+ private bool StartsAt (int x, int y)
+ {
+ return Start.X == x && Start.Y == y;
+ }
+
+ private bool IsDot ()
+ {
+ return Length == 0;
+ }
+ }
+ }
+}
diff --git a/Terminal.Gui/Core/View.cs b/Terminal.Gui/Core/View.cs
index c7104fcdb..8734261c0 100644
--- a/Terminal.Gui/Core/View.cs
+++ b/Terminal.Gui/Core/View.cs
@@ -446,14 +446,11 @@ namespace Terminal.Gui {
public virtual Rect Frame {
get => frame;
set {
- if (SuperView != null) {
- SuperView.SetNeedsDisplay (frame);
- SuperView.SetNeedsDisplay (value);
- }
+ var rect = GetMaxNeedDisplay (frame, value);
frame = new Rect (value.X, value.Y, Math.Max (value.Width, 0), Math.Max (value.Height, 0));
TextFormatter.Size = GetBoundsTextFormatterSize ();
SetNeedsLayout ();
- SetNeedsDisplay (frame);
+ SetNeedsDisplay (rect);
}
}
@@ -811,6 +808,7 @@ namespace Terminal.Gui {
{
var actX = x is Pos.PosAbsolute ? x.Anchor (0) : frame.X;
var actY = y is Pos.PosAbsolute ? y.Anchor (0) : frame.Y;
+ Rect oldFrame = frame;
if (AutoSize) {
var s = GetAutoSize ();
@@ -825,7 +823,21 @@ namespace Terminal.Gui {
}
TextFormatter.Size = GetBoundsTextFormatterSize ();
SetNeedsLayout ();
- SetNeedsDisplay ();
+ SetNeedsDisplay (GetMaxNeedDisplay (oldFrame, frame));
+ }
+
+ Rect GetMaxNeedDisplay (Rect oldFrame, Rect newFrame)
+ {
+ var rect = new Rect () {
+ X = Math.Min (oldFrame.X, newFrame.X),
+ Y = Math.Min (oldFrame.Y, newFrame.Y),
+ Width = Math.Max (oldFrame.Width, newFrame.Width),
+ Height = Math.Max (oldFrame.Height, newFrame.Height)
+ };
+ rect.Width += Math.Max (oldFrame.X - newFrame.X, 0);
+ rect.Height += Math.Max (oldFrame.Y - newFrame.Y, 0);
+
+ return rect;
}
void TextFormatter_HotKeyChanged (Key obj)
@@ -1537,12 +1549,7 @@ namespace Terminal.Gui {
// Draw the subview
// Use the view's bounds (view-relative; Location will always be (0,0)
if (view.Visible && view.Frame.Width > 0 && view.Frame.Height > 0) {
- var rect = new Rect () {
- X = Math.Min (view.Bounds.X, view.NeedDisplay.X),
- Y = Math.Min (view.Bounds.Y, view.NeedDisplay.Y),
- Width = Math.Max (view.Bounds.Width, view.NeedDisplay.Width),
- Height = Math.Max (view.Bounds.Height, view.NeedDisplay.Height)
- };
+ var rect = view.Bounds;
view.OnDrawContent (rect);
view.Redraw (rect);
view.OnDrawContentComplete (rect);
diff --git a/UICatalog/Scenarios/LineDrawing.cs b/UICatalog/Scenarios/LineDrawing.cs
new file mode 100644
index 000000000..f3adac86d
--- /dev/null
+++ b/UICatalog/Scenarios/LineDrawing.cs
@@ -0,0 +1,201 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection.Metadata.Ecma335;
+using Terminal.Gui;
+using Terminal.Gui.Graphs;
+
+namespace UICatalog.Scenarios {
+
+ [ScenarioMetadata (Name: "Line Drawing", Description: "Demonstrates LineCanvas.")]
+ [ScenarioCategory ("Controls")]
+ [ScenarioCategory ("Layout")]
+ public class LineDrawing : Scenario {
+
+ public override void Setup ()
+ {
+ var toolsWidth = 8;
+
+ var canvas = new DrawingArea {
+ Width = Dim.Fill (-toolsWidth),
+ Height = Dim.Fill ()
+ };
+
+ var tools = new ToolsView (toolsWidth) {
+ Y = 1,
+ X = Pos.AnchorEnd (toolsWidth + 1),
+ Height = Dim.Fill (),
+ Width = Dim.Fill ()
+ };
+
+
+ tools.ColorChanged += (c) => canvas.SetColor (c);
+ tools.SetStyle += (b) => canvas.BorderStyle = b;
+
+ Win.Add (canvas);
+ Win.Add (tools);
+ Win.Add (new Label (" -Tools-") { X = Pos.AnchorEnd (toolsWidth + 1) });
+ }
+
+ class ToolsView : View {
+
+ LineCanvas grid;
+ public event Action ColorChanged;
+ public event Action SetStyle;
+
+ Dictionary swatches = new Dictionary {
+ { new Point(1,1),Color.Red},
+ { new Point(3,1),Color.Green},
+ { new Point(5,1),Color.BrightBlue},
+ { new Point(7,1),Color.Black},
+ { new Point(1,3),Color.White},
+ };
+
+ public ToolsView (int width)
+ {
+ grid = new LineCanvas ();
+
+ grid.AddLine (new Point (0, 0), int.MaxValue, Orientation.Vertical, BorderStyle.Single);
+ grid.AddLine (new Point (0, 0), width, Orientation.Horizontal, BorderStyle.Single);
+ grid.AddLine (new Point (width, 0), int.MaxValue, Orientation.Vertical, BorderStyle.Single);
+
+ grid.AddLine (new Point (0, 2), width, Orientation.Horizontal, BorderStyle.Single);
+
+ grid.AddLine (new Point (2, 0), int.MaxValue, Orientation.Vertical, BorderStyle.Single);
+ grid.AddLine (new Point (4, 0), int.MaxValue, Orientation.Vertical, BorderStyle.Single);
+ grid.AddLine (new Point (6, 0), int.MaxValue, Orientation.Vertical, BorderStyle.Single);
+
+ grid.AddLine (new Point (0, 4), width, Orientation.Horizontal, BorderStyle.Single);
+ }
+ public override void Redraw (Rect bounds)
+ {
+ base.Redraw (bounds);
+
+ Driver.SetAttribute (new Terminal.Gui.Attribute (Color.DarkGray, ColorScheme.Normal.Background));
+ grid.Draw (this, bounds);
+
+ foreach (var swatch in swatches) {
+ Driver.SetAttribute (new Terminal.Gui.Attribute (swatch.Value, ColorScheme.Normal.Background));
+ AddRune (swatch.Key.X, swatch.Key.Y, '█');
+ }
+
+ Driver.SetAttribute (new Terminal.Gui.Attribute (ColorScheme.Normal.Foreground, ColorScheme.Normal.Background));
+ AddRune (3, 3, Application.Driver.HDLine);
+ AddRune (5, 3, Application.Driver.HLine);
+ AddRune (7, 3, Application.Driver.ULRCorner);
+ }
+
+ public override bool OnMouseEvent (MouseEvent mouseEvent)
+ {
+ if (mouseEvent.Flags.HasFlag (MouseFlags.Button1Clicked)) {
+ foreach (var swatch in swatches) {
+ if (mouseEvent.X == swatch.Key.X && mouseEvent.Y == swatch.Key.Y) {
+
+ ColorChanged?.Invoke (swatch.Value);
+ return true;
+ }
+ }
+
+ if (mouseEvent.X == 3 && mouseEvent.Y == 3) {
+
+ SetStyle?.Invoke (BorderStyle.Double);
+ return true;
+ }
+ if (mouseEvent.X == 5 && mouseEvent.Y == 3) {
+
+ SetStyle?.Invoke (BorderStyle.Single);
+ return true;
+ }
+ if (mouseEvent.X == 7 && mouseEvent.Y == 3) {
+
+ SetStyle?.Invoke (BorderStyle.Rounded);
+ return true;
+ }
+ }
+
+ return base.OnMouseEvent (mouseEvent);
+ }
+ }
+
+ class DrawingArea : View {
+ ///
+ /// Index into by color.
+ ///
+ Dictionary colorLayers = new Dictionary ();
+ List canvases = new List ();
+ int currentColor;
+
+ Point? currentLineStart = null;
+
+ public BorderStyle BorderStyle { get; internal set; }
+
+ public DrawingArea ()
+ {
+ AddCanvas (Color.White);
+ }
+
+ private void AddCanvas (Color c)
+ {
+ if (colorLayers.ContainsKey (c)) {
+ return;
+ }
+
+ canvases.Add (new LineCanvas ());
+ colorLayers.Add (c, canvases.Count - 1);
+ currentColor = canvases.Count - 1;
+ }
+
+ public override void Redraw (Rect bounds)
+ {
+ base.Redraw (bounds);
+
+ foreach (var kvp in colorLayers) {
+
+ Driver.SetAttribute (new Terminal.Gui.Attribute (kvp.Key, ColorScheme.Normal.Background));
+ canvases [kvp.Value].Draw (this, bounds);
+ }
+ }
+ public override bool OnMouseEvent (MouseEvent mouseEvent)
+ {
+
+ if (mouseEvent.Flags.HasFlag (MouseFlags.Button1Pressed)) {
+ if (currentLineStart == null) {
+ currentLineStart = new Point (mouseEvent.X, mouseEvent.Y);
+ }
+ } else {
+ if (currentLineStart != null) {
+
+ var start = currentLineStart.Value;
+ var end = new Point (mouseEvent.X, mouseEvent.Y);
+ var orientation = Orientation.Vertical;
+ var length = end.Y - start.Y;
+
+ // if line is wider than it is tall switch to horizontal
+ if (Math.Abs (start.X - end.X) > Math.Abs (start.Y - end.Y)) {
+ orientation = Orientation.Horizontal;
+ length = end.X - start.X;
+ }
+
+
+ canvases [currentColor].AddLine (
+ start,
+ length,
+ orientation,
+ BorderStyle);
+
+ currentLineStart = null;
+ SetNeedsDisplay ();
+ }
+ }
+
+ return base.OnMouseEvent (mouseEvent);
+ }
+
+ internal void SetColor (Color c)
+ {
+ AddCanvas (c);
+ currentColor = colorLayers [c];
+ }
+
+ }
+ }
+}
diff --git a/UnitTests/Drivers/ConsoleDriverTests.cs b/UnitTests/Drivers/ConsoleDriverTests.cs
index cdc8edfc6..a77d5f5a6 100644
--- a/UnitTests/Drivers/ConsoleDriverTests.cs
+++ b/UnitTests/Drivers/ConsoleDriverTests.cs
@@ -319,7 +319,7 @@ namespace Terminal.Gui.DriverTests {
Application.Shutdown ();
}
-
+
[Fact, AutoInitShutdown]
public void AddRune_On_Clip_Left_Or_Right_Replace_Previous_Or_Next_Wide_Rune_With_Space ()
{
@@ -440,6 +440,8 @@ namespace Terminal.Gui.DriverTests {
Assert.Equal (code, actual.Value);
}
+ private static object packetLock = new object ();
+
///
/// Sometimes when using remote tools EventKeyRecord sends 'virtual keystrokes'.
/// These are indicated with the wVirtualKeyCode of 231. When we see this code
@@ -485,122 +487,126 @@ namespace Terminal.Gui.DriverTests {
if (iterations == 0) Application.Driver.SendKeys ((char)mappedConsoleKey, ConsoleKey.Packet, shift, alt, control);
};
- Application.Run ();
- Application.Shutdown ();
+ lock (packetLock) {
+ Application.Run ();
+ Application.Shutdown ();
+ }
}
public class PacketTest : IEnumerable, IEnumerable