/*** /ignitionweb/widgets.js **********************************/


/**
 * IgnitionWeb 4.0
 * 
 * Content Management System and Web Site Development Framework
 * 
 * Copyright 2007 by High-Touch Communications Inc.
 * 
 * This software was developed internally by High-Touch Communications Inc.
 */
 
 /**
  * A supporting class for selection lists
  */
 function SelectionList(id, fieldName) {
    this.available = $(id + '-available');
    this.selected = $(id + '-selected');
    Element.extend(this.available);
    Element.extend(this.selected);
    this.fieldName = fieldName;
    
    Event.observe($(id + '-select'), 'click', this.select.bindAsEventListener(this));
    Event.observe($(id + '-deselect'), 'click', this.deselect.bindAsEventListener(this));
    Event.observe(this.available.form, 'submit', this.submit.bindAsEventListener(this));
    
 }
 
 SelectionList.prototype = {
    initialize : function() {},
    /**
     * Moves an item from the "available" list to the "selected" list.
     */
    select : function() {
        this.moveSelected(this.available, this.selected);
    },       
    /**
     * Moves an item from the "selected" list to the "available" list.
     */    
    deselect : function() {
        this.moveSelected(this.selected, this.available);
    },
    
    /**
    * Moves all selected items from the specified source
    * to the specified destination
    *
    * @param HTMLElement source         the source list
    * @param HTMLElement destination    the destination list
    */
    moveSelected: function(source, destination) {
        $A(source.options)
        .findAll(
            function(option){ 
                return option.selected; 
            }
        ).each(
            function(option) {
                var option = Element.remove(option);
                destination.appendChild(option);
            }
        );
        
    },
    
    
    /**
     * Adds the selected items to the form fields
     */
    submit: function() {
        var form = this.available.form;
        this.selected.multiple = true;
        for (var i=0; i < this.selected.options.length;i++) {
            this.selected.options[i].selected = true;
        }
    }
 }
 
Callout = Class.create();
Callout.DEFAULT_OPACITY = 0.8;

Callout.prototype = {    
    initialize: function(element, options) {
        this.element = $(element);
        this.options = options || {};
        if (!this.options.opacity) {
            this.options.opacity = Callout.DEFAULT_OPACITY;
        }
        if (!this.options.text) {
            this.options.text = '';
        }
        this.element.callout = this;
        Event.observe(window, 'load',
            this.create.bindAsEventListener(this));
    },
    
    setText : function(text) {
        this.options.text = text;
        Element.update(this.callout, text);
    },
    
    create: function() {
        var element = document.createElement('div');
        Element.extend(this.element);
        var elementId = this.element.id + '-callout';                
        $(element).id = elementId;                
        $(element).style.backgroundImage =  "url('" + Paths.www + '/img/bg_callout.gif' + "')";
        $(element).style.backgroundRepeat = 'no-repeat';        
        $(element).className = 'callout';                             
        $(element).update(this.options.text);               
        
        this.element.parentNode.insertBefore(element, this.element);
        Position.absolutize(element); 
               
        
        $(element).hide();
        this.callout = $(elementId);
    },
    
    show : function() {
        this.callout.show();
        var width = this.element.getWidth();
        var offset = Position.cumulativeOffset(this.element);
        new Effect.Move(this.callout, {x: offset[0]-10, y: offset[1]-10, 'duration' : 0.0, mode:'absolute', queue:'front'});
        
        new Effect.Parallel([
               new Effect.Move(this.callout, {x: offset[0], y: offset[1] - this.callout.getHeight(), mode:'absolute'}),
               new Effect.Fade(this.callout, {from:0.0, to: this.options.opacity})
        ], {queue: 'end'});
    },
    
    hide: function() {
        this.callout.hide();
    }
}
    
Widget = Class.create();
Widget.createOption = function(value, label) {
    return new Option(label, value)
};

Widget.Methods = {

    addOption : function(list, option) {
        try {
            $(list).add(option, null);
        } catch(e) {
            $(list).add(option);
        }
    },
    updateOptions : function(list, options) {
        $(list).immediateDescendants().each(
            function(element) {
                $(element).remove();
            }
        );
        if (options.length) {
            for (var i=0;i<options.length;i++) {
                $(list).addOption(Widget.createOption(i, options[i]));
            }
        } else {
            $H(options).each(function(item) {
                $(list).addOption(Widget.createOption(item.key, item.value));
            });
        
        }
    }
}

Element.addMethods(Widget.Methods);


/*** /ignitionweb/tree.js **********************************/


Tree = Class.create();

Tree.prototype = {
    expanded : {},

    initialize: function(id, nodes, expandedNodes, ajax, ajaxOptions, collapsedImage, expandedImage) {
        this.id = id;
        this.nodes = nodes;
        this.attachEvents();
        this.ajaxOptions = ajaxOptions;
        this.collapsedImage = collapsedImage;
        this.expandedImage = expandedImage;
        
        $A(this.nodes).each(
            this.collapse.bind(this)
        );
        $A(expandedNodes).each(
            this.expand.bind(this)
        );
        
        
        if (ajax) {
            this.useAJAX();
        }
    },
    
    useAJAX : function() {
        $A(this.nodes).each(
            function(node) {
                Event.observe(
                    $(this.getNodeLinkId(node)), 
                    'click',
                    function(e) {
                        Event.stop(e);
                        var link = Event.element(e);
                        if (this.update) {                        
                            new Ajax.Updater(
                                this.update,
                                link.href,
                                this.ajaxOptions
                            );
                        } else {
                            new Ajax.Request(
                                link.href,
                                this.ajaxOptions
                            );
                        }
                        link.addClassName('selected');
                        if (this.selected) {
                            this.selected.removeClassName('selected');
                        }
                        this.selected = link;
                    }.bindAsEventListener(this)
                );
            }.bind(this)
        );
    },
    
    getNodeElementId : function(nodeId) {
        return this.id + '-' + nodeId;
    },
    
    getNodeChildrenId : function(nodeId) {
        return this.getNodeElementId(nodeId) + '-children';
    },

    getNodeToggleId : function(nodeId) {
        return this.getNodeElementId(nodeId) + '-toggle';
    },
    
    getNodeLinkId : function(nodeId) {
        return this.getNodeElementId(nodeId) + '-link';
    },
    
    
    attachEvents : function() {
        $A(this.nodes).each(
            function(nodeId) {    
                var nodeToggle = $(this.getNodeToggleId(nodeId));                
                if (nodeToggle) {
                    Event.observe(nodeToggle, 'click', 
                        function(e, nodeId) {
                            this.toggle(nodeId);
                        }.bindAsEventListener(this, nodeId));
                }
            }.bind(this)
        );       
    },
    
    toggle : function(nodeId) {
        if (this.expanded[nodeId]) {
            this.collapse(nodeId);
        } else {
            this.expand(nodeId);
        }
    },
    
    expand : function(nodeId) {
        var children = $(this.getNodeChildrenId(nodeId));
        if (children) {
            children.show();
        } 
        
        var toggle = $(this.getNodeToggleId(nodeId));
        if (toggle) {
            toggle.src = this.expandedImage;
        }
        
        this.expanded[nodeId] = true;
    },
    
    collapse : function(nodeId) {
        var children = $(this.getNodeChildrenId(nodeId));
        if (children) {
            children.hide();
        }
        
        var toggle = $(this.getNodeToggleId(nodeId));
        if (toggle) {
            toggle.src = this.collapsedImage;        
        }
        
        this.expanded[nodeId] = false;        
    },
    
    setSelectedNodeId : function(nodeId) {
        this.selected = $(this.getNodeLinkId(nodeId));
    }
}


/*** /ignitionweb/validator.js **********************************/


/**
 * IgnitionWeb 4.0
 * 
 * Content Management System and Web Site Development Framework
 * 
 * Copyright 2007 by High-Touch Communications Inc.
 * 
 * This software was developed internally by High-Touch Communications Inc.
 * In no event shall this source code be published.
 */

Validator = Class.create();

/**
 * An AJAX-based forms validator that uses callouts
 * to display error messages.
 */
