// <SCRIPT Language="javascript">
	var  hexs= new Array("0", "1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");
	var iPageType=0;
	var offsetX, offsetY;
	var sampleareaObj;
	var samplearea3Obj = new Array(3);
	var spectrumObj;
	var textreadableObjb;
	var textreadableObjc;
	var textrgbObj=new Array(2);
	var additivehexObj;
	var additiveRGBObj;
	var qualityimagegoodObj;
	var qualityimagepoorObj;
	var qualitytextObj;
	var unisliders=new Array(4);

	var spectrumleft=0;
	var spectrumtop=0;
	var horizlumps = new Array(0xFF0000, 0xFFFF00, 0x00FF00, 0x00FFFF, 0x0000FF, 0xFF00FF, 0xFF0000);
	var width=420;
	var toprowcolours = new Array(width);
	var chunks=width/6;
	var blackwhitesteps=30;
	var height=270;
	var colourhalf=(height-blackwhitesteps)/2;
	var mouseon=0;

	var currentfontset="verdana, sans-serif";	
	var currentFontSize=10;
	var currentcolourdiff=765;
	var textbrighterthanbackground=1;

	var blacktowhite=gradient(blackwhitesteps,0,0xFFFFFF);

	var currentcolourID=0;
	var currentBackgroundYIQ=255;
	var currentcoloursFloat = new Array(255,255,255,0,0,0,10);
	var currentcolours = new Array(255,255,255,0,0,0,10);

	var goodnessestimate=new Array(125, 500);  // start 	off with the breakpoint values for brghtness and colour for 10pt text
	var brightnessweightings=new Array(0.299, 0.587, 0.114);		

	var yiqtv=255;
	var yiqbv=0;
	var yiqdiffv=255;

	var yiqtvalueObj;
	var yiqbvalueObj;
	var yiqdiffObj;
	var yiqcdiffObj;
	var yiqrangeul=new Array(110, -140);
	var yiqrangeObj;
	var fontadjustpc=new Array(2.5, 1);
	var fontadjuststp=new Array(yiqrangeul[0]*Math.pow(1+(fontadjustpc[0]/100),6), yiqrangeul[1]*Math.pow(1+(fontadjustpc[1]/100),6));

			
// ******************************************** function gradient
	function gradient(numberofsteps, startcolor, endcolor) {
   
		var theArray = new Array(numberofsteps);
	    start_red  = startcolor >> 16;
   		start_green = (startcolor & 0x00FF00) >> 8;
    	start_blue = startcolor & 0x0000FF;

    	end_red = endcolor >> 16;
    	end_green= (endcolor & 0x00FF00) >> 8;
    	end_blue = endcolor & 0x0000FF;

    	incRed = ((end_red - start_red) / numberofsteps);
    	incGreen = ((end_green - start_green) / numberofsteps);
    	incBlue = ((end_blue - start_blue) / numberofsteps);


	    for (x=0; x < numberofsteps; x++) {
    	    if (((start_red + incRed) >= 0x00) && ((start_red + incRed) <= 0xFF)){
        	    start_red =start_red+ incRed;
        	}
        	if (((start_green + incGreen) >= 0x00) && ((start_green + incGreen) <= 0xFF)){
            	start_green = start_green+incGreen;
	        }
    	    if (((start_blue + incBlue) >= 0x00) && ((start_blue + incBlue) <= 0xFF)){
	       	    start_blue =start_blue+ incBlue;
    	    }

	        theArray[x] = mergergb( start_red, start_green,  start_blue);

	    }
    	return theArray;
	}

// ********************************************** function mergergb
	function mergergb(r, g, b) {
    	return (r << 16 | g << 8 | b);
	}	


 



//	******************************************** function xf1 sets the hex values
	function xf1(istextcolour){
		var imod=0;
		if(!istextcolour){(imod=3)};
		strhex="#"+(hexs[currentcolours[0+imod]>>4])+(hexs[currentcolours[0+imod]&15])+(hexs[currentcolours[1+imod]>>4])+(hexs[currentcolours[1+imod] & 15])+(hexs[currentcolours[2+imod]>>4])+(hexs[currentcolours[2+imod]&15]);
	
		if(istextcolour){
			document.cpradios.Eye0.value=strhex;


		} else {
			document.cpradios.Eye1.value=strhex;
		}
	}

