/*******************************************************************************
* Copyright (c) 2005, 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 implementation
*******************************************************************************/
package org.eclipse.epf.authoring.ui.views;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.eclipse.core.runtime.ListenerList;
import org.eclipse.core.runtime.SafeRunner;
import org.eclipse.emf.common.notify.AdapterFactory;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider;
import org.eclipse.epf.authoring.ui.providers.ConfigPackageContentProvider;
import org.eclipse.epf.library.configuration.ConfigurationData;
import org.eclipse.epf.library.edit.navigator.ConfigContentPackageItemProvider.LeafElementsItemProvider;
import org.eclipse.epf.library.edit.util.TngUtil;
import org.eclipse.epf.uma.ContentPackage;
import org.eclipse.epf.uma.CustomCategory;
import org.eclipse.epf.uma.MethodElement;
import org.eclipse.epf.uma.MethodPackage;
import org.eclipse.epf.uma.MethodPlugin;
import org.eclipse.jface.util.SafeRunnable;
import org.eclipse.jface.viewers.CheckStateChangedEvent;
import org.eclipse.jface.viewers.CheckboxTreeViewer;
import org.eclipse.jface.viewers.ICheckStateListener;
import org.eclipse.jface.viewers.ITreeViewerListener;
import org.eclipse.jface.viewers.TreeExpansionEvent;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Item;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.swt.widgets.TreeItem;
import org.eclipse.swt.widgets.Widget;
import org.eclipse.ui.dialogs.ContainerCheckedTreeViewer;
/**
* ContainerCheckedTreeViewer class that supports MethodElements.
* Specifically, has changes to support FeatureValueWrapperItemProviders.
*
* Also, expands the tree for checked items when they are set via
* setCheckedElements(..) iff expandWhenChecking is true.
* @author Jeff Hardy
* @author Phong Nguyen Le
*/
public class MethodContainerCheckedTreeViewer extends
ContainerCheckedTreeViewer {
protected boolean expandWhenChecking = false;
protected boolean initializingTreeCheckState = false;
private ConfigurationData configData;
private boolean disableHandleLeafCrayChecks = false;
protected ListenerList childrenCheckStateListeners = new ListenerList();
/**
* Constructor for MethodContainerCheckedTreeViewer.
* @see CheckboxTreeViewer#CheckboxTreeViewer(Composite)
*/
public MethodContainerCheckedTreeViewer(Composite parent) {
super(parent);
initViewer();
}
/**
* Constructor for MethodContainerCheckedTreeViewer.
* @see CheckboxTreeViewer#CheckboxTreeViewer(Composite,int)
*/
public MethodContainerCheckedTreeViewer(Composite parent, int style) {
super(parent, style);
initViewer();
}
/**
* Constructor for MethodContainerCheckedTreeViewer.
* @see CheckboxTreeViewer#CheckboxTreeViewer(Tree)
*/
public MethodContainerCheckedTreeViewer(Tree tree) {
super(tree);
initViewer();
}
protected void initViewer() {
setUseHashlookup(true);
addCheckStateListener(new ICheckStateListener() {
public void checkStateChanged(CheckStateChangedEvent event) {
updateWrappers(event.getElement());
doCheckStateChanged(event.getElement());
// not ready to call the following line yet
// handleLeafCrayChecks(element);
}
});
addTreeListener(new ITreeViewerListener() {
public void treeCollapsed(TreeExpansionEvent event) {
}
public void treeExpanded(TreeExpansionEvent event) {
Widget item = findItem(event.getElement());
if (item instanceof TreeItem) {
initializeItem((TreeItem) item);
}
}
});
}
/**
* The item has expanded. Updates the checked state of its children.
*/
protected void initializeItem(TreeItem item) {
if (item.getChecked() && !item.getGrayed()) {
updateChildrenItems(item);
}
}
/**
* Updates the check state of all created children
*/
protected void updateChildrenItems(TreeItem parent) {
Item[] children = getChildren(parent);
boolean state = parent.getChecked();
for (int i = 0; i < children.length; i++) {
TreeItem curr = (TreeItem) children[i];
if (curr.getData() != null
&& ((curr.getChecked() != state) || curr.getGrayed())) {
curr.setChecked(state);
curr.setGrayed(false);
notifyChildrenCheckStateListeners(new CheckStateChangedEvent(this, curr.getData(),
state));
updateChildrenItems(curr);
}
}
}
@Override
protected void doCheckStateChanged(Object element) {
if (initializingTreeCheckState) {
// when initializing, don't update children:
// parent may have been gray-checked and we don't
// want to white-check all children
// children will be checked because setCheckedElements(..)
// typically receives list of all checked elements
Widget item = findItem(element);
if (item instanceof TreeItem) {
TreeItem treeItem = (TreeItem) item;
treeItem.setGrayed(false);
updateParentItems(treeItem.getParentItem());
}
} else {
super.doCheckStateChanged(element);
}
}
private void handleLeafCrayChecks(Object element) {
if (getConfigData() == null || disableHandleLeafCrayChecks) {
return;
}
Widget item = findItem(element);
TreeItem treeItem = item instanceof TreeItem ? (TreeItem) item : null;
if (treeItem == null) {
return;
}
Set<LeafElementsItemProvider> uncheckedLeafs = new HashSet<LeafElementsItemProvider>();
collectUncheckedLeafs(treeItem, uncheckedLeafs);
handleLeafCrayChecks(uncheckedLeafs);
}
private void collectUncheckedLeafs(TreeItem treeItem, Set<LeafElementsItemProvider> uncheckedLeafs) {
if (treeItem.getData() instanceof LeafElementsItemProvider) {
if (! treeItem.getChecked()) {
uncheckedLeafs.add((LeafElementsItemProvider) treeItem.getData());
}
return;
}
Item[] children = getChildren(treeItem);
for (int i = 0; i < children.length; i++) {
TreeItem curr = (TreeItem) children[i];
collectUncheckedLeafs(curr, uncheckedLeafs);
}
}
public void handleLeafCrayChecks(
Collection<LeafElementsItemProvider> uncheckedLeafs) {
if (uncheckedLeafs == null || uncheckedLeafs.isEmpty()) {
return;
}
Set<TreeItem> grayCheckedSet = new HashSet<TreeItem>();
for (LeafElementsItemProvider leaf : uncheckedLeafs) {
MethodPackage leafParent = leaf.getParentPackage();
if (!getConfigData().hasAddedElements(leafParent)) {
continue;
}
Widget item = findItem(leaf);
if (item instanceof TreeItem) {
TreeItem treeItem = (TreeItem) item;
while (treeItem != null) {
if (!grayCheckedSet.contains(treeItem)) {
treeItem.setChecked(true);
treeItem.setGrayed(true);
grayCheckedSet.add(treeItem);
}
treeItem = treeItem.getParentItem();
}
}
}
}
public void updateParents(Object element) {
Widget item = findItem(element);
if (item instanceof TreeItem) {
TreeItem treeItem = (TreeItem) item;
updateParentItems(treeItem.getParentItem());
}
}
/**
* Updates the check / gray state of all parent items
*/
protected void updateParentItems(TreeItem item) {
if (item != null) {
Item[] children = getChildren(item);
boolean containsChecked = false;
boolean containsUnchecked = false;
for (int i = 0; i < children.length; i++) {
TreeItem curr = (TreeItem) children[i];
containsChecked |= curr.getChecked();
containsUnchecked |= (!curr.getChecked() || curr.getGrayed());
}
item.setChecked(containsChecked);
item.setGrayed(containsChecked && containsUnchecked);
if (expandWhenChecking && item.getChecked()) {
item.setExpanded(true);
}
updateParentItems(item.getParentItem());
}
}
private void updateWrappers(Object object) {
boolean state = getChecked(object);
Object element = TngUtil.unwrap(object);
if(object != element) {
setChecked(element, state);
}
AdapterFactory adapterFactory = null;
if (getContentProvider() instanceof AdapterFactoryContentProvider) {
adapterFactory = ((AdapterFactoryContentProvider) getContentProvider())
.getAdapterFactory();
}
if (adapterFactory != null) {
Collection<?> wrappers = TngUtil.getWrappers(adapterFactory,
element);
if (!wrappers.isEmpty()) {
for (Object wrapper : wrappers) {
setChecked(wrapper, state);
}
}
}
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jface.viewers.CheckboxTreeViewer#setCheckedElements(java.lang.Object[])
*/
public void setCheckedElements(Object[] elements) {
// fix elements list to use EPF's wrappers
List<Object> treeElements = new ArrayList<Object>();
AdapterFactory adapterFactory = null;
if (getContentProvider() instanceof AdapterFactoryContentProvider) {
adapterFactory = ((AdapterFactoryContentProvider)getContentProvider()).getAdapterFactory();
}
for (int i = 0; i < elements.length; i++) {
Object element = elements[i];
if (adapterFactory != null) {
treeElements.addAll(TngUtil.getWrappers(adapterFactory, element));
}
if(!(element instanceof CustomCategory)) {
treeElements.add(element);
}
}
initializingTreeCheckState = true;
super.setCheckedElements(treeElements.toArray());
initializingTreeCheckState = false;
}
/**
* Returns a list of top-most checked elements in this viewer's tree,
* including currently hidden ones that are marked as
* checked but are under a collapsed ancestor.
*
* Only returns white-checked items, not grayed items
*
* @return the array of checked elements
*
* @see #setCheckedElements
*/
public Object[] getTopCheckedElements() {
ArrayList v = new ArrayList();
Control tree = getControl();
internalCollectTopChecked(v, tree);
return v.toArray();
}
/**
* Gathers the top-most checked states of the given widget and its
* descendents, following a pre-order traversal of the tree.
*
* @param result a writable list of elements (element type: <code>Object</code>)
* @param widget the widget
*/
private void internalCollectTopChecked(List result, Widget widget) {
Item[] items = getChildren(widget);
for (int i = 0; i < items.length; i++) {
Item item = items[i];
if (item instanceof TreeItem && ((TreeItem) item).getChecked() && !((TreeItem) item).getGrayed()) {
Object data = item.getData();
if (data != null) {
result.add(data);
}
}
if (item instanceof TreeItem && (!((TreeItem) item).getChecked() || ((TreeItem) item).getGrayed())) {
internalCollectTopChecked(result, item);
}
}
}
public boolean isExpandWhenChecking() {
return expandWhenChecking;
}
public void setExpandWhenChecking(boolean expandWhenChecking) {
this.expandWhenChecking = expandWhenChecking;
}
/**
* notified when children checkstate is changed (by checking a parent)
* @param listener
*/
public void addChildrenCheckStateListener(ICheckStateListener listener) {
childrenCheckStateListeners.add(listener);
}
public void removeChildrenCheckStateListener(ICheckStateListener listener) {
childrenCheckStateListeners.remove(listener);
}
protected void notifyChildrenCheckStateListeners(final CheckStateChangedEvent event) {
for (final Object listener : childrenCheckStateListeners.getListeners()) {
SafeRunner.run(new SafeRunnable() {
public void run() {
((ICheckStateListener)listener).checkStateChanged(event);
}
});
}
}
public Set<MethodPackage> getElementsUnslectedPkgs(Collection<MethodPackage> pkgsInConfig, ConfigPackageContentProvider provider) {
Set<MethodPackage> elementsUnslectedPkgs = new HashSet<MethodPackage>();
for (MethodPackage pkg : pkgsInConfig) {
if (pkg instanceof ContentPackage) {
Object leaf = provider.getLeafElementsNode(pkg);
Widget item = findItem(leaf);
if (item instanceof TreeItem) {
TreeItem treeItem = (TreeItem) item;
if (! treeItem.getChecked() || treeItem.getGrayed()) {
elementsUnslectedPkgs.add((ContentPackage) pkg);
}
}
}
}
return elementsUnslectedPkgs;
}
public void debugDump(Collection items, String msg) {
System.out.println("LD> msg : " + msg); //$NON-NLS-1$
for (Object item : items) {
System.out.println("LD> item : " + item); //$NON-NLS-1$
System.out.println("LD> found: " + findItem(item)); //$NON-NLS-1$
}
System.out.println(""); //$NON-NLS-1$
}
public ConfigurationData getConfigData() {
return configData;
}
public void setConfigData(ConfigurationData configData) {
this.configData = configData;
}
@Override
public boolean setChecked(Object element, boolean state) {
try {
disableHandleLeafCrayChecks = true;
return super.setChecked(element, state);
} finally {
disableHandleLeafCrayChecks = false;
}
}
public void debugTree() {
Object root = getRoot();
Tree tree = (Tree) this.findItem(root);
debugItem(tree.getItem(0), "LD>"); //$NON-NLS-1$
}
private void debugItem(Object objItem, String indent) {
if (objItem instanceof TreeItem) {
TreeItem item = (TreeItem) objItem;
System.out.println(indent + "item : " + item + ", hash: " //$NON-NLS-1$ //$NON-NLS-2$
+ item.hashCode());
System.out.println(indent + "data : " + item.getData()); //$NON-NLS-1$
System.out.println(""); //$NON-NLS-1$
for (TreeItem cItem : item.getItems()) {
debugItem(cItem, indent + " "); //$NON-NLS-1$
}
} else {
System.out.println(indent + "objItem : " + objItem); //$NON-NLS-1$
System.out.println(""); //$NON-NLS-1$
}
}
}