///////////// BASE AND PRIMITIVE CLASSES\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\

function Class(){ 
  return function(args){ 
    if ( this instanceof arguments.callee ) {
      if ( typeof this.construct == "function" )
	     if(args.callee)
              this.construct.apply( this, args);
	     else 	
		      this.construct.apply( this, arguments);
    }
	else
	{ 	
        return  new arguments.callee( arguments );           
	}
  }
};  
Engine=new Class();
RegExpr=new Class();
Strings=new Class();
Numbers=new Class();


////////////////////////////////////ENGINE CLASS \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
Engine.prototype.construct=function()
{
	this.isDOM = (document.getElementById ? true : false);
    this.isIE4 = ((document.all && !this.isDOM) ? true : false);
this.isNS4 = (document.layers ? true : false);
this.end_flag=0,this.form_length=0,this.form_submit=0,this.form,compute_index=0,this.fifo=new Array(),this.backbone=new Array(),this.computeObj=new Object();
this.pause_flipper=0,this.start_flipper=0,this.flipped_object,this.option,add_index=1;
this.form_elements=new Array("INPUT","TEXTAREA","SELECT","CHECKBOX"),this.buttons=new Object(),this.button_index=0;                             // elements from form, for AI
this.form_buttons=new Array("button","image","submit");
this.alerter_default="You have to enter a: ";
this.flip_index=0,this.max_flip_index=10,this.input_init_color="";                                                                   // how many times the eror field should flip colors
this.flip_color_even='#ff9933',this.flip_color_odd='#ffffff',this.flip_color_rest='#fff00f';                                          //the alternated colors of the error flipper
this.flip_border_even='#000000',this.flip_border_odd='#000000',this.flip_border_rest='';
this.hash_table=new Array(),this.form_elements_id=new Array();
this.color="#ff00f1";  
this.dragObject,this.mouse_update_flag=0,this.drag_interval_id,this.drag_flag=0,this.drag_started=0,this.XY={},this.dragArray=new Array(),this.resizeArray=new Array();
this.cursors = new Array(
	'default',
	'crosshair',
	'e-resize',
	'hand',
	'help',
	'move',
	'n-resize',
	'ne-resize',
	'nw-resize',
	's-resize',
	'se-resize',
	'sw-resize',
	'text',
	'w-resize',
	'wait'
); 
this.node_types = new Array(  
     "FAKE NODE", // fix array offset  
     "ELEMENT NODE",  
     "ATTRIBUTE NODE",  
     "TEXT NODE",  
     "CDATA SECTION NODE",  
     "ENTITY REFERENCE NODE",  
     "ENTITY NODE",  
     "PROCESSING INSTRUCTION NODE",  
     "COMMENT NODE",  
     "DOCUMENT NODE",  
     "DOCUMENT TYPE NODE",  
     "DOCUMENT FRAGMENT NODE",  
     "NOTATION NODE"  
 );  
	}


Engine.prototype.updateMouse=function(e)
 { 
	if(!e) var e=window.event;
	  XY=pos.getMouse(e); 
	 
	 }
Engine.prototype.getIndex=function(arr,el)
{
	for(var j=0;j<=arr.length-1;j++)
	 {
		 if(arr[j]==el){ 
		  return j;
	    	 }
		 }
	}
Engine.prototype.compactare=function(arr,index,meth,element)
{ 
   if(meth==null) meth="out";
  if(meth=="out"){
	if(index!=null)  { 
	for(var j=index;j<=arr.length-1;j++)
	{ 
		arr[j]=arr[j+1];
		}
		arr.length=arr.length-1;
  }//else alert("ERROR: unsupported index for compactare()");
  }
  else
  {
	  	for(var j=0;j<=arr.length-1;j++)
	   { 
		   if(j==index){
		    var temp=arr[j];
	    	arr[j]=element; 
	         index++;
			 element=temp;
		   }

		}

	  }
	return arr;
	}
