/*============================================================================||
||       __  ___  _______    ___  ____  __         ___                        ||
||      /  \/  /_/__  __/_ _/ __\/_/  \/ /   _____/   \                       ||
||     / /\_/ / ___/ / __ `/ /  __/ __/  \  / ___/  `_/                       ||
||    / /  / / __// / /_/ / /__/ / / / /\ \/ __// /\ \                        ||
||   /_/  /_/____/_/\__,_/\___/_/_/ /_/ /_/____/_/ /_/                        ||
||                                                                            ||
||============================================================================||
|| XLibrary																	                                  ||
|| Copyright Tim Jones. All Rights Reserved.                                  ||
||============================================================================*/

XLibrary = {};

//=============================================================================

//-----------------------------------------------------------------------------
// Contains the current version of the XLibrary software
//-----------------------------------------------------------------------------
XLibrary.Version = {
	Major	: 1,
	Minor	: 0,
	Release : "Beta",

	//-------------------------------------------------------------------------
	// Get the current version in string format
	//
	// Return:
	//		String - Containing version, i.e: "1.0 Beta"
	//-------------------------------------------------------------------------
	Get : function() {
		return this.Major + "." + this.Minor + " " + this.Release;
	}
};

//=============================================================================

//-----------------------------------------------------------------------------
// Include another JavaScript file. This will print from where it is called.
//
// Parameters:
//		File - The JavaScript file that is to be loaded.
//-----------------------------------------------------------------------------
XLibrary.Include = function(File) {
	document.write("<script type=\"text/javascript\" language=\"JavaScript\" src=\"" + File + "\"></script>");
}

//=============================================================================
XLibrary.Delete = function(Object) {
	if(Object.OnCleanup) {
		Object.OnCleanup();
	}

	delete Object;

	Object = null;
}

//-----------------------------------------------------------------------------
XLibrary.DeleteArray = function(Object) {
	//Delete all Children
	for(var i = 0;i < Object.length;i++) {
		XLibrary.Delete(Object[i]);
	}

	delete Object;

	Object = null;
}

//=============================================================================

XLibrary.Path = "./xlibrary/";

//-----------------------------------------------------------------------------
// Include all the files used in the XLibrary
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
// Core Files
//-----------------------------------------------------------------------------
/*============================================================================||
||       __  ___  _______    ___  ____  __         ___                        ||
||      /  \/  /_/__  __/_ _/ __\/_/  \/ /   _____/   \                       ||
||     / /\_/ / ___/ / __ `/ /  __/ __/  \  / ___/  `_/                       ||
||    / /  / / __// / /_/ / /__/ / / / /\ \/ __// /\ \                        ||
||   /_/  /_/____/_/\__,_/\___/_/_/ /_/ /_/____/_/ /_/                        ||
||                                                                            ||
||============================================================================||
|| XArray																	  ||
|| Copyright Tim Jones. All Rights Reserved.                                  ||
||============================================================================*/

XArray = {};

//=============================================================================
XArray.Push_Front = function(theArray, Value) {
	theArray.reverse();

	theArray.push(Value);

	theArray.reverse();

	return theArray;
}

//=============================================================================

/*============================================================================||
||       __  ___  _______    ___  ____  __         ___                        ||
||      /  \/  /_/__  __/_ _/ __\/_/  \/ /   _____/   \                       ||
||     / /\_/ / ___/ / __ `/ /  __/ __/  \  / ___/  `_/                       ||
||    / /  / / __// / /_/ / /__/ / / / /\ \/ __// /\ \                        ||
||   /_/  /_/____/_/\__,_/\___/_/_/ /_/ /_/____/_/ /_/                        ||
||                                                                            ||
||============================================================================||
|| XCallback																  ||
|| Copyright Tim Jones. All Rights Reserved.                                  ||
||============================================================================*/

XCallback = {};

//=============================================================================
XCallback.Callback = function() {
}

//=============================================================================

/*============================================================================||
||       __  ___  _______    ___  ____  __         ___                        ||
||      /  \/  /_/__  __/_ _/ __\/_/  \/ /   _____/   \                       ||
||     / /\_/ / ___/ / __ `/ /  __/ __/  \  / ___/  `_/                       ||
||    / /  / / __// / /_/ / /__/ / / / /\ \/ __// /\ \                        ||
||   /_/  /_/____/_/\__,_/\___/_/_/ /_/ /_/____/_/ /_/                        ||
||                                                                            ||
||============================================================================||
|| XClass																	  ||
|| Copyright Tim Jones. All Rights Reserved.                                  ||
||============================================================================*/

XClass = {};

//=============================================================================
XClass.Class = function() {
}

//=============================================================================

/*============================================================================||
||       __  ___  _______    ___  ____  __         ___                        ||
||      /  \/  /_/__  __/_ _/ __\/_/  \/ /   _____/   \                       ||
||     / /\_/ / ___/ / __ `/ /  __/ __/  \  / ___/  `_/                       ||
||    / /  / / __// / /_/ / /__/ / / / /\ \/ __// /\ \                        ||
||   /_/  /_/____/_/\__,_/\___/_/_/ /_/ /_/____/_/ /_/                        ||
||                                                                            ||
||============================================================================||
|| XControl																	  ||
|| Copyright Tim Jones. All Rights Reserved.                                  ||
||============================================================================*/

XControl = {};

