- auto size Name column in node

- rewrote ObjectGraphBuilder so that now property Expressions are not evaluated until rendered

git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/trunk@4419 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/Visualizers/Graph/Drawing/PositionedGraphNodeControl.xaml

@@ -43,17 +43,19 @@
                 <GridView>
                         <GridView.ColumnHeaderContainerStyle>
                             <Style>
-                                <Setter Property="FrameworkElement.Visibility" Value="Collapsed"/>
+                            		<!-- 
+                                <Setter Property="FrameworkElement.Visibility" Value="Collapsed"/>	-->
+                        	 		<Setter Property="FrameworkElement.Height" Value="1"/>
                             </Style>
                         </GridView.ColumnHeaderContainerStyle>
                         <GridView.Columns>
                         	   <!-- Expand button (either property or nested) -->
-                            <GridViewColumn Header="Plus" Width="35">
+                            <GridViewColumn Header="Plus" Width="Auto">
                                 <GridViewColumn.CellTemplate>
                                     <DataTemplate>
                                         <StackPanel>
-                                            <ToggleButton x:Name="Expander" Width="20" Margin="0" IsChecked="{Binding IsExpanded}" Click="NestedExpandButton_Click" Padding="0">+</ToggleButton>
+                                            <ToggleButton x:Name="Expander" Width="20" Margin="-4 -1 -4 -1" IsChecked="{Binding IsExpanded}" Click="NestedExpandButton_Click" Padding="0">+</ToggleButton>
-                                            <ToggleButton x:Name="PropertyExpander" Width="20" Margin="0" IsChecked="{Binding IsPropertyExpanded}" Click="PropertyExpandButton_Click" Padding="0">+</ToggleButton>
+                                            <ToggleButton x:Name="PropertyExpander" Width="20" Margin="-4 -1 -4 -1" IsChecked="{Binding IsPropertyExpanded}" Click="PropertyExpandButton_Click" Padding="0">+</ToggleButton>
                                         </StackPanel>
                                         <DataTemplate.Triggers>
                                             <DataTrigger Binding="{Binding Path=HasChildren}" Value="False">
@@ -70,24 +72,26 @@
                                 </GridViewColumn.CellTemplate>
                             </GridViewColumn>
                         	   <!-- Name -->
-                            <GridViewColumn Header="Name" Width="60">
+                            <GridViewColumn Header="Name" Width="Auto">
                                 <GridViewColumn.CellTemplate>
                                     <DataTemplate>
                                         		<!--
                                         		<TextBlock Text="hello" MinWidth="100"></TextBlock>
 												-->
-                                            <TextBlock Text="{Binding Name}" MinWidth="80"></TextBlock>
+                                    	<StackPanel Orientation="Horizontal">
+                                            <TextBlock Text="{Binding Name}"></TextBlock></StackPanel>
                                     </DataTemplate>
                                 </GridViewColumn.CellTemplate>
                             </GridViewColumn>
                         	   <!-- Text -->
-                            <GridViewColumn Header="Value" Width="80">
+                            <GridViewColumn Header="Value      " Width="Auto">
                                 <GridViewColumn.CellTemplate>
                                     <DataTemplate>
                                     		<!--
                                     		<TextBlock Text="val" MinWidth="100"></TextBlock>
 											-->
-                                        <TextBlock Text="{Binding Text}" MinWidth="80"></TextBlock>
+                                    	<StackPanel Orientation="Horizontal">
+                                        <TextBlock Text="{Binding Text}"></TextBlock></StackPanel>
                                     </DataTemplate>
                                 </GridViewColumn.CellTemplate>
                             </GridViewColumn>

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/Visualizers/Graph/Drawing/PositionedGraphNodeControl.xaml.cs

@@ -4,7 +4,11 @@
 //     <owner name="Martin Koníček" email="martin.konicek@gmail.com"/>
 //     <version>$Revision$</version>
 // </file>
+using System;
+using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.Linq;
+using System.Reflection;
 using System.Text;
 using System.Windows;
 using System.Windows.Controls;
@@ -13,11 +17,10 @@ using System.Windows.Data;
 using System.Windows.Documents;
 using System.Windows.Input;
 using System.Windows.Media;
