// **********************************************************************
// Based on 'Image cross-fade' script written by www.brothercake.com
// **********************************************************************

//global object
var ixf = { 'clock' : null, 'count' : 1 };

// additional variables
ixf.imgs = new Array();

var imgsText = new Array();
var base_id = "";

this.new_image_idx = 0;
this.preloadImages = "FALSE";  // required for Firefox else cache images



/************************************************************************
*  Functions
************************************************************************/
function setImgSrcArray()
{

	for(var i=0; arguments[i] != null; i++)
	{
	  	  ixf.imgs[i] = arguments[i];
	}

	//cache the images
	ixf.cache = [];
	for(var i=0; i<ixf.imgs.length; i++)
	{
		ixf.cache[i] = new Image;
		ixf.cache[i].src = ixf.imgs[i];
	}

};


function setImgAltTextArray()
{

	for(var i=0; arguments[i] != null; i++)
	{
	  	  imgsText[i] = arguments[i];
	}

};


function cacheImages()
{

	ixf.cache = [];
	for(var i=0; i<ixf.imgs.length; i++)
	{
		ixf.cache[i] = new Image;
		ixf.cache[i].src = ixf.imgs[i];
	}


};


function initTransformation()
{

    id_base = arguments[0];

    ixf.obj = document.getElementById(id_base);
	
	// if element not found, end here
	if(!ixf.obj)
	{
		return false;
	}

	//store the supported form of opacity
	if(typeof ixf.obj.style.opacity != 'undefined')
	{
		ixf.type = 'w3c';
	}
	else if(typeof ixf.obj.style.MozOpacity != 'undefined')
	{
		ixf.type = 'moz';
	}
	else if(typeof ixf.obj.style.KhtmlOpacity != 'undefined')
	{
		ixf.type = 'khtml';
	}
	else if(typeof ixf.obj.filters == 'object')
	{
		//weed out win/ie5.0 by testing the length of the filters collection (where filters is an object with no data)
		//then weed out mac/ie5 by testing first the existence of the alpha object (to prevent errors in win/ie5.0)
		//then the returned value type, which should be a number, but in mac/ie5 is an empty string
		ixf.type = (ixf.obj.filters.length > 0 && typeof ixf.obj.filters.alpha == 'object' && typeof ixf.obj.filters.alpha.opacity == 'number') ? 'ie' : 'none';
	}
	else {
		ixf.type = 'none';
	}


	// For Firefox we need to add (preload) the images to the page as soon as it is opened
	if(ixf.type == 'w3c')
	{
		this.preloadImages = "TRUE";
	}


	if(this.preloadImages == "TRUE")
	{

		// insert an empty img tag into the html for each image
		//document.write("<img id='t_img0'><img id='t_img1'><img id='t_img2'><img id='t_img3'>");

		// add the images, placing them in the same position as the image in the html
		for(var i=0; i<ixf.imgs.length; i++)
		{
			// insert an empty img tag with the respective id attribute into the html
			document.write("<img id='" + id_base + i +"'>");

			// copy the new img obj
			ixf.newimg = document.getElementById(id_base + i);

			// set style - this hides the image
			ixf.newimg.className = 'idupe';

			// set src to new image src
			ixf.src = ixf.imgs[i];
			ixf.newimg.src = ixf.src

			// position new image in the same place on the page
			ixf.newimg.style.left = ixf.getRealPosition(ixf.obj, 'x') + 'px';
			ixf.newimg.style.top = ixf.getRealPosition(ixf.obj, 'y') + 'px';
		}

	}
	else {
		cacheImages()
	}

};


