/* Common JS */

/* rotating masthead images for Corporate Home */

function RotatingMasthead(ArgumentsObj) {
    /* Arg Defaults */
    var NewArguments = { DOMObject : false, ImageFileNames: false };
    /* Replace Default Args */
    for (var argName in ArgumentsObj) {
       NewArguments[argName] = ArgumentsObj[argName];
    }
    /* Set Obj Properties from Args */
    this.DOMObject = NewArguments.DOMObject;
    this.ImageFileNames = NewArguments.ImageFileNames;

    this.pickImage = function() {
        var randomRange = this.ImageFileNames.length - 1;
        var randomNumber = (Math.round((Math.random()*randomRange)+1));
        var newImg = this.ImageFileNames[randomNumber-1];
        this.swapImage(newImg);
    }

    this.swapImage = function(newImageName) {
        if (this.DOMObject) {
            this.DOMObject.style.backgroundImage = 'url(images/'+newImageName+')';
        }
    }
    this.pickImage();
}

RotatingMastheadsInit = function() {
    Mastheads = new Object(); 
    Mastheads.Instances = new Array();

    var elementRefs = new Array(
        '.masthead.corporate',
        '.masthead.medicare'
        );
    var imageRefs = new Array(
        new Array(
            'Corporate.Masthead.OrchardFun.jpg',
            'Corporate.Masthead.FamilyTrio.jpg',
            'Corporate.Masthead.BeachGirls.jpg',
            'Corporate.Masthead.BeachCuddle.jpg'),
        new Array(
            'Medicare.Masthead.Grandchildren.jpg',
            'Medicare.Masthead.SummerDrinks.jpg')
        ); 
    for(var i=0, l = elementRefs.length; i < l; i++){
        var elRef = elementRefs[i];
        var images = imageRefs[i];
        if ((elObjs = $A($$(elRef))) && (elObjs.length > 0)) {
            elObjs.each( function(el){
                var mast = new RotatingMasthead({ DOMObject:el, ImageFileNames:images });
                Mastheads.Instances.push(mast);
            });
        }
    }
}
Event.observe(document, 'dom:loaded', RotatingMastheadsInit, false);


/* hover states for buttons, since IE6 does     *
 * not support CSS :hover an anything but <a>  */

function HoverableButton(ArgumentsObj) {
    /* Arg Defaults */
    var NewArguments = { DOMReference : false, styleClass : false };
    /* Replace Default Args */
    for (var argName in ArgumentsObj) {
       NewArguments[argName] = ArgumentsObj[argName];
    }
    /* Set Obj Properties from Args */
    this.DOMObject = NewArguments.DOMReference;
    this.className = NewArguments.styleClass;

    this.doHover = function() {
        button = this.DOMObject;
        var defaultClass = this.className;
        var hoverClassSuffix = 'Hover';
        var hoverClass = defaultClass+hoverClassSuffix;
        button.toggleClassName(hoverClass);
        button.toggleClassName(defaultClass);
    }

    this.setupEvents = function() {
        var buttonObj = this;
        className = buttonObj.className;
        Event.observe(this.DOMObject, 'mouseover', function(){ buttonObj.doHover(); }, false);
        Event.observe(this.DOMObject, 'mouseout', function(){ buttonObj.doHover(); }, false);
    }

    this.setupEvents();
    return true;
}

ButtonHovers = new Object();
ButtonHovers.init = function() {
    //check for IE6 using Dean Edward method 
    var IE6 = false /*@cc_on || @_jscript_version < 5.7 @*/;
    if(!IE6) return;

    ButtonHovers.buttons = new Array();
    var elementClassNames = new Array('purpleButton','arrow','controlTextBase','controlTextLarger','controlTextLargest');

    for(var i=0, l = elementClassNames.length; i < l; i++){
        var className = elementClassNames[i];
        if ((buttonRefs = $A($$('.'+className))) && (buttonRefs.length > 0)) {
            buttonRefs.each( function(buttonRef){
                var button = new HoverableButton({ DOMReference:buttonRef, styleClass:className });
                ButtonHovers.buttons.push(button);
            });
        }
    }
}
Event.observe(window, 'load', ButtonHovers.init, false);


/* Custom Lytebox Modification, Use an alternate close button */
Event.observe(window, 'load', lyteboxModInit, false);

