/*** /unisource/products.js **********************************/


Products = Class.create();

Products.Details = Class.create();
/**
 * Represents a Product Details pop-up
 */
Products.Details.prototype = {
    cart : null,
    
    productId : null,
    
    /**
    * Creates a new instance of the Product Details pop-up
    *
    * @param HTMLElement contentId the DOM ID of the pop-up container element
    */
    initialize : function(contentId) {
        this.contentId = contentId;
        
        new DeepFreeze(this, ['addToCart']);        
    },
    
    /**
    * Returns the shopping cart object
    *
    * @return Object
    */
    getCart : function() {
        var cartElement = $('mini-cart');
        
        if (cartElement) {
            this.cart = cartElement.cart;
        }        
        
        return this.cart;
    },
    
    /**
    * Displays the product details pop-up in the current screen
    *
    * @param Integer productId              the product ID to display
    * @param Boolean showAvailability       whether or not to display product availability information
    * @param String alternativeProductsUrl  the URL for the alternative product listing
    */
    show : function(productId, showAvailability, alternativeProductsUrl) {
        // moves the detail container outside the listing    
        var container = $(this.contentId);
        if (container.parentNode.tagName.toLowerCase() != 'body') {
            document.getElementsByTagName('body')[0].appendChild(container);
        }
        
        if(!showAvailability || showAvailability == 'undefined'){
            showAvailability = '';
        }else{
            showAvailability = '/' + showAvailability;
        }
        if(!alternativeProductsUrl || alternativeProductsUrl == 'undefined'){
            alternativeProductsUrl = '';
        }else{
            alternativeProductsUrl = '/' + alternativeProductsUrl;
        }
        var requestParameters = {
            alternativeProductsUrl: alternativeProductsUrl             
        };
        
        if (this.featuredProductId) {
            requestParameters.featuredProductId = this.featuredProductId;
        }        
         
        new Ajax.Updater(
            this.contentId + '-content', 
            Paths.www + '/uni_products/showDetails/' + productId + '/' + this.contentId + showAvailability,
            {
                parameters: requestParameters,
                onSuccess : function() {                                                        
                    $(this.contentId).details = this;
                    $(this.contentId).unipopup.show();   
                    this.productId = productId;     
                }.bindAsEventListener(this),
                evalScripts: true
            }
        );
    },
    
    /**
    * Hides this product details pop-up
    */
    hide : function() {
        $(this.contentId).unipopup.hide();   
    },
    
    
    /**
    * Adds the selected product to the mini-cart, if available
    */
    addToCart : function() {
        var products = {};
        products[this.productId] = $(this.contentId + '-quantity').value;
                
        this.getCart().observeOnce(
            MyUnisource.MiniCart.Event.PRODUCTS_SUBMITTED,        
            function() {
                this.hide();
                this.unfreeze();
            }.bind(this)
        );
        
        this.cart.submitProducts(products);
        
    }
}

Products.Listing = Class.create();


Products.Listing.quantities = {};
Products.Listing.listings = [];

Products.Listing.Event = {
    /**
    * Invoked when the product listing is about to be 
    * submitted in order to add products to the current
    * order
    */
    SUBMITTING : 'submitting', 
    
    /**
    * Invoked after the products have been added to the 
    * order.
    */
    SUBMITTED : 'submitted'
}

/**
 * Clears all retained quantities
 */
Products.Listing.clearAll = function() {
    Products.Listing.quantities = {};
}

/**
 * Retains quantities in all product listings that are still
 * on the page at the moment this function
 * is called.
 */
Products.Listing.retainAll = function() {
	Products.Listing.forAll(
		function(listing) {
			listing.retain();
		}
	);
}


/**
* Removes listings that are no longer part of the DOM
*/
Products.Listing.clearZombies = function()
{
    if (Products.Listing.listings)
    {
        var clearedListings =
            $A(Products.Listing.listings).findAll(
                function(listingId) {
                    var listingElement = $(listingId);
                    return listingElement && listingElement.listing && listingElement.listing.getForm();
                }
            );
            
        Products.Listing.listings = clearedListings;
    }
}

/**
 * Restores quantities in all product listings that are still
 * on the page.
 */
Products.Listing.restoreAll = function() {
    Products.Listing.clearZombies();
	Products.Listing.forAll(
		function(listing) {
			listing.restore();			
		}                  
	);                     
}

Products.Listing.forgetAll = function(productIds) {
    Products.Listing.forAll (
		function(listing) {
			listing.forgetQuantities(productIds);
		}
	);
}

Products.Listing.forAll = function(lambda) {
	if (Products.Listing.listings) {
		$A(Products.Listing.listings).each(	
			function(listingId){
				var listingElement = $(listingId);
				if (listingElement 
					&& listingElement.listing
					&& listingElement.listing instanceof Products.Listing) {
					lambda(listingElement.listing);
				}			
			}
		);
	}
}

/**
 * Function called whenever a listing is loaded.
 *
 * Overwrite with your favorite JS code.
 * e.g.
 * Products.Listing.onLoad = function (listing) {
 *      alert('Listing contains ' + listing.productIds + ' product(s).');
 * }
 *
 * @access public
 * @param Listing listing The loaded product listing
 * @return boolean False
 */
Products.Listing.onLoad = function (loaded) {
    /* overwrite */
    return false;   
}

/**
 * A Listing implementation for the Unisource product listing
 * that provides value retention for pagination
 */        
Products.Listing.prototype = Object.extend(new Listing(), 
{    

    /**
     * Retained product quantities for listings with an "Add to Cart" option
     */
    quantities : {},
    
    
    /**
    * The ID of the root element for the mini cart, to
    * which the actual cart object is attached
    *
    * @var string
    */
    miniCartId : 'mini-cart',
    
    
    /**
    * Indicates whether or not this listing is "frozen", in 
    * which case 
    *
    * @var bool
    */
    frozen: false,
    
    /**
     * The main constructor
     *
     * @param id                the listing ID
     * @param productIds        the products contained in this product listing
     * @param checkboxEnabled   indicates whether checkboxes should be enabled
     * @param enditableQuantity indicates whether or not the quantities are editable
     */
    initialize : function(id, productIds, checkboxEnabled, editableQuantity) {
        this.id = id;
        this.productIds = productIds;
        this.checkboxEnabled = checkboxEnabled || false;
        this.editableQuantity = editableQuantity || false;

        this.attach();
        
        if (Products.Listing.listings && $A(Products.Listing.listings).indexOf(id) == -1) {
            Products.Listing.listings.push(id);
        } else {
            Products.Listing.listings = [this];
        }
        
        this.refreshQuantities();
        Products.Listing.onLoad(this);
        this.observeOnce(
            Listing.Event.PAGE_CHANGED,
            this.defaultPageChangedHandler.bind(this)
        );
        
        this.observe(
            Products.Listing.Event.SUBMITTED,
            function() {
                this.unfreeze();
            }.bind(this)
        );
        new DeepFreeze(this, ['handleSubmit']);        
                    
    },
    
    defaultPageChangedHandler : function() {
        window.setTimeout(
        	function() {
                if( ! $(this.id) )
                    return;

		        // Focus on the first quantity field
		        var inputs = $(this.id).getElementsByTagName('input');
		        if (inputs) {
			        for (var i = 0, c = inputs.length; i < c; i++) {
			            if (inputs[i].id.match(/quantity/)) {
			                var input = inputs[i];  
			                $(this.id).scrollTo();
			                input.focus();
			                break;
			            }
			        }
				} 
			}.bind(this),
			200
		);
    
    },
    
    /**
    * Returns the form data associated with this listing
    */
    getForm : function() {
        return $(this.id).getForm();
    },
    
    
    /**
     * Attaches the event handlers required by this listing
     */
    attach : function() {
        Listing.prototype.initialize.apply(this, [this.id, this.productIds]);

        this.listing = $(this.id);
                
        
        // Register pagination event handlers
        if (this.editableQuantity) {
            this.observeOnce(
                Listing.Event.PAGE_CHANGING,
                this.retain.bind(this)
            );
            
            this.observeOnce(
                Listing.Event.PAGE_CHANGED,
                this.restore.bind(this)
            );

            this.observeOnce(
                Listing.Event.SORTING,
                this.retain.bind(this)
            );
            
            this.observeOnce(
                Listing.Event.SORTED,
                this.restore.bind(this)
            );
            
        }  
        
        
        var up = this;
        var exec = function(form) {
            var cart = up.getCart();
            if (cart) {

                if (form && up.editableQuantity) {
                    Event.observe(
                        form, 
                        'submit',
                        function(e, form) {
                            Event.stop(e);
                            var form = $(up.id).getForm();    
                            if (form) {
                                up.handleSubmit(form);
                            }
                        }.bindAsEventListener(up)
                    );
                } 
                cart.observe(
                    MyUnisource.MiniCart.Event.PRODUCT_SUBMISSION_FAILED,
                    function() {
                        up.unfreeze();
                    }.bind(up)
                );   
                
            } 
            
        };
        
        if(document.loaded) {
            var form = $(this.id).getForm();
            exec(form);
        } else {
            Event.observe( window, 'load', function() {                        
                var element = $(up.id);
                if (element.getForm) {
                    var form = $(up.id).getForm();
                    exec(form);
                }
            } );
        }
            
    },
    
    clearOnSubmit : function() {
        var cart = this.getCart();
        if (cart) {
            cart.observeOnce(
                MyUnisource.MiniCart.Event.PRODUCTS_SUBMITTED,
                function(products) {
                    for(var i = 0, length = products.length;i<length;i++) {
                        var product = products[i];
                        var quantityElement = this.getQuantityElement(product.id);
                        var oldValue = 0;
                        if (quantityElement) {            
                            oldValue = quantityElement.value;            
                            quantityElement.value = '';                                
                        } 
                        if (this.order) {
                            if (this.order.hasProduct(product.id)) {
                                this.order.refreshLine(product.id, oldValue, 0);
                            }
                        }
                    }
                    var productIds = $A(products).map(
                        function(product) {
                            return product.id;
                        }
                    ).toArray()

                    this.forgetQuantities(productIds);                                        
                    if (Products.Listing.listings) {
                        Products.Listing.forgetAll(productIds);                    
                    }                         

                }.bind(this)
            );            
        }     
    },
    
    
    /**
     * Creates hidden elements for retained quantities before submitting
     * the form
     *
     * @param event the submit event
     * @param form  the form being submitted
     */
    handleSubmit : function(form) {
        Products.Listing.retainAll();
        
        $A(Products.Listing.listings).each(
            function(listingId) {    
                var listingElement = $(listingId);
                
                if (listingElement && listingElement.listing instanceof Products.Listing) {
                    listingElement.listing.populateRetainedQuantities(form);
                }
            }
        );
        
        this.submitToMiniCart(form);        
    },
    
    /**
    * Removes the quantities for the specified products from this 
    * listing.
    * 
    * @param Array productIds an array of product IDs
    */
    forgetQuantities: function(productIds) {
    	$A(productIds).findAll(
    		function(productId) {
    			var result =
                ( 
                    this.quantities[productId]
                    ||
                    Products.Listing.quantities[productId]
                );
                return result;    
    		}.bind(this)
    	).each(
    		function(productId) {
                if (this.quantities[productId]) {
    			    delete this.quantities[productId];    			
                }
                if (Products.Listing.quantities[productId]) {
                    delete Products.Listing.quantities[productId];
                }
    		}.bind(this)
    	);
    },
    
    /**
    * Adds all products in this form to the mini-cart, including
    * the ones that have been retained from pagination.
    */
    submitToMiniCart: function(form) {
        if (!form) {
            form = this.order.form;
        }
        this.fire(Products.Listing.Event.SUBMITTING);
    	this.retain();
    	this.refreshQuantities();
    	var quantities = {};
    	$H(this.quantities).each(
    		function(entry) {
    			if (entry.value > 0) {    			
    				quantities[entry.key] = entry.value;
    			}
    		}
    	);    	
        
    	var cart = this.getCart();
        var options = {};
        if (form) {
            $(form).getInputs().findAll(function(e) {return e.type == 'hidden'}).each(
                function(e) { 
                    
                    var match = e.name.match(/^Options\[(.+)\]$/)            
                    if (match) {
                        options[match[1]] = e.value;
                    }
                }
            );
        }
        
        this.clearOnSubmit();
    	cart.submitProducts(quantities, options);
    },
    
    /**
    * Returns the mini-cart instance to which products will 
    * be added
    */
    getCart : function() {
    	var cartElement = $(this.miniCartId);
    	var cart = (cartElement) ? cartElement.cart : null;
        if (cart) {
            if (!cart.productListings) {
                cart.productListings = {};
            }
            if (cart.productListings[this.id] !== this) {
                cart.productListings[this.id] = this;
                cart.observe(
                    MyUnisource.MiniCart.Event.PRODUCTS_SUBMITTED,
                    function() {
                        this.fire(Products.Listing.Event.SUBMITTED);
                    }
                );
            }        
        }
        return cart;
    },
    
    
    /**
     * Creates hidden elements only for this listing's retained
     * quantities
     *
     * @param form the form to which new elements will be added
     */
    populateRetainedQuantities : function(form) {
        this.refreshQuantities();
        
        $H(this.quantities).each(
            function(entry) {       
                if (!this.hasProduct(entry.key)) {
                    var input = this.createQuantityInput(form, entry.key, entry.value);
                    form.appendChild(input);
                }
            }.bind(this)
        );    
    },
    
    refreshQuantities: function() {
    	this.quantities = Products.Listing.quantities;
    },
    
    
    /**
     * Determines if the specified product is part of 
     * the current listing.
     *
     * @param productId the ID of the product to check
     */
    hasProduct: function(productId) {
        return $A(this.productIds).indexOf(productId) != -1
    },
    
    
    /**
     * Creates a hidden form element for a single product quantity
     * and returns it
     *
     * @return HTMLElement
     */
    createQuantityInput : function(form, productId, quantity) {
        var input = document.createElement('input');
        input.type = 'hidden';
        input.name = this.getQuantityElementName(productId);
        input.value = quantity;
        return input;
    },
        
    
    /**
     * Returns the name of the quantity element for the specified
     * product ID
     *
     * @param productId the ID of the product
     */
    getQuantityElementName : function(productId) {
        return 'quantity[' + productId + ']';
    },
    
    
    /**
     * Returns the element for the product quantity
     *
     * @param productId the ID of the product
     */
    getQuantityElement : function(productId) {
        return $(this.id + '-product-' + productId + '-quantity');
    },
    
    /**
     * Retains product selections
     */
    retain : function() {
        $A(this.productIds).each(
            function(productId) {
                var quantityElement = this.getQuantityElement(productId);
                
                if (quantityElement && (quantityElement.value !== '')) {
                    Products.Listing.quantities[productId] 
                        = this.quantities[productId] 
                        = quantityElement.value;
                }
                
            }.bind(this)
        );        
    },
    
    
    
    /**
     * Restores previously selected quantities
     */        
    restore : function() {
        $H(Products.Listing.quantities).each(
            function(entry) {
                var quantityElement = this.getQuantityElement(entry.key);
                    
                if (quantityElement) {
                	var oldValue = quantityElement.value;
                    quantityElement.value = entry.value;
                } 
            }.bind(this)                        
        ); 
        
        if (this.order) {
            this.order.updateAllAmounts();
        }
        
        
    },
    
    /**
    * "Freezes" this listing, thereby preventing submit events
    * from being handled.
    */
    freeze : function() {
        this.frozen = true;
    },
    
    /**
    * Removes the flag causing this listing to ignore "submit" 
    * events
    */
    unfreeze : function() {
        this.frozen = false;
    },
    
    /**
    * Displays an inventory popup for a product
    * 
    * @param string The product ID
    */
    showInventoryFor: function (productID) {
        ////
        if (typeof this.inventoryRequest != 'undefined' 
                && this.inventoryRequest != null)
        {
            this.inventoryRequest.transport.onreadystatechange = Prototype.emptyFunction;
            this.inventoryRequest.transport.abort();
            Ajax.activeRequestCount--;
        }
        this.inventoryRequest = new Ajax.Request(
            Paths.www + '/uni_products/fetchInventory/' + productID, 
            {
                onSuccess: function (response) {
                    var result = response.responseJSON;                
                    if (result.success && result.quantity > 0) {
                        $(this.id + '-inventory-quantity-box-quantity').update(result.quantity);
                        $(this.id + '-inventory-quantity-box-uom-code').update(result.uom_code);
                        $(this.id + '-inventory-quantity-box').show();
                        $(this.id + '-inventory-error-message').hide();                        
                    } else {
                        $(this.id + '-inventory-quantity-box').hide();
                        $(this.id + '-inventory-error-message').show();
                        
                    }
                    $(this.id + '-inventory').unipopup.show();
                    this.inventoryRequest = null;
                }.bind(this)
            }
        );
        
    }    
    
}
);




