Attachment #27868 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);
		}		
		}
		
		
		tree.addFilter(new CapabilityFilter());





     * @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) {
        return isElementMatch(viewer, element);
                .getContentProvider()).getChildren(element);
        if ((children != null) && (children.length > 0))
            return filter(viewer, element, children).length > 0;

        String labelText = ((ILabelProvider) ((StructuredViewer) viewer)
                .getLabelProvider()).getText(element);
        if(labelText == null)
        	return false;
        return match(labelText);
    }
    
    /**

    protected boolean match(String string) {
        return matcher.match(string);
    }
    
    /**
     * Answers whether the given Object should be selected in 
     * the filtered control.
     * 
     * @param element
     * @return true if this element should be auto selected
     */
    protected boolean isElementSelectable(Object element){
    	return element != null;
    }
    
    /**
     * Answers whether the given element in the given viewer matches
     * the filter pattern. 
     * 
     * @param viewer
     * @param element
     * @return true if the element matches the filter pattern
     */
    protected boolean isElementMatch(Viewer viewer, Object element){
        Object[] children = ((ITreeContentProvider) ((AbstractTreeViewer) viewer)
                .getContentProvider()).getChildren(element);
        if ((children != null) && (children.length > 0))
            return filter(viewer, element, children).length > 0;

        String labelText = ((ILabelProvider) ((StructuredViewer) viewer)
                .getLabelProvider()).getText(element);
        if(labelText == null)
        	return false;
        return match(labelText);   	
    }
}




		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.getFilterControl().getText();

		// 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);
			}
		}




import org.eclipse.jface.action.ToolBarManager;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.ViewerFilter;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.SWT;
import org.eclipse.swt.accessibility.AccessibleAdapter;

