if ("undefined" == typeof(RadDockNamespace))
{
	RadDockNamespace = new Object();
}

/*************************************************
 *
 * Global vars
 *
 *************************************************/
RadDockNamespace.RadDock_ActiveObject = null;			/* Dockable object that is curently dragging */
RadDockNamespace.RadDock_DragStartFired = false;   /* Flag to show if the drag start is already fired*/
RadDockNamespace.RadDock_ResizeStartFired = false;  /* Flag to show if resize start is already fired*/
RadDockNamespace.RadDock_ActiveDockingZone = null;		/* Docking zone currently hover by the active object */
RadDockNamespace.RadDock_DragHelper = null;				/* Active drag helper */
RadDockNamespace.RadDock_DragHelperTooltip = null;
RadDockNamespace.RadDock_HoverDockableObject = null;	/* Dockable object under the mouse pointer */
RadDockNamespace.RadDock_Action = "";					/* Possible action for the hoverd dockable object if start drag; */
RadDockNamespace.RadDock_MouseX = 0;					/* Last mouse x-coord */
RadDockNamespace.RadDock_MouseY = 0;					/* Last mouse y-coord */
RadDockNamespace.RadDock_IsActiveObjectDragged = false;	/* Flag indicates if when drag is started the object is actually dragged */

/*************************************************
 *
 * RadDockNamespace.RadDock_MouseMove
 *
 *************************************************/
RadDockNamespace.RadDock_MouseMove = function(eventArgs)
{
	if (!eventArgs)
	{
		eventArgs = window.event;
	}
	
	if (RadDockNamespace.RadDock_ActiveObject)
	{
		RadDockNamespace.RadDock_DragActiveObject(eventArgs);
		RadDockNamespace.RadDock_IsActiveObjectDragged = true;
	}
	else if (!this.effect)
	{
		var o = RadDockNamespace.RadDock_GetHoverdDockableObjectAction(eventArgs);
		
		RadDockNamespace.RadDock_HoverDockableObject = o ? o.hoveredObject : null;
		RadDockNamespace.RadDock_Action = o ? o.action : null;
		
		RadDockNamespace.RadDock_SetCursor(RadDockNamespace.RadDock_Action);
	}
};

/*************************************************
 *
 * RadDockNamespace.RadDock_MouseDown
 *
 *************************************************/
RadDockNamespace.RadDock_MouseDown = function(eventArgs)
{
	if (!eventArgs)
	{
		eventArgs = window.event;
	}
	
	if (RadDockNamespace.RadDock_HoverDockableObject)
	{
		RadDockNamespace.RadDock_StartDrag(RadDockNamespace.RadDock_HoverDockableObject, eventArgs);
		
		if (eventArgs.preventDefault)
		{
			eventArgs.preventDefault();
		}
		
		eventArgs.returnValue = false;
	}
};

/*************************************************
 *
 * RadDockNamespace.RadDock_MouseUp
 *
 *************************************************/
RadDockNamespace.RadDock_MouseUp = function(eventArgs)
{
	if (!eventArgs)
	{
		eventArgs = window.event;
	}
	if (RadDockNamespace.RadDock_ActiveObject)
	{
		var activeObject = RadDockNamespace.RadDock_ActiveObject;
        //Petio: Changed to fire only when the object is drage. On Resize it is not fired
		if (activeObject.FireEvent && "move" == RadDockNamespace.RadDock_Action) 
		{
			activeObject.FireEvent("DragEnd",'', activeObject);
		}

		RadDockNamespace.RadDock_EndDrag(eventArgs);
	}
};

/*************************************************
 *
 * RadDockNamespace.RadDock_KeyDown
 *
 *************************************************/
RadDockNamespace.RadDock_KeyDown = function(eventArgs)
{
	if (!eventArgs)
	{
		eventArgs = window.event;
	}
	
	if (27 == eventArgs.keyCode)
	{	
		if (RadDockNamespace.RadDock_ActiveObject)
			RadDockNamespace.RadDock_CancelDrag(eventArgs);
		
		if (this.effect)
		{
			this.effect.SetToStop();
		}		
	}
};

/*************************************************
 *
 * RadDockNamespace.RadDock_StartDrag
 *
 *************************************************/
