| /* |
| * Copyright (C) 2010 The Android Open Source Project |
| * |
| * Licensed under the Eclipse Public License, Version 1.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.eclipse.org/org/documents/epl-v10.php |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.ide.eclipse.adt.internal.editors.layout.gle2; |
| |
| import com.android.SdkConstants; |
| import com.android.ide.common.api.DropFeedback; |
| import com.android.ide.common.api.IViewRule; |
| import com.android.ide.common.api.Rect; |
| import com.android.ide.common.api.SegmentType; |
| import com.android.ide.eclipse.adt.internal.editors.layout.gre.NodeProxy; |
| import com.android.utils.Pair; |
| |
| import org.eclipse.jface.action.IStatusLineManager; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.dnd.DND; |
| import org.eclipse.swt.dnd.DragSource; |
| import org.eclipse.swt.dnd.DragSourceEvent; |
| import org.eclipse.swt.dnd.DragSourceListener; |
| import org.eclipse.swt.dnd.DropTarget; |
| import org.eclipse.swt.dnd.DropTargetEvent; |
| import org.eclipse.swt.dnd.DropTargetListener; |
| import org.eclipse.swt.dnd.TextTransfer; |
| import org.eclipse.swt.events.KeyEvent; |
| import org.eclipse.swt.events.KeyListener; |
| import org.eclipse.swt.events.MouseEvent; |
| import org.eclipse.swt.events.MouseListener; |
| import org.eclipse.swt.events.MouseMoveListener; |
| import org.eclipse.swt.events.MouseTrackListener; |
| import org.eclipse.swt.events.TypedEvent; |
| import org.eclipse.swt.graphics.Cursor; |
| import org.eclipse.swt.graphics.Device; |
| import org.eclipse.swt.graphics.GC; |
| import org.eclipse.swt.graphics.Image; |
| import org.eclipse.swt.graphics.ImageData; |
| import org.eclipse.swt.graphics.Rectangle; |
| import org.eclipse.swt.widgets.Display; |
| import org.eclipse.ui.IEditorSite; |
| |
| import java.util.ArrayList; |
| import java.util.List; |
| |
| /** |
| * The {@link GestureManager} is is the central manager of gestures; it is responsible |
| * for recognizing when particular gestures should begin and terminate. It |
| * listens to the drag, mouse and keyboard systems to find out when to start |
| * gestures and in order to update the gestures along the way. |
| */ |
| public class GestureManager { |
| /** The canvas which owns this GestureManager. */ |
| private final LayoutCanvas mCanvas; |
| |
| /** The currently executing gesture, or null. */ |
| private Gesture mCurrentGesture; |
| |
| /** A listener for drop target events. */ |
| private final DropTargetListener mDropListener = new CanvasDropListener(); |
| |
| /** A listener for drag source events. */ |
| private final DragSourceListener mDragSourceListener = new CanvasDragSourceListener(); |
| |
| /** Tooltip shown during the gesture, or null */ |
| private GestureToolTip mTooltip; |
| |
| /** |
| * The list of overlays associated with {@link #mCurrentGesture}. Will be |
| * null before it has been initialized lazily by the paint routine (the |
| * initialized value can never be null, but it can be an empty collection). |
| */ |
| private List<Overlay> mOverlays; |
| |
| /** |
| * Most recently seen mouse position (x coordinate). We keep a copy of this |
| * value since we sometimes need to know it when we aren't told about the |
| * mouse position (such as when a keystroke is received, such as an arrow |
| * key in order to tweak the current drop position) |
| */ |
| protected int mLastMouseX; |
| |
| /** |
| * Most recently seen mouse position (y coordinate). We keep a copy of this |
| * value since we sometimes need to know it when we aren't told about the |
| * mouse position (such as when a keystroke is received, such as an arrow |
| * key in order to tweak the current drop position) |
| */ |
| protected int mLastMouseY; |
| |
| /** |
| * Most recently seen mouse mask. We keep a copy of this since in some |
| * scenarios (such as on a drag gesture) we don't get access to it. |
| */ |
| protected int mLastStateMask; |
| |
| /** |
| * Listener for mouse motion, click and keyboard events. |
| */ |
| private Listener mListener; |
| |
| /** |
| * When we the drag leaves, we don't know if that's the last we'll see of |
| * this drag or if it's just temporarily outside the canvas and it will |
| * return. We want to restore it if it comes back. This is also necessary |
| * because even on a drop we'll receive a |
| * {@link DropTargetListener#dragLeave} right before the drop, and we need |
| * to restore it in the drop. Therefore, when we lose a {@link DropGesture} |
| * to a {@link DropTargetListener#dragLeave}, we store a reference to the |
| * current gesture as a {@link #mZombieGesture}, since the gesture is dead |
| * but might be brought back to life if we see a subsequent |
| * {@link DropTargetListener#dragEnter} before another gesture begins. |
| */ |
| private DropGesture mZombieGesture; |
| |
| /** |
| * Flag tracking whether we've set a message or error message on the global status |
| * line (since we only want to clear that message if we have set it ourselves). |
| * This is the actual message rather than a boolean such that (if we can get our |
| * hands on the global message) we can check to see if the current message is the |
| * one we set and only in that case clear it when it is no longer applicable. |
| */ |
| private String mDisplayingMessage; |
| |
| /** |
| * Constructs a new {@link GestureManager} for the given |
| * {@link LayoutCanvas}. |
| * |
| * @param canvas The canvas which controls this {@link GestureManager} |
| */ |
| public GestureManager(LayoutCanvas canvas) { |
| mCanvas = canvas; |
| } |
| |
| /** |
| * Returns the canvas associated with this GestureManager. |
| * |
| * @return The {@link LayoutCanvas} associated with this GestureManager. |
| * Never null. |
| */ |
| public LayoutCanvas getCanvas() { |
| return mCanvas; |
| } |
| |
| /** |
| * Returns the current gesture, if one is in progress, and otherwise returns |
| * null. |
| * |
| * @return The current gesture or null. |
| */ |
| public Gesture getCurrentGesture() { |
| return mCurrentGesture; |
| } |
| |
| /** |
| * Paints the overlays associated with the current gesture, if any. |
| * |
| * @param gc The graphics object to paint into. |
| */ |
| public void paint(GC gc) { |
| if (mCurrentGesture == null) { |
| return; |
| } |
| |
| if (mOverlays == null) { |
| mOverlays = mCurrentGesture.createOverlays(); |
| Device device = gc.getDevice(); |
| for (Overlay overlay : mOverlays) { |
| overlay.create(device); |
| } |
| } |
| for (Overlay overlay : mOverlays) { |
| overlay.paint(gc); |
| } |
| } |
| |
| /** |
| * Registers all the listeners needed by the {@link GestureManager}. |
| * |
| * @param dragSource The drag source in the {@link LayoutCanvas} to listen |
| * to. |
| * @param dropTarget The drop target in the {@link LayoutCanvas} to listen |
| * to. |
| */ |
| public void registerListeners(DragSource dragSource, DropTarget dropTarget) { |
| assert mListener == null; |
| mListener = new Listener(); |
| mCanvas.addMouseMoveListener(mListener); |
| mCanvas.addMouseListener(mListener); |
| mCanvas.addKeyListener(mListener); |
| |
| if (dragSource != null) { |
| dragSource.addDragListener(mDragSourceListener); |
| } |
| if (dropTarget != null) { |
| dropTarget.addDropListener(mDropListener); |
| } |
| } |
| |
| /** |
| * Unregisters all the listeners previously registered by |
| * {@link #registerListeners}. |
| * |
| * @param dragSource The drag source in the {@link LayoutCanvas} to stop |
| * listening to. |
| * @param dropTarget The drop target in the {@link LayoutCanvas} to stop |
| * listening to. |
| */ |
| public void unregisterListeners(DragSource dragSource, DropTarget dropTarget) { |
| if (mCanvas.isDisposed()) { |
| // If the LayoutCanvas is already disposed, we shouldn't try to unregister |
| // the listeners; they are already not active and an attempt to remove the |
| // listener will throw a widget-is-disposed exception. |
| mListener = null; |
| return; |
| } |
| |
| if (mListener != null) { |
| mCanvas.removeMouseMoveListener(mListener); |
| mCanvas.removeMouseListener(mListener); |
| mCanvas.removeKeyListener(mListener); |
| mListener = null; |
| } |
| |
| if (dragSource != null) { |
| dragSource.removeDragListener(mDragSourceListener); |
| } |
| if (dropTarget != null) { |
| dropTarget.removeDropListener(mDropListener); |
| } |
| } |
| |
| /** |
| * Starts the given gesture. |
| * |
| * @param mousePos The most recent mouse coordinate applicable to the new |
| * gesture, in control coordinates. |
| * @param gesture The gesture to initiate |
| */ |
| private void startGesture(ControlPoint mousePos, Gesture gesture, int mask) { |
| if (mCurrentGesture != null) { |
| finishGesture(mousePos, true); |
| assert mCurrentGesture == null; |
| } |
| |
| if (gesture != null) { |
| mCurrentGesture = gesture; |
| mCurrentGesture.begin(mousePos, mask); |
| } |
| } |
| |
| /** |
| * Updates the current gesture, if any, for the given event. |
| * |
| * @param mousePos The most recent mouse coordinate applicable to the new |
| * gesture, in control coordinates. |
| * @param event The event corresponding to this update. May be null. Don't |
| * make any assumptions about the type of this event - for |
| * example, it may not always be a MouseEvent, it could be a |
| * DragSourceEvent, etc. |
| */ |
| private void updateMouse(ControlPoint mousePos, TypedEvent event) { |
| if (mCurrentGesture != null) { |
| mCurrentGesture.update(mousePos); |
| } |
| } |
| |
| /** |
| * Finish the given gesture, either from successful completion or from |
| * cancellation. |
| * |
| * @param mousePos The most recent mouse coordinate applicable to the new |
| * gesture, in control coordinates. |
| * @param canceled True if and only if the gesture was canceled. |
| */ |
| private void finishGesture(ControlPoint mousePos, boolean canceled) { |
| if (mCurrentGesture != null) { |
| mCurrentGesture.end(mousePos, canceled); |
| if (mOverlays != null) { |
| for (Overlay overlay : mOverlays) { |
| overlay.dispose(); |
| } |
| mOverlays = null; |
| } |
| mCurrentGesture = null; |
| mZombieGesture = null; |
| mLastStateMask = 0; |
| updateMessage(null); |
| updateCursor(mousePos); |
| mCanvas.redraw(); |
| } |
| } |
| |
| /** |
| * Update the cursor to show the type of operation we expect on a mouse press: |
| * <ul> |
| * <li>Over a selection handle, show a directional cursor depending on the position of |
| * the selection handle |
| * <li>Over a widget, show a move (hand) cursor |
| * <li>Otherwise, show the default arrow cursor |
| * </ul> |
| */ |
| void updateCursor(ControlPoint controlPoint) { |
| // We don't hover on the root since it's not a widget per see and it is always there. |
| SelectionManager selectionManager = mCanvas.getSelectionManager(); |
| |
| if (!selectionManager.isEmpty()) { |
| Display display = mCanvas.getDisplay(); |
| Pair<SelectionItem, SelectionHandle> handlePair = |
| selectionManager.findHandle(controlPoint); |
| if (handlePair != null) { |
| SelectionHandle handle = handlePair.getSecond(); |
| int cursorType = handle.getSwtCursorType(); |
| Cursor cursor = display.getSystemCursor(cursorType); |
| if (cursor != mCanvas.getCursor()) { |
| mCanvas.setCursor(cursor); |
| } |
| return; |
| } |
| |
| // See if it's over a selected view |
| LayoutPoint layoutPoint = controlPoint.toLayout(); |
| for (SelectionItem item : selectionManager.getSelections()) { |
| if (item.getRect().contains(layoutPoint.x, layoutPoint.y) |
| && !item.isRoot()) { |
| Cursor cursor = display.getSystemCursor(SWT.CURSOR_HAND); |
| if (cursor != mCanvas.getCursor()) { |
| mCanvas.setCursor(cursor); |
| } |
| return; |
| } |
| } |
| } |
| |
| if (mCanvas.getCursor() != null) { |
| mCanvas.setCursor(null); |
| } |
| } |
| |
| /** |
| * Update the Eclipse status message with any feedback messages from the given |
| * {@link DropFeedback} object, or clean up if there is no more feedback to process |
| * @param feedback the feedback whose message we want to display, or null to clear the |
| * message if previously set |
| */ |
| void updateMessage(DropFeedback feedback) { |
| IEditorSite editorSite = mCanvas.getEditorDelegate().getEditor().getEditorSite(); |
| IStatusLineManager status = editorSite.getActionBars().getStatusLineManager(); |
| if (feedback == null) { |
| if (mDisplayingMessage != null) { |
| status.setMessage(null); |
| status.setErrorMessage(null); |
| mDisplayingMessage = null; |
| } |
| } else if (feedback.errorMessage != null) { |
| if (!feedback.errorMessage.equals(mDisplayingMessage)) { |
| mDisplayingMessage = feedback.errorMessage; |
| status.setErrorMessage(mDisplayingMessage); |
| } |
| } else if (feedback.message != null) { |
| if (!feedback.message.equals(mDisplayingMessage)) { |
| mDisplayingMessage = feedback.message; |
| status.setMessage(mDisplayingMessage); |
| } |
| } else if (mDisplayingMessage != null) { |
| // TODO: Can we check the existing message and only clear it if it's the |
| // same as the one we set? |
| mDisplayingMessage = null; |
| status.setMessage(null); |
| status.setErrorMessage(null); |
| } |
| |
| // Tooltip |
| if (feedback != null && feedback.tooltip != null) { |
| Pair<Boolean,Boolean> position = mCurrentGesture.getTooltipPosition(); |
| boolean below = position.getFirst(); |
| if (feedback.tooltipY != null) { |
| below = feedback.tooltipY == SegmentType.BOTTOM; |
| } |
| boolean toRightOf = position.getSecond(); |
| if (feedback.tooltipX != null) { |
| toRightOf = feedback.tooltipX == SegmentType.RIGHT; |
| } |
| if (mTooltip == null) { |
| mTooltip = new GestureToolTip(mCanvas, below, toRightOf); |
| } |
| mTooltip.update(feedback.tooltip, below, toRightOf); |
| } else if (mTooltip != null) { |
| mTooltip.dispose(); |
| mTooltip = null; |
| } |
| } |
| |
| /** |
| * Returns the current mouse position as a {@link ControlPoint} |
| * |
| * @return the current mouse position as a {@link ControlPoint} |
| */ |
| public ControlPoint getCurrentControlPoint() { |
| return ControlPoint.create(mCanvas, mLastMouseX, mLastMouseY); |
| } |
| |
| /** |
| * Returns the current SWT modifier key mask as an {@link IViewRule} modifier mask |
| * |
| * @return the current SWT modifier key mask as an {@link IViewRule} modifier mask |
| */ |
| public int getRuleModifierMask() { |
| int swtMask = mLastStateMask; |
| int modifierMask = 0; |
| if ((swtMask & SWT.MOD1) != 0) { |
| modifierMask |= DropFeedback.MODIFIER1; |
| } |
| if ((swtMask & SWT.MOD2) != 0) { |
| modifierMask |= DropFeedback.MODIFIER2; |
| } |
| if ((swtMask & SWT.MOD3) != 0) { |
| modifierMask |= DropFeedback.MODIFIER3; |
| } |
| return modifierMask; |
| } |
| |
| /** |
| * Helper class which implements the {@link MouseMoveListener}, |
| * {@link MouseListener} and {@link KeyListener} interfaces. |
| */ |
| private class Listener implements MouseMoveListener, MouseListener, MouseTrackListener, |
| KeyListener { |
| |
| // --- MouseMoveListener --- |
| |
| @Override |
| public void mouseMove(MouseEvent e) { |
| mLastMouseX = e.x; |
| mLastMouseY = e.y; |
| mLastStateMask = e.stateMask; |
| |
| ControlPoint controlPoint = ControlPoint.create(mCanvas, e); |
| if ((e.stateMask & SWT.BUTTON_MASK) != 0) { |
| if (mCurrentGesture != null) { |
| updateMouse(controlPoint, e); |
| mCanvas.redraw(); |
| } |
| } else { |
| updateCursor(controlPoint); |
| mCanvas.hover(e); |
| mCanvas.getPreviewManager().moved(controlPoint); |
| } |
| } |
| |
| // --- MouseListener --- |
| |
| @Override |
| public void mouseUp(MouseEvent e) { |
| ControlPoint mousePos = ControlPoint.create(mCanvas, e); |
| |
| if (mCurrentGesture == null) { |
| // If clicking on a configuration preview, just process it there |
| if (mCanvas.getPreviewManager().click(mousePos)) { |
| return; |
| } |
| |
| // Just a click, select |
| Pair<SelectionItem, SelectionHandle> handlePair = |
| mCanvas.getSelectionManager().findHandle(mousePos); |
| if (handlePair == null) { |
| mCanvas.getSelectionManager().select(e); |
| } |
| } |
| if (mCurrentGesture == null) { |
| updateCursor(mousePos); |
| } else if (mCurrentGesture instanceof DropGesture) { |
| // Mouse Up shouldn't be delivered in the middle of a drag & drop - |
| // but this can happen on some versions of Linux |
| // (see http://code.google.com/p/android/issues/detail?id=19057 ) |
| // and if we process the mouseUp it will abort the remainder of |
| // the drag & drop operation, so ignore this event! |
| } else { |
| finishGesture(mousePos, false); |
| } |
| mCanvas.redraw(); |
| } |
| |
| @Override |
| public void mouseDown(MouseEvent e) { |
| mLastMouseX = e.x; |
| mLastMouseY = e.y; |
| mLastStateMask = e.stateMask; |
| |
| // Not yet used. Should be, for Mac and Linux. |
| } |
| |
| @Override |
| public void mouseDoubleClick(MouseEvent e) { |
| // SWT delivers a double click event even if you click two different buttons |
| // in rapid succession. In any case, we only want to let you double click the |
| // first button to warp to XML: |
| if (e.button == 1) { |
| // Warp to the text editor and show the corresponding XML for the |
| // double-clicked widget |
| LayoutPoint p = ControlPoint.create(mCanvas, e).toLayout(); |
| CanvasViewInfo vi = mCanvas.getViewHierarchy().findViewInfoAt(p); |
| if (vi != null) { |
| mCanvas.show(vi); |
| } |
| } |
| } |
| |
| // --- MouseTrackListener --- |
| |
| @Override |
| public void mouseEnter(MouseEvent e) { |
| ControlPoint mousePos = ControlPoint.create(mCanvas, e); |
| mCanvas.getPreviewManager().enter(mousePos); |
| } |
| |
| @Override |
| public void mouseExit(MouseEvent e) { |
| ControlPoint mousePos = ControlPoint.create(mCanvas, e); |
| mCanvas.getPreviewManager().exit(mousePos); |
| } |
| |
| @Override |
| public void mouseHover(MouseEvent e) { |
| } |
| |
| // --- KeyListener --- |
| |
| @Override |
| public void keyPressed(KeyEvent e) { |
| mLastStateMask = e.stateMask; |
| // Workaround for the fact that in keyPressed the current state |
| // mask is not yet updated |
| if (e.keyCode == SWT.SHIFT) { |
| mLastStateMask |= SWT.MOD2; |
| } |
| if (SdkConstants.CURRENT_PLATFORM == SdkConstants.PLATFORM_DARWIN) { |
| if (e.keyCode == SWT.COMMAND) { |
| mLastStateMask |= SWT.MOD1; |
| } |
| } else { |
| if (e.keyCode == SWT.CTRL) { |
| mLastStateMask |= SWT.MOD1; |
| } |
| } |
| |
| // Give gestures a first chance to see and consume the key press |
| if (mCurrentGesture != null) { |
| // unless it's "Escape", which cancels the gesture |
| if (e.keyCode == SWT.ESC) { |
| ControlPoint controlPoint = ControlPoint.create(mCanvas, |
| mLastMouseX, mLastMouseY); |
| finishGesture(controlPoint, true); |
| return; |
| } |
| |
| if (mCurrentGesture.keyPressed(e)) { |
| return; |
| } |
| } |
| |
| // Fall back to canvas actions for the key press |
| mCanvas.handleKeyPressed(e); |
| } |
| |
| @Override |
| public void keyReleased(KeyEvent e) { |
| mLastStateMask = e.stateMask; |
| // Workaround for the fact that in keyPressed the current state |
| // mask is not yet updated |
| if (e.keyCode == SWT.SHIFT) { |
| mLastStateMask &= ~SWT.MOD2; |
| } |
| if (SdkConstants.CURRENT_PLATFORM == SdkConstants.PLATFORM_DARWIN) { |
| if (e.keyCode == SWT.COMMAND) { |
| mLastStateMask &= ~SWT.MOD1; |
| } |
| } else { |
| if (e.keyCode == SWT.CTRL) { |
| mLastStateMask &= ~SWT.MOD1; |
| } |
| } |
| |
| if (mCurrentGesture != null) { |
| mCurrentGesture.keyReleased(e); |
| } |
| } |
| } |
| |
| /** Listener for Drag & Drop events. */ |
| private class CanvasDropListener implements DropTargetListener { |
| public CanvasDropListener() { |
| } |
| |
| /** |
| * The cursor has entered the drop target boundaries. {@inheritDoc} |
| */ |
| @Override |
| public void dragEnter(DropTargetEvent event) { |
| mCanvas.showInvisibleViews(true); |
| mCanvas.getEditorDelegate().getGraphicalEditor().dismissHoverPalette(); |
| |
| if (mCurrentGesture == null) { |
| Gesture newGesture = mZombieGesture; |
| if (newGesture == null) { |
| newGesture = new MoveGesture(mCanvas); |
| } else { |
| mZombieGesture = null; |
| } |
| startGesture(ControlPoint.create(mCanvas, event), |
| newGesture, 0); |
| } |
| |
| if (mCurrentGesture instanceof DropGesture) { |
| ((DropGesture) mCurrentGesture).dragEnter(event); |
| } |
| } |
| |
| /** |
| * The cursor is moving over the drop target. {@inheritDoc} |
| */ |
| @Override |
| public void dragOver(DropTargetEvent event) { |
| if (mCurrentGesture instanceof DropGesture) { |
| ((DropGesture) mCurrentGesture).dragOver(event); |
| } |
| } |
| |
| /** |
| * The cursor has left the drop target boundaries OR data is about to be |
| * dropped. {@inheritDoc} |
| */ |
| @Override |
| public void dragLeave(DropTargetEvent event) { |
| if (mCurrentGesture instanceof DropGesture) { |
| DropGesture dropGesture = (DropGesture) mCurrentGesture; |
| dropGesture.dragLeave(event); |
| finishGesture(ControlPoint.create(mCanvas, event), true); |
| mZombieGesture = dropGesture; |
| } |
| |
| mCanvas.showInvisibleViews(false); |
| } |
| |
| /** |
| * The drop is about to be performed. The drop target is given a last |
| * chance to change the nature of the drop. {@inheritDoc} |
| */ |
| @Override |
| public void dropAccept(DropTargetEvent event) { |
| Gesture gesture = mCurrentGesture != null ? mCurrentGesture : mZombieGesture; |
| if (gesture instanceof DropGesture) { |
| ((DropGesture) gesture).dropAccept(event); |
| } |
| } |
| |
| /** |
| * The data is being dropped. {@inheritDoc} |
| */ |
| @Override |
| public void drop(final DropTargetEvent event) { |
| // See if we had a gesture just prior to the drop (we receive a dragLeave |
| // right before the drop which we don't know whether means the cursor has |
| // left the canvas for good or just before a drop) |
| Gesture gesture = mCurrentGesture != null ? mCurrentGesture : mZombieGesture; |
| mZombieGesture = null; |
| |
| if (gesture instanceof DropGesture) { |
| ((DropGesture) gesture).drop(event); |
| |
| finishGesture(ControlPoint.create(mCanvas, event), true); |
| } |
| } |
| |
| /** |
| * The operation being performed has changed (e.g. modifier key). |
| * {@inheritDoc} |
| */ |
| @Override |
| public void dragOperationChanged(DropTargetEvent event) { |
| if (mCurrentGesture instanceof DropGesture) { |
| ((DropGesture) mCurrentGesture).dragOperationChanged(event); |
| } |
| } |
| } |
| |
| /** |
| * Our canvas {@link DragSourceListener}. Handles drag being started and |
| * finished and generating the drag data. |
| */ |
| private class CanvasDragSourceListener implements DragSourceListener { |
| |
| /** |
| * The current selection being dragged. This may be a subset of the |
| * canvas selection due to the "sanitize" pass. Can be empty but never |
| * null. |
| */ |
| private final ArrayList<SelectionItem> mDragSelection = new ArrayList<SelectionItem>(); |
| |
| private SimpleElement[] mDragElements; |
| |
| /** |
| * The user has begun the actions required to drag the widget. |
| * <p/> |
| * Initiate a drag only if there is one or more item selected. If |
| * there's none, try to auto-select the one under the cursor. |
| * {@inheritDoc} |
| */ |
| @Override |
| public void dragStart(DragSourceEvent e) { |
| LayoutPoint p = LayoutPoint.create(mCanvas, e); |
| ControlPoint controlPoint = ControlPoint.create(mCanvas, e); |
| SelectionManager selectionManager = mCanvas.getSelectionManager(); |
| |
| // See if the mouse is over a selection handle; if so, start a resizing |
| // gesture. |
| Pair<SelectionItem, SelectionHandle> handle = |
| selectionManager.findHandle(controlPoint); |
| if (handle != null) { |
| startGesture(controlPoint, new ResizeGesture(mCanvas, handle.getFirst(), |
| handle.getSecond()), mLastStateMask); |
| e.detail = DND.DROP_NONE; |
| e.doit = false; |
| mCanvas.redraw(); |
| return; |
| } |
| |
| // We need a selection (simple or multiple) to do any transfer. |
| // If there's a selection *and* the cursor is over this selection, |
| // use all the currently selected elements. |
| // If there is no selection or the cursor is not over a selected |
| // element, *change* the selection to match the element under the |
| // cursor and use that. If nothing can be selected, abort the drag |
| // operation. |
| List<SelectionItem> selections = selectionManager.getSelections(); |
| mDragSelection.clear(); |
| SelectionItem primary = null; |
| |
| if (!selections.isEmpty()) { |
| // Is the cursor on top of a selected element? |
| boolean insideSelection = false; |
| |
| for (SelectionItem cs : selections) { |
| if (!cs.isRoot() && cs.getRect().contains(p.x, p.y)) { |
| primary = cs; |
| insideSelection = true; |
| break; |
| } |
| } |
| |
| if (!insideSelection) { |
| CanvasViewInfo vi = mCanvas.getViewHierarchy().findViewInfoAt(p); |
| if (vi != null && !vi.isRoot() && !vi.isHidden()) { |
| primary = selectionManager.selectSingle(vi); |
| insideSelection = true; |
| } |
| } |
| |
| if (insideSelection) { |
| // We should now have a proper selection that matches the |
| // cursor. Let's use this one. We make a copy of it since |
| // the "sanitize" pass below might remove some of the |
| // selected objects. |
| if (selections.size() == 1) { |
| // You are dragging just one element - this might or |
| // might not be the root, but if it's the root that is |
| // fine since we will let you drag the root if it is the |
| // only thing you are dragging. |
| mDragSelection.addAll(selections); |
| } else { |
| // Only drag non-root items. |
| for (SelectionItem cs : selections) { |
| if (!cs.isRoot() && !cs.isHidden()) { |
| mDragSelection.add(cs); |
| } else if (cs == primary) { |
| primary = null; |
| } |
| } |
| } |
| } |
| } |
| |
| // If you are dragging a non-selected item, select it |
| if (mDragSelection.isEmpty()) { |
| CanvasViewInfo vi = mCanvas.getViewHierarchy().findViewInfoAt(p); |
| if (vi != null && !vi.isRoot() && !vi.isHidden()) { |
| primary = selectionManager.selectSingle(vi); |
| mDragSelection.addAll(selections); |
| } |
| } |
| |
| SelectionManager.sanitize(mDragSelection); |
| |
| e.doit = !mDragSelection.isEmpty(); |
| int imageCount = mDragSelection.size(); |
| if (e.doit) { |
| mDragElements = SelectionItem.getAsElements(mDragSelection, primary); |
| GlobalCanvasDragInfo.getInstance().startDrag(mDragElements, |
| mDragSelection.toArray(new SelectionItem[imageCount]), |
| mCanvas, new Runnable() { |
| @Override |
| public void run() { |
| mCanvas.getClipboardSupport().deleteSelection("Remove", |
| mDragSelection); |
| } |
| }); |
| } |
| |
| // If you drag on the -background-, we make that into a marquee |
| // selection |
| if (!e.doit || (imageCount == 1 |
| && (mDragSelection.get(0).isRoot() || mDragSelection.get(0).isHidden()))) { |
| boolean toggle = (mLastStateMask & (SWT.CTRL | SWT.SHIFT | SWT.COMMAND)) != 0; |
| startGesture(controlPoint, |
| new MarqueeGesture(mCanvas, toggle), mLastStateMask); |
| e.detail = DND.DROP_NONE; |
| e.doit = false; |
| } else { |
| // Otherwise, the drag means you are moving something |
| mCanvas.showInvisibleViews(true); |
| startGesture(controlPoint, new MoveGesture(mCanvas), 0); |
| |
| // Render drag-images: Copy portions of the full screen render. |
| Image image = mCanvas.getImageOverlay().getImage(); |
| if (image != null) { |
| /** |
| * Transparency of the dragged image ([0-255]). We're using 30% |
| * translucency to make the image faint and not obscure the drag |
| * feedback below it. |
| */ |
| final byte DRAG_TRANSPARENCY = (byte) (0.3 * 255); |
| |
| List<Rectangle> rectangles = new ArrayList<Rectangle>(imageCount); |
| if (imageCount > 0) { |
| ImageData data = image.getImageData(); |
| Rectangle imageRectangle = new Rectangle(0, 0, data.width, data.height); |
| for (SelectionItem item : mDragSelection) { |
| Rectangle bounds = item.getRect(); |
| // Some bounds can be outside the rendered rectangle (for |
| // example, in an absolute layout, you can have negative |
| // coordinates), so create the intersection of these bounds. |
| Rectangle clippedBounds = imageRectangle.intersection(bounds); |
| rectangles.add(clippedBounds); |
| } |
| Rectangle boundingBox = ImageUtils.getBoundingRectangle(rectangles); |
| double scale = mCanvas.getHorizontalTransform().getScale(); |
| e.image = SwtUtils.drawRectangles(image, rectangles, boundingBox, scale, |
| DRAG_TRANSPARENCY); |
| |
| // Set the image offset such that we preserve the relative |
| // distance between the mouse pointer and the top left corner of |
| // the dragged view |
| int deltaX = (int) (scale * (boundingBox.x - p.x)); |
| int deltaY = (int) (scale * (boundingBox.y - p.y)); |
| e.offsetX = -deltaX; |
| e.offsetY = -deltaY; |
| |
| // View rules may need to know it as well |
| GlobalCanvasDragInfo dragInfo = GlobalCanvasDragInfo.getInstance(); |
| Rect dragBounds = null; |
| int width = (int) (scale * boundingBox.width); |
| int height = (int) (scale * boundingBox.height); |
| dragBounds = new Rect(deltaX, deltaY, width, height); |
| dragInfo.setDragBounds(dragBounds); |
| |
| // Record the baseline such that we can perform baseline alignment |
| // on the node as it's dragged around |
| NodeProxy firstNode = |
| mCanvas.getNodeFactory().create(mDragSelection.get(0).getViewInfo()); |
| dragInfo.setDragBaseline(firstNode.getBaseline()); |
| } |
| } |
| } |
| |
| // No hover during drag (since no mouse over events are delivered |
| // during a drag to keep the hovers up to date anyway) |
| mCanvas.clearHover(); |
| |
| mCanvas.redraw(); |
| } |
| |
| /** |
| * Callback invoked when data is needed for the event, typically right |
| * before drop. The drop side decides what type of transfer to use and |
| * this side must now provide the adequate data. {@inheritDoc} |
| */ |
| @Override |
| public void dragSetData(DragSourceEvent e) { |
| if (TextTransfer.getInstance().isSupportedType(e.dataType)) { |
| e.data = SelectionItem.getAsText(mCanvas, mDragSelection); |
| return; |
| } |
| |
| if (SimpleXmlTransfer.getInstance().isSupportedType(e.dataType)) { |
| e.data = mDragElements; |
| return; |
| } |
| |
| // otherwise we failed |
| e.detail = DND.DROP_NONE; |
| e.doit = false; |
| } |
| |
| /** |
| * Callback invoked when the drop has been finished either way. On a |
| * successful move, remove the originating elements. |
| */ |
| @Override |
| public void dragFinished(DragSourceEvent e) { |
| // Clear the selection |
| mDragSelection.clear(); |
| mDragElements = null; |
| GlobalCanvasDragInfo.getInstance().stopDrag(); |
| |
| finishGesture(ControlPoint.create(mCanvas, e), e.detail == DND.DROP_NONE); |
| mCanvas.showInvisibleViews(false); |
| mCanvas.redraw(); |
| } |
| } |
| } |
