home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Multimedija / shufflr.air / ShufflrClient.swf / scripts / mx / core / ScrollControlBase.as < prev    next >
Encoding:
Text File  |  2010-06-23  |  21.8 KB  |  607 lines
  1. package mx.core
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.display.Graphics;
  5.    import flash.display.Shape;
  6.    import flash.events.Event;
  7.    import flash.events.MouseEvent;
  8.    import flash.geom.Point;
  9.    import mx.controls.HScrollBar;
  10.    import mx.controls.ToolTip;
  11.    import mx.controls.VScrollBar;
  12.    import mx.controls.scrollClasses.ScrollBar;
  13.    import mx.events.ScrollEvent;
  14.    import mx.events.ScrollEventDetail;
  15.    import mx.events.ScrollEventDirection;
  16.    import mx.managers.ToolTipManager;
  17.    import mx.styles.ISimpleStyleClient;
  18.    
  19.    use namespace mx_internal;
  20.    
  21.    public class ScrollControlBase extends UIComponent
  22.    {
  23.       mx_internal static const VERSION:String = "3.5.0.12683";
  24.       
  25.       private var numberOfRows:Number = 0;
  26.       
  27.       private var _scrollTipFunction:Function;
  28.       
  29.       private var scrollTip:ToolTip;
  30.       
  31.       public var showScrollTips:Boolean = false;
  32.       
  33.       private var numberOfCols:Number = 0;
  34.       
  35.       protected var maskShape:Shape;
  36.       
  37.       private var oldTTMEnabled:Boolean;
  38.       
  39.       mx_internal var _maxHorizontalScrollPosition:Number;
  40.       
  41.       protected var border:IFlexDisplayObject;
  42.       
  43.       private var _viewMetrics:EdgeMetrics;
  44.       
  45.       mx_internal var _maxVerticalScrollPosition:Number;
  46.       
  47.       protected var verticalScrollBar:ScrollBar;
  48.       
  49.       mx_internal var _horizontalScrollPosition:Number = 0;
  50.       
  51.       private var propsInited:Boolean;
  52.       
  53.       protected var horizontalScrollBar:ScrollBar;
  54.       
  55.       mx_internal var _horizontalScrollPolicy:String = "off";
  56.       
  57.       mx_internal var _verticalScrollPosition:Number = 0;
  58.       
  59.       private var scrollThumbMidPoint:Number;
  60.       
  61.       mx_internal var _verticalScrollPolicy:String = "auto";
  62.       
  63.       protected var scrollAreaChanged:Boolean;
  64.       
  65.       private var viewableColumns:Number;
  66.       
  67.       public var liveScrolling:Boolean = true;
  68.       
  69.       private var viewableRows:Number;
  70.       
  71.       private var invLayout:Boolean;
  72.       
  73.       public function ScrollControlBase()
  74.       {
  75.          super();
  76.          _viewMetrics = EdgeMetrics.EMPTY;
  77.          addEventListener(MouseEvent.MOUSE_WHEEL,mouseWheelHandler);
  78.       }
  79.       
  80.       override public function set enabled(param1:Boolean) : void
  81.       {
  82.          super.enabled = param1;
  83.          if(horizontalScrollBar)
  84.          {
  85.             horizontalScrollBar.enabled = param1;
  86.          }
  87.          if(verticalScrollBar)
  88.          {
  89.             verticalScrollBar.enabled = param1;
  90.          }
  91.       }
  92.       
  93.       [Bindable("scrollTipFunctionChanged")]
  94.       public function get scrollTipFunction() : Function
  95.       {
  96.          return _scrollTipFunction;
  97.       }
  98.       
  99.       public function set scrollTipFunction(param1:Function) : void
  100.       {
  101.          _scrollTipFunction = param1;
  102.          dispatchEvent(new Event("scrollTipFunctionChanged"));
  103.       }
  104.       
  105.       override protected function updateDisplayList(param1:Number, param2:Number) : void
  106.       {
  107.          super.updateDisplayList(param1,param2);
  108.          layoutChrome(param1,param2);
  109.          var _loc3_:Number = param1;
  110.          var _loc4_:Number = param2;
  111.          invLayout = false;
  112.          var _loc5_:EdgeMetrics = _viewMetrics = viewMetrics;
  113.          if(Boolean(horizontalScrollBar) && horizontalScrollBar.visible)
  114.          {
  115.             horizontalScrollBar.setActualSize(_loc3_ - _loc5_.left - _loc5_.right,horizontalScrollBar.minHeight);
  116.             horizontalScrollBar.move(_loc5_.left,_loc4_ - _loc5_.bottom);
  117.             horizontalScrollBar.enabled = enabled;
  118.          }
  119.          if(Boolean(verticalScrollBar) && verticalScrollBar.visible)
  120.          {
  121.             verticalScrollBar.setActualSize(verticalScrollBar.minWidth,_loc4_ - _loc5_.top - _loc5_.bottom);
  122.             verticalScrollBar.move(_loc3_ - _loc5_.right,_loc5_.top);
  123.             verticalScrollBar.enabled = enabled;
  124.          }
  125.          var _loc6_:DisplayObject = maskShape;
  126.          var _loc7_:Number = _loc3_ - _loc5_.left - _loc5_.right;
  127.          var _loc8_:Number = _loc4_ - _loc5_.top - _loc5_.bottom;
  128.          _loc6_.width = _loc7_ < 0 ? 0 : _loc7_;
  129.          _loc6_.height = _loc8_ < 0 ? 0 : _loc8_;
  130.          _loc6_.x = _loc5_.left;
  131.          _loc6_.y = _loc5_.top;
  132.       }
  133.       
  134.       protected function setScrollBarProperties(param1:int, param2:int, param3:int, param4:int) : void
  135.       {
  136.          var _loc7_:Boolean = false;
  137.          var _loc5_:String = this.horizontalScrollPolicy;
  138.          var _loc6_:String = this.verticalScrollPolicy;
  139.          scrollAreaChanged = false;
  140.          if(_loc5_ == ScrollPolicy.ON || param2 < param1 && param1 > 0 && _loc5_ == ScrollPolicy.AUTO)
  141.          {
  142.             if(!horizontalScrollBar)
  143.             {
  144.                createHScrollBar(false);
  145.                horizontalScrollBar.addEventListener(ScrollEvent.SCROLL,scrollHandler);
  146.                horizontalScrollBar.addEventListener(ScrollEvent.SCROLL,scrollTipHandler);
  147.                horizontalScrollBar.scrollPosition = mx_internal::_horizontalScrollPosition;
  148.             }
  149.             _loc7_ = roomForScrollBar(horizontalScrollBar,unscaledWidth,unscaledHeight);
  150.             if(_loc7_ != horizontalScrollBar.visible)
  151.             {
  152.                horizontalScrollBar.visible = _loc7_;
  153.                scrollAreaChanged = true;
  154.             }
  155.             if(horizontalScrollBar && horizontalScrollBar.visible && (numberOfCols != param1 || viewableColumns != param2 || scrollAreaChanged))
  156.             {
  157.                horizontalScrollBar.setScrollProperties(param2,0,param1 - param2);
  158.                if(horizontalScrollBar.scrollPosition != mx_internal::_horizontalScrollPosition)
  159.                {
  160.                   horizontalScrollBar.scrollPosition = mx_internal::_horizontalScrollPosition;
  161.                }
  162.                viewableColumns = param2;
  163.                numberOfCols = param1;
  164.             }
  165.          }
  166.          else if((_loc5_ == ScrollPolicy.AUTO || _loc5_ == ScrollPolicy.OFF) && horizontalScrollBar && horizontalScrollBar.visible)
  167.          {
  168.             horizontalScrollPosition = 0;
  169.             horizontalScrollBar.setScrollProperties(param2,0,0);
  170.             horizontalScrollBar.visible = false;
  171.             viewableColumns = NaN;
  172.             scrollAreaChanged = true;
  173.          }
  174.          if(_loc6_ == ScrollPolicy.ON || param4 < param3 && param3 > 0 && _loc6_ == ScrollPolicy.AUTO)
  175.          {
  176.             if(!verticalScrollBar)
  177.             {
  178.                createVScrollBar(false);
  179.                verticalScrollBar.addEventListener(ScrollEvent.SCROLL,scrollHandler);
  180.                verticalScrollBar.addEventListener(ScrollEvent.SCROLL,scrollTipHandler);
  181.                verticalScrollBar.scrollPosition = mx_internal::_verticalScrollPosition;
  182.             }
  183.             _loc7_ = roomForScrollBar(verticalScrollBar,unscaledWidth,unscaledHeight);
  184.             if(_loc7_ != verticalScrollBar.visible)
  185.             {
  186.                verticalScrollBar.visible = _loc7_;
  187.                scrollAreaChanged = true;
  188.             }
  189.             if(verticalScrollBar && verticalScrollBar.visible && (numberOfRows != param3 || viewableRows != param4 || scrollAreaChanged))
  190.             {
  191.                verticalScrollBar.setScrollProperties(param4,0,param3 - param4);
  192.                if(verticalScrollBar.scrollPosition != mx_internal::_verticalScrollPosition)
  193.                {
  194.                   verticalScrollBar.scrollPosition = mx_internal::_verticalScrollPosition;
  195.                }
  196.                viewableRows = param4;
  197.                numberOfRows = param3;
  198.             }
  199.          }
  200.          else if((_loc6_ == ScrollPolicy.AUTO || _loc6_ == ScrollPolicy.OFF) && verticalScrollBar && verticalScrollBar.visible)
  201.          {
  202.             verticalScrollPosition = 0;
  203.             verticalScrollBar.setScrollProperties(param4,0,0);
  204.             verticalScrollBar.visible = false;
  205.             viewableRows = NaN;
  206.             scrollAreaChanged = true;
  207.          }
  208.          if(scrollAreaChanged)
  209.          {
  210.             updateDisplayList(unscaledWidth,unscaledHeight);
  211.          }
  212.       }
  213.       
  214.       private function createHScrollBar(param1:Boolean) : ScrollBar
  215.       {
  216.          horizontalScrollBar = new HScrollBar();
  217.          horizontalScrollBar.visible = param1;
  218.          horizontalScrollBar.enabled = enabled;
  219.          var _loc2_:String = getStyle("horizontalScrollBarStyleName");
  220.          horizontalScrollBar.styleName = _loc2_;
  221.          addChild(horizontalScrollBar);
  222.          horizontalScrollBar.validateNow();
  223.          return horizontalScrollBar;
  224.       }
  225.       
  226.       [Bindable("horizontalScrollPolicyChanged")]
  227.       public function get horizontalScrollPolicy() : String
  228.       {
  229.          return mx_internal::_horizontalScrollPolicy;
  230.       }
  231.       
  232.       [Bindable("maxVerticalScrollPositionChanged")]
  233.       public function get maxVerticalScrollPosition() : Number
  234.       {
  235.          if(!isNaN(mx_internal::_maxVerticalScrollPosition))
  236.          {
  237.             return mx_internal::_maxVerticalScrollPosition;
  238.          }
  239.          return !!verticalScrollBar ? verticalScrollBar.maxScrollPosition : 0;
  240.       }
  241.       
  242.       public function set horizontalScrollPosition(param1:Number) : void
  243.       {
  244.          mx_internal::_horizontalScrollPosition = param1;
  245.          if(horizontalScrollBar)
  246.          {
  247.             horizontalScrollBar.scrollPosition = param1;
  248.          }
  249.          dispatchEvent(new Event("viewChanged"));
  250.       }
  251.       
  252.       protected function roomForScrollBar(param1:ScrollBar, param2:Number, param3:Number) : Boolean
  253.       {
  254.          var _loc4_:EdgeMetrics = borderMetrics;
  255.          return param2 >= param1.minWidth + _loc4_.left + _loc4_.right && param3 >= param1.minHeight + _loc4_.top + _loc4_.bottom;
  256.       }
  257.       
  258.       public function set maxHorizontalScrollPosition(param1:Number) : void
  259.       {
  260.          mx_internal::_maxHorizontalScrollPosition = param1;
  261.          dispatchEvent(new Event("maxHorizontalScrollPositionChanged"));
  262.       }
  263.       
  264.       [Bindable("viewChanged")]
  265.       [Bindable("scroll")]
  266.       public function get verticalScrollPosition() : Number
  267.       {
  268.          return mx_internal::_verticalScrollPosition;
  269.       }
  270.       
  271.       public function set horizontalScrollPolicy(param1:String) : void
  272.       {
  273.          var _loc2_:String = param1.toLowerCase();
  274.          if(mx_internal::_horizontalScrollPolicy != _loc2_)
  275.          {
  276.             mx_internal::_horizontalScrollPolicy = _loc2_;
  277.             invalidateDisplayList();
  278.             dispatchEvent(new Event("horizontalScrollPolicyChanged"));
  279.          }
  280.       }
  281.       
  282.       override protected function createChildren() : void
  283.       {
  284.          var _loc1_:Graphics = null;
  285.          super.createChildren();
  286.          createBorder();
  287.          if(!maskShape)
  288.          {
  289.             maskShape = new FlexShape();
  290.             maskShape.name = "mask";
  291.             _loc1_ = maskShape.graphics;
  292.             _loc1_.beginFill(16777215);
  293.             _loc1_.drawRect(0,0,10,10);
  294.             _loc1_.endFill();
  295.             addChild(maskShape);
  296.          }
  297.          maskShape.visible = false;
  298.       }
  299.       
  300.       override public function styleChanged(param1:String) : void
  301.       {
  302.          var _loc3_:String = null;
  303.          var _loc4_:String = null;
  304.          var _loc2_:Boolean = param1 == null || param1 == "styleName";
  305.          super.styleChanged(param1);
  306.          if(_loc2_ || param1 == "horizontalScrollBarStyleName")
  307.          {
  308.             if(horizontalScrollBar)
  309.             {
  310.                _loc3_ = getStyle("horizontalScrollBarStyleName");
  311.                horizontalScrollBar.styleName = _loc3_;
  312.             }
  313.          }
  314.          if(_loc2_ || param1 == "verticalScrollBarStyleName")
  315.          {
  316.             if(verticalScrollBar)
  317.             {
  318.                _loc4_ = getStyle("verticalScrollBarStyleName");
  319.                verticalScrollBar.styleName = _loc4_;
  320.             }
  321.          }
  322.          if(_loc2_ || param1 == "borderSkin")
  323.          {
  324.             if(border)
  325.             {
  326.                removeChild(DisplayObject(border));
  327.                border = null;
  328.                createBorder();
  329.             }
  330.          }
  331.       }
  332.       
  333.       private function createVScrollBar(param1:Boolean) : ScrollBar
  334.       {
  335.          verticalScrollBar = new VScrollBar();
  336.          verticalScrollBar.visible = param1;
  337.          verticalScrollBar.enabled = enabled;
  338.          var _loc2_:String = getStyle("verticalScrollBarStyleName");
  339.          verticalScrollBar.styleName = _loc2_;
  340.          addChild(verticalScrollBar);
  341.          return verticalScrollBar;
  342.       }
  343.       
  344.       mx_internal function get scroll_verticalScrollBar() : ScrollBar
  345.       {
  346.          return verticalScrollBar;
  347.       }
  348.       
  349.       protected function createBorder() : void
  350.       {
  351.          var _loc1_:Class = null;
  352.          if(!border && isBorderNeeded())
  353.          {
  354.             _loc1_ = getStyle("borderSkin");
  355.             if(_loc1_ != null)
  356.             {
  357.                border = new _loc1_();
  358.                if(border is IUIComponent)
  359.                {
  360.                   IUIComponent(border).enabled = enabled;
  361.                }
  362.                if(border is ISimpleStyleClient)
  363.                {
  364.                   ISimpleStyleClient(border).styleName = this;
  365.                }
  366.                addChildAt(DisplayObject(border),0);
  367.                invalidateDisplayList();
  368.             }
  369.          }
  370.       }
  371.       
  372.       mx_internal function get scroll_horizontalScrollBar() : ScrollBar
  373.       {
  374.          return horizontalScrollBar;
  375.       }
  376.       
  377.       protected function layoutChrome(param1:Number, param2:Number) : void
  378.       {
  379.          if(border)
  380.          {
  381.             border.move(0,0);
  382.             border.setActualSize(param1,param2);
  383.          }
  384.       }
  385.       
  386.       protected function scrollHandler(param1:Event) : void
  387.       {
  388.          var _loc2_:ScrollBar = null;
  389.          var _loc3_:Number = NaN;
  390.          var _loc4_:QName = null;
  391.          if(param1 is ScrollEvent)
  392.          {
  393.             _loc2_ = ScrollBar(param1.target);
  394.             _loc3_ = _loc2_.scrollPosition;
  395.             if(_loc2_ == verticalScrollBar)
  396.             {
  397.                _loc4_ = new QName(mx_internal,"_verticalScrollPosition");
  398.             }
  399.             else if(_loc2_ == horizontalScrollBar)
  400.             {
  401.                _loc4_ = new QName(mx_internal,"_horizontalScrollPosition");
  402.             }
  403.             dispatchEvent(param1);
  404.             if(_loc4_)
  405.             {
  406.                this[_loc4_] = _loc3_;
  407.             }
  408.          }
  409.       }
  410.       
  411.       protected function mouseWheelHandler(param1:MouseEvent) : void
  412.       {
  413.          var _loc2_:int = 0;
  414.          var _loc3_:Number = NaN;
  415.          var _loc4_:Number = NaN;
  416.          var _loc5_:ScrollEvent = null;
  417.          if(Boolean(verticalScrollBar) && verticalScrollBar.visible)
  418.          {
  419.             param1.stopPropagation();
  420.             _loc2_ = param1.delta <= 0 ? 1 : -1;
  421.             _loc3_ = Math.max(Math.abs(param1.delta),verticalScrollBar.lineScrollSize);
  422.             _loc4_ = verticalScrollPosition;
  423.             verticalScrollPosition += 3 * _loc3_ * _loc2_;
  424.             _loc5_ = new ScrollEvent(ScrollEvent.SCROLL);
  425.             _loc5_.direction = ScrollEventDirection.VERTICAL;
  426.             _loc5_.position = verticalScrollPosition;
  427.             _loc5_.delta = verticalScrollPosition - _loc4_;
  428.             dispatchEvent(_loc5_);
  429.          }
  430.       }
  431.       
  432.       private function scrollTipHandler(param1:Event) : void
  433.       {
  434.          var _loc2_:ScrollBar = null;
  435.          var _loc3_:* = false;
  436.          var _loc4_:String = null;
  437.          var _loc5_:Number = NaN;
  438.          var _loc6_:String = null;
  439.          var _loc7_:Point = null;
  440.          if(param1 is ScrollEvent)
  441.          {
  442.             if(!showScrollTips)
  443.             {
  444.                return;
  445.             }
  446.             if(ScrollEvent(param1).detail == ScrollEventDetail.THUMB_POSITION)
  447.             {
  448.                if(scrollTip)
  449.                {
  450.                   systemManager.topLevelSystemManager.removeChildFromSandboxRoot("toolTipChildren",scrollTip as DisplayObject);
  451.                   scrollTip = null;
  452.                   ToolTipManager.enabled = oldTTMEnabled;
  453.                }
  454.             }
  455.             else if(ScrollEvent(param1).detail == ScrollEventDetail.THUMB_TRACK)
  456.             {
  457.                _loc2_ = ScrollBar(param1.target);
  458.                _loc3_ = _loc2_ == verticalScrollBar;
  459.                _loc4_ = _loc3_ ? "vertical" : "horizontal";
  460.                _loc5_ = _loc2_.scrollPosition;
  461.                if(!scrollTip)
  462.                {
  463.                   scrollTip = new ToolTip();
  464.                   systemManager.topLevelSystemManager.addChildToSandboxRoot("toolTipChildren",scrollTip as DisplayObject);
  465.                   scrollThumbMidPoint = _loc2_.mx_internal::scrollThumb.height / 2;
  466.                   oldTTMEnabled = ToolTipManager.enabled;
  467.                   ToolTipManager.enabled = false;
  468.                }
  469.                _loc6_ = _loc5_.toString();
  470.                if(_scrollTipFunction != null)
  471.                {
  472.                   _loc6_ = _scrollTipFunction(_loc4_,_loc5_);
  473.                }
  474.                if(_loc6_ == "")
  475.                {
  476.                   scrollTip.visible = false;
  477.                }
  478.                else
  479.                {
  480.                   scrollTip.text = _loc6_;
  481.                   ToolTipManager.mx_internal::sizeTip(scrollTip);
  482.                   _loc7_ = new Point();
  483.                   if(_loc3_)
  484.                   {
  485.                      _loc7_.x = -3 - scrollTip.width;
  486.                      _loc7_.y = _loc2_.mx_internal::scrollThumb.y + scrollThumbMidPoint - scrollTip.height / 2;
  487.                   }
  488.                   else
  489.                   {
  490.                      _loc7_.x = -3 - scrollTip.height;
  491.                      _loc7_.y = _loc2_.mx_internal::scrollThumb.y + scrollThumbMidPoint - scrollTip.width / 2;
  492.                   }
  493.                   _loc7_ = _loc2_.localToGlobal(_loc7_);
  494.                   scrollTip.move(_loc7_.x,_loc7_.y);
  495.                   scrollTip.visible = true;
  496.                }
  497.             }
  498.          }
  499.       }
  500.       
  501.       public function set verticalScrollPosition(param1:Number) : void
  502.       {
  503.          mx_internal::_verticalScrollPosition = param1;
  504.          if(verticalScrollBar)
  505.          {
  506.             verticalScrollBar.scrollPosition = param1;
  507.          }
  508.          dispatchEvent(new Event("viewChanged"));
  509.       }
  510.       
  511.       [Bindable("viewChanged")]
  512.       [Bindable("scroll")]
  513.       public function get horizontalScrollPosition() : Number
  514.       {
  515.          return mx_internal::_horizontalScrollPosition;
  516.       }
  517.       
  518.       private function isBorderNeeded() : Boolean
  519.       {
  520.          var _loc1_:Object = getStyle("borderStyle");
  521.          if(_loc1_)
  522.          {
  523.             if(_loc1_ != "none" || _loc1_ == "none" && getStyle("mouseShield"))
  524.             {
  525.                return true;
  526.             }
  527.          }
  528.          _loc1_ = getStyle("backgroundColor");
  529.          if(_loc1_ !== null && _loc1_ !== "")
  530.          {
  531.             return true;
  532.          }
  533.          _loc1_ = getStyle("backgroundImage");
  534.          return _loc1_ != null && _loc1_ != "";
  535.       }
  536.       
  537.       [Bindable("maxHorizontalScrollPositionChanged")]
  538.       public function get maxHorizontalScrollPosition() : Number
  539.       {
  540.          if(!isNaN(mx_internal::_maxHorizontalScrollPosition))
  541.          {
  542.             return mx_internal::_maxHorizontalScrollPosition;
  543.          }
  544.          return !!horizontalScrollBar ? horizontalScrollBar.maxScrollPosition : 0;
  545.       }
  546.       
  547.       public function set maxVerticalScrollPosition(param1:Number) : void
  548.       {
  549.          mx_internal::_maxVerticalScrollPosition = param1;
  550.          dispatchEvent(new Event("maxVerticalScrollPositionChanged"));
  551.       }
  552.       
  553.       public function set verticalScrollPolicy(param1:String) : void
  554.       {
  555.          var _loc2_:String = param1.toLowerCase();
  556.          if(mx_internal::_verticalScrollPolicy != _loc2_)
  557.          {
  558.             mx_internal::_verticalScrollPolicy = _loc2_;
  559.             invalidateDisplayList();
  560.             dispatchEvent(new Event("verticalScrollPolicyChanged"));
  561.          }
  562.       }
  563.       
  564.       public function get viewMetrics() : EdgeMetrics
  565.       {
  566.          _viewMetrics = borderMetrics.clone();
  567.          if(!horizontalScrollBar && horizontalScrollPolicy == ScrollPolicy.ON)
  568.          {
  569.             createHScrollBar(true);
  570.             horizontalScrollBar.addEventListener(ScrollEvent.SCROLL,scrollHandler);
  571.             horizontalScrollBar.addEventListener(ScrollEvent.SCROLL,scrollTipHandler);
  572.             horizontalScrollBar.scrollPosition = mx_internal::_horizontalScrollPosition;
  573.             invalidateDisplayList();
  574.          }
  575.          if(!verticalScrollBar && verticalScrollPolicy == ScrollPolicy.ON)
  576.          {
  577.             createVScrollBar(true);
  578.             verticalScrollBar.addEventListener(ScrollEvent.SCROLL,scrollHandler);
  579.             verticalScrollBar.addEventListener(ScrollEvent.SCROLL,scrollTipHandler);
  580.             verticalScrollBar.scrollPosition = mx_internal::_verticalScrollPosition;
  581.             invalidateDisplayList();
  582.          }
  583.          if(Boolean(verticalScrollBar) && verticalScrollBar.visible)
  584.          {
  585.             _viewMetrics.right += verticalScrollBar.minWidth;
  586.          }
  587.          if(Boolean(horizontalScrollBar) && horizontalScrollBar.visible)
  588.          {
  589.             _viewMetrics.bottom += horizontalScrollBar.minHeight;
  590.          }
  591.          return _viewMetrics;
  592.       }
  593.       
  594.       [Bindable("verticalScrollPolicyChanged")]
  595.       public function get verticalScrollPolicy() : String
  596.       {
  597.          return mx_internal::_verticalScrollPolicy;
  598.       }
  599.       
  600.       public function get borderMetrics() : EdgeMetrics
  601.       {
  602.          return Boolean(border) && border is IRectangularBorder ? IRectangularBorder(border).borderMetrics : EdgeMetrics.EMPTY;
  603.       }
  604.    }
  605. }
  606.  
  607.