KickJava   Java API By Example, From Geeks To Geeks.

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


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.lang.reflect.InvocationTargetException JavaDoc;
14 import java.util.ArrayList JavaDoc;
15 import java.util.List JavaDoc;
16
17 import org.eclipse.core.runtime.Assert;
18 import org.eclipse.core.runtime.IProgressMonitor;
19 import org.eclipse.core.runtime.IStatus;
20 import org.eclipse.core.runtime.OperationCanceledException;
21 import org.eclipse.core.runtime.Status;
22 import org.eclipse.core.runtime.jobs.Job;
23
24 import org.eclipse.swt.SWT;
25 import org.eclipse.swt.custom.BusyIndicator;
26 import org.eclipse.swt.custom.CLabel;
27 import org.eclipse.swt.custom.SashForm;
28 import org.eclipse.swt.custom.ViewForm;
29 import org.eclipse.swt.dnd.DND;
30 import org.eclipse.swt.dnd.DropTarget;
31 import org.eclipse.swt.dnd.DropTargetAdapter;
32 import org.eclipse.swt.dnd.Transfer;
33 import org.eclipse.swt.events.ControlEvent;
34 import org.eclipse.swt.events.ControlListener;
35 import org.eclipse.swt.events.FocusEvent;
36 import org.eclipse.swt.events.FocusListener;
37 import org.eclipse.swt.events.KeyAdapter;
38 import org.eclipse.swt.events.KeyEvent;
39 import org.eclipse.swt.events.KeyListener;
40 import org.eclipse.swt.graphics.Point;
41 import org.eclipse.swt.widgets.Composite;
42 import org.eclipse.swt.widgets.Control;
43 import org.eclipse.swt.widgets.Display;
44 import org.eclipse.swt.widgets.Label;
45 import org.eclipse.swt.widgets.ScrollBar;
46 import org.eclipse.swt.widgets.ToolBar;
47
48 import org.eclipse.help.IContextProvider;
49
50 import org.eclipse.jface.action.IMenuListener;
51 import org.eclipse.jface.action.IMenuManager;
52 import org.eclipse.jface.action.IStatusLineManager;
53 import org.eclipse.jface.action.IToolBarManager;
54 import org.eclipse.jface.action.MenuManager;
55 import org.eclipse.jface.action.Separator;
56 import org.eclipse.jface.action.ToolBarManager;
57 import org.eclipse.jface.dialogs.IDialogSettings;
58 import org.eclipse.jface.dialogs.MessageDialog;
59 import org.eclipse.jface.util.IPropertyChangeListener;
60 import org.eclipse.jface.util.PropertyChangeEvent;
61 import org.eclipse.jface.util.TransferDragSourceListener;
62 import org.eclipse.jface.util.TransferDropTargetListener;
63 import org.eclipse.jface.viewers.AbstractTreeViewer;
64 import org.eclipse.jface.viewers.IBasicPropertyConstants;
65 import org.eclipse.jface.viewers.ISelection;
66 import org.eclipse.jface.viewers.ISelectionChangedListener;
67 import org.eclipse.jface.viewers.IStructuredSelection;
68 import org.eclipse.jface.viewers.SelectionChangedEvent;
69 import org.eclipse.jface.viewers.StructuredSelection;
70 import org.eclipse.jface.viewers.StructuredViewer;
71
72 import org.eclipse.ui.IActionBars;
73 import org.eclipse.ui.IEditorPart;
74 import org.eclipse.ui.IMemento;
75 import org.eclipse.ui.IPageLayout;
76 import org.eclipse.ui.IPartListener2;
77 import org.eclipse.ui.IViewSite;
78 import org.eclipse.ui.IWorkbenchActionConstants;
79 import org.eclipse.ui.IWorkbenchPart;
80 import org.eclipse.ui.IWorkbenchPartReference;
81 import org.eclipse.ui.IWorkbenchPartSite;
82 import org.eclipse.ui.IWorkingSet;
83 import org.eclipse.ui.IWorkingSetManager;
84 import org.eclipse.ui.PartInitException;
85 import org.eclipse.ui.PlatformUI;
86 import org.eclipse.ui.actions.ActionContext;
87 import org.eclipse.ui.actions.ActionFactory;
88 import org.eclipse.ui.actions.ActionGroup;
89 import org.eclipse.ui.part.IShowInSource;
90 import org.eclipse.ui.part.IShowInTargetList;
91 import org.eclipse.ui.part.PageBook;
92 import org.eclipse.ui.part.ResourceTransfer;
93 import org.eclipse.ui.part.ShowInContext;
94 import org.eclipse.ui.part.ViewPart;
95
96 import org.eclipse.ui.views.navigator.LocalSelectionTransfer;
97
98 import org.eclipse.jdt.core.IJavaElement;
99 import org.eclipse.jdt.core.IMember;
100 import org.eclipse.jdt.core.IType;
101 import org.eclipse.jdt.core.ITypeHierarchy;
102 import org.eclipse.jdt.core.ITypeRoot;
103 import org.eclipse.jdt.core.JavaCore;
104 import org.eclipse.jdt.core.JavaModelException;
105
106 import org.eclipse.jdt.internal.corext.util.Messages;
107
108 import org.eclipse.jdt.ui.IContextMenuConstants;
109 import org.eclipse.jdt.ui.ITypeHierarchyViewPart;
110 import org.eclipse.jdt.ui.JavaElementLabels;
111 import org.eclipse.jdt.ui.JavaUI;
112 import org.eclipse.jdt.ui.PreferenceConstants;
113 import org.eclipse.jdt.ui.actions.CCPActionGroup;
114 import org.eclipse.jdt.ui.actions.GenerateActionGroup;
115 import org.eclipse.jdt.ui.actions.JavaSearchActionGroup;
116 import org.eclipse.jdt.ui.actions.OpenEditorActionGroup;
117 import org.eclipse.jdt.ui.actions.OpenViewActionGroup;
118 import org.eclipse.jdt.ui.actions.RefactorActionGroup;
119
120 import org.eclipse.jdt.internal.ui.IJavaHelpContextIds;
121 import org.eclipse.jdt.internal.ui.JavaPlugin;
122 import org.eclipse.jdt.internal.ui.actions.CompositeActionGroup;
123 import org.eclipse.jdt.internal.ui.actions.NewWizardsActionGroup;
124 import org.eclipse.jdt.internal.ui.actions.SelectAllAction;
125 import org.eclipse.jdt.internal.ui.dnd.DelegatingDropAdapter;
126 import org.eclipse.jdt.internal.ui.dnd.JdtViewerDragAdapter;
127 import org.eclipse.jdt.internal.ui.dnd.ResourceTransferDragAdapter;
128 import org.eclipse.jdt.internal.ui.javaeditor.EditorUtility;
129 import org.eclipse.jdt.internal.ui.packageview.SelectionTransferDragAdapter;
130 import org.eclipse.jdt.internal.ui.preferences.MembersOrderPreferenceCache;
131 import org.eclipse.jdt.internal.ui.util.ExceptionHandler;
132 import org.eclipse.jdt.internal.ui.util.JavaUIHelp;
133 import org.eclipse.jdt.internal.ui.viewsupport.IViewPartInputProvider;
134 import org.eclipse.jdt.internal.ui.viewsupport.JavaUILabelProvider;
135 import org.eclipse.jdt.internal.ui.viewsupport.SelectionProviderMediator;
136 import org.eclipse.jdt.internal.ui.viewsupport.StatusBarUpdater;
137 import org.eclipse.jdt.internal.ui.workingsets.WorkingSetFilterActionGroup;
138
139 /**
140  * view showing the super types/sub types of its input.
141  */

