/* ***** ************************* TEXTMARK API ************************************ */        
 
var TEXTMARK_fOldMouseUp = document.onmouseup;      
document.onmouseup = TEXTMARK_TextMouseUp

var TEXTMARK_fOldMouseDown = document.onmousedown;      
document.onmousedown = TEXTMARK_TextMouseDown

var TEXTMARK_bTextMouseDown = false;

//const
var TEXTMARK_nToolMarker = 1;

var TEXTMARK_sTargetName = "" // Text to mark on
var TEXTMARK_sCurColor = "";  // chosen color    
var TEXTMARK_sText =  "";
var TEXTMARK_nCurrentMarker  = -1   
//var TEXTMARK_nAddFontSize  = 10;
//var TEXTMARK_nFontSize = "110%";
var TEXTMARK_nActiveTool = "";             
var TEXTMARK_bMouseUp = false;             

//------------------------------------------------------------------------

function TEXTMARK_CompressChars (sText)
//       ~~~~~~~~~~~~~~~~~~~~~
{
  var sNewText = sText  
  sNewText = sNewText.replace(" ", ""); //tab
  sNewText = sNewText.replace(" ", "");
  sNewText = sNewText.replace(",", "");
  sNewText = sNewText.replace(".", "");
  sNewText = sNewText.replace("'", "");
  sNewText = sNewText.replace("-", "");
  sNewText = sNewText.replace(":", "");  
  return sNewText
}
//------------------------------------------------------------------------

function TEXTMARK_CheckIsChildElToCheck (oEl, sChildID)
//       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
{
  var nLen = oEl.children.length
  sChildID = sChildID.toLowerCase()  
   
  for (var i=0; i<nLen; i++)
  {     
    if (oEl.children.item(i).id.toLowerCase() == sChildID)
    {
      return i;
    }
  }
  return -1;
}
//------------------------------------------------------------------------

function TEXTMARK_MngClearMarkers (sTextID)
//       ~~~~~~~~~~~~~~~~~~~~~~~~
{   
   var sRetValue = window.showModalDialog("../deleteMarkers.aspx","", "dialogHeight:300px;dialogWidth:300px")
   if (sRetValue == "ok")
    TEXTMARK_ClearAllMarkers(sTextID)
}
//------------------------------------------------------------------------

function TEXTMARK_ClearAllMarkers (sTextID)
//       ~~~~~~~~~~~~~~~~~~~~~~~~
{
  var oEl = eval(TEXTMARK_sTargetName);
  var oAllEl = oEl.all.tags("LABEL")
  if (oAllEl != null)
  { 
    for (var i=oAllEl.length-1; i>=0; i--)
    {
      if (oAllEl[i].color != 'undefined')
      { 
        oAllEl[i].outerHTML = oAllEl[i].innerHTML;              
      }
    }
  }
}
//------------------------------------------------------------------------

function  TEXTMARK_GetQuestMarkNum (sTextID, sMarkType)
//       ~~~~~~~~~~~~~~~~~~~~~~~~~
{
  var oEl = eval("TEXT_" + sTextID)      
  var aMarkers = oEl.all.tags("SPAN")          
  var nMarkersNum = 0;
 
  for(var i=0; i<aMarkers.length; i++)  
  {
    if (aMarkers[i].sType ==  sMarkType)
      nMarkersNum++;
  }
  return nMarkersNum  
}
//------------------------------------------------------------------------