/*** /unisource/highlight.js **********************************/


Highlight = Class.create();

Highlight.prototype = {    
    initialize: function(element) {        
        element = $(element);
        element.__highlight = this;
        this.element = element;
        Event.observe(element, 'mouseover',
            this.handleMouseOver.bindAsEventListener(this)
        );            
        Event.observe(element, 'mouseout',
            this.handleMouseOut.bindAsEventListener(this)
        );          
        element.style.filter ="progid:DXImageTransform.Microsoft.Alpha(opacity=100)"
          
    },
    
    replaceClass: function(element, enabled) {
        var newStyle = (enabled) ? 'on' : 'off';
        var oldStyle = (enabled) ? 'off' : 'on';
        
        element.className = element.className.replace(
            oldStyle,
            newStyle);
    },
    
    replaceSource : function(element, enabled) {
        var newSuffix = (enabled) ? 'on' : 'off';
        var oldSuffix = (enabled) ? 'off' : 'on';
        element.src = element.src.replace(
            oldSuffix,
            newSuffix);   
    },
    
    freeze : function() {
        this.frozen = true;
    },
    
    unfreeze : function() {
        this.frozen = false;
    },
    
    handleMouseOver : function(event) {
        this.setEnabled(true);
    },
    
    handleMouseOut : function(event) {
        this.setEnabled(false);
    },    
    
    changeOpacity: function(enabled) {
        if (enabled) {
            opacity = 0.5;
        } else {
            opacity = 1.0;
        }
        this.element.style.opacity = opacity;
        if (this.element.filters) {
            this.element.filters.item("DXImageTransform.Microsoft.Alpha").opacity= opacity * 100;
        }
    },
    
    setEnabled : function(enabled) {
        if (this.frozen) {
            return;
        }
        if (this.element.tagName == 'IMG' || this.element.tagName == 'INPUT') {
            this.changeOpacity(enabled);
        } else {
            $A(this.element.getElementsByTagName('SPAN')).each(
                function(element) {
                    if ($(element)) {
                        this.replaceClass($(element), enabled);
                    }
                }.bind(this)
            );
            $A(this.element.getElementsByTagName('IMG')).each(
                function(element) {
                    if ($(element)) {
                        this.replaceSource($(element), enabled);
                    }
                }.bind(this)
            );
        }
        
    }        
};

Highlight.enable = function(element) {
	if (typeof(element) == 'string') {
    	element = document.getElementById(element);
	}
    if (element && !element.__highlight) {
        new Highlight(element);
    }
}

Highlight.enableButton = function(element) {
    if (Highlight.buttonsEnabled) {
        Highlight.enable(element);            
    }    
}
Highlight.enableButtons = function() {
    if (Highlight.buttonsEnabled) {
        $$('input.button').each(
            function(element) {
                Highlight.enable($(element));
            }
        );
        $$('img.button').each(
            function(element) {
                Highlight.enable($(element));
            }
        );
    }
}

Element.addMethods({
    stopClickPropagation: function (element) {
        Event.observe(
            element,
            'click',
            function(event) {
                var link = Event.element(event);                                    
                if (event.preventDefault) {
                    event.stopPropagation(); // Gecko
                } else {
                    event.cancelBubble = true; // Trident
                }                                    
            }
        );     
    }
}
);




/*** /unisource/popup.js **********************************/


UniPopup = Class.create();

/**
 * Creates a popup using the content of the given
 * id's container.
 *
 * Popups with a single button (either image or input)
 * are closed on the press of the Return key.
 *
 */
UniPopup.prototype = {
    _visible: false,
    container: null,
    timeout: null,
    initialize: function(id, modal, position, closebox, draghandle, hidden) 
    {
        this.id = id;
        this.container = $('popup-container');
        
        this.moveToContainer();
                
        this.modal = modal;
        this.position = position;
        this.closebox = closebox;
        this.draghandle = draghandle;
        
        // determines whether the popup has a single action
        var imgs = $(id).getElementsByTagName('img');
        var buttonCount = 0;
        for (var i = 0; i < imgs.length; i++) {
            if (imgs[i].className && imgs[i].className.indexOf('button') != -1) {
                buttonCount++;
            }
        }
        var inputs = $(id).getElementsByTagName('input');
        for (var i = 0; i < inputs.length; i++) {
            if (inputs[i].type && (inputs[i].type == 'submit' || inputs[i].type == 'image')) {
                buttonCount++;
            }
        }
        if (buttonCount == 1) {
            this.pseudoModal = true;
        } else {
            this.pseudoModal = false;
        }
        
        if(!hidden) {
            this.show();            
        }
    },
    
    /**
    * If a top-level container is available for pop-ups, the pop-up element is moved to it. This is necessary
    * in order to prevent side effects resulting from positioning
    */
    moveToContainer : function() {
        var popupElement = $(this.id);
        if (this.container !== null && popupElement.parentNode !== this.container) {
            var removedNode = popupElement.parentNode.removeChild(popupElement);
            this.container.appendChild(removedNode);
        }
    },
    
    show: function(event) {    
                       
        this._visible = true;        
        
        // Centerizing popup please
        if(this.position == 'center') {
            if(window.innerWidth) { // FF and Safari
                var popup_x     = window.innerWidth;
                var popup_y     = window.innerHeight;
                var offset_x    = window.pageXOffset;
                var offset_y    = window.pageYOffset;        
            } else {                // IE
                var popup_x     = document.documentElement.clientWidth;
                var popup_y     = document.documentElement.clientHeight;
                var offset_x    = document.documentElement.scrollLeft;
                var offset_y    = document.documentElement.scrollTop;        
            }
            
            var dimensions = $(this.id).getDimensions();
            
            //alert(dimensions.width + ':' + dimensions.height);

            popup_x = (popup_x - dimensions.width) * 0.5 + offset_x;
            popup_y = (popup_y - dimensions.height) * 0.5 + offset_y;
            
            var _position = 'exact' + popup_x + ',' + popup_y;
        } else {
            var _position = this.position;
        }
        
        var popup = $(this.id).popup;
        if (!popup) {
            // create the popup
            var options = {
                modal: this.modal,
                position: _position,
                closebox: this.closebox,
                draghandle: this.draghandle,
                hidden: true
            };
            popup = new Popup(this.id, null, options);
        } else {
            popup.options.position = _position;
        }
        
        UniPopupStack.push(this);
        $(this.id).popup.show();  
        if (this.onopen) {
            window.setTimeout(
                this.onopen,
                100
            );
        }
    },
    /**
     * Returns true if the popup is visible.
     *
     * @access public
     * @return boolean
     */
    visible: function () {  
        if (this.timeout != null) {
            clearTimeout(this.timeout);
            this.timeout = null;
        }          
        return this._visible;
    },
    hide: function(event) {
        //Event.stop(event);  
        $(this.id).popup.hide();
        if (this.onclose) {
            this.onclose();
        }
                
        if (this.pseudoModal) {
            UniPopupStack.remove(this);
        }
        
        var duration = $(this.id).popup.options.duration * 1000;
        var _this    = this;
        this.timeout = setTimeout(function () {_this._visible = false;}, duration);
    },
    /**
     * Returns true if the popup is not visible.
     *
     * @access public
     * @return boolean
     */
    hidden: function () {                         
        return !this._visible;
    }
}

/**
 * Controls the current list of visible pop-ups that can 
 * be closed with a simple press of the Return key.
 *
 * @author Dimitry Zolotaryov
 * @author2 Ahmed Al-Saadi
 */
UniPopupStack = {}
/**
 * Holds the visible popup stack
 */
UniPopupStack.stack = new Array();
/**
 * Add a pop-up to the stack
 *
 * @access public
 * @param UniPopup popup The popup 
 * @return void
 */
UniPopupStack.push = function (popup) {
    var windowEvent = function (e) {
        if ((e.keyCode == 13 || e.keyCode == 27) && UniPopupStack.stack.length > 0) {
            if (!UniPopupStack.testPopupTarget(Event.element(e))) {
                switch(e.keyCode) {
                    case 13:
                        // Enter key pressed 
                        var popupElement = UniPopupStack.pop();
                        if(popupElement.actionFn) {
                            popupElement.actionFn();
                            Event.stop(e);
                            return false;
                        }
                        return true;
                    case 27:
                        // Escape key pressed
                        UniPopupStack.pop();
                        Event.stop(e);
                        return false;
                }
            }
        }
    }
    Event.observe(document, 'keypress', windowEvent);
    
    // redeclare the push function                          
    UniPopupStack.push = function (popup) {
        var foundIndex = false;
        for (var i = 0; i < this.stack.length && foundIndex == false; i++) {
            if (this.stack[i] == popup) {
                foundIndex = i;
            }   
        }
        if (foundIndex == false) {
            this.stack.push(popup);
        } else {
            this.stack.splice(foundIndex, 1);
            this.stack.push(popup);
        }
    }
    return UniPopupStack.push(popup);
}
/**
 * Tests to see if the press happened in the popup
 *
 * @access public
 * @return bool test result
 */
 UniPopupStack.testPopupTarget = function (target) {
    // tests that the action was not taken within the popup
    var inPopup = false;
    while (target && (target = target.parentNode) && !inPopup) {
        if (target.className && target.className.indexOf('popup') != -1) {
            inPopup = true;
        }
    }
    return inPopup;
 } 


/**
 * Pops the top most visible popup
 * from view.
 *
 * @access public
 * @return moxed Either the popup or false if none is present
 */
UniPopupStack.pop = function () {
    if (this.stack.length > 0) {
        var popup = this.stack[this.stack.length - 1];
        if (popup) {
            popup.hide();
        }
        return popup;
    } else {
        return false;
    }
}
/**
 * Remove a popup from the stack.
 *
 * @access public
 * @param UniPopup popup The popup to remove
 * @return boolean True if the element was found
 */