function lyteboxModInit() {
    this.closeBox = function() {
        if (window.parent.myLytebox) {
            window.parent.myLytebox.end();
        } else {
            window.close();
        }
    }
    LyteBoxInit = this;
    cControls = $A($$('p#controlClose'));
    if (cControls.length > 0) {
        cControls.each( function(controlClose){
            Event.observe(controlClose, 'click', function(){ LyteBoxInit.closeBox(); return false; }, false);
            Event.observe(controlClose, 'mouseover', function(){ this.addClassName('hover'); return false; }, false);
            Event.observe(controlClose, 'mouseout', function(){ this.removeClassName('hover'); return false; }, false);
        });
    }
}

/* Tabs Interface */

Event.observe(document, 'dom:loaded', tabsInit, false);

function tabsInit() {
	/* setup tabs object */
	TabsModel = Object;
	TabsModel.tabLabelNameSpace = 'div.main div.pageBody div.leftColumn dl.sectionTabs > dt';
	TabsModel.tabNameSpace = 'div.main div.pageBody div.leftColumn dl.sectionTabs > dd';

	/* assign event handlers to tab controls/labels */
    tabControls = $A($$(TabsModel.tabLabelNameSpace));
	if (tabControls.length) {
		tabControls.each( function(tabC){
			Event.observe(tabC, 'click', function(){ return function(){ showTab(tabC); }(tabC); }, false);
			Event.observe(tabC, 'mouseover', function(){ 
					if (!tabC.className.match(/active/)) { 
					tabC.addClassName('hover'); 
					}
				}, false);
			Event.observe(tabC, 'mouseout', function(){ tabC.removeClassName('hover'); }, false);
		});
		/* show first tab */
		showTab(tabControls[0]);
	}
}

function showTab(tabC) {
	/* hide all tabs */
	if (tabs = $A($$(TabsModel.tabNameSpace))) {
		hideall(tabs);
	}
	/* switch all tab labels to inactive state */
	if (tabControls = $A($$(TabsModel.tabLabelNameSpace))) {
		tabControls.each( function(tabC){
			tabC.removeClassName('active');
			tabC.removeClassName('hover');
		});
	}
	/* show tab for clicked label */
	tabSelector = TabsModel.tabNameSpace + '.' + tabC.className;
	if (tabs = $A($$(tabSelector))) {
		tabs.each( function(tab){ tab.show(); } );
	}
	/* switch clicked label to active state */
	tabC.addClassName('active');
	
}

function hideall(elements) {
	elements.each( function(el){ el.hide(); } );
}


/* Call To Action boxes */

function CallToAction(ArgumentsObj) {
    /* Arg defaults */
    var NewArguments = { DOMReference : false };
    /* Replace default args */
    for (var argName in ArgumentsObj) {
       NewArguments[argName] = ArgumentsObj[argName];
    }
    /* Set Obj properties from args */
    this.DOMObject = NewArguments.DOMReference;

    /* More Obj Properties */
    this.containerObject = this.DOMObject.ancestors()[1];
    this.containerClass = this.containerObject.className.match(/^\w+/);

    this.doHover = function() {
        this.containerObject.addClassName(this.containerClass+'Hover');
        this.containerObject.removeClassName(this.containerClass);
        this.containerObject.style.cursor = 'pointer'; 
    }

    this.undoHover= function() {
        this.containerObject.addClassName(this.containerClass);
        this.containerObject.removeClassName(this.containerClass+'Hover'); 
    }

    this.handleClick = function() {
        /* Inherit HTML target attribute behaviors */
        if (this.target && (this.target === "_new" || this.target === "_blank")) {
            /* Create a new window for the link */
            var newWindowName = "callToActionDestination"+this.DOMObject.id;
            var newWindow=window.open(this.href,newWindowName);
        } else {
            /* Link to same window */
            window.location = this.href; 
       }
    }

    this.disableNativeAnchor = function() {
        /* Copy DOM Obj properties into JS Obj and  
           then clear them so only JS will handle them */
        this.href = this.DOMObject.href;
        this.DOMObject.removeAttribute("href");
        this.target = this.DOMObject.target;
        this.DOMObject.removeAttribute("target");
    }

    this.setupEvents = function() {
        var CTAObj = this;
        Event.observe(this.containerObject, 'click', function(){ CTAObj.handleClick(); }, false);
        Event.observe(this.containerObject, 'mouseover', function(){ CTAObj.doHover(); }, false);
        Event.observe(this.containerObject, 'mouseout', function(){ CTAObj.undoHover(); }, false);
    }

    this.disableNativeAnchor();
    this.setupEvents();
    return true;
}

