// Copyright (C) 2007 Alan Ardzinov, Saint-Petersburg, Russia 
// http://www.terchy.com, ardalan@mail.ru, ICQ 56320602

/*
function asd(sName, sValue, bShowType, bInAlert, bDo)
function is_array (vValue)
function s_AddLeadSymbols(sStr, sSymbol, iTotalLength)
function s_AddLeadZeros(sStr, iTotalLength)
function s_AddParamToQS(sQS, sParamName, sParamValue)
function s_AreAllSymbolsInRange(sStr, sRange, bCaseSens)
function s_Char (sLetter)
function s_CutPrefix(sValue, sPrefix)
function s_CutStringFromLeft(sString, sStringToCut)
function s_CutStringFromRight(sString, sStringToCut, bCase)
function s_GetBetweenBrakets(sWhere, sLeftBraket, sRightBraket, iStart)
function s_GetChar (iNum)
function s_GetParamFromQueryString (sParam, sQS)
function s_GetParamFromStr(sStr, sParamName, sSepar)
function s_GetParamParesArrayFromString(sStr, sSepar)
function s_GetPrefix(sValue, sPrefix)
function s_GetRandomParamForQS()
function s_GetTextParams(sText)
function s_GetToken (sStr, sToken)
function s_Init (sValue, sAlter)
function s_InStr(sWhere, sWhat, iStart, bCaseSens)
function s_InStrRev(sWhere, sWhat, iStart, bCaseSens)
function s_IsDef(vValue)
function s_IsLeft (sWhere, sWhat)
function s_IsRight(sString, sStringToCompare, bCase)
function s_IsUndef(vValue)
function s_Left (sStr, iNum)
function s_CutAndAddIfCutted(sStr, iLength, sAdd)
function s_Len (sStr)
function s_Mid (sStr, iStart, iNum)
function s_RemoveLeadSymbols(sString, sSymbol)
function s_RemoveLeadZeros(sString)
function s_Repeat (sStr, iCount)
function s_Replace(sWhere, sWhat, sToWhat, iStart, iCount, bCaseSens)
function s_ReplaceFromTo(sWhere, iFrom, iTo, sTo)
function s_ReplaceToSubString(sWhere, sSubstring, sTo, bCaseSens)
function s_Reverse (sStr)
function s_Right (sStr, iNum)
function s_Split(sStr, sSepar)

*/
var gsStr;
var sSTR_UNDEF = "undefined";
var bSTR_CASESENSITIVE = true;
var sSTR_FROMRIGHT = "sSTR_FROMRIGHT";

/* indexes of array for text parameters */
var iSTR_TEXT_ROWS = 1;
var iSTR_TEXT_MAXROWLEN = 2;

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

function s_GetRandomParamForQS()
{
  sRandomName   = Math.random();
  sRandomValue  = Math.random();
  return sRandomName + "=" +sRandomValue;
}


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

function s_ReplaceFromTo(sWhere, iFrom, iTo, sTo)
{
  iTo = s_Init(iTo, iFrom);
  sTo = s_Init(sTo, ""); 
  sStr = s_Left(sWhere, iFrom - 1) + sTo + s_Mid(sWhere, iTo + 1);
  return sStr;
}

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

function s_Split(sStr, sSepar)
{
  if (sStr == "") {return "";}

  sSepar = s_Init(sSepar, "");

    
  if (sSepar == "") 
  {
    var aArray = new Array();
    for (i = 0; i < sStr.length; i++)
    {
      aArray[i + 1] = sStr.charAt(i);
    }   
    return aArray;
  }
  
  return sStr.split(sSepar);
  
}

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

function s_Reverse (sStr)
{
  var aArray = new Array();
  aArray = s_Split(sStr);
  aArray = aArray.reverse();
  sStr = aArray.join(""); 
  return sStr;
}

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

function s_InStrRev(sWhere, sWhat, iStart, bCaseSens)
{
  sWhere = s_Reverse(sWhere);
  sWhat = s_Reverse(sWhat);
  iPos = s_InStr(sWhere, sWhat, iStart, bCaseSens);
/*  alert(iPos);*/
  if (iPos > 0) {iPos = s_Len(sWhere) + 2 - iPos - s_Len(sWhat);}
  return iPos;
}

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

