Adds Basic Drag & Drop Support for Operations

JLLeitschuh · JLLeitschuh · commit 4ce227bbf6ec · 2016-04-08T12:07:43.000-04:00
diff --git a/ui/src/main/java/edu/wpi/grip/ui/OperationController.java b/ui/src/main/java/edu/wpi/grip/ui/OperationController.java
@@ -6,14 +6,20 @@
 import edu.wpi.grip.core.Pipeline;
 import edu.wpi.grip.core.Step;
 import edu.wpi.grip.ui.annotations.ParametrizedController;
+import edu.wpi.grip.ui.dragging.OperationDragService;
 import edu.wpi.grip.ui.util.StyleClassNameUtility;
 import javafx.fxml.FXML;
 import javafx.scene.control.Label;
 import javafx.scene.control.Tooltip;
 import javafx.scene.image.Image;
 import javafx.scene.image.ImageView;
+import javafx.scene.input.DataFormat;
+import javafx.scene.input.Dragboard;
+import javafx.scene.input.TransferMode;
 import javafx.scene.layout.GridPane;
 
+import java.util.Collections;
+
 /**
  * A JavaFX control that renders information about an {@link Operation}.  This is used in the palette view to present
  * the user with information on the various operations to choose from.
@@ -35,16 +41,18 @@ public class OperationController implements Controller {
 
     private final Pipeline pipeline;
     private final Step.Factory stepFactory;
+    private final OperationDragService operationDragService;
     private final Operation operation;
 
     public interface Factory {
         OperationController create(Operation operation);
     }
 
     @Inject
-    OperationController(Pipeline pipeline, Step.Factory stepFactory, @Assisted Operation operation) {
+    OperationController(Pipeline pipeline, Step.Factory stepFactory, OperationDragService operationDragService, @Assisted Operation operation) {
         this.pipeline = pipeline;
         this.stepFactory = stepFactory;
+        this.operationDragService = operationDragService;
         this.operation = operation;
     }
 
@@ -65,6 +73,22 @@ public void initialize() {
 
         // Ensures that when this element is hidden that it also removes its size calculations
         root.managedProperty().bind(root.visibleProperty());
+
+
+        root.setOnDragDetected(mouseEvent -> {
+            // Create a snapshot to use as the cursor
+            final ImageView preview = new ImageView(root.snapshot(null, null));
+
+            final Dragboard db = root.startDragAndDrop(TransferMode.ANY);
+            db.setContent(Collections.singletonMap(DataFormat.PLAIN_TEXT, operation.getName()));
+            db.setDragView(preview.getImage());
+            // Begin the dragging
+            root.startFullDrag();
+            // Tell the drag service that this is the operation that will be received
+            operationDragService.beginDrag(operation);
+
+            mouseEvent.consume();
+        });
     }
 
     @FXML
diff --git a/ui/src/main/java/edu/wpi/grip/ui/dragging/DragService.java b/ui/src/main/java/edu/wpi/grip/ui/dragging/DragService.java
@@ -0,0 +1,56 @@
+package edu.wpi.grip.ui.dragging;
+
+
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.ReadOnlyObjectProperty;
+import javafx.beans.property.SimpleObjectProperty;
+
+import java.util.Optional;
+
+/**
+ * A service to provide data transfer capabilities between two controllers.
+ * Concrete versions of the service are usually {@link com.google.inject.Singleton Singletons}
+ * so that they can be injected into the two controllers.
+ *
+ * @param <T> The value that the object property holds.
+ */
+public abstract class DragService<T> {
+    private final ObjectProperty<T> dragProperty;
+
+    /**
+     * @param name The name for the {@link SimpleObjectProperty}
+     */
+    public DragService(String name) {
+        this.dragProperty = new SimpleObjectProperty<>(this, name);
+    }
+
+    /**
+     * @return The read only version of this object property.
+     */
+    public ReadOnlyObjectProperty<T> getDragProperty() {
+        return dragProperty;
+    }
+
+    /**
+     * @return The value stored in the object property.
+     */
+    public Optional<T> getValue() {
+        return Optional.ofNullable(dragProperty.get());
+    }
+
+    /**
+     * Begins the drag action
+     *
+     * @param value The value to be transferred during the drag.
+     */
+    public void beginDrag(T value) {
+        this.dragProperty.set(value);
+    }
+
+    /**
+     * This should be called when the drag action is complete.
+     */
+    public void completeDrag() {
+        dragProperty.setValue(null);
+    }
+}
diff --git a/ui/src/main/java/edu/wpi/grip/ui/dragging/OperationDragService.java b/ui/src/main/java/edu/wpi/grip/ui/dragging/OperationDragService.java
@@ -0,0 +1,17 @@
+package edu.wpi.grip.ui.dragging;
+
+
+import com.google.inject.Singleton;
+import edu.wpi.grip.core.Operation;
+
+/**
+ * Service for dragging an {@link Operation} from the {@link edu.wpi.grip.ui.pipeline.PipelineController}
+ * to the {@link edu.wpi.grip.ui.pipeline.PipelineController}.
+ */
+@Singleton
+public class OperationDragService extends DragService<Operation> {
+
+    public OperationDragService() {
+        super("operation");
+    }
+}
diff --git a/ui/src/main/java/edu/wpi/grip/ui/pipeline/PipelineController.java b/ui/src/main/java/edu/wpi/grip/ui/pipeline/PipelineController.java
@@ -4,11 +4,15 @@
 import com.google.common.eventbus.Subscribe;
 import com.google.inject.Singleton;
 import com.sun.javafx.application.PlatformImpl;
