Type.registerNamespace('Sys.Extended.UI.Animation');

Sys.Extended.UI.Animation.UpdatePanelAnimationBehavior = function(element) {
    // Play animations just before and just after an UpdatePanel updates
    // "element" - updatePanel associated with the behavior
    Sys.Extended.UI.Animation.UpdatePanelAnimationBehavior.initializeBase(this, [element]);

    // Generic animation behaviors that automatically build animations from JSON descriptions
    this._onUpdating = new Sys.Extended.UI.Animation.GenericAnimationBehavior(element);
    this._onUpdated = new Sys.Extended.UI.Animation.GenericAnimationBehavior(element);

    this._postBackPending = null;
    this._pageLoadedHandler = null;
    this._alwaysFinishOnUpdatingAnimation = null;
    this._triggerControlsClientID = null;
    this._updatePanelID = "";
    this._updatePanelClientID = "";
    this._childrenAsTriggers = false;
};
Sys.Extended.UI.Animation.UpdatePanelAnimationBehavior.prototype = {
    initialize: function() {
        Sys.Extended.UI.Animation.UpdatePanelAnimationBehavior.callBaseMethod(this, 'initialize');

        // Wrap the UpdatePanel in another div (or span) that we'll do the animation with
        var element = this.get_element();
        var parentDiv = document.createElement(element.tagName);
        element.parentNode.insertBefore(parentDiv, element);
        parentDiv.appendChild(element);

        // Move the behavior from the UpdatePanel to the new parent div
        Array.remove(element._behaviors, this);
        Array.remove(element._behaviors, this._onUpdating);
        Array.remove(element._behaviors, this._onUpdated);
        if(parentDiv._behaviors) {
            Array.add(parentDiv._behaviors, this);
            Array.add(parentDiv._behaviors, this._onUpdating);
            Array.add(parentDiv._behaviors, this._onUpdated);
        } else {
            parentDiv._behaviors = [this, this._onUpdating, this._onUpdated];
        }
        this._element = this._onUpdating._element = this._onUpdated._element = parentDiv;

        // Initialize the generic animation behaviors
        this._onUpdating.initialize();
        this._onUpdated.initialize();

        // Attach to the beginRequest/pageLoaded events (and we'll get _pageRequestManager
        // from calling registerPartialUpdates)
        this.registerPartialUpdateEvents();
        this._pageLoadedHandler = Function.createDelegate(this, this._pageLoaded);
        this._pageRequestManager.add_pageLoaded(this._pageLoadedHandler);
    },

    dispose: function() {
        // Important: remove event handler before calling base dispose
        // (which will set _pageRequestManager to null)
        if(this._pageRequestManager && this._pageLoadedHandler) {
            this._pageRequestManager.remove_pageLoaded(this._pageLoadedHandler);
            this._pageLoadedHandler = null;
        }

        Sys.Extended.UI.Animation.UpdatePanelAnimationBehavior.callBaseMethod(this, 'dispose');
    },

    _partialUpdateBeginRequest: function(sender, beginRequestEventArgs) {
        // Method that will be called when a partial update (via an UpdatePanel) begins,
        // if registerPartialUpdateEvents() has been called.
        // "sender" - sender
        // "beginRequestEventArgs" - event arguments
        Sys.Extended.UI.Animation.UpdatePanelAnimationBehavior.callBaseMethod(this, '_partialUpdateBeginRequest', [sender, beginRequestEventArgs]);

        if(!this._postBackPending) {
            if(this._isTriggeredByTriggerControl(beginRequestEventArgs._postBackElement.id)
                || this._isTriggeredByChildControl(sender, beginRequestEventArgs)) {                    
                this._postBackPending = true;
                this._onUpdated.quit();
                this._onUpdating.play();
            }
        }
    },

    _isTriggeredByTriggerControl: function(postBackElementID) {
        return this._triggerControlsClientID.length 
            && this._triggerControlsClientID.indexOf(postBackElementID) != -1;
    },

    _isTriggeredByChildControl: function (sender, beginRequestEventArgs) {
        if(!this.get_childrenAsTriggers())
            return false;

        if(!beginRequestEventArgs._updatePanelsToUpdate)
            return false;

        if(beginRequestEventArgs._updatePanelsToUpdate.indexOf(this.get_updatePanelID()) === -1)
            return false;

        var panelIndex = sender._updatePanelIDs.indexOf(this.get_updatePanelID());

        if(!sender._updatePanelHasChildrenAsTriggers[panelIndex])
            return false;

        var postBackElement = document.getElementById(beginRequestEventArgs._postBackElement.id);
        return postBackElement.parentElement.id === this.get_updatePanelClientID();
    },

    _pageLoaded: function(sender, args) {
        // Method that will be called when a partial update (via an UpdatePanel) finishes
        // "sender" - sender
        // "args" - event arguments
        if(this._postBackPending) {
            this._postBackPending = false;

            var element = this.get_element();
            var panels = args.get_panelsUpdated();
            for(var i = 0; i < panels.length; i++) {
                if(panels[i].parentNode == element) {
                    if(this._alwaysFinishOnUpdatingAnimation) {
                        this._tryAndStopOnUpdating();
                    }
                    else {
                        this._onUpdating.quit();
                        this._onUpdated.play();
                    }
                    break;
                }
            }
        }
    },

    _tryAndStopOnUpdating: function() {
        if(this._onUpdating.get_animation().get_isPlaying()) {
            var context = this;
            window.setTimeout(function() { context._tryAndStopOnUpdating.apply(context); }, 200);
        }
        else {
            this._onUpdating.quit();
            this._onUpdated.play();
        }
    },

    /// <summary>
    /// Generic animation played as when any UpdatePanel begins updating
    /// </summary>
    /// <getter>get_onUpdating</getter>
    /// <setter>set_onUpdating</setter>
    /// <member name="cP:AjaxControlToolkit.UpdatePanelAnimationExtender.onUpdating" />
    get_onUpdating: function() {
        return this._onUpdating.get_json();
    },
    set_onUpdating: function(value) {
        this._onUpdating.set_json(value);
        this.raisePropertyChanged('onUpdating');
    },

    get_OnUpdating: function() {
        Sys.Extended.Deprecated("get_OnUpdating()", "get_onUpdating()");
        return this.get_onUpdating();
    },
    set_OnUpdating: function(value) {
        Sys.Extended.Deprecated("set_OnUpdating(value)", "set_onUpdating(value)");
        this.set_onUpdating();
    },

    /// <summary>
    /// Generic OnUpdating Animation's behavior
    /// </summary>
    /// <getter>get_onUpdatingBehavior</getter>
    /// <member name="cP:AjaxControlToolkit.UpdatePanelAnimationExtender.onUpdatingBehavior" />
    get_onUpdatingBehavior: function() {
        return this._onUpdating;
    },
    get_OnUpdatingBehavior: function() {
        Sys.Extended.Deprecated("get_OnUpdatingBehavior()", "get_onUpdatingBehavior()");
        return this.get_onUpdatingBehavior();
    },

    /// <summary>
    /// Generic animation played after the UpdatePanel has finished updating
    /// (but only if the UpdatePanel was changed)
    /// </summary>
    /// <getter>get_onUpdated</getter>
    /// <setter>set_onUpdated</setter>
    /// <member name="cP:AjaxControlToolkit.UpdatePanelAnimationExtender.onUpdated" />
    get_onUpdated: function() {
        return this._onUpdated.get_json();
    },
    set_onUpdated: function(value) {
        this._onUpdated.set_json(value);
        this.raisePropertyChanged('onUpdated');
    },

    get_OnUpdated: function() {
        Sys.Extended.Deprecated("get_OnUpdated()", "get_onUpdated()");
        return this.get_onUpdated();
    },
    set_OnUpdated: function(value) {
        Sys.Extended.Deprecated("set_OnUpdated(value)", "set_onUpdated(value)");
        this.set_onUpdated(value);
    },

    /// <summary>
    /// Generic OnUpdated Animation's behavior
    /// </summary>
    /// <getter>get_onUpdatedBehavior</getter>
    /// <member name="cP:AjaxControlToolkit.UpdatePanelAnimationExtender.onUpdatedBehavior" />
    get_onUpdatedBehavior: function() {
        return this._onUpdated;
    },
    get_OnUpdatedBehavior: function() {
        Sys.Extended.Deprecated("get_OnUpdatedBehavior()", "get_onUpdatedBehavior()");
        return this.get_onUpdatedBehavior();
    },

    /// <summary>
    /// An optional property that makes sure the OnUpdated event will fire
    /// only after the onUpdating event is completed
    /// </summary>
    /// <getter>get_alwaysFinishOnUpdatingAnimation</getter>
    /// <setter>set_alwaysFinishOnUpdatingAnimation</setter>
    /// <member name="cP:AjaxControlToolkit.UpdatePanelAnimationExtender.alwaysFinishOnUpdatingAnimation" />
    get_alwaysFinishOnUpdatingAnimation: function() {
        // Indicates whether to always finish play the OnUpating animation before the
        // OnUpdated animation starts.
        return this._alwaysFinishOnUpdatingAnimation;
    },
    set_alwaysFinishOnUpdatingAnimation: function(value) {
        if(this._alwaysFinishOnUpdatingAnimation != value) {
            this._alwaysFinishOnUpdatingAnimation = value;
            this.raisePropertyChanged('alwaysFinishOnUpdatingAnimation');
        }
    },

    get_AlwaysFinishOnUpdatingAnimation: function() {
        Sys.Extended.Deprecated("get_AlwaysFinishOnUpdatingAnimation()", "get_alwaysFinishOnUpdatingAnimation()");
        return this.get_alwaysFinishOnUpdatingAnimation();
    },
    set_AlwaysFinishOnUpdatingAnimation: function(value) {
        Sys.Extended.Deprecated("set_AlwaysFinishOnUpdatingAnimation(value)", "set_alwaysFinishOnUpdatingAnimation(value)");
        this.set_alwaysFinishOnUpdatingAnimation(value);
    },

    /// <summary>
    /// ClientIDs of the trigger controls
    /// </summary>
    /// <getter>get_triggerControlsClientID</getter>
    /// <setter>set_triggerControlsClientID</setter>
    /// <member name="cP:AjaxControlToolkit.UpdatePanelAnimationExtender.triggerControlsClientID" />
    get_triggerControlsClientID: function() {
        return this._triggerControlsClientID;
    },
    set_triggerControlsClientID: function(value) {
        if(this._triggerControlsClientID != value) {
            this._triggerControlsClientID = value;
            this.raisePropertyChanged('triggerControlsClientID');
        }
    },

    get_TriggerControlsClientID: function() {
        Sys.Extended.Deprecated("get_TriggerControlsClientID()", "get_triggerControlsClientID()");
        return this._triggerControlsClientID;
    },
    set_TriggerControlsClientID: function(value) {
        Sys.Extended.Deprecated("set_TriggerControlsClientID(value)", "set_triggerControlsClientID(value)");
        this.set_triggerControlsClientID(value);
    },

    /// <summary>
    /// ID of the target update panel
    /// </summary>
    /// <getter>get_updatePanelID</getter>
    /// <setter>set_updatePanelID</setter>
    /// <member name="cP:AjaxControlToolkit.UpdatePanelAnimationExtender.updatePanelID" />
    get_updatePanelID: function () {
        return this._updatePanelID;
    },
    set_updatePanelID: function (value) {
        if(this._updatePanelID != value) {
            this._updatePanelID = value;
            this.raisePropertyChanged('updatePanelID');
        }
    },

    /// <summary>
    /// Client ID of the target update panel
    /// </summary>
    /// <getter>get_updatePanelClientID</getter>
    /// <setter>set_updatePanelClientID</setter>
    /// <member name="cP:AjaxControlToolkit.UpdatePanelAnimationExtender.updatePanelClientID" />
    get_updatePanelClientID: function () {
        return this._updatePanelClientID;
    },
    set_updatePanelClientID: function (value) {
        if(this._updatePanelClientID != value) {
            this._updatePanelClientID = value;
            this.raisePropertyChanged('updatePanelClientID');
        }
    },

    /// <summary>
    /// An optional property that enables update panel animation
    /// if the postback is caused by a panel's immediate children
    /// </summary>
    /// <getter>get_childrenAsTriggers</getter>
    /// <setter>set_childrenAsTriggers</setter>
    /// <member name="cP:AjaxControlToolkit.UpdatePanelAnimationExtender.childrenAsTriggers" />
    get_childrenAsTriggers: function () {
        return this._childrenAsTriggers;
    },
    set_childrenAsTriggers: function (value) {
        if(this._childrenAsTriggers != value) {
            this._childrenAsTriggers = value;
            this.raisePropertyChanged('childrenAsTriggers');
        }
    }
};
Sys.Extended.UI.Animation.UpdatePanelAnimationBehavior.registerClass('Sys.Extended.UI.Animation.UpdatePanelAnimationBehavior', Sys.Extended.UI.BehaviorBase);