Engine.prototype.DragON=function()
{   
  
       if(dragObject!=null && drag_flag==1)
	      { 	
		  if(XY.x!=undefined){
		    var x_rel=XY.x-pos.offsetX;
	        var y_rel=XY.y-pos.offsetY;
			pos.move(dragObject,x_rel,y_rel);
		  }
			}

	}
Engine.prototype.ResizeON=function()
{   
  var coord={},zone=0;
       if(resObject!=null && res_flag==1)
	      { 
		  if(XY.x!=undefined){
		  resize_handler.obj=resObject;	  
		  coord=dom.getMargins(resObject); 
		 
		  if(XY.x==coord.left){ 
		     zone=1;
		   	 document.body.style.cursor=cursors[13];
		  }
		  else if(XY.x==coord.right){ 
		     zone=1;
		   	 document.body.style.cursor=cursors[2];
		  }
		  else if(XY.y==coord.top){ 
		     zone=1;
		   	 document.body.style.cursor=cursors[6];
		  }
		  else if(XY.y==coord.bottom){ 
		     zone=1;
		   	 document.body.style.cursor=cursors[6];
		  }
		  else if(XY.x==coord.left && XY.y==coord.top){ 
		     zone=1;
		   	 document.body.style.cursor=cursors[8];
		  }
		  else if(XY.x==coord.left && XY.y==coord.bottom){ 
		     zone=1;
		   	 document.body.style.cursor=cursors[8];
		  }
		   else if(XY.x==coord.right && XY.y==coord.bottom){ 
		     zone=1;
		   	 document.body.style.cursor=cursors[8];
		  }
		   else if(XY.x==coord.right && XY.y==coord.top){ 
		     zone=1;
		   	 document.body.style.cursor=cursors[8];
		  }
		  else
		      { 
		       zone=0;
			   document.body.style.cursor=cursors[0];
			  }
		  }
         if(zone==1)
		  { 
	  	 observer.activate("onmousedown",resObject,"",'',resize_handler.startResize);
		   }
		 else
		  {
			 if(contains(observer.active_observers,"onmousedown"+resObject))
		        observer.activate("kill_onmousedown",resObject,"",'',resize_handler.startResize);
		 }
		  
			}

	}	
Engine.prototype.addCSS=function(obj,rule,value)
{
	 switch(rule)
	  {
		  case "innerHTML": obj.innerHTML=value; break;
		  case "position": obj.style.position=value; break;
		  case "top": obj.style.top=value+"px"; break;
		  case "left": obj.style.left=value+"px"; break;
		  case "border": obj.style.border=value; break;
		  case "color": obj.style.color=value; break;
		  case "backgroudColor": obj.style.backgroudColor=value; break;
		  case "src": obj.src=value; break;
		  case "href": obj.href=value; break;
		  case "className": obj.className=value; break;
		  case "id": obj.id=value; break;
	  }
	  return obj;
	}


Engine.prototype.getIt=function(id) {  
	if (this.isDOM) return document.getElementById(id);
	if (this.isIE4) return document.all[id];
	if (this.isNS4) return document.layers[id];
}
Engine.prototype.getIByClass=function(classname,node)
 {   
      if(!node) node = document.getElementsByTagName("body")[0];
      var a = [];
      var els = node.getElementsByTagName("*");
         for(var i=0;i<=els.length-1;  i++)
           if(els[i].className==classname && els[i].className!=null){a.push(els[i]);}
          return a;
		}