UniPopupStack.remove = function (popup) {
    var found = false;
    for (var i = 0; i < this.stack.length && found == false; i++) {
        if (this.stack[i] == popup) {
            this.stack.splice(i, 1);
            found = true;
        }
    }
    return found;
}



/*** /unisource/button.js **********************************/


UniButton = Class.create();

UniButton.prototype = {
    initialize : function(id) {
        this.id = id;
        this.button = $(id);
        
        if (this.button) {
            this.attach();
        }
    },
    
    
    attach: function(){}
}

UniButton.AjaxSubmit = Class.create();
UniButton.AjaxSubmit.prototype = Object.extend(
    new UniButton(),
    {
        parameters: {},
        
        url: null,
        
        initialize : function(id, isDefault, parameters, url) {
            UniButton.prototype.initialize.apply(this, [id]);
            this.isDefault = isDefault;
            if (parameters) {
                this.parameters = parameters;
            }
            
            if (url) {
                this.url = url;
            }
        },
        
        attach : function() {
                
            if (this.isDefault) {
                Event.observe(
                    this.button.form,
                    'submit',
                    this.handle.bindAsEventListener(this)
                );
            } else {
                Event.observe(
                    this.button,
                    'click',
                    this.handle.bindAsEventListener(this)
                );
            }
        },
        handle : function(event) {
            Event.stop(event);
            
            var requestParameters = {
                parameters: Form.serialize(this.button.form),
                evalScripts: true
            };
            
            $H(this.parameters).each(
                function(entry) {
                    requestParameters[entry.key] = entry.value;
                }
            );
            
            this.sendRequest(requestParameters);
        
        },   
        
        getUrl : function() {
            return (this.url) ? Paths.www + this.url : this.button.form.action;
        }             
    }
);

UniButton.AjaxSubmit.Simple = Class.create();

UniButton.AjaxSubmit.Simple.prototype = Object.extend(
    new UniButton.AjaxSubmit(),
    {
        sendRequest : function(parameters) {
            new Ajax.Request(
                this.getUrl(),
                parameters                
            );
        }
    }
);

UniButton.AjaxSubmit.Update = Class.create();

UniButton.AjaxSubmit.Update.prototype = Object.extend(
    new UniButton.AjaxSubmit(),
    {
        initialize : function(id, isDefault, parameters, url, update) {
            this.update = update;
            UniButton.AjaxSubmit.prototype.initialize.apply(this, [id, isDefault, parameters, url]);
        },
        sendRequest : function(parameters) {
            new Ajax.Updater(
                this.update,
                this.getUrl(),
                parameters                
            );
        }
    }
);


/*** /unisource/dropdown.js **********************************/


DropDown = Class.create();

DropDown.lastZIndex = 50; 

/**
 * The current drop down. It may not
 * be open.
 *
 * @static
 * @var Boolean current
 */
DropDown.current = null;

/**
 * Sets the current drop down instance.
 * 
 * If one is already set, it will be closed and the
 * next will be opened.
 *
 * @static
 * @param DropDown dropDown
 */
DropDown.setCurrent = function (dropDown) {
    if (this.current != null) {
        // the timeout compensates for the animation
        // e.g. if expanding, we should wait till it's over before closing
        this.current.scheduleCollapse();
        
    }
    this.current = dropDown;
}

/**
 * Removes the given drop down from as current if
 * it is infact the current one.
 *
 * @static
 * @param DropDown dropDown
 */        
DropDown.remCurrent = function (dropDown) {
    if (this.current == dropDown) {
        this.current = null;
    }
}

/**
 * Key handler for the entire document. 
 *
 * If a drop-down is open, it is considered the 
 * target of key events.
 */
DropDown.documentKeyPress = function (event) {
    if (!event) event = window.event;
    if (DropDown.current && DropDown.current.expanded) {            
        var letter = String.fromCharCode(event.keyCode).toUpperCase();
        if (letter >= 'A' && letter <= 'Z') {
            DropDown.scrollTo(letter, DropDown.current.element);
        }
    }
}
Event.observe(document, 'keydown', DropDown.documentKeyPress);

/**
 * Scrolls to the indicated letter in the 
 * given container
 *
 * @param Char letter The letter to scroll to
 * @param Node container The container object
 */
DropDown.scrollTo = function (letter, container) {     
    var ul = container.getElementsByTagName('ul');
    ul = ul.length > 0 ? ul[0] : null;
    
    if (ul != null) {
        var items = ul.getElementsByTagName('li');
        var found = -1;         
        
        for (var i = 0; i < items.length; i++) {
            if (!Element.hasClassName(items[i], 'nofocus')) {
                Element.removeClassName(items[i], 'focus');
                if (found == -1) {
                    var text = items[i].innerHTML;       
                    // strips the tags
                    while (text.match(/<\/?[^>]+>/)) {
                        text = text.replace(/<\/?[^>]+>/, '');
                    }
                    // strips white space
                    text = trim(text);                
                    if (text.substr(0, 1) == letter) {
                        found = i;
                    }
                }
            }
        }            
        if (found > -1) { 
            // div (scrolling) > ul > li
            var li = items[found];
            var liHeight = Element.getHeight(li);
            var liBottom = li.offsetTop - li.parentNode.offsetTop + liHeight;
            var scrollTop = liBottom - liHeight;
            ul.parentNode.scrollTop = scrollTop > 0 ? scrollTop : 0;
            
            Element.addClassName(li, 'focus');
        }
    } // end id ul != null
}
                               
DropDown.prototype = {
    /**
     * The current animation
     */
    animation: null,
    animationDuration : 0.3,
    /**
     * Indicates whether a collapse was scheduled
     */
    collapseScheduled: false,
    element : null,
    options : null,
    selector : null,
    expanded: false,
    selectedId : null,
    selectedCaption: null,
    clickAwayObserver : null,
            
    initialize : function(id, selectedId, defaultId) {
        this.id = id;
        this.element = $(id + '-dropdown');
        this.options = $(id + '-options');
        this.selector = $(id + '-selector');
        this.selectedCaption = $(id + '-selected-caption');
        this.setDimensions();
        this.attachEvents();        
        if (selectedId) {
            this.select(selectedId);
        } else if (defaultId) {
            this.selectedCaption.update($(this.id + '-option-' + defaultId).innerHTML);
        } else if (this.selectedCaption.innerHTML == '') {
            var items = this.options.getElementsByTagName('LI');
            this.selectedCaption.update(items[0].innerHTML);
        }
        
        this.options.style.zIndex = --DropDown.lastZIndex;
        this.element.style.zIndex = --DropDown.lastZIndex;
        
    },
    
    setDimensions : function() {
        var maximumLength = this.getMaximumLength();
        var selectorDimensions = this.selector.getDimensions();
        var allottedSpace = (maximumLength - 2)*7;
        var width;
        if (allottedSpace > selectorDimensions.width) {
            width = allottedSpace;
        } else {
            width = selectorDimensions.width;
        }
        
        this.options.style.width =  width + 'px';
    },
    
    attachEvents : function() {
        Event.observe(        
            this.element,
            'click',
            function(e) {
                Event.stop(e);
                this.toggle();
            }.bindAsEventListener(this)
        );
        
        // alert('binding event');
        // Event.observe(document.documentElement, 'keypress', this.keyPressedEvent.bindAsEventListener(this));       
        // this.element.onkeypress = function () { alert('key') }
        
        $A(this.options.getElementsByTagName('LI')).each(
            function(element) {
                var itemId = this.extractId(element);
                
                Event.observe(
                    element,
                    'mouseover',
                    function(e) {
                        Event.element(e).addClassName('hover');
                    }.bindAsEventListener(this, itemId)
                );
                
                Event.observe(
                    element,
                    'mouseout',
                    function(e) {
                        Event.element(e).removeClassName('hover');
                    }.bindAsEventListener(this, itemId)
                );
                
                Event.observe(
                    element,
                    'click',                    
                    function(e, itemId) {
                        this.select(itemId, true);
                        
                    }.bindAsEventListener(this, itemId)
                )
            }.bind(this)
        );              
    },
    
    /**
     * Event handler for handling the pressing of a key
     * on the drop-down.
     *
     * @param Event e
     */
    keyPressedEvent: function (e) {
        alert('here');
        /*
        if (!e) e = window.event;
        alert(e.keyCode);
        */
    },
    
    attachClickAway : function() {
        this.clickAwayObserver = function(e) {
            Event.stop(e);
            this.collapse();
            this.removeClickAway();
        }.bindAsEventListener(this);
        
        Event.observe(
            document.documentElement, 
            'click', 
            this.clickAwayObserver
        );
    },
    
    removeClickAway : function() {
        Event.stopObserving(document.documentElement, 'click', this.clickAwayObserver);
    },
    
    extractId : function(listItem) {
        var matches = listItem.id.match('-option-(.+)$');
        var id = null;
        if (matches && matches.length == 2) {
            id = matches[1];
        }
        return id;
    },
    
    getMaximumLength : function() {
        var maximumLength = 0;
        var items = this.options.getElementsByTagName('LI');
        
        for (var i=0;i<items.length;i++) {
            var text = trim(items[i].innerHTML);
            if (text.length > maximumLength) {
                maximumLength = text.length;
            } 
        }
        
        return maximumLength;
    },
    
    resetSelection: function() {
        if (this.selectedId) {
            $(this.id + '-option-' + this.selectedId).removeClassName('selected');
        }                          
    },
    
    select: function(itemId, fireEvent) {
        this.resetSelection();
        var option = $(this.id + '-option-' + itemId);
        if (option) {
            option.addClassName('selected');
        }
        this.selector.addClassName('selected');
        this.selectedId = itemId;
        $(this.selectedCaption).update(option.innerHTML);
        if (fireEvent) {
            this.collapse(
                {                    
                    beforeStart: function() {
                        this.onSelect(this.selectedId);
                    }.bind(this)
                }
        );
        } else {
            this.collapse();
        }
        
    },
    
    toggle :function() {
        if (this.expanded) {
            this.collapse();
        } else {
            this.expand();            
        }
    },
    
    expand : function() {
        DropDown.setCurrent(this);
        if (this.expanded || this.animation != null) {
            return;
        }
        
        //$(this.options).show();    
        this.setDimensions();
        $(this.options).style.top = '100%';
        
        // resets the list items' classes
        var lis = this.element.getElementsByTagName('li');                     
        for (var i = 0; i < lis.length; i++) {
            Element.removeClassName(lis[i], 'focus');
        }
        
        this.animation = new Effect.SlideDown(
            this.options,            
            {
                duration: this.animationDuration,   
                afterFinish : function() {      
                    this.attachClickAway();
                    this.animation = null;
                    this.expanded = true;
                    this.callCollapse();
                }.bind(this)
            }
        );
    },
    
    collapse : function(options) {
        DropDown.remCurrent(this);
        if (!this.expanded || this.animation) {
            return;
        }
        options = options || {}; 
        
        this.collapseScheduled = false;
        this.animation = new Effect.SlideUp(
            this.options,            
            {
                duration: this.animationDuration,   
                beforeStart : options.beforeStart || function () {},
                afterFinish : function() { 
                    if (options.afterFinish) {
                        options.afterFinish();
                    }
                    this.removeClickAway();
                    this.animation = null; 
                    this.expanded = false;                   
                }.bind(this)
            }
        );
    },
    
    /**
     * Schedules a collapse
     */
    scheduleCollapse: function() {    
        this.collapseScheduled = true;
        this.collapse();              
    },
    
    /**
     * Run by the openining animation in case a close
     * call was scheduled.
     */
    callCollapse: function() {
        if (this.collapseScheduled) {
            this.collapse();               
        }
    }
}

function trim(str, chars) {
    return ltrim(rtrim(str, chars), chars);
}

function ltrim(str, chars) {
    chars = chars || "\\s";
    return str.replace(new RegExp("^[" + chars + "]+", "g"), "");
}

function rtrim(str, chars) {
    chars = chars || "\\s";
    return str.replace(new RegExp("[" + chars + "]+$", "g"), "");
}


/*** /unisource/debug.js **********************************/


/**
 * Unisource Andromeda v. 2.0
 * 
 * Copyright 2007 by High-Touch Communications Inc.
 * 
 * 
 * This software was developed internally by High-Touch Communications Inc.
 * for Unisource. In no event shall this source code be published.
 */

