fx.Dragger Extends goog.events.EventTarget
A class that allows mouse or touch-based dragging (moving) of an element

Inheritance

Constructor

goog.fx.Dragger(targetopt_handleopt_limits)

Parameters

target : Element
The element that will be dragged.
opt_handle : Element=
An optional handle to control the drag, if null the target is used.
opt_limits : goog.math.Rect=
Object containing left, top, width, and height.

Instance Methods

Public Protected Private
calculatePosition_(dxdy) !goog.math.Coordinate
Calculates the drag position.
Arguments:
dx : number
The horizontal movement delta.
dy : number
The vertical movement delta.
Returns: !goog.math.Coordinate  The newly calculated drag element position.
code »
cleanUpAfterDragging_()
Unregisters the event handlers that are only active during dragging, and releases mouse capture.
code »
computeInitialPosition()
Overridable function for computing the initial position of the target before dragging begins.
code »
defaultAction(xy)
Overridable function for handling the default action of the drag behaviour. Normally this is simply moving the element to x,y though in some cases it might be used to resize the layer. This is basically a shortcut to implementing a default ondrag event handler.
Arguments:
x : number
X-coordinate for target element. In right-to-left, x this is the number of pixels the target should be moved to from the right.
y : number
Y-coordinate for target element.
code »
disposeInternal()
No description.
code »
doDrag(exydragFromScroll)
No description.
Arguments:
e : goog.events.BrowserEvent
The closure object representing the browser event that caused a drag event.
x : number
The new horizontal position for the drag element.
y : number
The new vertical position for the drag element.
dragFromScroll : boolean
Whether dragging was caused by scrolling the associated scroll target.
code »
enableRightPositioningForRtl(useRightPositioningForRtl)
Turns on/off true RTL behavior. This should be called immediately after construction. This is a temporary flag to allow clients to transition to the new component at their convenience. At some point true will be the default.
Arguments:
useRightPositioningForRtl : boolean
True if "right" should be used for positioning, false if "left" should be used for positioning.
code »
endDrag(eopt_dragCanceled)
Event handler that is used to end the drag.
Arguments:
e : goog.events.BrowserEvent
Event object.
opt_dragCanceled : boolean=
Whether the drag has been canceled.
code »
endDragCancel(e)
Event handler that is used to end the drag by cancelling it.
Arguments:
e : goog.events.BrowserEvent
Event object.
code »
fireDragStart_(e) boolean
Fires a goog.fx.Dragger.EventType.START event.
Arguments:
e : goog.events.BrowserEvent
Browser event that triggered the drag.
Returns: boolean  False iff preventDefault was called on the DragEvent.
code »
getEnabled() boolean
No description.
Returns: boolean  Whether the dragger is enabled.
code »
getHandler() goog.events.EventHandler.<T>
Returns the event handler, intended for subclass use.
Returns: goog.events.EventHandler.<T>  The event handler.
code »
getHysteresis() number
Gets the distance the user has to drag the element before a drag operation is started.
Returns: number  distance The number of pixels after which a mousedown and move is considered a drag.
code »
handleMove_(e)
Event handler that is used on mouse / touch move to update the drag
Arguments:
e : goog.events.BrowserEvent
Event object.
code »
isDragging() boolean
No description.
Returns: boolean  Whether the dragger is currently in the midst of a drag.
code »
isRightToLeft_() boolean
Whether the DOM element being manipulated is rendered right-to-left.
Returns: boolean  True if the DOM element is rendered right-to-left, false otherwise.
code »
limitX(x) number
Returns the 'real' x after limits are applied (allows for some limits to be undefined).
Arguments:
x : number
X-coordinate to limit.
Returns: number  The 'real' X-coordinate after limits are applied.
code »
limitY(y) number
Returns the 'real' y after limits are applied (allows for some limits to be undefined).
Arguments:
y : number
Y-coordinate to limit.
Returns: number  The 'real' Y-coordinate after limits are applied.
code »
maybeReinitTouchEvent_(e)
Re-initializes the event with the first target touch event or, in the case of a stop event, the last changed touch.
Arguments:
e : goog.events.BrowserEvent
A TOUCH... event.
code »
onScroll_(e)
Event handler for scroll target scrolling.
Arguments:
e : goog.events.BrowserEvent
The event.
code »
setCancelIeDragStart(cancelIeDragStart)
Enables cancelling of built-in IE drag events.
Arguments:
cancelIeDragStart : boolean
Whether to enable cancelling of IE dragstart event.
code »
setEnabled(enabled)
Set whether dragger is enabled
Arguments:
enabled : boolean
Whether dragger is enabled.
code »
setHysteresis(distance)
Sets the distance the user has to drag the element before a drag operation is started.
Arguments:
distance : number
The number of pixels after which a mousedown and move is considered a drag.
code »
setLimits(limits)
Sets (or reset) the Drag limits after a Dragger is created.
Arguments:
limits : ?goog.math.Rect
Object containing left, top, width, height for new Dragger limits. If target is right-to-left and enableRightPositioningForRtl(true) is called, then rect is interpreted as right, top, width, and height.
code »
setScrollTarget(scrollTarget)
Sets the SCROLL event target to make drag element follow scrolling.
Arguments:
scrollTarget : EventTarget
The event target that dispatches SCROLL events.
code »
setupDragHandlers()
Sets up event handlers when dragging starts.
code »
startDrag(e)
Event handler that is used to start the drag
Arguments:
e : goog.events.BrowserEvent
Event object.
code »
addEventListener(typeopt_captureopt_handlerScope)
Use #listen instead, when possible. Otherwise, use goog.events.listen if you are passing Object (instead of Function) as handler. 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.
Arguments:
type : string
The type of the event to listen for.
: ?function():? | ?{handleEvent:function():?
No description.
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.
code »
assertInitialized_()
Asserts that the event target instance is initialized properly.
code »
dispatchEvent()
No description.
code »
disposeInternal()
Removes 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.
code »
fireListeners()
No description.
code »
getListener()
No description.
code »
getListeners()
No description.
code »
getParentEventTarget() 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.
code »
hasListener()
No description.
code »
listen()
No description.
code »
listenOnce()
No description.
code »
removeAllListeners()
No description.
code »
removeEventListener(typeopt_captureopt_handlerScope)
Use #unlisten instead, when possible. Otherwise, use goog.events.unlisten if you are passing Object (instead of Function) as handler. 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 : string
The type of the event to listen for.
: ?function():? | ?{handleEvent:function():?
No description.
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.
code »
setParentEventTarget(parent)
Sets the parent of this event target to use for capture/bubble mechanism.
Arguments:
parent : goog.events.EventTarget
Parent listenable (null if none).
code »
setTargetForTesting(target)
Sets the target to be used for event.target when firing event. Mainly used for testing. For example, see goog.testing.events.mixinListenable.
Arguments:
target : !Object
The target.
code »
unlisten()
No description.
code »
unlistenByKey()
No description.
code »
addOnDisposeCallback(callbackopt_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=
An optional scope to call the callback in.
code »
dispose() void
Disposes of the object. If the object hasn'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: void  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' disposeInternal method. Everywhere else the public dispose method must be used. For example:
  mypackage.MyClass = function() {
    mypackage.MyClass.base(this, 'constructor');
    // Constructor logic specific to MyClass.
    ...
  };
  goog.inherits(mypackage.MyClass, goog.Disposable);

  mypackage.MyClass.prototype.disposeInternal = function() {
    // Dispose logic specific to MyClass.
    ...
    // Call superclass's disposeInternal at the end of the subclass's, like
    // in C++, to avoid hard-to-catch issues.
    mypackage.MyClass.base(this, 'disposeInternal');
  };
code »
getDisposed() boolean
Use #isDisposed instead. No description.
Returns: boolean  Whether the object has been disposed of.
code »
isDisposed() boolean
No description.
Returns: boolean  Whether the object has been disposed of.
code »
registerDisposable(disposable)
Associates a disposable object with this object so that they will be disposed together.
Arguments:
disposable : goog.disposable.IDisposable
that will be disposed when this object is disposed.
code »

Instance Properties

clientX :
Current x position of mouse or touch relative to viewport.
Code »
clientY :
Current y position of mouse or touch relative to viewport.
Code »
constructor :
No description.
Code »
deltaX :
Current x position of drag relative to target's parent.
Code »
deltaY :
Current y position of drag relative to target's parent.
Code »
document_ :
Reference to a document object to use for the events.
Code »
dragging_ :
Whether object is currently being dragged.
Code »
enabled_ :
Whether dragging is currently enabled.
Code »
eventHandler_ : goog.events.EventHandler
No description.
Code »
handle :
Reference to the handler that initiates the drag.
Code »
hysteresisDistanceSquared_ :
The amount of distance, in pixels, after which a mousedown or touchstart is considered a drag.
Code »
ieDragStartCancellingOn_ :
Whether IE drag events cancelling is on.
Code »
limits : goog.math.Rect
Object representing the limits of the drag region.
Code »
mouseDownTime_ :
Timestamp of when the mousedown or touchstart occurred.
Code »
pageScroll : goog.math.Coordinate
The current page scroll value.
Code »
rightToLeft_ :
Whether the element is rendered right-to-left. We initialize this lazily.
Code »
screenX :
Current x position of mouse or touch relative to screen. Deprecated because it doesn't take into affect zoom level or pixel density.
Code »
screenY :
Current y position of mouse or touch relative to screen. Deprecated because it doesn't take into affect zoom level or pixel density.
Code »
scrollTarget_ :
The SCROLL event target used to make drag element follow scrolling.
Code »
startX :
The x position where the first mousedown or touchstart occurred.
Code »
startY :
The y position where the first mousedown or touchstart occurred.
Code »
target :
Reference to drag target element.
Code »
useRightPositioningForRtl_ :
Whether the dragger implements the changes described in http://b/6324964, making it truly RTL. This is a temporary flag to allow clients to transition to the new behavior at their convenience. At some point it will be the default.
Code »
actualEventTarget_ : goog.events.EventTarget
The object to use for event.target. Useful when mixing in an EventTarget to another object.
Code »
constructor :
No description.
Code »
eventTargetListeners_ : goog.events.ListenerMap
Maps of event type to an array of listeners.
Code »
parentEventTarget_ : goog.events.EventTarget
Parent event target, used during event bubbling. TODO(user): Change this to goog.events.Listenable. This currently breaks people who expect getParentEventTarget to return goog.events.EventTarget.
Code »
creationStack :
If monitoring the goog.Disposable instances is enabled, stores the creation stack trace of the Disposable instance.
Code »
disposed_ :
Whether the object has been disposed of.
Code »
onDisposeCallbacks_ :
Callbacks to invoke when this object is disposed.
Code »

Static Methods

goog.fx.Dragger.cloneNode(sourceEl) !Element
Creates copy of node being dragged. This is a utility function to be used wherever it is inappropriate for the original source to follow the mouse cursor itself.
Arguments:
sourceEl : Element
Element to copy.
Returns: !Element  The clone of sourceEl.
code »

Static Properties

goog.fx.Dragger.HAS_SET_CAPTURE_ :
Whether setCapture is supported by the browser.
Code »
goog.fx.Dragger.superClass_ :
No description.
Code »

Enumerations

goog.fx.Dragger.EventType :
Constants for event names.
Constants:
BEFOREDRAG
No description.
DRAG
No description.
EARLY_CANCEL
No description.
END
No description.
START
No description.
Code »

Package fx

Package Reference