package com.vaadin.event;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
import com.vaadin.ui.Component;
-public interface ComponentTransferable extends Transferable {
+public class ComponentTransferable implements Transferable {
+ private Map<String, Object> rawVariables = new HashMap<String, Object>();
+ private Component sourceComponent;
+
+ public ComponentTransferable(Component sourceComponent,
+ Map<String, Object> rawVariables) {
+ this.sourceComponent = sourceComponent;
+ this.rawVariables = rawVariables;
+ }
+
+ public Component getSourceComponent() {
+ return sourceComponent;
+ }
+
+ public Object getData(String dataFlawor) {
+ return rawVariables.get(dataFlawor);
+ }
+
+ public void setData(String dataFlawor, Object value) {
+ rawVariables.put(dataFlawor, value);
+ }
- /**
- * @return the component that started the drag operation
- */
- public Component getSourceComponent();
+ public Collection<String> getDataFlawors() {
+ return rawVariables.keySet();
+ }
}
package com.vaadin.event;
-public interface DataBoundTransferable extends ComponentTransferable {
+import java.util.Map;
- public Object getItemId();
+import com.vaadin.ui.Component;
- public Object getPropertyId();
+public abstract class DataBoundTransferable extends ComponentTransferable {
+
+ public DataBoundTransferable(Component sourceComponent,
+ Map<String, Object> rawVariables) {
+ super(sourceComponent, rawVariables);
+ }
+
+ public abstract Object getItemId();
+
+ public abstract Object getPropertyId();
}
import com.vaadin.event.Transferable;
-public abstract class DragAndDropEvent implements Serializable {
+public class DragAndDropEvent implements Serializable {
private static final long serialVersionUID = -2232591107911385564L;
private Transferable transferable;
- private TargetDetails dropDetails;
+ private DropTargetDetails dropDetails;
- public DragAndDropEvent(Transferable tr, TargetDetails details) {
+ public DragAndDropEvent(Transferable tr, DropTargetDetails details) {
transferable = tr;
dropDetails = details;
}
return transferable;
}
- public TargetDetails getDropTargetData() {
+ public DropTargetDetails 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;
- }
-
-}
*
* <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
+ * @return the drag source related transferable
*/
- public Transferable getTransferable(Transferable transferable,
- Map<String, Object> rawVariables);
+ public Transferable getTransferable(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);
- }
-}
public interface DropHandler extends Serializable {
- public void drop(DropEvent dropEvent);
+ public void drop(DragAndDropEvent dropEvent);
/**
* Returns the {@link AcceptCriterion} used to evaluate whether the
* 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
+ * automatically create a {@link DropTargetDetails} with all the client
* variables.
* <p>
* If this method returns null the data from client side will be passed
* Parameters passed from the client side widget.
* @return A DropData object with the translated data or null.
*/
- public TargetDetails translateDragDropDetails(
+ public DropTargetDetails translateDragDropDetails(
Map<String, Object> clientVariables);
}
\ No newline at end of file
--- /dev/null
+package com.vaadin.event.dd;
+
+import java.io.Serializable;
+
+public interface DropTargetDetails extends Serializable {
+
+ 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 DropTargetDetailsImpl implements DropTargetDetails {
+
+ private HashMap<String, Object> data = new HashMap<String, Object>();
+
+ public DropTargetDetailsImpl(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;
-
-import java.io.Serializable;
-
-public interface TargetDetails extends Serializable {
-
- 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
import com.vaadin.terminal.gwt.client.UIDL;
-final public class VAcceptAll implements VAcceptCriterion {
- public void accept(VDragEvent drag, UIDL configuration,
- VAcceptCallback callback) {
- callback.accepted(drag);
- }
+final public class VAcceptAll extends VAcceptCriterion {
- public boolean needsServerSideCheck(VDragEvent drag, UIDL criterioUIDL) {
- return false;
+ @Override
+ public boolean validates(VDragEvent drag, UIDL configuration) {
+ return true;
}
}
\ No newline at end of file
import com.vaadin.terminal.gwt.client.UIDL;
-public interface VAcceptCriterion {
+public abstract class VAcceptCriterion {
/**
* Checks if current drag event has valid drop target and target accepts the
* @param configuration
* @param callback
*/
- public void accept(VDragEvent drag, UIDL configuration,
- VAcceptCallback callback);
+ public void accept(final VDragEvent drag, UIDL configuration,
+ final VAcceptCallback callback) {
+ if (needsServerSideCheck(drag, configuration)) {
+ VDragEventServerCallback acceptCallback = new VDragEventServerCallback() {
+ public void handleResponse(boolean accepted, UIDL response) {
+ if (accepted) {
+ callback.accepted(drag);
+ }
+ }
+ };
+ VDragAndDropManager.get().visitServer(acceptCallback);
+ } else {
+ boolean validates = validates(drag, configuration);
+ if (validates) {
+ callback.accepted(drag);
+ }
+ }
- public boolean needsServerSideCheck(VDragEvent drag, UIDL criterioUIDL);
+ }
+
+ public abstract boolean validates(VDragEvent drag, UIDL configuration);
+
+ public boolean needsServerSideCheck(VDragEvent drag, UIDL criterioUIDL) {
+ return false;
+ }
}
import com.vaadin.terminal.gwt.client.ApplicationConnection;
import com.vaadin.terminal.gwt.client.UIDL;
-final public class VAnd implements VAcceptCriterion {
+/**
+ * TODO implementation could now be simplified/optimized
+ *
+ */
+final public class VAnd extends VAcceptCriterion {
private boolean b1;
private boolean b2;
private VAcceptCriterion crit1;
private VAcceptCriterion crit2;
- public void accept(VDragEvent drag, UIDL configuration,
- VAcceptCallback callback) {
+ private VAcceptCriterion getCriteria(VDragEvent drag, UIDL configuration,
+ int i) {
+ UIDL childUIDL = configuration.getChildUIDL(i);
+ return VAcceptCriteria.get(childUIDL.getStringAttribute("name"));
+ }
+
+ @Override
+ public boolean validates(VDragEvent drag, UIDL configuration) {
if (crit1 == null) {
crit1 = getCriteria(drag, configuration, 0);
crit2 = getCriteria(drag, configuration, 1);
if (crit1 == null || crit2 == null) {
ApplicationConnection.getConsole().log(
"And criteria didn't found a chidl criteria");
- return;
+ return false;
}
}
crit1.accept(drag, configuration.getChildUIDL(0), accept1cb);
crit2.accept(drag, configuration.getChildUIDL(1), accept2cb);
- if (b1 && b2) {
- callback.accepted(drag);
- }
- }
- private VAcceptCriterion getCriteria(VDragEvent drag, UIDL configuration,
- int i) {
- UIDL childUIDL = configuration.getChildUIDL(i);
- return VAcceptCriteria.get(childUIDL.getStringAttribute("name"));
+ return b1 && b2;
}
- public boolean needsServerSideCheck(VDragEvent drag, UIDL criterioUIDL) {
- return false; // TODO enforce on server side
- }
}
\ No newline at end of file
import com.vaadin.terminal.gwt.client.Paintable;
import com.vaadin.terminal.gwt.client.UIDL;
-final public class VComponentFilter implements VAcceptCriterion {
- public void accept(VDragEvent drag, UIDL configuration,
- VAcceptCallback callback) {
+final public class VComponentFilter extends VAcceptCriterion {
+
+ @Override
+ public boolean validates(VDragEvent drag, UIDL configuration) {
try {
Paintable component = drag.getTransferable().getDragSource();
int c = configuration.getIntAttribute("c");
.getCurrentDropHandler().getApplicationConnection()
.getPaintable(requiredPid);
if (paintable == component) {
- callback.accepted(drag);
+ return true;
}
}
} catch (Exception e) {
}
- return;
- }
-
- public boolean needsServerSideCheck(VDragEvent drag, UIDL criterioUIDL) {
return false;
}
}
\ No newline at end of file
import com.vaadin.terminal.gwt.client.UIDL;
-final public class VContainsDataFlawor implements VAcceptCriterion {
- public void accept(VDragEvent drag, UIDL configuration,
- VAcceptCallback callback) {
- String name = configuration.getStringAttribute("p");
- boolean contains = drag.getTransferable().getDataFlawors().contains(
- name);
- if (contains) {
- callback.accepted(drag);
- }
- }
+final public class VContainsDataFlawor extends VAcceptCriterion {
- public boolean needsServerSideCheck(VDragEvent drag, UIDL criterioUIDL) {
- return false;
+ @Override
+ public boolean validates(VDragEvent drag, UIDL configuration) {
+ String name = configuration.getStringAttribute("p");
+ return drag.getTransferable().getDataFlawors().contains(name);
}
}
\ No newline at end of file
import com.vaadin.terminal.gwt.client.UIDL;
-final public class VDataBound implements VAcceptCriterion {
- public void accept(VDragEvent drag, UIDL configuration,
- VAcceptCallback callback) {
- if (drag.getTransferable().getData("itemId") != null) {
- callback.accepted(drag);
- }
- }
+final public class VDataBound extends VAcceptCriterion {
- public boolean needsServerSideCheck(VDragEvent drag, UIDL criterioUIDL) {
- return false;
+ @Override
+ public boolean validates(VDragEvent drag, UIDL configuration) {
+ return drag.getTransferable().getData("itemId") != null;
}
}
\ No newline at end of file
import com.vaadin.terminal.gwt.client.UIDL;
-final public class VDropDetailEquals implements VAcceptCriterion {
- public void accept(VDragEvent drag, UIDL configuration,
- VAcceptCallback callback) {
+final public class VDropDetailEquals extends VAcceptCriterion {
+
+ @Override
+ public boolean validates(VDragEvent drag, UIDL configuration) {
String name = configuration.getStringAttribute("p");
String value = configuration.getStringAttribute("v");
Object object = drag.getDropDetails().get(name);
- if (value.equals(object)) {
- callback.accepted(drag);
- }
- }
-
- public boolean needsServerSideCheck(VDragEvent drag, UIDL criterioUIDL) {
- return false;
+ return value.equals(object);
}
}
\ No newline at end of file
import com.vaadin.terminal.gwt.client.UIDL;
-final public class VIdentifierIs implements VAcceptCriterion {
- public void accept(VDragEvent drag, UIDL configuration,
- VAcceptCallback callback) {
+final public class VIdentifierIs extends VAcceptCriterion {
+
+ @Override
+ public boolean validates(VDragEvent drag, UIDL configuration) {
try {
Object data = drag.getTransferable().getData("itemId");
Set<String> stringArrayVariableAsSet = configuration
.getStringArrayVariableAsSet("keys");
- if (stringArrayVariableAsSet.contains(data)) {
- callback.accepted(drag);
- }
+ return stringArrayVariableAsSet.contains(data);
} catch (Exception e) {
}
- return;
- }
-
- public boolean needsServerSideCheck(VDragEvent drag, UIDL criterioUIDL) {
return false;
}
}
\ No newline at end of file
import com.vaadin.terminal.gwt.client.UIDL;
-final public class VIsOverId implements VAcceptCriterion {
- public void accept(VDragEvent drag, UIDL configuration,
- VAcceptCallback callback) {
+final public class VIsOverId extends VAcceptCriterion {
+
+ @Override
+ public boolean validates(VDragEvent drag, UIDL configuration) {
try {
Set<String> stringArrayVariableAsSet = configuration
.getStringArrayVariableAsSet("keys");
- if (stringArrayVariableAsSet.contains(drag.getDropDetails().get(
- "itemIdOver"))) {
- callback.accepted(drag);
- }
+ return stringArrayVariableAsSet.contains(drag.getDropDetails().get(
+ "itemIdOver"));
} catch (Exception e) {
}
- return;
- }
-
- public boolean needsServerSideCheck(VDragEvent drag, UIDL criterioUIDL) {
return false;
}
}
\ No newline at end of file
* @deprecated example class testing custom behavior
*/
@Deprecated
-final public class VLazyInitItemIdentifiers implements VAcceptCriterion {
+final public class VLazyInitItemIdentifiers extends VAcceptCriterion {
private boolean loaded = false;
private HashSet<String> hashSet;
private VDragEvent lastDragEvent;
+ @Override
public void accept(final VDragEvent drag, UIDL configuration,
final VAcceptCallback callback) {
if (lastDragEvent == null || lastDragEvent != drag) {
}
+ @Override
public boolean needsServerSideCheck(VDragEvent drag, UIDL criterioUIDL) {
return loaded;
}
+
+ @Override
+ public boolean validates(VDragEvent drag, UIDL configuration) {
+ return false; // not used is this implementation
+ }
}
\ No newline at end of file
import com.vaadin.terminal.gwt.client.ApplicationConnection;
import com.vaadin.terminal.gwt.client.UIDL;
-final public class VNot implements VAcceptCriterion {
+/**
+ * TODO implementation could now be simplified/optimized
+ *
+ */
+final public class VNot extends VAcceptCriterion {
private boolean b1;
private VAcceptCriterion crit1;
+ @Override
public void accept(VDragEvent drag, UIDL configuration,
VAcceptCallback callback) {
if (crit1 == null) {
return VAcceptCriteria.get(childUIDL.getStringAttribute("name"));
}
+ @Override
public boolean needsServerSideCheck(VDragEvent drag, UIDL criterioUIDL) {
return false; // TODO enforce on server side
}
+
+ @Override
+ public boolean validates(VDragEvent drag, UIDL configuration) {
+ return false; // not used
+ }
}
\ No newline at end of file
import com.vaadin.terminal.gwt.client.ApplicationConnection;
import com.vaadin.terminal.gwt.client.UIDL;
-final public class VOr implements VAcceptCriterion {
+/**
+ * TODO implementation could now be simplified/optimized
+ *
+ */
+final public class VOr extends VAcceptCriterion {
private boolean b1;
private boolean b2;
private VAcceptCriterion crit1;
private VAcceptCriterion crit2;
+ @Override
public void accept(VDragEvent drag, UIDL configuration,
VAcceptCallback callback) {
if (crit1 == null) {
return VAcceptCriteria.get(childUIDL.getStringAttribute("name"));
}
+ @Override
public boolean needsServerSideCheck(VDragEvent drag, UIDL criterioUIDL) {
return false; // TODO enforce on server side
}
+ @Override
+ public boolean validates(VDragEvent drag, UIDL configuration) {
+ return false; // not used here
+ }
+
}
\ No newline at end of file
import com.vaadin.terminal.gwt.client.UIDL;
-final public class VOverTreeNode implements VAcceptCriterion {
- public void accept(VDragEvent drag, UIDL configuration,
- VAcceptCallback callback) {
+final public class VOverTreeNode extends VAcceptCriterion {
+
+ @Override
+ public boolean validates(VDragEvent drag, UIDL configuration) {
Boolean containsKey = (Boolean) drag.getDropDetails().get(
"itemIdOverIsNode");
- if (containsKey != null && containsKey.booleanValue()) {
- callback.accepted(drag);
- return;
- }
- return;
- }
-
- public boolean needsServerSideCheck(VDragEvent drag, UIDL criterioUIDL) {
- return false;
+ return containsKey != null && containsKey.booleanValue();
}
}
\ No newline at end of file
import com.vaadin.terminal.gwt.client.UIDL;
-final public class VServerAccept implements VAcceptCriterion {
+final public class VServerAccept extends VAcceptCriterion {
+ @Override
public void accept(final VDragEvent drag, UIDL configuration,
final VAcceptCallback callback) {
VDragAndDropManager.get().visitServer(acceptCallback);
}
+ @Override
public boolean needsServerSideCheck(VDragEvent drag, UIDL criterioUIDL) {
return true;
}
+
+ @Override
+ public boolean validates(VDragEvent drag, UIDL configuration) {
+ return false; // not used
+ }
}
\ No newline at end of file
import com.vaadin.terminal.gwt.client.Paintable;
import com.vaadin.terminal.gwt.client.UIDL;
-final public class VSourceIsSameAsTarget implements VAcceptCriterion {
- public void accept(VDragEvent drag, UIDL configuration,
- VAcceptCallback callback) {
+final public class VSourceIsSameAsTarget extends VAcceptCriterion {
+
+ @Override
+ public boolean validates(VDragEvent drag, UIDL configuration) {
Paintable dragSource = drag.getTransferable().getDragSource();
Paintable paintable = VDragAndDropManager.get().getCurrentDropHandler()
.getPaintable();
- if (paintable == dragSource) {
- callback.accepted(drag);
- }
- }
-
- public boolean needsServerSideCheck(VDragEvent drag, UIDL criterioUIDL) {
- return false;
+ return paintable == dragSource;
}
}
\ No newline at end of file
import com.vaadin.event.ComponentTransferable;
import com.vaadin.event.Transferable;
-import com.vaadin.event.dd.DragEvent;
+import com.vaadin.event.dd.DragAndDropEvent;
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.DropTargetDetails;
+import com.vaadin.event.dd.DropTargetDetailsImpl;
import com.vaadin.event.dd.acceptCriteria.AcceptCriterion;
import com.vaadin.terminal.PaintException;
import com.vaadin.terminal.VariableOwner;
private int currentEventId;
- private Transferable transferable;
-
private boolean lastVisitAccepted = false;
- private DragEvent dragEvent;
+ private DragAndDropEvent dragEvent;
private final AbstractCommunicationManager manager;
* source for Transferable, drop target for DragDropDetails).
*/
Transferable transferable = constructTransferable(dropTarget, variables);
- TargetDetails dropData = constructDragDropDetails(dropTarget, variables);
- DropEvent dropEvent = new DropEvent(transferable, dropData);
+ DropTargetDetails dropData = constructDragDropDetails(dropTarget,
+ variables);
+ DragAndDropEvent dropEvent = new DragAndDropEvent(transferable,
+ dropData);
if (dropHandler.getAcceptCriterion().accepts(dropEvent)) {
dropHandler.drop(dropEvent);
}
* source for Transferable, current target for DragDropDetails).
*/
Transferable transferable = constructTransferable(dropTarget, variables);
- TargetDetails dragDropDetails = constructDragDropDetails(dropTarget,
- variables);
+ DropTargetDetails dragDropDetails = constructDragDropDetails(
+ dropTarget, variables);
- dragEvent = new DragEvent(transferable, dragDropDetails);
+ dragEvent = new DragAndDropEvent(transferable, dragDropDetails);
lastVisitAccepted = acceptCriterion.accepts(dragEvent);
}
* @return
*/
@SuppressWarnings("unchecked")
- private TargetDetails constructDragDropDetails(DropTarget dropTarget,
+ private DropTargetDetails constructDragDropDetails(DropTarget dropTarget,
Map<String, Object> variables) {
Map<String, Object> rawDragDropDetails = (Map<String, Object>) variables
.get("evt");
- TargetDetails dropData = dropTarget
+ DropTargetDetails dropData = dropTarget
.translateDragDropDetails(rawDragDropDetails);
if (dropData == null) {
// Create a default DragDropDetails with all the raw variables
- dropData = new TargetDetailsImpl(rawDragDropDetails);
+ dropData = new DropTargetDetailsImpl(rawDragDropDetails);
}
dropData.setData(DROPTARGET_KEY, dropTarget);
private Transferable constructTransferable(DropTarget dropHandlerOwner,
Map<String, Object> variables) {
int eventId = (Integer) variables.get("eventId");
- if (currentEventId != eventId) {
- transferable = null;
- }
currentEventId = eventId;
final Component sourceComponent = (Component) variables
variables = (Map<String, Object>) variables.get("tra");
+ Transferable transferable = null;
if (sourceComponent != null && sourceComponent instanceof DragSource) {
- transferable = ((DragSource) sourceComponent).getTransferable(
- transferable, variables);
+ transferable = ((DragSource) sourceComponent)
+ .getTransferable(variables);
} else {
if (transferable == null) {
if (sourceComponent != null) {
- transferable = new ComponentTransferable() {
-
- private Map<String, Object> td = new HashMap<String, Object>();
-
- public Component getSourceComponent() {
- return sourceComponent;
- }
-
- public Object getData(String dataFlawor) {
- return td.get(dataFlawor);
- }
-
- public void setData(String dataFlawor, Object value) {
- td.put(dataFlawor, value);
- }
-
- public Collection<String> getDataFlawors() {
- return td.keySet();
- }
-
- };
+ transferable = new ComponentTransferable(sourceComponent,
+ variables);
} else {
transferable = new Transferable() {
private Map<String, Object> td = new HashMap<String, Object>();
}
}
- /*
- * Add remaining (non-handled) variables to transferable as is
- */
- for (String key : variables.keySet()) {
- transferable.setData(key, variables.get(key));
- }
-
return transferable;
}
import com.vaadin.event.DataBoundTransferable;
import com.vaadin.event.Transferable;
import com.vaadin.event.dd.DragAndDropEvent;
-import com.vaadin.event.dd.TargetDetailsImpl;
+import com.vaadin.event.dd.DropTargetDetailsImpl;
import com.vaadin.event.dd.acceptCriteria.ClientCriterion;
import com.vaadin.event.dd.acceptCriteria.ClientSideCriterion;
import com.vaadin.terminal.KeyMapper;
}
- public class AbstractSelectDropDetails extends TargetDetailsImpl {
+ public class AbstractSelectDropDetails extends DropTargetDetailsImpl {
private Object idOver;
package com.vaadin.ui;
-import java.util.Collection;
import java.util.Map;
import com.vaadin.event.ComponentTransferable;
import com.vaadin.event.dd.DragSource;
import com.vaadin.event.dd.DropHandler;
import com.vaadin.event.dd.DropTarget;
-import com.vaadin.event.dd.TargetDetails;
+import com.vaadin.event.dd.DropTargetDetails;
import com.vaadin.terminal.PaintException;
import com.vaadin.terminal.PaintTarget;
import com.vaadin.terminal.gwt.client.ui.VDragAndDropWrapper;
public class DragAndDropWrapper extends CustomComponent implements DropTarget,
DragSource {
- public class DDWrapperTransferable implements ComponentTransferable {
- private final Map<String, Object> rawVariables;
+ public class DDWrapperTransferable extends ComponentTransferable {
- private DDWrapperTransferable(Map<String, Object> rawVariables) {
- this.rawVariables = rawVariables;
- }
-
- public void setData(String dataFlawor, Object value) {
- // TODO Auto-generated method stub
-
- }
-
- public Collection<String> getDataFlawors() {
- return rawVariables.keySet();
- }
-
- public Object getData(String dataFlawor) {
- return rawVariables.get(dataFlawor);
- }
-
- public Component getSourceComponent() {
- return DragAndDropWrapper.this;
+ public DDWrapperTransferable(Component sourceComponent,
+ Map<String, Object> rawVariables) {
+ super(sourceComponent, rawVariables);
}
/**
* @return
*/
public Component getDraggedComponent() {
- Component object = (Component) rawVariables.get("component");
+ Component object = (Component) getData("component");
return object;
}
}
requestRepaint();
}
- public TargetDetails translateDragDropDetails(
+ public DropTargetDetails translateDragDropDetails(
Map<String, Object> clientVariables) {
// TODO Auto-generated method stub
return null;
}
- public Transferable getTransferable(Transferable transferable,
- final Map<String, Object> rawVariables) {
- return new DDWrapperTransferable(rawVariables);
+ public Transferable getTransferable(final Map<String, Object> rawVariables) {
+ return new DDWrapperTransferable(this, rawVariables);
}
public void setDragStartMode(DragStartMode dragStartMode) {
import com.vaadin.event.ComponentTransferable;
import com.vaadin.event.DataBoundTransferable;
import com.vaadin.event.Transferable;
-import com.vaadin.event.dd.DropEvent;
+import com.vaadin.event.dd.DragAndDropEvent;
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.DropTargetDetails;
+import com.vaadin.event.dd.DropTargetDetailsImpl;
import com.vaadin.event.dd.acceptCriteria.AcceptAll;
import com.vaadin.event.dd.acceptCriteria.AcceptCriterion;
import com.vaadin.terminal.PaintException;
}
public static class ImportPrettyMuchAnything implements DropHandler {
- public void drop(DropEvent event) {
+ public void drop(DragAndDropEvent event) {
DragDropPane pane = (DragDropPane) event.getDropTargetData()
.getTarget();
}
}
- class DragEventDetails extends TargetDetailsImpl {
+ class DragEventDetails extends DropTargetDetailsImpl {
public DragEventDetails(Map<String, Object> rawVariables) {
super(rawVariables);
}
- public TargetDetails translateDragDropDetails(
+ public DropTargetDetails translateDragDropDetails(
Map<String, Object> clientVariables) {
return new DragEventDetails(clientVariables);
}
import com.vaadin.event.Action;
import com.vaadin.event.DataBoundTransferable;
import com.vaadin.event.ItemClickEvent;
-import com.vaadin.event.Transferable;
import com.vaadin.event.Action.Handler;
import com.vaadin.event.ItemClickEvent.ItemClickListener;
import com.vaadin.event.ItemClickEvent.ItemClickSource;
requestRepaint();
}
- class TableTransferable implements DataBoundTransferable {
+ class TableTransferable extends DataBoundTransferable {
- private final HashMap<String, Object> data = new HashMap<String, Object>();
+ public TableTransferable(Map<String, Object> rawVariables) {
+ super(Table.this, rawVariables);
+ Object object = rawVariables.get("itemId");
+ if (object != null) {
+ setData("itemId", itemIdMapper.get((String) object));
+ }
+ }
+ @Override
public Object getItemId() {
- return data.get("itemId");
+ return getData("itemId");
}
+ @Override
public Object getPropertyId() {
return getItemCaptionPropertyId();
}
- public Component getSourceComponent() {
- return Table.this;
- }
-
- public Object getData(String dataFlawor) {
- return data.get(dataFlawor);
- }
-
- public Collection<String> getDataFlawors() {
- return data.keySet();
- }
-
- public void setData(String dataFlawor, Object value) {
- data.put(dataFlawor, value);
- }
-
}
- private void updateTransferable(Map<String, Object> payload, Transferable tr) {
- Object object = payload.get("itemId");
- if (object != null) {
- tr.setData("itemId", itemIdMapper.get((String) object));
- payload.remove("itemId");
- }
- }
-
- public TableTransferable getTransferable(Transferable transferable,
- Map<String, Object> rawVariables) {
- if (transferable == null) {
- transferable = new TableTransferable();
- }
- updateTransferable(rawVariables, transferable);
- return (TableTransferable) transferable;
+ public TableTransferable getTransferable(Map<String, Object> rawVariables) {
+ TableTransferable transferable = new TableTransferable(rawVariables);
+ return transferable;
}
public DropHandler getDropHandler() {
private int itemDragModes = DRAG_OUT;
- class TreeTransferable implements DataBoundTransferable {
+ class TreeTransferable extends DataBoundTransferable {
- private final HashMap<String, Object> data = new HashMap<String, Object>();
+ public TreeTransferable(Component sourceComponent,
+ Map<String, Object> rawVariables) {
+ super(sourceComponent, rawVariables);
+ }
+ @Override
public Object getItemId() {
- return data.get("itemId");
+ return getData("itemId");
}
+ @Override
public Object getPropertyId() {
return getItemCaptionPropertyId();
}
-
- public Component getSourceComponent() {
- return Tree.this;
- }
-
- public Object getData(String dataFlawor) {
- if (dataFlawor.equals("Text")) {
- return getItemCaption(getItemId());
- }
- return data.get(dataFlawor);
- }
-
- public Collection<String> getDataFlawors() {
- return data.keySet();
- }
-
- public void setData(String dataFlawor, Object value) {
- data.put(dataFlawor, value);
- }
}
- public Transferable getTransferable(Transferable transferable,
- Map<String, Object> payload) {
- if (transferable == null) {
- transferable = new TreeTransferable();
- }
+ public Transferable getTransferable(Map<String, Object> payload) {
+ TreeTransferable transferable = new TreeTransferable(this, payload);
// updating drag source variables
Object object = payload.get("itemId");
if (object != null) {
transferable.setData("itemId", itemIdMapper.get((String) object));
}
- payload.remove("itemId");
return transferable;
}
import java.util.Map;
-import com.vaadin.event.dd.DropEvent;
+import com.vaadin.event.dd.DragAndDropEvent;
import com.vaadin.event.dd.DropHandler;
import com.vaadin.event.dd.DropTarget;
-import com.vaadin.event.dd.TargetDetails;
+import com.vaadin.event.dd.DropTargetDetails;
import com.vaadin.event.dd.acceptCriteria.AcceptAll;
import com.vaadin.event.dd.acceptCriteria.AcceptCriterion;
import com.vaadin.ui.AbstractComponent;
public DropHandler getDropHandler() {
return new DropHandler() {
- public void drop(DropEvent event) {
+ public void drop(DragAndDropEvent event) {
// Do something with data
return;
}
};
}
- public TargetDetails translateDragDropDetails(
+ public DropTargetDetails 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
import com.vaadin.event.DataBoundTransferable;
import com.vaadin.event.Transferable;
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.IsDatabound;
Transferable transferable = dragEvent.getTransferable();
// System.out.println("Simulating 500ms processing...");
// try {
- // Thread.sleep(200);
+ // Thread.sleep(9000);
// } catch (InterruptedException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
}
- public void drop(DropEvent event) {
+ public void drop(DragAndDropEvent event) {
AbstractSelectDropDetails details = (AbstractSelectDropDetails) event
.getDropTargetData();
// TODO set properties, so same sorter could be used in Table
import com.vaadin.event.DataBoundTransferable;
import com.vaadin.event.Transferable;
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;
};
tree3.setDropHandler(new DropHandler() {
- public void drop(DropEvent dropEvent) {
+ public void drop(DragAndDropEvent dropEvent) {
Transferable transferable = dropEvent.getTransferable();
String data = (String) transferable.getData("Text");
if (data == null) {
DropHandler dropHandler = new DropHandler() {
- public void drop(DropEvent event) {
+ public void drop(DragAndDropEvent event) {
/*
* We know transferrable is from table, so it is of type
* DataBindedTransferrable
*/
dropHandler = new DropHandler() {
- public void drop(DropEvent event) {
+ public void drop(DragAndDropEvent event) {
AbstractSelectDropDetails details = (AbstractSelectDropDetails) event
.getDropTargetData();
Transferable transferable = event.getTransferable();
import com.vaadin.demo.tutorial.addressbook.data.Person;
import com.vaadin.demo.tutorial.addressbook.data.PersonContainer;
import com.vaadin.event.DataBoundTransferable;
-import com.vaadin.event.dd.DropEvent;
+import com.vaadin.event.dd.DragAndDropEvent;
import com.vaadin.event.dd.DropHandler;
import com.vaadin.event.dd.acceptCriteria.AcceptCriterion;
import com.vaadin.event.dd.acceptCriteria.ComponentFilter;
return crit;
}
- public void drop(DropEvent dropEvent) {
+ public void drop(DragAndDropEvent dropEvent) {
AbstractSelectDropDetails dropTargetData = (AbstractSelectDropDetails) dropEvent
.getDropTargetData();
DataBoundTransferable transferable = (DataBoundTransferable) dropEvent
import java.util.Iterator;
-import com.vaadin.event.dd.DropEvent;
+import com.vaadin.event.dd.DragAndDropEvent;
import com.vaadin.event.dd.DropHandler;
import com.vaadin.event.dd.DropTarget;
import com.vaadin.event.dd.acceptCriteria.AcceptAll;
return AcceptAll.get();
}
- public void drop(DropEvent dropEvent) {
+ public void drop(DragAndDropEvent dropEvent) {
/*
* TODO wrap componentns in wrappers (so we can build reordering
import com.vaadin.event.ComponentTransferable;
import com.vaadin.event.Transferable;
-import com.vaadin.event.dd.DropEvent;
+import com.vaadin.event.dd.DragAndDropEvent;
import com.vaadin.event.dd.DropHandler;
import com.vaadin.event.dd.DropTarget;
-import com.vaadin.event.dd.TargetDetails;
+import com.vaadin.event.dd.DropTargetDetails;
import com.vaadin.event.dd.acceptCriteria.AcceptCriterion;
import com.vaadin.event.dd.acceptCriteria.And;
import com.vaadin.event.dd.acceptCriteria.DropDetailEquals;
return crit;
}
- public void drop(DropEvent dropEvent) {
+ public void drop(DragAndDropEvent dropEvent) {
Transferable transferable = dropEvent.getTransferable();
if (transferable instanceof ComponentTransferable) {
ComponentTransferable ct = (ComponentTransferable) transferable;
Iterator<Component> componentIterator = layout
.getComponentIterator();
Component next = componentIterator.next();
- TargetDetails dropTargetData = dropEvent
+ DropTargetDetails dropTargetData = dropEvent
.getDropTargetData();
DropTarget target = dropTargetData.getTarget();
while (next != target) {
import com.vaadin.event.ComponentTransferable;
import com.vaadin.event.Transferable;
-import com.vaadin.event.dd.DropEvent;
+import com.vaadin.event.dd.DragAndDropEvent;
import com.vaadin.event.dd.DropHandler;
import com.vaadin.event.dd.DropTarget;
-import com.vaadin.event.dd.TargetDetails;
+import com.vaadin.event.dd.DropTargetDetails;
import com.vaadin.event.dd.acceptCriteria.AcceptAll;
import com.vaadin.event.dd.acceptCriteria.AcceptCriterion;
import com.vaadin.ui.Component;
return AcceptAll.get();
}
- public void drop(DropEvent dropEvent) {
+ public void drop(DragAndDropEvent dropEvent) {
Transferable transferable = dropEvent.getTransferable();
if (transferable instanceof ComponentTransferable) {
ComponentTransferable ct = (ComponentTransferable) transferable;
Iterator<Component> componentIterator = cssLayout
.getComponentIterator();
Component next = componentIterator.next();
- TargetDetails dropTargetData = dropEvent
+ DropTargetDetails dropTargetData = dropEvent
.getDropTargetData();
DropTarget target = dropTargetData.getTarget();
while (next != target) {
projects / vaadin-framework.git / commitdiff