Class goog.fx.AbstractDragDrop

Add possible drop target for current drag operation.

Add item to drag object.

Makes drag and drop aware of a target container that could scroll mid drag.

Associate drop target with drag element.

Called after a drag operation has finished.

Calculate the outer bounds (the region all targets are inside).

Creates copy of node being dragged.

Event handler for containers scrolling.

Creates an element for the item being dragged.

Creates the Dragger for the drag element.

Called once a drag operation has finished. Removes event listeners and elements.

Unattach listeners from this object. Classes that extend EventTarget may need to override this method in order to remove references to DOM Elements and additional listeners, it should be something like this:

MyClass.prototype.disposeInternal = function() {
MyClass.superClass_.disposeInternal.call(this);
// Dispose logic for MyClass
};

Called when removing an item. Removes event listeners and classes.

Cleans up the scrollable container listeners.

Event handler that's used to stop drag. Fires a drop event if over a valid target.

Returns the position for the drag element.

Returns the dragger object.

Gets the scroll distance as a coordinate object, using the window of the current drag element's dom.

Returns the target for a given cursor position.

Initialize drag and drop functionality for sources/targets already added. Sources/targets added after init has been called will initialize themselves one by one.

Initializes a single item.

Sets up listeners for the scrollable containers that keep track of their scroll positions.

Whether the control has been initialized.

Checks whatever a given point is inside a given box.

Creates a dummy target for the given cursor position. The assumption is to create as big dummy target box as possible, the only constraints are: - The dummy targert box cannot overlap any of real target boxes. - The dummy target has to contain a point with current mouse coordinates. NOTE: For performance reasons the box construction algorithm is kept simple and it is not optimal (see example below). Currently it is O(n) in regard to the number of real drop target boxes, but its result depends on the order of those boxes being processed (the order in which they're added to the targetList_ collection). The algorithm. a) Assumptions - Mouse pointer is in the bounding box of real target boxes. - None of the boxes have negative coordinate values. - Mouse pointer is not contained by any of "real target" boxes. b) Outline - Initialize the fake target to the bounding box of real targets. - For each real target box - clip the fake target box so it does not contain that target box, but does contain the mouse pointer. -- Project the real target box, mouse pointer and fake target box onto both axes and calculate the clipping coordinates. -- Only one coordinate is used to clip the fake target box to keep the fake target as big as possible. -- If the projection of the real target box contains the mouse pointer, clipping for a given axis is not possible. -- If both clippings are possible, the clipping more distant from the mouse pointer is selected to keep bigger fake target area. - Save the created fake target only if it has a big enough area. c) Example

Input:           Algorithm created box:        Maximum box:
+---------------------+ +---------------------+ +---------------------+
| B1      |        B2 | | B1               B2 | | B1               B2 |
|         |           | |   +-------------+   | |+-------------------+|
|---------x-----------| |   |             |   | ||                   ||
|         |           | |   |             |   | ||                   ||
|         |           | |   |             |   | ||                   ||
|         |           | |   |             |   | ||                   ||
|         |           | |   |             |   | ||                   ||
|         |           | |   +-------------+   | |+-------------------+|
| B4      |        B3 | | B4               B3 | | B4               B3 |
+---------------------+ +---------------------+ +---------------------+

Starts a drag event for an item if the mouse button stays pressed and the cursor moves a few pixels. Allows dragging of items without first having to register them with addItem.

Event handler for drag events. Determines the active drop target, if any, and fires dragover and dragout events appropriately.

Recalculates the geometry of this source's drag targets. Call this if the position or visibility of a drag target has changed during a drag, or if targets are added or removed. TODO(user): this is an expensive operation; more efficient APIs may be necessary.

Recalculates the current scroll positions of scrollable containers and allocates targets. Call this if the position of a container changed or if targets are added or removed.

Removes all scrollable containers.

Removes all items.

Set class to add to source elements being dragged.

Sets the SCROLL event target to make drag element follow scrolling.

Set class to add to source elements.

Set a function that provides subtargets. A subtargeting function returns an arbitrary identifier for each subtarget of an element. DnD code will generate additional drag over / out events when switching from subtarget to subtarget. This is useful for instance if you are interested if you are on the top half or the bottom half of the element. The provided function will be given the DragDropItem, box, x, y box is the current window coordinates occupied by element x, y is the mouse position in window coordinates

Set class to add to target elements.

Event handler that's used to start drag.

Event handler for suppressing selectstart events. Selecting should be disabled while dragging.