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

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