import com.vaadin.terminal.PaintException;
import com.vaadin.terminal.PaintTarget;
-import com.vaadin.terminal.gwt.client.ui.dd.VDragAndDropManager.DragEventType;
import com.vaadin.ui.Component;
import com.vaadin.ui.Tree.Location;
import com.vaadin.ui.Tree.TreeDropDetails;
* {@link #receive(Transferable)} method.
*
*/
-public abstract class AbstractDropHandler implements DropHandler {
+public abstract class AbstractDropHandler implements DragDropHandler {
/**
* Criterion that can be used create policy to accept/discard dragged
* content (presented by {@link Transferable}).
*
*/
public interface AcceptCriterion {
- public boolean accepts(DragRequest request);
+ public boolean accepts(Transferable transferable,
+ DragDropDetails dragDropDetails);
}
public interface ClientSideVerifiable extends AcceptCriterion {
}
private static final class AcceptAll implements ClientSideVerifiable {
- public boolean accepts(DragRequest event) {
+
+ public boolean accepts(Transferable transferable,
+ DragDropDetails dragDropDetails) {
return true;
}
this.f2 = f2;
}
- public boolean accepts(DragRequest event) {
- return f1.accepts(event) && f2.accepts(event);
+ public boolean accepts(Transferable transferable,
+ DragDropDetails dragDropDetails) {
+ return f1.accepts(transferable, dragDropDetails)
+ && f2.accepts(transferable, dragDropDetails);
}
public boolean isClientSideVerifiable() {
this.component = component;
}
- public boolean accepts(DragRequest event) {
- if (event.getTransferable() instanceof ComponentTransferable) {
- return ((ComponentTransferable) event.getTransferable())
+ public boolean accepts(Transferable transferable,
+ DragDropDetails dragDropDetails) {
+ if (transferable instanceof ComponentTransferable) {
+ return ((ComponentTransferable) transferable)
.getSourceComponent() == component;
} else {
return false;
}
private static final class IsDataBinded implements ClientSideVerifiable {
- public boolean accepts(DragRequest event) {
- Transferable transferable = event.getTransferable();
- if (transferable instanceof DataBindedTransferrable) {
- return ((DataBindedTransferrable) transferable).getItemId() != null;
+ public boolean accepts(Transferable transferable,
+ DragDropDetails dragDropDetails) {
+ if (transferable instanceof DataBindedTransferable) {
+ return ((DataBindedTransferable) transferable).getItemId() != null;
}
return false;
}
this.acceptCriterion = acceptCriterion;
}
- public boolean accepts(DragRequest event) {
- return !acceptCriterion.accepts(event);
+ public boolean accepts(Transferable transferable,
+ DragDropDetails dragDropDetails) {
+ return !acceptCriterion.accepts(transferable, dragDropDetails);
}
}
this.f2 = f2;
}
- public boolean accepts(DragRequest event) {
- return f1.accepts(event) || f2.accepts(event);
+ public boolean accepts(Transferable transferable,
+ DragDropDetails dragDropDetails) {
+ return f1.accepts(transferable, dragDropDetails)
+ || f2.accepts(transferable, dragDropDetails);
}
}
public static class OverTreeNode implements ClientSideVerifiable {
- public boolean accepts(DragRequest event) {
+ public boolean accepts(Transferable transferable,
+ DragDropDetails dragDropDetails) {
try {
- TreeDropDetails eventDetails = (TreeDropDetails) event
- .getEventDetails();
+ TreeDropDetails eventDetails = (TreeDropDetails) dragDropDetails;
return eventDetails.getDropLocation() == Location.MIDDLE;
} catch (Exception e) {
return false;
/*
* (non-Javadoc)
*
- * @seecom.vaadin.event.DropHandler#acceptTransferrable(com.vaadin.event.
+ * @seecom.vaadin.event.DropHandler#acceptTransferable(com.vaadin.event.
* Transferable)
*/
- public boolean acceptTransferrable(DragRequest request) {
- return acceptCriterion.accepts(request);
+ public boolean acceptTransferable(Transferable transferable,
+ DragDropDetails dragDropDetails) {
+ return acceptCriterion.accepts(transferable, dragDropDetails);
}
private boolean clientSideVerifiable() {
return false;
}
- public void handleDragRequest(DragRequest event) {
- boolean acceptTransferrable = acceptTransferrable(event);
- if (acceptTransferrable) {
- if (event.getType() == DragEventType.DROP) {
- receive(event.getTransferable(), event.getEventDetails());
- } else {
- event.setResponseParameter("accepted", true);
- }
+ public void handleDragRequest(DragRequest event, Transferable transferable,
+ DragDropDetails dragDropDetails) {
+ boolean acceptTransferable = acceptTransferable(transferable,
+ dragDropDetails);
+ if (acceptTransferable) {
+ event.setResponseParameter("accepted", true);
+ }
+ }
+ public boolean drop(Transferable transferable,
+ DragDropDetails dragDropDetails) {
+ boolean acceptTransferable = acceptTransferable(transferable,
+ dragDropDetails);
+ if (acceptTransferable) {
+ receive(transferable, dragDropDetails);
+ return true;
}
+ return false;
}
public void paint(PaintTarget target) throws PaintException {
*
* @see com.vaadin.event.DropHandler#receive(com.vaadin.event.Transferable)
*/
- public abstract void receive(Transferable transferable, Object dropDetails);
+ public abstract void receive(Transferable transferable,
+ DragDropDetails dropDetails);
public void setAcceptCriterion(AcceptCriterion acceptCriterion) {
this.acceptCriterion = acceptCriterion;
--- /dev/null
+package com.vaadin.event;
+
+public interface DataBindedTransferable extends ComponentTransferable {
+
+ public Object getItemId();
+
+ public Object getPropertyId();
+
+}
+++ /dev/null
-package com.vaadin.event;
-
-public interface DataBindedTransferrable extends ComponentTransferable {
-
- public Object getItemId();
-
- public Object getPropertyId();
-
-}
--- /dev/null
+package com.vaadin.event;
+
+import java.util.Map;
+
+/**
+ * DragDropDataTranslator provides a method for translating drop data from a
+ * client side widget to server side values. This interface is optional for drop
+ * operations and only need to be implemented if translation is necessary. If
+ * this is not implemented the data will be passed through as-is without
+ * conversion.
+ */
+public interface DragDropDataTranslator {
+ /**
+ * Called before a drop operation to translate the drop data provided by the
+ * client widget. Should return a DropData implementation with the new
+ * values. If null is returned the {@link DragDropHandler} will
+ * automatically create a DropData with all the client variables.
+ *
+ * @param rawVariables
+ * Parameters passed from the client side widget.
+ * @return A DropData object with the translated data or null.
+ */
+ public DragDropDetails translateDragDropDetails(
+ Map<String, Object> clientVariables);
+
+}
\ No newline at end of file
--- /dev/null
+package com.vaadin.event;
+
+import com.vaadin.ui.Component;
+
+public interface DragDropDetails {
+
+ public Object get(String key);
+
+ public Object put(String key, Object value);
+
+ public Component getTarget();
+}
--- /dev/null
+package com.vaadin.event;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import com.vaadin.terminal.gwt.server.DragAndDropService;
+import com.vaadin.ui.Component;
+
+public class DragDropDetailsImpl implements DragDropDetails {
+
+ private HashMap<String, Object> data = new HashMap<String, Object>();
+
+ public DragDropDetailsImpl(Map<String, Object> rawDropData) {
+ data.putAll(rawDropData);
+ }
+
+ public Object get(String key) {
+ return data.get(key);
+ }
+
+ public Object put(String key, Object value) {
+ return data.put(key, value);
+ }
+
+ public Component getTarget() {
+ return (Component) data.get(DragAndDropService.DROPTARGET_KEY);
+ }
+}
--- /dev/null
+package com.vaadin.event;
+
+public interface DragDropHandler extends DropHandler {
+
+ public void handleDragRequest(DragRequest event, Transferable transferable,
+ DragDropDetails dragDropDetails);
+
+}
public class DragRequest {
private DragEventType dragEventType;
- private Transferable transferable;
private Map<String, Object> responseData;
- private Object eventDetails;
- public DragRequest(DragEventType dragEventType, Transferable transferable) {
+ public DragRequest(DragEventType dragEventType) {
this.dragEventType = dragEventType;
- this.transferable = transferable;
- }
-
- public Transferable getTransferable() {
- return transferable;
}
public DragEventType getType() {
responseData.put(key, value);
}
- public void setEventDetails(Object eventDetails) {
- this.eventDetails = eventDetails;
- }
-
- public Object getEventDetails() {
- return eventDetails;
- }
-
}
public interface DropHandler {
- public void handleDragRequest(DragRequest event);
+ public boolean drop(Transferable transferable, DragDropDetails dropDetails);
}
\ No newline at end of file
--- /dev/null
+package com.vaadin.event;
+
+import com.vaadin.ui.Component;
+
+/**
+ * DropTarget is a marker interface for components supporting drop operations. A
+ * component that wants to receive drop events should implement this interface
+ * and provide a DropHandler which will handle the actual drop event.
+ *
+ */
+public interface DropTarget extends Component {
+
+ public DropHandler getDropHandler();
+
+}
\ No newline at end of file
+++ /dev/null
-package com.vaadin.event;
-
-import java.util.Map;
-
-import com.vaadin.ui.Component;
-
-/**
- * Implementing component most commonly has also setDropHandler method, but not
- * polluting interface here as component might also have internal
- * AbstractDropHandler implementation.
- *
- */
-public interface HasDropHandler extends Component {
- public DropHandler getDropHandler();
-
- /**
- * TODO Consider using map-like type as return type that would be auto
- * created by terminal in case this implementation would return null. Would
- * enable using simple event details without server side class. Should at
- * least include the component that {@link HasDropHandler} -> would make it
- * possible for one drophandler to be used on multiple components.
- *
- * @param rawVariables
- * @return
- */
- public Object getDragEventDetails(Map<String, Object> rawVariables);
-}
\ No newline at end of file
* @param rawVariables
* @return
*/
- public Transferable getTransferrable(Transferable transferable,
+ public Transferable getTransferable(Transferable transferable,
Map<String, Object> rawVariables);
}
VDragEvent drag = VDragAndDropManager.get().startDrag(
transferable, event.getNativeEvent(), true);
drag.createDragImage(((Widget) paintable).getElement(), true);
- drag.getEventDetails().put(
+ drag.getDropDetails().put(
"mouseDown",
new MouseEventDetails(event.getNativeEvent())
.serialize());
public boolean html5DragDrop(VHtml5DragEvent event) {
ApplicationConnection.getConsole().log("HTML 5 Drag Drop");
- VTransferable transferable = vaadinDragEvent.getTransferrable();
+ VTransferable transferable = vaadinDragEvent.getTransferable();
JsArrayString types = event.getTypes();
for (int i = 0; i < types.length(); i++) {
return false;
}
- Map<String, Object> transferable = drag.getEventDetails();
+ Map<String, Object> transferable = drag.getDropDetails();
// this is absolute layout based, and we may want to set
// component
currentMouseOverKey = findCurrentMouseOverKey(drag.getElementOver());
- drag.getEventDetails().put("itemIdOver", currentMouseOverKey);
+ drag.getDropDetails().put("itemIdOver", currentMouseOverKey);
if (currentMouseOverKey != null) {
String detail = getDropDetail(drag.getCurrentGwtEvent());
&& "Center".equals(detail)) {
overTreeNode = true;
}
- drag.getEventDetails().put("itemIdOverIsNode", overTreeNode);
- drag.getEventDetails().put("detail", detail);
+ drag.getDropDetails().put("itemIdOverIsNode", overTreeNode);
+ drag.getDropDetails().put("detail", detail);
}
}
@Override
public void dragOver(final VDragEvent currentDrag) {
- final Object oldIdOver = currentDrag.getEventDetails().get(
+ final Object oldIdOver = currentDrag.getDropDetails().get(
"itemIdOver");
final String oldDetail = (String) currentDrag
- .getEventDetails().get("detail");
+ .getDropDetails().get("detail");
updateTreeRelatedDragData(currentDrag);
final String detail = getDropDetail(currentDrag
}
/**
- * If transferrable is accepted (either via server visit or client side
+ * If transferable is accepted (either via server visit or client side
* rules) the default implementation calls {@link #dragAccepted(VDragEvent)}
* method.
*/
private final class OverTreeNode implements VAcceptCriteria {
public boolean accept(VDragEvent drag, UIDL configuration) {
- Boolean containsKey = (Boolean) drag.getEventDetails().get(
+ Boolean containsKey = (Boolean) drag.getDropDetails().get(
"itemIdOverIsNode");
if (containsKey != null && containsKey.booleanValue()) {
return true;
private final class ComponentCriteria implements VAcceptCriteria {
public boolean accept(VDragEvent drag, UIDL configuration) {
try {
- Paintable component = drag.getTransferrable().getComponent();
+ Paintable component = drag.getTransferable().getComponent();
String requiredPid = configuration
.getStringAttribute("component");
Paintable paintable = VDragAndDropManager.get()
private final class HasItemId implements VAcceptCriteria {
public boolean accept(VDragEvent drag, UIDL configuration) {
- return drag.getTransferrable().getItemId() != null;
+ return drag.getTransferable().getItemId() != null;
}
}
}
if (currentDropHandler != null) {
// we have dropped on a drop target
- boolean sendTransferrableToServer = currentDropHandler
+ boolean sendTransferableToServer = currentDropHandler
.drop(currentDrag);
- if (sendTransferrableToServer) {
+ if (sendTransferableToServer) {
doRequest(DragEventType.DROP);
}
currentDropHandler = null;
false);
client.updateVariable(DD_SERVICE, "dhowner", paintable, false);
- VTransferable transferable = currentDrag.getTransferrable();
+ VTransferable transferable = currentDrag.getTransferable();
if (transferable.getItemId() != null) {
client.updateVariable(DD_SERVICE, "itemId", transferable
try {
MouseEventDetails mouseEventDetails = new MouseEventDetails(
currentDrag.currentGwtEvent);
- currentDrag.getEventDetails().put("mouseEvent",
+ currentDrag.getDropDetails().put("mouseEvent",
mouseEventDetails.serialize());
} catch (Exception e) {
// NOP, (at least oophm on Safari) can't serialize html dd event
// mouseevent
}
} else {
- currentDrag.getEventDetails().put("mouseEvent", null);
+ currentDrag.getDropDetails().put("mouseEvent", null);
}
- client.updateVariable(DD_SERVICE, "evt", currentDrag.getEventDetails(),
+ client.updateVariable(DD_SERVICE, "evt", currentDrag.getDropDetails(),
false);
client.updateVariable(DD_SERVICE, "tra", transferable.getVariableMap(),
start = new Date();
}
- public VTransferable getTransferrable() {
+ public VTransferable getTransferable() {
return transferable;
}
*
* @return
*/
- public Map<String, Object> getEventDetails() {
+ public Map<String, Object> getDropDetails() {
return dropDetails;
}
public interface VDropHandler {
/**
- * Called by D'D' manager when drag gets over this drop handler.
+ * Called by DragAndDropManager when a drag operation is in progress and the
+ * cursor enters the area occupied by this Paintable.
*
- * @param drag
+ * @param dragEvent
+ * DragEvent which contains the transferable and other
+ * information for the operation
*/
- public void dragEnter(VDragEvent drag);
+ public void dragEnter(VDragEvent dragEvent);
/**
- * Called by D'D' manager when drag gets out this drop handler.
+ * Called by DragAndDropManager when a drag operation is in progress and the
+ * cursor leaves the area occupied by this Paintable.
*
- * @param drag
+ * @param dragEvent
+ * DragEvent which contains the transferable and other
+ * information for the operation
*/
- public void dragLeave(VDragEvent drag);
+ public void dragLeave(VDragEvent dragEvent);
/**
- * The actual drop happened on this drop handler.
+ * Called by DragAndDropManager when a drag operation was in progress and a
+ * drop was performed on this Paintable.
*
- * @param drag
- * @return true if Tranferrable of this drag event needs to be sent to
- * server, false if drop was finally canceled or no server visit is
- * needed
+ *
+ * @param dragEvent
+ * DragEvent which contains the transferable and other
+ * information for the operation
+ *
+ * @return true if the Tranferrable of this drag event needs to be sent to
+ * the server, false if drop is rejected or no server side event
+ * should be sent
*/
public boolean drop(VDragEvent drag);
public void dragOver(VDragEvent currentDrag);
/**
- * Returns the Paintable into which this DragHandler is assosiated
+ * Returns the Paintable into which this DragHandler is associated
*/
public Paintable getPaintable();
import java.util.Map;
import com.vaadin.event.ComponentTransferable;
+import com.vaadin.event.DragDropDataTranslator;
+import com.vaadin.event.DragDropDetails;
+import com.vaadin.event.DragDropDetailsImpl;
+import com.vaadin.event.DragDropHandler;
import com.vaadin.event.DragRequest;
import com.vaadin.event.DropHandler;
-import com.vaadin.event.HasDropHandler;
+import com.vaadin.event.DropTarget;
import com.vaadin.event.Transferable;
import com.vaadin.terminal.DragSource;
import com.vaadin.terminal.VariableOwner;
public class DragAndDropService implements VariableOwner {
private static final long serialVersionUID = -4745268869323400203L;
-
+
+ public static final String DROPTARGET_KEY = "target";
+
private int lastVisitId;
private DragRequest currentRequest;
private Transferable transferable;
public void changeVariables(Object source, Map<String, Object> variables) {
- HasDropHandler dropHandlerOwner = (HasDropHandler) variables
- .get("dhowner");
- if (dropHandlerOwner == null) {
+ Object owner = variables.get("dhowner");
+
+ // Validate drop handler owner
+ if (!(owner instanceof DropTarget)) {
+ System.err.println("DropHandler owner " + owner
+ + " must implement DropTarget");
return;
}
+ if (owner == null) {
+ System.err.println("DropHandler owner is null");
+ return;
+ }
+
+ DropTarget dropTarget = (DropTarget) owner;
lastVisitId = (Integer) variables.get("visitId");
- currentRequest = constructDragRequest(variables, dropHandlerOwner);
+ // Is this a drop request or a drag/move request?
+ boolean dropRequest = isDropRequest(variables);
+ if (dropRequest) {
+ handleDropRequest(dropTarget, variables);
+ } else {
+ handleDragRequest(dropTarget, variables);
+ }
- DropHandler dropHandler = (dropHandlerOwner).getDropHandler();
+ }
- Object eventDetails = dropHandlerOwner
- .getDragEventDetails((Map<String, Object>) variables.get("evt"));
+ /**
+ * Handles a drop request from the VDragAndDropManager.
+ *
+ * @param dropTarget
+ * @param variables
+ */
+ private void handleDropRequest(DropTarget dropTarget,
+ Map<String, Object> variables) {
+ DropHandler dropHandler = (dropTarget).getDropHandler();
+ if (dropHandler == null) {
+ // No dropHandler returned so no drop can be performed.
+ System.err
+ .println("DropTarget.getDropHandler() returned null for owner: "
+ + dropTarget);
+ return;
+ }
- currentRequest.setEventDetails(eventDetails);
+ /*
+ * Construct the Transferable and the DragDropDetails for the drop
+ * operation based on the info passed from the client widgets (drag
+ * source for Transferable, drop target for DragDropDetails).
+ */
+ Transferable transferable = constructTransferable(dropTarget, variables);
+ DragDropDetails dropData = constructDragDropDetails(dropTarget,
+ variables);
- dropHandler.handleDragRequest(currentRequest);
- if (currentRequest.getType() == DragEventType.DROP) {
- // TODO transferable should also be cleaned on each non-dnd
- // variable change (if visited server, but drop did not happen ->
- // should do cleanup to release memory)
- transferable = null;
+ dropHandler.drop(transferable, dropData);
+ }
+
+ /**
+ * Handles a drag/move request from the VDragAndDropManager.
+ *
+ * @param dropTarget
+ * @param variables
+ */
+ private void handleDragRequest(DropTarget dropTarget,
+ Map<String, Object> variables) {
+ lastVisitId = (Integer) variables.get("visitId");
+
+ DropHandler dropHandler = (dropTarget).getDropHandler();
+ if (!(dropHandler instanceof DragDropHandler)) {
+ System.err
+ .println("DragRequest could not be send to handler as DropHandle does not implement DragDropHandler");
+ return;
}
+ DragDropHandler dragDropHandler = (DragDropHandler) dropHandler;
+ /*
+ * Construct the Transferable and the DragDropDetails for the drag
+ * operation based on the info passed from the client widgets (drag
+ * source for Transferable, current target for DragDropDetails).
+ */
+ Transferable transferable = constructTransferable(dropTarget, variables);
+ DragDropDetails dragDropDetails = constructDragDropDetails(dropTarget,
+ variables);
+
+ dragDropHandler.handleDragRequest(constructDragRequest(variables,
+ transferable), transferable, dragDropDetails);
}
- private DragRequest constructDragRequest(Map<String, Object> variables,
- HasDropHandler dropHandlerOwner) {
- Transferable transferable = constructTransferrable(variables,
- dropHandlerOwner);
+ private static DragRequest constructDragRequest(
+ Map<String, Object> variables, Transferable transferable) {
int type = (Integer) variables.get("type");
- DragRequest dragRequest = new DragRequest(DragEventType.values()[type],
- transferable);
+ DragRequest dragRequest = new DragRequest(DragEventType.values()[type]);
return dragRequest;
}
+ /**
+ * Construct DragDropDetails based on variables from client drop target.
+ * Uses DragDropDetailsTranslator if available, otherwise a default
+ * DragDropDetails implementation is used.
+ *
+ * @param dropTarget
+ * @param variables
+ * @return
+ */
+ @SuppressWarnings("unchecked")
+ private DragDropDetails constructDragDropDetails(DropTarget dropTarget,
+ Map<String, Object> variables) {
+ Map<String, Object> rawDragDropDetails = (Map<String, Object>) variables
+ .get("evt");
+
+ DragDropDetails dropData = null;
+ if (dropTarget instanceof DragDropDataTranslator) {
+ dropData = ((DragDropDataTranslator) dropTarget)
+ .translateDragDropDetails(rawDragDropDetails);
+ }
+
+ if (dropData == null) {
+ // Create a default DragDropDetails with all the raw variables
+ dropData = new DragDropDetailsImpl(rawDragDropDetails);
+ }
+
+ dropData.put(DROPTARGET_KEY, dropTarget);
+
+ return dropData;
+ }
+
+ private boolean isDropRequest(Map<String, Object> variables) {
+ return getRequestType(variables) == DragEventType.DROP;
+ }
+
+ private DragEventType getRequestType(Map<String, Object> variables) {
+ int type = (Integer) variables.get("type");
+ return DragEventType.values()[type];
+ }
+
@SuppressWarnings("unchecked")
- private Transferable constructTransferrable(Map<String, Object> variables,
- HasDropHandler dropHandlerOwner) {
+ private Transferable constructTransferable(DropTarget dropHandlerOwner,
+ Map<String, Object> variables) {
int eventId = (Integer) variables.get("eventId");
if (currentEventId != eventId) {
transferable = null;
variables = (Map<String, Object>) variables.get("tra");
- if (sourceComponent != null
- && sourceComponent instanceof DragSource) {
- transferable = ((DragSource) sourceComponent)
- .getTransferrable(transferable, variables);
+ if (sourceComponent != null && sourceComponent instanceof DragSource) {
+ transferable = ((DragSource) sourceComponent).getTransferable(
+ transferable, variables);
} else {
if (transferable == null) {
if (sourceComponent != null) {
import com.vaadin.event.AbstractDropHandler;
import com.vaadin.event.ComponentTransferable;
-import com.vaadin.event.DataBindedTransferrable;
-import com.vaadin.event.HasDropHandler;
+import com.vaadin.event.DataBindedTransferable;
+import com.vaadin.event.DragDropDataTranslator;
+import com.vaadin.event.DragDropDetails;
+import com.vaadin.event.DragDropDetailsImpl;
+import com.vaadin.event.DropTarget;
import com.vaadin.event.Transferable;
import com.vaadin.terminal.PaintException;
import com.vaadin.terminal.PaintTarget;
*/
@SuppressWarnings("serial")
@ClientWidget(com.vaadin.terminal.gwt.client.ui.VDragDropPane.class)
-public class DragDropPane extends AbsoluteLayout implements HasDropHandler {
+public class DragDropPane extends AbsoluteLayout implements DropTarget,
+ DragDropDataTranslator {
private AbstractDropHandler abstractDropHandler;
dropHandler = new AbstractDropHandler() {
@Override
public void receive(Transferable transferable,
- Object dropDetails) {
+ DragDropDetails dropDetails) {
DragEventDetails ed = (DragEventDetails) dropDetails;
if (transferable instanceof ComponentTransferable) {
Component component = ctr.getSourceComponent();
if (component.getParent() != DragDropPane.this) {
- if (transferable instanceof DataBindedTransferrable) {
+ if (transferable instanceof DataBindedTransferable) {
// Item has been dragged, construct a Label from
// Item id
Label l = new Label();
l.setSizeUndefined();
l
.setValue("ItemId : "
- + ((DataBindedTransferrable) transferable)
+ + ((DataBindedTransferable) transferable)
.getItemId());
DragDropPane.this.addComponent(l);
component = l;
return abstractDropHandler;
}
- class DragEventDetails {
-
- private Map<String, Object> vars;
+ class DragEventDetails extends DragDropDetailsImpl {
public DragEventDetails(Map<String, Object> rawVariables) {
- vars = rawVariables;
+ super(rawVariables);
}
public Integer getAbsoluteTop() {
- return (Integer) vars.get("absoluteTop");
+ return (Integer) get("absoluteTop");
}
public Integer getAbsoluteLeft() {
- return (Integer) vars.get("absoluteLeft");
+ return (Integer) get("absoluteLeft");
}
public MouseEventDetails getMouseDownEvent() {
- return MouseEventDetails
- .deSerialize((String) vars.get("mouseDown"));
+ return MouseEventDetails.deSerialize((String) get("mouseDown"));
}
public MouseEventDetails getMouseEvent() {
- return MouseEventDetails.deSerialize((String) vars
- .get("mouseEvent"));
+ return MouseEventDetails.deSerialize((String) get("mouseEvent"));
}
}
- public Object getDragEventDetails(Map<String, Object> rawVariables) {
- return new DragEventDetails(rawVariables);
+ public DragDropDetails translateDragDropDetails(
+ Map<String, Object> clientVariables) {
+ return new DragEventDetails(clientVariables);
}
}
import com.vaadin.data.util.ContainerOrderedWrapper;
import com.vaadin.data.util.IndexedContainer;
import com.vaadin.event.Action;
-import com.vaadin.event.DataBindedTransferrable;
+import com.vaadin.event.DataBindedTransferable;
import com.vaadin.event.ItemClickEvent;
import com.vaadin.event.Transferable;
import com.vaadin.event.Action.Handler;
import com.vaadin.event.ItemClickEvent.ItemClickListener;
import com.vaadin.event.ItemClickEvent.ItemClickSource;
+import com.vaadin.terminal.DragSource;
import com.vaadin.terminal.KeyMapper;
import com.vaadin.terminal.PaintException;
import com.vaadin.terminal.PaintTarget;
import com.vaadin.terminal.Resource;
-import com.vaadin.terminal.DragSource;
import com.vaadin.terminal.gwt.client.MouseEventDetails;
import com.vaadin.terminal.gwt.client.ui.VScrollTable;
@SuppressWarnings("serial")
@ClientWidget(VScrollTable.class)
public class Table extends AbstractSelect implements Action.Container,
- Container.Ordered, Container.Sortable, ItemClickSource,
- DragSource {
+ Container.Ordered, Container.Sortable, ItemClickSource, DragSource {
/**
* Modes that Table support as drag sourse.
requestRepaint();
}
- class TableTransferrable implements DataBindedTransferrable {
+ class TableTransferable implements DataBindedTransferable {
private final HashMap<String, Object> data = new HashMap<String, Object>();
}
- private void updateTransferrable(Map<String, Object> payload,
- Transferable tr) {
+ private void updateTransferable(Map<String, Object> payload, Transferable tr) {
Object object = payload.get("itemId");
if (object != null) {
tr.setData("itemId", itemIdMapper.get((String) object));
}
}
- public Transferable getTransferrable(Transferable transferable,
+ public TableTransferable getTransferable(Transferable transferable,
Map<String, Object> rawVariables) {
if (transferable == null) {
- transferable = new TableTransferrable();
+ transferable = new TableTransferable();
}
- updateTransferrable(rawVariables, transferable);
- return transferable;
+ updateTransferable(rawVariables, transferable);
+ return (TableTransferable) transferable;
}
}
import com.vaadin.data.util.IndexedContainer;
import com.vaadin.event.AbstractDropHandler;
import com.vaadin.event.Action;
-import com.vaadin.event.DataBindedTransferrable;
+import com.vaadin.event.DataBindedTransferable;
+import com.vaadin.event.DragDropDataTranslator;
+import com.vaadin.event.DragDropDetailsImpl;
import com.vaadin.event.DropHandler;
-import com.vaadin.event.HasDropHandler;
+import com.vaadin.event.DropTarget;
import com.vaadin.event.ItemClickEvent;
import com.vaadin.event.Transferable;
import com.vaadin.event.ItemClickEvent.ItemClickListener;
@SuppressWarnings("serial")
@ClientWidget(VTree.class)
public class Tree extends AbstractSelect implements Container.Hierarchical,
- Action.Container, ItemClickSource, DragSource, HasDropHandler {
+ Action.Container, ItemClickSource, DragSource, DropTarget,
+ DragDropDataTranslator {
private static final Method EXPAND_METHOD;
private int itemDragModes = DRAG_OUT;
- class TreeTransferrable implements DataBindedTransferrable {
+ class TreeTransferable implements DataBindedTransferable {
private final HashMap<String, Object> data = new HashMap<String, Object>();
}
}
- public Transferable getTransferrable(Transferable transferable,
+ public Transferable getTransferable(Transferable transferable,
Map<String, Object> payload) {
if (transferable == null) {
- transferable = new TreeTransferrable();
+ transferable = new TreeTransferable();
}
// updating drag source variables
Object object = payload.get("itemId");
// New items
target.addVariable(this, "newitem", new String[] {});
- if (abstractDropHandler != null) {
- abstractDropHandler.paint(target);
+ if (dropHandler instanceof AbstractDropHandler) {
+ ((AbstractDropHandler) dropHandler).paint(target);
}
}
private ItemStyleGenerator itemStyleGenerator;
- private AbstractDropHandler abstractDropHandler;
+ private DropHandler dropHandler;
public void addListener(ItemClickListener listener) {
addListener(VTree.ITEM_CLICK_EVENT_ID, ItemClickEvent.class, listener,
}
public DropHandler getDropHandler() {
- return abstractDropHandler;
+ return dropHandler;
}
- public void setDropHandler(AbstractDropHandler abstractDropHandler) {
- this.abstractDropHandler = abstractDropHandler;
- }
-
- public Object getDragEventDetails(Map<String, Object> rawVariables) {
- return new TreeDropDetails(rawVariables);
+ public void setDropHandler(DropHandler dropHandler) {
+ this.dropHandler = dropHandler;
}
public enum Location {
TOP, BOTTOM, MIDDLE
}
- public class TreeDropDetails {
+ public class TreeDropDetails extends DragDropDetailsImpl {
- private Map<String, Object> vars;
private Object idOver;
TreeDropDetails(Map<String, Object> rawVariables) {
- vars = rawVariables;
+ super(rawVariables);
// eagar fetch itemid, mapper may be emptied
- String keyover = (String) vars.get("itemIdOver");
+ String keyover = (String) get("itemIdOver");
if (keyover != null) {
idOver = itemIdMapper.get(keyover);
}
}
public Location getDropLocation() {
- String s = (String) vars.get("detail");
+ String s = (String) get("detail");
if ("Top".equals(s)) {
return Location.TOP;
} else if ("Bottom".equals(s)) {
}
+ public TreeDropDetails translateDragDropDetails(
+ Map<String, Object> clientVariables) {
+ return new TreeDropDetails(clientVariables);
+ }
+
}
package com.vaadin.tests.dd;
import com.vaadin.event.ComponentTransferable;
-import com.vaadin.event.DragRequest;
+import com.vaadin.event.DragDropDetails;
import com.vaadin.event.Transferable;
import com.vaadin.event.AbstractDropHandler.AcceptCriterion;
import com.vaadin.ui.DragDropPane;
DragDropPane pane = new DragDropPane();
setContent(pane);
pane.getDropHandler().setAcceptCriterion(new AcceptCriterion() {
- public boolean accepts(DragRequest request) {
- Transferable transferable = request.getTransferable();
+ public boolean accepts(Transferable transferable,
+ DragDropDetails dragDropDetails) {
if (transferable instanceof ComponentTransferable) {
ComponentTransferable componentTransferrable = (ComponentTransferable) transferable;
if (componentTransferrable.getSourceComponent() == tree1) {
package com.vaadin.tests.dd;
-import java.util.Map;
-
import com.vaadin.event.AbstractDropHandler;
+import com.vaadin.event.DragDropDetails;
+import com.vaadin.event.DragDropHandler;
import com.vaadin.event.DragRequest;
import com.vaadin.event.DropHandler;
-import com.vaadin.event.HasDropHandler;
+import com.vaadin.event.DropTarget;
import com.vaadin.event.Transferable;
import com.vaadin.terminal.gwt.client.ui.dd.VDragAndDropManager.DragEventType;
import com.vaadin.ui.AbstractComponent;
*
*/
@ClientWidget(VMyDropTarget.class)
- class MyDropTarget extends AbstractComponent implements HasDropHandler {
-
+ class MyDropTarget extends AbstractComponent implements DropTarget {
public DropHandler getDropHandler() {
- return new DropHandler() {
- public void handleDragRequest(DragRequest dragRequest) {
- Transferable transferable = dragRequest.getTransferable();
+ return new DragDropHandler() {
+ public void handleDragRequest(DragRequest dragRequest,
+ Transferable transferable,
+ DragDropDetails dragDropDetails) {
DragEventType type = dragRequest.getType();
switch (type) {
- case DROP:
- // Do something with data
-
- break;
case ENTER:
// eg. validate transferrable
}
}
- };
- }
- public Object getDragEventDetails(Map<String, Object> rawVariables) {
- /*
- * If client side sets some event details, translate them to desired
- * server side presentation here. The returned object will be passed
- * for drop handler.
- */
- return null;
+ public boolean drop(Transferable transferable,
+ DragDropDetails dropDetails) {
+ // Do something with data
+ return true;
+ }
+ };
}
}
import com.vaadin.data.util.HierarchicalContainer;
import com.vaadin.event.AbstractDropHandler;
import com.vaadin.event.ComponentTransferable;
-import com.vaadin.event.DataBindedTransferrable;
-import com.vaadin.event.DragRequest;
+import com.vaadin.event.DataBindedTransferable;
+import com.vaadin.event.DragDropDetails;
import com.vaadin.event.Transferable;
import com.vaadin.event.AbstractDropHandler.AcceptCriterion;
import com.vaadin.terminal.ExternalResource;
.setCaption("Pane2 (accept needs server side visit, only \"Bar\")");
AcceptCriterion f = new AcceptCriterion() {
- public boolean accepts(DragRequest request) {
- Transferable transferable = request.getTransferable();
+ public boolean accepts(Transferable transferable,
+ DragDropDetails dragDropDetails) {
// System.out.println("Simulating 500ms processing...");
// try {
// Thread.sleep(200);
AbstractDropHandler itemSorter = new AbstractDropHandler() {
@Override
- public void receive(Transferable transferable, Object dropdetails) {
+ public void receive(Transferable transferable,
+ DragDropDetails dropdetails) {
TreeDropDetails details = (TreeDropDetails) dropdetails;
// TODO set properties, so same sorter could be used in Table
- if (transferable instanceof DataBindedTransferrable) {
- DataBindedTransferrable transferrable2 = (DataBindedTransferrable) transferable;
+ if (transferable instanceof DataBindedTransferable) {
+ DataBindedTransferable transferrable2 = (DataBindedTransferable) transferable;
Object itemId = transferrable2.getItemId();
import com.vaadin.demo.tutorial.addressbook.data.Person;
import com.vaadin.demo.tutorial.addressbook.data.PersonContainer;
import com.vaadin.event.AbstractDropHandler;
-import com.vaadin.event.DataBindedTransferrable;
+import com.vaadin.event.DataBindedTransferable;
+import com.vaadin.event.DragDropDetails;
import com.vaadin.event.Transferable;
import com.vaadin.event.AbstractDropHandler.AcceptCriterion;
import com.vaadin.event.AbstractDropHandler.And;
AbstractDropHandler dropHandler = new AbstractDropHandler() {
@Override
- public void receive(Transferable transferable, Object dropdetails) {
+ public void receive(Transferable transferable,
+ DragDropDetails dropdetails) {
/*
* We know transferrable is from table, so it is of type
* DataBindedTransferrable
*/
- DataBindedTransferrable tr = (DataBindedTransferrable) transferable;
+ DataBindedTransferable tr = (DataBindedTransferable) transferable;
Object itemId = tr.getItemId();
Table fromTable = (Table) tr.getSourceComponent();
String name = fromTable.getItem(itemId).getItemProperty("Name")
dropHandler = new AbstractDropHandler() {
@Override
- public void receive(Transferable transferable, Object dropdetails) {
+ public void receive(Transferable transferable,
+ DragDropDetails dropdetails) {
TreeDropDetails details = (TreeDropDetails) dropdetails;
- if (transferable instanceof DataBindedTransferrable) {
- DataBindedTransferrable tr = (DataBindedTransferrable) transferable;
+ if (transferable instanceof DataBindedTransferable) {
+ DataBindedTransferable tr = (DataBindedTransferable) transferable;
Object itemId = tree2.addItem();
tree2.setParent(itemId, details.getItemIdOver());
projects / vaadin-framework.git / commitdiff