//------------------------------------------------------------------------------
// 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.edit.command;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import org.eclipse.emf.common.command.AbstractCommand;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.epf.library.edit.ui.UserInteractionHelper;
import org.eclipse.epf.library.edit.util.Misc;
import org.eclipse.epf.library.edit.util.TngUtil;
import org.eclipse.epf.uma.ContentCategory;
import org.eclipse.epf.uma.ContentPackage;
import org.eclipse.epf.uma.CustomCategory;
import org.eclipse.epf.uma.MethodElement;
import org.eclipse.epf.uma.MethodPlugin;
import org.eclipse.epf.uma.UmaFactory;
import org.eclipse.epf.uma.VariabilityType;
import org.eclipse.epf.uma.ecore.impl.MultiResourceEObject;
import org.eclipse.epf.uma.ecore.util.OppositeFeature;
import org.eclipse.epf.uma.util.UmaUtil;
/**
* This command is used to assign a method element to a category. If the category
* is in a base method plug-in of the element, this command will automatically
* create a contributor to the base category and assign the element to the
* contributing category. This is avoids modifying the base method plug-in.
*
* @author Phong Nguyen Le
* @since 1.0
*/
public class AddToCategoryCommand extends AbstractCommand implements
IResourceAwareCommand {
private ContentCategory category;
private EStructuralFeature feature;
private MethodElement element;
private String[] categoryPkgPath;
private boolean checkForExistingContributor;
private ContentCategory usedCategory = null;
private boolean createNewContributor = false;
private ContentPackage categoryPkg;
private Collection<Resource> modifiedResources;
private Object oldOppositeFeatureValue;
private List usedCategories;
public AddToCategoryCommand(ContentCategory category,
MethodElement element, EStructuralFeature feature,
String[] categoryPkgPath, boolean checkForExistingContributor,
List usedCategories) {
this.category = category;
this.feature = feature;
this.element = element;
this.categoryPkgPath = categoryPkgPath;
this.checkForExistingContributor = checkForExistingContributor;
this.usedCategories = usedCategories;
}
protected boolean prepare() {
// check if this operation will modify the element in opposite feature
// value
//
return UserInteractionHelper.checkModifyOpposite(category, feature,
element);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.emf.common.command.AbstractCommand#getLabel()
*/
public String getLabel() {
return "Add To Category"; //$NON-NLS-1$
}
private void prepareCategory() {
// create contributor for category if it is not in the same plugin with
// the element
//
MethodPlugin elementPlugin = UmaUtil.getMethodPlugin(element);
MethodPlugin categoryPlugin = UmaUtil.getMethodPlugin(category);
if (categoryPlugin != elementPlugin
&& Misc.isBaseOf(categoryPlugin, elementPlugin,
new HashMap<String, Boolean>())) {
if (category.getVariabilityBasedOnElement() != null) {
throw new IllegalArgumentException(
"Could not add element to an extended category that is in a different plug-in: " + category); //$NON-NLS-1$
}
if (!feature.isMany()) {
throw new UnsupportedOperationException();
}
categoryPkg = UmaUtil.findContentPackage(elementPlugin,
categoryPkgPath);
ContentCategory contrib = null;
if (checkForExistingContributor) {
// look for the existing contributor for the category
//
contrib = TngUtil.findContributor(categoryPkg, category);
}
if (contrib == null) {
createNewContributor = true;
} else {
usedCategory = contrib;
}
} else {
usedCategory = category;
}
}
public void execute() {
prepareCategory();
modifiedResources = new HashSet<Resource>();
redo();
}
public void redo() {
if (createNewContributor) {
ContentCategory contrib = (ContentCategory) UmaFactory.eINSTANCE
.create(category.eClass());
contrib.setVariabilityBasedOnElement(category);
contrib.setVariabilityType(VariabilityType.CONTRIBUTES);
categoryPkg.getContentElements().add(contrib);
usedCategory = contrib;
if (usedCategory instanceof CustomCategory) {
CustomCategory root = TngUtil.getRootCustomCategory(UmaUtil
.getMethodPlugin(usedCategory));
List list = root.getCategorizedElements();
list.add(usedCategory);
TngUtil.setDefaultName(root, (CustomCategory)usedCategory, category.getName());
} else {
usedCategory.setName(category.getName());
}
// set presentation name empty for new contributors
usedCategory.setPresentationName("");
}
OppositeFeature oppositeFeature = OppositeFeature
.getOppositeFeature(feature);
MultiResourceEObject mrEObj = (MultiResourceEObject) element;
oldOppositeFeatureValue = mrEObj.getOppositeFeatureMap().get(
oppositeFeature);
if (feature.isMany()) {
Collection collection = (Collection) usedCategory.eGet(feature);
if (oldOppositeFeatureValue != null && !oppositeFeature.isMany()) {
if (oldOppositeFeatureValue != usedCategory) {
EObject oldOppVal = (EObject) oldOppositeFeatureValue;
((Collection) oldOppVal.eGet(feature)).remove(element);
if (oldOppVal.eResource() != null) {
modifiedResources.add(oldOppVal.eResource());
}
collection.add(element);
}
}
if (!collection.contains(element)) {
collection.add(element);
}
} else {
if (oldOppositeFeatureValue != null && !oppositeFeature.isMany()) {
if (oldOppositeFeatureValue != usedCategory) {
EObject oldOppVal = (EObject) oldOppositeFeatureValue;
oldOppVal.eSet(feature, null);
if (oldOppVal.eResource() != null) {
modifiedResources.add(oldOppVal.eResource());
}
}
}
if (usedCategory != oldOppositeFeatureValue) {
usedCategory.eSet(feature, element);
}
}
if (usedCategory.eResource() != null) {
modifiedResources.add(usedCategory.eResource());
}
if (usedCategories.contains(category)) {
usedCategories.remove(category);
}
}
public void undo() {
OppositeFeature oppositeFeature = OppositeFeature
.getOppositeFeature(feature);
if (feature.isMany()) {
Collection collection = (Collection) usedCategory.eGet(feature);
collection.remove(element);
} else {
usedCategory.eSet(feature, null);
}
// restore old value of the single-value opposite feature
//
if (!oppositeFeature.isMany() && oldOppositeFeatureValue != null
&& oldOppositeFeatureValue != usedCategory) {
EObject oldOppVal = (EObject) oldOppositeFeatureValue;
if (feature.isMany()) {
((Collection) oldOppVal.eGet(feature)).add(element);
} else {
oldOppVal.eSet(feature, element);
}
}
if (createNewContributor) {
if (TngUtil.isEmpty(usedCategory)) {
MethodPlugin usedCategoryPlugin = UmaUtil.getMethodPlugin(usedCategory);
EcoreUtil.remove(usedCategory);
if (usedCategory instanceof CustomCategory) {
TngUtil.getRootCustomCategory(usedCategoryPlugin)
.getCategorizedElements().remove(usedCategory);
}
usedCategory = null;
}
}
if (!usedCategories.contains(category)) {
usedCategories.add(category);
}
}
public Collection<?> getAffectedObjects() {
return Collections.singletonList(usedCategory);
}
public Collection<Resource> getModifiedResources() {
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=146662
// Below adding category's resource to modifiedResources is needed,
// because before executing command, need to verify if resource is mutable or not
// getModifiedResources() called before executing actual execute() in few cases.
// Useful in special cases like if resource is in version control.
//
if(modifiedResources == null) {
modifiedResources = new HashSet<Resource>();
prepareCategory();
if(usedCategory != null && usedCategory.eResource() != null) {
modifiedResources.add(usedCategory.eResource());
}
if(createNewContributor && usedCategory == null && element != null) {
MethodPlugin plugin = UmaUtil.getMethodPlugin(element);
if(plugin != null && plugin.eResource() != null) {
modifiedResources.add(plugin.eResource());
}
}
}
if (modifiedResources == null) {
return Collections.emptyList();
}
return modifiedResources;
}
}