-import edu.wpi.grip.core.*;
+import edu.wpi.grip.core.Connection;
+import edu.wpi.grip.core.Pipeline;
+import edu.wpi.grip.core.Source;
+import edu.wpi.grip.core.Step;
 import edu.wpi.grip.core.events.*;
 import edu.wpi.grip.core.sockets.InputSocket;
 import edu.wpi.grip.core.sockets.OutputSocket;
 import edu.wpi.grip.ui.annotations.ParametrizedController;
+import edu.wpi.grip.ui.dragging.OperationDragService;
 import edu.wpi.grip.ui.pipeline.input.InputSocketController;
 import edu.wpi.grip.ui.pipeline.source.SourceController;
 import edu.wpi.grip.ui.pipeline.source.SourceControllerFactory;
@@ -22,6 +26,7 @@
 import javafx.scene.Group;
 import javafx.scene.Node;
 import javafx.scene.Parent;
+import javafx.scene.input.TransferMode;
 import javafx.scene.layout.HBox;
 import javafx.scene.layout.Pane;
 import javafx.scene.layout.VBox;
@@ -54,9 +59,13 @@ public final class PipelineController {
     @Inject
     private SourceControllerFactory sourceControllerFactory;
     @Inject
+    private Step.Factory stepFactory;
+    @Inject
     private StepController.Factory stepControllerFactory;
     @Inject
     private AddSourceView addSourceView;
+    @Inject
+    private OperationDragService operationDragService;
 
     private ControllerMap<StepController, Node> stepsMapManager;
     private ControllerMap<SourceController, Node> sourceMapManager;
@@ -80,6 +89,20 @@ public void initialize() throws Exception {
             stepsMapManager.add(stepController);
         });
 
+        stepBox.setOnDragOver(dragEvent -> {
+            operationDragService.getValue().ifPresent(operation -> {
+                dragEvent.acceptTransferModes(TransferMode.ANY);
+            });
+
+        });
+
+        stepBox.setOnDragDropped(mouseEvent -> {
+            operationDragService.getValue().ifPresent(operation -> {
+                operationDragService.completeDrag();
+                pipeline.addStep(stepFactory.create(operation));
+            });
+        });
+
         addSourcePane.getChildren().add(addSourceView);
     }
 
diff --git a/ui/src/main/java/edu/wpi/grip/ui/pipeline/SocketHandleView.java b/ui/src/main/java/edu/wpi/grip/ui/pipeline/SocketHandleView.java
@@ -5,17 +5,17 @@
 import com.google.inject.Inject;
 import com.google.inject.Singleton;
 import com.google.inject.assistedinject.Assisted;
-import edu.wpi.grip.core.*;
+import edu.wpi.grip.core.Connection;
+import edu.wpi.grip.core.Pipeline;
 import edu.wpi.grip.core.events.ConnectionAddedEvent;
 import edu.wpi.grip.core.events.ConnectionRemovedEvent;
 import edu.wpi.grip.core.events.SocketConnectedChangedEvent;
 import edu.wpi.grip.core.sockets.InputSocket;
 import edu.wpi.grip.core.sockets.OutputSocket;
 import edu.wpi.grip.core.sockets.Socket;
