bug 1037094, to much indentation for first comment in a function parameters and defau...
[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.
26  * The adapater delegates the <code>dragEnter</code>, <code>dragOperationChanged
27  * </code>, <code>dragOver</code> and <code>dropAccept</code> method to the
28  * <code>validateDrop</code> method. Furthermore it adds location feedback.
29  */
30 public class JdtViewerDropAdapter implements DropTargetListener {
31
32         /**
33          * Constant describing the position of the mouse cursor relative 
34          * to the target object.  This means the mouse is positioned
35          * slightly before the target.
36          */
37         protected static final int LOCATION_BEFORE= 1;
38         
39         /**
40          * Constant describing the position of the mouse cursor relative 
41          * to the target object.  This means the mouse is positioned
42          * slightly after the target.
43          */
44         protected static final int LOCATION_AFTER= 2;
45         
46         /**
47          * Constant describing the position of the mouse cursor relative 
48          * to the target object.  This means the mouse is positioned
49          * 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 
55          * to the target object.  This means the mouse is not positioned
56          * over or near any 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
62          * an item.
63          */
64         private static final int LOCATION_EPSILON= 5; 
65         
66         /**
67          * Style to enable location feedback.
68          */
69         public static final int INSERTION_FEEDBACK= 1 << 1; 
70
71         private StructuredViewer fViewer;
72         private int fFeedback;
73         private boolean fShowInsertionFeedback;
74         private int fRequestedOperation;
75         private int fLastOperation;
76         protected int fLocation;
77         protected Object fTarget;
78
79         public JdtViewerDropAdapter(StructuredViewer viewer, int feedback) {
80                 fViewer= viewer;
81                 Assert.isNotNull(fViewer);
82                 fFeedback= feedback;
83                 fLastOperation= -1;
84         }
85
86         /**
87          * Controls whether the drop adapter shows insertion feedback or not.
88          * 
89          * @param showInsertionFeedback <code>true</code> if the drop adapter is supposed
90          *      to show insertion feedback. Otherwise <code>false</code>
91          */
92         public void showInsertionFeedback(boolean showInsertionFeedback) {
93                 fShowInsertionFeedback= showInsertionFeedback;
94         }
95         
96         /**
97          * Returns the viewer this adapter is working on.
98          */
99         protected StructuredViewer getViewer() {
100                 return fViewer;
101         } 
102         
103         //---- Hooks to override -----------------------------------------------------
104         
105         /**
106          * The actual drop has occurred. Calls <code>drop(Object target, DropTargetEvent event)
107          * </code>.
108          * @see DropTargetListener#drop(org.eclipse.swt.dnd.DropTargetEvent)
109          */      
110         public void drop(DropTargetEvent event) {
111                 drop(fTarget, event);
112         }
113         
114         /**
115          * The actual drop has occurred.
116          * @param target the drop target in form of a domain element.
117          * @param event the drop traget event
118          */      
119         public void drop(Object target, DropTargetEvent event) {
120         }
121         
122         /**
123          * Checks if the drop is valid. The method calls <code>validateDrop
124          * (Object target, DropTargetEvent event). Implementors can alter the 
125          * <code>currentDataType</code> field and the <code>detail</code> field 
126          * to give feedback about drop acceptence.
127          */
128         public void validateDrop(DropTargetEvent event) {
129                 validateDrop(fTarget, event, fRequestedOperation);
130         }
131         
132         /**
133          * Checks if the drop on the current target is valid. The method
134          * can alter the <code>currentDataType</code> field and the <code>
135          * detail</code> field to give feedback about drop acceptence.
136          * @param target the drop target in form of a domain element.
137          * @param event the drop traget event
138          * @param operation the operation requested by the user.
139          */
140         public void validateDrop(Object target, DropTargetEvent event, int operation) {
141         }
142         
143         public void dragEnter(DropTargetEvent event) {
144                 dragOperationChanged(event);
145         }
146         
147         public void dragLeave(DropTargetEvent event) {
148                 fTarget= null;
149                 fLocation= LOCATION_NONE;
150         }
151         
152         public void dragOperationChanged(DropTargetEvent event) {
153                 fRequestedOperation= event.detail;
154                 fTarget= computeTarget(event);
155                 fLocation= computeLocation(event);
156                 validateDrop(event);
157                 fLastOperation= event.detail;
158                 computeFeedback(event);
159         }
160         
161         public void dragOver(DropTargetEvent event) {
162                 Object oldTarget= fTarget;
163                 fTarget= computeTarget(event);
164                 
165                 //set the location feedback
166                 int oldLocation= fLocation;
167                 fLocation= computeLocation(event);
168                 if (oldLocation != fLocation || oldTarget != fTarget || fLastOperation != event.detail) {
169                         validateDrop(event);
170                         fLastOperation= event.detail;
171                 } else {
172                         event.detail= fLastOperation;
173                 }
174                 computeFeedback(event);
175         }
176         
177         public void dropAccept(DropTargetEvent event) {
178                 fTarget= computeTarget(event);
179                 validateDrop(event);
180                 fLastOperation= event.detail;
181         }
182         
183         /**
184          * Returns the data held by <code>event.item</code>. Inside a viewer
185          * this corresponds to the items data model element.
186          */
187         protected Object computeTarget(DropTargetEvent event) {
188                 return event.item == null ? null : event.item.getData();
189         }
190         
191         /**
192          * Returns the position of the given coordinates relative to the given target.
193          * The position is determined to be before, after, or on the item, based on 
194          * some threshold value. The return value is one of the LOCATION_* constants 
195          * defined in this class.
196          */
197         final protected int computeLocation(DropTargetEvent event) {
198                 if (!(event.item instanceof Item))
199                         return LOCATION_NONE;
200                 
201                 Item item= (Item) event.item;
202                 Point coordinates= fViewer.getControl().toControl(new Point(event.x, event.y));
203                 Rectangle bounds= getBounds(item);
204                 if (bounds == null) {
205                         return LOCATION_NONE;
206                 }
207                 if ((coordinates.y - bounds.y) < LOCATION_EPSILON) {
208                         return LOCATION_BEFORE;
209                 }
210                 if ((bounds.y + bounds.height - coordinates.y) < LOCATION_EPSILON) {
211                         return LOCATION_AFTER;
212                 }
213                 return LOCATION_ON;
214         }
215
216         /**
217          * Returns the bounds of the given item, or <code>null</code> if it is not a 
218          * valid type of item.
219          */
220         private Rectangle getBounds(Item item) {
221                 if (item instanceof TreeItem)
222                         return ((TreeItem) item).getBounds();
223                         
224                 if (item instanceof TableItem)
225                         return ((TableItem) item).getBounds(0);
226                         
227                 return null;
228         }
229
230         /**
231          * Sets the drag under feedback corresponding to the value of <code>fLocation</code>
232          * and the <code>INSERTION_FEEDBACK</code> style bit.
233          */
234         protected void computeFeedback(DropTargetEvent event) {
235                 if (!fShowInsertionFeedback && fLocation != LOCATION_NONE) {
236                         event.feedback= DND.FEEDBACK_SELECT;
237                 } else {
238                         if (fLocation == LOCATION_BEFORE) {
239                                 event.feedback= DND.FEEDBACK_INSERT_BEFORE;
240                         } else if (fLocation == LOCATION_AFTER) {
241                                 event.feedback= DND.FEEDBACK_INSERT_AFTER;
242                         }
243                 }
244                 event.feedback|= fFeedback;
245         }
246         
247         /**
248          * Sets the drop operation to </code>DROP_NODE<code>.
249          */
250         protected void clearDropOperation(DropTargetEvent event) {
251                 event.detail= DND.DROP_NONE;
252         }
253         
254         /**
255          * Returns the requested drop operation.
256          */
257         protected int getRequestedOperation() {
258                 return fRequestedOperation;
259         } 
260 }