/*******************************
*
* dhtml_utils.js
* 
* Dhtml Classes Library 
* Utilizes prototypejs framework http://www.prototypejs.org/ -- prototype.js version 1.5.1.1
* Utilizes script.aculo.us Copyright (c) 2005-2007 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us) -- scriptaculous.js version 1.7.1_beta3
*
*
*
* Author: John Hutcheson, control.option
* Version: 1
* 
*
*******************************/

/* BrowserDetect Object */
var BrowserDetect = {
	isWin: (navigator.platform=="Win32") ? true : false,
	isMac: (navigator.platform=="MacPPC") ? true : false,
	isCSS: (document.body && document.body.style) ? true : false,
	isW3C: (this.isCSS && document.getElementById) ? true : false,
	isIE: (navigator.appVersion.indexOf("MSIE") != -1) ? true : false,
	isIE6CSS: (document.compatMode && document.compatMode.indexOf("CSS1") >= 0) ? true : false,
	isIE7: (document.documentElement && typeof document.documentElement.style.maxHeight!="undefined" && document.all) ? true : false,
	isIE6: (document.compatMode && document.compatMode.indexOf("CSS1") >= 0 && navigator.appVersion.indexOf("MSIE") != -1 && ! (document.documentElement && typeof document.documentElement.style.maxHeight!="undefined" && document.all)) ? true : false
};
/* BrowserDetect Object Ends */

/* ElementExtension Class */
var ElementExtension = Class.create();

ElementExtension.prototype = {
	
	initialize: function() { 
		this.browserDetect = BrowserDetect;
		this.checkBrowser = this._browser.bind(this);
	},
	
	
	_browser: function(element) { 
		var element = $(element);
		return this.browserDetect;
	},
	
	// Set the visibility of an object to visible
	setVisible: function(element) {
		var element = $(element).style;
		if (element) {
			element.visibility = "visible";
		}
	},
	
	// Set the visibility of an object to hidden
	setHidden: function(element) {
		var element = $(element).style;
		if (element) {
			element.visibility = "hidden";
		}
	},
	
	setBgTransPng: function(element) {
		var element = $(element);
		var cb = element.checkBrowser();
		if (cb.isIE && cb.isIE6CSS && ! cb.isIE7) {
			var elBg = element.getStyle('background-image');
			if (elBg.indexOf('url(') != -1) {
				if (elBg.toUpperCase().indexOf('.PNG') == -1) {
					return;
				}
				
				element.setStyle({backgroundImage: 'none'});
				
				var imgSrc = elBg.replace('url(', '');
				imgSrc = (imgSrc.indexOf('.PNG') == -1) ? imgSrc.replace('.png)', '.png') : imgSrc.replace('.PNG)', '.PNG');
															   
				element.style.filter = "progid:DXImageTransform.Microsoft.AlphaImageLoader(src=" + imgSrc + ", sizingMethod='scale')";
			}
		}
	}
};
/* ElementExtension Class Ends */


/* UtilityMethods Object */
var UtilityMethods = {

	getQueryString: function () {
		var queryString = location.search.substring(1);
		return queryString;
	},
	
	getQueryArgs: function() {
		var args = $H(new Object());
		var query = this.getQueryString();
		var pairs = $A(query.split("&"));
		
		pairs.each(function (pair) {
			var eqPos = pair.indexOf("=");
			var argName = pair.substring(0, eqPos);
			var value = pair.substring(eqPos + 1);
			value = decodeURIComponent(value);
			args[argName] = value;
		});
		
		return args;
		
	},
	
	getQueryArgValue: function (argName) {
		var args = this.getQueryArgs();
		return args[argName];
	},
	
	checkBrowser: function() {
		return BrowserDetect;
	}
};
/* UtilityMethods Class Ends */

/* ImageRollover Class */
var ImageRollover = Class.create();

ImageRollover.prototype = {
	
	/* 
	* arg: offIndicator - optional. If supplied use instead of _off as the off state indicator in image src.
	* arg: overIndicator - optional. If supplied use instead of _over as the over state indicator in image src.
	* imagesOff - Object - hash of image id and image src for the off state
	* imagesOver - Object - hash of image id and image src for the over state
	*/
	initialize: function(offIndicator, overIndicator, onIndicator) { 
		this.offIndicator = offIndicator ? offIndicator + '.' : '_off.';
		this.overIndicator = overIndicator ? overIndicator + '.' : '_over.';
		this.onIndicator = onIndicator ? onIndicator + '.' : '_on.';
		if (document.images) {
			// Images Off Object Constructor
			this.offImages = new Object();
			
			// Images Over Object Object Constructor
			this.overImages = new Object();
			
			//Vars for binding the over and out calls as event listeners
			this.boundOver = this.over.bindAsEventListener(this);
			this.boundOut = this.out.bindAsEventListener(this);
			Event.observe (document, 'mouseover', this.boundOver);
			Event.observe (document, 'mouseout', this.boundOut);
		}
	},
	
	// Image pre-caching method
	// adds images to the imagesOff and imagesOver hashes for precaching and over and out methods.
	addItem: function(el) {
		if (!el.src) {
			return false;
		}
		var elem = $(el);
		var imgId = elem.id;
		var dimensions = elem.getDimensions();
		var imgWidth = dimensions.width;
		var imgHeight = dimensions.height;
		if (this.offImages && this.overImages) {
			if (this.offImages[imgId] && this.overImages[imgId]) {
				return true;
			} else {
				var srcStringOff = elem.src;
				var srcStringOver;
				if (srcStringOff.include(this.overIndicator)) {
					srcStringOver = srcStringOff;
				} else if (srcStringOff.include(this.onIndicator)) {
					srcStringOver = srcStringOff.replace(this.onIndicator, this.overIndicator);
				} else {
					srcStringOver = srcStringOff.replace(this.offIndicator, this.overIndicator);
				}
				
				this.offImages[imgId] = new Image(imgWidth, imgHeight);
				this.offImages[imgId].src = srcStringOff;
				this.overImages[imgId] = new Image(imgWidth, imgHeight);
				this.overImages[imgId].src = srcStringOver;
				
				return true;
			}
		}
		return false;
	},
	
	// Image rollover removal method
	// removes images from the imagesOff and imagesOver hashes.
	removeItem: function(el) {
		if (!el.src) {
			return false;
		}
		var imgId = el.id;
		
		if (this.offImages && this.overImages) {
			if (!this.offImages[imgId] && !this.overImages[imgId]) {
				return false;
			} else {
				delete this.offImages[imgId];
				delete this.overImages[imgId];
				
				return true;
			}
		}
		return false;
	},
	
	// Image Swap - set to over state
	over: function(e, elementId) {
		if (e != null) {
			var elt = $(Event.element(e));
			if (elt.hasClassName("rollover") && this.overImages[elt.id]) {
				Event.stop(e);
				elt.src  = this.overImages[elt.id].src;
			}
		} else {
			if (!elementId) {
				return;
			}
			$(elementId).src = this.overImages[elementId].src;
		}
	},
	// Image Swap - set to off state
	out: function(e, elementId) {
		if (e != null) {
			var elt = $(Event.element(e));
			if (elt.hasClassName("rollover") && this.offImages[elt.id]) {
				Event.stop(e);
				elt.src  = this.offImages[elt.id].src;
			}
		} else {
			if (!elementId) {
				return;
			}
			$(elementId).src = this.offImages[elementId].src;
		}
	}
};
/* ImageRollover Class Ends */

/* CSS Class Swapping Class */
var CSSRollover = Class.create ();

CSSRollover.prototype = {
	initialize: function (indicatorClass, mouseOverClass, mouseDisabledClass) {
		this.indClass = indicatorClass;
		this.overClass = mouseOverClass;
		this.disClass = mouseDisabledClass;
		this.defaultDisClass = "disabled";
		this.boundOver = this.over.bindAsEventListener(this);
		this.boundOut = this.out.bindAsEventListener(this);
		Event.observe (document, 'mouseover', this.boundOver);
		Event.observe (document, 'mouseout', this.boundOut);
	},
	
	addItem: function (el) {},
	
	over: function(e, elementId) {
		if (e)  {
			var elem = $(Event.element(e)) || $(elementId);
			if (elem.hasClassName(this.indClass) &! elem.hasClassName(this.disClass) &! elem.hasClassName(this.defaultDisClass)) {
				Event.stop(e);
				elem.addClassName(this.overClass);
			}
		} else {
			if (!elementId) return;
			$(elementId).addClassName(this.overClass);
		}
	},
	// Image Swap - set to off state
	out: function(e, elementId)  {
		if (e)  {
			var elem = $(Event.element(e)) || $(elementId);
			if (elem.hasClassName(this.indClass) &! elem.hasClassName(this.disClass) &! elem.hasClassName(this.defaultDisClass)) {
				Event.stop(e);
				elem.removeClassName(this.overClass);
			}
		} else {
			if (!elementId) return;
			$(elementId).removeClassName(this.overClass);
		}
	}
}
/* CSS Class Swapping Class Ends */