RadDockNamespace.RadDock_StartDrag = function(dragElement, eventArgs)
{
	RadDockNamespace.RadDock_IsActiveObjectDragged = false;
	RadDockNamespace.RadDock_ActiveObject = dragElement;
	RadDockNamespace.RadDock_DragStartFired = false;
	RadDockNamespace.RadDock_DragStartFired = false;
	
	RadDockNamespace.RadDock_MouseX = eventArgs.clientX;
	RadDockNamespace.RadDock_MouseY = eventArgs.clientY;

	// If object is floating bring it to front of all elements	
	if (RadDockNamespace.RadDock_ActiveObject.IsFloating())
	{
		RadDockNamespace.RadDock_ActiveObject.BringToFront();
	}
};

/*************************************************
 *
 * RadDockNamespace.RadDock_EndDrag
 *
 *************************************************/
RadDockNamespace.RadDock_EndDrag = function(eventArgs)
{
	if (RadDockNamespace.RadDock_IsActiveObjectDragged)
	{
		RadDockNamespace.RadDock_IsActiveObjectDragged = false;
		
		var activeObject = RadDockNamespace.RadDock_ActiveObject;
		var useEffects = activeObject.Manager.UseEffects;
		
		if (useEffects)
		{
			RadDockNamespace.RadDock_EndDragWithEffects(eventArgs);
		}
		else
		{
			RadDockNamespace.RadDock_EndDragNoEffect(eventArgs);
		}

		if (activeObject.FireEvent) 
		{	
		    //Petio	-Add ResizeEnd event. Drop is not fired when resize appears    
		    if("move" == RadDockNamespace.RadDock_Action)
		    {		    
		        activeObject.FireEvent("Drop",'', activeObject);
		    }
		    else
		    {		    
		        activeObject.FireEvent("ResizeEnd",'', activeObject);		   
		    }
			
		}
		

	}


	RadDockNamespace.RadDock_CancelDrag(eventArgs);
};

RadDockNamespace.RadDock_EndDragNoEffect = function(eventArgs)
{
	var activeZone = RadDockNamespace.RadDock_ActiveDockingZone;
	var activeObject = RadDockNamespace.RadDock_ActiveObject;
	var startZone = activeObject.ParentDockingZone;
	
	var dockedObject, undockedObject;

	if (activeZone)
	{
		activeZone.Dock(activeObject);
		
		dockedObject = activeObject;
	}
	else if (RadDockNamespace.RadDock_DragHelper)
	{	
		var rc = RadDockNamespace.RadDock_DragHelper.GetRect();
		
		if ("move" == RadDockNamespace.RadDock_Action
			&& activeObject.IsDocked())
		{		
			if (!activeObject.CanFloat())
			{
				return;
			}
			activeObject.Undock();
			undockedObject = activeObject;
		}			
		
		activeObject.SetRect(rc);
	}		
	
	activeObject.SaveState();
	
	if (startZone)
	{
		startZone.SaveState();
	}
	
	if (dockedObject)
	{
		dockedObject.Docked();
	}
	else if (undockedObject)
	{
		undockedObject.Undocked();
	}
	
	dockedObject = null;
	undockedObject = null;
};

