/* $Id: FigStubState.java 18728 2010-09-10 09:29:47Z 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:

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

 import java.awt.Color;

 import java.awt.Font;

 import java.awt.Rectangle;

 import java.beans.PropertyChangeEvent;

 import java.util.Iterator;

 import org.apache.log4j.Logger;

 import org.argouml.model.Facade;

 import org.argouml.model.Model;

 import org.argouml.model.StateMachinesHelper;

 import org.argouml.uml.diagram.DiagramSettings;

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

 import org.tigris.gef.base.Selection;

 import org.tigris.gef.presentation.Fig;

 import org.tigris.gef.presentation.FigLine;

 import org.tigris.gef.presentation.FigRect;

 import org.tigris.gef.presentation.FigText;

 /**

  * Class to display graphics for a UML StubState in a diagram.

  *

  * @author pepargouml@yahoo.es

  */

 public class FigStubState extends FigStateVertex {

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

     private static final int X = 0;

     private static final int Y = 0;

     private static final int WIDTH = 45;

     private static final int HEIGHT = 20;

     private FigText referenceFig;

     private FigLine stubline;

     private Facade facade;

     private StateMachinesHelper stateMHelper;

     /**

      * Construct a new FigStubState.

      * 

      * @param owner owning UML element

      * @param bounds position and size

      * @param settings rendering settings

      */

     public FigStubState(Object owner, Rectangle bounds,

             DiagramSettings settings) {

         super(owner, bounds, settings);

         initFigs();

     }

     @Override

     protected Fig createBigPortFig() {

         FigRect fr = new FigRect(X, Y, WIDTH, HEIGHT);

         fr.setLineWidth(0);

         fr.setFilled(false);

         return fr;

     }

     private void initFigs() {

         facade = Model.getFacade();

         stateMHelper = Model.getStateMachinesHelper();

         stubline = new FigLine(X,

                 Y,

                 WIDTH,

                 Y,

                 TEXT_COLOR);

         referenceFig = new FigText(0, 0, WIDTH, HEIGHT, true);

         referenceFig.setFont(getSettings().getFontPlain());

         referenceFig.setTextColor(TEXT_COLOR);

         referenceFig.setReturnAction(FigText.END_EDITING);

         referenceFig.setTabAction(FigText.END_EDITING);

         referenceFig.setJustification(FigText.JUSTIFY_CENTER);

         referenceFig.setLineWidth(0);

         referenceFig.setBounds(X, Y,

                 WIDTH, referenceFig.getBounds().height);

         referenceFig.setFilled(false);

         referenceFig.setEditable(false);

         addFig(getBigPort());

         addFig(referenceFig);

         addFig(stubline);

         setShadowSize(0);

         setBlinkPorts(false); //make port invisible unless mouse enters

     }

     /*

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

      */

     @Override

     public Object clone() {

         FigStubState figClone = (FigStubState) super.clone();

         Iterator it = figClone.getFigs().iterator();

         figClone.setBigPort((FigRect) it.next());

         figClone.referenceFig = (FigText) it.next();

         figClone.stubline = (FigLine) it.next();

         return figClone;

     }

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

     // Fig accessors

     /**

      * Synch states are fixed size.

      * @return false

      */

     @Override

     public boolean isResizable() {

         return false;

     }

     /*

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

      */

     @Override

     public Selection makeSelection() {

         return new SelectionMoveClarifiers(this);

     }

     /*

      * @see org.tigris.gef.presentation.Fig#setLineColor(java.awt.Color)

      */

     @Override

     public void setLineColor(Color col) {

         stubline.setLineColor(col);

     }

     /*

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

      */

     @Override

     public Color getLineColor() {

         return stubline.getLineColor();

     }

     /*

      * @see org.tigris.gef.presentation.Fig#setFillColor(java.awt.Color)

      */

     @Override

     public void setFillColor(Color col) {

         referenceFig.setFillColor(col);

     }

     /*

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

      */

     @Override

     public Color getFillColor() {

         return referenceFig.getFillColor();

     }

     /*

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

      */

     @Override

     public void setFilled(boolean f) {

         referenceFig.setFilled(f);

     }

     @Override

     public boolean isFilled() {

         return referenceFig.isFilled();

     }

     /*

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

      */

     @Override

     public void setLineWidth(int w) {

         stubline.setLineWidth(w);

     }

     /*

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

      */

     @Override

     public int getLineWidth() {

         return stubline.getLineWidth();

     }

     /*

      * @see org.tigris.gef.presentation.Fig#setBoundsImpl(int, int, int, int)

      */

     @Override

     protected void setStandardBounds(int theX, int theY, int theW, int theH) {

         Rectangle oldBounds = getBounds();

         theW = 60;

         referenceFig.setBounds(theX, theY, theW,

                 referenceFig.getBounds().height);

         stubline.setShape(theX, theY,

                 theX + theW, theY);

         getBigPort().setBounds(theX, theY, theW, theH);

         calcBounds(); //_x = x; _y = y; _w = w; _h = h;

         updateEdges();

         firePropChange("bounds", oldBounds, getBounds());

     }

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

     // event processing

     /*

      * Update the text labels.

      *

      * @see org.argouml.uml.diagram.ui.FigNodeModelElement#modelChanged(java.beans.PropertyChangeEvent)

      */

     @Override

     protected void modelChanged(PropertyChangeEvent mee) {

         super.modelChanged(mee);

         // TODO: Rather than specifically ignore some item maybe it would be better

         // to specifically state what items are of interest. Otherwise we may still

         // be acting on other events we don't need

         if (!Model.getFacade().isATransition(mee.getNewValue())

                 && getOwner() != null) {

             Object container = facade.getContainer(getOwner());

             //The event source is the owner stub state

             if ((mee.getSource().equals(getOwner()))) {

                 if (mee.getPropertyName().equals("referenceState")) {

                     updateReferenceText();

                     final Object oldRef;

                     if (container != null && facade.isASubmachineState(container)

                             && facade.getSubmachine(container) != null) {

                         final Object top;

                         top = facade.getTop(facade.getSubmachine(container));

                         oldRef = stateMHelper.getStatebyName(

                                 (String) mee.getOldValue(), top);

                     } else {

                         oldRef = null;

                     }

                     updateListeners(oldRef, getOwner());

                 } else if ((mee.getPropertyName().equals("container")

                         && facade.isASubmachineState(container))) {

                     removeListeners();

                     Object o = mee.getOldValue();

                     if (o != null && facade.isASubmachineState(o)) {

                         removeElementListener(o);

                     }

                     stateMHelper.setReferenceState(getOwner(), null);

                     updateListeners(getOwner(), getOwner());

                     updateReferenceText();

                 }

             } else {

                 /*The event source is the submachine state*/

                 if (container != null

                         && mee.getSource().equals(container)

                         && facade.isASubmachineState(container)

                         && facade.getSubmachine(container) != null) {

                     /* The submachine has got a new name*/

                     // This indicates a change in association, not name - tfm

                     if (mee.getPropertyName().equals("submachine")) {

                         final Object oldRef;

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

                             final Object top;

                             top = facade.getTop(mee.getOldValue());

                             oldRef = stateMHelper.getStatebyName(facade

                                     .getReferenceState(getOwner()), top);

                         } else {

                             oldRef = null;

                         }

                         stateMHelper.setReferenceState(getOwner(), null);

                         updateListeners(oldRef, getOwner());

                         updateReferenceText();

                     }

                 } else {

                     // The event source is the stub state's referenced state

                     // or one of the referenced state's path.

                     final Object top;

                     if (facade.getSubmachine(container) != null) {

                         top = facade.getTop(facade.getSubmachine(container));

                     } else {

                         top = null;

                     }

                     String path = facade.getReferenceState(getOwner());

                     Object refObject = stateMHelper.getStatebyName(path, top);

                     String ref;

                     if (refObject == null) {

                         // The source was the referenced state that has got

                         // a new name.

                         ref = stateMHelper.getPath(mee.getSource());

                     } else {

                         //The source was one of the referenced state's path which

                         // has got a new name.

                         ref = stateMHelper.getPath(refObject);

                     }

                     // The Referenced State or one of his path's states has got

                     // a new name

                     stateMHelper.setReferenceState(getOwner(), ref);

                     updateReferenceText();

                 }

             }

         }

     }

     /**

      * Rerender the whole figure.

      * Call superclass then add reference text

      */

     @Override

     public void renderingChanged() {

         super.renderingChanged();

         updateReferenceText();

     }

     /**

      * Update the reference text.

      */

     public void updateReferenceText() {

         Object text = null;

         try {

             text = facade.getReferenceState(getOwner());

         } catch (Exception e) {

             LOG.error("Exception caught and ignored!!", e);

         }

         if (text != null) {

             referenceFig.setText((String) text);

         } else {

             referenceFig.setText("");

         }

         calcBounds();

         setBounds(getBounds());

         damage();

     }

     /**

      * @param newOwner

      */

     private void addListeners(Object newOwner) {

         Object container;

         Object top;

         Object reference;

         container = facade.getContainer(newOwner);

         //The new submachine container is added as listener

         if (container != null

                 && facade.isASubmachineState(container)) {

             addElementListener(container);

         }

         //All states in the new reference state's path are added

         // as listeners

         if (container != null

                 && facade.isASubmachineState(container)

                 && facade.getSubmachine(container) != null) {

             top = facade.getTop(facade.getSubmachine(container));

             reference = stateMHelper.getStatebyName(facade

                     .getReferenceState(newOwner), top);

             String[] properties = {"name", "container"};

             container = reference;

             while (container != null

                     && !container.equals(top)) {

                 addElementListener(container);

                 container = facade.getContainer(container);

             }

         }

     }

     /**

      * Remove all the existing listeners

      */

     private void removeListeners() {

         Object container;

         Object top;

         Object reference;

         Object owner = getOwner();

         if (owner == null) {

             return;

         }

         container = facade.getContainer(owner);

         //The old submachine container is deleted as listener

         if (container != null

                 && facade.isASubmachineState(container)) {

             removeElementListener(container);

         }

         //All states in the old reference state's path are deleted

         // as listeners

         if (container != null

                 && facade.isASubmachineState(container)

                 && facade.getSubmachine(container) != null) {

             top = facade.getTop(facade.getSubmachine(container));

             reference = stateMHelper.getStatebyName(facade

                     .getReferenceState(owner), top);

             if (reference != null) {

                 removeElementListener(reference);

                 container = facade.getContainer(reference);

                 while (container != null && !facade.isTop(container)) {

                     removeElementListener(container);

                     container = facade.getContainer(container);

                 }

             }

         }

     }

     /**

      * @param newOwner the new owner UML object

      * @param oldV the old owner UML object

      * @deprecated for 0.27.2 by tfmorris. Use

      *             {@link #updateListeners(Object, Object)} with the argument

      *             order swapper. There are no internal users of this method, so

      *             the only potential users are people who've subclassed this

      *             Fig.

      */

     protected void updateListenersX(Object newOwner, Object oldV) {

         // Just swap order of arguments to get to new form

         updateListeners(oldV, newOwner);

     }

     @Override

     protected void updateListeners(Object oldV, Object newOwner) {

         if (oldV != null) {

             if (oldV != newOwner) {

                 removeElementListener(oldV);

             }

             Object container = facade.getContainer(oldV);

             while (container != null && !facade.isTop(container)) {

                 removeElementListener(container);

                 container = facade.getContainer(container);

             }

         }

         super.updateListeners(getOwner(), newOwner);

     }

     @Override

     protected void updateFont() {

         super.updateFont();

         Font f = getSettings().getFont(Font.PLAIN);

         referenceFig.setFont(f);

     }

 }