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