import org.eclipse.swt.events.FocusListener;
import org.eclipse.swt.events.KeyAdapter;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.events.TraverseEvent;
import org.eclipse.swt.events.TraverseListener;
import org.eclipse.swt.graphics.Color;
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.Display;
import org.eclipse.swt.widgets.Text;
import org.eclipse.swt.widgets.ToolBar;
import org.eclipse.swt.widgets.TreeItem;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.internal.WorkbenchMessages;
import org.eclipse.ui.plugin.AbstractUIPlugin;


    private PatternFilter patternFilter;
    
    private ViewerFilter viewerFilter;

    private FocusListener listener;


                | 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){
                    	treeViewer.getTree().setFocus();
            	} else if (e.character == SWT.CR)
					return;
            	
            	textChanged();
            }
        });
        
        // enter key set focus to tree
        getFilterControl().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 {
						boolean hasFocus = getViewer().getTree().setFocus();
						if (hasFocus){
							TreeItem item = getFirstHighlightedItem(getViewer().getTree().getItems());
							if (item != null){
								getViewer().getTree().setSelection(new TreeItem[] {item});
								ISelection sel = getViewer().getSelection();
								getViewer().setSelection(sel, true);
							}
						}
					}
				}
			}
		});

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

        createRefreshJob();
    }

    private TreeItem getFirstHighlightedItem(TreeItem[] items){
		for (int i = 0; i < items.length; i++){
			if (patternFilter.isElementMatch(treeViewer, items[i].getData()) && patternFilter.isElementSelectable(items[i].getData())){
				return items[i];
			}
			return getFirstHighlightedItem(items[i].getItems());
		}
		return null;
    }
    /**
     * Create the refresh job for the receiver.
     *

				if(treeViewer.getControl().isDisposed())
					return Status.CANCEL_STATUS;
				
				String filterText = getFilterControl().getText();
		        boolean initial = initialText != null && filterText.equals(initialText); 
		        if (initial) {
		            patternFilter.setPattern(null);
		        } else {
		            patternFilter.setPattern(filterText);
		        }       
		        treeViewer.getControl().setRedraw(false);
		        treeViewer.refresh(true);

		       
		        if (filterText.length() > 0 && !initial) {
		            treeViewer.expandAll();
		            TreeItem[] items = getViewer().getTree().getItems();
		            if (items.length > 0)
		            	treeViewer.getTree().showItem(items[0]);	// to prevent scrolling
		            // enabled toolbar is a hint that there is text to clear
		            // and the list is currently being filtered
		            filterToolBar.getControl().setVisible(true);
		        } else {
		            // disabled toolbar is a hint that there is no text to clear
		            // and the list is currently not filtered
		            filterToolBar.getControl().setVisible(viewerFilter != null);
		        }
		        return Status.OK_STATUS;
			}

	 */
	protected void createFilterControl(Composite parent) {
		filterText =  new Text(parent, SWT.SINGLE | SWT.BORDER);
		filterText.getAccessible().addAccessibleListener(
				new AccessibleAdapter(){
					/* (non-Javadoc)
					 * @see org.eclipse.swt.accessibility.AccessibleListener#getName(org.eclipse.swt.accessibility.AccessibleEvent)
					 */
					public void getName(AccessibleEvent e) {
						String filterTextString = getFilterControl().getText();
						if(filterTextString.length() == 0){
							e.result = initialText;
						}
						else
							e.result = filterTextString;
					}
				});
	}

	protected AccessibleAdapter getAccessibleListener() {
		return new AccessibleAdapter(){
			/* (non-Javadoc)
			 * @see org.eclipse.swt.accessibility.AccessibleListener#getName(org.eclipse.swt.accessibility.AccessibleEvent)
			 */
			public void getName(AccessibleEvent e) {
				String filterTextString = getFilterText();
				if(filterTextString.length() == 0){
					e.result = initialText;
				}
				else
					e.result = filterTextString;
			}
			
		};
	}

	/**
	 * Get the text from the filter widget.
	 * @return String
	 */
    protected String getFilterText() {
		return filterText.getText();
	}
	/**
     * update the receiver after the text has changed
     */

    	refreshJob.schedule(200);
    }

	/**
	 * Get the text from the filter control.
	 * @return Text
	 */
	protected String getFilterControlText() {
		return filterText.getText();
	}

    /**
     * Set the background for the widgets that support the filter text area
     * 

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


    protected void clearText() {
        setFilterText(""); //$NON-NLS-1$
        
        if(viewerFilter != null){
        	getViewer().removeFilter(viewerFilter);
        	viewerFilter = null;
    		getShell().setText(cachedTitle);
        }
		

     * 
     * @return the text field
     */
    public Text getFilterControl() {
        return filterText;
    }


	 * Add the filter to the viewer.
	 * @param filter
	 */
	public void addFilter(ViewerFilter filter) {
		viewerFilter = filter;
		getViewer().addFilter(filter);
		setInitialText(WorkbenchMessages.FilteredTree_FilteredMessage);
		




/*******************************************************************************
 * 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());
               
    }
}




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;	
	}
	
	/*
	 * (non-Javadoc)
	 * @see org.eclipse.ui.internal.dialogs.PatternFilter#isElementSelectable(java.lang.Object)
	 */
	protected boolean isElementSelectable(Object element){
		return element instanceof IViewDescriptor;
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.ui.internal.dialogs.PatternFilter#isElementMatch(org.eclipse.jface.viewers.Viewer, java.lang.Object)
	 */
	protected boolean isElementMatch(Viewer viewer, Object element){
		String text = null;
		if (element instanceof IViewCategory){
			IViewCategory desc = (IViewCategory) element;
			text = desc.getLabel();
		}
		else if (element instanceof IViewDescriptor){
			IViewDescriptor desc = (IViewDescriptor) element;
			text = desc.getLabel();			
		}	

		if(text != null && wordMatches(text))
			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;
		}
		return keywordMatches(node);
	}
	
	/*
	 * Return true if the given Object matches with any possible keywords
	 * that have been provided.  Currently this is only applicable for 
	 * preference and property pages.
	 */
	private boolean keywordMatches(Object element){
		if (element instanceof WorkbenchPreferenceExtensionNode) {
			WorkbenchPreferenceExtensionNode workbenchNode = (WorkbenchPreferenceExtensionNode) element;

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

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.ui.internal.dialogs.PatternFilter#isElementSelectable(java.lang.Object)
	 */
	protected boolean isElementSelectable(Object element){
		return element instanceof WorkbenchPreferenceExtensionNode;
	}
	
	/*
	 * (non-Javadoc)
	 * @see org.eclipse.ui.internal.dialogs.PatternFilter#isElementMatch(org.eclipse.jface.viewers.Viewer, java.lang.Object)
	 */
	protected boolean isElementMatch(Viewer viewer, Object element){
		IPreferenceNode node = (IPreferenceNode) element;
		String text = node.getLabelText();

		if(wordMatches(text))
			return true;
		
		return keywordMatches(node);
	}
}

Return to bug 102081

Lines 20-25 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/dialogs/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

(-)Eclipse UI/org/eclipse/ui/internal/dialogs/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

(-)Eclipse UI/org/eclipse/ui/internal/dialogs/FilteredPreferenceDialog.java (-8 / +5 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-132 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));	126	}
128	}
129
130		127
131	tree.addFilter(new CapabilityFilter());	128	tree.addFilter(new CapabilityFilter());
132		129