function s_Char (sLetter)
{
  return sLetter;
}  

//--------------------------------------------------------------
  
function s_GetChar (iNum)
{
  var L;
  L = '@abcdefghijklmnopqrstuvwxyz_';
  return L.charAt(iNum);
}
// -----------------------------------------------------

function s_GetToken (sStr, sToken)
{
  var bFromRight = s_GetPrefix(sStr, sSTR_FROMRIGHT);
  if (bFromRight) {sStr = s_CutPrefix(sStr, sSTR_FROMRIGHT); }
  
  var k;
  
  if (bFromRight) 
  {
    k = s_InStrRev(sStr, sToken);
  }
  else
  {
    k = sStr.indexOf (sToken, 0);
  }

  if (k == -1)
  {
    gsStr = "";
    return sStr;
  }
  else
  {
    if ( bFromRight ) 
    {
      gsStr = s_Left(sStr, k);
      return (s_Mid(sStr, k + sToken.length));
    }
    else
    {
      gsStr = s_Mid(sStr, k + sToken.length + 1);
      return (s_Left(sStr, k));
    }
  }
}

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

function s_RemoveLeadSymbols(sString, sSymbol)
{
//alert("sSymbol=" + sSymbol)
  if (sSymbol == "") {return sString;}
  
  while( s_IsLeft(sString, sSymbol))
    sString = s_CutStringFromLeft(sString, sSymbol);
  
  return sString;
}

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

function s_RemoveLeadZeros(sString)
{
  sString = s_RemoveLeadSymbols(sString, "0");
  if( sString == "" ){ sString = "0"; }
  
  return sString;
}

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

function s_Repeat (sStr, iCount)
{
  sRes = "";
  for (i = 1; i <= iCount; i++)
  {
    sRes += sStr;
  }
  
  return sRes;
}

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

function s_AddLeadSymbols(sStr, sSymbol, iTotalLength)
{
  //это важно, т.к. острочивает sStr, которое может быть передано
  //и как число
  oStr = new String (sStr);

  iAddCount = iTotalLength - oStr.length;
  if (iAddCount > 0)
  {
    oStr = s_Repeat(sSymbol, iAddCount) + oStr;
  }
  return oStr; 
}

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

function s_AddLeadZeros(sStr, iTotalLength)
{
  return s_AddLeadSymbols(sStr, "0", iTotalLength);
}

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

function s_Init (sValue, sAlter)
{
  if (typeof(sAlter)  == "undefined") {sAlter = false;}
  if (typeof(sValue)  == "undefined") {sValue = sAlter;}
  return sValue;
}

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

function is_array (vValue)
{
  // нерациональная запись 
//  if (typeof(vValue[0]) != "undefined"){return true;} else {return false;}
  
  //рационаьно:
  return (typeof(vValue[0]) != "undefined");
}


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

function asd(sName, sValue, bShowType, bInAlert, bDo)
{
//bShowType - показывать ли тип параметра sValue

//bInAlert : true  - выводить a алерт
//           false - (или не задано) - выводить в текст документа
//           1     - не выводить, готовить к выводу в алерте  
//           0     - не выводить, готовить к выводу в текст документа 


//  это меняем на вызов ф. s_Init()
//  if (typeof(bInAlert)  == "undefined") {bInAlert = false;}
  bDo = s_Init(bDo);
  bInAlert = s_Init(bInAlert);
  bShowType = s_Init(bShowType);

  if (!bDo) {return;}
  
  if (typeof(sValue) == "undefined")
  {
    sValue = "значение не задано";
  }
  
  var sStr;
  
  if (!bShowType)
  {
    sStr = sValue;
  }
  else
  {
    switch (typeof(sValue)) 
    {
      case "undefined":
      alert("");
        sType = "неопределенный";
        sValue = "значение не задано";
        break;
      case "number":
        sType = "число";
        break;
      case "string":
        sType = "строка";
        break;
      case "boolean":
        sType = "логический";
        break;
      case "object":
        sType = "объект";
        break;
      case "function":
        sType = "функция";
        break;
    }
    sStr = sValue + "(" + sType + ")";
  }


  if (!is_array(sValue))
  {
    //описываем сначала отрицание т.к. оно короче
    sStr = sName + "=" + sStr + "<br>";
  }
  else
  {
    sArrayHeader = "=============== массив " + sName + ", элементов: " + sValue.length + " =================<br>";
    sStr = sArrayHeader;
    var i;
    for (i = 0; i < sValue.length; i++)
    {
      sStr += "[" + i + "]" + " = " + sValue[i] + "<br>";
    }
    sStr += sArrayHeader;
    document.write(sStr);
  }
  

  if ( typeof(bInAlert) == "number")
  {
    //вывод не предусмотрен, просто подготавливаем строку

    if ( bInAlert == 1)// для последующего вывода в алерте
    {
      sStr = s_Replace (sStr, "<br>", "\n");
    }

    return sStr;
  }
  else
  {
    if (bInAlert)
    {
      sStr = s_Replace (sStr, "<br>", "\n");
      alert(sStr);
    }
    else
    {
      document.write(sStr);
    }
  }
  
}