/**
* Represents a debug console that can be used to display
* any non-fatal errors generated during the execution of a
* Unisource Web page when the site is running in a development
* or staging environment
*/
DebugConsole = Class.create(
    {
    
        /**
        * The ID of the top-level element that contains the debug console
        *
        * @var string
        */
        id: null,
        
        /**
        * The pop-up that contains the debug console
        *
        * @var HTMLElement
        */
        consolePopup : null,
        
        /**
        * Creates a new debug console
        */
        initialize : function(id) {
            this.id = id;
            this.consolePopup = $(id);
            this.consolePopup.debug = this;
        },
        
        /**
        * Shows the error console
        */
        show : function() {
            this.consolePopup.unipopup.show();
        },
        
        /**
        * Hides the error console
        */
        hide: function() {
            this.consolePopup.unipopup.hide();
        },
        
        /**
        * Returns the HTML element in which the specified error's stack is
        * contained
        *
        * @param Integer  errorIndex the index of an error in the console
        */
        getStackTraceElement : function(errorIndex) {
            return $(this.id + '-error-' + errorIndex + '-stack-trace');
        },
        
        /**
        * Returns the HTML element corresponding to the link that performs
        * the specified action according to the naming convention used in 
        * debug_console.thtml
        *
        * @param Integer errorIndex the index of an error in the console
        * @param string  action     the name of the action
        */
        getActionLink: function(errorIndex, action) {
            return $(this.id + '-error-' + errorIndex + '-action-' + action);
        },
        
        /**
        * Shows the stack trace for the error with the specified idex
        *
        * @param Integer errorIndex the index of the error for which the stack trace will
        *       be displayed        
        */
        showStackTrace: function(errorIndex) {
            var stackTrace = this.getStackTraceElement(errorIndex);
            if (stackTrace) {
                stackTrace.show();
            }
            
            var showAction = this.getActionLink(errorIndex, 'stack-trace-show');
            if (showAction) {
                showAction.hide();
            }
            
            var hideAction = this.getActionLink(errorIndex, 'stack-trace-hide');
            if (hideAction) {
                hideAction.show();
            }
            
        },
        
        /**
        * Hides the stack trace for the error with the specified idex
        *
        * @param Integer errorIndex the index of the error for which the stack trace will
        *       be hidden        
        */
        hideStackTrace : function(errorIndex) {
            var stackTrace = this.getStackTraceElement(errorIndex);
            if (stackTrace) {
                stackTrace.hide();
            }
            
            var showAction = this.getActionLink(errorIndex, 'stack-trace-show');
            if (showAction) {
                showAction.show();
            }
            
            var hideAction = this.getActionLink(errorIndex, 'stack-trace-hide');
            if (hideAction) {
                hideAction.hide();
            }
                    
        }
    }
);


/*** /unisource/inactivity_timeout.js **********************************/


Unisource.InactivityTimeout = Class.create(
    {
        initialize : function(timeout, warningThreshold, gracePeriod) {
            this.timeout = timeout * 1000;
            this.warningThreshold = warningThreshold * 1000;                    
            this.gracePeriod = gracePeriod * 1000;
            
            this.timeBombs = {};
        
            this.attachEvents();
            
            Ajax.Responders.register(
                {
                    onComplete : function() {
                        this.clear();
                        this.attachEvents();
                    }.bind(this)
                }
            );
        },
        
        attachEvents : function() {
            this.timeBombs.warning = setTimeout(
                this.showWarning.bind(this),
                this.timeout - this.warningThreshold
            );            
        },
        
        showWarning : function() {
            $('inactivity-timeout-warning-popup').unipopup.show();
            
            this.timeBombs.timeout = setTimeout(
                this.showFinal.bind(this),
                this.warningThreshold
            );
        },
        
        showFinal : function() {
            $('inactivity-timeout-warning-popup').unipopup.hide();
            $('inactivity-timeout-popup').unipopup.show();
            
            this.timeBombs.grace = setTimeout(
                this.close.bind(this),
                this.gracePeriod
            );
            
        },
        
        close: function() {
            window.close();
        },
        
        clear : function () {
            $H(this.timeBombs).each(
                function(entry) {
                    clearTimeout(entry.value);
                }
            );
            
            this.timeBombs = {};
        }
    }
); 


/*** /datepicker.js **********************************/


/*
        DatePicker v4.2 by frequency-decoder.com

        Released under a creative commons Attribution-ShareAlike 2.5 license (http://creativecommons.org/licenses/by-sa/2.5/)

        Please credit frequency-decoder in any derivative work - thanks.
        
        You are free:

        * to copy, distribute, display, and perform the work
        * to make derivative works
        * to make commercial use of the work

        Under the following conditions:

                by Attribution.
                --------------
                You must attribute the work in the manner specified by the author or licensor.

                sa
                --
                Share Alike. If you alter, transform, or build upon this work, you may distribute the resulting work only under a license identical to this one.

        * For any reuse or distribution, you must make clear to others the license terms of this work.
        * Any of these conditions can be waived if you get permission from the copyright holder.
*/
var datePickerController;

