XLibrary = {};

XLibrary.Version = {
	Major	: 1,
	Minor	: 0,
	Release : "Beta",

	Get : function() {
		return this.Major + "." + this.Minor + " " + this.Release;
	}
};

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/";

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

	theArray.push(Value);

	theArray.reverse();

	return theArray;
}

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 = {};

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

		self.SrcElement	= SrcElement;

		var Visible		= true;

	self.GetX = function() {
		var X = self.SrcElement.style.left.replace("px", "");
			X = X.replace("%", "");
	
		return parseInt(X);
	}

	self.GetY = function() {
		var Y = self.SrcElement.style.top.replace("px", "");
			Y = Y.replace("%", "");

		return parseInt(Y);
	}

	self.Show = function() {
		if(self.SrcElement) {
			self.SrcElement.style.display = "block";
		}

		Visible = true;
	}

	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;
	}

	self.Hide = function() {
		if(self.SrcElement) {
			self.SrcElement.style.display = "none";
		}

		Visible = false;
	}

	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.AddChildBefore = function(ID, Parent, Content) {
	var NewElement		= document.createElement('div');

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

	Parent.insertBefore(NewElement, Parent.firstChild);

	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;
	}
}

XElement.Purge = function(d) {
	if(d == null) return;

    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;
}

if(Array.prototype.push == null){
	Array.prototype.push = function(){
		for(var i = 0; i < arguments.length; i++){
			this[this.length] = arguments[i];
		};
		return this.length;
	};
};

var EventCache = function(){
	var listEvents = [];
	
	return {
		listEvents : listEvents,
	
		add : function(node, sEventName, fHandler, bCapture){
			listEvents.push(arguments);
		},
	
		flush : function(){
			var i, item;
			for(i = listEvents.length - 1; i >= 0; i = i - 1){
				item = listEvents[i];
				
				if(item[0].removeEventListener){
					item[0].removeEventListener(item[1], item[2], item[3]);
				};
				
				/* From this point on we need the event names to be prefixed with 'on" */
				if(item[1].substring(0, 2) != "on"){
					item[1] = "on" + item[1];
				};
				
				if(item[0].detachEvent){
					item[0].detachEvent(item[1], item[2]);
				};
				
				item[0][item[1]] = null;
			};
		}
	};
}();


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;
	}

	EventCache.add(Element, EventName, Callback, true);
}

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 = {};

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 = {};

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 = {};

XXML.HTTP = null;

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;
}

XXML.GetPage = function(URL, Callback) {
	var HTTP = XXML.SendRequest(URL, Callback, false);

	return HTTP.responseText;
}

XXML.SendRequest = 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("GET", URL, Async); 
	HTTP.send("");

	return HTTP;
}

XXML.GetPage_POST = function(URL, Callback) {
	var HTTP = XXML.SendRequest_POST(URL, Callback, false);

	return HTTP.responseText;
}

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;
}

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

	Input = escape(Input);

	return Input;
}

XXML.UncleanURLArg = function(Input) {
	Input = unescape(Input);

	return Input;
}


XDrag = {};

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

	//public
		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);
	}

	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);
}

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, 50);
		}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, 50);
		}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();
}

XDropMenu = {};

XDropMenu.Menu = function(ParentElement, List) {
	var self					= this;

	self.ParentElement				= ParentElement;

	self.ListElement				= null;

	self.IsOnMenu					= false;

	self.Height						= 0;

	self.OffsetX					= 3;
	self.OffsetY					= 30;

	self.Classname					= "XDropMenu-";

	self.OnMouseOver = function() {
		self.IsOnMenu = true;

		if(self.ListElement.style.display == "block") return;

		self.ListElement.style.display = "block";

		var X = XElement.GetPosX(self.ParentElement);
		var Y = XElement.GetPosY(self.ParentElement);

		self.ListElement.style.left = (X + self.OffsetX) + "px";
		self.ListElement.style.top  = (Y + self.OffsetY) + "px";

		XEffect.Grow(self.ListElement, 10, 0, 0, 0, self.Height, false, null);
	}

	self.OnMouseOut = function(Event) {
		self.IsOnMenu = false;

		function HideMe() {
			if(self.IsOnMenu) return;

			function Hide() {
				self.ListElement.style.display = "none";
			}

			XEffect.Grow(self.ListElement, 10, 0, self.Height, 0, self.Height, true, Hide);
		}

		setTimeout(HideMe, 100);
	}

	self.OnMouseOver_List = function(Event) {
		self.IsOnMenu = true;
	}

	self.OnMouseOut_List = function(Event) {
		self.OnMouseOut(Event);
	}

	self.PopulateList = function(List) {
		self.ListElement = document.createElement('div');

		self.ListElement.className = self.Classname + "Button-List";
		self.ListElement.innerHTML = "";

		document.body.appendChild(self.ListElement);

		for(var i = 0;i < List.length;i++) {
			var OnClickPre  = "";
			var OnClickPost = "";

			if(List[i][2]) {
				OnClickPre  = "";
				OnClickPost = ""
			}else{
				OnClickPre  = "document.location.href = '";
				OnClickPost = "'";
			}

			self.ListElement.innerHTML = self.ListElement.innerHTML + "<div class='" + self.Classname + "Button-List-Item' onMouseOver='this.className = \"" + self.Classname + "Button-List-Item-Over\"' onMouseOut='this.className = \"" + self.Classname + "Button-List-Item\"' onClick=\"" + OnClickPre + List[i][1] + OnClickPost + "\">" + List[i][0] + "</div>";
		}

		self.ListElement.innerHTML = self.ListElement.innerHTML + "<img src='./gfx/" + self.Classname + "bottom.png'/>";

		self.Height = XElement.GetHeight(self.ListElement);

		self.ListElement.style.display = "none";

		XEvent.AddEvent(self.ListElement, "mouseover", self.OnMouseOver_List);
		XEvent.AddEvent(self.ListElement, "mouseout", self.OnMouseOut_List);
	}

	XEvent.AddEvent(self.ParentElement, "mouseover", self.OnMouseOver);
	XEvent.AddEvent(self.ParentElement, "mouseout", self.OnMouseOut);

	self.PopulateList(List);
}

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;

	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;
	}

	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);
	}

	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";
			}
		}
	}

	this.OnCleanup = function() {
		XLibrary.Delete(self.Callback);

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

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;
}