Validator.prototype = {
    
    errorList : {},
    
    validationUrl : null,
    
    form : null,
    
    errorCount : 0,
    
    verticalOffset: 50,
    
    callouts: [],
    
    method: 'alert', // alert or pop-ups
    
    validated : false,
    
    initialize : function(form, url) {
        this.setForm(form);
        this.validationUrl = url;
        new RetryHandler(
            this,
            {
                validate : {
                    type: RetryHandler.ASYNCHRONOUS
                }
            }
        )
    },
    
    clearCallouts : function() {
        for (var i=0;i<this.callouts.length;i++) {
            if (this.callouts[i].parentNode) {
                this.callouts[i].remove();
            }
        }
        
        this.callouts = [];
    },
    
    /**
     * The default error handler that can be attached to any
     * form element
     */
    handleError : function(elementIndex) {
        if (this.visible) {
            var element = document.createElement('div');
            Element.extend(this.parentNode);
            var elementId = this.id + '-callout';
            element.id = elementId;            
            element.style.backgroundImage =  "url('" + IW.imageDir + 'bg_callout.gif' + "')";
            element.style.backgroundRepeat = 'no-repeat';
            element.className = 'callout';
            Element.update(element, this.errorText);
            this.parentNode.insertBefore(element, this);
            Position.absolutize(element);            
            
            var max = Element.getWidth(document.documentElement) - element.getWidth()  - 10 - Position.cumulativeOffset(this)[0];
            Element.extend(element);
            
            
            var width = this.getWidth();
            if (width > max) {
                width = max;
            }
            
            var finalOpacity = 0.4 + 0.4 * (elementIndex / this.form.validator.errorCount);
            
            new Effect.Parallel([
                new Effect.Move($(elementId), {x: width - 50, y:-this.form.validator.verticalOffset, mode:'relative'}),
                new Effect.Fade($(elementId), {from:0.0, to: finalOpacity})
            ]);
            this.form.validator.callouts.push(element);
            var wrapper = {
              remove : function() {element.remove(); }
            };
            wrapper.element = element;
            Event.observe(element, 'click', wrapper.remove.bindAsEventListener(wrapper));
            
        }
    },
    
    /**
     * Displays pop-ups for all elements for which errors
     * were encountered
     */
    handleErrors: function() {   
        this.clearCallouts();
        var alreadyProcessed = {}; // to avoid duplicates
        var errors = '';
        
        // TODO: Restructure this whole thing
        if (this.errorCount > 0) {   
            if(this.method == 'alert') {
                $H(this.errorList).each(
                    function(entry) {
                        errors += '- ' + entry.value + '\n';                        
                    }
                );            
                alert(errors);    
            } else if (this.method == 'pop-ups') {
                var firstErrorElement = null;        
                for (var i=0; i < this.form.elements.length; i++){
                    var el   = this.form.elements[i];                   
                    var name = el.name.replace(/\[\]$/, '');
                    if (this.errorList[name] && !alreadyProcessed[name]) {
                        el.errorText = this.errorList[name];                    
                        el.onvalidationerror(i);
                        if (!firstErrorElement) {
                            firstErrorElement = i;
                        }
                        alreadyProcessed[name] = true;                        
                    } 
                }                
                if (this.method == 'pop-ups' && firstErrorElement) {   
                    Element.extend(elements[firstErrorElement]);
                    elements[firstErrorElement].scrollTo();
                }
            } else { // its a custom function
                this.method(this.errorList);
            }
        }                         
    },     
    
    /**
     * Sets up a form for this validator
     *
     * @param form the ID of the form
     */
    setForm: function(form) {
        this.form = $(form);
        this.form.validator = this;
        this.addHandlers();
    },
    
    /**
     * Adds validation handlers to all elements in a given form
     */
    addHandlers : function() {
        with(this.form) {
            for (var i=0;i<elements.length;i++) {
                elements[i].onvalidationerror = this.handleError;
            }    
        }
    },
    
    /**
     * An onSuccess callback that sets up the error list.
     */
    ajaxHandler : function(transport) {
        if (transport.responseText) {
            this.errorList = eval('(' + transport.responseText + ')');
            this.errorCount = 0;
            if (this.errorList && !(this.errorList.length === 0)){
                for (var i in this.errorList) {
                    this.errorCount++;
                }            
            }    
            this.handleErrors();
        }
        this.validated = true;
        return true;
    },
    
    /**                         * JavaScript validation
     */
    validate : function(event, options) {
        var fail = arguments.callee.fail;
        if (!options) {
            options = {};
        }
        if (options.submit === undefined) {
            options.submit = true;
        }
        this.validated = false;
        if (this.form.actionName == 'cancel') {
            return;
        }
        new Ajax.Request(
            this.validationUrl,
            {
                method: 'post',
                onSuccess : this.ajaxHandler.bindAsEventListener(this),
                onFailure : function(transport) {
                    fail(
                        function() {
                            alert('Validation failure: ' + transport.status + ': ' + transport.statusText);
                        } 
                    );
                },
                
                onException: function(transport, e) {
                    fail(
                        function() {
                            alert(e.message);
                        }                    
                    )
                },
                asynchronous: false,
                parameters: Form.serialize(this.form)
            }                      
        );
        if (event) {
            if (!this.validated || this.errorCount > 0) {
                Event.stop(event);
            } 
        } else {
            if (this.validated && this.errorCount == 0 && options.submit) {
                
                window.setTimeout(
                    this.form.submit,
                    1
                );
            }
        } 
        return (this.errorCount == 0);
    }
};



/**
 * Enables the validator for a specific form
 * 
 * @param form the name of the form
 * @param url  the url of the validation action
 */
Validator.enable = function(form, url) {
    form = $(form);
    if (!form.validator) {
        var validator = new Validator(form, url);
        form.validationHandler = validator.validate.bindAsEventListener(validator);
        Event.observe(form, 'submit', form.validationHandler);
    }
}


/**
 * SHOULD disable the validator for a specific form
 * 
 * @param form the name of the form
 * @param url  the url of the validation action
 */
Validator.disable = function(form) {
    form = $(form);
    if (form.validator) {
        Event.stopObserving(form, 'submit', form.validationHandler);
        
        // This is a hardcore workaround, because the previous line doesn't 
        // seem to be working
        $(form).actionName = 'cancel';
    }
}

Validator.submit = function(form) {
    if (form.validator) {
        form.validator.validate();
    } else {
        form.submit();
    }
}


/*** /ignitionweb/ajax.js **********************************/


IwAjax = Class.create();

IwAjax.link = function(link, updateElement, afterUpdate) {
    new Ajax.Updater(
        $(updateElement),
        link.href,
        {
            evalScripts: true,
            onComplete : function() {
                if (afterUpdate) {
                    window.setTimeout(
                        afterUpdate,
                        100
                    );
                } 
            }
        }
    );
    return false;
}


/*** /unisource/myunisource/myunisource.js **********************************/


MyUnisource = Class.create();

MyUnisource.Manager = {
	Folders : {
		attachQuickAdd : function() {
            Event.observe('quick-add-product-code', 'keypress', function (event) {
                if (event.keyCode == 13 && !UniPopupStack.pop()) {
                    $('folders-listing').folders.quickAdd($('quick-add-product-code'));
                    Event.stop(event);
                    return false;
                }
            });		
		}
	}

};


/*** /unisource/myunisource/minicart.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.
 */
 
 


/**
* The Mini-Cart - a reduced version of the primary order cart, which
* makes it possible to use "straight AJAX" to add products without 
* going back and forth between product listings and the cart
*
* @author Artem Ploujnikov <artem@htc.ca> 
*/
MyUnisource.MiniCart = Class.create();

MyUnisource.MiniCart.Order = {
	FIRST_ON_TOP : 1,
	LAST_ON_TOP : 2
};



