Java DND.FEEDBACK_EXPAND属性代码示例

public void dragOver(DropTargetEvent event) {
	event.feedback = DND.FEEDBACK_SELECT;
	float location = computeRelativeLocation(event);
	if (location > THRESHOLD) {
		event.feedback = DND.FEEDBACK_INSERT_AFTER;
	} else {
		event.feedback = DND.FEEDBACK_INSERT_BEFORE;
	}
	// always provide expand/scroll capability when dragging
	event.feedback |= DND.FEEDBACK_EXPAND | DND.FEEDBACK_SCROLL;
}
 

/**
 * Get the feedback given the semantics
 *  
 * @param semantics
 * @return the feedback to use.
 */
private int getFeedback(InsertionSemantics semantics) {
	switch (semantics) {
	case BEFORE: return DND.FEEDBACK_INSERT_BEFORE;
	case ON:     return DND.FEEDBACK_SELECT | DND.FEEDBACK_EXPAND;
	case AFTER:  return DND.FEEDBACK_INSERT_AFTER;
	default:     return DND.FEEDBACK_NONE;
	}
}
 

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

protected void handleDragOver() {
	if (TreeViewerTransfer.getInstance().getViewer() != getViewer()) {
		getCurrentEvent().detail = DND.DROP_NONE;
		return;
	}
	getCurrentEvent().feedback = DND.FEEDBACK_SCROLL | DND.FEEDBACK_EXPAND;
	super.handleDragOver();
}
 

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

/**
 * 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 = originalDropType;

    Iterator iter = listeners.iterator();
    while (iter.hasNext()) {
        TransferDropTargetListener listener = (TransferDropTargetListener) iter
                .next();
        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;
            }
event.currentDataType = originalDataType;
        }
    }
    setCurrentListener(null, event);
    event.detail = DND.DROP_NONE;
    
    // -always- ensure that expand/scroll are on...otherwise
    // if a valid drop target is a child of an invalid one
    // you can't get there...
    event.feedback = DND.FEEDBACK_EXPAND | DND.FEEDBACK_SCROLL;
}
 

@Override
public void dragOver(DropTargetEvent event) {
	super.dragOver(event);
	
	// Overrides feedback: by default is DND.FEEDBACK_SELECT
	feedback = DND.FEEDBACK_SELECT | DND.FEEDBACK_SCROLL | DND.FEEDBACK_EXPAND;
	
	boolean shouldFeedBack = true;
	if (PaletteSourceTransfer.getInstance().isSupportedType(event.currentDataType)) {
		shouldFeedBack = false;
	}
	
	// Handles feedback for objects that can be ordered
	if (shouldFeedBack && getCurrentOperation() == DND.DROP_MOVE) {
		Object targetObject = getCurrentTarget();
		Object sourceObject = getSelectedObject();
		if ((sourceObject != null) && (targetObject != null)) {
			// Source and target objects must be different
			if (!sourceObject.equals(targetObject)) {
				if ((sourceObject instanceof TreeObject) && (targetObject instanceof TreeObject)) {
					// Source and target objects can be ordered
					if ((sourceObject instanceof IOrderableTreeObject) && (targetObject instanceof IOrderableTreeObject)) {
						// Source and target objects must have the same parent
						if (((TreeObject)sourceObject).getParent().equals(((TreeObject)targetObject).getParent())) {
							boolean srcInherited = false;
							if (sourceObject instanceof DatabaseObjectTreeObject) srcInherited = ((DatabaseObjectTreeObject)sourceObject).isInherited;
							else if (sourceObject instanceof IPropertyTreeObject) srcInherited = ((IPropertyTreeObject)sourceObject).isInherited();
							// Source object musn't be inherited
							if (!srcInherited) {
								int currentLocation = getCurrentLocation();
								switch (currentLocation) {
									case LOCATION_BEFORE:
										feedback = DND.FEEDBACK_INSERT_BEFORE;
										break;
									case LOCATION_AFTER:
										feedback = DND.FEEDBACK_INSERT_AFTER;
										break;
									case LOCATION_ON:
									default:
										feedback = DND.FEEDBACK_SELECT | DND.FEEDBACK_SCROLL | DND.FEEDBACK_EXPAND;
										break;
								}									
							}
						}
					}
				}
			}
		}
	}
	
	// Set feedback
	event.feedback = feedback;
}
 

public void dragOver(DropTargetEvent event) {
 event.feedback = DND.FEEDBACK_EXPAND | DND.FEEDBACK_SCROLL; 
}
 

@Override
public void dragOver(DropTargetEvent event) {
	// select, expand and scroll the tree node
	event.feedback = DND.FEEDBACK_SELECT | DND.FEEDBACK_EXPAND | DND.FEEDBACK_SCROLL;
}
 

@Override
public void dragOver(DropTargetEvent event) {
	
	event.feedback = DND.FEEDBACK_EXPAND | DND.FEEDBACK_SCROLL;
       
	IStructuredSelection structuredSelection = (IStructuredSelection) LocalSelectionTransfer
               .getTransfer().getSelection();
	
	if (structuredSelection.size() == 1) {
		
		Object element = structuredSelection.getFirstElement();
		
		if (element instanceof AvroNode) {

			AvroNode sourceNode = (AvroNode) element;

			TreeItem item = (TreeItem) event.item;
			if (item != null) {					
				
				AvroNode targetNode = nodeConverter.convertToAvroNode(item.getData());
				
				if (targetNode == sourceNode) {
					
					event.detail = DND.DROP_NONE;
					
				} else {
				
					int tolerance = dropPolicy.getTargetPositionTolerance();
					
					Point pt = schemaViewer.getTreeViewer().getTree().toControl(event.x, event.y);
					Rectangle bounds = item.getBounds();

					if (pt.y < bounds.y + tolerance) {
						position = TargetPosition.BEFORE;
						event.feedback |= DND.FEEDBACK_INSERT_BEFORE;
					}
					else if (pt.y > bounds.y + bounds.height - tolerance) {
						position = TargetPosition.AFTER;
						event.feedback |= DND.FEEDBACK_INSERT_AFTER;
					}
					else {
						position = TargetPosition.UPON;
						event.feedback |= DND.FEEDBACK_SELECT;
					}

					event.detail = dropPolicy.dragOver(sourceNode, targetNode, position);											
					
				}
			}
			
		} else {
			event.detail = DND.DROP_NONE;
		}
           
	}

}
 

/**
 * The purpose of a template is to be copied. Therefore, the Drop operation
 * is set to <code>DND.DROP_COPY</code> by default.
 * 
 * @see org.eclipse.gef.dnd.AbstractTransferDropTargetListener#handleDragOver()
 */
protected void handleDragOver() {
	getCurrentEvent().detail = DND.DROP_COPY;
	getCurrentEvent().feedback = DND.FEEDBACK_SCROLL | DND.FEEDBACK_EXPAND;
	super.handleDragOver();
}