// ******************************************* function xf2 sets the sample area colours
	function xf2(istextcolour){
		if(iPageType!=3){

			if(istextcolour){
				sampleareaObj.style.color=document.cpradios.Eye0.value;
		
			} else {
		
				sampleareaObj.style.background=document.cpradios.Eye1.value;
       	
		
			}
		} else {
		
			if(istextcolour){
				samplearea3Obj[0].style.background=document.cpradios.Eye0.value;
		
			} else {
		
				samplearea3Obj[2].style.background=document.cpradios.Eye1.value;
       	
		
			}
		
			var cols2=new Array(3);
			for(var i=0;i<3;i++){
				cols2[i]=currentcolours[0+i]+currentcolours[3+i];
				if(cols2[i]>255){
					cols2[i]=255;
				}	
				
			}
			
			strhex="#"+(hexs[cols2[0]>>4])+(hexs[cols2[0]&15])+(hexs[cols2[1]>>4])+(hexs[cols2[1] & 15])+(hexs[cols2[2]>>4])+(hexs[cols2[2]&15]);
			samplearea3Obj[1].style.background=strhex;
			additivehexObj.obj.innerHTML=strhex;
			additiveRGBObj.obj.innerHTML=cols2[0]+","+cols2[1]+","+cols2[2];
			
			
		}
}
// ***************************************** function xf3 sets the currentcolours from the spectrum
function xf3(acolour, imod){

	if(acolour>-1){
		currentcolours[0+imod]  = (acolour & 0xFF0000) >> 16;	// red
   		currentcolours[1+imod] = (acolour & 0x00FF00) >> 8;   // green
   		currentcolours[2+imod] = acolour & 0x0000FF;   // blue			
	}
	for(n=0; n<3;n++){
		slidersArray[imod+n].setPosition(1-(currentcolours[n+imod]/255));	
		currentcoloursFloat[n+imod]=currentcolours[n+imod];
	}


}
//   *************************************************** function spectrumMouseUp event on mouseup on spectrumobj
	function spectrumMouseUp(e){
		mouseon=!mouseon;
		if(mouseon){
			if(document.cpradios.cpradio[0].checked){
				document.cpradios.lockslider0.checked=false;
			} else {
				document.cpradios.lockslider1.checked=false;
		
			}
		}
		slideIsUp(); // just to be sure

	}

//  **************************************************** function spectrumMouseMove is called when the mouse moves over the listened-for object
	function spectrumMouseMove(e){

		if(mouseon){

			var mouseCoords=getMousePos(e);
	

			var imod=(document.cpradios.cpradio[1].checked)*3;
			
//			innerText("diagnostic",+String(mouseCoords[0])+"|"+String(spectrumleft)+"|"+String(mouseCoords[1])+"|"+String(spectrumtop));
			xf3(clickedonSpectrum(mouseCoords[0]-spectrumleft,mouseCoords[1]-spectrumtop),imod); // sets currentcolours and moves sliders
			changeofcolourvalue(imod==0,true);
		}
	}
	
	
	
// **************************************************** function spectrumMouseOut event called on mouseout
	function spectrumMouseOut(e){
		mouseon=false;
	}

// *************************************************** function clickedonSpectrum returns colour
	function clickedonSpectrum(xoffset, yoffset){

		var iItem=0;
		if(yoffset==(colourhalf-1)){
			return toprowcolours[xoffset];
		} else {	
			if(yoffset<colourhalf){
				iItem=yoffset;

				tempsteps1= gradient(colourhalf, 0xFFFFFF,toprowcolours[xoffset]);

				return tempsteps1[iItem];
			} else {
				if(yoffset<(colourhalf*2)){
					iItem=yoffset-colourhalf;
					tempsteps1= gradient(colourhalf, toprowcolours[xoffset],0);
					return tempsteps1[iItem];
				} else {
					return blacktowhite[yoffset-(colourhalf*2)];
				}
			}	
		}
	}