MyUnisource.MiniCart.prototype = {
	/**
	* The ID of the cart element
	*
	* @var String
	*/ 
	id : null,
	
	/**
	* The cart element
	*
	* @var HTMLElement
	*/
	cart : null,
	
	/**
	* The tbody element that contains the products
	*
	* @var HTMLTableBody
	*/
	productBody: null,
	
	
	/**
	* Keeps track of requests issued by this cart. This
	* makes it possible to cancel the ones that shouldn't
	* be there.
	*/
	quantityRequests: [],
	
	
	/**
	* The contents of the cart as an associative array:
	*
	* {'011003' : {
	*		product_code : '011003',
	*		description : 'bogus product',
	*  		quantity : 1,
	*		price : {
	*			uom : 'SHT',
	* 			brackets : [
	*				{
	*					minimum_quantity: 0,
	*					price: 10,
	*					uom: {
	*						quantity : 'SKD',
	*						price: 'SHT'
	*					},
	*				},
	*				{
	*					minimum_quantity: 100,
	*					price: 8,
	*					uom: {
	*						quantity : 'CS',
	*						price: 'UN'
	*					},
	*				}
	*			]
	*       }
	* }
	*/
	products : {},
	
	/**
	* A collection of ProductRow instances representing the products
	* in this mini-cart
	*
	* @var Array
	*/
	rows : [],
	
	
	/**
	* The total of line totals in this cart
	*
	* @var Number
	*/
	total : 0.0,
	
	/**
	* The HTML element used to display the total
	* 
	* @var HTMLElement
	*/
	totalElement : null,
	
	/**
	* The HTML element used to display the product count
	*
	* @var HTMLElement
	*/
	productCountElement : null,
	
	
	/**
	* The table row with the product count
	*
	* @var HTMLElement
	*/
	productCountRow : null,
	
	/**
	* The HTML label text for the product count
	*
	* @var HTMLElement
	*/
	productCountLabel : null,
	
	/**
	* The HTML element in which user-friendly information
	* about the number of items being displayed (e.g. 1 to 5 of 200)
	*
	* @var HTMLElement
	*/
	displayInfoElement : null,
	
	
	/**
	* The element that contains the table header (removed when there are zero products)
	*
	* @var HTMLElement
	*/
	headerElement : null,
	
	/**
	* The row with the "Create a new order" link - shows when there are no
	* products in the cart and links to My Catalogue
	*
	* @var HTMLElement
	*/
	createOrderRow : null,
	
	
	/**
	* The panel that contains "Proceed to Checkout"
	*
	* @var HTMLElement
	*/
	bottomPanel : null,

	/**
	* The table row for the product total
	*
	* @var HTMLElement
	*/	
	totalRow : null,
	
	/**
	* Specifies the tab index of the last quantity item
	*
	* @var Integer
	*/
	lastTabIndex : 10000,
	
	/**
	* Display options for the mini-cart (e.g. whether prices should be 
	* shown, etc.)
	*
	* @var Object
	*/
	options : {},
	
	/**
	* The text template used for the display info
	*/
	text : {
		displayInfoTemplate : '%from% to %to% of %total%',
		unknownPrice: 'N/A',
		productCount : {
			singular:  'item in current order',
			plural:	'items in current order',
			zero : 'Create a new order'
		},
		quantityUpdateError : "Unable to send product quantities to the server\nReason: %reason%", 
        submitProductsError : "Unable to add products to the cart\nReason :%reason%"
	},
	
	/**
	* The number of products in the cart
	*
	* @var Integer
	*/
	productCount : 0,
	
	/**
	* The number of seconds between quantity updates
	* (if the quantities are actually changed)
	*
	* @var Number
	*/
	quantityUpdateFrequency: 5,
	
	
	/**
	* The range of products being displayed
	*/
	displayRange: {
		from : 1,
		to :   5
	},
	
	/**
	* Indicates whether any quantities have been
	* modified since the last update (i.e. a "dirty" flag)
	*/
	quantitiesModified : false,
	
	/**
	* An array of products whose quantities have been
	* modified.
	*/
	updatedQuantities : [],
	
	/**
	* A Prototype "periodical executer" for automatic
	* server-side quantity synchronization
	*
	* @var PeriodicalExecuter
	*/
	quantityExecuter : false,
	
    /**
    * The last time the cart was "touched" (i.e. modifications were made
    * to it).
    *
    * @var Date
    */
    lastTouch : new Date(),
    
    /**
    * The number of time, in milliseconds, since the last change to warrant
    * an update
    *
    * @var int
    */
    touchThreshold: 5000,
	
	
	/**
	* Initializes a MiniCart instance
	*
	* @param string id the ID of the cart element
	*/
	initialize : function(id, products, listingMode, text, options) {
		new EventHandler(this);
		this.id = id;
		this.cart = $(id);
		this.cart.cart = this;
		this.productBody = $(id + '-products');
		
		if (this.options) {
			this.options = options;
		} else {
			this.options = {};
		}
		
		if (text) {
			this.text = text;
		}
		if (listingMode)  {
			this.listingMode = listingMode;
        } else if (this.options.sequence == 'addition_order') {
            this.listingMode = new MyUnisource.MiniCart.DisplayAllListingMode();
		} else {
			this.listingMode = new MyUnisource.MiniCart.MoreLessListingMode();
		}		
				
		this.totalElement = $(id + '-total');
		this.productCountElement = $(id + '-product-count');
		this.productCountRow = $(id + '-product-count-row');
		this.productCountLabel = $(id + '-product-count-label');
		this.createOrderRow = $(id + '-create-order-row');
		this.displayInfoElement = $(id + '-display-info');
		this.headerElement = $(id + '-header');
		this.bottomPanel = $(id + '-bottom-panel');
		this.totalRow = $(id + '-product-total-row');

		if (products) {
			this.addProducts(
				products,
				MyUnisource.MiniCart.Order.FIRST_ON_TOP
			);
			
		} 
		if (options.showPrices) {
			this.recalculateTotal();
			this.updateTotals();	
		}
			
		this.attachEvents();
		
		this.listingMode.setup(this);
		$(this.id + '-container').style.display = 'block';
        new RetryHandler(
            this, 
            {
                submitProducts : {
                    type: RetryHandler.ASYNCHRONOUS
                },
                updateQuantities : {
                    type: RetryHandler.ASYNCHRONOUS
                }
            }
        );
	},
	
	/**
	* Attaches event listeners to this\
	* cart
	*/
	attachEvents : function() {
		if (this.options.showPrices) {
			this.observe(
				MyUnisource.MiniCart.Event.TOTAL_CHANGED,
				this.updateTotals.bind(this)
			);
		}
		
		this.observe(
			MyUnisource.MiniCart.Event.DISPLAY_RANGE_CHANGED,
			function() {
				this.updateDisplayInfo();
				this.updateRowVisibility();
			}.bind(this)
		);
		
        this.startQuantityUpdates();
        		
		Event.observe(
			window,
			'beforeunload',
			function() {
				this.updateQuantities({synchronous: true, isFinal : true});
			}.bind(this)
		);
		
		
	},
    
    /**
    * Sets the touch marker to the current time
    */
    touch : function() {
        this.lastTouch = new Date();
    },
    
    
    /**
    * Determines whether the amount of time elapsed since the last
    * touch is greater than or equal to the touch threshold
    *
    * @return bool
    */
    isTouched : function() {
        var now = new Date();
        return now.getTime() - this.lastTouch.getTime() >= this.touchThreshold;
    },
    
    
    
    /**
    * Starts periodically sending updated quantities to the
    * server
    */
    startQuantityUpdates : function() {
        this.quantityExecuter = new PeriodicalExecuter(
            this.updateQuantities.bind(this),
            5
        );
    },
    
    /**
    * Stops periodic quantity updates 
    */
    stopQuantityUpdates : function() {
        if (this.quantityExecuter !== null) {
            this.quantityExecuter.stop();        
        }
    },
	
	
	/**
	* Increments the tab index counter by one and returns its
	* new value
	*/
	getNextTabIndex : function() {
		return ++this.lastTabIndex;
	},
		
	/**
	* Adds an array of products to this cart
	*
	* @param Array products an array of product definitions, in the order
	* 		in which they were added to the cart
	*/
	addProducts: function(products, order) {
    
		if (!order) {
            order = 
                (this.options.sequence == 'addition_order') ? 
                    MyUnisource.MiniCart.Order.FIRST_ON_TOP :  MyUnisource.MiniCart.Order.LAST_ON_TOP;
        }
		for (var i=0, length = products.length;i<length;i++) {
            var product = products[i];
            if (this.products[product.id] && this.products[product.id].quantity > 0) {                                                
                this.products[product.id].cartRow.setQuantity(product.quantity);
                if (order == MyUnisource.MiniCart.Order.LAST_ON_TOP) {
                    this.moveToTop(product.id);
                }
            } else {
                if (this.products[product.id]) {
                    delete this.products[product.id];
                }                    
                this.addProduct(product, order);
            }        
        }
		this.assignTabIndexes();		
	},	
	
	/**
	* Moves the table row for the specified product ID to the top of
	* the cart
	*
	* @param Integer productId the product ID that should appear at the top
	* 		of the list
	*/
	moveToTop : function(productId) {
		this.moveRow(
			productId,
			0
		);
	},
	/**
	* Moves the table row for the specified product ID to the bottom of
	* the cart
	*
	* @param Integer productId the product ID that should appear at the bottom
	* 		of the list
	*/
	moveToBottom : function(productId) {
		this.moveRow(
			productId,
			this.rows.length - 1
		);
	},
	
	/**
	* Moves the row for the specified product ID to the specified
	* index
	*
	* @param Integer productId the product whose row will be moved
	* @param Integer desiredPosition the position where the row
	* 		will be placed
	*/
	moveRow : function(productId, desiredPosition) {
		if (this.productBody.rows.length > 1) {
			var productRow = this.products[productId].cartRow;
			var productPosition = 
				this.rows.indexOf(
					this.products[productId].cartRow
				);
				
            if (desiredPosition > this.productBody.rows.length) {
                desiredPosition = this.productBody.rows.length;
            }
            
			this.rows.move(productPosition, desiredPosition);
			if (!productRow.row.visible()) {
				productRow.row.show();
			}
			var rowElement = this.productBody.removeChild(
				productRow.row
			);
			productRow.row = rowElement;
            if (desiredPosition < this.productBody.rows.length - 1) {
			    this.productBody.insertBefore(
				    rowElement,
				    this.productBody.rows[desiredPosition]
			    );			
            } else {
                this.productBody.appendChild(rowElement);
            }
		}
	},
    
    /**
    * Returns the default addition order for this cart
    *
    * @return Integer
    */
    getDefaultOrder : function() {
        var order;
        if (this.options.sequence == 'addition_order')  {
            order = MyUnisource.MiniCart.Order.FIRST_ON_TOP;
        } else {
            order = MyUnisource.MiniCart.Order.LAST_ON_TOP;            
        }
        
        return order;
    },
	
		
	/**
	* Dynamically adds a product to the mini-cart
	*
	* @param Object product a single product definition
	*
	* @access public
	*/
	addProduct: function(product, order) {
		if (!order) order = this.getDefaultOrder();
		this.products[product.id] = product;	
        
		var productRow = new MyUnisource.MiniCart.ProductRow(
			this, 
			product,
			order);
		product.cartRow = productRow;
			
		if (order == MyUnisource.MiniCart.Order.LAST_ON_TOP) {
			this.rows.unshift(
				productRow
			);
		} else {
			this.rows.push(
				productRow
			);
		}
		this.productCount++;
	},
	
	/**
	* Recalculates the total of all rows from scratch
	*/
	recalculateTotal : function() {	
		this.total = this.rows.sum(
			function(row) {
				return row.getPrice().total;
			}
		);	
	},
	
	/**
	* Assigns tab indexes to all rows
	*/
	assignTabIndexes : function() {
        for (var i = 0, length=this.rows;i<length;i++) {
            this.rows[i].setTabIndex(++this.lastTabIndex);
        }
	},
	
	/**
	* Returns the cart total                                 
	*
	* @return Number
	*/
	getTotal : function () {
		return this.total;
	},
	
	/**
	* Updates the display info based on the products
	* currently being displayed
	*/
	updateDisplayInfo : function() {
		this.displayInfoElement.update(
			this.formatDisplayInfo()
		);
		this.productCountElement.update(
			this.rows.length
		);
		
		var productCountLabelText;
		if (this.rows.length == 0){
			this.setEmpty(true);
		} else if (this.rows.length == 1) {			
			productCountLabelText = this.text.productCount.singular;
			this.setEmpty(false);
		} else {
			productCountLabelText = this.text.productCount.plural;
			this.setEmpty(false);
		}		
		this.productCountLabel.update(productCountLabelText);		
	},
	
	/**
	* Changes the display of the cart to accommodate empty
	* and non-empty carts
	*/
	setEmpty : function(empty) {
		if (empty) {
			if (this.totalRow) {
				this.totalRow.hide();
			}
			this.productCountRow.hide();
			this.bottomPanel.hide();
			this.createOrderRow.show();
			this.headerElement.hide();			
		} else {
			if (this.totalRow) {
				this.totalRow.show();
			}
			this.productCountRow.show();
			this.bottomPanel.show();
			this.createOrderRow.hide();
			this.headerElement.show();
		}
	},
	
	/**
	* Determines which rows are being displayed
	* and which ones will be hidden and updates
	* the DOM accordingly
	*/
	updateRowVisibility: function() {
		for (var i=0;i<this.rows.length;i++) {
			var row = this.rows[i];
			if (this.isRowVisible(i)) {
				row.show();
			} else {
				row.hide();                
			}
		}
	},
	
	/**
	* Determines if the row with the specified
	* array index is visible
	*
	* @param int rowIndex
	*/
	isRowVisible: function(rowIndex) {
		rowIndex++;
		
				
		var result = 
		(
			(rowIndex >= this.displayRange.from)
			&&
			(rowIndex <= this.displayRange.to)
		);
		
		return result;
	},
	
	
	/**
	* Formats the line of text indicating the number of
	* items being displayed as 1 to 5 of 100
	*
	* @return String
	*/
	formatDisplayInfo : function() {
		var values = {
			'%from%'  : Math.min(this.displayRange.from, this.rows.length),
			'%to%'    : Math.min(this.displayRange.to, this.rows.length),
			'%total%' : this.productCount
		};
		
		return this.text.displayInfoTemplate.replaceAll(values);
	},
	
	/**
	* Updates the total and the product count
	*/
	updateTotals : function() {
		$(this.totalElement).update(
			Unisource.formatCurrency(
				this.total
			)
		);
	},
	
	/**
	* Displays the Product Details pop-up for the selected product
	*
	* @param Integer productId the ID of the product for which the 
	*   		details are being requested
	*/
	showProductDetails : function(productId) {
		new Ajax.Updater(
			$(this.id + '-product-details-container'),
			Paths.www + '/uni_products/showDetails/' + productId + '/null/true',
			{
				onSuccess : function() {
					$(this.id + '-product-details-popup').unipopup.show();
				}.bind(this)
			}
		);
	},
	
	/**
	* Adds multiple products from a dictionary-style object formatted
	* as {[product id 1] : [quantity 1], [product id 2] : [quantity 2], ...}
	* to the mini-cart by means of a lightweight AJAX request
	*
	* @param object products a "hash" of products with product IDs as keys
	* 		and product quantities as values
	*
	*/
	submitProducts : function(products, options) {
        if (!options) {
            options = {};
        }
        var fail = arguments.callee.fail;
		products = $H(products);
		var productIds = products.keys().toArray().join(',');
		var quantities = products.values().toArray().join(',');
        this.stopQuantityUpdates();
        
        var requestParameters = {
            'products': productIds,
            'quantities' : quantities
        };
        $H(options).each(function(entry) {
            requestParameters['options[' + entry.key + ']'] = entry.value;
        });
		new Ajax.Request(
			Paths.www + '/myunisource/uni_orders/addToMiniCart',
			{
				method: 'post',			
				parameters: requestParameters,
				onCreate : function(transport) {
					UniAjax.hidePopups(transport);
				},
				
				onSuccess : this.addProductsFromAjaxResponse.bind(this),
                
                onFailure : function(transport) {
                    this.fire(MyUnisource.MiniCart.Event.PRODUCT_SUBMISSION_FAILED);
                    fail(
                        function() {
                            alert(
                                this.text.submitProductsError.replaceAll(
                                    {'%reason%' : transport.status + ':' + transport.statusText}
                                )
                            );
                        }
                    );
                }.bind(this),
				
				onException : function(transport, e) {     
                    this.fire(MyUnisource.MiniCart.Event.PRODUCT_SUBMISSION_FAILED);
                    fail(
                        function() {
                            alert(
                                this.text.submitProductsError.replaceAll(
                                    {'%reason%' : e.message}
                                )
                            );
                        }
                    );
				}.bind(this)
			}
		);		
	},
	
	/**
	* Performs a "quick-add" operation for one or more
	* products. This is similar to submitProducts(), except
	* that the server gets an array of product codes instead
	* of product IDs, and per-client product code resolution
	* rules apply
	*
	* @param products The products to be added, formatted as follows
	* 	{product code 1 : quantity 1, product 2 : quantity 2}
	*/
	quickAddProducts : function(products, options) {
		if (!options) options = {};
		
		new Ajax.Request(
			Paths.www + '/myunisource/uni_orders/quickAddToMiniCart',
			{
				parameters : $H(products).toServerArray('quantity'),
				onCreate : function(transport) {
					UniAjax.hidePopups(transport);
				},
				onSuccess : function(transport) {
					this.addProductsFromAjaxResponse(transport);
					if (options.onSuccess) {
						options.onSuccess();
					}
				}.bind(this)
			}
		);	
	},
	
	
	/**
	* Parses the server's response and adds products
	* accordingly
	*
	* @param XMLHttpRequest transport the AJAX transport
	*/
	addProductsFromAjaxResponse : function(transport) {
        try {
            var products = transport.responseJSON;
            this.addProducts(products);        
		    if (this.options.showPrices) {
			    this.recalculateTotal();
		    }
		    this.fire(MyUnisource.MiniCart.Event.DISPLAY_RANGE_CHANGED);
		    this.fire(MyUnisource.MiniCart.Event.TOTAL_CHANGED);
		    this.listingMode.fire(MyUnisource.MiniCart.Event.PRODUCT_COUNT_CHANGED);
		    this.fire(MyUnisource.MiniCart.Event.PRODUCTS_SUBMITTED, products);
		    $(this.id + '-container').scrollTo();	
            this.startQuantityUpdates();        
        } catch (e) {
            var message = e.message;
            if (e.stack) {
                message += ' ' + e.stack;
            }
            alert(message);
        }
	},
	
	
	/**
	* Sends the quantities to the server, if necessary.
	*/
	updateQuantities : function(options) {
		var fail = arguments.callee.fail;
        if (this.quantitiesModified && this.isTouched()) {
            this.stopQuantityUpdates();
		
			var handleResponse = function(transport) {
				var result = transport.responseJSON;
				if (result && result.success) {
					this.resetUpdatedQuantities();
				    this.startQuantityUpdates();
                } else if (result && result.message) {
                    this.stopQuantityUpdates();
					alert(
						this.text.quantityUpdateError.replaceAll(
							{'%reason%' : result.message}
						)
					);
				} else {
					this.stopQuantityUpdates();
                    alert(
						this.text.quantityUpdateError.replaceAll(
							{'%reason%' : transport.responseText}
						)
					);
				}
			}.bindAsEventListener(this);
			
			var destination = Paths.www + '/myunisource/uni_orders/updateQuantitiesOnly';
			if (!options || !options.synchronous) {			
				// Use Prototype
				new Ajax.Request(
					destination,
					{
						parameters : this.getUpdatedQuantities().toServerArray('quantity'),
						onCreate : function(transport) {
							UniAjax.hidePopups(transport);
							this.quantityRequests.push(transport);							
						}.bind(this),
						
						onSuccess : handleResponse,
						onFailure : function(transport) {
                            fail
                            (
                                function() {
							        alert(
								        this.text.quantityUpdateError.replaceAll(
									        {'%reason%' : transport.statusText}
								        )
							        );
                                }
                            );
						}.bindAsEventListener(this),
                        onException : function(e) {
                            this.stopQuantityUpdates();
                            fail
                            (
                                function() {
                                    alert(
                                        this.text.quantityUpdateError.replaceAll(
                                            {'%reason%' : e.message }
                                        )
                                    );
                                }
                            );                        
                        }
					}
				);
			} else {
				this.killQuantityRequests();
				// Manual request
				var transport = Ajax.getTransport();
				transport.open(
					'post',
					destination,
					false
				);
				var allQuantities = this.getAllQuantities();
				
				transport.setRequestHeader('Content-Type','application/x-www-form-urlencoded');
				transport.send(allQuantities.toServerArray('quantity').toHttpString());
				
				if (transport.readyState == 4 && !options.isFinal) {
					handleResponse(transport);
				}			
			}
		} 
 	},
 	
	killQuantityRequests : function() {
		$A(this.quantityRequests).each(
			function(request) {
				if (request.readyState == 2 || request.readyState == 3)  {
					request.abort();
				}
			}
		);		
	},
	
	/**
	* Makes the cart "forget" any retained information regarding
	* updated quantities
	*/
	resetUpdatedQuantities : function() {
		this.quantitiesModified = false;
		this.updatedQuantities = [];
	},
	
	
	
	/**
	* Returns updated product quantities as an associative object 
	* with product IDs as keys and the corresponding quantities as values
	*/
	getUpdatedQuantities: function() {
		var products = this.products;
		return this.updatedQuantities.toDictionary(
			function(productId) {
				return productId;
			},
			function(productId) {
				return products[productId] ?  products[productId].quantity : 0;
			}
		);	
	},	
	
	
	/**
	* Converts a list of products to a product id => quantity
	* asspcoation
	*/
	getAllQuantities : function() {
		var products = $H(this.products);
		var allQuantities = {};
		
		products.each(function(entry){allQuantities[entry.key] = entry.value.quantity});
			
		return $H(allQuantities);
	}
}   

