+++ /dev/null
-package com.vaadin.event;
-
-import com.vaadin.terminal.PaintException;
-import com.vaadin.terminal.PaintTarget;
-import com.vaadin.ui.Component;
-import com.vaadin.ui.Tree.Location;
-import com.vaadin.ui.Tree.TreeDropDetails;
-
-/**
- * An implementation of DropHandler interface.
- *
- * AcceptCriterion may be used to configure accept rules. Using them can result
- * client side verifiable accept rules for quick feedback in UI. Still rules are
- * also validate on server so implementor don't need to double check validity on
- * {@link #receive(Transferable)} method.
- *
- */
-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(Transferable transferable,
- DragDropDetails dragDropDetails);
- }
-
- public interface ClientSideVerifiable extends AcceptCriterion {
-
- /**
- * May depend on state, like in OR or AND, so to be really
- * ClientSideVerifiable needs to return true here (instead of just
- * implementing marker interface).
- */
- public boolean isClientSideVerifiable();
-
- public void paint(PaintTarget target) throws PaintException;
-
- }
-
- private static final class AcceptAll implements ClientSideVerifiable {
-
- public boolean accepts(Transferable transferable,
- DragDropDetails dragDropDetails) {
- return true;
- }
-
- public boolean isClientSideVerifiable() {
- return true;
- }
-
- public void paint(PaintTarget target) throws PaintException {
- target.startTag("acceptCriterion");
- target.addAttribute("name", "acceptAll");
- target.endTag("acceptCriterion");
- }
- }
-
- public static class And implements ClientSideVerifiable {
- private AcceptCriterion f1;
- private AcceptCriterion f2;
-
- public And(AcceptCriterion f1, AcceptCriterion f2) {
- this.f1 = f1;
- this.f2 = f2;
- }
-
- public boolean accepts(Transferable transferable,
- DragDropDetails dragDropDetails) {
- return f1.accepts(transferable, dragDropDetails)
- && f2.accepts(transferable, dragDropDetails);
- }
-
- public boolean isClientSideVerifiable() {
- boolean a1 = f1 instanceof ClientSideVerifiable ? ((ClientSideVerifiable) f1)
- .isClientSideVerifiable()
- : false;
- boolean a2 = f2 instanceof ClientSideVerifiable ? ((ClientSideVerifiable) f2)
- .isClientSideVerifiable()
- : false;
- return a1 && a2;
- }
-
- public void paint(PaintTarget target) throws PaintException {
- target.startTag("acceptCriterion");
- target.addAttribute("name", "and");
- ((ClientSideVerifiable) f1).paint(target);
- ((ClientSideVerifiable) f2).paint(target);
- target.endTag("acceptCriterion");
- }
- }
-
- public static class ComponentFilter implements ClientSideVerifiable {
- private Component component;
-
- public ComponentFilter(Component component) {
- this.component = component;
- }
-
- public boolean accepts(Transferable transferable,
- DragDropDetails dragDropDetails) {
- if (transferable instanceof ComponentTransferable) {
- return ((ComponentTransferable) transferable)
- .getSourceComponent() == component;
- } else {
- return false;
- }
- }
-
- public boolean isClientSideVerifiable() {
- return true;
- }
-
- public void paint(PaintTarget target) throws PaintException {
- target.startTag("acceptCriterion");
- target.addAttribute("name", "component");
- target.addAttribute("component", component);
- target.endTag("acceptCriterion");
- }
- }
-
- private static final class IsDataBinded implements ClientSideVerifiable {
- public boolean accepts(Transferable transferable,
- DragDropDetails dragDropDetails) {
- if (transferable instanceof DataBindedTransferable) {
- return ((DataBindedTransferable) transferable).getItemId() != null;
- }
- return false;
- }
-
- public boolean isClientSideVerifiable() {
- return true;
- }
-
- public void paint(PaintTarget target) throws PaintException {
- target.startTag("acceptCriterion");
- target.addAttribute("name", "needsItemId");
- target.endTag("acceptCriterion");
- }
- }
-
- public class Not implements AcceptCriterion {
- private AcceptCriterion acceptCriterion;
-
- public Not(AcceptCriterion acceptCriterion) {
- this.acceptCriterion = acceptCriterion;
- }
-
- public boolean accepts(Transferable transferable,
- DragDropDetails dragDropDetails) {
- return !acceptCriterion.accepts(transferable, dragDropDetails);
- }
-
- }
-
- public class Or implements AcceptCriterion {
- private AcceptCriterion f1;
- private AcceptCriterion f2;
-
- Or(AcceptCriterion f1, AcceptCriterion f2) {
- this.f1 = f1;
- this.f2 = f2;
- }
-
- 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(Transferable transferable,
- DragDropDetails dragDropDetails) {
- try {
- TreeDropDetails eventDetails = (TreeDropDetails) dragDropDetails;
- return eventDetails.getDropLocation() == Location.MIDDLE;
- } catch (Exception e) {
- return false;
- }
- }
-
- public boolean isClientSideVerifiable() {
- return true;
- }
-
- public void paint(PaintTarget target) throws PaintException {
- target.startTag("acceptCriterion");
- target.addAttribute("name", "overTreeNode");
- target.endTag("acceptCriterion");
- }
-
- }
-
- public static final AcceptCriterion CRITERION_ACCEPT_ALL = new AcceptAll();
-
- public static final AcceptCriterion CRITERION_HAS_ITEM_ID = new IsDataBinded();
-
- private AcceptCriterion acceptCriterion = CRITERION_ACCEPT_ALL;
-
- /*
- * (non-Javadoc)
- *
- * @seecom.vaadin.event.DropHandler#acceptTransferable(com.vaadin.event.
- * Transferable)
- */
- public boolean acceptTransferable(Transferable transferable,
- DragDropDetails dragDropDetails) {
- return acceptCriterion.accepts(transferable, dragDropDetails);
- }
-
- private boolean clientSideVerifiable() {
- if (acceptCriterion instanceof ClientSideVerifiable) {
- return ((ClientSideVerifiable) acceptCriterion)
- .isClientSideVerifiable();
- }
- return false;
- }
-
- 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 {
- target.startTag("dh");
- if (!clientSideVerifiable()) {
- target.addAttribute("serverValidate", true);
- } else {
- ((ClientSideVerifiable) acceptCriterion).paint(target);
- }
- target.endTag("dh");
- }
-
- /*
- * (non-Javadoc)
- *
- * @see com.vaadin.event.DropHandler#receive(com.vaadin.event.Transferable)
- */
- public abstract void receive(Transferable transferable,
- DragDropDetails dropDetails);
-
- public void setAcceptCriterion(AcceptCriterion acceptCriterion) {
- this.acceptCriterion = acceptCriterion;
- }
-
-}
+++ /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);
-
-}
+++ /dev/null
-package com.vaadin.event;
-
-import java.util.HashMap;
-import java.util.Map;
-
-import com.vaadin.terminal.gwt.client.ui.dd.VDragAndDropManager.DragEventType;
-
-public class DragRequest {
-
- private DragEventType dragEventType;
- private Map<String, Object> responseData;
-
- public DragRequest(DragEventType dragEventType) {
- this.dragEventType = dragEventType;
- }
-
- public DragEventType getType() {
- return dragEventType;
- }
-
- public Map<String, Object> getResponseData() {
- return responseData;
- }
-
- /**
- * DropHanler can pass simple parameters back to client side.
- *
- * TODO define which types are supported (most likely the same as in UIDL)
- *
- * @param key
- * @param value
- */
- public void setResponseParameter(String key, Object value) {
- if (responseData == null) {
- responseData = new HashMap<String, Object>();
- }
- responseData.put(key, value);
- }
-
-}
+++ /dev/null
-package com.vaadin.event;
-
-public interface DropHandler {
-
- 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.dd;
+
+import java.io.Serializable;
+
+import com.vaadin.event.Transferable;
+
+public abstract class DragAndDropEvent implements Serializable {
+ private static final long serialVersionUID = -2232591107911385564L;
+ private Transferable transferable;
+ private TargetDetails dropDetails;
+
+ public DragAndDropEvent(Transferable tr, TargetDetails details) {
+ transferable = tr;
+ dropDetails = details;
+ }
+
+ public Transferable getTransferable() {
+ return transferable;
+ }
+
+ public TargetDetails getDropTargetData() {
+ return dropDetails;
+ }
+}
--- /dev/null
+package com.vaadin.event.dd;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import com.vaadin.event.Transferable;
+
+public class DragEvent extends DragAndDropEvent {
+
+ private HashMap<String, Object> responseData;
+
+ public DragEvent(Transferable tr, TargetDetails details) {
+ super(tr, details);
+ }
+
+ private static final long serialVersionUID = 7105802828455781246L;
+
+ public void setResponseData(String key, Object value) {
+ if (responseData != null) {
+ responseData = new HashMap<String, Object>();
+ }
+ responseData.put(key, value);
+ }
+
+ /**
+ * non-api, used by terminal
+ *
+ * @return
+ */
+ public Map<String, Object> getResponseData() {
+ return responseData;
+ }
+
+}
--- /dev/null
+package com.vaadin.event.dd;
+
+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 getTransferable(Transferable transferable,
+ Map<String, Object> rawVariables);
+
+}
\ No newline at end of file
--- /dev/null
+package com.vaadin.event.dd;
+
+import com.vaadin.event.Transferable;
+
+public class DropEvent extends DragAndDropEvent {
+
+ public DropEvent(Transferable tr, TargetDetails details) {
+ super(tr, details);
+ }
+}
--- /dev/null
+package com.vaadin.event.dd;
+
+import com.vaadin.event.dd.acceptCriteria.AcceptAll;
+import com.vaadin.event.dd.acceptCriteria.AcceptCriterion;
+
+public interface DropHandler {
+
+ public void drop(DropEvent dropEvent);
+
+ /**
+ * Returns the {@link AcceptCriterion} used to evaluate whether the
+ * {@link Transferable} will be handed over to {@link DropHandler}. If
+ * client side can't verify the {@link AcceptCriterion}, the same criteria
+ * may be tested also prior to actual drop - during the drag operation.
+ * <p>
+ * If everything is accepted developer can return {@link AcceptAll}
+ * instance.
+ *
+ * @return the {@link AcceptCriterion}
+ */
+ public AcceptCriterion getAcceptCriterion();
+
+}
--- /dev/null
+package com.vaadin.event.dd;
+
+import java.util.Map;
+
+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();
+
+ /**
+ * 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 terminal implementation will
+ * automatically create a {@link TargetDetails} with all the client
+ * variables.
+ * <p>
+ * If this method returns null the data from client side will be passed
+ * through as-is without conversion.
+ *
+ * @param rawVariables
+ * Parameters passed from the client side widget.
+ * @return A DropData object with the translated data or null.
+ */
+ public TargetDetails translateDragDropDetails(
+ Map<String, Object> clientVariables);
+
+}
\ No newline at end of file
--- /dev/null
+package com.vaadin.event.dd;
+
+public interface TargetDetails {
+ public Object getData(String key);
+
+ public Object setData(String key, Object value);
+
+ public DropTarget getTarget();
+
+}
--- /dev/null
+package com.vaadin.event.dd;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import com.vaadin.terminal.gwt.server.DragAndDropService;
+
+public class TargetDetailsImpl implements TargetDetails {
+
+ private HashMap<String, Object> data = new HashMap<String, Object>();
+
+ public TargetDetailsImpl(Map<String, Object> rawDropData) {
+ data.putAll(rawDropData);
+ }
+
+ public Object getData(String key) {
+ return data.get(key);
+ }
+
+ public Object setData(String key, Object value) {
+ return data.put(key, value);
+ }
+
+ public DropTarget getTarget() {
+ return (DropTarget) data.get(DragAndDropService.DROPTARGET_KEY);
+ }
+}
\ No newline at end of file
--- /dev/null
+/**
+ *
+ */
+package com.vaadin.event.dd.acceptCriteria;
+
+import com.vaadin.event.dd.DragAndDropEvent;
+import com.vaadin.terminal.PaintException;
+import com.vaadin.terminal.PaintTarget;
+
+public final class AcceptAll implements AcceptCriterion {
+
+ private static AcceptCriterion singleton = new AcceptAll();
+
+ private AcceptAll() {
+ }
+
+ public boolean isClientSideVerifiable() {
+ return true;
+ }
+
+ public void paint(PaintTarget target) throws PaintException {
+ target.startTag("-ac");
+ target.addAttribute("name", "acceptAll");
+ target.endTag("-ac");
+ }
+
+ public static AcceptCriterion get() {
+ return singleton;
+ }
+
+ public boolean accepts(DragAndDropEvent dragEvent) {
+ return true;
+ }
+
+ public void paintResponse(PaintTarget target) throws PaintException {
+ // TODO Auto-generated method stub
+
+ }
+}
\ No newline at end of file
--- /dev/null
+/**
+ *
+ */
+package com.vaadin.event.dd.acceptCriteria;
+
+import com.vaadin.event.Transferable;
+import com.vaadin.event.dd.DragAndDropEvent;
+import com.vaadin.event.dd.DropHandler;
+import com.vaadin.terminal.PaintException;
+import com.vaadin.terminal.PaintTarget;
+
+public interface AcceptCriterion {
+
+ /**
+ * Criterion that can be used create policy to accept/discard dragged
+ * content (presented by {@link Transferable}).
+ *
+ * May depend on state, like in OR or AND, so to be really
+ * ClientSideVerifiable needs to return true here (instead of just
+ * implementing marker interface).
+ */
+ public boolean isClientSideVerifiable();
+
+ public void paint(PaintTarget target) throws PaintException;
+
+ /**
+ * This needs to be implemented iff criterion does some lazy server side
+ * initialization. The UIDL painted in this method will be passed to client
+ * side drop handler implementation. Implementation can assume that
+ * {@link #accepts(DragAndDropEvent)} is called before this method.
+ *
+ * @param target
+ * @throws PaintException
+ */
+ public void paintResponse(PaintTarget target) throws PaintException;
+
+ /**
+ * Validates the data in event to be approriate for
+ * {@link DropHandler#drop(com.vaadin.event.dd.DropEvent)} method.
+ * <p>
+ * Note, that event if your criterion is matched on client side, it is a
+ * very good manner to validate the data on server side too.
+ *
+ * @param dragEvent
+ * @return
+ */
+ public boolean accepts(DragAndDropEvent dragEvent);
+}
\ No newline at end of file
--- /dev/null
+/**
+ *
+ */
+package com.vaadin.event.dd.acceptCriteria;
+
+import com.vaadin.event.dd.DragAndDropEvent;
+import com.vaadin.terminal.PaintException;
+import com.vaadin.terminal.PaintTarget;
+
+public class And implements AcceptCriterion {
+ private AcceptCriterion f1;
+ private AcceptCriterion f2;
+
+ public And(AcceptCriterion f1, AcceptCriterion f2) {
+ this.f1 = f1;
+ this.f2 = f2;
+ }
+
+ public boolean isClientSideVerifiable() {
+ boolean a1 = f1 instanceof AcceptCriterion ? (f1)
+ .isClientSideVerifiable() : false;
+ boolean a2 = f2 instanceof AcceptCriterion ? (f2)
+ .isClientSideVerifiable() : false;
+ return a1 && a2;
+ }
+
+ public void paint(PaintTarget target) throws PaintException {
+ target.startTag("-ac");
+ target.addAttribute("name", "and");
+ (f1).paint(target);
+ (f2).paint(target);
+ target.endTag("-ac");
+ }
+
+ public boolean accepts(DragAndDropEvent dragEvent) {
+ return f1.accepts(dragEvent) && f2.accepts(dragEvent);
+ }
+
+ public void paintResponse(PaintTarget target) throws PaintException {
+ // TODO Auto-generated method stub
+
+ }
+}
\ No newline at end of file
--- /dev/null
+package com.vaadin.event.dd.acceptCriteria;
+
+import java.io.Serializable;
+
+import com.vaadin.terminal.PaintException;
+import com.vaadin.terminal.PaintTarget;
+
+public abstract class ClientSideCriterion implements Serializable,
+ AcceptCriterion {
+
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+
+ public final boolean isClientSideVerifiable() {
+ return true;
+ }
+
+ public void paint(PaintTarget target) throws PaintException {
+ target.startTag("-ac");
+ target.addAttribute("name", getIdentifier());
+ paintContent(target);
+ target.endTag("-ac");
+ }
+
+ public void paintContent(PaintTarget target) {
+ }
+
+ abstract protected String getIdentifier();
+
+ public void paintResponse(PaintTarget target) throws PaintException {
+ // NOP, nothing to do as this is client side verified criterion
+ }
+
+}
--- /dev/null
+/**
+ *
+ */
+package com.vaadin.event.dd.acceptCriteria;
+
+import com.vaadin.event.ComponentTransferable;
+import com.vaadin.event.dd.DragAndDropEvent;
+import com.vaadin.terminal.PaintException;
+import com.vaadin.terminal.PaintTarget;
+import com.vaadin.ui.Component;
+
+public class ComponentFilter implements AcceptCriterion {
+ private Component component;
+
+ public ComponentFilter(Component component) {
+ this.component = component;
+ }
+
+ public boolean isClientSideVerifiable() {
+ return true;
+ }
+
+ public void paint(PaintTarget target) throws PaintException {
+ target.startTag("-ac");
+ target.addAttribute("name", "component");
+ target.addAttribute("component", component);
+ target.endTag("-ac");
+ }
+
+ public boolean accepts(DragAndDropEvent dragEvent) {
+ if (dragEvent.getTransferable() instanceof ComponentTransferable) {
+ return ((ComponentTransferable) dragEvent.getTransferable())
+ .getSourceComponent() == component;
+ } else {
+ return false;
+ }
+ }
+
+ public void paintResponse(PaintTarget target) throws PaintException {
+ // TODO Auto-generated method stub
+
+ }
+}
\ No newline at end of file
--- /dev/null
+/**
+ *
+ */
+package com.vaadin.event.dd.acceptCriteria;
+
+import com.vaadin.event.DataBindedTransferable;
+import com.vaadin.event.dd.DragAndDropEvent;
+import com.vaadin.terminal.PaintException;
+import com.vaadin.terminal.PaintTarget;
+
+public final class IsDataBinded implements AcceptCriterion {
+ private static IsDataBinded singleton = new IsDataBinded();
+
+ private IsDataBinded() {
+ }
+
+ public boolean isClientSideVerifiable() {
+ return true;
+ }
+
+ public void paint(PaintTarget target) throws PaintException {
+ target.startTag("-ac");
+ target.addAttribute("name", "needsItemId");
+ target.endTag("-ac");
+ }
+
+ public static IsDataBinded get() {
+ return singleton;
+ }
+
+ public boolean accepts(DragAndDropEvent dragEvent) {
+ if (dragEvent.getTransferable() instanceof DataBindedTransferable) {
+ return ((DataBindedTransferable) dragEvent.getTransferable())
+ .getItemId() != null;
+ }
+ return false;
+ }
+
+ public void paintResponse(PaintTarget target) throws PaintException {
+ // TODO Auto-generated method stub
+
+ }
+}
\ No newline at end of file
--- /dev/null
+/**
+ *
+ */
+package com.vaadin.event.dd.acceptCriteria;
+
+import com.vaadin.event.dd.DragAndDropEvent;
+import com.vaadin.terminal.PaintException;
+import com.vaadin.terminal.PaintTarget;
+
+public class Not implements AcceptCriterion {
+ private AcceptCriterion acceptCriterion;
+
+ public Not(AcceptCriterion acceptCriterion) {
+ this.acceptCriterion = acceptCriterion;
+ }
+
+ public boolean isClientSideVerifiable() {
+ // TODO Auto-generated method stub
+ return false;
+ }
+
+ public void paint(PaintTarget target) throws PaintException {
+ // TODO Auto-generated method stub
+
+ }
+
+ public boolean accepts(DragAndDropEvent dragEvent) {
+ return !acceptCriterion.accepts(dragEvent);
+ }
+
+ public void paintResponse(PaintTarget target) throws PaintException {
+ // TODO Auto-generated method stub
+
+ }
+
+}
\ No newline at end of file
--- /dev/null
+/**
+ *
+ */
+package com.vaadin.event.dd.acceptCriteria;
+
+import com.vaadin.event.dd.DragAndDropEvent;
+import com.vaadin.terminal.PaintException;
+import com.vaadin.terminal.PaintTarget;
+
+public class Or implements AcceptCriterion {
+ private AcceptCriterion f1;
+ private AcceptCriterion f2;
+
+ Or(AcceptCriterion f1, AcceptCriterion f2) {
+ this.f1 = f1;
+ this.f2 = f2;
+ }
+
+ public boolean isClientSideVerifiable() {
+ // TODO Auto-generated method stub
+ return false;
+ }
+
+ public void paint(PaintTarget target) throws PaintException {
+ // TODO Auto-generated method stub
+
+ }
+
+ public boolean accepts(DragAndDropEvent dragEvent) {
+ return f1.accepts(dragEvent) || f2.accepts(dragEvent);
+ }
+
+ public void paintResponse(PaintTarget target) throws PaintException {
+ // TODO Auto-generated method stub
+
+ }
+}
\ No newline at end of file
--- /dev/null
+/**
+ *
+ */
+package com.vaadin.event.dd.acceptCriteria;
+
+import com.vaadin.event.dd.DragAndDropEvent;
+import com.vaadin.terminal.PaintException;
+import com.vaadin.terminal.PaintTarget;
+import com.vaadin.ui.Tree.Location;
+import com.vaadin.ui.Tree.TreeDropDetails;
+
+public class OverTreeNode implements AcceptCriterion {
+
+ public boolean isClientSideVerifiable() {
+ return true;
+ }
+
+ public void paint(PaintTarget target) throws PaintException {
+ target.startTag("-ac");
+ target.addAttribute("name", "overTreeNode");
+ target.endTag("-ac");
+ }
+
+ public boolean accepts(DragAndDropEvent dragEvent) {
+ try {
+ TreeDropDetails eventDetails = (TreeDropDetails) dragEvent
+ .getDropTargetData();
+ return eventDetails.getDropLocation() == Location.MIDDLE;
+ } catch (Exception e) {
+ return false;
+ }
+ }
+
+ public void paintResponse(PaintTarget target) throws PaintException {
+ // TODO Auto-generated method stub
+
+ }
+
+}
\ No newline at end of file
--- /dev/null
+package com.vaadin.event.dd.acceptCriteria;
+
+import java.io.Serializable;
+
+import com.vaadin.terminal.PaintException;
+import com.vaadin.terminal.PaintTarget;
+
+public abstract class ServerSideCriterion implements Serializable,
+ AcceptCriterion {
+
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+
+ public final boolean isClientSideVerifiable() {
+ return false;
+ }
+
+ public void paint(PaintTarget target) throws PaintException {
+ target.startTag("-ac");
+ target.addAttribute("name", getIdentifier());
+ paintContent(target);
+ target.endTag("-ac");
+ }
+
+ public void paintContent(PaintTarget target) {
+ }
+
+ public void paintResponse(PaintTarget target) throws PaintException {
+ }
+
+ protected String getIdentifier() {
+ return "-ss";
+ }
+}
+++ /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 getTransferable(Transferable transferable,
- Map<String, Object> rawVariables);
-
-}
.getEventTarget();
Paintable paintable = client.getPaintable((Element) eventTarget
.cast());
- VTransferable transferable = new VTransferable();
- transferable.setComponent(paintable);
- VDragEvent drag = VDragAndDropManager.get().startDrag(
- transferable, event.getNativeEvent(), true);
- drag.createDragImage(((Widget) paintable).getElement(), true);
- drag.getDropDetails().put(
- "mouseDown",
- new MouseEventDetails(event.getNativeEvent())
- .serialize());
- event.preventDefault(); // prevent text selection
+ if (paintable != null) {
+ VTransferable transferable = new VTransferable();
+ transferable.setComponent(paintable);
+ VDragEvent drag = VDragAndDropManager.get().startDrag(
+ transferable, event.getNativeEvent(), true);
+ drag.createDragImage(((Widget) paintable).getElement(),
+ true);
+ drag.getDropDetails().put(
+ "mouseDown",
+ new MouseEventDetails(event.getNativeEvent())
+ .serialize());
+ event.preventDefault(); // prevent text selection
+ }
}
}, MouseDownEvent.getType());
if (!uidl.hasAttribute("cached")) {
int childCount = uidl.getChildCount();
UIDL childUIDL = uidl.getChildUIDL(childCount - 1);
- getDropHandler().updateRules(childUIDL);
+ getDropHandler().updateAcceptRules(childUIDL);
}
}
if ("actions".equals(childUidl.getTag())) {
updateActionMap(childUidl);
continue;
- } else if ("dh".equals(childUidl.getTag())) {
+ } else if ("-ac".equals(childUidl.getTag())) {
updateDropHandler(childUidl);
continue;
}
@Override
public void dragEnter(VDragEvent drag) {
- updateTreeRelatedDragData(drag);
- super.dragEnter(drag);
}
@Override
.getCurrentGwtEvent());
boolean nodeHasChanged = (currentMouseOverKey != null && currentMouseOverKey != oldIdOver)
|| (oldIdOver != null);
- boolean detailHasChanded = !detail.equals(oldDetail);
+ boolean detailHasChanded = (detail != null && !detail
+ .equals(oldDetail))
+ || (detail == null && oldDetail != null);
if (nodeHasChanged || detailHasChanded) {
ApplicationConnection.getConsole().log(
"Change in Transferable " + currentMouseOverKey
+ " " + detail);
+ final String newKey = currentMouseOverKey;
validate(new VAcceptCallback() {
- public void accepted() {
- keyToNode.get(currentMouseOverKey).emphasis(
- detail);
+ public void accepted(VDragEvent event) {
+ if (newKey != null) {
+ keyToNode.get(newKey).emphasis(detail);
+ }
}
}, currentDrag);
if (oldIdOver != null
};
}
- dropHandler.updateRules(childUidl);
+ dropHandler.updateAcceptRules(childUidl);
}
public String getDropDetail(NativeEvent event) {
TreeNode treeNode = keyToNode.get(currentMouseOverKey);
+ if (treeNode == null) {
+ return null;
+ }
// TODO no scroll support
int offsetHeight = treeNode.nodeCaptionDiv.getOffsetHeight();
int absoluteTop = treeNode.getAbsoluteTop();
package com.vaadin.terminal.gwt.client.ui.dd;
-import com.vaadin.event.AbstractDropHandler;
-import com.vaadin.event.DropTarget;
+import com.google.gwt.user.client.Command;
import com.vaadin.event.Transferable;
-import com.vaadin.event.AbstractDropHandler.AcceptCriterion;
+import com.vaadin.event.dd.DropTarget;
+import com.vaadin.event.dd.acceptCriteria.AcceptCriterion;
import com.vaadin.terminal.gwt.client.Paintable;
import com.vaadin.terminal.gwt.client.UIDL;
public abstract class VAbstractDropHandler implements VDropHandler {
- private boolean mustValidateOnServer = true;
private UIDL criterioUIDL;
+ private VAcceptCriteria acceptCriteria;
/**
* 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.
+ * painted by {@link AcceptCriterion} to this method. Practically the
+ * details about {@link AcceptCriterion} are saved.
*
* @param uidl
*/
- public void updateRules(UIDL uidl) {
- 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;
- }
+ public void updateAcceptRules(UIDL uidl) {
+ criterioUIDL = uidl;
+ acceptCriteria = VAcceptCriterion.get(uidl.getStringAttribute("name"));
+ if (acceptCriteria == null) {
+ throw new IllegalArgumentException(
+ "No accept criteria found with given name "
+ + uidl.getStringAttribute("name"));
}
}
*/
public void dragEnter(final VDragEvent drag) {
validate(new VAcceptCallback() {
- public void accepted() {
+
+ public void accepted(VDragEvent event) {
dragAccepted(drag);
}
}, 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 validateOnClient(VDragEvent drag) {
- if (criterioUIDL != null) {
- String criteriaName = criterioUIDL.getStringAttribute("name");
- VAcceptCriteria acceptCriteria = VAcceptCriterion.get(criteriaName);
- if (acceptCriteria != null) {
- // ApplicationConnection.getConsole().log(
- // "Criteria : " + acceptCriteria.getClass().getName());
- return acceptCriteria.accept(drag, criterioUIDL);
+ protected void validate(final VAcceptCallback cb, final VDragEvent event) {
+ Command checkCriteria = new Command() {
+ public void execute() {
+ acceptCriteria.accept(event, criterioUIDL, cb);
}
- }
- return false;
+ };
+
+ VDragAndDropManager.get().executeWhenReady(checkCriteria);
}
+ boolean validated = 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 (mustValidateOnServer) {
+ if (acceptCriteria.needsServerSideCheck(drag, criterioUIDL)) {
return true;
} else {
- return validateOnClient(drag);
+ validated = false;
+ acceptCriteria.accept(drag, criterioUIDL, new VAcceptCallback() {
+ public void accepted(VDragEvent event) {
+ validated = true;
+ }
+ });
+ return validated;
}
+
}
/**
* the drag and drop operation ends or the {@link VAbstractDropHandler} has
* changed before response arrives, the method is never called.
*/
- public void accepted();
+ public void accepted(VDragEvent event);
}
public interface VAcceptCriteria {
- public boolean accept(VDragEvent drag, UIDL configuration);
+ /**
+ * Checks if current drag event has valid drop target and target accepts the
+ * transferable. If drop target is valid, callback is used.
+ *
+ * @param drag
+ * @param configuration
+ * @param callback
+ */
+ public void accept(VDragEvent drag, UIDL configuration,
+ VAcceptCallback callback);
+
+ public boolean needsServerSideCheck(VDragEvent drag, UIDL criterioUIDL);
}
package com.vaadin.terminal.gwt.client.ui.dd;
-import java.util.HashMap;
-import java.util.Map;
-
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;
static {
impl = GWT.create(VAcceptCriterionImpl.class);
- impl.populateCriterionMap(criterion);
+ impl.init();
}
public static VAcceptCriteria get(String name) {
- return criterion.get(name);
+ return impl.get(name);
}
}
package com.vaadin.terminal.gwt.client.ui.dd;
+import java.util.HashMap;
+import java.util.HashSet;
import java.util.Map;
import com.vaadin.terminal.gwt.client.ApplicationConnection;
public class VAcceptCriterionImpl {
private final class OverTreeNode implements VAcceptCriteria {
- public boolean accept(VDragEvent drag, UIDL configuration) {
+ public void accept(VDragEvent drag, UIDL configuration,
+ VAcceptCallback callback) {
Boolean containsKey = (Boolean) drag.getDropDetails().get(
"itemIdOverIsNode");
if (containsKey != null && containsKey.booleanValue()) {
- return true;
+ callback.accepted(drag);
+ return;
}
+ return;
+ }
+
+ public boolean needsServerSideCheck(VDragEvent drag, UIDL criterioUIDL) {
return false;
}
}
private final class ComponentCriteria implements VAcceptCriteria {
- public boolean accept(VDragEvent drag, UIDL configuration) {
+ public void accept(VDragEvent drag, UIDL configuration,
+ VAcceptCallback callback) {
try {
Paintable component = drag.getTransferable().getComponent();
String requiredPid = configuration
Paintable paintable = VDragAndDropManager.get()
.getCurrentDropHandler().getApplicationConnection()
.getPaintable(requiredPid);
- return paintable == component;
+ if (paintable == component) {
+ callback.accepted(drag);
+ }
} catch (Exception e) {
}
+ return;
+ }
+
+ public boolean needsServerSideCheck(VDragEvent drag, UIDL criterioUIDL) {
return false;
}
}
private final class And implements VAcceptCriteria {
- public boolean accept(VDragEvent drag, UIDL configuration) {
- UIDL childUIDL = configuration.getChildUIDL(0);
- UIDL childUIDL2 = configuration.getChildUIDL(1);
- VAcceptCriteria acceptCriteria = VAcceptCriterion.get(childUIDL
- .getStringAttribute("name"));
- VAcceptCriteria acceptCriteria2 = VAcceptCriterion.get(childUIDL2
- .getStringAttribute("name"));
- if (acceptCriteria == null || acceptCriteria2 == null) {
+ private boolean b1;
+ private boolean b2;
+
+ public void accept(VDragEvent drag, UIDL configuration,
+ VAcceptCallback callback) {
+
+ VAcceptCriteria crit1 = getCriteria(drag, configuration, 0);
+ VAcceptCriteria crit2 = getCriteria(drag, configuration, 1);
+ if (crit1 == null || crit2 == null) {
ApplicationConnection.getConsole().log(
"And criteria didn't found a chidl criteria");
- return false;
+ return;
}
- boolean accept = acceptCriteria.accept(drag, childUIDL);
- boolean accept2 = acceptCriteria2.accept(drag, childUIDL2);
- return accept && accept2;
+
+ b1 = false;
+ b2 = false;
+
+ VAcceptCallback accept1cb = new VAcceptCallback() {
+ public void accepted(VDragEvent event) {
+ b1 = true;
+ }
+ };
+ VAcceptCallback accept2cb = new VAcceptCallback() {
+ public void accepted(VDragEvent event) {
+ b2 = true;
+ }
+ };
+
+ crit1.accept(drag, configuration.getChildUIDL(0), accept1cb);
+ crit2.accept(drag, configuration.getChildUIDL(0), callback);
+ if (b1 && b2) {
+ callback.accepted(drag);
+ }
+ }
+
+ private VAcceptCriteria getCriteria(VDragEvent drag,
+ UIDL configuration, int i) {
+ UIDL childUIDL = configuration.getChildUIDL(i);
+ return VAcceptCriterion.get(childUIDL.getStringAttribute("name"));
+ }
+
+ public boolean needsServerSideCheck(VDragEvent drag, UIDL criterioUIDL) {
+ return false; // enforce on server side
+ // return getCriteria(drag, criterioUIDL, 0).needsServerSideCheck(
+ // drag, criterioUIDL.getChildUIDL(0))
+ // && getCriteria(drag, criterioUIDL, 1).needsServerSideCheck(
+ // drag, criterioUIDL.getChildUIDL(1));
}
}
private final class AcceptAll implements VAcceptCriteria {
- public boolean accept(VDragEvent drag, UIDL configuration) {
- return true;
+ public void accept(VDragEvent drag, UIDL configuration,
+ VAcceptCallback callback) {
+ callback.accepted(drag);
+ }
+
+ public boolean needsServerSideCheck(VDragEvent drag, UIDL criterioUIDL) {
+ return false;
}
}
private final class HasItemId implements VAcceptCriteria {
- public boolean accept(VDragEvent drag, UIDL configuration) {
- return drag.getTransferable().getData("itemId") != null;
+ public void accept(VDragEvent drag, UIDL configuration,
+ VAcceptCallback callback) {
+ if (drag.getTransferable().getData("itemId") != null) {
+ callback.accepted(drag);
+ }
+ }
+
+ public boolean needsServerSideCheck(VDragEvent drag, UIDL criterioUIDL) {
+ return false;
+ }
+ }
+
+ private final class ServerAccept implements VAcceptCriteria {
+ public void accept(final VDragEvent drag, UIDL configuration,
+ final VAcceptCallback callback) {
+
+ // TODO could easily cache the response for current drag event
+
+ VDragEventServerCallback acceptCallback = new VDragEventServerCallback() {
+ public void handleResponse(boolean accepted, UIDL response) {
+ if (accepted) {
+ callback.accepted(drag);
+ }
+ }
+ };
+ VDragAndDropManager.get().visitServer(acceptCallback);
+ }
+
+ public boolean needsServerSideCheck(VDragEvent drag, UIDL criterioUIDL) {
+ return true;
+ }
+ }
+
+ private final class LazyInitItemIdentifiers implements VAcceptCriteria {
+ private boolean loaded = false;
+ private HashSet<String> hashSet;
+ private VDragEvent lastDragEvent;
+
+ public void accept(final VDragEvent drag, UIDL configuration,
+ final VAcceptCallback callback) {
+ if (lastDragEvent == null || lastDragEvent != drag) {
+ loaded = false;
+ lastDragEvent = drag;
+ }
+ if (loaded) {
+ Object object = drag.getDropDetails().get("itemIdOver");
+ if (hashSet.contains(object)) {
+ callback.accepted(drag);
+ }
+ } else {
+
+ VDragEventServerCallback acceptCallback = new VDragEventServerCallback() {
+
+ public void handleResponse(boolean accepted, UIDL response) {
+ hashSet = new HashSet<String>();
+ String[] stringArrayAttribute = response
+ .getStringArrayAttribute("allowedIds");
+ for (int i = 0; i < stringArrayAttribute.length; i++) {
+ hashSet.add(stringArrayAttribute[i]);
+ }
+ loaded = true;
+ if (accepted) {
+ callback.accepted(drag);
+ }
+ }
+ };
+
+ VDragAndDropManager.get().visitServer(acceptCallback);
+ }
+
+ }
+
+ public boolean needsServerSideCheck(VDragEvent drag, UIDL criterioUIDL) {
+ return loaded;
}
}
+ private Map<String, VAcceptCriteria> instances = new HashMap<String, VAcceptCriteria>();
+
/**
* TODO this class/method must be written by generator
*
*
* TODO use fully qualified names of server side counterparts as keys
*/
- public void populateCriterionMap(Map<String, VAcceptCriteria> map) {
+ private void populateCriterionMap(Map<String, VAcceptCriteria> map) {
VAcceptCriteria crit;
crit = new HasItemId();
map.put("component", crit);
}
+
+ public void init() {
+ populateCriterionMap(instances);
+ }
+
+ public VAcceptCriteria get(String name) {
+ // FIXME make all lazy inited and possibility to use instances per
+ // handler
+ if (name.equals("-ss")) {
+ return new ServerAccept();
+ } else if (name.equals("com.vaadin.ui.Tree.TreeDropCriterion")) {
+ return new LazyInitItemIdentifiers();
+ } else {
+ return instances.get(name);
+ }
+ }
}
package com.vaadin.terminal.gwt.client.ui.dd;
+import java.util.LinkedList;
+
import com.google.gwt.dom.client.Element;
import com.google.gwt.dom.client.NativeEvent;
import com.google.gwt.dom.client.Node;
import com.vaadin.terminal.gwt.client.ApplicationConnection;
import com.vaadin.terminal.gwt.client.MouseEventDetails;
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;
// dragleave on old
if (currentDropHandler != null) {
currentDropHandler.dragLeave(currentDrag);
- acceptCallback = null;
+ serverCallback = null;
}
// dragenter on new
currentDropHandler = findDragTarget;
} catch (Exception e) {
ApplicationConnection.getConsole().log(
"FIXME : ERROR in elementFromPoint hack.");
- e.printStackTrace();
+ throw new RuntimeException(e);
} finally {
dragElement.getStyle().setProperty("display", display);
}
&& currentDropHandler != newDragHanler) {
currentDropHandler.dragLeave(currentDrag);
currentDropHandler = null;
- acceptCallback = null;
+ serverCallback = null;
}
break;
case Event.ONMOUSEMOVE:
this.currentDropHandler = currentDropHandler;
}
- private VAcceptCallback acceptCallback;
+ private VDragEventServerCallback serverCallback;
private HandlerRegistration deferredStartRegistration;
doRequest(DragEventType.DROP);
}
currentDropHandler = null;
- acceptCallback = null;
+ serverCallback = null;
}
*
* @param acceptCallback
*/
- public void visitServer(VAcceptCallback acceptCallback) {
+ public void visitServer(VDragEventServerCallback acceptCallback) {
doRequest(DragEventType.ENTER);
- this.acceptCallback = acceptCallback;
+ serverCallback = acceptCallback;
}
private void doRequest(DragEventType drop) {
}
public void handleServerResponse(ValueMap valueMap) {
- if (acceptCallback == null) {
+ if (serverCallback == null) {
return;
}
- int visitId = valueMap.getInt("visitId");
+ UIDL uidl = (UIDL) valueMap.cast();
+ int visitId = uidl.getIntAttribute("visitId");
+
if (this.visitId == visitId) {
- if (valueMap.containsKey("accepted")) {
- acceptCallback.accepted();
+ serverCallback.handleResponse(uidl.getBooleanAttribute("accepted"),
+ uidl);
+ serverCallback = null;
+ }
+ runDeferredCommands();
+ }
+
+ private void runDeferredCommands() {
+ if (deferredCommands != null && !deferredCommands.isEmpty()) {
+ Command command = deferredCommands.poll();
+ command.execute();
+ if (!isBusy()) {
+ runDeferredCommands();
}
- acceptCallback = null;
}
}
}
};
+ private LinkedList<Command> deferredCommands;
+
+ private boolean isBusy() {
+ return serverCallback != null;
+ }
+
+ /**
+ * Method to que tasks until all dd related server visits are done
+ *
+ * @param command
+ */
+ private void defer(Command command) {
+ if (deferredCommands == null) {
+ deferredCommands = new LinkedList<Command>();
+ }
+ deferredCommands.add(command);
+ }
+
+ /**
+ * Method to execute commands when all existing dd related tasks are
+ * completed (some may require server visit).
+ * <p>
+ * Using this method may be handy if criterion that uses lazy initialization
+ * are used. Check
+ *
+ * @param command
+ */
+ public void executeWhenReady(Command command) {
+ if (isBusy()) {
+ defer(command);
+ } else {
+ command.execute();
+ }
+ }
+
}
--- /dev/null
+package com.vaadin.terminal.gwt.client.ui.dd;
+
+import com.vaadin.terminal.gwt.client.UIDL;
+
+public interface VDragEventServerCallback {
+
+ public void handleResponse(boolean accepted, UIDL response);
+
+}
import java.util.HashMap;
import java.util.Map;
-import com.vaadin.terminal.DragSource;
+import com.vaadin.event.dd.DragSource;
import com.vaadin.terminal.gwt.client.Paintable;
/**
package com.vaadin.terminal.gwt.server;
-import com.vaadin.Application;
-import com.vaadin.Application.SystemMessages;
-import com.vaadin.external.org.apache.commons.fileupload.FileItemIterator;
-import com.vaadin.external.org.apache.commons.fileupload.FileItemStream;
-import com.vaadin.external.org.apache.commons.fileupload.FileUpload;
-import com.vaadin.external.org.apache.commons.fileupload.FileUploadException;
-import com.vaadin.external.org.apache.commons.fileupload.ProgressListener;
-import com.vaadin.terminal.ApplicationResource;
-import com.vaadin.terminal.DownloadStream;
-import com.vaadin.terminal.PaintException;
-import com.vaadin.terminal.PaintTarget;
-import com.vaadin.terminal.Paintable;
-import com.vaadin.terminal.URIHandler;
-import com.vaadin.terminal.UploadStream;
-import com.vaadin.terminal.VariableOwner;
-import com.vaadin.terminal.Paintable.RepaintRequestEvent;
-import com.vaadin.terminal.Terminal.ErrorEvent;
-import com.vaadin.terminal.Terminal.ErrorListener;
-import com.vaadin.terminal.gwt.client.ApplicationConnection;
-import com.vaadin.terminal.gwt.server.ComponentSizeValidator.InvalidLayout;
-import com.vaadin.ui.AbstractField;
-import com.vaadin.ui.Component;
-import com.vaadin.ui.Upload;
-import com.vaadin.ui.Window;
-import com.vaadin.ui.Upload.UploadException;
-
import java.io.BufferedWriter;
import java.io.CharArrayWriter;
import java.io.IOException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
+import com.vaadin.Application;
+import com.vaadin.Application.SystemMessages;
+import com.vaadin.external.org.apache.commons.fileupload.FileItemIterator;
+import com.vaadin.external.org.apache.commons.fileupload.FileItemStream;
+import com.vaadin.external.org.apache.commons.fileupload.FileUpload;
+import com.vaadin.external.org.apache.commons.fileupload.FileUploadException;
+import com.vaadin.external.org.apache.commons.fileupload.ProgressListener;
+import com.vaadin.terminal.ApplicationResource;
+import com.vaadin.terminal.DownloadStream;
+import com.vaadin.terminal.PaintException;
+import com.vaadin.terminal.PaintTarget;
+import com.vaadin.terminal.Paintable;
+import com.vaadin.terminal.URIHandler;
+import com.vaadin.terminal.UploadStream;
+import com.vaadin.terminal.VariableOwner;
+import com.vaadin.terminal.Paintable.RepaintRequestEvent;
+import com.vaadin.terminal.Terminal.ErrorEvent;
+import com.vaadin.terminal.Terminal.ErrorListener;
+import com.vaadin.terminal.gwt.client.ApplicationConnection;
+import com.vaadin.terminal.gwt.server.ComponentSizeValidator.InvalidLayout;
+import com.vaadin.ui.AbstractField;
+import com.vaadin.ui.Component;
+import com.vaadin.ui.Upload;
+import com.vaadin.ui.Window;
+import com.vaadin.ui.Upload.UploadException;
+
/**
* This is a common base class for the server-side implementations of the
* communication system between the client code (compiled with GWT into
private VariableOwner getDragAndDropService() {
if (dragAndDropService == null) {
- dragAndDropService = new DragAndDropService();
+ dragAndDropService = new DragAndDropService(this);
}
return dragAndDropService;
}
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.DropTarget;
import com.vaadin.event.Transferable;
-import com.vaadin.terminal.DragSource;
+import com.vaadin.event.dd.DragEvent;
+import com.vaadin.event.dd.DragSource;
+import com.vaadin.event.dd.DropEvent;
+import com.vaadin.event.dd.DropHandler;
+import com.vaadin.event.dd.DropTarget;
+import com.vaadin.event.dd.TargetDetails;
+import com.vaadin.event.dd.TargetDetailsImpl;
+import com.vaadin.event.dd.acceptCriteria.AcceptCriterion;
+import com.vaadin.terminal.PaintException;
import com.vaadin.terminal.VariableOwner;
import com.vaadin.terminal.gwt.client.ui.dd.VDragAndDropManager.DragEventType;
import com.vaadin.ui.Component;
private int lastVisitId;
- private DragRequest currentRequest;
-
private int currentEventId;
private Transferable transferable;
+ private boolean lastVisitAccepted = false;
+
+ private DragEvent dragEvent;
+
+ private final AbstractCommunicationManager manager;
+
+ private AcceptCriterion acceptCriterion;
+
+ public DragAndDropService(AbstractCommunicationManager manager) {
+ this.manager = manager;
+ }
+
public void changeVariables(Object source, Map<String, Object> variables) {
Object owner = variables.get("dhowner");
DropTarget dropTarget = (DropTarget) owner;
lastVisitId = (Integer) variables.get("visitId");
- // Is this a drop request or a drag/move request?
+ // request may be dropRequest or request during drag operation (commonly
+ // dragover or dragenter)
boolean dropRequest = isDropRequest(variables);
if (dropRequest) {
handleDropRequest(dropTarget, variables);
* source for Transferable, drop target for DragDropDetails).
*/
Transferable transferable = constructTransferable(dropTarget, variables);
- DragDropDetails dropData = constructDragDropDetails(dropTarget,
- variables);
-
- dropHandler.drop(transferable, dropData);
+ TargetDetails dropData = constructDragDropDetails(dropTarget, variables);
+ DropEvent dropEvent = new DropEvent(transferable, dropData);
+ if (dropHandler.getAcceptCriterion().accepts(dropEvent)) {
+ dropHandler.drop(dropEvent);
+ }
}
/**
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;
- }
+ acceptCriterion = dropTarget.getDropHandler().getAcceptCriterion();
- 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,
+ TargetDetails dragDropDetails = constructDragDropDetails(dropTarget,
variables);
- currentRequest = constructDragRequest(variables, transferable);
- dragDropHandler.handleDragRequest(currentRequest, transferable,
- dragDropDetails);
- }
-
- private static DragRequest constructDragRequest(
- Map<String, Object> variables, Transferable transferable) {
+ dragEvent = new DragEvent(transferable, dragDropDetails);
- int type = (Integer) variables.get("type");
- DragRequest dragRequest = new DragRequest(DragEventType.values()[type]);
- return dragRequest;
+ lastVisitAccepted = acceptCriterion.accepts(dragEvent);
}
/**
* @return
*/
@SuppressWarnings("unchecked")
- private DragDropDetails constructDragDropDetails(DropTarget dropTarget,
+ private TargetDetails 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);
- }
+ TargetDetails dropData = dropTarget
+ .translateDragDropDetails(rawDragDropDetails);
if (dropData == null) {
// Create a default DragDropDetails with all the raw variables
- dropData = new DragDropDetailsImpl(rawDragDropDetails);
+ dropData = new TargetDetailsImpl(rawDragDropDetails);
}
- dropData.put(DROPTARGET_KEY, dropTarget);
+ dropData.setData(DROPTARGET_KEY, dropTarget);
return dropData;
}
return true;
}
- void printJSONResponse(PrintWriter outWriter) {
+ void printJSONResponse(PrintWriter outWriter) throws PaintException {
if (isDirty()) {
- // TODO paint responsedata
- outWriter.print(", dd : {");
- outWriter.print("visitId:");
- outWriter.print(lastVisitId);
- Map<String, Object> responseData = currentRequest.getResponseData();
- if (responseData != null) {
- for (String key : responseData.keySet()) {
- Object object = responseData.get(key);
- outWriter.print(",\"");
- // TODO JSON escaping for key and object
- outWriter.print(key);
- outWriter.print("\":");
- outWriter.print(object);
- }
+
+ outWriter.print(", \"dd\":");
+
+ JsonPaintTarget jsonPaintTarget = new JsonPaintTarget(manager,
+ outWriter, false);
+ jsonPaintTarget.startTag("dd");
+ jsonPaintTarget.addAttribute("visitId", lastVisitId);
+ if (acceptCriterion != null) {
+ jsonPaintTarget.addAttribute("accepted", lastVisitAccepted);
+ acceptCriterion.paintResponse(jsonPaintTarget);
}
- outWriter.print("}");
- currentRequest = null;
+ jsonPaintTarget.endTag("dd");
+ jsonPaintTarget.close();
+ lastVisitId = -1;
+ lastVisitAccepted = false;
+ acceptCriterion = null;
+ dragEvent = null;
}
}
private boolean isDirty() {
- if (currentRequest != null) {
+ if (lastVisitId > 0) {
return true;
}
return false;
import java.util.Map;
-import com.vaadin.event.AbstractDropHandler;
import com.vaadin.event.ComponentTransferable;
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.event.dd.DropEvent;
+import com.vaadin.event.dd.DropHandler;
+import com.vaadin.event.dd.DropTarget;
+import com.vaadin.event.dd.TargetDetails;
+import com.vaadin.event.dd.TargetDetailsImpl;
+import com.vaadin.event.dd.acceptCriteria.AcceptAll;
+import com.vaadin.event.dd.acceptCriteria.AcceptCriterion;
import com.vaadin.terminal.PaintException;
import com.vaadin.terminal.PaintTarget;
import com.vaadin.terminal.gwt.client.MouseEventDetails;
*/
@SuppressWarnings("serial")
@ClientWidget(com.vaadin.terminal.gwt.client.ui.VDragDropPane.class)
-public class DragDropPane extends AbsoluteLayout implements DropTarget,
- DragDropDataTranslator {
+public class DragDropPane extends AbsoluteLayout implements DropTarget {
- private AbstractDropHandler abstractDropHandler;
+ private DropHandler dropHandler;
- public DragDropPane(AbstractDropHandler dropHandler) {
+ public DragDropPane(DropHandler dropHandler) {
setWidth("400px");
setHeight("300px");
if (dropHandler == null) {
- dropHandler = new AbstractDropHandler() {
- @Override
- public void receive(Transferable transferable,
- DragDropDetails dropDetails) {
-
- DragEventDetails ed = (DragEventDetails) dropDetails;
- if (transferable instanceof ComponentTransferable) {
- ComponentTransferable ctr = (ComponentTransferable) transferable;
- Component component = ctr.getSourceComponent();
-
- if (component.getParent() != DragDropPane.this) {
- if (transferable instanceof DataBindedTransferable) {
- // Item has been dragged, construct a Label from
- // Item id
- Label l = new Label();
- l.setSizeUndefined();
- l
- .setValue("ItemId : "
- + ((DataBindedTransferable) transferable)
- .getItemId());
- DragDropPane.this.addComponent(l);
- component = l;
-
- } else {
- // we have a component that is been dragged, add
- // it
- // to
- // this
- DragDropPane.this.addComponent(component);
- }
-
- Integer left = ed.getAbsoluteLeft();
- Integer top = ed.getAbsoluteTop();
-
- MouseEventDetails eventDetails = ed.getMouseEvent();
-
- int clientX = eventDetails.getClientX();
- int clientY = eventDetails.getClientY();
-
- try {
- DragDropPane.this.getPosition(component)
- .setTopValue(clientY - top);
- DragDropPane.this.getPosition(component)
- .setLeftValue(clientX - left);
- } catch (Exception e) {
- // TODO: handle exception
- }
- } else {
- // drag ended inside the this Pane
-
- MouseEventDetails start = ed.getMouseDownEvent();
- MouseEventDetails eventDetails = ed.getMouseEvent();
-
- int deltaX = eventDetails.getClientX()
- - start.getClientX();
- int deltaY = eventDetails.getClientY()
- - start.getClientY();
-
- ComponentPosition p = DragDropPane.this
- .getPosition(component);
- p.setTopValue(p.getTopValue() + deltaY);
- p.setLeftValue(p.getLeftValue() + deltaX);
-
- }
+ this.dropHandler = new ImportPrettyMuchAnything();
+ } else {
+ this.dropHandler = dropHandler;
+ }
- } else {
- // drag coming outside of Vaadin
- String object = (String) transferable
- .getData("text/plain");
+ }
+
+ public DragDropPane() {
+ this(null);
+ }
+
+ @Override
+ public void paintContent(PaintTarget target) throws PaintException {
+ super.paintContent(target);
+ dropHandler.getAcceptCriterion().paint(target);
+ }
- String content = (String) transferable
- .getData("fileContents");
+ public DropHandler getDropHandler() {
+ return dropHandler;
+ }
+ public static class ImportPrettyMuchAnything implements DropHandler {
+ public void drop(DropEvent event) {
+ DragDropPane pane = (DragDropPane) event.getDropTargetData()
+ .getTarget();
+
+ DragEventDetails ed = (DragEventDetails) event.getDropTargetData();
+ Transferable transferable = event.getTransferable();
+ if (transferable instanceof ComponentTransferable) {
+ ComponentTransferable ctr = (ComponentTransferable) transferable;
+ Component component = ctr.getSourceComponent();
+
+ if (component.getParent() != pane) {
+ if (transferable instanceof DataBindedTransferable) {
+ // Item has been dragged, construct a Label from
+ // Item id
Label l = new Label();
- l.setCaption("Generated from HTML5 drag:");
- if (object != null) {
- l.setValue(object);
- } else {
- l.setValue("HTML5 dd");
- }
-
- l.setDescription(content);
l.setSizeUndefined();
+ l.setValue("ItemId : "
+ + ((DataBindedTransferable) transferable)
+ .getItemId());
+ pane.addComponent(l);
+ component = l;
+
+ } else {
+ // we have a component that is been dragged, add
+ // it
+ // to
+ // this
+ pane.addComponent(component);
+ }
+
+ Integer left = ed.getAbsoluteLeft();
+ Integer top = ed.getAbsoluteTop();
+
+ MouseEventDetails eventDetails = ed.getMouseEvent();
- DragDropPane.this.addComponent(l);
+ int clientX = eventDetails.getClientX();
+ int clientY = eventDetails.getClientY();
+ try {
+ pane.getPosition(component).setTopValue(clientY - top);
+ pane.getPosition(component)
+ .setLeftValue(clientX - left);
+ } catch (Exception e) {
+ // TODO: handle exception
}
+ } else {
+ // drag ended inside the this Pane
+
+ MouseEventDetails start = ed.getMouseDownEvent();
+ MouseEventDetails eventDetails = ed.getMouseEvent();
+
+ int deltaX = eventDetails.getClientX() - start.getClientX();
+ int deltaY = eventDetails.getClientY() - start.getClientY();
+
+ ComponentPosition p = pane.getPosition(component);
+ p.setTopValue(p.getTopValue() + deltaY);
+ p.setLeftValue(p.getLeftValue() + deltaX);
}
- };
- if (dropHandler instanceof AbstractDropHandler) {
- AbstractDropHandler new_name = dropHandler;
- new_name
- .setAcceptCriterion(AbstractDropHandler.CRITERION_ACCEPT_ALL);
- }
- }
- abstractDropHandler = dropHandler;
- }
- public DragDropPane() {
- this(null);
- }
+ } else {
+ // drag coming outside of Vaadin
+ String object = (String) transferable.getData("text/plain");
- @Override
- public void paintContent(PaintTarget target) throws PaintException {
- super.paintContent(target);
- if (abstractDropHandler instanceof AbstractDropHandler) {
- AbstractDropHandler new_name = abstractDropHandler;
- new_name.paint(target);
+ String content = (String) transferable.getData("fileContents");
+
+ Label l = new Label();
+ l.setCaption("Generated from HTML5 drag:");
+ if (object != null) {
+ l.setValue(object);
+ } else {
+ l.setValue("HTML5 dd");
+ }
+
+ l.setDescription(content);
+ l.setSizeUndefined();
+
+ pane.addComponent(l);
+
+ }
+ return;
}
- }
- public AbstractDropHandler getDropHandler() {
- return abstractDropHandler;
+ public AcceptCriterion getAcceptCriterion() {
+ return AcceptAll.get();
+ }
}
- class DragEventDetails extends DragDropDetailsImpl {
+ class DragEventDetails extends TargetDetailsImpl {
public DragEventDetails(Map<String, Object> rawVariables) {
super(rawVariables);
}
public Integer getAbsoluteTop() {
- return (Integer) get("absoluteTop");
+ return (Integer) getData("absoluteTop");
}
public Integer getAbsoluteLeft() {
- return (Integer) get("absoluteLeft");
+ return (Integer) getData("absoluteLeft");
}
public MouseEventDetails getMouseDownEvent() {
- return MouseEventDetails.deSerialize((String) get("mouseDown"));
+ return MouseEventDetails.deSerialize((String) getData("mouseDown"));
}
public MouseEventDetails getMouseEvent() {
- return MouseEventDetails.deSerialize((String) get("mouseEvent"));
+ return MouseEventDetails
+ .deSerialize((String) getData("mouseEvent"));
}
}
- public DragDropDetails translateDragDropDetails(
+ public TargetDetails translateDragDropDetails(
Map<String, Object> clientVariables) {
return new DragEventDetails(clientVariables);
}
+ public void setDropHandler(DropHandler dropHandler2) {
+ dropHandler = dropHandler2;
+ requestRepaint();
+ }
+
}
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.event.dd.DragSource;
import com.vaadin.terminal.KeyMapper;
import com.vaadin.terminal.PaintException;
import com.vaadin.terminal.PaintTarget;
import com.vaadin.data.Item;
import com.vaadin.data.util.ContainerHierarchicalWrapper;
import com.vaadin.data.util.IndexedContainer;
-import com.vaadin.event.AbstractDropHandler;
import com.vaadin.event.Action;
import com.vaadin.event.DataBindedTransferable;
-import com.vaadin.event.DragDropDataTranslator;
-import com.vaadin.event.DragDropDetailsImpl;
-import com.vaadin.event.DropHandler;
-import com.vaadin.event.DropTarget;
import com.vaadin.event.ItemClickEvent;
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.event.dd.DragAndDropEvent;
+import com.vaadin.event.dd.DragSource;
+import com.vaadin.event.dd.DropHandler;
+import com.vaadin.event.dd.DropTarget;
+import com.vaadin.event.dd.TargetDetailsImpl;
+import com.vaadin.event.dd.acceptCriteria.ServerSideCriterion;
import com.vaadin.terminal.KeyMapper;
import com.vaadin.terminal.PaintException;
import com.vaadin.terminal.PaintTarget;
@SuppressWarnings("serial")
@ClientWidget(VTree.class)
public class Tree extends AbstractSelect implements Container.Hierarchical,
- Action.Container, ItemClickSource, DragSource, DropTarget,
- DragDropDataTranslator {
+ Action.Container, ItemClickSource, DragSource, DropTarget {
private static final Method EXPAND_METHOD;
}
public Object getData(String dataFlawor) {
+ if (dataFlawor.equals("Text")) {
+ return getItemCaption(getItemId());
+ }
return data.get(dataFlawor);
}
// New items
target.addVariable(this, "newitem", new String[] {});
- if (dropHandler instanceof AbstractDropHandler) {
- ((AbstractDropHandler) dropHandler).paint(target);
+ if (dropHandler != null) {
+ dropHandler.getAcceptCriterion().paint(target);
}
}
TOP, BOTTOM, MIDDLE
}
- public class TreeDropDetails extends DragDropDetailsImpl {
+ public class TreeDropDetails extends TargetDetailsImpl {
private Object idOver;
TreeDropDetails(Map<String, Object> rawVariables) {
super(rawVariables);
// eagar fetch itemid, mapper may be emptied
- String keyover = (String) get("itemIdOver");
+ String keyover = (String) getData("itemIdOver");
if (keyover != null) {
idOver = itemIdMapper.get(keyover);
}
}
public Location getDropLocation() {
- String s = (String) get("detail");
+ String s = (String) getData("detail");
if ("Top".equals(s)) {
return Location.TOP;
} else if ("Bottom".equals(s)) {
return new TreeDropDetails(clientVariables);
}
+ /**
+ * API for {@link TreeDropCriterion}
+ *
+ * @param itemId
+ * @return
+ */
+ private String key(Object itemId) {
+ return itemIdMapper.key(itemId);
+ }
+
+ /**
+ * An example of lazy initializing criterion. Initially pretty much no data
+ * is sent to client, on first accepts set (per drag request) the client
+ * side data structure is initialized and no subsequent requests requests
+ * are needed during that drag and drop operation.
+ * <p>
+ * See client side counterpart
+ */
+ public static abstract class TreeDropCriterion extends ServerSideCriterion {
+
+ private Tree tree;
+
+ private Set<Object> allowedItemIds;
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see
+ * com.vaadin.event.dd.acceptCriteria.ServerSideCriterion#getIdentifier
+ * ()
+ */
+ @Override
+ protected String getIdentifier() {
+ return TreeDropCriterion.class.getCanonicalName();
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see
+ * com.vaadin.event.dd.acceptCriteria.AcceptCriterion#accepts(com.vaadin
+ * .event.dd.DragAndDropEvent)
+ */
+ public boolean accepts(DragAndDropEvent dragEvent) {
+ TreeDropDetails dropTargetData = (TreeDropDetails) dragEvent
+ .getDropTargetData();
+ tree = (Tree) dragEvent.getDropTargetData().getTarget();
+ allowedItemIds = getAllowedItemIds(dragEvent, tree);
+ return allowedItemIds.contains(dropTargetData.getItemIdOver());
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see
+ * com.vaadin.event.dd.acceptCriteria.AcceptCriterion#paintResponse(
+ * com.vaadin.terminal.PaintTarget)
+ */
+ @Override
+ public void paintResponse(PaintTarget target) throws PaintException {
+ /*
+ * send allowed nodes to client so subsequent requests can be
+ * avoided
+ */
+ Object[] array = allowedItemIds.toArray();
+ for (int i = 0; i < array.length; i++) {
+ String key = tree.key(array[i]);
+ array[i] = key;
+ }
+ target.addAttribute("allowedIds", array);
+ }
+
+ protected abstract Set<Object> getAllowedItemIds(
+ DragAndDropEvent dragEvent, Tree tree);
+
+ }
+
}
package com.vaadin.tests.dd;
import com.vaadin.event.ComponentTransferable;
-import com.vaadin.event.DragDropDetails;
import com.vaadin.event.Transferable;
-import com.vaadin.event.AbstractDropHandler.AcceptCriterion;
+import com.vaadin.event.dd.DragAndDropEvent;
+import com.vaadin.event.dd.acceptCriteria.AcceptCriterion;
+import com.vaadin.event.dd.acceptCriteria.ServerSideCriterion;
import com.vaadin.ui.DragDropPane;
import com.vaadin.ui.Tree;
import com.vaadin.ui.Window;
DragDropPane pane = new DragDropPane();
setContent(pane);
- pane.getDropHandler().setAcceptCriterion(new AcceptCriterion() {
- public boolean accepts(Transferable transferable,
- DragDropDetails dragDropDetails) {
+ pane.setSizeFull();
+ setWidth("450px");
+ setHeight("150px");
+
+ final ServerSideCriterion serverSideCriterion = new ServerSideCriterion() {
+
+ public boolean accepts(DragAndDropEvent dragEvent) {
+ Transferable transferable = dragEvent.getTransferable();
if (transferable instanceof ComponentTransferable) {
ComponentTransferable componentTransferrable = (ComponentTransferable) transferable;
if (componentTransferrable.getSourceComponent() == tree1) {
}
return false;
}
+ };
+
+ pane.setDropHandler(new DragDropPane.ImportPrettyMuchAnything() {
+ @Override
+ public AcceptCriterion getAcceptCriterion() {
+ return serverSideCriterion;
+ }
});
- pane.setSizeFull();
- setWidth("450px");
- setHeight("150px");
+
}
}
package com.vaadin.tests.dd;
-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.DropTarget;
-import com.vaadin.event.Transferable;
-import com.vaadin.terminal.gwt.client.ui.dd.VDragAndDropManager.DragEventType;
+import java.util.Map;
+
+import com.vaadin.event.dd.DropEvent;
+import com.vaadin.event.dd.DropHandler;
+import com.vaadin.event.dd.DropTarget;
+import com.vaadin.event.dd.TargetDetails;
+import com.vaadin.event.dd.acceptCriteria.AcceptAll;
+import com.vaadin.event.dd.acceptCriteria.AcceptCriterion;
import com.vaadin.ui.AbstractComponent;
import com.vaadin.ui.ClientWidget;
import com.vaadin.ui.Component;
@ClientWidget(VMyDropTarget.class)
class MyDropTarget extends AbstractComponent implements DropTarget {
public DropHandler getDropHandler() {
- return new DragDropHandler() {
- public void handleDragRequest(DragRequest dragRequest,
- Transferable transferable,
- DragDropDetails dragDropDetails) {
- DragEventType type = dragRequest.getType();
- switch (type) {
-
- case ENTER:
- // eg. validate transferrable
- if (transferable.getDataFlawors().contains("Foo")) {
- dragRequest.getResponseData().put("valueFor",
- "clientSideCallBack");
- }
-
- break;
- case OVER:
-
- break;
- case LEAVE:
-
- break;
- default:
- break;
- }
+ return new DropHandler() {
+ public void drop(DropEvent event) {
+ // Do something with data
+ return;
}
- public boolean drop(Transferable transferable,
- DragDropDetails dropDetails) {
- // Do something with data
- return true;
+ public AcceptCriterion getAcceptCriterion() {
+ return AcceptAll.get();
}
+
};
}
+ public TargetDetails translateDragDropDetails(
+ Map<String, Object> clientVariables) {
+ // If component has some special drop details that it needs to
+ // translate for server side use, developer must return a
+ // DragDropDetails here. If details does not exist or raw client
+ // side data is ok, it is safe to return null here.
+ return null;
+ }
+
}
/**
import com.vaadin.data.Item;
import com.vaadin.data.util.HierarchicalContainer;
-import com.vaadin.event.AbstractDropHandler;
import com.vaadin.event.ComponentTransferable;
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.dd.DragAndDropEvent;
+import com.vaadin.event.dd.DropEvent;
+import com.vaadin.event.dd.DropHandler;
+import com.vaadin.event.dd.acceptCriteria.AcceptCriterion;
+import com.vaadin.event.dd.acceptCriteria.IsDataBinded;
+import com.vaadin.event.dd.acceptCriteria.ServerSideCriterion;
import com.vaadin.terminal.ExternalResource;
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.Component;
pane1.addComponent(label);
DragDropPane pane2 = new DragDropPane();
- pane2.setDebugId("pane2");
- pane2.setSizeFull();
pane2
- .setCaption("Pane2 (accept needs server side visit, only \"Bar\")");
-
- AcceptCriterion f = new AcceptCriterion() {
- public boolean accepts(Transferable transferable,
- DragDropDetails dragDropDetails) {
- // System.out.println("Simulating 500ms processing...");
- // try {
- // Thread.sleep(200);
- // } catch (InterruptedException e) {
- // // TODO Auto-generated catch block
- // e.printStackTrace();
- // }
- // System.out.println("Done get to work.");
- if (transferable instanceof ComponentTransferable) {
- ComponentTransferable ct = (ComponentTransferable) transferable;
-
- Component component = ct.getSourceComponent();
- if (component != null) {
- if (component.toString() != null
- && component.toString().contains("Bar")) {
- return true;
+ .setCaption("Pane2 (accept needs server side visit, check for \"Bar\")");
+ DropHandler dropHandler = new DragDropPane.ImportPrettyMuchAnything() {
+ private final AcceptCriterion crit = new ServerSideCriterion() {
+ public boolean accepts(DragAndDropEvent dragEvent) {
+ Transferable transferable = dragEvent.getTransferable();
+ // System.out.println("Simulating 500ms processing...");
+ // try {
+ // Thread.sleep(200);
+ // } catch (InterruptedException e) {
+ // // TODO Auto-generated catch block
+ // e.printStackTrace();
+ // }
+ // System.out.println("Done get to work.");
+ if (transferable instanceof ComponentTransferable) {
+ ComponentTransferable ct = (ComponentTransferable) transferable;
+
+ Component component = ct.getSourceComponent();
+ if (component != null) {
+ if (component.toString() != null
+ && component.toString().contains("Bar")) {
+ return true;
+ }
}
}
+ return false;
}
- return false;
+ };
+
+ @Override
+ public AcceptCriterion getAcceptCriterion() {
+ return crit;
}
+
};
- pane2.getDropHandler().setAcceptCriterion(f);
+ pane2.setDropHandler(dropHandler);
+ pane2.setDebugId("pane2");
+ pane2.setSizeFull();
DragDropPane pane3 = new DragDropPane();
pane3.setSizeFull();
*
* TODO fix algorithm, broken in some cases.
*/
- AbstractDropHandler itemSorter = new AbstractDropHandler() {
-
- @Override
- 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 DataBindedTransferable) {
- DataBindedTransferable transferrable2 = (DataBindedTransferable) transferable;
-
- Object itemId = transferrable2.getItemId();
-
- Object itemIdOver = details.getItemIdOver();
-
- Location dropLocation = details.getDropLocation();
-
- if (dropLocation == Location.MIDDLE) {
- t.setParent(itemId, itemIdOver);
- return;
- } else if (Location.TOP == dropLocation) {
- // if on top of the caption area, add before
- itemIdOver = idx.prevItemId(itemIdOver);
- }
-
- if (itemId.equals(itemIdOver)) {
- // the location is same
- return;
- }
-
- HierarchicalContainer subtree = getSubTree(idx, itemId);
- boolean removed = idx.removeItem(itemId);
-
- if (removed) {
-
- if (dropLocation == null) {
- System.err
- .println("No detail of drop place available");
- }
-
- Item addItemAfter = idx
- .addItemAfter(itemIdOver, itemId);
- populateSubTree(idx, subtree, itemId);
- // ensure the same parent as with related item
- Object parent = idx.getParent(itemIdOver);
- idx.setParent(itemId, parent);
- }
- }
-
- }
+ DropHandler itemSorter = new DropHandler() {
private void populateSubTree(HierarchicalContainer idx,
HierarchicalContainer subtree, Object itemId) {
}
- };
+ public void drop(DropEvent event) {
+ TreeDropDetails details = (TreeDropDetails) event
+ .getDropTargetData();
+ // TODO set properties, so same sorter could be used in Table
+ Transferable transferable = event.getTransferable();
+ if (transferable instanceof DataBindedTransferable) {
+ DataBindedTransferable transferrable2 = (DataBindedTransferable) transferable;
- /*
- * Accept only drags that have item identifiers
- */
- itemSorter
- .setAcceptCriterion(AbstractDropHandler.CRITERION_HAS_ITEM_ID);
+ Object itemId = transferrable2.getItemId();
+
+ Object itemIdOver = details.getItemIdOver();
+
+ Location dropLocation = details.getDropLocation();
+
+ if (dropLocation == Location.MIDDLE) {
+ t.setParent(itemId, itemIdOver);
+ return;
+ } else if (Location.TOP == dropLocation) {
+ // if on top of the caption area, add before
+ itemIdOver = idx.prevItemId(itemIdOver);
+ }
+
+ if (itemId.equals(itemIdOver)) {
+ // the location is same
+ return;
+ }
+
+ HierarchicalContainer subtree = getSubTree(idx, itemId);
+ boolean removed = idx.removeItem(itemId);
+
+ if (removed) {
+
+ if (dropLocation == null) {
+ System.err
+ .println("No detail of drop place available");
+ }
+
+ Item addItemAfter = idx
+ .addItemAfter(itemIdOver, itemId);
+ populateSubTree(idx, subtree, itemId);
+ // ensure the same parent as with related item
+ Object parent = idx.getParent(itemIdOver);
+ idx.setParent(itemId, parent);
+ }
+ }
+
+ return;
+ }
+
+ public AcceptCriterion getAcceptCriterion() {
+ // TODO should actually check that source is same as target
+ return IsDataBinded.get();
+ }
+
+ };
t.setDropHandler(itemSorter);
package com.vaadin.tests.dd;
import java.util.Collection;
+import java.util.HashSet;
+import java.util.Set;
import com.vaadin.data.Item;
import com.vaadin.data.util.HierarchicalContainer;
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.DataBindedTransferable;
-import com.vaadin.event.DragDropDetails;
import com.vaadin.event.Transferable;
-import com.vaadin.event.AbstractDropHandler.AcceptCriterion;
-import com.vaadin.event.AbstractDropHandler.And;
+import com.vaadin.event.dd.DragAndDropEvent;
+import com.vaadin.event.dd.DropEvent;
+import com.vaadin.event.dd.DropHandler;
+import com.vaadin.event.dd.acceptCriteria.AcceptCriterion;
+import com.vaadin.event.dd.acceptCriteria.And;
+import com.vaadin.event.dd.acceptCriteria.ComponentFilter;
+import com.vaadin.event.dd.acceptCriteria.IsDataBinded;
+import com.vaadin.event.dd.acceptCriteria.OverTreeNode;
import com.vaadin.terminal.Resource;
import com.vaadin.terminal.ThemeResource;
import com.vaadin.tests.components.TestBase;
Table table = new Table("Drag rows to Tree on left or right");
Tree tree2 = new Tree("Accepts items, copies values");
+ private Tree tree3;
+
@Override
protected void setup() {
Window w = getLayout().getWindow();
populateTable();
addComponent(hl);
+ tree3 = new Tree(
+ "Tree with lazy loading criteria, of first server visit caches accept rules for all captions");
+
+ tree3.addItem("Drag on me");
+ tree3.addItem("Or me");
+ /*
+ * An example of lazy initializing drop criterion with component
+ * specific api for easy rule writing.
+ *
+ * Example is pretty stupid (accepts drop on all nodes, but by
+ * explicitly defining them here), but demonstrates lazy initialization
+ * option if rules are heavy.
+ */
+ final AcceptCriterion crit = new Tree.TreeDropCriterion() {
+
+ @Override
+ protected Set<Object> getAllowedItemIds(DragAndDropEvent dragEvent,
+ Tree tree) {
+ HashSet<Object> hashSet = new HashSet<Object>(tree.getItemIds());
+ return hashSet;
+ }
+ };
+
+ tree3.setDropHandler(new DropHandler() {
+ public void drop(DropEvent dropEvent) {
+ Transferable transferable = dropEvent.getTransferable();
+ String data = (String) transferable.getData("Text");
+ if (data == null) {
+ data = "-no Text data flawor-";
+ }
+ tree3.addItem(data);
+ TreeDropDetails dropTargetData = (TreeDropDetails) dropEvent
+ .getDropTargetData();
+ tree3.setParent(data, dropTargetData.getItemIdOver());
+
+ }
+
+ public AcceptCriterion getAcceptCriterion() {
+ return crit;
+ }
+ });
+
+ addComponent(tree3);
+
/*
* Make table rows draggable
*/
table.setDragMode(Table.DragModes.ROWS);
- AbstractDropHandler dropHandler = new AbstractDropHandler() {
- @Override
- public void receive(Transferable transferable,
- DragDropDetails dropdetails) {
+ AcceptCriterion onNode = new OverTreeNode();
+ AcceptCriterion fromTree = new ComponentFilter(table);
+ final And and = new And(fromTree, onNode);
+
+ DropHandler dropHandler = new DropHandler() {
+
+ public void drop(DropEvent event) {
/*
* We know transferrable is from table, so it is of type
* DataBindedTransferrable
*/
- DataBindedTransferable tr = (DataBindedTransferable) transferable;
+ DataBindedTransferable tr = (DataBindedTransferable) event
+ .getTransferable();
Object itemId = tr.getItemId();
Table fromTable = (Table) tr.getSourceComponent();
String name = fromTable.getItem(itemId).getItemProperty("Name")
* As we also accept only drops on folders, we know dropDetails
* is from Tree and it contains itemIdOver.
*/
- TreeDropDetails details = (TreeDropDetails) dropdetails;
+ TreeDropDetails details = (TreeDropDetails) event
+ .getDropTargetData();
Object idOver = details.getItemIdOver();
tree1.setParent(name, idOver);
* Remove the item from table
*/
table.removeItem(itemId);
+ }
+ public AcceptCriterion getAcceptCriterion() {
+ return and;
}
};
- AcceptCriterion onNode = new AbstractDropHandler.OverTreeNode();
- AcceptCriterion fromTree = new AbstractDropHandler.ComponentFilter(
- table);
- And and = new AbstractDropHandler.And(fromTree, onNode);
- dropHandler.setAcceptCriterion(and);
tree1.setDropHandler(dropHandler);
/*
* source. Also make drags from tree1 possible.
*/
- dropHandler = new AbstractDropHandler() {
- @Override
- public void receive(Transferable transferable,
- DragDropDetails dropdetails) {
- TreeDropDetails details = (TreeDropDetails) dropdetails;
+ dropHandler = new DropHandler() {
+ public void drop(DropEvent event) {
+ TreeDropDetails details = (TreeDropDetails) event
+ .getDropTargetData();
+ Transferable transferable = event.getTransferable();
if (transferable instanceof DataBindedTransferable) {
DataBindedTransferable tr = (DataBindedTransferable) transferable;
}
}
}
+
+ public AcceptCriterion getAcceptCriterion() {
+ return IsDataBinded.get();
+ }
};
- dropHandler
- .setAcceptCriterion(AbstractDropHandler.CRITERION_HAS_ITEM_ID);
tree2.setDropHandler(dropHandler);
w.addWindow(acceptAnyThing);
acceptAnyThing.setPositionY(450);
- acceptAnyThing.setPositionX(0);
+ acceptAnyThing.setPositionX(150);
w.addWindow(acceptFromTree1viaServerCheck);
acceptFromTree1viaServerCheck.setPositionY(450);
- acceptFromTree1viaServerCheck.setPositionX(300);
+ acceptFromTree1viaServerCheck.setPositionX(450);
}
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.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;
private ApplicationConnection client;
public void dragEnter(VDragEvent drag) {
- VDragAndDropManager.get().visitServer(new VAcceptCallback() {
- public void accepted() {
- // show drag hints here
- }
- });
}
public void dragLeave(VDragEvent drag) {
projects / vaadin-framework.git / commitdiff