| New file |
|---|
| 0,0 → 1,225 |
|---|
| 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 |
| } |
| }); |
| |
| } |