Attachment #81545 for bug #207064




 *******************************************************************************/
package org.eclipse.pde.internal.ui.launcher;

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

import org.eclipse.swt.widgets.Widget;

public class OSGiBundleBlock extends AbstractPluginBlock {

	private HashMap levelColumnCache = new HashMap();
	private HashMap autoColumnCache = new HashMap();
	private TreeEditor levelColumnEditor = null;
	private TreeEditor autoColumnEditor = null;

	class OSGiLabelProvider extends PDELabelProvider {
		public Image getColumnImage(Object obj, int index) {
			return index == 0 ? super.getColumnImage(obj, index) : null;
		}

		public String getColumnText(Object obj, int index) {
			switch (index) {
			case 0:
				return super.getColumnText(obj, index);
			case 1:
				if (levelColumnCache != null && levelColumnCache.containsKey(obj))
					return (String) levelColumnCache.get(obj);
				return ""; //$NON-NLS-1$
			case 2:
				if (autoColumnCache != null && autoColumnCache.containsKey(obj))
					return (String) autoColumnCache.get(obj);
				return ""; //$NON-NLS-1$
			default:

	public OSGiBundleBlock(BundlesTab tab) {
		super(tab);
	}

	protected void createPluginViewer(Composite composite, int span, int indent) {
		super.createPluginViewer(composite, span, indent);
		Tree tree = fPluginTreeViewer.getTree();

		TreeColumn column1 = new TreeColumn(tree, SWT.LEFT);
		column1.setText(fTab.getName());
		column1.setWidth(300);

		TreeColumn column2 = new TreeColumn(tree, SWT.CENTER);
		column2.setText(PDEUIMessages.EquinoxPluginBlock_levelColumn);
		column2.setWidth(80);

		TreeColumn column3 = new TreeColumn(tree, SWT.CENTER);
		column3.setText(PDEUIMessages.EquinoxPluginBlock_autoColumn);
		column3.setWidth(80);
		tree.setHeaderVisible(true);

		createEditors();
	}

	private void createEditors() {
		final Tree tree = fPluginTreeViewer.getTree();


				final Spinner spinner = new Spinner(tree, SWT.BORDER);
				spinner.setMinimum(0);
				String level = item.getText(1);
				int defaultLevel = level.length() == 0 || "default".equals(level) ? 0 : Integer.parseInt(level); //$NON-NLS-1$
				spinner.setSelection(defaultLevel);
				spinner.addModifyListener(new ModifyListener() {
					public void modifyText(ModifyEvent e) {
						if (item.getChecked()) {
							int selection = spinner.getSelection();
							item.setText(1, selection == 0 ? "default" //$NON-NLS-1$
									: Integer.toString(selection));
							levelColumnCache.put(item.getData(), item
									.getText(1));
							fTab.updateLaunchConfigurationDialog();
						}
					}

				levelColumnEditor.setEditor(spinner, item, 1);

				final CCombo combo = new CCombo(tree, SWT.BORDER | SWT.READ_ONLY);
				combo.setItems(new String[] {"default", Boolean.toString(true), Boolean.toString(false) }); //$NON-NLS-1$
				combo.setText(item.getText(2));
				combo.pack();
				combo.addSelectionListener(new SelectionAdapter() {

						if (item.getChecked()) {
							item.setText(2, combo.getText());
							fTab.updateLaunchConfigurationDialog();
							autoColumnCache.put(item.getData(), item.getText(2));
						}
					}
				});
				autoColumnEditor.setEditor(combo, item, 2);

			}
		});
	}

	private boolean isEditable(TreeItem item) {
		Object obj = item.getData();
		if (obj instanceof IPluginModelBase) {
			IPluginModelBase model = (IPluginModelBase) obj;
			if (!"org.eclipse.osgi".equals(model.getPluginBase().getId())) //$NON-NLS-1$
				return fPluginTreeViewer.getChecked(model);
		}
		return false;
	}

	protected ILabelProvider getLabelProvider() {
		return new OSGiLabelProvider();
	}

	protected void savePluginState(ILaunchConfigurationWorkingCopy config) {
		Object[] selected = fPluginTreeViewer.getCheckedElements();
		StringBuffer wBuffer = new StringBuffer();
		StringBuffer tBuffer = new StringBuffer();
		for (int i = 0; i < selected.length; i++) {
			if (selected[i] instanceof IPluginModelBase) {
				IPluginModelBase model = (IPluginModelBase) selected[i];
				String id = model.getPluginBase().getId();
				//TreeItem item = (TreeItem)fPluginTreeViewer.testFindItem(model);
				if (model.getUnderlyingResource() == null) {
					appendToBuffer(tBuffer, id, model);
				} else {
					appendToBuffer(wBuffer, id, model);
				}
			}
		}
		config.setAttribute(IPDELauncherConstants.WORKSPACE_BUNDLES, wBuffer
				.length() == 0 ? (String) null : wBuffer.toString());
		config.setAttribute(IPDELauncherConstants.TARGET_BUNDLES, tBuffer
				.length() == 0 ? (String) null : tBuffer.toString());

		StringBuffer buffer = new StringBuffer();
		if (fAddWorkspaceButton.getSelection()) {
			for (int i = 0; i < fWorkspaceModels.length; i++) {

					buffer.append(fWorkspaceModels[i].getPluginBase().getId());
				}
			}
		}
		config.setAttribute(IPDELauncherConstants.DESELECTED_WORKSPACE_PLUGINS,
				buffer.length() > 0 ? buffer.toString() : (String) null);
	}

	private void appendToBuffer(StringBuffer buffer, String id, Object element) {
		if (buffer.length() > 0)
			buffer.append(","); //$NON-NLS-1$
		buffer.append(id);
		buffer.append("@"); //$NON-NLS-1$
		buffer.append(levelColumnCache.get(element));
		// buffer.append(item.getText(1));
		buffer.append(":"); //$NON-NLS-1$
		// buffer.append(item.getText(2));
		buffer.append(autoColumnCache.get(element));
	}

