_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);

} ;