/************************* DivTrigger.js *************************
Version 2.8, modified to refactor functions to permit rescaling on resize.

PURPOSE
Lays a dynamically created, transparent "trigger" div over another "wrapped" div already in the HTML. The "trigger" permits zooming to a predetermined size on mouseover.

You can also manually double the image in the HTML with a "shadow" div containing a small version of the image. This serves as a placeholder for the image to be expanded.

ARGUMENTS
All dimensions include "px" unless indicated as Int.
argObj can include (* = required):
    wrappedElement*
    containerElement
    triggerWidth
    expandToWidth
	expandToElement
	expandToPercentage (if expandToElement, expandToWidth="80" is reinterpreted as 80% of expandToElement--else of screen.)
    triggerHeight
    triggerOffset (where the trigger lies relative to the wrapped div--usually "center")
    justification ("center", "upper-left", "lower-left", "upper-right", "lower-right", "center-right", "center-left", "center-top", "center-bottom")
    zoomDuration (milliseconds)
    incrementDuration (milliseconds)
	imageAspectRatioForIE ("2" is a horizontal rectangle; unnecessary for W3C browsers, which can read image height automatically. This allows arbitrary heights in actual HTML.)
    functionAtEnd (eg, function() { alert(this) } )
    functionReturning (eg, function() { alert(this) } )
    functionOnClick (eg, function() { alert(this) } )

TRIGGER STYLES
You set the other style properties in a CSS class called zoomTrigger.
Give this class a low opacity (eg, .05) or IE6 will bubble incorrectly to the underlying div.

WRAPPED STYLES
You will probably want to give the div to zoom (the "wrapped" div) and its trigger (via CSS class "zoom-trigger") an absolute position.
If you want an image in that div to zoom, set its width to that of the wrapped div, eg "#div-containing-image-to-expand img { width: 100% }"
For IE to work, you need to set the positions of the wrapped divs directly in HTML, or you can't refer to them in this constructor, eg <div id="div-containing-image-to-expand" style="top:0px; left:0px; width: 200px">...

INITIALIZING ZOOMTRIGGER
Onload, call some variation of this:
	new ZoomTrigger({
	    wrappedElement: document.getElementById("div-containing-image-to-expand") ,
	    containerElement: document.getElementById("div-containing-that-div"),
	    expandToWidth: "500px"
	 }) ;

UPGRADE
Future versions should permit setting animation parameters (eg, opacity and increment of "20") via argObj. Also clarify terms: Rename "wrapper" to "trigger" and "shadow" to "placeholder" here and below for clarity.
**************************************/
// Create managers.
zoomContainers = [] ; // Used for adjusting z-index on zoom.
zoomTriggerObjs = [] ; // Used for adjusting percentages on window resize.
function assignZoomDimensions ( zoomTriggerObj ) {
	// Called onload and on resize when percentages are involved. Returns pixel value.
	/*__________ Calculate animation parameters. Note that it's crucial not to reduce the increments to integers too soon. __________*/
	// Calculate expandToWidth.
	_offsetW = zoomTriggerObj.htmlElement.expandToElement.offsetWidth; debug("_offsetW", 2) ;
	expandToPercentage = zoomTriggerObj.htmlElement.expandToPercentage; debug("expandToPercentage", 2) ;
	if ( zoomTriggerObj.htmlElement.expandToElement ) { // For use with image-floater class.
		if ( zoomTriggerObj.htmlElement.expandToPercentage  ) { // Instead of rewriting everything in percentages, I'm cheating by converting first to pixels.
			zoomTriggerObj.htmlElement.expandToWidth = parseInt( zoomTriggerObj.htmlElement.expandToElement.offsetWidth * ( zoomTriggerObj.htmlElement.expandToPercentage  / 100 ) ) + "px" ;
			expandToWidthAfter = zoomTriggerObj.htmlElement.expandToWidth; debug("expandToWidthAfter", 3) ;
		}
		else { // Expand to the full width (100%) of an element.
			zoomTriggerObj.htmlElement.expandToWidth = zoomTriggerObj.htmlElement.expandToElement.offsetWidth + "px" ;
		}
	}
	else if ( zoomTriggerObj.htmlElement.expandToPercentage ){ // Expand to percentage of screen.
		zoomTriggerObj.htmlElement.expandToWidth = parseInt( browsers.screenWidth() * ( zoomTriggerObj.htmlElement.expandToPercentage  / 100 ) ) + "px" ;
	}
    zoomTriggerObj.htmlElement.numberOfSteps = parseInt( zoomTriggerObj.htmlElement.zoomDuration / zoomTriggerObj.htmlElement.incrementDuration ) ;
	_zoomDur = zoomTriggerObj.htmlElement.zoomDuration; debug("_zoomDur", 2) ;
	_incDur = zoomTriggerObj.htmlElement.incrementDuration; debug("_incDur", 2) ;
    // Pre-calculate and populate an array with all the widths required for the zoom.
    zoomTriggerObj.htmlElement.zoomWidthDifference = parseInt(zoomTriggerObj.htmlElement.expandToWidth) - parseInt(zoomTriggerObj.htmlElement.shrinkToWidth) ;
	_shrink = zoomTriggerObj.htmlElement.shrinkToWidth; debug("_shrink", 2) ;
    zoomTriggerObj.htmlElement.zoomWidthIncrementFlo =  zoomTriggerObj.htmlElement.zoomWidthDifference / zoomTriggerObj.htmlElement.numberOfSteps-1 ; // Also used below for centering. Floating point number.
	_zoomWDiff = zoomTriggerObj.htmlElement.zoomWidthDifference; debug("_zoomWDiff", 2) ;
	_numSteps = zoomTriggerObj.htmlElement.numberOfSteps; debug("_numSteps", 2) ;
    zoomTriggerObj.htmlElement.zoomWidthArray = new Array() ;
    for( var stepNum = 0 ; stepNum < zoomTriggerObj.htmlElement.numberOfSteps ; stepNum++ ){
        zoomTriggerObj.htmlElement.zoomWidthArray[stepNum] = Math.round(    parseInt(zoomTriggerObj.htmlElement.shrinkToWidth) + (  ( zoomTriggerObj.htmlElement.zoomWidthIncrementFlo ) * stepNum  )    ) ;
    }
    zoomTriggerObj.htmlElement.zoomHeightIncrementFlo = zoomTriggerObj.htmlElement.zoomWidthIncrementFlo / zoomTriggerObj.htmlElement.aspectRatio ;
	zoomHeightIncrementFlo =	zoomTriggerObj.htmlElement.zoomHeightIncrementFlo ; debug("zoomHeightIncrementFlo") ;
}
function ZoomTrigger(argObj) {
    // Create the trigger div that overlays the div to expand.
    this.htmlElement = document.createElement('div') ;
    this.htmlElement.containerElement = (typeof argObj.containerElement == "undefined" )? document.body : argObj.containerElement ;
	this.htmlElement.containerElement.appendChild(this.htmlElement) ;
	zoomContainers.push( this.htmlElement.containerElement ) ;
    // Define handles.
    this.htmlElement.JSObject = this ;
    this.htmlElement.id = "wrapper-for_" + argObj.wrappedElement.id ; // UPGRADE: Consider renaming to trigger_for -- is that more consistent?
    this.htmlElement.wrappedElement = argObj.wrappedElement ; // The image div inside the rollover div.
    this.htmlElement.wrappedElement.triggerElement = this.htmlElement ;
	// Determine original dimensions and aspectRatio.
	if (browsers.ie || browsers.saf) { // IE SUCKS!!
		if ( argObj.imageAspectRatioForIE ) { // Originally written inline as a custom HTML attribute for the "zoomable" div.
		    this.htmlElement.aspectRatio = argObj.imageAspectRatioForIE ;
		}
		else if (browsers.ie) { // Arbitrary, but corrects for IE's inability to set overflow: visible for vertical images in horizontal divs.
		    this.htmlElement.aspectRatio = .7 ;
		}
	}
	else { // A decent browser.
		// If you can get the original image height, that's more reliable than the one written inline. Note however that defining height inline may be necessary to manipulate it with ZoomTrigger.js.
		var imageSourceHeightInt = this.htmlElement.wrappedElement.getElementsByTagName("img")[0].height ;
		this.htmlElement.imageHeightInt = ( (typeof imageSourceHeightInt != "undefined") && (imageSourceHeightInt > 0) )? imageSourceHeightInt : this.htmlElement.wrappedElement.style.height ;
	    this.htmlElement.aspectRatio = parseInt( this.htmlElement.imageHeightInt ) / parseInt(this.htmlElement.wrappedElement.style.width) ;
	}
    // Set the target sizes for the wrapped div's expansion and contraction. Default value is arbitrary.
    this.htmlElement.shrinkToWidth =  (typeof argObj.shrinkToWidth == "undefined" )? this.htmlElement.wrappedElement.style.width  : argObj.shrinkToWidth ;
    this.htmlElement.shrinkToHeight =  (typeof argObj.shrinkToHeight == "undefined" )? this.htmlElement.wrappedElement.style.height  : argObj.shrinkToHeight ;
    this.htmlElement.expandToWidth =  (typeof argObj.expandToWidth == "undefined" )? "300px" : argObj.expandToWidth ;
    this.htmlElement.expandToPercentage =  (typeof argObj.expandToPercentage == "undefined" )? false : argObj.expandToPercentage ;
    this.htmlElement.expandToElement =  (typeof argObj.expandToElement == "undefined" )? false : argObj.expandToElement ;
	// Register animation parameters.
    this.htmlElement.justification =  (typeof argObj.justification == "undefined" )? "center" : argObj.justification ;
    this.htmlElement.zoomDuration =  (typeof argObj.zoomDuration == "undefined" )? 300 : argObj.zoomDuration ; // Was 500.
    this.htmlElement.incrementDuration =  (typeof argObj.incrementDuration == "undefined" )? 50 : argObj.incrementDuration ; // Was 50.
	// Enable expanding to an element's size or percentage. Note that these are set on load and, for percentages, on resize.
	assignZoomDimensions( this ) ; // A function so you can call on resize.
    this.htmlElement.expandToHeight = parseInt( parseInt(this.htmlElement.expandToWidth) / this.htmlElement.aspectRatio ) + "px" ;
    // Size the trigger div. Default values are arbitrary.
    this.htmlElement.style.width = (typeof argObj.triggerWidth == "undefined" )? this.htmlElement.expandToWidth : argObj.triggerWidth ;
    this.htmlElement.style.height = (typeof argObj.triggerHeight == "undefined" )? this.htmlElement.expandToHeight : argObj.triggerHeight ;
    // Style the trigger div via the CSS class zoomTrigger.
    this.htmlElement.className = "zoom-trigger" ;
    this.htmlElement.style.zIndex = 100 ;
    // Position the trigger div.
    this.htmlElement.triggerOffset =  (typeof argObj.triggerOffset == "undefined" )? "center" : argObj.triggerOffset ;
    this.htmlElement.style.position = "absolute" ;
    var triggerWidthInt = parseInt(this.htmlElement.style.width) ;
    // DEBUG: jon changed these from variables to properties so they could be referenced later.
    this.htmlElement.wrappedElement.wrappedLeftInt = parseInt(this.htmlElement.wrappedElement.style.left) ;
    this.htmlElement.wrappedElement.wrappedWidthInt = parseInt(this.htmlElement.wrappedElement.style.width) ;
    var triggerHeightInt = parseInt(this.htmlElement.style.height) ;
    this.htmlElement.wrappedElement.wrappedTopInt = parseInt(this.htmlElement.wrappedElement.style.top) ;
    this.htmlElement.wrappedElement.wrappedHeightInt = parseInt(this.htmlElement.wrappedElement.style.height) ;
    switch (this.htmlElement.triggerOffset) { // I don't think this will get used that often, so I didn't finish many options here. UPGRADE: It could also be used to offset by particular px values.
        case "center" :
			var leftPx = parseInt(this.htmlElement.wrappedElement.wrappedLeftInt + this.htmlElement.wrappedElement.wrappedWidthInt/2 - triggerWidthInt/2) + "px" ;
            this.htmlElement.style.left = leftPx ;
			var topPx =  parseInt(this.htmlElement.wrappedElement.wrappedTopInt + this.htmlElement.wrappedElement.wrappedHeightInt/2 - triggerHeightInt/2) + "px" ;
            this.htmlElement.style.top = topPx ;
            break ;
        case "upper-left" :
            this.htmlElement.style.top = this.htmlElement.wrappedElement.style.top ;
            this.htmlElement.style.left = this.htmlElement.wrappedElement.style.left ;
            break ;
        case "upper-right" :
            this.htmlElement.style.left = this.htmlElement.wrappedElement.wrappedLeftInt + this.htmlElement.wrappedElement.wrappedWidthInt - triggerWidthInt + "px" ;
            this.htmlElement.style.top = this.htmlElement.wrappedElement.style.top ;
            break ;
    }
    // Opacities aren't as fussy as widths, so you don't need an array with all the opacities required for the zoom.
    // UPGRADE: Enable zoom to sub-100% opacity.
    if (browsers.ie) {
        this.htmlElement.opacityDifference = 100 - eval(this.htmlElement.wrappedElement.filters.alpha.opacity) ;
        this.htmlElement.opacityIncrement = parseInt( this.htmlElement.opacityDifference / this.htmlElement.numberOfSteps ) ;
    }
    else {
        this.htmlElement.opacityDifference = 1 - eval(this.htmlElement.wrappedElement.style.opacity) ;

        this.htmlElement.opacityIncrement = this.htmlElement.opacityDifference / this.htmlElement.numberOfSteps ;
    }
    // Rolling over this trigger div should zoom the wrapped div.
    this.htmlElement.onmouseover = function() { startExpansionLoop(this) ; } ;
    this.htmlElement.onmouseout =  function() { startContractionLoop(this) ; } ;
    // These flags keep weird loops from happening.
    this.htmlElement.wrappedElement.isExpanding = false ;
    this.htmlElement.wrappedElement.isContracting = false ;
    // Add function call for various stages of the zoom.
    this.htmlElement.functionAtEnd = (argObj.functionAtEnd)? argObj.functionAtEnd : "" ;
    this.htmlElement.functionReturning = (argObj.functionReturning)? argObj.functionReturning : "" ;
    this.htmlElement.onclick = (argObj.functionOnClick)? argObj.functionOnClick : "" ;
	/*__________ Add this object to manager. __________*/
	zoomTriggerObjs.push( this ) ; // Don't need more handles at this point.
}
function startExpansionLoop( triggerMousedOnEle ) { // The arg is the overlay div that was moused over or off.
//     gonnaExpandTo = triggerMousedOnEle.expandToWidth; debug( "gonnaExpandTo" )
    if (triggerMousedOnEle.wrappedElement.isExpanding || triggerMousedOnEle.wrappedElement.isContracting) {
         // Don't interfere with existing zooms.
//         expansionNotTriggeredFor = triggerMousedOnEle.id; debug("expansionNotTriggeredFor") ;
    }
    else {
        triggerMousedOnEle.wrappedElement.isExpanding = true ;
//         triggerEleExpanding_id = triggerMousedOnEle.id ; debug("triggerEleExpanding_id") ;
        triggerMousedOnEle.stepNum = 0 ;
        triggerMousedOnEle.expandLoop = setInterval(   function() {  expandDivABit(triggerMousedOnEle) } , triggerMousedOnEle.incrementDuration ) ; // 50    ) ;
     }
}
function startContractionLoop( triggerMousedOffEle ) { // The arg is the overlay div that was moused over or off.
//     gonnaContractTo = triggerMousedOffEle.shrinkToWidth ; debug("gonnaContractTo")
    if (triggerMousedOffEle.wrappedElement.isContracting) {  // Don't interfere with existing contraction.
//         contractionNotTriggeredFor = triggerMousedOffEle.id; debug("contractionNotTriggeredFor") ;
    }
     else {
         if (triggerMousedOffEle.expandLoop) { // Abort any expansions in process.
             clearInterval(triggerMousedOffEle.expandLoop) ;
             triggerMousedOffEle.wrappedElement.isExpanding = false ;
        }
        // Begin contraction.
        triggerMousedOffEle.wrappedElement.isContracting = true ;
//         triggerEleContracting_id = triggerMousedOffEle.id ; debug("triggerEleContracting_id") ;
        triggerMousedOffEle.shrinkLoop = setInterval(   function() {  contractDivABit(triggerMousedOffEle) } , triggerMousedOffEle.incrementDuration ) ; //50    ) ;
        if (triggerMousedOffEle.functionReturning) eval( triggerMousedOffEle.functionReturning() ) ;
    }
}
function expandDivABit(triggerExpandingEle) {
	expandDivABit_triggerExpandingEle = triggerExpandingEle.id; debug("expandDivABit_triggerExpandingEle") // DEBUGGING.
    triggerExpandingEle.stepNum++
    if (triggerExpandingEle.stepNum >= triggerExpandingEle.numberOfSteps) { // Stop expanding.
        clearInterval(triggerExpandingEle.expandLoop) ;
        triggerExpandingEle.wrappedElement.isExpanding = false ;
        if (browsers.ie) {
            triggerExpandingEle.wrappedElement.filters.alpha.opacity = 100 ;
        }
        else {
            triggerExpandingEle.wrappedElement.style.opacity = 1 ; // DEBUG: added this.
        }
        if (triggerExpandingEle.functionAtEnd) eval( triggerExpandingEle.functionAtEnd() ) ;
		// Focus expanding div in front of all other divs. DEBUG: Added in v2.4 to prevent bad overlaps.
		for (var containerCounter=0; containerCounter < zoomContainers.length; containerCounter++) {
			zoomContainers[containerCounter].style.zIndex = 1 ;
		};
		_triggerExpandingEle_id = triggerExpandingEle.id; debug("_triggerExpandingEle_id", 4) ;
		triggerExpandingEle.containerElement.style.zIndex = 2 ;
    }
    else { // Continue expanding.
        triggerExpandingEle.wrappedElement.style.width = triggerExpandingEle.zoomWidthArray[triggerExpandingEle.stepNum] + "px" ;
        triggerExpandingEle.wrappedElement.style.height = parseInt( parseInt(triggerExpandingEle.wrappedElement.style.width) / triggerExpandingEle.aspectRatio ) + "px" ;
        switch (triggerExpandingEle.justification ) {
            case "center" :
                triggerExpandingEle.wrappedElement.style.left = parseInt( triggerExpandingEle.wrappedElement.style.left ) - parseInt(triggerExpandingEle.zoomWidthIncrementFlo/2) + "px" ;
                triggerExpandingEle.wrappedElement.style.top = parseInt( triggerExpandingEle.wrappedElement.style.top ) - parseInt(triggerExpandingEle.zoomHeightIncrementFlo/2) + "px" ;
                break ;
            case "upper-right" :
                triggerExpandingEle.wrappedElement.style.left = parseInt( triggerExpandingEle.wrappedElement.style.left ) - parseInt(triggerExpandingEle.zoomWidthIncrementFlo) + "px" ;
                break ;
            case "lower-left" :
                triggerExpandingEle.wrappedElement.style.top = parseInt( triggerExpandingEle.wrappedElement.style.top ) - parseInt(triggerExpandingEle.zoomHeightIncrementFlo) + "px" ;
                break ;
            case "lower-right" :
                triggerExpandingEle.wrappedElement.style.left = parseInt( triggerExpandingEle.wrappedElement.style.left ) - parseInt(triggerExpandingEle.zoomWidthIncrementFlo) + "px" ;
                triggerExpandingEle.wrappedElement.style.top = parseInt( triggerExpandingEle.wrappedElement.style.top ) - parseInt(triggerExpandingEle.zoomHeightIncrementFlo) + "px" ;
                break ;
            case "upper-left" :
                break ; // Divs naturally expand from this corner.
            case "center-right" :
                triggerExpandingEle.wrappedElement.style.left = parseInt( triggerExpandingEle.wrappedElement.style.left ) - parseInt(triggerExpandingEle.zoomWidthIncrementFlo) + "px" ;
                triggerExpandingEle.wrappedElement.style.top = parseInt( triggerExpandingEle.wrappedElement.style.top ) - parseInt(triggerExpandingEle.zoomHeightIncrementFlo/2) + "px" ;
                break ;
            case "center-left" :
                // triggerExpandingEle.wrappedElement.style.left = parseInt( triggerExpandingEle.wrappedElement.style.left ) + parseInt(triggerExpandingEle.zoomWidthIncrementFlo/2) + "px" ;
                triggerExpandingEle.wrappedElement.style.top = parseInt( triggerExpandingEle.wrappedElement.style.top ) - parseInt(triggerExpandingEle.zoomHeightIncrementFlo/2) + "px" ;
                break ;
            case "center-top" :
                triggerExpandingEle.wrappedElement.style.left = parseInt( triggerExpandingEle.wrappedElement.style.left ) - parseInt(triggerExpandingEle.zoomWidthIncrementFlo/2) + "px" ;
                break ;
            case "center-bottom" :
                triggerExpandingEle.wrappedElement.style.left = parseInt( triggerExpandingEle.wrappedElement.style.left ) - parseInt(triggerExpandingEle.zoomWidthIncrementFlo/2) + "px" ;
                triggerExpandingEle.wrappedElement.style.top = parseInt( triggerExpandingEle.wrappedElement.style.top ) - parseInt(triggerExpandingEle.zoomHeightIncrementFlo) + "px" ;
                break ;
        }
        if (browsers.ie) {
            triggerExpandingEle.wrappedElement.filters.alpha.opacity = eval( triggerExpandingEle.wrappedElement.filters.alpha.opacity ) + (triggerExpandingEle.opacityIncrement ) ; // Note that a crossbrowser opacityIncrement (100% v. 1) was normalized above.
        }
        else {
            triggerExpandingEle.wrappedElement.style.opacity = eval( triggerExpandingEle.wrappedElement.style.opacity ) + triggerExpandingEle.opacityIncrement  ;
        }
    }
}
function contractDivABit(triggerContractingEle) {
    triggerContractingEle.stepNum--
    if (triggerContractingEle.stepNum <= 0) { // Stop shrinking.
        // debug("'gonna stop shrinking now'")
        clearInterval(triggerContractingEle.shrinkLoop) ;
        triggerContractingEle.wrappedElement.isContracting = false ;
        // DEBUG: Jon added manual assignments below.
        triggerContractingEle.wrappedElement.style.left = triggerContractingEle.wrappedElement.wrappedLeftInt + "px" ;
        triggerContractingEle.wrappedElement.style.width = triggerContractingEle.wrappedElement.wrappedWidthInt + "px" ;
        triggerContractingEle.wrappedElement.style.top = triggerContractingEle.wrappedElement.wrappedTopInt + "px" ;
        triggerContractingEle.wrappedElement.style.height = triggerContractingEle.wrappedElement.wrappedHeightInt + "px" ;
        // debug("'stopped shrinking!'")
        // var contractionStoppedFor = triggerContractingEle.id ; debug("contractionStoppedFor") ;
    }
    else { // Continue shrinking.
        triggerContractingEle.wrappedElement.style.width = triggerContractingEle.zoomWidthArray[triggerContractingEle.stepNum] + "px" ;
        switch (triggerContractingEle.justification ) {
            case "center" :
                triggerContractingEle.wrappedElement.style.left = parseInt( triggerContractingEle.wrappedElement.style.left ) + parseInt(triggerContractingEle.zoomWidthIncrementFlo/2) + "px" ;
                triggerContractingEle.wrappedElement.style.top = parseInt( triggerContractingEle.wrappedElement.style.top ) + parseInt(triggerContractingEle.zoomHeightIncrementFlo/2) + "px" ;
                break ;
            case "upper-right" :
                triggerContractingEle.wrappedElement.style.left = parseInt( triggerContractingEle.wrappedElement.style.left ) + parseInt(triggerContractingEle.zoomWidthIncrementFlo) + "px" ;
                break ;
            case "lower-left" :
                triggerContractingEle.wrappedElement.style.top = parseInt( triggerContractingEle.wrappedElement.style.top ) + parseInt(triggerContractingEle.zoomHeightIncrementFlo) + "px" ;
                break ;
            case "lower-right" :
                triggerContractingEle.wrappedElement.style.left = parseInt( triggerContractingEle.wrappedElement.style.left ) + parseInt(triggerContractingEle.zoomWidthIncrementFlo) + "px" ;
                triggerContractingEle.wrappedElement.style.top = parseInt( triggerContractingEle.wrappedElement.style.top ) + parseInt(triggerContractingEle.zoomHeightIncrementFlo) + "px" ;
                break ;
            case "upper-left" :
                break ; // Divs naturally expand from this corner.
            case "center-right" :
                triggerContractingEle.wrappedElement.style.left = parseInt( triggerContractingEle.wrappedElement.style.left ) + parseInt(triggerContractingEle.zoomWidthIncrementFlo) + "px" ;
                triggerContractingEle.wrappedElement.style.top = parseInt( triggerContractingEle.wrappedElement.style.top ) + parseInt(triggerContractingEle.zoomHeightIncrementFlo/2) + "px" ;
                break ;
            case "center-left" :
                triggerContractingEle.wrappedElement.style.left = parseInt( triggerContractingEle.wrappedElement.style.left ) + parseInt(triggerContractingEle.zoomWidthIncrementFlo) + "px" ;
                triggerContractingEle.wrappedElement.style.top = parseInt( triggerContractingEle.wrappedElement.style.top ) + parseInt(triggerContractingEle.zoomHeightIncrementFlo/2) + "px" ;
                break ;
            case "center-top" :
                triggerContractingEle.wrappedElement.style.left = parseInt( triggerContractingEle.wrappedElement.style.left ) + parseInt(triggerContractingEle.zoomWidthIncrementFlo/2) + "px" ;
                break ;
            case "center-bottom" :
                triggerContractingEle.wrappedElement.style.left = parseInt( triggerContractingEle.wrappedElement.style.left ) + parseInt(triggerContractingEle.zoomWidthIncrementFlo/2) + "px" ;
                triggerContractingEle.wrappedElement.style.top = parseInt( triggerContractingEle.wrappedElement.style.top ) + parseInt(triggerContractingEle.zoomHeightIncrementFlo) + "px" ;
                break ;
        }
        if (browsers.ie) {
            triggerContractingEle.wrappedElement.filters.alpha.opacity = eval( triggerContractingEle.wrappedElement.filters.alpha.opacity ) - (triggerContractingEle.opacityIncrement) ; // WAS .08
        }
        else {
            triggerContractingEle.wrappedElement.style.opacity = eval( triggerContractingEle.wrappedElement.style.opacity ) - triggerContractingEle.opacityIncrement ;
        }
    }
}
function resizeZoomPercentages() {
	// Called via <body onresize="..."> .
	for (var zoomObjCounter=0; zoomObjCounter < zoomTriggerObjs.length; zoomObjCounter++) {
		assignZoomDimensions( zoomTriggerObjs[zoomObjCounter] ) ;
	};
}