unityPane.js

Go to the documentation of this file.

 
define( [
                'remoto!stdlib:js/panes/pane.js',
                'remoto!stdlib:js/include/utils.js',
                'remoto!stdlib:js/include/objectRegistry.js',
                'remoto!stdlib:js/panes/panes/unityPane.css',
        ],
        function(pane,utils,objectRegistry)
        {
                'use strict';
 
        // Unity Pane
 
                unityPane.prototype = new pane;
                function unityPane(layout)
                {
                        pane.call(this,layout);
 
                        this._type = "unityPane";
 
                        this._url = null;
 
                        this._context = {};
                        this._config = {
                                scale: 1
                        };
                        //{
                        //      "urlPrefix": "https://some.domain.com/with/some/path/prefix",
                        //      "config": "build.json",
                        //      "progress": false
                        //}
 
 
                        this._progress = null;
                        this._instance = null;
                        this._createUnityInstance = null;
                        this._canvas = null;    //not jquery object!
 
                        this._active = false;
                        this._unityActivate = null;
                        this._unityDeactivate = null;
 
                        this._subscriptions = {};
                }
 
                unityPane.prototype.createHTML = function()
                {
                        if (this._html) return this._html;
 
                        pane.prototype.createHTML.call(this);
 
                        var h = this._content;
                        h.addClass("unityPane");
 
                        var c = $("<canvas class='unityCanvas'>").appendTo(this._content);
                        c.attr("tabindex","-1");        //for keyboard focus
                        c.bind("mouseenter mousemove", function() { c.focus(); } );
 
                        this._canvas = c[0];
 
                        //console.warn("unity create progress widget!!");
                        //this._progress =
 
                        return this._html;
                }
 
                unityPane.prototype.applySubscription = function(data,metadata)
                {
                        //console.log("unityPane applySubscription()",arguments);
 
                        this._config = utils.copyObject(data,this._config);
 
                        this._context = utils.copyObject(metadata.context,this._context);
                        this._context = utils.copyObject(this._config,this._context);
 
                        this._config = utils.resolveContextValues(this._config,this._context);
 
                        if (!this._config.urlPrefix || !this._config.config)
                                console.error("unityPane subscription did not contain a url");
 
                        var url = this._config.urlPrefix + "/" + this._config.config;
 
                        if (url !== this._url)
                        {
                                this._url = url;
 
                                //console.log("Loading unity config: ",this._url,this._config);
                                var jqxhr = $.get( this._url )
                                        .done( this.configLoaded.bind(this) )
                                        .fail( this.configLoadFail.bind(this,this._url) );
 
                                this._html.trigger("paneLoadStart");
                        }
                }
 
                unityPane.prototype.applyRequestError = function(command,id,reason)
                {
                        console.error("unityPane applyRequestError",arguments);
                }
 
                unityPane.prototype.applyDiff = function(diff,user)
                {
                        //todo later... it's complicated to receive pointers to other projects after the initial load.
                        console.error("FIXME: unityPane applyDiff()",arguments);
                }
 
                unityPane.prototype.resize = function()
                {
                        //if (this._content)
                        //      this._content.find("canvas").attr({
                        //              width: this._content.width(),
                        //              height: this._content.height()
                        //      });
                }
 
                unityPane.prototype.configLoaded = function(config)
                {
                        var THIS = this;
 
                        this._config = utils.copyObject(this._config,config);
                        this._context = utils.copyObject(this._config,this._context);
                        this._config = utils.resolveContextValues(this._config,this._context);
 
                        //if (/iPhone|iPad|iPod|Android/i.test(navigator.userAgent))
                        //      this._config.devicePixelRatio = 1;
 
                        this._config.devicePixelRatio = this._config.scale;
 
                        //console.log("CONFIG LOADED!",this._config);
 
                        // https://api.jquery.com/jquery.getscript/
                        $.getScript( this._config.loaderUrl )
                                .done( function( data, textStatus, jqxhr )
                                {
                                        if (textStatus === "success")
                                        {
                                                //console.log("loaded the loader!",THIS._config.loaderUrl,arguments);
 
                                                THIS._createUnityInstance = window.createUnityInstance;
                                                delete window.createUnityInstance;
 
                                                //THIS.resize();
 
                                                THIS._createUnityInstance(THIS._canvas, THIS._config, THIS.loadProgress.bind(THIS) )
                                                        .then( THIS.loadComplete.bind(THIS) )
                                                        .catch( THIS.loadError.bind(THIS) );
                                        }
                                        else
                                                THIS.configLoadFail(THIS._config.loaderUrl);
                                })
                                .fail( this.configLoadFail.bind(this,this._config.loaderUrl ) );
                }
 
                unityPane.prototype.configLoadFail = function(url)
                {
                        console.error("Failed to load unity setup: ",url);
                }
 
                unityPane.prototype.loadError = function(error)
                {
                        console.error("unity load error",arguments);
                }
 
                unityPane.prototype.loadProgress = function(progress)
                {
                        if (this._progress)
                        {
                                console.log("FIXME create progress widget!",progress);
                                //this._progress.value = progress;
                        }
                        else
                                console.log("unityPane load progress: ",progress);
                }
 
                unityPane.prototype.loadComplete = function(unityInstance)
                {
                        //console.log("unity load complete",arguments);
 
                        this._instance = unityInstance;
 
                        //if (this._progress)
                        //      this._progress.hide();
 
                        var sessionInfo = this._config.sessionInfo;
 
                        this.toUnity = unityInstance.Module["asmLibraryArg"]["toUnity"].bind(this);
                        this._unityActivate = unityInstance.Module["asmLibraryArg"]["activatePane"].bind(this);
                        this._unityDeactivate = unityInstance.Module["asmLibraryArg"]["deactivatePane"].bind(this);
                        unityInstance.Module["asmLibraryArg"]["registerPane"]( this.fromUnity.bind(this), sessionInfo, this.vfsClientRunning.bind(this) );
 
                        if (this._active)
                                this.activate();
                        else
                                this.deactivate();
 
                        //moved to vfsClientRunning
                        //this._html.trigger("paneLoadComplete");
                }
 
                unityPane.prototype.vfsClientRunning = function()
                {
                        //console.log("VFS unity client running!");
                        this._html.trigger("paneLoadComplete");
                }
 
                unityPane.prototype.quitComplete = function()
                {
                        //probably never gets called because Quit() is during the destroy and we don't wait.
                        console.log("Unity quit complete!",arguments);
                }
 
                unityPane.prototype.fromUnity = function(request)
                {
                        //console.log("from unity",arguments);
 
                        var command = request.command;
                        var attributes = request.attributes;
 
                        switch(command)
                        {
                                case "subscribe":       for (var p in attributes)
                                                        {
                                                                p = utils.cleanPath(p);
                                                                if (p in this._subscriptions)
                                                                        this._subscriptions[p].increment(attributes[p]);
                                                                else
                                                                        this._subscriptions[p] = new unitySubscription(p,attributes[p],this);
                                                        }
 
                                                        break;
 
                                case "unsubscribe":     for (var p in attributes)
                                                        {
                                                                p = utils.cleanPath(p);
                                                                //if (p in this._subscriptions)
                                                                //      this._subscriptions[p].decrement(attributes[p]);
                                                                //else
                                                                //      this._subscriptions[p] = new unitySubscription(p,attributes[p],this);
                                                                console.log("can't unsubscribe yet!",p,attributes[p]);
                                                        }
 
                                                        break;
 
                                default:                console.error("Unknown command: "+command);
                                                        break;
                        }
                }
 
                unityPane.prototype.activate = function()
                {
                        this._active = true;
 
                        if (this._unityActivate)
                                this._unityActivate();
                }
 
                unityPane.prototype.deactivate = function()
                {
                        this._active = false;
 
                        if (this._unityDeactivate)
                                this._unityDeactivate();
                }
 
                unityPane.prototype.toUnity = function(message)
                {
                        console.error("the unityPane::toUnity method will be overridden once the instance has loaded.");
                }
 
                unityPane.prototype.destroy = function()
                {
                        for (var s in this._subscriptions)
                                this._subscriptions[s].destroy();
                        this._subscriptions = {};
 
                        if (this._instance)
                        {       this._instance.Quit( this.quitComplete.bind(this) );
                                this._instance.Module["asmLibraryArg"]["_unregisterPane"]();
                        }
 
                        pane.prototype.destroy.call(this);
 
                        this._config = {};
                        this._instance = null;
                        this._createUnityInstance = null;
                        this._unityActivate = null;
                        this._unityDeactivate = null;
 
                        this._canvas = null;    //not jquery object!
                        this.toUnity = null;
                }
 
 
        // Unity Subscription
 
                function unitySubscription(path,count,instance)
                {
                        this._path = path;
                        this._count = count * 1 || 1;
                        this._instance = instance;
 
                        objectRegistry.registerObject(path,this);
                }
 
                unitySubscription.prototype.applySubscription = function(data,metadata)
                {
                        //console.log("unitySubscription subscription",arguments);
 
                        var c = {
                                command: "subscribe",
                                attributes: {
                                        path: this._path,
                                        data: data,
                                        metadata: metadata
                                }
                        }
 
                        this._instance.toUnity(c);
                }
 
                unitySubscription.prototype.applyDiff = function(diff,user)
                {
                        //console.log("unitySubscription diff",arguments);
 
                        var c = {
                                command: "diff",
                                user: user,
                                attributes: {
                                        path: this._path,
                                        diff: diff
                                }
                        }
 
                        this._instance.toUnity(c);
                }
 
                unitySubscription.prototype.increment = function(c)
                {
                        if (c && c*1)
                        {       this._count += c * 1;
                                objectRegistry.registerObject(this._path,this);         //should already be registered, but will cause it to load again
                        }
                }
 
                unitySubscription.prototype.decrement = function(d)
                {
                        console.log("FIXME: can't decrement yet");
                }
 
                unitySubscription.prototype.destroy = function()
                {
                        objectRegistry.unregisterObject(this._path,this);
                }
 
                return unityPane;
        }
);