(function() {

// Detect the browser language
datePicker.languageinfo = navigator.language ? navigator.language : navigator.userLanguage;
datePicker.languageinfo = datePicker.languageinfo ? datePicker.languageinfo.toLowerCase().replace(/-[a-z]+$/, "") : 'en';

script  = null;

// Defaults should the locale file not load
datePicker.months       = ["January","February","March","April","May","June","July","August","September","October","November","December"];
datePicker.fullDay      = ["Mmonday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"];
datePicker.titles       = ["Previous month","Next month","Previous year","Next year", "Today", "Show Calendar"];

datePicker.getDaysPerMonth = function(nMonth, nYear) {
        nMonth = (nMonth + 12) % 12;
        return (((0 == (nYear%4)) && ((0 != (nYear%100)) || (0 == (nYear%400)))) && nMonth == 1) ? 29: [31,28,31,30,31,30,31,31,30,31,30,31][nMonth];
};

function datePicker(options) {

        this.defaults          = {};
        for(opt in options) { this[opt] = this.defaults[opt] = options[opt]; };
        
        this.date              = new Date();
        this.yearinc           = 1;
        this.timer             = null;
        this.pause             = 1000;
        this.timerSet          = false;
        this.fadeTimer         = null;
        this.interval          = new Date();
        this.firstDayOfWeek    = this.defaults.firstDayOfWeek = this.dayInc = this.monthInc = this.yearInc = 6;//this.opacity = this.opacityTo = 
        this.opacity = this.opacityTo = 0; // this makes possible to get the calendar on the first click
        this.dateSet           = null;
        this.visible           = false;
        this.disabledDates     = [];
        this.enabledDates      = [];
        this.nbsp              = String.fromCharCode( 160 );
        var o = this;

        o.events = {
                onblur:function(e) {
                        o.removeKeyboardEvents();
                },
                onfocus:function(e) {
                        o.addKeyboardEvents();
                },
                onkeydown: function (e) {
                        o.stopTimer();
                        if(!o.visible) return false;

                        if(e == null) e = document.parentWindow.event;
                        var kc = e.keyCode ? e.keyCode : e.charCode;

                        if( kc == 13 ) {
                                // close (return)
                                var td = document.getElementById(o.id + "-date-picker-hover");
                                if(!td || td.className.search(/out-of-range|day-disabled/) != -1) return o.killEvent(e);
                                o.returnFormattedDate();
                                o.hide();
                                return o.killEvent(e);
                        } else if(kc == 27) {
                                // close (esc)
                                o.hide();
                                return o.killEvent(e);
                        } else if(kc == 32 || kc == 0) {
                                // today (space)
                                o.date =  new Date();
                                o.updateTable();
                                return o.killEvent(e);
                        };

                        // Internet Explorer fires the keydown event faster than the JavaScript engine can
                        // update the interface. The following attempts to fix this.
                        /*@cc_on
                        @if(@_win32)
                                if(new Date().getTime() - o.interval.getTime() < 100) return o.killEvent(e);
                                o.interval = new Date();
                        @end
                        @*/

                        if ((kc > 49 && kc < 56) || (kc > 97 && kc < 104)) {
                                if (kc > 96) kc -= (96-48);
                                kc -= 49;
                                o.firstDayOfWeek = (o.firstDayOfWeek + kc) % 7;
                                o.updateTable();
                                return o.killEvent(e);
                        };

                        if ( kc < 37 || kc > 40 ) return true;

                        var d = new Date( o.date ).valueOf();

                        if ( kc == 37 ) {
                                // ctrl + left = previous month
                                if( e.ctrlKey ) {
                                        d = new Date( o.date );
                                        d.setDate( Math.min(d.getDate(), datePicker.getDaysPerMonth(d.getMonth() - 1,d.getFullYear())) );
                                        d.setMonth( d.getMonth() - 1 );
                                } else {
                                        d = new Date( o.date.getFullYear(), o.date.getMonth(), o.date.getDate() - 1 );
                                };
                        } else if ( kc == 39 ) {
                                // ctrl + right = next month
                                if( e.ctrlKey ) {
                                        d = new Date( o.date );
                                        d.setDate( Math.min(d.getDate(), datePicker.getDaysPerMonth(d.getMonth() + 1,d.getFullYear())) );
                                        d.setMonth( d.getMonth() + 1 );
                                } else {
                                        d = new Date( o.date.getFullYear(), o.date.getMonth(), o.date.getDate() + 1 );
                                };
                        } else if ( kc == 38 ) {
                                // ctrl + up = next year
                                if( e.ctrlKey ) {
                                        d = new Date( o.date );
                                        d.setDate( Math.min(d.getDate(), datePicker.getDaysPerMonth(d.getMonth(),d.getFullYear() + 1)) );
                                        d.setFullYear( d.getFullYear() + 1 );
                                } else {
                                        d = new Date( o.date.getFullYear(), o.date.getMonth(), o.date.getDate() - 7 );
                                };
                        } else if ( kc == 40 ) {
                                // ctrl + down = prev year
                                if( e.ctrlKey ) {
                                        d = new Date( o.date );
                                        d.setDate( Math.min(d.getDate(), datePicker.getDaysPerMonth(d.getMonth(),d.getFullYear() - 1)) );
                                        d.setFullYear( d.getFullYear() - 1 );
                                } else {
                                        d = new Date( o.date.getFullYear(), o.date.getMonth(), o.date.getDate() + 7 );
                                };
                        };

                        var tmpDate = new Date(d);

                        if(o.outOfRange(tmpDate)) return o.killEvent(e);
                        
                        var cacheDate = new Date(o.date);
                        o.date = tmpDate;

                        if(cacheDate.getFullYear() != o.date.getFullYear() || cacheDate.getMonth() != o.date.getMonth()) o.updateTable();
                        else {
                                o.disableTodayButton();
                                var tds = o.table.getElementsByTagName('td');
                                var txt;
                                var start = o.date.getDate() - 6;
                                if(start < 0) start = 0;

                                for(var i = start, td; td = tds[i]; i++) {
                                        txt = Number(td.firstChild.nodeValue);
                                        if(isNaN(txt) || txt != o.date.getDate()) continue;
                                        o.removeHighlight();
                                        td.id = o.id + "-date-picker-hover";
                                        td.className = td.className.replace(/date-picker-hover/g, "") + " date-picker-hover";
                                };
                        };
                        return o.killEvent(e);
                },
                gotoToday: function(e) {
                        o.date = new Date();
                        o.updateTable();
                        return o.killEvent(e);
                },
                onmousedown: function(e) {
                        if ( e == null ) e = document.parentWindow.event;
                        var el = e.target != null ? e.target : e.srcElement;

                        var found = false;
                        while(el.parentNode) {
                                if(el.id && (el.id == "fd-"+o.id || el.id == "fd-but-"+o.id)) {
                                        found = true;
                                        break;
                                };
                                try {
                                        el = el.parentNode;
                                } catch(err) {
                                        break;
                                };
                        };
                        if(found) return true;
                        o.stopTimer();
                        datePickerController.hideAll();
                },
                onmouseover: function(e) {
                        o.stopTimer();
                        var txt = this.firstChild.nodeValue;
                        if(this.className == "out-of-range" || txt.search(/^[\d]+$/) == -1) return;
                        
                        o.removeHighlight();
                        
                        this.id = o.id+"-date-picker-hover";
                        this.className = this.className.replace(/date-picker-hover/g, "") + " date-picker-hover";
                        
                        o.date.setDate(this.firstChild.nodeValue);
                        o.disableTodayButton();
                },
                onclick: function(e) {
                        if(o.opacity != o.opacityTo || this.className.search(/out-of-range|day-disabled/) != -1) return false;
                        if ( e == null ) e = document.parentWindow.event;
                        var el = e.target != null ? e.target : e.srcElement;
                        while ( el.nodeType != 1 ) el = el.parentNode;
                        var d = new Date( o.date );
                        var txt = el.firstChild.data;
                        if(txt.search(/^[\d]+$/) == -1) return;
                        var n = Number( txt );
                        if(isNaN(n)) { return true; };
                        d.setDate( n );
                        o.date = d;
                        o.returnFormattedDate();
                        if(!o.staticPos) o.hide();
                        o.stopTimer();
                        return o.killEvent(e);
                },
                incDec: function(e) {
                        if ( e == null ) e = document.parentWindow.event;
                        var el = e.target != null ? e.target : e.srcElement;

                        if(el && el.className && el.className.search('fd-disabled') != -1) { return false; }
                        datePickerController.addEvent(document, "mouseup", o.events.clearTimer);
                        o.timerInc      = 800;
                        o.dayInc        = arguments[1];
                        o.yearInc       = arguments[2];
                        o.monthInc      = arguments[3];
                        o.timerSet      = true;

                        o.updateTable();
                        return true;
                },
                clearTimer: function(e) {
                        o.stopTimer();
                        o.timerInc      = 1000;
                        o.yearInc       = 0;
                        o.monthInc      = 0;
                        o.dayInc        = 0;
                        datePickerController.removeEvent(document, "mouseup", o.events.clearTimer);
                }
        };
        o.stopTimer = function() {
                o.timerSet = false;
                window.clearTimeout(o.timer);
        };
        o.removeHighlight = function() {
                if(document.getElementById(o.id+"-date-picker-hover")) {
                        document.getElementById(o.id+"-date-picker-hover").className = document.getElementById(o.id+"-date-picker-hover").className.replace("date-picker-hover", "");
                        document.getElementById(o.id+"-date-picker-hover").id = "";
                };
        };
        o.reset = function() {
                for(def in o.defaults) { o[def] = o.defaults[def]; };
        };
        o.setOpacity = function(op) {
                o.div.style.opacity = op/100;
                o.div.style.filter = 'alpha(opacity=' + op + ')';
                o.opacity = op;
        };
        o.fade = function() {
                window.clearTimeout(o.fadeTimer);
                o.fadeTimer = null;
                delete(o.fadeTimer);
                
                var diff = Math.round(o.opacity + ((o.opacityTo - o.opacity) / 4));

                o.setOpacity(diff);

                if(Math.abs(o.opacityTo - diff) > 3 && !o.noTransparency) {
                        o.fadeTimer = window.setTimeout(o.fade, 50);
                } else {
                        o.setOpacity(o.opacityTo);
                        if(o.opacityTo == 0) {
                                o.div.style.display = "none";
                                o.visible = false;
                        } else {
                                o.visible = true;
                        };
                };
        };
        o.killEvent = function(e) {
                e = e || document.parentWindow.event;
                
                if(e.stopPropagation) {
                        e.stopPropagation();
                        e.preventDefault();
                };
                
                /*@cc_on
                @if(@_win32)
                e.cancelBubble = true;
                e.returnValue = false;
                @end
                @*/
                return false;
        };
        o.getElem = function() {
                return document.getElementById(o.id.replace(/^fd-/, '')) || false;
        };
        o.setRangeLow = function(range) {
                if(String(range).search(/^(\d\d?\d\d)(0[1-9]|1[012])(0[1-9]|[12][0-9]|3[01])$/) == -1) range = '';
                o.low = o.defaults.low = range;
                if(o.staticPos) o.updateTable(true);
        };
        o.setRangeHigh = function(range) {
                if(String(range).search(/^(\d\d?\d\d)(0[1-9]|1[012])(0[1-9]|[12][0-9]|3[01])$/) == -1) range = '';
                o.high = o.defaults.high = range;
                if(o.staticPos) o.updateTable(true);
        };
        o.setDisabledDays = function(dayArray) {
                o.disableDays = o.defaults.disableDays = dayArray;
                if(o.staticPos) o.updateTable(true);
        };
        o.setDisabledDates = function(dateArray) {
                var fin = [];
                for(var i = dateArray.length; i-- ;) {
                        if(dateArray[i].match(/^(\d\d\d\d|\*\*\*\*)(0[1-9]|1[012]|\*\*)(0[1-9]|[12][0-9]|3[01])$/) != -1) fin[fin.length] = dateArray[i];
                };
                if(fin.length) {
                        o.disabledDates = fin;
                        o.enabledDates = [];
                        if(o.staticPos) o.updateTable(true);
                };
        };
        o.setEnabledDates = function(dateArray) {
                var fin = [];
                for(var i = dateArray.length; i-- ;) {
                        if(dateArray[i].match(/^(\d\d\d\d|\*\*\*\*)(0[1-9]|1[012]|\*\*)(0[1-9]|[12][0-9]|3[01]|\*\*)$/) != -1 && dateArray[i] != "********") fin[fin.length] = dateArray[i];
                };
                if(fin.length) {
                        o.disabledDates = [];
                        o.enabledDates = fin;
                        if(o.staticPos) o.updateTable(true);
                };
        };
        o.getDisabledDates = function(y, m) {
                if(o.enabledDates.length) return o.getEnabledDates(y, m);
                var obj = {};
                var d = datePicker.getDaysPerMonth(m - 1, y);
                m = m < 10 ? "0" + String(m) : m;
                for(var i = o.disabledDates.length; i-- ;) {
                        var tmp = o.disabledDates[i].replace("****", y).replace("**", m);
                        if(tmp < Number(String(y)+m+"01") || tmp > Number(y+String(m)+d)) continue;
                        obj[tmp] = 1;
                };
                return obj;
        };
        o.getEnabledDates = function(y, m) {
                var obj = {};
                var d = datePicker.getDaysPerMonth(m - 1, y);
                m = m < 10 ? "0" + String(m) : m;
                var day,tmp,de,me,ye,disabled;
                for(var dd = 1; dd <= d; dd++) {
                        day = dd < 10 ? "0" + String(dd) : dd;
                        disabled = true;
                        for(var i = o.enabledDates.length; i-- ;) {
                                tmp = o.enabledDates[i];
                                ye  = String(o.enabledDates[i]).substr(0,4);
                                me  = String(o.enabledDates[i]).substr(4,2);
                                de  = String(o.enabledDates[i]).substr(6,2);

                                if(ye == y && me == m && de == day) {
                                        disabled = false;
                                        break;
                                }
                                
                                if(ye == "****" || me == "**" || de == "**") {
                                        if(ye == "****") tmp = tmp.replace(/^\*\*\*\*/, y);
                                        if(me == "**")   tmp = tmp = tmp.substr(0,4) + String(m) + tmp.substr(6,2);
                                        if(de == "**")   tmp = tmp.replace(/\*\*/, day);

                                        if(tmp == String(y + String(m) + day)) {
                                                disabled = false;
                                                break;
                                        };
                                };
                        };
                        if(disabled) obj[String(y + String(m) + day)] = 1;
                };
                return obj;
        };
        o.setFirstDayOfWeek = function(e) {
                if ( e == null ) e = document.parentWindow.event;
                var elem = e.target != null ? e.target : e.srcElement;
                if(elem.tagName.toLowerCase() != "th") {
                        while(elem.tagName.toLowerCase() != "th") elem = elem.parentNode;
                };
                var cnt = 0;
                while(elem.previousSibling) {
                        elem = elem.previousSibling;
                        if(elem.tagName.toLowerCase() == "th") cnt++;
                };
                o.firstDayOfWeek = (o.firstDayOfWeek + cnt) % 7;
                o.updateTableHeaders();
                return o.killEvent(e);
        };
        o.truePosition = function(element) {
                var pos = o.cumulativeOffset(element);
                if(window.opera) { return pos; }
                var iebody      = (document.compatMode && document.compatMode != "BackCompat")? document.documentElement : document.body;
                var dsocleft    = document.all ? iebody.scrollLeft : window.pageXOffset;
                var dsoctop     = document.all ? iebody.scrollTop  : window.pageYOffset;
                var posReal     = o.realOffset(element);
                return [pos[0] - posReal[0] + dsocleft, pos[1] - posReal[1] + dsoctop];
        };
        o.realOffset = function(element) {
                var t = 0, l = 0;
                do {
                        t += element.scrollTop  || 0;
                        l += element.scrollLeft || 0;
                        element = element.parentNode;
                } while (element);
                return [l, t];
        };
        o.cumulativeOffset = function(element) {
                var t = 0, l = 0;
                do {
                        t += element.offsetTop  || 0;
                        l += element.offsetLeft || 0;
                        element = element.offsetParent;
                } while (element);
                return [l, t];
        };
        o.resize = function() {
                if(!o.created || !o.getElem()) return;
                
                o.div.style.visibility = "hidden";
                if(!o.staticPos) { o.div.style.left = o.div.style.top = "0px"; }
                o.div.style.display = "block";
                
                var osh = o.div.offsetHeight;
                var osw = o.div.offsetWidth;
                
                o.div.style.visibility = "visible";
                o.div.style.display = "none";
                
                if(!o.staticPos) {
                        var elem          = document.getElementById('fd-but-' + o.id);
                        var pos           = o.truePosition(elem);
                        var trueBody      = (document.compatMode && document.compatMode!="BackCompat") ? document.documentElement : document.body;
                        var scrollTop     = window.devicePixelRatio || window.opera ? 0 : trueBody.scrollTop;
                        var scrollLeft    = window.devicePixelRatio || window.opera ? 0 : trueBody.scrollLeft;

                        if(parseInt(trueBody.clientWidth+scrollLeft) < parseInt(osw+pos[0])) {
                                o.div.style.left = Math.abs(parseInt((trueBody.clientWidth+scrollLeft) - osw)) + "px";
                        } else {
                                o.div.style.left  = pos[0] + "px";
                        };

                        if(parseInt(trueBody.clientHeight+scrollTop) < parseInt(osh+pos[1]+elem.offsetHeight+2)) {
                                o.div.style.top   = Math.abs(parseInt(pos[1] - (osh + 2))) + "px";
                        } else {
                                o.div.style.top   = Math.abs(parseInt(pos[1] + elem.offsetHeight + 2)) + "px";
                        };
                };
                /*@cc_on
                @if(@_jscript_version <= 5.6)
                if(o.staticPos) return;
                o.iePopUp.style.top    = o.div.style.top;
                o.iePopUp.style.left   = o.div.style.left;
                o.iePopUp.style.width  = osw + "px";
                o.iePopUp.style.height = (osh - 2) + "px";
                @end
                @*/
        };
        o.equaliseDates = function() {
                var clearDayFound = false;
                var tmpDate;
                for(var i = o.low; i <= o.high; i++) {
                        tmpDate = String(i);
                        if(!o.disableDays[new Date(tmpDate.substr(0,4), tmpDate.substr(6,2), tmpDate.substr(4,2)).getDay() - 1]) {
                                clearDayFound = true;
                                break;
                        };
                };
                if(!clearDayFound) o.disableDays = o.defaults.disableDays = [0,0,0,0,0,0,0];
        };
        o.outOfRange = function(tmpDate) {
                if(!o.low && !o.high) return false;

                var level = false;
                if(!tmpDate) {
                        level = true;
                        tmpDate = o.date;
                };
                
                var d  = (tmpDate.getDate() < 10) ? "0" + tmpDate.getDate() : tmpDate.getDate();
                var m  = ((tmpDate.getMonth() + 1) < 10) ? "0" + (tmpDate.getMonth() + 1) : tmpDate.getMonth() + 1;
                var y  = tmpDate.getFullYear();
                var dt = String(y)+String(m)+String(d);

                if(o.low && parseInt(dt) < parseInt(o.low)) {
                        if(!level) return true;
                        o.date = new Date(o.low.substr(0,4), o.low.substr(4,2)-1, o.low.substr(6,2), 5, 0, 0);
                        return false;
                };
                if(o.high && parseInt(dt) > parseInt(o.high)) {
                        if(!level) return true;
                        o.date = new Date( o.high.substr(0,4), o.high.substr(4,2)-1, o.high.substr(6,2), 5, 0, 0);
                };
                return false;
        };
        o.create = function() {
                
                function createTH(details) {
                        var th = document.createElement('th');
                        if(details.thClassName) th.className = details.thClassName;
                        if(details.colspan) {
                                /*@cc_on
                                /*@if (@_win32)
                                th.setAttribute('colSpan',details.colspan);
                                @else @*/
                                th.setAttribute('colspan',details.colspan);
                                /*@end
                                @*/
                        };
                        /*@cc_on
                        /*@if (@_win32)
                        th.unselectable = "on";
                        /*@end@*/
                        return th;
                };
                
                function createThAndButton(tr, obj) {
                        for(var i = 0, details; details = obj[i]; i++) {
                                var th = createTH(details);
                                tr.appendChild(th);
                                var but = document.createElement('span');
                                but.className = details.className;
                                but.id = o.id + details.id;
                                but.appendChild(document.createTextNode(details.text));
                                but.title = details.title || "";
                                if(details.onmousedown) but.onmousedown = details.onmousedown;
                                if(details.onclick)     but.onclick     = details.onclick;
                                if(details.onmouseout)  but.onmouseout  = details.onmouseout;
                                th.appendChild(but);
                        };
                };
                
                /*@cc_on
                @if(@_jscript_version <= 5.6)
                        if(!document.getElementById("iePopUpHack")) {
                                o.iePopUp = document.createElement('iframe');
                                o.iePopUp.src = "javascript:'<html></html>';";
                                o.iePopUp.setAttribute('className','iehack');
                                o.iePopUp.scrolling="no";
                                o.iePopUp.frameBorder="0";
                                o.iePopUp.name = o.iePopUp.id = "iePopUpHack";
                                document.body.appendChild(o.iePopUp);
                        } else {
                                o.iePopUp = document.getElementById("iePopUpHack");
                        };
                @end
                @*/
                
                if(typeof(fdLocale) == "object" && o.locale) {
                        datePicker.titles  = fdLocale.titles;
                        datePicker.months  = fdLocale.months;
                        datePicker.fullDay = fdLocale.fullDay;
                        // Optional parameters
                        if(fdLocale.dayAbbr) datePicker.dayAbbr = fdLocale.dayAbbr;
                        if(fdLocale.firstDayOfWeek) o.firstDayOfWeek = o.defaults.firstDayOfWeek = fdLocale.firstDayOfWeek;
                };
                
                o.div = document.createElement('div');
                o.div.style.zIndex = 9999;
                o.div.id = "fd-"+o.id;
                o.div.className = "datePicker";
                
                if(!o.staticPos) {
                        document.getElementsByTagName('body')[0].appendChild(o.div);
                } else {
                        elem = o.getElem();
                        if(!elem) {
                                o.div = null;
                                return;
                        };
                        o.div.className += " staticDP";
                        o.div.setAttribute("tabIndex", "0");
                        o.div.onfocus = o.events.onfocus;
                        o.div.onblur  = o.events.onblur;
                        elem.parentNode.insertBefore(o.div, elem.nextSibling);
                        if(o.hideInput && elem.type && elem.type == "text") elem.setAttribute("type", "hidden");
                };
                
                //var nbsp = String.fromCharCode( 160 );
                var tr, row, col, tableHead, tableBody;

                o.table = document.createElement('table');
                o.div.appendChild( o.table );
                
                tableHead = document.createElement('thead');
                o.table.appendChild( tableHead );
                
                tr  = document.createElement('tr');
                tableHead.appendChild(tr);

                // Title Bar
                o.titleBar = createTH({thClassName:"date-picker-title", colspan:7});
                tr.appendChild( o.titleBar );
                tr = null;
                
                var span = document.createElement('span');
                span.className = "month-display";
                o.titleBar.appendChild(span);

                span = document.createElement('span');
                span.className = "year-display";
                o.titleBar.appendChild(span);

                span = null;
                
                tr  = document.createElement('tr');
                tableHead.appendChild(tr);

                createThAndButton(tr, [{className:"prev-but", id:"-prev-year-but", text:"\u00AB", title:datePicker.titles[2], onmousedown:function(e) { o.events.incDec(e,0,-1,0); }, onmouseout:o.events.clearTimer },{className:"prev-but", id:"-prev-month-but", text:"\u2039", title:datePicker.titles[0], onmousedown:function(e) { o.events.incDec(e,0,0,-1); }, onmouseout:o.events.clearTimer },{colspan:3, className:"today-but", id:"-today-but", text:datePicker.titles.length > 4 ? datePicker.titles[4] : "Today", onclick:o.events.gotoToday},{className:"next-but", id:"-next-month-but", text:"\u203A", title:datePicker.titles[1], onmousedown:function(e) { o.events.incDec(e,0,0,1); }, onmouseout:o.events.clearTimer },{className:"next-but", id:"-next-year-but", text:"\u00BB", title:datePicker.titles[3], onmousedown:function(e) { o.events.incDec(e,0,1,0); }, onmouseout:o.events.clearTimer }]);

                tableBody = document.createElement('tbody');
                o.table.appendChild( tableBody );

                for(var rows = 0; rows < 7; rows++) {
                        row = document.createElement('tr');

                        if(rows != 0) tableBody.appendChild(row);
                        else          tableHead.appendChild(row);
                        
                        for(var cols = 0; cols < 7; cols++) {
                                col = (rows == 0) ? document.createElement('th') : document.createElement('td');

                                row.appendChild(col);
                                if(rows != 0) {
                                        col.appendChild(document.createTextNode(o.nbsp));
                                        col.onmouseover = o.events.onmouseover;
                                        col.onclick = o.events.onclick;
                                } else {
                                        col.className = "date-picker-day-header";
                                        col.scope = "col";
                                };
                                col = null;
                        };
                        row = null;
                };

                // Table headers
                var but;
                var ths = o.table.getElementsByTagName('thead')[0].getElementsByTagName('tr')[2].getElementsByTagName('th');
                for ( var y = 0; y < 7; y++ ) {
                        if(y > 0) {
                                but = document.createElement("span");
                                but.className = "fd-day-header";
                                but.onclick = ths[y].onclick = o.setFirstDayOfWeek;
                                but.appendChild(document.createTextNode(o.nbsp));
                                ths[y].appendChild(but);
                                but = null;
                        } else {
                                ths[y].appendChild(document.createTextNode(o.nbsp));
                        };
                };
                
                o.ths = o.table.getElementsByTagName('thead')[0].getElementsByTagName('tr')[2].getElementsByTagName('th');
                o.trs = o.table.getElementsByTagName('tbody')[0].getElementsByTagName('tr');
                
                o.updateTableHeaders();
                
                tableBody = tableHead = tr = createThAndButton = createTH = null;
                o.created = true;
                
                if(o.low && o.high && (o.high - o.low < 7)) { o.equaliseDates(); };
                
                if(o.staticPos) {
                        var yyN = document.getElementById(o.id);
                        datePickerController.addEvent(yyN, "change", o.changeHandler);
                        if(o.splitDate) {
                                var mmN = document.getElementById(o.id+'-mm');
                                var ddN = document.getElementById(o.id+'-dd');
                                datePickerController.addEvent(mmN, "change", o.changeHandler);
                                datePickerController.addEvent(ddN, "change", o.changeHandler);
                        };
                };

                if(o.staticPos) { o.show(); }
                else {
                        o.resize();
                        o.fade();
                };
        };
        o.changeHandler = function() {
                o.setDateFromInput();
                o.updateTable();
        };
        o.setDateFromInput = function() {
                function m2c(val) {
                        return String(val).length < 2 ? "00".substring(0, 2 - String(val).length) + String(val) : val;
                };

                o.dateSet = null;
                
                var elem = o.getElem();
                if(!elem) return;

                if(!o.splitDate) {
                        var date = datePickerController.dateFormat(elem.value, o.format.search(/m-d-y/i) != -1);

                } else {
                        var mmN = document.getElementById(o.id+'-mm');
                        var ddN = document.getElementById(o.id+'-dd');
                        var tm = parseInt(mmN.tagName.toLowerCase() == "input"  ? mmN.value  : mmN.options[mmN.selectedIndex].value, 10);
                        var td = parseInt(ddN.tagName.toLowerCase() == "input"  ? ddN.value  : ddN.options[ddN.selectedIndex].value, 10);
                        var ty = parseInt(elem.tagName.toLowerCase() == "input" ? elem.value : elem.options[elem.selectedIndex || 0].value, 10);
                        var date = datePickerController.dateFormat(tm + "/" + td + "/" + ty, true);
                };

                var badDate = false;
                if(!date) {
                        badDate = true;
                        date = String(new Date().getFullYear()) + m2c(new Date().getMonth()+1) + m2c(new Date().getDate());
                };

                var d,m,y;
                y = Number(date.substr(0, 4));
                m = Number(date.substr(4, 2)) - 1;
                d = Number(date.substr(6, 2));

                var dpm = datePicker.getDaysPerMonth(m, y);
                if(d > dpm) d = dpm;

                if(new Date( y, m, d ) == 'Invalid Date' || new Date( y, m, d ) == 'NaN') {

                        badDate = true;
                        o.date = new Date();
                        o.date.setHours(5);
                        return;
                };

                o.date = new Date( y, m, d );

                o.date.setHours(5);

                if(!badDate) o.dateSet = new Date(o.date);
                m2c = null;
        };
        o.returnFormattedDate = function() {

                var elem = o.getElem();
                if(!elem) return;
                
                var d                   = (o.date.getDate() < 10) ? "0" + o.date.getDate() : o.date.getDate();
                var m                   = ((o.date.getMonth() + 1) < 10) ? "0" + (o.date.getMonth() + 1) : o.date.getMonth() + 1;
                var yyyy                = o.date.getFullYear();
                var disabledDates       = o.getDisabledDates(yyyy, m);
                var weekDay             = ( o.date.getDay() + 6 ) % 7;

                if(!(o.disableDays[weekDay] || String(yyyy)+m+d in disabledDates)) {

                        if(o.splitDate) {
                                var ddE = document.getElementById(o.id+"-dd");
                                var mmE = document.getElementById(o.id+"-mm");

                                if(ddE.tagName.toLowerCase() == "input") { ddE.value = d; }
                                else { ddE.selectedIndex = d - 1; };
                                
                                if(mmE.tagName.toLowerCase() == "input") { mmE.value = m; }
                                else { mmE.selectedIndex = m - 1; };
                                
                                if(elem.tagName.toLowerCase() == "input") elem.value = yyyy;
                                else {
                                        for(var opt = 0; opt < elem.options.length; opt++) {
                                                if(elem.options[opt].value == yyyy) {
                                                        elem.selectedIndex = opt;
                                                        break;
                                                };
                                        };
                                };
                        } else {
                                elem.value = o.format.replace('y',yyyy).replace('m',m).replace('d',d).replace(/-/g,o.divider);
                        };
                        if(!elem.type || elem.type && elem.type != "hidden") elem.focus();
                        if(o.staticPos) {
                                o.dateSet = new Date( o.date );
                                o.updateTable();
                        };
                        
                        // Programmatically fire the onchange event
                        if(document.createEvent) {
                                var onchangeEvent = document.createEvent('HTMLEvents');
                                onchangeEvent.initEvent('change', true, false);
                                elem.dispatchEvent(onchangeEvent);
                        } else if(document.createEventObject) {
                                elem.fireEvent('onchange');
                        };
                };
        };

        o.disableTodayButton = function() {
                var today = new Date();
                document.getElementById(o.id + "-today-but").className = document.getElementById(o.id + "-today-but").className.replace("fd-disabled", "");
                if(o.outOfRange(today) || (o.date.getDate() == today.getDate() && o.date.getMonth() == today.getMonth() && o.date.getFullYear() == today.getFullYear())) {
                        document.getElementById(o.id + "-today-but").className += " fd-disabled";
                        document.getElementById(o.id + "-today-but").onclick = null;
                } else {
                        document.getElementById(o.id + "-today-but").onclick = o.events.gotoToday;
                };
        };

        o.updateTableHeaders = function() {
                var d, but;
                var ths = o.ths;
                for ( var y = 0; y < 7; y++ ) {
                        d = (o.firstDayOfWeek + y) % 7;
                        ths[y].title = datePicker.fullDay[d];

                        if(y > 0) {
                                but = ths[y].getElementsByTagName("span")[0];
                                but.removeChild(but.firstChild);
                                but.appendChild(document.createTextNode(datePicker.dayAbbr ? datePicker.dayAbbr[d] : datePicker.fullDay[d].charAt(0)));
                                but.title = datePicker.fullDay[d];
                                but = null;
                        } else {
                                ths[y].removeChild(ths[y].firstChild);
                                ths[y].appendChild(document.createTextNode(datePicker.dayAbbr ? datePicker.dayAbbr[d] : datePicker.fullDay[d].charAt(0)));
                        };
                };
                o.updateTable();
        };

        o.updateTable = function(noCallback) {

                if(o.timerSet) {
                        var d = new Date(o.date);
                        d.setDate( Math.min(d.getDate()+o.dayInc, datePicker.getDaysPerMonth(d.getMonth()+o.monthInc,d.getFullYear()+o.yearInc)) );
                        d.setMonth( d.getMonth() + o.monthInc );
                        d.setFullYear( d.getFullYear() + o.yearInc );
                        o.date = d;
                };
                
                if(!noCallback && "onupdate" in datePickerController && typeof(datePickerController.onupdate) == "function") datePickerController.onupdate(o);

                o.outOfRange();
                o.disableTodayButton();
                
                // Set the tmpDate to the second day of this month (to avoid daylight savings time madness on Windows)
                var tmpDate = new Date( o.date.getFullYear(), o.date.getMonth(), 2 );
                tmpDate.setHours(5);

                var tdm = tmpDate.getMonth();
                var tdy = tmpDate.getFullYear();

                // Do the disableDates for this year and month
                var disabledDates = o.getDisabledDates(o.date.getFullYear(), o.date.getMonth() + 1);

                var today = new Date();

                // Previous buttons out of range
                var b = document.getElementById(o.id + "-prev-year-but");
                b.className = b.className.replace("fd-disabled", "");
                if(o.outOfRange(new Date((tdy - 1), Number(tdm), datePicker.getDaysPerMonth(Number(tdm), tdy-1)))) {
                        b.className += " fd-disabled";
                        if(o.yearInc == -1) o.stopTimer();
                };

                b = document.getElementById(o.id + "-prev-month-but")
                b.className = b.className.replace("fd-disabled", "");
                if(o.outOfRange(new Date(tdy, (Number(tdm) - 1), datePicker.getDaysPerMonth(Number(tdm)-1, tdy)))) {
                        b.className += " fd-disabled";
                        if(o.monthInc == -1)  o.stopTimer();
                };

                // Next buttons out of range
                b= document.getElementById(o.id + "-next-year-but")
                b.className = b.className.replace("fd-disabled", "");
                if(o.outOfRange(new Date((tdy + 1), Number(tdm), 1))) {
                        b.className += " fd-disabled";
                        if(o.yearInc == 1)  o.stopTimer();
                };

                b = document.getElementById(o.id + "-next-month-but")
                b.className = b.className.replace("fd-disabled", "");
                if(o.outOfRange(new Date(tdy, Number(tdm) + 1, 1))) {
                        b.className += " fd-disabled";
                        if(o.monthInc == 1)  o.stopTimer();
                };

                b = null;
                
                var cd = o.date.getDate();
                var cm = o.date.getMonth();
                var cy = o.date.getFullYear();
                
                // Title Bar
                var span = o.titleBar.getElementsByTagName("span");
                while(span[0].firstChild) span[0].removeChild(span[0].firstChild);
                while(span[1].firstChild) span[1].removeChild(span[1].firstChild);
                span[0].appendChild(document.createTextNode(datePicker.months[cm] + o.nbsp));
                span[1].appendChild(document.createTextNode(cy));

                tmpDate.setDate( 1 );
                        
                var dt, cName, td, tds, i;
                var weekDay = ( tmpDate.getDay() + 6 ) % 7;
                var firstColIndex = (( (weekDay - o.firstDayOfWeek) + 7 ) % 7) - 1;
                var dpm = datePicker.getDaysPerMonth(cm, cy);

                var todayD = today.getDate();
                var todayM = today.getMonth();
                var todayY = today.getFullYear();
                
                var c = "class";
                /*@cc_on
                @if(@_win32)
                c = "className";
                @end
                @*/

                var stub = String(tdy) + (String(tdm+1).length < 2 ? "0" + (tdm+1) : tdm+1);
                
                for(var row = 0; row < 6; row++) {

                        tds = o.trs[row].getElementsByTagName('td');

                        for(var col = 0; col < 7; col++) {
                        
                                td = tds[col];
                                td.removeChild(td.firstChild);

                                td.setAttribute("id", "");
                                td.setAttribute("title", "");

                                i = (row * 7) + col;
                        
                                if(i > firstColIndex && i <= (firstColIndex + dpm)) {
                                        dt = i - firstColIndex;
                                        tmpDate.setDate(dt);
                                        td.appendChild(document.createTextNode(dt));

                                        if(o.outOfRange(tmpDate)) {
                                                td.setAttribute(c, "out-of-range");
                                        } else {

                                                cName = [];
                                                weekDay = ( tmpDate.getDay() + 6 ) % 7;

                                                if(dt == todayD && tdm == todayM && tdy == todayY) {
                                                        cName.push("date-picker-today");
                                                };

                                                if(o.dateSet != null && o.dateSet.getDate() == dt && o.dateSet.getMonth() == tdm && o.dateSet.getFullYear() == tdy) {
                                                        cName.push("date-picker-selected-date");
                                                };
                                                
                                                if(o.disableDays[weekDay] || stub + String(dt) in disabledDates) {
                                                        cName.push("day-disabled");
                                                } else if(o.highlightDays[weekDay]) {
                                                        cName.push("date-picker-highlight");
                                                };
                                                
                                                if(cd == dt) {
                                                        td.setAttribute("id", o.id + "-date-picker-hover");
                                                        cName.push("date-picker-hover");
                                                };
                                                
                                                cName.push("dm-" + dt + '-' + (tdm + 1) + " " + " dmy-" + dt + '-' + (tdm + 1) + '-' + tdy);
                                                td.setAttribute(c, cName.join(' '));
                                                td.setAttribute("title", datePicker.months[cm] + o.nbsp + dt + "," + o.nbsp + cy);
                                        };
                                } else {
                                        td.appendChild(document.createTextNode(o.nbsp));
                                        td.setAttribute(c, "date-picker-unused");
                                };
                        };
                };

                if(o.timerSet) {
                        o.timerInc = 50 + Math.round(((o.timerInc - 50) / 1.8));
                        o.timer = window.setTimeout(o.updateTable, o.timerInc);
                };
        };
        o.addKeyboardEvents = function() {
                datePickerController.addEvent(document, "keypress", o.events.onkeydown);
                /*@cc_on
                @if(@_win32)
                datePickerController.removeEvent(document, "keypress", o.events.onkeydown);
                datePickerController.addEvent(document, "keydown", o.events.onkeydown);
                @end
                @*/
                if(window.devicePixelRatio) {
                        datePickerController.removeEvent(document, "keypress", o.events.onkeydown);
                        datePickerController.addEvent(document, "keydown", o.events.onkeydown);
                };
        };
        o.removeKeyboardEvents =function() {
                datePickerController.removeEvent(document, "keypress", o.events.onkeydown);
                datePickerController.removeEvent(document, "keydown",  o.events.onkeydown);
        };
        o.show = function() {
                var elem = o.getElem();
                if(!elem || o.visible || elem.disabled) return;

                o.reset();
                o.setDateFromInput();
                o.updateTable();
                
                if(!o.staticPos) o.resize();
                
                datePickerController.addEvent(o.staticPos ? o.table : document, "mousedown", o.events.onmousedown);

                if(!o.staticPos) { o.addKeyboardEvents(); };
                
                o.opacityTo = o.noTransparency ? 99 : 90;
                o.div.style.display = "block";
                /*@cc_on
                @if(@_jscript_version <= 5.6)
                if(!o.staticPos) o.iePopUp.style.display = "block";
                @end
                @*/

                o.fade();
                o.visible = true;
        };
        o.hide = function() {
                if(!o.visible) return;
                o.stopTimer();
                if(o.staticPos) return;
                
                datePickerController.removeEvent(document, "mousedown", o.events.onmousedown);
                datePickerController.removeEvent(document, "mouseup",  o.events.clearTimer);
                o.removeKeyboardEvents();
                
                /*@cc_on
                @if(@_jscript_version <= 5.6)
                o.iePopUp.style.display = "none";
                @end
                @*/
                
                o.opacityTo = 0;
                o.fade();
                o.visible = false;
                var elem = o.getElem();
                if(elem) elem.focus();
        };
        o.destroy = function() {
                // Cleanup for Internet Explorer
                datePickerController.removeEvent(o.staticPos ? o.table : document, "mousedown", o.events.onmousedown);
                datePickerController.removeEvent(document, "mouseup",   o.events.clearTimer);
                o.removeKeyboardEvents();

                if(o.staticPos) {
                        var yyN = document.getElementById(o.id);
                        datePickerController.removeEvent(yyN, "change", o.changeHandler);
                        if(o.splitDate) {
                                var mmN = document.getElementById(o.id+'-mm');
                                var ddN = document.getElementById(o.id+'-dd');

                                datePickerController.removeEvent(mmN, "change", o.changeHandler);
                                datePickerController.removeEvent(ddN, "change", o.changeHandler);
                        };
                        o.div.onfocus = o.div.onblur = null;
                };
                
                var ths = o.table.getElementsByTagName("th");
                for(var i = 0, th; th = ths[i]; i++) {
                        th.onmouseover = th.onmouseout = th.onmousedown = th.onclick = null;
                };
                
                var tds = o.table.getElementsByTagName("td");
                for(var i = 0, td; td = tds[i]; i++) {
                        td.onmouseover = td.onclick = null;
                };

                var butts = o.table.getElementsByTagName("span");
                for(var i = 0, butt; butt = butts[i]; i++) {
                        butt.onmousedown = butt.onclick = butt.onkeypress = null;
                };
                
                o.ths = o.trs = null;
                
                clearTimeout(o.fadeTimer);
                clearTimeout(o.timer);
                o.fadeTimer = o.timer = null;
                
                /*@cc_on
                @if(@_jscript_version <= 5.6)
                o.iePopUp = null;
                @end
                @*/
                
                if(!o.staticPos && document.getElementById(o.id.replace(/^fd-/, 'fd-but-'))) {
                        var butt = document.getElementById(o.id.replace(/^fd-/, 'fd-but-'));
                        butt.onclick = butt.onpress = null;
                };
                
                o.titleBar = o.table = o.div = null;
                o = null;
        };

        o.create();
};

datePickerController = function() {
        var datePickers = {};
        var uniqueId    = 0;
        
        var addEvent = function(obj, type, fn) {
                if( obj.attachEvent ) {
                        obj["e"+type+fn] = fn;
                        obj[type+fn] = function(){obj["e"+type+fn]( window.event );};
                        obj.attachEvent( "on"+type, obj[type+fn] );
                } else {
                        obj.addEventListener( type, fn, true );
                };
        };
        var removeEvent = function(obj, type, fn) {
                try {
                        if( obj.detachEvent ) {
                                obj.detachEvent( "on"+type, obj[type+fn] );
                                obj[type+fn] = null;
                        } else {
                                obj.removeEventListener( type, fn, true );
                        };
                } catch(err) {};
        };

        var hideAll = function(exception) {
                var dp;
                for(dp in datePickers) {
                        if(!datePickers[dp].created || datePickers[dp].staticPos) continue;
                        if(exception && exception == datePickers[dp].id) { continue; };
                        if(document.getElementById(datePickers[dp].id))  { datePickers[dp].hide(); };
                };
        };
        var cleanUp = function() {
                var dp;
                for(dp in datePickers) {
                        if(!document.getElementById(datePickers[dp].id)) {
                                dpElem = document.getElementById("fd-"+datePickers[dp].id);
                                datePickers[dp].destroy();
                                datePickers[dp] = null;
                                delete datePickers[dp];
                                if(dpElem) {
                                        dpElem.parentNode.removeChild(dpElem);
                                };
                        };
                };
        };
        var destroy = function() {
                for(dp in datePickers) {
                        if(!datePickers[dp].created) continue;
                        datePickers[dp].destroy();
                        datePickers[dp] = null;
                        delete datePickers[dp];
                };
                datePickers = null;
                /*@cc_on
                @if(@_jscript_version <= 5.6)
                        if(document.getElementById("iePopUpHack")) {
                                document.body.removeChild(document.getElementById("iePopUpHack"));
                        };
                @end
                @*/
                datePicker.script = null;
                removeEvent(window, 'load', datePickerController.create);
                removeEvent(window, 'unload', datePickerController.destroy);
        };
        var dateFormat = function(dateIn, favourMDY) {
                var dateTest = [
                        { regExp:/^(0?[1-9]|[12][0-9]|3[01])([- \/.])(0?[1-9]|1[012])([- \/.])((\d\d)?\d\d)$/, d:1, m:3, y:5 },  // dmy
                        { regExp:/^(0?[1-9]|1[012])([- \/.])(0?[1-9]|[12][0-9]|3[01])([- \/.])((\d\d)?\d\d)$/, d:3, m:1, y:5 },  // mdy
                        { regExp:/^(\d\d\d\d)([- \/.])(0?[1-9]|1[012])([- \/.])(0?[1-9]|[12][0-9]|3[01])$/,    d:5, m:3, y:1 }   // ymd
                        ];

                var start;
                var cnt = 0;
                while(cnt < 3) {
                        start = (cnt + (favourMDY ? 4 : 3)) % 3;
                        if(dateIn.match(dateTest[start].regExp)) {
                                res = dateIn.match(dateTest[start].regExp);
                                y = res[dateTest[start].y];
                                m = res[dateTest[start].m];
                                d = res[dateTest[start].d];
                                if(m.length == 1) m = "0" + m;
                                if(d.length == 1) d = "0" + d;
                                if(y.length != 4) y = (parseInt(y) < 50) ? '20' + y : '19' + y;
                                return String(y)+m+d;
                        };
                        cnt++;
                };
                return 0;
        };
        var joinNodeLists = function() {
                if(!arguments.length) { return []; }
                var nodeList = [];
                for (var i = 0; i < arguments.length; i++) {
                        for (var j = 0, item; item = arguments[i][j]; j++) {
                                nodeList[nodeList.length] = item;
                        };
                };
                return nodeList;
        };
        var addDatePicker = function(inpId, options) {
                if(!(inpId in datePickers)) datePickers[inpId] = new datePicker(options);
        };
        var getDatePicker = function(inpId) {
                if(!(inpId in datePickers)) throw "No datePicker has been created for the form element with an id of '" + inpId.toString() + "'";
                return datePickers[inpId];
        };
        var create = function() {
                if(!(typeof document.createElement != "undefined" && typeof document.documentElement != "undefined" && typeof document.documentElement.offsetWidth == "number")) return;

                cleanUp();
                
                var inputs  = joinNodeLists(document.getElementsByTagName('input'), document.getElementsByTagName('select'));
                var regExp1 = /disable-days-([1-7]){1,6}/g;             // the days to disable
                var regExp2 = /no-transparency/g;                       // do not use transparency effects
                var regExp3 = /highlight-days-([1-7]){1,7}/g;           // the days to highlight in red
                var regExp4 = /range-low-(\d\d\d\d-\d\d-\d\d)/g;        // the lowest selectable date
                var regExp5 = /range-high-(\d\d\d\d-\d\d-\d\d)/g;       // the highest selectable date
                var regExp6 = /format-(d-m-y|m-d-y|y-m-d)/g;            // the input/output date format
                var regExp7 = /divider-(dot|slash|space|dash)/g;        // the character used to divide the date
                var regExp8 = /no-locale/g;                             // do not attempt to detect the browser language
                var regExp9 = /no-fade/g;                               // always show the datepicker
                var regExp10 = /hide-input/g;                           // hide the input
                
                for(var i=0, inp; inp = inputs[i]; i++) {
		                
                        if(inp.className && (inp.className.search(regExp6) != -1 || inp.className.search(/split-date/) != -1) && ((inp.tagName.toLowerCase() == "input" && (inp.type == "text" || inp.type == "hidden")) || inp.tagName.toLowerCase() == "select")) {

                                //if(!inp.id) { inp.id = "fdDatePicker-" + datePickerController.uniqueId++; };
                                if(!inp.id) { inp.id = "fdDatePicker-" + uniqueId++; };
                                var options = {
                                        id:inp.id,
                                        low:"",
                                        high:"",
                                        divider:"/",
                                        format:"d-m-y",
                                        highlightDays:[0,0,0,0,0,1,1],
                                        disableDays:[0,0,0,0,0,0,0],
                                        locale:inp.className.search(regExp8) == -1,
                                        splitDate:0,
                                        noTransparency:inp.className.search(regExp2) != -1,
                                        staticPos:inp.className.search(regExp9) != -1,
                                        hideInput:inp.className.search(regExp10) != -1
                                };

                                if(!options.staticPos) {
                                        options.hideInput = false;
                                } else {
                                        options.noTransparency = true;
                                };
                                
                                // Split the date into three parts ?
                                if(inp.className.search(/split-date/) != -1) {
                                        if(document.getElementById(inp.id+'-dd') && document.getElementById(inp.id+'-mm') && document.getElementById(inp.id+'-dd').tagName.search(/input|select/i) != -1 && document.getElementById(inp.id+'-mm').tagName.search(/input|select/i) != -1) {
                                                options.splitDate = 1;
                                        };
                                };
                                
                                // Date format(variations of d-m-y)
                                if(inp.className.search(regExp6) != -1) {
                                        options.format = inp.className.match(regExp6)[0].replace('format-','');
                                };
                                
                                // What divider to use, a "/", "-", "." or " "
                                if(inp.className.search(regExp7) != -1) {
                                        var dividers = { dot:".", space:" ", dash:"-", slash:"/" };
                                        options.divider = (inp.className.search(regExp7) != -1 && inp.className.match(regExp7)[0].replace('divider-','') in dividers) ? dividers[inp.className.match(regExp7)[0].replace('divider-','')] : "/";
                                };

                                // The days to highlight
                                if(inp.className.search(regExp3) != -1) {
                                        var tmp = inp.className.match(regExp3)[0].replace(/highlight-days-/, '');
                                        options.highlightDays = [0,0,0,0,0,0,0];
                                        for(var j = 0; j < tmp.length; j++) {
                                                options.highlightDays[tmp.charAt(j) - 1] = 1;
                                        };
                                };

                                // The days to disable
                                if(inp.className.search(regExp1) != -1) {
                                        var tmp = inp.className.match(regExp1)[0].replace(/disable-days-/, '');
                                        options.disableDays = [0,0,0,0,0,0,0];
                                        for(var j = 0; j < tmp.length; j++) {
                                                options.disableDays[tmp.charAt(j) - 1] = 1;
                                        };
                                };

                                // The lower limit
                                if(inp.className.search(/range-low-today/i) != -1) {
                                        options.low = datePickerController.dateFormat((new Date().getMonth() + 1) + "/" + new Date().getDate() + "/" + new Date().getFullYear(), true);
                                } else if(inp.className.search(regExp4) != -1) {
                                        options.low = datePickerController.dateFormat(inp.className.match(regExp4)[0].replace(/range-low-/, ''), false);
                                        if(!options.low) {
                                                options.low = '';
                                        };
                                };

                                // The higher limit
                                if(inp.className.search(/range-high-today/i) != -1 && inp.className.search(/range-low-today/i) == -1) {
                                        options.high = datePickerController.dateFormat((new Date().getMonth() + 1) + "/" + new Date().getDate() + "/" + new Date().getFullYear(), true);
                                } else if(inp.className.search(regExp5) != -1) {
                                        options.high = datePickerController.dateFormat(inp.className.match(regExp5)[0].replace(/range-high-/, ''), false);
                                        if(!options.high) {
                                                options.high = '';
                                        };
                                };

                                // Always round lower & higher limits if a selectList involved
                                if(inp.tagName.search(/select/i) != -1) {
                                        options.low  = options.low  ? Math.min(inp.options[0].value, inp.options[inp.options.length - 1].value) + String(options.low).substr(4,4)  : datePickerController.dateFormat(Math.min(inp.options[0].value, inp.options[inp.options.length - 1].value) + "/01/01");
                                        options.high = options.high ? Math.max(inp.options[0].value, inp.options[inp.options.length - 1].value) + String(options.high).substr(4,4) : datePickerController.dateFormat(Math.max(inp.options[0].value, inp.options[inp.options.length - 1].value) + "/12/31");
                                };

                                // Datepicker is already created so reset it's defaults
                                if(document.getElementById('fd-'+inp.id)) {
                                        for(var opt in options) {
                                                datePickers[inp.id].defaults[opt] = options[opt];
                                        };
                                        datePickers[inp.id].enabledDays = datePickers[inp.id].disabledDays = [];
                                };
                                
                                // Create the button (if needs be)
                                var but;
                                
                                if(!options.staticPos && !document.getElementById("fd-but-" + inp.id)) {
                                        
                                		but = document.createElement('a');
                                        but.href = "#";
                                        
                                        var span = document.createElement('span');
                                        span.appendChild(document.createTextNode(String.fromCharCode( 160 )));

                                        but.className = "date-picker-control";
                                        but.title = (typeof(fdLocale) == "object" && options.locale && fdLocale.titles.length > 5) ? fdLocale.titles[5] : "";
                                        
                                        but.id = "fd-but-" + inp.id;
                                        but.appendChild(span);
                                
                                        if(inp.nextSibling) {
                                                inp.parentNode.insertBefore(but, inp.nextSibling);
                                        } else {
                                                inp.parentNode.appendChild(but);
                                        };
                                } else if(!options.staticPos) {
                                        but = document.getElementById("fd-but-" + inp.id);
                                };
                                
                                // Add button events
                                if(!options.staticPos) {
                                        but.onclick = but.onpress = function(e) {
                                                e = e || window.event;
                                                var inpId = this.id.replace('fd-but-','');
                                                try { var dp = datePickerController.getDatePicker(inpId); } catch(err) { return false; };

                                                if(e.type == "press") {
                                                        var kc = e.keyCode != null ? e.keyCode : e.charCode;
                                                        if(kc != 13) return true;
                                                        if(dp.visible) {
                                                                hideAll();
                                                                return false;
                                                        };
                                                };
                                                if(!dp.visible) {
                                                        datePickerController.hideAll(inpId);
                                                        dp.show();
                                                } else {
                                                        datePickerController.hideAll();
                                                };
                                                return false;
                                        };
                                };
                                
                                // Create the datePicker (if needs be)
                                if(!document.getElementById('fd-'+inp.id)) {
                                        //datePickerController.datePickers[inp.id] = new datePicker(options);
                                        datePickers[inp.id] = new datePicker(options);
                                };

                                but = null;
                        };
                };
        }
        
        return {
                addEvent:addEvent,
                removeEvent:removeEvent,
                create:create,
                destroy:destroy,
                cleanUp:cleanUp,
                addDatePicker:addDatePicker,
                getDatePicker:getDatePicker,
                dateFormat:dateFormat,
                datePickers:datePickers,
                hideAll:hideAll
        };
}();


})();

