easyui-draganddrop/lib/rubbishBin.js

Drag and drop elements including a file explorer and a rubbish bin.

'use strict';

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var easyui = require('easyui'),
    Element = easyui.Element;

var DroppableElement = require('./droppableElement');

var RubbishBin = function (_DroppableElement) {
  _inherits(RubbishBin, _DroppableElement);

  function RubbishBin(selector, removeHandler) {
    _classCallCheck(this, RubbishBin);

    var droppableElementMoveHandler = removeHandler; ///

    var _this = _possibleConstructorReturn(this, (RubbishBin.__proto__ || Object.getPrototypeOf(RubbishBin)).call(this, selector, droppableElementMoveHandler));

    _this.close();
    return _this;
  }

  _createClass(RubbishBin, [{
    key: 'getMarkedDirectory',
    value: function getMarkedDirectory() {
      var markedDirectory = null;

      return markedDirectory;
    }
  }, {
    key: 'getDirectoryOverlappingDraggableEntry',
    value: function getDirectoryOverlappingDraggableEntry(draggableEntry) {
      var directoryOverlappingDraggableEntry = null; ///

      return directoryOverlappingDraggableEntry;
    }
  }, {
    key: 'addMarker',
    value: function addMarker(draggableEntry, directoryOverlappingDraggableEntry) {
      this.open();
    }
  }, {
    key: 'removeMarker',
    value: function removeMarker() {
      this.close();
    }
  }, {
    key: 'isMarked',
    value: function isMarked() {
      var open = this.isOpen(),
          marked = open; ///

      return marked;
    }
  }, {
    key: 'isToBeMarked',
    value: function isToBeMarked(draggableEntry) {
      var bounds = this.getBounds(),
          draggableEntryCollapsedBounds = draggableEntry.getCollapsedBounds(),
          overlappingDraggableEntryCollapsedBounds = bounds.areOverlapping(draggableEntryCollapsedBounds),
          toBeMarked = overlappingDraggableEntryCollapsedBounds; ///

      return toBeMarked;
    }
  }, {
    key: 'dragging',
    value: function dragging(draggableEntry, explorer) {
      var marked = this.isMarked();

      if (marked) {
        var toBeMarked = this.isToBeMarked(draggableEntry);

        if (!toBeMarked) {
          var droppableElementToBeMarked = this.getDroppableElementToBeMarked(draggableEntry);

          if (droppableElementToBeMarked !== null) {
            var directoryOverlappingDraggableEntry = droppableElementToBeMarked.getDirectoryOverlappingDraggableEntry(draggableEntry);

            droppableElementToBeMarked.addMarker(draggableEntry, directoryOverlappingDraggableEntry);
          } else {
            explorer.addMarkerInPlace(draggableEntry);
          }

          this.removeMarker();
        }
      }
    }
  }, {
    key: 'moveDirectory',
    value: function moveDirectory(directory, sourceDirectoryPath, movedDirectoryPath) {
      if (movedDirectoryPath === null) {
        var explorer = directory.getExplorer(),
            directoryPath = sourceDirectoryPath; ///

        explorer.removeDirectory(directoryPath);
      }
    }
  }, {
    key: 'moveFile',
    value: function moveFile(file, sourceFilePath, movedFilePath) {
      if (movedFilePath === null) {
        var explorer = file.getExplorer(),
            filePath = sourceFilePath; ///

        explorer.removeFile(filePath);
      }
    }
  }, {
    key: 'open',
    value: function open() {
      this.addClass('open');
    }
  }, {
    key: 'close',
    value: function close() {
      this.removeClass('open');
    }
  }, {
    key: 'isOpen',
    value: function isOpen() {
      var open = this.hasClass('open');

      return open;
    }
  }, {
    key: 'pathMapsFromDraggableEntries',
    value: function pathMapsFromDraggableEntries(draggableEntries, sourcePath, targetPath) {
      var pathMaps = draggableEntries.map(function (draggableEntry) {
        var pathMap = {},
            draggableEntryPath = draggableEntry.getPath(),
            sourceDraggableEntryPath = draggableEntryPath,
            ///
        targetDraggableEntryPath = null;

        pathMap[sourceDraggableEntryPath] = targetDraggableEntryPath;

        return pathMap;
      });

      return pathMaps;
    }
  }], [{
    key: 'clone',
    value: function clone(selector, removeHandler) {
      return Element.clone(RubbishBin, selector, removeHandler);
    }
  }, {
    key: 'fromHTML',
    value: function fromHTML(html, removeHandler) {
      return Element.fromHTML(RubbishBin, html, removeHandler);
    }
  }]);

  return RubbishBin;
}(DroppableElement);