//	************************************************ function changeofcolourvalue
function changeofcolourvalue(istextvalue, doreadability){
	xf1(istextvalue); // sets the hex values
	xf2(istextvalue); // sets the sample area
	setrgbs(istextvalue*3, doreadability); // sets rgbs and does readability values


}

// Thnks to Quirksmode.org for this, see http://www.xs4all.nl/~ppk/js/index.html?dhtmloptions.html
// *************************************************** function getObj
	function getObj(name){
	  if (document.getElementById)  {
	  	this.obj = document.getElementById(name);
		this.style = document.getElementById(name).style;
	  } else if (document.all)  {
		this.obj = document.all[name];
		this.style = document.all[name].style;
	  }  else if (document.layers)  {
		this.obj = getObjNN4(document,name);
		this.style = this.obj;
	  }
	}

	function getObjNN4(obj,name){
		var x = obj.layers;
		var thereturn;
		for (var i=0;i<x.length;i++)	{
		if (x[i].id == name)
		 	thereturn = x[i];
		else if (x[i].layers.length)
			var tmp = getObjNN4(x[i],name);
			if (tmp) thereturn = tmp;
		}
		return thereturn;
	}

// End mini-API
	
// still unqualified thanks to quirksmode.org
// *********************************************** function findPosX
	function findPosX(obj){
        var curleft = 0;
        if (obj.offsetParent)
        {
                while (obj.offsetParent)
                {
                        curleft += obj.offsetLeft
                        obj = obj.offsetParent;
                }
        }
        else if (obj.x)
                curleft += obj.x;
        return curleft;
	}
// ********************************************** function findPosY
	function findPosY(obj){
        var curtop = 0;
        if (obj.offsetParent)
        {
                while (obj.offsetParent)
                {
                        curtop += obj.offsetTop
                        obj = obj.offsetParent;
                }
        }
        else if (obj.y)
                curtop += obj.y;
        return curtop;
	}
	
//	set innerHTML
// **********************************************************  function innerText
	function innerText(name, vVar){

	  	if (document.getElementById)  {
			if(document.getElementById(name)){
		  		document.getElementById(name).innerHTML=vVar;
			}
		}
		else if (document.all){
			if(document.all[name]){
				document.all[name].innerHTML=vVar;
			}
		}
  		else if (document.layers){
   			if(document.layers[name]){
				document.layers[name].innerHTML=vVar;
			}
		} else {
		
  		}
	}	
	
	
	
	
	
