FilterTree处于 org.eclipse.ui.dialogs中，他的显示效果大致如下：
由于需求中要同时展示两颗Tree，并且同时具有过滤功能，如果使用两个FilterTree ，在UI上很难看，所以考虑改写FilterTree，使之同时操控两棵树，最初的方案是继承FilterTree改写他的createControl（）增加一个treeviewer，但发现其中很多私有属性在改写中收到很多限制，于是直接使用了起源，直接在源码内改写，由于它与PatternFilter关系比较紧密，故同时引入，大体思想就是增加一个TreeViewer,改变treeComposite的Layout,并且为新的treeViewer克隆一份过滤处理程序，与之前默认的treeViewer大体相同，最后增加方法支持是否显示新增treeviewer动态设置。
重要代码
CCBFilterTree.java
package com.benson.ccb.favoritites.filterView.filter;
/*******************************************************************************
* Copyright (c) 2004, 2009 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
* Jacek Pospychala - bug 187762
*******************************************************************************/
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.action.ToolBarManager;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.jface.viewers.IContentProvider;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.SWT;
import org.eclipse.swt.accessibility.ACC;
import org.eclipse.swt.accessibility.AccessibleAdapter;
import org.eclipse.swt.accessibility.AccessibleControlAdapter;
import org.eclipse.swt.accessibility.AccessibleControlEvent;
import org.eclipse.swt.accessibility.AccessibleEvent;
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.KeyAdapter;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.MouseAdapter;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.MouseMoveListener;
import org.eclipse.swt.events.MouseTrackListener;
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.Color;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Text;
import org.eclipse.swt.widgets.TreeItem;
import org.eclipse.ui.IWorkbenchPreferenceConstants;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.dialogs.PatternFilter;
import org.eclipse.ui.internal.WorkbenchMessages;
import org.eclipse.ui.plugin.AbstractUIPlugin;
import org.eclipse.ui.progress.WorkbenchJob;
/**
* A simple control that provides a text widget and a tree viewer. The contents
* of the text widget are used to drive a PatternFilter that is on the viewer.
*
* @see org.eclipse.ui.dialogs.PatternFilter
* @since 3.2
*/
public class CCBFilterTree extends Composite {
/**
* The filter text widget to be used by this tree. This value may be
* <code>null</code> if there is no filter widget, or if the controls have
* not yet been created.
*/
protected Text filterText;
/**
* The control representing the clear button for the filter text entry. This
* value may be <code>null</code> if no such button exists, or if the
* controls have not yet been created.
* <p>
* <strong>Note:</strong> As of 3.5, this is not used if the new look is chosen.
* </p>
*/
protected ToolBarManager filterToolBar;
/**
* The control representing the clear button for the filter text entry. This
* value may be <code>null</code> if no such button exists, or if the
* controls have not yet been created.
* <p>
* <strong>Note:</strong> This is only used if the new look is chosen.
* </p>
*
* @since 3.5
*/
protected Control clearButtonControl;
/**
* The viewer for the filtered tree. This value should never be
* <code>null</code> after the widget creation methods are complete.
*/
protected TreeViewer treeViewer;
/**
* The viewer for the extra filtered tree. This value is possible
* <code>null</code>.
*/
protected TreeViewer extraTreeViewer;
/**
* The Composite on which the filter controls are created. This is used to
* set the background color of the filter controls to match the surrounding
* controls.
*/
protected Composite filterComposite;
/**
* The pattern filter for the tree. This value must not be <code>null</code>.
*/
private CCBPatternFilter patternFilter;
/**
* The text to initially show in the filter text control.
*/
protected String initialText = ""; //$NON-NLS-1$
/**
* The job used to refresh the tree.
*/
private Job refreshJob;
private Job refreshJobExtra;
/**
* The parent composite of the filtered tree.
*
* @since 3.3
*/
protected Composite parent;
/**
* Whether or not to show the filter controls (text and clear button). The
* default is to show these controls. This can be overridden by providing a
* setting in the product configuration file. The setting to add to not show
* these controls is:
*
* org.eclipse.ui/SHOW_FILTERED_TEXTS=false
*/
protected boolean showFilterControls;
/**
* @since 3.3
*/
protected Composite treeComposite;
/**
* Tells whether to use the pre 3.5 or the new look.
*
* @since 3.5
*/
private boolean useNewLook = false;
/**
* Image descriptor for enabled clear button.
*/
private static final String CLEAR_ICON = "org.eclipse.ui.internal.dialogs.CLEAR_ICON"; //$NON-NLS-1$
/**
* Image descriptor for disabled clear button.
*/
private static final String DISABLED_CLEAR_ICON= "org.eclipse.ui.internal.dialogs.DCLEAR_ICON"; //$NON-NLS-1$
/**
* Maximum time spent expanding the tree after the filter text has been
* updated (this is only used if we were able to at least expand the visible
* nodes)
*/
private static final long SOFT_MAX_EXPAND_TIME = 200;
/**
* Get image descriptors for the clear button.
*/
static {
ImageDescriptor descriptor = AbstractUIPlugin
.imageDescriptorFromPlugin(PlatformUI.PLUGIN_ID,
"$nl$/icons/full/etool16/clear_co.gif"); //$NON-NLS-1$
if (descriptor != null) {
JFaceResources.getImageRegistry().put(CLEAR_ICON, descriptor);
}
descriptor = AbstractUIPlugin.imageDescriptorFromPlugin(
PlatformUI.PLUGIN_ID, "$nl$/icons/full/dtool16/clear_co.gif"); //$NON-NLS-1$
if (descriptor != null) {
JFaceResources.getImageRegistry().put(DISABLED_CLEAR_ICON, descriptor);
}
}
/**
* Create a new instance of the receiver.
*
* @param parent
* the parent <code>Composite</code>
* @param treeStyle
* the style bits for the <code>Tree</code>
* @param filter
* the filter to be used
*
* @deprecated As of 3.5, replaced by
* {@link #FilteredTree(Composite, int, PatternFilter, boolean)} where using the new
* look is encouraged
*/
public CCBFilterTree(Composite parent, int treeStyle, CCBPatternFilter filter) {
super(parent, SWT.NONE);
this.parent = parent;
init(treeStyle, filter);
}
/**
* Create a new instance of the receiver.
*
* @param parent
* the parent <code>Composite</code>
* @param treeStyle
* the style bits for the <code>Tree</code>
* @param filter
* the filter to be used
* @param useNewLook
* <code>true</code> if the new 3.5 look should be used
* @since 3.5
*/
public CCBFilterTree(Composite parent, int treeStyle, CCBPatternFilter filter, boolean useNewLook) {
super(parent, SWT.NONE);
this.parent = parent;
this.useNewLook= useNewLook;
init(treeStyle, filter);
}
/**
* Create a new instance of the receiver. Subclasses that wish to override
* the default creation behavior may use this constructor, but must ensure
* that the <code>init(composite, int, PatternFilter)</code> method is
* called in the overriding constructor.
*
* @param parent
* the parent <code>Composite</code>
* @see #init(int, PatternFilter)
*
* @since 3.3
* @deprecated As of 3.5, replaced by {@link #FilteredTree(Composite, boolean)} where using the
* look is encouraged
* @wbp.parser.constructor
*/
protected CCBFilterTree(Composite parent) {
super(parent, SWT.NONE);
this.parent = parent;
}
/**
* Create a new instance of the receiver. Subclasses that wish to override
* the default creation behavior may use this constructor, but must ensure
* that the <code>init(composite, int, PatternFilter)</code> method is
* called in the overriding constructor.
*
* @param parent
* the parent <code>Composite</code>
* @param useNewLook
* <code>true</code> if the new 3.5 look should be used
* @see #init(int, PatternFilter)
*
* @since 3.5
*/
protected CCBFilterTree(Composite parent, boolean useNewLook) {
super(parent, SWT.NONE);
this.parent = parent;
this.useNewLook = useNewLook;
}
/**
* Create the filtered tree.
*
* @param treeStyle
* the style bits for the <code>Tree</code>
* @param filter
* the filter to be used
*
* @since 3.3
*/
protected void init(int treeStyle, CCBPatternFilter filter) {
patternFilter = filter;
showFilterControls = PlatformUI.getPreferenceStore().getBoolean(
IWorkbenchPreferenceConstants.SHOW_FILTERED_TEXTS);
createControl(parent, treeStyle);
createRefreshJob();
setInitialText(WorkbenchMessages.FilteredTree_FilterMessage);
setFont(parent.getFont());
}
/**
* Create the filtered tree's controls. Subclasses should override.
*
* @param parent
* @param treeStyle
*/
protected void createControl(Composite parent, int treeStyle) {
GridLayout layout = new GridLayout();
layout.marginHeight = 0;
layout.marginWidth = 0;
setLayout(layout);
setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
if (showFilterControls) {
if (!useNewLook || useNativeSearchField(parent)) {
filterComposite= new Composite(this, SWT.NONE);
} else {
filterComposite= new Composite(this, SWT.BORDER);
filterComposite.setBackground(getDisplay().getSystemColor(SWT.COLOR_LIST_BACKGROUND));
}
GridLayout filterLayout= new GridLayout(2, false);
filterLayout.marginHeight= 0;
filterLayout.marginWidth= 0;
filterLayout.numColumns=2;
filterComposite.setLayout(filterLayout);
filterComposite.setFont(parent.getFont());
createFilterControls(filterComposite);
filterComposite.setLayoutData(new GridData(SWT.FILL, SWT.BEGINNING,
true, false));
}
treeComposite = new Composite(this, SWT.NONE);
GridLayout treeCompositeLayout = new GridLayout();
treeCompositeLayout.marginHeight = 0;
treeCompositeLayout.marginWidth = 0;
treeCompositeLayout.numColumns=2;
treeComposite.setLayout(treeCompositeLayout);
GridData data = new GridData(SWT.FILL, SWT.FILL, true, true);
treeComposite.setLayoutData(data);
treeViewer = createTreeViewer(treeComposite, treeStyle);
extraTreeViewer = createTreeViewer(treeComposite, treeStyle);
treeViewer.getControl().addDisposeListener(new DisposeListener() {
public void widgetDisposed(DisposeEvent e) {
refreshJob.cancel();
}
});
extraTreeViewer.getControl().addDisposeListener(new DisposeListener() {
public void widgetDisposed(DisposeEvent e) {
refreshJobExtra.cancel();
}
});
}
private static Boolean useNativeSearchField;
private static boolean useNativeSearchField(Composite composite) {
if (useNativeSearchField == null) {
useNativeSearchField = Boolean.FALSE;
Text testText = null;
try {
testText = new Text(composite, SWT.SEARCH | SWT.ICON_CANCEL);
useNativeSearchField = new Boolean((testText.getStyle() & SWT.ICON_CANCEL) != 0);
} finally {
if (testText != null) {
testText.dispose();
}
}
}
return useNativeSearchField.booleanValue();
}
/**
* Create the filter controls. By default, a text and corresponding tool bar
* button that clears the contents of the text is created. Subclasses may
* override.
*
* @param parent
* parent <code>Composite</code> of the filter controls
* @return the <code>Composite</code> that contains the filter controls
*/
protected Composite createFilterControls(Composite parent) {
createFilterText(parent);
if (useNewLook)
createClearTextNew(parent);
else
createClearTextOld(parent);
if (clearButtonControl != null) {
// initially there is no text to clear
clearButtonControl.setVisible(false);
}
if (filterToolBar != null) {
filterToolBar.update(false);
// initially there is no text to clear
filterToolBar.getControl().setVisible(false);
}
return parent;
}
/**
* Creates and set up the tree and tree viewer. This method calls
* {@link #doCreateTreeViewer(Composite, int)} to create the tree viewer.
* Subclasses should override {@link #doCreateTreeViewer(Composite, int)}
* instead of overriding this method.
*
* @param parent
* parent <code>Composite</code>
* @param style
* SWT style bits used to create the tree
* @return the tree
*/
protected TreeViewer createTreeViewer(Composite parent, int style) {
TreeViewer treeViewer = doCreateTreeViewer(parent, style);
GridData data = new GridData(SWT.FILL, SWT.FILL, true, true);
treeViewer.getControl().setLayoutData(data);
if (treeViewer instanceof NotifyingTreeViewer) {
patternFilter.setUseCache(true);
}
treeViewer.addFilter(patternFilter);
return treeViewer;
}
/**
* Creates the tree viewer. Subclasses may override.
*
* @param parent
* the parent composite
* @param style
* SWT style bits used to create the tree viewer
* @return the tree viewer
*
* @since 3.3
*/
protected TreeViewer doCreateTreeViewer(Composite parent, int style) {
return new NotifyingTreeViewer(parent, style);
}
/**
* Return the first item in the tree that matches the filter pattern.
*
* @param items
* @return the first matching TreeItem
*/
private TreeItem getFirstMatchingItem(TreeItem[] items) {
for (int i = 0; i < items.length; i++) {
if (patternFilter.isLeafMatch(treeViewer, items[i].getData())
&& patternFilter.isElementSelectable(items[i].getData())) {
return items[i];
}
TreeItem treeItem = getFirstMatchingItem(items[i].getItems());
if (treeItem != null) {
return treeItem;
}
}
return null;
}
/**
* Create the refresh job for the receiver.
*
*/
private void createRefreshJob() {
refreshJob = doCreateRefreshJob();
refreshJob.setSystem(true);
//==================
refreshJobExtra = doCreateRefreshJobExtra();
refreshJobExtra.setSystem(true);
}
/**
* Creates a workbench job that will refresh the tree based on the current filter text.
* Subclasses may override.
*
* @return a workbench job that can be scheduled to refresh the tree
*
* @since 3.4
*/
protected WorkbenchJob doCreateRefreshJob() {
return new WorkbenchJob("Refresh Filter") {//$NON-NLS-1$
public IStatus runInUIThread(IProgressMonitor monitor) {
if (treeViewer.getControl().isDisposed()) {
return Status.CANCEL_STATUS;
}
String text = getFilterString();
if (text == null) {
return Status.OK_STATUS;
}
boolean initial = initialText != null
&& initialText.equals(text);
if (initial) {
patternFilter.setPattern(null);
} else if (text != null) {
patternFilter.setPattern(text);
}
Control redrawFalseControl = treeComposite != null ? treeComposite
: treeViewer.getControl();
try {
// don't want the user to see updates that will be made to
// the tree
// we are setting redraw(false) on the composite to avoid
// dancing scrollbar
redrawFalseControl.setRedraw(false);
if (!narrowingDown) {
// collapse all
TreeItem[] is = treeViewer.getTree().getItems();
for (int i = 0; i < is.length; i++) {
TreeItem item = is[i];
if (item.getExpanded()) {
treeViewer.setExpandedState(item.getData(),
false);
}
}
}
treeViewer.refresh(true);
if (text.length() > 0 && !initial) {
/*
* Expand elements one at a time. After each is
* expanded, check to see if the filter text has been
* modified. If it has, then cancel the refresh job so
* the user doesn't have to endure expansion of all the
* nodes.
*/
TreeItem[] items = getViewer().getTree().getItems();
int treeHeight = getViewer().getTree().getBounds().height;
int numVisibleItems = treeHeight
/ getViewer().getTree().getItemHeight();
long stopTime = SOFT_MAX_EXPAND_TIME
+ System.currentTimeMillis();
boolean cancel = false;
if (items.length > 0
&& recursiveExpand(items, monitor, stopTime,
new int[] { numVisibleItems })) {
cancel = true;
}
// enabled toolbar - there is text to clear
// and the list is currently being filtered
updateToolbar(true);
if (cancel) {
return Status.CANCEL_STATUS;
}
} else {
// disabled toolbar - there is no text to clear
// and the list is currently not filtered
updateToolbar(false);
}
} finally {
// done updating the tree - set redraw back to true
TreeItem[] items = getViewer().getTree().getItems();
if (items.length > 0
&& getViewer().getTree().getSelectionCount() == 0) {
treeViewer.getTree().setTopItem(items[0]);
}
redrawFalseControl.setRedraw(true);
}
return Status.OK_STATUS;
}
/**
* Returns true if the job should be canceled (because of timeout or
* actual cancellation).
*
* @param items
* @param monitor
* @param cancelTime
* @param numItemsLeft
* @return true if canceled
*/
private boolean recursiveExpand(TreeItem[] items,
IProgressMonitor monitor, long cancelTime,
int[] numItemsLeft) {
boolean canceled = false;
for (int i = 0; !canceled && i < items.length; i++) {
TreeItem item = items[i];
boolean visible = numItemsLeft[0]-- >= 0;
if (monitor.isCanceled()
|| (!visible && System.currentTimeMillis() > cancelTime)) {
canceled = true;
} else {
Object itemData = item.getData();
if (itemData != null) {
if (!item.getExpanded()) {
// do the expansion through the viewer so that
// it can refresh children appropriately.
treeViewer.setExpandedState(itemData, true);
}
TreeItem[] children = item.getItems();
if (items.length > 0) {
canceled = recursiveExpand(children, monitor,
cancelTime, numItemsLeft);
}
}
}
}
return canceled;
}
};
}
protected WorkbenchJob doCreateRefreshJobExtra() {
return new WorkbenchJob("Refresh Filter Extra") {//$NON-NLS-1$
public IStatus runInUIThread(IProgressMonitor monitor) {
if (extraTreeViewer.getControl().isDisposed()) {
return Status.CANCEL_STATUS;
}
String text = getFilterString();
if (text == null) {
return Status.OK_STATUS;
}
boolean initial = initialText != null
&& initialText.equals(text);
if (initial) {
patternFilter.setPattern(null);
} else if (text != null) {
patternFilter.setPattern(text);
}
Control redrawFalseControl = treeComposite != null ? treeComposite
: extraTreeViewer.getControl();
try {
// don't want the user to see updates that will be made to
// the tree
// we are setting redraw(false) on the composite to avoid
// dancing scrollbar
redrawFalseControl.setRedraw(false);
if (!narrowingDown) {
// collapse all
TreeItem[] is = extraTreeViewer.getTree().getItems();
for (int i = 0; i < is.length; i++) {
TreeItem item = is[i];
if (item.getExpanded()) {
extraTreeViewer.setExpandedState(item.getData(),
false);
}
}
}
extraTreeViewer.refresh(true);
if (text.length() > 0 && !initial) {
/*
* Expand elements one at a time. After each is
* expanded, check to see if the filter text has been
* modified. If it has, then cancel the refresh job so
* the user doesn't have to endure expansion of all the
* nodes.
*/
TreeItem[] items = getExtraTreeViewer().getTree().getItems();
int treeHeight = getExtraTreeViewer().getTree().getBounds().height;
int numVisibleItems = treeHeight
/ getExtraTreeViewer().getTree().getItemHeight();
long stopTime = SOFT_MAX_EXPAND_TIME
+ System.currentTimeMillis();
boolean cancel = false;
if (items.length > 0
&& recursiveExpand(items, monitor, stopTime,
new int[] { numVisibleItems })) {
cancel = true;
}
// enabled toolbar - there is text to clear
// and the list is currently being filtered
updateToolbar(true);
if (cancel) {
return Status.CANCEL_STATUS;
}
} else {
// disabled toolbar - there is no text to clear
// and the list is currently not filtered
updateToolbar(false);
}
} finally {
// done updating the tree - set redraw back to true
TreeItem[] items = getExtraTreeViewer().getTree().getItems();
if (items.length > 0
&& getExtraTreeViewer().getTree().getSelectionCount() == 0) {
extraTreeViewer.getTree().setTopItem(items[0]);
}
redrawFalseControl.setRedraw(true);
}
return Status.OK_STATUS;
}
/**
* Returns true if the job should be canceled (because of timeout or
* actual cancellation).
*
* @param items
* @param monitor
* @param cancelTime
* @param numItemsLeft
* @return true if canceled
*/
private boolean recursiveExpand(TreeItem[] items,
IProgressMonitor monitor, long cancelTime,
int[] numItemsLeft) {
boolean canceled = false;
for (int i = 0; !canceled && i < items.length; i++) {
TreeItem item = items[i];
boolean visible = numItemsLeft[0]-- >= 0;
if (monitor.isCanceled()
|| (!visible && System.currentTimeMillis() > cancelTime)) {
canceled = true;
} else {
Object itemData = item.getData();
if (itemData != null) {
if (!item.getExpanded()) {
// do the expansion through the viewer so that
// it can refresh children appropriately.
extraTreeViewer.setExpandedState(itemData, true);
}
TreeItem[] children = item.getItems();
if (items.length > 0) {
canceled = recursiveExpand(children, monitor,
cancelTime, numItemsLeft);
}
}
}
}
return canceled;
}
};
}
//============================================================================
protected void updateToolbar(boolean visible) {
if (clearButtonControl != null) {
clearButtonControl.setVisible(visible);
}
if (filterToolBar != null) {
filterToolBar.getControl().setVisible(visible);
}
}
/**
* Creates the filter text and adds listeners. This method calls
* {@link #doCreateFilterText(Composite)} to create the text control.
* Subclasses should override {@link #doCreateFilterText(Composite)} instead
* of overriding this method.
*
* @param parent
* <code>Composite</code> of the filter text
*/
protected void createFilterText(Composite parent) {
filterText = doCreateFilterText(parent);
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 = filterText.getText();
if (filterTextString.length() == 0
|| filterTextString.equals(initialText)) {
e.result = initialText;
} else {
e.result = NLS
.bind(
WorkbenchMessages.FilteredTree_AccessibleListenerFiltered,
new String[] {
filterTextString,
String
.valueOf(getFilteredItemsCount()) });
}
}
/**
* Return the number of filtered items
* @return int
*/
private int getFilteredItemsCount() {
int total = 0;
TreeItem[] items = getViewer().getTree().getItems();
for (int i = 0; i < items.length; i++) {
total += itemCount(items[i]);
}
return total;
}
// private int getFilteredItemsCount() {
// int total = 0;
// TreeItem[] items = getViewer().getTree().getItems();
// TreeItem[] items1 = getExtraTreeViewer().getTree()
// .getItems();
//
// TreeItem[] allItems = new TreeItem[items.length
// + items1.length];
// System.arraycopy(items, 0, allItems, 0, items.length);
// System.arraycopy(items1, 0, allItems, items.length,
// items1.length);
// for (int i = 0; i < allItems.length; i++) {
// total += itemCount(allItems[i]);
//
// }
// return total;
// }
/**
* Return the count of treeItem and it's children to infinite depth.
* @param treeItem
* @return int
*/
private int itemCount(TreeItem treeItem) {
int count = 1;
TreeItem[] children = treeItem.getItems();
for (int i = 0; i < children.length; i++) {
count += itemCount(children[i]);
}
return count;
}
});
filterText.addFocusListener(new FocusAdapter() {
/*
* (non-Javadoc)
*
* @see org.eclipse.swt.events.FocusListener#focusLost(org.eclipse.swt.events.FocusEvent)
*/
public void focusGained(FocusEvent e) {
if (!useNewLook) {
/*
* Running in an asyncExec because the selectAll() does not appear to work when
* using mouse to give focus to text.
*/
Display display= filterText.getDisplay();
display.asyncExec(new Runnable() {
public void run() {
if (!filterText.isDisposed()) {
if (getInitialText().equals(
filterText.getText().trim())) {
filterText.selectAll();
}
}
}
});
return;
}
}
/*
* (non-Javadoc)
*
* @see org.eclipse.swt.events.FocusAdapter#focusLost(org.eclipse.swt.events.FocusEvent)
*/
public void focusLost(FocusEvent e) {
if (!useNewLook) {
return;
}
if (filterText.getText().equals(initialText)) {
setFilterText(""); //$NON-NLS-1$
textChanged();
}
}
});
if (useNewLook) {
filterText.addMouseListener(new MouseAdapter() {
/*
* (non-Javadoc)
*
* @see
* org.eclipse.swt.events.MouseAdapter#mouseDown(org.eclipse.swt.events.MouseEvent)
*/
public void mouseDown(MouseEvent e) {
if (filterText.getText().equals(initialText)) {
// XXX: We cannot call clearText() due to https://bugs.eclipse.org/bugs/show_bug.cgi?id=260664
setFilterText(""); //$NON-NLS-1$
textChanged();
}
}
});
}
filterText.addKeyListener(new KeyAdapter() {
/*
* (non-Javadoc)
*
* @see org.eclipse.swt.events.KeyAdapter#keyReleased(org.eclipse.swt.events.KeyEvent)
*/
public void keyPressed(KeyEvent e) {
// on a CR we want to transfer focus to the list
boolean hasItems = getViewer().getTree().getItemCount() > 0;
if (hasItems && e.keyCode == SWT.ARROW_DOWN) {
treeViewer.getTree().setFocus();
return;
}
}
});
// enter key set focus to tree
filterText.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();
} else {
// if the initial filter text hasn't changed, do not try
// to match
boolean hasFocus = getViewer().getTree().setFocus();
boolean textChanged = !getInitialText().equals(
filterText.getText().trim());
if (hasFocus && textChanged
&& filterText.getText().trim().length() > 0) {
TreeItem item = getFirstMatchingItem(getViewer()
.getTree().getItems());
if (item != null) {
getViewer().getTree().setSelection(
new TreeItem[] { item });
ISelection sel = getViewer().getSelection();
getViewer().setSelection(sel, true);
}
}
}
}
}
});
filterText.addModifyListener(new ModifyListener() {
/*
* (non-Javadoc)
*
* @see org.eclipse.swt.events.ModifyListener#modifyText(org.eclipse.swt.events.ModifyEvent)
*/
public void modifyText(ModifyEvent e) {
textChanged();
}
});
// if we're using a field with built in cancel we need to listen for
// default selection changes (which tell us the cancel button has been
// pressed)
if ((filterText.getStyle() & SWT.ICON_CANCEL) != 0) {
filterText.addSelectionListener(new SelectionAdapter() {
/*
* (non-Javadoc)
*
* @see org.eclipse.swt.events.SelectionAdapter#widgetDefaultSelected(org.eclipse.swt.events.SelectionEvent)
*/
public void widgetDefaultSelected(SelectionEvent e) {
if (e.detail == SWT.ICON_CANCEL)
clearText();
}
});
}
GridData gridData= new GridData(SWT.FILL, SWT.CENTER, true, false);
// if the text widget supported cancel then it will have it's own
// integrated button. We can take all of the space.
if ((filterText.getStyle() & SWT.ICON_CANCEL) != 0)
gridData.horizontalSpan = 2;
filterText.setLayoutData(gridData);
}
/**
* Creates the text control for entering the filter text. Subclasses may
* override.
*
* @param parent
* the parent composite
* @return the text widget
*
* @since 3.3
*/
protected Text doCreateFilterText(Composite parent) {
if (!useNewLook || useNativeSearchField(parent)) {
return new Text(parent, SWT.SINGLE | SWT.BORDER | SWT.SEARCH
| SWT.ICON_CANCEL);
}
return new Text(parent, SWT.SINGLE);
}
private String previousFilterText;
private boolean narrowingDown;
/**
* Update the receiver after the text has changed.
*/
protected void textChanged() {
narrowingDown = previousFilterText == null
|| getFilterString().startsWith(previousFilterText);
previousFilterText = getFilterString();
// cancel currently running job first, to prevent unnecessary redraw
refreshJob.cancel();
refreshJob.schedule(getRefreshJobDelay());
refreshJobExtra.cancel();
refreshJobExtra.schedule(getRefreshJobDelay());
}
/**
* Return the time delay that should be used when scheduling the
* filter refresh job. Subclasses may override.
*
* @return a time delay in milliseconds before the job should run
*
* @since 3.5
*/
protected long getRefreshJobDelay() {
return 200;
}
/**
* Set the background for the widgets that support the filter text area.
*
* @param background
* background <code>Color</code> to set
*/
public void setBackground(Color background) {
super.setBackground(background);
if (filterComposite != null && (!useNewLook || useNativeSearchField(filterComposite))) {
filterComposite.setBackground(background);
}
if (filterToolBar != null && filterToolBar.getControl() != null) {
filterToolBar.getControl().setBackground(background);
}
}
/**
* Create the button that clears the text.
*
* @param parent
* parent <code>Composite</code> of toolbar button
*/
private void createClearTextOld(Composite parent) {
// only create the button if the text widget doesn't support one
// natively
if ((filterText.getStyle() & SWT.ICON_CANCEL) == 0) {
filterToolBar= new ToolBarManager(SWT.FLAT | SWT.HORIZONTAL);
filterToolBar.createControl(parent);
IAction clearTextAction= new Action("", IAction.AS_PUSH_BUTTON) {//$NON-NLS-1$
/*
* (non-Javadoc)
*
* @see org.eclipse.jface.action.Action#run()
*/
public void run() {
clearText();
}
};
clearTextAction
.setToolTipText(WorkbenchMessages.FilteredTree_ClearToolTip);
clearTextAction.setImageDescriptor(JFaceResources
.getImageRegistry().getDescriptor(CLEAR_ICON));
clearTextAction.setDisabledImageDescriptor(JFaceResources
.getImageRegistry().getDescriptor(DISABLED_CLEAR_ICON));
filterToolBar.add(clearTextAction);
}
}
/**
* Create the button that clears the text.
*
* @param parent parent <code>Composite</code> of toolbar button
*/
private void createClearTextNew(Composite parent) {
// only create the button if the text widget doesn't support one
// natively
if ((filterText.getStyle() & SWT.ICON_CANCEL) == 0) {
final Image inactiveImage= JFaceResources.getImageRegistry().getDescriptor(DISABLED_CLEAR_ICON).createImage();
final Image activeImage= JFaceResources.getImageRegistry().getDescriptor(CLEAR_ICON).createImage();
final Image pressedImage= new Image(getDisplay(), activeImage, SWT.IMAGE_GRAY);
final Label clearButton= new Label(parent, SWT.NONE);
clearButton.setLayoutData(new GridData(SWT.BEGINNING, SWT.CENTER, false, false));
clearButton.setImage(inactiveImage);
clearButton.setBackground(parent.getDisplay().getSystemColor(SWT.COLOR_LIST_BACKGROUND));
clearButton.setToolTipText(WorkbenchMessages.FilteredTree_ClearToolTip);
clearButton.addMouseListener(new MouseAdapter() {
private MouseMoveListener fMoveListener;
public void mouseDown(MouseEvent e) {
clearButton.setImage(pressedImage);
fMoveListener= new MouseMoveListener() {
private boolean fMouseInButton= true;
public void mouseMove(MouseEvent e) {
boolean mouseInButton= isMouseInButton(e);
if (mouseInButton != fMouseInButton) {
fMouseInButton= mouseInButton;
clearButton.setImage(mouseInButton ? pressedImage : inactiveImage);
}
}
};
clearButton.addMouseMoveListener(fMoveListener);
}
public void mouseUp(MouseEvent e) {
if (fMoveListener != null) {
clearButton.removeMouseMoveListener(fMoveListener);
fMoveListener= null;
boolean mouseInButton= isMouseInButton(e);
clearButton.setImage(mouseInButton ? activeImage : inactiveImage);
if (mouseInButton) {
clearText();
filterText.setFocus();
}
}
}
private boolean isMouseInButton(MouseEvent e) {
Point buttonSize = clearButton.getSize();
return 0 <= e.x && e.x < buttonSize.x && 0 <= e.y && e.y < buttonSize.y;
}
});
clearButton.addMouseTrackListener(new MouseTrackListener() {
public void mouseEnter(MouseEvent e) {
clearButton.setImage(activeImage);
}
public void mouseExit(MouseEvent e) {
clearButton.setImage(inactiveImage);
}
public void mouseHover(MouseEvent e) {
}
});
clearButton.addDisposeListener(new DisposeListener() {
public void widgetDisposed(DisposeEvent e) {
inactiveImage.dispose();
activeImage.dispose();
pressedImage.dispose();
}
});
clearButton.getAccessible().addAccessibleListener(
new AccessibleAdapter() {
public void getName(AccessibleEvent e) {
e.result= WorkbenchMessages.FilteredTree_AccessibleListenerClearButton;
}
});
clearButton.getAccessible().addAccessibleControlListener(
new AccessibleControlAdapter() {
public void getRole(AccessibleControlEvent e) {
e.detail= ACC.ROLE_PUSHBUTTON;
}
});
this.clearButtonControl= clearButton;
}
}
/**
* Clears the text in the filter text widget.
*/
protected void clearText() {
setFilterText(""); //$NON-NLS-1$
textChanged();
}
/**
* Set the text in the filter control.
*
* @param string
*/
protected void setFilterText(String string) {
if (filterText != null) {
filterText.setText(string);
selectAll();
}
}
/**
* Returns the pattern filter used by this tree.
*
* @return The pattern filter; never <code>null</code>.
*/
public final CCBPatternFilter getPatternFilter() {
return patternFilter;
}
/**
* Get the tree viewer of the receiver.
*
* @return the tree viewer
*/
public TreeViewer getViewer() {
return treeViewer;
}
/**
* 获得附加树
* @return
*/
public TreeViewer getExtraTreeViewer() {
return extraTreeViewer;
}
/**
* Get the filter text for the receiver, if it was created. Otherwise return
* <code>null</code>.
*
* @return the filter Text, or null if it was not created
*/
public Text getFilterControl() {
return filterText;
}
/**
* Convenience method to return the text of the filter control. If the text
* widget is not created, then null is returned.
*
* @return String in the text, or null if the text does not exist
*/
protected String getFilterString() {
return filterText != null ? filterText.getText() : null;
}
/**
* Set the text that will be shown until the first focus. A default value is
* provided, so this method only need be called if overriding the default
* initial text is desired.
*
* @param text
* initial text to appear in text field
*/
public void setInitialText(String text) {
initialText = text;
if (useNewLook && filterText != null) {
filterText.setMessage(text);
if (filterText.isFocusControl()) {
setFilterText(initialText);
textChanged();
} else {
getDisplay().asyncExec(new Runnable() {
public void run() {
if (!filterText.isDisposed() && filterText.isFocusControl()) {
setFilterText(initialText);
textChanged();
}
}
});
}
} else {
setFilterText(initialText);
textChanged();
}
}
/**
* Select all text in the filter text field.
*
*/
protected void selectAll() {
if (filterText != null) {
filterText.selectAll();
}
}
/**
* Get the initial text for the receiver.
*
* @return String
*/
protected String getInitialText() {
return initialText;
}
/**
* Return a bold font if the given element matches the given pattern.
* Clients can opt to call this method from a Viewer's label provider to get
* a bold font for which to highlight the given element in the tree.
*
* @param element
* element for which a match should be determined
* @param tree
* FilteredTree in which the element resides
* @param filter
* PatternFilter which determines a match
*
* @return bold font
*/
public static Font getBoldFont(Object element, CCBFilterTree tree,
CCBPatternFilter filter) {
String filterText = tree.getFilterString();
if (filterText == null) {
return null;
}
// Do nothing if it's empty string
String initialText = tree.getInitialText();
if (!filterText.equals("") && !filterText.equals(initialText)) {//$NON-NLS-1$
if (tree.getPatternFilter() != filter) {
boolean initial= initialText != null
&& initialText.equals(filterText);
if (initial) {
filter.setPattern(null);
} else if (filterText != null) {
filter.setPattern(filterText);
}
}
if (filter.isElementVisible(tree.getViewer(), element)
&& filter.isLeafMatch(tree.getViewer(), element)) {
return JFaceResources.getFontRegistry().getBold(
JFaceResources.DIALOG_FONT);
}
}
return null;
}
/**
* Custom tree viewer subclass that clears the caches in patternFilter on
* any change to the tree. See bug 187200.
*
* @since 3.3
*
*/
class NotifyingTreeViewer extends TreeViewer {
/**
* @param parent
* @param style
*/
public NotifyingTreeViewer(Composite parent, int style) {
super(parent, style);
}
public void add(Object parentElementOrTreePath, Object childElement) {
getPatternFilter().clearCaches();
super.add(parentElementOrTreePath, childElement);
}
public void add(Object parentElementOrTreePath, Object[] childElements) {
getPatternFilter().clearCaches();
super.add(parentElementOrTreePath, childElements);
}
protected void inputChanged(Object input, Object oldInput) {
getPatternFilter().clearCaches();
super.inputChanged(input, oldInput);
}
public void insert(Object parentElementOrTreePath, Object element,
int position) {
getPatternFilter().clearCaches();
super.insert(parentElementOrTreePath, element, position);
}
public void refresh() {
getPatternFilter().clearCaches();
super.refresh();
}
public void refresh(boolean updateLabels) {
getPatternFilter().clearCaches();
super.refresh(updateLabels);
}
public void refresh(Object element) {
getPatternFilter().clearCaches();
super.refresh(element);
}
public void refresh(Object element, boolean updateLabels) {
getPatternFilter().clearCaches();
super.refresh(element, updateLabels);
}
public void remove(Object elementsOrTreePaths) {
getPatternFilter().clearCaches();
super.remove(elementsOrTreePaths);
}
public void remove(Object parent, Object[] elements) {
getPatternFilter().clearCaches();
super.remove(parent, elements);
}
public void remove(Object[] elementsOrTreePaths) {
getPatternFilter().clearCaches();
super.remove(elementsOrTreePaths);
}
public void replace(Object parentElementOrTreePath, int index,
Object element) {
getPatternFilter().clearCaches();
super.replace(parentElementOrTreePath, index, element);
}
public void setChildCount(Object elementOrTreePath, int count) {
getPatternFilter().clearCaches();
super.setChildCount(elementOrTreePath, count);
}
public void setContentProvider(IContentProvider provider) {
getPatternFilter().clearCaches();
super.setContentProvider(provider);
}
public void setHasChildren(Object elementOrTreePath, boolean hasChildren) {
getPatternFilter().clearCaches();
super.setHasChildren(elementOrTreePath, hasChildren);
}
}
/**
* 隐藏/展示 附加树
*/
public void setExtraTreeViewerUIState(boolean visible){
GridData gd = (GridData) extraTreeViewer.getControl().getLayoutData();
GridLayout treeCompositeLayout= (GridLayout)treeComposite.getLayout();
if(visible){
gd.exclude=false;
treeCompositeLayout.numColumns=2;
}else{
gd.exclude=true;
treeCompositeLayout.numColumns=1;
}
extraTreeViewer.getControl().setVisible(visible);
treeComposite.layout();
}
}
//================================================================================
CCBPatternFilter.java
package com.benson.ccb.favoritites.filterView.filter;
/*******************************************************************************
* Copyright (c) 2004, 2009 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.eclipse.jface.viewers.AbstractTreeViewer;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.StructuredViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerFilter;
import org.eclipse.ui.internal.misc.StringMatcher;
import com.ibm.icu.text.BreakIterator;
/**
* A filter used in conjunction with <code>FilteredTree</code>. In order to
* determine if a node should be filtered it uses the content and label provider
* of the tree to do pattern matching on its children. This causes the entire
* tree structure to be realized. Note that the label provider must implement
* ILabelProvider.
*
* @see org.eclipse.ui.dialogs.FilteredTree
* @since 3.2
*/
public class CCBPatternFilter extends ViewerFilter {
/*
* Cache of filtered elements in the tree
*/
private Map cache = new HashMap();
/*
* Maps parent elements to TRUE or FALSE
*/
private Map foundAnyCache = new HashMap();
private boolean useCache = false;
/**
* Whether to include a leading wildcard for all provided patterns. A
* trailing wildcard is always included.
*/
private boolean includeLeadingWildcard = false;
/**
* The string pattern matcher used for this pattern filter.
*/
private StringMatcher matcher;
private boolean useEarlyReturnIfMatcherIsNull = true;
private static Object[] EMPTY = new Object[0];
/* (non-Javadoc)
* @see org.eclipse.jface.viewers.ViewerFilter#filter(org.eclipse.jface.viewers.Viewer, java.lang.Object, java.lang.Object[])
*/
public final Object[] filter(Viewer viewer, Object parent, Object[] elements) {
// we don't want to optimize if we've extended the filter ... this
// needs to be addressed in 3.4
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=186404
if (matcher == null && useEarlyReturnIfMatcherIsNull) {
return elements;
}
if (!useCache) {
return super.filter(viewer, parent, elements);
}
Object[] filtered = (Object[]) cache.get(parent);
if (filtered == null) {
Boolean foundAny = (Boolean) foundAnyCache.get(parent);
if (foundAny != null && !foundAny.booleanValue()) {
filtered = EMPTY;
} else {
filtered = super.filter(viewer, parent, elements);
}
cache.put(parent, filtered);
}
return filtered;
}
/**
* Returns true if any of the elements makes it through the filter.
* This method uses caching if enabled; the computation is done in
* computeAnyVisible.
*
* @param viewer
* @param parent
* @param elements the elements (must not be an empty array)
* @return true if any of the elements makes it through the filter.
*/
private boolean isAnyVisible(Viewer viewer, Object parent, Object[] elements) {
if (matcher == null) {
return true;
}
if (!useCache) {
return computeAnyVisible(viewer, elements);
}
Object[] filtered = (Object[]) cache.get(parent);
if (filtered != null) {
return filtered.length > 0;
}
Boolean foundAny = (Boolean) foundAnyCache.get(parent);
if (foundAny == null) {
foundAny = computeAnyVisible(viewer, elements) ? Boolean.TRUE : Boolean.FALSE;
foundAnyCache.put(parent, foundAny);
}
return foundAny.booleanValue();
}
/**
* Returns true if any of the elements makes it through the filter.
*
* @param viewer the viewer
* @param elements the elements to test
* @return <code>true</code> if any of the elements makes it through the filter
*/
private boolean computeAnyVisible(Viewer viewer, Object[] elements) {
boolean elementFound = false;
for (int i = 0; i < elements.length && !elementFound; i++) {
Object element = elements[i];
elementFound = isElementVisible(viewer, element);
}
return elementFound;
}
/* (non-Javadoc)
* @see org.eclipse.jface.viewers.ViewerFilter#select(org.eclipse.jface.viewers.Viewer, java.lang.Object, java.lang.Object)
*/
public final boolean select(Viewer viewer, Object parentElement,
Object element) {
return isElementVisible(viewer, element);
}
/**
* Sets whether a leading wildcard should be attached to each pattern
* string.
*
* @param includeLeadingWildcard
* Whether a leading wildcard should be added.
*/
public final void setIncludeLeadingWildcard(
final boolean includeLeadingWildcard) {
this.includeLeadingWildcard = includeLeadingWildcard;
}
/**
* The pattern string for which this filter should select
* elements in the viewer.
*
* @param patternString
*/
public void setPattern(String patternString) {
// these 2 strings allow the PatternFilter to be extended in
// 3.3 - https://bugs.eclipse.org/bugs/show_bug.cgi?id=186404
if ("org.eclipse.ui.keys.optimization.true".equals(patternString)) { //$NON-NLS-1$
useEarlyReturnIfMatcherIsNull = true;
return;
} else if ("org.eclipse.ui.keys.optimization.false".equals(patternString)) { //$NON-NLS-1$
useEarlyReturnIfMatcherIsNull = false;
return;
}
clearCaches();
if (patternString == null || patternString.equals("")) { //$NON-NLS-1$
matcher = null;
} else {
String pattern = patternString + "*"; //$NON-NLS-1$
if (includeLeadingWildcard) {
pattern = "*" + pattern; //$NON-NLS-1$
}
matcher = new StringMatcher(pattern, true, false);
}
}
/**
* Clears the caches used for optimizing this filter. Needs to be called whenever
* the tree content changes.
*/
/* package */ void clearCaches() {
cache.clear();
foundAnyCache.clear();
}
/**
* Answers whether the given String matches the pattern.
*
* @param string the String to test
*
* @return whether the string matches the pattern
*/
private boolean match(String string) {
if (matcher == null) {
return true;
}
return matcher.match(string);
}
/**
* Answers whether the given element is a valid selection in
* the filtered tree. For example, if a tree has items that
* are categorized, the category itself may not be a valid
* selection since it is used merely to organize the elements.
*
* @param element
* @return true if this element is eligible for automatic selection
*/
public boolean isElementSelectable(Object element){
return element != null;
}
/**
* Answers whether the given element in the given viewer matches
* the filter pattern. This is a default implementation that will
* show a leaf element in the tree based on whether the provided
* filter text matches the text of the given element's text, or that
* of it's children (if the element has any).
*
* Subclasses may override this method.
*
* @param viewer the tree viewer in which the element resides
* @param element the element in the tree to check for a match
*
* @return true if the element matches the filter pattern
*/
public boolean isElementVisible(Viewer viewer, Object element){
return isParentMatch(viewer, element) || isLeafMatch(viewer, element);
}
/**
* Check if the parent (category) is a match to the filter text. The default
* behavior returns true if the element has at least one child element that is
* a match with the filter text.
*
* Subclasses may override this method.
*
* @param viewer the viewer that contains the element
* @param element the tree element to check
* @return true if the given element has children that matches the filter text
*/
protected boolean isParentMatch(Viewer viewer, Object element){
Object[] children = ((ITreeContentProvider) ((AbstractTreeViewer) viewer)
.getContentProvider()).getChildren(element);
if ((children != null) && (children.length > 0)) {
return isAnyVisible(viewer, element, children);
}
return false;
}
/**
* Check if the current (leaf) element is a match with the filter text.
* The default behavior checks that the label of the element is a match.
*
* Subclasses should override this method.
*
* @param viewer the viewer that contains the element
* @param element the tree element to check
* @return true if the given element's label matches the filter text
*/
protected boolean isLeafMatch(Viewer viewer, Object element){
String labelText = ((ILabelProvider) ((StructuredViewer) viewer)
.getLabelProvider()).getText(element);
if(labelText == null) {
return false;
}
return wordMatches(labelText);
}
/**
* Take the given filter text and break it down into words using a
* BreakIterator.
*
* @param text
* @return an array of words
*/
private String[] getWords(String text){
List words = new ArrayList();
// Break the text up into words, separating based on whitespace and
// common punctuation.
// Previously used String.split(..., "\\W"), where "\W" is a regular
// expression (see the Javadoc for class Pattern).
// Need to avoid both String.split and regular expressions, in order to
// compile against JCL Foundation (bug 80053).
// Also need to do this in an NL-sensitive way. The use of BreakIterator
// was suggested in bug 90579.
BreakIterator iter = BreakIterator.getWordInstance();
iter.setText(text);
int i = iter.first();
while (i != java.text.BreakIterator.DONE && i < text.length()) {
int j = iter.following(i);
if (j == java.text.BreakIterator.DONE) {
j = text.length();
}
// match the word
if (Character.isLetterOrDigit(text.charAt(i))) {
String word = text.substring(i, j);
words.add(word);
}
i = j;
}
return (String[]) words.toArray(new String[words.size()]);
}
/**
* Return whether or not if any of the words in text satisfy the
* match critera.
*
* @param text the text to match
* @return boolean <code>true</code> if one of the words in text
* satisifes the match criteria.
*/
protected boolean wordMatches(String text) {
if (text == null) {
return false;
}
//If the whole text matches we are all set
if(match(text)) {
return true;
}
// Otherwise check if any of the words of the text matches
String[] words = getWords(text);
for (int i = 0; i < words.length; i++) {
String word = words[i];
if (match(word)) {
return true;
}
}
return false;
}
/**
* Can be called by the filtered tree to turn on caching.
*
* @param useCache The useCache to set.
*/
void setUseCache(boolean useCache) {
this.useCache = useCache;
}
}
FilterTreeView.java (具体展示的视图)
package com.benson.ccb.favoritites.filterView;
import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.commands.IHandler;
import org.eclipse.jface.action.IMenuListener;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.ui.IWorkbenchActionConstants;
import org.eclipse.ui.part.ViewPart;
import com.benson.ccb.favoritites.command.contributions.RemoveContributionItem;
import com.benson.ccb.favoritites.filterView.filter.CCBPatternFilter;
import com.benson.ccb.favoritites.filterView.filter.CCBFilterTree;
public class FilterTreeView extends ViewPart {
TreeViewer treeViewer;
TreeViewer treeViewer1;
IHandler removeHandler;
RemoveContributionItem removeContributionItem;
CCBFilterTree filterTree;
public TreeViewer getTreeViewer() {
return treeViewer;
}
@Override
public void createPartControl(Composite parent) {
// TODO Auto-generated method stub
// 过滤树
filterTree = new CCBFilterTree(parent, SWT.MULTI
| SWT.V_SCROLL | SWT.H_SCROLL | SWT.SINGLE,
new CCBPatternFilter(), true);
treeViewer = filterTree.getViewer();
treeViewer1 = filterTree.getExtraTreeViewer();
// treeViewer = new TreeViewer(parent, SWT.BORDER);
Tree tree = treeViewer.getTree();
treeViewer.setLabelProvider(new MyLabelProvider());
treeViewer.setContentProvider(new MyContentProvider());
treeViewer.setInput(new Factory().createData());
treeViewer.expandAll();
treeViewer1.setLabelProvider(new MyLabelProvider());
treeViewer1.setContentProvider(new MyContentProvider());
treeViewer1.setInput(new Factory().createData1());
treeViewer1.expandAll();
createContextMenu();
createContibution();
}
/**
* 创建上下文菜单
*/
private void createContextMenu() {
MenuManager mm = new MenuManager("#Popup Menu");
mm.setRemoveAllWhenShown(true); //这个就是定义菜单显示的时候先清空
mm.addMenuListener(new IMenuListener() {
@Override
public void menuAboutToShow(IMenuManager manager) {
// TODO Auto-generated method stub
FilterTreeView.this.fillContextMenu(manager);
}
});
Menu menu = mm.createContextMenu(treeViewer.getControl());
treeViewer.getControl().setMenu(menu);
this.getSite().registerContextMenu(mm, treeViewer);
}
private void fillContextMenu(IMenuManager menuManager) {
menuManager.add(removeContributionItem);
menuManager.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));
}
@Override
public void setFocus() {
// TODO Auto-generated method stub
treeViewer.getControl().setFocus();
}
private void createContibution(){
removeHandler=new RemoveHanlder();
removeContributionItem=new RemoveContributionItem(this, removeHandler);
}
class RemoveHanlder extends AbstractHandler {
@Override
public Object execute(ExecutionEvent event) throws ExecutionException {
// TODO Auto-generated method stub
System.out.println("执行删除操作");
return null;
}
}
public CCBFilterTree getFilterTree() {
return filterTree;
}
}