//------------------------------------------------------------------------------
// 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.authoring.gef.edit;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import org.eclipse.draw2d.PositionConstants;
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.epf.authoring.gef.commands.ChangeBoundsCommand;
import org.eclipse.epf.diagram.model.Node;
import org.eclipse.gef.DefaultEditDomain;
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.jface.action.IAction;
import org.eclipse.jface.viewers.StructuredSelection;
/**
* Service class to allow updating diagram to a default layout. Most of the code
* are moved from the Editor class.
*
* @author Jinhua Xi
* @since 1.0
*/
public class DiagramUpdateService {
private DefaultEditDomain editDomain;
private GraphicalViewer graphicalViewer;
private ActionRegistry actionRegistry;
public DiagramUpdateService(
GraphicalViewer graphicalViewer, DefaultEditDomain editDomain,
ActionRegistry actionRegistry) {
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 (!children.isEmpty()) {
Comparator comparator = new Comparator() {
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);
}
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.clearRecentlyAddedParts();
getGraphicalViewer().setSelection(new StructuredSelection());
}
}
}
/*
private void resetSizes(AbstractGraphicalEditPart ep, AbstractGraphicalEditPart parent) {
if (!(ep instanceof WorkProductCompositeEditPart)) {
List sourceLinks = ep.getSourceConnections();
if (sourceLinks.size() > 0) {
for (int b = 0; b < sourceLinks.size(); b++) {
LinkEditPart link = (LinkEditPart) sourceLinks.get(b);
AbstractGraphicalEditPart target = (AbstractGraphicalEditPart) link
.getTarget();
int w = target.getFigure().getBounds().width;
int ew = ep.getFigure().getPreferredSize().width;
if (w > ew) {
Point location = ep.getFigure().getBounds()
.getLocation();
location.x+=(w-ew)/2;
Command c = new ChangeBoundsCommand(((Node) ep
.getModel()), ep.getFigure().getBounds()
.getLocation(), w);
getCommandStack().execute(c);
int h = ep.getFigure().getPreferredSize().height;
ep.getFigure()
.setPreferredSize(new Dimension(w, h));
ep.getFigure().setSize(new Dimension(w, h));
}
getGraphicalViewer()
.setSelection(
new StructuredSelection(new Object[] { ep,
target }));
IAction valign = getActionRegistry().getAction(
DiagramActionService.ALIGN_VERT_FIRST_SELECTED);
valign.run();
}
}
List targetLinks = ep.getTargetConnections();
if (targetLinks.size() > 0) {
for (int b = 0; b < targetLinks.size(); b++) {
LinkEditPart link = (LinkEditPart) 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(((Node) ep
.getModel()), ep.getFigure().getBounds()
.getLocation(), w);
getCommandStack().execute(c);
int h = ep.getFigure().getPreferredSize().height;
ep.getFigure()
.setPreferredSize(new Dimension(w, h));
ep.getFigure().setSize(new Dimension(w, h));
}
getGraphicalViewer()
.setSelection(
new StructuredSelection(new Object[] { ep,
source }));
IAction valign = getActionRegistry().getAction(
DiagramActionService.ALIGN_VERT_FIRST_SELECTED);
valign.run();
}
}
parent.getFigure().getLayoutManager().layout(parent.getFigure());
if (ep instanceof NodeContainerEditPart) {
List children = ep.getChildren();
for (int d = 0; d < children.size(); d++) {
AbstractGraphicalEditPart p = (AbstractGraphicalEditPart) children
.get(d);
resetSizes(p, ep);
}
}
}
}
*/
/**
* 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++) {
LinkEditPart link = (LinkEditPart) 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(((Node) ep
.getModel()), target.getFigure().getBounds()
.getLocation(), w);
getCommandStack().execute(c);
int h = target.getFigure().getPreferredSize().height;
target.getFigure()
.setPreferredSize(new Dimension(w, h));
target.getFigure().setSize(new Dimension(w, h));
}
getGraphicalViewer()
.setSelection(
new StructuredSelection(new Object[] { ep,
target }));
IAction valign = getActionRegistry().getAction(
DiagramActionService.ALIGN_VERT_FIRST_SELECTED);
valign.run();
}
}
List targetLinks = ep.getTargetConnections();
if (targetLinks.size() > 0) {
for (int b = 0; b < targetLinks.size(); b++) {
LinkEditPart link = (LinkEditPart) 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(((Node) ep
.getModel()), source.getFigure().getBounds()
.getLocation(), w);
getCommandStack().execute(c);
int h = source.getFigure().getPreferredSize().height;
source.getFigure()
.setPreferredSize(new Dimension(w, h));
source.getFigure().setSize(new Dimension(w, h));
}
getGraphicalViewer()
.setSelection(
new StructuredSelection(new Object[] { ep,
source }));
IAction valign = getActionRegistry().getAction(
DiagramActionService.ALIGN_VERT_FIRST_SELECTED);
valign.run();
}
}
if (ep instanceof NodeContainerEditPart) {
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) ((LinkEditPart) part
.getTargetConnections().get(0)).getSource();
position = PositionConstants.NORTH;
} else if (part.getSourceConnections().size() > 0) {
linkedPart = (AbstractGraphicalEditPart) ((LinkEditPart) 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((Node) part.getModel(), np,
partBounds.width);
getCommandStack().execute(c);
}
}
return moved;
}
/**
* Method to adjust the size of editpart.
*
*/
private void adjustSize(AbstractGraphicalEditPart ep) {
if (ep instanceof WorkProductCompositeEditPart) {
adjustSize((NodeContainerEditPart) ep, 1);
}
// Below Code generic NodeContainerEditPart modification.
else if (ep instanceof NodeContainerEditPart) {
// This is to allow user customizable
// String count = AuthoringUIPlugin.getDefault().getPreferenceStore()
// .getString(TemplateConstants.ADD_ROLE_TASKS_COUNT);
// if(count != null || count != ""){
// int i = Integer.parseInt(count);
// if(i > 0){
// adjustSize((NodeContainerEditPart) ep, i);
// }
// }else{
// adjustSize((NodeContainerEditPart) ep, 50);
// }
adjustSize((NodeContainerEditPart) 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(NodeContainerEditPart ep, int horizCount) {
int requiredWidth = 0;
int rowMaxHeight = 0;
int rows = 0;
int widthSum = 0;
int heightSum = 0;
int column = 0;
//int originalWidth = ep.getFigure().getSize().width;
List children = ep.getChildren();
for (int p = 0; p < children.size();) {
if (column == 0) {
rows++;
}
if (column < horizCount) {
AbstractGraphicalEditPart child = (AbstractGraphicalEditPart) children
.get(p);
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;
}
}
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(((Node) ep.getModel()), ep
.getFigure().getBounds().getLocation(), requiredWidth);
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) {
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));
((Node) ep.getModel()).setHeight(requiredHeight - delta);
ep.getFigure().setSize(
new Dimension(requiredWidth, requiredHeight - delta));
}
}
protected void enumerateConnectedParts(AbstractGraphicalEditPart part,
List 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) ((LinkEditPart) part
.getTargetConnections().get(x)).getSource();
enumerateConnectedParts(linkedPart, connected);
}
for (int x = 0; x < part.getSourceConnections().size(); x++) {
linkedPart = (AbstractGraphicalEditPart) ((LinkEditPart) 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 stragglers = new ArrayList();
// these are groups of elements connected with links
List groups = new ArrayList();
// 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 connected = new ArrayList();
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((Node) p
.getModel(), new Point(bounds.x + horizontalDelta,
bounds.y + verticalDelta), bounds.width);
getCommandStack().execute(cbc);
p.getFigure().setLocation(
new Point(bounds.x + horizontalDelta, bounds.y
+ verticalDelta));
}
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((Node) p
.getModel(), new Point(next, limit), bounds.width);
getCommandStack().execute(cbc);
p.getFigure().setLocation(new Point(next, limit));
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;
}
}