jQuery(document).ready(function() {
	var panneau = jQuery("#bottom_panel_menu").html();
	jQuery("#bottom_panel_menu").html(" ");
	jQuery("#upper_panel_menu").html(panneau);

	jQuery("#onglet_search").click(function() {
		$("#signin_menu").slideUp("normal");
		$("#account_menu").slideUp("normal");
		$("#language_menu").slideUp("normal");
		$("#searchfind_menu").slideToggle("normal");
	});

	jQuery("#onglet_signin").click(function() {
		$("#searchfind_menu").slideUp("normal");
		$("#language_menu").slideUp("normal");
		$("#signin_menu").slideToggle("normal");
	});

	jQuery("#onglet_account").click(function() {
		$("#searchfind_menu").slideUp("normal");
		$("#language_menu").slideUp("normal");
		$("#account_menu").slideToggle("normal");
	});

	jQuery("#onglet_language").click(function() {
		$("#searchfind_menu").slideUp("normal");
		$("#signin_menu").slideUp("normal");
		$("#account_menu").slideUp("normal");
		$("#language_menu").slideToggle("normal");
	});

	jQuery("#qwr").attr("autocomplete", "off");

	jQuery("#qwr").autocomplete(
		"/search/suggest/",
		{
			delay:10,
			minChars:4,
			matchSubset:1,
			matchContains:1,
			pathQuery:true,
			maxItemsToShow:10,
			cacheLength:10,
			autoFill:false
		}
	);

	jQuery("#form_search").submit(
		function() {
			var qwr = noaccent(jQuery("#qwr").val()).toLowerCase();
			var url = jQuery(this).attr("action");

			if(qwr.length > 0)
			{
				qwr = qwr.replace(/[ ]/g, "-");
				url += qwr + "/";
				document.location = url;
			}
			return(false);
	});

	jQuery("#upsearch").click(
		function() {
			jQuery("#form_search").submit();
		}
	);
});

// ====================================================================
//       URLEncode and URLDecode functions
//
// Copyright Albion Research Ltd. 2002
// http://www.albionresearch.com/
//
// You may copy these functions providing that
// (a) you leave this copyright notice intact, and
// (b) if you use these functions on a publicly accessible
//     web site you include a credit somewhere on the web site
//     with a link back to http://www.albionresearch.com/
//
// If you find or fix any bugs, please let us know at albionresearch.com
//
// SpecialThanks to Neelesh Thakur for being the first to
// report a bug in URLDecode() - now fixed 2003-02-19.
// And thanks to everyone else who has provided comments and suggestions.
// ====================================================================
function arURLEncode(plaintext)
{
	// The Javascript escape and unescape functions do not correspond
	// with what browsers actually do...
	var SAFECHARS = "0123456789" +					// Numeric
					"ABCDEFGHIJKLMNOPQRSTUVWXYZ" +	// Alphabetic
					"abcdefghijklmnopqrstuvwxyz" +
					"-_.!~*'()";					// RFC2396 Mark characters
	var HEX = "0123456789ABCDEF";
	var encoded = "";
	for (var i = 0; i < plaintext.length; i++ ) {
		var ch = plaintext.charAt(i);
	    if (ch == " ") {
		    encoded += "+";				// x-www-urlencoded, rather than %20
		} else if (SAFECHARS.indexOf(ch) != -1) {
		    encoded += ch;
		} else {
		    var charCode = ch.charCodeAt(0);
			if (charCode > 255) {
			    alert( "Unicode Character '"
                        + ch
                        + "' cannot be encoded using standard URL encoding.\n" +
				          "(URL encoding only supports 8-bit characters.)\n" +
						  "A space (+) will be substituted." );
				encoded += "+";
			} else {
				encoded += "%";
				encoded += HEX.charAt((charCode >> 4) & 0xF);
				encoded += HEX.charAt(charCode & 0xF);
			}
		}
	} // for

	return(encoded);
};

function arURLDecode(encoded)
{
   // Replace + with ' '
   // Replace %xx with equivalent character
   // Put [ERROR] in output if %xx is invalid.
   var HEXCHARS = "0123456789ABCDEFabcdef";
   var plaintext = "";
   var i = 0;
   while (i < encoded.length) {
       var ch = encoded.charAt(i);
	   if (ch == "+") {
	       plaintext += " ";
		   i++;
	   } else if (ch == "%") {
			if (i < (encoded.length-2)
					&& HEXCHARS.indexOf(encoded.charAt(i+1)) != -1
					&& HEXCHARS.indexOf(encoded.charAt(i+2)) != -1 ) {
				plaintext += unescape( encoded.substr(i,3) );
				i += 3;
			} else {
				alert( 'Bad escape combination near ...' + encoded.substr(i) );
				plaintext += "%[ERROR]";
				i++;
			}
		} else {
		   plaintext += ch;
		   i++;
		}
	} // while

   return(plaintext);
};

