Type.registerNamespace("Telerik.Web.UI");

Telerik.Web.UI.TabStripOrientation = function () {}
Telerik.Web.UI.TabStripOrientation.prototype = {
	HorizontalTop : 0,
	HorizontalBottom : 1,
	VerticalRight : 2,
	VerticalLeft : 3
}

Telerik.Web.UI.TabStripOrientation.isHorizontal = function (value)
{
	return value == Telerik.Web.UI.TabStripOrientation.HorizontalTop || 
		value == Telerik.Web.UI.TabStripOrientation.HorizontalBottom;
}

Telerik.Web.UI.TabStripOrientation.isVertical = function (value)
{
	return !Telerik.Web.UI.TabStripOrientation.isHorizontal(value);
}

Telerik.Web.UI.TabStripOrientation.registerEnum("Telerik.Web.UI.TabStripOrientation");

Telerik.Web.UI.TabStripAlign = function () {}
Telerik.Web.UI.TabStripAlign.prototype = {
	Left : 0,
	Center : 1,
	Right : 2,
	Justify : 3
}
Telerik.Web.UI.TabStripAlign.registerEnum("Telerik.Web.UI.TabStripAlign");

Telerik.Web.UI.TabStripScrollButtonsPosition = function () {}
Telerik.Web.UI.TabStripScrollButtonsPosition.prototype = {
	Left : 0,
	Middle : 1,
	Right : 2
}
Telerik.Web.UI.TabStripScrollButtonsPosition.registerEnum("Telerik.Web.UI.TabStripScrollButtonsPosition");

Telerik.Web.UI.RadTabStripCancelEventArgs = function (tab, domEvent)
{
	Telerik.Web.UI.RadTabStripCancelEventArgs.initializeBase(this);
	this._tab = tab;
	this._domEvent = domEvent;
}

Telerik.Web.UI.RadTabStripCancelEventArgs.prototype = 
{
	get_tab : function ()
	{
		return this._tab;
	},
	
	get_domEvent : function ()
	{
		return this._domEvent;
	}
}

Telerik.Web.UI.RadTabStripCancelEventArgs.registerClass('Telerik.Web.UI.RadTabStripCancelEventArgs', Sys.CancelEventArgs);

Telerik.Web.UI.RadTabStripEventArgs = function (tab, domEvent)
{
	Telerik.Web.UI.RadTabStripEventArgs.initializeBase(this);
	this._tab = tab;
	this._domEvent = domEvent;
}

Telerik.Web.UI.RadTabStripEventArgs.prototype = 
{
	get_tab : function ()
	{
		return this._tab;
	},
	
	get_domEvent : function ()
	{
		return this._domEvent;
	}
}

Telerik.Web.UI.RadTabStripEventArgs.registerClass('Telerik.Web.UI.RadTabStripEventArgs', Sys.EventArgs);

Telerik.Web.UI.RadTabStrip = function (element)
{
	Telerik.Web.UI.RadTabStrip.initializeBase(this, [element]);
	
	this._childTypeName = "Telerik.Web.UI.RadTab";
	
	this._orientation = Telerik.Web.UI.TabStripOrientation.HorizontalTop;
	this._align = Telerik.Web.UI.TabStripAlign.Left;
	this._selectedIndex = -1;
	this._selectedIndexes = [];
	this._selectedIndexesJson = "[]";
	this._logEntriesJson = "[]";
	this._scrollState = {};
	this._scrollStateJson = "{}";
	
	this._multiPageID = null;
	
	this._causesValidation = true;
	this._validationGroup = "";
	this._postBackReference = null;
	this._scrollChildren = false;
	this._scrollButtonsPosition = Telerik.Web.UI.TabStripScrollButtonsPosition.Right;
	this._perTabScrolling = false;
	this._reorderTabsOnSelect = false;
	this._skin = null;
}