Lines 61-76 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/dialogs/PatternFilter.java (-10 / +33 lines)
61	* @see org.eclipse.jface.viewers.ViewerFilter#select(org.eclipse.jface.viewers.Viewer, java.lang.Object, java.lang.Object)	61	* @see org.eclipse.jface.viewers.ViewerFilter#select(org.eclipse.jface.viewers.Viewer, java.lang.Object, java.lang.Object)
62	*/	62	*/
63	public boolean select(Viewer viewer, Object parentElement, Object element) {	63	public boolean select(Viewer viewer, Object parentElement, Object element) {
64	Object[] children = ((ITreeContentProvider) ((AbstractTreeViewer) viewer)	64	return isElementMatch(viewer, element);
65	.getContentProvider()).getChildren(element);
66	if ((children != null) && (children.length > 0))
67	return filter(viewer, element, children).length > 0;
68
69	String labelText = ((ILabelProvider) ((StructuredViewer) viewer)
70	.getLabelProvider()).getText(element);
71	if(labelText == null)
72	return false;
73	return match(labelText);
74	}	65	}
75		66
76	/**	67	/**
Lines 111-114 Link Here
111	protected boolean match(String string) {	102	protected boolean match(String string) {
112	return matcher.match(string);	103	return matcher.match(string);
113	}	104	}
		105
		106	/**
		107	* Answers whether the given Object should be selected in
		108	* the filtered control.
		109	*
		110	* @param element
		111	* @return true if this element should be auto selected
		112	*/
		113	protected boolean isElementSelectable(Object element){
		114	return element != null;
		115	}
		116
		117	/**
		118	* Answers whether the given element in the given viewer matches
		119	* the filter pattern.
		120	*
		121	* @param viewer
		122	* @param element
		123	* @return true if the element matches the filter pattern
		124	*/
		125	protected boolean isElementMatch(Viewer viewer, Object element){
		126	Object[] children = ((ITreeContentProvider) ((AbstractTreeViewer) viewer)
		127	.getContentProvider()).getChildren(element);
		128	if ((children != null) && (children.length > 0))
		129	return filter(viewer, element, children).length > 0;
		130
		131	String labelText = ((ILabelProvider) ((StructuredViewer) viewer)
		132	.getLabelProvider()).getText(element);
		133	if(labelText == null)
		134	return false;
		135	return match(labelText);
		136	}
114	}	137	}

Lines 14-50 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/dialogs/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.getFilterControl().getText();
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	}

Lines 19-25 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/dialogs/FilteredTree.java (-64 / +81 lines)
19	import org.eclipse.jface.action.ToolBarManager;	19	import org.eclipse.jface.action.ToolBarManager;
20	import org.eclipse.jface.resource.ImageDescriptor;	20	import org.eclipse.jface.resource.ImageDescriptor;
21	import org.eclipse.jface.resource.JFaceResources;	21	import org.eclipse.jface.resource.JFaceResources;
		22	import org.eclipse.jface.viewers.ISelection;
