Attachment #139425 for bug #191432

View | Details | Raw Unified | Return to bug 191432
Collapse All | Expand All




import org.eclipse.search.internal.core.text.PatternConstructor;
import org.eclipse.search.internal.ui.Messages;
import org.eclipse.search.internal.ui.SearchMessages;
import org.eclipse.search.ui.ISearchQuery;
import org.eclipse.search.ui.ISearchResult;
import org.eclipse.search.ui.text.AbstractTextSearchResult;
import org.eclipse.search.ui.text.FileTextSearchScope;
import org.eclipse.search.ui.text.Match;


public class FileSearchQuery implements IFileSearchQuery {

	private final static class TextSearchResultCollector extends TextSearchRequestor {


		}
		return fResult;
	}
	
	/** 
	 * {@inheritDoc}
	 */
	public boolean isShowLineMatches() {
		return !isFileNameSearch();
	}
}

Lines 71-77 Link Here

(-)search/org/eclipse/search/internal/ui/text/FileTreeContentProvider.java (-1 / +1 lines)
71	private synchronized void initialize(AbstractTextSearchResult result) {	71	private synchronized void initialize(AbstractTextSearchResult result) {
72	fResult= result;	72	fResult= result;
73	fChildrenMap= new HashMap();	73	fChildrenMap= new HashMap();
74	boolean showLineMatches= !((FileSearchQuery) fResult.getQuery()).isFileNameSearch();	74	boolean showLineMatches= ((IFileSearchQuery) fResult.getQuery()).isShowLineMatches();
75		75
76	if (result != null) {	76	if (result != null) {
77	Object[] elements= result.getElements();	77	Object[] elements= result.getElements();




import org.eclipse.search.internal.ui.Messages;
import org.eclipse.search.internal.ui.SearchMessages;
import org.eclipse.search.ui.IContextMenuConstants;
import org.eclipse.search.ui.ISearchQuery;
import org.eclipse.search.ui.ISearchResultViewPart;
import org.eclipse.search.ui.text.AbstractTextSearchResult;
import org.eclipse.search.ui.text.AbstractTextSearchViewPage;

		addSortActions(mgr);
		fActionGroup.setContext(new ActionContext(getSite().getSelectionProvider().getSelection()));
		fActionGroup.fillContextMenu(mgr);
		ISearchQuery query= getInput().getQuery();
		if (query instanceof FileSearchQuery && ((FileSearchQuery) query).getSearchString().length() > 0) {
			IStructuredSelection selection= (IStructuredSelection) getViewer().getSelection();
			if (!selection.isEmpty()) {
				ReplaceAction replaceSelection= new ReplaceAction(getSite().getShell(), (FileSearchResult) getInput(), selection.toArray(), true);


	private boolean showLineMatches() {
		AbstractTextSearchResult input= getInput();
		return getLayout() == FLAG_LAYOUT_TREE && input != null && ((IFileSearchQuery) input.getQuery()).isShowLineMatches();
	}

}




import java.io.IOException;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.regex.PatternSyntaxException;


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

import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.dialogs.DialogPage;
import org.eclipse.jface.dialogs.ErrorDialog;

import org.eclipse.jface.fieldassist.ComboContentAdapter;
import org.eclipse.jface.resource.JFaceColors;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.jface.text.FindReplaceDocumentAdapter;
import org.eclipse.jface.text.FindReplaceDocumentAdapterContentProposalProvider;

import org.eclipse.search.internal.ui.ISearchHelpContextIds;
import org.eclipse.search.internal.ui.SearchMessages;
import org.eclipse.search.internal.ui.SearchPlugin;
import org.eclipse.search.internal.ui.text.FileSearchScopeConfigurationBlock.FileSearchScopeConfigurationBlockListener;
import org.eclipse.search.internal.ui.util.FileTypeEditor;
import org.eclipse.search.internal.ui.util.SWTUtil;
import org.eclipse.search.ui.IReplacePage;
import org.eclipse.search.ui.ISearchPage;
import org.eclipse.search.ui.ISearchPageContainer;

	private boolean fFirstTime= true;
	private boolean fIsCaseSensitive;
	private boolean fIsRegExSearch;
	private boolean fSearchDerived;

	private Combo fPattern;
	private Button fIsCaseSensitiveCheckbox;
	private Combo fExtensions;
	private Button fIsRegExCheckbox;
	private CLabel fStatusLabel;
	private Button fSearchDerivedCheckbox;

	private ISearchPageContainer fContainer;
	private FileTypeEditor fFileTypeEditor;

	private ContentAssistCommandAdapter fPatterFieldContentAssist;

	private FileSearchScopeConfigurationBlock fScopeConfigurationBlock;

	private static class SearchPatternData {
		public final boolean isCaseSensitive;
		public final boolean isRegExSearch;

		}
	}

	public TextSearchPage() {
		fScopeConfigurationBlock= new FileSearchScopeConfigurationBlock(new FileSearchScopeConfigurationBlockListener() {
			public void extensionsTextChanged() {
				updateOKStatus();
			}

			public void derivedSelectionChanged() {
				writeConfiguration();
			}
		});
	}

	//---- Action Handling ------------------------------------------------

	private ISearchQuery newQuery() throws CoreException {
		SearchPatternData data= getPatternData();
		TextSearchPageInput input= new TextSearchPageInput(data.textPattern, data.isCaseSensitive, data.isRegExSearch, fScopeConfigurationBlock.createTextSearchScope());
		return TextSearchQueryProvider.getPreferred().createQuery(input);
	}


		return fPattern.getText();
	}

	public FileTextSearchScope createTextSearchScope() {
		// Setup search scope
		switch (getContainer().getSelectedScope()) {
			case ISearchPageContainer.WORKSPACE_SCOPE:
				return FileTextSearchScope.newWorkspaceScope(getExtensions(), fSearchDerived);
			case ISearchPageContainer.SELECTION_SCOPE:
				return getSelectedResourcesScope();
			case ISearchPageContainer.SELECTED_PROJECTS_SCOPE:
				return getEnclosingProjectScope();
			case ISearchPageContainer.WORKING_SET_SCOPE:
				IWorkingSet[] workingSets= getContainer().getSelectedWorkingSets();
				return FileTextSearchScope.newSearchScope(workingSets, getExtensions(), fSearchDerived);
			default:
				// unknown scope
				return FileTextSearchScope.newWorkspaceScope(getExtensions(), fSearchDerived);
		}
	}

	private FileTextSearchScope getSelectedResourcesScope() {
		HashSet resources= new HashSet();
		ISelection sel= getContainer().getSelection();
		if (sel instanceof IStructuredSelection && !sel.isEmpty()) {
			Iterator iter= ((IStructuredSelection) sel).iterator();
			while (iter.hasNext()) {
				Object curr= iter.next();
				if (curr instanceof IWorkingSet) {
					IWorkingSet workingSet= (IWorkingSet) curr;
					if (workingSet.isAggregateWorkingSet() && workingSet.isEmpty()) {
						return FileTextSearchScope.newWorkspaceScope(getExtensions(), fSearchDerived);
					}
					IAdaptable[] elements= workingSet.getElements();
					for (int i= 0; i < elements.length; i++) {
						IResource resource= (IResource)elements[i].getAdapter(IResource.class);
						if (resource != null && resource.isAccessible()) {
							resources.add(resource);
						}
					}
				} else if (curr instanceof IAdaptable) {
					IResource resource= (IResource) ((IAdaptable)curr).getAdapter(IResource.class);
					if (resource != null && resource.isAccessible()) {
						resources.add(resource);
					}
				}
			}
		}
		IResource[] arr= (IResource[]) resources.toArray(new IResource[resources.size()]);
		return FileTextSearchScope.newSearchScope(arr, getExtensions(), fSearchDerived);
	}

	private FileTextSearchScope getEnclosingProjectScope() {
		String[] enclosingProjectName= getContainer().getSelectedProjectNames();
		if (enclosingProjectName == null) {
			return FileTextSearchScope.newWorkspaceScope(getExtensions(), fSearchDerived);
		}

		IWorkspaceRoot root= ResourcesPlugin.getWorkspace().getRoot();
		IResource[] res= new IResource[enclosingProjectName.length];
		for (int i= 0; i < res.length; i++) {
			res[i]= root.getProject(enclosingProjectName[i]);
		}

		return FileTextSearchScope.newSearchScope(res, getExtensions(), fSearchDerived);
	}


	private SearchPatternData findInPrevious(String pattern) {
		for (Iterator iter= fPreviousSearchPatterns.iterator(); iter.hasNext();) {
			SearchPatternData element= (SearchPatternData) iter.next();

					getPattern(),
					isCaseSensitive(),
					fIsRegExCheckbox.getSelection(),
					fScopeConfigurationBlock.getExtensions(),
					getContainer().getSelectedScope(),
					getContainer().getSelectedWorkingSets());
		fPreviousSearchPatterns.add(0, match);

		return patterns;
	}

	private String[] getExtensions() {
		return fFileTypeEditor.getFileTypes();
	}

	private boolean isCaseSensitive() {
		return fIsCaseSensitiveCheckbox.getSelection();
	}

				fFirstTime= false;
				// Set item and text here to prevent page from resizing
				fPattern.setItems(getPreviousSearchPatterns());
				fScopeConfigurationBlock.setExtensions(getPreviousExtensions());
//				if (fExtensions.getItemCount() == 0) {
//					loadFilePatternDefaults();
//				}
				if (!initializePatternControl()) {
					fPattern.select(0);
					fScopeConfigurationBlock.setExtensionsText("*"); //$NON-NLS-1$
					handleWidgetSelected();
				}
			}


	final void updateOKStatus() {
		boolean regexStatus= validateRegex();
		boolean hasFilePattern= fScopeConfigurationBlock.getExtensionsText().length() > 0;
		getContainer().setPerformActionEnabled(regexStatus && hasFilePattern);
	}


		data.heightHint= convertHeightInCharsToPixels(1) / 3;
		separator.setLayoutData(data);

		fScopeConfigurationBlock.createControl(result);

		setControl(result);
		Dialog.applyDialogFont(result);

		fIsCaseSensitiveCheckbox.setSelection(patternData.isCaseSensitive);
		fIsRegExCheckbox.setSelection(patternData.isRegExSearch);
		fPattern.setText(patternData.textPattern);
		fScopeConfigurationBlock.setFileTypes(patternData.fileNamePatterns);
		if (patternData.workingSets != null)
			getContainer().setSelectedWorkingSets(patternData.workingSets);
		else

					fPattern.setText(insertEscapeChars(text));

				if (getPreviousExtensions().length > 0) {
					fScopeConfigurationBlock.setExtensionsText(getPreviousExtensions()[0]);
				} else {
					String extension= getExtensionFromEditor();
					if (extension != null)
						fScopeConfigurationBlock.setExtensionsText(extension);
					else
						fScopeConfigurationBlock.setExtensionsText("*"); //$NON-NLS-1$
				}
				return true;
			}

		return null;
	}

	private void addFileNameControls(Composite group) {
		// grid layout with 2 columns

		// Line with label, combo and button
		Label label= new Label(group, SWT.LEAD);
		label.setText(SearchMessages.SearchPage_fileNamePatterns_text);
		label.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, false, false, 2, 1));
		label.setFont(group.getFont());

		fExtensions= new Combo(group, SWT.SINGLE | SWT.BORDER);
		fExtensions.addModifyListener(new ModifyListener() {
			public void modifyText(ModifyEvent e) {
				updateOKStatus();
			}
		});
		GridData data= new GridData(GridData.FILL, GridData.FILL, true, false, 1, 1);
		data.widthHint= convertWidthInCharsToPixels(50);
		fExtensions.setLayoutData(data);
		fExtensions.setFont(group.getFont());

		Button button= new Button(group, SWT.PUSH);
		button.setText(SearchMessages.SearchPage_browse);
		GridData gridData= new GridData(SWT.BEGINNING, SWT.CENTER, false, false, 1, 1);
		gridData.widthHint= SWTUtil.getButtonWidthHint(button);
		button.setLayoutData(gridData);
		button.setFont(group.getFont());

		fFileTypeEditor= new FileTypeEditor(fExtensions, button);

		// Text line which explains the special characters
		Label description= new Label(group, SWT.LEAD);
		description.setText(SearchMessages.SearchPage_fileNamePatterns_hint);
		description.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, false, false, 2, 1));
		description.setFont(group.getFont());

		fSearchDerivedCheckbox= new Button(group, SWT.CHECK);
		fSearchDerivedCheckbox.setText(SearchMessages.TextSearchPage_searchDerived_label);

		fSearchDerivedCheckbox.setSelection(fSearchDerived);
		fSearchDerivedCheckbox.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				fSearchDerived= fSearchDerivedCheckbox.getSelection();
				writeConfiguration();
			}
		});
		fSearchDerivedCheckbox.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, false, false, 2, 1));
		fSearchDerivedCheckbox.setFont(group.getFont());
  	}

	/**
	 * Sets the search page's container.
	 * @param container the container to set
	 */
	public void setContainer(ISearchPageContainer container) {
		fContainer= container;
		fScopeConfigurationBlock.setContainer(container);
	}

	private ISearchPageContainer getContainer() {

		IDialogSettings s= getDialogSettings();
		fIsCaseSensitive= s.getBoolean(STORE_CASE_SENSITIVE);
		fIsRegExSearch= s.getBoolean(STORE_IS_REG_EX_SEARCH);
		fScopeConfigurationBlock.setSearchDerived(s.getBoolean(STORE_SEARCH_DERIVED));

		try {
			int historySize= s.getInt(STORE_HISTORY_SIZE);

		IDialogSettings s= getDialogSettings();
		s.put(STORE_CASE_SENSITIVE, fIsCaseSensitive);
		s.put(STORE_IS_REG_EX_SEARCH, fIsRegExSearch);
		s.put(STORE_SEARCH_DERIVED, fScopeConfigurationBlock.getSearchDerived());

		int historySize= Math.min(fPreviousSearchPatterns.size(), HISTORY_SIZE);
		s.put(STORE_HISTORY_SIZE, historySize);

Lines 28-36 Link Here

(-)search/org/eclipse/search/internal/ui/text/FileSearchResult.java (-2 / +2 lines)
28	public class FileSearchResult extends AbstractTextSearchResult implements IEditorMatchAdapter, IFileMatchAdapter {	28	public class FileSearchResult extends AbstractTextSearchResult implements IEditorMatchAdapter, IFileMatchAdapter {
29	private final Match[] EMPTY_ARR= new Match[0];	29	private final Match[] EMPTY_ARR= new Match[0];
30		30
31	private FileSearchQuery fQuery;	31	private IFileSearchQuery fQuery;
32		32
33	public FileSearchResult(FileSearchQuery job) {	33	public FileSearchResult(IFileSearchQuery job) {
34	fQuery= job;	34	fQuery= job;
35	}	35	}
36	public ImageDescriptor getImageDescriptor() {	36	public ImageDescriptor getImageDescriptor() {

Lines 230-235 Link Here

(-)search/org/eclipse/search/internal/ui/SearchMessages.properties (+9 lines)
230	SelectAllAction_label= Select A&ll	230	SelectAllAction_label= Select A&ll
231	SelectAllAction_tooltip= Select All	231	SelectAllAction_tooltip= Select All
232		232
		233	SpellingSearchPage_spellingEngineDropDown_label=Spelling Engine:
		234	SpellingSearchPage_spellingEnginePreferencePage_link=Configure the spelling engines on the <a>Spelling Preference Page</a>.
		235	SpellingSearchQuery_query_label=Spelling Problems Search
		236	SpellingSearchQuery_result11_label=1 spelling problem in 1 file
		237	SpellingSearchQuery_result1n_label={0} spelling problem in {1} files
		238	SpellingSearchQuery_resultn1_label={0} spelling problems in 1 file
		239	SpellingSearchQuery_resultnn_label={0} spelling problems in {1} files
		240	SpellingSearchResultPage_fixProblemMenu_label=Fix Spelling Problem
		241
233	RemovePotentialMatchesAction_removePotentialMatch_text= Remove Potential Match	242	RemovePotentialMatchesAction_removePotentialMatch_text= Remove Potential Match
234	RemovePotentialMatchesAction_removePotentialMatch_tooltip= Remove Potential Match	243	RemovePotentialMatchesAction_removePotentialMatch_tooltip= Remove Potential Match
235	RemovePotentialMatchesAction_removePotentialMatches_text= Remove potential Matches	244	RemovePotentialMatchesAction_removePotentialMatches_text= Remove potential Matches




	public static String RemovePotentialMatchesAction_dialog_title;
	public static String RemovePotentialMatchesAction_dialog_message;
	public static String OpenWithMenu_label;
	
	public static String SpellingSearchPage_spellingEngineDropDown_label;
	public static String SpellingSearchPage_spellingEnginePreferencePage_link;
	public static String SpellingSearchQuery_query_label;
	public static String SpellingSearchQuery_result11_label;
	public static String SpellingSearchQuery_result1n_label;
	public static String SpellingSearchQuery_resultn1_label;
	public static String SpellingSearchQuery_resultnn_label;
	public static String SpellingSearchResultPage_fixProblemMenu_label;
	
	
	static {
		NLS.initializeMessages(BUNDLE_NAME, SearchMessages.class);
	}




       point="org.eclipse.core.runtime.preferences">
    <initializer class="org.eclipse.search.internal.ui.SearchPreferenceInitializer"/>
 </extension>
 
 <!--
 			Spelling Problem Search
 -->
 
    <extension
         point="org.eclipse.search.searchPages">
      <page
            canSearchEnclosingProjects="true"
            class="org.eclipse.search.internal.ui.spelling.SpellingSearchPage"
            enabled="true"
            id="org.eclipse.ui.workbench.texteditor.spelling.searchPage"
            label="Spelling Problems"
            showScopeSection="true">
      </page>
   </extension>
   
   <extension
         point="org.eclipse.search.searchResultViewPages">
      <viewPage
            class="org.eclipse.search.internal.ui.spelling.SpellingSearchResultPage"
            id="org.eclipse.ui.workbench.texteditor.spelling.searchResultPage"
            searchResultClass="org.eclipse.search.internal.ui.spelling.SpellingSearchResult">
      </viewPage>
   </extension>
   
</plugin>




/*******************************************************************************
 * 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
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.search.internal.ui.spelling;

import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Link;

import org.eclipse.jface.dialogs.DialogPage;
import org.eclipse.jface.preference.PreferenceDialog;
import org.eclipse.jface.preference.PreferenceStore;

import org.eclipse.ui.dialogs.PreferencesUtil;

import org.eclipse.ui.texteditor.spelling.SpellingEngineDescriptor;
import org.eclipse.ui.texteditor.spelling.SpellingService;

import org.eclipse.search.internal.ui.SearchMessages;
import org.eclipse.search.internal.ui.text.FileSearchScopeConfigurationBlock;
import org.eclipse.search.internal.ui.text.FileSearchScopeConfigurationBlock.FileSearchScopeConfigurationBlockListener;
import org.eclipse.search.ui.ISearchPage;
import org.eclipse.search.ui.ISearchPageContainer;
import org.eclipse.search.ui.NewSearchUI;

public class SpellingSearchPage extends DialogPage implements ISearchPage {
	
	private final SpellingEngineDescriptor[] fSpellingEngines;

	private SpellingEngineDescriptor fSelectedEngine;
	private FileSearchScopeConfigurationBlock fScopeConfigurationBlock;
	private ISearchPageContainer fContainer;

	public SpellingSearchPage() {
		fScopeConfigurationBlock= new FileSearchScopeConfigurationBlock(new FileSearchScopeConfigurationBlockListener() {
			public void extensionsTextChanged() {
				boolean hasFilePattern= fScopeConfigurationBlock.getExtensionsText().length() > 0;
				fContainer.setPerformActionEnabled(hasFilePattern);
			}

			public void derivedSelectionChanged() {
			}
		});

		SpellingService spellingService= new SpellingService(new PreferenceStore());
		fSpellingEngines= spellingService.getSpellingEngineDescriptors();
		fSelectedEngine= spellingService.getDefaultSpellingEngineDescriptor();
	}

	/** 
	 * {@inheritDoc}
	 */
	public boolean performAction() {
		SpellingSearchQuery query= new SpellingSearchQuery(fScopeConfigurationBlock.createTextSearchScope(), fSelectedEngine.getId());
		NewSearchUI.runQueryInBackground(query);
		return true;
	}

	/** 
	 * {@inheritDoc}
	 */
	public void setContainer(ISearchPageContainer container) {
		fContainer= container;
		fScopeConfigurationBlock.setContainer(container);
	}
	
	/** 
	 * {@inheritDoc}
	 */
	public void createControl(Composite parent) {
		initializeDialogUnits(parent);

		Composite control= new Composite(parent, SWT.NONE);
		control.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
		control.setLayout(new GridLayout(2, false));

		if (fSpellingEngines.length > 1) {
			Label label= new Label(control, SWT.NONE);
			label.setLayoutData(new GridData(SWT.BEGINNING, SWT.CENTER, false, false, 2, 1));
			label.setText(SearchMessages.SpellingSearchPage_spellingEngineDropDown_label);

			final Combo combo= new Combo(control, SWT.DROP_DOWN | SWT.READ_ONLY);
			combo.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 2, 1));

			int index= 0;
			String[] items= new String[fSpellingEngines.length];
			for (int i= 0; i < items.length; i++) {
				items[i]= fSpellingEngines[i].getLabel();
				if (fSpellingEngines[i] == fSelectedEngine)
					index= i;
			}
			combo.setItems(items);
			combo.select(index);
			combo.addSelectionListener(new SelectionAdapter() {
				/**
				 * {@inheritDoc}
				 */
				public void widgetSelected(SelectionEvent e) {
					fSelectedEngine= fSpellingEngines[combo.getSelectionIndex()];
				}
			});
		}

		fScopeConfigurationBlock.createControl(control);
		fScopeConfigurationBlock.setExtensionsText("*"); //$NON-NLS-1$

		Link link= new Link(control, SWT.NONE);
		GridData layoutData= new GridData(SWT.END, SWT.CENTER, false, false, 2, 1);
		layoutData.verticalIndent= 15;
		link.setLayoutData(layoutData);
		link.setText(SearchMessages.SpellingSearchPage_spellingEnginePreferencePage_link);
		link.addSelectionListener(new SelectionAdapter() {
			/**
			 * {@inheritDoc}
			 */
			public void widgetSelected(SelectionEvent e) {
				PreferenceDialog dialog= PreferencesUtil.createPreferenceDialogOn(getShell(), "org.eclipse.ui.editors.preferencePages.Spelling", new String[0], null); //$NON-NLS-1$
				dialog.open();
			}
		});

		setControl(control);
	}

}




/*******************************************************************************
 * 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
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.search.internal.ui.spelling;

import org.eclipse.search.internal.ui.text.FileSearchResult;

public class SpellingSearchResult extends FileSearchResult {

	public SpellingSearchResult(SpellingSearchQuery query) {
		super(query);
	}
	
}




/*******************************************************************************
 * 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
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.search.internal.ui.text;

import org.eclipse.search.ui.ISearchQuery;

public interface IFileSearchQuery extends ISearchQuery {
	public String getResultLabel(int nMatches);
	
	public boolean isShowLineMatches();
}




/*******************************************************************************
 * 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
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.search.internal.ui.spelling;

import org.eclipse.core.resources.IFile;

import org.eclipse.ui.texteditor.spelling.SpellingProblem;

import org.eclipse.search.internal.ui.text.LineElement;

public class SpellingLineElement extends LineElement {
	private final SpellingProblem fProblem;
	
	public SpellingLineElement(IFile parent, int lineNumber, int lineStartOffset, String lineContent, SpellingProblem problem) {
		super(parent, lineNumber, lineStartOffset, lineContent);
		fProblem= problem;
	}
	
	public SpellingProblem getProblem() {
		return fProblem;
	}
}




/*******************************************************************************
 * 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
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.search.internal.ui.spelling;

import java.util.regex.Pattern;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Status;

import org.eclipse.core.resources.IFile;

import org.eclipse.core.filebuffers.FileBuffers;
import org.eclipse.core.filebuffers.ITextFileBuffer;
import org.eclipse.core.filebuffers.ITextFileBufferManager;
import org.eclipse.core.filebuffers.LocationKind;

import org.eclipse.jface.preference.PreferenceStore;

import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;

import org.eclipse.ui.texteditor.spelling.ISpellingProblemCollector;
import org.eclipse.ui.texteditor.spelling.SpellingContext;
import org.eclipse.ui.texteditor.spelling.SpellingProblem;
import org.eclipse.ui.texteditor.spelling.SpellingService;

import org.eclipse.search.core.text.TextSearchEngine;
import org.eclipse.search.core.text.TextSearchRequestor;
import org.eclipse.search.internal.ui.Messages;
import org.eclipse.search.internal.ui.SearchMessages;
import org.eclipse.search.internal.ui.SearchPlugin;
import org.eclipse.search.internal.ui.text.IFileSearchQuery;
import org.eclipse.search.internal.ui.text.LineElement;
import org.eclipse.search.internal.ui.text.SearchResultUpdater;
import org.eclipse.search.ui.ISearchResult;
import org.eclipse.search.ui.text.FileTextSearchScope;

public class SpellingSearchQuery implements IFileSearchQuery {
	
	private static class SpellingSearchRequestor extends TextSearchRequestor {
		
		private final SpellingSearchResult fResult;
		private SpellingService fSpellingService;
		
		public SpellingSearchRequestor(SpellingSearchResult result, SpellingService spellingService) {
			fResult= result;
			fSpellingService= spellingService;
		}
		
		/** 
		 * {@inheritDoc}
		 */
		public boolean acceptFile(final IFile file) throws CoreException {
			ITextFileBufferManager bufferManager= FileBuffers.getTextFileBufferManager();
			bufferManager.connect(file.getFullPath(), LocationKind.IFILE, new NullProgressMonitor());
			try {
				ITextFileBuffer buffer= bufferManager.getTextFileBuffer(file.getFullPath(), LocationKind.IFILE);

				SpellingContext context= new SpellingContext();
				context.setContentType(buffer.getContentType());

				final IDocument document= buffer.getDocument();
				fSpellingService.check(document, context, new ISpellingProblemCollector() {
					
					public void endCollecting() {
					}
					
					public void beginCollecting() {
					}
					
					public void accept(SpellingProblem problem) {
						try {
							int lineNumber= document.getLineOfOffset(problem.getOffset());
							int lineStartOffset= document.getLineOffset(lineNumber);
							int lineLength= document.getLineLength(lineNumber);
							LineElement lineElement= new SpellingLineElement(file, lineNumber, lineStartOffset, document.get(lineStartOffset, lineLength), problem);
							fResult.addMatch(new SpellingSearchMatch(file, problem, lineElement));
						} catch (BadLocationException e) {
							SearchPlugin.log(e);
						}
					}
					
				}, new NullProgressMonitor());
			} finally {
				bufferManager.disconnect(file.getFullPath(), LocationKind.IFILE, new NullProgressMonitor());
			}
			return true;
		}
	}

	private final FileTextSearchScope fScope;

	private final String fSpellingEngineId;
	private SpellingSearchResult fResult;
	
	public SpellingSearchQuery(FileTextSearchScope scope, String spellingEngineId) {
		fScope= scope;
		fSpellingEngineId= spellingEngineId;
	}

	/**
	 * {@inheritDoc}
	 */
	public ISearchResult getSearchResult() {
		if (fResult == null) {
			fResult= new SpellingSearchResult(this);
			new SearchResultUpdater(fResult);
		}
		return fResult;
	}

	/** 
	 * {@inheritDoc}
	 */
	public boolean canRerun() {
		return true;
	}
	
	/** 
	 * {@inheritDoc}
	 */
	public boolean canRunInBackground() {
		return true;
	}
	
	/** 
	 * {@inheritDoc}
	 */
	public String getLabel() {
		return SearchMessages.SpellingSearchQuery_query_label;
	}
	
	/** 
	 * {@inheritDoc}
	 */
	public IStatus run(IProgressMonitor monitor) throws OperationCanceledException {
		SpellingSearchResult searchResult= (SpellingSearchResult)getSearchResult();
		searchResult.removeAll();

		PreferenceStore store= new PreferenceStore();
		store.setValue(SpellingService.PREFERENCE_SPELLING_ENABLED, true);
		store.setValue(SpellingService.PREFERENCE_SPELLING_ENGINE, fSpellingEngineId);

		SpellingService spellingService= new SpellingService(store);

		TextSearchEngine engine= TextSearchEngine.create();
		engine.search(fScope, new SpellingSearchRequestor(searchResult, spellingService), Pattern.compile(""), monitor); //$NON-NLS-1$

		return Status.OK_STATUS;
	}
	
	/** 
	 * {@inheritDoc}
	 */
	public String getResultLabel(int matchesCount) {
		int fileCount= fResult.getElements().length;

		Object[] args= new Object[] { new Integer(matchesCount), new Integer(fileCount) };
		if (fileCount == 1 && matchesCount == 1) {
			return SearchMessages.SpellingSearchQuery_result11_label;
		} else if (fileCount == 1) {
			return Messages.format(SearchMessages.SpellingSearchQuery_resultn1_label, args);
		} else if (matchesCount == 1) {
			return Messages.format(SearchMessages.SpellingSearchQuery_result1n_label, args);
		} else {
			return Messages.format(SearchMessages.SpellingSearchQuery_resultnn_label, args);
		}
	}
	
	/** 
	 * {@inheritDoc}
	 */
	public boolean isShowLineMatches() {
		return true;
	}
	
}




/*******************************************************************************
 * 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
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.search.internal.ui.spelling;

import org.eclipse.swt.graphics.ImageData;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.NullProgressMonitor;

import org.eclipse.core.resources.IResource;

import org.eclipse.core.filebuffers.FileBuffers;
import org.eclipse.core.filebuffers.ITextFileBuffer;
import org.eclipse.core.filebuffers.ITextFileBufferManager;
import org.eclipse.core.filebuffers.LocationKind;

import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.jface.text.contentassist.ICompletionProposal;

import org.eclipse.search.internal.ui.SearchMessages;
import org.eclipse.search.internal.ui.SearchPlugin;
import org.eclipse.search.internal.ui.text.FileSearchPage;
import org.eclipse.search.ui.IContextMenuConstants;
import org.eclipse.search.ui.text.AbstractTextSearchResult;
import org.eclipse.search.ui.text.AbstractTextSearchViewPage;
import org.eclipse.search.ui.text.Match;

public class SpellingSearchResultPage extends FileSearchPage {

	private static final class ResolveSpellingProblemAction extends Action {

		private final SpellingLineElement fElement;
		private final ICompletionProposal fProposal;

		private final AbstractTextSearchViewPage fPage;

		public ResolveSpellingProblemAction(SpellingLineElement element, final ICompletionProposal proposal, AbstractTextSearchViewPage page) {
			super(proposal.getDisplayString());
			
			fElement= element;
			fProposal= proposal;
			fPage= page;
			
			setImageDescriptor(new ImageDescriptor() {
				public ImageData getImageData() {
					return proposal.getImage().getImageData();
				}
			});
		}
		
		/** 
		 * {@inheritDoc}
		 */
		public void run() {
			try {
				IResource file= fElement.getParent();
				
				ITextFileBufferManager bufferManager= FileBuffers.getTextFileBufferManager();
				bufferManager.connect(file.getFullPath(), LocationKind.IFILE, new NullProgressMonitor());
				try {
					ITextFileBuffer buffer= bufferManager.getTextFileBuffer(file.getFullPath(), LocationKind.IFILE);
					
					fProposal.apply(buffer.getDocument());

					AbstractTextSearchResult input= fPage.getInput();
					if (input != null) {
						Match[] matches= input.getMatches(file);
						for (int i= 0; i < matches.length; i++) {
							Match match= matches[i];
							if (match instanceof SpellingSearchMatch && ((SpellingSearchMatch)match).getLineElement() == fElement) {
								input.removeMatch(match);
							}
						}
					}
				} finally {
					bufferManager.disconnect(file.getFullPath(), LocationKind.IFILE, new NullProgressMonitor());
				}
			} catch (CoreException e) {
				SearchPlugin.log(e);
			}
		}
	}

	/** 
	 * {@inheritDoc}
	 */
	protected void fillContextMenu(IMenuManager mgr) {
		super.fillContextMenu(mgr);

		ISelection selection= getSite().getSelectionProvider().getSelection();
		if (selection instanceof IStructuredSelection) {
			IStructuredSelection sselection= (IStructuredSelection) selection;
			if (sselection.size() == 1 && sselection.getFirstElement() instanceof SpellingLineElement) {
				SpellingLineElement element= (SpellingLineElement) sselection.getFirstElement();

				ICompletionProposal[] proposals= element.getProblem().getProposals();

				if (proposals.length > 0) {
					MenuManager replaceMenu= new MenuManager(SearchMessages.SpellingSearchResultPage_fixProblemMenu_label);

					for (int i= 0; i < proposals.length; i++) {
						replaceMenu.add(new ResolveSpellingProblemAction(element, proposals[i], this));
					}

					mgr.appendToGroup(IContextMenuConstants.GROUP_EDIT, replaceMenu);
				}
			}
		}
	}

}