142 public class TypeHierarchyViewPart extends ViewPart implements ITypeHierarchyViewPart, IViewPartInputProvider {
143
144     private static final String JavaDoc DIALOGSTORE_HIERARCHYVIEW= "TypeHierarchyViewPart.hierarchyview"; //$NON-NLS-1$
145
private static final String JavaDoc DIALOGSTORE_VIEWLAYOUT= "TypeHierarchyViewPart.orientation"; //$NON-NLS-1$
146
private static final String JavaDoc DIALOGSTORE_QUALIFIED_NAMES= "TypeHierarchyViewPart.qualifiednames"; //$NON-NLS-1$
147
private static final String JavaDoc DIALOGSTORE_LINKEDITORS= "TypeHierarchyViewPart.linkeditors"; //$NON-NLS-1$
148

149     private static final String JavaDoc TAG_INPUT= "input"; //$NON-NLS-1$
150
private static final String JavaDoc TAG_VIEW= "view"; //$NON-NLS-1$
151
private static final String JavaDoc TAG_LAYOUT= "orientation"; //$NON-NLS-1$
152
private static final String JavaDoc TAG_RATIO= "ratio"; //$NON-NLS-1$
153
private static final String JavaDoc TAG_SELECTION= "selection"; //$NON-NLS-1$
154
private static final String JavaDoc TAG_VERTICAL_SCROLL= "vertical_scroll"; //$NON-NLS-1$
155
private static final String JavaDoc TAG_QUALIFIED_NAMES= "qualified_names"; //$NON-NLS-1$
156
private static final String JavaDoc TAG_EDITOR_LINKING= "link_editors"; //$NON-NLS-1$
157

158     private static final String JavaDoc GROUP_FOCUS= "group.focus"; //$NON-NLS-1$
159

160     
161
162     // the selected type in the hierarchy view
163
private IType fSelectedType;
164     // input element or null
165
private IJavaElement fInputElement;
166     
167     // history of input elements. No duplicates
168
private ArrayList JavaDoc fInputHistory;
169     
170     private IMemento fMemento;
171     private IDialogSettings fDialogSettings;
172     
173     private TypeHierarchyLifeCycle fHierarchyLifeCycle;
174     private ITypeHierarchyLifeCycleListener fTypeHierarchyLifeCycleListener;
175     
176     private IPropertyChangeListener fPropertyChangeListener;
177         
178     private SelectionProviderMediator fSelectionProviderMediator;
179     private ISelectionChangedListener fSelectionChangedListener;
180     private IPartListener2 fPartListener;
181
182     private int fCurrentLayout;
183     private boolean fInComputeLayout;
184     
185     private boolean fLinkingEnabled;
186     private boolean fShowQualifiedTypeNames;
187     private boolean fSelectInEditor;
188     
189     private boolean fIsVisible;
190     private boolean fNeedRefresh;
191     private boolean fIsEnableMemberFilter;
192     private boolean fIsRefreshRunnablePosted;
193     
194     private int fCurrentViewerIndex;
195     private TypeHierarchyViewer[] fAllViewers;
196     
197     private MethodsViewer fMethodsViewer;
198     
199     private SashForm fTypeMethodsSplitter;
200     private PageBook fViewerbook;
201     private PageBook fPagebook;
202     
203     private Label fNoHierarchyShownLabel;
204     private Label fEmptyTypesViewer;
205     
206     private ViewForm fTypeViewerViewForm;
207     private ViewForm fMethodViewerViewForm;
208     
209     private CLabel fMethodViewerPaneLabel;
210     private JavaUILabelProvider fPaneLabelProvider;
211     private Composite fParent;
212     
213     private ToggleViewAction[] fViewActions;
214     private ToggleLinkingAction fToggleLinkingAction;
215     private HistoryDropDownAction fHistoryDropDownAction;
216     private ToggleOrientationAction[] fToggleOrientationActions;
217     private EnableMemberFilterAction fEnableMemberFilterAction;
218     private ShowQualifiedTypeNamesAction fShowQualifiedTypeNamesAction;
219     private FocusOnTypeAction fFocusOnTypeAction;
220     private FocusOnSelectionAction fFocusOnSelectionAction;
221     private CompositeActionGroup fActionGroups;
222     private SelectAllAction fSelectAllAction;
223     
224     private WorkingSetFilterActionGroup fWorkingSetActionGroup;
225     private Job fRestoreStateJob;
226     
227     public TypeHierarchyViewPart() {
228         fSelectedType= null;
229         fInputElement= null;
230         fIsVisible= false;
231         fIsRefreshRunnablePosted= false;
232         fSelectInEditor= true;
233         fRestoreStateJob= null;
234         
235         fHierarchyLifeCycle= new TypeHierarchyLifeCycle();
236         fTypeHierarchyLifeCycleListener= new ITypeHierarchyLifeCycleListener() {
237             public void typeHierarchyChanged(TypeHierarchyLifeCycle typeHierarchy, IType[] changedTypes) {
238                 doTypeHierarchyChanged(typeHierarchy, changedTypes);
239             }
240         };
241         fHierarchyLifeCycle.addChangedListener(fTypeHierarchyLifeCycleListener);
242         
243         fPropertyChangeListener= new IPropertyChangeListener() {
244             public void propertyChange(PropertyChangeEvent event) {
245                 doPropertyChange(event);
246             }
247         };
248         PreferenceConstants.getPreferenceStore().addPropertyChangeListener(fPropertyChangeListener);
249
250         fIsEnableMemberFilter= false;
251         
252         fInputHistory= new ArrayList JavaDoc();
253         fAllViewers= null;
254                 
255         fViewActions= new ToggleViewAction[] {
256             new ToggleViewAction(this, HIERARCHY_MODE_CLASSIC),
257             new ToggleViewAction(this, HIERARCHY_MODE_SUPERTYPES),
258             new ToggleViewAction(this, HIERARCHY_MODE_SUBTYPES)
259         };
260         
261         fDialogSettings= JavaPlugin.getDefault().getDialogSettings();
262         
263         fHistoryDropDownAction= new HistoryDropDownAction(this);
264         fHistoryDropDownAction.setEnabled(false);
265         
266         fToggleOrientationActions= new ToggleOrientationAction[] {
267             new ToggleOrientationAction(this, VIEW_LAYOUT_VERTICAL),
268             new ToggleOrientationAction(this, VIEW_LAYOUT_HORIZONTAL),
269             new ToggleOrientationAction(this, VIEW_LAYOUT_AUTOMATIC),
270             new ToggleOrientationAction(this, VIEW_LAYOUT_SINGLE)
271         };
272             
273         fEnableMemberFilterAction= new EnableMemberFilterAction(this, false);
274         fShowQualifiedTypeNamesAction= new ShowQualifiedTypeNamesAction(this, false);
275         
276         fFocusOnTypeAction= new FocusOnTypeAction(this);
277         
278         fToggleLinkingAction= new ToggleLinkingAction(this);
279         
280         fPaneLabelProvider= new JavaUILabelProvider();
281
282         fFocusOnSelectionAction= new FocusOnSelectionAction(this);
283     
284         fPartListener= new IPartListener2() {
285             public void partVisible(IWorkbenchPartReference ref) {
286                 IWorkbenchPart part= ref.getPart(false);
287                 if (part == TypeHierarchyViewPart.this) {
288                     visibilityChanged(true);
289                 }
290             }
291
292             public void partHidden(IWorkbenchPartReference ref) {
293                 IWorkbenchPart part= ref.getPart(false);
294                 if (part == TypeHierarchyViewPart.this) {
295                     visibilityChanged(false);
296                 }
297             }
298
299             public void partActivated(IWorkbenchPartReference ref) {
300                 IWorkbenchPart part= ref.getPart(false);
301                 if (part instanceof IEditorPart)
302                     editorActivated((IEditorPart) part);
303             }
304
305             public void partInputChanged(IWorkbenchPartReference ref) {
306                 IWorkbenchPart part= ref.getPart(false);
307                 if (part instanceof IEditorPart)
308                     editorActivated((IEditorPart) part);
309             }
310
311             public void partBroughtToTop(IWorkbenchPartReference ref) {}
312             public void partClosed(IWorkbenchPartReference ref) {}
313             public void partDeactivated(IWorkbenchPartReference ref) {}
314             public void partOpened(IWorkbenchPartReference ref) {}
315         };
316         
317         fSelectionChangedListener= new ISelectionChangedListener() {
318             public void selectionChanged(SelectionChangedEvent event) {
319                 doSelectionChanged(event);
320             }
321         };
322     }
323
324     /**
325      * Method doPropertyChange.
326      * @param event
327      */

328     protected void doPropertyChange(PropertyChangeEvent event) {
329         String JavaDoc property= event.getProperty();
330         if (fMethodsViewer != null) {
331             if (MembersOrderPreferenceCache.isMemberOrderProperty(event.getProperty())) {
332                 fMethodsViewer.refresh();
333             }
334         }
335         if (IWorkingSetManager.CHANGE_WORKING_SET_CONTENT_CHANGE.equals(property)) {
336             updateHierarchyViewer(true);
337             updateTitle();
338         }
339     }
340         
341     /**
342      * Adds the entry if new. Inserted at the beginning of the history entries list.
343      * @param entry The new entry
344      */

345     private void addHistoryEntry(IJavaElement entry) {
346         if (fInputHistory.contains(entry)) {
347             fInputHistory.remove(entry);
348         }
349         fInputHistory.add(0, entry);
350         fHistoryDropDownAction.setEnabled(true);
351     }
352     
353     private void updateHistoryEntries() {
354         for (int i= fInputHistory.size() - 1; i >= 0; i--) {
355             IJavaElement type= (IJavaElement) fInputHistory.get(i);
356             if (!type.exists()) {
357                 fInputHistory.remove(i);
358             }
359         }
360         fHistoryDropDownAction.setEnabled(!fInputHistory.isEmpty());
361     }
362     
363     /**
364      * Goes to the selected entry, without updating the order of history entries.
365      * @param entry The entry to open
366      */

367     public void gotoHistoryEntry(IJavaElement entry) {
368         if (fInputHistory.contains(entry)) {
369             updateInput(entry);
370         }
371     }
372     
373     /**
374      * Gets all history entries.
375      * @return All history entries
376      */

377     public IJavaElement[] getHistoryEntries() {
378         if (fInputHistory.size() > 0) {
379             updateHistoryEntries();
380         }
381         return (IJavaElement[]) fInputHistory.toArray(new IJavaElement[fInputHistory.size()]);
382     }
383     
384     /**
385      * Sets the history entries
386      * @param elems The history elements to set
387      */

388     public void setHistoryEntries(IJavaElement[] elems) {
389         fInputHistory.clear();
390         for (int i= 0; i < elems.length; i++) {
391             fInputHistory.add(elems[i]);
392         }
393         updateHistoryEntries();
394     }
395     
396     /**
397      * Selects an member in the methods list or in the current hierarchy.
398      * @param member The member to select
399      */

400     public void selectMember(IMember member) {
401         fSelectInEditor= false;
402         if (member.getElementType() != IJavaElement.TYPE) {
403             Control methodControl= fMethodsViewer.getControl();
404             if (methodControl != null && !methodControl.isDisposed()) {
405                 methodControl.setFocus();
406             }
407
408             fMethodsViewer.setSelection(new StructuredSelection(member), true);
409         } else {
410             Control viewerControl= getCurrentViewer().getControl();
411             if (viewerControl != null && !viewerControl.isDisposed()) {
412                 viewerControl.setFocus();
413             }
414             
415             if (!member.equals(fSelectedType)) {
416                 getCurrentViewer().setSelection(new StructuredSelection(member), true);
417             }
418         }
419         fSelectInEditor= true;
420     }
421
422     /**
423      * @return The input type
424      * @deprecated
425      */

426     public IType getInput() {
427         if (fInputElement instanceof IType) {
428             return (IType) fInputElement;
429         }
430         return null;
431     }
432     
433     /**
434      * Sets the input to a new type
435      * @param type The new input type
436      * @deprecated
437      */

438     public void setInput(IType type) {
439         setInputElement(type);
440     }
441     
442     /**
443      * Returns the input element of the type hierarchy.
444      * Can be of type <code>IType</code> or <code>IPackageFragment</code>
445      * @return the input element
446      */

447     public IJavaElement getInputElement() {
448         return fInputElement;
449     }
450         
451
452     /**
453      * Sets the input to a new element.
454      * @param element the input element
455      */

456     public void setInputElement(IJavaElement element) {
457         IMember memberToSelect= null;
458         if (element != null) {
459             if (element instanceof IMember) {
460                 if (element.getElementType() != IJavaElement.TYPE) {
461                     memberToSelect= (IMember) element;
462                     element= memberToSelect.getDeclaringType();
463                     
464                 }
465                 if (!element.exists()) {
466                     MessageDialog.openError(getSite().getShell(), TypeHierarchyMessages.TypeHierarchyViewPart_error_title, TypeHierarchyMessages.TypeHierarchyViewPart_error_message);
467                     return;
468                 }
469             } else {
470                 int kind= element.getElementType();
471                 if (kind != IJavaElement.JAVA_PROJECT && kind != IJavaElement.PACKAGE_FRAGMENT_ROOT && kind != IJavaElement.PACKAGE_FRAGMENT) {
472                     element= null;
473                     JavaPlugin.logErrorMessage("Invalid type hierarchy input type.");//$NON-NLS-1$
474
}
475             }
476         }
477         if (element != null && !element.equals(fInputElement)) {
478             addHistoryEntry(element);
479         }
480             
481         updateInput(element);
482         if (memberToSelect != null) {
483             selectMember(memberToSelect);
484         }
485     }
486     
487     /*
488      * Changes the input to a new type
489      * @param inputElement
490      */

491     private void updateInput(IJavaElement inputElement) {
492         IJavaElement prevInput= fInputElement;
493         
494         synchronized (this) {
495             if (fRestoreStateJob != null) {
496                 fRestoreStateJob.cancel();
497                 try {
498                     fRestoreStateJob.join();
499                 } catch (InterruptedException JavaDoc e) {
500                     // ignore
501
} finally {
502                     fRestoreStateJob= null;
503                 }
504             }
505         }
506         
507         // Make sure the UI got repainted before we execute a long running
508
// operation. This can be removed if we refresh the hierarchy in a
509
// separate thread.
510
// Work-around for http://dev.eclipse.org/bugs/show_bug.cgi?id=30881
511
processOutstandingEvents();
512         if (inputElement == null) {
513             clearInput();
514         } else {
515             fInputElement= inputElement;
516             fNoHierarchyShownLabel.setText(Messages.format(TypeHierarchyMessages.TypeHierarchyViewPart_createinput, inputElement.getElementName()));
517             try {
518                 fHierarchyLifeCycle.ensureRefreshedTypeHierarchy(inputElement, JavaPlugin.getActiveWorkbenchWindow());
519                 // fHierarchyLifeCycle.ensureRefreshedTypeHierarchy(inputElement, getSite().getWorkbenchWindow());
520
} catch (InvocationTargetException JavaDoc e) {
521                 ExceptionHandler.handle(e, getSite().getShell(), TypeHierarchyMessages.TypeHierarchyViewPart_exception_title, TypeHierarchyMessages.TypeHierarchyViewPart_exception_message);
522                 clearInput();
523                 return;
524             } catch (InterruptedException JavaDoc e) {
525                 fNoHierarchyShownLabel.setText(TypeHierarchyMessages.TypeHierarchyViewPart_empty);
526                 return;
527             }
528                 
529             if (inputElement.getElementType() != IJavaElement.TYPE) {
530                 setHierarchyMode(HIERARCHY_MODE_CLASSIC);
531             }
532             // turn off member filtering
533
fSelectInEditor= false;
534             setMemberFilter(null);
535             internalSelectType(null, false); // clear selection
536
fIsEnableMemberFilter= false;
537             if (!inputElement.equals(prevInput)) {
538                 updateHierarchyViewer(true);
539             }
540             IType root= getSelectableType(inputElement);
541             internalSelectType(root, true);
542             updateMethodViewer(root);
543             updateToolbarButtons();
544             updateTitle();
545             showMembersInHierarchy(false);
546             fPagebook.showPage(fTypeMethodsSplitter);
547             fSelectInEditor= true;
548         }
549     }
550     
551     private void processOutstandingEvents() {
552         Display display= getDisplay();
553         if (display != null && !display.isDisposed())
554             display.update();
555     }
556     
557     private void clearInput() {
558         fInputElement= null;
559         fHierarchyLifeCycle.freeHierarchy();
560         
561         updateHierarchyViewer(false);
562         updateToolbarButtons();
563     }
564
565     /*
566      * @see IWorbenchPart#setFocus
567      */

568     public void setFocus() {
569         fPagebook.setFocus();
570     }
571
572     /*
573      * @see IWorkbenchPart#dispose
574      */

575     public void dispose() {
576         fHierarchyLifeCycle.freeHierarchy();
577         fHierarchyLifeCycle.removeChangedListener(fTypeHierarchyLifeCycleListener);
578         fPaneLabelProvider.dispose();
579         
580         if (fMethodsViewer != null) {
581             fMethodsViewer.dispose();
582         }
583         
584         if (fPropertyChangeListener != null) {
585             JavaPlugin.getDefault().getPreferenceStore().removePropertyChangeListener(fPropertyChangeListener);
586             fPropertyChangeListener= null;
587         }
588         
589         getSite().getPage().removePartListener(fPartListener);
590
591         if (fActionGroups != null)
592             fActionGroups.dispose();
593         
594         if (fWorkingSetActionGroup != null) {
595             fWorkingSetActionGroup.dispose();
596         }
597         
598         super.dispose();
599     }
600         
601     /* (non-Javadoc)
602      * @see org.eclipse.core.runtime.IAdaptable#getAdapter(java.lang.Class)
603      */

604     public Object JavaDoc getAdapter(Class JavaDoc key) {
605         if (key == IShowInSource.class) {
606             return getShowInSource();
607         }
608         if (key == IShowInTargetList.class) {
609             return new IShowInTargetList() {
610                 public String JavaDoc[] getShowInTargetIds() {
611                     return new String JavaDoc[] { JavaUI.ID_PACKAGES, IPageLayout.ID_RES_NAV };
612                 }
613
614             };
615         }
616         if (key == IContextProvider.class) {
617             return JavaUIHelp.getHelpContextProvider(this, IJavaHelpContextIds.TYPE_HIERARCHY_VIEW);
618         }
619         return super.getAdapter(key);
620     }
621     
622     private Control createTypeViewerControl(Composite parent) {
623         fViewerbook= new PageBook(parent, SWT.NULL);
624                 
625         KeyListener keyListener= createKeyListener();
626                         
627         // Create the viewers
628
TypeHierarchyViewer superTypesViewer= new SuperTypeHierarchyViewer(fViewerbook, fHierarchyLifeCycle, this);
629         initializeTypesViewer(superTypesViewer, keyListener, IContextMenuConstants.TARGET_ID_SUPERTYPES_VIEW);
630         
631         TypeHierarchyViewer subTypesViewer= new SubTypeHierarchyViewer(fViewerbook, fHierarchyLifeCycle, this);
632         initializeTypesViewer(subTypesViewer, keyListener, IContextMenuConstants.TARGET_ID_SUBTYPES_VIEW);
633         
634         TypeHierarchyViewer vajViewer= new TraditionalHierarchyViewer(fViewerbook, fHierarchyLifeCycle, this);
635         initializeTypesViewer(vajViewer, keyListener, IContextMenuConstants.TARGET_ID_HIERARCHY_VIEW);
636
637         fAllViewers= new TypeHierarchyViewer[3];
638         fAllViewers[HIERARCHY_MODE_SUPERTYPES]= superTypesViewer;
639         fAllViewers[HIERARCHY_MODE_SUBTYPES]= subTypesViewer;
640         fAllViewers[HIERARCHY_MODE_CLASSIC]= vajViewer;
641         
642         int currViewerIndex;
643         try {
644             currViewerIndex= fDialogSettings.getInt(DIALOGSTORE_HIERARCHYVIEW);
645             if (currViewerIndex < 0 || currViewerIndex > 2) {
646                 currViewerIndex= HIERARCHY_MODE_CLASSIC;
647             }
648         } catch (NumberFormatException JavaDoc e) {
649             currViewerIndex= HIERARCHY_MODE_CLASSIC;
650         }
651             
652         fEmptyTypesViewer= new Label(fViewerbook, SWT.TOP | SWT.LEFT | SWT.WRAP);
653         
654         for (int i= 0; i < fAllViewers.length; i++) {
655             fAllViewers[i].setInput(fAllViewers[i]);
656         }
657         
658         // force the update
659
fCurrentViewerIndex= -1;
660         setHierarchyMode(currViewerIndex);
661                 
662         return fViewerbook;
663     }
664     
665     private KeyListener createKeyListener() {
666         return new KeyAdapter() {
667             public void keyReleased(KeyEvent event) {
668                 if (event.stateMask == 0) {
669                     if (event.keyCode == SWT.F5) {
670                         ITypeHierarchy hierarchy= fHierarchyLifeCycle.getHierarchy();
671                         if (hierarchy != null) {
672                             fHierarchyLifeCycle.typeHierarchyChanged(hierarchy);
673                             doTypeHierarchyChangedOnViewers(null);
674                         }
675                         updateHierarchyViewer(false);
676                         return;
677                     }
678                 }
679             }
680         };
681     }
682     
683
684     private void initializeTypesViewer(final TypeHierarchyViewer typesViewer, KeyListener keyListener, String JavaDoc cotextHelpId) {
685         typesViewer.getControl().setVisible(false);
686         typesViewer.getControl().addKeyListener(keyListener);
687         typesViewer.initContextMenu(new IMenuListener() {
688             public void menuAboutToShow(IMenuManager menu) {
689                 fillTypesViewerContextMenu(typesViewer, menu);
690             }
691         }, cotextHelpId, getSite());
692         typesViewer.addPostSelectionChangedListener(fSelectionChangedListener);
693         typesViewer.setQualifiedTypeName(isQualifiedTypeNamesEnabled());
694         typesViewer.setWorkingSetFilter(fWorkingSetActionGroup.getWorkingSetFilter());
695     }
696     
697     private Control createMethodViewerControl(Composite parent) {
698         fMethodsViewer= new MethodsViewer(parent, fHierarchyLifeCycle, this);
699         fMethodsViewer.initContextMenu(new IMenuListener() {
700             public void menuAboutToShow(IMenuManager menu) {
701                 fillMethodsViewerContextMenu(menu);
702             }
703         }, IContextMenuConstants.TARGET_ID_MEMBERS_VIEW, getSite());
704         fMethodsViewer.addPostSelectionChangedListener(fSelectionChangedListener);
705         
706         Control control= fMethodsViewer.getTable();
707         control.addKeyListener(createKeyListener());
708         control.addFocusListener(new FocusListener() {
709             public void focusGained(FocusEvent e) {
710                 fSelectAllAction.setEnabled(true);
711             }
712
713             public void focusLost(FocusEvent e) {
714                 fSelectAllAction.setEnabled(false);
715             }
716         });
717         
718         return control;
719     }
720     
721     private void initDragAndDrop() {
722         for (int i= 0; i < fAllViewers.length; i++) {
723             addDragAdapters(fAllViewers[i]);
724             addDropAdapters(fAllViewers[i]);
725         }
726         addDragAdapters(fMethodsViewer);
727         fMethodsViewer.addDropSupport(DND.DROP_NONE, new Transfer[0], new DropTargetAdapter());
728
729         //DND on empty hierarchy
730
DropTarget dropTarget = new DropTarget(fPagebook, DND.DROP_MOVE | DND.DROP_COPY | DND.DROP_LINK | DND.DROP_DEFAULT);
731         dropTarget.setTransfer(new Transfer[] { LocalSelectionTransfer.getInstance() });
732         dropTarget.addDropListener(new TypeHierarchyTransferDropAdapter(this, fAllViewers[0]));
733     }
734     
735     private void addDropAdapters(AbstractTreeViewer viewer) {
736         Transfer[] transfers= new Transfer[] { LocalSelectionTransfer.getInstance() };
737         int ops= DND.DROP_MOVE | DND.DROP_COPY | DND.DROP_LINK | DND.DROP_DEFAULT;
738         
739         TransferDropTargetListener[] dropListeners= new TransferDropTargetListener[] {
740             new TypeHierarchyTransferDropAdapter(this, viewer)
741         };
742         viewer.addDropSupport(ops, transfers, new DelegatingDropAdapter(dropListeners));
743     }
744
745     private void addDragAdapters(StructuredViewer viewer) {
746         int ops= DND.DROP_COPY | DND.DROP_LINK;
747         Transfer[] transfers= new Transfer[] { LocalSelectionTransfer.getInstance(), ResourceTransfer.getInstance()};
748
749         TransferDragSourceListener[] dragListeners= new TransferDragSourceListener[] {
750             new SelectionTransferDragAdapter(viewer),
751             new ResourceTransferDragAdapter(viewer)
752         };
753         viewer.addDragSupport(ops, transfers, new JdtViewerDragAdapter(viewer, dragListeners));
754     }
755             
756     /**
757      * Returns the inner component in a workbench part.
758      * @see IWorkbenchPart#createPartControl(Composite)
759      */

760     public void createPartControl(Composite container) {
761         fParent= container;
762         addResizeListener(container);
763
764         fPagebook= new PageBook(container, SWT.NONE);
765         fWorkingSetActionGroup= new WorkingSetFilterActionGroup(getSite(), fPropertyChangeListener);
766
767         // page 1 of page book (no hierarchy label)
768

769         fNoHierarchyShownLabel= new Label(fPagebook, SWT.TOP + SWT.LEFT + SWT.WRAP);
770         fNoHierarchyShownLabel.setText(TypeHierarchyMessages.TypeHierarchyViewPart_empty);
771         
772         // page 2 of page book (viewers)
773

774         fTypeMethodsSplitter= new SashForm(fPagebook, SWT.VERTICAL);
775         fTypeMethodsSplitter.setVisible(false);
776
777         fTypeViewerViewForm= new ViewForm(fTypeMethodsSplitter, SWT.NONE);
778                         
779         Control typeViewerControl= createTypeViewerControl(fTypeViewerViewForm);
780         fTypeViewerViewForm.setContent(typeViewerControl);
781                 
782         fMethodViewerViewForm= new ViewForm(fTypeMethodsSplitter, SWT.NONE);
783         fTypeMethodsSplitter.setWeights(new int[] {35, 65});
784         
785         Control methodViewerPart= createMethodViewerControl(fMethodViewerViewForm);
786         fMethodViewerViewForm.setContent(methodViewerPart);
787         
788         fMethodViewerPaneLabel= new CLabel(fMethodViewerViewForm, SWT.NONE);
789         fMethodViewerViewForm.setTopLeft(fMethodViewerPaneLabel);
790                 
791         ToolBar methodViewerToolBar= new ToolBar(fMethodViewerViewForm, SWT.FLAT | SWT.WRAP);
792         fMethodViewerViewForm.setTopCenter(methodViewerToolBar);
793
794         initDragAndDrop();
795         
796         MenuManager menu= new MenuManager();
797         menu.add(fFocusOnTypeAction);
798         fNoHierarchyShownLabel.setMenu(menu.createContextMenu(fNoHierarchyShownLabel));
799         
800         fPagebook.showPage(fNoHierarchyShownLabel);
801
802         int layout;
803         try {
804             layout= fDialogSettings.getInt(DIALOGSTORE_VIEWLAYOUT);
805             if (layout < 0 || layout > 3) {
806                 layout= VIEW_LAYOUT_AUTOMATIC;
807             }
808         } catch (NumberFormatException JavaDoc e) {
809             layout= VIEW_LAYOUT_AUTOMATIC;
810         }
811         // force the update
812
fCurrentLayout= -1;
813         // will fill the main tool bar
814
setViewLayout(layout);
815             
816         showQualifiedTypeNames(fDialogSettings.getBoolean(DIALOGSTORE_QUALIFIED_NAMES));
817         setLinkingEnabled(fDialogSettings.getBoolean(DIALOGSTORE_LINKEDITORS));
818
819         // set the filter menu items
820
IActionBars actionBars= getViewSite().getActionBars();
821         IMenuManager viewMenu= actionBars.getMenuManager();
822         for (int i= 0; i < fViewActions.length; i++) {
823             ToggleViewAction action= fViewActions[i];
824             viewMenu.add(action);
825             action.setEnabled(false);
826         }
827         viewMenu.add(new Separator());
828         
829         fWorkingSetActionGroup.fillViewMenu(viewMenu);
830         
831         viewMenu.add(new Separator());
832         
833         IMenuManager layoutSubMenu= new MenuManager(TypeHierarchyMessages.TypeHierarchyViewPart_layout_submenu);
834         viewMenu.add(layoutSubMenu);
835         for (int i= 0; i < fToggleOrientationActions.length; i++) {
836             layoutSubMenu.add(fToggleOrientationActions[i]);
837         }
838         viewMenu.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));
839         viewMenu.add(fShowQualifiedTypeNamesAction);
840         viewMenu.add(fToggleLinkingAction);
841         
842     
843         // fill the method viewer tool bar
844
ToolBarManager lowertbmanager= new ToolBarManager(methodViewerToolBar);
845         lowertbmanager.add(fEnableMemberFilterAction);
846         lowertbmanager.add(new Separator());
847         fMethodsViewer.contributeToToolBar(lowertbmanager);
848         lowertbmanager.update(true);
849                             
850         // selection provider
851
int nHierarchyViewers= fAllViewers.length;
852         StructuredViewer[] trackedViewers= new StructuredViewer[nHierarchyViewers + 1];
853         for (int i= 0; i < nHierarchyViewers; i++) {
854             trackedViewers[i]= fAllViewers[i];
855         }
856         trackedViewers[nHierarchyViewers]= fMethodsViewer;
857         fSelectionProviderMediator= new SelectionProviderMediator(trackedViewers, getCurrentViewer());
858         IStatusLineManager slManager= getViewSite().getActionBars().getStatusLineManager();
859         fSelectionProviderMediator.addSelectionChangedListener(new StatusBarUpdater(slManager));
860         
861         getSite().setSelectionProvider(fSelectionProviderMediator);
862         getSite().getPage().addPartListener(fPartListener);
863         
864         // see http://bugs.eclipse.org/bugs/show_bug.cgi?id=33657
865
IJavaElement input= null; //determineInputElement();
866
if (fMemento != null) {
867             restoreState(fMemento, input);
868         } else if (input != null) {
869             setInputElement(input);
870         } else {
871             setViewerVisibility(false);
872         }
873
874         PlatformUI.getWorkbench().getHelpSystem().setHelp(fPagebook, IJavaHelpContextIds.TYPE_HIERARCHY_VIEW);
875         
876         
877         fActionGroups= new CompositeActionGroup(new ActionGroup[] {
878                 new NewWizardsActionGroup(this.getSite()),
879                 new OpenEditorActionGroup(this),
880                 new OpenViewActionGroup(this),
881                 new CCPActionGroup(this),
882                 new GenerateActionGroup(this),
883                 new RefactorActionGroup(this),
884                 new JavaSearchActionGroup(this)
885         });
886         
887         fActionGroups.fillActionBars(actionBars);
888         fSelectAllAction= new SelectAllAction(fMethodsViewer);
889         
890         actionBars.setGlobalActionHandler(ActionFactory.SELECT_ALL.getId(), fSelectAllAction);
891     }
892
893     private void addResizeListener(Composite parent) {
894         parent.addControlListener(new ControlListener() {
895             public void controlMoved(ControlEvent e) {
896             }
897             public void controlResized(ControlEvent e) {
898                 if (getViewLayout() == VIEW_LAYOUT_AUTOMATIC && !fInComputeLayout) {
899                     setViewLayout(VIEW_LAYOUT_AUTOMATIC);
900                 }
901             }
902         });
903     }
904
905     /* (non-Javadoc)
906      * @see org.eclipse.jdt.ui.ITypeHierarchyViewPart#setViewLayout(int)
907      */

