/** @generated */
 @Override
 protected Command getDestroyElementCommand(DestroyElementRequest req) {
   CompoundCommand cc = getDestroyEdgesCommand();
   addDestroyShortcutsCommand(cc);
   cc.add(getGEFWrapper(new DestroyElementCommand(req)));
   return cc.unwrap();
 }
  /**
   * Return the command to create the view
   *
   * @param container the container for the element
   * @param semanticElement
   * @return The command to create the view
   */
  protected Command getCreateViewCommand(View container, EObject semanticElement, Point location) {

    // creation of the node
    ViewDescriptor viewDescriptor =
        new ViewDescriptor(
            new EObjectAdapter(semanticElement),
            Node.class,
            null,
            ViewUtil.APPEND,
            true,
            ((IGraphicalEditPart) this.getHost()).getDiagramPreferencesHint());
    CompoundCommand compositeCmd = new CompoundCommand("Create View"); // $NON-NLS-1$
    CreateCommand cmd = new CreateCommand(getEditingDomain(), viewDescriptor, container);
    if (cmd.canExecute()) {
      compositeCmd.add(new ICommandProxy(cmd));
    }
    // set the location
    if (location != null) {
      SetBoundsCommand setBoundsCommand =
          new SetBoundsCommand(
              getEditingDomain(),
              "move",
              (IAdaptable) cmd.getCommandResult().getReturnValue(),
              location); //$NON-NLS-1$
      if (setBoundsCommand.canExecute()) {
        compositeCmd.add(new ICommandProxy(setBoundsCommand));
      }
    }

    return compositeCmd;
  }
  public void run() {
    CompoundCommand command = new CompoundCommand();
    WorkflowModelEditor editor =
        (WorkflowModelEditor)
            PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActiveEditor();
    final DiagramEditorPage diagramEditorPage = (DiagramEditorPage) editor.getCurrentPage();
    if (actualMode.equals(DiagramModeType.MODE_450_LITERAL)) {
      // move children if children have negative positions
      PoolSymbol poolSymbol = DiagramUtil.getDefaultPool(diagram);
      if (poolSymbol != null && !poolSymbol.getNodes().isEmpty()) {
        int[] checkNegative = new int[] {0, 0};
        PoolLaneUtils.checkForNegativePositions(poolSymbol, checkNegative);
        if (checkNegative[0] < 0 || checkNegative[1] < 0) {
          checkNegative[0] = -checkNegative[0];
          checkNegative[1] = -checkNegative[1];
          EditPart editPart = diagramEditorPage.findEditPart(diagram);
          command.add(PoolLaneUtils.moveAllChildren(editPart, checkNegative));
        }
      }
    }
    Command cmd =
        new SetValueCmd(diagram, CWM_PKG.getDiagramType_Mode(), actualMode) {
          public void redo() {
            super.redo();
            updatePalette(getValue());
          }

          public void undo() {
            super.undo();
            updatePalette(getUndoValue());
          }

          public void updatePalette(Object value) {
            WorkflowModelEditorPaletteFactory.setDiagramModeType((DiagramModeType) value);
            WorkflowModelEditorPaletteFactory.updatePalette(diagramEditorPage);
            WorkflowModelEditorPaletteFactory.setDiagramModeType(null);
          }
        };
    command.add(cmd);
    command.add(
        new DelegatingCommand() {
          public Command createDelegate() {
            CompoundCommand cmd = new CompoundCommand();
            PoolSymbol poolSymbol = DiagramUtil.getDefaultPool(diagram);
            EditPart editPart = diagramEditorPage.findEditPart(diagram);
            Rectangle newSize = PoolLaneUtils.checkPoolSize((DiagramEditPart) editPart);
            if (newSize != null) {
              cmd.add(
                  new SetValueCmd(
                      poolSymbol, CWM_PKG.getINodeSymbol_Width(), new Integer(newSize.width)));
              cmd.add(
                  new SetValueCmd(
                      poolSymbol, CWM_PKG.getINodeSymbol_Height(), new Integer(newSize.height)));
              return cmd;
            }
            return null;
          }
        });
    domain.getCommandStack().execute(command);
  }
  protected Command createNodeChangeBoundCommands(final List<ShapeEditPart> sortedNodes) {

    final CompoundCommand result = new CompoundCommand();
    final Iterator<ShapeEditPart> iterEditParts = sortedNodes.iterator();
    while (iterEditParts.hasNext()) {
      final ShapeEditPart shapeEditPart = iterEditParts.next();

      final ChangeBoundsRequest request =
          new ChangeBoundsRequest(org.eclipse.gef.RequestConstants.REQ_MOVE);
      request.setEditParts(shapeEditPart);
      final Point ptLocation = new Point(0, 0);
      // the zoom.
      double scale = 1.0;
      if (shapeEditPart.getRoot() instanceof DiagramRootEditPart) {
        final ZoomManager zoomManager =
            ((DiagramRootEditPart) shapeEditPart.getRoot()).getZoomManager();
        scale = zoomManager.getZoom();
      }
      // Compute request data.
      final Point ptOldLocation = shapeEditPart.getFigure().getBounds().getLocation();

      final Dimension delta = ptLocation.getDifference(ptOldLocation);

      request.setMoveDelta(new PrecisionPoint(delta.width * scale, delta.height * scale));
      request.setLocation(new PrecisionPoint(ptLocation.x * scale, ptLocation.y * scale));

      final Command cmd = this.buildCommandWrapper(request, shapeEditPart);
      result.add(cmd);
    }

    return result;
  }
 private void addNewChild(XamlNode parent, XamlNode child) {
   if (child instanceof XamlAttribute && !parent.getAttributes().contains(child)) {
     commandList.add(new AddNewChildCommand(parent, child));
   } else if (child instanceof XamlElement && !parent.getChildNodes().contains(child)) {
     commandList.add(new AddNewChildCommand(parent, child));
   }
 }
 /**
  * Gets a command from each child in the group.
  *
  * @param request
  * @return the compound command
  */
 private Command getCommandFromChildren(Request request) {
   CompoundCommand cc = new CompoundCommand();
   for (Iterator iter = getHost().getChildren().iterator(); iter.hasNext(); ) {
     EditPart childEP = (EditPart) iter.next();
     cc.add(childEP.getCommand(request));
   }
   cc.unwrap();
   return cc;
 }
 /**
  * Overridden so that if a child shape is moved or resized such that the group's location (i.e.
  * top left corner) changes, the group's location as well as all the children's relative locations
  * are updated.
  */
 protected Command getResizeChildrenCommand(ChangeBoundsRequest request) {
   CompoundCommand resize = new CompoundCommand();
   resize.add(super.getResizeChildrenCommand(request));
   resize.add(
       new ICommandProxy(
           new UpdateGroupLocationCommand(
               ((IGraphicalEditPart) getHost()).getEditingDomain(), (View) getHost().getModel())));
   return resize;
 }
  protected Command computeCommand() {
    MUIElement selectedPart = model;

    if (selectedPart instanceof MPart) {
      MGenericStack<MUIElement> partStack = findParentStack();
      if (partStack != null) {
        selectedPart = partStack;
      }
    }

    MElementContainer<MUIElement> parent = partStack.getParent();
    List<MUIElement> children = parent.getChildren();
    int index = children.indexOf(partStack);
    if (parent instanceof MGenericTile<?>) {
      MGenericTile<?> genericTile = (MGenericTile<?>) parent;
      int modelIndex = children.indexOf(selectedPart);
      if (modelIndex == 0 && index == 1 && children.size() == 2 && genericTile.isHorizontal()) {
        return UnexecutableCommand.INSTANCE;
      }
    }

    CompoundCommand result = new CompoundCommand();

    MPartSashContainer newSash = MBasicFactory.INSTANCE.createPartSashContainer();
    String preferData = partStack.getContainerData();
    newSash.setContainerData(preferData);
    newSash.setHorizontal(true);

    if (selectedPart instanceof MPartStack) {
      if (selectedPart.getParent() == null) {
        selectedPart.setContainerData(preferData);
        result.add(CommandFactory.createAddChildCommand(newSash, selectedPart, 0));
      } else {
        result.add(new ChangeParentCommand(newSash, selectedPart, 0));
        if (!preferData.equals(selectedPart.getContainerData())) {
          result.add(
              new ApplyAttributeSettingCommand(
                  (EObject) selectedPart, "containerData", preferData));
        }
      }
    } else if (selectedPart instanceof MPart) {
      MPart part = (MPart) selectedPart;
      MPartStack createPartStack = MBasicFactory.INSTANCE.createPartStack();
      createPartStack.setContainerData(preferData);
      if (part.getParent() != null) {
        result.add(new ChangeParentCommand(createPartStack, part, 0));
      } else {
        result.add(CommandFactory.createAddChildCommand(createPartStack, part, 0));
      }
      result.add(CommandFactory.createAddChildCommand(newSash, createPartStack, 0));
    }

    result.add(new ChangeParentCommand(newSash, partStack, 1));

    result.add(CommandFactory.createAddChildCommand(parent, newSash, index));
    return result.unwrap();
  }
 private CompoundCommand clone(CompoundCommand commands) {
   CompoundCommand ret = new CompoundCommand();
   if (dependantCommands != null) {
     for (Iterator iter = commands.getCommands().iterator(); iter.hasNext(); ) {
       RetargetParentPasteCommand command = (RetargetParentPasteCommand) iter.next();
       ret.add(command.clone());
     }
   }
   return ret;
 }
 /** @generated */
 protected Command getDestroyElementCommand(DestroyElementRequest req) {
   CompoundCommand cc = getDestroyEdgesCommand();
   addDestroyShortcutsCommand(cc);
   View view = (View) getHost().getModel();
   if (view.getEAnnotation("Shortcut") != null) { // $NON-NLS-1$
     req.setElementToDestroy(view);
   }
   cc.add(getGEFWrapper(new DestroyElementCommand(req)));
   return cc.unwrap();
 }
  @Override
  protected boolean handleKeyDown(KeyEvent event) {
    int dx = 0;
    int dy = 0;

    if (event.keyCode == SWT.SHIFT) {
      shift = true;
    }

    if (event.keyCode == SWT.ARROW_DOWN) {
      dy = 1;

    } else if (event.keyCode == SWT.ARROW_LEFT) {
      dx = -1;

    } else if (event.keyCode == SWT.ARROW_RIGHT) {
      dx = 1;

    } else if (event.keyCode == SWT.ARROW_UP) {
      dy = -1;
    }

    ERDiagram diagram = (ERDiagram) this.getCurrentViewer().getContents().getModel();

    List selectedObject = this.getCurrentViewer().getSelectedEditParts();
    if (!selectedObject.isEmpty()) {

      CompoundCommand command = new CompoundCommand();

      for (Object object : selectedObject) {

        if (object instanceof ERTableEditPart || object instanceof NoteEditPart) {
          NodeElementEditPart editPart = (NodeElementEditPart) object;

          NodeElement nodeElement = (NodeElement) editPart.getModel();

          MoveElementCommand moveElementCommand =
              new MoveElementCommand(
                  diagram,
                  editPart.getFigure().getBounds(),
                  nodeElement.getX() + dx,
                  nodeElement.getY() + dy,
                  nodeElement.getWidth(),
                  nodeElement.getHeight(),
                  nodeElement);

          command.add(moveElementCommand);
        }
      }

      this.executeCommand(command.unwrap());
    }

    return super.handleKeyDown(event);
  }
 @Override
 protected Command getAddCommand(Request req) {
   ChangeBoundsRequest request = (ChangeBoundsRequest) req;
   List editParts = request.getEditParts();
   CompoundCommand command = new CompoundCommand();
   for (int i = 0; i < editParts.size(); i++) {
     EditPart child = (EditPart) editParts.get(i);
     command.add(createAddCommand(child));
   }
   return command.unwrap();
 }
 /**
  * @see
  *     org.eclipse.gef.editpolicies.ContainerEditPolicy#getAddCommand(org.eclipse.gef.requests.GroupRequest)
  */
 protected Command getAddCommand(GroupRequest request) {
   CompoundCommand cmd = new CompoundCommand();
   for (int i = 0; i < request.getEditParts().size(); i++) {
     AddAndAssignSourceCommand add = new AddAndAssignSourceCommand();
     add.setParent((StructuredActivity) getHost().getParent().getModel());
     add.setSource((Activity) getHost().getModel());
     add.setChild(((Activity) ((EditPart) request.getEditParts().get(i)).getModel()));
     cmd.add(add);
   }
   return cmd;
 }
 /**
  * Creates commands to destroy all host incoming and outgoing links.
  *
  * @generated
  */
 protected CompoundCommand getDestroyEdgesCommand() {
   CompoundCommand cmd = new CompoundCommand();
   View view = (View) getHost().getModel();
   for (Iterator it = view.getSourceEdges().iterator(); it.hasNext(); ) {
     cmd.add(getDestroyElementCommand((Edge) it.next()));
   }
   for (Iterator it = view.getTargetEdges().iterator(); it.hasNext(); ) {
     cmd.add(getDestroyElementCommand((Edge) it.next()));
   }
   return cmd;
 }
 private Command getDeleteComponentCommand() {
   CompoundCommand commands = new CompoundCommand();
   if (getSourceConnections().size() > 0)
     commands.add(getConnectionsDeleteCommand(getSourceConnections()));
   if (getTargetConnections().size() > 0)
     commands.add(getConnectionsDeleteCommand(getTargetConnections()));
   if (getParent() != null)
     commands.add(
         new DeleteVisualComponentCommand(
             (ComponentDiagram) getParent().getModel(), (NodeVisualModel) getModel()));
   return commands;
 }
  /**
   * Execute the command : create the model element, then the corresponding views
   *
   * @see org.eclipse.gef.commands.Command#execute()
   */
  @Override
  public void execute() {
    Object constraint = null;
    if (elementCreationCommand != null) {
      elementCreationCommand.execute();
      constraint = elementCreationCommand.getICommand().getCommandResult().getReturnValue();
    }
    if (constraint instanceof Constraint && compartment != null && type != null) {
      // construct the complete command for views creation and execute it.
      viewsCreationCommand = new CompoundCommand();
      // creation of the node by the compartment
      ViewDescriptor descriptor =
          new CreateViewRequest.ViewDescriptor(
              new EObjectAdapter((EObject) constraint),
              Node.class,
              type.getSemanticHint(),
              compartment.getDiagramPreferencesHint());
      CreateViewRequest request = new CreateViewRequest(descriptor);
      Command nodeCreationCommand = compartment.getCommand(request);
      viewsCreationCommand.add(nodeCreationCommand);

      // try and recover the created edit part, then create the link
      if (linkedActionEditPart != null && getLinkType() != null) {
        IAdaptable targetAdapter = extractResult(nodeCreationCommand);
        if (targetAdapter != null) {
          IAdaptable sourceAdapter = new SemanticAdapter(null, linkedActionEditPart.getModel());
          // descriptor of the link
          CreateConnectionViewRequest.ConnectionViewDescriptor linkdescriptor =
              new CreateConnectionViewRequest.ConnectionViewDescriptor(
                  getLinkType(),
                  getLinkType().getSemanticHint(),
                  compartment.getDiagramPreferencesHint());
          CommonDeferredCreateConnectionViewCommand aLinkCommand =
              new CommonDeferredCreateConnectionViewCommand(
                  EditorUtils.getTransactionalEditingDomain(),
                  getLinkType().getSemanticHint(),
                  sourceAdapter,
                  targetAdapter,
                  compartment.getViewer(),
                  compartment.getDiagramPreferencesHint(),
                  linkdescriptor,
                  null);
          aLinkCommand.setElement((EObject) constraint);
          viewsCreationCommand.add(new ICommandProxy(aLinkCommand));
        }
      }
      viewsCreationCommand.execute();
    }
  }
  private Command createCommandChain() {
    CompoundCommand chain = new CompoundCommand();

    sort(_editParts);
    double startPosition = calculateStartPosition();
    double spacing = calculateSpacing();

    for (int i = 1; i < _editParts.size() - 1; i++) {
      AbstractWidgetModel widget = _editParts.get(i).getWidgetModel();
      int newPosition = calculateNewPosition(startPosition, spacing, i);

      chain.add(new SetPropertyCommand(widget, _positionProperty, newPosition));
    }

    return chain;
  }
 private void updateDependantCommands(NodeVisualModel parentVisualModel) {
   if (dependantCommands != null) {
     for (Iterator iter = dependantCommands.getCommands().iterator(); iter.hasNext(); ) {
       RetargetParentPasteCommand command = (RetargetParentPasteCommand) iter.next();
       command.setParent(parentVisualModel);
     }
   }
 }
 /**
  * Undo model and views creation
  *
  * @see org.eclipse.gef.commands.Command#undo()
  */
 @Override
 public void undo() {
   if (viewsCreationCommand != null) {
     viewsCreationCommand.undo();
   }
   if (elementCreationCommand != null) {
     elementCreationCommand.undo();
   }
 }
  /**
   * Adds a "Set as default" behavior to a list of commands
   *
   * @param commands
   * @return
   */
  protected List<Command> convertToDefault(List<Command> commands) {
    List<Command> result = new ArrayList<Command>(commands.size());
    for (Command command : commands) {
      final Command commandToExecute = command;
      CompoundCommand compound = new CompoundCommand(commandToExecute.getLabel());
      compound.add(commandToExecute);
      compound.add(
          new Command("Set default drop behavior") {

            @Override
            public void execute() {
              defaultHandler.defaultActionSelected(commandToExecute);
            }
          });

      result.add(compound);
    }
    return result;
  }
