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

var RadDockableObjectGripFlags = 
{
	None		: 0
	, TitleBar	: 1
	, Top		: 2
	, Bottom	: 4
	, Left		: 8
	, Right		: 16
	, All		: 31	//	(TitleBar | Top | Bottom | Left | Right)
	, Auto		: 32
};

RadDockNamespace.RadDockingModeFlags =
{
	Disabled		: 0
	, AlwaysDock	: 1
	, NeverDock		: 2
	, Dockable		: 3	// (AlwaysDock | NeverDock)
};

RadDockNamespace.RadDockableObjectBehaviorFlags =
{
	None		: 0
	, Resize	: 1
	, Collapse	: 2
	, Close		: 4
	, Pin		: 8
	// Add more flags here
	, Resizable : 7		// (Collapse | Resize)
};

RadDockNamespace.RadDockableObjectState =
{
	Expanded : 1
	, Pinned : 2
	, Closed : 4
};

/*************************************************
 *
 * RadDock_InitDockableObject
 *
 *************************************************/
RadDockNamespace.InitDockableObject = function (element, dockableObjectInfo)
{
	RadDockNamespace.InitMoveableObject(element);
	Object.Extend(element, RadDockNamespace.RadDockableObject);
	Object.Extend(element, RadDockNamespace.RadEventHandlerList);
	
// set the overlay element
	var tagName  = (document.all) ? 'iframe':'span' ; // in FF we do not need overlay so use a plain simple span
	var overlayElement				= document.createElement(tagName);
	//overlayElement					= overlayElement.cloneNode(true); - PETIO: this is not needed
	overlayElement.src				= "javascript:'';";	
	overlayElement.frameBorder		= 0;	
	overlayElement.scrolling		= "no";		
	overlayElement.style.filter	= "progid:DXImageTransform.Microsoft.Alpha(opacity=0)";
	overlayElement.style.overflow	= "hidden";		

	overlayElement.style.display	= "inline";  
    //Petio: this fix the problem with the initial space. "jump effect"
    //Petio: Maybe I Should  remove the othre two setOverlayInitialPosition invokes 
    setOverlayInitialPosition(); 
  
	element.Overlay = document.body.insertBefore(overlayElement, document.body.firstChild);
   
	
	var i = 0;
	
	/*** Dockable object Properties ***/	
	element.IsDockingEnabled = dockableObjectInfo[i++];
	element.ServerID = dockableObjectInfo[i++];
	element.Behavior = dockableObjectInfo[i++];
	element.DockingMode = dockableObjectInfo[i++];
	element.AllowedDockingZoneTypes = dockableObjectInfo[i++];
	element.AllowedDockingZones = dockableObjectInfo[i++];
	
	var parentDockingZoneID = dockableObjectInfo[i++];
	
	element.ParentDockingZone = parentDockingZoneID ? 
		document.getElementById(parentDockingZoneID) 
		: null;
	
	element.FloatingObjectEnabledGrips = dockableObjectInfo[i++];
	element.DockedObjectEnabledGrips = dockableObjectInfo[i++];
	
	var arrGrips = dockableObjectInfo[i++];
	
	element.ClientRow = document.getElementById(dockableObjectInfo[i++]);
	element.controlState = dockableObjectInfo[i++];
	element.ExpandedHeight = dockableObjectInfo[i++];	
	
	var arrCommands = dockableObjectInfo[i++];
	var hiddenInputID = dockableObjectInfo[i++];
	
	// deserialize json string
	element.clientEventHandlers = eval('(' + dockableObjectInfo[i++] + ')');
	
	/*** Dockable object Properties ***/
	
	element.HiddenInput = document.getElementById(hiddenInputID);
		
	element.InitGrips(arrGrips);
	element.InitCommands(arrCommands);	
	element.SetDisplayStyle();

	function setOverlayInitialPosition() 
	{
		// set th eoverlay position
		overlayElement.style.position	= "absolute";
		if (element.style.position == 'absolute')
		{
			var dockRect = RadGetElementRect(element);
			overlayElement.style.left   = dockRect.left;
			overlayElement.style.top    = dockRect.top;
			overlayElement.style.width	= dockRect.width;
			overlayElement.style.height	= dockRect.height;
			RadDockNamespace.FixIeHeight(overlayElement);
		} 
		else 
		{
			overlayElement.style.left      = -10000;
			overlayElement.style.top       = -10000;
		}
	}

	// damn callback
	if (!document.readyState || "complete" == document.readyState)
	{
		RadDockNamespace.FixIeHeight(element); 
		element.SaveState();
		setOverlayInitialPosition();
	}
	else if (window.attachEvent)
	{
		var funcSaveState = function()
		{
			RadDockNamespace.FixIeHeight(element); 
			element.SaveState();
			setOverlayInitialPosition();
		};		
//		alert('attaching saveState for element[' + element.id + ']')
		window.attachEvent("onload", funcSaveState);
	}
	
	element.ClientRow.cells[0].style.height = document.all ? "100%" : "";	//BUG: under Moz object extends its height on expand.

	
	// set some properties which can not be set from code behind
	// because of xHTML compliancy
	var elementIds = ['TitlebarCell','TitleCell','HorizontalGripCell1','HorizontalGripCell2','VerticalGripCell1','VerticalGripCell2'];
	for (var i=0;i < elementIds.length; i ++) {

		var _id = elementIds[i];
		var _o = document.getElementById(element.id + '_' + _id);
		if (_o != null) {
			RadDockNamespace.AttachEvent(_o, "dragstart", new Function("return false"));			
			_o.setAttribute("unselectable", "on");
		}
		
	}
	
	var clientEvents = ["DockStateChanged", "Dock", "UnDock", "DragStart", "Drag", "Drop", "DragEnd","ResizeStart","ResizeEnd"];
	
	for (var i=0; i < clientEvents.length; i ++) {
		element.AddEventHandler( clientEvents[i], element.ExecuteClientEventHandler);	
	}
	
	if (element.IsPinned())
	{
		if (!element.IsClosed() && !element.IsDocked())
		{
			element.Pin();
		}
		else
		{
			element.needPin = true;
		}
	}

};

