if(typeof IdeorisLib == 'undefined')
	IdeorisLib = {};

if(typeof IdeorisLib.Classes == 'undefined')
	IdeorisLib.Classes = {};

IdeorisLib.CrossBrowser = {
	IE:  document.all?true:false ,
	ns4: false,
	op5: false,
	op6: false,
	agt: "",
	mac: false,
	ie: false,
	mac_ie: false,

	init: function()
	{
		this.unreferenced.init();
	},

	SniffBrowser: function()
	{
		ns4 = document.layers;
		op5 = (navigator.userAgent.indexOf("Opera 5")!=-1) 
			||(navigator.userAgent.indexOf("Opera/5")!=-1);
		op6 = (navigator.userAgent.indexOf("Opera 6")!=-1) 
			||(navigator.userAgent.indexOf("Opera/6")!=-1);
		agt=navigator.userAgent.toLowerCase();
		mac = (agt.indexOf("mac")!=-1);
		ie = (agt.indexOf("msie") != -1); 
		mac_ie = mac && ie;
	},

	GetMouseX: function(e) 
	{
		var tempX = -1;

		if(!e)
			e = window.event;

		if (e.pageX)
		{
			tempX = e.pageX;
		} 
		else if (e.clientX) 
		{
			tempX = event.clientX + document.body.scrollLeft;
		}

		return tempX;
	},

	GetMouseY: function (e)
	{
		var tempY = -1;

		if(!e)
			e = window.event;

		if (e.pageY)
		{
			tempY = e.pageY;
		} 
		else if (e.clientY) 
		{
			tempY = event.clientY + document.body.scrollTop;
		}

		return tempY;
	},


	GetMouseXY: function (e)
	{
		var tempY = -1;
		var tempX = -1;

		if(!e)
			e = window.event;

		if (e.pageY)
		{
			tempY = e.pageY;
		} 
		else if (e.clientY) 
		{
			tempY = event.clientY + document.body.scrollTop;
		}

		if (e.pageX)
		{
			tempX = e.pageX;
		} 
		else if (e.clientX) 
		{
			tempX = event.clientX + document.body.scrollLeft;
		}

		return [tempX, tempY];
	},

	findPosX: function(paramObject)
	{
		var obj = this.GetObject(paramObject);
		var curleft = 0;

		if(!obj)
			return curleft;

		if(obj.offsetParent)
		{
			while(1) 
			{
			  curleft += obj.offsetLeft;

			  if(!obj.offsetParent)
				break;

			  obj = obj.offsetParent;
			}
		}
		else if(obj.x)
		{
			curleft += obj.x;
		}

		return curleft;
	},

	GetAttrPixValue: function(e,a)
	{
		var px=0;
		if(window.getComputedStyle)
		{
			var css,sty=window.getComputedStyle(e,'');
			if(sty && sty.getPropertyCSSValue)
			{
				css = sty.getPropertyCSSValue(a);
				if((css) && css.primitiveType<=18)
				{
					try
					{
						px=css.getFloatValue(5)|0;
					}
					catch (e)
					{
					}
				}
			}
		}

		return px;
	},

	findPosY: function(paramObject, debug)
	{
		var obj = this.GetObject(paramObject);
		var curtop = 0;

		if(!obj)
			return curtop;

		if(obj.offsetParent)
		{
			while(1)
			{
			  curtop += obj.offsetTop;

			  if(debug)
				{
					//alert(obj.tagName);
				  //alert("Current Top: " + curtop);
				}

			  if(!obj.offsetParent)
				break;

			  obj = obj.offsetParent;
			}
		}
		else if(obj.y)
			curtop += obj.y;

		return curtop;
	},

	FindPosXY: function(paramObject)
	{
		var obj = this.GetObject(paramObject);
		var curTop = 0;
		var curLeft = 0;

		if(!obj)
			return [curTop, curLeft];

		if(obj.offsetParent)
			while(1)
			{
			  curTop += obj.offsetTop;
			  curLeft += obj.offsetLeft;

			  if(!obj.offsetParent)
				break;

			  obj = obj.offsetParent;
			}
		else
		{
			curTop += obj.y;
			curLeft += obj.x;
		}

		return [curTop, curLeft];
	},

	GetScrollXY: function(objectId) 
	{
		var elem = this.GetObject(objectId);
		var scrOfX = 0, scrOfY = 0;

		if( typeof( elem.pageYOffset ) == 'number' ) {
			//Netscape compliant
			scrOfY = elem.pageYOffset;
			scrOfX = elem.pageXOffset;
		} 
		else if( elem.scrollLeft || elem.scrollTop ) 
		{
			//DOM compliant
			scrOfY = elem.scrollTop;
			scrOfX = elem.scrollLeft;
		}

		return [ scrOfX, scrOfY ];
	},

	GetScrollDimensions: function(objectId)
	{
		var elem = this.GetObject(objectId);
		
		return [ elem.scrollWidth, elem.scrollHeight ];
	},

	GetWindowScrollXY: function()
	{
		var scrOfX = 0, scrOfY = 0;

		if( typeof( window.pageYOffset ) == 'number' ) 
		{
			//Netscape compliant
			scrOfY = window.pageYOffset;
			scrOfX = window.pageXOffset;
		} 
		else if( document.body && ( document.body.scrollLeft || document.body.scrollTop ) ) 
		{
			//DOM compliant
			scrOfY = document.body.scrollTop;
			scrOfX = document.body.scrollLeft;
		} 
		else if( document.documentElement && ( document.documentElement.scrollLeft || document.documentElement.scrollTop ) ) 
		{
			//IE6 standards compliant mode
			scrOfY = document.documentElement.scrollTop;
			scrOfX = document.documentElement.scrollLeft;
		}

		return [ scrOfX, scrOfY ];
	},

	GetElementHeight: function(objectId) 
	{
		var elem = this.GetObject(objectId);

		if (this.ns4) 
			return elem.clip.height;
		else 
		{
			if (this.op5) 
				xPos = elem.style.pixelHeight;
			else 
				xPos = elem.offsetHeight;

			return xPos;
		} 
	},

	GetElementWidth: function(objectId) 
	{
		var elem = this.GetObject(objectId);

		if (this.ns4) 
			return elem.clip.width;
		else 
		{
			if (this.op5) 
				xPos = elem.style.pixelWidth;
			else 
				xPos = elem.style.width;

			return parseInt(xPos);
		}
	},

	GetElementDimensions: function(objectId)
	{
		var elem = this.GetObject(objectId);
		var nWidth = 0;
		var nHeight = 0;

		if (this.ns4) 
		{
			nWidth = elem.clip.width;
			nHeight = elem.clip.height;
		}
		else 
		{
			var xPos = 0;
			var yPos = 0;

			if (this.op5) 
			{
				xPos = elem.style.pixelWidth;
				yPos = elem.style.pixelHeight;
			}
			else 
			{
				xPos = elem.style.width;
				yPos = elem.style.height;
			}

			nWidth = parseInt(xPos);
			nHeight = parseInt(yPos);
		}

		return [nWidth, nHeight];
	},

	GetElementClientDimensions: function(objectId)
	{
		var elem = this.GetObject(objectId);
		var nWidth = 0;
		var nHeight = 0;

		if (this.ns4) 
		{
			nWidth = elem.clip.width;
			nHeight = elem.clip.height;
		}
		else 
		{
			var xPos = 0;
			var yPos = 0;

			if (this.op5) 
			{
				xPos = elem.style.pixelWidth;
				yPos = elem.style.pixelHeight;
			}
			else 
			{
				xPos = elem.clientWidth;
				yPos = elem.clientHeight;
			}

			nWidth = xPos;
			nHeight = yPos;
		}

		return [nWidth, nHeight];
	},

	/*Includes border width*/
	GetElementActualDimensions: function(objectId)
	{
		var objStyle = IdeorisLib.CrossBrowser.GetStyleObject(objectId);
		var arrClientDimensions = IdeorisLib.CrossBrowser.GetElementClientDimensions(objectId);

		var arrBorderSizes = this.GetElementBorderSizes(objectId);

		arrClientDimensions[0] += (arrBorderSizes[2] + arrBorderSizes[3]);
		arrClientDimensions[1] +=  (arrBorderSizes[0] + arrBorderSizes[1]);

		return arrClientDimensions;
	},

	GetElementBorderSizes: function(objectId)
	{
		var objStyle = IdeorisLib.CrossBrowser.GetStyleObject(objectId);

		var nBorderLeftWidth  = 0;
		var nBorderRightWidth = 0;
		var nBorderTopWidth  = 0;
		var nBorderBottomWidth = 0;

		if(objStyle.borderLeftWidth != "")
			nBorderLeftWidth = parseInt(objStyle.borderLeftWidth);

		if(objStyle.borderLeftWidth != "")
			nBorderRightWidth = parseInt(objStyle.borderRightWidth);

		if(objStyle.borderLeftWidth != "")
			nBorderTopWidth = parseInt(objStyle.borderTopWidth);

		if(objStyle.borderLeftWidth != "")
			nBorderBottomWidth = parseInt(objStyle.borderBottomWidth);

		return [nBorderTopWidth, nBorderBottomWidth, nBorderLeftWidth, nBorderRightWidth];
	},

	SetElementWidth: function(objectId, width)
	{
		var elem = this.GetObject(objectId);

		if (this.ns4) 
			elem.clip.width = width;
		else 
		{
			if (this.op5) 
				elem.style.pixelWidth = width;
			else if(typeof (elem.width) == 'number')
				elem.width = width;
			else
				elem.style.width = width;
		}
	},

	GetElementOffsetDimensions: function(objectId)
	{
		var elem = this.GetObject(objectId);
		var nWidth = 0;
		var nHeight = 0;

		if (this.ns4) 
		{
			nWidth = elem.clip.width;
			nHeight = elem.clip.height;
		}
		else 
		{
			var xPos = 0;
			var yPos = 0;

			if (this.op5) 
			{
				xPos = elem.style.pixelWidth;
				yPos = elem.style.pixelHeight;
			}
			else 
			{
				xPos = elem.offsetWidth;
				yPos = elem.offsetHeight;
			}

			//alert("GetElementOffsetDimensions: " + elem.id + ": " + xPos + "---" + yPos);

			nWidth = parseInt(xPos);
			nHeight = parseInt(yPos);
		}

		return [nWidth, nHeight];
	},

	
	GetElementOffsetWidth: function(objectId) 
	{
		var elem = this.GetObject(objectId);

		if (this.ns4) 
			return elem.clip.width;
		else 
		{
			if (this.op5) 
				xPos = elem.style.pixelWidth;
			else 
				xPos = elem.offsetWidth;

			return parseInt(xPos);
		}
	},

	GetWindowDimensions: function()
	{
		if(typeof window.innerWidth != 'undefined')
			return [window.innerWidth, window.innerHeight];

		if(typeof document.documentElement.clientWidth != 'undefined')
		{
			if(document.documentElement.clientWidth > 0)
				return [document.documentElement.clientWidth, document.documentElement.clientHeight];
		}

		return [document.body.clientWidth, document.body.clientHeight];
	},

	getImageWidth: function(myImage) 
	{
		var x, obj;
		if (document.layers) 
		{
			var img = this.getImage(myImage);
			return img.width;
		} 
		else 
		{
			return this.getElementWidth(myImage);
		}
		return -1;
	},

	getImageHeight: function(myImage) 
	{
		var y, obj;
		if (document.layers) 
		{
			var img = this.getImage(myImage);
			return img.height;
		}
		else 
		{
			return this.getElementHeight(myImage);
		}
		return -1;
	},

	findImage: function(name, doc) 
	{
		var i, img;
		for (i = 0; i < doc.images.length; i++) 
		{
			if (doc.images[i].name == name) 
			{
				return doc.images[i];
			}
		}
		for (i = 0; i < doc.layers.length; i++) 
		{
			if ((img = this.findImage(name, doc.layers[i].document)) != null) 
			{
				img.container = doc.layers[i];
				return img;
			}
		}
		return null;
	},

	getImage: function(name) 
	{
		if (document.layers) 
		{
			return this.findImage(name, document);
		}
		return null;
	},

	MoveXY: function(myObject, x, y, bRelativeToParent, bXYArePageCoordinates, debug) 
	{
		var parentObj = null;
		var obj = this.GetObject(myObject);
		var objStyle = this.GetStyleObject(myObject);
		var nParentDifX = 0;
		var nParentDifY = 0;
		var nPageCoordinateX = x;
		var nPageCoordinateY = y;
		var nParentX = 0;
		var nParentY = 0;
		var nCurrentObjX = 0;
		var nCurrentObjY = 0;

		if(objStyle == false)
			return;

		if(obj && bRelativeToParent)
		{
			parentObj = obj.offsetParent;

			if(parentObj)
			{
				nParentX = this.findPosX(parentObj);
				nCurrentObjX = this.findPosX(obj);
				nParentY = this.findPosY(parentObj);
				nCurrentObjY = this.findPosY(obj);

				nParentDifX = nCurrentObjX - nParentX;
				nParentDifY = nCurrentObjY - nParentY;

				if(bXYArePageCoordinates)
				{
					nPageCoordinateX = nPageCoordinateX - nCurrentObjX + nParentDifX;
					nPageCoordinateY = nPageCoordinateY - nCurrentObjY + nParentDifY;
				}
				else
				{
					nPageCoordinateY = nPageCoordinateY + nParentDifY;
					nPageCoordinateX = nPageCoordinateX + nParentDifX;
				}

				if(debug)
				{
					if(window.AppendText)
						window.AppendText("PageCoordinates: Y: " + nPageCoordinateY + " X: " + nPageCoordinateX);
				}

			}
		}


		if (this.ns4) 
		{
			objStyle.top = nPageCoordinateY;
			objStyle.left = nPageCoordinateX;
		} 
		else 
		{
			if (this.op5) 
			{
				objStyle.pixelTop = nPageCoordinateY;
				objStyle.pixelLeft = nPageCoordinateX;
			}
			else 
			{
				objStyle.top = nPageCoordinateY + "px";
				objStyle.left = nPageCoordinateX + "px";

				if(debug)
				{
					//objStyle.top = "100px";
					if(window.AppendText)
						window.AppendText("Obj style: Top: " + objStyle.top + "  Left: " + objStyle.left);
				}
			}	
		}
	},

	MoveX: function(myObject, x, bRelativeToParent) 
	{
		var parentObj = null;
		var obj = this.GetObject(myObject);
		var objStyle = this.GetStyleObject(myObject);
		var nParentDifX = 0;

		if(obj && bRelativeToParent)
		{
			parentObj = obj.offsetParent;

			if(parentObj)
			{
				var nParentX = this.findPosX(parentObj);
				var nCurrentObjX = this.findPosX(obj);

				nParentDifX = nCurrentObjX - nParentX;
			}
		}

		if (this.ns4) 
			objStyle.left = x + nParentDifX;
		else 
		{
			if (this.op5) 
				objStyle.pixelLeft = x + nParentDifX;
			else 
				objStyle.left = x + nParentDifX;
		}
	},
	
	MoveY: function(myObject, y, bRelativeToParent, debug) 
	{
		var parentObj = null;
		var obj = this.GetObject(myObject);
		var objStyle = this.GetStyleObject(myObject);
		var nParentDifY = 0;

		if(obj && bRelativeToParent)
		{
			parentObj = obj.offsetParent;

			if(parentObj)
			{
				var nParentY = this.findPosY(parentObj);
				var nCurrentObjY = this.findPosY(obj);

				nParentDifY = nCurrentObjY - nParentY;
			}
		}

		if (ns4) 
			objStyle.top = y + nParentDifY;
		else 
		{
			if (op5) 
				objStyle.pixelTop = y + nParentDifY;
			else 
			{
				if(debug)
				{
					window.AppendText("Y: " + y + " nParentDifY: " + nParentDifY);
				}

					
				objStyle.top = (y + nParentDifY) + "px";
			}
		}
	},

	MoveDistByX: function(myObject, x) 
	{
		var obj = this.GetObject(myObject);
		var objStyle = this.GetStyleObject(myObject);

		if (this.ns4) 
			objStyle.left += parseInt(x);
		else 
		{
			if (this.op5) 
				objStyle.pixelLeft += parseInt(x);
			else 
			{
				if(typeof objStyle.posLeft != "undefined")
				{
					objStyle.posLeft += x; //For IE
				}
				else
				{
					var nLeftVal = 0;
					if(objStyle.left != "")
						nLeftVal = parseInt(objStyle.left);

					objStyle.left = (nLeftVal + parseInt(x)) + 'px'; //For Mozilla
				}
			}
		}
	},

	MoveDistByY: function(myObject, y) 
	{
		var obj = this.GetObject(myObject);
		var objStyle = this.GetStyleObject(myObject);

		if (this.ns4) 
			objStyle.top = parseInt(y);
		else 
		{
			if (this.op5) 
				objStyle.pixelTop += parseInt(y); // + parseInt(objY);
			else 
			{
				if(typeof objStyle.posTop != "undefined")
				{
					objStyle.posTop += parseInt(y); //For IE
				}
				else
				{
					var nTopVal = 0;
					if(objStyle.top != "")
						nTopVal = parseInt(objStyle.top);

					objStyle.top = (nTopVal + parseInt(y)) + 'px'; //For Mozilla
				}

			}
		}
	},

	GetPositionsDif: function(element1, element2, bOnlyIncClientArea)
	{
		var objElement1 = this.GetObject(element1);
		var objElement2 = this.GetObject(element2);

		var arrElement1_XY = IdeorisLib.CrossBrowser.FindPosXY(objElement1);
		var arrElement2_XY = IdeorisLib.CrossBrowser.FindPosXY(objElement2);

		//window.AppendText(arrElement1_XY + "[[[[]]]]" + arrElement2_XY);

		if(bOnlyIncClientArea)
		{
			var arrBorderSizes = this.GetElementBorderSizes(element1);

			arrElement1_XY[0] += arrBorderSizes[2]; //Left border
			arrElement1_XY[1] += arrBorderSizes[0]; //Top border
		}


		return [(arrElement2_XY[0] - arrElement1_XY[0]), (arrElement2_XY[1] - arrElement1_XY[1])];
	},

	GetObject: function(objectId)
	{
		//If not string type, then return the object itself
		if(typeof objectId != 'string')
			return objectId;

		if(document.getElementById && document.getElementById(objectId)) 
		{
			return document.getElementById(objectId);
		} 
		else if (document.all && document.all(objectId)) 
		{
			return document.all(objectId);
		} 
		else if (document.layers && document.layers[objectId]) 
		{
			return this.getObjNN4(document,objectId);
		} 
		else 
		{
			return false;
		}
	},
	
	MoveToObject: function(objectToMoveID, referencedObjectID, type, debug)
	{
		var objToMove = this.GetObject(objectToMoveID);
		var objReferenced = this.GetObject(referencedObjectID);
		var objToMoveStyle = this.GetStyleObject(objectToMoveID);
		var objReferencedStyle = this.GetStyleObject(referencedObjectID);

		if(!objToMove)
			return -1; //Not moved

		if(!objReferenced)
			return -2; //No referenced object

		var bPositionAbsolute = false;
		if(objToMoveStyle.position == "absolute" || this.GetComputedStyle(objectToMoveID, "position") == "absolute")
			bPositionAbsolute = true;


		var positionsReferencedObj = this.FindPosXY(objReferenced, debug);

		var objReferencedX = positionsReferencedObj[1];
		var objReferencedY = positionsReferencedObj[0];


		var objToMoveX = this.findPosX(objToMove);
		var objToMoveY = this.findPosY(objToMove);

		var newObjToMoveX = objReferencedX;
		var newObjToMoveY = objReferencedY;

		if(debug)
			alert("New Obj X: " + newObjToMoveX + " Y: " + newObjToMoveY + "  Old Obj X: " + objToMoveX + " Y: " + objToMoveY);

		switch(type)
		{
			case 6: //Top left + b/w element client
			case 1: //Top Left
			{
				if(type == 6)
				{
					var borderTopWidth = 0;
					var borderLeftWidth = 0;

					if(objReferencedStyle.borderTopWidth != "")
						borderTopWidth = parseInt(objReferencedStyle.borderTopWidth);

					if(objReferencedStyle.borderLeftWidth != "")
						borderLeftWidth = parseInt(objReferencedStyle.borderLeftWidth);

					if(typeof borderLeftWidth == 'undefined' || borderLeftWidth == "")
						borderLeftWidth = 0;

					if(objToMoveX != objReferencedX)
						newObjToMoveX += parseInt(borderLeftWidth);

					if(objToMoveY != objReferencedY)
						newObjToMoveY += parseInt(borderTopWidth);
				}

				break;
			}
			case 2: //Top right
			case 5: //Top right within boundaries
			{
				var objReferencedWidth = this.GetElementWidth(objReferenced);
				//alert("Obj width: " + objReferencedWidth);
				newObjToMoveX += objReferencedWidth; 

				if(type == 5)
				{
					var objToMoveWidth = this.GetElementWidth(objToMove);

					var nBorderLeft = parseInt(objToMoveStyle.borderLeftWidth);
					var nBorderRight = parseInt(objToMoveStyle.borderRightWidth);

					newObjToMoveX -= (objToMoveWidth + nBorderLeft + nBorderRight);
				}

				//newObjToMoveX += ((objReferencedX - objToMoveX) + objReferencedWidth );
				//alert("NewOBjtoMoveX: " + newObjToMoveX + " objToMoveX: " + objToMoveX);
				break;
			}
			case 7: //Center in height (within client area)
			case 8: //Center b/w referenced client area + considering object to move height
			{
				var referencedObjClientDim = this.GetElementClientDimensions(objReferenced);
				var objToMoveActualDim = this.GetElementActualDimensions(objToMove);
				var arrPosDif = this.GetPositionsDif(objReferenced, objToMove, true /*bOnlyIncClientArea*/);
				var arrBorderSizes = this.GetElementBorderSizes(objReferenced);

				var nHeight = referencedObjClientDim[1];
				var nHeightMid = parseInt(nHeight / 2);

				newObjToMoveY += arrBorderSizes[0];

				if(type == 7)
				{
					if(nHeightMid != arrPosDif[1])
					{
						newObjToMoveY += (nHeightMid - arrPosDif[1]);
						newObjToMoveX += (arrBorderSizes[2]);
					}
				}
				else if(type == 8)
				{
					if(objToMoveActualDim[1] < referencedObjClientDim[1])
					{
						var nAvailableHeight = referencedObjClientDim[1] - objToMoveActualDim[1];
						nHeightMid = parseInt(nAvailableHeight / 2);

						if(nHeightMid != arrPosDif[1])
						{
							newObjToMoveY += (nHeightMid - arrPosDif[1]);
							newObjToMoveX += (arrBorderSizes[2]);
						}
					}
				}

				break;
			}
			case 3: //Bottom left
			{

				var objReferencedHeight = this.GetElementHeight(objReferenced);

				if(debug)
				{
					alert("Object height: " + objReferencedHeight);

					if(window.AppendText)
						window.AppendText(objReferencedHeight + "--" + newObjToMoveY + "--" + bPositionAbsolute);
				}

				newObjToMoveY += objReferencedHeight;

				break;
			}
			case 4: //Bottom right
			{
				var objReferencedWidth = this.GetElementWidth(objReferenced);
				var objReferencedHeight = this.GetElementHeight(objReferenced);

				newObjToMoveX += objReferencedWidth;
				newObjToMoveY += objReferencedHeight;

				break;
			}
			default:
			{
				alert("Invalid type(" + type + "): valid types are 1 - top left, 2 - top right, 3 - bottom left, 4- bottom right");
				return;
			}

		}

		if(bPositionAbsolute)
		{
			this.MoveXY(objToMove, newObjToMoveX, newObjToMoveY, true, true, debug);
		}
		else
		{
			var difObjToMoveX = (objToMoveX - newObjToMoveX) * (-1);
			var difObjToMoveY = (objToMoveY - newObjToMoveY) * (-1);
			
			//alert(difObjToMoveX + "--" + difObjToMoveY);

			this.MoveDistByY(objToMove, difObjToMoveY);
			this.MoveDistByX(objToMove, difObjToMoveX);
		}

		return 1; //Successfully moved
	},

	MoveToTopLeft: function(objectToMoveID, referencedObjectID)
	{
		this.MoveToObject(objectToMoveID, referencedObjectID, 1);
	},

	MoveToTopRight: function(objectToMoveID, referencedObjectID)
	{
		this.MoveToObject(objectToMoveID, referencedObjectID, 2);
	},

	MoveToBottomLeft: function(objectToMoveID, referencedObjectID, debug)
	{
		this.MoveToObject(objectToMoveID, referencedObjectID, 3, debug);
	},

	MoveToBottomRight: function(objectToMoveID, referencedObjectID)
	{
		this.MoveToObject(objectToMoveID, referencedObjectID, 4);
	},

	Show: function(objectId)
	{
		var styleObj = this.GetStyleObject(objectId);

		if(styleObj)
			styleObj.display = "block";
	},

	Hide: function(objectId)
	{
		var styleObj = this.GetStyleObject(objectId);

		if(styleObj)
			styleObj.display = "none";
	},

	SetOpacity: function(objectId, opacityValue) 
	{ 
		var styleObj = this.GetStyleObject(objectId);
		
		if(!styleObj)
			return; //Failed to change object opacity

		//if(typeof styleObj.opacity != 'undefined')
		{
			styleObj.opacity = (opacityValue / 100); 
		}

		//if(typeof styleObj.MozOpacity != 'undefined')
			styleObj.MozOpacity = (opacityValue / 100); 

		//if(typeof styleObj.KhtmlOpacity != 'undefined')
			styleObj.KhtmlOpacity = (opacityValue / 100); 

		//if(typeof styleObj.filter != 'undefined')
			styleObj.filter = "alpha(opacity=" + opacityValue + ")"; 
	},

	GetStyleObject: function(objectId) 
	{
		var object = this.GetObject(objectId);

		if(typeof (object) == 'undefined')
			return false;

		if(document.layers && object)
			return object;
		else if(document.getElementById || document.all)
		{
			if(typeof (object.style) == 'undefined')
				return false;

			return object.style;
		}
		else
			return false;
	} ,


	GetComputedStyle: function(elementId, style) 
	{ 
		var element = this.GetObject(elementId); 

		var activeStyle = "";
		
		if(!element)
			return activeStyle;
		
		if (element.currentStyle) 
		{ 
			activeStyle = element.currentStyle[style]; 
		} 
		else if (window.getComputedStyle) 
		{ 
			var compstyle = window.getComputedStyle(element, ""); 
			activeStyle = compstyle.getPropertyValue(style);
		}

		return activeStyle; 
	}, 


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

	CancelEvent: function(e)
	{
		if(!e)
			e = window.event;

		if(typeof (e.cancelBubble) != 'undefined')
			e.cancelBubble = true;

		if(e.stopPropagation)
			e.stopPropagation();

	},

	unreferenced: {
		init: function() {
			IdeorisLib.CrossBrowser.SniffBrowser();
		}
	}
};