//=============================================================================
XControl.Control = function(SrcElement) {
	var self			= this;

	//public
		self.Class				= new XClass.Class();
		self.Callback			= new XCallback.Callback();
		self.Element			= new XElement.Element(SrcElement);

		self.Parent				= 0;
		self.Child				= new Array();

		self.Disabled			= false;
		self.Focus				= false;

	//private

	//-------------------------------------------------------------------------
	self.SetDimensions = function(Width, Height) {
		XElement.SetWidth(self.Element.SrcElement, Width);
		XElement.SetHeight(self.Element.SrcElement, Height);
	}

	//-------------------------------------------------------------------------
	self.AddChild = function(NewChild) {
		self.Child.push(NewChild);
	}

	//-------------------------------------------------------------------------
	this.ShowChildren = function() {
		for(var i = 0;i < self.Child.length;i++) {
			if(self.Child[i].Control.Element) {
				self.Child[i].Control.Element.Show();
			}
		}
	}
	
	//-------------------------------------------------------------------------
	this.HideChildren = function() {
		for(var i = 0;i < self.Child.length;i++) {
			if(self.Child[i].Element) {
				self.Child[i].Element.Hide();
			}
		}
	}

	//-------------------------------------------------------------------------
	this.HasFocus = function() {
		if(self.Focus) {
			return 1;
		}

		for(var i = 0;i < self.Child.length;i++) {
			if(self.Child[i].Control) {
				if(self.Child[i].Control.Focus) {
					return 2;
				}
			}
		}

		return 0;
	}

	//-------------------------------------------------------------------------
	this.GainFocus = function() {
		self.Focus = true;

		if(self.Parent.Control) {
			self.Parent.Control.GainFocus();
		}

		if(self.Callback.GainFocus) {
			self.Callback.GainFocus();
		}

		if(self.Class.GainFocus) {
			self.Element.SrcElement.className = self.Class.GainFocus;
		}
	}

	//-------------------------------------------------------------------------
	this.LoseFocus = function() {
		self.Focus = false;

		for(var i = 0;i < self.Child.length;i++) {
			if(self.Child[i].Control) {
				self.Child[i].Control.LoseFocus();
			}
		}

		if(self.Callback.LoseFocus) {
			self.Callback.LoseFocus();
		}

		if(self.Class.LoseFocus) {
			self.Element.SrcElement.className = self.Class.LoseFocus;
		}
	}

	//-------------------------------------------------------------------------
	// Calls a Callback function (if available) and sets the Elements class
	// (if available) on the appropriate event.
	//
	// Parameters:
	//		Event - Event structure passed by the browser
	//-------------------------------------------------------------------------
	var OnEvent = function(Event) {
		var Type = Event.type;

		if(self.Callback[Type]) {
			self.Callback[Type](Event);
		}

		if(self.Class[Type]) {
			if(self.HasFocus() == 0) {
				self.Element.SrcElement.className = self.Class[Type];
			}
		}
	}

	//=========================================================================
	self.OnCleanup = function() {
		XLibrary.Delete(self.Class);
		XLibrary.Delete(self.Callback);
		XLibrary.Delete(self.Element);

		XLibrary.DeleteArray(self.Child);

		XEvent.DeleteEvent(self.Element.SrcElement, "mousedown", OnEvent);
		XEvent.DeleteEvent(self.Element.SrcElement, "mouseup", OnEvent);
		XEvent.DeleteEvent(self.Element.SrcElement, "mousemove", OnEvent);
		XEvent.DeleteEvent(self.Element.SrcElement, "mouseover", OnEvent);
		XEvent.DeleteEvent(self.Element.SrcElement, "mouseout", OnEvent);
		XEvent.DeleteEvent(self.Element.SrcElement, "click", OnEvent);

		XEvent.DeleteEvent(self.Element.SrcElement, "keydown", OnEvent);
		XEvent.DeleteEvent(self.Element.SrcElement, "keyup", OnEvent);
	}

	//=========================================================================
	// Constructor
	//=========================================================================

	// Tracks for Mouse Events
	XEvent.AddEvent(self.Element.SrcElement, "mousedown", OnEvent);
	XEvent.AddEvent(self.Element.SrcElement, "mouseup", OnEvent);
	XEvent.AddEvent(self.Element.SrcElement, "mousemove", OnEvent);
	XEvent.AddEvent(self.Element.SrcElement, "mouseover", OnEvent);
	XEvent.AddEvent(self.Element.SrcElement, "mouseout", OnEvent);
	XEvent.AddEvent(self.Element.SrcElement, "click", OnEvent);

	// Tracks for Keyboard Events
	XEvent.AddEvent(self.Element.SrcElement, "keydown", OnEvent);
	XEvent.AddEvent(self.Element.SrcElement, "keyup", OnEvent);
}

//=============================================================================

/*============================================================================||
||       __  ___  _______    ___  ____  __         ___                        ||
||      /  \/  /_/__  __/_ _/ __\/_/  \/ /   _____/   \                       ||
||     / /\_/ / ___/ / __ `/ /  __/ __/  \  / ___/  `_/                       ||
||    / /  / / __// / /_/ / /__/ / / / /\ \/ __// /\ \                        ||
||   /_/  /_/____/_/\__,_/\___/_/_/ /_/ /_/____/_/ /_/                        ||
||                                                                            ||
||============================================================================||
|| XDocument																  ||
|| Copyright Tim Jones. All Rights Reserved.                                  ||
||============================================================================*/

XDocument = {};

//=============================================================================
XDocument.GetWidth = function() {
	var Width = 0;

	if(typeof(window.innerWidth) == 'number') {
		//Non-IE
		Width = window.innerWidth;
	}else if(document.documentElement && document.documentElement.clientWidth) {
		//IE 6+ in 'standards compliant mode'
		Width = document.documentElement.clientWidth;
	}else if(document.body && document.body.clientWidth) {
		//IE 4 compatible
		Width = document.body.clientWidth;
	}

	return Width;
}

//-----------------------------------------------------------------------------
XDocument.GetHeight = function() {
	var Height = 0;

	if(typeof(window.innerWidth) == 'number') {
		//Non-IE
		Height = window.innerHeight;
	}else if( document.documentElement && document.documentElement.clientHeight) {
		//IE 6+ in 'standards compliant mode'
		Height = document.documentElement.clientHeight;
	}else if( document.body && document.body.clientHeight) {
		//IE 4 compatible
		Height = document.body.clientHeight;
	}

	return Height;
}

//=============================================================================
XDocument.DisableTextSelect = function() {
	document.onselectstart = new Function ('return false');
}

//-----------------------------------------------------------------------------
XDocument.EnableTextSelect = function() {
	document.onselectstart = new Function ('return true');
}

//=============================================================================
XDocument.DisableScrollbars = function() {
	document.body.style.overflow = "hidden";
}

//-----------------------------------------------------------------------------
XDocument.EnableScrollbars = function() {
	document.body.style.overflow = "auto";
}

//=============================================================================

/*============================================================================||
||       __  ___  _______    ___  ____  __         ___                        ||
||      /  \/  /_/__  __/_ _/ __\/_/  \/ /   _____/   \                       ||
||     / /\_/ / ___/ / __ `/ /  __/ __/  \  / ___/  `_/                       ||
||    / /  / / __// / /_/ / /__/ / / / /\ \/ __// /\ \                        ||
||   /_/  /_/____/_/\__,_/\___/_/_/ /_/ /_/____/_/ /_/                        ||
||                                                                            ||
||============================================================================||
|| XElement																	  ||
|| Copyright Tim Jones. All Rights Reserved.                                  ||
||============================================================================*/

XElement = {};

