var windowNum = 1;
var currentURL;

function popper(url,w,h,id) {
	newwindow=window.open(url,id,'width='+w+',height='+h+',toolbar=no,location=no,menubar=no');
	if (window.focus) {newwindow.focus()}
}

// fix png
		var version = navigator.userAgent;
		var findIE6 = version.indexOf('MSIE 6');
		
		var validElements = new Array();
		var allElements = new Array();
		
		// create object: getElementsByClassName
		function getElementsByClassName(element, classNameIs){
			this.classNameis = classNameIs;
			this.element = element;
			this.foundElements = getElements;
			
			// method find applicable elements;
			function getElements() {
				var allElements = document.getElementsByTagName(this.element);
				var z = 0;
				for (x = 0; x < allElements.length; x++) {	
					if (allElements[x].className == this.classNameis){
						validElements[z] = allElements[x];
						z++;
					} 
				}
				return validElements;
			}		
		}
		
		function fixpng(whoneedsfixing){
			if	(findIE6 != -1){
				validElements = [];
				allElements = [];
				getElementsByClassName('img',whoneedsfixing);
				for (z = 0; z < this.foundElements().length; z++) {
					validElements[z].style.filter = "progid:DXImageTransform.Microsoft.AlphaImageLoader(sizingMethod=scale src='"+ validElements[z].src +"')";
					validElements[z].src = 'http://www.nixonnow.com/image/common/clear.gif';
				}
			}
		}
		
		