IdeorisLib.CrossBrowser.init();


//=================Ajax Class===========================================
IdeorisLib.Classes.AjaxClass = function(url, data)
{
	/*Private variables*/
	var m_url = url;
	var m_sendMethod = "GET";
	var m_sendData = data;
	var m_counter  = 0;
	

	/*public variables*/
	//this.m_responseText = "";

	/*public functions*/
	this.SetURL = SetURL;
	this.GetURL = GetURL;
	this.SetSendMethod = SetSendMethod;
	this.Send = Send;
	this.LaunchJavascript = LaunchJavascript;
	this.SetRequestData = SetRequestData;
	this.OnAjaxStateChange = OnAjaxStateChange;
	this.OnAjaxDataReceived = OnAjaxDataReceived;

	/*private functions*/
	function SetURL(url)
	{
		m_url = url;
	}

	function GetURL()
	{
		return m_url;
	}

	function SetSendMethod(sendMethod)
	{
		m_sendMethod = sendMethod;
	}

	function SetRequestData(data)
	{
		m_sendData = data;
	}

	//Empty functions
	function OnAjaxStateChange(httpObj, readyState)
	{
	}
	
	//Empty functions
	function OnAjaxDataReceived(httpObj, responseText)
	{
	}

	function Send()
	{
		var httpObj = IdeorisLib.Classes.AjaxClass.GetXMLHttpObject();

		//now we got the XmlHttpRequest object, send the request.
		if (httpObj)
		{
			var thisClassObj = this; //Closure will save this local variable (requires in onreadystatechange)s

			httpObj.onreadystatechange = function ()
			{
				if(window.OnAjaxStateChange)
					window.OnAjaxStateChange(thisClassObj, httpObj, httpObj.readyState);

				if(thisClassObj.OnAjaxStateChange)
					thisClassObj.OnAjaxStateChange(httpObj, httpObj.readyState);


				if(httpObj.readyState==4)
				{
					if(httpObj.status == 200)
					{
						if(window.OnAjaxDataReceived)
							window.OnAjaxDataReceived(thisClassObj, httpObj, httpObj.responseText);

						if(thisClassObj.OnAjaxDataReceived)
							thisClassObj.OnAjaxDataReceived(httpObj, httpObj.responseText);

					}
				}
			}

			var callingUrl = m_url;

			if(m_sendMethod == "GET")
			{
				var myDate = new Date();
				var myTime = myDate.getTime();

				//todo: find "?". If find then append "&" otherwise append "?"
				var urlAppend = "?";
				if(m_url.indexOf("?") != -1)
					urlAppend = "&";

				callingUrl = callingUrl + urlAppend + "CacheRemover_jsdfhjshfsdf=" + myTime;
			}

			httpObj.open(m_sendMethod, callingUrl, true);

			if(m_sendMethod == "POST")
			{
				httpObj.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
				httpObj.setRequestHeader("Content-length", m_sendData.length);
				httpObj.setRequestHeader("Connection", "close");
				httpObj.send(m_sendData);
			}
			else
			{ //send get request
				httpObj.send(null);
			}
		}		

		return true; //send request successful
	}

	function LaunchJavascript(responseText) 
	{
		var js = '';
		// RegExp from prototype.sonio.net
		//var ScriptFragment = "(?:<script.*?>)((\n|.)*?)(?:</script>)";
		var ScriptFragment = '(?:<script.*?>)((\n|\\r\\n|.)*?)(?:</script>)'; 

		var match    = new RegExp(ScriptFragment, 'img');
		var scripts  = responseText.match(match);
		
		
		if(scripts) 
		{
			var js = '';
			for(var s = 0; s < scripts.length; s++) 
			{
					var match = new RegExp(ScriptFragment, 'im');

					js += scripts[s].match(match)[1];
			}
			js = js.replace(/<!--/g,'').replace(/\/\/-->/g,'');
			eval(js);
		}
	}
};

