DragDropGroup (Closure Library API Documentation

Whether the control has been initialized.

Returns:

True if it's been initialized.

code »

isInside(x, y, box) ⇒

Use goog.math.Box.contains. Checks whatever a given point is inside a given box.

Arguments:

x :

Cursor position on the x-axis.

y :

Cursor position on the y-axis.

box :

(goog.math.Box | null)

Box to check position against.

Returns:

Whether the given point is inside box.

code »

maybeCreateDummyTargetForPosition_(x, y) ⇒

(goog.fx.ActiveDropTarget_ | null)

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 target 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. - For targets inside a scrollable container, the box used is the intersection of the scrollable container's box and the target's box. This is because the part of the target that extends outside the scrollable container should not be used in the clipping calculations. 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 |
+---------------------+ +---------------------+ +---------------------+

Arguments:

x :

Cursor position on the x-axis.

y :

Cursor position on the y-axis.

Returns:

(goog.fx.ActiveDropTarget_ | null)

Dummy drop target.

code »

maybeStartDrag(event, item)

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.

Arguments:

event :

(goog.events.BrowserEvent | null)

Mouse down event.

item :

(goog.fx.DragDropItem | null)

Item that's being dragged.

code »

moveDrag_(event)

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

Arguments:

event :

(goog.fx.DragEvent | null)

Drag event.

code »

recalculateDragTargets()

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.

code »

recalculateScrollableContainers()

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.

code »

removeAllScrollableContainers()

Removes all scrollable containers.

code »

removeItems()

Removes all items.

code »

setDragClass(className)

Set class to add to source elements being dragged.

Arguments:

className :

Class to be added.

code »

setScrollTarget(scrollTarget)

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

Arguments:

scrollTarget :

(EventTarget | null)

The element that dispatches SCROLL events.

code »

setSourceClass(className)

Set class to add to source elements.

Arguments:

className :

Class to be added.

code »

setSubtargetFunction(f)

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

Arguments:

f :

(Function | null)

The new subtarget function.

code »

setTargetClass(className)

Set class to add to target elements.

Arguments:

className :

Class to be added.

code »

startDrag(event, item)

Event handler that's used to start drag.

Arguments:

event :

(goog.events.BrowserEvent | null)

Mouse move event.

item :

(goog.fx.DragDropItem | null)

Item that's being dragged.

code »

suppressSelect_(event) ⇒

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

Arguments:

event :

(goog.events.Event | null)

The selectstart event to suppress.

Returns:

Whether to perform default behavior.

code »

Defined in goog.events.EventTarget

addEventListener(type, handler, opt_capture, opt_handlerScope)

Adds an event listener to the event target. The same handler can only be added once per the type. Even if you add the same handler multiple times using the same type then it will only be called once when the event is dispatched. Supported for legacy but use goog.events.listen(src, type, handler) instead.

Arguments:

type :

The type of the event to listen for.

handler :

(Object | null)

The function to handle the event. The handler can also be an object that implements the handleEvent method which takes the event object as argument.

opt_capture :

(boolean | undefined)

In DOM-compliant browsers, this determines whether the listener is fired during the capture or bubble phase of the event.

opt_handlerScope :

(Object | null | undefined)

Object in whose scope to call the listener.

code »

dispatchEvent(e) ⇒

Dispatches an event (or event like object) and calls all listeners listening for events of this type. The type of the event is decided by the type property on the event object. If any of the listeners returns false OR calls preventDefault then this function will return false. If one of the capture listeners calls stopPropagation, then the bubble listeners won't fire.

Arguments:

e :

(Object | null | string)

Event object.

Returns:

If anyone called preventDefault on the event object (or if any of the handlers returns false this will also return false.

code »

disposeInternal()

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
};

code »

getParentEventTarget() ⇒

(goog.events.EventTarget | null)

Returns the parent of this event target to use for bubbling.

Returns:

(goog.events.EventTarget | null)

The parent EventTarget or null if there is no parent.

code »

removeEventListener(type, handler, opt_capture, opt_handlerScope)

Removes an event listener from the event target. The handler must be the same object as the one added. If the handler has not been added then nothing is done.

Arguments:

type :

The type of the event to listen for.

handler :

(Object | null)

The function to handle the event. The handler can also be an object that implements the handleEvent method which takes the event object as argument.

opt_capture :

(boolean | undefined)

In DOM-compliant browsers, this determines whether the listener is fired during the capture or bubble phase of the event.

opt_handlerScope :

(Object | null | undefined)

Object in whose scope to call the listener.

code »

setParentEventTarget(parent)

Sets the parent of this event target to use for bubbling.

Arguments:

parent :

(goog.events.EventTarget | null)

Parent EventTarget (null if none).

code »

Defined in goog.Disposable

addOnDisposeCallback(callback, opt_scope)

Invokes a callback function when this object is disposed. Callbacks are invoked in the order in which they were added.

Arguments:

callback :

?function (this:T):

The callback function.

opt_scope :

(T | undefined)

An optional scope to call the callback in.

code »

dispose() ⇒

undefined

Disposes of the object. If the object hasn&#39;t already been disposed of, calls #disposeInternal. Classes that extend goog.Disposable should override #disposeInternal in order to delete references to COM objects, DOM nodes, and other disposable objects. Reentrant.

Returns:

undefined

Nothing.

code »

disposeInternal()

Deletes or nulls out any references to COM objects, DOM nodes, or other disposable objects. Classes that extend goog.Disposable should override this method. Not reentrant. To avoid calling it twice, it must only be called from the subclass&#39; disposeInternal method. Everywhere else the public dispose method must be used. For example:

mypackage.MyClass = function() {
goog.base(this);
// Constructor logic specific to MyClass.
...
};
goog.inherits(mypackage.MyClass, goog.Disposable);

mypackage.MyClass.prototype.disposeInternal = function() {
// Dispose logic specific to MyClass.
...
// Call superclass&#39;s disposeInternal at the end of the subclass&#39;s, like
// in C++, to avoid hard-to-catch issues.
goog.base(this, &#39;disposeInternal&#39;);
};

code »

getDisposed() ⇒

Use #isDisposed instead. No description.

Returns:

Whether the object has been disposed of.

code »

isDisposed() ⇒

No description.

Returns: