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