import com.vaadin.terminal.PaintTarget;
import com.vaadin.terminal.gwt.client.ui.dd.DragAndDropManager.DragEventType;
import com.vaadin.ui.Component;
+import com.vaadin.ui.Tree.Location;
+import com.vaadin.ui.Tree.TreeDropDetails;
/**
* An implementation of DropHandler interface.
* Criterion that can be used create policy to accept/discard dragged
* content (presented by {@link Transferable}).
*
- * TODO figure out how this can be done partly on client at least in some
- * cases. isClientSideFilterable() tms.
- *
*/
public interface AcceptCriterion {
- public boolean accepts(Transferable transferable);
+ public boolean accepts(DragRequest request);
}
public interface ClientSideVerifiable extends AcceptCriterion {
}
private static final class AcceptAll implements ClientSideVerifiable {
- public boolean accepts(Transferable transferable) {
+ public boolean accepts(DragRequest event) {
return true;
}
this.f2 = f2;
}
- public boolean accepts(Transferable transferable) {
- return f1.accepts(transferable) && f2.accepts(transferable);
+ public boolean accepts(DragRequest event) {
+ return f1.accepts(event) && f2.accepts(event);
}
public boolean isClientSideVerifiable() {
this.component = component;
}
- public boolean accepts(Transferable transferable) {
- if (transferable instanceof ComponentTransferrable) {
- return ((ComponentTransferrable) transferable)
+ public boolean accepts(DragRequest event) {
+ if (event.getTransferable() instanceof ComponentTransferrable) {
+ return ((ComponentTransferrable) event.getTransferable())
.getSourceComponent() == component;
} else {
return false;
}
private static final class IsDataBinded implements ClientSideVerifiable {
- public boolean accepts(Transferable transferable) {
+ public boolean accepts(DragRequest event) {
+ Transferable transferable = event.getTransferable();
if (transferable instanceof DataBindedTransferrable) {
return ((DataBindedTransferrable) transferable).getItemId() != null;
}
this.acceptCriterion = acceptCriterion;
}
- public boolean accepts(Transferable transferable) {
- return !acceptCriterion.accepts(transferable);
+ public boolean accepts(DragRequest event) {
+ return !acceptCriterion.accepts(event);
}
}
this.f2 = f2;
}
- public boolean accepts(Transferable transferable) {
- return f1.accepts(transferable) || f2.accepts(transferable);
+ public boolean accepts(DragRequest event) {
+ return f1.accepts(event) || f2.accepts(event);
}
}
public static class OverTreeNode implements ClientSideVerifiable {
- public boolean accepts(Transferable transferable) {
+ public boolean accepts(DragRequest event) {
try {
- return transferable.getData("detail").toString().toLowerCase()
- .equals("center");
+ TreeDropDetails eventDetails = (TreeDropDetails) event
+ .getEventDetails();
+ return eventDetails.getDropLocation() == Location.MIDDLE;
} catch (Exception e) {
return false;
}
* @seecom.vaadin.event.DropHandler#acceptTransferrable(com.vaadin.event.
* Transferable)
*/
- public boolean acceptTransferrable(Transferable transferable) {
- return acceptCriterion.accepts(transferable);
+ public boolean acceptTransferrable(DragRequest request) {
+ return acceptCriterion.accepts(request);
}
private boolean clientSideVerifiable() {
}
public void handleDragRequest(DragRequest event) {
- boolean acceptTransferrable = acceptTransferrable(event
- .getTransferrable());
+ boolean acceptTransferrable = acceptTransferrable(event);
if (acceptTransferrable) {
if (event.getType() == DragEventType.DROP) {
- receive(event.getTransferrable());
+ receive(event.getTransferable(), event.getEventDetails());
} else {
event.setResponseParameter("accepted", true);
}
*
* @see com.vaadin.event.DropHandler#receive(com.vaadin.event.Transferable)
*/
- public abstract void receive(Transferable transferable);
+ public abstract void receive(Transferable transferable, Object dropDetails);
public void setAcceptCriterion(AcceptCriterion acceptCriterion) {
this.acceptCriterion = acceptCriterion;
private DragEventType dragEventType;
private Transferable transferable;
private Map<String, Object> responseData;
+ private Object eventDetails;
public DragRequest(DragEventType dragEventType, Transferable transferable) {
this.dragEventType = dragEventType;
this.transferable = transferable;
}
- public Transferable getTransferrable() {
+ public Transferable getTransferable() {
return transferable;
}
responseData.put(key, value);
}
+ public void setEventDetails(Object eventDetails) {
+ this.eventDetails = eventDetails;
+ }
+
+ public Object getEventDetails() {
+ return eventDetails;
+ }
+
}
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
+ * 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
--- /dev/null
+package com.vaadin.terminal;
+
+import java.util.Map;
+
+import com.vaadin.event.Transferable;
+
+public interface DragSource {
+
+ /**
+ * DragSource may convert client side variables to meaningful values on
+ * server side. For example in Selects we convert item identifiers to
+ * generated string keys for the client side. Translators in Selects should
+ * convert them back to item identifiers.
+ * <p>
+ * Translator should remove variables it handled from rawVariables. All non
+ * handled variables are added to Transferable automatically by terminal.
+ *
+ * <p>
+ *
+ * @param transferable
+ * the Transferable object if one has been created for this drag
+ * and drop operation, null if Transferable is not yet
+ * instantiated
+ * @param rawVariables
+ * @return
+ */
+ public Transferable getTransferrable(Transferable transferable,
+ Map<String, Object> rawVariables);
+
+}
+++ /dev/null
-package com.vaadin.terminal;
-
-import java.util.Map;
-
-import com.vaadin.event.Transferable;
-
-public interface TransferTranslator {
-
- /**
- * Translate translators may convert client side variables to meaningful
- * values on server side. For example in Selects we convert item identifiers
- * to generated string keys for the client side. Translators in Selects
- * should convert them back to item identifiers.
- * <p>
- * Translator should remove variables it handled from rawVariables. All non
- * handled variables are added to Transferable automatically by terminal.
- *
- * @param transferable
- * the Transferable object if one has been created for this drag
- * and drop operation, null if Transferable is not yet
- * instantiated
- * @param rawVariables
- * @return
- */
- public Transferable getTransferrable(Transferable transferable,
- Map<String, Object> rawVariables, boolean isDropTarget);
-
-}
package com.vaadin.terminal.gwt.client.ui;
+import java.util.Map;
+
import com.google.gwt.core.client.JsArrayString;
import com.google.gwt.dom.client.EventTarget;
import com.google.gwt.event.dom.client.MouseDownEvent;
cloneNode.getStyle().setBackgroundColor("#999");
cloneNode.getStyle().setOpacity(0.4);
drag.setDragImage(cloneNode);
- drag.getTransferrable().setData(
+ drag.getEventDetails().put(
"mouseDown",
new MouseEventDetails(event.getNativeEvent())
.serialize());
return false;
}
- Transferable transferable = drag.getTransferrable();
+ Map<String, Object> transferable = drag.getEventDetails();
// this is absolute layout based, and we may want to set
// component
int absoluteLeft = getAbsoluteLeft();
int absoluteTop = getAbsoluteTop();
- transferable.setData("absoluteLeft", absoluteLeft);
- transferable.setData("absoluteTop", absoluteTop);
+ transferable.put("absoluteLeft", absoluteLeft);
+ transferable.put("absoluteTop", absoluteTop);
getStyleElement().getStyle().setBackgroundColor("yellow");
return super.drop(drag);
import com.vaadin.terminal.gwt.client.Util;
import com.vaadin.terminal.gwt.client.ui.VScrollTable.VScrollTableBody.VScrollTableRow;
import com.vaadin.terminal.gwt.client.ui.dd.DragAndDropManager;
+import com.vaadin.terminal.gwt.client.ui.dd.DragEvent;
import com.vaadin.terminal.gwt.client.ui.dd.Transferable;
/**
transferable.setItemId("" + rowKey);
// TODO propertyId
- com.vaadin.terminal.gwt.client.ui.dd.DragEvent ev = DragAndDropManager
- .get().startDrag(transferable, event,
- true);
+ DragEvent ev = DragAndDropManager.get()
+ .startDrag(transferable, event, true);
Element cloneNode = (Element) getElement()
.cloneNode(true);
cloneNode.getStyle().setOpacity(0.4);
}
private void updateTreeRelatedTransferData(DragEvent drag) {
- drag.getTransferrable().setData("itemIdOver", currentMouseOverKey);
+ drag.getEventDetails().put("itemIdOver", currentMouseOverKey);
if (currentMouseOverKey != null) {
String detail = getDropDetail(drag.getCurrentGwtEvent());
&& "Center".equals(detail)) {
overTreeNode = true;
}
- drag.getTransferrable().setData("itemIdOverIsNode", overTreeNode);
-
- drag.getTransferrable().setData("detail", detail);
+ drag.getEventDetails().put("itemIdOverIsNode", overTreeNode);
+ drag.getEventDetails().put("detail", detail);
}
}
@Override
public void dragOver(final DragEvent currentDrag) {
- final Object oldIdOver = currentDrag.getTransferrable()
- .getData("itemIdOver");
+ final Object oldIdOver = currentDrag.getEventDetails().get(
+ "itemIdOver");
final String oldDetail = (String) currentDrag
- .getTransferrable().getData("detail");
+ .getEventDetails().get("detail");
/*
* Using deferred command, so event bubbles to TreeNode
* event listener. Currently here via preview
boolean nodeHasChanged = (currentMouseOverKey != null && currentMouseOverKey != oldIdOver)
|| (oldIdOver != null);
boolean detailHasChanded = !detail
- .equals(oldIdOver);
+ .equals(oldDetail);
if (nodeHasChanged || detailHasChanded) {
ApplicationConnection.getConsole().log(
DragEventType.OVER, accpectedCb);
} else {
- if (validates(currentDrag
- .getTransferrable())) {
+ if (validates(currentDrag)) {
accpectedCb.handleResponse(null);
} else {
keyToNode.get(currentMouseOverKey)
}
}
});
- } else if (validates(drag.getTransferrable())) {
+ } else if (validates(drag)) {
dragAccepted(drag);
}
}
/**
* Returns true if client side rules are met.
*
- * @param transferable
+ * @param drag
* @return
*/
- protected boolean validates(Transferable transferable) {
+ protected boolean validates(DragEvent drag) {
if (criterioUIDL != null) {
String criteriaName = criterioUIDL.getStringAttribute("name");
AcceptCriteria acceptCriteria = AcceptCriterion.get(criteriaName);
if (acceptCriteria != null) {
// ApplicationConnection.getConsole().log(
// "Criteria : " + acceptCriteria.getClass().getName());
- return acceptCriteria.accept(transferable, criterioUIDL);
+ return acceptCriteria.accept(drag, criterioUIDL);
}
}
return false;
if (serverValidate) {
return true;
} else {
- return validates(drag.getTransferrable());
+ return validates(drag);
}
}
public interface AcceptCriteria {
- public boolean accept(Transferable transferable, UIDL configuration);
+ public boolean accept(DragEvent drag, UIDL configuration);
}
public class AcceptCriterionImpl {
private final class OverTreeNode implements AcceptCriteria {
- public boolean accept(Transferable transferable, UIDL configuration) {
- Boolean containsKey = (Boolean) transferable
- .getData("itemIdOverIsNode");
+ public boolean accept(DragEvent drag, UIDL configuration) {
+ Boolean containsKey = (Boolean) drag.getEventDetails().get(
+ "itemIdOverIsNode");
if (containsKey != null && containsKey.booleanValue()) {
return true;
}
}
private final class ComponentCriteria implements AcceptCriteria {
- public boolean accept(Transferable transferable, UIDL configuration) {
+ public boolean accept(DragEvent drag, UIDL configuration) {
try {
- // FIXME should have access to client too, change transferrable
- // to DragEvent??
- Paintable component = transferable.getComponent();
+ Paintable component = drag.getTransferrable().getComponent();
String requiredPid = configuration
.getStringAttribute("component");
String pid = ((Widget) component).getElement()
}
private final class And implements AcceptCriteria {
- public boolean accept(Transferable transferable, UIDL configuration) {
+ public boolean accept(DragEvent drag, UIDL configuration) {
UIDL childUIDL = configuration.getChildUIDL(0);
UIDL childUIDL2 = configuration.getChildUIDL(1);
AcceptCriteria acceptCriteria = AcceptCriterion.get(childUIDL
"And criteria didn't found a chidl criteria");
return false;
}
- boolean accept = acceptCriteria.accept(transferable, childUIDL);
- boolean accept2 = acceptCriteria2.accept(transferable, childUIDL2);
+ boolean accept = acceptCriteria.accept(drag, childUIDL);
+ boolean accept2 = acceptCriteria2.accept(drag, childUIDL2);
return accept && accept2;
}
}
private final class AcceptAll implements AcceptCriteria {
- public boolean accept(Transferable transferable, UIDL configuration) {
+ public boolean accept(DragEvent drag, UIDL configuration) {
return true;
}
}
private final class HasItemId implements AcceptCriteria {
- public boolean accept(Transferable transferable, UIDL configuration) {
- return transferable.getItemId() != null;
+ public boolean accept(DragEvent drag, UIDL configuration) {
+ return drag.getTransferrable().getItemId() != null;
}
}
try {
MouseEventDetails mouseEventDetails = new MouseEventDetails(
currentDrag.currentGwtEvent);
- transferable.setData("mouseEvent", mouseEventDetails
- .serialize());
+ currentDrag.getEventDetails().put("mouseEvent",
+ mouseEventDetails.serialize());
} catch (Exception e) {
// NOP, (at least oophm on Safari) can't serialize html dd event
// to
// mouseevent
}
} else {
- transferable.setData("mouseEvent", null);
+ currentDrag.getEventDetails().put("mouseEvent", null);
}
+ client.updateVariable(DD_SERVICE, "evt", currentDrag.getEventDetails(),
+ false);
- client.updateVariable(DD_SERVICE, "payload", transferable
- .getVariableMap(), true);
+ client.updateVariable(DD_SERVICE, "tra", transferable.getVariableMap(),
+ true);
}
package com.vaadin.terminal.gwt.client.ui.dd;
import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
import com.google.gwt.dom.client.NativeEvent;
import com.google.gwt.user.client.Element;
private Date start;
+ private HashMap<String, Object> dropDetails = new HashMap<String, Object>();
+
DragEvent(Transferable t, NativeEvent startEvent) {
transferable = t;
this.startEvent = startEvent;
DragAndDropManager.get().setDragElement(node);
}
+ /**
+ * TODO consider using similar smaller (than map) api as in Transferable
+ *
+ * TODO clean up when drop handler changes
+ *
+ * @return
+ */
+ public Map<String, Object> getEventDetails() {
+ return dropDetails;
+ }
+
}
import java.util.HashMap;
import java.util.Map;
-import com.vaadin.terminal.TransferTranslator;
+import com.vaadin.terminal.DragSource;
import com.vaadin.terminal.gwt.client.Paintable;
/**
* This is commonly actually a key to property id on client side than the
* actual propertyId.
*
- * Translated by terminal and {@link TransferTranslator}
+ * Translated by terminal and {@link DragSource}
*
* @return the propertyId
*/
* This is commonly actually a key to property id on client side than the
* actual propertyId.
*
- * Translated by terminal and {@link TransferTranslator}
+ * Translated by terminal and {@link DragSource}
*
* @param propertyId
* the propertyId to set
* This is commonly actually a key to item id on client side than the actual
* itemId.
*
- * Translated by terminal and {@link TransferTranslator}
+ * Translated by terminal and {@link DragSource}
*
* @param itemId
* the itemId to set
import com.vaadin.event.DropHandler;
import com.vaadin.event.HasDropHandler;
import com.vaadin.event.Transferable;
-import com.vaadin.terminal.TransferTranslator;
+import com.vaadin.terminal.DragSource;
import com.vaadin.terminal.VariableOwner;
import com.vaadin.terminal.gwt.client.ui.dd.DragAndDropManager.DragEventType;
import com.vaadin.ui.Component;
currentRequest = constructDragRequest(variables, dropHandlerOwner);
DropHandler dropHandler = (dropHandlerOwner).getDropHandler();
+
+ Object eventDetails = dropHandlerOwner
+ .getDragEventDetails((Map<String, Object>) variables.get("evt"));
+
+ currentRequest.setEventDetails(eventDetails);
+
dropHandler.handleDragRequest(currentRequest);
if (currentRequest.getType() == DragEventType.DROP) {
// TODO transferable should also be cleaned on each non-dnd
final Component sourceComponent = (Component) variables
.get("component");
+
+ variables = (Map<String, Object>) variables.get("tra");
+
if (sourceComponent != null
- && sourceComponent instanceof TransferTranslator) {
- transferable = ((TransferTranslator) sourceComponent)
- .getTransferrable(transferable, variables, false);
+ && sourceComponent instanceof DragSource) {
+ transferable = ((DragSource) sourceComponent)
+ .getTransferrable(transferable, variables);
} else {
if (transferable == null) {
if (sourceComponent != null) {
}
}
}
- /*
- * Also let dropHandler translate variables if it implements
- * TransferTranslator
- */
- if (dropHandlerOwner instanceof TransferTranslator) {
- transferable = ((TransferTranslator) dropHandlerOwner)
- .getTransferrable(transferable, variables, true);
- }
/*
* Add remaining (non-handled) variables to transferable as is
*/
- variables = (Map<String, Object>) variables.get("payload");
for (String key : variables.keySet()) {
transferable.setData(key, variables.get(key));
}
package com.vaadin.ui;
+import java.util.Map;
+
import com.vaadin.event.AbstractDropHandler;
import com.vaadin.event.ComponentTransferrable;
import com.vaadin.event.DataBindedTransferrable;
if (dropHandler == null) {
dropHandler = new AbstractDropHandler() {
@Override
- public void receive(Transferable transferable) {
+ public void receive(Transferable transferable,
+ Object dropDetails) {
+
+ DragEventDetails ed = (DragEventDetails) dropDetails;
if (transferable instanceof ComponentTransferrable) {
ComponentTransferrable ctr = (ComponentTransferrable) transferable;
Component component = ctr.getSourceComponent();
// this
DragDropPane.this.addComponent(component);
}
- Integer left = (Integer) transferable
- .getData("absoluteLeft");
- Integer top = (Integer) transferable
- .getData("absoluteTop");
- MouseEventDetails eventDetails = MouseEventDetails
- .deSerialize((String) transferable
- .getData("mouseEvent"));
+ Integer left = ed.getAbsoluteLeft();
+ Integer top = ed.getAbsoluteTop();
+
+ MouseEventDetails eventDetails = ed.getMouseEvent();
int clientX = eventDetails.getClientX();
int clientY = eventDetails.getClientY();
} else {
// drag ended inside the this Pane
- MouseEventDetails start = MouseEventDetails
- .deSerialize((String) transferable
- .getData("mouseDown"));
- MouseEventDetails eventDetails = MouseEventDetails
- .deSerialize((String) transferable
- .getData("mouseEvent"));
+ MouseEventDetails start = ed.getMouseDownEvent();
+ MouseEventDetails eventDetails = ed.getMouseEvent();
int deltaX = eventDetails.getClientX()
- start.getClientX();
return abstractDropHandler;
}
+ class DragEventDetails {
+
+ private Map<String, Object> vars;
+
+ public DragEventDetails(Map<String, Object> rawVariables) {
+ vars = rawVariables;
+ }
+
+ public Integer getAbsoluteTop() {
+ return (Integer) vars.get("absoluteTop");
+ }
+
+ public Integer getAbsoluteLeft() {
+ return (Integer) vars.get("absoluteLeft");
+ }
+
+ public MouseEventDetails getMouseDownEvent() {
+ return MouseEventDetails
+ .deSerialize((String) vars.get("mouseDown"));
+ }
+
+ public MouseEventDetails getMouseEvent() {
+ return MouseEventDetails.deSerialize((String) vars
+ .get("mouseEvent"));
+ }
+
+ }
+
+ public Object getDragEventDetails(Map<String, Object> rawVariables) {
+ return new DragEventDetails(rawVariables);
+ }
+
}
import com.vaadin.terminal.PaintException;
import com.vaadin.terminal.PaintTarget;
import com.vaadin.terminal.Resource;
-import com.vaadin.terminal.TransferTranslator;
+import com.vaadin.terminal.DragSource;
import com.vaadin.terminal.gwt.client.MouseEventDetails;
import com.vaadin.terminal.gwt.client.ui.VScrollTable;
@ClientWidget(VScrollTable.class)
public class Table extends AbstractSelect implements Action.Container,
Container.Ordered, Container.Sortable, ItemClickSource,
- TransferTranslator {
+ DragSource {
/**
* Modes that Table support as drag sourse.
}
- private void updateTransferrable(Map<String, Object> rawVariables,
- Transferable tr, boolean isDropTarget) {
- Map<String, Object> payload = (Map<String, Object>) rawVariables
- .get("payload");
- if (!isDropTarget) {
- Object object = payload.get("itemId");
- if (object != null) {
- tr.setData("itemId", itemIdMapper.get((String) object));
- payload.remove("itemId");
- }
+ private void updateTransferrable(Map<String, Object> payload,
+ Transferable tr) {
+ Object object = payload.get("itemId");
+ if (object != null) {
+ tr.setData("itemId", itemIdMapper.get((String) object));
+ payload.remove("itemId");
}
}
public Transferable getTransferrable(Transferable transferable,
- Map<String, Object> rawVariables, boolean isDropTarget) {
+ Map<String, Object> rawVariables) {
if (transferable == null) {
transferable = new TableTransferrable();
}
- updateTransferrable(rawVariables, transferable, isDropTarget);
+ updateTransferrable(rawVariables, transferable);
return transferable;
}
}
import com.vaadin.event.Transferable;
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.TransferTranslator;
import com.vaadin.terminal.gwt.client.MouseEventDetails;
import com.vaadin.terminal.gwt.client.ui.VTree;
@SuppressWarnings("serial")
@ClientWidget(VTree.class)
public class Tree extends AbstractSelect implements Container.Hierarchical,
- Action.Container, ItemClickSource, TransferTranslator, HasDropHandler {
+ Action.Container, ItemClickSource, DragSource, HasDropHandler {
private static final Method EXPAND_METHOD;
}
public Transferable getTransferrable(Transferable transferable,
- Map<String, Object> rawVariables, boolean isDropTarget) {
+ Map<String, Object> payload) {
if (transferable == null) {
transferable = new TreeTransferrable();
}
- Map<String, Object> payload = (Map<String, Object>) rawVariables
- .get("payload");
- if (isDropTarget) {
- // updating drag target variables
- Object object = payload.get("itemIdOver");
- Object object2 = itemIdMapper.get((String) object);
- transferable.setData("itemIdOver", object2);
- payload.remove("itemIdOver");
- } else {
- // updating drag source variables
- Object object = payload.get("itemId");
- if (object != null) {
- transferable.setData("itemId", itemIdMapper
- .get((String) object));
- }
- payload.remove("itemId");
+ // updating drag source variables
+ Object object = payload.get("itemId");
+ if (object != null) {
+ transferable.setData("itemId", itemIdMapper.get((String) object));
}
+ payload.remove("itemId");
return transferable;
}
this.abstractDropHandler = abstractDropHandler;
}
+ public Object getDragEventDetails(Map<String, Object> rawVariables) {
+ return new TreeDropDetails(rawVariables);
+ }
+
+ public enum Location {
+ TOP, BOTTOM, MIDDLE
+ }
+
+ public class TreeDropDetails {
+
+ private Map<String, Object> vars;
+ private Object idOver;
+
+ TreeDropDetails(Map<String, Object> rawVariables) {
+ vars = rawVariables;
+ // eagar fetch itemid, mapper may be emptied
+ String keyover = (String) vars.get("itemIdOver");
+ if (keyover != null) {
+ idOver = itemIdMapper.get(keyover);
+ }
+ }
+
+ public Object getItemIdOver() {
+ return idOver;
+ }
+
+ public Location getDropLocation() {
+ String s = (String) vars.get("detail");
+ if ("Top".equals(s)) {
+ return Location.TOP;
+ } else if ("Bottom".equals(s)) {
+ return Location.BOTTOM;
+ } else {
+ return Location.MIDDLE;
+ }
+ }
+
+ }
+
}
package com.vaadin.tests.dd;
import com.vaadin.event.ComponentTransferrable;
+import com.vaadin.event.DragRequest;
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(Transferable transferable) {
+ public boolean accepts(DragRequest request) {
+ Transferable transferable = request.getTransferable();
if (transferable instanceof ComponentTransferrable) {
ComponentTransferrable componentTransferrable = (ComponentTransferrable) transferable;
if (componentTransferrable.getSourceComponent() == tree1) {
package com.vaadin.tests.dd;
+import java.util.Map;
+
import com.vaadin.event.AbstractDropHandler;
import com.vaadin.event.DragRequest;
import com.vaadin.event.DropHandler;
public DropHandler getDropHandler() {
return new DropHandler() {
- public void handleDragRequest(DragRequest event) {
- Transferable transferable = event.getTransferrable();
- DragEventType type = event.getType();
+ public void handleDragRequest(DragRequest dragRequest) {
+ Transferable transferable = dragRequest.getTransferable();
+ DragEventType type = dragRequest.getType();
switch (type) {
case DROP:
// Do something with data
case ENTER:
// eg. validate transferrable
if (transferable.getDataFlawors().contains("Foo")) {
- event.getResponseData().put("valueFor",
+ dragRequest.getResponseData().put("valueFor",
"clientSideCallBack");
}
};
}
+ 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;
+ }
+
}
/**
import com.vaadin.event.AbstractDropHandler;
import com.vaadin.event.ComponentTransferrable;
import com.vaadin.event.DataBindedTransferrable;
+import com.vaadin.event.DragRequest;
import com.vaadin.event.Transferable;
import com.vaadin.event.AbstractDropHandler.AcceptCriterion;
import com.vaadin.terminal.ExternalResource;
import com.vaadin.ui.Table;
import com.vaadin.ui.Tree;
import com.vaadin.ui.Table.DragModes;
+import com.vaadin.ui.Tree.Location;
+import com.vaadin.ui.Tree.TreeDropDetails;
/**
* DD playground. Better quality example/prototype codes in {@link DDTest2}.
.setCaption("Pane2 (accept needs server side visit, only \"Bar\")");
AcceptCriterion f = new AcceptCriterion() {
- public boolean accepts(Transferable transferable) {
+ public boolean accepts(DragRequest request) {
+ Transferable transferable = request.getTransferable();
// System.out.println("Simulating 500ms processing...");
// try {
// Thread.sleep(200);
AbstractDropHandler itemSorter = new AbstractDropHandler() {
@Override
- public void receive(Transferable transferable) {
+ public void receive(Transferable transferable, Object dropdetails) {
+ TreeDropDetails details = (TreeDropDetails) dropdetails;
// TODO set properties, so same sorter could be used in Table
if (transferable instanceof DataBindedTransferrable) {
DataBindedTransferrable transferrable2 = (DataBindedTransferrable) transferable;
Object itemId = transferrable2.getItemId();
- Object itemIdOver = transferable.getData("itemIdOver");
+ Object itemIdOver = details.getItemIdOver();
- String detail = ((String) transferable.getData("detail"))
- .toLowerCase();
+ Location dropLocation = details.getDropLocation();
- if ("center".equals(detail)) {
+ if (dropLocation == Location.MIDDLE) {
t.setParent(itemId, itemIdOver);
return;
- } else if ("top".equals(detail)) {
+ } else if (Location.TOP == dropLocation) {
// if on top of the caption area, add before
itemIdOver = idx.prevItemId(itemIdOver);
}
if (removed) {
- if (detail == null) {
+ if (dropLocation == null) {
System.err
.println("No detail of drop place available");
}
import com.vaadin.ui.Table;
import com.vaadin.ui.Tree;
import com.vaadin.ui.Window;
+import com.vaadin.ui.Tree.TreeDropDetails;
public class DDTest2 extends TestBase {
AbstractDropHandler dropHandler = new AbstractDropHandler() {
@Override
- public void receive(Transferable transferable) {
+ public void receive(Transferable transferable, Object dropdetails) {
/*
* We know transferrable is from table, so it is of type
* DataBindedTransferrable
Table fromTable = (Table) tr.getSourceComponent();
String name = fromTable.getItem(itemId).getItemProperty("Name")
.toString();
+
tree1.addItem(name);
tree1.setChildrenAllowed(name, false);
/*
- * As we also accept only drops on folders, we know data
- * contains itemIdOver
+ * As we also accept only drops on folders, we know dropDetails
+ * is from Tree and it contains itemIdOver.
*/
- Object idOver = tr.getData("itemIdOver");
+ TreeDropDetails details = (TreeDropDetails) dropdetails;
+ Object idOver = details.getItemIdOver();
tree1.setParent(name, idOver);
/*
dropHandler = new AbstractDropHandler() {
@Override
- public void receive(Transferable transferable) {
+ public void receive(Transferable transferable, Object dropdetails) {
+ TreeDropDetails details = (TreeDropDetails) dropdetails;
+
if (transferable instanceof DataBindedTransferrable) {
DataBindedTransferrable tr = (DataBindedTransferrable) transferable;
Object itemId = tree2.addItem();
- tree2.setParent(itemId, tr.getData("itemIdOver"));
+ tree2.setParent(itemId, details.getItemIdOver());
if (tr.getSourceComponent() == tree1) {
// use item id from tree1 as caption
tree2.setItemCaption(itemId, (String) tr.getItemId());
projects / vaadin-framework.git / commitdiff