/*Static function of Ajax Class*/
IdeorisLib.Classes.AjaxClass.GetXMLHttpObject = function()
{
	var xmlHttpObjName = null;
	try
	{    // Firefox, Opera 8.0+, Safari    
			xmlHttpObjName=new XMLHttpRequest();    
	}
	catch (e)
	{    
			// Internet Explorer    
			try
			{      
				xmlHttpObjName=new ActiveXObject("Msxml2.XMLHTTP");      
			}
			catch (e)
			{      
				try
				{
					xmlHttpObjName=new ActiveXObject("Microsoft.XMLHTTP");        
				}
				catch (e)
				{        
				}      
			}    

			alert("catching exception");
	}
	
	return xmlHttpObjName;
}


//=================Event Class===========================================

IdeorisLib.Classes.EventManager = function()
{
	this.AttachEvent = AttachEvent;
	this.DetachEvent = DetachEvent;
	this.IsEventAttached = IsEventAttached;

	/*Private variable*/
	var m_this = this;

	/*Public function*/
	function AttachEvent(element, callableObject, eventName, eventHandler)
	{
		var correctedEventName = GetCorrectedEventName(element, eventName);

		//A closure function - necessary to create
		var closureFunc = function(e)
		{
			if(callableObject != null)
			{
				//eventHandler is called on "callableObject" and 1st argument as event, 2nd arg as element
				eventHandler.call(callableObject, e, element);
			}
			else
			{
				//eventHandler is called on "element" and 1st argument as event
				eventHandler.call(element, e);
			}
		};

		if(element.addEventListener)
		{
			var cacheObj = new IdeorisLib.Classes.EventManager.CacheObject(correctedEventName, eventHandler, closureFunc, this, element);
			IdeorisLib.Classes.EventManager.Cache.push(cacheObj);

			//non-IE browser
			element.addEventListener(correctedEventName, closureFunc, false);
		}
		else if(element.attachEvent)
		{

			var cacheObj = new IdeorisLib.Classes.EventManager.CacheObject(correctedEventName, eventHandler, closureFunc, this, element);

			IdeorisLib.Classes.EventManager.Cache.push(cacheObj);

			//Attaching event in IE
			element.attachEvent(correctedEventName, closureFunc);
		}
	}
	
	function DetachEvent(element, eventName, eventHandler)
	{
		var correctedEventName = GetCorrectedEventName(element, eventName);

		var cacheObj = GetMatchingEvent(correctedEventName, eventHandler, true); //Remove the element if found

		if(cacheObj == false)
			return false; //event not detached

		if(element.removeEventListener)
		{
			//non-IE browser
			element.removeEventListener(correctedEventName, cacheObj.closerFunc, false);
			return true; //event detached successfully
		}
		else
		{
			element.detachEvent(correctedEventName, cacheObj.closerFunc);

			return true; //detached successfully
		}

		return false;
	}

	/*
	Private function
	*/
	function GetCorrectedEventName(element, eventName)
	{
		if(element.addEventListener)
			return eventName; //No correction required for IE specific browsers

		var correctedEventName = "";
		if(eventName.length < 3)
			correctedEventName = "on" + eventName;
		else
		{
			var subStr = eventName.substring(0, 2);

			if(subStr.toLowerCase() != "on")
				correctedEventName = "on" + eventName;
			else
				correctedEventName = eventName;
		}
	
		return correctedEventName;
	}

	function IsEventAttached(element, eventName, eventHandler)
	{
		var length = IdeorisLib.Classes.EventManager.Cache.length;
		var correctedEventName = GetCorrectedEventName(element, eventName);

		for(var i = 0; i < length; i++)
		{
			var cacheObj = IdeorisLib.Classes.EventManager.Cache[i];
			
			if(cacheObj.eventName == correctedEventName && cacheObj.eventHandler == eventHandler && cacheObj.eventManagerObj == this)
			{
				return cacheObj;
			}
		}

		return false;
	}

	/*Returns false if nothing found otherwise "IdeorisLib.Classes.EventManager.CacheObject" is returned*/
	function GetMatchingEvent(eventName, eventHandler, bRemoveIfFound)
	{
		var length = IdeorisLib.Classes.EventManager.Cache.length;

		if(length <= 0)
			return false; //No matching event found

		for(var i = 0; i < length; i++)
		{
			var cacheObj = IdeorisLib.Classes.EventManager.Cache[i];

			if(cacheObj.eventName == eventName && cacheObj.eventHandler == eventHandler)
			{
				if(bRemoveIfFound)
					IdeorisLib.Classes.EventManager.Cache.splice(i, 1); //remove element from ith position

				return cacheObj;
			}
		}

		return false;
	}

	function OnUnloadDetachAllEvents()
	{
		var length = IdeorisLib.Classes.EventManager.Cache.length;

		if(length <= 0)
			return; //No matching event found

		for(var i = (length - 1); i >= 0; i--)
		{
			var cacheObj = IdeorisLib.Classes.EventManager.Cache[i];

			m_this.DetachEvent(cacheObj.element, cacheObj.eventName, cacheObj.eventHandler);
		}
	}

	this.AttachEvent(window, this, "unload", OnUnloadDetachAllEvents);
}