/* Menus Class */
var Menus = Class.create();

Menus.prototype = {
	
	initialize: function(args) {
		if (!document.images) return;
		if (!args.indicatorClass) return;
		this.indClass = args.indicatorClass;
		this.disClass = args.disabledClass;
		this.trigClass = args.triggerClass;
		this.menuClass = args.menuClass;
		this.rollover = args.rolloverObj;
		this.menus = $A([]);
		this.menusHash = {};
		var boundOver = this.over.bindAsEventListener(this);
		var boundOut = this.out.bindAsEventListener(this);
		Event.observe (document, 'mouseover', boundOver);
		Event.observe (document, 'mouseout', boundOut);
	},
	
	addItem: function(menuObj) {
		
		var myTrigger = $(menuObj.trigger).addClassName(this.indClass).addClassName(this.trigClass), myMenu = $(menuObj.menu).addClassName(this.indClass).addClassName(this.menuClass), mChildren = myMenu.descendants();
		
		if (mChildren.length > 0) {
            var mIndx = mChildren.length;
            while (--mIndx >= 0)
            {
            	if (mChildren[mIndx].addClassName){
                    mChildren[mIndx].addClassName(this.indClass).addClassName(this.menuClass);
                }
            }
		}
		
		if (this.rollover) this.rollover.addItem(myTrigger);
        
		this.menus.push({trigger:myTrigger, menu:myMenu});
        this.menusHash[myTrigger.id] = this.menus.length - 1;
	},
	
	over: function (e) {
		var elt = $(Event.element(e));
		if (elt.hasClassName(this.indClass) &! elt.hasClassName(this.disClass)) {
			Event.stop(e);
			if (elt.hasClassName(this.trigClass)) {
				this.showMenu (elt);
			} else if (elt.hasClassName(this.menuClass)) {
				this.keepMenu();
			}
		}
	},
	
	out: function (e) {
		var elt = $(Event.element(e));
		if (elt.hasClassName(this.indClass) &! elt.hasClassName(this.disClass)) {
			Event.stop(e);
			this.requestHide();
		}
	},
	
	requestHide: function() {
		var boundHide = this.hideMenus.bind(this);
		this.timer = setTimeout(boundHide, 80);
	},
	
	hideMenus: function() {
		var indx = this.menus.length;
		while (--indx >= 0) {
			if (this.rollover) this.rollover.out(null, this.menus[indx].trigger.id);
			var myMenu = this.menus[indx].menu;
			if (this.disClass && myMenu.hasClassName(this.disClass)) continue;
			this.hideElement(myMenu);
		}
	},
	
	showMenu: function(element) {
		this.keepMenu();
		this.hideMenus();
		if (this.rollover) this.rollover.over(null, element.id);
		var myMenu = this.menus[this.menusHash[element.id]].menu;
		if (this.disClass && myMenu.hasClassName(this.disClass)) return;
		this.showElement(myMenu)
	},
	
	
	
	hideElement: function (element) {
		element.setHidden();
	},
	
	showElement: function (element) {
		element.setVisible();
	},
	
	keepMenu: function () {
		clearTimeout(this.timer);
	}
};
/* Menus Class Ends */

/* IntlMenu Class - Menus sub class */

var IntlMenu = Class.create();


IntlMenu.prototype = Object.extend(new Menus({}), {

	showElement: function (element) {
		var offSet = Position.cumulativeOffset(this.menus[0].trigger);
		element.setStyle({left: offSet[0] + "px", top: (offSet[1] - element.getHeight()) + "px"});
		element.setVisible();
	}
});
/* IntlMenu Class Ends */

////////////////////////////////////////////////////////////

/* ElemEffectSwitch Class */
var ElemEffectSwitch = Class.create();

ElemEffectSwitch.prototype = {
    
    initialize: function(args) { 
        if (document.images) {
            if (!args) {
                return;
            }
            
            if (!args.trigger || !args.elementEffect) {
                throw new Error("ElemEffectSwitch requires an args object with a trigger property that is either the element id of a trigger element or an Array of trigger element ids. It also requires an elementEffect property which points to a subclass of the AbstractElemEffect class");
                return;
            }
            
            if (AbstractElemEffect.prototype.isPrototypeOf(args.elementEffect)) {
				this._elemEffect = args.elementEffect;
                this._effectTarget = this._elemEffect.getTarget();
            } else {
                throw new Error("args property elementEffect must be a subclass of AbstractElemEffect");
                return;
            }
            
            if (typeof args.trigger == "string" && $(args.trigger)) {
                this._triggersArray = [$(args.trigger)];
            }
            else if (args.trigger.constructor === Array) {
                this._triggersArray = args.trigger;
            }
            else {
                return;
            }
            
            this._indClass = args.indicatorClass;
            this._openState = args.openedClass;
            this._openOverState = args.openedOverClass;
            this._closeState = args.closedClass;
            this._closeOverState = args.closedOverClass;
            this._closeBtnClass = args.closeButtonClass;
            
            this._isToggle = args.isToggleSwitch || true;
            
            
            this._triggers = $A([]);
            var tIndx = this._triggersArray.length;
            while (--tIndx >= 0) {
                this._setTrigger(this._triggersArray[tIndx]);
            }
            
            if (this._openState && this._closeState && this._openOverState && this._closeOverState) {
                this._boundOver = this.over.bindAsEventListener(this);
                this._boundOut = this.out.bindAsEventListener(this);
                Event.observe (document, 'mouseover', this._boundOver);
                Event.observe (document, 'mouseout', this._boundOut);
            }
            
            this._elemEffect.addBeforeOpenCall(this.beforeOpen.bind(this));
            this._elemEffect.addAfterOpenCall(this.afterOpen.bind(this));
            this._elemEffect.addBeforeCloseCall(this.beforeClose.bind(this));
            this._elemEffect.addAfterCloseCall(this.afterClose.bind(this));
            
            this._boundClick = this._clickListener.bindAsEventListener(this);
            Event.observe (document, 'click', this._boundClick);
            
        }
    },
    
    _setTrigger: function (element) {
        var elem = $(element);
        elem.setStyle({cursor:'pointer'});
        elem.addClassName (this._indClass);
        if (this._openState && this._closeState)
        {
            if (this._elemEffect.isClosed()) {
                elem.removeClassName(this._openState).addClassName(this._closeState);
            } else {
                elem.removeClassName(this._closeState).addClassName(this._openState);
            }
        }
        this._triggers.push(elem);
    },
    
    over: function(e, elementId) {
        if (! this._openOverState &! this._closeOverState) return;
        
        var elem = (e) ? $(Event.element(e)) : $(elementId);
        if (elem.hasClassName(this._indClass)) {
            if (e) Event.stop(e);
            if (elem.hasClassName(this._closeState)) {   
                elem.removeClassName(this._closeState).addClassName(this._closeOverState);
            } else if (elem.hasClassName(this._openState)) { 
                elem.removeClassName(this._openState).addClassName(this._openOverState);
            } else {
                return;
            }
        }
    },
    // Image Swap - set to off state
    out: function(e, elementId)  {
        if (! this._openOverState &! this._closeOverState) return;
        
        var elem = (e) ? $(Event.element(e)) : $(elementId);
        if (elem.hasClassName(this._indClass)) {
            if (e) Event.stop(e);
            if (elem.hasClassName(this._closeOverState)) {   
                elem.removeClassName(this._closeOverState).addClassName(this._closeState);
            } else if (elem.hasClassName(this._openOverState)) { 
                elem.removeClassName(this._openOverState).addClassName(this._openState);
            } else {
                return;
            }
        }
    },
    
    
    _clickListener: function(e) {
        var element = $(Event.element(e));
        if (element.hasClassName(this._indClass)) {
            Event.stop(e);
            Event.stopObserving (document, 'click', this._boundClick);
            
            if (this._elemEffect.isClosed()) {
                this._openEffect();
            } else {
                if (!this._isToggle) return;
                this._closeEffect();
            }
            
           
        } else if (this._closeBtnClass && element.hasClassName(this._closeBtnClass)) {
            Event.stop(e);
            this._closeEffect();
        }
    },
    
    _openEffect: function () {
        this._elemEffect.openEffect();
    },
    
    _closeEffect: function () {
        this._elemEffect.closeEffect();
    },
    
    beforeOpen:function () {
        Event.stopObserving (document, 'click', this._boundClick);
        this._setTriggersOn();
    },
    
    afterOpen:function () {
        Event.observe (document, 'click', this._boundClick);
    },
    
    beforeClose:function () {
        Event.stopObserving (document, 'click', this._boundClick);
    },
    
    afterClose:function () {
        Event.observe (document, 'click', this._boundClick);
        this._setTriggersOff();
    },
    
    _setTriggersOn: function() {
        var indx = this._triggers.length;
        while (--indx >= 0) {
            this._triggers[indx].addClassName('disabled');
            if (this._openState && this._closeState) {
                if (this._openOverState && this._closeOverState) {
                    this._triggers[indx].removeClassName(this._closeOverState).removeClassName(this._closeState).addClassName(this._openState);
                } else {
                    this._triggers[indx].removeClassName(this._closeState).addClassName(this._openState);
                }
            }
        }
    },
    
    _setTriggersOff: function() {
        var indx = this._triggers.length;
        while (--indx >= 0) {
            this._triggers[indx].removeClassName('disabled');
            if (this._openState && this._closeState) {
                if (this._openOverState && this._closeOverState) {
                    this._triggers[indx].removeClassName(this._openOverState).removeClassName(this._openState).addClassName(this._closeState);
                } else {
                    this._triggers[indx].removeClassName(this._openState).addClassName(this._closeState);
                }
            }
        }
    }
};
/* ElemEffectSwitch Class Ends */

