      *  funcName(value:Number):String
      *  </pre>
      *
-     *  <p>The following example prefixes the data tip text with a dollar sign and 
-     *  formats the text using the <code>dataTipPrecision</code> 
+     *  <p>The following example prefixes the data tip text with a dollar sign and
+     *  formats the text using the <code>dataTipPrecision</code>
      *  of a Slider Control named 'slide': </p>
      *
      *  <pre>
      *  import mx.formatters.NumberBase;
-     *  function myDataTipFormatter(value:Number):String { 
-     *      var dataFormatter:NumberBase = new NumberBase(".", ",", ".", ""); 
-     *      return   "$ " + dataFormatter.formatPrecision(String(value), slide.getStyle("dataTipPrecision")); 
+     *  function myDataTipFormatter(value:Number):String {
+     *      var dataFormatter:NumberBase = new NumberBase(".", ",", ".", "");
+     *      return   "$ " + dataFormatter.formatPrecision(String(value), slide.getStyle("dataTipPrecision"));
      *  }
      *  </pre>
      *
-     *  @default undefined   
+     *  @default undefined
      */
     public function get dataTipFormatFunction():Function
     {
-        return _dataTipFormatFunction;
-    }
-
+      return _dataTipFormatFunction;
+    }
+    
     /**
      *  @private
      */
     public function set dataTipFormatFunction(value:Function):void
     {
-        _dataTipFormatFunction = value;
-    }
-
+      _dataTipFormatFunction = value;
+    }
+    
     //----------------------------------
     //  direction
     //----------------------------------
-
+    
     /**
      *  @private
      */
     protected var _direction:String = SliderDirection.HORIZONTAL;
-
+    
     /**
      *  @private
      */
     private var directionChanged:Boolean = false;
-
+    
     [Inspectable(defaultValue="horizontal")]