MyUnisource.MiniCart.Event = {
	TOTAL_CHANGED : 'total-changed',
	DISPLAY_RANGE_CHANGED : 'display-range-changed',
	PRODUCT_COUNT_CHANGED : 'product-count-changed',
	PRODUCTS_SUBMITTED : 'products-submitted',
    PRODUCT_SUBMISSION_FAILED: 'product-submission-failed'
};


MyUnisource.MiniCart.Link = {
	CATALOGUE: Paths.www + '/pages/my_unisource/catalogue/search',
	ORDER : Paths.www + '/myunisource/uni_orders/createOrder'
};

MyUnisource.MiniCart.QUANTITY_SIZE = 2;
MyUnisource.MiniCart.QUANTITY_MAX_LENGTH = 5;

MyUnisource.MiniCart.Css = {
	PRODUCT_DESCRIPTION: 'product-description'
};

MyUnisource.MiniCart.ProductRow = Class.create();
MyUnisource.MiniCart.ProductRow.prototype = 
{
	/**
	* The cart to which this row belongs
	*
	* @var MyUnisource.MiniCart
	*/
	cart : null,
	/**
	* The product contained in this row
	*
	* @var object
	*/
	product : null,
	
	/**
	* The DOM object corresponding to this table row
	*
	* @var HTMLTableRow
	*/
	row : null,
	
	/**
	* The DOM object corresponding to the cell in
	* which the product code is contained
	*
	* @var HTMLTableCell
	*/
	productCodeCell : null,
	
	/**
	* The link to the product details in which
	* the product code is wrapped
	*/
	productCodeLink : null,
	
	/**
	* The cell in which the quantity is contained
	*
	* @var HTMLTableCell
	*/
	quantityCell : null,
	
	/**
	* The input box for the quantity
	*
	* @var HTMLInput
	*/
	quantityBox : null,
	
	
	/**
	* The div element that contains the product code
	* elements - relatively positioned
	*
	* @var HTMLElement
	*/
	productCodeContainer : null,
	          
	/**
	* The table cell containing the row total
	*
	* @var HTMLTableCell
	*/          
	totalCell : null,
	
	/**
	* The listing mode used by this cart
	*
	* @var MyUnisource.MiniCart.ListingMode
	*/
	listingMode : null,
	
	/**
	* The pricing record for the product
	*
	* @var MyUnisource.ProductPrice
	*/
	productPrice : null,
	
	
	/**
	* The previous effective price (i.e. the one that was 
	* applicable before the last quantity change)
	*
	* @var object
	*/
	oldPrice : null,
	
	
	/**
	* The previous product quantity
	*
	* @var int
	*/
	oldQuantity : 0,
    
    
    
	/**
	* Creates a new product row
	*
	* @param MiniCart cart 		the cart to which this row belongs
	* @param object   product   the product information
	*/
	initialize : function(cart, product, order) {
		this.cart = cart;
		this.product = product;
		this.productPrice = new MyUnisource.ProductPrice(this.product.price);
		this.create(order);
	},
	
	/**
	* Returns the price for the product in this row,
	* effective at the current quantity
	*
	* @return object
	*/
	getPrice : function() {
		return this.oldPrice;
	},	
    
	/**
	* Creates the DOM elements necessary to display the product
	* in the mini-cart
	*
	* @param String order indicates the order in which rows are
	* 	added to the table (MyUnisource.MiniCart.Order.*) 
	* @access public
	*/
	create : function(order) {
		var rowIndex;
		if (order == MyUnisource.MiniCart.Order.LAST_ON_TOP) {
			rowIndex = 0;
		} else {
			rowIndex = this.cart.productBody.rows.length;
		}        
		this.row = this.cart.productBody.insertRow(rowIndex);		
		this.productCodeCell = this.row.insertCell(0);	
		this.productCodeCell.className = 'product-code';
        this.productCodeContainer = document.createElement('div');
		this.productCodeContainer.className = 'product-code';
		this.productCodeCell.appendChild(this.productCodeContainer);
        this.createProductDescriptionBox();
		this.createProductCodeLink();
        
		this.quantityCell = this.row.insertCell(1);
		this.quantityCell.className = 'quantity';
		this.createQuantityBox();
		
		if (this.cart.options.showPrices) {
			this.totalCell = this.row.insertCell(2);
			this.totalCell.className = 'total';
			this.createTotalNode();				
		}
        
	},
	
	
	/**
	* Completely removes this row and its product from the cart.
	* The product will be deleted on the server as of the next
	* quantity update.
	*/
	remove : function() {
		delete this.cart.products[this.product.id];
		if (this.cart.options.showPrices) {
			this.cart.total -= this.getPrice().total;
		}
		this.row.parentNode.removeChild(this.row);
		this.focusOnNext();
		this.cart.rows.splice(		
			this.cart.rows.findIndexOf(this),
			1
		);
		this.cart.productCount--;
		this.cart.quantitiesModified = true;
		this.cart.updatedQuantities.push(this.product.id);
		this.cart.fire(
			MyUnisource.MiniCart.Event.DISPLAY_RANGE_CHANGED);
		this.cart.fire(
			MyUnisource.MiniCart.Event.TOTAL_CHANGED);
		this.cart.listingMode.fire(
			MyUnisource.MiniCart.Event.PRODUCT_COUNT_CHANGED);
	},
	
	
	
	/**
	* Shows the product description box for this
	* product
	*
	* @access public
	*/
	showDescription : function() {
		var box = $(this.productDescriptionBox);
        var cell = $(this.productCodeCell);
        var offset = cell.cumulativeOffset();
        box.show();
        var width = box.getWidth();
        var height = box.getHeight();
        var cellWidth = cell.getWidth();
        box.style.left = (offset.left + (cellWidth - width)* 0.5).toString() + 'px';
        box.style.top = (offset.top - height).toString() + 'px';
		this.productCodeCell.style.cursor = 'pointer';
        
	},
	
	/**
	* Hides the product description box for this
	* product
	*
	* @access public
	*/
	hideDescription : function() {
		this.productCodeCell.style.cursor = 'auto';
		$(this.productDescriptionBox).hide();
	},
	
	/**
	* Creates a link to the product code. Hovering over
	* this link will cause the product description to appear
	* in a floating "div"
	*
	* @access private
	*/
	createProductCodeLink : function() {
		var productCodeLink = document.createElement('a');
		
		Event.observe( 
			productCodeLink,
			'click',
			function(e) {
				Event.stop(e);
				this.cart.showProductDetails(this.product.id)
			}.bindAsEventListener(this)
		);
		
		Event.observe(
			productCodeLink,
			'mouseover',
			this.showDescription.bind(this)
		);
		
		Event.observe(
			productCodeLink,
			'mouseout',
			this.hideDescription.bind(this)
		);
		
		productCodeLink.appendChild(
			document.createTextNode(
				this.product['product_code'].toString().pad(6, '0', 'left')
			)
		);
        
        
		this.productCodeContainer.appendChild(productCodeLink);
	},
	
	/**
	* Creates a floating box for the product description
	*
	* @access private
	*/
	createProductDescriptionBox : function() {
		this.productDescriptionBox = document.createElement('div');
		this.productDescriptionBox.className = 
			MyUnisource.MiniCart.Css.PRODUCT_DESCRIPTION;		
		this.productDescriptionBox.style.display = 'none';
		this.productDescriptionBox.appendChild(
			document.createTextNode(this.product.description)
		);
		this.productCodeContainer.appendChild(this.productDescriptionBox);
	},
	
	/**
	* Creates the quantity box in which the user
	* can enter the quantity of the product they 
	* would like to order
	*
	* @access private
	*/
	createQuantityBox : function() {
		this.quantityBox = document.createElement('input');
		
		with (this.quantityBox) {
			type = 'text';
			maxlength = MyUnisource.MiniCart.QUANTITY_MAX_LENGTH;
			size = MyUnisource.MiniCart.QUANTITY_SIZE;
			value = (this.product.quantity) ? this.product.quantity : 0;
		}
		
		Event.observe(
			this.quantityBox,
			'keyup',
			function() {
				this.updateQuantity(this.quantityBox.value);
				this.previousQuantity = this.quantityBox.value;
			}.bind(this)
		);
		
		
		this.quantityCell.appendChild(this.quantityBox);
		
		var uomNode = document.createTextNode(this.product.price.uom.order);
		this.quantityCell.appendChild(uomNode);
	},
	
	/**
	* Creates the price field
	*/
	createTotalNode : function() {
		var price = this.productPrice.getPriceAt(this.product.quantity);
		if (!price) {
			price = {total : 0, price : 0};
		}

		this.totalNode = document.createTextNode(
			this.getDisplayTotal(price)
		);
		this.totalCell.appendChild(this.totalNode);
		this.oldPrice = price;
	},
	
	
	/**
	* Formats a price for display while taking unknown prices
	* into account
	*
	* @param object price the price returned by MyUnisource.ProductPrice
	*
	* @return String
	*/
	getDisplayTotal : function(price) {
		var displayTotal;
		
		if (!price || price.bracket === null) {
			displayTotal = this.cart.text.unknownPrice;
		} else {
			displayTotal = Unisource.formatCurrency(
				price.total
			);		
		}
		
		return displayTotal;
	},
	
	/**
	* Sets the product quantity to the specified value and updates the UI
	* accordingly
	*
	* @param Number quantity the number of units to add
	*/
	setQuantity: function(quantity) {
		this.quantityBox.value = this.product.quantity = quantity;
		if (this.cart.options.showPrices) {
			this.updatePrice();
		}
	},
	
	
	/**
	* Updates the UI in response to a user-initiated quantity
	* update
	*
	* @param Integer newQuantity the new product quantity	
	*/
	updateQuantity : function(newQuantity) {
		
		if (!(typeof(newQuantity) == 'number' ||  newQuantity.match(/^\d+$/))) {
			this.quantityBox.value = this.oldQuantity;
		} else if (newQuantity == 0) {
            this.cart.touch();
			this.remove();
		} else if (this.product.quantity != newQuantity) {
			this.cart.touch();
            
			// Update the underlying object
			this.product.quantity = this.cart.products[this.product.id].quantity = newQuantity;								
			if (this.cart.options.showPrices) {
				this.updatePrice();
			}
			this.cart.fire(MyUnisource.MiniCart.Event.TOTAL_CHANGED);
			
			this.cart.quantitiesModified = true;
			this.cart.updatedQuantities.push(this.product.id);
		}
	},
	/**
	* Updates the display of the price for this product
	*/
	updatePrice : function() {
        // Calculate the delta to update the total
        var newPrice = this.productPrice.getPriceAt(this.product.quantity);		
        var delta;
		        
        if (this.oldPrice !== null) {
	        delta = newPrice.total - this.oldPrice.total;
        } else {
	        delta = newPrice.total;
        }

        // Update the total row in the cart
        this.cart.total += delta;

        this.totalNode.data =
	        this.getDisplayTotal(newPrice);	
	        
        this.oldPrice = newPrice;
        this.oldQuantity = this.product.quantity;
	},
	
	/**
	* Makes this row visible in the user's browser
	*/
	show : function() {
		$(this.row).show();
	},
	
	/**
	* Hides this row in the user's browser
	*/
	hide : function() {
		$(this.row).hide();
	},
	
	/**
	* Sets the tab index on the quantity field to the specified
	* value
	*
	* @param int index the new index
	*/
	setTabIndex : function(index) {
		this.quantityBox.tabIndex = index;
	},
	
	
	/**
	* Focuses on the quantity box
	*/
	focus : function() {
		var quantityBox = this.quantityBox;
		var focusLambda = function() {
			quantityBox.focus();
		}
		focusLambda.defer(1);
	},	
	
	/**
	* Attempt to focus on the next available row in the correct
	* listing order. If no such row is available, the previous one
	* will be selected unless this method is called on the only row
	* in the cart
	*/
	focusOnNext : function() {
		if (this.cart.rows.length > 1) {
			var myIndex = this.cart.rows.indexOf(this);
			if (myIndex != -1) {
				var end = this.cart.rows.length - 1;
				var focusRow;
				
				if (myIndex < end) {
					focusRow = this.cart.rows[myIndex + 1];	
				} else if (myIndex > 0) {
					focusRow = this.cart.rows[myIndex - 1];
				}
				
				if (focusRow) {
					focusRow.focus();			
				}
			}
		}
	}
}

