//! DanceEdge.debug.js
//

(function() {
function executeScript() {

Type.registerNamespace('DanceEdge.Async');

////////////////////////////////////////////////////////////////////////////////
// DanceEdge.Async.IAsyncResult

DanceEdge.Async.IAsyncResult = function() { 
};
DanceEdge.Async.IAsyncResult.prototype = {
    get_asyncState : null,
    get_completedSynchronously : null,
    get_isCompleted : null
}
DanceEdge.Async.IAsyncResult.registerInterface('DanceEdge.Async.IAsyncResult');


////////////////////////////////////////////////////////////////////////////////
// DanceEdge.Async.AsyncResult

DanceEdge.Async.AsyncResult = function DanceEdge_Async_AsyncResult(callback, asyncState) {
    /// <summary>
    /// AsyncResult class.
    /// </summary>
    /// <param name="callback" type="DanceEdge.Async.AsyncCallback">
    /// </param>
    /// <param name="asyncState" type="Object">
    /// </param>
    /// <field name="_asyncState" type="Object">
    /// </field>
    /// <field name="_callback" type="DanceEdge.Async.AsyncCallback">
    /// </field>
    /// <field name="_completedSynchronously" type="Boolean">
    /// </field>
    /// <field name="_isCompleted" type="Boolean">
    /// </field>
    /// <field name="_result" type="Object">
    /// </field>
    this.set_asyncState(asyncState);
    this.set_callback(callback);
}
DanceEdge.Async.AsyncResult.prototype = {
    _asyncState: null,
    _callback: null,
    _completedSynchronously: false,
    _isCompleted: false,
    _result: null,
    
    get_asyncState: function DanceEdge_Async_AsyncResult$get_asyncState() {
        /// <summary>
        /// State associated with this AsyncState.
        /// </summary>
        /// <value type="Object"></value>
        return this._asyncState;
    },
    set_asyncState: function DanceEdge_Async_AsyncResult$set_asyncState(value) {
        /// <summary>
        /// State associated with this AsyncState.
        /// </summary>
        /// <value type="Object"></value>
        this._asyncState = value;
        return value;
    },
    
    get_callback: function DanceEdge_Async_AsyncResult$get_callback() {
        /// <summary>
        /// Callback.
        /// </summary>
        /// <value type="DanceEdge.Async.AsyncCallback"></value>
        return this._callback;
    },
    set_callback: function DanceEdge_Async_AsyncResult$set_callback(value) {
        /// <summary>
        /// Callback.
        /// </summary>
        /// <value type="DanceEdge.Async.AsyncCallback"></value>
        this._callback = value;
        return value;
    },
    
    get_completedSynchronously: function DanceEdge_Async_AsyncResult$get_completedSynchronously() {
        /// <summary>
        /// True if the operation completed synchronously.
        /// </summary>
        /// <value type="Boolean"></value>
        return this._completedSynchronously;
    },
    set_completedSynchronously: function DanceEdge_Async_AsyncResult$set_completedSynchronously(value) {
        /// <summary>
        /// True if the operation completed synchronously.
        /// </summary>
        /// <value type="Boolean"></value>
        this._completedSynchronously = value;
        return value;
    },
    
    get_isCompleted: function DanceEdge_Async_AsyncResult$get_isCompleted() {
        /// <summary>
        /// True if the request is completed.
        /// </summary>
        /// <value type="Boolean"></value>
        return this._isCompleted;
    },
    set_isCompleted: function DanceEdge_Async_AsyncResult$set_isCompleted(value) {
        /// <summary>
        /// True if the request is completed.
        /// </summary>
        /// <value type="Boolean"></value>
        this._isCompleted = value;
        return value;
    },
    
    get__result: function DanceEdge_Async_AsyncResult$get__result() {
        /// <summary>
        /// The result of the request.
        /// </summary>
        /// <value type="Object"></value>
        return this._result;
    },
    set__result: function DanceEdge_Async_AsyncResult$set__result(value) {
        /// <summary>
        /// The result of the request.
        /// </summary>
        /// <value type="Object"></value>
        this._result = value;
        return value;
    }
}


Type.registerNamespace('DanceEdge');

////////////////////////////////////////////////////////////////////////////////
// DanceEdge._parseState

DanceEdge._parseState = function() { 
    /// <field name="text" type="Number" integer="true" static="true">
    /// </field>
    /// <field name="tag" type="Number" integer="true" static="true">
    /// </field>
};
DanceEdge._parseState.prototype = {
    text: 0, 
    tag: 1
}
DanceEdge._parseState.registerEnum('DanceEdge._parseState', false);


////////////////////////////////////////////////////////////////////////////////
// DanceEdge._constants

DanceEdge._constants = function DanceEdge__constants() {
    /// <field name="_imageBase" type="String" static="true">
    /// </field>
    /// <field name="_headerTemplateName" type="String" static="true">
    /// </field>
    /// <field name="_topNavItemTemplateName" type="String" static="true">
    /// </field>
    /// <field name="_secondaryNavItemTemplateName" type="String" static="true">
    /// </field>
    /// <field name="_backgroundImageContainer" type="String" static="true">
    /// </field>
    /// <field name="_headerContainer" type="String" static="true">
    /// </field>
    /// <field name="_topNavContainer" type="String" static="true">
    /// </field>
    /// <field name="_topNavListClass" type="String" static="true">
    /// </field>
    /// <field name="_secondaryNavContainer" type="String" static="true">
    /// </field>
    /// <field name="_secondaryNavListClass" type="String" static="true">
    /// </field>
    /// <field name="_navSelectedClass" type="String" static="true">
    /// </field>
    /// <field name="_contentContainer" type="String" static="true">
    /// </field>
    /// <field name="_titleBase" type="String" static="true">
    /// </field>
}


////////////////////////////////////////////////////////////////////////////////
// DanceEdge.Globals

DanceEdge.Globals = function DanceEdge_Globals() {
    /// <field name="_maxWordLength" type="Number" integer="true" static="true">
    /// </field>
}
DanceEdge.Globals.tmplEval = function DanceEdge_Globals$tmplEval(expression, data) {
    /// <summary>
    /// This method assumes that we are making a series of property calls finished with a method invokation.
    /// </summary>
    /// <param name="expression" type="String">
    /// </param>
    /// <param name="data" type="Object">
    /// </param>
    /// <returns type="Object"></returns>
    var parts = expression.split('.');
    var current = data;
    for (var i = 0; i < parts.length - 1; i++) {
        current = current[parts[0]];
    }
    return current[parts[parts.length - 1]](null);
}
DanceEdge.Globals.getArticleImageUrl = function DanceEdge_Globals$getArticleImageUrl(expression, data) {
    /// <param name="expression" type="String">
    /// </param>
    /// <param name="data" type="Object">
    /// </param>
    /// <returns type="String"></returns>
    var value = DanceEdge.Globals.tmplEval(expression, data);
    return DanceEdge.DanceEdgeApp.getArticleImageUrl(DanceEdge.Globals.tmplEval(expression, data));
}
DanceEdge.Globals.htmlStringLengthGreaterThan = function DanceEdge_Globals$htmlStringLengthGreaterThan(expression, data, comparisonLength) {
    /// <summary>
    /// Determine the length of the html string (ignoring tags).
    /// </summary>
    /// <param name="expression" type="String">
    /// </param>
    /// <param name="data" type="Object">
    /// </param>
    /// <param name="comparisonLength" type="Number" integer="true">
    /// </param>
    /// <returns type="Boolean"></returns>
    var html = DanceEdge.Globals.tmplEval(expression, data);
    var length = 0;
    var tag = false;
    for (var i = 0; i < html.length; i++) {
        var current = html.charAt(i);
        if (tag) {
            if (current !== '>') {
                continue;
            }
            else {
                tag = false;
            }
        }
        else if (html.charAt(i) === '<') {
            tag = true;
        }
        else {
            length++;
        }
    }
    return length > comparisonLength;
}
DanceEdge.Globals.htmlSubstring = function DanceEdge_Globals$htmlSubstring(expression, data, comparisonLength) {
    /// <summary>
    /// Return the well formatted html substring of length 'length' (ignoring tags in length calculations).
    /// </summary>
    /// <param name="expression" type="String">
    /// </param>
    /// <param name="data" type="Object">
    /// </param>
    /// <param name="comparisonLength" type="Number" integer="true">
    /// </param>
    /// <returns type="String"></returns>
    var html = DanceEdge.Globals.tmplEval(expression, data);
    if (html.length <= comparisonLength) {
        return html;
    }
    var openTags = [];
    var state = DanceEdge._parseState.text;
    var sb = new ss.StringBuilder();
    var length = 0;
    var tagStart = 0;
    for (var i = 0; i < html.length && length < comparisonLength; i++) {
        var current = html.charAt(i);
        sb.append(current);
        switch (state) {
            case DanceEdge._parseState.text:
                if (current === '<') {
                    state = DanceEdge._parseState.tag;
                    tagStart = i;
                }
                else {
                    length++;
                    if (length >= comparisonLength) {
                        sb.append(DanceEdge.Globals._finishWordAndCloseTags(html, i, openTags));
                    }
                }
                break;
            case DanceEdge._parseState.tag:
                if (current === '>') {
                    var isClosingTag = (html.charAt(tagStart + 1) === '/');
                    var isCollapsedTag = (html.charAt(i - 1) === '/');
                    if (isClosingTag) {
                        ss.Debug.assert(html.substring(tagStart + 2, i) === openTags.peek());
                        openTags.pop();
                    }
                    else if (!isCollapsedTag) {
                        openTags.push(html.substring(tagStart + 1, i));
                    }
                    state = DanceEdge._parseState.text;
                }
                break;
        }
    }
    return sb.toString();
}
DanceEdge.Globals._finishWordAndCloseTags = function DanceEdge_Globals$_finishWordAndCloseTags(html, currentIndex, openTags) {
    /// <param name="html" type="String">
    /// </param>
    /// <param name="currentIndex" type="Number" integer="true">
    /// </param>
    /// <param name="openTags" type="Array">
    /// </param>
    /// <returns type="String"></returns>
    ss.Debug.assert(currentIndex < html.length);
    if (currentIndex >= html.length) {
        return '';
    }
    var sb = new ss.StringBuilder();
    if (!DanceEdge.Globals._isWhiteSpace(html.charAt(currentIndex))) {
        var endIndex = -1;
        for (var i = currentIndex + 1; i < html.length && (currentIndex - i) <= DanceEdge.Globals._maxWordLength; i++) {
            if (DanceEdge.Globals._isWhiteSpace(html.charAt(i))) {
                endIndex = i;
                break;
            }
        }
        if (endIndex === -1) {
            sb.append(html.substr(currentIndex + 1, DanceEdge.Globals._maxWordLength));
        }
        else {
            sb.append(html.substring(currentIndex + 1, endIndex));
        }
    }
    sb.append('...');
    while (openTags.length > 0) {
        sb.append(String.format('</{0}>', openTags.pop()));
    }
    return sb.toString();
}
DanceEdge.Globals._isWhiteSpace = function DanceEdge_Globals$_isWhiteSpace(c) {
    /// <param name="c" type="String">
    /// </param>
    /// <returns type="Boolean"></returns>
    return c === ' ' || c === '\t' || c === '\r' || c === '\n';
}


////////////////////////////////////////////////////////////////////////////////
// DanceEdge.NavigationState

DanceEdge.NavigationState = function DanceEdge_NavigationState() {
    /// <field name="section" type="String">
    /// </field>
    /// <field name="subsection" type="String">
    /// </field>
    /// <field name="article" type="String">
    /// </field>
    this.section = '';
    this.subsection = '';
    this.article = '';
}
DanceEdge.NavigationState.clone = function DanceEdge_NavigationState$clone(original) {
    /// <summary>
    /// I am making this a static method because I don't want it to be serialized.
    /// </summary>
    /// <param name="original" type="DanceEdge.NavigationState">
    /// </param>
    /// <returns type="DanceEdge.NavigationState"></returns>
    var clone = new DanceEdge.NavigationState();
    clone.section = original.section;
    clone.subsection = original.subsection;
    clone.article = original.article;
    return clone;
}
DanceEdge.NavigationState.getArticle = function DanceEdge_NavigationState$getArticle(siteDefinition, state) {
    /// <summary>
    /// Return the article for the given NavigationState and article id.
    /// </summary>
    /// <param name="siteDefinition" type="DanceEdge.DataModel.SiteDefinition">
    /// </param>
    /// <param name="state" type="DanceEdge.NavigationState">
    /// </param>
    /// <returns type="DanceEdge.DataModel.Article"></returns>
    var section = (!String.isNullOrEmpty(state.subsection)) ? DanceEdge.DataModel.Section.getSubSectionFromSection(siteDefinition, state.section, state.subsection) : siteDefinition.getSectionById(state.section);
    return section.getArticleById(state.article);
}
DanceEdge.NavigationState.getBaseState = function DanceEdge_NavigationState$getBaseState(siteDefinition) {
    /// <param name="siteDefinition" type="DanceEdge.DataModel.SiteDefinition">
    /// </param>
    /// <returns type="DanceEdge.NavigationState"></returns>
    var newState = new DanceEdge.NavigationState();
    var section = siteDefinition.getSectionById(siteDefinition.get_defaultSectionId());
    newState.section = section.get_id();
    newState.subsection = (String.isNullOrEmpty(section.get_defaultSubsectionId())) ? '' : section.get_defaultSubsectionId();
    return newState;
}
DanceEdge.NavigationState.prototype = {
    section: null,
    subsection: null,
    article: null
}


////////////////////////////////////////////////////////////////////////////////
// DanceEdge.DanceEdgeApp

DanceEdge.DanceEdgeApp = function DanceEdge_DanceEdgeApp() {
    /// <field name="_animationLength" type="Number" integer="true" static="true">
    /// </field>
    /// <field name="_headerAnimationLength" type="Number" integer="true" static="true">
    /// </field>
    /// <field name="_previousIndex" type="String" static="true">
    /// </field>
    /// <field name="_navState" type="DanceEdge.NavigationState" static="true">
    /// </field>
    /// <field name="_siteDefinition" type="DanceEdge.DataModel.SiteDefinition" static="true">
    /// </field>
}
DanceEdge.DanceEdgeApp.main = function DanceEdge_DanceEdgeApp$main(args) {
    /// <param name="args" type="Object">
    /// </param>
    if (window.location.href.toLowerCase().indexOf('camillesdanceedge.com') === -1 && window.location.href.toLowerCase().indexOf('localhost') === -1) {
        window.location.href = 'http://www.camillesdanceedge.com';
    }
    var requestManager = new DanceEdge.Net.RequestManager(document.URL.substring(0, document.URL.lastIndexOf('/')));
    DanceEdge.DataModel.DataModelUtils.set_requestManager(requestManager);
    $(window).bind('hashchange', DanceEdge.DanceEdgeApp._hashChanged);
    DanceEdge.DataModel.SiteDefinition.beginGet(DanceEdge.DanceEdgeApp._getSiteDefinitionCallback, null);
}
DanceEdge.DanceEdgeApp._hashChanged = function DanceEdge_DanceEdgeApp$_hashChanged(e) {
    /// <summary>
    /// Called when the hash is changed on the url.
    /// </summary>
    /// <param name="e" type="jQueryEvent">
    /// </param>
    var newState;
    var navigated = false;
    if (window.location.href.lastIndexOf('#') !== -1) {
        newState = $.bbq.getState();
        if (ss.isNullOrUndefined(newState.article) || ss.isNullOrUndefined(newState.subsection) || ss.isNullOrUndefined(newState.section)) {
            newState = DanceEdge.NavigationState.getBaseState(DanceEdge.DanceEdgeApp._siteDefinition);
            $.bbq.pushState(newState, 2);
            return;
        }
        if (!String.equals(newState.article, DanceEdge.DanceEdgeApp._navState.article, true)) {
            if (!String.isNullOrEmpty(newState.article)) {
                var articleContent = DanceEdge.DataModel.ArticleContentCache.getArticleContentById(newState.article);
                if (articleContent == null) {
                    DanceEdge.DataModel.ArticleContentCache.beginGetSectionArticles((String.isNullOrEmpty(newState.subsection)) ? newState.section : newState.subsection, function(asyncResult) {
                        DanceEdge.DanceEdgeApp._navigateArticlePrivate(DanceEdge.DataModel.ArticleContentCache.getArticleContentById(newState.article));
                    }, null);
                }
                else {
                    DanceEdge.DanceEdgeApp._navigateArticlePrivate(articleContent);
                }
                navigated = true;
            }
            else {
                DanceEdge.DanceEdgeApp._navigateSectionPrivate(newState);
                navigated = true;
            }
        }
        else if (!String.equals(newState.subsection, DanceEdge.DanceEdgeApp._navState.subsection, true) || !String.equals(newState.section, DanceEdge.DanceEdgeApp._navState.section, true)) {
            DanceEdge.DanceEdgeApp._navigateSectionPrivate(newState);
            navigated = true;
        }
    }
    else {
        newState = DanceEdge.NavigationState.getBaseState(DanceEdge.DanceEdgeApp._siteDefinition);
        DanceEdge.DanceEdgeApp._navigateSectionPrivate(newState);
        navigated = true;
    }
    if (navigated) {
        DanceEdge.DanceEdgeApp._updateBannerImage();
    }
}
DanceEdge.DanceEdgeApp.getArticleImageUrl = function DanceEdge_DanceEdgeApp$getArticleImageUrl(url) {
    /// <param name="url" type="String">
    /// </param>
    /// <returns type="String"></returns>
    return DanceEdge.DataModel.ArticleContent.getImageUrl(url, DanceEdge.DanceEdgeApp._siteDefinition);
}
DanceEdge.DanceEdgeApp._updateBannerImage = function DanceEdge_DanceEdgeApp$_updateBannerImage() {
    var backgroundImage = $('#' + DanceEdge.DanceEdgeApp._siteDefinition.get_settings()[DanceEdge._constants._headerContainer]);
    var backgroundImageElement = backgroundImage.get(0);
    var animateIn = function() {
        var index = 0;
        var previousIndex = backgroundImageElement[DanceEdge.DanceEdgeApp._previousIndex];
        if (ss.isNullOrUndefined(previousIndex)) {
            index = Math.truncate((Math.random() * 10000)) % DanceEdge.DanceEdgeApp._siteDefinition.get_bannerImages().length;
        }
        else {
            index = previousIndex;
            index = (index + 1) % DanceEdge.DanceEdgeApp._siteDefinition.get_bannerImages().length;
        }
        backgroundImageElement[DanceEdge.DanceEdgeApp._previousIndex] = index;
        var image = DanceEdge.DanceEdgeApp._siteDefinition.get_bannerImages()[index];
        backgroundImageElement.style.backgroundImage = 'url(' + image.get_url() + ')';
        backgroundImage.fadeIn(DanceEdge.DanceEdgeApp._headerAnimationLength);
        var headerContainer = $('#' + DanceEdge.DanceEdgeApp._siteDefinition.get_settings()[DanceEdge._constants._headerContainer]);
        headerContainer.get(0).style.color = image.get_headerColor();
    };
    if (!String.isNullOrEmpty(backgroundImageElement.style.backgroundImage)) {
        backgroundImage.fadeOut(DanceEdge.DanceEdgeApp._headerAnimationLength, animateIn);
    }
    else {
        animateIn.invoke();
    }
}
DanceEdge.DanceEdgeApp._getSiteDefinitionCallback = function DanceEdge_DanceEdgeApp$_getSiteDefinitionCallback(result) {
    /// <param name="result" type="DanceEdge.Async.IAsyncResult">
    /// </param>
    DanceEdge.DanceEdgeApp._siteDefinition = DanceEdge.DataModel.SiteDefinition.endGet(result);
    DanceEdge.DanceEdgeApp._navState = new DanceEdge.NavigationState();
    if (DanceEdge.DanceEdgeApp._siteDefinition != null) {
        DanceEdge.DanceEdgeApp._renderSite(DanceEdge.DanceEdgeApp._siteDefinition);
    }
    else {
        DanceEdge.DanceEdgeApp._renderEmptySite();
    }
    DanceEdge.DanceEdgeApp._hashChanged(null);
}
DanceEdge.DanceEdgeApp._renderSite = function DanceEdge_DanceEdgeApp$_renderSite(siteDefinition) {
    /// <summary>
    /// $('#' + DanceEdge.DanceEdgeApp._siteDefinition.get_settings()[DanceEdge._constants._topNavContainer])
    /// Render the site using the SiteDefinition provided.
    /// </summary>
    /// <param name="siteDefinition" type="DanceEdge.DataModel.SiteDefinition">
    /// </param>
    DanceEdge.DanceEdgeApp._renderHeader(siteDefinition);
    DanceEdge.DanceEdgeApp._renderNav(siteDefinition, siteDefinition.get_sections(), DanceEdge._constants._topNavListClass, DanceEdge._constants._topNavItemTemplateName, DanceEdge._constants._topNavContainer, null);
    DanceEdge.DanceEdgeApp._renderFooter(siteDefinition);
}
DanceEdge.DanceEdgeApp._renderHeader = function DanceEdge_DanceEdgeApp$_renderHeader(siteDefinition) {
    /// <param name="siteDefinition" type="DanceEdge.DataModel.SiteDefinition">
    /// </param>
    var settings = siteDefinition.get_settings();
    var headerTemplateName = settings[DanceEdge._constants._headerTemplateName];
    var headerTemplate = $.template(headerTemplateName, $('#' + headerTemplateName).html());
    $('#' + settings[DanceEdge._constants._headerContainer]).append($.tmpl(headerTemplateName, {}));
    window.setTimeout(function() {
        $('#' + 'headerAnimation1').fadeIn(DanceEdge.DanceEdgeApp._headerAnimationLength);
    }, DanceEdge.DanceEdgeApp._headerAnimationLength);
    window.setTimeout(function() {
        $('#' + 'headerAnimation2').fadeIn(DanceEdge.DanceEdgeApp._headerAnimationLength);
    }, DanceEdge.DanceEdgeApp._headerAnimationLength * 2);
    window.setTimeout(function() {
        $('#' + 'headerAnimation3').fadeIn(DanceEdge.DanceEdgeApp._headerAnimationLength);
    }, DanceEdge.DanceEdgeApp._headerAnimationLength * 3);
    window.setTimeout(function() {
        $('#' + 'headerAnimation4').fadeIn(DanceEdge.DanceEdgeApp._headerAnimationLength);
    }, DanceEdge.DanceEdgeApp._headerAnimationLength * 4);
    window.setTimeout(function() {
        $('#' + 'headerAnimation5').fadeIn(DanceEdge.DanceEdgeApp._headerAnimationLength);
    }, DanceEdge.DanceEdgeApp._headerAnimationLength * 5);
    window.setTimeout(function() {
        $('#' + 'headerAnimation6').fadeIn(DanceEdge.DanceEdgeApp._headerAnimationLength);
    }, DanceEdge.DanceEdgeApp._headerAnimationLength * 6);
}
DanceEdge.DanceEdgeApp._renderNav = function DanceEdge_DanceEdgeApp$_renderNav(siteDefinition, sections, navListClassSetting, itemTemplateSetting, container, parent) {
    /// <param name="siteDefinition" type="DanceEdge.DataModel.SiteDefinition">
    /// </param>
    /// <param name="sections" type="Array" elementType="Section">
    /// </param>
    /// <param name="navListClassSetting" type="String">
    /// </param>
    /// <param name="itemTemplateSetting" type="String">
    /// </param>
    /// <param name="container" type="String">
    /// </param>
    /// <param name="parent" type="DanceEdge.DataModel.Section">
    /// </param>
    var subsection = (parent != null);
    var settings = siteDefinition.get_settings();
    var list = $('<ul></ul>', { 'class': settings[navListClassSetting] });
    var itemTemplateName = settings[itemTemplateSetting];
    var itemTemplate = $.template(itemTemplateName, $('#' + itemTemplateName).html());
    sections.forEach(function(section, index, array) {
        var data = {};
        if (subsection) {
            data['Section'] = parent.get_id();
            data['Subsection'] = (section).get_id();
        }
        else {
            data['Section'] = (section).get_id();
            data['Subsection'] = (section).get_defaultSubsectionId();
        }
        data['HighlightId'] = (section).get_id();
        data['Name'] = (section).get_name();
        list.append($.tmpl(itemTemplateName, data));
        if (!subsection && DanceEdge.DanceEdgeApp._navState.section === (section).get_id()) {
            DanceEdge.DanceEdgeApp._renderNav(siteDefinition, (section).get_subSections(), DanceEdge._constants._secondaryNavListClass, DanceEdge._constants._secondaryNavItemTemplateName, DanceEdge._constants._secondaryNavContainer, section);
        }
    });
    var containerObject = $('#' + settings[container]);
    var currentContents = containerObject.contents();
    var animateIn = function() {
        containerObject.append(list);
        list.fadeIn(DanceEdge.DanceEdgeApp._animationLength);
        var current = (subsection) ? DanceEdge.DanceEdgeApp._siteDefinition.getSectionById(DanceEdge.DanceEdgeApp._navState.subsection) : DanceEdge.DanceEdgeApp._siteDefinition.getSectionById(DanceEdge.DanceEdgeApp._navState.section);
        if (current != null) {
            DanceEdge.DanceEdgeApp._highlightNavLink(current, (subsection) ? DanceEdge._constants._secondaryNavContainer : DanceEdge._constants._topNavContainer);
        }
    };
    if (currentContents.length !== 0) {
        containerObject.contents().fadeOut(DanceEdge.DanceEdgeApp._animationLength, function() {
            currentContents.remove();
            animateIn.invoke();
        });
    }
    else {
        animateIn.invoke();
    }
}
DanceEdge.DanceEdgeApp._navigateSectionPrivate = function DanceEdge_DanceEdgeApp$_navigateSectionPrivate(newState) {
    /// <param name="newState" type="DanceEdge.NavigationState">
    /// </param>
    var isSubsection = !String.isNullOrEmpty(newState.subsection);
    if (((!isSubsection && String.equals(DanceEdge.DanceEdgeApp._navState.section, newState.section, true)) || (isSubsection && String.equals(DanceEdge.DanceEdgeApp._navState.subsection, newState.subsection, true))) && String.isNullOrEmpty(DanceEdge.DanceEdgeApp._navState.article)) {
        return;
    }
    var section = DanceEdge.DanceEdgeApp._siteDefinition.getSectionById(newState.section);
    var subsection = null;
    if (isSubsection) {
        subsection = DanceEdge.DanceEdgeApp._siteDefinition.getSectionById(newState.subsection);
    }
    var renderSecondaryNav = !String.equals(DanceEdge.DanceEdgeApp._navState.section, newState.section, true);
    if (renderSecondaryNav) {
        DanceEdge.DanceEdgeApp._renderNav(DanceEdge.DanceEdgeApp._siteDefinition, section.get_subSections(), DanceEdge._constants._secondaryNavListClass, DanceEdge._constants._secondaryNavItemTemplateName, DanceEdge._constants._secondaryNavContainer, section);
    }
    var activeSection = (isSubsection) ? subsection : section;
    DanceEdge.DataModel.ArticleContentCache.beginGetSectionArticles(activeSection.get_id(), DanceEdge.DanceEdgeApp._getArticleContentCallback, activeSection);
    if (!isSubsection) {
        DanceEdge.DanceEdgeApp._navState.section = section.get_id();
        DanceEdge.DanceEdgeApp._navState.subsection = section.get_defaultSubsectionId();
    }
    else {
        DanceEdge.DanceEdgeApp._navState.subsection = section.get_id();
    }
    DanceEdge.DanceEdgeApp._navState = DanceEdge.NavigationState.clone(newState);
    DanceEdge.DanceEdgeApp._navState.article = '';
    DanceEdge.DanceEdgeApp._highlightNavLink(section, DanceEdge._constants._topNavContainer);
    var title = section.get_name();
    if (isSubsection) {
        DanceEdge.DanceEdgeApp._highlightNavLink(subsection, DanceEdge._constants._secondaryNavContainer);
        title += ' - ' + subsection.get_name();
    }
    DanceEdge.DanceEdgeApp._updateTitle(title);
}
DanceEdge.DanceEdgeApp._updateTitle = function DanceEdge_DanceEdgeApp$_updateTitle(titleSuffix) {
    /// <param name="titleSuffix" type="String">
    /// </param>
    document.title = DanceEdge.DanceEdgeApp._siteDefinition.get_settings()[DanceEdge._constants._titleBase] + titleSuffix;
}
DanceEdge.DanceEdgeApp._navigateArticlePrivate = function DanceEdge_DanceEdgeApp$_navigateArticlePrivate(articleContent) {
    /// <param name="articleContent" type="DanceEdge.DataModel.ArticleContent">
    /// </param>
    if (articleContent == null) {
        window.location.href = 'http://www.camillesdanceedge.com';
    }
    var settings = DanceEdge.DanceEdgeApp._siteDefinition.get_settings();
    var contentContainer = $('#' + settings[DanceEdge._constants._contentContainer]);
    var contentTemplateName = articleContent.get_templateId();
    DanceEdge.DanceEdgeApp._navState.article = articleContent.get_id();
    var animateIn = function() {
        var contentTemplate = $.template(contentTemplateName, $('#' + contentTemplateName).html());
        contentContainer.append($.tmpl(contentTemplateName, articleContent));
        contentContainer.contents().fadeIn(DanceEdge.DanceEdgeApp._animationLength);
    };
    if (contentContainer.contents().length !== 0) {
        contentContainer.contents().fadeOut(DanceEdge.DanceEdgeApp._animationLength, function() {
            contentContainer.contents().remove();
            animateIn.invoke();
        });
    }
    else {
        animateIn.invoke();
    }
    DanceEdge.DanceEdgeApp._updateTitle(articleContent.get_title());
}
DanceEdge.DanceEdgeApp._highlightNavLink = function DanceEdge_DanceEdgeApp$_highlightNavLink(active, containerName) {
    /// <param name="active" type="DanceEdge.DataModel.Section">
    /// </param>
    /// <param name="containerName" type="String">
    /// </param>
    var settings = DanceEdge.DanceEdgeApp._siteDefinition.get_settings();
    var navSelectedClass = settings[DanceEdge._constants._navSelectedClass];
    var navItems = $('#' + DanceEdge.DanceEdgeApp._siteDefinition.get_settings()[containerName]).find('li');
    navItems.children('a').removeClass(navSelectedClass);
    navItems.each(function(index, element) {
        var current = $.tmplItem(element);
        if (String.equals(active.get_id(), (current.data)['HighlightId'], false)) {
            $(element).children('a').addClass(navSelectedClass);
        }
    });
}
DanceEdge.DanceEdgeApp._getArticleContentCallback = function DanceEdge_DanceEdgeApp$_getArticleContentCallback(asyncResult) {
    /// <param name="asyncResult" type="DanceEdge.Async.IAsyncResult">
    /// </param>
    var articleContents = DanceEdge.DataModel.ArticleContentCache.endGetSectionArticles(asyncResult);
    var settings = DanceEdge.DanceEdgeApp._siteDefinition.get_settings();
    var contentContainer = $('#' + settings[DanceEdge._constants._contentContainer]);
    var section = asyncResult.get_asyncState();
    var contentTemplateName = section.get_templateId();
    var animateIn = function() {
        if (articleContents.length > 0) {
            var data = {};
            data['Section'] = DanceEdge.DanceEdgeApp._navState.section;
            data['Subsection'] = DanceEdge.DanceEdgeApp._navState.subsection;
            data['Article'] = articleContents[0];
            data['SubArticles'] = (articleContents.length > 1) ? articleContents.extract(1) : [];
            var contentTemplate = $.template(section.get_templateId(), $('#' + contentTemplateName).html());
            contentContainer.append($.tmpl(contentTemplateName, data));
            contentContainer.contents().fadeIn(DanceEdge.DanceEdgeApp._animationLength);
        }
    };
    if (contentContainer.contents().length !== 0) {
        contentContainer.contents().fadeOut(DanceEdge.DanceEdgeApp._animationLength, function() {
            contentContainer.contents().remove();
            animateIn.invoke();
        });
    }
    else {
        animateIn.invoke();
    }
}
DanceEdge.DanceEdgeApp._renderFooter = function DanceEdge_DanceEdgeApp$_renderFooter(siteDefinition) {
    /// <param name="siteDefinition" type="DanceEdge.DataModel.SiteDefinition">
    /// </param>
}
DanceEdge.DanceEdgeApp._renderEmptySite = function DanceEdge_DanceEdgeApp$_renderEmptySite() {
    document.body.innerHTML = 'DanceEdgeOnline.com is temporarily unavailable. Please check back later.';
}


Type.registerNamespace('DanceEdge.Controllers');

////////////////////////////////////////////////////////////////////////////////
// DanceEdge.Controllers.NavigationManager

DanceEdge.Controllers.NavigationManager = function DanceEdge_Controllers_NavigationManager() {
    /// <field name="_activeSection" type="DanceEdge.DataModel.Section">
    /// </field>
    /// <field name="_subSection" type="DanceEdge.DataModel.Section">
    /// </field>
}
DanceEdge.Controllers.NavigationManager.prototype = {
    _activeSection: null,
    _subSection: null,
    
    navigateSection: function DanceEdge_Controllers_NavigationManager$navigateSection(section) {
        /// <param name="section" type="DanceEdge.DataModel.Section">
        /// </param>
    },
    
    navigateSubsection: function DanceEdge_Controllers_NavigationManager$navigateSubsection(subSection) {
        /// <param name="subSection" type="DanceEdge.DataModel.Section">
        /// </param>
    },
    
    get_activeSection: function DanceEdge_Controllers_NavigationManager$get_activeSection() {
        /// <value type="DanceEdge.DataModel.Section"></value>
        return this._activeSection;
    },
    set_activeSection: function DanceEdge_Controllers_NavigationManager$set_activeSection(value) {
        /// <value type="DanceEdge.DataModel.Section"></value>
        this._activeSection = value;
        return value;
    },
    
    get_subSection: function DanceEdge_Controllers_NavigationManager$get_subSection() {
        /// <value type="DanceEdge.DataModel.Section"></value>
        return this._subSection;
    },
    set_subSection: function DanceEdge_Controllers_NavigationManager$set_subSection(value) {
        /// <value type="DanceEdge.DataModel.Section"></value>
        this._subSection = value;
        return value;
    }
}


Type.registerNamespace('DanceEdge.DataModel');

////////////////////////////////////////////////////////////////////////////////
// DanceEdge.DataModel.Article

DanceEdge.DataModel.Article = function DanceEdge_DataModel_Article() {
    /// <field name="_title" type="String">
    /// </field>
    /// <field name="_id" type="String">
    /// </field>
}
DanceEdge.DataModel.Article.parseArticleArray = function DanceEdge_DataModel_Article$parseArticleArray(articleCollection) {
    /// <param name="articleCollection" type="Array" elementType="Object">
    /// </param>
    /// <returns type="Array" elementType="Article"></returns>
    if (articleCollection == null) {
        return null;
    }
    var articles = new Array(articleCollection.length);
    for (var i = 0; i < articleCollection.length; i++) {
        articles[i] = DanceEdge.DataModel.Article.parseArticle(articleCollection[i]);
    }
    return articles;
}
DanceEdge.DataModel.Article.parseArticle = function DanceEdge_DataModel_Article$parseArticle(articleDictionary) {
    /// <param name="articleDictionary" type="Object">
    /// </param>
    /// <returns type="DanceEdge.DataModel.Article"></returns>
    var article = new DanceEdge.DataModel.Article();
    article.set_title(articleDictionary['Title']);
    article.set_id(articleDictionary['Id']);
    return article;
}
DanceEdge.DataModel.Article.prototype = {
    _title: null,
    _id: null,
    
    get_title: function DanceEdge_DataModel_Article$get_title() {
        /// <summary>
        /// The title of the article.
        /// </summary>
        /// <value type="String"></value>
        return this._title;
    },
    set_title: function DanceEdge_DataModel_Article$set_title(value) {
        /// <summary>
        /// The title of the article.
        /// </summary>
        /// <value type="String"></value>
        this._title = value;
        return value;
    },
    
    get_id: function DanceEdge_DataModel_Article$get_id() {
        /// <summary>
        /// The id of the article.
        /// </summary>
        /// <value type="String"></value>
        return this._id;
    },
    set_id: function DanceEdge_DataModel_Article$set_id(value) {
        /// <summary>
        /// The id of the article.
        /// </summary>
        /// <value type="String"></value>
        this._id = value;
        return value;
    }
}


////////////////////////////////////////////////////////////////////////////////
// DanceEdge.DataModel.ArticleContent

DanceEdge.DataModel.ArticleContent = function DanceEdge_DataModel_ArticleContent() {
    /// <summary>
    /// Summary description for ArticleContent
    /// </summary>
    /// <field name="_id" type="String">
    /// </field>
    /// <field name="_image" type="String">
    /// </field>
    /// <field name="_templateId" type="String">
    /// </field>
    /// <field name="_title" type="String">
    /// </field>
    /// <field name="_summary" type="String">
    /// </field>
    /// <field name="_body" type="String">
    /// </field>
    /// <field name="_rotationIndex" type="Number" integer="true" static="true">
    /// </field>
}
DanceEdge.DataModel.ArticleContent.parseArticleContentArray = function DanceEdge_DataModel_ArticleContent$parseArticleContentArray(articleContentCollection) {
    /// <param name="articleContentCollection" type="Array" elementType="Object">
    /// </param>
    /// <returns type="Array" elementType="ArticleContent"></returns>
    if (articleContentCollection == null) {
        return null;
    }
    var articleContents = new Array(articleContentCollection.length);
    for (var i = 0; i < articleContentCollection.length; i++) {
        articleContents[i] = DanceEdge.DataModel.ArticleContent.parseArticleContent(articleContentCollection[i]);
    }
    return articleContents;
}
DanceEdge.DataModel.ArticleContent.parseArticleContent = function DanceEdge_DataModel_ArticleContent$parseArticleContent(articleContentDictionary) {
    /// <param name="articleContentDictionary" type="Object">
    /// </param>
    /// <returns type="DanceEdge.DataModel.ArticleContent"></returns>
    var articleContent = new DanceEdge.DataModel.ArticleContent();
    articleContent.set_id(articleContentDictionary['Id']);
    articleContent.set_image(articleContentDictionary['Image']);
    articleContent.set_templateId(articleContentDictionary['TemplateId']);
    articleContent.set_title(articleContentDictionary['Title']);
    articleContent.set_summary(articleContentDictionary['Summary']);
    articleContent.set_body(articleContentDictionary['Body']);
    return articleContent;
}
DanceEdge.DataModel.ArticleContent.getImageUrl = function DanceEdge_DataModel_ArticleContent$getImageUrl(url, siteDefinition) {
    /// <param name="url" type="String">
    /// </param>
    /// <param name="siteDefinition" type="DanceEdge.DataModel.SiteDefinition">
    /// </param>
    /// <returns type="String"></returns>
    if (String.isNullOrEmpty(url)) {
        if (DanceEdge.DataModel.ArticleContent._rotationIndex === -1) {
            DanceEdge.DataModel.ArticleContent._rotationIndex = Math.truncate((Math.random() * 10000));
        }
        else {
            DanceEdge.DataModel.ArticleContent._rotationIndex++;
        }
        var images = siteDefinition.get_articleImages();
        var length = images.length;
        DanceEdge.DataModel.ArticleContent._rotationIndex = DanceEdge.DataModel.ArticleContent._rotationIndex % length;
        while (!images[DanceEdge.DataModel.ArticleContent._rotationIndex].get_inRotation()) {
            DanceEdge.DataModel.ArticleContent._rotationIndex = (DanceEdge.DataModel.ArticleContent._rotationIndex + 1) % length;
        }
        url = images[DanceEdge.DataModel.ArticleContent._rotationIndex].get_url();
    }
    return url;
}
DanceEdge.DataModel.ArticleContent.prototype = {
    _id: null,
    _image: null,
    _templateId: null,
    _title: null,
    _summary: null,
    _body: null,
    
    get_id: function DanceEdge_DataModel_ArticleContent$get_id() {
        /// <value type="String"></value>
        return this._id;
    },
    set_id: function DanceEdge_DataModel_ArticleContent$set_id(value) {
        /// <value type="String"></value>
        this._id = value;
        return value;
    },
    
    get_image: function DanceEdge_DataModel_ArticleContent$get_image() {
        /// <value type="String"></value>
        return this._image;
    },
    set_image: function DanceEdge_DataModel_ArticleContent$set_image(value) {
        /// <value type="String"></value>
        this._image = value;
        return value;
    },
    
    get_templateId: function DanceEdge_DataModel_ArticleContent$get_templateId() {
        /// <value type="String"></value>
        return this._templateId;
    },
    set_templateId: function DanceEdge_DataModel_ArticleContent$set_templateId(value) {
        /// <value type="String"></value>
        this._templateId = value;
        return value;
    },
    
    get_title: function DanceEdge_DataModel_ArticleContent$get_title() {
        /// <value type="String"></value>
        return this._title;
    },
    set_title: function DanceEdge_DataModel_ArticleContent$set_title(value) {
        /// <value type="String"></value>
        this._title = value;
        return value;
    },
    
    get_summary: function DanceEdge_DataModel_ArticleContent$get_summary() {
        /// <value type="String"></value>
        return this._summary;
    },
    set_summary: function DanceEdge_DataModel_ArticleContent$set_summary(value) {
        /// <value type="String"></value>
        this._summary = value;
        return value;
    },
    
    get_body: function DanceEdge_DataModel_ArticleContent$get_body() {
        /// <value type="String"></value>
        return this._body;
    },
    set_body: function DanceEdge_DataModel_ArticleContent$set_body(value) {
        /// <value type="String"></value>
        this._body = value;
        return value;
    }
}


////////////////////////////////////////////////////////////////////////////////
// DanceEdge.DataModel.ArticleContentCache

DanceEdge.DataModel.ArticleContentCache = function DanceEdge_DataModel_ArticleContentCache() {
    /// <field name="_methodName" type="String" static="true">
    /// </field>
    /// <field name="_articleContentMap" type="Object" static="true">
    /// </field>
    /// <field name="_articleContentById" type="Object" static="true">
    /// </field>
}
DanceEdge.DataModel.ArticleContentCache.beginGetSectionArticles = function DanceEdge_DataModel_ArticleContentCache$beginGetSectionArticles(sectionId, callback, state) {
    /// <param name="sectionId" type="String">
    /// </param>
    /// <param name="callback" type="DanceEdge.Async.AsyncCallback">
    /// </param>
    /// <param name="state" type="Object">
    /// </param>
    /// <returns type="DanceEdge.Async.IAsyncResult"></returns>
    var result = new DanceEdge.Async.AsyncResult(callback, state);
    if (Object.keyExists(DanceEdge.DataModel.ArticleContentCache._articleContentMap, sectionId)) {
        result.set__result(DanceEdge.DataModel.ArticleContentCache._articleContentMap[sectionId]);
        window.setTimeout(function() {
            callback.invoke(result);
        }, 0);
    }
    else {
        var parameters = {};
        parameters['sectionId'] = sectionId;
        DanceEdge.DataModel.DataModelUtils.get_requestManager().beginGetRequest(DanceEdge.DataModel.ArticleContentCache._methodName, parameters, function(requestResult) {
            DanceEdge.DataModel.ArticleContentCache._callback(sectionId, requestResult, result);
        }, result);
    }
    return result;
}
DanceEdge.DataModel.ArticleContentCache.endGetSectionArticles = function DanceEdge_DataModel_ArticleContentCache$endGetSectionArticles(asyncResult) {
    /// <param name="asyncResult" type="DanceEdge.Async.IAsyncResult">
    /// </param>
    /// <returns type="Array" elementType="ArticleContent"></returns>
    return (asyncResult).get__result();
}
DanceEdge.DataModel.ArticleContentCache.getArticleContentById = function DanceEdge_DataModel_ArticleContentCache$getArticleContentById(articleId) {
    /// <param name="articleId" type="String">
    /// </param>
    /// <returns type="DanceEdge.DataModel.ArticleContent"></returns>
    return (Object.keyExists(DanceEdge.DataModel.ArticleContentCache._articleContentById, articleId)) ? DanceEdge.DataModel.ArticleContentCache._articleContentById[articleId] : null;
}
DanceEdge.DataModel.ArticleContentCache._callback = function DanceEdge_DataModel_ArticleContentCache$_callback(sectionId, requestResult, outerResult) {
    /// <param name="sectionId" type="String">
    /// </param>
    /// <param name="requestResult" type="DanceEdge.Async.IAsyncResult">
    /// </param>
    /// <param name="outerResult" type="DanceEdge.Async.AsyncResult">
    /// </param>
    DanceEdge.DataModel.ArticleContentCache._articleContentMap[sectionId] = DanceEdge.DataModel.ArticleContent.parseArticleContentArray(DanceEdge.DataModel.DataModelUtils.get_requestManager().endGetRequest(requestResult));
    outerResult.set__result(DanceEdge.DataModel.ArticleContentCache._articleContentMap[sectionId]);
    var $enum1 = ss.IEnumerator.getEnumerator(DanceEdge.DataModel.ArticleContentCache._articleContentMap[sectionId]);
    while ($enum1.moveNext()) {
        var current = $enum1.get_current();
        DanceEdge.DataModel.ArticleContentCache._articleContentById[current.get_id()] = current;
    }
    if (outerResult.get_callback() != null) {
        outerResult.get_callback().invoke(outerResult);
    }
}


////////////////////////////////////////////////////////////////////////////////
// DanceEdge.DataModel.ArticleImage

DanceEdge.DataModel.ArticleImage = function DanceEdge_DataModel_ArticleImage() {
    /// <field name="_inRotation$1" type="Boolean">
    /// </field>
    DanceEdge.DataModel.ArticleImage.initializeBase(this);
}
DanceEdge.DataModel.ArticleImage.parseArticleImageArray = function DanceEdge_DataModel_ArticleImage$parseArticleImageArray(articleImageCollection) {
    /// <param name="articleImageCollection" type="Array" elementType="Object">
    /// </param>
    /// <returns type="Array" elementType="ArticleImage"></returns>
    if (articleImageCollection == null) {
        return null;
    }
    var articleImages = new Array(articleImageCollection.length);
    for (var i = 0; i < articleImageCollection.length; i++) {
        articleImages[i] = DanceEdge.DataModel.ArticleImage.parseArticleImage(articleImageCollection[i]);
    }
    return articleImages;
}
DanceEdge.DataModel.ArticleImage.parseArticleImage = function DanceEdge_DataModel_ArticleImage$parseArticleImage(articleImageDictionary) {
    /// <param name="articleImageDictionary" type="Object">
    /// </param>
    /// <returns type="DanceEdge.DataModel.ArticleImage"></returns>
    var articleImage = new DanceEdge.DataModel.ArticleImage();
    DanceEdge.DataModel.Image.parseImage(articleImageDictionary, articleImage);
    articleImage.set_inRotation(articleImageDictionary['InRotation']);
    return articleImage;
}
DanceEdge.DataModel.ArticleImage.prototype = {
    _inRotation$1: false,
    
    get_inRotation: function DanceEdge_DataModel_ArticleImage$get_inRotation() {
        /// <value type="Boolean"></value>
        return this._inRotation$1;
    },
    set_inRotation: function DanceEdge_DataModel_ArticleImage$set_inRotation(value) {
        /// <value type="Boolean"></value>
        this._inRotation$1 = value;
        return value;
    }
}


////////////////////////////////////////////////////////////////////////////////
// DanceEdge.DataModel.BannerImage

DanceEdge.DataModel.BannerImage = function DanceEdge_DataModel_BannerImage() {
    /// <field name="_headerColor$1" type="String">
    /// </field>
    DanceEdge.DataModel.BannerImage.initializeBase(this);
}
DanceEdge.DataModel.BannerImage.parseBannerImageArray = function DanceEdge_DataModel_BannerImage$parseBannerImageArray(bannerImageCollection) {
    /// <param name="bannerImageCollection" type="Array" elementType="Object">
    /// </param>
    /// <returns type="Array" elementType="BannerImage"></returns>
    if (bannerImageCollection == null) {
        return null;
    }
    var bannerImages = new Array(bannerImageCollection.length);
    for (var i = 0; i < bannerImageCollection.length; i++) {
        bannerImages[i] = DanceEdge.DataModel.BannerImage.parseBannerImage(bannerImageCollection[i]);
    }
    return bannerImages;
}
DanceEdge.DataModel.BannerImage.parseBannerImage = function DanceEdge_DataModel_BannerImage$parseBannerImage(bannerImageDictionary) {
    /// <param name="bannerImageDictionary" type="Object">
    /// </param>
    /// <returns type="DanceEdge.DataModel.BannerImage"></returns>
    var bannerImage = new DanceEdge.DataModel.BannerImage();
    DanceEdge.DataModel.Image.parseImage(bannerImageDictionary, bannerImage);
    bannerImage.set_headerColor(bannerImageDictionary['HeaderColor']);
    return bannerImage;
}
DanceEdge.DataModel.BannerImage.prototype = {
    _headerColor$1: null,
    
    get_headerColor: function DanceEdge_DataModel_BannerImage$get_headerColor() {
        /// <value type="String"></value>
        return this._headerColor$1;
    },
    set_headerColor: function DanceEdge_DataModel_BannerImage$set_headerColor(value) {
        /// <value type="String"></value>
        this._headerColor$1 = value;
        return value;
    }
}


////////////////////////////////////////////////////////////////////////////////
// DanceEdge.DataModel.DataModelUtils

DanceEdge.DataModel.DataModelUtils = function DanceEdge_DataModel_DataModelUtils() {
    /// <field name="_requestManager" type="DanceEdge.Net.RequestManager" static="true">
    /// </field>
}
DanceEdge.DataModel.DataModelUtils.get_requestManager = function DanceEdge_DataModel_DataModelUtils$get_requestManager() {
    /// <value type="DanceEdge.Net.RequestManager"></value>
    return DanceEdge.DataModel.DataModelUtils._requestManager;
}
DanceEdge.DataModel.DataModelUtils.set_requestManager = function DanceEdge_DataModel_DataModelUtils$set_requestManager(value) {
    /// <value type="DanceEdge.Net.RequestManager"></value>
    DanceEdge.DataModel.DataModelUtils._requestManager = value;
    return value;
}


////////////////////////////////////////////////////////////////////////////////
// DanceEdge.DataModel.Image

DanceEdge.DataModel.Image = function DanceEdge_DataModel_Image() {
    /// <field name="_url" type="String">
    /// </field>
}
DanceEdge.DataModel.Image.parseImage = function DanceEdge_DataModel_Image$parseImage(imageDictionary, image) {
    /// <param name="imageDictionary" type="Object">
    /// </param>
    /// <param name="image" type="DanceEdge.DataModel.Image">
    /// </param>
    /// <returns type="DanceEdge.DataModel.Image"></returns>
    image.set_url(imageDictionary['Url']);
    return image;
}
DanceEdge.DataModel.Image.prototype = {
    _url: null,
    
    get_url: function DanceEdge_DataModel_Image$get_url() {
        /// <value type="String"></value>
        return this._url;
    },
    set_url: function DanceEdge_DataModel_Image$set_url(value) {
        /// <value type="String"></value>
        this._url = value;
        return value;
    }
}


////////////////////////////////////////////////////////////////////////////////
// DanceEdge.DataModel.Section

DanceEdge.DataModel.Section = function DanceEdge_DataModel_Section() {
    /// <field name="_defaultSubsectionId" type="String">
    /// </field>
    /// <field name="_id" type="String">
    /// </field>
    /// <field name="_isSubsection" type="Boolean">
    /// </field>
    /// <field name="_name" type="String">
    /// </field>
    /// <field name="_subsections" type="Array" elementType="Section">
    /// </field>
    /// <field name="_articles" type="Array" elementType="Article">
    /// </field>
    /// <field name="_templateId" type="String">
    /// </field>
    /// <field name="_subsectionsById" type="Object">
    /// </field>
    /// <field name="_articlesById" type="Object">
    /// </field>
}
DanceEdge.DataModel.Section.parseSectionArray = function DanceEdge_DataModel_Section$parseSectionArray(sectionCollection) {
    /// <param name="sectionCollection" type="Array" elementType="Object">
    /// </param>
    /// <returns type="Array" elementType="Section"></returns>
    if (sectionCollection == null) {
        return null;
    }
    var sections = new Array(sectionCollection.length);
    for (var i = 0; i < sectionCollection.length; i++) {
        sections[i] = DanceEdge.DataModel.Section.parseSection(sectionCollection[i]);
    }
    return sections;
}
DanceEdge.DataModel.Section.parseSection = function DanceEdge_DataModel_Section$parseSection(sectionDictionary) {
    /// <param name="sectionDictionary" type="Object">
    /// </param>
    /// <returns type="DanceEdge.DataModel.Section"></returns>
    var section = new DanceEdge.DataModel.Section();
    section.set_defaultSubsectionId(sectionDictionary['DefaultSubsectionId']);
    section.set_id(sectionDictionary['Id']);
    section.set_isSubsection(sectionDictionary['IsSubsection']);
    section.set_name(sectionDictionary['Name']);
    section.set_subSections(DanceEdge.DataModel.Section.parseSectionArray(sectionDictionary['SubSections']));
    section.set_articles(DanceEdge.DataModel.Article.parseArticleArray(sectionDictionary['Articles']));
    section.set_templateId(sectionDictionary['TemplateId']);
    return section;
}
DanceEdge.DataModel.Section.getSubSectionFromSection = function DanceEdge_DataModel_Section$getSubSectionFromSection(siteDefinition, sectionId, subsectionId) {
    /// <param name="siteDefinition" type="DanceEdge.DataModel.SiteDefinition">
    /// </param>
    /// <param name="sectionId" type="String">
    /// </param>
    /// <param name="subsectionId" type="String">
    /// </param>
    /// <returns type="DanceEdge.DataModel.Section"></returns>
    if (String.isNullOrEmpty(subsectionId)) {
        return null;
    }
    return siteDefinition.getSectionById(sectionId).getSubsectionById(subsectionId);
}
DanceEdge.DataModel.Section.prototype = {
    _defaultSubsectionId: null,
    _id: null,
    _isSubsection: false,
    _name: null,
    _subsections: null,
    _articles: null,
    _templateId: null,
    _subsectionsById: null,
    _articlesById: null,
    
    getSubsectionById: function DanceEdge_DataModel_Section$getSubsectionById(subsectionId) {
        /// <param name="subsectionId" type="String">
        /// </param>
        /// <returns type="DanceEdge.DataModel.Section"></returns>
        if (this._subsectionsById == null) {
            this._subsectionsById = {};
            var $enum1 = ss.IEnumerator.getEnumerator(this._subsections);
            while ($enum1.moveNext()) {
                var current = $enum1.get_current();
                this._subsectionsById[current.get_id()] = current;
            }
        }
        return (Object.keyExists(this._subsectionsById, subsectionId)) ? this._subsectionsById[subsectionId] : null;
    },
    
    getArticleById: function DanceEdge_DataModel_Section$getArticleById(articleId) {
        /// <param name="articleId" type="String">
        /// </param>
        /// <returns type="DanceEdge.DataModel.Article"></returns>
        if (this._articlesById == null) {
            this._articlesById = {};
            var $enum1 = ss.IEnumerator.getEnumerator(this._articles);
            while ($enum1.moveNext()) {
                var current = $enum1.get_current();
                this._articlesById[current.get_id()] = current;
            }
        }
        return (Object.keyExists(this._articlesById, articleId)) ? this._articlesById[articleId] : null;
    },
    
    get_defaultSubsectionId: function DanceEdge_DataModel_Section$get_defaultSubsectionId() {
        /// <summary>
        /// The id of the default subsection.
        /// </summary>
        /// <value type="String"></value>
        return this._defaultSubsectionId;
    },
    set_defaultSubsectionId: function DanceEdge_DataModel_Section$set_defaultSubsectionId(value) {
        /// <summary>
        /// The id of the default subsection.
        /// </summary>
        /// <value type="String"></value>
        this._defaultSubsectionId = value;
        if (String.isNullOrEmpty(this._defaultSubsectionId)) {
            this._defaultSubsectionId = '';
        }
        return value;
    },
    
    get_id: function DanceEdge_DataModel_Section$get_id() {
        /// <summary>
        /// The id of the section.
        /// </summary>
        /// <value type="String"></value>
        return this._id;
    },
    set_id: function DanceEdge_DataModel_Section$set_id(value) {
        /// <summary>
        /// The id of the section.
        /// </summary>
        /// <value type="String"></value>
        this._id = value;
        return value;
    },
    
    get_isSubsection: function DanceEdge_DataModel_Section$get_isSubsection() {
        /// <summary>
        /// True if this is a subsection.
        /// </summary>
        /// <value type="Boolean"></value>
        return this._isSubsection;
    },
    set_isSubsection: function DanceEdge_DataModel_Section$set_isSubsection(value) {
        /// <summary>
        /// True if this is a subsection.
        /// </summary>
        /// <value type="Boolean"></value>
        this._isSubsection = value;
        return value;
    },
    
    get_name: function DanceEdge_DataModel_Section$get_name() {
        /// <summary>
        /// The title of the section.
        /// </summary>
        /// <value type="String"></value>
        return this._name;
    },
    set_name: function DanceEdge_DataModel_Section$set_name(value) {
        /// <summary>
        /// The title of the section.
        /// </summary>
        /// <value type="String"></value>
        this._name = value;
        return value;
    },
    
    get_subSections: function DanceEdge_DataModel_Section$get_subSections() {
        /// <summary>
        /// Child sections.
        /// </summary>
        /// <value type="Array" elementType="Section"></value>
        return this._subsections;
    },
    set_subSections: function DanceEdge_DataModel_Section$set_subSections(value) {
        /// <summary>
        /// Child sections.
        /// </summary>
        /// <value type="Array" elementType="Section"></value>
        this._subsections = value;
        return value;
    },
    
    get_articles: function DanceEdge_DataModel_Section$get_articles() {
        /// <summary>
        /// Articles belonging to this section.
        /// </summary>
        /// <value type="Array" elementType="Article"></value>
        return this._articles;
    },
    set_articles: function DanceEdge_DataModel_Section$set_articles(value) {
        /// <summary>
        /// Articles belonging to this section.
        /// </summary>
        /// <value type="Array" elementType="Article"></value>
        this._articles = value;
        return value;
    },
    
    get_templateId: function DanceEdge_DataModel_Section$get_templateId() {
        /// <summary>
        /// The id of the template associated with this section.
        /// </summary>
        /// <value type="String"></value>
        return this._templateId;
    },
    set_templateId: function DanceEdge_DataModel_Section$set_templateId(value) {
        /// <summary>
        /// The id of the template associated with this section.
        /// </summary>
        /// <value type="String"></value>
        this._templateId = value;
        return value;
    }
}


////////////////////////////////////////////////////////////////////////////////
// DanceEdge.DataModel.SiteDefinition

DanceEdge.DataModel.SiteDefinition = function DanceEdge_DataModel_SiteDefinition() {
    /// <field name="_siteDefinition" type="DanceEdge.DataModel.SiteDefinition" static="true">
    /// </field>
    /// <field name="_siteDefinitionMethodName" type="String" static="true">
    /// </field>
    /// <field name="_defaultSectionId" type="String">
    /// </field>
    /// <field name="_articleImages" type="Array" elementType="ArticleImage">
    /// </field>
    /// <field name="_bannerImages" type="Array" elementType="BannerImage">
    /// </field>
    /// <field name="_sections" type="Array" elementType="Section">
    /// </field>
    /// <field name="_settings" type="Object">
    /// </field>
    /// <field name="_sectionsById" type="Object">
    /// </field>
}
DanceEdge.DataModel.SiteDefinition.beginGet = function DanceEdge_DataModel_SiteDefinition$beginGet(callback, state) {
    /// <param name="callback" type="DanceEdge.Async.AsyncCallback">
    /// </param>
    /// <param name="state" type="Object">
    /// </param>
    /// <returns type="DanceEdge.Async.IAsyncResult"></returns>
    var result = new DanceEdge.Async.AsyncResult(callback, state);
    if (DanceEdge.DataModel.SiteDefinition._siteDefinition == null) {
        DanceEdge.DataModel.DataModelUtils.get_requestManager().beginGetRequest(DanceEdge.DataModel.SiteDefinition._siteDefinitionMethodName, null, function(requestResult) {
            DanceEdge.DataModel.SiteDefinition._callback(requestResult, result);
        }, result);
    }
    else {
        window.setTimeout(function() {
            DanceEdge.DataModel.SiteDefinition._callback(null, result);
        }, 0);
    }
    return result;
}
DanceEdge.DataModel.SiteDefinition.endGet = function DanceEdge_DataModel_SiteDefinition$endGet(asyncResult) {
    /// <param name="asyncResult" type="DanceEdge.Async.IAsyncResult">
    /// </param>
    /// <returns type="DanceEdge.DataModel.SiteDefinition"></returns>
    return DanceEdge.DataModel.SiteDefinition._siteDefinition;
}
DanceEdge.DataModel.SiteDefinition._callback = function DanceEdge_DataModel_SiteDefinition$_callback(requestResult, outerResult) {
    /// <param name="requestResult" type="DanceEdge.Async.IAsyncResult">
    /// </param>
    /// <param name="outerResult" type="DanceEdge.Async.AsyncResult">
    /// </param>
    if (DanceEdge.DataModel.SiteDefinition._siteDefinition == null) {
        DanceEdge.DataModel.SiteDefinition._siteDefinition = DanceEdge.DataModel.SiteDefinition._parse(DanceEdge.DataModel.DataModelUtils.get_requestManager().endGetRequest(requestResult));
    }
    if (outerResult.get_callback() != null) {
        outerResult.get_callback().invoke(outerResult);
    }
}
DanceEdge.DataModel.SiteDefinition._parse = function DanceEdge_DataModel_SiteDefinition$_parse(definition) {
    /// <param name="definition" type="Object">
    /// </param>
    /// <returns type="DanceEdge.DataModel.SiteDefinition"></returns>
    var siteDefinition = new DanceEdge.DataModel.SiteDefinition();
    siteDefinition.set_defaultSectionId(definition['DefaultSectionId']);
    siteDefinition.set_articleImages(DanceEdge.DataModel.ArticleImage.parseArticleImageArray(definition['ArticleImages']));
    siteDefinition.set_bannerImages(DanceEdge.DataModel.BannerImage.parseBannerImageArray(definition['BannerImages']));
    siteDefinition.set_sections(DanceEdge.DataModel.Section.parseSectionArray(definition['Sections']));
    siteDefinition.set_settings({});
    var settings = definition['Settings'];
    for (var i = 0; i < settings.length; i++) {
        siteDefinition.get_settings()[settings[i]['Name']] = settings[i]['Value'];
    }
    return siteDefinition;
}
DanceEdge.DataModel.SiteDefinition.prototype = {
    _defaultSectionId: null,
    _articleImages: null,
    _bannerImages: null,
    _sections: null,
    _settings: null,
    _sectionsById: null,
    
    getSectionById: function DanceEdge_DataModel_SiteDefinition$getSectionById(sectionId) {
        /// <param name="sectionId" type="String">
        /// </param>
        /// <returns type="DanceEdge.DataModel.Section"></returns>
        if (this._sectionsById == null) {
            this._sectionsById = {};
            var $enum1 = ss.IEnumerator.getEnumerator(this._sections);
            while ($enum1.moveNext()) {
                var current = $enum1.get_current();
                this._sectionsById[current.get_id()] = current;
                var $enum2 = ss.IEnumerator.getEnumerator(current.get_subSections());
                while ($enum2.moveNext()) {
                    var subsection = $enum2.get_current();
                    this._sectionsById[subsection.get_id()] = subsection;
                }
            }
        }
        return (Object.keyExists(this._sectionsById, sectionId)) ? this._sectionsById[sectionId] : null;
    },
    
    get_defaultSectionId: function DanceEdge_DataModel_SiteDefinition$get_defaultSectionId() {
        /// <summary>
        /// The id of the default section to display.
        /// </summary>
        /// <value type="String"></value>
        return this._defaultSectionId;
    },
    set_defaultSectionId: function DanceEdge_DataModel_SiteDefinition$set_defaultSectionId(value) {
        /// <summary>
        /// The id of the default section to display.
        /// </summary>
        /// <value type="String"></value>
        this._defaultSectionId = value;
        return value;
    },
    
    get_articleImages: function DanceEdge_DataModel_SiteDefinition$get_articleImages() {
        /// <value type="Array" elementType="ArticleImage"></value>
        return this._articleImages;
    },
    set_articleImages: function DanceEdge_DataModel_SiteDefinition$set_articleImages(value) {
        /// <value type="Array" elementType="ArticleImage"></value>
        this._articleImages = value;
        return value;
    },
    
    get_bannerImages: function DanceEdge_DataModel_SiteDefinition$get_bannerImages() {
        /// <value type="Array" elementType="BannerImage"></value>
        return this._bannerImages;
    },
    set_bannerImages: function DanceEdge_DataModel_SiteDefinition$set_bannerImages(value) {
        /// <value type="Array" elementType="BannerImage"></value>
        this._bannerImages = value;
        return value;
    },
    
    get_sections: function DanceEdge_DataModel_SiteDefinition$get_sections() {
        /// <value type="Array" elementType="Section"></value>
        return this._sections;
    },
    set_sections: function DanceEdge_DataModel_SiteDefinition$set_sections(value) {
        /// <value type="Array" elementType="Section"></value>
        this._sections = value;
        return value;
    },
    
    get_settings: function DanceEdge_DataModel_SiteDefinition$get_settings() {
        /// <value type="Object"></value>
        return this._settings;
    },
    set_settings: function DanceEdge_DataModel_SiteDefinition$set_settings(value) {
        /// <value type="Object"></value>
        this._settings = value;
        return value;
    }
}


Type.registerNamespace('DanceEdge.Net');

////////////////////////////////////////////////////////////////////////////////
// DanceEdge.Net.RequestManager

DanceEdge.Net.RequestManager = function DanceEdge_Net_RequestManager(baseUrl) {
    /// <param name="baseUrl" type="String">
    /// </param>
    /// <field name="_pendingRequests" type="Object">
    /// </field>
    /// <field name="_baseUrl" type="String">
    /// </field>
    /// <field name="_serviceName" type="String" static="true">
    /// </field>
    this._baseUrl = baseUrl;
    this._pendingRequests = {};
}
DanceEdge.Net.RequestManager.prototype = {
    _pendingRequests: null,
    _baseUrl: null,
    
    beginGetRequest: function DanceEdge_Net_RequestManager$beginGetRequest(methodName, parameters, callback, state) {
        /// <summary>
        /// Get an item from the server.
        /// </summary>
        /// <param name="methodName" type="String">
        /// </param>
        /// <param name="parameters" type="Object">
        /// </param>
        /// <param name="callback" type="DanceEdge.Async.AsyncCallback">
        /// </param>
        /// <param name="state" type="Object">
        /// </param>
        /// <returns type="DanceEdge.Async.IAsyncResult"></returns>
        var result = new DanceEdge.Async.AsyncResult(callback, state);
        var requestKey = this._getRequestKey(methodName, parameters);
        if (!Object.keyExists(this._pendingRequests, requestKey)) {
            var options = {};
            options.url = this._baseUrl + '/' + DanceEdge.Net.RequestManager._serviceName + '/' + methodName;
            options.contentType = 'application/json';
            options.dataType = 'json';
            options.type = 'POST';
            if (parameters != null) {
                options.data = JSON.stringify(parameters);
            }
            options.success = ss.Delegate.create(this, function(data, textStatus, request) {
                var asyncResults = this._pendingRequests[requestKey];
                for (var i = 0; i < asyncResults.length; i++) {
                    var current = asyncResults[i];
                    current.set__result((data)['d']);
                    if (current.get_callback() != null) {
                        current.get_callback().invoke(current);
                    }
                }
                delete this._pendingRequests[requestKey];
            });
            $.ajax(options);
        }
        if (ss.isNullOrUndefined(this._pendingRequests[requestKey])) {
            this._pendingRequests[requestKey] = [];
        }
        (this._pendingRequests[requestKey]).add(result);
        return result;
    },
    
    endGetRequest: function DanceEdge_Net_RequestManager$endGetRequest(result) {
        /// <summary>
        /// Get an item from the server.
        /// </summary>
        /// <param name="result" type="DanceEdge.Async.IAsyncResult">
        /// </param>
        /// <returns type="Object"></returns>
        return (result).get__result();
    },
    
    _getRequestKey: function DanceEdge_Net_RequestManager$_getRequestKey(methodName, parameters) {
        /// <param name="methodName" type="String">
        /// </param>
        /// <param name="parameters" type="Object">
        /// </param>
        /// <returns type="String"></returns>
        var retVal = methodName;
        if (parameters != null) {
            var $dict1 = parameters;
            for (var $key2 in $dict1) {
                var entry = { key: $key2, value: $dict1[$key2] };
                retVal += entry.key + entry.value;
            }
        }
        return retVal;
    }
}


DanceEdge.Async.AsyncResult.registerClass('DanceEdge.Async.AsyncResult', null, DanceEdge.Async.IAsyncResult);
DanceEdge._constants.registerClass('DanceEdge._constants');
DanceEdge.Globals.registerClass('DanceEdge.Globals');
DanceEdge.NavigationState.registerClass('DanceEdge.NavigationState');
DanceEdge.DanceEdgeApp.registerClass('DanceEdge.DanceEdgeApp');
DanceEdge.Controllers.NavigationManager.registerClass('DanceEdge.Controllers.NavigationManager');
DanceEdge.DataModel.Article.registerClass('DanceEdge.DataModel.Article');
DanceEdge.DataModel.ArticleContent.registerClass('DanceEdge.DataModel.ArticleContent');
DanceEdge.DataModel.ArticleContentCache.registerClass('DanceEdge.DataModel.ArticleContentCache');
DanceEdge.DataModel.Image.registerClass('DanceEdge.DataModel.Image');
DanceEdge.DataModel.ArticleImage.registerClass('DanceEdge.DataModel.ArticleImage', DanceEdge.DataModel.Image);
DanceEdge.DataModel.BannerImage.registerClass('DanceEdge.DataModel.BannerImage', DanceEdge.DataModel.Image);
DanceEdge.DataModel.DataModelUtils.registerClass('DanceEdge.DataModel.DataModelUtils');
DanceEdge.DataModel.Section.registerClass('DanceEdge.DataModel.Section');
DanceEdge.DataModel.SiteDefinition.registerClass('DanceEdge.DataModel.SiteDefinition');
DanceEdge.Net.RequestManager.registerClass('DanceEdge.Net.RequestManager');
DanceEdge._constants._imageBase = 'ImageBase';
DanceEdge._constants._headerTemplateName = 'HeaderTemplate';
DanceEdge._constants._topNavItemTemplateName = 'TopNavItemTemplate';
DanceEdge._constants._secondaryNavItemTemplateName = 'SecondaryNavItemTemplate';
DanceEdge._constants._backgroundImageContainer = 'BackgroundImageContainer';
DanceEdge._constants._headerContainer = 'HeaderContainer';
DanceEdge._constants._topNavContainer = 'TopNavContainer';
DanceEdge._constants._topNavListClass = 'TopNavListClass';
DanceEdge._constants._secondaryNavContainer = 'SecondaryNavContainer';
DanceEdge._constants._secondaryNavListClass = 'SecondaryNavListClass';
DanceEdge._constants._navSelectedClass = 'NavSelectedClass';
DanceEdge._constants._contentContainer = 'ContentContainer';
DanceEdge._constants._titleBase = 'TitleBase';
DanceEdge.Globals._maxWordLength = 15;
DanceEdge.DanceEdgeApp._animationLength = 200;
DanceEdge.DanceEdgeApp._headerAnimationLength = 500;
DanceEdge.DanceEdgeApp._previousIndex = 'previousIndex';
DanceEdge.DanceEdgeApp._navState = null;
DanceEdge.DanceEdgeApp._siteDefinition = null;
DanceEdge.DataModel.ArticleContent._rotationIndex = -1;
DanceEdge.DataModel.ArticleContentCache._methodName = 'GetArticleContent';
DanceEdge.DataModel.ArticleContentCache._articleContentMap = {};
DanceEdge.DataModel.ArticleContentCache._articleContentById = {};
DanceEdge.DataModel.DataModelUtils._requestManager = null;
DanceEdge.DataModel.SiteDefinition._siteDefinition = null;
DanceEdge.DataModel.SiteDefinition._siteDefinitionMethodName = 'GetSiteDefinition';
DanceEdge.Net.RequestManager._serviceName = 'SiteService.svc';

}
ss.loader.registerScript('DanceEdge', [], executeScript);
})();