<?xml version="1.0" encoding="utf-8"?>
<!--

  Licensed to the Apache Software Foundation (ASF) under one or more
  contributor license agreements.  See the NOTICE file distributed with
  this work for additional information regarding copyright ownership.
  The ASF licenses this file to You under the Apache License, Version 2.0
  (the "License"); you may not use this file except in compliance with
  the License.  You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.

-->


<!--- 

The default skin class for the Spark TabBar component. The ButtonBarButtons 
created by the TabBar component use the TabBarButtonSkin class.  

@see spark.components.TabBar
@see spark.components.ButtonBarButton

@langversion 3.0
@playerversion Flash 10
@playerversion AIR 1.5
@productversion Flex 4

-->

<s:Skin 
	xmlns:fx="http://ns.adobe.com/mxml/2009" 
	xmlns:s="library://ns.adobe.com/flex/spark"
	xmlns:fb="http://ns.adobe.com/flashbuilder/2009"     
	alpha.disabled="0.5">
	
	<fx:Metadata>
		<![CDATA[ 
		/** 
		* @copy spark.skins.spark.ApplicationSkin#hostComponent
		*/
		[HostComponent("spark.components.TabBar")]
		]]>
	</fx:Metadata> 
	
	<fx:Script  fb:purpose="styling" >
		<![CDATA[ 
			
			import mx.core.UIComponent;
			
			/**
			 *  @private
			 *  Push the cornerRadius style to the item renderers.
			 */
			override protected function updateDisplayList(unscaledWidth:Number, unscaleHeight:Number):void
			{
				const numElements:int = dataGroup.numElements;
				const cornerRadius:int = hostComponent.getStyle("cornerRadius");
				for (var i:int = 0; i < numElements; i++)
				{
					var elt:UIComponent = dataGroup.getElementAt(i) as UIComponent;
					if (elt)
						elt.setStyle("cornerRadius", cornerRadius);
				}
				
				super.updateDisplayList(unscaledWidth, unscaledHeight);
			}
			
		]]>            
	</fx:Script>
	
	<s:states>
		<s:State name="normal" />
		<s:State name="disabled" />
	</s:states>
	
	<!--- 
	@copy spark.components.SkinnableDataContainer#dataGroup
	-->
	<s:DataGroup id="dataGroup" width="100%" height="100%">
		<s:layout>
			<s:ButtonBarHorizontalLayout gap="-1"/>
		</s:layout>
		<s:itemRenderer>
			<fx:Component>
				<s:ButtonBarButton skinClass="skins.CustomTabBarButtonSkin" />
			</fx:Component>
		</s:itemRenderer>
	</s:DataGroup>
	
</s:Skin>