Engine.prototype.contains=function(a, e,$how) { 
	for(j=0;j<a.length-1;j++){
	  if($how==null){
	    if(a[j]==e)return true;
	  }
	    else if(e.indexOf(a[j])!=-1) return true;
	}
		 return false; 
}
Engine.prototype.unique=function(arr) {  
	tmp = new Array(0);
	for(i=0;i<arr.length;i++){
		if(!this.contains(tmp, arr[i])){
			tmp.length+=1;
			tmp[tmp.length-1]=arr[i];
		}
	}
	return tmp;
}
Engine.prototype.limit_text=function(id)
{  
	var nrc=this.getI(id).value.length; 
	var ramase=500-nrc;
	if(ramase<=0)
	{
	var text_redus=this.getI(id).value.substr(0,500);
	this.getI(id).value=text_redus;
	ramase=500;
     }
}
Engine.prototype.hash=function(type,hashable,value,other_table)
{   
	var hash=0;
     hash=hex_md5(hashable); 
	 if(type=="set")
	 {  
	  if(other_table==null){ 
	      hash_table[hash_table.length]={id:hash, val:value}; 
	  }
	    else{	
	     other_table[other_table.length]={id:hash, val:value}; 
		 }
		 
 	 } 
	 else if(type=="get"){
	 if(other_table==null)
	  var temp_table=hash_table;
	 else
	  var temp_table=other_table;
	  for(i=0;i<=temp_table.length-1;i++)
	   if(temp_table[i].id==hash)
	    return temp_table[i].val;

	 }
	}

	
Engine.prototype.EngineTest=function()
{
	return true;
	}  
////////////////////////////////END ENGINE METHODES\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\

////////////////////////////////////Number classs\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\

Numbers.prototype.construct=function()
{
	
	}
Numbers.prototype.isInteger=function(s)
   {
      var i;

      if (this.isEmpty(s))
      if (this.isInteger.arguments.length == 1) return 0;
      else return (this.isInteger.arguments[1] == true);
      for (i = 0; i < s.length; i++)
      {
         var c = s.charAt(i);

         if (!this.isDigit(c)) return false;
      }

      return true;
   }
Numbers.prototype.isEmpty=function(s)
   {
      return ((s == null) || (s == "") || (s.length == 0))
   }
Numbers.prototype.isDigit=function(c)
   {
      return ((c >= "0") && (c <= "9"))
   }

//////////////////////////////////End number class \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\

////////////////////////////////START REEGULAR EXPRESSION CLASS\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\

RegExpr.prototype.construct=function()
{
	this.email_pattern=/([0-9a-z]([0-9a-z_\.]*)@([0-9a-z_\.]*)([.][0-9a-z]{3})$)|([0-9a-z]([0-9a-z_\.]*)@([0-9a-z_\.]*)(\.[0-9a-z]{2})(\.[0-9a-z]{3})*$)/i;
	
	}
RegExpr.prototype.test=function($type,$victim)
{
	  switch($type)
	   {
		   case "email" : return this.email_pattern.test($victim);
		   }
	}

////////////////////////////////End regular expression class\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\

////////////////////// Start String class\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
Strings.prototype.construct=function()
{
	
	}
Strings.prototype.compare=function($a,$b)
{
	 if($a==$b) return true;
	       else return false;
	}
Strings.prototype.erase=function(blocks,victim)
{ ;
	  blocks=blocks.split(" ");
	   for(i=0;i<=blocks.length-1;i++)
			 victim=victim.replace(blocks[i],""); 
		   return victim; 
	}
Strings.prototype.getLetter=function(nr)
{
	var chars = "ABCDEFGHIJKLMNOPQRSTUVWXTZ";
	 return chars[nr]; 
	}
Strings.prototype.randomString=function() {
	var chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXTZabcdefghiklmnopqrstuvwxyz";
	var string_length = 8;
	var randomstring = '';
	for (var i=0; i<string_length; i++) {
		var rnum = Math.floor(Math.random() * chars.length);
		randomstring += chars.substring(rnum,rnum+1);
	}
	return randomstring;
}	
/////////////////////////end string class\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\


var engine=new Engine("0");	
var regexpr=new RegExpr("0");
var string=new Strings("0");
var number=new Numbers("0");
	
	
	
	
////////////////////////////////////////////////////////////////////////////MD5 hash\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
//************************************************************************************************************************************************\\\\\\\\\\


