org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/MethodsViewer.java - jdt/eclipse.jdt.ui - Git at Google

 /*******************************************************************************
  * Copyright (c) 2000, 2005 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.jdt.internal.ui.typehierarchy;

 import java.util.ArrayList;
 import java.util.List;

 import org.eclipse.swt.SWT;
 import org.eclipse.swt.widgets.Composite;
 import org.eclipse.swt.widgets.Menu;
 import org.eclipse.swt.widgets.ScrollBar;
 import org.eclipse.swt.widgets.Table;

 import org.eclipse.jface.action.IMenuListener;
 import org.eclipse.jface.action.IMenuManager;
 import org.eclipse.jface.action.MenuManager;
 import org.eclipse.jface.action.Separator;
 import org.eclipse.jface.action.ToolBarManager;
 import org.eclipse.jface.viewers.IOpenListener;
 import org.eclipse.jface.viewers.ISelection;
 import org.eclipse.jface.viewers.OpenEvent;
 import org.eclipse.jface.viewers.StructuredSelection;

 import org.eclipse.ui.IMemento;
 import org.eclipse.ui.IWorkbenchPart;
 import org.eclipse.ui.IWorkbenchPartSite;

 import org.eclipse.jdt.core.IMethod;
 import org.eclipse.jdt.core.JavaModelException;

 import org.eclipse.jdt.internal.corext.util.JavaModelUtil;

 import org.eclipse.jdt.ui.JavaElementLabels;
 import org.eclipse.jdt.ui.actions.MemberFilterActionGroup;
 import org.eclipse.jdt.ui.actions.OpenAction;

 import org.eclipse.jdt.internal.ui.IJavaHelpContextIds;
 import org.eclipse.jdt.internal.ui.JavaPlugin;
 import org.eclipse.jdt.internal.ui.filters.SyntheticMembersFilter;
 import org.eclipse.jdt.internal.ui.util.JavaUIHelp;
 import org.eclipse.jdt.internal.ui.util.SelectionUtil;
 import org.eclipse.jdt.internal.ui.viewsupport.DecoratingJavaLabelProvider;
 import org.eclipse.jdt.internal.ui.viewsupport.ProblemTableViewer;

 /**
  * Method viewer shows a list of methods of a input type.
  * Offers filter actions.
  * No dependency to the type hierarchy view
  */
 public class MethodsViewer extends ProblemTableViewer {

 	private static final String TAG_SHOWINHERITED= "showinherited";		 //$NON-NLS-1$
 	private static final String TAG_SORTBYDEFININGTYPE= "sortbydefiningtype";		 //$NON-NLS-1$
 	private static final String TAG_VERTICAL_SCROLL= "mv_vertical_scroll";		 //$NON-NLS-1$

 	private MethodsLabelProvider fLabelProvider;

 	private MemberFilterActionGroup fMemberFilterActionGroup;

 	private OpenAction fOpen;
 	private ShowInheritedMembersAction fShowInheritedMembersAction;
 	private SortByDefiningTypeAction fSortByDefiningTypeAction;

 	public MethodsViewer(Composite parent, final TypeHierarchyLifeCycle lifeCycle, IWorkbenchPart part) {
 		super(new Table(parent, SWT.MULTI));

 		addFilter(new SyntheticMembersFilter());

 		fLabelProvider= new MethodsLabelProvider(lifeCycle, this);

 		setLabelProvider(new DecoratingJavaLabelProvider(fLabelProvider, true));
 		setContentProvider(new MethodsContentProvider(lifeCycle));

 		HierarchyViewerSorter sorter= new HierarchyViewerSorter(lifeCycle);
 		sorter.setSortByDefiningType(false);
 		setSorter(sorter);

 		fOpen= new OpenAction(part.getSite());
 		addOpenListener(new IOpenListener() {
 			public void open(OpenEvent event) {
 				fOpen.run();
 			}
 		});

 		fMemberFilterActionGroup= new MemberFilterActionGroup(this, "HierarchyMethodView", false, MemberFilterActionGroup.ALL_FILTERS & ~MemberFilterActionGroup.FILTER_LOCALTYPES); //$NON-NLS-1$

 		fShowInheritedMembersAction= new ShowInheritedMembersAction(this, false);
 		fSortByDefiningTypeAction= new SortByDefiningTypeAction(this, false);

 		showInheritedMethodsNoRedraw(false);
 		sortByDefiningTypeNoRedraw(false);

 		JavaUIHelp.setHelp(this, IJavaHelpContextIds.TYPE_HIERARCHY_VIEW);
 	}

 	private void showInheritedMethodsNoRedraw(boolean on) {
 		MethodsContentProvider cprovider= (MethodsContentProvider) getContentProvider();
 		cprovider.showInheritedMethods(on);
 		fShowInheritedMembersAction.setChecked(on);
 		if (on) {
 			fLabelProvider.setTextFlags(fLabelProvider.getTextFlags() | JavaElementLabels.ALL_POST_QUALIFIED);
 		} else {
 			fLabelProvider.setTextFlags(fLabelProvider.getTextFlags() & ~JavaElementLabels.ALL_POST_QUALIFIED);
 		}
 		if (on) {
 			sortByDefiningTypeNoRedraw(false);
 		}
 		fSortByDefiningTypeAction.setEnabled(!on);

 	}

 	/**
 	 * Show inherited methods
 	 */
 	public void showInheritedMethods(boolean on) {
 		if (on == isShowInheritedMethods()) {
 			return;
 		}
 		try {
 			getTable().setRedraw(false);
 			showInheritedMethodsNoRedraw(on);
 			refresh();
 		} finally {
 			getTable().setRedraw(true);
 		}
 	}

 	private void sortByDefiningTypeNoRedraw(boolean on) {
 		fSortByDefiningTypeAction.setChecked(on);
 		fLabelProvider.setShowDefiningType(on);
 		((HierarchyViewerSorter) getSorter()).setSortByDefiningType(on);
 	}

 	/**
 	 * Show the name of the defining type
 	 */
 	public void sortByDefiningType(boolean on) {
 		if (on == isShowDefiningTypes()) {
 			return;
 		}
 		try {
 			getTable().setRedraw(false);
 			sortByDefiningTypeNoRedraw(on);
 			refresh();
 		} finally {
 			getTable().setRedraw(true);
 		}
 	}

 	/*
 	 * @see Viewer#inputChanged(Object, Object)
 	 */
 	protected void inputChanged(Object input, Object oldInput) {
 		super.inputChanged(input, oldInput);
 	}

 	/**
 	 * Returns <code>true</code> if inherited methods are shown.
 	 */
 	public boolean isShowInheritedMethods() {
 		return ((MethodsContentProvider) getContentProvider()).isShowInheritedMethods();
 	}

 	/**
 	 * Returns <code>true</code> if defining types are shown.
 	 */
 	public boolean isShowDefiningTypes() {
 		return fLabelProvider.isShowDefiningType();
 	}

 	/**
 	 * Saves the state of the filter actions
 	 */
 	public void saveState(IMemento memento) {
 		fMemberFilterActionGroup.saveState(memento);

 		memento.putString(TAG_SHOWINHERITED, String.valueOf(isShowInheritedMethods()));
 		memento.putString(TAG_SORTBYDEFININGTYPE, String.valueOf(isShowDefiningTypes()));

 		ScrollBar bar= getTable().getVerticalBar();
 		int position= bar != null ? bar.getSelection() : 0;
 		memento.putString(TAG_VERTICAL_SCROLL, String.valueOf(position));
 	}

 	/**
 	 * Restores the state of the filter actions
 	 */
 	public void restoreState(IMemento memento) {
 		fMemberFilterActionGroup.restoreState(memento);
 		getControl().setRedraw(false);
 		refresh();
 		getControl().setRedraw(true);

 		boolean showInherited= Boolean.valueOf(memento.getString(TAG_SHOWINHERITED)).booleanValue();
 		showInheritedMethods(showInherited);

 		boolean showDefiningTypes= Boolean.valueOf(memento.getString(TAG_SORTBYDEFININGTYPE)).booleanValue();
 		sortByDefiningType(showDefiningTypes);

 		ScrollBar bar= getTable().getVerticalBar();
 		if (bar != null) {
 			Integer vScroll= memento.getInteger(TAG_VERTICAL_SCROLL);
 			if (vScroll != null) {
 				bar.setSelection(vScroll.intValue());
 			}
 		}
 	}

 	/**
 	 * Attaches a contextmenu listener to the table
 	 */
 	public void initContextMenu(IMenuListener menuListener, String popupId, IWorkbenchPartSite viewSite) {
 		MenuManager menuMgr= new MenuManager();
 		menuMgr.setRemoveAllWhenShown(true);
 		menuMgr.addMenuListener(menuListener);
 		Menu menu= menuMgr.createContextMenu(getTable());
 		getTable().setMenu(menu);
 		viewSite.registerContextMenu(popupId, menuMgr, this);
 	}


 	/**
 	 * Fills up the context menu with items for the method viewer
 	 * Should be called by the creator of the context menu
 	 */
 	public void contributeToContextMenu(IMenuManager menu) {
 	}

 	/**
 	 * Fills up the tool bar with items for the method viewer
 	 * Should be called by the creator of the tool bar
 	 */
 	public void contributeToToolBar(ToolBarManager tbm) {
 		tbm.add(fShowInheritedMembersAction);
 		tbm.add(fSortByDefiningTypeAction);
 		tbm.add(new Separator());
 		fMemberFilterActionGroup.contributeToToolBar(tbm);
 	}

 	public void dispose() {
 		if (fMemberFilterActionGroup != null) {
 			fMemberFilterActionGroup.dispose();
 			fMemberFilterActionGroup= null;
 		}
 	}

 	/*
 	 * @see StructuredViewer#handleInvalidSelection(ISelection, ISelection)
 	 */
 	protected void handleInvalidSelection(ISelection invalidSelection, ISelection newSelection) {
 		// on change of input, try to keep selected methods stable by selecting a method with the same
 		// signature: See #5466
 		List oldSelections= SelectionUtil.toList(invalidSelection);
 		List newSelections= SelectionUtil.toList(newSelection);
 		if (!oldSelections.isEmpty()) {
 			ArrayList newSelectionElements= new ArrayList(newSelections);
 			try {
 				Object[] currElements= getFilteredChildren(getInput());
 				for (int i= 0; i < oldSelections.size(); i++) {
 					Object curr= oldSelections.get(i);
 					if (curr instanceof IMethod && !newSelections.contains(curr)) {
 						IMethod method= (IMethod) curr;
 						if (method.exists()) {
 							IMethod similar= findSimilarMethod(method, currElements);
 							if (similar != null) {
 								newSelectionElements.add(similar);
 							}
 						}
 					}
 				}
 				if (!newSelectionElements.isEmpty()) {
 					newSelection= new StructuredSelection(newSelectionElements);
 				} else if (currElements.length > 0) {
 					newSelection= new StructuredSelection(currElements[0]);
 				}
 			} catch (JavaModelException e) {
 				JavaPlugin.log(e);
 			}
 		}
 		setSelection(newSelection);
 		updateSelection(newSelection);
 	}

 	private IMethod findSimilarMethod(IMethod meth, Object[] elements) throws JavaModelException {
 		String name= meth.getElementName();
 		String[] paramTypes= meth.getParameterTypes();
 		boolean isConstructor= meth.isConstructor();

 		for (int i= 0; i < elements.length; i++) {
 			Object curr= elements[i];
 			if (curr instanceof IMethod && JavaModelUtil.isSameMethodSignature(name, paramTypes, isConstructor, (IMethod) curr)) {
 				return (IMethod) curr;
 			}
 		}
 		return null;
 	}


 }
	/*******************************************************************************
	* Copyright (c) 2000, 2005 IBM Corporation and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	*******************************************************************************/
	package org.eclipse.jdt.internal.ui.typehierarchy;

	import java.util.ArrayList;
	import java.util.List;

	import org.eclipse.swt.SWT;
	import org.eclipse.swt.widgets.Composite;
	import org.eclipse.swt.widgets.Menu;
	import org.eclipse.swt.widgets.ScrollBar;
	import org.eclipse.swt.widgets.Table;

	import org.eclipse.jface.action.IMenuListener;
	import org.eclipse.jface.action.IMenuManager;
	import org.eclipse.jface.action.MenuManager;
	import org.eclipse.jface.action.Separator;
	import org.eclipse.jface.action.ToolBarManager;
	import org.eclipse.jface.viewers.IOpenListener;
	import org.eclipse.jface.viewers.ISelection;
	import org.eclipse.jface.viewers.OpenEvent;
	import org.eclipse.jface.viewers.StructuredSelection;

	import org.eclipse.ui.IMemento;
	import org.eclipse.ui.IWorkbenchPart;
	import org.eclipse.ui.IWorkbenchPartSite;

	import org.eclipse.jdt.core.IMethod;
	import org.eclipse.jdt.core.JavaModelException;

	import org.eclipse.jdt.internal.corext.util.JavaModelUtil;

	import org.eclipse.jdt.ui.JavaElementLabels;
	import org.eclipse.jdt.ui.actions.MemberFilterActionGroup;
	import org.eclipse.jdt.ui.actions.OpenAction;

	import org.eclipse.jdt.internal.ui.IJavaHelpContextIds;
	import org.eclipse.jdt.internal.ui.JavaPlugin;
	import org.eclipse.jdt.internal.ui.filters.SyntheticMembersFilter;
	import org.eclipse.jdt.internal.ui.util.JavaUIHelp;
	import org.eclipse.jdt.internal.ui.util.SelectionUtil;
	import org.eclipse.jdt.internal.ui.viewsupport.DecoratingJavaLabelProvider;
	import org.eclipse.jdt.internal.ui.viewsupport.ProblemTableViewer;

	/**
	* Method viewer shows a list of methods of a input type.
	* Offers filter actions.
	* No dependency to the type hierarchy view
	*/
	public class MethodsViewer extends ProblemTableViewer {

	private static final String TAG_SHOWINHERITED= "showinherited"; //$NON-NLS-1$
	private static final String TAG_SORTBYDEFININGTYPE= "sortbydefiningtype"; //$NON-NLS-1$
	private static final String TAG_VERTICAL_SCROLL= "mv_vertical_scroll"; //$NON-NLS-1$

	private MethodsLabelProvider fLabelProvider;

	private MemberFilterActionGroup fMemberFilterActionGroup;

	private OpenAction fOpen;
	private ShowInheritedMembersAction fShowInheritedMembersAction;
	private SortByDefiningTypeAction fSortByDefiningTypeAction;

	public MethodsViewer(Composite parent, final TypeHierarchyLifeCycle lifeCycle, IWorkbenchPart part) {
	super(new Table(parent, SWT.MULTI));

	addFilter(new SyntheticMembersFilter());

	fLabelProvider= new MethodsLabelProvider(lifeCycle, this);

	setLabelProvider(new DecoratingJavaLabelProvider(fLabelProvider, true));
	setContentProvider(new MethodsContentProvider(lifeCycle));

	HierarchyViewerSorter sorter= new HierarchyViewerSorter(lifeCycle);
	sorter.setSortByDefiningType(false);
	setSorter(sorter);

	fOpen= new OpenAction(part.getSite());
	addOpenListener(new IOpenListener() {
	public void open(OpenEvent event) {
	fOpen.run();
	}
	});

	fMemberFilterActionGroup= new MemberFilterActionGroup(this, "HierarchyMethodView", false, MemberFilterActionGroup.ALL_FILTERS & ~MemberFilterActionGroup.FILTER_LOCALTYPES); //$NON-NLS-1$

	fShowInheritedMembersAction= new ShowInheritedMembersAction(this, false);
	fSortByDefiningTypeAction= new SortByDefiningTypeAction(this, false);

	showInheritedMethodsNoRedraw(false);
	sortByDefiningTypeNoRedraw(false);

	JavaUIHelp.setHelp(this, IJavaHelpContextIds.TYPE_HIERARCHY_VIEW);
	}

	private void showInheritedMethodsNoRedraw(boolean on) {
	MethodsContentProvider cprovider= (MethodsContentProvider) getContentProvider();
	cprovider.showInheritedMethods(on);
	fShowInheritedMembersAction.setChecked(on);
	if (on) {
	fLabelProvider.setTextFlags(fLabelProvider.getTextFlags() \| JavaElementLabels.ALL_POST_QUALIFIED);
	} else {
	fLabelProvider.setTextFlags(fLabelProvider.getTextFlags() & ~JavaElementLabels.ALL_POST_QUALIFIED);
	}
	if (on) {
	sortByDefiningTypeNoRedraw(false);
	}
	fSortByDefiningTypeAction.setEnabled(!on);

	}

	/**
	* Show inherited methods
	*/
	public void showInheritedMethods(boolean on) {
	if (on == isShowInheritedMethods()) {
	return;
	}
	try {
	getTable().setRedraw(false);
	showInheritedMethodsNoRedraw(on);
	refresh();
	} finally {
	getTable().setRedraw(true);
	}
	}

	private void sortByDefiningTypeNoRedraw(boolean on) {
	fSortByDefiningTypeAction.setChecked(on);
	fLabelProvider.setShowDefiningType(on);
	((HierarchyViewerSorter) getSorter()).setSortByDefiningType(on);
	}

	/**
	* Show the name of the defining type
	*/
	public void sortByDefiningType(boolean on) {
	if (on == isShowDefiningTypes()) {
	return;
	}
	try {
	getTable().setRedraw(false);
	sortByDefiningTypeNoRedraw(on);
	refresh();
	} finally {
	getTable().setRedraw(true);
	}
	}

	/*
	* @see Viewer#inputChanged(Object, Object)
	*/
	protected void inputChanged(Object input, Object oldInput) {
	super.inputChanged(input, oldInput);
	}

	/**
	* Returns <code>true</code> if inherited methods are shown.
	*/
	public boolean isShowInheritedMethods() {
	return ((MethodsContentProvider) getContentProvider()).isShowInheritedMethods();
	}

	/**
	* Returns <code>true</code> if defining types are shown.
	*/
	public boolean isShowDefiningTypes() {
	return fLabelProvider.isShowDefiningType();
	}

	/**
	* Saves the state of the filter actions
	*/
	public void saveState(IMemento memento) {
	fMemberFilterActionGroup.saveState(memento);

	memento.putString(TAG_SHOWINHERITED, String.valueOf(isShowInheritedMethods()));
	memento.putString(TAG_SORTBYDEFININGTYPE, String.valueOf(isShowDefiningTypes()));

	ScrollBar bar= getTable().getVerticalBar();
	int position= bar != null ? bar.getSelection() : 0;
	memento.putString(TAG_VERTICAL_SCROLL, String.valueOf(position));
	}

	/**
	* Restores the state of the filter actions
	*/
	public void restoreState(IMemento memento) {
	fMemberFilterActionGroup.restoreState(memento);
	getControl().setRedraw(false);
	refresh();
	getControl().setRedraw(true);

	boolean showInherited= Boolean.valueOf(memento.getString(TAG_SHOWINHERITED)).booleanValue();
	showInheritedMethods(showInherited);

	boolean showDefiningTypes= Boolean.valueOf(memento.getString(TAG_SORTBYDEFININGTYPE)).booleanValue();
	sortByDefiningType(showDefiningTypes);

	ScrollBar bar= getTable().getVerticalBar();
	if (bar != null) {
	Integer vScroll= memento.getInteger(TAG_VERTICAL_SCROLL);
	if (vScroll != null) {
	bar.setSelection(vScroll.intValue());
	}
	}
	}

	/**
	* Attaches a contextmenu listener to the table
	*/
	public void initContextMenu(IMenuListener menuListener, String popupId, IWorkbenchPartSite viewSite) {
	MenuManager menuMgr= new MenuManager();
	menuMgr.setRemoveAllWhenShown(true);
	menuMgr.addMenuListener(menuListener);
	Menu menu= menuMgr.createContextMenu(getTable());
	getTable().setMenu(menu);
	viewSite.registerContextMenu(popupId, menuMgr, this);
	}


	/**
	* Fills up the context menu with items for the method viewer
	* Should be called by the creator of the context menu
	*/
	public void contributeToContextMenu(IMenuManager menu) {
	}

	/**
	* Fills up the tool bar with items for the method viewer
	* Should be called by the creator of the tool bar
	*/
	public void contributeToToolBar(ToolBarManager tbm) {
	tbm.add(fShowInheritedMembersAction);
	tbm.add(fSortByDefiningTypeAction);
	tbm.add(new Separator());
	fMemberFilterActionGroup.contributeToToolBar(tbm);
	}

	public void dispose() {
	if (fMemberFilterActionGroup != null) {
	fMemberFilterActionGroup.dispose();
	fMemberFilterActionGroup= null;
	}
	}

	/*
	* @see StructuredViewer#handleInvalidSelection(ISelection, ISelection)
	*/
	protected void handleInvalidSelection(ISelection invalidSelection, ISelection newSelection) {
	// on change of input, try to keep selected methods stable by selecting a method with the same
	// signature: See #5466
	List oldSelections= SelectionUtil.toList(invalidSelection);
	List newSelections= SelectionUtil.toList(newSelection);
	if (!oldSelections.isEmpty()) {
	ArrayList newSelectionElements= new ArrayList(newSelections);
	try {
	Object[] currElements= getFilteredChildren(getInput());
	for (int i= 0; i < oldSelections.size(); i++) {
	Object curr= oldSelections.get(i);
	if (curr instanceof IMethod && !newSelections.contains(curr)) {
	IMethod method= (IMethod) curr;
	if (method.exists()) {
	IMethod similar= findSimilarMethod(method, currElements);
	if (similar != null) {
	newSelectionElements.add(similar);
	}
	}
	}
	}
	if (!newSelectionElements.isEmpty()) {
	newSelection= new StructuredSelection(newSelectionElements);
	} else if (currElements.length > 0) {
	newSelection= new StructuredSelection(currElements[0]);
	}
	} catch (JavaModelException e) {
	JavaPlugin.log(e);
	}
	}
	setSelection(newSelection);
	updateSelection(newSelection);
	}

	private IMethod findSimilarMethod(IMethod meth, Object[] elements) throws JavaModelException {
	String name= meth.getElementName();
	String[] paramTypes= meth.getParameterTypes();
	boolean isConstructor= meth.isConstructor();

	for (int i= 0; i < elements.length; i++) {
	Object curr= elements[i];
	if (curr instanceof IMethod && JavaModelUtil.isSameMethodSignature(name, paramTypes, isConstructor, (IMethod) curr)) {
	return (IMethod) curr;
	}
	}
	return null;
	}



	}