-
+    
     /**
      *  The orientation of the slider control.
      *  Valid values in MXML are <code>"horizontal"</code> or <code>"vertical"</code>.

     *  <p>For example, if <code>tickInterval</code> is 1 and
     *  <code>maximum</code> is 10,  then a tick mark is placed at each
     *  1/10th interval along the slider.
     *  A value of 0 shows no tick marks. If the <code>tickValues</code> property 
     *  is set to a non-empty Array, then this property is ignored.</p>
     *
     *  @default 0
     */
    public function get tickInterval():Number
    {
        return _tickInterval;
    }

    /**
     *  @private
     */
    public function set tickInterval(value:Number):void
    {
        _tickInterval = value;
        ticksChanged = true;

        invalidateProperties();
        invalidateDisplayList();
    }

    
    //----------------------------------
    //  tickValues
    //----------------------------------

    /**
     *  @private
     */
    private var _tickValues:Array = [];

    [Inspectable(category="General", defaultValue="undefined", arrayType="Number")]

    /**
     *  The positions of the tick marks on the slider. The positions correspond
     *  to the values on the slider and should be between 
     *  the <code>minimum</code> and <code>maximum</code> values.
     *  For example, if the <code>tickValues</code> property 
     *  is [0, 2.5, 7.5, 10] and <code>maximum</code> is 10, then a tick mark is placed
     *  in the following positions along the slider: the beginning of the slider, 
     *  1/4 of the way in from the left, 
     *  3/4 of the way in from the left, and at the end of the slider. 
     *  
     *  <p>If this property is set to a non-empty Array, then the <code>tickInterval</code> property
     *  is ignored.</p>
     *

     */
    public function get value():Number
    {
      return _values[0];
    }
    
    /**
     *  @private
     */
    public function set value(val:Number):void
    {
      setValueAt(val, 0, true);
      valuesChanged = true;
      minimumSet = true;
      
      invalidateProperties();
      invalidateDisplayList();
      
      dispatchEvent(new FlexEvent(FlexEvent.VALUE_COMMIT));
    }
    
    //----------------------------------
    //  values
    //----------------------------------
    
    /**
     *  @private
     */
    private var _values:Array = [0, 0];
    
    /**
     *  @private
     */
    private var valuesChanged:Boolean = false;
    
    [Bindable("change")]
    [Inspectable(category="General", arrayType="Number")]
    
    /**
     *  An array of values for each thumb when <code>thumbCount</code>
     *  is greater than 1.
     */
    public function get values():Array
    {
      return _values;
    }
    
    /**
     *  @private
     */
    public function set values(value:Array):void
    {
      _values = value;
      valuesChanged = true;
      minimumSet = true;
      
      invalidateProperties();
      invalidateDisplayList();
    }
    
    //--------------------------------------------------------------------------
    //
    //  Overridden methods
    //
    //--------------------------------------------------------------------------
    
    /**
     *  @private
     */
    override protected function initializeAccessibility():void
    {
      if (SliderBase.createAccessibilityImplementation != null)
        SliderBase.createAccessibilityImplementation(this);
    }
    
    /**
     *  @private
     */
    override protected function createChildren():void
    {
      super.createChildren();
      
      if (!innerSlider)
      {
        innerSlider = new UIComponent();
        UIComponent(innerSlider).tabChildren = true;
        addChild(innerSlider);
      }
      
      createBackgroundTrack();
      
      if (!trackHitArea)
      {
        trackHitArea = new UIComponent();
        innerSlider.addChild(trackHitArea); // trackHitArea should always be on top
        
        trackHitArea.addEventListener(MouseEvent.MOUSE_DOWN,
          track_mouseDownHandler);
      }
      
      invalidateProperties(); // Force commitProperties to be called on instantiation
    }
    
    /**
     *  @private
     */
    override public function styleChanged(styleProp:String):void
    {
      var anyStyle:Boolean = styleProp == null || styleProp == "styleName";
      
      super.styleChanged(styleProp);
      
      if (styleProp == "showTrackHighlight" || anyStyle)
      {
        trackHighlightChanged = true;
        invalidateProperties();
      }
      
      if (styleProp == "trackHighlightSkin" || anyStyle)
      {
        if (innerSlider && highlightTrack)
        {
          innerSlider.removeChild(DisplayObject(highlightTrack));
          highlightTrack = null;
        }
        trackHighlightChanged = true;
        invalidateProperties();
      }
      
      if (styleProp == "labelStyleName" || anyStyle)
      {
        labelStyleChanged = true;
        invalidateProperties();
      }
      
      if (styleProp == "trackMargin" || anyStyle)
      {
        invalidateSize();
      }
      
      if (styleProp == "trackSkin" || anyStyle)
      {
        if (track)
        {
          innerSlider.removeChild(DisplayObject(track));
          track = null;
          createBackgroundTrack();
        }
      }
      
      invalidateDisplayList();
    }
    
    /**
     *  @private
     */
    override protected function commitProperties():void
    {
      super.commitProperties();
      
      var n:int;
      var i:int;
      
      if (trackHighlightChanged)
      {
        trackHighlightChanged = false;
        
        if (getStyle("showTrackHighlight"))
        {
          createHighlightTrack();
        }
        else if (highlightTrack)
        {
          innerSlider.removeChild(DisplayObject(highlightTrack));
          highlightTrack = null;
        }
      }
      
      if (directionChanged)
      {
        directionChanged = false;
        var isHorizontal:Boolean = _direction == SliderDirection.HORIZONTAL;
        
        if (isHorizontal)
        {
          DisplayObject(innerSlider).rotation = 0;
        }
        else
        {
          DisplayObject(innerSlider).rotation = -90;
          innerSlider.y = unscaledHeight;
        }
        
        if (labelObjects)
        {
          for (var labelIndex:int = labelObjects.numChildren - 1; labelIndex >= 0; labelIndex--)
          {
            var labelObj:SliderLabel = SliderLabel(
              labelObjects.getChildAt(labelIndex));
            labelObj.rotation = isHorizontal ? 0 : 90;
          }
        }
      }
      
      if (labelStyleChanged && !labelsChanged)
      {
        labelStyleChanged = false;
        
        if (labelObjects)
        {
          var labelStyleName:String = getStyle("labelStyleName");
          n = labelObjects.numChildren;
          for (i = 0; i < n; i++)
          {
            ISimpleStyleClient(labelObjects.getChildAt(i)).styleName = labelStyleName;
          }
        }
      }
      
      if (ticksChanged)
      {
        ticksChanged = false;
        
        createTicks();
      }
      
      if (labelsChanged)
      {
        labelsChanged = false;
        
        createLabels();
      }
      
      if (thumbsChanged)
      {
        thumbsChanged = false;
        
        createThumbs();
      }
      
      
      if (initValues)
      {
        initValues = false;
        
        if (!valuesChanged)
        {
          var val:Number = minimum;
          
          n = _thumbCount;
          for (i = 0; i < n; i++)
          {
            _values[i] = val;
            setValueAt(val, i);
            if (_snapInterval && _snapInterval != 0)
              val += snapInterval;
            else
              val++;
          }
          
          snapIntervalChanged = false;
        }
      }
      
      if (snapIntervalChanged)
      {
        snapIntervalChanged = false;
        
        if (!valuesChanged)
        {
          n = thumbs.numChildren;
          for (i = 0; i < n; i++)
          {
            setValueAt(getValueFromX(SliderThumb(thumbs.getChildAt(i)).xPosition), i);
          }
        }
      }
      
      
      
      if (valuesChanged)
      {
        valuesChanged = false;
        
        n = _thumbCount;
        for (i = 0; i < n; i++)
        {
          setValueAt(getValueFromX(getXFromValue(Math.min(Math.max(values[i], minimum), maximum))), i);
        }
      }
      
      if (enabledChanged)
      {
        enabledChanged = false;
        
        n = thumbs.numChildren;
        for (i = 0; i < n; i++)
        {
          SliderThumb(thumbs.getChildAt(i)).enabled = _enabled;
        }
        
        n = labelObjects ? labelObjects.numChildren : 0;
        for (i = 0; i < n; i++)
        {
          SliderLabel(labelObjects.getChildAt(i)).enabled = _enabled;
        }
      }
      
      if (tabIndexChanged)
      {
        tabIndexChanged = false;
        
        n = thumbs.numChildren;
        for (i = 0; i < n; i++)
        {
          SliderThumb(thumbs.getChildAt(i)).tabIndex = _tabIndex;
        }
      }
    }
    
    /**
     *  Calculates the amount of space that the component takes up.
     *  A horizontal slider control calculates its height by examining
