typescript-closure-tools
Version:
Command-line tools to convert closure-style JSDoc annotations to typescript, and to convert typescript sources to closure externs files
342 lines (293 loc) • 13.4 kB
TypeScript
/// <reference path="../../../globals.d.ts" />
/// <reference path="../events/eventtarget.d.ts" />
/// <reference path="../math/rect.d.ts" />
/// <reference path="../math/coordinate.d.ts" />
/// <reference path="../events/eventhandler.d.ts" />
/// <reference path="../events/browserevent.d.ts" />
/// <reference path="../events/event.d.ts" />
declare module goog.fx {
class Dragger extends Dragger__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class Dragger__Class extends goog.events.EventTarget__Class {
/**
* A class that allows mouse or touch-based dragging (moving) of an element
*
* @param {Element} target The element that will be dragged.
* @param {Element=} opt_handle An optional handle to control the drag, if null
* the target is used.
* @param {goog.math.Rect=} opt_limits Object containing left, top, width,
* and height.
*
* @extends {goog.events.EventTarget}
* @constructor
*/
constructor(target: Element, opt_handle?: Element, opt_limits?: goog.math.Rect);
/**
* Reference to drag target element.
* @type {Element}
*/
target: Element;
/**
* Reference to the handler that initiates the drag.
* @type {Element}
*/
handle: Element;
/**
* Object representing the limits of the drag region.
* @type {goog.math.Rect}
*/
limits: goog.math.Rect;
/**
* Current x position of mouse or touch relative to viewport.
* @type {number}
*/
clientX: number;
/**
* Current y position of mouse or touch relative to viewport.
* @type {number}
*/
clientY: number;
/**
* Current x position of mouse or touch relative to screen. Deprecated because
* it doesn't take into affect zoom level or pixel density.
* @type {number}
* @deprecated Consider switching to clientX instead.
*/
screenX: number;
/**
* Current y position of mouse or touch relative to screen. Deprecated because
* it doesn't take into affect zoom level or pixel density.
* @type {number}
* @deprecated Consider switching to clientY instead.
*/
screenY: number;
/**
* The x position where the first mousedown or touchstart occurred.
* @type {number}
*/
startX: number;
/**
* The y position where the first mousedown or touchstart occurred.
* @type {number}
*/
startY: number;
/**
* Current x position of drag relative to target's parent.
* @type {number}
*/
deltaX: number;
/**
* Current y position of drag relative to target's parent.
* @type {number}
*/
deltaY: number;
/**
* The current page scroll value.
* @type {goog.math.Coordinate}
*/
pageScroll: goog.math.Coordinate;
/**
* 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.
* @param {boolean} useRightPositioningForRtl True if "right" should be used for
* positioning, false if "left" should be used for positioning.
*/
enableRightPositioningForRtl(useRightPositioningForRtl: boolean): void;
/**
* Returns the event handler, intended for subclass use.
* @return {goog.events.EventHandler.<T>} The event handler.
* @this T
* @template T
*/
getHandler<T>(): goog.events.EventHandler<T>;
/**
* Sets (or reset) the Drag limits after a Dragger is created.
* @param {goog.math.Rect?} limits 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.
*/
setLimits(limits: goog.math.Rect): void;
/**
* Sets the distance the user has to drag the element before a drag operation is
* started.
* @param {number} distance The number of pixels after which a mousedown and
* move is considered a drag.
*/
setHysteresis(distance: number): void;
/**
* Gets the distance the user has to drag the element before a drag operation is
* started.
* @return {number} distance The number of pixels after which a mousedown and
* move is considered a drag.
*/
getHysteresis(): number;
/**
* Sets the SCROLL event target to make drag element follow scrolling.
*
* @param {EventTarget} scrollTarget The event target that dispatches SCROLL
* events.
*/
setScrollTarget(scrollTarget: EventTarget): void;
/**
* Enables cancelling of built-in IE drag events.
* @param {boolean} cancelIeDragStart Whether to enable cancelling of IE
* dragstart event.
*/
setCancelIeDragStart(cancelIeDragStart: boolean): void;
/**
* @return {boolean} Whether the dragger is enabled.
*/
getEnabled(): boolean;
/**
* Set whether dragger is enabled
* @param {boolean} enabled Whether dragger is enabled.
*/
setEnabled(enabled: boolean): void;
/**
* Event handler that is used to start the drag
* @param {goog.events.BrowserEvent} e Event object.
*/
startDrag(e: goog.events.BrowserEvent): void;
/**
* Sets up event handlers when dragging starts.
* @protected
*/
setupDragHandlers(): void;
/**
* Event handler that is used to end the drag.
* @param {goog.events.BrowserEvent} e Event object.
* @param {boolean=} opt_dragCanceled Whether the drag has been canceled.
*/
endDrag(e: goog.events.BrowserEvent, opt_dragCanceled?: boolean): void;
/**
* Event handler that is used to end the drag by cancelling it.
* @param {goog.events.BrowserEvent} e Event object.
*/
endDragCancel(e: goog.events.BrowserEvent): void;
/**
* @param {goog.events.BrowserEvent} e The closure object
* representing the browser event that caused a drag event.
* @param {number} x The new horizontal position for the drag element.
* @param {number} y The new vertical position for the drag element.
* @param {boolean} dragFromScroll Whether dragging was caused by scrolling
* the associated scroll target.
* @protected
*/
doDrag(e: goog.events.BrowserEvent, x: number, y: number, dragFromScroll: boolean): void;
/**
* Returns the 'real' x after limits are applied (allows for some
* limits to be undefined).
* @param {number} x X-coordinate to limit.
* @return {number} The 'real' X-coordinate after limits are applied.
*/
limitX(x: number): number;
/**
* Returns the 'real' y after limits are applied (allows for some
* limits to be undefined).
* @param {number} y Y-coordinate to limit.
* @return {number} The 'real' Y-coordinate after limits are applied.
*/
limitY(y: number): number;
/**
* Overridable function for computing the initial position of the target
* before dragging begins.
* @protected
*/
computeInitialPosition(): void;
/**
* 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.
* @param {number} x 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.
* @param {number} y Y-coordinate for target element.
*/
defaultAction(x: number, y: number): void;
/**
* @return {boolean} Whether the dragger is currently in the midst of a drag.
*/
isDragging(): boolean;
}
class DragEvent extends DragEvent__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class DragEvent__Class extends goog.events.Event__Class {
/**
* Object representing a drag event
* @param {string} type Event type.
* @param {goog.fx.Dragger} dragobj Drag object initiating event.
* @param {number} clientX X-coordinate relative to the viewport.
* @param {number} clientY Y-coordinate relative to the viewport.
* @param {goog.events.BrowserEvent} browserEvent The closure object
* representing the browser event that caused this drag event.
* @param {number=} opt_actX Optional actual x for drag if it has been limited.
* @param {number=} opt_actY Optional actual y for drag if it has been limited.
* @param {boolean=} opt_dragCanceled Whether the drag has been canceled.
* @constructor
* @extends {goog.events.Event}
*/
constructor(type: string, dragobj: goog.fx.Dragger, clientX: number, clientY: number, browserEvent: goog.events.BrowserEvent, opt_actX?: number, opt_actY?: number, opt_dragCanceled?: boolean);
/**
* X-coordinate relative to the viewport
* @type {number}
*/
clientX: number;
/**
* Y-coordinate relative to the viewport
* @type {number}
*/
clientY: number;
/**
* The closure object representing the browser event that caused this drag
* event.
* @type {goog.events.BrowserEvent}
*/
browserEvent: goog.events.BrowserEvent;
/**
* The real x-position of the drag if it has been limited
* @type {number}
*/
left: number;
/**
* The real y-position of the drag if it has been limited
* @type {number}
*/
top: number;
/**
* Reference to the drag object for this event
* @type {goog.fx.Dragger}
*/
dragger: goog.fx.Dragger;
/**
* Whether drag was canceled with this event. Used to differentiate between
* a legitimate drag END that can result in an action and a drag END which is
* a result of a drag cancelation. For now it can happen 1) with drag END
* event on FireFox when user drags the mouse out of the window, 2) with
* drag END event on IE7 which is generated on MOUSEMOVE event when user
* moves the mouse into the document after the mouse button has been
* released, 3) when TOUCHCANCEL is raised instead of TOUCHEND (on touch
* events).
* @type {boolean}
*/
dragCanceled: boolean;
}
}
declare module goog.fx.Dragger {
/**
* 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.
*
* @param {Element} sourceEl Element to copy.
* @return {!Element} The clone of {@code sourceEl}.
*/
function cloneNode(sourceEl: Element): Element;
/**
* Constants for event names.
* @enum {string}
*/
enum EventType { EARLY_CANCEL, START, BEFOREDRAG, DRAG, END }
}