908     public void setViewLayout(int layout) {
909         if (fCurrentLayout != layout || layout == VIEW_LAYOUT_AUTOMATIC) {
910             fInComputeLayout= true;
911             try {
912                 boolean methodViewerNeedsUpdate= false;
913                 
914                 if (fMethodViewerViewForm != null && !fMethodViewerViewForm.isDisposed()
915                         && fTypeMethodsSplitter != null && !fTypeMethodsSplitter.isDisposed()) {
916                     
917                     boolean horizontal= false;
918                     if (layout == VIEW_LAYOUT_SINGLE) {
919                         fMethodViewerViewForm.setVisible(false);
920                         showMembersInHierarchy(false);
921                         updateMethodViewer(null);
922                     } else {
923                         if (fCurrentLayout == VIEW_LAYOUT_SINGLE) {
924                             fMethodViewerViewForm.setVisible(true);
925                             methodViewerNeedsUpdate= true;
926                         }
927                         if (layout == VIEW_LAYOUT_AUTOMATIC) {
928                             if (fParent != null && !fParent.isDisposed()) {
929                                 Point size= fParent.getSize();
930                                 if (size.x != 0 && size.y != 0) {
931                                     // bug 185397 - Hierarchy View flips orientation multiple times on resize
932
Control viewFormToolbar= fTypeViewerViewForm.getTopLeft();
933                                     if (viewFormToolbar != null && !viewFormToolbar.isDisposed() && viewFormToolbar.isVisible()) {
934                                         size.y -= viewFormToolbar.getSize().y;
935                                     }
936                                     horizontal= size.x > size.y;
937                                 }
938                             }
939                             if (fCurrentLayout == VIEW_LAYOUT_AUTOMATIC) {
940                                 boolean wasHorizontal= fTypeMethodsSplitter.getOrientation() == SWT.HORIZONTAL;
941                                 if (wasHorizontal == horizontal) {
942                                     return; // no real change
943
}
944                             }
945                             
946                         } else if (layout == VIEW_LAYOUT_HORIZONTAL) {
947                             horizontal= true;
948                         }
949                         fTypeMethodsSplitter.setOrientation(horizontal ? SWT.HORIZONTAL : SWT.VERTICAL);
950                     }
951                     updateMainToolbar(horizontal);
952                     fTypeMethodsSplitter.layout();
953                 }
954                 if (methodViewerNeedsUpdate) {
955                     updateMethodViewer(fSelectedType);
956                 }
957                 fDialogSettings.put(DIALOGSTORE_VIEWLAYOUT, layout);
958                 fCurrentLayout= layout;
959                 
960                 updateCheckedState();
961             } finally {
962                 fInComputeLayout= false;
963             }
964         }
965     }
966     
967     /* (non-Javadoc)
968      * @see org.eclipse.jdt.ui.ITypeHierarchyViewPart#getViewLayout()
969      */