function  TEXTMARK_CheckSelAnswers (sTextID, sMarkType)
//       ~~~~~~~~~~~~~~~~~~~~~~~~~
{                
  var oEl = eval("TEXT_" + sTextID)      
  var aMarkers = oEl.all.tags("LABEL")          
  var nQuestNumOk = 0;
  var nQuestNumWrong = 0;
  
  if (sMarkType == undefined)
    var sMarkType = "QuestMark";       
  for(var i=0; i<aMarkers.length; i++)  
  //for(var i=aMarkers.length-1; i>=0; i--)
  {     
    if (aMarkers[i].bCr == false)   
    {
      TEXTMARK_RemoveAnswerImg (aMarkers[i])
    }        
    // Marker has a child element id="QuestMark/DeleteMark"  --> return index of the child element
    var nQuestChild = TEXTMARK_CheckIsChildElToCheck(aMarkers[i],  sMarkType)      

    if (nQuestChild != -1)
    {       
      var sOriginalMark = aMarkers[i].children.item(nQuestChild).innerText;
      sOriginalMark = TEXTMARK_CompressChars(sOriginalMark)            
      var sQuestColor = aMarkers[i].children.item(nQuestChild).color    
      
    }
    if (aMarkers[i].parentElement.id == sMarkType)
    {       
      var sOriginalMark = aMarkers[i].parentElement.innerText;
      sOriginalMark = TEXTMARK_CompressChars(sOriginalMark)
      var sQuestColor = aMarkers[i].parentElement.color;    
    }    

    if (aMarkers[i].parentElement.id == sMarkType || nQuestChild != -1)
    {                                                     
      var sMark = aMarkers[i].innerText;               
      sMark = TEXTMARK_CompressChars(sMark);   

      if (sMark == sOriginalMark && (sQuestColor == aMarkers[i].color))
      {
        nQuestNumOk++;       
        aMarkers[i].bCr = true;
        TEXTMARK_SetAnswerImg (aMarkers[i], true)
      }  
      else
      {
        nQuestNumWrong++;       
        aMarkers[i].bCr = false;
        TEXTMARK_SetAnswerImg (aMarkers[i], false)
      }  
    }  
    else
    {
      nQuestNumWrong++;       
      aMarkers[i].bCr = false;
      TEXTMARK_SetAnswerImg (aMarkers[i], false)
    }
  }   
  //  alert("nTotalQuest Of Type " + sMarkType + ": " + TEXTMARK_GetQuestMarkNum(sTextID, sMarkType))
  //  alert("nQuestNumWrong: "+ nQuestNumWrong)
  //  alert("nQuestNumOk: "+ nQuestNumOk)
  var ret = new Object();
  ret.nNumCorrect = nQuestNumOk;
  ret.nNumWrong = nQuestNumWrong;
  return ret;
}
//-------------------------------------------------------

function TEXTMARK_SetAnswerImg (oMarker, bOk)
//       ~~~~~~~~~~~~~~~~~~~~~
{ 
  if (bOk)
    var sImg = "url(../images/right.GIF)"        
  else   
    var sImg = "url(../images/wrong.GIF)"
    
  oMarker.style.backgroundImage = sImg;              
  oMarker.style.backgroundPosition = "top right";    
  oMarker.style.backgroundRepeat = "no-repeat";    
  oMarker.style.paddingLeft = "16";    
}
//-------------------------------------------------------

function TEXTMARK_RemoveAnswerImg (oMarker)
//       ~~~~~~~~~~~~~~~~~~~~~~~
{   
  oMarker.style.removeAttribute("backgroundImage")
  oMarker.style.removeAttribute("paddingLeft")  
  oMarker.style.removeAttribute("backgroundPosition")    
  oMarker.style.removeAttribute("backgroundRepeat")    
}
//-------------------------------------------------------

function TEXTMARK_sGetPlainText (sTextID)
//       ~~~~~~~~~~~~~~~~~~~~~~
{
  var oEl = eval("TEXT_" + sTextID)          
  var oDuplicateText = oEl.cloneNode(true)
  var aMarkers = oDuplicateText.all.tags("LABEL")          
  var arroAudioseg = oDuplicateText.all.tags("SPAN");    
  var arrHeadlines = new Array();
  
  for(var i=aMarkers.length-1; i>=0; i--)  
  {                                            
    if (aMarkers[i].getAttribute("className") == 'MarkerDelete')   
    {
      aMarkers[i].removeNode(true);  
    }        
  }

  for (var i=0; i<arroAudioseg.length; i++)  
  { 
    if (arroAudioseg[i].sType == 'headline' ) 
    {     
      arrHeadlines.push(arroAudioseg[i]);
    }
  } 
  for (var i=arrHeadlines.length-1; i>=0; i--)  
  { 
     arrHeadlines[i].removeNode(true); 
  }

  var nLen = oDuplicateText.all.length         
  for (var i=nLen-1; i>=0; i--)
  {     
    if (oDuplicateText.all(i).tagName != "BR")
      oDuplicateText.all(i).removeNode()
  } 
  var sText = oDuplicateText.innerHTML;  
  var re = /<BR>/gi  //regular expression
  sText = sText.replace(re, "\n")       
  document.getElementById("debug").value = sText;      
}
//-------------------------------------------------------

