home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Multimedija / shufflr.air / ShufflrClient.swf / scripts / mx / controls / VideoDisplay.as < prev    next >
Encoding:
Text File  |  2010-06-23  |  24.3 KB  |  805 lines

  1. package mx.controls
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.events.Event;
  5.    import flash.events.ProgressEvent;
  6.    import flash.media.Camera;
  7.    import mx.controls.videoClasses.VideoPlayer;
  8.    import mx.core.EdgeMetrics;
  9.    import mx.core.IFlexDisplayObject;
  10.    import mx.core.IRectangularBorder;
  11.    import mx.core.IUIComponent;
  12.    import mx.core.UIComponent;
  13.    import mx.core.mx_internal;
  14.    import mx.events.CuePointEvent;
  15.    import mx.events.FlexEvent;
  16.    import mx.events.MetadataEvent;
  17.    import mx.events.VideoEvent;
  18.    import mx.styles.ISimpleStyleClient;
  19.    import mx.utils.LoaderUtil;
  20.    
  21.    use namespace mx_internal;
  22.    
  23.    public class VideoDisplay extends UIComponent
  24.    {
  25.       mx_internal static const VERSION:String = "3.5.0.12683";
  26.       
  27.       private static const DEFAULT_WIDTH:Number = 10;
  28.       
  29.       private static const DEFAULT_HEIGHT:Number = 10;
  30.       
  31.       private var sourceChanged:Boolean = false;
  32.       
  33.       private var _playheadUpdateInterval:int = -1;
  34.       
  35.       private var _autoBandWidthDetection:Boolean = false;
  36.       
  37.       protected var border:IFlexDisplayObject;
  38.       
  39.       private var _idleTimeout:int = -1;
  40.       
  41.       private var _volume:Number = 0.75;
  42.       
  43.       private var _source:String = null;
  44.       
  45.       private var creationCompleted:Boolean = false;
  46.       
  47.       mx_internal var videoPlayer:VideoPlayer = null;
  48.       
  49.       private var _ncManagerClass:Class = null;
  50.       
  51.       private var _maintainAspectRatio:Boolean = true;
  52.       
  53.       private var _cuePointManagerClass:Class = null;
  54.       
  55.       private var _progressInterval:int = -1;
  56.       
  57.       private var _cuePoints:Array = null;
  58.       
  59.       private var asCuePointIndexResetPending:Boolean = false;
  60.       
  61.       private var makeVideoVisibleOnLayout:Boolean = false;
  62.       
  63.       private var _cuePointManager:Object = null;
  64.       
  65.       private var closeCalled:Boolean = false;
  66.       
  67.       private var _totalTime:Number = NaN;
  68.       
  69.       private var _live:Boolean = false;
  70.       
  71.       private var _bufferTime:Number = 0.1;
  72.       
  73.       private var _playheadTime:Number = NaN;
  74.       
  75.       private var _autoPlay:Boolean = true;
  76.       
  77.       private var _autoRewind:Boolean = true;
  78.       
  79.       public function VideoDisplay()
  80.       {
  81.          super();
  82.          addEventListener(FlexEvent.CREATION_COMPLETE,creationCompleteHandler);
  83.       }
  84.       
  85.       [Bindable("playheadUpdate")]
  86.       [Bindable("playheadTimeChanged")]
  87.       [Bindable("change")]
  88.       public function get playheadTime() : Number
  89.       {
  90.          return mx_internal::videoPlayer != null ? mx_internal::videoPlayer.playheadTime : _playheadTime;
  91.       }
  92.       
  93.       public function set playheadTime(param1:Number) : void
  94.       {
  95.          _playheadTime = param1;
  96.          asCuePointIndexResetPending = true;
  97.          if(mx_internal::videoPlayer)
  98.          {
  99.             mx_internal::videoPlayer.playheadTime = param1;
  100.             dispatchEvent(new Event("playheadTimeChanged"));
  101.          }
  102.       }
  103.       
  104.       [Bindable("autoBandWidthDetection")]
  105.       public function get autoBandWidthDetection() : Boolean
  106.       {
  107.          return _autoBandWidthDetection;
  108.       }
  109.       
  110.       public function set autoBandWidthDetection(param1:Boolean) : void
  111.       {
  112.          if(_autoBandWidthDetection != param1)
  113.          {
  114.             _autoBandWidthDetection = param1;
  115.             if(mx_internal::videoPlayer)
  116.             {
  117.                mx_internal::videoPlayer.autoBandWidthDetection = param1;
  118.             }
  119.             dispatchEvent(new Event("autoBandWidthDetectionChanged"));
  120.          }
  121.       }
  122.       
  123.       [Bindable("maintainAspectRatioChanged")]
  124.       public function get maintainAspectRatio() : Boolean
  125.       {
  126.          return _maintainAspectRatio;
  127.       }
  128.       
  129.       [Bindable("resize")]
  130.       public function get videoWidth() : int
  131.       {
  132.          return !!mx_internal::videoPlayer ? mx_internal::videoPlayer.videoWidth : -1;
  133.       }
  134.       
  135.       public function set autoPlay(param1:Boolean) : void
  136.       {
  137.          _autoPlay = param1;
  138.       }
  139.       
  140.       public function set cuePointManagerClass(param1:Class) : void
  141.       {
  142.          _cuePointManagerClass = param1;
  143.       }
  144.       
  145.       public function stop() : void
  146.       {
  147.          if(!mx_internal::videoPlayer)
  148.          {
  149.             return;
  150.          }
  151.          mx_internal::videoPlayer.stop();
  152.       }
  153.       
  154.       public function get progressInterval() : int
  155.       {
  156.          if(mx_internal::videoPlayer)
  157.          {
  158.             return mx_internal::videoPlayer.progressInterval;
  159.          }
  160.          return _progressInterval == -1 ? int(VideoPlayer.DEFAULT_UPDATE_PROGRESS_INTERVAL) : _progressInterval;
  161.       }
  162.       
  163.       public function set maintainAspectRatio(param1:Boolean) : void
  164.       {
  165.          if(_maintainAspectRatio != param1)
  166.          {
  167.             _maintainAspectRatio = param1;
  168.             invalidateSize();
  169.             invalidateDisplayList();
  170.             dispatchEvent(new Event("maintainAspectRatioChanged"));
  171.          }
  172.       }
  173.       
  174.       private function videoPlayer_metadataHandler(param1:MetadataEvent) : void
  175.       {
  176.          resizeVideo();
  177.          dispatchEvent(param1.clone());
  178.       }
  179.       
  180.       [Bindable("volumeChanged")]
  181.       public function get volume() : Number
  182.       {
  183.          return !!mx_internal::videoPlayer ? mx_internal::videoPlayer.volume : _volume;
  184.       }
  185.       
  186.       [Bindable("sourceChanged")]
  187.       public function get source() : String
  188.       {
  189.          return _source;
  190.       }
  191.       
  192.       private function get ncManagerClass() : Class
  193.       {
  194.          return _ncManagerClass != null ? _ncManagerClass : VideoPlayer.DEFAULT_INCMANAGER;
  195.       }
  196.       
  197.       public function set progressInterval(param1:int) : void
  198.       {
  199.          if(_progressInterval != param1)
  200.          {
  201.             _progressInterval = param1;
  202.             if(mx_internal::videoPlayer)
  203.             {
  204.                mx_internal::videoPlayer.progressInterval = param1;
  205.             }
  206.          }
  207.       }
  208.       
  209.       [Bindable("stateChange")]
  210.       public function get stateResponsive() : Boolean
  211.       {
  212.          return !!mx_internal::videoPlayer ? mx_internal::videoPlayer.stateResponsive : true;
  213.       }
  214.       
  215.       private function resizeVideo() : void
  216.       {
  217.          var _loc1_:Number = mx_internal::videoPlayer.videoWidth;
  218.          var _loc2_:Number = mx_internal::videoPlayer.videoHeight;
  219.          if(_loc1_ > 0 && _loc2_ > 0 && (measuredWidth != _loc1_ || measuredHeight != _loc2_))
  220.          {
  221.             invalidateSize();
  222.             invalidateDisplayList();
  223.             makeVideoVisibleOnLayout = true;
  224.          }
  225.       }
  226.       
  227.       [Bindable("bufferTimeChanged")]
  228.       public function get bufferTime() : Number
  229.       {
  230.          return _bufferTime;
  231.       }
  232.       
  233.       [Bindable("metadataReceived")]
  234.       public function get metadata() : Object
  235.       {
  236.          return mx_internal::videoPlayer != null ? mx_internal::videoPlayer.metadata : null;
  237.       }
  238.       
  239.       [Bindable("metadataReceived")]
  240.       [Bindable("totalTimeUpdated")]
  241.       [Bindable("complete")]
  242.       public function get totalTime() : Number
  243.       {
  244.          if(!isNaN(_totalTime))
  245.          {
  246.             return _totalTime;
  247.          }
  248.          return mx_internal::videoPlayer != null ? mx_internal::videoPlayer.totalTime : NaN;
  249.       }
  250.       
  251.       public function set volume(param1:Number) : void
  252.       {
  253.          if(_volume != param1)
  254.          {
  255.             _volume = param1;
  256.             if(mx_internal::videoPlayer)
  257.             {
  258.                mx_internal::videoPlayer.volume = param1;
  259.             }
  260.             dispatchEvent(new Event("volumeChanged"));
  261.          }
  262.       }
  263.       
  264.       [Bindable("stateChange")]
  265.       public function get playing() : Boolean
  266.       {
  267.          return mx_internal::videoPlayer != null && mx_internal::videoPlayer.state == VideoPlayer.PLAYING;
  268.       }
  269.       
  270.       public function set source(param1:String) : void
  271.       {
  272.          if(_source != param1)
  273.          {
  274.             _source = param1;
  275.             _playheadTime = NaN;
  276.             sourceChanged = true;
  277.             dispatchEvent(new Event("sourceChanged"));
  278.             if(_autoPlay && creationCompleted)
  279.             {
  280.                autoPlaying();
  281.             }
  282.          }
  283.       }
  284.       
  285.       override protected function createChildren() : void
  286.       {
  287.          super.createChildren();
  288.          createBorder();
  289.          createVideoPlayer();
  290.       }
  291.       
  292.       private function set ncManagerClass(param1:Class) : void
  293.       {
  294.          _ncManagerClass = param1;
  295.       }
  296.       
  297.       public function play() : void
  298.       {
  299.          if(!mx_internal::videoPlayer)
  300.          {
  301.             createVideoPlayer();
  302.          }
  303.          if(mx_internal::videoPlayer.playheadTime >= 0)
  304.          {
  305.             asCuePointIndexResetPending = true;
  306.          }
  307.          if(sourceChanged || closeCalled)
  308.          {
  309.             sourceChanged = false;
  310.             closeCalled = false;
  311.             mx_internal::videoPlayer.play(getActualURL(_source),_live,isNaN(_totalTime) ? -1 : _totalTime);
  312.          }
  313.          else
  314.          {
  315.             mx_internal::videoPlayer.play(null,_live,isNaN(_totalTime) ? -1 : _totalTime);
  316.          }
  317.       }
  318.       
  319.       protected function layoutChrome(param1:Number, param2:Number) : void
  320.       {
  321.          if(border)
  322.          {
  323.             border.move(0,0);
  324.             border.setActualSize(param1,param2);
  325.          }
  326.       }
  327.       
  328.       protected function createBorder() : void
  329.       {
  330.          var _loc1_:Class = null;
  331.          if(!border && isBorderNeeded())
  332.          {
  333.             _loc1_ = getStyle("borderSkin");
  334.             border = new _loc1_();
  335.             if(border is IUIComponent)
  336.             {
  337.                IUIComponent(border).enabled = enabled;
  338.             }
  339.             if(border is ISimpleStyleClient)
  340.             {
  341.                ISimpleStyleClient(border).styleName = this;
  342.             }
  343.             addChildAt(DisplayObject(border),0);
  344.             invalidateDisplayList();
  345.          }
  346.       }
  347.       
  348.       [Bindable("autoRewindChanged")]
  349.       public function get autoRewind() : Boolean
  350.       {
  351.          return _autoRewind;
  352.       }
  353.       
  354.       private function videoPlayer_rewindHandler(param1:VideoEvent) : void
  355.       {
  356.          dispatchEvent(param1.clone());
  357.       }
  358.       
  359.       [Bindable("progress")]
  360.       [Bindable("complete")]
  361.       public function get bytesLoaded() : int
  362.       {
  363.          if(mx_internal::videoPlayer)
  364.          {
  365.             return mx_internal::videoPlayer.bytesLoaded;
  366.          }
  367.          return -1;
  368.       }
  369.       
  370.       private function videoPlayer_readyHandler(param1:VideoEvent) : void
  371.       {
  372.          resizeVideo();
  373.          dispatchEvent(param1.clone());
  374.       }
  375.       
  376.       private function getActualURL(param1:String) : String
  377.       {
  378.          var _loc2_:String = null;
  379.          var _loc3_:int = 0;
  380.          if(!(param1.indexOf(":") > -1 || param1.indexOf("/") == 0 || param1.indexOf("\\") == 0))
  381.          {
  382.             if(root)
  383.             {
  384.                _loc2_ = LoaderUtil.normalizeURL(root.loaderInfo);
  385.             }
  386.             else if(systemManager)
  387.             {
  388.                _loc2_ = LoaderUtil.normalizeURL(DisplayObject(systemManager).loaderInfo);
  389.             }
  390.             if(_loc2_)
  391.             {
  392.                _loc3_ = Math.max(_loc2_.lastIndexOf("\\"),_loc2_.lastIndexOf("/"));
  393.                if(_loc3_ != -1)
  394.                {
  395.                   param1 = _loc2_.substr(0,_loc3_ + 1) + param1;
  396.                }
  397.             }
  398.          }
  399.          return param1;
  400.       }
  401.       
  402.       private function videoPlayer_stateChangeHandler(param1:VideoEvent) : void
  403.       {
  404.          if(mx_internal::videoPlayer.state == VideoPlayer.PLAYING)
  405.          {
  406.             resizeVideo();
  407.          }
  408.          if(param1.state == VideoEvent.CONNECTION_ERROR)
  409.          {
  410.             this.close();
  411.          }
  412.          dispatchEvent(param1.clone());
  413.       }
  414.       
  415.       public function set bufferTime(param1:Number) : void
  416.       {
  417.          if(_bufferTime != param1)
  418.          {
  419.             _bufferTime = param1;
  420.             if(mx_internal::videoPlayer)
  421.             {
  422.                mx_internal::videoPlayer.bufferTime = param1;
  423.             }
  424.             dispatchEvent(new Event("bufferTimeChanged"));
  425.          }
  426.       }
  427.       
  428.       override protected function measure() : void
  429.       {
  430.          var _loc2_:Number = NaN;
  431.          super.measure();
  432.          var _loc1_:Number = mx_internal::videoPlayer.videoWidth;
  433.          _loc2_ = mx_internal::videoPlayer.videoHeight;
  434.          measuredWidth = Math.max(_loc1_,DEFAULT_WIDTH);
  435.          measuredHeight = Math.max(_loc2_,DEFAULT_HEIGHT);
  436.          var _loc3_:* = !isNaN(explicitWidth);
  437.          var _loc4_:* = !isNaN(explicitHeight);
  438.          if(_maintainAspectRatio && (_loc3_ || _loc4_))
  439.          {
  440.             if(_loc3_ && !_loc4_ && _loc1_ > 0)
  441.             {
  442.                measuredHeight = explicitWidth * _loc2_ / _loc1_;
  443.             }
  444.             else if(_loc4_ && !_loc3_ && _loc2_ > 0)
  445.             {
  446.                measuredWidth = explicitHeight * _loc1_ / _loc2_;
  447.             }
  448.          }
  449.          measuredMinWidth = DEFAULT_WIDTH;
  450.          measuredMinHeight = DEFAULT_HEIGHT;
  451.       }
  452.       
  453.       private function videoPlayer_progressHandler(param1:ProgressEvent) : void
  454.       {
  455.          dispatchEvent(param1.clone());
  456.       }
  457.       
  458.       public function set totalTime(param1:Number) : void
  459.       {
  460.          if(_totalTime != param1)
  461.          {
  462.             _totalTime = param1;
  463.             dispatchEvent(new Event("totalTimeUpdated"));
  464.          }
  465.       }
  466.       
  467.       private function isBorderNeeded() : Boolean
  468.       {
  469.          var _loc1_:Object = getStyle("borderStyle");
  470.          if(_loc1_)
  471.          {
  472.             if(_loc1_ != "none" || _loc1_ == "none" && getStyle("mouseShield"))
  473.             {
  474.                return true;
  475.             }
  476.          }
  477.          _loc1_ = getStyle("backgroundColor");
  478.          if(_loc1_ !== null && _loc1_ !== "")
  479.          {
  480.             return true;
  481.          }
  482.          _loc1_ = getStyle("backgroundImage");
  483.          return _loc1_ != null && _loc1_ != "";
  484.       }
  485.       
  486.       private function videoPlayer_cuePointHandler(param1:MetadataEvent) : void
  487.       {
  488.          var _loc2_:Object = param1.info;
  489.          var _loc3_:CuePointEvent = new CuePointEvent(CuePointEvent.CUE_POINT);
  490.          _loc3_.cuePointName = _loc2_.name;
  491.          _loc3_.cuePointTime = _loc2_.time;
  492.          _loc3_.cuePointType = _loc2_.type;
  493.          dispatchEvent(_loc3_);
  494.       }
  495.       
  496.       private function autoPlaying() : void
  497.       {
  498.          if(_source)
  499.          {
  500.             if(_autoPlay)
  501.             {
  502.                play();
  503.             }
  504.             else
  505.             {
  506.                load();
  507.             }
  508.             if(!isNaN(_playheadTime))
  509.             {
  510.                asCuePointIndexResetPending = Boolean(_playheadTime >= 0);
  511.                mx_internal::videoPlayer.seek(_playheadTime);
  512.             }
  513.          }
  514.       }
  515.       
  516.       [Bindable("resize")]
  517.       public function get videoHeight() : int
  518.       {
  519.          return !!mx_internal::videoPlayer ? mx_internal::videoPlayer.videoHeight : -1;
  520.       }
  521.       
  522.       public function get autoPlay() : Boolean
  523.       {
  524.          return _autoPlay;
  525.       }
  526.       
  527.       public function get cuePointManagerClass() : Class
  528.       {
  529.          return _cuePointManagerClass;
  530.       }
  531.       
  532.       public function set autoRewind(param1:Boolean) : void
  533.       {
  534.          if(_autoRewind != param1)
  535.          {
  536.             _autoRewind = param1;
  537.             if(mx_internal::videoPlayer)
  538.             {
  539.                mx_internal::videoPlayer.autoRewind = param1;
  540.             }
  541.             dispatchEvent(new Event("autoRewindChanged"));
  542.          }
  543.       }
  544.       
  545.       [Bindable("progress")]
  546.       [Bindable("complete")]
  547.       public function get bytesTotal() : int
  548.       {
  549.          if(mx_internal::videoPlayer)
  550.          {
  551.             return mx_internal::videoPlayer.bytesTotal;
  552.          }
  553.          return -1;
  554.       }
  555.       
  556.       [Bindable("stateChange")]
  557.       public function get state() : String
  558.       {
  559.          return !!mx_internal::videoPlayer ? mx_internal::videoPlayer.state : VideoPlayer.DISCONNECTED;
  560.       }
  561.       
  562.       private function createVideoPlayer() : void
  563.       {
  564.          mx_internal::videoPlayer = new VideoPlayer(10,10,_ncManagerClass);
  565.          addChild(mx_internal::videoPlayer);
  566.          mx_internal::videoPlayer.visible = false;
  567.          mx_internal::videoPlayer.autoBandWidthDetection = _autoBandWidthDetection;
  568.          mx_internal::videoPlayer.autoRewind = _autoRewind;
  569.          mx_internal::videoPlayer.bufferTime = _bufferTime;
  570.          mx_internal::videoPlayer.volume = _volume;
  571.          if(_idleTimeout != -1)
  572.          {
  573.             mx_internal::videoPlayer.idleTimeout = _idleTimeout;
  574.          }
  575.          if(_playheadUpdateInterval != -1)
  576.          {
  577.             mx_internal::videoPlayer.playheadUpdateInterval = _playheadUpdateInterval;
  578.          }
  579.          if(_progressInterval != -1)
  580.          {
  581.             mx_internal::videoPlayer.progressInterval = _progressInterval;
  582.          }
  583.          mx_internal::videoPlayer.addEventListener(VideoEvent.PLAYHEAD_UPDATE,videoPlayer_playheadUpdateHandler);
  584.          mx_internal::videoPlayer.addEventListener(VideoEvent.COMPLETE,videoPlayer_completeHandler);
  585.          mx_internal::videoPlayer.addEventListener(MetadataEvent.CUE_POINT,videoPlayer_cuePointHandler);
  586.          mx_internal::videoPlayer.addEventListener(MetadataEvent.METADATA_RECEIVED,videoPlayer_metadataHandler);
  587.          mx_internal::videoPlayer.addEventListener(ProgressEvent.PROGRESS,videoPlayer_progressHandler);
  588.          mx_internal::videoPlayer.addEventListener(VideoEvent.READY,videoPlayer_readyHandler);
  589.          mx_internal::videoPlayer.addEventListener(VideoEvent.REWIND,videoPlayer_rewindHandler);
  590.          mx_internal::videoPlayer.addEventListener(VideoEvent.STATE_CHANGE,videoPlayer_stateChangeHandler);
  591.          if(cuePointManagerClass)
  592.          {
  593.             _cuePointManager = new cuePointManagerClass(mx_internal::videoPlayer);
  594.             _cuePointManager.videoDisplay = this;
  595.          }
  596.          if(_cuePoints)
  597.          {
  598.             setCuePoints(_cuePoints);
  599.          }
  600.       }
  601.       
  602.       private function setCuePoints(param1:Array) : void
  603.       {
  604.          if(_cuePointManager)
  605.          {
  606.             _cuePointManager.setCuePoints(param1);
  607.          }
  608.          _cuePoints = null;
  609.          dispatchEvent(new Event("cuePointsChanged"));
  610.       }
  611.       
  612.       public function attachCamera(param1:Camera) : void
  613.       {
  614.          if(!mx_internal::videoPlayer)
  615.          {
  616.             createVideoPlayer();
  617.          }
  618.          mx_internal::videoPlayer.attachCamera(param1);
  619.          mx_internal::videoPlayer.visible = true;
  620.       }
  621.       
  622.       public function get cuePointManager() : Object
  623.       {
  624.          return _cuePointManager;
  625.       }
  626.       
  627.       private function videoPlayer_playheadUpdateHandler(param1:VideoEvent) : void
  628.       {
  629.          dispatchEvent(param1.clone());
  630.          if(_cuePointManager)
  631.          {
  632.             if(asCuePointIndexResetPending && mx_internal::videoPlayer.state != VideoPlayer.SEEKING)
  633.             {
  634.                asCuePointIndexResetPending = false;
  635.                _cuePointManager.resetCuePointIndex(param1.playheadTime);
  636.             }
  637.             _cuePointManager.dispatchCuePoints();
  638.          }
  639.       }
  640.       
  641.       public function set playheadUpdateInterval(param1:int) : void
  642.       {
  643.          if(_playheadUpdateInterval != param1)
  644.          {
  645.             _playheadUpdateInterval = param1;
  646.             if(mx_internal::videoPlayer)
  647.             {
  648.                mx_internal::videoPlayer.playheadUpdateInterval = param1;
  649.             }
  650.          }
  651.       }
  652.       
  653.       private function videoPlayer_completeHandler(param1:VideoEvent) : void
  654.       {
  655.          dispatchEvent(param1.clone());
  656.       }
  657.       
  658.       public function set live(param1:Boolean) : void
  659.       {
  660.          _live = param1;
  661.       }
  662.       
  663.       public function set idleTimeout(param1:int) : void
  664.       {
  665.          if(_idleTimeout != param1)
  666.          {
  667.             _idleTimeout = param1;
  668.             if(mx_internal::videoPlayer)
  669.             {
  670.                mx_internal::videoPlayer.idleTimeout = param1;
  671.             }
  672.          }
  673.       }
  674.       
  675.       public function load() : void
  676.       {
  677.          if(!mx_internal::videoPlayer)
  678.          {
  679.             createVideoPlayer();
  680.          }
  681.          if(sourceChanged)
  682.          {
  683.             sourceChanged = false;
  684.             mx_internal::videoPlayer.load(getActualURL(_source),false,isNaN(_totalTime) ? -1 : _totalTime);
  685.          }
  686.       }
  687.       
  688.       public function set cuePoints(param1:Array) : void
  689.       {
  690.          _cuePoints = param1;
  691.          if(_cuePointManager)
  692.          {
  693.             setCuePoints(param1);
  694.          }
  695.       }
  696.       
  697.       public function get idleTimeout() : int
  698.       {
  699.          if(mx_internal::videoPlayer)
  700.          {
  701.             return mx_internal::videoPlayer.idleTimeout;
  702.          }
  703.          return _idleTimeout == -1 ? int(VideoPlayer.DEFAULT_IDLE_TIMEOUT_INTERVAL) : _idleTimeout;
  704.       }
  705.       
  706.       public function get playheadUpdateInterval() : int
  707.       {
  708.          if(mx_internal::videoPlayer)
  709.          {
  710.             return mx_internal::videoPlayer.playheadUpdateInterval;
  711.          }
  712.          return _playheadUpdateInterval == -1 ? int(VideoPlayer.DEFAULT_UPDATE_TIME_INTERVAL) : _playheadUpdateInterval;
  713.       }
  714.       
  715.       private function creationCompleteHandler(param1:FlexEvent) : void
  716.       {
  717.          removeEventListener(FlexEvent.CREATION_COMPLETE,creationCompleteHandler);
  718.          creationCompleted = true;
  719.          autoPlaying();
  720.       }
  721.       
  722.       public function get live() : Boolean
  723.       {
  724.          return _live;
  725.       }
  726.       
  727.       public function pause() : void
  728.       {
  729.          if(!mx_internal::videoPlayer)
  730.          {
  731.             return;
  732.          }
  733.          mx_internal::videoPlayer.pause();
  734.       }
  735.       
  736.       override protected function updateDisplayList(param1:Number, param2:Number) : void
  737.       {
  738.          var _loc10_:Number = NaN;
  739.          var _loc11_:Number = NaN;
  740.          super.updateDisplayList(param1,param2);
  741.          layoutChrome(param1,param2);
  742.          if(!mx_internal::videoPlayer)
  743.          {
  744.             return;
  745.          }
  746.          var _loc3_:EdgeMetrics = borderMetrics;
  747.          var _loc4_:Number = _loc3_.left;
  748.          var _loc5_:Number = _loc3_.top;
  749.          var _loc6_:Number = param1 - _loc3_.left - _loc3_.right;
  750.          var _loc7_:Number = param2 - _loc3_.top - _loc3_.bottom;
  751.          var _loc8_:Number = mx_internal::videoPlayer.videoWidth;
  752.          var _loc9_:Number = mx_internal::videoPlayer.videoHeight;
  753.          if(_maintainAspectRatio && _loc8_ > 0 && _loc9_ > 0)
  754.          {
  755.             _loc10_ = _loc6_ / _loc8_;
  756.             _loc11_ = _loc7_ / _loc9_;
  757.             if(_loc10_ < _loc11_)
  758.             {
  759.                _loc7_ = _loc6_ * _loc9_ / _loc8_;
  760.                _loc5_ = (param2 - _loc7_) / 2;
  761.             }
  762.             else if(_loc11_ < _loc10_)
  763.             {
  764.                _loc6_ = _loc7_ * _loc8_ / _loc9_;
  765.                _loc4_ = (param1 - _loc6_) / 2;
  766.             }
  767.          }
  768.          mx_internal::videoPlayer.x = _loc4_;
  769.          mx_internal::videoPlayer.y = _loc5_;
  770.          mx_internal::videoPlayer.setSize(_loc6_,_loc7_);
  771.          if(makeVideoVisibleOnLayout)
  772.          {
  773.             makeVideoVisibleOnLayout = false;
  774.             mx_internal::videoPlayer.visible = true;
  775.          }
  776.       }
  777.       
  778.       public function close() : void
  779.       {
  780.          if(!mx_internal::videoPlayer)
  781.          {
  782.             return;
  783.          }
  784.          mx_internal::videoPlayer.close();
  785.          closeCalled = true;
  786.       }
  787.       
  788.       [Bindable("cuePointsChanged")]
  789.       public function get cuePoints() : Array
  790.       {
  791.          if(!_cuePointManager)
  792.          {
  793.             return _cuePoints;
  794.          }
  795.          return _cuePointManager.getCuePoints();
  796.       }
  797.       
  798.       public function get borderMetrics() : EdgeMetrics
  799.       {
  800.          return Boolean(border) && border is IRectangularBorder ? IRectangularBorder(border).borderMetrics : EdgeMetrics.EMPTY;
  801.       }
  802.    }
  803. }
  804.  
  805.