RadDockNamespace.RadDock_EndDragWithEffects = function(eventArgs)
{
	var activeZone = RadDockNamespace.RadDock_ActiveDockingZone;
	var activeObject = RadDockNamespace.RadDock_ActiveObject;
	var action = RadDockNamespace.RadDock_Action;
	var startZone = activeObject.ParentDockingZone;
		
	var dockedObject, undockedObject;
	
	var startObject, endObject, moveObject;
	var startRect, endRect;
	
	startRect = activeObject.GetRect();
	
	
	if ("move" == action
		&& activeObject.ParentDockingZone)
	{
		startObject = RadDockNamespace.RadDock_CreateSubstObject(activeObject, false);
	}		
	
	if (activeZone)
	{

		// dock the object
		activeZone.Dock(activeObject);
		activeObject.Docked(false);			
		dockedObject = activeObject;
					
		endRect = activeObject.GetRect();						
		endObject = RadDockNamespace.RadDock_CreateSubstObject(activeObject, true);
		
		// move fake object
		moveObject = activeObject.cloneNode(3);				
		document.body.appendChild(moveObject);
		moveObject.style.position = "absolute";				
		moveObject.style.display = "";
						
		moveObject.GetRect = activeObject.GetRect;
		moveObject.SetRect = activeObject.SetRect;
		moveObject.SetSize = activeObject.SetSize;
		moveObject.Overlay = activeObject.Overlay;
		
		moveObject.MoveTo = activeObject.MoveTo;
		
		activeObject.style.display = "none";
	}
	else
	{
		if ("move" == action
			&& activeObject.IsDocked())
		{
			if (!activeObject.CanFloat())
			{
				if (startObject)
				{
					startObject.parentNode.removeChild(startObject);
					startObject = null;
				}
				return;
			}
	
			// undock if docked
			activeObject.Undock();
			undockedObject = activeObject;
		}
		
		moveObject = activeObject;
		endRect = RadDockNamespace.RadDock_DragHelper.GetRect();
	}
	
	if ("move" == action)
	{
		moveObject.SetRect(startRect);
	}
	
	var i = 0;
	var effects = new Array();
	
	if (startObject)
	{
	
		effects[i++] = 
			new RadEffect.Resize( 
				{ 
					object : startObject
					, width : 0
					, height : 0
					, sync : true 
				} 
			);
	}		
	
	if (endObject)
	{
		effects[i++] = 
			new RadEffect.Resize( 
			{ 
				object : endObject
				, width : endRect.width
				, height : endRect.height
				, sync : true
			} 
		);
	}		
	
	if (!("move" != action && activeObject.ParentDockingZone))
	{
		// no MoveTo when resizing docked object
		effects[i++] = 
			new RadEffect.MoveTo( 
			{ 
				object : moveObject
				, destX : endRect.left
				, destY : endRect.top
				, sync : true
			} 
		);
	}
	
	if ("move" != action)
	{
		// xHtml IE problem hack!
		var h = moveObject.style.height;
		var ieHeightFixDelta = RadDockNamespace.FixIeHeight(moveObject);
		moveObject.style.height = h;
		// end hack	
	
		effects[i++] = 
			new RadEffect.Resize( 
			{ 
				object : moveObject
				, width : endRect.width
				, height : endRect.height - ieHeightFixDelta
				, sync : true
			} 
		);
	}
	
	var __this = this;
	var onFinish = function()
	{
		if (startObject)
		{
			startObject.parentNode.removeChild(startObject);
			startObject = null;
		}
		
		if (endObject)
		{
			endObject.parentNode.removeChild(endObject);
			endObject = null;
		}
		
		if (moveObject && moveObject != activeObject)
		{
			moveObject.parentNode.removeChild(moveObject);
			moveObject = null;
		}
	
		if (dockedObject)
		{
			dockedObject.Docked();
		}
		else if (undockedObject)
		{
			undockedObject.Undocked();
		}
		
		if (startZone)
		{
			startZone.SaveState();
			startZone = null;
		}
		
		if (activeZone)
		{
			activeZone.SaveState();
			activeZone = null;
		}
		
		activeObject.SaveState();
		
		dockedObject = null;
		undockedObject = null;
		
		__this.effect = null;
		RadDockNamespace.RadDock_SetCursor("default");
	};
	
	var manager = activeObject.Manager;
	
	this.effect = new RadEffect.Parallel(
		{
			fps : manager.EffectsUpdateSpeed
			, duration : manager.EffectsDuration
			, beforeStart : function() { RadDockNamespace.RadDock_SetCursor("wait"); }
			, afterFinish : onFinish
			, effects : effects
		}
	);

};

RadDockNamespace.RadDock_CreateSubstObject = function(dockableObject, collapsed)
{
	var subsObj;	
	if (document.all)
	{
		subsObj = document.createElement("span"); 
	}
	else
	{	
		subsObj = document.createElement("table");
		subsObj.insertRow(0).insertCell(0);
	}	
	var rc = dockableObject.GetRect();	
	subsObj.style.width = (collapsed ? 0 : rc.width) + "px";
	subsObj.style.height = (collapsed ? 0 : rc.height) + "px";
	subsObj.style.font = "normal 1px arial";	
	//subsObj.style.backgroundColor = arguments[2];
	dockableObject.parentNode.insertBefore(subsObj, dockableObject);	
	return subsObj;
};

/*************************************************
 *
 * RadDockNamespace.RadDock_CancelDrag
 *
 *************************************************/
