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 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
}