KickJava   Java API By Example, From Geeks To Geeks.

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


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 java.util.ArrayList JavaDoc;
14 import java.util.List JavaDoc;
15
16 import org.eclipse.swt.SWT;
17 import org.eclipse.swt.widgets.Composite;
18 import org.eclipse.swt.widgets.Menu;
19 import org.eclipse.swt.widgets.ScrollBar;
20 import org.eclipse.swt.widgets.Table;
21
22 import org.eclipse.jface.action.IMenuListener;
23 import org.eclipse.jface.action.IMenuManager;
24 import org.eclipse.jface.action.MenuManager;
25 import org.eclipse.jface.action.Separator;
26 import org.eclipse.jface.action.ToolBarManager;
27 import org.eclipse.jface.viewers.IOpenListener;
28 import org.eclipse.jface.viewers.ISelection;
29 import org.eclipse.jface.viewers.OpenEvent;
30 import org.eclipse.jface.viewers.StructuredSelection;
31
32 import org.eclipse.ui.IMemento;
33 import org.eclipse.ui.IWorkbenchPart;
34 import org.eclipse.ui.IWorkbenchPartSite;
35
36 import org.eclipse.jdt.core.IMethod;
37 import org.eclipse.jdt.core.JavaModelException;
38
39 import org.eclipse.jdt.internal.corext.util.JavaModelUtil;
40
41 import org.eclipse.jdt.ui.JavaElementLabels;
42 import org.eclipse.jdt.ui.actions.MemberFilterActionGroup;
43 import org.eclipse.jdt.ui.actions.OpenAction;
44
45 import org.eclipse.jdt.internal.ui.IJavaHelpContextIds;
46 import org.eclipse.jdt.internal.ui.JavaPlugin;
47 import org.eclipse.jdt.internal.ui.filters.SyntheticMembersFilter;
48 import org.eclipse.jdt.internal.ui.util.JavaUIHelp;
49 import org.eclipse.jdt.internal.ui.util.SelectionUtil;
50 import org.eclipse.jdt.internal.ui.viewsupport.ColoredViewersManager;
51 import org.eclipse.jdt.internal.ui.viewsupport.DecoratingJavaLabelProvider;
52 import org.eclipse.jdt.internal.ui.viewsupport.ProblemTableViewer;
53
54 /**
55  * Method viewer shows a list of methods of a input type.
56  * Offers filter actions.
57  * No dependency to the type hierarchy view
58  */