/**
* Represents a listing mode
*
*/
MyUnisource.MiniCart.ListingMode = Class.create();
MyUnisource.MiniCart.ListingMode.prototype = {
	/**
	* A reference to a mini-cart
	*
	* @var MyUnisource.MiniCart
	* @access protected
	*/
	cart : null,

	
	/**
	* Creates a new instance of this listing mode
	*/
	initialize : function() {
	},
	
	/**
	* Sets up the listing mode, registering
	* all relevant event handlers
	*/
	setup : function(cart) {
		this.cart = cart;
	},
	
	
	/**
	* Sets the new display range
	*/
	setRange: function(rangeFrom, rangeTo) {
		var newRange = {
			from: rangeFrom,
			to: rangeTo
		};
		
		this.cart.displayRange = newRange;
		this.cart.fire(MyUnisource.MiniCart.Event.DISPLAY_RANGE_CHANGED);
	}
	
};

MyUnisource.MiniCart.DisplayAllListingMode = Class.create(
    MyUnisource.MiniCart.ListingMode,
    {
        /**
        * Creates a new Display All listing mode
        * instance
        */
        initialize : function() {
            new EventHandler(this);
            
        },
        
        /**
        * Configures the listing mode instance
        *
        * @param MyUnisource.MiniCart cart a cart instance
        */
        setup : function($super, cart) {        
            $super(cart);
            this.toggleElement = $(this.cart.id + '-more-less-toggle')            
            this.labelElement = $(this.cart.id + '-more-less-toggle-label')            
            
            this.cart.displayInfoElement.hide();
            var toggleElement = $(this.cart.id + '-more-less-toggle')            
            toggleElement.hide();
            
            this.setRange(1, this.cart.productCount);
            
            this.observe(
                MyUnisource.MiniCart.Event.PRODUCT_COUNT_CHANGED,
                function() {
                    this.setRange(1, this.cart.productCount);                    
                }.bind(this)
            );
            
        }        
    }
);