function TEXTMARK_ReturnColor ()
//       ~~~~~~~~~~~~~~~~~~~~
{
  TEXTMARK_nActiveTool = ""; 
  BASETEXT_HideCursor();  
  document.releaseCapture();    
}
//-------------------------------------------------------

function TEXTMARK_MngFillColorText(sTextID, sColor, bShowColor)
//       ~~~~~~~~~~~~~~~~~~~~~~~~~
{ 
  var oEl = eval(sTextID)        
  var aMarkers = oEl.all("SetColor")    
 
  for(var i=0; i< aMarkers.length; i++)
  {  
    if (aMarkers[i].color == sColor) 
    {       
      if (bShowColor)
        aMarkers[i].style.backgroundColor = sColor
      else
      {
        aMarkers[i].style.backgroundColor = ""                            
      }  
      BASETEXT_ScrollText(sTextID,  aMarkers[i])      
    }

  }     
}
//-------------------------------------------------------

function TEXTMARK_InitColor (sTextID, sColor)
//       ~~~~~~~~~~~~~~~~~
{   
  TEXTMARK_nActiveTool = TEXTMARK_nToolMarker; 
  TEXTMARK_sTargetName = sTextID;        
  TEXTMARK_sCurColor = sColor;   
  TEXTMARK_attachMouseMove();      
}
//---------------------------------

function TEXTMARK_attachMouseMove ()
//       ~~~~~~~~~~~~~~~~~~~~~~~~ 
{ 
  var oDicColors = eval("TextMark_" + TEXTMARK_sTargetName + "_oDictionaryColors");       
  var oCursor_img = document.getElementById("Cursor_TextCursor_img");    
  var oCursor = document.getElementById("Cursor_TextCursor");    
  if (TEXTMARK_sCurColor == 'eraser' || TEXTMARK_sCurColor == 'delete')
    oCursor_img.src = "../images/markerCur" + TEXTMARK_sCurColor + ".gif";                                  
  else
    oCursor_img.src = "../images/markerCur" + oDicColors(TEXTMARK_sCurColor) + ".gif";                                    

  BASETEXT_SetCursor(oCursor, eval(TEXTMARK_sTargetName))      
}
//________________________________________________________________________

function TEXTMARK_TextMouseDown ()
//       ~~~~~~~~~~~~~~~~~~~~~~
{  
  if (TEXTMARK_checkIsTextTarget(event.srcElement,TEXTMARK_sTargetName) != null)
    TEXTMARK_bTextMouseDown = true;
  else
    TEXTMARK_bTextMouseDown = false;    
}
//________________________________________________________________________

