From 16c7e8fc72ff3876ed508f3c0a304b139f9ee029 Mon Sep 17 00:00:00 2001
From: dmytro lytovchenko <dmytro.lytovchenko@gmail.com>
Date: Sun, 7 Jul 2019 11:46:59 +0200
Subject: [PATCH] Hovering a lane in incoming select mode, will show allowed
 turns as circles

---
 TLM/TLM/TLM.csproj                            |   2 +-
 TLM/TLM/Traffic/Data/SpeedLimit.cs            | 349 ++++++++-------
 TLM/TLM/UI/SubTool.cs                         |  46 +-
 .../UI/SubTools/LaneArrows/LaneArrowTool.cs   | 411 +-----------------
 .../LaneArrows/LaneArrowTool_Render.cs        | 160 +++++--
 ...ArrowTool_Click.cs => LaneArrowTool_UI.cs} |  34 +-
 TLM/TLM/UI/TrafficManagerTool.cs              |  74 +++-
 7 files changed, 425 insertions(+), 651 deletions(-)
 rename TLM/TLM/UI/SubTools/LaneArrows/{LaneArrowTool_Click.cs => LaneArrowTool_UI.cs} (82%)

diff --git a/TLM/TLM/TLM.csproj b/TLM/TLM/TLM.csproj
index eaefe93cd..63cd668a3 100644
--- a/TLM/TLM/TLM.csproj
+++ b/TLM/TLM/TLM.csproj
@@ -255,7 +255,7 @@
     <Compile Include="UI\SubTools\LaneArrows\Geometry.cs" />
     <Compile Include="UI\SubTools\LaneArrows\LaneArrowsEditor.cs" />
     <Compile Include="UI\SubTools\LaneArrows\LaneArrowTool.cs" />
-    <Compile Include="UI\SubTools\LaneArrows\LaneArrowTool_Click.cs" />
+    <Compile Include="UI\SubTools\LaneArrows\LaneArrowTool_UI.cs" />
     <Compile Include="UI\SubTools\LaneArrows\LaneArrowTool_Render.cs" />
     <Compile Include="UI\SubTools\LaneArrows\OutgoingTurnsCollection.cs" />
     <Compile Include="UI\SubTools\ParkingRestrictionsTool.cs" />
