Attachment #74682 for bug #101993

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




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;

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;

			};

		// Drop Adapter
		DelegatingDropAdapter delegatingDropAdapter= new DelegatingDropAdapter();
		delegatingDropAdapter.addDropTargetListener(
			new SelectionTransferDropAdapter(fOutlineViewer)			
		);
		fOutlineViewer.addDropSupport(ops | DND.DROP_DEFAULT, transfers, delegatingDropAdapter);

		// Drag Adapter
		JdtViewerDragAdapter dragAdapter= new JdtViewerDragAdapter(fOutlineViewer);
		dragAdapter.addDragSourceListener(
			new SelectionTransferDragAdapter(fOutlineViewer)
		);
		fOutlineViewer.addDragSupport(ops, transfers, dragAdapter);
	}
	
	/**

Lines 17-22 Link Here

(-)ui/org/eclipse/jdt/internal/ui/packageview/FileTransferDropAdapter.java (-18 / +34 lines)
17	import org.eclipse.swt.dnd.DropTargetEvent;	17	import org.eclipse.swt.dnd.DropTargetEvent;
18	import org.eclipse.swt.dnd.FileTransfer;	18	import org.eclipse.swt.dnd.FileTransfer;
19	import org.eclipse.swt.dnd.Transfer;	19	import org.eclipse.swt.dnd.Transfer;
		20	import org.eclipse.swt.dnd.TransferData;
20	import org.eclipse.swt.widgets.Display;	21	import org.eclipse.swt.widgets.Display;
21	import org.eclipse.swt.widgets.Shell;	22	import org.eclipse.swt.widgets.Shell;
22		23
Lines 42-56 Link Here
42	class FileTransferDropAdapter extends JdtViewerDropAdapter implements TransferDropTargetListener {	43	class FileTransferDropAdapter extends JdtViewerDropAdapter implements TransferDropTargetListener {
43		44
44	FileTransferDropAdapter(AbstractTreeViewer viewer) {	45	FileTransferDropAdapter(AbstractTreeViewer viewer) {
45	super(viewer, DND.FEEDBACK_SCROLL \| DND.FEEDBACK_EXPAND);	46	super(viewer);
		47
		48	setScrollEnabled(true);
		49	setExpandEnabled(true);
		50	setFeedbackEnabled(false);
46	}	51	}
47		52
48	//---- TransferDropTargetListener interface ---------------------------------------	53	//---- TransferDropTargetListener interface ---------------------------------------
49		54
		55	/**
		56	* {@inheritDoc}
		57	*/
50	public Transfer getTransfer() {	58	public Transfer getTransfer() {
51	return FileTransfer.getInstance();	59	return FileTransfer.getInstance();
52	}	60	}
53		61
		62	/**
		63	* {@inheritDoc}
		64	*/
54	public boolean isEnabled(DropTargetEvent event) {	65	public boolean isEnabled(DropTargetEvent event) {
55	Object target= event.item != null ? event.item.getData() : null;	66	Object target= event.item != null ? event.item.getData() : null;
56	if (target == null)	67	if (target == null)
Lines 60-102 Link Here
60		71
61	//---- Actual DND -----------------------------------------------------------------	72	//---- Actual DND -----------------------------------------------------------------
62		73
63	public void validateDrop(Object target, DropTargetEvent event, int operation) {	74	/**
64	event.detail= DND.DROP_NONE;	75	* {@inheritDoc}
65		76	*/
		77	public int validateDrop(Object target, int operation, TransferData transferType) {
		78
66	boolean isPackageFragment= target instanceof IPackageFragment;	79	boolean isPackageFragment= target instanceof IPackageFragment;
67	boolean isJavaProject= target instanceof IJavaProject;	80	boolean isJavaProject= target instanceof IJavaProject;
68	boolean isPackageFragmentRoot= target instanceof IPackageFragmentRoot;	81	boolean isPackageFragmentRoot= target instanceof IPackageFragmentRoot;
69	boolean isContainer= target instanceof IContainer;	82	boolean isContainer= target instanceof IContainer;
70		83
71	if (!(isPackageFragment \|\| isJavaProject \|\| isPackageFragmentRoot \|\| isContainer))	84	if (!(isPackageFragment \|\| isJavaProject \|\| isPackageFragmentRoot \|\| isContainer))
72	return;	85	return DND.DROP_NONE;
73		86
74	if (isContainer) {	87	if (isContainer) {
75	IContainer container= (IContainer)target;	88	IContainer container= (IContainer)target;
76	if (container.isAccessible() && !Resources.isReadOnly(container))	89	if (container.isAccessible() && !Resources.isReadOnly(container))
77	event.detail= DND.DROP_COPY;	90	return DND.DROP_COPY;
78	} else {	91	} else {
79	IJavaElement element= (IJavaElement)target;	92	IJavaElement element= (IJavaElement)target;
80	if (!element.isReadOnly())	93	if (!element.isReadOnly())
81	event.detail= DND.DROP_COPY;	94	return DND.DROP_COPY;
82	}	95	}
83		96
84	return;	97	return DND.DROP_NONE;
85	}	98	}
86		99
87	public void drop(Object dropTarget, final DropTargetEvent event) {	100	/**
		101	* {@inheritDoc}
		102	*/
		103	public int performDrop(final Object data) {
88	try {	104	try {
89	int operation= event.detail;	105	int operation= getCurrentOperation();
90		106
91	event.detail= DND.DROP_NONE;
92	final Object data= event.data;
93	if (data == null \|\| !(data instanceof String[]) \|\| operation != DND.DROP_COPY)	107	if (data == null \|\| !(data instanceof String[]) \|\| operation != DND.DROP_COPY)
94	return;	108	return DND.DROP_NONE;
95		109
96	final IContainer target= getActualTarget(dropTarget);	110	final IContainer target= getActualTarget(getCurrentTarget());
97	if (target == null)	111	if (target == null)
98	return;	112	return DND.DROP_NONE;
99		113
100	// Run the import operation asynchronously.	114	// Run the import operation asynchronously.
101	// Otherwise the drag source (e.g., Windows Explorer) will be blocked	115	// Otherwise the drag source (e.g., Windows Explorer) will be blocked
102	// while the operation executes. Fixes bug 35796.	116	// while the operation executes. Fixes bug 35796.
Lines 104-118 Link Here
104	public void run() {	118	public void run() {
105	getShell().forceActive();	119	getShell().forceActive();
106	new CopyFilesAndFoldersOperation(getShell()).copyFiles((String[]) data, target);	120	new CopyFilesAndFoldersOperation(getShell()).copyFiles((String[]) data, target);
107	// Import always performs a copy.
108	event.detail= DND.DROP_COPY;
109	}	121	}
110	});	122	});
		123
		124	return DND.DROP_COPY;
111	} catch (JavaModelException e) {	125	} catch (JavaModelException e) {
112	String title= PackagesMessages.DropAdapter_errorTitle;	126	String title= PackagesMessages.DropAdapter_errorTitle;
113	String message= PackagesMessages.DropAdapter_errorMessage;	127	String message= PackagesMessages.DropAdapter_errorMessage;
114	ExceptionHandler.handle(e, getShell(), title, message);	128	ExceptionHandler.handle(e, getShell(), title, message);
115	}	129	}
		130
		131	return DND.DROP_NONE;
