form.js

Go to the documentation of this file.

 
define( [
                'remoto!stdlib:js/panes/pane.js',
                'remoto!stdlib:js/include/preferences.js',
                'remoto!stdlib:js/widgets/widgetFactory.js',
                'remoto!stdlib:js/paneManager/paneManager.js',
                'remoto!stdlib:js/include/objectRegistry.js',
                'remoto!stdlib:js/include/utils.js',
                'remoto!stdlib:js/panes/panes/form.css',
        ],
        function(pane,preferences,widgetFactory,paneManager,objectRegistry,utils)
        {
                'use strict';
 
                form.prototype = new pane;
                function form(layout)
                {
                        pane.call(this, layout);
 
                        if (!layout) return;                            //for the default constructor
 
                        this._type = "form";
 
                        this._attributes = {};
                        this._formJq = null;
 
                        this._diffing = false;                          //don't report value changes while diff is being applied.
                        this._objectLoader = null;
                        this._useAttributes = false;                    //new style forms, or ones with base classes, use the attributes offset for fields... detect that.
                        this._context = {};
 
                        this._enabledFilter = layout.enabledFilter || null;     //only enable fields where this option is true or the filter is null
                        if (this._enabledFilter)                        //if there's a filter, remember to save it
                                this._saveFields["enabledFilter"] = this._enabledFilter;
 
                        this._help = null;
                        this._wrapper = null;                           //don't remove!  This is for formList panes
 
                        //console.log(layout);
                }
 
                form.prototype.createHTML = function(createHeader)
                {
                        if (this._html) return this._html;
 
                        pane.prototype.createHTML.call(this,createHeader);
 
                        this._formJq = $("<div class='formCanvas'>").appendTo(this._content);
 
                        return this._html;
                }
 
                form.prototype.applySubscription = function(data,metadata)
                {
                        //console.log("form apply subscription",arguments);
 
                        if (this._subscribed)
                        {       this.applyDiff(data,null);
                                return;
                        }
 
                        this._subscribed = true;
 
                        if (data.base || data.attributes)
                        {       this._useAttributes = true;
                                //console.log(this);
                                //console.log(arguments);
                                if (metadata.context)
                                {       this._context = metadata.context;
                                        data = utils.resolveContextValues(data,metadata.context);
                                }
 
                                if (!this._objectLoader)
                                        this._objectLoader = new objectRegistry.objectLoader(metadata.nodeMenu || metadata.base || (metadata.context ? metadata.context.base : null) || "");
                                return this._objectLoader.fetchDefinition( data.base, data, this.applyDiff.bind(this) );
                        }
                        else
                                return this.applyDiff(data);
                }
 
                form.prototype.applyDiff = function(diff,user)
                {
                        //console.log("form apply diff",arguments);
                        //console.log(diff);
 
                        var c,v;
 
                        this._diffing = true;
 
                        //diff = utils.resolveContextValues(diff,this._context);
 
                        try
                        {
                                if (diff)
                                {
                                        if (this._useAttributes && diff.attributes)             //the old style of forms doesn't have an attributes field, but all the new ones do.
                                        {
                                                if (diff.help)
                                                        this._help = diff.help;
 
                                                diff = diff.attributes;
                                        }
 
                                        //console.log(diff);
                                        var diffSorted = utils.sortObjectByMemberAttribute(diff,"index");
                                        //console.log(diffSorted);
 
                                        //for (var v in diff)
                                        for (var __i=0;__i < diffSorted.length; __i++)
                                        {
                                                v = diffSorted[__i].__key;
                                                c = diff[v];
 
                                                if (!(c instanceof Object))                     //includes arrays
                                                        c = { value:c };
 
                                                //if (v.startsWith("__"))
                                                //      continue;
 
                                                if (this._attributes[v])
                                                {
                                                        if (!paneManager._singlePane)
                                                                this._attributes[v].activeUser = user;  //for arrow messages
                                                        else
                                                                this._attributes[v].activeUser = null;
 
                                                        if (c)                                  //if it's not null or false, do a set operation
                                                        {
                                                                if ("value" in c)
                                                                        this._attributes[v].immediateValue = c.value;
 
                                                                if ("options" in  c)
                                                                        this._attributes[v].applyOptions(c.options);
 
                                                                //if ("tip" in c)
                                                                //      console.warn("Have not implemented changeable tips yet.");
 
                                                                //if ("label" in c)
                                                                //      console.warn("Have not implemented changeable labels yet.");
 
                                                                //console.log(user);
                                                                //console.trace();
                                                        }
                                                        else                                    //else do a delete operation
                                                        {
                                                                this._attributes[v].destroy();
                                                                delete this._attributes[v];
                                                                console.error("FIXME: delete widget: '"+v+"' ... need to post update.");
                                                        }
 
                                                        this._attributes[v].activeUser = null;
                                                }
                                                else                                            //if it doesn't exist, create it
                                                {
                                                        var d = utils.copyObject(c);
 
                                                        if (!d) continue;
 
                                                        d.variable = v;
                                                        if (!d.change)                          //we may want to override the form's normal functionality.
                                                                d.change = this.changeField.bind(this);
 
                                                        var w = widgetFactory( d );
 
                                                        if (w)
                                                        {       this._attributes[v] = w;
                                                                //console.log(w);
 
                                        //                      if (widget._group)
                                        //                              widget._group._rowJq.append( w.createHTML() );
                                        //                      else
                                                                        this._formJq.append( w.createHTML() );
 
                                                                w.activate();
 
                                                                if (this._enabledFilter)
                                                                {
                                                                        var e = this._enabledFilter;
                                                                        if (!w._options[e])
                                                                                w.enabled = false;
                                                                }
                                                        }
                                                        else
                                                        {
                                                                if (preferences.fetch('reportFormErrors')===true)
                                                                {
                                                                        console.dir(c);
                                                                        //throw "Bad Widget: "+c;
                                                                }
                                                        }
                                                }
                                        }
                                }
                                else
                                        console.error("diff was null!");
                        }
                        catch (err)
                        {
                                console.error("Caught exception: "+err.message);
                                console.log(diff);
                                console.log(diffSorted);
                        }
 
                        this._diffing = false;
                }
 
                form.prototype.applySettings = function(settings)
                {
                        //console.log("form applySettings -- form has no settings!");
                        //console.log(settings);
                }
 
                form.prototype.changeField = function(variable,value,widget)
                {
                        //if a form is being changed, don't emit updates
                        //for a form that doesn't have a path (like when a form is used to create a new object in a modal), don't emit.
 
                        if (!this._diffing && this._path)
                        {
                                //console.log("Change field!... need to post updates");
                                //console.log(arguments);
 
                                var u = {};
                                u[variable] = { value:value };
 
                                if (this._useAttributes)
                                        u = { attributes:u };
 
                                //objectRegistry.applyDiff( this._path, u, null, this );        //propagate changes to any other instance on this path.
                                //paneManager.applyDiff( this._path, u, null, this );
                                objectRegistry.applyDiff( this._path, u, null, this._parent );  //propagate changes to any other instance on this path.
 
                                this.postUpdate( u );
 
                                /*
                                console.log(variable);
                                if (variable === "name")
                                {
                                        console.log("emit rename tab here");
                                }
                                */
                        }
                }
 
                form.prototype.getField = function(field)
                {
                        if (field in this._attributes)
                                return this._attributes[field];
 
                        return null;
                }
 
                form.prototype.getValue = function(field)
                {
                        if (field in this._attributes)
                                return this._attributes[field].value;
 
                        return null;
                }
 
                form.prototype.getValues = function()
                {
                        var v = {};
 
                        for(var a in this._attributes)
                                if (!this._attributes[a].isDefault)
                                        v[a] = this._attributes[a].value;
                        //      else
                        //      {       console.log("was default: "+a);
                        //              console.log(this._attributes[a].value);
                        //              console.log(this._attributes[a].defaultValue);
                        //      }
 
                        return v;
                }
 
                form.prototype.validate = function()
                {
                        var valid = true;
                        var v;
 
                        for (var a in this._attributes)
                        {       v = this._attributes[a].validate();
                                valid = (v===true) && valid;
                        }
 
                        return valid;
                }
 
                form.prototype.destroy = function()
                {
                        //console.log("form destroy");
 
                        for (var a in this._attributes)
                                this._attributes[a].destroy();
 
                        pane.prototype.destroy.call(this);
 
                        this._attributes = null;
                        this._help = null;
                        this._wrapper = null;
                        this._formJq = null;
                        this._objectLoader = null;
                }
 
                return form;
        }
);