//------------------------------------------------------------------------------
// 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;
}
}