function TEXTMARK_TextMouseUp ()
//       ~~~~~~~~~~~~~~~~~~~~
{ 
  var bOldMouseUp = false;

  if (TEXTMARK_fOldMouseUp != null)
    bOldMouseUp = true;     
  
  if (TEXTMARK_nActiveTool == "")
  {
    if (bOldMouseUp)
      TEXTMARK_fOldMouseUp();   
    return;  
  }
  if (TEXTMARK_checkIsTextTarget(event.srcElement,TEXTMARK_sTargetName) == null)
  { 
    if (bOldMouseUp)
      TEXTMARK_fOldMouseUp();
    if (TEXTMARK_bTextMouseDown)  
    {
      TEXTMARK_bTextMouseDown = false;    
      document.selection.empty();    
    }
    return; 
  }  
  
  if (!TEXTMARK_bTextMouseDown)
  {
   document.selection.empty();    
   return;    
  }
  
  var oSel = document.selection;	  	       	       	    
  if (oSel != null && !TEXTMARK_bMouseUp)
	{ 	    	
	  var oSelRange = oSel.createRange();
	  oSelRange.expand("word")	  
	  
	  var sLen = oSelRange.text.length;	 	  
	  
	  if (sLen > 0 && TEXTMARK_sCurColor!= "" && oSelRange.text != "" && oSelRange.text != " ")
	  { 	  
      TEXTMARK_bMouseUp  = true
      window.setTimeout("TEXTMARK_bMouseUp=false", 500) 	  
	    //oSelRange.expand("word")
	    sLen = oSelRange.text.length;	        	  	  	  	  	    	    	    	  	    	    
	    var oEl = eval(TEXTMARK_sTargetName);        
	    oEl.setCapture();       
	    oSelRange.collapse();
	    oSelRange.pasteHTML("$1$");	    
	    var nMove = oSelRange.move("character", sLen)
	    
	    oSelRange.pasteHTML("$2$");		 
	       	    
	    TEXTMARK_sText =  oEl.innerHTML;		 	    	    	    	    	    
	    var sNewText = TEXTMARK_UpdateTextMarker();	  	    	    
      sNewText = TEXTMARK_MergeMarkersManager(sNewText);	        	                      
	    oEl.innerHTML = sNewText     	        	        	    
	  
	    TEXTMARK_EraseMarkers()
	    //debug.value = oEl.innerHTML;
	    document.selection.empty();	    	    
	  }
  }  
  if (bOldMouseUp)
    TEXTMARK_fOldMouseUp();   
  document.releaseCapture();    
} 
//---------------------------------

function TEXTMARK_MergeMarkersManager (sNewText)
//       ~~~~~~~~~~~~~~~~~~~~~~~~~~
{
  var nPos = 0;
  var oText = new Object(); 
  oText.nPos = -1;
  oText.sText = sNewText;
  while((oText = TEXTMARK_MergeMarkers(oText.sText, oText.nPos)).nPos != -1)
    ;
  return oText.sText;      
}
//---------------------------------

function TEXTMARK_MergeMarkers (sNewText, nStartPos)
//       ~~~~~~~~~~~~~~~~~~~~
{
  var oText  = new Object();
  oText.nPos = -1
  oText.sText = sNewText;   
  var nPos = sNewText.toLowerCase().indexOf("</label><label", nStartPos+1);                
  var nPos1 = sNewText.toLowerCase().indexOf("</label></span><label", nStartPos+1);                
  
  // end of string to check merge strings
  var sEndMergeString = "</label>";
  //
  if (nPos1 != -1)
  {
    // when Coloring span-type of QuestMark etc;
    // the <label> is a child of the span: 
    // <span type="QuestMark"...><label>...</label></span><label...
    nPos = nPos1
    sEndMergeString = "</label></span>";
  }  
  
  
  if (nPos != -1)
  {
    var sStr = sNewText.substring(0,nPos);
    var nStartMarker1 = sStr.toLowerCase().lastIndexOf("<label ");
    var sStrMarker1 = TEXTMARK_GetMarkerElement(nStartMarker1, TEXTMARK_sText);        
    var sColor1 = TEXTMARK_GetAttribValue(sStrMarker1, "color");
    var nStartMarker2 = nPos + sEndMergeString.length;
    var sStrMarker2 = TEXTMARK_GetMarkerElement(nStartMarker2, TEXTMARK_sText); 
    var sColor2 = TEXTMARK_GetAttribValue(sStrMarker2, "color");       
    if (sColor1 == sColor2)     
    {
      var sStrStart = sNewText.substring(0, nPos);
      var nEndTagMarker = sNewText.indexOf(">", nStartMarker2)                  
      var sStrEnd = sNewText.substring(nEndTagMarker+1, sNewText.length);            
      sNewText = sStrStart + sStrEnd;            
      oText.nPos  = nPos;          
      oText.sText = sNewText;
    }                              
  }                                       
  return oText;
}
//---------------------------------

function TEXTMARK_EraseMarkers ()
//       ~~~~~~~~~~~~~~~~~~~~~~
{
  var oEl = eval(TEXTMARK_sTargetName);
  var oAllEl = oEl.all.tags("LABEL")
  if (oAllEl != null)
  {         
    for (var i=0; i<oAllEl.length; i++)
    {
      if (oAllEl[i].color != 'undefined')
      { 
        if (oAllEl[i].getAttribute("color") == 'eraser')        
          oAllEl[i].outerHTML = oAllEl[i].innerHTML;              
      }
    }
  }
}
//---------------------------------