970     public int getViewLayout() {
971         return fCurrentLayout;
972     }
973         
974     private void updateCheckedState() {
975         for (int i= 0; i < fToggleOrientationActions.length; i++) {
976             fToggleOrientationActions[i].setChecked(getViewLayout() == fToggleOrientationActions[i].getOrientation());
977         }
978     }
979
980     private void updateMainToolbar(boolean horizontal) {
981         IActionBars actionBars= getViewSite().getActionBars();
982         IToolBarManager tbmanager= actionBars.getToolBarManager();
983                 
984         if (horizontal) {
985             clearMainToolBar(tbmanager);
986             ToolBar typeViewerToolBar= new ToolBar(fTypeViewerViewForm, SWT.FLAT | SWT.WRAP);
987             fillMainToolBar(new ToolBarManager(typeViewerToolBar));
988             fTypeViewerViewForm.setTopLeft(typeViewerToolBar);
989         } else {
990             fTypeViewerViewForm.setTopLeft(null);
991             fillMainToolBar(tbmanager);
992         }
993     }
994     
995     private void fillMainToolBar(IToolBarManager tbmanager) {
996         tbmanager.removeAll();
997         for (int i= 0; i < fViewActions.length; i++) {
998             tbmanager.add(fViewActions[i]);
999         }
1000        tbmanager.add(fHistoryDropDownAction);
1001        tbmanager.update(false);
1002    }
1003
1004    private void clearMainToolBar(IToolBarManager tbmanager) {
1005        tbmanager.removeAll();
1006        tbmanager.update(false);
1007    }
1008    
1009    
1010    /*
1011     * Creates the context menu for the hierarchy viewers
1012     */