IdeorisLib.Classes.EventManager.Cache = [];
IdeorisLib.Classes.EventManager.CacheObject = function(eventName, eventHandler, closerFunc, eventManagerObj, element)
{
	this.eventManagerObj = eventManagerObj;
	this.eventName = eventName;
	this.eventHandler = eventHandler;
	this.closerFunc = closerFunc; /*Proxy event handler*/
	this.element = element;
}


//====================Draggable Table=============================================

/*
Steps

1) Create Containment elements (DIV - Scrollable)
2) Attach table to containment element
3) Register mousemove event for DIV
4) Loop through table head elements and register "mouseup", "mousedown" and "mousemove" events
5) Register "mouseup" event for body
6) OnMouseDown set variables
7) OnMouseMove re-calculate the width
8) OnMouseUp reset all variables
*/
IdeorisLib.Classes.TableSizer = function(tableName)
{
	/*Public functions*/
	this.Initialise = Initialise;
	this.CreateElements = CreateElements;


	/*Public Variables*/
	this.m_tableName = tableName;
	this.m_divLineName = "";
	this.m_containerName = "";

	/*Local variables*/
	var eventManagerObj = new IdeorisLib.Classes.EventManager();
    var m_minColWidth = 20; /*Minimum width of column below which it can't be dragged*/
	var m_iEdgeThreshold = 5; /*Column edge limit where column is allowable to drag*/

	var m_currentMouseDownElement = null;
	var m_bIsMouseDown = false;
	var m_nStartMouseX = -1;
	var m_nInitialColWidth = 0;

	function OnBodyMouseUp(e, element)
	{
		ResetVariables();

		return;
	}

	function ResetVariables()
	{
		m_bIsMouseDown = false;
		m_currentMouseDownElement = null;
		m_nStartMouseX = -1;
		m_nInitialColWidth = 0;
	}

	function OnDivContainerMouseMove(e, element)
	{
		if (!e)
			e = window.event;

		if(m_currentMouseDownElement != null)
			OnColumnMouseMove(e, m_currentMouseDownElement);

		return;
	}

	function OnColumnMouseMove(e, element)
	{
		if (!e) 
           e = window.event;
		
		IdeorisLib.CrossBrowser.CancelEvent(e); //Don't propagate the event further

		var objTable = element.parentNode.parentNode;
		if(objTable.tagName.toUpperCase() == "THEAD")
			objTable = objTable.parentNode;

		if(!m_bIsMouseDown)
		{
			var bOnBorderRight = IsOnBorderRight( objTable, element, e);

			if(bOnBorderRight)
				element.style.cursor = "col-resize";
			else
				ResetVariables();

			return;
		}

		//Get current mouse position
		var nCurrentX = IdeorisLib.CrossBrowser.GetMouseX(e);
		//Get total mouse movement differences
		var nDiff = nCurrentX - m_nStartMouseX;

		var nNewWidth = m_nInitialColWidth + nDiff;
		//Renew column width if not less than certain limit
		if(nNewWidth >= m_minColWidth)
			m_currentMouseDownElement.style.width = m_nInitialColWidth + nDiff;
	}

	function OnColumnMouseDown(e, element)
	{
		if (!e) 
           e = window.event;

		if(m_bIsMouseDown)
			return;

		var objTable = element.parentNode.parentNode;
		if(objTable.tagName.toUpperCase() == "THEAD")
			objTable = objTable.parentNode;

		var bOnBorderRight = IsOnBorderRight( objTable, element, e);
		if(!bOnBorderRight)
			return;

		m_currentMouseDownElement = element;
		m_bIsMouseDown = true;
		m_nStartMouseX = IdeorisLib.CrossBrowser.GetMouseX(e);
		m_nInitialColWidth = IdeorisLib.CrossBrowser.GetElementWidth(m_currentMouseDownElement);

		window.AppendText("ObjectWidth Width: " + m_nInitialColWidth + " Start MouseX: " + m_nStartMouseX);


		//window.AppendText("OnColumnMouseDown: IsResizable range: " + m_isResizableRange + " Same Elem: " + bSameElement + " m_nLastMouseX: " + m_nLastMouseX);
	}

	function OnColumnMouseUp(e, element)
	{
		m_bIsMouseDown = false;
		m_nLastMouseX = -1;
		m_currentMouseDownElement = null;

		//if(this.m_divLineName != "")
		//	IdeorisLib.CrossBrowser.Hide(this.m_divLineName);

		IdeorisLib.CrossBrowser.CancelEvent(e);
	}

	/* Function that tells me if on the border or not */
	function IsOnBorderLeft( objTable, objTH, e)
	{
		var left = objTH.offsetLeft;
		var pos = IdeorisLib.CrossBrowser.findPosX(objTable);
		var absLeft = pos + left;

		if( IdeorisLib.CrossBrowser.GetMouseX(e) < (absLeft + m_iEdgeThreshold) )
		   return 1;

		return 0;
	}

	function GetDragLinePosX( objTable, objTH)
	{
		var left = objTH.style.left;
		var offsetLeft = objTH.offsetLeft;
		var pos = IdeorisLib.CrossBrowser.findPosX(objTable);
		var width = IdeorisLib.CrossBrowser.GetElementOffsetWidth(objTH);
		var absRight = pos + offsetLeft + width;
		var objParentNode = objTable.parentNode;
		var nScrollLeftX  = 0;
		var nScrollWidth = 0;

		if(objParentNode)
		{
			var scrollXY = IdeorisLib.CrossBrowser.GetScrollXY(objParentNode);
			nScrollWidth = objParentNode.scrollWidth;
			nScrollLeftX = scrollXY[0];
		}

		window.AppendText("Left: " + left + " OffsetLeft: " + offsetLeft + " Pos: " + pos + " Width: " + width + " ScrollLeft: " + nScrollLeftX  + " ScrollWidth: " + nScrollWidth + " AbsRight: " + absRight);

		if(!IdeorisLib.CrossBrowser.IE)
			absRight = absRight - nScrollLeftX;
		else
			absRight = absRight;

		return absRight;
	}

	/* Function that tells me if on the border or not */
	function IsOnBorderRight( objTable, objTH, e)
	{
		var left = objTH.offsetLeft;
		var pos = IdeorisLib.CrossBrowser.findPosX(objTable);
		var width = IdeorisLib.CrossBrowser.GetElementOffsetWidth(objTH);
		var absRight = pos + left + width;
		var nMouseX =  IdeorisLib.CrossBrowser.GetMouseX(e);
		var nParentTagName = "";
		var nScrollLeftX = 0;

		var objParentNode = objTable.parentNode;
		
		if(objParentNode)
		{
			var scrollXY = IdeorisLib.CrossBrowser.GetScrollXY(objParentNode);
			nScrollLeftX = scrollXY[0];

			nParentTagName = objParentNode.tagName;
		}
		
		absRight = absRight - nScrollLeftX;

 		//window.AppendText("objTH.offsetLeft: " + left + "  Pos: " + pos + " absRight: " + absRight + " width: " + width + " MouseX: " + nMouseX + " ScrollLeft: " + nScrollLeftX + "Tag Name: " + nParentTagName + " " + scrollXY);

		if( nMouseX > (absRight - m_iEdgeThreshold) ){
		   return 1;
		}
		return 0;
	}



	function CreateElements()
	{
		if(this.m_divContainerName == "")
			return;
		
		//this.m_divLineName = this.m_tableName + "_DIV";
		this.m_containerName = this.m_tableName + "_CONTAINER_DIV";

		/*=====Movement line===========*/
		/*var lineObj = document.createElement("div");
		lineObj.setAttribute("id", this.m_divLineName);
		lineObj.style.display = "none";
		lineObj.style.position = "absolute";
		lineObj.style.width = "1px";
		lineObj.style.backgroundColor = "black";
		lineObj.style.height = "40px";
*/

		/*=======Table container====================*/
		var containmentObj = document.createElement("div");
		containmentObj.setAttribute("id", this.m_containerName);
		containmentObj.style.width = "500px";
		containmentObj.style.height = "100px";
		containmentObj.style.overflow = "scroll";
		eventManagerObj.AttachEvent(containmentObj, this, "mousemove", OnDivContainerMouseMove);

		//Add line to containment obj
		//containmentObj.appendChild(lineObj);

		//Add table to div container (auto-generated...less code required in HTML)
		var tableObj = IdeorisLib.CrossBrowser.GetObject(this.m_tableName);
		var tableParentObj = tableObj.parentNode;
		tableParentObj.insertBefore(containmentObj, tableObj);

		containmentObj.appendChild(tableObj);
	}

	function Initialise()
	{
		//Creating additional elements
		this.CreateElements(); 

		var table = document.getElementById (this.m_tableName);
		// Test if there is such element in the document
		if (table != null) {
			// Test is this element a table
			if (table.nodeName.toUpperCase () == "TABLE") {

				for (i = 0; i < table.childNodes.length; i++) 
				{
					var tableHead = table.childNodes[i];
					// Look for the header
					// Tables without header will not be handled.
					if (tableHead.nodeName.toUpperCase () == "THEAD") 
					{
						// Go through THEAD nodes and set resize markers
						// IE in THEAD contains TR element which contains TH elements
						// Mozilla in THEAD contains TH elements
						for (j = 0; j < tableHead.childNodes.length; j++) {
							var tableHeadNode = tableHead.childNodes[j];
							// Handles IE style THEAD with TR
							if (tableHeadNode.nodeName.toUpperCase () == "TR") {
								for (k = 0; k < tableHeadNode.childNodes.length; k++) 
								{
									var column = tableHeadNode.childNodes[k];
									eventManagerObj.AttachEvent(column, this, "mousemove", OnColumnMouseMove);
									eventManagerObj.AttachEvent(column, this, "mousedown", OnColumnMouseDown);
									eventManagerObj.AttachEvent(column, this, "mouseup", OnColumnMouseUp);

									if (column.offsetWidth < m_minColWidth) {
										column.style.width = m_minColWidth;
									}
									else {
										column.style.width = column.offsetWidth;
									}
								}
							}
							// Handles Mozilla style THEAD
							else if (tableHeadNode.nodeName.toUpperCase () == "TH") {
								var column = tableHeadNode;
								eventManagerObj.AttachEvent(column, this, "mousemove", OnColumnMouseMove);
								eventManagerObj.AttachEvent(column, this, "mousedown", OnColumnMouseDown);
								eventManagerObj.AttachEvent(column, this, "mouseup", OnColumnMouseUp);

								if (column.offsetWidth < m_minColWidth) {
									column.style.width = m_minColWidth;
								}
								else {
									column.style.width = column.offsetWidth;
								}
							}
						}
						//table.style.tableLayout = "fixed";
						// Once we have found THEAD element and updated it
						// there is no need to go through rest of the table
						i = table.childNodes.length;
					}
				}
			}
		}
	} //end function 

	eventManagerObj.AttachEvent(document.body, this, "mouseup", OnBodyMouseUp);
}