// -----------------------------------------------------
function s_Len (sStr)
{
  oStr = new String (sStr);
  return oStr.length;
}

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

function s_Left (sStr, iNum)
{
  return sStr.substring(0, iNum);
}

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

function s_Right (sStr, iNum)
{
  return sStr.substring(sStr.length - iNum, sStr.length);
}

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

function s_Mid (sStr, iStart, iNum)
{
  //это важно, т.к. острочивает sStr, которое может быть передано
  //и как число
  oStr = new String (sStr);

  iStart = iStart - 1;
  if (iNum == -1 || iNum == 0 || typeof(iNum) == 'undefined')
  {
    iNum = oStr.length; 
  }
  else
  {
    iNum = iStart + iNum; 
  }
  
  return oStr.substring(iStart, iNum);
}

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

function s_GetPrefix(sValue, sPrefix)
{
  if (s_Left(sValue, sPrefix.length) == sPrefix)
  {
    return true;
  }
  else
  {
    return false;
  }
}

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

function s_CutPrefix(sValue, sPrefix)
{
  if (s_GetPrefix(sValue, sPrefix))
  {return s_Mid(sValue, sPrefix.length + 1, -1);}
  else
  {return sValue;}
}

//------------------------------------------------------
function s_InStr(sWhere, sWhat, iStart, bCaseSens)
{
  //LM: 2007-01-29.
  
  
  iStart = s_Init(iStart, 1);
  if (iStart == 0) {iStart = 1;}
  bCaseSens = s_Init(bCaseSens, false);
  oWhere = new String (sWhere);
  oWhat = new String (sWhat);
  
  if (!bCaseSens) 
  {
    oWhere = oWhere.toUpperCase();
    oWhat = oWhat.toUpperCase();
  }
  
  iPos = oWhere.indexOf(oWhat, iStart - 1);
  if (iPos >= 0)
  {iPos++;}
  else
  {iPos = 0;}
  
  return iPos;
}

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

function s_Replace(sWhere, sWhat, sToWhat, iStart, iCount, bCaseSens)
{
  
  iStart = s_Init(iStart, 1);
  if (iStart == 0) {iStart = 1;}
  iCount = s_Init(iCount, 0);
  bCaseSens = s_Init(bCaseSens, false);//пока не используется
  
  oWhere = new String (sWhere);
  oWhat = new String (sWhat);
  oToWhat = new String (sToWhat);

  var k1 = iStart;
  var sStr = oWhere;
  var bF = true;
  var iReplacedCount = 0;
  
  while (bF)
  {
    k1 = s_InStr(sStr, oWhat, k1, bCaseSens)

    if (k1 > 0 )
    {
      if (k1 > 1)
      {
        sStrBefore = s_Left (sStr, k1 - 1);
      }
      else
      {
        sStrBefore = "";
      }
      
      sStr = sStrBefore + oToWhat + s_Mid (sStr, k1 + oWhat.length);

      iReplacedCount ++;

      k1 = k1 + oToWhat.length;

      if (iCount > 0) 
      { 
        if ( iReplacedCount >= iCount ) {bF = false;}
      }
    }
    else
    {
      bF = false;
    }
  }
  
  return sStr;
 
}

