/* $Id: TabConstraints.java 17881 2010-01-12 21:09:28Z linus $

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

  * Copyright (c) 2009 Contributors - see below

  * All rights reserved. This program and the accompanying materials

  * are made available under the terms of the Eclipse Public License v1.0

  * which accompanies this distribution, and is available at

  * http://www.eclipse.org/legal/epl-v10.html

  *

  * Contributors:

  *    tfmorris

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

  *

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

  */

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

 import java.awt.BorderLayout;

 import java.awt.event.ComponentEvent;

 import java.awt.event.ComponentListener;

 import java.io.IOException;

 import java.util.ArrayList;

 import java.util.Iterator;

 import java.util.List;

 import javax.swing.JOptionPane;

 import javax.swing.JToolBar;

 import javax.swing.event.EventListenerList;

 import org.apache.log4j.Logger;

 import org.argouml.application.api.AbstractArgoJPanel;

 import org.argouml.model.Model;

 import org.argouml.ocl.ArgoFacade;

 import org.argouml.ocl.OCLUtil;

 import org.argouml.swingext.UpArrowIcon;

 import org.argouml.ui.TabModelTarget;

 import org.argouml.ui.targetmanager.TargetEvent;

 import org.tigris.gef.presentation.Fig;

 import org.tigris.toolbar.ToolBarManager;

 import tudresden.ocl.OclException;

 import tudresden.ocl.OclTree;

 import tudresden.ocl.check.OclTypeException;

 import tudresden.ocl.gui.ConstraintRepresentation;

 import tudresden.ocl.gui.EditingUtilities;

 import tudresden.ocl.gui.OCLEditor;

 import tudresden.ocl.gui.OCLEditorModel;

 import tudresden.ocl.gui.events.ConstraintChangeEvent;

 import tudresden.ocl.gui.events.ConstraintChangeListener;

 import tudresden.ocl.parser.OclParserException;

 import tudresden.ocl.parser.analysis.DepthFirstAdapter;

 import tudresden.ocl.parser.node.AConstraintBody;

 import tudresden.ocl.parser.node.TName;

 /**

   * Tab for OCL constraint editing.

   *

   * @author v1.0: Falk Finger

   * @author v2.0: Steffen Zschaler

   */

 public class TabConstraints extends AbstractArgoJPanel

     implements TabModelTarget, ComponentListener {

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

     /**

      * The actual editor pane.

      */

     private OCLEditor mOcleEditor;

     /**

      * The current target element.

      */

     private Object mMmeiTarget;

     /**

      * The constructor.

      */

     public TabConstraints() {

         super("tab.constraints");

         setIcon(new UpArrowIcon());

         setLayout(new BorderLayout(0, 0));

         mOcleEditor = new OCLEditor();

         mOcleEditor.setOptionMask(OCLEditor.OPTIONMASK_TYPECHECK

                    /*|  //removed to workaround problems with autosplit

                      OCLEditor.OPTIONMASK_AUTOSPLIT*/);

         mOcleEditor.setDoAutoSplit(false);

         setToolbarRollover(true);

         setToolbarFloatable(false);

         getOclToolbar().setName("misc.toolbar.constraints");

         add(mOcleEditor);

         addComponentListener(this);

     }

     /**

      * Set the toolbar rollover style.

      *

      * @param enable If true then button borders do not become visible

      * until mouse rolls over button.

      */

     private void setToolbarRollover(boolean enable) {

         if (!ToolBarManager.alwaysUseStandardRollover()) {

             getOclToolbar().putClientProperty(

                     "JToolBar.isRollover", Boolean.TRUE);

         }

     }

     /**

      * Set the toolbar floating style.

      *

      * @param enable If true then the toolbar can be floated and docked

      */

     private void setToolbarFloatable(boolean enable) {

         getOclToolbar().setFloatable(false);

     }

     /**

      * Get a reference to the toolbar object contained in the

      * OCLEditor component.  This is currently a nasty hack. We really

      * require an interface method on OCLEditor (Bob Tarling 8 Feb

      * 2003).

      *

      * @return The toolbar

      */

     private JToolBar getOclToolbar() {

         return (JToolBar) mOcleEditor.getComponent(0);

     }

     //TabModelTarget interface methods

     /**

      * Should this tab be activated for the current target element?<p>

      *

      * Argo only supports constraints for Classes and Features

      * (eg. Attributes and Operations) currently.

      *

      * {@inheritDoc}

      */

     public boolean shouldBeEnabled(Object target) {

         target = (target instanceof Fig) ? ((Fig) target).getOwner() : target;

         return (Model.getFacade().isAClass(target)

                 || Model.getFacade().isAFeature(target));

     }

     /*

      * @see org.argouml.ui.TabTarget#getTarget()

      */

     public Object getTarget() {

         return mMmeiTarget;

     }

     /**

      * Refresh the tab because the target has changed.

      */

     public void refresh() {

         setTarget(mMmeiTarget);

     }

     /**

      * Set the target element to be displayed in this tab. Only model elements

      * will be accepted by the constraint tab.

      *

      * {@inheritDoc}

      */

     public void setTarget(Object oTarget) {

         oTarget =

             (oTarget instanceof Fig) ? ((Fig) oTarget).getOwner() : oTarget;

         if (!(Model.getFacade().isAModelElement(oTarget))) {

             mMmeiTarget = null;

             return;

         }

         mMmeiTarget = oTarget;

         if (isVisible()) {

             setTargetInternal(mMmeiTarget);

         }

     }

     private void setTargetInternal(Object oTarget) {

         // Set editor's model

         if (oTarget != null) {

             mOcleEditor.setModel(new ConstraintModel(oTarget));

         }

     }

     /**

      * Adapter to provide information and a manipulation interface for a

      * target element's set of constraints to the constraint editor.

      */

     private static class ConstraintModel implements OCLEditorModel {

         /**

          * The target element being edited.

          */

         private Object theMMmeiTarget;

         /**

          * A list of all the constraints in m_nmeiTarget. This is necessary to

          * induce a consistent order on the constraints.

          */

         private ArrayList theMAlConstraints;

         /**

          * List of listeners.

          */

         private EventListenerList theMEllListeners = new EventListenerList();

         /**

          * Construct a new ConstraintModel.

          */

         public ConstraintModel(Object mmeiTarget) {

             super();

             theMMmeiTarget = mmeiTarget;

             theMAlConstraints =

                 new ArrayList(Model.getFacade().getConstraints(theMMmeiTarget));

         }

         /**

          * Return the number of constraints in this model.

          */

         public int getConstraintCount() {

             return theMAlConstraints.size();

         }

         /**

          * Return the constraint with the specified index.

          *

          * @param nIdx the index of the constraint to be returned.

          *             0 <= nIdx < {@link #getConstraintCount}

          */

         public ConstraintRepresentation getConstraintAt(int nIdx) {

             return representationFor(nIdx);

         }

         /**

          * Remove the specified constraint from the model.

          *

          * @param nIdx the index of the constraint to be removed.

          *             0 <= nIdx < {@link #getConstraintCount}

          */

         public void removeConstraintAt(int nIdx) {

             if ((nIdx < 0) || (nIdx > theMAlConstraints.size())) {

                 return;

             }

             Object mc = theMAlConstraints.remove(nIdx);

             if (mc != null) {

                 Model.getCoreHelper().removeConstraint(theMMmeiTarget, mc);

             }

             fireConstraintRemoved(mc, nIdx);

         }

         /**

          * Add a fresh constraint to the model.<p>

          *

          * There are 2 restrictions on what can be parsed, given

          * the current OCL grammar:

          * <ol>

          *   <li>Class names must have a capital first letter.

          *   <li>Feature name must have a lower case first letter.

          * </ol>

          */

         public void addConstraint() {

             // check ocl parsing constraints

             Object mmeContext = OCLUtil

                     .getInnerMostEnclosingNamespace(theMMmeiTarget);

             String contextName = Model.getFacade().getName(mmeContext);

             String targetName = Model.getFacade().getName(theMMmeiTarget);

             if ((contextName == null

                  || contextName.equals (""))

                 ||  // this is to fix issue #2056

                 (targetName == null

                  || targetName.equals (""))

                 ||   // this is to fix issue #2056

                 !Character.isUpperCase(contextName.charAt(0))

                 || (Model.getFacade().isAClass (theMMmeiTarget)

                     && !Character.isUpperCase(targetName.charAt(0)))

                 || (Model.getFacade().isAFeature(theMMmeiTarget)

                     && !Character.isLowerCase(targetName.charAt(0)))) {

                 // TODO: I18n

                 JOptionPane.showMessageDialog(

                     null,

                     "The OCL Toolkit requires that:\n\n"

                     + "Class names have a capital first letter and\n"

                     + "Attribute or Operation names have "

                     + "a lower case first letter.",

                     "Require Correct name convention:",

                     JOptionPane.ERROR_MESSAGE);

                 // do not create a constraint:

                 return;

             }

             // null elements represent new constraints, which will be

             // added to the target the first time any actual editing

             // takes place.  This is done to ensure syntactical

             // correctness of constraints stored with the target.

             theMAlConstraints.add(null);

             fireConstraintAdded();

         }

         // TODO: - please add some javadoc - ugly classname also

         private class CR implements ConstraintRepresentation {

             /**

              * The constraint being represented.

              */

             private Object theMMcConstraint;

             /**

              * The constraint's index in the list of

              * constraints. Necessary only for new constraints, where

              * m_mcConstraint is still <tt>null</tt>.

              */

             private int theMNIdx = -1;

             public CR(Object mcConstraint, int nIdx) {

                 super();

                 theMMcConstraint = mcConstraint;

                 theMNIdx = nIdx;

             }

             public CR(int nIdx) {

                 this(null, nIdx);

             }

             /**

              * Get the name of the constraint.

              */

             public String getName() {

                 if (theMMcConstraint == null) {

                     return "newConstraint";

                 }

                 return Model.getFacade().getName(theMMcConstraint);

             }

             /**

              * Get the constraint's body.

              */

             public String getData() {

                 if (theMMcConstraint == null) {

                     return OCLUtil.getContextString(theMMmeiTarget);

                 }

                 return (String) Model.getFacade().getBody(

                         Model.getFacade().getBody(theMMcConstraint));

             }

             /**

              * Set the constraint's body text. For the exceptions the

              * detailed message must be human readable.

              *

              * @param sData the new body of the constraint

              *

              * @exception IllegalStateException if the constraint is

              *            not in a state to accept body changes.

              * @exception OclParserException if the specified constraint is not

              *     syntactically correct.

              * @exception OclTypeException if the specified constraint

              *            does not adhere by OCL type rules.

              */

             public void setData(String sData, EditingUtilities euHelper)

                 throws OclParserException, OclTypeException {

                 // Parse and check specified constraint.

                 OclTree tree = null;

                 try {

                     Object mmeContext = OCLUtil

                             .getInnerMostEnclosingNamespace(theMMmeiTarget);

                     try {

                         tree =

                             euHelper.parseAndCheckConstraint(

                                 sData,

                                 new ArgoFacade(mmeContext));

                     } catch (IOException ioe) {

                         // Ignored: Highly unlikely, and what would we

                         // do anyway?  log it

                         LOG.error("problem parsing And Checking Constraints",

                                    ioe);

                         return;

                     }

                     // Split constraint body, if user wants us to

                     if (euHelper.getDoAutoSplit()) {

                         List lConstraints = euHelper.splitConstraint(tree);

                         if (lConstraints.size() > 0) {

                             removeConstraintAt(theMNIdx);

                             for (Iterator i = lConstraints.iterator();

                                  i.hasNext();) {

                                 OclTree ocltCurrent = (OclTree) i.next();

                                 Object mc =

                                     Model.getCoreFactory()

                                         .createConstraint();

                                 Model.getCoreHelper().setName(mc, ocltCurrent

                                     .getConstraintName());

                                 Model.getCoreHelper().setBody(mc,

                                         Model.getDataTypesFactory()

                                                 .createBooleanExpression(

                                                         "OCL",

                                                         ocltCurrent

                                                         .getExpression()));

                                 Model.getCoreHelper().addConstraint(

                                         theMMmeiTarget,

                                         mc);

                                 // the constraint _must_ be owned by a namespace

                                 if (Model.getFacade().getNamespace(

                                         theMMmeiTarget)

                                         != null) {

                                     Model.getCoreHelper().addOwnedElement(

                                             Model.getFacade().getNamespace(

                                                     theMMmeiTarget),

                                             mc);

                                 } else if (Model.getFacade().getNamespace(

                                         mmeContext) != null) {

                                     Model.getCoreHelper().addOwnedElement(

                                             Model.getFacade().getNamespace(

                                                     mmeContext),

                                             theMMcConstraint);

                                 }

                                 theMAlConstraints.add(mc);

                                 fireConstraintAdded();

                             }

                             return;

                         }

                     }

                     // Store constraint body

                     Object mcOld = null;

                     if (theMMcConstraint == null) {

                         // New constraint, first time setData is called

                         theMMcConstraint =

                             Model.getCoreFactory().createConstraint();

                         Model.getCoreHelper().setName(

                                 theMMcConstraint,

                                 "newConstraint");

                         Model.getCoreHelper().setBody(

                                 theMMcConstraint,

                                 Model.getDataTypesFactory()

                                         .createBooleanExpression("OCL", sData));

                         Model.getCoreHelper().addConstraint(theMMmeiTarget,

                                 theMMcConstraint);

                         // the constraint _must_ be owned by a namespace

                         Object targetNamespace =

                             Model.getFacade().getNamespace(theMMmeiTarget);

                         Object contextNamespace =

                             Model.getFacade().getNamespace(mmeContext);

                         if (targetNamespace != null) {

                             Model.getCoreHelper().addOwnedElement(

                                     targetNamespace,

                                     theMMcConstraint);

                         } else if (contextNamespace != null) {

                             Model.getCoreHelper().addOwnedElement(

                                     contextNamespace,

                                     theMMcConstraint);

                         }

                         theMAlConstraints.set(theMNIdx, theMMcConstraint);

                     } else {

                         mcOld = Model.getCoreFactory().createConstraint();

                         Model.getCoreHelper().setName(

                                 mcOld,

                                 Model.getFacade().getName(theMMcConstraint));

                         Model.getCoreHelper().setBody(

                                 mcOld,

                                 Model.getDataTypesFactory()

                                         .createBooleanExpression("OCL",

                                                 (String) Model.getFacade()

                                                         .getBody(

                                                 Model.getFacade().getBody(

                                                         theMMcConstraint))));

                         Model.getCoreHelper().setBody(theMMcConstraint,

                                 Model.getDataTypesFactory()

                                         .createBooleanExpression("OCL", sData));

                     }

                     fireConstraintDataChanged(theMNIdx, mcOld,

                             theMMcConstraint);

                 } catch (OclTypeException pe) {

                     LOG.warn("There was some sort of OCL Type problem", pe);

                     throw pe;

                 } catch (OclParserException pe1) {

                     LOG.warn("Could not parse the constraint", pe1);

                     throw pe1;

                 } catch (OclException oclExc) {

                     // a runtime exception that occurs when some

                     // internal test fails

                     LOG.warn("There was some unidentified problem");

                     throw oclExc;

                 }

             }

             /**

              * Set the constraint's name.

              */

             public void setName(

                 final String sName,

                 final EditingUtilities euHelper) {

                 if (theMMcConstraint != null) {

                     // Check name for consistency with spec

                     if (!euHelper.isValidConstraintName(sName)) {

                         throw new IllegalArgumentException(

                                 "Please specify a valid name.");

                     }

                     // Set name

                     Object mcOld =

                         Model.getCoreFactory().createConstraint();

                     Model.getCoreHelper().setName(mcOld,

                             Model.getFacade().getName(theMMcConstraint));

                     Object constraintBody =

                         Model.getFacade().getBody(theMMcConstraint);

                     Model.getCoreHelper().setBody(mcOld,

                             Model.getDataTypesFactory()

                                 .createBooleanExpression(

                                         "OCL",

                                         (String) Model.getFacade().getBody(

                                                 constraintBody)));

                     Model.getCoreHelper().setName(theMMcConstraint, sName);

                     fireConstraintNameChanged(theMNIdx, mcOld,

                             theMMcConstraint);

                     // Also set name in constraint body -- Added 03/14/2001

                     try {

                         OclTree tree = null;

                         Object mmeContext = OCLUtil

                                 .getInnerMostEnclosingNamespace(theMMmeiTarget);

                         constraintBody =

                             Model.getFacade().getBody(theMMcConstraint);

                         tree =

                             euHelper.parseAndCheckConstraint(

                                 (String) Model.getFacade().getBody(

                                         constraintBody),

                                 new ArgoFacade(mmeContext));

                         if (tree != null) {

                             tree.apply(new DepthFirstAdapter() {

                                 private int nameID = 0;

                                 public void caseAConstraintBody(

                                         AConstraintBody node) {

                                     // replace name

                                     if (nameID == 0) {

                                         node.setName(new TName(sName));

                                     } else {

                                         node.setName(new TName(

                                                 sName + "_" + nameID));

                                     }

                                     nameID++;

                                 }

                             });

                             setData(tree.getExpression(), euHelper);

                         }

                     } catch (Throwable t) {

                         // OK, so that didn't work out... Just ignore

                         // any problems and don't set the name in the

                         // constraint body better had log it.

                         LOG.error("some unidentified problem", t);

                     }

                 } else {

                     throw new IllegalStateException(

                         "Please define and submit a constraint body first.");

                 }

             }

         }

         /**

          * Create a representation adapter for the given constraint.

          */

         private CR representationFor(int nIdx) {

             if ((nIdx < 0) || (nIdx >= theMAlConstraints.size())) {

                 return null;

             }

             Object mc = theMAlConstraints.get(nIdx);

             if (mc != null) {

                 return new CR(mc, nIdx);

             }

             return new CR(nIdx);

         }

         /**

          * Add a listener to be informed of changes in the model.

          *

          * @param ccl the new listener

          */

         public void addConstraintChangeListener(ConstraintChangeListener ccl) {

             theMEllListeners.add(ConstraintChangeListener.class, ccl);

         }

         /**

          * Remove a listener to be informed of changes in the model.

          *

          * @param ccl the listener to be removed

          */

         public void removeConstraintChangeListener(

                 ConstraintChangeListener ccl) {

             theMEllListeners.remove(ConstraintChangeListener.class, ccl);

         }

         protected void fireConstraintRemoved(

                 Object mc, int nIdx) {

             // Guaranteed to return a non-null array

             Object[] listeners = theMEllListeners.getListenerList();

             ConstraintChangeEvent cce = null;

             // Process the listeners last to first, notifying

             // those that are interested in this event

             for (int i = listeners.length - 2; i >= 0; i -= 2) {

                 if (listeners[i] == ConstraintChangeListener.class) {

                     // Lazily create the event:

                     if (cce == null) {

                         cce = new ConstraintChangeEvent(

                             this,

                             nIdx,

                             new CR(mc, nIdx),

                             null);

                     }

                     ((ConstraintChangeListener) listeners[i + 1])

                         .constraintRemoved(cce);

                 }

             }

         }

         protected void fireConstraintAdded() {

             // Guaranteed to return a non-null array

             Object[] listeners = theMEllListeners.getListenerList();

             ConstraintChangeEvent cce = null;

             // Process the listeners last to first, notifying

             // those that are interested in this event

             for (int i = listeners.length - 2; i >= 0; i -= 2) {

                 if (listeners[i] == ConstraintChangeListener.class) {

                     // Lazily create the event:

                     if (cce == null) {

                         int nIdx = theMAlConstraints.size() - 1;

                         cce =

                             new ConstraintChangeEvent(

                                     this,

                                     nIdx,

                                     null,

                                     representationFor(nIdx));

                     }

                     ((ConstraintChangeListener) listeners[i + 1])

                         .constraintAdded(cce);

                 }

             }

         }

         protected void fireConstraintDataChanged(

                          int nIdx,

                          Object mcOld,

                          Object mcNew) {

             // Guaranteed to return a non-null array

             Object[] listeners = theMEllListeners.getListenerList();

             ConstraintChangeEvent cce = null;

             // Process the listeners last to first, notifying

             // those that are interested in this event

             for (int i = listeners.length - 2; i >= 0; i -= 2) {

                 if (listeners[i] == ConstraintChangeListener.class) {

                     // Lazily create the event:

                     if (cce == null) {

                         cce = new ConstraintChangeEvent(

                             this,

                             nIdx,

                             new CR(mcOld, nIdx),

                             new CR(mcNew, nIdx));

                     }

                     ((ConstraintChangeListener) listeners[i + 1])

                         .constraintDataChanged(cce);

                 }

             }

         }

         protected void fireConstraintNameChanged(

                          int nIdx,

                          Object mcOld,

                          Object mcNew) {

             // Guaranteed to return a non-null array

             Object[] listeners = theMEllListeners.getListenerList();

             ConstraintChangeEvent cce = null;

             // Process the listeners last to first, notifying

             // those that are interested in this event

             for (int i = listeners.length - 2; i >= 0; i -= 2) {

                 if (listeners[i] == ConstraintChangeListener.class) {

                     // Lazily create the event:

                     if (cce == null) {

                         cce = new ConstraintChangeEvent(

                             this,

                             nIdx,

                             new CR(mcOld, nIdx),

                             new CR(mcNew, nIdx));

                     }

                     ((ConstraintChangeListener) listeners[i + 1])

                         .constraintNameChanged(cce);

                 }

             }

         }

     }

     /*

      * @see org.argouml.ui.targetmanager.TargetListener#targetAdded(

      *         org.argouml.ui.targetmanager.TargetEvent)

      */

     public void targetAdded(TargetEvent e) {

         // TODO: Why is this ignored? - tfm - 20070110

     }

     /*

      * @see org.argouml.ui.targetmanager.TargetListener#targetRemoved(

      *         org.argouml.ui.targetmanager.TargetEvent)

      */

     public void targetRemoved(TargetEvent e) {

         setTarget(e.getNewTarget());

     }

     /*

      * @see org.argouml.ui.targetmanager.TargetListener#targetSet(

      *         org.argouml.ui.targetmanager.TargetEvent)

      */

     public void targetSet(TargetEvent e) {

         setTarget(e.getNewTarget());

     }

     /*

      * @see java.awt.event.ComponentListener#componentShown(java.awt.event.ComponentEvent)

      */

     public void componentShown(ComponentEvent e) {

         // Update our model with our saved target

         setTargetInternal(mMmeiTarget);

     }

     /*

      * @see java.awt.event.ComponentListener#componentHidden(java.awt.event.ComponentEvent)

      */

     public void componentHidden(ComponentEvent e) {

         // We have no model event listeners, so no need to do anything

     }

     public void componentMoved(ComponentEvent e) {

         // ignored

     }

     public void componentResized(ComponentEvent e) {

         // ignored

     }

 }