• index
• goog
• fx
• search: Go

The goog.fx.DragListGroup Class

goog.fx.DragListGroup
> goog.events.EventTarget
> goog.Disposable

goog.fx.DragListGroup()

A class representing a group of one or more "drag lists" with items that can be dragged within them and between them. Example usage: var dragListGroup = new goog.fx.DragListGroup(); dragListGroup.setDragItemHandleHoverClass(className1, className2); dragListGroup.setDraggerElClass(className3); dragListGroup.addDragList(vertList, goog.fx.DragListDirection.DOWN); dragListGroup.addDragList(horizList, goog.fx.DragListDirection.RIGHT); dragListGroup.init();

.EventType {Object}

Events dispatched by this class.

.addDragList(dragListElement, growthDirection, opt_unused, opt_dragHoverClass)

Adds a drag list to this DragListGroup. All calls to this method must happen before the call to init(). Remember that all child nodes (except text nodes) will be made draggable to any other drag list in this group.

dragListElement {Element}

Must be a container for a list of items that should all be made draggable.

growthDirection {goog.fx.DragListDirection}

The direction that this drag list grows in (i.e. if an item is appended to the DOM, the list's bounding box expands in this direction).

opt_unused {boolean=}

Unused argument.

opt_dragHoverClass {string=}

CSS class to apply to this drag list when the draggerEl hovers over it during a drag action.

.addEventListener(type, handler, opt_capture, opt_handlerScope)

Inherited from goog.events.EventTarget .

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.

type {string}

The type of the event to listen for.

handler {Function|Object}

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

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

opt_handlerScope {Object=}

Object in whose scope to call the listener.

.addOnDisposeCallback(callback, opt_scope)

Inherited from goog.Disposable .

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

callback {!Function}

The callback function.

opt_scope {Object=}

An optional scope to call the callback in.

.creationStack {string}

Inherited from goog.Disposable .

If monitoring the goog.Disposable instances is enabled, stores the creation stack trace of the Disposable instance.

.dispatchEvent(e)

Inherited from goog.events.EventTarget .

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.

e {string|Object|goog.events.Event}

Event object.

returns {boolean}

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

.dispose()

Inherited from goog.Disposable .

Disposes of the object. If the object hasn't already been disposed of, calls {@link #disposeInternal}. Classes that extend {@code goog.Disposable} should override {@link #disposeInternal} in order to delete references to COM objects, DOM nodes, and other disposable objects. Reentrant.

returns {void}

Nothing.

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

.getHysteresis()

returns {number}

distance The number of pixels after which a mousedown and move is considered a drag.

.getParentEventTarget()

Inherited from goog.events.EventTarget .

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

returns {goog.events.EventTarget}

The parent EventTarget or null if there is no parent.

.init()

Performs the initial setup to make all items in all lists draggable.

.isDisposed()

Inherited from goog.Disposable .

returns {boolean}

Whether the object has been disposed of.

.registerDisposable(disposable)

Inherited from goog.Disposable .

Associates a disposable object with this object so that they will be disposed together.

disposable {goog.disposable.IDisposable}

that will be disposed when this object is disposed.

.removeEventListener(type, handler, opt_capture, opt_handlerScope)

Inherited from goog.events.EventTarget .

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.

type {string}

The type of the event to listen for.

handler {Function|Object}

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

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

opt_handlerScope {Object=}

Object in whose scope to call the listener.

.setCurrDragItemClass(var_args)

Sets a user-supplied CSS class to add to the current drag item (during a drag action). If not set, the default behavior adds visibility:hidden to the current drag item so that it is a block of empty space in the hover drag list (if any). If this class is set by the user, then the default behavior does not happen (unless, of course, the class also contains visibility:hidden).

var_args {...!string}

The CSS class or classes.

.setDragItemHandleHoverClass(var_args)

Sets a user-supplied CSS class to add to a drag item handle on hover (not during a drag action).

var_args {...!string}

The CSS class or classes.

.setDragItemHoverClass(var_args)

Sets a user-supplied CSS class to add to a drag item on hover (not during a drag action).

var_args {...!string}

The CSS class or classes.

.setDraggerElClass(draggerElClass)

Sets a user-supplied CSS class to add to the clone of the current drag item that's actually being dragged around (during a drag action).

draggerElClass {string}

The CSS class.

.setFunctionToGetHandleForDragItem(getHandleForDragItemFn)

Sets a user-supplied function used to get the "handle" element for a drag item. The function must accept exactly one argument. The argument may be any drag item element. If not set, the default implementation uses the whole drag item as the handle.

getHandleForDragItemFn {function(Element): Element}

A function that, given any drag item, returns a reference to its "handle" element (which may be the drag item element itself).

.setHysteresis(distance)

Sets the distance the user has to drag the element before a drag operation is started.

distance {number}

The number of pixels after which a mousedown and move is considered a drag.

.setIsCurrDragItemAlwaysDisplayed()

Sets the property of the currDragItem that it is always displayed in the list.

.setNoUpdateWhileDragging()

Sets the private property updateWhileDragging_ to false. This disables the update of the position of the currDragItem while dragging. It will only be placed to its new location once the drag ends.

.setParentEventTarget(parent)

Inherited from goog.events.EventTarget .

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

parent {goog.events.EventTarget?}

Parent EventTarget (null if none).

Documentation generated using JvJsDoc, version 0.5 on 2012-09-03.