1.5/plugins/org.eclipse.epf.library/src/org/eclipse/epf/library/layout/elements/PracticeLayout.java - epf/org.eclipse.epf.composer - Git at Google

 //------------------------------------------------------------------------------
 // Copyright (c) 2005, 2006 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.library.layout.elements;

 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;

 import org.eclipse.emf.ecore.EReference;
 import org.eclipse.emf.ecore.EStructuralFeature;
 import org.eclipse.epf.library.configuration.ConfigurationHelper;
 import org.eclipse.epf.library.edit.PresentationContext;
 import org.eclipse.epf.library.edit.configuration.PracticeItemProvider;
 import org.eclipse.epf.library.edit.configuration.PracticeItemProvider.GroupingHelper;
 import org.eclipse.epf.library.edit.util.CategorySortHelper;
 import org.eclipse.epf.library.edit.util.PracticePropUtil;
 import org.eclipse.epf.library.layout.ElementLayoutManager;
 import org.eclipse.epf.library.layout.util.XmlElement;
 import org.eclipse.epf.uma.MethodElement;
 import org.eclipse.epf.uma.Practice;
 import org.eclipse.epf.uma.Task;
 import org.eclipse.epf.uma.UmaPackage;
 import org.eclipse.epf.uma.WorkProduct;
 import org.eclipse.epf.uma.ecore.util.OppositeFeature;
 import org.eclipse.epf.uma.util.UserDefinedTypeMeta;


 /**
  * The element layout for a Practice
  *
  * @author Weiping Lu
  * @since 1.5
  */
 public class PracticeLayout extends AbstractElementLayout {

 	public PracticeLayout() {
 		super();
 	}

 	public void init(ElementLayoutManager layoutManager, MethodElement element) {
 		super.__init(layoutManager, element);
 	}

 	@Override
 	protected XmlElement getXmlElement() {
 		XmlElement elementXml = super.getXmlElement();

 		Practice practice = (Practice) getElement();
 		PracticePropUtil propUtil = PracticePropUtil.getPracticePropUtil();
 		try {
 			UserDefinedTypeMeta meta = propUtil.getUtdData(practice);
 			if (meta != null) {
 				addReferences(udtFeauteObj, elementXml,
 					"User defined type", Collections.singletonList(meta)); //$NON-NLS-1$
 			}
 		} catch (Exception e) {
 		}
 		return elementXml;
 	}

 	private static Object udtFeauteObj = new Object();
 	@Override
 	protected void processChild(Object feature, XmlElement parent, List items,
 			boolean includeReferences) {
 		if (feature == udtFeauteObj) {
 			if (items == null || items.isEmpty()) {
 				return;
 			}

 			for (UserDefinedTypeMeta meta : (List<UserDefinedTypeMeta>) items) {
 				XmlElement childXmlElement = new XmlElement("Element");//$NON-NLS-1$
 				parent.addChild(childXmlElement);
 				for (String name : UserDefinedTypeMeta.rteNames) {
 					String value = meta.getRteNameMap().get(name);
 					if (value == null) {
 						value = name;
 					}
 					childXmlElement.setAttribute(name, value);//$NON-NLS-1$
 				}
 			}

 			return;
 		}
 		super.processChild(feature, parent, items, includeReferences);
 	}

 	/**
 	 * @see org.eclipse.epf.library.layout.IElementLayout#getXmlElement(boolean)
 	 */
 	public XmlElement getXmlElement(boolean includeReferences) {
 		XmlElement elementXml = super.getXmlElement(includeReferences);

 		if (includeReferences) {
 			EStructuralFeature feature = UmaPackage.Literals.PRACTICE__CONTENT_REFERENCES;
 			List<MethodElement> children = calc0nFeatureValue(element, null,
 					feature, layoutManager.getElementRealizer());

 			List<WorkProduct> wpSlotInputs = getInputWpSlots(children);

 			EStructuralFeature feature1 = UmaPackage.Literals.PRACTICE__ACTIVITY_REFERENCES;
 			List<MethodElement> children1 = calc0nFeatureValue(element, null,
 					feature1, layoutManager.getElementRealizer());

 //			EStructuralFeature feature2 = UmaPackage.Literals.PRACTICE__SUB_PRACTICES;
 //			List<MethodElement> children2 = calc0nFeatureValue(element, null,
 //					feature2, layoutManager.getElementRealizer());

 			children.addAll(children1);
 //			children.addAll(children2);

 			List ret = new ArrayList();

 			Practice practice = (Practice) getElement();
 			PracticePropUtil propUtil = PracticePropUtil.getPracticePropUtil();
 			boolean isUtdType = propUtil.isUdtType(practice);
 			if (isUtdType) {
 				Set<MethodElement> set = new HashSet<MethodElement>();
 				for (EReference ref : propUtil.getUdtMeta(practice).getQualifiedReferences()) {
 					List<MethodElement> qrList = ConfigurationHelper
 							.calc0nFeatureValue(element, ref, layoutManager
 									.getElementRealizer());
 					if (qrList != null && !qrList.isEmpty()) {
 						set.addAll(qrList);
 					}
 				}
 				if (! set.isEmpty()) {
 					children.removeAll(set);
 				}
 			}

 			GroupingHelper groupingHelper = new GroupingHelper(this, isUtdType) {
 				protected void grouping(Object parentObject, List ret,
 						Collection children, GroupingHelper groupingHelper) {
 					if (getGrouper() instanceof PracticeLayout) {
 						((PracticeLayout) getGrouper()).grouping(parentObject, ret,
 								children, groupingHelper);
 					}
 				}
 			};

 			grouping(this, ret, children, groupingHelper);

 			addReferences(feature,
 					elementXml, "Practice guidance tree", ret); //$NON-NLS-1$

 			if (wpSlotInputs != null) {
 				addReferences(feature,
 					elementXml, "Input work product slots", wpSlotInputs); //$NON-NLS-1$
 			}

 			if (isUtdType) {
 				List<MethodElement> list = propUtil.getUdtReferencingList(practice);
 				if (list != null && !list.isEmpty()) {
 					list = ConfigurationHelper.getCalculatedElements(list, layoutManager.getElementRealizer());
 				}
 				addReferences(feature,
 						elementXml, "Udt referencing list", list); //$NON-NLS-1$
 			}
 		}

 		return elementXml;
 	}

 	private List<WorkProduct> getInputWpSlots(List<MethodElement> elements) {
 		Set<WorkProduct> slots = new HashSet<WorkProduct>();
 		for (MethodElement elem: elements) {
 			if (elem instanceof Task) {
 				Task task = (Task) elem;
 				for (WorkProduct wp: task.getMandatoryInput()) {
 					if (wp.getIsAbstract()) {
 						slots.add(wp);
 					}
 				}
 				for (WorkProduct wp: task.getOptionalInput()) {
 					if (wp.getIsAbstract()) {
 						slots.add(wp);
 					}
 				}
 			}
 		}
 		if (slots.isEmpty()) {
 			return null;
 		}

 		List<WorkProduct> wpSlotInputs = new ArrayList<WorkProduct>();
 		wpSlotInputs.addAll(slots);

 		if (wpSlotInputs.size() > 1) {
 			Comparator comparator = PresentationContext.INSTANCE.getPresNameComparator();
 			Collections.<WorkProduct>sort(wpSlotInputs, comparator);
 		}

 		return wpSlotInputs;
 	}

 	protected boolean acceptFeatureValue(EStructuralFeature feature, Object value) {
 		if (feature.isMany()) {
 			//return false;
 		}
 		return super.acceptFeatureValue(feature, value);
 	}

 	private void grouping(Object parentObject, List ret, Collection children,
 			PracticeItemProvider.GroupingHelper groupingHelper) {
 		Map<String, List> map = PracticeItemProvider.getSubGroupMap(children, groupingHelper);

 		boolean toSort = true;
 		if (parentObject instanceof PracticeLayout) {
 			MethodElement elem = ((PracticeLayout) parentObject).element;
 			if (elem != null) {
 				toSort = ! CategorySortHelper.isManualCategorySort(elem);
 			}
 		}
 		String[] keys = groupingHelper.getKeysInOrder();
 		for (int i = 0; i < keys.length; i++) {
 			String key = keys[i];
 			List subgroupChildren = map.get(key);
 			if (subgroupChildren == null || subgroupChildren.isEmpty()) {
 				continue;
 			}
 			if (groupingHelper.toGroup(key, subgroupChildren)) {
 				subgroupChildren = groupingHelper.nestedGrouping(parentObject, key, subgroupChildren);
 				SubGroupValue subGroupValue = new SubGroupValue(key, subgroupChildren);
 				ret.add(subGroupValue);
 			} else {
 				if (toSort) {
 					PracticeItemProvider.sort(subgroupChildren);
 				}
 				ret.addAll(subgroupChildren);
 			}
 		}
 	}

 	protected void processNonMethodElementInProcessChild(
 			Object nonMethodElementChild, Object feature, XmlElement parent,
 			boolean includeReferences) {

 		if (nonMethodElementChild instanceof SubGroupValue) {
 			SubGroupValue subGroupValue = (SubGroupValue) nonMethodElementChild;
 			String key = subGroupValue.key;
 			List listValue = subGroupValue.listValue;
 			addReferences(feature,
 				parent, key, listValue);
 		}
 	}

 	protected boolean acceptFeatureValue(OppositeFeature feature, Object value) {
 /*		if ( feature == AssociationHelper.DescribableElement_CustomCategories) {
 			return true;
 		}*/
 		return super.acceptFeatureValue(feature, value);
 	}

 	static class SubGroupValue {
 		public String key;
 		public List listValue;

 		public SubGroupValue(String key, List listValue) {
 			this.key = key;
 			this.listValue = listValue;
 		}
 	}

 	protected void loadQrReferences(XmlElement elementXml) {
 		super.loadQrReferences(elementXml);

 		Practice practice = (Practice) getElement();
 		PracticePropUtil propUtil = PracticePropUtil.getPracticePropUtil();
 		UserDefinedTypeMeta meta = propUtil.getUdtMeta(practice);
 		if (meta == null || meta.getQualifiedReferences().isEmpty()) {
 			return;
 		}

 		XmlElement qrWrapper = elementXml.newChild(TAG_REFERENCELIST);
 		qrWrapper.setAttribute("name", "UDT reference qualifiers");  //$NON-NLS-1$//$NON-NLS-2$

 		//List<EReference> references = getSortedReferences(meta.getQualifiedReferences(), meta);
 		Set<EReference> references = meta.getQualifiedReferences();

 		for (EReference ref : references) {
 			List<MethodElement> qrList = ConfigurationHelper
 					.calc0nFeatureValue(element, ref, layoutManager
 							.getElementRealizer());
 			if (qrList != null && !qrList.isEmpty()) {
 				String name = meta.getReferenceQualifierName(ref.getName());
 				addReferences(ref, qrWrapper, name, qrList);
 			}
 		}
 	}

 	private List<EReference> getSortedReferences(Set<EReference> references, final UserDefinedTypeMeta meta) {
 		List<EReference> result = new ArrayList<EReference>();
 		for (EReference ref : references) {
 			result.add(ref);
 		}

 		Collections.sort(result, new Comparator<EReference>() {
 			public int compare(EReference object1, EReference object2) {
 				String name1 = meta.getReferenceQualifierName(object1.getName());
 				String name2 = meta.getReferenceQualifierName(object2.getName());
 				return name1.compareTo(name2);
 			}
 		});

 		return result;
 	}

 }
	//------------------------------------------------------------------------------
	// Copyright (c) 2005, 2006 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.library.layout.elements;

	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.Collections;
	import java.util.Comparator;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;

	import org.eclipse.emf.ecore.EReference;
	import org.eclipse.emf.ecore.EStructuralFeature;
	import org.eclipse.epf.library.configuration.ConfigurationHelper;
	import org.eclipse.epf.library.edit.PresentationContext;
	import org.eclipse.epf.library.edit.configuration.PracticeItemProvider;
	import org.eclipse.epf.library.edit.configuration.PracticeItemProvider.GroupingHelper;
	import org.eclipse.epf.library.edit.util.CategorySortHelper;
	import org.eclipse.epf.library.edit.util.PracticePropUtil;
	import org.eclipse.epf.library.layout.ElementLayoutManager;
	import org.eclipse.epf.library.layout.util.XmlElement;
	import org.eclipse.epf.uma.MethodElement;
	import org.eclipse.epf.uma.Practice;
	import org.eclipse.epf.uma.Task;
	import org.eclipse.epf.uma.UmaPackage;
	import org.eclipse.epf.uma.WorkProduct;
	import org.eclipse.epf.uma.ecore.util.OppositeFeature;
	import org.eclipse.epf.uma.util.UserDefinedTypeMeta;


	/**
	* The element layout for a Practice
	*
	* @author Weiping Lu
	* @since 1.5
	*/
	public class PracticeLayout extends AbstractElementLayout {

	public PracticeLayout() {
	super();
	}

	public void init(ElementLayoutManager layoutManager, MethodElement element) {
	super.__init(layoutManager, element);
	}

	@Override
	protected XmlElement getXmlElement() {
	XmlElement elementXml = super.getXmlElement();

	Practice practice = (Practice) getElement();
	PracticePropUtil propUtil = PracticePropUtil.getPracticePropUtil();
	try {
	UserDefinedTypeMeta meta = propUtil.getUtdData(practice);
	if (meta != null) {
	addReferences(udtFeauteObj, elementXml,
	"User defined type", Collections.singletonList(meta)); //$NON-NLS-1$
	}
	} catch (Exception e) {
	}
	return elementXml;
	}

	private static Object udtFeauteObj = new Object();
	@Override
	protected void processChild(Object feature, XmlElement parent, List items,
	boolean includeReferences) {
	if (feature == udtFeauteObj) {
	if (items == null \|\| items.isEmpty()) {
	return;
	}

	for (UserDefinedTypeMeta meta : (List<UserDefinedTypeMeta>) items) {
	XmlElement childXmlElement = new XmlElement("Element");//$NON-NLS-1$
	parent.addChild(childXmlElement);
	for (String name : UserDefinedTypeMeta.rteNames) {
	String value = meta.getRteNameMap().get(name);
	if (value == null) {
	value = name;
	}
	childXmlElement.setAttribute(name, value);//$NON-NLS-1$
	}
	}

	return;
	}
	super.processChild(feature, parent, items, includeReferences);
	}

	/**
	* @see org.eclipse.epf.library.layout.IElementLayout#getXmlElement(boolean)
	*/
	public XmlElement getXmlElement(boolean includeReferences) {
	XmlElement elementXml = super.getXmlElement(includeReferences);

	if (includeReferences) {
	EStructuralFeature feature = UmaPackage.Literals.PRACTICE__CONTENT_REFERENCES;
	List<MethodElement> children = calc0nFeatureValue(element, null,
	feature, layoutManager.getElementRealizer());

	List<WorkProduct> wpSlotInputs = getInputWpSlots(children);

	EStructuralFeature feature1 = UmaPackage.Literals.PRACTICE__ACTIVITY_REFERENCES;
	List<MethodElement> children1 = calc0nFeatureValue(element, null,
	feature1, layoutManager.getElementRealizer());

	// EStructuralFeature feature2 = UmaPackage.Literals.PRACTICE__SUB_PRACTICES;
	// List<MethodElement> children2 = calc0nFeatureValue(element, null,
	// feature2, layoutManager.getElementRealizer());

	children.addAll(children1);
	// children.addAll(children2);

	List ret = new ArrayList();

	Practice practice = (Practice) getElement();
	PracticePropUtil propUtil = PracticePropUtil.getPracticePropUtil();
	boolean isUtdType = propUtil.isUdtType(practice);
	if (isUtdType) {
	Set<MethodElement> set = new HashSet<MethodElement>();
	for (EReference ref : propUtil.getUdtMeta(practice).getQualifiedReferences()) {
	List<MethodElement> qrList = ConfigurationHelper
	.calc0nFeatureValue(element, ref, layoutManager
	.getElementRealizer());
	if (qrList != null && !qrList.isEmpty()) {
	set.addAll(qrList);
	}
	}
	if (! set.isEmpty()) {
	children.removeAll(set);
	}
	}

	GroupingHelper groupingHelper = new GroupingHelper(this, isUtdType) {
	protected void grouping(Object parentObject, List ret,
	Collection children, GroupingHelper groupingHelper) {
	if (getGrouper() instanceof PracticeLayout) {
	((PracticeLayout) getGrouper()).grouping(parentObject, ret,
	children, groupingHelper);
	}
	}
	};

	grouping(this, ret, children, groupingHelper);

	addReferences(feature,
	elementXml, "Practice guidance tree", ret); //$NON-NLS-1$

	if (wpSlotInputs != null) {
	addReferences(feature,
	elementXml, "Input work product slots", wpSlotInputs); //$NON-NLS-1$
	}

	if (isUtdType) {
	List<MethodElement> list = propUtil.getUdtReferencingList(practice);
	if (list != null && !list.isEmpty()) {
	list = ConfigurationHelper.getCalculatedElements(list, layoutManager.getElementRealizer());
	}
	addReferences(feature,
	elementXml, "Udt referencing list", list); //$NON-NLS-1$
	}
	}

	return elementXml;
	}

	private List<WorkProduct> getInputWpSlots(List<MethodElement> elements) {
	Set<WorkProduct> slots = new HashSet<WorkProduct>();
	for (MethodElement elem: elements) {
	if (elem instanceof Task) {
	Task task = (Task) elem;
	for (WorkProduct wp: task.getMandatoryInput()) {
	if (wp.getIsAbstract()) {
	slots.add(wp);
	}
	}
	for (WorkProduct wp: task.getOptionalInput()) {
	if (wp.getIsAbstract()) {
	slots.add(wp);
	}
	}
	}
	}
	if (slots.isEmpty()) {
	return null;
	}

	List<WorkProduct> wpSlotInputs = new ArrayList<WorkProduct>();
	wpSlotInputs.addAll(slots);

	if (wpSlotInputs.size() > 1) {
	Comparator comparator = PresentationContext.INSTANCE.getPresNameComparator();
	Collections.<WorkProduct>sort(wpSlotInputs, comparator);
	}

	return wpSlotInputs;
	}

	protected boolean acceptFeatureValue(EStructuralFeature feature, Object value) {
	if (feature.isMany()) {
	//return false;
	}
	return super.acceptFeatureValue(feature, value);
	}

	private void grouping(Object parentObject, List ret, Collection children,
	PracticeItemProvider.GroupingHelper groupingHelper) {
	Map<String, List> map = PracticeItemProvider.getSubGroupMap(children, groupingHelper);

	boolean toSort = true;
	if (parentObject instanceof PracticeLayout) {
	MethodElement elem = ((PracticeLayout) parentObject).element;
	if (elem != null) {
	toSort = ! CategorySortHelper.isManualCategorySort(elem);
	}
	}
	String[] keys = groupingHelper.getKeysInOrder();
	for (int i = 0; i < keys.length; i++) {
	String key = keys[i];
	List subgroupChildren = map.get(key);
	if (subgroupChildren == null \|\| subgroupChildren.isEmpty()) {
	continue;
	}
	if (groupingHelper.toGroup(key, subgroupChildren)) {
	subgroupChildren = groupingHelper.nestedGrouping(parentObject, key, subgroupChildren);
	SubGroupValue subGroupValue = new SubGroupValue(key, subgroupChildren);
	ret.add(subGroupValue);
	} else {
	if (toSort) {
	PracticeItemProvider.sort(subgroupChildren);
	}
	ret.addAll(subgroupChildren);
	}
	}
	}

	protected void processNonMethodElementInProcessChild(
	Object nonMethodElementChild, Object feature, XmlElement parent,
	boolean includeReferences) {

	if (nonMethodElementChild instanceof SubGroupValue) {
	SubGroupValue subGroupValue = (SubGroupValue) nonMethodElementChild;
	String key = subGroupValue.key;
	List listValue = subGroupValue.listValue;
	addReferences(feature,
	parent, key, listValue);
	}
	}

	protected boolean acceptFeatureValue(OppositeFeature feature, Object value) {
	/* if ( feature == AssociationHelper.DescribableElement_CustomCategories) {
	return true;
	}*/
	return super.acceptFeatureValue(feature, value);
	}

	static class SubGroupValue {
	public String key;
	public List listValue;

	public SubGroupValue(String key, List listValue) {
	this.key = key;
	this.listValue = listValue;
	}
	}

	protected void loadQrReferences(XmlElement elementXml) {
	super.loadQrReferences(elementXml);

	Practice practice = (Practice) getElement();
	PracticePropUtil propUtil = PracticePropUtil.getPracticePropUtil();
	UserDefinedTypeMeta meta = propUtil.getUdtMeta(practice);
	if (meta == null \|\| meta.getQualifiedReferences().isEmpty()) {
	return;
	}

	XmlElement qrWrapper = elementXml.newChild(TAG_REFERENCELIST);
	qrWrapper.setAttribute("name", "UDT reference qualifiers"); //$NON-NLS-1$//$NON-NLS-2$

	//List<EReference> references = getSortedReferences(meta.getQualifiedReferences(), meta);
	Set<EReference> references = meta.getQualifiedReferences();

	for (EReference ref : references) {
	List<MethodElement> qrList = ConfigurationHelper
	.calc0nFeatureValue(element, ref, layoutManager
	.getElementRealizer());
	if (qrList != null && !qrList.isEmpty()) {
	String name = meta.getReferenceQualifierName(ref.getName());
	addReferences(ref, qrWrapper, name, qrList);
	}
	}
	}

	private List<EReference> getSortedReferences(Set<EReference> references, final UserDefinedTypeMeta meta) {
	List<EReference> result = new ArrayList<EReference>();
	for (EReference ref : references) {
	result.add(ref);
	}

	Collections.sort(result, new Comparator<EReference>() {
	public int compare(EReference object1, EReference object2) {
	String name1 = meta.getReferenceQualifierName(object1.getName());
	String name2 = meta.getReferenceQualifierName(object2.getName());
	return name1.compareTo(name2);
	}
	});

	return result;
	}

	}