public <T extends Object> XConnection createConnection(
final T connectionObject,
final ConnectionMapping<T> connectionMapping,
final Procedure1<? super XConnection> initializer,
final InterpreterContext context) {
boolean _isApplicable = connectionMapping.isApplicable(connectionObject);
if (_isApplicable) {
final ConnectionMapping<T> connectionMappingCasted =
((ConnectionMapping<T>) connectionMapping);
final IMappedElementDescriptor<T> descriptor =
this.<T>getDescriptor(connectionObject, connectionMappingCasted);
boolean _equals = Objects.equal(descriptor, null);
if (_equals) {
return null;
}
final XConnection existingConnection = context.getConnection(descriptor);
boolean _or = false;
boolean _notEquals = (!Objects.equal(existingConnection, null));
if (_notEquals) {
_or = true;
} else {
boolean _isCreateConnections = context.isCreateConnections();
boolean _not = (!_isCreateConnections);
_or = _not;
}
if (_or) {
return existingConnection;
}
final XConnection connection = connectionMappingCasted.createConnection(descriptor);
XDiagramConfig _config = connectionMappingCasted.getConfig();
_config.initialize(connection);
List<AbstractLabelMappingCall<?, T>> _labels = connectionMapping.getLabels();
final Consumer<AbstractLabelMappingCall<?, T>> _function =
(AbstractLabelMappingCall<?, T> it) -> {
ObservableList<XConnectionLabel> _labels_1 = connection.getLabels();
Iterable<? extends XLabel> _execute = this.execute(it, connectionObject);
Iterable<XConnectionLabel> _filter =
Iterables.<XConnectionLabel>filter(_execute, XConnectionLabel.class);
Iterables.<XConnectionLabel>addAll(_labels_1, _filter);
};
_labels.forEach(_function);
initializer.apply(connection);
this.<T>createEndpoints(connectionMapping, connectionObject, connection, context);
boolean _and = false;
XNode _source = connection.getSource();
boolean _notEquals_1 = (!Objects.equal(_source, null));
if (!_notEquals_1) {
_and = false;
} else {
XNode _target = connection.getTarget();
boolean _notEquals_2 = (!Objects.equal(_target, null));
_and = _notEquals_2;
}
if (_and) {
context.addConnection(connection);
return connection;
}
}
return null;
}
protected <T extends Object> void populateDiagram(
final DiagramMapping<T> diagramMapping,
final T diagramObject,
final InterpreterContext context) {
List<AbstractNodeMappingCall<?, T>> _nodes = diagramMapping.getNodes();
final Consumer<AbstractNodeMappingCall<?, T>> _function =
(AbstractNodeMappingCall<?, T> it) -> {
this.execute(it, diagramObject, context);
};
_nodes.forEach(_function);
List<AbstractConnectionMappingCall<?, T>> _connections = diagramMapping.getConnections();
final Consumer<AbstractConnectionMappingCall<?, T>> _function_1 =
(AbstractConnectionMappingCall<?, T> it) -> {
final Procedure1<XConnection> _function_2 = (XConnection it_1) -> {};
this.execute(it, diagramObject, _function_2, context);
};
_connections.forEach(_function_1);
context.setIsCreateNodes(false);
List<ConnectionMapping<?>> _eagerConnections = diagramMapping.getEagerConnections();
boolean _isEmpty = _eagerConnections.isEmpty();
boolean _not = (!_isEmpty);
if (_not) {
List<ConnectionMapping<?>> _eagerConnections_1 = diagramMapping.getEagerConnections();
final HashSet<ConnectionMapping<?>> eagerConnections =
new HashSet<ConnectionMapping<?>>(_eagerConnections_1);
List<AbstractNodeMappingCall<?, T>> _nodes_1 = diagramMapping.getNodes();
final Consumer<AbstractNodeMappingCall<?, T>> _function_2 =
(AbstractNodeMappingCall<?, T> it) -> {
this.<T>connectNodesEagerly(it, diagramObject, eagerConnections, context);
};
_nodes_1.forEach(_function_2);
}
context.setIsCreateNodes(true);
}
protected <T extends Object> void doRevealElement(
final T element, final EntryCall<? super T> entryCall, final IEditorPart editor) {
XDiagram _diagram = this.root.getDiagram();
final InterpreterContext interpreterContext = new InterpreterContext(_diagram);
entryCall.execute(element, this.configInterpreter, interpreterContext);
CommandStack _commandStack = this.root.getCommandStack();
interpreterContext.executeCommands(_commandStack);
final IMappedElementDescriptor<T> descriptor = this.<T, Object>createMappedDescriptor(element);
XDiagram _diagram_1 = interpreterContext.getDiagram();
ObservableList<XNode> _nodes = _diagram_1.getNodes();
XDiagram _diagram_2 = interpreterContext.getDiagram();
ObservableList<XConnection> _connections = _diagram_2.getConnections();
Iterable<XDomainObjectShape> _plus = Iterables.<XDomainObjectShape>concat(_nodes, _connections);
final Function1<XDomainObjectShape, Boolean> _function =
(XDomainObjectShape it) -> {
DomainObjectDescriptor _domainObjectDescriptor = it.getDomainObjectDescriptor();
return Boolean.valueOf(Objects.equal(_domainObjectDescriptor, descriptor));
};
final XDomainObjectShape centerShape =
IterableExtensions.<XDomainObjectShape>findFirst(_plus, _function);
CommandStack _commandStack_1 = this.root.getCommandStack();
ParallelAnimationCommand _parallelAnimationCommand = new ParallelAnimationCommand();
final Procedure1<ParallelAnimationCommand> _function_1 =
(ParallelAnimationCommand it) -> {
boolean _needsLayoutCommand = interpreterContext.needsLayoutCommand();
if (_needsLayoutCommand) {
Layouter _layouter = new Layouter();
XDiagram _diagram_3 = interpreterContext.getDiagram();
Duration _millis = DurationExtensions.millis(500);
LazyCommand _createLayoutCommand =
_layouter.createLayoutCommand(LayoutType.DOT, _diagram_3, _millis, centerShape);
it.operator_add(_createLayoutCommand);
}
final Function1<XShape, Boolean> _function_2 =
(XShape it_1) -> {
return Boolean.valueOf(Objects.equal(it_1, centerShape));
};
SelectAndRevealCommand _selectAndRevealCommand =
new SelectAndRevealCommand(this.root, _function_2);
it.operator_add(_selectAndRevealCommand);
};
ParallelAnimationCommand _doubleArrow =
ObjectExtensions.<ParallelAnimationCommand>operator_doubleArrow(
_parallelAnimationCommand, _function_1);
_commandStack_1.execute(_doubleArrow);
}
public <T extends Object, U extends Object> XDiagram createDiagram(
final T diagramObject,
final DiagramMapping<T> diagramMapping,
final boolean isOnDemand,
final InterpreterContext context) {
XDiagram _xblockexpression = null;
{
boolean _isApplicable = diagramMapping.isApplicable(diagramObject);
boolean _not = (!_isApplicable);
if (_not) {
return null;
}
final IMappedElementDescriptor<T> descriptor =
this.<T>getDescriptor(diagramObject, diagramMapping);
boolean _equals = Objects.equal(descriptor, null);
if (_equals) {
return null;
}
XDiagram _diagram = context.getDiagram();
DomainObjectDescriptor _domainObjectDescriptor = _diagram.getDomainObjectDescriptor();
final boolean replaceDiagram = (!Objects.equal(_domainObjectDescriptor, descriptor));
context.setIsReplaceRootDiagram(replaceDiagram);
XDiagram _xifexpression = null;
if (replaceDiagram) {
_xifexpression = diagramMapping.createDiagram(descriptor);
} else {
_xifexpression = context.getDiagram();
}
final XDiagram diagram = _xifexpression;
InterpreterContext _xifexpression_1 = null;
if (replaceDiagram) {
_xifexpression_1 = new InterpreterContext(diagram, context);
} else {
_xifexpression_1 = context;
}
final InterpreterContext newContext = _xifexpression_1;
if (isOnDemand) {
diagram.setLayoutOnActivate(true);
final Procedure1<XDiagram> _function =
(XDiagram it) -> {
final Function1<T, Object> _function_1 =
(T domainObject) -> {
Object _xblockexpression_1 = null;
{
this.<T>populateDiagram(diagramMapping, domainObject, newContext);
newContext.directlyApplyChanges();
XRoot _root = CoreExtensions.getRoot(diagram);
final CommandStack commandStack = _root.getCommandStack();
newContext.executeCommands(commandStack);
_xblockexpression_1 = null;
}
return _xblockexpression_1;
};
descriptor.<Object>withDomainObject(_function_1);
};
diagram.setContentsInitializer(_function);
} else {
this.<T>populateDiagram(diagramMapping, diagramObject, newContext);
}
_xblockexpression = diagram;
}
return _xblockexpression;
}
public <T extends Object> XNode createNode(
final T nodeObject, final NodeMapping<T> nodeMapping, final InterpreterContext context) {
boolean _isApplicable = nodeMapping.isApplicable(nodeObject);
if (_isApplicable) {
final IMappedElementDescriptor<T> descriptor = this.<T>getDescriptor(nodeObject, nodeMapping);
boolean _equals = Objects.equal(descriptor, null);
if (_equals) {
return null;
}
boolean _isCreateDuplicateNodes = context.isCreateDuplicateNodes();
boolean _not = (!_isCreateDuplicateNodes);
if (_not) {
final XNode existingNode = context.getNode(descriptor);
boolean _or = false;
boolean _notEquals = (!Objects.equal(existingNode, null));
if (_notEquals) {
_or = true;
} else {
boolean _isCreateNodes = context.isCreateNodes();
boolean _not_1 = (!_isCreateNodes);
_or = _not_1;
}
if (_or) {
return existingNode;
}
}
final XNode node = nodeMapping.createNode(descriptor);
XDiagramConfig _config = nodeMapping.getConfig();
_config.initialize(node);
context.addNode(node);
boolean _isCreateConnections = context.isCreateConnections();
if (_isCreateConnections) {
List<AbstractConnectionMappingCall<?, T>> _incoming = nodeMapping.getIncoming();
final Consumer<AbstractConnectionMappingCall<?, T>> _function =
(AbstractConnectionMappingCall<?, T> it) -> {
boolean _isOnDemand = it.isOnDemand();
boolean _not_2 = (!_isOnDemand);
if (_not_2) {
final Procedure1<XConnection> _function_1 =
(XConnection it_1) -> {
it_1.setTarget(node);
};
this.execute(it, nodeObject, _function_1, context);
}
};
_incoming.forEach(_function);
List<AbstractConnectionMappingCall<?, T>> _outgoing = nodeMapping.getOutgoing();
final Consumer<AbstractConnectionMappingCall<?, T>> _function_1 =
(AbstractConnectionMappingCall<?, T> it) -> {
boolean _isOnDemand = it.isOnDemand();
boolean _not_2 = (!_isOnDemand);
if (_not_2) {
final Procedure1<XConnection> _function_2 =
(XConnection it_1) -> {
it_1.setSource(node);
};
this.execute(it, nodeObject, _function_2, context);
}
};
_outgoing.forEach(_function_1);
}
List<AbstractLabelMappingCall<?, T>> _labels = nodeMapping.getLabels();
final Consumer<AbstractLabelMappingCall<?, T>> _function_2 =
(AbstractLabelMappingCall<?, T> it) -> {
ObservableList<XLabel> _labels_1 = node.getLabels();
Iterable<? extends XLabel> _execute = this.execute(it, nodeObject);
Iterables.<XLabel>addAll(_labels_1, _execute);
};
_labels.forEach(_function_2);
if ((node instanceof XDiagramContainer)) {
DiagramMappingCall<?, T> _nestedDiagram = nodeMapping.getNestedDiagram();
XDiagram _execute = null;
if (_nestedDiagram != null) {
XDiagram _xDiagram = new XDiagram();
InterpreterContext _interpreterContext = new InterpreterContext(_xDiagram, context);
_execute = this.execute(_nestedDiagram, nodeObject, _interpreterContext);
}
((XDiagramContainer) node).setInnerDiagram(_execute);
}
return node;
} else {
return null;
}
}
protected <T extends Object> void connectNodesEagerly(
final AbstractNodeMappingCall<?, T> it,
final T diagramObject,
final Set<ConnectionMapping<?>> eagerConnections,
final InterpreterContext context) {
final Iterable<?> nodeObjects = this.select(it, diagramObject);
NodeMapping<?> _nodeMapping = it.getNodeMapping();
final NodeMapping<Object> nodeMappingCasted = ((NodeMapping<Object>) _nodeMapping);
for (final Object nodeObject : nodeObjects) {
{
final IMappedElementDescriptor<Object> descriptor =
this.<Object>getDescriptor(nodeObject, nodeMappingCasted);
final XNode node = context.getNode(descriptor);
boolean _notEquals = (!Objects.equal(node, null));
if (_notEquals) {
List<AbstractConnectionMappingCall<?, Object>> _incoming =
nodeMappingCasted.getIncoming();
final Function1<AbstractConnectionMappingCall<?, Object>, Boolean> _function =
(AbstractConnectionMappingCall<?, Object> it_1) -> {
boolean _and = false;
boolean _isOnDemand = it_1.isOnDemand();
if (!_isOnDemand) {
_and = false;
} else {
AbstractMapping<?> _mapping = it_1.getMapping();
boolean _contains = eagerConnections.contains(_mapping);
_and = _contains;
}
return Boolean.valueOf(_and);
};
Iterable<AbstractConnectionMappingCall<?, Object>> _filter =
IterableExtensions.<AbstractConnectionMappingCall<?, Object>>filter(
_incoming, _function);
final Consumer<AbstractConnectionMappingCall<?, Object>> _function_1 =
(AbstractConnectionMappingCall<?, Object> it_1) -> {
final Procedure1<XConnection> _function_2 =
(XConnection it_2) -> {
it_2.setTarget(node);
};
this.execute(it_1, nodeObject, _function_2, context);
};
_filter.forEach(_function_1);
List<AbstractConnectionMappingCall<?, Object>> _outgoing =
nodeMappingCasted.getOutgoing();
final Function1<AbstractConnectionMappingCall<?, Object>, Boolean> _function_2 =
(AbstractConnectionMappingCall<?, Object> it_1) -> {
boolean _and = false;
boolean _isOnDemand = it_1.isOnDemand();
if (!_isOnDemand) {
_and = false;
} else {
AbstractMapping<?> _mapping = it_1.getMapping();
boolean _contains = eagerConnections.contains(_mapping);
_and = _contains;
}
return Boolean.valueOf(_and);
};
Iterable<AbstractConnectionMappingCall<?, Object>> _filter_1 =
IterableExtensions.<AbstractConnectionMappingCall<?, Object>>filter(
_outgoing, _function_2);
final Consumer<AbstractConnectionMappingCall<?, Object>> _function_3 =
(AbstractConnectionMappingCall<?, Object> it_1) -> {
final Procedure1<XConnection> _function_4 =
(XConnection it_2) -> {
it_2.setSource(node);
};
this.execute(it_1, nodeObject, _function_4, context);
};
_filter_1.forEach(_function_3);
}
}
}
}
