KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > eclipse > jdt > internal > ui > typehierarchy > TypeHierarchyViewer


1 /*******************************************************************************
2  * Copyright (c) 2000, 2007 IBM Corporation and others.
3  * All rights reserved. This program and the accompanying materials
4  * are made available under the terms of the Eclipse Public License v1.0
5  * which accompanies this distribution, and is available at
6  * http://www.eclipse.org/legal/epl-v10.html
7  *
8  * Contributors:
9  * IBM Corporation - initial API and implementation
10  *******************************************************************************/
11 package org.eclipse.jdt.internal.ui.typehierarchy;
12
13 import org.eclipse.core.runtime.Assert;
14
15 import org.eclipse.swt.SWT;
16 import org.eclipse.swt.widgets.Composite;
17 import org.eclipse.swt.widgets.Menu;
18 import org.eclipse.swt.widgets.Tree;
19
20 import org.eclipse.jface.action.IMenuListener;
21 import org.eclipse.jface.action.IMenuManager;
22 import org.eclipse.jface.action.MenuManager;
23 import org.eclipse.jface.viewers.IContentProvider;
24 import org.eclipse.jface.viewers.IOpenListener;
25 import org.eclipse.jface.viewers.OpenEvent;
26 import org.eclipse.jface.viewers.ViewerFilter;
27
28 import org.eclipse.ui.IWorkbenchPart;
29 import org.eclipse.ui.IWorkbenchPartSite;
30
31 import org.eclipse.jdt.core.IMember;
32 import org.eclipse.jdt.core.IType;
33
34 import org.eclipse.jdt.ui.JavaElementLabels;
35 import org.eclipse.jdt.ui.actions.OpenAction;
36
37 import org.eclipse.jdt.internal.ui.IJavaHelpContextIds;
38 import org.eclipse.jdt.internal.ui.util.JavaUIHelp;
39 import org.eclipse.jdt.internal.ui.viewsupport.ColoredViewersManager;
40 import org.eclipse.jdt.internal.ui.viewsupport.DecoratingJavaLabelProvider;
41 import org.eclipse.jdt.internal.ui.viewsupport.ProblemTreeViewer;
42  
43 public abstract class TypeHierarchyViewer extends ProblemTreeViewer {
44     
45     private OpenAction fOpen;
46     private HierarchyLabelProvider fLabelProvider;
47             
48     public TypeHierarchyViewer(Composite parent, IContentProvider contentProvider, TypeHierarchyLifeCycle lifeCycle, IWorkbenchPart part) {
49         super(new Tree(parent, SWT.SINGLE));
50
51         fLabelProvider= new HierarchyLabelProvider(lifeCycle);
52     
53         setLabelProvider(new DecoratingJavaLabelProvider(fLabelProvider, true));
54         setUseHashlookup(true);
55             
56         setContentProvider(contentProvider);
57         setComparator(new HierarchyViewerSorter(lifeCycle));
58         
59         fOpen= new OpenAction(part.getSite());
60         addOpenListener(new IOpenListener() {
61             public void open(OpenEvent event) {
62                 fOpen.run();
63             }
64         });
65         
66         ColoredViewersManager.install(this);
67         
68         JavaUIHelp.setHelp(this, IJavaHelpContextIds.TYPE_HIERARCHY_VIEW);
69     }
70     
71     public void setQualifiedTypeName(boolean on) {
72         if (on) {
73             fLabelProvider.setTextFlags(fLabelProvider.getTextFlags() | JavaElementLabels.T_POST_QUALIFIED);
74         } else {
75             fLabelProvider.setTextFlags(fLabelProvider.getTextFlags() & ~JavaElementLabels.T_POST_QUALIFIED);
76         }
77         refresh();
78     }
79     
80     /**
81      * Attaches a contextmenu listener to the tree
82      * @param menuListener the menu listener
83      * @param popupId the popup id
84      * @param viewSite the view site
85      */
86     public void initContextMenu(IMenuListener menuListener, String JavaDoc popupId, IWorkbenchPartSite viewSite) {
87         MenuManager menuMgr= new MenuManager();
88         menuMgr.setRemoveAllWhenShown(true);
89         menuMgr.addMenuListener(menuListener);
90         Menu menu= menuMgr.createContextMenu(getTree());
91         getTree().setMenu(menu);
92         viewSite.registerContextMenu(popupId, menuMgr, this);
93     }
94
95     /**
96      * Fills up the context menu with items for the hierarchy viewer
97      * Should be called by the creator of the context menu
98      * @param menu the menu manager
99      */
100     public void contributeToContextMenu(IMenuManager menu) {
101     }
102
103     /**
104      * Set the member filter
105      * @param memberFilter the member filters to set
106      */
107     public void setMemberFilter(IMember[] memberFilter) {
108         TypeHierarchyContentProvider contentProvider= getHierarchyContentProvider();
109         if (contentProvider != null) {
110             contentProvider.setMemberFilter(memberFilter);
111         }
112     }
113
114     /**
115      * Returns if method filtering is enabled.
116      * @return <code>true</code>if method filtering is enabled.
117      */
118     public boolean isMethodFiltering() {
119         TypeHierarchyContentProvider contentProvider= getHierarchyContentProvider();
120         if (contentProvider != null) {
121             return contentProvider.getMemberFilter() != null;
122         }
123         return false;
124     }
125
126     public void setWorkingSetFilter(ViewerFilter filter) {
127         fLabelProvider.setFilter(filter);
128         TypeHierarchyContentProvider contentProvider= getHierarchyContentProvider();
129         if (contentProvider != null) {
130             contentProvider.setWorkingSetFilter(filter);
131         }
132     }
133     
134     /**
135      * Returns true if the hierarchy contains elements. Returns one of them
136      * With member filtering it is possible that no elements are visible
137      * @return one of the elements contained
138      */
139     public Object JavaDoc containsElements() {
140         TypeHierarchyContentProvider contentProvider= getHierarchyContentProvider();
141         if (contentProvider != null) {
142             Object JavaDoc[] elements= contentProvider.getElements(null);
143             if (elements.length > 0) {
144                 return elements[0];
145             }
146         }
147         return null;
148     }
149     
150     /**
151      * Returns true if the hierarchy contains elements. Returns one of them
152      * With member filtering it is possible that no elements are visible
153      * @return the tree root
154      */
155     public IType getTreeRootType() {
156         TypeHierarchyContentProvider contentProvider= getHierarchyContentProvider();
157         if (contentProvider != null) {
158             Object JavaDoc[] elements= contentProvider.getElements(null);
159             if (elements.length > 0 && elements[0] instanceof IType) {
160                 return (IType) elements[0];
161             }
162         }
163         return null;
164     }
165             
166     /**
167      * Returns true if the hierarchy contains element the element.
168      * @param element the element
169      * @return <code>true</code> if element is shown
170      */
171     public boolean isElementShown(Object JavaDoc element) {
172         return findItem(element) != null;
173     }
174     
175     /**
176      * Updates the content of this viewer: refresh and expanding the tree in the way wanted.
177      * @param doExpand if set, update should expand
178      */
179     public abstract void updateContent(boolean doExpand);
180     
181     /**
182      * Returns the title for the current view
183      * @return the title
184      */
185     public abstract String JavaDoc getTitle();
186     
187     /*
188      * @see StructuredViewer#setContentProvider
189      * Content provider must be of type TypeHierarchyContentProvider
190      */
191     public void setContentProvider(IContentProvider cp) {
192         Assert.isTrue(cp instanceof TypeHierarchyContentProvider);
193         super.setContentProvider(cp);
194     }
195
196     protected TypeHierarchyContentProvider getHierarchyContentProvider() {
197         return (TypeHierarchyContentProvider)getContentProvider();
198     }
199     
200 }
201
Popular Tags