diff --git a/TLM/TLM/Traffic/Data/SpeedLimit.cs b/TLM/TLM/Traffic/Data/SpeedLimit.cs
index 7f72d4c6a..d3e839d05 100644
--- a/TLM/TLM/Traffic/Data/SpeedLimit.cs
+++ b/TLM/TLM/Traffic/Data/SpeedLimit.cs
@@ -1,176 +1,175 @@
-using System;
-using System.Collections.Generic;
-using TrafficManager.State;
-using TrafficManager.UI;
-using UnityEngine;
-
-namespace TrafficManager.Traffic.Data {
-	public enum SpeedUnit {
-		CurrentlyConfigured,	// Currently selected in the options menu
-		Kmph,
-		Mph
-	}
-
-	public enum MphSignStyle {
-		SquareUS = 0,
-		RoundUK = 1,
-		RoundGerman = 2,
-	}
-
-	/// <summary>
-	/// Defines a speed limit value with default Kmph and display value of Mph
-	/// for when the option is set to display Mph. The engine still uses kmph.
-	/// </summary>
-	public struct SpeedLimit {
-		public const float SPEED_TO_KMPH = 50.0f; // 1.0f equals 50 km/h
-		private const ushort LOWER_KMPH = 10;
-		public const ushort UPPER_KMPH = 140;
-		private const ushort KMPH_STEP = 10;
-		public const int BREAK_PALETTE_COLUMN_KMPH = 8; // palette shows N in a row, then break and another row
-
-		private const float SPEED_TO_MPH = 32.06f; // 50 km/h converted to mph
-		private const ushort LOWER_MPH = 5;
-		public const ushort UPPER_MPH = 90;
-		private const ushort MPH_STEP = 5;
-		public const int BREAK_PALETTE_COLUMN_MPH = 10; // palette shows M in a row, then break and another row
-
-		private const float LOWER_SPEED = 0.1f; 
-		private const float UPPER_SPEED = 2 * 10.0f; // 1000 km/h
-
-		/// <summary>
-		/// Produces list of speed limits to offer user in the palette
-		/// </summary>
-		/// <param name="unit">What kind of speed limit list is required</param>
-		/// <returns>List from smallest to largest speed with the given unit. Zero (no limit) is not added to the list.
-		/// The values are in-game speeds as float.</returns>
-		public static List<float> EnumerateSpeedLimits(SpeedUnit unit) {
-			var result = new List<float>();
-			switch (unit) {
-				case SpeedUnit.Kmph:
-					for (var km = LOWER_KMPH; km <= UPPER_KMPH; km += KMPH_STEP) {
-						result.Add(km / SPEED_TO_KMPH);
-					}
-					break;
-				case SpeedUnit.Mph:
-					for (var mi = LOWER_MPH; mi <= UPPER_MPH; mi += MPH_STEP) {
-						result.Add(mi / SPEED_TO_MPH);
-					}
-					break;
-				case SpeedUnit.CurrentlyConfigured:
-					// Automatically choose from the config
-					return GlobalConfig.Instance.Main.DisplaySpeedLimitsMph
-						       ? EnumerateSpeedLimits(SpeedUnit.Mph)
-						       : EnumerateSpeedLimits(SpeedUnit.Kmph);
-			}
-
-			return result;
-		}
-
-		public static string ToMphPreciseString(float speed) {
-			if (IsZero(speed)) {
-				return Translation.GetString("Speed_limit_unlimited");
-			}
-
-			return ToMphPrecise(speed) + " MPH";
-		}
-
-		public static string ToKmphPreciseString(float speed) {
-			if (IsZero(speed)) {
-				return Translation.GetString("Speed_limit_unlimited");
-			}
-
-			return ToKmphPrecise(speed) + " km/h";
-		}
-
-		public static bool NearlyEqual(float a, float b) {
-			return Mathf.Abs(a - b) < 0.001f;
-		}
-
-		public static bool IsZero(float speed) {
-			return speed < 0.001f;
-		}
-
-		public static bool IsValidRange(float speed) {
-			return IsZero(speed) || (speed >= LOWER_SPEED && speed <= UPPER_SPEED);
-		}
-
-		/// <summary>
-		/// Convert float game speed to mph and round to nearest STEP
-		/// </summary>
-		/// <param name="speed"></param>
-		/// <returns></returns>
-		public static ushort ToMphRounded(float speed) {
-			var mph = speed * SPEED_TO_MPH;
-			return (ushort)(Mathf.Round(mph / MPH_STEP) * MPH_STEP);
-		}
-
-		public static ushort ToMphPrecise(float speed) {
-			return (ushort)Mathf.Round(speed * SPEED_TO_MPH);
-		}
-
-		/// <summary>
-		/// Convert float game speed to km/h and round to nearest STEP
-		/// </summary>
-		/// <param name="speed"></param>
-		/// <returns></returns>
-		public static ushort ToKmphRounded(float speed) {
-			var kmph = speed * SPEED_TO_KMPH;
-			return (ushort)(Mathf.Round(kmph / KMPH_STEP) * KMPH_STEP);
-		}
-
-		public static ushort ToKmphPrecise(float speed) {
-			return (ushort)Mathf.Round(speed * SPEED_TO_KMPH);
-		}
-
-		/// <summary>
-		/// Based on the MPH/KMPH settings round the current speed to the nearest STEP and
-		/// then decrease by STEP.
-		/// </summary>
-		/// <param name="speed">Ingame speed</param>
-		/// <returns>Ingame speed decreased by the increment for MPH or KMPH</returns>
-		public static float GetPrevious(float speed) {
-			if (speed < 0f) {
-				return -1f;
-			}
-			if (GlobalConfig.Instance.Main.DisplaySpeedLimitsMph) {
-				var rounded = ToMphRounded(speed);
-				return (rounded > LOWER_MPH ? rounded - MPH_STEP : LOWER_MPH) / SPEED_TO_MPH;
-			} else {
-				var rounded = ToKmphRounded(speed);
-				return (rounded > LOWER_KMPH ? rounded - KMPH_STEP : LOWER_KMPH) / SPEED_TO_KMPH;
-			}
-		}
-
-		/// <summary>
-		/// Based on the MPH/KMPH settings round the current speed to the nearest STEP and
-		/// then increase by STEP.
-		/// </summary>
-		/// <param name="speed">Ingame speed</param>
-		/// <returns>Ingame speed increased by the increment for MPH or KMPH</returns>
-		public static float GetNext(float speed) {
-			if (speed < 0f) {
-				return -1f;
-			}
-			if (GlobalConfig.Instance.Main.DisplaySpeedLimitsMph) {
-				var rounded = ToMphRounded(speed);
-				return (rounded < UPPER_MPH ? rounded + MPH_STEP : UPPER_MPH) / SPEED_TO_MPH;
-			}
-			else {
-				var rounded = ToKmphRounded(speed);
-				return (rounded < UPPER_KMPH ? rounded + KMPH_STEP : UPPER_KMPH) / SPEED_TO_KMPH;
-			}
-		}
-
-		/// <summary>
-		/// For US signs and MPH enabled, scale textures vertically by 1.25f.
-		/// Other signs are round.
-		/// </summary>
-		/// <returns>Multiplier for horizontal sign size</returns>
-		public static float GetVerticalTextureScale() {
-			return (GlobalConfig.Instance.Main.DisplaySpeedLimitsMph &&
-			        GlobalConfig.Instance.Main.MphRoadSignStyle == MphSignStyle.SquareUS)
-				       ? 1.25f
-				       : 1.0f;
-		}
-	}
+namespace TrafficManager.Traffic.Data {
+    using System.Collections.Generic;
+    using State;
+    using UI;
+    using UnityEngine;
+
+    public enum SpeedUnit {
+        CurrentlyConfigured,	// Currently selected in the options menu
+        Kmph,
+        Mph
+    }
+
+    public enum MphSignStyle {
+        SquareUS = 0,
+        RoundUK = 1,
+        RoundGerman = 2,
+    }
+
+    /// <summary>
+    /// Defines a speed limit value with default Kmph and display value of Mph
+    /// for when the option is set to display Mph. The engine still uses kmph.
+    /// </summary>
+    public struct SpeedLimit {
+        public const float SPEED_TO_KMPH = 50.0f; // 1.0f equals 50 km/h
+        private const ushort LOWER_KMPH = 10;
+        public const ushort UPPER_KMPH = 140;
+        private const ushort KMPH_STEP = 10;
+        public const int BREAK_PALETTE_COLUMN_KMPH = 8; // palette shows N in a row, then break and another row
+
+        private const float SPEED_TO_MPH = 32.06f; // 50 km/h converted to mph
+        private const ushort LOWER_MPH = 5;
+        public const ushort UPPER_MPH = 90;
+        private const ushort MPH_STEP = 5;
+        public const int BREAK_PALETTE_COLUMN_MPH = 10; // palette shows M in a row, then break and another row
+
+        private const float LOWER_SPEED = 0.1f;
+        private const float UPPER_SPEED = 2 * 10.0f; // 1000 km/h
+
+        /// <summary>
+        /// Produces list of speed limits to offer user in the palette
+        /// </summary>
+        /// <param name="unit">What kind of speed limit list is required</param>
+        /// <returns>List from smallest to largest speed with the given unit. Zero (no limit) is not added to the list.
+        /// The values are in-game speeds as float.</returns>
+        public static List<float> EnumerateSpeedLimits(SpeedUnit unit) {
+            var result = new List<float>();
+            switch (unit) {
+                case SpeedUnit.Kmph:
+                    for (var km = LOWER_KMPH; km <= UPPER_KMPH; km += KMPH_STEP) {
+                        result.Add(km / SPEED_TO_KMPH);
+                    }
+                    break;
+                case SpeedUnit.Mph:
+                    for (var mi = LOWER_MPH; mi <= UPPER_MPH; mi += MPH_STEP) {
+                        result.Add(mi / SPEED_TO_MPH);
+                    }
+                    break;
+                case SpeedUnit.CurrentlyConfigured:
+                    // Automatically choose from the config
+                    return GlobalConfig.Instance.Main.DisplaySpeedLimitsMph
+                               ? EnumerateSpeedLimits(SpeedUnit.Mph)
+                               : EnumerateSpeedLimits(SpeedUnit.Kmph);
+            }
+
+            return result;
+        }
+
+        public static string ToMphPreciseString(float speed) {
+            if (IsZero(speed)) {
+                return Translation.GetString("Speed_limit_unlimited");
+            }
+
+            return ToMphPrecise(speed) + " MPH";
+        }
+
+        public static string ToKmphPreciseString(float speed) {
+            if (IsZero(speed)) {
+                return Translation.GetString("Speed_limit_unlimited");
+            }
+
+            return ToKmphPrecise(speed) + " km/h";
+        }
+
+        public static bool NearlyEqual(float a, float b) {
+            return Mathf.Abs(a - b) < 0.001f;
+        }
+
+        public static bool IsZero(float speed) {
+            return speed < 0.001f;
+        }
+
+        public static bool IsValidRange(float speed) {
+            return IsZero(speed) || (speed >= LOWER_SPEED && speed <= UPPER_SPEED);
+        }
+
+        /// <summary>
+        /// Convert float game speed to mph and round to nearest STEP
+        /// </summary>
+        /// <param name="speed"></param>
+        /// <returns></returns>
+        public static ushort ToMphRounded(float speed) {
+            var mph = speed * SPEED_TO_MPH;
+            return (ushort)(Mathf.Round(mph / MPH_STEP) * MPH_STEP);
+        }
+
+        public static ushort ToMphPrecise(float speed) {
+            return (ushort)Mathf.Round(speed * SPEED_TO_MPH);
+        }
+
+        /// <summary>
+        /// Convert float game speed to km/h and round to nearest STEP
+        /// </summary>
+        /// <param name="speed"></param>
+        /// <returns></returns>
+        public static ushort ToKmphRounded(float speed) {
+            var kmph = speed * SPEED_TO_KMPH;
+            return (ushort)(Mathf.Round(kmph / KMPH_STEP) * KMPH_STEP);
+        }
+
+        public static ushort ToKmphPrecise(float speed) {
+            return (ushort)Mathf.Round(speed * SPEED_TO_KMPH);
+        }
+
+        /// <summary>
+        /// Based on the MPH/KMPH settings round the current speed to the nearest STEP and
+        /// then decrease by STEP.
+        /// </summary>
+        /// <param name="speed">Ingame speed</param>
+        /// <returns>Ingame speed decreased by the increment for MPH or KMPH</returns>
+        public static float GetPrevious(float speed) {
+            if (speed < 0f) {
+                return -1f;
+            }
+            if (GlobalConfig.Instance.Main.DisplaySpeedLimitsMph) {
+                var rounded = ToMphRounded(speed);
+                return (rounded > LOWER_MPH ? rounded - MPH_STEP : LOWER_MPH) / SPEED_TO_MPH;
+            } else {
+                var rounded = ToKmphRounded(speed);
+                return (rounded > LOWER_KMPH ? rounded - KMPH_STEP : LOWER_KMPH) / SPEED_TO_KMPH;
+            }
+        }
+
+        /// <summary>
+        /// Based on the MPH/KMPH settings round the current speed to the nearest STEP and
+        /// then increase by STEP.
+        /// </summary>
+        /// <param name="speed">Ingame speed</param>
+        /// <returns>Ingame speed increased by the increment for MPH or KMPH</returns>
+        public static float GetNext(float speed) {
+            if (speed < 0f) {
+                return -1f;
+            }
+            if (GlobalConfig.Instance.Main.DisplaySpeedLimitsMph) {
+                var rounded = ToMphRounded(speed);
+                return (rounded < UPPER_MPH ? rounded + MPH_STEP : UPPER_MPH) / SPEED_TO_MPH;
+            }
+            else {
+                var rounded = ToKmphRounded(speed);
+                return (rounded < UPPER_KMPH ? rounded + KMPH_STEP : UPPER_KMPH) / SPEED_TO_KMPH;
+            }
+        }
+
+        /// <summary>
+        /// For US signs and MPH enabled, scale textures vertically by 1.25f.
+        /// Other signs are round.
+        /// </summary>
+        /// <returns>Multiplier for horizontal sign size</returns>
+        public static float GetVerticalTextureScale() {
+            return (GlobalConfig.Instance.Main.DisplaySpeedLimitsMph &&
+                    GlobalConfig.Instance.Main.MphRoadSignStyle == MphSignStyle.SquareUS)
+                       ? 1.25f
+                       : 1.0f;
+        }
+    }
 }
\ No newline at end of file
diff --git a/TLM/TLM/UI/SubTool.cs b/TLM/TLM/UI/SubTool.cs
index a9ab6afa0..256e5f970 100644
--- a/TLM/TLM/UI/SubTool.cs
+++ b/TLM/TLM/UI/SubTool.cs
@@ -4,7 +4,10 @@
     using UnityEngine;
 
     public abstract class SubTool {
-        public TrafficManagerTool MainTool { get; }
+        /// <summary>
+        /// Parent Main Tool, one for all subtools
+        /// </summary>
+        internal TrafficManagerTool MainTool { get; }
 
         protected Texture2D WindowTexture {
             get {
@@ -94,25 +97,25 @@ public abstract class SubTool {
 
         private GUIStyle borderlessStyle;
 
-        protected ushort HoveredNodeId => TrafficManagerTool.HoveredNodeId;
+        protected ushort HoveredNodeId => MainTool.HoveredNodeId;
 
-        protected ushort HoveredSegmentId => TrafficManagerTool.HoveredSegmentId;
+        protected ushort HoveredSegmentId => MainTool.HoveredSegmentId;
 
-        protected uint HoveredLaneId => TrafficManagerTool.HoveredLaneId;
+        protected uint HoveredLaneId => MainTool.HoveredLaneId;
 
         protected ushort SelectedNodeId {
-            get => TrafficManagerTool.SelectedNodeId;
-            set => TrafficManagerTool.SelectedNodeId = value;
+            get => MainTool.SelectedNodeId;
+            set => MainTool.SelectedNodeId = value;
         }
 
         protected ushort SelectedSegmentId {
-            get => TrafficManagerTool.SelectedSegmentId;
-            set => TrafficManagerTool.SelectedSegmentId = value;
+            get => MainTool.SelectedSegmentId;
+            set => MainTool.SelectedSegmentId = value;
         }
 
         protected uint SelectedLaneId {
-            get => TrafficManagerTool.SelectedLaneId;
-            set => TrafficManagerTool.SelectedLaneId = value;
+            get => MainTool.SelectedLaneId;
+            set => MainTool.SelectedLaneId = value;
         }
 
         public SubTool(TrafficManagerTool mainTool) {
@@ -127,12 +130,33 @@ public abstract class SubTool {
         const float NATIVE_HEIGHT = 1200;
 
         /// <summary>
-        /// Called whenever the
+        /// Called whenever left mouse is clicked on the screen, over the GUI or the world
         /// </summary>
         public abstract void OnPrimaryClickOverlay();
 
         public virtual void OnSecondaryClickOverlay() { }
 
+        /// <summary>
+        /// Hovered node is changed to a different value than before (also 0)
+        /// </summary>
+        /// <param name="oldNodeId">The previously hovered node</param>
+        /// <param name="newNodeId">New hovered node</param>
+        internal virtual void OnChangeHoveredNode(ushort oldNodeId, ushort newNodeId) { }
+
+        /// <summary>
+        /// Hovered segment is changed to a different value than before (also 0)
+        /// </summary>
+        /// <param name="oldSegmentId">The previously hovered segment</param>
+        /// <param name="newSegmentId">New hovered segment</param>
+        internal virtual void OnChangeHoveredSegment(ushort oldSegmentId, ushort newSegmentId) { }
+
+        /// <summary>
+        /// Hovered lane is changed a different value than before (also 0)
+        /// </summary>
+        /// <param name="oldLaneId">The previously hovered lane</param>
+        /// <param name="newLaneId">New hovered lane</param>
+        internal virtual void OnChangeHoveredLane(uint oldLaneId, uint newLaneId) { }
+
         public virtual void OnToolGUI(Event e) {
             // set up scaling
             /*Vector2 resolution = UIView.GetAView().GetScreenResolution();
diff --git a/TLM/TLM/UI/SubTools/LaneArrows/LaneArrowTool.cs b/TLM/TLM/UI/SubTools/LaneArrows/LaneArrowTool.cs
index eaa5d880f..ae1b595fd 100644
--- a/TLM/TLM/UI/SubTools/LaneArrows/LaneArrowTool.cs
+++ b/TLM/TLM/UI/SubTools/LaneArrows/LaneArrowTool.cs
@@ -1,5 +1,4 @@
 namespace TrafficManager.UI.SubTools.LaneArrows {
-    using System;
     using System.Collections.Generic;
     using ColossalFramework;
     using CSUtil.Commons;
@@ -45,12 +44,7 @@ private enum Trigger {
         /// <summary>
         /// Allowed outgoing turns grouped by the direction
         /// </summary>
-        private OutgoingTurnsCollection outgoingTurns_;
-
-//        /// <summary>
-//        /// Allowed outgoing lanes
-//        /// </summary>
-//        private HashSet<uint> outgoingLanes_;
+        private OutgoingTurnsCollection? outgoingTurns_;
 
         public LaneArrowTool(TrafficManagerTool mainTool)
             : base(mainTool) {
@@ -186,33 +180,6 @@ public LaneArrowTool(TrafficManagerTool mainTool)
             // No GUI interaction in this mode
         }
 
-        // Cancel selection immediately if there are no vehicle lanes
-        // var numLanes = TrafficManagerTool.GetSegmentNumVehicleLanes(
-        //     SelectedSegmentId, SelectedNodeId, out _, LaneArrowManager.VEHICLE_TYPES);
-        // if (numLanes <= 0) {
-        //     Deselect();
-        //     return;
-        // }
-
-//            var nodePos = Singleton<NetManager>.instance.m_nodes.m_buffer[SelectedNodeId].m_position;
-//            var visible = MainTool.WorldToScreenPoint(nodePos, out _);
-//            if (!visible) {
-//                return;
-//            }
-
-//            var camPos = Singleton<SimulationManager>.instance.m_simulationView.m_position;
-//            var diff = nodePos - camPos;
-//            if (diff.magnitude > TrafficManagerTool.MAX_OVERLAY_DISTANCE) {
-//                return; // do not draw if too distant
-//            }
-
-//            // Try click something on Canvas
-//            foreach (var laneEditor in laneEditors_.Values) {
-//                if (laneEditor.Gui.HandleInput()) {
-//                    break; // handle until first true is returned (consumed)
-//                }
-//            }
-
         /// <summary>
         /// Handle events for OutgoingDirections state
         /// </summary>
@@ -230,245 +197,6 @@ public LaneArrowTool(TrafficManagerTool mainTool)
             SelectedLaneId = 0;
         }
 
-//        /// <summary>
-//        /// Create canvas one per incoming segment to the selected node.
-//        /// Fill each canvas with lane buttons.
-//        /// The initial GUI state is one lane control button per each incoming lane.
-//        /// Clicking that lane button will produce 0..3 arrow buttons controlling that lane.
-//        /// Clicking another lane button will destroy these and create another 0..3 buttons.
-//        /// Right-clicking, or clicking another node will destroy the GUI.
-//        /// </summary>
-//        private void CreateEditorsForAllSegments() {
-//            var nodeBuffer = Singleton<NetManager>.instance.m_nodes.m_buffer;
-//            var segmentBuffer = Singleton<NetManager>.instance.m_segments.m_buffer;
-//            var selectedNode = nodeBuffer[SelectedNodeId];
-//            var nodeId = SelectedNodeId;
-//
-//            // For all incoming segments
-//            for (var i = 0; i < MAX_NODE_SEGMENTS; ++i) {
-//                var incomingSegmentId = selectedNode.GetSegment(i);
-//                if (incomingSegmentId == 0) {
-//                    continue;
-//                }
-//
-//                var incomingSegment = segmentBuffer[incomingSegmentId];
-//
-//                // Create the GUI form and center it according to the node position
-//                Quaternion rotInverse;
-//                Vector3 guiOriginWorldPos;
-//                var editor = new LaneArrowsEditor();
-//                editor.CreateWorldSpaceCanvas(
-//                    incomingSegment, nodeId, incomingSegmentId, out guiOriginWorldPos, out rotInverse);
-//                laneEditors_[incomingSegmentId] = editor;
-//
-//                if (LaneConnectionManager.Instance.HasNodeConnections(nodeId)) {
-//                    // Do not allow editing lanes, because custom connections exist
-//                    // Create a forbidden icon button which does not click
-//                    CreateForbiddenButton_LaneConnections();
-//                    return; // do not create any more buttons
-//                }
-//
-//                var laneList = GetIncomingLaneList(incomingSegmentId, nodeId);
-//                CreateLaneControlButtons(editor, nodeId, incomingSegmentId, laneList,
-//                                         rotInverse, guiOriginWorldPos);
-//            }
-//        }
-
-//        /// <summary>
-//        /// As now we know that lane arrows cannot be edited, we do not create lane control GUI,
-//        /// instead create a single button with a warning icon. Clicking this button
-//        /// will pop up an explanation message.
-//        /// </summary>
-//        private void CreateForbiddenButton_LaneConnections() {
-//            var gui = laneEditors_.First().Value.Gui; // exact 1 element in laneEditors
-//            var button = gui.AddButton(
-//                new Vector3(0f, 0f, 0f),
-//                new Vector2(LANE_BUTTON_SIZE, LANE_BUTTON_SIZE),
-//                string.Empty);
-//            WorldSpaceGUI.SetButtonSprite(button, LaneArrowsTextures.GetSprite(3, 2));
-//
-//            UnityAction clickLaneConnections = () => {
-//                const string MESSAGE = "Lane arrows disabled for this node, because you have custom " +
-//                                       "lane connections set up.";
-//                UIView.library
-//                      .ShowModal<ExceptionPanel>("ExceptionPanel")
-//                      .SetMessage("No Lane Arrows for this node", MESSAGE, false);
-//            };
-//            button.GetComponent<Button>().onClick.AddListener(clickLaneConnections);
-//        }
-
-//        /// <summary>
-//        /// The lane editing is possible.
-//        /// Create buttons one per lane.
-//        /// </summary>
-//        /// <param name="editor">The editor containing canvas for these buttons</param>
-//        /// <param name="nodeId">Node being the center of the junction and all editors</param>
-//        /// <param name="segmentId">Segment we are editing in this canvas</param>
-//        /// <param name="laneList">List of lanes to create buttons for them</param>
-//        /// <param name="rotInverse">The inverse rotation quaternion for projecting world stuff into the canvas</param>
-//        /// <param name="guiOriginWorldPos">Where GUI 0,0 is located in the world</param>
-//        private void CreateLaneControlButtons(LaneArrowsEditor editor,
-//                                              ushort nodeId,
-//                                              ushort segmentId,
-//                                              IList<LanePos> laneList,
-//                                              Quaternion rotInverse,
-//                                              Vector3 guiOriginWorldPos) {
-//            var lanesBuffer = Singleton<NetManager>.instance.m_lanes.m_buffer;
-//
-//            var geometry = SegmentGeometry.Get(segmentId);
-//            if (geometry == null) {
-//                Log.Error("LaneArrowTool._guiLaneChangeWindow: No geometry information " +
-//                          $"available for segment {segmentId}");
-//                return;
-//            }
-//
-//            var isStartNode = geometry.StartNodeId() == nodeId;
-//
-//            // Now iterate over eligible lanes
-//            for (var i = 0; i < laneList.Count; i++) {
-//                var laneId = laneList[i].laneId;
-//                var lane = lanesBuffer[laneId];
-//                var laneFlags = (NetLane.Flags)lane.m_flags;
-//
-//                if (!Flags.applyLaneArrowFlags(laneList[i].laneId)) {
-//                    Flags.removeLaneArrowFlags(laneList[i].laneId);
-//                }
-//
-//                // Get position of the editable lane
-//                var laneEndPosition = lane.m_bezier.Position(isStartNode ? 0f : 1f);
-//                var buttonPositionRot = rotInverse * (laneEndPosition - guiOriginWorldPos);
-//
-//                // because UI grows up (away from the node), shift it slightly back in by 3 button sizes
-//                // TODO: Get the distance (junction size) from netSegment.Info and step back by that
-//                var buttonPosition = new Vector3(buttonPositionRot.x,
-//                                                 buttonPositionRot.z - (LANE_BUTTON_SIZE * 3f),
-//                                                 0f);
-//
-//                var laneEditButton = editor.Gui.AddButton(
-//                    buttonPosition, new Vector2(LANE_BUTTON_SIZE, LANE_BUTTON_SIZE));
-//
-//                WorldSpaceGUI.SetButtonSprite(
-//                    laneEditButton, LaneArrowsTextures.GetLaneControlSprite(laneFlags));
-//
-//                laneEditButton.GetComponent<Button>().onClick.AddListener(
-//                    () => {
-//                        // Ignore second click on the same control button
-//                        if (laneEditButton == sharedState_.btnCurrentControlButton_) {
-//                            return;
-//                        }
-//
-//                        SelectedSegmentId = segmentId;
-//                        SelectedLaneId = laneId;
-//                        try {
-//                            CreateLaneArrowButtons(
-//                                laneEditButton, segmentId, SelectedNodeId, laneId, isStartNode);
-//                        }
-//                        catch (Exception e) {
-//                            Log.Error($"While creating lane arrows: {e}");
-//                        }
-//                    });
-//
-//                // TODO: Fix this if only one incoming lane available in the whole junction? or delete this
-////                if (laneList.Count == 1) {
-////                    // For only one lane, immediately open the arrow buttons
-////                    sharedState_.selectedLaneId_ = laneId;
-////                    CreateLaneControlArrows(laneEditButton, segmentId, SelectedNodeId, laneId, isStartNode);
-////                }
-//            }
-//        }
-
-//        /// <summary>
-//        /// Create world space canvas in the ground plane.
-//        /// Recreate Lane Arrows at the location of the given button and slightly above it.
-//        /// </summary>
-//        /// <param name="originButton">The button user clicked to create these controls</param>
-//        /// <param name="segmentId">Current segment being edited</param>
-//        /// <param name="nodeId">Current junction</param>
-//        /// <param name="laneId">Current lane being edited</param>
-//        /// <param name="isStartNode">Bool if selected node is start node of the geometry (used for
-//        ///     lane modifications later)</param>
-//        private void CreateLaneArrowButtons(GameObject originButton,
-//                                            ushort segmentId,
-//                                            ushort nodeId,
-//                                            uint laneId,
-//                                            bool isStartNode) {
-//            // Set some nice color or effect to highlight
-//            originButton.GetComponent<Image>().color = Color.gray;
-//
-//            var lane = Singleton<NetManager>.instance.m_lanes.m_buffer[laneId];
-//            var flags = (NetLane.Flags)lane.m_flags;
-//
-//            sharedState_.DestroyLaneArrowButtons();
-//            sharedState_.btnCurrentControlButton_ = originButton; // save this to decolorize it later
-//
-//            // Get all possible turn directions to leave the nodeId via this segment
-//            var editor = laneEditors_[segmentId];
-//            editor.PossibleTurns = GetAllTurnsOut(nodeId, segmentId);
-//
-//            //-----------------
-//            // Button FORWARD
-//            //-----------------
-//            var forward = (flags & NetLane.Flags.Forward) != 0 ? LaneButtonState.On : LaneButtonState.Off;
-//            if (editor.PossibleTurns != null
-//                && editor.PossibleTurns.Value.Contains(ArrowDirection.Forward)) {
-//                GuiAddLaneArrowForward(editor, originButton, forward);
-//                UnityAction clickForward = () => {
-//                    OnClickForward(laneId, isStartNode, sharedState_.btnLaneArrowForward_);
-//                };
-//
-//                var buttonComponent = sharedState_.btnLaneArrowForward_.GetComponent<Button>();
-//                buttonComponent.onClick.AddListener(clickForward);
-////            } else {
-////                GuiAddLaneArrowForward(originButton, LaneButtonState.Disabled);
-//                // Note: no click handler added
-//            }
-//
-//            //-----------------
-//            // Button LEFT
-//            //-----------------
-//            var left = (flags & NetLane.Flags.Left) != 0 ? LaneButtonState.On : LaneButtonState.Off;
-//            if (editor.PossibleTurns != null
-//                && editor.PossibleTurns.Value.Contains(ArrowDirection.Left)) {
-//                GuiAddLaneArrowLeft(editor, originButton, left);
-//                UnityAction clickLeft = () => {
-//                    OnClickLeft(segmentId, SelectedNodeId, laneId,
-//                                isStartNode, sharedState_.btnLaneArrowLeft_);
-//                };
-//                var buttonComponent = sharedState_.btnLaneArrowLeft_.GetComponent<Button>();
-//                buttonComponent.onClick.AddListener(clickLeft);
-////            } else {
-////                GuiAddLaneArrowLeft(originButton, LaneButtonState.Disabled);
-//                // Note: no click handler added
-//            }
-//
-//            //-----------------
-//            // Button RIGHT
-//            //-----------------
-//            var right = (flags & NetLane.Flags.Right) != 0 ? LaneButtonState.On : LaneButtonState.Off;
-//            if (editor.PossibleTurns != null
-//                && editor.PossibleTurns.Value.Contains(ArrowDirection.Right)) {
-//                GuiAddLaneArrowRight(editor, originButton, right);
-//                UnityAction clickRight = () => {
-//                    OnClickRight(segmentId, SelectedNodeId, laneId,
-//                                 isStartNode, sharedState_.btnLaneArrowRight_);
-//                };
-//                var buttonComponent = sharedState_.btnLaneArrowRight_.GetComponent<Button>();
-//                buttonComponent.onClick.AddListener(clickRight);
-////            } else {
-////                GuiAddLaneArrowRight(originButton, LaneButtonState.Disabled);
-//                // Note: no click handler added
-//            }
-//        }
-
-//        private void UpdateButtonGraphics(uint laneId,
-//                                          NetLane.Flags direction,
-//                                          GameObject button) {
-//            var lane = Singleton<NetManager>.instance.m_lanes.m_buffer[laneId];
-//            var flags = (NetLane.Flags)lane.m_flags;
-//            var buttonState = (flags & direction) != 0 ? LaneButtonState.On : LaneButtonState.Off;
-//            WorldSpaceGUI.SetButtonSprite(button, SelectControlButtonSprite(direction, buttonState));
-//        }
-
         internal static IList<LanePos> GetIncomingLaneList(ushort segmentId, ushort nodeId) {
             var segmentsBuffer = Singleton<NetManager>.instance.m_segments.m_buffer;
             return Constants.ServiceFactory.NetService.GetSortedLanes(
@@ -480,143 +208,6 @@ public LaneArrowTool(TrafficManagerTool mainTool)
                 true);
         }
 
-//        private void OnClickForward(uint laneId, bool startNode, GameObject button) {
-//            var res = Flags.LaneArrowChangeResult.Invalid;
-//            LaneArrowManager.Instance.ToggleLaneArrows(
-//                laneId,
-//                startNode,
-//                Flags.LaneArrows.Forward,
-//                out res);
-//            if (res == Flags.LaneArrowChangeResult.Invalid ||
-//                res == Flags.LaneArrowChangeResult.Success) {
-//                UpdateButtonGraphics(laneId, NetLane.Flags.Forward, button);
-//                UpdateLaneControlButton(sharedState_.btnLaneArrowForward_.transform.parent.gameObject, laneId);
-//            }
-//        }
-
-//        private void OnClickLeft(ushort segmentId, ushort nodeId, uint laneId, bool startNode, GameObject button) {
-//            var res = Flags.LaneArrowChangeResult.Invalid;
-//            LaneArrowManager.Instance.ToggleLaneArrows(
-//                laneId,
-//                startNode,
-//                Flags.LaneArrows.Left,
-//                out res);
-//            if (res == Flags.LaneArrowChangeResult.Invalid ||
-//                res == Flags.LaneArrowChangeResult.Success) {
-//                UpdateButtonGraphics(laneId, NetLane.Flags.Left, button);
-//                UpdateLaneControlButton(sharedState_.btnLaneArrowLeft_.transform.parent.gameObject, laneId);
-//            }
-//        }
-
-//        private void OnClickRight(ushort segmentId, ushort nodeId, uint laneId, bool startNode, GameObject button) {
-//            var res = Flags.LaneArrowChangeResult.Invalid;
-//            LaneArrowManager.Instance.ToggleLaneArrows(
-//                laneId,
-//                startNode,
-//                Flags.LaneArrows.Right,
-//                out res);
-//            if (res == Flags.LaneArrowChangeResult.Invalid ||
-//                res == Flags.LaneArrowChangeResult.Success) {
-//                UpdateButtonGraphics(laneId, NetLane.Flags.Right, button);
-//                UpdateLaneControlButton(sharedState_.btnLaneArrowRight_.transform.parent.gameObject, laneId);
-//            }
-//        }
-
-//        private void UpdateLaneControlButton(GameObject button, uint laneId) {
-//            var lane = Singleton<NetManager>.instance.m_lanes.m_buffer[laneId];
-//            var flags = (NetLane.Flags)lane.m_flags;
-//            WorldSpaceGUI.SetButtonSprite(button, LaneArrowsTextures.GetLaneControlSprite(flags));
-//        }
-
-//        private Sprite GetLaneControlSprite(LaneButtonState state, ArrowDirection dir) {
-//            switch (state) {
-//                case LaneButtonState.On:
-//                    return LaneArrowsTextures.GetLaneArrowSprite(dir, true, false);
-//                case LaneButtonState.Off:
-//                    return LaneArrowsTextures.GetLaneArrowSprite(dir, false, false);
-//                default:
-//                    return LaneArrowsTextures.GetLaneArrowSprite(dir, false, true);
-//            }
-//        }
-
-//        /// <summary>
-//        /// Based on NetLane Flags direction and button state (on, off, disabled),
-//        /// return the texture to display on button.
-//        /// </summary>
-//        /// <param name="direction">Left, Right, Forward, no bit combinations</param>
-//        /// <param name="state">Button state (on, off, disabled)</param>
-//        /// <returns>The texture</returns>
-//        private Sprite SelectControlButtonSprite(NetLane.Flags direction, LaneButtonState state) {
-//            switch (direction) {
-//                case NetLane.Flags.Forward:
-//                    return GetLaneControlSprite(state, ArrowDirection.Forward);
-//                case NetLane.Flags.Left:
-//                    return GetLaneControlSprite(state, ArrowDirection.Left);
-//                case NetLane.Flags.Right:
-//                    return GetLaneControlSprite(state, ArrowDirection.Right);
-//                default:
-//                    Log.Error($"Trying to find texture for lane state {direction.ToString()}");
-//                    return null;
-//            }
-//        }
-
-//        /// <summary>
-//        /// Creates Turn Left lane control button slightly to the left of the originButton.
-//        /// </summary>
-//        /// <param name="originButton">The parent for the new button</param>
-//        /// <param name="forward">The state of the button (on, off, disabled)</param>
-//        private void GuiAddLaneArrowForward(LaneArrowsEditor editor,
-//                                            GameObject originButton,
-//                                            LaneButtonState forward) {
-//            sharedState_.btnLaneArrowForward_ = editor.Gui.AddButton(
-//                new Vector3(0f, LANE_BUTTON_SIZE * 1.3f, 0f),
-//                new Vector2(LANE_BUTTON_SIZE, LANE_BUTTON_SIZE),
-//                string.Empty,
-//                originButton);
-//
-//            WorldSpaceGUI.SetButtonSprite(
-//                sharedState_.btnLaneArrowForward_,
-//                SelectControlButtonSprite(NetLane.Flags.Forward, forward));
-//        }
-
-//        /// <summary>
-//        /// Creates Turn Left lane control button slightly to the left of the originButton.
-//        /// </summary>
-//        /// <param name="originButton">The parent for the new button</param>
-//        /// <param name="left">The state of the button (on, off, disabled)</param>
-//        private void GuiAddLaneArrowLeft(LaneArrowsEditor editor,
-//                                         GameObject originButton,
-//                                         LaneButtonState left) {
-//            sharedState_.btnLaneArrowLeft_ = editor.Gui.AddButton(
-//                new Vector3(-LANE_BUTTON_SIZE, LANE_BUTTON_SIZE * 1.3f, 0f),
-//                new Vector2(LANE_BUTTON_SIZE, LANE_BUTTON_SIZE),
-//                string.Empty,
-//                originButton);
-//
-//            WorldSpaceGUI.SetButtonSprite(
-//                sharedState_.btnLaneArrowLeft_,
-//                SelectControlButtonSprite(NetLane.Flags.Left, left));
-//        }
-
-//        /// <summary>
-//        /// Creates Turn Right lane control button, slightly right, belonging to the originButton
-//        /// </summary>
-//        /// <param name="originButton">The parent for the new button</param>
-//        /// <param name="right">The state of the button (on, off, disabled)</param>
-//        private void GuiAddLaneArrowRight(LaneArrowsEditor editor,
-//                                          GameObject originButton,
-//                                          LaneButtonState right) {
-//            sharedState_.btnLaneArrowRight_ = editor.Gui.AddButton(
-//                new Vector3(LANE_BUTTON_SIZE, LANE_BUTTON_SIZE * 1.3f, 0f),
-//                new Vector2(LANE_BUTTON_SIZE, LANE_BUTTON_SIZE),
-//                string.Empty,
-//                originButton);
-//
-//            WorldSpaceGUI.SetButtonSprite(
-//                sharedState_.btnLaneArrowRight_,
-//                SelectControlButtonSprite(NetLane.Flags.Right, right));
-//        }
-
         /// <summary>
         /// For incoming segment into a node, get allowed directions to leave the segment.
         /// This is used to disable some of the lane turn buttons.
diff --git a/TLM/TLM/UI/SubTools/LaneArrows/LaneArrowTool_Render.cs b/TLM/TLM/UI/SubTools/LaneArrows/LaneArrowTool_Render.cs
index d203ff4ca..c3f6c3b37 100644
--- a/TLM/TLM/UI/SubTools/LaneArrows/LaneArrowTool_Render.cs
+++ b/TLM/TLM/UI/SubTools/LaneArrows/LaneArrowTool_Render.cs
@@ -1,3 +1,7 @@
+//------------------------------------------------------------------------------
+// Rendering part of the Lane Arrow Tool
+// Handles drawing overlays and other visual effects
+//------------------------------------------------------------------------------
 namespace TrafficManager.UI.SubTools.LaneArrows {
     using System;
     using System.Collections.Generic;
@@ -10,22 +14,32 @@ public partial class LaneArrowTool {
         /// <summary>
         /// White. New hovered node in node selection mode.
         /// </summary>
-        private readonly Color PALETTE_HOVERED = Color.white;
+        private static readonly Color PALETTE_HOVERED = Color.white;
 
         /// <summary>
         /// Blue solid. Currently (active) selected node.
         /// </summary>
-        private readonly Color PALETTE_SELECTED = new Color(0f, 0f, 1f, 1f);
+        private static readonly Color PALETTE_SELECTED = new Color(0f, 0f, 1f, 1f);
 
         /// <summary>
         /// White translucent. Outline for current segment, when we are operating lanes.
         /// </summary>
-        private readonly Color PALETTE_CURRENT_SEGMENT_GHOST = new Color(1f, 1f, 1f, 0.33f);
+        private static readonly Color PALETTE_CURRENT_SEGMENT_GHOST = new Color(1f, 1f, 1f, 0.33f);
 
         /// <summary>
-        /// Green, for allowed turns.
+        /// Translucent green, for allowed turns.
         /// </summary>
-        private readonly Color PALETTE_TURN_ALLOWED = new Color(0f, 0.6f, 0f, 0.66f);
+        private static readonly Color PALETTE_TURN_ALLOWED1 = new Color(0f, 0.5f, 0f, 0.3f);
+
+        /// <summary>
+        /// Solid green, for blinking green on allowed turn circles.
+        /// </summary>
+        private static readonly Color PALETTE_TURN_ALLOWED2 = new Color(0f, 1f, 0f, 0.66f);
+
+        /// <summary>
+        /// Used for turn circles which are not allowed but should be visible
+        /// </summary>
+        private static readonly Color PALETTE_TURN_INACTIVE = Color.black;
 
         private void RenderHoveredNode(RenderManager.CameraInfo cameraInfo) {
             var nodeBuffer = Singleton<NetManager>.instance.m_nodes.m_buffer;
@@ -92,6 +106,9 @@ public partial class LaneArrowTool {
             if (HoveredLaneId != 0 && incomingLanes_.Contains(HoveredLaneId)) {
                 // TODO: Check if hovered lane has SelectedNodeId as one of its ends
                 RenderLaneOverlay(cameraInfo, laneBuffer[HoveredLaneId], 2f, PALETTE_HOVERED);
+
+                RenderOutgoingDirectionsAsLanes(cameraInfo, HoveredLaneId,
+                                                RenderOutgoingLaneStyle.Circles);
             }
 
             // Draw the incoming lanes in black/blue pulsating color
@@ -122,39 +139,63 @@ public partial class LaneArrowTool {
             var orange = MainTool.GetToolColor(true, false);
             RenderLaneOverlay(cameraInfo, laneBuffer[SelectedLaneId], 2f, orange);
 
-            RenderOutgoingDirectionsAsLanes(cameraInfo);
+            RenderOutgoingDirectionsAsLanes(cameraInfo, SelectedLaneId,
+                                            RenderOutgoingLaneStyle.Sausages);
         }
 
-        private void RenderOutgoingDirectionsAsLanes(RenderManager.CameraInfo cameraInfo) {
+        private enum RenderOutgoingLaneStyle {
+            Sausages,
+            Circles
+        }
+
+        /// <summary>
+        /// A helper which relies on outgoingTurns_ being set up, renders outgoing lanes
+        /// for the given laneId, in green
+        /// </summary>
+        /// <param name="cameraInfo"></param>
+        /// <param name="laneId"></param>
+        private void RenderOutgoingDirectionsAsLanes(RenderManager.CameraInfo cameraInfo,
+                                                     uint laneId,
+                                                     RenderOutgoingLaneStyle style) {
+            if (!outgoingTurns_.HasValue || laneId == 0) {
+                return;
+            }
+
             var laneBuffer = Singleton<NetManager>.instance.m_lanes.m_buffer;
 
             // Draw outgoing directions for the last selected segment
-            var selectedLane = laneBuffer[SelectedLaneId];
+            var selectedLane = laneBuffer[laneId];
             var selectedLaneFlags = (NetLane.Flags) selectedLane.m_flags;
 
             // Turns out of this node converted to lanes (we want all turn bits here)
-            var outgoingLaneTurns = outgoingTurns_.GetLanesFor(NetLane.Flags.LeftForwardRight);
-            var hoveredDirection = outgoingTurns_.FindDirection(HoveredSegmentId);
+            var outgoingLaneTurns = outgoingTurns_?.GetLanesFor(NetLane.Flags.LeftForwardRight);
+            var hoveredDirection = outgoingTurns_?.FindDirection(HoveredSegmentId);
 
-            foreach (var outDirections in outgoingTurns_.AllTurns) {
+            foreach (var outDirections in outgoingTurns_?.AllTurns) {
                 switch (outDirections.Key) {
                     case ArrowDirection.Left:
-                        RenderOutgoingDirection(cameraInfo,
-                                                (selectedLaneFlags & NetLane.Flags.Left) != 0,
-                                                hoveredDirection == ArrowDirection.Left,
-                                                outgoingLaneTurns[outDirections.Key]);
+                        RenderOutgoingDirectionsAsLanes_One(
+                            cameraInfo,
+                            style,
+                            (selectedLaneFlags & NetLane.Flags.Left) != 0,
+                            hoveredDirection == ArrowDirection.Left,
+                            outgoingLaneTurns[outDirections.Key]);
                         break;
                     case ArrowDirection.Forward:
-                        RenderOutgoingDirection(cameraInfo,
-                                                (selectedLaneFlags & NetLane.Flags.Forward) != 0,
-                                                hoveredDirection == ArrowDirection.Forward,
-                                                outgoingLaneTurns[outDirections.Key]);
+                        RenderOutgoingDirectionsAsLanes_One(
+                            cameraInfo,
+                            style,
+                            (selectedLaneFlags & NetLane.Flags.Forward) != 0,
+                            hoveredDirection == ArrowDirection.Forward,
+                            outgoingLaneTurns[outDirections.Key]);
                         break;
                     case ArrowDirection.Right:
-                        RenderOutgoingDirection(cameraInfo,
-                                                (selectedLaneFlags & NetLane.Flags.Right) != 0,
-                                                hoveredDirection == ArrowDirection.Right,
-                                                outgoingLaneTurns[outDirections.Key]);
+                        RenderOutgoingDirectionsAsLanes_One(
+                            cameraInfo,
+                            style,
+                            (selectedLaneFlags & NetLane.Flags.Right) != 0,
+                            hoveredDirection == ArrowDirection.Right,
+                            outgoingLaneTurns[outDirections.Key]);
                         break;
                     case ArrowDirection.Turn:
                     case ArrowDirection.None:
@@ -170,11 +211,13 @@ public partial class LaneArrowTool {
         /// <param name="turnEnabled">Render green if the turn is enabled</param>
         /// <param name="turnHovered">Render green+white, or white if hovered</param>
         /// <param name="laneTurns">Set of all lane ids to render</param>
-        private void RenderOutgoingDirection(RenderManager.CameraInfo cameraInfo,
-                                             bool turnEnabled,
-                                             bool turnHovered,
-                                             HashSet<uint> laneTurns) {
-            var color = PALETTE_TURN_ALLOWED;
+        private void RenderOutgoingDirectionsAsLanes_One(
+            RenderManager.CameraInfo cameraInfo,
+            RenderOutgoingLaneStyle style,
+            bool turnEnabled,
+            bool turnHovered,
+            HashSet<uint> laneTurns) {
+            var color = PALETTE_TURN_ALLOWED1; // no blinking/translucent green
             if (!turnEnabled) {
                 // Replace with pulsating blue
                 var t = Time.time - (float) Math.Truncate(Time.time); // fraction
@@ -187,10 +230,59 @@ public partial class LaneArrowTool {
             }
 
             var laneBuffer = Singleton<NetManager>.instance.m_lanes.m_buffer;
+            var nodeBuffer = Singleton<NetManager>.instance.m_nodes.m_buffer;
+            var selectedNode = nodeBuffer[SelectedNodeId];
+
+            switch (style) {
+                case RenderOutgoingLaneStyle.Sausages:
+                    foreach (var laneId in laneTurns) {
+                        var lane = laneBuffer[laneId];
+                        RenderLaneOverlay(cameraInfo, lane, 2f, color);
+                    }
 
-            foreach (var laneId in laneTurns) {
-                RenderLaneOverlay(cameraInfo, laneBuffer[laneId], 2f, color);
+                    break;
+                case RenderOutgoingLaneStyle.Circles:
+                    foreach (var laneId in laneTurns) {
+                        var lane = laneBuffer[laneId];
+                        RenderOutgoingLaneAsCircle(cameraInfo, turnEnabled, color, lane, selectedNode);
+                    }
+
+                    break;
+            }
+        }
+
+        /// <summary>
+        /// A helper which displays outgoing lane as a circle (or maybe a sprite?)
+        /// </summary>
+        /// <param name="cameraInfo">The camera</param>
+        /// <param name="turnEnabled">Whether the exit is possible, or blocked</param>
+        /// <param name="color">Base render color (pulsating blue most likely)</param>
+        /// <param name="lane">The lane we are drawing</param>
+        /// <param name="selectedNode">The node which is being edited</param>
+        private static void RenderOutgoingLaneAsCircle(RenderManager.CameraInfo cameraInfo,
+                                                       bool turnEnabled,
+                                                       Color color,
+                                                       NetLane lane,
+                                                       NetNode selectedNode) {
+            if (turnEnabled) {
+                // blinking bright green/translucent green
+                var t = (long)Math.Truncate(Time.time * 2f); // integer part, 2x faster blink
+                color = t % 2 == 0 ? PALETTE_TURN_ALLOWED1 : PALETTE_TURN_ALLOWED2;
+            } else {
+                color = PALETTE_TURN_INACTIVE; // black
             }
+
+            // Pick end of the lane, closest to the node being edited
+            var aPosition = lane.CalculatePosition(0f);
+            var bPosition = lane.CalculatePosition(1f);
+            var aDistSqr = (aPosition - selectedNode.m_position).sqrMagnitude;
+            var bDistSqr = (bPosition - selectedNode.m_position).sqrMagnitude;
+            var nearestPos = aDistSqr < bDistSqr ? aPosition : bPosition;
+
+            Singleton<ToolManager>.instance.m_drawCallData.m_overlayCalls += 1;
+            Singleton<RenderManager>.instance.OverlayEffect.DrawCircle(
+                cameraInfo, color, nearestPos, 2f,
+                -1f, 1280f, false, false);
         }
 
         /// <summary>
@@ -211,17 +303,9 @@ public partial class LaneArrowTool {
         }
 
         private static void RenderLaneOverlay(RenderManager.CameraInfo cameraInfo,
-                                              //ref NetSegment segment,
                                               NetLane lane,
                                               float width,
                                               Color color) {
-//            var info = segment.Info;
-//            if (info == null ||
-//                ((segment.m_flags & NetSegment.Flags.Untouchable) != NetSegment.Flags.None
-//                 && !info.m_overlayVisible)) {
-//                return;
-//            }
-
             ++Singleton<ToolManager>.instance.m_drawCallData.m_overlayCalls;
 
             Singleton<RenderManager>.instance.OverlayEffect.DrawBezier(
diff --git a/TLM/TLM/UI/SubTools/LaneArrows/LaneArrowTool_Click.cs b/TLM/TLM/UI/SubTools/LaneArrows/LaneArrowTool_UI.cs
similarity index 82%
rename from TLM/TLM/UI/SubTools/LaneArrows/LaneArrowTool_Click.cs
rename to TLM/TLM/UI/SubTools/LaneArrows/LaneArrowTool_UI.cs
index d3305c314..94725b368 100644
--- a/TLM/TLM/UI/SubTools/LaneArrows/LaneArrowTool_Click.cs
+++ b/TLM/TLM/UI/SubTools/LaneArrows/LaneArrowTool_UI.cs
@@ -1,10 +1,13 @@
+//------------------------------------------------------------------------------
+// User interactions part of the Lane Arrow Tool
+// Handles mouse moving and clicking
+
 namespace TrafficManager.UI.SubTools.LaneArrows {
     using System;
     using ColossalFramework;
     using CSUtil.Commons;
     using Manager.Impl;
     using State;
-    using UnityEngine;
 
     public partial class LaneArrowTool {
         /// <summary>
@@ -79,7 +82,7 @@ public partial class LaneArrowTool {
 
         private void OnPrimaryClickOverlay_OutgoingDirections() {
             if (HoveredSegmentId != 0) {
-                var hoveredDirection = outgoingTurns_.FindDirection(HoveredSegmentId);
+                var hoveredDirection = outgoingTurns_?.FindDirection(HoveredSegmentId);
                 var segmentBuffer = Singleton<NetManager>.instance.m_segments.m_buffer;
                 var hoveredSegment = segmentBuffer[HoveredSegmentId];
 
@@ -142,5 +145,30 @@ public partial class LaneArrowTool {
 //                Deselect();
 //            }
         }
+
+        internal override void OnChangeHoveredSegment(ushort oldSegmentId, ushort newSegmentId) {
+            switch (fsm_.State) {
+                case State.IncomingSelect:
+                    OnChangeHoveredSegment_IncomingSelect(oldSegmentId, newSegmentId);
+                    break;
+
+                case State.NodeSelect:
+                case State.OutgoingDirections:
+                case State.OutgoingLanes:
+                case State.Off:
+                    break;
+            }
+        }
+
+        private void OnChangeHoveredSegment_IncomingSelect(ushort oldSegmentId, ushort newSegmentId) {
+            if (newSegmentId == 0) {
+                outgoingTurns_ = null;
+                return;
+            }
+
+            outgoingTurns_ = GetOutgoingTurns(SelectedNodeId, newSegmentId);
+        }
     }
-}
\ No newline at end of file
+}
+
+//------------------------------------------------------------------------------
diff --git a/TLM/TLM/UI/TrafficManagerTool.cs b/TLM/TLM/UI/TrafficManagerTool.cs
index 1c92e09ba..8d4c5b16e 100644
--- a/TLM/TLM/UI/TrafficManagerTool.cs
+++ b/TLM/TLM/UI/TrafficManagerTool.cs
@@ -8,7 +8,6 @@
     using CSUtil.Commons;
     using Custom.AI;
     using GenericGameBridge.Service;
-    using JetBrains.Annotations;
     using MainMenu;
     using Manager;
     using Manager.Impl;
@@ -21,17 +20,58 @@
     using Util;
     using static Traffic.Data.ExtCitizenInstance;
 
-    [UsedImplicitly]
     public class TrafficManagerTool : DefaultTool, IObserver<GlobalConfig> {
         private ToolMode toolMode_;
 
-        internal static ushort HoveredNodeId;
+        /// <summary>
+        /// The node id currently under the mouse pointer
+        /// </summary>
+        internal ushort HoveredNodeId {
+            get => hoveredNodeId_;
+            private set {
+                if (hoveredNodeId_ == value) {
+                    return;
+                }
+
+                var oldValue = hoveredNodeId_;
+                hoveredNodeId_ = value;
+                activeSubTool?.OnChangeHoveredNode(oldValue, value);
+            }
+        }
+
+        /// <summary>
+        /// The segment id currently under the mouse pointer
+        /// </summary>
+        internal ushort HoveredSegmentId {
+            get => hoveredSegmentId_;
+            private set {
+                if (hoveredSegmentId_ == value) {
+                    return;
+                }
 
-        internal static ushort HoveredSegmentId;
+                var oldValue = hoveredSegmentId_;
+                hoveredSegmentId_ = value;
+                activeSubTool?.OnChangeHoveredSegment(oldValue, value);
+            }
+        }
+
+        /// <summary>
+        /// The lane id (inside the hoveredSegmentId) currently closest to the mouse pointer
+        /// </summary>
+        internal uint HoveredLaneId {
+            get => hoveredLaneId_;
+            private set {
+                if (hoveredLaneId_ == value) {
+                    return;
+                }
 
-        internal static uint HoveredLaneId = 0;
+                var oldValue = hoveredLaneId_;
+                hoveredLaneId_ = value;
+                activeSubTool?.OnChangeHoveredLane(oldValue, value);
+            }
+        }
 
-        private static bool mouseClickProcessed;
+        private bool mouseClickProcessed;
 
         private const float DEBUG_CLOSE_LOD = 300f;
 
@@ -39,11 +79,11 @@ public class TrafficManagerTool : DefaultTool, IObserver<GlobalConfig> {
 
         private IDictionary<ToolMode, SubTool> subTools = new TinyDictionary<ToolMode, SubTool>();
 
-        public static ushort SelectedNodeId { get; internal set; }
+        public ushort SelectedNodeId { get; internal set; }
 
-        public static ushort SelectedSegmentId { get; internal set; }
+        public ushort SelectedSegmentId { get; internal set; }
 
-        public static uint SelectedLaneId { get; internal set; }
+        public uint SelectedLaneId { get; internal set; }
 
         public static TransportDemandViewMode CurrentTransportDemandViewMode {
             get; internal set;
@@ -55,9 +95,15 @@ public class TrafficManagerTool : DefaultTool, IObserver<GlobalConfig> {
             ExtVehicleType.Service, ExtVehicleType.RailVehicle
         };
 
-        private static SubTool activeSubTool;
+        private SubTool activeSubTool;
+
+        private IDisposable confDisposable;
+
+        private ushort hoveredNodeId_;
+
+        private ushort hoveredSegmentId_;
 
-        private static IDisposable confDisposable;
+        private uint hoveredLaneId_;
 
         static TrafficManagerTool() {
         }
@@ -754,8 +800,10 @@ public class TrafficManagerTool : DefaultTool, IObserver<GlobalConfig> {
             foreach (var ln in GetIncomingLaneList(HoveredSegmentId, HoveredNodeId)) {
                 var lane = laneBuffer[ln.laneId];
 
-                var sqrDist1 = (groundOutput.m_hitPos - lane.m_bezier.a).sqrMagnitude;
-                var sqrDist2 = (groundOutput.m_hitPos - lane.m_bezier.b).sqrMagnitude;
+                var aPosition = lane.CalculatePosition(0f);
+                var bPosition = lane.CalculatePosition(1f);
+                var sqrDist1 = (groundOutput.m_hitPos - aPosition).sqrMagnitude;
+                var sqrDist2 = (groundOutput.m_hitPos - bPosition).sqrMagnitude;
                 var sqrDist = Mathf.Min(sqrDist1, sqrDist2);
                 if (sqrDist < minSqrDist) {
                     minSqrDist = sqrDist;