//  and now, some code from me	
//	*********************************************function loadedup
	function loadedup(isource){
		iPageType=isource;
		var n;
		for(var k=0; k<6; k++){
			if((isource==0)||(isource==2)||(isource==3)){
				setmouseevents(k);
			}
			n=k+1;
		
			tempsteps= gradient(chunks , horizlumps[k], horizlumps[n]);		
			for(n=0; n<chunks; n++){
				toprowcolours[(k*chunks)+n]=tempsteps[n];	
			}
		}
		if(isource!=3){
			setmouseevents(6);
		}
		if(isource==1){
			for(k=7;k<13;k++){
				setmouseevents(k);
			}
			for(k=0; k<420; k++){
				samplearealines[k]=new getObj("samplearealine"+(k+1));
			}
			var initialcolours=new Array(0x7F7F7F, 0, 0xFFFFFF);
			for(k=0;k<3;k++){
				xf3(initialcolours[k],k*3);
			
			
			}

		}
		if(isource==3){
			for(k=0;k<3;k++){
				samplearea3Obj[k] = new getObj("samplearea"+k);
			}
			additivehexObj=new getObj("additivehex");
			additiveRGBObj=new getObj("additiveRGB");
		} else {
			sampleareaObj = new getObj("samplearea");
			textreadableObjb=new getObj("makelegibleb");
			qualityimagegoodObj=new getObj("qualityimagegood");
			qualityimagepoorObj=new getObj("qualityimagepoor");
			qualitytextObj=new getObj("legibilityseems");

			yiqtvalueObj=new getObj("yiqtvalue");

			yiqbvalueObj=new getObj("yiqbvalue");

			yiqdiffObj=new getObj("yiqdiff");
			yiqcdiffObj=new getObj("yiqcdiff");
			
			yiqrangeObj=new getObj("yiqrange");
		}
		textrgbObj[0]=new getObj("textrgb");
		textrgbObj[1]=new getObj("backgroundrgb");
		spectrumObj = new getObj('spectrum');


		var strX="";
		for(k=0;k<4;k++){
			if(k>1){
				strX="b";
				n=k-2;
			}	else {
				n=k;
			}
	
			if((isource==2)||(isource==3)||(k<2)){

				unisliders[k]=new getObj("lockslider"+strX+n);
				if (document.addEventListener){
					unisliders[k].obj.addEventListener('click', unislidersclick,true);
				} else {
					if(document.attachEvent){
						if(k==0){
							unisliders[k].obj.attachEvent('onclick',unislider0click);
						} else if(k==1){
							unisliders[k].obj.attachEvent('onclick',unislider1click);
						} else if(k==2){
							unisliders[k].obj.attachEvent('onclick',unislider2click);
						} else if(k==3){
							unisliders[k].obj.attachEvent('onclick',unislider3click);
						}					
					}
				}	
			}			
		}


		spectrumleft=findPosX(spectrumObj.obj);
		spectrumtop=findPosY(spectrumObj.obj);

//  we've already sent the user a message if the event registration model won't work on this machine.		
		if (document.addEventListener){
			spectrumObj.obj.addEventListener('mouseup',spectrumMouseUp,true);
			spectrumObj.obj.addEventListener('mouseout',spectrumMouseOut,true);
			spectrumObj.obj.addEventListener('mousemove',spectrumMouseMove,true);

		} else {
			if(document.attachEvent){
				spectrumObj.obj.attachEvent('onmouseup',spectrumMouseUp);
				spectrumObj.obj.attachEvent('onmouseout',spectrumMouseOut);
				spectrumObj.obj.attachEvent('onmousemove',spectrumMouseMove);
			}
		}
// for some reason in Firefox the values aren't always being reset on reload
		if(isource!=3){
			var fontselect=new getObj("fontselect");
			changeselectfont(fontselect.obj.value);
			document.cpradios.Text0.value="more pay";
			document.cpradios.Eye1.value="#000000";

			document.cpradios.Eye0.value="#FFFFFF";
		} else {
			document.cpradios.Eye1.value="#00FF00";

			document.cpradios.Eye0.value="#FF0000";
		
		}
		document.cpradios.lockslider0.checked=false;
		document.cpradios.lockslider1.checked=false;
		setcolourvalues();  //  then presets on html file aren't significant
	}
	
//	************************************************ function moveColour
function moveColour(colournum, imod, andsetslider, doreadability){


	if(andsetslider){		
		slidersArray[colournum].setPosition(1-(currentcolours[colournum]/255));	
	}
	if(doreadability){		// final one of this block
		xf1( !imod);	// xf1 sets the hex values
		xf2(!imod);	//  xf2 sets the sample area colour
		setrgbs(imod, true);  //  setrgbs sets the rgb values and does readability values

		document.cpradios.cpradio[imod/3].checked=true;
	}
}



//	************************************************* function movefont
function movefont(currentFontSize){
	vSize=String(currentFontSize)+'pt';
	innerText("pointsize",vSize);
	sampleareaObj.style.fontSize=vSize;

	for(var i=0;i<2;i++){
		yiqrangeul[i]=parseInt((fontadjuststp[i]*(Math.pow(1-(fontadjustpc[i]/100),currentFontSize-4)))+0.5);
	}

	//  this formula magically gives the font size increased by 2.5% for each font-point 
	
//	yiqrangeul[1]=0-yiqrangeul[1];
	yiqrangeObj.obj.innerHTML=yiqrangeul[0]+" to "+yiqrangeul[1];
	tryforreadability();
}

// ************************************************** function changetext
function changetext(){
	var C8=String(document.cpradios.Text0.value);
	if(C8.length>8){
		C8=C8.substring(0,8);
	}

//	innerText("samplearea","<BR>"+C8);
	sampleareaObj.obj.innerHTML="<BR>"+C8;
}