function TEXTMARK_checkIsTextTarget (el, elID)
//       ~~~~~~~~~~~~~~~~~~~~~~~~~
{ 
	if (el == null)	      
    return null;		
    
  if (el.tagName == null)   
    return null;   
  
	var att = el.getAttribute("id");	     
	if (att == elID)
		return el;    	  
	return TEXTMARK_checkIsTextTarget (el.parentElement, elID);     
}
//________________________________________

function TEXTMARK_GetMarkerText ()
//       ~~~~~~~~~~~~~~~~~~~~~~
{   
  var sElement = TEXTMARK_GetMarkerElement(TEXTMARK_nCurrentMarker, TEXTMARK_sText) 

  var nPos1 = sElement.indexOf(">")
  var nPos2 = sElement.indexOf("</label>")
  return (sElement.substring(nPos1+1, nPos2))        
}
//________________________________________      

function TEXTMARK_GetMarkerElement (nCurPos, sText)
//       ~~~~~~~~~~~~~~~~~~~~~~~~
{         
  var sTempText = sText.toLowerCase();        
  var nEndPos = sTempText.indexOf("</label>", nCurPos)        
  if (nEndPos != -1)
    var sElMarker = sTempText.substring(nCurPos, nEndPos + "</label>".length)        
  else
     sElMarker = "";   
  return  sElMarker
  var nPos1 = sElMarker.indexOf(">")
  var nPos2 = sElMarker.indexOf("</label>")
  return (sElMarker.substring(nPos1+1, nPos2))        
}
//________________________________________      

