You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@royale.apache.org by pu...@apache.org on 2020/09/21 13:31:06 UTC
[royale-asjs] branch develop updated: Create Slider.as
This is an automated email from the ASF dual-hosted git repository.
pushminakazi pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/royale-asjs.git
The following commit(s) were added to refs/heads/develop by this push:
new 3fcd757 Create Slider.as
3fcd757 is described below
commit 3fcd757d78b048a3175de3541f8e656e0e67e61e
Author: pashminakazi <42...@users.noreply.github.com>
AuthorDate: Mon Sep 21 18:30:54 2020 +0500
Create Slider.as
---
.../royale/mx/controls/sliderClasses/Slider.as | 2882 ++++++++++++++++++++
1 file changed, 2882 insertions(+)
diff --git a/frameworks/projects/MXRoyale/src/main/royale/mx/controls/sliderClasses/Slider.as b/frameworks/projects/MXRoyale/src/main/royale/mx/controls/sliderClasses/Slider.as
new file mode 100644
index 0000000..364ed11
--- /dev/null
+++ b/frameworks/projects/MXRoyale/src/main/royale/mx/controls/sliderClasses/Slider.as
@@ -0,0 +1,2882 @@
+////////////////////////////////////////////////////////////////////////////////
+//
+// 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.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+package mx.controls.sliderClasses
+{
+
+//import flash.display.DisplayObject;
+import mx.core.UIComponent;
+import mx.display.Graphics;
+import mx.events.FocusEvent;
+import mx.events.KeyboardEvent;
+import org.apache.royale.events.MouseEvent;
+import org.apache.royale.geom.Point;
+
+import mx.core.IFlexDisplayObject;
+import mx.core.IUIComponent;
+import mx.core.LayoutDirection;
+import mx.core.UIComponent;
+import mx.core.mx_internal;
+import mx.effects.Tween;
+import mx.events.FlexEvent;
+import mx.events.SliderEvent;
+import mx.events.SliderEventClickTarget;
+import mx.formatters.NumberFormatter;
+import mx.styles.ISimpleStyleClient;
+import mx.styles.StyleProxy;
+
+use namespace mx_internal;
+
+//--------------------------------------
+// Events
+//--------------------------------------
+
+/**
+ * Dispatched when the slider changes value due to mouse or keyboard interaction.
+ *
+ * <p>If the <code>liveDragging</code> property is <code>true</code>,
+ * the event is dispatched continuously as the user moves the thumb.
+ * If <code>liveDragging</code> is <code>false</code>,
+ * the event is dispatched when the user releases the slider thumb.</p>
+ *
+ * @eventType mx.events.SliderEvent.CHANGE
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+[Event(name="change", type="mx.events.SliderEvent")]
+
+/**
+ * Dispatched when the slider's thumb is pressed and then moved by the mouse.
+ * This event is always preceded by a <code>thumbPress</code> event.
+ * @eventType mx.events.SliderEvent.THUMB_DRAG
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+[Event(name="thumbDrag", type="mx.events.SliderEvent")]
+
+/**
+ * Dispatched when the slider's thumb is pressed, meaning
+ * the user presses the mouse button over the thumb.
+ *
+ * @eventType mx.events.SliderEvent.THUMB_PRESS
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+[Event(name="thumbPress", type="mx.events.SliderEvent")]
+
+/**
+ * Dispatched when the slider's thumb is released,
+ * meaning the user releases the mouse button after
+ * a <code>thumbPress</code> event.
+ *
+ * @eventType mx.events.SliderEvent.THUMB_RELEASE
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+[Event(name="thumbRelease", type="mx.events.SliderEvent")]
+
+//--------------------------------------
+// Styles
+//--------------------------------------
+
+//include "../../styles/metadata/FillStyles.as";
+
+/**
+ * The color of the black section of the border.
+ *
+ * @default 0x919999
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+[Style(name="borderColor", type="uint", format="Color", inherit="no", theme="halo")]
+
+/**
+ * Color of the track highlight.
+ *
+ * @default #0099FF
+ *
+ * @langversion 3.0
+ * @playerversion Flash 10
+ * @playerversion AIR 1.5
+ * @productversion Flex 4
+ */
+[Style(name="accentColor", type="uint", format="Color", inherit="yes", theme="spark")]
+
+/**
+ * Color of focus ring when the component is in focus
+ *
+ * @default 0x70B2EE
+ *
+ * @langversion 3.0
+ * @playerversion Flash 10
+ * @playerversion AIR 1.5
+ * @productversion Flex 4
+ */
+[Style(name="focusColor", type="uint", format="Color", inherit="yes", theme="spark")]
+
+/**
+ * Invert the direction of the thumbs.
+ * If <code>true</code>, the thumbs will be flipped.
+ *
+ * @default false
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+[Style(name="invertThumbDirection", type="Boolean", inherit="no")]
+
+/**
+ * The y-position offset (if direction is horizontal)
+ * or x-position offset (if direction is vertical)
+ * of the labels relative to the track.
+ *
+ * @default -10
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+[Style(name="labelOffset", type="Number", format="Length", inherit="no")]
+
+/**
+ * The name of the style to use for the slider label.
+ *
+ * @default undefined
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+[Style(name="labelStyleName", type="String", inherit="no")]
+
+/**
+ * Duration in milliseconds for the sliding animation
+ * when you click on the track to move a thumb.
+ *
+ * @default 300
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+[Style(name="slideDuration", type="Number", format="Time", inherit="no")]
+
+/**
+ * Tweening function used by the sliding animation
+ * when you click on the track to move a thumb.
+ *
+ * @default undefined
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+[Style(name="slideEasingFunction", type="Function", inherit="no")]
+
+/**
+ * The y-position offset (if direction is horizontal)
+ * or x-position offset (if direction is vertical)
+ * of the thumb relative to the track.
+ *
+ * @default 0
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+[Style(name="thumbOffset", type="Number", format="Length", inherit="no")]
+
+/**
+ * The color of the tick marks.
+ * Can be a hex color value or the string name of a known color.
+ *
+ * @default 0x6F7777.
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+[Style(name="tickColor", type="uint", format="Color", inherit="no")]
+
+/**
+ * The length in pixels of the tick marks.
+ * If <code>direction</code> is <code>Direction.HORIZONTAL</code>,
+ * then adjust the height of the tick marks.
+ * If <code>direction</code> is <code>Direction.VERTICAL</code>,
+ * then adjust the width.
+ *
+ * @default 3
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+[Style(name="tickLength", type="Number", format="Length", inherit="no")]
+
+/**
+ * The y-position offset (if direction is horizontal)
+ * or x-position offset (if direction is vertical)
+ * of the tick marks relative to the track.
+ *
+ * @default -6
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+[Style(name="tickOffset", type="Number", format="Length", inherit="no")]
+
+/**
+ * The thickness in pixels of the tick marks.
+ * If direction is horizontal,
+ * then adjust the width of the tick marks.
+ * If direction is vertical,
+ * then adjust the height.
+ *
+ * @default 1
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+[Style(name="tickThickness", type="Number", format="Length", inherit="no")]
+
+/**
+ * The colors of the track, as an array of two colors.
+ * You can use the same color twice for a solid track color.
+ *
+ * <p>You use this property along with the <code>fillAlphas</code>
+ * property. Typically you set <code>fillAlphas</code> to [ 1.0, 1.0 ]
+ * when setting <code>trackColors</code>.</p>
+ *
+ * @default [ 0xE7E7E7, 0xE7E7E7 ]
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+[Style(name="trackColors", type="Array", arrayType="uint", format="Color", inherit="no", theme="halo")]
+
+/**
+ * Specifies whether to enable track highlighting between thumbs
+ * (or a single thumb and the beginning of the track).
+ *
+ * @default false
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+[Style(name="showTrackHighlight", type="Boolean", inherit="no")]
+
+/**
+ * The size of the track margins, in pixels.
+ * If <code>undefined</code>, then the track margins will be determined
+ * by the length of the first and last labels.
+ * If given a value, Flex attempts to fit the labels in the available space.
+ *
+ * @default undefined
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+[Style(name="trackMargin", type="Number", format="Length", inherit="no")]
+
+/**
+ * The name of the style declaration to use for the data tip.
+ *
+ * @default undefined
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+[Style(name="dataTipStyleName", type="String", inherit="no")]
+
+/**
+ * The offset, in pixels, of the data tip relative to the thumb.
+ * Used in combination with the <code>dataTipPlacement</code>
+ * style property of the HSlider and VSlider controls.
+ *
+ * @default 16
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+[Style(name="dataTipOffset", type="Number", format="Length", inherit="no")]
+
+/**
+ * Number of decimal places to use for the data tip text.
+ * A value of 0 means to round all values to an integer.
+ *
+ * @default 2
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+[Style(name="dataTipPrecision", type="int", inherit="no")]
+
+/**
+ * The default skin for the slider thumb.
+ *
+ * @default SliderThumbSkin
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+[Style(name="thumbSkin", type="Class", inherit="no", states="up, over, down, disabled")]
+
+/**
+ * The skin for the slider thumb up state.
+ *
+ * @default SliderThumbSkin
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+[Style(name="thumbUpSkin", type="Class", inherit="no")]
+
+/**
+ * The skin for the slider thumb over state.
+ *
+ * @default SliderThumbSkin
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+[Style(name="thumbOverSkin", type="Class", inherit="no")]
+
+/**
+ * The skin for the slider thumb down state.
+ *
+ * @default SliderThumbSkin
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+[Style(name="thumbDownSkin", type="Class", inherit="no")]
+
+/**
+ * The skin for the slider thumb disabled state.
+ *
+ * @default SliderThumbSkin
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+[Style(name="thumbDisabledSkin", type="Class", inherit="no")]
+
+/**
+ * The skin for the slider track when it is selected.
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+[Style(name="trackHighlightSkin", type="Class", inherit="no")]
+
+/**
+ * The skin for the slider track.
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+[Style(name="trackSkin", type="Class", inherit="no")]
+
+//--------------------------------------
+// Other metadata
+//--------------------------------------
+
+[AccessibilityClass(implementation="mx.accessibility.SliderAccImpl")]
+
+[ResourceBundle("SharedResources")]
+
+/**
+ * The Slider class is the base class for the Flex slider controls.
+ * The slider controls let users select a value by moving a slider thumb
+ * between the end points of the slider
+ * track. The current value of the slider is determined by
+ * the relative location of the thumb between the
+ * end points of the slider, corresponding to the slider's minimum and maximum values.
+ * The Slider class is subclassed by HSlider and VSlider.
+ *
+ * @mxml
+ *
+ * <p>The Slider class cannot be used as an MXML tag. Use the <code><mx:HSlider></code>
+ * and <code><mx:VSlider></code> tags instead. However, the Slider class does define tag
+ * attributes used by the <code><mx:HSlider></code> and <code><mx:VSlider></code> tags. </p>
+ *
+ * <p>The Slider class inherits all of the tag attributes
+ * of its superclass, and adds the following tag attributes:</p>
+ *
+ * <pre>
+ * <mx:<i>tagname</i>
+ * <strong>Properties</strong>
+ * allowThumbOverlap="false|true"
+ * allowTrackClick="true|false"
+ * dataTipFormatFunction="undefined"
+ * direction="horizontal|vertical"
+ * labels="undefined"
+ * liveDragging="false|true"
+ * maximum="10"
+ * minimum="0"
+ * showDataTip="true|false"
+ * sliderDataTipClass="sliderDataTip"
+ * sliderThumbClass="SliderThumb"
+ * snapInterval="0"
+ * thumbCount="1"
+ * tickInterval="0"
+ * tickValues="undefined"
+ * value="<i>The value of the minimum property.</i>"
+ *
+ * <strong>Styles</strong>
+ * borderColor="0x919999"
+ * dataTipOffset="16"
+ * dataTipPrecision="2"
+ * dataTipStyleName="undefined"
+ * fillAlphas="[0.6, 0.4, 0.75, 0.65]"
+ * fillColors="[0xFFFFFF, 0xCCCCCC, 0xFFFFFF, 0xEEEEEE;]"
+ * labelOffset="-10"
+ * labelStyleName="undefined"
+ * showTrackHighlight="false"
+ * slideDuration="300"
+ * slideEasingFunction="undefined"
+ * thumbDisabledSkin="SliderThumbSkin"
+ * thumbDownSkin="SliderThumbSkin"
+ * thumbOffset="0"
+ * thumbOverSkin="SliderThumbSkin"
+ * thumbUpSkin="SliderThumbSkin"
+ * tickColor="0x6F7777"
+ * tickLength="3"
+ * tickOffset="-6"
+ * tickThickness="1"
+ * trackColors="[ 0xEEEEEE, 0xFFFFFF ]"
+ * tracHighlightSkin="SliderHighlightSkin"
+ * trackMargin="undefined"
+ * trackSkin="SliderTrackSkin"
+ *
+ * <strong>Events</strong>
+ * change="<i>No default</i>"
+ * thumbDrag="<i>No default</i>"
+ * thumbPress="<i>No default</i>"
+ * thumbRelease="<i>No default</i>"
+ * />
+ * </pre>
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+public class Slider extends UIComponent
+{
+ //include "../../core/Version.as";
+
+ //--------------------------------------------------------------------------
+ //
+ // Class mixins
+ //
+ //--------------------------------------------------------------------------
+
+ /**
+ * @private
+ * Placeholder for mixin by SliderAccImpl.
+ */
+ mx_internal static var createAccessibilityImplementation:Function;
+
+ //--------------------------------------------------------------------------
+ //
+ // Constructor
+ //
+ //--------------------------------------------------------------------------
+
+ /**
+ * Constructor.
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+ public function Slider()
+ {
+ super();
+ }
+
+ //--------------------------------------------------------------------------
+ //
+ // Variables
+ //
+ //--------------------------------------------------------------------------
+
+ /**
+ * @private
+ */
+ private var track:IFlexDisplayObject;
+
+ /**
+ * @private
+ */
+ private var thumbs:UIComponent;
+
+ /**
+ * @private
+ */
+ private var thumbsChanged:Boolean = true;
+
+ /**
+ * @private
+ */
+ private var ticks:UIComponent;
+
+ /**
+ * @private
+ */
+ private var ticksChanged:Boolean = false;
+
+ /**
+ * @private
+ */
+ private var labelObjects:UIComponent;
+
+ /**
+ * @private
+ */
+ private var highlightTrack:IFlexDisplayObject;
+
+ /**
+ * @private
+ */
+ mx_internal var innerSlider:UIComponent;
+
+ /**
+ * @private
+ */
+ private var trackHitArea:UIComponent;
+
+ /**
+ * @private
+ */
+ //mx_internal var dataTip:SliderDataTip;
+
+ /**
+ * @private
+ */
+ private var trackHighlightChanged:Boolean = true;
+
+ /**
+ * @private
+ */
+ private var initValues:Boolean = true; // Always initValues at startup
+
+ /**
+ * @private
+ */
+ private var dataFormatter:NumberFormatter;
+
+ /**
+ * @private
+ */
+ private var interactionClickTarget:String;
+
+ /**
+ * @private
+ */
+ private var labelStyleChanged:Boolean = false;
+
+ /**
+ * @private
+ * is the last interaction from the keyboard?
+ */
+ mx_internal var keyInteraction:Boolean = false;
+
+ //--------------------------------------------------------------------------
+ //
+ // Overridden properties
+ //
+ //--------------------------------------------------------------------------
+
+ //----------------------------------
+ // baselinePosition
+ //----------------------------------
+
+ /**
+ * @private
+ */
+ /* override public function get baselinePosition():Number
+ {
+ if (!validateBaselinePosition())
+ return NaN;
+
+ return int(0.75 * height);
+ } */
+
+ //----------------------------------
+ // enabled
+ //----------------------------------
+
+ /**
+ * @private
+ */
+ private var _enabled:Boolean;
+
+ /**
+ * @private
+ */
+ private var enabledChanged:Boolean = false;
+
+ [Inspectable(category="General", enumeration="true,false", defaultValue="true")]
+
+ /**
+ * @private
+ */
+ override public function get enabled():Boolean
+ {
+ return _enabled;
+ }
+
+ /**
+ * @private
+ */
+ override public function set enabled(value:Boolean):void
+ {
+ _enabled = value;
+ enabledChanged = true;
+
+ invalidateProperties();
+ }
+
+ /**
+ * @private
+ */
+ private var _tabIndex:Number;
+
+ /**
+ * @private
+ */
+ private var tabIndexChanged:Boolean;
+
+ /**
+ * @private
+ */
+ override public function set tabIndex(value:int):void
+ {
+ super.tabIndex = value;
+ _tabIndex = value;
+
+ tabIndexChanged = true;
+ invalidateProperties();
+ }
+
+ //--------------------------------------------------------------------------
+ //
+ // Properties
+ //
+ //--------------------------------------------------------------------------
+
+ //----------------------------------
+ // allowThumbOverlap
+ //----------------------------------
+
+ [Inspectable(defaultValue="false")]
+
+ /**
+ * If set to <code>false</code>, then each thumb can only be moved to the edge of
+ * the adjacent thumb.
+ * If <code>true</code>, then each thumb can be moved to any position on the track.
+ *
+ * @default false
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+ public var allowThumbOverlap:Boolean = false;
+
+ //----------------------------------
+ // allowTrackClick
+ //----------------------------------
+
+ [Inspectable(defaultValue="true")]
+
+ /**
+ * Specifies whether clicking on the track will move the slider thumb.
+ *
+ * @default true
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+ public var allowTrackClick:Boolean = true;
+
+ //----------------------------------
+ // dataTipFormatFunction
+ //----------------------------------
+
+ /**
+ * @private
+ */
+ private var _dataTipFormatFunction:Function;
+
+ /**
+ * Callback function that formats the data tip text.
+ * The function takes a single Number as an argument
+ * and returns a formatted String.
+ *
+ * <p>The function has the following signature:</p>
+ * <pre>
+ * 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>
+ * 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"));
+ * }
+ * </pre>
+ *
+ * @default undefined
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+ public function get dataTipFormatFunction():Function
+ {
+ return _dataTipFormatFunction;
+ }
+
+ /**
+ * @private
+ */
+ public function set dataTipFormatFunction(value:Function):void
+ {
+ _dataTipFormatFunction = value;
+ }
+
+ //----------------------------------
+ // direction
+ //----------------------------------
+
+ /**
+ * @private
+ */
+ private 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>In ActionScript, you use the following constants
+ * to set this property:
+ * <code>SliderDirection.VERTICAL</code> and
+ * <code>SliderDirection.HORIZONTAL</code>.</p>
+ *
+ * The HSlider and VSlider controls set this property for you;
+ * do not set it when using those controls.
+ *
+ * @default SliderDirection.HORIZONTAL
+ * @see mx.controls.sliderClasses.SliderDirection
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+ public function get direction():String
+ {
+ return _direction;
+ }
+
+ /**
+ * @private
+ */
+ public function set direction(value:String):void
+ {
+ _direction = value;
+ directionChanged = true;
+
+ invalidateProperties();
+ invalidateSize();
+ invalidateDisplayList();
+ }
+
+ //----------------------------------
+ // labels
+ //----------------------------------
+
+ /**
+ * @private
+ */
+ private var _labels:Array = [];
+
+ /**
+ * @private
+ */
+ private var labelsChanged:Boolean = false;
+
+ [Inspectable(category="General", arrayType="String", defaultValue="undefined")]
+
+ /**
+ * An array of strings used for the slider labels.
+ * Flex positions the labels at the beginning of the track,
+ * and spaces them evenly between the beginning of the track
+ * and the end of the track.
+ *
+ * <p>For example, if the array contains three items,
+ * the first item is placed at the beginning of the track,
+ * the second item in the middle, and the last item
+ * at the end of the track.</p>
+ *
+ * <p>If only one label is specified, it is placed at the
+ * beginning of the track.
+ * By default, labels are placed above the tick marks
+ * (if present) or above the track.
+ * To align the labels with the tick marks, make sure that
+ * the number of tick marks is equal to the number of labels.</p>
+ *
+ * @default undefined
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+ public function get labels():Array
+ {
+ return _labels;
+ }
+
+ /**
+ * @private
+ */
+ public function set labels(value:Array):void
+ {
+ _labels = value;
+ labelsChanged = true;
+
+ invalidateProperties();
+ invalidateSize();
+ invalidateDisplayList();
+ }
+
+ //----------------------------------
+ // liveDragging
+ //----------------------------------
+
+ [Inspectable(category="General", defaultValue="false")]
+
+ /**
+ * Specifies whether live dragging is enabled for the slider.
+ * If <code>false</code>, Flex sets the <code>value</code> and
+ * <code>values</code> properties and dispatches the <code>change</code>
+ * event when the user stops dragging the slider thumb.
+ * If <code>true</code>, Flex sets the <code>value</code> and
+ * <code>values</code> properties and dispatches the <code>change</code>
+ * event continuously as the user moves the thumb.
+ *
+ * @default false
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+ public var liveDragging:Boolean = false;
+
+ //----------------------------------
+ // maximum
+ //----------------------------------
+
+ /**
+ * @private
+ * Storage for the maximum property.
+ */
+ private var _maximum:Number = 10;
+
+ [Inspectable(category="General", defaultValue="10")]
+
+ /**
+ * The maximum allowed value on the slider.
+ *
+ * @default 10
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+ public function get maximum():Number
+ {
+ return _maximum;
+ }
+
+ /**
+ * @private
+ */
+ public function set maximum(value:Number):void
+ {
+ _maximum = value;
+ ticksChanged = true;
+ if (!initValues)
+ valuesChanged = true;
+
+ invalidateProperties();
+ invalidateDisplayList();
+ }
+
+ //----------------------------------
+ // minimum
+ //----------------------------------
+
+ /**
+ * @private
+ * Storage for the minimum property.
+ */
+ private var _minimum:Number = 0;
+
+ /**
+ * @private
+ */
+ private var minimumSet:Boolean = false;
+
+ [Inspectable(category="General", defaultValue="0")]
+
+ /**
+ * The minimum allowed value on the slider control.
+ *
+ * @default 0
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+ public function get minimum():Number
+ {
+ return _minimum;
+ }
+
+ /**
+ * @private
+ */
+ public function set minimum(value:Number):void
+ {
+ _minimum = value;
+ ticksChanged = true;
+
+ if (!initValues)
+ valuesChanged = true;
+
+ invalidateProperties();
+ invalidateDisplayList();
+ }
+
+ //----------------------------------
+ // showDataTip
+ //----------------------------------
+
+ [Inspectable(category="General", defaultValue="true")]
+
+ /**
+ * If set to <code>true</code>, show a data tip during user interaction
+ * containing the current value of the slider.
+ *
+ * @default true
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+ public var showDataTip:Boolean = true;
+
+ //----------------------------------
+ // sliderThumbClass
+ //----------------------------------
+
+ /**
+ * @private
+ */
+ //private var _thumbClass:Class = SliderThumb;
+
+ /**
+ * A reference to the class to use for each thumb.
+ *
+ * @default SliderThumb
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+ /* public function get sliderThumbClass():Class
+ {
+ return _thumbClass;
+ } */
+
+ /**
+ * @private
+ */
+ /* public function set sliderThumbClass(value:Class):void
+ {
+ _thumbClass = value;
+ thumbsChanged = true;
+
+ invalidateProperties();
+ invalidateDisplayList();
+ } */
+
+ //----------------------------------
+ // sliderDataTipClass
+ //----------------------------------
+
+ /**
+ * @private
+ */
+ //private var _sliderDataTipClass:Class = SliderDataTip;
+
+ /**
+ * A reference to the class to use for the data tip.
+ *
+ * @default SliderDataTip
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+ /* public function get sliderDataTipClass():Class
+ {
+ return _sliderDataTipClass;
+ } */
+
+ /**
+ * @private
+ */
+ /* public function set sliderDataTipClass(value:Class):void
+ {
+ _sliderDataTipClass = value;
+
+ invalidateProperties();
+ } */
+
+ //----------------------------------
+ // snapInterval
+ //----------------------------------
+
+ /**
+ * @private
+ */
+ private var _snapInterval:Number = 0;
+
+ /**
+ * @private
+ */
+ private var snapIntervalPrecision:int = -1;
+
+ /**
+ * @private
+ */
+ private var snapIntervalChanged:Boolean = false;
+
+ [Inspectable(category="General", defaultValue="0")]
+
+ /**
+ * Specifies the increment value of the slider thumb
+ * as the user moves the thumb.
+ * For example, if <code>snapInterval</code> is 2,
+ * the <code>minimum</code> value is 0,
+ * and the <code>maximum</code> value is 10,
+ * the thumb snaps to the values 0, 2, 4, 6, 8, and 10
+ * as the user move the thumb.
+ * A value of 0, means that the slider moves continuously
+ * between the <code>minimum</code> and <code>maximum</code> values.
+ *
+ * @default 0
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+ public function get snapInterval():Number
+ {
+ return _snapInterval;
+ }
+
+ /**
+ * @private
+ */
+ public function set snapInterval(value:Number):void
+ {
+ _snapInterval = value;
+
+ var parts:Array = (new String(1 + value)).split(".");
+ if (parts.length == 2)
+ snapIntervalPrecision = parts[1].length;
+ else
+ snapIntervalPrecision = -1;
+
+ if (!isNaN(value) && value != 0)
+ {
+ snapIntervalChanged = true;
+
+ invalidateProperties();
+ invalidateDisplayList();
+ }
+ }
+
+ //----------------------------------
+ // thumbCount
+ //----------------------------------
+
+ /**
+ * @private
+ * Storage for the thumbCount property.
+ */
+ private var _thumbCount:int = 1;
+
+ [Inspectable(category="General", defaultValue="1")]
+
+ /**
+ * The number of thumbs allowed on the slider.
+ * Possible values are 1 or 2.
+ * If set to 1, then the <code>value</code> property contains
+ * the current value of the slider.
+ * If set to 2, then the <code>values</code> property contains
+ * an array of values representing the value for each thumb.
+ *
+ * @default 1
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+ public function get thumbCount():int
+ {
+ return _thumbCount;
+ }
+
+ /**
+ * @private
+ */
+ public function set thumbCount(value:int):void
+ {
+ var numThumbs:int = (value > 2) ? 2 : value;
+ numThumbs = value < 1 ? 1 : value;
+
+ if (numThumbs != _thumbCount)
+ {
+ _thumbCount = numThumbs;
+ thumbsChanged = true;
+
+ initValues = true;
+
+ invalidateProperties();
+ invalidateDisplayList();
+ }
+ }
+
+ //----------------------------------
+ // thumbStyleFilters
+ //----------------------------------
+
+ /**
+ * Set of styles to pass from the Slider to the thumbs.
+ * @see mx.styles.StyleProxy
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+ protected function get thumbStyleFilters():Object
+ {
+ return null;
+ }
+ //----------------------------------
+ // tickInterval
+ //----------------------------------
+
+ /**
+ * @private
+ */
+ private var _tickInterval:Number = 0;
+
+ [Inspectable(category="General", defaultValue="0")]
+
+ /**
+ * The spacing of the tick marks relative to the <code>maximum</code> value
+ * of the control.
+ * Flex displays tick marks whenever you set the <code>tickInterval</code>
+ * property to a nonzero value.
+ *
+ * <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
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+ 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>
+ *
+ * @default undefined
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+ public function get tickValues():Array
+ {
+ return _tickValues;
+ }
+
+ /**
+ * @private
+ */
+ public function set tickValues(value:Array):void
+ {
+ _tickValues = value;
+ ticksChanged = true;
+
+ invalidateProperties();
+ invalidateDisplayList();
+ }
+
+ //----------------------------------
+ // value
+ //----------------------------------
+
+ [Bindable("change")]
+ [Bindable("valueCommit")]
+ [Inspectable(category="General", defaultValue="undefined")]
+
+ /**
+ * Contains the position of the thumb, and is a number between the
+ * <code>minimum</code> and <code>maximum</code> properties.
+ * Use the <code>value</code> property when <code>thumbCount</code> is 1.
+ * When <code>thumbCount</code> is greater than 1, use the
+ * <code>values</code> property instead.
+ * The default value is equal to the minimum property.
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+ /* 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.
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+ 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 (Slider.createAccessibilityImplementation != null)
+ Slider.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(UIComponent(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(UIComponent(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(UIComponent(highlightTrack));
+ highlightTrack = null;
+ }
+ }
+
+ if (directionChanged)
+ {
+ directionChanged = false;
+ var isHorizontal:Boolean = _direction == SliderDirection.HORIZONTAL;
+
+ if (isHorizontal)
+ {
+ UIComponent(innerSlider).rotation = 0;
+ }
+ else
+ {
+ UIComponent(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 (track is IUIComponent)
+ IUIComponent(track).enabled = enabled;
+
+ if (highlightTrack && highlightTrack is IUIComponent)
+ IUIComponent(highlightTrack).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
+ * the position of its labels, tick marks, and thumbs
+ * relative to the track.
+ * The height of the control is equivalent to the position
+ * of the bottom of the lowest element subtracted
+ * from the position of the top of the highest element.
+ * The width of a horizontal slider control defaults to 250 pixels.
+ * For a vertical slider control, the width and the length
+ * measurements are reversed.
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+ override protected function measure():void
+ {
+ super.measure();
+
+ /* var isHorizontal:Boolean = (direction == SliderDirection.HORIZONTAL);
+ var numLabels:int = labelObjects ? labelObjects.numChildren : 0;
+ var trackMargin:Number = getStyle("trackMargin");
+ var length:Number = DEFAULT_MEASURED_WIDTH;
+
+ if (!isNaN(trackMargin))
+ {
+ if (numLabels > 0)
+ {
+ length += (isHorizontal ?
+ SliderLabel(labelObjects.getChildAt(0)).getExplicitOrMeasuredWidth() / 2 :
+ SliderLabel(labelObjects.getChildAt(0)).getExplicitOrMeasuredHeight() / 2);
+ }
+ if (numLabels > 1)
+ {
+ length += (isHorizontal ?
+ SliderLabel(labelObjects.getChildAt(numLabels - 1)).getExplicitOrMeasuredWidth() / 2 :
+ SliderLabel(labelObjects.getChildAt(numLabels - 1)).getExplicitOrMeasuredHeight() / 2);
+ }
+ //length += track.width;
+ }
+
+ var bounds:Object = getComponentBounds();
+ var thickness:Number = bounds.lower - bounds.upper;
+
+ measuredMinWidth = measuredWidth = isHorizontal ? length : thickness;
+ measuredMinHeight = measuredHeight = isHorizontal ? thickness : length; */
+ }
+
+ /**
+ * Positions the elements of the control.
+ * The track, thumbs, labels, and tick marks are all positioned
+ * and sized by this method.
+ * The track is sized based on the length of the labels and on the track margin.
+ * If you specify a <code>trackMargin</code>, then the size of the track
+ * is equal to the available width minus the <code>trackMargin</code> times 2.
+ *
+ * <p>Tick marks are spaced at even intervals along the track starting from the beginning of the track. An additional tick mark is placed
+ * at the end of the track if one doesn't already exist (if the tick interval isn't a factor of the maximum value). The tick mark
+ * y-position is based on the <code>tickOffset</code>. An offset of 0 places the bottom of the tick at the top of the track. Negative offsets
+ * move the ticks upwards while positive offsets move them downward through the track.</p>
+ *
+ * <p>Labels are positioned at even intervals along the track. The labels are always horizontally centered above their
+ * interval position unless the <code>trackMargin</code> setting is too small. If you specify a <code>trackMargin</code>, then the first and last labels will
+ * position themselves at the left and right borders of the control. Labels will not crop or resize themselves if they overlap,
+ * so be sure to allow enough space for them to fit on the track. The y-position is based on the <code>labelOffset</code> property. An offset of 0
+ * places the bottom of the label at the top of the track. Unlike tick marks, the labels can not be positioned to overlap the track.
+ * If the offset is a positive number, then the top of the label will be positioned below the bottom of the track.</p>
+ *
+ * <p>The thumbs are positioned to overlap the track. Their x-position is determined by their value. The y-position is
+ * controlled by the <code>thumbOffset</code> property. An offset of 0 places the center of the thumb at the center of the track. A negative
+ * offset moves the thumbs upwards while a positive offset moves the thumbs downwards.</p>
+ *
+ * <p>The placement of the tick marks, labels and thumbs are all independent from each other. They will not attempt to reposition
+ * themselves if they overlap.</p>
+ *
+ * <p>For a vertical slider control, the same rules apply. In the above description, substitute width for height, height for width,
+ * left for up or top, right for down or bottom, x-position for y-position, and y-position for x-position.</p>
+ *
+ * @param unscaledWidth Specifies the width of the component, in pixels,
+ * in the component's coordinates, regardless of the value of the
+ * <code>scaleX</code> property of the component.
+ *
+ * @param unscaledHeight Specifies the height of the component, in pixels,
+ * in the component's coordinates, regardless of the value of the
+ * <code>scaleY</code> property of the component.
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+ override protected function updateDisplayList(unscaledWidth:Number,
+ unscaledHeight:Number):void
+ {
+ super.updateDisplayList(unscaledWidth, unscaledHeight);
+
+// graphics.beginFill(0xEEEEEE);
+// graphics.drawRect(0, 0, unscaledWidth, unscaledHeight);
+// graphics.endFill();
+
+ /* var isHorizontal:Boolean = (_direction == SliderDirection.HORIZONTAL);
+ var numLabels:int = labelObjects ? labelObjects.numChildren : 0;
+ var trackMargin:Number = getStyle("trackMargin");
+ var firstThumbWidth:Number = 6;
+ var firstThumbHeight:Number = 0;
+ var firstThumb:SliderThumb;
+
+ if (thumbs && thumbs.numChildren > 0)
+ firstThumb = SliderThumb(thumbs.getChildAt(0));
+
+ if (thumbs && firstThumb) {
+ firstThumbWidth = firstThumb.getExplicitOrMeasuredWidth();
+ firstThumbHeight = firstThumb.getExplicitOrMeasuredHeight();
+ }
+
+ var trackLeftOffset:Number = firstThumbWidth / 2; // Enough space for the thumb to rest at the edges
+ var trackRightOffset:Number = trackLeftOffset;
+
+ var availSpace:Number;
+
+ var firstLabelSize:Number = 0;
+ if (numLabels > 0)
+ {
+ var firstLabel:SliderLabel =
+ SliderLabel(labelObjects.getChildAt(0));
+
+ firstLabelSize = isHorizontal ?
+ firstLabel.getExplicitOrMeasuredWidth() :
+ firstLabel.getExplicitOrMeasuredHeight();
+ }
+
+ var lastLabelSize:Number = 0;
+ if (numLabels > 1)
+ {
+ var lastLabel:SliderLabel =
+ SliderLabel(labelObjects.getChildAt(numLabels - 1));
+ lastLabelSize = isHorizontal ?
+ lastLabel.getExplicitOrMeasuredWidth():
+ lastLabel.getExplicitOrMeasuredHeight();
+ }
+
+ if (!isNaN(trackMargin))
+ availSpace = trackMargin;
+ else
+ availSpace = (firstLabelSize + lastLabelSize) / 2;
+
+ if (numLabels > 0)
+ {
+ if (!isNaN(trackMargin))
+ {
+ trackLeftOffset = Math.max(trackLeftOffset,
+ availSpace / (numLabels > 1 ? 2 : 1));
+ }
+ else
+ {
+ trackLeftOffset = Math.max(trackLeftOffset, firstLabelSize / 2);
+ }
+ }
+ else
+ {
+
+ trackLeftOffset = Math.max(trackLeftOffset, availSpace / 2);
+ }
+
+ var bounds:Object = getComponentBounds();
+
+ //track.x = Math.round(trackLeftOffset);
+
+ var trackY:Number = (((isHorizontal ? unscaledHeight : unscaledWidth) -
+ (Number(bounds.lower) - Number(bounds.upper))) / 2) - Number(bounds.upper);
+
+ track.move(Math.round(trackLeftOffset), Math.round(trackY));
+ track.setActualSize((isHorizontal ? unscaledWidth: unscaledHeight) - (trackLeftOffset * 2), track.height);
+
+ // Layout the thumbs' y positions.
+ var tY:Number = track.y +
+ (track.height - firstThumbHeight) / 2 +
+ getStyle("thumbOffset");
+
+ var n:int = _thumbCount;
+ for (var i:int = 0; i < n; i++)
+ {
+ var currentThumb:SliderThumb = SliderThumb(thumbs.getChildAt(i));
+ currentThumb.move(currentThumb.x, tY);
+ currentThumb.visible = true;
+ currentThumb.setActualSize(currentThumb.getExplicitOrMeasuredWidth(),
+ currentThumb.getExplicitOrMeasuredHeight());
+ }
+
+ var g:Graphics = trackHitArea.graphics;
+
+ var tLength:Number = 0
+ if (_tickInterval > 0 || (_tickValues && _tickValues.length > 0))
+ tLength = getStyle("tickLength");
+ g.clear();
+ g.beginFill(0,0);
+ g.drawRect(track.x,
+ track.y - firstThumbHeight/2 - tLength,
+ track.width,
+ track.height + firstThumbHeight + tLength);
+ g.endFill();
+
+ if (_direction != SliderDirection.HORIZONTAL)
+ innerSlider.y = unscaledHeight;
+
+ layoutTicks();
+
+ layoutLabels();
+
+ setPosFromValue(); // use the value to position the thumb's x
+
+ drawTrackHighlight(); */
+ }
+
+ //--------------------------------------------------------------------------
+ //
+ // Methods
+ //
+ //--------------------------------------------------------------------------
+
+ /**
+ * @private
+ */
+ /* private function createBackgroundTrack():void
+ {
+ if (!track)
+ {
+ var trackSkinClass:Class = getStyle("trackSkin");
+
+ track = new trackSkinClass();
+
+ if (track is ISimpleStyleClient)
+ ISimpleStyleClient(track).styleName = this;
+
+ if (track is IUIComponent)
+ IUIComponent(track).enabled = enabled;
+
+ innerSlider.addChildAt(UIComponent(track),0);
+ }
+ } */
+
+ /**
+ * @private
+ */
+ /* private function createHighlightTrack():void
+ {
+ var showTrackHighlight:Boolean = getStyle("showTrackHighlight");
+ if (!highlightTrack && showTrackHighlight)
+ {
+ var trackHighlightClass:Class =
+ getStyle("trackHighlightSkin");
+ highlightTrack = new trackHighlightClass();
+
+ if (highlightTrack is ISimpleStyleClient)
+ ISimpleStyleClient(highlightTrack).styleName = this;
+
+ if (highlightTrack is IUIComponent)
+ IUIComponent(highlightTrack).enabled = enabled;
+
+ innerSlider.addChildAt(UIComponent(highlightTrack),
+ innerSlider.getChildIndex(UIComponent(track)) + 1);
+ }
+ } */
+
+ /**
+ * @private
+ */
+ /* private function createThumbs():void
+ {
+ var n:int;
+ var i:int;
+
+ // Delete all thumb children
+ if (thumbs)
+ {
+ n = thumbs.numChildren;
+ for (i = n - 1; i >= 0; i--)
+ {
+ // we don't need to bother to remove the event listeners here
+ // they will be removed by the garbage collector automatically
+ thumbs.removeChildAt(i);
+ }
+ }
+ else
+ {
+ thumbs = new UIComponent();
+ thumbs.tabChildren = true;
+ thumbs.tabEnabled = false;
+ thumbs.tabFocusEnabled = false;
+ innerSlider.addChild(thumbs);
+ }
+
+ var thumb:SliderThumb; // We want to force the thumb to be a subclass of SliderThumb
+
+ n = _thumbCount;
+ for (i = 0; i < n; i++)
+ {
+ thumb = SliderThumb(new _thumbClass());
+
+ thumb.owner = this;
+ thumb.styleName = new StyleProxy(this, thumbStyleFilters);
+ thumb.thumbIndex = i;
+ thumb.visible = true;
+ thumb.enabled = enabled;
+
+ thumb.upSkinName = "thumbUpSkin";
+ thumb.downSkinName = "thumbDownSkin";
+ thumb.disabledSkinName = "thumbDisabledSkin";
+ thumb.overSkinName = "thumbOverSkin";
+ thumb.skinName = "thumbSkin";
+
+ thumbs.addChild(thumb);
+
+ thumb.addEventListener(FocusEvent.FOCUS_IN,
+ thumb_focusInHandler);
+ thumb.addEventListener(FocusEvent.FOCUS_OUT,
+ thumb_focusOutHandler);
+ }
+ } */
+
+ /**
+ * @private
+ */
+ /* private function createLabels():void
+ {
+ var labelObj:SliderLabel;
+
+ if (labelObjects)
+ {
+ for (var i:int = labelObjects.numChildren - 1; i >= 0; i--)
+ {
+ labelObjects.removeChildAt(i);
+ }
+ }
+ else
+ {
+ labelObjects = new UIComponent();
+ innerSlider.addChildAt(labelObjects, innerSlider.getChildIndex(trackHitArea));
+ }
+
+ if (_labels)
+ {
+ var numLabels:int = _labels.length;
+
+ for (var j:int = 0; j < numLabels; j++)
+ {
+ labelObj = new SliderLabel();
+
+ labelObj.text = _labels[j] is String ?
+ _labels[j] :
+ _labels[j].toString();
+
+ if (_direction != SliderDirection.HORIZONTAL)
+ labelObj.rotation = 90;
+
+ var labelStyleName:String = getStyle("labelStyleName");
+ if (labelStyleName)
+ labelObj.styleName = labelStyleName;
+
+ labelObjects.addChild(labelObj);
+ }
+ }
+ } */
+
+ /**
+ * @private
+ */
+ /* private function createTicks():void
+ {
+ if (!ticks)
+ {
+ ticks = new UIComponent();
+
+ innerSlider.addChild(ticks);
+ }
+ } */
+
+ /**
+ * @private
+ */
+ /* private function getComponentBounds():Object
+ {
+ var isHorizontal:Boolean = (direction == SliderDirection.HORIZONTAL);
+ var numLabels:int = labelObjects ? labelObjects.numChildren : 0;
+ var labelY:Number;
+ var labelSize:Number = 0;
+ var thumbY:Number;
+ var upperBound:Number = 0;
+ var lowerBound:Number = track.height;
+
+ if (numLabels > 0)
+ {
+ var sliderLabel:SliderLabel =
+ SliderLabel(labelObjects.getChildAt(0));
+
+ if (isHorizontal)
+ {
+ labelSize = sliderLabel.getExplicitOrMeasuredHeight();
+ }
+ else
+ {
+ for (var i:int = 0; i < numLabels; i++)
+ {
+ sliderLabel = SliderLabel(labelObjects.getChildAt(i));
+ labelSize = Math.max(labelSize,
+ sliderLabel.getExplicitOrMeasuredWidth());
+ }
+ }
+
+ var labOffset:Number = getStyle("labelOffset");
+ labelY = labOffset - (labOffset > 0 ? 0 : labelSize);
+
+ upperBound = Math.min(upperBound, labelY);
+ lowerBound = Math.max(lowerBound, labOffset + (labOffset > 0 ? labelSize : 0));
+ }
+
+ if (ticks)
+ {
+ var tLen:Number = getStyle("tickLength");
+ var tOff:Number = getStyle("tickOffset");
+
+ upperBound = Math.min(upperBound, tOff - tLen);
+ lowerBound = Math.max(lowerBound, tOff);
+ }
+
+ if (thumbs && thumbs.numChildren > 0)
+ {
+ thumbY = (track.height - SliderThumb(thumbs.getChildAt(0)).getExplicitOrMeasuredHeight()) / 2 +
+ getStyle("thumbOffset");
+
+ upperBound = Math.min(upperBound, thumbY);
+ lowerBound = Math.max(lowerBound, thumbY + SliderThumb(thumbs.getChildAt(0)).getExplicitOrMeasuredHeight());
+ }
+
+ return { lower: lowerBound, upper: upperBound };
+ } */
+
+ /**
+ * @private
+ */
+/* private function layoutTicks():void
+ {
+ if (ticks)
+ {
+ var g:Graphics = ticks.graphics;
+ var tLength:Number = getStyle("tickLength");
+ var tOffset:Number = getStyle("tickOffset");
+ var tickWidth:Number = getStyle("tickThickness");
+ var xPos:Number;
+ var tColor:Number = getStyle("tickColor");
+
+ var usePositions:Boolean = _tickValues && _tickValues.length > 0 ? true : false;
+ var positionIndex:int = 0;
+ var val:Number = usePositions ? _tickValues[positionIndex++] : minimum;
+
+ g.clear();
+
+ if (_tickInterval > 0 || usePositions)
+ {
+ g.lineStyle(tickWidth,tColor,100);
+
+ do
+ {
+ xPos = Math.round(getXFromValue(val));
+ g.moveTo(xPos, tLength);
+ g.lineTo(xPos, 0);
+ val = usePositions ? (positionIndex < _tickValues.length ? _tickValues[positionIndex++] : NaN) : _tickInterval + val;
+ } while (val < maximum || (usePositions && positionIndex < _tickValues.length))
+
+ // draw the last tick
+ if (!usePositions || val == maximum)
+ {
+ xPos = track.x + track.width - 1;
+ g.moveTo(xPos, tLength);
+ g.lineTo(xPos, 0);
+ }
+
+ ticks.y = Math.round(track.y + tOffset - tLength);
+ }
+ }
+ } */
+
+ /**
+ * @private
+ */
+/* private function layoutLabels():void
+ {
+ var numLabels:Number = labelObjects ? labelObjects.numChildren : 0;
+ var availSpace:Number;
+
+ if (numLabels > 0)
+ {
+ var labelInterval:Number = track.width / (numLabels - 1);
+ // The amount of space we have available for the labels to hang past the track
+ availSpace = Math.max((_direction == SliderDirection.HORIZONTAL ?
+ unscaledWidth :
+ unscaledHeight) - track.width,
+ SliderThumb(thumbs.getChildAt(0)).getExplicitOrMeasuredWidth());
+
+ var labelPos:Number;
+ var left:Number = track.x;
+ var curLabel:Object;
+
+ for (var i:int = 0; i < numLabels; i++)
+ {
+ curLabel = labelObjects.getChildAt(i);
+ curLabel.setActualSize(curLabel.getExplicitOrMeasuredWidth(), curLabel.getExplicitOrMeasuredHeight());
+
+ var yPos:Number = track.y - curLabel.height + getStyle("labelOffset");
+
+ if (_direction == SliderDirection.HORIZONTAL)
+ {
+ labelPos = curLabel.getExplicitOrMeasuredWidth() / 2;
+
+ if (i == 0)
+ labelPos = Math.min(labelPos, availSpace / (numLabels > Number(1) ? Number(2) : Number(1)));
+ else if (i == (numLabels - 1))
+ labelPos = Math.max(labelPos, curLabel.getExplicitOrMeasuredWidth() - availSpace / 2);
+
+ curLabel.move(left - labelPos,yPos);
+ }
+ else
+ {
+ var labelOff:Number = getStyle("labelOffset");
+
+ labelPos = curLabel.getExplicitOrMeasuredHeight() / 2;
+
+ if (i == 0)
+ labelPos = Math.max(labelPos, curLabel.getExplicitOrMeasuredHeight() - availSpace / (numLabels > Number(1) ? Number(2) : Number(1)));
+ else if (i == (numLabels-1))
+ labelPos = Math.min(labelPos,availSpace / 2);
+
+ curLabel.move(left + labelPos,track.y + labelOff +
+ (labelOff > 0 ? 0 : -curLabel.getExplicitOrMeasuredWidth()));
+ }
+ left += labelInterval;
+ }
+ }
+ } */
+
+ /**
+ * @private
+ */
+ /* mx_internal function drawTrackHighlight():void
+ {
+ if (highlightTrack)
+ {
+ var xPos:Number;
+ var tWidth:Number;
+
+ var firstThumb:SliderThumb = SliderThumb(thumbs.getChildAt(0));
+
+ if (_thumbCount > 1)
+ {
+ xPos = firstThumb.xPosition;
+ var secondThumb:SliderThumb = SliderThumb(thumbs.getChildAt(1));
+ tWidth = secondThumb.xPosition - firstThumb.xPosition;
+ }
+ else
+ {
+ xPos = track.x;
+ tWidth = firstThumb.xPosition - xPos;
+ }
+
+
+ highlightTrack.move(xPos, track.y + 1);
+ highlightTrack.setActualSize(tWidth > 0 ? tWidth : 0, highlightTrack.height);
+ }
+ } */
+
+ /**
+ * @private
+ * Helper function that starts the dataTip and dispatches the press event.
+ */
+/* mx_internal function onThumbPress(thumb:Object):void
+ {
+ if (showDataTip)
+ {
+ // Setup number formatter
+ dataFormatter = new NumberFormatter();
+ dataFormatter.precision = getStyle("dataTipPrecision");
+
+ if (!dataTip)
+ {
+ dataTip = SliderDataTip(new sliderDataTipClass());
+ systemManager.toolTipChildren.addChild(dataTip);
+
+ var dataTipStyleName:String = getStyle("dataTipStyleName");
+ if (dataTipStyleName)
+ {
+ dataTip.styleName = dataTipStyleName;
+ }
+ }
+
+ var formattedVal:String;
+ if (_dataTipFormatFunction != null)
+ {
+ formattedVal = this._dataTipFormatFunction(
+ getValueFromX(thumb.xPosition));
+ }
+ else
+ {
+ formattedVal = dataFormatter.format(getValueFromX(thumb.xPosition));
+ }
+
+ dataTip.text = formattedVal;
+
+ // Tool tip has been freshly created and new text assigned to it.
+ // Hence force a validation so that we can set the
+ // size required to show the text completely.
+ dataTip.validateNow();
+ dataTip.setActualSize(dataTip.getExplicitOrMeasuredWidth(),dataTip.getExplicitOrMeasuredHeight());
+ positionDataTip(thumb);
+ }
+ keyInteraction = false;
+
+ var event:SliderEvent = new SliderEvent(SliderEvent.THUMB_PRESS);
+ event.value = getValueFromX(thumb.xPosition);;
+ event.thumbIndex = thumb.thumbIndex;
+ dispatchEvent(event);
+ } */
+
+ /**
+ * @private
+ */
+ /* mx_internal function onThumbRelease(thumb:Object):void
+ {
+ interactionClickTarget = SliderEventClickTarget.THUMB;
+
+ destroyDataTip();
+
+ setValueFromPos(thumb.thumbIndex);
+
+ dataFormatter = null;
+
+ var event:SliderEvent = new SliderEvent(SliderEvent.THUMB_RELEASE);
+ event.value = getValueFromX(thumb.xPosition);;
+ event.thumbIndex = thumb.thumbIndex;
+ dispatchEvent(event);
+ } */
+
+ /**
+ * @private
+ */
+ /* mx_internal function onThumbMove(thumb:Object):void
+ {
+ var value:Number = getValueFromX(thumb.xPosition);
+
+ if (showDataTip)
+ {
+ dataTip.text = _dataTipFormatFunction != null ?
+ _dataTipFormatFunction(value) :
+ dataFormatter.format(value);
+
+ dataTip.setActualSize(dataTip.getExplicitOrMeasuredWidth(),
+ dataTip.getExplicitOrMeasuredHeight());
+
+ positionDataTip(thumb);
+ }
+
+ if (liveDragging)
+ {
+ interactionClickTarget = SliderEventClickTarget.THUMB;
+ setValueAt(value, thumb.thumbIndex);
+ }
+
+ var event:SliderEvent = new SliderEvent(SliderEvent.THUMB_DRAG);
+ event.value = value;
+ event.thumbIndex = thumb.thumbIndex;
+ dispatchEvent(event);
+ } */
+
+ /**
+ * @private
+ */
+ /* private function positionDataTip(thumb:Object):void
+ {
+ var relX:Number;
+ var relY:Number;
+
+ var tX:Number = thumb.x;
+ var tY:Number = thumb.y;
+
+ var tPlacement:String = getStyle("dataTipPlacement");
+ var tOffset:Number = getStyle("dataTipOffset");
+
+ // If the layoutDirection is rtl, swap left and right placement
+ if (layoutDirection == LayoutDirection.RTL)
+ {
+ if (tPlacement == "left")
+ tPlacement = "right";
+ else if (tPlacement == "right")
+ tPlacement = "left";
+ }
+
+ // Need to special case tooltip position because the tooltip movieclip
+ // resides in the root movie clip, instead of the Slider movieclip
+ if (_direction == SliderDirection.HORIZONTAL)
+ {
+ relX = tX;
+ relY = tY;
+
+ if (tPlacement == "left")
+ {
+ relX -= tOffset + dataTip.width;
+ relY += (thumb.height - dataTip.height) / 2;
+ }
+ else if (tPlacement == "right")
+ {
+ relX += tOffset + thumb.width;
+ relY += (thumb.height - dataTip.height) / 2;
+ }
+ else if (tPlacement == "top")
+ {
+ relY -= tOffset + dataTip.height;
+ relX -= (dataTip.width - thumb.width) / 2;
+ }
+ else if (tPlacement == "bottom")
+ {
+ relY += tOffset + thumb.height;
+ relX -= (dataTip.width - thumb.width) / 2;
+ }
+ }
+ else
+ {
+ relX = tY;
+ relY = unscaledHeight - tX - (dataTip.height + thumb.width) / 2;
+
+ if (tPlacement == "left")
+ {
+ relX -= tOffset + dataTip.width;
+ }
+ else if (tPlacement == "right")
+ {
+ relX += tOffset + thumb.height;
+ }
+ else if (tPlacement == "top")
+ {
+ relY -= tOffset + (dataTip.height + thumb.width) / 2;
+ relX -= (dataTip.width - thumb.height) / 2;
+ }
+ else if (tPlacement == "bottom")
+ {
+ relY += tOffset + (dataTip.height + thumb.width) / 2;
+ relX -= (dataTip.width - thumb.height) / 2;
+ }
+ }
+
+ if (layoutDirection == LayoutDirection.RTL)
+ relX += dataTip.width;
+
+ var o:Point = new Point(relX, relY);
+ var r:Point = localToGlobal(o);
+ r = dataTip.parent.globalToLocal(r);
+
+ dataTip.x = r.x < 0 ? 0 : r.x;
+ dataTip.y = r.y < 0 ? 0 : r.y;
+ } */
+
+ /**
+ * @private
+ */
+/* private function destroyDataTip():void
+ {
+ if (dataTip)
+ {
+ systemManager.toolTipChildren.removeChild(dataTip);
+ dataTip = null;
+ }
+ } */
+
+ /**
+ * @private
+ * Utility for finding the x position which corresponds
+ * to the given value.
+ */
+ /* mx_internal function getXFromValue(v:Number):Number
+ {
+ var val:Number;
+
+ if (v == minimum)
+ val = track.x;
+ else if (v == maximum)
+ val = track.x + track.width;
+ else
+ val = track.x + (v - minimum) * (track.width) / (maximum - minimum);
+
+ return val;
+ } */
+
+ /**
+ * @private
+ */
+/* mx_internal function getXBounds(selectedThumbIndex:int):Object
+ {
+ var maxX:Number = track.x + track.width;
+ var minX:Number = track.x;
+ if (allowThumbOverlap)
+ {
+ return { max: maxX, min: minX };
+ }
+
+ var minBound:Number = NaN;
+ var maxBound:Number = NaN;
+
+ var prevThumb:SliderThumb =
+ selectedThumbIndex > 0 ?
+ SliderThumb(thumbs.getChildAt(selectedThumbIndex - 1)) :
+ null;
+
+ var nextThumb:SliderThumb =
+ selectedThumbIndex + 1 < thumbs.numChildren ?
+ SliderThumb(thumbs.getChildAt(selectedThumbIndex + 1)) :
+ null;
+
+ if (prevThumb)
+ minBound = prevThumb.xPosition + prevThumb.width / 2;
+
+ if (nextThumb)
+ maxBound = nextThumb.xPosition - nextThumb.width / 2;
+
+ if (isNaN(minBound))
+ minBound = minX;
+ else
+ minBound = Math.min(Math.max(minX,minBound),maxX);
+
+ if (isNaN(maxBound))
+ maxBound = maxX;
+ else
+ maxBound = Math.max(Math.min(maxX, maxBound),minX);
+
+ return { max: maxBound, min: minBound };
+ } */
+
+ /**
+ * @private
+ * Utility for positioning the thumb(s) from the current value.
+ */
+ /* private function setPosFromValue():void
+ {
+ var n:int = _thumbCount;
+ for (var i:int = 0; i < n; i++)
+ {
+ var thumb:SliderThumb = SliderThumb(thumbs.getChildAt(i));
+ thumb.xPosition = getXFromValue(values[i]);
+ }
+ } */
+
+ /**
+ * @private
+ * Utility for getting a value corresponding to a given x.
+ */
+/* mx_internal function getValueFromX(xPos:Number):Number
+ {
+ var v:Number = (xPos - track.x) *
+ (maximum - minimum) /
+ (track.width) + minimum;
+
+ var threshold:Number = (maximum - minimum) / 1000;
+
+ // kill rounding error at the edges.
+ if (v - minimum <= threshold)
+ {
+ v = minimum;
+ }
+ else if (maximum - v <= threshold)
+ {
+ v = maximum;
+ }
+ else if (!isNaN(_snapInterval) && _snapInterval != 0)
+ {
+ v = Math.round((v - minimum) / _snapInterval) *
+ _snapInterval + minimum;
+ }
+
+ return v;
+ } */
+
+ /**
+ * @private
+ * Utility for committing a value of a given thumb.
+ */
+ /* private function setValueFromPos(thumbIndex:int):void
+ {
+ var thumb:SliderThumb = SliderThumb(thumbs.getChildAt(thumbIndex));
+ setValueAt(getValueFromX(thumb.xPosition), thumbIndex);
+ } */
+
+ /**
+ * @private
+ */
+ /* mx_internal function getSnapValue(value:Number, thumb:SliderThumb = null):Number
+ {
+ if (!isNaN(_snapInterval) && _snapInterval != 0)
+ {
+ var val:Number = getValueFromX(value);
+
+ if (thumb && (thumbs.numChildren > 1) && !allowThumbOverlap)
+ {
+ var check_bounds:Boolean = true;
+ var bounds:Object
+
+ bounds = getXBounds(thumb.thumbIndex);
+
+ var prevThumb:SliderThumb =
+ thumb.thumbIndex > 0 ?
+ SliderThumb(thumbs.getChildAt(thumb.thumbIndex- 1)) :
+ null;
+
+ var nextThumb:SliderThumb =
+ thumb.thumbIndex + 1 < thumbs.numChildren ?
+ SliderThumb(thumbs.getChildAt(thumb.thumbIndex + 1)) :
+ null;
+
+ if (prevThumb)
+ {
+ bounds.min -= (prevThumb.width / 2);
+ // check if thumb is at minimum, if not we can ignore the bounds logic
+ if (val == minimum)
+ if (getValueFromX((prevThumb.xPosition - prevThumb.width/2)) != minimum)
+ check_bounds = false;
+ }
+ else
+ {
+ if (val == minimum)
+ check_bounds = false;
+ }
+
+ if (nextThumb)
+ {
+ bounds.max += (nextThumb.width / 2);
+ // check if thumb is at maximum, if not we can ignore the bounds logic
+ if (val == maximum)
+ if (getValueFromX((nextThumb.xPosition + nextThumb.width/2)) != maximum)
+ check_bounds = false;
+ }
+ else
+ {
+ if (val == maximum)
+ check_bounds = false;
+ }
+ if (check_bounds)
+ val = Math.min(Math.max(val, getValueFromX(Math.round(bounds.min)) + _snapInterval),
+ getValueFromX(Math.round(bounds.max)) - _snapInterval);
+
+ }
+ return getXFromValue(val);
+ }
+
+ return value;
+ } */
+
+ /**
+ * @private Accessed by the Thumb to find out the snap interval
+ */
+ /* mx_internal function getSnapIntervalWidth():Number
+ {
+ return _snapInterval * track.width / (maximum - minimum);
+ } */
+
+ /**
+ * @private
+ */
+ /* mx_internal function updateThumbValue(thumbIndex:int):void
+ {
+ setValueFromPos(thumbIndex);
+ } */
+
+ /**
+ * Returns the thumb object at the given index. Use this method to
+ * style and customize individual thumbs in a slider control.
+ *
+ * @param index The zero-based index number of the thumb.
+ *
+ * @return A reference to the SliderThumb object.
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+ /* public function getThumbAt(index:int):SliderThumb
+ {
+ return index >= 0 && index < thumbs.numChildren ?
+ SliderThumb(thumbs.getChildAt(index)) :
+ null;
+ } */
+
+ /**
+ * This method sets the value of a slider thumb, and updates the display.
+ *
+ * @param index The zero-based index number of the thumb to set
+ * the value of, where a value of 0 corresponds to the first thumb.
+ *
+ * @param value The value to set the thumb to
+ *
+ * @langversion 3.0
+ * @playerversion Flash 9
+ * @playerversion AIR 1.1
+ * @productversion Flex 3
+ */
+ /* public function setThumbValueAt(index:int, value:Number):void
+ {
+ setValueAt(value, index, true);
+ valuesChanged = true;
+
+ invalidateProperties();
+ invalidateDisplayList();
+ } */
+
+ /**
+ * @private
+ */
+ /* private function setValueAt(value:Number, index:int,
+ isProgrammatic:Boolean = false):void
+ {
+ var oldValue:Number = _values[index];
+ var threshold:Number = (maximum - minimum) / 1000;
+
+ // we need to do the round of (to remove the floating point error)
+ // if the stepSize had a fractional value
+ if (snapIntervalPrecision != -1)
+ {
+ var scale:Number = Math.pow(10, snapIntervalPrecision);
+ value = Math.round(value * scale) / scale;
+ }
+
+ _values[index] = value;
+
+ if (!isProgrammatic)
+ {
+ var event:SliderEvent = new SliderEvent(SliderEvent.CHANGE);
+ event.value = value;
+ event.thumbIndex = index;
+ event.clickTarget = interactionClickTarget;
+ //set the triggerEvent correctly
+ if (keyInteraction)
+ {
+ event.triggerEvent = new KeyboardEvent(KeyboardEvent.KEY_DOWN);
+ //reset to mouse default
+ keyInteraction = false;
+ }
+ else
+ {
+ event.triggerEvent = new MouseEvent(MouseEvent.CLICK);
+ }
+
+ if (!isNaN(oldValue))
+ {
+ if (Math.abs(oldValue - value) > threshold)
+ dispatchEvent(event)
+ }
+ // Handle case of changing from NaN to a valid value
+ else if (!isNaN(value))
+ {
+ dispatchEvent(event);
+ }
+ }
+
+ invalidateDisplayList();
+ } */
+
+ /**
+ * @private
+ */
+ /* mx_internal function registerMouseMove(listener:Function):void
+ {
+ innerSlider.addEventListener(MouseEvent.MOUSE_MOVE, listener);
+ } */
+
+ /**
+ * @private
+ */
+ /* mx_internal function unRegisterMouseMove(listener:Function):void
+ {
+ innerSlider.removeEventListener(MouseEvent.MOUSE_MOVE, listener);
+ } */
+
+ //--------------------------------------------------------------------------
+ //
+ // Event handlers
+ //
+ //--------------------------------------------------------------------------
+
+ /**
+ * @private
+ * Move the thumb when pressed.
+ */
+ /* private function track_mouseDownHandler(event:MouseEvent):void
+ {
+ if (event.target != trackHitArea && event.target != ticks)
+ return;
+ if (enabled && allowTrackClick)
+ {
+ interactionClickTarget = SliderEventClickTarget.TRACK;
+ //this is a mouse event
+ keyInteraction = false;
+ var pt:Point = new Point(event.localX, event.localY);
+ var xM:Number = pt.x;
+ var minIndex:Number = 0;
+ var minDistance:Number = 10000000;
+
+ // find the nearest thumb
+ var n:int = _thumbCount;
+ for (var i:int = 0; i < n; i++)
+ {
+ var d:Number = Math.abs(SliderThumb(thumbs.getChildAt(i)).xPosition - xM);
+ if (d < minDistance)
+ {
+ minIndex = i;
+ minDistance = d;
+ }
+ }
+ var thumb:SliderThumb = SliderThumb(thumbs.getChildAt(minIndex));
+ if (!isNaN(_snapInterval) && _snapInterval != 0)
+ xM = getXFromValue(getValueFromX(xM));
+
+ var duration:Number = getStyle("slideDuration");
+ var t:Tween = new Tween(thumb, thumb.xPosition, xM, duration);
+
+ var easingFunction:Function = getStyle("slideEasingFunction") as Function;
+ if (easingFunction != null)
+ t.easingFunction = easingFunction;
+
+ drawTrackHighlight();
+ }
+ } */
+
+ /**
+ * @private
+ */
+ private function thumb_focusInHandler(event:mx.events.FocusEvent):void
+ {
+ //dispatchEvent(event);
+ }
+
+ /**
+ * @private
+ */
+ private function thumb_focusOutHandler(event:mx.events.FocusEvent):void
+ {
+ //dispatchEvent(event);
+ }
+
+ /**
+ * @private
+ */
+ mx_internal function getTrackHitArea():UIComponent
+ {
+ return trackHitArea;
+ }
+
+}
+
+}