//=============================================================================
XElement.Element = function(SrcElement) {
	var self			= this;

	// public
		self.SrcElement	= SrcElement;		//The actual element on the page

	// private
		var Visible		= true;

	//-------------------------------------------------------------------------
	// Gets the X Coordinate of the SrcElement
	//
	// Return:
	//		Integer - X Coordinate of SrcElement
	//-------------------------------------------------------------------------
	self.GetX = function() {
		var X = self.SrcElement.style.left.replace("px", "");
			X = X.replace("%", "");
	
		return parseInt(X);
	}

	//-------------------------------------------------------------------------
	// Gets the Y Coordinate of the SrcElement
	//
	// Return:
	//		Integer - Y Coordinate of SrcElement
	//-------------------------------------------------------------------------
	self.GetY = function() {
		var Y = self.SrcElement.style.top.replace("px", "");
			Y = Y.replace("%", "");

		return parseInt(Y);
	}

	//-------------------------------------------------------------------------
	// Shows the current element
	//-------------------------------------------------------------------------
	self.Show = function() {
		if(self.SrcElement) {
			self.SrcElement.style.display = "block";
		}

		Visible = true;
	}

	//-------------------------------------------------------------------------
	// Shows the current element
	//-------------------------------------------------------------------------
	self.ShowAt = function(X, Y) {
		if(self.SrcElement) {
			self.SrcElement.style.display = "block";
		}

		self.SrcElement.style.left  = X + "px";
		self.SrcElement.style.right = Y + "px";

		self.SrcElement.style.position = "absolute";

		Visible = true;
	}

	//-------------------------------------------------------------------------
	// Hides the current element
	//-------------------------------------------------------------------------
	self.Hide = function() {
		if(self.SrcElement) {
			self.SrcElement.style.display = "none";
		}

		Visible = false;
	}

	//-------------------------------------------------------------------------
	// Returns visibility of element based upon style.display
	//
	// Return:
	//		bool - Visibility of element
	//-------------------------------------------------------------------------
	self.IsVisible = function() {
		return Visible;
	}

	//=========================================================================
	self.OnCleanup = function() {
	}
}

//=============================================================================
XElement.AddElement = function(ID, Content) {
	var NewElement		= document.createElement('div');

	NewElement.setAttribute("id", ID);
	NewElement.innerHTML = Content;

	document.body.appendChild(NewElement);

	return NewElement;
}

//-----------------------------------------------------------------------------
XElement.GetByID = function(ID) {
	return document.getElementById(ID);
}

//-----------------------------------------------------------------------------
XElement.AddChild = function(ID, Parent, Content) {
	var NewElement		= document.createElement('div');

	NewElement.setAttribute("id", ID);
	NewElement.innerHTML = Content;

	Parent.appendChild(NewElement);

	return NewElement;
}

//-----------------------------------------------------------------------------
XElement.RemoveChild = function(Element, Parent) {
	XElement.Purge(Element);

	Parent.removeChild(Element);

	Element = null;
}

//-----------------------------------------------------------------------------
XElement.RemoveAllChildren = function(Element) {
	XElement.Purge(Element);

	while(Element.hasChildNodes()) {
		XElement.Purge(Element.firstChild);
		
		var T = Element.firstChild;

		Element.removeChild(Element.firstChild);

		T = null;
	}
}

//-----------------------------------------------------------------------------
// Function by: Douglas Crockford
//-----------------------------------------------------------------------------
// http://www.crockford.com/javascript/memory/leak.html
//-----------------------------------------------------------------------------
XElement.Purge = function(d) {
    var a = d.attributes, i, l, n;
    if (a) {
        l = a.length;
        for (i = 0; i < l; i += 1) {
            n = a[i].name;
            if (typeof d[n] === 'function') {
                d[n] = null;
            }
        }
    }
    a = d.childNodes;
    if (a) {
        l = a.length;
        for (i = 0; i < l; i += 1) {
            XElement.Purge(d.childNodes[i]);
        }
    }
}

//-----------------------------------------------------------------------------
XElement.SetDimension = function(NewValue, Value) {
	var Post = "px";

	if(NewValue[Value.length - 1] == "%" || NewValue[Value.length - 1] == "x") {
		return NewValue;
	}

	if(Value) {
		if(Value[Value.length - 1] == "%") {
			Post = "%";
		}
	}

	return NewValue + Post;
}

//-----------------------------------------------------------------------------
XElement.SetX = function(Element, X) {
	Element.style.left = XElement.SetDimension(X, Element.style.left);
}

//-----------------------------------------------------------------------------
XElement.SetY = function(Element, Y) {
	Element.style.top = XElement.SetDimension(Y, Element.style.top);
}

//-----------------------------------------------------------------------------
XElement.GetX = function(Element) {
	if(Element.style && Element.style.left) {
		var X = Element.style.left.replace("px", "");
			X = X.replace("%", "");

		return parseInt(X);
	}else
	if(Element.offsetLeft) {
		return Element.offsetLeft;
	}

	return 0;
}

//-----------------------------------------------------------------------------
XElement.GetY = function(Element) {
	if(Element.style && Element.style.top) {
		var Y = Element.style.top.replace("px", "");
			Y = Y.replace("%", "");

		return parseInt(Y);
	}else
	if(Element.offsetTop) {
		return Element.offsetTop;
	}

	return 0;
}

//-----------------------------------------------------------------------------
XElement.GetPosX = function(Element) {
	var X = 0;

	if(Element.offsetParent) {
		while(Element.offsetParent) {
			X += Element.offsetLeft;
			Element = Element.offsetParent;
		}
	}else if(Element.x) {
		X += Element.x;
	}else if(Element.offsetLeft) {
		X += Element.offsetLeft;
	}

	return X;
}

//-----------------------------------------------------------------------------
XElement.GetPosY = function(Element) {
	var Y = 0;

	if(Element.offsetParent) {
		while(Element.offsetParent) {
			Y += Element.offsetTop;
			Element = Element.offsetParent;
		}
	}else if(Element.y) {
		Y += Element.y;
	}else if(Element.offsetTop) {
		Y += Element.offsetTop;
	}

	return Y;
}

//-----------------------------------------------------------------------------
XElement.SetWidth = function(Element, Width) {
	Element.style.width = XElement.SetDimension(Width, Element.style.width);
}

//-----------------------------------------------------------------------------
XElement.SetHeight = function(Element, Height) {
	Element.style.height = XElement.SetDimension(Height, Element.style.height);
}

//-----------------------------------------------------------------------------
XElement.GetWidth = function(Element) {
	if(Element.style && Element.style.width) {
		var Width = Element.style.width.replace("px", "");
			Width = Width.replace("%", "");

		return parseInt(Width);
	}else
	if(Element.offsetWidth) {
		return Element.offsetWidth;
	}else
	if(Element.innerWidth) {
		return Element.innerWidth;
	}

	return 0;
}

//-----------------------------------------------------------------------------
XElement.GetHeight = function(Element) {
	if(Element.style && Element.style.height) {
		var Height = Element.style.height.replace("px", "");
			Height = Height.replace("%", "");

		if(Height > 0) {	
			return parseInt(Height);
		}
	}

	if(Element.offsetHeight) {
		return Element.offsetHeight;
	}else
	if(Element.innerHeight) {
		return Element.innerHeight;
	}

	return 0;
}

