1 _changeIds = function(elt, suffix) {

     2 	if (elt.id)

     3 		elt.id =  elt.id + suffix ;

     4 	var c = elt.firstChild ;

     5 	while (c != null) {

     6 		_changeIds(c, suffix) ;

     7 		c = c.nextSibling ; 

     8 	}

     9 } ;

    10 

    11 suffix = 0 ;

    12 domDuplicate = function(elt) {

    13 	var newElt = elt.cloneNode(true) ;

    14 	suffix++ ;

    15 	_changeIds(newElt, '-'+suffix) ;

    16 	return newElt ;

    17 } ;

    18 

    19 getDuplicated = function(elt) {

    20 	return document.getElementById(elt.id + '-' + suffix) ;

    21 } ;

    22 

    23 logSel = function(selection) {

    24 	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']) ;

    25 } ;

    26 

    27 log = function (msg) {

    28 	var log = document.getElementById("log") ;

    29 	log.innerHTML = log.innerHTML + "<li>" + msg + "</li>" ; 

    30 } ;

    31 

    32 // from ext

    33 urlEncode = function(o){

    34     if(!o){

    35         return "";

    36     }

    37     var buf = [];

    38     for(var key in o){

    39         var ov = o[key], k = encodeURIComponent(key);

    40         var type = typeof ov;

    41         if(type == 'undefined'){

    42             buf.push(k, "=&");

    43         }else if(type != "function" && type != "object"){

    44             buf.push(k, "=", encodeURIComponent(ov), "&");

    45         }else if(CY.Lang.isArray(ov)){

    46             if (ov.length) {

    47                 for(var i = 0, len = ov.length; i < len; i++) {

    48                     buf.push(k, "=", encodeURIComponent(ov[i] === undefined ? '' : ov[i]), "&");

    49                 }

    50             } else {

    51                 buf.push(k, "=&");

    52             }

    53         }

    54     }

    55     buf.pop();

    56     return buf.join("");

    57 };

    58 

    59 //from ext

    60 /**

    61  * 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]}.

    62  * @param {String} string

    63  * @param {Boolean} overwrite (optional) Items of the same name will overwrite previous values instead of creating an an array (Defaults to false).

    64  * @return {Object} A literal with members

    65  */

    66 urlDecode = function(string, overwrite){

    67     if(!string || !string.length){

    68         return {};

    69     }

    70     var obj = {};

    71     var pairs = string.split('&');

    72     var pair, name, value;

    73     for(var i = 0, len = pairs.length; i < len; i++){

    74         pair = pairs[i].split('=');

    75         name = decodeURIComponent(pair[0]);

    76         value = decodeURIComponent(pair[1]);

    77         if(overwrite !== true){

    78             if(typeof obj[name] == "undefined"){

    79                 obj[name] = value;

    80             }else if(typeof obj[name] == "string"){

    81                 obj[name] = [obj[name]];

    82                 obj[name].push(value);

    83             }else{

    84                 obj[name].push(value);

    85             }

    86         }else{

    87             obj[name] = value;

    88         }

    89     }

    90     return obj;

    91 };

    92 

    93 

    94 areSortedArraysEqual = function (a1, a2) {

    95 	if (a1.length != a2.length) 

    96 		return false ;

    97 	for (var i = 0, ilen = a1.length ; i < ilen ; i++) {

    98 		if (a1[i] != a2[i])

    99 			return false ;

   100 	}

   101 	return true

   102 } ;

   103 

   104 // in place ordering!

   105 quicksort = function (vec) {

   106 	_quicksort(vec, 0, vec.length-1) ;

   107 };

   108 

   109 // cf. http://www.4guysfromrolla.com/webtech/012799-1.shtml

   110 _quicksort = function (vec, loBound, hiBound)

   111 /**************************************************************

   112 	This function adapted from the algorithm given in:

   113 		Data Abstractions & Structures Using C++, by

   114 		Mark Headington and David Riley, pg. 586.

   115 

   116 	quicksort is the fastest array sorting routine for

   117 	unordered arrays.  Its big O is n log n.

   118  **************************************************************/

   119 {

   120 

   121 	var pivot, loSwap, hiSwap, temp;

   122 

   123 	// Two items to sort

   124 	if (hiBound - loBound == 1)

   125 	{

   126 		if (vec[loBound] > vec[hiBound])

   127 		{

   128 			temp = vec[loBound];

   129 			vec[loBound] = vec[hiBound];

   130 			vec[hiBound] = temp;

   131 		}

   132 		return;

   133 	}

   134 

   135 	// Three or more items to sort

   136 	pivot = vec[parseInt((loBound + hiBound) / 2)];

   137 	vec[parseInt((loBound + hiBound) / 2)] = vec[loBound];

   138 	vec[loBound] = pivot;

   139 	loSwap = loBound + 1;

   140 	hiSwap = hiBound;

   141 

   142 	do {

   143 		// Find the right loSwap

   144 		while (loSwap <= hiSwap && vec[loSwap] <= pivot)

   145 			loSwap++;

   146 

   147 		// Find the right hiSwap

   148 		while (vec[hiSwap] > pivot)

   149 			hiSwap--;

   150 

   151 		// Swap values if loSwap is less than hiSwap

   152 		if (loSwap < hiSwap)

   153 		{

   154 			temp = vec[loSwap];

   155 			vec[loSwap] = vec[hiSwap];

   156 			vec[hiSwap] = temp;

   157 		}

   158 	} while (loSwap < hiSwap);

   159 

   160 	vec[loBound] = vec[hiSwap];

   161 	vec[hiSwap] = pivot;

   162 

   163 

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

   165 

   166 	// 2 or more items in first section		

   167 	if (loBound < hiSwap - 1)

   168 		_quicksort(vec, loBound, hiSwap - 1);

   169 

   170 

   171 	// 2 or more items in second section

   172 	if (hiSwap + 1 < hiBound)

   173 		_quicksort(vec, hiSwap + 1, hiBound);

   174 } ;