RadDockNamespace.RadDock_CancelDrag = function(eventArgs)
{
	RadDockNamespace.RadDock_HideDragHelper();
	
	if (RadDockNamespace.RadDock_ActiveDockingZone)
	{
		RadDockNamespace.RadDock_ActiveDockingZone.Highlight(false);
	}

	RadDockNamespace.RadDock_ActiveObject = null;
	RadDockNamespace.RadDock_DragStartFired = false;
	RadDockNamespace.RadDock_ResizeStartFired = false;	
	RadDockNamespace.RadDock_ActiveDockingZone = null;	
	
	RadDockNamespace.RadDock_MouseX = null;
	RadDockNamespace.RadDock_MouseY = null;
	
	if (RadDockNamespace.RadDock_DragHelperTooltip)
	{
		RadDockNamespace.RadDock_DragHelperTooltip.Hide();
		RadDockNamespace.RadDock_DragHelperTooltip = null;
	}
};

/*************************************************
 *
 * RadDockNamespace.RadDock_DragActiveObject
 *
 *************************************************/
RadDockNamespace.RadDock_DragActiveObject = function(eventArgs)
{
	var dx = eventArgs.clientX - RadDockNamespace.RadDock_MouseX;
	var dy = eventArgs.clientY - RadDockNamespace.RadDock_MouseY;
	
	var activeObject = RadDockNamespace.RadDock_ActiveObject;	
	var manager = activeObject.Manager;
	
	if (!RadDockNamespace.RadDock_DragHelper)
	{		
		RadDockNamespace.RadDock_DragHelper = RadDockNamespace.RadDock_InitDragHelper(activeObject);
	}
	
	if (manager.ShowToolTipWhileDragging 
		&& !RadDockNamespace.RadDock_DragHelperTooltip)
	{
		RadDockNamespace.RadDock_DragHelperTooltip = RadDockNamespace.RadDock_InitDragHelperTooltip(activeObject);
	}
	
	var dragHelper = RadDockNamespace.RadDock_DragHelper;
		
	if ("move" == RadDockNamespace.RadDock_Action)
	{
		// Move the drag helper
		dragHelper.MoveBy(dx, dy);		
		var dragHelperRect = dragHelper.GetRect();
		
		// Get the docking zone that drag helper is hovering
		RadDockNamespace.RadDock_ActiveDockingZone = 
			manager.DockingZoneHitTest(activeObject
				, eventArgs
				, dragHelperRect
			);
		
		// Try to scroll the document to make drag helper fit in it
		RadDockNamespace.RadDock_ScrollDocumentToFit(dragHelperRect);
		
		RadDockNamespace.RadDock_ShowTooltip(eventArgs, dragHelperRect, true);

		if (activeObject.FireEvent) 
		{		    
			if (!RadDockNamespace.RadDock_DragStartFired) 
			{
				RadDockNamespace.RadDock_DragStartFired = true;
				activeObject.FireEvent("DragStart", '', activeObject);
			}		
			activeObject.FireEvent("Drag", '', activeObject);
		}

	}
	else
	{
	    if (activeObject.FireEvent) 
		{		    
			if (!RadDockNamespace.RadDock_ResizeStartFired) 
			{
				RadDockNamespace.RadDock_ResizeStartFired = true;
				activeObject.FireEvent("ResizeStart", '', activeObject);
			}		
		}
		// NOTE: for proper resizing we need to set the
		// size of the inner object that is a clone of 
		// the original dockable object (if any).
		var child = dragHelper.childNodes[0];
		if (child)
		{
			child.style.width = "1px";
			child.style.height = "1px";
		}
		
		// Resize the drag helper
		dragHelper.Resize(RadDockNamespace.RadDock_Action, dx, dy);
		var dragHelperRect = dragHelper.GetRect();
		
		// Resize the drag helper content if any		
		if (child)
		{
			child.style.width = dragHelperRect.width + "px";
			child.style.height = dragHelperRect.height + "px";
			RadDockNamespace.FixIeHeight(child);
		}
		RadDockNamespace.RadDock_ShowTooltip(eventArgs, dragHelperRect, false);
	}
	
	RadDockNamespace.RadDock_MouseX = eventArgs.clientX;
	RadDockNamespace.RadDock_MouseY = eventArgs.clientY;
};

