Attachment #151933 for bug #276466

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




	 * constructors in the Call Hierarchy.
	 * <p>
	 * Value is of type <code>String</code>: semicolon separated list of fully qualified type names.
	 * <strong> It has been replaced in 3.6 by API:
	 * {@link PreferenceConstants#PREF_DEFAULT_EXPAND_WITH_CONSTRUCTORS_MEMBERS}</strong>
	 * </p>
	 * 
	 * @since 3.5
	 */
	public static final String OLD_PREF_DEFAULT_EXPAND_WITH_CONSTRUCTORS= "CallHierarchy.defaultExpandWithConstructors"; //$NON-NLS-1$

	/**
	 * A named preference that controls whether methods from anonymous types are by default expanded
	 * with constructors in the Call Hierarchy.
	 * <p>
	 * Value is of type <code>Boolean</code>.
	 * </p>
	 * 
	 * @since 3.5
	 */
	public static final String PREF_ANONYMOUS_EXPAND_WITH_CONSTRUCTORS= "CallHierarchy.anonymousExpandWithConstructors"; //$NON-NLS-1$

	private final static Object[] EMPTY_ARRAY= new Object[0];



		if (!wrapper.isExpandWithConstructorsSet()) {
			if (CallHierarchyContentProvider.canExpandWithConstructors(wrapper)) {
				IMethod method= (IMethod)wrapper.getMember();
				IType type= method.getDeclaringType();
				try {
					boolean withConstructors= false;
					if (type != null) {
						boolean anonymousPref= PreferenceConstants.getPreferenceStore().getBoolean(PreferenceConstants.PREF_ANONYMOUS_EXPAND_WITH_CONSTRUCTORS);
						if (anonymousPref && type.isAnonymous()) {
							withConstructors= true;
						} else if (isInTheDefaultExpandWithConstructorList(method)) {
							withConstructors= true;
						}
					}

	}
	
	/**
	 * Checks if the method or its declaring type matches the pre-defined array of methods and types
	 * for default expand with constructors.
	 * 
	 * @param method the wrapped method
	 * @return <code>true</code> if method or type matches the pre-defined list, <code>false</code>
	 *         otherwise
	 * 
	 * @param type the declaring type of the caller method wrapper
	 * @return <code>true</code> if type matches the pre-defined list, <code>false</code> otherwise
	 * @since 3.5
	 */
	static boolean isInTheDefaultExpandWithConstructorList(IMethod method) {
		String serializedMembers= PreferenceConstants.getPreferenceStore().getString(PreferenceConstants.PREF_DEFAULT_EXPAND_WITH_CONSTRUCTORS_MEMBERS);
		if (serializedMembers.length() == 0)
			return false;
		String methodName= method.getElementName();
		IType declaringType= method.getDeclaringType();
		String[] defaultMemberNames= serializedMembers.split(";"); //$NON-NLS-1$

		String declaringTypeName= declaringType.getFullyQualifiedName('.') + ".*"; //$NON-NLS-1$;
		String qualifiedMethodName= declaringType.getFullyQualifiedName('.') + '.' + methodName;
		String superClassName;
		String[] superInterfaceNames;
		try {
			superClassName= declaringType.getSuperclassName();
			if (superClassName != null) {
				if (superClassName.contains("<")) { //$NON-NLS-1$
					superClassName= stripParametersFromSuperType(superClassName);
				}
			}
			superInterfaceNames= declaringType.getSuperInterfaceNames();
		} catch (JavaModelException e) {
			return false;
		}
		for (int i= 0; i < defaultMemberNames.length; i++) {
			String defaultMemberName= defaultMemberNames[i];
			if (qualifiedMethodName.equals(defaultMemberName) || declaringTypeName.equals(defaultMemberName) || checkSuperTypeMatch(superClassName, defaultMemberName)
					|| (checkMethodInSuperType(methodName, superClassName, defaultMemberName))) {
				return true;
			}
			if (superInterfaceNames.length > 0) {
				for (int j= 0; j < superInterfaceNames.length; j++) {
					if (superInterfaceNames[j].contains("<")) { //$NON-NLS-1$
						superInterfaceNames[j]= stripParametersFromSuperType(superInterfaceNames[j]);
					}
					if (checkSuperTypeMatch(superInterfaceNames[j], defaultMemberName) || checkMethodInSuperType(methodName, superInterfaceNames[j], defaultMemberName))
						return true;
				}
			}

	}

	/**
	 * Strips parameters from the given super type name and returns the substring containing only
	 * the type name.
	 * 
	 * @param superTypeName the super type name
	 * @return the substring containing only the type name without the parameters
	 * 
	 * @since 3.6
	 */
	private static String stripParametersFromSuperType(String superTypeName) {
		int pos= superTypeName.indexOf('<');//strip the parameters
		return superTypeName.substring(0, pos);
	}

	/**
	 * Check if the method in the super type matches the default member.
	 * 
	 * @param methodName the method name
	 * @param superTypeName the super type name
	 * @param defaultMemberName the member in the default list
	 * 
	 * @return <code>true</code> if the method in the super type matches the default member,
	 *         <code>false</code> otherwise
	 * 
	 * @since 3.6
	 */
	private static boolean checkMethodInSuperType(String methodName, String superTypeName, String defaultMemberName) {
		if (superTypeName != null && typeNameMatches(methodName, defaultMemberName)) {
			int pos= defaultMemberName.lastIndexOf('.');
			String defaultTypeName= defaultMemberName.substring(0, pos);
			return typeNameMatches(superTypeName, defaultTypeName);
		}
		return false;
	}

	/**
	 * Check whether the given super type name matches the given default type.
	 * 
	 * @param superType the super type name
	 * @param defaultMemberName the default member from the default list
	 * 
	 * @return <code>true</code> if super type matches with the given type in the default list,
	 *         <code>false></code> otherwise
	 * 
	 * @since 3.6
	 */
	private static boolean checkSuperTypeMatch(String superType, String defaultMemberName) {
		if (defaultMemberName.endsWith(".*")) { //$NON-NLS-1$
			defaultMemberName= defaultMemberName.substring(0, defaultMemberName.length() - 2);
		}
		return (superType != null && typeNameMatches(superType, defaultMemberName));
	}

	/**
	 * Checks whether the two type names match. They match if they
	 * are equal, or if could be the same type but one is missing the package.
	 * 




	public static String CallHierarchyViewPart_callsFromMembers_3;
	public static String CallHierarchyViewPart_callsFromMembers_more;
	public static String CallHierarchyViewPart_callsFromMethod;
	public static String ExpandWithConstructorsConfigurationBlock_description;
	public static String ExpandWithConstructorsConfigurationBlock_newType_button;
	public static String ExpandWithConstructorsConfigurationBlock_newMember_button;
	public static String ExpandWithConstructorsConfigurationBlock_edit_button;
	public static String ExpandWithConstructorsConfigurationBlock_remove_button;
	public static String ExpandWithConstructorsConfigurationBlock_restoreDefaults_button;
	public static String CallHierarchyTypesOrMembersDialog_member_title;
	public static String CallHierarchyTypesOrMembersDialog_member_labelText;
	public static String CallHierarchyTypesOrMembersDialog_type_title;
	public static String CallHierarchyTypesOrMembersDialog_type_labelText;
	public static String CallHierarchyTypesOrMembersDialog_browse_button;
	public static String CallHierarchyTypesOrMembersDialog_ChooseTypeDialog_title;
	public static String CallHierarchyTypesOrMembersDialog_ChooseTypeDialog_description;
	public static String CallHierarchyTypesOrMembersDialog_ChooseTypeDialog_error_message;
	public static String CallHierarchyTypesOrMembersDialog_error_enterName;
	public static String CallHierarchyTypesOrMembersDialog_error_invalidMemberName;
	public static String CallHierarchyTypesOrMembersDialog_error_invalidTypeName;
	public static String CallHierarchyTypesOrMembersDialog_error_entryExists;
	public static String CallHierarchyTypesOrMembersDialog_anonymousTypes_label;
	public static String FocusOnSelectionAction_focusOnSelection_text;
	public static String FocusOnSelectionAction_focusOnSelection_description;
	public static String FocusOnSelectionAction_focusOnSelection_tooltip;

	public static String ExpandWithConstructorsAction_expandWithConstructors_text;
	public static String ExpandWithConstructorsAction_expandWithConstructors_description;
	public static String ExpandWithConstructorsAction_expandWithConstructors_tooltip;
	public static String ExpandWithConstructorsDialog_anonymousTypes_label;
	public static String ExpandWithConstructorsDialog_explanation_label;
	public static String ExpandWithConstructorsDialog_not_a_valid_type_name;
	public static String ExpandWithConstructorsDialog_title;
	public static String ExpandWithConstructorsDialog_typeNames_label;
	static {
		NLS.initializeMessages(BUNDLE_NAME, CallHierarchyMessages.class);
	}




ExpandWithConstructorsAction_expandWithConstructors_text= &Expand with Constructors
ExpandWithConstructorsAction_expandWithConstructors_description= Expand with constructors
ExpandWithConstructorsAction_expandWithConstructors_tooltip= Expand with Constructors
ExpandWithConstructorsDialog_title= Expand with Constructors

ExpandWithConstructorsConfigurationBlock_description= De&fine a list of members or types with their fully qualified names. The call hierarchy for these members or members of the types will be expanded with constructors by default.
ExpandWithConstructorsConfigurationBlock_newType_button= New &Type...
ExpandWithConstructorsConfigurationBlock_newMember_button= New &Member...
ExpandWithConstructorsConfigurationBlock_edit_button= &Edit...
ExpandWithConstructorsConfigurationBlock_remove_button= &Remove 
ExpandWithConstructorsConfigurationBlock_restoreDefaults_button= Restore &Defaults

CallHierarchyTypesOrMembersDialog_member_title= New Member for Expand With Constructors
CallHierarchyTypesOrMembersDialog_member_labelText= Enter a fully qualified non-static, non-constructor member (e.g. \'java.lang.Runnable.run\'): 
CallHierarchyTypesOrMembersDialog_type_title= New Type for Expand With Constructors
CallHierarchyTypesOrMembersDialog_type_labelText= Enter a fully qualified type (e.g. \'java.lang.Runnable\'):
CallHierarchyTypesOrMembersDialog_browse_button= &Browse...
CallHierarchyTypesOrMembersDialog_ChooseTypeDialog_title= Type Selection
CallHierarchyTypesOrMembersDialog_ChooseTypeDialog_description= Choose type name:
CallHierarchyTypesOrMembersDialog_ChooseTypeDialog_error_message= A problem occurred while collecting types. See the error Log for details.
CallHierarchyTypesOrMembersDialog_error_enterName=Enter a name or prefix.
CallHierarchyTypesOrMembersDialog_error_invalidTypeName=Not a valid type name.
CallHierarchyTypesOrMembersDialog_error_invalidMemberName=Not a valid member name.
CallHierarchyTypesOrMembersDialog_error_entryExists=Entry already exists in list.
CallHierarchyTypesOrMembersDialog_anonymousTypes_label=&All methods in anonymous types





/*******************************************************************************
 * Copyright (c) 2009 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
 *
 *******************************************************************************/

package org.eclipse.jdt.internal.ui.callhierarchy;

import java.util.Arrays;
import java.util.List;

import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;

import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.IStatus;

import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.dialogs.StatusDialog;
import org.eclipse.jface.layout.PixelConverter;
import org.eclipse.jface.operation.IRunnableContext;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.ViewerComparator;
import org.eclipse.jface.window.Window;

import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.dialogs.SelectionDialog;
import org.eclipse.ui.preferences.IWorkbenchPreferenceContainer;

import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaConventions;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.search.IJavaSearchScope;
import org.eclipse.jdt.core.search.SearchEngine;

import org.eclipse.jdt.ui.IJavaElementSearchConstants;
import org.eclipse.jdt.ui.JavaUI;
import org.eclipse.jdt.ui.PreferenceConstants;

import org.eclipse.jdt.internal.ui.IJavaHelpContextIds;
import org.eclipse.jdt.internal.ui.JavaPluginImages;
import org.eclipse.jdt.internal.ui.dialogs.StatusInfo;
import org.eclipse.jdt.internal.ui.dialogs.TextFieldNavigationHandler;
import org.eclipse.jdt.internal.ui.preferences.OptionsConfigurationBlock;
import org.eclipse.jdt.internal.ui.util.BusyIndicatorRunnableContext;
import org.eclipse.jdt.internal.ui.util.ExceptionHandler;
import org.eclipse.jdt.internal.ui.viewsupport.BasicElementLabels;
import org.eclipse.jdt.internal.ui.viewsupport.JavaElementImageProvider;
import org.eclipse.jdt.internal.ui.wizards.IStatusChangeListener;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.DialogField;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.IDialogFieldListener;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.IListAdapter;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.IStringButtonAdapter;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.LayoutUtil;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.ListDialogField;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.StringButtonDialogField;

/**
 * Call hierarchy expand with constructors configuration block.
 *
 * @since 3.6
 */
public class ExpandWithConstructorsConfigurationBlock extends OptionsConfigurationBlock {

	/**
	 * Call hierarchy expand with constructors dialog for types and members.
	 */
	private static class CallHierarchyTypesOrMembersDialog extends StatusDialog {

		/**
		 * The change listener class for the dialog field and the string button dialog field.
		 *
		 */
		private class StringButtonAdapter implements IDialogFieldListener, IStringButtonAdapter {
			/*
			 * @see IDialogFieldListener#dialogFieldChanged(DialogField)
			 */
			public void dialogFieldChanged(DialogField field) {
				doValidation();
			}

			/*
			 * @see IStringButtonAdapter#changeControlPressed(DialogField)
			 */
			public void changeControlPressed(DialogField field) {
				doBrowseTypes();
			}
		}

		/**
		 * The name dialog field to hold the default expand with constructors list.
		 */
		private StringButtonDialogField fNameDialogField;

		/**
		 * The list of previously existing entries.
		 */
		private List fExistingEntries;

		/**
		 * Tells whether it is an member or type.
		 */
		private final boolean fIsEditingMember;

		/**
		 * Creates a call hierarchy preference dialog for members or types.
		 *
		 * @param parent the parent shell
		 * @param existingEntries the existing list of types and members
		 * @param isEditingMember <code>true</code if its a member, <code>false</code> otherwise
		 */
		public CallHierarchyTypesOrMembersDialog(Shell parent, List existingEntries, boolean isEditingMember) {
			super(parent);
			fIsEditingMember= isEditingMember;
			fExistingEntries= existingEntries;

			String label, title;
			if (isEditingMember) {
				title= CallHierarchyMessages.CallHierarchyTypesOrMembersDialog_member_title;
				label= CallHierarchyMessages.CallHierarchyTypesOrMembersDialog_member_labelText;
			} else {
				title= CallHierarchyMessages.CallHierarchyTypesOrMembersDialog_type_title;
				label= CallHierarchyMessages.CallHierarchyTypesOrMembersDialog_type_labelText;
			}
			setTitle(title);

			StringButtonAdapter adapter= new StringButtonAdapter();

			fNameDialogField= new StringButtonDialogField(adapter);
			fNameDialogField.setLabelText(label);
			fNameDialogField.setButtonLabel(CallHierarchyMessages.CallHierarchyTypesOrMembersDialog_browse_button);
			fNameDialogField.setDialogFieldListener(adapter);
			fNameDialogField.setText(""); //$NON-NLS-1$
		}

		/*
		 * @see org.eclipse.jface.dialogs.Dialog#isResizable()		 *
		 */
		protected boolean isResizable() {
			return true;
		}

		/**
		 * Sets the initial selection in the name dialog field.
		 *
		 * @param editedEntry the edited entry
		 */
		public void setInitialSelection(String editedEntry) {
			Assert.isNotNull(editedEntry);
			if (editedEntry.length() == 0)
				fNameDialogField.setText(""); //$NON-NLS-1$
			else
				fNameDialogField.setText(editedEntry);
		}

		/**
		 * Returns the resulting text from the name dialog field.
		 *
		 * @return the resulting text from the name dialog field
		 */
		public String getResult() {
			String val= fNameDialogField.getText();
			if (!fIsEditingMember)
				val= val + WILDCARD;
			return val;
		}

		/*
		 * @see org.eclipse.jface.dialogs.Dialog#createDialogArea(org.eclipse.swt.widgets.Composite)
		 */
		protected Control createDialogArea(Composite parent) {
			Composite composite= (Composite)super.createDialogArea(parent);
			initializeDialogUnits(composite);

			GridLayout layout= (GridLayout)composite.getLayout();
			layout.numColumns= 2;

			fNameDialogField.doFillIntoGrid(composite, 3);

			fNameDialogField.getChangeControl(null).setVisible(!fIsEditingMember);

			LayoutUtil.setHorizontalSpan(fNameDialogField.getLabelControl(null), 2);

			int fieldWidthHint= convertWidthInCharsToPixels(60);
			Text text= fNameDialogField.getTextControl(null);
			LayoutUtil.setWidthHint(text, fieldWidthHint);
			LayoutUtil.setHorizontalGrabbing(text);
			LayoutUtil.setHorizontalSpan(text, fIsEditingMember ? 2 : 1);
			TextFieldNavigationHandler.install(text);

			DialogField.createEmptySpace(composite, 1);

			fNameDialogField.postSetFocusOnDialogField(parent.getDisplay());

			applyDialogFont(composite);
			return composite;
		}

		/**
		 * Creates the type hierarchy for type selection.
		 */
		private void doBrowseTypes() {
			IRunnableContext context= new BusyIndicatorRunnableContext();
			IJavaSearchScope scope= SearchEngine.createWorkspaceScope();
			int style= IJavaElementSearchConstants.CONSIDER_ALL_TYPES;
			try {
				SelectionDialog dialog= JavaUI.createTypeDialog(getShell(), context, scope, style, false, fNameDialogField.getText());
				dialog.setTitle(CallHierarchyMessages.CallHierarchyTypesOrMembersDialog_ChooseTypeDialog_title);
				dialog.setMessage(CallHierarchyMessages.CallHierarchyTypesOrMembersDialog_ChooseTypeDialog_description);
				if (dialog.open() == Window.OK) {
					IType res= (IType)dialog.getResult()[0];
					fNameDialogField.setText(res.getFullyQualifiedName('.'));
				}
			} catch (JavaModelException e) {
				ExceptionHandler.handle(e, getShell(), CallHierarchyMessages.CallHierarchyTypesOrMembersDialog_ChooseTypeDialog_title,
						CallHierarchyMessages.CallHierarchyTypesOrMembersDialog_ChooseTypeDialog_error_message);
			}
		}

		/**
		 * Validates the entered type or member and updates the status.
		 */
		private void doValidation() {
			StatusInfo status= new StatusInfo();
			String newText= fNameDialogField.getText();
			if (newText.length() == 0) {
				status.setError(""); //$NON-NLS-1$
			} else {
				IStatus val= JavaConventions.validateJavaTypeName(newText, JavaCore.VERSION_1_3, JavaCore.VERSION_1_3);
				if (val.matches(IStatus.ERROR)) {
					if (fIsEditingMember)
						status.setError(CallHierarchyMessages.CallHierarchyTypesOrMembersDialog_error_invalidMemberName);
					else
						status.setError(CallHierarchyMessages.CallHierarchyTypesOrMembersDialog_error_invalidTypeName);
				} else {
					if (doesExist(newText)) {
						status.setError(CallHierarchyMessages.CallHierarchyTypesOrMembersDialog_error_entryExists);
					}
				}
			}
			updateStatus(status);
		}

		/**
		 * Checks if the entry already exists.
		 *
		 * @param name the type or member name
		 * @return <code>true</code> if it already exists in the list of types and members,
		 *         <code>false</code> otherwise
		 */
		private boolean doesExist(String name) {
			for (int i= 0; i < fExistingEntries.size(); i++) {
				String entry= (String)fExistingEntries.get(i);
				if (name.equals(entry)) {
					return true;
				}
			}
			return false;
		}


		/*
		 * @see org.eclipse.jface.window.Window#configureShell(Shell)
		 */
		protected void configureShell(Shell newShell) {
			super.configureShell(newShell);
			PlatformUI.getWorkbench().getHelpSystem().setHelp(newShell, IJavaHelpContextIds.CALL_HIERARCHY_EXPAND_WITH_CONSTRUCTORS_DIALOG);
		}

	}

	/*
	 * @see org.eclipse.jdt.internal.ui.preferences.OptionsConfigurationBlock#performOk()
	 */
	public boolean performOk() {
		setValue(ANONYMOUS_EXPAND_WITH_CONSTRUCTORS, fIsAnonymous);
		return super.performOk();
	}

	/**
	 * The list label provider class.
	 */
	private static class ListLabelProvider extends LabelProvider {

		public final Image MEMBER_ICON;

		private final Image CLASS_ICON;

		/**
		 * Create the member and class icons.
		 */
		public ListLabelProvider() {
			MEMBER_ICON= JavaElementImageProvider.getDecoratedImage(JavaPluginImages.DESC_MISC_PUBLIC, 0, JavaElementImageProvider.SMALL_SIZE);
			CLASS_ICON= JavaElementImageProvider.getDecoratedImage(JavaPluginImages.DESC_OBJS_CLASS, 0, JavaElementImageProvider.SMALL_SIZE);
		}

		/*
		 * @see org.eclipse.jface.viewers.LabelProvider#getImage(java.lang.Object)
		 */
		public Image getImage(Object element) {
			return ((String)element).endsWith(WILDCARD) ? CLASS_ICON : MEMBER_ICON;
		}

		/*
		 * @see org.eclipse.jface.viewers.LabelProvider#getText(java.lang.Object)
		 */
		public String getText(Object element) {
			return BasicElementLabels.getJavaElementName((String)element);
		}
	}


	/**
	 * The change listener for <code>ListDialogField</code>.
	 */
	private class ListAdapter implements IListAdapter, IDialogFieldListener {

		/**
		 * Checks if field can be edited.
		 *
		 * @param field the list dialog field
		 * @return <code>true</code> if it can be edited, <code>false</code> otherwise
		 */
		private boolean canEdit(ListDialogField field) {
			List selected= field.getSelectedElements();
			return selected.size() == 1;
		}

		/*
		 * @see org.eclipse.jdt.internal.ui.wizards.dialogfields.IListAdapter#customButtonPressed(org.eclipse.jdt.internal.ui.wizards.dialogfields.ListDialogField, int)
		 */
		public void customButtonPressed(ListDialogField field, int index) {
			doButtonPressed(index);
		}

		/*
		 * @see org.eclipse.jdt.internal.ui.wizards.dialogfields.IListAdapter#selectionChanged(org.eclipse.jdt.internal.ui.wizards.dialogfields.ListDialogField)
		 */
		public void selectionChanged(ListDialogField field) {
			fList.enableButton(IDX_EDIT, canEdit(field));
			fList.enableButton(IDX_REMOVE, canRemove(field));
		}

		/**
		 * Checks if the field can be removed.
		 *
		 * @param field the list dialog field
		 * @return <code>true</code> if it can be removed, <code>false</code> otherwise
		 */
		private boolean canRemove(ListDialogField field) {
			List selected= field.getSelectedElements();
			return selected.size() != 0;
		}

		/* )
		 * @see org.eclipse.jdt.internal.ui.wizards.dialogfields.IDialogFieldListener#dialogFieldChanged(org.eclipse.jdt.internal.ui.wizards.dialogfields.DialogField)
		 */
		public void dialogFieldChanged(DialogField field) {
			doDialogFieldChanged(field);
		}

		/*
		 * @see org.eclipse.jdt.internal.ui.wizards.dialogfields.IListAdapter#doubleClicked(org.eclipse.jdt.internal.ui.wizards.dialogfields.ListDialogField)
		 */
		public void doubleClicked(ListDialogField field) {
			if (canEdit(field)) {
				doButtonPressed(IDX_EDIT);
			}
		}
	}

	private static final String WILDCARD= ".*"; //$NON-NLS-1$

	private static final int IDX_NEW_TYPE= 0;
	private static final int IDX_NEW_MEMBER= 1;
	private static final int IDX_EDIT= 2;
	private static final int IDX_REMOVE= 3;
	private static final int IDX_RESTORE_DEFAULTS= 4;

	private ListDialogField fList;

	private Button fAnonymousButton;

	protected boolean fIsAnonymous;

	/**
	 * A key that holds the list of methods or types whose methods are by default expanded with constructors in the Call Hierarchy.
	 */
	private static Key DEFAULT_EXPAND_WITH_CONSTRUCTORS_MEMBERS= getJDTUIKey(PreferenceConstants.PREF_DEFAULT_EXPAND_WITH_CONSTRUCTORS_MEMBERS);

	/**
	 * A key that controls whether the methods from anonymous types are by default expanded with constructors in the Call Hierarchy.
	 */
	private static Key ANONYMOUS_EXPAND_WITH_CONSTRUCTORS= getJDTUIKey(PreferenceConstants.PREF_ANONYMOUS_EXPAND_WITH_CONSTRUCTORS);

	/**
	 * Returns all the key values.
	 *
	 * @return array of keys
	 */
	public static Key[] getAllKeys() {
		return new Key[] { DEFAULT_EXPAND_WITH_CONSTRUCTORS_MEMBERS, ANONYMOUS_EXPAND_WITH_CONSTRUCTORS };
	}


	/**
	 * Creates the call hierarchy preferences configuration block.
	 *
	 * @param context the status
	 * @param container the preference container
	 */
	public ExpandWithConstructorsConfigurationBlock(IStatusChangeListener context, IWorkbenchPreferenceContainer container) {
		super(context, null, getAllKeys(), container);
	}

	/*
	 * @see org.eclipse.jdt.internal.ui.preferences.OptionsConfigurationBlock#createContents(org.eclipse.swt.widgets.Composite)
	 */
	protected Control createContents(Composite parent) {
		Composite control= new Composite(parent, SWT.NONE);
		GridLayout layout= new GridLayout();
		layout.numColumns= 2;
		layout.marginWidth= 10;
		layout.marginHeight= 10;
		control.setLayout(layout);

		createPreferenceList(control);

		fAnonymousButton= new Button(control, SWT.CHECK);
		fAnonymousButton.setText(CallHierarchyMessages.CallHierarchyTypesOrMembersDialog_anonymousTypes_label);
		fIsAnonymous= getBooleanValue(ANONYMOUS_EXPAND_WITH_CONSTRUCTORS);
		fAnonymousButton.setSelection(fIsAnonymous);
		fAnonymousButton.setLayoutData(new GridData(SWT.LEAD, SWT.TOP, false, false));
		fAnonymousButton.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				fIsAnonymous= fAnonymousButton.getSelection();
			}

		});

		initialize();

		Dialog.applyDialogFont(control);

		return control;
	}

	/**
	 * Create a list dialog field.
	 *
	 * @param parent the composite
	 */
	private void createPreferenceList(Composite parent) {
		String[] buttonLabels= new String[] {
				CallHierarchyMessages.ExpandWithConstructorsConfigurationBlock_newType_button,
				CallHierarchyMessages.ExpandWithConstructorsConfigurationBlock_newMember_button,
				CallHierarchyMessages.ExpandWithConstructorsConfigurationBlock_edit_button,
				CallHierarchyMessages.ExpandWithConstructorsConfigurationBlock_remove_button,
				CallHierarchyMessages.ExpandWithConstructorsConfigurationBlock_restoreDefaults_button
		};

		ListAdapter adapter= new ListAdapter();

		fList= new ListDialogField(adapter, buttonLabels, new ListLabelProvider());
		fList.setDialogFieldListener(adapter);
		fList.setLabelText(CallHierarchyMessages.ExpandWithConstructorsConfigurationBlock_description);
		fList.setRemoveButtonIndex(IDX_REMOVE);
		fList.enableButton(IDX_EDIT, false);
		fList.setViewerComparator(new ViewerComparator());

		PixelConverter pixelConverter= new PixelConverter(parent);

		fList.doFillIntoGrid(parent, 3);
		LayoutUtil.setHorizontalSpan(fList.getLabelControl(null), 2);
		LayoutUtil.setWidthHint(fList.getLabelControl(null), pixelConverter.convertWidthInCharsToPixels(60));
		LayoutUtil.setHorizontalGrabbing(fList.getListControl(null));

		Control listControl= fList.getListControl(null);
		GridData gd= (GridData)listControl.getLayoutData();
		gd.verticalAlignment= GridData.FILL;
		gd.grabExcessVerticalSpace= true;
		gd.heightHint= pixelConverter.convertHeightInCharsToPixels(10);
	}

	/**
	 * Initialize the elements of the list dialog field.
	 */
	public void initialize() {
		fList.setElements(Arrays.asList(getDefaultExpandWithConstructorsMembers()));
	}

	/*
	 * @see org.eclipse.jdt.internal.ui.preferences.OptionsConfigurationBlock#performDefaults()
	 */
	public void performDefaults() {
		String str= PreferenceConstants.getPreferenceStore().getDefaultString(PreferenceConstants.PREF_DEFAULT_EXPAND_WITH_CONSTRUCTORS_MEMBERS);
		fList.setElements(Arrays.asList(deserializeMembers(str)));
		fIsAnonymous= PreferenceConstants.getPreferenceStore().getDefaultBoolean(PreferenceConstants.PREF_ANONYMOUS_EXPAND_WITH_CONSTRUCTORS);
		fAnonymousButton.setSelection(fIsAnonymous);
		super.performDefaults();
	}

	/*
	 * @see org.eclipse.jdt.internal.ui.preferences.OptionsConfigurationBlock#getFullBuildDialogStrings(boolean)
	 */
	protected String[] getFullBuildDialogStrings(boolean workspaceSettings) {
		return null;
	}

	/*
	 * @see org.eclipse.jdt.internal.ui.preferences.OptionsConfigurationBlock#validateSettings(org.eclipse.jdt.internal.ui.preferences.OptionsConfigurationBlock.Key, java.lang.String, java.lang.String)
	 */
	protected void validateSettings(Key changedKey, String oldValue, String newValue) {

	}

	/**
	 * Perform the 'New' and 'Edit' button operations by opening the respective call hierarchy
	 * preferences dialog, and 'Restore Defaults' button by restoring to default values for the list dialog.
	 *
	 * @param index the index of the button
	 */
	private void doButtonPressed(int index) {
		if (index == IDX_NEW_TYPE || index == IDX_NEW_MEMBER) { // add new
			List existing= fList.getElements();
			CallHierarchyTypesOrMembersDialog dialog= new CallHierarchyTypesOrMembersDialog(getShell(), existing, index == IDX_NEW_MEMBER);
			if (dialog.open() == Window.OK) {
				fList.addElement(dialog.getResult());
			}
		} else if (index == IDX_EDIT) { // edit
			List selected= fList.getSelectedElements();
			if (selected.isEmpty())
				return;

			String editedEntry= (String)selected.get(0);

			List existing= fList.getElements();
			existing.remove(editedEntry);
			boolean isType= editedEntry.endsWith(WILDCARD);
			CallHierarchyTypesOrMembersDialog dialog= new CallHierarchyTypesOrMembersDialog(getShell(), existing, !isType);
			if (isType)
				dialog.setInitialSelection(editedEntry.substring(0, editedEntry.length() - 2));
			else
				dialog.setInitialSelection(editedEntry);

			if (dialog.open() == Window.OK) {
				fList.replaceElement(editedEntry, dialog.getResult());
			}
		} else if (index == IDX_RESTORE_DEFAULTS){
			performDefaults();
		}
	}

	/**
	 * Update the key on dialog field change.
	 *
	 * @param field the dialog field
	 */
	protected final void doDialogFieldChanged(DialogField field) {
		// set values in working copy
		if (field == fList) {
			setValue(DEFAULT_EXPAND_WITH_CONSTRUCTORS_MEMBERS, serializeMembers(fList.getElements()));
		}
	}

	/**
	 * Returns the array of strings containing the types or methods for default expand with constructors.
	 *
	 * @return the array of strings containing the types or methods for default expand with constructors
	 */
	private String[] getDefaultExpandWithConstructorsMembers() {
		String str= getValue(DEFAULT_EXPAND_WITH_CONSTRUCTORS_MEMBERS);
		if (str != null && str.length() > 0) {
			return deserializeMembers(str);
		}
		return new String[0];
	}

	/**
	 * Return the array of types and/or methods after splitting the stored preference string.
	 *
	 * @param str the input string
	 * @return the array of types and/or methods
	 */
	private static String[] deserializeMembers(String str) {
		return str.split(";"); //$NON-NLS-1$
	}

	/**
	 * Creates a single output string from the list of strings using a delimiter.
	 * 
	 * @param list the input list of types and/or methods
	 * @return the single output string from the list of strings using a delimiter
	 */
	public static String serializeMembers(List list) {
		int size= list.size();
		StringBuffer buf= new StringBuffer();
		for (int i= 0; i < size; i++) {
			buf.append((String)list.get(i));
			if (i < size - 1)
				buf.append(';');
		}
		return buf.toString();
	}

}




 *******************************************************************************/
package org.eclipse.jdt.internal.ui.callhierarchy;

import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Shell;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.dialogs.TrayDialog;

import org.eclipse.ui.PlatformUI;

import org.eclipse.jdt.core.JavaConventions;
import org.eclipse.jdt.core.JavaCore;

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

import org.eclipse.jdt.ui.PreferenceConstants;

import org.eclipse.jdt.internal.ui.IJavaHelpContextIds;
import org.eclipse.jdt.internal.ui.wizards.IStatusChangeListener;

/**
 * Configuration dialog for default "Expand with Constructors" behavior.
 * 
 * @since 3.5
 */
class ExpandWithConstructorsDialog extends TrayDialog {

	private Control fConfigurationBlockControl;
	private ExpandWithConstructorsConfigurationBlock fConfigurationBlock;

	private Button fAnonymousButton;
	private StyledText fDefaultTypesText;
	
	protected ExpandWithConstructorsDialog(Shell parentShell) {
		super(parentShell);
	}

	protected void configureShell(Shell newShell) {
		super.configureShell(newShell);
		newShell.setText(CallHierarchyMessages.ExpandWithConstructorsDialog_title);
		setHelpAvailable(false);
		PlatformUI.getWorkbench().getHelpSystem().setHelp(newShell, IJavaHelpContextIds.CALL_HIERARCHY_EXPAND_WITH_CONSTRUCTORS_DIALOG);
	}

	/*
	 * @see org.eclipse.jface.dialogs.Dialog#createDialogArea(org.eclipse.swt.widgets.Composite)
	 */
	protected Control createDialogArea(Composite composite) {
		fConfigurationBlock= new ExpandWithConstructorsConfigurationBlock(new IStatusChangeListener() {
			public void statusChanged(IStatus status) {
				//Do nothing

		descriptionLabel.setText(CallHierarchyMessages.ExpandWithConstructorsDialog_explanation_label);
		descriptionLabel.setLayoutData(new GridData(SWT.LEFT, SWT.CENTER, true, false));
		
		
		Label typesLabel= new Label(composite, SWT.WRAP);
		typesLabel.setText(CallHierarchyMessages.ExpandWithConstructorsDialog_typeNames_label);
		typesLabel.setLayoutData(new GridData(SWT.LEFT, SWT.CENTER, true, false));
		
		fDefaultTypesText= new StyledText(composite, SWT.BORDER | SWT.WRAP | SWT.H_SCROLL | SWT.V_SCROLL);
		GridData gd= new GridData(SWT.FILL, SWT.FILL, true, true);
		gd.heightHint= convertHeightInCharsToPixels(10);
		fDefaultTypesText.setLayoutData(gd);
		
		String defaultTypesPref= PreferenceConstants.getPreferenceStore().getString(CallHierarchyContentProvider.PREF_DEFAULT_EXPAND_WITH_CONSTRUCTORS);
		String defaultTypesText= defaultTypesPref.replace(';', '\n');
		fDefaultTypesText.setText(defaultTypesText);
		fDefaultTypesText.setSelection(fDefaultTypesText.getCharCount());
		
		fDefaultTypesText.addModifyListener(new ModifyListener() {
			public void modifyText(ModifyEvent e) {
				validateInput();
			}
		}, null);
		GridData data= new GridData(GridData.FILL, GridData.FILL, true, true);
		fConfigurationBlockControl= fConfigurationBlock.createContents(composite);
		fConfigurationBlockControl.setLayoutData(data);

		Dialog.applyDialogFont(composite);
		fAnonymousButton.setSelection(anonymousPref);
		fAnonymousButton.setLayoutData(new GridData(SWT.LEFT, SWT.CENTER, true, false));
		
		return composite;
	}


	 * @see org.eclipse.jface.dialogs.Dialog#okPressed()
	 */
	protected void okPressed() {
		fConfigurationBlock.performOk();
		
		String defaultTypes= fDefaultTypesText.getText().trim();
		String defaultTypesPref= defaultTypes.replaceAll(LINE_DELIMITER_REGEX, ";"); //$NON-NLS-1$
		PreferenceConstants.getPreferenceStore().setValue(CallHierarchyContentProvider.PREF_DEFAULT_EXPAND_WITH_CONSTRUCTORS, defaultTypesPref);
		
		super.okPressed();
	}

	private void validateInput() {
		StatusInfo status= new StatusInfo();
		
		String[] defaultTypes= fDefaultTypesText.getText().split(LINE_DELIMITER_REGEX);
		for (int i= 0; i < defaultTypes.length; i++) {
			String type= defaultTypes[i];
			if (type.length() == 0)
				continue;
			
			IStatus typeNameStatus= JavaConventions.validateJavaTypeName(type, JavaCore.VERSION_1_3, JavaCore.VERSION_1_3);
			if (typeNameStatus.getSeverity() == IStatus.ERROR) {
				status.setError(Messages.format(CallHierarchyMessages.ExpandWithConstructorsDialog_not_a_valid_type_name, type));
				break;
			}
		}
		
		updateStatus(status);
	}
}




 *******************************************************************************/
package org.eclipse.jdt.ui;

import java.util.Arrays;
import java.util.Locale;
import java.util.StringTokenizer;


import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.JavaUIPreferenceInitializer;
import org.eclipse.jdt.internal.ui.callhierarchy.CallHierarchyContentProvider;
import org.eclipse.jdt.internal.ui.callhierarchy.ExpandWithConstructorsConfigurationBlock;
import org.eclipse.jdt.internal.ui.javaeditor.SemanticHighlightings;
import org.eclipse.jdt.internal.ui.preferences.NewJavaProjectPreferencePage;
import org.eclipse.jdt.internal.ui.preferences.formatter.FormatterProfileManager;

	 */
	public static final String EDITOR_FOLDING_HEADERS= "editor_folding_default_headers"; //$NON-NLS-1$

	/**
	 * A named preference that holds the methods or types whose methods are by default expanded with
	 * constructors in the Call Hierarchy.
	 * <p>
	 * Value is of type <code>String</code>: semicolon separated list of fully qualified type names
	 * appended with ".*" or "." + method name.
	 * </p>
	 * 
	 * @since 3.6
	 */
	public static final String PREF_DEFAULT_EXPAND_WITH_CONSTRUCTORS_MEMBERS= "CallHierarchy.defaultExpandWithConstructorsMembers"; //$NON-NLS-1$

	/**
	 * A named preference that controls whether methods from anonymous types are by default expanded
	 * with constructors in the Call Hierarchy.
	 * <p>
	 * Value is of type <code>Boolean</code>.
	 * </p>
	 * 
	 * @since 3.6
	 */
	public static final String PREF_ANONYMOUS_EXPAND_WITH_CONSTRUCTORS= "CallHierarchy.anonymousExpandWithConstructors"; //$NON-NLS-1$


	//---------- Properties File Editor ----------



		// Colors that are set by the current theme
		JavaUIPreferenceInitializer.setThemeBasedPreferences(store, false);

		store.setDefault(PREF_ANONYMOUS_EXPAND_WITH_CONSTRUCTORS, true);
		store.setDefault(PREF_DEFAULT_EXPAND_WITH_CONSTRUCTORS_MEMBERS, "java.lang.Runnable.run;java.util.concurrent.Callable.call;org.eclipse.swt.widgets.Listener.handleEvent"); //$NON-NLS-1$
		// compatibility code
		String str= store.getString(CallHierarchyContentProvider.OLD_PREF_DEFAULT_EXPAND_WITH_CONSTRUCTORS);
		if (str.length() > 0) {
			String[] oldPrefStr= str.split(";"); //$NON-NLS-1$
			for (int i= 0; i < oldPrefStr.length; i++) {
				oldPrefStr[i]= oldPrefStr[i] + (".*"); //$NON-NLS-1$				
			}
			store.setValue(PREF_DEFAULT_EXPAND_WITH_CONSTRUCTORS_MEMBERS, ExpandWithConstructorsConfigurationBlock.serializeMembers(Arrays.asList(oldPrefStr)));
			store.setToDefault(CallHierarchyContentProvider.OLD_PREF_DEFAULT_EXPAND_WITH_CONSTRUCTORS);
		}
	}

	/**

Return to bug 276466

Lines 49-70 Link Here

(-)ui/org/eclipse/jdt/internal/ui/callhierarchy/CallHierarchyContentProvider.java (-36 / +94 lines)
49	* constructors in the Call Hierarchy.	49	* constructors in the Call Hierarchy.
50	* <p>	50	* <p>
51	* Value is of type <code>String</code>: semicolon separated list of fully qualified type names.	51	* Value is of type <code>String</code>: semicolon separated list of fully qualified type names.
		52	* <strong> It has been replaced in 3.6 by API:
		53	* {@link PreferenceConstants#PREF_DEFAULT_EXPAND_WITH_CONSTRUCTORS_MEMBERS}</strong>
52	* </p>	54	* </p>
53	*	55	*
54	* @since 3.5	56	* @since 3.5
55	*/	57	*/
56	public static final String PREF_DEFAULT_EXPAND_WITH_CONSTRUCTORS= "CallHierarchy.defaultExpandWithConstructors"; //$NON-NLS-1$	58	public static final String OLD_PREF_DEFAULT_EXPAND_WITH_CONSTRUCTORS= "CallHierarchy.defaultExpandWithConstructors"; //$NON-NLS-1$
57
58	/**
59	* A named preference that controls whether methods from anonymous types are by default expanded
60	* with constructors in the Call Hierarchy.
61	* <p>
62	* Value is of type <code>Boolean</code>.
63	* </p>
64	*
65	* @since 3.5
66	*/
67	public static final String PREF_ANONYMOUS_EXPAND_WITH_CONSTRUCTORS= "CallHierarchy.anonymousExpandWithConstructors"; //$NON-NLS-1$
68		59
69	private final static Object[] EMPTY_ARRAY= new Object[0];	60	private final static Object[] EMPTY_ARRAY= new Object[0];
70		61
Lines 175-188 Link Here
175		166
176	if (!wrapper.isExpandWithConstructorsSet()) {	167	if (!wrapper.isExpandWithConstructorsSet()) {
177	if (CallHierarchyContentProvider.canExpandWithConstructors(wrapper)) {	168	if (CallHierarchyContentProvider.canExpandWithConstructors(wrapper)) {
178	IType type= wrapper.getMember().getDeclaringType();	169	IMethod method= (IMethod)wrapper.getMember();
		170	IType type= method.getDeclaringType();
179	try {	171	try {
180	boolean withConstructors= false;	172	boolean withConstructors= false;
181	if (type != null) {	173	if (type != null) {
182	boolean anonymousPref= PreferenceConstants.getPreferenceStore().getBoolean(PREF_ANONYMOUS_EXPAND_WITH_CONSTRUCTORS);	174	boolean anonymousPref= PreferenceConstants.getPreferenceStore().getBoolean(PreferenceConstants.PREF_ANONYMOUS_EXPAND_WITH_CONSTRUCTORS);
183	if (anonymousPref && type.isAnonymous()) {	175	if (anonymousPref && type.isAnonymous()) {
184	withConstructors= true;	176	withConstructors= true;
185	} else if (isInTheDefaultExpandWithConstructorList(type)) {	177	} else if (isInTheDefaultExpandWithConstructorList(method)) {
186	withConstructors= true;	178	withConstructors= true;
187	}	179	}
188	}	180	}
Lines 217-253 Link Here
217	}	209	}
218		210
219	/**	211	/**
220	* Checks if declaring type matches the pre-defined array of types for default expand with	212	* Checks if the method or its declaring type matches the pre-defined array of methods and types
221	* constructors.	213	* for default expand with constructors.
		214	*
		215	* @param method the wrapped method
		216	* @return <code>true</code> if method or type matches the pre-defined list, <code>false</code>
		217	* otherwise
222	*	218	*
223	* @param type the declaring type of the caller method wrapper
224	* @return <code>true</code> if type matches the pre-defined list, <code>false</code> otherwise
225	* @since 3.5	219	* @since 3.5
226	*/	220	*/
227	static boolean isInTheDefaultExpandWithConstructorList(IType type) {	221	static boolean isInTheDefaultExpandWithConstructorList(IMethod method) {
228	String serializedTypes= PreferenceConstants.getPreferenceStore().getString(PREF_DEFAULT_EXPAND_WITH_CONSTRUCTORS);	222	String serializedMembers= PreferenceConstants.getPreferenceStore().getString(PreferenceConstants.PREF_DEFAULT_EXPAND_WITH_CONSTRUCTORS_MEMBERS);
229	if (serializedTypes.length() == 0)	223	if (serializedMembers.length() == 0)
230	return false;	224	return false;
231		225	String methodName= method.getElementName();
232	String[] defaultTypes= serializedTypes.split(";"); //$NON-NLS-1$	226	IType declaringType= method.getDeclaringType();
233		227	String[] defaultMemberNames= serializedMembers.split(";"); //$NON-NLS-1$
234	String typeName= type.getFullyQualifiedName('.');	228
235	String superClass;	229	String declaringTypeName= declaringType.getFullyQualifiedName('.') + ".*"; //$NON-NLS-1$;
236	String[] superInterfaces;	230	String qualifiedMethodName= declaringType.getFullyQualifiedName('.') + '.' + methodName;
		231	String superClassName;
		232	String[] superInterfaceNames;
237	try {	233	try {
238	superClass= type.getSuperclassName();	234	superClassName= declaringType.getSuperclassName();
239	superInterfaces= type.getSuperInterfaceNames();	235	if (superClassName != null) {
		236	if (superClassName.contains("<")) { //$NON-NLS-1$
		237	superClassName= stripParametersFromSuperType(superClassName);
		238	}
		239	}
		240	superInterfaceNames= declaringType.getSuperInterfaceNames();
240	} catch (JavaModelException e) {	241	} catch (JavaModelException e) {
241	return false;	242	return false;
242	}	243	}
243	for (int i= 0; i < defaultTypes.length; i++) {	244	for (int i= 0; i < defaultMemberNames.length; i++) {
244	String defaultType= defaultTypes[i];	245	String defaultMemberName= defaultMemberNames[i];
245	if (typeName.equals(defaultType) \|\| (superClass != null && typeNameMatches(superClass, defaultType))) {	246	if (qualifiedMethodName.equals(defaultMemberName) \|\| declaringTypeName.equals(defaultMemberName) \|\| checkSuperTypeMatch(superClassName, defaultMemberName)
		247	\|\| (checkMethodInSuperType(methodName, superClassName, defaultMemberName))) {
246	return true;	248	return true;
247	}	249	}
248	if (superInterfaces.length > 0) {	250	if (superInterfaceNames.length > 0) {
249	for (int j= 0; j < superInterfaces.length; j++) {	251	for (int j= 0; j < superInterfaceNames.length; j++) {
250	if (typeNameMatches(superInterfaces[j], defaultType))	252	if (superInterfaceNames[j].contains("<")) { //$NON-NLS-1$
		253	superInterfaceNames[j]= stripParametersFromSuperType(superInterfaceNames[j]);
		254	}
		255	if (checkSuperTypeMatch(superInterfaceNames[j], defaultMemberName) \|\| checkMethodInSuperType(methodName, superInterfaceNames[j], defaultMemberName))
251	return true;	256	return true;
252	}	257	}
253	}	258	}
Lines 256-261 Link Here
256	}	261	}
257		262
258	/**	263	/**
		264	* Strips parameters from the given super type name and returns the substring containing only
		265	* the type name.
		266	*
		267	* @param superTypeName the super type name
		268	* @return the substring containing only the type name without the parameters
		269	*
		270	* @since 3.6
		271	*/
		272	private static String stripParametersFromSuperType(String superTypeName) {
		273	int pos= superTypeName.indexOf('<');//strip the parameters
		274	return superTypeName.substring(0, pos);
		275	}
		276
		277	/**
		278	* Check if the method in the super type matches the default member.
		279	*
		280	* @param methodName the method name
		281	* @param superTypeName the super type name
		282	* @param defaultMemberName the member in the default list
		283	*
		284	* @return <code>true</code> if the method in the super type matches the default member,
		285	* <code>false</code> otherwise
		286	*
		287	* @since 3.6
		288	*/
		289	private static boolean checkMethodInSuperType(String methodName, String superTypeName, String defaultMemberName) {
		290	if (superTypeName != null && typeNameMatches(methodName, defaultMemberName)) {
		291	int pos= defaultMemberName.lastIndexOf('.');
		292	String defaultTypeName= defaultMemberName.substring(0, pos);
		293	return typeNameMatches(superTypeName, defaultTypeName);
		294	}
		295	return false;
		296	}
		297
		298	/**
		299	* Check whether the given super type name matches the given default type.
		300	*
		301	* @param superType the super type name
		302	* @param defaultMemberName the default member from the default list
		303	*
		304	* @return <code>true</code> if super type matches with the given type in the default list,
		305	* <code>false></code> otherwise
		306	*
		307	* @since 3.6
		308	*/
		309	private static boolean checkSuperTypeMatch(String superType, String defaultMemberName) {
		310	if (defaultMemberName.endsWith(".*")) { //$NON-NLS-1$
		311	defaultMemberName= defaultMemberName.substring(0, defaultMemberName.length() - 2);
		312	}
		313	return (superType != null && typeNameMatches(superType, defaultMemberName));
		314	}
		315
		316	/**
259	* Checks whether the two type names match. They match if they	317	* Checks whether the two type names match. They match if they
260	* are equal, or if could be the same type but one is missing the package.	318	* are equal, or if could be the same type but one is missing the package.
261	*	319	*

Lines 149-156 Link Here

(-)ui/org/eclipse/jdt/internal/ui/callhierarchy/CallHierarchyMessages.properties (-5 / +23 lines)
149	ExpandWithConstructorsAction_expandWithConstructors_text= &Expand with Constructors	149	ExpandWithConstructorsAction_expandWithConstructors_text= &Expand with Constructors
150	ExpandWithConstructorsAction_expandWithConstructors_description= Expand with constructors	150	ExpandWithConstructorsAction_expandWithConstructors_description= Expand with constructors
151	ExpandWithConstructorsAction_expandWithConstructors_tooltip= Expand with Constructors	151	ExpandWithConstructorsAction_expandWithConstructors_tooltip= Expand with Constructors
152	ExpandWithConstructorsDialog_anonymousTypes_label=&All methods in anonymous types	152	ExpandWithConstructorsDialog_title= Expand with Constructors
153	ExpandWithConstructorsDialog_explanation_label=Configure the types whose instance methods are expanded with constructors by default.	153
154	ExpandWithConstructorsDialog_not_a_valid_type_name=''{0}'' is not a valid type name	154	ExpandWithConstructorsConfigurationBlock_description= De&fine a list of members or types with their fully qualified names. The call hierarchy for these members or members of the types will be expanded with constructors by default.
155	ExpandWithConstructorsDialog_title=Expand with Constructors	155	ExpandWithConstructorsConfigurationBlock_newType_button= New &Type...
156	ExpandWithConstructorsDialog_typeNames_label=Type &names (each on a line):	156	ExpandWithConstructorsConfigurationBlock_newMember_button= New &Member...
		157	ExpandWithConstructorsConfigurationBlock_edit_button= &Edit...
		158	ExpandWithConstructorsConfigurationBlock_remove_button= &Remove
		159	ExpandWithConstructorsConfigurationBlock_restoreDefaults_button= Restore &Defaults
		160
		161	CallHierarchyTypesOrMembersDialog_member_title= New Member for Expand With Constructors
		162	CallHierarchyTypesOrMembersDialog_member_labelText= Enter a fully qualified non-static, non-constructor member (e.g. \'java.lang.Runnable.run\'):
		163	CallHierarchyTypesOrMembersDialog_type_title= New Type for Expand With Constructors
		164	CallHierarchyTypesOrMembersDialog_type_labelText= Enter a fully qualified type (e.g. \'java.lang.Runnable\'):
		165	CallHierarchyTypesOrMembersDialog_browse_button= &Browse...
		166	CallHierarchyTypesOrMembersDialog_ChooseTypeDialog_title= Type Selection
		167	CallHierarchyTypesOrMembersDialog_ChooseTypeDialog_description= Choose type name:
		168	CallHierarchyTypesOrMembersDialog_ChooseTypeDialog_error_message= A problem occurred while collecting types. See the error Log for details.
		169	CallHierarchyTypesOrMembersDialog_error_enterName=Enter a name or prefix.
		170	CallHierarchyTypesOrMembersDialog_error_invalidTypeName=Not a valid type name.
		171	CallHierarchyTypesOrMembersDialog_error_invalidMemberName=Not a valid member name.
		172	CallHierarchyTypesOrMembersDialog_error_entryExists=Entry already exists in list.
		173	CallHierarchyTypesOrMembersDialog_anonymousTypes_label=&All methods in anonymous types
		174

Lines 10-54 Link Here

(-)ui/org/eclipse/jdt/internal/ui/callhierarchy/ExpandWithConstructorsDialog.java (-81 / +18 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.jdt.internal.ui.callhierarchy;	11	package org.eclipse.jdt.internal.ui.callhierarchy;
12		12
13	import org.eclipse.swt.SWT;
14	import org.eclipse.swt.custom.StyledText;
15	import org.eclipse.swt.events.ModifyEvent;
16	import org.eclipse.swt.events.ModifyListener;
17	import org.eclipse.swt.layout.GridData;	13	import org.eclipse.swt.layout.GridData;
18	import org.eclipse.swt.widgets.Button;
19	import org.eclipse.swt.widgets.Composite;	14	import org.eclipse.swt.widgets.Composite;
20	import org.eclipse.swt.widgets.Control;	15	import org.eclipse.swt.widgets.Control;
21	import org.eclipse.swt.widgets.Label;
22	import org.eclipse.swt.widgets.Shell;	16	import org.eclipse.swt.widgets.Shell;
23		17
24	import org.eclipse.core.runtime.IStatus;	18	import org.eclipse.core.runtime.IStatus;
25		19
26	import org.eclipse.jface.dialogs.StatusDialog;	20	import org.eclipse.jface.dialogs.Dialog;
		21	import org.eclipse.jface.dialogs.TrayDialog;
27		22
28	import org.eclipse.ui.PlatformUI;	23	import org.eclipse.ui.PlatformUI;
29		24
30	import org.eclipse.jdt.core.JavaConventions;
31	import org.eclipse.jdt.core.JavaCore;
32
33	import org.eclipse.jdt.internal.corext.util.Messages;
34
35	import org.eclipse.jdt.ui.PreferenceConstants;
36
37	import org.eclipse.jdt.internal.ui.IJavaHelpContextIds;	25	import org.eclipse.jdt.internal.ui.IJavaHelpContextIds;
38	import org.eclipse.jdt.internal.ui.dialogs.StatusInfo;	26	import org.eclipse.jdt.internal.ui.wizards.IStatusChangeListener;
39		27
40	/**	28	/**
41	* Configuration dialog for default "Expand with Constructors" behavior.	29	* Configuration dialog for default "Expand with Constructors" behavior.
42	*	30	*
43	* @since 3.5	31	* @since 3.5
44	*/	32	*/
45	class ExpandWithConstructorsDialog extends StatusDialog {	33	class ExpandWithConstructorsDialog extends TrayDialog {
46		34
47	private static final String LINE_DELIMITER_REGEX= "\\r\\n?\|\\n"; //$NON-NLS-1$	35	private Control fConfigurationBlockControl;
		36	private ExpandWithConstructorsConfigurationBlock fConfigurationBlock;
48		37
49	private Button fAnonymousButton;
50	private StyledText fDefaultTypesText;
51
52	protected ExpandWithConstructorsDialog(Shell parentShell) {	38	protected ExpandWithConstructorsDialog(Shell parentShell) {
53	super(parentShell);	39	super(parentShell);
54	}	40	}
Lines 66-114 Link Here
66	protected void configureShell(Shell newShell) {	52	protected void configureShell(Shell newShell) {
67	super.configureShell(newShell);	53	super.configureShell(newShell);
68	newShell.setText(CallHierarchyMessages.ExpandWithConstructorsDialog_title);	54	newShell.setText(CallHierarchyMessages.ExpandWithConstructorsDialog_title);
69	setHelpAvailable(false);
70	PlatformUI.getWorkbench().getHelpSystem().setHelp(newShell, IJavaHelpContextIds.CALL_HIERARCHY_EXPAND_WITH_CONSTRUCTORS_DIALOG);	55	PlatformUI.getWorkbench().getHelpSystem().setHelp(newShell, IJavaHelpContextIds.CALL_HIERARCHY_EXPAND_WITH_CONSTRUCTORS_DIALOG);
71	}	56	}
72		57
73	/*	58	/*
74	* @see org.eclipse.jface.dialogs.Dialog#createDialogArea(org.eclipse.swt.widgets.Composite)	59	* @see org.eclipse.jface.dialogs.Dialog#createDialogArea(org.eclipse.swt.widgets.Composite)
75	*/	60	*/
76	protected Control createDialogArea(Composite parent) {	61	protected Control createDialogArea(Composite composite) {
77	Composite composite= (Composite)super.createDialogArea(parent);	62	fConfigurationBlock= new ExpandWithConstructorsConfigurationBlock(new IStatusChangeListener() {
78	((GridData)composite.getLayoutData()).widthHint= convertWidthInCharsToPixels(60);	63	public void statusChanged(IStatus status) {
79		64	//Do nothing
80	Label descriptionLabel= new Label(composite, SWT.WRAP);	65
81	descriptionLabel.setText(CallHierarchyMessages.ExpandWithConstructorsDialog_explanation_label);
82	descriptionLabel.setLayoutData(new GridData(SWT.LEFT, SWT.CENTER, true, false));
83
84
85	Label typesLabel= new Label(composite, SWT.WRAP);
86	typesLabel.setText(CallHierarchyMessages.ExpandWithConstructorsDialog_typeNames_label);
87	typesLabel.setLayoutData(new GridData(SWT.LEFT, SWT.CENTER, true, false));
88
89	fDefaultTypesText= new StyledText(composite, SWT.BORDER \| SWT.WRAP \| SWT.H_SCROLL \| SWT.V_SCROLL);
90	GridData gd= new GridData(SWT.FILL, SWT.FILL, true, true);
91	gd.heightHint= convertHeightInCharsToPixels(10);
92	fDefaultTypesText.setLayoutData(gd);
93
94	String defaultTypesPref= PreferenceConstants.getPreferenceStore().getString(CallHierarchyContentProvider.PREF_DEFAULT_EXPAND_WITH_CONSTRUCTORS);
95	String defaultTypesText= defaultTypesPref.replace(';', '\n');
96	fDefaultTypesText.setText(defaultTypesText);
97	fDefaultTypesText.setSelection(fDefaultTypesText.getCharCount());
98
99	fDefaultTypesText.addModifyListener(new ModifyListener() {
100	public void modifyText(ModifyEvent e) {
101	validateInput();
102	}	66	}
103	});	67	}, null);
104		68	GridData data= new GridData(GridData.FILL, GridData.FILL, true, true);
105		69	fConfigurationBlockControl= fConfigurationBlock.createContents(composite);
106	fAnonymousButton= new Button(composite, SWT.CHECK);	70	fConfigurationBlockControl.setLayoutData(data);
107	fAnonymousButton.setText(CallHierarchyMessages.ExpandWithConstructorsDialog_anonymousTypes_label);	71
108	boolean anonymousPref= PreferenceConstants.getPreferenceStore().getBoolean(CallHierarchyContentProvider.PREF_ANONYMOUS_EXPAND_WITH_CONSTRUCTORS);	72	Dialog.applyDialogFont(composite);
109	fAnonymousButton.setSelection(anonymousPref);
110	fAnonymousButton.setLayoutData(new GridData(SWT.LEFT, SWT.CENTER, true, false));
111
112	return composite;	73	return composite;
113	}	74	}
114		75
Lines 116-146 Link Here
116	* @see org.eclipse.jface.dialogs.Dialog#okPressed()	77	* @see org.eclipse.jface.dialogs.Dialog#okPressed()
117	*/	78	*/
118	protected void okPressed() {	79	protected void okPressed() {
119	PreferenceConstants.getPreferenceStore().setValue(CallHierarchyContentProvider.PREF_ANONYMOUS_EXPAND_WITH_CONSTRUCTORS, fAnonymousButton.getSelection());	80	fConfigurationBlock.performOk();
120
121	String defaultTypes= fDefaultTypesText.getText().trim();
122	String defaultTypesPref= defaultTypes.replaceAll(LINE_DELIMITER_REGEX, ";"); //$NON-NLS-1$
123	PreferenceConstants.getPreferenceStore().setValue(CallHierarchyContentProvider.PREF_DEFAULT_EXPAND_WITH_CONSTRUCTORS, defaultTypesPref);
124
125	super.okPressed();	81	super.okPressed();
126	}	82	}
127
128	private void validateInput() {
129	StatusInfo status= new StatusInfo();
130
131	String[] defaultTypes= fDefaultTypesText.getText().split(LINE_DELIMITER_REGEX);
132	for (int i= 0; i < defaultTypes.length; i++) {
133	String type= defaultTypes[i];
134	if (type.length() == 0)
135	continue;
136
137	IStatus typeNameStatus= JavaConventions.validateJavaTypeName(type, JavaCore.VERSION_1_3, JavaCore.VERSION_1_3);
138	if (typeNameStatus.getSeverity() == IStatus.ERROR) {
139	status.setError(Messages.format(CallHierarchyMessages.ExpandWithConstructorsDialog_not_a_valid_type_name, type));
140	break;
141	}
142	}
143
144	updateStatus(status);
145	}
146	}	83	}

Lines 10-15 Link Here

(-)ui/org/eclipse/jdt/ui/PreferenceConstants.java (-3 / +38 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.jdt.ui;	11	package org.eclipse.jdt.ui;
12		12
		13	import java.util.Arrays;
13	import java.util.Locale;	14	import java.util.Locale;
14	import java.util.StringTokenizer;	15	import java.util.StringTokenizer;
15		16
Lines 44-49 Link Here
44	import org.eclipse.jdt.internal.ui.JavaPlugin;	45	import org.eclipse.jdt.internal.ui.JavaPlugin;
45	import org.eclipse.jdt.internal.ui.JavaUIPreferenceInitializer;	46	import org.eclipse.jdt.internal.ui.JavaUIPreferenceInitializer;
46	import org.eclipse.jdt.internal.ui.callhierarchy.CallHierarchyContentProvider;	47	import org.eclipse.jdt.internal.ui.callhierarchy.CallHierarchyContentProvider;
		48	import org.eclipse.jdt.internal.ui.callhierarchy.ExpandWithConstructorsConfigurationBlock;
47	import org.eclipse.jdt.internal.ui.javaeditor.SemanticHighlightings;	49	import org.eclipse.jdt.internal.ui.javaeditor.SemanticHighlightings;
48	import org.eclipse.jdt.internal.ui.preferences.NewJavaProjectPreferencePage;	50	import org.eclipse.jdt.internal.ui.preferences.NewJavaProjectPreferencePage;
49	import org.eclipse.jdt.internal.ui.preferences.formatter.FormatterProfileManager;	51	import org.eclipse.jdt.internal.ui.preferences.formatter.FormatterProfileManager;
Lines 3233-3238 Link Here
3233	*/	3235	*/
3234	public static final String EDITOR_FOLDING_HEADERS= "editor_folding_default_headers"; //$NON-NLS-1$	3236	public static final String EDITOR_FOLDING_HEADERS= "editor_folding_default_headers"; //$NON-NLS-1$
3235		3237
		3238	/**
		3239	* A named preference that holds the methods or types whose methods are by default expanded with
		3240	* constructors in the Call Hierarchy.
		3241	* <p>
		3242	* Value is of type <code>String</code>: semicolon separated list of fully qualified type names
		3243	* appended with ".*" or "." + method name.
		3244	* </p>
		3245	*
		3246	* @since 3.6
		3247	*/
		3248	public static final String PREF_DEFAULT_EXPAND_WITH_CONSTRUCTORS_MEMBERS= "CallHierarchy.defaultExpandWithConstructorsMembers"; //$NON-NLS-1$
		3249
		3250	/**
		3251	* A named preference that controls whether methods from anonymous types are by default expanded
		3252	* with constructors in the Call Hierarchy.
		3253	* <p>
		3254	* Value is of type <code>Boolean</code>.
		3255	* </p>
		3256	*
		3257	* @since 3.6
		3258	*/
		3259	public static final String PREF_ANONYMOUS_EXPAND_WITH_CONSTRUCTORS= "CallHierarchy.anonymousExpandWithConstructors"; //$NON-NLS-1$
		3260
3236		3261
3237	//---------- Properties File Editor ----------	3262	//---------- Properties File Editor ----------
3238		3263
Lines 3875-3883 Link Here
3875		3900
3876	// Colors that are set by the current theme	3901	// Colors that are set by the current theme
3877	JavaUIPreferenceInitializer.setThemeBasedPreferences(store, false);	3902	JavaUIPreferenceInitializer.setThemeBasedPreferences(store, false);
3878		3903
3879	store.setDefault(CallHierarchyContentProvider.PREF_ANONYMOUS_EXPAND_WITH_CONSTRUCTORS, true);	3904	store.setDefault(PREF_ANONYMOUS_EXPAND_WITH_CONSTRUCTORS, true);
3880	store.setDefault(CallHierarchyContentProvider.PREF_DEFAULT_EXPAND_WITH_CONSTRUCTORS, "java.lang.Runnable;java.util.concurrent.Callable;org.eclipse.swt.widgets.Listener"); //$NON-NLS-1$	3905	store.setDefault(PREF_DEFAULT_EXPAND_WITH_CONSTRUCTORS_MEMBERS, "java.lang.Runnable.run;java.util.concurrent.Callable.call;org.eclipse.swt.widgets.Listener.handleEvent"); //$NON-NLS-1$
		3906	// compatibility code
		3907	String str= store.getString(CallHierarchyContentProvider.OLD_PREF_DEFAULT_EXPAND_WITH_CONSTRUCTORS);
		3908	if (str.length() > 0) {
		3909	String[] oldPrefStr= str.split(";"); //$NON-NLS-1$
		3910	for (int i= 0; i < oldPrefStr.length; i++) {
		3911	oldPrefStr[i]= oldPrefStr[i] + (".*"); //$NON-NLS-1$
		3912	}
		3913	store.setValue(PREF_DEFAULT_EXPAND_WITH_CONSTRUCTORS_MEMBERS, ExpandWithConstructorsConfigurationBlock.serializeMembers(Arrays.asList(oldPrefStr)));
		3914	store.setToDefault(CallHierarchyContentProvider.OLD_PREF_DEFAULT_EXPAND_WITH_CONSTRUCTORS);
		3915	}
3881	}	3916	}
3882		3917
3883	/**	3918	/**

Lines 88-93 Link Here

(-)ui/org/eclipse/jdt/internal/ui/callhierarchy/CallHierarchyMessages.java (-4 / +19 lines)
88	public static String CallHierarchyViewPart_callsFromMembers_3;	88	public static String CallHierarchyViewPart_callsFromMembers_3;
89	public static String CallHierarchyViewPart_callsFromMembers_more;	89	public static String CallHierarchyViewPart_callsFromMembers_more;
90	public static String CallHierarchyViewPart_callsFromMethod;	90	public static String CallHierarchyViewPart_callsFromMethod;
		91	public static String ExpandWithConstructorsConfigurationBlock_description;
		92	public static String ExpandWithConstructorsConfigurationBlock_newType_button;
		93	public static String ExpandWithConstructorsConfigurationBlock_newMember_button;
		94	public static String ExpandWithConstructorsConfigurationBlock_edit_button;
		95	public static String ExpandWithConstructorsConfigurationBlock_remove_button;
		96	public static String ExpandWithConstructorsConfigurationBlock_restoreDefaults_button;
		97	public static String CallHierarchyTypesOrMembersDialog_member_title;
		98	public static String CallHierarchyTypesOrMembersDialog_member_labelText;
		99	public static String CallHierarchyTypesOrMembersDialog_type_title;
		100	public static String CallHierarchyTypesOrMembersDialog_type_labelText;
		101	public static String CallHierarchyTypesOrMembersDialog_browse_button;
		102	public static String CallHierarchyTypesOrMembersDialog_ChooseTypeDialog_title;
		103	public static String CallHierarchyTypesOrMembersDialog_ChooseTypeDialog_description;
		104	public static String CallHierarchyTypesOrMembersDialog_ChooseTypeDialog_error_message;
		105	public static String CallHierarchyTypesOrMembersDialog_error_enterName;
		106	public static String CallHierarchyTypesOrMembersDialog_error_invalidMemberName;
		107	public static String CallHierarchyTypesOrMembersDialog_error_invalidTypeName;
		108	public static String CallHierarchyTypesOrMembersDialog_error_entryExists;
		109	public static String CallHierarchyTypesOrMembersDialog_anonymousTypes_label;
91	public static String FocusOnSelectionAction_focusOnSelection_text;	110	public static String FocusOnSelectionAction_focusOnSelection_text;
92	public static String FocusOnSelectionAction_focusOnSelection_description;	111	public static String FocusOnSelectionAction_focusOnSelection_description;
93	public static String FocusOnSelectionAction_focusOnSelection_tooltip;	112	public static String FocusOnSelectionAction_focusOnSelection_tooltip;
Lines 142-152 Link Here
142	public static String ExpandWithConstructorsAction_expandWithConstructors_text;	161	public static String ExpandWithConstructorsAction_expandWithConstructors_text;
143	public static String ExpandWithConstructorsAction_expandWithConstructors_description;	162	public static String ExpandWithConstructorsAction_expandWithConstructors_description;
144	public static String ExpandWithConstructorsAction_expandWithConstructors_tooltip;	163	public static String ExpandWithConstructorsAction_expandWithConstructors_tooltip;
145	public static String ExpandWithConstructorsDialog_anonymousTypes_label;
146	public static String ExpandWithConstructorsDialog_explanation_label;
147	public static String ExpandWithConstructorsDialog_not_a_valid_type_name;
148	public static String ExpandWithConstructorsDialog_title;	164	public static String ExpandWithConstructorsDialog_title;
149	public static String ExpandWithConstructorsDialog_typeNames_label;
150	static {	165	static {
151	NLS.initializeMessages(BUNDLE_NAME, CallHierarchyMessages.class);	166	NLS.initializeMessages(BUNDLE_NAME, CallHierarchyMessages.class);
152	}	167	}