function TEXTMARK_UpdateTextMarker ()
//       ~~~~~~~~~~~~~~~~~~~~~~~~
{
  var bNewMarkerOpen  = false
  
  var oNextToken = new Object();
  oNextToken.nPos = -1;     
  TEXTMARK_nCurrentMarker = -1;   
  var sCurrentMarkerColor = "";
  var aTokens = new Array("<label", "</label>", "$1$", "$2$")
  while((oNextToken = TEXTMARK_ReadNextToken(aTokens, oNextToken.nPos)).nPos != -1)        
  {     
    if (oNextToken.sTokenType == aTokens[0])
    {             
      TEXTMARK_nCurrentMarker = oNextToken.nPos;                                    
      sCurrentMarkerColor = TEXTMARK_GetCurrentMarkerColor()                                         
      if (bNewMarkerOpen)
      {
        /*Remove Start Marker*/
        var nPosEndOpenMarker = TEXTMARK_sText.indexOf(">", oNextToken.nPos); 
        var sBegin = TEXTMARK_sText.substring(0, oNextToken.nPos)              
        var sEnd = TEXTMARK_sText.substring(nPosEndOpenMarker+1, TEXTMARK_sText.length)              
        TEXTMARK_sText = sBegin + sEnd;                            
      }  
    }
    else if (oNextToken.sTokenType == aTokens[1])
    {                     
      if (TEXTMARK_nCurrentMarker != -1) //end of existing marker    
      {
        if (bNewMarkerOpen)
        {    
          /* Remove End Marker*/                              
          var nPosEndOpenMarker = TEXTMARK_sText.indexOf(">", oNextToken.nPos); 
          var sBegin = TEXTMARK_sText.substring(0, oNextToken.nPos)
          var sEnd = TEXTMARK_sText.substring(nPosEndOpenMarker+1, TEXTMARK_sText.length)
          TEXTMARK_sText = sBegin + sEnd;                                                  
        }
        /* <label1>...</label1><label2>....</label2> */                                                        
        if (TEXTMARK_sText.toLowerCase().indexOf("<label",oNextToken.nPos) == oNextToken.nPos)              
        { 
          if (TEXTMARK_CheckIsMarkerElement(oNextToken.nPos, TEXTMARK_sText) != "")
            oNextToken.nPos -=1;                
        }                
        TEXTMARK_nCurrentMarker = -1;                            
      }
    }             
    else if (oNextToken.sTokenType == aTokens[2])
    {       
      bNewMarkerOpen = true;               
      
      /* Insert Start New Marker (Instead of special sign) */    
      var sBegin = TEXTMARK_sText.substring(0, oNextToken.nPos)          
      var sEnd = TEXTMARK_sText.substring(oNextToken.nPos+aTokens[2].length, TEXTMARK_sText.length)                                  
      if (TEXTMARK_nCurrentMarker != -1)
      { 
        /* <label1>$1$...$2$...</label1>*/                
        var bOverlapping = TEXTMARK_CheckOverLapping(oNextToken.nPos);
        if (bOverlapping)
        { 
          sBegin = sBegin.substring(0, TEXTMARK_nCurrentMarker)                                
          var sNewMarker = TEXTMARK_GetNewMarker(TEXTMARK_sCurColor)          
          TEXTMARK_sText = sBegin + sNewMarker + sEnd;                                                                                   
          var sLen = TEXTMARK_GetNewMarker(TEXTMARK_sCurColor)
          oNextToken.nPos = TEXTMARK_nCurrentMarker          
        }
        else
        {
          TEXTMARK_sText = sBegin + "</label>" + TEXTMARK_GetNewMarker(TEXTMARK_sCurColor) + sEnd;                   
          oNextToken.nPos += "</label>".length;
        }
      }
      else
      {
        TEXTMARK_sText = sBegin + TEXTMARK_GetNewMarker(TEXTMARK_sCurColor) + sEnd;                                                                                 
      } 
    }
    else if (oNextToken.sTokenType == aTokens[3])
    { 
      /* Insert End New Marker */    
      var sBegin = TEXTMARK_sText.substring(0, oNextToken.nPos)
      var sEnd = TEXTMARK_sText.substring(oNextToken.nPos+aTokens[3].length , TEXTMARK_sText.length)            
      if (TEXTMARK_nCurrentMarker != -1)
      {
        /* new marker that covers 2 tangent markers  */
        if (TEXTMARK_sText.toLowerCase().indexOf(aTokens[1], oNextToken.nPos) == (oNextToken.nPos + oNextToken.sTokenType.length))
        {
          sEnd = TEXTMARK_sText.substring(oNextToken.nPos + oNextToken.sTokenType.length + aTokens[1].length, TEXTMARK_sText.length )
          TEXTMARK_sText = sBegin + "</label>" +  sEnd;  
        }
        else
        {  
          /* Insert Start Marker for TEXTMARK_nCurrentMarker */                            
          TEXTMARK_sText = sBegin + "</label>" + TEXTMARK_GetNewMarker(sCurrentMarkerColor) + sEnd;  
        }
      }             
      else
      {               
        TEXTMARK_sText = sBegin + "</label>" +  sEnd;  
      }
      return TEXTMARK_sText;
    }           
  }
  return TEXTMARK_sText;        
}
//---------------------------------

function TEXTMARK_CheckNewMarkerOverLapSimpleMarker (nCurPos)
//       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
{
  var sBegin = TEXTMARK_sText.substring(0, nCurPos+1);
  if (sBegin.indexOf(">")+1 == nCurPos)
  {
    var sEl = sBegin.substring(sBegin.indexOf("<label"),sBegin.indexOf(">"));          
    if (sEl.indexOf(">") == -1)  /* Block with LABEL - NOT marker LABEL*/
    {             
      return sBegin.toLowerCase().indexOf("<label");
    }  
    else
      return -1;              
  }           
  return -1;
}
//---------------------------------      

function TEXTMARK_CheckOverLapColor (nCurPos)
//       ~~~~~~~~~~~~~~~~~~~~~~~~
{
  var sBegin = TEXTMARK_sText.substring(0, nCurPos+1);
  if (sBegin.indexOf("<label") != -1)
  {
    if (TEXTMARK_CheckIsMarkerElement(sBegin.indexOf("<label"), TEXTMARK_sText) != "")
      TEXTMARK_GetMarkerElement(sBegin.indexOf("<label"), TEXTMARK_sText)
    var sEl = sBegin.substring(sBegin.indexOf("<label"),sBegin.indexOf(">"));          
    if (sEl.indexOf(">") == -1)  /* Block with LABEL - NOT marker LABEL*/
    {             
      return sBegin.toLowerCase().indexOf("<label");
    }  
    else
      return -1;              
  }           
  return -1;
}
//---------------------------------      