Exemple #21
0
  private Command createCommand(List<?> selection, RGB newColor) {
    CompoundCommand result = new CompoundCommand(Messages.FillColorAction_1);

    for (Object object : selection) {
      if (object instanceof EditPart) {
        Object model = ((EditPart) object).getModel();
        if (shouldEnable(model)) {
          Command cmd =
              new FillColorCommand(
                  (IDiagramModelObject) model, ColorFactory.convertRGBToString(newColor));
          if (cmd.canExecute()) {
            result.add(cmd);
          }
        }
      }
    }

    return result.unwrap();
  }
 /** @generated */
 protected void addDestroyChildNodesCommand(CompoundCommand cmd) {
   View view = (View) getHost().getModel();
   EAnnotation annotation = view.getEAnnotation("Shortcut"); // $NON-NLS-1$
   if (annotation != null) {
     return;
   }
   for (Iterator it = view.getChildren().iterator(); it.hasNext(); ) {
     Node node = (Node) it.next();
     switch (hub.top.adaptiveSystem.diagram.part.AdaptiveSystemVisualIDRegistry.getVisualID(
         node)) {
       case hub.top.adaptiveSystem.diagram.edit.parts.PreNetEditPart.VISUAL_ID:
         cmd.add(getDestroyElementCommand(node));
         break;
       case hub.top.adaptiveSystem.diagram.edit.parts.DoNetEditPart.VISUAL_ID:
         cmd.add(getDestroyElementCommand(node));
         break;
     }
   }
 }
  /** Clear links */
  @SuppressWarnings({"rawtypes", "unchecked"})
  private static void clearLinks() {
    Collection values =
        getDiagramEditor().getDiagramGraphicalViewer().getEditPartRegistry().values();
    Iterator iterator = values.iterator();
    CompoundCommand ccModel = new CompoundCommand();
    org.eclipse.gef.commands.CompoundCommand ccView =
        new org.eclipse.gef.commands.CompoundCommand();

    while (iterator.hasNext()) {
      Object editPart = iterator.next();
      if (editPart instanceof EsbLinkEditPart) {
        EsbLinkEditPart linkEditPart = (EsbLinkEditPart) editPart;
        /*
         * We shouldn't remove EsbLinkEditParts if the target of the link is a AbstractEndpointInputConnectorEditPart.
         * Because these kind of links will not be get regenerated again according to the current implementation.
         */
        if (linkEditPart.getTarget() instanceof AbstractEndpointInputConnectorEditPart) {
          continue;
        }
        Collection linkCollection = new ArrayList();
        linkCollection.add(((ConnectorImpl) linkEditPart.getModel()).getElement());
        org.eclipse.emf.edit.command.DeleteCommand modelDeleteCommand =
            new org.eclipse.emf.edit.command.DeleteCommand(
                getDiagramEditor().getEditingDomain(), linkCollection);
        if (modelDeleteCommand.canExecute()) {
          ccModel.append(modelDeleteCommand);
        }
        DeleteCommand viewDeleteCommand = new DeleteCommand(linkEditPart.getNotationView());
        if (viewDeleteCommand.canExecute()) {
          ccView.add(new ICommandProxy(viewDeleteCommand));
        }
      }
    }

    if (ccModel.canExecute()) {
      getDiagramEditor().getEditingDomain().getCommandStack().execute(ccModel);
    }
    if (ccView.canExecute()) {
      getDiagramEditor().getDiagramEditDomain().getDiagramCommandStack().execute(ccView);
    }
  }
  public void execute() {
    visualModel = EditormodelFactory.eINSTANCE.createNodeVisualModel(copyVisualModel);
    visualModel.setSemanticModel(
        CoremodelFactory.eINSTANCE.createComponentModel(
            (ComponentModel) copyVisualModel.getSemanticModel()));

    updateBounds();
    updateDependantCommands(visualModel);
    dependantCommands.execute();

    super.redo();
  }
  /** {@inheritDoc} */
  @Override
  protected Command createDeleteViewCommand(GroupRequest deleteRequest) {
    CompoundCommand deleteViewsCommand = new CompoundCommand();

    /* apex added start */
    // Activation의 source connections들을 parent인 lifeline으로 이동하여 연결
    if (getHost() instanceof ShapeNodeEditPart) {
      LifelineEditPart lifelineEP = SequenceUtil.getParentLifelinePart(getHost());
      IFigure figure = lifelineEP.getNodeFigure();
      Rectangle newBounds = figure.getBounds().getCopy();
      figure.translateToAbsolute(newBounds);

      List connections = ((ShapeNodeEditPart) getHost()).getSourceConnections();
      for (Iterator iter = connections.iterator(); iter.hasNext(); ) {
        ConnectionNodeEditPart connection = (ConnectionNodeEditPart) iter.next();
        Point location = SequenceUtil.getAbsoluteEdgeExtremity(connection, true);

        ReconnectRequest reconnReq = new ReconnectRequest();
        reconnReq.setConnectionEditPart(connection);
        reconnReq.setLocation(location);
        reconnReq.setTargetEditPart(lifelineEP);
        reconnReq.setType(RequestConstants.REQ_RECONNECT_SOURCE);
        reconnReq.getExtendedData().put(SequenceRequestConstant.DO_NOT_MOVE_EDIT_PARTS, true);

        deleteViewsCommand.add(lifelineEP.getCommand(reconnReq));
      }
    }
    /* apex added end */

    Command deleteViewCommand = super.createDeleteViewCommand(deleteRequest);
    deleteViewsCommand.add(deleteViewCommand);
    if (getHost() instanceof ShapeNodeEditPart) {
      TransactionalEditingDomain editingDomain = ((ShapeNodeEditPart) getHost()).getEditingDomain();
      SequenceDeleteHelper.completeDeleteExecutionSpecificationViewCommand(
          deleteViewsCommand, editingDomain, getHost());
    }

    return deleteViewsCommand;
  }
  /**
   * Gets the command to handle objects dropped into the Mapping diagram.
   *
   * @param dropRequest The drop request.
   * @return The executable command.
   */
  public Command getDropObjectsCommand(DropObjectsRequest dropRequest) {

    ModelRelEditPart modelRelEditPart = (ModelRelEditPart) getHost();
    CompoundCommand command = new CompoundCommand("Add model element references");
    IElementType elementType =
        MIDElementTypes.getElementType(ModelElementReferenceEditPart.VISUAL_ID);
    EReference containment = RelationshipPackage.Literals.MODEL_ENDPOINT_REFERENCE__MODEL_ELEM_REFS;

    Iterator<?> it = dropRequest.getObjects().iterator();
    while (it.hasNext()) {
      RelationshipDiagramOutlineDropObject dropObj =
          (RelationshipDiagramOutlineDropObject) it.next();
      ModelEndpointReference modelEndpointRef = dropObj.getModelEndpointReference();
      CreateElementRequest createReq =
          new CreateElementRequest(
              modelRelEditPart.getEditingDomain(), modelEndpointRef, elementType, containment);
      command.add(
          new ICommandProxy( // convert GMF command to GEF command
              new ModelElementReferenceDropCommand(createReq, dropObj)));
    }

    return command;
  }
  /** creates the command to move the shapes left or right. */
  protected Command getCommand() {
    if (_container == null) {
      return null;
    }
    CompoundCommand command = new CompoundCommand("Multiple Shape Move");
    TransactionalEditingDomain editingDomain = _container.getEditingDomain();

    Point moveDelta = ((ChangeBoundsRequest) getSourceRequest()).getMoveDelta().getCopy();
    Dimension spSizeDelta = new Dimension(moveDelta.x, moveDelta.y);
    ZoomManager zoomManager =
        ((DiagramRootEditPart) getCurrentViewer().getRootEditPart()).getZoomManager();
    spSizeDelta.scale(1 / zoomManager.getZoom());
    command.add(_container.getCommand(getSourceRequest()));

    for (IGraphicalEditPart sp : _subProcesses) {
      Dimension spDim = sp.getFigure().getBounds().getSize().getCopy();
      spDim.expand(spSizeDelta);
      SetBoundsCommand setBounds =
          new SetBoundsCommand(editingDomain, "MultipleShape Move", sp, spDim);
      command.add(new ICommandProxy(setBounds));
    }
    return command;
  }
  /**
   * @see org.eclipse.ui.IActionDelegate#run(org.eclipse.jface.action.IAction)
   * @param action
   */
  public void run(IAction action) {
    // 1 this is a associationEnd?
    CompoundCommand command = new CompoundCommand();
    if (selectedElement instanceof AssociationEndSourceEditPart
        || selectedElement instanceof AssociationEndTargetEditPart
        || selectedElement instanceof AssociationClassRoleSourceEditPart
        || selectedElement instanceof AssociationClassRoleTargetEditPart) {
      // 2. look for the future owner of the property, run only for binary association
      Property property = (Property) ((GraphicalEditPart) selectedElement).resolveSemanticElement();
      if (property.getAssociation() != null) {

        // add property in association

        EStructuralFeature feature = UMLPackage.eINSTANCE.getAssociation_NavigableOwnedEnd();
        List<Property> attributeList = new ArrayList<Property>();
        attributeList.addAll(property.getAssociation().getNavigableOwnedEnds());
        attributeList.remove(property);
        SetRequest setRequest = new SetRequest(property.getAssociation(), feature, attributeList);
        SetValueCommand setValueCommand = new SetValueCommand(setRequest);
        command.add(new ICommandProxy(setValueCommand));
        selectedElement.getDiagramEditDomain().getDiagramCommandStack().execute(command);
      }
    }
  }
 /** @generated */
 protected void addDestroyShortcutsCommand(CompoundCommand command) {
   View view = (View) getHost().getModel();
   if (view.getEAnnotation("Shortcut") != null) { // $NON-NLS-1$
     return;
   }
   for (Iterator it = view.getDiagram().getChildren().iterator(); it.hasNext(); ) {
     View nextView = (View) it.next();
     if (nextView.getEAnnotation("Shortcut") == null
         || !nextView.isSetElement()
         || nextView.getElement() != view.getElement()) { // $NON-NLS-1$
       continue;
     }
     command.add(getDestroyElementCommand(nextView));
   }
 }
 @Override
 protected void executeCurrentCommand() {
   FiguresHelper.AVOID_OVERLAP_ENABLE = false;
   super.executeCurrentCommand();
   FiguresHelper.AVOID_OVERLAP_ENABLE = true;
   CompoundCommand cc = new CompoundCommand("Check Overlap");
   for (IGraphicalEditPart ep : _movingShapes) {
     Location loc = (Location) ((Node) ep.getNotationView()).getLayoutConstraint();
     Point oldLoc = new Point(loc.getX(), loc.getY());
     Point newLoc =
         FiguresHelper.handleCompartmentMargin(
             ep, loc.getX(), loc.getY(), (ep.resolveSemanticElement() instanceof SubProcessEvent));
     if ((newLoc.x != 0 && newLoc.y != 0) && !newLoc.equals(oldLoc)) {
       cc.add(
           new ICommandProxy(
               new SetBoundsCommand(
                   _container.getEditingDomain(),
                   "Check Overlap",
                   new EObjectAdapter(ep.getNotationView()),
                   newLoc)));
     }
   }
   executeCommand(cc);
 }