/* $Id: TabDiagram.java 17865 2010-01-12 20:45:26Z 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-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.diagram.ui;

 import java.awt.BorderLayout;

 import java.awt.Graphics;

 import java.awt.Graphics2D;

 import java.awt.RenderingHints;

 import java.awt.event.MouseEvent;

 import java.beans.PropertyChangeEvent;

 import java.beans.PropertyChangeListener;

 import java.util.ArrayList;

 import java.util.Arrays;

 import java.util.List;

 import java.util.Vector;

 import javax.swing.JComponent;

 import javax.swing.JPanel;

 import javax.swing.JToolBar;

 import javax.swing.SwingUtilities;

 import javax.swing.border.EtchedBorder;

 import org.apache.log4j.Logger;

 import org.argouml.application.api.AbstractArgoJPanel;

 import org.argouml.application.api.Argo;

 import org.argouml.configuration.Configuration;

 import org.argouml.ui.TabModelTarget;

 import org.argouml.ui.targetmanager.TargetEvent;

 import org.argouml.ui.targetmanager.TargetManager;

 import org.argouml.uml.diagram.ArgoDiagram;

 import org.argouml.uml.ui.ActionCopy;

 import org.argouml.uml.ui.ActionCut;

 import org.tigris.gef.base.Diagram;

 import org.tigris.gef.base.Editor;

 import org.tigris.gef.base.FigModifyingMode;

 import org.tigris.gef.base.Globals;

 import org.tigris.gef.base.LayerManager;

 import org.tigris.gef.base.ModeSelect;

 import org.tigris.gef.event.GraphSelectionEvent;

 import org.tigris.gef.event.GraphSelectionListener;

 import org.tigris.gef.event.ModeChangeEvent;

 import org.tigris.gef.event.ModeChangeListener;

 import org.tigris.gef.graph.GraphModel;

 import org.tigris.gef.graph.presentation.JGraph;

 import org.tigris.gef.presentation.Fig;

 import org.tigris.toolbar.ToolBarFactory;

 /**

  * The TabDiagram is the tab in the multieditorpane that holds a diagram. The

  * TabDiagram consists of a JGraph (with the figs) and a toolbar.

  * It used to be possible (in past versions of ArgoUML)

  * to spawn objects of this class into a dialog via the spawn method of its

  * parent.

  * <p>

  * NOTE: This tab is unlike the others in that it acts as a bridge to forward

  * received Diagram events to the TargetManager.  (Not sure if this 

  * functionality is duplicated elsewhere - tfm 20070924)

  */

 public class TabDiagram

     extends AbstractArgoJPanel

     implements TabModelTarget, GraphSelectionListener, ModeChangeListener,

     PropertyChangeListener {

     /**

      * Logger.

      */

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

     /**

      * The diagram object.

      */

     private UMLDiagram target;

     /**

      * The GEF JGraph in where the figs are painted.

      */

     private JGraph graph;

     /**

      * Prevents target event cycles between this and the TargetManager.

      */

     private boolean updatingSelection;

     /**

      * The toolbar that is positioned just above

      * the diagram containing the drawing tools.

      */

     private JToolBar toolBar;

     /**

      * Default constructor.

      */

     public TabDiagram() {

         this("Diagram");

     }

     /**

      * Constructor.

      *

      * @param tag The type of diagram that we are creating.

      */

     public TabDiagram(String tag) {

         super(tag);

         setLayout(new BorderLayout());

         graph = new DnDJGraph();

         graph.setDrawingSize((612 - 30) * 2, (792 - 55 - 20) * 2);

         // TODO: should update to size of diagram contents

         Globals.setStatusBar(new StatusBarAdapter());

         JPanel p = new JPanel();

         p.setLayout(new BorderLayout());

         p.setBorder(new EtchedBorder(EtchedBorder.LOWERED));

         p.add(graph, BorderLayout.CENTER);

         add(p, BorderLayout.CENTER);

         graph.addGraphSelectionListener(this);

         graph.addModeChangeListener(this);

     }

     /*

      * The clone method that should clone the JGraph with it's contents and

      * the toolbar with it's contents. Since both JGraph as the toolbar are

      * coming from the GEF framework, cloning them will be hard work and should

      * actually not be placed here but in a clone method of the JGraph and the

      * Toolbar.

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

      */

     @Override

     public Object clone() {

         // next statement gives us a clone JGraph but not a cloned Toolbar

         TabDiagram newPanel = new TabDiagram();

         if (target != null) {

             newPanel.setTarget(target);

         }

         ToolBarFactory factory = new ToolBarFactory(target.getActions());

         factory.setRollover(true);

         factory.setFloatable(false);

         newPanel.setToolBar(factory.createToolBar());

         setToolBar(factory.createToolBar());

         return newPanel;

     }

     /**

      * Sets the target of the tab. The target should always be an instance of

      * UMLDiagram.

      * 

      * @param t the target

      */

     public void setTarget(Object t) {

         if (!(t instanceof UMLDiagram)) {

             // This is perfectly normal and happens among other things

             // within the call to setDiagram (below).

             LOG.debug("target is null in set target or "

                       + "not an instance of UMLDiagram");

             return;

         }

         UMLDiagram newTarget = (UMLDiagram) t;

         if (target != null) {

             target.removePropertyChangeListener("remove", this);

         }

         newTarget.addPropertyChangeListener("remove", this);

         setToolBar(newTarget.getJToolBar());

         // NOTE: This listener needs to always be active 

         // even if this tab isn't visible

         graph.removeGraphSelectionListener(this);

         graph.setDiagram(newTarget);

         graph.addGraphSelectionListener(this);

         target = newTarget;

     }

     /*

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

      */

     public Object getTarget() {

         return target;

     }

     /**

      * Getter for the Toolbar.

      *

      * @return The ToolBar.

      */

     public JToolBar getToolBar() {

         return toolBar;

     }

     /*

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

      */

     public void refresh() {

         setTarget(target);

     }

     /*

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

      */

     public boolean shouldBeEnabled(Object newTarget) {

         return newTarget instanceof ArgoDiagram;

     }

     /**

      * Getter for the {@link JGraph}.

      *

      * @return The JGraph.

      */

     public JGraph getJGraph() {

         return graph;

     }

     /*

      * @see java.awt.Component#setVisible(boolean)

      */

     public void setVisible(boolean b) {

         super.setVisible(b);

         getJGraph().setVisible(b);

     }

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

     // events

     /**

      * In the selectionChanged method not only the selection of this

      * diagram is set but also the selection in the projectbrowser.

      *

      * @param gse The event.

      */

     public void selectionChanged(GraphSelectionEvent gse) {

         if (!updatingSelection) {

             updatingSelection = true;

             List<Fig> selections = gse.getSelections();

             ActionCut.getInstance().setEnabled(

                     selections != null && !selections.isEmpty());

             // TODO: If ActionCopy is no longer a singleton, how shall

             //       this work?

             ActionCopy.getInstance()

                     .setEnabled(selections != null && !selections.isEmpty());

             /*

              * ActionPaste.getInstance().setEnabled( Globals.clipBoard

              * != null && !Globals.clipBoard.isEmpty());

              */

             // the old selection

             List currentSelection =

                 TargetManager.getInstance().getTargets();

             List removedTargets = new ArrayList(currentSelection);

             List addedTargets = new ArrayList();

             for (Object selection : selections) {

                 Object owner = TargetManager.getInstance().getOwner(selection);

                 if (currentSelection.contains(owner)) {

                     removedTargets.remove(owner); // remains selected

                 } else {

                     // add to selection

                     addedTargets.add(owner);

                 }

             }

             if (addedTargets.size() == 1

                     && removedTargets.size() == currentSelection.size()

                     && removedTargets.size() != 0) {

                 // Optimize for the normal case to minimize target changes

                 TargetManager.getInstance().setTarget(addedTargets.get(0));

             } else {

                 for (Object o : removedTargets) {

                     TargetManager.getInstance().removeTarget(o);

                 }

                 for (Object o : addedTargets) {

                     TargetManager.getInstance().addTarget(o);

                 }

             }

             updatingSelection = false;

         }

     }

     /**

      * @param listener the listener to be removed

      */

     public void removeGraphSelectionListener(GraphSelectionListener listener) {

         graph.removeGraphSelectionListener(listener);

     }

     /*

      * @see org.tigris.gef.event.ModeChangeListener#modeChange(org.tigris.gef.event.ModeChangeEvent)

      */

     public void modeChange(ModeChangeEvent mce) {

         LOG.debug("TabDiagram got mode change event");

         if (target != null    // Target might not have been initialised yet. 

                 && !Globals.getSticky() 

                 && Globals.mode() instanceof ModeSelect) {

 //            if (_target instanceof UMLDiagram) {

             target.deselectAllTools();

 //            }

         }

     }

     /**

      * @param listener the listener to be removed

      */

     public void removeModeChangeListener(ModeChangeListener listener) {

         graph.removeModeChangeListener(listener);

     }

     /**

      * Sets the toolbar.  Adds the toolbar to the north borderlayout

      * position of the diagram.<p>

      *

      * @param toolbar is the toolbar to be set.

      */

     public void setToolBar(JToolBar toolbar) {

         // TODO: This must happen on the AWT thread

         if (!Arrays.asList(getComponents()).contains(toolbar)) {

             if (target != null) {

                 remove(((UMLDiagram) getTarget()).getJToolBar());

             }

             add(toolbar, BorderLayout.NORTH);

             toolBar = toolbar;

             invalidate();

             validate();

             repaint();

         }

     }

     /*

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

      *          TargetEvent)

      */

     public void targetAdded(final TargetEvent e) {

         setNewTargets(e);

     }

     /*

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

      *          TargetEvent)

      */

     public void targetRemoved(final TargetEvent e) {

         // how to handle empty target lists?

         // probably the TabDiagram should only show an empty pane in that case

         setNewTargets(e);

     }

     /*

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

      *          org.argouml.ui.targetmanager.TargetEvent)

      */

     public void targetSet(final TargetEvent e) {

         setNewTargets(e);

     }

     /**

      * We have no guarantee which thread our events will be delivered on,

      * so make sure the work gets done on our AWT event thread.

      * 

      * @param e the target change event 

      */

     private void setNewTargets(final TargetEvent e) {

         if (SwingUtilities.isEventDispatchThread()) {

             setTarget(e.getNewTarget());

             select(e.getNewTargets());            

         } else {

             SwingUtilities.invokeLater(new Runnable() {

                 public void run() {

                     setTarget(e.getNewTarget());

                     select(e.getNewTargets());                

                 }

             });

         }

     }

     private void select(Object[] targets) {

         LayerManager manager = graph.getEditor().getLayerManager();

         List<Fig> figList = new ArrayList<Fig>();

         for (int i = 0; i < targets.length; i++) {

             if (targets[i] != null) {

                 Fig theTarget = null;

                 if (targets[i] instanceof Fig

                         && manager.getActiveLayer().getContents().contains(

                                 targets[i])) {

                     theTarget = (Fig) targets[i];

                 } else {

                     theTarget = manager.presentationFor(targets[i]);

                 }

                 if (theTarget != null && !figList.contains(theTarget)) {

                     figList.add(theTarget);

                 }

             }

         }

         // This checks the order in addition to the contents

         // Is that really what we want here? - tfm 20070603

         if (!figList.equals(graph.selectedFigs())) {

             graph.deselectAll();

             graph.select(new Vector<Fig>(figList));

         }

     }

     /**

      * The UID.

      */

     private static final long serialVersionUID = -3305029387374936153L;

     public void propertyChange(PropertyChangeEvent arg0) {

         // Any Swing work done here needs to be queued to the AWT thread

         // since we don't know what thread our event will arrive on 

         if ("remove".equals(arg0.getPropertyName())) {

             LOG.debug("Got remove event for diagram = " + arg0.getSource() 

                     + " old value = " + arg0.getOldValue());

             // Although we register for notification of diagrams being

             // deleted, we currently depend on the TargetManager to assign

             // a new target when this happens

             // When we implement MDI and have our own list of open diagrams

             // we can ressurect the use of this

         }

     }

 }

 /**

  * The ArgoUML editor.

  */

 class ArgoEditor extends Editor {

     private RenderingHints  argoRenderingHints;

     /**

      * Constructor for the Editor.

      *

      * @param d The Diagram that this editor works in.

      */

     public ArgoEditor(Diagram d) {

         super(d);

         setupRenderingHints();

     }

     /**

      * Constructor for the Editor.

      *

      * @param gm The Graphmodel.

      * @param c The component.

      */

     public ArgoEditor(GraphModel gm, JComponent c) {

         super(gm, c);

         setupRenderingHints();

     }

     /*

      * @see java.awt.event.MouseListener#mouseEntered(java.awt.event.MouseEvent)

      */

     @Override

     public void mouseEntered(MouseEvent me) {

         if (getActiveTextEditor() != null) {

             getActiveTextEditor().requestFocus();

         }

         translateMouseEvent(me);

         Globals.curEditor(this);

         pushMode((FigModifyingMode) Globals.mode());

         setUnderMouse(me);

         _modeManager.mouseEntered(me);

     }

     /*

      * @see java.awt.event.MouseMotionListener#mouseMoved(java.awt.event.MouseEvent)

      */

     @Override

     public void mouseMoved(MouseEvent me) {

         //- RedrawManager.lock();

         translateMouseEvent(me);

         Globals.curEditor(this);

         setUnderMouse(me);

         Fig currentFig = getCurrentFig();

         if (currentFig != null && Globals.getShowFigTips()) {

             String tip = currentFig.getTipString(me);

             if (tip != null && (getJComponent() != null)) {

                 JComponent c = getJComponent();

                 if (c.getToolTipText() == null

                     || !(c.getToolTipText().equals(tip))) {

                     c.setToolTipText(tip);

                 }

             }

         } else if (getJComponent() != null

                    && getJComponent().getToolTipText() != null) {

             getJComponent().setToolTipText(null); //was ""

         }

         _selectionManager.mouseMoved(me);

         _modeManager.mouseMoved(me);

         //- RedrawManager.unlock();

         //- _redrawer.repairDamage();

     }

     /*

      * Overridden to set Argo-specific RenderingHints to determine whether

      * or not antialiasing should be turned on.

      *

      * @see org.tigris.gef.base.Editor#paint(java.awt.Graphics)

      */

     @Override

     public synchronized void paint(Graphics g) {

         if (!shouldPaint()) {

             return;

         }

         if (g instanceof Graphics2D) {

             Graphics2D g2 = (Graphics2D) g;

             g2.setRenderingHints(argoRenderingHints);

             double scale = getScale();

             g2.scale(scale, scale);

         }

         getLayerManager().paint(g);

         //getLayerManager().getActiveLayer().paint(g);

         if (_canSelectElements) {

             _selectionManager.paint(g);

             _modeManager.paint(g);

         }

     }

     /**

      * Construct a new set of RenderingHints to reflect current user

      * settings.

      */

     private void setupRenderingHints() {

         argoRenderingHints = new RenderingHints(null);

         argoRenderingHints.put(RenderingHints.KEY_FRACTIONALMETRICS,

             RenderingHints.VALUE_FRACTIONALMETRICS_ON);

         if (Configuration.getBoolean(Argo.KEY_SMOOTH_EDGES, false)) {

             argoRenderingHints.put(RenderingHints.KEY_RENDERING,

                 RenderingHints.VALUE_RENDER_QUALITY);

             argoRenderingHints.put(RenderingHints.KEY_ANTIALIASING,

                 RenderingHints.VALUE_ANTIALIAS_ON);

             argoRenderingHints.put(RenderingHints.KEY_TEXT_ANTIALIASING,

                 RenderingHints.VALUE_TEXT_ANTIALIAS_ON);

         } else {

             argoRenderingHints.put(RenderingHints.KEY_RENDERING,

                 RenderingHints.VALUE_RENDER_SPEED);

             argoRenderingHints.put(RenderingHints.KEY_ANTIALIASING,

                 RenderingHints.VALUE_ANTIALIAS_OFF);

             argoRenderingHints.put(RenderingHints.KEY_TEXT_ANTIALIASING,

                 RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);

         }

     }

     /**

      * The UID.

      */

     private static final long serialVersionUID = -799007144549997407L;

 }