Context Navigation

View.as @ 596

Visit:

Revision 596, 13.0 KB checked in by pablo, 4 years ago (diff)
Removed view component to locking mechanism V4 control bar locks user input to the sliders when the player is in the locked state

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Original Format