source: trunk/fl5/src/com/longtailvideo/jwplayer/view/View.as @ 587

Revision 587, 13.3 KB checked in by pablo, 4 years ago (diff)

Fixing loading order issue in FireFox for OS X
Line 
1package com.longtailvideo.jwplayer.view {
2        import com.longtailvideo.jwplayer.events.GlobalEventDispatcher;
3        import com.longtailvideo.jwplayer.events.MediaEvent;
4        import com.longtailvideo.jwplayer.events.PlayerEvent;
5        import com.longtailvideo.jwplayer.events.PlayerStateEvent;
6        import com.longtailvideo.jwplayer.events.PlaylistEvent;
7        import com.longtailvideo.jwplayer.events.ViewEvent;
8        import com.longtailvideo.jwplayer.model.Model;
9        import com.longtailvideo.jwplayer.player.IPlayer;
10        import com.longtailvideo.jwplayer.player.PlayerState;
11        import com.longtailvideo.jwplayer.player.PlayerV4Emulation;
12        import com.longtailvideo.jwplayer.plugins.IPlugin;
13        import com.longtailvideo.jwplayer.plugins.PluginConfig;
14        import com.longtailvideo.jwplayer.utils.RootReference;
15        import com.longtailvideo.jwplayer.utils.Stretcher;
16        import com.longtailvideo.jwplayer.view.interfaces.IControlbarComponent;
17        import com.longtailvideo.jwplayer.view.interfaces.IDisplayComponent;
18        import com.longtailvideo.jwplayer.view.interfaces.IDockComponent;
19        import com.longtailvideo.jwplayer.view.interfaces.IPlayerComponent;
20        import com.longtailvideo.jwplayer.view.interfaces.IPlaylistComponent;
21        import com.longtailvideo.jwplayer.view.interfaces.ISkin;
22       
23        import flash.display.DisplayObject;
24        import flash.display.Loader;
25        import flash.display.MovieClip;
26        import flash.display.Sprite;
27        import flash.display.Stage;
28        import flash.display.StageAlign;
29        import flash.display.StageDisplayState;
30        import flash.display.StageScaleMode;
31        import flash.events.ErrorEvent;
32        import flash.events.Event;
33        import flash.events.IOErrorEvent;
34        import flash.net.URLRequest;
35
36        public class View extends GlobalEventDispatcher {
37                private var _player:IPlayer;
38                private var _model:Model;
39                private var _skin:ISkin;
40                private var _components:IPlayerComponents;
41                private var _fullscreen:Boolean = false;
42                private var stage:Stage;
43
44                private var _root:MovieClip;
45
46                private var _backgroundLayer:MovieClip;
47                private var _mediaLayer:MovieClip;
48                private var _imageLayer:MovieClip;
49                private var _componentsLayer:MovieClip;
50                private var _logoLayer:MovieClip;
51                private var _pluginsLayer:MovieClip;
52                private var _plugins:Object;
53
54                private var _displayMasker:MovieClip;
55
56                private var _image:Loader;
57                private var _logo:Logo;
58
59                private var layoutManager:PlayerLayoutManager;
60               
61                [Embed(source="../../../../../assets/flash/loader/loader.swf")]
62                private var LoadingScreen:Class;
63
64                [Embed(source="../../../../../assets/flash/loader/error.swf")]
65                private var ErrorScreen:Class;
66
67                private var loaderScreen:Sprite;
68                private var loaderAnim:DisplayObject;
69               
70                public function View(player:IPlayer, model:Model) {
71                        _player = player;
72                        _model = model;
73
74                        RootReference.stage.scaleMode = StageScaleMode.NO_SCALE;
75                        RootReference.stage.stage.align = StageAlign.TOP_LEFT;
76
77                        loaderScreen = new Sprite();
78                        loaderScreen.name = 'loaderScreen';
79                       
80                        loaderAnim = new LoadingScreen() as DisplayObject;
81                        loaderScreen.addChild(loaderAnim);
82
83                        RootReference.stage.addChildAt(loaderScreen, 0);
84
85                        if (RootReference.stage.stageWidth > 0) {
86                                resizeStage();
87                        } else {
88                                RootReference.stage.addEventListener(Event.RESIZE, resizeStage);
89                                RootReference.stage.addEventListener(Event.ADDED_TO_STAGE, resizeStage);
90                        }
91
92                        _root = new MovieClip();
93                }
94               
95                private function resizeStage(evt:Event=null):void {
96                        RootReference.stage.scaleMode = StageScaleMode.NO_SCALE;
97                        RootReference.stage.stage.align = StageAlign.TOP_LEFT;
98                       
99                        loaderScreen.graphics.clear();
100                        loaderScreen.graphics.beginFill(0, 1);
101                        loaderScreen.graphics.drawRect(0, 0, RootReference.stage.stageWidth, RootReference.stage.stageHeight);
102                        loaderScreen.graphics.endFill();
103                       
104                       
105                        loaderAnim.x = (RootReference.stage.stageWidth - loaderAnim.width) / 2;
106                        loaderAnim.y = (RootReference.stage.stageHeight - loaderAnim.height) / 2;
107                       
108                        trace("stage dimensions: " + RootReference.stage.stageWidth + "x" + RootReference.stage.stageHeight);
109                        trace("loaderAnim dimensions: " + loaderAnim.width + "x" + loaderAnim.height);
110                        trace("loaderAnim Position: " + loaderAnim.x + ", " + loaderAnim.y);
111                        trace("loaderScreen Position: " + loaderScreen.x + ", " + loaderScreen.y);
112                       
113                }
114
115                public function get skin():ISkin {
116                        return _skin;
117                }
118
119
120                public function set skin(skn:ISkin):void {
121                        _skin = skn;
122                }
123               
124                public function setupView():void {
125                        setupLayers();
126                        setupComponents();
127
128                        RootReference.stage.addEventListener(Event.FULLSCREEN, resizeHandler);
129                        RootReference.stage.addEventListener(Event.RESIZE, resizeHandler);
130
131                        _model.addEventListener(MediaEvent.JWPLAYER_MEDIA_LOADED, mediaLoaded);
132                        _model.playlist.addEventListener(PlaylistEvent.JWPLAYER_PLAYLIST_ITEM, itemHandler);
133                        _model.addEventListener(PlayerStateEvent.JWPLAYER_PLAYER_STATE, stateHandler);
134
135                        layoutManager = new PlayerLayoutManager(_player);
136                        var menu:RightclickMenu = new RightclickMenu(_model, _root);
137                        menu.addGlobalListener(forward);
138                       
139                        redraw();
140                }
141               
142                public function completeView(isError:Boolean=false, errorMsg:String=""):void {
143                        if (!isError) {
144                                RootReference.stage.removeChild(loaderScreen);
145                                RootReference.stage.addChildAt(_root, 0);
146                        } else {
147                                loaderScreen.removeChild(loaderAnim);
148                                var errorScreen:DisplayObject = new ErrorScreen() as DisplayObject;
149                                errorScreen.x = (loaderScreen.width - errorScreen.width) / 2;
150                                errorScreen.y = (loaderScreen.height - errorScreen.height) / 2;
151                                loaderScreen.addChild(errorScreen);
152                        }
153                }
154               
155                private function setupLayers():void {
156                        _backgroundLayer = setupLayer("background", 0);
157                        setupBackground();
158                       
159                        _mediaLayer = setupLayer("media", 1);
160                        _mediaLayer.visible = false;
161
162                        _imageLayer = setupLayer("image", 2);
163                        _image = new Loader();
164
165                        _componentsLayer = setupLayer("components", 3);
166
167                        _pluginsLayer = setupLayer("plugins", 4);
168                        _plugins = {};
169
170                        _logoLayer = setupLayer("logo", 5);
171                        _logo = new Logo(_player);
172                        _logoLayer.addChild(_logo);
173                }
174
175                private function setupLayer(name:String, index:Number):MovieClip {
176                        var layer:MovieClip = new MovieClip();
177                        _root.addChildAt(layer, index);
178                        layer.name = name;
179                        layer.x = 0;
180                        layer.y = 0;
181                        return layer;
182                }
183
184                private function setupBackground():void {
185                        var background:MovieClip = new MovieClip();
186                        background.name = "background";
187                        _backgroundLayer.addChild(background);
188                        background.graphics.beginFill(_player.config.screencolor ? _player.config.screencolor.color : 0x000000, 1);
189                        background.graphics.drawRect(0, 0, 1, 1);
190                        background.graphics.endFill();
191                }
192
193                private function setupDisplayMask():void {
194                        _displayMasker = new MovieClip();
195                        _displayMasker.graphics.beginFill(0x000000, 1);
196                        _displayMasker.graphics.drawRect(0, 0, _player.config.width, _player.config.height);
197                        _displayMasker.graphics.endFill();
198                       
199                        _backgroundLayer.mask = _displayMasker;
200                        _imageLayer.mask = _displayMasker;
201                        _mediaLayer.mask = _displayMasker;
202                }
203               
204                private function setupComponents():void {
205                        _components = new PlayerComponents(_player);
206                       
207                        setupComponent(_components.display, 0);
208                        setupComponent(_components.playlist, 1);
209                        setupComponent(_components.controlbar, 2);
210                        setupComponent(_components.dock, 3);
211                }
212               
213                private function setupComponent(component:IPlayerComponent, index:Number):void {
214                        component.addGlobalListener(forward);
215                        _componentsLayer.addChildAt(component as DisplayObject, index);
216                }
217               
218               
219                private function resizeHandler(event:Event):void {
220                        redraw();
221
222                        var currentFSMode:Boolean = (RootReference.stage.displayState == StageDisplayState.FULL_SCREEN);
223                        if (_model.fullscreen != currentFSMode) {
224                                dispatchEvent(new ViewEvent(ViewEvent.JWPLAYER_VIEW_FULLSCREEN, currentFSMode));
225                        }
226                }
227                               
228               
229                public function fullscreen(mode:Boolean=true):void {
230                        RootReference.stage.displayState = mode ? StageDisplayState.FULL_SCREEN : StageDisplayState.NORMAL;
231                }
232
233                /** Redraws the plugins and player components **/
234                public function redraw():void {
235                        layoutManager.resize(RootReference.stage.stageWidth, RootReference.stage.stageHeight);
236
237                        _components.resize(_player.config.width, _player.config.height);
238
239                        resizeBackground();
240                        resizeMasker();
241
242                        if (_imageLayer.numChildren) {
243                                _imageLayer.x = _components.display.x;
244                                _imageLayer.y = _components.display.y;
245                                Stretcher.stretch(_image, _player.config.width, _player.config.height, _player.config.stretching);
246                        }
247                       
248                        if (_mediaLayer.numChildren && _model.media.display) {
249                                _mediaLayer.x = _components.display.x;
250                                _mediaLayer.y = _components.display.y;
251                                _model.media.resize(_player.config.width, _player.config.height);
252                        }
253
254                        if (_logoLayer.numChildren) {
255                                _logoLayer.x = _components.display.x;
256                                _logoLayer.y = _components.display.y;
257                                _logo.resize(_player.config.width, _player.config.height);
258                        }
259                       
260                        for (var i:Number = 0; i < _pluginsLayer.numChildren; i++) {
261                                var plug:IPlugin = _pluginsLayer.getChildAt(i) as IPlugin;
262                                var plugDisplay:DisplayObject = plug as DisplayObject;
263                                if (plug && plugDisplay) {
264                                        var cfg:PluginConfig = _player.config.pluginConfig(plug.id);
265                                        if (cfg['visible']) {
266                                                plugDisplay.visible = true;
267                                                plugDisplay.x = cfg['x'];
268                                                plugDisplay.y = cfg['y'];
269                                                plug.resize(cfg.width, cfg.height);
270                                        } else {
271                                                plugDisplay.visible = false;
272                                        }
273                                }
274                        }
275                        PlayerV4Emulation.getInstance(_player).resize(_player.config.width, _player.config.height);
276                }
277
278                private function resizeBackground():void {
279                        var bg:DisplayObject = _backgroundLayer.getChildByName("background");
280                        bg.width = _player.config.width;
281                        bg.height = _player.config.height;
282                        bg.x = _components.display.x;
283                        bg.y = _components.display.y;
284                }
285
286                private function resizeMasker():void {
287                        if (_displayMasker == null) setupDisplayMask();
288                       
289                        _displayMasker.graphics.clear();
290                        _displayMasker.graphics.beginFill(0, 1);
291                        _displayMasker.graphics.drawRect(_components.display.x, _components.display.y, _player.config.width, _player.config.height);
292                        _displayMasker.graphics.endFill();
293                }
294
295                public function get components():IPlayerComponents {
296                        return _components;
297                }
298
299                public function overrideComponent(newComponent:IPlayerComponent):void {
300                        if (newComponent is IControlbarComponent) {
301                                // Replace controlbar
302                        } else if (newComponent is IDisplayComponent) {
303                                // Replace display
304                        } else if (newComponent is IDockComponent) {
305                                // Replace dock
306                        } else if (newComponent is IPlaylistComponent) {
307                                // Replace playlist
308                        } else {
309                                dispatchEvent(new ErrorEvent(ErrorEvent.ERROR, false, false, "Component must implement a component interface"));
310                        }
311                }
312
313                public function addPlugin(id:String, plugin:IPlugin):void {
314                        try {
315                                var plugDO:DisplayObject = plugin as DisplayObject;
316                                if (!_plugins[id] && plugDO != null) {
317                                        _plugins[id] = plugDO;
318                                        _pluginsLayer.addChild(plugDO);
319                                        //_pluginsLayer[id] = plugDO;
320                                }
321                        } catch (e:Error) {
322                                dispatchEvent(new ErrorEvent(ErrorEvent.ERROR, false, false, e.message));
323                        }
324                }
325
326                public function removePlugin(plugin:IPlugin):void {
327                        var id:String = plugin.id;
328                        if (id && _plugins[id] is IPlugin) {
329                                _pluginsLayer.removeChild(_plugins[id]);
330                                delete _plugins[id];
331                        }
332                }
333
334               
335                public function loadedPlugins():Array {
336                        var list:Array = [];
337                        for (var pluginId:String in _plugins) {
338                                if (_plugins[pluginId] is IPlugin) {
339                                        list.push(pluginId);
340                                }
341                        }
342                        return list;
343                }
344
345                public function getPlugin(id:String):IPlugin {
346                        return _plugins[id] as IPlugin;
347                }
348               
349                public function bringPluginToFront(id:String):void {
350                        var plugin:IPlugin = getPlugin(id);
351                        _pluginsLayer.setChildIndex(plugin as DisplayObject, _pluginsLayer.numChildren - 1);                   
352                }
353
354                private function mediaLoaded(evt:MediaEvent):void {
355                        _mediaLayer.x = _components.display.x;
356                        _mediaLayer.y = _components.display.y;
357                        if (_model.media.display) {
358                                _model.media.resize(_player.config.width, _player.config.height);
359                                _mediaLayer.addChild(_model.media.display);
360                        }
361                }
362
363                private function itemHandler(evt:PlaylistEvent):void {
364                        while (_mediaLayer.numChildren) {
365                                _mediaLayer.removeChildAt(0);
366                        }
367                        if (_model.playlist.currentItem && _model.playlist.currentItem.image) {
368                                loadImage(_model.playlist.currentItem.image);
369
370                        }
371                }
372
373                private function loadImage(url:String):void {
374                        while (_imageLayer.numChildren) {
375                                _imageLayer.removeChildAt(0);
376                        }
377
378                        _image = new Loader();
379                        _image.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, imageError);
380                        _image.contentLoaderInfo.addEventListener(Event.COMPLETE, imageComplete);
381                        _image.load(new URLRequest(url));
382                }
383
384                private function imageComplete(evt:Event):void {
385                        _imageLayer.addChild(_image);
386                        _imageLayer.x = _components.display.x;
387                        _imageLayer.y = _components.display.y;
388                        Stretcher.stretch(_image, _player.config.width, _player.config.height, _player.config.stretching);
389                }
390
391                private function imageError(evt:IOErrorEvent):void {
392                        _image = null;
393                        dispatchEvent(new PlayerEvent(PlayerEvent.JWPLAYER_ERROR, evt.text));
394                }
395
396                private function stateHandler(evt:PlayerStateEvent):void {
397                        switch (evt.newstate) {
398                                case PlayerState.IDLE:
399                                        _imageLayer.visible = true;
400                                        _mediaLayer.visible = false;
401                                        _logoLayer.visible = false;
402                                        break;
403                                case PlayerState.PLAYING:
404                                        if (_model.media.display) {
405                                                _imageLayer.visible = false;
406                                                _mediaLayer.visible = true;
407                                        }
408                                        _logoLayer.visible = true;
409                                        break;
410                        }
411                }
412
413                private function forward(evt:Event):void {
414                        if (evt is PlayerEvent) dispatchEvent(evt);
415                }
416
417        }
418}
Note: See TracBrowser for help on using the repository browser.