	public void initializeFrom(ILaunchConfiguration configuration) throws CoreException {
		super.initializeFrom(configuration);
		initWorkspacePluginsState(configuration);

		fLaunchConfiguration = configuration;
		handleFilterButton(); // Once the page is initialized, apply any filtering.
	}

	private void initExternalPluginsState(ILaunchConfiguration configuration)
			throws CoreException {
		Map map = BundleLauncherHelper.getTargetBundleMap(configuration);
		Iterator iter = map.keySet().iterator();
		while (iter.hasNext()) {
			IPluginModelBase model = (IPluginModelBase) iter.next();
			if (fPluginTreeViewer.setChecked(model, true)) {
				setText(model, map.get(model).toString());
			}
		}
		fNumExternalChecked = map.size();
		resetGroup(fExternalPlugins);
		fPluginTreeViewer.setChecked(fExternalPlugins, fNumExternalChecked > 0);
		fPluginTreeViewer.setGrayed(fExternalPlugins, fNumExternalChecked > 0

	}

	private void resetGroup(NamedElement group) {
		Object[] children = group.getChildren();
		if ( children == null ) return;
		for (int i = 0; i < children.length; i++) {
			Object child = children[i];
			if (child instanceof IPluginModelBase) {
				if (fPluginTreeViewer.getChecked(child)) {
					resetText((IPluginModelBase) child);
				}
			} 
		}
	}


		Map map = BundleLauncherHelper.getWorkspaceBundleMap(configuration);
		Iterator iter = map.keySet().iterator();
		while (iter.hasNext()) {
			IPluginModelBase model = (IPluginModelBase) iter.next();
			if (fPluginTreeViewer.setChecked(model, true)) {
				setText(model, map.get(model).toString());
			}

		fNumWorkspaceChecked = map.size();
		resetGroup(fWorkspacePlugins);

		fPluginTreeViewer.setChecked(fWorkspacePlugins,
				fNumWorkspaceChecked > 0);
		fPluginTreeViewer.setGrayed(fWorkspacePlugins, fNumWorkspaceChecked > 0
				&& fNumWorkspaceChecked < fWorkspaceModels.length);
	}

	protected void handleGroupStateChanged(Object group, boolean checked) {
		super.handleGroupStateChanged(group, checked);
		if (group instanceof NamedElement) {
			NamedElement namedElement = (NamedElement) group;
			Object[] children = namedElement.getChildren();
			if ( children == null ) return;
			for (int i = 0; i < children.length; i++) {
				Object child = children[i];
				if (child instanceof IPluginModelBase) {
					if (fPluginTreeViewer.getChecked(child) == (((String)(levelColumnCache.get(child))).length() == 0 )) {
						resetText((IPluginModelBase) child);
					}
				}
			}
		}
	}

	protected void handleCheckStateChanged(CheckStateChangedEvent event) {
		super.handleCheckStateChanged(event);
		resetText((IPluginModelBase) event.getElement());
	}

	protected void setChecked(IPluginModelBase model, boolean checked) {
		super.setChecked(model, checked);
		resetText(model);
	}

	protected void setCheckedElements(Object[] checked) {
		super.setCheckedElements(checked);
		updateGroup(fWorkspacePlugins);
		updateGroup(fExternalPlugins);
	}

	private void updateGroup(Object group) {
		if (group instanceof NamedElement) {
			NamedElement namedElement = (NamedElement) group;
			Object[] children = namedElement.getChildren();
			if ( children == null ) return;
			for (int i = 0; i < children.length; i++) {
				Object child = children[i];
				if (child instanceof IPluginModelBase) {
					if (fPluginTreeViewer.getChecked(child) == (((String)(levelColumnCache.get(child))).length() == 0 )) {
						resetText((IPluginModelBase) child);
					}
				} 
			}
		}
	}

	private void setText(IPluginModelBase model, String value) {
		int index = value == null ? -1 : value.indexOf(':');
		String levelValue = index == -1 ? "" : value.substring(0, index); //$NON-NLS-1$
		String autoValue = index == -1 ? "" : value.substring(index + 1); //$NON-NLS-1$

		levelColumnCache.put(model, levelValue);
		autoColumnCache.put(model, autoValue);
		Widget widget = fPluginTreeViewer.testFindItem(model);
		if (widget instanceof TreeItem) {
			TreeItem item = (TreeItem) widget;
			item.setText(1, levelValue); //$NON-NLS-1$
			item.setText(2, autoValue); //$NON-NLS-1$
			item.setText(2, index == -1 ? "" : value.substring(index + 1)); //$NON-NLS-1$
		}
	}


	private void resetText(IPluginModelBase model) {
		String levelText = null;
		String autoText = null;
		Widget widget = fPluginTreeViewer.testFindItem(model);
		if (fPluginTreeViewer.getChecked(model)) {
			resetText((TreeItem)widget);
		}
	}
	
	private void resetText(TreeItem item) {
		if (item.getChecked()) {
			IPluginModelBase model = (IPluginModelBase)item.getData();
			boolean isSystemBundle = "org.eclipse.osgi".equals(model.getPluginBase().getId()); //$NON-NLS-1$
			if (!"default".equals(levelColumnCache.get(model))) //$NON-NLS-1$
				levelText = isSystemBundle ? "" : "default";
			if (!"default".equals(autoColumnCache.get(model))) //$NON-NLS-1$
				autoText = isSystemBundle ? "" : "default";
		}
		else {
			if ( ((String)levelColumnCache.get(model)).length() > 0 ) {
				levelText = "";
			}
			if ( ((String)autoColumnCache.get(model)).length() > 0 ) {
				autoText = "";
			}
		}
		if ( levelText != null ) {
			levelColumnCache.put(model, levelText);
			if ( widget instanceof TreeItem ) {
				((TreeItem)widget).setText(1, levelText); //$NON-NLS-1$
			}
		}
		if ( autoText != null ) {
			autoColumnCache.put(model, autoText);
			if ( widget instanceof TreeItem ) {
				((TreeItem)widget).setText(2, autoText); //$NON-NLS-1$
			}
		}
	}

	protected void handleRestoreDefaults() {
		Object[] selected = fPluginTreeViewer.getCheckedElements();
		for (int i = 0; i < selected.length; i++) {
			if (selected[i] instanceof IPluginModelBase) {
				resetText((IPluginModelBase) selected[i]);
			}
		}
	}

	protected int getTreeViewerStyle() {
		return super.getTreeViewerStyle() | SWT.FULL_SELECTION;
	}

	protected LaunchValidationOperation createValidationOperation() {
		return new OSGiValidationOperation(fLaunchConfiguration);
	}

	
	/**
	 * Refreshes the tree viewer. This caches the values of the level and auto
	 * column, and it clears any editors on the view. Finally, it sets the
	 * selection to the root node.
	 */
	protected void refreshTreeView(CheckboxTreeViewer treeView) {
		// Remove any selection
		if (treeView.getTree().getItemCount() > 0) {
			treeView.getTree().setSelection(treeView.getTree().getItem(0));
		} else {
			treeView.setSelection(new StructuredSelection(
					StructuredSelection.EMPTY));
		}

			treeView.setSelection(new StructuredSelection(StructuredSelection.EMPTY));
		}
		
		// Reset any editors on the tree viewer
		if (levelColumnEditor != null && levelColumnEditor.getEditor() != null
				&& !levelColumnEditor.getEditor().isDisposed()) {
			levelColumnEditor.getEditor().dispose();
		}
		

		if (autoColumnEditor != null && autoColumnEditor.getEditor() != null
				&& !autoColumnEditor.getEditor().isDisposed()) {
			autoColumnEditor.getEditor().dispose();
		}
		
		// Cache the current text
		levelColumnCache = new HashMap();
		autoColumnCache = new HashMap();
		ArrayList allTreeItems = getAllTreeItems(treeView.getTree().getItems());
		for (Iterator iterator = allTreeItems.iterator(); iterator.hasNext();) {
			TreeItem item = (TreeItem) iterator.next();
			levelColumnCache.put(item.getData(), item.getText(1));
			autoColumnCache.put(item.getData(), item.getText(2));
		}
	}

