/* $Id: UMLDiagram.java 18729 2010-09-10 16:10:34Z bobtarling $

  *****************************************************************************

  * Copyright (c) 2009-2010 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:

  *    Bob Tarling

  *****************************************************************************

  *

  * Some portions of this file was previously release using the BSD License:

  */

 // Copyright (c) 1996-2008 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.diagram.ui;

 import java.awt.Component;

 import java.awt.Point;

 import java.awt.Rectangle;

 import java.beans.PropertyVetoException;

 import javax.swing.Action;

 import javax.swing.ButtonModel;

 import javax.swing.JToolBar;

 import org.apache.log4j.Logger;

 import org.argouml.gefext.ArgoModeCreateFigCircle;

 import org.argouml.gefext.ArgoModeCreateFigInk;

 import org.argouml.gefext.ArgoModeCreateFigLine;

 import org.argouml.gefext.ArgoModeCreateFigPoly;

 import org.argouml.gefext.ArgoModeCreateFigRRect;

 import org.argouml.gefext.ArgoModeCreateFigRect;

 import org.argouml.gefext.ArgoModeCreateFigSpline;

 import org.argouml.i18n.Translator;

 import org.argouml.kernel.Project;

 import org.argouml.model.Model;

 import org.argouml.ui.CmdCreateNode;

 import org.argouml.uml.UUIDHelper;

 import org.argouml.uml.diagram.ArgoDiagramImpl;

 import org.argouml.uml.diagram.DiagramElement;

 import org.argouml.uml.diagram.DiagramSettings;

 import org.argouml.uml.diagram.Relocatable;

 import org.argouml.uml.diagram.UMLMutableGraphSupport;

 import org.argouml.util.ToolBarUtility;

 import org.tigris.gef.base.LayerPerspective;

 import org.tigris.gef.base.ModeBroom;

 import org.tigris.gef.base.ModeCreatePolyEdge;

 import org.tigris.gef.base.ModePlace;

 import org.tigris.gef.base.ModeSelect;

 import org.tigris.gef.graph.GraphFactory;

 import org.tigris.gef.graph.GraphModel;

 import org.tigris.gef.presentation.FigNode;

 import org.tigris.toolbar.ToolBarFactory;

 import org.tigris.toolbar.ToolBarManager;

 import org.tigris.toolbar.toolbutton.ToolButton;

 /**

  * This class provides support for writing a UML diagram for argo using

  * the GEF framework. <p>

  *

  * It adds common buttons, and some help

  * with creating a valid diagram name. <p>

  *

  * There are various methods for returning 'structures' of Actions

  * which are used to build toolbars and dropdown buttons within toolbars.

  * These structures are arrays of Objects.

  * An array element is actually either an Action, null or another array.

  * When building a toolbar an Action is used to create a button and null

  * is used to create a spacer in the toolbar.

  * An element containing an array results in a dropdown toolbar button

  * being created which contains all the items in that array. <p>

  *

  * The "owner" of the UMLDiagram needs to be set to the

  * UML modelelement of which the diagram depends.

  * For a class diagram is that its namespace.

  * For a collaboration diagram is that the Collaboration UML object.

  * For a sequence diagram is that the collaboration.

  * For a deployment diagram is that the namespace.

  * For a statechart diagram is that the statemachine.

  * For a activitydiagram is that the activitygraph.

  * Override the getOwner method to return the owner. <p>

  *

  * The "owner" is shown in the diagram's properties

  * panel as the "home model". <p>

  */

 public abstract class UMLDiagram

     extends ArgoDiagramImpl

     implements Relocatable {

     private static final Logger LOG = Logger.getLogger(UMLDiagram.class);

     /**

      * Tool to add a comment node.

      */

     private static Action actionComment =

         new RadioAction(new ActionAddNote());

     /**

      * Tool to create an relationship between a comment node and some other node

      * using a polyedge.<p>

      */

     private static Action actionCommentLink =

         new RadioAction(new ActionSetAddCommentLinkMode());

     private static Action actionSelect =

         new ActionSetMode(ModeSelect.class, "button.select");

     private static Action actionBroom =

         new ActionSetMode(ModeBroom.class, "button.broom");

     private static Action actionRectangle =

         new RadioAction(new ActionSetMode(ArgoModeCreateFigRect.class, 

                 "Rectangle", "misc.primitive.rectangle"));

     private static Action actionRRectangle =

         new RadioAction(new ActionSetMode(ArgoModeCreateFigRRect.class, 

                 "RRect", "misc.primitive.rounded-rectangle"));

     private static Action actionCircle =

         new RadioAction(new ActionSetMode(ArgoModeCreateFigCircle.class, 

                 "Circle", "misc.primitive.circle"));

     private static Action actionLine =

         new RadioAction(new ActionSetMode(ArgoModeCreateFigLine.class, 

                 "Line", "misc.primitive.line"));

     private static Action actionText =

         new RadioAction(new ActionSetMode(ArgoModeCreateFigText.class, 

                 "Text", "misc.primitive.text"));

     private static Action actionPoly =

         new RadioAction(new ActionSetMode(ArgoModeCreateFigPoly.class, 

                 "Polygon", "misc.primitive.polygon"));

     private static Action actionSpline =

         new RadioAction(new ActionSetMode(ArgoModeCreateFigSpline.class, 

                 "Spline", "misc.primitive.spline"));

     private static Action actionInk =

         new RadioAction(new ActionSetMode(ArgoModeCreateFigInk.class, 

                 "Ink", "misc.primitive.ink"));

     private JToolBar toolBar;

     private Action selectedAction;

     /**

      * Default constructor will become protected. All subclasses should have

      * their constructors invoke the 3-arg version of the constructor.

      * 

      * @deprecated for 0.27.2 by tfmorris. Use

      *             {@link #UMLDiagram(String, Object, GraphModel)} or another

      *             explicit constructor.

      */

     @SuppressWarnings("deprecation")

     @Deprecated

     public UMLDiagram() {

         super();

     }

     /**

      * @param ns the UML namespace of this diagram

      * @deprecated for 0.27.2 by tfmorris. Use

      *             {@link #UMLDiagram(String, Object, GraphModel)}.

      */

     @Deprecated

     public UMLDiagram(Object ns) {

         this();

         if (!Model.getFacade().isANamespace(ns)) {

             throw new IllegalArgumentException();

         }

         // TODO: Should we require a GraphModel in the constructor since 

         // our implementations of setNamespace are going to try and set

         // the namespace on the graphmodel as well?

         setNamespace(ns);

     }

     /**

      * @param name the name of the diagram

      * @param ns the UML namespace of this diagram

      * @deprecated for 0.27.2 by tfmorris. Use

      *             {@link #UMLDiagram(String, Object, GraphModel)}.

      */

     @Deprecated

     public UMLDiagram(String name, Object ns) {

         this(ns);

         try {

             setName(name);

         } catch (PropertyVetoException pve) {

             LOG.fatal("Name not allowed in construction of diagram");

         }

     }

     /**

      * Construct a new ArgoUML diagram.  This is the fully specified form

      * of the constructor typically used by subclasses.

      * 

      * @param name the name of the new diagram

      * @param graphModel graph model to associate with diagram

      * @param ns the namespace which will "own" the diagram

      */

     public UMLDiagram(String name, Object ns, GraphModel graphModel) {

         super(name, graphModel, new LayerPerspective(name, graphModel));

         setNamespace(ns);

     }

     /**

      * Construct an unnamed diagram using the given GraphModel.

      * 

      * @param graphModel graph model to associate with diagram

      */

     public UMLDiagram(GraphModel graphModel) {    

         super("", graphModel, new LayerPerspective("", graphModel));

     }

     /**

      * Method called by PGML parser during diagram load to initialize a diagram

      * after it's been constructed. Order of method invocations currently is:

      * <ul>

      * <li>0-arg constructor

      * <li>setDiagramSettings

      * <li>initialize(Object) // UML element representing owner/home model

      * <li>setName(String)

      * <li>setScale(double)

      * <li>setShowSingleMultiplicity(boolean)

      * <ul>

      * 

      * @param owner UML model element representing owner/namespace/home model

      * @see org.tigris.gef.base.Diagram#initialize(java.lang.Object)

      */

     @Override

     public void initialize(Object owner) {

         super.initialize(owner);

         /* The following is the default implementation

          * for diagrams of which the owner is a namespace.

          */

         if (Model.getFacade().isANamespace(owner)) {

             setNamespace(owner);

         }

     }

     /*

      * @see org.tigris.gef.base.Diagram#getClassAndModelID()

      */

     public String getClassAndModelID() {

         String s = super.getClassAndModelID();

         if (getOwner() == null) {

             return s;

         }

         String id = UUIDHelper.getUUID(getOwner());

         return s + "|" + id;

     }

     /**

      * Get the toolbar for the diagram.

      * @return the diagram toolbar

      */

     public JToolBar getJToolBar() {

         if (toolBar == null) {

             initToolBar();

             toolBar.setName("misc.toolbar.diagram");

         }

         return toolBar;

     }

     /**

      * Create the toolbar based on actions for the specific diagram

      * subclass.

      * @see org.tigris.gef.base.Diagram#initToolBar()

      */

     public void initToolBar() {

         ToolBarFactory factory = new ToolBarFactory(getActions());

         factory.setRollover(true);

         factory.setFloatable(false);

         toolBar = factory.createToolBar();

         toolBar.putClientProperty("ToolBar.toolTipSelectTool", 

                 Translator.localize("action.select"));

     }

     /**

      * Return actions available for building toolbar or similar.

      * @return an array of available actions.

      */

     public Object[] getActions() {

         Object[] manipulateActions = getManipulateActions();

         Object[] umlActions = getUmlActions();

         Object[] commentActions = getCommentActions();

         Object[] shapeActions = getShapeActions();

         Object[] actions =

             new Object[manipulateActions.length

                 + umlActions.length

                 + commentActions.length

                 + shapeActions.length];

         int posn = 0;

         System.arraycopy(

             manipulateActions,           // source

             0,                           // source position

             actions,                     // destination

             posn,                        // destination position

             manipulateActions.length);   // number of objects to be copied

         posn += manipulateActions.length;

         System.arraycopy(umlActions, 0, actions, posn, umlActions.length);

         posn += umlActions.length;

         System.arraycopy(commentActions, 0, actions, posn,

                 commentActions.length);

         posn += commentActions.length;

         System.arraycopy(shapeActions, 0, actions, posn, shapeActions.length);

         return actions;

     }

     /**

      * Implement in the ancestor to get a 'structure' of actions for

      * appending the UML creation tools to the toolbar.

      * @return the actions structure

      */

     protected abstract Object[] getUmlActions();

     /**

      * Get a 'structure' of actions for appending the manipulation

      * mode tools to the toolbar.

      * @return the actions structure

      */

     private Object[] getManipulateActions() {

         Object[] actions =

         {

             new RadioAction(actionSelect),

             new RadioAction(actionBroom),

             null,

         };

         return actions;

     }

     /**

      * Get a 'structure' of actions for appending the comment

      * tools to the toolbar.

      * @return the actions structure

      */

     private Object[] getCommentActions() {

         Object[] actions =

         {

             null,

             actionComment,

             actionCommentLink,

         };

         return actions;

     }

     /**

      * Get a 'structure' of actions for appending primitive drawing

      * tools to the toolbar.

      * @return the actions structure

      */

     private Object[] getShapeActions() {

         Object[] actions = {

             null,

             getShapePopupActions(),

         };

         return actions;

     }

     /**

      * Get a 'structure' of actions for showing in the shape

      * primitives popup tool button.

      * @return the actions structure

      */

     private Object[] getShapePopupActions() {

         Object[][] actions = {

             {actionRectangle, actionRRectangle },

             {actionCircle,    actionLine },

             {actionText,      actionPoly },

             {actionSpline,    actionInk },

         };

         ToolBarUtility.manageDefault(actions, "diagram.shape");

         return actions;

     }

     /**

      * Set the given action as the selected action (ie pressed down on the

      * diagram toolbar). All other actions become unselected.

      *

      * @param theAction the action to become selected

      */

     public void setSelectedAction(Action theAction) {

         selectedAction = theAction;

         int toolCount = toolBar.getComponentCount();

         for (int i = 0; i < toolCount; ++i) {

             Component c = toolBar.getComponent(i);

             if (c instanceof ToolButton) {

                 ToolButton tb = (ToolButton) c;

                 Action action = tb.getRealAction();

                 if (action instanceof RadioAction) {

                     action = ((RadioAction) action).getAction();

                 }

                 Action otherAction = theAction;

                 if (theAction instanceof RadioAction) {

                     otherAction = ((RadioAction) theAction).getAction();

                 }

                 if (action != null && !action.equals(otherAction)) {

                     tb.setSelected(false);

                     ButtonModel bm = tb.getModel();

                     bm.setRollover(false);

                     bm.setSelected(false);

                     bm.setArmed(false);

                     bm.setPressed(false);

                     if (!ToolBarManager.alwaysUseStandardRollover()) {

                         tb.setBorderPainted(false);

                     }

                 } else {

                     tb.setSelected(true);

                     ButtonModel bm = tb.getModel();

                     bm.setRollover(true);

                     if (!ToolBarManager.alwaysUseStandardRollover()) {

                         tb.setBorderPainted(true);

                     }

                 }

             }

         }

     }

     /**

      * Get the selected action.

      * 

      * @return the selected action

      */

     public Action getSelectedAction() {

         return selectedAction;

     }

     /**

      * Unselect all the toolbar buttons.

      */

     public void deselectAllTools() {

         setSelectedAction(actionSelect);

         actionSelect.actionPerformed(null);

     }

     /**

      * Factory method to build an Action for creating a node in the

      * diagram.

      *

      * @param modelElement identifies the model element type to make

      * @param descr the description to give this action.

      * @return The action to create a new node.

      */

     protected Action makeCreateNodeAction(Object modelElement, String descr) {

         return new RadioAction(new CmdCreateNode(modelElement, descr));

     }

     /**

      * Factory method to build an Action for creating an edge in the

      * diagram.

      *

      * @param modelElement identifies the model element type to make

      * @param descr the description to give this action.

      * @return The action to create a new node.

      */

     protected Action makeCreateEdgeAction(Object modelElement, String descr) {

         return new RadioAction(

             new ActionSetMode(ModeCreatePolyEdge.class, "edgeClass",

                     modelElement, descr));

     }

     /**

      * Factory method to build an Action for creating an edge in the

      * diagram.

      *

      * @param modeClass the mode class to instantiate drawing

      * @param metaType identifies the model element type to make

      * @param descr the description to give this action.

      * @return The action to create a new node.

      */

     protected Action makeCreateDependencyAction(

             Class modeClass, 

             Object metaType, 

             String descr) {

         return new RadioAction(

             new ActionSetMode(modeClass, "edgeClass", metaType, descr));

     }

     /**

      * Factory method to build an Action for creating an edge in the

      * diagram.

      * @return The action to create a new generalization mode.

      */

     protected Action makeCreateGeneralizationAction() {

         return new RadioAction(

             new ActionSetMode(

                     ModeCreateGeneralization.class, 

                     "edgeClass", 

                     Model.getMetaTypes().getGeneralization(), 

                     "button.new-generalization"));

     }

     /**

      * Factory method to build an Action for creating an association edge in

      * the diagram.

      *

      * @param aggregationKind the type of aggregation for this association

      * @param unidirectional true if this is a one way association.

      * @param descr the description to give this action.

      * @return The action to create a new association.

      */

     protected Action makeCreateAssociationAction(

             Object aggregationKind,

             boolean unidirectional,

             String descr) {

         return new RadioAction(

             new ActionSetAddAssociationMode(aggregationKind,

                 unidirectional, descr));

     }

     /**

      * Factory method to build an Action for creating an association end edge

      * in the diagram.

      *

      * @param descr the description to give this action.

      * @return The action to create a new association.

      */

     protected Action makeCreateAssociationEndAction(String descr) {

         return new RadioAction(new ActionSetAddAssociationEndMode(descr));

     }

     /**

      * Factory method to build an Action for creating an edge in the

      * diagram.

      *

      * @param descr the description to give this action.

      * @return The action to create a new node.

      */

     protected Action makeCreateAssociationClassAction(String descr) {

         return new RadioAction(new ActionSetAddAssociationClassMode(descr));

     }

     /**

      * Reset the diagram serial counter to the initial value. This should e.g.

      * be done when the menuitem File->New is activated.

      * 

      * @deprecated for 0.27.3 by tfmorris. This is a noop. Diagram name

      *             duplication is checked for and managed at the project level.

      */

     @Deprecated

     public void resetDiagramSerial() {

     }

     /**

      * @return Returns the diagramSerial.

      * @deprecated for 0.27.3 by tfmorris. This is always returns 1. Diagram

      *             naming is managed at the project level.

      */

     @Deprecated

     protected int getNextDiagramSerial() {

         return 1;

     }

     /**

      * @return a string that can be used as a label for this kind of diagram

      */

     public abstract String getLabelName();

     /*

      * @see org.argouml.ui.explorer.Relocatable#isRelocationAllowed(java.lang.Object)

      */

     public abstract boolean isRelocationAllowed(Object base);

     /*

      * @see org.argouml.ui.explorer.Relocatable#relocate(java.lang.Object)

      */

     public abstract boolean relocate(Object base);

     @Override

     public final void setProject(Project p) {

         super.setProject(p);

         UMLMutableGraphSupport gm = (UMLMutableGraphSupport) getGraphModel();

         gm.setProject(p);

     }

     /**

      * Create a new diagram name.

      * @return String

      */

     protected String getNewDiagramName() {

         // TODO: Add "unnamed" or "new" or something? (Localized, of course)

         return /*"unnamed " + */ getLabelName();

     }

     /**

      * Method to test it the diagram can accept a certain object.

      * This should be overridden by any diagram that wants to accept a certain

      * type of object. All other diagrams should not bother since the default

      * answer is false, ie. don't accept the object.

      * @param objectToAccept The object which acceptability will be checked.

      * @return True if it can accept it, false otherwise.

      */

     public boolean doesAccept(

             @SuppressWarnings("unused") Object objectToAccept) {

         return false;

     }

     /**

      * Handles elements dropped over.

      * @param droppedObject The dropped object.

      * @param location The location in the diagram where the object is dropped.

      * @return The object that has been added to the diagram.

      */

     public DiagramElement drop(Object droppedObject, Point location) {

         // If location is non-null, convert to a rectangle that we can use

         Rectangle bounds = null;

         if (location != null) {

             bounds = new Rectangle(location.x, location.y, 0, 0);

         }

         return createDiagramElement(droppedObject, bounds);

     }

     /**

      * Gets the instructions to be displayed on the status bar.

      * @param droppedObject The object for which instructions will be given.

      * @return The instructions.

      */

     public String getInstructions(Object droppedObject) {

         return Translator.localize("misc.message.click-on-diagram-to-add", 

                 new Object[] {Model.getFacade().toString(droppedObject), });

     }

     /**

      * Creates a diagram specific @see org.tigris.gef.base.ModePlace that 

      * allows the diagram to place an accepted type of object 

      * [ @see #doesAccept(Object) ] as it should. This is required 1. since a 

      * diagram may receive an object that can't be placed as is, but needs some

      * transformation and 2. diagrams in modules should be independent from the

      * main app, and should use their own implementation of ModePlace if it's

      * required.

      * @param gf TODO

      * @param instructions a help string for the user

      * @return The created ModePlace.

      */

     public ModePlace getModePlace(GraphFactory gf, String instructions) {

         return new ModePlace(gf, instructions);

     }

     /**

      * Create a nary association diamond shaped FigNode on this diagram.

      *  

      * @param modelElement the model element this FigNode is to represent

      * @param bounds the position and size for the diamond node.

      * @param settings the diagram setting for presentation.

      * @return The FigNode of the diamond representing the model element

      */

     protected FigNodeModelElement createNaryAssociationNode(

             final Object modelElement,

             final Rectangle bounds,

             final DiagramSettings settings) {

         final FigNodeAssociation diamondFig =

             new FigNodeAssociation(modelElement, bounds, settings);

         if (Model.getFacade().isAAssociationClass(modelElement)

                 && bounds != null) {

             final FigClassAssociationClass classBoxFig =

                 new FigClassAssociationClass(

                         modelElement, bounds, settings);

             final FigEdgeAssociationClass dashEdgeFig =

                 new FigEdgeAssociationClass(

                         classBoxFig, diamondFig, settings);

             classBoxFig.renderingChanged();

             // TODO: Why isn't this calculation for location working?

             Point location = bounds.getLocation();

             location.y = (location.y - diamondFig.getHeight()) - 32;

             if (location.y < 16) {

                 location.y = 16;

             }

             classBoxFig.setLocation(location);

             this.add(diamondFig);

             this.add(classBoxFig);

             this.add(dashEdgeFig);

         }

         return diamondFig;

     }

 }