/*******************************************************************************
 * 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
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.search.internal.ui.spelling;

import org.eclipse.core.resources.IFile;

import org.eclipse.ui.texteditor.spelling.SpellingProblem;

import org.eclipse.search.internal.ui.text.FileMatch;
import org.eclipse.search.internal.ui.text.LineElement;

public class SpellingSearchMatch extends FileMatch {
	
	private final SpellingProblem fProblem;
	private final IFile fFile;

	public SpellingSearchMatch(IFile file, SpellingProblem problem, LineElement element) {
		super(file, problem.getOffset(), problem.getLength(), element);
		
		fFile= file;
		fProblem= problem;
	}

	public SpellingProblem getProblem() {
		return fProblem;
	}
	
	public IFile getFile() {
		return fFile;
	}

}




/*******************************************************************************
 * 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
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.search.internal.ui.text;

import java.util.HashSet;
import java.util.Iterator;

import org.eclipse.swt.SWT;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Label;

import org.eclipse.core.runtime.IAdaptable;

import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.jface.layout.PixelConverter;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.ui.IWorkingSet;

import org.eclipse.search.internal.ui.SearchMessages;
import org.eclipse.search.internal.ui.util.FileTypeEditor;
import org.eclipse.search.internal.ui.util.SWTUtil;
import org.eclipse.search.ui.ISearchPageContainer;
import org.eclipse.search.ui.text.FileTextSearchScope;

public class FileSearchScopeConfigurationBlock {

	public static abstract class FileSearchScopeConfigurationBlockListener {
		public abstract void extensionsTextChanged();

		public abstract void derivedSelectionChanged();
	}

	private final FileSearchScopeConfigurationBlockListener fListener;

	private ISearchPageContainer fContainer;
	private Combo fExtensions;
	private Button fSearchDerivedCheckbox;
	private FileTypeEditor fFileTypeEditor;
	private boolean fSearchDerived;
	private Composite fControl;

	public FileSearchScopeConfigurationBlock(FileSearchScopeConfigurationBlockListener listener) {
		fListener= listener;
	}

	public void setContainer(ISearchPageContainer container) {
		fContainer= container;
	}

	public String[] getExtensions() {
		return fFileTypeEditor.getFileTypes();
	}

	public String getExtensionsText() {
		return fExtensions.getText();
	}

	public void setExtensionsText(String text) {
		fExtensions.setText(text);
	}

	public void setExtensions(String[] extensions) {
		fExtensions.setItems(extensions);
	}

	public void setSearchDerived(boolean enabled) {
		fSearchDerived= enabled;
	}

	public boolean getSearchDerived() {
		return fSearchDerived;
	}

	public void setFileTypes(String[] types) {
		fFileTypeEditor.setFileTypes(types);
	}

	public void createControl(Composite parent) {
		fControl= parent;

		addFileNameControls(parent);
	}

	public FileTextSearchScope createTextSearchScope() {
		// Setup search scope
		switch (getContainer().getSelectedScope()) {
			case ISearchPageContainer.WORKSPACE_SCOPE:
				return FileTextSearchScope.newWorkspaceScope(getExtensions(), fSearchDerived);
			case ISearchPageContainer.SELECTION_SCOPE:
				return getSelectedResourcesScope();
			case ISearchPageContainer.SELECTED_PROJECTS_SCOPE:
				return getEnclosingProjectScope();
			case ISearchPageContainer.WORKING_SET_SCOPE:
				IWorkingSet[] workingSets= getContainer().getSelectedWorkingSets();
				return FileTextSearchScope.newSearchScope(workingSets, getExtensions(), fSearchDerived);
			default:
				// unknown scope
				return FileTextSearchScope.newWorkspaceScope(getExtensions(), fSearchDerived);
		}
	}

	private FileTextSearchScope getSelectedResourcesScope() {
		HashSet resources= new HashSet();
		ISelection sel= getContainer().getSelection();
		if (sel instanceof IStructuredSelection && !sel.isEmpty()) {
			Iterator iter= ((IStructuredSelection)sel).iterator();
			while (iter.hasNext()) {
				Object curr= iter.next();
				if (curr instanceof IWorkingSet) {
					IWorkingSet workingSet= (IWorkingSet)curr;
					if (workingSet.isAggregateWorkingSet() && workingSet.isEmpty()) {
						return FileTextSearchScope.newWorkspaceScope(getExtensions(), fSearchDerived);
					}
					IAdaptable[] elements= workingSet.getElements();
					for (int i= 0; i < elements.length; i++) {
						IResource resource= (IResource)elements[i].getAdapter(IResource.class);
						if (resource != null && resource.isAccessible()) {
							resources.add(resource);
						}
					}
				} else if (curr instanceof IAdaptable) {
					IResource resource= (IResource)((IAdaptable)curr).getAdapter(IResource.class);
					if (resource != null && resource.isAccessible()) {
						resources.add(resource);
					}
				}
			}
		}
		IResource[] arr= (IResource[])resources.toArray(new IResource[resources.size()]);
		return FileTextSearchScope.newSearchScope(arr, getExtensions(), fSearchDerived);
	}

	private FileTextSearchScope getEnclosingProjectScope() {
		String[] enclosingProjectName= getContainer().getSelectedProjectNames();
		if (enclosingProjectName == null) {
			return FileTextSearchScope.newWorkspaceScope(getExtensions(), fSearchDerived);
		}

		IWorkspaceRoot root= ResourcesPlugin.getWorkspace().getRoot();
		IResource[] res= new IResource[enclosingProjectName.length];
		for (int i= 0; i < res.length; i++) {
			res[i]= root.getProject(enclosingProjectName[i]);
		}

		return FileTextSearchScope.newSearchScope(res, getExtensions(), fSearchDerived);
	}


	private ISearchPageContainer getContainer() {
		return fContainer;
	}

	private void addFileNameControls(Composite group) {
		// grid layout with 2 columns

		// Line with label, combo and button
		Label label= new Label(group, SWT.LEAD);
		label.setText(SearchMessages.SearchPage_fileNamePatterns_text);
		label.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, false, false, 2, 1));
		label.setFont(group.getFont());

		fExtensions= new Combo(group, SWT.SINGLE | SWT.BORDER);
		fExtensions.addModifyListener(new ModifyListener() {
			public void modifyText(ModifyEvent e) {
				fListener.extensionsTextChanged();
			}
		});
		GridData data= new GridData(GridData.FILL, GridData.FILL, true, false, 1, 1);
		data.widthHint= convertWidthInCharsToPixels(50);
		fExtensions.setLayoutData(data);
		fExtensions.setFont(group.getFont());

		Button button= new Button(group, SWT.PUSH);
		button.setText(SearchMessages.SearchPage_browse);
		GridData gridData= new GridData(SWT.BEGINNING, SWT.CENTER, false, false, 1, 1);
		gridData.widthHint= SWTUtil.getButtonWidthHint(button);
		button.setLayoutData(gridData);
		button.setFont(group.getFont());

		fFileTypeEditor= new FileTypeEditor(fExtensions, button);

		// Text line which explains the special characters
		Label description= new Label(group, SWT.LEAD);
		description.setText(SearchMessages.SearchPage_fileNamePatterns_hint);
		description.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, false, false, 2, 1));
		description.setFont(group.getFont());

		fSearchDerivedCheckbox= new Button(group, SWT.CHECK);
		fSearchDerivedCheckbox.setText(SearchMessages.TextSearchPage_searchDerived_label);

		fSearchDerivedCheckbox.setSelection(fSearchDerived);
		fSearchDerivedCheckbox.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				fSearchDerived= fSearchDerivedCheckbox.getSelection();
				fListener.derivedSelectionChanged();
			}
		});
		fSearchDerivedCheckbox.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, false, false, 2, 1));
		fSearchDerivedCheckbox.setFont(group.getFont());
	}

	private int convertWidthInCharsToPixels(int width) {
		return new PixelConverter(fControl).convertWidthInCharsToPixels(width);
	}

}

Return to bug 191432

Lines 196-201 Link Here

(-)search/org/eclipse/search/internal/ui/SearchMessages.java (+11 lines)
196	public static String RemovePotentialMatchesAction_dialog_title;	196	public static String RemovePotentialMatchesAction_dialog_title;
197	public static String RemovePotentialMatchesAction_dialog_message;	197	public static String RemovePotentialMatchesAction_dialog_message;
198	public static String OpenWithMenu_label;	198	public static String OpenWithMenu_label;
		199
		200	public static String SpellingSearchPage_spellingEngineDropDown_label;
		201	public static String SpellingSearchPage_spellingEnginePreferencePage_link;
		202	public static String SpellingSearchQuery_query_label;
		203	public static String SpellingSearchQuery_result11_label;
		204	public static String SpellingSearchQuery_result1n_label;
		205	public static String SpellingSearchQuery_resultn1_label;
		206	public static String SpellingSearchQuery_resultnn_label;
		207	public static String SpellingSearchResultPage_fixProblemMenu_label;
		208
		209
199	static {	210	static {
200	NLS.initializeMessages(BUNDLE_NAME, SearchMessages.class);	211	NLS.initializeMessages(BUNDLE_NAME, SearchMessages.class);
201	}	212	}

Lines 394-397 Link Here

(-)plugin.xml (+26 lines)
394	point="org.eclipse.core.runtime.preferences">	394	point="org.eclipse.core.runtime.preferences">
395	<initializer class="org.eclipse.search.internal.ui.SearchPreferenceInitializer"/>	395	<initializer class="org.eclipse.search.internal.ui.SearchPreferenceInitializer"/>
396	</extension>	396	</extension>
		397
		398	<!--
		399	Spelling Problem Search
		400	-->
		401
		402	<extension
		403	point="org.eclipse.search.searchPages">
		404	<page
		405	canSearchEnclosingProjects="true"
		406	class="org.eclipse.search.internal.ui.spelling.SpellingSearchPage"
		407	enabled="true"
		408	id="org.eclipse.ui.workbench.texteditor.spelling.searchPage"
		409	label="Spelling Problems"
		410	showScopeSection="true">
		411	</page>
		412	</extension>
		413
		414	<extension
		415	point="org.eclipse.search.searchResultViewPages">
		416	<viewPage
		417	class="org.eclipse.search.internal.ui.spelling.SpellingSearchResultPage"
		418	id="org.eclipse.ui.workbench.texteditor.spelling.searchResultPage"
		419	searchResultClass="org.eclipse.search.internal.ui.spelling.SpellingSearchResult">
		420	</viewPage>
		421	</extension>
		422
397	</plugin>	423	</plugin>

Lines 29-42 Link Here

(-)search/org/eclipse/search/internal/ui/text/FileSearchQuery.java (-2 / +8 lines)
29	import org.eclipse.search.internal.core.text.PatternConstructor;	29	import org.eclipse.search.internal.core.text.PatternConstructor;
30	import org.eclipse.search.internal.ui.Messages;	30	import org.eclipse.search.internal.ui.Messages;
31	import org.eclipse.search.internal.ui.SearchMessages;	31	import org.eclipse.search.internal.ui.SearchMessages;
32	import org.eclipse.search.ui.ISearchQuery;
33	import org.eclipse.search.ui.ISearchResult;	32	import org.eclipse.search.ui.ISearchResult;
34	import org.eclipse.search.ui.text.AbstractTextSearchResult;	33	import org.eclipse.search.ui.text.AbstractTextSearchResult;
35	import org.eclipse.search.ui.text.FileTextSearchScope;	34	import org.eclipse.search.ui.text.FileTextSearchScope;
36	import org.eclipse.search.ui.text.Match;	35	import org.eclipse.search.ui.text.Match;
37		36
38		37
39	public class FileSearchQuery implements ISearchQuery {	38	public class FileSearchQuery implements IFileSearchQuery {
40		39
41	private final static class TextSearchResultCollector extends TextSearchRequestor {	40	private final static class TextSearchResultCollector extends TextSearchRequestor {
42		41
Lines 275-278 Link Here
275	}	274	}
276	return fResult;	275	return fResult;
277	}	276	}
		277
		278	/**
		279	* {@inheritDoc}
		280	*/
		281	public boolean isShowLineMatches() {
		282	return !isFileNameSearch();
		283	}
