//------------------------------------------------------------------------------
// 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.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.eclipse.emf.ecore.EObject;
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.util.LibraryEditUtil;
import org.eclipse.epf.library.edit.util.ProcessUtil;
import org.eclipse.epf.library.edit.util.Suppression;
import org.eclipse.epf.library.layout.ElementLayoutManager;
import org.eclipse.epf.library.layout.IElementLayout;
import org.eclipse.epf.library.layout.util.XmlElement;
import org.eclipse.epf.uma.Descriptor;
import org.eclipse.epf.uma.DescriptorDescription;
import org.eclipse.epf.uma.MethodElement;
import org.eclipse.epf.uma.RoleDescriptor;
import org.eclipse.epf.uma.TaskDescriptor;
import org.eclipse.epf.uma.UmaPackage;
import org.eclipse.epf.uma.WorkProductDescriptor;
import org.eclipse.epf.uma.ecore.util.OppositeFeature;
import org.eclipse.epf.uma.util.AssociationHelper;
/**
* base layout class for descriptors
*
* @author Jinhua Xi
* @author Phong Nguyen Le
* @since 1.0
*/
public abstract class DescriptorLayout extends AbstractProcessElementLayout {
public static final Collection<EStructuralFeature> extraFeaturesFromContentElement = Arrays.asList(new EStructuralFeature[] {
UmaPackage.eINSTANCE.getContentElement_Assets(),
UmaPackage.eINSTANCE.getContentElement_Checklists(),
UmaPackage.eINSTANCE.getContentElement_ConceptsAndPapers(),
UmaPackage.eINSTANCE.getContentElement_Examples(),
UmaPackage.eINSTANCE.getContentElement_Guidelines(),
UmaPackage.eINSTANCE.getContentElement_SupportingMaterials()
});
MethodElement linkedElement = null;
public MethodElement getLinkedElement() {
return linkedElement;
}
AbstractElementLayout elementLayout = null;
protected void __init(ElementLayoutManager layoutManager,
MethodElement element) {
super.__init(layoutManager, element);
// 196094 - Task descriptor page should show the realized content of the linked element
if (element instanceof TaskDescriptor) {
linkedElement = ((TaskDescriptor) element).getTask();
linkedElement = ConfigurationHelper.getCalculatedElement(linkedElement, layoutManager.getElementRealizer());
if (linkedElement != null) {
elementLayout = new TaskLayout();
}
} else if (element instanceof RoleDescriptor) {
linkedElement = ((RoleDescriptor) element).getRole();
linkedElement = ConfigurationHelper.getCalculatedElement(linkedElement, layoutManager.getElementRealizer());
if (linkedElement != null) {
elementLayout = new RoleLayout();
}
} else if (element instanceof WorkProductDescriptor) {
linkedElement = ((WorkProductDescriptor) element).getWorkProduct();
linkedElement = ConfigurationHelper.getCalculatedElement(linkedElement, layoutManager.getElementRealizer());
if (linkedElement != null) {
elementLayout = new WorkProductLayout();
}
}
if (elementLayout != null) {
elementLayout.init(layoutManager, linkedElement);
elementLayout.setContentTarget(element);
}
// make sure the linked element is loaded
if ( linkedElement != null ) {
for (Iterator<EObject> iter = linkedElement.eAllContents(); iter.hasNext();) {
iter.next();
}
}
}
/**
* for descriptors, if the attribute is not defined, get from the libed
* element
*
* @param feature EStructuralFeature
* @return Object
*/
public Object getAttributeFeatureValue(EStructuralFeature feature) {
Object value = super.getAttributeFeatureValue(feature);
if ((elementLayout == null) || (value != null)
&& (value.toString().length() > 0)) {
return value;
}
// if the attribute is not defined, grab the attribute value from the
// linked element
// specified attributes only. Add more feature here if needed
if (feature == UmaPackage.eINSTANCE.getMethodElement_BriefDescription()) {
return elementLayout.getAttributeFeatureValue(feature);
}
return value;
}
/**
* get the layout for a child element of this element
* ActivityElementLayout should override this method to create layout with node path
* @param child
* @return IElementLayout
*/
protected IElementLayout getChildLayout(MethodElement child)
{
if ( layoutManager.getValidator().showExtraInfoForDescriptors()
&& (child instanceof DescriptorDescription) ) {
DescriptorDescriptionLayout l = new DescriptorDescriptionLayout(this.element);
l.init(layoutManager, child);
return l;
} else {
return layoutManager.getLayout(child, true);
}
}
protected Collection<EStructuralFeature> getExtraFeaturesFromContentElement() {
return extraFeaturesFromContentElement;
}
protected boolean acceptFeatureValue(EStructuralFeature feature,
Object value) {
Suppression sup = super.getSuppression(super.owningProcess);
if ( sup != null ) {
// check suppression
if ( value instanceof List ) {
List items = (List)value;
int i = 0;
while ( i < items.size() ) {
Object v = items.get(i);
if ( isSuppressed(sup, feature, v) ) {
items.remove(i);
} else {
i++;
}
}
if ( items.size() == 0 ) {
return false;
}
} else {
if ( isSuppressed(sup, feature, value) ) {
return false;
}
}
}
return super.acceptFeatureValue(feature, value);
}
protected boolean isSuppressed(Suppression sup, EStructuralFeature feature, Object element) {
if ( element instanceof Descriptor ) {
return sup.isSuppressed(element);
}
return false;
}
protected boolean isTaskOppositeFeature(OppositeFeature feature) {
return (feature == AssociationHelper.RoleDescriptor_PrimaryTaskDescriptors)
|| ( feature == AssociationHelper.RoleDescriptor_AdditionalTaskDescriptors)
|| ( feature == AssociationHelper.RoleDescriptor_AssistsIn_TaskDescriptors)
|| ( feature == AssociationHelper.WorkProductDescriptor_ExternalInputTo_TaskDescriptors)
|| ( feature == AssociationHelper.WorkProductDescriptor_MandatoryInputTo_TaskDescriptors)
|| ( feature == AssociationHelper.WorkProductDescriptor_OptionalInputTo_TaskDescriptors)
|| ( feature == AssociationHelper.WorkProductDescriptor_OutputFrom_TaskDescriptors);
}
public XmlElement getXmlElement(boolean includeReferences) {
XmlElement elementXml = super.getXmlElement(includeReferences);
if (linkedElement != null) {
String cType = linkedElement.getType().getName();
elementXml.setAttribute(
"ConcreteType", cType); //$NON-NLS-1$
}
return elementXml;
}
@Override
protected MethodElement getElementForElementPath() {
// This method gets called before "linkedElement" is assigned a value
if (layoutManager.getValidator().showLinkedPageForDescriptor()
&& element instanceof Descriptor) {
MethodElement linkedContentElement = ProcessUtil
.getAssociatedElement((Descriptor) element);
if (linkedContentElement != null) {
linkedContentElement = ConfigurationHelper.getCalculatedElement(linkedContentElement, layoutManager.getElementRealizer());
}
if (linkedContentElement != null) {
return linkedContentElement;
}
}
return super.getElementForElementPath();
}
@Override
protected boolean isExcludeFeature(EStructuralFeature feature) {
UmaPackage up = UmaPackage.eINSTANCE;
boolean b = feature == up
.getTaskDescriptor_PerformedPrimarilyByExcluded()
|| feature == up
.getTaskDescriptor_AdditionallyPerformedByExclude()
|| feature == up.getTaskDescriptor_MandatoryInputExclude()
|| feature == up.getTaskDescriptor_OptionalInputExclude()
|| feature == up.getTaskDescriptor_OutputExclude()
|| feature == up.getRoleDescriptor_ResponsibleForExclude()
|| feature == up.getDescriptor_GuidanceAdditional()
|| feature == up.getDescriptor_GuidanceExclude();
return b;
}
protected boolean isSynReferece(EStructuralFeature feature) {
if (! ProcessUtil.isSynFree() || linkedElement == null) {
return false;
}
Map<EReference, EReference> guidanceRefMap = LibraryEditUtil.getInstance().getGuidanceRefMap(linkedElement.eClass());
return guidanceRefMap == null ? false : guidanceRefMap.containsKey(feature);
}
}