if (mDown && dragmode != 0) {
VTransferable transferable = new VTransferable();
transferable.setComponent(VScrollTable.this);
- transferable.setItemId("" + rowKey);
+ transferable.setData("itemId", "" + rowKey);
// TODO propertyId
VDragEvent ev = VDragAndDropManager.get()
import com.vaadin.terminal.gwt.client.Paintable;
import com.vaadin.terminal.gwt.client.UIDL;
import com.vaadin.terminal.gwt.client.Util;
-import com.vaadin.terminal.gwt.client.ValueMap;
import com.vaadin.terminal.gwt.client.ui.dd.VAbstractDropHandler;
import com.vaadin.terminal.gwt.client.ui.dd.VAcceptCallback;
import com.vaadin.terminal.gwt.client.ui.dd.VDragAndDropManager;
import com.vaadin.terminal.gwt.client.ui.dd.VDropHandler;
import com.vaadin.terminal.gwt.client.ui.dd.VHasDropHandler;
import com.vaadin.terminal.gwt.client.ui.dd.VTransferable;
-import com.vaadin.terminal.gwt.client.ui.dd.VDragAndDropManager.DragEventType;
/**
*
@Override
protected void dragAccepted(final VDragEvent drag) {
+
}
@Override
ApplicationConnection.getConsole().log(
"Change in Transferable " + currentMouseOverKey
+ " " + detail);
- VAcceptCallback accpectedCb = new VAcceptCallback() {
- public void handleResponse(ValueMap responseData) {
- if (responseData == null // via client
- // side
- // validation
- || responseData.containsKey("accepted")) {
- keyToNode.get(currentMouseOverKey)
- .emphasis(detail);
- }
- }
- };
- if (validateOnServer()) {
- VDragAndDropManager.get().visitServer(
- DragEventType.OVER, accpectedCb);
-
- } else {
- if (validates(currentDrag)) {
- accpectedCb.handleResponse(null);
- } else {
+ validate(new VAcceptCallback() {
+ public void accepted() {
keyToNode.get(currentMouseOverKey).emphasis(
- null);
- }
- if (oldIdOver != null
- && oldIdOver != currentMouseOverKey) {
- keyToNode.get(oldIdOver).emphasis(null);
+ detail);
}
+ }, currentDrag);
+ if (oldIdOver != null
+ && oldIdOver != currentMouseOverKey) {
+ keyToNode.get(oldIdOver).emphasis(null);
}
}
// start actual drag on slight move when mouse is down
VTransferable t = new VTransferable();
t.setComponent(VTree.this);
- t.setItemId(key);
+ t.setData("itemId", key);
VDragEvent drag = VDragAndDropManager.get().startDrag(
t, mouseDownEvent, true);
package com.vaadin.terminal.gwt.client.ui.dd;
+import com.vaadin.event.AbstractDropHandler;
+import com.vaadin.event.DropTarget;
+import com.vaadin.event.Transferable;
+import com.vaadin.event.AbstractDropHandler.AcceptCriterion;
import com.vaadin.terminal.gwt.client.Paintable;
import com.vaadin.terminal.gwt.client.UIDL;
-import com.vaadin.terminal.gwt.client.ValueMap;
-import com.vaadin.terminal.gwt.client.ui.dd.VDragAndDropManager.DragEventType;
public abstract class VAbstractDropHandler implements VDropHandler {
- private boolean serverValidate;
+ private boolean mustValidateOnServer = true;
private UIDL criterioUIDL;
+ /**
+ * Implementor/user of {@link VAbstractDropHandler} must pass the UIDL
+ * painted by {@link AbstractDropHandler} (the server side counterpart) to
+ * this method. Practically the details about {@link AcceptCriterion} are
+ * saved.
+ *
+ * @param uidl
+ */
public void updateRules(UIDL uidl) {
- serverValidate = uidl.getBooleanAttribute("serverValidate");
+ mustValidateOnServer = uidl.getBooleanAttribute("serverValidate");
int childCount = uidl.getChildCount();
for (int i = 0; i < childCount; i++) {
UIDL childUIDL = uidl.getChildUIDL(i);
if (childUIDL.getTag().equals("acceptCriterion")) {
criterioUIDL = childUIDL;
- // TODO consider parsing the criteria tree here instead of
- // translating uidl during validates()
-
}
}
}
- public boolean validateOnServer() {
- return serverValidate;
- }
-
/**
* Default implementation does nothing.
*/
}
/**
- * Default implementation does nothing.
+ * Default implementation does nothing. Implementors should clean possible
+ * emphasis or drag icons here.
*/
public void dragLeave(VDragEvent drag) {
- // TODO Auto-generated method stub
}
/**
+ * The default implementation in {@link VAbstractDropHandler} checks if the
+ * Transferable is accepted.
+ * <p>
* If transferable is accepted (either via server visit or client side
- * rules) the default implementation calls {@link #dragAccepted(VDragEvent)}
- * method.
+ * rules) the default implementation calls abstract
+ * {@link #dragAccepted(VDragEvent)} method.
+ * <p>
+ * If drop handler has distinct places where some parts may accept the
+ * {@link Transferable} and others don't, one should use similar validation
+ * logic in dragOver method and replace this method with empty
+ * implementation.
+ *
*/
public void dragEnter(final VDragEvent drag) {
- if (serverValidate) {
- VDragAndDropManager.get().visitServer(DragEventType.ENTER,
- new VAcceptCallback() {
- public void handleResponse(ValueMap responseData) {
- if (responseData.containsKey("accepted")) {
- dragAccepted(drag);
- }
- }
- });
- } else if (validates(drag)) {
- dragAccepted(drag);
- }
+ validate(new VAcceptCallback() {
+ public void accepted() {
+ dragAccepted(drag);
+ }
+ }, drag);
}
+ /**
+ * This method is called when a valid drop location was found with
+ * {@link AcceptCriterion} either via client or server side check.
+ * <p>
+ * Implementations can set some hints for users here to highlight that the
+ * drag is on a valid drop location.
+ *
+ * @param drag
+ */
abstract protected void dragAccepted(VDragEvent drag);
+ protected void validate(VAcceptCallback cb, VDragEvent event) {
+ if (mustValidateOnServer) {
+ VDragAndDropManager.get().visitServer(cb);
+ } else if (validateOnClient(event)) {
+ cb.accepted();
+ }
+ }
+
/**
* Returns true if client side rules are met.
*
* @param drag
* @return
*/
- protected boolean validates(VDragEvent drag) {
+ protected boolean validateOnClient(VDragEvent drag) {
if (criterioUIDL != null) {
String criteriaName = criterioUIDL.getStringAttribute("name");
VAcceptCriteria acceptCriteria = VAcceptCriterion.get(criteriaName);
return false;
}
+ /**
+ * The default implemmentation visits server if {@link AcceptCriterion}
+ * can't be verified on client or if {@link AcceptCriterion} are met on
+ * client.
+ */
public boolean drop(VDragEvent drag) {
- if (serverValidate) {
+ if (mustValidateOnServer) {
return true;
} else {
- return validates(drag);
+ return validateOnClient(drag);
}
}
+ /**
+ * Returns the Paintable who owns this {@link VAbstractDropHandler}. Server
+ * side counterpart of the Paintable is expected to implement
+ * {@link DropTarget} interface.
+ */
public abstract Paintable getPaintable();
}
package com.vaadin.terminal.gwt.client.ui.dd;
-import com.vaadin.terminal.gwt.client.ValueMap;
public interface VAcceptCallback {
/**
* This method is called by {@link VDragAndDropManager} if the
* {@link VDragEvent} is still active. Developer can update for example drag
- * icon or target emphasis based on the information returned from server
- * side. If the drag and drop operation ends or the
- * {@link VAbstractDropHandler} has changed before response arrives, the
- * method is never called.
- *
- * @param responseData
+ * icon or empahsis the target if the target accepts the transferable. If
+ * the drag and drop operation ends or the {@link VAbstractDropHandler} has
+ * changed before response arrives, the method is never called.
*/
- public void handleResponse(ValueMap responseData);
+ public void accepted();
}
import com.google.gwt.core.client.GWT;
+/**
+ * A class via all AcceptCriteria instances are fetched by an identifier.
+ */
public class VAcceptCriterion {
protected static Map<String, VAcceptCriteria> criterion = new HashMap<String, VAcceptCriteria>();
private static VAcceptCriterionImpl impl;
private final class HasItemId implements VAcceptCriteria {
public boolean accept(VDragEvent drag, UIDL configuration) {
- return drag.getTransferable().getItemId() != null;
+ return drag.getTransferable().getData("itemId") != null;
}
}
/**
- * TODO this method could be written by generator
+ * TODO this class/method must be written by generator
*
- * TODO consider moving implementations to top level classes
+ * TODO move implementations to top level classes.
*
* TODO use fully qualified names of server side counterparts as keys
*/
private NativePreviewHandler defaultDragAndDropEventHandler = new DefaultDragAndDropEventHandler();
+ /**
+ * Flag to indicate if drag operation has really started or not. Null check
+ * of currentDrag field is not enough as a lazy start may be pending.
+ */
+ private boolean isStarted;
+
/**
* This method is used to start Vaadin client side drag and drop operation.
* Operation may be started by virtually any Widget.
public VDragEvent startDrag(VTransferable transferable,
final NativeEvent startEvent, final boolean handleDragEvents) {
interruptDrag();
+ isStarted = false;
currentDrag = new VDragEvent(transferable, startEvent);
updateCurrentEvent(startEvent);
final Command startDrag = new Command() {
public void execute() {
+ isStarted = true;
VDropHandler dh = null;
if (startEvent != null) {
dh = findDragTarget((Element) currentDrag.currentGwtEvent
if (handleDragEvents) {
handlerRegistration = Event
.addNativePreviewHandler(defaultDragAndDropEventHandler);
+ if (dragElement != null
+ && dragElement.getParentElement() == null) {
+ // deferred attaching drag image is on going, we can
+ // hurry with it now
+ lazyAttachDragElement.cancel();
+ lazyAttachDragElement.run();
+ }
}
}
};
- if (handleDragEvents) {
+ if (handleDragEvents
+ && Event.as(startEvent).getTypeInt() == Event.ONMOUSEDOWN) {
// only really start drag event on mousemove
- if (Event.as(startEvent).getTypeInt() == Event.ONMOUSEDOWN) {
-
- deferredStartRegistration = Event
- .addNativePreviewHandler(new NativePreviewHandler() {
-
- public void onPreviewNativeEvent(
- NativePreviewEvent event) {
- int typeInt = event.getTypeInt();
- switch (typeInt) {
- case Event.ONMOUSEOVER:
- if (dragElement == null
- || !dragElement
- .isOrHasChild((Node) event
- .getNativeEvent()
- .getCurrentEventTarget()
- .cast())) {
- // drag image appeared below, ignore
- ApplicationConnection.getConsole().log(
- "Drag image appeared");
- break;
- }
- case Event.ONKEYDOWN:
- case Event.ONKEYPRESS:
- case Event.ONKEYUP:
- case Event.ONBLUR:
- // don't cancel possible drag start
- break;
- case Event.ONMOUSEOUT:
-
- if (dragElement == null
- || !dragElement
- .isOrHasChild((Node) event
- .getNativeEvent()
- .getRelatedEventTarget()
- .cast())) {
- // drag image appeared below, ignore
- ApplicationConnection.getConsole().log(
- "Drag image appeared");
- break;
- }
- case Event.ONMOUSEMOVE:
- deferredStartRegistration.removeHandler();
- deferredStartRegistration = null;
- updateCurrentEvent(event.getNativeEvent());
- startDrag.execute();
+ deferredStartRegistration = Event
+ .addNativePreviewHandler(new NativePreviewHandler() {
+
+ public void onPreviewNativeEvent(
+ NativePreviewEvent event) {
+ int typeInt = event.getTypeInt();
+ switch (typeInt) {
+ case Event.ONMOUSEOVER:
+ if (dragElement == null
+ || !dragElement
+ .isOrHasChild((Node) event
+ .getNativeEvent()
+ .getCurrentEventTarget()
+ .cast())) {
+ // drag image appeared below, ignore
+ ApplicationConnection.getConsole().log(
+ "Drag image appeared");
break;
- default:
- // on any other events, clean up the
- // deferred drag start
+ }
+ case Event.ONKEYDOWN:
+ case Event.ONKEYPRESS:
+ case Event.ONKEYUP:
+ case Event.ONBLUR:
+ // don't cancel possible drag start
+ break;
+ case Event.ONMOUSEOUT:
+
+ if (dragElement == null
+ || !dragElement
+ .isOrHasChild((Node) event
+ .getNativeEvent()
+ .getRelatedEventTarget()
+ .cast())) {
+ // drag image appeared below, ignore
ApplicationConnection.getConsole().log(
- "Drag did not start due event"
- + event.getNativeEvent()
- .getType());
-
- deferredStartRegistration.removeHandler();
- deferredStartRegistration = null;
- currentDrag = null;
- if (dragElement != null) {
- RootPanel.getBodyElement().removeChild(
- dragElement);
- dragElement = null;
- }
+ "Drag image appeared");
break;
}
-
+ case Event.ONMOUSEMOVE:
+ deferredStartRegistration.removeHandler();
+ deferredStartRegistration = null;
+ updateCurrentEvent(event.getNativeEvent());
+ startDrag.execute();
+ break;
+ default:
+ // on any other events, clean up the
+ // deferred drag start
+ ApplicationConnection.getConsole().log(
+ "Drag did not start due event"
+ + event.getNativeEvent()
+ .getType());
+
+ deferredStartRegistration.removeHandler();
+ deferredStartRegistration = null;
+ currentDrag = null;
+ if (dragElement != null) {
+ RootPanel.getBodyElement().removeChild(
+ dragElement);
+ dragElement = null;
+ }
+ break;
}
- });
+ }
- } else {
- startDrag.execute();
- }
+ });
} else {
startDrag.execute();
currentDrag = null;
if (dragElement != null) {
- RootPanel.getBodyElement().removeChild(dragElement);
+ if (dragElement.getParentElement() != null) {
+ RootPanel.getBodyElement().removeChild(dragElement);
+ }
dragElement = null;
}
}
*
* @param acceptCallback
*/
- public void visitServer(DragEventType type, VAcceptCallback acceptCallback) {
- doRequest(type);
+ public void visitServer(VAcceptCallback acceptCallback) {
+ doRequest(DragEventType.ENTER);
this.acceptCallback = acceptCallback;
}
VTransferable transferable = currentDrag.getTransferable();
- if (transferable.getItemId() != null) {
- client.updateVariable(DD_SERVICE, "itemId", transferable
- .getItemId(), false);
- }
- if (transferable.getPropertyId() != null) {
- client.updateVariable(DD_SERVICE, "propertyId", transferable
- .getPropertyId(), false);
- }
-
client.updateVariable(DD_SERVICE, "component", transferable
.getComponent(), false);
}
int visitId = valueMap.getInt("visitId");
if (this.visitId == visitId) {
- acceptCallback.handleResponse(valueMap);
+ if (valueMap.containsKey("accepted")) {
+ acceptCallback.accepted();
+ }
acceptCallback = null;
}
}
style.setZIndex(600000);
updateDragImagePosition();
- /*
- * To make our default dnd handler as compatible as possible, we
- * need to defer the appearance of dragElement. Otherwise events
- * that are derived from sequences of other events might not fire as
- * domchanged will fire between them.
- */
- lazyAttachDragElement.schedule(300);
+ if (isStarted) {
+ lazyAttachDragElement.run();
+ } else {
+ /*
+ * To make our default dnd handler as compatible as possible, we
+ * need to defer the appearance of dragElement. Otherwise events
+ * that are derived from sequences of other events might not
+ * fire as domchanged will fire between them or mouse up might
+ * happen on dragElement.
+ */
+ lazyAttachDragElement.schedule(300);
+ }
}
}
@Override
public void run() {
- if (dragElement != null) {
+ if (dragElement != null && dragElement.getParentElement() == null) {
RootPanel.getBodyElement().appendChild(dragElement);
}
import com.google.gwt.dom.client.TableElement;
import com.google.gwt.dom.client.TableSectionElement;
import com.google.gwt.dom.client.Style.Unit;
+import com.google.gwt.event.dom.client.MouseOverEvent;
import com.google.gwt.user.client.Element;
import com.vaadin.terminal.gwt.client.BrowserInfo;
return transferable;
}
+ /**
+ * Returns the the latest {@link NativeEvent} that relates to this drag and
+ * drop operation. For example on {@link VDropHandler#dragEnter(VDragEvent)}
+ * this is commonly a {@link MouseOverEvent}.
+ *
+ * @return
+ */
public NativeEvent getCurrentGwtEvent() {
return currentGwtEvent;
}
- public int getEventId() {
+ int getEventId() {
return id;
}
+ /**
+ * @deprecated will be removed from final implementation, here just to aid
+ * development.
+ */
+ @Deprecated
public long sinceStart() {
return new Date().getTime() - start.getTime();
}
/**
* Detecting the element on which the the event is happening may be
* problematic during drag and drop operation. This is especially the case
- * if a drag image (often called drag proxy) is kept under the mouse cursor
- * (see {@link #createDragImage(Element, boolean)}. Drag and drop event
- * handlers (like the one provided by {@link VDragAndDropManager} ) should
- * set elmentOver field to reflect the the actual element on which the
- * pointer currently is (drag image excluded). {@link VDropHandler}s can
+ * if a drag image (often called also drag proxy) is kept under the mouse
+ * cursor (see {@link #createDragImage(Element, boolean)}. Drag and drop
+ * event handlers (like the one provided by {@link VDragAndDropManager} )
+ * should set elmentOver field to reflect the the actual element on which
+ * the pointer currently is (drag image excluded). {@link VDropHandler}s can
* then more easily react properly on drag events by reading the element via
* this method.
*
* TODO decide if this method should be here or in {@link VTransferable} (in
* HTML5 it is in DataTransfer) or {@link VDragAndDropManager}
*
- * TODO should be possible to override behaviour an set to HTML5
- * DataTransfer
+ * TODO should be possible to override behavior. Like to proxy the element
+ * to HTML5 DataTransfer
*
* @param node
*/
import com.google.gwt.core.client.JsArrayString;
import com.google.gwt.dom.client.NativeEvent;
+/**
+ * Helper class to access html5 style drag events.
+ *
+ */
public class VHtml5DragEvent extends NativeEvent {
protected VHtml5DragEvent() {
}
private final Map<String, Object> variables = new HashMap<String, Object>();
/**
+ * Returns the component currently being dragged or from which the
+ * transferable is created (eg. a tree which node is dragged).
+ *
* @return the component
*/
public Paintable getComponent() {
}
/**
+ * Sets the component currently being dragged or from which the transferable
+ * is created (eg. a tree which node is dragged).
+ * <p>
+ * The server side counterpart of the componennt may implement
+ * {@link DragSource} interface if it wants to translate or complement the
+ * server side instance of this Transferable.
+ *
* @param component
* the component to set
*/
this.component = component;
}
- /**
- * This is commonly actually a key to property id on client side than the
- * actual propertyId.
- *
- * Translated by terminal and {@link DragSource}
- *
- * @return the propertyId
- */
- public String getPropertyId() {
- return (String) variables.get("propertyId");
- }
-
- /**
- * This is commonly actually a key to property id on client side than the
- * actual propertyId.
- *
- * Translated by terminal and {@link DragSource}
- *
- * @param propertyId
- * the propertyId to set
- */
- public void setPropertyId(String propertyId) {
- variables.put("propertyId", propertyId);
- }
-
- /**
- * @return the itemId
- */
- public String getItemId() {
- return (String) variables.get("itemId");
- }
-
- /**
- * This is commonly actually a key to item id on client side than the actual
- * itemId.
- *
- * Translated by terminal and {@link DragSource}
- *
- * @param itemId
- * the itemId to set
- */
- public void setItemId(String itemId) {
- variables.put("itemId", itemId);
- }
-
public Object getData(String dataFlawor) {
return variables.get(dataFlawor);
}
}
/**
- * This method should only be called by {@link VDragAndDropManager}.
+ * This helper method should only be called by {@link VDragAndDropManager}.
*
* @return data in this Transferable that needs to be moved to server.
*/
- public Map<String, Object> getVariableMap() {
+ Map<String, Object> getVariableMap() {
return variables;
}
import com.vaadin.terminal.gwt.client.ApplicationConnection;
import com.vaadin.terminal.gwt.client.Paintable;
import com.vaadin.terminal.gwt.client.UIDL;
-import com.vaadin.terminal.gwt.client.ValueMap;
import com.vaadin.terminal.gwt.client.ui.dd.VAcceptCallback;
import com.vaadin.terminal.gwt.client.ui.dd.VDragAndDropManager;
import com.vaadin.terminal.gwt.client.ui.dd.VDragEvent;
import com.vaadin.terminal.gwt.client.ui.dd.VDropHandler;
import com.vaadin.terminal.gwt.client.ui.dd.VHasDropHandler;
-import com.vaadin.terminal.gwt.client.ui.dd.VDragAndDropManager.DragEventType;
public class VMyDropTarget extends Composite implements VHasDropHandler,
VDropHandler, Paintable {
private ApplicationConnection client;
public void dragEnter(VDragEvent drag) {
- VDragAndDropManager.get().visitServer(DragEventType.ENTER,
- new VAcceptCallback() {
- public void handleResponse(ValueMap responseData) {
- // show hints, error messages etc
- }
- });
+ VDragAndDropManager.get().visitServer(new VAcceptCallback() {
+ public void accepted() {
+ // show drag hints here
+ }
+ });
}
public void dragLeave(VDragEvent drag) {
projects / vaadin-framework.git / commitdiff