bundles/org.eclipse.e4.ui.workbench.addons.swt/src/org/eclipse/e4/ui/workbench/addons/dndaddon/DnDManager.java - platform/eclipse.platform.ui - Git at Google

 /*******************************************************************************
  * Copyright (c) 2010, 2018 IBM Corporation and others.
  *
  * 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 Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.e4.ui.workbench.addons.dndaddon;

 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 import org.eclipse.e4.core.services.events.IEventBroker;
 import org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer;
 import org.eclipse.e4.ui.model.application.ui.MUIElement;
 import org.eclipse.e4.ui.model.application.ui.basic.MPartStack;
 import org.eclipse.e4.ui.model.application.ui.basic.MWindow;
 import org.eclipse.e4.ui.services.IStylingEngine;
 import org.eclipse.e4.ui.widgets.ImageBasedFrame;
 import org.eclipse.e4.ui.workbench.IPresentationEngine;
 import org.eclipse.e4.ui.workbench.UIEvents;
 import org.eclipse.e4.ui.workbench.modeling.EModelService;
 import org.eclipse.jface.util.Geometry;
 import org.eclipse.swt.SWT;
 import org.eclipse.swt.custom.CTabFolder;
 import org.eclipse.swt.custom.CTabItem;
 import org.eclipse.swt.events.DragDetectListener;
 import org.eclipse.swt.events.KeyEvent;
 import org.eclipse.swt.events.KeyListener;
 import org.eclipse.swt.graphics.Cursor;
 import org.eclipse.swt.graphics.Image;
 import org.eclipse.swt.graphics.Rectangle;
 import org.eclipse.swt.graphics.Region;
 import org.eclipse.swt.graphics.Resource;
 import org.eclipse.swt.layout.FillLayout;
 import org.eclipse.swt.widgets.Control;
 import org.eclipse.swt.widgets.Display;
 import org.eclipse.swt.widgets.Shell;
 import org.eclipse.swt.widgets.Tracker;
 import org.osgi.service.event.EventHandler;

 class DnDManager {
 	private static final Rectangle offScreenRect = new Rectangle(10000, -10000, 1, 1);

 	public static final int HOSTED = 1;
 	public static final int GHOSTED = 2;
 	public static final int SIMPLE = 3;
 	private int feedbackStyle = SIMPLE;

 	Collection<DragAgent> dragAgents = new ArrayList<>();
 	Collection<DropAgent> dropAgents = new ArrayList<>();

 	DnDInfo info;
 	DragAgent dragAgent;

 	private MWindow dragWindow;

 	private Shell dragHost;
 	private Control dragCtrl;

 	private Tracker tracker;
 	boolean dragging;

 	private Shell overlayFrame;
 	private List<Rectangle> frames = new ArrayList<>();

 	DragDetectListener dragDetector = e -> {
 		if (dragging || e.widget.isDisposed()) {
 			return;
 		}

 		info.update(e);
 		dragAgent = getDragAgent(info);
 		if (dragAgent != null) {
 			try {
 				dragging = true;
 				isModified = (e.stateMask & SWT.MOD1) != 0;
 				startDrag();
 			} finally {
 				dragging = false;
 			}
 		}
 	};

 	public void addFrame(Rectangle newRect) {
 		frames.add(newRect);
 		updateOverlay();
 	}

 	private List<Image> images = new ArrayList<>();
 	private List<Rectangle> imageRects = new ArrayList<>();

 	protected boolean isModified;

 	public void addImage(Rectangle imageRect, Image image) {
 		imageRects.add(imageRect);
 		images.add(image);
 		updateOverlay();
 	}

 	public DnDManager(MWindow topLevelWindow) {
 		dragWindow = topLevelWindow;
 		info = new DnDInfo(topLevelWindow);

 		// Dragging stacks and parts
 		dragAgents.add(new PartDragAgent(this));

 		dropAgents.add(new StackDropAgent(this));
 		dropAgents.add(new SplitDropAgent2(this));
 		dropAgents.add(new DetachedDropAgent(this));

 		// dragging trim
 		dragAgents.add(new IBFDragAgent(this));
 		dropAgents.add(new TrimDropAgent(this));

 		// Register a 'dragDetect' against any stacks that get created
 		hookWidgets();

 		getDragShell().addDisposeListener(e -> dispose());
 	}

 	/**
 	 * Do any widget specific logic hookup. We should break the model generic logic away from the
 	 * specific platform by moving this code into an SWT-specific subclass
 	 */
 	private void hookWidgets() {
 		EventHandler stackWidgetHandler = event -> {
 			MUIElement element = (MUIElement) event.getProperty(UIEvents.EventTags.ELEMENT);

 			// Only add listeners for stacks in *this* window
 			MWindow elementWin = getModelService().getTopLevelWindowFor(element);
 			if (elementWin != dragWindow) {
 				return;
 			}

 			// Listen for drags starting in CTabFolders
 			if (element.getWidget() instanceof CTabFolder || element.getWidget() instanceof ImageBasedFrame) {
 				Control ctrl = (Control) element.getWidget();

 				// Ensure there's only one drag detect listener per ctrl
 				ctrl.removeDragDetectListener(dragDetector);
 				ctrl.addDragDetectListener(dragDetector);
 			}
 		};

 		IEventBroker eventBroker = dragWindow.getContext().get(IEventBroker.class);
 		eventBroker.subscribe(UIEvents.UIElement.TOPIC_WIDGET, stackWidgetHandler);
 	}

 	public MWindow getDragWindow() {
 		return dragWindow;
 	}

 	public EModelService getModelService() {
 		return dragWindow.getContext().get(EModelService.class);
 	}

 	public Shell getDragShell() {
 		return (Shell) (dragWindow.getWidget() instanceof Shell ? dragWindow.getWidget() : null);
 	}

 	protected void dispose() {
 		clearOverlay();

 		if (overlayFrame != null && !overlayFrame.isDisposed()) {
 			overlayFrame.dispose();
 		}
 		overlayFrame = null;

 		for (DragAgent agent : dragAgents) {
 			agent.dispose();
 		}
 		for (DropAgent agent : dropAgents) {
 			agent.dispose();
 		}
 		info.curElement = null;
 		info = null;
 	}

 	private void track() {
 		Display.getCurrent().syncExec(() -> {
 			info.update();
 			dragAgent.track(info);

 			// Hack: Spin the event loop
 			update();
 		});
 	}

 	protected void startDrag() {
 		// Create a new tracker for this drag instance
 		Shell activeShell = Display.getCurrent().getActiveShell();
 		if (activeShell == null) {
 			return;
 		}

 		tracker = new Tracker(activeShell, SWT.NULL);
 		tracker.setStippled(true);
 		setRectangle(offScreenRect);

 		tracker.addKeyListener(new KeyListener() {
 			@Override
 			public void keyReleased(KeyEvent e) {
 				if (e.keyCode == SWT.MOD1) {
 					isModified = false;
 					track();
 				}
 			}

 			@Override
 			public void keyPressed(KeyEvent e) {
 				if (e.keyCode == SWT.MOD1) {
 					isModified = true;
 					track();
 				}
 			}
 		});

 		tracker.addListener(SWT.Move, event -> track());

 		// Some control needs to capture the mouse during the drag or
 		// other controls will interfere with the cursor
 		getDragShell().setCapture(true);

 		try {
 			dragAgent.dragStart(info);

 			// Run tracker until mouse up occurs or escape key pressed.
 			boolean performDrop = tracker.open();

 			// clean up
 			finishDrag(performDrop);
 		} finally {
 			getDragShell().setCursor(null);
 			getDragShell().setCapture(false);
 		}
 	}

 	public void update() {
 		Display.getCurrent().update();
 	}

 	/**
 	 * @param performDrop
 	 */
 	private void finishDrag(boolean performDrop) {
 		// Tear down any feedback
 		if (tracker != null && !tracker.isDisposed()) {
 			tracker.dispose();
 			tracker = null;
 		}

 		if (overlayFrame != null) {
 			overlayFrame.dispose();
 			overlayFrame = null;
 		}

 		if (dragHost != null) {
 			dragHost.dispose();
 			dragHost = null;
 		}

 		// Perform either drop or cancel
 		try {
 			dragAgent.dragFinished(performDrop, info);
 		} finally {
 			dragAgent = null;
 		}
 	}

 	public void setCursor(Cursor newCursor) {
 		getDragShell().setCursor(newCursor);
 	}

 	public void setRectangle(Rectangle newRect) {
 		if (tracker == null) {
 			return;
 		}

 		Rectangle[] rectArray = { Geometry.copy(newRect) };
 		tracker.setRectangles(rectArray);
 	}

 	public void hostElement(MUIElement element, int xOffset, int yOffset) {
 		if (element == null) {
 			if (dragHost != null && !dragHost.isDisposed()) {
 				dragHost.dispose();
 			}
 			dragHost = null;
 			return;
 		}

 		Shell parentShell = getDragShell();

 		dragHost = new Shell(parentShell, SWT.NO_TRIM);
 		dragHost.setBackground(parentShell.getDisplay().getSystemColor(SWT.COLOR_WHITE));
 		dragHost.setLayout(new FillLayout());
 		dragHost.setAlpha(120);
 		Region shellRgn = new Region(dragHost.getDisplay());
 		dragHost.setRegion(shellRgn);

 		dragCtrl = (Control) element.getWidget();
 		if (dragCtrl != null) {
 			dragHost.setSize(dragCtrl.getSize());
 		} else {
 			dragHost.setSize(400, 400);
 		}

 		if (feedbackStyle == HOSTED) {
 			// Special code to wrap the element in a CTF if it's coming from one
 			MUIElement elementParent = element.getParent();
 			if (elementParent instanceof MPartStack
 					&& elementParent.getWidget() instanceof CTabFolder) {
 				CTabFolder curCTF = (CTabFolder) elementParent.getWidget();
 				dragHost.setSize(curCTF.getSize());
 				CTabItem elementItem = getItemForElement(curCTF, element);
 				assert (elementItem != null);

 				IPresentationEngine renderingEngine = dragWindow.getContext().get(
 						IPresentationEngine.class);
 				CTabFolder ctf = new CTabFolder(dragHost, SWT.BORDER);
 				CTabItem newItem = new CTabItem(ctf, SWT.NONE);
 				newItem.setText(elementItem.getText());
 				newItem.setImage(elementItem.getImage());

 				element.getParent().getChildren().remove(element);
 				dragCtrl = (Control) renderingEngine.createGui(element, ctf, getModelService()
 						.getContainingContext(element));
 				newItem.setControl(dragCtrl);
 			}
 		} else if (feedbackStyle == GHOSTED) {
 			dragCtrl.setParent(dragHost);
 			dragCtrl.setLocation(0, 0);
 			dragHost.layout();
 		}

 		update();

 		// Pass the shell to the info element for tracking
 		dragHost.open();
 		info.setDragHost(dragHost, xOffset, yOffset);
 	}

 	public void setDragHostVisibility(boolean visible) {
 		if (dragHost == null || dragHost.isDisposed()) {
 			return;
 		}

 		if (visible) {
 			if (dragHost.getChildren().length > 0
 					&& dragHost.getChildren()[0] instanceof CTabFolder) {
 				CTabFolder ctf = (CTabFolder) dragHost.getChildren()[0];
 				dragCtrl.setParent(ctf);
 				dragHost.setVisible(true);
 			} else {
 				dragCtrl.setParent(dragHost);
 			}
 		} else {
 			dragHost.setVisible(false);
 		}
 	}

 	private CTabItem getItemForElement(CTabFolder elementCTF, MUIElement element) {
 		for (CTabItem item : elementCTF.getItems()) {
 			if (item.getData(AbstractPartRenderer.OWNING_ME) == element) {
 				return item;
 			}
 		}
 		return null;
 	}

 	public void clearOverlay() {
 		frames.clear();
 		images.clear();
 		imageRects.clear();

 		if (overlayFrame != null) {
 			overlayFrame.setVisible(false);
 		}
 	}

 	private void updateOverlay() {
 		Rectangle bounds = getOverlayBounds();
 		if (bounds == null) {
 			clearOverlay();
 			return;
 		}

 		if (overlayFrame == null) {
 			overlayFrame = new Shell(getDragShell(), SWT.NO_TRIM | SWT.ON_TOP);
 			overlayFrame.setData(DragAndDropUtil.IGNORE_AS_DROP_TARGET, Boolean.TRUE);
 			overlayFrame.setBackground(Display.getCurrent().getSystemColor(SWT.COLOR_DARK_GREEN));
 			overlayFrame.setAlpha(150);

 			IStylingEngine stylingEngine = dragWindow.getContext().get(IStylingEngine.class);
 			stylingEngine.setClassname(overlayFrame, "DragFeedback"); //$NON-NLS-1$
 			stylingEngine.style(overlayFrame);

 			overlayFrame.addPaintListener(e -> {
 				for (int i = 0; i < images.size(); i++) {
 					Image image = images.get(i);
 					Rectangle iRect = imageRects.get(i);
 					e.gc.drawImage(image, iRect.x, iRect.y);
 				}
 			});
 		}

 		// Reset for this set of overlays
 		overlayFrame.setBounds(bounds);

 		Region curRegion = overlayFrame.getRegion();
 		if (curRegion != null && !curRegion.isDisposed()) {
 			curRegion.dispose();
 		}

 		Region rgn = new Region();

 		// Add frames
 		for (Rectangle frameRect : frames) {
 			int x = frameRect.x - bounds.x;
 			int y = frameRect.y - bounds.y;

 			if (frameRect.width > 6) {
 				Rectangle outerBounds = new Rectangle(x - 3, y - 3, frameRect.width + 6,
 						frameRect.height + 6);
 				rgn.add(outerBounds);
 				Rectangle innerBounds = new Rectangle(x, y, frameRect.width, frameRect.height);
 				rgn.subtract(innerBounds);
 			} else {
 				Rectangle itemBounds = new Rectangle(x, y, frameRect.width, frameRect.height);
 				rgn.add(itemBounds);
 			}
 		}

 		// Add images
 		for (int i = 0; i < images.size(); i++) {
 			Rectangle ir = imageRects.get(i);
 			Image im = images.get(i);

 			int x = ir.x - bounds.x;
 			int y = ir.y - bounds.y;

 			rgn.add(x, y, im.getBounds().width, im.getBounds().height);
 		}

 		overlayFrame.setRegion(rgn);
 		// Region object needs to be disposed at the right point in time
 		addResourceDisposeListener(overlayFrame, rgn);
 		overlayFrame.setVisible(true);
 	}

 	private void addResourceDisposeListener(Control control, final Resource resource) {
 		control.addDisposeListener(e -> {
 			if (!resource.isDisposed()) {
 				resource.dispose();
 			}
 		});
 	}

 	private Rectangle getOverlayBounds() {
 		Rectangle bounds = null;
 		for (Rectangle fr : frames) {
 			if (fr.width > 6) {
 				Rectangle outerBounds = new Rectangle(fr.x - 3, fr.y - 3, fr.width + 6,
 						fr.height + 6);
 				if (bounds == null) {
 					bounds = outerBounds;
 				}
 				bounds.add(outerBounds);
 			} else {
 				if (bounds == null) {
 					bounds = fr;
 				}
 				bounds.add(fr);
 			}
 		}

 		for (Rectangle ir : imageRects) {
 			if (bounds == null) {
 				bounds = ir;
 			}
 			bounds.add(ir);
 		}

 		return bounds;
 	}

 	public void frameRect(Rectangle bounds) {
 		clearOverlay();
 		if (bounds != null) {
 			addFrame(bounds);
 		}
 	}

 	public void addDragAgent(DragAgent newAgent) {
 		if (!dragAgents.contains(newAgent)) {
 			dragAgents.add(newAgent);
 		}
 	}

 	public void removeDragAgent(DragAgent agentToRemove) {
 		dragAgents.remove(agentToRemove);
 	}

 	public void addDropAgent(DropAgent newAgent) {
 		if (!dropAgents.contains(newAgent)) {
 			dropAgents.add(newAgent);
 		}
 	}

 	public void removeDropAgent(DropAgent agentToRemove) {
 		dropAgents.remove(agentToRemove);
 	}

 	private DragAgent getDragAgent(DnDInfo info) {
 		for (DragAgent agent : dragAgents) {
 			if (agent.canDrag(info)) {
 				return agent;
 			}
 		}
 		return null;
 	}

 	public DropAgent getDropAgent(MUIElement dragElement, DnDInfo info) {
 		for (DropAgent agent : dropAgents) {
 			if (agent.canDrop(dragElement, info)) {
 				return agent;
 			}
 		}
 		return null;
 	}

 	/**
 	 * @return Return the feedback style
 	 */
 	public int getFeedbackStyle() {
 		return feedbackStyle;
 	}

 	/**
 	 * @param newBounds
 	 */
 	public void setHostBounds(Rectangle newBounds) {
 		if (dragHost == null || dragHost.isDisposed()) {
 			return;
 		}

 		info.setDragHostBounds(newBounds);
 		update();
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2010, 2018 IBM Corporation and others.
	*
	* 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 Corporation - initial API and implementation
	*******************************************************************************/
	package org.eclipse.e4.ui.workbench.addons.dndaddon;

	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.List;
	import org.eclipse.e4.core.services.events.IEventBroker;
	import org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer;
	import org.eclipse.e4.ui.model.application.ui.MUIElement;
	import org.eclipse.e4.ui.model.application.ui.basic.MPartStack;
	import org.eclipse.e4.ui.model.application.ui.basic.MWindow;
	import org.eclipse.e4.ui.services.IStylingEngine;
	import org.eclipse.e4.ui.widgets.ImageBasedFrame;
	import org.eclipse.e4.ui.workbench.IPresentationEngine;
	import org.eclipse.e4.ui.workbench.UIEvents;
	import org.eclipse.e4.ui.workbench.modeling.EModelService;
	import org.eclipse.jface.util.Geometry;
	import org.eclipse.swt.SWT;
	import org.eclipse.swt.custom.CTabFolder;
	import org.eclipse.swt.custom.CTabItem;
	import org.eclipse.swt.events.DragDetectListener;
	import org.eclipse.swt.events.KeyEvent;
	import org.eclipse.swt.events.KeyListener;
	import org.eclipse.swt.graphics.Cursor;
	import org.eclipse.swt.graphics.Image;
	import org.eclipse.swt.graphics.Rectangle;
	import org.eclipse.swt.graphics.Region;
	import org.eclipse.swt.graphics.Resource;
	import org.eclipse.swt.layout.FillLayout;
	import org.eclipse.swt.widgets.Control;
	import org.eclipse.swt.widgets.Display;
	import org.eclipse.swt.widgets.Shell;
	import org.eclipse.swt.widgets.Tracker;
	import org.osgi.service.event.EventHandler;

	class DnDManager {
	private static final Rectangle offScreenRect = new Rectangle(10000, -10000, 1, 1);

	public static final int HOSTED = 1;
	public static final int GHOSTED = 2;
	public static final int SIMPLE = 3;
	private int feedbackStyle = SIMPLE;

	Collection<DragAgent> dragAgents = new ArrayList<>();
	Collection<DropAgent> dropAgents = new ArrayList<>();

	DnDInfo info;
	DragAgent dragAgent;

	private MWindow dragWindow;

	private Shell dragHost;
	private Control dragCtrl;

	private Tracker tracker;
	boolean dragging;

	private Shell overlayFrame;
	private List<Rectangle> frames = new ArrayList<>();

	DragDetectListener dragDetector = e -> {
	if (dragging \|\| e.widget.isDisposed()) {
	return;
	}

	info.update(e);
	dragAgent = getDragAgent(info);
	if (dragAgent != null) {
	try {
	dragging = true;
	isModified = (e.stateMask & SWT.MOD1) != 0;
	startDrag();
	} finally {
	dragging = false;
	}
	}
	};

	public void addFrame(Rectangle newRect) {
	frames.add(newRect);
	updateOverlay();
	}

	private List<Image> images = new ArrayList<>();
	private List<Rectangle> imageRects = new ArrayList<>();

	protected boolean isModified;

	public void addImage(Rectangle imageRect, Image image) {
	imageRects.add(imageRect);
	images.add(image);
	updateOverlay();
	}

	public DnDManager(MWindow topLevelWindow) {
	dragWindow = topLevelWindow;
	info = new DnDInfo(topLevelWindow);

	// Dragging stacks and parts
	dragAgents.add(new PartDragAgent(this));

	dropAgents.add(new StackDropAgent(this));
	dropAgents.add(new SplitDropAgent2(this));
	dropAgents.add(new DetachedDropAgent(this));

	// dragging trim
	dragAgents.add(new IBFDragAgent(this));
	dropAgents.add(new TrimDropAgent(this));

	// Register a 'dragDetect' against any stacks that get created
	hookWidgets();

	getDragShell().addDisposeListener(e -> dispose());
	}

	/**
	* Do any widget specific logic hookup. We should break the model generic logic away from the
	* specific platform by moving this code into an SWT-specific subclass
	*/
	private void hookWidgets() {
	EventHandler stackWidgetHandler = event -> {
	MUIElement element = (MUIElement) event.getProperty(UIEvents.EventTags.ELEMENT);

	// Only add listeners for stacks in this window
	MWindow elementWin = getModelService().getTopLevelWindowFor(element);
	if (elementWin != dragWindow) {
	return;
	}

	// Listen for drags starting in CTabFolders
	if (element.getWidget() instanceof CTabFolder \|\| element.getWidget() instanceof ImageBasedFrame) {
	Control ctrl = (Control) element.getWidget();

	// Ensure there's only one drag detect listener per ctrl
	ctrl.removeDragDetectListener(dragDetector);
	ctrl.addDragDetectListener(dragDetector);
	}
	};

	IEventBroker eventBroker = dragWindow.getContext().get(IEventBroker.class);
	eventBroker.subscribe(UIEvents.UIElement.TOPIC_WIDGET, stackWidgetHandler);
	}

	public MWindow getDragWindow() {
	return dragWindow;
	}

	public EModelService getModelService() {
	return dragWindow.getContext().get(EModelService.class);
	}

	public Shell getDragShell() {
	return (Shell) (dragWindow.getWidget() instanceof Shell ? dragWindow.getWidget() : null);
	}

	protected void dispose() {
	clearOverlay();

	if (overlayFrame != null && !overlayFrame.isDisposed()) {
	overlayFrame.dispose();
	}
	overlayFrame = null;

	for (DragAgent agent : dragAgents) {
	agent.dispose();
	}
	for (DropAgent agent : dropAgents) {
	agent.dispose();
	}
	info.curElement = null;
	info = null;
	}

	private void track() {
	Display.getCurrent().syncExec(() -> {
	info.update();
	dragAgent.track(info);

	// Hack: Spin the event loop
	update();
	});
	}

	protected void startDrag() {
	// Create a new tracker for this drag instance
	Shell activeShell = Display.getCurrent().getActiveShell();
	if (activeShell == null) {
	return;
	}

	tracker = new Tracker(activeShell, SWT.NULL);
	tracker.setStippled(true);
	setRectangle(offScreenRect);

	tracker.addKeyListener(new KeyListener() {
	@Override
	public void keyReleased(KeyEvent e) {
	if (e.keyCode == SWT.MOD1) {
	isModified = false;
	track();
	}
	}

	@Override
	public void keyPressed(KeyEvent e) {
	if (e.keyCode == SWT.MOD1) {
	isModified = true;
	track();
	}
	}
	});

	tracker.addListener(SWT.Move, event -> track());

	// Some control needs to capture the mouse during the drag or
	// other controls will interfere with the cursor
	getDragShell().setCapture(true);

	try {
	dragAgent.dragStart(info);

	// Run tracker until mouse up occurs or escape key pressed.
	boolean performDrop = tracker.open();

	// clean up
	finishDrag(performDrop);
	} finally {
	getDragShell().setCursor(null);
	getDragShell().setCapture(false);
	}
	}

	public void update() {
	Display.getCurrent().update();
	}

	/**
	* @param performDrop
	*/
	private void finishDrag(boolean performDrop) {
	// Tear down any feedback
	if (tracker != null && !tracker.isDisposed()) {
	tracker.dispose();
	tracker = null;
	}

	if (overlayFrame != null) {
	overlayFrame.dispose();
	overlayFrame = null;
	}

	if (dragHost != null) {
	dragHost.dispose();
	dragHost = null;
	}

	// Perform either drop or cancel
	try {
	dragAgent.dragFinished(performDrop, info);
	} finally {
	dragAgent = null;
	}
	}

	public void setCursor(Cursor newCursor) {
	getDragShell().setCursor(newCursor);
	}

	public void setRectangle(Rectangle newRect) {
	if (tracker == null) {
	return;
	}

	Rectangle[] rectArray = { Geometry.copy(newRect) };
	tracker.setRectangles(rectArray);
	}

	public void hostElement(MUIElement element, int xOffset, int yOffset) {
	if (element == null) {
	if (dragHost != null && !dragHost.isDisposed()) {
	dragHost.dispose();
	}
	dragHost = null;
	return;
	}

	Shell parentShell = getDragShell();

	dragHost = new Shell(parentShell, SWT.NO_TRIM);
	dragHost.setBackground(parentShell.getDisplay().getSystemColor(SWT.COLOR_WHITE));
	dragHost.setLayout(new FillLayout());
	dragHost.setAlpha(120);
	Region shellRgn = new Region(dragHost.getDisplay());
	dragHost.setRegion(shellRgn);

	dragCtrl = (Control) element.getWidget();
	if (dragCtrl != null) {
	dragHost.setSize(dragCtrl.getSize());
	} else {
	dragHost.setSize(400, 400);
	}

	if (feedbackStyle == HOSTED) {
	// Special code to wrap the element in a CTF if it's coming from one
	MUIElement elementParent = element.getParent();
	if (elementParent instanceof MPartStack
	&& elementParent.getWidget() instanceof CTabFolder) {
	CTabFolder curCTF = (CTabFolder) elementParent.getWidget();
	dragHost.setSize(curCTF.getSize());
	CTabItem elementItem = getItemForElement(curCTF, element);
	assert (elementItem != null);

	IPresentationEngine renderingEngine = dragWindow.getContext().get(
	IPresentationEngine.class);
	CTabFolder ctf = new CTabFolder(dragHost, SWT.BORDER);
	CTabItem newItem = new CTabItem(ctf, SWT.NONE);
	newItem.setText(elementItem.getText());
	newItem.setImage(elementItem.getImage());

	element.getParent().getChildren().remove(element);
	dragCtrl = (Control) renderingEngine.createGui(element, ctf, getModelService()
	.getContainingContext(element));
	newItem.setControl(dragCtrl);
	}
	} else if (feedbackStyle == GHOSTED) {
	dragCtrl.setParent(dragHost);
	dragCtrl.setLocation(0, 0);
	dragHost.layout();
	}

	update();

	// Pass the shell to the info element for tracking
	dragHost.open();
	info.setDragHost(dragHost, xOffset, yOffset);
	}

	public void setDragHostVisibility(boolean visible) {
	if (dragHost == null \|\| dragHost.isDisposed()) {
	return;
	}

	if (visible) {
	if (dragHost.getChildren().length > 0
	&& dragHost.getChildren()[0] instanceof CTabFolder) {
	CTabFolder ctf = (CTabFolder) dragHost.getChildren()[0];
	dragCtrl.setParent(ctf);
	dragHost.setVisible(true);
	} else {
	dragCtrl.setParent(dragHost);
	}
	} else {
	dragHost.setVisible(false);
	}
	}

	private CTabItem getItemForElement(CTabFolder elementCTF, MUIElement element) {
	for (CTabItem item : elementCTF.getItems()) {
	if (item.getData(AbstractPartRenderer.OWNING_ME) == element) {
	return item;
	}
	}
	return null;
	}

	public void clearOverlay() {
	frames.clear();
	images.clear();
	imageRects.clear();

	if (overlayFrame != null) {
	overlayFrame.setVisible(false);
	}
	}

	private void updateOverlay() {
	Rectangle bounds = getOverlayBounds();
	if (bounds == null) {
	clearOverlay();
	return;
	}

	if (overlayFrame == null) {
	overlayFrame = new Shell(getDragShell(), SWT.NO_TRIM \| SWT.ON_TOP);
	overlayFrame.setData(DragAndDropUtil.IGNORE_AS_DROP_TARGET, Boolean.TRUE);
	overlayFrame.setBackground(Display.getCurrent().getSystemColor(SWT.COLOR_DARK_GREEN));
	overlayFrame.setAlpha(150);

	IStylingEngine stylingEngine = dragWindow.getContext().get(IStylingEngine.class);
	stylingEngine.setClassname(overlayFrame, "DragFeedback"); //$NON-NLS-1$
	stylingEngine.style(overlayFrame);

	overlayFrame.addPaintListener(e -> {
	for (int i = 0; i < images.size(); i++) {
	Image image = images.get(i);
	Rectangle iRect = imageRects.get(i);
	e.gc.drawImage(image, iRect.x, iRect.y);
	}
	});
	}

	// Reset for this set of overlays
	overlayFrame.setBounds(bounds);

	Region curRegion = overlayFrame.getRegion();
	if (curRegion != null && !curRegion.isDisposed()) {
	curRegion.dispose();
	}

	Region rgn = new Region();

	// Add frames
	for (Rectangle frameRect : frames) {
	int x = frameRect.x - bounds.x;
	int y = frameRect.y - bounds.y;

	if (frameRect.width > 6) {
	Rectangle outerBounds = new Rectangle(x - 3, y - 3, frameRect.width + 6,
	frameRect.height + 6);
	rgn.add(outerBounds);
	Rectangle innerBounds = new Rectangle(x, y, frameRect.width, frameRect.height);
	rgn.subtract(innerBounds);
	} else {
	Rectangle itemBounds = new Rectangle(x, y, frameRect.width, frameRect.height);
	rgn.add(itemBounds);
	}
	}

	// Add images
	for (int i = 0; i < images.size(); i++) {
	Rectangle ir = imageRects.get(i);
	Image im = images.get(i);

	int x = ir.x - bounds.x;
	int y = ir.y - bounds.y;

	rgn.add(x, y, im.getBounds().width, im.getBounds().height);
	}

	overlayFrame.setRegion(rgn);
	// Region object needs to be disposed at the right point in time
	addResourceDisposeListener(overlayFrame, rgn);
	overlayFrame.setVisible(true);
	}

	private void addResourceDisposeListener(Control control, final Resource resource) {
	control.addDisposeListener(e -> {
	if (!resource.isDisposed()) {
	resource.dispose();
	}
	});
	}

	private Rectangle getOverlayBounds() {
	Rectangle bounds = null;
	for (Rectangle fr : frames) {
	if (fr.width > 6) {
	Rectangle outerBounds = new Rectangle(fr.x - 3, fr.y - 3, fr.width + 6,
	fr.height + 6);
	if (bounds == null) {
	bounds = outerBounds;
	}
	bounds.add(outerBounds);
	} else {
	if (bounds == null) {
	bounds = fr;
	}
	bounds.add(fr);
	}
	}

	for (Rectangle ir : imageRects) {
	if (bounds == null) {
	bounds = ir;
	}
	bounds.add(ir);
	}

	return bounds;
	}

	public void frameRect(Rectangle bounds) {
	clearOverlay();
	if (bounds != null) {
	addFrame(bounds);
	}
	}

	public void addDragAgent(DragAgent newAgent) {
	if (!dragAgents.contains(newAgent)) {
	dragAgents.add(newAgent);
	}
	}

	public void removeDragAgent(DragAgent agentToRemove) {
	dragAgents.remove(agentToRemove);
	}

	public void addDropAgent(DropAgent newAgent) {
	if (!dropAgents.contains(newAgent)) {
	dropAgents.add(newAgent);
	}
	}

	public void removeDropAgent(DropAgent agentToRemove) {
	dropAgents.remove(agentToRemove);
	}

	private DragAgent getDragAgent(DnDInfo info) {
	for (DragAgent agent : dragAgents) {
	if (agent.canDrag(info)) {
	return agent;
	}
	}
	return null;
	}

	public DropAgent getDropAgent(MUIElement dragElement, DnDInfo info) {
	for (DropAgent agent : dropAgents) {
	if (agent.canDrop(dragElement, info)) {
	return agent;
	}
	}
	return null;
	}

	/**
	* @return Return the feedback style
	*/
	public int getFeedbackStyle() {
	return feedbackStyle;
	}

	/**
	* @param newBounds
	*/
	public void setHostBounds(Rectangle newBounds) {
	if (dragHost == null \|\| dragHost.isDisposed()) {
	return;
	}

	info.setDragHostBounds(newBounds);
	update();
	}
	}