/*
 * Configurable variables. You may need to tweak these to be compatible with
 * the server-side, but the defaults work in most cases.
 */
var hexcase = 0;  /* hex output format. 0 - lowercase; 1 - uppercase        */
var b64pad  = ""; /* base-64 pad character. "=" for strict RFC compliance   */
var chrsz   = 8;  /* bits per input character. 8 - ASCII; 16 - Unicode      */

/*
 * These are the functions you'll usually want to call
 * They take string arguments and return either hex or base-64 encoded strings
 */
function hex_md5(s){ return binl2hex(core_md5(str2binl(s), s.length * chrsz));}
function b64_md5(s){ return binl2b64(core_md5(str2binl(s), s.length * chrsz));}
function str_md5(s){ return binl2str(core_md5(str2binl(s), s.length * chrsz));}
function hex_hmac_md5(key, data) { return binl2hex(core_hmac_md5(key, data)); }
function b64_hmac_md5(key, data) { return binl2b64(core_hmac_md5(key, data)); }
function str_hmac_md5(key, data) { return binl2str(core_hmac_md5(key, data)); }

/*
 * Perform a simple self-test to see if the VM is working
 */
function md5_vm_test()
{
  return hex_md5("abc") == "900150983cd24fb0d6963f7d28e17f72";
}

/*
 * Calculate the MD5 of an array of little-endian words, and a bit length
 */