//=============================================================================

/*============================================================================||
||       __  ___  _______    ___  ____  __         ___                        ||
||      /  \/  /_/__  __/_ _/ __\/_/  \/ /   _____/   \                       ||
||     / /\_/ / ___/ / __ `/ /  __/ __/  \  / ___/  `_/                       ||
||    / /  / / __// / /_/ / /__/ / / / /\ \/ __// /\ \                        ||
||   /_/  /_/____/_/\__,_/\___/_/_/ /_/ /_/____/_/ /_/                        ||
||                                                                            ||
||============================================================================||
|| XEvent																	  ||
|| Copyright Tim Jones. All Rights Reserved.                                  ||
||============================================================================*/

XEvent = {};

//=============================================================================
XEvent.AddEvent = function(Element, EventName, Callback) {
	if(!Element) return;

	//Internet Explorer Only
	if(Element.attachEvent) { // IE
		Element.attachEvent("on" + EventName, Callback);

	//W3C compliant browsers
	}else if (Element.addEventListener) {
		Element.addEventListener(EventName, Callback, false);

	//Anything else
	}else{
		Element["on" + EventName] = Callback;
	}
}

//-----------------------------------------------------------------------------
XEvent.DeleteEvent = function(Element, EventName, Callback) {
	if(!Element) return;

	//Internet Explorer Only
	if(Element.detachEvent) { // IE
		Element.detachEvent("on" + EventName, Callback);

	//W3C compliant browsers
	}else if (Element.removeEventListener) {
		Element.removeEventListener(EventName, Callback, false);

	//Anything else
	}else{
		Element["on" + EventName] = 0;
	}
}

//-----------------------------------------------------------------------------
XEvent.GetSrcElement = function(Event) {
	//W3C
	if(Event.target) {
		return Event.target;

	//Internet Explorer
	}else{
		return Event.srcElement;
	}
}

//=============================================================================

/*============================================================================||
||       __  ___  _______    ___  ____  __         ___                        ||
||      /  \/  /_/__  __/_ _/ __\/_/  \/ /   _____/   \                       ||
||     / /\_/ / ___/ / __ `/ /  __/ __/  \  / ___/  `_/                       ||
||    / /  / / __// / /_/ / /__/ / / / /\ \/ __// /\ \                        ||
||   /_/  /_/____/_/\__,_/\___/_/_/ /_/ /_/____/_/ /_/                        ||
||                                                                            ||
||============================================================================||
|| XMouse																	  ||
|| Copyright Tim Jones. All Rights Reserved.                                  ||
||============================================================================*/

XMouse = {};

//=============================================================================
XMouse.GetX = function(Event) {
	if(!Event) {
		var Event = window.event;
	}

	if(Event) {
		if(Event.pageX) {
			return Event.pageX;
		}else if (Event.clientX) {
			return Event.clientX + document.body.scrollLeft;
		}
	}

	return 0;
}

//-----------------------------------------------------------------------------
XMouse.GetY = function(Event) {
	if(!Event) {
		var Event = window.event;
	}

	if(Event) {
		if(Event.pageY) {
			return Event.pageY;
		}else if (Event.clientY) {
			return Event.clientY + document.body.scrollTop;
		}
	}

	return 0;
}

//=============================================================================

/*============================================================================||
||       __  ___  _______    ___  ____  __         ___                        ||
||      /  \/  /_/__  __/_ _/ __\/_/  \/ /   _____/   \                       ||
||     / /\_/ / ___/ / __ `/ /  __/ __/  \  / ___/  `_/                       ||
||    / /  / / __// / /_/ / /__/ / / / /\ \/ __// /\ \                        ||
||   /_/  /_/____/_/\__,_/\___/_/_/ /_/ /_/____/_/ /_/                        ||
||                                                                            ||
||============================================================================||
|| XString																	  ||
|| Copyright Tim Jones. All Rights Reserved.                                  ||
||============================================================================*/

XString = {};

//=============================================================================
XString.Explode = function(Seperator, Input, Limit) {
	Input		= new String(Input);
	Seperator	= new String(Seperator);

	ExplodeArray = new Array(1);
	BufferString = "";
	Index		 = 0;

	for(i = 0; i < Input.length; i++) {
		CurrentChar = Input.charAt(i);

		if(Seperator.indexOf(CurrentChar) != -1 && ((Index < Limit && Limit != 0) || (Limit < 0))) {
			ExplodeArray[Index] = BufferString;
			Index++;

			BufferString = ""; 
		}else{ 
			BufferString += CurrentChar; 
		}
	}

	ExplodeArray[Index] = BufferString; 

	return ExplodeArray;
}

//=============================================================================

/*============================================================================||
||       __  ___  _______    ___  ____  __         ___                        ||
||      /  \/  /_/__  __/_ _/ __\/_/  \/ /   _____/   \                       ||
||     / /\_/ / ___/ / __ `/ /  __/ __/  \  / ___/  `_/                       ||
||    / /  / / __// / /_/ / /__/ / / / /\ \/ __// /\ \                        ||
||   /_/  /_/____/_/\__,_/\___/_/_/ /_/ /_/____/_/ /_/                        ||
||                                                                            ||
||============================================================================||
|| XXML																		  ||
|| Copyright Tim Jones. All Rights Reserved.                                  ||
||============================================================================*/

XXML = {};

//=============================================================================

XXML.HTTP = null;

//=============================================================================
/*
	Returns a XML HTTP Request Object

	@Return
		XML HTTP Request Object, or null if incapable
*/
XXML.GetHTTP = function() {
	if(XXML.HTTP != null) {
		delete XXML.HTTP;
	}

	if(window.XMLHttpRequest) {
		XXML.HTTP = new XMLHttpRequest();
	}else if (window.ActiveXObject) {
		try {
			XXML.HTTP = new ActiveXObject("Msxml2.XMLHTTP");
		} catch (e) {
			try {
				XXML.HTTP = new ActiveXObject("Microsoft.XMLHTTP");
			} catch (e) {}
		}
	}

	return XXML.HTTP;
}

//-----------------------------------------------------------------------------
/*
	Returns the contents of a URL

	URL			The URL of the page
	Callback	Callback function for OnReadyStateChange of HTTP Request

	@Return
		HTTP Request responseText
*/
XXML.GetPage = function(URL, Callback) {
	var HTTP = XXML.SendRequest(URL, Callback, false);

	return HTTP.responseText;
}