MyUnisource.MiniCart.MoreLessListingMode = Class.create(
	MyUnisource.MiniCart.ListingMode,
	{
		/**
		* The number of products to display in the Collapsed state
		*
		* @var Integer
		*/
		collapsedProductCount : 5,
		
		/**
		* The element (usually a link) used to
		* toggle the display mode
		*
		* @var HTMLElement		
		*/
		toggleElement : null,
		
		/**
		* The element with the text label (usually a span tag)
		*
		* @var HTMLElement
		*/
		labelElement: null,
		
		text : {},
		
		state : 'collapsed',
		
		/**
		* Creates a new More/Less listing mode
		* instance
		*
		* @param MyUnisource.MiniCart a mini-cart 
		*/
		initialize : function(collapsedProductCount) {
			this.text = MyUnisource.MiniCart.MoreLessListingMode.Text;
			if (collapsedProductCount) {
				this.collapsedProductCount = collapsedProductCount;
			}
			new EventHandler(this);
			
		},
		
		setup : function($super, cart) {		
			$super(cart);
			this.toggleElement = $(this.cart.id + '-more-less-toggle')			
			this.labelElement = $(this.cart.id + '-more-less-toggle-label')			
			Event.observe(
				this.toggleElement,
				'click',
				function(e) {
					Event.stop(e);
					this.toggle();
				}.bindAsEventListener(this)
			);
			
			this.observe(
				MyUnisource.MiniCart.Event.PRODUCT_COUNT_CHANGED,
				this.checkProductCount.bind(this)
			);
			
			this.collapse();
			this.checkProductCount();
		},
				
		                      
		/**
		* Displays all products 
		*/
		expand : function() {
			this.state = 'expanded';
			this.updateLabel();
			this.setRange(1, this.cart.productCount);			
		},
		
		
		/**
		* Displays a subset of products
		*/
		collapse : function() {
			this.state = 'collapsed';
			this.updateLabel();
			this.setRange(1, this.collapsedProductCount);			
		},
		
		/**
		* Updates the text label, depending on the current state
		*/
		updateLabel: function() {    
			var rawText = this.text[this.state];
			var text;
			switch(this.state) {
				case 'expanded':
					text = '&laquo; ' + rawText;
					break;
				case 'collapsed':
					text = rawText + ' &raquo;'
					break;
			}
			this.labelElement.update(text);
		},
		
		/**
		* Collapses the list if it is expanded
		* and vice versa
		*/
		toggle : function() {
			switch(this.state) {
				case 'collapsed':
					this.expand();
					break;
				case 'expanded':
					this.collapse();
					break;
			}
		},
		
		checkProductCount : function() {
			if (this.cart.rows.length > this.collapsedProductCount) {
				this.toggleElement.show();
				this.cart.displayInfoElement.show();
			} else {
				this.toggleElement.hide();
				this.cart.displayInfoElement.hide();
			}
		}
	}
);

MyUnisource.MiniCart.MoreLessListingMode.Text = 
{
	expanded : 'Less',
	collapsed : 'More'
}



/*** /unisource/myunisource/pricing.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.
 */
 
MyUnisource.ProductPrice = Class.create();
MyUnisource.ProductPrice.prototype = {
	
};

MyUnisource.PriceBracket = Class.create();
MyUnisource.PriceBracket.prototype = {
	
	/**
	* The minimum quantity at which this bracket applies
	*
	* @var Integer
	*/
	minimumQuantity : 0,
	
	/**
	* The price in this bracket per priceQuantity units
	*
	* @var Number
	*/
	price: 0.0,
	
	/**
	* The number of units for which the price is specified
	*
	* @var Number
	*/
	priceQuantity : 0.0,
	
	/**
	* The unit of measure for the
	* price and for the quantity
	*/
	unitOfMeasure : {
		price: 'UN',
		quantity: 'UN'
	},
	
	/**
	* A reference to the productPrice instance to which this
	* bracket belongs - used for unit conversions
	*
	* @var MyUnisource.ProductPrice
	*/
	productPrice : null,
	

	/**
	* Creates a new price bracket
	*
	* @param object bracketDetails an object with the following keys:
	*
	* 'minimum_quantity' the minimum quantity for this price bracket
	* 'price'            the bracket price
	* 'price_quantity'   the quantity for which the price is specified
	* 'uom'              {price: [price UOM], quantity : [quantity UOM]}
	* 
	*/
	initialize: function(productPrice, bracketDetails) {
		this.productPrice = productPrice;
		
		if (bracketDetails['minimum_quantity']) {
			this.minimumQuantity = Number(bracketDetails['minimum_quantity']);
		}
		if (bracketDetails['price']) {
			this.price = Number(bracketDetails['price']);
		}

		if (bracketDetails['price_quantity']) {
			this.priceQuantity = Number(bracketDetails['price_quantity']);
		}
		
		if (bracketDetails['uom']) {
			this.unitOfMeasure = bracketDetails['uom'];
		}		
	},
	
	/**
	* Determines if this bracket meets the minimum
	* quantity requirements at the specified price and
	* Unit of Measure
	*
	* @param Integer quantity 		the number of unitOfMeasure units being purchased
	* @param String  unitOfMeasure  the unit to use
	*
	* @return Boolean
	*/
	isApplicable : function(quantity, unitOfMeasure) {
		var bracketQuantity = this.productPrice.convertQuantity(
			this.minimumQuantity,
			this.unitOfMeasure.quantity,
			unitOfMeasure
		);
		
		return Number(quantity) >= bracketQuantity;
	},
	/**
	* Calculates the price per specified unit
	* 
	* @param String unitOfMeasure the target unit of measure
	*/
	getUnitPrice : function(unitOfMeasure) {
		var numberOfTargetUnits = this.productPrice.convertQuantity(
			this.priceQuantity,
			this.unitOfMeasure.price,
			unitOfMeasure
		);
		
		return this.price / numberOfTargetUnits;
	}
};

