home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Puzzle / filler.swf / scripts / mx / controls / scrollClasses / ScrollBar.as next >
Encoding:
Text File  |  2008-09-02  |  21.8 KB  |  600 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 || param1.target == mx_internal::scrollTrack))
  279.          {
  280.             return;
  281.          }
  282.          if(trackScrolling)
  283.          {
  284.             trackScrollTimer.start();
  285.          }
  286.       }
  287.       
  288.       private function scrollTrack_mouseDownHandler(param1:MouseEvent) : void
  289.       {
  290.          var _loc2_:Point = null;
  291.          if(!(param1.target == this || param1.target == mx_internal::scrollTrack))
  292.          {
  293.             return;
  294.          }
  295.          trackScrolling = true;
  296.          systemManager.addEventListener(MouseEvent.MOUSE_UP,scrollTrack_mouseUpHandler,true);
  297.          systemManager.addEventListener(MouseEvent.MOUSE_MOVE,scrollTrack_mouseMoveHandler,true);
  298.          systemManager.stage.addEventListener(MouseEvent.MOUSE_MOVE,stage_scrollTrack_mouseMoveHandler);
  299.          systemManager.stage.addEventListener(Event.MOUSE_LEAVE,scrollTrack_mouseLeaveHandler);
  300.          _loc2_ = new Point(param1.localX,param1.localY);
  301.          _loc2_ = param1.target.localToGlobal(_loc2_);
  302.          _loc2_ = globalToLocal(_loc2_);
  303.          trackPosition = _loc2_.y;
  304.          if(isNaN(mx_internal::oldPosition))
  305.          {
  306.             mx_internal::oldPosition = scrollPosition;
  307.          }
  308.          trackScrollRepeatDirection = mx_internal::scrollThumb.y + mx_internal::scrollThumb.height < _loc2_.y ? 1 : (mx_internal::scrollThumb.y > _loc2_.y ? -1 : 0);
  309.          mx_internal::pageScroll(trackScrollRepeatDirection);
  310.          if(!trackScrollTimer)
  311.          {
  312.             trackScrollTimer = new Timer(getStyle("repeatDelay"),1);
  313.             trackScrollTimer.addEventListener(TimerEvent.TIMER,trackScrollTimerHandler);
  314.          }
  315.          trackScrollTimer.start();
  316.       }
  317.       
  318.       public function get minScrollPosition() : Number
  319.       {
  320.          return _minScrollPosition;
  321.       }
  322.       
  323.       override public function set doubleClickEnabled(param1:Boolean) : void
  324.       {
  325.       }
  326.       
  327.       public function set scrollPosition(param1:Number) : void
  328.       {
  329.          var _loc2_:Number = NaN;
  330.          var _loc3_:Number = NaN;
  331.          _scrollPosition = param1;
  332.          if(mx_internal::scrollThumb)
  333.          {
  334.             if(!cacheAsBitmap)
  335.             {
  336.                cacheHeuristic = mx_internal::scrollThumb.cacheHeuristic = true;
  337.             }
  338.             if(!mx_internal::isScrolling)
  339.             {
  340.                param1 = Math.min(param1,maxScrollPosition);
  341.                param1 = Math.max(param1,minScrollPosition);
  342.                _loc2_ = maxScrollPosition - minScrollPosition;
  343.                _loc3_ = _loc2_ == 0 || isNaN(_loc2_) ? 0 : (param1 - minScrollPosition) * (trackHeight - mx_internal::scrollThumb.height) / _loc2_ + trackY;
  344.                mx_internal::scrollThumb.move(0,Math.round(_loc3_));
  345.             }
  346.          }
  347.       }
  348.       
  349.       mx_internal function pageScroll(param1:int) : void
  350.       {
  351.          var _loc2_:Number = NaN;
  352.          var _loc3_:Number = NaN;
  353.          var _loc4_:Number = NaN;
  354.          var _loc5_:String = null;
  355.          _loc2_ = _pageScrollSize != 0 ? _pageScrollSize : pageSize;
  356.          _loc3_ = _scrollPosition + param1 * _loc2_;
  357.          if(_loc3_ > maxScrollPosition)
  358.          {
  359.             _loc3_ = maxScrollPosition;
  360.          }
  361.          else if(_loc3_ < minScrollPosition)
  362.          {
  363.             _loc3_ = minScrollPosition;
  364.          }
  365.          if(_loc3_ != scrollPosition)
  366.          {
  367.             _loc4_ = scrollPosition;
  368.             scrollPosition = _loc3_;
  369.             _loc5_ = param1 < 0 ? mx_internal::pageMinusDetail : mx_internal::pagePlusDetail;
  370.             mx_internal::dispatchScrollEvent(_loc4_,_loc5_);
  371.          }
  372.       }
  373.       
  374.       private function scrollTrack_mouseLeaveHandler(param1:Event) : void
  375.       {
  376.          var _loc2_:String = null;
  377.          trackScrolling = false;
  378.          systemManager.removeEventListener(MouseEvent.MOUSE_UP,scrollTrack_mouseUpHandler,true);
  379.          systemManager.removeEventListener(MouseEvent.MOUSE_MOVE,scrollTrack_mouseMoveHandler,true);
  380.          systemManager.stage.removeEventListener(MouseEvent.MOUSE_MOVE,stage_scrollTrack_mouseMoveHandler);
  381.          systemManager.stage.removeEventListener(Event.MOUSE_LEAVE,scrollTrack_mouseLeaveHandler);
  382.          if(trackScrollTimer)
  383.          {
  384.             trackScrollTimer.reset();
  385.          }
  386.          if(param1.target != this)
  387.          {
  388.             return;
  389.          }
  390.          _loc2_ = mx_internal::oldPosition > scrollPosition ? mx_internal::pageMinusDetail : mx_internal::pagePlusDetail;
  391.          mx_internal::dispatchScrollEvent(mx_internal::oldPosition,_loc2_);
  392.          mx_internal::oldPosition = NaN;
  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 set pageSize(param1:Number) : void
  401.       {
  402.          _pageSize = param1;
  403.       }
  404.       
  405.       mx_internal function get pagePlusDetail() : String
  406.       {
  407.          return direction == ScrollBarDirection.VERTICAL ? ScrollEventDetail.PAGE_DOWN : ScrollEventDetail.PAGE_RIGHT;
  408.       }
  409.       
  410.       override public function set enabled(param1:Boolean) : void
  411.       {
  412.          super.enabled = param1;
  413.          invalidateDisplayList();
  414.       }
  415.       
  416.       mx_internal function get pageMinusDetail() : String
  417.       {
  418.          return direction == ScrollBarDirection.VERTICAL ? ScrollEventDetail.PAGE_UP : ScrollEventDetail.PAGE_LEFT;
  419.       }
  420.       
  421.       private function get maxDetail() : String
  422.       {
  423.          return direction == ScrollBarDirection.VERTICAL ? ScrollEventDetail.AT_BOTTOM : ScrollEventDetail.AT_RIGHT;
  424.       }
  425.       
  426.       private function scrollTrack_mouseOutHandler(param1:MouseEvent) : void
  427.       {
  428.          if(trackScrolling)
  429.          {
  430.             trackScrollTimer.stop();
  431.          }
  432.       }
  433.       
  434.       mx_internal function dispatchScrollEvent(param1:Number, param2:String) : void
  435.       {
  436.          var _loc3_:ScrollEvent = null;
  437.          _loc3_ = new ScrollEvent(ScrollEvent.SCROLL);
  438.          _loc3_.detail = param2;
  439.          _loc3_.position = scrollPosition;
  440.          _loc3_.delta = scrollPosition - param1;
  441.          _loc3_.direction = direction;
  442.          dispatchEvent(_loc3_);
  443.       }
  444.       
  445.       public function set lineScrollSize(param1:Number) : void
  446.       {
  447.          _lineScrollSize = param1;
  448.       }
  449.       
  450.       public function set direction(param1:String) : void
  451.       {
  452.          _direction = param1;
  453.          invalidateSize();
  454.          invalidateDisplayList();
  455.          dispatchEvent(new Event("directionChanged"));
  456.       }
  457.       
  458.       public function get scrollPosition() : Number
  459.       {
  460.          return _scrollPosition;
  461.       }
  462.       
  463.       override protected function createChildren() : void
  464.       {
  465.          var _loc1_:Class = null;
  466.          super.createChildren();
  467.          if(!mx_internal::scrollTrack)
  468.          {
  469.             _loc1_ = getStyle("trackSkin");
  470.             mx_internal::scrollTrack = new _loc1_();
  471.             if(mx_internal::scrollTrack is ISimpleStyleClient)
  472.             {
  473.                ISimpleStyleClient(mx_internal::scrollTrack).styleName = this;
  474.             }
  475.             addChild(mx_internal::scrollTrack);
  476.          }
  477.          if(!mx_internal::upArrow)
  478.          {
  479.             mx_internal::upArrow = new Button();
  480.             mx_internal::upArrow.enabled = false;
  481.             mx_internal::upArrow.autoRepeat = true;
  482.             mx_internal::upArrow.focusEnabled = false;
  483.             mx_internal::upArrow.mx_internal::upSkinName = "upArrowUpSkin";
  484.             mx_internal::upArrow.mx_internal::overSkinName = "upArrowOverSkin";
  485.             mx_internal::upArrow.mx_internal::downSkinName = "upArrowDownSkin";
  486.             mx_internal::upArrow.mx_internal::disabledSkinName = "upArrowDisabledSkin";
  487.             mx_internal::upArrow.mx_internal::upIconName = "";
  488.             mx_internal::upArrow.mx_internal::overIconName = "";
  489.             mx_internal::upArrow.mx_internal::downIconName = "";
  490.             mx_internal::upArrow.mx_internal::disabledIconName = "";
  491.             addChild(mx_internal::upArrow);
  492.             mx_internal::upArrow.styleName = this;
  493.             mx_internal::upArrow.validateProperties();
  494.             mx_internal::upArrow.addEventListener(FlexEvent.BUTTON_DOWN,upArrow_buttonDownHandler);
  495.          }
  496.          if(!mx_internal::downArrow)
  497.          {
  498.             mx_internal::downArrow = new Button();
  499.             mx_internal::downArrow.enabled = false;
  500.             mx_internal::downArrow.autoRepeat = true;
  501.             mx_internal::downArrow.focusEnabled = false;
  502.             mx_internal::downArrow.mx_internal::upSkinName = "downArrowUpSkin";
  503.             mx_internal::downArrow.mx_internal::overSkinName = "downArrowOverSkin";
  504.             mx_internal::downArrow.mx_internal::downSkinName = "downArrowDownSkin";
  505.             mx_internal::downArrow.mx_internal::disabledSkinName = "downArrowDisabledSkin";
  506.             mx_internal::downArrow.mx_internal::upIconName = "";
  507.             mx_internal::downArrow.mx_internal::overIconName = "";
  508.             mx_internal::downArrow.mx_internal::downIconName = "";
  509.             mx_internal::downArrow.mx_internal::disabledIconName = "";
  510.             addChild(mx_internal::downArrow);
  511.             mx_internal::downArrow.styleName = this;
  512.             mx_internal::downArrow.validateProperties();
  513.             mx_internal::downArrow.addEventListener(FlexEvent.BUTTON_DOWN,downArrow_buttonDownHandler);
  514.          }
  515.       }
  516.       
  517.       public function set maxScrollPosition(param1:Number) : void
  518.       {
  519.          _maxScrollPosition = param1;
  520.       }
  521.       
  522.       public function get pageSize() : Number
  523.       {
  524.          return _pageSize;
  525.       }
  526.       
  527.       [Bindable("directionChanged")]
  528.       public function get direction() : String
  529.       {
  530.          return _direction;
  531.       }
  532.       
  533.       public function get lineScrollSize() : Number
  534.       {
  535.          return _lineScrollSize;
  536.       }
  537.       
  538.       mx_internal function lineScroll(param1:int) : void
  539.       {
  540.          var _loc2_:Number = NaN;
  541.          var _loc3_:Number = NaN;
  542.          var _loc4_:Number = NaN;
  543.          var _loc5_:String = null;
  544.          _loc2_ = _lineScrollSize;
  545.          _loc3_ = _scrollPosition + param1 * _loc2_;
  546.          if(_loc3_ > maxScrollPosition)
  547.          {
  548.             _loc3_ = maxScrollPosition;
  549.          }
  550.          else if(_loc3_ < minScrollPosition)
  551.          {
  552.             _loc3_ = minScrollPosition;
  553.          }
  554.          if(_loc3_ != scrollPosition)
  555.          {
  556.             _loc4_ = scrollPosition;
  557.             scrollPosition = _loc3_;
  558.             _loc5_ = param1 < 0 ? mx_internal::lineMinusDetail : mx_internal::linePlusDetail;
  559.             mx_internal::dispatchScrollEvent(_loc4_,_loc5_);
  560.          }
  561.       }
  562.       
  563.       override protected function updateDisplayList(param1:Number, param2:Number) : void
  564.       {
  565.          if(mx_internal::$height == 1)
  566.          {
  567.             return;
  568.          }
  569.          if(!mx_internal::upArrow)
  570.          {
  571.             return;
  572.          }
  573.          super.updateDisplayList(param1,param2);
  574.          if(cacheAsBitmap)
  575.          {
  576.             cacheHeuristic = mx_internal::scrollThumb.cacheHeuristic = false;
  577.          }
  578.          mx_internal::upArrow.move(0,0);
  579.          mx_internal::upArrow.setActualSize(mx_internal::upArrow.getExplicitOrMeasuredWidth(),mx_internal::upArrow.getExplicitOrMeasuredHeight());
  580.          mx_internal::scrollTrack.y = 0;
  581.          mx_internal::scrollTrack.height = mx_internal::virtualHeight;
  582.          mx_internal::downArrow.move(0,mx_internal::virtualHeight - mx_internal::downArrow.getExplicitOrMeasuredHeight());
  583.          mx_internal::downArrow.setActualSize(mx_internal::downArrow.getExplicitOrMeasuredWidth(),mx_internal::downArrow.getExplicitOrMeasuredHeight());
  584.          setScrollProperties(pageSize,minScrollPosition,maxScrollPosition,_pageScrollSize);
  585.          scrollPosition = _scrollPosition;
  586.       }
  587.       
  588.       private function scrollTrack_mouseMoveHandler(param1:MouseEvent) : void
  589.       {
  590.          var _loc2_:Point = null;
  591.          if(trackScrolling)
  592.          {
  593.             _loc2_ = new Point(param1.stageX,param1.stageY);
  594.             _loc2_ = globalToLocal(_loc2_);
  595.             trackPosition = _loc2_.y;
  596.          }
  597.       }
  598.    }
  599. }
  600.