22	import org.eclipse.jface.viewers.TreeViewer;	23	import org.eclipse.jface.viewers.TreeViewer;
		24	import org.eclipse.jface.viewers.ViewerFilter;
23	import org.eclipse.osgi.util.NLS;	25	import org.eclipse.osgi.util.NLS;
24	import org.eclipse.swt.SWT;	26	import org.eclipse.swt.SWT;
25	import org.eclipse.swt.accessibility.AccessibleAdapter;	27	import org.eclipse.swt.accessibility.AccessibleAdapter;
Lines 30-43 Link Here
30	import org.eclipse.swt.events.FocusListener;	32	import org.eclipse.swt.events.FocusListener;
31	import org.eclipse.swt.events.KeyAdapter;	33	import org.eclipse.swt.events.KeyAdapter;
32	import org.eclipse.swt.events.KeyEvent;	34	import org.eclipse.swt.events.KeyEvent;
		35	import org.eclipse.swt.events.TraverseEvent;
		36	import org.eclipse.swt.events.TraverseListener;
33	import org.eclipse.swt.graphics.Color;	37	import org.eclipse.swt.graphics.Color;
34	import org.eclipse.swt.layout.GridData;	38	import org.eclipse.swt.layout.GridData;
35	import org.eclipse.swt.layout.GridLayout;	39	import org.eclipse.swt.layout.GridLayout;
36	import org.eclipse.swt.widgets.Combo;
37	import org.eclipse.swt.widgets.Composite;	40	import org.eclipse.swt.widgets.Composite;
38	import org.eclipse.swt.widgets.Control;	41	import org.eclipse.swt.widgets.Display;
39	import org.eclipse.swt.widgets.Text;	42	import org.eclipse.swt.widgets.Text;
40	import org.eclipse.swt.widgets.ToolBar;	43	import org.eclipse.swt.widgets.ToolBar;
		44	import org.eclipse.swt.widgets.TreeItem;
41	import org.eclipse.ui.PlatformUI;	45	import org.eclipse.ui.PlatformUI;
42	import org.eclipse.ui.internal.WorkbenchMessages;	46	import org.eclipse.ui.internal.WorkbenchMessages;
43	import org.eclipse.ui.plugin.AbstractUIPlugin;	47	import org.eclipse.ui.plugin.AbstractUIPlugin;
Lines 62-68 Link Here
62		66
63	private PatternFilter patternFilter;	67	private PatternFilter patternFilter;
64		68
65	private PreferenceNodeFilter preferenceFilter;	69	private ViewerFilter viewerFilter;
66		70
67	private FocusListener listener;	71	private FocusListener listener;
68		72
Lines 133-156 Link Here
133	\| GridData.GRAB_HORIZONTAL));	137	\| GridData.GRAB_HORIZONTAL));
134		138
135	createFilterControl(filterParent);	139	createFilterControl(filterParent);
136	getFilterControl().addKeyListener(new KeyAdapter() {	140	getFilterControl().addKeyListener(new KeyAdapter() {
137		141	/*
138	/*	142	* (non-Javadoc)
139	* (non-Javadoc)	143	*
140	*	144	* @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)	145	*/
142	*/	146	public void keyReleased(KeyEvent e) {
143	public void keyReleased(KeyEvent e) {	147	// on a CR we want to transfer focus to the list
144	// on a CR we want to transfer focus to the list	148	if(e.keyCode == SWT.ARROW_DOWN){
145	if(e.keyCode == SWT.ARROW_DOWN){	149	treeViewer.getTree().setFocus();
146		150	} else if (e.character == SWT.CR)
147	if (!(getFilterControl() instanceof Combo)) {	151	return;
148	treeViewer.getTree().setFocus();	152
149	}	153	textChanged();
150	} else	154	}
151	textChanged();	155	});
152	}	156
153	});	157	// enter key set focus to tree
		158	getFilterControl().addTraverseListener( new TraverseListener () {
		159	public void keyTraversed(TraverseEvent e) {
		160	if (e.detail == SWT.TRAVERSE_RETURN) {
		161	e.doit = false;
		162	if (getViewer().getTree().getItemCount() == 0) {
		163	Display.getCurrent().beep();
		164	setFilterText(""); //$NON-NLS-1$
		165	} else {
		166	boolean hasFocus = getViewer().getTree().setFocus();
		167	if (hasFocus){
		168	TreeItem item = getFirstHighlightedItem(getViewer().getTree().getItems());
		169	if (item != null){
		170	getViewer().getTree().setSelection(new TreeItem[] {item});
		171	ISelection sel = getViewer().getSelection();
		172	getViewer().setSelection(sel, true);
		173	}
		174	}
		175	}
		176	}
		177	}
		178	});
