Attachment 74682 Details for Bug 101993 – fix

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

[patch] fix

fix_101993.txt (text/plain), 82.88 KB, created by Benno Baumgartner

on 2007-07-26 08:55:30 EDT

(hide)

Description:

Filename:

MIME Type:

Creator: Benno Baumgartner

Created: 2007-07-26 08:55:30 EDT

Size: 82.88 KB

patch

obsolete

>### Eclipse Workspace Patch 1.0
>#P org.eclipse.jdt.ui
>Index: ui/org/eclipse/jdt/internal/ui/javaeditor/JavaOutlinePage.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javaeditor/JavaOutlinePage.java,v
>retrieving revision 1.203
>diff -u -r1.203 JavaOutlinePage.java
>--- ui/org/eclipse/jdt/internal/ui/javaeditor/JavaOutlinePage.java	26 Apr 2007 16:19:03 -0000	1.203
>+++ ui/org/eclipse/jdt/internal/ui/javaeditor/JavaOutlinePage.java	26 Jul 2007 12:27:14 -0000
>@@ -43,10 +43,9 @@
> import org.eclipse.jface.action.MenuManager;
> import org.eclipse.jface.action.Separator;
> import org.eclipse.jface.preference.IPreferenceStore;
>+import org.eclipse.jface.util.DelegatingDropAdapter;
> import org.eclipse.jface.util.IPropertyChangeListener;
> import org.eclipse.jface.util.PropertyChangeEvent;
>-import org.eclipse.jface.util.TransferDragSourceListener;
>-import org.eclipse.jface.util.TransferDropTargetListener;
> import org.eclipse.jface.viewers.IBaseLabelProvider;
> import org.eclipse.jface.viewers.IPostSelectionProvider;
> import org.eclipse.jface.viewers.ISelection;
>@@ -121,7 +120,6 @@
> import org.eclipse.jdt.internal.ui.actions.AbstractToggleLinkingAction;
> import org.eclipse.jdt.internal.ui.actions.CategoryFilterActionGroup;
> import org.eclipse.jdt.internal.ui.actions.CompositeActionGroup;
>-import org.eclipse.jdt.internal.ui.dnd.DelegatingDropAdapter;
> import org.eclipse.jdt.internal.ui.dnd.JdtViewerDragAdapter;
> import org.eclipse.jdt.internal.ui.packageview.SelectionTransferDragAdapter;
> import org.eclipse.jdt.internal.ui.packageview.SelectionTransferDropAdapter;
>@@ -1348,16 +1346,18 @@
> 			};
> 
> 		// Drop Adapter
>-		TransferDropTargetListener[] dropListeners= new TransferDropTargetListener[] {
>-			new SelectionTransferDropAdapter(fOutlineViewer)
>-		};
>-		fOutlineViewer.addDropSupport(ops | DND.DROP_DEFAULT, transfers, new DelegatingDropAdapter(dropListeners));
>+		DelegatingDropAdapter delegatingDropAdapter= new DelegatingDropAdapter();
>+		delegatingDropAdapter.addDropTargetListener(
>+			new SelectionTransferDropAdapter(fOutlineViewer)			
>+		);
>+		fOutlineViewer.addDropSupport(ops | DND.DROP_DEFAULT, transfers, delegatingDropAdapter);
> 
> 		// Drag Adapter
>-		TransferDragSourceListener[] dragListeners= new TransferDragSourceListener[] {
>+		JdtViewerDragAdapter dragAdapter= new JdtViewerDragAdapter(fOutlineViewer);
>+		dragAdapter.addDragSourceListener(
> 			new SelectionTransferDragAdapter(fOutlineViewer)
>-		};
>-		fOutlineViewer.addDragSupport(ops, transfers, new JdtViewerDragAdapter(fOutlineViewer, dragListeners));
>+		);
>+		fOutlineViewer.addDragSupport(ops, transfers, dragAdapter);
> 	}
> 	
> 	/**
>Index: ui/org/eclipse/jdt/internal/ui/packageview/FileTransferDropAdapter.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/FileTransferDropAdapter.java,v
>retrieving revision 1.29
>diff -u -r1.29 FileTransferDropAdapter.java
>--- ui/org/eclipse/jdt/internal/ui/packageview/FileTransferDropAdapter.java	11 Sep 2005 10:40:56 -0000	1.29
>+++ ui/org/eclipse/jdt/internal/ui/packageview/FileTransferDropAdapter.java	26 Jul 2007 12:27:14 -0000
>@@ -17,6 +17,7 @@
> import org.eclipse.swt.dnd.DropTargetEvent;
> import org.eclipse.swt.dnd.FileTransfer;
> import org.eclipse.swt.dnd.Transfer;
>+import org.eclipse.swt.dnd.TransferData;
> import org.eclipse.swt.widgets.Display;
> import org.eclipse.swt.widgets.Shell;
> 
>@@ -42,15 +43,25 @@
> class FileTransferDropAdapter extends JdtViewerDropAdapter implements TransferDropTargetListener {
> 	
> 	FileTransferDropAdapter(AbstractTreeViewer viewer) {
>-		super(viewer, DND.FEEDBACK_SCROLL | DND.FEEDBACK_EXPAND);
>+		super(viewer);
>+		
>+		setScrollEnabled(true);
>+		setExpandEnabled(true);
>+		setFeedbackEnabled(false);
> 	}
> 
> 	//---- TransferDropTargetListener interface ---------------------------------------
> 	
>+	/**
>+	 * {@inheritDoc}
>+	 */
> 	public Transfer getTransfer() {
> 		return FileTransfer.getInstance();
> 	}
> 	
>+	/**
>+	 * {@inheritDoc}
>+	 */
> 	public boolean isEnabled(DropTargetEvent event) {
> 		Object target= event.item != null ? event.item.getData() : null;
> 		if (target == null)
>@@ -60,43 +71,46 @@
> 
> 	//---- Actual DND -----------------------------------------------------------------
> 	
>-	public void validateDrop(Object target, DropTargetEvent event, int operation) {
>-		event.detail= DND.DROP_NONE;
>-		
>+	/**
>+	 * {@inheritDoc}
>+	 */
>+	public int validateDrop(Object target, int operation, TransferData transferType) {
>+	
> 		boolean isPackageFragment= target instanceof IPackageFragment;
> 		boolean isJavaProject= target instanceof IJavaProject;
> 		boolean isPackageFragmentRoot= target instanceof IPackageFragmentRoot;
> 		boolean isContainer= target instanceof IContainer;
> 		
> 		if (!(isPackageFragment || isJavaProject || isPackageFragmentRoot || isContainer)) 
>-			return;
>+			return DND.DROP_NONE;
> 			
> 		if (isContainer) {
> 			IContainer container= (IContainer)target;
> 			if (container.isAccessible() && !Resources.isReadOnly(container))
>-				event.detail= DND.DROP_COPY;
>+				return DND.DROP_COPY;
> 		} else {
> 			IJavaElement element= (IJavaElement)target;
> 			if (!element.isReadOnly()) 
>-				event.detail= DND.DROP_COPY;
>+				return DND.DROP_COPY;
> 		}
> 			
>-		return;	
>+		return DND.DROP_NONE;	
> 	}
> 
>-	public void drop(Object dropTarget, final DropTargetEvent event) {
>+	/**
>+	 * {@inheritDoc}
>+	 */
>+	public int performDrop(final Object data) {
> 		try {
>-			int operation= event.detail;
>+			int operation= getCurrentOperation();
> 
>-			event.detail= DND.DROP_NONE;
>-			final Object data= event.data;
> 			if (data == null || !(data instanceof String[]) || operation != DND.DROP_COPY)
>-				return;
>+				return DND.DROP_NONE;
> 
>-			final IContainer target= getActualTarget(dropTarget);
>+			final IContainer target= getActualTarget(getCurrentTarget());
> 			if (target == null)
>-				return;
>-
>+				return DND.DROP_NONE;
>+			
> 			// Run the import operation asynchronously. 
> 			// Otherwise the drag source (e.g., Windows Explorer) will be blocked 
> 			// while the operation executes. Fixes bug 35796.
>@@ -104,15 +118,17 @@
> 				public void run() {
> 					getShell().forceActive();
> 					new CopyFilesAndFoldersOperation(getShell()).copyFiles((String[]) data, target);
>-					// Import always performs a copy.
>-					event.detail= DND.DROP_COPY;
> 				}
> 			});
>+			
>+			return DND.DROP_COPY;
> 		} catch (JavaModelException e) {
> 			String title= PackagesMessages.DropAdapter_errorTitle; 
> 			String message= PackagesMessages.DropAdapter_errorMessage; 
> 			ExceptionHandler.handle(e, getShell(), title, message);
> 		}
>+		
>+		return DND.DROP_NONE;
> 	}
> 	
> 	private IContainer getActualTarget(Object dropTarget) throws JavaModelException{
>Index: ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java,v
>retrieving revision 1.301
>diff -u -r1.301 PackageExplorerPart.java
>--- ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java	23 May 2007 14:30:44 -0000	1.301
>+++ ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java	26 Jul 2007 12:27:14 -0000
>@@ -55,10 +55,9 @@
> import org.eclipse.jface.dialogs.IDialogSettings;
> import org.eclipse.jface.dialogs.MessageDialog;
> import org.eclipse.jface.preference.IPreferenceStore;
>+import org.eclipse.jface.util.DelegatingDropAdapter;
> import org.eclipse.jface.util.IPropertyChangeListener;
> import org.eclipse.jface.util.PropertyChangeEvent;
>-import org.eclipse.jface.util.TransferDragSourceListener;
>-import org.eclipse.jface.util.TransferDropTargetListener;
> import org.eclipse.jface.viewers.AbstractTreeViewer;
> import org.eclipse.jface.viewers.DoubleClickEvent;
> import org.eclipse.jface.viewers.IContentProvider;
>@@ -137,7 +136,6 @@
> 
> import org.eclipse.jdt.internal.ui.IJavaHelpContextIds;
> import org.eclipse.jdt.internal.ui.JavaPlugin;
>-import org.eclipse.jdt.internal.ui.dnd.DelegatingDropAdapter;
> import org.eclipse.jdt.internal.ui.dnd.JdtViewerDragAdapter;
> import org.eclipse.jdt.internal.ui.dnd.ResourceTransferDragAdapter;
> import org.eclipse.jdt.internal.ui.filters.OutputFolderFilter;
>@@ -893,12 +891,18 @@
> 			LocalSelectionTransfer.getInstance(), 
> 			ResourceTransfer.getInstance(),
> 			FileTransfer.getInstance()};
>-		TransferDragSourceListener[] dragListeners= new TransferDragSourceListener[] {
>-			new SelectionTransferDragAdapter(fViewer),
>-			new ResourceTransferDragAdapter(fViewer),
>+
>+		JdtViewerDragAdapter dragAdapter= new JdtViewerDragAdapter(fViewer);
>+		dragAdapter.addDragSourceListener(
>+			new SelectionTransferDragAdapter(fViewer)
>+		);
>+		dragAdapter.addDragSourceListener(
>+			new ResourceTransferDragAdapter(fViewer)
>+		);
>+		dragAdapter.addDragSourceListener(
> 			new FileTransferDragAdapter(fViewer)
>-		};
>-		fViewer.addDragSupport(ops, transfers, new JdtViewerDragAdapter(fViewer, dragListeners));
>+		);
>+		fViewer.addDragSupport(ops, transfers, dragAdapter);
> 	}
> 
> 	private void initDrop() {
>@@ -906,12 +910,17 @@
> 		Transfer[] transfers= new Transfer[] {
> 			LocalSelectionTransfer.getInstance(), 
> 			FileTransfer.getInstance()};
>-		TransferDropTargetListener[] dropListeners= new TransferDropTargetListener[] {
>-			new SelectionTransferDropAdapter(fViewer),
>-			new FileTransferDropAdapter(fViewer),
>+		DelegatingDropAdapter delegatingDropAdapter= new DelegatingDropAdapter();
>+		delegatingDropAdapter.addDropTargetListener(
>+			new SelectionTransferDropAdapter(fViewer)
>+		);
>+		delegatingDropAdapter.addDropTargetListener(
>+			new FileTransferDropAdapter(fViewer)
>+		);
>+		delegatingDropAdapter.addDropTargetListener(	
> 			new WorkingSetDropAdapter(this)
>-		};
>-		fViewer.addDropSupport(ops, transfers, new DelegatingDropAdapter(dropListeners));
>+		);
>+		fViewer.addDropSupport(ops, transfers, delegatingDropAdapter);
> 	}
> 
> 	/**
>Index: ui/org/eclipse/jdt/internal/ui/packageview/SelectionTransferDropAdapter.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/SelectionTransferDropAdapter.java,v
>retrieving revision 1.61
>diff -u -r1.61 SelectionTransferDropAdapter.java
>--- ui/org/eclipse/jdt/internal/ui/packageview/SelectionTransferDropAdapter.java	19 Jun 2006 15:17:15 -0000	1.61
>+++ ui/org/eclipse/jdt/internal/ui/packageview/SelectionTransferDropAdapter.java	26 Jul 2007 12:27:14 -0000
>@@ -18,6 +18,7 @@
> import org.eclipse.swt.dnd.DND;
> import org.eclipse.swt.dnd.DropTargetEvent;
> import org.eclipse.swt.dnd.Transfer;
>+import org.eclipse.swt.dnd.TransferData;
> import org.eclipse.swt.widgets.Shell;
> 
> import org.eclipse.jface.util.TransferDropTargetListener;
>@@ -52,18 +53,26 @@
> 	private int fCanCopyElements;
> 	private ISelection fSelection;
> 
>-	private static final long DROP_TIME_DIFF_TRESHOLD= 150;
>-
> 	public SelectionTransferDropAdapter(StructuredViewer viewer) {
>-		super(viewer, DND.FEEDBACK_SCROLL | DND.FEEDBACK_EXPAND);
>+		super(viewer);
>+		
>+		setScrollEnabled(true);
>+		setExpandEnabled(true);
>+		setFeedbackEnabled(false);
> 	}
> 
> 	//---- TransferDropTargetListener interface ---------------------------------------
> 	
>+	/**
>+	 * {@inheritDoc}
>+	 */
> 	public Transfer getTransfer() {
> 		return LocalSelectionTransfer.getInstance();
> 	}
> 	
>+	/**
>+	 * {@inheritDoc}
>+	 */
> 	public boolean isEnabled(DropTargetEvent event) {
> 		Object target= event.item != null ? event.item.getData() : null;
> 		if (target == null)
>@@ -73,11 +82,17 @@
> 
> 	//---- Actual DND -----------------------------------------------------------------
> 	
>+	/**
>+	 * {@inheritDoc}
>+	 */
> 	public void dragEnter(DropTargetEvent event) {
> 		clear();
> 		super.dragEnter(event);
> 	}
> 	
>+	/**
>+	 * {@inheritDoc}
>+	 */
> 	public void dragLeave(DropTargetEvent event) {
> 		clear();
> 		super.dragLeave(event);
>@@ -92,24 +107,42 @@
> 		fCanCopyElements= 0;
> 	}
> 	
>-	public void validateDrop(Object target, DropTargetEvent event, int operation) {
>-		event.detail= DND.DROP_NONE;
>-		
>-		if (tooFast(event)) 
>-			return;
>+	/**
>+	 * {@inheritDoc}
>+	 */
>+	public int validateDrop(Object target, int operation, TransferData transferType) {
> 		
> 		initializeSelection();
>+		
>+		if (target == null)
>+			return DND.DROP_NONE;
>+		
>+		//Do not allow to drop on itself, bug 14228
>+		if (fElements.size() == 1) {
>+			IJavaElement[] javaElements= ReorgUtils.getJavaElements(fElements);
>+			IResource[] resources= ReorgUtils.getResources(fElements);
>+			
>+			if (javaElements.length == 1 && javaElements[0].equals(target))
>+				return DND.DROP_NONE;
>+			
>+			if (resources.length == 1 && resources[0].equals(target))
>+				return DND.DROP_NONE;
>+		}
> 				
> 		try {
> 			switch(operation) {
>-				case DND.DROP_DEFAULT:	event.detail= handleValidateDefault(target, event); break;
>-				case DND.DROP_COPY: 	event.detail= handleValidateCopy(target, event); break;
>-				case DND.DROP_MOVE: 	event.detail= handleValidateMove(target, event); break;
>+				case DND.DROP_DEFAULT:
>+					return handleValidateDefault(target);
>+				case DND.DROP_COPY: 
>+					return handleValidateCopy(target);
>+				case DND.DROP_MOVE: 	
>+					return handleValidateMove(target);
> 			}
> 		} catch (JavaModelException e){
> 			ExceptionHandler.handle(e, PackagesMessages.SelectionTransferDropAdapter_error_title, PackagesMessages.SelectionTransferDropAdapter_error_message); 
>-			event.detail= DND.DROP_NONE;
>-		}	
>+		}
>+		
>+		return DND.DROP_NONE;
> 	}
> 
> 	protected void initializeSelection(){
>@@ -125,16 +158,15 @@
> 	protected ISelection getSelection(){
> 		return fSelection;
> 	}
>-	
>-	private boolean tooFast(DropTargetEvent event) {
>-		return Math.abs(LocalSelectionTransfer.getInstance().getSelectionSetTime() - (event.time & 0xFFFFFFFFL)) < DROP_TIME_DIFF_TRESHOLD;
>-	}	
> 
>-	public void drop(Object target, DropTargetEvent event) {
>+	/**
>+	 * {@inheritDoc}
>+	 */
>+	public int performDrop(Object data) {
> 		try{
>-			switch(event.detail) {
>-				case DND.DROP_MOVE: handleDropMove(target, event); break;
>-				case DND.DROP_COPY: handleDropCopy(target, event); break;
>+			switch(getCurrentOperation()) {
>+				case DND.DROP_MOVE: handleDropMove(getCurrentTarget()); break;
>+				case DND.DROP_COPY: handleDropCopy(getCurrentTarget()); break;
> 			}
> 		} catch (JavaModelException e){
> 			ExceptionHandler.handle(e, PackagesMessages.SelectionTransferDropAdapter_error_title, PackagesMessages.SelectionTransferDropAdapter_error_message); 
>@@ -142,31 +174,23 @@
> 			ExceptionHandler.handle(e, RefactoringMessages.OpenRefactoringWizardAction_refactoring, RefactoringMessages.OpenRefactoringWizardAction_exception); 
> 		} catch (InterruptedException e) {
> 			//ok
>-		} finally {
>-			// The drag source listener must not perform any operation
>-			// since this drop adapter did the remove of the source even
>-			// if we moved something.
>-			event.detail= DND.DROP_NONE;
> 		}
>+		// The drag source listener must not perform any operation
>+		// since this drop adapter did the remove of the source even
>+		// if we moved something.
>+		return DND.DROP_NONE;
>+		
> 	}
> 	
>-	private int handleValidateDefault(Object target, DropTargetEvent event) throws JavaModelException{
>-		if (target == null)
>-			return DND.DROP_NONE;
>-		
>-		if ((event.operations & DND.DROP_MOVE) != 0) {
>-			return handleValidateMove(target, event);
>-		}
>-		if ((event.operations & DND.DROP_COPY) != 0) {
>-			return handleValidateCopy(target, event);
>-		}
>-		return DND.DROP_NONE;
>+	private int handleValidateDefault(Object target) throws JavaModelException{
>+		int result= handleValidateMove(target);
>+		if (result != DND.DROP_NONE)
>+			return result;
>+			
>+		return handleValidateCopy(target);
> 	}
> 	
>-	private int handleValidateMove(Object target, DropTargetEvent event) throws JavaModelException{
>-		if (target == null)
>-			return DND.DROP_NONE;
>-		
>+	private int handleValidateMove(Object target) throws JavaModelException{		
> 		if (fMoveProcessor == null) {
> 			IMovePolicy policy= ReorgPolicyFactory.createMovePolicy(ReorgUtils.getResources(fElements), ReorgUtils.getJavaElements(fElements));
> 			if (policy.canEnable())
>@@ -193,7 +217,7 @@
> 		return fCanMoveElements == 2;
> 	}
> 
>-	private void handleDropMove(final Object target, DropTargetEvent event) throws JavaModelException, InvocationTargetException, InterruptedException{
>+	private void handleDropMove(final Object target) throws JavaModelException, InvocationTargetException, InterruptedException{
> 		IJavaElement[] javaElements= ReorgUtils.getJavaElements(fElements);
> 		IResource[] resources= ReorgUtils.getResources(fElements);
> 		ReorgMoveStarter starter= null;
>@@ -205,7 +229,7 @@
> 			starter.run(getShell());
> 	}
> 
>-	private int handleValidateCopy(Object target, DropTargetEvent event) throws JavaModelException{
>+	private int handleValidateCopy(Object target) throws JavaModelException{
> 
> 		if (fCopyProcessor == null) {
> 			final ICopyPolicy policy= ReorgPolicyFactory.createCopyPolicy(ReorgUtils.getResources(fElements), ReorgUtils.getJavaElements(fElements));
>@@ -232,7 +256,7 @@
> 		return fCanCopyElements == 2;
> 	}		
> 	
>-	private void handleDropCopy(final Object target, DropTargetEvent event) throws JavaModelException, InvocationTargetException, InterruptedException{
>+	private void handleDropCopy(final Object target) throws JavaModelException, InvocationTargetException, InterruptedException{
> 		IJavaElement[] javaElements= ReorgUtils.getJavaElements(fElements);
> 		IResource[] resources= ReorgUtils.getResources(fElements);
> 		ReorgCopyStarter starter= null;
>Index: ui/org/eclipse/jdt/internal/ui/packageview/WorkingSetDropAdapter.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/WorkingSetDropAdapter.java,v
>retrieving revision 1.7
>diff -u -r1.7 WorkingSetDropAdapter.java
>--- ui/org/eclipse/jdt/internal/ui/packageview/WorkingSetDropAdapter.java	28 Mar 2006 16:53:30 -0000	1.7
>+++ ui/org/eclipse/jdt/internal/ui/packageview/WorkingSetDropAdapter.java	26 Jul 2007 12:27:14 -0000
>@@ -26,6 +26,7 @@
> import org.eclipse.swt.dnd.DND;
> import org.eclipse.swt.dnd.DropTargetEvent;
> import org.eclipse.swt.dnd.Transfer;
>+import org.eclipse.swt.dnd.TransferData;
> 
> import org.eclipse.jface.util.TransferDropTargetListener;
> import org.eclipse.jface.viewers.ISelection;
>@@ -55,16 +56,26 @@
> 	private IWorkingSet fWorkingSet;
> 
> 	public WorkingSetDropAdapter(PackageExplorerPart part) {
>-		super(part.getTreeViewer(), DND.FEEDBACK_SCROLL | DND.FEEDBACK_EXPAND);
>+		super(part.getTreeViewer());
> 		fPackageExplorer= part;
>+		
>+		setScrollEnabled(true);
>+		setExpandEnabled(true);
>+		setFeedbackEnabled(false);
> 	}
> 
> 	//---- TransferDropTargetListener interface ---------------------------------------
> 	
>+	/**
>+	 * {@inheritDoc}
>+	 */
> 	public Transfer getTransfer() {
> 		return LocalSelectionTransfer.getInstance();
> 	}
> 	
>+	/**
>+	 * {@inheritDoc}
>+	 */
> 	public boolean isEnabled(DropTargetEvent event) {
> 		Object target= event.item != null ? event.item.getData() : null;
> 		if (target == null)
>@@ -82,23 +93,25 @@
> 
> 	//---- Actual DND -----------------------------------------------------------------
> 	
>-	public void validateDrop(Object target, DropTargetEvent event, int operation) {
>-		event.detail= DND.DROP_NONE;
>+	/**
>+	 * {@inheritDoc}
>+	 */
>+	public int validateDrop(Object target, int operation, TransferData transferType) {
> 		switch(operation) {
> 			case DND.DROP_DEFAULT:
> 			case DND.DROP_COPY:
> 			case DND.DROP_MOVE:
>-				event.detail= validateTarget(target, operation); 
>-				break;
>-			case DND.DROP_LINK:
>-				event.detail= DND.DROP_NONE; 
>-				break;
>+				return validateTarget(target, operation);
>+			default:
>+				return DND.DROP_NONE;
> 		}
>+		
> 	}
> 	
> 	private int validateTarget(Object target, int operation) {
>-		showInsertionFeedback(false);
>-		setDefaultFeedback(DND.FEEDBACK_SCROLL | DND.FEEDBACK_EXPAND);
>+		setFeedbackEnabled(false);
>+		setScrollEnabled(true);
>+		setExpandEnabled(true);
> 		if (!isValidTarget(target))
> 			return DND.DROP_NONE;
> 		ISelection s= LocalSelectionTransfer.getInstance().getSelection();
>@@ -109,9 +122,9 @@
> 		initializeState(target, s);
> 		
> 		if (isWorkingSetSelection()) {
>-			setDefaultFeedback(DND.FEEDBACK_SCROLL);
>-			if (fLocation == LOCATION_BEFORE || fLocation == LOCATION_AFTER) {
>-				showInsertionFeedback(true);
>+			setExpandEnabled(false);
>+			if (getCurrentLocation() == LOCATION_BEFORE || getCurrentLocation() == LOCATION_AFTER) {
>+				setFeedbackEnabled(true);
> 				return DND.DROP_MOVE;
> 			}
> 			return DND.DROP_NONE;
>@@ -184,14 +197,17 @@
> 		return true;
> 	}
> 
>-	public void drop(Object target, final DropTargetEvent event) {
>+	/**
>+	 * {@inheritDoc}
>+	 */
>+	public int performDrop(Object data) {
> 		if (isWorkingSetSelection()) {
> 			performWorkingSetReordering();
> 		} else {
>-			performElementRearrange(event.detail);
>+			performElementRearrange(getCurrentOperation());
> 		}
> 		// drag adapter has nothing to do, even on move.
>-		event.detail= DND.DROP_NONE;
>+		return DND.DROP_NONE;
> 	}
> 
> 	private void performWorkingSetReordering() {
>@@ -199,7 +215,7 @@
> 		List activeWorkingSets= new ArrayList(Arrays.asList(model.getActiveWorkingSets()));
> 		int index= activeWorkingSets.indexOf(fWorkingSet);
> 		if (index != -1) {
>-			if (fLocation == LOCATION_AFTER)
>+			if (getCurrentLocation() == LOCATION_AFTER)
> 				index++;
> 			List result= new ArrayList(activeWorkingSets.size());
> 			List selected= new ArrayList(Arrays.asList(fElementsToAdds));
>@@ -267,4 +283,8 @@
> 			performElementRearrange(eventDetail);
> 		}
> 	}
>+
>+	public void internalTestSetLocation(int location) {
>+		setCurrentLocation(location);
>+	}
> }
>Index: ui/org/eclipse/jdt/internal/ui/dnd/DelegatingDragAdapter.java
>===================================================================
>RCS file: ui/org/eclipse/jdt/internal/ui/dnd/DelegatingDragAdapter.java
>diff -N ui/org/eclipse/jdt/internal/ui/dnd/DelegatingDragAdapter.java
>--- ui/org/eclipse/jdt/internal/ui/dnd/DelegatingDragAdapter.java	29 May 2007 18:41:35 -0000	1.14
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,117 +0,0 @@
>-/*******************************************************************************
>- * Copyright (c) 2000, 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 API and implementation
>- *******************************************************************************/
>-package org.eclipse.jdt.internal.ui.dnd;
>-
>-import java.util.ArrayList;
>-import java.util.Iterator;
>-import java.util.List;
>-
>-import org.eclipse.core.runtime.Assert;
>-
>-import org.eclipse.swt.dnd.DragSource;
>-import org.eclipse.swt.dnd.DragSourceEvent;
>-import org.eclipse.swt.dnd.DragSourceListener;
>-import org.eclipse.swt.dnd.Transfer;
>-import org.eclipse.swt.dnd.TransferData;
>-
>-import org.eclipse.jface.util.TransferDragSourceListener;
>-
>-/**
>- * A delegating drag adapter negotiates between a set of <code>TransferDragSourceListener</code>s
>- * On <code>dragStart</code> the adapter determines the listener to be used for any further
>- * <code>drag*</code> callback.
>- */
>-public class DelegatingDragAdapter implements DragSourceListener {
>-
>-	private TransferDragSourceListener[] fPossibleListeners;
>-	private List fActiveListeners;
>-	private TransferDragSourceListener fFinishListener;
>-	
>-	public DelegatingDragAdapter(TransferDragSourceListener[] listeners) {
>-		setPossibleListeners(listeners);
>-	}
>-	
>-	protected void setPossibleListeners(TransferDragSourceListener[] listeners) {
>-		Assert.isNotNull(listeners);
>-		Assert.isTrue(fActiveListeners == null, "Can only set possible listeners before drag operation has started"); //$NON-NLS-1$
>-		fPossibleListeners= listeners;
>-	}
>-	
>-	/* non Java-doc
>-	 * @see DragSourceListener
>-	 */
>-	public void dragStart(DragSourceEvent event) {
>-		fFinishListener= null;
>-		boolean saveDoit= event.doit;
>-		Object saveData= event.data;
>-		boolean doIt= false;
>-		List transfers= new ArrayList(fPossibleListeners.length);
>-		fActiveListeners= new ArrayList(fPossibleListeners.length);
>-		
>-		for (int i= 0; i < fPossibleListeners.length; i++) {
>-			TransferDragSourceListener listener= fPossibleListeners[i];
>-			event.doit= saveDoit;
>-			listener.dragStart(event);
>-			if (event.doit) {
>-				transfers.add(listener.getTransfer());
>-				fActiveListeners.add(listener);
>-			}
>-			doIt= doIt || event.doit;
>-		}
>-		if (doIt) {
>-			((DragSource)event.widget).setTransfer((Transfer[])transfers.toArray(new Transfer[transfers.size()]));
>-		}
>-		event.data= saveData;
>-		event.doit= doIt;
>-	}
>-
>-	/* non Java-doc
>-	 * @see DragSourceListener
>-	 */
>-	public void dragSetData(DragSourceEvent event) {
>-		fFinishListener= getListener(event.dataType);
>-		if (fFinishListener != null)
>-			fFinishListener.dragSetData(event);
>-	}
>-	
>-	/* non Java-doc
>-	 * @see DragSourceListener
>-	 */
>-	public void dragFinished(DragSourceEvent event) {
>-		try{
>-			if (fFinishListener != null) {
>-				fFinishListener.dragFinished(event);
>-			} else {
>-				// If the user presses Escape then we get a dragFinished without
>-				// getting a dragSetData before.
>-				fFinishListener= getListener(event.dataType);
>-				if (fFinishListener != null)
>-					fFinishListener.dragFinished(event);
>-			}
>-		} finally{
>-			fFinishListener= null;
>-			fActiveListeners= null;
>-		}	
>-	}
>-	
>-	private TransferDragSourceListener getListener(TransferData type) {
>-		if (type == null)
>-			return null;
>-			
>-		for (Iterator iter= fActiveListeners.iterator(); iter.hasNext();) {
>-			TransferDragSourceListener listener= (TransferDragSourceListener)iter.next();
>-			if (listener.getTransfer().isSupportedType(type)) {
>-				return listener;
>-			}
>-		}
>-		return null;
>-	}	
>-}
>Index: ui/org/eclipse/jdt/internal/ui/dnd/DelegatingDropAdapter.java
>===================================================================
>RCS file: ui/org/eclipse/jdt/internal/ui/dnd/DelegatingDropAdapter.java
>diff -N ui/org/eclipse/jdt/internal/ui/dnd/DelegatingDropAdapter.java
>--- ui/org/eclipse/jdt/internal/ui/dnd/DelegatingDropAdapter.java	31 Aug 2006 09:59:17 -0000	1.13
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,270 +0,0 @@
>-/*******************************************************************************
>- * Copyright (c) 2000, 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 API and implementation
>- *******************************************************************************/
>-package org.eclipse.jdt.internal.ui.dnd;
>-
>-import org.eclipse.core.runtime.Assert;
>-import org.eclipse.core.runtime.SafeRunner;
>-
>-import org.eclipse.swt.dnd.DND;
>-import org.eclipse.swt.dnd.DropTargetEvent;
>-import org.eclipse.swt.dnd.DropTargetListener;
>-import org.eclipse.swt.dnd.Transfer;
>-import org.eclipse.swt.dnd.TransferData;
>-
>-import org.eclipse.jface.util.SafeRunnable;
>-import org.eclipse.jface.util.TransferDropTargetListener;
>-
>-/**
>- * A delegating drop adapter negotiates between a set of
>- * <code>TransferDropTargetListener</code> s On <code>dragEnter</code> the
>- * adapter determines the listener to be used for any further <code>drag*</code>
>- * callback.
>- */
>-public class DelegatingDropAdapter implements DropTargetListener {
>-
>-	private TransferDropTargetListener[] fListeners;
>-	private TransferDropTargetListener fCurrentListener;
>-	private int fOriginalDropType;
>-
>-	/**
>-	 * Creates a new delegating drop adapter.
>-	 * 
>-	 * @param listeners an array of potential listeners
>-	 */
>-	public DelegatingDropAdapter(TransferDropTargetListener[] listeners) {
>-		Assert.isNotNull(listeners);
>-		fListeners= listeners;
>-	}
>-
>-	/**
>-	 * The cursor has entered the drop target boundaries. The current listener
>-	 * is updated, and <code>#dragEnter()</code> is forwarded to the current
>-	 * listener.
>-	 * 
>-	 * @param event the drop target event
>-	 * @see DropTargetListener#dragEnter(DropTargetEvent)
>-	 */
>-	public void dragEnter(DropTargetEvent event) {
>-		fOriginalDropType= event.detail;
>-		updateCurrentListener(event);
>-	}
>-
>-	/**
>-	 * The cursor has left the drop target boundaries. The event is forwarded to
>-	 * the current listener.
>-	 * 
>-	 * @param event the drop target event
>-	 * @see DropTargetListener#dragLeave(DropTargetEvent)
>-	 */
>-	public void dragLeave(final DropTargetEvent event) {
>-		setCurrentListener(null, event);
>-	}
>-
>-	/**
>-	 * The operation being performed has changed (usually due to the user
>-	 * changing a drag modifier key while dragging). Updates the current
>-	 * listener and forwards this event to that listener.
>-	 * 
>-	 * @param event the drop target event
>-	 * @see DropTargetListener#dragOperationChanged(DropTargetEvent)
>-	 */
>-	public void dragOperationChanged(final DropTargetEvent event) {
>-		fOriginalDropType= event.detail;
>-		TransferDropTargetListener oldListener= getCurrentListener();
>-		updateCurrentListener(event);
>-		final TransferDropTargetListener newListener= getCurrentListener();
>-		// only notify the current listener if it hasn't changed based on the
>-		// operation change. otherwise the new listener would get a dragEnter
>-		// followed by a dragOperationChanged with the exact same event.
>-		if (newListener != null && newListener == oldListener) {
>-			SafeRunner.run(new SafeRunnable() {
>-				public void run() throws Exception {
>-					newListener.dragOperationChanged(event);
>-				}
>-			});
>-		}
>-	}
>-
>-	/**
>-	 * The cursor is moving over the drop target. Updates the current listener
>-	 * and forwards this event to that listener. If no listener can handle the
>-	 * drag operation the <code>event.detail</code> field is set to
>-	 * <code>DND.DROP_NONE</code> to indicate an invalid drop.
>-	 * 
>-	 * @param event the drop target event
>-	 * @see DropTargetListener#dragOver(DropTargetEvent)
>-	 */
>-	public void dragOver(final DropTargetEvent event) {
>-		TransferDropTargetListener oldListener= getCurrentListener();
>-		updateCurrentListener(event);
>-		final TransferDropTargetListener newListener= getCurrentListener();
>-
>-		// only notify the current listener if it hasn't changed based on the
>-		// drag over. otherwise the new listener would get a dragEnter
>-		// followed by a dragOver with the exact same event.
>-		if (newListener != null && newListener == oldListener) {
>-			SafeRunner.run(new SafeRunnable() {
>-				public void run() throws Exception {
>-					newListener.dragOver(event);
>-				}
>-			});
>-		}
>-	}
>-
>-	/**
>-	 * Forwards this event to the current listener, if there is one. Sets the
>-	 * current listener to <code>null</code> afterwards.
>-	 * 
>-	 * @param event the drop target event
>-	 * @see DropTargetListener#drop(DropTargetEvent)
>-	 */
>-	public void drop(final DropTargetEvent event) {
>-		updateCurrentListener(event);
>-		if (getCurrentListener() != null) {
>-			SafeRunner.run(new SafeRunnable() {
>-				public void run() throws Exception {
>-					getCurrentListener().drop(event);
>-				}
>-			});
>-		}
>-		setCurrentListener(null, event);
>-	}
>-
>-	/**
>-	 * Forwards this event to the current listener if there is one.
>-	 * 
>-	 * @param event the drop target event
>-	 * @see DropTargetListener#dropAccept(DropTargetEvent)
>-	 */
>-	public void dropAccept(final DropTargetEvent event) {
>-		if (getCurrentListener() != null) {
>-			SafeRunner.run(new SafeRunnable() {
>-				public void run() throws Exception {
>-					getCurrentListener().dropAccept(event);
>-				}
>-			});
>-		}
>-	}
>-
>-	/**
>-	 * Returns the listener which currently handles drop events.
>-	 * 
>-	 * @return the <code>TransferDropTargetListener</code> which currently
>-	 * handles drop events.
>-	 */
>-	private TransferDropTargetListener getCurrentListener() {
>-		return fCurrentListener;
>-	}
>-
>-	/**
>-	 * Returns the transfer data type supported by the given listener. Returns
>-	 * <code>null</code> if the listener does not support any of the specified
>-	 * data types.
>-	 * 
>-	 * @param dataTypes available data types
>-	 * @param listener <code>TransferDropTargetListener</code> to use for
>-	 * testing supported data types.
>-	 * @return the transfer data type supported by the given listener or
>-	 * <code>null</code>.
>-	 */
>-	private TransferData getSupportedTransferType(TransferData[] dataTypes, TransferDropTargetListener listener) {
>-		for (int i= 0; i < dataTypes.length; i++) {
>-			if (listener.getTransfer().isSupportedType(dataTypes[i])) {
>-				return dataTypes[i];
>-			}
>-		}
>-		return null;
>-	}
>-
>-	/**
>-	 * Returns the combined set of <code>Transfer</code> types of all
>-	 * <code>TransferDropTargetListeners</code>.
>-	 * 
>-	 * @return the combined set of <code>Transfer</code> types
>-	 */
>-	public Transfer[] getTransfers() {
>-		Transfer[] types= new Transfer[fListeners.length];
>-		for (int i= 0; i < fListeners.length; i++) {
>-			types[i]= fListeners[i].getTransfer();
>-		}
>-		return types;
>-	}
>-
>-	/**
>-	 * Sets the current listener to <code>listener</code>. Sends the given
>-	 * <code>DropTargetEvent</code> if the current listener changes.
>-	 * 
>-	 * @return <code>true</code> if the new listener is different than the
>-	 * previous <code>false</code> otherwise
>-	 */
>-	private boolean setCurrentListener(TransferDropTargetListener listener, final DropTargetEvent event) {
>-		if (fCurrentListener == listener)
>-			return false;
>-		if (fCurrentListener != null) {
>-			SafeRunner.run(new SafeRunnable() {
>-				public void run() throws Exception {
>-					fCurrentListener.dragLeave(event);
>-				}
>-			});
>-		}
>-		fCurrentListener= listener;
>-		if (fCurrentListener != null) {
>-			SafeRunner.run(new SafeRunnable() {
>-				public void run() throws Exception {
>-					fCurrentListener.dragEnter(event);
>-				}
>-			});
>-		}
>-		return true;
>-	}
>-
>-	/**
>-	 * Updates the current listener to one that can handle the drop. There can
>-	 * be many listeners and each listener may be able to handle many
>-	 * <code>TransferData</code> types. The first listener found that can
>-	 * handle a drop of one of the given <code>TransferData</code> types will
>-	 * be selected. If no listener can handle the drag operation the
>-	 * <code>event.detail</code> field is set to <code>DND.DROP_NONE</code>
>-	 * to indicate an invalid drop.
>-	 * 
>-	 * @param event the drop target event
>-	 */
>-	private void updateCurrentListener(DropTargetEvent event) {
>-		int originalDetail= event.detail;
>-		// Revert the detail to the "original" drop type that the User
>-		// indicated. This is necessary because the previous listener 
>-		// may have changed the detail to something other than what the 
>-		// user indicated.
>-		event.detail= fOriginalDropType;
>-
>-		for (int i= 0; i < fListeners.length; i++) {
>-			TransferDropTargetListener listener= fListeners[i];
>-			TransferData dataType= getSupportedTransferType(event.dataTypes, listener);
>-			if (dataType != null) {
>-				TransferData originalDataType= event.currentDataType;
>-				// set the data type supported by the drop listener
>-				event.currentDataType= dataType;
>-				if (listener.isEnabled(event)) {
>-					// if the listener stays the same, set its previously
>-					// determined
>-					// event detail
>-					if (!setCurrentListener(listener, event))
>-						event.detail= originalDetail;
>-					return;
>-				} else {
>-					event.currentDataType= originalDataType;
>-				}
>-			}
>-		}
>-		setCurrentListener(null, event);
>-		event.detail= DND.DROP_NONE;
>-	}
>-}
>Index: ui/org/eclipse/jdt/internal/ui/dnd/JdtViewerDropAdapter.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/dnd/JdtViewerDropAdapter.java,v
>retrieving revision 1.16
>diff -u -r1.16 JdtViewerDropAdapter.java
>--- ui/org/eclipse/jdt/internal/ui/dnd/JdtViewerDropAdapter.java	29 May 2007 18:41:35 -0000	1.16
>+++ ui/org/eclipse/jdt/internal/ui/dnd/JdtViewerDropAdapter.java	26 Jul 2007 12:27:14 -0000
>@@ -1,5 +1,5 @@
> /*******************************************************************************
>- * Copyright (c) 2000, 2006 IBM Corporation and others.
>+ * Copyright (c) 2007 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
>@@ -10,288 +10,483 @@
> *******************************************************************************/
> package org.eclipse.jdt.internal.ui.dnd;
> 
>-import org.eclipse.core.runtime.Assert;
>-
> import org.eclipse.swt.dnd.DND;
>+import org.eclipse.swt.dnd.DropTargetAdapter;
> import org.eclipse.swt.dnd.DropTargetEvent;
>-import org.eclipse.swt.dnd.DropTargetListener;
>+import org.eclipse.swt.dnd.TransferData;
> import org.eclipse.swt.graphics.Point;
> import org.eclipse.swt.graphics.Rectangle;
> import org.eclipse.swt.widgets.Item;
> import org.eclipse.swt.widgets.TableItem;
> import org.eclipse.swt.widgets.TreeItem;
> 
>-import org.eclipse.jface.viewers.StructuredViewer;
>+import org.eclipse.jface.viewers.ISelection;
>+import org.eclipse.jface.viewers.IStructuredSelection;
>+import org.eclipse.jface.viewers.Viewer;
> 
> /**
>- * A drag and drop adapter to be used together with structured viewers.
>- * The adapater delegates the <code>dragEnter</code>, <code>dragOperationChanged
>- * </code>, <code>dragOver</code> and <code>dropAccept</code> method to the
>- * <code>validateDrop</code> method. Furthermore it adds location feedback.
>+ * This adapter class provides generic drag-and-drop support for a viewer.
>+ * 
>+ * Subclasses must implement the following methods:
>+ * <ul>
>+ * <li><code>validateDrop</code> - identifies valid drop targets in viewer</li>
>+ * <li><code>performDrop</code> - carries out a drop into a viewer</li>
>+ * </ul>
>+ * The <code>setFeedbackEnabled</code> method can be called to turn on and off 
>+ * visual insertion feedback (on by default).
>+ * 
>+ * 
>+ * THIS IS (ALMOST) A ONE-TO-ONE COPY OF PLATFORMS ViewerDropAdapter
>+ * REFERE THERE FIRST IF YOU NEED TO FIX SOMETHING.
>+ * 
> */
>-public class JdtViewerDropAdapter implements DropTargetListener {
>-
>-	/**
>-	 * Constant describing the position of the mouse cursor relative 
>-	 * to the target object. This means the mouse is not positioned
>-	 * over or near any valid target.
>-	 */
>-	public static final int LOCATION_NONE= DND.FEEDBACK_NONE;
>-	
>-	/**
>-	 * Constant describing the position of the mouse cursor relative 
>-	 * to the target object. This means the mouse is positioned
>-	 * directly on the target.
>-	 */
>-	public static final int LOCATION_ON= DND.FEEDBACK_SELECT;
>-	
>-	/**
>-	 * Constant describing the position of the mouse cursor relative 
>-	 * to the target object. This means the mouse is positioned
>-	 * slightly before the target.
>-	 */
>-	public static final int LOCATION_BEFORE= DND.FEEDBACK_INSERT_BEFORE;
>-	
>-	/**
>-	 * Constant describing the position of the mouse cursor relative 
>-	 * to the target object. This means the mouse is positioned
>-	 * slightly after the target.
>-	 */
>-	public static final int LOCATION_AFTER= DND.FEEDBACK_INSERT_AFTER;
>-	
>-	/**
>-	 * The threshold used to determine if the mouse is before or after
>-	 * an item.
>-	 */
>-	private static final int LOCATION_EPSILON= 5; 
>-	
>-
>-	private static final int ITEM_MARGIN_LEFT= 40;
>-	private static final int ITEM_MARGIN_RIGTH= 10;
>-	
>-	/**
>-	 * Style to enable location feedback.
>-	 */
>-	public static final int INSERTION_FEEDBACK= 1 << 1; 
>-
>-	private StructuredViewer fViewer;
>-	private int fFeedback;
>-	private boolean fShowInsertionFeedback;
>-	private boolean fFullWidthMatchesItem;
>-	private int fRequestedOperation;
>-	private int fLastOperation;
>-	protected int fLocation;
>-	protected Object fTarget;
>-
>-
>-
>-	public JdtViewerDropAdapter(StructuredViewer viewer, int feedback) {
>-		Assert.isNotNull(viewer);
>-		fViewer= viewer;
>-		fFeedback= feedback;
>-		fLastOperation= -1;
>-		fFullWidthMatchesItem= true;
>-	}
>+public abstract class JdtViewerDropAdapter extends DropTargetAdapter {
> 
>-	/**
>-	 * Controls whether the drop adapter shows insertion feedback or not.
>-	 * 
>-	 * @param showInsertionFeedback <code>true</code> if the drop adapter is supposed
>-	 *	to show insertion feedback. Otherwise <code>false</code>
>-	 */
>-	public void showInsertionFeedback(boolean showInsertionFeedback) {
>-		fShowInsertionFeedback= showInsertionFeedback;
>-	}
>-	
>-	/**
>-	 * Controls whether the drop adapter matches an tree or table item on the full width of the viewer. 
>-	 * 
>-	 * @param enable <code>true</code> if the drop adapter is supposed
>-	 *	to test the horizontal distance
>-	 */
>-	protected void setFullWidthMatchesItem(boolean enable) {
>-		fFullWidthMatchesItem= enable;
>-	}
>-	
>-	/**
>-	 * Returns the viewer this adapter is working on.
>-	 */
>-	protected StructuredViewer getViewer() {
>-		return fViewer;
>-	} 
>-	
>-	//---- Hooks to override -----------------------------------------------------
>-	
>-	/**
>-	 * The actual drop has occurred. Calls <code>drop(Object target, DropTargetEvent event)
>-	 * </code>.
>-	 * @see DropTargetListener#drop(org.eclipse.swt.dnd.DropTargetEvent)
>-	 */	 
>-	public void drop(DropTargetEvent event) {
>-		drop(fTarget, event);
>-	}
>-	
>-	/**
>-	 * The actual drop has occurred.
>-	 * @param target the drop target in form of a domain element.
>-	 * @param event the drop traget event
>-	 */	 
>-	public void drop(Object target, DropTargetEvent event) {
>-	}
>-	
>-	/**
>-	 * Checks if the drop is valid. The method calls <code>validateDrop
>-	 * (Object target, DropTargetEvent event). Implementors can alter the 
>-	 * <code>currentDataType</code> field and the <code>detail</code> field 
>-	 * to give feedback about drop acceptence.
>-	 */
>-	public void validateDrop(DropTargetEvent event) {
>-		validateDrop(fTarget, event, fRequestedOperation);
>-	}
>-	
>-	/**
>-	 * Checks if the drop on the current target is valid. The method
>-	 * can alter the <code>currentDataType</code> field and the <code>
>-	 * detail</code> field to give feedback about drop acceptence.
>-	 * @param target the drop target in form of a domain element.
>-	 * @param event the drop traget event
>-	 * @param operation the operation requested by the user.
>-	 */
>-	public void validateDrop(Object target, DropTargetEvent event, int operation) {
>-	}
>-	
>-	public void dragEnter(DropTargetEvent event) {
>-		dragOperationChanged(event);
>-	}
>-	
>-	public void dragLeave(DropTargetEvent event) {
>-		fTarget= null;
>-		fLocation= LOCATION_NONE;
>-	}
>-	
>-	public void dragOperationChanged(DropTargetEvent event) {
>-		fRequestedOperation= event.detail;
>-		fTarget= computeTarget(event);
>-		fLocation= computeLocation(event);
>-		validateDrop(event);
>-		fLastOperation= event.detail;
>-		computeFeedback(event);
>-	}
>-	
>-	public void dragOver(DropTargetEvent event) {
>-		Object oldTarget= fTarget;
>-		fTarget= computeTarget(event);
>-		
>-		//set the location feedback
>-		int oldLocation= fLocation;
>-		fLocation= computeLocation(event);
>-		if (oldLocation != fLocation || oldTarget != fTarget || fLastOperation != event.detail) {
>-			validateDrop(event);
>-			fLastOperation= event.detail;
>-		} else {
>-			event.detail= fLastOperation;
>+ /**
>+ * Constant describing the position of the cursor relative 
>+ * to the target object. This means the mouse is positioned
>+ * slightly before the target.
>+ * @see #getCurrentLocation()
>+ */
>+ public static final int LOCATION_BEFORE = 1;
>+
>+ /**
>+ * Constant describing the position of the cursor relative 
>+ * to the target object. This means the mouse is positioned
>+ * slightly after the target.
>+ * @see #getCurrentLocation()
>+ */
>+ public static final int LOCATION_AFTER = 2;
>+
>+ /**
>+ * Constant describing the position of the cursor relative 
>+ * to the target object. This means the mouse is positioned
>+ * directly on the target.
>+ * @see #getCurrentLocation()
>+ */
>+ public static final int LOCATION_ON = 3;
>+
>+ /**
>+ * Constant describing the position of the cursor relative 
>+ * to the target object. This means the mouse is not positioned
>+ * over or near any valid target.
>+ * @see #getCurrentLocation()
>+ */
>+ public static final int LOCATION_NONE = 4;
>+
>+ /**
>+ * The viewer to which this drop support has been added.
>+ */
>+ private Viewer viewer;
>+
>+ /**
>+ * The current operation.
>+ */
>+ private int currentOperation = DND.DROP_NONE;
>+
>+ /**
>+ * The last valid operation.
>+ */
>+ private int lastValidOperation = DND.DROP_NONE;
>+
>+ /**
>+ * The data item currently under the mouse.
>+ */
>+ private Object currentTarget;
>+
>+ /**
>+ * Information about the position of the mouse relative to the
>+ * target (before, on, or after the target. Location is one of
>+ * the <code>LOCATION_* </code> constants defined in this type.
>+ */
>+ private int currentLocation;
>+
>+ /**
>+ * A flag that allows adapter users to turn the insertion
>+ * feedback on or off. Default is <code>true</code>.
>+ */
>+ private boolean feedbackEnabled = true;
>+
>+ /**
>+ * A flag that allows adapter users to turn auto scrolling
>+ * on or off. Default is <code>true</code>.
>+ */
>+ private boolean scrollEnabled = true;
>+
>+ /**
>+ * A flag that allows adapter users to turn auto
>+ * expanding on or off. Default is <code>true</code>.
>+ */
>+ private boolean expandEnabled = true;
>+ 
>+ /**
>+ * A flag that allows adapter users to turn selection feedback
>+ * on or off. Default is <code>true</code>.
>+ */
>+ private boolean selectFeedbackEnabled = true;
>+
>+ /**
>+ * Creates a new drop adapter for the given viewer.
>+ *
>+ * @param viewer the viewer
>+ */
>+ protected JdtViewerDropAdapter(Viewer viewer) {
>+ this.viewer = viewer;
>+ }
>+
>+ /**
>+ * Returns the position of the given event's coordinates relative to its target.
>+ * The position is determined to be before, after, or on the item, based on
>+ * some threshold value.
>+ *
>+ * @param event the event
>+ * @return one of the <code>LOCATION_* </code>constants defined in this class
>+ */
>+ protected int determineLocation(DropTargetEvent event) {
>+ if (!(event.item instanceof Item)) {
>+ return LOCATION_NONE;
>+ }
>+ Item item = (Item) event.item;
>+ Point coordinates = new Point(event.x, event.y);
>+ coordinates = viewer.getControl().toControl(coordinates);
>+ if (item != null) {
>+ Rectangle bounds = getBounds(item);
>+ if (bounds == null) {
>+ return LOCATION_NONE;
>+ }
>+ if ((coordinates.y - bounds.y) < 5) {
>+ return LOCATION_BEFORE;
>+ }
>+ if ((bounds.y + bounds.height - coordinates.y) < 5) {
>+ return LOCATION_AFTER;
>+ }
>+ }
>+ return LOCATION_ON;
>+ }
>+
>+ /**
>+ * Returns the target item of the given drop event.
>+ *
>+ * @param event the event
>+ * @return The target of the drop, may be <code>null</code>.
>+ */
>+ protected Object determineTarget(DropTargetEvent event) {
>+ return event.item == null ? null : event.item.getData();
>+ }
>+
>+ /* (non-Javadoc)
>+ * Method declared on DropTargetAdapter.
>+ * The mouse has moved over the drop target. If the
>+ * target item has changed, notify the action and check
>+ * that it is still enabled.
>+ */
>+ private void doDropValidation(DropTargetEvent event) {
>+ currentOperation= validateDrop(currentTarget, lastValidOperation, event.currentDataType);
>+ event.detail = currentOperation;
>+ }
>+
>+ /* (non-Javadoc)
>+ * Method declared on DropTargetAdapter.
>+ * The drag has entered this widget's region. See
>+ * if the drop should be allowed.
>+ */
>+ public void dragEnter(DropTargetEvent event) {
>+ currentTarget = determineTarget(event);
>+ lastValidOperation = event.detail;
>+ doDropValidation(event);
>+ }
>+
>+ /* (non-Javadoc)
>+ * Method declared on DropTargetAdapter.
>+ * The drop operation has changed, see if the action
>+ * should still be enabled.
>+ */
>+ public void dragOperationChanged(DropTargetEvent event) {
>+ currentTarget = determineTarget(event);
>+ lastValidOperation = event.detail;
>+ doDropValidation(event);
>+ }
>+
>+ /* (non-Javadoc)
>+ * Method declared on DropTargetAdapter.
>+ * The mouse has moved over the drop target. If the
>+ * target item has changed, notify the action and check
>+ * that it is still enabled.
>+ */
>+ public void dragOver(DropTargetEvent event) {
>+ //use newly revealed item as target if scrolling occurs
>+ Object target = determineTarget(event);
>+
>+ //set the location feedback
>+ int oldLocation = currentLocation;
>+ currentLocation = determineLocation(event);
>+ setFeedback(event, currentLocation);
>+
>+ //see if anything has really changed before doing validation.
>+ if (target != currentTarget || currentLocation != oldLocation) {
>+ currentTarget = target;
>+ doDropValidation(event);
>+ }
>+ }
>+
>+ /* (non-Javadoc)
>+ * Method declared on DropTargetAdapter.
>+ * The user has dropped something on the desktop viewer.
>+ */
>+ public void drop(DropTargetEvent event) {
>+ currentLocation = determineLocation(event);
>+
>+ //perform the drop behavior
>+ currentOperation= performDrop(event.data);
>+ event.detail= currentOperation;
>+ }
>+
>+ /* (non-Javadoc)
>+ * Method declared on DropTargetAdapter.
>+ * Last chance for the action to disable itself
>+ */
>+ public void dropAccept(DropTargetEvent event) {
>+ 	event.detail= validateDrop(currentTarget, event.detail, event.currentDataType);
>+ }
>+
>+ /**
>+ * Returns the bounds of the given SWT tree or table item.
>+ *
>+ * @param item the SWT Item
>+ * @return the bounds, or <code>null</code> if it is not a known type of item
>+ */
>+ protected Rectangle getBounds(Item item) {
>+ if (item instanceof TreeItem) {
>+ return ((TreeItem) item).getBounds();
>+ }
>+ if (item instanceof TableItem) {
>+ return ((TableItem) item).getBounds(0);
>+ }
>+ return null;
>+ }
>+
>+ /**
>+ * Returns a constant describing the position of the mouse relative to the
>+ * target (before, on, or after the target. 
>+ *
>+ * @return one of the <code>LOCATION_* </code> constants defined in this type
>+ */
>+ protected int getCurrentLocation() {
>+ return currentLocation;
>+ }
>+
>+ /**
>+ * Returns the current operation.
>+ *
>+ * @return a <code>DROP_*</code> constant from class <code>DND</code>
>+ *
>+ * @see DND#DROP_COPY
>+ * @see DND#DROP_MOVE
>+ * @see DND#DROP_LINK
>+ * @see DND#DROP_NONE
>+ */
>+ protected int getCurrentOperation() {
>+ return currentOperation;
>+ }
>+
>+ /**
>+ * Returns the target object currently under the mouse.
>+ *
>+ * @return the current target object
>+ */
>+ protected Object getCurrentTarget() {
>+ return currentTarget;
>+ }
>+
>+ /**
>+ * Returns whether visible insertion feedback should be presented to the user.
>+ * 
>+ * Typical insertion feedback is the horizontal insertion bars that appear 
>+ * between adjacent items while dragging.
>+ * 
>+ *
>+ * @return <code>true</code> if visual feedback is desired, and <code>false</code> if not
>+ */
>+ public boolean getFeedbackEnabled() {
>+ return feedbackEnabled;
>+ }
>+
>+ /**
>+ * Returns the object currently selected by the viewer.
>+ *
>+ * @return the selected object, or <code>null</code> if either no object or 
>+ * multiple objects are selected
>+ */
>+ protected Object getSelectedObject() {
>+ ISelection selection = viewer.getSelection();
>+ if (selection instanceof IStructuredSelection && !selection.isEmpty()) {
>+ IStructuredSelection structured = (IStructuredSelection) selection;
>+ return structured.getFirstElement();
>+ }
>+ return null;
>+ }
>+
>+ /**
>+ * @return the viewer to which this drop support has been added.
>+ */
>+ protected Viewer getViewer() {
>+ return viewer;
>+ }
>+
>+ /**
>+ * @deprecated this method should not be used. Exception handling has been 
>+ * 	removed from DropTargetAdapter methods overridden by this class.
>+ * Handles any exception that occurs during callback, including 
>+ * rethrowing behavior.
>+ * 
>+ * [Issue: Implementation prints stack trace and eats exception to avoid
>+ * crashing VA/J.
>+ * Consider conditionalizing the implementation to do one thing in VAJ
>+ * and something more reasonable in other operating environments.
>+ * ]
>+ * 
>+ *
>+ * @param exception the exception
>+ * @param event the event
>+ */
>+ protected void handleException(Throwable exception, DropTargetEvent event) {
>+ // Currently we never rethrow because VA/Java crashes if an SWT
>+ // callback throws anything. Generally catching Throwable is bad, but in
>+ // this cases it's better than hanging the image.
>+ exception.printStackTrace();
>+ event.detail = DND.DROP_NONE;
>+ }
>+
>+ /**
>+ * Performs any work associated with the drop.
>+ * 
>+ * Subclasses must implement this method to provide drop behavior.
>+ * 
>+ *
>+ * @param data the drop data
>+ * @return <code>true</code> if the drop was successful, and 
>+ * <code>false</code> otherwise
>+ */
>+ public abstract int performDrop(Object data);
>+
>+ /* (non-Javadoc)
>+ * Method declared on DropTargetAdapter.
>+ * The mouse has moved over the drop target. If the
>+ * target item has changed, notify the action and check
>+ * that it is still enabled.
>+ */
>+ private void setFeedback(DropTargetEvent event, int location) {
>+ if (feedbackEnabled) {
>+ switch (location) {
>+ case LOCATION_BEFORE:
>+ event.feedback = DND.FEEDBACK_INSERT_BEFORE;
>+ break;
>+ case LOCATION_AFTER:
>+ event.feedback = DND.FEEDBACK_INSERT_AFTER;
>+ break;
>+ case LOCATION_ON:
>+ default:
>+ event.feedback = DND.FEEDBACK_SELECT;
>+ break;
>+ }
>+ }
>+ 
>+ // Explicitly inhibit SELECT feedback if desired
>+		if (!selectFeedbackEnabled) {
>+			event.feedback &= ~DND.FEEDBACK_SELECT;
> 		}
>-		computeFeedback(event);
>-	}
>-	
>-	public void dropAccept(DropTargetEvent event) {
>-		fTarget= computeTarget(event);
>-		validateDrop(event);
>-		fLastOperation= event.detail;
>-	}
>-	
>-	/**
>-	 * Returns the data held by <code>event.item</code>. Inside a viewer
>-	 * this corresponds to the items data model element.
>-	 */
>-	protected Object computeTarget(DropTargetEvent event) {
>-		if (event.item == null) {
>-			return null;
>-		}
>-		if (!fFullWidthMatchesItem) {
>-			Point coordinates= fViewer.getControl().toControl(new Point(event.x, event.y));
>-			Rectangle bounds= getBounds((Item) event.item);
>-			if (coordinates.x < bounds.x - ITEM_MARGIN_LEFT || coordinates.x >= bounds.x + bounds.width + ITEM_MARGIN_RIGTH) {
>-				event.item= null; // too far away
>-				return null;
>-			}
>-		}
>-		return event.item.getData();
>-	}
>-	
>-	/**
>-	 * Returns the position of the given coordinates relative to the given target.
>-	 * The position is determined to be before, after, or on the item, based on 
>-	 * some threshold value. The return value is one of the LOCATION_* constants 
>-	 * defined in this class.
>-	 */
>-	protected int computeLocation(DropTargetEvent event) {
>-		if (!(event.item instanceof Item))
>-			return LOCATION_NONE;
>-		
>-		Item item= (Item) event.item;
>-		Point coordinates= fViewer.getControl().toControl(new Point(event.x, event.y));
>-		Rectangle bounds= getBounds(item);
>-		if (bounds == null) {
>-			return LOCATION_NONE;
>-		}
>-		if ((coordinates.y - bounds.y) < LOCATION_EPSILON) {
>-			return LOCATION_BEFORE;
>+
>+		if (expandEnabled) {
>+			event.feedback |= DND.FEEDBACK_EXPAND;
> 		}
>-		if ((bounds.y + bounds.height - coordinates.y) < LOCATION_EPSILON) {
>-			return LOCATION_AFTER;
>+		if (scrollEnabled) {
>+			event.feedback |= DND.FEEDBACK_SCROLL;
> 		}
>-		return LOCATION_ON;
>-	}
>-
>-	/**
>-	 * Returns the bounds of the given item, or <code>null</code> if it is not a 
>-	 * valid type of item.
>-	 */
>-	private Rectangle getBounds(Item item) {
>-		if (item instanceof TreeItem)
>-			return ((TreeItem) item).getBounds();
>-			
>-		if (item instanceof TableItem)
>-			return ((TableItem) item).getBounds(0);
>-			
>-		return null;
>-	}
>+ }
> 
>-	/**
>-	 * Sets the drag under feedback corresponding to the value of <code>fLocation</code>
>-	 * and the <code>INSERTION_FEEDBACK</code> style bit.
>-	 */
>-	protected void computeFeedback(DropTargetEvent event) {
>-		if (!fShowInsertionFeedback && fLocation != LOCATION_NONE) {
>-			event.feedback= DND.FEEDBACK_SELECT;
>-		} else {
>-			event.feedback= fLocation;
>-		}
>-		event.feedback|= fFeedback;
>-	}
>-	
>-	/**
>-	 * Sets the drop operation to </code>DROP_NODE<code>.
>-	 */
>-	protected void clearDropOperation(DropTargetEvent event) {
>-		event.detail= DND.DROP_NONE;
>-	}
>-	
>-	/**
>-	 * Returns the requested drop operation.
>-	 */
>-	protected int getRequestedOperation() {
>-		return fRequestedOperation;
>-	} 
>-	
>-	protected void setDefaultFeedback(int feedback) {
>-		fFeedback= feedback;
>-	}
>-	
>-	//---- helper methods to test DnD 
>-	
>-	public void internalTestSetLocation(int location) {
>-		fLocation= location;
>+ /**
>+	 * Sets whether visible insertion feedback should be presented to the user.
>+	 * 
>+	 * Typical insertion feedback is the horizontal insertion bars that appear
>+	 * between adjacent items while dragging.
>+	 * 
>+	 * 
>+	 * @param value
>+	 * <code>true</code> if visual feedback is desired, and
>+	 * <code>false</code> if not
>+	 */
>+ public void setFeedbackEnabled(boolean value) {
>+ feedbackEnabled = value;
>+ }
>+
>+ /**
>+ * Sets whether selection feedback should be provided during dragging.
>+ *
>+ * @param value <code>true</code> if selection feedback is desired, and
>+ * <code>false</code> if not
>+ * 
>+ * @since 3.2
>+ */
>+ public void setSelectionFeedbackEnabled(boolean value) {
>+ selectFeedbackEnabled = value;
>+ }
>+
>+ /**
>+ * Sets whether auto scrolling and expanding should be provided during dragging.
>+ *
>+ * @param value <code>true</code> if scrolling and expanding is desired, and
>+ * <code>false</code> if not
>+ * @since 2.0
>+ */
>+ public void setScrollExpandEnabled(boolean value) {
>+ 	expandEnabled = value;
>+ 	scrollEnabled = value;
>+ }
>+
>+ /**
>+ * Sets whether auto expanding should be provided during dragging.
>+ *
>+ * @param value <code>true</code> if expanding is desired, and
>+ * <code>false</code> if not
>+ * @since 3.4
>+ */
>+ public void setExpandEnabled(boolean value) {
>+ expandEnabled = value;
>+ }
>+ 
>+ /**
>+ * Sets whether auto scrolling should be provided during dragging.
>+ *
>+ * @param value <code>true</code> if scrolling is desired, and
>+ * <code>false</code> if not
>+ * @since 3.4
>+ */
>+ public void setScrollEnabled(boolean value) {
>+ scrollEnabled = value;
>+ }
>+
>+ /**
>+ * Validates dropping on the given object. This method is called whenever some 
>+ * aspect of the drop operation changes.
>+ * 
>+ * Subclasses must implement this method to define which drops make sense.
>+ * 
>+ * 
>+ * @param target the object that the mouse is currently hovering over, or
>+ * <code>null</code> if the mouse is hovering over empty space
>+ * @param operation the current drag operation (copy, move, etc.)
>+ * @param transferType the current transfer type
>+ * @return <code>true</code> if the drop is valid, and <code>false</code>
>+ * otherwise
>+ */
>+ public abstract int validateDrop(Object target, int operation,
>+ TransferData transferType);
>+ 
>+ /**
>+ * For testing only. The location should not be set otherwise.
>+ * @param location the location to assume
>+ */
>+ protected void setCurrentLocation(int location) {
>+ 	currentLocation= location;
> 	}
> }
>Index: ui/org/eclipse/jdt/internal/ui/dnd/JdtViewerDragAdapter.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/dnd/JdtViewerDragAdapter.java,v
>retrieving revision 1.7
>diff -u -r1.7 JdtViewerDragAdapter.java
>--- ui/org/eclipse/jdt/internal/ui/dnd/JdtViewerDragAdapter.java	29 May 2007 18:41:35 -0000	1.7
>+++ ui/org/eclipse/jdt/internal/ui/dnd/JdtViewerDragAdapter.java	26 Jul 2007 12:27:14 -0000
>@@ -14,7 +14,7 @@
> 
> import org.eclipse.swt.dnd.DragSourceEvent;
> 
>-import org.eclipse.jface.util.TransferDragSourceListener;
>+import org.eclipse.jface.util.DelegatingDragAdapter;
> import org.eclipse.jface.viewers.IStructuredSelection;
> import org.eclipse.jface.viewers.StructuredViewer;
> 
>@@ -22,8 +22,8 @@
> 
> 	private StructuredViewer fViewer;
> 
>-	public JdtViewerDragAdapter(StructuredViewer viewer, TransferDragSourceListener[] listeners) {
>-		super(listeners);
>+	public JdtViewerDragAdapter(StructuredViewer viewer) {
>+		super();
> 		Assert.isNotNull(viewer);
> 		fViewer= viewer;
> 	}
>Index: ui/org/eclipse/jdt/internal/ui/callhierarchy/CallHierarchyTransferDropAdapter.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/callhierarchy/CallHierarchyTransferDropAdapter.java,v
>retrieving revision 1.6
>diff -u -r1.6 CallHierarchyTransferDropAdapter.java
>--- ui/org/eclipse/jdt/internal/ui/callhierarchy/CallHierarchyTransferDropAdapter.java	17 Jun 2005 15:51:53 -0000	1.6
>+++ ui/org/eclipse/jdt/internal/ui/callhierarchy/CallHierarchyTransferDropAdapter.java	26 Jul 2007 12:27:13 -0000
>@@ -11,69 +11,45 @@
> *******************************************************************************/
> package org.eclipse.jdt.internal.ui.callhierarchy;
> 
>-import org.eclipse.swt.dnd.DND;
>-import org.eclipse.swt.dnd.DropTargetEvent;
>-
> import org.eclipse.jface.viewers.ISelection;
> import org.eclipse.jface.viewers.StructuredViewer;
> 
> import org.eclipse.jdt.core.IMethod;
> 
>-import org.eclipse.jdt.internal.ui.packageview.SelectionTransferDropAdapter;
>+import org.eclipse.jdt.internal.ui.dnd.ViewerInputDropAdapter;
> import org.eclipse.jdt.internal.ui.util.SelectionUtil;
> 
>-class CallHierarchyTransferDropAdapter extends SelectionTransferDropAdapter {
>-
>-	private static final int OPERATION = DND.DROP_LINK;
>+class CallHierarchyTransferDropAdapter extends ViewerInputDropAdapter {
>+	
> 	private CallHierarchyViewPart fCallHierarchyViewPart;
> 
> 	public CallHierarchyTransferDropAdapter(CallHierarchyViewPart viewPart, StructuredViewer viewer) {
> 		super(viewer);
>-		setFullWidthMatchesItem(false);
> 		fCallHierarchyViewPart= viewPart;
>-	}
>-
>-	public void validateDrop(Object target, DropTargetEvent event, int operation) {
>-		event.detail= DND.DROP_NONE;
>-		initializeSelection();
>-		if (target != null){
>-			super.validateDrop(target, event, operation);
>-			return;
>-		}	
>-		if (getInputElement(getSelection()) != null) 
>-			event.detail= OPERATION;
>-	}
>+	}	
> 	
>-	/* (non-Javadoc)
>-	 * @see org.eclipse.jdt.internal.ui.packageview.SelectionTransferDropAdapter#isEnabled(org.eclipse.swt.dnd.DropTargetEvent)
>+	/**
>+	 * {@inheritDoc}
> 	 */
>-	public boolean isEnabled(DropTargetEvent event) {
>-		return true;
>-	}
>-
>-	public void drop(Object target, DropTargetEvent event) {
>-		if (target != null || event.detail != OPERATION){
>-			super.drop(target, event);
>-			return;
>-		}	
>-		IMethod input= getInputElement(getSelection());
>-		fCallHierarchyViewPart.setMethod(input);
>+	protected void doInputView(Object inputElement) {
>+		fCallHierarchyViewPart.setMethod((IMethod) inputElement);
> 	}
> 	
>-	private static IMethod getInputElement(ISelection selection) {
>+	/**
>+	 * {@inheritDoc}
>+	 */
>+	protected Object getInputElement(ISelection selection) {
> 		Object single= SelectionUtil.getSingleElement(selection);
> 		if (single == null)
> 			return null;
>+		
> 		return getCandidate(single);
> 	}
> 
>- /**
>- * Converts the input to a possible input candidates
>- */ 
>- public static IMethod getCandidate(Object input) {
>- if (!(input instanceof IMethod)) {
>+ private static IMethod getCandidate(Object input) {
>+ if (!(input instanceof IMethod))
> return null;
>- }
>+ 
> return (IMethod) input;
> }
> }
>Index: ui/org/eclipse/jdt/internal/ui/callhierarchy/CallHierarchyViewPart.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/callhierarchy/CallHierarchyViewPart.java,v
>retrieving revision 1.59
>diff -u -r1.59 CallHierarchyViewPart.java
>--- ui/org/eclipse/jdt/internal/ui/callhierarchy/CallHierarchyViewPart.java	19 Dec 2006 15:34:28 -0000	1.59
>+++ ui/org/eclipse/jdt/internal/ui/callhierarchy/CallHierarchyViewPart.java	26 Jul 2007 12:27:14 -0000
>@@ -40,8 +40,7 @@
> import org.eclipse.jface.action.MenuManager;
> import org.eclipse.jface.action.Separator;
> import org.eclipse.jface.dialogs.IDialogSettings;
>-import org.eclipse.jface.util.TransferDragSourceListener;
>-import org.eclipse.jface.util.TransferDropTargetListener;
>+import org.eclipse.jface.util.DelegatingDropAdapter;
> import org.eclipse.jface.viewers.IOpenListener;
> import org.eclipse.jface.viewers.ISelection;
> import org.eclipse.jface.viewers.ISelectionChangedListener;
>@@ -96,7 +95,6 @@
> import org.eclipse.jdt.internal.ui.IJavaHelpContextIds;
> import org.eclipse.jdt.internal.ui.JavaPlugin;
> import org.eclipse.jdt.internal.ui.actions.CompositeActionGroup;
>-import org.eclipse.jdt.internal.ui.dnd.DelegatingDropAdapter;
> import org.eclipse.jdt.internal.ui.dnd.JdtViewerDragAdapter;
> import org.eclipse.jdt.internal.ui.dnd.ResourceTransferDragAdapter;
> import org.eclipse.jdt.internal.ui.javaeditor.EditorUtility;
>@@ -327,21 +325,25 @@
> 		Transfer[] transfers= new Transfer[] { LocalSelectionTransfer.getInstance() };
> 		int ops= DND.DROP_MOVE | DND.DROP_COPY | DND.DROP_LINK | DND.DROP_DEFAULT;
> 		
>-		TransferDropTargetListener[] dropListeners= new TransferDropTargetListener[] {
>-			new CallHierarchyTransferDropAdapter(this, viewer)
>-		};
>-		viewer.addDropSupport(ops, transfers, new DelegatingDropAdapter(dropListeners));
>+		DelegatingDropAdapter delegatingDropAdapter= new DelegatingDropAdapter();
>+		delegatingDropAdapter.addDropTargetListener(
>+			new CallHierarchyTransferDropAdapter(this, viewer)			
>+		);
>+		viewer.addDropSupport(ops, transfers, delegatingDropAdapter);
> 	}
> 
> 	private void addDragAdapters(StructuredViewer viewer) {
> 		int ops= DND.DROP_COPY | DND.DROP_LINK;
> 		Transfer[] transfers= new Transfer[] { LocalSelectionTransfer.getInstance(), ResourceTransfer.getInstance()};
> 
>-		TransferDragSourceListener[] dragListeners= new TransferDragSourceListener[] {
>-			new SelectionTransferDragAdapter(viewer),
>+		JdtViewerDragAdapter dragAdapter= new JdtViewerDragAdapter(viewer);
>+		dragAdapter.addDragSourceListener(
>+			new SelectionTransferDragAdapter(viewer)
>+		);
>+		dragAdapter.addDragSourceListener(
> 			new ResourceTransferDragAdapter(viewer)
>-		};
>-		viewer.addDragSupport(ops, transfers, new JdtViewerDragAdapter(viewer, dragListeners));
>+		);
>+		viewer.addDragSupport(ops, transfers, dragAdapter);
> 	}	
> 
> public void createPartControl(Composite parent) {
>Index: ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyTransferDropAdapter.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyTransferDropAdapter.java,v
>retrieving revision 1.18
>diff -u -r1.18 TypeHierarchyTransferDropAdapter.java
>--- ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyTransferDropAdapter.java	17 Jun 2005 15:51:58 -0000	1.18
>+++ ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyTransferDropAdapter.java	26 Jul 2007 12:27:14 -0000
>@@ -10,63 +10,44 @@
> *******************************************************************************/
> package org.eclipse.jdt.internal.ui.typehierarchy;
> 
>-import org.eclipse.swt.dnd.DND;
>-import org.eclipse.swt.dnd.DropTargetEvent;
>-
> import org.eclipse.jface.viewers.AbstractTreeViewer;
> import org.eclipse.jface.viewers.ISelection;
> 
> import org.eclipse.jdt.core.IJavaElement;
> 
>-import org.eclipse.jdt.internal.ui.packageview.SelectionTransferDropAdapter;
>+import org.eclipse.jdt.internal.ui.dnd.ViewerInputDropAdapter;
> import org.eclipse.jdt.internal.ui.util.OpenTypeHierarchyUtil;
> import org.eclipse.jdt.internal.ui.util.SelectionUtil;
> 
>-public class TypeHierarchyTransferDropAdapter extends SelectionTransferDropAdapter {
>+public class TypeHierarchyTransferDropAdapter extends ViewerInputDropAdapter {
> 
>-	private static final int OPERATION = DND.DROP_LINK;
> 	private TypeHierarchyViewPart fTypeHierarchyViewPart;
> 
> 	public TypeHierarchyTransferDropAdapter(TypeHierarchyViewPart viewPart, AbstractTreeViewer viewer) {
> 		super(viewer);
>-		setFullWidthMatchesItem(false);
> 		fTypeHierarchyViewPart= viewPart;
> 	}
>-
>-	public void validateDrop(Object target, DropTargetEvent event, int operation) {
>-		event.detail= DND.DROP_NONE;
>-		initializeSelection();
>-		if (target != null){
>-			super.validateDrop(target, event, operation);
>-			return;
>-		}	
>-		if (getInputElement(getSelection()) != null) 
>-			event.detail= TypeHierarchyTransferDropAdapter.OPERATION;
>-	}
> 		
>-	/* (non-Javadoc)
>-	 * @see org.eclipse.jdt.internal.ui.packageview.SelectionTransferDropAdapter#isEnabled(org.eclipse.swt.dnd.DropTargetEvent)
>+	/**
>+	 * {@inheritDoc}
> 	 */
>-	public boolean isEnabled(DropTargetEvent event) {
>-		return true;
>-	}	
>-
>-	public void drop(Object target, DropTargetEvent event) {
>-		if (target != null || event.detail != TypeHierarchyTransferDropAdapter.OPERATION){
>-			super.drop(target, event);
>-			return;
>-		}	
>-		IJavaElement input= getInputElement(getSelection());
>-		fTypeHierarchyViewPart.setInputElement(input);
>+	protected void doInputView(Object inputElement) {
>+		fTypeHierarchyViewPart.setInputElement((IJavaElement) inputElement);
> 	}
> 	
>-	private static IJavaElement getInputElement(ISelection selection) {
>+	/**
>+	 * {@inheritDoc}
>+	 */
>+	protected Object getInputElement(ISelection selection) {
> 		Object single= SelectionUtil.getSingleElement(selection);
> 		if (single == null)
> 			return null;
>+		
> 		IJavaElement[] candidates= OpenTypeHierarchyUtil.getCandidates(single);
> 		if (candidates != null && candidates.length > 0) 
> 			return candidates[0];
>+		
> 		return null;
> 	}
>+
> }
>Index: ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java,v
>retrieving revision 1.212
>diff -u -r1.212 TypeHierarchyViewPart.java
>--- ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java	29 May 2007 18:41:39 -0000	1.212
>+++ ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java	26 Jul 2007 12:27:15 -0000
>@@ -56,10 +56,9 @@
> import org.eclipse.jface.action.ToolBarManager;
> import org.eclipse.jface.dialogs.IDialogSettings;
> import org.eclipse.jface.dialogs.MessageDialog;
>+import org.eclipse.jface.util.DelegatingDropAdapter;
> import org.eclipse.jface.util.IPropertyChangeListener;
> import org.eclipse.jface.util.PropertyChangeEvent;
>-import org.eclipse.jface.util.TransferDragSourceListener;
>-import org.eclipse.jface.util.TransferDropTargetListener;
> import org.eclipse.jface.viewers.AbstractTreeViewer;
> import org.eclipse.jface.viewers.IBasicPropertyConstants;
> import org.eclipse.jface.viewers.ISelection;
>@@ -122,7 +121,6 @@
> import org.eclipse.jdt.internal.ui.actions.CompositeActionGroup;
> import org.eclipse.jdt.internal.ui.actions.NewWizardsActionGroup;
> import org.eclipse.jdt.internal.ui.actions.SelectAllAction;
>-import org.eclipse.jdt.internal.ui.dnd.DelegatingDropAdapter;
> import org.eclipse.jdt.internal.ui.dnd.JdtViewerDragAdapter;
> import org.eclipse.jdt.internal.ui.dnd.ResourceTransferDragAdapter;
> import org.eclipse.jdt.internal.ui.javaeditor.EditorUtility;
>@@ -736,21 +734,25 @@
> 		Transfer[] transfers= new Transfer[] { LocalSelectionTransfer.getInstance() };
> 		int ops= DND.DROP_MOVE | DND.DROP_COPY | DND.DROP_LINK | DND.DROP_DEFAULT;
> 		
>-		TransferDropTargetListener[] dropListeners= new TransferDropTargetListener[] {
>-			new TypeHierarchyTransferDropAdapter(this, viewer)
>-		};
>-		viewer.addDropSupport(ops, transfers, new DelegatingDropAdapter(dropListeners));
>+		DelegatingDropAdapter delegatingDropAdapter= new DelegatingDropAdapter();
>+		delegatingDropAdapter.addDropTargetListener(
>+			new TypeHierarchyTransferDropAdapter(this, viewer)				
>+		);
>+		viewer.addDropSupport(ops, transfers, delegatingDropAdapter);
> 	}
> 
> 	private void addDragAdapters(StructuredViewer viewer) {
> 		int ops= DND.DROP_COPY | DND.DROP_LINK;
> 		Transfer[] transfers= new Transfer[] { LocalSelectionTransfer.getInstance(), ResourceTransfer.getInstance()};
> 
>-		TransferDragSourceListener[] dragListeners= new TransferDragSourceListener[] {
>-			new SelectionTransferDragAdapter(viewer),
>+		JdtViewerDragAdapter dragAdapter= new JdtViewerDragAdapter(viewer);
>+		dragAdapter.addDragSourceListener(
>+			new SelectionTransferDragAdapter(viewer)
>+		);
>+		dragAdapter.addDragSourceListener(
> 			new ResourceTransferDragAdapter(viewer)
>-		};
>-		viewer.addDragSupport(ops, transfers, new JdtViewerDragAdapter(viewer, dragListeners));
>+		);
>+		viewer.addDragSupport(ops, transfers, dragAdapter);
> 	}	
> 			
> 	/**
>Index: ui/org/eclipse/jdt/internal/ui/browsing/JavaBrowsingPart.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/browsing/JavaBrowsingPart.java,v
>retrieving revision 1.167
>diff -u -r1.167 JavaBrowsingPart.java
>--- ui/org/eclipse/jdt/internal/ui/browsing/JavaBrowsingPart.java	27 Apr 2007 12:19:56 -0000	1.167
>+++ ui/org/eclipse/jdt/internal/ui/browsing/JavaBrowsingPart.java	26 Jul 2007 12:27:13 -0000
>@@ -43,10 +43,9 @@
> import org.eclipse.jface.action.IStatusLineManager;
> import org.eclipse.jface.action.IToolBarManager;
> import org.eclipse.jface.action.MenuManager;
>+import org.eclipse.jface.util.DelegatingDropAdapter;
> import org.eclipse.jface.util.IPropertyChangeListener;
> import org.eclipse.jface.util.PropertyChangeEvent;
>-import org.eclipse.jface.util.TransferDragSourceListener;
>-import org.eclipse.jface.util.TransferDropTargetListener;
> import org.eclipse.jface.viewers.IContentProvider;
> import org.eclipse.jface.viewers.ILabelProvider;
> import org.eclipse.jface.viewers.IOpenListener;
>@@ -120,7 +119,6 @@
> import org.eclipse.jdt.internal.ui.JavaPlugin;
> import org.eclipse.jdt.internal.ui.actions.CompositeActionGroup;
> import org.eclipse.jdt.internal.ui.actions.NewWizardsActionGroup;
>-import org.eclipse.jdt.internal.ui.dnd.DelegatingDropAdapter;
> import org.eclipse.jdt.internal.ui.dnd.JdtViewerDragAdapter;
> import org.eclipse.jdt.internal.ui.dnd.ResourceTransferDragAdapter;
> import org.eclipse.jdt.internal.ui.infoviews.AbstractInfoView;
>@@ -438,20 +436,25 @@
> 		Transfer[] dropTransfers= new Transfer[] {
> 			LocalSelectionTransfer.getInstance()
> 		};
>-		TransferDropTargetListener[] dropListeners= new TransferDropTargetListener[] {
>+		DelegatingDropAdapter delegatingDropAdapter= new DelegatingDropAdapter();
>+		delegatingDropAdapter.addDropTargetListener(
> 			new SelectionTransferDropAdapter(fViewer)
>-		};
>-		fViewer.addDropSupport(ops | DND.DROP_DEFAULT, dropTransfers, new DelegatingDropAdapter(dropListeners));
>+		);
>+		fViewer.addDropSupport(ops | DND.DROP_DEFAULT, dropTransfers, delegatingDropAdapter);
> 
> 		// Drag
> 		Transfer[] dragTransfers= new Transfer[] {
> 			LocalSelectionTransfer.getInstance(),
> 			ResourceTransfer.getInstance()};
>-		TransferDragSourceListener[] dragListeners= new TransferDragSourceListener[] {
>-			new SelectionTransferDragAdapter(fViewer),
>+		
>+		JdtViewerDragAdapter dragAdapter= new JdtViewerDragAdapter(fViewer);
>+		dragAdapter.addDragSourceListener(
>+			new SelectionTransferDragAdapter(fViewer)
>+		);
>+		dragAdapter.addDragSourceListener(
> 			new ResourceTransferDragAdapter(fViewer)
>-		};
>-		fViewer.addDragSupport(ops, dragTransfers, new JdtViewerDragAdapter(fViewer, dragListeners));
>+		);
>+		fViewer.addDragSupport(ops, dragTransfers, dragAdapter);
> 	}
> 
> 	protected void fillActionBars(IActionBars actionBars) {
>Index: ui/org/eclipse/jdt/internal/ui/search/JavaSearchResultPage.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/search/JavaSearchResultPage.java,v
>retrieving revision 1.70
>diff -u -r1.70 JavaSearchResultPage.java
>--- ui/org/eclipse/jdt/internal/ui/search/JavaSearchResultPage.java	26 Apr 2007 16:19:03 -0000	1.70
>+++ ui/org/eclipse/jdt/internal/ui/search/JavaSearchResultPage.java	26 Jul 2007 12:27:14 -0000
>@@ -31,7 +31,6 @@
> import org.eclipse.jface.action.IToolBarManager;
> import org.eclipse.jface.action.MenuManager;
> import org.eclipse.jface.action.Separator;
>-import org.eclipse.jface.util.TransferDragSourceListener;
> import org.eclipse.jface.viewers.ILabelProvider;
> import org.eclipse.jface.viewers.IStructuredSelection;
> import org.eclipse.jface.viewers.ITreeContentProvider;
>@@ -301,12 +300,14 @@
> 		Transfer[] transfers= new Transfer[] { LocalSelectionTransfer.getInstance(), ResourceTransfer.getInstance() };
> 		int ops= DND.DROP_COPY | DND.DROP_LINK;
> 		
>-		TransferDragSourceListener[] dragListeners= new TransferDragSourceListener[] {
>-			new SelectionTransferDragAdapter(viewer),
>+		JdtViewerDragAdapter dragAdapter= new JdtViewerDragAdapter(viewer);
>+		dragAdapter.addDragSourceListener(
>+			new SelectionTransferDragAdapter(viewer)
>+		);
>+		dragAdapter.addDragSourceListener(
> 			new ResourceTransferDragAdapter(viewer)
>-		};
>-		
>-		viewer.addDragSupport(ops, transfers, new JdtViewerDragAdapter(viewer, dragListeners));
>+		);
>+		viewer.addDragSupport(ops, transfers, dragAdapter);
> 	}	
> 
> 	protected void configureTableViewer(TableViewer viewer) {
>Index: ui/org/eclipse/jdt/internal/ui/dnd/ViewerInputDropAdapter.java
>===================================================================
>RCS file: ui/org/eclipse/jdt/internal/ui/dnd/ViewerInputDropAdapter.java
>diff -N ui/org/eclipse/jdt/internal/ui/dnd/ViewerInputDropAdapter.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ ui/org/eclipse/jdt/internal/ui/dnd/ViewerInputDropAdapter.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,102 @@
>+/*******************************************************************************
>+ * Copyright (c) 2007 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.jdt.internal.ui.dnd;
>+
>+
>+import org.eclipse.swt.dnd.DND;
>+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.Item;
>+
>+import org.eclipse.jface.viewers.ISelection;
>+import org.eclipse.jface.viewers.StructuredViewer;
>+
>+import org.eclipse.jdt.internal.ui.packageview.SelectionTransferDropAdapter;
>+
>+public abstract class ViewerInputDropAdapter extends SelectionTransferDropAdapter {
>+
>+	private static final int ITEM_MARGIN_LEFT= 40;
>+	private static final int ITEM_MARGIN_RIGTH= 10;
>+	private static final int OPERATION= DND.DROP_LINK;
>+
>+	public ViewerInputDropAdapter(StructuredViewer viewer) {
>+		super(viewer);
>+	}
>+	
>+	protected abstract Object getInputElement(ISelection selection);
>+	protected abstract void doInputView(Object inputElement);
>+	
>+	/**
>+	 * {@inheritDoc}
>+	 */
>+	public int validateDrop(Object target, int operation, TransferData transferType) {
>+	
>+		setSelectionFeedbackEnabled(true);
>+		setExpandEnabled(true);
>+		
>+		initializeSelection();
>+		
>+		if (target != null){
>+			return super.validateDrop(target, operation, transferType);
>+		} else if (getInputElement(getSelection()) != null) { 
>+			setSelectionFeedbackEnabled(false);
>+			setExpandEnabled(false);
>+			return OPERATION;
>+		} else {
>+			return DND.DROP_NONE;
>+		}
>+	}
>+	
>+	/**
>+	 * {@inheritDoc}
>+	 */
>+	public int performDrop(Object data) {
>+		setSelectionFeedbackEnabled(true);
>+		setExpandEnabled(true);
>+		
>+		if (getCurrentTarget() != null || getCurrentOperation() != OPERATION){
>+			return super.performDrop(data);
>+		}
>+		
>+		Object input= getInputElement(getSelection());
>+		if (input != null)
>+			doInputView(input);
>+		
>+		return DND.DROP_NONE;
>+	}
>+
>+	/**
>+	 * {@inheritDoc}
>+	 */
>+	public boolean isEnabled(DropTargetEvent event) {
>+		return true;
>+	}
>+
>+	/**
>+	 * {@inheritDoc}
>+	 */
>+	protected Object determineTarget(DropTargetEvent event) {
>+		if (event.item == null)
>+			return super.determineTarget(event);
>+		
>+		Point coordinates= getViewer().getControl().toControl(new Point(event.x, event.y));
>+		Rectangle bounds= getBounds((Item) event.item);
>+		if (coordinates.x < bounds.x - ITEM_MARGIN_LEFT || coordinates.x >= bounds.x + bounds.width + ITEM_MARGIN_RIGTH) {
>+			event.item= null; // too far away
>+			return null;
>+		}
>+		
>+		return super.determineTarget(event);
>+	}
>+
>+}

Actions: View | Diff

Attachments on bug 101993: 74682 | 74687