Coverage Report

 /* $Id: ExplorerTree.java 18968 2011-01-13 14:39:23Z tfmorris $
  *****************************************************************************
  * 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.ui.explorer;
 
 import java.awt.Graphics;
 import java.awt.Image;
 import java.awt.event.MouseAdapter;
 import java.awt.event.MouseEvent;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Enumeration;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Set;
 
 import javax.swing.JPopupMenu;
 import javax.swing.JTree;
 import javax.swing.event.TreeExpansionEvent;
 import javax.swing.event.TreeExpansionListener;
 import javax.swing.event.TreeSelectionEvent;
 import javax.swing.event.TreeSelectionListener;
 import javax.swing.event.TreeWillExpandListener;
 import javax.swing.tree.DefaultMutableTreeNode;
 import javax.swing.tree.TreePath;
 
 import org.argouml.application.helpers.ResourceLoaderWrapper;
 import org.argouml.kernel.Project;
 import org.argouml.kernel.ProjectManager;
 import org.argouml.kernel.ProjectSettings;
 import org.argouml.model.Model;
 import org.argouml.ui.DisplayTextTree;
 import org.argouml.ui.ProjectActions;
 import org.argouml.ui.targetmanager.TargetEvent;
 import org.argouml.ui.targetmanager.TargetListener;
 import org.argouml.ui.targetmanager.TargetManager;
 import org.tigris.gef.presentation.Fig;
 
 /**
  * This class is the JTree for the explorer. It provides:
  * <p>
  * 
  * <pre>
  *  - selection/target management
  *  - mouse listener for the pop up
  * </pre>
  * 
  * @author alexb
  * @since 0.15.2
  */
 public class ExplorerTree extends DisplayTextTree {
 
     /**
      * Background image only displayed in UML2 mode
      */
     private Image bgImage = null;
 
     /**
      * Prevents target event cycles between this and the TargetManager.
      */
     private boolean updatingSelection;
 
     /**
      * Prevents target event cycles between this and the TargetManager for tree
      * selection events.
      */
     private boolean updatingSelectionViaTreeSelection;
 
     /**
      * Creates a new instance of ExplorerTree.
      */
     public ExplorerTree() {
         super();
 
         Project p = ProjectManager.getManager().getCurrentProject();
         this.setModel(new ExplorerTreeModel(p, this));
         if (Model.getFacade().getUmlVersion().charAt(0) == '2') {
             bgImage = ResourceLoaderWrapper.lookupIconResource(
                     "uml2explorerbg").getImage();
         }
         if (p != null) {
             ProjectSettings ps = p.getProjectSettings();
             setShowStereotype(ps.getShowStereotypesValue());
         }
         this.addMouseListener(new ExplorerMouseListener(this));
         this.addTreeSelectionListener(new ExplorerTreeSelectionListener());
         this.addTreeWillExpandListener(new ExplorerTreeWillExpandListener());
         this.addTreeExpansionListener(new ExplorerTreeExpansionListener());
 
         TargetManager.getInstance().addTargetListener(
                 new ExplorerTargetListener());
     }
 
     /**
      * Listens to mouse events coming from the *JTree*, on right click, brings
      * up the pop-up menu.
      */
     class ExplorerMouseListener extends MouseAdapter {
 
         private JTree mLTree;
 
         /**
          * The constructor.
          * 
          * @param newtree
          */
         public ExplorerMouseListener(JTree newtree) {
             super();
             mLTree = newtree;
         }
 
         /**
          * Brings up the pop-up menu.
          * 
          * @see java.awt.event.MouseListener#mousePressed(java.awt.event.MouseEvent)
          */
         @Override
         public void mousePressed(MouseEvent me) {
             if (me.isPopupTrigger()) {
                 me.consume();
                 showPopupMenu(me);
             }
         }
 
         /**
          * Brings up the pop-up menu.
          * 
          * On Windows and Motif platforms, the user brings up a popup menu by
          * releasing the right mouse button while the cursor is over a component
          * that is popup-enabled.
          * 
          * @see java.awt.event.MouseListener#mouseReleased(java.awt.event.MouseEvent)
          */
         @Override
         public void mouseReleased(MouseEvent me) {
             if (me.isPopupTrigger()) {
                 me.consume();
                 showPopupMenu(me);
             }
         }
 
         /**
          * Brings up the pop-up menu.
          * 
          * @see java.awt.event.MouseListener#mouseClicked(java.awt.event.MouseEvent)
          */
         @Override
         public void mouseClicked(MouseEvent me) {
             if (me.isPopupTrigger()) {
                 me.consume();
                 showPopupMenu(me);
             }
             if (me.getClickCount() >= 2) {
                 myDoubleClick();
             }
         }
 
         /**
          * Double-clicking on an item attempts to show the item in a diagram.
          */
         private void myDoubleClick() {
             Object target = TargetManager.getInstance().getTarget();
             if (target != null) {
                 List show = new ArrayList();
                 show.add(target);
                 ProjectActions.jumpToDiagramShowing(show);
             }
         }
 
         /**
          * Builds a pop-up menu for extra functionality for the Tree.
          * 
          * @param me The mouse event.
          */
         public void showPopupMenu(MouseEvent me) {
 
             TreePath path = getPathForLocation(me.getX(), me.getY());
             if (path == null) {
                 return;
             }
 
             /*
              * We preserve the current (multiple) selection, if we are over part
              * of it ...
              */
             if (!isPathSelected(path)) {
                 /* ... otherwise we select the item below the mousepointer. */
                 getSelectionModel().setSelectionPath(path);
             }
 
             Object selectedItem = ((DefaultMutableTreeNode) path
                     .getLastPathComponent()).getUserObject();
             JPopupMenu popup = new ExplorerPopup(selectedItem, me);
 
             if (popup.getComponentCount() > 0) {
                 popup.show(mLTree, me.getX(), me.getY());
             }
         }
 
     } /* end class ExplorerMouseListener */
 
     /**
      * Helps prepare state before a node is expanded.
      */
     class ExplorerTreeWillExpandListener implements TreeWillExpandListener {
 
         /*
          * @see
          * javax.swing.event.TreeWillExpandListener#treeWillCollapse(javax.swing
          * .event.TreeExpansionEvent)
          */
         public void treeWillCollapse(TreeExpansionEvent tee) {
             // unimplemented - we only care about expanding
         }
 
         /*
          * Updates stereotype setting, adds all children per treemodel 'build on
          * demand' design.
          * 
          * @see
          * javax.swing.event.TreeWillExpandListener#treeWillExpand(javax.swing
          * .event.TreeExpansionEvent)
          */
         public void treeWillExpand(TreeExpansionEvent tee) {
             // TODO: This should not need to know about ProjectSettings - tfm
             Project p = ProjectManager.getManager().getCurrentProject();
             ProjectSettings ps = p.getProjectSettings();
             setShowStereotype(ps.getShowStereotypesValue());
 
             if (getModel() instanceof ExplorerTreeModel) {
 
                 ((ExplorerTreeModel) getModel()).updateChildren(tee.getPath());
             }
         }
     }
 
     /**
      * Helps react to tree expansion events.
      */
     class ExplorerTreeExpansionListener implements TreeExpansionListener {
 
         /*
          * @see javax.swing.event.TreeExpansionListener#treeCollapsed(
          * javax.swing.event.TreeExpansionEvent)
          */
         public void treeCollapsed(TreeExpansionEvent event) {
             // does nothing.
         }
 
         /*
          * @see javax.swing.event.TreeExpansionListener#treeExpanded(
          * javax.swing.event.TreeExpansionEvent) Updates the selection state.
          */
         public void treeExpanded(TreeExpansionEvent event) {
 
             // need to update the selection state.
             setSelection(TargetManager.getInstance().getTargets().toArray());
         }
     }
 
     /**
      * Refresh the selection of the tree nodes. This does not cause new events
      * to be fired to the TargetManager.
      */
     public void refreshSelection() {
         Collection targets = TargetManager.getInstance().getTargets();
         updatingSelectionViaTreeSelection = true;
         setSelection(targets.toArray());
         updatingSelectionViaTreeSelection = false;
     }
 
     /**
      * Sets the selection state for a given set of targets.
      * 
      * @param targets the targets
      */
     private void setSelection(Object[] targets) {
         updatingSelectionViaTreeSelection = true;
 
         this.clearSelection();
         addTargetsInternal(targets);
         updatingSelectionViaTreeSelection = false;
     }
 
     private void addTargetsInternal(Object[] addedTargets) {
         if (addedTargets.length < 1) {
             return;
         }
         Set targets = new HashSet();
         for (Object t : addedTargets) {
             if (t instanceof Fig) {
                 targets.add(((Fig) t).getOwner());
             } else {
                 targets.add(t);
             }
             // TODO: The following can be removed if selectAll gets fixed
             selectVisible(t);
         }
 
         // TODO: This doesn't perform well enough with large models to have
         // it enabled by default. If the performance can't be improved,
         // perhaps we can introduce a manual "find in explorer tree" action.
         // selectAll(targets);
 
         int[] selectedRows = getSelectionRows();
         if (selectedRows != null && selectedRows.length > 0) {
             // TODO: This only works if the item is visible
             // (all its parents are expanded)
             // getExpandedDescendants, makeVisible
             makeVisible(getPathForRow(selectedRows[0]));
             scrollRowToVisible(selectedRows[0]);
         }
     }
 
     /**
      * Select any targets which are visible in the explorer pane
      */
     private void selectVisible(Object target) {
         for (int j = 0; j < getRowCount(); j++) {
             Object rowItem = ((DefaultMutableTreeNode) getPathForRow(j)
                     .getLastPathComponent()).getUserObject();
             if (rowItem == target) {
                 addSelectionRow(j);
             }
         }
     }
 
     /**
      * Search the entire tree and select all instances of targets found.
      */
     private void selectAll(Set targets) {
         ExplorerTreeModel model = (ExplorerTreeModel) getModel();
         ExplorerTreeNode root = (ExplorerTreeNode) model.getRoot();
         selectChildren(model, root, targets);
     }
 
     /*
      * Perform recursive search of subtree rooted at 'node', selecting all nodes
      * which have a userObject matching one of our targets.
      */
     private void selectChildren(ExplorerTreeModel model, ExplorerTreeNode node,
             Set targets) {
         if (targets.isEmpty()) {
             return;
         }
 
         Object nodeObject = node.getUserObject();
         if (nodeObject != null) {
             for (Object t : targets) {
                 if (t == nodeObject) {
                     addSelectionPath(new TreePath(node.getPath()));
                     // target may appear multiple places in the tree, so
                     // we don't stop here (but it's expensive to search
                     // the whole tree) - tfm - 20070904
                     // targets.remove(t);
                     // break;
                 }
             }
         }
 
         model.updateChildren(new TreePath(node.getPath()));
         Enumeration e = node.children();
         while (e.hasMoreElements()) {
             selectChildren(model, (ExplorerTreeNode) e.nextElement(), targets);
         }
     }
 
     public void paint(Graphics g) {
         super.paint(g);
         if (bgImage != null) {
             g.drawImage(bgImage, 0, 40, null);
         }
     }
 
     /**
      * Manages selecting the item to show in Argo's other views based on the
      * highlighted row.
      */
     class ExplorerTreeSelectionListener implements TreeSelectionListener {
 
         /**
          * @see javax.swing.event.TreeSelectionListener#valueChanged(javax.swing.event.TreeSelectionEvent)
          * 
          *      Change in explorer tree selection -> set target in target
          *      manager.
          */
         public void valueChanged(TreeSelectionEvent e) {
 
             if (!updatingSelectionViaTreeSelection) {
                 updatingSelectionViaTreeSelection = true;
 
                 // get the elements
                 TreePath[] addedOrRemovedPaths = e.getPaths();
                 TreePath[] selectedPaths = getSelectionPaths();
                 List elementsAsList = new ArrayList();
                 for (int i = 0; selectedPaths != null
                         && i < selectedPaths.length; i++) {
                     Object element = ((DefaultMutableTreeNode) selectedPaths[i]
                             .getLastPathComponent()).getUserObject();
                     elementsAsList.add(element);
                     // scan the visible rows for duplicates of
                     // this elem and select them
                     int rows = getRowCount();
                     for (int row = 0; row < rows; row++) {
                         Object rowItem = ((DefaultMutableTreeNode) getPathForRow(
                                 row).getLastPathComponent()).getUserObject();
                         if (rowItem == element && !(isRowSelected(row))) {
                             addSelectionRow(row);
                         }
                     }
                 }
 
                 // check which targetmanager method to call
                 boolean callSetTarget = true;
                 List addedElements = new ArrayList();
                 for (int i = 0; i < addedOrRemovedPaths.length; i++) {
                     Object element = ((DefaultMutableTreeNode) addedOrRemovedPaths[i]
                             .getLastPathComponent()).getUserObject();
                     if (!e.isAddedPath(i)) {
                         callSetTarget = false;
                         break;
                     }
                     addedElements.add(element);
                 }
 
                 if (callSetTarget
                         && addedElements.size() == elementsAsList.size()
                         && elementsAsList.containsAll(addedElements)) {
                     TargetManager.getInstance().setTargets(elementsAsList);
                 } else {
                     // we must call the correct method on targetmanager
                     // for each added or removed target
                     List removedTargets = new ArrayList();
                     List addedTargets = new ArrayList();
                     for (int i = 0; i < addedOrRemovedPaths.length; i++) {
                         Object element = ((DefaultMutableTreeNode) addedOrRemovedPaths[i]
                                 .getLastPathComponent()).getUserObject();
                         if (e.isAddedPath(i)) {
                             addedTargets.add(element);
                         } else {
                             removedTargets.add(element);
                         }
                     }
                     // we can't remove the targets in one go, we have to
                     // do it one by one.
                     if (!removedTargets.isEmpty()) {
                         Iterator it = removedTargets.iterator();
                         while (it.hasNext()) {
                             TargetManager.getInstance().removeTarget(it.next());
                         }
                     }
                     if (!addedTargets.isEmpty()) {
                         Iterator it = addedTargets.iterator();
                         while (it.hasNext()) {
                             TargetManager.getInstance().addTarget(it.next());
                         }
                     }
                 }
 
                 updatingSelectionViaTreeSelection = false;
             }
         }
     }
 
     class ExplorerTargetListener implements TargetListener {
 
         /**
          * Actions a change in targets received from the TargetManager.
          * 
          * @param targets the targets
          */
         private void setTargets(Object[] targets) {
 
             if (!updatingSelection) {
                 updatingSelection = true;
                 if (targets.length <= 0) {
                     clearSelection();
                 } else {
                     setSelection(targets);
                 }
                 updatingSelection = false;
             }
         }
 
         /*
          * @see org.argouml.ui.targetmanager.TargetListener#targetAdded(
          * org.argouml.ui.targetmanager.TargetEvent)
          */
         public void targetAdded(TargetEvent e) {
             if (!updatingSelection) {
                 updatingSelection = true;
                 Object[] targets = e.getAddedTargets();
 
                 updatingSelectionViaTreeSelection = true;
                 addTargetsInternal(targets);
                 updatingSelectionViaTreeSelection = false;
                 updatingSelection = false;
             }
             // setTargets(e.getNewTargets());
         }
 
         /*
          * @see org.argouml.ui.targetmanager.TargetListener#targetRemoved(
          * org.argouml.ui.targetmanager.TargetEvent)
          */
         public void targetRemoved(TargetEvent e) {
             if (!updatingSelection) {
                 updatingSelection = true;
 
                 Object[] targets = e.getRemovedTargets();
 
                 int rows = getRowCount();
                 for (int i = 0; i < targets.length; i++) {
                     Object target = targets[i];
                     if (target instanceof Fig) {
                         target = ((Fig) target).getOwner();
                     }
                     for (int j = 0; j < rows; j++) {
                         Object rowItem = ((DefaultMutableTreeNode) getPathForRow(
                                 j).getLastPathComponent()).getUserObject();
                         if (rowItem == target) {
                             updatingSelectionViaTreeSelection = true;
                             removeSelectionRow(j);
                             updatingSelectionViaTreeSelection = false;
                         }
                     }
                 }
 
                 if (getSelectionCount() > 0) {
                     scrollRowToVisible(getSelectionRows()[0]);
                 }
                 updatingSelection = false;
             }
             // setTargets(e.getNewTargets());
         }
 
         /*
          * @see org.argouml.ui.targetmanager.TargetListener#targetSet(
          * org.argouml.ui.targetmanager.TargetEvent)
          */
         public void targetSet(TargetEvent e) {
             setTargets(e.getNewTargets());
 
         }
     }
 
     /**
      * The UID.
      */
     private static final long serialVersionUID = 992867483644759920L;
 }