// ************************************************ function changeselectfont
function changeselectfont(strFonts){
		
	sampleareaObj.style.fontFamily=strFonts;
	currentfontset=strFonts;
}
// *********************************************** function setspecificfont
function setspecificfont(){
	var wantedfont=document.cpradios.nameoffont.value;
	if(wantedfont==""){
		wantedfont=currentfontset;
	}
	sampleareaObj.style.fontFamily=wantedfont;
	
}	



// ********************************************** function setcolourvalues called when user clicks Set button
function setcolourvalues(){

	if(setcolourvalueitem(document.cpradios.Eye0.value,0)){
		if(setcolourvalueitem(document.cpradios.Eye1.value,3)){
			xf1(true); // sets the hex values
			xf1(false)
			xf2(true); // sets the sample area
			xf2(false)
			setrgbs(0, true); // sets rgbs 
			setrgbs(3,true) // and does readability values
		}
	}

}

// ********************************************** function setcolourvalueitem 

function setcolourvalueitem(icolourstring, iIndex){
	var ret=1;

	var acolourstring=icolourstring;
	var hexchars="0123456789ABCDEFabcdef";
	var thischar="s";
	var maxdec=((256*256*256)-1);		
//  trim leading and trailing spaces
	while(thischar=="s"){
		if(acolourstring.length>0){
			if(acolourstring.substr(0,1)==" "){
				acolourstring=acolourstring.substr(1);
			} else if(acolourstring.substr(acolourstring.length-1,1)==" ") {		
				acolourstring=acolourstring.substr(0,acolourstring.length-1);
			}	else {
				thischar="";
			}
			
		} else {
			ret=0;	
			thischar="";
		}
		
		
	}
	var hexformat=(acolourstring.substr(0,1)=="#");
	var rgbformat=acolourstring.indexOf(",")>0;


	if(hexformat){
		if(acolourstring.length<2){
			ret=0;
		} else {
			acolourstring=acolourstring.substr(1);
		}
	}		
	if(ret==1){
		var colourindexmod=1;
		var acolour=0;
		var i=2;
		var trgbs=new Array(0,0,0);
		for(n=acolourstring.length-1;n>=0;n--){
			thischar=acolourstring.substr(n,1);
			thisPos=hexchars.indexOf(thischar);
			if(thisPos>15){
				thisPos=thisPos-6;
			}
		
			if(rgbformat&&ret){
				if(thischar!=" "){
					if(thischar==","){
						if(i==0){
							ret=0;
						} else {
							i--;
							colourindexmod=1;
						}
					} else {
						thisPos=hexchars.indexOf(acolourstring.substr(n,1));
						if((thisPos<0)||(thisPos>9)){
							ret=0;
						} else {
							trgbs[i]=trgbs[i]+(thisPos*colourindexmod);
							colourindexmod=colourindexmod*10;
							if(trgbs[i]>255){
								ret=0;
							}
						}
					}
				}
													

			} else if(hexformat&&ret){

				if(colourindexmod==1){
					acolour=thisPos;
					colourindexmod=16;
				} else if(i<0){
					ret=0;
				} else { 	
					acolour=acolour+(thisPos*colourindexmod);
					colourindexmod=1;
					trgbs[i]=acolour;
					acolour=0;
					i--;
				}							
			} else if(ret){
				acolour=acolour+(thisPos*colourindexmod);
				colourindexmod=colourindexmod*10;
				if(acolour>maxdec){
					ret=0;
				}	
			}		
		}
	}	
	if(ret==1){
		if(hexformat||rgbformat){
			for(n=0;n<3;n++){
				currentcolours[iIndex+n]=trgbs[n];
			}
			acolour=-1;
		}
		xf3(acolour, iIndex);  // if decimal number xf3 splits acolour out, otherwise (=-1) it doesn't

	}
	if(!ret){
		alert("'"+String(icolourstring)+"' is not a decimal number, or a hexadecimal number beginning with #, or rgb values separated by commas"); 
	
	
	}
	return ret;
}