MyUnisource.Packs = {
	1: {
		code : 'M',
		quantity: 1000
	},
	2 : {
		code : 'C',
		quantity : 100
	},
	3 : {
		code : 'U',
		quantity : 1
	},
	4 : {
		code : 'W',
		quantity: 100,
		unit: 'LB'
	}
}


MyUnisource.ProductPrice = Class.create();

/**
* Represents the pricing scheme for a product - with
* effective brackets and product conversions
*/
MyUnisource.ProductPrice.prototype = {
	/**
	* The default unit of measure used for this
	* product
	* 
	* @var 	String
	*/
	stockUnitOfMeasure : 'UN',
	
	/**
	* The pack sizes to be used
	*
	* @var Object
	*/
	packSizes : {},
	
	/**
	* PriceBracket objects representing the available
	* price breaks
	*
	* @var Array
	*/
	brackets : [],
	
	/**
	* The default unit of measure used for quantities
	*
	* @var String
	*/
	unitOfMeasure: null,
	
	
	/**
	* Creates a new product price from a JSON-style
	* object
	*
	* @param price the price to parse.
	*/
	initialize : function(price) {
		this.brackets = [];
		this.stockUnitOfMeasure = price.uom.stock;
		this.known = price.known;
		
		$H(price.packs).each(
			function(entry) {
				this.packSizes[entry.value.uom] = Number(entry.value.quantity);
			}.bind(this)
		);
		
		if (price.weight && price.weight_pack_id) {
			var packQuantity;
			if (MyUnisource.Packs[price.weight_pack_id]) {
				 packQuantity = MyUnisource.Packs[parseInt(price.weight_pack_id)].quantity; // pounds per unit
			} else {
				packQuantity = 1;
			}
			
			// [packQuantity] sheets = [weight] LB
			// X sheets = 1 LB
			// X = 1 * packQuantity / weight
			this.packSizes['LB'] = packQuantity / price.weight;
		}
		
		if (price.known && price.breaks) {
			$A(price.breaks).each(
				function(priceBreak) {
					this.brackets.push(
						new MyUnisource.PriceBracket(this, priceBreak)
					);
				}.bind(this)		
			);
		}
		
		if (price.uom.order) {
			this.unitOfMeasure = price.uom.order;
		}
	},

	/**
	* Computes the price bracket at the specified
	* quantity
	*
	* @param Integer quantity 		the quantity of the product being ordered
	* @param String  unitOfMeasure  the target unit of measure 
	*/
	getPriceBracketAt : function(quantity, unitOfMeasure) {        
		var effectiveBracket;
		
		if (this.known) {
			if (!unitOfMeasure) {
				unitOfMeasure = this.unitOfMeasure;
			}
			effectiveBracket = this.findBracket(quantity, unitOfMeasure);
			
			if (effectiveBracket === null) {
				effectiveBracket = this.brackets[0];
			}
		} else {
			effectiveBracket = null;
		}
		
		return effectiveBracket;
	},
	/**
	* Attempts to find a bracket that applies to a specific
	* quantity
	*/
	findBracket : function(quantity, unitOfMeasure) {
		var effectiveBracket = Lambda.last(
			this.brackets,
			function(bracket) {
				return bracket.isApplicable(
					quantity, 
					unitOfMeasure
				);
			}
		);	
		return effectiveBracket;
	},
	
	/**
	* Returns the price at the specified quantity, as an
	* object:
	*
	* {
	*    unit:     the unit price
	*    total:    the line total (quantity * unit price),
	* 	 bracket:  the price bracket being used
	* }
	*/
	getPriceAt : function(quantity, unitOfMeasure) {
		if (!unitOfMeasure) {
			unitOfMeasure = this.unitOfMeasure;
		}
		
		var effectiveBracket = this.getPriceBracketAt(quantity, unitOfMeasure);
		
		var price;

		if (effectiveBracket === null) {	
			price = {
				unit: null,
				total: 0,
				bracket: null
			}
		} else {
			var unitPrice = effectiveBracket.getUnitPrice(unitOfMeasure);
			
			price = {
				unit: unitPrice,
				total: unitPrice * quantity,
				bracket : effectiveBracket
			};       		
		}
		return price;
	},
	
	/**
	* Returns the number of Stock UOMs per specified unit
	*
	* @param unitOfMeasure the unit of measure for which the
	*		conversion factor will be obtained
	*/
	getConversionFactor : function(unitOfMeasure) {	
		var conversionFactor = NaN;
		
		if (unitOfMeasure == this.stockUnitOfMeasure) {
			conversionFactor = 1.0;	
		} else if (this.packSizes[unitOfMeasure]) {
			conversionFactor = this.packSizes[unitOfMeasure];
		}
		
		return conversionFactor;
	},
	
	
	/**
	* Performs a quantity conversion using pack sizes
	*
	* @param Integer quantity 	   		  the quantity to convert
	* @param String  unitOfMeasure 		  the original Unit of Measure
	* @param String  targetUnitOfMeasure  the unit of measure at which the
	* 									  conversion is being made
	*
	* @return Number
	*/
	convertQuantity : function(quantity, unitOfMeasure, targetUnitOfMeasure) {
		var targetQuantity;
		
		if (unitOfMeasure == targetUnitOfMeasure) {
			targetQuantity = quantity;
		} else {
			targetQuantity = 
				quantity 
				*
				this.getConversionFactor(unitOfMeasure) 
				/ 
				this.getConversionFactor(targetUnitOfMeasure);
		}
		
		return targetQuantity;
	}
	
}


/*** /unisource/myunisource/cell_switch.js **********************************/


MyUnisource.CellSwitch = Class.create(
    {
        initialize : function(id, options) {
            this.id = id;
            this.options = options || {};

            this.searchForm = $(this.id + '-search-form');
            this.cellTree = $(this.id + '-tree').tree;
            this.emptyContainer = $(this.id + '-no-match-found');
            this.characterLimitContainer = $(this.id + '-character-limit');
            
            this.resultMessageContainer = $(this.id + '-result-message');
            this.resultMessageTemplate = this.resultMessageContainer.innerHTML;
            
            this.attachEvents();                    
                    
        },
        
        attachEvents: function() {
            Event.observe(
                this.searchForm,
                'submit',
                function(e) {
                    Event.stop(e);                    
                    this.search();            
                }.bindAsEventListener(this)
            );
            
            this.cellTree.observe(
                DynamicPaginator.Event.LOADED,
                function() {
                    if (this.cellTree.isEmpty()) {
                        this.emptyContainer.show();                        
                    } else {
                        this.emptyContainer.hide();                        
                    }
                }.bind(this)
            );
        },
        
        search : function() {
            var keywords = this.searchForm.elements['data[Search][keywords]'].value;

            if (this.options.minimumCharacters && keywords.length < this.options.minimumCharacters) {
                this.characterLimitContainer.show();
            } else {
                
                this.characterLimitContainer.hide();
                var message = this.resultMessageTemplate.replace('%keywords%', keywords);
                this.resultMessageContainer.update( message );
                this.resultMessageContainer.show();
                
                this.cellTree.fetch(
                    {
                        action : Paths.www + '/myunisource/uni_cells/search/' + encodeURIComponent(keywords),
                        count : Paths.www + '/myunisource/uni_cells/countSearch/' + encodeURIComponent(keywords),
                        recount : true                    
                    }
                );             
            }
        }
    }
);


/*** /unisource/listing.js **********************************/


Listing = Class.create();

new EventHandler(Listing);

Listing.Event = {
    CREATED : 'created',
    PAGE_CHANGING : 'page-changing',
    PAGE_CHANGED : 'page-changed',
    SORTING : 'sorting',
    SORTED : 'sorted',
    MASTER_TOGGLING : 'master-toggling',
    MASTER_TOGGLED : 'master-toggled'
};

