1.5/plugins/org.eclipse.epf.authoring.ui/src/org/eclipse/epf/authoring/ui/actions/IndentAction.java

//------------------------------------------------------------------------------
// Copyright (c) 2005, 2007 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.actions;

import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.eclipse.emf.common.command.AbstractCommand;
import org.eclipse.emf.common.command.Command;
import org.eclipse.emf.common.command.UnexecutableCommand;
import org.eclipse.emf.common.notify.AdapterFactory;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain;
import org.eclipse.emf.edit.domain.IEditingDomainProvider;
import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
import org.eclipse.emf.edit.ui.action.CommandActionHandler;
import org.eclipse.epf.authoring.ui.AuthoringUIResources;
import org.eclipse.epf.authoring.ui.editors.ProcessEditor;
import org.eclipse.epf.library.edit.command.IResourceAwareCommand;
import org.eclipse.epf.library.edit.util.TngUtil;
import org.eclipse.epf.library.edit.validation.DependencyChecker;
import org.eclipse.epf.richtext.RichTextImages;
import org.eclipse.epf.uma.Activity;
import org.eclipse.epf.uma.BreakdownElement;
import org.eclipse.epf.uma.MethodPackage;
import org.eclipse.epf.uma.Process;
import org.eclipse.epf.uma.ProcessPackage;
import org.eclipse.epf.uma.WorkBreakdownElement;
import org.eclipse.epf.uma.WorkOrder;
import org.eclipse.epf.uma.util.UmaUtil;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.swt.custom.BusyIndicator;
import org.eclipse.ui.IWorkbenchPart;

/**
 * Indents breakdown elements in a process tree.
 * 
 * @author Phong Nguyen Le
 * @since  1.2
 */