//--------------------------------------------------------------
function s_GetParamParesArrayFromString(sStr, sSepar)
{
  aParamsPares = new Array();
  aParamsPares = sStr.split(sSepar);
  return aParamsPares;
}

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

function s_GetParamFromStr(sStr, sParamName, sSepar)
{
  aParamsPares = new Array();
  aParamsPares = s_GetParamParesArrayFromString (sStr, sSepar);

  
  k = aParamsPares.length;

  if (k < 1)
  {
    return "";
  }
  else
  {
    aParams = new Array();
    for (i = 0; i < aParamsPares.length; i++)
    {
      aParams = aParamsPares[i].split("=");

      if (aParams.length == 2 )
      {
        if (aParams[0] == sParamName)
        {
          return aParams[1];
        }
      }

    }
    return "";
  }
}

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

function s_GetParamFromQueryString (sParam, sQS)
{
  sQS = s_Init (sQS, location.search);

  if ( s_Left(sQS, 1) == "?")
  {
    sQS = s_Mid(sQS, 2);
  }
  
  return s_GetParamFromStr (sQS, sParam, "&");
}

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

function s_AddParamToQS(sQS, sParamName, sParamValue)
{
  var sConnector;
  sParamValue = s_Init(sParamValue, "");
  sConnector = (s_InStr(sQS, "?") > 0 ) ? "&" : "?";

  sQS += sConnector + sParamName;

  if (sParamValue != "") {sQS += "=" + sParamValue;}
  return sQS;    
}

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

function s_IsLeft (sWhere, sWhat, bCaseSens)
{
  bCaseSens = s_Init( bCaseSens, true );
  
  if ( bCaseSens ) 
  { return s_Left(sWhere, s_Len(sWhat)) == sWhat; }
  else
  { 
    sCompareString = sWhere.toUpperCase();
    return s_Left(sCompareString, s_Len(sWhat)) == sWhat.toUpperCase(); 
  }
  
}

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

function s_CutStringFromRight(sString, sStringToCut, bCase)
{
  bCase = s_Init(bCase, true);
  if (s_IsRight(sString, sStringToCut, bCase))
  {
    return s_Left(sString, s_Len(sString) - s_Len(sStringToCut));
  }
  return sString;
}

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

function s_CutStringFromLeft(sString, sStringToCut, bCaseSens)
{
  bCaseSens = s_Init(bCaseSens, true);
  
  if (s_IsLeft(sString, sStringToCut, bCaseSens))
  {
    return s_Mid(sString, s_Len(sStringToCut) + 1);
  }
  return sString;
}

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

function s_IsRight(sString, sStringToCompare, bCase)
{
  bCase = s_Init(bCase, true);
  
  var sStr = s_Right(sString, s_Len(sStringToCompare));
  if (bCase) 
  {
    return sStr == sStringToCompare;
  }
  else
{
    return sStr.toUpperCase() == sStringToCompare.toUpperCase();
  }
}
 
 
//--------------------------------------------------------------

function s_IsDef(vValue)
{
//unusable
  return typeof(vValue) == "undefined";
}

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

function s_IsUndef(vValue)
{
//unusable
  return !s_IsDef(vValue);
}

/*---------------------------------------------------------*/

function s_GetBetweenBrakets(sWhere, sLeftBraket, sRightBraket, iStart)
{
  var aRes = new Array();
  aRes[1] = "";
  aRes[2] = 0;
  
  
  iStart = s_Init(iStart, 0);  
  if (typeof(sLeftBraket) == sJS_TYPE_UNDEF) {return "";}
  sRightBraket = s_Init(sRightBraket, sLeftBraket);

  var iBegPos = s_InStr(sWhere, sLeftBraket, iStart);
  if (iBegPos == 0) {return aRes;}
  iBegPos = iBegPos + s_Len(sLeftBraket);
  
  var iEndPos = s_InStr(sWhere, sRightBraket, iBegPos);
  if (iEndPos == 0) {return aRes;}
  
  aRes[2] = iEndPos + s_Len(sRightBraket);
  
  if (iBegPos == iEndPos) {return aRes;}
  aRes[1] = s_Mid(sWhere, iBegPos, iEndPos - iBegPos)
  return aRes;  
  
}
/*---------------------------------------------------------*/