function myURLEncode(chaine)
{
	var encoded = escape(chaine);
	encoded = encoded.replace("+", "%2B");
	encoded = encoded.replace("/", "%2F");

	return(encoded);
}

function myURLEncode(encoded)
{
	var chaine = unescape(encoded);

	return(chaine);
}

function noaccent(chaine)
{
  temp = chaine.replace(/[àâä]/gi, "a");
  temp = temp.replace(/[éèêë]/gi, "e");
  temp = temp.replace(/[îï]/gi, "i");
  temp = temp.replace(/[ôö]/gi, "o");
  temp = temp.replace(/[ùûü]/gi, "u");
  temp = temp.replace(/[']/gi, " ");

  return temp;
}

// From: http://nerds-central.blogspot.com/2007/01/javascript-hash-tables-why-and-how.html
function Hash()
{
    var _hash=new Array();
    var _keys=new Array();
    var _count=0;

    this.keys=function()
    {
        var ret=new Array();
        var l=_count;
        for(var i=0;i<l;++i)
        {
            ret.push(_keys[i]);
        }
        return ret;
    }

    this.values=function()
    {
        var ret=new Array();
        var l=_count;
        for(var i=0;i<l;++i)
        {
            var k=_keys[i];
            ret.push(_hash[_keys[i]]);
        }
        return ret;
    }

    this.add=function(key,value)
    {
        if(typeof(_hash[key])==='undefined')
        {
            _keys.push(key);
            _count++;
        }
        _hash[key]=value;
    }

    this.getItem=function(key)
    {
        return _hash[key];
    }

    this.setItem=function(key,value)
    {
        _hash[key]=value;
    }

    this.exists=function(key)
    {
        return typeof(_hash[key])!='undefined';
    }

    this.removeAll=function()
    {
        _hash=new Array();
        _keys=new Array();
        _count=0;
    }

    this.count=function()
    {
        return _count;
    }

    // very slow for now
    this.remove=function(key)
    {
        var newHash=new Array();
        var newKeys=new Array();
        var l=_keys.length;
        _count=0;
        for(var i=0;i<l;++i)
        {
            var ik=keys[i];
            if(ik!=key)
            {
                newKeys.push(ik);
                newHash[ik]=_hash[ik];
                _count++;
            }
        }
        _hash=newHash;
        _keys=newKeys;
    }
}

// http://kevin.vanzonneveld.net
// +   original by: Arpad Ray (mailto:arpad@php.net)
// *     example 1: serialize(['Kevin', 'van', 'Zonneveld']);
// *     returns 1: 'a:3:{i:0;s:5:"Kevin";i:1;s:3:"van";i:2;s:9:"Zonneveld";}'
function serialize( inp )
{
    var getType = function( inp ) {
        var type = typeof inp, match;
        if(type == 'object' && !inp)
        {
            return 'null';
        }
        if (type == "object") {
            if(!inp.constructor)
            {
                return 'object';
            }
            var cons = inp.constructor.toString();
            if (match = cons.match(/(\w+)\(/)) {
                cons = match[1].toLowerCase();
            }
            var types = ["boolean", "number", "string", "array"];
            for (key in types) {
                if (cons == types[key]) {
                    type = types[key];
                    break;
                }
            }
        }
        return type;
    };

    var type = getType(inp);
    var val;
    switch (type) {
        case "undefined":
            val = "N";
            break;
        case "boolean":
            val = "b:" + (inp ? "1" : "0");
            break;
        case "number":
            val = (Math.round(inp) == inp ? "i" : "d") + ":" + inp;
            break;
        case "string":
            val = "s:" + inp.length + ":\"" + inp + "\"";
            break;
        case "array":
            val = "a";
        case "object":
            if (type == "object") {
                var objname = inp.constructor.toString().match(/(\w+)\(\)/);
                if (objname == undefined) {
                    return;
                }
                objname[1] = serialize(objname[1]);
                val = "O" + objname[1].substring(1, objname[1].length - 1);
            }
            var count = 0;
            var vals = "";
            var okey;
            for (key in inp) {
                okey = (key.match(/^[0-9]+$/) ? parseInt(key) : key);
                vals += serialize(okey) +
                        serialize(inp[key]);
                count++;
            }
            val += ":" + count + ":{" + vals + "}";
            break;
    }
    if (type != "object" && type != "array") val += ";";
    return val;
}

// http://kevin.vanzonneveld.net
// +   original by: Arpad Ray (mailto:arpad@php.net)
// +   improved by: Pedro Tainha (http://www.pedrotainha.com)
// +   bugfixed by: dptr1988
// *     example 1: unserialize('a:3:{i:0;s:5:"Kevin";i:1;s:3:"van";i:2;s:9:"Zonneveld";}');
// *     returns 1: ['Kevin', 'van', 'Zonneveld']
function unserialize ( inp )
{
    error = 0;
    if (inp == "" || inp.length < 2) {
        errormsg = "input is too short";
        return;
    }
    var val, kret, vret, cval;
    var type = inp.charAt(0);
    var cont = inp.substring(2);
    var size = 0, divpos = 0, endcont = 0, rest = "", next = "";

    switch (type) {
    case "N": // null
        if (inp.charAt(1) != ";") {
            errormsg = "missing ; for null";
        }
        // leave val undefined
        rest = cont;
        break;
    case "b": // boolean
        if (!/[01];/.test(cont.substring(0,2))) {
            errormsg = "value not 0 or 1, or missing ; for boolean";
        }
        val = (cont.charAt(0) == "1");
        rest = cont.substring(2);  //changed...
        break;
    case "s": // string
        val = "";
        divpos = cont.indexOf(":");
        if (divpos == -1) {
            errormsg = "missing : for string";
            break;
        }
        size = parseInt(cont.substring(0, divpos));
        if (size == 0) {
            if (cont.length - divpos < 4) {
                errormsg = "string is too short";
                break;
            }
            rest = cont.substring(divpos + 4);
            break;
        }
        if ((cont.length - divpos - size) < 4) {
            errormsg = "string is too short";
            break;
        }
        if (cont.substring(divpos + 2 + size, divpos + 4 + size) != "\";") {
            errormsg = "string is too long, or missing \";";
        }
        val = cont.substring(divpos + 2, divpos + 2 + size);
        rest = cont.substring(divpos + 4 + size);
        break;
    case "i": // integer
    case "d": // float
        var dotfound = 0;
        for (var i = 0; i < cont.length; i++) {
            cval = cont.charAt(i);
            if (isNaN(parseInt(cval)) && !(type == "d" && cval == "." && !dotfound++)) {
                endcont = i;
                break;
            }
        }
        if (!endcont || cont.charAt(endcont) != ";") {
            errormsg = "missing or invalid value, or missing ; for int/float";
        }
        val = cont.substring(0, endcont);
        val = (type == "i" ? parseInt(val) : parseFloat(val));
        rest = cont.substring(endcont + 1);
        break;
    case "a": // array
        if (cont.length < 4) {
            errormsg = "array is too short";
            return;
        }
        divpos = cont.indexOf(":", 1);
        if (divpos == -1) {
            errormsg = "missing : for array";
            return;
        }
        size = parseInt(cont.substring(1*divpos, 0));  //changed...
        cont = cont.substring(divpos + 2);
        val = new Array();
        if (cont.length < 1) {
            errormsg = "array is too short";
            return;
        }
        for (var i = 0; i + 1 < size * 2; i += 2) {
            kret = unserialize(cont, 1);
            if (error || kret[0] == undefined || kret[1] == "") {
                errormsg = "missing or invalid key, or missing value for array";
                return;
            }
            vret = unserialize(kret[1], 1);
            if (error) {
                errormsg = "invalid value for array";
                return;
            }
            val[kret[0]] = vret[0];
            cont = vret[1];
        }
        if (cont.charAt(0) != "}") {
            errormsg = "missing ending }, or too many values for array";
            return;
        }
        rest = cont.substring(1);
        break;
    case "O": // object
        divpos = cont.indexOf(":");
        if (divpos == -1) {
            errormsg = "missing : for object";
            return;
        }
        size = parseInt(cont.substring(0, divpos));
        var objname = cont.substring(divpos + 2, divpos + 2 + size);
        if (cont.substring(divpos + 2 + size, divpos + 4 + size) != "\":") {
            errormsg = "object name is too long, or missing \":";
            return;
        }
        var objprops = unserialize("a:" + cont.substring(divpos + 4 + size), 1);
        if (error) {
            errormsg = "invalid object properties";
            return;
        }
        rest = objprops[1];
        var objout = "function " + objname + "(){";
        for (key in objprops[0]) {
            objout += "this['" + key + "']=objprops[0]['" + key + "'];";
        }
        objout += "}val=new " + objname + "();";
        eval(objout);
        break;
    default:
        errormsg = "invalid input type";
    }
    return (arguments.length == 1 ? val : [val, rest]);
}

function get_comment_resultat( contenu )
{
	var pos1 = contenu.indexOf("<!-- ");
	var pos2 = contenu.indexOf(" -->");
	var chaine = "";

	if(pos1 >= 0 && pos2 >= 0)
	{
		chaine = contenu.substring(pos1, pos2+3+1);
		chaine = chaine.replace("<!-- ", "");
		chaine = chaine.replace(" -->", "");
	}
	return( chaine );
}