function TEXTMARK_CheckOverLapping ()
//       ~~~~~~~~~~~~~~~~~~~~~~~
{
  /* <label1>...</label1>$1$...$2$*/                
  if (TEXTMARK_CheckIsMarkerElement(TEXTMARK_nCurrentMarker, TEXTMARK_sText) != "")
  {   
    var sElement = TEXTMARK_GetMarkerElement(TEXTMARK_nCurrentMarker, TEXTMARK_sText);          
    if (sElement.charAt(sElement.indexOf(">") + 1) == "$")
      return true
    else
      return false                
  }
  else
    return false;
}
//---------------------------------

function TEXTMARK_CheckIsMarkerElement (nPos, sText)
//       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
{         
  var sMarker = TEXTMARK_GetMarkerElement(nPos, sText);                 
  return TEXTMARK_GetAttribValue(sMarker, "color");        
}
//---------------------------------

function TEXTMARK_ReadNextToken (aTokens, nStartPos)
//       ~~~~~~~~~~~~~~~~~~~~~
{
  var nCurPos = 0          
  var bFound = false
  var nPos = 0;      
  var oNextToken = new Object();                        
  oNextToken.nPos = -1;
  
  var sTempText = TEXTMARK_sText.toLowerCase();        
  var nTempPos = -1;     
              
  for (var i=0; i<aTokens.length; i++)        
  {           
    var nPos = sTempText.indexOf(aTokens[i].toLowerCase(), nStartPos+1);          
    if (nPos != -1)
    { 
      if (aTokens[i] == "<label")
      {
        if (TEXTMARK_CheckIsMarkerElement(nPos, TEXTMARK_sText) == "")
        {                 
          continue;               
        }  
      }
      //debug1.value +=  aTokens[i] + nPos + "\n"   
      
      if (nTempPos != -1)
      {
        if ( nPos < nTempPos )
        {
          nTempPos = nPos
          oNextToken.sTokenType = aTokens[i];     
          oNextToken.nPos = nTempPos;                                     
        }            
      }
      else
      {
        oNextToken.sTokenType = aTokens[i];     
        oNextToken.nPos = nPos;                                     
        nTempPos = nPos            
      }
    }          
  }  
  //debug1.value += "chosen: " +  oNextToken.sTokenType + "\n"             
  
  return oNextToken;
}
//---------------------------------

function TEXTMARK_GetCurrentMarkerColor ()
//       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
{
  var sMarkerElement = TEXTMARK_GetMarkerElement (TEXTMARK_nCurrentMarker, TEXTMARK_sText);
  return TEXTMARK_GetAttribValue(sMarkerElement, "color");
}
//---------------------------------

function TEXTMARK_GetNewMarker (sColor)
//       ~~~~~~~~~~~~~~~~~~~~~
{   
  if (sColor.toLowerCase() == "delete")
  {
     //var sNewMarker = "<label id=\"marker\" color=\"" + sColor + "\" style=background-color:''" + " CLASS=\"MarkerDelete\">";               
     var sNewMarker = "<label id=\"marker\" color=\"" + sColor + "\" CLASS='MarkerDelete'>";                 
  }   
  else
    var sNewMarker = "<label id=\"marker\" color=\"" + sColor + "\" style=background-color:'" + sColor + "'>";               
  return sNewMarker; 
}
//---------------------------------      
      
function TEXTMARK_GetAttribValue(sElement, sAttrib)
//       ~~~~~~~~~~~~~~~~~~~~~~
{
  var sElement = sElement.toLowerCase()
  sAttrib  = " " + sAttrib.toLowerCase() + "="
  nPos = sElement.indexOf(sAttrib)
  if (nPos == -1)
    return "";
  nPos += sAttrib.length
  if (sElement.charAt(nPos) == '"')
    nPos++
  sValue = ""
  while ('" />'.indexOf(sElement.charAt(nPos)) == -1)
    sValue += sElement.charAt(nPos++)
  return sValue;
}
//-------------------------------------------------------