function movieLoader(refid,w,h,id) {
			var so = new SWFObject("/flash/movies/nixon-flv-player.swf?"+Math.random()+"&RND=4548579", "mymovie", w, h, "9", "#FFFFFF");
			so.addVariable("moviePath", "/flash/movies/"+refid+".flv");
			so.addParam("wmode", "transparent");
			so.addVariable("loaderColor", "0xA7A9AC");
			//so.addVariable("timelineColor", "0xFFFFFF");
			so.addVariable("finishFunction", "videoFinish");
			so.write(id);
		}
		
		function videoFinish() { 
			//$('movieslideshowcontainer').innerHTML = "";
		}
		
		// JavaScript Document

		// ----------------------------------
		// Z-Lightbox v. 1.0
		// Copyright 2008 by Zaneray Inc.
		// Written by: Flori Seeger
		// ----------------------------------
		
		window.onresize=function() { setprocessingheight(); }
		window.onscroll=function() { setprocessingheight(); }
		
		function setprocessingheight() {
			if ($('processingdisp')){
				var xscroll = 0;
				var yscroll = 0;
				var xtotalscroll = 0;
				var ytotalscroll = 0;
				var xwindow = 0;
				var ywindow = 0;
				var xdiv = 0;
				var ydiv = 0;
				
				// how far scrolled in x and y directions
				xscroll = window.pageXOffset ||
									document.body.scrollLeft ||
									document.documentElement.scrollLeft;
			
				yscroll = window.pageYOffset ||
									document.body.scrollTop ||
									document.documentElement.scrollTop;
			
				// browser window width and height
				xwindow = self.innerWidth ||
									document.documentElement.clientWidth ||
									document.body.clientWidth;
									
				ywindow = self.innerHeight ||
									document.documentElement.clientHeight ||
									document.body.clientHeight;
				
				// total possible scroll x and y directions
				xtotalscroll = xwindow + window.scrollMaxX ||
											 document.body.scrollWidth ||
											 document.body.offsetWidth;
				
				ytotalscroll = ywindow + window.scrollMaxY ||
											 document.body.scrollHeight ||
											 document.body.offsetHeight;
				
				// get display container width and height				
				xdiv = $('processingdisp').offsetWidth;
				ydiv = $('processingdisp').offsetHeight; 	
				
				//$('processing').style.width = xwindow + (xscroll - 20) + 'px'; //disabled and replaced with 100% width in css
				$('processing').style.height = ywindow + yscroll + 'px';
				
				if (xwindow <= xdiv){
					$('processingdisp').style.left = "0px";
				}
				else {
					$('processingdisp').style.left = ((xwindow + xscroll*2) / 2) - (xdiv / 2) + "px"; //half the width of processingdisp
				}
			
				if (ywindow <= ydiv){
					//$('processingdisp').style.top = "0px";
				}
				else {
					$('processingdisp').style.top = ((ywindow + yscroll*2) / 2) - (ydiv / 2) + "px"; //half the height of processingdisp
				}
			}
		}
		
		// stop event bubbling
		function stopbubble(e){
			if (!e) var e = window.event;
			e.cancelBubble = true;
			if (e.stopPropagation) e.stopPropagation();
		}
		
		// ----------------------------------
		// Z-Zoom v. 1.0
		// Copyright 2008 by Zaneray Inc.
		// Written by: Flori Seeger
		// ----------------------------------
		var xs; // width start
		var xc; // width counter
		var xe; // max zoom width
		var ys; // height start
		var yc; // height counter
		var ye; // max zoom height
		var xt; // width total
		var yt; // height total
		var ratio; // width to height ratio
		var pixelspeed; // zoom speed in pixel
		var loopspeed = 40; // function recall after 40ms = 25fps
		
		var varsetup = false;
		var xd; //width direction (zoom in or out)
		var yd; //heith direction (zoom in or out)
		var zoomxdone; //flag 
		var zoomydone; //flag
		
		function zoom(element,pixelspeed,xe,ye){
			// setup initial variables
			if (varsetup == false){
				zoomdone = false;
				xs = xc = element.offsetWidth;
				ys = yc = element.offsetHeight;
				xt = xe - xs;
				yt = ye - ys;
				ratio =  xt / yt;
				varsetup = true;
				if (xs > xe){
				xd = 'zoomoutx';
				}
				else {
					xd = 'zoominx';
				}
				
				if (ys > ye){
					yd = 'zoomouty';
				}
				else {
					yd = 'zoominy';
				}
				zoomxdone = false;
				zoomydone = false;
			}
			
			// zoom x direction / switch for zoom in and zoom out
			switch (xd){
				case 'zoominx':
					xc = (xc + (pixelspeed * ratio));
					if (xc < xe){
						element.style.width = xc + "px";
					}
					if ((xc + (pixelspeed * ratio)) >= xe){
						element.style.width = xe + "px";
						zoomxdone = true;
					}
				break;
	
				case 'zoomoutx':
					xc = (xc - (pixelspeed * ratio));
					if (xc > xe){
						element.style.width = xc + "px";
					}
					if ((xc + (pixelspeed * ratio)) <= xe){
						element.style.width = xe + "px";
						zoomxdone = true;
					}
				break;
			}
			
			// zoom y direction / switch for zoom in and zoom out
			switch (yd){
				case 'zoominy':
					yc = (yc + pixelspeed);
					if (yc < ye){
						element.style.height = yc + "px";
					}
					if ((yc + pixelspeed) >= ye){
						element.style.height = ye + "px";
						zoomydone = true;
					}
				break;
	
				case 'zoomouty':
					yc = (yc - pixelspeed);
					if (yc > ye){
						element.style.height = yc + "px";
					}
					if ((yc + pixelspeed) <= ye){
						element.style.height = ye + "px";
						zoomydone = true;
					}
				break;
			}
			
			// check on flags
			if (zoomxdone == false && zoomydone == false){
				setprocessingheight();
				setTimeout(function () { zoom(element,pixelspeed,xe,ye); }, loopspeed);
			}
			else {
				varsetup = false;
				zoomdone = true;
				setprocessingheight();
			}
			//debug help
			//alert (xs +"/"+ xe +"/"+ ys +"/"+ ye +"/"+ xt +"/"+ yt +"/"+ ratio +"/"+ pixelspeed)
		}
		
		// ----------------------------------
		// EZ-Y Scroll v. 1.0
		// Copyright 2008 by Zaneray Inc.
		// Written by: Flori Seeger
		// ----------------------------------
		var scrolldistancey;
		var scrolldone = true;
		var scrollinit = false;
		var scrollpxcounter;
		var scrollstep;
		var scrollmaxy;
		var easearray= new Array();
		function easyscroll(direction,user,distance,type,containernum){
			scrolldistancey = distance;
			if (user == true && scrolldone == true){
				var execute = true;
			}
			if (user == false) {
				var execute = true;
			}
			if (execute == true){
				if (scrollinit == false){
					var scrollconstrainerheight = $('scrollconstrainer' + containernum).offsetHeight;
					var scrollcontainerheight = $('scrollcontainer' + containernum).offsetHeight;
					scrollmaxy = scrollcontainerheight - scrollconstrainerheight;
					scrollinit = true;
					scrolldone = false;
					scrollstep = 0;
					scrollpxcounter = 0;
					if (type == 'watch'){
						easearray=[5,10,15,20,15,10,5,4,1];
					}
					if (type == 'softgoods'){
						easearray=[1,3,5,10,15,20,15,10,7,5,2,1];
					}
					if (type == 'softgoodstext'){
						easearray=[1,3,5,10,12,10,7,5,3,2,1,1];
					}
				}
				var positioncheck = parseFloat($('scrollcontainer' + containernum).offsetTop);
				if (positioncheck == -1 || positioncheck == 0){
					$('uparrow' + containernum).style.display = 'none';
				}
				else {
					$('uparrow' + containernum).style.display = 'block';
				}
				if ((positioncheck * -1) >= scrollmaxy){
					$('downarrow' + containernum).style.display = 'none';
				}
				else {
					$('downarrow' + containernum).style.display = 'block';
				}
				//check if vertical scroll is possible
				if (scrollmaxy > 0){
					setTimeout(function () { scrollnow(direction,user,distance,type,containernum); }, 33);
				}
			}
		}
		
		// ----------------------------------
		// Z-Opacity Scroll v. 1.0
		// Copyright 2008 by Zaneray Inc.
		// Written by: Flori Seeger
		// ----------------------------------
		function opacity(id, opacStart, opacEnd, millisec) {
			//speed for each frame
			var speed = Math.round(millisec / 100);
			var timer = 0;
		
			//determine the direction for the blending, if start and end are the same nothing happens
			if(opacStart > opacEnd) {
				for(i = opacStart; i >= opacEnd; i--) {
					setTimeout("changeOpac(" + i + ",'" + id + "')",(timer * speed));
					timer++;
				}
			} else if(opacStart < opacEnd) {
				for(i = opacStart; i <= opacEnd; i++)
					{
					setTimeout("changeOpac(" + i + ",'" + id + "')",(timer * speed));
					timer++;
				}
			}
		}
		
		//change the opacity for different browsers
		function changeOpac(opacity, id) {
			if (opacity == 100 && faderobject == id){
				opacityrunning = false;
			}
			if ($(id)){
				var object = $(id).style; 
				object.opacity = (opacity / 100);
				object.MozOpacity = (opacity / 100);
				object.KhtmlOpacity = (opacity / 100);
				object.filter = "alpha(opacity=" + opacity + ")";
			}
		}
		
		/*---------------------------------------------------------
		GENERIC DIV TOGGLER
		img represents and image with and on and off state.
		format: img.gif for off state / img-on.gif for on state
		----------------------------------------------------------*/
		var openDiv = '';
		var openTab = '';
		var openTabID = '';
		function divToggle(daDiv, daImg) { 
			//if(!$(daImg)) return false;
			if (openDiv != '') {
				if ($(daDiv).style.display == 'block') { 
					//Close the same div that's open
					$(daDiv).style.display = 'none';
					openDiv = '';
					if (openTab != '') {
						openTab = openTab.replace(/-on.gif/,'.gif');
						$(daImg).src = openTab;
						openTab = '';
					}
				} else { 
					//Close the current div
					$(openDiv).style.display = 'none';
					$(daDiv).style.display = 'block';
					openDiv = daDiv;
					if (openTab != '') { 
						openTab = openTab.replace(/-on.gif/,'.gif');
						$(openTabID).src = openTab;
						openTab = '';
					}
					if (daImg != '') { 
						openTab = $(daImg).src;
						openTab = openTab.replace(/.gif/,'-on.gif');
						$(daImg).src = openTab;
						openTabID = daImg;
					}
				}
			} else { 
				//Open that div for the very first time.
				$(daDiv).style.display = 'block';
				openDiv = daDiv;
				if (daImg != '') { 
					if(!$(daImg)) return false;
					openTab = $(daImg).src;
					openTab = openTab.replace(/.gif/,'-on.gif');
					$(daImg).src = openTab;
					openTabID = daImg;
				}
			}
		}
		
		//0 is closed 1 is open
		var simpleState = 0;
		function simpleToggle(daDiv) { 
			if (simpleState ==  0) {
				$(daDiv).style.display = 'block';
				simpleState = 1;
			} else { 
				$(daDiv).style.display = 'none';
				simpleState = 0;
			}
		}
		
		   //standard zaneray isEmpty
    function isEmpty(v) {
      if (v == null) { return true; }
      if (typeof v == 'undefined') { return true; }
      if (v == undefined) { return true; }
      if (v == "") { return true; }
      return false;
    }

    function makeMovementArray(lft,pct,onlyEvens) {
      var updnAr = new Array();
      var noJumps = 15;
      var start = 0;
      if (onlyEvens) start++;
      var nxt = start;
      var lftOvr = ( lft % 2 );
      lft = parseInt((parseInt(lft) / 2) - 1);
      var nextInt = start;
      updnAr[0] = start;
      var done = false;
      var k = 1;
           
      while (!done) {
        nxt = nxt * pct;
        nextInt = parseInt(nxt);
        if (onlyEvens) {
          if ( ( nextInt % 2) == 1 ) {
            nextInt++;
          }
        }
        if (nextInt < lft) {
          updnAr[k] = nextInt;
        }
        else {
          if (lft < updnAr[k-1] ) {
            updnAr[k-1] = updnAr[k-1] + lft;
          }
          else {
            updnAr[k] = lft;
          }
          done = true; 
        }
        lft = lft - nextInt;
        k++;
      }
      var g = updnAr.length;
      for (var w=(updnAr.length-1); w > -1; w--) {
        updnAr[g] = updnAr[w];
        if (lftOvr == 1) { 
          updnAr[w] = updnAr[w] + 1;
          lftOvr = 0;
        }
        g++;
      }
      return updnAr;
    }
    var isLeftSliding = false;
    var leftSlide = function(ele,to,onComplete) {
      isLeftSliding = true;
      var theEle = document.getElementById(ele);
      var curPos = theEle.offsetLeft;
      var forward = false;
      if ( curPos > to ) {
        forward = true;
      }
      var beChange = Math.abs( curPos - to );
      var easeArray  = makeMovementArray(beChange,1.33,true);
      for (var i = 0; i < easeArray.length; i++) {
        if (forward) {
          curPos = curPos - easeArray[i];
        }
        else {
          curPos = curPos + easeArray[i];
        }
        setTimeout("document.getElementById('"+ele+"').style.left='"+curPos+"px'",i*33);
        k = i*33;
      }
      setTimeout("document.getElementById('"+ele+"').style.left='"+to+"px'",k);
      setTimeout("isLeftSliding=false",k);
      if (onComplete != "") { 
        setTimeout(onComplete,k); 
      }
    }

	// 100% original code by Flori Seeger
	// Copyright 2007 by The ZaneRay Group Inc.
	
	// create object: getElementsByClassName
	function getElementsByClassName(element, classNameIs){
	  var validElements = [];
		var allElements = document.getElementsByTagName(element);
		var z = 0;
		for (x = 0; x < allElements.length; x++) {	
			if (allElements[x].className.indexOf(classNameIs) > -1) {
				validElements[z] = allElements[x];
				z++;
			} 
		}
		return validElements;
	}
		
	function cssmodify(cssstyle,cssproperty,element,classNameIs){
		var validElements = getElementsByClassName(element,classNameIs);
		for (z = 0; z < validElements.length; z++) {
			validElements[z].style[cssstyle] = cssproperty;
		}
	}
	
		//--------------------------------------------------------------------------------------------------------
		// Z-Zoom v. 1.50
		// Copyright 2008 by Zaneray Inc.
		// Written by: Flori Seeger
		//--------------------------------------------------------------------------------------------------------
		// todo: 
		// cleanup parent function
		//--------------------------------------------------------------------------------------------------------
		// params:
		// element = object 
		// xstart = x start size
		// ystart = y start size
		// xend = x end size
		// yend = y end size
		// ease = name of ease array
		// callbackfunction = function that called
		// who = additional element pass
		
		var sideslideease = new Array;
		boxease = [3,6,9,15,10,7,5,3,3,2,2,1];
	
		
		var loopspeed = 35; // function recall after 40ms = 25fps
		var currentelement;
		var zzoom = function (element, xstart, ystart, xend, yend, ease, callbackfunction, delay) {
			if (delay != ''){
				element.delaytimer = setTimeout(function () { zzoom(element, xstart, ystart, xend, yend, ease, callbackfunction, ''); }, delay);
				return;
			}
			element.varsetup = false;
																	
			element.zoom = function (element){
				
				if (element.varsetup == false){
					

					// element position
					element.xp = element.offsetLeft;
					element.yp = element.offsetTop;
					
					// check if element has border
					var version = navigator.userAgent;
					if (element.style.borderWidth.indexOf('1px') > -1){
						element.xyoffset = 2;
					}
					else {
						element.xyoffset = 0;
					}
					
					// element width / height
					element.xw = element.offsetWidth;
					element.yh = element.offsetHeight;
					
					// clear timer if running
					clearTimeout(element.zoomtimer);
					
					// setup end zoom size
					element.xe = xend; 
					element.ye = yend;
					
					// setup current height and width properties
					if (currentelement == element && element.zoomxdone == false || element.zoomydone == false){
						if (xstart < 0){
							element.xc = element.offsetWidth * -1;
						}
						else {
							element.xc = element.offsetWidth;
						}
						if (ystart < 0){
							element.yc = element.offsetHeight * -1;
						}
						else {
							element.yc = element.offsetHeight;
						}
					
					}
					else {
						element.xc = xstart;
						element.yc = ystart;
					}
					currentelement = element;
					
					// enable zoom functions
					element.zoomxdone = false;
					element.zoomydone = false;
					
					// run setup only once
					element.varsetup = true;
					
					// reset array counter
					element.loopcounter = 0;
					
					// get total zoom distances, convert neg to pos
					if (element.xe < 0){
						var xe = -element.xe;
					}
					else {
						var xe = element.xe;
					}
					if (element.xc < 0){
						var xc = -element.xc;
					}
					else {
						var xc = element.xc;
					}
					if (element.ye < 0){
						var ye = -element.ye;
					}
					else {
						var ye = element.ye;
					}
					if (element.yc < 0){
						var yc = -element.yc;
					}
					else {
						var yc = element.yc;
					}
					element.xt = xe - xc;
					element.yt = ye - yc;
					//set zoom aspect ratio
					element.ratio =  element.xt / element.yt;
					if (element.ratio < 0){
						element.ratio = -element.ratio;
					}
					
					// catch 0 ratio or ration set to infinity caused by devision by zero
					// and negative or invalid ratio
					if (element.ratio <= 0 || element.ratio == 'Infinity'){
						element.ratio = 1;
					}
					
					// x check if zoom-in or zoom-out
					if (element.xt != 0){
						if (element.xc > element.xe){
						element.xd = 'zoomoutx';
						}
						else {
							element.xd = 'zoominx';
						}
					}
					else {
						element.xd = 'noxzoom';
						element.zoomxdone = true;
					}
					
					// y check if zoom-in or zoom-out
					if (element.yt != 0){	
						if (element.yc > element.ye){
							element.yd = 'zoomouty';
						}
						else {
							element.yd = 'zoominy';
						}
					}
					else {
						element.yd = 'noyzoom';
						element.zoomydone = true;
					}
					
					// check if negative zoom direction
					if (element.xc < 0){
						element.xn = true;
						element.xc = element.xc * -1;
					}
					if (element.yc < 0){
						element.yn = true;
						element.yc = element.yc * -1;
					}

				}
	
				// ---------- X DIRECTION ----------
				// zoom x direction / switch for zoom in and zoom out
				if (element.zoomxdone == false){
					switch (element.xd){
						case 'zoominx':
							if (element.xn == true){
								
								element.xc = element.xc - eval(ease)[element.loopcounter] * element.ratio;
								
								if (element.xc * -1 < element.xe){
									element.style.width = element.xc + "px";
									element.style.left =  element.xp + element.xw - element.xc - element.xyoffset + "px";
								}
								
								if (-1 * element.xc + eval(ease)[element.loopcounter] * element.ratio >= element.xe){
									element.style.width = -1 * element.xe + "px";
									element.style.left = element.xp + element.xw - element.xe * -1 - element.xyoffset + "px";
									element.zoomxdone = true;
								}
								
							}
							else {
								
								element.xc = element.xc + (eval(ease)[element.loopcounter] * element.ratio);
						
								if (element.xc < element.xe){
									element.style.width = element.xc + "px";
								}
								
								if (element.xc + eval(ease)[element.loopcounter] * element.ratio >= element.xe){
									element.style.width = element.xe + "px";
									element.zoomxdone = true;
								}
								
							}
						break;
			
						case 'zoomoutx':
							
							if (element.xn == true){
								
								element.xc = element.xc + eval(ease)[element.loopcounter] * element.ratio;
							
								if (element.xc > element.xe){
									element.style.width = element.xc + "px";
									element.style.left = element.xp - element.xc + element.xw - element.xyoffset + "px";
								}
								
								if (-1 * element.xc - eval(ease)[element.loopcounter] * element.ratio <= element.xe){
									element.style.width = -1 * element.xe + "px";
									element.style.left = element.xp + element.xe + element.xw - element.xyoffset + "px";
									element.zoomxdone = true;
								}
								
							}
							else {
								
								element.xc = element.xc - eval(ease)[element.loopcounter] * element.ratio;
								
								if (element.xc > element.xe){
									element.style.width = element.xc + "px";
								}
								
								if (element.xc - eval(ease)[element.loopcounter] * element.ratio <= element.xe){
									element.style.width = element.xe + "px";
									element.zoomxdone = true;
								}
								
							}
						break;
					}
				}
				
				// ---------- Y DIRECTION ----------
				// zoom y direction / switch for zoom in and zoom out
				if (element.zoomydone == false){
					switch (element.yd){
						case 'zoominy':
							if (element.yn == true){
								
								element.yc = element.yc - eval(ease)[element.loopcounter];
								
								if ((element.yc * -1) < element.ye){
									element.style.height = element.yc + "px";
									element.style.top =  element.yp + element.yh - element.yc - element.xyoffset + "px";
								}
								
								if (-1 * (element.yc + eval(ease)[element.loopcounter]) >= element.ye){
									element.style.height = -1 * element.ye + "px";
									element.style.top = element.yp + element.yh - element.ye * -1 - element.xyoffset + "px";
									element.zoomydone = true;
								}
								
							}
							else {
								
								element.yc = element.yc + eval(ease)[element.loopcounter];
							
								if (element.yc < element.ye){
									element.style.height = element.yc + "px";
								}
								
								if (element.yc + eval(ease)[element.loopcounter] >= element.ye){
									element.style.height = element.ye + "px";
									element.zoomydone = true;
								}
								
							}
						break;
			
						case 'zoomouty':
							if (element.yn == true){
								
								element.yc = element.yc + eval(ease)[element.loopcounter];
								
								if (element.yc > element.ye){
									element.style.height = element.yc + "px";
									element.style.top = element.yp - element.yc + element.yh - element.xyoffset + "px";
								}
								
								if (-1 * element.yc - eval(ease)[element.loopcounter] <= element.ye){
									element.style.height = -1 * element.ye + "px";
									element.style.top = element.yp + element.ye + element.yh - element.xyoffset + "px";
									element.zoomydone = true;
								}
								
							}
							else {
								
								element.yc = element.yc - eval(ease)[element.loopcounter];
							
								if (element.yc > element.ye){
									element.style.height = element.yc + "px";
								}
								
								if (element.yc - eval(ease)[element.loopcounter] <= element.ye){
									element.style.height = element.ye + "px";
									element.zoomydone = true;
								}
								
							}
						break;
					}
				}
				
				// check on flags
				if (element.zoomxdone == false || element.zoomydone == false){
					if (eval(ease).length - 1 > element.loopcounter){
						element.loopcounter++;
					}
					element.zoomtimer = setTimeout(function () { element.zoom(element); }, loopspeed);
				}
				else {
					//-----------------------------------------------------------------------
					// use switch below ONLY if you need x/y specific end of function triggers
					//-----------------------------------------------------------------------
					//switch (element.xd){
					//	case 'zoominx':
					//	break;
					//	
					//	case 'zoomoutx':
					//	break;
					//}
					
					//switch (element.yd){
					//	case 'zoominy':	
					//	break;
					//	
					//	case 'zoomouty':
					//	break;
					//}
					
					// callbacks
					if (callbackfunction == 'ml'){
						try{
							who.mldone(element);
						}
						catch(err){}
					}
					if (callbackfunction == 'hideinfoslideclose'){
						hideinfoslideclose();
					}
					
					if (callbackfunction == 'hidepictureslideclose'){
						hidepictureslideclose();
					}
					
					if (callbackfunction == 'hideczoomclose'){
						hideczoomclose();
					}
					
					clearTimeout(element.zoomtimer);
					element.varsetup = false;
				}
			}
			element.zoom(element);
		}