function DOMObjectsIDCollector() {
    this.create = function() {
        self.IDCollection = new Array();
    }
    this.destroy = function() {
        self.IDCollection = null;  
    }
    this.reset = function() {
        self.destroy();
        self.create();
    }
    this.push = function(newEl) {
        if (self.IDCollection) {
           self.IDCollection.push(newEl); 
        } else {
            return false;
        }
    }
    this.isIDUnique = function(IDCompareLeft) {
        $A(self.IDCollection).each( function(IDCompareRight){
            if (IDCompareLeft === IDCompareRight) {
                return false;   
            }
        });
        return true;
    }
    var self = this;
    this.create();
    return true;
}

function callToAction_init() {
	/*
	Add hover and click state to containers with
    anchors inside them, 2nd level down, aka
    dl > dt > a OR div > h6 > a
	____________________________________________*/
	
    /* Setup and Config */
    var CallToActionBoxes = new Array();
    var DOMIDUtil = new DOMObjectsIDCollector();

    /* Input as CSS selectors for use with prototype.js */
    var cssStyleSelectors = new Array('dl.callToActionWide a','dl.callToActionMed a','dl.callToAction a','dl.callToActionTiny a','dl.retireeSolutions a','dl.healthRecords a','dl.behavioralBenefits a','dl.providerPair a','dl.readingBanner a','dl.laptopSideBanner a','dl.medChartBanner a','dl.ourOfferings a','dl.ourTeam a','dl.emailBanner a','dl.news a','dl.docList a','dl.miniBanner a','dl.doctorsBanner a','dl.careGivers a','dl.mailRequest a','dl.navBox a','dl.planningCallout a','dl.nationalExercise a','dl.portalDemo a','dl.enrollment a','dl.serviceArea a','dl.requestMore a');

    /* Loop over the CSS selector strings */
    for(var i=0, l = cssStyleSelectors.length; i < l; i++){

        /* Create an array of prototype.js DOM objects */
        var DOMObjects = $A($$(cssStyleSelectors[i]));

        /* reset a uniqueness util used in following loop */
        DOMIDUtil.reset();

        /* Iterate over each Obj / layout element */
        DOMObjects.each( function(obj,index){

            /* We only need the first anchor in each Call to Action box 
               Determine this carefully since collecting prototype DOM Objs 
               by CSS selector can group them from separate layout boxes into
               this loop. Instead of iteration order, use parent object's id */
            var parentObj = obj.ancestors()[1];
            var parentID = parentObj.identify();
            
            /* Add parentID to collection */
            DOMIDUtil.push(parentID);

            /* Is parentID for this layout obj unique? */
            if (DOMIDUtil.isIDUnique(obj.id)) {
                /* Enhance it, create a new Call To Action JS Obj */
                var newCall = new CallToAction({ DOMReference:obj });
                CallToActionBoxes.push(newCall);
            } else {
                /* It's in a box that's already activated, so don't create a duplicate 
                   Call To Action JS Obj but still disable the native HTML anchor behavior */
                obj.removeAttribute("href");
                obj.removeAttribute("target");
            }
        });
    }

    /* unset DOMIDUtil */
    DOMIDUtil.destroy();
}
Event.observe(window, 'load', callToAction_init, false);


/* Print page function */

PrintPage = new Object();

PrintPage.init = function() {
    if (printEls = $A($$('div.pageFunctions ul li.printPage'))) {
        printEls.each( function(pControl){
            Event.observe(pControl, 'click', function(){ window.print(); }, false);
        });
    }
}

//print page init listener
Event.observe(window, 'load', PrintPage.init, false);


/* Get State Links function */

selectButton = new Object();

selectButton.init = function() {
    if (selectBtn = $A($$('.stateSubmit'))) {
        selectBtn.each( function(obj){
            Event.observe(obj, 'click', function(){ GetState(obj);return false; }, false);
        });
    }
}

//init listener
Event.observe(window, 'load', selectButton.init, false);

