private void setupNodes(IList nodes)
{
#if DEBUG
for (int i = 0; i < m_nodePresenters.Count; i++)
{
Debug.Assert(m_nodePresenters[i] != null);
Debug.Assert(VisualTreeHelper.GetParent(m_nodePresenters[i]) == this);
}
#endif
int nodesCount = (nodes == null) ? 0 : nodes.Count;
GraphContentPresenter[] newNodes = new GraphContentPresenter[nodesCount];
for (int i = 0; i < nodesCount; i++)
{
for (int j = 0; j < m_nodePresenters.Count; j++)
{
if (m_nodePresenters[j] != null)
{
if (nodes[i] == m_nodePresenters[j].Content)
{
newNodes[i] = m_nodePresenters[j];
m_nodePresenters[j] = null;
break;
}
}
}
}
for (int i = 0; i < m_nodePresenters.Count; i++)
{
if (m_nodePresenters[i] != null)
{
beginRemoveAnimation(m_nodePresenters[i], false);
m_nodePresenters[i] = null;
}
}
for (int i = 0; i < newNodes.Length; i++)
{
if (newNodes[i] == null)
{
newNodes[i] = GetGraphContentPresenter(nodes[i],
m_nodeTemplateBinding, m_nodeTemplateSelectorBinding, true);
this.AddVisualChild(newNodes[i]);
}
}
#if DEBUG
m_nodePresenters.ForEach(item => Debug.Assert(item == null));
newNodes.CountForEach((item, i) => {
Debug.Assert(item != null);
Debug.Assert(VisualTreeHelper.GetParent(item) == this);
Debug.Assert(item.Content == nodes[i]);
});
#endif
m_nodePresenters.Clear();
m_nodePresenters.AddRange(newNodes);
}
private static bool updateGraphCP(GraphContentPresenter graphContentPresenter, Vector forceVector,
double coefficientOfDampening, double frameRate, Point parentCenter)
{
bool parentCenterChanged = (graphContentPresenter.ParentCenter != parentCenter);
if (parentCenterChanged)
{
graphContentPresenter.ParentCenter = parentCenter;
}
//add system drag
Debug.Assert(coefficientOfDampening > 0);
Debug.Assert(coefficientOfDampening < 1);
graphContentPresenter.Velocity *= (1 - coefficientOfDampening * frameRate);
//add force
graphContentPresenter.Velocity += (forceVector * frameRate);
//apply terminalVelocity
if (graphContentPresenter.Velocity.Length > s_terminalVelocity)
{
graphContentPresenter.Velocity *= (s_terminalVelocity / graphContentPresenter.Velocity.Length);
}
if (graphContentPresenter.Velocity.Length > s_minVelocity && forceVector.Length > s_minVelocity)
{
graphContentPresenter.Location += (graphContentPresenter.Velocity * frameRate);
return(true);
}
else
{
graphContentPresenter.Velocity = new Vector();
return(false || parentCenterChanged);
}
}
private void beginRemoveAnimation(GraphContentPresenter graphContentPresenter, bool isCenter)
{
Debug.Assert(VisualTreeHelper.GetParent(graphContentPresenter) == this);
this.InvalidateVisual();
m_fadingGCPList.Add(graphContentPresenter);
graphContentPresenter.IsHitTestVisible = false;
if (isCenter)
{
graphContentPresenter.WasCenter = true;
}
ScaleTransform scaleTransform = graphContentPresenter.ScaleTransform;
DoubleAnimation doubleAnimation = new DoubleAnimation(0, s_hideDuration);
doubleAnimation.Completed +=
delegate(object sender, EventArgs e)
{
CleanUpGCP(graphContentPresenter);
};
doubleAnimation.FillBehavior = FillBehavior.Stop;
doubleAnimation.Freeze();
scaleTransform.BeginAnimation(ScaleTransform.ScaleXProperty, doubleAnimation);
scaleTransform.BeginAnimation(ScaleTransform.ScaleYProperty, doubleAnimation);
graphContentPresenter.BeginAnimation(OpacityProperty, doubleAnimation);
}
private static GraphContentPresenter GetGraphContentPresenter(object content, BindingBase nodeTemplateBinding,
BindingBase nodeTemplateSelectorBinding, bool offsetCenter)
{
GraphContentPresenter gcp =
new GraphContentPresenter(content, nodeTemplateBinding, nodeTemplateSelectorBinding, offsetCenter);
return(gcp);
}
private GraphContentPresenter GetGraphContentPresenter(object content, BindingBase nodeTemplateBinding,
BindingBase nodeTemplateSelectorBinding, bool offsetCenter)
{
GraphContentPresenter gcp = new GraphContentPresenter(content, nodeTemplateBinding, nodeTemplateSelectorBinding, offsetCenter);
_needsMeasure.Add(gcp);
_needsArrange.Add(gcp);
return(gcp);
}
private void CleanUpGCP(GraphContentPresenter contentPresenter)
{
if (m_fadingGCPList.Contains(contentPresenter))
{
Debug.Assert(VisualTreeHelper.GetParent(contentPresenter) == this);
this.RemoveVisualChild(contentPresenter);
m_fadingGCPList.Remove(contentPresenter);
}
}
private static DoubleAnimation GetNewHideAnimation(GraphContentPresenter element, Graph owner, int key)
{
DoubleAnimation da = new DoubleAnimation(0, HideDuration);
da.FillBehavior = FillBehavior.Stop;
//da.SetValue(Timeline.DesiredFrameRateProperty, HideDesiredFrameRate);
HideAnimationManager ham = new HideAnimationManager(owner, key);
da.Completed += new EventHandler(ham.CompletedHandler);
da.Freeze();
return(da);
}
private void CleanUpGCP(int key)
{
Debug.Assert(CheckAccess());
if (_fadingGCPs.ContainsKey(key))
{
GraphContentPresenter gcp = _fadingGCPs[key];
Debug.Assert(gcp != null);
Debug.Assert(VisualTreeHelper.GetParent(gcp) == this);
this.RemoveVisualChild(gcp);
_fadingGCPListValid = false;
_isChildCountValid = false;
_fadingGCPs.Remove(key);
}
}
private void KillGCP(GraphContentPresenter gcp, bool isCenter)
{
Debug.Assert(VisualTreeHelper.GetParent(gcp) == this);
this.InvalidateVisual();
_fadingGCPs.Add(_fadingGCPsNextKey, gcp);
_fadingGCPListValid = false;
_isChildCountValid = false;
int theKey = _fadingGCPsNextKey;
gcp.IsHitTestVisible = false;
if (isCenter)
{
gcp.WasCenter = true;
}
ScaleTransform st = gcp.ScaleTransform;
DoubleAnimation da = GetNewHideAnimation(gcp, this, theKey);
st.BeginAnimation(ScaleTransform.ScaleXProperty, da);
st.BeginAnimation(ScaleTransform.ScaleYProperty, da);
gcp.BeginAnimation(OpacityProperty, da);
if (_fadingGCPsNextKey == int.MaxValue)
{
_fadingGCPsNextKey = int.MinValue;
}
else
{
_fadingGCPsNextKey++;
}
}
private void setupNodes(IList nodes)
{
#if DEBUG
for (int i = 0; i < m_nodePresenters.Count; i++) {
Debug.Assert(m_nodePresenters[i] != null);
Debug.Assert(VisualTreeHelper.GetParent(m_nodePresenters[i]) == this);
}
#endif
int nodesCount = (nodes == null) ? 0 : nodes.Count;
GraphContentPresenter[] newNodes = new GraphContentPresenter[nodesCount];
for (int i = 0; i < nodesCount; i++) {
for (int j = 0; j < m_nodePresenters.Count; j++) {
if (m_nodePresenters[j] != null) {
if (nodes[i] == m_nodePresenters[j].Content) {
newNodes[i] = m_nodePresenters[j];
m_nodePresenters[j] = null;
break;
}
}
}
}
for (int i = 0; i < m_nodePresenters.Count; i++) {
if (m_nodePresenters[i] != null) {
beginRemoveAnimation(m_nodePresenters[i], false);
m_nodePresenters[i] = null;
}
}
for (int i = 0; i < newNodes.Length; i++) {
if (newNodes[i] == null) {
newNodes[i] = GetGraphContentPresenter(nodes[i],
m_nodeTemplateBinding, m_nodeTemplateSelectorBinding, true);
this.AddVisualChild(newNodes[i]);
}
}
#if DEBUG
m_nodePresenters.ForEach(item => Debug.Assert(item == null));
newNodes.CountForEach((item, i) => {
Debug.Assert(item != null);
Debug.Assert(VisualTreeHelper.GetParent(item) == this);
Debug.Assert(item.Content == nodes[i]);
});
#endif
m_nodePresenters.Clear();
m_nodePresenters.AddRange(newNodes);
}
private void SetupNodes(IList nodes)
{
#if DEBUG
for (int i = 0; i < _nodePresenters.Count; i++)
{
Debug.Assert(_nodePresenters[i] != null);
Debug.Assert(VisualTreeHelper.GetParent(_nodePresenters[i]) == this);
}
#endif
int nodesCount = (nodes == null) ? 0 : nodes.Count;
GraphContentPresenter[] newNodes = new GraphContentPresenter[nodesCount];
for (int i = 0; i < nodesCount; i++)
{
for (int j = 0; j < _nodePresenters.Count; j++)
{
if (_nodePresenters[j] != null)
{
if (nodes[i] == _nodePresenters[j].Content)
{
newNodes[i] = _nodePresenters[j];
_nodePresenters[j] = null;
break;
}
}
}
}
for (int i = 0; i < _nodePresenters.Count; i++)
{
if (_nodePresenters[i] != null)
{
beginRemoveAnimation(_nodePresenters[i], false);
_nodePresenters[i] = null;
}
}
for (int i = 0; i < newNodes.Length; i++)
{
if (newNodes[i] == null)
{
newNodes[i] = GetGraphContentPresenter(nodes[i],
m_nodeTemplateBinding, m_nodeTemplateSelectorBinding, true);
this.AddVisualChild(newNodes[i]);
}
}
#if DEBUG
for (int i = 0; i < _nodePresenters.Count; i++)
{
Debug.Assert(_nodePresenters[i] == null);
}
for (int i = 0; i < newNodes.Length; i++)
{
Debug.Assert(newNodes[i] != null);
Debug.Assert(VisualTreeHelper.GetParent(newNodes[i]) == this);
Debug.Assert(newNodes[i].Content == nodes[i]);
}
#endif
_nodePresenters.Clear();
_nodePresenters.AddRange(newNodes);
_isChildCountValid = false;
}
private void SetUpCleanCenter(object newCenter)
{
Debug.Assert(m_centerGraphContentPresenter == null);
m_centerGraphContentPresenter = GetGraphContentPresenter(newCenter, m_nodeTemplateBinding, m_nodeTemplateSelectorBinding, false);
this.AddVisualChild(m_centerGraphContentPresenter);
_isChildCountValid = false;
}
private void handleChanges()
{
handleNodesChangedWiring();
if (_centerChanged && _nodeCollectionChanged &&
CenterObject != null &&
m_centerGraphContentPresenter != null
)
{
Debug.Assert(!CenterObject.Equals(_centerDataInUse));
Debug.Assert(m_centerGraphContentPresenter.Content == null || m_centerGraphContentPresenter.Content.Equals(_centerDataInUse));
_centerDataInUse = CenterObject;
//figure out if we can re-cycle one of the existing children as the center Node
//if we can, newCenter != null
GraphContentPresenter newCenterPresenter = null;
for (int i = 0; i < _nodePresenters.Count; i++)
{
if (_nodePresenters[i].Content.Equals(CenterObject))
{
//we should re-use this
newCenterPresenter = _nodePresenters[i];
_nodePresenters[i] = null;
break;
}
}
//figure out if we can re-cycle the exsting center as one of the new child nodes
//if we can, newChild != null && newChildIndex == indexOf(data in Nodes)
int newChildIndex = -1;
GraphContentPresenter newChildPresenter = null;
for (int i = 0; i < _nodesInUse.Count; i++)
{
if (_nodesInUse[i] != null && m_centerGraphContentPresenter.Content != null && _nodesInUse[i].Equals(m_centerGraphContentPresenter.Content))
{
newChildIndex = i;
newChildPresenter = m_centerGraphContentPresenter;
m_centerGraphContentPresenter = null;
break;
}
}
//now we potentially have a center (or not) and one edge(or not)
GraphContentPresenter[] newChildren = new GraphContentPresenter[_nodesInUse.Count];
//we did all the work to see if the current cernter can be reused.
//if it can, use it
if (newChildPresenter != null)
{
newChildren[newChildIndex] = newChildPresenter;
}
//now go through all the existing children and place them in newChildren
//if they match
for (int i = 0; i < _nodesInUse.Count; i++)
{
if (newChildren[i] == null)
{
for (int j = 0; j < _nodePresenters.Count; j++)
{
if (_nodePresenters[j] != null)
{
if (_nodesInUse[i].Equals(_nodePresenters[j].Content))
{
Debug.Assert(newChildren[i] == null);
newChildren[i] = _nodePresenters[j];
_nodePresenters[j] = null;
break;
}
}
}
}
}
//we've now reused everything we can
if (m_centerGraphContentPresenter == null)
{
//we didn't find anything to recycle
//create a new one
if (newCenterPresenter == null)
{
m_centerGraphContentPresenter = GetGraphContentPresenter(CenterObject,
m_nodeTemplateBinding, m_nodeTemplateSelectorBinding, false
);
this.AddVisualChild(m_centerGraphContentPresenter);
}
else //we did find something to recycle. Use it.
{
m_centerGraphContentPresenter = newCenterPresenter;
Debug.Assert(VisualTreeHelper.GetParent(newCenterPresenter) == this);
}
}
else
{
if (newCenterPresenter == null)
{
m_centerGraphContentPresenter.Content = CenterObject;
}
else
{
beginRemoveAnimation(m_centerGraphContentPresenter, true);
m_centerGraphContentPresenter = newCenterPresenter;
Debug.Assert(VisualTreeHelper.GetParent(newCenterPresenter) == this);
}
}
//go through all of the old CPs that are not being used and remove them
for (int i = 0; i < _nodePresenters.Count; i++)
{
if (_nodePresenters[i] != null)
{
beginRemoveAnimation(_nodePresenters[i], false);
}
}
//go through and "fill in" all the new CPs
for (int i = 0; i < _nodesInUse.Count; i++)
{
if (newChildren[i] == null)
{
GraphContentPresenter gcp = GetGraphContentPresenter(_nodesInUse[i],
m_nodeTemplateBinding, m_nodeTemplateSelectorBinding, true);
this.AddVisualChild(gcp);
newChildren[i] = gcp;
}
}
_nodePresenters.Clear();
_nodePresenters.AddRange(newChildren);
_isChildCountValid = false;
_centerChanged = false;
_nodeCollectionChanged = false;
}
else
{
if (_centerChanged)
{
_centerDataInUse = CenterObject;
if (m_centerGraphContentPresenter != null)
{
Debug.Assert(_centerDataInUse == null);
beginRemoveAnimation(m_centerGraphContentPresenter, true);
m_centerGraphContentPresenter = null;
}
if (_centerDataInUse != null)
{
SetUpCleanCenter(_centerDataInUse);
}
_centerChanged = false;
}
if (_nodeCollectionChanged)
{
SetupNodes(Nodes);
_nodesInUse = Nodes;
_nodeCollectionChanged = false;
}
}
#if DEBUG
if (CenterObject != null)
{
CenterObject.Equals(_centerDataInUse);
Debug.Assert(m_centerGraphContentPresenter != null);
}
else
{
Debug.Assert(_centerDataInUse == null);
}
if (Nodes != null)
{
Debug.Assert(_nodePresenters != null);
Debug.Assert(Nodes.Count == _nodePresenters.Count);
Debug.Assert(_nodesInUse == Nodes);
}
else
{
Debug.Assert(_nodesInUse == null);
if (_nodePresenters != null)
{
Debug.Assert(_nodePresenters.Count == 0);
}
}
#endif
}
private GraphContentPresenter GetGraphContentPresenter(object content, BindingBase nodeTemplateBinding,
BindingBase nodeTemplateSelectorBinding, bool offsetCenter)
{
GraphContentPresenter gcp =
new GraphContentPresenter(content, nodeTemplateBinding, nodeTemplateSelectorBinding, offsetCenter);
_needsMeasure.Add(gcp);
_needsArrange.Add(gcp);
return gcp;
}
private void CleanUpGCP(GraphContentPresenter contentPresenter)
{
if (_fadingGCPList.Contains(contentPresenter))
{
Debug.Assert(VisualTreeHelper.GetParent(contentPresenter) == this);
this.RemoveVisualChild(contentPresenter);
_isChildCountValid = false;
_fadingGCPList.Remove(contentPresenter);
}
}
private static GraphContentPresenter GetGraphContentPresenter(object content, BindingBase nodeTemplateBinding,
BindingBase nodeTemplateSelectorBinding, bool offsetCenter)
{
GraphContentPresenter gcp =
new GraphContentPresenter(content, nodeTemplateBinding, nodeTemplateSelectorBinding, offsetCenter);
return gcp;
}
private static DoubleAnimation GetNewHideAnimation(GraphContentPresenter element, Graph owner, int key)
{
DoubleAnimation da = new DoubleAnimation(0, HideDuration);
da.FillBehavior = FillBehavior.Stop;
//da.SetValue(Timeline.DesiredFrameRateProperty, HideDesiredFrameRate);
HideAnimationManager ham = new HideAnimationManager(owner, key);
da.Completed += new EventHandler(ham.CompletedHandler);
da.Freeze();
return da;
}
private void SetupNodes(IList nodes)
{
#if DEBUG
for (int i = 0; i < _nodePresenters.Count; i++)
{
Debug.Assert(_nodePresenters[i] != null);
Debug.Assert(VisualTreeHelper.GetParent(_nodePresenters[i]) == this);
}
#endif
int nodesCount = (nodes == null) ? 0 : nodes.Count;
GraphContentPresenter[] newNodes = new GraphContentPresenter[nodesCount];
for (int i = 0; i < nodesCount; i++)
{
for (int j = 0; j < _nodePresenters.Count; j++)
{
if (_nodePresenters[j] != null)
{
if (nodes[i] == _nodePresenters[j].Content)
{
newNodes[i] = _nodePresenters[j];
_nodePresenters[j] = null;
break;
}
}
}
}
for (int i = 0; i < _nodePresenters.Count; i++)
{
if (_nodePresenters[i] != null)
{
KillGCP(_nodePresenters[i], false);
_nodePresenters[i] = null;
}
}
for (int i = 0; i < newNodes.Length; i++)
{
if (newNodes[i] == null)
{
newNodes[i] = GetGraphContentPresenter(nodes[i],
_nodeTemplateBinding, _nodeTemplateSelectorBinding, true);
this.AddVisualChild(newNodes[i]);
}
}
#if DEBUG
for (int i = 0; i < _nodePresenters.Count; i++)
{
Debug.Assert(_nodePresenters[i] == null);
}
for (int i = 0; i < newNodes.Length; i++)
{
Debug.Assert(newNodes[i] != null);
Debug.Assert(VisualTreeHelper.GetParent(newNodes[i]) == this);
Debug.Assert(newNodes[i].Content == nodes[i]);
}
#endif
_nodePresenters.Clear();
_nodePresenters.AddRange(newNodes);
_isChildCountValid = false;
}
private void handleChanges()
{
handleNodesChangedWiring();
if (_centerChanged && _nodeCollectionChanged && _centerObjectPresenter != null && _nodePresenters != null &&
CenterObject != null && !CenterObject.Equals(_centerDataInUse))
{
Debug.Assert(!CenterObject.Equals(_centerDataInUse));
Debug.Assert(_centerObjectPresenter.Content == null || _centerObjectPresenter.Content.Equals(_centerDataInUse));
_centerDataInUse = CenterObject;
//figure out if we can re-cycle one of the existing children as the center Node
//if we can, newCenter != null
GraphContentPresenter newCenterPresenter = null;
for (int i = 0; i < _nodePresenters.Count; i++)
{
if (_nodePresenters[i].Content.Equals(CenterObject))
{
//we should re-use this
newCenterPresenter = _nodePresenters[i];
_nodePresenters[i] = null;
break;
}
}
//figure out if we can re-cycle the exsting center as one of the new child nodes
//if we can, newChild != null && newChildIndex == indexOf(data in Nodes)
int newChildIndex = -1;
GraphContentPresenter newChildPresnter = null;
for (int i = 0; i < _nodesInUse.Count; i++)
{
if (_nodesInUse[i] != null && _centerObjectPresenter.Content != null && _nodesInUse[i].Equals(_centerObjectPresenter.Content))
{
newChildIndex = i;
newChildPresnter = _centerObjectPresenter;
_centerObjectPresenter = null;
break;
}
}
//now we potentially have a center (or not) and one edge(or not)
GraphContentPresenter[] newChildren = new GraphContentPresenter[_nodesInUse.Count];
if (newChildPresnter != null)
{
newChildren[newChildIndex] = newChildPresnter;
}
for (int i = 0; i < _nodesInUse.Count; i++)
{
if (newChildren[i] == null)
{
for (int j = 0; j < _nodePresenters.Count; j++)
{
if (_nodePresenters[j] != null)
{
if (_nodesInUse[i].Equals(_nodePresenters[j].Content))
{
Debug.Assert(newChildren[i] == null);
newChildren[i] = _nodePresenters[j];
_nodePresenters[j] = null;
break;
}
}
}
}
}
//we've no reused everything we can
if (_centerObjectPresenter == null)
{
if (newCenterPresenter == null)
{
_centerObjectPresenter = GetGraphContentPresenter(CenterObject,
_nodeTemplateBinding, _nodeTemplateSelectorBinding, false
);
this.AddVisualChild(_centerObjectPresenter);
}
else
{
_centerObjectPresenter = newCenterPresenter;
Debug.Assert(VisualTreeHelper.GetParent(newCenterPresenter) == this);
}
}
else
{
if (newCenterPresenter == null)
{
_centerObjectPresenter.Content = CenterObject;
}
else
{
KillGCP(_centerObjectPresenter, true);
_centerObjectPresenter = newCenterPresenter;
Debug.Assert(VisualTreeHelper.GetParent(newCenterPresenter) == this);
}
}
//go through all of the old CPs that are not being used and remove them
for (int i = 0; i < _nodePresenters.Count; i++)
{
if (_nodePresenters[i] != null)
{
KillGCP(_nodePresenters[i], false);
}
}
//go throug and "fill in" all the new CPs
for (int i = 0; i < _nodesInUse.Count; i++)
{
if (newChildren[i] == null)
{
GraphContentPresenter gcp = GetGraphContentPresenter(_nodesInUse[i],
_nodeTemplateBinding, _nodeTemplateSelectorBinding, true);
this.AddVisualChild(gcp);
newChildren[i] = gcp;
}
}
_nodePresenters.Clear();
_nodePresenters.AddRange(newChildren);
_isChildCountValid = false;
_centerChanged = false;
_nodeCollectionChanged = false;
}
if (_centerChanged)
{
_centerDataInUse = CenterObject;
if (_centerObjectPresenter != null)
{
KillGCP(_centerObjectPresenter, true);
_centerObjectPresenter = null;
}
if (_centerDataInUse != null)
{
SetUpCleanCenter(_centerDataInUse);
}
_centerChanged = false;
}
if (_nodeCollectionChanged)
{
SetupNodes(Nodes);
_nodesInUse = Nodes;
_nodeCollectionChanged = false;
}
#if DEBUG
if (CenterObject != null)
{
CenterObject.Equals(_centerDataInUse);
Debug.Assert(_centerObjectPresenter != null);
}
else
{
Debug.Assert(_centerDataInUse == null);
}
if (Nodes != null)
{
Debug.Assert(_nodePresenters != null);
Debug.Assert(Nodes.Count == _nodePresenters.Count);
Debug.Assert(_nodesInUse == Nodes);
}
else
{
Debug.Assert(_nodesInUse == null);
if (_nodePresenters != null)
{
Debug.Assert(_nodePresenters.Count == 0);
}
}
#endif
}
private void KillGCP(GraphContentPresenter gcp, bool isCenter)
{
Debug.Assert(VisualTreeHelper.GetParent(gcp) == this);
this.InvalidateVisual();
_fadingGCPs.Add(_fadingGCPsNextKey, gcp);
_fadingGCPListValid = false;
_isChildCountValid = false;
int theKey = _fadingGCPsNextKey;
gcp.IsHitTestVisible = false;
if (isCenter)
{
gcp.WasCenter = true;
}
ScaleTransform st = gcp.ScaleTransform;
DoubleAnimation da = GetNewHideAnimation(gcp, this, theKey);
st.BeginAnimation(ScaleTransform.ScaleXProperty, da);
st.BeginAnimation(ScaleTransform.ScaleYProperty, da);
gcp.BeginAnimation(OpacityProperty, da);
if (_fadingGCPsNextKey == int.MaxValue)
{
_fadingGCPsNextKey = int.MinValue;
}
else
{
_fadingGCPsNextKey++;
}
}
private void handleChanges()
{
handleNodesChangedWiring();
if (m_centerChanged && m_nodeCollectionChanged &&
CenterObject != null &&
m_centerGraphContentPresenter != null
)
{
Debug.Assert(!CenterObject.Equals(m_centerDataInUse));
Debug.Assert(m_centerGraphContentPresenter.Content == null || m_centerGraphContentPresenter.Content.Equals(m_centerDataInUse));
m_centerDataInUse = CenterObject;
//figure out if we can re-cycle one of the existing children as the center Node
//if we can, newCenter != null
GraphContentPresenter newCenterPresenter = null;
for (int i = 0; i < m_nodePresenters.Count; i++)
{
if (m_nodePresenters[i].Content.Equals(CenterObject))
{
//we should re-use this
newCenterPresenter = m_nodePresenters[i];
m_nodePresenters[i] = null;
break;
}
}
//figure out if we can re-cycle the exsting center as one of the new child nodes
//if we can, newChild != null && newChildIndex == indexOf(data in Nodes)
int newChildIndex = -1;
GraphContentPresenter newChildPresenter = null;
for (int i = 0; i < m_nodesInUse.Count; i++)
{
if (m_nodesInUse[i] != null && m_centerGraphContentPresenter.Content != null && m_nodesInUse[i].Equals(m_centerGraphContentPresenter.Content))
{
newChildIndex = i;
newChildPresenter = m_centerGraphContentPresenter;
m_centerGraphContentPresenter = null;
break;
}
}
//now we potentially have a center (or not) and one edge(or not)
GraphContentPresenter[] newChildren = new GraphContentPresenter[m_nodesInUse.Count];
//we did all the work to see if the current cernter can be reused.
//if it can, use it
if (newChildPresenter != null)
{
newChildren[newChildIndex] = newChildPresenter;
}
//now go through all the existing children and place them in newChildren
//if they match
for (int i = 0; i < m_nodesInUse.Count; i++)
{
if (newChildren[i] == null)
{
for (int j = 0; j < m_nodePresenters.Count; j++)
{
if (m_nodePresenters[j] != null)
{
if (m_nodesInUse[i].Equals(m_nodePresenters[j].Content))
{
Debug.Assert(newChildren[i] == null);
newChildren[i] = m_nodePresenters[j];
m_nodePresenters[j] = null;
break;
}
}
}
}
}
//we've now reused everything we can
if (m_centerGraphContentPresenter == null)
{
//we didn't find anything to recycle
//create a new one
if (newCenterPresenter == null)
{
m_centerGraphContentPresenter = GetGraphContentPresenter(
CenterObject,
m_nodeTemplateBinding,
m_nodeTemplateSelectorBinding,
false
);
this.AddVisualChild(m_centerGraphContentPresenter);
}
else
{ //we did find something to recycle. Use it.
m_centerGraphContentPresenter = newCenterPresenter;
Debug.Assert(VisualTreeHelper.GetParent(newCenterPresenter) == this);
}
}
else
{
if (newCenterPresenter == null)
{
m_centerGraphContentPresenter.Content = CenterObject;
}
else
{
beginRemoveAnimation(m_centerGraphContentPresenter, true);
m_centerGraphContentPresenter = newCenterPresenter;
Debug.Assert(VisualTreeHelper.GetParent(newCenterPresenter) == this);
}
}
//go through all of the old CPs that are not being used and remove them
m_nodePresenters
.Where(gcp => gcp != null)
.ForEach(gcp => beginRemoveAnimation(gcp, false));
//go through and "fill in" all the new CPs
for (int i = 0; i < m_nodesInUse.Count; i++)
{
if (newChildren[i] == null)
{
GraphContentPresenter gcp = GetGraphContentPresenter(m_nodesInUse[i],
m_nodeTemplateBinding, m_nodeTemplateSelectorBinding, true);
this.AddVisualChild(gcp);
newChildren[i] = gcp;
}
}
m_nodePresenters.Clear();
m_nodePresenters.AddRange(newChildren);
m_centerChanged = false;
m_nodeCollectionChanged = false;
}
else
{
if (m_centerChanged)
{
m_centerDataInUse = CenterObject;
if (m_centerGraphContentPresenter != null)
{
Debug.Assert(m_centerDataInUse == null);
beginRemoveAnimation(m_centerGraphContentPresenter, true);
m_centerGraphContentPresenter = null;
}
if (m_centerDataInUse != null)
{
SetUpCleanCenter(m_centerDataInUse);
}
m_centerChanged = false;
}
if (m_nodeCollectionChanged)
{
setupNodes(Nodes);
m_nodesInUse = Nodes;
m_nodeCollectionChanged = false;
}
}
#if DEBUG
if (CenterObject != null)
{
CenterObject.Equals(m_centerDataInUse);
Debug.Assert(m_centerGraphContentPresenter != null);
}
else
{
Debug.Assert(m_centerDataInUse == null);
}
if (Nodes != null)
{
Debug.Assert(m_nodePresenters != null);
Debug.Assert(Nodes.Count == m_nodePresenters.Count);
Debug.Assert(m_nodesInUse == Nodes);
}
else
{
Debug.Assert(m_nodesInUse == null);
if (m_nodePresenters != null)
{
Debug.Assert(m_nodePresenters.Count == 0);
}
}
#endif
Children.ForEach(gcp => SetIsCenter(gcp, gcp == m_centerGraphContentPresenter));
}
private static bool updateGraphCP(GraphContentPresenter graphContentPresenter, Vector forceVector,
double coefficientOfDampening, double frameRate, Point parentCenter)
{
bool parentCenterChanged = (graphContentPresenter.ParentCenter != parentCenter);
if (parentCenterChanged)
{
graphContentPresenter.ParentCenter = parentCenter;
}
//add system drag
Debug.Assert(coefficientOfDampening > 0);
Debug.Assert(coefficientOfDampening < 1);
graphContentPresenter.Velocity *= (1 - coefficientOfDampening * frameRate);
//add force
graphContentPresenter.Velocity += (forceVector * frameRate);
//apply terminalVelocity
if (graphContentPresenter.Velocity.Length > s_terminalVelocity)
{
graphContentPresenter.Velocity *= (s_terminalVelocity / graphContentPresenter.Velocity.Length);
}
if (graphContentPresenter.Velocity.Length > s_minVelocity && forceVector.Length > s_minVelocity)
{
graphContentPresenter.Location += (graphContentPresenter.Velocity * frameRate);
return true;
}
else
{
graphContentPresenter.Velocity = new Vector();
return false || parentCenterChanged;
}
}
private void beginRemoveAnimation(GraphContentPresenter graphContentPresenter, bool isCenter)
{
Debug.Assert(VisualTreeHelper.GetParent(graphContentPresenter) == this);
this.InvalidateVisual();
_fadingGCPList.Add(graphContentPresenter);
_isChildCountValid = false;
graphContentPresenter.IsHitTestVisible = false;
if (isCenter)
{
graphContentPresenter.WasCenter = true;
}
ScaleTransform scaleTransform = graphContentPresenter.ScaleTransform;
DoubleAnimation doubleAnimation = new DoubleAnimation(0, s_hideDuration);
doubleAnimation.Completed +=
delegate(object sender, EventArgs e)
{
CleanUpGCP(graphContentPresenter);
};
doubleAnimation.FillBehavior = FillBehavior.Stop;
doubleAnimation.Freeze();
scaleTransform.BeginAnimation(ScaleTransform.ScaleXProperty, doubleAnimation);
scaleTransform.BeginAnimation(ScaleTransform.ScaleYProperty, doubleAnimation);
graphContentPresenter.BeginAnimation(OpacityProperty, doubleAnimation);
}
private void SetUpCleanCenter(object newCenter)
{
Debug.Assert(_centerGraphContentPresenter == null);
_centerGraphContentPresenter = GetGraphContentPresenter(newCenter, _centerNodeTemplateBinding, _nodeTemplateBinding, _nodeTemplateSelectorBinding, false);
_centerGraphContentPresenter.SetBinding(ContentPresenter.ContentTemplateProperty, _centerNodeTemplateBinding);
this.AddVisualChild(_centerGraphContentPresenter);
}
