function Relations() {

	this.items = {};

}

Relations.prototype = {

	constructor: Relations,

	/**

	 * Add an element to the dictionnary under the given name.

	 * 

	 * @param {String} id: identifier for the item

	 * @param {Object} element: item to register

	 * 

	 * @returns {Connector}: inserted element wrapped with a Connector

	 */

	add: function(id, element) {

		return this.items[id] = new Connector(element, id, this);

	},

	remove: function(id) {

	},

	/**

	 * Gets the wanted item

	 * 

	 * @param {String} id: item name

	 * 

	 * @returns {Connector}: the wanted item, wrapped in a selector

	 */

	get: function(id) {

		return this.items[id];

	},

	/**

	 * Executes all the registered actions for a given element and a given event.

	 * 

	 * First, if the required item is frozen, nothing is executed.

	 * Then, it checks every observer to see if they are locked, otherwise, their 

	 * action is performed.

	 *  

	 * @param {String} id: id of the element activated

	 * @param {String} event: name of the event activated

	 * @param eventParameters: parameters passed by the event raised

	 * 

	 * @returns: null

	 */

	execute: function(id, event, eventParameters) {

		var item = this.get(id);

		if (!item.isFrozen()) {

			var functions = item.listenedEvents[event];

			for(var i =0; i<functions.length; ++i) {

				var observer = this.get(functions[i][0]);

				if (!observer.isLocked()) {

					functions[i][1](observer.element, eventParameters);

				}

			}

		}

	},

	/**

	 * Executes an action on each selected item

	 * 

	 * The selection is made through an selector string or directly a regular

	 * expression. Then, on each selected item, the given action is performed

	 * passed the item as this in the action.

	 * 

	 * @param {String/RegExp} selector: selection test to get items

	 * @param {Function} action: action to perform

	 * @param {Boolean} getDetails: retrieve all information captured 

	 * 	by special expressions

	 * 

	 * @returns: {Integer} nombre d'éléments trouvés par la recherche

	 */

	each: function(selector, action, getDetails) {

		if (undefined==getDetails) {

			getDetails = false;

		}

		var expr = this.buildExpression(selector, getDetails);

		var compteur = 0;

		if (false==getDetails) {

			for (var itemName in this.items) {

				if (expr.test(itemName)) {

					action.call(this.items[itemName], this.items[itemName].element);

					++compteur;

				}

			}

		}

		else {

			var details = null;

			for (var itemName in this.items) {

				details = itemName.match(expr);

				if (null!=details) {

					action.call(this.items[itemName], this.items[itemName].element, details);

					++compteur;

				}

			}

		}

		return compteur;

	},

	/**

	 * Build a selector from a string

	 * 

	 * If a string is passed, it is turned as a RegExp.

	 * If an RegExp instance is passed, it is returned directly.

	 * 

	 * @param string selector: string to turn as selector

	 * @param RegExp selector: regular expression to use

	 * 

	 * @returns {RegExp}: selector

	 */

	buildExpression: function(selector, getDetails) {

		if (RegExp==selector) {

			return selector;

		}

		var expression = selector;

		expression = expression.replace(/(\(|\))/g, "\\$1");

		if (false==getDetails) {

			expression = expression.replace(/\[\[digit\]\]/g, "[0-9]+");

			expression = expression.replace(/\[\[letter\]\]/g, "[a-zA-Z]+");

			expression = expression.replace(/\./g, "\\.");

			expression = expression.replace(/\?/g, ".");

			expression = expression.replace(/\*/g, ".+");

		}

		else {

			expression = expression.replace(/\[\[digit\]\]/g, "([0-9]+)");

			expression = expression.replace(/\[\[letter\]\]/g, "([a-zA-Z]+)");

			expression = expression.replace(/\./g, "\\.");

			expression = expression.replace(/\?/g, "(.)");

			expression = expression.replace(/\*/g, "(.+)");

		}

		return RegExp("^" + expression + "$");

	}

};

function Connector(object, id, manager) {

	this.manager = manager;

	this.element = object;

	this.id = id;

	this.listenedEvents = {};

	this.locked = false;

	this.frozen = false;

}

Connector.prototype = {

	constructor: Connector,

	object: function() { return this.element; },

	bind: function(event, id, action) {

		if (undefined==action) {

			this.bind(event, this.id, id);

		}

		else {

			if (undefined!=this.listenedEvents[event]) {

				this.listenedEvents[event].push([id, action]);

			}

			else {

				var object = this;

				this.listenedEvents[event] = [[id, action]];

				this.element.on(event, function() {

					object.manager.execute(object.id, event, arguments);

				}) ;

			}

		}

		return this;

	},

	bindTo: function(event, id, action) {

		this.manager.get(id).bind(event, this.id, action);

		return this;

	},

	unbind: function(id, event) {

		return this;

	},

	click: function(id, action) {

		return this.bind("click", id, action);

	},

	dblclick: function(id, action) {

		return this.bind("dblclick", id, action);

	},

	mouseover: function(id, action) {

		return this.bind("mouseover", id, action);

	},

	mouseout: function(id, action) {

		return this.bind("mouseout", id, action);

	},

	lock: function() {	this.locked = true;	},

	unlock: function() {	this.locked = false;	},

	isLocked: function() {	return true==this.locked; },

	freeze: function() {	this.frozen = true;	},

	unfreeze: function() {	this.frozen = false;	},

	isFrozen: function() {	return true==this.frozen; }

};