//-----------------------------------------------------------------------------
/*
	Sends a HTTP Request to the specified URL

	URL			The URL of the page
	Callback	Callback function for OnReadyStateChange of HTTP Request
	Async		If this process is asynchronous or not

	@Return
		The HTTP Request Object
*/
XXML.SendRequest = function(URL, Callback, Async) {
	var HTTP = XXML.GetHTTP();

	if(HTTP == null) {
		return;
	}

	/*HTTP.onreadystatechange = function() { 	
		if (HTTP.readyState == 4) {
			if (HTTP.status == 200) {
				if(Callback) {
					Callback(HTTP);
				}
			} else {
				alert("ERROR : " + HTTP.status);
			}
		}

	};*/

	SplitString = function(Input, Char) {
		var Strings = new Array();

		var Index = Input.indexOf(Char);

		if(Index == -1) {
			Index = Input.length;
		}

		Strings[0] = Input.substr(0, Index);
		Strings[1] = Input.substr(Index + 1, Input.length);

		return Strings;
	}

	var Strings = SplitString(URL, "?");
	
	/*HTTP.open("POST", Strings[0], Async); 
	HTTP.setRequestHeader("Content-Type", "application/x-www-form-urlencoded"); 
	HTTP.setRequestHeader("Content-length", Strings[1].length);
	HTTP.setRequestHeader("Connection", "close");
	HTTP.send(Strings[1]);*/

	///*	
	HTTP.open("GET", URL, Async); 
	HTTP.send("");
	//*/

	return HTTP;
}

//-----------------------------------------------------------------------------
/*
	Returns the contents of a URL

	URL			The URL of the page
	Callback	Callback function for OnReadyStateChange of HTTP Request

	@Return
		HTTP Request responseText
*/
XXML.GetPage_POST = function(URL, Callback) {
	var HTTP = XXML.SendRequest_POST(URL, Callback, false);

	return HTTP.responseText;
}

//-----------------------------------------------------------------------------
/*
	Sends a HTTP Request to the specified URL

	URL			The URL of the page
	Callback	Callback function for OnReadyStateChange of HTTP Request
	Async		If this process is asynchronous or not

	@Return
		The HTTP Request Object
*/
XXML.SendRequest_POST = function(URL, Callback, Async) {
	var HTTP = XXML.GetHTTP();

	if(HTTP == null) {
		return;
	}

	SplitString = function(Input, Char) {
		var Strings = new Array();

		var Index = Input.indexOf(Char);

		if(Index == -1) {
			Index = Input.length;
		}

		Strings[0] = Input.substr(0, Index);
		Strings[1] = Input.substr(Index + 1, Input.length);

		return Strings;
	}

	var Strings = SplitString(URL, "?");
	
	HTTP.open("POST", Strings[0], Async); 
	HTTP.setRequestHeader("Content-Type", "application/x-www-form-urlencoded"); 
	HTTP.setRequestHeader("Content-length", Strings[1].length);
	HTTP.setRequestHeader("Connection", "close");
	HTTP.send(Strings[1]);

	return HTTP;
}

//=============================================================================
/*
	Cleans a variable fit for a URL string

	Input	The variable to clean (string)

	@Return
		The cleaned input
*/
XXML.CleanURLArg = function(Input) {
	/*Input = Input.replace(/&/g, "%26");
	Input = Input.replace(/=/g, "%3D");
	Input = Input.replace(/\+/g, "%2B");*/

	Input = escape(Input);

	return Input;
}

//-----------------------------------------------------------------------------
/*
	Uncleans a variable

	@Return
		The uncleaned input
*/
XXML.UncleanURLArg = function(Input) {
	/*Input = Input.replace(/%26/g, "&");
	Input = Input.replace(/%3D/g, "=");
	Input = Input.replace(/%2B/g, "+");*/

	Input = unescape(Input);

	return Input;
}
//=============================================================================


//-----------------------------------------------------------------------------
// Controls
//-----------------------------------------------------------------------------
/*============================================================================||
||       __  ___  _______    ___  ____  __         ___                        ||
||      /  \/  /_/__  __/_ _/ __\/_/  \/ /   _____/   \                       ||
||     / /\_/ / ___/ / __ `/ /  __/ __/  \  / ___/  `_/                       ||
||    / /  / / __// / /_/ / /__/ / / / /\ \/ __// /\ \                        ||
||   /_/  /_/____/_/\__,_/\___/_/_/ /_/ /_/____/_/ /_/                        ||
||                                                                            ||
||============================================================================||
|| XDesktop																	  ||
|| Copyright Tim Jones. All Rights Reserved.                                  ||
||============================================================================*/

XDesktop = {};

