<?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 thumb and track skins are defined by the
HScrollBarThumbSkin and HScrollBarTrackSkin classes, respectively. -->
<s:Skin xmlns:fx="http://ns.adobe.com/mxml/2009" xmlns:s="library://ns.adobe.com/flex/spark"
	  minWidth="35" minHeight="15"
	  alpha.disabled="0.5"
	  alpha.inactive="0.5">

    <fx:Metadata>
    <![CDATA[ 
	/** 
	 * @copy spark.skins.default.ApplicationSkin#hostComponent
	 */
    	[HostComponent("spark.components.HScrollBar")]
    ]]>
    </fx:Metadata> 
    
	<s:states>
		<s:State name="normal" />
		<s:State name="disabled" />
		<s:State name="inactive" />
	</s:states>
    
    <!--- Defines the skin class for the HScrollBarSkin's track. The default skin class is HScrollBarTrackSkin. -->
    <!-- when using custom theme set path to theme's skin MXML files: arcade.skins.xxxSkin -->
    <s:Button id="track" left="16" right="15" width="54"
              focusEnabled="false"
              skinClass="arcade.skins.HScrollBarTrackSkin" />
    <!--- Defines the skin class for the HScrollBarSkin's thumb. The default skin class is HScrollBarThumbSkin. -->
   	<!-- when using custom theme set path to theme's skin MXML files: arcade.skins.xxxSkin -->
    <s:Button id="thumb" 
              focusEnabled="false"
              skinClass="arcade.skins.HScrollBarThumbSkin"  />

    <!--- Defines the skin class for the left button of the HScrollBarSkin. The default skin class is ScrollBarLeftButtonSkin. -->
    <!-- when using custom theme set path to theme's skin MXML files: arcade.skins.xxxSkin -->
    <s:Button id="decrementButton" left="0"
              focusEnabled="false"
              skinClass="arcade.skins.ScrollBarLeftButtonSkin"  />
              
    <!--- Defines the skin class for the right button of the HScrollBarSkin. The default skin class is ScrollBarRightButtonSkin. -->
    <!-- when using custom theme set path to theme's skin MXML files: arcade.skins.xxxSkin -->
    <s:Button id="incrementButton" right="0"
              focusEnabled="false"
              skinClass="arcade.skins.ScrollBarRightButtonSkin" />

</s:Skin>
