/* $Id: DiagramInterface.java 17870 2010-01-12 20:49:32Z linus $
*****************************************************************************
* Copyright (c) 2009 Contributors - see below
* 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:
* mvw
*****************************************************************************
*
* Some portions of this file was previously release using the BSD License:
*/
// Copyright (c) 1996-2009 The Regents of the University of California. All
// Rights Reserved. Permission to use, copy, modify, and distribute this
// software and its documentation without fee, and without a written
// agreement is hereby granted, provided that the above copyright notice
// and this paragraph appear in all copies. This software program and
// documentation are copyrighted by The Regents of the University of
// California. The software program and documentation are supplied "AS
// IS", without any accompanying services from The Regents. The Regents
// does not warrant that the operation of the program will be
// uninterrupted or error-free. The end-user understands that the program
// was developed for research purposes and is advised not to rely
// exclusively on the program for any reason. IN NO EVENT SHALL THE
// UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,
// SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS,
// ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
// THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF
// SUCH DAMAGE. THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY
// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE
// PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF
// CALIFORNIA HAS NO OBLIGATIONS TO PROVIDE MAINTENANCE, SUPPORT,
// UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
package org.argouml.uml.reveng;
import java.awt.Rectangle;
import java.beans.PropertyVetoException;
import java.util.ArrayList;
import java.util.List;
import org.apache.log4j.Logger;
import org.argouml.kernel.Project;
import org.argouml.model.Model;
import org.argouml.uml.diagram.ArgoDiagram;
import org.argouml.uml.diagram.DiagramElement;
import org.argouml.uml.diagram.DiagramFactory;
import org.argouml.uml.diagram.static_structure.ClassDiagramGraphModel;
import org.argouml.uml.diagram.static_structure.ui.FigClassifierBox;
import org.argouml.uml.diagram.ui.FigNodeModelElement;
import org.tigris.gef.base.Editor;
import org.tigris.gef.base.LayerPerspective;
import org.tigris.gef.presentation.Fig;
/**
* Instances of this class interface the current Class diagram.<p>
*
* This class is used by the import mechanism to create packages,
* interfaces and classes within the diagrams.
* It is also used to find the correct diagram to work in.
*
* @author Andreas Rueckert
* @since 0.9
*/
public class DiagramInterface {
private static final char DIAGRAM_NAME_SEPARATOR = '_';
private static final String DIAGRAM_NAME_SUFFIX = "classes";
private static final Logger LOG =
Logger.getLogger(DiagramInterface.class);
private Editor currentEditor;
/**
* To know what diagrams we have to layout after the import,
* we store them in this list.
*/
private List<ArgoDiagram> modifiedDiagrams =
new ArrayList<ArgoDiagram>();
/**
* The current GraphModel of the current classdiagram.
*/
private ClassDiagramGraphModel currentGM;
/**
* The current Layer of the current classdiagram.
*/
private LayerPerspective currentLayer;
/**
* The current diagram for the isInDiagram method.
*/
private ArgoDiagram currentDiagram;
private Project currentProject;
/**
* Creates a new DiagramInterface.
*
* @param editor The editor to operate on.
*/
public DiagramInterface(Editor editor) {
currentEditor = editor;
LayerPerspective layer =
(LayerPerspective) editor.getLayerManager().getActiveLayer();
currentProject = ((ArgoDiagram) layer.getDiagram()).getProject();
}
/**
* Creates a new DiagramInterface.
*
* @param editor The editor to operate on.
* @param project the project being operated on
*/
public DiagramInterface(Editor editor, Project project) {
currentEditor = editor;
}
/**
* Get the current editor.
*
* @return The current editor.
*/
Editor getEditor() {
return currentEditor;
}
/**
* Mark a diagram as modified, so we can layout it, after the
* import is complete.<p>
*
* If the diagram is not already marked, add it to the list.<p>
*
* @param diagram The diagram to mark as modified.
*/
void markDiagramAsModified(ArgoDiagram diagram) {
if (!modifiedDiagrams.contains(diagram)) {
modifiedDiagrams.add(diagram);
}
}
/**
* Get the list of modified diagrams.
*
* @return The list of modified diagrams.
*/
public List<ArgoDiagram> getModifiedDiagramList() {
return modifiedDiagrams;
}
/**
* Reset the list of modified diagrams.
*/
void resetModifiedDiagrams() {
modifiedDiagrams = new ArrayList<ArgoDiagram>();
}
/**
* Add a package to the current diagram. If the package already has
* a representation in the current diagram, it is not(!) added.
*
* @param newPackage The package to add.
*/
public void addPackage(Object newPackage) {
if (!isInDiagram(newPackage)) {
if (currentGM.canAddNode(newPackage)) {
DiagramElement newPackageFig =
currentDiagram.createDiagramElement(
newPackage,
new Rectangle(0, 0, 0, 0));
currentLayer.add((FigNodeModelElement) newPackageFig);
currentGM.addNode(newPackage);
currentLayer.putInPosition((FigNodeModelElement) newPackageFig);
}
}
}
/**
* Check if a given package has a representation in the current
* diagram.
*
* @param p The package to lookup in the current diagram.
* @return true if this package has a figure in the current diagram,
* false otherwise.
*/
public boolean isInDiagram(Object p) {
if (currentDiagram == null) {
return false;
} else {
return currentDiagram.getNodes().contains(p);
}
}
/**
* Check if this diagram already exists in the project.<p>
*
* @param name package name (converted to class name)
* @return true if diagram exists in project.
*/
public boolean isDiagramInProject(String name) {
if (currentProject == null) {
throw new RuntimeException("current project not set yet");
}
return currentProject.getDiagram(getDiagramName(name)) != null;
}
/**
* Create a diagram name from a package name.
*
* @param packageName The package name.
* @return The name for the diagram.
*/
private String getDiagramName(String packageName) {
/*
* TODO: This transformation is Java specific. We need a more
* language/notation scheme for specifying qualified names.
* Possible algorithm - replace all punctuation with our
* internal separator, replace multiple separators with a single
* instance (for languages like C++). What about I18N? - tfm
*/
return packageName.replace('.', DIAGRAM_NAME_SEPARATOR)
+ DIAGRAM_NAME_SEPARATOR + DIAGRAM_NAME_SUFFIX;
}
/**
* Select a class diagram as the current diagram, creating it
* if necessary.
*
* @param p The package.
* @param name The fully qualified name of this package.
*/
public void selectClassDiagram(Object p, String name) {
// Check if this diagram already exists in the project
if (currentProject == null) {
throw new RuntimeException("current project not set yet");
}
ArgoDiagram m = currentProject.getDiagram(getDiagramName(name));
if (m != null) {
// The diagram already exists in this project. Select it
// as the current target.
setCurrentDiagram(m);
} else {
// Otherwise create a new classdiagram for the package.
addClassDiagram(p, name);
}
}
/**
* Add a new class diagram for a package to the project.
*
* @param ns
* The namespace to contain the diagram. If null, the root model
* will be used.
* @param name
* The fully qualified name of the package, which is used to
* generate the diagram name from.
*/
public void addClassDiagram(Object ns, String name) {
if (currentProject == null) {
throw new RuntimeException("current project not set yet");
}
ArgoDiagram d = DiagramFactory.getInstance().createDiagram(
DiagramFactory.DiagramType.Class,
ns == null ? currentProject.getRoot() : ns, null);
try {
d.setName(getDiagramName(name));
} catch (PropertyVetoException pve) {
LOG.error("Failed to set diagram name.", pve);
}
currentProject.addMember(d);
setCurrentDiagram(d);
}
/**
* Add a class to the current diagram.
*
* @param newClass The new class to add to the editor.
* @param minimise minimise the class fig by hiding compartiments
* (of attributes and operations)
*/
public void addClass(Object newClass, boolean minimise) {
addClassifier(newClass, minimise);
}
/**
* 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) {
// if the classifier is not in the current diagram, add it:
if (currentGM.canAddNode(classifier)) {
FigClassifierBox newFig =
(FigClassifierBox) currentDiagram.createDiagramElement(
classifier,
new Rectangle(0, 0, 0, 0));
/*
* 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)) {
newFig.setAttributesVisible(!minimise);
}
newFig.renderingChanged();
} 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);
}
/**
* Add a interface to the current diagram.
*
* @param newInterface The interface to add.
* @param minimise minimise the class fig by hiding compartiments
* (of attributes and operations)
*/
public void addInterface(Object newInterface, boolean minimise) {
addClassifier(newInterface, minimise);
}
/**
* Creates class diagram under the root.
* Is used for classes out of packages.
*
*/
public void createRootClassDiagram() {
selectClassDiagram(null, "");
}
/**
* selects a diagram without affecting the gui.
*
* @param diagram the diagram
*/
public void setCurrentDiagram(ArgoDiagram diagram) {
if (diagram == null) {
throw new RuntimeException("you can't select a null diagram");
}
currentGM = (ClassDiagramGraphModel) diagram.getGraphModel();
currentLayer = diagram.getLayer();
currentDiagram = diagram;
currentProject = diagram.getProject();
markDiagramAsModified(diagram);
}
}