function s_ReplaceToSubString(sWhere, sSubstring, sTo, bCaseSens)
{
  bCaseSens = s_Init(bCaseSens, false);
  var bFromRight = s_GetPrefix(sWhere, sSTR_FROMRIGHT);
  if (bFromRight) {sWhere = s_CutPrefix(sWhere, sSTR_FROMRIGHT); }

  var i = 0;
  if (bFromRight) 
  {
    i = s_InStrRev(sWhere, sSubstring, 0, bCaseSens);
    if (i == 0) {return sWhere;}
    return s_Left(sWhere, i - 1 + s_Len(sSubstring)) + sTo;
  }
  else
  {
    i = s_InStr(sWhere, sSubstring, 0, bCaseSens);
    if (i == 0) {return sWhere;}
    return sTo + s_Mid(sWhere, i);
  }
  
}

/*---------------------------------------------------------*/
function s_CutAndAddIfCutted(sStr, iLength, sAdd)
{
  sAdd = s_Init(sAdd, " ...");
  if (s_Len(sStr) > iLength)
  {
    sStr = s_Left(sStr, iLength) + sAdd;
  }
  return sStr;
}

/*---------------------------------------------------------*/

function s_chr(vCode)
{

//alert(vCode);

  if (!s_IsNumeric(vCode)) 
  {
    var aArray = new Array();
    aArray = s_Split (vCode, "&#");

//alert(aArray + "\r\n" + aArray.length + "\r\n" + aArray[1]);

    if (aArray.length > 1) 
    {
      var sStr = "";
      for (i = 0; i < aArray.length; i++)
      {
        if (aArray[i] != "") 
        {
          sStr = sStr + s_chr(aArray[i]);
        }
      }
      return sStr;
    }
    
    if ( s_IsLeft (vCode + "", "&#") ) 
    {
      vCode = s_Mid(vCode, 3);
    }
    
    if (!s_IsNumeric(vCode)) 
    {
      return "";
    }
  }
  
  return String.fromCharCode(vCode);
}

/*---------------------------------------------------------*/

function s_IsNumeric( mixed_var ) {
    // http://kevin.vanzonneveld.net
    // +   original by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
    // +   improved by: David
    // +   improved by: taith
    // +   bugfixed by: Tim de Koning
    // *     example 1: is_numeric(186.31);
    // *     returns 1: true
    // *     example 2: is_numeric('Kevin van Zonneveld');
    // *     returns 2: false
    // *     example 3: is_numeric('+186.31e2');
    // *     returns 3: true
    // *     example 4: is_numeric('');
    // *     returns 4: false
 
    if (mixed_var === '') 
    {
      return false;
    }
 
    return !isNaN(mixed_var * 1);
}

/*---------------------------------------------------------*/

function s_AreAllSymbolsInRange(sStr, sRange, bCaseSens)
{
  bCaseSens = s_Init ( bCaseSens, false );
  
  for (i = 0; i < sStr.length; i++)
  {
    if ( s_InStr( sRange, sStr.charAt(i), 1, bCaseSens ) == 0) 
    {
      return false;
    }
  }
  return true;  
}

/*---------------------------------------------------------*/


function s_GetTextParams( sText )
{
  var aParams = new Array();
  if ( sText == "" ) {return false;}
  
  var aRows = s_Split ( sText, "\r" );
  
  aParams[ iSTR_TEXT_ROWS ] = aRows.length;

  var iMaxLen = 0;
  for (i = 0; i < aRows.length; i++)
  {
    if ( iMaxLen < aRows[ i ].length ) 
    {
      iMaxLen = aRows[ i ].length;
    }
  }

  aParams[ iSTR_TEXT_MAXROWLEN ] = iMaxLen;
  return aParams;
}