-using Debugger.AddIn.Visualizers.Graph.Layout;
+
-using System;
-using System.Collections.Generic;
-using System.Linq;
 using Debugger.AddIn.Visualizers.Common;
+using Debugger.AddIn.Visualizers.Graph.Layout;
+using System.Windows.Threading;
 
 namespace Debugger.AddIn.Visualizers.Graph.Drawing
 {
@@ -61,6 +64,53 @@ namespace Debugger.AddIn.Visualizers.Graph.Drawing
 				this.view = getInitialView(this.root);
 				// data virtualization, PropertyNodeViewModel implements IEvaluate
 				this.listView.ItemsSource = new VirtualizingObservableCollection<ContentNode>(this.view);
+				
+				int maxLen = this.view.Max(contentNode => { return contentNode.Name.Length; } );
+				int spaces = Math.Max((int)(maxLen * 1.5), 0);
+				string sp = "";
+				for (int i = 0; i < spaces; i++)
+					sp += " ";
+					
+				GridView gv = listView.View as GridView;
+				gv.Columns[1].Header = "Name" + sp;
+				
+				
+				//AutoSizeColumns();
+				
+				/*DispatcherTimer t = new DispatcherTimer();
+				t.Interval = TimeSpan.FromMilliseconds(1000);
+				t.Start();
+				t.Tick += (s, ee) => { AutoSizeColumns(); t.Stop(); };*/
+			}
+		}
+		
+		public void AutoSizeColumns()
+		{
+			//listView.UpdateLayout();
+			//listView.Measure(new Size(800, 800));
+			//double sum = 0;
+			GridView gv = listView.View as GridView;
+			if (gv != null)
+			{
+				foreach (var c in gv.Columns)
+				{
+					//var header = c.Header as GridViewColumnHeader;
+					// Code below was found in GridViewColumnHeader.OnGripperDoubleClicked() event handler (using Reflector)
+					// i.e. it is the same code that is executed when the gripper is double clicked
+					//var uw = c.GetType().GetMethod("UpdateActualWidth", BindingFlags.Instance | BindingFlags.InvokeMethod | BindingFlags.NonPublic);
+					//uw.Invoke(c, new object[] { });
+					//if (double.IsNaN(c.Width))
+					{
+						c.Width = c.ActualWidth;
+					}
+					c.Width = double.NaN;
+
+					/*var dw = c.GetType().GetProperty("DesiredWidth", BindingFlags.Instance | BindingFlags.InvokeMethod | BindingFlags.NonPublic);
+					double desired = (double)dw.GetValue(c, null);
+					c.Width = c.ActualWidth;	// ActualWidth is not correct until GridViewRowPresenter gets measured
+					c.Width = double.NaN;
+					sum += c.Width;*/
+				}
 			}
 		}
 		
@@ -85,6 +135,7 @@ namespace Debugger.AddIn.Visualizers.Graph.Drawing
 			PositionedNodeProperty property = clickedNode.Property;
 			//property.IsPropertyExpanded = !property.IsPropertyExpanded;  // done by databinding
 			clickedButton.Content = property.IsPropertyExpanded ? "-" : "+";
+			
 			if (property.IsPropertyExpanded)
 			{
 				OnPropertyExpanded(property);
@@ -112,6 +163,7 @@ namespace Debugger.AddIn.Visualizers.Graph.Drawing
 					this.view.Insert(clickedIndex + i, childNode);
 					i++;
 				}
+				// insertChildren(clickedNode, this.view, clickedIndex); // TODO
 				OnContentNodeExpanded(clickedNode);
 			}
 			else
@@ -124,19 +176,21 @@ namespace Debugger.AddIn.Visualizers.Graph.Drawing
 				}
 				OnContentNodeCollapsed(clickedNode);
 			}
+			
+			//AutoSizeColumns();
 
 			// set to Auto again to resize columns
-			var colName = (this.listView.View as GridView).Columns[0];
+			/*var colName = (this.listView.View as GridView).Columns[0];
 			var colValue = (this.listView.View as GridView).Columns[1];
 			colName.Width = 300;
 			colName.Width = double.NaN;
 			colValue.Width = 300;
 			colValue.Width = double.NaN;
-			//this.view.Insert(0, new NestedNodeViewModel());
+			//this.view.Insert(0, new ContentNode());
 			//this.view.RemoveAt(0);
 			this.listView.UpdateLayout();
 			this.listView.Width = colName.ActualWidth + colValue.ActualWidth + 30;
-			this.listView.Width = double.NaN;
+			this.listView.Width = double.NaN;*/
 		}
 		
 		private ObservableCollection<ContentNode> getInitialView(ContentNode root)

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/Visualizers/Graph/Layout/ContentNode.cs