	/**
	 * This gets all the tree items from a tree.  
	 * 
	 * This method must exist in some SWT util library, so it can probably be 
	 * removed when I find it.
	 * 
	 * @param roots
	 * @return
	 */
	private ArrayList getAllTreeItems(TreeItem[] roots) {
		ArrayList list = new ArrayList();
		for (int i = 0; i < roots.length; i++) {
			TreeItem item = roots[i];
			list.add(item);
			list.addAll(getAllTreeItems(item.getItems()));
		}
		return list;
	}
	
	
}

Lines 48-53 Link Here

(-)src/org/eclipse/pde/internal/ui/launcher/AbstractPluginBlock.java (-3 / +20 lines)
48	import org.eclipse.pde.internal.ui.PDEUIMessages;	48	import org.eclipse.pde.internal.ui.PDEUIMessages;
49	import org.eclipse.pde.internal.ui.elements.DefaultContentProvider;	49	import org.eclipse.pde.internal.ui.elements.DefaultContentProvider;
50	import org.eclipse.pde.internal.ui.elements.NamedElement;	50	import org.eclipse.pde.internal.ui.elements.NamedElement;
		51	import org.eclipse.pde.internal.ui.launcher.FilteredCheckboxTree.FilterableCheckboxTreeViewer;
		52	import org.eclipse.pde.internal.ui.launcher.FilteredCheckboxTree.PreRefreshNotifier;
51	import org.eclipse.pde.internal.ui.util.PersistablePluginObject;	53	import org.eclipse.pde.internal.ui.util.PersistablePluginObject;
52	import org.eclipse.pde.internal.ui.util.SWTUtil;	54	import org.eclipse.pde.internal.ui.util.SWTUtil;
53	import org.eclipse.pde.internal.ui.wizards.ListUtil;	55	import org.eclipse.pde.internal.ui.wizards.ListUtil;
Lines 70-75 Link Here
70	import org.eclipse.ui.IWorkingSetManager;	72	import org.eclipse.ui.IWorkingSetManager;
71	import org.eclipse.ui.PlatformUI;	73	import org.eclipse.ui.PlatformUI;
72	import org.eclipse.ui.dialogs.IWorkingSetSelectionDialog;	74	import org.eclipse.ui.dialogs.IWorkingSetSelectionDialog;
		75	import org.eclipse.ui.dialogs.PatternFilter;