/* AbstractElemEffect Class Starts */

var AbstractElemEffect = Class.create();

AbstractElemEffect.prototype = {

    initialize: function() {
       
    },
	
    
    addBeforeOpenCall: function (method, argsArray) {
      if (method.constructor != Function) return;
	  if (!argsArray) argsArray = [];
      if (argsArray && argsArray.constructor != Array) {
	      argsArray = [argsArray];
	  }
      this._beforeOpenCalls.push({method:method, args:argsArray});
    },
    
    addAfterOpenCall: function (method, argsArray) {
       if (method.constructor != Function) return;
       if (!argsArray) argsArray = [];
	   if (argsArray && argsArray.constructor != Array) {
	   	   argsArray = [argsArray];
       }
       this._afterOpenCalls.push({method:method, args:argsArray});
    },
    
    addBeforeCloseCall: function (method, argsArray) {
      if (method.constructor != Function) return;
      if (!argsArray) argsArray = [];
	  if (argsArray && argsArray.constructor != Array) {
          argsArray = [argsArray];
      }
      this._beforeCloseCalls.push({method:method, args:argsArray});
    },
    
    addAfterCloseCall: function (method, argsArray) {
       if (method.constructor != Function) return;
       if (!argsArray) argsArray = [];
       if (argsArray && argsArray.constructor != Array) {
           argsArray = [argsArray];
       }
       this._afterCloseCalls.push({method:method, args:argsArray});
    },
    
    _makeBeforeOpenCalls: function () {
        for(var i = 0, l = this._beforeOpenCalls.length; i < l; i++) {
            this._beforeOpenCalls[i].method.apply(this, this._beforeOpenCalls[i].args);
        }
    },
    
    _makeAfterOpenCalls: function () {
        for(var i = 0, l = this._afterOpenCalls.length; i < l; i++) {
            this._afterOpenCalls[i].method.apply(this, this._afterOpenCalls[i].args);
        }
    },
    
    _makeBeforeCloseCalls: function () {
        for(var i = 0, l = this._beforeCloseCalls.length; i < l; i++) {
            this._beforeCloseCalls[i].method.apply(this, this._beforeCloseCalls[i].args);
        }
    },
    
    _makeAfterCloseCalls: function () {
        for(var i = 0, l = this._afterCloseCalls.length; i < l; i++) {
            this._afterCloseCalls[i].method.apply(this, this._afterCloseCalls[i].args);
        }
    },
    
    openEffect:function () {
        //This is an abstract method to be overridden by concrete subclass
    },
    
    closeEffect: function () {
        //This is an abstract method to be overridden by concrete subclass
    },
    
    getTarget: function () {
        //This is an abstract method to be overridden by concrete subclass
    },
	
	isClosed: function () {
		return this._closed;
	}
};


/* AbstractElemEffect Class Ends */

/* ElemFadeEffect Class Starts */

var ElemFadeEffect = Class.create();

ElemFadeEffect.prototype = Object.extend(new AbstractElemEffect(), {

    initialize: function(args) {
        if (document.images) {
            if (!args) {
                return;
            }
            
            if (!args.targetElement) {
                throw new Error("ElemEffect requires an args object with a targetElement property that is the element id of a target element for the effect.");
                return;
            }
            this._effectTarget = $(args.targetElement);
            this._duration = (args.duration && args.duration.constructor == Number) ? args.duration : 1.0;
            this._delay = (args.delay && args.delay.constructor == Number) ? args.delay : 0;
            
            
            this._boundBeforeOpen = this._beforeOpen.bind(this);
            this._boundAfterOpen = this._afterOpen.bind(this);
            this._boundBeforeClose = this._beforeClose.bind(this);
            this._boundAfterClose = this._afterClose.bind(this);
			
			this._beforeOpenCalls = $A([]);
            this._afterOpenCalls = $A([]);
            this._beforeCloseCalls = $A([]);
            this._afterCloseCalls = $A([]);
			
			this._closed = (this._effectTarget.getStyle('display') == 'none');
        }
    },
    
    _beforeOpen: function () {
		this._makeBeforeOpenCalls();
	},
	
	_afterOpen: function () {
       this._closed = false;
	   this._running = false;
	   this._makeAfterOpenCalls();
    },
	
	_beforeClose: function () {
        this._makeBeforeCloseCalls();
    },
    
    _afterClose: function () {
       this._closed = true;
       this._running = false;
       this._makeAfterCloseCalls();
    },
    
    openEffect:function () {

		if (! this.isClosed()) return;
		if (this._running) return;
		this._running = true;
		new Effect.Appear(this._effectTarget, { delay: this._delay, duration: this._duration, transition: Effect.Transitions.sinoidal, beforeStart: this._boundBeforeOpen, afterFinish: this._boundAfterOpen });
    },
    
    closeEffect: function () {
		if (this.isClosed()) return;
		if (this._running) return;
        this._running = true;
        new Effect.Fade(this._effectTarget, { delay: this._delay, duration: this._duration, transition: Effect.Transitions.sinoidal, beforeStart: this._boundBeforeClose, afterFinish: this._boundAfterClose });
    },
    
    getTarget: function () {
        return this._effectTarget;
    }
});

/* ElemFadeEffect Class Ends */

/* ElemToggleEffect Class Starts */

var ElemToggleEffect = Class.create();

ElemToggleEffect.prototype = Object.extend(new AbstractElemEffect(), {

    initialize: function(args) {
        if (document.images) {
            if (!args) {
                return;
            }
            
            if (!args.targetElement) {
                throw new Error("ElemEffect requires an args object with a targetElement property that is the element id of a target element for the effect.");
                return;
            }
            this._effectTarget = $(args.targetElement);
			this._effectType = (args.effectToggleType && args.effectToggleType.constructor == String) ? args.effectToggleType : "appear";
            if (this._effectType != "appear" && this._effectType != "blind" && this._effectType != "slide") {
                throw new Error("Incorrect Effect Toggle Type specified");
                this._effectType = "appear";
            }
            this._duration = (args.duration && args.duration.constructor == Number) ? args.duration : 1.0;
            this._delay = (args.delay && args.delay.constructor == Number) ? args.delay : 0;
            this._transition = args.transition || Effect.Transitions.linear;
            
            this._boundBeforeOpen = this._beforeOpen.bind(this);
            this._boundAfterOpen = this._afterOpen.bind(this);
            this._boundBeforeClose = this._beforeClose.bind(this);
            this._boundAfterClose = this._afterClose.bind(this);
			
			this._beforeOpenCalls = $A([]);
            this._afterOpenCalls = $A([]);
            this._beforeCloseCalls = $A([]);
            this._afterCloseCalls = $A([]);
            
            this._closed = (this._effectTarget.getStyle('display') == 'none');
        }
    },
    
    _beforeOpen: function () {
        this._makeBeforeOpenCalls();
    },
    
    _afterOpen: function () {
       this._closed = false;
       this._running = false;
       this._makeAfterOpenCalls();
    },
    
    _beforeClose: function () {
        this._makeBeforeCloseCalls();
    },
    
    _afterClose: function () {
       this._closed = true;
       this._running = false;
       this._makeAfterCloseCalls();
    },
    
    openEffect:function () {
        if (! this.isClosed()) return;
        if (this._running) return;
        this._running = true;
		//alert('here::'+this._effectTarget);
		new Effect.toggle(this._effectTarget, this._effectType, { duration:this._duration, delay:this._delay, transition: this._transition, beforeStart: this._boundBeforeOpen, afterFinish: this._boundAfterOpen });
    },
    
    closeEffect: function () {
		//if (this.isClosed()) return;
        //if (this._running) return;
        this._running = true;
		this._effectTarget.hide();
        this._beforeClose();
		this._afterClose();
        //new Effect.toggle(this._effectTarget, this._effectType, { duration:this._duration, delay:this._delay, transition: this._transition, beforeStart: this._boundBeforeClose, afterFinish: this._boundAfterClose });
    },
    
    getTarget: function () {
        return this._effectTarget;
    }
});