datePickerController.addEvent(window, 'load', datePickerController.create);
datePickerController.addEvent(window, 'unload', datePickerController.destroy);



/*** /element.js **********************************/


Element.EXPAND_COLLAPSE_DURATION = 0.5;

Element._findAncestorForm = function(element) {
    var node = element;
    
    do {
        node = node.parentNode;
    } while(node && node.nodeName !== 'FORM');

    return node; 
};


Element._setEnabledOnChildren = function(element, enabled) {
    if (element.nodeName == 'INPUT' || element.nodeName == 'SELECT') {
        element.disabled = !enabled;
    } else {
        $A(element.childNodes).each(
            function (child) {
                Element_setEnabledOnChildren(child, enabled);
            }
        );
    }
};


Element.addMethods
(
    {
        addOption : function(element, option) {
            try {
                element.add(option, null);
            } catch (e) {
                element.add(option);
            }
        },
        
        clearOptions : function(element) {
            while(element.options && element.options.length > 0) {
                element.remove(0);
            }
        },
        
        setOptions: function (element, options) {
            $(element).clearOptions();
            $H(options).each(
                function(entry) {
                    $(element).addOption(new Option(entry.value, entry.key));
                }.bind(this)
            );
        },
        
        addRow : function(element, columns) {
            var row = element.insertRow(element.rows.count);
            $A(columns).each(
                function(content) {
                    var cell = row.insertCell(-1);
                    cell.appendChild(
                        document.createTextNode(
                            content
                        )
                    );
                }
            );
        },
        
        deleteAllRows : function(element) {
            if (element.rows) {
                while(element.rows.length) {
                    element.deleteRow(0);
                }
            }
        },
        
        removeAllChildren: function(element) {
            var child = element.firstChild;
            while (child) {            
                var nextSibling = child.nextSibling;
                $(child).remove();
                child = nextSibling;
            }
        },
        

        
        disableAll : function(element) {
            Element._setEnabledOnChildren(element, false);
        },
        
        enableAll : function(element) {
            Element._setEnabledOnChildren(element, true);
        },
        
        
        expand : function(element) {
            Effect.BlindDown(
                element.id, 
                {
                    duration : Element.EXPAND_COLLAPSE_DURATION
                }
            );      
        },

        collapse : function(element) {
            Effect.BlindUp(
                element.id, 
                {
                    duration : Element.EXPAND_COLLAPSE_DURATION
                }
            );      
        },
        
        
        getForm: function(element) {
            var form = null;
            
            if (element.form) {
                form = element.form;
            } else {
                form = Element._findAncestorForm(element);
            }
            
            return form;
        },
        
        scrollToElement : function(element, target, scrollAxes) {
            if (!scrollAxes) {
                scrollAxes = [true, true];
            }
            var targetPosition = Position.cumulativeOffset(target);
            var elementPosition = Position.cumulativeOffset(element);
            if (scrollAxes[0]) {
                element.scrollLeft = targetPosition[0] - elementPosition[0];
            }
            
            if (scrollAxes[1]) {
                element.scrollTop = elementPosition[1] - targetPosition[1];
            }
        }
        
    }
);


