typescript-closure-tools
Version:
Command-line tools to convert closure-style JSDoc annotations to typescript, and to convert typescript sources to closure externs files
375 lines (320 loc) • 15 kB
TypeScript
/// <reference path="../../../globals.d.ts" />
/// <reference path="./component.d.ts" />
/// <reference path="../dom/dom.d.ts" />
/// <reference path="./rangemodel.d.ts" />
/// <reference path="../events/event.d.ts" />
/// <reference path="../math/coordinate.d.ts" />
/// <reference path="../fx/transitionbase.d.ts" />
declare module goog.ui {
class SliderBase extends SliderBase__Class { }
/** Fake class which should be extended to avoid inheriting static properties */
class SliderBase__Class extends goog.ui.Component__Class {
/**
* This creates a SliderBase object.
* @param {goog.dom.DomHelper=} opt_domHelper Optional DOM helper.
* @param {(function(number):?string)=} opt_labelFn An optional function mapping
* slider values to a description of the value.
* @constructor
* @extends {goog.ui.Component}
*/
constructor(opt_domHelper?: goog.dom.DomHelper, opt_labelFn?: { (_0: number): string });
/**
* The underlying range model
* @type {goog.ui.RangeModel}
* @protected
*/
rangeModel: goog.ui.RangeModel;
/**
* The minThumb dom-element, pointing to the start of the selected range.
* @type {HTMLDivElement}
* @protected
*/
valueThumb: HTMLDivElement;
/**
* The maxThumb dom-element, pointing to the end of the selected range.
* @type {HTMLDivElement}
* @protected
*/
extentThumb: HTMLDivElement;
/**
* The dom-element highlighting the selected range.
* @type {HTMLDivElement}
* @protected
*/
rangeHighlight: HTMLDivElement;
/**
* Enables/disables true RTL behavior. This should be called immediately after
* construction. 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.
* @param {boolean} flipForRtl True if the slider should be flipped for RTL,
* false otherwise.
*/
enableFlipForRtl(flipForRtl: boolean): void;
/**
* Returns the CSS class applied to the slider element for the given
* orientation. Subclasses must override this method.
* @param {goog.ui.SliderBase.Orientation} orient The orientation.
* @return {string} The CSS class applied to slider elements.
* @protected
*/
getCssClass(orient: goog.ui.SliderBase.Orientation): string;
/**
* Subclasses must implement this method and set the valueThumb and
* extentThumb to non-null values. They can also set the rangeHighlight
* element if a range highlight is desired.
* @type {function() : void}
* @protected
*/
createThumbs: { (): void };
/**
* Returns the value to use for the current mouse position
* @param {goog.events.Event} e The mouse event object.
* @return {number} The value that this mouse position represents.
*/
getValueFromMousePosition(e: goog.events.Event): number;
/**
* Returns whether a thumb is currently being dragged with the mouse (or via
* touch). Note that changing the value with keyboard, mouswheel, or via
* move-to-point click immediately sends a CHANGE event without going through a
* dragged state.
* @return {boolean} Whether a dragger is currently being dragged.
*/
isDragging(): boolean;
/**
* Moves the thumbs by the specified delta as follows
* - as long as both thumbs stay within [min,max], both thumbs are moved
* - once a thumb reaches or exceeds min (or max, respectively), it stays
* - at min (or max, respectively).
* In case both thumbs have reached min (or max), no change event will fire.
* If the specified delta is smaller than the step size, it will be rounded
* to the step size.
* @param {number} delta The delta by which to move the selected range.
*/
moveThumbs(delta: number): void;
/**
* Sets the value and extent of the underlying range model. We enforce that
* getMinimum() <= value <= getMaximum() - extent and
* getMinExtent <= extent <= getMaximum() - getValue()
* If this is not satisfied for the given extent, the call is ignored and no
* CHANGE event fires. This is a utility method to allow setting the thumbs
* simultaneously and ensuring that only one event fires.
* @param {number} value The value to which to set the value.
* @param {number} extent The value to which to set the extent.
*/
setValueAndExtent(value: number, extent: number): void;
/**
* @return {number} The minimum value.
*/
getMinimum(): number;
/**
* Sets the minimum number.
* @param {number} min The minimum value.
*/
setMinimum(min: number): void;
/**
* @return {number} The maximum value.
*/
getMaximum(): number;
/**
* Sets the maximum number.
* @param {number} max The maximum value.
*/
setMaximum(max: number): void;
/**
* @return {HTMLDivElement} The value thumb element.
*/
getValueThumb(): HTMLDivElement;
/**
* @return {HTMLDivElement} The extent thumb element.
*/
getExtentThumb(): HTMLDivElement;
/**
* Call back when the internal range model changes. Sub-classes may override
* and re-enter this method to update a11y state. Consider protected.
* @param {goog.events.Event} e The event object.
* @protected
*/
handleRangeModelChange(e: goog.events.Event): void;
/**
* Returns the position to move the handle to for a given value
* @param {number} val The value to get the coordinate for.
* @return {!goog.math.Coordinate} Coordinate with either x or y set.
*/
getThumbCoordinateForValue(val: number): goog.math.Coordinate;
/**
* Sets the value and starts animating the handle towards that position.
* @param {number} v Value to set and animate to.
*/
animatedSetValue(v: number): void;
/**
* @return {boolean} True if the slider is animating, false otherwise.
*/
isAnimating(): boolean;
/**
* Sets the factory that will be used to create additional animations to be
* played when animating to a new value. These animations can be for any
* element and the animations will be played in addition to the default
* animation(s). The animations will also be played in the same parallel queue
* ensuring that all animations are played at the same time.
* @see #animatedSetValue
*
* @param {goog.ui.SliderBase.AnimationFactory} factory The animation factory to
* use. This will not change the default animations played by the slider.
* It will only allow for additional animations.
*/
setAdditionalAnimations(factory: goog.ui.SliderBase.AnimationFactory): void;
/**
* Changes the orientation.
* @param {goog.ui.SliderBase.Orientation} orient The orientation.
*/
setOrientation(orient: goog.ui.SliderBase.Orientation): void;
/**
* @return {goog.ui.SliderBase.Orientation} the orientation of the slider.
*/
getOrientation(): goog.ui.SliderBase.Orientation;
/**
* @return {number} The amount to increment/decrement for page up/down as well
* as when holding down the mouse button on the background.
*/
getBlockIncrement(): number;
/**
* Sets the amount to increment/decrement for page up/down as well as when
* holding down the mouse button on the background.
*
* @param {number} value The value to set the block increment to.
*/
setBlockIncrement(value: number): void;
/**
* Sets the minimal value that the extent may have.
*
* @param {number} value The minimal value for the extent.
*/
setMinExtent(value: number): void;
/**
* @return {number} The amount to increment/decrement for up, down, left and
* right arrow keys and mouse wheel events.
*/
getUnitIncrement(): number;
/**
* Sets the amount to increment/decrement for up, down, left and right arrow
* keys and mouse wheel events.
* @param {number} value The value to set the unit increment to.
*/
setUnitIncrement(value: number): void;
/**
* @return {?number} The step value used to determine how to round the value.
*/
getStep(): number;
/**
* Sets the step value. The step value is used to determine how to round the
* value.
* @param {?number} step The step size.
*/
setStep(step: number): void;
/**
* @return {boolean} Whether clicking on the backgtround should move directly to
* that point.
*/
getMoveToPointEnabled(): boolean;
/**
* Sets whether clicking on the background should move directly to that point.
* @param {boolean} val Whether clicking on the background should move directly
* to that point.
*/
setMoveToPointEnabled(val: boolean): void;
/**
* @return {number} The value of the underlying range model.
*/
getValue(): number;
/**
* Sets the value of the underlying range model. We enforce that
* getMinimum() <= value <= getMaximum() - getExtent()
* If this is not satisifed for the given value, the call is ignored and no
* CHANGE event fires.
* @param {number} value The value.
*/
setValue(value: number): void;
/**
* @return {number} The value of the extent of the underlying range model.
*/
getExtent(): number;
/**
* Sets the extent of the underlying range model. We enforce that
* getMinExtent() <= extent <= getMaximum() - getValue()
* If this is not satisifed for the given extent, the call is ignored and no
* CHANGE event fires.
* @param {number} extent The value to which to set the extent.
*/
setExtent(extent: number): void;
/**
* Change the visibility of the slider.
* You must call this if you had set the slider's value when it was invisible.
* @param {boolean} visible Whether to show the slider.
*/
setVisible(visible: boolean): void;
/**
* Set a11y roles and state.
* @protected
*/
setAriaRoles(): void;
/**
* Set a11y roles and state when values change.
* @protected
*/
updateAriaStates(): void;
/**
* Enables or disables mouse wheel handling for the slider. The mouse wheel
* handler enables the user to change the value of slider using a mouse wheel.
*
* @param {boolean} enable Whether to enable mouse wheel handling.
*/
setHandleMouseWheel(enable: boolean): void;
/**
* @return {boolean} Whether the slider handles mousewheel.
*/
isHandleMouseWheel(): boolean;
/**
* Enables or disables the slider. A disabled slider will ignore all
* user-initiated events. Also fires goog.ui.Component.EventType.ENABLE/DISABLE
* event as appropriate.
* @param {boolean} enable Whether to enable the slider or not.
*/
setEnabled(enable: boolean): void;
/**
* @return {boolean} Whether the slider is enabled or not.
*/
isEnabled(): boolean;
/**
* @return {?string} The text value for the slider's current value, or null if
* unavailable.
*/
getTextValue(): string;
}
}
declare module goog.ui.SliderBase {
interface AnimationFactory {
/**
* Creates an additonal animation to play when animating to a new value.
*
* @param {number} previousValue The previous value (before animation).
* @param {number} newValue The new value (after animation).
* @param {number} interval The animation interval.
* @return {!Array.<!goog.fx.TransitionBase>} The additional animations to play.
*/
createAnimations(previousValue: number, newValue: number, interval: number): goog.fx.TransitionBase[];
}
/**
* Event types used to listen for dragging events. Note that extent drag events
* are also sent for single-thumb sliders, since the one thumb controls both
* value and extent together; in this case, they can simply be ignored.
* @enum {string}
*/
enum EventType { DRAG_VALUE_START, DRAG_VALUE_END, DRAG_EXTENT_START, DRAG_EXTENT_END, DRAG_START, DRAG_END }
/**
* Enum for representing the orientation of the slider.
*
* @enum {string}
*/
enum Orientation { VERTICAL, HORIZONTAL }
}