116	}	132	}
117		133
118	private IContainer getActualTarget(Object dropTarget) throws JavaModelException{	134	private IContainer getActualTarget(Object dropTarget) throws JavaModelException{




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;


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;

			LocalSelectionTransfer.getInstance(), 
			ResourceTransfer.getInstance(),
			FileTransfer.getInstance()};

		JdtViewerDragAdapter dragAdapter= new JdtViewerDragAdapter(fViewer);
		dragAdapter.addDragSourceListener(
			new SelectionTransferDragAdapter(fViewer)
		);
		dragAdapter.addDragSourceListener(
			new ResourceTransferDragAdapter(fViewer)
		);
		dragAdapter.addDragSourceListener(
			new FileTransferDragAdapter(fViewer)
		);
		fViewer.addDragSupport(ops, transfers, dragAdapter);
	}

	private void initDrop() {

		Transfer[] transfers= new Transfer[] {
			LocalSelectionTransfer.getInstance(), 
			FileTransfer.getInstance()};
		DelegatingDropAdapter delegatingDropAdapter= new DelegatingDropAdapter();
		delegatingDropAdapter.addDropTargetListener(
			new SelectionTransferDropAdapter(fViewer)
		);
		delegatingDropAdapter.addDropTargetListener(
			new FileTransferDropAdapter(fViewer)
		);
		delegatingDropAdapter.addDropTargetListener(	
			new WorkingSetDropAdapter(this)
		);
		fViewer.addDropSupport(ops, transfers, delegatingDropAdapter);
	}

	/**

Lines 18-23 Link Here

(-)ui/org/eclipse/jdt/internal/ui/packageview/SelectionTransferDropAdapter.java (-44 / +68 lines)
18	import org.eclipse.swt.dnd.DND;	18	import org.eclipse.swt.dnd.DND;
19	import org.eclipse.swt.dnd.DropTargetEvent;	19	import org.eclipse.swt.dnd.DropTargetEvent;
20	import org.eclipse.swt.dnd.Transfer;	20	import org.eclipse.swt.dnd.Transfer;
		21	import org.eclipse.swt.dnd.TransferData;
21	import org.eclipse.swt.widgets.Shell;	22	import org.eclipse.swt.widgets.Shell;
22		23
23	import org.eclipse.jface.util.TransferDropTargetListener;	24	import org.eclipse.jface.util.TransferDropTargetListener;
Lines 52-69 Link Here
52	private int fCanCopyElements;	53	private int fCanCopyElements;
53	private ISelection fSelection;	54	private ISelection fSelection;
54		55
55	private static final long DROP_TIME_DIFF_TRESHOLD= 150;
56
57	public SelectionTransferDropAdapter(StructuredViewer viewer) {	56	public SelectionTransferDropAdapter(StructuredViewer viewer) {
58	super(viewer, DND.FEEDBACK_SCROLL \| DND.FEEDBACK_EXPAND);	57	super(viewer);
		58
		59	setScrollEnabled(true);
		60	setExpandEnabled(true);
		61	setFeedbackEnabled(false);
59	}	62	}
60		63
61	//---- TransferDropTargetListener interface ---------------------------------------	64	//---- TransferDropTargetListener interface ---------------------------------------
62		65
		66	/**
		67	* {@inheritDoc}
		68	*/
63	public Transfer getTransfer() {	69	public Transfer getTransfer() {
64	return LocalSelectionTransfer.getInstance();	70	return LocalSelectionTransfer.getInstance();
65	}	71	}
66		72
		73	/**
		74	* {@inheritDoc}
		75	*/
