Esempio n. 1
0
 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;
 }