Attachment #27653 for bug #102081

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




import org.eclipse.jface.viewers.IDoubleClickListener;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TreeViewer;

    private static final String STORE_SELECTED_VIEW_ID = DIALOG_SETTING_SECTION_NAME
            + ".STORE_SELECTED_VIEW_ID"; //$NON-NLS-1$    

    private FilteredTree filteredTree;

    private Button okButton;


        Composite composite = (Composite) super.createDialogArea(parent);
        composite.setFont(parent.getFont());

        createFilteredTreeViewer(composite);

        layoutTopControl(filteredTree.getViewer().getControl());

        // Restore the last state
        restoreWidgetValues();

    }

    /**
     * Create a new filtered tree viewer in the parent.
     * 
     * @param parent the parent <code>Composite</code>.
     */
    private void createFilteredTreeViewer(Composite parent) {
    	PatternItemFilter filter = new ViewPatternFilter(true); 
    	int styleBits = SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER;
		filteredTree = new FilteredTree(parent, styleBits, filter);
		TreeViewer treeViewer = filteredTree.getViewer();
		treeViewer.setLabelProvider(new ViewLabelProvider());
		treeViewer.setContentProvider(new ViewContentProvider());
		treeViewer.setSorter(new ViewSorter((ViewRegistry) viewReg));
		treeViewer.setInput(viewReg);
		treeViewer.addSelectionChangedListener(this);
		treeViewer.addDoubleClickListener(this);
		treeViewer.addFilter(new CapabilityFilter());
		
		filteredTree.setBackground(parent.getDisplay().getSystemColor(SWT.COLOR_WIDGET_BACKGROUND));
		filteredTree.setInitialText(WorkbenchMessages.WorkbenchPreferenceDialog_FilterMessage);

		//if the tree has only one or zero views, make the combo area disable
		if(hasAtMostOneView(filteredTree.getViewer())){
			filteredTree.getFilterControl().setEnabled(false);
		}
		
		applyDialogFont(filteredTree);
    }

	/**
	 * Return whether or not there are less than two views in the list.
	 * @param tree
	 * @return <code>true</code> if there are less than two
	 * views in the list.
	 */
	private boolean hasAtMostOneView(TreeViewer tree){
		ITreeContentProvider contentProvider = (ITreeContentProvider ) tree.getContentProvider();
		Object[] children= contentProvider.getElements(tree.getInput());
		
		if(children.length <= 1){
			if(children.length == 0)
				return true;
			return !contentProvider.hasChildren(children[0]);				
		}
		return false;
	}

    /*
     * (non-Javadoc)

    public void doubleClick(DoubleClickEvent event) {
        IStructuredSelection s = (IStructuredSelection) event.getSelection();
        Object element = s.getFirstElement();
        if (filteredTree.getViewer().isExpandable(element)) {
            filteredTree.getViewer().setExpandedState(element, !filteredTree.getViewer().getExpandedState(element));
        } else if (viewDescs.length > 0) {
            saveWidgetValues();
            setReturnCode(OK);

        }

        if (!categoriesToExpand.isEmpty())
            filteredTree.getViewer().setExpandedElements(categoriesToExpand.toArray());
        
        String selectedViewId = settings.get(STORE_SELECTED_VIEW_ID);
        if (selectedViewId != null) {
            IViewDescriptor viewDesc = reg.find(selectedViewId);
            if (viewDesc != null) {
                filteredTree.getViewer().setSelection(new StructuredSelection(viewDesc), true);
            }
        }
    }

        IDialogSettings settings = getDialogSettings();

        // Collect the ids of the all expanded categories
        Object[] expandedElements = filteredTree.getViewer().getExpandedElements();
        String[] expandedCategoryIds = new String[expandedElements.length];
        for (int i = 0; i < expandedElements.length; ++i)
            expandedCategoryIds[i] = ((IViewCategory) expandedElements[i]).getId();




package org.eclipse.ui.internal.dialogs;

import java.text.BreakIterator;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import org.eclipse.jface.preference.IPreferenceNode;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.ui.internal.preferences.WorkbenchPreferenceExtensionNode;

/**
 * Abstract class that handles filtering items based on a supplied
 * matching string.
 * 
 * @since 3.1
 * 
 */
public abstract class PatternItemFilter extends PatternFilter {

	/**
	 * this cache is needed because
	 * WorkbenchPreferenceExtensionNode.getKeywordLabels() is expensive. When it
	 * tracks keyword changes effectivly than this cache can be removed.
	 */
	private Map keywordCache = new HashMap();

	protected boolean matchItem;

	/**

		super();
		matchItem = isMatchItem;
	}
	
	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.viewers.ViewerFilter#select(org.eclipse.jface.viewers.Viewer,
	 *      java.lang.Object, java.lang.Object)
	 */
	public boolean select(Viewer viewer, Object parentElement, Object element) {

		ITreeContentProvider contentProvider = (ITreeContentProvider) ((TreeViewer) viewer)
				.getContentProvider();

		IPreferenceNode node = (IPreferenceNode) element;
		Object[] children = contentProvider.getChildren(node);
		String text = node.getLabelText();

		if(wordMatches(text))
			return true;
		
		if (matchItem) {

			// Will return true if any subnode of the element matches the search
			if (filter(viewer, element, children).length > 0)
				return true;
		}

		if (node instanceof WorkbenchPreferenceExtensionNode) {
			WorkbenchPreferenceExtensionNode workbenchNode = (WorkbenchPreferenceExtensionNode) node;

			Collection keywordCollection = (Collection) keywordCache.get(node);
			if (keywordCollection == null) {
				keywordCollection = workbenchNode.getKeywordLabels();
				keywordCache.put(node, keywordCollection);
			}
			if (keywordCollection.isEmpty())
				return false;
			Iterator keywords = keywordCollection.iterator();
			while (keywords.hasNext()) {
				if (wordMatches((String) keywords.next()))
					return true;
			}
		}
		return false;

	}