59 public class MethodsViewer extends ProblemTableViewer {
60     
61     private static final String JavaDoc TAG_SHOWINHERITED= "showinherited"; //$NON-NLS-1$
62
private static final String JavaDoc TAG_SORTBYDEFININGTYPE= "sortbydefiningtype"; //$NON-NLS-1$
63
private static final String JavaDoc TAG_VERTICAL_SCROLL= "mv_vertical_scroll"; //$NON-NLS-1$
64

65     private MethodsLabelProvider fLabelProvider;
66     
67     private MemberFilterActionGroup fMemberFilterActionGroup;
68     
69     private OpenAction fOpen;
70     private ShowInheritedMembersAction fShowInheritedMembersAction;
71     private SortByDefiningTypeAction fSortByDefiningTypeAction;
72     
73     public MethodsViewer(Composite parent, final TypeHierarchyLifeCycle lifeCycle, IWorkbenchPart part) {
74         super(new Table(parent, SWT.MULTI));
75         
76         addFilter(new SyntheticMembersFilter());
77         
78         fLabelProvider= new MethodsLabelProvider(lifeCycle, this);
79     
80         setLabelProvider(new DecoratingJavaLabelProvider(fLabelProvider, true));
81         setContentProvider(new MethodsContentProvider(lifeCycle));
82         
83         HierarchyViewerSorter sorter= new HierarchyViewerSorter(lifeCycle);
84         sorter.setSortByDefiningType(false);
85         setComparator(sorter);
86         
87         fOpen= new OpenAction(part.getSite());
88         addOpenListener(new IOpenListener() {
89             public void open(OpenEvent event) {
90                 fOpen.run();
91             }
92         });
93         
94         fMemberFilterActionGroup= new MemberFilterActionGroup(this, "HierarchyMethodView", false, MemberFilterActionGroup.ALL_FILTERS & ~MemberFilterActionGroup.FILTER_LOCALTYPES); //$NON-NLS-1$
95

96         fShowInheritedMembersAction= new ShowInheritedMembersAction(this, false);
97         fSortByDefiningTypeAction= new SortByDefiningTypeAction(this, false);
98         
99         showInheritedMethodsNoRedraw(false);
100         sortByDefiningTypeNoRedraw(false);
101         
102         ColoredViewersManager.install(this);
103         
104         JavaUIHelp.setHelp(this, IJavaHelpContextIds.TYPE_HIERARCHY_VIEW);
105     }
106
107     private void showInheritedMethodsNoRedraw(boolean on) {
108         MethodsContentProvider cprovider= (MethodsContentProvider) getContentProvider();
109         cprovider.showInheritedMethods(on);
110         fShowInheritedMembersAction.setChecked(on);
111         if (on) {
112             fLabelProvider.setTextFlags(fLabelProvider.getTextFlags() | JavaElementLabels.ALL_POST_QUALIFIED);
113         } else {
114             fLabelProvider.setTextFlags(fLabelProvider.getTextFlags() & ~JavaElementLabels.ALL_POST_QUALIFIED);
115         }
116         if (on) {
117             sortByDefiningTypeNoRedraw(false);
118         }
119         fSortByDefiningTypeAction.setEnabled(!on);
120
121     }
122     
123     /**
124      * Show inherited methods
125      * @param on the new state
126      */

127     public void showInheritedMethods(boolean on) {
128         if (on == isShowInheritedMethods()) {
129             return;
130         }
131         try {
132             getTable().setRedraw(false);
133             showInheritedMethodsNoRedraw(on);
134             refresh();
135         } finally {
136             getTable().setRedraw(true);
137         }
138     }
139
140     private void sortByDefiningTypeNoRedraw(boolean on) {
141         fSortByDefiningTypeAction.setChecked(on);
142         fLabelProvider.setShowDefiningType(on);
143         ((HierarchyViewerSorter) getComparator()).setSortByDefiningType(on);
144     }
145
146     /**
147      * Show the name of the defining type
148      * @param on the new state
149      */

150     public void sortByDefiningType(boolean on) {
151         if (on == isShowDefiningTypes()) {
152             return;
153         }
154         try {
155             getTable().setRedraw(false);
156             sortByDefiningTypeNoRedraw(on);
157             refresh();
158         } finally {
159             getTable().setRedraw(true);
160         }
161     }
162         
163     /*
164      * @see Viewer#inputChanged(Object, Object)
165      */

166     protected void inputChanged(Object JavaDoc input, Object JavaDoc oldInput) {
167         super.inputChanged(input, oldInput);
168     }
169     
170     /**
171      * Returns <code>true</code> if inherited methods are shown.
172      * @return <code>true</code> if inherited methods are shown.
173      */

174     public boolean isShowInheritedMethods() {
175         return ((MethodsContentProvider) getContentProvider()).isShowInheritedMethods();
176     }
177     
178     /**
179      * Returns <code>true</code> if defining types are shown.
180      * @return <code>true</code> if defining types are shown.
181      */

182     public boolean isShowDefiningTypes() {
183         return fLabelProvider.isShowDefiningType();
184     }
185
186     /**
187      * Saves the state of the filter actions
188      * @param memento the memento
189      */

190     public void saveState(IMemento memento) {
191         fMemberFilterActionGroup.saveState(memento);
192         
193         memento.putString(TAG_SHOWINHERITED, String.valueOf(isShowInheritedMethods()));
194         memento.putString(TAG_SORTBYDEFININGTYPE, String.valueOf(isShowDefiningTypes()));
195
196         ScrollBar bar= getTable().getVerticalBar();
197         int position= bar != null ? bar.getSelection() : 0;
198         memento.putString(TAG_VERTICAL_SCROLL, String.valueOf(position));
199     }
200
201     /**
202      * Restores the state of the filter actions
203      * @param memento the memento
204      */

205     public void restoreState(IMemento memento) {
206         fMemberFilterActionGroup.restoreState(memento);
207         getControl().setRedraw(false);
208         refresh();
209         getControl().setRedraw(true);
210         
211         boolean showInherited= Boolean.valueOf(memento.getString(TAG_SHOWINHERITED)).booleanValue();
212         showInheritedMethods(showInherited);
213         
214         boolean showDefiningTypes= Boolean.valueOf(memento.getString(TAG_SORTBYDEFININGTYPE)).booleanValue();
215         sortByDefiningType(showDefiningTypes);
216         
217         ScrollBar bar= getTable().getVerticalBar();
218         if (bar != null) {
219             Integer JavaDoc vScroll= memento.getInteger(TAG_VERTICAL_SCROLL);
220             if (vScroll != null) {
221                 bar.setSelection(vScroll.intValue());
222             }
223         }
224     }
225     
226     /**
227      * Attaches a contextmenu listener to the table
228      * @param menuListener the menu listener
229      * @param popupId the popup id
230      * @param viewSite the view site
231      */

232     public void initContextMenu(IMenuListener menuListener, String JavaDoc popupId, IWorkbenchPartSite viewSite) {
233         MenuManager menuMgr= new MenuManager();
234         menuMgr.setRemoveAllWhenShown(true);
235         menuMgr.addMenuListener(menuListener);
236         Menu menu= menuMgr.createContextMenu(getTable());
237         getTable().setMenu(menu);
238         viewSite.registerContextMenu(popupId, menuMgr, this);
239     }
240         
241     
242     /**
243      * Fills up the context menu with items for the method viewer
244      * Should be called by the creator of the context menu
245      * @param menu teh menu manager
246      */

247     public void contributeToContextMenu(IMenuManager menu) {
248     }
249
250     /**
251      * Fills up the tool bar with items for the method viewer
252      * Should be called by the creator of the tool bar
253      * @param tbm the tool bar manager
254      */

255     public void contributeToToolBar(ToolBarManager tbm) {
256         tbm.add(fShowInheritedMembersAction);
257         tbm.add(fSortByDefiningTypeAction);
258         tbm.add(new Separator());
259         fMemberFilterActionGroup.contributeToToolBar(tbm);
260     }
261     
262     public void dispose() {
263         if (fMemberFilterActionGroup != null) {
264             fMemberFilterActionGroup.dispose();
265             fMemberFilterActionGroup= null;
266         }
267     }
268
269     /*
270      * @see StructuredViewer#handleInvalidSelection(ISelection, ISelection)
271      */

272     protected void handleInvalidSelection(ISelection invalidSelection, ISelection newSelection) {
273         // on change of input, try to keep selected methods stable by selecting a method with the same
274
// signature: See #5466
275
List JavaDoc oldSelections= SelectionUtil.toList(invalidSelection);
276         List JavaDoc newSelections= SelectionUtil.toList(newSelection);
277         if (!oldSelections.isEmpty()) {
278             ArrayList JavaDoc newSelectionElements= new ArrayList JavaDoc(newSelections);
279             try {
280                 Object JavaDoc[] currElements= getFilteredChildren(getInput());
281                 for (int i= 0; i < oldSelections.size(); i++) {
282                     Object JavaDoc curr= oldSelections.get(i);
283                     if (curr instanceof IMethod && !newSelections.contains(curr)) {
284                         IMethod method= (IMethod) curr;
285                         if (method.exists()) {
286                             IMethod similar= findSimilarMethod(method, currElements);
287                             if (similar != null) {
288                                 newSelectionElements.add(similar);
289                             }
290                         }
291                     }
292                 }
293                 if (!newSelectionElements.isEmpty()) {
294                     newSelection= new StructuredSelection(newSelectionElements);
295                 } else if (currElements.length > 0) {
296                     newSelection= new StructuredSelection(currElements[0]);
297                 }
298             } catch (JavaModelException e) {
299                 JavaPlugin.log(e);
300             }
301         }
302         setSelection(newSelection);
303         updateSelection(newSelection);
304     }
305     
306     private IMethod findSimilarMethod(IMethod meth, Object JavaDoc[] elements) throws JavaModelException {
307         String JavaDoc name= meth.getElementName();
308         String JavaDoc[] paramTypes= meth.getParameterTypes();
309         boolean isConstructor= meth.isConstructor();
310         
311         for (int i= 0; i < elements.length; i++) {
312             Object JavaDoc curr= elements[i];
313             if (curr instanceof IMethod && JavaModelUtil.isSameMethodSignature(name, paramTypes, isConstructor, (IMethod) curr)) {
314                 return (IMethod) curr;
315             }
316         }
317         return null;
318     }
319
320
321
322 }
323
Popular Tags