+import edu.wpi.grip.ui.dragging.DragService;
 import javafx.beans.property.BooleanProperty;
-import javafx.beans.property.ObjectProperty;
 import javafx.beans.property.SimpleBooleanProperty;
-import javafx.beans.property.SimpleObjectProperty;
 import javafx.css.PseudoClass;
 import javafx.scene.control.Button;
 import javafx.scene.control.Tooltip;
@@ -24,6 +24,7 @@
 import javafx.scene.input.TransferMode;
 
 import java.util.Collections;
+import java.util.Optional;
 import java.util.Set;
 import java.util.stream.Collectors;
 
@@ -46,8 +47,10 @@ public class SocketHandleView extends Button {
      * connection to be made.
      */
     @Singleton
-    protected static final class DragService {
-        private final ObjectProperty<Socket> socket = new SimpleObjectProperty<>(this, "socket");
+    protected static final class SocketDragService extends DragService<Socket> {
+        public SocketDragService() {
+            super("socket");
+        }
     }
 
     final private BooleanProperty connectingProperty = new SimpleBooleanProperty(this, "connecting", false);
@@ -61,7 +64,7 @@ public interface Factory {
     SocketHandleView(EventBus eventBus,
                      Pipeline pipeline,
                      Connection.Factory<Object> connectionFactory,
-                     DragService dragService,
+                     SocketDragService socketDragService,
                      @Assisted Socket socket) {
         this.eventBus = eventBus;
         this.socket = socket;
@@ -97,27 +100,27 @@ public interface Factory {
             mouseEvent.consume();
 
             this.connectingProperty.set(true);
-            dragService.socket.setValue(this.socket);
+            socketDragService.beginDrag(this.socket);
         });
 
         // Remove the "connecting" property (which changes the appearance of the handle) when the user moves the cursor
         // out of the socket handle or completes the drag.  If the user moves the cursor away, it only disables the
         // connecting property if it's not the socket that the user started dragging from, since that one is supposed
         // to be dragged away.
         this.setOnDragExited(dragEvent -> {
-            Socket<?> other = dragService.socket.getValue();
-            if (other != null) this.connectingProperty.set(this.socket == other);
+            socketDragService.getValue().ifPresent( other -> {
+                this.connectingProperty.set(this.socket == other);
+            });
         });
 
         this.setOnDragDone(dragEvent -> {
             this.connectingProperty.set(false);
-            dragService.socket.setValue(null);
+            socketDragService.completeDrag();
         });
 
         // When the user drops the connection onto another socket, add a new connection.
         this.setOnDragDropped(dragEvent -> {
-            Socket<?> other = dragService.socket.getValue();
-            if (other != null) {
+            socketDragService.getValue().ifPresent(other -> {
                 InputSocket inputSocket;
                 OutputSocket outputSocket;
 
@@ -139,23 +142,24 @@ public interface Factory {
                 }
                 final Connection connection = connectionFactory.create(outputSocket, inputSocket);
                 eventBus.post(new ConnectionAddedEvent(connection));
-            }
+            });
         });
 
         // Accept a drag event if it's possible to connect the two sockets
         this.setOnDragOver(dragEvent -> {
-            Socket<?> other = dragService.socket.getValue();
-            if (other != null && pipeline.canConnect(this.socket, other)) {
-                dragEvent.acceptTransferModes(TransferMode.ANY);
-                this.connectingProperty.set(true);
-            }
+            socketDragService.getValue().ifPresent(other -> {
+                if (pipeline.canConnect(this.socket, other)) {
+                    dragEvent.acceptTransferModes(TransferMode.ANY);
+                    this.connectingProperty.set(true);
+                }
+            });
         });
 
         // While dragging, disable any socket that we can't drag onto, providing visual feedback to the user about
         // what can be connected.
-        dragService.socket.addListener(observable -> {
-            Socket<?> other = dragService.socket.getValue();
-            pseudoClassStateChanged(DISABLED_PSEUDO_CLASS, other != null && !pipeline.canConnect(socket, other));
+        socketDragService.getDragProperty().addListener(observable -> {
+            Optional<Socket> other = socketDragService.getValue();
+            pseudoClassStateChanged(DISABLED_PSEUDO_CLASS, other.isPresent() && !pipeline.canConnect(socket, other.get()));
         });
     }
 
diff --git a/ui/src/main/resources/edu/wpi/grip/ui/MainWindow.fxml b/ui/src/main/resources/edu/wpi/grip/ui/MainWindow.fxml
@@ -139,7 +139,7 @@
                     <fx:include source="preview/Previews.fxml"/>
                     <fx:include source="Palette.fxml"/>
                 </SplitPane>
-                <ScrollPane fx:id="bottomPane">
+                <ScrollPane fx:id="bottomPane" fitToHeight="true" fitToWidth="true">
                     <fx:include source="pipeline/Pipeline.fxml" fx:id="pipelineView"/>
                 </ScrollPane>
             </items>
diff --git a/ui/src/main/resources/edu/wpi/grip/ui/pipeline/Pipeline.fxml b/ui/src/main/resources/edu/wpi/grip/ui/pipeline/Pipeline.fxml
@@ -1,27 +1,30 @@
 <?xml version="1.0" encoding="UTF-8"?>
 
+<?import java.lang.*?>
+<?import javafx.scene.*?>
+<?import javafx.scene.control.*?>
+<?import javafx.scene.shape.*?>
 <?import javafx.scene.control.Label?>
 <?import javafx.scene.control.Separator?>
 <?import javafx.scene.Group?>
 <?import javafx.scene.layout.*?>
 <?import javafx.scene.shape.Rectangle?>
-<StackPane maxWidth="Infinity" maxHeight="Infinity" fx:id="root"
-           fx:controller="edu.wpi.grip.ui.pipeline.PipelineController"
-           styleClass="pipeline" xmlns:fx="http://javafx.com/fxml/1">
+
+<StackPane fx:id="root" maxHeight="Infinity" maxWidth="Infinity" styleClass="pipeline" xmlns="http://javafx.com/javafx/8.0.40" xmlns:fx="http://javafx.com/fxml/1" fx:controller="edu.wpi.grip.ui.pipeline.PipelineController">
     <children>
-        <HBox>
-            <VBox fillWidth="true">
-                <Label styleClass="pane-title" text="Sources" maxWidth="Infinity"/>
-                <Separator orientation="HORIZONTAL"/>
-                <Pane fx:id="addSourcePane"/>
-                <VBox fx:id="sourcesBox" styleClass="sources"/>
+        <HBox maxWidth="1.7976931348623157E308">
+            <VBox fillWidth="true" maxWidth="1.7976931348623157E308">
+                <Label maxWidth="Infinity" styleClass="pane-title" text="Sources" />
+                <Separator orientation="HORIZONTAL" />
+                <Pane fx:id="addSourcePane" />
+                <VBox fx:id="sourcesBox" styleClass="sources" />
             </VBox>
-            <Separator orientation="VERTICAL"/>
-            <HBox fx:id="stepBox" styleClass="steps" fillHeight="false"/>
+            <Separator orientation="VERTICAL" />
+            <HBox fx:id="stepBox" fillHeight="false" maxWidth="1.7976931348623157E308" styleClass="steps" HBox.hgrow="ALWAYS" />
         </HBox>
         <Group fx:id="connections" mouseTransparent="true">
             <StackPane.alignment>TOP_LEFT</StackPane.alignment>
-            <Rectangle x="0" y="0" width="1" height="1" opacity="0"/>
+            <Rectangle height="1" opacity="0" width="1" x="0" y="0" />
         </Group>
     </children>
 </StackPane>
diff --git a/ui/src/test/java/edu/wpi/grip/ui/pipeline/OutputSocketControllerTest.java b/ui/src/test/java/edu/wpi/grip/ui/pipeline/OutputSocketControllerTest.java
@@ -34,7 +34,7 @@ public void start(Stage stage) {
         initiallyPreviewedOutputSocket = new InitiallyPreviewedOutputSocket("Initially previewed");
 
         final SocketHandleView.Factory socketHandleFactory
-                = socket -> new SocketHandleView(new EventBus(), null, null, new SocketHandleView.DragService(), socket);
+                = socket -> new SocketHandleView(new EventBus(), null, null, new SocketHandleView.SocketDragService(), socket);
         defaultOutputSocketController =
                 new OutputSocketController(socketHandleFactory, outputSocket);
         initiallyPreviewedOutputSocketController =
