/* $Id: FigNodeModelElement.java 18859 2010-11-29 21:37:03Z mvw $

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

  * 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:

  *    Thomas Neustupny

  *    Bob Tarling

  *    Michiel van der Wulp

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

  *

  * 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.diagram.ui;

 import java.awt.Dimension;

 import java.awt.Font;

 import java.awt.Graphics;

 import java.awt.Image;

 import java.awt.Rectangle;

 import java.awt.event.InputEvent;

 import java.awt.event.KeyEvent;

 import java.awt.event.KeyListener;

 import java.awt.event.MouseEvent;

 import java.awt.event.MouseListener;

 import java.beans.PropertyChangeEvent;

 import java.beans.PropertyChangeListener;

 import java.beans.PropertyVetoException;

 import java.beans.VetoableChangeListener;

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.HashSet;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Set;

 import java.util.Vector;

 import javax.swing.Action;

 import javax.swing.Icon;

 import javax.swing.JMenu;

 import javax.swing.JSeparator;

 import javax.swing.SwingUtilities;

 import org.apache.log4j.Logger;

 import org.argouml.application.events.ArgoDiagramAppearanceEvent;

 import org.argouml.application.events.ArgoDiagramAppearanceEventListener;

 import org.argouml.application.events.ArgoEventPump;

 import org.argouml.application.events.ArgoEventTypes;

 import org.argouml.application.events.ArgoHelpEvent;

 import org.argouml.application.events.ArgoNotationEvent;

 import org.argouml.application.events.ArgoNotationEventListener;

 import org.argouml.cognitive.Designer;

 import org.argouml.cognitive.Highlightable;

 import org.argouml.cognitive.ToDoItem;

 import org.argouml.cognitive.ToDoList;

 import org.argouml.cognitive.ui.ActionGoToCritique;

 import org.argouml.i18n.Translator;

 import org.argouml.kernel.DelayedChangeNotify;

 import org.argouml.kernel.DelayedVChangeListener;

 import org.argouml.kernel.Owned;

 import org.argouml.kernel.Project;

 import org.argouml.model.AssociationChangeEvent;

 import org.argouml.model.AttributeChangeEvent;

 import org.argouml.model.DeleteInstanceEvent;

 import org.argouml.model.DiElement;

 import org.argouml.model.InvalidElementException;

 import org.argouml.model.Model;

 import org.argouml.model.UmlChangeEvent;

 import org.argouml.notation.Notation;

 import org.argouml.notation.NotationName;

 import org.argouml.notation.NotationProvider;

 import org.argouml.notation.NotationProviderFactory2;

 import org.argouml.notation.NotationRenderer;

 import org.argouml.notation.NotationSettings;

 import org.argouml.profile.FigNodeStrategy;

 import org.argouml.ui.ArgoJMenu;

 import org.argouml.ui.Clarifier;

 import org.argouml.ui.ContextActionFactoryManager;

 import org.argouml.ui.ProjectActions;

 import org.argouml.ui.UndoableAction;

 import org.argouml.ui.targetmanager.TargetManager;

 import org.argouml.uml.StereotypeUtility;

 import org.argouml.uml.diagram.ArgoDiagram;

 import org.argouml.uml.diagram.DiagramAppearance;

 import org.argouml.uml.diagram.DiagramElement;

 import org.argouml.uml.diagram.DiagramSettings;

 import org.argouml.uml.diagram.DiagramSettings.StereotypeStyle;

 import org.argouml.uml.diagram.PathContainer;

 import org.argouml.uml.ui.ActionDeleteModelElements;

 import org.argouml.util.IItemUID;

 import org.argouml.util.ItemUID;

 import org.tigris.gef.base.Diagram;

 import org.tigris.gef.base.Globals;

 import org.tigris.gef.base.Layer;

 import org.tigris.gef.base.LayerPerspective;

 import org.tigris.gef.base.Selection;

 import org.tigris.gef.graph.MutableGraphSupport;

 import org.tigris.gef.presentation.Fig;

 import org.tigris.gef.presentation.FigGroup;

 import org.tigris.gef.presentation.FigImage;

 import org.tigris.gef.presentation.FigNode;

 import org.tigris.gef.presentation.FigRect;

 import org.tigris.gef.presentation.FigText;

 /**

  * Abstract class to display diagram icons for UML ModelElements that

  * look like nodes and that have editable names and can be

  * resized.

  * <p>

  * NOTE: This will drop the ArgoNotationEventListener and 

  * ArgoDiagramAppearanceEventListener interfaces in the next release.  

  * The corresponding methods have been marked as deprecated.

  *

  * @author abonner

  */

 public abstract class FigNodeModelElement

     extends FigNode

     implements

         VetoableChangeListener,

         DelayedVChangeListener,

         MouseListener,

         KeyListener,

         PropertyChangeListener,

         PathContainer,

         ArgoDiagramAppearanceEventListener,

         ArgoNotationEventListener,

         NotationRenderer,

         Highlightable,

         IItemUID,

         Clarifiable,

         ArgoFig,

         StereotypeStyled,

         DiagramElement,

         Owned {

     private static final Logger LOG =

         Logger.getLogger(FigNodeModelElement.class);

     // TODO: There are lots and LOTS of magic numbers used in calculating 

     // positions and sizes.  Any time you see Figs being placed at 10,10 use

     // these constants instead.  If you can reliably interpret calculations,

     // you can factor them out of there as well.  Add additional constants

     // as needed to express other common factors - tfm 20081201

     /**

      * Default width for a node fig. 

      * Used to be 60 (up to V0.20), later (from V0.22) it was 90.

      * Now 64 to align to grid better.

      */

     protected static final int WIDTH = 64;

     /**

      * The default minimum height of the name fig, computed to allow room for

      * the Critics "clarifiers" (red squiggly line) with the default font. This

      * should really go away and be managed internally to the name figs and

      * fetched through getMinimumSize(). The final height can change based on

      * the font selected.

      */

     protected static final int NAME_FIG_HEIGHT = 21;

     /**

      * Padding to be used above and below the name.

      */

     protected static final int NAME_V_PADDING = 2;

     private DiElement diElement;

     private NotationProvider notationProviderName;

     /**

      * True if an instance is allowed to be

      * invisible. This is currently only set true by FigEdgePort.

      * TODO: FigEdgePort should be removed from the FigNodeModelElement

      * hierarchy and so the need for this removed.

      */

     protected boolean invisibleAllowed = false;

     /**

      * Needed for loading. Warning: if false, a too small size might look bad!

      */

     private boolean checkSize = true;

     /**

      * Offset from the end of the set of popup actions at which new items

      * should be inserted by concrete figures.

      * @See {@link #getPopUpActions(MouseEvent)}

      */

     private static int popupAddOffset;

     /**

      * Used for #buildModifierPopUp().

      */

     protected static final int ROOT = 1;

     /**

      * Used for #buildModifierPopUp().

      */

     protected static final int ABSTRACT = 2;

     /**

      * Used for #buildModifierPopUp().

      */

     protected static final int LEAF = 4;

     /**

      * Used for #buildModifierPopUp().

      */

     protected static final int ACTIVE = 8;

     private Fig bigPort;

     /**

      * use getNameFig() and setNameFig() to access the Figs.

      * Use getName() and setName() to just change the text.

      */

     private FigText nameFig;

     /**

      * use getter/setter

      * getStereotypeFig() and setStereoTypeFig() to access the Figs.

      * Use getStereotype() and setStereotype() to change stereotype

      * text.

      */

     private FigStereotypesGroup stereotypeFig;

     /**

      * The <code>FigProfileIcon</code> being currently displayed

      */

     private FigProfileIcon stereotypeFigProfileIcon;

     /**

      * Contains the figs of the floating stereotypes when viewed in 

      * <code>SmallIcon</code> mode.

      */

     private List<Fig> floatingStereotypes = new ArrayList<Fig>();

     /**

      * The current stereotype view, defaults to "textual".

      * 

      * @see DiagramAppearance#STEREOTYPE_VIEW_TEXTUAL

      * @see DiagramAppearance#STEREOTYPE_VIEW_SMALL_ICON

      * @see DiagramAppearance#STEREOTYPE_VIEW_BIG_ICON

      */

     private DiagramSettings.StereotypeStyle stereotypeStyle = 

         DiagramSettings.StereotypeStyle.TEXTUAL;   

     /**

      * The width of the profile icons when viewed at the small icon mode.

      * The icon width is resized to <code>ICON_WIDTH</code> and the height is 

      * set to a value that attempts to keep the original width/height 

      * proportion. 

      */

     private static final int ICON_WIDTH = 16;

     /**

      * When stereotypes are shown in <code>BigIcon</code> mode the 

      * <code>nameFig</code> is replaced by the one provided by the 

      * <code>FigProfileIcon</code> 

      * 

      * @see FigProfileIcon

      */

     private FigText originalNameFig;

     /**

      * EnclosedFigs are the Figs that are enclosed by this figure. Say that

      * it is a Package then these are the Classes, Interfaces, Packages etc

      * that are on this figure. This is not the same as the figures in the

      * FigGroup that this FigNodeModelElement "is", since these are the

      * figures that make up this high-level primitive figure.

      */

     private Vector<Fig> enclosedFigs = new Vector<Fig>();

     /**

      * The figure enclosing this figure such as a package surrounding a class.

      */

     private Fig encloser;

     // TODO: Bobs says - what is the purpose of this flag? Please document.

     private boolean readyToEdit = true;

     private boolean suppressCalcBounds;

     private static boolean showBoldName;

     private ItemUID itemUid;

     /**

      * Set the removeFromDiagram to false if this node may not

      * be removed from the diagram.

      */

     private boolean removeFromDiagram = true;

     /**

      * If the contains text to be edited by the user.

      */

     private boolean editable = true;

     // TODO: A more strongly typed data structure could be used here.

     private Set<Object[]> listeners = new HashSet<Object[]>();

     /**

      * Settings which affect rendering (color, font, line width, etc);

      */

     private DiagramSettings settings;

     /**

      * The notation settings for this specific fig.  We manage it separately

      * from DiagramSettings because it is more likely to change.

      */

     private NotationSettings notationSettings;

     /**

      * Construct an unplaced Fig with no owner using the given 

      * rendering settings.

      */

     private void constructFigs() {

         // TODO: Why isn't this stuff managed by the nameFig itself?

         nameFig.setFilled(true);

         nameFig.setText(placeString());

         nameFig.setBotMargin(7); // make space for the clarifier

         nameFig.setRightMargin(4); // margin between text and border

         nameFig.setLeftMargin(4);

         readyToEdit = false;

         setShadowSize(getSettings().getDefaultShadowWidth());

         /* TODO: how to handle changes in shadowsize 

          * from the project properties? */

         stereotypeStyle = getSettings().getDefaultStereotypeView();

     }

     /**

      * Construct a figure at a specific position for a given model element

      * with the given settings. This is the constructor used by the PGML

      * parser when loading a diagram from a file.<p>

      * 

      * Beware: the width and height in the given Rectangle are currently ignored.

      * According issue 5604 this is a bug.

      * 

      * @param element ModelElement associated with figure

      * @param bounds x & y are used to set position, width & height are ignored

      * @param renderSettings  the rendering settings to use for the Fig

      */

     protected FigNodeModelElement(Object element, Rectangle bounds, 

             DiagramSettings renderSettings) {

         super();

         super.setOwner(element);

         // TODO: We currently don't support per-fig settings for most stuff, so

         // we can just use the defaults that we were given.

 //        settings = new DiagramSettings(renderSettings);

         settings = renderSettings;

         // Be careful here since subclasses could have overridden this with

         // the assumption that it wouldn't be called before the constructors

         // finished

         super.setFillColor(FILL_COLOR);

         super.setLineColor(LINE_COLOR);

         super.setLineWidth(LINE_WIDTH);

         super.setTextColor(TEXT_COLOR); // Some subclasses will try to use this

         /*

          * Notation settings are different since, we know that, at a minimum,

          * the isShowPath() setting can change because with implement

          * PathContainer, so we make sure that we have a private copy of the

          * notation settings.

          */

         notationSettings = new NotationSettings(settings.getNotationSettings());

         // this rectangle marks the whole modelelement figure; everything

         // is inside it:

         bigPort = createBigPortFig();

         nameFig = new FigNameWithAbstractAndBold(element, 

                 new Rectangle(X0, Y0, WIDTH, NAME_FIG_HEIGHT), getSettings(), true);

         stereotypeFig = createStereotypeFig();

         constructFigs();

         // TODO: For a FigPool the element will be null.

         // When issue 5031 is resolved this constraint can be reinstated

 //        if (element == null) {

 //            throw new IllegalArgumentException("An owner must be supplied");

 //        }

         if (element != null && !Model.getFacade().isAUMLElement(element)) {

             throw new IllegalArgumentException(

                     "The owner must be a model element - got a "

                     + element.getClass().getName());

         }

         nameFig.setText(placeString());

         if (element != null) {

             NotationName nn = Notation.findNotation(notationSettings.getNotationLanguage());

             notationProviderName =

                 NotationProviderFactory2.getInstance().getNotationProvider(

                         getNotationProviderType(), element, this, nn);

             /* This next line presumes that the 1st fig with this owner 

              * is the previous port - and consequently nullifies the owner 

              * of this 1st fig. */

             bindPort(element, bigPort);

             // Add a listener for changes to any property

             addElementListener(element);

         }

         if (bounds != null) {

             setLocation(bounds.x, bounds.y);

         }

         // TODO: The following is carried over from setOwner, but probably 

         // isn't needed

 //        renderingChanged();

         // It does the following (add as needed):

 //        updateNameText();

 //        updateStereotypeText();

 //        updateStereotypeIcon();        

 //        updateBounds();

 //        damage();

         readyToEdit = true;

     }

     /**

      * Overrule this if a rectangle is not usable.

      * 

      * @return the Fig to be used as bigPort

      */

     protected Fig createBigPortFig() {

         return new FigRect(X0, Y0, 0, 0, DEBUG_COLOR, DEBUG_COLOR);

     }

     protected FigStereotypesGroup createStereotypeFig() {

         return new FigStereotypesGroup(getOwner(), 

                 new Rectangle(X0, Y0, WIDTH, STEREOHEIGHT), settings);

     }

     /**

      * This is the final call at creation time of the Fig, i.e. here

      * it is put on a Diagram.

      * 

      * @param lay the Layer (which has a 1..1 relation to the Diagram)

      * @see org.tigris.gef.presentation.Fig#setLayer(org.tigris.gef.base.Layer)

      */

     @Override

     public void setLayer(Layer lay) {

         super.setLayer(lay);

         determineDefaultPathVisible();

     }

     /**

      * Clone this figure. After the base clone method has been called determine

      * which child figs of the clone represent the name, stereotype and port.

      * <p>

      * TODO: enclosedFigs, encloser and eventSenders may also need to be cloned.

      * 

      * @see java.lang.Object#clone()

      * @return the cloned figure

      */

     @Override

     public Object clone() {

         final FigNodeModelElement clone = (FigNodeModelElement) super.clone();

         final Iterator cloneIter = clone.getFigs().iterator();

         for (Object thisFig : getFigs()) {

             final Fig cloneFig = (Fig) cloneIter.next();

             if (thisFig == getBigPort()) {

                 clone.setBigPort(cloneFig);

             }

             if (thisFig == nameFig) {

                 clone.nameFig = (FigSingleLineText) thisFig;

                 /* TODO: MVW: I think this has to be: 

                  * clone.nameFig = (FigSingleLineText) cloneFig;

                  * but have not the means to investigate, 

                  * since this code is not yet used.

                  * Enable the menu-items for Copy/Paste to test... 

                  * BTW: In some other FigNodeModelElement 

                  * classes I see the same mistake. */

             }

             if (thisFig == getStereotypeFig()) {

                 clone.stereotypeFig = (FigStereotypesGroup) thisFig;

                 /* Idem here:

                  * clone.stereotypeFig = (FigStereotypesGroup) cloneFig; */

             }

         }

         return clone;

     }

     /**

      * Default Reply text to be shown while placing node in diagram.

      * Overrule this when the text is not "new [UMLClassName]".

      *

      * @return the text to be shown while placing node in diagram

      */

     public String placeString() {

         if (Model.getFacade().isAModelElement(getOwner())) {

             String placeString = Model.getFacade().getName(getOwner());

             if (placeString == null) {

                 placeString =

                     // TODO: I18N

                     "new " + Model.getFacade().getUMLClassName(getOwner());

             }

             return placeString;

         }

         return "";

     }

     /**

      * @param id UID

      */

     public void setItemUID(ItemUID id) {

         itemUid = id;

     }

     /**

      * @return UID

      */

     public ItemUID getItemUID() {

         return itemUid;

     }

     /**

      * Get the Fig that displays the model element name.

      *

      * @return the name Fig

      */

     protected FigText getNameFig() {

         return nameFig;

     }

     /**

      * Get the Rectangle in which the model elements name is displayed

      * @return bounding box for name

      */

     public Rectangle getNameBounds() {

         return nameFig.getBounds();

     }

     /**

      * Set the Fig that displays the model element name.

      *

      * @param fig the name Fig

      */

     protected void setNameFig(FigText fig) {

         nameFig = fig;

         if (nameFig != null) {

             updateFont();

         }

     }

     /**

      * Get the name of the model element this Fig represents.

      *

      * @return the name of the model element

      */

     public String getName() {

         return nameFig.getText();

     }

     /**

      * Change the name of the model element this Fig represents.

      *

      * @param n the name of the model element

      */

     public void setName(String n) {

         nameFig.setText(n);

     }

     /**

      * This method returns a Vector of one of these 4 types:

      * AbstractAction, JMenu, JMenuItem, JSeparator.

      * {@inheritDoc}

      */

     @Override

     public Vector getPopUpActions(MouseEvent me) {

         ActionList popUpActions =

             new ActionList(super.getPopUpActions(me), isReadOnly());

         final List<Action> modulesActions =

             ContextActionFactoryManager.getContextPopupActions();

         for (Action a : modulesActions) {

             if (a instanceof List) {

                 JMenu m = new JMenu((Action) a);

                 popUpActions.add(m);

                 for (Action subAction : (List<Action>) a) {

                     m.add(subAction);

                 }

             } else {

                 popUpActions.add(a);

             }

         }

         // Show ...

         ArgoJMenu show = buildShowPopUp();

         if (show.getMenuComponentCount() > 0) {

             popUpActions.add(show);

         }

         // popupAddOffset should be equal to the number of items added here:

         popUpActions.add(new JSeparator());

         popupAddOffset = 1;

         if (removeFromDiagram) {

             popUpActions.add(

                     ProjectActions.getInstance().getRemoveFromDiagramAction());

             popupAddOffset++;

         }

         if (!isReadOnly()) {

             popUpActions.add(new ActionDeleteModelElements());

             popupAddOffset++;

         }

         /* Check if multiple items are selected: */

         if (TargetManager.getInstance().getTargets().size() == 1) {

             // TODO: Having Critics actions here introduces an unnecessary

             // dependency on the Critics subsystem.  Have it register its

             // desired actions using an extension mechanism - tfm

             ToDoList tdList = Designer.theDesigner().getToDoList();

             List<ToDoItem> items = tdList.elementListForOffender(getOwner());

             if (items != null && items.size() > 0) {

                 // TODO: This creates a dependency on the Critics subsystem.

                 // We need a generic way for modules (including our internal

                 // subsystems) to request addition of actions to the popup

                 // menu. - tfm 20080430

                 ArgoJMenu critiques = new ArgoJMenu("menu.popup.critiques");

                 ToDoItem itemUnderMouse = hitClarifier(me.getX(), me.getY());

                 if (itemUnderMouse != null) {

                     critiques.add(new ActionGoToCritique(itemUnderMouse));

                     critiques.addSeparator();

                 }

                 for (ToDoItem item : items) {

                     if (item != itemUnderMouse) {

                         critiques.add(new ActionGoToCritique(item));

                     }

                 }

                 popUpActions.add(0, new JSeparator());

                 popUpActions.add(0, critiques);

             }

         }

         // Add stereotypes submenu

         Collection<Object> elements = new ArrayList<Object>();

         Object owner = getOwner();

         if (owner != null) {

             elements.add(owner);

         }

         for (Object o : TargetManager.getInstance().getTargets()) {

             Object element = null;

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

                 element = o;

             } else if (o instanceof Fig) {

                 element = ((Fig) o).getOwner();

             }

             if (element != null && element != owner) {

                 elements.add(element);

             }

         }

         final Action[] stereoActions =

             StereotypeUtility.getApplyStereotypeActions(elements);

         if (stereoActions != null) {

             popUpActions.add(0, new JSeparator());

             final ArgoJMenu stereotypes =

                 new ArgoJMenu("menu.popup.apply-stereotypes");

             for (Action action : stereoActions) {

                 stereotypes.addCheckItem(action);

             }

             popUpActions.add(0, stereotypes);

         }

         if (TargetManager.getInstance().getTargets().size() == 1) {

             // add stereotype view submenu

             ArgoJMenu stereotypesView =

                 new ArgoJMenu("menu.popup.stereotype-view");

             // TODO: There are cyclic dependencies between ActionStereotypeView*

             // and FigNodeModelElement.  Register these actions opaquely since

             // we don't what they are. - tfm

             stereotypesView.addRadioItem(new ActionStereotypeViewTextual(this));

             stereotypesView.addRadioItem(new ActionStereotypeViewBigIcon(this));

             stereotypesView.addRadioItem(

                     new ActionStereotypeViewSmallIcon(this));

             popUpActions.add(0, stereotypesView);

         }

         return popUpActions;

     }

     protected ArgoJMenu buildShowPopUp() {

         ArgoJMenu showMenu = new ArgoJMenu("menu.popup.show");

         for (UndoableAction ua : ActionSetPath.getActions()) {

             showMenu.add(ua);

         }

         return showMenu;

     }

     /**

      * @return the pop-up menu item for Visibility

      */

     protected Object buildVisibilityPopUp() {

         ArgoJMenu visibilityMenu = new ArgoJMenu("menu.popup.visibility");

         visibilityMenu.addRadioItem(new ActionVisibilityPublic(getOwner()));

         visibilityMenu.addRadioItem(new ActionVisibilityPrivate(getOwner()));

         visibilityMenu.addRadioItem(new ActionVisibilityProtected(getOwner()));

         visibilityMenu.addRadioItem(new ActionVisibilityPackage(getOwner()));

         return visibilityMenu;

     }

     /**

      * Build a pop-up menu item for the various modifiers.<p>

      *

      * This function is designed to be easily extendable with new items.

      *

      * @param items bitwise OR of the items: ROOT, ABSTRACT, LEAF, ACTIVE.

      * @return the menu item

      */

     protected Object buildModifierPopUp(int items) {

         ArgoJMenu modifierMenu = new ArgoJMenu("menu.popup.modifiers");

         if ((items & ABSTRACT) > 0) {

             modifierMenu.addCheckItem(new ActionModifierAbstract(getOwner()));

         }

         if ((items & LEAF) > 0) {

             modifierMenu.addCheckItem(new ActionModifierLeaf(getOwner()));

         }

         if ((items & ROOT) > 0) {

             modifierMenu.addCheckItem(new ActionModifierRoot(getOwner()));

         }

         if ((items & ACTIVE) > 0) {

             modifierMenu.addCheckItem(new ActionModifierActive(getOwner()));

         }

         return modifierMenu;

     }

     /*

      * @see org.tigris.gef.presentation.Fig#getEnclosingFig()

      */

     @Override

     public Fig getEnclosingFig() {

         return encloser;

     }

     /*

      * Updates the modelelement container if the fig is moved in or

      * out another fig. If this fig doesn't have an enclosing fig

      * anymore, the namespace of the diagram will be the owning

      * modelelement. If this fig is moved inside another

      * FigNodeModelElement the owner of that fignodemodelelement will

      * be the owning modelelement.

      * 

      * @see org.tigris.gef.presentation.FigNode#setEnclosingFig(org.tigris.gef.presentation.Fig)

      */

     @Override

     public void setEnclosingFig(Fig newEncloser) {

         Fig oldEncloser = encloser;

         LayerPerspective layer = (LayerPerspective) getLayer();

         if (layer != null) {

             ArgoDiagram diagram = (ArgoDiagram) layer.getDiagram();

             diagram.encloserChanged(

                     this,

                     (FigNode) oldEncloser,

                     (FigNode) newEncloser);

         }

         super.setEnclosingFig(newEncloser);

         if (layer != null && newEncloser != oldEncloser) {

             Diagram diagram = layer.getDiagram();

             if (diagram instanceof ArgoDiagram) {

                 ArgoDiagram umlDiagram = (ArgoDiagram) diagram;

                 // Set the namespace of the enclosed model element to the

                 // namespace of the encloser.

                 Object namespace = null;

                 if (newEncloser == null) {

                     // The node's been placed on the diagram

                     umlDiagram.setModelElementNamespace(getOwner(), null);

                 } else { 

                     // The node's been placed within some Fig

                     namespace = newEncloser.getOwner();

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

                         umlDiagram.setModelElementNamespace(

                                 getOwner(), namespace);

                     }

                 }

             }

             if (encloser instanceof FigNodeModelElement) {

                 ((FigNodeModelElement) encloser).removeEnclosedFig(this);

             }

             if (newEncloser instanceof FigNodeModelElement) {

                 ((FigNodeModelElement) newEncloser).addEnclosedFig(this);

             }

         }

         encloser = newEncloser;

     }

     /**

      * Handle the case where this fig is moved into a Component.

      * 

      * @param newEncloser the new encloser for this Fig

      */

     protected void moveIntoComponent(Fig newEncloser) {

         final Object component = newEncloser.getOwner();

         final Object owner = getOwner();

         assert Model.getFacade().isAComponent(component);

         assert Model.getFacade().isAUMLElement(owner);

         final Collection er1 = Model.getFacade().getElementResidences(owner);

         final Collection er2 = Model.getFacade().getResidentElements(component);

         boolean found = false;

         // Find all ElementResidences between the class and the component:

         final Collection<Object> common = new ArrayList<Object>(er1);

         common.retainAll(er2);

         for (Object elementResidence : common) {

             if (!found) {

                 found = true;

                 // There is already a correct ElementResidence

             } else {

                 // There were 2 ElementResidences .. strange case.

                 Model.getUmlFactory().delete(elementResidence);

             }

         }

         if (!found) {

             // There was no ElementResidence yet, so let's create one:

             Model.getCoreFactory().buildElementResidence(

                     owner, component);

         }

     }

     /**

      * Add a Fig that is enclosed by this figure.

      * 

      * @param fig The fig to be added

      */

     public void addEnclosedFig(Fig fig) {

         enclosedFigs.add(fig);

     }

     /**

      * Removes the given Fig from the list of enclosed Figs.

      * 

      * @param fig The Fig to be removed

      */

     public void removeEnclosedFig(Fig fig) {

         enclosedFigs.remove(fig);

     }

     /*

      * @see org.tigris.gef.presentation.Fig#getEnclosedFigs()

      */

     @Override

     public Vector<Fig> getEnclosedFigs() {

         return enclosedFigs;

     }

     /*

      * @see org.tigris.gef.presentation.Fig#makeSelection()

      */

     @Override

     public Selection makeSelection() {

         return new SelectionDefaultClarifiers(this);

     }

     /**

      * Displays visual indications of pending ToDoItems.

      * Please note that the list of advices (ToDoList) is not the same

      * as the list of element known by the FigNode (_figs). Therefore,

      * it is necessary to check if the graphic item exists before drawing

      * on it. See ClAttributeCompartment for an example.

      * @param g the graphics device

      * @see org.argouml.uml.cognitive.critics.ClAttributeCompartment

      */

     public void paintClarifiers(Graphics g) {

         // TODO: Generalize extension and remove critic specific stuff

         int iconX = getX();

         int iconY = getY() - 10;

         ToDoList tdList = Designer.theDesigner().getToDoList();

         List<ToDoItem> items = tdList.elementListForOffender(getOwner());

         for (ToDoItem item : items) {

             Icon icon = item.getClarifier();

             if (icon instanceof Clarifier) {

                 ((Clarifier) icon).setFig(this);

                 ((Clarifier) icon).setToDoItem(item);

             }

             if (icon != null) {

                 icon.paintIcon(null, g, iconX, iconY);

                 iconX += icon.getIconWidth();

             }

         }

         items = tdList.elementListForOffender(this);

         for (ToDoItem item : items) {

             Icon icon = item.getClarifier();

             if (icon instanceof Clarifier) {

                 ((Clarifier) icon).setFig(this);

                 ((Clarifier) icon).setToDoItem(item);

             }

             if (icon != null) {

                 icon.paintIcon(null, g, iconX, iconY);

                 iconX += icon.getIconWidth();

             }

         }

     }

     /**

      * @param x the x of the hit

      * @param y the y of the hit

      * @return the todo item of which the clarifier has been hit

      */

     protected ToDoItem hitClarifier(int x, int y) {

         // TODO: ToDoItem stuff should be made an opaque extension

         int iconX = getX();

         ToDoList tdList = Designer.theDesigner().getToDoList();

         List<ToDoItem> items = tdList.elementListForOffender(getOwner());

         for (ToDoItem item : items) {

             Icon icon = item.getClarifier();

             int width = icon.getIconWidth();

             if (y >= getY() - 15

                     && y <= getY() + 10

                     && x >= iconX

                     && x <= iconX + width) {

                 return item;

             }

             iconX += width;

         }

         for (ToDoItem item : items) {

             Icon icon = item.getClarifier();

             if (icon instanceof Clarifier) {

                 ((Clarifier) icon).setFig(this);

                 ((Clarifier) icon).setToDoItem(item);

                 if (((Clarifier) icon).hit(x, y)) {

                     return item;

                 }

             }

         }

         items = tdList.elementListForOffender(this);

         for (ToDoItem item : items) {

             Icon icon = item.getClarifier();

             int width = icon.getIconWidth();

             if (y >= getY() - 15

                     && y <= getY() + 10

                     && x >= iconX

                     && x <= iconX + width) {

                 return item;

             }

             iconX += width;

         }

         for (ToDoItem item : items) {

             Icon icon = item.getClarifier();

             if (icon instanceof Clarifier) {

                 ((Clarifier) icon).setFig(this);

                 ((Clarifier) icon).setToDoItem(item);

                 if (((Clarifier) icon).hit(x, y)) {

                     return item;

                 }

             }

         }

         return null;

     }

     /*

      * @see org.tigris.gef.presentation.Fig#getTipString(java.awt.event.MouseEvent)

      */

     @Override

     public String getTipString(MouseEvent me) {

         // TODO: Generalize extension and remove critic specific code

         ToDoItem item = hitClarifier(me.getX(), me.getY());

         String tip = "";

         if (item != null

             && Globals.curEditor().getSelectionManager().containsFig(this)) {

             tip = item.getHeadline() + " ";

         } else if (getOwner() != null) {

             tip = Model.getFacade().getTipString(getOwner());

         } else {

             tip = toString();

         }

         if (tip != null && tip.length() > 0 && !tip.endsWith(" ")) {

             tip += " ";

         }

         return tip;

     }

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

     // event handlers

     /*

      * @see java.beans.VetoableChangeListener#vetoableChange(java.beans.PropertyChangeEvent)

      */

     public void vetoableChange(PropertyChangeEvent pce) {

         LOG.debug("in vetoableChange");

         Object src = pce.getSource();

         if (src == getOwner()) {

             DelayedChangeNotify delayedNotify =

                 new DelayedChangeNotify(this, pce);

             SwingUtilities.invokeLater(delayedNotify);

         } else {

             LOG.debug("FigNodeModelElement got vetoableChange"

                       + " from non-owner:"

                       + src);

         }

     }

     /*

      * @see org.argouml.kernel.DelayedVChangeListener#delayedVetoableChange(java.beans.PropertyChangeEvent)

      */

     public void delayedVetoableChange(PropertyChangeEvent pce) {

         LOG.debug("in delayedVetoableChange");

         // update any text, colors, fonts, etc.

         renderingChanged();

         endTrans();

     }

     /**

      * Determine new bounds. <p>

      * 

      * This algorithm makes the box grow 

      * (if the calculated minimum size grows), 

      * but then it can never shrink again 

      * (not even if the calculated minimum size is smaller).<p>

      * 

      * If the user can not resize the fig, e.g. like the FigActor or FigFinalState, 

      * then we return the original size.

      */

     protected void updateBounds() {

         if (!checkSize) {

             return;

         }

         Rectangle bbox = getBounds();

         Dimension minSize = getMinimumSize();

         if (isResizable()) {

             bbox.width = Math.max(bbox.width, minSize.width);

             bbox.height = Math.max(bbox.height, minSize.height);

         }

         /* Only update the bounds if they change:  */

         if (bbox.x != getX()

                 || bbox.y != getY()

                 || bbox.width != getWidth()

                 || bbox.height != getHeight()) {

             setBounds(bbox.x, bbox.y, bbox.width, bbox.height);

         }

     }

     /*

      * @see java.beans.PropertyChangeListener#propertyChange(java.beans.PropertyChangeEvent)

      */

     public void propertyChange(final PropertyChangeEvent pve) {

         final Object src = pve.getSource();

         final String pName = pve.getPropertyName();

         if (pve instanceof DeleteInstanceEvent && src == getOwner()) {

             removeFromDiagram();

             return;

         }

         // We are getting events we don't want. Filter them out.

         if (pve.getPropertyName().equals("supplierDependency")

                 && Model.getFacade().isADependency(pve.getOldValue())) {

             // TODO: Can we instruct the model event pump not to send these in

             // the first place? See defect 5095.

             return;

         }

         // We handle and consume editing events

         if (pName.equals("editing")

                 && Boolean.FALSE.equals(pve.getNewValue())) {

             try {

                 //parse the text that was edited

                 textEdited((FigText) src);

                 // resize the FigNode to accommodate the new text

                 final Rectangle bbox = getBounds();

                 final Dimension minSize = getMinimumSize();

                 bbox.width = Math.max(bbox.width, minSize.width);

                 bbox.height = Math.max(bbox.height, minSize.height);

                 setBounds(bbox.x, bbox.y, bbox.width, bbox.height);

                 endTrans();

             } catch (PropertyVetoException ex) {

                 LOG.error("could not parse the text entered. "

                         + "PropertyVetoException",

                         ex);

             }

         } else if (pName.equals("editing")

                 && Boolean.TRUE.equals(pve.getNewValue())) {

             if (!isReadOnly()) {

                 textEditStarted((FigText) src);

             }

         } else {

             super.propertyChange(pve);

         }

         if (Model.getFacade().isAUMLElement(src)) {

             final UmlChangeEvent event = (UmlChangeEvent) pve;

             /* If the source of the event is an UML object,

              * e.g. the owner of this Fig (but not always only the owner

              * is shown, e.g. for a class, also its attributes are shown),

              * then the UML model has been changed.

              */

             final Object owner = getOwner();

             if (owner == null) {

                 // TODO: Should this not be an assert?

                 return;

             }

             try {

                 modelChanged(event);

             } catch (InvalidElementException e) {

                 if (LOG.isDebugEnabled()) {

                     LOG.debug("modelChanged method accessed deleted element"

                             + formatEvent(event),

                             e);

                 }

             }

             if (event.getSource() == owner 

                     && "stereotype".equals(event.getPropertyName())) {

                 stereotypeChanged(event);            

             }

             Runnable doWorkRunnable = new Runnable() {

                 public void run() {

                     try {

                         updateLayout(event);

                     } catch (InvalidElementException e) {

                         if (LOG.isDebugEnabled()) {

                             LOG.debug("updateLayout method accessed "

                                     + "deleted element " 

                                     + formatEvent(event), e);

                         }

                     }

                 }  

             };

             SwingUtilities.invokeLater(doWorkRunnable);

         }

     }

     private String formatEvent(PropertyChangeEvent event) {

         return "\n\t event = " + event.getClass().getName() 

                 + "\n\t source = " + event.getSource() 

                 + "\n\t old = " + event.getOldValue()

                 + "\n\t name = " + event.getPropertyName();

     }

     /**

      * Return true if the model element that this Fig represents is read only

      * @return The model element is read only.

      */

     private boolean isReadOnly() {

         try {

             return Model.getModelManagementHelper().isReadOnly(getOwner());

         } catch (InvalidElementException e) {

             return true;

         }

     }

     /**

      * Called by propertyChanged when it detects that a stereotype

      * has been added or removed. On removal the FigNode removes its

      * listener to that stereotype. When a new stereotype is detected

      * we add a listener.

      * TODO: Bob says: In my opinion we shouldn't be doing this here.

      * FigStereotype should always be listening to change of its

      * owners name.

      * FigStereotypesCompartment should always be listening for add

      * or remove of Stereotypes to its owner.

      * Those classes will need to pass some event to the FigNode on

      * the AWT thread only if a change results in a change of size

      * that requires a redraw.

      * <p>NOTE: Runs at the Model (MDR) Thread </p>

      * @param event the UmlChangeEvent that caused the change

      */

     private void stereotypeChanged(final UmlChangeEvent event) {

         final Object owner = getOwner();

         assert owner != null;

         try {          

             if (event.getOldValue() != null) {

                 removeElementListener(event.getOldValue());

             }

             if (event.getNewValue() != null) {

                 addElementListener(event.getNewValue(), "name");

             }

         } catch (InvalidElementException e) {

             LOG.debug("stereotypeChanged method accessed deleted element ", e);

         }

     }

     /**

      * This method is called when the user doubleclicked on the text field,

      * and starts editing. Subclasses should overrule this field to e.g.

      * supply help to the user about the used format. <p>

      *

      * It is also possible to alter the text to be edited

      * already here, e.g. by adding the stereotype in front of the name,

      * by using setFullyHandleStereotypes(true) in the NotationSettings 

      * argument of the NotationProvider.toString() function, 

      * but that seems not user-friendly. See issue 3838.

      *

      * @param ft the FigText that will be edited and contains the start-text

      */

     protected void textEditStarted(FigText ft) {

         if (ft == getNameFig()) {

             showHelp(notationProviderName.getParsingHelp());

             ft.setText(notationProviderName.toString(getOwner(), 

                     getNotationSettings()));

         }

         if (ft instanceof CompartmentFigText) {

             final CompartmentFigText figText = (CompartmentFigText) ft;

             showHelp(figText.getNotationProvider().getParsingHelp());

             figText.setText(figText.getNotationProvider().toString(

                     figText.getOwner(), getNotationSettings()));

         }

     }

     /**

      * Utility function to localize the given string with help text, and show it

      * in the status bar of the ArgoUML window. This function is used in favour

      * of the inline call to enable later improvements; e.g. it would be

      * possible to show a help-balloon.

      * <p>

      * TODO: Work this out. One matter to possibly improve: show multiple lines.

      * 

      * @param s the given string to be localized and shown

      */

     protected void showHelp(String s) {

         if (s == null) {

             // Convert null to empty string and clear help message

             ArgoEventPump.fireEvent(new ArgoHelpEvent(

                     ArgoEventTypes.HELP_CHANGED, this, ""));

         } else {

             ArgoEventPump.fireEvent(new ArgoHelpEvent(

                     ArgoEventTypes.HELP_CHANGED, this, Translator.localize(s)));

         }

     }

     /**

      * This method is called after the user finishes editing a text

      * field that is in the FigNodeModelElement.  Determine which

      * field and update the model.  This class handles the name,

      * the stereotype, and any CompartmentFigTexts.

      * Subclasses should override to handle other text elements.

      *

      * @param ft the FigText that has been edited and contains the new text

      * @throws PropertyVetoException thrown when new text represents

      * an unacceptable value

      */

     protected void textEdited(FigText ft) throws PropertyVetoException {