//	********************************************** function setrgbs display the rgb values and check readability values
function setrgbs(imod, anddoreadability){
	var strrgb=String(currentcolours[0+imod])+","+String(currentcolours[1+imod])+","+String(currentcolours[2+imod]);
	textrgbObj[imod/3].obj.innerHTML=strrgb;

	if(anddoreadability&&(iPageType!=3)){
		
		if(imod==3){
			yiqbv=parseInt((getyiq(currentcolours, 3))+0.5);
			yiqbvalueObj.obj.innerHTML=yiqbv;
		} else {
			yiqtv=parseInt((getyiq(currentcolours, 0))+0.5);
			yiqtvalueObj.obj.innerHTML=yiqtv;
		
		}	
		yiqdiffv=yiqtv-yiqbv;
		yiqdiffObj.obj.innerHTML=yiqdiffv;

		bgcdiff=getcolourdiff(currentcolours);
		yiqcdiffObj.obj.innerHTML=String(bgcdiff);
	
	
		tryforreadability();

	}

}	
/*
// ********************************************** function getbrightnessdiff
function getbrightnessdiff(trycolours, setglobalvars){
	var ibdiff=new Array(0,0);
	var bgc=backgroundyiq();

	var bgyiq= bgc[4];

	var txtyiq=textyiq(trycolours);
	if(bgyiq>txtyiq){
		if(setglobalvars){
			textbrighterthanbackground=-1; // background brighter than text so we'll first try adjusting colours downwards
		}
		ibdiff[0]=Math.floor(bgyiq-txtyiq);
	}else if(txtyiq>bgyiq){
		if(setglobalvars){
	
			textbrighterthanbackground=1;
		}
		ibdiff[0]=Math.floor(txtyiq-bgyiq);
	
	} else {	// they're the same
		if(setglobalvars){
			if(bgyiq>128){
				textbrighterthanbackground=-1;
			} else {
				textbrighterthanbackground=1;
			
			}	
		}
		ibdiff[0]=0;
	}	





	return ibdiff;	
	
}

// ********************************************* function backgroundyiq
function backgroundyiq(){
	var bgc=new Array(currentcolours[0+3]*brightnessweightings[0] , currentcolours[1+3]*brightnessweightings[1] , currentcolours[2+3]*brightnessweightings[2],0,0);
	bgc[3]= ( (bgc[0]+((255-currentcolours[0+3])*0.047)) + (bgc[1]+((255-currentcolours[1+3])*0.092)) + (bgc[2]+((255-currentcolours[2+3])*0.018)) );

	bgc[4]= bgc[0]+bgc[1]+bgc[2];
	return bgc;
	
}
*/
// ********************************************** function textyiq
function getyiq(trycolours, imod){
	return ( (trycolours[0+imod]*brightnessweightings[0])+(trycolours[1+imod]*brightnessweightings[1])+(trycolours[2+imod]*brightnessweightings[2]) );
}
// ********************************************** function getgcolourdiff
function getcolourdiff(trycolours){

	var bgcdiff=0;
	for(i=0;i<3;i++){
		bgcdiff=bgcdiff+(Math.max(trycolours[i],currentcolours[i+3])-Math.min(trycolours[i],currentcolours[i+3]));
	}
	return bgcdiff;

}
//	********************************************* function tryforreadability
function tryforreadability(){
//	if((currentbrightnessdiff<goodnessestimate[0])||(currentcolourdiff<goodnessestimate[1])){
	var lseems="legibilityseems";
	var litpoor="poor";
	var litgood="good";
	if(rangeispoor(yiqdiffv)){

		flipgoodpoorcaptions(litpoor,lseems, qualityimagegoodObj, qualityimagepoorObj);
		textreadableObjb.style.visibility="visible";
		
		
																
	} else {
		flipgoodpoorcaptions(litgood,lseems,qualityimagepoorObj, qualityimagegoodObj);
		textreadableObjb.style.visibility="hidden";
		
	}

		
	
}
// ********************************************** function rangeisgood
function rangeispoor(onthisdiff){
	return (onthisdiff<(yiqrangeul[0]+1))&&(onthisdiff>(yiqrangeul[1]-1));

}
//	********************************************* function flipgoodpoorcaptions
function flipgoodpoorcaptions(goodorpoor, textfieldname, hidObj, visObj){
	innerText(textfieldname,goodorpoor);
			
	hidObj.style.width="0px";
	hidObj.style.visibility="hidden";
	visObj.style.width="18px";
	visObj.style.visibility="visible";
		
	
}
//	******************************************** function makeereadable
function makereadable(whichone){	// whichone=1 = brightness  whichone=2 = colour
//  try to bring the text brighter or darker so it becomes readable	
//  do we have to adjust up or adjust down?	


	var newcolours=new Array(3);
	
	if(whichone==1){		// adjust brightness
			newcolours=moveforbrightness(currentcolours, 1, ((yiqtv>yiqbv)*2)-1);

	} else {	// whichone==2 - adjust for colour
		newcolours=adjustcolours(inc, currentcolours,1);			
	}
	if(newcolours[0]>-1){
		for(i=0;i<3;i++){
			currentcolours[i]=newcolours[i];
			moveColour(i, 0, false, i==2);
		}
		xf3(-1, 0);	// moves sliders and sets slider colour vars
	}			
	
}




