| /****************************************************************************** |
| * Copyright (c) 2002, 2009 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 API and implementation |
| ****************************************************************************/ |
| |
| package org.eclipse.gmf.runtime.diagram.ui.parts; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Iterator; |
| import java.util.List; |
| |
| import org.eclipse.core.runtime.IAdaptable; |
| import org.eclipse.draw2d.Cursors; |
| import org.eclipse.gef.EditPart; |
| import org.eclipse.gef.EditPartViewer; |
| import org.eclipse.gef.Request; |
| import org.eclipse.gef.commands.Command; |
| import org.eclipse.gef.dnd.AbstractTransferDropTargetListener; |
| import org.eclipse.jface.util.LocalSelectionTransfer; |
| import org.eclipse.jface.viewers.StructuredSelection; |
| import org.eclipse.swt.dnd.DND; |
| import org.eclipse.swt.dnd.DropTargetEvent; |
| import org.eclipse.swt.dnd.Transfer; |
| |
| import org.eclipse.gmf.runtime.diagram.ui.requests.DropObjectsRequest; |
| import org.eclipse.gmf.runtime.notation.View; |
| |
| /** |
| * Performs a drop of one or more semantic elements using a given transfer. The Drop is performed by |
| * using a {@link DropObjectsRequest} to obtain a <code>Command</code> from the targeted |
| * <code>EditPart</code>. The target edit part might re-interpret the <code>DropElementsRequest</code> |
| * to mean another request. Note that some transfers on different OS's occur at the drop time, hence |
| * live feedback cannot be provided for these transfers (i.e. command created). If this is the case then to enable |
| * drag and drop on different platforms {@link #isDataTransfered()} needs to be implemented. |
| * <P> |
| * This class is <code>abstract</code>. Subclasses are responsible for providing the |
| * appropriate <code>Transfer</code> object based on the type of elements that are being dragged. |
| * |
| * @author melaasar, aboyko |
| */ |
| public abstract class DiagramDropTargetListener |
| extends AbstractTransferDropTargetListener { |
| |
| /** |
| * Constructor for DiagramDropTargetListener. |
| * @param viewer |
| */ |
| public DiagramDropTargetListener(EditPartViewer viewer) { |
| super(viewer); |
| setEnablementDeterminedByCommand(true); |
| } |
| |
| /** |
| * Constructor for DiagramDropTargetListener. |
| * @param viewer |
| * @param xfer |
| */ |
| public DiagramDropTargetListener(EditPartViewer viewer, Transfer xfer) { |
| super(viewer, xfer); |
| setEnablementDeterminedByCommand(true); |
| } |
| |
| /** |
| * |
| * @see org.eclipse.gef.dnd.AbstractTransferDropTargetListener#createTargetRequest() |
| */ |
| protected Request createTargetRequest() { |
| return new DropObjectsRequest(); |
| } |
| |
| /** |
| * A helper method that casts the target Request to a DropElementsRequest. |
| * @return DropElementsRequest |
| */ |
| protected final DropObjectsRequest getDropObjectsRequest() { |
| return ((DropObjectsRequest) getTargetRequest()); |
| } |
| |
| /** |
| * gets a list of objects being dropped on the diagram |
| * @return <code>List</code> |
| */ |
| protected abstract List getObjectsBeingDropped(); |
| |
| /** |
| * @see org.eclipse.swt.dnd.DropTargetListener#dragEnter(org.eclipse.swt.dnd.DropTargetEvent) |
| */ |
| public void dragEnter(DropTargetEvent event) { |
| super.dragEnter(event); |
| handleDragEnter(); // called to properly initialize the effect |
| } |
| |
| /** |
| * Called whenever the User enters the target. By default, the target Request and |
| * target EditPart are updated, and feedback is |
| */ |
| protected void handleDragEnter() { |
| handleDragOver(); |
| } |
| |
| /** |
| * The purpose of a template is to be copied. Therefore, the drop operation can't be |
| * anything but <code>DND.DROP_COPY</code>. |
| * @see AbstractTransferDropTargetListener#handleDragOperationChanged() |
| */ |
| protected void handleDragOperationChanged() { |
| super.handleDragOperationChanged(); |
| /* |
| * The edit policies creating the command for the drop request may modify the |
| * required detail field, so it's being set for the event here. However, if the command |
| * can't be created due to the fact that data hasn't been transfered yet then the request will |
| * contain DND.DROP_NONE required detail that we don't want to set for the event. |
| */ |
| if (getDropObjectsRequest().getRequiredDetail() != DND.DROP_NONE) { |
| getCurrentEvent().detail = getDropObjectsRequest().getRequiredDetail(); |
| } |
| } |
| |
| /** |
| * The purpose of a template is to be copied. Therefore, the Drop operation is set to |
| * <code>DND.DROP_COPY</code> by default. |
| * @see org.eclipse.gef.dnd.AbstractTransferDropTargetListener#handleDragOver() |
| */ |
| protected void handleDragOver() { |
| super.handleDragOver(); |
| /* |
| * The edit policies creating the command for the drop request may modify the |
| * required detail field, so it's being set for the event here. However, if the command |
| * can't be created due to the fact that data hasn't been transfered yet then the request will |
| * contain DND.DROP_NONE required detail that we don't want to set for the event. |
| */ |
| if (getDropObjectsRequest().getRequiredDetail() != DND.DROP_NONE) { |
| getCurrentEvent().detail = getDropObjectsRequest().getRequiredDetail(); |
| } |
| getCurrentEvent().feedback = DND.FEEDBACK_SCROLL | DND.FEEDBACK_EXPAND; |
| } |
| |
| /** |
| * Overridden to select the request result if any |
| * @see org.eclipse.gef.dnd.AbstractTransferDropTargetListener#handleDrop() |
| */ |
| protected void handleDrop() { |
| getViewer().setCursor(Cursors.WAIT); |
| super.handleDrop(); |
| getViewer().setCursor(null); |
| selectAddedViews(); |
| } |
| |
| /** |
| * Selects the created views that could result from the drop request if any |
| */ |
| private void selectAddedViews() { |
| Object result = getDropObjectsRequest().getResult(); |
| if (result == null || !(result instanceof Collection)) |
| return; |
| EditPartViewer viewer = getViewer(); |
| List editParts = new ArrayList(); |
| Iterator views = ((Collection)result).iterator(); |
| |
| while (views.hasNext()) { |
| Object view = views.next(); |
| if (view instanceof IAdaptable) { |
| EditPart editPart = (EditPart) viewer.getEditPartRegistry().get(((IAdaptable)view).getAdapter(View.class)); |
| if (editPart != null) |
| editParts.add(editPart); |
| } |
| } |
| |
| if (!editParts.isEmpty()) { |
| //Force a layout first. |
| viewer.getControl().forceFocus(); |
| getViewer().flush(); |
| viewer.setSelection(new StructuredSelection(editParts)); |
| } |
| } |
| |
| /** |
| * Assumes that the target request is a {@link DropObjectsRequest}. GEF |
| * wipes out the request in {@link #isEnabled(DropTargetEvent)} method, we |
| * don't. Hence we just update the necessary fields: <li>the mouse location |
| * <li>the objects being dropped <li>the allowed detail that comes from the |
| * DND event |
| * |
| * @see org.eclipse.gef.dnd.AbstractTransferDropTargetListener# |
| * updateTargetRequest() |
| */ |
| protected void updateTargetRequest() { |
| DropObjectsRequest request = getDropObjectsRequest(); |
| request.setLocation(getDropLocation()); |
| request.setObjects(getObjectsBeingDropped()); |
| request.setAllowedDetail(getCurrentEvent().operations); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.gef.dnd.AbstractTransferDropTargetListener#isEnabled(org.eclipse.swt.dnd.DropTargetEvent) |
| */ |
| public boolean isEnabled(DropTargetEvent event) { |
| /* |
| * Cache the current event |
| */ |
| setCurrentEvent(event); |
| |
| /* |
| * Update the target request and target editpart |
| */ |
| updateTargetRequest(); |
| updateTargetEditPart(); |
| |
| if (getTargetEditPart() == null) { |
| return false; |
| } else if (isEnablementDeterminedByCommand() && isDataTransfered()) { |
| /* |
| * Check the command only if: |
| * 1) The data has been transfered from the drag source to the event |
| * 2) The "ask for command" option is on. (It's "on" by default) |
| */ |
| Command command = getCommand(); |
| return command != null && command.canExecute(); |
| } else { |
| /* |
| * Otherwise we should enable the drop. Executable command needs to be created at the drop time anyway. |
| * Hence, we'll fail the drop there if there is no target editpart or no data transfered. |
| */ |
| return true; |
| } |
| } |
| |
| /** |
| * It is not a common use case to have the transfered data at the drag time, |
| * hence live feedback cannot be provided for all types of DnD. Since the |
| * occurrence of the data transfer at the drag time depends mostly on the |
| * used OS and the the type of data transfer, clients are responsible to |
| * experiment with their DnD and come up with the appropriate implementation |
| * of this method for their specific DnD support. By default the method |
| * checks if there is a local selection transfer or data field in the event |
| * is not null. |
| * |
| * @return <code>true</code> if data has been transfered. |
| */ |
| protected boolean isDataTransfered() { |
| return LocalSelectionTransfer.getTransfer().getSelection() != null || getCurrentEvent().data != null; |
| } |
| |
| } |