module.exports = RubbishBin;
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../es6/rubbishBin.js"],"names":["easyui","require","Element","DroppableElement","RubbishBin","selector","removeHandler","droppableElementMoveHandler","close","markedDirectory","draggableEntry","directoryOverlappingDraggableEntry","open","isOpen","marked","bounds","getBounds","draggableEntryCollapsedBounds","getCollapsedBounds","overlappingDraggableEntryCollapsedBounds","areOverlapping","toBeMarked","explorer","isMarked","isToBeMarked","droppableElementToBeMarked","getDroppableElementToBeMarked","getDirectoryOverlappingDraggableEntry","addMarker","addMarkerInPlace","removeMarker","directory","sourceDirectoryPath","movedDirectoryPath","getExplorer","directoryPath","removeDirectory","file","sourceFilePath","movedFilePath","filePath","removeFile","addClass","removeClass","hasClass","draggableEntries","sourcePath","targetPath","pathMaps","map","pathMap","draggableEntryPath","getPath","sourceDraggableEntryPath","targetDraggableEntryPath","clone","html","fromHTML","module","exports"],"mappings":"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","file":"rubbishBin.js","sourcesContent":["'use strict';\n\nconst easyui = require('easyui'),\n      Element = easyui.Element;\n\nconst DroppableElement = require('./droppableElement');\n\nclass RubbishBin extends DroppableElement {\n  constructor(selector, removeHandler) {\n    const droppableElementMoveHandler = removeHandler;  ///\n    \n    super(selector, droppableElementMoveHandler);\n\n    this.close();\n  }\n\n  getMarkedDirectory() {\n    const markedDirectory = null;\n    \n    return markedDirectory;\n  }\n\n  getDirectoryOverlappingDraggableEntry(draggableEntry) {\n    const directoryOverlappingDraggableEntry = null; ///\n\n    return directoryOverlappingDraggableEntry;\n  }\n\n  addMarker(draggableEntry, directoryOverlappingDraggableEntry) {\n    this.open();\n  }\n\n  removeMarker() {\n    this.close();\n  }\n\n  isMarked() {\n    const open = this.isOpen(),\n          marked = open;  ///\n    \n    return marked;\n  }\n\n  isToBeMarked(draggableEntry) {\n    const bounds = this.getBounds(),\n          draggableEntryCollapsedBounds = draggableEntry.getCollapsedBounds(),\n          overlappingDraggableEntryCollapsedBounds = bounds.areOverlapping(draggableEntryCollapsedBounds),\n          toBeMarked = overlappingDraggableEntryCollapsedBounds; ///\n\n    return toBeMarked;\n  }\n  \n  dragging(draggableEntry, explorer) {\n    const marked = this.isMarked();\n\n    if (marked) {\n      const toBeMarked = this.isToBeMarked(draggableEntry);\n\n      if (!toBeMarked) {\n        const droppableElementToBeMarked = this.getDroppableElementToBeMarked(draggableEntry);\n\n        if (droppableElementToBeMarked !== null) {\n          const directoryOverlappingDraggableEntry = droppableElementToBeMarked.getDirectoryOverlappingDraggableEntry(draggableEntry);\n\n          droppableElementToBeMarked.addMarker(draggableEntry, directoryOverlappingDraggableEntry);\n        } else {\n          explorer.addMarkerInPlace(draggableEntry);\n        }\n\n        this.removeMarker();\n      }\n    }\n  }\n\n  moveDirectory(directory, sourceDirectoryPath, movedDirectoryPath) {\n    if (movedDirectoryPath === null) {\n      const explorer = directory.getExplorer(),\n            directoryPath = sourceDirectoryPath;  ///\n\n      explorer.removeDirectory(directoryPath);\n    }\n  }\n\n  moveFile(file, sourceFilePath, movedFilePath) {\n    if (movedFilePath === null) {\n      const explorer = file.getExplorer(),\n            filePath = sourceFilePath;  ///\n\n      explorer.removeFile(filePath);\n    }\n  }\n\n  open() {\n    this.addClass('open');\n  }\n\n  close() {\n    this.removeClass('open');\n  }\n\n  isOpen() {\n    const open = this.hasClass('open');\n    \n    return open;\n  }\n\n  pathMapsFromDraggableEntries(draggableEntries, sourcePath, targetPath) {\n    const pathMaps = draggableEntries.map(function(draggableEntry) {\n      const pathMap = {},\n            draggableEntryPath = draggableEntry.getPath(),\n            sourceDraggableEntryPath = draggableEntryPath,  ///\n            targetDraggableEntryPath = null;\n\n      pathMap[sourceDraggableEntryPath] = targetDraggableEntryPath;\n\n      return pathMap;\n    });\n\n    return pathMaps;\n  }\n\n  static clone(selector, removeHandler) {\n    return Element.clone(RubbishBin, selector, removeHandler);\n  }\n\n  static fromHTML(html, removeHandler) {\n    return Element.fromHTML(RubbishBin, html, removeHandler);\n  }\n}\n\nmodule.exports = RubbishBin;\n"]}