/* ElemToggleEffect Class Ends */


/* ElemShowHideEffect Class Starts */

var ElemShowHideEffect = Class.create();

ElemShowHideEffect.prototype = Object.extend(new AbstractElemEffect(), {

    initialize: function(args) {
        if (document.images) {
            if (!args) {
                return;
            }
            
            if (!args.targetElement) {
                throw new Error("ElemEffect requires an args object with a targetElement property that is the element id of a target element for the effect.");
                return;
            }
            this._effectTarget = $(args.targetElement);
            this._boundBeforeOpen = this._beforeOpen.bind(this);
            this._boundAfterOpen = this._afterOpen.bind(this);
            this._boundBeforeClose = this._beforeClose.bind(this);
            this._boundAfterClose = this._afterClose.bind(this);
            
            this._beforeOpenCalls = $A([]);
            this._afterOpenCalls = $A([]);
            this._beforeCloseCalls = $A([]);
            this._afterCloseCalls = $A([]);
            
            this._closed = (this._effectTarget.getStyle('display') == 'none');
        }
    },
    
    _beforeOpen: function () {
        this._makeBeforeOpenCalls();
    },
    
    _afterOpen: function () {
       this._closed = false;
       this._running = false;
       this._makeAfterOpenCalls();
    },
    
    _beforeClose: function () {
        this._makeBeforeCloseCalls();
    },
    
    _afterClose: function () {
       this._closed = true;
       this._running = false;
       this._makeAfterCloseCalls();
    },
    
    openEffect:function () {
        if (! this.isClosed()) return;
        if (this._running) return;
        this._running = true;
		this._effectTarget.show();
        this._beforeOpen();
		this._afterOpen();
    },
    
    closeEffect: function () {
        if (this.isClosed()) return;
        if (this._running) return;
        this._running = true;
		this._effectTarget.hide();
        this._beforeClose();
		this._afterClose();
    },
    
    getTarget: function () {
        return this._effectTarget;
    }
});

/* ElemShowHideEffect Class Ends */

var ebiSiteletFunctions = {};
var oceanaFader;

////////////////////////////////////////////////////////////


/* FlashOverlay Class Begins */


var FlashOverlay = Class.create();

FlashOverlay.prototype = {
    
    initialize: function (args) {
        this._swfPath = args.swfPath;
		this._noFlashContent = args.noFlashContent;
		this._width = args.width || "100%";
		this._height = args.height || "100%";
		this._version = args.version || "10.0.0";
		this._flashvars = args.flashvars;
        this._params = args.params;
		this._overlayContainer = $(args.overlayContainer);
		this._overlayTint = $(args.overlayTint);
		this._flashContent = $(args.flashContent);
		this._flashContainer = this._flashContent.up();
		this._flashContent.remove();
		this._overlayOpacity = args.overlayOpacity || 0.5;
		this._overlayTint.setStyle({opacity: this._overlayOpacity, cursor: "pointer"});
    },
    
    
    addFlash: function () {
	
		this._flashContainer.appendChild(this._flashContent);
		if (this._noFlashContent) {
			this._flashContent.innerHTML = this._noFlashContent;
		}
		//alert('HE::'+this._swfPath+"::"+this._flashvars);
        swfobject.embedSWF(this._swfPath, this._flashContent.id, this._width, this._height, this._version, "expressInstall.swf", this._flashvars, this._params);
        swfobject.createCSS("#" + this._flashContent.id,"outline:none"); 
    },
	
	destroyOverlay: function () {
		this._flashContainer.immediateDescendants().each(function(element, i) { 
		  element.remove();
	    });
	}
};


/* FlashOverlay Class Ends */


var SkuSelectChangeListener = Class.create();

SkuSelectChangeListener.prototype = {
	initialize:function () {
		var boundSelectChange = this.onSelectChange.bindAsEventListener(this);
		
		if (document.createEventObject) {
			//Event.observe (document, 'onchange', this.boundSelectChange);
			$$('select.sku_select').each(function(selectElement){
				Event.observe (selectElement, 'change', boundSelectChange);
			});
		} else {
			Event.observe (document, 'change', boundSelectChange);
		}
	},
	
	onSelectChange: function (e) {
		var element = $(Event.element(e));
		if (element.tagName == "SELECT" && element.hasClassName("sku_select")) {
			var optionElem = $(element.options[element.selectedIndex]);
			var purchaseButton = element.up('form.buymod_form').down('input.purchase_button');
			purchaseButton.addClassName((optionElem.hasClassName('replenishable')) ? 'replenish' : '');
			purchaseButton.value = optionElem.value;
		}
	}
};


/* SwatchUtils Class */
var SwatchUtils = Class.create();