if(typeof IdeorisLib.Classes.Table == 'undefined')
	IdeorisLib.Classes.Table = {};
	
IdeorisLib.Classes.Table.ColumnManager = function(tableName)
{
	/*Public functions*/
	this.Initialise = Initialise;
	this.AttachEventsToColumn = AttachEventsToColumn;
	this.ShowHideColumn = ShowHideColumn;
	
	/*Public Variables*/
	this.m_tableName = tableName;

	/*Local variables*/
	var m_eventManagerObj = new IdeorisLib.Classes.EventManager();
	var m_currentColumnToHide = null;

	function OnContextMenu(e, element)
	{
		window.AppendText("OnContextMenu event is fired in ColumnManager class " + this.m_tableName);

		var posX = IdeorisLib.CrossBrowser.GetMouseX(e);
		var posY = IdeorisLib.CrossBrowser.GetMouseY(e);

		var divObj = document.getElementById("contextMenuTmp");
		IdeorisLib.CrossBrowser.MoveXY(divObj, posX + 1, posY + 1, true, true);
		IdeorisLib.CrossBrowser.Show(divObj);
		IdeorisLib.CrossBrowser.CancelEvent(e);

		if(m_eventManagerObj.IsEventAttached(element, "click",  OnContextMenuClick) == false)
		{
			window.AppendText("Click event not attached");
			m_eventManagerObj.AttachEvent(divObj, this, "click", OnContextMenuClick);
		}

		m_currentColumnToHide = element;
		//if(confirm("Do you want to hide this column?"))
		////{
		//	window.AppendText("Time to hide this column");
		//}

		return false;

	}

	function OnContextMenuClick(e, element)
	{
		if(m_currentColumnToHide == null)
			return;

		var divObj = document.getElementById("contextMenuTmp");
		IdeorisLib.CrossBrowser.Hide(divObj);

		IdeorisLib.CrossBrowser.CancelEvent(e);

		this.ShowHideColumn(m_currentColumnToHide, false);

		//No column to hide once hide operation is completed
		m_currentColumnToHide = null;
	}

	function OnColumnMouseDown(e, element)
	{
		m_currentColumnToHide = null;
		//window.AppendText("OnColumnMouseDown event is fired in ColumnManager class " + this.m_tableName);
	}

	function ShowHideColumn(element, bShow)
	{
		var strDisplay = 'none';
		var col_no = -1;

		if(bShow)
			strDisplay = "block";

		//if (do_show) stl = 'block'
		//else         stl = 'none';


		var tbl  = document.getElementById(this.m_tableName);

		var rows = tbl.getElementsByTagName('thead');
		for (var row=0; row<rows.length;row++) 
		{
			var cels = rows[row].getElementsByTagName('th');

			  if(cels.length <= 0)
				  continue;
			
			  if(col_no == -1)
			  {
				  for (var cellCounter = 0; cellCounter < cels.length; cellCounter++)
				  {
					  if(element == cels[cellCounter])
					  {
						  col_no = cellCounter;
						  break;
					  }
				  }
			  }

			  cels[col_no].style.display = strDisplay;
		}

		var rows = tbl.getElementsByTagName('tr');
		for (var row=0; row<rows.length;row++) 
		{
		  var cels = rows[row].getElementsByTagName('td');

		  if(cels.length <= 0)
			  continue;

		  cels[col_no].style.display = strDisplay;
		}
	}

	function Initialise()
	{
		var tableObj = document.getElementById(this.m_tableName);

		//If object exists and of type "TABLE"
		if(tableObj != null && tableObj.nodeName.toUpperCase() == "TABLE")
		{
			for(i = 0; i < tableObj.childNodes.length; i++)
			{
				var tableHead = tableObj.childNodes[i];

				if(tableHead.nodeName.toUpperCase() != "THEAD")
					continue;

				for(j = 0; j < tableHead.childNodes.length; j++)
				{
					var nodeOfTableHead = tableHead.childNodes[j];

					if(nodeOfTableHead.nodeName.toUpperCase() == "TH")
						this.AttachEventsToColumn(nodeOfTableHead);
					else if(nodeOfTableHead.nodeName.toUpperCase() == "TR")
					{
						for (k = 0; k < nodeOfTableHead.childNodes.length; k++)
							this.AttachEventsToColumn(nodeOfTableHead.childNodes[k]);
					}
				}
			}
		}
	}

	function AttachEventsToColumn(columnObj)
	{
		m_eventManagerObj.AttachEvent(columnObj, this, "contextmenu", OnContextMenu);
	}
}