Subversion Repositories Applications.papyrus

if(!dojo._hasResource["dojo._base.connect"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.

dojo._hasResource["dojo._base.connect"] = true;

dojo.provide("dojo._base.connect");

dojo.require("dojo._base.lang");

// this file courtesy of the TurboAjax Group, licensed under a Dojo CLA

// low-level delegation machinery

dojo._listener = {

	// create a dispatcher function

	getDispatcher: function(){

		// following comments pulled out-of-line to prevent cloning them

		// in the returned function.

		// - indices (i) that are really in the array of listeners (ls) will

		//   not be in Array.prototype. This is the 'sparse array' trick

		//   that keeps us safe from libs that take liberties with built-in

		//   objects

		// - listener is invoked with current scope (this)

		return function(){

			var ap=Array.prototype, c=arguments.callee, ls=c._listeners, t=c.target;

			// return value comes from original target function

			var r=t && t.apply(this, arguments);

			// invoke listeners after target function

			for(var i in ls){

				if(!(i in ap)){

					ls[i].apply(this, arguments);

				}

			}

			// return value comes from original target function

			return r;

		}

	},

	// add a listener to an object

	add: function(/*Object*/ source, /*String*/ method, /*Function*/ listener){

		// Whenever 'method' is invoked, 'listener' will have the same scope.

		// Trying to supporting a context object for the listener led to

		// complexity.

		// Non trivial to provide 'once' functionality here

		// because listener could be the result of a dojo.hitch call,

		// in which case two references to the same hitch target would not

		// be equivalent.

		source = source || dojo.global;

		// The source method is either null, a dispatcher, or some other function

		var f = source[method];

		// Ensure a dispatcher

		if(!f||!f._listeners){

			var d = dojo._listener.getDispatcher();

			// original target function is special

			d.target = f;

			// dispatcher holds a list of listeners

			d._listeners = [];

			// redirect source to dispatcher

			f = source[method] = d;

		}

		// The contract is that a handle is returned that can

		// identify this listener for disconnect.

		//

		// The type of the handle is private. Here is it implemented as Integer.

		// DOM event code has this same contract but handle is Function

		// in non-IE browsers.

		//

		// We could have separate lists of before and after listeners.

		return f._listeners.push(listener) ; /*Handle*/

	},

	// remove a listener from an object

	remove: function(/*Object*/ source, /*String*/ method, /*Handle*/ handle){

		var f = (source||dojo.global)[method];

		// remember that handle is the index+1 (0 is not a valid handle)

		if(f && f._listeners && handle--){

			delete f._listeners[handle];

		}

	}

};

// Multiple delegation for arbitrary methods.

// This unit knows nothing about DOM,

// but we include DOM aware

// documentation and dontFix

// argument here to help the autodocs.

// Actual DOM aware code is in event.js.

dojo.connect = function(/*Object|null*/ obj,

						/*String*/ event,

						/*Object|null*/ context,

						/*String|Function*/ method,

						/*Boolean*/ dontFix){

	// summary:

	//		Create a link that calls one function when another executes.

	//

	// description:

	//		Connects method to event, so that after event fires, method

	//		does too. All connected functions are passed the same arguments as

	//		the event function was initially called with. You may connect as

	//		many methods to event as needed.

	//

	//		event must be a string. If obj is null, dojo.global is used.

	//

	//		null arguments may simply be omitted.

	//

	//		obj[event] can resolve to a function or undefined (null).

	//		If obj[event] is null, it is assigned a function.

	//

	//		The return value is a handle that is needed to

	//		remove this connection with dojo.disconnect.

	//

	// obj:

	//		The source object for the event function.

	//		Defaults to dojo.global if null.

	//		If obj is a DOM node, the connection is delegated

	//		to the DOM event manager (unless dontFix is true).

	//

	// event:

	//		String name of the event function in obj.

	//		I.e. identifies a property obj[event].

	//

	// context:

	//		The object that method will receive as "this".

	//

	//		If context is null and method is a function, then method

	//		inherits the context of event.

	//

	//		If method is a string then context must be the source

	//		object object for method (context[method]). If context is null,

	//		dojo.global is used.

	//

	// method:

	//		A function reference, or name of a function in context.

	//		The function identified by method fires after event does.

	//		method receives the same arguments as the event.

	//		See context argument comments for information on method's scope.

	//

	// dontFix:

	//		If obj is a DOM node, set dontFix to true to prevent delegation

	//		of this connection to the DOM event manager.

	//

	// example:

	//		When obj.onchange(), do ui.update():

	//	|	dojo.connect(obj, "onchange", ui, "update");

	//	|	dojo.connect(obj, "onchange", ui, ui.update); // same

	//

	// example:

	//		Using return value for disconnect:

	//	|	var link = dojo.connect(obj, "onchange", ui, "update");

	//	|	...

	//	|	dojo.disconnect(link);

	//

	// example:

	//		When onglobalevent executes, watcher.handler is invoked:

	//	|	dojo.connect(null, "onglobalevent", watcher, "handler");

	//

	// example:

	//		When ob.onCustomEvent executes, customEventHandler is invoked:

	//	|	dojo.connect(ob, "onCustomEvent", null, "customEventHandler");

	//	|	dojo.connect(ob, "onCustomEvent", "customEventHandler"); // same

	//

	// example:

	//		When ob.onCustomEvent executes, customEventHandler is invoked

	//		with the same scope (this):

	//	|	dojo.connect(ob, "onCustomEvent", null, customEventHandler);

	//	|	dojo.connect(ob, "onCustomEvent", customEventHandler); // same

	//

	// example:

	//		When globalEvent executes, globalHandler is invoked

	//		with the same scope (this):

	//	|	dojo.connect(null, "globalEvent", null, globalHandler);

	//	|	dojo.connect("globalEvent", globalHandler); // same

	// normalize arguments

	var a=arguments, args=[], i=0;

	// if a[0] is a String, obj was ommited

	args.push(dojo.isString(a[0]) ? null : a[i++], a[i++]);

	// if the arg-after-next is a String or Function, context was NOT omitted

	var a1 = a[i+1];

	args.push(dojo.isString(a1)||dojo.isFunction(a1) ? a[i++] : null, a[i++]);

	// absorb any additional arguments

	for(var l=a.length; i<l; i++){	args.push(a[i]); }

	// do the actual work

	return dojo._connect.apply(this, args); /*Handle*/

}

// used by non-browser hostenvs. always overriden by event.js

dojo._connect = function(obj, event, context, method){

	var l=dojo._listener, h=l.add(obj, event, dojo.hitch(context, method));

	return [obj, event, h, l]; // Handle

}

dojo.disconnect = function(/*Handle*/ handle){

	// summary:

	//		Remove a link created by dojo.connect.

	// description:

	//		Removes the connection between event and the method referenced by handle.

	// handle:

	//		the return value of the dojo.connect call that created the connection.

	if(handle && handle[0] !== undefined){

		dojo._disconnect.apply(this, handle);

		// let's not keep this reference

		delete handle[0];

	}

}

dojo._disconnect = function(obj, event, handle, listener){

	listener.remove(obj, event, handle);

}

// topic publish/subscribe

dojo._topics = {};

dojo.subscribe = function(/*String*/ topic, /*Object|null*/ context, /*String|Function*/ method){

	//	summary:

	//		Attach a listener to a named topic. The listener function is invoked whenever the

	//		named topic is published (see: dojo.publish).

	//		Returns a handle which is needed to unsubscribe this listener.

	//	context:

	//		Scope in which method will be invoked, or null for default scope.

	//	method:

	//		The name of a function in context, or a function reference. This is the function that

	//		is invoked when topic is published.

	//	example:

	//	|	dojo.subscribe("alerts", null, function(caption, message){ alert(caption + "\n" + message); };

	//	|	dojo.publish("alerts", [ "read this", "hello world" ]);

	// support for 2 argument invocation (omitting context) depends on hitch

	return [topic, dojo._listener.add(dojo._topics, topic, dojo.hitch(context, method))]; /*Handle*/

}

dojo.unsubscribe = function(/*Handle*/ handle){

	//	summary:

	//	 	Remove a topic listener.

	//	handle:

	//	 	The handle returned from a call to subscribe.

	//	example:

	//	|	var alerter = dojo.subscribe("alerts", null, function(caption, message){ alert(caption + "\n" + message); };

	//	|	...

	//	|	dojo.unsubscribe(alerter);

	if(handle){

		dojo._listener.remove(dojo._topics, handle[0], handle[1]);

	}

}

dojo.publish = function(/*String*/ topic, /*Array*/ args){

	//	summary:

	//	 	Invoke all listener method subscribed to topic.

	//	topic:

	//	 	The name of the topic to publish.

	//	args:

	//	 	An array of arguments. The arguments will be applied

	//	 	to each topic subscriber (as first class parameters, via apply).

	//	example:

	//	|	dojo.subscribe("alerts", null, function(caption, message){ alert(caption + "\n" + message); };

	//	|	dojo.publish("alerts", [ "read this", "hello world" ]);

	// Note that args is an array, which is more efficient vs variable length

	// argument list.  Ideally, var args would be implemented via Array

	// throughout the APIs.

	var f = dojo._topics[topic];

	if(f){

		f.apply(this, args||[]);

	}

}

dojo.connectPublisher = function(	/*String*/ topic,

									/*Object|null*/ obj,

									/*String*/ event){

	//	summary:

	//	 	Ensure that everytime obj.event() is called, a message is published

	//	 	on the topic. Returns a handle which can be passed to

	//	 	dojo.disconnect() to disable subsequent automatic publication on

	//	 	the topic.

	//	topic:

	//	 	The name of the topic to publish.

	//	obj:

	//	 	The source object for the event function. Defaults to dojo.global

	//	 	if null.

	//	event:

	//	 	The name of the event function in obj.

	//	 	I.e. identifies a property obj[event].

	//	example:

	//	|	dojo.connectPublisher("/ajax/start", dojo, "xhrGet"};

	var pf = function(){ dojo.publish(topic, arguments); }

	return (event) ? dojo.connect(obj, event, pf) : dojo.connect(obj, pf); //Handle

};

}