Changed how blocks of selected nodes are replaced with a new type.

Author: KN4CK3R

UI/MemoryViewControl.cs

@@ -726,38 +726,117 @@ public void InsertBytes(int length)
 			}
 		}
 
-		public void ReplaceSelectedNodesWithType(Type type)
+		/// <summary>Groups the selected nodes in blocks if the nodes are continues.</summary>
+		/// <param name="selection">The selection to partition.</param>
+		/// <returns>An enumeration with blocks of continues nodes.</returns>
+		private static IEnumerable<List<HotSpot>> PartitionSelectedNodes(IEnumerable<HotSpot> selection)
 		{
-			Contract.Requires(type != null);
-			Contract.Requires(type.IsSubclassOf(typeof(BaseNode)));
+			Contract.Requires(selection != null);
 
-			var newSelected = new List<HotSpot>(selectedNodes.Count);
+			var it = selection.GetEnumerator();
+			if (!it.MoveNext())
+			{
+				yield break;
+			}
+
+			var partition = new List<HotSpot>();
+			partition.Add(it.Current);
 
-			foreach (var selected in selectedNodes.Where(s => !(s.Node is ClassNode)))
+			var last = it.Current;
+
+			while (it.MoveNext())
 			{
-				var node = Activator.CreateInstance(type) as BaseNode;
+				if (it.Current.Address != last.Address + last.Node.MemorySize)
+				{
+					yield return partition;
+
+					partition = new List<HotSpot>();
+				}
+
+				partition.Add(it.Current);
 
-				node.Intialize();
+				last = it.Current;
+			}
 
-				if (selected.Node.ParentNode.ReplaceChildNode(selected.Node, node))
+			if (partition.Count != 0)
+			{
+				yield return partition;
+			}
+		}
+
+		private static IEnumerable<HotSpot> RecursiveReplaceNodes(BaseContainerNode parentNode, Type type, IEnumerable<BaseNode> nodesToReplace)
+		{
+			Contract.Requires(parentNode != null);
+			Contract.Requires(type != null);
+			Contract.Requires(nodesToReplace != null);
+
+			foreach (var nodeToReplace in nodesToReplace)
+			{
+				var temp = new List<BaseNode>();
+				if (parentNode.ReplaceChildNode(nodeToReplace, type, ref temp))
 				{
+					var node = temp.First();
+
 					node.IsSelected = true;
 
-					var hotspot = new HotSpot
+					yield return new HotSpot
 					{
 						Address = node.ParentNode.Offset.Add(node.Offset),
 						Node = node
 					};
 
-					newSelected.Add(hotspot);
-
-					if (selectionAnchor.Node == selected.Node)
+					if (temp.Count > 1)
 					{
-						selectionAnchor = hotspot;
+						foreach (var hs in RecursiveReplaceNodes(parentNode, type, temp))
+						{
+							yield return hs;
+						}
 					}
-					if (selectionCaret.Node == selected.Node)
+				}
+			}
+		}
+
+		public void ReplaceSelectedNodesWithType(Type type)
+		{
+			Contract.Requires(type != null);
+			Contract.Requires(type.IsSubclassOf(typeof(BaseNode)));
+
+			var newSelected = new List<HotSpot>(selectedNodes.Count);
+
+			// Group the selected nodes in continues selected blocks.
+			foreach (var selectedPartition in PartitionSelectedNodes(selectedNodes.Where(s => !(s.Node is ClassNode))))
+			{
+				foreach (var selected in selectedPartition)
+				{
+					var createdNodes = new List<BaseNode>();
+					if (selected.Node.ParentNode.ReplaceChildNode(selected.Node, type, ref createdNodes))
 					{
-						selectionCaret = hotspot;
+						var node = createdNodes.First();
+
+						node.IsSelected = true;
+
+						var hotspot = new HotSpot
+						{
+							Address = node.ParentNode.Offset.Add(node.Offset),
+							Node = node
+						};
+
+						newSelected.Add(hotspot);
+
+						if (selectionAnchor.Node == selected.Node)
+						{
+							selectionAnchor = hotspot;
+						}
+						if (selectionCaret.Node == selected.Node)
+						{
+							selectionCaret = hotspot;
+						}
+
+						// If the block contains more than one node and the replaced node decomposed to more than one node replace the new nodes to.
+						if (selectedPartition.Count > 1 && createdNodes.Count > 1)
+						{
+							newSelected.AddRange(RecursiveReplaceNodes(selected.Node.ParentNode, type, createdNodes.Skip(1)));
+						}
 					}
 				}
 			}