Telerik.Web.UI.RadTabStrip._getTabGroups = function (listElement, sizeProperty)
{
	var groups = [];
	var currentGroup = [];
	currentGroup.size = 0;
	Array.add(groups, currentGroup);
	
	var listItems = $telerik.getChildrenByTagName(listElement, "li");
	for (var i = 0; i < listItems.length; i++)
	{
		if (listItems[i].className == "rtsBreak")
		{
			currentGroup = [];
			currentGroup.size = 0;
			Array.add(groups, currentGroup);
			continue;
		}
		
		currentGroup.size += listItems[i][sizeProperty];
		Array.add(currentGroup, listItems[i]);
	}
	
	return groups;
}

Telerik.Web.UI.RadTabStrip._reorder = function (clientId, selectedIndex)
{
	var tabStripElement = $get(clientId);
	if (!tabStripElement) return;
	var levelElement = $telerik.getChildByClassName(tabStripElement, "rtsLevel1");
	if (!levelElement) return;
	
	var listElement = $telerik.getFirstChildByTagName(levelElement, "ul");
	if (!listElement) return;
	var listItems = $telerik.getChildrenByClassName(listElement, "rtsLI");
	var tabElement = listItems[selectedIndex];
	if (!tabElement) return;
	
	Telerik.Web.UI.RadTabStrip._reorderTabs(listElement, tabElement);
}

Telerik.Web.UI.RadTabStrip._reorderTabs = function(listElement, tabElement)
{
	var groups = Telerik.Web.UI.RadTabStrip._getTabGroups(listElement);
	if (groups.length < 2) return;
	
	var lastGroup = groups[groups.length - 1];
	var currentGroup = null;
	
	for (var i = 0; i < groups.length; i++)
	{
		if (Array.indexOf(groups[i], tabElement) > -1)
		{
			currentGroup = groups[i];
			break;
		}
	}
	
	if (!currentGroup || currentGroup == lastGroup) return;
	
	for (var i = 0; i < lastGroup.length; i++)
		listElement.insertBefore(lastGroup[i], currentGroup[0]);
	
	for (var i = 0; i < currentGroup.length; i++)
		listElement.appendChild(currentGroup[i]);
}

Telerik.Web.UI.RadTabStrip._align = function (elementId, alignment, orientation)
{
	var tabStripElement = $get(elementId);
	
	if (alignment != Telerik.Web.UI.TabStripAlign.Justify && Telerik.Web.UI.TabStripOrientation.isHorizontal(orientation)) 
		return;
	
	if (alignment == Telerik.Web.UI.TabStripAlign.Left || tabStripElement._aligned) return;
	
	if (alignment == Telerik.Web.UI.TabStripAlign.Justify)
	{
		Telerik.Web.UI.RadTabStrip._justifyTabStrip(tabStripElement, orientation);
		return;
	}
	
	Telerik.Web.UI.RadTabStrip._verticalAlign(tabStripElement, alignment, orientation);
}

Telerik.Web.UI.RadTabStrip._justifyTabStrip = function (tabStripElement, orientation)
{
	var levelElements = $telerik.getChildrenByTagName(tabStripElement, "div");
	if (levelElements.length < 1) return;
	
	for (var level = 0; level < levelElements.length; level ++)
	{
		var levelElement = levelElements[level];
		var childListElements = $telerik.getChildrenByTagName(levelElement, "ul");
		if (childListElements.length < 1) return;
	
		for (var i = 0; i < childListElements.length; i++)
			Telerik.Web.UI.RadTabStrip._justify(childListElements[i], orientation);
	}
}

Telerik.Web.UI.RadTabStrip._justify = function (childListElement, orientation)
{
	var sizeProperty = "offsetWidth";
	var setSize = function (element, size) { 
		element.style.width = size + "px"; 
	};
	
	if (Telerik.Web.UI.TabStripOrientation.isVertical(orientation))
	{
		sizeProperty = "offsetHeight";
		setSize = function (element, size) { 
			element.firstChild.firstChild.firstChild.style.height = size + "px";
			var diff = element.offsetHeight - size;
			if (diff > 0)
				element.firstChild.firstChild.firstChild.style.height = size - diff + "px";
		};
	}
	
	Telerik.Web.UI.RadTabStrip._justifyListElement(childListElement, sizeProperty, setSize);
}