function core_md5(x, len)
{
  /* append padding */
  x[len >> 5] |= 0x80 << ((len) % 32);
  x[(((len + 64) >>> 9) << 4) + 14] = len;

  var a =  1732584193;
  var b = -271733879;
  var c = -1732584194;
  var d =  271733878;

  for(var i = 0; i < x.length; i += 16)
  {
    var olda = a;
    var oldb = b;
    var oldc = c;
    var oldd = d;

    a = md5_ff(a, b, c, d, x[i+ 0], 7 , -680876936);
    d = md5_ff(d, a, b, c, x[i+ 1], 12, -389564586);
    c = md5_ff(c, d, a, b, x[i+ 2], 17,  606105819);
    b = md5_ff(b, c, d, a, x[i+ 3], 22, -1044525330);
    a = md5_ff(a, b, c, d, x[i+ 4], 7 , -176418897);
    d = md5_ff(d, a, b, c, x[i+ 5], 12,  1200080426);
    c = md5_ff(c, d, a, b, x[i+ 6], 17, -1473231341);
    b = md5_ff(b, c, d, a, x[i+ 7], 22, -45705983);
    a = md5_ff(a, b, c, d, x[i+ 8], 7 ,  1770035416);
    d = md5_ff(d, a, b, c, x[i+ 9], 12, -1958414417);
    c = md5_ff(c, d, a, b, x[i+10], 17, -42063);
    b = md5_ff(b, c, d, a, x[i+11], 22, -1990404162);
    a = md5_ff(a, b, c, d, x[i+12], 7 ,  1804603682);
    d = md5_ff(d, a, b, c, x[i+13], 12, -40341101);
    c = md5_ff(c, d, a, b, x[i+14], 17, -1502002290);
    b = md5_ff(b, c, d, a, x[i+15], 22,  1236535329);

    a = md5_gg(a, b, c, d, x[i+ 1], 5 , -165796510);
    d = md5_gg(d, a, b, c, x[i+ 6], 9 , -1069501632);
    c = md5_gg(c, d, a, b, x[i+11], 14,  643717713);
    b = md5_gg(b, c, d, a, x[i+ 0], 20, -373897302);
    a = md5_gg(a, b, c, d, x[i+ 5], 5 , -701558691);
    d = md5_gg(d, a, b, c, x[i+10], 9 ,  38016083);
    c = md5_gg(c, d, a, b, x[i+15], 14, -660478335);
    b = md5_gg(b, c, d, a, x[i+ 4], 20, -405537848);
    a = md5_gg(a, b, c, d, x[i+ 9], 5 ,  568446438);
    d = md5_gg(d, a, b, c, x[i+14], 9 , -1019803690);
    c = md5_gg(c, d, a, b, x[i+ 3], 14, -187363961);
    b = md5_gg(b, c, d, a, x[i+ 8], 20,  1163531501);
    a = md5_gg(a, b, c, d, x[i+13], 5 , -1444681467);
    d = md5_gg(d, a, b, c, x[i+ 2], 9 , -51403784);
    c = md5_gg(c, d, a, b, x[i+ 7], 14,  1735328473);
    b = md5_gg(b, c, d, a, x[i+12], 20, -1926607734);

    a = md5_hh(a, b, c, d, x[i+ 5], 4 , -378558);
    d = md5_hh(d, a, b, c, x[i+ 8], 11, -2022574463);
    c = md5_hh(c, d, a, b, x[i+11], 16,  1839030562);
    b = md5_hh(b, c, d, a, x[i+14], 23, -35309556);
    a = md5_hh(a, b, c, d, x[i+ 1], 4 , -1530992060);
    d = md5_hh(d, a, b, c, x[i+ 4], 11,  1272893353);
    c = md5_hh(c, d, a, b, x[i+ 7], 16, -155497632);
    b = md5_hh(b, c, d, a, x[i+10], 23, -1094730640);
    a = md5_hh(a, b, c, d, x[i+13], 4 ,  681279174);
    d = md5_hh(d, a, b, c, x[i+ 0], 11, -358537222);
    c = md5_hh(c, d, a, b, x[i+ 3], 16, -722521979);
    b = md5_hh(b, c, d, a, x[i+ 6], 23,  76029189);
    a = md5_hh(a, b, c, d, x[i+ 9], 4 , -640364487);
    d = md5_hh(d, a, b, c, x[i+12], 11, -421815835);
    c = md5_hh(c, d, a, b, x[i+15], 16,  530742520);
    b = md5_hh(b, c, d, a, x[i+ 2], 23, -995338651);

    a = md5_ii(a, b, c, d, x[i+ 0], 6 , -198630844);
    d = md5_ii(d, a, b, c, x[i+ 7], 10,  1126891415);
    c = md5_ii(c, d, a, b, x[i+14], 15, -1416354905);
    b = md5_ii(b, c, d, a, x[i+ 5], 21, -57434055);
    a = md5_ii(a, b, c, d, x[i+12], 6 ,  1700485571);
    d = md5_ii(d, a, b, c, x[i+ 3], 10, -1894986606);
    c = md5_ii(c, d, a, b, x[i+10], 15, -1051523);
    b = md5_ii(b, c, d, a, x[i+ 1], 21, -2054922799);
    a = md5_ii(a, b, c, d, x[i+ 8], 6 ,  1873313359);
    d = md5_ii(d, a, b, c, x[i+15], 10, -30611744);
    c = md5_ii(c, d, a, b, x[i+ 6], 15, -1560198380);
    b = md5_ii(b, c, d, a, x[i+13], 21,  1309151649);
    a = md5_ii(a, b, c, d, x[i+ 4], 6 , -145523070);
    d = md5_ii(d, a, b, c, x[i+11], 10, -1120210379);
    c = md5_ii(c, d, a, b, x[i+ 2], 15,  718787259);
    b = md5_ii(b, c, d, a, x[i+ 9], 21, -343485551);

    a = safe_add(a, olda);
    b = safe_add(b, oldb);
    c = safe_add(c, oldc);
    d = safe_add(d, oldd);
  }
  return Array(a, b, c, d);

}

/*
 * These functions implement the four basic operations the algorithm uses.
 */
