| //------------------------------------------------------------------------------ |
| // Copyright (c) 2005, 2006 IBM Corporation and others. |
| // All rights reserved. This program and the accompanying materials |
| // are made available under the terms of the Eclipse Public License v1.0 |
| // which accompanies this distribution, and is available at |
| // http://www.eclipse.org/legal/epl-v10.html |
| // |
| // Contributors: |
| // IBM Corporation - initial implementation |
| //------------------------------------------------------------------------------ |
| package org.eclipse.epf.diagram.add.service; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collections; |
| import java.util.Comparator; |
| import java.util.Iterator; |
| import java.util.List; |
| |
| import org.eclipse.draw2d.IFigure; |
| import org.eclipse.draw2d.PositionConstants; |
| import org.eclipse.draw2d.RectangleFigure; |
| import org.eclipse.draw2d.ToolbarLayout; |
| import org.eclipse.draw2d.geometry.Dimension; |
| import org.eclipse.draw2d.geometry.Point; |
| import org.eclipse.draw2d.geometry.Rectangle; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.transaction.Transaction; |
| import org.eclipse.emf.transaction.impl.InternalTransactionalEditingDomain; |
| import org.eclipse.epf.diagram.add.edit.parts.ActivityDetailDiagramEditPart; |
| import org.eclipse.epf.diagram.add.edit.parts.RoleNodeEditPart; |
| import org.eclipse.epf.diagram.add.edit.parts.RoleTaskCompositeEditPart; |
| import org.eclipse.epf.diagram.add.edit.parts.TaskNodeEditPart; |
| import org.eclipse.epf.diagram.add.edit.parts.WorkProductCompositeEditPart; |
| import org.eclipse.epf.diagram.core.commands.ChangeBoundsCommand; |
| import org.eclipse.epf.diagram.core.util.DiagramConstants; |
| import org.eclipse.gef.DefaultEditDomain; |
| import org.eclipse.gef.EditPart; |
| import org.eclipse.gef.GraphicalEditPart; |
| import org.eclipse.gef.GraphicalViewer; |
| import org.eclipse.gef.commands.Command; |
| import org.eclipse.gef.commands.CommandStack; |
| import org.eclipse.gef.editparts.AbstractGraphicalEditPart; |
| import org.eclipse.gef.ui.actions.ActionRegistry; |
| import org.eclipse.gmf.runtime.diagram.core.util.ViewUtil; |
| import org.eclipse.gmf.runtime.diagram.ui.editparts.ConnectionNodeEditPart; |
| import org.eclipse.gmf.runtime.diagram.ui.editparts.DiagramEditPart; |
| import org.eclipse.gmf.runtime.diagram.ui.editparts.IGraphicalEditPart; |
| import org.eclipse.gmf.runtime.diagram.ui.editparts.ShapeNodeEditPart; |
| import org.eclipse.gmf.runtime.draw2d.ui.figures.FigureUtilities; |
| import org.eclipse.gmf.runtime.draw2d.ui.figures.WrapLabel; |
| import org.eclipse.gmf.runtime.gef.ui.figures.NodeFigure; |
| import org.eclipse.gmf.runtime.notation.Node; |
| import org.eclipse.gmf.runtime.notation.NotationPackage; |
| import org.eclipse.gmf.runtime.notation.View; |
| import org.eclipse.jface.viewers.StructuredSelection; |
| import org.eclipse.swt.graphics.Font; |
| |
| /** |
| * Service class for reset the Activity Detail Diagram. |
| * Code migrated from old diagram code. |
| * |
| * @author Shashidhar Kannoori |
| * @author Phong Nguyen Le |
| * @since 1.2 |
| **/ |
| public class DiagramResetService { |
| |
| private DefaultEditDomain editDomain; |
| |
| private GraphicalViewer graphicalViewer; |
| |
| private ActionRegistry actionRegistry; |
| |
| private InternalTransactionalEditingDomain transactionDomain; |
| |
| int delta = 0; |
| |
| private static final int IMG_HEIGHT = 32; |
| |
| public DiagramResetService(InternalTransactionalEditingDomain transactionDomain, |
| GraphicalViewer graphicalViewer, DefaultEditDomain editDomain, |
| ActionRegistry actionRegistry) { |
| this.transactionDomain = transactionDomain; |
| this.graphicalViewer = graphicalViewer; |
| this.editDomain = editDomain; |
| this.actionRegistry = actionRegistry; |
| } |
| |
| private GraphicalViewer getGraphicalViewer() { |
| return graphicalViewer; |
| } |
| |
| /** |
| * Returns the command stack. |
| * |
| * @return the command stack |
| */ |
| protected CommandStack getCommandStack() { |
| return getEditDomain().getCommandStack(); |
| } |
| |
| /** |
| * Returns the edit domain. |
| * |
| * @return the edit domain |
| */ |
| protected DefaultEditDomain getEditDomain() { |
| return editDomain; |
| } |
| |
| /** |
| * Lazily creates and returns the action registry. |
| * |
| * @return the action registry |
| */ |
| protected ActionRegistry getActionRegistry() { |
| return actionRegistry; |
| } |
| |
| /** |
| * Method used only in ActivityDetailDiagram or any diagram need auto-layout. |
| * Method will verify recently added editparts in the Activitydetaildiagram editpart |
| * indirectly from WorkBreakdownStructure (means any descriptors created in wbs, corresponding |
| * EditPart will get created in ActivityDetailDiagram Viewer) and does auto-layout |
| * all the new added editparts and existing ones. |
| * |
| */ |
| public void cleanUpDiagram() { |
| if (getGraphicalViewer().getContents() instanceof ActivityDetailDiagramEditPart) { |
| ActivityDetailDiagramEditPart dep = (ActivityDetailDiagramEditPart) getGraphicalViewer() |
| .getContents(); |
| List children = dep.getRecentlyAddedParts(); |
| |
| // If any oblique links rectify them to straight. |
| // anyObliqueLinks(dep, children); |
| |
| if (!children.isEmpty()) { |
| Comparator<Object> comparator = new Comparator<Object>() { |
| |
| public int compare(Object arg0, Object arg1) { |
| int rc = 0; |
| if (arg0 instanceof RoleTaskCompositeEditPart) { |
| if (!(arg1 instanceof RoleTaskCompositeEditPart)) |
| rc = -1; |
| } else if (arg1 instanceof RoleTaskCompositeEditPart) |
| rc = 1; |
| return rc; |
| } |
| |
| }; |
| |
| Object[] array = children.toArray(); |
| Arrays.sort(array, comparator); |
| for (int a = 0; a < array.length; a++) { |
| AbstractGraphicalEditPart ep = (AbstractGraphicalEditPart) array[a]; |
| adjustSize(ep); |
| } |
| |
| // force relayout after size adjustment |
| // |
| dep.getViewport().validate(); |
| |
| for (int b = 0; b < array.length; b++) { |
| AbstractGraphicalEditPart ep = (AbstractGraphicalEditPart) array[b]; |
| cleanUp(ep); |
| } |
| for (int c = 0; c < array.length; c++) { |
| AbstractGraphicalEditPart ep = (AbstractGraphicalEditPart) array[c]; |
| reduceLinkLength(ep); |
| } |
| // for (int c = 0; c < array.length; c++) { |
| // AbstractGraphicalEditPart ep = (AbstractGraphicalEditPart) array[c]; |
| // if(ep instanceof RoleTaskCompositeEditPart){ |
| // resetSizes(ep, ep); |
| // } |
| // } |
| packDiagram(); |
| dep.refresh(); |
| dep.clearRecentlyAddedParts(); |
| getGraphicalViewer().setSelection(new StructuredSelection()); |
| } |
| } |
| } |
| |
| /** |
| * This method does a vertical alignment of all nodes with links |
| */ |
| private void cleanUp(AbstractGraphicalEditPart ep) { |
| if (!(ep instanceof WorkProductCompositeEditPart)) { |
| List sourceLinks = ep.getSourceConnections(); |
| if (sourceLinks.size() > 0) { |
| for (int b = 0; b < sourceLinks.size(); b++) { |
| ConnectionNodeEditPart link = (ConnectionNodeEditPart) sourceLinks.get(b); |
| AbstractGraphicalEditPart target = (AbstractGraphicalEditPart) link |
| .getTarget(); |
| int w = target.getFigure().getBounds().width; |
| int ew = ep.getFigure().getPreferredSize().width; |
| if (w < ew) { |
| Command c = new ChangeBoundsCommand(transactionDomain, ((Node) ep |
| .getModel()), target.getFigure().getBounds() |
| .getLocation(), w, target.getFigure().getPreferredSize().height); |
| getCommandStack().execute(c); |
| int h = target.getFigure().getPreferredSize().height; |
| target.getFigure() |
| .setPreferredSize(new Dimension(w, h)); |
| target.getFigure().setSize(new Dimension(w, h)); |
| } |
| List list = new ArrayList(); |
| list.add(ep); |
| list.add(target); |
| verticalAlignToFirstSelected(list); |
| } |
| } |
| List targetLinks = ep.getTargetConnections(); |
| if (targetLinks.size() > 0) { |
| for (int b = 0; b < targetLinks.size(); b++) { |
| ConnectionNodeEditPart link = (ConnectionNodeEditPart) targetLinks.get(b); |
| AbstractGraphicalEditPart source = (AbstractGraphicalEditPart) link |
| .getSource(); |
| int w = source.getFigure().getBounds().width; |
| int ew = ep.getFigure().getPreferredSize().width; |
| if (w < ew) { |
| Command c = new ChangeBoundsCommand(transactionDomain,((Node) ep |
| .getModel()), source.getFigure().getBounds() |
| .getLocation(), w,-1); |
| getCommandStack().execute(c); |
| int h = source.getFigure().getPreferredSize().height; |
| source.getFigure() |
| .setPreferredSize(new Dimension(w, h)); |
| source.getFigure().setSize(new Dimension(w, h)); |
| } |
| List list = new ArrayList(); |
| list.add(ep); |
| list.add(source); |
| verticalAlignToFirstSelected(list); |
| } |
| } |
| if (ep instanceof WorkProductCompositeEditPart || |
| ep instanceof RoleTaskCompositeEditPart) { |
| List children = ep.getChildren(); |
| for (int d = 0; d < children.size(); d++) { |
| AbstractGraphicalEditPart p = (AbstractGraphicalEditPart) children |
| .get(d); |
| cleanUp(p); |
| } |
| } |
| } |
| } |
| |
| /** |
| * For auto-layout, need to adjust connection(or link) length, based on |
| * connecting editparts(figures). |
| * |
| */ |
| private boolean reduceLinkLength(AbstractGraphicalEditPart part) { |
| boolean moved = false; |
| // only move new WorkProductComposite elements |
| if (part instanceof WorkProductCompositeEditPart) { |
| AbstractGraphicalEditPart linkedPart = null; |
| int position = PositionConstants.CENTER; |
| // is this element linked to another item? |
| if (part.getTargetConnections().size() > 0) { |
| linkedPart = (AbstractGraphicalEditPart) ((ConnectionNodeEditPart) part |
| .getTargetConnections().get(0)).getSource(); |
| position = PositionConstants.NORTH; |
| } else if (part.getSourceConnections().size() > 0) { |
| linkedPart = (AbstractGraphicalEditPart) ((ConnectionNodeEditPart) part |
| .getSourceConnections().get(0)).getTarget(); |
| position = PositionConstants.SOUTH; |
| } |
| if (linkedPart != null) { |
| if (!(linkedPart.getParent() instanceof DiagramEditPart)) { |
| linkedPart = (AbstractGraphicalEditPart) linkedPart |
| .getParent(); |
| } |
| // get the part's position |
| Rectangle partBounds = part.getFigure().getBounds(); |
| // get the linked part's position |
| Rectangle linkedPartBounds = linkedPart.getFigure().getBounds(); |
| // determine in which direction is the linked part |
| // int position = partBounds.getPosition(linkedPartBounds |
| // .getLocation()); |
| // assume it is below us, so this part moves up |
| int direction = -1; |
| if ((position & PositionConstants.NORTH) == PositionConstants.NORTH |
| || (position & PositionConstants.CENTER) == PositionConstants.CENTER) { |
| // above us, move down |
| direction = 1; |
| } |
| // set new bounds for the part so that it sites just outside of |
| // the linked part |
| Rectangle testBounds = partBounds.getCopy(); |
| if (direction == 1) { |
| testBounds.y = linkedPartBounds.y + linkedPartBounds.height |
| + VERT_PIX_PADDING; |
| } else { |
| testBounds.y = linkedPartBounds.y - VERT_PIX_PADDING |
| - partBounds.height; |
| } |
| // set the new location for the part in the model |
| Point np = new Point(testBounds.x, testBounds.y); |
| part.getFigure().setLocation(np); |
| Command c = new ChangeBoundsCommand(transactionDomain,(Node) part.getModel(), np, |
| partBounds.width, -1); |
| getCommandStack().execute(c); |
| } |
| } |
| return moved; |
| } |
| |
| /** |
| * Method to adjust the size of editpart. |
| * |
| */ |
| private void adjustSize(AbstractGraphicalEditPart ep) { |
| if (ep instanceof WorkProductCompositeEditPart) { |
| adjustSize((WorkProductCompositeEditPart) ep, 1); |
| } |
| else if (ep instanceof RoleTaskCompositeEditPart) { |
| adjustSize((RoleTaskCompositeEditPart) ep, 50); |
| } |
| } |
| |
| protected final static int HORIZ_PIX_PADDING = 30; |
| |
| protected final static int VERT_PIX_PADDING = 20; |
| |
| /** |
| * Adjusts the size of ContainerEditPart to accomodate number of editparts in a row, |
| * push the remaining the editparts in two second row. |
| * This is useful for {@link ToolbarLayout} |
| * |
| */ |
| private void adjustSize(ShapeNodeEditPart ep, int horizCount) { |
| int requiredWidth = 0; |
| int rowMaxHeight = 0; |
| int rows = 0; |
| int widthSum = 0; |
| int heightSum = 0; |
| int column = 0; |
| |
| delta = 0; |
| List children = ep.getChildren(); |
| IFigure parentFigure = ep.getFigure(); |
| //TODO: need revisit transaction usage |
| try{ |
| Transaction tx = ((InternalTransactionalEditingDomain)transactionDomain).startTransaction(false, Collections.EMPTY_MAP); |
| for (int p = 0; p < children.size();) { |
| if (column == 0) { |
| rows++; |
| } |
| if (column < horizCount) { |
| AbstractGraphicalEditPart child = (AbstractGraphicalEditPart) children |
| .get(p); |
| if(child instanceof RoleNodeEditPart || child instanceof TaskNodeEditPart){ |
| resetSize((ShapeNodeEditPart)child, parentFigure); |
| // List list = new ArrayList(); |
| // list.add(child.getModel()); |
| // PersistViewsCommand cmd = new PersistViewsCommand(transactionDomain, list); |
| // cmd.execute(new NullProgressMonitor(), null); |
| } |
| Dimension d = child.getFigure().getPreferredSize(); |
| widthSum += d.width; |
| if (d.height > rowMaxHeight) { |
| rowMaxHeight = d.height; |
| } |
| p++; |
| column++; |
| } else { |
| if (widthSum > requiredWidth) { |
| requiredWidth = widthSum; |
| } |
| heightSum += rowMaxHeight; |
| rowMaxHeight = 0; |
| widthSum = 0; |
| column = 0; |
| } |
| } |
| tx.commit(); |
| }catch(Exception e){ |
| |
| } |
| if (widthSum > requiredWidth) { |
| requiredWidth = widthSum; |
| } |
| heightSum += rowMaxHeight; |
| requiredWidth += HORIZ_PIX_PADDING |
| * Math.min(horizCount, children.size()); |
| int requiredHeight = heightSum + (VERT_PIX_PADDING * rows); |
| Command cmd = new ChangeBoundsCommand(transactionDomain, ((Node) ep.getModel()), ep |
| .getFigure().getBounds().getLocation(), requiredWidth, requiredHeight); |
| getCommandStack().execute(cmd); |
| ep.getFigure().setPreferredSize( |
| new Dimension(requiredWidth, requiredHeight)); |
| //((Node) ep.getModel()).setHeight(requiredHeight); |
| ep.getFigure().setSize(new Dimension(requiredWidth, requiredHeight)); |
| ep.getFigure().getLayoutManager().layout(ep.getFigure()); |
| // after layout, check the bottom-most child figure against the bottom |
| // of the container, adjust the bottom of the container is necessary |
| if (ep instanceof WorkProductCompositeEditPart && children.size() > 0) { |
| int totalCalculatedHeight = 0; |
| for (int i=0; i < children.size(); i++) { |
| GraphicalEditPart part = (GraphicalEditPart) children.get(i); |
| Node nodeObj = (Node) part.getModel(); |
| EObject o = nodeObj.getElement(); |
| totalCalculatedHeight += part.getFigure().getPreferredSize().height; |
| } |
| int height = totalCalculatedHeight + 20 + 5 * (children.size() - 1); |
| GraphicalEditPart last = (GraphicalEditPart) children.get(children |
| .size() - 1); |
| Point childBottom = last.getFigure().getBounds().getBottom(); |
| Point parentBottom = ep.getFigure().getBounds().getBottom(); |
| int delta = parentBottom.y - childBottom.y - (VERT_PIX_PADDING / 2); |
| // ep.getFigure().setPreferredSize( |
| // new Dimension(requiredWidth, requiredHeight - delta)); |
| // cmd = new ChangeBoundsCommand(transactionDomain, ((Node) ep.getModel()), ep |
| // .getFigure().getBounds().getLocation(), -1, requiredHeight-delta); |
| // getCommandStack().execute(cmd); |
| // ep.getFigure().setSize( |
| // new Dimension(requiredWidth, requiredHeight - delta)); |
| ep.getFigure().setPreferredSize( |
| new Dimension(requiredWidth, height)); |
| cmd = new ChangeBoundsCommand(transactionDomain, ((Node) ep.getModel()), ep |
| .getFigure().getBounds().getLocation(), -1, height); |
| getCommandStack().execute(cmd); |
| ep.getFigure().setSize( |
| new Dimension(requiredWidth, height)); |
| } |
| } |
| |
| |
| |
| |
| private void resetSize(ShapeNodeEditPart ep, IFigure parentFigure){ |
| |
| Node model = (Node)ep.getModel(); |
| IGraphicalEditPart child = (IGraphicalEditPart)ep.getChildren().get(0); |
| NodeFigure nodeFigure = (NodeFigure)ep.getFigure(); |
| List nodeFigureChildren = nodeFigure.getChildren(); |
| IFigure childFigure = (IFigure)nodeFigureChildren.get(0); |
| if(childFigure instanceof RectangleFigure){ |
| IFigure labelFigure = (IFigure)((RectangleFigure)childFigure).getChildren().get(0); |
| if(labelFigure instanceof WrapLabel){ |
| Dimension figDimension = labelFigure.getSize(); |
| Dimension d = labelFigure.getPreferredSize(); |
| Point p = nodeFigure.getLocation().getCopy(); |
| p.x = p.x + delta; |
| nodeFigure.setLocation(p); |
| if (d.width > nodeFigure.getSize().width) { |
| // System.out.println("Node figure width: "+nodeFigure.getSize().width); |
| // System.out.println("Text width: "+ d.width); |
| delta += d.width - nodeFigure.getSize().width; |
| } |
| if(d.width > figDimension.width){ |
| int width = d.width; |
| View view = ((View)child.getModel()); |
| ViewUtil.setStructuralFeatureValue(view, |
| NotationPackage.eINSTANCE.getSize_Width(), new Integer( |
| width)); |
| ViewUtil.setStructuralFeatureValue(model, |
| NotationPackage.eINSTANCE.getSize_Width(), new Integer( |
| width)); |
| nodeFigure.setPreferredSize(new Dimension(width, nodeFigure.getPreferredSize().height)); |
| if (childFigure.getPreferredSize().height > nodeFigure.getPreferredSize().height) |
| nodeFigure.setPreferredSize(new Dimension(width, childFigure.getPreferredSize().height)); |
| childFigure.setPreferredSize(new Dimension(width, childFigure.getPreferredSize().height)); |
| labelFigure.setPreferredSize(new Dimension(width, labelFigure.getPreferredSize().height)); |
| |
| nodeFigure.setSize(new Dimension(width, nodeFigure.getPreferredSize().height)); |
| if (childFigure.getPreferredSize().height > nodeFigure.getPreferredSize().height) |
| nodeFigure.setPreferredSize(new Dimension(width, childFigure.getPreferredSize().height)); |
| childFigure.setSize(new Dimension(width, childFigure.getPreferredSize().height)); |
| labelFigure.setSize(new Dimension(width, labelFigure.getPreferredSize().height)); |
| |
| // nodeFigure.setConstraint(childFigure, new Rectangle(nodeFigure.getLocation().x, |
| // nodeFigure.getLocation().y, width, childFigure.getBounds().height)); |
| // Change the location |
| // System.out.println("child bounds before: " + nodeFigure.getBounds() +"delta: " + delta); |
| } |
| } |
| } |
| } |
| |
| |
| protected void enumerateConnectedParts(AbstractGraphicalEditPart part, |
| List<EditPart> connected) { |
| // only add parts directly on the diagram surface |
| if (!connected.contains(part)) { |
| if (!(part.getParent() instanceof DiagramEditPart)) { |
| if (!connected.contains(part.getParent())) { |
| connected.add(part.getParent()); |
| } |
| } else { |
| connected.add(part); |
| } |
| AbstractGraphicalEditPart linkedPart = null; |
| List children = part.getChildren(); |
| for (int x = 0; x < children.size(); x++) { |
| AbstractGraphicalEditPart p = (AbstractGraphicalEditPart) children |
| .get(x); |
| enumerateConnectedParts(p, connected); |
| } |
| // is this element linked to another item? |
| for (int x = 0; x < part.getTargetConnections().size(); x++) { |
| linkedPart = (AbstractGraphicalEditPart) ((ConnectionNodeEditPart) part |
| .getTargetConnections().get(x)).getSource(); |
| enumerateConnectedParts(linkedPart, connected); |
| } |
| for (int x = 0; x < part.getSourceConnections().size(); x++) { |
| linkedPart = (AbstractGraphicalEditPart) ((ConnectionNodeEditPart) part |
| .getSourceConnections().get(x)).getTarget(); |
| enumerateConnectedParts(linkedPart, connected); |
| } |
| } |
| } |
| |
| /** |
| * This method finds single elements and groups of elements, and positions |
| * them starting from the top of the diagram and continuously down the page. |
| */ |
| private void packDiagram() { |
| ActivityDetailDiagramEditPart diagram = (ActivityDetailDiagramEditPart) getGraphicalViewer() |
| .getContents(); |
| // start at the top of the diagram |
| // Dimension diagramSize = diagram.getFigure().getSize(); |
| // no new shapes can be moved above this y-axis value |
| int reserved = 0; |
| // these are elements without connections |
| List<EditPart> stragglers = new ArrayList<EditPart>(); |
| // these are groups of elements connected with links |
| List<List> groups = new ArrayList<List>(); |
| // these are top level parts on the diagram that have been added |
| List diagramParts = diagram.getRecentlyAddedParts(); |
| for (int x = 0; x < diagramParts.size(); x++) { |
| AbstractGraphicalEditPart p = (AbstractGraphicalEditPart) diagramParts |
| .get(x); |
| boolean found = false; |
| for (int g = 0; g < groups.size() && found == false; g++) { |
| List group = (List) groups.get(g); |
| if (group.contains(p)) { |
| found = true; |
| break; |
| } |
| } |
| if (!found) { |
| List<EditPart> connected = new ArrayList<EditPart>(); |
| enumerateConnectedParts(p, connected); |
| if (connected.size() == 1) { |
| stragglers.add(p); |
| } else { |
| groups.add(connected); |
| } |
| } |
| } |
| // process each group closest to the top (min y value) |
| while (groups.size() > 0) { |
| List top = (List) groups.get(0); |
| int topY = getVerticalMinPart(top).getFigure().getBounds().y; |
| for (int x = 0; x < groups.size(); x++) { |
| List g = (List) groups.get(x); |
| int y = getVerticalMinPart(g).getFigure().getBounds().y; |
| if (y < topY) { |
| top = g; |
| topY = y; |
| } |
| } |
| int limit = reserved + 1; |
| int verticalDelta = limit - topY; |
| int leftX = getHorizontalMinPart(top).getFigure().getBounds().x; |
| int horizontalDelta = HORIZ_PIX_PADDING - leftX; |
| for (int x = 0; x < top.size(); x++) { |
| AbstractGraphicalEditPart p = (AbstractGraphicalEditPart) top |
| .get(x); |
| Rectangle bounds = p.getFigure().getBounds(); |
| ChangeBoundsCommand cbc = new ChangeBoundsCommand(transactionDomain,(Node) p |
| .getModel(), new Point(bounds.x + horizontalDelta, |
| bounds.y + verticalDelta), bounds.width, -1); |
| getCommandStack().execute(cbc); |
| p.getFigure().setLocation( |
| new Point(bounds.x + horizontalDelta, bounds.y |
| + verticalDelta)); |
| p.refresh(); |
| } |
| int bottomY = getVerticalMaxPart(top).getFigure().getBounds() |
| .bottom(); |
| reserved = bottomY + (VERT_PIX_PADDING * 2); |
| groups.remove(top); |
| } |
| int next = HORIZ_PIX_PADDING; |
| for (int x = 0; x < stragglers.size(); x++) { |
| int limit = reserved + 1; |
| AbstractGraphicalEditPart p = (AbstractGraphicalEditPart) stragglers |
| .get(x); |
| Rectangle bounds = p.getFigure().getBounds(); |
| ChangeBoundsCommand cbc = new ChangeBoundsCommand(transactionDomain, (Node) p |
| .getModel(), new Point(next, limit), bounds.width, -1); |
| getCommandStack().execute(cbc); |
| p.getFigure().setLocation(new Point(next, limit)); |
| p.refresh(); |
| next += bounds.width + HORIZ_PIX_PADDING; |
| } |
| } |
| |
| private AbstractGraphicalEditPart getVerticalMinPart(List parts) { |
| AbstractGraphicalEditPart rc = parts.size() > 0 ? (AbstractGraphicalEditPart) parts |
| .get(0) |
| : null; |
| for (int x = 0; x < parts.size(); x++) { |
| AbstractGraphicalEditPart p = (AbstractGraphicalEditPart) parts |
| .get(x); |
| if (p.getFigure().getBounds().y < rc.getFigure().getBounds().y) { |
| rc = p; |
| } |
| } |
| return rc; |
| } |
| |
| private AbstractGraphicalEditPart getHorizontalMinPart(List parts) { |
| AbstractGraphicalEditPart rc = parts.size() > 0 ? (AbstractGraphicalEditPart) parts |
| .get(0) |
| : null; |
| for (int x = 0; x < parts.size(); x++) { |
| AbstractGraphicalEditPart p = (AbstractGraphicalEditPart) parts |
| .get(x); |
| if (p.getFigure().getBounds().x < rc.getFigure().getBounds().x) { |
| rc = p; |
| } |
| } |
| return rc; |
| } |
| |
| private AbstractGraphicalEditPart getVerticalMaxPart(List parts) { |
| AbstractGraphicalEditPart rc = parts.size() > 0 ? (AbstractGraphicalEditPart) parts |
| .get(0) |
| : null; |
| for (int x = 0; x < parts.size(); x++) { |
| AbstractGraphicalEditPart p = (AbstractGraphicalEditPart) parts |
| .get(x); |
| if (p.getFigure().getBounds().bottom() > rc.getFigure().getBounds() |
| .bottom()) { |
| rc = p; |
| } |
| } |
| return rc; |
| } |
| |
| public void verticalAlignToFirstSelected(List editParts) { |
| // get the selected items |
| // List editParts = getGraphicalViewer().getSelectedEditParts(); |
| AbstractGraphicalEditPart alignToPart = null; |
| // find the first diagram part we can align to |
| for (int a = 0; a < editParts.size(); a++) { |
| if (editParts.get(a) instanceof ShapeNodeEditPart) { |
| AbstractGraphicalEditPart ep = (AbstractGraphicalEditPart) editParts |
| .get(a); |
| if (alignToPart == null) { |
| // remember it and stop |
| alignToPart = ep; |
| break; |
| } |
| } |
| } |
| // loop through the elements and set their new position |
| for (int a = 0; a < editParts.size(); a++) { |
| if (editParts.get(a) instanceof ShapeNodeEditPart) { |
| AbstractGraphicalEditPart ep = (AbstractGraphicalEditPart) editParts |
| .get(a); |
| // we can skip the first one since this is an align-to |
| if (ep != alignToPart) { |
| // calculate the offset for centerline alignment |
| Rectangle bounds = ep.getFigure().getBounds(); |
| Rectangle alignToPartBounds = alignToPart.getFigure().getBounds(); |
| Dimension ps = alignToPart.getFigure().getPreferredSize(); |
| int offset = bounds.getCenter().x - alignToPartBounds.getCenter().x; |
| // is this inside a container? |
| if (!(ep.getParent() instanceof DiagramEditPart)) { |
| // adjust the offset since we are moving the |
| // container |
| ep = (AbstractGraphicalEditPart) ep.getParent(); |
| Rectangle parentBounds = ep.getFigure().getBounds(); |
| offset += bounds.x - parentBounds.x; |
| bounds = parentBounds; |
| } |
| // send the command to move the element |
| org.eclipse.gef.commands.Command c = new ChangeBoundsCommand( |
| transactionDomain, (Node) ep.getModel(), new Point( |
| alignToPart.getFigure().getBounds().x |
| - offset, bounds.y), bounds.width, |
| -1); |
| getCommandStack().execute(c); |
| ep.getFigure().setLocation( |
| new Point(alignToPart.getFigure().getBounds().x |
| - offset, bounds.y)); |
| Point sp = alignToPart.getFigure().getBounds().getCenter(); |
| boolean connected = false; |
| // check if the part is connected via source connections |
| List list = ((ShapeNodeEditPart) alignToPart) |
| .getSourceConnections(); |
| for (Iterator itor = list.iterator(); itor.hasNext();) { |
| ConnectionNodeEditPart lp = (ConnectionNodeEditPart) itor |
| .next(); |
| if (lp.getTarget().equals(ep)) { |
| connected = true; |
| break; |
| } |
| } |
| // if not found above, check if it is connected via target connections |
| if (!connected) { |
| list = ((ShapeNodeEditPart) alignToPart) |
| .getTargetConnections(); |
| for (Iterator itor = list.iterator(); itor.hasNext();) { |
| ConnectionNodeEditPart lp = (ConnectionNodeEditPart) itor |
| .next(); |
| if (lp.getSource().equals(ep)) { |
| connected = true; |
| break; |
| } |
| } |
| } |
| Point p = new Point(); |
| p.x = ((Integer) ViewUtil.getStructuralFeatureValue( |
| (View) ep.getModel(), NotationPackage.eINSTANCE |
| .getLocation_X())).intValue(); |
| p.y = ((Integer) ViewUtil.getStructuralFeatureValue( |
| (View) ep.getModel(), NotationPackage.eINSTANCE |
| .getLocation_Y())).intValue(); |
| Point tp = p.getCopy(); |
| Point centerPoint = ep.getFigure().getBounds().getCenter(); |
| int delta = sp.x - centerPoint.x; |
| tp.x = tp.x + delta; |
| c = new ChangeBoundsCommand(transactionDomain, (Node) ep |
| .getModel(), tp, ep.getFigure().getBounds().width, |
| -1); |
| getCommandStack().execute(c); |
| ep.getFigure().setLocation(new Point(tp.x, tp.y)); |
| } |
| } |
| } |
| } |
| |
| |
| /** |
| * Return height of text of th enode |
| * |
| * @param node |
| * @return |
| */ |
| public static Dimension getTextDimension(String text) { |
| if (text != null){ |
| Font f = DiagramConstants.DEFAULT_FONT; |
| Dimension d = FigureUtilities.getTextExtents(text, f); |
| |
| if (d != null) |
| return d; |
| } |
| return null; |
| } |
| |
| private void anyObliqueLinks(ActivityDetailDiagramEditPart dep, |
| List recentlyAddedChildren) { |
| List children = dep.getChildren(); |
| for (Iterator iterator = children.iterator(); iterator.hasNext();) { |
| IGraphicalEditPart part = (IGraphicalEditPart) iterator.next(); |
| if(part instanceof RoleTaskCompositeEditPart){ |
| List grandChildren = ((RoleTaskCompositeEditPart)part).getChildren(); |
| for (Iterator iterator2 = grandChildren.iterator(); iterator2 |
| .hasNext();) { |
| ShapeNodeEditPart child = (ShapeNodeEditPart) iterator2 |
| .next(); |
| if (child instanceof TaskNodeEditPart) { |
| Point p = child.getFigure().getBounds().getCenter(); |
| List connected = child.getTargetConnections(); |
| if (!connected.isEmpty()) { |
| AbstractGraphicalEditPart linkedPart = (AbstractGraphicalEditPart) ((ConnectionNodeEditPart) connected |
| .get(0)).getSource(); |
| Point pt = linkedPart.getFigure().getBounds() |
| .getCenter(); |
| if (p.x != pt.x) { |
| if (!recentlyAddedChildren.contains(part)) { |
| recentlyAddedChildren.add(part); |
| } |
| } |
| } |
| connected = child.getSourceConnections(); |
| if (!connected.isEmpty()) { |
| AbstractGraphicalEditPart linkedPart = (AbstractGraphicalEditPart) ((ConnectionNodeEditPart)connected |
| .get(0)).getSource(); |
| Point ps = linkedPart.getFigure().getBounds() |
| .getCenter(); |
| if (p.x != ps.x) { |
| if (!recentlyAddedChildren.contains(part)) { |
| recentlyAddedChildren.add(part); |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| } |
| } |
