@qooxdoo/framework 7.9.2 → 8.0.0-beta.2

package/source/class/qx/event/handler/DragDrop.js

@@ -147,45 +147,35 @@ qx.Class.define("qx.event.handler.DragDrop", {
     // interface implementation
     registerEvent(target, type, capture) {
       // Nothing needs to be done here
-    },
-
-    // interface implementation
+    }, // interface implementation
     unregisterEvent(target, type, capture) {
       // Nothing needs to be done here
     },
-
     /*
     ---------------------------------------------------------------------------
-      PUBLIC METHODS
+    PUBLIC METHODS
     ---------------------------------------------------------------------------
-    */
-
-    /**
+    */ /**
      * Registers a supported type
      *
      * @param type {String} The type to add
-     */
-    addType(type) {
+     */ addType(type) {
       this.__types[type] = true;
     },
-
     /**
      * Registers a supported action. One of <code>move</code>,
      * <code>copy</code> or <code>alias</code>.
      *
      * @param action {String} The action to add
-     */
-    addAction(action) {
+     */ addAction(action) {
       this.__actions[action] = true;
     },
-
     /**
      * Whether the current drag target supports the given type
      *
      * @param type {String} Any type
      * @return {Boolean} Whether the type is supported
-     */
-    supportsType(type) {
+     */ supportsType(type) {
       return !!this.__types[type];
     },
 
@@ -214,12 +204,8 @@ qx.Class.define("qx.event.handler.DragDrop", {
      * on the drop target. This method fires a <code>droprequest</code> at
      * the drag target which should be answered by calls to {@link #addData}.
      *
-     * Note that this is a synchronous method and if any of the drag and drop
-     * events handlers are implemented using Promises, this may fail; @see
-     * `getDataAsync`.
-     *
      * @param type {String} Any supported type
-     * @return {var} The result data in a promise
+     * @return {var} The result data
      */
     getData(type) {
       if (!this.__validDrop || !this.__dropTarget) {
@@ -238,7 +224,6 @@ qx.Class.define("qx.event.handler.DragDrop", {
           "droprequest",
           this.__dragTarget,
           this.__dropTarget,
-          false,
           false
         );
       }
@@ -252,50 +237,6 @@ qx.Class.define("qx.event.handler.DragDrop", {
       return this.__cache[type] || null;
     },
 
-    /**
-     * Returns the data of the given type during the <code>drop</code> event
-     * on the drop target. This method fires a <code>droprequest</code> at
-     * the drag target which should be answered by calls to {@link #addData}.
-     *
-     * @param type {String} Any supported type
-     * @return {qx.Promise} The result data in a promise
-     */
-    getDataAsync(type) {
-      if (!this.__validDrop || !this.__dropTarget) {
-        throw new Error(
-          "This method must not be used outside the drop event listener!"
-        );
-      }
-
-      if (!this.__types[type]) {
-        throw new Error("Unsupported data type: " + type + "!");
-      }
-
-      var tracker = {};
-      var self = this;
-      if (!this.__cache[type]) {
-        qx.event.Utils.then(tracker, function () {
-          self.__currentType = type;
-          return self.__fireEvent(
-            "droprequest",
-            self.__dragTarget,
-            self.__dropTarget,
-            false
-          );
-        });
-      }
-
-      return qx.event.Utils.then(tracker, function () {
-        if (!this.__cache[type]) {
-          throw new Error(
-            "Please use a droprequest listener to the drag source to fill the manager with data!"
-          );
-        }
-
-        return this.__cache[type] || null;
-      });
-    },
-
     /**
      * Returns the currently selected action (by user keyboard modifiers)
      *
@@ -307,28 +248,6 @@ qx.Class.define("qx.event.handler.DragDrop", {
       return this.__currentAction;
     },
 
-    /**
-     * Returns the currently selected action (by user keyboard modifiers)
-     *
-     * @return {qx.Promise|String} One of <code>move</code>, <code>copy</code> or
-     *    <code>alias</code>
-     */
-    getCurrentActionAsync: qx.core.Environment.select("qx.promise", {
-      true() {
-        var self = this;
-
-        return qx.Promise.resolve(self.__detectAction()).then(function () {
-          return self.__currentAction;
-        });
-      },
-      false() {
-        throw new Error(
-          this.classname +
-            ".getCurrentActionAsync not supported because qx.promise==false"
-        );
-      }
-    }),
-
     /**
      * Returns the widget which has been the target of the drag start.
      * @return {qx.ui.core.Widget} The widget on which the drag started.
@@ -386,16 +305,10 @@ qx.Class.define("qx.event.handler.DragDrop", {
      * Detects the current action and stores it under the private
      * field <code>__currentAction</code>. Also fires the event
      * <code>dragchange</code> on every modification.
-     *
-     * @return {qx.Promise|null}
      */
     __detectAction() {
       if (this.__dragTarget == null) {
-        if (qx.core.Environment.get("qx.promise")) {
-          return qx.Promise.reject();
-        } else {
-          return null;
-        }
+        return;
       }
 
       var actions = this.__actions;
@@ -422,44 +335,31 @@ qx.Class.define("qx.event.handler.DragDrop", {
         }
       }
 
-      var self = this;
-      var tracker = {};
       var old = this.__currentAction;
       if (current != old) {
         if (this.__dropTarget) {
-          qx.event.Utils.catch(function () {
-            self.__validAction = false;
+          this.__currentAction = current;
+          this.__validAction = this.__fireEvent(
+            "dragchange",
+            this.__dropTarget,
+            this.__dragTarget,
+            true
+          );
+          if (!this.__validAction) {
             current = null;
-          });
-          qx.event.Utils.then(tracker, function () {
-            self.__currentAction = current;
-            return self.__fireEvent(
-              "dragchange",
-              self.__dropTarget,
-              self.__dragTarget,
-              true
-            );
-          });
-          qx.event.Utils.then(tracker, function (validAction) {
-            self.__validAction = validAction;
-            if (!validAction) {
-              current = null;
-            }
-          });
+          }
         }
-      }
 
-      return qx.event.Utils.then(tracker, function () {
         if (current != old) {
-          self.__currentAction = current;
-          return self.__fireEvent(
+          this.__currentAction = current;
+          this.__fireEvent(
             "dragchange",
-            self.__dragTarget,
-            self.__dropTarget,
+            this.__dragTarget,
+            this.__dropTarget,
             false
           );
         }
-      });
+      }
     },
 
     /**
@@ -472,10 +372,10 @@ qx.Class.define("qx.event.handler.DragDrop", {
      *    depending on the drag event
      * @param cancelable {Boolean} Whether the event is cancelable
      * @param original {qx.event.type.Pointer} Original pointer event
-     * @return {qx.Promise|Boolean} <code>true</code> if the event's default behavior was
+     * @return {Boolean} <code>true</code> if the event's default behavior was
      * not prevented
      */
-    __fireEvent(type, target, relatedTarget, cancelable, original, async) {
+    __fireEvent(type, target, relatedTarget, cancelable, original) {
       var Registration = qx.event.Registration;
       var dragEvent = Registration.createEvent(type, qx.event.type.Drag, [
         cancelable,
@@ -486,27 +386,7 @@ qx.Class.define("qx.event.handler.DragDrop", {
         dragEvent.setRelatedTarget(relatedTarget);
       }
 
-      var result = Registration.dispatchEvent(target, dragEvent);
-      if (qx.core.Environment.get("qx.promise")) {
-        if (async === undefined || async) {
-          return qx.Promise.resolve(result).then(function () {
-            return !dragEvent.getDefaultPrevented();
-          });
-        } else {
-          if (qx.core.Environment.get("qx.debug")) {
-            if (qx.Promise.isPromise(result)) {
-              this.error(
-                'DragDrop event "' +
-                  type +
-                  '" returned a promise but a synchronous event was required, drag and drop may not work as expected (consider using getDataAsync)'
-              );
-            }
-          }
-          return result;
-        }
-      } else {
-        return result;
-      }
+      return Registration.dispatchEvent(target, dragEvent);
     },
 
     /**
@@ -551,12 +431,8 @@ qx.Class.define("qx.event.handler.DragDrop", {
 
     /**
      * Cleans up a drag&drop session when <code>dragstart</code> was fired before.
-     *
-     * @return {qx.Promise?} promise, if one was created by event handlers
      */
     clearSession() {
-      //this.debug("clearSession");
-
       // Deregister from root events
       this.__manager.removeListener(
         this.__root,
@@ -564,7 +440,6 @@ qx.Class.define("qx.event.handler.DragDrop", {
         this._onPointermove,
         this
       );
-
       this.__manager.removeListener(
         this.__root,
         "pointerup",
@@ -580,7 +455,6 @@ qx.Class.define("qx.event.handler.DragDrop", {
         this,
         true
       );
-
       this.__manager.removeListener(
         this.__root,
         "keyup",
@@ -588,7 +462,6 @@ qx.Class.define("qx.event.handler.DragDrop", {
         this,
         true
       );
-
       this.__manager.removeListener(
         this.__root,
         "keypress",
@@ -596,7 +469,6 @@ qx.Class.define("qx.event.handler.DragDrop", {
         this,
         true
       );
-
       this.__manager.removeListener(
         this.__root,
         "roll",
@@ -605,37 +477,29 @@ qx.Class.define("qx.event.handler.DragDrop", {
         true
       );
 
-      var tracker = {};
-      var self = this;
-
       // Fire dragend event
       if (this.__dragTarget) {
-        qx.event.Utils.then(tracker, function () {
-          return self.__fireEvent(
-            "dragend",
-            self.__dragTarget,
-            self.__dropTarget,
-            false
-          );
-        });
+        this.__fireEvent(
+          "dragend",
+          this.__dragTarget,
+          this.__dropTarget,
+          false
+        );
       }
 
-      return qx.event.Utils.then(tracker, function () {
-        // Cleanup
-        self.__validDrop = false;
-        self.__dropTarget = null;
-        if (self.__dragTargetWidget) {
-          self.__dragTargetWidget.removeState("drag");
-          self.__dragTargetWidget = null;
-        }
+      // Cleanup
+      this.__validDrop = false;
+      this.__dropTarget = null;
+      if (this.__dragTargetWidget) {
+        this.__dragTargetWidget.removeState("drag");
+        this.__dragTargetWidget = null;
+      }
 
-        // Clear init
-        //self.debug("Clearing drag target");
-        self.__dragTarget = null;
-        self.__sessionActive = false;
-        self.__startConfig = null;
-        self.__rebuildStructures();
-      });
+      // Clear init
+      this.__dragTarget = null;
+      this.__sessionActive = false;
+      this.__startConfig = null;
+      this.__rebuildStructures();
     },
 
     /*
@@ -656,7 +520,7 @@ qx.Class.define("qx.event.handler.DragDrop", {
       }
       // prevent scrolling
       this.__manager.addListener(this.__root, "roll", this._onRoll, this, true);
-      return this._start(e);
+      this._start(e);
     },
 
     /**
@@ -683,13 +547,11 @@ qx.Class.define("qx.event.handler.DragDrop", {
       var draggable = this.__findDraggable(target);
       if (draggable) {
         // This is the source target
-        //this.debug("Setting dragtarget = " + draggable);
         this.__dragTarget = draggable;
 
         var widgetOriginalTarget = qx.ui.core.Widget.getWidgetByElement(
           this.__startConfig.original
         );
-
         while (widgetOriginalTarget && widgetOriginalTarget.isAnonymous()) {
           widgetOriginalTarget = widgetOriginalTarget.getLayoutParent();
         }
@@ -699,52 +561,42 @@ qx.Class.define("qx.event.handler.DragDrop", {
         }
 
         // fire cancelable dragstart
-        var self = this;
-        var tracker = {};
-        qx.event.Utils.catch(function () {
-          //self.debug("dragstart FAILED, setting __sessionActive=false");
-          self.__sessionActive = false;
-        });
-        qx.event.Utils.then(tracker, function () {
-          return self.__fireEvent(
+        if (
+          !this.__fireEvent(
             "dragstart",
-            self.__dragTarget,
-            self.__dropTarget,
+            this.__dragTarget,
+            this.__dropTarget,
             true,
             e
-          );
-        });
-        return qx.event.Utils.then(tracker, function (validAction) {
-          if (!validAction) {
-            return;
-          }
-          //self.debug("dragstart ok, setting __sessionActive=true")
-          self.__manager.addListener(
-            self.__root,
-            "keydown",
-            self._onKeyDown,
-            self,
-            true
-          );
-
-          self.__manager.addListener(
-            self.__root,
-            "keyup",
-            self._onKeyUp,
-            self,
-            true
-          );
+          )
+        ) {
+          return false;
+        }
 
-          self.__manager.addListener(
-            self.__root,
-            "keypress",
-            self._onKeyPress,
-            self,
-            true
-          );
+        this.__manager.addListener(
+          this.__root,
+          "keydown",
+          this._onKeyDown,
+          this,
+          true
+        );
+        this.__manager.addListener(
+          this.__root,
+          "keyup",
+          this._onKeyUp,
+          this,
+          true
+        );
+        this.__manager.addListener(
+          this.__root,
+          "keypress",
+          this._onKeyPress,
+          this,
+          true
+        );
+        this.__sessionActive = true;
 
-          self.__sessionActive = true;
-        });
+        return true;
       }
     },
 
@@ -767,7 +619,6 @@ qx.Class.define("qx.event.handler.DragDrop", {
           this._onPointermove,
           this
         );
-
         this.__manager.addListener(
           this.__root,
           "pointerup",
@@ -789,159 +640,112 @@ qx.Class.define("qx.event.handler.DragDrop", {
         return;
       }
 
-      //this.debug("_onPointermove: start");
-
-      var self = this;
-      var tracker = {};
-
-      qx.event.Utils.catch(function () {
-        return self.clearSession();
-      });
-
       // start the drag session for mouse
-      if (!self.__sessionActive && e.getPointerType() == "mouse") {
-        var delta = self._getDelta(e);
+      if (!this.__sessionActive && e.getPointerType() == "mouse") {
+        var delta = this._getDelta(e);
         // if the mouse moved a bit in any direction
         var distance = qx.event.handler.DragDrop.MIN_DRAG_DISTANCE;
         if (
           delta &&
           (Math.abs(delta.x) > distance || Math.abs(delta.y) > distance)
         ) {
-          //self.debug("_onPointermove: outside min drag distance");
-          qx.event.Utils.then(tracker, function () {
-            return self._start(e);
-          });
+          if (!this._start(e)) {
+            this.clearSession();
+            return;
+          }
         }
       }
 
-      return qx.event.Utils.then(tracker, function () {
-        // check if the session has been activated
-        if (!self.__sessionActive) {
-          //self.debug("not active");
-          return;
-        }
+      // check if the session has been activated
+      if (!this.__sessionActive) {
+        return;
+      }
+
+      if (
+        !this.__fireEvent("drag", this.__dragTarget, this.__dropTarget, true, e)
+      ) {
+        this.clearSession();
+      }
+
+      // find current hovered droppable
+      var el = e.getTarget();
+      if (this.__startConfig.target === el) {
+        // on touch devices the native events return wrong elements as target (its always the element where the dragging started)
+        el = e
+          .getNativeEvent()
+          .view.document.elementFromPoint(
+            e.getDocumentLeft(),
+            e.getDocumentTop()
+          );
+      }
+      var cursor = this.getCursor();
+      if (!cursor) {
+        cursor = qx.ui.core.DragDropCursor.getInstance();
+      }
+      var cursorEl = cursor.getContentElement().getDomElement();
+      if (cursorEl && (el === cursorEl || cursorEl.contains(el))) {
+        var display = qx.bom.element.Style.get(cursorEl, "display");
+        // get the cursor out of the way
+        qx.bom.element.Style.set(cursorEl, "display", "none");
+        el = e
+          .getNativeEvent()
+          .view.document.elementFromPoint(
+            e.getDocumentLeft(),
+            e.getDocumentTop()
+          );
+        qx.bom.element.Style.set(cursorEl, "display", display);
+      }
+
+      if (el !== cursorEl) {
+        var droppable = this.__findDroppable(el);
+
+        // new drop target detected
+        if (droppable && droppable != this.__dropTarget) {
+          // fire dragleave for previous drop target
+          if (this.__dropTarget) {
+            this.__fireEvent(
+              "dragleave",
+              this.__dropTarget,
+              this.__dragTarget,
+              false,
+              e
+            );
+          }
+
+          this.__validDrop = true; // initial value should be true
+          this.__dropTarget = droppable;
 
-        var tracker = {};
-        qx.event.Utils.then(tracker, function () {
-          //self.debug("active, firing drag");
-          return self.__fireEvent(
-            "drag",
-            self.__dragTarget,
-            self.__dropTarget,
+          this.__validDrop = this.__fireEvent(
+            "dragover",
+            droppable,
+            this.__dragTarget,
             true,
             e
           );
-        });
-        qx.event.Utils.then(tracker, function (validAction) {
-          if (!validAction) {
-            this.clearSession();
-          }
+        }
 
-          //self.debug("drag");
-          // find current hovered droppable
-          var el = e.getTarget();
-          if (self.__startConfig.target === el) {
-            // on touch devices the native events return wrong elements as target (its always the element where the dragging started)
-            el = e
-              .getNativeEvent()
-              .view.document.elementFromPoint(
-                e.getDocumentLeft(),
-                e.getDocumentTop()
-              );
-          }
-          var cursor = self.getCursor();
-          if (!cursor) {
-            cursor = qx.ui.core.DragDropCursor.getInstance();
-          }
-          var cursorEl = cursor.getContentElement().getDomElement();
-          if (cursorEl && (el === cursorEl || cursorEl.contains(el))) {
-            var display = qx.bom.element.Style.get(cursorEl, "display");
-            // get the cursor out of the way
-            qx.bom.element.Style.set(cursorEl, "display", "none");
-            el = e
-              .getNativeEvent()
-              .view.document.elementFromPoint(
-                e.getDocumentLeft(),
-                e.getDocumentTop()
-              );
-
-            qx.bom.element.Style.set(cursorEl, "display", display);
-          }
+        // only previous drop target
+        else if (!droppable && this.__dropTarget) {
+          this.__fireEvent(
+            "dragleave",
+            this.__dropTarget,
+            this.__dragTarget,
+            false,
+            e
+          );
+          this.__dropTarget = null;
+          this.__validDrop = false;
 
-          if (el !== cursorEl) {
-            var droppable = self.__findDroppable(el);
-
-            // new drop target detected
-            if (droppable && droppable != self.__dropTarget) {
-              var dropLeaveTarget = self.__dropTarget;
-
-              self.__validDrop = true; // initial value should be true
-              self.__dropTarget = droppable;
-
-              var innerTracker = {};
-              qx.event.Utils.catch(innerTracker, function () {
-                self.__dropTarget = null;
-                self.__validDrop = false;
-              });
-
-              // fire dragleave for previous drop target
-              if (dropLeaveTarget) {
-                qx.event.Utils.then(innerTracker, function () {
-                  return self.__fireEvent(
-                    "dragleave",
-                    dropLeaveTarget,
-                    self.__dragTarget,
-                    false,
-                    e
-                  );
-                });
-              }
-
-              qx.event.Utils.then(innerTracker, function () {
-                return self.__fireEvent(
-                  "dragover",
-                  droppable,
-                  self.__dragTarget,
-                  true,
-                  e
-                );
-              });
-
-              return qx.event.Utils.then(innerTracker, function (validDrop) {
-                self.__validDrop = validDrop;
-              });
-            }
-
-            // only previous drop target
-            else if (!droppable && self.__dropTarget) {
-              var innerTracker = {};
-              qx.event.Utils.then(innerTracker, function () {
-                return self.__fireEvent(
-                  "dragleave",
-                  self.__dropTarget,
-                  self.__dragTarget,
-                  false,
-                  e
-                );
-              });
-              return qx.event.Utils.then(innerTracker, function () {
-                self.__dropTarget = null;
-                self.__validDrop = false;
-
-                return self.__detectAction();
-              });
-            }
-          }
-        });
-        return qx.event.Utils.then(tracker, function () {
-          // Reevaluate current action
-          var keys = self.__keys;
-          keys.Control = e.isCtrlPressed();
-          keys.Shift = e.isShiftPressed();
-          keys.Alt = e.isAltPressed();
-          return self.__detectAction();
-        });
-      });
+          qx.event.Timer.once(this.__detectAction, this, 0);
+        }
+      }
+
+      // Reevaluate current action
+      var keys = this.__keys;
+      keys.Control = e.isCtrlPressed();
+      keys.Shift = e.isShiftPressed();
+      keys.Alt = e.isAltPressed();
+      this.__detectAction();
     },
 
     /**
@@ -975,31 +779,24 @@ qx.Class.define("qx.event.handler.DragDrop", {
         return;
       }
 
-      var tracker = {};
-      var self = this;
-
       // Fire drop event in success case
       if (this.__validDrop && this.__validAction) {
-        qx.event.Utils.then(tracker, function () {
-          return self.__fireEvent(
-            "drop",
-            self.__dropTarget,
-            self.__dragTarget,
-            false,
-            e
-          );
-        });
+        this.__fireEvent(
+          "drop",
+          this.__dropTarget,
+          this.__dragTarget,
+          false,
+          e
+        );
       }
 
-      return qx.event.Utils.then(tracker, function () {
-        // Stop event
-        if (e.getTarget() == self.__dragTarget) {
-          e.stopPropagation();
-        }
+      // Stop event
+      if (e.getTarget() == this.__dragTarget) {
+        e.stopPropagation();
+      }
 
-        // Clean up
-        return self.clearSession();
-      });
+      // Clean up
+      this.clearSession();
     },
 
     /**
@@ -1016,7 +813,7 @@ qx.Class.define("qx.event.handler.DragDrop", {
      * @param e {qx.event.type.Event} Event object
      */
     _onWindowBlur(e) {
-      return this.clearSession();
+      this.clearSession();
     },
 
     /**
@@ -1032,7 +829,7 @@ qx.Class.define("qx.event.handler.DragDrop", {
         case "Shift":
           if (!this.__keys[iden]) {
             this.__keys[iden] = true;
-            return this.__detectAction();
+            this.__detectAction();
           }
       }
     },
@@ -1050,7 +847,7 @@ qx.Class.define("qx.event.handler.DragDrop", {
         case "Shift":
           if (this.__keys[iden]) {
             this.__keys[iden] = false;
-            return this.__detectAction();
+            this.__detectAction();
           }
       }
     },
@@ -1064,7 +861,7 @@ qx.Class.define("qx.event.handler.DragDrop", {
       var iden = e.getKeyIdentifier();
       switch (iden) {
         case "Escape":
-          return this.clearSession();
+          this.clearSession();
       }
     }
   },