public class IndentAction extends
		CommandActionHandler implements IWorkbenchPartAction, IModifyingAction {

	public static class IndentCommand extends AbstractCommand implements IResourceAwareCommand {
		
		private Collection<BreakdownElement> elements;
		private AdapterFactory adapterFactory;
		private Set modifiedResources;
		private BreakdownElement element;
		private Activity oldParent;
		private Activity newParent;
		private int oldIndex;
		private Map<WorkBreakdownElement, WorkOrder> circularWorkOrders;

		public IndentCommand(Collection<BreakdownElement> collection, AdapterFactory adapterFactory) {
			this.elements = collection;
			this.adapterFactory = adapterFactory;
			setLabel(LABEL);
		}

		public Collection getModifiedResources() {
			if(modifiedResources == null) {
				Process proc = null;
				for (Iterator<BreakdownElement> iter = elements.iterator(); proc == null && iter.hasNext();) {
					BreakdownElement e = iter.next();
					proc = TngUtil.getOwningProcess(e);
				}
				if(proc != null) {
					Resource resource = proc.eResource();
					if(resource != null) {
						modifiedResources = Collections.singleton(proc.eResource());
					}
				}
				if(modifiedResources == null) {
					modifiedResources = Collections.EMPTY_SET;
				}
			}
			return modifiedResources;
		}
		
		@Override
		protected boolean prepare() {
			element = elements.iterator().next();
			oldParent = element.getSuperActivities();
			if(oldParent == null) {
				return false;
			}
			oldIndex = oldParent.getBreakdownElements().indexOf(element);
			ITreeItemContentProvider ip = (ITreeItemContentProvider) adapterFactory.adapt(oldParent, 
					ITreeItemContentProvider.class);
			List<Object> children = new LinkedList<Object>(ip.getChildren(oldParent));
			int index = children.indexOf(element);
			if(index > 0) {
				Object prev = children.get(index - 1);
				if(prev instanceof Activity) {
					newParent = (Activity) prev;
					return DependencyChecker.checkCircularForMovingVariabilityElement(newParent, Collections.singleton(element), true);
				}
			}
			return false;
		}

		public void execute() {
			newParent.getBreakdownElements().add(element);
			
			// remove circular work orders
			//
			if(element instanceof WorkBreakdownElement) {
				if(circularWorkOrders == null) {
					circularWorkOrders = new HashMap<WorkBreakdownElement, WorkOrder>();
				}
				else {
					circularWorkOrders.clear();
				}
				WorkOrder wo = UmaUtil.findWorkOrder(newParent, element);
				if(wo != null) {	
					newParent.getLinkToPredecessor().remove(wo);
					circularWorkOrders.put(newParent, wo);
				}
				WorkBreakdownElement wbe = (WorkBreakdownElement) element;
				wo = UmaUtil.findWorkOrder(wbe, newParent);
				if(wo != null) {
					wbe.getLinkToPredecessor().remove(wo);
					circularWorkOrders.put(wbe, wo);
				}
			}			
			
			// move the process pacakge of the activity to new parent package
			//
			if(element instanceof Activity) {
				ProcessPackage parentPkg = (ProcessPackage) newParent.eContainer();
				parentPkg.getChildPackages().add((MethodPackage) element.eContainer());
			}
		}

		public void redo() {
			execute();
		}
		
		@Override
		public void undo() {
			if(circularWorkOrders != null && !circularWorkOrders.isEmpty()) {
				for (Map.Entry<WorkBreakdownElement, WorkOrder> entry : circularWorkOrders.entrySet()) {
					entry.getKey().getLinkToPredecessor().add(entry.getValue());
				}
				circularWorkOrders.clear();
			}
			oldParent.getBreakdownElements().add(oldIndex, element);			
			if(element instanceof Activity) {
				ProcessPackage parentPkg = (ProcessPackage) oldParent.eContainer();
				parentPkg.getChildPackages().add((MethodPackage) element.eContainer());
			}
		}
		
		@Override
		public Collection getAffectedObjects() {
			return elements;
		}
	}

	private static final String LABEL = AuthoringUIResources.ProcessEditor_Action_Indent;

	private ProcessEditor editor;

	/**
	 * Creates an instance
	 * @param text
	 */
	public IndentAction(String text) {
		super(null, text);
	}
	
	/**
	 * Creates an instance
	 *
	 */
	public IndentAction() {
		this(LABEL);
		setImageDescriptor(RichTextImages.IMG_DESC_INDENT);
		setDisabledImageDescriptor(RichTextImages.DISABLED_IMG_DESC_INDENT);
		setToolTipText(LABEL);
	}
	
	/**
	 * @see org.eclipse.emf.edit.ui.action.CommandActionHandler#updateSelection(org.eclipse.jface.viewers.IStructuredSelection)
	 */
	public boolean updateSelection(IStructuredSelection selection) {
		// support indent only one activity for now
		//
		boolean ret = false;
		if(selection.size() == 1) {
			Object e = selection.getFirstElement();
			if(e instanceof Activity) {
				ret = super.updateSelection(selection);				
			}
		}
		setEnabled(ret);
		return ret;
		
		//TODO: support indent multiple activities in selection
//		ArrayList<Activity> list = new ArrayList<Activity>();
//		for (Iterator iter = selection.iterator(); iter.hasNext();) {
//			Object element = iter.next();
//			if(element instanceof Activity) {
//				list.add((Activity) element);
//			}
//		}
//		if(list.isEmpty()) {
//			return false;
//		}
//		return super.updateSelection(new StructuredSelection(list));
	}
	
	/**
	 * @see org.eclipse.emf.edit.ui.action.CommandActionHandler#createCommand(java.util.Collection)
	 */
	public Command createCommand(Collection selection) {
		if(domain instanceof AdapterFactoryEditingDomain) {
			return new IndentCommand(selection, ((AdapterFactoryEditingDomain)domain).getAdapterFactory());
		}
		return UnexecutableCommand.INSTANCE;
	}	

	/**
	 * @see org.eclipse.epf.authoring.ui.actions.IWorkbenchPartAction#setActiveWorkbenchPart(org.eclipse.ui.IWorkbenchPart)
	 */
	public void setActiveWorkbenchPart(IWorkbenchPart workbenchPart) {
		if(workbenchPart instanceof IEditingDomainProvider) {
			domain = ((IEditingDomainProvider)workbenchPart).getEditingDomain();
		}
		if(workbenchPart instanceof ProcessEditor) {
			editor = (ProcessEditor) workbenchPart;
		}		
		else if(workbenchPart == null) {
			editor = null;
		}
	}	
	
	private void superRun() {
		super.run();
	}
	
	/**
	 * @see org.eclipse.emf.edit.ui.action.CommandActionHandler#run()
	 */
	public void run() {
		BusyIndicator.showWhile(editor.getEditorSite()
				.getShell().getDisplay(), new Runnable() {

					public void run() {
						superRun();
					}
			
		});
	}
	
}