// ************************************************** function moveforbrightness	
function moveforbrightness(workoncolours,  tries, inc){	
	
// adjust each slider up or down and see whether that works
	var testcolours=new Array(workoncolours[0],workoncolours[1],workoncolours[2]);
	var stop=0;
	var hitlimits=0;
		
	while(!stop){
		hitlimits=0;
		for(var i=0;i<3;i++){
			testcolours[i]=testcolours[i]+inc;
//if(tries==3){
//	alert(testcolours[i]);
//}
			if((testcolours[i]<0)||(testcolours[i]>255)){
				// hit a limit.
				// if 1st try, try the other way
				if(tries==1){
					testcolours=moveforbrightness(workoncolours,  2, 0-inc);
					stop=1;
					break;
				} else if(tries==2){
//		start again but allow other sliders to adjust to limits
					testcolours=moveforbrightness(workoncolours,  3, 0-inc);
					stop=1;
					break;
				} else if(tries==3){
					if(hitlimits==2){
//		start again but other way and allow other sliders to adjust to limits
						testcolours=moveforbrightness(workoncolours, 4, 0-inc);
						stop=1;
						break;
					} else {
						testcolours[i]=testcolours[i]-inc;  //put us back to where we were			
						hitlimits++;
					}
				} else {  //  we're on tries = 4
					if(hitlimits==2){
					// can't go any further
						alert('Unable to make text readable with a background brightness of '+yiqbv+' and font size '+sampleareaObj.style.fontSize);
						testcolours[0]=-1;
						stop=1;
						break;
					} else {
						testcolours[i]=testcolours[i]-inc;  //put us back to where we were			
						hitlimits++;
					}
				}
			} else {	//  testcolours are in range still, might as well test for brightness diff on each one
				if(!rangeispoor(getyiq(testcolours,0)-yiqbv)){
					stop=1;
					break;
				}
			}	
		}
	}



	return testcolours;

	
	

//  shouldn't loop too badly on recursions, we hope.

}

// ************************************************** function adjustcolour
function adjustcolours(inc, workoncolours, tries){

// try incrementing the colours in unison up or down and see whether it works
// don't know of any smarter method than this

// currently this routine is not used

	var ret=new Array(3);
	var testcolours=new Array(workoncolours[0],workoncolours[1],workoncolours[2]);
	var newcurrentcolourdiff=-1;
	var howmanyout=0;
	var i=0;
	var istop=0;
	while((newcurrentcolourdiff!=getcolourdiff(testcolours))&&(istop==0)){
		if(inc>0){
			if(testcolours[i]<255){
				testcolours[i]++;
			} else {
				howmanyout++;
			}
		} else {
			if(testcolours[i]>0){
				testcolours[i]--;
			} else {
				howmanyout++;
			}
		}
		if(howmanyout>2){
			if(tries==2){
				alert("Cannot adjust for colour difference at these values");  
				istop=-1;
			} else {
				testcolours=adjustcolours(0-inc,workoncolours,2);
				istop=testcolours[0];
			}			
		} else {
			if(i==2){
				i=0;
			} else {
				i++;
			}
		}							
	}
	if(istop==-1){
		return [-1,-1,-1];
	} else {	
		return testcolours;
	}
}