if (typeof YAHOO != 'undefined') {
    
    if (YAHOO.env.ua.ie) {
        YAHOO.util.Event.onDOMReady(shimSubmits);
    }
    
    function addDefaultTextListeners(el) {
        restoreDefaultText(null, el);
        YAHOO.util.Event.addListener(el, 'focus', clearDefaultText, el);
        YAHOO.util.Event.addListener(el, 'blur', restoreDefaultText, el);
        YAHOO.util.Event.addListener(el.form, 'submit', defaultTextFormEventMassAction, [el.form, clearDefaultText]);
        YAHOO.util.Event.addListener(el.form, 'reset', defaultTextFormEventMassAction, [el.form, restoreDefaultText]);
    }
    YAHOO.util.Event.onDOMReady(function() {
        YAHOO.util.Dom.batch(
            YAHOO.util.Selector.query("input[type=text][defaultText], textarea[defaultText]", 'body_container', false),
            addDefaultTextListeners
        );
    });
    

    /**
     * Updates the number of characters remaining.
     * Color of the label changes to red when the there are no characters remaining.
     * Doesn't allow to put in more than the specified characters. 
     */ 
    function maintainTextareaMaxlength(event, args) {
        var textarea = this;
        var textareaMaxlength = this.getAttribute("maxlength");
        var remainingCharCount = textareaMaxlength - (textarea.value == textarea.getAttribute("defaultText") ? 0 : textarea.value.length);
        var remainingCharCountMessage = YAHOO.util.Dom.getElementsByClassName(this.name + '-remaining', null, this.form)[0];
        if (remainingCharCount < 0) {
            textarea.value = textarea.value.substring(0, textareaMaxlength);
            remainingCharCount = 0;
        }
        if (remainingCharCountMessage) {
            if (remainingCharCount == 0) {
                YAHOO.util.Dom.addClass(remainingCharCountMessage, 'inlineErrorMessageText');
                YAHOO.util.Dom.getElementsByClassName('count', null, remainingCharCountMessage)[0].innerHTML = 'no';
            }
            else {
                YAHOO.util.Dom.removeClass(remainingCharCountMessage, 'inlineErrorMessageText');
                YAHOO.util.Dom.getElementsByClassName('count', null, remainingCharCountMessage)[0].innerHTML = remainingCharCount;
            }
        }
    }
    YAHOO.util.Event.onDOMReady(function() {
        var eventTypes = ['keyup', 'blur', 'change'];
        var maxlengthTextareas = YAHOO.util.Dom.getElementsBy(function(el) {
            return el.getAttribute('maxlength') != null && el.getAttribute('maxlength') != '';
        }, 'TEXTAREA');
        for (var i = 0, ii = maxlengthTextareas.length; i < ii; i++) {
            for (var j = 0, jj = eventTypes.length; j < jj; j++) {
                YAHOO.util.Event.on(maxlengthTextareas[i], eventTypes[j], maintainTextareaMaxlength, maxlengthTextareas[i], true);
            }
            maintainTextareaMaxlength.call(maxlengthTextareas[i]);
        }
    });
    
    function genericHeightAnim(el, timer, easing) {
        var elRegion = YAHOO.util.Dom.getRegion(el);
        var elBBMHeight = 0;
        var heightStyles = ['margin-top', 'margin-bottom', 'border-top-width', 'border-bottom-width'];
        for (var i = 0; i < heightStyles.length; i++) {
            var tmpHeight = YAHOO.util.Dom.getStyle(el, heightStyles[i]);
            if (tmpHeight && tmpHeight != null) {
                var parsedHeight = tmpHeight.replace(/px/, '');
                if (!isNaN(Number(parsedHeight))) { //apparently IE answers some of these questions with "medium" >.<
                    elBBMHeight += Number(tmpHeight.replace(/px/, ''));
                }
            }
        }
        var elAnim = new YAHOO.util.Anim(el.parentNode, {height: {to: elRegion.height + elBBMHeight}}, timer, easing);
        elAnim.onComplete.subscribe(function() {
            this.getEl().parentNode.style.overflow = '';
            this.getEl().parentNode.style.height = '';
        });
        elAnim.animate();
    }
    
    /********************************************
    * generic confirmation animation
    *********************************************/
    LADDERS.confirmationAnimations = {};
    
    /**
     * Generic "confirmation" animations.  Creates a partially opaque mask with a messsage centered within.
     * Also adds object to LADDERS.confirmationAnimations for access afterwards.
     * 
     * @param el {HTMLElement} The element to mask and center within
     * @param animId {String} Arbitrary unique id; use to add to LADDERS.confirmationAnimations
     * @param message {String} Message to display
     * @param messageClass {String} ['success', 'error', 'info'] (Optional, defaults to 'success')
     * @return {Object} animation: {YAHOO.util.Anim}, overlay: {YAHOO.widget.Overlay}
     */
    function confirmationAnimation(el, animId, message, messageClass) {
        messageClass = (messageClass || 'success');
        var containerRegion = YAHOO.util.Dom.getRegion(el);
        var fadeInDuration = 0.15;
        
        //create overlay with message
        var confirmationOverlay = new YAHOO.widget.Overlay('confirmation-' + animId, {
            effect: {effect: YAHOO.widget.ContainerEffect.FADE, duration: fadeInDuration},
            visible: false,
            zIndex: 6
        });
        confirmationOverlay.setBody(message.replace(/\\n/, '<br/>'));
        YAHOO.util.Dom.addClass(confirmationOverlay.element, (messageClass || 'success') + 'Messages');
        
        //create mask
        var confirmationMask = document.createElement('DIV');
        confirmationMask.className = messageClass + ' confirmation-mask';
        YAHOO.util.Dom.setStyle(confirmationMask, 'opacity', 0);
        YAHOO.util.Dom.setStyle(confirmationMask, 'z-index', 5);
        confirmationMask.style.width = containerRegion.width + 'px';
        confirmationMask.style.height = containerRegion.height + 'px';
        
        var maskFadeIn = new YAHOO.util.Anim(confirmationMask, {opacity: {from: 0, to: .5}}, fadeInDuration);
        var maskFadeOut = new YAHOO.util.Anim(confirmationMask, {opacity: {from: .5, to: 0}}, 1.5, YAHOO.util.Easing.easeIn);
        
        //when we render the message overlay, add the mask and trigger the chain of animations
        confirmationOverlay.renderEvent.subscribe(function() {
            var overlayRegion = YAHOO.util.Dom.getRegion(this.element);
            var clientRegion = YAHOO.util.Dom.getClientRegion();
            el.appendChild(confirmationMask);
            YAHOO.util.Dom.setXY(confirmationMask, containerRegion);
            this.cfg.setProperty('x', containerRegion.x + (containerRegion.width - overlayRegion.width)/2);
            if (containerRegion.bottom > clientRegion.bottom)  {
                this.cfg.setProperty('y', containerRegion.y + ((clientRegion.bottom - containerRegion.y) - overlayRegion.height)/2);
            }
            else {
                this.cfg.setProperty('y', containerRegion.y + (containerRegion.height - overlayRegion.height)/2);
            }
            maskFadeIn.animate();
        });
        
        //starting the mask fadein should also show the message
        maskFadeIn.onStart.subscribe(confirmationOverlay.show, confirmationOverlay, true);
        //hide the mask .5 sec after the fade-in animation completes
        maskFadeIn.onComplete.subscribe(maskFadeOut.animate, maskFadeOut, true);
        //delete the mask and remove the message overlay when fadeOut is finished 
        maskFadeOut.onComplete.subscribe(confirmationOverlay.hide, confirmationOverlay, true);
        //destroy the overlay when it's hidden so that it doesn't pop up on a 2nd firing
        confirmationOverlay.hideEvent.subscribe(function() {
            confirmationMask.parentNode.removeChild(confirmationMask);
            this.destroy();
        });
        
        confirmationOverlay.render(el);
        
        LADDERS.confirmationAnimations[animId] = {
            animation: maskFadeOut,
            overlay: confirmationOverlay
        };
        
        return LADDERS.confirmationAnimations[animId];
    }
    
}