	/**
	 * Return whether or not if any of the words in text satisfy the
	 * match critera.

	 * @return boolean <code>true</code> if one of the words in text 
	 * satisifes the match criteria.
	 */
	protected boolean wordMatches(String text) {
		
		//If the whole text matches we are all set
		if(match(text))




import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;

 */
public abstract class FilteredPreferenceDialog extends PreferenceDialog implements IWorkbenchPreferenceContainer{

	protected FilteredTree filteredTree;

	private Object pageData;
	

	 * @see org.eclipse.jface.preference.PreferenceDialog#createTreeViewer(org.eclipse.swt.widgets.Composite)
	 */
	protected TreeViewer createTreeViewer(Composite parent) {
		PatternItemFilter filter = new PreferencePatternFilter(true); 
		int styleBits = SWT.SINGLE | SWT.H_SCROLL;
		filteredTree = new FilteredTree(parent, styleBits, filter);
		GridData gd = new GridData(SWT.FILL, SWT.FILL, true, true);
		gd.horizontalIndent = IDialogConstants.HORIZONTAL_MARGIN;
		filteredTree.setBackground(parent.getDisplay().getSystemColor(SWT.COLOR_LIST_BACKGROUND));

		
		//if the tree has only one or zero pages, make the combo area disable
		if(hasAtMostOnePage(tree)){
			filteredTree.getFilterControl().setEnabled(false);
			filteredTree.getFilterCombo().setSelection(new Point(0,0));
		}
		
		




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

import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;
import org.eclipse.swt.events.FocusAdapter;
import org.eclipse.swt.events.FocusEvent;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.TraverseEvent;
import org.eclipse.swt.events.TraverseListener;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.internal.WorkbenchPlugin;

/**
 * The FilteredComboTree is a filtered tree that uses an 
 * editable combo rather than just a text.
 */
public class FilteredComboTree extends FilteredTree {

	private Combo filterCombo;
	
	private static final String SEARCHHISTORY = "search"; //$NON-NLS-1$

	//Set a number limitation of items to be saved in combo
	private static final int maxNumItems = 20;
	/**
	 * Create a new instance of the receiver.
	 * @param parent
	 * @param treeStyle
	 */
	public FilteredComboTree(Composite parent, int treeStyle) {
		super(parent, treeStyle);
	}

	/**
	 *  Create a new instance of the receiver with a supplied filter.
	 * @param parent
	 * @param treeStyle
	 * @param filter
	 */
	public FilteredComboTree(Composite parent, int treeStyle, PatternItemFilter filter) {
		super(parent, treeStyle, filter);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.internal.dialogs.FilteredTree#createFilterControl(org.eclipse.swt.widgets.Composite)
	 */
	protected void createFilterControl(Composite parent) {
		filterCombo = new Combo(parent, SWT.DROP_DOWN | SWT.BORDER);
		filterCombo.setFont(parent.getFont());
		getPreferenceSearchHistory();
		filterCombo.addTraverseListener( new TraverseListener () {
			public void keyTraversed(TraverseEvent e) {
				if (e.detail == SWT.TRAVERSE_RETURN) {
					e.doit = false;
					if (getViewer().getTree().getItemCount() == 0) {
						Display.getCurrent().beep();
						setFilterText(""); //$NON-NLS-1$
					} else {
						getViewer().getTree().setFocus();
					}
				}
			}
		});
		filterCombo.addFocusListener(new FocusAdapter(){
			/* (non-Javadoc)
			 * @see org.eclipse.swt.events.FocusAdapter#focusLost(org.eclipse.swt.events.FocusEvent)
			 */
			public void focusLost(FocusEvent e) {
				String [] textValues = filterCombo.getItems();
				String newText = filterCombo.getText();
				
				if((newText.equals(""))||(newText .equals(initialText)))//$NON-NLS-1$
					return;
			
				for (int i = 0; i < textValues.length; i++) {
					if(textValues[i].equals(newText))
						return;					
				}
					
				if(textValues.length >= maxNumItems)				
					//Discard the oldest search to get space for new search 
					filterCombo.remove(maxNumItems-1);
				
				filterCombo.add(newText,0);
			}
		});
		filterCombo.addSelectionListener(new SelectionAdapter(){
			/* (non-Javadoc)
			 * @see org.eclipse.swt.events.SelectionAdapter#widgetSelected(org.eclipse.swt.events.SelectionEvent)
			 */
			public void widgetSelected(SelectionEvent e) {
				textChanged();
			}
		});
		
		filterCombo.addDisposeListener(new DisposeListener() {
		
			/* (non-Javadoc)
			 * @see org.eclipse.swt.events.DisposeListener#widgetDisposed(org.eclipse.swt.events.DisposeEvent)
			 */
			public void widgetDisposed(DisposeEvent e) {
			   	saveDialogSettings();
			}
		});
		
		filterCombo.getAccessible().addAccessibleListener(getAccessibleListener());
		
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.internal.dialogs.FilteredTree#getFilterControl()
	 */
	public Control getFilterControl() {
		return filterCombo;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.internal.dialogs.FilteredTree#getFilterControlText()
	 */
	protected String getFilterControlText() {
		return filterCombo.getText();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.internal.dialogs.FilteredTree#setFilterText(java.lang.String)
	 */
	protected void setFilterText(String string) {
		filterCombo.setText(string);
		selectAll();
	}
	
	protected void selectAll() {
		filterCombo.setSelection(new Point(0,filterCombo.getText().length()));
	}
	
	/**
	 * Get the combo box used by the receiver.
	 * @return Combo
	 */
	public Combo getFilterCombo() {
		return filterCombo;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ui.internal.dialogs.FilteredTree#getFilterText()
	 */
	protected String getFilterText() {
		return filterCombo.getText();
	}
		
	/**
     * Return a dialog setting section for this dialog
     */
    private IDialogSettings getDialogSettings() {
        IDialogSettings settings = WorkbenchPlugin.getDefault()
                .getDialogSettings();
        IDialogSettings thisSettings = settings
                .getSection(getClass().getName());
        if (thisSettings == null)
            thisSettings = settings.addNewSection(getClass().getName());
        return thisSettings;
    }
   
	
	/**
	 * Get the preferences search history for this eclipse's start, 
	 * Note that this history will not be cleared until this eclipse closes
	 * 
	 */
	public void getPreferenceSearchHistory(){		
		IDialogSettings settings = getDialogSettings();
		String[] search = settings.getArray(SEARCHHISTORY);
		
		if(search == null)
			return;
		
		for(int i = 0; i < search.length;i++){
			filterCombo.add(search[i]);
		}
				
	}
	
	 /**
     * Saves the search history.
     */
    private void saveDialogSettings() {   
    	IDialogSettings settings =getDialogSettings();
    	
    	//If the settings contains the same key, the previous value will be replaced by new one
    	settings.put(SEARCHHISTORY,filterCombo.getItems());
               
    }
}




		implements IFontProvider {

	
	private FilteredTree filterTree;

	PreferenceBoldLabelProvider(FilteredTree filterTree) {
		this.filterTree = filterTree;
	}
	/**
	 * Using "false" to construct the filter so that this filter can filter
	 * supernodes of a matching node
	 */
	PatternItemFilter filterForBoldElements = new PreferencePatternFilter(false);

	public Font getFont(Object element) {

		String filterText = filterTree.getFilterControlText();

		// Do nothing if it's empty string
		if (!(filterText.equals("") || filterText.equals(filterTree.getInitialText()))) {//$NON-NLS-1$

			boolean initial = filterTree.getInitialText() != null
					&& filterText.equals(filterTree.getInitialText());
			if (initial) {
				filterForBoldElements.setPattern(null);
			} else {
				filterForBoldElements.setPattern(filterText);
			}

			ITreeContentProvider contentProvider = (ITreeContentProvider) filterTree.getViewer()
					.getContentProvider();
			Object parent = contentProvider.getParent(element);

			if (filterForBoldElements.select(filterTree.getViewer(), parent, element)) {
				return JFaceResources.getFontRegistry().getBold(JFaceResources.DIALOG_FONT);
			}
		}




                | GridData.GRAB_HORIZONTAL));

        createFilterControl(filterParent);
        getFilterControl().addKeyListener(new KeyAdapter() {

            /*
             * (non-Javadoc)
             * 
             * @see org.eclipse.swt.events.KeyAdapter#keyReleased(org.eclipse.swt.events.KeyEvent)
             */
            public void keyReleased(KeyEvent e) {
            	// on a CR we want to transfer focus to the list
            	if(e.keyCode == SWT.ARROW_DOWN){

                    if (!(getFilterControl() instanceof Combo)) {
                    	treeViewer.getTree().setFocus();
                    }
            	} else
            		textChanged();
            }
        });

        GridData data = new GridData(GridData.FILL_HORIZONTAL
                | GridData.GRAB_HORIZONTAL);

    public void setBackground(Color background) {
        super.setBackground(background);
        filterParent.setBackground(background);
        getFilterControl().setBackground(background);
        filterToolBar.getControl().setBackground(background);
    }





package org.eclipse.ui.internal.dialogs;

import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.ui.views.IViewCategory;
import org.eclipse.ui.views.IViewDescriptor;

/**
 * A class that handles filtering view node items based on a supplied
 * matching string.
 *  
 * @since 3.2
 *
 */
public class ViewPatternFilter extends PatternItemFilter {

	/**
	 * Create a new instance of a ViewPatternFilter 
	 * @param isMatchItem
	 */
	public ViewPatternFilter(boolean isMatchItem) {
		super(isMatchItem);
	}
	
	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.viewers.ViewerFilter#select(org.eclipse.jface.viewers.Viewer,
	 *      java.lang.Object, java.lang.Object)
	 */
	public boolean select(Viewer viewer, Object parentElement, Object element) {

		ITreeContentProvider contentProvider = (ITreeContentProvider) ((TreeViewer) viewer)
				.getContentProvider();

		String text = null;
		Object[] children = null;
		if (element instanceof IViewCategory){
			IViewCategory desc = (IViewCategory) element;
			children = contentProvider.getChildren(desc);
			text = desc.getLabel();
		}
		else if (element instanceof IViewDescriptor){
			IViewDescriptor desc = (IViewDescriptor) element;
			children = contentProvider.getChildren(desc);
			text = desc.getLabel();			
		}

		if(text != null && wordMatches(text))
			return true;
		
		if (matchItem && children != null) {
			// Will return true if any subnode of the element matches the search
			if (filter(viewer, element, children).length > 0)
				return true;
		}	

		return false;
	}

}




package org.eclipse.ui.internal.dialogs;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import org.eclipse.jface.preference.IPreferenceNode;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.ui.internal.preferences.WorkbenchPreferenceExtensionNode;

/**
 * A class that handles filtering preference node items based on a supplied
 * matching string.
 *  
 * @since 3.2
 *
 */
public class PreferencePatternFilter extends PatternItemFilter {

	/**
	 * this cache is needed because
	 * WorkbenchPreferenceExtensionNode.getKeywordLabels() is expensive. When it
	 * tracks keyword changes effectivly than this cache can be removed.
	 */
	private Map keywordCache = new HashMap();
	
	
	/**
	 * Create a new instance of a PreferencePatternFilter
	 * 
	 * @param isMatchItem
	 */
	public PreferencePatternFilter(boolean isMatchItem) {
		super(isMatchItem);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.viewers.ViewerFilter#select(org.eclipse.jface.viewers.Viewer,
	 *      java.lang.Object, java.lang.Object)
	 */
	public boolean select(Viewer viewer, Object parentElement, Object element) {

		ITreeContentProvider contentProvider = (ITreeContentProvider) ((TreeViewer) viewer)
				.getContentProvider();

		IPreferenceNode node = (IPreferenceNode) element;
		Object[] children = contentProvider.getChildren(node);
		String text = node.getLabelText();

		if(wordMatches(text))
			return true;
		
		if (matchItem) {

			// Will return true if any subnode of the element matches the search
			if (filter(viewer, element, children).length > 0)
				return true;
		}

		if (node instanceof WorkbenchPreferenceExtensionNode) {
			WorkbenchPreferenceExtensionNode workbenchNode = (WorkbenchPreferenceExtensionNode) node;

			Collection keywordCollection = (Collection) keywordCache.get(node);
			if (keywordCollection == null) {
				keywordCollection = workbenchNode.getKeywordLabels();
				keywordCache.put(node, keywordCollection);
			}
			if (keywordCollection.isEmpty())
				return false;
			Iterator keywords = keywordCollection.iterator();
			while (keywords.hasNext()) {
				if (wordMatches((String) keywords.next()))
					return true;
			}
		}
		return false;
	}

}

Return to bug 102081

Lines 20-25 Link Here

(-)ShowViewDialog.java (-20 / +51 lines)
20	import org.eclipse.jface.viewers.IDoubleClickListener;	20	import org.eclipse.jface.viewers.IDoubleClickListener;
21	import org.eclipse.jface.viewers.ISelectionChangedListener;	21	import org.eclipse.jface.viewers.ISelectionChangedListener;
22	import org.eclipse.jface.viewers.IStructuredSelection;	22	import org.eclipse.jface.viewers.IStructuredSelection;
		23	import org.eclipse.jface.viewers.ITreeContentProvider;
23	import org.eclipse.jface.viewers.SelectionChangedEvent;	24	import org.eclipse.jface.viewers.SelectionChangedEvent;
24	import org.eclipse.jface.viewers.StructuredSelection;	25	import org.eclipse.jface.viewers.StructuredSelection;
25	import org.eclipse.jface.viewers.TreeViewer;	26	import org.eclipse.jface.viewers.TreeViewer;
Lines 56-62 Link Here
56	private static final String STORE_SELECTED_VIEW_ID = DIALOG_SETTING_SECTION_NAME	57	private static final String STORE_SELECTED_VIEW_ID = DIALOG_SETTING_SECTION_NAME
57	+ ".STORE_SELECTED_VIEW_ID"; //$NON-NLS-1$	58	+ ".STORE_SELECTED_VIEW_ID"; //$NON-NLS-1$
58		59
59	private TreeViewer tree;	60	private FilteredTree filteredTree;
60		61
61	private Button okButton;	62	private Button okButton;
62		63
Lines 135-143 Link Here
135	Composite composite = (Composite) super.createDialogArea(parent);	136	Composite composite = (Composite) super.createDialogArea(parent);
136	composite.setFont(parent.getFont());	137	composite.setFont(parent.getFont());
137		138
138	createViewer(composite);	139	createFilteredTreeViewer(composite);
139		140
140	layoutTopControl(tree.getControl());	141	layoutTopControl(filteredTree.getViewer().getControl());
141		142
142	// Restore the last state	143	// Restore the last state
143	restoreWidgetValues();	144	restoreWidgetValues();
Lines 147-167 Link Here
147	}	148	}
148		149
149	/**	150	/**
150	* Create a new viewer in the parent.	151	* Create a new filtered tree viewer in the parent.
151	*	152	*
152	* @param parent the parent <code>Composite</code>.	153	* @param parent the parent <code>Composite</code>.
153	*/	154	*/
154	private void createViewer(Composite parent) {	155	private void createFilteredTreeViewer(Composite parent) {
155	tree = new TreeViewer(parent, SWT.MULTI \| SWT.H_SCROLL \| SWT.V_SCROLL	156	PatternItemFilter filter = new ViewPatternFilter(true);
156	\| SWT.BORDER);	157	int styleBits = SWT.MULTI \| SWT.H_SCROLL \| SWT.V_SCROLL \| SWT.BORDER;
157	tree.setLabelProvider(new ViewLabelProvider());	158	filteredTree = new FilteredTree(parent, styleBits, filter);
158	tree.setContentProvider(new ViewContentProvider());	159	TreeViewer treeViewer = filteredTree.getViewer();
159	tree.setSorter(new ViewSorter((ViewRegistry) viewReg));	160	treeViewer.setLabelProvider(new ViewLabelProvider());
160	tree.setInput(viewReg);	161	treeViewer.setContentProvider(new ViewContentProvider());
161	tree.addSelectionChangedListener(this);	162	treeViewer.setSorter(new ViewSorter((ViewRegistry) viewReg));
162	tree.addDoubleClickListener(this);	163	treeViewer.setInput(viewReg);
163	tree.getTree().setFont(parent.getFont());	164	treeViewer.addSelectionChangedListener(this);
164	}	165	treeViewer.addDoubleClickListener(this);
		166	treeViewer.addFilter(new CapabilityFilter());
		167
		168	filteredTree.setBackground(parent.getDisplay().getSystemColor(SWT.COLOR_WIDGET_BACKGROUND));
		169	filteredTree.setInitialText(WorkbenchMessages.WorkbenchPreferenceDialog_FilterMessage);
		170
		171	//if the tree has only one or zero views, make the combo area disable
		172	if(hasAtMostOneView(filteredTree.getViewer())){
		173	filteredTree.getFilterControl().setEnabled(false);
		174	}
		175
		176	applyDialogFont(filteredTree);
		177	}
		178
		179	/**
		180	* Return whether or not there are less than two views in the list.
		181	* @param tree
		182	* @return <code>true</code> if there are less than two
		183	* views in the list.
		184	*/
		185	private boolean hasAtMostOneView(TreeViewer tree){
		186	ITreeContentProvider contentProvider = (ITreeContentProvider ) tree.getContentProvider();
		187	Object[] children= contentProvider.getElements(tree.getInput());
		188
		189	if(children.length <= 1){
		190	if(children.length == 0)
		191	return true;
		192	return !contentProvider.hasChildren(children[0]);
		193	}
		194	return false;
		195	}
165		196
166	/*	197	/*
167	* (non-Javadoc)	198	* (non-Javadoc)
Lines 171-178 Link Here
171	public void doubleClick(DoubleClickEvent event) {	202	public void doubleClick(DoubleClickEvent event) {
172	IStructuredSelection s = (IStructuredSelection) event.getSelection();	203	IStructuredSelection s = (IStructuredSelection) event.getSelection();
173	Object element = s.getFirstElement();	204	Object element = s.getFirstElement();
174	if (tree.isExpandable(element)) {	205	if (filteredTree.getViewer().isExpandable(element)) {
175	tree.setExpandedState(element, !tree.getExpandedState(element));	206	filteredTree.getViewer().setExpandedState(element, !filteredTree.getViewer().getExpandedState(element));
176	} else if (viewDescs.length > 0) {	207	} else if (viewDescs.length > 0) {
177	saveWidgetValues();	208	saveWidgetValues();
178	setReturnCode(OK);	209	setReturnCode(OK);
Lines 236-248 Link Here
236	}	267	}
237		268
238	if (!categoriesToExpand.isEmpty())	269	if (!categoriesToExpand.isEmpty())
239	tree.setExpandedElements(categoriesToExpand.toArray());	270	filteredTree.getViewer().setExpandedElements(categoriesToExpand.toArray());
240		271
241	String selectedViewId = settings.get(STORE_SELECTED_VIEW_ID);	272	String selectedViewId = settings.get(STORE_SELECTED_VIEW_ID);
242	if (selectedViewId != null) {	273	if (selectedViewId != null) {
243	IViewDescriptor viewDesc = reg.find(selectedViewId);	274	IViewDescriptor viewDesc = reg.find(selectedViewId);
244	if (viewDesc != null) {	275	if (viewDesc != null) {
245	tree.setSelection(new StructuredSelection(viewDesc), true);	276	filteredTree.getViewer().setSelection(new StructuredSelection(viewDesc), true);
246	}	277	}
247	}	278	}
248	}	279	}
Lines 255-261 Link Here
255	IDialogSettings settings = getDialogSettings();	286	IDialogSettings settings = getDialogSettings();
256		287
257	// Collect the ids of the all expanded categories	288	// Collect the ids of the all expanded categories
258	Object[] expandedElements = tree.getExpandedElements();	289	Object[] expandedElements = filteredTree.getViewer().getExpandedElements();
259	String[] expandedCategoryIds = new String[expandedElements.length];	290	String[] expandedCategoryIds = new String[expandedElements.length];
260	for (int i = 0; i < expandedElements.length; ++i)	291	for (int i = 0; i < expandedElements.length; ++i)
261	expandedCategoryIds[i] = ((IViewCategory) expandedElements[i]).getId();	292	expandedCategoryIds[i] = ((IViewCategory) expandedElements[i]).getId();

Lines 11-43 Link Here

(-)PatternItemFilter.java (-67 / +4 lines)
11	package org.eclipse.ui.internal.dialogs;	11	package org.eclipse.ui.internal.dialogs;
12		12
13	import java.text.BreakIterator;	13	import java.text.BreakIterator;
14	import java.util.Collection;
15	import java.util.HashMap;
16	import java.util.Iterator;
17	import java.util.Map;
18
19	import org.eclipse.jface.preference.IPreferenceNode;
20	import org.eclipse.jface.viewers.ITreeContentProvider;
21	import org.eclipse.jface.viewers.TreeViewer;
22	import org.eclipse.jface.viewers.Viewer;
23	import org.eclipse.ui.internal.preferences.WorkbenchPreferenceExtensionNode;
24		14
25	/**	15	/**
26	* A class which handles filtering preferences nodes based on a supplied	16	* Abstract class that handles filtering items based on a supplied
27	* matching string.	17	* matching string.
28	*	18	*
29	* @since 3.1	19	* @since 3.1
30	*	20	*
31	*/	21	*/
32	public class PatternItemFilter extends PatternFilter {	22	public abstract class PatternItemFilter extends PatternFilter {
33
34	/**
35	* this cache is needed because
36	* WorkbenchPreferenceExtensionNode.getKeywordLabels() is expensive. When it
37	* tracks keyword changes effectivly than this cache can be removed.
38	*/
39	private Map keywordCache = new HashMap();
40
41	protected boolean matchItem;	23	protected boolean matchItem;
42		24
43	/**	25	/**
Lines 49-100 Link Here
49	super();	31	super();
50	matchItem = isMatchItem;	32	matchItem = isMatchItem;
51	}	33	}
52		34
53	/*
54	* (non-Javadoc)
55	*
56	* @see org.eclipse.jface.viewers.ViewerFilter#select(org.eclipse.jface.viewers.Viewer,
57	* java.lang.Object, java.lang.Object)
58	*/
59	public boolean select(Viewer viewer, Object parentElement, Object element) {
60
61	ITreeContentProvider contentProvider = (ITreeContentProvider) ((TreeViewer) viewer)
62	.getContentProvider();
63
64	IPreferenceNode node = (IPreferenceNode) element;
65	Object[] children = contentProvider.getChildren(node);
66	String text = node.getLabelText();
67
68	if(wordMatches(text))
69	return true;
70
71	if (matchItem) {
72
73	// Will return true if any subnode of the element matches the search
74	if (filter(viewer, element, children).length > 0)
75	return true;
76	}
77
78	if (node instanceof WorkbenchPreferenceExtensionNode) {
79	WorkbenchPreferenceExtensionNode workbenchNode = (WorkbenchPreferenceExtensionNode) node;
80
81	Collection keywordCollection = (Collection) keywordCache.get(node);
82	if (keywordCollection == null) {
83	keywordCollection = workbenchNode.getKeywordLabels();
84	keywordCache.put(node, keywordCollection);
85	}
86	if (keywordCollection.isEmpty())
87	return false;
88	Iterator keywords = keywordCollection.iterator();
89	while (keywords.hasNext()) {
90	if (wordMatches((String) keywords.next()))
91	return true;
92	}
93	}
94	return false;
95
96	}
97
98	/**	35	/**
99	* Return whether or not if any of the words in text satisfy the	36	* Return whether or not if any of the words in text satisfy the
100	* match critera.	37	* match critera.
Lines 102-108 Link Here
102	* @return boolean <code>true</code> if one of the words in text	39	* @return boolean <code>true</code> if one of the words in text
103	* satisifes the match criteria.	40	* satisifes the match criteria.
104	*/	41	*/
105	private boolean wordMatches(String text) {	42	protected boolean wordMatches(String text) {
106		43
107	//If the whole text matches we are all set	44	//If the whole text matches we are all set
108	if(match(text))	45	if(match(text))

Lines 34-40 Link Here

(-)FilteredPreferenceDialog.java (-6 / +4 lines)
34	import org.eclipse.jface.viewers.TreeViewer;	34	import org.eclipse.jface.viewers.TreeViewer;
35	import org.eclipse.swt.SWT;	35	import org.eclipse.swt.SWT;
36	import org.eclipse.swt.graphics.Font;	36	import org.eclipse.swt.graphics.Font;
37	import org.eclipse.swt.graphics.Point;
38	import org.eclipse.swt.layout.GridData;	37	import org.eclipse.swt.layout.GridData;
39	import org.eclipse.swt.layout.GridLayout;	38	import org.eclipse.swt.layout.GridLayout;
40	import org.eclipse.swt.widgets.Composite;	39	import org.eclipse.swt.widgets.Composite;
Lines 57-63 Link Here
57	*/	56	*/
58	public abstract class FilteredPreferenceDialog extends PreferenceDialog implements IWorkbenchPreferenceContainer{	57	public abstract class FilteredPreferenceDialog extends PreferenceDialog implements IWorkbenchPreferenceContainer{
59		58
60	protected FilteredComboTree filteredTree;	59	protected FilteredTree filteredTree;
61		60
62	private Object pageData;	61	private Object pageData;
63		62
Lines 108-116 Link Here
108	* @see org.eclipse.jface.preference.PreferenceDialog#createTreeViewer(org.eclipse.swt.widgets.Composite)	107	* @see org.eclipse.jface.preference.PreferenceDialog#createTreeViewer(org.eclipse.swt.widgets.Composite)
109	*/	108	*/
110	protected TreeViewer createTreeViewer(Composite parent) {	109	protected TreeViewer createTreeViewer(Composite parent) {
111	PatternItemFilter filter = new PatternItemFilter(true);	110	PatternItemFilter filter = new PreferencePatternFilter(true);
112	int styleBits = SWT.SINGLE \| SWT.H_SCROLL;	111	int styleBits = SWT.SINGLE \| SWT.H_SCROLL;
113	filteredTree = new FilteredComboTree(parent, styleBits, filter);	112	filteredTree = new FilteredTree(parent, styleBits, filter);
114	GridData gd = new GridData(SWT.FILL, SWT.FILL, true, true);	113	GridData gd = new GridData(SWT.FILL, SWT.FILL, true, true);
115	gd.horizontalIndent = IDialogConstants.HORIZONTAL_MARGIN;	114	gd.horizontalIndent = IDialogConstants.HORIZONTAL_MARGIN;
116	filteredTree.setBackground(parent.getDisplay().getSystemColor(SWT.COLOR_LIST_BACKGROUND));	115	filteredTree.setBackground(parent.getDisplay().getSystemColor(SWT.COLOR_LIST_BACKGROUND));
Lines 123-130 Link Here
123		122
124	//if the tree has only one or zero pages, make the combo area disable	123	//if the tree has only one or zero pages, make the combo area disable
125	if(hasAtMostOnePage(tree)){	124	if(hasAtMostOnePage(tree)){
126	filteredTree.getFilterCombo().setEnabled(false);	125	filteredTree.getFilterControl().setEnabled(false);
127	filteredTree.getFilterCombo().setSelection(new Point(0,0));
128	}	126	}
129		127
130		128

Lines 14-50 Link Here

(-)PreferenceBoldLabelProvider.java (-10 / +10 lines)
14	implements IFontProvider {	14	implements IFontProvider {
15		15
16		16
17	private FilteredComboTree comboTree;	17	private FilteredTree filterTree;
18		18
19	PreferenceBoldLabelProvider(FilteredComboTree comboTree) {	19	PreferenceBoldLabelProvider(FilteredTree filterTree) {
20	this.comboTree = comboTree;	20	this.filterTree = filterTree;
21	}	21	}
22	/**	22	/**
23	* Using "false" to construct the filter so that this filter can filter	23	* Using "false" to construct the filter so that this filter can filter
24	* supernodes of a matching node	24	* supernodes of a matching node
25	*/	25	*/
26	PatternItemFilter filterForBoldElements = new PatternItemFilter(false);	26	PatternItemFilter filterForBoldElements = new PreferencePatternFilter(false);
27		27
28	public Font getFont(Object element) {	28	public Font getFont(Object element) {
29		29
30	String filterText = comboTree.getFilterControlText();	30	String filterText = filterTree.getFilterControlText();
31		31
32	// Do nothing if it's empty string	32	// Do nothing if it's empty string
33	if (!(filterText.equals("") \|\| filterText.equals(comboTree.getInitialText()))) {//$NON-NLS-1$	33	if (!(filterText.equals("") \|\| filterText.equals(filterTree.getInitialText()))) {//$NON-NLS-1$
34		34
35	boolean initial = comboTree.getInitialText() != null	35	boolean initial = filterTree.getInitialText() != null
36	&& filterText.equals(comboTree.getInitialText());	36	&& filterText.equals(filterTree.getInitialText());
37	if (initial) {	37	if (initial) {
38	filterForBoldElements.setPattern(null);	38	filterForBoldElements.setPattern(null);
39	} else {	39	} else {
40	filterForBoldElements.setPattern(filterText);	40	filterForBoldElements.setPattern(filterText);
41	}	41	}
42		42
43	ITreeContentProvider contentProvider = (ITreeContentProvider) comboTree.getViewer()	43	ITreeContentProvider contentProvider = (ITreeContentProvider) filterTree.getViewer()
44	.getContentProvider();	44	.getContentProvider();
45	Object parent = contentProvider.getParent(element);	45	Object parent = contentProvider.getParent(element);
46		46
47	if (filterForBoldElements.select(comboTree.getViewer(), parent, element)) {	47	if (filterForBoldElements.select(filterTree.getViewer(), parent, element)) {
48	return JFaceResources.getFontRegistry().getBold(JFaceResources.DIALOG_FONT);	48	return JFaceResources.getFontRegistry().getBold(JFaceResources.DIALOG_FONT);
49	}	49	}
50	}	50	}

Removed Link Here

(-)FilteredComboTree.java (-210 lines)
1	/*******************************************************************************
2	* Copyright (c) 2005 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.ui.internal.dialogs;
12
13	import org.eclipse.jface.dialogs.IDialogSettings;
14	import org.eclipse.swt.SWT;
15	import org.eclipse.swt.events.DisposeEvent;
16	import org.eclipse.swt.events.DisposeListener;
17	import org.eclipse.swt.events.FocusAdapter;
18	import org.eclipse.swt.events.FocusEvent;
19	import org.eclipse.swt.events.SelectionAdapter;
20	import org.eclipse.swt.events.SelectionEvent;
21	import org.eclipse.swt.events.TraverseEvent;
22	import org.eclipse.swt.events.TraverseListener;
23	import org.eclipse.swt.graphics.Point;
24	import org.eclipse.swt.widgets.Combo;
25	import org.eclipse.swt.widgets.Composite;
26	import org.eclipse.swt.widgets.Control;
27	import org.eclipse.swt.widgets.Display;
28	import org.eclipse.ui.internal.WorkbenchPlugin;
29
30	/**
31	* The FilteredComboTree is a filtered tree that uses an
32	* editable combo rather than just a text.
33	*/
34	public class FilteredComboTree extends FilteredTree {
35
36	private Combo filterCombo;
37
38	private static final String SEARCHHISTORY = "search"; //$NON-NLS-1$
39
40	//Set a number limitation of items to be saved in combo
41	private static final int maxNumItems = 20;
42	/**
43	* Create a new instance of the receiver.
44	* @param parent
45	* @param treeStyle
46	*/
47	public FilteredComboTree(Composite parent, int treeStyle) {
48	super(parent, treeStyle);
49	}
50
51	/**
52	* Create a new instance of the receiver with a supplied filter.
53	* @param parent
54	* @param treeStyle
55	* @param filter
56	*/
57	public FilteredComboTree(Composite parent, int treeStyle, PatternItemFilter filter) {
58	super(parent, treeStyle, filter);
59	}
60
61	/* (non-Javadoc)
62	* @see org.eclipse.ui.internal.dialogs.FilteredTree#createFilterControl(org.eclipse.swt.widgets.Composite)
63	*/
64	protected void createFilterControl(Composite parent) {
65	filterCombo = new Combo(parent, SWT.DROP_DOWN \| SWT.BORDER);
66	filterCombo.setFont(parent.getFont());
67	getPreferenceSearchHistory();
68	filterCombo.addTraverseListener( new TraverseListener () {
69	public void keyTraversed(TraverseEvent e) {
70	if (e.detail == SWT.TRAVERSE_RETURN) {
71	e.doit = false;
72	if (getViewer().getTree().getItemCount() == 0) {
73	Display.getCurrent().beep();
74	setFilterText(""); //$NON-NLS-1$
75	} else {
76	getViewer().getTree().setFocus();
77	}
78	}
79	}
80	});
81	filterCombo.addFocusListener(new FocusAdapter(){
82	/* (non-Javadoc)
83	* @see org.eclipse.swt.events.FocusAdapter#focusLost(org.eclipse.swt.events.FocusEvent)
84	*/
85	public void focusLost(FocusEvent e) {
86	String [] textValues = filterCombo.getItems();
87	String newText = filterCombo.getText();
88
89	if((newText.equals(""))\|\|(newText .equals(initialText)))//$NON-NLS-1$
90	return;
91
92	for (int i = 0; i < textValues.length; i++) {
93	if(textValues[i].equals(newText))
94	return;
95	}
96
97	if(textValues.length >= maxNumItems)
98	//Discard the oldest search to get space for new search
99	filterCombo.remove(maxNumItems-1);
100
101	filterCombo.add(newText,0);
102	}
103	});
104	filterCombo.addSelectionListener(new SelectionAdapter(){
105	/* (non-Javadoc)
106	* @see org.eclipse.swt.events.SelectionAdapter#widgetSelected(org.eclipse.swt.events.SelectionEvent)
107	*/
108	public void widgetSelected(SelectionEvent e) {
109	textChanged();
110	}
111	});
112
113	filterCombo.addDisposeListener(new DisposeListener() {
114
115	/* (non-Javadoc)
116	* @see org.eclipse.swt.events.DisposeListener#widgetDisposed(org.eclipse.swt.events.DisposeEvent)
117	*/
118	public void widgetDisposed(DisposeEvent e) {
119	saveDialogSettings();
120	}
121	});
122
123	filterCombo.getAccessible().addAccessibleListener(getAccessibleListener());
124
125	}
126
127	/* (non-Javadoc)
128	* @see org.eclipse.ui.internal.dialogs.FilteredTree#getFilterControl()
129	*/
130	public Control getFilterControl() {
131	return filterCombo;
132	}
133
134	/* (non-Javadoc)
135	* @see org.eclipse.ui.internal.dialogs.FilteredTree#getFilterControlText()
136	*/
137	protected String getFilterControlText() {
138	return filterCombo.getText();
139	}
140
141	/* (non-Javadoc)
142	* @see org.eclipse.ui.internal.dialogs.FilteredTree#setFilterText(java.lang.String)
143	*/
144	protected void setFilterText(String string) {
145	filterCombo.setText(string);
146	selectAll();
147	}
148
149	protected void selectAll() {
150	filterCombo.setSelection(new Point(0,filterCombo.getText().length()));
151	}
152
153	/**
154	* Get the combo box used by the receiver.
155	* @return Combo
156	*/
157	public Combo getFilterCombo() {
158	return filterCombo;
159	}
160
161	/* (non-Javadoc)
162	* @see org.eclipse.ui.internal.dialogs.FilteredTree#getFilterText()
163	*/
164	protected String getFilterText() {
165	return filterCombo.getText();
166	}
167
168	/**
169	* Return a dialog setting section for this dialog
170	*/
171	private IDialogSettings getDialogSettings() {
172	IDialogSettings settings = WorkbenchPlugin.getDefault()
173	.getDialogSettings();
174	IDialogSettings thisSettings = settings
175	.getSection(getClass().getName());
176	if (thisSettings == null)
177	thisSettings = settings.addNewSection(getClass().getName());
178	return thisSettings;
179	}
180
181
182	/**
183	* Get the preferences search history for this eclipse's start,
184	* Note that this history will not be cleared until this eclipse closes
185	*
186	*/
187	public void getPreferenceSearchHistory(){
188	IDialogSettings settings = getDialogSettings();
189	String[] search = settings.getArray(SEARCHHISTORY);
190
191	if(search == null)
192	return;
193
194	for(int i = 0; i < search.length;i++){
195	filterCombo.add(search[i]);
196	}
197
198	}
199
200	/**
201	* Saves the search history.
202	*/
203	private void saveDialogSettings() {
204	IDialogSettings settings =getDialogSettings();
205
206	//If the settings contains the same key, the previous value will be replaced by new one
207	settings.put(SEARCHHISTORY,filterCombo.getItems());
208
209	}
210	}

Lines 133-156 Link Here

(-)FilteredTree.java (-19 / +18 lines)
133	\| GridData.GRAB_HORIZONTAL));	133	\| GridData.GRAB_HORIZONTAL));
134		134
135	createFilterControl(filterParent);	135	createFilterControl(filterParent);
136	getFilterControl().addKeyListener(new KeyAdapter() {	136	getFilterControl().addKeyListener(new KeyAdapter() {
137		137
138	/*	138	/*
139	* (non-Javadoc)	139	* (non-Javadoc)
140	*	140	*
141	* @see org.eclipse.swt.events.KeyAdapter#keyReleased(org.eclipse.swt.events.KeyEvent)	141	* @see org.eclipse.swt.events.KeyAdapter#keyReleased(org.eclipse.swt.events.KeyEvent)
142	*/	142	*/
143	public void keyReleased(KeyEvent e) {	143	public void keyReleased(KeyEvent e) {
144	// on a CR we want to transfer focus to the list	144	// on a CR we want to transfer focus to the list
145	if(e.keyCode == SWT.ARROW_DOWN){	145	if(e.keyCode == SWT.ARROW_DOWN){
146		146
147	if (!(getFilterControl() instanceof Combo)) {	147	if (!(getFilterControl() instanceof Combo)) {
148	treeViewer.getTree().setFocus();	148	treeViewer.getTree().setFocus();
149	}	149	}
150	} else	150	} else
151	textChanged();	151	textChanged();
152	}	152	}
153	});	153	});
154		154
155	GridData data = new GridData(GridData.FILL_HORIZONTAL	155	GridData data = new GridData(GridData.FILL_HORIZONTAL
156	\| GridData.GRAB_HORIZONTAL);	156	\| GridData.GRAB_HORIZONTAL);
Lines 278-284 Link Here
278	public void setBackground(Color background) {	278	public void setBackground(Color background) {
279	super.setBackground(background);	279	super.setBackground(background);
280	filterParent.setBackground(background);	280	filterParent.setBackground(background);
281	getFilterControl().setBackground(background);
282	filterToolBar.getControl().setBackground(background);	281	filterToolBar.getControl().setBackground(background);
283	}	282	}
284		283

Added Link Here

(-)Eclipse (+62 lines)
1	package org.eclipse.ui.internal.dialogs;
2
3	import org.eclipse.jface.viewers.ITreeContentProvider;
4	import org.eclipse.jface.viewers.TreeViewer;
5	import org.eclipse.jface.viewers.Viewer;
6	import org.eclipse.ui.views.IViewCategory;
7	import org.eclipse.ui.views.IViewDescriptor;
8
9	/**
10	* A class that handles filtering view node items based on a supplied
11	* matching string.
12	*
13	* @since 3.2
14	*
15	*/
16	public class ViewPatternFilter extends PatternItemFilter {
17
18	/**
19	* Create a new instance of a ViewPatternFilter
20	* @param isMatchItem
21	*/
22	public ViewPatternFilter(boolean isMatchItem) {
23	super(isMatchItem);
24	}
25
26	/*
27	* (non-Javadoc)
28	*
29	* @see org.eclipse.jface.viewers.ViewerFilter#select(org.eclipse.jface.viewers.Viewer,
30	* java.lang.Object, java.lang.Object)
31	*/
32	public boolean select(Viewer viewer, Object parentElement, Object element) {
33
34	ITreeContentProvider contentProvider = (ITreeContentProvider) ((TreeViewer) viewer)
35	.getContentProvider();
36
37	String text = null;
38	Object[] children = null;
39	if (element instanceof IViewCategory){
40	IViewCategory desc = (IViewCategory) element;
41	children = contentProvider.getChildren(desc);
42	text = desc.getLabel();
43	}
44	else if (element instanceof IViewDescriptor){
45	IViewDescriptor desc = (IViewDescriptor) element;
46	children = contentProvider.getChildren(desc);
47	text = desc.getLabel();
48	}
49
50	if(text != null && wordMatches(text))
51	return true;
52
53	if (matchItem && children != null) {
54	// Will return true if any subnode of the element matches the search
55	if (filter(viewer, element, children).length > 0)
56	return true;
57	}
58
59	return false;
60	}
61
62	}

Added Link Here

(-)Eclipse (+84 lines)
1	package org.eclipse.ui.internal.dialogs;
2
3	import java.util.Collection;
4	import java.util.HashMap;
5	import java.util.Iterator;
6	import java.util.Map;
7
8	import org.eclipse.jface.preference.IPreferenceNode;
9	import org.eclipse.jface.viewers.ITreeContentProvider;
10	import org.eclipse.jface.viewers.TreeViewer;
11	import org.eclipse.jface.viewers.Viewer;
12	import org.eclipse.ui.internal.preferences.WorkbenchPreferenceExtensionNode;
13
14	/**
15	* A class that handles filtering preference node items based on a supplied
16	* matching string.
17	*
18	* @since 3.2
19	*
20	*/
21	public class PreferencePatternFilter extends PatternItemFilter {
22
23	/**
24	* this cache is needed because
25	* WorkbenchPreferenceExtensionNode.getKeywordLabels() is expensive. When it
26	* tracks keyword changes effectivly than this cache can be removed.
27	*/
28	private Map keywordCache = new HashMap();
29
30
31	/**
32	* Create a new instance of a PreferencePatternFilter
33	*
34	* @param isMatchItem
35	*/
36	public PreferencePatternFilter(boolean isMatchItem) {
37	super(isMatchItem);
38	}
39
40	/*
41	* (non-Javadoc)
42	*
43	* @see org.eclipse.jface.viewers.ViewerFilter#select(org.eclipse.jface.viewers.Viewer,
44	* java.lang.Object, java.lang.Object)
45	*/
46	public boolean select(Viewer viewer, Object parentElement, Object element) {
47
48	ITreeContentProvider contentProvider = (ITreeContentProvider) ((TreeViewer) viewer)
49	.getContentProvider();
50
51	IPreferenceNode node = (IPreferenceNode) element;
52	Object[] children = contentProvider.getChildren(node);
53	String text = node.getLabelText();
54
55	if(wordMatches(text))
56	return true;
57
58	if (matchItem) {
59
60	// Will return true if any subnode of the element matches the search
61	if (filter(viewer, element, children).length > 0)
62	return true;
63	}
64
65	if (node instanceof WorkbenchPreferenceExtensionNode) {
66	WorkbenchPreferenceExtensionNode workbenchNode = (WorkbenchPreferenceExtensionNode) node;
67
68	Collection keywordCollection = (Collection) keywordCache.get(node);
69	if (keywordCollection == null) {
70	keywordCollection = workbenchNode.getKeywordLabels();
71	keywordCache.put(node, keywordCollection);
72	}
73	if (keywordCollection.isEmpty())
74	return false;
75	Iterator keywords = keywordCollection.iterator();
76	while (keywords.hasNext()) {
77	if (wordMatches((String) keywords.next()))
78	return true;
79	}
80	}
81	return false;
82	}
83
84	}