/* $Id: TabProps.java 18360 2010-05-03 21:17:15Z bobtarling $

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

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

  *    bobtarling

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

  *

  * 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.util.Enumeration;

 import java.util.Hashtable;

 import javax.swing.JPanel;

 import javax.swing.event.EventListenerList;

 import org.apache.log4j.Logger;

 import org.argouml.application.api.AbstractArgoJPanel;

 import org.argouml.cognitive.Critic;

 import org.argouml.model.Model;

 import org.argouml.swingext.UpArrowIcon;

 import org.argouml.ui.TabModelTarget;

 import org.argouml.ui.targetmanager.TargetEvent;

 import org.argouml.ui.targetmanager.TargetListener;

 import org.argouml.ui.targetmanager.TargetManager;

 import org.argouml.uml.diagram.ArgoDiagram;

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

 import org.tigris.gef.base.Diagram;

 import org.tigris.gef.presentation.Fig;

 import org.tigris.gef.presentation.FigText;

 import org.tigris.swidgets.Horizontal;

 import org.tigris.swidgets.Orientable;

 import org.tigris.swidgets.Orientation;

 /**

  * This is the tab on the details panel (DetailsPane) that holds the property

  * panel. On change of target, the property panel in TabProps is changed.

  * <p>

  * With the introduction of the TargetManager, this class holds its original

  * power of controlling its target. The property panels (subclasses of

  * PropPanel) for which this class is the container are being registered as

  * TargetListeners in the setTarget method of this class. They are not

  * registered with TargetManager but with this class to prevent race-conditions

  * while firing TargetEvents from TargetManager.

  */

 public class TabProps

     extends AbstractArgoJPanel

     implements TabModelTarget {

     /**

      * Logger.

      */

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

     private JPanel blankPanel = new JPanel();

     private Hashtable<Class, JPanel> panels = 

         new Hashtable<Class, JPanel>();

     private JPanel lastPanel;

     private String panelClassBaseName = "";

     /**

      * The panel currently displayed in center

      */

     private JPanel currentPanel;

     private Object target;

     /**

      * The list with targetlisteners, these are the property panels

      * managed by TabProps.

      * It should only contain one listener at a time.

      */

     private EventListenerList listenerList = new EventListenerList();

     /**

      * The constructor.

      *

      */

     public TabProps() {

         this("tab.properties", "ui.PropPanel");

     }

     /**

      * The constructor.

      *

      * @param tabName the name of the tab

      * @param panelClassBase the panel class base

      */

     public TabProps(String tabName, String panelClassBase) {

         super(tabName);

         setIcon(new UpArrowIcon());

         // TODO: This should be managed by the DetailsPane TargetListener - tfm

         // remove the following line

         TargetManager.getInstance().addTargetListener(this);

         setOrientation(Horizontal.getInstance());

         panelClassBaseName = panelClassBase;

         setLayout(new BorderLayout());

     }

     /**

      * Set the orientation of the property panel.

      *

      * @param orientation the new orientation for this property panel

      *

      * @see org.tigris.swidgets.Orientable#setOrientation(org.tigris.swidgets.Orientation)

      */

     @Override

     public void setOrientation(Orientation orientation) {

         super.setOrientation(orientation);

         Enumeration pps = panels.elements();

         while (pps.hasMoreElements()) {

             Object o = pps.nextElement();

             if (o instanceof Orientable) {

                 Orientable orientable = (Orientable) o;

                 orientable.setOrientation(orientation);

             }

         }

     }

     /**

      * Adds a property panel to the internal list. This allows a plugin to

      * add / register a new property panel at run-time.

      * This property panel will then

      * be displayed in the detatils pane whenever an element

      * of the given metaclass is selected.

      *

      * @param clazz the metaclass whose details show be displayed

      *          in the property panel p

      * @param panel an instance of the property panel for the metaclass m

      *

      */

     public void addPanel(Class clazz, PropPanel panel) {

         panels.put(clazz, panel);

     }

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

     // accessors

     /**

      * Sets the target of the property panel. The given target t

      * may either be a Diagram or a modelelement. If the target

      * given is a Fig, a check is made if the fig has an owning

      * modelelement and occurs on the current diagram.

      * If so, that modelelement is the target.

      *

      * @deprecated As of ArgoUml version 0.13.5,

      *         the visibility of this method will change in the future,

      *         replaced by {@link org.argouml.ui.targetmanager.TargetManager}.

      *         TODO: MVW: I think this should not be deprecated.

      *

      * @param target the new target

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

      */

     @Deprecated

     public void setTarget(Object target) {

         // targets ought to be UML objects or diagrams

         LOG.info("setTarget: there are "

                 + TargetManager.getInstance().getTargets().size()

                 + " targets");

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

         if (!(target == null || Model.getFacade().isAUMLElement(target) 

                 || target instanceof ArgoDiagram

                 // TODO Improve extensibility of this!

                 || target instanceof Critic)) {

             target = null;

         }

         if (lastPanel != null) {

             remove(lastPanel);

             if (lastPanel instanceof TargetListener) {

                 // TODO: We should assert this never happens before removing

                 // panels should control their own listeners

                 removeTargetListener((TargetListener) lastPanel);

             }

         }

         // TODO: No need to do anything if we're not visible      

 //        if (!isVisible()) {

 //            return;

 //        }

         this.target = target;

         if (target == null) {

             add(blankPanel, BorderLayout.CENTER);

             validate();

             repaint();

             lastPanel = blankPanel;

         } else {

             JPanel newPanel = findPanelFor(target);

             if (newPanel != null && newPanel instanceof TabModelTarget) {

                 addTargetListener((TabModelTarget) newPanel);

             }

             if (currentPanel != null) {

                 remove(currentPanel);

                 currentPanel = null;

             }

             if (newPanel != null) {

                 currentPanel = newPanel;

             } else {

                 currentPanel = blankPanel;

                 lastPanel = blankPanel;

             }

             add(currentPanel);

             validate();

             repaint();

         }

     }

     /*

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

      */

     public void refresh() {

         setTarget(TargetManager.getInstance().getTarget());

     }

     /**

      * Find the correct properties panel for the target.

      *

      * @param trgt the target class

      * @return the tab panel

      */

     private JPanel findPanelFor(Object trgt) {

         // TODO: No test coverage for this or createPropPanel? - tfm

         JPanel panel = createPropPanel(trgt);

         if (panel != null) {

             LOG.debug("Factory created " + panel.getClass().getName()

                     + " for " + trgt.getClass().getName());

             panels.put(trgt.getClass(), panel);

             return panel;

         }

         LOG.error("Failed to create a prop panel for : " + trgt);

         return null;

     }

     /**

      * A factory method to create a PropPanel for a particular target (Diagram,

      * UML Element or GEF Fig).

      *

      * @param targetObject the target object

      * @return A new prop panel to display any model element of the given type

      */

     private JPanel createPropPanel(Object targetObject) {

         JPanel propPanel = null;

         for (PropPanelFactory factory

                 : PropPanelFactoryManager.getFactories()) {

             propPanel = factory.createPropPanel(targetObject);

             if (propPanel != null) return propPanel;

         }        

         /* This does not work (anymore/yet?), 

          * since we never have a FigText here: */

         if (targetObject instanceof FigText) {

             propPanel = new PropPanelString();

         }

         if (propPanel instanceof Orientable) {

             ((Orientable) propPanel).setOrientation(getOrientation());

         }

         // TODO: We shouldn't need this as well as the above.

         if (propPanel instanceof PropPanel) {

             ((PropPanel) propPanel).setOrientation(getOrientation());

         }

         return propPanel;

     }

     /**

      * @return the name

      */

     protected String getClassBaseName() {

         return panelClassBaseName;

     }

     /**

      * Returns the current target.

      * @deprecated As of ArgoUml version 0.13.5,

      * the visibility of this method will change in the future, replaced by

      * {@link org.argouml.ui.targetmanager.TargetManager#getTarget()

      * TargetManager.getInstance().getTarget()}.

      * TODO: MVW: I think this should not be deprecated.

      *

      * @return the target

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

      */

     @Deprecated

     public Object getTarget() {

         return target;

     }

     /**

      * Determines if the property panel should be enabled.

      * The property panel should always be enabled if the

      * target is an instance of a modelelement or an argodiagram.

      * If the target given is a Fig, a check is made if the fig

      * has an owning modelelement and occurs on

      * the current diagram. If so, that modelelement is the target.

      * @param target the target

      * @return true if property panel should be enabled

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

      */

     public boolean shouldBeEnabled(Object target) {

         if (target instanceof Fig) {

             target = ((Fig) target).getOwner();

         }

         // TODO: this should be more extensible... may be only 

         // "findPanelFor(target)" if there is a panel why not show it?

         return ((target instanceof Diagram || Model.getFacade().isAUMLElement(

                 target)) || target instanceof Critic

                 && findPanelFor(target) != null);

     }

     /*

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

      */

     public void targetAdded(TargetEvent targetEvent) {

         setTarget(TargetManager.getInstance().getSingleTarget());

         fireTargetAdded(targetEvent);

         if (listenerList.getListenerCount() > 0) {

             validate();

             repaint();

         }

     }

     /*

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

      */

     public void targetRemoved(TargetEvent targetEvent) {

         setTarget(TargetManager.getInstance().getSingleTarget());

         fireTargetRemoved(targetEvent);

         validate();

         repaint();

     }

     /*

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

      */

     public void targetSet(TargetEvent targetEvent) {

         setTarget(TargetManager.getInstance().getSingleTarget());

         fireTargetSet(targetEvent);

         validate();

         repaint();

     }

     /**

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

     }

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

             }

         }

     }

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

             }

         }

     }

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

             }

         }

     }

 } /* end class TabProps */