// Main function
function imgTransition()
{

    //if the timer is not already going
    if(ixf.clock == null)
    {

        // Increment the image number to go to the next slide
        if (this.new_image_idx < ixf.imgs.length - 1) {
            this.new_image_idx++;
        }
        else {
            // if last slide reached, restart at the first slide
            this.new_image_idx = 0;
        }
        ixf.src = ixf.imgs[this.new_image_idx];


        //change the image alt text if defined
        if(imgsText.length > 0)
        {
			if(imgsText[this.new_image_idx] == null)
			{
				ixf.obj.alt = "";
				//ixf.newimg.alt = "";
			}
			else {
				ixf.obj.alt = imgsText[this.new_image_idx];
				//ixf.newimg.alt = imgsText[this.new_image_idx];
			}

        	//ixf.obj.alt = imgsText[this.new_image_idx];
        }


        //if any kind of opacity is supported
        if(ixf.type != 'none')
        {
        	if(this.preloadImages != "TRUE")
        	{
				//create a new image object and append it to body
				//detecting support for namespaced element creation, in case we're in the XML DOM
				ixf.newimg = document.getElementsByTagName('body')[0].appendChild((typeof document.createElementNS != 'undefined') ? document.createElementNS('http://www.w3.org/1999/xhtml', 'img') : document.createElement('img'));
			}

            //set positioning classname
            ixf.newimg.className = 'idupe';

            //set src to new image src
            ixf.newimg.src = ixf.src

            //move it to superimpose original image
            ixf.newimg.style.left = ixf.getRealPosition(ixf.obj, 'x') + 'px';
            ixf.newimg.style.top = ixf.getRealPosition(ixf.obj, 'y') + 'px';

            //copy and convert fade duration argument
            ixf.length = parseInt(arguments[1], 10) * 1000;

            //create fade resolution argument as 20 steps per transition
            ixf.resolution = parseInt(arguments[1], 10) * 20;

            //start the timer
            ixf.clock = setInterval('ixf.crossfade()', ixf.length/ixf.resolution);
        }

        //otherwise if opacity is not supported
        else {
            //just do the image swap
            ixf.obj.src = ixf.src;
        }
    }

};


//crossfade timer function
ixf.crossfade = function()
{

    //decrease the counter on a linear scale
    ixf.count -= (1 / ixf.resolution);

    //if the counter has reached the bottom
    if(ixf.count < (1 / ixf.resolution))
    {
        //clear the timer
        clearInterval(ixf.clock);
        ixf.clock = null;

        //reset the counter
        ixf.count = 1;

        //set the original image to the src of the new image
        ixf.obj.src = ixf.src;
    }

    //set new opacity value on both elements
    //using whatever method is supported
    switch(ixf.type)
    {
        case 'ie' :
            ixf.obj.filters.alpha.opacity = ixf.count * 100;
            ixf.newimg.filters.alpha.opacity = (1 - ixf.count) * 100;
            break;

        case 'khtml' :
            ixf.obj.style.KhtmlOpacity = ixf.count;
            ixf.newimg.style.KhtmlOpacity = (1 - ixf.count);
            break;

        case 'moz' :
            //restrict max opacity to prevent a visual popping effect in firefox
            ixf.obj.style.MozOpacity = (ixf.count == 1 ? 0.9999999 : ixf.count);
            ixf.newimg.style.MozOpacity = (1 - ixf.count);
            break;

        default :
            //restrict max opacity to prevent a visual popping effect in firefox
            ixf.obj.style.opacity = (ixf.count == 1 ? 0.9999999 : ixf.count);
            ixf.newimg.style.opacity = (1 - ixf.count);
    }

    //now that we've gone through one fade iteration
    //we can show the image that's fading in
    ixf.newimg.style.visibility = 'visible';

    //keep new image in position with original image
    //in case text size changes mid transition or something
    ixf.newimg.style.left = ixf.getRealPosition(ixf.obj, 'x') + 'px';
    ixf.newimg.style.top = ixf.getRealPosition(ixf.obj, 'y') + 'px';

    //if the counter is at the top, which is just after the timer has finished
    if(ixf.count == 1)
    {
        //remove the duplicate image - depending on browser
        if(preloadImages != "TRUE")
        {
        	ixf.newimg.parentNode.removeChild(ixf.newimg);
        }
    }

};



//get real position method
ixf.getRealPosition = function()
{

    this.pos = (arguments[1] == 'x') ? arguments[0].offsetLeft : arguments[0].offsetTop;
    this.tmp = arguments[0].offsetParent;
    while(this.tmp != null)
    {
        this.pos += (arguments[1] == 'x') ? this.tmp.offsetLeft : this.tmp.offsetTop;
        this.tmp = this.tmp.offsetParent;
    }

    return this.pos;

};