/// <summary>
/// Create a DiagramNode.
/// </summary>
private DiagramNode CreateNode(Shape person, NodeType type, bool clickEvent, double scale)
{
DiagramNode node = CreateNode(person, type, clickEvent);
node.Scale = scale;
return(node);
}
/// <summary>
/// Animate the new person that was added to the diagram.
/// </summary>
private void AnimateNewPerson()
{
// The new person is optional, can be null.
if (newPerson == null)
{
return;
}
// Get the UI element to animate.
DiagramNode node = logic.GetDiagramNode(newPerson);
if (node != null)
{
// Create the new person animation.
DoubleAnimation anim = new DoubleAnimation(0, 1,
GlobalData.GetAnimationDuration(Const.NewPersonAnimationDuration));
// Animate the node.
ScaleTransform transform = new ScaleTransform();
transform.BeginAnimation(ScaleTransform.ScaleXProperty, anim);
transform.BeginAnimation(ScaleTransform.ScaleYProperty, anim);
node.RenderTransform = transform;
}
newPerson = null;
}
/// <summary>
/// A node was clicked, make that node the primary node.
/// </summary>
private void OnNodeClick(object sender, RoutedEventArgs e)
{
// Get the node that was clicked.
DiagramNode node = sender as DiagramNode;
if (node != null)
{
// Make it the primary node. This raises the CurrentChanged
// event, which repopulates the diagram.
logic.Family.Current = node.Shape;
}
}
/// <summary>
/// Create a DiagramNode.
/// </summary>
private DiagramNode CreateNode(Shape person, NodeType type, bool clickEvent)
{
DiagramNode node = new DiagramNode();
node.Shape = person;
node.Type = type;
if (clickEvent)
{
node.Click += nodeClickHandler;
}
return(node);
}
/// <summary>
/// Add the siblings to the specified row and group.
/// </summary>
private void AddSiblingNodes(DiagramRow row, DiagramGroup group,
Collection <Shape> siblings, NodeType nodeType, double scale)
{
foreach (Shape sibling in siblings)
{
if (!personLookup.ContainsKey(sibling))
{
// Siblings node.
DiagramNode node = CreateNode(sibling, nodeType, true, scale);
group.Add(node);
personLookup.Add(node.Shape, new DiagramConnectorNode(node, group, row));
}
}
}
/// <summary>
/// Creates the primary row. The row contains groups: 1) The primary-group
/// that only contains the primary node, and 2) The optional left-group
/// that contains spouses and siblings.
/// </summary>
public DiagramRow CreatePrimaryRow(Shape person, double scale, double scaleRelated)
{
// The primary node contains two groups,
DiagramGroup primaryGroup = new DiagramGroup();
DiagramGroup leftGroup = new DiagramGroup();
// Set up the row.
DiagramRow row = new DiagramRow();
// Add primary node.
DiagramNode node = CreateNode(person, NodeType.Primary, false, scale);
primaryGroup.Add(node);
personLookup.Add(node.Shape, new DiagramConnectorNode(node, primaryGroup, row));
// Current spouses.
Collection <Shape> currentSpouses = person.CurrentSpouses;
AddSpouseNodes(person, row, leftGroup, currentSpouses,
NodeType.Spouse, scaleRelated, true);
// Previous spouses.
Collection <Shape> previousSpouses = person.PreviousSpouses;
AddSpouseNodes(person, row, leftGroup, previousSpouses,
NodeType.Spouse, scaleRelated, false);
// Siblings.
Collection <Shape> siblings = person.Siblings;
AddSiblingNodes(row, leftGroup, siblings, NodeType.Sibling, scaleRelated);
// Half siblings.
Collection <Shape> halfSiblings = person.HalfSiblings;
AddSiblingNodes(row, leftGroup, halfSiblings, NodeType.SiblingLeft, scaleRelated);
if (leftGroup.Nodes.Count > 0)
{
leftGroup.Reverse();
row.Add(leftGroup);
}
row.Add(primaryGroup);
return(row);
}
/// <summary>
/// Add the spouses to the specified row and group.
/// </summary>
private void AddSpouseNodes(Shape person, DiagramRow row,
DiagramGroup group, Collection <Shape> spouses,
NodeType nodeType, double scale, bool married)
{
foreach (Shape spouse in spouses)
{
if (!personLookup.ContainsKey(spouse))
{
// Spouse node.
DiagramNode node = CreateNode(spouse, nodeType, true, scale);
group.Add(node);
// Add connection.
DiagramConnectorNode connectorNode = new DiagramConnectorNode(node, group, row);
personLookup.Add(node.Shape, connectorNode);
connections.Add(new MarriedDiagramConnector(married, personLookup[person], connectorNode));
}
}
}
/// <summary>
/// Create the child row. The row contains a group for each child.
/// Each group contains the child and spouses.
/// </summary>
public DiagramRow CreateChildrenRow(List <Shape> children, double scale, double scaleRelated)
{
// Setup the row.
DiagramRow row = new DiagramRow();
foreach (Shape child in children)
{
// Each child is in their group, the group contains the child
// and any spouses. The groups does not contain siblings.
DiagramGroup group = new DiagramGroup();
row.Add(group);
// Child.
if (!personLookup.ContainsKey(child))
{
DiagramNode node = CreateNode(child, NodeType.Related, true, scale);
group.Add(node);
personLookup.Add(node.Shape, new DiagramConnectorNode(node, group, row));
}
// Current spouses.
Collection <Shape> currentSpouses = child.CurrentSpouses;
AddSpouseNodes(child, row, group, currentSpouses,
NodeType.Spouse, scaleRelated, true);
// Previous spouses.
Collection <Shape> previousSpouses = child.PreviousSpouses;
AddSpouseNodes(child, row, group, previousSpouses,
NodeType.Spouse, scaleRelated, false);
// Connections.
AddParentConnections(child);
group.Reverse();
}
return(row);
}
public DiagramConnectorNode(DiagramNode node, DiagramGroup group, DiagramRow row)
{
this.node = node;
this.group = group;
this.row = row;
}
/// <summary>
/// Add the node to the group.
/// </summary>
public void Add(DiagramNode node)
{
this.nodes.Add(node);
this.AddVisualChild(node);
}
/// <summary>
/// Create the parent row. The row contains a group for each parent.
/// Each groups contains the parent, spouses and siblings.
/// </summary>
public DiagramRow CreateParentRow(Collection <Shape> parents, double scale, double scaleRelated)
{
// Set up the row.
DiagramRow row = new DiagramRow();
int groupCount = 0;
foreach (Shape person in parents)
{
// Each parent is in their group, the group contains the parent,
// spouses and siblings.
DiagramGroup group = new DiagramGroup();
row.Add(group);
// Determine if this is a left or right oriented group.
bool left = (groupCount++ % 2 == 0) ? true : false;
// Parent.
if (!personLookup.ContainsKey(person))
{
DiagramNode node = CreateNode(person, NodeType.Related, true, scale);
group.Add(node);
personLookup.Add(node.Shape, new DiagramConnectorNode(node, group, row));
}
// Current spouses.
Collection <Shape> currentSpouses = person.CurrentSpouses;
RemoveDuplicates(currentSpouses, parents);
AddSpouseNodes(person, row, group, currentSpouses,
NodeType.Spouse, scaleRelated, true);
// Previous spouses.
Collection <Shape> previousSpouses = person.PreviousSpouses;
RemoveDuplicates(previousSpouses, parents);
AddSpouseNodes(person, row, group, previousSpouses,
NodeType.Spouse, scaleRelated, false);
// Siblings.
Collection <Shape> siblings = person.Siblings;
AddSiblingNodes(row, group, siblings, NodeType.Sibling, scaleRelated);
// Half siblings.
Collection <Shape> halfSiblings = person.HalfSiblings;
AddSiblingNodes(row, group, halfSiblings, left ?
NodeType.SiblingLeft : NodeType.SiblingRight, scaleRelated);
// Connections.
AddChildConnections(person);
AddChildConnections(currentSpouses);
AddChildConnections(previousSpouses);
if (left)
{
group.Reverse();
}
}
// Add connections that span across groups.
AddSpouseConnections(parents);
return(row);
}