RadDockNamespace.RadDock_ShowTooltip = function(eventArgs, rect, positionOrSize)
{
	var toolTip = RadDockNamespace.RadDock_DragHelperTooltip;
	if (toolTip)
	{
		if (positionOrSize)
		{
			toolTip.SetText("(" + rect.left + "," + rect.top + ")");
		}
		else
		{
			toolTip.SetText("(" + rect.width + " x " + rect.height + ")");
		}
		var x = eventArgs.clientX + 5 + RadDockNamespace.GetScrollLeft();
		var y = eventArgs.clientY + 5 + RadDockNamespace.GetScrollTop();
		toolTip.ShowAt(x, y);
	}
};


/*************************************************
 *
 * RadDockNamespace.RadDock_InitDragHelper
 *
 *************************************************/
RadDockNamespace.RadDock_InitDragHelper = function(dockableObject)
{
	var dockingManager = dockableObject.Manager;
	if (!dockingManager.DragHelper) return;
	
	if (!dockingManager.IsDragHelperMoved && document.all) 
	{
		// move the helper to be direct child of
		// the body tags in order to position it 
		// properly (otherwise it is positioned relatively according to the parent element)
		var dragHelperClone = dockingManager.DragHelper.cloneNode(true);
		document.body.appendChild(dragHelperClone);
		dockingManager.DragHelper.parentNode.removeChild(dockingManager.DragHelper);
		dockingManager.IsDragHelperMoved = true;
		dockingManager.DragHelper = dragHelperClone;
	}

	var dragHelper = dockingManager.DragHelper;
	if (!dragHelper)
		return null;
	
	dragHelper.innerHTML = "";

	// TODO handle FF also
	if (dockingManager.ShowContentWhileDragging)
	{		
		var rc = dockableObject.GetRect();
		
		// Clone the original dockable object 
		// to show the dragable object content in
		// the drag helper.
		
		var clone = dockableObject.cloneNode(true);	
		clone.style.position = "";
		clone.style.display = "";
		/* 
			We dont need to set the w/h again since they are added to the original object instead
			This is making problem when IE is in xHTML mode.
		*/
		//clone.style.width = rc.width + "px";
		//clone.style.height = rc.height + "px";
		dragHelper.appendChild(clone);
	}

	dragHelper.style.position = "absolute";	
	dragHelper.Show();

	dragHelper.SetRect(dockableObject.GetRect());

	dragHelper.BringToFront();	
	return dragHelper;
};

RadDockNamespace.RadDock_InitDragHelperTooltip = function(dockableObject)
{
	var dockingManager = dockableObject.Manager;
	if (!dockingManager.DragHelperTooltip) return;
	
	// TODO handle FF also
	if (!dockingManager.IsDragTooltipMoved && document.all) 
	{
		// move the helper to be direct child of
		// the body tags in order to position it 
		// properly (otherwise it is positioned relatively according to the parent element)
		
		var dragHelperTooltipClone = dockingManager.DragHelperTooltip.cloneNode(true);
		document.body.appendChild(dragHelperTooltipClone);
		dockingManager.DragHelperTooltip.parentNode.removeChild(dockingManager.DragHelperTooltip);
		dockingManager.IsDragTooltipMoved = true;
		dockingManager.DragHelperTooltip = dragHelperTooltipClone;
	}

	var dragHelperTooltip = dockingManager.DragHelperTooltip;
	if (!dragHelperTooltip)
		return null;
		
	dragHelperTooltip.BringToFront();
	
	return dragHelperTooltip;
};

/*************************************************
 *
 * RadDockNamespace.RadDock_HideDragHelper
 *
 *************************************************/
RadDockNamespace.RadDock_HideDragHelper = function()
{
	var dragHelper = RadDockNamespace.RadDock_DragHelper;
	
	if (dragHelper)
	{
		dragHelper.Hide();
		dragHelper.innerHTML = "";
	}
	
	RadDockNamespace.RadDock_DragHelper = null;
};

/*************************************************
 *
 * RadDockNamespace.RadDock_GetHoverdDockableObjectAction
 *
 *************************************************/