67	public boolean isEnabled(DropTargetEvent event) {	76	public boolean isEnabled(DropTargetEvent event) {
68	Object target= event.item != null ? event.item.getData() : null;	77	Object target= event.item != null ? event.item.getData() : null;
69	if (target == null)	78	if (target == null)
Lines 73-83 Link Here
73		82
74	//---- Actual DND -----------------------------------------------------------------	83	//---- Actual DND -----------------------------------------------------------------
75		84
		85	/**
		86	* {@inheritDoc}
		87	*/
76	public void dragEnter(DropTargetEvent event) {	88	public void dragEnter(DropTargetEvent event) {
77	clear();	89	clear();
78	super.dragEnter(event);	90	super.dragEnter(event);
79	}	91	}
80		92
		93	/**
		94	* {@inheritDoc}
		95	*/
81	public void dragLeave(DropTargetEvent event) {	96	public void dragLeave(DropTargetEvent event) {
82	clear();	97	clear();
83	super.dragLeave(event);	98	super.dragLeave(event);
Lines 92-115 Link Here
92	fCanCopyElements= 0;	107	fCanCopyElements= 0;
93	}	108	}
94		109
95	public void validateDrop(Object target, DropTargetEvent event, int operation) {	110	/**
96	event.detail= DND.DROP_NONE;	111	* {@inheritDoc}
97		112	*/
98	if (tooFast(event))	113	public int validateDrop(Object target, int operation, TransferData transferType) {
99	return;
100		114
101	initializeSelection();	115	initializeSelection();
		116
		117	if (target == null)
		118	return DND.DROP_NONE;
		119
		120	//Do not allow to drop on itself, bug 14228
		121	if (fElements.size() == 1) {
		122	IJavaElement[] javaElements= ReorgUtils.getJavaElements(fElements);
		123	IResource[] resources= ReorgUtils.getResources(fElements);
		124
		125	if (javaElements.length == 1 && javaElements[0].equals(target))
		126	return DND.DROP_NONE;
		127
		128	if (resources.length == 1 && resources[0].equals(target))
		129	return DND.DROP_NONE;
		130	}
102		131
103	try {	132	try {
104	switch(operation) {	133	switch(operation) {
105	case DND.DROP_DEFAULT: event.detail= handleValidateDefault(target, event); break;	134	case DND.DROP_DEFAULT:
106	case DND.DROP_COPY: event.detail= handleValidateCopy(target, event); break;	135	return handleValidateDefault(target);
107	case DND.DROP_MOVE: event.detail= handleValidateMove(target, event); break;	136	case DND.DROP_COPY:
		137	return handleValidateCopy(target);
		138	case DND.DROP_MOVE:
		139	return handleValidateMove(target);
108	}	140	}
109	} catch (JavaModelException e){	141	} catch (JavaModelException e){
110	ExceptionHandler.handle(e, PackagesMessages.SelectionTransferDropAdapter_error_title, PackagesMessages.SelectionTransferDropAdapter_error_message);	142	ExceptionHandler.handle(e, PackagesMessages.SelectionTransferDropAdapter_error_title, PackagesMessages.SelectionTransferDropAdapter_error_message);
111	event.detail= DND.DROP_NONE;	143	}
112	}	144
		145	return DND.DROP_NONE;
113	}	146	}
114		147
115	protected void initializeSelection(){	148	protected void initializeSelection(){
Lines 125-140 Link Here
125	protected ISelection getSelection(){	158	protected ISelection getSelection(){
126	return fSelection;	159	return fSelection;
127	}	160	}
128
129	private boolean tooFast(DropTargetEvent event) {
130	return Math.abs(LocalSelectionTransfer.getInstance().getSelectionSetTime() - (event.time & 0xFFFFFFFFL)) < DROP_TIME_DIFF_TRESHOLD;
131	}
132		161
133	public void drop(Object target, DropTargetEvent event) {	162	/**
		163	* {@inheritDoc}
		164	*/
		165	public int performDrop(Object data) {
134	try{	166	try{
135	switch(event.detail) {	167	switch(getCurrentOperation()) {
136	case DND.DROP_MOVE: handleDropMove(target, event); break;	168	case DND.DROP_MOVE: handleDropMove(getCurrentTarget()); break;
137	case DND.DROP_COPY: handleDropCopy(target, event); break;	169	case DND.DROP_COPY: handleDropCopy(getCurrentTarget()); break;
138	}	170	}
139	} catch (JavaModelException e){	171	} catch (JavaModelException e){
140	ExceptionHandler.handle(e, PackagesMessages.SelectionTransferDropAdapter_error_title, PackagesMessages.SelectionTransferDropAdapter_error_message);	172	ExceptionHandler.handle(e, PackagesMessages.SelectionTransferDropAdapter_error_title, PackagesMessages.SelectionTransferDropAdapter_error_message);
Lines 142-172 Link Here
142	ExceptionHandler.handle(e, RefactoringMessages.OpenRefactoringWizardAction_refactoring, RefactoringMessages.OpenRefactoringWizardAction_exception);	174	ExceptionHandler.handle(e, RefactoringMessages.OpenRefactoringWizardAction_refactoring, RefactoringMessages.OpenRefactoringWizardAction_exception);
143	} catch (InterruptedException e) {	175	} catch (InterruptedException e) {
144	//ok	176	//ok
145	} finally {
146	// The drag source listener must not perform any operation
147	// since this drop adapter did the remove of the source even
148	// if we moved something.
149	event.detail= DND.DROP_NONE;
150	}	177	}
		178	// The drag source listener must not perform any operation
		179	// since this drop adapter did the remove of the source even
		180	// if we moved something.
		181	return DND.DROP_NONE;
		182
151	}	183	}
152		184
153	private int handleValidateDefault(Object target, DropTargetEvent event) throws JavaModelException{	185	private int handleValidateDefault(Object target) throws JavaModelException{
154	if (target == null)	186	int result= handleValidateMove(target);
155	return DND.DROP_NONE;	187	if (result != DND.DROP_NONE)
156		188	return result;
157	if ((event.operations & DND.DROP_MOVE) != 0) {	189
158	return handleValidateMove(target, event);	190	return handleValidateCopy(target);
159	}
160	if ((event.operations & DND.DROP_COPY) != 0) {
161	return handleValidateCopy(target, event);
162	}
163	return DND.DROP_NONE;
164	}	191	}
165		192
166	private int handleValidateMove(Object target, DropTargetEvent event) throws JavaModelException{	193	private int handleValidateMove(Object target) throws JavaModelException{
167	if (target == null)
168	return DND.DROP_NONE;
169
170	if (fMoveProcessor == null) {	194	if (fMoveProcessor == null) {
171	IMovePolicy policy= ReorgPolicyFactory.createMovePolicy(ReorgUtils.getResources(fElements), ReorgUtils.getJavaElements(fElements));	195	IMovePolicy policy= ReorgPolicyFactory.createMovePolicy(ReorgUtils.getResources(fElements), ReorgUtils.getJavaElements(fElements));
172	if (policy.canEnable())	196	if (policy.canEnable())
Lines 193-199 Link Here
193	return fCanMoveElements == 2;	217	return fCanMoveElements == 2;
194	}	218	}
195		219
196	private void handleDropMove(final Object target, DropTargetEvent event) throws JavaModelException, InvocationTargetException, InterruptedException{	220	private void handleDropMove(final Object target) throws JavaModelException, InvocationTargetException, InterruptedException{
197	IJavaElement[] javaElements= ReorgUtils.getJavaElements(fElements);	221	IJavaElement[] javaElements= ReorgUtils.getJavaElements(fElements);
198	IResource[] resources= ReorgUtils.getResources(fElements);	222	IResource[] resources= ReorgUtils.getResources(fElements);
199	ReorgMoveStarter starter= null;	223	ReorgMoveStarter starter= null;
Lines 205-211 Link Here
205	starter.run(getShell());	229	starter.run(getShell());
206	}	230	}
207		231
208	private int handleValidateCopy(Object target, DropTargetEvent event) throws JavaModelException{	232	private int handleValidateCopy(Object target) throws JavaModelException{
209		233
210	if (fCopyProcessor == null) {	234	if (fCopyProcessor == null) {
211	final ICopyPolicy policy= ReorgPolicyFactory.createCopyPolicy(ReorgUtils.getResources(fElements), ReorgUtils.getJavaElements(fElements));	235	final ICopyPolicy policy= ReorgPolicyFactory.createCopyPolicy(ReorgUtils.getResources(fElements), ReorgUtils.getJavaElements(fElements));
Lines 232-238 Link Here
232	return fCanCopyElements == 2;	256	return fCanCopyElements == 2;
233	}	257	}
234		258
235	private void handleDropCopy(final Object target, DropTargetEvent event) throws JavaModelException, InvocationTargetException, InterruptedException{	259	private void handleDropCopy(final Object target) throws JavaModelException, InvocationTargetException, InterruptedException{
236	IJavaElement[] javaElements= ReorgUtils.getJavaElements(fElements);	260	IJavaElement[] javaElements= ReorgUtils.getJavaElements(fElements);
237	IResource[] resources= ReorgUtils.getResources(fElements);	261	IResource[] resources= ReorgUtils.getResources(fElements);
238	ReorgCopyStarter starter= null;	262	ReorgCopyStarter starter= null;

Lines 26-31 Link Here

(-)ui/org/eclipse/jdt/internal/ui/packageview/WorkingSetDropAdapter.java (-17 / +37 lines)
26	import org.eclipse.swt.dnd.DND;	26	import org.eclipse.swt.dnd.DND;
27	import org.eclipse.swt.dnd.DropTargetEvent;	27	import org.eclipse.swt.dnd.DropTargetEvent;
28	import org.eclipse.swt.dnd.Transfer;	28	import org.eclipse.swt.dnd.Transfer;
		29	import org.eclipse.swt.dnd.TransferData;
29		30
30	import org.eclipse.jface.util.TransferDropTargetListener;	31	import org.eclipse.jface.util.TransferDropTargetListener;
31	import org.eclipse.jface.viewers.ISelection;	32	import org.eclipse.jface.viewers.ISelection;
Lines 55-70 Link Here
55	private IWorkingSet fWorkingSet;	56	private IWorkingSet fWorkingSet;
56		57
57	public WorkingSetDropAdapter(PackageExplorerPart part) {	58	public WorkingSetDropAdapter(PackageExplorerPart part) {
58	super(part.getTreeViewer(), DND.FEEDBACK_SCROLL \| DND.FEEDBACK_EXPAND);	59	super(part.getTreeViewer());
59	fPackageExplorer= part;	60	fPackageExplorer= part;
		61
		62	setScrollEnabled(true);
		63	setExpandEnabled(true);
		64	setFeedbackEnabled(false);
60	}	65	}
61		66
62	//---- TransferDropTargetListener interface ---------------------------------------	67	//---- TransferDropTargetListener interface ---------------------------------------
63		68
		69	/**
		70	* {@inheritDoc}
		71	*/
64	public Transfer getTransfer() {	72	public Transfer getTransfer() {
65	return LocalSelectionTransfer.getInstance();	73	return LocalSelectionTransfer.getInstance();
66	}	74	}
67		75
		76	/**
		77	* {@inheritDoc}
		78	*/
68	public boolean isEnabled(DropTargetEvent event) {	79	public boolean isEnabled(DropTargetEvent event) {
69	Object target= event.item != null ? event.item.getData() : null;	80	Object target= event.item != null ? event.item.getData() : null;
70	if (target == null)	81	if (target == null)
Lines 82-104 Link Here
82		93
83	//---- Actual DND -----------------------------------------------------------------	94	//---- Actual DND -----------------------------------------------------------------
84		95
85	public void validateDrop(Object target, DropTargetEvent event, int operation) {	96	/**
86	event.detail= DND.DROP_NONE;	97	* {@inheritDoc}
		98	*/
		99	public int validateDrop(Object target, int operation, TransferData transferType) {
87	switch(operation) {	100	switch(operation) {
88	case DND.DROP_DEFAULT:	101	case DND.DROP_DEFAULT:
89	case DND.DROP_COPY:	102	case DND.DROP_COPY:
90	case DND.DROP_MOVE:	103	case DND.DROP_MOVE:
91	event.detail= validateTarget(target, operation);	104	return validateTarget(target, operation);
92	break;	105	default:
93	case DND.DROP_LINK:	106	return DND.DROP_NONE;
94	event.detail= DND.DROP_NONE;
95	break;
96	}	107	}
		108
97	}	109	}
98		110
99	private int validateTarget(Object target, int operation) {	111	private int validateTarget(Object target, int operation) {
100	showInsertionFeedback(false);	112	setFeedbackEnabled(false);
101	setDefaultFeedback(DND.FEEDBACK_SCROLL \| DND.FEEDBACK_EXPAND);	113	setScrollEnabled(true);
		114	setExpandEnabled(true);
102	if (!isValidTarget(target))	115	if (!isValidTarget(target))
103	return DND.DROP_NONE;	116	return DND.DROP_NONE;
104	ISelection s= LocalSelectionTransfer.getInstance().getSelection();	117	ISelection s= LocalSelectionTransfer.getInstance().getSelection();
Lines 109-117 Link Here
109	initializeState(target, s);	122	initializeState(target, s);
110		123
111	if (isWorkingSetSelection()) {	124	if (isWorkingSetSelection()) {
112	setDefaultFeedback(DND.FEEDBACK_SCROLL);	125	setExpandEnabled(false);
113	if (fLocation == LOCATION_BEFORE \|\| fLocation == LOCATION_AFTER) {	126	if (getCurrentLocation() == LOCATION_BEFORE \|\| getCurrentLocation() == LOCATION_AFTER) {
114	showInsertionFeedback(true);	127	setFeedbackEnabled(true);
115	return DND.DROP_MOVE;	128	return DND.DROP_MOVE;
116	}	129	}
117	return DND.DROP_NONE;	130	return DND.DROP_NONE;
Lines 184-197 Link Here
184	return true;	197	return true;
185	}	198	}
186		199
187	public void drop(Object target, final DropTargetEvent event) {	200	/**
		201	* {@inheritDoc}
		202	*/
		203	public int performDrop(Object data) {
188	if (isWorkingSetSelection()) {	204	if (isWorkingSetSelection()) {
189	performWorkingSetReordering();	205	performWorkingSetReordering();
190	} else {	206	} else {
191	performElementRearrange(event.detail);	207	performElementRearrange(getCurrentOperation());
192	}	208	}
193	// drag adapter has nothing to do, even on move.	209	// drag adapter has nothing to do, even on move.
194	event.detail= DND.DROP_NONE;	210	return DND.DROP_NONE;
195	}	211	}
196		212
197	private void performWorkingSetReordering() {	213	private void performWorkingSetReordering() {
Lines 199-205 Link Here
199	List activeWorkingSets= new ArrayList(Arrays.asList(model.getActiveWorkingSets()));	215	List activeWorkingSets= new ArrayList(Arrays.asList(model.getActiveWorkingSets()));
200	int index= activeWorkingSets.indexOf(fWorkingSet);	216	int index= activeWorkingSets.indexOf(fWorkingSet);
201	if (index != -1) {	217	if (index != -1) {
202	if (fLocation == LOCATION_AFTER)	218	if (getCurrentLocation() == LOCATION_AFTER)
203	index++;	219	index++;
204	List result= new ArrayList(activeWorkingSets.size());	220	List result= new ArrayList(activeWorkingSets.size());
205	List selected= new ArrayList(Arrays.asList(fElementsToAdds));	221	List selected= new ArrayList(Arrays.asList(fElementsToAdds));
Lines 267-270 Link Here
267	performElementRearrange(eventDetail);	283	performElementRearrange(eventDetail);
268	}	284	}
269	}	285	}
		286
		287	public void internalTestSetLocation(int location) {
		288	setCurrentLocation(location);
		289	}
270	}	290	}




/*******************************************************************************
 * 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;
	}	
}




/*******************************************************************************
 * 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;
	}
}




/*******************************************************************************
 * 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

 *******************************************************************************/
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.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.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.Viewer;

/**
 * This adapter class provides generic drag-and-drop support for a viewer.
 * <p>
 * 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).
 * </p>
 * <p>
 * THIS IS (ALMOST) A ONE-TO-ONE COPY OF PLATFORMS ViewerDropAdapter
 * REFERE THERE FIRST IF YOU NEED TO FIX SOMETHING.
 * </p>
 */
public abstract class JdtViewerDropAdapter extends DropTargetAdapter {

	/**
	 * 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;
	}

    /**
     * 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.
     * <p>
     * Typical insertion feedback is the horizontal insertion bars that appear 
     * between adjacent items while dragging.
     * </p>
     *
     * @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.
     * <p>
     * [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.
     * ]
     * </p>
     *
     * @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.
     * <p>
     * Subclasses must implement this method to provide drop behavior.
     * </p>
     *
     * @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;
		}

		if (expandEnabled) {
			event.feedback |= DND.FEEDBACK_EXPAND;
	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 (scrollEnabled) {
			event.feedback |= DND.FEEDBACK_SCROLL;
		}
    }
	}

	/**
	 * 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 whether visible insertion feedback should be presented to the user.
	 * <p>
	 * Typical insertion feedback is the horizontal insertion bars that appear
	 * between adjacent items while dragging.
	 * </p>
	 * 
	 * @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.
     * <p>
     * Subclasses must implement this method to define which drops make sense.
     * </p>
     * 
     * @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;
	}
}

Lines 14-20 Link Here

(-)ui/org/eclipse/jdt/internal/ui/dnd/JdtViewerDragAdapter.java (-3 / +3 lines)
14		14
15	import org.eclipse.swt.dnd.DragSourceEvent;	15	import org.eclipse.swt.dnd.DragSourceEvent;
16		16
17	import org.eclipse.jface.util.TransferDragSourceListener;	17	import org.eclipse.jface.util.DelegatingDragAdapter;
18	import org.eclipse.jface.viewers.IStructuredSelection;	18	import org.eclipse.jface.viewers.IStructuredSelection;
19	import org.eclipse.jface.viewers.StructuredViewer;	19	import org.eclipse.jface.viewers.StructuredViewer;
20		20
Lines 22-29 Link Here
22		22
23	private StructuredViewer fViewer;	23	private StructuredViewer fViewer;
24		24
25	public JdtViewerDragAdapter(StructuredViewer viewer, TransferDragSourceListener[] listeners) {	25	public JdtViewerDragAdapter(StructuredViewer viewer) {
26	super(listeners);	26	super();
27	Assert.isNotNull(viewer);	27	Assert.isNotNull(viewer);
28	fViewer= viewer;	28	fViewer= viewer;
29	}	29	}




 *******************************************************************************/
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.dnd.ViewerInputDropAdapter;
import org.eclipse.jdt.internal.ui.util.SelectionUtil;

class CallHierarchyTransferDropAdapter extends ViewerInputDropAdapter {
	
	private static final int OPERATION = DND.DROP_LINK;
	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;
	}
	
	/**
	 * {@inheritDoc}
	 */
	protected void doInputView(Object inputElement) {
		fCallHierarchyViewPart.setMethod((IMethod) inputElement);
	}

	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);
	}
	
	/**
	 * {@inheritDoc}
	 */
	protected Object getInputElement(ISelection selection) {
		Object single= SelectionUtil.getSingleElement(selection);
		if (single == null)
			return null;
		
		return getCandidate(single);
	}
    
    private static IMethod getCandidate(Object input) {
        if (!(input instanceof IMethod))
     */ 
    public static IMethod getCandidate(Object input) {
        if (!(input instanceof IMethod)) {
            return null;
        
        return (IMethod) input;
    }
}




import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.util.DelegatingDropAdapter;
import org.eclipse.jface.util.TransferDropTargetListener;
import org.eclipse.jface.viewers.IOpenListener;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;

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;

		Transfer[] transfers= new Transfer[] { LocalSelectionTransfer.getInstance() };
		int ops= DND.DROP_MOVE | DND.DROP_COPY | DND.DROP_LINK | DND.DROP_DEFAULT;
		
		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()};

		JdtViewerDragAdapter dragAdapter= new JdtViewerDragAdapter(viewer);
		dragAdapter.addDragSourceListener(
			new SelectionTransferDragAdapter(viewer)
		);
		dragAdapter.addDragSourceListener(
			new ResourceTransferDragAdapter(viewer)
		);
		viewer.addDragSupport(ops, transfers, dragAdapter);
	}	
            
    public void createPartControl(Composite parent) {




 *******************************************************************************/
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.dnd.ViewerInputDropAdapter;
import org.eclipse.jdt.internal.ui.util.OpenTypeHierarchyUtil;
import org.eclipse.jdt.internal.ui.util.SelectionUtil;

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;
	}
		
	/**
	 * {@inheritDoc}
	 */
	protected void doInputView(Object inputElement) {
		fTypeHierarchyViewPart.setInputElement((IJavaElement) inputElement);
	}	

	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);
	}
	
	/**
	 * {@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;
	}

}




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;

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;

		Transfer[] transfers= new Transfer[] { LocalSelectionTransfer.getInstance() };
		int ops= DND.DROP_MOVE | DND.DROP_COPY | DND.DROP_LINK | DND.DROP_DEFAULT;
		
		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()};

		JdtViewerDragAdapter dragAdapter= new JdtViewerDragAdapter(viewer);
		dragAdapter.addDragSourceListener(
			new SelectionTransferDragAdapter(viewer)
		);
		dragAdapter.addDragSourceListener(
			new ResourceTransferDragAdapter(viewer)
		);
		viewer.addDragSupport(ops, transfers, dragAdapter);
	}	
			
	/**




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;

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;

		Transfer[] dropTransfers= new Transfer[] {
			LocalSelectionTransfer.getInstance()
		};
		DelegatingDropAdapter delegatingDropAdapter= new DelegatingDropAdapter();
		delegatingDropAdapter.addDropTargetListener(
			new SelectionTransferDropAdapter(fViewer)
		);
		fViewer.addDropSupport(ops | DND.DROP_DEFAULT, dropTransfers, delegatingDropAdapter);

		// Drag
		Transfer[] dragTransfers= new Transfer[] {
			LocalSelectionTransfer.getInstance(),
			ResourceTransfer.getInstance()};
		
		JdtViewerDragAdapter dragAdapter= new JdtViewerDragAdapter(fViewer);
		dragAdapter.addDragSourceListener(
			new SelectionTransferDragAdapter(fViewer)
		);
		dragAdapter.addDragSourceListener(
			new ResourceTransferDragAdapter(fViewer)
		);
		fViewer.addDragSupport(ops, dragTransfers, dragAdapter);
	}

	protected void fillActionBars(IActionBars actionBars) {




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;

		Transfer[] transfers= new Transfer[] { LocalSelectionTransfer.getInstance(), ResourceTransfer.getInstance() };
		int ops= DND.DROP_COPY | DND.DROP_LINK;
		
		JdtViewerDragAdapter dragAdapter= new JdtViewerDragAdapter(viewer);
		dragAdapter.addDragSourceListener(
			new SelectionTransferDragAdapter(viewer)
		);
		dragAdapter.addDragSourceListener(
			new ResourceTransferDragAdapter(viewer)
		);
		viewer.addDragSupport(ops, transfers, dragAdapter);
		viewer.addDragSupport(ops, transfers, new JdtViewerDragAdapter(viewer, dragListeners));
	}	

	protected void configureTableViewer(TableViewer viewer) {




/*******************************************************************************
 * 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);
	}

}

Return to bug 101993

Lines 43-52 Link Here

(-)ui/org/eclipse/jdt/internal/ui/javaeditor/JavaOutlinePage.java (-10 / +10 lines)
43	import org.eclipse.jface.action.MenuManager;	43	import org.eclipse.jface.action.MenuManager;
44	import org.eclipse.jface.action.Separator;	44	import org.eclipse.jface.action.Separator;
45	import org.eclipse.jface.preference.IPreferenceStore;	45	import org.eclipse.jface.preference.IPreferenceStore;
		46	import org.eclipse.jface.util.DelegatingDropAdapter;
46	import org.eclipse.jface.util.IPropertyChangeListener;	47	import org.eclipse.jface.util.IPropertyChangeListener;
47	import org.eclipse.jface.util.PropertyChangeEvent;	48	import org.eclipse.jface.util.PropertyChangeEvent;
48	import org.eclipse.jface.util.TransferDragSourceListener;
49	import org.eclipse.jface.util.TransferDropTargetListener;
50	import org.eclipse.jface.viewers.IBaseLabelProvider;	49	import org.eclipse.jface.viewers.IBaseLabelProvider;
51	import org.eclipse.jface.viewers.IPostSelectionProvider;	50	import org.eclipse.jface.viewers.IPostSelectionProvider;
52	import org.eclipse.jface.viewers.ISelection;	51	import org.eclipse.jface.viewers.ISelection;
Lines 121-127 Link Here
121	import org.eclipse.jdt.internal.ui.actions.AbstractToggleLinkingAction;	120	import org.eclipse.jdt.internal.ui.actions.AbstractToggleLinkingAction;
122	import org.eclipse.jdt.internal.ui.actions.CategoryFilterActionGroup;	121	import org.eclipse.jdt.internal.ui.actions.CategoryFilterActionGroup;
123	import org.eclipse.jdt.internal.ui.actions.CompositeActionGroup;	122	import org.eclipse.jdt.internal.ui.actions.CompositeActionGroup;
124	import org.eclipse.jdt.internal.ui.dnd.DelegatingDropAdapter;
125	import org.eclipse.jdt.internal.ui.dnd.JdtViewerDragAdapter;	123	import org.eclipse.jdt.internal.ui.dnd.JdtViewerDragAdapter;
126	import org.eclipse.jdt.internal.ui.packageview.SelectionTransferDragAdapter;	124	import org.eclipse.jdt.internal.ui.packageview.SelectionTransferDragAdapter;
127	import org.eclipse.jdt.internal.ui.packageview.SelectionTransferDropAdapter;	125	import org.eclipse.jdt.internal.ui.packageview.SelectionTransferDropAdapter;
Lines 1348-1363 Link Here
1348	};	1346	};
1349		1347
1350	// Drop Adapter	1348	// Drop Adapter
1351	TransferDropTargetListener[] dropListeners= new TransferDropTargetListener[] {	1349	DelegatingDropAdapter delegatingDropAdapter= new DelegatingDropAdapter();
1352	new SelectionTransferDropAdapter(fOutlineViewer)	1350	delegatingDropAdapter.addDropTargetListener(
1353	};	1351	new SelectionTransferDropAdapter(fOutlineViewer)
1354	fOutlineViewer.addDropSupport(ops \| DND.DROP_DEFAULT, transfers, new DelegatingDropAdapter(dropListeners));	1352	);
		1353	fOutlineViewer.addDropSupport(ops \| DND.DROP_DEFAULT, transfers, delegatingDropAdapter);
1355		1354
1356	// Drag Adapter	1355	// Drag Adapter
1357	TransferDragSourceListener[] dragListeners= new TransferDragSourceListener[] {	1356	JdtViewerDragAdapter dragAdapter= new JdtViewerDragAdapter(fOutlineViewer);
		1357	dragAdapter.addDragSourceListener(
1358	new SelectionTransferDragAdapter(fOutlineViewer)	1358	new SelectionTransferDragAdapter(fOutlineViewer)
1359	};	1359	);
1360	fOutlineViewer.addDragSupport(ops, transfers, new JdtViewerDragAdapter(fOutlineViewer, dragListeners));	1360	fOutlineViewer.addDragSupport(ops, transfers, dragAdapter);
1361	}	1361	}
1362		1362
1363	/**	1363	/**

Lines 55-64 Link Here

(-)ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java (-13 / +22 lines)
55	import org.eclipse.jface.dialogs.IDialogSettings;	55	import org.eclipse.jface.dialogs.IDialogSettings;
56	import org.eclipse.jface.dialogs.MessageDialog;	56	import org.eclipse.jface.dialogs.MessageDialog;
57	import org.eclipse.jface.preference.IPreferenceStore;	57	import org.eclipse.jface.preference.IPreferenceStore;
		58	import org.eclipse.jface.util.DelegatingDropAdapter;
58	import org.eclipse.jface.util.IPropertyChangeListener;	59	import org.eclipse.jface.util.IPropertyChangeListener;
59	import org.eclipse.jface.util.PropertyChangeEvent;	60	import org.eclipse.jface.util.PropertyChangeEvent;
60	import org.eclipse.jface.util.TransferDragSourceListener;
61	import org.eclipse.jface.util.TransferDropTargetListener;
62	import org.eclipse.jface.viewers.AbstractTreeViewer;	61	import org.eclipse.jface.viewers.AbstractTreeViewer;
63	import org.eclipse.jface.viewers.DoubleClickEvent;	62	import org.eclipse.jface.viewers.DoubleClickEvent;
64	import org.eclipse.jface.viewers.IContentProvider;	63	import org.eclipse.jface.viewers.IContentProvider;
Lines 137-143 Link Here
137		136
138	import org.eclipse.jdt.internal.ui.IJavaHelpContextIds;	137	import org.eclipse.jdt.internal.ui.IJavaHelpContextIds;
139	import org.eclipse.jdt.internal.ui.JavaPlugin;	138	import org.eclipse.jdt.internal.ui.JavaPlugin;
140	import org.eclipse.jdt.internal.ui.dnd.DelegatingDropAdapter;
141	import org.eclipse.jdt.internal.ui.dnd.JdtViewerDragAdapter;	139	import org.eclipse.jdt.internal.ui.dnd.JdtViewerDragAdapter;
142	import org.eclipse.jdt.internal.ui.dnd.ResourceTransferDragAdapter;	140	import org.eclipse.jdt.internal.ui.dnd.ResourceTransferDragAdapter;
143	import org.eclipse.jdt.internal.ui.filters.OutputFolderFilter;	141	import org.eclipse.jdt.internal.ui.filters.OutputFolderFilter;
Lines 893-904 Link Here
893	LocalSelectionTransfer.getInstance(),	891	LocalSelectionTransfer.getInstance(),
894	ResourceTransfer.getInstance(),	892	ResourceTransfer.getInstance(),
895	FileTransfer.getInstance()};	893	FileTransfer.getInstance()};
896	TransferDragSourceListener[] dragListeners= new TransferDragSourceListener[] {	894
897	new SelectionTransferDragAdapter(fViewer),	895	JdtViewerDragAdapter dragAdapter= new JdtViewerDragAdapter(fViewer);
898	new ResourceTransferDragAdapter(fViewer),	896	dragAdapter.addDragSourceListener(
		897	new SelectionTransferDragAdapter(fViewer)
		898	);
		899	dragAdapter.addDragSourceListener(
		900	new ResourceTransferDragAdapter(fViewer)
		901	);
		902	dragAdapter.addDragSourceListener(
899	new FileTransferDragAdapter(fViewer)	903	new FileTransferDragAdapter(fViewer)
900	};	904	);
901	fViewer.addDragSupport(ops, transfers, new JdtViewerDragAdapter(fViewer, dragListeners));	905	fViewer.addDragSupport(ops, transfers, dragAdapter);
902	}	906	}
903		907
904	private void initDrop() {	908	private void initDrop() {
Lines 906-917 Link Here
906	Transfer[] transfers= new Transfer[] {	910	Transfer[] transfers= new Transfer[] {
907	LocalSelectionTransfer.getInstance(),	911	LocalSelectionTransfer.getInstance(),
908	FileTransfer.getInstance()};	912	FileTransfer.getInstance()};
909	TransferDropTargetListener[] dropListeners= new TransferDropTargetListener[] {	913	DelegatingDropAdapter delegatingDropAdapter= new DelegatingDropAdapter();
910	new SelectionTransferDropAdapter(fViewer),	914	delegatingDropAdapter.addDropTargetListener(
911	new FileTransferDropAdapter(fViewer),	915	new SelectionTransferDropAdapter(fViewer)
		916	);
		917	delegatingDropAdapter.addDropTargetListener(
		918	new FileTransferDropAdapter(fViewer)
		919	);
		920	delegatingDropAdapter.addDropTargetListener(
912	new WorkingSetDropAdapter(this)	921	new WorkingSetDropAdapter(this)
913	};	922	);
914	fViewer.addDropSupport(ops, transfers, new DelegatingDropAdapter(dropListeners));	923	fViewer.addDropSupport(ops, transfers, delegatingDropAdapter);
915	}	924	}
916		925
917	/**	926	/**

Removed Link Here

(-)ui/org/eclipse/jdt/internal/ui/dnd/DelegatingDragAdapter.java (-117 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.jdt.internal.ui.dnd;
12
13	import java.util.ArrayList;
14	import java.util.Iterator;
15	import java.util.List;
16
17	import org.eclipse.core.runtime.Assert;
18
19	import org.eclipse.swt.dnd.DragSource;
20	import org.eclipse.swt.dnd.DragSourceEvent;
21	import org.eclipse.swt.dnd.DragSourceListener;
22	import org.eclipse.swt.dnd.Transfer;
23	import org.eclipse.swt.dnd.TransferData;
24
25	import org.eclipse.jface.util.TransferDragSourceListener;
26
27	/**
28	* A delegating drag adapter negotiates between a set of <code>TransferDragSourceListener</code>s
29	* On <code>dragStart</code> the adapter determines the listener to be used for any further
30	* <code>drag*</code> callback.
31	*/
32	public class DelegatingDragAdapter implements DragSourceListener {
33
34	private TransferDragSourceListener[] fPossibleListeners;
35	private List fActiveListeners;
36	private TransferDragSourceListener fFinishListener;
37
38	public DelegatingDragAdapter(TransferDragSourceListener[] listeners) {
39	setPossibleListeners(listeners);
40	}
41
42	protected void setPossibleListeners(TransferDragSourceListener[] listeners) {
43	Assert.isNotNull(listeners);
44	Assert.isTrue(fActiveListeners == null, "Can only set possible listeners before drag operation has started"); //$NON-NLS-1$
45	fPossibleListeners= listeners;
46	}
47
48	/* non Java-doc
49	* @see DragSourceListener
50	*/
51	public void dragStart(DragSourceEvent event) {
52	fFinishListener= null;
53	boolean saveDoit= event.doit;
54	Object saveData= event.data;
55	boolean doIt= false;
56	List transfers= new ArrayList(fPossibleListeners.length);
57	fActiveListeners= new ArrayList(fPossibleListeners.length);
58
59	for (int i= 0; i < fPossibleListeners.length; i++) {
60	TransferDragSourceListener listener= fPossibleListeners[i];
61	event.doit= saveDoit;
62	listener.dragStart(event);
63	if (event.doit) {
64	transfers.add(listener.getTransfer());
65	fActiveListeners.add(listener);
66	}
67	doIt= doIt \|\| event.doit;
68	}
69	if (doIt) {
70	((DragSource)event.widget).setTransfer((Transfer[])transfers.toArray(new Transfer[transfers.size()]));
71	}
72	event.data= saveData;
73	event.doit= doIt;
74	}
75
76	/* non Java-doc
77	* @see DragSourceListener
78	*/
79	public void dragSetData(DragSourceEvent event) {
80	fFinishListener= getListener(event.dataType);
81	if (fFinishListener != null)
82	fFinishListener.dragSetData(event);
83	}
84
85	/* non Java-doc
86	* @see DragSourceListener
87	*/
88	public void dragFinished(DragSourceEvent event) {
89	try{
90	if (fFinishListener != null) {
91	fFinishListener.dragFinished(event);
92	} else {
93	// If the user presses Escape then we get a dragFinished without
94	// getting a dragSetData before.
95	fFinishListener= getListener(event.dataType);
96	if (fFinishListener != null)
97	fFinishListener.dragFinished(event);
98	}
99	} finally{
100	fFinishListener= null;
101	fActiveListeners= null;
102	}
103	}
104
105	private TransferDragSourceListener getListener(TransferData type) {
106	if (type == null)
107	return null;
108
109	for (Iterator iter= fActiveListeners.iterator(); iter.hasNext();) {
110	TransferDragSourceListener listener= (TransferDragSourceListener)iter.next();
111	if (listener.getTransfer().isSupportedType(type)) {
112	return listener;
113	}
114	}
115	return null;
116	}
117	}

Lines 11-79 Link Here

(-)ui/org/eclipse/jdt/internal/ui/callhierarchy/CallHierarchyTransferDropAdapter.java (-40 / +16 lines)
11	*******************************************************************************/	11	*******************************************************************************/
12	package org.eclipse.jdt.internal.ui.callhierarchy;	12	package org.eclipse.jdt.internal.ui.callhierarchy;
13		13
14	import org.eclipse.swt.dnd.DND;
15	import org.eclipse.swt.dnd.DropTargetEvent;
16
17	import org.eclipse.jface.viewers.ISelection;	14	import org.eclipse.jface.viewers.ISelection;
18	import org.eclipse.jface.viewers.StructuredViewer;	15	import org.eclipse.jface.viewers.StructuredViewer;
19		16
20	import org.eclipse.jdt.core.IMethod;	17	import org.eclipse.jdt.core.IMethod;
21		18
22	import org.eclipse.jdt.internal.ui.packageview.SelectionTransferDropAdapter;	19	import org.eclipse.jdt.internal.ui.dnd.ViewerInputDropAdapter;
23	import org.eclipse.jdt.internal.ui.util.SelectionUtil;	20	import org.eclipse.jdt.internal.ui.util.SelectionUtil;
24		21
25	class CallHierarchyTransferDropAdapter extends SelectionTransferDropAdapter {	22	class CallHierarchyTransferDropAdapter extends ViewerInputDropAdapter {
26		23
27	private static final int OPERATION = DND.DROP_LINK;
28	private CallHierarchyViewPart fCallHierarchyViewPart;	24	private CallHierarchyViewPart fCallHierarchyViewPart;
29		25
30	public CallHierarchyTransferDropAdapter(CallHierarchyViewPart viewPart, StructuredViewer viewer) {	26	public CallHierarchyTransferDropAdapter(CallHierarchyViewPart viewPart, StructuredViewer viewer) {
31	super(viewer);	27	super(viewer);
32	setFullWidthMatchesItem(false);
33	fCallHierarchyViewPart= viewPart;	28	fCallHierarchyViewPart= viewPart;
34	}	29	}
35
36	public void validateDrop(Object target, DropTargetEvent event, int operation) {
37	event.detail= DND.DROP_NONE;
38	initializeSelection();
39	if (target != null){
40	super.validateDrop(target, event, operation);
41	return;
42	}
43	if (getInputElement(getSelection()) != null)
44	event.detail= OPERATION;
45	}
46		30
47	/* (non-Javadoc)	31	/**
48	* @see org.eclipse.jdt.internal.ui.packageview.SelectionTransferDropAdapter#isEnabled(org.eclipse.swt.dnd.DropTargetEvent)	32	* {@inheritDoc}
49	*/	33	*/
50	public boolean isEnabled(DropTargetEvent event) {	34	protected void doInputView(Object inputElement) {
51	return true;	35	fCallHierarchyViewPart.setMethod((IMethod) inputElement);
52	}
53
54	public void drop(Object target, DropTargetEvent event) {
55	if (target != null \|\| event.detail != OPERATION){
56	super.drop(target, event);
57	return;
58	}
59	IMethod input= getInputElement(getSelection());
60	fCallHierarchyViewPart.setMethod(input);
61	}	36	}
62		37
63	private static IMethod getInputElement(ISelection selection) {	38	/**
		39	* {@inheritDoc}
		40	*/
		41	protected Object getInputElement(ISelection selection) {
64	Object single= SelectionUtil.getSingleElement(selection);	42	Object single= SelectionUtil.getSingleElement(selection);
65	if (single == null)	43	if (single == null)
66	return null;	44	return null;
		45
67	return getCandidate(single);	46	return getCandidate(single);
68	}	47	}
69		48
70	/**	49	private static IMethod getCandidate(Object input) {
71	* Converts the input to a possible input candidates	50	if (!(input instanceof IMethod))
72	*/
73	public static IMethod getCandidate(Object input) {
74	if (!(input instanceof IMethod)) {
75	return null;	51	return null;
76	}	52
77	return (IMethod) input;	53	return (IMethod) input;
78	}	54	}
79	}	55	}

Lines 10-72 Link Here

(-)ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyTransferDropAdapter.java (-32 / +13 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.jdt.internal.ui.typehierarchy;	11	package org.eclipse.jdt.internal.ui.typehierarchy;
12		12
13	import org.eclipse.swt.dnd.DND;
14	import org.eclipse.swt.dnd.DropTargetEvent;
15
16	import org.eclipse.jface.viewers.AbstractTreeViewer;	13	import org.eclipse.jface.viewers.AbstractTreeViewer;
17	import org.eclipse.jface.viewers.ISelection;	14	import org.eclipse.jface.viewers.ISelection;
18		15
19	import org.eclipse.jdt.core.IJavaElement;	16	import org.eclipse.jdt.core.IJavaElement;
20		17
21	import org.eclipse.jdt.internal.ui.packageview.SelectionTransferDropAdapter;	18	import org.eclipse.jdt.internal.ui.dnd.ViewerInputDropAdapter;
22	import org.eclipse.jdt.internal.ui.util.OpenTypeHierarchyUtil;	19	import org.eclipse.jdt.internal.ui.util.OpenTypeHierarchyUtil;
23	import org.eclipse.jdt.internal.ui.util.SelectionUtil;	20	import org.eclipse.jdt.internal.ui.util.SelectionUtil;
24		21
25	public class TypeHierarchyTransferDropAdapter extends SelectionTransferDropAdapter {	22	public class TypeHierarchyTransferDropAdapter extends ViewerInputDropAdapter {
26		23
27	private static final int OPERATION = DND.DROP_LINK;
28	private TypeHierarchyViewPart fTypeHierarchyViewPart;	24	private TypeHierarchyViewPart fTypeHierarchyViewPart;
29		25
30	public TypeHierarchyTransferDropAdapter(TypeHierarchyViewPart viewPart, AbstractTreeViewer viewer) {	26	public TypeHierarchyTransferDropAdapter(TypeHierarchyViewPart viewPart, AbstractTreeViewer viewer) {
31	super(viewer);	27	super(viewer);
32	setFullWidthMatchesItem(false);
33	fTypeHierarchyViewPart= viewPart;	28	fTypeHierarchyViewPart= viewPart;
34	}	29	}
35
36	public void validateDrop(Object target, DropTargetEvent event, int operation) {
37	event.detail= DND.DROP_NONE;
38	initializeSelection();
39	if (target != null){
40	super.validateDrop(target, event, operation);
41	return;
42	}
43	if (getInputElement(getSelection()) != null)
44	event.detail= TypeHierarchyTransferDropAdapter.OPERATION;
45	}
46		30
47	/* (non-Javadoc)	31	/**
48	* @see org.eclipse.jdt.internal.ui.packageview.SelectionTransferDropAdapter#isEnabled(org.eclipse.swt.dnd.DropTargetEvent)	32	* {@inheritDoc}
49	*/	33	*/
50	public boolean isEnabled(DropTargetEvent event) {	34	protected void doInputView(Object inputElement) {
51	return true;	35	fTypeHierarchyViewPart.setInputElement((IJavaElement) inputElement);
52	}
53
54	public void drop(Object target, DropTargetEvent event) {
55	if (target != null \|\| event.detail != TypeHierarchyTransferDropAdapter.OPERATION){
56	super.drop(target, event);
57	return;
58	}
59	IJavaElement input= getInputElement(getSelection());
60	fTypeHierarchyViewPart.setInputElement(input);
61	}	36	}
62		37
63	private static IJavaElement getInputElement(ISelection selection) {	38	/**
		39	* {@inheritDoc}
		40	*/
		41	protected Object getInputElement(ISelection selection) {
64	Object single= SelectionUtil.getSingleElement(selection);	42	Object single= SelectionUtil.getSingleElement(selection);
65	if (single == null)	43	if (single == null)
66	return null;	44	return null;
		45
67	IJavaElement[] candidates= OpenTypeHierarchyUtil.getCandidates(single);	46	IJavaElement[] candidates= OpenTypeHierarchyUtil.getCandidates(single);
68	if (candidates != null && candidates.length > 0)	47	if (candidates != null && candidates.length > 0)
69	return candidates[0];	48	return candidates[0];
		49
70	return null;	50	return null;
71	}	51	}
		52
72	}	53	}

Lines 56-65 Link Here

(-)ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java (-11 / +13 lines)
56	import org.eclipse.jface.action.ToolBarManager;	56	import org.eclipse.jface.action.ToolBarManager;
57	import org.eclipse.jface.dialogs.IDialogSettings;	57	import org.eclipse.jface.dialogs.IDialogSettings;
58	import org.eclipse.jface.dialogs.MessageDialog;	58	import org.eclipse.jface.dialogs.MessageDialog;
		59	import org.eclipse.jface.util.DelegatingDropAdapter;
59	import org.eclipse.jface.util.IPropertyChangeListener;	60	import org.eclipse.jface.util.IPropertyChangeListener;
60	import org.eclipse.jface.util.PropertyChangeEvent;	61	import org.eclipse.jface.util.PropertyChangeEvent;
61	import org.eclipse.jface.util.TransferDragSourceListener;
62	import org.eclipse.jface.util.TransferDropTargetListener;
63	import org.eclipse.jface.viewers.AbstractTreeViewer;	62	import org.eclipse.jface.viewers.AbstractTreeViewer;
64	import org.eclipse.jface.viewers.IBasicPropertyConstants;	63	import org.eclipse.jface.viewers.IBasicPropertyConstants;
65	import org.eclipse.jface.viewers.ISelection;	64	import org.eclipse.jface.viewers.ISelection;
Lines 122-128 Link Here
122	import org.eclipse.jdt.internal.ui.actions.CompositeActionGroup;	121	import org.eclipse.jdt.internal.ui.actions.CompositeActionGroup;
123	import org.eclipse.jdt.internal.ui.actions.NewWizardsActionGroup;	122	import org.eclipse.jdt.internal.ui.actions.NewWizardsActionGroup;
124	import org.eclipse.jdt.internal.ui.actions.SelectAllAction;	123	import org.eclipse.jdt.internal.ui.actions.SelectAllAction;
125	import org.eclipse.jdt.internal.ui.dnd.DelegatingDropAdapter;
126	import org.eclipse.jdt.internal.ui.dnd.JdtViewerDragAdapter;	124	import org.eclipse.jdt.internal.ui.dnd.JdtViewerDragAdapter;
127	import org.eclipse.jdt.internal.ui.dnd.ResourceTransferDragAdapter;	125	import org.eclipse.jdt.internal.ui.dnd.ResourceTransferDragAdapter;
128	import org.eclipse.jdt.internal.ui.javaeditor.EditorUtility;	126	import org.eclipse.jdt.internal.ui.javaeditor.EditorUtility;
Lines 736-756 Link Here
736	Transfer[] transfers= new Transfer[] { LocalSelectionTransfer.getInstance() };	734	Transfer[] transfers= new Transfer[] { LocalSelectionTransfer.getInstance() };
737	int ops= DND.DROP_MOVE \| DND.DROP_COPY \| DND.DROP_LINK \| DND.DROP_DEFAULT;	735	int ops= DND.DROP_MOVE \| DND.DROP_COPY \| DND.DROP_LINK \| DND.DROP_DEFAULT;
738		736
739	TransferDropTargetListener[] dropListeners= new TransferDropTargetListener[] {	737	DelegatingDropAdapter delegatingDropAdapter= new DelegatingDropAdapter();
740	new TypeHierarchyTransferDropAdapter(this, viewer)	738	delegatingDropAdapter.addDropTargetListener(
741	};	739	new TypeHierarchyTransferDropAdapter(this, viewer)
742	viewer.addDropSupport(ops, transfers, new DelegatingDropAdapter(dropListeners));	740	);
		741	viewer.addDropSupport(ops, transfers, delegatingDropAdapter);
743	}	742	}
744		743
745	private void addDragAdapters(StructuredViewer viewer) {	744	private void addDragAdapters(StructuredViewer viewer) {
746	int ops= DND.DROP_COPY \| DND.DROP_LINK;	745	int ops= DND.DROP_COPY \| DND.DROP_LINK;
747	Transfer[] transfers= new Transfer[] { LocalSelectionTransfer.getInstance(), ResourceTransfer.getInstance()};	746	Transfer[] transfers= new Transfer[] { LocalSelectionTransfer.getInstance(), ResourceTransfer.getInstance()};
748		747
749	TransferDragSourceListener[] dragListeners= new TransferDragSourceListener[] {	748	JdtViewerDragAdapter dragAdapter= new JdtViewerDragAdapter(viewer);
750	new SelectionTransferDragAdapter(viewer),	749	dragAdapter.addDragSourceListener(
		750	new SelectionTransferDragAdapter(viewer)
		751	);
		752	dragAdapter.addDragSourceListener(
751	new ResourceTransferDragAdapter(viewer)	753	new ResourceTransferDragAdapter(viewer)
752	};	754	);
753	viewer.addDragSupport(ops, transfers, new JdtViewerDragAdapter(viewer, dragListeners));	755	viewer.addDragSupport(ops, transfers, dragAdapter);
754	}	756	}
755		757
756	/**	758	/**

Lines 43-52 Link Here

(-)ui/org/eclipse/jdt/internal/ui/browsing/JavaBrowsingPart.java (-10 / +13 lines)
43	import org.eclipse.jface.action.IStatusLineManager;	43	import org.eclipse.jface.action.IStatusLineManager;
44	import org.eclipse.jface.action.IToolBarManager;	44	import org.eclipse.jface.action.IToolBarManager;
45	import org.eclipse.jface.action.MenuManager;	45	import org.eclipse.jface.action.MenuManager;
		46	import org.eclipse.jface.util.DelegatingDropAdapter;
46	import org.eclipse.jface.util.IPropertyChangeListener;	47	import org.eclipse.jface.util.IPropertyChangeListener;
47	import org.eclipse.jface.util.PropertyChangeEvent;	48	import org.eclipse.jface.util.PropertyChangeEvent;
48	import org.eclipse.jface.util.TransferDragSourceListener;
49	import org.eclipse.jface.util.TransferDropTargetListener;
50	import org.eclipse.jface.viewers.IContentProvider;	49	import org.eclipse.jface.viewers.IContentProvider;
51	import org.eclipse.jface.viewers.ILabelProvider;	50	import org.eclipse.jface.viewers.ILabelProvider;
52	import org.eclipse.jface.viewers.IOpenListener;	51	import org.eclipse.jface.viewers.IOpenListener;
Lines 120-126 Link Here
120	import org.eclipse.jdt.internal.ui.JavaPlugin;	119	import org.eclipse.jdt.internal.ui.JavaPlugin;
121	import org.eclipse.jdt.internal.ui.actions.CompositeActionGroup;	120	import org.eclipse.jdt.internal.ui.actions.CompositeActionGroup;
122	import org.eclipse.jdt.internal.ui.actions.NewWizardsActionGroup;	121	import org.eclipse.jdt.internal.ui.actions.NewWizardsActionGroup;
123	import org.eclipse.jdt.internal.ui.dnd.DelegatingDropAdapter;
124	import org.eclipse.jdt.internal.ui.dnd.JdtViewerDragAdapter;	122	import org.eclipse.jdt.internal.ui.dnd.JdtViewerDragAdapter;
125	import org.eclipse.jdt.internal.ui.dnd.ResourceTransferDragAdapter;	123	import org.eclipse.jdt.internal.ui.dnd.ResourceTransferDragAdapter;
126	import org.eclipse.jdt.internal.ui.infoviews.AbstractInfoView;	124	import org.eclipse.jdt.internal.ui.infoviews.AbstractInfoView;
Lines 438-457 Link Here
438	Transfer[] dropTransfers= new Transfer[] {	436	Transfer[] dropTransfers= new Transfer[] {
439	LocalSelectionTransfer.getInstance()	437	LocalSelectionTransfer.getInstance()
440	};	438	};
441	TransferDropTargetListener[] dropListeners= new TransferDropTargetListener[] {	439	DelegatingDropAdapter delegatingDropAdapter= new DelegatingDropAdapter();
		440	delegatingDropAdapter.addDropTargetListener(
442	new SelectionTransferDropAdapter(fViewer)	441	new SelectionTransferDropAdapter(fViewer)
443	};	442	);
444	fViewer.addDropSupport(ops \| DND.DROP_DEFAULT, dropTransfers, new DelegatingDropAdapter(dropListeners));	443	fViewer.addDropSupport(ops \| DND.DROP_DEFAULT, dropTransfers, delegatingDropAdapter);
445		444
446	// Drag	445	// Drag
447	Transfer[] dragTransfers= new Transfer[] {	446	Transfer[] dragTransfers= new Transfer[] {
448	LocalSelectionTransfer.getInstance(),	447	LocalSelectionTransfer.getInstance(),
449	ResourceTransfer.getInstance()};	448	ResourceTransfer.getInstance()};
450	TransferDragSourceListener[] dragListeners= new TransferDragSourceListener[] {	449
451	new SelectionTransferDragAdapter(fViewer),	450	JdtViewerDragAdapter dragAdapter= new JdtViewerDragAdapter(fViewer);
		451	dragAdapter.addDragSourceListener(
		452	new SelectionTransferDragAdapter(fViewer)
		453	);
		454	dragAdapter.addDragSourceListener(
452	new ResourceTransferDragAdapter(fViewer)	455	new ResourceTransferDragAdapter(fViewer)
453	};	456	);
454	fViewer.addDragSupport(ops, dragTransfers, new JdtViewerDragAdapter(fViewer, dragListeners));	457	fViewer.addDragSupport(ops, dragTransfers, dragAdapter);
455	}	458	}
456		459
457	protected void fillActionBars(IActionBars actionBars) {	460	protected void fillActionBars(IActionBars actionBars) {

Lines 31-37 Link Here

(-)ui/org/eclipse/jdt/internal/ui/search/JavaSearchResultPage.java (-6 / +7 lines)
31	import org.eclipse.jface.action.IToolBarManager;	31	import org.eclipse.jface.action.IToolBarManager;
32	import org.eclipse.jface.action.MenuManager;	32	import org.eclipse.jface.action.MenuManager;
33	import org.eclipse.jface.action.Separator;	33	import org.eclipse.jface.action.Separator;
34	import org.eclipse.jface.util.TransferDragSourceListener;
35	import org.eclipse.jface.viewers.ILabelProvider;	34	import org.eclipse.jface.viewers.ILabelProvider;
36	import org.eclipse.jface.viewers.IStructuredSelection;	35	import org.eclipse.jface.viewers.IStructuredSelection;
37	import org.eclipse.jface.viewers.ITreeContentProvider;	36	import org.eclipse.jface.viewers.ITreeContentProvider;
Lines 301-312 Link Here
301	Transfer[] transfers= new Transfer[] { LocalSelectionTransfer.getInstance(), ResourceTransfer.getInstance() };	300	Transfer[] transfers= new Transfer[] { LocalSelectionTransfer.getInstance(), ResourceTransfer.getInstance() };
302	int ops= DND.DROP_COPY \| DND.DROP_LINK;	301	int ops= DND.DROP_COPY \| DND.DROP_LINK;
303		302
304	TransferDragSourceListener[] dragListeners= new TransferDragSourceListener[] {	303	JdtViewerDragAdapter dragAdapter= new JdtViewerDragAdapter(viewer);
305	new SelectionTransferDragAdapter(viewer),	304	dragAdapter.addDragSourceListener(
		305	new SelectionTransferDragAdapter(viewer)
		306	);
		307	dragAdapter.addDragSourceListener(
306	new ResourceTransferDragAdapter(viewer)	308	new ResourceTransferDragAdapter(viewer)
307	};	309	);
308		310	viewer.addDragSupport(ops, transfers, dragAdapter);
309	viewer.addDragSupport(ops, transfers, new JdtViewerDragAdapter(viewer, dragListeners));
310	}	311	}
311		312
312	protected void configureTableViewer(TableViewer viewer) {	313	protected void configureTableViewer(TableViewer viewer) {

Added Link Here

(-)ui/org/eclipse/jdt/internal/ui/dnd/ViewerInputDropAdapter.java (+102 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.jdt.internal.ui.dnd;
12
13
14	import org.eclipse.swt.dnd.DND;
15	import org.eclipse.swt.dnd.DropTargetEvent;
16	import org.eclipse.swt.dnd.TransferData;
17	import org.eclipse.swt.graphics.Point;
18	import org.eclipse.swt.graphics.Rectangle;
19	import org.eclipse.swt.widgets.Item;
20
21	import org.eclipse.jface.viewers.ISelection;
22	import org.eclipse.jface.viewers.StructuredViewer;
23
24	import org.eclipse.jdt.internal.ui.packageview.SelectionTransferDropAdapter;
25
26	public abstract class ViewerInputDropAdapter extends SelectionTransferDropAdapter {
27
28	private static final int ITEM_MARGIN_LEFT= 40;
29	private static final int ITEM_MARGIN_RIGTH= 10;
30	private static final int OPERATION= DND.DROP_LINK;
31
32	public ViewerInputDropAdapter(StructuredViewer viewer) {
33	super(viewer);
34	}
35
36	protected abstract Object getInputElement(ISelection selection);
37	protected abstract void doInputView(Object inputElement);
38
39	/**
40	* {@inheritDoc}
41	*/
42	public int validateDrop(Object target, int operation, TransferData transferType) {
43
44	setSelectionFeedbackEnabled(true);
45	setExpandEnabled(true);
46
47	initializeSelection();
48
49	if (target != null){
50	return super.validateDrop(target, operation, transferType);
51	} else if (getInputElement(getSelection()) != null) {
52	setSelectionFeedbackEnabled(false);
53	setExpandEnabled(false);
54	return OPERATION;
55	} else {
56	return DND.DROP_NONE;
57	}
58	}
59
60	/**
61	* {@inheritDoc}
62	*/
63	public int performDrop(Object data) {
64	setSelectionFeedbackEnabled(true);
65	setExpandEnabled(true);
66
67	if (getCurrentTarget() != null \|\| getCurrentOperation() != OPERATION){
68	return super.performDrop(data);
69	}
70
71	Object input= getInputElement(getSelection());
72	if (input != null)
73	doInputView(input);
74
75	return DND.DROP_NONE;
76	}
77
78	/**
79	* {@inheritDoc}
80	*/
81	public boolean isEnabled(DropTargetEvent event) {
82	return true;
83	}
84
85	/**
86	* {@inheritDoc}
87	*/
88	protected Object determineTarget(DropTargetEvent event) {
89	if (event.item == null)
90	return super.determineTarget(event);
91
92	Point coordinates= getViewer().getControl().toControl(new Point(event.x, event.y));
93	Rectangle bounds= getBounds((Item) event.item);
94	if (coordinates.x < bounds.x - ITEM_MARGIN_LEFT \|\| coordinates.x >= bounds.x + bounds.width + ITEM_MARGIN_RIGTH) {
95	event.item= null; // too far away
96	return null;
97	}
98
99	return super.determineTarget(event);
100	}
101
102	}