73		76
74	public abstract class AbstractPluginBlock {	77	public abstract class AbstractPluginBlock {
75		78
Lines 104-109 Link Here
104		107
105	private Button fValidateButton;	108	private Button fValidateButton;
106		109
		110	private FilteredCheckboxTree fPluginFilteredTree;
		111
107	class Listener extends SelectionAdapter {	112	class Listener extends SelectionAdapter {
108		113
109	private void filterAffectingControl(SelectionEvent e) {	114	private void filterAffectingControl(SelectionEvent e) {
Lines 272-278 Link Here
272	}	277	}
273		278
274	protected void createPluginViewer(Composite composite, int span, int indent) {	279	protected void createPluginViewer(Composite composite, int span, int indent) {
275	fPluginTreeViewer = new CheckboxTreeViewer(composite, getTreeViewerStyle()) ;	280	//fPluginTreeViewer = new CheckboxTreeViewer(composite, getTreeViewerStyle()) ;
		281	fPluginFilteredTree = new FilteredCheckboxTree(composite, getTreeViewerStyle(), new PatternFilter());
		282	fPluginTreeViewer = (CheckboxTreeViewer) fPluginFilteredTree.getViewer();
		283	((FilterableCheckboxTreeViewer)fPluginTreeViewer).addPerRefreshNotifier(new PreRefreshNotifier() {
		284
		285	public void preRefresh(FilterableCheckboxTreeViewer viewer) {
		286	refreshTreeView(fPluginTreeViewer);
		287
		288	}
		289
		290	});
276	fPluginTreeViewer.addCheckStateListener(new ICheckStateListener() {	291	fPluginTreeViewer.addCheckStateListener(new ICheckStateListener() {
277		292
278	public void checkStateChanged(CheckStateChangedEvent event) {	293	public void checkStateChanged(CheckStateChangedEvent event) {
Lines 321-327 Link Here
321	GridData gd = new GridData(GridData.FILL_BOTH);	336	GridData gd = new GridData(GridData.FILL_BOTH);
322	gd.horizontalSpan = span;	337	gd.horizontalSpan = span;
323	gd.horizontalIndent = indent;	338	gd.horizontalIndent = indent;
324	fPluginTreeViewer.getTree().setLayoutData(gd);	339	fPluginFilteredTree.setLayoutData(gd);
325		340
326	Image siteImage =	341	Image siteImage =
327	PDEPlugin.getDefault().getLabelProvider().get(	342	PDEPlugin.getDefault().getLabelProvider().get(
Lines 336-341 Link Here
336	PDEUIMessages.PluginsTab_target,	351	PDEUIMessages.PluginsTab_target,
337	siteImage);	352	siteImage);
338		353
		354	fWorkspacePlugins.setChildren(fWorkspaceModels);
		355	fExternalPlugins.setChildren(fExternalModels);
339	fPluginTreeViewer.addFilter(new Filter());	356	fPluginTreeViewer.addFilter(new Filter());
340	}	357	}
341		358
Lines 428-434 Link Here
428	}	445	}
429		446
430	protected void handleFilterButton() {	447	protected void handleFilterButton() {
431	refreshTreeView(fPluginTreeViewer);
432	fPluginTreeViewer.refresh();	448	fPluginTreeViewer.refresh();
433	fPluginTreeViewer.expandAll();	449	fPluginTreeViewer.expandAll();
434	}	450	}
Lines 585-590 Link Here
585		601
586	public void enableViewer(boolean enable) {	602	public void enableViewer(boolean enable) {
587	fPluginTreeViewer.getTree().setEnabled(enable);	603	fPluginTreeViewer.getTree().setEnabled(enable);
		604	fPluginFilteredTree.getFilterControl().setEnabled(enable);
588	fAddRequiredButton.setEnabled(enable);	605	fAddRequiredButton.setEnabled(enable);
589	fDefaultsButton.setEnabled(enable);	606	fDefaultsButton.setEnabled(enable);
590	fWorkingSetButton.setEnabled(enable);	607	fWorkingSetButton.setEnabled(enable);

Lines 18-23 Link Here

(-)src/org/eclipse/pde/internal/ui/elements/NamedElement.java (+17 lines)
18	private String name;	18	private String name;
19		19
20	private IPDEElement parent;	20	private IPDEElement parent;
		21
		22	private Object[] children;
21		23
22	public NamedElement(String name) {	24	public NamedElement(String name) {
23	this(name, null, null);	25	this(name, null, null);
Lines 33-38 Link Here
33	this.parent = parent;	35	this.parent = parent;
34	}	36	}
35		37
		38	/**
		39	* Sets the children of this element. The children are not copied
		40	* @param children
		41	*/
		42	public void setChildren(Object[] children) {
		43	this.children = children;
		44	}
		45
		46	/**
		47	* Gets the children of this element. The children are not copied
		48	*/
		49	public Object[] getChildren() {
		50	return children;
		51	}
		52
36	public Image getImage() {	53	public Image getImage() {
37	return image;	54	return image;
38	}	55	}




/*******************************************************************************
 * 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:
 *     Ian Bull - initial API and implementation (Bug #207064)
 *******************************************************************************/
package org.eclipse.pde.internal.ui.launcher;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.eclipse.jface.viewers.CheckStateChangedEvent;
import org.eclipse.jface.viewers.CheckboxTreeViewer;
import org.eclipse.jface.viewers.ICheckStateListener;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Item;
import org.eclipse.swt.widgets.TreeItem;
import org.eclipse.swt.widgets.Widget;
import org.eclipse.ui.dialogs.FilteredTree;
import org.eclipse.ui.dialogs.PatternFilter;

/**
 * A FilteredChecboxTree.  This tree stores all the tree elements internally, and keeps the
 * check state in sync.  This way, even if an element is filtered, the caller can get and set the
 * checked state.  
 * 
 * The internal representation is additive.  That is, elements are never removed from the internal
 * representation.  This is OK since the PDE launch Dialog never changes the elements once
 * the view is opened.  If any other tree is based on this code, they may want to address this issue. 
 * 
 * This is not public because it was customized for the Launch Dialog.
 * 
 * @author Ian Bull
 */
class FilteredCheckboxTree extends FilteredTree {

	/**
	 * The FilteredCheckboxTree Constructor.
	 * @param parent The parent composite where this Tree will be placed.
	 * @param treeStyle Tree styles
	 * @param filter The pattern filter that wil be used to filter elements
	 */
	public FilteredCheckboxTree(Composite parent, int treeStyle, PatternFilter filter) {
		super(parent, treeStyle, filter);
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.ui.dialogs.FilteredTree#doCreateTreeViewer(org.eclipse.swt.widgets.Composite, int)
	 */
	protected TreeViewer doCreateTreeViewer(Composite parent, int style) {
		return new FilterableCheckboxTreeViewer(parent, style);
	}

	/**
	 * Classes which implement this interface deal with notifications from the
	 * filtered checkbox tree viewer.  The notifications are fired before a refresh
	 * happens. 
	 */
	interface PreRefreshNotifier {
		public void preRefresh(FilterableCheckboxTreeViewer viewer);
	}

	/**
	 * A CheckboxTreeViewer that maintains an internal representation of all the nodes.
	 * 
	 */
	 class FilterableCheckboxTreeViewer extends CheckboxTreeViewer {
		static final String NONE = "none";
		static final String CHECKED = "checked";
		static final String GREYED = "greyed";
		static final String CHECKED_GREYED = "checked_greyed";

		/**
		 * The internal node for the FilterableCheckboxTreeViewer
		 */
		class FilteredCheckboxTreeItem {
			Object data;    // Data element
			String state;   // Checked State
			List children = new ArrayList();
			public FilteredCheckboxTreeItem(Object data, String state, Map itemCache, FilteredCheckboxTreeItem parent) {
				this.data = data;
				this.state = state;
				itemCache.put(data, this);
				if ( parent != null ) {
					parent.children.add(this);
				}
			}
		}

		/* A cache of all the nodes */
		Map itemCache = new HashMap();
		
		/* The preRefresh Listeners */
		List refreshingListeners = new ArrayList();

		/**
		 * FilterableCheckboxTreeViewer constructor. This creates the tree part of the filtered tree.
		 */
		public FilterableCheckboxTreeViewer(Composite parent, int style) {
			super(parent, style);
			addCheckStateListener(new ICheckStateListener() {

				public void checkStateChanged(CheckStateChangedEvent event) {
					FilteredCheckboxTreeItem item = (FilteredCheckboxTreeItem) itemCache.get(event.getElement());
					if ( item != null ) {
						item.state = event.getChecked() ? CHECKED : NONE;
					}
				}
			});
		}

	
		/**
		 * Allows clients to listen to the tree refresh.
		 */
		public void addPerRefreshNotifier(PreRefreshNotifier notifier) {
			if (refreshingListeners.contains(notifier))return;
			refreshingListeners.add(notifier);
		}
		
	
		/*
		 * (non-Javadoc)
		 * @see org.eclipse.jface.viewers.CheckboxTreeViewer#getChecked(java.lang.Object)
		 */
		public boolean getChecked(Object element) {
			Widget testFindItem = getViewer().testFindItem(element);
			testFindItem = null;
			if  ( testFindItem == null ) {
				if ( itemCache.containsKey(element)) {
					FilteredCheckboxTreeItem item = (FilteredCheckboxTreeItem) itemCache.get(element);
					if ( item.state.equals(CHECKED)) return true;
					if ( item.state.equals(CHECKED_GREYED )) return true;
					if ( item.state.equals(GREYED)) return true;
					else if ( item.state.equals(NONE)) return false;
				}
			}
			return super.getChecked(element);
		}
	
		/*
		 * (non-Javadoc)
		 * @see org.eclipse.jface.viewers.CheckboxTreeViewer#getCheckedElements()
		 */
		public Object[] getCheckedElements() {
			Iterator iterator = itemCache.values().iterator();
			List checkedElements = new LinkedList();
			while(iterator.hasNext()) {
				FilteredCheckboxTreeItem item = (FilteredCheckboxTreeItem) iterator.next();
				Widget testFindItem = getViewer().testFindItem(item.data);
				testFindItem = null;
				if ( testFindItem == null ) {
					if ( item.state.equals(CHECKED) || item.state.equals(CHECKED_GREYED) || item.state.equals(GREYED)) {
						checkedElements.add(item.data);
					}
				}
				else {
					if (((TreeItem)testFindItem).getChecked()) {
						checkedElements.add(testFindItem.getData());
					}
				}
			}
			return checkedElements.toArray();
		}
	
		/*
		 * (non-Javadoc)
		 * @see org.eclipse.jface.viewers.CheckboxTreeViewer#setChecked(java.lang.Object, boolean)
		 */
		public boolean setChecked(Object element, boolean state) {
			if ( itemCache.containsKey(element) ) {
				FilteredCheckboxTreeItem item = (FilteredCheckboxTreeItem) itemCache.get(element);
				item.state = state ? CHECKED : NONE;
			}
			return super.setChecked(element, state);
		}
		
		/*
		 * (non-Javadoc)
		 * @see org.eclipse.jface.viewers.CheckboxTreeViewer#setCheckedElements(java.lang.Object[])
		 */
		public void setCheckedElements(Object[] elements) {
			Set s = new HashSet(itemCache.keySet());
			s.removeAll(new HashSet(Arrays.asList(elements)));
			for (int i = 0; i < elements.length; i++) {
				FilteredCheckboxTreeItem item = (FilteredCheckboxTreeItem) itemCache.get(elements[i]);
				if ( item != null ) {
					item.state = CHECKED;
				}
			}
			for (Iterator iterator = s.iterator(); iterator.hasNext();) {
				Object object = iterator.next();
				FilteredCheckboxTreeItem item = (FilteredCheckboxTreeItem) itemCache.get(object);
				if ( item != null ) {
					item.state = NONE;
				}
			}
			super.setCheckedElements(elements);
		}
		
		/*
		 * (non-Javadoc)
		 * @see org.eclipse.jface.viewers.CheckboxTreeViewer#setSubtreeChecked(java.lang.Object, boolean)
		 */
		public boolean setSubtreeChecked(Object element, boolean state) {
			String newState = state ? CHECKED : NONE;
			FilteredCheckboxTreeItem filteredCheckboxTreeItem = (FilteredCheckboxTreeItem) itemCache.get(element);
			if ( filteredCheckboxTreeItem != null ) {
				filteredCheckboxTreeItem.state = newState;
				List children = filteredCheckboxTreeItem.children;
				for (Iterator iterator = children.iterator(); iterator.hasNext();) {
					FilteredCheckboxTreeItem child = (FilteredCheckboxTreeItem) iterator.next();
					child.state = newState;
				}
			}
			return super.setSubtreeChecked(element, state);
		}

		/*
		 * (non-Javadoc)
		 * @see org.eclipse.jface.viewers.CheckboxTreeViewer#preservingSelection(java.lang.Runnable)
		 */
		protected void preservingSelection(Runnable updateCode) {
			super.preservingSelection(updateCode);
			
			// Re-apply the checked state
			ArrayList allTreeItems = getAllTreeItems(treeViewer.getTree().getItems());
			for (Iterator iterator = allTreeItems.iterator(); iterator.hasNext();) {
				TreeItem item = (TreeItem) iterator.next();
				doApplyCheckedState(item, item.getData());
			}
		}
		

		/*
		 * (non-Javadoc)
		 * @see org.eclipse.jface.viewers.AbstractTreeViewer#internalRefresh(java.lang.Object, boolean)
		 */
		protected void internalRefresh(Object element, boolean updateLabels) {
			// Notify anybody who is listening for the refresh
			for (Iterator iterator = refreshingListeners.iterator(); iterator.hasNext();) {
				PreRefreshNotifier notifier = (PreRefreshNotifier) iterator.next();
				notifier.preRefresh(FilterableCheckboxTreeViewer.this);
			}
			saveCheckedState();
			super.internalRefresh(element, updateLabels);
			treeViewer.expandAll();
		}	

		
		/*
		 * Set the checked state 
		 */
		private void doApplyCheckedState(Item item, Object element) {
			// update the item first
			super.doUpdateItem(item, element);
			
			// Update the checked state
			TreeItem treeItem = (TreeItem) item;
			if (itemCache.containsKey(element)) {
				String state = ((FilteredCheckboxTreeItem)itemCache.get(element)).state;
				if (state.equals(CHECKED_GREYED)) {
					treeItem.setGrayed(true);
					treeItem.setChecked(true);
				} else if (state.equals(CHECKED)) {
					treeItem.setChecked(true);
					treeItem.setGrayed(false);
				} else if (state.equals(GREYED)) {
					treeItem.setGrayed(true);
					treeItem.setChecked(false);
				} else {
					treeItem.setGrayed(false);
					treeItem.setChecked(false);
				}
			}
		}
		
		/*
		 * A helper method to get all the items in the tree
		 */
		private ArrayList getAllTreeItems(TreeItem[] roots) {
			ArrayList list = new ArrayList();
			for (int i = 0; i < roots.length; i++) {
				TreeItem item = roots[i];
				list.add(item);
				list.addAll(getAllTreeItems(item.getItems()));
			}
			return list;
		}
		
		/**
		 * Saves the checked state of all the elements in the tree
		 */
		private void saveCheckedState() {
			TreeItem[] items = treeViewer.getTree().getItems();
			for (int i = 0; i < items.length; i++) {
				TreeItem item = items[i];
				if (!itemCache.containsKey(item.getData())) {
					new FilteredCheckboxTreeItem(item.getData(), getItemState(item), itemCache, null);
				}
				FilteredCheckboxTreeItem filteredCheckboxTreeItem = (FilteredCheckboxTreeItem) itemCache.get(item.getData());
				filteredCheckboxTreeItem.state = getItemState(item);
				saveCheckedState(filteredCheckboxTreeItem, item);
			}
		}
		
		/**
		 * Saves the checked state of an item and all its children
		 */
		private void saveCheckedState(FilteredCheckboxTreeItem parent, TreeItem parentItem) {
			TreeItem[] items = parentItem.getItems();
			for (int i = 0; i < items.length; i++) {
				TreeItem item = items[i];
				if (!itemCache.containsKey(item.getData())) {
					new FilteredCheckboxTreeItem(item.getData(), getItemState(item), itemCache, parent);
				}
				FilteredCheckboxTreeItem filteredCheckboxTreeItem = (FilteredCheckboxTreeItem) itemCache.get(item.getData());
				filteredCheckboxTreeItem.state = getItemState(item);
				saveCheckedState(filteredCheckboxTreeItem, item);
			}
		}
		
		/**
		 * Computes the checked state from a tree item 
		 */
		private String getItemState(TreeItem item) {
			if (item.getChecked() && item.getGrayed()) {
				return CHECKED_GREYED;
			} else if (item.getChecked()) {
				return CHECKED;
			} else if (item.getGrayed()) {
				return GREYED;
			} else {
				return NONE;
			}
		}

	} // end of FilterableCheckboxTreeViewer

}

Return to bug 207064

Added Link Here

(-)src/org/eclipse/pde/internal/ui/launcher/FilteredCheckboxTree.java (+352 lines)
1	/*******************************************************************************
2	* All rights reserved. This program and the accompanying materials
3	* are made available under the terms of the Eclipse Public License v1.0
4	* which accompanies this distribution, and is available at
5	* http://www.eclipse.org/legal/epl-v10.html
6	*
7	* Contributors:
8	* Ian Bull - initial API and implementation (Bug #207064)
9	*******************************************************************************/
10	package org.eclipse.pde.internal.ui.launcher;
11
12	import java.util.ArrayList;
13	import java.util.Arrays;
14	import java.util.HashMap;
15	import java.util.HashSet;
16	import java.util.Iterator;
17	import java.util.LinkedList;
18	import java.util.List;
19	import java.util.Map;
20	import java.util.Set;
21
22	import org.eclipse.jface.viewers.CheckStateChangedEvent;
23	import org.eclipse.jface.viewers.CheckboxTreeViewer;
24	import org.eclipse.jface.viewers.ICheckStateListener;
25	import org.eclipse.jface.viewers.TreeViewer;
26	import org.eclipse.swt.widgets.Composite;
27	import org.eclipse.swt.widgets.Item;
28	import org.eclipse.swt.widgets.TreeItem;
29	import org.eclipse.swt.widgets.Widget;
30	import org.eclipse.ui.dialogs.FilteredTree;
31	import org.eclipse.ui.dialogs.PatternFilter;
32
33	/**
34	* A FilteredChecboxTree. This tree stores all the tree elements internally, and keeps the
35	* check state in sync. This way, even if an element is filtered, the caller can get and set the
36	* checked state.
37	*
38	* The internal representation is additive. That is, elements are never removed from the internal
39	* representation. This is OK since the PDE launch Dialog never changes the elements once
40	* the view is opened. If any other tree is based on this code, they may want to address this issue.
41	*
42	* This is not public because it was customized for the Launch Dialog.
43	*
44	* @author Ian Bull
45	*/
46	class FilteredCheckboxTree extends FilteredTree {
47
48	/**
49	* The FilteredCheckboxTree Constructor.
50	* @param parent The parent composite where this Tree will be placed.
51	* @param treeStyle Tree styles
52	* @param filter The pattern filter that wil be used to filter elements
53	*/
54	public FilteredCheckboxTree(Composite parent, int treeStyle, PatternFilter filter) {
55	super(parent, treeStyle, filter);
56	}
57
58	/*
59	* (non-Javadoc)
60	* @see org.eclipse.ui.dialogs.FilteredTree#doCreateTreeViewer(org.eclipse.swt.widgets.Composite, int)
61	*/
62	protected TreeViewer doCreateTreeViewer(Composite parent, int style) {
63	return new FilterableCheckboxTreeViewer(parent, style);
64	}
65
66	/**
67	* Classes which implement this interface deal with notifications from the
68	* filtered checkbox tree viewer. The notifications are fired before a refresh
69	* happens.
70	*/
71	interface PreRefreshNotifier {
72	public void preRefresh(FilterableCheckboxTreeViewer viewer);
73	}
74
75	/**
76	* A CheckboxTreeViewer that maintains an internal representation of all the nodes.
77	*
78	*/
79	class FilterableCheckboxTreeViewer extends CheckboxTreeViewer {
80	static final String NONE = "none";
81	static final String CHECKED = "checked";
82	static final String GREYED = "greyed";
83	static final String CHECKED_GREYED = "checked_greyed";
84
85	/**
86	* The internal node for the FilterableCheckboxTreeViewer
87	*/
88	class FilteredCheckboxTreeItem {
89	Object data; // Data element
90	String state; // Checked State
91	List children = new ArrayList();
92	public FilteredCheckboxTreeItem(Object data, String state, Map itemCache, FilteredCheckboxTreeItem parent) {
93	this.data = data;
94	this.state = state;
95	itemCache.put(data, this);
96	if ( parent != null ) {
97	parent.children.add(this);
98	}
99	}
100	}
101
102	/* A cache of all the nodes */
103	Map itemCache = new HashMap();
104
105	/* The preRefresh Listeners */
106	List refreshingListeners = new ArrayList();
107
108	/**
109	* FilterableCheckboxTreeViewer constructor. This creates the tree part of the filtered tree.
110	*/
111	public FilterableCheckboxTreeViewer(Composite parent, int style) {
112	super(parent, style);
113	addCheckStateListener(new ICheckStateListener() {
114
115	public void checkStateChanged(CheckStateChangedEvent event) {
116	FilteredCheckboxTreeItem item = (FilteredCheckboxTreeItem) itemCache.get(event.getElement());
117	if ( item != null ) {
118	item.state = event.getChecked() ? CHECKED : NONE;
119	}
120	}
121	});
122	}
123
124
125	/**
126	* Allows clients to listen to the tree refresh.
127	*/
128	public void addPerRefreshNotifier(PreRefreshNotifier notifier) {
129	if (refreshingListeners.contains(notifier))return;
130	refreshingListeners.add(notifier);
131	}
132
133
134	/*
135	* (non-Javadoc)
136	* @see org.eclipse.jface.viewers.CheckboxTreeViewer#getChecked(java.lang.Object)
137	*/
138	public boolean getChecked(Object element) {
139	Widget testFindItem = getViewer().testFindItem(element);
140	testFindItem = null;
141	if ( testFindItem == null ) {
142	if ( itemCache.containsKey(element)) {
143	FilteredCheckboxTreeItem item = (FilteredCheckboxTreeItem) itemCache.get(element);
144	if ( item.state.equals(CHECKED)) return true;
145	if ( item.state.equals(CHECKED_GREYED )) return true;
146	if ( item.state.equals(GREYED)) return true;
147	else if ( item.state.equals(NONE)) return false;
148	}
149	}
150	return super.getChecked(element);
151	}
152
153	/*
154	* (non-Javadoc)
155	* @see org.eclipse.jface.viewers.CheckboxTreeViewer#getCheckedElements()
156	*/
157	public Object[] getCheckedElements() {
158	Iterator iterator = itemCache.values().iterator();
159	List checkedElements = new LinkedList();
160	while(iterator.hasNext()) {
161	FilteredCheckboxTreeItem item = (FilteredCheckboxTreeItem) iterator.next();
162	Widget testFindItem = getViewer().testFindItem(item.data);
163	testFindItem = null;
164	if ( testFindItem == null ) {
165	if ( item.state.equals(CHECKED) \|\| item.state.equals(CHECKED_GREYED) \|\| item.state.equals(GREYED)) {
166	checkedElements.add(item.data);
167	}
168	}
169	else {
170	if (((TreeItem)testFindItem).getChecked()) {
171	checkedElements.add(testFindItem.getData());
172	}
173	}
174	}
175	return checkedElements.toArray();
176	}
177
178	/*
179	* (non-Javadoc)
180	* @see org.eclipse.jface.viewers.CheckboxTreeViewer#setChecked(java.lang.Object, boolean)
181	*/
182	public boolean setChecked(Object element, boolean state) {
183	if ( itemCache.containsKey(element) ) {
184	FilteredCheckboxTreeItem item = (FilteredCheckboxTreeItem) itemCache.get(element);
185	item.state = state ? CHECKED : NONE;
186	}
187	return super.setChecked(element, state);
188	}
189
190	/*
191	* (non-Javadoc)
192	* @see org.eclipse.jface.viewers.CheckboxTreeViewer#setCheckedElements(java.lang.Object[])
193	*/
194	public void setCheckedElements(Object[] elements) {
195	Set s = new HashSet(itemCache.keySet());
196	s.removeAll(new HashSet(Arrays.asList(elements)));
197	for (int i = 0; i < elements.length; i++) {
198	FilteredCheckboxTreeItem item = (FilteredCheckboxTreeItem) itemCache.get(elements[i]);
199	if ( item != null ) {
200	item.state = CHECKED;
201	}
202	}
203	for (Iterator iterator = s.iterator(); iterator.hasNext();) {
204	Object object = iterator.next();
205	FilteredCheckboxTreeItem item = (FilteredCheckboxTreeItem) itemCache.get(object);
206	if ( item != null ) {
207	item.state = NONE;
208	}
209	}
210	super.setCheckedElements(elements);
211	}
212
213	/*
214	* (non-Javadoc)
215	* @see org.eclipse.jface.viewers.CheckboxTreeViewer#setSubtreeChecked(java.lang.Object, boolean)
216	*/
217	public boolean setSubtreeChecked(Object element, boolean state) {
218	String newState = state ? CHECKED : NONE;
219	FilteredCheckboxTreeItem filteredCheckboxTreeItem = (FilteredCheckboxTreeItem) itemCache.get(element);
220	if ( filteredCheckboxTreeItem != null ) {
221	filteredCheckboxTreeItem.state = newState;
222	List children = filteredCheckboxTreeItem.children;
223	for (Iterator iterator = children.iterator(); iterator.hasNext();) {
224	FilteredCheckboxTreeItem child = (FilteredCheckboxTreeItem) iterator.next();
225	child.state = newState;
226	}
227	}
228	return super.setSubtreeChecked(element, state);
229	}
230
231	/*
232	* (non-Javadoc)
233	* @see org.eclipse.jface.viewers.CheckboxTreeViewer#preservingSelection(java.lang.Runnable)
234	*/
235	protected void preservingSelection(Runnable updateCode) {
236	super.preservingSelection(updateCode);
237
238	// Re-apply the checked state
239	ArrayList allTreeItems = getAllTreeItems(treeViewer.getTree().getItems());
240	for (Iterator iterator = allTreeItems.iterator(); iterator.hasNext();) {
241	TreeItem item = (TreeItem) iterator.next();
242	doApplyCheckedState(item, item.getData());
243	}
244	}
245
246
247	/*
248	* (non-Javadoc)
249	* @see org.eclipse.jface.viewers.AbstractTreeViewer#internalRefresh(java.lang.Object, boolean)
250	*/
251	protected void internalRefresh(Object element, boolean updateLabels) {
252	// Notify anybody who is listening for the refresh
253	for (Iterator iterator = refreshingListeners.iterator(); iterator.hasNext();) {
254	PreRefreshNotifier notifier = (PreRefreshNotifier) iterator.next();
255	notifier.preRefresh(FilterableCheckboxTreeViewer.this);
256	}
257	saveCheckedState();
258	super.internalRefresh(element, updateLabels);
259	treeViewer.expandAll();
260	}
261
262
263	/*
264	* Set the checked state
265	*/
266	private void doApplyCheckedState(Item item, Object element) {
267	// update the item first
268	super.doUpdateItem(item, element);
269
270	// Update the checked state
271	TreeItem treeItem = (TreeItem) item;
272	if (itemCache.containsKey(element)) {
273	String state = ((FilteredCheckboxTreeItem)itemCache.get(element)).state;
274	if (state.equals(CHECKED_GREYED)) {
275	treeItem.setGrayed(true);
276	treeItem.setChecked(true);
277	} else if (state.equals(CHECKED)) {
278	treeItem.setChecked(true);
279	treeItem.setGrayed(false);
280	} else if (state.equals(GREYED)) {
281	treeItem.setGrayed(true);
282	treeItem.setChecked(false);
283	} else {
284	treeItem.setGrayed(false);
285	treeItem.setChecked(false);
286	}
287	}
288	}
289
290	/*
291	* A helper method to get all the items in the tree
292	*/
293	private ArrayList getAllTreeItems(TreeItem[] roots) {
294	ArrayList list = new ArrayList();
295	for (int i = 0; i < roots.length; i++) {
296	TreeItem item = roots[i];
297	list.add(item);
298	list.addAll(getAllTreeItems(item.getItems()));
299	}
300	return list;
301	}
302
303	/**
304	* Saves the checked state of all the elements in the tree
305	*/
306	private void saveCheckedState() {
307	TreeItem[] items = treeViewer.getTree().getItems();
308	for (int i = 0; i < items.length; i++) {
309	TreeItem item = items[i];
310	if (!itemCache.containsKey(item.getData())) {
311	new FilteredCheckboxTreeItem(item.getData(), getItemState(item), itemCache, null);
312	}
313	FilteredCheckboxTreeItem filteredCheckboxTreeItem = (FilteredCheckboxTreeItem) itemCache.get(item.getData());
314	filteredCheckboxTreeItem.state = getItemState(item);
315	saveCheckedState(filteredCheckboxTreeItem, item);
316	}
317	}
318
319	/**
320	* Saves the checked state of an item and all its children
321	*/
322	private void saveCheckedState(FilteredCheckboxTreeItem parent, TreeItem parentItem) {
323	TreeItem[] items = parentItem.getItems();
324	for (int i = 0; i < items.length; i++) {
325	TreeItem item = items[i];
326	if (!itemCache.containsKey(item.getData())) {
327	new FilteredCheckboxTreeItem(item.getData(), getItemState(item), itemCache, parent);
328	}
329	FilteredCheckboxTreeItem filteredCheckboxTreeItem = (FilteredCheckboxTreeItem) itemCache.get(item.getData());
330	filteredCheckboxTreeItem.state = getItemState(item);
331	saveCheckedState(filteredCheckboxTreeItem, item);
332	}
333	}
334
335	/**
336	* Computes the checked state from a tree item
337	*/
338	private String getItemState(TreeItem item) {
339	if (item.getChecked() && item.getGrayed()) {
340	return CHECKED_GREYED;
341	} else if (item.getChecked()) {
342	return CHECKED;
343	} else if (item.getGrayed()) {
344	return GREYED;
345	} else {
346	return NONE;
347	}
348	}
349
350	} // end of FilterableCheckboxTreeViewer
351
352	}