Skip to content

Content of file EditingDomainViewerDropAdapter.java

/**
 * Copyright (c) 2002-2010 IBM Corporation and others.
 * 
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 * IBM - Initial API and implementation
 */
// REUSED CLASS
package org.eclipse.emf.edit.ui.dnd;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

import org.eclipse.emf.common.command.Command;
import org.eclipse.emf.edit.command.DragAndDropCommand;
import org.eclipse.emf.edit.command.DragAndDropFeedback;
import org.eclipse.emf.edit.domain.EditingDomain;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.dnd.DND;
import org.eclipse.swt.dnd.DropTargetAdapter;
import org.eclipse.swt.dnd.DropTargetEvent;
import org.eclipse.swt.dnd.TransferData;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.TableItem;
import org.eclipse.swt.widgets.TreeItem;
import org.eclipse.swt.widgets.Widget;

/**
 * This implementation of a drop target listener is designed to turn a drag and drop
 * operation into a {@link Command} based on the model objects of an {@link EditingDomain} and created by
 * {@link DragAndDropCommand#create}. It is
 * designed to do early data transfer so the the enablement and feedback of the
 * drag and drop interaction can intimately depend on the state of the model objects
 * involved. On some platforms, however, early data transfer is not available, so this
 * feedback cannot be provided.
 * <p>
 * The base implementation of this class should be sufficient for most applications. Any change in behaviour is
 * typically accomplished by overriding {@link org.eclipse.emf.edit.provider.ItemProviderAdapter}
 * .createDragAndDropCommand to return a derived implementation of {@link DragAndDropCommand}. This is how one these
 * adapters is typically hooked up:
 *
 * <pre>
 * viewer.addDropSupport(DND.DROP_COPY | DND.DROP_MOVE | DND.DROP_LINK,
 * 	new Transfer[] { LocalTransfer.getInstance() },
 * 	EditingDomainViewerDropAdapter(viewer));
 * </pre>
 * <p>
 * This implementation prefers to use a {@link LocalTransfer}, which short-circuits the transfer process for simple
 * transfers within the workbench, the method {@link #getDragSource} can be overridden to change the behaviour. The
 * implementation also only handles an {@link IStructuredSelection}, but the method {@link #extractDragSource} can be
 * overridden to change the behaviour.
 * <p>
 * SWT's {@link DND#FEEDBACK_SCROLL auto-scroll} and {@link DND#FEEDBACK_EXPAND auto-expand} (hover) are enabled by
 * default. The method {@link #getAutoFeedback} can be overridden to change this behaviour.
 */