//=============================================================================
/*
	A Generic Window Class for DIV window element

	SrcElement		The Targer Element that this class treats as a Window
*/
XDesktop.Desktop = function(SrcElement) {
	var self			= this;		//This class

	//public
		self.Control		= new XControl.Control(SrcElement);

	//private
		var CloseChild		= null;

	//-------------------------------------------------------------------------
	self.OnMouseDown = function(Event) {
		var Found = false;

		var Element = Event.target;

		if(!Element) {
			Element = Event.srcElement;
		}

		while(Element) {
			if(Element.tagName == "DIV" && Element.className == "Window") {
				break;
			}

			Element = Element.parentNode;
		}

		if(!Element) return;

		var ID = Element.id;

		for(var i = 0;i < self.Control.Child.length;i++) {
			if(self.Control.Child[i].Control.Element) {
				if(self.Control.Child[i].Control.Element.SrcElement.id == ID) {
					Found = true;
				}
			}
		}

		if(Found) {
			for(var i = 0;i < self.Control.Child.length;i++) {
				if(self.Control.Child[i].Control.Element) {
					if(self.Control.Child[i].Control.Element.SrcElement.id == ID) {
						self.Control.Child[i].Control.Element.SrcElement.style.zIndex = 100;

						self.Control.Child[i].Control.Element.SrcElement.style.filter = "alpha(opacity=100)";
						self.Control.Child[i].Control.Element.SrcElement.style.MozOpacity = 1.0;
					}else{
						self.Control.Child[i].Control.Element.SrcElement.style.zIndex = 10;

						self.Control.Child[i].Control.Element.SrcElement.style.filter = "alpha(opacity=50)";
						self.Control.Child[i].Control.Element.SrcElement.style.MozOpacity = 0.5;
					}
				}
			}
		}
	}


	//-------------------------------------------------------------------------
	/*
		asd

		@Return
			None
	*/
	self.OpenWindow = function(ID, URL, Title, Args, Width, Height) {
		if(XElement.GetByID(ID)) return;

		URL = URL + "?WinID=" + ID;

		if(Args.length > 0) {
			URL = URL + "&" + Args;
		}

		if(Height >= XDocument.GetHeight()) {
			var NewHeight = XDocument.GetHeight() - 100;

			Width  = Width - (Height - NewHeight);
			Height = NewHeight;
		}

		var Content = XXML.GetPage_POST("win_template.php?IsWindow=true&URL=" + escape(URL) + "&Title=" + escape(Title));

		Content = Content.replace(/ID_Window/g, ID);
		Content = Content.replace(/ID_Handle/g, ID + "_Handle");
		Content = Content.replace(/ID_Resize/g, ID + "_Resize");
		Content = Content.replace(/ID_Content/g, ID + "_Content");
		Content = Content.replace(/ID_Drag/g, ID + "_Drag");

		var Element = XElement.AddChild(ID, XElement.GetByID("Desktop"), Content);

		Element.className = "Window";

		ChildWin1 = new XWindow.Window(Element);

		Dragger = new XDrag.Drag(Element, XElement.GetByID(ID + "_Handle"));
		Resize	= new XResize.Create(XElement.GetByID(ID + "_Resize"), Element);

		Resize.Callback["mousemove"] = function() {
			XElement.GetByID(ID + "_Content").style.height = (XElement.GetHeight(XElement.GetByID(ID)) - 36) + "px";
		}

		for(var i = 0;i < self.Control.Child.length;i++) {
			if(self.Control.Child[i].Control.Element) {
				self.Control.Child[i].Control.Element.SrcElement.style.zIndex = 10;

				self.Control.Child[i].Control.Element.SrcElement.style.MozOpacity = 0.5;
				self.Control.Child[i].Control.Element.SrcElement.style.filter = "alpha(opacity=50)";
			}
		}

		self.Control.AddChild(ChildWin1);

		Element.style.width  = Width  + "px";
		Element.style.height = Height + "px";

		XElement.GetByID(ID + "_Content").style.height = (XElement.GetHeight(Element) - 36) + "px";

		ChildWin1.AlignCenter();

		XEffect.FadeIn(Element, 10);

		return ChildWin1;
	}

	//-------------------------------------------------------------------------
	/*
		asd

		@Return
			None
	*/
	self.CloseWindow = function(ID) {
		function Close() {
			CloseChild.OnCleanup();

			CloseChild.Control.Element.SrcElement.style.display = "none";

			XElement.RemoveAllChildren(CloseChild.Control.Element.SrcElement);
			XElement.RemoveChild(CloseChild.Control.Element.SrcElement, XElement.GetByID("Desktop"));
		}

		var i = 0;

		for(i = 0;i < self.Control.Child.length;i++) {
			if(self.Control.Child[i] && self.Control.Child[i].Control.Element.SrcElement.id == ID) {
				XEffect.FadeOut(self.Control.Child[i].Control.Element.SrcElement, 10, Close);

				CloseChild = self.Control.Child[i];

				break;
			}
		}

		self.Control.Child.splice(i, 1);
	}

	//=========================================================================
	/*
		Class destructor
	*/
	self.OnCleanup = function() {
		XLibrary.Delete(self.Control);	//Delete Control class
	}

	//=========================================================================
	// Constructor
	//=========================================================================
	XEvent.AddEvent(SrcElement, "mousedown", self.OnMouseDown);
}

//=============================================================================

/*============================================================================||
||       __  ___  _______    ___  ____  __         ___                        ||
||      /  \/  /_/__  __/_ _/ __\/_/  \/ /   _____/   \                       ||
||     / /\_/ / ___/ / __ `/ /  __/ __/  \  / ___/  `_/                       ||
||    / /  / / __// / /_/ / /__/ / / / /\ \/ __// /\ \                        ||
||   /_/  /_/____/_/\__,_/\___/_/_/ /_/ /_/____/_/ /_/                        ||
||                                                                            ||
||============================================================================||
|| XDrag																	  ||
|| Copyright Tim Jones. All Rights Reserved.                                  ||
||============================================================================*/

XDrag = {};

//=============================================================================

XDrag.Drag = function(SrcElement, Handle) {
	var self					= this;

	//public
		self.Class				= new XClass.Class();
		self.Callback			= new XCallback.Callback();
		self.Element			= new XElement.Element(SrcElement);
		self.Handle				= new XElement.Element(Handle);

		self.XAxis				= true;
		self.YAxis				= true;
	
	//private

	var Element_Boundary = 0;

	var Clicked	= false;

	var StartX		= 0;
	var StartY		= 0;

	var ElementX	= 0;
	var ElementY	= 0;

	//-------------------------------------------------------------------------
	this.OnMouseUp = function(Event) {
		Clicked = false;

		XDocument.EnableTextSelect();
	}

	//-------------------------------------------------------------------------
	this.OnMouseDown = function(Event) {
		Clicked = true;

		if(self.XAxis) {
			StartX   = XMouse.GetX(Event);
			ElementX = XElement.GetX(self.Element.SrcElement);
		}

		if(self.YAxis) {
			StartY   = XMouse.GetY(Event);
			ElementY = XElement.GetY(self.Element.SrcElement);
		}

		XDocument.DisableTextSelect();
	}

	//-------------------------------------------------------------------------
	this.OnMouseMove = function(Event) {
		if(Clicked == false) return;

		if(self.XAxis) {
			var NewX = (ElementX + (XMouse.GetX(Event) - StartX));
			
			if(Element_Boundary) {
				if(NewX >= XElement.GetX(Element_Boundary) &&
					NewX <= XElement.GetX(Element_Boundary) + XElement.GetWidth(Element_Boundary)) {
					XElement.SetX(self.Element.SrcElement, NewX);
				}else{
					if(NewX < 0) {
						XElement.SetX(self.Element.SrcElement, 0);
					}else{
						XElement.SetX(self.Element.SrcElement, XElement.GetWidth(Element_Boundary));
					}
				}
			}else{
				XElement.SetX(self.Element.SrcElement, NewX);
			}
		}

		if(self.YAxis) {
			var NewY = (ElementY + (XMouse.GetY(Event) - StartY));

			if(Element_Boundary) {
				if(NewY >= XElement.GetY(Element_Boundary) &&
					NewY <= XElement.GetY(Element_Boundary) + XElement.GetHeight(Element_Boundary)) {
					XElement.SetY(self.Element.SrcElement, NewY);
				}else{
					if(NewY < 0) {
						XElement.SetY(self.Element.SrcElement, 0);
					}else{
						XElement.SetY(self.Element.SrcElement, XElement.GetHeight(Element_Boundary));
					}
				}
			}else{
				XElement.SetY(self.Element.SrcElement, NewY);
			}
		}

		if(self.Callback["mousemove"]) {
			self.Callback["mousemove"](Event);
		}
	}

	//=========================================================================
	self.OnCleanup = function() {
		XLibrary.Delete(self.Control);
		XLibrary.Delete(self.Callback);
		XLibrary.Delete(self.Element);
		XLibrary.Delete(self.Handle);

		if(Handle) {
			XEvent.RemoveEvent(Handle, "mousedown", self.OnMouseDown);
		}else{
			XEvent.RemoveEvent(Element, "mousedown", self.OnMouseDown);
		}

		XEvent.RemoveEvent(window.document, "mouseup", self.OnMouseUp);
		XEvent.RemoveEvent(window.document, "mousemove", self.OnMouseMove);
	}

	//=========================================================================
	// Constructor
	//=========================================================================

	if(Handle) {
		XEvent.AddEvent(Handle, "mousedown", self.OnMouseDown);
	}else{
		XEvent.AddEvent(Element, "mousedown", self.OnMouseDown);
	}

	XEvent.AddEvent(window.document, "mouseup", self.OnMouseUp);
	XEvent.AddEvent(window.document, "mousemove", self.OnMouseMove);
}

