1 11 package org.eclipse.jdt.internal.ui.typehierarchy; 12 13 import java.lang.reflect.InvocationTargetException ; 14 import java.util.ArrayList ; 15 import java.util.List ; 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 142 public class TypeHierarchyViewPart extends ViewPart implements ITypeHierarchyViewPart, IViewPartInputProvider { 143 144 private static final String DIALOGSTORE_HIERARCHYVIEW= "TypeHierarchyViewPart.hierarchyview"; private static final String DIALOGSTORE_VIEWLAYOUT= "TypeHierarchyViewPart.orientation"; private static final String DIALOGSTORE_QUALIFIED_NAMES= "TypeHierarchyViewPart.qualifiednames"; private static final String DIALOGSTORE_LINKEDITORS= "TypeHierarchyViewPart.linkeditors"; 149 private static final String TAG_INPUT= "input"; private static final String TAG_VIEW= "view"; private static final String TAG_LAYOUT= "orientation"; private static final String TAG_RATIO= "ratio"; private static final String TAG_SELECTION= "selection"; private static final String TAG_VERTICAL_SCROLL= "vertical_scroll"; private static final String TAG_QUALIFIED_NAMES= "qualified_names"; private static final String TAG_EDITOR_LINKING= "link_editors"; 158 private static final String GROUP_FOCUS= "group.focus"; 160 161 162 private IType fSelectedType; 164 private IJavaElement fInputElement; 166 167 private ArrayList 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 (); 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 328 protected void doPropertyChange(PropertyChangeEvent event) { 329 String 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 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 367 public void gotoHistoryEntry(IJavaElement entry) { 368 if (fInputHistory.contains(entry)) { 369 updateInput(entry); 370 } 371 } 372 373 377 public IJavaElement[] getHistoryEntries() { 378 if (fInputHistory.size() > 0) { 379 updateHistoryEntries(); 380 } 381 return (IJavaElement[]) fInputHistory.toArray(new IJavaElement[fInputHistory.size()]); 382 } 383 384 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 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 426 public IType getInput() { 427 if (fInputElement instanceof IType) { 428 return (IType) fInputElement; 429 } 430 return null; 431 } 432 433 438 public void setInput(IType type) { 439 setInputElement(type); 440 } 441 442 447 public IJavaElement getInputElement() { 448 return fInputElement; 449 } 450 451 452 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."); } 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 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 e) { 500 } finally { 502 fRestoreStateJob= null; 503 } 504 } 505 } 506 507 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 } catch (InvocationTargetException e) { 521 ExceptionHandler.handle(e, getSite().getShell(), TypeHierarchyMessages.TypeHierarchyViewPart_exception_title, TypeHierarchyMessages.TypeHierarchyViewPart_exception_message); 522 clearInput(); 523 return; 524 } catch (InterruptedException e) { 525 fNoHierarchyShownLabel.setText(TypeHierarchyMessages.TypeHierarchyViewPart_empty); 526 return; 527 } 528 529 if (inputElement.getElementType() != IJavaElement.TYPE) { 530 setHierarchyMode(HIERARCHY_MODE_CLASSIC); 531 } 532 fSelectInEditor= false; 534 setMemberFilter(null); 535 internalSelectType(null, false); 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 568 public void setFocus() { 569 fPagebook.setFocus(); 570 } 571 572 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 604 public Object getAdapter(Class key) { 605 if (key == IShowInSource.class) { 606 return getShowInSource(); 607 } 608 if (key == IShowInTargetList.class) { 609 return new IShowInTargetList() { 610 public String [] getShowInTargetIds() { 611 return new String [] { 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 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 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 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 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 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 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 769 fNoHierarchyShownLabel= new Label(fPagebook, SWT.TOP + SWT.LEFT + SWT.WRAP); 770 fNoHierarchyShownLabel.setText(TypeHierarchyMessages.TypeHierarchyViewPart_empty); 771 772 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 e) { 809 layout= VIEW_LAYOUT_AUTOMATIC; 810 } 811 fCurrentLayout= -1; 813 setViewLayout(layout); 815 816 showQualifiedTypeNames(fDialogSettings.getBoolean(DIALOGSTORE_QUALIFIED_NAMES)); 817 setLinkingEnabled(fDialogSettings.getBoolean(DIALOGSTORE_LINKEDITORS)); 818 819 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 ToolBarManager lowertbmanager= new ToolBarManager(methodViewerToolBar); 845 lowertbmanager.add(fEnableMemberFilterAction); 846 lowertbmanager.add(new Separator()); 847 fMethodsViewer.contributeToToolBar(lowertbmanager); 848 lowertbmanager.update(true); 849 850 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 IJavaElement input= null; 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 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 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; } 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 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 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.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 1032 private void fillMethodsViewerContextMenu(IMenuManager menu) { 1033 JavaPlugin.createStandardGroups(menu); 1034 fMethodsViewer.contributeToContextMenu(menu); 1036 fActionGroups.setContext(new ActionContext(getSite().getSelectionProvider().getSelection())); 1037 fActionGroups.fillContextMenu(menu); 1038 fActionGroups.setContext(null); 1039 } 1040 1041 1044 private void setViewerVisibility(boolean showHierarchy) { 1045 if (showHierarchy) { 1046 fViewerbook.showPage(getCurrentViewer().getControl()); 1047 } else { 1048 fViewerbook.showPage(fEmptyTypesViewer); 1049 } 1050 } 1051 1052 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 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 runnable= new Runnable () { 1089 public void run() { 1090 getCurrentViewer().updateContent(doExpand); } 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 runnable= new Runnable () { 1109 public void run() { 1110 fMethodsViewer.refresh(); } 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(""); fMethodViewerPaneLabel.setImage(null); 1122 } 1123 Runnable runnable= new Runnable () { 1124 public void run() { 1125 fMethodsViewer.setInput(input); } 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 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 selected= ((IStructuredSelection)sel).toList(); 1167 int nSelected= selected.size(); 1168 if (nSelected != 0) { 1169 List types= new ArrayList (nSelected); 1170 for (int i= nSelected-1; i >= 0; i--) { 1171 Object 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 } 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 elem, StructuredViewer originViewer) { 1193 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 viewerTitle= getCurrentViewer().getTitle(); 1231 1232 String tooltip; 1233 String title; 1234 if (fInputElement != null) { 1235 IWorkingSet workingSet= fWorkingSetActionGroup.getWorkingSet(); 1236 if (workingSet == null) { 1237 String [] args= new String [] { 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 [] args= new String [] { 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= ""; 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 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 internalSelectType(methodViewerInput, true); 1316 } else if (fSelectedType != null) { 1317 internalSelectType(fSelectedType, true); 1319 updateMethodViewer(fSelectedType); 1320 } 1321 } else { 1322 methodSelectionChanged(fMethodsViewer.getSelection()); 1323 } 1324 } 1325 fEnableMemberFilterAction.setChecked(on); 1326 } 1327 1328 1331 public boolean isShowMembersInHierarchy() { 1332 return fIsEnableMemberFilter; 1333 } 1334 1335 1336 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 1355 public boolean isQualifiedTypeNamesEnabled() { 1356 return fShowQualifiedTypeNames; 1357 } 1358 1359 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 () { 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 try { 1398 fHierarchyLifeCycle.ensureRefreshedTypeHierarchy(fInputElement, getSite().getWorkbenchWindow()); 1399 } catch (InvocationTargetException e) { 1400 ExceptionHandler.handle(e, getSite().getShell(), TypeHierarchyMessages.TypeHierarchyViewPart_exception_title, TypeHierarchyMessages.TypeHierarchyViewPart_exception_message); 1401 clearInput(); 1402 return; 1403 } catch (InterruptedException e) { 1404 return; 1405 } 1406 fMethodsViewer.refresh(); 1407 updateHierarchyViewer(false); 1408 } else { 1409 Object 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 [] { IBasicPropertyConstants.P_TEXT, IBasicPropertyConstants.P_IMAGE } ); 1422 } 1423 } 1424 } 1425 } 1426 1427 1430 public void init(IViewSite site, IMemento memento) throws PartInitException { 1431 super.init(site, memento); 1432 fMemento= memento; 1433 } 1434 1435 1438 public void saveState(IMemento memento) { 1439 if (fPagebook == null) { 1440 if (fMemento != null) { memento.putMemento(fMemento); 1443 } 1444 return; 1445 } 1446 if (fInputElement != null) { 1447 String 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 1476 private void restoreState(final IMemento memento, IJavaElement defaultInput) { 1477 IJavaElement input= defaultInput; 1478 String 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 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 () { 1515 public void run() { 1516 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 viewerIndex= memento.getInteger(TAG_VIEW); 1540 if (viewerIndex != null) { 1541 setHierarchyMode(viewerIndex.intValue()); 1542 } 1543 Integer layout= memento.getInteger(TAG_LAYOUT); 1544 if (layout != null) { 1545 setViewLayout(layout.intValue()); 1546 } 1547 1548 Integer val= memento.getInteger(TAG_EDITOR_LINKING); 1549 if (val != null) { 1550 setLinkingEnabled(val.intValue() != 0); 1551 } 1552 1553 Integer showQualified= memento.getInteger(TAG_QUALIFIED_NAMES); 1554 if (showQualified != null) { 1555 showQualifiedTypeNames(showQualified.intValue() != 0); 1556 } 1557 1558 updateCheckedState(); 1559 1560 Integer 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 vScroll= memento.getInteger(TAG_VERTICAL_SCROLL); 1567 if (vScroll != null) { 1568 bar.setSelection(vScroll.intValue()); 1569 } 1570 } 1571 fMethodsViewer.restoreState(memento); 1572 } 1573 1574 1578 protected void visibilityChanged(boolean isVisible) { 1579 fIsVisible= isVisible; 1580 if (isVisible && fNeedRefresh) { 1581 doTypeHierarchyChangedOnViewers(null); 1582 } 1583 fNeedRefresh= false; 1584 } 1585 1586 1587 1591 protected void editorActivated(IEditorPart editor) { 1592 if (!isLinkingEnabled()) { 1593 return; 1594 } 1595 if (fInputElement == null) { 1596 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 1617 public Object getViewPartInput() { 1618 return fInputElement; 1619 } 1620 1621 1622 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 1638 public boolean isLinkingEnabled() { 1639 return fLinkingEnabled; 1640 } 1641 1642 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 |