/* $Id: TabStyle.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:

  *    thn

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

  *

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

  */

 // Copyright (c) 1996-2008 The Regents of the University of California. All

 // Rights Reserved. Permission to use, copy, modify, and distribute this

 // software and its documentation without fee, and without a written

 // agreement is hereby granted, provided that the above copyright notice

 // and this paragraph appear in all copies. This software program and

 // documentation are copyrighted by The Regents of the University of

 // California. The software program and documentation are supplied "AS

 // IS", without any accompanying services from The Regents. The Regents

 // does not warrant that the operation of the program will be

 // uninterrupted or error-free. The end-user understands that the program

 // was developed for research purposes and is advised not to rely

 // exclusively on the program for any reason. IN NO EVENT SHALL THE

 // UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,

 // SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS,

 // ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF

 // THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF

 // SUCH DAMAGE. THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY

 // WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE

 // PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF

 // CALIFORNIA HAS NO OBLIGATIONS TO PROVIDE MAINTENANCE, SUPPORT,

 // UPDATES, ENHANCEMENTS, OR MODIFICATIONS.

 package org.argouml.uml.ui;

 import java.awt.BorderLayout;

 import java.beans.PropertyChangeEvent;

 import java.beans.PropertyChangeListener;

 import java.util.Collection;

 import java.util.Hashtable;

 import javax.swing.JPanel;

 import javax.swing.SwingUtilities;

 import javax.swing.event.EventListenerList;

 import org.apache.log4j.Logger;

 import org.argouml.application.api.AbstractArgoJPanel;

 import org.argouml.kernel.DelayedChangeNotify;

 import org.argouml.kernel.DelayedVChangeListener;

 import org.argouml.kernel.Project;

 import org.argouml.kernel.ProjectManager;

 import org.argouml.model.Model;

 import org.argouml.swingext.UpArrowIcon;

 import org.argouml.ui.StylePanel;

 import org.argouml.ui.TabFigTarget;

 import org.argouml.ui.targetmanager.TargetEvent;

 import org.argouml.ui.targetmanager.TargetListener;

 import org.argouml.uml.diagram.ArgoDiagram;

 import org.argouml.uml.diagram.DiagramUtils;

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

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

 import org.argouml.uml.util.namespace.Namespace;

 import org.argouml.uml.util.namespace.StringNamespace;

 import org.argouml.uml.util.namespace.StringNamespaceElement;

 import org.tigris.gef.presentation.Fig;

 import org.tigris.gef.presentation.FigEdge;

 /**

  * Provides support for changing the appearance of a diagram element. For each

  * class of a diagram element, the TabStyle class attempts to find an according

  * class of StylePanel which contains the attributes to be modified in terms of

  * style.

  * <p>

  * The constructor of TabStyle takes an array argument which contains possible

  * base names for these style panels, or by default StylePanel and SP,

  * alternating between these two prefixes and the namespace of the Fig class or

  * <code>org.argouml.ui</code>. With this configuration, the stylepanel for

  * e.g. <code>org.argouml.uml.diagram.static.structure.ui.FigClass</code>,

  * will be looked at in the following places:

  * <ul>

  * <li>org.argouml.uml.diagram.static_structure.ui.StylePanelFigClass

  * <li>org.argouml.uml.diagram.static_structure.ui.SPFigClass

  * <li>org.argouml.ui.StylePanelFigClass

  * <li>org.argouml.ui.SPFigClass

  * </ul>

  * It continues to traverse the superclass structure until a matching class has

  * been found, e.g.

  * <ul>

  * <li>org.argouml.uml.diagram.ui.StylePanelFigNodeModelElement

  * <li>org.argouml.uml.diagram.ui.SPFigNodeModelElement

  * <li>org.argouml.ui.StylePanelFigNodeModelElement

  * <li>org.argouml.ui.SPFigNodeModelElement

  * </ul>

  * If a stylepanel had been found, it will be stored in a cache.<p>

  *

  * According the decision taken in issue 502, this tab is renamed "Presentation"

  * for the user. And the Presentation tab shall contain presentation options,

  * and no semantic UML properties (which belong in the "Properties" panel).

  * In contrast, the diagram pop-up menu for a model element

  * may access both presentation options as well as semantic UML properties. <p>

  *

  * Note also that the semantic properties of a UML model element exist in one

  * copy only but the presentation options exist in one copy per diagram

  * that the model element is showing in. E.g. a class could have

  * attributes hidden in one diagram and showing in another. So, for the user

  * it would be very logical to separate these 2 kinds of settings

  * on different tabs.

  *

  */

 public class TabStyle extends AbstractArgoJPanel implements TabFigTarget,

         PropertyChangeListener, DelayedVChangeListener {

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

     private Fig target;

     private boolean shouldBeEnabled = false;

     private JPanel blankPanel = new JPanel();

     private Hashtable<Class, TabFigTarget> panels = 

         new Hashtable<Class, TabFigTarget>();

     private JPanel lastPanel = null;

     /**

      * The stylepanel shown by the tab style.

      */

     private StylePanel stylePanel = null;

     private String[] stylePanelNames;

     private EventListenerList listenerList = new EventListenerList();

     /**

      * The constructor.

      *

      * @param tabName the name of the tab

      * @param spn style panel names

      */

     public TabStyle(String tabName, String[] spn) {

         super(tabName);

         this.stylePanelNames = spn;

         setIcon(new UpArrowIcon());

         setLayout(new BorderLayout());

     }

     /**

      * Construct a default stylepanel with basenames <code>StylePanel</code>

      * and <code>SP</code>, resulting in the lookup order described above.

      */

     public TabStyle() {

         this("tab.style", new String[] {"StylePanel", "SP"});

     }

     /**

      * Adds a style panel to the internal list. This allows a plugin to add and

      * register a new style panel at run-time. This property style will then be

      * displayed in the details pane whenever an element of the given metaclass

      * is selected.

      *

      * @param c

      *            the metaclass whose details show be displayed in the property

      *            panel p

      * @param s

      *            an instance of the style panel for the metaclass m

      */

     public void addPanel(Class c, StylePanel s) {

         panels.put(c, s);

     }

     /**

      * Sets the target of the style tab.

      * 

      * @param t

      *            is the new target

      */

     public void setTarget(Object t) {

         if (target != null) {

             target.removePropertyChangeListener(this);

             if (target instanceof FigEdge) {

                 // In this case, the bounds are determined by the FigEdge

                 ((FigEdge) target).getFig().removePropertyChangeListener(this);

             }

             if (target instanceof FigAssociationClass) {

                 // In this case, the bounds (of the box) are determined 

                 // by the FigClassAssociationClass

                 FigClassAssociationClass ac = 

                     ((FigAssociationClass) target).getAssociationClass();

                 // A newly created AssociationClass may not have all its parts

                 // created by the time we are called

                 if (ac != null) {

                     ac.removePropertyChangeListener(this);

                 }

             }

         }

         // TODO: Defer most of this work if the panel isn't visible - tfm

         // the responsibility of determining if the given target is a

         // correct one for this tab has been moved from the

         // DetailsPane to the member tabs of the details pane. Reason for

         // this is that the details pane is configurable and cannot

         // know what's the correct target for some tab.

         if (!(t instanceof Fig)) {

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

                 ArgoDiagram diagram = DiagramUtils.getActiveDiagram();

                 if (diagram != null) {

                     t = diagram.presentationFor(t);

                 }

                 if (!(t instanceof Fig)) {

                     Project p = ProjectManager.getManager().getCurrentProject();

                     Collection col = p.findFigsForMember(t);

                     if (col == null || col.isEmpty()) {

                         return;

                     }

                     t = col.iterator().next();

                 }

                 if (!(t instanceof Fig)) {

                     return;

                 }

             } else {

                 return;

             }

         }

         target = (Fig) t;

         if (target != null) {

             target.addPropertyChangeListener(this);

             // TODO: This shouldn't know about the specific type of Fig that 

             // is being displayed.  That couples it too strongly to things it

             // shouldn't need to know about - tfm - 20070924

             if (target instanceof FigEdge) {

                 // In this case, the bounds are determined by the FigEdge

                 ((FigEdge) target).getFig().addPropertyChangeListener(this);

             }

             if (target instanceof FigAssociationClass) {

                 // In this case, the bounds (of the box) are determined 

                 // by the FigClassAssociationClass

                 FigClassAssociationClass ac = 

                     ((FigAssociationClass) target).getAssociationClass();

                 // A newly created AssociationClass may not have all its parts

                 // created by the time we are called

                 if (ac != null) {

                     ac.addPropertyChangeListener(this);

                 }

             }

         }

         if (lastPanel != null) {

             remove(lastPanel);

             if (lastPanel instanceof TargetListener) {

                 removeTargetListener((TargetListener) lastPanel);

             }

         }

         if (t == null) {

             add(blankPanel, BorderLayout.NORTH);

             shouldBeEnabled = false;

             lastPanel = blankPanel;

             return;

         }

         shouldBeEnabled = true;

         stylePanel = null;

         Class targetClass = t.getClass();

         stylePanel = findPanelFor(targetClass);

         if (stylePanel != null) {

             removeTargetListener(stylePanel);

             addTargetListener(stylePanel);

             stylePanel.setTarget(target);

             add(stylePanel, BorderLayout.NORTH);

             shouldBeEnabled = true;

             lastPanel = stylePanel;

         } else {

             add(blankPanel, BorderLayout.NORTH);

             shouldBeEnabled = false;

             lastPanel = blankPanel;

         }

         validate();

         repaint();

     }

     /*

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

      */

     public void refresh() {

         setTarget(target);

     }

     /**

      * Find the stylepanel for a given target class.

      *

      * @param targetClass

      *            the target class

      * @return a Stylepanel object or <code>null</code> on error

      */

     public StylePanel findPanelFor(Class targetClass) {

         Class panelClass = null;

         TabFigTarget p = panels.get(targetClass);

         if (p == null) {

             Class newClass = targetClass;

             while (newClass != null && panelClass == null) {

                 panelClass = panelClassFor(newClass);

                 newClass = newClass.getSuperclass();

             }

             if (panelClass == null) {

                 return null;

             }

             try {

                 p = (TabFigTarget) panelClass.newInstance();

             } catch (IllegalAccessException ignore) {

                 LOG.error(ignore);

                 return null;

             } catch (InstantiationException ignore) {

                 LOG.error(ignore);

                 return null;

             }

             panels.put(targetClass, p);

         }

         LOG.debug("found style for " + targetClass.getName() + "("

                 + p.getClass() + ")");

         return (StylePanel) p;

     }

     /**

      * Get the class for the required stylepanel.

      *

      * @param targetClass the class of the current selected target.

      * @return the panel class for the class given or

      * null if none available.

      */

     public Class panelClassFor(Class targetClass) {

         if (targetClass == null) {

             return null;

         }

         StringNamespace classNs = (StringNamespace) StringNamespace

                 .parse(targetClass);

         StringNamespace baseNs = (StringNamespace) StringNamespace.parse(

                 "org.argouml.ui.", Namespace.JAVA_NS_TOKEN);

         StringNamespaceElement targetClassElement =

                 (StringNamespaceElement) classNs.peekNamespaceElement();

         LOG.debug("Attempt to find style panel for: " + classNs);

         classNs.popNamespaceElement();

         String[] bases = new String[] {

                 classNs.toString(), baseNs.toString() 

         };

         for (String stylePanelName : stylePanelNames) {

             for (String baseName : bases) {

                 String name = baseName + "." + stylePanelName

                         + targetClassElement;

                 Class cls = loadClass(name);

                 if (cls != null) {

                     return cls;

                 }

             }

         }

         return null;

     }

     private Class loadClass(String name) {

         try {

             Class cls = Class.forName(name);

             return cls;

         } catch (ClassNotFoundException ignore) {

             LOG.debug("ClassNotFoundException. Could not find class:"

                     + name);

         }

         return null;

     }

     /**

      * @return the style panel names

      */

     protected String[] getStylePanelNames() {

         return stylePanelNames;

     }

     /*

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

      */

     public Object getTarget() {

         return target;

     }

     /*

      * @see org.argouml.ui.TabTarget#shouldBeEnabled(java.lang.Object)

      */

     public boolean shouldBeEnabled(Object targetItem) {

         if (!(targetItem instanceof Fig)) {

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

                 ArgoDiagram diagram = DiagramUtils.getActiveDiagram();

                 if (diagram == null) {

                     shouldBeEnabled = false;

                     return false;

                 }

                 Fig f = diagram.presentationFor(targetItem);

                 if (f == null) {

                     shouldBeEnabled = false;

                     return false;

                 }

                 targetItem = f;

             } else {

                 shouldBeEnabled = false;

                 return false;

             }

         }

         shouldBeEnabled = true;

         // TODO: It would be better to defer this initialization until the panel

         // actually needs to be displayed. Perhaps optimistically always return

         // true and figure out later if we've got something to display - tfm -

         // 20070110

         Class targetClass = targetItem.getClass();

         stylePanel = findPanelFor(targetClass);

         targetClass = targetClass.getSuperclass();

         if (stylePanel == null) {

             shouldBeEnabled = false;

         }

         return shouldBeEnabled;

     }

     /*

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

      */

     public void propertyChange(PropertyChangeEvent pce) {

         DelayedChangeNotify delayedNotify = new DelayedChangeNotify(this, pce);

         SwingUtilities.invokeLater(delayedNotify);

     }

     /*

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

      */

     public void delayedVetoableChange(PropertyChangeEvent pce) {

         if (stylePanel != null) {

             stylePanel.refresh(pce);

         }

     }

     /*

      * @see TargetListener#targetAdded(TargetEvent)

      */

     public void targetAdded(TargetEvent e) {

         setTarget(e.getNewTarget());

         fireTargetAdded(e);

     }

     /*

      * @see TargetListener#targetRemoved(TargetEvent)

      */

     public void targetRemoved(TargetEvent e) {

         // how to handle empty target lists?

         // probably the TabProps should only show an empty pane in that

         // case

         setTarget(e.getNewTarget());

         fireTargetRemoved(e);

     }

     /*

      * @see TargetListener#targetSet(TargetEvent)

      */

     public void targetSet(TargetEvent e) {

         setTarget(e.getNewTarget());

         fireTargetSet(e);

     }

     /**

      * Adds a listener.

      *

      * @param listener

      *            the listener to add

      */

     private void addTargetListener(TargetListener listener) {

         listenerList.add(TargetListener.class, listener);

     }

     /**

      * Removes a target listener.

      *

      * @param listener

      *            the listener to remove

      */

     private void removeTargetListener(TargetListener listener) {

         listenerList.remove(TargetListener.class, listener);

     }

     /**

      * @param targetEvent

      */

     private void fireTargetSet(TargetEvent targetEvent) {

         //          Guaranteed to return a non-null array

         Object[] listeners = listenerList.getListenerList();

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

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

                 // Lazily create the event:

                 ((TargetListener) listeners[i + 1]).targetSet(targetEvent);

             }

         }

     }

     /**

      * @param targetEvent

      */

     private void fireTargetAdded(TargetEvent targetEvent) {

         // Guaranteed to return a non-null array

         Object[] listeners = listenerList.getListenerList();

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

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

                 // Lazily create the event:

                 ((TargetListener) listeners[i + 1]).targetAdded(targetEvent);

             }

         }

     }

     /**

      * @param targetEvent

      */

     private void fireTargetRemoved(TargetEvent targetEvent) {

         // Guaranteed to return a non-null array

         Object[] listeners = listenerList.getListenerList();

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

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

                 // Lazily create the event:

                 ((TargetListener) listeners[i + 1]).targetRemoved(targetEvent);

             }

         }

     }

 }