Update TAutoComplete, OnSuggest event for getting suggestions.

1 files changed, 125 insertions, 16 deletions

diff --git a/framework/Web/Javascripts/extended/base.js b/framework/Web/Javascripts/extended/base.js
index d7fabdd0..d88f82db 100644
--- a/framework/Web/Javascripts/extended/base.js
+++ b/framework/Web/Javascripts/extended/base.js
@@ -29,15 +29,22 @@ Class.extend = function(base, definition)
 }

 

 /*

-	Base, version 1.0.1

+	Base, version 1.0.2

 	Copyright 2006, Dean Edwards

 	License: http://creativecommons.org/licenses/LGPL/2.1/

 */

-

-function Base() {

+/*

+var Base = function() {

+	if (arguments.length) {

+		if (this == window) { // cast an object to this class

+			Base.prototype.extend.call(arguments[0], arguments.callee.prototype);

+		} else {

+			this.extend(arguments[0]);

+		}

+	}

 };

 

-Base.version = "1.0.1";

+Base.version = "1.0.2";

 

 Base.prototype = {

 	extend: function(source, value) {

@@ -46,13 +53,16 @@ Base.prototype = {
 			var ancestor = this[source];

 			// overriding?

 			if ((ancestor instanceof Function) && (value instanceof Function) &&

-				ancestor.valueOf() != value.valueOf() && /\binherit\b/.test(value)) {

+				ancestor.valueOf() != value.valueOf() && /\bbase\b/.test(value)) {

 				var method = value;

+			//	var _prototype = this.constructor.prototype;

+			//	var fromPrototype = !Base._prototyping && _prototype[source] == ancestor;

 				value = function() {

-					var previous = this.inherit;

-					this.inherit = ancestor;

+					var previous = this.base;

+				//	this.base = fromPrototype ? _prototype[source] : ancestor;

+					this.base = ancestor;

 					var returnValue = method.apply(this, arguments);

-					this.inherit = previous;

+					this.base = previous;

 					return returnValue;

 				};

 				// point to the underlying method

@@ -85,18 +95,14 @@ Base.prototype = {
 		return this;

 	},

 

-	inherit: function() {

+	base: function() {

 		// call this method from any other method to invoke that method's ancestor

 	}

 };

 

-Base.extend = function(_instance, _static) {	

+Base.extend = function(_instance, _static) {

 	var extend = Base.prototype.extend;

 	if (!_instance) _instance = {};

-	// create the constructor

-	if (_instance.constructor == Object) {

-		_instance.constructor = new Function;

-	}

 	// build the prototype

 	Base._prototyping = true;

 	var _prototype = new this;

@@ -112,13 +118,116 @@ Base.extend = function(_instance, _static) {
 	klass.prototype = _prototype;

 	// build the class interface

 	klass.extend = this.extend;

+	klass.implement = this.implement;

 	klass.toString = function() {

 		return String(constructor);

 	};

 	extend.call(klass, _static);

-	// support singletons

+	// single instance

 	var object = constructor ? klass : _prototype;

 	// class initialisation

 	if (object.init instanceof Function) object.init();

 	return object;

-};
\ No newline at end of file
+};

+

+Base.implement = function(_interface) {

+	if (_interface instanceof Function) _interface = _interface.prototype;

+	this.prototype.extend(_interface);

+};

+*/

+

+/*

+ * Signals and Slots for Prototype: Easy custom javascript events

+ * http://tetlaw.id.au/view/blog/signals-and-slots-for-prototype-easy-custom-javascript-events

+ * Andrew Tetlaw

+ * Version 1 (2006-05-03)

+ *

+ * http://creativecommons.org/licenses/by-sa/2.5/

+ */

+Signal = {

+	throwErrors : true,

+	MT : function(){ return true },

+	connect : function(obj1, func1, obj2, func2, options) {

+		var options = Object.extend({

+			connectOnce : false

+		}, options || {});

+		if(typeof func1 != 'string' || typeof func2 != 'string') return;

+

+		var sigObj = obj1 || window;

+		var slotObj = obj2 || window;

+		var signame = func1+'__signal_';

+		var slotsname = func1+'__slots_';

+		if(!sigObj[signame]) {

+			// having the slotFunc in a var and setting it by using an anonymous function in this way

+			// is apparently a good way to prevent memory leaks in IE if the objects are DOM nodes.

+			var slotFunc = function() {

+				var args = arguments;

+				var result = sigObj[signame].apply(sigObj,args);

+				sigObj[slotsname].each(function(slot){

+					try {

+						if(slot && slot[0]) { // testing for null, a disconnect may have nulled this slot

+							slot[0][slot[1]].apply(slot[0],args); //[0] = obj, [1] = func name

+						}

+					} catch(e) {

+						if(Signal.throwErrors) throw e;

+					}

+				});

+				return result;

+			};

+			(function() {

+				sigObj[slotsname] = $A([]);

+				sigObj[signame] = sigObj[func1] || Signal.MT;

+				sigObj[func1] = slotFunc;

+			})();

+		}

+		var con = (sigObj[slotsname].length > 0) ? 

+					(options.connectOnce ? !sigObj[slotsname].any(function(slot) { return (slot[0] == slotObj && slot[1] == func2) }) : true) : 

+					true;

+		if(con) {

+			sigObj[slotsname].push([slotObj,func2]);

+		}

+	},

+	connectOnce : function(obj1, func1, obj2, func2, options) {

+		Signal.connect(obj1, func1, obj2, func2, Object.extend(options || {}, {connectOnce : true}))

+	},

+	disconnect : function(obj1, func1, obj2, func2, options) {

+		var options = Object.extend({

+			disconnectAll : false

+		}, options || {});

+		if(typeof func1 != 'string' || typeof func2 != 'string') return;

+

+		var sigObj = obj1 || window;

+		var slotObj = obj2 || window;

+		var signame = func1+'__signal_';

+		var slotsname = func1+'__slots_';

+

+		// I null them in this way so that any currectly active signal will read a null slot,

+		// otherwise the slot will be applied even though it's been disconnected

+		if(sigObj[slotsname]) {

+			if(options.disconnectAll) {

+				sigObj[slotsname] = sigObj[slotsname].collect(function(slot) {

+					if(slot[0] == slotObj && slot[1] == func2) {

+						slot[0] = null;

+						return null;

+					} else {

+						return slot;

+					}

+				}).compact();

+			} else {

+				var idx = -1;

+				sigObj[slotsname] = sigObj[slotsname].collect(function(slot, index) {

+					if(slot[0] == slotObj && slot[1] == func2 && idx < 0) {  //disconnect first match

+						idx = index;

+						slot[0] = null;

+						return null;

+					} else {

+						return slot;

+					}

+				}).compact();

+			}

+		}

+	},

+	disconnectAll : function(obj1, func1, obj2, func2, options) {

+		Signal.disconnect(obj1, func1, obj2, func2, Object.extend(options || {}, {disconnectAll : true}))

+	}

+}