function GetState(button)
{
    var formField = button.up(0);
    var arrSelect = formField.getElementsByTagName("select");
    var boxObj = formField.up(0);
    var stateDivs;
    var i;
    
    var stateVal = arrSelect[0].options[arrSelect[0].selectedIndex].value;
    
    stateDivs = boxObj.getElementsByTagName("div");
            
    for(i=0;i<stateDivs.length; i++)
    {
        stateDivs[i].style.display="none";
    }
            
    if (arrSelect[0].selectedIndex != 0)
    {
        if ( $(stateVal) )
        {
            
            $(stateVal).show();
        }
        else
        {
            alert("No disponible");
        }
    }
    
    return false;
    
}


/* Text size page function         *
 * Allow user to set font size via 3 controls: *
 * Base: default, normal size                  *
 * Larger: one size larger                     *
 * Largest: largest size                       *
 * The setting is retained across page loads   *
 * via cookie                                  */

function DocumentStyleSheetsUtil() {
    this.styleSheets = document.styleSheets;
    this.selectorTexts = new Array();
    this.matchingCSSText = '';

    this.selectorsMatch = function(selectorCompareLeft) {

        for(var i=0, l = self.selectorTexts.length; i < l; i++){
            var selectorCompareRight = self.selectorTexts[i];
            if ( selectorCompareRight.match(selectorCompareLeft) ){
                return true;
            }
        }

        return false;
    }

    this.extractCSSValue = function() {
        var value = "CSSValue-dummyValue";
        var propValueString = self.matchingCSSText.replace(/^.+{(.*)}.*$/,'$1');
        var propertyValuePairs = propValueString.split(/;/);
        var replacePattern = /.*font-size.*:\s*([\d.]+)em/;
        var replacement = '$1';

        for(var i=0, l = propertyValuePairs.length; i < l; i++){
            var cssPair = propertyValuePairs[i];
            if (cssPair.match(self.propertyCSS)) {
                // ok to reset this if encounter more than one,
                // usually the last would be same as effective CSS
                value = cssPair.replace(replacePattern,replacement);
            }
        }

        return value;
    }

    this.doStyleSheetSelectorsMatch = function(ruleObject) {
        self.selectorTexts = ruleObject.selectorText.split(/,/);
        if (self.selectorsMatch(self.selectorCSS)) {
            self.matchingCSSText = ruleObject.cssText;
            if (self.matchingCSSText.match(self.propertyCSS)) {
                return true;
            }
        }
        return false;
    }

    this.styleSheetsInner = function(styleSheet) {
        var extracted = false;

        // Loop over styleSheet rules
        for(var m=0, p = styleSheet.cssRules.length; m < p; m++){

            var ruleObject = styleSheet.cssRules[m];

            // @import and other rules have different values for type property
            if (ruleObject.type == 1) {
                if (self.doStyleSheetSelectorsMatch(ruleObject)) {
                    extracted = self.extractCSSValue();
                }
            } else if (ruleObject.type == 3) {
                var importedStyleSheet = ruleObject.styleSheet;
                extracted = self.styleSheetsInner(importedStyleSheet);
            }
        }
        return extracted;
    }

    this.getStyleSheetValue = function(selector,property) {
        var CSSValue = false;
        self.selectorCSS = selector;
        self.propertyCSS = property;


        // Loop over the styleSheets
        for(var i=0, l = self.styleSheets.length; i < l; i++){

            var styleSheet = self.styleSheets[i];
            if (self.styleSheetsInner(styleSheet)) {
                CSSValue = self.styleSheetsInner(styleSheet);
            }

        }

        return CSSValue;
    }

    var self = this;
}