@@ -88,22 +88,12 @@ namespace Debugger.AddIn.Visualizers.Graph.Layout
 		/// <summary>
 		/// Show a button to expand property associated with this node?
 		/// </summary>
-		public bool ShowExpandPropertyButton
+		public virtual bool ShowExpandPropertyButton
 		{
 			get 
 			{
-				var thisAsPropertyNode = this as ContentPropertyNode;
+				// this is NestedNodeViewModel -> no property, don't show expand button
-				if (thisAsPropertyNode == null) 
+				return false;
-				{
-					// this is NestedNodeViewModel -> no property, don't show expand button
-					return false;
-				}
-				else
-				{
-					// this is PositionedNodeViewModel -> show expand button when appropriate
-					PositionedNodeProperty property = thisAsPropertyNode.Property;
-					return (!property.IsAtomic && !property.IsNull);
-				}
 			}
 		}
 		
@@ -150,7 +140,7 @@ namespace Debugger.AddIn.Visualizers.Graph.Layout
 		
 		public virtual void InitFrom(AbstractNode source, Expanded expanded)
 		{
-			this.Name = getNestedNodeName(source);
+			this.Name = getContentNodeName(source);
 			this.Text = "";			// lazy evaluated later
 			this.IsNested = true;
 			this.path = this.Parent == null ? this.Name : this.Parent.Path + "." + this.Name;
@@ -173,7 +163,7 @@ namespace Debugger.AddIn.Visualizers.Graph.Layout
 			}
 		}
 		
