public void UpdateParent(ModelNodeId nodeId, ModelNodeId?parentNodeId)
{
UpdateNodeCore(
nodeId,
i => i.WithParentNode(parentNodeId, CalculateHierarchyLevel(parentNodeId)),
DiagramNodeMember.ParentNode);
}
public DiagramEvent UpdateNodeHeaderSize(ModelNodeId nodeId, Size2D newSize)
{
return(UpdateNodeCore(
nodeId,
i => i.WithHeaderSize(newSize),
(oldNode, newNode) => new DiagramNodeChangedEvent(oldNode, newNode, DiagramNodeMember.HeaderSize)));
}
private static ModelRelationship CreateInstance(
ModelRelationshipId id,
ModelNodeId source,
ModelNodeId target,
ModelRelationshipStereotype stereotype,
[CanBeNull] object payload)
=> new ModelRelationship(id, source, target, stereotype, payload);
public DiagramEvent UpdateNodeCenter(ModelNodeId nodeId, Point2D newCenter)
{
return(UpdateNode(
nodeId,
i => i.WithCenter(newCenter),
(oldNode, newNode) => new DiagramNodeChangedEvent(oldNode, newNode, DiagramNodeMember.Position)));
}
public void UpdateChildrenAreaTopLeft(ModelNodeId nodeId, Point2D newTopLeft)
{
UpdateNodeCore(
nodeId,
i => i.WithChildrenAreaTopLeft(newTopLeft),
DiagramNodeMember.ChildrenAreaTopLeft);
}
public void UpdateNodeRelativeTopLeft(ModelNodeId nodeId, Point2D newRelativeTopLeft)
{
UpdateNodeCore(
nodeId,
i => i.WithRelativeTopLeft(newRelativeTopLeft),
DiagramNodeMember.RelativePosition);
}
private ModelNodeId?GetParentDiagramNodeId(ModelNodeId modelNodeId)
{
var containerNodes = LatestDiagram.Model
.GetRelatedNodes(modelNodeId, CommonDirectedModelRelationshipTypes.Container, recursive: false)
.ToList();
if (!containerNodes.Any())
{
return(null);
}
if (containerNodes.Count > 1)
{
throw new Exception($"{modelNodeId} has more than 1 containers.");
}
var potentialContainerNode = containerNodes.First();
if (LatestDiagram.NodeExists(potentialContainerNode.Id))
{
return(potentialContainerNode.Id);
}
return(null);
}
public static RoslynModelNode CreateModelNode(ISymbol symbol)
{
var namedTypeSymbol = symbol as INamedTypeSymbol;
if (namedTypeSymbol == null)
{
throw new NotImplementedException($"CreateModelNode for {symbol.GetType().Name} is not implemented.");
}
var id = ModelNodeId.Create();
switch (namedTypeSymbol.TypeKind)
{
case TypeKind.Class:
return(new RoslynClassNode(id, namedTypeSymbol));
case TypeKind.Interface:
return(new RoslynInterfaceNode(id, namedTypeSymbol));
case TypeKind.Struct:
return(new RoslynStructNode(id, namedTypeSymbol));
case TypeKind.Enum:
return(new RoslynEnumNode(id, namedTypeSymbol));
case TypeKind.Delegate:
return(new RoslynDelegateNode(id, namedTypeSymbol));
default:
throw new Exception($"Unexpected TypeKind: {namedTypeSymbol.TypeKind}");
}
}
private void UpdateNodeCore(
ModelNodeId nodeId,
[NotNull] Func <IDiagramNode, IDiagramNode> nodeMutatorFunc,
DiagramNodeMember updatedMember)
{
if (!_nodes.ContainsKey(nodeId))
{
return;
}
var oldNode = _nodes[nodeId];
var newNode = nodeMutatorFunc(oldNode);
_nodes[newNode.Id] = newNode;
_shapeEvents.Add(new DiagramNodeChangedEvent(oldNode, newNode, updatedMember));
if (updatedMember.In(ParentNodeChildrenAreaSizeAffectingMembers))
{
UpdateParentNodeChildrenAreaSize(newNode);
}
if (updatedMember.In(AbsolutePositionAffectingMembers))
{
UpdateAbsolutePosition(newNode);
}
if (updatedMember.In(ChildrenAbsolutePositionAffectingMembers))
{
UpdateChildrenAbsolutePosition(newNode);
}
}
public ModelRelationship(ModelRelationshipId id, ModelNodeId source, ModelNodeId target, ModelRelationshipStereotype stereotype)
{
Id = id;
Source = source;
Target = target;
Stereotype = stereotype ?? throw new ArgumentNullException(nameof(stereotype));
}
public IEnumerable <IModelNode> GetRelatedNodes(ModelNodeId nodeId,
DirectedModelRelationshipType directedModelRelationshipType, bool recursive = false)
{
return(Graph.GetAdjacentVertices(nodeId, directedModelRelationshipType.Direction,
i => i.Stereotype == directedModelRelationshipType.Stereotype,
recursive));
}
public PropertyNode(ModelNodeId id, string name, ModelOrigin origin = ModelOrigin.SourceCode,
bool hasGetter = true, bool hasSetter = true)
: base(id, name, ModelNodeStereotypes.Property, origin)
{
HasGetter = hasGetter;
HasSetter = hasSetter;
}
private void FollowDiagramNode(ModelNodeId nodeId)
{
if (_followedNodeIds?.Contains(nodeId) == true)
{
MoveViewport();
}
}
public ModelNode(ModelNodeId id, [NotNull] string name, [NotNull] ModelNodeStereotype stereotype, ModelOrigin origin)
{
Id = id;
Name = name ?? throw new ArgumentNullException(nameof(name));
Stereotype = stereotype ?? throw new ArgumentNullException(nameof(stereotype));
Origin = origin;
}
public ModelEvent AddRelationship(
ModelNodeId sourceId,
ModelNodeId targetId,
ModelRelationshipStereotype stereotype,
object payload = null)
{
if (payload != null && _payloadToModelRelationshipMap.ContainsKey(payload))
{
throw new Exception($"The model already contains a relationship with payload: {payload}");
}
var relationship = CreateRelationship(sourceId, targetId, stereotype, payload);
if (!IsRelationshipValid(relationship))
{
throw new ArgumentException($"{relationship} is invalid.");
}
var itemEvents = new List <ModelItemEventBase>();
var(newGraph, newPayloadToModelRelationshipMap) = AddRelationshipCore(
relationship,
_graph,
_payloadToModelRelationshipMap,
itemEvents);
var newModel = CreateInstance(newGraph, _payloadToModelNodeMap, newPayloadToModelRelationshipMap);
return(ModelEvent.Create(newModel, itemEvents));
}
public DiagramEvent UpdateNodeTopLeft(ModelNodeId nodeId, Point2D newTopLeft)
{
return(UpdateNode(
nodeId,
i => i.WithTopLeft(newTopLeft),
(oldNode, newNode) => new DiagramNodeChangedEvent(oldNode, newNode, DiagramNodeMember.Position)));
}
public ModelNode(ModelNodeId id, [NotNull] string name, ModelNodeStereotype stereotype, object payload = null)
{
Id = id;
Name = name;
Stereotype = stereotype;
Payload = payload;
}
public bool TryGetDiagramNodeUi(ModelNodeId modelNodeId, out IDiagramNodeUi viewModel)
{
var result = TryGetDiagramNodeViewModel(modelNodeId, out var diagramNodeViewModel);
viewModel = diagramNodeViewModel;
return(result);
}
private static IModelNode CreateNode(
[NotNull] string name,
ModelNodeStereotype stereotype,
[CanBeNull] object payload)
{
return(new ModelNode(ModelNodeId.Create(), name, stereotype, payload));
}
public void AddNode(ModelNodeId nodeId)
{
var maybeModelNode = _model.TryGetNode(nodeId);
if (!maybeModelNode.HasValue)
{
throw new Exception($"Node {nodeId} not found in model.");
}
AddNodeCore(maybeModelNode.Value);
var parentNodeId = GetParentNodeId(nodeId);
if (parentNodeId != null && DiagramNodeExists(parentNodeId.Value))
{
UpdateParent(nodeId, parentNodeId);
}
var childNodeIds = GetChildDiagramNodeIds(nodeId);
foreach (var childNodeId in childNodeIds)
{
UpdateParent(childNodeId, nodeId);
}
}
public DiagramEvent UpdateNodeChildrenAreaSize(ModelNodeId nodeId, Size2D newSize)
{
return(UpdateNode(
nodeId,
i => i.WithChildrenAreaSize(newSize),
(oldNode, newNode) => new DiagramNodeChangedEvent(oldNode, newNode, DiagramNodeMember.ChildrenAreaSize)));
}
public void UpdateSize(ModelNodeId nodeId, Size2D newSize)
{
UpdateNodeCore(
nodeId,
i => i.WithSize(newSize),
DiagramNodeMember.Size);
}
private List <ModelNodeId> GetChildDiagramNodeIds(ModelNodeId modelNodeId)
{
return(_model
.GetRelatedNodes(modelNodeId, CommonDirectedModelRelationshipTypes.Contained, recursive: false)
.Select(i => i.Id)
.Where(DiagramNodeExists)
.ToList());
}
private IModelRelationship CreateRelationship(
ModelNodeId sourceId,
ModelNodeId targetId,
ModelRelationshipStereotype stereotype,
[CanBeNull] object payload)
{
return(new ModelRelationship(CreateModelRelationshipId(), sourceId, targetId, stereotype, payload));
}
private static IModelRelationship CreateRelationship(
ModelNodeId sourceId,
ModelNodeId targetId,
ModelRelationshipStereotype stereotype,
object payload = null)
{
return(new ModelRelationship(ModelRelationshipId.Create(), sourceId, targetId, stereotype, payload));
}
private Size2D CalculateChildrenAreaSize(ModelNodeId parentNodeId)
{
var childrenAreaSize = GetChildNodes(parentNodeId)
.Select(i => i.RelativeRect).Where(i => i.IsDefined()).Union()
.WithMargin(_childrenAreaPadding).Size;
return(childrenAreaSize.IsDefined ? childrenAreaSize : Size2D.Zero);
}
public DiagramConnector(
IModelRelationship relationship,
ModelNodeId source,
ModelNodeId target,
ConnectorType connectorType)
: this(relationship, source, target, connectorType, Route.Empty)
{
}
public void UpdateNode_NonExistingId_Throws()
{
var modelService = CreateModelService();
Action a = () => modelService.UpdateNode(new ModelNode(ModelNodeId.Create(), "A", ModelNodeStereotype.Default));
a.Should().Throw <InvalidOperationException>().Where(i => i.Message.Contains("not found"));
}
private async Task <IReadOnlyList <ModelNodeId> > ExtendDiagramAsync(
ModelNodeId nodeId,
CancellationToken cancellationToken,
IIncrementalProgress progress)
{
return(await Task.Run(
() => ShowModelNodeWithHierarchy(nodeId, cancellationToken, progress).ToArray(),
cancellationToken));
}
private void RemoveModelNode(ModelNodeId modelNodeId)
{
var itemToRemove = Items.FirstOrDefault(i => i.Id == modelNodeId);
if (itemToRemove != null)
{
Items.Remove(itemToRemove);
}
}