if (typeof YAHOO != 'undefined' && typeof YAHOO.widget != 'undefined') {
    YAHOO.widget.Module.prototype.setElement = function(bodyContent) {
        this.element.innerHTML = bodyContent;
        this.init(this.element, this.cfg.getConfig());
    };
    
    LADDERS.YUIDialogs = new YAHOO.widget.OverlayManager();
    
    function yuiDialogEvent(event, args) {
        yuiDialog.apply(YAHOO.util.Event.getTarget(event), args);
    }
    
    function submitThis(event) { //avoids scoping issues in callback functions
        YAHOO.util.Event.stopEvent(event);
        this.submit();
    }
    
    function hideThis(event) { //avoids scoping issues in callback functions
        YAHOO.util.Event.stopEvent(event);
        this.hide();
    }
    
    var yuiDialogProperties = {
        close: true,
        draggable: false,
        effect: YAHOO.env.ua.ie ? null : {effect: YAHOO.widget.ContainerEffect.FADE, duration: 0.25},
        fixedcenter: 'contained',
        hideaftersubmit: false,
        modal: true,
        underlay: 'matte',
        visible: false,
        zindex: 6
    }
    
    function yuiDialog(/*String*/ id, /*String*/ hdText, /*String*/ bdText, /*Object*/ okButton) {
        var confirmDialogId = id || 'confirmDialog'; 
        var confirmDialog = LADDERS.YUIDialogs.find(confirmDialogId) || new YAHOO.widget.Dialog(confirmDialogId, yuiDialogProperties);
        if (!confirmDialog.header || confirmDialog.header == '') {
            confirmDialog.setHeader(hdText || '&nbsp;');
        }
        if (bdText) {
            confirmDialog.setBody(bdText);
        }
        confirmDialog.setFooter(' ');
        var buttonConfig = [okButton];
        if (okButton.handler != hideThis) {
            buttonConfig.push({text: 'Cancel', handler: hideThis});
        }
        confirmDialog.cfg.queueProperty('buttons', buttonConfig);
        confirmDialog.render(document.body);
        if (confirmDialog.form && confirmDialog.form.innerHTML != '') {
            YAHOO.util.Dom.addClass(confirmDialog.element.getElementsByTagName('DIV')[0], 'has-form'); 
        }
        var okButton = confirmDialog.getButtons()[0]._button || confirmDialog.getButtons()[0]; //stupid YUI buttons
        okButton.className = 'glossy blue small';
        okButton.hideFocus = true;
        if (confirmDialog.getButtons().length > 1) {
            var cancelButton = confirmDialog.getButtons()[1]._button || confirmDialog.getButtons()[1]; //stupid YUI buttons
            cancelButton.className = 'cancel a';
            cancelButton.hideFocus = true;
        }
        LADDERS.YUIDialogs.register(confirmDialog);
        //TODO -- this only works on a stack 2 deep atm, since hiding the 2nd one to show the 3rd calls back the 1st
        var activeDialog = LADDERS.YUIDialogs.getActive();
        if (activeDialog) {
            var showActiveDialogFn = function() {
                activeDialog.show();
                confirmDialog.hideEvent.unsubscribe(showActiveDialogFn);
            };
            confirmDialog.hideEvent.subscribe(showActiveDialogFn);
        }
        LADDERS.YUIDialogs.hideAll();
        confirmDialog.showEvent.subscribe(function() {
            LADDERS.YUIDialogs.focus(confirmDialog);
            YAHOO.util.Event.on(confirmDialog.mask, 'click', YAHOO.util.Event.stopEvent, YAHOO.util.Event, true);
        });
        confirmDialog.show();
        return confirmDialog;
    }
    
    //based of the idea that many of our forms are actually going to be fully form-backed servlets that could stand alone if needed
    function yuiAJAXDialog(/*String*/ url, /*Object*/ okButton, /*Function*/ loadingSuccessCallback, /*Function*/ submitSuccessCallback, /*Boolean*/ runLoadingSuccessOnErrorLoad) {
        var holderElement = document.createElement('DIV');
        holderElement.style.display = 'none';
        document.body.appendChild(holderElement);
        YAHOO.util.Dom.addClass(document.body, 'in-progress');
        YAHOO.util.Connect.resetFormState();
        YAHOO.util.Connect.asyncRequest('GET', url, {
            success: function(response) { // this function populates the holder element with returned HTML
                var holderElement = response.argument[0];
                holderElement.innerHTML = response.responseText;
                runScriptTags(holderElement.getElementsByTagName('SCRIPT'));
                var extantDialog = LADDERS.YUIDialogs.find(holderElement.getElementsByTagName('DIV')[0].id);
                if (extantDialog) {
                    extantDialog.destroy();
                }
                var newDialog = yuiDialog(holderElement.getElementsByTagName('DIV')[0].id, null, null, okButton);
                response.argument[1] = newDialog;
                newDialog.beforeSubmitEvent.subscribe(function() {
                    YAHOO.util.Dom.addClass(document.body, 'in-progress');
                    YAHOO.util.Dom.batch(newDialog.footer.getElementsByTagName('BUTTON'), function(el) {
                        el.disabled = true;
                    });
                });
                newDialog.callback.argument = newDialog;
                newDialog.callback.failure = ajaxFailure;
                newDialog.callback.success = function(response) { // this function run gets when the Dialog is sucessfully submitted
                    YAHOO.util.Dom.removeClass(document.body, 'in-progress');
                    var newDialog = response.argument;
                    if (response.status == 202) { 
                        //server accepted request, but validation errors have occurred
                        var holderElement = document.createElement('DIV');
                        holderElement.innerHTML = response.responseText.replace(/id=[\\'\\"][A-Za-z0-9]*[\\'\\"]/, 'id="temp"'); //avoid dupedIds now, intentionally NOT global
                        newDialog.setHeader(YAHOO.util.Dom.getElementsByClassName('hd', 'DIV', holderElement)[0].innerHTML);
                        newDialog.setBody(YAHOO.util.Dom.getElementsByClassName('bd', 'DIV', holderElement)[0].innerHTML);
                        YAHOO.util.Dom.batch(newDialog.footer.getElementsByTagName('BUTTON'), function(el) {
                            el.disabled = false;
                        });
                        holderElement = null;
                        if (runLoadingSuccessOnErrorLoad) {
                            loadingSuccessCallback.call(this, newDialog);
                        }
                    }
                    else if (submitSuccessCallback && (response.status == 204 || response.status == 200)) {
                        //fully sucessful submit: custom successCallback provided
                        submitSuccessCallback.call(this, response);
                    }
                    else if (response.status == 200) {
                        //fully successful submit: server returns content; show a confirmation animation with that content
                        confirmationAnimation(newDialog.element.getElementsByTagName('DIV')[0], newDialog.id, response.responseText).overlay.beforeHideEvent.subscribe(function() {
                            newDialog.hide();
                        });
                    }
                    else if (response.status == 204) {
                        //fully successful submit: server returns no response content
                        newDialog.hide();
                    }
                    else {
                        ajaxFailure(response);
                    }
                }
            },
            failure: ajaxFailure,
            customevents: {
                onSuccess: function(eventType, args) { //this will run after the success callback above, so the response content will be present in the DOM
                    if (loadingSuccessCallback) {
                        loadingSuccessCallback.apply(args[0].argument[1]);
                    }
                },
                onComplete: function(eventType, args) { //this will be run after the dialog content is loaded initially, to clean up in either success or failure case
                    YAHOO.util.Dom.removeClass(document.body, 'in-progress');
                    args[0].argument[0].parentNode.removeChild(args[0].argument[0]);
                }
            },
            argument: [holderElement, null],
            cache: false
        });
    }
    
    var globalMessage;
    function showGlobalMessage(message) {
        globalMessage = yuiDialog('globalMessage', null, message, {text: 'Close This Message', handler: hideThis});
    }
    
    function ajaxFailure(response) {
        if (response.status == 401) { //HttpServletResponse.SC_UNAUTHORIZED
            window.location = '/login';
        }
        else if (response.status == 403) { //HttpServletResponse.SC_FORBIDDEN
            window.location = '/login?tooManySessions=true';
        }
        else if (response.status > 0) {
            var activeDialog = LADDERS.YUIDialogs.getActive();
            if (activeDialog) {
                activeDialog.cfg.setProperty('effect', null);
                activeDialog.hide();
            }
            showGlobalMessage('<strong>There was an error performing the specified action:<br/><br/>' + response.statusText + '(' + response.status + ')</strong>');
        }
    }
    
}

//wire global messaging straight into the JSON parser
if (typeof YAHOO != 'undefined' && typeof YAHOO.lang != 'undefined' && typeof YAHOO.lang.JSON != 'undefined' && typeof YAHOO.lang.JSON._parse == 'undefined') {
    YAHOO.lang.JSON._parse = YAHOO.lang.JSON.parse;
    YAHOO.lang.JSON.parse = function(s, filter) {
        var parsed = YAHOO.lang.JSON._parse(s, filter); 
        if (parsed != null) {
            if (parsed.GLOBAL_MESSAGING) {
                showGlobalMessage(parsed.GLOBAL_MESSAGING);
                delete parsed.GLOBAL_MESSAGING;
            }
            return parsed;
        }
    };
    
    YAHOO.lang.JSON.formToJSON = function(/*HTMLFormElement*/ theForm) {
        var formData = {};
        for (var i = 0; i < theForm.elements.length; i++) {
            var formElement = theForm.elements[i];
            if (formElement.name && formElement.name != '') {
                formDataElement = this.addDeepKey(formData, formElement.name);
                if (!formElement.disabled) {
                    if ((formElement.type == 'radio' || formElement.type == 'checkbox') && formElement.checked) {
                        formDataElement[formDataElement.length] = formElement.value; 
                    }
                    else if (formElement.type == 'select-one' && formElement.selectedIndex > -1) {
                        formDataElement[formDataElement.length] = formElement.options[formElement.selectedIndex].value;
                    }
                    else if ((formElement.type == 'text' || formElement.type == 'textarea' || formElement.type == 'hidden')) {
                        formDataElement[formDataElement.length] = formElement.value;
                    }
                }
            }
        }
        return formData;
    };
    
    YAHOO.lang.JSON.queryStringToJSON = function(/*String*/ url, /*Boolean*/ makeDeep) {
        var qsData = {};
        var idx = url.indexOf("?");
        var queryString = idx >= 0 ? url.substr(idx + 1) : url;
        // Remove the hash if any
        idx = queryString.lastIndexOf("#");
        queryString = idx >= 0 ? queryString.substr(0, idx) : queryString;
        params = queryString.split("&");
        for (var i = 0; i < params.length; i++) {
            var tokens = params[i].split("=");
            var qsDataElement = this.addDeepKey(qsData, tokens[0]);
            qsDataElement[qsDataElement.length] = unescape(tokens[1]).replace(/\+/g, ' ');  
        }
        return qsData;
    };
    
    YAHOO.lang.JSON.addDeepKey = function(JSON, key) {
        var keyAncestry = key.split('.');
        var node = JSON;
        for (var j = 0; j < keyAncestry.length; j++) {
            var keyAncestryCollectionFlag = keyAncestry[j].toString().match(/\[[0-9]+\]/g);
            if (keyAncestryCollectionFlag) {
                //this is an element in an array -- stick a number into the Ancestry
                keyAncestry[j] = keyAncestry[j].split('[')[0];
                var keyAncestryCollectionKey = keyAncestryCollectionFlag[0].slice(1, -1);
                keyAncestry.splice(j + 1, 0, new Number(keyAncestryCollectionKey));
            }
            if (!node[keyAncestry[j]]) {
                if (j + 1 == keyAncestry.length || keyAncestryCollectionFlag) {
                    //we're either at the bottom (create the value array) or need to create an intermediary object array
                    node[keyAncestry[j]] = [];
                }
                else {
                    //create another node
                    node[keyAncestry[j]] = {};
                }   
            }
            node = node[keyAncestry[j]];
        }
        return node;
    }
}

//auto-init tlc-menus
if (typeof YAHOO != 'undefined' && typeof YAHOO.widget != 'undefined' && typeof YAHOO.widget.Menu != 'undefined') {
    var tlcMenuEffect = YAHOO.env.ua.ie ? null : {effect: YAHOO.widget.ContainerEffect.FADE, duration: 0.1}; 
    var tlcMenuDelay = 100;
    var tlcMenuClassname = 'tlc-menu';
    var tlcMenuProperties = {
        position: 'dynamic',
        hidedelay: tlcMenuDelay,
        effect: tlcMenuEffect,
        shadow: false,
        zindex: 3
    };
    
    function preventMenuRefocus(event) {
        //YUI's Menu widget tries to be helpful on hide by returning focus to whatever element had focus before the menu opened.  We need to kill this behavior if it would cause a scroll, per RL-7429 
        var currentTarget = document.activeElement || document.currentTarget;
        if (currentTarget && YAHOO.util.Dom.getRegion(currentTarget).top > YAHOO.util.Dom.getDocumentScrollTop() + YAHOO.util.Dom.getViewportHeight()) {
            currentTarget.blur();
            document.body.focus();
        }
    }
    
    function addMenuTriggerMask(menu, trigger) {
        if (YAHOO.util.Dom.getElementsByClassName('trigger-mask', 'DIV', menu.element).length > 0) {
            return;
        }
        var triggerMask = document.createElement('DIV');
        var triggerRegion = YAHOO.util.Dom.getRegion(trigger);
        triggerMask.innerHTML = '&nbsp;';
        triggerMask.className = 'trigger-mask';
        triggerMask.style.height = triggerRegion.height + 'px';
        triggerMask.style.width = triggerRegion.width + 'px';
        menu.appendToHeader(triggerMask);
        menu.beforeShowEvent.subscribe(function() {
            YAHOO.util.Dom.setXY(triggerMask, triggerRegion);
        });
        YAHOO.util.Event.addListener(triggerMask, 'mouseout', function(event, menu) {
            var relatedTarget = YAHOO.util.Event.getRelatedTarget(event);
            if (!(relatedTarget == menu.element || YAHOO.util.Dom.isAncestor(menu.element, relatedTarget))) {
                menu.hide();
            }
        }, menu);
    }
    
    function initializeTlcMenus() {
        YAHOO.util.Dom.getElementsBy(function(el) {
            return YAHOO.util.Dom.hasClass(el, tlcMenuClassname) && el.id && el.id != '' && el.id.indexOf('yui-gen') == -1;
        },
        null, 
        null, 
        function(el) {
            var trigger = $(el.id + '-trigger');
            var triggerMask = document.createElement('DIV');
            var tlcMenu = new YAHOO.widget.Menu(el, tlcMenuProperties);
            tlcMenu.cfg.setProperty('context', [trigger, 'tl', 'bl', ['beforeShow', 'windowResize']]);
            addMenuTriggerMask(tlcMenu, trigger);
            tlcMenu.render();
            if (YAHOO.util.Dom.hasClass(trigger, 'glossy')) {
                YAHOO.util.Event.addListener(trigger, 'click', tlcMenu.show, null, tlcMenu);
                YAHOO.util.Event.addListener(trigger, 'click', function(event) {
                    YAHOO.util.Event.stopEvent(event);
                }, null, tlcMenu);
            }
            else {
                YAHOO.util.Event.addListener(trigger, 'mouseover', tlcMenu.show, null, tlcMenu);
            }
        });
    }
    YAHOO.util.Event.onDOMReady(initializeTlcMenus);
}

//auto-init faux selects with class 'faux-select'
if (typeof YAHOO != 'undefined' && typeof YAHOO.widget != 'undefined' && typeof YAHOO.widget.Button != 'undefined') {
    var fauxSelects = {};
    function createFauxSelect(el) {
        var selectWidth;  //this might seem redundant, but it's actually just thorough
        if (YAHOO.util.Dom.getRegion(el).width > 0) {
            selectWidth = YAHOO.util.Dom.getRegion(el).width + "px";
        }
        else {
            selectWidth = YAHOO.util.Dom.getStyle(el, 'width');
        }
        var selectStyles = {};
        for (var i = 0; i < el.style.length; i++) {
            selectStyles[el.style[i]] = el.style[el.style[i]];
        }
        if (el.id == '') {
            YAHOO.util.Dom.generateId(el, '');
        }
        var fauxId = el.id;
        el.id = el.id + '-original';
        fauxSelects[fauxId] = new YAHOO.widget.Button({ 
            id: fauxId, 
            name: fauxId,
            label: "<em class=\"yui-button-label\">" + el.options[el.selectedIndex].innerText + "</em>",
            type: "menu",  
            menu: el,
            container: el.parentNode.insertBefore(document.createElement('SPAN'), el),
            lazyloadmenu: false,
            menumaxheight: 200,
            disabled: el.disabled,
            tabindex: el.tabIndex
        });
        fauxSelects[fauxId].getMenu().getItems()[el.selectedIndex].cfg.setProperty('selected', true);
        fauxSelects[fauxId].getMenu().keyDownEvent.unsubscribeAll();
        YAHOO.util.Dom.addClass(fauxSelects[fauxId], 'faux-select');
        fauxSelects[fauxId].getMenu().cfg.setProperty('classname', 'faux-select');
        for (styleName in selectStyles) {
            YAHOO.util.Dom.setStyle(fauxSelects[fauxId], styleName, selectStyles[styleName]);
        }
        YAHOO.util.Dom.setStyle(fauxSelects[fauxId], 'width', selectWidth);
        YAHOO.util.Dom.setStyle(fauxSelects[fauxId].getMenu().element, 'minWidth', selectWidth);
        
        //methods
        fauxSelects[fauxId].options = fauxSelects[fauxId].getMenu().srcElement.options;
        fauxSelects[fauxId].selectedIndex = fauxSelects[fauxId].getMenu().srcElement.selectedIndex;
        fauxSelects[fauxId].add = function(/*Option*/ option, /*Number*/ optIndex) {
            this.getMenu().srcElement.options.add(option, optIndex);
            return this.getMenu().insertItem(option, optIndex);
        }
        fauxSelects[fauxId].remove = function(/*Number*/ optIndex) {
            this.getMenu().srcElement.options.remove(optIndex);
            return this.getMenu().removeItem(optIndex);
        }
        
        //selecting options with the keyboard
        function keyDownSelect(event) {
            var menuItems = this.getMenu().getItems();
            if (event.keyCode == 40 || event.keyCode == 39) {
                if (this.selectedIndex < menuItems.length - 1) {
                    this.set('selectedMenuItem', menuItems[this.selectedIndex + 1], false);
                }
                YAHOO.util.Event.stopEvent(event);
            }
            else if (event.keyCode == 38 || event.keyCode == 37) {
                if (this.selectedIndex > 0) {
                    this.set('selectedMenuItem', menuItems[this.selectedIndex - 1], false);
                }
                YAHOO.util.Event.stopEvent(event);
            }
        }
        fauxSelects[fauxId].on("keydown", keyDownSelect);
        fauxSelects[fauxId].getMenu().keyDownEvent.subscribe(function(event, args) {
            if (args[0].keyCode == 9 || args[0].keyCode == 13) { //tabbing away
                this._hideMenu();
            }
            else {
                keyDownSelect.call(this, args[0]);
            }
        }, fauxSelects[fauxId], true);
        
        //update the label and selectedIndex(es) when a menu item is chosen
        fauxSelects[fauxId].on("selectedMenuItemChange", function(event) {
            if (!event.newValue.cfg.getProperty('submenu')) {
                this.set("label", ("<em class=\"yui-button-label\">" + event.newValue.cfg.getProperty("text") + "</em>"));
                event.prevValue.cfg.setProperty('selected', false);
                event.newValue.cfg.setProperty('selected', true);
                this.getMenu().activeItem = event.newValue;
                event.newValue.focus();
                this.getMenu().srcElement.selectedIndex = event.newValue.index;
                this.selectedIndex = event.newValue.index;
                if (this.getMenu().srcElement.onchange) {
                    this.getMenu().srcElement.onchange(event);
                }
            }
            else {
                YAHOO.util.Event.stopEvent(event);
            }
        });
        
        fauxSelects[fauxId].getMenu().subscribe("beforeShow", function(event) {
            this.activeItem.cfg.setProperty('selected', true);
        });
        YAHOO.util.Event.addListener(
            YAHOO.util.Dom.getElementBy(
                function(labelEl) {
                    return labelEl.htmlFor == fauxId;
                },
                'LABEL',
                YAHOO.util.Dom.getAncestorByTagName(el, 'FORM')
            ),
            'click',
            fauxSelects[fauxId].focus,
            fauxSelects[fauxId],
            true
        );
    }
    YAHOO.util.Dom.getElementsByClassName('faux-select', 'SELECT', 'body_container', createFauxSelect);
    
    /****
     * fauxSelectJobFunction - Called when job function drop down is changed
     * On the following pages:
     *  - ecommerce/createRegistration.jsp
     *  - register/customSolutionRegistration.jsp
     *  - register/promoCodeRegistration.jsp
     * 
     */
    function fauxSelectJobFunction(theSelect) {
    	if (theSelect.selectedIndex > 1) {
    		disableFauxSelect(fauxSelects['jobLevel-hr']);
    	}
    	else {
    		enableFauxSelect(fauxSelects['jobLevel-hr']);
    	}
    	if (theSelect.selectedIndex != 2) {
    		disableFauxSelect(fauxSelects['jobLevel-agency']);
    	}
    	else {
    		enableFauxSelect(fauxSelects['jobLevel-agency']);
    	}
    	if (theSelect.selectedIndex != 3) {
    		disableFauxSelect(fauxSelects['jobLevel-raa']);
    	}
    	else {
    		enableFauxSelect(fauxSelects['jobLevel-raa']);
    	}
    	if (theSelect.selectedIndex < 4) {
    		disableFauxSelect(fauxSelects['jobLevel-others']);
    	}
    	else {
    		enableFauxSelect(fauxSelects['jobLevel-others']);
    	}
    }


    /****
     * initFauxSelectJobFunction - Called when job function drop down is changed
     * On the following pages:
     *  - ecommerce/createRegistration.jsp
     *  - register/customSolutionRegistration.jsp
     *  - register/promoCodeRegistration.jsp
     * 
     */
    function initFauxSelectJobFunction() {
        var theSelect = fauxSelects['jobFunction'];
        
        disableFauxSelect(fauxSelects['jobLevel-hr']);
        disableFauxSelect(fauxSelects['jobLevel-agency']);
        disableFauxSelect(fauxSelects['jobLevel-raa']);
        disableFauxSelect(fauxSelects['jobLevel-others']);
               
        if (theSelect.getMenu().activeItem.value == 9) {
        	enableFauxSelect(fauxSelects['jobLevel-hr']);
        }
        else if (theSelect.getMenu().activeItem.value == 10) {
        	enableFauxSelect(fauxSelects['jobLevel-agency']);
        }
        else if (theSelect.getMenu().activeItem.value == 11) {
        	enableFauxSelect(fauxSelects['jobLevel-raa']);
        }
        else {
        	enableFauxSelect(fauxSelects['jobLevel-others']);
        }
    }
    
    
    function enableFauxSelect(theSelect) {
    	theSelect.set('disabled', false);
    	YAHOO.util.Dom.setStyle(theSelect, "display", "block");
    }
    
    function disableFauxSelect(theSelect) {
    	theSelect.set('disabled', true);
    	YAHOO.util.Dom.setStyle(theSelect, "display", "none");
    }
}



if (typeof YAHOO != 'undefined' && typeof YAHOO.util != 'undefined' && typeof YAHOO.util.Connect != 'undefined') {
    YAHOO.util.Connect._asyncRequest = YAHOO.util.Connect.asyncRequest;
    YAHOO.util.Connect.asyncRequest = function(method, uri, callback, postData) {
        if (method.toUpperCase() == 'GET' && LADDERS.ajaxScope) {
            for (var ajaxScopeVar in LADDERS.ajaxScope) {
                uri = uri + (uri.indexOf('?') == -1 ? '?' : '&') + "AJAX_SCOPE_" + ajaxScopeVar + "=" + LADDERS.ajaxScope[ajaxScopeVar];
            }
        }
        else if (method.toUpperCase() == 'POST' && LADDERS.ajaxScope) {
            for (var ajaxScopeVar in LADDERS.ajaxScope) {
                postData = (!postData ? '' : (postData + '&')) + "AJAX_SCOPE_" + ajaxScopeVar + "=" + LADDERS.ajaxScope[ajaxScopeVar];
            }
        }
        return YAHOO.util.Connect._asyncRequest(method, uri, callback, postData);
    };
}