1013    private void fillTypesViewerContextMenu(TypeHierarchyViewer viewer, IMenuManager menu) {
1014        JavaPlugin.createStandardGroups(menu);
1015        
1016        menu.appendToGroup(IContextMenuConstants.GROUP_SHOW, new Separator(GROUP_FOCUS));
1017        // viewer entries
1018
viewer.contributeToContextMenu(menu);
1019        
1020        if (fFocusOnSelectionAction.canActionBeAdded())
1021            menu.appendToGroup(GROUP_FOCUS, fFocusOnSelectionAction);
1022        menu.appendToGroup(GROUP_FOCUS, fFocusOnTypeAction);
1023
1024        fActionGroups.setContext(new ActionContext(getSite().getSelectionProvider().getSelection()));
1025        fActionGroups.fillContextMenu(menu);
1026        fActionGroups.setContext(null);
1027    }
1028
1029    /*
1030     * Creates the context menu for the method viewer
1031     */

1032    private void fillMethodsViewerContextMenu(IMenuManager menu) {
1033        JavaPlugin.createStandardGroups(menu);
1034        // viewer entries
1035
fMethodsViewer.contributeToContextMenu(menu);
1036        fActionGroups.setContext(new ActionContext(getSite().getSelectionProvider().getSelection()));
1037        fActionGroups.fillContextMenu(menu);
1038        fActionGroups.setContext(null);
1039    }
1040    
1041    /*
1042     * Toggles between the empty viewer page and the hierarchy
1043     */

