import java.util.HashMap;

import java.util.Map;

import org.eclipse.jface.window.Window;

import org.eclipse.ui.dialogs.ElementListSelectionDialog;

import org.eclipse.jdt.core.Flags;

import org.eclipse.jdt.core.IMethod;

import org.eclipse.jdt.core.IType;

import org.eclipse.jdt.core.ITypeHierarchy;

import org.eclipse.jdt.ui.JavaElementLabelProvider;

			try {		

				switch(element.getElementType()) {

					case IJavaElement.METHOD :

						// Check parent is interface

						if(element.getParent().getElementType() == IJavaElement.TYPE && 

								((IType) element.getParent()).isInterface()) {

							// Grab method & interface

							IMethod method = (IMethod) element;

							IType iface = (IType) element.getParent();

							// Create hierarchy & map to store implementing types

							ITypeHierarchy hierarchy = iface.newTypeHierarchy(null); 

							Map impTypes = new HashMap();

							// Get *all* sub types

							IType[] subTypes = hierarchy.getAllSubtypes(iface);

							for (int i = 0; i < subTypes.length; i++) {

								// Attempt to get method (TODO: Is this utility method accurate enough?)

								IMethod currentMethod = JavaModelUtil.findMethod(method.getElementName(), 

										method.getParameterTypes(), 

										false, 

										subTypes[i]);							

								// Additionally, check the return types are the same...

								if(currentMethod != null && 

										currentMethod.getReturnType().equals(method.getReturnType())) {

									// Check it's not been overriden in a sub interface or 

									// redeclared as abstract somewhere

									if(!subTypes[i].isInterface() &&

											!Flags.isAbstract(currentMethod.getFlags()) &&

											!impTypes.containsKey(subTypes[i])) {

										impTypes.put(subTypes[i], currentMethod);

									}

								}

							}

							// Prompt user for choice

							IType[] types = (IType[]) impTypes.keySet().toArray(new IType[impTypes.size()-1]);

							IType selectedImpl = selectImplementingType(types, method.getElementName());

							// Set type to open

							if(selectedImpl != null) {

								element = (IJavaElement) impTypes.get(selectedImpl);

							}							

						}						

						break;

					case IJavaElement.TYPE :

						// Check its an interface

						if(((IType) element).isInterface()) {

							IType iface = (IType) element;

							// Create hierarchy & list for implementing classes

							ITypeHierarchy hierarchy = iface.newTypeHierarchy(null); // TODO : Should use ProgressMonitor

							List implTypes = new ArrayList();

							// Add only direct subtypes which are classes (no extending interfaces)

							IType[] subTypes = hierarchy.getSubtypes(iface);

							for (int i= 0; i < subTypes.length; i++) {

								if(subTypes[i].isClass()) {

									implTypes.add(subTypes[i]);

								}

							}

							// Prompt user for selection

							IType[] types = (IType[]) implTypes.toArray(new IType[implTypes.size()-1]);

							IType selectedImpl = selectImplementingType(types,

									iface.getElementName());

							// Set type to open

							if(selectedImpl != null) {

								element = selectedImpl;

							}

						}

						break;

				}

			} catch(JavaModelException jme) { /*...*/ }

	private IType selectImplementingType(IType[] types, String elementName) {

		// Check basic

		if(types.length == 0) return null;		

		if(types.length == 1) return types[0];

		// Prompt user to choose

		int flags = JavaElementLabelProvider.SHOW_DEFAULT | JavaElementLabelProvider.SHOW_POST_QUALIFIED;

		ElementListSelectionDialog dialog= new ElementListSelectionDialog(fEditor.getSite().getShell(), 

				new JavaElementLabelProvider(flags));

		dialog.setTitle("Open Implementation"); //$NON-NLS-1$

		dialog.setMessage("Choose an implementation of: " + elementName); //$NON-NLS-1$

		dialog.setElements(types);

		// Prompt user to select type						

		if (dialog.open() == Window.OK) {

			return (IType) dialog.getFirstResult();

		}

		return null;

	}