/*** /xslt.js **********************************/


Ajax.XSLTUpdater = Class.create();


Ajax.XSLTUpdater.prototype = {
    serverProcessor : '/xsl_stylesheets/getAsHTML',    
    stylesheet : '/xsl/static/' + Paths.lang + '/secure_unisource.xsl',
    
    initialize : function(element, url, options) {
        this.element = $(element);
        this.url = url;
        this.mode = 'server';
        this.processor = null;
        
        if (options === undefined) {
            options = {};
        }
        this.options = options;
        this.processSuccessOption();
        
        this.fetchStylesheet(Paths.www + this.stylesheet);
        
        if (document.recalc) {// IE
            this.mode = 'client';
        } else if (XSLTProcessor) {
            // We need to flag = 'server' for Safari here
            this.mode = 'client';
            this.processor = new XSLTProcessor();
            this.processor.importStylesheet(this.parsedStylesheet);
        }
        
        var processMethod = this.process[this.mode].bind(this);
        processMethod();
    },
    
    processSuccessOption : function() {
        if (this.options.onSuccess) {
            this.onSuccess = this.options.onSuccess;
        } else {
            this.onSuccess = Prototype.emptyFunction;
        }
    },
    
    fetchStylesheet : function(url) {
        var stylesheet = null;
        var stylesheetText = null;
        request = new Ajax.Request(url, 
            {
                asynchronous : false,
                onSuccess : function(transport) {;
                    stylesheet = transport.responseXML;
                    stylesheetText = transport.responseText;
                },
                onFailure : function(transport) {
                    alert('Download error: ' + transport.status + ' ' + transport.statusText);
                }
            }
        );
        if (stylesheet == null) {
            alert('ERROR: could not load: ' + url);
        }
        this.parsedStylesheet = stylesheet;
        this.stylesheetText = stylesheetText;
        
    },
    
    
    runScripts: function() {
        var scripts = $(this.element).getElementsByTagName('script');
        $A(scripts).each(
            function(scriptElement) {
                try {
                    eval(scriptElement.text);
                } catch(e) {
                    alert(e.message);
                }
            }
        );
    },
    
    
    process : {
        client : function() {            
            var options = this.options;
            options.onSuccess = this.update.client.bindAsEventListener(this);
            new Ajax.Request(
                this.url,
                options
            );
                
        },
        server : function() {
            var options = this.options;
            options.onSuccess = this.update.server.bind(this);
            options.method = 'post';
            options.postBody = 'url=' + this.url;
            new Ajax.Request(
                Paths.www + this.serverProcessor,
                options
            );
        }
    }, 
    
    update : {
        client : function(transport) {
            if (!transport.responseXML) {
                $(this.element).update('The server returned an empty response');
            } else {
                var processedResponse;
                if (this.processor) {
                    processedResponse = this.processor.transformToFragment(transport.responseXML, document);
        
                    $A(this.element.childNodes).each(function(node) {
                        this.element.removeChild(node);
                    }.bind(this));
                    $(this.element).appendChild(processedResponse);
                } else {
                    //IE
                    this.parsedStylesheet.resolveExternals = true;
                    try {
                        processedResponse = 
                            transport.responseXML.transformNode(this.parsedStylesheet);
                    } catch(e) {
                    }
                    this.element.innerHTML = '';
                    var decoy = document.createElement('div');
                    decoy.innerHTML = processedResponse;
                    $(this.element).appendChild(decoy);
                }
            }
            
            this.runScripts();
            this.onSuccess(transport);
        },
        server: function(transport) {
            this.element.update(transport.responseText);
        }
    }
};

Ajax.ActiveXXSLTWrapper = Class.create();
Ajax.ActiveXXSLTWrapper.prototype = {
    initialize: function() {
        this.processor = new ActiveXObject('Microsoft.XMLDOM');
    }
}