1044    private void setViewerVisibility(boolean showHierarchy) {
1045        if (showHierarchy) {
1046            fViewerbook.showPage(getCurrentViewer().getControl());
1047        } else {
1048            fViewerbook.showPage(fEmptyTypesViewer);
1049        }
1050    }
1051    
1052    /*
1053     * Sets the member filter. <code>null</code> disables member filtering.
1054     */

1055    private void setMemberFilter(IMember[] memberFilter) {
1056        Assert.isNotNull(fAllViewers);
1057        for (int i= 0; i < fAllViewers.length; i++) {
1058            fAllViewers[i].setMemberFilter(memberFilter);
1059        }
1060    }
1061    
1062    private IType getSelectableType(IJavaElement elem) {
1063        if (elem.getElementType() != IJavaElement.TYPE) {
1064            return getCurrentViewer().getTreeRootType();
1065        } else {
1066            return (IType) elem;
1067        }
1068    }
1069    
1070    private void internalSelectType(IMember elem, boolean reveal) {
1071        TypeHierarchyViewer viewer= getCurrentViewer();
1072        viewer.removePostSelectionChangedListener(fSelectionChangedListener);
1073        viewer.setSelection(elem != null ? new StructuredSelection(elem) : StructuredSelection.EMPTY, reveal);
1074        viewer.addPostSelectionChangedListener(fSelectionChangedListener);
1075    }
1076        
1077    /*
1078     * When the input changed or the hierarchy pane becomes visible,
1079     * <code>updateHierarchyViewer<code> brings up the correct view and refreshes
1080     * the current tree
1081     */

1082    private void updateHierarchyViewer(final boolean doExpand) {
1083        if (fInputElement == null) {
1084            fNoHierarchyShownLabel.setText(TypeHierarchyMessages.TypeHierarchyViewPart_empty);
1085            fPagebook.showPage(fNoHierarchyShownLabel);
1086        } else {
1087            if (getCurrentViewer().containsElements() != null) {
1088                Runnable JavaDoc runnable= new Runnable JavaDoc() {
1089                    public void run() {
1090                        getCurrentViewer().updateContent(doExpand); // refresh
1091
}
1092                };
1093                BusyIndicator.showWhile(getDisplay(), runnable);
1094                if (!isChildVisible(fViewerbook, getCurrentViewer().getControl())) {
1095                    setViewerVisibility(true);
1096                }
1097            } else {
1098                fEmptyTypesViewer.setText(Messages.format(TypeHierarchyMessages.TypeHierarchyViewPart_nodecl, fInputElement.getElementName()));
1099                setViewerVisibility(false);
1100            }
1101        }
1102    }
1103    
1104    private void updateMethodViewer(final IType input) {
1105        if (!fIsEnableMemberFilter && fCurrentLayout != VIEW_LAYOUT_SINGLE) {
1106            if (input == fMethodsViewer.getInput()) {
1107                if (input != null) {
1108                    Runnable JavaDoc runnable= new Runnable JavaDoc() {
1109                        public void run() {
1110                            fMethodsViewer.refresh(); // refresh
1111
}
1112                    };
1113                    BusyIndicator.showWhile(getDisplay(), runnable);
1114                }
1115            } else {
1116                if (input != null) {
1117                    fMethodViewerPaneLabel.setText(fPaneLabelProvider.getText(input));
1118                    fMethodViewerPaneLabel.setImage(fPaneLabelProvider.getImage(input));
1119                } else {
1120                    fMethodViewerPaneLabel.setText(""); //$NON-NLS-1$
1121
fMethodViewerPaneLabel.setImage(null);
1122                }
1123                Runnable JavaDoc runnable= new Runnable JavaDoc() {
1124                    public void run() {
1125                        fMethodsViewer.setInput(input); // refresh
1126
}
1127                };
1128                BusyIndicator.showWhile(getDisplay(), runnable);
1129            }
1130        }
1131    }
1132    
1133    protected void doSelectionChanged(SelectionChangedEvent e) {
1134        if (e.getSelectionProvider() == fMethodsViewer) {
1135            methodSelectionChanged(e.getSelection());
1136        } else {
1137            typeSelectionChanged(e.getSelection());
1138        }
1139    }
1140    
1141    
1142    
1143    private void methodSelectionChanged(ISelection sel) {
1144        if (sel instanceof IStructuredSelection) {
1145            List JavaDoc selected= ((IStructuredSelection)sel).toList();
1146            int nSelected= selected.size();
1147            if (fIsEnableMemberFilter) {
1148                IMember[] memberFilter= null;
1149                if (nSelected > 0) {
1150                    memberFilter= new IMember[nSelected];
1151                    selected.toArray(memberFilter);
1152                }
1153                setMemberFilter(memberFilter);
1154                updateHierarchyViewer(true);
1155                updateTitle();
1156                internalSelectType(fSelectedType, true);
1157            }
1158            if (nSelected == 1 && fSelectInEditor) {
1159                revealElementInEditor(selected.get(0), fMethodsViewer);
1160            }
1161        }
1162    }
1163    
1164    private void typeSelectionChanged(ISelection sel) {
1165        if (sel instanceof IStructuredSelection) {
1166            List JavaDoc selected= ((IStructuredSelection)sel).toList();
1167            int nSelected= selected.size();
1168            if (nSelected != 0) {
1169                List JavaDoc types= new ArrayList JavaDoc(nSelected);
1170                for (int i= nSelected-1; i >= 0; i--) {
1171                    Object JavaDoc elem= selected.get(i);
1172                    if (elem instanceof IType && !types.contains(elem)) {
1173                        types.add(elem);
1174                    }
1175                }
1176                if (types.size() == 1) {
1177                    fSelectedType= (IType) types.get(0);
1178                    updateMethodViewer(fSelectedType);
1179                } else if (types.size() == 0) {
1180                    // method selected, no change
1181
}
1182                if (nSelected == 1 && fSelectInEditor) {
1183                    revealElementInEditor(selected.get(0), getCurrentViewer());
1184                }
1185            } else {
1186                fSelectedType= null;
1187                updateMethodViewer(null);
1188            }
1189        }
1190    }
1191    
1192    private void revealElementInEditor(Object JavaDoc elem, StructuredViewer originViewer) {
1193        // only allow revealing when the type hierarchy is the active page
1194
// no revealing after selection events due to model changes
1195

1196        if (getSite().getPage().getActivePart() != this) {
1197            return;
1198        }
1199        
1200        if (fSelectionProviderMediator.getViewerInFocus() != originViewer) {
1201            return;
1202        }
1203        
1204        IEditorPart editorPart= EditorUtility.isOpenInEditor(elem);
1205        if (editorPart != null && (elem instanceof IJavaElement)) {
1206            getSite().getPage().removePartListener(fPartListener);
1207            getSite().getPage().bringToTop(editorPart);
1208            EditorUtility.revealInEditor(editorPart, (IJavaElement) elem);
1209            getSite().getPage().addPartListener(fPartListener);
1210        }
1211    }
1212    
1213    private Display getDisplay() {
1214        if (fPagebook != null && !fPagebook.isDisposed()) {
1215            return fPagebook.getDisplay();
1216        }
1217        return null;
1218    }
1219    
1220    private boolean isChildVisible(Composite pb, Control child) {
1221        Control[] children= pb.getChildren();
1222        for (int i= 0; i < children.length; i++) {
1223            if (children[i] == child && children[i].isVisible())
1224                return true;
1225        }
1226        return false;
1227    }
1228    
1229    private void updateTitle() {
1230        String JavaDoc viewerTitle= getCurrentViewer().getTitle();
1231        
1232        String JavaDoc tooltip;
1233        String JavaDoc title;
1234        if (fInputElement != null) {
1235            IWorkingSet workingSet= fWorkingSetActionGroup.getWorkingSet();
1236            if (workingSet == null) {
1237                String JavaDoc[] args= new String JavaDoc[] { viewerTitle, JavaElementLabels.getElementLabel(fInputElement, JavaElementLabels.ALL_DEFAULT) };
1238                title= Messages.format(TypeHierarchyMessages.TypeHierarchyViewPart_title, args);
1239                tooltip= Messages.format(TypeHierarchyMessages.TypeHierarchyViewPart_tooltip, args);
1240            } else {
1241                String JavaDoc[] args= new String JavaDoc[] { viewerTitle, JavaElementLabels.getElementLabel(fInputElement, JavaElementLabels.ALL_DEFAULT), workingSet.getLabel() };
1242                title= Messages.format(TypeHierarchyMessages.TypeHierarchyViewPart_ws_title, args);
1243                tooltip= Messages.format(TypeHierarchyMessages.TypeHierarchyViewPart_ws_tooltip, args);
1244            }
1245        } else {
1246            title= ""; //$NON-NLS-1$
1247
tooltip= viewerTitle;
1248        }
1249        setContentDescription(title);
1250        setTitleToolTip(tooltip);
1251    }
1252    
1253    private void updateToolbarButtons() {
1254        boolean isType= fInputElement instanceof IType;
1255        for (int i= 0; i < fViewActions.length; i++) {
1256            ToggleViewAction action= fViewActions[i];
1257            if (action.getViewerIndex() == HIERARCHY_MODE_CLASSIC) {
1258                action.setEnabled(fInputElement != null);
1259            } else {
1260                action.setEnabled(isType);
1261            }
1262        }
1263    }
1264        
1265
1266    public void setHierarchyMode(int viewerIndex) {
1267        Assert.isNotNull(fAllViewers);
1268        if (viewerIndex < fAllViewers.length && fCurrentViewerIndex != viewerIndex) {
1269            fCurrentViewerIndex= viewerIndex;
1270            
1271            updateHierarchyViewer(true);
1272            if (fInputElement != null) {
1273                ISelection currSelection= getCurrentViewer().getSelection();
1274                if (currSelection == null || currSelection.isEmpty()) {
1275                    internalSelectType(getSelectableType(fInputElement), false);
1276                    currSelection= getCurrentViewer().getSelection();
1277                }
1278                if (!fIsEnableMemberFilter) {
1279                    typeSelectionChanged(currSelection);
1280                }
1281            }
1282            updateTitle();
1283                    
1284            fDialogSettings.put(DIALOGSTORE_HIERARCHYVIEW, viewerIndex);
1285            getCurrentViewer().getTree().setFocus();
1286        }
1287        for (int i= 0; i < fViewActions.length; i++) {
1288            ToggleViewAction action= fViewActions[i];
1289            action.setChecked(fCurrentViewerIndex == action.getViewerIndex());
1290        }
1291    }
1292
1293    public int getHierarchyMode() {
1294        return fCurrentViewerIndex;
1295    }
1296    
1297    private TypeHierarchyViewer getCurrentViewer() {
1298        return fAllViewers[fCurrentViewerIndex];
1299    }
1300
1301    /* (non-Javadoc)
1302     * @see org.eclipse.jdt.ui.ITypeHierarchyViewPart#showMembersInHierarchy(boolean)
1303     */