1		/* $Id: ExplorerTree.java 18968 2011-01-13 14:39:23Z tfmorris $
2		*****************************************************************************
3		* Copyright (c) 2009 Contributors - see below
4		* All rights reserved. This program and the accompanying materials
5		* are made available under the terms of the Eclipse Public License v1.0
6		* which accompanies this distribution, and is available at
7		* http://www.eclipse.org/legal/epl-v10.html
8		*
9		* Contributors:
10		* thn
11		*****************************************************************************
12		*
13		* Some portions of this file was previously release using the BSD License:
14		*/
15
16		// Copyright (c) 1996-2008 The Regents of the University of California. All
17		// Rights Reserved. Permission to use, copy, modify, and distribute this
18		// software and its documentation without fee, and without a written
19		// agreement is hereby granted, provided that the above copyright notice
20		// and this paragraph appear in all copies. This software program and
21		// documentation are copyrighted by The Regents of the University of
22		// California. The software program and documentation are supplied "AS
23		// IS", without any accompanying services from The Regents. The Regents
24		// does not warrant that the operation of the program will be
25		// uninterrupted or error-free. The end-user understands that the program
26		// was developed for research purposes and is advised not to rely
27		// exclusively on the program for any reason. IN NO EVENT SHALL THE
28		// UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,
29		// SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS,
30		// ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
31		// THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF
32		// SUCH DAMAGE. THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY
33		// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
34		// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE
35		// PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF
36		// CALIFORNIA HAS NO OBLIGATIONS TO PROVIDE MAINTENANCE, SUPPORT,
37		// UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
38
39		package org.argouml.ui.explorer;
40
41		import java.awt.Graphics;
42		import java.awt.Image;
43		import java.awt.event.MouseAdapter;
44		import java.awt.event.MouseEvent;
45		import java.util.ArrayList;
46		import java.util.Collection;
47		import java.util.Enumeration;
48		import java.util.HashSet;
49		import java.util.Iterator;
50		import java.util.List;
51		import java.util.Set;
52
53		import javax.swing.JPopupMenu;
54		import javax.swing.JTree;
55		import javax.swing.event.TreeExpansionEvent;
56		import javax.swing.event.TreeExpansionListener;
57		import javax.swing.event.TreeSelectionEvent;
58		import javax.swing.event.TreeSelectionListener;
59		import javax.swing.event.TreeWillExpandListener;
60		import javax.swing.tree.DefaultMutableTreeNode;
61		import javax.swing.tree.TreePath;
62
63		import org.argouml.application.helpers.ResourceLoaderWrapper;
64		import org.argouml.kernel.Project;
65		import org.argouml.kernel.ProjectManager;
66		import org.argouml.kernel.ProjectSettings;
67		import org.argouml.model.Model;
68		import org.argouml.ui.DisplayTextTree;
69		import org.argouml.ui.ProjectActions;
70		import org.argouml.ui.targetmanager.TargetEvent;
71		import org.argouml.ui.targetmanager.TargetListener;
72		import org.argouml.ui.targetmanager.TargetManager;
73		import org.tigris.gef.presentation.Fig;
74
75		/**
76		* This class is the JTree for the explorer. It provides:
77		* <p>
78		*
79		* <pre>
80		* - selection/target management
81		* - mouse listener for the pop up
82		* </pre>
83		*
84		* @author alexb
85		* @since 0.15.2
86		*/
87	5239	public class ExplorerTree extends DisplayTextTree {
88
89		/**
90		* Background image only displayed in UML2 mode
91		*/
92	900	private Image bgImage = null;
93
94		/**
95		* Prevents target event cycles between this and the TargetManager.
96		*/
97		private boolean updatingSelection;
98
99		/**
100		* Prevents target event cycles between this and the TargetManager for tree
101		* selection events.
102		*/
103		private boolean updatingSelectionViaTreeSelection;
104
105		/**
106		* Creates a new instance of ExplorerTree.
107		*/
108		public ExplorerTree() {
109	900	super();
110
111	900	Project p = ProjectManager.getManager().getCurrentProject();
112	900	this.setModel(new ExplorerTreeModel(p, this));
113	900	if (Model.getFacade().getUmlVersion().charAt(0) == '2') {
114	0	bgImage = ResourceLoaderWrapper.lookupIconResource(
115		"uml2explorerbg").getImage();
116		}
117	900	if (p != null) {
118	0	ProjectSettings ps = p.getProjectSettings();
119	0	setShowStereotype(ps.getShowStereotypesValue());
120		}
121	900	this.addMouseListener(new ExplorerMouseListener(this));
122	900	this.addTreeSelectionListener(new ExplorerTreeSelectionListener());
123	900	this.addTreeWillExpandListener(new ExplorerTreeWillExpandListener());
124	900	this.addTreeExpansionListener(new ExplorerTreeExpansionListener());
125
126	900	TargetManager.getInstance().addTargetListener(
127		new ExplorerTargetListener());
128	900	}
129
130		/**
131		* Listens to mouse events coming from the JTree, on right click, brings
132		* up the pop-up menu.
133		*/
134		class ExplorerMouseListener extends MouseAdapter {
135
136		private JTree mLTree;
137
138		/**
139		* The constructor.
140		*
141		* @param newtree
142		*/
143	900	public ExplorerMouseListener(JTree newtree) {
144	900	super();
145	900	mLTree = newtree;
146	900	}
147
148		/**
149		* Brings up the pop-up menu.
150		*
151		* @see java.awt.event.MouseListener#mousePressed(java.awt.event.MouseEvent)
152		*/
153		@Override
154		public void mousePressed(MouseEvent me) {
155	0	if (me.isPopupTrigger()) {
156	0	me.consume();
157	0	showPopupMenu(me);
158		}
159	0	}
160
161		/**
162		* Brings up the pop-up menu.
163		*
164		* On Windows and Motif platforms, the user brings up a popup menu by
165		* releasing the right mouse button while the cursor is over a component
166		* that is popup-enabled.
167		*
168		* @see java.awt.event.MouseListener#mouseReleased(java.awt.event.MouseEvent)
169		*/
170		@Override
171		public void mouseReleased(MouseEvent me) {
172	0	if (me.isPopupTrigger()) {
173	0	me.consume();
174	0	showPopupMenu(me);
175		}
176	0	}
177
178		/**
179		* Brings up the pop-up menu.
180		*
181		* @see java.awt.event.MouseListener#mouseClicked(java.awt.event.MouseEvent)
182		*/
183		@Override
184		public void mouseClicked(MouseEvent me) {
185	0	if (me.isPopupTrigger()) {
186	0	me.consume();
187	0	showPopupMenu(me);
188		}
189	0	if (me.getClickCount() >= 2) {
190	0	myDoubleClick();
191		}
192	0	}
193
194		/**
195		* Double-clicking on an item attempts to show the item in a diagram.
196		*/
197		private void myDoubleClick() {
198	0	Object target = TargetManager.getInstance().getTarget();
199	0	if (target != null) {
200	0	List show = new ArrayList();
201	0	show.add(target);
202	0	ProjectActions.jumpToDiagramShowing(show);
203		}
204	0	}
205
206		/**
207		* Builds a pop-up menu for extra functionality for the Tree.
208		*
209		* @param me The mouse event.
210		*/
211		public void showPopupMenu(MouseEvent me) {
212
213	0	TreePath path = getPathForLocation(me.getX(), me.getY());
214	0	if (path == null) {
215	0	return;
216		}
217
218		/*
219		* We preserve the current (multiple) selection, if we are over part
220		* of it ...
221		*/
222	0	if (!isPathSelected(path)) {
223		/* ... otherwise we select the item below the mousepointer. */
224	0	getSelectionModel().setSelectionPath(path);
225		}
226
227	0	Object selectedItem = ((DefaultMutableTreeNode) path
228		.getLastPathComponent()).getUserObject();
229	0	JPopupMenu popup = new ExplorerPopup(selectedItem, me);
230
231	0	if (popup.getComponentCount() > 0) {
232	0	popup.show(mLTree, me.getX(), me.getY());
233		}
234	0	}
235
236		} /* end class ExplorerMouseListener */
237
238		/**
239		* Helps prepare state before a node is expanded.
240		*/
241	900	class ExplorerTreeWillExpandListener implements TreeWillExpandListener {
242
243		/*
244		* @see
245		* javax.swing.event.TreeWillExpandListener#treeWillCollapse(javax.swing
246		* .event.TreeExpansionEvent)
247		*/
248		public void treeWillCollapse(TreeExpansionEvent tee) {
249		// unimplemented - we only care about expanding
250	0	}
251
252		/*
253		* Updates stereotype setting, adds all children per treemodel 'build on
254		* demand' design.
255		*
256		* @see
257		* javax.swing.event.TreeWillExpandListener#treeWillExpand(javax.swing
258		* .event.TreeExpansionEvent)
259		*/
260		public void treeWillExpand(TreeExpansionEvent tee) {
261		// TODO: This should not need to know about ProjectSettings - tfm
262	10	Project p = ProjectManager.getManager().getCurrentProject();
263	10	ProjectSettings ps = p.getProjectSettings();
264	10	setShowStereotype(ps.getShowStereotypesValue());
265
266	10	if (getModel() instanceof ExplorerTreeModel) {
267
268	10	((ExplorerTreeModel) getModel()).updateChildren(tee.getPath());
269		}
270	10	}
271		}
272
273		/**
274		* Helps react to tree expansion events.
275		*/
276	900	class ExplorerTreeExpansionListener implements TreeExpansionListener {
277
278		/*
279		* @see javax.swing.event.TreeExpansionListener#treeCollapsed(
280		* javax.swing.event.TreeExpansionEvent)
281		*/
282		public void treeCollapsed(TreeExpansionEvent event) {
283		// does nothing.
284	0	}
285
286		/*
287		* @see javax.swing.event.TreeExpansionListener#treeExpanded(
288		* javax.swing.event.TreeExpansionEvent) Updates the selection state.
289		*/
290		public void treeExpanded(TreeExpansionEvent event) {
291
292		// need to update the selection state.
293	10	setSelection(TargetManager.getInstance().getTargets().toArray());
294	10	}
295		}
296
297		/**
298		* Refresh the selection of the tree nodes. This does not cause new events
299		* to be fired to the TargetManager.
300		*/
301		public void refreshSelection() {
302	231	Collection targets = TargetManager.getInstance().getTargets();
303	231	updatingSelectionViaTreeSelection = true;
304	231	setSelection(targets.toArray());
305	231	updatingSelectionViaTreeSelection = false;
306	231	}
307
308		/**
309		* Sets the selection state for a given set of targets.
310		*
311		* @param targets the targets
312		*/
313		private void setSelection(Object[] targets) {
314	1442	updatingSelectionViaTreeSelection = true;
315
316	1442	this.clearSelection();
317	1442	addTargetsInternal(targets);
318	1442	updatingSelectionViaTreeSelection = false;
319	1442	}
320
321		private void addTargetsInternal(Object[] addedTargets) {
322	1442	if (addedTargets.length < 1) {
323	0	return;
324		}
325	1442	Set targets = new HashSet();
326	2884	for (Object t : addedTargets) {
327	1442	if (t instanceof Fig) {
328	0	targets.add(((Fig) t).getOwner());
329		} else {
330	1442	targets.add(t);
331		}
332		// TODO: The following can be removed if selectAll gets fixed
333	1442	selectVisible(t);
334		}
335
336		// TODO: This doesn't perform well enough with large models to have
337		// it enabled by default. If the performance can't be improved,
338		// perhaps we can introduce a manual "find in explorer tree" action.
339		// selectAll(targets);
340
341	1442	int[] selectedRows = getSelectionRows();
342	1442	if (selectedRows != null && selectedRows.length > 0) {
343		// TODO: This only works if the item is visible
344		// (all its parents are expanded)
345		// getExpandedDescendants, makeVisible
346	10	makeVisible(getPathForRow(selectedRows[0]));
347	10	scrollRowToVisible(selectedRows[0]);
348		}
349	1442	}
350
351		/**
352		* Select any targets which are visible in the explorer pane
353		*/
354		private void selectVisible(Object target) {
355	2492	for (int j = 0; j < getRowCount(); j++) {
356	1050	Object rowItem = ((DefaultMutableTreeNode) getPathForRow(j)
357		.getLastPathComponent()).getUserObject();
358	1050	if (rowItem == target) {
359	10	addSelectionRow(j);
360		}
361		}
362	1442	}
363
364		/**
365		* Search the entire tree and select all instances of targets found.
366		*/
367		private void selectAll(Set targets) {
368	0	ExplorerTreeModel model = (ExplorerTreeModel) getModel();
369	0	ExplorerTreeNode root = (ExplorerTreeNode) model.getRoot();
370	0	selectChildren(model, root, targets);
371	0	}
372
373		/*
374		* Perform recursive search of subtree rooted at 'node', selecting all nodes
375		* which have a userObject matching one of our targets.
376		*/
377		private void selectChildren(ExplorerTreeModel model, ExplorerTreeNode node,
378		Set targets) {
379	0	if (targets.isEmpty()) {
380	0	return;
381		}
382
383	0	Object nodeObject = node.getUserObject();
384	0	if (nodeObject != null) {
385	0	for (Object t : targets) {
386	0	if (t == nodeObject) {
387	0	addSelectionPath(new TreePath(node.getPath()));
388		// target may appear multiple places in the tree, so
389		// we don't stop here (but it's expensive to search
390		// the whole tree) - tfm - 20070904
391		// targets.remove(t);
392		// break;
393		}
394		}
395		}
396
397	0	model.updateChildren(new TreePath(node.getPath()));
398	0	Enumeration e = node.children();
399	0	while (e.hasMoreElements()) {
400	0	selectChildren(model, (ExplorerTreeNode) e.nextElement(), targets);
401		}
402	0	}
403
404		public void paint(Graphics g) {
405	1422	super.paint(g);
406	1422	if (bgImage != null) {
407	0	g.drawImage(bgImage, 0, 40, null);
408		}
409	1422	}
410
411		/**
412		* Manages selecting the item to show in Argo's other views based on the
413		* highlighted row.
414		*/
415	900	class ExplorerTreeSelectionListener implements TreeSelectionListener {
416
417		/**
418		* @see javax.swing.event.TreeSelectionListener#valueChanged(javax.swing.event.TreeSelectionEvent)
419		*
420		* Change in explorer tree selection -> set target in target
421		* manager.
422		*/
423		public void valueChanged(TreeSelectionEvent e) {
424
425	19	if (!updatingSelectionViaTreeSelection) {
426	9	updatingSelectionViaTreeSelection = true;
427
428		// get the elements
429	9	TreePath[] addedOrRemovedPaths = e.getPaths();
430	9	TreePath[] selectedPaths = getSelectionPaths();
431	9	List elementsAsList = new ArrayList();
432	9	for (int i = 0; selectedPaths != null
433	9	&& i < selectedPaths.length; i++) {
434	0	Object element = ((DefaultMutableTreeNode) selectedPaths[i]
435		.getLastPathComponent()).getUserObject();
436	0	elementsAsList.add(element);
437		// scan the visible rows for duplicates of
438		// this elem and select them
439	0	int rows = getRowCount();
440	0	for (int row = 0; row < rows; row++) {
441	0	Object rowItem = ((DefaultMutableTreeNode) getPathForRow(
442		row).getLastPathComponent()).getUserObject();
443	0	if (rowItem == element && !(isRowSelected(row))) {
444	0	addSelectionRow(row);
445		}
446		}
447		}
448
449		// check which targetmanager method to call
450	9	boolean callSetTarget = true;
451	9	List addedElements = new ArrayList();
452	9	for (int i = 0; i < addedOrRemovedPaths.length; i++) {
453	9	Object element = ((DefaultMutableTreeNode) addedOrRemovedPaths[i]
454		.getLastPathComponent()).getUserObject();
455	9	if (!e.isAddedPath(i)) {
456	9	callSetTarget = false;
457	9	break;
458		}
459	0	addedElements.add(element);
460		}
461
462	9	if (callSetTarget
463		&& addedElements.size() == elementsAsList.size()
464		&& elementsAsList.containsAll(addedElements)) {
465	0	TargetManager.getInstance().setTargets(elementsAsList);
466		} else {
467		// we must call the correct method on targetmanager
468		// for each added or removed target
469	9	List removedTargets = new ArrayList();
470	9	List addedTargets = new ArrayList();
471	18	for (int i = 0; i < addedOrRemovedPaths.length; i++) {
472	9	Object element = ((DefaultMutableTreeNode) addedOrRemovedPaths[i]
473		.getLastPathComponent()).getUserObject();
474	9	if (e.isAddedPath(i)) {
475	0	addedTargets.add(element);
476		} else {
477	9	removedTargets.add(element);
478		}
479		}
480		// we can't remove the targets in one go, we have to
481		// do it one by one.
482	9	if (!removedTargets.isEmpty()) {
483	9	Iterator it = removedTargets.iterator();
484	18	while (it.hasNext()) {
485	9	TargetManager.getInstance().removeTarget(it.next());
486		}
487		}
488	9	if (!addedTargets.isEmpty()) {
489	0	Iterator it = addedTargets.iterator();
490	0	while (it.hasNext()) {
491	0	TargetManager.getInstance().addTarget(it.next());
492		}
493		}
494		}
495
496	9	updatingSelectionViaTreeSelection = false;
497		}
498	19	}
499		}
500
501	900	class ExplorerTargetListener implements TargetListener {
502
503		/**
504		* Actions a change in targets received from the TargetManager.
505		*
506		* @param targets the targets
507		*/
508		private void setTargets(Object[] targets) {
509
510	1239	if (!updatingSelection) {
511	1239	updatingSelection = true;
512	1239	if (targets.length <= 0) {
513	38	clearSelection();
514		} else {
515	1201	setSelection(targets);
516		}
517	1239	updatingSelection = false;
518		}
519	1239	}
520
521		/*
522		* @see org.argouml.ui.targetmanager.TargetListener#targetAdded(
523		* org.argouml.ui.targetmanager.TargetEvent)
524		*/
525		public void targetAdded(TargetEvent e) {
526	0	if (!updatingSelection) {
527	0	updatingSelection = true;
528	0	Object[] targets = e.getAddedTargets();
529
530	0	updatingSelectionViaTreeSelection = true;
531	0	addTargetsInternal(targets);
532	0	updatingSelectionViaTreeSelection = false;
533	0	updatingSelection = false;
534		}
535		// setTargets(e.getNewTargets());
536	0	}
537
538		/*
539		* @see org.argouml.ui.targetmanager.TargetListener#targetRemoved(
540		* org.argouml.ui.targetmanager.TargetEvent)
541		*/
542		public void targetRemoved(TargetEvent e) {
543	88	if (!updatingSelection) {
544	88	updatingSelection = true;
545
546	88	Object[] targets = e.getRemovedTargets();
547
548	88	int rows = getRowCount();
549	176	for (int i = 0; i < targets.length; i++) {
550	88	Object target = targets[i];
551	88	if (target instanceof Fig) {
552	0	target = ((Fig) target).getOwner();
553		}
554	264	for (int j = 0; j < rows; j++) {
555	176	Object rowItem = ((DefaultMutableTreeNode) getPathForRow(
556		j).getLastPathComponent()).getUserObject();
557	176	if (rowItem == target) {
558	0	updatingSelectionViaTreeSelection = true;
559	0	removeSelectionRow(j);
560	0	updatingSelectionViaTreeSelection = false;
561		}
562		}
563		}
564
565	88	if (getSelectionCount() > 0) {
566	0	scrollRowToVisible(getSelectionRows()[0]);
567		}
568	88	updatingSelection = false;
569		}
570		// setTargets(e.getNewTargets());
571	88	}
572
573		/*
574		* @see org.argouml.ui.targetmanager.TargetListener#targetSet(
575		* org.argouml.ui.targetmanager.TargetEvent)
576		*/
577		public void targetSet(TargetEvent e) {
578	1239	setTargets(e.getNewTargets());
579
580	1239	}
581		}
582
583		/**
584		* The UID.
585		*/
586		private static final long serialVersionUID = 992867483644759920L;
587		}