154		179
155	GridData data = new GridData(GridData.FILL_HORIZONTAL	180	GridData data = new GridData(GridData.FILL_HORIZONTAL
156	\| GridData.GRAB_HORIZONTAL);	181	\| GridData.GRAB_HORIZONTAL);
Lines 182-187 Link Here
182	createRefreshJob();	207	createRefreshJob();
183	}	208	}
184		209
		210	private TreeItem getFirstHighlightedItem(TreeItem[] items){
		211	for (int i = 0; i < items.length; i++){
		212	if (patternFilter.isElementMatch(treeViewer, items[i].getData()) && patternFilter.isElementSelectable(items[i].getData())){
		213	return items[i];
		214	}
		215	return getFirstHighlightedItem(items[i].getItems());
		216	}
		217	return null;
		218	}
185	/**	219	/**
186	* Create the refresh job for the receiver.	220	* Create the refresh job for the receiver.
187	*	221	*
Lines 195-206 Link Here
195	if(treeViewer.getControl().isDisposed())	229	if(treeViewer.getControl().isDisposed())
196	return Status.CANCEL_STATUS;	230	return Status.CANCEL_STATUS;
197		231
198	String filterText = getFilterControlText();	232	String filterText = getFilterControl().getText();
199	boolean initial = initialText != null && filterText.equals(initialText);	233	boolean initial = initialText != null && filterText.equals(initialText);
200	if (initial) {	234	if (initial) {
201	patternFilter.setPattern(null);	235	patternFilter.setPattern(null);
202	} else {	236	} else {
203	patternFilter.setPattern(getFilterControlText());	237	patternFilter.setPattern(filterText);
204	}	238	}
205	treeViewer.getControl().setRedraw(false);	239	treeViewer.getControl().setRedraw(false);
206	treeViewer.refresh(true);	240	treeViewer.refresh(true);
Lines 208-220 Link Here
208		242
209	if (filterText.length() > 0 && !initial) {	243	if (filterText.length() > 0 && !initial) {
210	treeViewer.expandAll();	244	treeViewer.expandAll();
		245	TreeItem[] items = getViewer().getTree().getItems();
		246	if (items.length > 0)
		247	treeViewer.getTree().showItem(items[0]); // to prevent scrolling
211	// enabled toolbar is a hint that there is text to clear	248	// enabled toolbar is a hint that there is text to clear
212	// and the list is currently being filtered	249	// and the list is currently being filtered
213	filterToolBar.getControl().setVisible(true);	250	filterToolBar.getControl().setVisible(true);
214	} else {	251	} else {
215	// disabled toolbar is a hint that there is no text to clear	252	// disabled toolbar is a hint that there is no text to clear
216	// and the list is currently not filtered	253	// and the list is currently not filtered
217	filterToolBar.getControl().setVisible(preferenceFilter != null);	254	filterToolBar.getControl().setVisible(viewerFilter != null);
218	}	255	}
219	return Status.OK_STATUS;	256	return Status.OK_STATUS;
220	}	257	}
Lines 228-260 Link Here
228	*/	265	*/
229	protected void createFilterControl(Composite parent) {	266	protected void createFilterControl(Composite parent) {
230	filterText = new Text(parent, SWT.SINGLE \| SWT.BORDER);	267	filterText = new Text(parent, SWT.SINGLE \| SWT.BORDER);
231	filterText.getAccessible().addAccessibleListener(getAccessibleListener());	268	filterText.getAccessible().addAccessibleListener(
		269	new AccessibleAdapter(){
		270	/* (non-Javadoc)
		271	* @see org.eclipse.swt.accessibility.AccessibleListener#getName(org.eclipse.swt.accessibility.AccessibleEvent)
		272	*/
		273	public void getName(AccessibleEvent e) {
		274	String filterTextString = getFilterControl().getText();
		275	if(filterTextString.length() == 0){
		276	e.result = initialText;
		277	}
		278	else
		279	e.result = filterTextString;
		280	}
		281	});
232	}	282	}
233		283
234	protected AccessibleAdapter getAccessibleListener() {
235	return new AccessibleAdapter(){
236	/* (non-Javadoc)
237	* @see org.eclipse.swt.accessibility.AccessibleListener#getName(org.eclipse.swt.accessibility.AccessibleEvent)
238	*/
239	public void getName(AccessibleEvent e) {
240	String filterTextString = getFilterText();
241	if(filterTextString.length() == 0){
242	e.result = initialText;
243	}
244	else
245	e.result = filterTextString;
246	}
247
248	};
249	}
250
251	/**
252	* Get the text from the filter widget.
253	* @return String
254	*/
255	protected String getFilterText() {
256	return filterText.getText();
257	}
258	/**	284	/**
259	* update the receiver after the text has changed	285	* update the receiver after the text has changed
260	*/	286	*/
Lines 262-275 Link Here
262	refreshJob.schedule(200);	288	refreshJob.schedule(200);
263	}	289	}
264		290
265	/**
266	* Get the text from the filter control.
267	* @return Text
268	*/
269	protected String getFilterControlText() {
270	return filterText.getText();
271	}
272
273	/**	291	/**
274	* Set the background for the widgets that support the filter text area	292	* Set the background for the widgets that support the filter text area
275	*	293	*
Lines 278-284 Link Here
278	public void setBackground(Color background) {	296	public void setBackground(Color background) {
279	super.setBackground(background);	297	super.setBackground(background);
280	filterParent.setBackground(background);	298	filterParent.setBackground(background);
281	getFilterControl().setBackground(background);
282	filterToolBar.getControl().setBackground(background);	299	filterToolBar.getControl().setBackground(background);
283	}	300	}
284		301
Lines 315-323 Link Here
315	protected void clearText() {	332	protected void clearText() {
316	setFilterText(""); //$NON-NLS-1$	333	setFilterText(""); //$NON-NLS-1$
317		334
318	if(preferenceFilter != null){	335	if(viewerFilter != null){
319	getViewer().removeFilter(preferenceFilter);	336	getViewer().removeFilter(viewerFilter);
320	preferenceFilter = null;	337	viewerFilter = null;
321	getShell().setText(cachedTitle);	338	getShell().setText(cachedTitle);
322	}	339	}
323		340
Lines 347-353 Link Here
347	*	364	*
348	* @return the text field	365	* @return the text field
349	*/	366	*/
350	public Control getFilterControl() {	367	public Text getFilterControl() {
351	return filterText;	368	return filterText;
352	}	369	}
353		370
Lines 394-401 Link Here
394	* Add the filter to the viewer.	411	* Add the filter to the viewer.
395	* @param filter	412	* @param filter
396	*/	413	*/
397	public void addFilter(PreferenceNodeFilter filter) {	414	public void addFilter(ViewerFilter filter) {
398	preferenceFilter = filter;	415	viewerFilter = filter;
399	getViewer().addFilter(filter);	416	getViewer().addFilter(filter);
400	setInitialText(WorkbenchMessages.FilteredTree_FilteredMessage);	417	setInitialText(WorkbenchMessages.FilteredTree_FilteredMessage);
401		418

Removed Link Here

(-)Eclipse UI/org/eclipse/ui/internal/dialogs/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	}

Added Link Here

(-)Eclipse (+89 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	ITreeContentProvider contentProvider = (ITreeContentProvider) ((TreeViewer) viewer)
34	.getContentProvider();
35
36	String text = null;
37	Object[] children = null;
38	if (element instanceof IViewCategory){
39	IViewCategory desc = (IViewCategory) element;
40	children = contentProvider.getChildren(desc);
41	text = desc.getLabel();
42	}
43	else if (element instanceof IViewDescriptor){
44	IViewDescriptor desc = (IViewDescriptor) element;
45	children = contentProvider.getChildren(desc);
46	text = desc.getLabel();
47	}
48
49	if(text != null && wordMatches(text))
50	return true;
51
52	if (matchItem && children != null) {
53	// Will return true if any subnode of the element matches the search
54	if (filter(viewer, element, children).length > 0)
55	return true;
56	}
57
58	return false;
59	}
60
61	/*
62	* (non-Javadoc)
63	* @see org.eclipse.ui.internal.dialogs.PatternFilter#isElementSelectable(java.lang.Object)
64	*/
65	protected boolean isElementSelectable(Object element){
66	return element instanceof IViewDescriptor;
67	}
68
69	/*
70	* (non-Javadoc)
71	* @see org.eclipse.ui.internal.dialogs.PatternFilter#isElementMatch(org.eclipse.jface.viewers.Viewer, java.lang.Object)
72	*/
73	protected boolean isElementMatch(Viewer viewer, Object element){
74	String text = null;
75	if (element instanceof IViewCategory){
76	IViewCategory desc = (IViewCategory) element;
77	text = desc.getLabel();
78	}
79	else if (element instanceof IViewDescriptor){
80	IViewDescriptor desc = (IViewDescriptor) element;
81	text = desc.getLabel();
82	}
83
84	if(text != null && wordMatches(text))
85	return true;
86
87	return false;
88	}
89	}