function ResizeException(ArgumentsObj) {
    /* Arg defaults */
    var NewArguments = {    
        DOMReference : false,
        selectorString : '',
        parentTextSizer : false
    };
    /* Replace default args */
    for (var argName in ArgumentsObj) {
       NewArguments[argName] = ArgumentsObj[argName];
    }
    /* Set Obj properties from args */
    this.DOMObject = NewArguments.DOMReference;
    this.selectorString = NewArguments.selectorString;
    this.parentTextSizer = NewArguments.parentTextSizer;
    this.exceptionSize = '';
    //this.originalSizeCSS = 1.27;
    this.originalSizeCSS = this.parentTextSizer.styleSheetsUtil.getStyleSheetValue(this.selectorString,'font-size');
    if (!this.originalSizeCSS) {
        this.originalSizeCSS = 1.27;
    }
    
    this.calculateResizeException = function() {
        // Setup for Maths Below
        var currentSize = parent.currentFontSize.replace(/em/,'');
        var documentBaseSize = parent.baseFontSize;
        var targetOrigSizeCSS = self.originalSizeCSS;

        var SizeCSS = null; //self.DOMObject.getStyle('font-size');
        if (!(SizeCSS === undefined) && !(SizeCSS === null) && !(SizeCSS.match(/px/))) {
            targetOrigSizeCSS = SizeCSS;
        }

        // Math, with floating point precision
        var exceptionSizeRough = ( documentBaseSize * targetOrigSizeCSS ) / currentSize;

        // Math, formatted as CSS value
        self.exceptionSize = Math.round(parseFloat(exceptionSizeRough)*100)/100 + 'em';
    }

    this.doResizeException = function() {
        self.DOMObject.style.fontSize = self.exceptionSize;
    }

    this.resetResizeException = function() {
        self.DOMObject.style.fontSize = '';
    }
    var self = this;
    var parent = self.parentTextSizer;
    return true;
}

