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