278	}	284	}

Lines 17-23 Link Here

(-)search/org/eclipse/search/internal/ui/text/TextSearchPage.java (-142 / +28 lines)
17	import java.io.IOException;	17	import java.io.IOException;
18	import java.io.StringReader;	18	import java.io.StringReader;
19	import java.util.ArrayList;	19	import java.util.ArrayList;
20	import java.util.HashSet;
21	import java.util.Iterator;	20	import java.util.Iterator;
22	import java.util.List;	21	import java.util.List;
23	import java.util.regex.PatternSyntaxException;	22	import java.util.regex.PatternSyntaxException;
Lines 38-50 Link Here
38		37
39	import org.eclipse.core.runtime.Assert;	38	import org.eclipse.core.runtime.Assert;
40	import org.eclipse.core.runtime.CoreException;	39	import org.eclipse.core.runtime.CoreException;
41	import org.eclipse.core.runtime.IAdaptable;
42	import org.eclipse.core.runtime.IStatus;	40	import org.eclipse.core.runtime.IStatus;
43		41
44	import org.eclipse.core.resources.IResource;
45	import org.eclipse.core.resources.IWorkspaceRoot;
46	import org.eclipse.core.resources.ResourcesPlugin;
47
48	import org.eclipse.jface.dialogs.Dialog;	42	import org.eclipse.jface.dialogs.Dialog;
49	import org.eclipse.jface.dialogs.DialogPage;	43	import org.eclipse.jface.dialogs.DialogPage;
50	import org.eclipse.jface.dialogs.ErrorDialog;	44	import org.eclipse.jface.dialogs.ErrorDialog;
Lines 52-58 Link Here
52	import org.eclipse.jface.fieldassist.ComboContentAdapter;	46	import org.eclipse.jface.fieldassist.ComboContentAdapter;
53	import org.eclipse.jface.resource.JFaceColors;	47	import org.eclipse.jface.resource.JFaceColors;
54	import org.eclipse.jface.viewers.ISelection;	48	import org.eclipse.jface.viewers.ISelection;
55	import org.eclipse.jface.viewers.IStructuredSelection;
56		49
57	import org.eclipse.jface.text.FindReplaceDocumentAdapter;	50	import org.eclipse.jface.text.FindReplaceDocumentAdapter;
58	import org.eclipse.jface.text.FindReplaceDocumentAdapterContentProposalProvider;	51	import org.eclipse.jface.text.FindReplaceDocumentAdapterContentProposalProvider;
Lines 71-78 Link Here
71	import org.eclipse.search.internal.ui.ISearchHelpContextIds;	64	import org.eclipse.search.internal.ui.ISearchHelpContextIds;
72	import org.eclipse.search.internal.ui.SearchMessages;	65	import org.eclipse.search.internal.ui.SearchMessages;
73	import org.eclipse.search.internal.ui.SearchPlugin;	66	import org.eclipse.search.internal.ui.SearchPlugin;
		67	import org.eclipse.search.internal.ui.text.FileSearchScopeConfigurationBlock.FileSearchScopeConfigurationBlockListener;