public class EditingDomainViewerDropAdapter extends DropTargetAdapter {
	private static final long serialVersionUID = 1L;
/** * This indicates whether the current platform is motif, which needs * special treatment, since it cannot do early data transfer, but doesn't * cleanly return null either. */ protected final static boolean IS_MOTIF = "motif".equals(SWT.getPlatform()); //$NON-NLS-1$ /** * This is the viewer for which this is a drop target listener. */ protected Viewer viewer; /** * This is the domain in which drag and drop commands will be executed. */ protected EditingDomain domain; /** * This is the collection of source objects being dragged. */ protected Collection<?> source; /** * This is the command created during dragging which provides the feedback and will carry out the action upon * completion. */ protected Command command; /** * This records the object for which the {@link #command} was created. */ protected Object commandTarget; /** * This keeps track of the original operation that the user requested, before * we started changing the event.detail. We always try to create the command * using this. */ protected int originalOperation; /** * This keeps track of the information used to create {@link #command}, but * does not need to be disposed. This allows us to dispose of the command * in dragLeave, and then, if we need to execute it, recreate it in drop. */ protected DragAndDropCommandInformation dragAndDropCommandInformation; /** * This creates an instance with the given domain and viewer. */ public EditingDomainViewerDropAdapter(EditingDomain domain, Viewer viewer) { this.viewer = viewer; this.domain = domain; } /** * This is called when the mouse first enters or starts dragging in the viewer. */ @Override public void dragEnter(DropTargetEvent event) { // Remember the requested operation. originalOperation = event.detail; helper(event); } /** * This is called when the mouse leaves or stops dragging in the viewer, * whether the operation was aborted or is about to do a dropAccept and drop. * The event argument is uninitialized, so it is impossible to distinguish * between the two cases. So, we do the clean-up now and recreate the * command later, if necessary. */ @Override public void dragLeave(DropTargetEvent event) { // Clean up the command if there is one. If we need it again in drop, // we'll recreate it from dragAndDropCommandInformation. // if (command != null) { command.dispose(); command = null; commandTarget = null; } // Clear the source data. We won't need this again, since, if it was // available, it's already in the command. // source = null; } /** * This is called when the operation has changed in some way, typically because the user changes keyboard modifiers. */ @Override public void dragOperationChanged(DropTargetEvent event) { // Remember the requested operation. originalOperation = event.detail; helper(event); } /** * This is called repeatedly, as the mouse moves over the viewer. */ @Override public void dragOver(DropTargetEvent event) { helper(event); } /** * This is called when the mouse is released over the viewer to initiate a * drop, between dragLeave and drop. */ @Override public void dropAccept(DropTargetEvent event) { helper(event); } /** * This is called to indicate that the drop action should be invoked. */ @Override 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); final Object target = extractDropTarget(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; dragAndDropCommandInformation = 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 helper(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) { // Clear out any old information from a previous drag. // dragAndDropCommandInformation = null; return; } } // Get the target object from the item widget and the mouse location in it. // final Object target = extractDropTarget(event.item); final float location = getLocation(event); // Determine if we can create a valid command at the current location. // boolean valid = false; // 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. // final 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; } } /** * This returns the bitwise OR'ed flags for desired auto-feedback effects. * Drag under effect DND constants are always OR'ed with this to enable them. * This implementation enables {@link DND#FEEDBACK_SCROLL auto-scroll} and {@link DND#FEEDBACK_EXPAND auto-expand} * (hover). */ protected int getAutoFeedback() { return DND.FEEDBACK_SCROLL | DND.FEEDBACK_EXPAND; } /** * This attempts to extract the drag source from the event early, i.e., * before the drop method. This implementation tries to use a {@link org.eclipse.emf.edit.ui.dnd.LocalTransfer}. If * the data is not yet * available (e.g. on platforms other than win32), it just returns null. */ protected Collection<?> getDragSource(DropTargetEvent event) { // Check whether the current data type can be transfered locally. // final LocalTransfer localTransfer = LocalTransfer.getInstance(); if (!localTransfer.isSupportedType(event.currentDataType)) { // Iterate over the data types to see if there is a data type that supports a local transfer. // final TransferData[] dataTypes = event.dataTypes; for (int i = 0; i < dataTypes.length; ++i) { final TransferData transferData = dataTypes[i]; // If the local transfer supports this data type, switch to that data type // if (localTransfer.isSupportedType(transferData)) { event.currentDataType = transferData; } } return null; } // Motif kludge: we would get something random instead of null. // if (IS_MOTIF) { return null; } // Transfer the data and, if non-null, extract it. // final Object object = localTransfer.nativeToJava(event.currentDataType); return object == null ? null : extractDragSource(object); } /** * This extracts a collection of dragged source objects from the given object retrieved from the transfer agent. * This default implementation converts a structured selection into a collection of elements. */ protected Collection<?> extractDragSource(Object object) { // Transfer the data and convert the structured selection to a collection of objects. // if (object instanceof IStructuredSelection) { final List<?> list = ((IStructuredSelection) object).toList(); return list; } return Collections.EMPTY_LIST; } /** * This extracts an object from the given item widget, providing the special * support required by an {@link org.eclipse.emf.common.ui.viewer.ExtendedTableTreeViewer.ExtendedTableTreeItem}. */ protected Object extractDropTarget(Widget item) { if (item == null) { return null; } return item.getData(); } /** * This returns the location of the mouse in the vertical direction, relative * to the item widget, from 0 (top) to 1 (bottom). */ protected float getLocation(DropTargetEvent event) { if (event.item instanceof TreeItem) { final TreeItem treeItem = (TreeItem) event.item; final Control control = treeItem.getParent(); final Point point = control.toControl(new Point(event.x, event.y)); final Rectangle bounds = treeItem.getBounds(); return (float) (point.y - bounds.y) / (float) bounds.height; } else if (event.item instanceof TableItem) { final TableItem tableItem = (TableItem) event.item; final Control control = tableItem.getParent(); final Point point = control.toControl(new Point(event.x, event.y)); final Rectangle bounds = tableItem.getBounds(0); return (float) (point.y - bounds.y) / (float) bounds.height; } else { return 0.0F; } } /** * This holds all of the information used to create a {@link DragAndDropCommand}, but does not need to be disposed. */ protected static class DragAndDropCommandInformation { protected EditingDomain domain; protected Object target; protected float location; protected int operations; protected int operation; protected Collection<?> source; public DragAndDropCommandInformation(EditingDomain domain, Object target, float location, int operations, int operation, Collection<?> source) { this.domain = domain; this.target = target; this.location = location; this.operations = operations; this.operation = operation; this.source = new ArrayList<Object>(source); } public Command createCommand() { return DragAndDropCommand.create(domain, target, location, operations, operation, source); } } }