function TextSizer() {
   this.captureFontSizeAfterLoad = function(){
       // Capture current font size. priority order: cookie, document, hardcoded
       if (self.getCookie('TextSize')) {
           self.originalFontSize = self.getCookie('TextSize');
       } else if (MainEls = $A($$('div.main'))) {
           if (MainEls.length > 0) {
               MainEls.each( function(main){
                   if (cSize = main.style.fontSize) {
                       self.originalFontSize = cSize;
                   } else {
                       self.originalFontSize = self.baseFontSize + 'em';
                   }
               });
           } else {
               self.originalFontSize = self.baseFontSize + 'em';
           }
       }
       self.currentFontSize = self.originalFontSize;
   }
   
   this.extractDOMObjects = function(){
        if ((controlBase = $('controlTextBase')) && (controlLg = $('controlTextLarger')) && (controlLgst = $('controlTextLargest'))) {
            self.controls = new Array;
            self.controls['base'] = controlBase;
            self.controls['large'] = controlLg;
            self.controls['largest'] = controlLgst;
        }
   }

   this.attachEventHandlers = function(){

        var controlBase = self.controls['base'];
        var controlLg = self.controls['large'];
        var controlLgst = self.controls['largest'];

        // attach events to smallest control
        Event.observe(controlBase, 'click', function(controlBase){ return function(){self.revertSize(controlBase);} }(controlBase), false);

        // attach events to medium control
        var sizeRatio = self.sizeRatioLarger;
        Event.observe(controlLg, 'mouseover', function(){ this.addClassName('hover'); }, false);
        Event.observe(controlLg, 'mouseout', function(){ this.removeClassName('hover'); }, false);
        Event.observe(controlLg, 'click', function(sizeRatio,controlLg){ return function(){
            self.changeSize(sizeRatio,this);
        } }(sizeRatio,controlLg), false);

        // attach events to large control
        var sizeRatio = self.sizeRatioLargest;
        Event.observe(controlLgst, 'mouseover', function(){ this.addClassName('hover'); }, false);
        Event.observe(controlLgst, 'mouseout', function(){ this.removeClassName('hover'); }, false);
        Event.observe(controlLgst, 'click', function(sizeRatio,controlLgst){ return function(){
            self.changeSize(sizeRatio,this);
        } }(sizeRatio,controlLgst), false);
   }
   
   this.doSizesAfterLoad = function(){
        // Has sizing been set over base size? (cookie)
        // If so, adjust size to proper ratio using thresholds
        var currentSize = self.currentFontSize.replace(/[A-Za-z%]+/,'');

        if (currentSize > (self.baseFontSize * self.sizeRatioLarger)) { 
        // size setting is largest, so override doc default
            self.changeSize(self.sizeRatioLargest, self.controls['largest']);
        } else if (currentSize > self.baseFontSize) { 
        // size setting is larger than doc default, so override it
            self.changeSize(self.sizeRatioLarger, self.controls['large']);
        } else { 
        // set default
            self.revertSize(self.controls['base']);
        }
        return true;
   }
   
    this.changeSize = function(sizeRatio,control) {
        // Set controls to inactive state
        self.inactivateControls();

        // Activate current control
        if (!(control === undefined) && !(control === null) && !(control == '')){
            control.addClassName('active');
        }

        // Change font size to new ratio
        if (MainEls = $$('div.main')) {
            MainEls.each( function(main){
                var toSize = parseFloat(self.baseFontSize) * parseFloat(sizeRatio);
                toSize = toSize + 'em';
                main.style.fontSize = toSize;
                self.currentFontSize = toSize;
                self.setCookie('TextSize', toSize);
            });
        }

        // Calculate Exception sizes before changing size
        //self.calcResizeExceptions();

        // Handle Exceptions
        //self.doResizeExceptions();
   }

   this.revertSize = function(sourceControl) {
       // Set controls to inactive state
       self.inactivateControls();

       // Activate current control
       if (!(sourceControl === undefined) && !(sourceControl === null) && !(sourceControl == '')){
           sourceControl.addClassName('active');
       }

       // Revert font size to base font size
       if (MainEls = $$('div.main')) {
           MainEls.each( function(main){
               var revertTo = self.baseFontSize + 'em';
               main.style.fontSize = revertTo;
               self.currentFontSize = revertTo; 
               self.setCookie('TextSize', revertTo);
           });
       }

       // Revert exceptions as well
       //self.resetResizeExceptions();
   }

   this.calcResizeExceptions = function() {
        self.exceptions.each( function(e) {
            e.calculateResizeException();
        });
   }

   this.doResizeExceptions = function() {
        self.exceptions.each( function(e) {
            e.doResizeException();
        });
   }

   this.resetResizeExceptions = function() {
        self.exceptions.each( function(e) {
            e.resetResizeException();
        });
   }
   
   this.inactivateControls = function() {
       if (controls = $A($$('div.pageFunctions .textSize span'))) {
            self.controls = controls;         
            controls.each( function(el){
                el.removeClassName('active');
            });
        }
    }
   
    // Heinle's function for retrieving a cookie
    this.getCookie = function (name){
        var cname = name + "=";
        var dc = document.cookie;
        if (dc.length > 0) {
            begin = dc.indexOf(cname);
            if (begin != -1) {
                begin += cname.length;
                end = dc.indexOf(";", begin);
                if (end == -1) end = dc.length;
                return unescape(dc.substring(begin, end));
            }
        }
        return null;
    }

    // Adaptation of Dorcht's function for setting a cookie
    this.setCookie = function (name, value, expires, path, domain, secure) {
        document.cookie = name + "=" + escape(value) +
        ((expires == null) ? "" : "; expires=" + expires.toGMTString()) +
        ((path == null) ? "" : "; path=" + path) +
        ((domain == null) ? "" : "; domain=" + domain) +
        ((secure == null) ? "" : "; secure");
    }

    this.init = function() {
        // Font size ratios
        self.baseFontSize = 1.1;
        self.sizeRatioLarger = 1.2;
        self.sizeRatioLargest = 1.3;

        // Controls in layout (DOM Objects)
        self.controls = false;

        // Instantiate styleSheets util
        self.styleSheetsUtil = new DocumentStyleSheetsUtil();

        // Exceptions, input as a set of prototype.js objects
        self.exceptions = new Array();
        var exceptionSelectors = new Array(
            //top navigation, medicare
            //'div.medicare div.pageBody ul.topNav li a',
            //main masthead h1
            //'dl.masthead dt'
        );
        
        // Loop over exception cases
        for (i = 0, l = exceptionSelectors.length; i < l; i++) {
            var excSelector = exceptionSelectors[i];
            var exceptionObjs = $A($$(excSelector));

            // Create exception util objects for each text resize exception
            // Easier to handle each exception within its own scope
            exceptionObjs.each( function(exception) {
                var newException = new ResizeException({ DOMReference:exception, selectorString:excSelector, parentTextSizer:self });
                self.exceptions.push(newException);
            });

        }

        // run setup for DOM Objects (self controls) 
        self.extractDOMObjects();

        // If no widgets on page, exit! Don't do sizing
        if (!self.controls) {
            return true;
        }

        // remaining setup
        self.attachEventHandlers();
        self.captureFontSizeAfterLoad();
        self.doSizesAfterLoad();
    }

    var self = this;
    self.init();
}

// TextSize init listener
Event.observe(document, 'dom:loaded', function(){ var ts = new TextSizer(); }, false);