/* $Id: UMLStateDiagram.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.state.ui;

 import java.awt.Point;

 import java.awt.Rectangle;

 import java.beans.PropertyChangeEvent;

 import java.beans.PropertyVetoException;

 import java.util.Collection;

 import java.util.HashSet;

 import javax.swing.Action;

 import org.apache.log4j.Logger;

 import org.argouml.i18n.Translator;

 import org.argouml.model.DeleteInstanceEvent;

 import org.argouml.model.Model;

 import org.argouml.ui.CmdCreateNode;

 import org.argouml.uml.diagram.DiagramElement;

 import org.argouml.uml.diagram.DiagramFactory;

 import org.argouml.uml.diagram.DiagramSettings;

 import org.argouml.uml.diagram.UMLMutableGraphSupport;

 import org.argouml.uml.diagram.activity.ui.FigActionState;

 import org.argouml.uml.diagram.state.StateDiagramGraphModel;

 import org.argouml.uml.diagram.static_structure.ui.FigComment;

 import org.argouml.uml.diagram.ui.ActionSetMode;

 import org.argouml.uml.diagram.ui.FigNodeModelElement;

 import org.argouml.uml.diagram.ui.RadioAction;

 import org.argouml.uml.diagram.ui.UMLDiagram;

 import org.argouml.uml.ui.behavior.common_behavior.ActionNewActionSequence;

 import org.argouml.uml.ui.behavior.common_behavior.ActionNewCallAction;

 import org.argouml.uml.ui.behavior.common_behavior.ActionNewCreateAction;

 import org.argouml.uml.ui.behavior.common_behavior.ActionNewDestroyAction;

 import org.argouml.uml.ui.behavior.common_behavior.ActionNewReturnAction;

 import org.argouml.uml.ui.behavior.common_behavior.ActionNewSendAction;

 import org.argouml.uml.ui.behavior.common_behavior.ActionNewTerminateAction;

 import org.argouml.uml.ui.behavior.common_behavior.ActionNewUninterpretedAction;

 import org.argouml.uml.ui.behavior.state_machines.ButtonActionNewGuard;

 import org.argouml.util.ToolBarUtility;

 import org.tigris.gef.base.LayerPerspective;

 import org.tigris.gef.base.LayerPerspectiveMutable;

 import org.tigris.gef.base.ModeCreatePolyEdge;

 import org.tigris.gef.presentation.FigNode;

 /**

  * The UML Statechart diagram. <p>

  * 

  * The correct name for this class would be 

  * "UMLStatechartDiagram". See issue 2306.

  */

 public class UMLStateDiagram extends UMLDiagram {

     private static final long serialVersionUID = -1541136327444703151L;

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

     /**

      * this diagram needs to be deleted when its statemachine is deleted.

      */

     private Object theStateMachine;

     ////////////////

     // actions for toolbar

     private Action actionStubState;

     private Action actionState;

     private Action actionSynchState;

     private Action actionSubmachineState;

     private Action actionCompositeState;

     private Action actionStartPseudoState;

     private Action actionFinalPseudoState;

     private Action actionBranchPseudoState;

     private Action actionForkPseudoState;

     private Action actionJoinPseudoState;

     private Action actionShallowHistoryPseudoState;

     private Action actionDeepHistoryPseudoState;

     private Action actionCallEvent;

     private Action actionChangeEvent;

     private Action actionSignalEvent;

     private Action actionTimeEvent;

     private Action actionGuard;

     private Action actionCallAction;

     private Action actionCreateAction;

     private Action actionDestroyAction;

     private Action actionReturnAction;

     private Action actionSendAction;

     private Action actionTerminateAction;

     private Action actionUninterpretedAction;

     private Action actionActionSequence;

     private Action actionTransition;

     private Action actionJunctionPseudoState;

     /**

      * Constructor used by PGML parser to create a new diagram.  Use of

      * this constructor by other callers is deprecated.

      * 

      * @deprecated for 0.27.3 by tfmorris.  Use 

      * {@link #UMLStateDiagram(String, Object)}

      */

     @Deprecated

     public UMLStateDiagram() {

         super(new StateDiagramGraphModel());

         try {

             setName(getNewDiagramName());

         } catch (PropertyVetoException pve) {

             // nothing we can do about veto, so just ignore it

         }

     }

     /**

      * Constructor.

      * 

      * @param name the name of the diagram

      * @param machine the StateMachine for the new diagram

      */

     public UMLStateDiagram(String name, Object machine) {

         super(name, machine, new StateDiagramGraphModel());

         if (!Model.getFacade().isAStateMachine(machine)) {

             throw new IllegalStateException(

                 "No StateMachine given to create a Statechart diagram");

         }

         namespace = getNamespaceFromMachine(machine);

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

             throw new IllegalArgumentException();

         }

         nameDiagram(namespace);

         setup(namespace, machine);

     }

     /**

      * Constructor.

      * 

      * @param ns the NameSpace for the new diagram

      * @param machine the StateMachine for the new diagram

      * @deprecated for 0.27.3 by tfmorris. Use

      *             {@link #UMLStateDiagram(String, Object)}/

      */

     @Deprecated

     public UMLStateDiagram(Object ns, Object machine) {

         this();

         if (!Model.getFacade().isAStateMachine(machine)) {

             throw new IllegalStateException(

                 "No StateMachine given to create a Statechart diagram");

         }

         if (ns == null) {

             ns = getNamespaceFromMachine(machine);

         }

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

             throw new IllegalArgumentException();

         }

         nameDiagram(ns);

         setup(ns, machine);

     }

     /**

      * Name the diagram based on the name of its namespace and the number of

      * behaviors that it contains.

      * @param ns containing namespace

      */

     private void nameDiagram(Object ns) {

         String nname = Model.getFacade().getName(ns);

         if (nname != null && nname.trim().length() != 0) {

             int number = (Model.getFacade().getBehaviors(ns)) == null ? 0

                     : Model.getFacade().getBehaviors(ns).size();

             String name = nname + " " + (number++);

             LOG.info("UMLStateDiagram constructor: String name = " + name);

             try {

                 setName(name);

             } catch (PropertyVetoException pve) {

                 // nothing we can do about veto, so just ignore it

             }

         }

     }

     /**

      * From a given StateMachine, find the Namespace. 

      * Guaranteed to give a non-null result.

      * 

      * @param machine the given StateMachine. 

      *          If not a StateMachine: throws exception

      * @return the best possible namespace to be deducted

      */

     private Object getNamespaceFromMachine(Object machine) {

         if (!Model.getFacade().isAStateMachine(machine)) {

             throw new IllegalStateException(

                 "No StateMachine given to create a Statechart diagram");

         }

         Object ns = Model.getFacade().getNamespace(machine);

         if (ns != null) {

             return ns;

         }

         Object context = Model.getFacade().getContext(machine);

         if (Model.getFacade().isAClassifier(context)) {

             ns = context;

         } else if (Model.getFacade().isABehavioralFeature(context)) {

             ns = Model.getFacade().getNamespace( // or just the owner?

                     Model.getFacade().getOwner(context));

         }

         if (ns == null) {

             ns = getProject().getRoots().iterator().next();

         }

         if (ns == null || !Model.getFacade().isANamespace(ns)) {

             throw new IllegalStateException(

                     "Can not deduce a Namespace from a StateMachine");

         }

         return ns;

     }

     /**

      * Get the owner of a statechart diagram.

      * @return the statemachine which owns the diagram

      * @see org.argouml.uml.diagram.ui.UMLDiagram#getOwner()

      */

     @Override

     public Object getOwner() {

         if (!(getGraphModel() instanceof StateDiagramGraphModel)) {

             throw new IllegalStateException(

                     "Incorrect graph model of "

                     + getGraphModel().getClass().getName());

         }

         StateDiagramGraphModel gm = (StateDiagramGraphModel) getGraphModel();

         return gm.getMachine();

     }

     /**

      * Called by the PGML parser to initialize the statechart

      * diagram. First the parser creates a statechart diagram via the

      * default constructor. Then this method is called.

      *

      * @param o the statemachine

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

      */

     @Override

     public void initialize(Object o) {

         if (Model.getFacade().isAStateMachine(o)) {

             Object machine = o;

             Object contextNamespace = getNamespaceFromMachine(machine);

             setup(contextNamespace, machine);

         } else {

             throw new IllegalStateException(

                 "Cannot find namespace "

                     + "while initializing "

                     + "statechart diagram");

         }

     }

     /**

      * Method to perform a number of important initializations of a

      * StateDiagram.<p>

      *

      * Each diagram type has a similar <I>UMLxxxDiagram</I> class.<p>

      *

      * Changed <I>lay</I> from <I>LayerPerspective</I> to

      * <I>LayerPerspectiveMutable</I>.  This class is a child of

      * <I>LayerPerspective</I> and was implemented to correct some

      * difficulties in changing the model. <I>lay</I> is used mainly

      * in <I>LayerManager</I>(GEF) to control the adding, changing and

      * deleting layers on the diagram...

      *

      * @param namespace Class from the UML model...connects the class to

      * the Statechart diagram.

      * @param machine StateMachine from the UML model

      * @author psager@tigris.org Jan. 24, 2oo2

      */

     public void setup(Object namespace, Object machine) {

         setNamespace(namespace);

         theStateMachine = machine;

         StateDiagramGraphModel gm = createGraphModel();

         gm.setHomeModel(namespace);

         if (theStateMachine != null) {

             gm.setMachine(theStateMachine);

         }

         StateDiagramRenderer rend = new StateDiagramRenderer(); // singleton

         LayerPerspective lay = new LayerPerspectiveMutable(

                 Model.getFacade().getName(namespace), gm);

         lay.setGraphNodeRenderer(rend);

         lay.setGraphEdgeRenderer(rend);

         setLayer(lay);

         /* Listen to machine deletion, 

          * to delete the diagram. */

         Model.getPump().addModelEventListener(this, theStateMachine, 

                 new String[] {"remove", "namespace"});

     }

     // TODO: Needs to be tidied up after stable release. Graph model

     // should be created in constructor

     private StateDiagramGraphModel createGraphModel() {

         if ((getGraphModel() instanceof StateDiagramGraphModel)) {

             return (StateDiagramGraphModel) getGraphModel();

         } else {

             return new StateDiagramGraphModel();

         }

     }

     /*

      * @see org.argouml.uml.diagram.ui.UMLDiagram#propertyChange(java.beans.PropertyChangeEvent)

      */

     @Override

     public void propertyChange(PropertyChangeEvent evt) {

         if ((evt.getSource() == theStateMachine)

                 && (evt instanceof DeleteInstanceEvent)

                 && "remove".equals(evt.getPropertyName())) {

             Model.getPump().removeModelEventListener(this, 

                     theStateMachine, new String[] {"remove", "namespace"});

             if (getProject() != null) {

                 getProject().moveToTrash(this);

             } else {

                 DiagramFactory.getInstance().removeDiagram(this);

             }

         }

         if (evt.getSource() == theStateMachine 

                 && "namespace".equals(evt.getPropertyName())) {

             Object newNamespace = evt.getNewValue();

             if (newNamespace != null // this in case we are being deleted 

                     && getNamespace() != newNamespace) {

                 /* The namespace of the statemachine is changed! */

                 setNamespace(newNamespace);

                 ((UMLMutableGraphSupport) getGraphModel())

                                 .setHomeModel(newNamespace);

             }

         }

     }

     /**

      * @return the StateMachine belonging to this diagram

      */

     public Object getStateMachine() {

         return ((StateDiagramGraphModel) getGraphModel()).getMachine();

     }

     /**

      * @param sm Set the StateMachine for this diagram.

      */

     public void setStateMachine(Object sm) {

         if (!Model.getFacade().isAStateMachine(sm)) {

             throw new IllegalArgumentException("This is not a StateMachine");

         }

         ((StateDiagramGraphModel) getGraphModel()).setMachine(sm);

     }

     /**

      * Get the actions from which to create a toolbar or equivalent

      * graphic triggers.

      * @return the array of actions

      * @see org.argouml.uml.diagram.ui.UMLDiagram#getUmlActions()

      */

     protected Object[] getUmlActions() {

         if (Model.getFacade().getUmlVersion().charAt(0) == '1') {

             Object[] actions =

             {

                 getActionState(),

                 getActionCompositeState(),

                 getActionTransition(),

                 getActionSynchState(),

                 getActionSubmachineState(),

                 getActionStubState(),

                 null,

                 getActionStartPseudoState(),

                 getActionFinalPseudoState(),

                 getActionJunctionPseudoState(),

                 getActionChoicePseudoState(),

                 getActionForkPseudoState(),

                 getActionJoinPseudoState(),

                 getActionShallowHistoryPseudoState(),

                 getActionDeepHistoryPseudoState(),

                 null,

                 getTriggerActions(),

                 getActionGuard(),

                 getEffectActions(),

             };

             return actions;

         } else {

             Object[] actions =

             {

                 getActionState(),

                 getActionTransition(),

                 null,

                 getActionStartPseudoState(),

                 getActionFinalPseudoState(),

                 getActionJunctionPseudoState(),

                 getActionChoicePseudoState(),

                 getActionForkPseudoState(),

                 getActionJoinPseudoState(),

                 getActionShallowHistoryPseudoState(),

                 getActionDeepHistoryPseudoState(),

                 null,

                 getTriggerActions(),

                 getActionGuard(),

                 getEffectActions(),

             };

             return actions;

         }

     }

     protected Object[] getTriggerActions() {

         Object[] actions = {

             getActionCallEvent(),

             getActionChangeEvent(),

             getActionSignalEvent(),

             getActionTimeEvent(),

         };

         ToolBarUtility.manageDefault(actions, "diagram.state.trigger");

         return actions;

     }

     protected Object[] getEffectActions() {

         Object[] actions = {

             getActionCallAction(),

             getActionCreateAction(),

             getActionDestroyAction(),

             getActionReturnAction(),

             getActionSendAction(),

             getActionTerminateAction(),

             getActionUninterpretedAction(),

             getActionActionSequence(),

         };

         ToolBarUtility.manageDefault(actions, "diagram.state.effect");

         return actions;

     }

     /*

      * @see org.argouml.uml.diagram.ui.UMLDiagram#getLabelName()

      */

     public String getLabelName() {

         return Translator.localize("label.state-chart-diagram");

     }

     /**

      * @return Returns the actionChoicePseudoState.

      */

     protected Action getActionChoicePseudoState() {

         if (actionBranchPseudoState == null) {

             actionBranchPseudoState = new RadioAction(

                     new ActionCreatePseudostate(Model.getPseudostateKind()

                             .getChoice(), "button.new-choice"));

         }

         return actionBranchPseudoState;

     }

     /**

      * @return Returns the actionCompositeState.

      */

     protected Action getActionCompositeState() {

         if (actionCompositeState == null) {

             actionCompositeState =

                 new RadioAction(new CmdCreateNode(

                         Model.getMetaTypes().getCompositeState(),

                         "button.new-compositestate"));

         }

         return actionCompositeState;

     }

     /**

      * @return Returns the actionDeepHistoryPseudoState.

      */

     protected Action getActionDeepHistoryPseudoState() {

         if (actionDeepHistoryPseudoState == null) {

             actionDeepHistoryPseudoState = new RadioAction(

                     new ActionCreatePseudostate(

                         Model.getPseudostateKind().getDeepHistory(),

                         "button.new-deephistory"));

         }

         return actionDeepHistoryPseudoState;

     }

     /**

      * @return Returns the actionFinalPseudoState.

      */

     protected Action getActionFinalPseudoState() {

         if (actionFinalPseudoState == null) {

             actionFinalPseudoState =

                 new RadioAction(

                         new CmdCreateNode(

                                 Model.getMetaTypes().getFinalState(),

                                 "button.new-finalstate"));

         }

         return actionFinalPseudoState;

     }

     /**

      * @return Returns the actionForkPseudoState.

      */

     protected Action getActionForkPseudoState() {

         if (actionForkPseudoState == null) {

             actionForkPseudoState = new RadioAction(

                     new ActionCreatePseudostate(

                             Model.getPseudostateKind()

                             .getFork(), "button.new-fork"));

         }

         return actionForkPseudoState;

     }

     /**

      * @return Returns the actionJoinPseudoState.

      */

     protected Action getActionJoinPseudoState() {

         if (actionJoinPseudoState == null) {

             actionJoinPseudoState = new RadioAction(new ActionCreatePseudostate(

                     Model.getPseudostateKind().getJoin(), "button.new-join"));

         }

         return actionJoinPseudoState;

     }

     /**

      * @return Returns the actionJunctionPseudoState.

      */

     protected Action getActionJunctionPseudoState() {

         if (actionJunctionPseudoState == null) {

             actionJunctionPseudoState = new RadioAction(

                     new ActionCreatePseudostate(

                         Model.getPseudostateKind().getJunction(),

                         "button.new-junction"));

         }

         return actionJunctionPseudoState;

     }

     /**

      * @return Returns the actionShallowHistoryPseudoState.

      */

     protected Action getActionShallowHistoryPseudoState() {

         if (actionShallowHistoryPseudoState == null) {

             actionShallowHistoryPseudoState = new RadioAction(

                     new ActionCreatePseudostate(

                         Model.getPseudostateKind().getShallowHistory(),

                         "button.new-shallowhistory"));

         }

         return actionShallowHistoryPseudoState;

     }

     /**

      * @return Returns the actionStartPseudoState.

      */

     protected Action getActionStartPseudoState() {

         if (actionStartPseudoState == null) {

             actionStartPseudoState = new RadioAction(

                     new ActionCreatePseudostate(

                         Model.getPseudostateKind().getInitial(),

                         "button.new-initial"));

         }

         return actionStartPseudoState;

     }

     /**

      * @return Returns the actionState.

      */

     protected Action getActionState() {

         if (actionState == null) {

             if (Model.getFacade().getUmlVersion().charAt(0) == '1') {

                 actionState =

                     new RadioAction(

                             new CmdCreateNode(Model.getMetaTypes().getSimpleState(),

                                               "button.new-simplestate"));

             } else {

                 actionState =

                     new RadioAction(

                             new CmdCreateNode(Model.getMetaTypes().getState(),

                                               "button.new-simplestate"));

             }

         }

         return actionState;

     }

     /**

      * @return Returns the actionSynchState.

      */

     protected Action getActionSynchState() {

         if (actionSynchState == null) {

             actionSynchState =

                 new RadioAction(

                         new CmdCreateNode(

                                 Model.getMetaTypes().getSynchState(),

                                 "button.new-synchstate"));

         }

         return actionSynchState;

     }

     /**

      * @return Returns the actionSubmachineState.

      */

     protected Action getActionSubmachineState() {

         if (actionSubmachineState == null) {

             actionSubmachineState =

                     new RadioAction(

                             new CmdCreateNode(

                                     Model.getMetaTypes().getSubmachineState(),

                                     "button.new-submachinestate"));

         }

         return actionSubmachineState;

     }

     /**

      * @return Returns the actionSubmachineState.

      */

     protected Action getActionStubState() {

         if (actionStubState == null) {

             actionStubState =

                     new RadioAction(

                             new CmdCreateNode(

                                     Model.getMetaTypes().getStubState(),

                                     "button.new-stubstate"));

         }

         return actionStubState;

     }

     /**

      * @return Returns the actionTransition.

      */

     protected Action getActionTransition() {

         if (actionTransition == null) {

             actionTransition = new RadioAction(

                     new ActionSetMode(

                         ModeCreatePolyEdge.class,

                         "edgeClass",

                         Model.getMetaTypes().getTransition(),

                         "button.new-transition"));

         }

         return actionTransition;

     }

     /**

      * @return Returns the actionCallEvent.

      */

     protected Action getActionCallEvent() {

         if (actionCallEvent == null) {

             actionCallEvent = new ButtonActionNewCallEvent();

         }

         return actionCallEvent;

     }

     /**

      * @return Returns the actionCallEvent.

      */

     protected Action getActionChangeEvent() {

         if (actionChangeEvent == null) {

             actionChangeEvent = new ButtonActionNewChangeEvent();

         }

         return actionChangeEvent;

     }

     /**

      * @return Returns the actionCallEvent.

      */

     protected Action getActionSignalEvent() {

         if (actionSignalEvent == null) {

             actionSignalEvent = new ButtonActionNewSignalEvent();

         }

         return actionSignalEvent;

     }

     /**

      * @return Returns the actionCallEvent.

      */

     protected Action getActionTimeEvent() {

         if (actionTimeEvent == null) {

             actionTimeEvent = new ButtonActionNewTimeEvent();

         }

         return actionTimeEvent;

     }

     protected Action getActionGuard() {

         if (actionGuard == null) {

             actionGuard = new ButtonActionNewGuard();

         }

         return actionGuard;

     }

     protected Action getActionCallAction() {

         if (actionCallAction == null) {

             actionCallAction = ActionNewCallAction.getButtonInstance();

         }

         return actionCallAction;

     }

     protected Action getActionCreateAction() {

         if (actionCreateAction == null) {

             actionCreateAction = ActionNewCreateAction.getButtonInstance();

         }

         return actionCreateAction;

     }

     protected Action getActionDestroyAction() {

         if (actionDestroyAction == null) {

             actionDestroyAction = ActionNewDestroyAction.getButtonInstance();

         }

         return actionDestroyAction;

     }

     protected Action getActionReturnAction() {

         if (actionReturnAction == null) {

             actionReturnAction = ActionNewReturnAction.getButtonInstance();

         }

         return actionReturnAction;

     }

     protected Action getActionSendAction() {

         if (actionSendAction == null) {

             actionSendAction = ActionNewSendAction.getButtonInstance();

         }

         return actionSendAction;

     }

     protected Action getActionTerminateAction() {

         if (actionTerminateAction == null) {

             actionTerminateAction = 

                 ActionNewTerminateAction.getButtonInstance();

         }

         return actionTerminateAction;

     }

     protected Action getActionUninterpretedAction() {

         if (actionUninterpretedAction == null) {

             actionUninterpretedAction = 

                 ActionNewUninterpretedAction.getButtonInstance();

         }

         return actionUninterpretedAction;

     }

     protected Action getActionActionSequence() {

         if (actionActionSequence == null) {

             actionActionSequence = 

                 ActionNewActionSequence.getButtonInstance();

         }

         return actionActionSequence;

     }

     /*

      * @see org.argouml.uml.diagram.ui.UMLDiagram#getDependentElement()

      */

     @Override

     public Object getDependentElement() {

         return getStateMachine();

     }

     /*

      * @see org.argouml.uml.diagram.ui.UMLDiagram#isRelocationAllowed(java.lang.Object)

      */

     public boolean isRelocationAllowed(Object base)  {

             return false;

             /* TODO: We may return the following when the

              * relocate() has been implemented. */

 //            Model.getStateMachinesHelper()

 //                .isAddingStatemachineAllowed(base);

     }

     @SuppressWarnings("unchecked")

     public Collection getRelocationCandidates(Object root) {

         /* TODO: We may return something useful when the

          * relocate() has been implemented, like 

          * all StateMachines that are not ActivityGraphs. */

         Collection c =  new HashSet();

         c.add(getOwner());

         return c;

     }

     /*

      * @see org.argouml.uml.diagram.ui.UMLDiagram#relocate(java.lang.Object)

      */

     public boolean relocate(Object base) {

         return false;

     }

     public void encloserChanged(FigNode enclosed, 

             FigNode oldEncloser, FigNode newEncloser) {

         // Do nothing.        

     }

     @Override

     public boolean doesAccept(Object objectToAccept) {

         if (Model.getFacade().isAState(objectToAccept)) {

             return true;

         } else if (Model.getFacade().isASynchState(objectToAccept)) {

             return true;

         } else if (Model.getFacade().isAStubState(objectToAccept)) {

             return true;

         } else if (Model.getFacade().isAPseudostate(objectToAccept)) {

             return true;

         } else if (Model.getFacade().isAComment(objectToAccept)) {

             return true;

         } 

         return false;

     }

     @Override

     public DiagramElement drop(Object droppedObject, Point location) {

         FigNodeModelElement figNode = null;

         // 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);

         }

         DiagramSettings settings = getDiagramSettings();

         if (Model.getFacade().isAActionState(droppedObject)) {

             figNode = new FigActionState(droppedObject, bounds, settings);

         } else if (Model.getFacade().isAFinalState(droppedObject)) {

             figNode = new FigFinalState(droppedObject, bounds, settings);

         } else if (Model.getFacade().isAStubState(droppedObject)) {

             figNode = new FigStubState(droppedObject, bounds, settings);

         } else if (Model.getFacade().isASubmachineState(droppedObject)) {

             figNode = new FigSubmachineState(droppedObject, bounds, settings);

         } else if (Model.getFacade().isACompositeState(droppedObject)) {

             figNode = new FigCompositeState(droppedObject, bounds, settings);

         } else if (Model.getFacade().isASynchState(droppedObject)) {

             figNode = new FigSynchState(droppedObject, bounds, settings);

         } else if (Model.getFacade().isAState(droppedObject)) {

             figNode = new FigSimpleState(droppedObject, bounds, settings);

         } else if (Model.getFacade().isAComment(droppedObject)) {

             figNode = new FigComment(droppedObject, bounds, settings);

         } else if (Model.getFacade().isAPseudostate(droppedObject)) {

             Object kind = Model.getFacade().getKind(droppedObject);

             if (kind == null) {

                 LOG.warn("found a null type pseudostate");

                 return null;

             }

             if (kind.equals(Model.getPseudostateKind().getInitial())) {

                 figNode = new FigInitialState(droppedObject, bounds, settings);

             } else if (kind.equals(

                     Model.getPseudostateKind().getChoice())) {

                 figNode = new FigBranchState(droppedObject, bounds, settings);

             } else if (kind.equals(

                     Model.getPseudostateKind().getJunction())) {

                 figNode = new FigJunctionState(droppedObject, bounds, settings);

             } else if (kind.equals(

                     Model.getPseudostateKind().getFork())) {

                 figNode = new FigForkState(droppedObject, bounds, settings);

             } else if (kind.equals(

                     Model.getPseudostateKind().getJoin())) {

                 figNode = new FigJoinState(droppedObject, bounds, settings);

             } else if (kind.equals(

                     Model.getPseudostateKind().getShallowHistory())) {

                 figNode = new FigShallowHistoryState(droppedObject, bounds, 

                         settings);

             } else if (kind.equals(

                     Model.getPseudostateKind().getDeepHistory())) {

                 figNode = new FigDeepHistoryState(droppedObject, bounds, 

                         settings);

             } else {

                 LOG.warn("found a type not known");

             }

         }

         if (figNode != null) {

             // if location is null here the position of the new figNode is set

             // after in org.tigris.gef.base.ModePlace.mousePressed(MouseEvent e)

             if (location != null) {

                 figNode.setLocation(location.x, location.y);

             }

             LOG.debug("Dropped object " + droppedObject + " converted to " 

                     + figNode);

         } else {

             LOG.debug("Dropped object NOT added " + figNode);

         }

         return figNode;

     }

     public DiagramElement createDiagramElement(

             final Object modelElement,

             final Rectangle bounds) {

         FigNodeModelElement figNode = null;

         DiagramSettings settings = getDiagramSettings();

         if (Model.getFacade().isAActionState(modelElement)) {

             figNode = new FigActionState(modelElement, bounds, settings);

         } else if (Model.getFacade().isAFinalState(modelElement)) {

             figNode = new FigFinalState(modelElement, bounds, settings);

         } else if (Model.getFacade().isAStubState(modelElement)) {

             figNode = new FigStubState(modelElement, bounds, settings);

         } else if (Model.getFacade().isASubmachineState(modelElement)) {

             figNode = new FigSubmachineState(modelElement, bounds, settings);

         } else if (Model.getFacade().isACompositeState(modelElement)) {

             figNode = new FigCompositeState(modelElement, bounds, settings);

         } else if (Model.getFacade().isASynchState(modelElement)) {

             figNode = new FigSynchState(modelElement, bounds, settings);

         } else if (Model.getFacade().isAState(modelElement)) {

             figNode = new FigSimpleState(modelElement, bounds, settings);

         } else if (Model.getFacade().isAComment(modelElement)) {

             figNode = new FigComment(modelElement, bounds, settings);

         } else if (Model.getFacade().isAPseudostate(modelElement)) {

             Object kind = Model.getFacade().getKind(modelElement);

             if (kind == null) {

                 LOG.warn("found a null type pseudostate");

                 return null;

             }

             if (kind.equals(Model.getPseudostateKind().getInitial())) {

                 figNode = new FigInitialState(modelElement, bounds, settings);

             } else if (kind.equals(

                     Model.getPseudostateKind().getChoice())) {

                 figNode = new FigBranchState(modelElement, bounds, settings);

             } else if (kind.equals(

                     Model.getPseudostateKind().getJunction())) {

                 figNode = new FigJunctionState(modelElement, bounds, settings);

             } else if (kind.equals(

                     Model.getPseudostateKind().getFork())) {

                 figNode = new FigForkState(modelElement, bounds, settings);

             } else if (kind.equals(

                     Model.getPseudostateKind().getJoin())) {

                 figNode = new FigJoinState(modelElement, bounds, settings);

             } else if (kind.equals(

                     Model.getPseudostateKind().getShallowHistory())) {

                 figNode = new FigShallowHistoryState(modelElement, bounds, 

                         settings);

             } else if (kind.equals(

                     Model.getPseudostateKind().getDeepHistory())) {

                 figNode = new FigDeepHistoryState(modelElement, bounds, 

                         settings);

             } else {

                 LOG.warn("found a type not known");

             }

         }

         if (figNode != null) {

             LOG.debug("Model element " + modelElement + " converted to " 

                     + figNode);

         } else {

             LOG.debug("Dropped object NOT added " + figNode);

         }

         return figNode;

     }

 }