1.5/plugins/org.eclipse.epf.authoring.ui/src/org/eclipse/epf/authoring/ui/dnd/EditingDomainTableTreeViewerDropAdapter.java

//------------------------------------------------------------------------------
// 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.authoring.ui.dnd;

import java.util.ArrayList;
import java.util.List;

import org.eclipse.emf.edit.command.DragAndDropCommand;
import org.eclipse.emf.edit.command.DragAndDropFeedback;
import org.eclipse.emf.edit.domain.EditingDomain;
import org.eclipse.emf.edit.ui.dnd.EditingDomainViewerDropAdapter;
import org.eclipse.epf.library.edit.util.ProcessScopeUtil;
import org.eclipse.epf.library.edit.util.ProcessUtil;
import org.eclipse.epf.uma.Activity;
import org.eclipse.epf.uma.Process;
import org.eclipse.epf.uma.ProcessComponent;
import org.eclipse.jface.viewers.TableTreeViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.swt.dnd.DND;
import org.eclipse.swt.dnd.DropTargetEvent;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableItem;
import org.eclipse.swt.widgets.Widget;

/**
 * Drop adapter for drag and drop
 * 
 * @author Phong Nguyen Le
 * @since 1.0
 */
public class EditingDomainTableTreeViewerDropAdapter extends
		EditingDomainViewerDropAdapter {

	public EditingDomainTableTreeViewerDropAdapter(EditingDomain domain,
			Viewer viewer) {
		super(domain, viewer);
	}


	/**
	 * @see org.eclipse.emf.edit.ui.dnd.EditingDomainViewerDropAdapter#dragEnter(org.eclipse.swt.dnd.DropTargetEvent)
	 */
	public void dragEnter(DropTargetEvent event) {
		if (event.detail == DND.DROP_NONE) {
			event.detail = DND.DROP_COPY;
		}
		super.dragEnter(event);
	}

	/**
	 * @see org.eclipse.emf.edit.ui.dnd.EditingDomainViewerDropAdapter#dragOver(org.eclipse.swt.dnd.DropTargetEvent)
	 */
	public void dragOver(DropTargetEvent event) {
		if (event.detail == DND.DROP_NONE) {
			event.detail = DND.DROP_COPY;
		}

		super.dragOver(event);
	}

	/**
	 * @see org.eclipse.emf.edit.ui.dnd.EditingDomainViewerDropAdapter#dropAccept(org.eclipse.swt.dnd.DropTargetEvent)
	 */
	public void dropAccept(DropTargetEvent event) {
		if (event.detail == DND.DROP_NONE) {
			event.detail = DND.DROP_COPY;
		}

		super.dropAccept(event);
	}

	/**
	 * @see org.eclipse.emf.edit.ui.dnd.EditingDomainViewerDropAdapter#helper(org.eclipse.swt.dnd.DropTargetEvent)
	 */
	protected void helper(DropTargetEvent event) {
		Table table = null;
		TableItem item = null;
		if (viewer instanceof TableTreeViewer) {
			table = ((TableTreeViewer) viewer).getTableTree().getTable();
			item = table.getItem(table.toControl(event.x, event.y));
			event.item = item;
		}

		superHelper(event);

		if (item != null && (event.feedback & DND.FEEDBACK_SELECT) != 0) {
			table.setSelection(new TableItem[] { item });
		}
	}

	/**
	 * Get drop target
	 * 
	 * @param item
	 * @return drop target object
	 */
	protected Object getDropTarget(Widget item) {
		return extractDropTarget(item);
	}

	/**
	 * This is called to indicate that the drop action should be invoked.
	 * @see org.eclipse.emf.edit.ui.dnd.EditingDomainViewerDropAdapter#drop(org.eclipse.swt.dnd.DropTargetEvent)
	 */
	public void drop(DropTargetEvent event) {
		// A command was created if the source was available early, and the
		// information used to create it was cached...
		if (dragAndDropCommandInformation != null) {
			// Recreate the command.
			command = dragAndDropCommandInformation.createCommand();
		} else {
			// Otherwise, the source should be available now as event.data, and
			// we can create the command.
			source = extractDragSource(event.data);
			Object target = getDropTarget(event.item);
			command = DragAndDropCommand.create(domain, target,
					getLocation(event), event.operations, originalOperation,
					source);
		}

		// If the command can execute...
		if (command.canExecute()) {
			// Execute it.
			domain.getCommandStack().execute(command);
		} else {
			// Otherwise, let's call the whole thing off.
			event.detail = DND.DROP_NONE;
			command.dispose();
		}

		// Clean up the state.
		command = null;
		commandTarget = null;
		source = null;
	}

	/**
	 * This method is called the same way for each of the
	 * {@link org.eclipse.swt.dnd.DropTargetListener} methods, except for leave
	 * and drop. If the source is available early, it creates or revalidates the
	 * {@link DragAndDropCommand}, and updates the event's detail (operation)
	 * and feedback (drag under effect), appropriately.
	 */
	protected void superHelper(DropTargetEvent event) {
		// If we can't do anything else, we'll provide the default select
		// feedback and enable auto-scroll and auto-expand effects.
		event.feedback = DND.FEEDBACK_SELECT | getAutoFeedback();

		// If we don't already have it, try to get the source early. We can't
		// give feedback if it's not available yet (this is platform-dependent).
		if (source == null) {
			source = getDragSource(event);
			if (source == null)
				return;
		}

		// Get the target object from the item widget and the mouse location in
		// it.
		Object target = getDropTarget(event.item);
		float location = getLocation(event);

		// Determine if we can create a valid command at the current location.
		boolean valid = false;
		modifiySource(target);
		
		// If we don't have a previous cached command...
		if (command == null) {
			// We'll need to keep track of the information we use to create the
			// command, so that we can recreate it in drop.
			dragAndDropCommandInformation = new DragAndDropCommandInformation(
					domain, target, location, event.operations,
					originalOperation, source);

			// Remember the target; create the command and test if it is
			// executable.
			commandTarget = target;
			command = dragAndDropCommandInformation.createCommand();
			valid = command.canExecute();
		} else {
			// Check if the cached command can provide DND
			// feedback/revalidation.
			if (target == commandTarget
					&& command instanceof DragAndDropFeedback) {
				// If so, revalidate the command.
				valid = ((DragAndDropFeedback) command).validate(target,
						location, event.operations, originalOperation, source);

				// Keep track of any changes to the command information.
				dragAndDropCommandInformation = new DragAndDropCommandInformation(
						domain, target, location, event.operations,
						originalOperation, source);
			} else {
				// If not, dispose the current command and create a new one.
				dragAndDropCommandInformation = new DragAndDropCommandInformation(
						domain, target, location, event.operations,
						originalOperation, source);
				commandTarget = target;
				command.dispose();
				command = dragAndDropCommandInformation.createCommand();
				valid = command.canExecute();
			}
		}

		// If this command can provide detailed drag and drop feedback...
		if (command instanceof DragAndDropFeedback) {
			// Use it for the operation and drag under effect.
			DragAndDropFeedback dragAndDropFeedback = (DragAndDropFeedback) command;
			event.detail = dragAndDropFeedback.getOperation();
			event.feedback = dragAndDropFeedback.getFeedback()
					| getAutoFeedback();
		} else if (!valid) {
			// There is no executable command, so we'd better nix the whole
			// deal.
			event.detail = DND.DROP_NONE;
		}
	}
	
	private void modifiySource(Object target) {
		if (source == null || source.isEmpty()) {
			return;
		}
		if (!(target instanceof Activity)) {
			return;
		}
		Process proc = ProcessUtil.getProcess((Activity) target);
		if (! ProcessScopeUtil.getInstance().isConfigFree(proc)) {
			return;
		}

		boolean toModify = false; 
		for (Object obj : source) {
			if (obj instanceof ProcessComponent) {
				toModify = true;
				break;
			}
		}
		if (!toModify) {
			return;
		}
		List<Object> list = new ArrayList<Object>();
		for (Object obj : source) {
			if (obj instanceof ProcessComponent) {
				Object process = ((ProcessComponent) obj).getProcess();
				if (process != null) {
					obj = process;
				}
			}
			list.add(obj);
		}
		source = list;
	}

}