_changeIds = function(elt, suffix) {
	if (elt.id)
		elt.id =  elt.id + suffix ;
	var c = elt.firstChild ;
	while (c != null) {
		_changeIds(c, suffix) ;
		c = c.nextSibling ; 
	}
} ;

suffix = 0 ;
domDuplicate = function(elt) {
	var newElt = elt.cloneNode(true) ;
	suffix++ ;
	_changeIds(newElt, '-'+suffix) ;
	return newElt ;
} ;

getDuplicated = function(elt) {
	return document.getElementById(elt.id + '-' + suffix) ;
} ;

logSel = function(selection) {
	log('text :' + selection['text'] + ', start id : ' + selection['start']['elt'].id + ' , start offset : ' + selection['start']['offset'] + ' , end id : ' + selection['end']['elt'].id + 'end offset : ' + selection['end']['offset']) ;
} ;

log = function (msg) {
	var log = document.getElementById("log") ;
	log.innerHTML = log.innerHTML + "<li>" + msg + "</li>" ; 
} ;

// from ext
urlEncode = function(o){
    if(!o){
        return "";
    }
    var buf = [];
    for(var key in o){
        var ov = o[key], k = encodeURIComponent(key);
        var type = typeof ov;
        if(type == 'undefined'){
            buf.push(k, "=&");
        }else if(type != "function" && type != "object"){
            buf.push(k, "=", encodeURIComponent(ov), "&");
        }else if(CY.Lang.isArray(ov)){
            if (ov.length) {
                for(var i = 0, len = ov.length; i < len; i++) {
                    buf.push(k, "=", encodeURIComponent(ov[i] === undefined ? '' : ov[i]), "&");
                }
            } else {
                buf.push(k, "=&");
            }
        }
    }
    buf.pop();
    return buf.join("");
};

//from ext
/**
 * Takes an encoded URL and and converts it to an object. e.g. Ext.urlDecode("foo=1&bar=2"); would return {foo: 1, bar: 2} or Ext.urlDecode("foo=1&bar=2&bar=3&bar=4", true); would return {foo: 1, bar: [2, 3, 4]}.
 * @param {String} string
 * @param {Boolean} overwrite (optional) Items of the same name will overwrite previous values instead of creating an an array (Defaults to false).
 * @return {Object} A literal with members
 */
urlDecode = function(string, overwrite){
    if(!string || !string.length){
        return {};
    }
    var obj = {};
    var pairs = string.split('&');
    var pair, name, value;
    for(var i = 0, len = pairs.length; i < len; i++){
        pair = pairs[i].split('=');
        name = decodeURIComponent(pair[0]);
        value = decodeURIComponent(pair[1]);
        if(overwrite !== true){
            if(typeof obj[name] == "undefined"){
                obj[name] = value;
            }else if(typeof obj[name] == "string"){
                obj[name] = [obj[name]];
                obj[name].push(value);
            }else{
                obj[name].push(value);
            }
        }else{
            obj[name] = value;
        }
    }
    return obj;
};


areSortedArraysEqual = function (a1, a2) {
	if (a1.length != a2.length) 
		return false ;
	for (var i = 0, ilen = a1.length ; i < ilen ; i++) {
		if (a1[i] != a2[i])
			return false ;
	}
	return true
} ;

// in place ordering!
quicksort = function (vec) {
	_quicksort(vec, 0, vec.length-1) ;
};

// cf. http://www.4guysfromrolla.com/webtech/012799-1.shtml
_quicksort = function (vec, loBound, hiBound)
/**************************************************************
	This function adapted from the algorithm given in:
		Data Abstractions & Structures Using C++, by
		Mark Headington and David Riley, pg. 586.

	quicksort is the fastest array sorting routine for
	unordered arrays.  Its big O is n log n.
 **************************************************************/
{

	var pivot, loSwap, hiSwap, temp;

	// Two items to sort
	if (hiBound - loBound == 1)
	{
		if (vec[loBound] > vec[hiBound])
		{
			temp = vec[loBound];
			vec[loBound] = vec[hiBound];
			vec[hiBound] = temp;
		}
		return;
	}

	// Three or more items to sort
	pivot = vec[parseInt((loBound + hiBound) / 2)];
	vec[parseInt((loBound + hiBound) / 2)] = vec[loBound];
	vec[loBound] = pivot;
	loSwap = loBound + 1;
	hiSwap = hiBound;

	do {
		// Find the right loSwap
		while (loSwap <= hiSwap && vec[loSwap] <= pivot)
			loSwap++;

		// Find the right hiSwap
		while (vec[hiSwap] > pivot)
			hiSwap--;

		// Swap values if loSwap is less than hiSwap
		if (loSwap < hiSwap)
		{
			temp = vec[loSwap];
			vec[loSwap] = vec[hiSwap];
			vec[hiSwap] = temp;
		}
	} while (loSwap < hiSwap);

	vec[loBound] = vec[hiSwap];
	vec[hiSwap] = pivot;


	// Recursively call function...  the beauty of quicksort

	// 2 or more items in first section		
	if (loBound < hiSwap - 1)
		_quicksort(vec, loBound, hiSwap - 1);


	// 2 or more items in second section
	if (hiSwap + 1 < hiBound)
		_quicksort(vec, hiSwap + 1, hiBound);
} ;