Telerik.Web.UI.RadTabStrip._justifyListElement = function (childListElement, sizeProperty, setSize)
{
	var targetSize = childListElement.parentNode[sizeProperty];
	if (targetSize <= 0) return;
	var tabGroups = Telerik.Web.UI.RadTabStrip._getTabGroups(childListElement, sizeProperty);
	
	for (var tabGroupIndex = 0; tabGroupIndex < tabGroups.length; tabGroupIndex++)
	{
		var currentGroup = tabGroups[tabGroupIndex]
		if (currentGroup.size <= 0) continue;
		var listItemRatios = [];
	
		for (var i = 0; i < currentGroup.length; i++)
			listItemRatios[i] = currentGroup[i][sizeProperty] / currentGroup.size;
	
		var accumulatedSize = 0;
		var i = 0;
		for (; i < currentGroup.length - 1; i++)
		{
			var size = Math.round(targetSize * listItemRatios[i]);
			setSize(currentGroup[i], size);
			accumulatedSize += size;
		}
		setSize(currentGroup[i], targetSize - accumulatedSize);
	}
}

Telerik.Web.UI.RadTabStrip._verticalAlign = function (tabStripElement, alignment, orientation)
{
	var levelElement = $telerik.getChildByClassName(tabStripElement, "rtsLevel1");
	if (!levelElement) return;
	
	var childListElement = $telerik.getChildByClassName(levelElement, "rtsUL");
	if (!childListElement) return;
	
	var marginTop = 0;
	
	if (alignment == Telerik.Web.UI.TabStripAlign.Center)
		marginTop = (levelElement.offsetHeight - childListElement.offsetHeight) / 2;
	
	if (alignment == Telerik.Web.UI.TabStripAlign.Right)
		marginTop = levelElement.offsetHeight - childListElement.offsetHeight;
	
	if (marginTop > 0)
	{
		childListElement.style.marginTop = marginTop + "px";
		tabStripElement._aligned = true;
	}
}
Telerik.Web.UI.RadTabStrip._createChildControls = function(owner, tabs)
{
	var data = owner.get_tabData();
	if (!data) return;
	
	var childElements = $telerik.getChildrenByClassName(owner.get_childListElement(), "rtsLI");
	
	for (var i = 0; i < data.length; i++)
	{
		var tab = new Telerik.Web.UI.RadTab();
		tabs.add(tab);
		
		var elementIndex = i;
		
		if (typeof(data[i].index) !== "undefined")
			elementIndex = data[i].index;
			
		tab._initialize(data[i], childElements[elementIndex]);
	}
}