74	import org.eclipse.search.internal.ui.util.FileTypeEditor;	68	import org.eclipse.search.internal.ui.util.FileTypeEditor;
75	import org.eclipse.search.internal.ui.util.SWTUtil;
76	import org.eclipse.search.ui.IReplacePage;	69	import org.eclipse.search.ui.IReplacePage;
77	import org.eclipse.search.ui.ISearchPage;	70	import org.eclipse.search.ui.ISearchPage;
78	import org.eclipse.search.ui.ISearchPageContainer;	71	import org.eclipse.search.ui.ISearchPageContainer;
Lines 103-122 Link Here
103	private boolean fFirstTime= true;	96	private boolean fFirstTime= true;
104	private boolean fIsCaseSensitive;	97	private boolean fIsCaseSensitive;
105	private boolean fIsRegExSearch;	98	private boolean fIsRegExSearch;
106	private boolean fSearchDerived;
107		99
108	private Combo fPattern;	100	private Combo fPattern;
109	private Button fIsCaseSensitiveCheckbox;	101	private Button fIsCaseSensitiveCheckbox;
110	private Combo fExtensions;
111	private Button fIsRegExCheckbox;	102	private Button fIsRegExCheckbox;
112	private CLabel fStatusLabel;	103	private CLabel fStatusLabel;
113	private Button fSearchDerivedCheckbox;
114		104
115	private ISearchPageContainer fContainer;	105	private ISearchPageContainer fContainer;
116	private FileTypeEditor fFileTypeEditor;
117		106
118	private ContentAssistCommandAdapter fPatterFieldContentAssist;	107	private ContentAssistCommandAdapter fPatterFieldContentAssist;
119		108
		109	private FileSearchScopeConfigurationBlock fScopeConfigurationBlock;
		110