-		private string getNestedNodeName(AbstractNode source)
+		private string getContentNodeName(AbstractNode source)
 		{
 			if (source is ThisNode)
 			{

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/Visualizers/Graph/Layout/ContentPropertyNode.cs

@@ -15,7 +15,7 @@ namespace Debugger.AddIn.Visualizers.Graph.Layout
 	{
 		PositionedNodeProperty positionedProperty;
 		
-		public ContentPropertyNode(PositionedGraphNode containingNode, ContentNode parent) 
+		public ContentPropertyNode(PositionedGraphNode containingNode, ContentNode parent)
 			: base(containingNode, parent)
 		{
 		}
@@ -45,6 +45,15 @@ namespace Debugger.AddIn.Visualizers.Graph.Layout
 			this.Text = this.positionedProperty.Value;
 		}
 		
+		public override bool ShowExpandPropertyButton
+		{
+			get
+			{
+				// show expand button when appropriate
+				return (!this.positionedProperty.IsAtomic && !this.positionedProperty.IsNull);
+			}
+		}
+		
 		public override void InitFrom(AbstractNode source, Expanded expanded)
 		{
 			if (!(source is PropertyNode))
@@ -57,7 +66,7 @@ namespace Debugger.AddIn.Visualizers.Graph.Layout
 			this.IsNested = false;
 			this.IsExpanded = false;			// always false, property content nodes are never expanded
 			this.positionedProperty = new PositionedNodeProperty(
-				sourcePropertyNode.Property, this.ContainingNode, 
+				sourcePropertyNode.Property, this.ContainingNode,
 				expanded.Expressions.IsExpanded(sourcePropertyNode.Property.Expression));
 		}
 	}

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/Visualizers/Graph/Layout/PositionedGraphNode.cs

@@ -73,7 +73,7 @@ namespace Debugger.AddIn.Visualizers.Graph.Layout
 		private void initVisualControl()
 		{
 			this.nodeVisualControl = new PositionedGraphNodeControl();
-			this.nodeVisualControl.MaxHeight = 200;
+			this.nodeVisualControl.MaxHeight = 300;
 			
 			// propagate events from nodeVisualControl
 			this.nodeVisualControl.PropertyExpanded += new EventHandler<PositionedPropertyEventArgs>(NodeVisualControl_PropertyExpanded);
@@ -104,7 +104,7 @@ namespace Debugger.AddIn.Visualizers.Graph.Layout
 		
 		public void Measure()
 		{
-			this.nodeVisualControl.Measure(new Size(500, 500));
+			this.nodeVisualControl.Measure(new Size(800, 800));
 		}
 		
 		public double Left { get; set; }

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/Visualizers/Graph/Layout/Tree/NeatoEdgeRouter.cs

@@ -30,7 +30,7 @@ namespace Debugger.AddIn.Visualizers.Graph.Layout
 		/// <returns><see cref="PositionedGraph" /> with preserved node positions and calculated edge positions.</returns>
 		public PositionedGraph CalculateEdges(PositionedGraph graphWithNodesPositioned)
 		{
-			DotFormatter dotFormatter = new BoxDotFormatter(graphWithNodesPositioned);
+			DotFormatter dotFormatter = new RecordDotFormatter(graphWithNodesPositioned);
 			
 			// start Neato.exe
 			NeatoProcess neatoProcess = NeatoProcess.Start();

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/Visualizers/Graph/ObjectGraph/ObjectGraph.cs

@@ -55,7 +55,7 @@ namespace Debugger.AddIn.Visualizers.Graph
         {
         	seenNodes.Add(root);
         	
-        	foreach(var prop in root.ComplexProperties)
+        	foreach(var prop in root.Properties)
         	{
         		if (prop.TargetNode != null && !seenNodes.Contains(prop.TargetNode))
         			determineReachableNodes(prop.TargetNode, seenNodes);

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/Visualizers/Graph/ObjectGraph/ObjectGraphBuilder.cs

@@ -112,7 +112,7 @@ namespace Debugger.AddIn.Visualizers.Graph
 		
 		public ObjectGraphNode ObtainNodeForExpression(Expression expr, out bool createdNewNode)
 		{
-			return ObtainNodeForValue(expr.GetPermanentReference(), out createdNewNode);
+			return ObtainNodeForValue(expr.EvalPermanentReference(), out createdNewNode);
 		}
 		
 		/// <summary>
@@ -157,11 +157,12 @@ namespace Debugger.AddIn.Visualizers.Graph
 			}
 			
 			// non-public members
-			if (type.HasMembers(nonPublicInstanceMemberFlags))
+			var nonPublicProperties = getProperties(value, type, this.nonPublicInstanceMemberFlags);
+			if (nonPublicProperties.Count > 0)
 			{
 				var nonPublicMembersNode = new NonPublicMembersNode();
 				node.AddChild(nonPublicMembersNode);
-				foreach (var nonPublicProperty in getProperties(value, type, this.nonPublicInstanceMemberFlags))
+				foreach (var nonPublicProperty in nonPublicProperties)
 				{
 					nonPublicMembersNode.AddChild(new PropertyNode(nonPublicProperty));
 				}
@@ -183,7 +184,26 @@ namespace Debugger.AddIn.Visualizers.Graph
 		{
 			List<ObjectGraphProperty> propertyList = new List<ObjectGraphProperty>();
 			
-			// take all properties for this value (type = value's real type)
+			foreach (PropertyInfo memberProp in shownType.GetProperties(flags))
+			{
+				if (memberProp.Name.Contains("<"))
+					continue;
+
+				// TODO just temporary - ObjectGraphProperty needs an expression
+				// to use expanded / nonexpanded (and to evaluate?)
+				Expression propExpression = value.Expression.AppendMemberReference(memberProp);
+				// Value, IsAtomic are lazy evaluated
+				//var t = memberProp.DeclaringType;
+				propertyList.Add(new ObjectGraphProperty
+				                 { Name = memberProp.Name,
+				                 	Expression = propExpression, Value = "",
+				                 	/*PropInfo = memberProp,*/ IsAtomic = true, TargetNode = null });
+				
+			}
+			
+			return propertyList.Sorted(ObjectPropertyComparer.Instance);
+			
+			/*// take all properties for this value (type = value's real type)
 			foreach(Expression memberExpr in value.Expression.AppendObjectMembers(shownType, flags))
 			{
 				// skip private backing fields
@@ -201,13 +221,12 @@ namespace Debugger.AddIn.Visualizers.Graph
 				}
 				else
 				{
-					ObjectGraphNode targetNode = null;
 					bool memberIsNull = memberExpr.IsNull();
-					propertyList.Add(createComplexProperty(memberName, memberExpr, targetNode, memberIsNull));
+					propertyList.Add(createComplexProperty(memberName, memberExpr, null, memberIsNull));
 				}
 			}
 			
-			return propertyList.Sorted(ObjectPropertyComparer.Instance);
+			return propertyList.Sorted(ObjectPropertyComparer.Instance);*/
 		}
 		
 		/// <summary>
@@ -217,23 +236,34 @@ namespace Debugger.AddIn.Visualizers.Graph
 		/// <param name="expandedNodes"></param>
 		private void loadNeighborsRecursive(ObjectGraphNode thisNode, ExpandedExpressions expandedNodes)
 		{
-			foreach(ObjectGraphProperty complexProperty in thisNode.ComplexProperties)
+			//foreach(ObjectGraphProperty complexProperty in thisNode.ComplexProperties)
+			foreach(ObjectGraphProperty complexProperty in thisNode.Properties)
 			{
 				ObjectGraphNode targetNode = null;
 				// we are only evaluating expanded nodes here
 				// (we have to do this to know the "shape" of the graph)
 				// property laziness makes sense, as we are not evaluating atomic and non-expanded properties out of user's view
-				if (!complexProperty.IsNull && expandedNodes.IsExpanded(complexProperty.Expression))
+				if (/*!complexProperty.IsNull && we dont know yet if it's null */expandedNodes.IsExpanded(complexProperty.Expression))
 				{
-					Value memberValue = complexProperty.Expression.GetPermanentReference();
+					// if expanded, evaluate this property
-					
+					Value memberValue = complexProperty.Expression.Evaluate(this.debuggerService.DebuggedProcess);
-					bool createdNew;
+					if (memberValue.IsNull)
-					// get existing node (loop) or create new
+					{
-					targetNode = ObtainNodeForValue(memberValue, out createdNew);
+						continue;
-					if (createdNew)
+					}
+					else
 					{
-						// if member node is new, recursively build its subtree
+						// if property value is not null, create neighbor
-						loadNeighborsRecursive(targetNode, expandedNodes);
+						memberValue = memberValue.GetPermanentReference();
+						
+						bool createdNew;
+						// get existing node (loop) or create new
+						targetNode = ObtainNodeForValue(memberValue, out createdNew);
+						if (createdNew)
+						{
+							// if member node is new, recursively build its subtree
+							loadNeighborsRecursive(targetNode, expandedNodes);
+						}
 					}
 				}
 				else

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/Visualizers/Graph/ObjectGraph/ObjectGraphNode.cs

@@ -39,16 +39,24 @@ namespace Debugger.AddIn.Visualizers.Graph
 			get; set;
 		}
 		
+		public IEnumerable<ObjectGraphProperty> Properties
+		{
+			get
+			{
+				return this.Content.FlattenPropertyNodes().Select(node => {return node.Property; });
+			}
+		}
+		
 		// TODO just for ObjectGraphBuilder, remove
 		/// <summary>
 		/// Only complex properties filtered out of <see cref="Properties"/>
 		/// </summary>
-		public IEnumerable<ObjectGraphProperty> ComplexProperties
+		/*public IEnumerable<ObjectGraphProperty> ComplexProperties
 		{
 			get
 			{
 				return this.Content.FlattenPropertyNodes().Select(node => {return node.Property; });
 			}
-		}
+		}*/
 	}
 }

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/Visualizers/Graph/ObjectGraph/ObjectGraphProperty.cs

@@ -8,21 +8,37 @@ using ICSharpCode.SharpDevelop.Services;
 using System;
 using System.Collections.Generic;
 using System.Text;
+using Debugger.AddIn.Visualizers.Utils;
 
 namespace Debugger.AddIn.Visualizers.Graph
 {
-    /// <summary>
+	/// <summary>
-    /// ObjectProperty used in ObjectGraph. Has TargetNode.
+	/// ObjectProperty used in ObjectGraph. Has TargetNode.
-    /// Support on-demand evaluation of Value property.
+	/// Support on-demand evaluation of Value property.
-    /// </summary>
+	/// </summary>
-    public class ObjectGraphProperty : ObjectProperty, IEvaluate
+	public class ObjectGraphProperty : ObjectProperty, IEvaluate
-    {
+	{
-        /// <summary>
+		/// <summary>
-        /// Node that this property points to. Can be null. Always null if <see cref="IsAtomic"/> is true.
+		/// Node that this property points to. Can be null. Always null if <see cref="IsAtomic"/> is true.
+		/// </summary>
+		public ObjectGraphNode TargetNode { get; set; }
+		
+		//private Expressions.Expression containingObjectExpression;
+		
+		/*public ObjectGraphProperty(Expressions.Expression containingObjectExpression)
+		{
+			if (containingObjectExpression == null)
+				throw new ArgumentNullException("containingObjectExpression");
+			this.containingObjectExpression = containingObjectExpression;
+		}*/
+		
+		/// <summary>
+        /// MemberInfo used for obtaining value of this property
         /// </summary>
-        public ObjectGraphNode TargetNode { get; set; }
+        public Debugger.MetaData.MemberInfo PropInfo { get; set; }
         
-       bool evaluateCalled = false;
+		
+		bool evaluateCalled = false;
 		public bool IsEvaluated
 		{
 			get { return this.evaluateCalled; }
@@ -30,13 +46,23 @@ namespace Debugger.AddIn.Visualizers.Graph
 		
 		public void Evaluate()
 		{
+			/*if (this.PropInfo == null)
+			{
+				throw new DebuggerVisualizerException("Cannot evaluate property with missing MemberInfo");
+			}
+			Value debuggerVal = this.containingObjectExpression.Evaluate(WindowsDebugger.CurrentProcess).GetMemberValue(this.PropInfo);*/
+			
 			if (this.Expression == null)
 			{
 				throw new DebuggerVisualizerException("Cannot evaluate property with missing Expression");
 			}
 			Value debuggerVal = this.Expression.Evaluate(WindowsDebugger.CurrentProcess);
-			this.Value = debuggerVal.IsNull ? string.Empty : debuggerVal.InvokeToString();
+			
+			this.IsAtomic = debuggerVal.Type.IsAtomic();
+			this.IsNull = debuggerVal.IsNull;
+			// null and complex properties evaluate to empty string
+			this.Value = debuggerVal.IsNull || (!this.IsAtomic) ? string.Empty : debuggerVal.InvokeToString();
 			this.evaluateCalled = true;
 		}
-    }
+	}
 }

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/Visualizers/ObjectProperty.cs

@@ -24,7 +24,7 @@ namespace Debugger.AddIn.Visualizers
         public string Value { get; set; }
         
         /// <summary>
-        /// Expression used for obtaining this property
+        /// Expression used for obtaining value of this property
         /// </summary>
         public Debugger.Expressions.Expression Expression { get; set; }
         

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/Visualizers/Utils/AtomicType.cs

@@ -16,6 +16,16 @@ namespace Debugger.AddIn.Visualizers.Utils
 	/// </summary>
 	public static class AtomicType
 	{
+		/// <summary>
+		/// Checks whether given expression's type is atomic.
+		/// </summary>
+		/// <param name="expr">Expression.</param>
+		/// <returns>True if expression's type is atomic, False otherwise.</returns>
+		public static bool IsAtomic(this DebugType type)
+		{
+			return !(type.IsClass || type.IsValueType /* = struct in C# */);
+		}
+		
 		/// <summary>
 		/// Checks whether given expression's type is atomic.
 		/// </summary>
@@ -24,7 +34,7 @@ namespace Debugger.AddIn.Visualizers.Utils
 		public static bool IsOfAtomicType(this Expression expr)
 		{
 			DebugType typeOfValue = expr.Evaluate(WindowsDebugger.CurrentProcess).Type;
-			return !(typeOfValue.IsClass || typeOfValue.IsValueType /* = struct in C# */);
+			return AtomicType.IsAtomic(typeOfValue);
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/Visualizers/Utils/DebuggerHelpers.cs

@@ -64,7 +64,7 @@ namespace Debugger.AddIn.Visualizers.Utils
 			return int.Parse(defaultHashCode);
 		}
 		
-		public static Value GetPermanentReference(this Expression expr)
+		public static Value EvalPermanentReference(this Expression expr)
 		{
 			return expr.Evaluate(WindowsDebugger.CurrentProcess).GetPermanentReference();
 		}