SwatchUtils.prototype = {
	
	initialize: function(bigSwatchElement, prodListArray, productsHash, offIndicator, overIndicator) { 
		
		this.bigSwatch = bigSwatchElement;
		this.prodsList = prodListArray;
		this.prodsHash = productsHash;
		this.offIndicator = offIndicator ? offIndicator + '.' : '_off.';
		this.overIndicator = overIndicator ? overIndicator + '.' : '_over.';
		
		if (document.images) {
			this.smlSwatchMasksOff = new Object();
			this.smlSwatchMasksOver = new Object();
			this.bigSwatchMasks = new Object();
			
			this.boundClick = this.onClick.bindAsEventListener(this);
			this.boundOver = this.over.bindAsEventListener(this);
			this.boundOut = this.out.bindAsEventListener(this);
			Event.observe (document, 'click', this.boundClick);
			Event.observe (document, 'mouseover', this.boundOver);
			Event.observe (document, 'mouseout', this.boundOut);
			
			this.isIE6 = (BrowserDetect.isIE && !BrowserDetect.isIE7);
			this.bigSwatchMaskElement;
			this.bigSwatchNameElement;
			this.bigSwatchDimensions;
			this.smlSwatchDimensions;
			this.setSwatches();
		} else {
			return;
		}
	},
	
	// Image pre-caching method
	// adds images to the imagesOff and imagesOver hashes for precaching and over and out methods.
	setSwatches: function() {
		var swatches = $$('.swatch');
		this.bigSwatchMaskElement = this.bigSwatch.down('.png');
		this.bigSwatchNameElement = this.bigSwatch.down('.name');
		this.bigSwatchDimensions = this.bigSwatchMaskElement.getDimensions();
		this.smlSwatchDimensions = swatches.first().getDimensions();
		var boundPrecache = this.precacheSwatchMasks.bind(this);
		swatches.each(boundPrecache);
	},
	
	precacheSwatchMasks: function (elem) {
		var imgSrcOff;
		if (this.isIE6) {
			imgSrcOff = elem.filters(0).src;
		} else {
			var bgImg = elem.getStyle('background-image').replace('url(', '');
			imgSrcOff = (bgImg.indexOf('.PNG') == -1) ? bgImg.replace('.png)', '.png') : bgImg.replace('.PNG)', '.PNG');
		}
		
		var prod_id = elem.up('form.buymod_form').down('input.product_id_input').value;
		var sku_id = elem.id;
		this.smlSwatchMasksOff[sku_id] = new Image(this.smlSwatchDimensions.width, this.smlSwatchDimensions.height);
		this.smlSwatchMasksOff[sku_id].src = imgSrcOff;
		
		this.smlSwatchMasksOver[sku_id] = new Image(this.smlSwatchDimensions.width, this.smlSwatchDimensions.height);
		this.smlSwatchMasksOver[sku_id].src = imgSrcOff.replace(this.offIndicator, this.overIndicator);
		
		
		this.bigSwatchMasks[sku_id] = new Image(this.bigSwatchDimensions.width, this.bigSwatchDimensions.height);
		this.bigSwatchMasks[sku_id].src = this.prodsHash[prod_id].sku_list[sku_id].shades[this.prodsHash[prod_id].sku_list[sku_id].shade_list[0]];
		this.bigSwatchMasks[sku_id].name = this.prodsHash[prod_id].sku_list[sku_id].shade_name;
		this.bigSwatchMasks[sku_id].hex = this.prodsHash[prod_id].sku_list[sku_id].shade_list[0];

	},
	
	
	onClick: function(e) {
		var element = $(Event.element(e));
		if (element.hasClassName('swatch') || element.hasClassName('swatch_name')) {
			var swatch = element.up('.swatch_container').down('.swatch');
			var sku_id = swatch.id;
			var bigSwatchMasks = this.bigSwatchMasks;
			var selectElem = element.up('form.buymod_form').down('select.shade_select');
			$A(selectElem.options).each(function (option, i) {
				var optiontext;
				var swatchname;
				optiontext = (option.text == 'Cr&egrave;me' || option.text == 'Crème') ? 'Cr&#232;me' : option.text;
				swatchname = (bigSwatchMasks[sku_id].name == 'Cr&egrave;me' || bigSwatchMasks[sku_id].name == 'Crème') ? 'Cr&#232;me' : bigSwatchMasks[sku_id].name;
				
				
				if (optiontext == swatchname) {
					selectElem.selectedIndex = i;
					throw $break;
				}
			});
			
			var evt;
			if (document.createEvent) {
				evt = document.createEvent("Events");
				evt.initEvent("change", true, false);
				selectElem.dispatchEvent(evt);
			}
			else if (document.createEventObject) {
				evt = document.createEventObject();
				selectElem.fireEvent("onchange", evt);
			}
			else return;
										
		}
	},
	
	// Image Swap - set to over state
	over: function(e) {
		Event.stop(e);
		var element = $(Event.element(e));
		if (element.hasClassName('swatch') || element.hasClassName('swatch_name')) {
			var swatch = element.up('.swatch_container').down('.swatch');
			var name = element.up('.swatch_container').down('.swatch_name');
			var sku_id = swatch.id;
			if (this.isIE6) {
				swatch.filters(0).src = this.smlSwatchMasksOver[sku_id].src;
				this.bigSwatchMaskElement.filters(0).src = this.bigSwatchMasks[sku_id].src;
			} else {
				swatch.setStyle({backgroundImage: 'url(' + this.smlSwatchMasksOver[sku_id].src + ')'});
				this.bigSwatchMaskElement.setStyle({backgroundImage: 'url(' + this.bigSwatchMasks[sku_id].src + ')'});
			}
			name.setStyle({color: '#f2b4a3'});
			this.bigSwatchMaskElement.setStyle({backgroundColor: '#' + this.bigSwatchMasks[sku_id].hex});
			this.bigSwatchNameElement.innerHTML = this.bigSwatchMasks[sku_id].name;
			this.bigSwatch.setVisible();
		}
	},
	// Image Swap - set to off state
	out: function(e) {
		Event.stop(e);
		var element = $(Event.element(e));
		if (element.hasClassName('swatch') || element.hasClassName('swatch_name')) {
			var swatch = element.up('.swatch_container').down('.swatch');
			var name = element.up('.swatch_container').down('.swatch_name');
			var sku_id = swatch.id;
			if (this.isIE6) {
				swatch.filters(0).src = this.smlSwatchMasksOff[sku_id].src;
			} else {
				swatch.setStyle({backgroundImage: 'url(' + this.smlSwatchMasksOff[sku_id].src + ')'});
			}
			name.setStyle({color: '#999999'});
			this.bigSwatch.setHidden();
		}
	}
};
/* SwatchUtils Class Ends */




/* Replenishment Class */
var Replenishment = Class.create();