//=============================================================================

//XLibrary.Include(XLibrary.Path + "XMenu.js");
/*============================================================================||
||       __  ___  _______    ___  ____  __         ___                        ||
||      /  \/  /_/__  __/_ _/ __\/_/  \/ /   _____/   \                       ||
||     / /\_/ / ___/ / __ `/ /  __/ __/  \  / ___/  `_/                       ||
||    / /  / / __// / /_/ / /__/ / / / /\ \/ __// /\ \                        ||
||   /_/  /_/____/_/\__,_/\___/_/_/ /_/ /_/____/_/ /_/                        ||
||                                                                            ||
||============================================================================||
|| XResize																	  ||
|| Copyright Tim Jones. All Rights Reserved.                                  ||
||============================================================================*/

XResize = {};

//=============================================================================

XResize.Resize = function() {
	var Clicked	= false;

	var StartX		= 0;
	var StartY		= 0;

	var ParentWidth		= 0;
	var ParentHeight	= 0;

	var SrcElement	= 0;
	var Parent		= 0;

	var XAxis		= true;
	var YAxis		= true;

	var	MinimumX	= 40;
	var	MinimumY	= 40;

	var self					= this;

	//public
		self.Callback			= new XCallback.Callback();

	//-------------------------------------------------------------------------
	this.SetAxis = function(NewXAxis, NewYAxis) {
		XAxis = NewXAxis;
		YAxis = NewYAxis;
	}

	//-------------------------------------------------------------------------
	this.SetSrcElement = function(NewSrcElement) {
		SrcElement = NewSrcElement;
	}

	//-------------------------------------------------------------------------
	this.SetParent = function(NewParent) {
		Parent = NewParent;
	}

	//-------------------------------------------------------------------------
	this.OnMouseUp = function(Event) {
		Clicked = false;

		if(self.Callback["mouseup"]) {
			self.Callback["mouseup"](Event);
		}
	}

	//-------------------------------------------------------------------------
	this.OnMouseDown = function(Event) {
		Clicked = true;

		if(XAxis) {
			StartX = XMouse.GetX(Event);
			ParentWidth = XElement.GetWidth(Parent);
		}

		if(YAxis) {
			StartY = XMouse.GetY(Event);
			ParentHeight = XElement.GetHeight(Parent);
		}
	}

	//-------------------------------------------------------------------------
	this.OnMouseMove = function(Event) {
		if(Clicked == false) return;

		self.OnUpdate(Event);

		if(self.Callback["mousemove"]) {
			self.Callback["mousemove"](Event);
		}
	}

	//-------------------------------------------------------------------------
	this.OnUpdate = function(Event) {
		if(XAxis) {
			var NewX = (ParentWidth + (XMouse.GetX(Event) - StartX));

			if(NewX >= MinimumX) {
				Parent.style.width = NewX + "px"; 
			}
		}

		if(YAxis) {
			var NewY = (ParentHeight + (XMouse.GetY(Event) - StartY));

			if(NewY >= MinimumY) {
				Parent.style.height  = NewY + "px";
			}
		}
	}
}

//=============================================================================
XResize.Create = function(Element, Parent) {
	Resize = new XResize.Resize();

	Resize.SetSrcElement(Element);
	Resize.SetParent(Parent);

	XEvent.AddEvent(Element, "mousedown", Resize.OnMouseDown);
	XEvent.AddEvent(window.document, "mouseup", Resize.OnMouseUp);
	XEvent.AddEvent(window.document, "mousemove", Resize.OnMouseMove);

	return Resize;
}

//=============================================================================

//XLibrary.Include(XLibrary.Path + "XToolbar.js");
/*============================================================================||
||       __  ___  _______    ___  ____  __         ___                        ||
||      /  \/  /_/__  __/_ _/ __\/_/  \/ /   _____/   \                       ||
||     / /\_/ / ___/ / __ `/ /  __/ __/  \  / ___/  `_/                       ||
||    / /  / / __// / /_/ / /__/ / / / /\ \/ __// /\ \                        ||
||   /_/  /_/____/_/\__,_/\___/_/_/ /_/ /_/____/_/ /_/                        ||
||                                                                            ||
||============================================================================||
|| XWindow																	  ||
|| Copyright Tim Jones. All Rights Reserved.                                  ||
||============================================================================*/

XWindow = {};

