A minor change of a page design
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / ui / dnd / JdtViewerDropAdapter.java
1 /*******************************************************************************
2  * Copyright (c) 2000, 2003 IBM Corporation and others.
3  * All rights reserved. This program and the accompanying materials 
4  * are made available under the terms of the Common Public License v1.0
5  * which accompanies this distribution, and is available at
6  * http://www.eclipse.org/legal/cpl-v10.html
7  * 
8  * Contributors:
9  *     IBM Corporation - initial API and implementation
10  *******************************************************************************/
11 package net.sourceforge.phpdt.internal.ui.dnd;
12
13 import org.eclipse.jface.util.Assert;
14 import org.eclipse.jface.viewers.StructuredViewer;
15 import org.eclipse.swt.dnd.DND;
16 import org.eclipse.swt.dnd.DropTargetEvent;
17 import org.eclipse.swt.dnd.DropTargetListener;
18 import org.eclipse.swt.graphics.Point;
19 import org.eclipse.swt.graphics.Rectangle;
20 import org.eclipse.swt.widgets.Item;
21 import org.eclipse.swt.widgets.TableItem;
22 import org.eclipse.swt.widgets.TreeItem;
23
24 /**
25  * A drag and drop adapter to be used together with structured viewers. The
26  * adapater delegates the <code>dragEnter</code>, <code>dragOperationChanged
27  * </code>,
28  * <code>dragOver</code> and <code>dropAccept</code> method to the
29  * <code>validateDrop</code> method. Furthermore it adds location feedback.
30  */
31 public class JdtViewerDropAdapter implements DropTargetListener {
32
33         /**
34          * Constant describing the position of the mouse cursor relative to the
35          * target object. This means the mouse is positioned slightly before the
36          * target.
37          */
38         protected static final int LOCATION_BEFORE = 1;
39
40         /**
41          * Constant describing the position of the mouse cursor relative to the
42          * target object. This means the mouse is positioned slightly after the
43          * target.
44          */
45         protected static final int LOCATION_AFTER = 2;
46
47         /**
48          * Constant describing the position of the mouse cursor relative to the
49          * target object. This means the mouse is positioned directly on the target.
50          */
51         protected static final int LOCATION_ON = 3;
52
53         /**
54          * Constant describing the position of the mouse cursor relative to the
55          * target object. This means the mouse is not positioned over or near any
56          * valid target.
57          */
58         protected static final int LOCATION_NONE = 4;
59
60         /**
61          * The threshold used to determine if the mouse is before or after an item.
62          */
63         private static final int LOCATION_EPSILON = 5;
64
65         /**
66          * Style to enable location feedback.
67          */
68         public static final int INSERTION_FEEDBACK = 1 << 1;
69
70         private StructuredViewer fViewer;
71
72         private int fFeedback;
73
74         private boolean fShowInsertionFeedback;
75
76         private int fRequestedOperation;
77
78         private int fLastOperation;
79
80         protected int fLocation;
81
82         protected Object fTarget;
83
84         public JdtViewerDropAdapter(StructuredViewer viewer, int feedback) {
85                 fViewer = viewer;
86                 Assert.isNotNull(fViewer);
87                 fFeedback = feedback;
88                 fLastOperation = -1;
89         }
90
91         /**
92          * Controls whether the drop adapter shows insertion feedback or not.
93          * 
94          * @param showInsertionFeedback
95          *            <code>true</code> if the drop adapter is supposed to show
96          *            insertion feedback. Otherwise <code>false</code>
97          */
98         public void showInsertionFeedback(boolean showInsertionFeedback) {
99                 fShowInsertionFeedback = showInsertionFeedback;
100         }
101
102         /**
103          * Returns the viewer this adapter is working on.
104          */
105         protected StructuredViewer getViewer() {
106                 return fViewer;
107         }
108
109         // ---- Hooks to override
110         // -----------------------------------------------------
111
112         /**
113          * The actual drop has occurred. Calls
114          * <code>drop(Object target, DropTargetEvent event)
115          * </code>.
116          * 
117          * @see DropTargetListener#drop(org.eclipse.swt.dnd.DropTargetEvent)
118          */
119         public void drop(DropTargetEvent event) {
120                 drop(fTarget, event);
121         }
122
123         /**
124          * The actual drop has occurred.
125          * 
126          * @param target
127          *            the drop target in form of a domain element.
128          * @param event
129          *            the drop traget event
130          */
131         public void drop(Object target, DropTargetEvent event) {
132         }
133
134         /**
135          * Checks if the drop is valid. The method calls <code>validateDrop
136          * (Object target, DropTargetEvent event). Implementors can alter the 
137          * <code>currentDataType</code> field and the <code>detail</code> field 
138          * to give feedback about drop acceptence.
139          */
140         public void validateDrop(DropTargetEvent event) {
141                 validateDrop(fTarget, event, fRequestedOperation);
142         }
143
144         /**
145          * Checks if the drop on the current target is valid. The method can alter
146          * the <code>currentDataType</code> field and the <code>
147          * detail</code>
148          * field to give feedback about drop acceptence.
149          * 
150          * @param target
151          *            the drop target in form of a domain element.
152          * @param event
153          *            the drop traget event
154          * @param operation
155          *            the operation requested by the user.
156          */
157         public void validateDrop(Object target, DropTargetEvent event, int operation) {
158         }
159
160         public void dragEnter(DropTargetEvent event) {
161                 dragOperationChanged(event);
162         }
163
164         public void dragLeave(DropTargetEvent event) {
165                 fTarget = null;
166                 fLocation = LOCATION_NONE;
167         }
168
169         public void dragOperationChanged(DropTargetEvent event) {
170                 fRequestedOperation = event.detail;
171                 fTarget = computeTarget(event);
172                 fLocation = computeLocation(event);
173                 validateDrop(event);
174                 fLastOperation = event.detail;
175                 computeFeedback(event);
176         }
177
178         public void dragOver(DropTargetEvent event) {
179                 Object oldTarget = fTarget;
180                 fTarget = computeTarget(event);
181
182                 // set the location feedback
183                 int oldLocation = fLocation;
184                 fLocation = computeLocation(event);
185                 if (oldLocation != fLocation || oldTarget != fTarget
186                                 || fLastOperation != event.detail) {
187                         validateDrop(event);
188                         fLastOperation = event.detail;
189                 } else {
190                         event.detail = fLastOperation;
191                 }
192                 computeFeedback(event);
193         }
194
195         public void dropAccept(DropTargetEvent event) {
196                 fTarget = computeTarget(event);
197                 validateDrop(event);
198                 fLastOperation = event.detail;
199         }
200
201         /**
202          * Returns the data held by <code>event.item</code>. Inside a viewer this
203          * corresponds to the items data model element.
204          */
205         protected Object computeTarget(DropTargetEvent event) {
206                 return event.item == null ? null : event.item.getData();
207         }
208
209         /**
210          * Returns the position of the given coordinates relative to the given
211          * target. The position is determined to be before, after, or on the item,
212          * based on some threshold value. The return value is one of the LOCATION_*
213          * constants defined in this class.
214          */
215         final protected int computeLocation(DropTargetEvent event) {
216                 if (!(event.item instanceof Item))
217                         return LOCATION_NONE;
218
219                 Item item = (Item) event.item;
220                 Point coordinates = fViewer.getControl().toControl(
221                                 new Point(event.x, event.y));
222                 Rectangle bounds = getBounds(item);
223                 if (bounds == null) {
224                         return LOCATION_NONE;
225                 }
226                 if ((coordinates.y - bounds.y) < LOCATION_EPSILON) {
227                         return LOCATION_BEFORE;
228                 }
229                 if ((bounds.y + bounds.height - coordinates.y) < LOCATION_EPSILON) {
230                         return LOCATION_AFTER;
231                 }
232                 return LOCATION_ON;
233         }
234
235         /**
236          * Returns the bounds of the given item, or <code>null</code> if it is not
237          * a valid type of item.
238          */
239         private Rectangle getBounds(Item item) {
240                 if (item instanceof TreeItem)
241                         return ((TreeItem) item).getBounds();
242
243                 if (item instanceof TableItem)
244                         return ((TableItem) item).getBounds(0);
245
246                 return null;
247         }
248
249         /**
250          * Sets the drag under feedback corresponding to the value of
251          * <code>fLocation</code> and the <code>INSERTION_FEEDBACK</code> style
252          * bit.
253          */
254         protected void computeFeedback(DropTargetEvent event) {
255                 if (!fShowInsertionFeedback && fLocation != LOCATION_NONE) {
256                         event.feedback = DND.FEEDBACK_SELECT;
257                 } else {
258                         if (fLocation == LOCATION_BEFORE) {
259                                 event.feedback = DND.FEEDBACK_INSERT_BEFORE;
260                         } else if (fLocation == LOCATION_AFTER) {
261                                 event.feedback = DND.FEEDBACK_INSERT_AFTER;
262                         }
263                 }
264                 event.feedback |= fFeedback;
265         }
266
267         /**
268          * Sets the drop operation to </code>DROP_NODE<code>.
269          */
270         protected void clearDropOperation(DropTargetEvent event) {
271                 event.detail = DND.DROP_NONE;
272         }
273
274         /**
275          * Returns the requested drop operation.
276          */
277         protected int getRequestedOperation() {
278                 return fRequestedOperation;
279         }
280 }