Listing.prototype = {
    sortAction : null,    
    pageAction : null,    
    updateElement : null,
    /**
     * List of listing options used in the displaying
     * of the listing.
     */
    options: {},
    /**
     * Default constructor
     */
    initialize: function(id, itemIds) 
    {
        this.id = id;
        if (itemIds) {
            this.itemIds = itemIds;
        } else {
            this.itemIds = [];
        }
        new EventHandler(this);
        
        var masterCheckbox = $(this.id + '-master-checkbox');
        if (masterCheckbox) {
        	Event.observe(
				masterCheckbox,
				'click',
				function(e) {
					this.fire(Listing.Event.MASTER_TOGGLING);
					var checkbox = Event.element(e);                    
					if (checkbox.checked) {
						this.selectAll();
					} else {
						this.deselectAll();
					}
					this.fire(Listing.Event.MASTER_TOGGLED);
				}.bindAsEventListener(this)
			);
		}
        
        this.options = {
            // Indicates whether the property checkbox-enabled is true.
            checkboxEnabled: null,
            // Indicates whether this is an alternative listing
            alternatives: null,
            // Indicates an action to take
            action: null
        }
        Listing.fire(Listing.Event.CREATED, this);
    },

    
    actionTypes: {
        regular : function() {return true;},
        'refresh-listing' : function(e, url) {
            this.onRefresh(url);
            if (e) {
                Event.stop(e);
            }
        },
        'refresh-listing-confirm' : function() {return false;}
    },
    
    onRefresh : Prototype.emptyFunction,

    registerActions : function(actions) {    
        $A(this.itemIds).each(
            function(itemId) {
                $A(actions).each(
                    function(action) {        
                        var type = (action.type) ? action.type : 'regular';
                        var link = $(this.id + '-item-' + itemId + '-action-' + action.id + '-link');
                        Event.observe(
                            link,
                            'click',
                            this.actionTypes[type].bindAsEventListener(this, link.href)
                        );
                    }.bind(this)
                );
            }.bind(this)
        );
    },
    
    confirmAction : function(actionId, itemId) {
        var link = $(actionId + '-link');
        this.onRefresh(link.href);
    },
    
    getPageUrl : function(page) {                                           
        return this.appendParams(
            Paths.www
            + this.pageAction
            + '/'
            + page
        );
    },
    
    /**
    * Determines whether the listing is empty
    *
    * @return Boolean
    * @access public
    */
    isEmpty : function() {
        return this.itemIds.length == 0;
    },
    
    getSortUrl: function(column, direction, page) {
        return this.appendParams(
            Paths.www
            + this.sortAction
            + '/'
            + column
            + '/'
            + direction
            + '/'
            + (page ? page : '')
        );
    },
    
    /**
     * Appends parameters to the given URL
     * 
     * E.g.
     *  http://unisource.ca/uni_products/sort/format/asc
     *  // becomes ...
     *  http://unisource.ca/uni_products/sort/format/asc?listing[ch]=true&listing[sc]=true
     *
     * @access public
     * @return string 
     */
    appendParams: function (path) {
        var params = [];
        var append = function (list, name, param) {
            if (param != null) {
                var value = (typeof param == 'boolean') ? 
                      (param ? 'true' : 'false')
                    : (escape(param));
                list[list.length] = name + '=' + value;
            }
        }
        append(params, 'listing[checkbox_enabled]', this.options.checkboxEnabled);
        append(params, 'listing[alternatives]',     this.options.alternatives);
        append(params, 'listing[action]',           this.options.action);
        
        if (this.options.source) {
            append(params, 'source', this.options.source);
        }
        
        if (params.length > 0) {
            path += (path.indexOf('?') != -1) ? '&' : '?';
            path += params.join('&');
        }
        return path;
    },
        
    invokeAction : function(url, startEvent, endEvent) {
        if (startEvent) {
            this.fire(startEvent);
        }
        
        if (this.updateElement) {
            if (typeof this.updateRequest != 'undefined') {                  
                delete this.updateRequest;
            }
            this.updateRequest = new Ajax.Updater(
                $(this.updateElement),
                url, 
                {
                    evalScripts: true,
                    
                    onComplete : function() {
                        if (endEvent) {
                            this.fire(endEvent);
                        }
                        
                        this.clearEvents();                        
                    }.bind(this)
                }
            );
            
        } else {
            location.href = url;
        }
    },
    
    /**
    * For listings with checkboxes, checks off the checkboxes
    * for all items.
    */
    selectAll : function() {
        var checkboxes = this.getAllCheckboxes();
        
        $A(checkboxes).each(
            function(checkbox) {
                if (checkbox) {
            	    checkbox.checked = true;
                }
            }.bind(this)
        );
    },
    
    /**
    * For listings with checkboxes, unchecks the checkboxes
    * for all items.
    */
    deselectAll : function() {
        var checkboxes = this.getAllCheckboxes();
        
        $A(checkboxes).each(
            function(checkbox) {
                if (checkbox) {
            	    checkbox.checked = false;
                }
            }.bind(this)
        );
	},
	
		    
    
    
    /**
    * Returns the checkbox for the specified item, if
    * available. If there are no checkboxes, or the item
    * is not on the list, null is returned
    *
    * @param Integer itemId the ID of the item
    */
    getCheckbox : function(itemId) {
    	return $(this.id + '-checkbox-' + itemId);
	},
	
	/**
	* Determines if the checkbox for the specified item
	* has been checked
	*
    * @param Integer itemId the ID of the item	
	*/
	isSelected : function(itemId) {
		var result = false;
		var checkbox = this.getCheckbox(itemId);
		if (checkbox) {
			result = checkbox.checked;
		}
		return result;
	},
	
	/**
	* Returns all checkboxes present in this listing, if any
	*
	* @return Array
	*/
	getAllCheckboxes : function() {
		if (!this.checkboxes) {
			this.checkboxes = [];
			
			$A(this.itemIds).each(
				function(itemId) {
				    this.checkboxes.push(this.getCheckbox(itemId));
				}.bind(this)
			);
		}
		
		return this.checkboxes;
	},
	
    
        
    /**
    * Navigates to the specified page
    *
    * @param Integer page the page number
    */
    goToPage: function(page) {        
        this.invokeAction(
            this.getPageUrl(page),
            Listing.Event.PAGE_CHANGING,
            Listing.Event.PAGE_CHANGED
        );
    },
    
    /**
    * Sorts the listing according to the specified
    * sorting criteria
    *
    * @param String column 	the column to sort by
    * @param String direction the sort direction ('ASC' or 'DESC')
    * @param int 	page      the page number
    */
    sort : function (column, direction, page) {        
        this.invokeAction(
            this.getSortUrl(column, direction, page),
            Listing.Event.SORTING,
            Listing.Event.SORTED
        );
    }
}


/*** /unisource/tabs.js **********************************/


Tabs = Class.create();

Tabs.prototype = {
    
    initialize: function(id, selectedIndex) {
        this.id = id;     
        $(this.id + '-content').tabs = this;     
        if (selectedIndex) {
            this.select(selectedIndex);
        }
        // Adds each tab to this instance
        this.tabs = new Array();
        var tab   = null;
        for(var i = 1; tab = $(this.id + '-' + i + '-link'); i++) { 
            tab.tabIndex = i;
            this.tabs.push(tab);
        }
        // Must be called after the tabs were added
        this.attachEvents();
        
        if (!selectedIndex) {
        	this.select(1);
        } else {
            this.select(selectedIndex);
        }
        // Adds itself to the stack
        TabsStack.push(this);
    },
    
    attachEvents : function() {
        for(var i=1;$(this.id + '-' + i + '-link');i++) {
        
            // tab references to this class
            var tab  = $(this.id + '-' + i + '-link');
            tab.tabs = this; 

            Event.observe(
                tab,
                'click',
                function(e, index) {
                    this.select(index);
                }.bindAsEventListener(this, i)
            );      
            Highlight.enable($(this.id + '-' + i + '-link'));                      
            
            Event.observe(window, 'load', 
                function(i) {
                    Highlight.enable($(this.id + '-' + i + '-link'));                               
                }.bindAsEventListener(this, i)
            );
        }
    },
    
    /**
     * Attaches an event to each tab in this object.
     *
     * The callback is called whenever the event is
     * clicked. The passed parameters are the event 
     * object and the index of the tab.
     *
     * @access public
     * @param String event The name of the event
     * @param Function callback The function called after the event is called
     */
    addTabEvent: function (event, callback) {
        for (var i = 0, c = this.tabs.length; i < c; i++) {
            Event.observe(this.tabs[i], event, function (event) {
                callback(event, this.tabIndex);
            }.bindAsEventListener(this.tabs[i]));
        }
    },
    
    select: function(index) {
        var tab = $(this.id + '-' + index + '-link');
        if (!tab) {
            return;
        }
        Highlight.enable(tab);

        if (this.selected) {
            this.selected.hide();
            var selectedTab = $(this.id + '-' + this.selectedIndex + '-link');
            Highlight.enable(selectedTab);
            selectedTab.__highlight.unfreeze();
            selectedTab.__highlight.setEnabled(false);
        }
        
        this.selected = $(this.id + '-content-' + index);
        this.selectedIndex = index;
        
        if (!this.selected) {
            return;
        }
        
        this.selected.show();
        tab.__highlight.unfreeze();
        tab.__highlight.setEnabled(true);
        tab.__highlight.freeze();
        
    }
}

/**
 * Tab stack. Used whenever another developer
 * is not passing a reference to tabs. :)
 *
 * @author Dimitry Zolotaryov
 */
var TabsStack = {
    tabs: null
};

/**
 * Adds a Tabs object to the stack
 *
 * @param Tabs tabs The tabs object
 */
TabsStack.push = function (tabs) {
    this.tabs = new Array();
    TabsStack.push = function (tabs) {
        this.tabs.push(tabs);
    }
    TabsStack.first = function () {
        return this.tabs[0];
    }
    return TabsStack.push(tabs);
}

/**
 * Returns the first element of the stack
 *
 * @return Tabs The first Tabs instance
 */
TabsStack.first = function () {
    // Initialized by TabsStack.push
    return null;
}