root/flash_player/trunk/src/org/korsakow/player/ExternalBindings.as @ 1255

package org.korsakow.player
{
        import flash.events.Event;
        import flash.external.ExternalInterface;
        import flash.geom.Point;
        
        import org.korsakow.debug.Debug;
        import org.korsakow.domain.exception.DomainObjectCreationException;
        import org.korsakow.domain.interf.ISnu;
        import org.korsakow.player.engine.IEnvironment;
        import org.korsakow.player.engine.event.EnvironmentEvent;
        import org.korsakow.player.widget.IWidgetComponent;

        /**
         * Defines the external interface.
         */
        public class ExternalBindings
        {
                private var _env:IEnvironment;
                private var _app:ApplicationBase;
                private var _onError:String;
                public function ExternalBindings(app:ApplicationBase, env:IEnvironment)
                {
                        _app = app;
                        _env = env;
                        
                        _env.addEventListener(EnvironmentEvent.SNU_BEGIN_PLAYING, onSnuBegin);
                }
                public function bind():void
                {
                        ExternalInterface.addCallback("addEventListener", errWrap(addEventExternalListener));
                        ExternalInterface.addCallback("pauseEngine", errWrap(pauseEngine));
                        ExternalInterface.addCallback("resumeEngine", errWrap(resumeEngine));
                        ExternalInterface.addCallback("getCurrentSnuId", errWrap(getCurrentSnuId));
                        ExternalInterface.addCallback("getCurrentMainMedia", errWrap(getCurrentMainMedia));
                        ExternalInterface.addCallback("executeSnu", errWrap(executeSnu));
                        ExternalInterface.addCallback("toString", errWrap(toString));
                        if (_app.config.has('onError')) {
                                _onError = _app.config.getString('onError');
                        }
                        if (_app.config.has("onReady")) {
                                ExternalInterface.call(_app.config.getString('onReady'), ExternalInterface.objectID);
                        }
                }
                private function handleError(e:Error):void
                {
                        handleErrorMessage(e.message + "\n" + e.getStackTrace());
                }
                private function handleErrorMessage(e:String):void
                {
                        e = ""+e;
                        Debug.log("Error in external binding", e);
                        if (_onError)
                                ExternalInterface.call(_onError, e);
                }
                private function errWrap(func:Function):Function
                {
                        return function():* {
                                try {
                                        return func.apply(null, arguments);
                                } catch (e:Error) {
                                        handleError(e);
                                }
                        };
                }
                private function onSnuBegin(event:Event):void
                {
                        if (!_env.currentMainMedia)
                                return;
//                      _env.currentMainMedia.addEventListener(MouseEvent.
                }
                public function pauseEngine():void
                {
                        return _env.pauseEngine();
                }
                public function resumeEngine():void
                {
                        return _env.resumeEngine();
                }
                public function addEventExternalListener(type:String, listener:String):void
                {
                        function wrap(e:Event):void {
                                ExternalInterface.call(listener, new ExternalEvent(e.type));
                        };
                        _env.addEventListener(type, wrap);
                }
                public function getCurrentSnuId():Number
                {
                        return _env.currentSnu?_env.currentSnu.id:-1;
                }
                public function executeSnu(id:uint):Boolean
                {
                        var snu:ISnu;
                        try {
                                snu = _env.findSnuById(id);
                        } catch (e:DomainObjectCreationException) {
                                return false;
                        }
                        if (snu)
                                _env.executeSnu(snu);
                        return true;
                }
                public function getCurrentMainMedia():ExternalWidget
                {
                        if (!_env.currentMainMedia)
                                return null;
                        var widget:IWidgetComponent = _env.currentMainMedia;
                        var pos:Point = widget.localToGlobal(new Point());
                        return new ExternalWidget(pos.x, pos.y, widget.width, widget.height);
                }
                
                public function toString():String
                {
                        return "[Korsakow Player Environment]";
                }
        }
}

internal class ExternalWidget
{
        public var x:Number;
        public var y:Number;
        public var globalX:Number;
        public var globalY:Number;
        public var width:Number;
        public var height:Number;
        
        public function ExternalWidget(x:Number, y:Number, width:Number, height:Number)
        {
                this.x = x;
                this.y = y;
                this.width = width;
                this.height = height;
        }
}

internal class ExternalEvent
{
        public var type:String;
        
        public function ExternalEvent(type:String)
        {
                this.type = type;
        }
        public function toString():String
        {
                return "[Event; " + type + "]";
        }
}