Replenishment.prototype = {

	initialize: function(replenishmentBoxId, prodListArray, productsHash) {
		if (document.images) {
			//Create empty Array for menu objects
			// To be populated by addMenu method
			this.buttons = $$('.purchase_button');
			
			this.replenishmentBox = $(replenishmentBoxId);
			this.prodsArray = prodListArray;
			this.prodsHash = productsHash;
				
			this.boundClick = this.onClick.bindAsEventListener(this);
			this.boundObserve = this.observeClick.bind(this);
			this.boundStopObserving = this.stopObservingClick.bind(this);
			
			this.observeClick();
			
			this.cartItems;
			this.clickedButton;
			this.useReplenishment;
			
			//this.boundShowBox = this.showReplenishmentBox.bind(this);
			//this.boundShowOptions = this.showReplenishmentOptions.bind(this);
			//this.boundShowCartErrors = this.showCartErrors.bind(this);
			//this.boundShowRepErrors = this.showReplenishErrors.bind(this);
			//this.boundShowSpin = this.showSpinner.bind(this);
			//this.boundHideBox = this.hideReplenishmentBox.bind(this);
			this.boundFinish = this.finishShopping.bind(this);
		}
	},
	
	observeClick: function () {
		Event.observe (document, 'click', this.boundClick);
	},
	
	stopObservingClick: function () {
		Event.stopObserving (document, 'click', this.boundClick);
	},
	
	onClick: function (e) {
		var element = $(Event.element(e));
		if (element.hasClassName("purchase_button") && !element.hasClassName("disabled")) {
			Event.stop(e);
			this.cartItems = $A(new Array());
			this.cartItems.push({ CATEGORY_ID: element.up('form.buymod_form').down('input.category_id_input').value, PRODUCT_ID: element.up('form.buymod_form').down('input.product_id_input').value, SKU_ID: element.value, QUANTITY: element.previous('input.qty_value').value, INTERVAL: "none" });
			this.clickedButton = element;
			this.useReplenishment = element.hasClassName('replenish');
			this.addToCart();
		}
		
		if (element.hasClassName("continue_replenish") || element.hasClassName("close_replenish")) {
			Event.stop(e);
			
			this.showSpinner();
			var formElem = element.up("form.interval_form");
			var formValues = formElem.serialize(true);
			
			this.cartItems.first().INTERVAL = formValues.LMReplenishment;
			this.cartItems.first().QUANTITY = 0;
			this.updateCart();
		}
		
		if (element.hasClassName("continue_error") || element.hasClassName("close_error")) {
			Event.stop(e);
			
			this.hideReplenishmentBox();
		}
	},
	
	addToCart:function() {
		var skuErrors = new Array();
		this.cartItems.each(function (element) {
			if (element.SKU_ID.blank() || element.SKU_ID == null)
			{
				skuErrors.push(element);
			}
		});
		
		
		if (skuErrors.length > 0)
		{
			this.showSkuErrors(skuErrors);
		}
		else
		{
			this.hideSkuErrors();
			this.disableShopping();
			this.stopObservingClick();
			if (this.useReplenishment) {
				this.showReplenishmentBox();				
			}
			var thisObj = this;
			var method = "cart.add_items";
			var args = eval('(' + this.cartItems.toJSON() + ')');
			var req = GenericJsonRpc.addAction({
				action: method,
				params: args,
				observers: [
					{
						onComplete: function(response) {
							var resultObj = eval(response.result);
							if (resultObj.success)
							{
								thisObj.updateCartCount();
								if (thisObj.useReplenishment)
								{
									thisObj.showReplenishmentOptions();
								}
								else
								{
									thisObj.boundFinish();
								}
							} else {
								if (!thisObj.useReplenishment) {
									thisObj.showReplenishmentBox();
								}
								thisObj.showCartErrors(resultObj.errors);
							}
						},
						onError: function(response) {
							window.alert('jsonrpc error');
						}
					}
				]
			});
			GenericJsonRpc.process('immediate');
		}
	},
	
	updateCart: function () {
		this.stopObservingClick();
		var thisObj = this;
		var method = "cart.update_item";
		var args = eval('(' + this.cartItems.toJSON() + ')');
		var req = GenericJsonRpc.addAction({
			action: method,
			params: args,
			observers: [
			{
				onComplete: function(response) {
					var resultObj = eval(response.result);
					if (resultObj.success)
					{
						thisObj.hideReplenishmentBox();
					} else {
						thisObj.showReplenishErrors(resultObj.errors);
					}
				},
				onError: function(response) {
					window.alert('jsonrpc error');
				}
			}
			]
		});
		GenericJsonRpc.process('immediate');
	},
	
	
	showReplenishmentBox: function() {
		if (BrowserDetect.isIE6) {
			if ($('shade_select_menu')) $('shade_select_menu').setHidden();
			this.replenishmentBox.down('.middle_content').setStyle({height:'120px'});
		}
		
		new Effect.Appear(this.replenishmentBox, {duration:0.5, delay:0.2, queue:{scope:"replenishment_effects", position:'front'}});
	},
	
	showReplenishmentOptions: function() {
		var cartItem = this.cartItems.first();
		var skuSize = this.prodsHash[cartItem.PRODUCT_ID].sku_list[cartItem.SKU_ID].product_size;
		var displayName = (! this.prodsHash[cartItem.PRODUCT_ID].sku_list[cartItem.SKU_ID].display_name.blank()) ? this.prodsHash[cartItem.PRODUCT_ID].sku_list[cartItem.SKU_ID].display_name + ' ' + skuSize : this.prodsHash[cartItem.PRODUCT_ID].product_name + ' ' + skuSize;
		
		if (!this.prodsHash[cartItem.PRODUCT_ID].sku_list[cartItem.SKU_ID].shade_name.blank()) {
			displayName += (' ' + this.prodsHash[cartItem.PRODUCT_ID].sku_list[cartItem.SKU_ID].shade_name);
		}
		
		$$('.replenishment_skuname').each(function(elem) {
			elem.innerHTML = displayName;										  
		});
		
		new Effect.Fade(this.replenishmentBox.down('.json_spinner'), {duration:0.3, queue:{scope:"replenishment_effects", position:'end'}});
		new Effect.BlindDown(this.replenishmentBox.down('.replenishment_options'), {duration:0.7, delay:0.2, queue:{scope:"replenishment_effects", position:'end'}, afterFinish: this.boundObserve});
	},
	
	showReplenishErrors: function (errors) {
		var cart_errors = this.replenishmentBox.down('.cart_errors');
		var error_text = cart_errors.down('.error_text');
		$A(errors).each(function(error) {
			var errorString;
			if (error.include("&#232;") && error.include("&egrave;")) {
				var stringOne = error.gsub("&#232;", "\350");
				errorString =  stringOne.gsub("&egrave;", "\350");
			} else if (error.include("&#232;") && !error.include("&egrave;")) {
				errorString = error.gsub("&#232;", "\350");
			} else if (error.include("&egrave;") && !error.include("&#232;")) {
				errorString = error.gsub("&egrave;", "\350");
			} else {
				errorString = error;
			}
			error_text.appendChild(document.createTextNode(errorString));
			error_text.appendChild(document.createElement("br"));
			error_text.appendChild(document.createElement("br"));
		});
		new Effect.BlindUp(this.replenishmentBox.down('.replenishment_options'), {duration:0.2, queue:{scope:"replenishment_effects", position:'end'}});
		new Effect.BlindDown(cart_errors, {duration:0.5, delay:0.1, queue:{scope:"replenishment_effects", position:'end'}, afterFinish: this.boundObserve});
	},
	
	showCartErrors: function (errors) {
		var cart_errors = this.replenishmentBox.down('.cart_errors');
		var error_text = cart_errors.down('.error_text');
		$A(errors).each(function(error) {
			var errorString;
			if (error.include("&#232;") && error.include("&egrave;")) {
				var stringOne = error.gsub("&#232;", "\350");
				errorString =  stringOne.gsub("&egrave;", "\350");
			} else if (error.include("&#232;") && !error.include("&egrave;")) {
				errorString = error.gsub("&#232;", "\350");
			} else if (error.include("&egrave;") && !error.include("&#232;")) {
				errorString = error.gsub("&egrave;", "\350");
			} else {
				errorString = error;
			}
			error_text.appendChild(document.createTextNode(errorString));
			error_text.appendChild(document.createElement("br"));
			error_text.appendChild(document.createElement("br"));
		});
		new Effect.BlindUp(this.replenishmentBox.down('.json_spinner'), {duration:0.2, queue:{scope:"replenishment_effects", position:'end'}});
		new Effect.BlindDown(cart_errors, {duration:0.5, delay:0.1, queue:{scope:"replenishment_effects", position:'end'}, afterFinish: this.boundObserve});
	},
	
	showSpinner: function() {
		new Effect.BlindUp(this.replenishmentBox.down('.replenishment_options'), {duration:0.5, delay:0.1, queue:{scope:"replenishment_effects", position:'end'}, afterFinish: this.boundStopObserving});
		new Effect.Appear(this.replenishmentBox.down('.json_spinner'), {duration:0.2, queue:{scope:"replenishment_effects", position:'end'}});
		
	},
	
	hideReplenishmentBox: function() {
		if (BrowserDetect.isIE6) {
			this.replenishmentBox.down('.middle_content').setStyle({height:'120px'});
		}
		new Effect.Opacity(this.replenishmentBox, {to:0.0, duration:0.3, queue:{scope:"replenishment_effects", position:'front'}, afterFinish:this.boundFinish});
	},
	
	finishShopping: function () {
		if (BrowserDetect.isIE6) {
			if ($('shade_select_menu')) $('shade_select_menu').setVisible();
			this.replenishmentBox.down('.middle_content').setStyle({height:'120px'});
		}
		this.enableShopping();
		this.observeClick();
		this.goToCart();
	},
	
	updateCartCount: function() {
		var countArray = $A(new Array());
		var countItem = { DUMMY: 0 };
		countArray.push(countItem);
		var thisObj = this;
		var method = "cart.item_count";
		var args = eval('(' + countArray.toJSON() + ')');
		var req = GenericJsonRpc.addAction({
			action: method,
			params: args,
			observers: [
			{
				onComplete: function(response) {
					var resultObj = eval(response.result);
					if (resultObj.success)
					{
						thisObj.setCartCount(resultObj.item_count);
					}
				},
				onError: function(response) {
					window.alert('jsonrpc error');
				}
			}
			]
		});
		GenericJsonRpc.process('immediate');
	},
	
	setCartCount: function(numitems) {
		var itemText = (numitems == 1) ? "item" : "items";
		$("cart_count").update(numitems + " " + itemText);
	},
	
	goToCart: function() {
		var currentHost = window.location.host;
		var currentLocation = window.location.href;
		var root = (currentLocation.indexOf("http://") != -1) ? "http://" + currentHost : currentHost;
		var returntoshop_url = currentLocation.replace(root, "");
		window.location.href = "http://" + currentHost + "/templates/session/viewbag.tmpl?returntoshop=" + encodeURIComponent(returntoshop_url);
	},
	
	disableShopping: function() {
		this.buttons.each(function (element) {
			element.disable();
			element.addClassName('disabled');
			element.removeClassName('rollover');
			var selectElem = element.up('form.buymod_form').down('select.shade_select');
			if (selectElem)
			{
				selectElem.addClassName('disabled');
				selectElem.disable();
			}
		});
	},
	
	enableShopping: function() {
		this.buttons.each(function (element) {
			element.enable();
			element.removeClassName('disabled');
			element.addClassName('rollover');
			var selectElem = element.up('form.buymod_form').down('select.shade_select');
			if (selectElem)
			{
				selectElem.removeClassName('disabled');
				selectElem.enable();
			}
		});
	},
	
	showSkuErrors: function(errorSkus) {
		var skuError = $("sku_error");
		if (errorSkus.length > 0)
		{
			if (skuError) skuError.setVisible();
		} else {
			if (skuError) skuError.setHidden();
		}
	},
	
	hideSkuErrors: function() {
		var skuError = $("sku_error");
		if (skuError) skuError.setHidden();
	}
};
/* Replenishment Class Ends */


/* Global functions */

// Global Nav search and email field clear and replace functions
var condText;
function clearTextBoxOnCondition(textBox,conditionText){
        if(textBox.value == conditionText) {
          textBox.value="";
	  condText=conditionText;
	}
}    


function fillTextBoxOnCondition(textBox){
        if(textBox.value == "") {
          textBox.value=condText;
        }
}

function checkMaxLength (textarea, evt, maxLength) {
	if (textarea.selected && evt.shiftKey)
	// ignore shift click for select
		return true;
	var allowKey = false;
	if (textarea.selected && textarea.selectedLength > 0)
		allowKey = true;
	else {
		var keyCode = document.layers ? evt.which : evt.keyCode;
		if (keyCode < 32 && keyCode != 13)
			allowKey = true;
		else
			allowKey = textarea.value.length < maxLength;
		}
	textarea.selected = false;
	return allowKey;
}

