YUI.add('scrollview-base', function (Y, NAME) {

/**

 * The scrollview-base module provides a basic ScrollView Widget, without scrollbar indicators

 *

 * @module scrollview

 * @submodule scrollview-base

 */

 // Local vars

var getClassName = Y.ClassNameManager.getClassName,

    DOCUMENT = Y.config.doc,

    IE = Y.UA.ie,

    NATIVE_TRANSITIONS = Y.Transition.useNative,

    vendorPrefix = Y.Transition._VENDOR_PREFIX, // Todo: This is a private property, and alternative approaches should be investigated

    SCROLLVIEW = 'scrollview',

    CLASS_NAMES = {

        vertical: getClassName(SCROLLVIEW, 'vert'),

        horizontal: getClassName(SCROLLVIEW, 'horiz')

    },

    EV_SCROLL_END = 'scrollEnd',

    FLICK = 'flick',

    DRAG = 'drag',

    MOUSEWHEEL = 'mousewheel',

    UI = 'ui',

    TOP = 'top',

    LEFT = 'left',

    PX = 'px',

    AXIS = 'axis',

    SCROLL_Y = 'scrollY',

    SCROLL_X = 'scrollX',

    BOUNCE = 'bounce',

    DISABLED = 'disabled',

    DECELERATION = 'deceleration',

    DIM_X = 'x',

    DIM_Y = 'y',

    BOUNDING_BOX = 'boundingBox',

    CONTENT_BOX = 'contentBox',

    GESTURE_MOVE = 'gesturemove',

    START = 'start',

    END = 'end',

    EMPTY = '',

    ZERO = '0s',

    SNAP_DURATION = 'snapDuration',

    SNAP_EASING = 'snapEasing',

    EASING = 'easing',

    FRAME_DURATION = 'frameDuration',

    BOUNCE_RANGE = 'bounceRange',

    _constrain = function (val, min, max) {

        return Math.min(Math.max(val, min), max);

    };

/**

 * ScrollView provides a scrollable widget, supporting flick gestures,

 * across both touch and mouse based devices.

 *

 * @class ScrollView

 * @param config {Object} Object literal with initial attribute values

 * @extends Widget

 * @constructor

 */

function ScrollView() {

    ScrollView.superclass.constructor.apply(this, arguments);

}

Y.ScrollView = Y.extend(ScrollView, Y.Widget, {

    // *** Y.ScrollView prototype

    /**

     * Flag driving whether or not we should try and force H/W acceleration when transforming. Currently enabled by default for Webkit.

     * Used by the _transform method.

     *

     * @property _forceHWTransforms

     * @type boolean

     * @protected

     */

    _forceHWTransforms: Y.UA.webkit ? true : false,

    /**

     * <p>Used to control whether or not ScrollView's internal

     * gesturemovestart, gesturemove and gesturemoveend

     * event listeners should preventDefault. The value is an

     * object, with "start", "move" and "end" properties used to

     * specify which events should preventDefault and which shouldn't:</p>

     *

     * <pre>

     * {

     *    start: false,

     *    move: true,

     *    end: false

     * }

     * </pre>

     *

     * <p>The default values are set up in order to prevent panning,

     * on touch devices, while allowing click listeners on elements inside

     * the ScrollView to be notified as expected.</p>

     *

     * @property _prevent

     * @type Object

     * @protected

     */

    _prevent: {

        start: false,

        move: true,

        end: false

    },

    /**

     * Contains the distance (postive or negative) in pixels by which

     *  the scrollview was last scrolled. This is useful when setting up

     *  click listeners on the scrollview content, which on mouse based

     *  devices are always fired, even after a drag/flick.

     *

     * <p>Touch based devices don't currently fire a click event,

     *  if the finger has been moved (beyond a threshold) so this

     *  check isn't required, if working in a purely touch based environment</p>

     *

     * @property lastScrolledAmt

     * @type Number

     * @public

     * @default 0

     */

    lastScrolledAmt: 0,

    /**

     * Internal state, defines the minimum amount that the scrollview can be scrolled along the X axis

     *

     * @property _minScrollX

     * @type number

     * @protected

     */

    _minScrollX: null,

    /**

     * Internal state, defines the maximum amount that the scrollview can be scrolled along the X axis

     *

     * @property _maxScrollX

     * @type number

     * @protected

     */

    _maxScrollX: null,

    /**

     * Internal state, defines the minimum amount that the scrollview can be scrolled along the Y axis

     *

     * @property _minScrollY

     * @type number

     * @protected

     */

    _minScrollY: null,

    /**

     * Internal state, defines the maximum amount that the scrollview can be scrolled along the Y axis

     *

     * @property _maxScrollY

     * @type number

     * @protected

     */

    _maxScrollY: null,

    /**

     * Designated initializer

     *

     * @method initializer

     * @param {Object} Configuration object for the plugin

     */

    initializer: function () {

        var sv = this;

        // Cache these values, since they aren't going to change.

        sv._bb = sv.get(BOUNDING_BOX);

        sv._cb = sv.get(CONTENT_BOX);

        // Cache some attributes

        sv._cAxis = sv.get(AXIS);

        sv._cBounce = sv.get(BOUNCE);

        sv._cBounceRange = sv.get(BOUNCE_RANGE);

        sv._cDeceleration = sv.get(DECELERATION);

        sv._cFrameDuration = sv.get(FRAME_DURATION);

    },

    /**

     * bindUI implementation

     *

     * Hooks up events for the widget

     * @method bindUI

     */

    bindUI: function () {

        var sv = this;

        // Bind interaction listers

        sv._bindFlick(sv.get(FLICK));

        sv._bindDrag(sv.get(DRAG));

        sv._bindMousewheel(true);

        // Bind change events

        sv._bindAttrs();

        // IE SELECT HACK. See if we can do this non-natively and in the gesture for a future release.

        if (IE) {

            sv._fixIESelect(sv._bb, sv._cb);

        }

        // Set any deprecated static properties

        if (ScrollView.SNAP_DURATION) {

            sv.set(SNAP_DURATION, ScrollView.SNAP_DURATION);

        }

        if (ScrollView.SNAP_EASING) {

            sv.set(SNAP_EASING, ScrollView.SNAP_EASING);

        }

        if (ScrollView.EASING) {

            sv.set(EASING, ScrollView.EASING);

        }

        if (ScrollView.FRAME_STEP) {

            sv.set(FRAME_DURATION, ScrollView.FRAME_STEP);

        }

        if (ScrollView.BOUNCE_RANGE) {

            sv.set(BOUNCE_RANGE, ScrollView.BOUNCE_RANGE);

        }

        // Recalculate dimension properties

        // TODO: This should be throttled.

        // Y.one(WINDOW).after('resize', sv._afterDimChange, sv);

    },

    /**

     * Bind event listeners

     *

     * @method _bindAttrs

     * @private

     */

    _bindAttrs: function () {

        var sv = this,

            scrollChangeHandler = sv._afterScrollChange,

            dimChangeHandler = sv._afterDimChange;

        // Bind any change event listeners

        sv.after({

            'scrollEnd': sv._afterScrollEnd,

            'disabledChange': sv._afterDisabledChange,

            'flickChange': sv._afterFlickChange,

            'dragChange': sv._afterDragChange,

            'axisChange': sv._afterAxisChange,

            'scrollYChange': scrollChangeHandler,

            'scrollXChange': scrollChangeHandler,

            'heightChange': dimChangeHandler,

            'widthChange': dimChangeHandler

        });

    },

    /**

     * Bind (or unbind) gesture move listeners required for drag support

     *

     * @method _bindDrag

     * @param drag {boolean} If true, the method binds listener to enable

     *  drag (gesturemovestart). If false, the method unbinds gesturemove

     *  listeners for drag support.

     * @private

     */

    _bindDrag: function (drag) {

        var sv = this,

            bb = sv._bb;

        // Unbind any previous 'drag' listeners

        bb.detach(DRAG + '|*');

        if (drag) {

            bb.on(DRAG + '|' + GESTURE_MOVE + START, Y.bind(sv._onGestureMoveStart, sv));

        }

    },

    /**

     * Bind (or unbind) flick listeners.

     *

     * @method _bindFlick

     * @param flick {Object|boolean} If truthy, the method binds listeners for

     *  flick support. If false, the method unbinds flick listeners.

     * @private

     */

    _bindFlick: function (flick) {

        var sv = this,

            bb = sv._bb;

        // Unbind any previous 'flick' listeners

        bb.detach(FLICK + '|*');

        if (flick) {

            bb.on(FLICK + '|' + FLICK, Y.bind(sv._flick, sv), flick);

            // Rebind Drag, becuase _onGestureMoveEnd always has to fire -after- _flick

            sv._bindDrag(sv.get(DRAG));

        }

    },

    /**

     * Bind (or unbind) mousewheel listeners.

     *

     * @method _bindMousewheel

     * @param mousewheel {Object|boolean} If truthy, the method binds listeners for

     *  mousewheel support. If false, the method unbinds mousewheel listeners.

     * @private

     */

    _bindMousewheel: function (mousewheel) {

        var sv = this,

            bb = sv._bb;

        // Unbind any previous 'mousewheel' listeners

        // TODO: This doesn't actually appear to work properly. Fix. #2532743

        bb.detach(MOUSEWHEEL + '|*');

        // Only enable for vertical scrollviews

        if (mousewheel) {

            // Bound to document, because that's where mousewheel events fire off of.

            Y.one(DOCUMENT).on(MOUSEWHEEL, Y.bind(sv._mousewheel, sv));

        }

    },

    /**

     * syncUI implementation.

     *

     * Update the scroll position, based on the current value of scrollX/scrollY.

     *

     * @method syncUI

     */

    syncUI: function () {

        var sv = this,

            scrollDims = sv._getScrollDims(),

            width = scrollDims.offsetWidth,

            height = scrollDims.offsetHeight,

            scrollWidth = scrollDims.scrollWidth,

            scrollHeight = scrollDims.scrollHeight;

        // If the axis is undefined, auto-calculate it

        if (sv._cAxis === undefined) {

            // This should only ever be run once (for now).

            // In the future SV might post-load axis changes

            sv._cAxis = {

                x: (scrollWidth > width),

                y: (scrollHeight > height)

            };

            sv._set(AXIS, sv._cAxis);

        }

        // get text direction on or inherited by scrollview node

        sv.rtl = (sv._cb.getComputedStyle('direction') === 'rtl');

        // Cache the disabled value

        sv._cDisabled = sv.get(DISABLED);

        // Run this to set initial values

        sv._uiDimensionsChange();

        // If we're out-of-bounds, snap back.

        if (sv._isOutOfBounds()) {

            sv._snapBack();

        }

    },

    /**

     * Utility method to obtain widget dimensions

     *

     * @method _getScrollDims

     * @return {Object} The offsetWidth, offsetHeight, scrollWidth and

     *  scrollHeight as an array: [offsetWidth, offsetHeight, scrollWidth,

     *  scrollHeight]

     * @private

     */

    _getScrollDims: function () {

        var sv = this,

            cb = sv._cb,

            bb = sv._bb,

            TRANS = ScrollView._TRANSITION,

            // Ideally using CSSMatrix - don't think we have it normalized yet though.

            // origX = (new WebKitCSSMatrix(cb.getComputedStyle("transform"))).e,

            // origY = (new WebKitCSSMatrix(cb.getComputedStyle("transform"))).f,

            origX = sv.get(SCROLL_X),

            origY = sv.get(SCROLL_Y),

            origHWTransform,

            dims;

        // TODO: Is this OK? Just in case it's called 'during' a transition.

        if (NATIVE_TRANSITIONS) {

            cb.setStyle(TRANS.DURATION, ZERO);

            cb.setStyle(TRANS.PROPERTY, EMPTY);

        }

        origHWTransform = sv._forceHWTransforms;

        sv._forceHWTransforms = false; // the z translation was causing issues with picking up accurate scrollWidths in Chrome/Mac.

        sv._moveTo(cb, 0, 0);

        dims = {

            'offsetWidth': bb.get('offsetWidth'),

            'offsetHeight': bb.get('offsetHeight'),

            'scrollWidth': bb.get('scrollWidth'),

            'scrollHeight': bb.get('scrollHeight')

        };

        sv._moveTo(cb, -(origX), -(origY));

        sv._forceHWTransforms = origHWTransform;

        return dims;

    },

    /**

     * This method gets invoked whenever the height or width attributes change,

     * allowing us to determine which scrolling axes need to be enabled.