var products = [

"Isis-Lite", "Isis-Lite", "™",
"BathyPro", "BathyPro", "™",
"DelphNav", "DelphNav", "™",
"SB-Logger", "SB-Logger", "™",
"GSF-Export", "GSF-Export", "™",
"Isis Sonar", "IsisŪ Sonar","™",
"TritonMap", "TritonMap","™",
"Survey Planner", "Survey Planner","™",
"SeaClass", "SeaClass","™",
"PipeClass", "PipeClass","™",
"ROVFlight", "ROVFlight","™",
"A-B", "A-B","™",
"DelphMap", "DelphMap","™",
"3-DViz", "3-DViz","™",
"SnippetPro", "SnippetPro","™",
"MSTMosaic", "MSTMosaic","™",
"HydroSuite", "HydroSuite","™",
"HarborSuite", "HarborSuite","™",
"SonarSuite", "SonarSuite","™",
"SubbottomSuite", "SubbottomSuite","™",
"Rugged Workstation", "Rugged Workstation","™",
"Portable Workstation", "Portable Workstation","™",
"Industrial Workstation", "Industrial Workstation","™",
"Isis Bathy", "IsisŪ Bathy","™",
"SB-Pick", "SB-Pick","™",
"Advanced Filtering", "Advanced Filtering","™",
"Swell Filtering", "Swell Filtering","™",
"Replay Only", "Replay Only","™",
"ASCII Reporting", "ASCII Reporting","™",
"Printing", "Printing","™",
"MosaicBasic", "MosaicBasic","™",
"TargetPro", "TargetPro","™",
"PipeTrack", "PipeTrack","™",
"SS-MosaicRT", "SS-MosaicRT","™",
"MBSS-Logger™", "MBSS-Logger™","™",
"MB-Monitor", "MB-Monitor","™",
"IntelliTrak", "IntelliTrak","™",
"IntelliQC", "IntelliQC","™",
"MosaicRT", "MosaicRT","™",
"SBPick", "SBPick","™",
"SnippetPro", "SnippetPro","™",
"Sonar Suite", "Sonar Suite","™",
"SS-Mosaic", "SS-Mosaic","™",
"SS-Office", "SS-Office","™",
"Subbottom Suite", "Subbottom Suite","™",
"Survey Monitor", "Survey Monitor","™",
"Survey Office", "Survey Office","™",
"3DViz", "3DViz","™",
"Triton A-B", "Triton A-B","™",
"TritonNav", "TritonNav","™",
"MB-DTM RT", "MB-DTM RT","™",
"MB-Logger", "MB-Logger","™",
"MB-Office", "MB-Office","™",
"MB-Office", "MB-Office","™",
"MBSS-Logger™", "MBSS-Logger™","™",
"Mosaic Basic", "Mosaic Basic","™",
"Harbor Suite", "Harbor Suite","™",
"Hydro Suite", "Hydro Suite","™",
"Isis Bathy", "IsisŪ Bathy","™",
"Isis Sonar", "IsisŪ Sonar","™",
"Isis Sonar Office", "Isis Sonar Office","™",
"Isis-Lite", "IsisŪ-Lite","™",
"BathyRT", "BathyRT","™",
"Fusion Office", "Fusion Office","™",
"MBSS-Logger™", "MBSS-Logger™","™",
"SS Logger", "SS Logger","™",
"SS-Logger™", "SS-Logger™", "™",
"Isis", "Isis", "™"
 ];

var trademarks = products;

var reg = ["Isis"];


//If the text in text node matches a product name, then we do our magic
//and replace the matched name with the replacement text
//finally, an entity is added if one is specified
function productMatch(n, prod, repl, entity) {
	
	if (n.parentNode==null) return; //can't do much with this
	
	var regex = prod;
	var rexp = new RegExp(regex, "gim");
	var rstring = n.data;

	var prevStart = 0;
	var posttext, mat;
	var temp = document.createDocumentFragment();
	while((mat=rexp.exec(rstring))!=null){ //Individual match
	  var pretext = rstring.substr(prevStart, mat.index);
	  posttext = rstring.substr(rexp.lastIndex);
	  var span = document.createElement("span");
	  span.appendChild(document.createTextNode(repl)); // matched product name
	  span.className = "productTM";
	  prevStart = rexp.lastIndex;
	  if (pretext.length>0) { //add text before the match
		 temp.appendChild(document.createTextNode(pretext));  
	  }
	  temp.appendChild(span);
	}
	temp.appendChild(document.createTextNode(posttext));
	if (entity!=null){
		if ((posttext!=null) && (posttext.indexOf(entity))==-1) {
			
		var espan = document.createElement("span");
	    espan.appendChild(document.createTextNode(entity)); // matched product name
	    espan.className = "entity";
		
		var par = n.parentNode;
		
		if (par.nextSibling == null) { //tack it onto the end of the parent, if the parent is a solo node, such as an anchor element
			par.appendChild(espan);
		} else {
			
			temp.appendChild(espan);
			//At this point, we really should split the anchor element and construct
			//a new node set with the following elements:
			//<anchor> -> pretext ->productname-><end anchor><entity><anchor duplicated>posttext<end anchor>
			// but I'm feeling lazy
		}
		
		}
	}
	n.parentNode.replaceChild(temp, n); 
	
	/*
	if (putelement.parentNode != null) {
		var temp2 = document.createDocumentFragment();
		temp2.appendChildNode(putelement);
	}
	// An entity such as TM or Reg needs special handling
	if (entity!=null) {
		var putelement = n; //The element that will precede the entity
		var par = n.parentNode;
		//Entities should fall outside of the anchor tag, if wrapping
		if ((par!=null) && (par.tagName=="A" || par.tagName=="a")) {
			putelement = par;
			
		if (putelement.parentNode != null) {
			putelement.replaceChild(temp2, 
		}temp2.appendChild(par);
			temp2.appendChild(document.createTextNode(entity));
			n.parentNode.replaceChild(temp, n); 
		} else	{
			par.append
		}
		temp.appendChild(document.createTextNode(entity));
	}

	
	//We need to replace the existing single node of text with a new span node that specifies the 
	//style for the product name and contains the original node as a child node
	*/

}


//For each text node, test whether it contains any of the product, TM or Reg strings
function processText(n) {
	var contents = n.data;
	var parent = n.parent;
	// Don't process already marked items
	if  ((parent!=null) && (parent.tagName=="span") && (parent.getAttribute("className")=="productTM"))  {
								alert("span productTM");
	} else {
		
		for (var i=0; i<products.length; i=i+3) {
			var prod = products[i];
			var regex = prod;
			if (contents.match(regex)) productMatch(n, prod, products[i+1], products[i+2]);
		}
	}
}


		

function processNode(n) {
	
	if (n==null) return;
	
	if (n.nodeType == 3) { //Text node
		processText(n);	
	} 
	else {
		var kids = n.childNodes;
		var numkids = kids.length;
		if (numkids>0) {
			for (var i=0; i<numkids; i++) {
				var n2 = kids[i];
				// Don't reprocess something already defined as a product span
				if (n2!=null)  { //element node
						processNode(n2);
				}
			}

		}
	}
}



function p2() {
 
 	var allelements;
	processNode(document.body);
	//if (document.all != null) { allelements = document.all; }
	//else {allelements = document.getElementsByTagName("*");}

	//if (allelements == null) alert("No Elements Found");
	//for (var i=0; i<allelements.length; i++) {
	//	 processNode(allelements[i]);
	//}
}