package net.sourceforge.c4jplugin.internal.ui.contracthierarchy;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.List;
import net.sourceforge.c4jplugin.C4JActivator;
import net.sourceforge.c4jplugin.internal.core.ContractReferenceModel;
import net.sourceforge.c4jplugin.internal.ui.contracthierarchy.actions.EnableMemberFilterAction;
import net.sourceforge.c4jplugin.internal.ui.contracthierarchy.actions.FocusOnSelectionAction;
import net.sourceforge.c4jplugin.internal.ui.contracthierarchy.actions.FocusOnTypeAction;
import net.sourceforge.c4jplugin.internal.ui.contracthierarchy.actions.HistoryDropDownAction;
import net.sourceforge.c4jplugin.internal.ui.contracthierarchy.actions.ShowQualifiedTypeNamesAction;
import net.sourceforge.c4jplugin.internal.ui.contracthierarchy.actions.ToggleLinkingAction;
import net.sourceforge.c4jplugin.internal.ui.contracthierarchy.actions.ToggleOrientationAction;
import net.sourceforge.c4jplugin.internal.ui.contracthierarchy.actions.ToggleRepresentationAction;
import net.sourceforge.c4jplugin.internal.ui.contracthierarchy.actions.ToggleViewAction;
import net.sourceforge.c4jplugin.internal.ui.contracthierarchy.tree.SubContractHierarchyViewer;
import net.sourceforge.c4jplugin.internal.ui.contracthierarchy.tree.SuperContractHierarchyViewer;
import net.sourceforge.c4jplugin.internal.ui.contracthierarchy.tree.TraditionalHierarchyViewer;
import net.sourceforge.c4jplugin.internal.ui.contracthierarchy.zest.ZestContractHierarchyViewer;
import net.sourceforge.c4jplugin.internal.ui.contracthierarchy.zest.ZoomContributionItem;
import net.sourceforge.c4jplugin.internal.util.ContractReferenceUtil;
import net.sourceforge.c4jplugin.internal.util.ExceptionHandler;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.help.IContextProvider;
import org.eclipse.jdt.core.IClassFile;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IMember;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.internal.ui.IJavaHelpContextIds;
import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.actions.CompositeActionGroup;
import org.eclipse.jdt.internal.ui.actions.NewWizardsActionGroup;
import org.eclipse.jdt.internal.ui.actions.SelectAllAction;
import org.eclipse.jdt.internal.ui.dnd.DelegatingDropAdapter;
import org.eclipse.jdt.internal.ui.dnd.JdtViewerDragAdapter;
import org.eclipse.jdt.internal.ui.dnd.ResourceTransferDragAdapter;
import org.eclipse.jdt.internal.ui.javaeditor.EditorUtility;
import org.eclipse.jdt.internal.ui.packageview.SelectionTransferDragAdapter;
import org.eclipse.jdt.internal.ui.preferences.MembersOrderPreferenceCache;
import org.eclipse.jdt.internal.ui.util.JavaUIHelp;
import org.eclipse.jdt.internal.ui.viewsupport.JavaUILabelProvider;
import org.eclipse.jdt.internal.ui.viewsupport.SelectionProviderMediator;
import org.eclipse.jdt.internal.ui.viewsupport.StatusBarUpdater;
import org.eclipse.jdt.internal.ui.workingsets.WorkingSetFilterActionGroup;
import org.eclipse.jdt.ui.IContextMenuConstants;
import org.eclipse.jdt.ui.JavaElementLabels;
import org.eclipse.jdt.ui.JavaUI;
import org.eclipse.jdt.ui.PreferenceConstants;
import org.eclipse.jdt.ui.actions.CCPActionGroup;
import org.eclipse.jdt.ui.actions.GenerateActionGroup;
import org.eclipse.jdt.ui.actions.JavaSearchActionGroup;
import org.eclipse.jdt.ui.actions.OpenEditorActionGroup;
import org.eclipse.jdt.ui.actions.OpenViewActionGroup;
import org.eclipse.jdt.ui.actions.RefactorActionGroup;
import org.eclipse.jface.action.IMenuListener;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.IStatusLineManager;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.action.ToolBarManager;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.jface.util.TransferDragSourceListener;
import org.eclipse.jface.util.TransferDropTargetListener;
import org.eclipse.jface.viewers.AbstractTreeViewer;
import org.eclipse.jface.viewers.IBasicPropertyConstants;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.StructuredViewer;
import org.eclipse.mylar.zest.core.viewers.AbstractStructuredGraphViewer;
import org.eclipse.mylar.zest.core.viewers.AbstractZoomableViewer;
import org.eclipse.mylar.zest.core.viewers.IZoomableWorkbenchPart;
import org.eclipse.mylar.zest.core.viewers.ZoomContributionViewItem;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.BusyIndicator;
import org.eclipse.swt.custom.CLabel;
import org.eclipse.swt.custom.SashForm;
import org.eclipse.swt.custom.ViewForm;
import org.eclipse.swt.dnd.DND;
import org.eclipse.swt.dnd.DropTarget;
import org.eclipse.swt.dnd.DropTargetAdapter;
import org.eclipse.swt.dnd.Transfer;
import org.eclipse.swt.events.ControlEvent;
import org.eclipse.swt.events.ControlListener;
import org.eclipse.swt.events.FocusEvent;
import org.eclipse.swt.events.FocusListener;
import org.eclipse.swt.events.KeyAdapter;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.events.KeyListener;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.ScrollBar;
import org.eclipse.swt.widgets.Scrollable;
import org.eclipse.swt.widgets.ToolBar;
import org.eclipse.ui.IActionBars;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IMemento;
import org.eclipse.ui.IPageLayout;
import org.eclipse.ui.IPartListener2;
import org.eclipse.ui.IViewSite;
import org.eclipse.ui.IWorkbenchActionConstants;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.IWorkbenchPartReference;
import org.eclipse.ui.IWorkbenchPartSite;
import org.eclipse.ui.IWorkingSet;
import org.eclipse.ui.IWorkingSetManager;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.actions.ActionContext;
import org.eclipse.ui.actions.ActionFactory;
import org.eclipse.ui.actions.ActionGroup;
import org.eclipse.ui.part.IShowInSource;
import org.eclipse.ui.part.IShowInTargetList;
import org.eclipse.ui.part.PageBook;
import org.eclipse.ui.part.ResourceTransfer;
import org.eclipse.ui.part.ShowInContext;
import org.eclipse.ui.part.ViewPart;
import org.eclipse.ui.views.navigator.LocalSelectionTransfer;
import com.sun.org.apache.regexp.internal.RE;
public class ContractHierarchyViewPart extends ViewPart {
public static final int VIEW_LAYOUT_VERTICAL= 0;
public static final int VIEW_LAYOUT_HORIZONTAL= 1;
public static final int VIEW_LAYOUT_SINGLE= 2;
public static final int VIEW_LAYOUT_AUTOMATIC= 3;
public static final int REPRESENTATION_MODE_TREE = 0;
public static final int REPRESENTATION_MODE_GRAPH = 1;
public static final int HIERARCHY_MODE_CLASSIC= 2;
public static final int HIERARCHY_MODE_SUPERTYPES= 0;
public static final int HIERARCHY_MODE_SUBTYPES= 1;
// the index of this mode must always come last
public static final int HIERARCHY_SPECIALMODE_GRAPH = 3;
private static final String DIALOGSTORE_HIERARCHYVIEW= "ContractHierarchyViewPart.hierarchyview"; //$NON-NLS-1$
private static final String DIALOGSTORE_VIEWLAYOUT= "ContractHierarchyViewPart.orientation"; //$NON-NLS-1$
private static final String DIALOGSTORE_REPRESENTATION= "ContractHierarchyViewPart.representation"; //$NON-NLS-1$
private static final String DIALOGSTORE_QUALIFIED_NAMES= "ContractHierarchyViewPart.qualifiednames"; //$NON-NLS-1$
private static final String DIALOGSTORE_LINKEDITORS= "ContractHierarchyViewPart.linkeditors"; //$NON-NLS-1$
private static final String TAG_INPUT= "input"; //$NON-NLS-1$
private static final String TAG_VIEW= "view"; //$NON-NLS-1$
private static final String TAG_LAYOUT= "orientation"; //$NON-NLS-1$
private static final String TAG_REPRESENTATION = "representation"; //$NON_NLS-1$
private static final String TAG_ZOOMLEVEL = "zoomlevel"; //$NON_NLS-1$
private static final String TAG_RATIO= "ratio"; //$NON-NLS-1$
private static final String TAG_SELECTION= "selection"; //$NON-NLS-1$
private static final String TAG_VERTICAL_SCROLL= "vertical_scroll"; //$NON-NLS-1$
private static final String TAG_QUALIFIED_NAMES= "qualified_names"; //$NON-NLS-1$
private static final String TAG_EDITOR_LINKING= "link_editors"; //$NON-NLS-1$
private static final String GROUP_FOCUS= "group.focus"; //$NON-NLS-1$
// the selected type in the hierarchy view
private IType fSelectedType;
// input element or null
private IJavaElement fInputElement;
// history of input elements. No duplicates
private ArrayList fInputHistory;
private IMemento fMemento;
private IDialogSettings fDialogSettings;
private ContractHierarchyLifeCycle fHierarchyLifeCycle;
private IContractHierarchyLifeCycleListener fTypeHierarchyLifeCycleListener;
private IPropertyChangeListener fPropertyChangeListener;
private SelectionProviderMediator fSelectionProviderMediator;
private ISelectionChangedListener fSelectionChangedListener;
private IPartListener2 fPartListener;
private int fCurrentLayout;
private boolean fInComputeLayout;
private int fCurrentRepresentation;
private boolean fLinkingEnabled;
private boolean fShowQualifiedTypeNames;
private boolean fSelectInEditor;
private boolean fIsVisible;
private boolean fNeedRefresh;
private boolean fIsEnableMemberFilter;
private boolean fIsRefreshRunnablePosted;
private int fCurrentViewerIndex;
private StructuredViewer[] fAllViewers;
private ZoomContributionItem fZoomControl;
private MethodsViewer fMethodsViewer;
private SashForm fTypeMethodsSplitter;
private PageBook fViewerbook;
private PageBook fPagebook;
private Label fNoHierarchyShownLabel;
private Label fEmptyTypesViewer;
private ViewForm fTypeViewerViewForm;
private ViewForm fMethodViewerViewForm;
private CLabel fMethodViewerPaneLabel;
private JavaUILabelProvider fPaneLabelProvider;
private Composite fParent;
private ToggleViewAction[] fViewActions;
private ToggleRepresentationAction[] fRepActions;
private ToggleLinkingAction fToggleLinkingAction;
private HistoryDropDownAction fHistoryDropDownAction;
private ToggleOrientationAction[] fToggleOrientationActions;
private EnableMemberFilterAction fEnableMemberFilterAction;
private ShowQualifiedTypeNamesAction fShowQualifiedTypeNamesAction;
private FocusOnTypeAction fFocusOnTypeAction;
private FocusOnSelectionAction fFocusOnSelectionAction;
private CompositeActionGroup fActionGroups;
private SelectAllAction fSelectAllAction;
private WorkingSetFilterActionGroup fWorkingSetActionGroup;
private Job fRestoreStateJob;
public ContractHierarchyViewPart() {
fSelectedType= null;
fInputElement= null;
fIsVisible= false;
fIsRefreshRunnablePosted= false;
fSelectInEditor= true;
fRestoreStateJob= null;
fHierarchyLifeCycle= new ContractHierarchyLifeCycle();
fTypeHierarchyLifeCycleListener= new IContractHierarchyLifeCycleListener() {
public void contractHierarchyChanged(ContractHierarchyLifeCycle typeHierarchy, IType[] changedTypes) {
doTypeHierarchyChanged(typeHierarchy, changedTypes);
}
};
fHierarchyLifeCycle.addChangedListener(fTypeHierarchyLifeCycleListener);
fPropertyChangeListener= new IPropertyChangeListener() {
public void propertyChange(PropertyChangeEvent event) {
doPropertyChange(event);
}
};
PreferenceConstants.getPreferenceStore().addPropertyChangeListener(fPropertyChangeListener);
fIsEnableMemberFilter= false;
fInputHistory= new ArrayList();
fAllViewers= null;
//fGraphViewer = null;
fViewActions= new ToggleViewAction[] {
new ToggleViewAction(this, HIERARCHY_MODE_CLASSIC),
new ToggleViewAction(this, HIERARCHY_MODE_SUPERTYPES),
new ToggleViewAction(this, HIERARCHY_MODE_SUBTYPES),
};
fRepActions = new ToggleRepresentationAction[] {
new ToggleRepresentationAction(this, REPRESENTATION_MODE_GRAPH),
new ToggleRepresentationAction(this, REPRESENTATION_MODE_TREE)
};
fDialogSettings= C4JActivator.getDefault().getDialogSettings();
fHistoryDropDownAction= new HistoryDropDownAction(this);
fHistoryDropDownAction.setEnabled(false);
fToggleOrientationActions= new ToggleOrientationAction[] {
new ToggleOrientationAction(this, VIEW_LAYOUT_VERTICAL),
new ToggleOrientationAction(this, VIEW_LAYOUT_HORIZONTAL),
new ToggleOrientationAction(this, VIEW_LAYOUT_AUTOMATIC),
new ToggleOrientationAction(this, VIEW_LAYOUT_SINGLE)
};
fEnableMemberFilterAction= new EnableMemberFilterAction(this, false);
fShowQualifiedTypeNamesAction= new ShowQualifiedTypeNamesAction(this, false);
fFocusOnTypeAction= new FocusOnTypeAction(this);
fToggleLinkingAction= new ToggleLinkingAction(this);
fPaneLabelProvider= new JavaUILabelProvider();
fFocusOnSelectionAction= new FocusOnSelectionAction(this);
fPartListener= new IPartListener2() {
public void partVisible(IWorkbenchPartReference ref) {
IWorkbenchPart part= ref.getPart(false);
if (part == ContractHierarchyViewPart.this) {
visibilityChanged(true);
}
}
public void partHidden(IWorkbenchPartReference ref) {
IWorkbenchPart part= ref.getPart(false);
if (part == ContractHierarchyViewPart.this) {
visibilityChanged(false);
}
}
public void partActivated(IWorkbenchPartReference ref) {
IWorkbenchPart part= ref.getPart(false);
if (part instanceof IEditorPart)
editorActivated((IEditorPart) part);
}
public void partInputChanged(IWorkbenchPartReference ref) {
IWorkbenchPart part= ref.getPart(false);
if (part instanceof IEditorPart)
editorActivated((IEditorPart) part);
}
public void partBroughtToTop(IWorkbenchPartReference ref) {}
public void partClosed(IWorkbenchPartReference ref) {}
public void partDeactivated(IWorkbenchPartReference ref) {}
public void partOpened(IWorkbenchPartReference ref) {}
};
fSelectionChangedListener= new ISelectionChangedListener() {
public void selectionChanged(SelectionChangedEvent event) {
doSelectionChanged(event);
}
};
}
/**
* Method doPropertyChange.
* @param event
*/
protected void doPropertyChange(PropertyChangeEvent event) {
String property= event.getProperty();
if (fMethodsViewer != null) {
if (MembersOrderPreferenceCache.isMemberOrderProperty(event.getProperty())) {
fMethodsViewer.refresh();
}
}
if (IWorkingSetManager.CHANGE_WORKING_SET_CONTENT_CHANGE.equals(property)) {
updateHierarchyViewer(true, true);
updateTitle();
}
}
/**
* Adds the entry if new. Inserted at the beginning of the history entries list.
* @param entry The new entry
*/
private void addHistoryEntry(IJavaElement entry) {
if (fInputHistory.contains(entry)) {
fInputHistory.remove(entry);
}
fInputHistory.add(0, entry);
fHistoryDropDownAction.setEnabled(true);
}
private void updateHistoryEntries() {
for (int i= fInputHistory.size() - 1; i >= 0; i--) {
IJavaElement type= (IJavaElement) fInputHistory.get(i);
if (!type.exists()) {
fInputHistory.remove(i);
}
}
fHistoryDropDownAction.setEnabled(!fInputHistory.isEmpty());
}
/**
* Goes to the selected entry, without updating the order of history entries.
* @param entry The entry to open
*/
public void gotoHistoryEntry(IJavaElement entry) {
if (fInputHistory.contains(entry)) {
updateInput(entry);
}
}
/**
* Gets all history entries.
* @return All history entries
*/
public IJavaElement[] getHistoryEntries() {
if (fInputHistory.size() > 0) {
updateHistoryEntries();
}
return (IJavaElement[]) fInputHistory.toArray(new IJavaElement[fInputHistory.size()]);
}
/**
* Sets the history entries
* @param elems The history elements to set
*/
public void setHistoryEntries(IJavaElement[] elems) {
fInputHistory.clear();
for (int i= 0; i < elems.length; i++) {
fInputHistory.add(elems[i]);
}
updateHistoryEntries();
}
/**
* Selects an member in the methods list or in the current hierarchy.
* @param member The member to select
*/
public void selectMember(IMember member) {
fSelectInEditor= false;
if (member.getElementType() != IJavaElement.TYPE) {
Control methodControl= fMethodsViewer.getControl();
if (methodControl != null && !methodControl.isDisposed()) {
methodControl.setFocus();
}
fMethodsViewer.setSelection(new StructuredSelection(member), true);
} else {
Control viewerControl= getCurrentViewer().getControl();
if (viewerControl != null && !viewerControl.isDisposed()) {
viewerControl.setFocus();
}
if (!member.equals(fSelectedType)) {
getCurrentViewer().setSelection(new StructuredSelection(member), true);
}
}
fSelectInEditor= true;
}
/**
* Returns the input element of the type hierarchy.
* Can be of type <code>IType</code> or <code>IPackageFragment</code>
* @return the input element
*/
public IJavaElement getInputElement() {
return fInputElement;
}
/**
* Sets the input to a new element.
* @param element the input element
*/
public void setInputElement(IJavaElement element) {
// if the input element is a contract, change the input to the
// contracts target
if (element != null) {
try {
IResource res = element.getUnderlyingResource();
IResource target = ContractReferenceModel.getTarget(res);
if (target != null) {
element = ContractReferenceUtil.getType(JavaCore.create(target));
}
} catch (JavaModelException e) {}
}
IMember memberToSelect= null;
if (element != null) {
if (element instanceof IMember) {
if (element.getElementType() != IJavaElement.TYPE) {
memberToSelect= (IMember) element;
element= memberToSelect.getDeclaringType();
}
if (!element.exists()) {
MessageDialog.openError(getSite().getShell(), ContractHierarchyMessages.TypeHierarchyViewPart_error_title, ContractHierarchyMessages.TypeHierarchyViewPart_error_message);
return;
}
} else {
int kind= element.getElementType();
if (kind != IJavaElement.JAVA_PROJECT && kind != IJavaElement.PACKAGE_FRAGMENT_ROOT && kind != IJavaElement.PACKAGE_FRAGMENT) {
element= null;
C4JActivator.logErrorMessage("Invalid contract hierarchy input type.");//$NON-NLS-1$
}
}
}
if (element != null && !element.equals(fInputElement)) {
addHistoryEntry(element);
}
updateInput(element);
if (memberToSelect != null) {
selectMember(memberToSelect);
}
}
/*
* Changes the input to a new type
* @param inputElement
*/
private void updateInput(IJavaElement inputElement) {
IJavaElement prevInput= fInputElement;
synchronized (this) {
if (fRestoreStateJob != null) {
fRestoreStateJob.cancel();
try {
fRestoreStateJob.join();
} catch (InterruptedException e) {
// ignore
} finally {
fRestoreStateJob= null;
}
}
}
// Make sure the UI got repainted before we execute a long running
// operation. This can be removed if we refresh the hierarchy in a
// separate thread.
// Work-araound for http://dev.eclipse.org/bugs/show_bug.cgi?id=30881
processOutstandingEvents();
if (inputElement == null) {
clearInput();
} else {
fInputElement= inputElement;
try {
fHierarchyLifeCycle.ensureRefreshedContractHierarchy(inputElement, C4JActivator.getDefault().getWorkbench().getActiveWorkbenchWindow());
// fHierarchyLifeCycle.ensureRefreshedTypeHierarchy(inputElement, getSite().getWorkbenchWindow());
} catch (InvocationTargetException e) {
ExceptionHandler.handle(e, getSite().getShell(), ContractHierarchyMessages.TypeHierarchyViewPart_exception_title, ContractHierarchyMessages.TypeHierarchyViewPart_exception_message);
clearInput();
return;
} catch (InterruptedException e) {
return;
}
if (inputElement.getElementType() != IJavaElement.TYPE) {
setHierarchyMode(HIERARCHY_MODE_CLASSIC);
}
// turn off member filtering
fSelectInEditor= false;
setMemberFilter(null);
internalSelectType(null, false); // clear selection
fIsEnableMemberFilter= false;
if (!inputElement.equals(prevInput)) {
updateHierarchyViewer(true, true);
}
IType root= getSelectableType(inputElement);
internalSelectType(root, true);
updateMethodViewer(root);
updateToolbarButtons();
updateTitle();
showMembersInHierarchy(false);
fPagebook.showPage(fTypeMethodsSplitter);
fSelectInEditor= true;
}
}
private void processOutstandingEvents() {
Display display= getDisplay();
if (display != null && !display.isDisposed())
display.update();
}
private void clearInput() {
fInputElement= null;
fHierarchyLifeCycle.freeHierarchy();
updateHierarchyViewer(false, false);
updateToolbarButtons();
}
/*
* @see IWorbenchPart#setFocus
*/
public void setFocus() {
fPagebook.setFocus();
}
/*
* @see IWorkbenchPart#dispose
*/
public void dispose() {
fHierarchyLifeCycle.freeHierarchy();
fHierarchyLifeCycle.removeChangedListener(fTypeHierarchyLifeCycleListener);
fPaneLabelProvider.dispose();
if (fMethodsViewer != null) {
fMethodsViewer.dispose();
}
if (fPropertyChangeListener != null) {
C4JActivator.getDefault().getPreferenceStore().removePropertyChangeListener(fPropertyChangeListener);
fPropertyChangeListener= null;
}
getSite().getPage().removePartListener(fPartListener);
if (fActionGroups != null)
fActionGroups.dispose();
if (fWorkingSetActionGroup != null) {
fWorkingSetActionGroup.dispose();
}
super.dispose();
}
/* (non-Javadoc)
* @see org.eclipse.core.runtime.IAdaptable#getAdapter(java.lang.Class)
*/
public Object getAdapter(Class key) {
if (key == IShowInSource.class) {
return getShowInSource();
}
if (key == IShowInTargetList.class) {
return new IShowInTargetList() {
public String[] getShowInTargetIds() {
return new String[] { JavaUI.ID_PACKAGES, IPageLayout.ID_RES_NAV };
}
};
}
if (key == IContextProvider.class) {
return JavaUIHelp.getHelpContextProvider(this, IJavaHelpContextIds.TYPE_HIERARCHY_VIEW);
}
return super.getAdapter(key);
}
private Control createTypeViewerControl(Composite parent) {
fViewerbook= new PageBook(parent, SWT.NULL);
KeyListener keyListener= createKeyListener();
// Create the viewers
StructuredViewer superTypesViewer= new SuperContractHierarchyViewer(fViewerbook, fHierarchyLifeCycle, this);
initializeTypesViewer(superTypesViewer, keyListener, "net.sourceforge.c4jplugin.ui.contracthierarchy.tree.supercontracts");
StructuredViewer subTypesViewer= new SubContractHierarchyViewer(fViewerbook, fHierarchyLifeCycle, this);
initializeTypesViewer(subTypesViewer, keyListener, "net.sourceforge.c4jplugin.ui.contracthierarchy.tree.subcontracts");
StructuredViewer vajViewer= new TraditionalHierarchyViewer(fViewerbook, fHierarchyLifeCycle, this);
initializeTypesViewer(vajViewer, keyListener, "net.sourceforge.c4jplugin.ui.contracthierarchy.tree");
StructuredViewer graphViewer= new ZestContractHierarchyViewer(fViewerbook, fHierarchyLifeCycle, this);
initializeTypesViewer(graphViewer, keyListener, "net.sourceforge.c4jplugin.ui.contracthierarchy.graph");
fAllViewers= new StructuredViewer[4];
fAllViewers[HIERARCHY_MODE_SUPERTYPES]= superTypesViewer;
fAllViewers[HIERARCHY_MODE_SUBTYPES]= subTypesViewer;
fAllViewers[HIERARCHY_MODE_CLASSIC]= vajViewer;
fAllViewers[HIERARCHY_SPECIALMODE_GRAPH] = graphViewer;
int currViewerIndex;
try {
currViewerIndex= fDialogSettings.getInt(DIALOGSTORE_HIERARCHYVIEW);
if (currViewerIndex < 0 || currViewerIndex > 2) {
currViewerIndex= HIERARCHY_MODE_CLASSIC;
}
} catch (NumberFormatException e) {
currViewerIndex= HIERARCHY_MODE_CLASSIC;
}
fEmptyTypesViewer= new Label(fViewerbook, SWT.TOP | SWT.LEFT | SWT.WRAP);
for (StructuredViewer viewer : fAllViewers) {
viewer.setInput(viewer);
}
int currRepresMode;
try {
currRepresMode = fDialogSettings.getInt(DIALOGSTORE_REPRESENTATION);
if (currRepresMode != REPRESENTATION_MODE_GRAPH ||
currRepresMode != REPRESENTATION_MODE_TREE) {
currRepresMode = REPRESENTATION_MODE_GRAPH;
}
} catch (NumberFormatException e) {
currRepresMode = REPRESENTATION_MODE_GRAPH;
}
// force the update
fCurrentViewerIndex= -1;
fCurrentRepresentation = -1;
setRepresentationMode(currRepresMode, false);
setHierarchyMode(currViewerIndex);
return fViewerbook;
}
private KeyListener createKeyListener() {
return new KeyAdapter() {
public void keyReleased(KeyEvent event) {
if (event.stateMask == 0) {
if (event.keyCode == SWT.F5) {
IContractHierarchy hierarchy= fHierarchyLifeCycle.getContractHierarchy();
if (hierarchy != null) {
fHierarchyLifeCycle.contractHierarchyChanged(hierarchy);
doTypeHierarchyChangedOnViewers(null);
}
updateHierarchyViewer(false, false);
return;
}
}
}
};
}
private void initializeTypesViewer(final StructuredViewer typesViewer, KeyListener keyListener, String cotextHelpId) {
typesViewer.getControl().setVisible(false);
typesViewer.getControl().addKeyListener(keyListener);
((IContractHierarchyViewer)typesViewer).initContextMenu(new IMenuListener() {
public void menuAboutToShow(IMenuManager menu) {
fillTypesViewerContextMenu(((IContractHierarchyViewer)typesViewer), menu);
}
}, cotextHelpId, getSite());
if (typesViewer instanceof AbstractStructuredGraphViewer) {
typesViewer.addSelectionChangedListener(fSelectionChangedListener);
}
else {
typesViewer.addPostSelectionChangedListener(fSelectionChangedListener);
}
((IContractHierarchyViewer)typesViewer).setQualifiedTypeName(isQualifiedTypeNamesEnabled());
((IContractHierarchyViewer)typesViewer).setWorkingSetFilter(fWorkingSetActionGroup.getWorkingSetFilter());
}
private Control createMethodViewerControl(Composite parent) {
fMethodsViewer= new MethodsViewer(parent, fHierarchyLifeCycle, this);
fMethodsViewer.initContextMenu(new IMenuListener() {
public void menuAboutToShow(IMenuManager menu) {
fillMethodsViewerContextMenu(menu);
}
}, IContextMenuConstants.TARGET_ID_MEMBERS_VIEW, getSite());
fMethodsViewer.addPostSelectionChangedListener(fSelectionChangedListener);
Control control= fMethodsViewer.getTable();
control.addKeyListener(createKeyListener());
control.addFocusListener(new FocusListener() {
public void focusGained(FocusEvent e) {
fSelectAllAction.setEnabled(true);
}
public void focusLost(FocusEvent e) {
fSelectAllAction.setEnabled(false);
}
});
return control;
}
private void initDragAndDrop() {
for (int i= 0; i < fAllViewers.length; i++) {
addDragAdapters(fAllViewers[i]);
addDropAdapters(fAllViewers[i]);
}
addDragAdapters(fMethodsViewer);
fMethodsViewer.addDropSupport(DND.DROP_NONE, new Transfer[0], new DropTargetAdapter());
//DND on empty hierarchy
DropTarget dropTarget = new DropTarget(fPagebook, DND.DROP_MOVE | DND.DROP_COPY | DND.DROP_LINK | DND.DROP_DEFAULT);
dropTarget.setTransfer(new Transfer[] { LocalSelectionTransfer.getInstance() });
dropTarget.addDropListener(new TypeHierarchyTransferDropAdapter(this, fAllViewers[0]));
}
private void addDropAdapters(StructuredViewer viewer) {
Transfer[] transfers= new Transfer[] { LocalSelectionTransfer.getInstance() };
int ops= DND.DROP_MOVE | DND.DROP_COPY | DND.DROP_LINK | DND.DROP_DEFAULT;
TransferDropTargetListener[] dropListeners= new TransferDropTargetListener[] {
new TypeHierarchyTransferDropAdapter(this, viewer)
};
viewer.addDropSupport(ops, transfers, new DelegatingDropAdapter(dropListeners));
}
private void addDragAdapters(StructuredViewer viewer) {
int ops= DND.DROP_COPY | DND.DROP_LINK;
Transfer[] transfers= new Transfer[] { LocalSelectionTransfer.getInstance(), ResourceTransfer.getInstance()};
TransferDragSourceListener[] dragListeners= new TransferDragSourceListener[] {
new SelectionTransferDragAdapter(viewer),
new ResourceTransferDragAdapter(viewer)
};
viewer.addDragSupport(ops, transfers, new JdtViewerDragAdapter(viewer, dragListeners));
}
/**
* Returns the inner component in a workbench part.
* @see IWorkbenchPart#createPartControl(Composite)
*/
public void createPartControl(Composite container) {
fParent= container;
addResizeListener(container);
fPagebook= new PageBook(container, SWT.NONE);
fWorkingSetActionGroup= new WorkingSetFilterActionGroup(getSite(), fPropertyChangeListener);
// page 1 of page book (no hierarchy label)
fNoHierarchyShownLabel= new Label(fPagebook, SWT.TOP + SWT.LEFT + SWT.WRAP);
fNoHierarchyShownLabel.setText(ContractHierarchyMessages.TypeHierarchyViewPart_empty);
// page 2 of page book (viewers)
fTypeMethodsSplitter= new SashForm(fPagebook, SWT.VERTICAL);
fTypeMethodsSplitter.setVisible(false);
fTypeViewerViewForm= new ViewForm(fTypeMethodsSplitter, SWT.NONE);
Control typeViewerControl= createTypeViewerControl(fTypeViewerViewForm);
fTypeViewerViewForm.setContent(typeViewerControl);
fMethodViewerViewForm= new ViewForm(fTypeMethodsSplitter, SWT.NONE);
fTypeMethodsSplitter.setWeights(new int[] {35, 65});
Control methodViewerPart= createMethodViewerControl(fMethodViewerViewForm);
fMethodViewerViewForm.setContent(methodViewerPart);
fMethodViewerPaneLabel= new CLabel(fMethodViewerViewForm, SWT.NONE);
fMethodViewerViewForm.setTopLeft(fMethodViewerPaneLabel);
ToolBar methodViewerToolBar= new ToolBar(fMethodViewerViewForm, SWT.FLAT | SWT.WRAP);
fMethodViewerViewForm.setTopCenter(methodViewerToolBar);
//initDragAndDrop();
MenuManager menu= new MenuManager();
menu.add(fFocusOnTypeAction);
fNoHierarchyShownLabel.setMenu(menu.createContextMenu(fNoHierarchyShownLabel));
fPagebook.showPage(fNoHierarchyShownLabel);
int layout;
try {
layout= fDialogSettings.getInt(DIALOGSTORE_VIEWLAYOUT);
if (layout < 0 || layout > 3) {
layout= VIEW_LAYOUT_AUTOMATIC;
}
} catch (NumberFormatException e) {
layout= VIEW_LAYOUT_AUTOMATIC;
}
// force the update
fCurrentLayout= -1;
// will fill the main tool bar
setViewLayout(layout);
showQualifiedTypeNames(fDialogSettings.getBoolean(DIALOGSTORE_QUALIFIED_NAMES));
setLinkingEnabled(fDialogSettings.getBoolean(DIALOGSTORE_LINKEDITORS));
// set the filter menu items
IActionBars actionBars= getViewSite().getActionBars();
IMenuManager viewMenu= actionBars.getMenuManager();
for (ToggleViewAction action : fViewActions) {
viewMenu.add(action);
action.setEnabled(false);
}
viewMenu.add(new Separator());
// set the presentation menu items
for (ToggleRepresentationAction action : fRepActions) {
viewMenu.add(action);
action.setEnabled(false);
}
viewMenu.add(new Separator());
fWorkingSetActionGroup.fillViewMenu(viewMenu);
viewMenu.add(new Separator());
IMenuManager layoutSubMenu= new MenuManager(ContractHierarchyMessages.TypeHierarchyViewPart_layout_submenu);
viewMenu.add(layoutSubMenu);
for (int i= 0; i < fToggleOrientationActions.length; i++) {
layoutSubMenu.add(fToggleOrientationActions[i]);
}
viewMenu.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));
viewMenu.add(fShowQualifiedTypeNamesAction);
viewMenu.add(fToggleLinkingAction);
// fill the method viewer tool bar
ToolBarManager lowertbmanager= new ToolBarManager(methodViewerToolBar);
lowertbmanager.add(fEnableMemberFilterAction);
lowertbmanager.add(new Separator());
fMethodsViewer.contributeToToolBar(lowertbmanager);
lowertbmanager.update(true);
// selection provider
int nHierarchyViewers= fAllViewers.length;
StructuredViewer[] trackedViewers= new StructuredViewer[nHierarchyViewers + 1];
for (int i= 0; i < nHierarchyViewers; i++) {
trackedViewers[i]= fAllViewers[i];
}
trackedViewers[nHierarchyViewers]= fMethodsViewer;
fSelectionProviderMediator= new SelectionProviderMediator(trackedViewers, getCurrentViewer());
IStatusLineManager slManager= getViewSite().getActionBars().getStatusLineManager();
fSelectionProviderMediator.addSelectionChangedListener(new StatusBarUpdater(slManager));
getSite().setSelectionProvider(fSelectionProviderMediator);
getSite().getPage().addPartListener(fPartListener);
// see http://bugs.eclipse.org/bugs/show_bug.cgi?id=33657
IJavaElement input= null; //determineInputElement();
if (fMemento != null) {
restoreState(fMemento, input);
} else if (input != null) {
setInputElement(input);
} else {
setViewerVisibility(false);
}
PlatformUI.getWorkbench().getHelpSystem().setHelp(fPagebook, IJavaHelpContextIds.TYPE_HIERARCHY_VIEW);
fActionGroups= new CompositeActionGroup(new ActionGroup[] {
new NewWizardsActionGroup(this.getSite()),
new OpenEditorActionGroup(this),
new OpenViewActionGroup(this),
new CCPActionGroup(this),
new GenerateActionGroup(this),
new RefactorActionGroup(this),
new JavaSearchActionGroup(this)
});
fActionGroups.fillActionBars(actionBars);
fSelectAllAction= new SelectAllAction(fMethodsViewer);
actionBars.setGlobalActionHandler(ActionFactory.SELECT_ALL.getId(), fSelectAllAction);
}
private void addResizeListener(Composite parent) {
parent.addControlListener(new ControlListener() {
public void controlMoved(ControlEvent e) {
}
public void controlResized(ControlEvent e) {
if (getViewLayout() == VIEW_LAYOUT_AUTOMATIC && !fInComputeLayout) {
setViewLayout(VIEW_LAYOUT_AUTOMATIC);
}
}
});
}
/* (non-Javadoc)
* @see org.eclipse.jdt.ui.ITypeHierarchyViewPart#setViewLayout(int)
*/
public void setViewLayout(int layout) {
if (fCurrentLayout != layout || layout == VIEW_LAYOUT_AUTOMATIC) {
fInComputeLayout= true;
try {
boolean methodViewerNeedsUpdate= false;
if (fMethodViewerViewForm != null && !fMethodViewerViewForm.isDisposed()
&& fTypeMethodsSplitter != null && !fTypeMethodsSplitter.isDisposed()) {
boolean horizontal= false;
if (layout == VIEW_LAYOUT_SINGLE) {
fMethodViewerViewForm.setVisible(false);
showMembersInHierarchy(false);
updateMethodViewer(null);
} else {
if (fCurrentLayout == VIEW_LAYOUT_SINGLE) {
fMethodViewerViewForm.setVisible(true);
methodViewerNeedsUpdate= true;
}
if (layout == VIEW_LAYOUT_AUTOMATIC) {
if (fParent != null && !fParent.isDisposed()) {
Point size= fParent.getSize();
if (size.x != 0 && size.y != 0) {
horizontal= size.x > size.y;
}
}
if (fCurrentLayout == VIEW_LAYOUT_AUTOMATIC) {
boolean wasHorizontal= fTypeMethodsSplitter.getOrientation() == SWT.HORIZONTAL;
if (wasHorizontal == horizontal) {
return; // no real change
}
}
} else if (layout == VIEW_LAYOUT_HORIZONTAL) {
horizontal= true;
}
fTypeMethodsSplitter.setOrientation(horizontal ? SWT.HORIZONTAL : SWT.VERTICAL);
}
updateMainToolbar(horizontal);
fTypeMethodsSplitter.layout();
}
if (methodViewerNeedsUpdate) {
updateMethodViewer(fSelectedType);
}
fDialogSettings.put(DIALOGSTORE_VIEWLAYOUT, layout);
fCurrentLayout= layout;
updateCheckedState();
} finally {
fInComputeLayout= false;
}
}
}
public void setRepresentationMode(int representation, boolean update) {
System.out.println("setRepMode called with " + representation + ", curr = " + fCurrentRepresentation);
if (getRepresentationMode() != representation) {
Assert.isNotNull(fAllViewers);
if (representation != REPRESENTATION_MODE_GRAPH
&& representation != REPRESENTATION_MODE_TREE) {
return;
}
fCurrentRepresentation = representation;
fDialogSettings.put(DIALOGSTORE_REPRESENTATION, representation);
if (update) {
updateHierarchyViewer(true, false);
if (fInputElement != null) {
ISelection currSelection= getCurrentViewer().getSelection();
if (currSelection == null || currSelection.isEmpty()) {
internalSelectType(getSelectableType(fInputElement), false);
currSelection= getCurrentViewer().getSelection();
}
if (!fIsEnableMemberFilter) {
typeSelectionChanged(currSelection);
}
}
//updateTitle();
getCurrentViewer().getControl().setFocus();
}
updateMainToolbar(fTypeViewerViewForm.getTopLeft() != null);
}
for (ToggleRepresentationAction action : fRepActions) {
action.setChecked(getRepresentationMode() == action.getRepresentation());
}
}
/* (non-Javadoc)
* @see org.eclipse.jdt.ui.ITypeHierarchyViewPart#getViewLayout()
*/
public int getViewLayout() {
return fCurrentLayout;
}
public int getRepresentationMode() {
return fCurrentRepresentation;
}
private void updateCheckedState() {
for (int i= 0; i < fToggleOrientationActions.length; i++) {
fToggleOrientationActions[i].setChecked(getViewLayout() == fToggleOrientationActions[i].getOrientation());
}
}
private void updateMainToolbar(boolean horizontal) {
IActionBars actionBars= getViewSite().getActionBars();
IToolBarManager tbmanager= actionBars.getToolBarManager();
if (horizontal) {
clearMainToolBar(tbmanager);
ToolBar typeViewerToolBar= new ToolBar(fTypeViewerViewForm, SWT.FLAT | SWT.WRAP);
fillMainToolBar(new ToolBarManager(typeViewerToolBar));
fTypeViewerViewForm.setTopLeft(typeViewerToolBar);
} else {
fTypeViewerViewForm.setTopLeft(null);
fillMainToolBar(tbmanager);
}
}
private void fillMainToolBar(IToolBarManager tbmanager) {
System.out.println("filling main toolbar (graph mode: " + (getRepresentationMode() == REPRESENTATION_MODE_GRAPH) + ")");
tbmanager.removeAll();
if (getRepresentationMode() == REPRESENTATION_MODE_GRAPH) {
fZoomControl = new ZoomContributionItem(((ZestContractHierarchyViewer)fAllViewers[HIERARCHY_SPECIALMODE_GRAPH]).getZoomManager());
tbmanager.add(fZoomControl);
}
//tbmanager.add(new Separator());
for (int i= 0; i < fViewActions.length; i++) {
tbmanager.add(fViewActions[i]);
}
tbmanager.add(fHistoryDropDownAction);
tbmanager.update(false);
}
private void clearMainToolBar(IToolBarManager tbmanager) {
tbmanager.removeAll();
tbmanager.update(false);
}
/*
* Creates the context menu for the hierarchy viewers
*/
private void fillTypesViewerContextMenu(IContractHierarchyViewer viewer, IMenuManager menu) {
JavaPlugin.createStandardGroups(menu);
menu.appendToGroup(IContextMenuConstants.GROUP_SHOW, new Separator(GROUP_FOCUS));
// viewer entries
viewer.contributeToContextMenu(menu);
if (fFocusOnSelectionAction.canActionBeAdded())
menu.appendToGroup(GROUP_FOCUS, fFocusOnSelectionAction);
menu.appendToGroup(GROUP_FOCUS, fFocusOnTypeAction);
fActionGroups.setContext(new ActionContext(getSite().getSelectionProvider().getSelection()));
fActionGroups.fillContextMenu(menu);
fActionGroups.setContext(null);
}
/*
* Creates the context menu for the method viewer
*/
private void fillMethodsViewerContextMenu(IMenuManager menu) {
JavaPlugin.createStandardGroups(menu);
// viewer entries
fMethodsViewer.contributeToContextMenu(menu);
fActionGroups.setContext(new ActionContext(getSite().getSelectionProvider().getSelection()));
fActionGroups.fillContextMenu(menu);
fActionGroups.setContext(null);
}
/*
* Toggles between the empty viewer page and the hierarchy
*/
private void setViewerVisibility(boolean showHierarchy) {
if (showHierarchy) {
fViewerbook.showPage(getCurrentViewer().getControl());
} else {
fViewerbook.showPage(fEmptyTypesViewer);
}
}
/*
* Sets the member filter. <code>null</code> disables member filtering.
*/
private void setMemberFilter(IMember[] memberFilter) {
Assert.isNotNull(fAllViewers);
for (int i= 0; i < fAllViewers.length; i++) {
((IContractHierarchyViewer)fAllViewers[i]).setMemberFilter(memberFilter);
}
}
private IType getSelectableType(IJavaElement elem) {
if (elem.getElementType() != IJavaElement.TYPE) {
return ((IContractHierarchyViewer)getCurrentViewer()).getRootType();
} else {
return (IType) elem;
}
}
private void internalSelectType(IMember elem, boolean reveal) {
StructuredViewer viewer= getCurrentViewer();
viewer.removePostSelectionChangedListener(fSelectionChangedListener);
viewer.setSelection(elem != null ? new StructuredSelection(elem) : StructuredSelection.EMPTY, reveal);
viewer.addPostSelectionChangedListener(fSelectionChangedListener);
}
/*
* When the input changed or the hierarchy pane becomes visible,
* <code>updateHierarchyViewer<code> brings up the correct view and refreshes
* the current tree or graph
*/
private void updateHierarchyViewer(final boolean doExpand, final boolean inputChanged) {
if (fInputElement == null) {
fNoHierarchyShownLabel.setText(ContractHierarchyMessages.TypeHierarchyViewPart_empty);
fPagebook.showPage(fNoHierarchyShownLabel);
} else {
if (((IContractHierarchyViewer)getCurrentViewer()).containsElements() != null) {
Runnable runnable= new Runnable() {
public void run() {
((IContractHierarchyViewer)getCurrentViewer()).updateContent(doExpand); // refresh
if (inputChanged && getCurrentViewer() instanceof ZestContractHierarchyViewer) {
((ZestContractHierarchyViewer)getCurrentViewer()).applyLayout();
}
}
};
BusyIndicator.showWhile(getDisplay(), runnable);
if (!isChildVisible(fViewerbook, getCurrentViewer().getControl())) {
setViewerVisibility(true);
}
} else {
fEmptyTypesViewer.setText(NLS.bind(ContractHierarchyMessages.TypeHierarchyViewPart_nodecl, fInputElement.getElementName()));
setViewerVisibility(false);
}
}
}
private void updateMethodViewer(final IType input) {
if (!fIsEnableMemberFilter && fCurrentLayout != VIEW_LAYOUT_SINGLE) {
if (input == fMethodsViewer.getInput()) {
if (input != null) {
Runnable runnable= new Runnable() {
public void run() {
fMethodsViewer.refresh(); // refresh
}
};
BusyIndicator.showWhile(getDisplay(), runnable);
}
} else {
if (input != null) {
fMethodViewerPaneLabel.setText(fPaneLabelProvider.getText(input));
fMethodViewerPaneLabel.setImage(fPaneLabelProvider.getImage(input));
} else {
fMethodViewerPaneLabel.setText(""); //$NON-NLS-1$
fMethodViewerPaneLabel.setImage(null);
}
Runnable runnable= new Runnable() {
public void run() {
fMethodsViewer.setInput(input); // refresh
}
};
BusyIndicator.showWhile(getDisplay(), runnable);
}
}
}
protected void doSelectionChanged(SelectionChangedEvent e) {
if (e.getSelectionProvider() == fMethodsViewer) {
methodSelectionChanged(e.getSelection());
} else {
typeSelectionChanged(e.getSelection());
}
}
private void methodSelectionChanged(ISelection sel) {
if (sel instanceof IStructuredSelection) {
List selected= ((IStructuredSelection)sel).toList();
int nSelected= selected.size();
if (fIsEnableMemberFilter) {
IMember[] memberFilter= null;
if (nSelected > 0) {
memberFilter= new IMember[nSelected];
selected.toArray(memberFilter);
}
setMemberFilter(memberFilter);
updateHierarchyViewer(true, true);
updateTitle();
internalSelectType(fSelectedType, true);
}
if (nSelected == 1 && fSelectInEditor) {
revealElementInEditor(selected.get(0), fMethodsViewer);
}
}
}
private void typeSelectionChanged(ISelection sel) {
if (sel instanceof IStructuredSelection) {
List selected= ((IStructuredSelection)sel).toList();
int nSelected= selected.size();
if (nSelected != 0) {
List types= new ArrayList(nSelected);
for (int i= nSelected-1; i >= 0; i--) {
Object elem= selected.get(i);
if (elem instanceof IType && !types.contains(elem)) {
types.add(elem);
}
}
if (types.size() == 1) {
fSelectedType= (IType) types.get(0);
updateMethodViewer(fSelectedType);
} else if (types.size() == 0) {
// method selected, no change
}
if (nSelected == 1 && fSelectInEditor) {
revealElementInEditor(selected.get(0), getCurrentViewer());
}
} else {
fSelectedType= null;
updateMethodViewer(null);
}
}
}
private void revealElementInEditor(Object elem, StructuredViewer originViewer) {
// only allow revealing when the type hierarchy is the active page
// no revealing after selection events due to model changes
if (getSite().getPage().getActivePart() != this) {
return;
}
if (fSelectionProviderMediator.getViewerInFocus() != originViewer) {
return;
}
IEditorPart editorPart= EditorUtility.isOpenInEditor(elem);
if (editorPart != null && (elem instanceof IJavaElement)) {
getSite().getPage().removePartListener(fPartListener);
getSite().getPage().bringToTop(editorPart);
EditorUtility.revealInEditor(editorPart, (IJavaElement) elem);
getSite().getPage().addPartListener(fPartListener);
}
}
private Display getDisplay() {
if (fPagebook != null && !fPagebook.isDisposed()) {
return fPagebook.getDisplay();
}
return null;
}
private boolean isChildVisible(Composite pb, Control child) {
Control[] children= pb.getChildren();
for (int i= 0; i < children.length; i++) {
if (children[i] == child && children[i].isVisible())
return true;
}
return false;
}
private void updateTitle() {
String viewerTitle= ((IContractHierarchyViewer)getCurrentViewer()).getTitle();
String tooltip;
String title;
if (fInputElement != null) {
IWorkingSet workingSet= fWorkingSetActionGroup.getWorkingSet();
if (workingSet == null) {
String[] args= new String[] { viewerTitle, JavaElementLabels.getElementLabel(fInputElement, JavaElementLabels.ALL_DEFAULT) };
title= NLS.bind(ContractHierarchyMessages.TypeHierarchyViewPart_title, args);
tooltip= NLS.bind(ContractHierarchyMessages.TypeHierarchyViewPart_tooltip, args);
} else {
String[] args= new String[] { viewerTitle, JavaElementLabels.getElementLabel(fInputElement, JavaElementLabels.ALL_DEFAULT), workingSet.getLabel() };
title= NLS.bind(ContractHierarchyMessages.TypeHierarchyViewPart_ws_title, args);
tooltip= NLS.bind(ContractHierarchyMessages.TypeHierarchyViewPart_ws_tooltip, args);
}
} else {
title= ""; //$NON-NLS-1$
tooltip= viewerTitle;
}
setContentDescription(title);
setTitleToolTip(tooltip);
}
private void updateToolbarButtons() {
boolean isType= fInputElement instanceof IType;
for (ToggleViewAction action : fViewActions) {
if (action.getViewerIndex() == HIERARCHY_MODE_CLASSIC) {
action.setEnabled(fInputElement != null);
} else {
action.setEnabled(isType);
}
}
for (ToggleRepresentationAction action : fRepActions) {
action.setEnabled(fInputElement != null);
}
}
public void setHierarchyMode(int viewerIndex) {
System.out.println("setHierarchyMode called with " + viewerIndex + ", curr = " + fCurrentViewerIndex);
Assert.isNotNull(fAllViewers);
if (viewerIndex < fAllViewers.length-1 && fCurrentViewerIndex != viewerIndex) {
fCurrentViewerIndex= viewerIndex;
((ZestContractHierarchyViewer)fAllViewers[HIERARCHY_SPECIALMODE_GRAPH]).setHierarchyMode(viewerIndex);
updateHierarchyViewer(true, false);
if (fInputElement != null) {
ISelection currSelection= getCurrentViewer().getSelection();
if (currSelection == null || currSelection.isEmpty()) {
internalSelectType(getSelectableType(fInputElement), false);
currSelection= getCurrentViewer().getSelection();
}
if (!fIsEnableMemberFilter) {
typeSelectionChanged(currSelection);
}
}
updateTitle();
fDialogSettings.put(DIALOGSTORE_HIERARCHYVIEW, viewerIndex);
getCurrentViewer().getControl().setFocus();
}
for (ToggleViewAction action : fViewActions) {
action.setChecked(fCurrentViewerIndex == action.getViewerIndex());
}
}
public int getHierarchyMode() {
return fCurrentViewerIndex;
}
private StructuredViewer getCurrentViewer() {
if (getRepresentationMode() == REPRESENTATION_MODE_GRAPH)
return fAllViewers[HIERARCHY_SPECIALMODE_GRAPH];
return fAllViewers[fCurrentViewerIndex];
}
/* (non-Javadoc)
* @see org.eclipse.jdt.ui.ITypeHierarchyViewPart#showMembersInHierarchy(boolean)
*/
public void showMembersInHierarchy(boolean on) {
if (on != fIsEnableMemberFilter) {
fIsEnableMemberFilter= on;
if (!on) {
IType methodViewerInput= (IType) fMethodsViewer.getInput();
setMemberFilter(null);
updateHierarchyViewer(true, false);
updateTitle();
if (methodViewerInput != null && ((IContractHierarchyViewer)getCurrentViewer()).isElementShown(methodViewerInput)) {
// avoid that the method view changes content by selecting the previous input
internalSelectType(methodViewerInput, true);
} else if (fSelectedType != null) {
// choose a input that exists
internalSelectType(fSelectedType, true);
updateMethodViewer(fSelectedType);
}
} else {
methodSelectionChanged(fMethodsViewer.getSelection());
}
}
fEnableMemberFilterAction.setChecked(on);
}
/* (non-Javadoc)
* @see org.eclipse.jdt.ui.ITypeHierarchyViewPart#isShowMembersInHierarchy()
*/
public boolean isShowMembersInHierarchy() {
return fIsEnableMemberFilter;
}
/* (non-Javadoc)
* @see org.eclipse.jdt.ui.ITypeHierarchyViewPart#showQualifiedTypeNames(boolean)
*/
public void showQualifiedTypeNames(boolean on) {
if (on != fShowQualifiedTypeNames) {
fShowQualifiedTypeNames= on;
if (fAllViewers != null) {
for (int i= 0; i < fAllViewers.length; i++) {
((IContractHierarchyViewer)fAllViewers[i]).setQualifiedTypeName(on);
}
}
}
fShowQualifiedTypeNamesAction.setChecked(on);
fDialogSettings.put(DIALOGSTORE_QUALIFIED_NAMES, on);
}
/* (non-Javadoc)
* @see org.eclipse.jdt.ui.ITypeHierarchyViewPart#isQualifiedTypeNamesEnabled()
*/
public boolean isQualifiedTypeNamesEnabled() {
return fShowQualifiedTypeNames;
}
/**
* Called from ITypeHierarchyLifeCycleListener.
* Can be called from any thread
* @param typeHierarchy Hierarchy that has changed
* @param changedTypes Types in the hierarchy that have change or <code>null</code> if the full hierarchy has changed
*/
protected void doTypeHierarchyChanged(final ContractHierarchyLifeCycle typeHierarchy, final IType[] changedTypes) {
if (!fIsVisible) {
fNeedRefresh= true;
return;
}
if (fIsRefreshRunnablePosted) {
return;
}
Display display= getDisplay();
if (display != null) {
fIsRefreshRunnablePosted= true;
display.asyncExec(new Runnable() {
public void run() {
try {
if (fPagebook != null && !fPagebook.isDisposed()) {
doTypeHierarchyChangedOnViewers(changedTypes);
}
} finally {
fIsRefreshRunnablePosted= false;
}
}
});
}
}
protected void doTypeHierarchyChangedOnViewers(IType[] changedTypes) {
if (fHierarchyLifeCycle.getContractHierarchy() == null || !fHierarchyLifeCycle.getContractHierarchy().exists()) {
clearInput();
} else {
if (changedTypes == null) {
// hierarchy change
try {
fHierarchyLifeCycle.ensureRefreshedContractHierarchy(fInputElement, getSite().getWorkbenchWindow());
} catch (InvocationTargetException e) {
ExceptionHandler.handle(e, getSite().getShell(), ContractHierarchyMessages.TypeHierarchyViewPart_exception_title, ContractHierarchyMessages.TypeHierarchyViewPart_exception_message);
clearInput();
return;
} catch (InterruptedException e) {
return;
}
fMethodsViewer.refresh();
updateHierarchyViewer(false, true);
} else {
// elements in hierarchy modified
Object methodViewerInput= fMethodsViewer.getInput();
fMethodsViewer.refresh();
fMethodViewerPaneLabel.setText(fPaneLabelProvider.getText(methodViewerInput));
fMethodViewerPaneLabel.setImage(fPaneLabelProvider.getImage(methodViewerInput));
if (((IContractHierarchyViewer)getCurrentViewer()).isMethodFiltering()) {
if (changedTypes.length == 1) {
getCurrentViewer().refresh(changedTypes[0]);
} else {
updateHierarchyViewer(false, true);
}
} else {
getCurrentViewer().update(changedTypes, new String[] { IBasicPropertyConstants.P_TEXT, IBasicPropertyConstants.P_IMAGE } );
}
}
}
}
/*
* @see IViewPart#init
*/
public void init(IViewSite site, IMemento memento) throws PartInitException {
super.init(site, memento);
fMemento= memento;
}
/*
* @see ViewPart#saveState(IMemento)
*/
public void saveState(IMemento memento) {
if (fPagebook == null) {
// part has not been created
if (fMemento != null) { //Keep the old state;
memento.putMemento(fMemento);
}
return;
}
if (fInputElement != null) {
String handleIndentifier= fInputElement.getHandleIdentifier();
memento.putString(TAG_INPUT, handleIndentifier);
}
memento.putInteger(TAG_VIEW, getHierarchyMode());
memento.putInteger(TAG_LAYOUT, getViewLayout());
memento.putInteger(TAG_REPRESENTATION, getRepresentationMode());
memento.putString(TAG_ZOOMLEVEL, ((ZestContractHierarchyViewer)fAllViewers[HIERARCHY_SPECIALMODE_GRAPH]).getZoomManager().getZoomAsText());
memento.putInteger(TAG_QUALIFIED_NAMES, isQualifiedTypeNamesEnabled() ? 1 : 0);
memento.putInteger(TAG_EDITOR_LINKING, isLinkingEnabled() ? 1 : 0);
int weigths[]= fTypeMethodsSplitter.getWeights();
int ratio= (weigths[0] * 1000) / (weigths[0] + weigths[1]);
memento.putInteger(TAG_RATIO, ratio);
ScrollBar bar= null;
Control control = getCurrentViewer().getControl();
if (control instanceof Scrollable) bar = ((Scrollable)control).getVerticalBar();
int position= bar != null ? bar.getSelection() : 0;
memento.putInteger(TAG_VERTICAL_SCROLL, position);
IJavaElement selection= (IJavaElement)((IStructuredSelection) getCurrentViewer().getSelection()).getFirstElement();
if (selection != null) {
memento.putString(TAG_SELECTION, selection.getHandleIdentifier());
}
fWorkingSetActionGroup.saveState(memento);
fMethodsViewer.saveState(memento);
}
/*
* Restores the type hierarchy settings from a memento.
*/
private void restoreState(final IMemento memento, IJavaElement defaultInput) {
IJavaElement input= defaultInput;
String elementId= memento.getString(TAG_INPUT);
if (elementId != null) {
input= JavaCore.create(elementId);
if (input != null && !input.exists()) {
input= null;
}
}
if (input == null) {
doRestoreState(memento, input);
} else {
final IJavaElement hierarchyInput= input;
synchronized (this) {
String label= NLS.bind(ContractHierarchyMessages.TypeHierarchyViewPart_restoreinput, hierarchyInput.getElementName());
fNoHierarchyShownLabel.setText(label);
fRestoreStateJob= new Job(label) {
protected IStatus run(IProgressMonitor monitor) {
try {
doRestoreInBackground(memento, hierarchyInput, monitor);
} catch (JavaModelException e) {
return e.getStatus();
} catch (OperationCanceledException e) {
return Status.CANCEL_STATUS;
}
return Status.OK_STATUS;
}
};
fRestoreStateJob.schedule();
}
}
}
private void doRestoreInBackground(final IMemento memento, final IJavaElement hierarchyInput, IProgressMonitor monitor) throws JavaModelException {
fHierarchyLifeCycle.doHierarchyRefresh(hierarchyInput, monitor);
if (!monitor.isCanceled()) {
Display.getDefault().asyncExec(new Runnable() {
public void run() {
// running async: check first if view still exists
if (fPagebook != null && !fPagebook.isDisposed()) {
doRestoreState(memento, hierarchyInput);
}
}
});
}
}
final void doRestoreState(IMemento memento, IJavaElement input) {
synchronized (this) {
if (fRestoreStateJob == null) {
return;
}
fRestoreStateJob= null;
}
fWorkingSetActionGroup.restoreState(memento);
setInputElement(input);
Integer rep = memento.getInteger(TAG_REPRESENTATION);
if (rep != null) {
setRepresentationMode(rep.intValue(), false);
}
String zoom = memento.getString(TAG_ZOOMLEVEL);
System.out.println("setting zoomlevel in manager during restore-state");
if (zoom != null) {
((ZestContractHierarchyViewer)fAllViewers[HIERARCHY_SPECIALMODE_GRAPH]).getZoomManager().setZoomAsText(zoom);
}
else {
((ZestContractHierarchyViewer)fAllViewers[HIERARCHY_SPECIALMODE_GRAPH]).getZoomManager().setZoomAsText("100%");
}
Integer viewerIndex= memento.getInteger(TAG_VIEW);
if (viewerIndex != null) {
setHierarchyMode(viewerIndex.intValue());
}
Integer layout= memento.getInteger(TAG_LAYOUT);
if (layout != null) {
setViewLayout(layout.intValue());
}
Integer val= memento.getInteger(TAG_EDITOR_LINKING);
if (val != null) {
setLinkingEnabled(val.intValue() != 0);
}
Integer showQualified= memento.getInteger(TAG_QUALIFIED_NAMES);
if (showQualified != null) {
showQualifiedTypeNames(showQualified.intValue() != 0);
}
updateCheckedState();
Integer ratio= memento.getInteger(TAG_RATIO);
if (ratio != null) {
fTypeMethodsSplitter.setWeights(new int[] { ratio.intValue(), 1000 - ratio.intValue() });
}
ScrollBar bar= null;
Control control = getCurrentViewer().getControl();
if (control instanceof Scrollable) bar = ((Scrollable)control).getVerticalBar();
if (bar != null) {
Integer vScroll= memento.getInteger(TAG_VERTICAL_SCROLL);
if (vScroll != null) {
bar.setSelection(vScroll.intValue());
}
}
fMethodsViewer.restoreState(memento);
}
/**
* view part becomes visible
* @param isVisible
*/
protected void visibilityChanged(boolean isVisible) {
fIsVisible= isVisible;
if (isVisible && fNeedRefresh) {
doTypeHierarchyChangedOnViewers(null);
}
fNeedRefresh= false;
}
/**
* Link selection to active editor.
* @param editor The activated editor
*/
protected void editorActivated(IEditorPart editor) {
if (!isLinkingEnabled()) {
return;
}
if (fInputElement == null) {
// no type hierarchy shown
return;
}
IJavaElement elem= (IJavaElement)editor.getEditorInput().getAdapter(IJavaElement.class);
try {
IType type= null;
if (elem instanceof IClassFile) {
type= ((IClassFile) elem).getType();
} else if (elem instanceof ICompilationUnit) {
type= ((ICompilationUnit) elem).findPrimaryType();
}
if (type != null) {
internalSelectType(type, true);
if (getCurrentViewer().getSelection().isEmpty()) {
updateMethodViewer(null);
} else {
updateMethodViewer(type);
}
}
} catch (JavaModelException e) {
C4JActivator.log(e);
}
}
/* (non-Javadoc)
* @see org.eclipse.jdt.internal.ui.viewsupport.IViewPartInputProvider#getViewPartInput()
*/
public Object getViewPartInput() {
return fInputElement;
}
/**
* @return Returns the <code>IShowInSource</code> for this view.
*/
protected IShowInSource getShowInSource() {
return new IShowInSource() {
public ShowInContext getShowInContext() {
return new ShowInContext(
null,
getSite().getSelectionProvider().getSelection());
}
};
}
/* (non-Javadoc)
* @see org.eclipse.jdt.ui.ITypeHierarchyViewPart#isLinkingEnabled()
*/
public boolean isLinkingEnabled() {
return fLinkingEnabled;
}
/* (non-Javadoc)
* @see org.eclipse.jdt.ui.ITypeHierarchyViewPart#setLinkingEnabled(boolean)
*/
public void setLinkingEnabled(boolean enabled) {
fLinkingEnabled= enabled;
fToggleLinkingAction.setChecked(enabled);
fDialogSettings.put(DIALOGSTORE_LINKEDITORS, enabled);
if (enabled) {
IWorkbenchPartSite site= getSite();
if (site != null) {
IEditorPart editor = site.getPage().getActiveEditor();
if (editor != null) {
editorActivated(editor);
}
}
}
}
public void clearNeededRefresh() {
fNeedRefresh= false;
}
}