home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Darbas / kidoz_v1.air / kidoz.swf / scripts / mx / controls / scrollClasses / ScrollBar.as next >
Encoding:
Text File  |  2009-05-06  |  24.1 KB  |  640 lines
  1. package mx.controls.scrollClasses
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.events.Event;
  5.    import flash.events.MouseEvent;
  6.    import flash.events.TimerEvent;
  7.    import flash.geom.Point;
  8.    import flash.ui.Keyboard;
  9.    import flash.utils.Timer;
  10.    import mx.controls.Button;
  11.    import mx.core.FlexVersion;
  12.    import mx.core.UIComponent;
  13.    import mx.core.mx_internal;
  14.    import mx.events.FlexEvent;
  15.    import mx.events.SandboxMouseEvent;
  16.    import mx.events.ScrollEvent;
  17.    import mx.events.ScrollEventDetail;
  18.    import mx.styles.ISimpleStyleClient;
  19.    import mx.styles.StyleProxy;
  20.    
  21.    use namespace mx_internal;
  22.    
  23.    public class ScrollBar extends UIComponent
  24.    {
  25.       mx_internal static const VERSION:String = "3.2.0.3958";
  26.       
  27.       public static const THICKNESS:Number = 16;
  28.       
  29.       private var _direction:String = "vertical";
  30.       
  31.       private var _pageScrollSize:Number = 0;
  32.       
  33.       mx_internal var scrollTrack:Button;
  34.       
  35.       mx_internal var downArrow:Button;
  36.       
  37.       mx_internal var scrollThumb:ScrollThumb;
  38.       
  39.       private var trackScrollRepeatDirection:int;
  40.       
  41.       private var _minScrollPosition:Number = 0;
  42.       
  43.       private var trackPosition:Number;
  44.       
  45.       private var _pageSize:Number = 0;
  46.       
  47.       mx_internal var _minHeight:Number = 32;
  48.       
  49.       private var _maxScrollPosition:Number = 0;
  50.       
  51.       private var trackScrollTimer:Timer;
  52.       
  53.       mx_internal var upArrow:Button;
  54.       
  55.       private var _lineScrollSize:Number = 1;
  56.       
  57.       private var _scrollPosition:Number = 0;
  58.       
  59.       private var trackScrolling:Boolean = false;
  60.       
  61.       mx_internal var isScrolling:Boolean;
  62.       
  63.       mx_internal var oldPosition:Number;
  64.       
  65.       mx_internal var _minWidth:Number = 16;
  66.       
  67.       public function ScrollBar()
  68.       {
  69.          super();
  70.       }
  71.       
  72.       override public function set enabled(param1:Boolean) : void
  73.       {
  74.          super.enabled = param1;
  75.          invalidateDisplayList();
  76.       }
  77.       
  78.       public function set lineScrollSize(param1:Number) : void
  79.       {
  80.          _lineScrollSize = param1;
  81.       }
  82.       
  83.       public function get minScrollPosition() : Number
  84.       {
  85.          return _minScrollPosition;
  86.       }
  87.       
  88.       mx_internal function dispatchScrollEvent(param1:Number, param2:String) : void
  89.       {
  90.          var _loc3_:ScrollEvent = new ScrollEvent(ScrollEvent.SCROLL);
  91.          _loc3_.detail = param2;
  92.          _loc3_.position = scrollPosition;
  93.          _loc3_.delta = scrollPosition - param1;
  94.          _loc3_.direction = direction;
  95.          dispatchEvent(_loc3_);
  96.       }
  97.       
  98.       private function downArrow_buttonDownHandler(param1:FlexEvent) : void
  99.       {
  100.          if(isNaN(mx_internal::oldPosition))
  101.          {
  102.             mx_internal::oldPosition = scrollPosition;
  103.          }
  104.          mx_internal::lineScroll(1);
  105.       }
  106.       
  107.       private function scrollTrack_mouseDownHandler(param1:MouseEvent) : void
  108.       {
  109.          if(!(param1.target == this || param1.target == mx_internal::scrollTrack))
  110.          {
  111.             return;
  112.          }
  113.          trackScrolling = true;
  114.          var _loc2_:DisplayObject = systemManager.getSandboxRoot();
  115.          _loc2_.addEventListener(MouseEvent.MOUSE_UP,scrollTrack_mouseUpHandler,true);
  116.          _loc2_.addEventListener(MouseEvent.MOUSE_MOVE,scrollTrack_mouseMoveHandler,true);
  117.          _loc2_.addEventListener(SandboxMouseEvent.MOUSE_UP_SOMEWHERE,scrollTrack_mouseLeaveHandler);
  118.          systemManager.deployMouseShields(true);
  119.          var _loc3_:Point = new Point(param1.localX,param1.localY);
  120.          _loc3_ = param1.target.localToGlobal(_loc3_);
  121.          _loc3_ = globalToLocal(_loc3_);
  122.          trackPosition = _loc3_.y;
  123.          if(isNaN(mx_internal::oldPosition))
  124.          {
  125.             mx_internal::oldPosition = scrollPosition;
  126.          }
  127.          trackScrollRepeatDirection = mx_internal::scrollThumb.y + mx_internal::scrollThumb.height < _loc3_.y ? 1 : (mx_internal::scrollThumb.y > _loc3_.y ? -1 : 0);
  128.          mx_internal::pageScroll(trackScrollRepeatDirection);
  129.          if(!trackScrollTimer)
  130.          {
  131.             trackScrollTimer = new Timer(getStyle("repeatDelay"),1);
  132.             trackScrollTimer.addEventListener(TimerEvent.TIMER,trackScrollTimerHandler);
  133.          }
  134.          trackScrollTimer.start();
  135.       }
  136.       
  137.       public function set minScrollPosition(param1:Number) : void
  138.       {
  139.          _minScrollPosition = param1;
  140.          invalidateDisplayList();
  141.       }
  142.       
  143.       public function get scrollPosition() : Number
  144.       {
  145.          return _scrollPosition;
  146.       }
  147.       
  148.       mx_internal function get linePlusDetail() : String
  149.       {
  150.          return direction == ScrollBarDirection.VERTICAL ? ScrollEventDetail.LINE_DOWN : ScrollEventDetail.LINE_RIGHT;
  151.       }
  152.       
  153.       public function get maxScrollPosition() : Number
  154.       {
  155.          return _maxScrollPosition;
  156.       }
  157.       
  158.       protected function get thumbStyleFilters() : Object
  159.       {
  160.          return null;
  161.       }
  162.       
  163.       override public function set doubleClickEnabled(param1:Boolean) : void
  164.       {
  165.       }
  166.       
  167.       public function get lineScrollSize() : Number
  168.       {
  169.          return _lineScrollSize;
  170.       }
  171.       
  172.       mx_internal function get virtualHeight() : Number
  173.       {
  174.          return unscaledHeight;
  175.       }
  176.       
  177.       public function set scrollPosition(param1:Number) : void
  178.       {
  179.          var _loc2_:Number = NaN;
  180.          var _loc3_:Number = NaN;
  181.          var _loc4_:Number = NaN;
  182.          _scrollPosition = param1;
  183.          if(mx_internal::scrollThumb)
  184.          {
  185.             if(!cacheAsBitmap)
  186.             {
  187.                cacheHeuristic = mx_internal::scrollThumb.cacheHeuristic = true;
  188.             }
  189.             if(!mx_internal::isScrolling)
  190.             {
  191.                param1 = Math.min(param1,maxScrollPosition);
  192.                param1 = Math.max(param1,minScrollPosition);
  193.                _loc2_ = maxScrollPosition - minScrollPosition;
  194.                _loc3_ = _loc2_ == 0 || isNaN(_loc2_) ? 0 : (param1 - minScrollPosition) * (trackHeight - mx_internal::scrollThumb.height) / _loc2_ + trackY;
  195.                _loc4_ = (mx_internal::virtualWidth - mx_internal::scrollThumb.width) / 2 + getStyle("thumbOffset");
  196.                mx_internal::scrollThumb.move(Math.round(_loc4_),Math.round(_loc3_));
  197.             }
  198.          }
  199.       }
  200.       
  201.       protected function get downArrowStyleFilters() : Object
  202.       {
  203.          return null;
  204.       }
  205.       
  206.       public function get pageSize() : Number
  207.       {
  208.          return _pageSize;
  209.       }
  210.       
  211.       public function set pageScrollSize(param1:Number) : void
  212.       {
  213.          _pageScrollSize = param1;
  214.       }
  215.       
  216.       public function set maxScrollPosition(param1:Number) : void
  217.       {
  218.          _maxScrollPosition = param1;
  219.          invalidateDisplayList();
  220.       }
  221.       
  222.       mx_internal function pageScroll(param1:int) : void
  223.       {
  224.          var _loc4_:Number = NaN;
  225.          var _loc5_:String = null;
  226.          var _loc2_:Number = _pageScrollSize != 0 ? _pageScrollSize : pageSize;
  227.          var _loc3_:Number = _scrollPosition + param1 * _loc2_;
  228.          if(_loc3_ > maxScrollPosition)
  229.          {
  230.             _loc3_ = maxScrollPosition;
  231.          }
  232.          else if(_loc3_ < minScrollPosition)
  233.          {
  234.             _loc3_ = minScrollPosition;
  235.          }
  236.          if(_loc3_ != scrollPosition)
  237.          {
  238.             _loc4_ = scrollPosition;
  239.             scrollPosition = _loc3_;
  240.             _loc5_ = param1 < 0 ? mx_internal::pageMinusDetail : mx_internal::pagePlusDetail;
  241.             mx_internal::dispatchScrollEvent(_loc4_,_loc5_);
  242.          }
  243.       }
  244.       
  245.       override protected function createChildren() : void
  246.       {
  247.          super.createChildren();
  248.          if(!mx_internal::scrollTrack)
  249.          {
  250.             mx_internal::scrollTrack = new Button();
  251.             mx_internal::scrollTrack.focusEnabled = false;
  252.             mx_internal::scrollTrack.mx_internal::skinName = "trackSkin";
  253.             mx_internal::scrollTrack.mx_internal::upSkinName = "trackUpSkin";
  254.             mx_internal::scrollTrack.mx_internal::overSkinName = "trackOverSkin";
  255.             mx_internal::scrollTrack.mx_internal::downSkinName = "trackDownSkin";
  256.             mx_internal::scrollTrack.mx_internal::disabledSkinName = "trackDisabledSkin";
  257.             if(mx_internal::scrollTrack is ISimpleStyleClient)
  258.             {
  259.                ISimpleStyleClient(mx_internal::scrollTrack).styleName = this;
  260.             }
  261.             addChild(mx_internal::scrollTrack);
  262.             mx_internal::scrollTrack.validateProperties();
  263.          }
  264.          if(!mx_internal::upArrow)
  265.          {
  266.             mx_internal::upArrow = new Button();
  267.             mx_internal::upArrow.enabled = false;
  268.             mx_internal::upArrow.autoRepeat = true;
  269.             mx_internal::upArrow.focusEnabled = false;
  270.             mx_internal::upArrow.mx_internal::upSkinName = "upArrowUpSkin";
  271.             mx_internal::upArrow.mx_internal::overSkinName = "upArrowOverSkin";
  272.             mx_internal::upArrow.mx_internal::downSkinName = "upArrowDownSkin";
  273.             mx_internal::upArrow.mx_internal::disabledSkinName = "upArrowDisabledSkin";
  274.             mx_internal::upArrow.mx_internal::skinName = "upArrowSkin";
  275.             mx_internal::upArrow.mx_internal::upIconName = "";
  276.             mx_internal::upArrow.mx_internal::overIconName = "";
  277.             mx_internal::upArrow.mx_internal::downIconName = "";
  278.             mx_internal::upArrow.mx_internal::disabledIconName = "";
  279.             addChild(mx_internal::upArrow);
  280.             mx_internal::upArrow.styleName = new StyleProxy(this,upArrowStyleFilters);
  281.             mx_internal::upArrow.validateProperties();
  282.             mx_internal::upArrow.addEventListener(FlexEvent.BUTTON_DOWN,upArrow_buttonDownHandler);
  283.          }
  284.          if(!mx_internal::downArrow)
  285.          {
  286.             mx_internal::downArrow = new Button();
  287.             mx_internal::downArrow.enabled = false;
  288.             mx_internal::downArrow.autoRepeat = true;
  289.             mx_internal::downArrow.focusEnabled = false;
  290.             mx_internal::downArrow.mx_internal::upSkinName = "downArrowUpSkin";
  291.             mx_internal::downArrow.mx_internal::overSkinName = "downArrowOverSkin";
  292.             mx_internal::downArrow.mx_internal::downSkinName = "downArrowDownSkin";
  293.             mx_internal::downArrow.mx_internal::disabledSkinName = "downArrowDisabledSkin";
  294.             mx_internal::downArrow.mx_internal::skinName = "downArrowSkin";
  295.             mx_internal::downArrow.mx_internal::upIconName = "";
  296.             mx_internal::downArrow.mx_internal::overIconName = "";
  297.             mx_internal::downArrow.mx_internal::downIconName = "";
  298.             mx_internal::downArrow.mx_internal::disabledIconName = "";
  299.             addChild(mx_internal::downArrow);
  300.             mx_internal::downArrow.styleName = new StyleProxy(this,downArrowStyleFilters);
  301.             mx_internal::downArrow.validateProperties();
  302.             mx_internal::downArrow.addEventListener(FlexEvent.BUTTON_DOWN,downArrow_buttonDownHandler);
  303.          }
  304.       }
  305.       
  306.       private function scrollTrack_mouseOverHandler(param1:MouseEvent) : void
  307.       {
  308.          if(!(param1.target == this || param1.target == mx_internal::scrollTrack))
  309.          {
  310.             return;
  311.          }
  312.          if(trackScrolling)
  313.          {
  314.             trackScrollTimer.start();
  315.          }
  316.       }
  317.       
  318.       private function get minDetail() : String
  319.       {
  320.          return direction == ScrollBarDirection.VERTICAL ? ScrollEventDetail.AT_TOP : ScrollEventDetail.AT_LEFT;
  321.       }
  322.       
  323.       mx_internal function isScrollBarKey(param1:uint) : Boolean
  324.       {
  325.          var _loc2_:Number = NaN;
  326.          if(param1 == Keyboard.HOME)
  327.          {
  328.             if(scrollPosition != 0)
  329.             {
  330.                _loc2_ = scrollPosition;
  331.                scrollPosition = 0;
  332.                mx_internal::dispatchScrollEvent(_loc2_,minDetail);
  333.             }
  334.             return true;
  335.          }
  336.          if(param1 == Keyboard.END)
  337.          {
  338.             if(scrollPosition < maxScrollPosition)
  339.             {
  340.                _loc2_ = scrollPosition;
  341.                scrollPosition = maxScrollPosition;
  342.                mx_internal::dispatchScrollEvent(_loc2_,maxDetail);
  343.             }
  344.             return true;
  345.          }
  346.          return false;
  347.       }
  348.       
  349.       mx_internal function get lineMinusDetail() : String
  350.       {
  351.          return direction == ScrollBarDirection.VERTICAL ? ScrollEventDetail.LINE_UP : ScrollEventDetail.LINE_LEFT;
  352.       }
  353.       
  354.       mx_internal function get pageMinusDetail() : String
  355.       {
  356.          return direction == ScrollBarDirection.VERTICAL ? ScrollEventDetail.PAGE_UP : ScrollEventDetail.PAGE_LEFT;
  357.       }
  358.       
  359.       private function get maxDetail() : String
  360.       {
  361.          return direction == ScrollBarDirection.VERTICAL ? ScrollEventDetail.AT_BOTTOM : ScrollEventDetail.AT_RIGHT;
  362.       }
  363.       
  364.       private function scrollTrack_mouseLeaveHandler(param1:Event) : void
  365.       {
  366.          trackScrolling = false;
  367.          var _loc2_:DisplayObject = systemManager.getSandboxRoot();
  368.          _loc2_.removeEventListener(MouseEvent.MOUSE_UP,scrollTrack_mouseUpHandler,true);
  369.          _loc2_.removeEventListener(MouseEvent.MOUSE_MOVE,scrollTrack_mouseMoveHandler,true);
  370.          _loc2_.removeEventListener(SandboxMouseEvent.MOUSE_UP_SOMEWHERE,scrollTrack_mouseLeaveHandler);
  371.          systemManager.deployMouseShields(false);
  372.          if(trackScrollTimer)
  373.          {
  374.             trackScrollTimer.reset();
  375.          }
  376.          if(param1.target != mx_internal::scrollTrack)
  377.          {
  378.             return;
  379.          }
  380.          var _loc3_:String = mx_internal::oldPosition > scrollPosition ? mx_internal::pageMinusDetail : mx_internal::pagePlusDetail;
  381.          mx_internal::dispatchScrollEvent(mx_internal::oldPosition,_loc3_);
  382.          mx_internal::oldPosition = NaN;
  383.       }
  384.       
  385.       protected function get upArrowStyleFilters() : Object
  386.       {
  387.          return null;
  388.       }
  389.       
  390.       private function get trackHeight() : Number
  391.       {
  392.          return mx_internal::virtualHeight - (mx_internal::upArrow.getExplicitOrMeasuredHeight() + mx_internal::downArrow.getExplicitOrMeasuredHeight());
  393.       }
  394.       
  395.       public function get pageScrollSize() : Number
  396.       {
  397.          return _pageScrollSize;
  398.       }
  399.       
  400.       override protected function measure() : void
  401.       {
  402.          super.measure();
  403.          mx_internal::upArrow.validateSize();
  404.          mx_internal::downArrow.validateSize();
  405.          mx_internal::scrollTrack.validateSize();
  406.          if(FlexVersion.compatibilityVersion >= FlexVersion.VERSION_3_0)
  407.          {
  408.             mx_internal::_minWidth = !!mx_internal::scrollThumb ? mx_internal::scrollThumb.getExplicitOrMeasuredWidth() : 0;
  409.             mx_internal::_minWidth = Math.max(mx_internal::scrollTrack.getExplicitOrMeasuredWidth(),mx_internal::upArrow.getExplicitOrMeasuredWidth(),mx_internal::downArrow.getExplicitOrMeasuredWidth(),mx_internal::_minWidth);
  410.          }
  411.          else
  412.          {
  413.             mx_internal::_minWidth = mx_internal::upArrow.getExplicitOrMeasuredWidth();
  414.          }
  415.          mx_internal::_minHeight = mx_internal::upArrow.getExplicitOrMeasuredHeight() + mx_internal::downArrow.getExplicitOrMeasuredHeight();
  416.       }
  417.       
  418.       mx_internal function lineScroll(param1:int) : void
  419.       {
  420.          var _loc4_:Number = NaN;
  421.          var _loc5_:String = null;
  422.          var _loc2_:Number = _lineScrollSize;
  423.          var _loc3_:Number = _scrollPosition + param1 * _loc2_;
  424.          if(_loc3_ > maxScrollPosition)
  425.          {
  426.             _loc3_ = maxScrollPosition;
  427.          }
  428.          else if(_loc3_ < minScrollPosition)
  429.          {
  430.             _loc3_ = minScrollPosition;
  431.          }
  432.          if(_loc3_ != scrollPosition)
  433.          {
  434.             _loc4_ = scrollPosition;
  435.             scrollPosition = _loc3_;
  436.             _loc5_ = param1 < 0 ? mx_internal::lineMinusDetail : mx_internal::linePlusDetail;
  437.             mx_internal::dispatchScrollEvent(_loc4_,_loc5_);
  438.          }
  439.       }
  440.       
  441.       public function setScrollProperties(param1:Number, param2:Number, param3:Number, param4:Number = 0) : void
  442.       {
  443.          var _loc5_:Number = NaN;
  444.          this.pageSize = param1;
  445.          _pageScrollSize = param4 > 0 ? param4 : param1;
  446.          this.minScrollPosition = Math.max(param2,0);
  447.          this.maxScrollPosition = Math.max(param3,0);
  448.          _scrollPosition = Math.max(this.minScrollPosition,_scrollPosition);
  449.          _scrollPosition = Math.min(this.maxScrollPosition,_scrollPosition);
  450.          if(this.maxScrollPosition - this.minScrollPosition > 0 && enabled)
  451.          {
  452.             mx_internal::upArrow.enabled = true;
  453.             mx_internal::downArrow.enabled = true;
  454.             mx_internal::scrollTrack.enabled = true;
  455.             addEventListener(MouseEvent.MOUSE_DOWN,scrollTrack_mouseDownHandler);
  456.             addEventListener(MouseEvent.MOUSE_OVER,scrollTrack_mouseOverHandler);
  457.             addEventListener(MouseEvent.MOUSE_OUT,scrollTrack_mouseOutHandler);
  458.             if(!mx_internal::scrollThumb)
  459.             {
  460.                mx_internal::scrollThumb = new ScrollThumb();
  461.                mx_internal::scrollThumb.focusEnabled = false;
  462.                addChildAt(mx_internal::scrollThumb,getChildIndex(mx_internal::downArrow));
  463.                mx_internal::scrollThumb.styleName = new StyleProxy(this,thumbStyleFilters);
  464.                mx_internal::scrollThumb.mx_internal::upSkinName = "thumbUpSkin";
  465.                mx_internal::scrollThumb.mx_internal::overSkinName = "thumbOverSkin";
  466.                mx_internal::scrollThumb.mx_internal::downSkinName = "thumbDownSkin";
  467.                mx_internal::scrollThumb.mx_internal::iconName = "thumbIcon";
  468.                mx_internal::scrollThumb.mx_internal::skinName = "thumbSkin";
  469.             }
  470.             _loc5_ = trackHeight < 0 ? 0 : Math.round(param1 / (this.maxScrollPosition - this.minScrollPosition + param1) * trackHeight);
  471.             if(_loc5_ < mx_internal::scrollThumb.minHeight)
  472.             {
  473.                if(trackHeight < mx_internal::scrollThumb.minHeight)
  474.                {
  475.                   mx_internal::scrollThumb.visible = false;
  476.                }
  477.                else
  478.                {
  479.                   _loc5_ = mx_internal::scrollThumb.minHeight;
  480.                   mx_internal::scrollThumb.visible = true;
  481.                   mx_internal::scrollThumb.setActualSize(mx_internal::scrollThumb.measuredWidth,mx_internal::scrollThumb.minHeight);
  482.                }
  483.             }
  484.             else
  485.             {
  486.                mx_internal::scrollThumb.visible = true;
  487.                mx_internal::scrollThumb.setActualSize(mx_internal::scrollThumb.measuredWidth,_loc5_);
  488.             }
  489.             mx_internal::scrollThumb.mx_internal::setRange(mx_internal::upArrow.getExplicitOrMeasuredHeight() + 0,mx_internal::virtualHeight - mx_internal::downArrow.getExplicitOrMeasuredHeight() - mx_internal::scrollThumb.height,this.minScrollPosition,this.maxScrollPosition);
  490.             scrollPosition = Math.max(Math.min(scrollPosition,this.maxScrollPosition),this.minScrollPosition);
  491.          }
  492.          else
  493.          {
  494.             mx_internal::upArrow.enabled = false;
  495.             mx_internal::downArrow.enabled = false;
  496.             mx_internal::scrollTrack.enabled = false;
  497.             if(mx_internal::scrollThumb)
  498.             {
  499.                mx_internal::scrollThumb.visible = false;
  500.             }
  501.          }
  502.       }
  503.       
  504.       private function trackScrollTimerHandler(param1:Event) : void
  505.       {
  506.          if(trackScrollRepeatDirection == 1)
  507.          {
  508.             if(mx_internal::scrollThumb.y + mx_internal::scrollThumb.height > trackPosition)
  509.             {
  510.                return;
  511.             }
  512.          }
  513.          if(trackScrollRepeatDirection == -1)
  514.          {
  515.             if(mx_internal::scrollThumb.y < trackPosition)
  516.             {
  517.                return;
  518.             }
  519.          }
  520.          mx_internal::pageScroll(trackScrollRepeatDirection);
  521.          if(Boolean(trackScrollTimer) && trackScrollTimer.repeatCount == 1)
  522.          {
  523.             trackScrollTimer.delay = getStyle("repeatInterval");
  524.             trackScrollTimer.repeatCount = 0;
  525.          }
  526.       }
  527.       
  528.       private function upArrow_buttonDownHandler(param1:FlexEvent) : void
  529.       {
  530.          if(isNaN(mx_internal::oldPosition))
  531.          {
  532.             mx_internal::oldPosition = scrollPosition;
  533.          }
  534.          mx_internal::lineScroll(-1);
  535.       }
  536.       
  537.       public function set pageSize(param1:Number) : void
  538.       {
  539.          _pageSize = param1;
  540.       }
  541.       
  542.       private function get trackY() : Number
  543.       {
  544.          return mx_internal::upArrow.getExplicitOrMeasuredHeight();
  545.       }
  546.       
  547.       private function scrollTrack_mouseOutHandler(param1:MouseEvent) : void
  548.       {
  549.          if(trackScrolling)
  550.          {
  551.             trackScrollTimer.stop();
  552.          }
  553.       }
  554.       
  555.       private function scrollTrack_mouseUpHandler(param1:MouseEvent) : void
  556.       {
  557.          scrollTrack_mouseLeaveHandler(param1);
  558.       }
  559.       
  560.       private function scrollTrack_mouseMoveHandler(param1:MouseEvent) : void
  561.       {
  562.          var _loc2_:Point = null;
  563.          if(trackScrolling)
  564.          {
  565.             _loc2_ = new Point(param1.stageX,param1.stageY);
  566.             _loc2_ = globalToLocal(_loc2_);
  567.             trackPosition = _loc2_.y;
  568.          }
  569.       }
  570.       
  571.       override protected function updateDisplayList(param1:Number, param2:Number) : void
  572.       {
  573.          if(mx_internal::$height == 1)
  574.          {
  575.             return;
  576.          }
  577.          if(!mx_internal::upArrow)
  578.          {
  579.             return;
  580.          }
  581.          super.updateDisplayList(param1,param2);
  582.          if(cacheAsBitmap)
  583.          {
  584.             cacheHeuristic = mx_internal::scrollThumb.cacheHeuristic = false;
  585.          }
  586.          mx_internal::upArrow.setActualSize(mx_internal::upArrow.getExplicitOrMeasuredWidth(),mx_internal::upArrow.getExplicitOrMeasuredHeight());
  587.          if(FlexVersion.compatibilityVersion >= FlexVersion.VERSION_3_0)
  588.          {
  589.             mx_internal::upArrow.move((mx_internal::virtualWidth - mx_internal::upArrow.width) / 2,0);
  590.          }
  591.          else
  592.          {
  593.             mx_internal::upArrow.move(0,0);
  594.          }
  595.          mx_internal::scrollTrack.setActualSize(mx_internal::scrollTrack.getExplicitOrMeasuredWidth(),mx_internal::virtualHeight);
  596.          if(FlexVersion.compatibilityVersion >= FlexVersion.VERSION_3_0)
  597.          {
  598.             mx_internal::scrollTrack.x = (mx_internal::virtualWidth - mx_internal::scrollTrack.width) / 2;
  599.          }
  600.          mx_internal::scrollTrack.y = 0;
  601.          mx_internal::downArrow.setActualSize(mx_internal::downArrow.getExplicitOrMeasuredWidth(),mx_internal::downArrow.getExplicitOrMeasuredHeight());
  602.          if(FlexVersion.compatibilityVersion >= FlexVersion.VERSION_3_0)
  603.          {
  604.             mx_internal::downArrow.move((mx_internal::virtualWidth - mx_internal::downArrow.width) / 2,mx_internal::virtualHeight - mx_internal::downArrow.getExplicitOrMeasuredHeight());
  605.          }
  606.          else
  607.          {
  608.             mx_internal::downArrow.move(0,mx_internal::virtualHeight - mx_internal::downArrow.getExplicitOrMeasuredHeight());
  609.          }
  610.          setScrollProperties(pageSize,minScrollPosition,maxScrollPosition,_pageScrollSize);
  611.          scrollPosition = _scrollPosition;
  612.       }
  613.       
  614.       mx_internal function get pagePlusDetail() : String
  615.       {
  616.          return direction == ScrollBarDirection.VERTICAL ? ScrollEventDetail.PAGE_DOWN : ScrollEventDetail.PAGE_RIGHT;
  617.       }
  618.       
  619.       mx_internal function get virtualWidth() : Number
  620.       {
  621.          return unscaledWidth;
  622.       }
  623.       
  624.       public function set direction(param1:String) : void
  625.       {
  626.          _direction = param1;
  627.          invalidateSize();
  628.          invalidateDisplayList();
  629.          dispatchEvent(new Event("directionChanged"));
  630.       }
  631.       
  632.       [Bindable("directionChanged")]
  633.       public function get direction() : String
  634.       {
  635.          return _direction;
  636.       }
  637.    }
  638. }
  639.  
  640.