// Pop a window
var popupWindow;
function popup(url,scrollbars,width,height){
    popupWindow = open(url, 'lmPopupWindow', 'toolbar=0,location=0,directories=0,status=0,menubars=0,resizable=0,scrollbars='+scrollbars+',width='+width+',height='+height+',top=20,left=20');
    if (popupWindow != null) {
        popupWindow.focus();
    }
}

//better popup
var popupWindowID;
function popupID(url,scrollbars,width,height,id){
    popupWindowID = open(url, id, 'toolbar=0,location=0,directories=0,status=0,menubars=0,resizable=0,scrollbars='+scrollbars+',width='+width+',height='+height+',top=20,left=20');
    if (popupWindowID != null) {
        popupWindowID.focus();
    }
}

// Close window
function closewindow() {
	this.window.close();
}


/* Copied from elcNavigation and head_common.tmpl */
if ((typeof wsmlMakeWebServiceHref) == "undefined")
{
  wsmlMakeWebServiceHref =
  wsmlMakeResourceHref =
  wsmlMakeResourceUrl =
  wsmlMakeLeakHref =
  wsmlMakeComponentHref =
  wsmlMakeCssHref = new Function ("u", "return u;");
}

// wsml functions are defined above
function elcSendURL( url ) {
	location.replace(wsmlMakeWebServiceHref(url));
}

/* Global functions end */


/* Initialization Scripts */

Element.addMethods(new ElementExtension());