RadDockNamespace.RadDock_GetHoverdDockableObjectAction = function(eventArgs)
{
	var hoveredObject = null;
	var action = "";
	
	var srcElement = RadDockNamespace.GetEventSrcElement(eventArgs);
	
	switch (srcElement.className)
	{
		case "RadDockableObjectResizeable":
			action = "resize";
			break;
		
		case "RadDockableObjectTitleBar":
		case "RadDockableObjectTitle":
		case "RadDockableObjectHorizontalGrip":
		case "RadDockableObjectVerticalGrip":
			action = "move";
			break;
			
		default:
			return null;
	}
	
	hoveredObject = RadDockNamespace.RadDock_GetParentDockableObject(srcElement);
	
	if (!hoveredObject)
		return null;
		
	// pinned objects cannot be moved/resized
	if (hoveredObject.IsPinned())
		return null;
	
	// disabled object
	if (hoveredObject.DockingMode == RadDockNamespace.RadDockingModeFlags.Disabled)
		return null;
	
	// object in disabled zone cannot be dragged
	if (hoveredObject.ParentDockingZone 
		&& !hoveredObject.ParentDockingZone.DockEnabled)
	{
		return null;		
	}
	
	// disable resize for ...
	if ("resize" == action)
	{
		// ... collapsed objects
		if (!hoveredObject.IsExpanded())
			return null;
		
		// ... for this object resize is not allowed 
		if (!hoveredObject.CanResize())
			return null;
	
		// ... object is docked to a zone with fixed size
		var parentZone = hoveredObject.ParentDockingZone;
		if (parentZone && parentZone.FixedSizeMode)
			return null;
			
		action = hoveredObject.CalcResizeDir(eventArgs);
	}
	
	return	{ 
		hoveredObject : hoveredObject
		, action : action 
	};
};

/*************************************************
 *
 * RadDockNamespace.RadDock_GetParentDockableObject
 *
 *************************************************/
RadDockNamespace.RadDock_GetParentDockableObject = function(element)
{
	var node = element;
	while (node && node.parentNode)
	{
		switch (node.className)
		{
			case "RadDockableObjectResizeable":
			case "RadDockableObjectFixed":
				return (node.IsDockableObject ? node : null);
		}
		node = node.parentNode;
	}
	return null;
};

/*************************************************
 *
 * RadDockNamespace.RadDock_SetCursor
 *
 *************************************************/
RadDockNamespace.RadDock_SetCursor = function(cursor, element)
{
	if (!cursor)
		cursor = "";

	if (!element || !element.style)
	{
		element = document.body;
	}
	
	if (element.style.cursor != cursor)
	{
		element.style.cursor = cursor;
	}
};

/*************************************************
 *
 * RadDockNamespace.RadDock_ScrollDocumentToFit
 *
 *************************************************/
RadDockNamespace.RadDock_ScrollDocumentToFit = function(rect)
{
	// Vertical scroll	
	var cy = 0;
	var docTop = RadDockNamespace.GetScrollTop();
	var docBottom = (document.body.clientHeight + docTop);	
	if (rect.top < docTop)
	{
		cy = -((docTop - rect.top) + 1);
	}
	else if (rect.bottom > docBottom)
	{
		cy = (rect.bottom - docBottom) + 1;
	}
	
	// Horizontal scroll
	var cx = 0;
	var docLeft = RadDockNamespace.GetScrollLeft();
	var docRight = (document.body.clientWidth + docLeft);
	if (rect.left < docLeft)
	{
		cx = -((docLeft - rect.left) + 1);
	}
	else if (rect.right > docRight)
	{
		cx = (rect.right - docRight) + 1;
	}
	
	window.scrollBy(cx, cy);
};

/*************************************************
 *
 * RadDock_GetDockingZone / PUBLIC /
 *
 *************************************************/
RadDock_GetDockingZone = function(id)
{
	var el = document.getElementById(id);
	return (el.IsDockingZone ? el : null);
}

/*************************************************
 *
 * RadDock_GetDockableObject / PUBLIC /
 *
 *************************************************/
RadDock_GetDockableObject = function(id)
{
	var el = document.getElementById(id);
	if (el == null) return null;
	
	return (el.IsDockableObject ? el : null);
}

//BEGIN_ATLAS_NOTIFY
if (typeof(Sys) != "undefined")
{
    if (Sys.Application != null && Sys.Application.notifyScriptLoaded != null)
    {
        Sys.Application.notifyScriptLoaded();
    }
}
//END_ATLAS_NOTIFY