// pour ne pas charger 2 fois le code
if(typeof(rwf__files)=='undefined'){

	// url + dossier ou se trouve le formulaire
	var rwf__domaine = 'http://www.rentabiliweb.com/component/form/';
	var rwf__domaine_1 = 'http://secure.rentabiliweb.com/form/';
	var rwf__domaine_2 = 'http://composants.rentabiliweb.com/form/';


	// url des fichiers du formulaire
	//var rwf__files = 'http://www.rentabiliweb.com/data/'; // obsolete
	var rwf__files_img = 'http://data.rentabiliweb.com/i/';
	var rwf__files_css = 'http://data.rentabiliweb.com/css/';
	var rwf__files_js = 'http://data.rentabiliweb.com/js/';
	// url vers laquelle on fait la requette ajax
	//var rwf__url_data_numbers = rwf__domaine+'getNumber.php';
	var rwf__url_data_numbers = rwf__domaine+'getNumber.php';
	// variable qui contient la r?ponse ajax
	var rwf__reponses_ajax = '';
	// url vers laquelle on fait la requette ajax pour la lang
	//var rwf__url_data_lang = rwf__domaine+'getLang.php';
	var rwf__url_data_lang = rwf__domaine+'getLang.php';
	// variable qui contient la reponse ajax du fichier de lang
	var rwf__reponses_ajax_lang = '';
	// ajouter des types de paiements si besoin
	var rwf__types_paiement = new Array('audiotel', 'sms', 'cb', 'internet', 'paypal', 'ticketsurf', 'neosurf', 'mistercash', 'onnet');
	// affiche les drapeaux des pays des type de paiements suivant
	var rwf__types_paiement_flags = new Array('audiotel', 'sms', 'internet', 'paypal', 'ticketsurf', 'neosurf', 'mistercash', 'onnet');
	// url vers laquel on va envoyer les codes entrer par l'internaute
	//var rwf__url_send_codes = rwf__domaine+'micropayment.php';
	var rwf__url_send_codes = rwf__domaine_1+'micropayment.php';
	// retourne les erreurs qui peuvent s'afficher a la validation des codes par l'utilisateur
	function rwf_error_code(rwf_tableau){
		var rwf_error_code = Array;
		if(rwf__nbr_errors>1){
			rwf_error_code['fr'] = 'Il y \340 '+ rwf__nbr_errors + ' erreurs dans les codes, ils sont signal\351s par un fond rouge';
			rwf_error_code['en'] = rwf__nbr_errors + ' mistakes in the codes, they are written in red';
			rwf_error_code['de'] = 'Es gibt '+ rwf__nbr_errors + ' Fehler in den Codes,sie werden durch einen roten Grund mitgeteilt';
			rwf_error_code['es'] = 'Hay '+ rwf__nbr_errors + ' errores en los c�digo, son marcados en rojo';
			rwf_error_code['ro'] = 'Printre codurile introduse, '+ rwf__nbr_errors + ' nu sunt valide';
		}else{
			rwf_error_code['fr'] = 'Le code est invalide';
			rwf_error_code['en'] = 'The code is invalid';
			rwf_error_code['de'] = 'Der Code ist invalid';
			rwf_error_code['es'] = 'Es inv�lido el c�digo';
			rwf_error_code['ro'] = 'Codul nu este valid';
		}

		return eval(rwf_tableau)[rwf__default_language];
	}

	// retourne l'erreur en cas de code syntaxe non valide
	function rwf_code_vide(rwf_tableau){
		var rwf_code_vide = Array;
		rwf_code_vide['fr'] = 'Il faut fournir un code valide de 8 caract\350res';
		rwf_code_vide['en'] = 'You have to give 8 letters or characters for having a valid code';
		rwf_code_vide['de'] = 'Man mu� einen Code von 8 Charakteren beschaffen';
		rwf_code_vide['es'] = 'Debe dar un c�digo de 8 letras';
		rwf_code_vide['ro'] = 'Trebuie sa introduceti un cod valid de 8 caractere';

		return eval(rwf_tableau)[rwf__default_language];
	}


	/*  Prototype JavaScript framework, version 1.5.0
	*  (c) 2005-2007 Sam Stephenson
	*
	*  Prototype is freely distributable under the terms of an MIT-style license.
	*  For details, see the Prototype web site: http://prototype.conio.net/
	*
	/*--------------------------------------------------------------------------*/

	var Prototype = {
		Version: '1.5.0',
		BrowserFeatures: {
			XPath: !!document.evaluate
		},

		ScriptFragment: '(?:<script.*?>)((\n|\r|.)*?)(?:<\/script>)',
		emptyFunction: function() {},
		K: function(x) { return x }
	}

	var Class = {
		create: function() {
			return function() {
				this.initialize.apply(this, arguments);
			}
		}
	}

	var Abstract = new Object();

	Object.extend = function(destination, source) {
		for (var property in source) {
			destination[property] = source[property];
		}
		return destination;
	}

	Object.extend(Object, {
		inspect: function(object) {
			try {
				if (object === undefined) return 'undefined';
				if (object === null) return 'null';
				return object.inspect ? object.inspect() : object.toString();
			} catch (e) {
				if (e instanceof RangeError) return '...';
				throw e;
			}
		},

		keys: function(object) {
			var keys = [];
			for (var property in object)
			keys.push(property);
			return keys;
		},

		values: function(object) {
			var values = [];
			for (var property in object)
			values.push(object[property]);
			return values;
		},

		clone: function(object) {
			return Object.extend({}, object);
		}
	});

	Function.prototype.bind = function() {
		var __method = this, args = $A(arguments), object = args.shift();
		return function() {
			return __method.apply(object, args.concat($A(arguments)));
		}
	}

	Function.prototype.bindAsEventListener = function(object) {
		var __method = this, args = $A(arguments), object = args.shift();
		return function(event) {
			return __method.apply(object, [( event || window.event)].concat(args).concat($A(arguments)));
		}
	}

	Object.extend(Number.prototype, {
		toColorPart: function() {
			var digits = this.toString(16);
			if (this < 16) return '0' + digits;
			return digits;
		},

		succ: function() {
			return this + 1;
		},

		times: function(iterator) {
			$R(0, this, true).each(iterator);
			return this;
		}
	});

	var Try = {
		these: function() {
			var returnValue;

			for (var i = 0, length = arguments.length; i < length; i++) {
				var lambda = arguments[i];
				try {
					returnValue = lambda();
					break;
				} catch (e) {}
			}

			return returnValue;
		}
	}

	/*--------------------------------------------------------------------------*/

	var PeriodicalExecuter = Class.create();
	PeriodicalExecuter.prototype = {
		initialize: function(callback, frequency) {
			this.callback = callback;
			this.frequency = frequency;
			this.currentlyExecuting = false;

			this.registerCallback();
		},

		registerCallback: function() {
			this.timer = setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
		},

		stop: function() {
			if (!this.timer) return;
			clearInterval(this.timer);
			this.timer = null;
		},

		onTimerEvent: function() {
			if (!this.currentlyExecuting) {
				try {
					this.currentlyExecuting = true;
					this.callback(this);
				} finally {
					this.currentlyExecuting = false;
				}
			}
		}
	}
	String.interpret = function(value){
		return value == null ? '' : String(value);
	}

	Object.extend(String.prototype, {
		gsub: function(pattern, replacement) {
			var result = '', source = this, match;
			replacement = arguments.callee.prepareReplacement(replacement);

			while (source.length > 0) {
				if (match = source.match(pattern)) {
					result += source.slice(0, match.index);
					result += String.interpret(replacement(match));
					source  = source.slice(match.index + match[0].length);
				} else {
					result += source, source = '';
				}
			}
			return result;
		},

		sub: function(pattern, replacement, count) {
			replacement = this.gsub.prepareReplacement(replacement);
			count = count === undefined ? 1 : count;

			return this.gsub(pattern, function(match) {
				if (--count < 0) return match[0];
				return replacement(match);
			});
		},

		scan: function(pattern, iterator) {
			this.gsub(pattern, iterator);
			return this;
		},

		truncate: function(length, truncation) {
			length = length || 30;
			truncation = truncation === undefined ? '...' : truncation;
			return this.length > length ?
			this.slice(0, length - truncation.length) + truncation : this;
		},

		strip: function() {
			return this.replace(/^\s+/, '').replace(/\s+$/, '');
		},

		stripTags: function() {
			return this.replace(/<\/?[^>]+>/gi, '');
		},

		stripScripts: function() {
			return this.replace(new RegExp(Prototype.ScriptFragment, 'img'), '');
		},

		extractScripts: function() {
			var matchAll = new RegExp(Prototype.ScriptFragment, 'img');
			var matchOne = new RegExp(Prototype.ScriptFragment, 'im');
			return (this.match(matchAll) || []).map(function(scriptTag) {
				return (scriptTag.match(matchOne) || ['', ''])[1];
			});
		},

		evalScripts: function() {
			return this.extractScripts().map(function(script) { return eval(script) });
		},

		escapeHTML: function() {
			var div = document.createElement('div');
			var text = document.createTextNode(this);
			div.appendChild(text);
			return div.innerHTML;
		},

		unescapeHTML: function() {
			var div = document.createElement('div');
			div.innerHTML = this.stripTags();
			return div.childNodes[0] ? (div.childNodes.length > 1 ?
			$A(div.childNodes).inject('',function(memo,node){ return memo+node.nodeValue }) :
			div.childNodes[0].nodeValue) : '';
		},

		toQueryParams: function(separator) {
			var match = this.strip().match(/([^?#]*)(#.*)?$/);
			if (!match) return {};

			return match[1].split(separator || '&').inject({}, function(hash, pair) {
				if ((pair = pair.split('='))[0]) {
					var name = decodeURIComponent(pair[0]);
					var value = pair[1] ? decodeURIComponent(pair[1]) : undefined;

					if (hash[name] !== undefined) {
						if (hash[name].constructor != Array)
						hash[name] = [hash[name]];
						if (value) hash[name].push(value);
					}
					else hash[name] = value;
				}
				return hash;
			});
		},

		toArray: function() {
			return this.split('');
		},

		succ: function() {
			return this.slice(0, this.length - 1) +
			String.fromCharCode(this.charCodeAt(this.length - 1) + 1);
		},

		camelize: function() {
			var parts = this.split('-'), len = parts.length;
			if (len == 1) return parts[0];

			var camelized = this.charAt(0) == '-'
			? parts[0].charAt(0).toUpperCase() + parts[0].substring(1)
			: parts[0];

			for (var i = 1; i < len; i++)
			camelized += parts[i].charAt(0).toUpperCase() + parts[i].substring(1);

			return camelized;
		},

		capitalize: function(){
			return this.charAt(0).toUpperCase() + this.substring(1).toLowerCase();
		},

		underscore: function() {
			return this.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'#{1}_#{2}').gsub(/([a-z\d])([A-Z])/,'#{1}_#{2}').gsub(/-/,'_').toLowerCase();
		},

		dasherize: function() {
			return this.gsub(/_/,'-');
		},

		inspect: function(useDoubleQuotes) {
			var escapedString = this.replace(/\\/g, '\\\\');
			if (useDoubleQuotes)
			return '"' + escapedString.replace(/"/g, '\\"') + '"';
    else
      return "'" + escapedString.replace(/'/g, '\\\'') + "'";
		}
	});

	String.prototype.gsub.prepareReplacement = function(replacement) {
		if (typeof replacement == 'function') return replacement;
		var template = new Template(replacement);
		return function(match) { return template.evaluate(match) };
	}

	String.prototype.parseQuery = String.prototype.toQueryParams;

	var Template = Class.create();
	Template.Pattern = /(^|.|\r|\n)(#\{(.*?)\})/;
	Template.prototype = {
		initialize: function(template, pattern) {
			this.template = template.toString();
			this.pattern  = pattern || Template.Pattern;
		},

		evaluate: function(object) {
			return this.template.gsub(this.pattern, function(match) {
				var before = match[1];
				if (before == '\\') return match[2];
				return before + String.interpret(object[match[3]]);
			});
		}
	}

	var $break    = new Object();
	var $continue = new Object();

	var Enumerable = {
		each: function(iterator) {
			var index = 0;
			try {
				this._each(function(value) {
					try {
						iterator(value, index++);
					} catch (e) {
						if (e != $continue) throw e;
					}
				});
			} catch (e) {
				if (e != $break) throw e;
			}
			return this;
		},

		eachSlice: function(number, iterator) {
			var index = -number, slices = [], array = this.toArray();
			while ((index += number) < array.length)
			slices.push(array.slice(index, index+number));
			return slices.map(iterator);
		},

		all: function(iterator) {
			var result = true;
			this.each(function(value, index) {
				result = result && !!(iterator || Prototype.K)(value, index);
				if (!result) throw $break;
			});
			return result;
		},

		any: function(iterator) {
			var result = false;
			this.each(function(value, index) {
				if (result = !!(iterator || Prototype.K)(value, index))
				throw $break;
			});
			return result;
		},

		collect: function(iterator) {
			var results = [];
			this.each(function(value, index) {
				results.push((iterator || Prototype.K)(value, index));
			});
			return results;
		},

		detect: function(iterator) {
			var result;
			this.each(function(value, index) {
				if (iterator(value, index)) {
					result = value;
					throw $break;
				}
			});
			return result;
		},

		findAll: function(iterator) {
			var results = [];
			this.each(function(value, index) {
				if (iterator(value, index))
				results.push(value);
			});
			return results;
		},

		grep: function(pattern, iterator) {
			var results = [];
			this.each(function(value, index) {
				var stringValue = value.toString();
				if (stringValue.match(pattern))
				results.push((iterator || Prototype.K)(value, index));
			})
			return results;
		},

		include: function(object) {
			var found = false;
			this.each(function(value) {
				if (value == object) {
					found = true;
					throw $break;
				}
			});
			return found;
		},

		inGroupsOf: function(number, fillWith) {
			fillWith = fillWith === undefined ? null : fillWith;
			return this.eachSlice(number, function(slice) {
				while(slice.length < number) slice.push(fillWith);
				return slice;
			});
		},

		inject: function(memo, iterator) {
			this.each(function(value, index) {
				memo = iterator(memo, value, index);
			});
			return memo;
		},

		invoke: function(method) {
			var args = $A(arguments).slice(1);
			return this.map(function(value) {
				return value[method].apply(value, args);
			});
		},

		max: function(iterator) {
			var result;
			this.each(function(value, index) {
				value = (iterator || Prototype.K)(value, index);
				if (result == undefined || value >= result)
				result = value;
			});
			return result;
		},

		min: function(iterator) {
			var result;
			this.each(function(value, index) {
				value = (iterator || Prototype.K)(value, index);
				if (result == undefined || value < result)
				result = value;
			});
			return result;
		},

		partition: function(iterator) {
			var trues = [], falses = [];
			this.each(function(value, index) {
			((iterator || Prototype.K)(value, index) ?
			trues : falses).push(value);
			});
			return [trues, falses];
		},

		pluck: function(property) {
			var results = [];
			this.each(function(value, index) {
				results.push(value[property]);
			});
			return results;
		},

		reject: function(iterator) {
			var results = [];
			this.each(function(value, index) {
				if (!iterator(value, index))
				results.push(value);
			});
			return results;
		},

		sortBy: function(iterator) {
			return this.map(function(value, index) {
				return {value: value, criteria: iterator(value, index)};
			}).sort(function(left, right) {
				var a = left.criteria, b = right.criteria;
				return a < b ? -1 : a > b ? 1 : 0;
			}).pluck('value');
		},

		toArray: function() {
			return this.map();
		},

		zip: function() {
			var iterator = Prototype.K, args = $A(arguments);
			if (typeof args.last() == 'function')
			iterator = args.pop();

			var collections = [this].concat(args).map($A);
			return this.map(function(value, index) {
				return iterator(collections.pluck(index));
			});
		},

		size: function() {
			return this.toArray().length;
		},

		inspect: function() {
			return '#<Enumerable:' + this.toArray().inspect() + '>';
		}
	}

	Object.extend(Enumerable, {
		map:     Enumerable.collect,
		find:    Enumerable.detect,
		select:  Enumerable.findAll,
		member:  Enumerable.include,
		entries: Enumerable.toArray
	});
	var $A = Array.from = function(iterable) {
		if (!iterable) return [];
		if (iterable.toArray) {
			return iterable.toArray();
		} else {
			var results = [];
			for (var i = 0, length = iterable.length; i < length; i++)
			results.push(iterable[i]);
			return results;
		}
	}

	Object.extend(Array.prototype, Enumerable);

	if (!Array.prototype._reverse)
	Array.prototype._reverse = Array.prototype.reverse;

	Object.extend(Array.prototype, {
		_each: function(iterator) {
			for (var i = 0, length = this.length; i < length; i++)
			iterator(this[i]);
		},

		clear: function() {
			this.length = 0;
			return this;
		},

		first: function() {
			return this[0];
		},

		last: function() {
			return this[this.length - 1];
		},

		compact: function() {
			return this.select(function(value) {
				return value != null;
			});
		},

		flatten: function() {
			return this.inject([], function(array, value) {
				return array.concat(value && value.constructor == Array ?
				value.flatten() : [value]);
			});
		},

		without: function() {
			var values = $A(arguments);
			return this.select(function(value) {
				return !values.include(value);
			});
		},

		indexOf: function(object) {
			for (var i = 0, length = this.length; i < length; i++)
			if (this[i] == object) return i;
			return -1;
		},

		reverse: function(inline) {
			return (inline !== false ? this : this.toArray())._reverse();
		},

		reduce: function() {
			return this.length > 1 ? this : this[0];
		},

		uniq: function() {
			return this.inject([], function(array, value) {
				return array.include(value) ? array : array.concat([value]);
			});
		},

		clone: function() {
			return [].concat(this);
		},

		size: function() {
			return this.length;
		},

		inspect: function() {
			return '[' + this.map(Object.inspect).join(', ') + ']';
		}
	});

	Array.prototype.toArray = Array.prototype.clone;

	function $w(string){
		string = string.strip();
		return string ? string.split(/\s+/) : [];
	}

	if(window.opera){
		Array.prototype.concat = function(){
			var array = [];
			for(var i = 0, length = this.length; i < length; i++) array.push(this[i]);
			for(var i = 0, length = arguments.length; i < length; i++) {
				if(arguments[i].constructor == Array) {
					for(var j = 0, arrayLength = arguments[i].length; j < arrayLength; j++)
					array.push(arguments[i][j]);
				} else {
					array.push(arguments[i]);
				}
			}
			return array;
		}
	}
	var Hash = function(obj) {
		Object.extend(this, obj || {});
	};

	Object.extend(Hash, {
		toQueryString: function(obj) {
			var parts = [];

			this.prototype._each.call(obj, function(pair) {
				if (!pair.key) return;

				if (pair.value && pair.value.constructor == Array) {
					var values = pair.value.compact();
					if (values.length < 2) pair.value = values.reduce();
					else {
						key = encodeURIComponent(pair.key);
						values.each(function(value) {
							value = value != undefined ? encodeURIComponent(value) : '';
							parts.push(key + '=' + encodeURIComponent(value));
						});
						return;
					}
				}
				if (pair.value == undefined) pair[1] = '';
				parts.push(pair.map(encodeURIComponent).join('='));
			});

			return parts.join('&');
		}
	});

	Object.extend(Hash.prototype, Enumerable);
	Object.extend(Hash.prototype, {
		_each: function(iterator) {
			for (var key in this) {
				var value = this[key];
				if (value && value == Hash.prototype[key]) continue;

				var pair = [key, value];
				pair.key = key;
				pair.value = value;
				iterator(pair);
			}
		},

		keys: function() {
			return this.pluck('key');
		},

		values: function() {
			return this.pluck('value');
		},

		merge: function(hash) {
			return $H(hash).inject(this, function(mergedHash, pair) {
				mergedHash[pair.key] = pair.value;
				return mergedHash;
			});
		},

		remove: function() {
			var result;
			for(var i = 0, length = arguments.length; i < length; i++) {
				var value = this[arguments[i]];
				if (value !== undefined){
					if (result === undefined) result = value;
					else {
						if (result.constructor != Array) result = [result];
						result.push(value)
					}
				}
				delete this[arguments[i]];
			}
			return result;
		},

		toQueryString: function() {
			return Hash.toQueryString(this);
		},

		inspect: function() {
			return '#<Hash:{' + this.map(function(pair) {
				return pair.map(Object.inspect).join(': ');
			}).join(', ') + '}>';
		}
	});

	function $H(object) {
		if (object && object.constructor == Hash) return object;
		return new Hash(object);
	};
	ObjectRange = Class.create();
	Object.extend(ObjectRange.prototype, Enumerable);
	Object.extend(ObjectRange.prototype, {
		initialize: function(start, end, exclusive) {
			this.start = start;
			this.end = end;
			this.exclusive = exclusive;
		},

		_each: function(iterator) {
			var value = this.start;
			while (this.include(value)) {
				iterator(value);
				value = value.succ();
			}
		},

		include: function(value) {
			if (value < this.start)
			return false;
			if (this.exclusive)
			return value < this.end;
			return value <= this.end;
		}
	});

	var $R = function(start, end, exclusive) {
		return new ObjectRange(start, end, exclusive);
	}

	var Ajax = {
		getTransport: function() {
			return Try.these(
			function() {return new XMLHttpRequest()},
			function() {return new ActiveXObject('Msxml2.XMLHTTP')},
			function() {return new ActiveXObject('Microsoft.XMLHTTP')}
			) || false;
		},

		activeRequestCount: 0
	}

	Ajax.Responders = {
		responders: [],

		_each: function(iterator) {
			this.responders._each(iterator);
		},

		register: function(responder) {
			if (!this.include(responder))
			this.responders.push(responder);
		},

		unregister: function(responder) {
			this.responders = this.responders.without(responder);
		},

		dispatch: function(callback, request, transport, json) {
			this.each(function(responder) {
				if (typeof responder[callback] == 'function') {
					try {
						responder[callback].apply(responder, [request, transport, json]);
					} catch (e) {}
				}
			});
		}
	};

	Object.extend(Ajax.Responders, Enumerable);

	Ajax.Responders.register({
		onCreate: function() {
			Ajax.activeRequestCount++;
		},
		onComplete: function() {
			Ajax.activeRequestCount--;
		}
	});

	Ajax.Base = function() {};
	Ajax.Base.prototype = {
		setOptions: function(options) {
			this.options = {
				method:       'post',
				asynchronous: true,
				contentType:  'application/x-www-form-urlencoded',
				encoding:     'UTF-8',
				parameters:   ''
			}
			Object.extend(this.options, options || {});

			this.options.method = this.options.method.toLowerCase();
			if (typeof this.options.parameters == 'string')
			this.options.parameters = this.options.parameters.toQueryParams();
		}
	}

	Ajax.Request = Class.create();
	Ajax.Request.Events =
	['Uninitialized', 'Loading', 'Loaded', 'Interactive', 'Complete'];

	Ajax.Request.prototype = Object.extend(new Ajax.Base(), {
		_complete: false,

		initialize: function(url, options) {
			this.transport = Ajax.getTransport();
			this.setOptions(options);
			this.request(url);
		},

		request: function(url) {
			this.url = url;
			this.method = this.options.method;
			var params = this.options.parameters;

			if (!['get', 'post'].include(this.method)) {
				// simulate other verbs over post
				params['_method'] = this.method;
				this.method = 'post';
			}

			params = Hash.toQueryString(params);
			if (params && /Konqueror|Safari|KHTML/.test(navigator.userAgent)) params += '&_='

			// when GET, append parameters to URL
			if (this.method == 'get' && params)
			this.url += (this.url.indexOf('?') > -1 ? '&' : '?') + params;

			try {
				Ajax.Responders.dispatch('onCreate', this, this.transport);

				this.transport.open(this.method.toUpperCase(), this.url,
				this.options.asynchronous);

				if (this.options.asynchronous)
				setTimeout(function() { this.respondToReadyState(1) }.bind(this), 10);

				this.transport.onreadystatechange = this.onStateChange.bind(this);
				this.setRequestHeaders();

				var body = this.method == 'post' ? (this.options.postBody || params) : null;

				this.transport.send(body);

				/* Force Firefox to handle ready state 4 for synchronous requests */
				if (!this.options.asynchronous && this.transport.overrideMimeType)
				this.onStateChange();

			}
			catch (e) {
				this.dispatchException(e);
			}
		},

		onStateChange: function() {
			var readyState = this.transport.readyState;
			if (readyState > 1 && !((readyState == 4) && this._complete))
			this.respondToReadyState(this.transport.readyState);
		},

		setRequestHeaders: function() {
			var headers = {
			'X-Requested-With': 'XMLHttpRequest',
			'X-Prototype-Version': Prototype.Version,
			'Accept': 'text/javascript, text/html, application/xml, text/xml, */*'
			};

			if (this.method == 'post') {
				headers['Content-type'] = this.options.contentType +
				(this.options.encoding ? '; charset=' + this.options.encoding : '');

				/* Force "Connection: close" for older Mozilla browsers to work
				* around a bug where XMLHttpRequest sends an incorrect
				* Content-length header. See Mozilla Bugzilla #246651.
				*/
				if (this.transport.overrideMimeType &&
				(navigator.userAgent.match(/Gecko\/(\d{4})/) || [0,2005])[1] < 2005)
				headers['Connection'] = 'close';
			}

			// user-defined headers
			if (typeof this.options.requestHeaders == 'object') {
				var extras = this.options.requestHeaders;

				if (typeof extras.push == 'function')
				for (var i = 0, length = extras.length; i < length; i += 2)
				headers[extras[i]] = extras[i+1];
				else
				$H(extras).each(function(pair) { headers[pair.key] = pair.value });
			}

			for (var name in headers)
			this.transport.setRequestHeader(name, headers[name]);
		},

		success: function() {
			return !this.transport.status
			|| (this.transport.status >= 200 && this.transport.status < 300);
		},

		respondToReadyState: function(readyState) {
			var state = Ajax.Request.Events[readyState];
			var transport = this.transport, json = this.evalJSON();

			if (state == 'Complete') {
				try {
					this._complete = true;
					(this.options['on' + this.transport.status]
					|| this.options['on' + (this.success() ? 'Success' : 'Failure')]
					|| Prototype.emptyFunction)(transport, json);
				} catch (e) {
					this.dispatchException(e);
				}

				if ((this.getHeader('Content-type') || 'text/javascript').strip().
				match(/^(text|application)\/(x-)?(java|ecma)script(;.*)?$/i))
				this.evalResponse();
			}

			try {
			(this.options['on' + state] || Prototype.emptyFunction)(transport, json);
			Ajax.Responders.dispatch('on' + state, this, transport, json);
			} catch (e) {
				this.dispatchException(e);
			}

			if (state == 'Complete') {
				// avoid memory leak in MSIE: clean up
				this.transport.onreadystatechange = Prototype.emptyFunction;
			}
		},

		getHeader: function(name) {
			try {
				return this.transport.getResponseHeader(name);
			} catch (e) { return null }
		},

		evalJSON: function() {
			try {
				var json = this.getHeader('X-JSON');
				return json ? eval('(' + json + ')') : null;
			} catch (e) { return null }
		},

		evalResponse: function() {
			try {
				return eval(this.transport.responseText);
			} catch (e) {
				this.dispatchException(e);
			}
		},

		dispatchException: function(exception) {
		(this.options.onException || Prototype.emptyFunction)(this, exception);
		Ajax.Responders.dispatch('onException', this, exception);
		}
	});

	Ajax.Updater = Class.create();

	Object.extend(Object.extend(Ajax.Updater.prototype, Ajax.Request.prototype), {
		initialize: function(container, url, options) {
			this.container = {
				success: (container.success || container),
				failure: (container.failure || (container.success ? null : container))
			}

			this.transport = Ajax.getTransport();
			this.setOptions(options);

			var onComplete = this.options.onComplete || Prototype.emptyFunction;
			this.options.onComplete = (function(transport, param) {
				this.updateContent();
				onComplete(transport, param);
			}).bind(this);

			this.request(url);
		},

		updateContent: function() {
			var receiver = this.container[this.success() ? 'success' : 'failure'];
			var response = this.transport.responseText;

			if (!this.options.evalScripts) response = response.stripScripts();

			if (receiver = $(receiver)) {
				if (this.options.insertion)
				new this.options.insertion(receiver, response);
				else
				receiver.update(response);
			}

			if (this.success()) {
				if (this.onComplete)
				setTimeout(this.onComplete.bind(this), 10);
			}
		}
	});

	Ajax.PeriodicalUpdater = Class.create();
	Ajax.PeriodicalUpdater.prototype = Object.extend(new Ajax.Base(), {
		initialize: function(container, url, options) {
			this.setOptions(options);
			this.onComplete = this.options.onComplete;

			this.frequency = (this.options.frequency || 2);
			this.decay = (this.options.decay || 1);

			this.updater = {};
			this.container = container;
			this.url = url;

			this.start();
		},

		start: function() {
			this.options.onComplete = this.updateComplete.bind(this);
			this.onTimerEvent();
		},

		stop: function() {
			this.updater.options.onComplete = undefined;
			clearTimeout(this.timer);
			(this.onComplete || Prototype.emptyFunction).apply(this, arguments);
		},

		updateComplete: function(request) {
			if (this.options.decay) {
				this.decay = (request.responseText == this.lastText ?
				this.decay * this.options.decay : 1);

				this.lastText = request.responseText;
			}
			this.timer = setTimeout(this.onTimerEvent.bind(this),
			this.decay * this.frequency * 1000);
		},

		onTimerEvent: function() {
			this.updater = new Ajax.Updater(this.container, this.url, this.options);
		}
	});
	function $(element) {
		if (arguments.length > 1) {
			for (var i = 0, elements = [], length = arguments.length; i < length; i++)
			elements.push($(arguments[i]));
			return elements;
		}
		if (typeof element == 'string')
		element = document.getElementById(element);
		return Element.extend(element);
	}

	if (Prototype.BrowserFeatures.XPath) {
		document._getElementsByXPath = function(expression, parentElement) {
			var results = [];
			var query = document.evaluate(expression, $(parentElement) || document,
			null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
			for (var i = 0, length = query.snapshotLength; i < length; i++)
			results.push(query.snapshotItem(i));
			return results;
		};
	}

	document.getElementsByClassName = function(className, parentElement) {
		if (Prototype.BrowserFeatures.XPath) {
			var q = ".//*[contains(concat(' ', @class, ' '), ' " + className + " ')]";
			return document._getElementsByXPath(q, parentElement);
		} else {
			var children = ($(parentElement) || document.body).getElementsByTagName('*');
			var elements = [], child;
			for (var i = 0, length = children.length; i < length; i++) {
				child = children[i];
				if (Element.hasClassName(child, className))
				elements.push(Element.extend(child));
			}
			return elements;
		}
	};

	/*--------------------------------------------------------------------------*/

	if (!window.Element)
	var Element = new Object();

	Element.extend = function(element) {
		if (!element || _nativeExtensions || element.nodeType == 3) return element;

		if (!element._extended && element.tagName && element != window) {
			var methods = Object.clone(Element.Methods), cache = Element.extend.cache;

			if (element.tagName == 'FORM')
			Object.extend(methods, Form.Methods);
			if (['INPUT', 'TEXTAREA', 'SELECT'].include(element.tagName))
			Object.extend(methods, Form.Element.Methods);

			Object.extend(methods, Element.Methods.Simulated);

			for (var property in methods) {
				var value = methods[property];
				if (typeof value == 'function' && !(property in element))
				element[property] = cache.findOrStore(value);
			}
		}

		element._extended = true;
		return element;
	};

	Element.extend.cache = {
		findOrStore: function(value) {
			return this[value] = this[value] || function() {
				return value.apply(null, [this].concat($A(arguments)));
			}
		}
	};

	Element.Methods = {
		visible: function(element) {
			return $(element).style.display != 'none';
		},

		toggle: function(element) {
			element = $(element);
			Element[Element.visible(element) ? 'hide' : 'show'](element);
			return element;
		},

		hide: function(element) {
			$(element).style.display = 'none';
			return element;
		},

		show: function(element) {
			$(element).style.display = '';
			return element;
		},

		remove: function(element) {
			element = $(element);
			element.parentNode.removeChild(element);
			return element;
		},

		update: function(element, html) {
			html = typeof html == 'undefined' ? '' : html.toString();
			$(element).innerHTML = html.stripScripts();
			setTimeout(function() {html.evalScripts()}, 10);
			return element;
		},

		replace: function(element, html) {
			element = $(element);
			html = typeof html == 'undefined' ? '' : html.toString();
			if (element.outerHTML) {
				element.outerHTML = html.stripScripts();
			} else {
				var range = element.ownerDocument.createRange();
				range.selectNodeContents(element);
				element.parentNode.replaceChild(
				range.createContextualFragment(html.stripScripts()), element);
			}
			setTimeout(function() {html.evalScripts()}, 10);
			return element;
		},

		inspect: function(element) {
			element = $(element);
			var result = '<' + element.tagName.toLowerCase();
			$H({'id': 'id', 'className': 'class'}).each(function(pair) {
				var property = pair.first(), attribute = pair.last();
				var value = (element[property] || '').toString();
				if (value) result += ' ' + attribute + '=' + value.inspect(true);
			});
			return result + '>';
		},

		recursivelyCollect: function(element, property) {
			element = $(element);
			var elements = [];
			while (element = element[property])
			if (element.nodeType == 1)
			elements.push(Element.extend(element));
			return elements;
		},

		ancestors: function(element) {
			return $(element).recursivelyCollect('parentNode');
		},

		descendants: function(element) {
			return $A($(element).getElementsByTagName('*'));
		},

		immediateDescendants: function(element) {
			if (!(element = $(element).firstChild)) return [];
			while (element && element.nodeType != 1) element = element.nextSibling;
			if (element) return [element].concat($(element).nextSiblings());
			return [];
		},

		previousSiblings: function(element) {
			return $(element).recursivelyCollect('previousSibling');
		},

		nextSiblings: function(element) {
			return $(element).recursivelyCollect('nextSibling');
		},

		siblings: function(element) {
			element = $(element);
			return element.previousSiblings().reverse().concat(element.nextSiblings());
		},

		match: function(element, selector) {
			if (typeof selector == 'string')
			selector = new Selector(selector);
			return selector.match($(element));
		},

		up: function(element, expression, index) {
			return Selector.findElement($(element).ancestors(), expression, index);
		},

		down: function(element, expression, index) {
			return Selector.findElement($(element).descendants(), expression, index);
		},

		previous: function(element, expression, index) {
			return Selector.findElement($(element).previousSiblings(), expression, index);
		},

		next: function(element, expression, index) {
			return Selector.findElement($(element).nextSiblings(), expression, index);
		},

		getElementsBySelector: function() {
			var args = $A(arguments), element = $(args.shift());
			return Selector.findChildElements(element, args);
		},

		getElementsByClassName: function(element, className) {
			return document.getElementsByClassName(className, element);
		},

		readAttribute: function(element, name) {
			element = $(element);
			if (document.all && !window.opera) {
				var t = Element._attributeTranslations;
				if (t.values[name]) return t.values[name](element, name);
				if (t.names[name])  name = t.names[name];
				var attribute = element.attributes[name];
				if(attribute) return attribute.nodeValue;
			}
			return element.getAttribute(name);
		},

		getHeight: function(element) {
			return $(element).getDimensions().height;
		},

		getWidth: function(element) {
			return $(element).getDimensions().width;
		},

		classNames: function(element) {
			return new Element.ClassNames(element);
		},

		hasClassName: function(element, className) {
			if (!(element = $(element))) return;
			var elementClassName = element.className;
			if (elementClassName.length == 0) return false;
			if (elementClassName == className ||
			elementClassName.match(new RegExp("(^|\\s)" + className + "(\\s|$)")))
			return true;
			return false;
		},

		addClassName: function(element, className) {
			if (!(element = $(element))) return;
			Element.classNames(element).add(className);
			return element;
		},

		removeClassName: function(element, className) {
			if (!(element = $(element))) return;
			Element.classNames(element).remove(className);
			return element;
		},

		toggleClassName: function(element, className) {
			if (!(element = $(element))) return;
			Element.classNames(element)[element.hasClassName(className) ? 'remove' : 'add'](className);
			return element;
		},

		observe: function() {
			Event.observe.apply(Event, arguments);
			return $A(arguments).first();
		},

		stopObserving: function() {
			Event.stopObserving.apply(Event, arguments);
			return $A(arguments).first();
		},

		// removes whitespace-only text node children
		cleanWhitespace: function(element) {
			element = $(element);
			var node = element.firstChild;
			while (node) {
				var nextNode = node.nextSibling;
				if (node.nodeType == 3 && !/\S/.test(node.nodeValue))
				element.removeChild(node);
				node = nextNode;
			}
			return element;
		},

		empty: function(element) {
			return $(element).innerHTML.match(/^\s*$/);
		},

		descendantOf: function(element, ancestor) {
			element = $(element), ancestor = $(ancestor);
			while (element = element.parentNode)
			if (element == ancestor) return true;
			return false;
		},

		scrollTo: function(element) {
			element = $(element);
			var pos = Position.cumulativeOffset(element);
			window.scrollTo(pos[0], pos[1]);
			return element;
		},

		getStyle: function(element, style) {
			element = $(element);
			if (['float','cssFloat'].include(style))
			style = (typeof element.style.styleFloat != 'undefined' ? 'styleFloat' : 'cssFloat');
			style = style.camelize();
			var value = element.style[style];
			if (!value) {
				if (document.defaultView && document.defaultView.getComputedStyle) {
					var css = document.defaultView.getComputedStyle(element, null);
					value = css ? css[style] : null;
				} else if (element.currentStyle) {
					value = element.currentStyle[style];
				}
			}

			if((value == 'auto') && ['width','height'].include(style) && (element.getStyle('display') != 'none'))
			value = element['offset'+style.capitalize()] + 'px';

			if (window.opera && ['left', 'top', 'right', 'bottom'].include(style))
			if (Element.getStyle(element, 'position') == 'static') value = 'auto';
			if(style == 'opacity') {
				if(value) return parseFloat(value);
				if(value = (element.getStyle('filter') || '').match(/alpha\(opacity=(.*)\)/))
				if(value[1]) return parseFloat(value[1]) / 100;
				return 1.0;
			}
			return value == 'auto' ? null : value;
		},

		setStyle: function(element, style) {
			element = $(element);
			for (var name in style) {
				var value = style[name];
				if(name == 'opacity') {
					if (value == 1) {
						value = (/Gecko/.test(navigator.userAgent) &&
						!/Konqueror|Safari|KHTML/.test(navigator.userAgent)) ? 0.999999 : 1.0;
						if(/MSIE/.test(navigator.userAgent) && !window.opera)
						element.style.filter = element.getStyle('filter').replace(/alpha\([^\)]*\)/gi,'');
					} else if(value == '') {
						if(/MSIE/.test(navigator.userAgent) && !window.opera)
						element.style.filter = element.getStyle('filter').replace(/alpha\([^\)]*\)/gi,'');
					} else {
						if(value < 0.00001) value = 0;
						if(/MSIE/.test(navigator.userAgent) && !window.opera)
						element.style.filter = element.getStyle('filter').replace(/alpha\([^\)]*\)/gi,'') +
						'alpha(opacity='+value*100+')';
					}
				} else if(['float','cssFloat'].include(name)) name = (typeof element.style.styleFloat != 'undefined') ? 'styleFloat' : 'cssFloat';
				element.style[name.camelize()] = value;
			}
			return element;
		},

		getDimensions: function(element) {
			element = $(element);
			var display = $(element).getStyle('display');
			if (display != 'none' && display != null) // Safari bug
			return {width: element.offsetWidth, height: element.offsetHeight};

			// All *Width and *Height properties give 0 on elements with display none,
			// so enable the element temporarily
			var els = element.style;
			var originalVisibility = els.visibility;
			var originalPosition = els.position;
			var originalDisplay = els.display;
			els.visibility = 'hidden';
			els.position = 'absolute';
			els.display = 'block';
			var originalWidth = element.clientWidth;
			var originalHeight = element.clientHeight;
			els.display = originalDisplay;
			els.position = originalPosition;
			els.visibility = originalVisibility;
			return {width: originalWidth, height: originalHeight};
		},

		makePositioned: function(element) {
			element = $(element);
			var pos = Element.getStyle(element, 'position');
			if (pos == 'static' || !pos) {
				element._madePositioned = true;
				element.style.position = 'relative';
				// Opera returns the offset relative to the positioning context, when an
				// element is position relative but top and left have not been defined
				if (window.opera) {
					element.style.top = 0;
					element.style.left = 0;
				}
			}
			return element;
		},

		undoPositioned: function(element) {
			element = $(element);
			if (element._madePositioned) {
				element._madePositioned = undefined;
				element.style.position =
				element.style.top =
				element.style.left =
				element.style.bottom =
				element.style.right = '';
			}
			return element;
		},

		makeClipping: function(element) {
			element = $(element);
			if (element._overflow) return element;
			element._overflow = element.style.overflow || 'auto';
			if ((Element.getStyle(element, 'overflow') || 'visible') != 'hidden')
			element.style.overflow = 'hidden';
			return element;
		},

		undoClipping: function(element) {
			element = $(element);
			if (!element._overflow) return element;
			element.style.overflow = element._overflow == 'auto' ? '' : element._overflow;
			element._overflow = null;
			return element;
		}
	};

	Object.extend(Element.Methods, {childOf: Element.Methods.descendantOf});

	Element._attributeTranslations = {};

	Element._attributeTranslations.names = {
		colspan:   "colSpan",
		rowspan:   "rowSpan",
		valign:    "vAlign",
		datetime:  "dateTime",
		accesskey: "accessKey",
		tabindex:  "tabIndex",
		enctype:   "encType",
		maxlength: "maxLength",
		readonly:  "readOnly",
		longdesc:  "longDesc"
	};

	Element._attributeTranslations.values = {
		_getAttr: function(element, attribute) {
			return element.getAttribute(attribute, 2);
		},

		_flag: function(element, attribute) {
			return $(element).hasAttribute(attribute) ? attribute : null;
		},

		style: function(element) {
			return element.style.cssText.toLowerCase();
		},

		title: function(element) {
			var node = element.getAttributeNode('title');
			return node.specified ? node.nodeValue : null;
		}
	};

	Object.extend(Element._attributeTranslations.values, {
		href: Element._attributeTranslations.values._getAttr,
		src:  Element._attributeTranslations.values._getAttr,
		disabled: Element._attributeTranslations.values._flag,
		checked:  Element._attributeTranslations.values._flag,
		readonly: Element._attributeTranslations.values._flag,
		multiple: Element._attributeTranslations.values._flag
	});

	Element.Methods.Simulated = {
		hasAttribute: function(element, attribute) {
			var t = Element._attributeTranslations;
			attribute = t.names[attribute] || attribute;
			return $(element).getAttributeNode(attribute).specified;
		}
	};

	// IE is missing .innerHTML support for TABLE-related elements
	if (document.all && !window.opera){
		Element.Methods.update = function(element, html) {
			element = $(element);
			html = typeof html == 'undefined' ? '' : html.toString();
			var tagName = element.tagName.toUpperCase();
			if (['THEAD','TBODY','TR','TD'].include(tagName)) {
				var div = document.createElement('div');
				switch (tagName) {
					case 'THEAD':
					case 'TBODY':
					div.innerHTML = '<table><tbody>' +  html.stripScripts() + '</tbody></table>';
					depth = 2;
					break;
					case 'TR':
					div.innerHTML = '<table><tbody><tr>' +  html.stripScripts() + '</tr></tbody></table>';
					depth = 3;
					break;
					case 'TD':
					div.innerHTML = '<table><tbody><tr><td>' +  html.stripScripts() + '</td></tr></tbody></table>';
					depth = 4;
				}
				$A(element.childNodes).each(function(node){
					element.removeChild(node)
				});
				depth.times(function(){ div = div.firstChild });

				$A(div.childNodes).each(
				function(node){ element.appendChild(node) });
			} else {
				element.innerHTML = html.stripScripts();
			}
			setTimeout(function() {html.evalScripts()}, 10);
			return element;
		}
	};

	Object.extend(Element, Element.Methods);

	var _nativeExtensions = false;

	if(/Konqueror|Safari|KHTML/.test(navigator.userAgent))
	['', 'Form', 'Input', 'TextArea', 'Select'].each(function(tag) {
		var className = 'HTML' + tag + 'Element';
		if(window[className]) return;
		var klass = window[className] = {};
		klass.prototype = document.createElement(tag ? tag.toLowerCase() : 'div').__proto__;
	});

	Element.addMethods = function(methods) {
		Object.extend(Element.Methods, methods || {});

		function copy(methods, destination, onlyIfAbsent) {
			onlyIfAbsent = onlyIfAbsent || false;
			var cache = Element.extend.cache;
			for (var property in methods) {
				var value = methods[property];
				if (!onlyIfAbsent || !(property in destination))
				destination[property] = cache.findOrStore(value);
			}
		}

		if (typeof HTMLElement != 'undefined') {
			copy(Element.Methods, HTMLElement.prototype);
			copy(Element.Methods.Simulated, HTMLElement.prototype, true);
			copy(Form.Methods, HTMLFormElement.prototype);
			[HTMLInputElement, HTMLTextAreaElement, HTMLSelectElement].each(function(klass) {
				copy(Form.Element.Methods, klass.prototype);
			});
			_nativeExtensions = true;
		}
	}

	var Toggle = new Object();
	Toggle.display = Element.toggle;

	/*--------------------------------------------------------------------------*/

	Abstract.Insertion = function(adjacency) {
		this.adjacency = adjacency;
	}

	Abstract.Insertion.prototype = {
		initialize: function(element, content) {
			this.element = $(element);
			this.content = content.stripScripts();

			if (this.adjacency && this.element.insertAdjacentHTML) {
				try {
					this.element.insertAdjacentHTML(this.adjacency, this.content);
				} catch (e) {
					var tagName = this.element.tagName.toUpperCase();
					if (['TBODY', 'TR'].include(tagName)) {
						this.insertContent(this.contentFromAnonymousTable());
					} else {
						throw e;
					}
				}
			} else {
				this.range = this.element.ownerDocument.createRange();
				if (this.initializeRange) this.initializeRange();
				this.insertContent([this.range.createContextualFragment(this.content)]);
			}

			setTimeout(function() {content.evalScripts()}, 10);
		},

		contentFromAnonymousTable: function() {
			var div = document.createElement('div');
			div.innerHTML = '<table><tbody>' + this.content + '</tbody></table>';
			return $A(div.childNodes[0].childNodes[0].childNodes);
		}
	}

	var Insertion = new Object();

	Insertion.Before = Class.create();
	Insertion.Before.prototype = Object.extend(new Abstract.Insertion('beforeBegin'), {
		initializeRange: function() {
			this.range.setStartBefore(this.element);
		},

		insertContent: function(fragments) {
			fragments.each((function(fragment) {
				this.element.parentNode.insertBefore(fragment, this.element);
			}).bind(this));
		}
	});

	Insertion.Top = Class.create();
	Insertion.Top.prototype = Object.extend(new Abstract.Insertion('afterBegin'), {
		initializeRange: function() {
			this.range.selectNodeContents(this.element);
			this.range.collapse(true);
		},

		insertContent: function(fragments) {
			fragments.reverse(false).each((function(fragment) {
				this.element.insertBefore(fragment, this.element.firstChild);
			}).bind(this));
		}
	});

	Insertion.Bottom = Class.create();
	Insertion.Bottom.prototype = Object.extend(new Abstract.Insertion('beforeEnd'), {
		initializeRange: function() {
			this.range.selectNodeContents(this.element);
			this.range.collapse(this.element);
		},

		insertContent: function(fragments) {
			fragments.each((function(fragment) {
				this.element.appendChild(fragment);
			}).bind(this));
		}
	});

	Insertion.After = Class.create();
	Insertion.After.prototype = Object.extend(new Abstract.Insertion('afterEnd'), {
		initializeRange: function() {
			this.range.setStartAfter(this.element);
		},

		insertContent: function(fragments) {
			fragments.each((function(fragment) {
				this.element.parentNode.insertBefore(fragment,
				this.element.nextSibling);
			}).bind(this));
		}
	});

	/*--------------------------------------------------------------------------*/

	Element.ClassNames = Class.create();
	Element.ClassNames.prototype = {
		initialize: function(element) {
			this.element = $(element);
		},

		_each: function(iterator) {
			this.element.className.split(/\s+/).select(function(name) {
				return name.length > 0;
			})._each(iterator);
		},

		set: function(className) {
			this.element.className = className;
		},

		add: function(classNameToAdd) {
			if (this.include(classNameToAdd)) return;
			this.set($A(this).concat(classNameToAdd).join(' '));
		},

		remove: function(classNameToRemove) {
			if (!this.include(classNameToRemove)) return;
			this.set($A(this).without(classNameToRemove).join(' '));
		},

		toString: function() {
			return $A(this).join(' ');
		}
	};

	Object.extend(Element.ClassNames.prototype, Enumerable);
	var Selector = Class.create();
	Selector.prototype = {
		initialize: function(expression) {
			this.params = {classNames: []};
			this.expression = expression.toString().strip();
			this.parseExpression();
			this.compileMatcher();
		},

		parseExpression: function() {
			function abort(message) { throw 'Parse error in selector: ' + message; }

			if (this.expression == '')  abort('empty expression');

			var params = this.params, expr = this.expression, match, modifier, clause, rest;
			while (match = expr.match(/^(.*)\[([a-z0-9_:-]+?)(?:([~\|!]?=)(?:"([^"]*)"|([^\]\s]*)))?\]$/i)) {
				params.attributes = params.attributes || [];
				params.attributes.push({name: match[2], operator: match[3], value: match[4] || match[5] || ''});
				expr = match[1];
			}

			if (expr == '*') return this.params.wildcard = true;

			while (match = expr.match(/^([^a-z0-9_-])?([a-z0-9_-]+)(.*)/i)) {
				modifier = match[1], clause = match[2], rest = match[3];
				switch (modifier) {
					case '#':       params.id = clause; break;
					case '.':       params.classNames.push(clause); break;
					case '':
					case undefined: params.tagName = clause.toUpperCase(); break;
					default:        abort(expr.inspect());
				}
				expr = rest;
			}

			if (expr.length > 0) abort(expr.inspect());
		},

		buildMatchExpression: function() {
			var params = this.params, conditions = [], clause;

			if (params.wildcard)
			conditions.push('true');
			if (clause = params.id)
			conditions.push('element.readAttribute("id") == ' + clause.inspect());
			if (clause = params.tagName)
			conditions.push('element.tagName.toUpperCase() == ' + clause.inspect());
			if ((clause = params.classNames).length > 0)
			for (var i = 0, length = clause.length; i < length; i++)
			conditions.push('element.hasClassName(' + clause[i].inspect() + ')');
			if (clause = params.attributes) {
				clause.each(function(attribute) {
					var value = 'element.readAttribute(' + attribute.name.inspect() + ')';
					var splitValueBy = function(delimiter) {
						return value + ' && ' + value + '.split(' + delimiter.inspect() + ')';
					}

					switch (attribute.operator) {
						case '=':       conditions.push(value + ' == ' + attribute.value.inspect()); break;
						case '~=':      conditions.push(splitValueBy(' ') + '.include(' + attribute.value.inspect() + ')'); break;
						case '|=':      conditions.push(
						splitValueBy('-') + '.first().toUpperCase() == ' + attribute.value.toUpperCase().inspect()
						); break;
						case '!=':      conditions.push(value + ' != ' + attribute.value.inspect()); break;
						case '':
						case undefined: conditions.push('element.hasAttribute(' + attribute.name.inspect() + ')'); break;
						default:        throw 'Unknown operator ' + attribute.operator + ' in selector';
					}
				});
			}

			return conditions.join(' && ');
		},

		compileMatcher: function() {
			this.match = new Function('element', 'if (!element.tagName) return false; \
      element = $(element); \
      return ' + this.buildMatchExpression());
		},

		findElements: function(scope) {
			var element;

			if (element = $(this.params.id))
			if (this.match(element))
			if (!scope || Element.childOf(element, scope))
			return [element];

			scope = (scope || document).getElementsByTagName(this.params.tagName || '*');

			var results = [];
			for (var i = 0, length = scope.length; i < length; i++)
			if (this.match(element = scope[i]))
			results.push(Element.extend(element));

			return results;
		},

		toString: function() {
			return this.expression;
		}
	}

	Object.extend(Selector, {
		matchElements: function(elements, expression) {
			var selector = new Selector(expression);
			return elements.select(selector.match.bind(selector)).map(Element.extend);
		},

		findElement: function(elements, expression, index) {
			if (typeof expression == 'number') index = expression, expression = false;
			return Selector.matchElements(elements, expression || '*')[index || 0];
		},

		findChildElements: function(element, expressions) {
			return expressions.map(function(expression) {
				return expression.match(/[^\s"]+(?:"[^"]*"[^\s"]+)*/g).inject([null], function(results, expr) {
					var selector = new Selector(expr);
					return results.inject([], function(elements, result) {
						return elements.concat(selector.findElements(result || element));
					});
				});
			}).flatten();
		}
	});

	function $$() {
		return Selector.findChildElements(document, $A(arguments));
	}
	var Form = {
		reset: function(form) {
			$(form).reset();
			return form;
		},

		serializeElements: function(elements, getHash) {
			var data = elements.inject({}, function(result, element) {
				if (!element.disabled && element.name) {
					var key = element.name, value = $(element).getValue();
					if (value != undefined) {
						if (result[key]) {
							if (result[key].constructor != Array) result[key] = [result[key]];
							result[key].push(value);
						}
						else result[key] = value;
					}
				}
				return result;
			});

			return getHash ? data : Hash.toQueryString(data);
		}
	};

	Form.Methods = {
		serialize: function(form, getHash) {
			return Form.serializeElements(Form.getElements(form), getHash);
		},

		getElements: function(form) {
			return $A($(form).getElementsByTagName('*')).inject([],
			function(elements, child) {
				if (Form.Element.Serializers[child.tagName.toLowerCase()])
				elements.push(Element.extend(child));
				return elements;
			}
			);
		},

		getInputs: function(form, typeName, name) {
			form = $(form);
			var inputs = form.getElementsByTagName('input');

			if (!typeName && !name) return $A(inputs).map(Element.extend);

			for (var i = 0, matchingInputs = [], length = inputs.length; i < length; i++) {
				var input = inputs[i];
				if ((typeName && input.type != typeName) || (name && input.name != name))
				continue;
				matchingInputs.push(Element.extend(input));
			}

			return matchingInputs;
		},

		disable: function(form) {
			form = $(form);
			form.getElements().each(function(element) {
				element.blur();
				element.disabled = 'true';
			});
			return form;
		},

		enable: function(form) {
			form = $(form);
			form.getElements().each(function(element) {
				element.disabled = '';
			});
			return form;
		},

		findFirstElement: function(form) {
			return $(form).getElements().find(function(element) {
				return element.type != 'hidden' && !element.disabled &&
				['input', 'select', 'textarea'].include(element.tagName.toLowerCase());
			});
		},

		focusFirstElement: function(form) {
			form = $(form);
			form.findFirstElement().activate();
			return form;
		}
	}

	Object.extend(Form, Form.Methods);

	/*--------------------------------------------------------------------------*/

	Form.Element = {
		focus: function(element) {
			$(element).focus();
			return element;
		},

		select: function(element) {
			$(element).select();
			return element;
		}
	}

	Form.Element.Methods = {
		serialize: function(element) {
			element = $(element);
			if (!element.disabled && element.name) {
				var value = element.getValue();
				if (value != undefined) {
					var pair = {};
					pair[element.name] = value;
					return Hash.toQueryString(pair);
				}
			}
			return '';
		},

		getValue: function(element) {
			element = $(element);
			var method = element.tagName.toLowerCase();
			return Form.Element.Serializers[method](element);
		},

		clear: function(element) {
			$(element).value = '';
			return element;
		},

		present: function(element) {
			return $(element).value != '';
		},

		activate: function(element) {
			element = $(element);
			element.focus();
			if (element.select && ( element.tagName.toLowerCase() != 'input' ||
			!['button', 'reset', 'submit'].include(element.type) ) )
			element.select();
			return element;
		},

		disable: function(element) {
			element = $(element);
			element.disabled = true;
			return element;
		},

		enable: function(element) {
			element = $(element);
			element.blur();
			element.disabled = false;
			return element;
		}
	}

	Object.extend(Form.Element, Form.Element.Methods);
	var Field = Form.Element;
	var $F = Form.Element.getValue;

	/*--------------------------------------------------------------------------*/

	Form.Element.Serializers = {
		input: function(element) {
			switch (element.type.toLowerCase()) {
				case 'checkbox':
				case 'radio':
				return Form.Element.Serializers.inputSelector(element);
				default:
				return Form.Element.Serializers.textarea(element);
			}
		},

		inputSelector: function(element) {
			return element.checked ? element.value : null;
		},

		textarea: function(element) {
			return element.value;
		},

		select: function(element) {
			return this[element.type == 'select-one' ?
			'selectOne' : 'selectMany'](element);
		},

		selectOne: function(element) {
			var index = element.selectedIndex;
			return index >= 0 ? this.optionValue(element.options[index]) : null;
		},

		selectMany: function(element) {
			var values, length = element.length;
			if (!length) return null;

			for (var i = 0, values = []; i < length; i++) {
				var opt = element.options[i];
				if (opt.selected) values.push(this.optionValue(opt));
			}
			return values;
		},

		optionValue: function(opt) {
			// extend element because hasAttribute may not be native
			return Element.extend(opt).hasAttribute('value') ? opt.value : opt.text;
		}
	}

	/*--------------------------------------------------------------------------*/

	Abstract.TimedObserver = function() {}
	Abstract.TimedObserver.prototype = {
		initialize: function(element, frequency, callback) {
			this.frequency = frequency;
			this.element   = $(element);
			this.callback  = callback;

			this.lastValue = this.getValue();
			this.registerCallback();
		},

		registerCallback: function() {
			setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
		},

		onTimerEvent: function() {
			var value = this.getValue();
			var changed = ('string' == typeof this.lastValue && 'string' == typeof value
			? this.lastValue != value : String(this.lastValue) != String(value));
			if (changed) {
				this.callback(this.element, value);
				this.lastValue = value;
			}
		}
	}

	Form.Element.Observer = Class.create();
	Form.Element.Observer.prototype = Object.extend(new Abstract.TimedObserver(), {
		getValue: function() {
			return Form.Element.getValue(this.element);
		}
	});

	Form.Observer = Class.create();
	Form.Observer.prototype = Object.extend(new Abstract.TimedObserver(), {
		getValue: function() {
			return Form.serialize(this.element);
		}
	});

	/*--------------------------------------------------------------------------*/

	Abstract.EventObserver = function() {}
	Abstract.EventObserver.prototype = {
		initialize: function(element, callback) {
			this.element  = $(element);
			this.callback = callback;

			this.lastValue = this.getValue();
			if (this.element.tagName.toLowerCase() == 'form')
			this.registerFormCallbacks();
			else
			this.registerCallback(this.element);
		},

		onElementEvent: function() {
			var value = this.getValue();
			if (this.lastValue != value) {
				this.callback(this.element, value);
				this.lastValue = value;
			}
		},

		registerFormCallbacks: function() {
			Form.getElements(this.element).each(this.registerCallback.bind(this));
		},

		registerCallback: function(element) {
			if (element.type) {
				switch (element.type.toLowerCase()) {
					case 'checkbox':
					case 'radio':
					Event.observe(element, 'click', this.onElementEvent.bind(this));
					break;
					default:
					Event.observe(element, 'change', this.onElementEvent.bind(this));
					break;
				}
			}
		}
	}

	Form.Element.EventObserver = Class.create();
	Form.Element.EventObserver.prototype = Object.extend(new Abstract.EventObserver(), {
		getValue: function() {
			return Form.Element.getValue(this.element);
		}
	});

	Form.EventObserver = Class.create();
	Form.EventObserver.prototype = Object.extend(new Abstract.EventObserver(), {
		getValue: function() {
			return Form.serialize(this.element);
		}
	});
	if (!window.Event) {
		var Event = new Object();
	}

	Object.extend(Event, {
		KEY_BACKSPACE: 8,
		KEY_TAB:       9,
		KEY_RETURN:   13,
		KEY_ESC:      27,
		KEY_LEFT:     37,
		KEY_UP:       38,
		KEY_RIGHT:    39,
		KEY_DOWN:     40,
		KEY_DELETE:   46,
		KEY_HOME:     36,
		KEY_END:      35,
		KEY_PAGEUP:   33,
		KEY_PAGEDOWN: 34,

		element: function(event) {
			return event.target || event.srcElement;
		},

		isLeftClick: function(event) {
			return (((event.which) && (event.which == 1)) ||
			((event.button) && (event.button == 1)));
		},

		pointerX: function(event) {
			return event.pageX || (event.clientX +
			(document.documentElement.scrollLeft || document.body.scrollLeft));
		},

		pointerY: function(event) {
			return event.pageY || (event.clientY +
			(document.documentElement.scrollTop || document.body.scrollTop));
		},

		stop: function(event) {
			if (event.preventDefault) {
				event.preventDefault();
				event.stopPropagation();
			} else {
				event.returnValue = false;
				event.cancelBubble = true;
			}
		},

		// find the first node with the given tagName, starting from the
		// node the event was triggered on; traverses the DOM upwards
		findElement: function(event, tagName) {
			var element = Event.element(event);
			while (element.parentNode && (!element.tagName ||
			(element.tagName.toUpperCase() != tagName.toUpperCase())))
			element = element.parentNode;
			return element;
		},

		observers: false,

		_observeAndCache: function(element, name, observer, useCapture) {
			if (!this.observers) this.observers = [];
			if (element.addEventListener) {
				this.observers.push([element, name, observer, useCapture]);
				element.addEventListener(name, observer, useCapture);
			} else if (element.attachEvent) {
				this.observers.push([element, name, observer, useCapture]);
				element.attachEvent('on' + name, observer);
			}
		},

		unloadCache: function() {
			if (!Event.observers) return;
			for (var i = 0, length = Event.observers.length; i < length; i++) {
				Event.stopObserving.apply(this, Event.observers[i]);
				Event.observers[i][0] = null;
			}
			Event.observers = false;
		},

		observe: function(element, name, observer, useCapture) {
			element = $(element);
			useCapture = useCapture || false;

			if (name == 'keypress' &&
			(navigator.appVersion.match(/Konqueror|Safari|KHTML/)
			|| element.attachEvent))
			name = 'keydown';

			Event._observeAndCache(element, name, observer, useCapture);
		},

		stopObserving: function(element, name, observer, useCapture) {
			element = $(element);
			useCapture = useCapture || false;

			if (name == 'keypress' &&
			(navigator.appVersion.match(/Konqueror|Safari|KHTML/)
			|| element.detachEvent))
			name = 'keydown';

			if (element.removeEventListener) {
				element.removeEventListener(name, observer, useCapture);
			} else if (element.detachEvent) {
				try {
					element.detachEvent('on' + name, observer);
				} catch (e) {}
			}
		}
	});

	/* prevent memory leaks in IE */
	if (navigator.appVersion.match(/\bMSIE\b/))
	Event.observe(window, 'unload', Event.unloadCache, false);
	var Position = {
		// set to true if needed, warning: firefox performance problems
		// NOT neeeded for page scrolling, only if draggable contained in
		// scrollable elements
		includeScrollOffsets: false,

		// must be called before calling withinIncludingScrolloffset, every time the
		// page is scrolled
		prepare: function() {
			this.deltaX =  window.pageXOffset
			|| document.documentElement.scrollLeft
			|| document.body.scrollLeft
			|| 0;
			this.deltaY =  window.pageYOffset
			|| document.documentElement.scrollTop
			|| document.body.scrollTop
			|| 0;
		},

		realOffset: function(element) {
			var valueT = 0, valueL = 0;
			do {
				valueT += element.scrollTop  || 0;
				valueL += element.scrollLeft || 0;
				element = element.parentNode;
			} while (element);
			return [valueL, valueT];
		},

		cumulativeOffset: function(element) {
			var valueT = 0, valueL = 0;
			do {
				valueT += element.offsetTop  || 0;
				valueL += element.offsetLeft || 0;
				element = element.offsetParent;
			} while (element);
			return [valueL, valueT];
		},

		positionedOffset: function(element) {
			var valueT = 0, valueL = 0;
			do {
				valueT += element.offsetTop  || 0;
				valueL += element.offsetLeft || 0;
				element = element.offsetParent;
				if (element) {
					if(element.tagName=='BODY') break;
					var p = Element.getStyle(element, 'position');
					if (p == 'relative' || p == 'absolute') break;
				}
			} while (element);
			return [valueL, valueT];
		},

		offsetParent: function(element) {
			if (element.offsetParent) return element.offsetParent;
			if (element == document.body) return element;

			while ((element = element.parentNode) && element != document.body)
			if (Element.getStyle(element, 'position') != 'static')
			return element;

			return document.body;
		},

		// caches x/y coordinate pair to use with overlap
		within: function(element, x, y) {
			if (this.includeScrollOffsets)
			return this.withinIncludingScrolloffsets(element, x, y);
			this.xcomp = x;
			this.ycomp = y;
			this.offset = this.cumulativeOffset(element);

			return (y >= this.offset[1] &&
			y <  this.offset[1] + element.offsetHeight &&
			x >= this.offset[0] &&
			x <  this.offset[0] + element.offsetWidth);
		},

		withinIncludingScrolloffsets: function(element, x, y) {
			var offsetcache = this.realOffset(element);

			this.xcomp = x + offsetcache[0] - this.deltaX;
			this.ycomp = y + offsetcache[1] - this.deltaY;
			this.offset = this.cumulativeOffset(element);

			return (this.ycomp >= this.offset[1] &&
			this.ycomp <  this.offset[1] + element.offsetHeight &&
			this.xcomp >= this.offset[0] &&
			this.xcomp <  this.offset[0] + element.offsetWidth);
		},

		// within must be called directly before
		overlap: function(mode, element) {
			if (!mode) return 0;
			if (mode == 'vertical')
			return ((this.offset[1] + element.offsetHeight) - this.ycomp) /
			element.offsetHeight;
			if (mode == 'horizontal')
			return ((this.offset[0] + element.offsetWidth) - this.xcomp) /
			element.offsetWidth;
		},

		page: function(forElement) {
			var valueT = 0, valueL = 0;

			var element = forElement;
			do {
				valueT += element.offsetTop  || 0;
				valueL += element.offsetLeft || 0;

				// Safari fix
				if (element.offsetParent==document.body)
				if (Element.getStyle(element,'position')=='absolute') break;

			} while (element = element.offsetParent);

			element = forElement;
			do {
				if (!window.opera || element.tagName=='BODY') {
					valueT -= element.scrollTop  || 0;
					valueL -= element.scrollLeft || 0;
				}
			} while (element = element.parentNode);

			return [valueL, valueT];
		},

		clone: function(source, target) {
			var options = Object.extend({
				setLeft:    true,
				setTop:     true,
				setWidth:   true,
				setHeight:  true,
				offsetTop:  0,
				offsetLeft: 0
			}, arguments[2] || {})

			// find page position of source
			source = $(source);
			var p = Position.page(source);

			// find coordinate system to use
			target = $(target);
			var delta = [0, 0];
			var parent = null;
			// delta [0,0] will do fine with position: fixed elements,
			// position:absolute needs offsetParent deltas
			if (Element.getStyle(target,'position') == 'absolute') {
				parent = Position.offsetParent(target);
				delta = Position.page(parent);
			}

			// correct by body offsets (fixes Safari)
			if (parent == document.body) {
				delta[0] -= document.body.offsetLeft;
				delta[1] -= document.body.offsetTop;
			}

			// set position
			if(options.setLeft)   target.style.left  = (p[0] - delta[0] + options.offsetLeft) + 'px';
			if(options.setTop)    target.style.top   = (p[1] - delta[1] + options.offsetTop) + 'px';
			if(options.setWidth)  target.style.width = source.offsetWidth + 'px';
			if(options.setHeight) target.style.height = source.offsetHeight + 'px';
		},

		absolutize: function(element) {
			element = $(element);
			if (element.style.position == 'absolute') return;
			Position.prepare();

			var offsets = Position.positionedOffset(element);
			var top     = offsets[1];
			var left    = offsets[0];
			var width   = element.clientWidth;
			var height  = element.clientHeight;

			element._originalLeft   = left - parseFloat(element.style.left  || 0);
			element._originalTop    = top  - parseFloat(element.style.top || 0);
			element._originalWidth  = element.style.width;
			element._originalHeight = element.style.height;

			element.style.position = 'absolute';
			element.style.top    = top + 'px';
			element.style.left   = left + 'px';
			element.style.width  = width + 'px';
			element.style.height = height + 'px';
		},

		relativize: function(element) {
			element = $(element);
			if (element.style.position == 'relative') return;
			Position.prepare();

			element.style.position = 'relative';
			var top  = parseFloat(element.style.top  || 0) - (element._originalTop || 0);
			var left = parseFloat(element.style.left || 0) - (element._originalLeft || 0);

			element.style.top    = top + 'px';
			element.style.left   = left + 'px';
			element.style.height = element._originalHeight;
			element.style.width  = element._originalWidth;
		}
	}

	// Safari returns margins on body which is incorrect if the child is absolutely
	// positioned.  For performance reasons, redefine Position.cumulativeOffset for
	// KHTML/WebKit only.
	if (/Konqueror|Safari|KHTML/.test(navigator.userAgent)) {
		Position.cumulativeOffset = function(element) {
			var valueT = 0, valueL = 0;
			do {
				valueT += element.offsetTop  || 0;
				valueL += element.offsetLeft || 0;
				if (element.offsetParent == document.body)
				if (Element.getStyle(element, 'position') == 'absolute') break;

				element = element.offsetParent;
			} while (element);

			return [valueL, valueT];
		}
	}

	Element.addMethods();

	function rwf_premiere_lettre_majuscule(rwf_chaine){
		return rwf_chaine.substr(0,1).toUpperCase()+rwf_chaine.substr(1,rwf_chaine.length).toLowerCase();
	}

	/**
	//////////////////////////////////////////////////////////////////////////
	//////////////////////////////////////////////////////////////////////////
	//////////////////////////////////////////////////////////////////////////
	FONCTIONS AJAX
	//////////////////////////////////////////////////////////////////////////
	//////////////////////////////////////////////////////////////////////////
	//////////////////////////////////////////////////////////////////////////
	*/

	// équivalent de isset() en php
	function rw_isset(v){
		if(typeof(v)=='undefined' || v==null){
			return false;
		}
		return true;
	}

	// équivalent de empty() en php
	function rw_empty(v){
		if(!rw_isset(v) || v==''){
			return true;
		}
		return false;
	}

	// permet d'ajouter plusieurs methode au window.onload
	// s'utilise de la maniere suivante
	//addLoadEvent(get_response);
	//addLoadEvent(get_lang);
	function rwf_addLoadEvent(rwf_func) {
		var rwf_oldonload = window.onload;
		if (typeof window.onload != 'function') {
			window.onload = rwf_func;
		}
		else {
			window.onload = function() {
				rwf_oldonload();
				rwf_func();
			}
		}
	}

	function rwf_EcrireCookie(rwf_nom, rwf_valeur){
		var rwf_argv=rwf_EcrireCookie.arguments;
		var rwf_argc=rwf_EcrireCookie.arguments.length;
		var rwf_expires=(rwf_argc > 2) ? rwf_argv[2] : null;
		var rwf_path=(rwf_argc > 3) ? rwf_argv[3] : null;
		var rwf_domain=(rwf_argc > 4) ? rwf_argv[4] : null;
		var rwf_secure=(rwf_argc > 5) ? rwf_argv[5] : false;
		document.cookie=rwf_nom+"="+escape(rwf_valeur)+
		((rwf_expires==null) ? "" : ("; expires="+rwf_expires.toGMTString()))+
		((rwf_path==null) ? "" : ("; path="+rwf_path))+
		((rwf_domain==null) ? "" : ("; domain="+rwf_domain))+
		((rwf_secure==true) ? "; secure" : "");
	}

	function rwf_getCookieVal(rwf_offset)
	{
		var rwf_endstr=document.cookie.indexOf (";", rwf_offset);
		if (rwf_endstr==-1) rwf_endstr=document.cookie.length;
		return unescape(document.cookie.substring(rwf_offset, rwf_endstr));
	}
	function rwf_LireCookie(rwf_nom)
	{
		var rwf_arg=rwf_nom+"=";
		var rwf_alen=rwf_arg.length;
		var rwf_clen=document.cookie.length;
		var i=0;
		while (i<rwf_clen)
		{
			var j=i+rwf_alen;
			if (document.cookie.substring(i, j)==rwf_arg) return rwf_getCookieVal(j);
			i=document.cookie.indexOf(" ",i)+1;
			if (i==0) break;

		}
		return null;
	}
	var _settimeout;
	function rwf_add_script_tag(rwf_url, rwf_param){
		rechercheNav=RegExp("MSIE [0-6].?[0-9]");
		if(_settimeout==true && navigator.appVersion.match(rechercheNav)){ // pour r�soudre le probleme sous ie6 qui ne charge pas le js
			_settimeout=false;
			setTimeout('rwf_add_script_tag(\''+rwf_url+'\',\''+rwf_param+'\')',100);
			return;
		}
		var rwf_tmp=new Date();
		rwf_tmp = '?rwf_time='+rwf_tmp.getTime()+'&';
		var rwf_script= document.createElement("script");
		rwf_script.setAttribute('type','text/javascript');
		if(rwf__add_data!=''){
			//		$('test').innerHTML += rwf_url+rwf_tmp+rwf_param+rwf__add_data+'<br />';
			rwf_script.setAttribute('src',rwf_url+rwf_tmp+rwf_param+rwf__add_data);
		}else{
			//		$('test').innerHTML += rwf_url+rwf_tmp+rwf_param+'<br />';
			rwf_script.setAttribute('src',rwf_url+rwf_tmp+rwf_param);
		}
		var rwf_head = document.getElementsByTagName("head")[0];
		rwf_head.appendChild(rwf_script);
	}

	// retourne l'url du fichier css
	function rwf_get_css_url(rwf_file_css){
		return rwf__files_css+'form2007/'+rwf_file_css+'.css';
		//	return rwf__files+'css/form2007/'+rwf_file_css+'.css'; // obsolete
	}

	function rwf_add_script_tag_css(rwf_url,rwf_complete){
		if(rwf_complete==null){
			rwf_url = rwf_get_css_url(rwf_url);
			//		if(rwf_url!='gabarit1'){
			//			rwf__skin = rwf_url;
			//		}else{
			//			rwf__skin = 'blue2';
			//		}
		}

		var rwf_tmp=new Date();
		rwf_tmp = '?rwf_time='+rwf_tmp.getTime()+'&';
		var rwf_style= document.createElement("link");
		rwf_style.setAttribute('type','text/css');
		rwf_style.setAttribute('rel','stylesheet');
		rwf_style.setAttribute('href',rwf_url+rwf_tmp);
		var rwf_head = document.getElementsByTagName("head")[0];
		rwf_head.appendChild(rwf_style);
	}

	var rwf__lang_selected='', rwf_type_paiement_selected='', rwf_pays_selected='', rwf_cookie_present=false;
	// requette ajax pour recuperer toutes les infos necessaires pour completer le formulaire
	function rwf_get_response(){

		function add_ajax_loader_img(){
			var rwf_block_parent_img1 = $('rentabiliweb_form_content_contact_code');
			var rwf_block_parent_img2 = $('rentabiliweb_form_content_contact_type');
			var rwf_block_parent_img3 = $('rentabiliweb_form_content_contact_type_img');
			var rwf_block_parent_img4 = $('rentabiliweb_form_content_pays_drapeaux');

			var rwf_img1 = document.createElement('img');
			var rwf_img2 = document.createElement('img');
			var rwf_img3 = document.createElement('img');
			var rwf_img4 = document.createElement('img');

			rwf_img1.src= rwf__files_img+'ajax-loader.gif';
			rwf_img2.src= rwf__files_img+'ajax-loader.gif';
			rwf_img3.src= rwf__files_img+'ajax-loader.gif';
			rwf_img3.src= rwf__files_img+'ajax-loader.gif';

			rwf_block_parent_img1.appendChild(rwf_img1);
			rwf_block_parent_img2.appendChild(rwf_img2);
			rwf_block_parent_img3.appendChild(rwf_img3);
			rwf_block_parent_img3.appendChild(rwf_img3);
		}

		add_ajax_loader_img();

		// fonction pour ajouter le liens vers les codes gratuits
		function rwf_create_code_gratuit(){
			var rwf_div_parent_code_gratuit = $('rentabiliweb_form_content_pays');

			var rwf_div_block_code_gratuit = document.createElement('a');
			rwf_div_block_code_gratuit.id = 'rentabiliweb_form_content_pays_code_gratuit';
			rwf_div_block_code_gratuit.target = '_blank';
			rwf_div_block_code_gratuit.href = 'http://www.rentabiliweb.com/code_gratuit/?SITE_ID='+rwf__site_id+'&DOC_ID='+rwf__doc_id;

			var rwf_div_block_code_gratuit_libele = document.createElement('span');
			rwf_div_block_code_gratuit_libele.id = 'rentabiliweb_form_content_pays_code_gratuit_libele';

			var rwf_div_block_code_gratuit_img = document.createElement('span');
			rwf_div_block_code_gratuit_img.id= 'rentabiliweb_form_content_pays_code_gratuit_img';

			var rwf_nouveau_img = document.createElement('img');
			rwf_nouveau_img.src= rwf__files_img+'form2007/imgs/icone-cadeau.gif';

			rwf_div_block_code_gratuit_img.appendChild(rwf_nouveau_img);
			rwf_div_block_code_gratuit.appendChild(rwf_div_block_code_gratuit_libele);
			rwf_div_block_code_gratuit.appendChild(rwf_div_block_code_gratuit_img);
			rwf_div_parent_code_gratuit.appendChild(rwf_div_block_code_gratuit);
		}

		if(typeof(rwf_code_gratuit)=='undefined'){
			// on ajoute le lien pour les codes gratuits
			//rwf_create_code_gratuit();
		}


		function rwf_ajoute_images(){
			var rwf_block_parent_img1 = $('rentabiliweb_form_links_img1');
			var rwf_block_parent_img2 = $('rentabiliweb_form_links_img2');
			var rwf_block_parent_img3 = $('rentabiliweb_form_links_img3');

			var rwf_img1 = document.createElement('img');
			var rwf_img2 = document.createElement('img');
			var rwf_img3 = document.createElement('img');

			var rwf_img_stats = document.createElement('img');
			rwf_img_stats.src= 'http://stat3.cybermonitor.com/rentabilitrack_v?R=RUBRIQUE&S=total;SECTION';
			rwf_img_stats.width = '1';
			rwf_img_stats.height = '1';

			rwf_img1.src= rwf__files_img+'form2007/imgs/ex.gif';
			rwf_img1.id='rentabiliweb_form_bottom_links_support_technique_img1';
			rwf_img2.src= rwf__files_img+'form2007/imgs/icra.gif';
			rwf_img3.src= rwf__files_img+'form2007/imgs/locker.gif';

			rwf_block_parent_img1.appendChild(rwf_img1);
			rwf_block_parent_img2.appendChild(rwf_img2);
			rwf_block_parent_img3.appendChild(rwf_img3);
			rwf_block_parent_img3.appendChild(rwf_img_stats);
		}
		if($('rentabiliweb_form_links_img1')){
			rwf_ajoute_images();
		}

		if(rwf__css_url && rwf__css_url!=''){
			rwf_add_script_tag_css(rwf__css_url, true);
		}else{
			rwf_add_script_tag_css('gabarit1');
			if(rwf__skin && rwf__skin!=''){
				rwf_add_script_tag_css(rwf__skin);
			}
		}


		// liste des styles disponible
		if(typeof(affiche_style_select)!='undefined' && affiche_style_select==true){
			rwf_ajouter_styles();
		}
		// liste des langues disponible
		rwf_ajouter_langues();
		var rwf_chaine = null;
		if(rwf_chaine=rwf_LireCookie("rentabiliweb_formulaire")){
			rwf_cookie_present = true;
			var rwf_reg=new RegExp("[;]+", "g");
			var rwf_reg2 = new RegExp("[=]+", "g");
			var rwf_tableau=rwf_chaine.split(rwf_reg);

			var rwf_tableau_length = rwf_tableau.length;
			for (var i=0; i<rwf_tableau_length; i++) {
				var rwf_tableau2 = rwf_tableau[i].split(rwf_reg2);

				if(rwf_tableau2[0]=='lang_selected'){
					rwf__lang_selected = rwf_tableau2[1];
				}else if(rwf_tableau2[0]=='type_paiement_selected'){
					rwf_type_paiement_selected = rwf_tableau2[1];
				}else if(rwf_tableau2[0]=='pays_selected'){
					rwf_pays_selected = rwf_tableau2[1];
				}
			}
		}else{ // s'il n'y a pas de cookie et qu'on a des choix par defaut
			if(rwf__lang_selected=='' && rwf__default_language!='' && rwf__geolocalisation==0){
				rwf__lang_selected = rwf__default_language;
			}
			if(rwf_type_paiement_selected=='' && rwf_default_payment_type!=''){
				rwf_type_paiement_selected=rwf_default_payment_type;
			}
			if(rwf_pays_selected=='' && rwf__default_country!=''){
				rwf_pays_selected=rwf__default_country;
			}
		}
		rwf_add_script_tag(rwf__url_data_numbers+'?doc_id='+rwf__doc_id+'&site_id='+rwf__site_id+'&geolocalisation='+rwf__geolocalisation+'&default_country='+rwf__default_country);
	}
	function rwf_reponse_data_numbers(){
		if(rwf__reponses_ajax){
			rwf_add_script_tag(rwf__url_data_lang);
		}else{
			$('rentabiliweb_form').innerHTML = '<a href="http://www.rentabiliweb.com">Formulaire desactiv\351 ou Services en cours d\'activation</a>';
			$('rentabiliweb_form').className = 'center_texte';
			return;
		}
	}

	var rwf__langues_name = new Array('Fran\347ais', 'English', 'Deutsch', 'Spanish', 'Romana');
	var rwf__langues_code = new Array('fr', 'en', 'de', 'es', 'ro');
	function rwf_ajouter_langues(){
		rwf_lang_tab = rwf__langues_code.length;
		var rwf_divParent = $('rentabiliweb_form_top_right_lang_select');
		rwf_divParent.innerHTML='';
		for(rwf_langues_i=0;rwf_langues_i<rwf_lang_tab;rwf_langues_i++){
			// creation des nouveaux noeuds
			var rwf_new_lang = document.createElement('option');
			rwf_new_lang.id='rentabiliweb_form_top_right_lang_select_'+rwf__langues_code[rwf_langues_i];
			rwf_new_lang.value=rwf__langues_code[rwf_langues_i];
			rwf_new_lang.appendChild(document.createTextNode(rwf__langues_name[rwf_langues_i]));
			// raccord des noeuds
			rwf_divParent.appendChild(rwf_new_lang);
		}
	}

	var rwf__styles_name = new Array('Bleu clair','Bleu','Gris', 'Orange', 'Rose', 'Jaune', 'Rouge', 'Vert');
	var rwf__styles_code = new Array('blue2','blue','grey', 'orange', 'pink', 'yellow', 'red', 'green');
	function rwf_ajouter_styles(){
		rwf_styles_tab = rwf__styles_code.length;
		var rwf_divParent = $('rentabiliweb_form_top_right_style_select');
		rwf_divParent.innerHTML='';
		for(rwf_styles_i=0;rwf_styles_i<rwf_styles_tab;rwf_styles_i++){
			// creation des nouveaux noeuds
			var rwf_new_style = document.createElement('option');
			rwf_new_style.id='rentabiliweb_form_top_right_style_select_'+rwf__langues_code[rwf_styles_i];
			rwf_new_style.value=rwf__styles_code[rwf_styles_i];
			rwf_new_style.appendChild(document.createTextNode(rwf__styles_name[rwf_styles_i]));
			// raccord des noeuds
			rwf_divParent.appendChild(rwf_new_style);
		}
	}

	// requette ajax pour récupérer toutes les langues
	var rwf_pays_default = rwf__default_country;
	function rwf_get_data_lang(){
		// on change la langue par rapport à la géolocalisation

		rwf_affiche_flags();
		if(typeof(rwf__geolocalisation) !='undefined' && rwf__geolocalisation == 1){
			rwf_pays_default = rwf__reponses_ajax_lang.lang.pays_default;
		}

		if(rwf__lang_selected!=''){
			rwf_change_lang(rwf__lang_selected);
		}else{
			rwf__lang_selected = rwf__reponses_ajax_lang.lang.lang_default;
			if(rwf__lang_selected==''){
				rwf__lang_selected = 'fr';
			}
			rwf_change_lang(rwf__lang_selected);
		}
		if(rwf_cookie_present==false && rwf_pays_default!='' && rwf_default_payment_type!=''){// choix de la geolocalisation
			rwf_pays_selected = rwf_pays_default;
			rwf_affiche_types_paiement(rwf_pays_default, rwf_default_payment_type);
		}else if(rwf_pays_selected!=null && rwf_type_paiement_selected!=null){ // choix du cookie ou choix du webmaster par défaut
			rwf_affiche_types_paiement(rwf_pays_selected, rwf_type_paiement_selected);
		}
	}
	var rwf__lang_selected_change=false;
	// code = code pays (fr, en, de ...)
	function rwf_change_lang(rwf_code){
		$('rentabiliweb_form_top_right_lang_select_'+rwf_code).selected = 'selected';
		$('rentabiliweb_form_logo_texte').innerHTML = rwf__reponses_ajax_lang.lang.logo_texte[rwf_code];
		$('rentabiliweb_form_top_right_libele_l').innerHTML = rwf_premiere_lettre_majuscule(rwf__reponses_ajax_lang.lang.langues_libele[rwf_code]);
		$('rentabiliweb_form_top_bottom_1').innerHTML = rwf__reponses_ajax_lang.lang.explication1[rwf_code];
		if(rwf_pays_length>2){
			$('rentabiliweb_form_top_bottom_2').innerHTML = rwf__reponses_ajax_lang.lang.explication2[rwf_code];
		}else{
			$('rentabiliweb_form_top_bottom_2').innerHTML = rwf__reponses_ajax_lang.lang.explication2_un_seul_pays[rwf_code];
		}
		$('rentabiliweb_form_content_pays_libele').innerHTML = rwf_premiere_lettre_majuscule(rwf__reponses_ajax_lang.lang.pays_libele[rwf_code]);
		$('rentabiliweb_form_content_pays_cb_libele').innerHTML = rwf_premiere_lettre_majuscule(rwf__reponses_ajax_lang.lang.cb_paiement_libele[rwf_code]);
		$('rentabiliweb_form_bottom_links_support_technique_libele').innerHTML = rwf_premiere_lettre_majuscule(rwf__reponses_ajax_lang.lang.support_technique_libele[rwf_code]);
		$('rentabiliweb_form_bottom_links_paiement_securise_libele').innerHTML = rwf_premiere_lettre_majuscule(rwf__reponses_ajax_lang.lang.paiement_securise_libele[rwf_code]);
		if($('rentabiliweb_form_content_pays_code_gratuit_libele')){
			$('rentabiliweb_form_content_pays_code_gratuit_libele').innerHTML = rwf_premiere_lettre_majuscule(rwf__reponses_ajax_lang.lang.code_gratuit_libele[rwf_code]);
		}

		if($('rentabiliweb_form_content_contact_type_audiotel')){
			$('rentabiliweb_form_content_contact_type_audiotel').innerHTML = '&nbsp;&nbsp;'+rwf_premiere_lettre_majuscule(rwf__reponses_ajax_lang.lang.audiotel_libele[rwf_code]);
		}
		if($('rentabiliweb_form_content_contact_type_sms')){
			$('rentabiliweb_form_content_contact_type_sms').innerHTML = '&nbsp;&nbsp;'+rwf_premiere_lettre_majuscule(rwf__reponses_ajax_lang.lang.sms_libele[rwf_code]);
		}
		if($('rentabiliweb_form_content_contact_type_internet')){
			$('rentabiliweb_form_content_contact_type_internet').innerHTML = '&nbsp;&nbsp;'+rwf_premiere_lettre_majuscule(rwf__reponses_ajax_lang.lang.internet_libele[rwf_code]);
		}
		if($('rentabiliweb_form_content_contact_type_paypal')){
			$('rentabiliweb_form_content_contact_type_paypal').innerHTML = '&nbsp;&nbsp;'+rwf_premiere_lettre_majuscule(rwf__reponses_ajax_lang.lang.paypal_libele[rwf_code]);
		}
		if($('rentabiliweb_form_content_contact_type_cb')){
			$('rentabiliweb_form_content_contact_type_cb').innerHTML = '&nbsp;&nbsp;'+rwf_premiere_lettre_majuscule(rwf__reponses_ajax_lang.lang.cb_libele[rwf_code]);
		}
		if($('rentabiliweb_form_content_contact_type_ticketsurf')){
			$('rentabiliweb_form_content_contact_type_ticketsurf').innerHTML = '&nbsp;&nbsp;'+rwf_premiere_lettre_majuscule(rwf__reponses_ajax_lang.lang.ticketsurf_libele[rwf_code]);
		}
		if($('rentabiliweb_form_content_contact_type_neosurf')){
			$('rentabiliweb_form_content_contact_type_neosurf').innerHTML = '&nbsp;&nbsp;'+rwf_premiere_lettre_majuscule(rwf__reponses_ajax_lang.lang.neosurf_libele[rwf_code]);
		}
		if($('rentabiliweb_form_content_contact_type_mistercash')){
			$('rentabiliweb_form_content_contact_type_mistercash').innerHTML = '&nbsp;&nbsp;'+rwf_premiere_lettre_majuscule(rwf__reponses_ajax_lang.lang.mistercash_libele[rwf_code]);
		}
		if($('rentabiliweb_form_content_contact_type_onnet')){
			$('rentabiliweb_form_content_contact_type_onnet').innerHTML = '&nbsp;&nbsp;'+rwf__reponses_ajax_lang.lang.onnet_libele[rwf_code];
		}

		rwf__default_language = rwf_code;

		// si on ne veux pas changer de pays sur un select de langue
		if(rwf__lang_selected!=rwf_code){
			rwf__lang_selected_change=true;
			rwf__lang_selected = rwf_code;
			rwf_affiche_types_paiement(rwf_pays_selected, rwf_type_paiement_selected);
		}

		// dernier pays selectionnee, pour l'ecriture dans le cookie si validation de code
		rwf__lang_selected = rwf_code;

	}
	var rwf__pays= new Object();
	// code du premier pays afficher
	var rwf_code_pays_default = '';
	//var preload_image_object = new Image();
	// nombre de pays
	var rwf_pays_length = 0;
	function rwf_affiche_flags(){
		var rwf_html='';
		var rwf_code_pays = '';
		rwf_affiche_types_paiement_default = false;

		var rwf_code = 0;
		rwf_nbr_type_paiement_flags = rwf__types_paiement_flags.length;
		for(rwf_i=0;rwf_i<rwf_nbr_type_paiement_flags;rwf_i++){
			var rwf_type_paiement = rwf__types_paiement_flags[rwf_i]
			if(rwf__reponses_ajax[rwf_type_paiement]){
				var rwf_pays_affiche_length = rwf__reponses_ajax[rwf_type_paiement].images.length;
				for(i=0;i<rwf_pays_affiche_length;i++){
					if(rwf_code_pays_default==''){
						rwf_code_pays_default=rwf__reponses_ajax[rwf_type_paiement].images[i].code;
					}
					rwf_code_pays = rwf__reponses_ajax[rwf_type_paiement].images[i].code;
					rwf_pays = false;
					for(rwf_key in rwf__pays){
						if(rwf__pays[rwf_key].code==rwf_code_pays){
							rwf_pays=true;
						}
					}
					if(rwf_pays==true){
						continue;
					}
					rwf__pays[++rwf_code] = new Object();
					rwf__pays[rwf_code]['code'] = rwf__reponses_ajax[rwf_type_paiement].images[i].code;
					rwf__pays[rwf_code]['libele'] = rwf__reponses_ajax[rwf_type_paiement].images[i].libele_pays;
					rwf__pays[rwf_code]['flag'] = rwf__reponses_ajax[rwf_type_paiement].images[i].flag;
				}
			}
		}

		// nombre de pays affich�
		rwf_pays_length = 0;
		for ( rwf_key in rwf__pays ) {
			rwf_pays_length++;
		}


		if(rwf_pays_length>0){
			for ( rwf_key in rwf__pays ) {
				if(rwf__pays[rwf_key].libele=='TOUS'){
					continue;
				}
				rwf_html += '<a href="javascript:void(0);" onclick="rwf_affiche_types_paiement(\''+rwf__pays[rwf_key].code+'\');">';
				rwf_html += '<img src="'+rwf__pays[rwf_key].flag+'" alt="'+rwf__pays[rwf_key].libele+'" title="'+rwf__pays[rwf_key].libele+'" />';
				rwf_html += '</a> ';

				if(rwf_affiche_types_paiement_default==false){
					rwf_code_pays = rwf__pays[rwf_key].code;
					rwf_affiche_types_paiement_default = true;
				}
			}
		}
		$('rentabiliweb_form_content_pays_drapeaux').innerHTML = rwf_html;
		if(rwf_pays_selected==null && rwf_type_paiement_selected==null){
			rwf_affiche_types_paiement(rwf_code_pays);
		}
		return;
	}
	function rwf_retourne_image_balise(rwf_name, rwf_onclick){
		return '<a href="javascript:void(0);" onclick="rwf_affiche_image('+rwf_onclick+');"><img src="'+rwf__files_img+'form2007/imgs/'+rwf_name+'.gif" alt="'+rwf_name+'" /></a>';
	}

	var rwf__nbr_codes_total = 0; // nombre total de codes a entrer
	var rwf_nbr_type_paiement = 0;
	var nbr_relance = 0;
	var test=0;
	function rwf_affiche_types_paiement(rwf_pays, rwf_v_type_paiement){
		// dernier pays selectionne, pour l'ecriture dans le cookie si validation de code
		var rwf_types_paiement_array = new Array();
		$('rentabiliweb_form_bottom_erreur').hide();

		rwf_pays_selected = rwf_pays;
		rwf_nbr_type_paiement=0;
		var rwf_tab_length = rwf__types_paiement.length;
		var rwf_html='';
		var rwf_html_cb='';
		var rwf_html_img='';
		var rwf_dossier_img_type_paiement;
		var rwf_affiche_image_default = false;
		var rwf_affiche_cb = false;
		var rwf_affiche_pays_flags = false;

		// si le type de paiement demandé n'existe pas alors on l'annule
		if(rw_empty(rwf__reponses_ajax[rwf_v_type_paiement])){
			rwf_v_type_paiement=null;
		}else if(rwf_v_type_paiement==null){
			// si le dernier type de paiement existe pour ce pays alors on le sélectionne par défaut
			if(rwf_type_paiement_selected!=''){
				var rwf_nbr_pays = rwf__reponses_ajax[rwf_type_paiement_selected].images.length;
				for(rwf_i=0;rwf_i<rwf_nbr_pays;rwf_i++){
					if((rwf__reponses_ajax[rwf_type_paiement_selected].images[0].libele_pays=='TOUS' || rwf__reponses_ajax[rwf_type_paiement_selected].images[0].libele_pays=='tous') || rwf__reponses_ajax[rwf_type_paiement_selected].images[rwf_i].code==rwf_pays){
						rwf_v_type_paiement = rwf_type_paiement_selected;
						break;
					}
				}
			}
		}
		// on boucle sur le nombre de type de paiement
		for(rwf_fi=0;rwf_fi<rwf_tab_length;rwf_fi++) {
			// si on trouve le type de paiement dans le retour serveur
			if(rwf__reponses_ajax[rwf__types_paiement[rwf_fi]]){
				var rwf_tab_types_paiement_length = rwf__reponses_ajax[rwf__types_paiement[rwf_fi]].images.length;
				for(rwf_j=0;rwf_j<rwf_tab_types_paiement_length;rwf_j++){
					var rwf_url_popup = null;
					var rwf_type_paiement = '';
					rwf_type_paiement = rwf__types_paiement[rwf_fi];

					if(rwf__reponses_ajax[rwf__types_paiement[rwf_fi]].url_popup){
						//					if(typeof(rwf__skin)=='undefined' || rwf__skin==''){
						//						_skin = 'blue2';
						//					}else{
						//						_skin = rwf__skin;
						//					}
						//					rwf_url_popup = rwf__reponses_ajax[rwf__types_paiement[rwf_fi]].url_popup+'&skin='+_skin;
						rwf_url_popup = rwf__reponses_ajax[rwf__types_paiement[rwf_fi]].url_popup;
					}
					// numero de l'image audiotel ou sms
					rwf_number_id = rwf__reponses_ajax[rwf__types_paiement[rwf_fi]].images[rwf_j].number_id;

					var rwf_image = '';
					if(rwf_type_paiement=='audiotel' || rwf_type_paiement=='sms'){
						var rwf_lang_selected = '';
						rwf_lang_selected='&lang_selected='+rwf__lang_selected;
						rwf_image = rwf__domaine+'displayImg.php?NUM_ID='+rwf_number_id+'&DOC_ID='+rwf__doc_id+'&code_pays='+rwf_pays+rwf_lang_selected;
					}else{
						rwf_image = rwf__types_paiement[rwf_fi];
					}

					var rwf_var_onclick = '\''+rwf_image+'\', \''+ rwf_url_popup+ '\', \''+rwf__reponses_ajax[rwf_type_paiement].nbr_codes+ '\', \''+rwf_type_paiement+'\'';

					if(rwf_type_paiement=='cb' && typeof(rwf__reponses_ajax['cb']) == 'object' && (rwf__reponses_ajax['cb'].images[0].libele_pays=='TOUS' || rwf__reponses_ajax['cb'].images[0].libele_pays=='tous')){
						rwf_nbr_type_paiement++;
						rwf_html += '<a href="javascript:void(0);" onclick="rwf_affiche_image('+rwf_var_onclick+');" id="rentabiliweb_form_content_contact_type_'+rwf__types_paiement[rwf_fi]+'">&nbsp;&nbsp;';
						rwf_html += rwf_premiere_lettre_majuscule(rwf__reponses_ajax_lang.lang[rwf__types_paiement[rwf_fi]+'_libele'][rwf__default_language]);
						rwf_html += '</a><br /> ';
						rwf_html_img += rwf_retourne_image_balise(rwf__types_paiement[rwf_fi], rwf_var_onclick);

						var rwf_cb_logo_click = '<a href="javascript:void(0);" onclick="rwf_affiche_image('+rwf_var_onclick+');">';
						rwf_cb_logo_click += '<img src="'+rwf__files_img+'form2007/imgs/cb.gif" alt="cb" />';
						rwf_cb_logo_click += '</a>';
						$('rentabiliweb_form_content_pays_cb_logo').innerHTML = rwf_cb_logo_click;
						$('rentabiliweb_form_content_pays_cb').className = '';

						//					if(rwf_affiche_image_default==false && rwf_v_type_paiement==null){
						//						rwf_affiche_image(rwf_image,rwf_url_popup,rwf__reponses_ajax[rwf__types_paiement[rwf_fi]].nbr_codes,rwf_type_paiement);
						//						rwf_nbr_codes = rwf__reponses_ajax[rwf__types_paiement[rwf_fi]].nbr_codes;
						//						rwf_affiche_image_default = true;
						//					}else if(rwf_type_paiement==rwf_v_type_paiement && rwf_affiche_image_default==false){
						//						rwf_affiche_image(rwf_image,rwf_url_popup,rwf__reponses_ajax[rwf__types_paiement[rwf_fi]].nbr_codes,rwf_type_paiement);
						//						rwf_nbr_codes = rwf__reponses_ajax[rwf__types_paiement[rwf_fi]].nbr_codes;
						//						rwf_affiche_image_default = true;
						//					}
						if((rwf_affiche_image_default==false && rwf_v_type_paiement==null) || rwf_type_paiement==rwf_v_type_paiement){
							rwf_affiche_image(rwf_image,rwf_url_popup,rwf__reponses_ajax[rwf__types_paiement[rwf_fi]].nbr_codes,rwf_type_paiement);
							rwf_nbr_codes = rwf__reponses_ajax[rwf__types_paiement[rwf_fi]].nbr_codes;
							rwf_affiche_image_default = true;
						}
						rwf_affiche_cb=true;
						continue;
					}
					if(rwf_type_paiement=='paypal' && typeof(rwf__reponses_ajax['paypal']) == 'object' && (rwf__reponses_ajax['paypal'].images[0].libele_pays=='TOUS' || rwf__reponses_ajax['paypal'].images[0].libele_pays=='tous')){
						rwf_nbr_type_paiement++;
						rwf_html += '<a href="javascript:void(0);" onclick="rwf_affiche_image('+rwf_var_onclick+');" id="rentabiliweb_form_content_contact_type_'+rwf__types_paiement[rwf_fi]+'">&nbsp;&nbsp;';
						rwf_html += rwf_premiere_lettre_majuscule(rwf__reponses_ajax_lang.lang[rwf__types_paiement[rwf_fi]+'_libele'][rwf__default_language]);
						rwf_html += '</a><br /> ';
						rwf_html_img += rwf_retourne_image_balise(rwf__types_paiement[rwf_fi], rwf_var_onclick);

						if((rwf_affiche_image_default==false && rwf_v_type_paiement==null) || rwf_type_paiement==rwf_v_type_paiement){
							rwf_affiche_image(rwf_image,rwf_url_popup,rwf__reponses_ajax[rwf__types_paiement[rwf_fi]].nbr_codes,rwf_type_paiement);
							rwf_nbr_codes = rwf__reponses_ajax[rwf__types_paiement[rwf_fi]].nbr_codes;
							rwf_affiche_image_default = true;
						}
						rwf_affiche_paypal=true;
						continue;
					}
					if(rwf__reponses_ajax[rwf__types_paiement[rwf_fi]].images[rwf_j].code==rwf_pays){
						var libele = (rwf_type_paiement=='onnet') ? rwf__reponses_ajax_lang.lang[rwf__types_paiement[rwf_fi]+'_libele'][rwf__default_language] : rwf_premiere_lettre_majuscule(rwf__reponses_ajax_lang.lang[rwf__types_paiement[rwf_fi]+'_libele'][rwf__default_language]);
						rwf_nbr_type_paiement++;
						rwf_html += '<a href="javascript:void(0);" onclick="rwf_affiche_image('+rwf_var_onclick+');" id="rentabiliweb_form_content_contact_type_'+rwf__types_paiement[rwf_fi]+'">&nbsp;&nbsp;';
						rwf_html += libele;
						rwf_html += '</a>';
						rwf_html_img += rwf_retourne_image_balise(rwf__types_paiement[rwf_fi], rwf_var_onclick);
						if(rwf_affiche_image_default==false && rwf_v_type_paiement==null){
							rwf_affiche_image(rwf_image,rwf_url_popup,rwf__reponses_ajax[rwf__types_paiement[rwf_fi]].nbr_codes,rwf_type_paiement);
							rwf_nbr_codes = rwf__reponses_ajax[rwf__types_paiement[rwf_fi]].nbr_codes;
							rwf_affiche_image_default = true;
						}else if(rwf_type_paiement==rwf_v_type_paiement && rwf_affiche_image_default==false){
							rwf_affiche_image(rwf_image,rwf_url_popup,rwf__reponses_ajax[rwf__types_paiement[rwf_fi]].nbr_codes,rwf_type_paiement);
							rwf_nbr_codes = rwf__reponses_ajax[rwf__types_paiement[rwf_fi]].nbr_codes;
							rwf_affiche_image_default = true;
						}
						rwf_affiche_pays_flags = true;
						break;
					}
				}
			}
		}
		if(rwf_affiche_pays_flags==false || $('rentabiliweb_form_content_pays_drapeaux').innerHTML==''){
			$('rentabiliweb_form_content_pays_libele').hide();
		}
		if(rwf_html_cb!=''){
			rwf_html += rwf_html_cb;
		}

		if(rwf_affiche_image_default==false){
			// si le type de paiement fournis par le cookie n'existe plus dans ce formulaire.
			// on affiche les type de paiement du pays afficher par d�faut, c'est � dire le premier
			if(nbr_relance++<1){
				// on relance au maximum qu'une fois l'affichage des types de paiement
				rwf_affiche_types_paiement(rwf_code_pays_default);
			}
			return;
		}
		$('rentabiliweb_form_content_contact_type').innerHTML = rwf_html;
		rechercheNav=RegExp("MSIE [0-6].?[0-9]");
		if(!navigator.appVersion.match(rechercheNav))
		{
			$('rentabiliweb_form_content_contact_type_img').innerHTML = rwf_html_img;
		}else{
			// que dans le cas o� on est avec ie6 on rafraichie la source de l'image
			setTimeout("rwf_affiche_type_paiement_img('"+rwf_formate_quote(rwf_html_img)+"')",20);
		}

		// si on a� aucun type de paiement on n'affiche pas de champs de codes a entrer
		if(rwf_html!=''){
			rwf__nbr_codes_total = rwf_nbr_codes;
			//affiche_code(nbr_codes);
		}
		if(rwf_affiche_image_default == false){
			rwf_affiche_image(null);
		}

		if(1==2){
			$('rentabiliweb_form_content_contact_type_');
		}
		// permet de diminuer la taille du formulaire s'il y � pas tous les drapeaux
		if(rwf_pays_length<=12 && rwf_nbr_type_paiement<=3){
			$('rentabiliweb_form_content_contact_block').setStyle({height:'85px'});
			rechercheNav=RegExp("MSIE [0-7].?[0-9]");
			if(navigator.appVersion.match(rechercheNav)){
				var rwf_height_block = $('rentabiliweb_form_content_contact_block').getHeight();
				rwf_height_block = rwf_height_block-5;
				$('rentabiliweb_form_content_contact_block').setStyle({height:''+rwf_height_block+'px'});
			}
			$('rentabiliweb_form_content_pays').setStyle({height:'241px'});
		}else if(rwf_pays_length<=12 && rwf_nbr_type_paiement<=6){ // nombre de type de paiement
			//		$('rentabiliweb_form_content_contact_block').setStyle({height:'105px'});
			//		$('rentabiliweb_form_content_pays').setStyle({height:'261px'});
			$('rentabiliweb_form_content_contact_block').setStyle({height:'120px'});
			rechercheNav=RegExp("MSIE [0-7].?[0-9]");
			if(!navigator.appVersion.match(rechercheNav))
			{
				$('rentabiliweb_form_content_pays').setStyle({height:'276px'});
			}else{
				// IE
				$('rentabiliweb_form_content_pays').setStyle({height:'281px'});
				var rwf_width = $('rentabiliweb_form_content_pays').getWidth();
				if(rwf_width>136){
					$('rentabiliweb_form_content_pays').setStyle({width:'132px'});
					$('rentabiliweb_form_content_pays').setStyle({height:'276px'});
				}
			}
		}else{
			$('rentabiliweb_form_content_pays').setStyle({height:'316px'});
			rechercheNav=RegExp("MSIE [0-7].?[0-9]");
			if(!navigator.appVersion.match(rechercheNav))
			{
				$('rentabiliweb_form_content_contact_block').setStyle({height:'160px'});
			}else{
				// IE
				$('rentabiliweb_form_content_contact_block').setStyle({height:'155px'});
			}
		}
		rechercheNav=RegExp("MSIE [0-7].?[0-9]");
		if(navigator.appVersion.match(rechercheNav))
		{
			// IE
			var rwf_width = $('rentabiliweb_form_content_pays').getWidth();
			var rwf_height = $('rentabiliweb_form_content_pays').getHeight();
			rwf_height = rwf_height-10;
			$('rentabiliweb_form_content_pays').setStyle({height:''+rwf_height+'px'});
			if(rwf_width>136){
				$('rentabiliweb_form_content_pays').setStyle({width:'132px'});
			}
		}
		return;
	}

	function rwf_affiche_type_paiement_img(rwf_html_img){
		rwf_html_img = rwf_formate_quote_origine(rwf_html_img);
		$('rentabiliweb_form_content_contact_type_img').innerHTML = rwf_html_img;
	}

	// remplace les "'" par des "\'"
	function rwf_formate_quote(rwf_value) {
		var rwf_reg_quote = new RegExp("\'", "g");
		rwf_value = rwf_value.replace(rwf_reg_quote, "\\'");
		return rwf_value;
	}
	// remplace les "\'" par des "'"
	function rwf_formate_quote_origine(rwf_value) {
		var rwf_reg_quote = new RegExp("\\'", "g");
		return rwf_value.replace(rwf_reg_quote, "\'");
	}

	function rwf_affiche_popup(rwf_type_paiement, rwf_url){
		var rwf_left	= ((screen.width - 320) / 2);
		if(typeof(rwf__skin)=='undefined' || rwf__skin==''){
			_skin = 'blue2';
		}else{
			_skin = rwf__skin;
		}
		if(rwf_type_paiement=='cb'){
			window.open(rwf_url+'&skin='+_skin, "MicropaiementCB", "toolbar=0, location=0, directories=0, status=0, scrollbars=1, resizable=1, copyhistory=0, menuBar=0, width=300, height=365,left="+rwf_left+",top=40");
		}else if(rwf_type_paiement=='ticketsurf'){
			window.open(rwf_url+'&skin='+_skin, "MicropaiementTicketSurf", "toolbar=0, location=0, directories=0, status=0, scrollbars=1, resizable=1, copyhistory=0, menuBar=0, width=322, height=350,left="+rwf_left+",top=40");
		}else if(rwf_type_paiement=='paypal'){
			window.open(rwf_url+'&skin='+_skin, "MicropaiementPaypal", "toolbar=0, location=0, directories=0, status=0, scrollbars=1, resizable=1, copyhistory=0, menuBar=0, width=800, height=630,left="+rwf_left+",top=40");
		}else if(rwf_type_paiement=='internet'){
			window.open(rwf_url+'&skin='+_skin, "MicropaiementInternet", "toolbar=0, location=0, directories=0, status=0, scrollbars=0, resizable=0, copyhistory=0, menuBar=0, width=300, height=365,left="+rwf_left+",top=40");
		}else if(rwf_type_paiement=='neosurf'){
			window.open(rwf_url+'&skin='+_skin, "MicropaiementNeoSurf", "toolbar=0, location=0, directories=0, status=0, scrollbars=0, resizable=0, copyhistory=0, menuBar=0, width=330, height=444,left="+rwf_left+",top=40");
		}else if(rwf_type_paiement=='mistercash'){
			window.open(rwf_url+'&skin='+_skin, "MicropaiementMisterCash", "toolbar=0, location=0, directories=0, status=0, scrollbars=0, resizable=0, copyhistory=0, menuBar=0, width=590, height=508,left="+rwf_left+",top=40");
		}else if(rwf_type_paiement=='onnet'){
			window.open(rwf_url+'&skin='+_skin, "MicropaiementOnNET", "toolbar=0, location=0, directories=0, status=0, scrollbars=1, resizable=0, copyhistory=0, menuBar=0, width=590, height=746,left="+rwf_left+",top=40");
		}
		return;
	}

	// affiche la bonne image en fonction de la langue
	function rwf_image_url(rwf_type){
		return rwf__files_img+'form2007/'+rwf_type+'/imgs/'+rwf__lang_selected+'.png';
		//	return rwf__files+'i/form2007/'+rwf_type+'/imgs/'+rwf__lang_selected+'.png'; // obsolete
	}

	var id_image=0;
	function rwf_affiche_image(rwf_image, rwf_url, rwf_nbr_codes, rwf_type_paiement){
		$('rentabiliweb_form_bottom_erreur').hide();

		// dernier type de paiement selectionné, pour l'écriture dans le cookie si validation de code
		var rwf_tab_length = rwf__types_paiement.length;

		for(rwf_ai_i=0;rwf_ai_i<rwf_tab_length;rwf_ai_i++){
			if(rwf__types_paiement[rwf_ai_i]==rwf_image){
				rwf_image = rwf_image_url(rwf_image);
				break;
			}
		}
		rwf_init_form(rwf_nbr_codes);
		if(rwf_nbr_codes>0){
			rwf_affiche_code(rwf_nbr_codes);
		}
		rwf_type_paiement_selected = rwf_type_paiement;

		$('rentabiliweb_form_content_contact_code').innerHTML='';

		var rwf_popup = '';
		if(rwf_url!=''){
			rwf_popup = 'rwf_affiche_popup(\''+rwf_type_paiement+'\', \''+rwf_url+'\')';
		}
		$('rentabiliweb_form_content_contact_code').innerHTML = '<a href="javascript:void(0);" onclick="'+rwf_popup+'"><img id="rentabiliweb_form_content_contact_code_img_numbers" src="'+rwf_image+'" /> </a>';
		rechercheNav=RegExp("MSIE [0-6].?[0-9]");
		if(navigator.appVersion.match(rechercheNav))
		{
			// que dans le cas o� on est avec ie6 on rafraichie la source de l'image
			setTimeout('affiche_image("'+rwf_image+'")',10);
		}
		return;
	}

	function affiche_image(image){
		$('rentabiliweb_form_content_contact_code_img_numbers').src = image;
		return;
	}

	// permet d'initialiser les variables du formulaire
	function rwf_init_form(rwf_nbr_codes_total){
		rwf__code = 0;
		//_nbr_codes_reste_a_afficher = 0;
		rwf__nbr_codes_restant = 0;
		rwf__nbr_codes_total = rwf_nbr_codes_total;
		rwf__nbr_errors = 0;
		return;
	}

	var rwf__nbr_codes_reste_a_afficher = 0; // nombre de champs de code restant a afficher
	var rwf__nbr_codes_restant = 0; // nombre de code restant a valider
	var dernier_champs = false; // permet de savoir si on affiche le dernier champs
	function rwf_affiche_code(rwf_nbr_codes){
		rwf__nbr_codes_reste_a_afficher = rwf_nbr_codes;
		rwf__nbr_codes_restant = rwf_nbr_codes;
		// on enleve d'abord tous les champs present;
		$('id_rentabiliweb_form_bottom_label').innerHTML = '';
		$('id_rentabiliweb_form_bottom_input').innerHTML = '';
		var _rwf_un_seul_code = true;
		if(rwf__nbr_codes_reste_a_afficher>1){
			_rwf_un_seul_code = false;
		}
		for(i=0;i<rwf__nbr_codes_reste_a_afficher;i++){
			if((i+1)==rwf__nbr_codes_reste_a_afficher){
				dernier_champs = true;
			}
			rwf_ajouter_champs_code(_rwf_un_seul_code);
		}
		return;
	}
	var rwf__code=0; // numero du champs en cours d'affichage
	function rwf_ajouter_champs_code(rwf_un_seul_code){
		// recherche du noeud parent
		var rwf_divParent_label = $('id_rentabiliweb_form_bottom_label');
		var rwf_divParent_input = $('id_rentabiliweb_form_bottom_input');
		if(rwf__code==0){
			rwf_divParent_label.innerHTML = '';
			rwf_divParent_input.innerHTML = '';
		}

		// creation des nouveaux noeuds
		var rwf_nouveauInput_parent = document.createElement('div');
		var rwf_nouveauLabel_parent = document.createElement('div');
		rwf_nouveauInput_parent.className = 'class_rentabiliweb_form_bottom_champs_input_parent';
		rwf_nouveauLabel_parent.className = 'class_rentabiliweb_form_bottom_champs_input_parent';
		var rwf_nouveauInput = document.createElement('input');
		var rwf_nouveauLabel = document.createElement('label');

		// parametrage des nouveaux noeuds
		if(rwf_un_seul_code==false){
			rwf_nouveauLabel.appendChild(document.createTextNode("Code "+ ++rwf__code + ": "));
		}else{
			rwf_nouveauLabel.appendChild(document.createTextNode("Code : "));
			++rwf__code;
		}
		rwf_nouveauLabel.htmlFor = 'id_rentabiliweb_form_bottom_champs_'+ rwf__code;
		rwf_nouveauLabel.className='class_rentabiliweb_form_bottom_champs_label';

		rwf_nouveauInput.name = 'code'+ rwf__code;
		rwf_nouveauInput.id = 'id_rentabiliweb_form_bottom_champs_'+ rwf__code;
		rwf_nouveauInput.className = 'class_rentabiliweb_form_bottom_champs_input';
		rwf_nouveauInput.type = 'text';
		rwf_nouveauInput.setAttribute("onkeypress", "if(event.keyCode==13)rwf_send_codes();");

		// raccord des noeuds
		rwf_nouveauInput_parent.appendChild(rwf_nouveauLabel);
		rwf_nouveauLabel_parent.appendChild(rwf_nouveauInput);
		rwf_divParent_label.appendChild(rwf_nouveauInput_parent);
		rwf_divParent_input.appendChild(rwf_nouveauLabel_parent);
		return;
	}

	function rwf_verif_char(evenement){
		var touche = window.event ? evenement.keyCode : evenement.which;
		if(touche == 13){ // si on � appuy� sur la touche entr�e
			return true;
		}
		return false;
	}

	// fonction qui permet d'envoyer les codes au serveur et recupere la reponse
	// _code egale au numero du dernier champs afficher

	function rwf_object_to_get(rwf_otg_object){
		var rwf_string_get='';
		for(rwf_fff in rwf_otg_object){
			if(rwf_string_get!=''){
				rwf_string_get +='&';
			}
			rwf_string_get += rwf_fff+'='+rwf_otg_object[rwf_fff];
		}
		return rwf_string_get;
	}

	function rwf_verif_code_regexp(rwf_code) { // v?rif validit? email par REGEXP
		var rwf_reg = /^[a-zA-Z0-9]{8}$/ // 8 caract?res
		//	return (rwf_reg.exec(rwf_code)!=null); // return true ou false si valide ou non
		return true;
	}

	var rwf__nbr_errors = 0;
	var rwf_var_parameters = new Object; // recupere le contenu de tous les champs
	var rwf_submit_codes = false;
	function rwf_send_codes(){
		// init
		rwf_var_parameters = new Object;
		$('rentabiliweb_form_bottom_erreur').innerHTML='';
		// init end
		if(rwf_submit_codes==true){
			return;
		}
		rwf_submit_codes = true;
		setTimeout('rwf_submit_codes=false',2000); // 2 secondes de temps morts entre chaque validation de codes
		// on insere ces varaibles dans un cookie pour ramener le visiteur directement avec ces parametres la prochaine fois
		rwf_ecrire_cookie('rentabiliweb_formulaire','lang_selected='+rwf__lang_selected+';pays_selected='+rwf_pays_selected+';type_paiement_selected='+rwf_type_paiement_selected);
		rwf_add_input_id_in_url();
		// redirection par url pro ssp
		if(typeof(rwf__url_pro)!="undefined" && rwf__url_pro!=''){
			var rwf_codes='';
			for(i=1;i<=rwf__code;i++){
				if($('id_rentabiliweb_form_bottom_champs_'+ i).value==''){
					$('rentabiliweb_form_bottom_erreur').innerHTML = rwf_affiche_alert_code_vide();
					$('rentabiliweb_form_bottom_erreur').show();
					$('id_rentabiliweb_form_bottom_champs_'+ i).focus();
					return;
				}
				if(i>1){
					rwf_codes +='&';
				}
				rwf_codes += 'code['+i+']='+$('id_rentabiliweb_form_bottom_champs_'+ i).value;
			}
			rwf_codes+='&doc_id='+rwf__doc_id;
			rwf_codes+='&id='+rwf__doc_id;
			rwf_codes+='&pays='+rwf_pays_selected;
			//		var rwf_caractere_separation_url = '?';
			//		var rwf_verif_url_type = new RegExp("[\?]","g")
			//		if(rwf__url_pro.replace(rwf_verif_url_type,"\?")){
			//			rwf_caractere_separation_url = '&';
			//		}

			var rwf_caractere_separation_url = '?';
			var rwf_verif_url_type = new RegExp("[\?]","g")
			var tableau=rwf__url_pro.split(rwf_verif_url_type);
			if(typeof(tableau[1])!='undefined'){
				rwf_caractere_separation_url = '&';
			}
			if(typeof(rwf_same_frame)!='undefined' && rwf_same_frame==true){
				//			rwf_submit_codes = true;
				window.location.replace(rwf__url_pro+rwf_caractere_separation_url+rwf_codes+rwf__add_data);
			}else{
				//			rwf_submit_codes = true;
				parent.window.location.replace(rwf__url_pro+rwf_caractere_separation_url+rwf_codes+rwf__add_data);
			}

			return;
		}

		rwf_var_parameters['id_doc']=rwf__doc_id;
		rwf_var_parameters['act'] = 'json';
		rwf_var_parameters['code']='';
		rwf_var_parameters['pays']=rwf_pays_selected;
		for(i=1;i<=rwf__code;i++){
			if(rwf_verif_code_regexp($('id_rentabiliweb_form_bottom_champs_'+ i).value)==false){
				$('rentabiliweb_form_bottom_erreur').innerHTML = rwf_affiche_alert_code_vide();
				$('rentabiliweb_form_bottom_erreur').show();
				$('id_rentabiliweb_form_bottom_champs_'+ i).focus();
				return;
			}
			if(i>1){
				rwf_var_parameters['code'] +='-';
			}
			rwf_var_parameters['code'] += $('id_rentabiliweb_form_bottom_champs_'+ i).value;
		}
		_settimeout=true;
		//	rwf_submit_codes = true;
		rwf_add_script_tag(rwf__url_send_codes, rwf_object_to_get(rwf_var_parameters));
	}
	function rwf_get_reponse_send_codes(){
		if(!rwf__reponses_ajax_codes){
			alert('error');
			return;
		}
		//	rwf_submit_codes = false;
		if(rwf__reponses_ajax_codes.error==0 && rwf__reponses_ajax_codes.allow==1 && rwf__reponses_ajax_codes.url!=''){
			// si tout est OK
			if(typeof(rwf_same_frame)!='undefined' && rwf_same_frame==true){
				window.location.replace(rwf__reponses_ajax_codes.url);
			}else{
				//			parent.window.location.replace(rwf__reponses_ajax_codes.url);
				//			alert(rwf__reponses_ajax_codes.url);
				top.location= rwf__reponses_ajax_codes.url;
			}
			return;
		}else{
			for(i=0;i<rwf__nbr_codes_total;i++){
				rwf_iclass = i+1;
				if(rwf__reponses_ajax_codes.codes[i]){
					if(rwf__reponses_ajax_codes.codes[i].allow==false){
						$('id_rentabiliweb_form_bottom_champs_'+rwf_iclass).className = 'class_rentabiliweb_form_bottom_champs_input_error';
						rwf__nbr_errors++;
					}else{
						$('id_rentabiliweb_form_bottom_champs_'+rwf_iclass).className = 'class_rentabiliweb_form_bottom_champs_input';
					}
				}else{
					// c'est que l'internaute � d�j� donner ce meme code
					rwf__nbr_errors++;
				}
			}
		}
		if(rwf_error_redirection && rwf_error_redirection==true){
			// si le webmaster veux rediriger l'internaut vers une page d'erreur.
			parent.window.location.replace(rwf__reponses_ajax_codes.url);
			return;
		}
		if(rwf__nbr_errors>0){
			$('rentabiliweb_form_bottom_erreur').innerHTML = rwf_affiche_error_text();
			$('rentabiliweb_form_bottom_erreur').show();
			rwf__nbr_errors = 0; // on remets le nombres d'erreurs a� l'etat initial

		}
		return;
	}

	function rwf_ecrire_cookie(rwf_nom_variable, rwf_contenu_variable){
		rwf_date=new Date;
		// duree du cookie en nombre de jours
		var rwf_nbr_jours = 365;
		rwf_date.setDate(rwf_date.getDate()+rwf_nbr_jours);
		rwf_EcrireCookie(rwf_nom_variable, rwf_contenu_variable, rwf_date, "/");
	}

	function rwf_affiche_popup_support_technique(){
		var rwf_left = ((screen.width - 340) / 2);
		var rwf_lang='fr';
		if(rwf__lang_selected!='fr'){
			rwf_lang = 'en';
		}
		//	var rwf_url = ' http://www.rentabiliweb.com/component/ticket/form.php?lang='+rwf_lang;
		if(typeof(rwf__skin)=='undefined' || rwf__skin==''){
			_skin = 'blue2';
		}else{
			_skin = rwf__skin;
		}
		var rwf_url = 'http://www.rentabiliweb.com/component/ticket/form.php?page=form2&lang='+rwf_lang+'&skin='+_skin;

		//	window.open(rwf_url, "SupportTechnique", "toolbar=0, location=0, directories=0, status=0, scrollbars=1, resizable=1, copyhistory=0, menuBar=0, width=340, height=610,left="+rwf_left+",top=40");
		window.open(rwf_url, "SupportTechnique", "toolbar=0, location=0, directories=0, status=0, scrollbars=0, resizable=1, copyhistory=0, menuBar=0, width=600, height=610,left="+rwf_left+",top=40");
	}

	function rwf_affiche_error_text(){
		return rwf_error_code('rwf_error_code');
	}

	function rwf_affiche_alert_code_vide(){
		return rwf_code_vide('rwf_code_vide');
	}

	// permet d'ajouter des parametres a transmettre dans l'url
	var rwf__add_data='';
	function rwf_add_data(rwf_key,rwf_value){
		rwf__add_data+='&'+rwf_key+'='+rwf_value;
	}
	// récupere le nom des id fournis
	var rwf_input_id_obj = new Object();
	var rwf_nbr_input_id_obj = 0;
	function rwf_add_input_id(rwf_id){
		rwf_input_id_obj[++rwf_nbr_input_id_obj] = rwf_id;
	}
	// récupere les valeurs des id
	function rwf_add_input_id_in_url(){
		for(rwf_key in rwf_input_id_obj){
			var rwf_key_value = rwf_input_id_obj[rwf_key];
			if($(rwf_key_value).type=='radio' && $(rwf_key_value).checked==false){
				continue;
			}else if($(rwf_key_value).type=='radio' && $(rwf_key_value).checked==true && $(rwf_key_value).name){
				rwf__add_data+='&'+$(rwf_key_value).name+'='+$(rwf_key_value).value;
				continue;
			}
			if($(rwf_key_value)){
				rwf__add_data+='&'+rwf_key_value+'='+$(rwf_key_value).value;
			}
		}
	}

} // tout début de fichier