1304    public void showMembersInHierarchy(boolean on) {
1305        if (on != fIsEnableMemberFilter) {
1306            fIsEnableMemberFilter= on;
1307            if (!on) {
1308                IType methodViewerInput= (IType) fMethodsViewer.getInput();
1309                setMemberFilter(null);
1310                updateHierarchyViewer(true);
1311                updateTitle();
1312            
1313                if (methodViewerInput != null && getCurrentViewer().isElementShown(methodViewerInput)) {
1314                    // avoid that the method view changes content by selecting the previous input
1315
internalSelectType(methodViewerInput, true);
1316                } else if (fSelectedType != null) {
1317                    // choose a input that exists
1318
internalSelectType(fSelectedType, true);
1319                    updateMethodViewer(fSelectedType);
1320                }
1321            } else {
1322                methodSelectionChanged(fMethodsViewer.getSelection());
1323            }
1324        }
1325        fEnableMemberFilterAction.setChecked(on);
1326    }
1327    
1328    /* (non-Javadoc)
1329     * @see org.eclipse.jdt.ui.ITypeHierarchyViewPart#isShowMembersInHierarchy()
1330     */

1331    public boolean isShowMembersInHierarchy() {
1332        return fIsEnableMemberFilter;
1333    }
1334    
1335    
1336    /* (non-Javadoc)
1337     * @see org.eclipse.jdt.ui.ITypeHierarchyViewPart#showQualifiedTypeNames(boolean)
1338     */

1339    public void showQualifiedTypeNames(boolean on) {
1340        if (on != fShowQualifiedTypeNames) {
1341            fShowQualifiedTypeNames= on;
1342            if (fAllViewers != null) {
1343                for (int i= 0; i < fAllViewers.length; i++) {
1344                    fAllViewers[i].setQualifiedTypeName(on);
1345                }
1346            }
1347        }
1348        fShowQualifiedTypeNamesAction.setChecked(on);
1349        fDialogSettings.put(DIALOGSTORE_QUALIFIED_NAMES, on);
1350    }
1351    
1352    /* (non-Javadoc)
1353     * @see org.eclipse.jdt.ui.ITypeHierarchyViewPart#isQualifiedTypeNamesEnabled()
1354     */

1355    public boolean isQualifiedTypeNamesEnabled() {
1356        return fShowQualifiedTypeNames;
1357    }
1358    
1359    /**
1360     * Called from ITypeHierarchyLifeCycleListener.
1361     * Can be called from any thread
1362     * @param typeHierarchy Hierarchy that has changed
1363     * @param changedTypes Types in the hierarchy that have change or <code>null</code> if the full hierarchy has changed
1364     */

1365    protected void doTypeHierarchyChanged(final TypeHierarchyLifeCycle typeHierarchy, final IType[] changedTypes) {
1366        if (!fIsVisible) {
1367            fNeedRefresh= true;
1368            return;
1369        }
1370        if (fIsRefreshRunnablePosted) {
1371            return;
1372        }
1373        
1374        Display display= getDisplay();
1375        if (display != null) {
1376            fIsRefreshRunnablePosted= true;
1377            display.asyncExec(new Runnable JavaDoc() {
1378                public void run() {
1379                    try {
1380                        if (fPagebook != null && !fPagebook.isDisposed()) {
1381                            doTypeHierarchyChangedOnViewers(changedTypes);
1382                        }
1383                    } finally {
1384                        fIsRefreshRunnablePosted= false;
1385                    }
1386                }
1387            });
1388        }
1389    }
1390    
1391    protected void doTypeHierarchyChangedOnViewers(IType[] changedTypes) {
1392        if (fHierarchyLifeCycle.getHierarchy() == null || !fHierarchyLifeCycle.getHierarchy().exists()) {
1393            clearInput();
1394        } else {
1395            if (changedTypes == null) {
1396                // hierarchy change
1397
try {
1398                    fHierarchyLifeCycle.ensureRefreshedTypeHierarchy(fInputElement, getSite().getWorkbenchWindow());
1399                } catch (InvocationTargetException JavaDoc e) {
1400                    ExceptionHandler.handle(e, getSite().getShell(), TypeHierarchyMessages.TypeHierarchyViewPart_exception_title, TypeHierarchyMessages.TypeHierarchyViewPart_exception_message);
1401                    clearInput();
1402                    return;
1403                } catch (InterruptedException JavaDoc e) {
1404                    return;
1405                }
1406                fMethodsViewer.refresh();
1407                updateHierarchyViewer(false);
1408            } else {
1409                // elements in hierarchy modified
1410
Object JavaDoc methodViewerInput= fMethodsViewer.getInput();
1411                fMethodsViewer.refresh();
1412                fMethodViewerPaneLabel.setText(fPaneLabelProvider.getText(methodViewerInput));
1413                fMethodViewerPaneLabel.setImage(fPaneLabelProvider.getImage(methodViewerInput));
1414                if (getCurrentViewer().isMethodFiltering()) {
1415                    if (changedTypes.length == 1) {
1416                        getCurrentViewer().refresh(changedTypes[0]);
1417                    } else {
1418                        updateHierarchyViewer(false);
1419                    }
1420                } else {
1421                    getCurrentViewer().update(changedTypes, new String JavaDoc[] { IBasicPropertyConstants.P_TEXT, IBasicPropertyConstants.P_IMAGE } );
1422                }
1423            }
1424        }
1425    }
1426    
1427    /*
1428     * @see IViewPart#init
1429     */

