/*******************************************************************************
* Copyright (c) 2000, 2008 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package com.ebmwebsourcing.petals.common.internal.provisional.ui.jdt;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.eclipse.jface.viewers.CheckStateChangedEvent;
import org.eclipse.jface.viewers.CheckboxTableViewer;
import org.eclipse.jface.viewers.CheckboxTreeViewer;
import org.eclipse.jface.viewers.ICheckStateListener;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.ITreeViewerListener;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TreeExpansionEvent;
import org.eclipse.jface.viewers.ViewerComparator;
import org.eclipse.jface.viewers.ViewerFilter;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.BusyIndicator;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.Tree;
/**
* Combines a CheckboxTreeViewer and CheckboxListViewer.
* <p>
* All viewer selection-driven interactions are handled within this viewer.
* </p>
* <p>
* Comes from the plug-in "org.eclipse.jdt.ui".
* </p>
*
* @contributor Vincent Zurczak - EBM WebSourcing
* <ul>
* <li>Added the method "refresh" to refresh the viewers.</li>
* <li>Improved performances with the items map.</li>
* <li>Added a "dispose()" method.</li>
* </ul>
*
*/
@SuppressWarnings({ "unchecked", "rawtypes" })
public class CheckboxTreeAndListGroup implements ICheckStateListener, ISelectionChangedListener, ITreeViewerListener {
private Object fRoot;
private Object fCurrentTreeSelection;
private final List fExpandedTreeNodes= new ArrayList();
private final Map fCheckedStateStore= new HashMap(9);
private final List fWhiteCheckedTreeItems= new ArrayList();
private final List fListeners= new ArrayList();
private final ITreeContentProvider fTreeContentProvider;
private final IStructuredContentProvider fListContentProvider;
private final ILabelProvider fTreeLabelProvider;
private final ILabelProvider fListLabelProvider;
// widgets
private CheckboxTreeViewer fTreeViewer;
private CheckboxTableViewer fListViewer;
/**
* Creates an instance of this class. Use this constructor if you wish to specify
* the width and/or height of the combined widget (to only hardcode one of the
* sizing dimensions, specify the other dimension's value as -1)
* @param parent parent composite
* @param rootObject
* @param treeContentProvider
* @param treeLabelProvider
* @param listContentProvider
* @param listLabelProvider
* @param style
* @param width the width
* @param height the height
*/
public CheckboxTreeAndListGroup(
Composite parent,
Object rootObject,
ITreeContentProvider treeContentProvider,
ILabelProvider treeLabelProvider,
IStructuredContentProvider listContentProvider,
ILabelProvider listLabelProvider,
int style,
int width,
int height) {
this.fRoot= rootObject;
this.fTreeContentProvider= treeContentProvider;
this.fListContentProvider= listContentProvider;
this.fTreeLabelProvider= treeLabelProvider;
this.fListLabelProvider= listLabelProvider;
createContents(parent, width, height, style);
}
/**
* This method must be called just before this window becomes visible.
*/
public void aboutToOpen() {
determineWhiteCheckedDescendents(this.fRoot);
checkNewTreeElements(getTreeChildren(this.fRoot));
this.fCurrentTreeSelection= null;
//select the first element in the list
Object[] elements= getTreeChildren(this.fRoot);
Object primary= elements.length > 0 ? elements[0] : null;
if (primary != null) {
this.fTreeViewer.setSelection(new StructuredSelection(primary));
}
this.fTreeViewer.getControl().setFocus();
}
/**
* Adds the passed listener to self's collection of clients
* that listen for changes to element checked states
*
* @param listener ICheckStateListener
*/
public void addCheckStateListener(ICheckStateListener listener) {
this.fListeners.add(listener);
}
/**
* Adds the receiver and all of it's ancestors to the checkedStateStore if they
* are not already there.
* @param treeElement
*/
private void addToHierarchyToCheckedStore(Object treeElement) {
// if this tree element is already gray then its ancestors all are as well
if (!this.fCheckedStateStore.containsKey(treeElement))
this.fCheckedStateStore.put(treeElement, new ArrayList());
Object parent= this.fTreeContentProvider.getParent(treeElement);
if (parent != null)
addToHierarchyToCheckedStore(parent);
}
/**
* Returns a boolean indicating whether all children of the passed tree element
* are currently white-checked
*
* @return boolean
* @param treeElement java.lang.Object
*/
protected boolean areAllChildrenWhiteChecked(Object treeElement) {
Object[] children= getTreeChildren(treeElement);
for (int i= 0; i < children.length; ++i) {
if (!this.fWhiteCheckedTreeItems.contains(children[i]))
return false;
}
return true;
}
/**
* Returns a boolean indicating whether all list elements associated with
* the passed tree element are currently checked
*
* @return boolean
* @param treeElement java.lang.Object
*/
protected boolean areAllElementsChecked(Object treeElement) {
List checkedElements= (List)this.fCheckedStateStore.get(treeElement);
if (checkedElements == null) // ie.- tree item not even gray-checked
return false;
return getListItemsSize(treeElement) == checkedElements.size();
}
/**
* Iterates through the passed elements which are being realized for the first
* time and check each one in the tree viewer as appropriate
* @param elements
*/
protected void checkNewTreeElements(Object[] elements) {
for (int i= 0; i < elements.length; ++i) {
Object currentElement= elements[i];
boolean checked= this.fCheckedStateStore.containsKey(currentElement);
this.fTreeViewer.setChecked(currentElement, checked);
this.fTreeViewer.setGrayed(
currentElement,
checked && !this.fWhiteCheckedTreeItems.contains(currentElement));
}
}
/**
* An item was checked in one of self's two views. Determine which
* view this occurred in and delegate appropriately
*
* @param event CheckStateChangedEvent
*/
public void checkStateChanged(final CheckStateChangedEvent event) {
//Potentially long operation - show a busy cursor
BusyIndicator.showWhile(this.fTreeViewer.getControl().getDisplay(), new Runnable() {
public void run() {
if (event.getCheckable().equals(CheckboxTreeAndListGroup.this.fTreeViewer))
treeItemChecked(event.getElement(), event.getChecked());
else
listItemChecked(event.getElement(), event.getChecked(), true);
notifyCheckStateChangeListeners(event);
}
});
}
/**
* Lay out and initialize self's visual components.
*
* @param parent org.eclipse.swt.widgets.Composite
* @param width int
* @param height int
* @param style
*/
protected void createContents(
Composite parent,
int width,
int height,
int style) {
// group pane
Composite composite= new Composite(parent, style);
GridLayout layout= new GridLayout();
layout.numColumns= 2;
layout.makeColumnsEqualWidth= true;
layout.marginHeight= 0;
layout.marginWidth= 0;
composite.setLayout(layout);
composite.setLayoutData(new GridData(GridData.FILL_BOTH));
createTreeViewer(composite, width / 2, height);
createListViewer(composite, width / 2, height);
initialize();
}
/**
* Creates this group's list viewer.
* @param parent the parent composite
* @param width the width
* @param height the height
*/
protected void createListViewer(Composite parent, int width, int height) {
this.fListViewer= CheckboxTableViewer.newCheckList(parent, SWT.BORDER);
this.fListViewer.setUseHashlookup(true);
GridData data= new GridData(GridData.FILL_BOTH);
data.widthHint= width;
data.heightHint= height;
this.fListViewer.getTable().setLayoutData(data);
this.fListViewer.setContentProvider(this.fListContentProvider);
this.fListViewer.setLabelProvider(this.fListLabelProvider);
this.fListViewer.addCheckStateListener(this);
}
/**
* Creates this group's tree viewer.
* @param parent parent composite
* @param width the width
* @param height the height
*/
protected void createTreeViewer(Composite parent, int width, int height) {
Tree tree= new Tree(parent, SWT.CHECK | SWT.BORDER);
GridData data= new GridData(GridData.FILL_BOTH);
data.widthHint= width;
data.heightHint= height;
tree.setLayoutData(data);
this.fTreeViewer= new CheckboxTreeViewer(tree);
this.fTreeViewer.setUseHashlookup(true);
this.fTreeViewer.setContentProvider(this.fTreeContentProvider);
this.fTreeViewer.setLabelProvider(this.fTreeLabelProvider);
this.fTreeViewer.addTreeListener(this);
this.fTreeViewer.addCheckStateListener(this);
this.fTreeViewer.addSelectionChangedListener(this);
}
/**
* Returns a boolean indicating whether the passed tree element should be
* at LEAST gray-checked. Note that this method does not consider whether
* it should be white-checked, so a specified tree item which should be
* white-checked will result in a <code>true</code> answer from this method.
* To determine whether a tree item should be white-checked use method
* #determineShouldBeWhiteChecked(Object).
*
* @param treeElement java.lang.Object
* @return boolean
* @see #determineShouldBeWhiteChecked(java.lang.Object)
*/
protected boolean determineShouldBeAtLeastGrayChecked(Object treeElement) {
// if any list items associated with treeElement are checked then it
// retains its gray-checked status regardless of its children
List checked= (List) this.fCheckedStateStore.get(treeElement);
if (checked != null && !checked.isEmpty())
return true;
// if any children of treeElement are still gray-checked then treeElement
// must remain gray-checked as well
Object[] children= getTreeChildren(treeElement);
for (int i= 0; i < children.length; ++i) {
if (this.fCheckedStateStore.containsKey(children[i]))
return true;
}
return false;
}
/**
* Returns a boolean indicating whether the passed tree item should be
* white-checked.
*
* @return boolean
* @param treeElement java.lang.Object
*/
protected boolean determineShouldBeWhiteChecked(Object treeElement) {
return areAllChildrenWhiteChecked(treeElement)
&& areAllElementsChecked(treeElement);
}
/**
* Recursively adds appropriate tree elements to the collection of
* known white-checked tree elements.
*
* @param treeElement java.lang.Object
*/
protected void determineWhiteCheckedDescendents(Object treeElement) {
// always go through all children first since their white-checked
// statuses will be needed to determine the white-checked status for
// this tree element
Object[] children= getTreeChildren(treeElement);
for (int i= 0; i < children.length; ++i)
determineWhiteCheckedDescendents(children[i]);
// now determine the white-checked status for this tree element
if (determineShouldBeWhiteChecked(treeElement))
setWhiteChecked(treeElement, true);
}
/**
* Causes the tree viewer to expand all its items
*/
public void expandAll() {
this.fTreeViewer.expandAll();
}
/**
* Answers a flat collection of all of the checked elements in the
* list portion of self
*
* @return java.util.Vector
*/
public Iterator getAllCheckedListItems() {
Set result= new HashSet();
Iterator listCollectionsEnum= this.fCheckedStateStore.values().iterator();
while (listCollectionsEnum.hasNext())
result.addAll((List)listCollectionsEnum.next());
return result.iterator();
}
/**
* Answer a collection of all of the checked elements in the tree portion
* of self
*
* @return java.util.Vector
*/
public Set getAllCheckedTreeItems() {
return new HashSet(this.fCheckedStateStore.keySet());
}
/**
* Answers the number of elements that have been checked by the
* user.
*
* @return int
*/
public int getCheckedElementCount() {
return this.fCheckedStateStore.size();
}
/**
* Returns a count of the number of list items associated with a
* given tree item.
*
* @return int
* @param treeElement java.lang.Object
*/
protected int getListItemsSize(Object treeElement) {
Object[] elements= getListElements(treeElement);
return elements.length;
}
/**
* Gets the table that displays the folder content
*
* @return the table used to show the list
*/
public Table getTable() {
return this.fListViewer.getTable();
}
/**
* Gets the tree that displays the list for a folder
*
* @return the tree used to show the folders
*/
public Tree getTree() {
return this.fTreeViewer.getTree();
}
/**
* Adds the given filter to the tree viewer and
* triggers refiltering and resorting of the elements.
*
* @param filter a viewer filter
*/
public void addTreeFilter(ViewerFilter filter) {
this.fTreeViewer.addFilter(filter);
}
/**
* Adds the given filter to the list viewer and
* triggers refiltering and resorting of the elements.
*
* @param filter a viewer filter
*/
public void addListFilter(ViewerFilter filter) {
this.fListViewer.addFilter(filter);
}
/**
* Logically gray-check all ancestors of treeItem by ensuring that they
* appear in the checked table
* @param treeElement
*/
protected void grayCheckHierarchy(Object treeElement) {
// if this tree element is already gray then its ancestors all are as well
if (this.fCheckedStateStore.containsKey(treeElement))
return; // no need to proceed upwards from here
this.fCheckedStateStore.put(treeElement, new ArrayList());
if (determineShouldBeWhiteChecked(treeElement)) {
setWhiteChecked(treeElement, true);
}
Object parent= this.fTreeContentProvider.getParent(treeElement);
if (parent != null)
grayCheckHierarchy(parent);
}
/**
* Sets the initial checked state of the passed list element to true.
* @param element
*/
public void initialCheckListItem(Object element) {
Object parent= this.fTreeContentProvider.getParent(element);
this.fCurrentTreeSelection= parent;
//As this is not done from the UI then set the box for updating from the selection to false
listItemChecked(element, true, false);
updateHierarchy(parent);
}
/**
* Sets the initial checked state of the passed element to true,
* as well as to all of its children and associated list elements
* @param element
*/
public void initialCheckTreeItem(Object element) {
treeItemChecked(element, true);
}
/**
* Initializes this group's viewers after they have been laid out.
*/
protected void initialize() {
this.fTreeViewer.setInput(this.fRoot);
}
/**
* Callback that's invoked when the checked status of an item in the list
* is changed by the user. Do not try and update the hierarchy if we are building the
* initial list.
* @param listElement
* @param state
* @param updatingFromSelection
*/
protected void listItemChecked(
Object listElement,
boolean state,
boolean updatingFromSelection) {
List checkedListItems= (List) this.fCheckedStateStore.get(this.fCurrentTreeSelection);
if (state) {
if (checkedListItems == null) {
// since the associated tree item has gone from 0 -> 1 checked
// list items, tree checking may need to be updated
grayCheckHierarchy(this.fCurrentTreeSelection);
checkedListItems= (List) this.fCheckedStateStore.get(this.fCurrentTreeSelection);
}
checkedListItems.add(listElement);
} else {
checkedListItems.remove(listElement);
if (checkedListItems.isEmpty()) {
// since the associated tree item has gone from 1 -> 0 checked
// list items, tree checking may need to be updated
ungrayCheckHierarchy(this.fCurrentTreeSelection);
}
}
if (updatingFromSelection)
updateHierarchy(this.fCurrentTreeSelection);
}
/**
* Notifies all checked state listeners that the passed element has had
* its checked state changed to the passed state
* @param event
*/
protected void notifyCheckStateChangeListeners(CheckStateChangedEvent event) {
Iterator listenersEnum= this.fListeners.iterator();
while (listenersEnum.hasNext())
((ICheckStateListener) listenersEnum.next()).checkStateChanged(event);
}
/**
*Sets the contents of the list viewer based upon the specified selected
*tree element. This also includes checking the appropriate list items.
*
*@param treeElement java.lang.Object
*/
protected void populateListViewer(final Object treeElement) {
if (treeElement == this.fCurrentTreeSelection)
return;
this.fCurrentTreeSelection= treeElement;
this.fListViewer.setInput(treeElement);
List listItemsToCheck= (List) this.fCheckedStateStore.get(treeElement);
if (listItemsToCheck != null) {
Iterator listItemsEnum= listItemsToCheck.iterator();
while (listItemsEnum.hasNext())
this.fListViewer.setChecked(listItemsEnum.next(), true);
}
}
/**
* Removes the passed listener from self's collection of clients
* that listen for changes to element checked states
*
* @param listener ICheckStateListener
*/
public void removeCheckStateListener(ICheckStateListener listener) {
this.fListeners.remove(listener);
}
/**
* Handles the selection of an item in the tree viewer
*
* @param event ISelection
*/
public void selectionChanged(final SelectionChangedEvent event) {
BusyIndicator.showWhile(getTable().getShell().getDisplay(), new Runnable() {
public void run() {
IStructuredSelection selection= (IStructuredSelection) event.getSelection();
Object selectedElement= selection.getFirstElement();
if (selectedElement == null) {
CheckboxTreeAndListGroup.this.fCurrentTreeSelection= null;
CheckboxTreeAndListGroup.this.fListViewer.setInput(CheckboxTreeAndListGroup.this.fCurrentTreeSelection);
return;
}
populateListViewer(selectedElement);
}
});
}
/**
* Selects or deselect all of the elements in the tree depending on the value of the selection
* boolean. Be sure to update the displayed files as well.
* @param selection
*/
public void setAllSelections(final boolean selection) {
//Potentially long operation - show a busy cursor
BusyIndicator.showWhile(this.fTreeViewer.getControl().getDisplay(), new Runnable() {
public void run() {
setTreeChecked(CheckboxTreeAndListGroup.this.fRoot, selection);
CheckboxTreeAndListGroup.this.fListViewer.setAllChecked(selection);
}
});
}
/**
* Sets the list viewer's providers to those passed
*
* @param contentProvider ITreeContentProvider
* @param labelProvider ILabelProvider
*/
public void setListProviders(
IStructuredContentProvider contentProvider,
ILabelProvider labelProvider) {
this.fListViewer.setContentProvider(contentProvider);
this.fListViewer.setLabelProvider(labelProvider);
}
/**
* Sets the sorter that is to be applied to self's list viewer
* @param comparator
*/
public void setListComparator(ViewerComparator comparator) {
this.fListViewer.setComparator(comparator);
}
/**
* Sets the root of the widget to be new Root. Regenerate all of the tables and lists from this
* value.
*
* @param newRoot
*/
public void setRoot(Object newRoot) {
this.fRoot= newRoot;
initialize();
}
/**
* Sets the checked state of the passed tree element appropriately, and
* do so recursively to all of its child tree elements as well
* @param treeElement
* @param state
*/
protected void setTreeChecked(Object treeElement, boolean state) {
if (treeElement.equals(this.fCurrentTreeSelection)) {
this.fListViewer.setAllChecked(state);
}
if (state) {
Object[] listItems= getListElements(treeElement);
List listItemsChecked= new ArrayList();
for (int i= 0; i < listItems.length; ++i)
listItemsChecked.add(listItems[i]);
this.fCheckedStateStore.put(treeElement, listItemsChecked);
} else
this.fCheckedStateStore.remove(treeElement);
setWhiteChecked(treeElement, state);
this.fTreeViewer.setChecked(treeElement, state);
this.fTreeViewer.setGrayed(treeElement, false);
// now logically check/uncheck all children as well
Object[] children= getTreeChildren(treeElement);
for (int i= 0; i < children.length; ++i) {
setTreeChecked(children[i], state);
}
}
/**
* Sets the tree viewer's providers to those passed
*
* @param contentProvider ITreeContentProvider
* @param labelProvider ILabelProvider
*/
public void setTreeProviders(
ITreeContentProvider contentProvider,
ILabelProvider labelProvider) {
this.fTreeViewer.setContentProvider(contentProvider);
this.fTreeViewer.setLabelProvider(labelProvider);
}
/**
* Sets the sorter that is to be applied to self's tree viewer
* @param sorter
*/
public void setTreeComparator(ViewerComparator sorter) {
this.fTreeViewer.setComparator(sorter);
}
/**
* Adjusts the collection of references to white-checked tree elements appropriately.
*
* @param treeElement java.lang.Object
* @param isWhiteChecked boolean
*/
protected void setWhiteChecked(Object treeElement, boolean isWhiteChecked) {
if (isWhiteChecked) {
if (!this.fWhiteCheckedTreeItems.contains(treeElement))
this.fWhiteCheckedTreeItems.add(treeElement);
} else
this.fWhiteCheckedTreeItems.remove(treeElement);
}
/**
* Handle the collapsing of an element in a tree viewer
* @param event
*/
public void treeCollapsed(TreeExpansionEvent event) {
// We don't need to do anything with this
}
/**
* Handles the expansionsion of an element in a tree viewer
* @param event
*/
public void treeExpanded(TreeExpansionEvent event) {
Object item= event.getElement();
// First see if the children need to be given their checked state at all. If they've
// already been realized then this won't be necessary
if (!this.fExpandedTreeNodes.contains(item)) {
this.fExpandedTreeNodes.add(item);
checkNewTreeElements(getTreeChildren(item));
}
}
/**
* Callback that's invoked when the checked status of an item in the tree
* is changed by the user.
* @param treeElement
* @param state
*/
protected void treeItemChecked(Object treeElement, boolean state) {
// recursively adjust all child tree elements appropriately
setTreeChecked(treeElement, state);
Object parent= this.fTreeContentProvider.getParent(treeElement);
if (parent == null)
return;
// now update upwards in the tree hierarchy
if (state)
grayCheckHierarchy(parent);
else
ungrayCheckHierarchy(parent);
updateHierarchy(treeElement);
}
/**
* Logically un-gray-check all ancestors of treeItem iff appropriate.
* @param treeElement
*/
protected void ungrayCheckHierarchy(Object treeElement) {
if (!determineShouldBeAtLeastGrayChecked(treeElement))
this.fCheckedStateStore.remove(treeElement);
Object parent= this.fTreeContentProvider.getParent(treeElement);
if (parent != null)
ungrayCheckHierarchy(parent);
}
/**
* Sets the checked state of self and all ancestors appropriately
* @param treeElement
*/
protected void updateHierarchy(Object treeElement) {
boolean whiteChecked= determineShouldBeWhiteChecked(treeElement);
boolean shouldBeAtLeastGray= determineShouldBeAtLeastGrayChecked(treeElement);
this.fTreeViewer.setChecked(treeElement, whiteChecked || shouldBeAtLeastGray);
setWhiteChecked(treeElement, whiteChecked);
if (whiteChecked)
this.fTreeViewer.setGrayed(treeElement, false);
else
this.fTreeViewer.setGrayed(treeElement, shouldBeAtLeastGray);
// proceed up the tree element hierarchy
Object parent= this.fTreeContentProvider.getParent(treeElement);
if (parent != null) {
updateHierarchy(parent);
}
}
/**
* Update the selections of the tree elements in items to reflect the new
* selections provided.
*
* @param items with keys of Object (the tree element) and values of List (the selected
* list elements).
*/
public void updateSelections(final Map items) {
//Potentially long operation - show a busy cursor
BusyIndicator.showWhile(this.fTreeViewer.getControl().getDisplay(), new Runnable() {
public void run() {
handleUpdateSelection(items);
}
});
}
/**
* Returns the result of running the given elements through the filters.
* @param filters
*
* @param elements the elements to filter
* @return only the elements which all filters accept
*/
protected Object[] filter(ViewerFilter[] filters, Object[] elements) {
if (filters != null) {
ArrayList filtered = new ArrayList(elements.length);
for( Object element : elements ) {
boolean add = true;
for( ViewerFilter filter : filters ) {
add = filter.select(null, null, element);
if (!add)
break;
}
if (add)
filtered.add(element);
}
return filtered.toArray();
}
return elements;
}
private Object[] getTreeChildren(Object element) {
return filter(this.fTreeViewer.getFilters(), this.fTreeContentProvider.getChildren(element));
}
private Object[] getListElements(Object element) {
return filter(this.fListViewer.getFilters(), this.fListContentProvider.getElements(element));
}
public Set getWhiteCheckedTreeItems() {
return new HashSet(this.fWhiteCheckedTreeItems);
}
private void handleUpdateSelection(Map items) {
// VZ: use entry set instead of key / getKey
//Update the store before the hierarchy to prevent updating parents before all of the children are done
Set<Map.Entry> entrySet = items.entrySet();
for( Map.Entry entry : entrySet ) {
//Replace the items in the checked state store with those from the supplied items
List selections= (List) entry.getValue();
if (selections.size() == 0)
//If it is empty remove it from the list
this.fCheckedStateStore.remove( entry.getKey());
else {
this.fCheckedStateStore.put( entry.getKey(), selections);
// proceed up the tree element hierarchy
Object parent= this.fTreeContentProvider.getParent( entry.getKey());
if (parent != null) {
addToHierarchyToCheckedStore(parent);
}
}
}
// Now update hierarchies
for( Map.Entry entry : entrySet ) {
updateHierarchy( entry.getKey());
if (this.fCurrentTreeSelection != null && this.fCurrentTreeSelection.equals( entry.getKey())) {
this.fListViewer.setAllChecked( false );
this.fListViewer.setCheckedElements(((List) entry.getValue()).toArray());
}
}
// VZ
}
/**
* Checks if an element is grey checked.
* @param object
* @return if an element is grey checked.
*/
public boolean isTreeItemGreyChecked(Object object) {
return this.fTreeViewer.getGrayed(object);
}
/**
* For a given element, expand its chidren to a level.
* @param object
* @param level
*/
public void expandTreeToLevel(Object object, int level) {
this.fTreeViewer.expandToLevel(object, level);
}
/**
* @param selection
*/
public void setTreeSelection(ISelection selection) {
this.fTreeViewer.setSelection(selection);
}
/**
* Refresh the viewers.
*/
public void refresh() {
if( this.fTreeViewer != null )
this.fTreeViewer.refresh();
}
// VZ
/**
* Disposes the kept resources.
*/
public void dispose() {
if( this.fListLabelProvider != null )
this.fListLabelProvider.dispose();
if( this.fTreeLabelProvider != null )
this.fTreeLabelProvider.dispose();
}
// VZ
}