RadDockNamespace.RadDockableObject = {
	
	IsDockableObject : true,

	GetState : function (index)
	{
		return ((this.controlState & index) > 0);
	},

	SetState : function (index, value)
	{
		var old = this.controlState;
		if (value)
		{
			this.controlState |= index;
		}
		else
		{
			this.controlState &= ~index;
		}
		
		if (old != this.controlState)
		{
			this.UpdateCommandsState();
			this.SaveState();
		}
	},
	
	UpdateState : function()
	{
	    if(!this.IsStaticObject)
	    {
	        this.UpdateCommandsState();
		    this.SaveState();
		    this.FireEvent("DockStateChanged", { docked : this.IsDocked() }, this);
		}
	},


	UpdateCommandsState : function ()
	{
		var isDocked = this.IsDocked();
		
		// expand/collapse
		var expanded = this.GetState(RadDockNamespace.RadDockableObjectState.Expanded);
		var cmdCollapse = this.GetCommandByName("Collapse");
		if (cmdCollapse)
		{
			cmdCollapse.Enable(expanded);
		}
		
		var cmdExpand = this.GetCommandByName("Expand");
		if (cmdExpand)
		{
			cmdExpand.Enable(!expanded);
		}
		
				var cmdUp = this.GetCommandByName("Up");
		if(cmdUp && this.ParentDockingZone)
		{
		   cmdUp.Enable(this.ParentDockingZone.GetPosition(this)!=0);
		}
		
		var cmdDown = this.GetCommandByName("Down");
		if(cmdDown && this.ParentDockingZone)
		{
		   cmdDown.Enable(this.ParentDockingZone.GetPosition(this) < 
		                 (this.ParentDockingZone.GetDockedObjects().length - 1));
		}
		
		// pin/unpin
		var pinned = this.GetState(RadDockNamespace.RadDockableObjectState.Pinned);
		cmd = this.GetCommandByName("Unpin");
		if (cmd)
		{
			cmd.Enable(!isDocked && pinned);
		}
		
		cmd = this.GetCommandByName("Pin");
		if (cmd)
		{
			cmd.Enable(!isDocked && !pinned);
		}
		
		// close
		//var closed = this.GetState(RadDockNamespace.RadDockableObjectState.Closed);
		cmd = this.GetCommandByName("Close");
		if (cmd)
		{
			cmd.Enable(true);	//always visible
		}
	},
	
	IsExpanded : function ()
	{
		return this.GetState(RadDockNamespace.RadDockableObjectState.Expanded);
	},

	IsPinned : function ()
	{
		return this.GetState(RadDockNamespace.RadDockableObjectState.Pinned);
	},

	IsClosed : function ()
	{
		return this.GetState(RadDockNamespace.RadDockableObjectState.Closed);
	},

	OnShowHide : function ()
	{
		var isVisible = this.IsVisible();
		this.SetState(RadDockNamespace.RadDockableObjectState.Closed, !isVisible);
		
		if (isVisible)
		{
			this.SetDisplayStyle();
		}
		
		if (isVisible && this.needPin)
		{
			this.Pin();
			this.needPin = null;
		}
	},

	Dispose : function ()
	{
		//Petio: remove the iframes for overlay:Resolves the problem when
		// OnAjax they stays attached to the body IFRAME		
		if(this.Overlay)
		    this.Overlay.parentNode.removeChild(this.Overlay);
		this.Overlay = null;
		
		if (null != this.Commands)
		{
			for (var i = 0; i < this.Commands.length; i++)
			{
				this.Commands[i] = null;
			}
		}
		this.Commands = null;
		
		this.ParentDockingZone = null;
		
		this.TitleBar = null;
		this.TopGrip = null;
		this.BottomGrip = null;
		this.LeftGrip = null;
		this.RightGrip = null;
		this.ClientRow = null;
		this.Manager = null;
		
		this.DockedObjectEnabledGrips = null;
		this.FloatingObjectEnabledGrips = null;	
	},

	SaveState : function ()
	{
		//alert('Save State [' +this.id + ']')
		var values = new Array();
		
		var width = (this.IsVisible() ? this.offsetWidth : this.__offsetWidth);
		var height = (this.IsVisible() ? this.offsetHeight : this.__offsetHeight);

		values[values.length] = this.style.top;
		values[values.length] = this.style.left;
		values[values.length] = (width + "px");
		values[values.length] = (this.IsExpanded() ? (height + "px") : this.ExpandedHeight);
		values[values.length] = this.controlState;
		values[values.length] = this.style.zIndex;
		values[values.length] = (this.ParentDockingZone ? this.ParentDockingZone.ServerID : "");

		var cmdStateArray = new Array();	
		var commands = this.Commands;
		var cmd;
		for (var i = 0; i < commands.length; i++)
		{
			cmd = commands[i];
			
			var items = new Array();
			items[items.length] = cmd.Name;
			items[items.length] = cmd.IsEnabled();
			items[items.length] = true;
			
			cmdStateArray[cmdStateArray.length] = items.join("!");
		}
		
		values[values.length] = cmdStateArray.join("|");
			
		this.HiddenInput.value = values.join(",");
	},

	//////////////////////////////////////////////////
	// Docking

	IsDocked : function ()
	{ 
		return ((this.DockingMode & RadDockNamespace.RadDockingModeFlags.AlwaysDock) > 0
					&& this.ParentDockingZone != null); 
	},

	IsFloating : function ()
	{
		return ((this.DockingMode & RadDockNamespace.RadDockingModeFlags.NeverDock) > 0 
					&& this.ParentDockingZone == null);
	},

	CanFloat : function ()
	{
		return ((this.DockingMode & RadDockNamespace.RadDockingModeFlags.NeverDock) > 0);
	},

	CanResize : function ()
	{
		return ((this.Behavior & RadDockNamespace.RadDockableObjectBehaviorFlags.Resize) > 0);
	},

	CanDockTo : function (dockingZone)
	{
		if (!dockingZone)
			return false;
			
		if (0 == (this.DockingMode & RadDockNamespace.RadDockingModeFlags.AlwaysDock))
			return false;
			
		if (RadDockingZoneTypeFlags.Custom == this.AllowedDockingZoneTypes)
		{
			var dockingZoneID = dockingZone.id;
			var zones = this.AllowedDockingZones;
			for (var i = 0; i < zones.length; i++)
			{
				if (dockingZoneID == zones[i])
					return true;
			}
			return false;
		}
		else
		{
			return ((this.AllowedDockingZoneTypes & dockingZone.Type) > 0);
		}
	},

	DockTo : function (dockingZone, position)
	{
		if (!dockingZone)
			return;
			
		if (!this.CanDockTo(dockingZone))
			return;
			
		dockingZone.Dock(this);
		this.Docked();
	},

	Undock : function ()
	{
		this.ParentDockingZone = null;
		
		this.parentNode.removeChild(this);
		
		var parentNode = document.getElementsByTagName("FORM")[0];
		parentNode = parentNode ? parentNode : document.body;
		parentNode.appendChild(this);
		
		this.BringToFront();
		
		//this.Undocked();
	},

	Docked : function (fireEvent)
	{
		this.SetDisplayStyle();
		this.SetGripsState();	
		this.SaveState();
		
		// when docked hide pin/unpin
		var cmd = this.GetCommandByName("Pin");
		if (cmd) 
		{ 
			cmd.Enable(false); 
		}
		
		cmd = this.GetCommandByName("Unpin");
		if (cmd) 
		{ 
			cmd.Enable(false); 
		}
		
		if (false != fireEvent)
		{
			this.FireEvent("DockStateChanged", { docked : true }, this);
			this.FireEvent("Dock",'', this);
		}
	},

	Undocked : function ()
	{
		this.SetDisplayStyle();
		this.SetGripsState();
		
		// when undocked show pin/unpin according to the pinned state
		var cmd = this.GetCommandByName("Pin");
		if (cmd) 
		{ 
			cmd.Enable(!this.IsPinned());
		}
		
		cmd = this.GetCommandByName("Unpin");
		if (cmd) 
		{ 
			cmd.Enable(this.IsPinned());
		}

		if (this.FloatingWidth || this.FloatingHeigth)
		{
			this.SetSize(this.FloatingWidth, this.FloatingHeigth);
			
			this.FloatingWidth = null;
			this.FloatingHeigth = null;
		}
			
		this.SaveState();
		
		this.FireEvent("DockStateChanged", { docked : false }, this);
		this.FireEvent("UnDock",'', this);
		
	},

	SetDisplayStyle : function ()
	{
		if (this.IsClosed())
			return;

		if (!this.IsDockingEnabled)
		{
			if (!document.all)
			{
				this.style.setProperty("clear", "both", "");
			}
			return;
		}
		
		if (this.IsDocked())
		{
			this.style.position = "";
			this.style.display  = "";
			if (this.Overlay) this.Overlay.style.display = "none";

			if ((this.ParentDockingZone.Type & RadDockingZoneTypeFlags.Horizontal) > 0) {
				
				this.style.display = "inline";
				this.SetFloatLeft();
			}
			else
			{
				this.RemoveFloatLeft();
			}
		}
		else
		{
			this.style.position = "absolute";
			if (this.Overlay) this.Overlay.style.display = "";

			if (document.all)
			{
				this.style.display = "";
			}
			else
			{
				this.style.setProperty("clear", "both", "");
			}
			this.RemoveFloatLeft();
		}
	},

	//////////////////////////////////////////////////
	// Grips

	InitGrips : function (arrGripIDs)
	{
		this.TitleBar = null;
		this.TopGrip = null;
		this.BottomGrip = null;
		this.LeftGrip = null;
		this.RightGrip = null;
		
		if (!arrGripIDs || !arrGripIDs.length)
			return;
		
		var gripID = 0;
		
		this.TitleBar = document.getElementById(arrGripIDs[gripID++]);
		this.TopGrip = document.getElementById(arrGripIDs[gripID++]);
		this.BottomGrip = document.getElementById(arrGripIDs[gripID++]);
		this.LeftGrip = document.getElementById(arrGripIDs[gripID++]);
		this.RightGrip = document.getElementById(arrGripIDs[gripID++]);
	},

	SetGripVisible : function (grip, visible)
	{
		if (grip)
		{
			grip.style.display = (visible ? "" : "none");
		}
	},

	IsGripVisible : function (grip)
	{
		return (grip.style.display != "none");
	},

	SetGripsState : function ()
	{
		this.SetGripVisible(this.TitleBar, this.CalcGripVisibleState(RadDockableObjectGripFlags.TitleBar));
		this.SetGripVisible(this.TopGrip, this.CalcGripVisibleState(RadDockableObjectGripFlags.Top));
		this.SetGripVisible(this.BottomGrip, this.CalcGripVisibleState(RadDockableObjectGripFlags.Bottom));
		this.SetGripVisible(this.LeftGrip, this.CalcGripVisibleState(RadDockableObjectGripFlags.Left));
		this.SetGripVisible(this.RightGrip, this.CalcGripVisibleState(RadDockableObjectGripFlags.Right));
	},

	CalcGripVisibleState : function (gripType)
	{
		var grips;
		if (this.IsDocked())
		{
			// docked object		
			grips = this.DockedObjectEnabledGrips;
			if (RadDockableObjectGripFlags.Auto == grips)
			{
				switch (this.ParentDockingZone.Type)
				{
					case RadDockingZoneTypeFlags.Top:
					case RadDockingZoneTypeFlags.Bottom:
					case RadDockingZoneTypeFlags.Left:
					case RadDockingZoneTypeFlags.Right:
						return (gripType == RadDockableObjectGripFlags.TitleBar);
					case RadDockingZoneTypeFlags.Horizontal:
						return (gripType == RadDockableObjectGripFlags.Left);
					case RadDockingZoneTypeFlags.Vertical:
						return (gripType == RadDockableObjectGripFlags.Top);
					default:
						return false;
				}	
			}
		}
		else
		{
			// floating object
			grips = this.FloatingObjectEnabledGrips;
			if (RadDockableObjectGripFlags.Auto == grips)
			{
				return (gripType == RadDockableObjectGripFlags.TitleBar);
			}
		}
		
		return ((grips & gripType) > 0);
	},

	CanCollapse : function ()
	{
		return ((this.Behavior & RadDockNamespace.RadDockableObjectBehaviorFlags.Collapse) > 0);
	},

	Expand : function (expanding)
	{
		if (null == expanding)
		{
			expanding = true;
		}
		
		if (expanding == this.IsExpanded())
		{
			return;
		}
		
		if (!expanding && this.IsExpanded())
		{
			this.ExpandedHeight = (this.offsetHeight + "px");
			
			
		} else {
			if (document.all) {

				/******** hack DK1-5813 ***********/
				// keep the old props
				var _oldVal_1 = this.style.height;
				var _oldVal_2 = this.ClientRow.style.display;
				
				var clientRow = this.ClientRow;
				var cell = clientRow.cells[0];
				
				var _oldVal_3 = cell.firstChild.style.display;
				var _oldVal_4 = cell.firstChild.style.height;
				var _oldVal_5 = cell.firstChild.style["float"];
				
				/**
					Hack:
					Expand the object and get what will be the difference between the real height and the needed height
					Then correct the wanted height in order to achieve the real height correct in xHTML mode
				*/
				this.ClientRow.style.display = "";
				
				cell.firstChild.style.display = "";
				cell.firstChild.style.height = "100%";

				this.style.height = parseInt(this.ExpandedHeight) + "px";
				
				var diff = RadDockNamespace.FixIeHeight(this, true);	

				this.ExpandedHeight = parseInt(this.ExpandedHeight) - diff;
				
				// restore the old props
				this.style.height				= _oldVal_1;
				this.ClientRow.style.display	= _oldVal_2;				
				cell.firstChild.style.display	= _oldVal_3;
				cell.firstChild.style.height	= _oldVal_4;
				cell.firstChild.style["float"]  = _oldVal_5;
			}
		}

		this.SetState(RadDockNamespace.RadDockableObjectState.Expanded, expanding);
			
		if (this.Manager.UseEffects)
		{
			var clientRow = this.ClientRow;
			var cell = clientRow.cells[0];		
			var __this = this;
			
			var beforeStart = function()
			{	
				cell.firstChild.style.display = "none";
				clientRow.style.display = "";
			};
			
			var afterFinish = function()
			{

				if (expanding)
				{
					cell.firstChild.style.display = "";
					cell.firstChild.style.height = "100%";
				}
				clientRow.style.display = expanding ? "" : "none";	
				
				//RadDockNamespace.FixIeHeight(__this);
				__this.SaveState();
			};
			
			var rc = this.GetRect();
			
			// When an object is wider/higher that the style.width/style.height
			// because of the content, a parasitic shrinking is performed and 
			// this needs to preset the style.width/height to the real size of the object		

		//	this.style.width = rc.width + "px";
		//	this.style.height = rc.height + "px";

			new RadEffect.Resize(
				{
					object : this
					, height : expanding ? this.ExpandedHeight : this.GetRect(this.TitleBar).height
					, width : rc.width
					, beforeStart : beforeStart
					, afterFinish : afterFinish
					, duration : 1/3
				}
			);	
		}	
		else
		{

			this.ClientRow.style.display = expanding ? "" : "none";	
			this.style.height = expanding ? (parseInt(this.ExpandedHeight) + "px") : "1px";

			
			if (this.Overlay)
			{
				this.Overlay.style.height = this.style.height;
			}
			this.SaveState();
		}
		this.FireEvent("DockStateChanged", { docked : this.IsDocked() }, this);

	},

	Collapse : function ()
	{
		this.Expand(false);
	},

	Pin : function ()
	{
		// NOTE: setInterval() is used with Mozilla too 
		// (instead of style.position="fixed") because to 
		// use the timer to make SaveState().
		
		var refThis = this;
		
		var offsetLeft = 0;
		var offsetTop = 0;	

		var bFirstTimeCalculation = true;
		var timerFunc = function()
		{
			if (bFirstTimeCalculation) {
				
				var rc = refThis.GetRect();
				
				offsetLeft = rc.left// - document.body.scrollLeft);
				offsetTop = rc.top// - document.body.scrollTop);	

				bFirstTimeCalculation = false;
			}

			refThis.MoveTo(RadDockNamespace.GetScrollLeft() + offsetLeft, RadDockNamespace.GetScrollTop() + offsetTop);
			refThis.SaveState();
		};
		
		this.timerID = setInterval(timerFunc, 10);	

		this.SetState(RadDockNamespace.RadDockableObjectState.Pinned, true);
	},

	Unpin : function ()
	{
		clearInterval(this.timerID);
		
		this.timerID = null;	
		this.SetState(RadDockNamespace.RadDockableObjectState.Pinned, false);
	},

	InitCommands : function (arrCommandInfo)
	{
		this.Commands = new Array();
		this.CommandHandlerList = new Array();
		
		// Init commands
		var cmdInfo, cmdElement, id;
		for (var i = 0; i < arrCommandInfo.length; i++)
		{
			cmdInfo = arrCommandInfo[i];
			id = cmdInfo[0];
			cmdElement = document.getElementById(id);
			
			if (cmdElement)
			{
				cmdInfo.splice(0, 1);
				RadDockNamespace.InitDockableObjectCommand(cmdElement, this, cmdInfo);
				
				this.Commands[this.Commands.length] = cmdElement;
				
				var cmdHandler = RadDockNamespace.CommandHandlerList[cmdElement.Name];
				if (cmdHandler && !cmdElement.OnCommand)
				{
					cmdElement.OnCommand = cmdHandler;
				}
			}
		}
	},

	Up : function()
	{
	    var p = this.ParentDockingZone;
        if (p)
        {
            var pos = p.GetPosition(this);
            p.SetAtPosition(this, pos - 1);
            if(pos > 0)
            {
                var arr = p.GetDockedObjects();
                if(pos < arr.length)
                    arr[pos].UpdateCommandsState();
            }

		    this.UpdateState();
		}
	},
	
	Down : function()
	{
	    var p = this.ParentDockingZone;
        if (p)
        {
            var pos = p.GetPosition(this);
            p.SetAtPosition(this, pos + 1);
            
            var arr = p.GetDockedObjects();
            if(pos < arr.length)
               arr[pos].UpdateCommandsState();
            
		    this.UpdateState();
		}
	},

	GetCommandByName : function (commandName)
	{
		var cmd;
		for (var i = 0; i < this.Commands.length; i++)
		{
			cmd = this.Commands[i];
			if (cmd && cmd.Name == commandName)
			{
				return cmd;
			}
		}
		return null;
	},

	// Expand/Collapse
	OnExpand : function (dockableObject, command)
	{
		dockableObject.Expand();
	},

	OnCollapse : function (dockableObject, command)
	{
		dockableObject.Collapse();
	},

	OnUp : function(dockableObject, command)
	{
	    dockableObject.Up();
	},
	
	OnDown : function(dockableObject, command)
	{
	    dockableObject.Down();
	},

	// Pin/Unpin
	OnPin : function (dockableObject, command)
	{
		dockableObject.Pin();
	},

	OnUnpin : function (dockableObject, command)
	{
		dockableObject.Unpin();
	},

	// Close
	OnClose : function (dockableObject, command)
	{
		dockableObject.Hide();
	},
	
	
	// --------------- Client API - events --------------//

	// obj -> the dockable object element
	ExecuteClientEventHandler : function (obj, eventArgs) {
		
		// call the appropriate handler by a naming convention
		var eventName = eventArgs.eventName;
		try {
			
			obj['On' + eventName](obj, eventArgs);
		} catch (e) {
			//alert(e.description)
		}
	},

	OnDock : function (sender, eventArgs) {
		if (this.clientEventHandlers["OnDock"]) {
			eval(this.clientEventHandlers["OnDock"])(sender, eventArgs);
		}
	},
	
	OnUnDock : function (sender, eventArgs) {
		if (this.clientEventHandlers["OnUnDock"]) {
			eval(this.clientEventHandlers["OnUnDock"])(sender, eventArgs);
		}
	},

	OnDragEnd : function (sender, eventArgs) {
		if (this.clientEventHandlers["OnDragEnd"]) {
			eval(this.clientEventHandlers["OnDragEnd"])(sender, eventArgs);
		}
	},
	
	OnDockStateChanged : function (sender, eventArgs) {
		if (this.clientEventHandlers["OnDockStateChanged"]) {
			eval(this.clientEventHandlers["OnDockStateChanged"])(sender, eventArgs);
		}
	},
	
	OnDrag : function (sender, eventArgs) {
		if (this.clientEventHandlers["OnDrag"]) {
			eval(this.clientEventHandlers["OnDrag"])(sender, eventArgs);
		}
	},
	
	OnDragStart : function (sender, eventArgs) {
		if (this.clientEventHandlers["OnDragStart"]) {
			eval(this.clientEventHandlers["OnDragStart"])(sender, eventArgs);
		}
	},
	
	OnDrop : function (sender, eventArgs) {
		if (this.clientEventHandlers["OnDrop"]) {
			eval(this.clientEventHandlers["OnDrop"])(sender, eventArgs);
		}
	},
	OnResizeStart : function (sender, eventArgs) {
		if (this.clientEventHandlers["OnResizeStart"]) {
			eval(this.clientEventHandlers["OnResizeStart"])(sender, eventArgs);
		}
	},
	OnResizeEnd : function (sender, eventArgs) {
		if (this.clientEventHandlers["OnResizeEnd"]) {
			eval(this.clientEventHandlers["OnResizeEnd"])(sender, eventArgs);
		}
	},
	SetFloatLeft : function()
	{
		this.style.styleFloat = "left";
	},
	
	RemoveFloatLeft : function()
	{
		this.style.styleFloat = "";
		if (this.style.removeAttribute)
		{
			this.style.removeAttribute("styleFloat");
		}
	}
};

//////////////////////////////////////////////////
// Commands
RadDockNamespace.CommandHandlerList = [];
RadDockNamespace.CommandHandlerList["Expand"] = RadDockNamespace.RadDockableObject.OnExpand;
RadDockNamespace.CommandHandlerList["Collapse"] = RadDockNamespace.RadDockableObject.OnCollapse;
RadDockNamespace.CommandHandlerList["Close"] = RadDockNamespace.RadDockableObject.OnClose;
RadDockNamespace.CommandHandlerList["Pin"] = RadDockNamespace.RadDockableObject.OnPin;
RadDockNamespace.CommandHandlerList["Unpin"] = RadDockNamespace.RadDockableObject.OnUnpin;
RadDockNamespace.CommandHandlerList["Up"] = RadDockNamespace.RadDockableObject.OnUp;
RadDockNamespace.CommandHandlerList["Down"] = RadDockNamespace.RadDockableObject.OnDown;

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