YUI.add('app-transitions-native', function (Y, NAME) {

/**

Provides the implementation of view transitions for `Y.App.Transitions` in

browsers which support native CSS3 transitions.

@module app

@submodule app-transitions-native

@since 3.5.0

**/

var AppTransitions = Y.App.Transitions;

/**

Provides the implementation of view transitions for `Y.App.Transitions` in

browsers which support native CSS3 transitions.

When this module is used, `Y.App.TransitionsNative` will automatically mix

itself in to `Y.App`.

@class App.TransitionsNative

@extensionfor App

@since 3.5.0

**/

function AppTransitionsNative() {}

AppTransitionsNative.prototype = {

    // -- Protected Properties -------------------------------------------------

    /**

    Whether this app is currently transitioning its `activeView`.

    @property _transitioning

    @type Boolean

    @default false

    @protected

    @since 3.5.0

    **/

    /**

    A queue that holds pending calls to this app's `_uiTransitionActiveView()`

    method.

    @property _viewTransitionQueue

    @type Array

    @default []

    @protected

    @since 3.5.0

    **/

    // -- Lifecycle Methods ----------------------------------------------------

    initializer: function () {

        this._transitioning       = false;

        this._viewTransitionQueue = [];

        // TODO: Consider the AOP approach that `Plugin.WidgetAnim` uses.

        Y.Do.before(this._queueActiveView, this, '_uiSetActiveView');

    },

    // -- Protected Methods ----------------------------------------------------

    /**

    Dequeues any pending calls to `_uiTransitionActiveView()`.

    **Note:** When there is more than one queued transition, only the most

    recent `activeView` change will be visually transitioned, while the others

    will have their `transition` option overridden to `false`.

    @method _dequeueActiveView

    @protected

    @since 3.5.0

    **/

    _dequeueActiveView: function () {

        var queue      = this._viewTransitionQueue,

            transition = queue.shift(),

            options;

        if (transition) {

            // When items are still left in the queue, override the transition

            // so it does not run.

            if (queue.length) {

                // Overrides `transition` option and splices in the new options.

                options = Y.merge(transition[2], {transition: false});

                transition.splice(2, 1, options);

            }

            this._uiTransitionActiveView.apply(this, transition);

        }

    },

    /**

    Returns an object containing a named fx for both `viewIn` and `viewOut`

    based on the relationship between the specified `newView` and `oldView`.

    @method _getFx

    @param {View} newView The view being transitioned-in.

    @param {View} oldView The view being transitioned-out.

    @param {String} [transition] The preferred transition to use.

    @return {Object} An object containing a named fx for both `viewIn` and

        `viewOut`.

    @protected

    @since 3.5.0

    **/

    _getFx: function (newView, oldView, transition) {

        var fx          = AppTransitions.FX,

            transitions = this.get('transitions');

        if (transition === false || !transitions) {

            return null;

        }

        if (transition) {

            return fx[transition];

        }

        if (this._isChildView(newView, oldView)) {

            return fx[transitions.toChild];

        }

        if (this._isParentView(newView, oldView)) {

            return fx[transitions.toParent];

        }

        return fx[transitions.navigate];

    },

    /**

    Queues calls to `_uiTransitionActiveView()` to make sure a currently running

    transition isn't interrupted.

    **Note:** This method prevents the default `_uiSetActiveView()` method from

    running.

    @method _queueActiveView

    @protected

    @since 3.5.0

    **/

    _queueActiveView: function () {

        var args = Y.Array(arguments, 0, true);

        this._viewTransitionQueue.push(args);

        if (!this._transitioning) {

            this._dequeueActiveView();

        }

        return new Y.Do.Prevent();

    },

    /**

    Performs the actual change of this app's `activeView` by visually

    transitioning between the `newView` and `oldView` using any specified

    `options`.

    The `newView` is attached to the app by rendering it to the `viewContainer`,

    and making this app a bubble target of its events.

    The `oldView` is detached from the app by removing it from the

    `viewContainer`, and removing this app as a bubble target for its events.

    The `oldView` will either be preserved or properly destroyed.

    **Note:** This method overrides `_uiSetActiveView()` and provides all of its

    functionality plus supports visual transitions. Also, the `activeView`

    attribute is read-only and can be changed by calling the `showView()`

    method.

    @method _uiTransitionActiveView

    @param {View} newView The View which is now this app's `activeView`.

    @param {View} [oldView] The View which was this app's `activeView`.

    @param {Object} [options] Optional object containing any of the following

        properties:

      @param {Function} [options.callback] Optional callback function to call

        after new `activeView` is ready to use, the function will be passed:

          @param {View} options.callback.view A reference to the new

            `activeView`.

      @param {Boolean} [options.prepend=false] Whether the `view` should be

        prepended instead of appended to the `viewContainer`.

      @param {Boolean} [options.render] Whether the `view` should be rendered.

        **Note:** If no value is specified, a view instance will only be

        rendered if it's newly created by this method.

      @param {Boolean|String} [options.transition] Optional transition override.

        A transition can be specified which will override the default, or

        `false` for no transition.

      @param {Boolean} [options.update=false] Whether an existing view should

        have its attributes updated by passing the `config` object to its

        `setAttrs()` method. **Note:** This option does not have an effect if

        the `view` instance is created as a result of calling this method.

    @protected

    @since 3.5.0

    **/

    _uiTransitionActiveView: function (newView, oldView, options) {

        options || (options = {});

        var callback = options.callback,

            container, transitioning, isChild, isParent, prepend,

            fx, fxConfig, transitions;

        // Quits early when to new and old views are the same.

        if (newView === oldView) {

            callback && callback.call(this, newView);

            this._transitioning = false;

            return this._dequeueActiveView();

        }

        fx       = this._getFx(newView, oldView, options.transition);

        isChild  = this._isChildView(newView, oldView);

        isParent = !isChild && this._isParentView(newView, oldView);

        prepend  = !!options.prepend || isParent;

        // Preforms simply attach/detach of the new and old view respectively

        // when there's no transition to perform.

        if (!fx) {

            this._attachView(newView, prepend);

            this._detachView(oldView);

            callback && callback.call(this, newView);

            this._transitioning = false;

            return this._dequeueActiveView();

        }

        this._transitioning = true;

        container     = this.get('container');

        transitioning = Y.App.CLASS_NAMES.transitioning;

        container.addClass(transitioning);

        this._attachView(newView, prepend);

        // Called when view transitions completed, if none were added this will

        // run right away.

        function complete() {

            this._detachView(oldView);

            container.removeClass(transitioning);

            callback && callback.call(this, newView);

            this._transitioning = false;

            return this._dequeueActiveView();

        }

        // Setup a new stack to run the view transitions in parallel.

        transitions = new Y.Parallel({context: this});

        fxConfig    = {

            crossView: !!oldView && !!newView,

            prepended: prepend

        };

        // Transition the new view first to prevent a gap when sliding.

        if (newView && fx.viewIn) {

            newView.get('container')

                .transition(fx.viewIn, fxConfig, transitions.add());

        }

        if (oldView && fx.viewOut) {

            oldView.get('container')

                .transition(fx.viewOut, fxConfig, transitions.add());

        }

        transitions.done(complete);

    }

};

// -- Transition fx ------------------------------------------------------------

Y.mix(Y.Transition.fx, {

    'app:fadeIn': {

        opacity : 1,

        duration: 0.3,

        on: {

            start: function (data) {

                var styles = {opacity: 0},

                    config = data.config;

                if (config.crossView && !config.prepended) {

                    styles.transform = 'translateX(-100%)';

                }

                this.setStyles(styles);

            },

            end: function () {

                this.setStyle('transform', 'translateX(0)');

            }

        }

    },

    'app:fadeOut': {

        opacity : 0,

        duration: 0.3,

        on: {

            start: function (data) {

                var styles = {opacity: 1},

                    config = data.config;

                if (config.crossView && config.prepended) {

                    styles.transform = 'translateX(-100%)';

                }

                this.setStyles(styles);

            },

            end: function () {

                this.setStyle('transform', 'translateX(0)');

            }

        }

    },

    'app:slideLeft': {

        duration : 0.3,

        transform: 'translateX(-100%)',

        on: {

            start: function () {

                this.setStyles({

                    opacity  : 1,

                    transform: 'translateX(0%)'

                });

            },

            end: function () {

                this.setStyle('transform', 'translateX(0)');

            }

        }

    },

    'app:slideRight': {

        duration : 0.3,

        transform: 'translateX(0)',

        on: {

            start: function () {

                this.setStyles({

                    opacity  : 1,

                    transform: 'translateX(-100%)'

                });

            },

            end: function () {

                this.setStyle('transform', 'translateX(0)');

            }

        }

    }

});

// -- Namespacae ---------------------------------------------------------------

Y.App.TransitionsNative = AppTransitionsNative;

Y.Base.mix(Y.App, [AppTransitionsNative]);

}, '@VERSION@', {"requires": ["app-transitions", "app-transitions-css", "parallel", "transition"]});