Event.observe(window, 'load', function() {
	
	var transPngs = $$('.transPng');
	var tpIndx = transPngs.length;
	while (--tpIndx >= 0) {
		transPngs[tpIndx].setBgTransPng();
	}
	
	var rollovers = $$('.rollover'), imgSwap = new ImageRollover("_off", "_on", "_highlite");
	var rIndx = rollovers.length;
	while (--rIndx >= 0) {
		imgSwap.addItem(rollovers[rIndx]);
	}
	
	$$('.imgmapover').each(function (element) {
		if (! imgSwap) var imgSwap = new ImageRollover("_off", "_on", "_highlite");
		imgSwap.addImage(element);
	});
	
	var cssSwap = new CSSRollover ("css_img_swap", "overstate", "disabled");
	
	
	if ($('globalnav_container')) {
		var gnavSwap = new CSSRollover ("gnav_mid_swap", "overstate", "onstate");
		var navMenus = new Menus({indicatorClass:"gnav_menu", triggerClass:"trigger", menuClass:"menu", disabledClass: "disabled_menu", rolloverObj:gnavSwap});
		$$(".nav_menu_trigger").each(function(elem){
			var menu = {trigger:elem.removeClassName("nav_menu_trigger"), menu:elem.id + "_menu"};
			navMenus.addItem(menu);
		});
	}
	
	var gfoot_intl = $('gfoot_intl');
	if (gfoot_intl) {
		var intlMenu = new IntlMenu({indicatorClass:"gfoot_intl_menu", triggerClass:"trigger", menuClass:"menu", rolloverObj:imgSwap});
		intlMenu.addItem({trigger:gfoot_intl, menu:"gfoot_intl_menu"});
	}
	
	//ebi Sitelet
	if ($('flash_overlay_ebi_container')) {
		var flashvars = {
			assetsDomain: "/flash/eyebalm/deploy/",
			siteData: "/xml/eyebalm.xml",
			width: "960",
			height: "500"
		}
		
		var params = {
			allowscriptaccess: "always",
			wmode: "opaque",
			scale: "noscale"
		}
		
		var ebiNoFlashHtml = '<img src="/images/ebi/sitelet/noflash.jpg" alt="To view this page please download and install Adobe Flash 9 or higher. Or, click here to explore LaMer.com and shop The Eye Balm Intense." width="960" height="500" border="0" usemap="#noflashmap" />' +
		                  '<map name="noflashmap" id="noflashmap">' +
						      '<area shape="rect" coords="356,208,449,235" href="http://www.adobe.com/products/flashplayer/" target="_blank" alt="download" />' +
							  '<area shape="rect" coords="214,234,302,262" href="javascript: void(0);" onclick="ebiSiteletFunctions.shop()" alt="LaMer.com" />' +
						  '</map>';
		
		var ebiFlash = new FlashOverlay({
			swfPath: "/flash/eyebalm/deploy/lamer-eyebalm.swf",
			noFlashContent: ebiNoFlashHtml,
			width: 960,
			height: 500,
			version: "9.0.45",
			flashvars: flashvars,
			params: params,
			overlayContainer: "flash_overlay_ebi_container",
			overlayTint: "flash_overlay_ebi_tint",
			flashContent: "flash_overlay_ebi_flash",
			overlayOpacity: 0.8
		});
		
		if (BrowserDetect.isIE6 || BrowserDetect.isIE7) {
			var ebiFader = new ElemToggleEffect({
				targetElement: 'flash_overlay_ebi_container',
				effectToggleType: 'appear',
					duration: 0.2,
					delay: 0.2,
					transition: Effect.Transitions.sinoidal
			});
		} else {
				var ebiFader = new ElemToggleEffect({
					targetElement: 'flash_overlay_ebi_container',
					effectToggleType: 'appear',
					duration: 0.2,
					delay: 0.2,
					transition: Effect.Transitions.sinoidal
		});
		}

		ebiFlash.addFlash();	
		ebiFader.addAfterOpenCall(ebiFlash.addFlash.bind(ebiFlash));
		ebiFader.addAfterCloseCall(ebiFlash.destroyOverlay.bind(ebiFlash));
		ebiFader.addAfterCloseCall(cmCreatePageElementTag, ['sitelet close', 'sitelet_EBI']);
		
		ebiSiteletFunctions = {
			shopFlag: false,

			shopURL: "/templates/products/sp_nonshaded.tmpl?CATEGORY_ID=CAT7080&PRODUCT_ID=PROD99429",
			effectObj: undefined,
			
			shop: function() {
				if (!ebiSiteletFunctions.shopFlag)
				{
					if (!ebiSiteletFunctions.effectObj) return;
					ebiSiteletFunctions.effectObj.addAfterCloseCall(ebiSiteletFunctions.gotoUrl.bind(ebiSiteletFunctions));
				}
				
				ebiSiteletFunctions.close();
			},
			
			open: function() {
				
				if (!ebiSiteletFunctions.effectObj) return;
				  ebiSiteletFunctions.effectObj.openEffect();

            },
			
			close: function() {
				if (!ebiSiteletFunctions.effectObj) return;
				ebiSiteletFunctions.effectObj.closeEffect();
								
			},
			
			gotoUrl: function () {
				window.location.href = ebiSiteletFunctions.shopURL;
			}
		};

		ebiSiteletFunctions.effectObj = ebiFader;
	
		Event.observe ($('flash_overlay_ebi_tint'), 'click', function (e) {
			ebiSiteletFunctions.close();
		});
		Event.observe ($('ebi_close_button'), 'click', function (e) {
			ebiSiteletFunctions.close();
		});	

		var ebiLanding;
		if (ebiLanding = $('lmebi')) 
		{
			Event.observe (ebiLanding, 'click', function (e) {
				ebiSiteletFunctions.open();
			});
			
			ebiFader.addAfterOpenCall(cmCreatePageElementTag, ['email landing pg open', 'sitelet_EBI']);
			
			ebiSiteletFunctions.open();	
		}
	
		if ($('spp_content_container')) {
			
			var ebiSwitch = new ElemEffectSwitch({
				indicatorClass: 'ebiSwitch',
				openedClass: 'toggle_onstate',
				openedOverClass: 'on_over',
				closedClass: 'toggle_offstate',
				closedOverClass: 'off_over',
				closeButtonClass: 'overlay_close',
				trigger: "ebi_sitelet_trigger",
				elementEffect: ebiFader
			});
			
			ebiFader.addAfterOpenCall(cmCreatePageElementTag, ['spp_ebi sitelet open', 'sitelet_EBI']);
		}
	
		if ($('hp_container')) {
			
			ebiFader.addAfterOpenCall(cmCreatePageElementTag, ['hp tout', 'sitelet_EBI']);
		}
						
		if (ebiLanding = $('ebi_landing')) {
			
			Event.observe (ebiLanding, 'click', openOceanaSitelet);
			ebiFader.openEffect();
		}
		
	}
	
	// Oceana Sitelet
    if ($('flash_overlay_oc_container')) {
        var oc_flashvars = {
            assetsDomain: "/flash/oceana/",
            siteData: "xml/lamer-oceana.xml",
            width: "960",
            height: "500"
        }
        
        var oc_params = {
            allowscriptaccess: "always",
            scale: "noscale",
			wmode: "opaque"
        }
		
		var oc_audio_flashvars = {
            assetsDomain: oc_flashvars.assetsDomain,
            siteData: "xml/audio.xml",
            width: "100",
            height: "20"
        }
		
		var oc_audio_params = {
            allowscriptaccess: "always",
            scale: "noscale",
            wmode: "transparent"
        }

        
        var noFlashHtml = '<img src="/images/oceana/sitelet/noflash.jpg" alt="To view this page please download and install Adobe Flash Player 9 or higher. Or, click here to explore LaMer.com and shop the World Oceans Day Cr&egrave;me de la Mer." name="oceana_noflash" width="960" height="500" border="0" usemap="#noflash_map" id="oceana_noflash"  />' +
                          '<map name="noflash_map" id="noflash_map">' +
                              '<area shape="rect" coords="355,220,444,251" href="http://www.adobe.com/products/flashplayer/" target="_blank" alt="download" />' +
                              '<area shape="rect" coords="153,244,236,278" href="/templates/products/spp.tmpl?CATEGORY_ID=CATEGORY5778&PRODUCT_ID=PROD16106" target="_self" alt="click here" />' +
                          '</map>';
        
        
        var oceanaFlash = new FlashOverlay({
            swfPath: "/flash/oceana/lamer-oceana.swf",
            noFlashContent: noFlashHtml,
            width: 960,
            height: 500,
            version: "9.0.45",
			flashvars: oc_flashvars,
            params: oc_params,
            overlayContainer: "flash_overlay_oc_container",
            overlayTint: "flash_overlay_oc_tint",
			overlayOpacity: 0.9,
            flashContent: "flash_overlay_oc_flash"
        });
		
		/*oceanaFader = new ElemToggleEffect({
            targetElement: 'flash_overlay_oc_container',
            effectToggleType: 'appear',
            duration: 0.2,
            delay: 0.2,
            transition: Effect.Transitions.sinoidal
        });*/
		
		if (BrowserDetect.isIE6 || BrowserDetect.isIE7) {
			oceanaFader = new ElemShowHideEffect({
				targetElement: 'flash_overlay_oc_container'
			});
		} else {
			oceanaFader = new ElemToggleEffect({
				targetElement: 'flash_overlay_oc_container',
				effectToggleType: 'appear',
				duration: 0.2,
				delay: 0.2,
				transition: Effect.Transitions.sinoidal
			});
		}
		
		var audioHTML = '<div id="flash_overlay_oc_audio_flash"></div>';
		var audioWrapper = $('flash_overlay_oc_audio');
		
		function oceanaAudioSwf() {
			audioWrapper.innerHTML = audioHTML;
			swfobject.embedSWF("/flash/oceana/audio.swf", 'flash_overlay_oc_audio_flash', 100, 20, "9.0.45", "expressInstall.swf", oc_audio_flashvars, oc_audio_params);
            swfobject.createCSS("#flash_overlay_oc_audio_flash","outline:none");
		}
		
		function killOceanaAudioSwf() {
			$('flash_overlay_oc_audio_flash').remove();
		}
        
		oceanaFader.addAfterOpenCall(oceanaFlash.addFlash.bind(oceanaFlash));
		oceanaFader.addBeforeOpenCall(oceanaAudioSwf);
        oceanaFader.addAfterOpenCall(cmCreatePageElementTag, ['Oceana Sitelet  Open', 'LM Oceana Flash Sitelet w/video_2010']);
		oceanaFader.addAfterCloseCall(killOceanaAudioSwf);
        oceanaFader.addAfterCloseCall(oceanaFlash.destroyOverlay.bind(oceanaFlash));
        oceanaFader.addAfterCloseCall(cmCreatePageElementTag, ['Oceana Sitelet  Close', 'LM Oceana Flash Sitelet w/video_2010']);
		
		var closeOceanaSitelet = oceanaFader.closeEffect.bindAsEventListener(oceanaFader);
		var openOceanaSitelet = oceanaFader.openEffect.bindAsEventListener(oceanaFader);
        Event.observe ($('flash_overlay_oc_tint'), 'click', closeOceanaSitelet);
		Event.observe ($('oceana_close_button'), 'click', closeOceanaSitelet);
		var oceanaLanding;
		if (oceanaLanding = $('oceana_landing')) {
			Event.observe (oceanaLanding, 'click', openOceanaSitelet);
			oceanaFader.openEffect();
		}
		
    }
	
	if ($('spp_content_container')) {
		var consultExpander = new ElemToggleEffect ({targetElement: 'consult_expanded', effectToggleType: 'blind',  duration: 0.3, delay: 0.2, transition: Effect.Transitions.sinoidal});
        var consultSwitch = new ElemEffectSwitch({indicatorClass: 'consultExpander', openedClass: 'toggle_onstate', openedOverClass: 'on_over', closedClass: 'toggle_offstate', closedOverClass: 'off_over', trigger: 'consultTrigger', elementEffect: consultExpander});
		
		var learnMoreExpander = new ElemToggleEffect ({targetElement: 'long_description_expander', effectToggleType: 'blind',  duration: 0.5, delay: 0.3, transition: Effect.Transitions.sinoidal});
		var learnMoreSwitch = new ElemEffectSwitch({indicatorClass: 'learnMoreExpander', openedClass: 'toggle_onstate', openedOverClass: 'on_over', closedClass: 'toggle_offstate', closedOverClass: 'off_over', trigger: 'learnMoreTrigger', elementEffect: learnMoreExpander});
		
		var replenishInfoFader = new ElemToggleEffect ({targetElement: 'replenish_info_box', effectToggleType: 'appear',  duration: 0.5, delay: 0.3, transition: Effect.Transitions.sinoidal});
		var replenishInfoSwitch = new ElemEffectSwitch({indicatorClass: 'infoFader', openedClass: 'toggle_onstate', openedOverClass: 'on_over', closedClass: 'toggle_offstate', closedOverClass: 'off_over', closeButtonClass: 'close_button', trigger: $$('.info_box_trigger'), elementEffect: replenishInfoFader});
		
		
		var sppReplenishment = new Replenishment('replenish_options_box', product_list, products);
		
		if ($('spp_content_container').hasClassName('shaded')) {
			var skuSelect = new SkuSelectChangeListener();
			var swatchUtils = new SwatchUtils($('big_swatch'), product_list, products, '_off', '_on');
		}
	}
	

	
	if ($('reviews_main')) {
		var helpFader = new ElemToggleEffect ({targetElement: 'reviews_help_box', effectToggleType: 'appear',  duration: 0.5, delay: 0.3, transition: Effect.Transitions.sinoidal});
		var guidelinesFader = new ElemToggleEffect ({targetElement: 'reviews_guidelines_box', effectToggleType: 'appear',  duration: 0.5, delay: 0.3, transition: Effect.Transitions.sinoidal});
		helpFader.addBeforeOpenCall(function(){
			if (! guidelinesFader.isClosed()) {
				guidelinesFader.closeEffect();
			}
		});
		
		guidelinesFader.addBeforeOpenCall(function(){
			if (! helpFader.isClosed()) {
				helpFader.closeEffect();
			}
		});
		
		
		var helpSwitch = new ElemEffectSwitch({indicatorClass: 'helpFaderSwitch', openedClass: 'toggle_onstate', openedOverClass: 'on_over', closedClass: 'toggle_offstate', closedOverClass: 'off_over', closeButtonClass: 'close_button', trigger: 'reviews_help', elementEffect: helpFader });
		var guidelinesSwitch = new ElemEffectSwitch({indicatorClass: 'guidelinesFaderSwitch', openedClass: 'toggle_onstate', openedOverClass: 'on_over', closedClass: 'toggle_offstate', closedOverClass: 'off_over', closeButtonClass: 'close_button', trigger: 'reviews_guidelines', elementEffect: guidelinesFader });
		var guidelinesSwitch2 = new ElemEffectSwitch({indicatorClass: 'guidelinesFaderSwitch', openedClass: 'toggle_onstate', openedOverClass: 'on_over', closedClass: 'toggle_offstate', closedOverClass: 'off_over', closeButtonClass: 'close_button', trigger: 'reviews_guidelines2', elementEffect: guidelinesFader });
	}
});