1430    public void init(IViewSite site, IMemento memento) throws PartInitException {
1431        super.init(site, memento);
1432        fMemento= memento;
1433    }
1434    
1435    /*
1436     * @see ViewPart#saveState(IMemento)
1437     */

1438    public void saveState(IMemento memento) {
1439        if (fPagebook == null) {
1440            // part has not been created
1441
if (fMemento != null) { //Keep the old state;
1442
memento.putMemento(fMemento);
1443            }
1444            return;
1445        }
1446        if (fInputElement != null) {
1447            String JavaDoc handleIndentifier= fInputElement.getHandleIdentifier();
1448            memento.putString(TAG_INPUT, handleIndentifier);
1449        }
1450        memento.putInteger(TAG_VIEW, getHierarchyMode());
1451        memento.putInteger(TAG_LAYOUT, getViewLayout());
1452        memento.putInteger(TAG_QUALIFIED_NAMES, isQualifiedTypeNamesEnabled() ? 1 : 0);
1453        memento.putInteger(TAG_EDITOR_LINKING, isLinkingEnabled() ? 1 : 0);
1454        
1455        int weigths[]= fTypeMethodsSplitter.getWeights();
1456        int ratio= (weigths[0] * 1000) / (weigths[0] + weigths[1]);
1457        memento.putInteger(TAG_RATIO, ratio);
1458        
1459        ScrollBar bar= getCurrentViewer().getTree().getVerticalBar();
1460        int position= bar != null ? bar.getSelection() : 0;
1461        memento.putInteger(TAG_VERTICAL_SCROLL, position);
1462
1463        IJavaElement selection= (IJavaElement)((IStructuredSelection) getCurrentViewer().getSelection()).getFirstElement();
1464        if (selection != null) {
1465            memento.putString(TAG_SELECTION, selection.getHandleIdentifier());
1466        }
1467        
1468        fWorkingSetActionGroup.saveState(memento);
1469            
1470        fMethodsViewer.saveState(memento);
1471    }
1472    
1473    /*
1474     * Restores the type hierarchy settings from a memento.
1475     */

1476    private void restoreState(final IMemento memento, IJavaElement defaultInput) {
1477        IJavaElement input= defaultInput;
1478        String JavaDoc elementId= memento.getString(TAG_INPUT);
1479        if (elementId != null) {
1480            input= JavaCore.create(elementId);
1481            if (input != null && !input.exists()) {
1482                input= null;
1483            }
1484        }
1485        if (input == null) {
1486            doRestoreState(memento, input);
1487        } else {
1488            final IJavaElement hierarchyInput= input;
1489            
1490            synchronized (this) {
1491                String JavaDoc label= Messages.format(TypeHierarchyMessages.TypeHierarchyViewPart_restoreinput, hierarchyInput.getElementName());
1492                fNoHierarchyShownLabel.setText(label);
1493
1494                fRestoreStateJob= new Job(label) {
1495                    protected IStatus run(IProgressMonitor monitor) {
1496                        try {
1497                            doRestoreInBackground(memento, hierarchyInput, monitor);
1498                        } catch (JavaModelException e) {
1499                            return e.getStatus();
1500                        } catch (OperationCanceledException e) {
1501                            return Status.CANCEL_STATUS;
1502                        }
1503                        return Status.OK_STATUS;
1504                    }
1505                };
1506                fRestoreStateJob.schedule();
1507            }
1508        }
1509    }
1510    
1511    private void doRestoreInBackground(final IMemento memento, final IJavaElement hierarchyInput, IProgressMonitor monitor) throws JavaModelException {
1512        fHierarchyLifeCycle.doHierarchyRefresh(hierarchyInput, monitor);
1513        final boolean doRestore= !monitor.isCanceled();
1514        Display.getDefault().asyncExec(new Runnable JavaDoc() {
1515            public void run() {
1516                // running async: check first if view still exists
1517
if (fPagebook != null && !fPagebook.isDisposed()) {
1518                    if (doRestore)
1519                        doRestoreState(memento, hierarchyInput);
1520                    else
1521                        fNoHierarchyShownLabel.setText(TypeHierarchyMessages.TypeHierarchyViewPart_empty);
1522                }
1523            }
1524        });
1525    }
1526    
1527        
1528    final void doRestoreState(IMemento memento, IJavaElement input) {
1529        synchronized (this) {
1530            if (fRestoreStateJob == null) {
1531                return;
1532            }
1533            fRestoreStateJob= null;
1534        }
1535        
1536        fWorkingSetActionGroup.restoreState(memento);
1537        setInputElement(input);
1538
1539        Integer JavaDoc viewerIndex= memento.getInteger(TAG_VIEW);
1540        if (viewerIndex != null) {
1541            setHierarchyMode(viewerIndex.intValue());
1542        }
1543        Integer JavaDoc layout= memento.getInteger(TAG_LAYOUT);
1544        if (layout != null) {
1545            setViewLayout(layout.intValue());
1546        }
1547        
1548        Integer JavaDoc val= memento.getInteger(TAG_EDITOR_LINKING);
1549        if (val != null) {
1550            setLinkingEnabled(val.intValue() != 0);
1551        }
1552        
1553        Integer JavaDoc showQualified= memento.getInteger(TAG_QUALIFIED_NAMES);
1554        if (showQualified != null) {
1555            showQualifiedTypeNames(showQualified.intValue() != 0);
1556        }
1557        
1558        updateCheckedState();
1559
1560        Integer JavaDoc ratio= memento.getInteger(TAG_RATIO);
1561        if (ratio != null) {
1562            fTypeMethodsSplitter.setWeights(new int[] { ratio.intValue(), 1000 - ratio.intValue() });
1563        }
1564        ScrollBar bar= getCurrentViewer().getTree().getVerticalBar();
1565        if (bar != null) {
1566            Integer JavaDoc vScroll= memento.getInteger(TAG_VERTICAL_SCROLL);
1567            if (vScroll != null) {
1568                bar.setSelection(vScroll.intValue());
1569            }
1570        }
1571        fMethodsViewer.restoreState(memento);
1572    }
1573    
1574    /**
1575     * view part becomes visible
1576     * @param isVisible
1577     */

1578    protected void visibilityChanged(boolean isVisible) {
1579        fIsVisible= isVisible;
1580        if (isVisible && fNeedRefresh) {
1581            doTypeHierarchyChangedOnViewers(null);
1582        }
1583        fNeedRefresh= false;
1584    }
1585    
1586    
1587    /**
1588     * Link selection to active editor.
1589     * @param editor The activated editor
1590     */

1591    protected void editorActivated(IEditorPart editor) {
1592        if (!isLinkingEnabled()) {
1593            return;
1594        }
1595        if (fInputElement == null) {
1596            // no type hierarchy shown
1597
return;
1598        }
1599        
1600        IJavaElement elem= (IJavaElement)editor.getEditorInput().getAdapter(IJavaElement.class);
1601        if (elem instanceof ITypeRoot) {
1602            IType type= ((ITypeRoot) elem).findPrimaryType();
1603            if (type != null) {
1604                internalSelectType(type, true);
1605                if (getCurrentViewer().getSelection().isEmpty()) {
1606                    updateMethodViewer(null);
1607                } else {
1608                    updateMethodViewer(type);
1609                }
1610            }
1611        }
1612    }
1613
1614    /* (non-Javadoc)
1615     * @see org.eclipse.jdt.internal.ui.viewsupport.IViewPartInputProvider#getViewPartInput()
1616     */

1617    public Object JavaDoc getViewPartInput() {
1618        return fInputElement;
1619    }
1620    
1621    
1622    /**
1623     * @return Returns the <code>IShowInSource</code> for this view.
1624     */

1625    protected IShowInSource getShowInSource() {
1626        return new IShowInSource() {
1627            public ShowInContext getShowInContext() {
1628                return new ShowInContext(
1629                    null,
1630                getSite().getSelectionProvider().getSelection());
1631            }
1632        };
1633    }
1634    
1635    /* (non-Javadoc)
1636     * @see org.eclipse.jdt.ui.ITypeHierarchyViewPart#isLinkingEnabled()
1637     */

1638    public boolean isLinkingEnabled() {
1639        return fLinkingEnabled;
1640    }
1641    
1642    /* (non-Javadoc)
1643     * @see org.eclipse.jdt.ui.ITypeHierarchyViewPart#setLinkingEnabled(boolean)
1644     */

1645    public void setLinkingEnabled(boolean enabled) {
1646        fLinkingEnabled= enabled;
1647        fToggleLinkingAction.setChecked(enabled);
1648        fDialogSettings.put(DIALOGSTORE_LINKEDITORS, enabled);
1649
1650        if (enabled) {
1651            IWorkbenchPartSite site= getSite();
1652            if (site != null) {
1653                IEditorPart editor = site.getPage().getActiveEditor();
1654                if (editor != null) {
1655                    editorActivated(editor);
1656                }
1657            }
1658        }
1659    }
1660    
1661    public void clearNeededRefresh() {
1662        fNeedRefresh= false;
1663    }
1664
1665}
1666
Popular Tags