Added Link Here

(-)Eclipse (+111 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	ITreeContentProvider contentProvider = (ITreeContentProvider) ((TreeViewer) viewer)
48	.getContentProvider();
49
50	IPreferenceNode node = (IPreferenceNode) element;
51	Object[] children = contentProvider.getChildren(node);
52	String text = node.getLabelText();
53
54	if(wordMatches(text))
55	return true;
56
57	if (matchItem) {
58	// Will return true if any subnode of the element matches the search
59	if (filter(viewer, element, children).length > 0)
60	return true;
61	}
62	return keywordMatches(node);
63	}
64
65	/*
66	* Return true if the given Object matches with any possible keywords
67	* that have been provided. Currently this is only applicable for
68	* preference and property pages.
69	*/
70	private boolean keywordMatches(Object element){
71	if (element instanceof WorkbenchPreferenceExtensionNode) {
72	WorkbenchPreferenceExtensionNode workbenchNode = (WorkbenchPreferenceExtensionNode) element;
73
74	Collection keywordCollection = (Collection) keywordCache.get(element);
75	if (keywordCollection == null) {
76	keywordCollection = workbenchNode.getKeywordLabels();
77	keywordCache.put(element, keywordCollection);
78	}
79	if (keywordCollection.isEmpty())
80	return false;
81	Iterator keywords = keywordCollection.iterator();
82	while (keywords.hasNext()) {
83	if (wordMatches((String) keywords.next()))
84	return true;
85	}
86	}
87	return false;
88	}
89
90	/*
91	* (non-Javadoc)
92	* @see org.eclipse.ui.internal.dialogs.PatternFilter#isElementSelectable(java.lang.Object)
93	*/
94	protected boolean isElementSelectable(Object element){
95	return element instanceof WorkbenchPreferenceExtensionNode;
96	}
97
98	/*
99	* (non-Javadoc)
100	* @see org.eclipse.ui.internal.dialogs.PatternFilter#isElementMatch(org.eclipse.jface.viewers.Viewer, java.lang.Object)
101	*/
102	protected boolean isElementMatch(Viewer viewer, Object element){
103	IPreferenceNode node = (IPreferenceNode) element;
104	String text = node.getLabelText();
105
106	if(wordMatches(text))
107	return true;
108
109	return keywordMatches(node);
110	}
111	}