import org.eclipse.jface.viewers.TreeViewer;

import org.eclipse.jface.viewers.*;

import org.eclipse.jface.viewers.Viewer;

		if (useCheckBoxTree)

		if (useCheckBoxTree) {

			return new ContainerCheckedTreeViewer(composite, style);

			final ContainerCheckedTreeViewer v = new ContainerCheckedTreeViewer(composite, style);

			v.addCheckStateListener(new ICheckStateListener() {

				public void checkStateChanged(CheckStateChangedEvent event) {

					// We use an additive check state cache so we need to remove

					// previously checked items if the user unchecked them.

					if (!event.getChecked() && checkState != null) {

						Iterator iter = checkState.iterator();

						ArrayList toRemove = new ArrayList(1);

						while (iter.hasNext()) {

							Object element = iter.next();

							if (v.getComparer().equals(element, event.getElement())) {

								toRemove.add(element);

								// Do not break out of the loop.  We may have duplicate equal

								// elements in the cache.  Since the cache is additive, we want

								// to be sure we've gotten everything.

							}

						}

						checkState.removeAll(toRemove);

					}

				}

			});

			return v;

		}

		filterJob = super.doCreateRefreshJob();

		// See bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=229735

		// Ideally we would not have to copy the filtering job, but this

		// gives us the most precise control over how and when to preserve

		// the check mark state.  We have modified the superclass job so

		// that everything is expanded rather than recursively expanding

		// the tree and checking for the stop time.  This simplifies the

		// restoration of the correct checkmarks.

		filterJob = 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;

				}

				if (monitor.isCanceled())

					return Status.CANCEL_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);

					treeViewer.getTree().setCursor(display.getSystemCursor(SWT.CURSOR_WAIT));

					rememberLeafCheckState();

					treeViewer.refresh(true);

					// The superclass did a recursive expand so it could be more responsive to subsequent

					// typing.  We are expanding all so that we know everything is realized when we go to

					// restore the check state afterward.

					treeViewer.expandAll();

					if (text.length() > 0 && !initial) {

						// enabled toolbar - there is text to clear

						// and the list is currently being filtered

						updateToolbar(true);

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

					}

					restoreLeafCheckState();

					redrawFalseControl.setRedraw(true);

					treeViewer.getTree().setCursor(null);

				}

				return Status.OK_STATUS;

			}

		};

 * CheckboxTreeViewer with special behaviour of the checked / gray state on 

 * Copy of ContainerCheckedTreeViewer which is specialized for use

 * container (non-leaf) nodes:

 * with DeferredFetchFilteredTree.  Originally copied from

 * Copied from org.eclipse.ui.dialogs

 * org.eclipse.ui.dialogs and altered to achieve the following:

 * Altered to achieve the following:

 * 

 * (1)checking a parent will also expand it when we know it's a long

 * (1)checking a parent will expand it when we know it's a long

 * of the parents to influence the check state of the children.

 * to be rippled through the child and parent nodes.

 * When children appear due to relaxed filtering,

 * Since we know that preservingSelection(Runnable) isn't working

 * we never want to assume they should also be selected.  There are

 * properly, no need to do a bunch of work here.

 * cases where this is not necessarily the right thing to do, but

 * The added methods is preservingSelection(Runnable).

 * there are more cases where it is wrong.

 * Modified methods are updateChildrenItems(TreeItem parent) and

 * The added methods are preservingSelection(Runnable) and 

 * updateParentItems(TreeItem parent).

 * updateParentsUsingChildren(TreeItem).

 * Modified method is updateChildrenItems(TreeItem parent).

 * (3) API added to update parent selection according to children.

 * (3)we correct the problem with preservingSelection(Runnable) by

 * This is used after a filter refresh to ensure that parents are

 * remembering the check state and restoring it after a refresh.  We

 * up to date.  Added method is

 * fire a check state event so clients monitoring the selection will know

 * updateParentSelectionsUsingChildren()

 * what's going on.  Added methods are internalRefresh(Object, boolean), 

 * saveCheckedState(), restoreCheckedState(), and 

 * fireCheckStateChanged(Object, boolean).  That last method is public

 * so that DeferredFetchFilteredTree can do the same thing when it 

 * remembers selections.

 * 

 * This class does not correct the general problem reported in

 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=170521

 * That is handled by preserving selections additively in 

 * DeferredFetchFilteredTree.  This class simply provides the API

 * needed by that class and manages the parent state according to the

 * children.