private String getDescr(Fig f) {
if (f == null) {
return null;
}
String className = f.getClass().getName();
StringBuffer descr = new StringBuffer(className.substring(className.lastIndexOf(".") + 1));
// descr.append(" - paints=").append(f.getPaintCount());
// descr.append(" - damages=").append(f.getDamageCount());
descr.append(
" - bounds=[" + f.getX() + "," + f.getY() + "," + f.getWidth() + "," + f.getHeight() + "]");
if (!f.isVisible()) {
descr.append(" - INVISIBLE");
}
if (f.isFilled()) {
descr.append(" - FILLED");
}
descr.append(
" - fill=["
+ f.getFillColor().getRed()
+ ","
+ f.getFillColor().getGreen()
+ ","
+ f.getFillColor().getBlue()
+ "]");
if (f.getOwner() != null) {
descr.append(" - owner=").append(f.getOwner());
}
if (f instanceof FigText) {
descr.append(" \"").append(((FigText) f).getText()).append("\"");
}
descr.append(" - lay=").append(toString(f.getLayer()));
descr.append(" - grp=").append(toString(f.getGroup()));
return descr.toString();
}
/** @see java.awt.event.ActionListener#actionPerformed(java.awt.event.ActionEvent) */
public void actionPerformed(ActionEvent ae) {
super.actionPerformed(ae);
try {
/*Here the actions to delete a region.
We assume the only figs enclosed in a concurrent composite state
are concurrent region figs*/
Fig f = (Fig) TargetManager.getInstance().getFigTarget();
Fig encloser = null;
int height = 0;
Rectangle encBound;
Project p = ProjectManager.getManager().getCurrentProject();
if (Model.getFacade().isAConcurrentRegion(f.getOwner())) encloser = f.getEnclosingFig();
Vector nodesInside;
nodesInside = ((Vector) encloser.getEnclosedFigs().clone());
int index = nodesInside.indexOf(f);
Rectangle r = f.getBounds();
encBound = encloser.getBounds();
if (Model.getFacade().isAConcurrentRegion(f.getOwner())) p.moveToTrash(f.getOwner());
// It wasnt the last region
if (index < nodesInside.size() - 1) {
Rectangle rFig = ((Fig) nodesInside.elementAt(index + 1)).getBounds();
height = rFig.y - r.y;
for (int i = ++index; i < nodesInside.size(); i++)
((FigNodeModelElement) nodesInside.elementAt(i)).displace(0, -height);
}
// It was the last region
else height = r.height + 4;
/*When only one concurrent region remains it must be erased and the
composite state sets non concurent*/
if (((Vector) encloser.getEnclosedFigs()).size() == 1) {
f = ((Fig) encloser.getEnclosedFigs().elementAt(0));
nodesInside = ((Vector) f.getEnclosedFigs());
Model.getStateMachinesHelper().setConcurrent(encloser.getOwner(), false);
if (!nodesInside.isEmpty()) {
for (int i = 0; i < nodesInside.size(); i++) {
FigStateVertex curFig = (FigStateVertex) nodesInside.elementAt(i);
curFig.setEnclosingFig(encloser);
}
}
p.moveToTrash(f.getOwner());
}
} catch (Exception ex) {
LOG.error(ex);
}
}
/** @see org.tigris.gef.presentation.Fig#setEnclosingFig(org.tigris.gef.presentation.Fig) */
public void setEnclosingFig(Fig encloser) {
if (encloser == null
|| (encloser != null && !Model.getFacade().isAInstance(encloser.getOwner()))) {
super.setEnclosingFig(encloser);
}
if (!(Model.getFacade().isAModelElement(getOwner()))) return;
if (encloser != null && (Model.getFacade().isAComponent(encloser.getOwner()))) {
Object component = /*(MComponent)*/ encloser.getOwner();
Object in = /*(MInterface)*/ getOwner();
Model.getCoreHelper().setContainer(resident, component);
Model.getCoreHelper().setResident(resident, in);
} else {
Model.getCoreHelper().setContainer(resident, null);
Model.getCoreHelper().setResident(resident, null);
}
}
public void setEnclosingFig(Fig encloser) {
if (encloser == getEncloser()) {
return;
}
if (encloser == null
|| (encloser != null && !Model.getFacade().isAInstance(encloser.getOwner()))) {
super.setEnclosingFig(encloser);
}
if (!(Model.getFacade().isAUMLElement(getOwner()))) {
return;
}
if (encloser != null && (Model.getFacade().isAComponent(encloser.getOwner()))) {
moveIntoComponent(encloser);
super.setEnclosingFig(encloser);
}
}
private void fixModel() {
Fig sourceFig = getSourceFigNode();
Fig destFig = getDestFigNode();
Object source = sourceFig.getOwner();
Object dest = destFig.getOwner();
LOG.error(
"Missing Generalization for figure in PGML -"
+ " attempting to recreate between "
+ source
+ " and "
+ dest);
if (Model.getFacade().isAGeneralizableElement(source)
&& Model.getFacade().isAGeneralizableElement(dest)) {
setOwner(Model.getCoreFactory().buildGeneralization(source, dest));
}
}
/**
* Updates the classifiers the edge is attached to.
*
* <p>Calls a helper method (layoutThisToSelf) to avoid this edge disappearing if the new source
* and dest are the same node.
*
* @return boolean whether or not the update was sucessful
*/
protected boolean updateClassifiers() {
Object owner = getOwner();
if (owner == null || getLayer() == null) {
LOG.error("The FigEdge has no owner or its layer is null");
return false;
}
Object newSource = getSource();
Object newDest = getDestination();
Fig currentSourceFig = getSourceFigNode();
Fig currentDestFig = getDestFigNode();
Object currentSource = null;
Object currentDestination = null;
if (currentSourceFig != null && currentDestFig != null) {
currentSource = currentSourceFig.getOwner();
currentDestination = currentDestFig.getOwner();
}
if (newSource != currentSource || newDest != currentDestination) {
Fig newSourceFig = getNoEdgePresentationFor(newSource);
Fig newDestFig = getNoEdgePresentationFor(newDest);
if (newSourceFig != currentSourceFig) {
setSourceFigNode((FigNode) newSourceFig);
setSourcePortFig(newSourceFig);
}
if (newDestFig != currentDestFig) {
setDestFigNode((FigNode) newDestFig);
setDestPortFig(newDestFig);
}
((FigNode) newSourceFig).updateEdges();
((FigNode) newDestFig).updateEdges();
calcBounds();
// adapted from SelectionWButtons from line 280
// calls a helper method to avoid this edge disappearing
// if the new source and dest are the same node.
if (newSourceFig == newDestFig) {
layoutThisToSelf();
}
}
return true;
}
/**
* If the selected Fig is a FigAssociation (an edge) then convert it to a FigNodeAssociation.
*
* @param fig the select end Fig
* @return the fig converted to a FigNode
*/
private FigNode convertToFigNode(Fig fig) {
if (fig instanceof FigEdgePort) {
fig = fig.getGroup();
}
if (!(fig instanceof FigAssociation)) {
return (FigNode) fig;
}
final FigAssociation figAssociation = (FigAssociation) fig;
final int x = figAssociation.getEdgePort().getX();
final int y = figAssociation.getEdgePort().getY();
final Object association = fig.getOwner();
final FigNode originalEdgePort = figAssociation.getEdgePort();
// Detach any edges (such as comment edges) already attached
// to the FigAssociation before the FigAssociation is removed.
// They'll later be re-attached to the new FigNodeAssociation
final Collection<FigEdge> existingEdges = originalEdgePort.getEdges();
for (FigEdge edge : existingEdges) {
originalEdgePort.removeFigEdge(edge);
}
figAssociation.removeFromDiagram();
// Create the new FigNodeAssociation and locate it.
final MutableGraphModel gm = (MutableGraphModel) editor.getGraphModel();
gm.addNode(association);
final LayerPerspective lay = (LayerPerspective) editor.getLayerManager().getActiveLayer();
final List associationFigs = lay.presentationsFor(association);
associationFigs.remove(figAssociation);
final FigNodeAssociation figNode = (FigNodeAssociation) associationFigs.get(0);
figNode.setLocation(x - figNode.getWidth() / 2, y - figNode.getHeight() / 2);
editor.add(figNode);
editor.getSelectionManager().deselectAll();
// Add the association ends to the graph model
final Collection<Object> associationEnds = Model.getFacade().getConnections(association);
for (Object associationEnd : associationEnds) {
gm.addEdge(associationEnd);
}
// Add the edges (such as comment edges) that were on the old
// FigAssociation to our new FigNodeAssociation and make sure they are
// positioned correctly.
for (FigEdge edge : existingEdges) {
if (edge.getDestFigNode() == originalEdgePort) {
edge.setDestFigNode(figNode);
edge.setDestPortFig(figNode);
}
if (edge.getSourceFigNode() == originalEdgePort) {
edge.setSourceFigNode(figNode);
edge.setSourcePortFig(figNode);
}
}
figNode.updateEdges();
return figNode;
}
/**
* Create an edge of the given type and connect it to the given nodes.
*
* @param graphModel the graph model in which to create the connection element
* @param edgeType the UML object type of the connection
* @param sourceFig the FigNode for the source element
* @param destFig the FigNode for the destination element
* @return The FigEdge representing the newly created model element
*/
@Override
protected FigEdge buildConnection(
MutableGraphModel graphModel, Object edgeType, Fig sourceFig, Fig destFig) {
try {
Object associationEnd =
Model.getUmlFactory()
.buildConnection(
edgeType, sourceFig.getOwner(), null, destFig.getOwner(), null, null, null);
final FigNode sourceFigNode = convertToFigNode(sourceFig);
final FigNode destFigNode = convertToFigNode(destFig);
graphModel.addEdge(associationEnd);
setNewEdge(associationEnd);
// Calling connect() will add the edge to the GraphModel and
// any LayerPersectives on that GraphModel will get a
// edgeAdded event and will add an appropriate FigEdge
// (determined by the GraphEdgeRenderer).
if (getNewEdge() != null) {
sourceFigNode.damage();
destFigNode.damage();
Layer lay = editor.getLayerManager().getActiveLayer();
FigEdge fe = (FigEdge) lay.presentationFor(getNewEdge());
_newItem.setLineColor(Color.black);
fe.setFig(_newItem);
fe.setSourcePortFig(sourceFigNode);
fe.setSourceFigNode(sourceFigNode);
fe.setDestPortFig(destFigNode);
fe.setDestFigNode(destFigNode);
return fe;
} else {
return null;
}
} catch (IllegalModelElementConnectionException e) {
// We have already confirmed the connection is valid
return null;
}
}
/**
* Add a classier to the current diagram.
*
* @param classifier The new class or interface to add to the editor.
* @param minimise minimise the class fig by hiding compartments (of attributes and operations)
*/
private void addClassifier(Object classifier, boolean minimise) {
String name = Model.getFacade().getName(classifier);
// if the classifier is not in the current diagram, add it:
if (currentGM.canAddNode(classifier)) {
FigClassifierBox newFig;
if (Model.getFacade().isAClass(classifier)) {
newFig = new FigClass(currentGM, classifier);
} else if (Model.getFacade().isAInterface(classifier)) {
newFig = new FigInterface(currentGM, classifier);
} else {
return;
}
/*
* The following calls are ORDER DEPENDENT. Not sure why, but the
* layer add must come before the model add or we'll end up with
* duplicate figures in the diagram. - tfm
*/
currentLayer.add(newFig);
currentGM.addNode(classifier);
currentLayer.putInPosition(newFig);
newFig.setOperationsVisible(!minimise);
if (Model.getFacade().isAClass(classifier)) {
((FigClass) newFig).setAttributesVisible(!minimise);
}
newFig.setSize(newFig.getMinimumSize());
} else {
// the class is in the diagram
// so we are on a second pass,
// find the fig for this class can update its visible state.
FigClassifierBox existingFig = null;
List figs = currentLayer.getContentsNoEdges();
for (int i = 0; i < figs.size(); i++) {
Fig fig = (Fig) figs.get(i);
if (classifier == fig.getOwner()) {
existingFig = (FigClassifierBox) fig;
}
}
existingFig.renderingChanged();
}
// add edges
// for a 2-pass r.e. process we might have already added the
// class but not its edges
currentGM.addNodeRelatedEdges(classifier);
}
@Override
public Object getOwner() {
if (super.getOwner() != null) {
return super.getOwner();
}
Fig group = this;
while (group != null && !(group instanceof FigEdge)) {
group = group.getGroup();
}
if (group == null) {
return null;
} else {
return group.getOwner();
}
}
/**
* A version of GEF's presentationFor() method which
*
* @param element ModelElement to return presentation for
* @return the Fig representing the presentation
*/
private Fig getNoEdgePresentationFor(Object element) {
if (element == null) {
throw new IllegalArgumentException("Can't search for a null owner");
}
List contents = getLayer().getContentsNoEdges();
int figCount = contents.size();
for (int figIndex = 0; figIndex < figCount; ++figIndex) {
Fig fig = (Fig) contents.get(figIndex);
if (fig.getOwner() == element) {
return fig;
}
}
throw new IllegalStateException(
"Can't find a FigNode representing " + Model.getFacade().getName(element));
}
/**
* If there are interfaces that are not inside a component the returned ListSet is not null. Then
* in the ListSet are the UMLDeploymentDiagram and all FigInterfaces with no enclosing
* FigComponent
*
* @param dd the diagram to check
* @return the set of offenders
*/
public ListSet computeOffenders(UMLDeploymentDiagram dd) {
Collection figs = dd.getLayer().getContents();
ListSet offs = null;
Iterator figIter = figs.iterator();
while (figIter.hasNext()) {
Object obj = figIter.next();
if (!(obj instanceof FigInterface)) continue;
FigInterface fi = (FigInterface) obj;
Fig enclosing = fi.getEnclosingFig();
if (enclosing == null || (!(Model.getFacade().isAComponent(enclosing.getOwner())))) {
if (offs == null) {
offs = new ListSet();
offs.add(dd);
}
offs.add(fi);
}
}
return offs;
}
public void setEnclosingFig(Fig encloser) {
if (encloser != null && encloser.getOwner() instanceof MNodeInstance && getOwner() != null) {
MNodeInstance node = (MNodeInstance) encloser.getOwner();
MComponentInstance comp = (MComponentInstance) getOwner();
if (comp.getNodeInstance() != node) {
comp.setNodeInstance(node);
}
super.setEnclosingFig(encloser);
Vector figures = getEnclosedFigs();
if (getLayer() != null) {
// elementOrdering(figures);
Vector contents = getLayer().getContents();
int contentsSize = contents.size();
for (int j = 0; j < contentsSize; j++) {
Object o = contents.elementAt(j);
if (o instanceof FigEdgeModelElement) {
FigEdgeModelElement figedge = (FigEdgeModelElement) o;
figedge.getLayer().bringToFront(figedge);
}
}
}
} else if (encloser == null && getEnclosingFig() != null) {
if (getEnclosingFig() instanceof FigNodeModelElement)
((FigNodeModelElement) getEnclosingFig()).getEnclosedFigs().removeElement(this);
_encloser = null;
}
/*
super.setEnclosingFig(encloser);
Vector figures = getEnclosedFigs();
if (getLayer() != null) {
// elementOrdering(figures);
Vector contents = getLayer().getContents();
int contentsSize = contents.size();
for (int j=0; j<contentsSize; j++) {
Object o = contents.elementAt(j);
if (o instanceof FigEdgeModelElement) {
FigEdgeModelElement figedge = (FigEdgeModelElement) o;
figedge.getLayer().bringToFront(figedge);
}
}
}
if (!(getOwner() instanceof MModelElement)) return;
if (getOwner() instanceof MComponentInstance) {
MComponentInstance me = (MComponentInstance) getOwner();
MNodeInstance mnode = null;
if (encloser != null && (encloser.getOwner() instanceof MNodeInstance)) {
mnode = (MNodeInstance) encloser.getOwner();
}
if (encloser != null && (encloser.getOwner() instanceof MComponentInstance)) {
MComponentInstance comp = (MComponentInstance) encloser.getOwner();
mnode = (MNodeInstance) comp.getNodeInstance();
}
try {
if(mnode != null) {
me.setNodeInstance(mnode);
}
else {
if (me.getNodeInstance() != null) {
me.setNodeInstance(null);
}
}
setNode(figures);
}
catch (Exception e) {
cat.error("could not set package", e);
}
}
*/
}
