//Add to Favorites
function addfav(webSiteName)
{

		if (document.all)
		window.external.AddFavorite(location.href, webSiteName + " " + document.title);
		else if (window.sidebar)
		window.sidebar.addPanel(webSiteName + " " + document.title, location.href, "")
		
	/*window.external.AddFavorite(location.href,webSiteName + " " + document.title);*/
	
}




//Make Home Page
//Only works on IE
//Not worth using
function makeHome(thisObject)
{
	thisObject.style.behavior='url(#default#homepage)';
	thisObject.setHomePage(location.href);	
}

//function addfav()
//   {
//   if (document.all)
//      {
//      window.external.AddFavorite
//      ("http://www.webdevelopersnotes.com","WebDevelopersNotes")
//      }
//   }

//alert("yo");

function activatePage()
{	

		//Get current hostname then compare to hostname of links present on the page
		var current_hostName = self.location.hostname;
		
		//loop throuth the links array and check each href
		for (var i = 0; i < document.links.length; i++) 
		{ 		
		
				  var current_link = document.links[i];				  
				  //alert(current_link.host)		
				  
					//#############################################################################################
					//#### Make External Links open into a new window

					//if current page host name = current link host name
					if ((current_hostName == current_link.hostname) || (current_link.href.indexOf('javascript:window.location.href') > -1))
					{					
					}else {
					
						//must be a link to another server
						current_link.target = "_blank";
					}

		}	
}


//##### Right buttom click ####
function doSomething(e)
{
	var rightclick;
	if (!e) var e = window.event;
	if (e.which) rightclick = (e.which == 3);
	else if (e.button) rightclick = (e.button == 2);
	//alert('Rightclick: ' + rightclick); // true or false
	this.href = "/lalal/";
	//alert(this.href);
}



//########


//Good site fopr js info http://www.quirksmode.org/js/events_properties.html

function move(url){	
	location.href = url;
}


function openWindow(url){
	
	mywindow = window.open(url)	

	mywindow.focus()
}


function makeTracks(url){
	mywindow = window.open(url)	
	mywindow.focus()
}


function myEncrypt(url){
return TEAencrypt("url","myPass");
}


//####################### ENCRYPTION for URLS ############################
//
     // TEAencrypt: Use Corrected Block TEA to encrypt plaintext using password
     //            (note plaintext & password must be strings not string objects)
     //
     // Return encrypted text as string
     //
     function TEAencrypt(plaintext, password)
     {
         if (plaintext.length == 0) return('');  // nothing to encrypt
         // 'escape' plaintext so chars outside ISO-8859-1 work in single-byte packing, but  
         // keep spaces as spaces (not '%20') so encrypted text doesn't grow too long, and 
         // convert result to longs
         var v = strToLongs(escape(plaintext).replace(/%20/g,' '));
         if (v.length == 1) v[1] = 0;  // algorithm doesn't work for n<2 so fudge by adding nulls
         var k = strToLongs(password.slice(0,16));  // simply convert first 16 chars of password as key
         var n = v.length;

         var z = v[n-1], y = v[0], delta = 0x9E3779B9;
         var mx, e, q = Math.floor(6 + 52/n), sum = 0;

         while (q-- > 0) {  // 6 + 52/n operations gives between 6 & 32 mixes on each word
             sum += delta;
             e = sum>>>2 & 3;
             for (var p = 0; p < n-1; p++) {
                 y = v[p+1];
                 mx = (z>>>5 ^ y<<2) + (y>>>3 ^ z<<4) ^ (sum^y) + (k[p&3 ^ e] ^ z)
                 z = v[p] += mx;
             }
             y = v[0];
             mx = (z>>>5 ^ y<<2) + (y>>>3 ^ z<<4) ^ (sum^y) + (k[p&3 ^ e] ^ z)
             z = v[n-1] += mx;
         }
         // note use of >>> in place of >> due to lack of 'unsigned' type in JavaScript 

         return escCtrlCh(longsToStr(v));
     }

     //
     // TEAdecrypt: Use Corrected Block TEA to decrypt ciphertext using password
     //
     function TEAdecrypt(ciphertext, password)
     {
         if (ciphertext.length == 0) return('');
         var v = strToLongs(unescCtrlCh(ciphertext));
         var k = strToLongs(password.slice(0,16)); 
         var n = v.length;

         var z = v[n-1], y = v[0], delta = 0x9E3779B9;
         var mx, e, q = Math.floor(6 + 52/n), sum = q*delta;

         while (sum != 0) {
             e = sum>>>2 & 3;
             for (var p = n-1; p > 0; p--) {
                 z = v[p-1];
                 mx = (z>>>5 ^ y<<2) + (y>>>3 ^ z<<4) ^ (sum^y) + (k[p&3 ^ e] ^ z)
                 y = v[p] -= mx;
             }
             z = v[n-1];
             mx = (z>>>5 ^ y<<2) + (y>>>3 ^ z<<4) ^ (sum^y) + (k[p&3 ^ e] ^ z)
             y = v[0] -= mx;
             sum -= delta;
         }

         var plaintext = longsToStr(v);
         // strip trailing null chars resulting from filling 4-char blocks:
         if (plaintext.search(/\0/) != -1) plaintext = plaintext.slice(0, plaintext.search(/\0/));

         return unescape(plaintext);
     }


     // supporting functions

     function strToLongs(s) {  // convert string to array of longs, each containing 4 chars
         // note chars must be within ISO-8859-1 (with Unicode code-point < 256) to fit 4/long
         var l = new Array(Math.ceil(s.length/4))
         for (var i=0; i<l.length; i++) {
             // note little-endian encoding - endianness is irrelevant as long as 
             // it is the same in longsToStr() 
             l[i] = s.charCodeAt(i*4) + (s.charCodeAt(i*4+1)<<8) + 
                    (s.charCodeAt(i*4+2)<<16) + (s.charCodeAt(i*4+3)<<24);
         }
         return l;  // note running off the end of the string generates nulls since 
     }              // bitwise operators treat NaN as 0

     function longsToStr(l) {  // convert array of longs back to string
         var a = new Array(l.length);
         for (var i=0; i<l.length; i++) {
             a[i] = String.fromCharCode(l[i] & 0xFF, l[i]>>>8 & 0xFF, 
                                        l[i]>>>16 & 0xFF, l[i]>>>24 & 0xFF);
         }
         return a.join('');  // use Array.join() rather than repeated string appends for efficiency
     }

     function escCtrlCh(str) {  // escape control chars which might cause problems with encrypted texts
         return str.replace(/[\0\n\v\f\r!]/g, function(c) { return '!' + c.charCodeAt(0) + '!'; });
     }

     function unescCtrlCh(str) {  // unescape potentially problematic nulls and control characters
         return str.replace(/!\d\d?!/g, function(c) { return String.fromCharCode(c.slice(1,-1)); });
     }

//####################################################################################################