Telerik.Web.UI.RadTabStrip.prototype = {
	/***** Private methods *****/
	_initScrolling : function ()
	{
		var tabContainer = this;
		
		while (tabContainer)
		{
			if (this._tabContainerRequiresScrolling(tabContainer))
			{
				if (tabContainer._scroller)
				{
					tabContainer._scroller._showArrows();
					var scrollableSize = this._getScrollableSize(tabContainer);
					var diff = scrollableSize - tabContainer._scroller._currentPosition;
					
					if (diff < 0)
						tabContainer._scroller._scrollTo(scrollableSize);
						
					tabContainer._scroller.setScrollingLimits(0, scrollableSize);
				}
				else
				{
					this._initScrollingForTabContainer(tabContainer);
				}
			}
			else
			{
				if (tabContainer._scroller)
				{
					tabContainer._scroller._hideArrows();
					tabContainer._scroller._scrollTo(0);
				}
			}
			tabContainer = tabContainer.get_selectedTab();
		}
		this.updateClientState();
	},
	
	_initScrollingForTabContainer : function (owner)
	{
		var scrollOrientation = Telerik.Web.UI.ScrollerOrientation.Horizontal;
		
		var startPosition = 0;
		if (owner.get_childListElement().style.marginLeft)
			startPosition = parseInt(owner.get_childListElement().style.marginLeft);
		
		if (this._orientation == Telerik.Web.UI.TabStripOrientation.VerticalRight ||
			this._orientation == Telerik.Web.UI.TabStripOrientation.VerticalLeft)
		{
			scrollOrientation = Telerik.Web.UI.ScrollerOrientation.Vertical;
			startPosition = 0;
			if (owner.get_childListElement().style.marginTop)
				startPosition = parseInt(owner.get_childListElement().style.marginTop);
		}
		owner._scroller = new Telerik.Web.UI.TabScroller(owner, scrollOrientation);
		owner._scroller.initialize();
		
		owner._scroller.setScrollingLimits(0, this._getScrollableSize(owner));
		owner._scroller._currentPosition = -startPosition;
		owner._scroller._calculateInitialTab();
		owner._scroller._updateArrows();
	},
	
	_getScrollableSize : function (owner)
	{
		if (this._orientation == Telerik.Web.UI.TabStripOrientation.VerticalRight ||
			this._orientation == Telerik.Web.UI.TabStripOrientation.VerticalLeft)
		{
			return this._getTabsSize(owner, "offsetHeight") - owner.get_levelElement().offsetHeight;
		}
		
		return this._getTabsSize(owner, "offsetWidth") - owner.get_levelElement().offsetWidth;
	},
	
	_getTabsSize : function (owner, sizeProperty)
	{
		var groups = Telerik.Web.UI.RadTabStrip._getTabGroups(owner.get_childListElement(), sizeProperty);
		var maxSize = 0;
		for (var i = 0; i < groups.length; i++)
		{
			if (maxSize < groups[i].size)
				maxSize = groups[i].size;
		}
		return maxSize;
	},
	
	_tabContainerRequiresScrolling : function (owner)
	{
		if (!owner._scrollChildren) return false;
		
		var levelElement = owner.get_levelElement();
		if (!levelElement) return false;
		
		var levelSize = levelElement.offsetWidth;
		
		
		if (this._orientation == Telerik.Web.UI.TabStripOrientation.VerticalRight ||
			this._orientation == Telerik.Web.UI.TabStripOrientation.VerticalLeft)
		{
			return levelElement.offsetHeight < this._getTabsSize(this, "offsetHeight");
		}
		return levelElement.offsetWidth < this._getTabsSize(owner, "offsetWidth");
	},
	
	_createChildControls : function ()
	{
		this._children = new Telerik.Web.UI.RadTabCollection(this);
		Telerik.Web.UI.RadTabStrip._createChildControls(this, this._children);
	},
	
	_getLevelElements : function ()
	{
		if (!this._levelElements)
			this._levelElements = $telerik.getChildrenByTagName(this.get_element(), "div");
		return this._levelElements;
	},
	
	_getListElementsForLevel : function (levelIndex)
	{
		return this._listElementsPerLevel[levelIndex];
	},
	
	_childInserting : function (index, tab, owner)
	{
		if (!owner._childControlsCreated) return;
		
		this._cachedSelectedTab = owner.get_selectedTab();
	},
	_childInserted : function (index, tab, owner)
	{
		this._allTabs = null;
		
		if (this._cachedSelectedTab)
		{
			owner._setSelectedIndex(this._cachedSelectedTab.get_index());
			this._cachedSelectedTab = null;
		}
		
		if (tab._cachedSelected)
		{
			owner._setSelectedIndex(index);
			tab._cachedSelected = false;
		}
		Telerik.Web.UI.RadTabStrip.callBaseMethod(this, "_childInserted", [index, tab, owner]);
		if (tab.get_isBreak())
		{
			var breakElement = document.createElement("li");
			breakElement.className = "rtsBreak";
			owner.get_childListElement().insertBefore(breakElement, tab.get_element().nextSibling);
		}
	},
	
	_childRemoving : function (tab)
	{
		if (tab.get_selected())
			tab.unselect();
		
		tab._cleanElements();
			
		Telerik.Web.UI.RadTabStrip.callBaseMethod(this, "_childRemoving", [tab]);
	},
	
	_childRemoved : function (tab, owner)
	{
		this._allTabs = null;
		
		var firstSibling = owner.get_tabs().getTab(0);
		if (firstSibling)
			firstSibling._updateAppearance();
		
		var lastSibling = owner.get_tabs().getTab(owner.get_tabs().get_count() - 1);
		if (lastSibling)
			lastSibling._updateAppearance();
		
		Telerik.Web.UI.RadTabStrip.callBaseMethod(this, "_childRemoved", [tab, owner]);
	},
	
	_childrenCleared : function (parent)
	{
		this._allTabs = null;
		
		parent.get_tabs().forEach(function(tab){ tab._cleanElements(); });
		
		Telerik.Web.UI.RadTabStrip.callBaseMethod(this, "_childrenCleared", [parent]);
	},
	
	_destroyChildren : function (owner)
	{
		owner.get_levelElement().removeChild(owner.get_childListElement());
		Array.remove(this._listElementsPerLevel[owner._getLevelIndex()], owner.get_childListElement());
		if (this._listElementsPerLevel[owner._getLevelIndex()].length < 1)
		{
			Array.removeAt(this._listElementsPerLevel, owner._getLevelIndex());
			Array.remove(this._levelElements, owner.get_levelElement());
			this.get_element().removeChild(owner.get_levelElement());
			owner._levelElement = null;
		}
		owner._childListElement = null;
	},
	
	_destroyChildListElement : function ()
	{
		this._destroyChildren(this);
	},
	
	_ensureElements : function ()
	{
		if (!this.get_childListElement())
			this._createChildListElement();
	},
	_createLevelElement : function (level)
	{
		var levelElement = document.createElement("div");
		var levelCssClass = "rtsLevel";
		if (this._align == Telerik.Web.UI.TabStripAlign.Center)
			levelCssClass += " rtsCenter";
		if (this._align == Telerik.Web.UI.TabStripAlign.Right)
			levelCssClass += " rtsRight";
			
		levelElement.className = levelCssClass + " rtsLevel" + level;
		
		if (this._ascendingRendering())
		{
			Array.add(this._listElementsPerLevel, []);
			Array.add(this._levelElements, levelElement);
			this.get_element().appendChild(levelElement);
		}
		else
		{
			Array.insert(this._listElementsPerLevel, 0, []);
			Array.insert(this._levelElements, 0, levelElement);
			this.get_element().insertBefore(levelElement, this.get_element().firstChild);
		}
		return levelElement;
	},
	
	_createChildListElement : function ()
	{
		var childListElement = document.createElement("ul");
		childListElement.className = "rtsUL";
		
		var levelElement = this._createLevelElement(1);
		levelElement.appendChild(childListElement);
		
		Array.add(this._listElementsPerLevel[this._getLevelIndex()], childListElement);
		return childListElement;
	},
	
	_initLevelElements : function ()
	{
		this._listElementsPerLevel = [];
		var levelElements = this._getLevelElements();
		for (var i = 0; i < levelElements.length; i++)
		{
			Array.add(this._listElementsPerLevel, $telerik.getChildrenByTagName(levelElements[i], "ul"));
		}
	},
	_ascendingRendering : function()
	{
		return this._orientation != Telerik.Web.UI.TabStripOrientation.HorizontalBottom;
	},
	_getLevelIndex : function ()
	{
		if (this._ascendingRendering())
			return 0;
		return this._getLevelElements().length - 1;
	},
	_unregisterSelectedTab : function (tab)
	{
		Array.remove(this._selectedIndexes, tab._getHierarchicalIndex());
		this._updateSelectedState();
	},
	
	_registerSelectedTab : function (tab)
	{
		Array.add(this._selectedIndexes, tab._getHierarchicalIndex());
		this._updateSelectedState();
	},
	
	_updateSelectedState : function ()
	{
		this._selectedIndexesJson = Sys.Serialization.JavaScriptSerializer.serialize(this._selectedIndexes);
		this.updateClientState();
	},
	
	_getHierarchicalIndex : function ()
	{
		return "-1";
	},
	
	_updateScrollState : function (owner, scrollPosition)
	{
		this._scrollState[owner._getHierarchicalIndex()] = -scrollPosition;
		this._scrollStateJson = Sys.Serialization.JavaScriptSerializer.serialize(this._scrollState);
		this.updateClientState();
	},
	
	_postback : function (tab)
	{
		if (!this._postBackReference)
			return;
			
		eval(String.format(this._postBackReference, tab._getHierarchicalIndex()));
	},
	
	_raiseCancelEvent : function (eventName, tab, domEvent)
	{
		var eventArgs = new Telerik.Web.UI.RadTabStripCancelEventArgs(tab, domEvent);
		this.raiseEvent(eventName, eventArgs);
		return eventArgs.get_cancel();
	},
	
	_raiseEvent : function (eventName, tab, domEvent)
	{
		this.raiseEvent(eventName, new Telerik.Web.UI.RadTabStripEventArgs(tab, domEvent));
	},
	
	/*DOM event handlers*/
	_resize : function (e)
	{
		if (!this._scrollInitInProgress)
			this._initScrolling();
		
		this.get_element()._aligned = null;
		
		Telerik.Web.UI.RadTabStrip._align(this.get_id(), this._align, this._orientation);
	},
	
	_doubleClick : function (e)
	{
		var tab = this._extractItemFromDomElement(e.eventMapTarget);
		this._raiseEvent("doubleClick", tab, e);
	},
	
	_mouseOver : function (e)
	{
		var tab = this._extractItemFromDomElement(e.eventMapTarget);
		
		if (this._highlightedTab == tab) return;
		
		if (this._highlightedTab)
			this._highlightedTab._unhighlight();
		
		tab._highlight();
		
		this._highlightedTab = tab;
		
		this._raiseEvent("mouseOver", tab, e);
	},

	_mouseOut : function (e)
	{
		if (!this._highlightedTab) return;
		
		if (!e.eventMapRelatedTarget) return;
		
		if ($telerik.isDescendant(this._highlightedTab.get_element(), e.eventMapRelatedTarget))
			return;
		
		this._highlightedTab._unhighlight();
		this._raiseEvent("mouseOut", this._highlightedTab, e);
		this._highlightedTab = null;
	},
	_contextMenu : function (e)
	{
		var tab = this._extractItemFromDomElement(e.eventMapTarget);
		this._raiseEvent("contextMenu", tab, e);
	},
	
	_click : function (e)
	{	
		var tab = this._extractItemFromDomElement(e.eventMapTarget);
		
		if (!tab.click(e))
			e.preventDefault();
	},
	
	_activate : function (e)
	{
		if (!e.altKey) return;
		var tab = this._extractItemFromDomElement(e.eventMapTarget);
		tab.click();
	},
	
	_requiresRtl : function ()
	{
		var currentElement = this.get_element();
		
		if (currentElement.className.indexOf("RadTabStrip_rtl") > -1) return false;
		
		return $telerik.getCurrentStyle(currentElement, "direction", "ltr") == "rtl";
	},
	
	_applyRtl : function ()
	{
		this.get_element().className = String.format("{0} RadTabStrip_rtl RadTabStrip_{1}_rtl", 
			this.get_element().className, this._skin);
	},
	/***** Public methods ******/
	
	initialize : function ()
	{
		this._initLevelElements();
		
		Telerik.Web.UI.RadTabStrip.callBaseMethod(this, 'initialize');
		
		Telerik.Web.UI.RadTabStrip._align(this.get_id(), this._align, this._orientation);
		
		this._updateSelectedState();
		
		this._eventMap.addHandlerForClassName("click", "rtsLI", this._click);
		this._eventMap.addHandlerForClassName("mouseover", "rtsLI", this._mouseOver);
		this._eventMap.addHandlerForClassName("mouseout", "rtsLI", this._mouseOut);
		this._eventMap.addHandlerForClassName("contextmenu", "rtsLI", this._contextMenu);
		this._eventMap.addHandlerForClassName("dblclick", "rtsLI", this._doubleClick);
		
		if ($telerik.isIE)
			this._eventMap.addHandlerForClassName("activate", "rtsLI", this._activate);

		this._resizeDelegate = Function.createDelegate(this, this._resize);
		
		$addHandler(window, "resize", this._resizeDelegate);
		
		if (this._requiresRtl())
			this._applyRtl();
			
		this._initScrolling();
		this.raiseEvent("load");
	},
	
	repaint : function ()
	{
		this._resize();
	},
	
	dispose : function ()
	{
		Telerik.Web.UI.RadTabStrip.callBaseMethod(this, 'dispose');
		
		$removeHandler(window, "resize", this._resizeDelegate);
		
		if (this._scroller)
			this._scroller.dispose();
	},
	
	commitChanges : function()
	{
		this._logEntriesJson = this._log.serialize();
		Telerik.Web.UI.RadTabStrip.callBaseMethod(this, "commitChanges");
	},
	
	enable : function()
	{
		this.set_enabled(true);
	},
	
	disable : function ()
	{
		this.set_enabled(false);
	},
	
	set_enabled : function (value)
	{
		Telerik.Web.UI.RadTabStrip.callBaseMethod(this, "set_enabled", [value]);
		if (!this.get_isInitialized()) return;
		
		this.get_element().disabled = !value;
		
		var disabledCssClass = String.format("RadTabStrip_{0}_disabled", this._skin);
		this.toggleCssClass(disabledCssClass);
	},
	
	get_causesValidation : function ()
	{
		return this._causesValidation;
	},
	
	set_causesValidation : function (value)
	{
		this._causesValidation = value;
	},
	
	get_validationGroup : function ()
	{
		return this._validationGroup;
	},
	
	set_validationGroup : function (value)
	{
		this._validationGroup = value;
	},
	
	get_unselectChildren : function ()
	{
		return this._unselectChildren == true;
	},
	set_unselectChildren : function (value)
	{
		this._unselectChildren = value;
	},
	get_selectedIndexes : function()
	{
		return this._selectedIndexes;
	},
	
	set_selectedIndexes : function(value)
	{
		this._selectedIndexes = value;
	},
		
	saveClientState : function ()
	{
		return "{\"selectedIndexes\":" + this._selectedIndexesJson +
				",\"logEntries\":" + this._logEntriesJson +
				",\"scrollState\":" + this._scrollStateJson +
				"}";
	},
	
	get_selectedTab : function ()
	{
		return this.get_tabs().getTab(this.get_selectedIndex()) || null;
	},
	
	get_selectedIndex : function ()
	{
		return this._selectedIndex;
	},
	
	set_selectedIndex : function (value)
	{
		if (value > -1)
		{
			var tab = this.get_tabs().getTab(value);
			if (tab)
				tab.select();
		}
		else
		{
			var selectedTab = this.get_selectedTab();
			if (selectedTab)
				selectedTab.unselect();
		}
	},
	
	_setSelectedIndex : function (value)
	{
		this._selectedIndex = value;
	},
	
	get_levelElement : function ()
	{
		if (!this._levelElement)
			this._levelElement = this._getLevelElements()[this._getLevelIndex()] || null;
		return this._levelElement;
	},
	
	get_childListElement : function ()
	{
		if (!this.get_levelElement())
			return null;
			
		if (!this._childListElement)
			this._childListElement = $telerik.getChildByClassName(this.get_levelElement(), "rtsUL");
		return this._childListElement;
	},
	
	get_tabData : function ()
	{
		return this._tabData;
	},
	
	set_tabData : function (value)
	{
		this._tabData = value;
	},
	
	get_tabs : function ()
	{
		return this._getChildren();
	},
	
	get_clickSelectedTab : function ()
	{
		return this._clickSelectedTab == true;
	},
	
	set_clickSelectedTab : function (value)
	{
		this._clickSelectedTab = value;
	},
	
	findTabByText : function (text)
	{
		return this._findItemByText(text);
	},
	
	findTabByValue : function (value)
	{
		return this._findItemByValue(value);
	},
	
	findTabByAttribute : function (attributeName, attributeValue)
	{
		return this._findItemByAttribute(attributeName, attributeValue);
	},	
	
	get_allTabs : function ()
	{
		if (!this._allTabs)
			this._allTabs = this._getAllItems();
		return this._allTabs;
	},
	
	get_multiPage : function()
	{
		if (!this.get_multiPageID()) return null;
		
		return $find(this.get_multiPageID());
	},
	
	set_multiPageID : function(value)
	{
		this._multiPageID = value;
	},
	
	get_multiPageID : function ()
	{
		return this._multiPageID;
	},
	
	/*** Events ***/
	add_tabSelecting : function (eventHandler)
	{
		this.get_events().addHandler("tabSelecting", eventHandler);
	},
	
	remove_tabSelecting : function (eventHandler)
	{
		this.get_events().removeHandler("tabSelecting", eventHandler);
	},
	
	add_tabSelected : function (eventHandler)
	{
		this.get_events().addHandler("tabSelected", eventHandler);
	},
	
	remove_tabSelected  : function (eventHandler)
	{
		this.get_events().removeHandler("tabSelected", eventHandler);
	},
	
	add_tabUnSelected : function (eventHandler)
	{
		this.get_events().addHandler("tabUnSelected", eventHandler);
	},
	
	remove_tabUnSelected  : function (eventHandler)
	{
		this.get_events().removeHandler("tabUnSelected", eventHandler);
	},
	
	add_load : function (eventHandler)
	{
		this.get_events().addHandler("load", eventHandler);
	},
	
	remove_load : function (eventHandler)
	{
		this.get_events().removeHandler("load", eventHandler);
	},
	
	add_mouseOver : function (eventHandler)
	{
		this.get_events().addHandler("mouseOver", eventHandler);
	},
	remove_mouseOver : function (eventHandler)
	{
		this.get_events().removeHandler("mouseOver", eventHandler);
	},
	
	add_mouseOut : function (eventHandler)
	{
		this.get_events().addHandler("mouseOut", eventHandler);
	},
	remove_mouseOut : function (eventHandler)
	{
		this.get_events().removeHandler("mouseOut", eventHandler);
	},
	
	add_contextMenu : function (eventHandler)
	{
		this.get_events().addHandler("contextMenu", eventHandler);
	},
	remove_contextMenu : function (eventHandler)
	{
		this.get_events().removeHandler("contextMenu", eventHandler);
	},
	
	add_doubleClick : function (eventHandler)
	{
		this.get_events().addHandler("doubleClick", eventHandler);
	},
	remove_doubleClick : function (eventHandler)
	{
		this.get_events().removeHandler("doubleClick", eventHandler);
	}
}

Telerik.Web.UI.RadTabStrip.registerClass('Telerik.Web.UI.RadTabStrip', Telerik.Web.UI.ControlItemContainer);
if(typeof(Sys)!=='undefined')Sys.Application.notifyScriptLoaded();