function md5_cmn(q, a, b, x, s, t)
{
  return safe_add(bit_rol(safe_add(safe_add(a, q), safe_add(x, t)), s),b);
}
function md5_ff(a, b, c, d, x, s, t)
{
  return md5_cmn((b & c) | ((~b) & d), a, b, x, s, t);
}
function md5_gg(a, b, c, d, x, s, t)
{
  return md5_cmn((b & d) | (c & (~d)), a, b, x, s, t);
}
function md5_hh(a, b, c, d, x, s, t)
{
  return md5_cmn(b ^ c ^ d, a, b, x, s, t);
}
function md5_ii(a, b, c, d, x, s, t)
{
  return md5_cmn(c ^ (b | (~d)), a, b, x, s, t);
}

/*
 * Calculate the HMAC-MD5, of a key and some data
 */
function core_hmac_md5(key, data)
{
  var bkey = str2binl(key);
  if(bkey.length > 16) bkey = core_md5(bkey, key.length * chrsz);

  var ipad = Array(16), opad = Array(16);
  for(var i = 0; i < 16; i++)
  {
    ipad[i] = bkey[i] ^ 0x36363636;
    opad[i] = bkey[i] ^ 0x5C5C5C5C;
  }

  var hash = core_md5(ipad.concat(str2binl(data)), 512 + data.length * chrsz);
  return core_md5(opad.concat(hash), 512 + 128);
}

/*
 * Add integers, wrapping at 2^32. This uses 16-bit operations internally
 * to work around bugs in some JS interpreters.
 */
function safe_add(x, y)
{
  var lsw = (x & 0xFFFF) + (y & 0xFFFF);
  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
  return (msw << 16) | (lsw & 0xFFFF);
}

/*
 * Bitwise rotate a 32-bit number to the left.
 */
function bit_rol(num, cnt)
{
  return (num << cnt) | (num >>> (32 - cnt));
}

/*
 * Convert a string to an array of little-endian words
 * If chrsz is ASCII, characters >255 have their hi-byte silently ignored.
 */
function str2binl(str)
{
  var bin = Array();
  var mask = (1 << chrsz) - 1;
  for(var i = 0; i < str.length * chrsz; i += chrsz)
    bin[i>>5] |= (str.charCodeAt(i / chrsz) & mask) << (i%32);
  return bin;
}

/*
 * Convert an array of little-endian words to a string
 */
function binl2str(bin)
{
  var str = "";
  var mask = (1 << chrsz) - 1;
  for(var i = 0; i < bin.length * 32; i += chrsz)
    str += String.fromCharCode((bin[i>>5] >>> (i % 32)) & mask);
  return str;
}

/*
 * Convert an array of little-endian words to a hex string.
 */
function binl2hex(binarray)
{
  var hex_tab = hexcase ? "0123456789ABCDEF" : "0123456789abcdef";
  var str = "";
  for(var i = 0; i < binarray.length * 4; i++)
  {
    str += hex_tab.charAt((binarray[i>>2] >> ((i%4)*8+4)) & 0xF) +
           hex_tab.charAt((binarray[i>>2] >> ((i%4)*8  )) & 0xF);
  }
  return str;
}

/*
 * Convert an array of little-endian words to a base-64 string
 */
function binl2b64(binarray)
{
  var tab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  var str = "";
  for(var i = 0; i < binarray.length * 4; i += 3)
  {
    var triplet = (((binarray[i   >> 2] >> 8 * ( i   %4)) & 0xFF) << 16)
                | (((binarray[i+1 >> 2] >> 8 * ((i+1)%4)) & 0xFF) << 8 )
                |  ((binarray[i+2 >> 2] >> 8 * ((i+2)%4)) & 0xFF);
    for(var j = 0; j < 4; j++)
    {
      if(i * 8 + j * 6 > binarray.length * 32) str += b64pad;
      else str += tab.charAt((triplet >> 6*(3-j)) & 0x3F);
    }
  }
  return str;
}