Subversion Repositories Applications.papyrus

if(!dojo._hasResource["dojox.wire.ml.Action"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
dojo._hasResource["dojox.wire.ml.Action"] = true;
dojo.provide("dojox.wire.ml.Action");
dojo.provide("dojox.wire.ml.ActionFilter");

dojo.require("dijit._Widget");
dojo.require("dijit._Container");
dojo.require("dojox.wire.Wire");
dojo.require("dojox.wire.ml.util");

dojo.declare("dojox.wire.ml.Action", [dijit._Widget, dijit._Container], {
        //      summary:
        //              A base widget to "run" a task on an event or a topic
        //      description:
        //              This widget represents a controller task to be run when an event
        //              (a function) or a topic is issued.
        //              Sub-classes must implement _run() method to implement their tasks.
        //              'trigger' specifies an event scope, an ID of a widget or an DOM
        //              element, or its property with the optional dotted notation.
        //              If this widget has child ActionFilter widgets, their filter()
        //              methods are called with the arguments to the event or the topic.
        //              If one of filter() methods returns false, run() won't be invoked.
        //              This widget also can serve as a composite task to run child
        //              Actions on an event or a topic specified to this widget.
        //      trigger:
        //              An event scope
        //      triggerEvent:
        //              An event (function) name
        //      triggerTopic:
        //              A topic name
        trigger: "",
        triggerEvent: "",
        triggerTopic: "",

        postCreate: function(){
                //      summary:
                //              Call _connect()
                //      description:
                //              See _connect().
                this._connect();
        },

        _connect: function(){
                //      summary:
                //              Connect run() method to an event or a topic
                //      description:
                //              If 'triggerEvent' and 'trigger' are specified, connect() is
                //              used to set up run() to be called on the event.
                //              If 'triggerTopic' is specified, subscribe() is used to set up
                //              run() to be called on the topic.
                if(this.triggerEvent){
                        if(this.trigger){
                                var scope = dojox.wire.ml._getValue(this.trigger);
                                if(scope){
                                        if(!scope[this.triggerEvent]){
                                                // set a dummy function for an anonymous object
                                                scope[this.triggerEvent] = function(){};
                                        }
                                        this._triggerHandle = dojo.connect(scope, this.triggerEvent, this, "run");
                                }
                        }else{
                                var event = this.triggerEvent.toLowerCase();
                                if(event == "onload"){
                                        var self = this;
                                        dojo.addOnLoad(function(){
                                                self._run.apply(self, arguments);
                                        });
                                }
                        }
                }else if(this.triggerTopic){
                        this._triggerHandle = dojo.subscribe(this.triggerTopic, this, "run");
                }
        },

        _disconnect: function(){
                //      summary:
                //              Disconnect run() method from an event or a topic
                //      description:
                //              If 'triggerEvent' and 'trigger' are specified, disconnect() is
                //              used to set up run() not to be called on the event.
                //              If 'triggerTopic' is specified, unsubscribe() is used to set up
                //              run() not to be called on the topic.
                if(this._triggerHandle){
                        if(this.triggerTopic){
                                dojo.unsubscribe(this.triggerTopic, this._triggerHandle);
                        }else{
                                dojo.disconnect(this._triggerHandle);
                        }
                }
        },

        run: function(){
                //      summary:
                //              Run a task
                //      description:
                //              This method calls filter() method of child ActionFilter
                //              widgets.
                //              If one of them returns false, this method returns.
                //              Otherwise, _run() method is called.
                var children = this.getChildren();
                for(var i in children){
                        var child = children[i];
                        if(child instanceof dojox.wire.ml.ActionFilter){
                                if(!child.filter.apply(child, arguments)){
                                        return;
                                }
                        }
                }
                this._run.apply(this, arguments);
        },

        _run: function(){
                //      summary:
                //              Call run() methods of child Action widgets
                //      description:
                //              If this widget has child Action widgets, their run() methods
                //              are called.
                var children = this.getChildren();
                for(var i in children){
                        var child = children[i];
                        if(child instanceof dojox.wire.ml.Action){
                                child.run.apply(child, arguments);
                        }
                }
        },

        uninitialize: function(){
                //      summary:
                //              Over-ride of base widget unitialize function to do some connection cleanup.
                this._disconnect();
                return true;
        }
});

dojo.declare("dojox.wire.ml.ActionFilter", dijit._Widget, {
        //      summary:
        //              A widget to define a filter for the parent Action to run
        //      description:
        //              This base class checks a required property specified with
        //              'required' attribute.
        //              If 'message' is specified, the message is set to a property
        //              specified with 'error'.
        //              Subclasses may implement their own filter() method.
        //      required:
        //              A property required
        //      requiredValue:
        //              Optional.  A specific value the property is required to have.  If this isn't provided
        //              than any non-false/non-null value of the required propery will cause this filter
        //              to pass.
        //      type:
        //              Optional.  A specific type to compare the values as (if requiredValue is set)
        //              Valid values for type are boolean, int, string.  Default is string.
        //      message:
        //              An error message to emit if the filter doesn't execute due to property mismatch.
        //      error:
        //              A property to store an error due to property mismatch.
        required: "",
        requiredValue: "",
        type: "",
        message: "",
        error: "",


        filter: function(){
                //      summary:
                //              Check if a required property is specified.  Also, if provided, check to see 
                //              if the required property contains a specific value.
                //      description:
                //              If a value is undefined for a property, specified with
                //              'required', this method returns false.
                //              If the value for a property is defined, but there isn't a requiredValue for it
                //              then any non-false value will cause the method to return true.
                //              if requiredValue is set, then filter compares that value with the value from
                //              the required property and returns true if and only if they match.
                //              The type option just allows for a way to convert the required property values
                //              into a proper form for comparison (boolean, number, etc).
                //              If 'message' is specified, it is set to a proeprty specified
                //              with 'error' or shown with alert().
                //              If 'required' starts with "arguments", a property of
                //              the method arguments are checked.
                //      returns:
                //              True if a required property is specified (and if requiredValue is specified, 
                //              that they match), otherwise false
                if(this.required === ""){
                        return true; //Boolean
                }else{
                        var value = dojox.wire.ml._getValue(this.required, arguments);
                        if(this.requiredValue === ""){
                                //Just see if there's a value, nothing to compare it to.
                                if(value){
                                        return true; //Boolean
                                }
                        }else{
                                //See if we need to type convert.
                                var reqValue = this.requiredValue;
                                if(this.type !== ""){
                                        var lType = this.type.toLowerCase();
                                        if(lType === "boolean"){
                                                if(reqValue.toLowerCase() === "false"){
                                                        reqValue = false;
                                                }else{
                                                        reqValue = true;
                                                }
                                        }else if(lType === "number"){
                                                reqValue = parseInt(reqValue, 10);
                                        }
                                }
                                if(value === reqValue){
                                        return true; //boolean
                                }
                        }
                }
                
                if(this.message){
                        if(this.error){
                                dojox.wire.ml._setValue(this.error, this.message);
                        }else{
                                alert(this.message);
                        }
                }
                return false; //Boolean
        }
});

}