//=============================================================================
/*
	A Generic Window Class for DIV window element

	SrcElement		The Targer Element that this class treats as a Window
*/
XWindow.Window = function(SrcElement) {
	var self			= this;		//This class

	//public
		self.Control		= new XControl.Control(SrcElement);

	//private
		var Maximized		= false;	//If the window is maximized or minimized
		var Minimized		= false;

		var Restore_X			= 0;	//Where to restore
		var Restore_Y			= 0;

		var Restore_Width		= 0;	//The original window width
		var Restore_Height		= 0;
			
		var Minimized_X			= 0;	//Where to minimize
		var Minimized_Y			= 0;

		var Minimized_Width		= 100;	//Size when minimized (usually small so only title bar shows)
		var Minimized_Height	= 25;

	//-------------------------------------------------------------------------
	/*
		Aligns the Window to the center of the screen

		@Return
			None
	*/
	self.AlignCenter = function() {
		var X = (XDocument.GetWidth()  / 2) - (XElement.GetWidth(self.Control.Element.SrcElement)  / 2);
		var Y = (XDocument.GetHeight() / 2) - (XElement.GetHeight(self.Control.Element.SrcElement) / 2) + document.body.scrollTop;

		XElement.SetX(self.Control.Element.SrcElement, X);
		XElement.SetY(self.Control.Element.SrcElement, Y);
	}

	//-------------------------------------------------------------------------
	/*
		Closes (essentially hides) the window

		@Return
			None
	*/
	self.Close = function() {
		self.Control.Element.Hide();
	}

	//-------------------------------------------------------------------------
	/*
		Maximizes the window (or restores if already maximized)

		@Return
			None
	*/
	self.Maximize = function() {
		//If already Maximized
		if(Maximized) {

			//Set the Dimensions and Coords to the Restore Variables
			self.Control.Element.SrcElement.style.width		= Restore_Width  + "px";
			self.Control.Element.SrcElement.style.height	= Restore_Height + "px";

			XElement.SetX(self.Control.Element.SrcElement, Restore_X);
			XElement.SetY(self.Control.Element.SrcElement, Restore_Y);
	
		//If not Maximized
		}else{
			//Store the Original Dimensions and Coords
			Restore_Width	= XElement.GetWidth(self.Control.Element.SrcElement);
			Restore_Height	= XElement.GetHeight(self.Control.Element.SrcElement);

			Restore_X = XElement.GetX(self.Control.Element.SrcElement);
			Restore_Y = XElement.GetY(self.Control.Element.SrcElement);

			//Set to 100% (fullscreen) and at (0, 0)
			self.Control.Element.SrcElement.style.width		= "100%";
			self.Control.Element.SrcElement.style.height	= "100%";

			XElement.SetX(self.Control.Element.SrcElement, 0);
			XElement.SetY(self.Control.Element.SrcElement, 0);

			//Turn off minimized
			Minimized = false;
		}

		//Toggle Maximized Flag
		Maximized = !Maximized;
	}

	//-------------------------------------------------------------------------
	/*
		Minimize the window (or restores if already minimized)

		@Return
			None
	*/
	self.Minimize = function() {
		//If window is minimized
		if(Minimized) {
			//Restore window back to original coords and dimensions
			self.Control.Element.SrcElement.style.width		= Restore_Width  + "px";
			self.Control.Element.SrcElement.style.height	= Restore_Height + "px";

			XElement.SetX(self.Control.Element.SrcElement, Restore_X);
			XElement.SetY(self.Control.Element.SrcElement, Restore_Y);

		//If window is not minimized
		}else{
			//Store original dimensions and coords
			Restore_Width	= XElement.GetWidth(self.Control.Element.SrcElement);
			Restore_Height	= XElement.GetHeight(self.Control.Element.SrcElement);

			Restore_X = XElement.GetX(self.Control.Element.SrcElement);
			Restore_Y = XElement.GetY(self.Control.Element.SrcElement);

			//Set to Minimized Dimensions and Coords
			self.Control.Element.SrcElement.style.width		= Minimized_Width  + "px";
			self.Control.Element.SrcElement.style.height	= Minimized_Height + "px";

			XElement.SetX(self.Control.Element.SrcElement, Minimized_X);
			XElement.SetY(self.Control.Element.SrcElement, Minimized_Y);
		}

		//Toggle Minimized flag
		Minimized = !Minimized;
	}

	//=========================================================================
	/*
		Class destructor
	*/
	self.OnCleanup = function() {
		XLibrary.Delete(self.Control);	//Delete Control class
	}

	//=========================================================================
	// Constructor
	//=========================================================================

	self.AlignCenter(); //Align window to center of the screen
}

//=============================================================================


//-----------------------------------------------------------------------------
// Other
//-----------------------------------------------------------------------------
//XLibrary.Include(XLibrary.Path + "XConsole.js");
/*============================================================================||
||       __  ___  _______    ___  ____  __         ___                        ||
||      /  \/  /_/__  __/_ _/ __\/_/  \/ /   _____/   \                       ||
||     / /\_/ / ___/ / __ `/ /  __/ __/  \  / ___/  `_/                       ||
||    / /  / / __// / /_/ / /__/ / / / /\ \/ __// /\ \                        ||
||   /_/  /_/____/_/\__,_/\___/_/_/ /_/ /_/____/_/ /_/                        ||
||                                                                            ||
||============================================================================||
|| XEffect																	  ||
|| Copyright Tim Jones. All Rights Reserved.                                  ||
||============================================================================*/

XEffect = {};

//=============================================================================
XEffect.Slide = function(Element, X, Y, X2, Y2, Steps) {
	if(Steps < 1) {
		return;
	}

	var Count = 0;

	var XInterval = (X2 - X) / Steps;
	var YInterval = (Y2 - Y) / Steps;

	var NewX = X;
	var NewY = Y;

	function OnMove() {
		NewX += XInterval;
		NewY += YInterval;

		Element.style.left = NewX + "px";
		Element.style.top  = NewY + "px";

		Count++;

		if(Count < Steps) {
			setTimeout(OnMove, 5);
		}
	}

	OnMove();
}

//-----------------------------------------------------------------------------
XEffect.FadeIn = function(Element, Steps, Callback) {
	if(Steps < 1) {
		return;
	}

	var Count = 0;

	var AlphaStep = 1.0 / Steps;

	function OnFade() {
		Element.style.filter		= "alpha(opacity=" + ((Count * AlphaStep) * 100) + ")";
		Element.style.MozOpacity	= Count * AlphaStep;

		Count++;

		if(Count < Steps) {
			setTimeout(OnFade, 10);
		}else{
			Element.style.filter = "alpha(opacity=100)";
			Element.style.MozOpacity = 1.0;

			if(Callback) {
				Callback();
			}
		}
	}

	OnFade();
}

//-----------------------------------------------------------------------------
XEffect.FadeOut = function(Element, Steps, Callback) {
	if(Steps < 1) {
		return;
	}

	var Count = Steps;

	var AlphaStep = 1.0 / Steps;

	function OnFade() {
		Element.style.filter = "alpha(opacity=" + ((Count * AlphaStep) * 100) + ")";
		Element.style.MozOpacity = Count * AlphaStep;

		Count--;

		if(Count >= 0) {
			setTimeout(OnFade, 10);
		}else{
			Element.style.filter = "alpha(opacity=0)";
			Element.style.MozOpacity = 0.0;

			if(Callback) {
				Callback();
			}
		}
	}

	OnFade();
}

//-----------------------------------------------------------------------------
XEffect.Grow = function(Element, Steps, StartWidth, StartHeight, GrowX, GrowY, Shrink, Callback) {
	if(Steps < 1) {
		return;
	}

	var Count = 0;

	var XInterval = GrowX / Steps;
	var YInterval = GrowY / Steps;

	var NewWidth	= StartWidth;
	var NewHeight	= StartHeight;

	if(Shrink) {
		XInterval = -XInterval;
		YInterval = -YInterval;
	}

	function OnMove() {
		NewWidth  += XInterval;
		NewHeight += YInterval;

		if(GrowX && NewWidth >= 0) {
			XElement.SetWidth(Element, NewWidth);
		}

		if(GrowY && NewHeight >= 0) {
			XElement.SetHeight(Element, NewHeight);
		}

		Count++;

		if(Count < Steps) {
			setTimeout(OnMove, 5);
		}else if(Callback) {
			Callback();
		}
	}

	OnMove();
}

//=============================================================================

//XLibrary.Include(XLibrary.Path + "XGrid.js");
//XLibrary.Include(XLibrary.Path + "XPreview.js");

//=============================================================================