120	private static class SearchPatternData {	111	private static class SearchPatternData {
121	public final boolean isCaseSensitive;	112	public final boolean isCaseSensitive;
122	public final boolean isRegExSearch;	113	public final boolean isRegExSearch;
Lines 215-225 Link Here
215	}	206	}
216	}	207	}
217		208
		209	public TextSearchPage() {
		210	fScopeConfigurationBlock= new FileSearchScopeConfigurationBlock(new FileSearchScopeConfigurationBlockListener() {
		211	public void extensionsTextChanged() {
		212	updateOKStatus();
		213	}
		214
		215	public void derivedSelectionChanged() {
		216	writeConfiguration();
		217	}
		218	});
		219	}
		220
218	//---- Action Handling ------------------------------------------------	221	//---- Action Handling ------------------------------------------------
219		222
220	private ISearchQuery newQuery() throws CoreException {	223	private ISearchQuery newQuery() throws CoreException {
221	SearchPatternData data= getPatternData();	224	SearchPatternData data= getPatternData();
222	TextSearchPageInput input= new TextSearchPageInput(data.textPattern, data.isCaseSensitive, data.isRegExSearch, createTextSearchScope());	225	TextSearchPageInput input= new TextSearchPageInput(data.textPattern, data.isCaseSensitive, data.isRegExSearch, fScopeConfigurationBlock.createTextSearchScope());
223	return TextSearchQueryProvider.getPreferred().createQuery(input);	226	return TextSearchQueryProvider.getPreferred().createQuery(input);
224	}	227	}
225		228
Lines 269-339 Link Here
269	return fPattern.getText();	272	return fPattern.getText();
270	}	273	}
271		274
272	public FileTextSearchScope createTextSearchScope() {
273	// Setup search scope
274	switch (getContainer().getSelectedScope()) {
275	case ISearchPageContainer.WORKSPACE_SCOPE:
276	return FileTextSearchScope.newWorkspaceScope(getExtensions(), fSearchDerived);
277	case ISearchPageContainer.SELECTION_SCOPE:
278	return getSelectedResourcesScope();
279	case ISearchPageContainer.SELECTED_PROJECTS_SCOPE:
280	return getEnclosingProjectScope();
281	case ISearchPageContainer.WORKING_SET_SCOPE:
282	IWorkingSet[] workingSets= getContainer().getSelectedWorkingSets();
283	return FileTextSearchScope.newSearchScope(workingSets, getExtensions(), fSearchDerived);
284	default:
285	// unknown scope
286	return FileTextSearchScope.newWorkspaceScope(getExtensions(), fSearchDerived);
287	}
288	}
289
290	private FileTextSearchScope getSelectedResourcesScope() {
291	HashSet resources= new HashSet();
292	ISelection sel= getContainer().getSelection();
293	if (sel instanceof IStructuredSelection && !sel.isEmpty()) {
294	Iterator iter= ((IStructuredSelection) sel).iterator();
295	while (iter.hasNext()) {
296	Object curr= iter.next();
297	if (curr instanceof IWorkingSet) {
298	IWorkingSet workingSet= (IWorkingSet) curr;
299	if (workingSet.isAggregateWorkingSet() && workingSet.isEmpty()) {
300	return FileTextSearchScope.newWorkspaceScope(getExtensions(), fSearchDerived);
301	}
302	IAdaptable[] elements= workingSet.getElements();
303	for (int i= 0; i < elements.length; i++) {
304	IResource resource= (IResource)elements[i].getAdapter(IResource.class);
305	if (resource != null && resource.isAccessible()) {
306	resources.add(resource);
307	}
308	}
309	} else if (curr instanceof IAdaptable) {
310	IResource resource= (IResource) ((IAdaptable)curr).getAdapter(IResource.class);
311	if (resource != null && resource.isAccessible()) {
312	resources.add(resource);
313	}
314	}
315	}
316	}
317	IResource[] arr= (IResource[]) resources.toArray(new IResource[resources.size()]);
318	return FileTextSearchScope.newSearchScope(arr, getExtensions(), fSearchDerived);
319	}
320
321	private FileTextSearchScope getEnclosingProjectScope() {
322	String[] enclosingProjectName= getContainer().getSelectedProjectNames();
323	if (enclosingProjectName == null) {
324	return FileTextSearchScope.newWorkspaceScope(getExtensions(), fSearchDerived);
325	}
326
327	IWorkspaceRoot root= ResourcesPlugin.getWorkspace().getRoot();
328	IResource[] res= new IResource[enclosingProjectName.length];
329	for (int i= 0; i < res.length; i++) {
330	res[i]= root.getProject(enclosingProjectName[i]);
331	}
332
333	return FileTextSearchScope.newSearchScope(res, getExtensions(), fSearchDerived);
334	}
335
336
337	private SearchPatternData findInPrevious(String pattern) {	275	private SearchPatternData findInPrevious(String pattern) {
338	for (Iterator iter= fPreviousSearchPatterns.iterator(); iter.hasNext();) {	276	for (Iterator iter= fPreviousSearchPatterns.iterator(); iter.hasNext();) {
339	SearchPatternData element= (SearchPatternData) iter.next();	277	SearchPatternData element= (SearchPatternData) iter.next();
Lines 358-364 Link Here
358	getPattern(),	296	getPattern(),
359	isCaseSensitive(),	297	isCaseSensitive(),
360	fIsRegExCheckbox.getSelection(),	298	fIsRegExCheckbox.getSelection(),
361	getExtensions(),	299	fScopeConfigurationBlock.getExtensions(),
362	getContainer().getSelectedScope(),	300	getContainer().getSelectedScope(),
363	getContainer().getSelectedWorkingSets());	301	getContainer().getSelectedWorkingSets());
364	fPreviousSearchPatterns.add(0, match);	302	fPreviousSearchPatterns.add(0, match);
Lines 385-394 Link Here
385	return patterns;	323	return patterns;
386	}	324	}
387		325
388	private String[] getExtensions() {
389	return fFileTypeEditor.getFileTypes();
390	}
391
392	private boolean isCaseSensitive() {	326	private boolean isCaseSensitive() {
393	return fIsCaseSensitiveCheckbox.getSelection();	327	return fIsCaseSensitiveCheckbox.getSelection();
394	}	328	}
Lines 402-414 Link Here
402	fFirstTime= false;	336	fFirstTime= false;
403	// Set item and text here to prevent page from resizing	337	// Set item and text here to prevent page from resizing
404	fPattern.setItems(getPreviousSearchPatterns());	338	fPattern.setItems(getPreviousSearchPatterns());
405	fExtensions.setItems(getPreviousExtensions());	339	fScopeConfigurationBlock.setExtensions(getPreviousExtensions());
406	// if (fExtensions.getItemCount() == 0) {	340	// if (fExtensions.getItemCount() == 0) {
407	// loadFilePatternDefaults();	341	// loadFilePatternDefaults();
408	// }	342	// }
409	if (!initializePatternControl()) {	343	if (!initializePatternControl()) {
410	fPattern.select(0);	344	fPattern.select(0);
411	fExtensions.setText("*"); //$NON-NLS-1$	345	fScopeConfigurationBlock.setExtensionsText("*"); //$NON-NLS-1$
412	handleWidgetSelected();	346	handleWidgetSelected();
413	}	347	}
414	}	348	}
Lines 420-426 Link Here
420		354
421	final void updateOKStatus() {	355	final void updateOKStatus() {
422	boolean regexStatus= validateRegex();	356	boolean regexStatus= validateRegex();
423	boolean hasFilePattern= fExtensions.getText().length() > 0;	357	boolean hasFilePattern= fScopeConfigurationBlock.getExtensionsText().length() > 0;
424	getContainer().setPerformActionEnabled(regexStatus && hasFilePattern);	358	getContainer().setPerformActionEnabled(regexStatus && hasFilePattern);
425	}	359	}
426		360
Lines 443-449 Link Here
443	data.heightHint= convertHeightInCharsToPixels(1) / 3;	377	data.heightHint= convertHeightInCharsToPixels(1) / 3;
444	separator.setLayoutData(data);	378	separator.setLayoutData(data);
445		379
446	addFileNameControls(result);	380	fScopeConfigurationBlock.createControl(result);
447		381
448	setControl(result);	382	setControl(result);
449	Dialog.applyDialogFont(result);	383	Dialog.applyDialogFont(result);
Lines 558-564 Link Here
558	fIsCaseSensitiveCheckbox.setSelection(patternData.isCaseSensitive);	492	fIsCaseSensitiveCheckbox.setSelection(patternData.isCaseSensitive);
559	fIsRegExCheckbox.setSelection(patternData.isRegExSearch);	493	fIsRegExCheckbox.setSelection(patternData.isRegExSearch);
560	fPattern.setText(patternData.textPattern);	494	fPattern.setText(patternData.textPattern);
561	fFileTypeEditor.setFileTypes(patternData.fileNamePatterns);	495	fScopeConfigurationBlock.setFileTypes(patternData.fileNamePatterns);
562	if (patternData.workingSets != null)	496	if (patternData.workingSets != null)
563	getContainer().setSelectedWorkingSets(patternData.workingSets);	497	getContainer().setSelectedWorkingSets(patternData.workingSets);
564	else	498	else
Lines 576-588 Link Here
576	fPattern.setText(insertEscapeChars(text));	510	fPattern.setText(insertEscapeChars(text));
577		511
578	if (getPreviousExtensions().length > 0) {	512	if (getPreviousExtensions().length > 0) {
579	fExtensions.setText(getPreviousExtensions()[0]);	513	fScopeConfigurationBlock.setExtensionsText(getPreviousExtensions()[0]);
580	} else {	514	} else {
581	String extension= getExtensionFromEditor();	515	String extension= getExtensionFromEditor();
582	if (extension != null)	516	if (extension != null)
583	fExtensions.setText(extension);	517	fScopeConfigurationBlock.setExtensionsText(extension);
584	else	518	else
585	fExtensions.setText("*"); //$NON-NLS-1$	519	fScopeConfigurationBlock.setExtensionsText("*"); //$NON-NLS-1$
586	}	520	}
587	return true;	521	return true;
588	}	522	}
Lines 634-694 Link Here
634	return null;	568	return null;
635	}	569	}
636		570
637	private void addFileNameControls(Composite group) {
638	// grid layout with 2 columns
639
640	// Line with label, combo and button
641	Label label= new Label(group, SWT.LEAD);
642	label.setText(SearchMessages.SearchPage_fileNamePatterns_text);
643	label.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, false, false, 2, 1));
644	label.setFont(group.getFont());
645
646	fExtensions= new Combo(group, SWT.SINGLE \| SWT.BORDER);
647	fExtensions.addModifyListener(new ModifyListener() {
648	public void modifyText(ModifyEvent e) {
649	updateOKStatus();
650	}
651	});
652	GridData data= new GridData(GridData.FILL, GridData.FILL, true, false, 1, 1);
653	data.widthHint= convertWidthInCharsToPixels(50);
654	fExtensions.setLayoutData(data);
655	fExtensions.setFont(group.getFont());
656
657	Button button= new Button(group, SWT.PUSH);
658	button.setText(SearchMessages.SearchPage_browse);
659	GridData gridData= new GridData(SWT.BEGINNING, SWT.CENTER, false, false, 1, 1);
660	gridData.widthHint= SWTUtil.getButtonWidthHint(button);
661	button.setLayoutData(gridData);
662	button.setFont(group.getFont());
663
664	fFileTypeEditor= new FileTypeEditor(fExtensions, button);
665
666	// Text line which explains the special characters
667	Label description= new Label(group, SWT.LEAD);
668	description.setText(SearchMessages.SearchPage_fileNamePatterns_hint);
669	description.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, false, false, 2, 1));
670	description.setFont(group.getFont());
671
672	fSearchDerivedCheckbox= new Button(group, SWT.CHECK);
673	fSearchDerivedCheckbox.setText(SearchMessages.TextSearchPage_searchDerived_label);
674
675	fSearchDerivedCheckbox.setSelection(fSearchDerived);
676	fSearchDerivedCheckbox.addSelectionListener(new SelectionAdapter() {
677	public void widgetSelected(SelectionEvent e) {
678	fSearchDerived= fSearchDerivedCheckbox.getSelection();
679	writeConfiguration();
680	}
681	});
682	fSearchDerivedCheckbox.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, false, false, 2, 1));
683	fSearchDerivedCheckbox.setFont(group.getFont());
684	}
685
686	/**	571	/**
687	* Sets the search page's container.	572	* Sets the search page's container.
688	* @param container the container to set	573	* @param container the container to set
689	*/	574	*/
690	public void setContainer(ISearchPageContainer container) {	575	public void setContainer(ISearchPageContainer container) {
691	fContainer= container;	576	fContainer= container;
		577	fScopeConfigurationBlock.setContainer(container);
692	}	578	}
693		579
694	private ISearchPageContainer getContainer() {	580	private ISearchPageContainer getContainer() {
Lines 727-733 Link Here
727	IDialogSettings s= getDialogSettings();	613	IDialogSettings s= getDialogSettings();
728	fIsCaseSensitive= s.getBoolean(STORE_CASE_SENSITIVE);	614	fIsCaseSensitive= s.getBoolean(STORE_CASE_SENSITIVE);
729	fIsRegExSearch= s.getBoolean(STORE_IS_REG_EX_SEARCH);	615	fIsRegExSearch= s.getBoolean(STORE_IS_REG_EX_SEARCH);
730	fSearchDerived= s.getBoolean(STORE_SEARCH_DERIVED);	616	fScopeConfigurationBlock.setSearchDerived(s.getBoolean(STORE_SEARCH_DERIVED));
731		617
732	try {	618	try {
733	int historySize= s.getInt(STORE_HISTORY_SIZE);	619	int historySize= s.getInt(STORE_HISTORY_SIZE);
Lines 752-758 Link Here
752	IDialogSettings s= getDialogSettings();	638	IDialogSettings s= getDialogSettings();
753	s.put(STORE_CASE_SENSITIVE, fIsCaseSensitive);	639	s.put(STORE_CASE_SENSITIVE, fIsCaseSensitive);
754	s.put(STORE_IS_REG_EX_SEARCH, fIsRegExSearch);	640	s.put(STORE_IS_REG_EX_SEARCH, fIsRegExSearch);
755	s.put(STORE_SEARCH_DERIVED, fSearchDerived);	641	s.put(STORE_SEARCH_DERIVED, fScopeConfigurationBlock.getSearchDerived());
756		642
757	int historySize= Math.min(fPreviousSearchPatterns.size(), HISTORY_SIZE);	643	int historySize= Math.min(fPreviousSearchPatterns.size(), HISTORY_SIZE);
758	s.put(STORE_HISTORY_SIZE, historySize);	644	s.put(STORE_HISTORY_SIZE, historySize);

Added Link Here

(-)search/org/eclipse/search/internal/ui/spelling/SpellingSearchPage.java (+138 lines)
1	/*******************************************************************************
2	* Copyright (c) 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.search.internal.ui.spelling;
12
13	import org.eclipse.swt.SWT;
14	import org.eclipse.swt.events.SelectionAdapter;
15	import org.eclipse.swt.events.SelectionEvent;
16	import org.eclipse.swt.layout.GridData;
17	import org.eclipse.swt.layout.GridLayout;
18	import org.eclipse.swt.widgets.Combo;
19	import org.eclipse.swt.widgets.Composite;
20	import org.eclipse.swt.widgets.Label;
21	import org.eclipse.swt.widgets.Link;
22
23	import org.eclipse.jface.dialogs.DialogPage;
24	import org.eclipse.jface.preference.PreferenceDialog;
25	import org.eclipse.jface.preference.PreferenceStore;
26
27	import org.eclipse.ui.dialogs.PreferencesUtil;
28
29	import org.eclipse.ui.texteditor.spelling.SpellingEngineDescriptor;
30	import org.eclipse.ui.texteditor.spelling.SpellingService;
31
32	import org.eclipse.search.internal.ui.SearchMessages;
33	import org.eclipse.search.internal.ui.text.FileSearchScopeConfigurationBlock;
34	import org.eclipse.search.internal.ui.text.FileSearchScopeConfigurationBlock.FileSearchScopeConfigurationBlockListener;
35	import org.eclipse.search.ui.ISearchPage;
36	import org.eclipse.search.ui.ISearchPageContainer;
37	import org.eclipse.search.ui.NewSearchUI;
38
39	public class SpellingSearchPage extends DialogPage implements ISearchPage {
40
41	private final SpellingEngineDescriptor[] fSpellingEngines;
42
43	private SpellingEngineDescriptor fSelectedEngine;
44	private FileSearchScopeConfigurationBlock fScopeConfigurationBlock;
45	private ISearchPageContainer fContainer;
46
47	public SpellingSearchPage() {
48	fScopeConfigurationBlock= new FileSearchScopeConfigurationBlock(new FileSearchScopeConfigurationBlockListener() {
49	public void extensionsTextChanged() {
50	boolean hasFilePattern= fScopeConfigurationBlock.getExtensionsText().length() > 0;
51	fContainer.setPerformActionEnabled(hasFilePattern);
52	}
53
54	public void derivedSelectionChanged() {
55	}
56	});
57
58	SpellingService spellingService= new SpellingService(new PreferenceStore());
59	fSpellingEngines= spellingService.getSpellingEngineDescriptors();
60	fSelectedEngine= spellingService.getDefaultSpellingEngineDescriptor();
61	}
62
63	/**
64	* {@inheritDoc}
65	*/
66	public boolean performAction() {
67	SpellingSearchQuery query= new SpellingSearchQuery(fScopeConfigurationBlock.createTextSearchScope(), fSelectedEngine.getId());
68	NewSearchUI.runQueryInBackground(query);
69	return true;
70	}
71
72	/**
73	* {@inheritDoc}
74	*/
75	public void setContainer(ISearchPageContainer container) {
76	fContainer= container;
77	fScopeConfigurationBlock.setContainer(container);
78	}
79
80	/**
81	* {@inheritDoc}
82	*/
83	public void createControl(Composite parent) {
84	initializeDialogUnits(parent);
85
86	Composite control= new Composite(parent, SWT.NONE);
87	control.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
88	control.setLayout(new GridLayout(2, false));
89
90	if (fSpellingEngines.length > 1) {
91	Label label= new Label(control, SWT.NONE);
92	label.setLayoutData(new GridData(SWT.BEGINNING, SWT.CENTER, false, false, 2, 1));
93	label.setText(SearchMessages.SpellingSearchPage_spellingEngineDropDown_label);
94
95	final Combo combo= new Combo(control, SWT.DROP_DOWN \| SWT.READ_ONLY);
96	combo.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 2, 1));
97
98	int index= 0;
99	String[] items= new String[fSpellingEngines.length];
100	for (int i= 0; i < items.length; i++) {
101	items[i]= fSpellingEngines[i].getLabel();
102	if (fSpellingEngines[i] == fSelectedEngine)
103	index= i;
104	}
105	combo.setItems(items);
106	combo.select(index);
107	combo.addSelectionListener(new SelectionAdapter() {
108	/**
109	* {@inheritDoc}
110	*/
111	public void widgetSelected(SelectionEvent e) {
112	fSelectedEngine= fSpellingEngines[combo.getSelectionIndex()];
113	}
114	});
115	}
116
117	fScopeConfigurationBlock.createControl(control);
118	fScopeConfigurationBlock.setExtensionsText("*"); //$NON-NLS-1$
119
120	Link link= new Link(control, SWT.NONE);
121	GridData layoutData= new GridData(SWT.END, SWT.CENTER, false, false, 2, 1);
122	layoutData.verticalIndent= 15;
123	link.setLayoutData(layoutData);
124	link.setText(SearchMessages.SpellingSearchPage_spellingEnginePreferencePage_link);
125	link.addSelectionListener(new SelectionAdapter() {
126	/**
127	* {@inheritDoc}
128	*/
129	public void widgetSelected(SelectionEvent e) {
130	PreferenceDialog dialog= PreferencesUtil.createPreferenceDialogOn(getShell(), "org.eclipse.ui.editors.preferencePages.Spelling", new String[0], null); //$NON-NLS-1$
131	dialog.open();
132	}
133	});
134
135	setControl(control);
136	}
137
138	}