// VSPageTools.js general toolkit file
// ------------------------------------------------------------
// namespace Viasoft
// Written by Viasoft Ltd. (viasoft.com.ua)
// Free permission to use granted under BSD licence

// *** Browser detection ***

function isNavigatorIE()
 {
  var ver = navigator.appVersion;
  
  if (window.opera != null)
   {
    return(false); // Opera found
   }
  else if (ver.indexOf("MSIE") >= 0)
   {
    return(true); // Found
   }
  else
   {
    return(false); // Not found
   }
 }
 
function isNavigatorFF()
 {
  var ver = navigator.userAgent;
  
  if (ver.indexOf("Firefox") >= 0)
   {
    return(true); // Found
   }
  else
   {
    return(false); // Not found
   }
 }
 
function isNavigatorOpera()
 {
  if (window.opera != null)
   {
    return(true); // Found
   }
  else
   {
    return(false); // Not found
   }
 }

function isNavigatorEngineGecko()
 {
  var client = navigator.userAgent;

  if (client.indexOf("Gecko") >= 0)
   {
    return(true);
   }
  else
   {
    return(false);
   }
 }

function isNavigatorEngineAppleWebKit()
 {
  var client = navigator.userAgent;

  if (client.indexOf("AppleWebKit") >= 0)
   {
    return(true);
   }
  else
   {
    return(false);
   }
 }
 
function getNavigatorVersionIE()
 {
  // Based in code from MSDN
  // Returns the version of Internet Explorer (as floating point number) or a -1
  // (indicating the use of another browser).
  
  var rv = -1; // Return value assumes failure.

  if (navigator.appName == 'Microsoft Internet Explorer')
   {
    var ua = navigator.userAgent;
    var re  = new RegExp("MSIE ([0-9]{1,}[\.0-9]{0,})");

    if (re.exec(ua) != null)
     {
      rv = parseFloat( RegExp.$1 );
     }
   }
   
  return rv;
 }

// *** General String Toolkit ***

function StrReplace(InputStr,FromStr,ToStr)
 {
  var FromPos;
  var FoundPos;
  var ResultStr;

  FromPos   = 0;
  FoundPos  = InputStr.indexOf(FromStr);
  ResultStr = "";

  if (FoundPos < 0)
   {
    ResultStr = InputStr; // NotFound
   }
  else
   {
    while(FoundPos >= 0)
     {
      ResultStr += InputStr.substring(FromPos,FoundPos);
      ResultStr += ToStr;

      FoundPos  += FromStr.length;

      FromPos    = FoundPos;
      FoundPos   = InputStr.indexOf(FromStr,FoundPos);
     }

    ResultStr += InputStr.substring(FromPos,InputStr.length);
   }

  return(ResultStr);
 }

function StrInsert(InputStr,FragmentStr,FragmentPos)
 {
  var Result = "";
  var InputLength = InputStr.length;
  
  if (FragmentPos < 0)
   {
    Result += FragmentStr;
    Result += InputStr;
   }
  else if (FragmentPos < InputLength)
   {
    Result += InputStr.substring(0,FragmentPos);
    Result += FragmentStr;
    Result += InputStr.substring(FragmentPos,InputLength);
   } 
  else
   {
    Result += InputStr;
    Result += FragmentStr;
   }
  
  return(Result);
 }
 
function StrLTrim(value)
 {
  return value.replace( /(^\s*)/g, '' );
 }

function StrRTrim(value)
 {
  return value.replace( /(\s*$)/g, '' );
 }

function StrTrim(value)
 {
  return value.replace( /(^\s*)|(\s*$)/g, '' );
//return StrRTrim(StrLTrim(value));
 }

function StrNormalizeSpace(value)
 {
  return StrTrim(value.replace( /(\s{2,})/g, ' ' ));
 }
 
function StrIsInteger(InputStr)
 {
  if (InputStr == null)
   {
    return(false);
   }
   
  InputStr = InputStr.toString();
   
  var value = parseInt(InputStr,10);
  
  if (isNaN(value))
   {
    return(false); // Non a number
   }
  else if ((value.toString()) != (InputStr))
   {
    return(false); // Not exactly match source representation
   }
  else if ((InputStr.indexOf('.') >= 0) || (InputStr.indexOf('e') >= 0) || (InputStr.indexOf('E') >= 0))
   {
    return(false); // Float
   }
  else
   {
    return(true); // Integer
   }
 }
 
function StrIsStartsWith(InputStr,CheckStr)
 {
  if ((InputStr == null) || (CheckStr == null))
   {
    return(false);
   }
   
  InputStr = ''+InputStr;
  CheckStr = ''+CheckStr;
  
  if (InputStr.length < CheckStr.length)
   {
    return(false);
   }
   
  if (InputStr.substring(0,CheckStr.length) == CheckStr)
   {
    return(true);
   }
  else
   {
    return(false);
   }
 }

function StrIsEndsWith(InputStr,CheckStr)
 {
  if ((InputStr == null) || (CheckStr == null))
   {
    return(false);
   }
   
  InputStr = ''+InputStr;
  CheckStr = ''+CheckStr;
  
  if (InputStr.length < CheckStr.length)
   {
    return(false);
   }
   
  if (InputStr.substring(InputStr.length - CheckStr.length,InputStr.length) == CheckStr)
   {
    return(true);
   }
  else
   {
    return(false);
   }
 }

// *** String Toolkit ***

function StrText2HTML(Str)
 {
  if (Str == undefined)
   {
    return(undefined); // Bug trap
   }
   
  if (Str == null) 
   {
    return(null); // Bug trap
   }
   
  var ResultStr = Str+""; // Force string type
  
  ResultStr = ResultStr.replace(/&/gi   ,"&amp;");
  ResultStr = ResultStr.replace(/>/gi   ,"&gt;");
  ResultStr = ResultStr.replace(/</gi   ,"&lt;");
//ResultStr = ResultStr.replace(/"/gi   ,"&quot;"); // Will confuse syntax parsers and comment strippers
  ResultStr = ResultStr.replace(/\u0022/gi,"&quot;");

//ResultStr = ResultStr.replace(/'/gi   ,"&apos;"); // Do not work under IE
//ResultStr = ResultStr.replace(/'/gi   ,"&#39;"); // Will confuse syntax parsers and comment strippers
  ResultStr = ResultStr.replace(/\u0027/gi,"&#39;");
  
  return ResultStr;
 }
 
function StrText2HTMLWithLn(Str)
 {
  if (Str == undefined)
   {
    return(undefined); // Bug trap
   }
   
  if (Str == null) 
   {
    return(null); // Bug trap
   }
   
  var ResultStr = StrText2HTML(Str);
  
  ResultStr = ResultStr.replace(/\n/gi,"<br/>\n");
   
  return(ResultStr);
 }
 
function StrText2JsText(Str)
 {
  // Subset. Only entities parsed
  
  if (Str == undefined)
   {
    return(undefined); // Bug trap
   }
   
  if (Str == null) 
   {
    return(null); // Bug trap
   }
   
  var ResultStr = Str+""; // Force string type
  
  ResultStr = StrReplace(ResultStr,"\\", "\\\\"); // plain slashes to slashes
  ResultStr = StrReplace(ResultStr,"\r", "\\r");  // 0x0a to \r
  ResultStr = StrReplace(ResultStr,"\n", "\\n");  // 0x0d to \n
  ResultStr = StrReplace(ResultStr,"\t", "\\t");  // TAB to \t
  //This is simple solution, but requires that programmer do things right
//ResultStr = StrReplace(ResultStr,"\"", "\\\""); // " to \"
//ResultStr = StrReplace(ResultStr,"\'", "\\\'"); // ' to \'
  //More robust to programmer errors version:
  //This can be safely put in <a href="javascript:">
  //Even if someone will fogot to pass HTML encode over it
  ResultStr = StrReplace(ResultStr,"\"", "\\x22"); // " to \x22 
  ResultStr = StrReplace(ResultStr,"\'", "\\x27"); // ' to \x27
  ResultStr = StrReplace(ResultStr,"&" , "\\x26"); // & to \x26
  ResultStr = StrReplace(ResultStr,"<" , "\\x3C"); // < to \x3C
  ResultStr = StrReplace(ResultStr,">" , "\\x3E"); // < to \x3E
  
  return ResultStr;
 }
 
function StrFormat(FormatStr)
 {
  // Very simplfied version of .NET string.Format
  // (Note if some replace string will contains "{n}" it will be substituted also)
  // Generaly, intended to use with numeric args only
  var result = FormatStr;
  var startIndex = 1; // Args are start from 1 (first arg is FormatStr)
  var i;
  
  //i.up(); // Force debug
  
  for (i = startIndex; i < arguments.length; i++)
   {
    result = StrReplace(result,"{"+(i-startIndex)+"}",arguments[i] + "");
   }
   
  return(result);
 }
 
// *** Some obsolete aliases: ***

var StringLTrim          = StrLTrim;
var StringRTrim          = StrRTrim;
var StringTrim           = StrTrim;
var StringNormalizeSpace = StrNormalizeSpace;
var StringFormat         = StrFormat;
 
// *** Event proccessing toolkit ***

function CancelEvent(e)
 {
  if (e == null)
   {
    return; // Bug trap
   }
   
  //IE only  
  //window.event.cancelBubble = true;
  //window.event.returnValue  = false;

  if (e.cancelBubble != null)
   {
    //IE
    e.cancelBubble = true;
   }

  if (e.stopPropagation != null)
   {
    //Another DOM compilant browser
    e.stopPropagation();
   }

  if (e.preventDefault != null)
   {
    //Another DOM compilant browser
    e.preventDefault();
   }
  else
   {
    //IE
    e.returnValue = false;
   }
 }

function StopEventBubble(e)
 {
  if (e == null)
   {
    return; // Bug trap
   }
   
  //IE only  
  //window.event.cancelBubble = true;
  //window.event.returnValue  = false;

  if (e.cancelBubble != null)
   {
    //IE
    e.cancelBubble = true;
   }

  if (e.stopPropagation != null)
   {
    //Another DOM compilant browser
    e.stopPropagation();
   }
 }

function GetEventTarget(e)
 {
  if (e == null)
   {
    return null;
   }

  var result = null;
  
  if (e.srcElement)
   {
    result = e.srcElement; // IE
   }
  else
   {
    result = e.target;

    if (result != null)
     {
      if (result.nodeType == 3) // defeat Safari bug
       {
        result = result.parentNode;
       }
     }
   }

  return(result);
 }

// *** Page url arg toolkit ***

function QueryStringItem(name,value)
 {
  this.name  = name;
  this.value = value;
 }
 
function QueryStringParseToItemsArray(queryString)
 {
  var args = new Array(  );
  
  if ((queryString == null) || (queryString == ''))
   {
    return(args); // Return empty array if no query
   }
  
  var query = queryString.substring(1);      // Get query string body
  var pairs = query.split("&");              // Break at "&"
  
  for(var i = 0; i < pairs.length; i++) 
   {
    var pos = pairs[i].indexOf('=');          // Look for "name=value"
    
    var argname  = null;
    var argvalue = null;
    
    if (pos == -1) 
     {
      // If not found, use null as value
      argname  = pairs[i];
      argvalue = null;
     }
    else
     {
      argname  = pairs[i].substring(0,pos); // Extract the name
      argvalue = pairs[i].substring(pos+1); // Extract the value
      // In JavaScript 1.5, use decodeURIComponent(  ) instead of unescape(  )
      argvalue = unescape(argvalue);
     }
     
    args[args.length] = new QueryStringItem(argname,argvalue);
   }
  
  return args;                                  // Return the object
 }
 
function QueryStringArrayCreate()
 {
  return(new Array());
 }
 
function QueryStringMakeByItemsArray(args)
 {
  if ((args == null) || (args.length <= 0))
   {
    return('');
   }
   
  var query = '?';
  
  for(var i = 0; i < args.length; i++) 
   {
    if (args[i].value != null)
     {
      if (i > 0)
       {
        query += '&';
       }
       
      query += args[i].name;
      
      query += '=';
      query += StrUrlEscape(args[i].value);
     }
   }
  
  return query;                                  // Return the object
 }
 
function QueryItemsArraySetParam(args,paramName,paramValue)
 {
  var found = false;
  for(var i = 0; i < args.length; i++) 
   {
    if (args[i].name == paramName)
     {
      args[i].value = paramValue;
      found = true;
     }
   }
   
  if (!found)
   {
    args[args.length] = new QueryStringItem(paramName,paramValue);
   } 
 }
 
function QueryItemsArrayGetParam(args,paramName)
 {
  for(var i = 0; i < args.length; i++) 
   {
    if (args[i].name == paramName)
     {
      return(args[i].value);
     }
   }
   
  return(null);
 }
  
function StrUrlEscape(paramValue)
 {
  // Use this as safe version of escape()
  // There are some missinterpretation between browser and ASP.NET
  // For expample, Many browsers encode "+" as "+" (at least with some DOCTYPE is set), but 
  // that is interpret by ASP.NET as space
  
  var valueStr = paramValue+'';

  // This is bit back (replace '+' as 01h and ' ' as 02h
  // Afre translation we will replace transalted values
  valueStr = StrReplace(valueStr, "+", "\x01");
  valueStr = StrReplace(valueStr, " ", "\x02");

  valueStr = escape(valueStr);

  valueStr = StrReplace(valueStr, "%02", "%20");
  valueStr = StrReplace(valueStr, "%01", "%2B");

  return (valueStr);
 }
 
function addArgToUrl(url,paramName,paramValue)
 {
  if (url.indexOf('?') < 0)
   {
    url += '?';
   }
  else
   {
    url += '&';
   }
   
  url += paramName;
  url += '=';
  url += StrUrlEscape(paramValue);
  
  return(url);
 }
  
// *** Focus toolkit ***

function FocusJumpToFirstInputInsideHolderByTagName(holderItemId,tagName)
 {
  //x.up(); // Force debug popup
  
  var holderItem = document.getElementById(holderItemId);
  
  if (holderItem == null)
   {
    return(false);
   }
  
  var holderInputList = holderItem.getElementsByTagName(tagName);
  
  if ((holderInputList != null) && (holderInputList.length != null) && (holderInputList.length > 0))
   {
    if (!holderInputList[0].disabled)
     {
      holderInputList[0].focus();
      return(true);
     }
   }
   
  return(false);
 }
 
function FocusJumpToFirstInputInsideHolder(holderItemId)
 {
  if (FocusJumpToFirstInputInsideHolderByTagName(holderItemId,"INPUT"))
   {
    return(true);
   }
  else if (FocusJumpToFirstInputInsideHolderByTagName(holderItemId,"SELECT"))
   {
    return(true);
   }
  else if (FocusJumpToFirstInputInsideHolderByTagName(holderItemId,"TEXTAREA"))
   {
    return(true);
   }
  else if (FocusJumpToFirstInputInsideHolderByTagName(holderItemId,"BUTTON"))
   {
    return(true);
   }
  else
   {
    return(false);
   }
 }

function FocusJumpToAndSelect(control)
 {
  if (control == null)
   {
    return;
   }
   
  if (control.focus == null)
   {
    return;
   }
   
  control.focus();
   
  if (isNavigatorIE())
   {
    DocumentControlSelectAllText(control);
   }
 }

function DocumentResetSelection()
 {
  // Call this in "onblur" handler for input type="password" element,
  // if you are using DocumentControlSelectAllText for it,
  // to fix IE6 bug.

  if (document.selection == null)
   {
    return;
   }
   
  if (document.selection.empty == null)
   {
    return;
   }

  try
   {
    document.selection.empty();
   }
  catch(e)
   {
    // ignore
   }
 }
 
function DocumentControlSelectAllText(control)
 {
  if (control == null)
   {
    return;
   }
   
  if (control.focus == null)
   {
    return;
   }
   
  if (control.select == null)
   {
    return;
   }
   
  try
   {
    control.select();
   }
  catch(e)
   {
    // ignore
   }
 }
 
// CssClassName toolkit

function elementClassNameAdd(item,classNameToAdd,addAsFirst)
 {
  var className  = item.className;
  var classNames = className.split(" ");
  var i;
  
  for (i = 0; i < classNames.length; i++)
   {
    if (classNames[i] == classNameToAdd)
     {
      return; // already exist
     }
   }

  if (addAsFirst)
   {
    item.className = classNameToAdd + " " + className;
   }
  else
   {   
    item.className = className + " " + classNameToAdd;
   }
 }
 
function elementClassNameRemove(item,classNameToRemove)
 {
  var classNamesOut = new Array();
  var classNames = item.className.split(" ");
  var i;
  
  for (i = 0; i < classNames.length; i++)
   {
    if (classNames[i] == classNameToRemove)
     {
      // skip
     }
    else if (classNames[i] == "")
     {
      // trim two spaces in source
     }
    else
     {
      classNamesOut[classNamesOut.length] = classNames[i];
     }
   }
  
  item.className = classNamesOut.join(" ");
 }

function elementClassNameIsExists(item,classNameToCheck)
 {
  var className = item.className;
  
  if (className == null)
   {
    return(false);
   }
  
  var classNames = className.split(" ");
  var i;
  
  for (i = 0; i < classNames.length; i++)
   {
    if (classNames[i] == classNameToCheck)
     {
      return(true); // exist
     }
   }
   
  return(false);
 }
 
// Element search by className

function elementFindFirstChildByTagNameAndClassName(item,tagName,classNameToCheck)
 {
  if (item == null)
   {
    return(null);
   }

  if (tagName == null)
   {
    return(null);
   }

  if (classNameToCheck == null)
   {
    return(null);
   }
   
  var tagItems = item.getElementsByTagName(tagName);
  
  if (tagItems == null)
   {
    return(null);
   }

  var tagCount = tagItems.length;
  
  for (var i = 0; i < tagCount; i++)
   {
    if (elementClassNameIsExists(tagItems[i],classNameToCheck))
     {
      return(tagItems[i]);
     }
   }
   
  return(null);
 }
 
// Expandable textarea tools

var elementTextAreaAjustHeightStyleOverflowValue = "visible";
var elementTextAreaAjustHeightDefStepSize        = 50;

function elementTextAreaAjustHeight(TextArea,stepSize)
 {
  if ((stepSize == null) || (stepSize <= 0))
   {
    stepSize = elementTextAreaAjustHeightDefStepSize;
   }
   
  if (false && isNavigatorIE() && (getNavigatorVersionIE() < 7))
   {
    if (TextArea.style.overflow == elementTextAreaAjustHeightStyleOverflowValue)
     {
      // Will be auto-adjusted
     }
    else if (TextArea.currentStyle.overflow == elementTextAreaAjustHeightStyleOverflowValue)
     {
      // Will be auto-adjusted
     }
    else
     {
      TextArea.style.overflow = elementTextAreaAjustHeightStyleOverflowValue;
     }
   }
  else
   {
    var currHeight = TextArea.style.height;
    
    if (currHeight.indexOf("px") > 0)
     {
      currHeight = currHeight.substring(0,currHeight.indexOf("px"));
      currHeight = parseInt(currHeight+"",10);
     }

    if (!isNavigatorIE())
     {
      currHeight = currHeight + 4; // Fix FF [2] & Chrome 2.2 [4=2+2] issues
     }
    else // (isNavigatorIE())
     {
      currHeight = currHeight + 6; // Fix IE issues
     }

    if ((TextArea.scrollHeight != null) && (TextArea.scrollHeight > 0))
     {
      if (currHeight < TextArea.scrollHeight)
       {
        var newHeight = TextArea.scrollHeight + stepSize;
        //alert(currHeight+":"+TextArea.scrollHeight+":"+newHeight);
        TextArea.style.height = newHeight+"px";
       }
     }
   }
 }

function elementTextAreaSetAsAutoAjustHeight(TextArea,stepSize)
 {
  if ((stepSize == null) || (stepSize <= 0))
   {
    stepSize = elementTextAreaAjustHeightDefStepSize;
   }

  elementTextAreaAjustHeight(TextArea,stepSize);
  
  var heightAjusterFunc = function() // Closure
   { 
    return(elementTextAreaAjustHeight(TextArea,stepSize)); 
   }
  
  TextArea.onkeydown  = heightAjusterFunc;
  TextArea.onkeyup    = heightAjusterFunc;
  TextArea.onkeypress = heightAjusterFunc;
  TextArea.onchange   = heightAjusterFunc;

  TextArea.AutoHeightKeepHeight = TextArea.style.height;
  TextArea.AutoHeightStepSize   = stepSize;
 }

function elementTextAreaResetAutoAjustedHeight(TextArea)
 {
  if (TextArea.AutoHeightKeepHeight != null)
   {
    TextArea.style.height = TextArea.AutoHeightKeepHeight;
    elementTextAreaAjustHeight(TextArea,TextArea.AutoHeightStepSize);
   }
 }

// URL hash functions

function pageURLGetHash(url)
 {
  var urlParts = url.split('#');
  var urlHash  = null;
  
  if (urlParts.length > 1)
   {
    urlHash = urlParts[urlParts.length-1];
   }
   
  return(urlHash);
 }

function pageURLStripHash(url)
 {
  var pos = url.indexOf('#');
  
  if (pos < 0)
   {
    return(url); // No hash found
   }
  else
   {
    return(url.substring(0,pos));
   }
 }
 
function pageURLStripQuery(url)
 {
  url = pageURLStripHash(url);

  var pos = url.indexOf('?');
  
  if (pos < 0)
   {
    return(url); // No query found
   }
  else
   {
    return(url.substring(0,pos));
   }
 }
 
function pageURLGetQuery(url)
 {
  url = pageURLStripHash(url);
  
  var urlParts = url.split('?');
  var urlQuery = null;
  
  if (urlParts.length > 1)
   {
    urlQuery = '?'+urlParts[urlParts.length-1]; // By convention, this must start with '?'
   }
   
  return(urlQuery);
 }

function pageURLGetQueryParam(query,paramName)
 {
  var params = QueryStringParseToItemsArray(query);
  return(QueryItemsArrayGetParam(params,paramName));
 }

function pageURLSetHash(url,newHash)
 {
  var url = pageURLStripHash(url);
  if ((newHash != null) && (newHash != ""))
   {
    return(url+'#'+newHash);
   }
  else
   {
    return(url);
   }
 }

function pageURLIsFromThisHost(url)
 {
  var thisHostUrlPrefix = '';
  
  thisHostUrlPrefix += window.location.protocol;
  thisHostUrlPrefix += "//";
  thisHostUrlPrefix += window.location.hostname;
  
  if (window.location.port != "")
   {
    thisHostUrlPrefix += ":";
    thisHostUrlPrefix += window.location.port;
   }
  
  thisHostUrlPrefix += "/";
  
  if (StrIsStartsWith(url,thisHostUrlPrefix))
   {
    return(true); // Link to this host
   }
  else
   {
    return(false); // Link to other host
   }
 }

// Some more constants

var pageElementDisplayStyleShow = '';
var pageElementDisplayStyleHide = 'none';

function pageElementIsDisplayed(pageElement)
 {
  if ((pageElement != null) && (pageElement.style != null))
   {
    if (pageElement.style.display == pageElementDisplayStyleHide)
     {
      return(false);
     }
    else
     {
      return(true);
     }
   }
  else
   {
    return(true); // Styling to supported for this element, so hiding not suppoted
   }
 }
 
function pageElementSetDisplay(pageElement,isShow)
 {
  if (isShow == null) { isShow = true; } // Default param value
  
  if ((pageElement != null) && (pageElement.style != null))
   {
    if (isShow)
     {
      pageElement.style.display = pageElementDisplayStyleShow;
     }
    else
     {
      pageElement.style.display = pageElementDisplayStyleHide;
     }
   }
 }

function pageElementDisplayShow(pageElement)
 {
  pageElementSetDisplay(pageElement,true);
 }

function pageElementDisplayHide(pageElement)
 {
  pageElementSetDisplay(pageElement,false);
 }
 
function pageElementSetDisplayById(pageElementId,isShow)
 {
  pageElementSetDisplay(document.getElementById(pageElementId),isShow);
 }

// Other functions

function pageElementSetEnabled(pageElement,isEnabled)
 {
  if (isEnabled == null) { isEnabled = true; } // Default param value

  if (pageElement != null)
   {
    pageElement.disabled = !isEnabled;
   }
 }
 
function pageElementSetDisabled(pageElement,isDisabled)
 {
  if (isDisabled == null) { isDisabled = true; } // Default param value

  if (pageElement != null)
   {
    pageElement.disabled = isDisabled;
   }
 }
 
function pageElementIsEnabled(pageElement)
 {
  if (pageElement != null)
   {
    if (pageElement.disabled == null)
     {
      return(true); // For FF default is to threat elements as enabled
     }
    else
     {
      return(!pageElement.disabled);
     }
   }
  else
   {
    return(false);
   }
 }
 
function pageElementIsDisabled(pageElement)
 {
  return(!pageElementIsEnabled(pageElement));
 }

function pageElementSetEnabledById(pageElementId,isEnabled)
 {
  pageElementSetEnabled(document.getElementById(pageElementId),isEnabled);
 }
 
function pageElementSetDisabledById(pageElementId,isDisabled)
 {
  pageElementSetDisabled(document.getElementById(pageElementId),isDisabled);
 }
 
function pageElementSetFocus(pageElement)
 {
  if (pageElement != null)
   {
    if (pageElement.style.display == pageElementDisplayStyleHide)
     {
     }
    else
     {
      pageElement.focus();
     }
   }
 }

function pageElementSetFocusById(pageElementId)
 {
  pageElementSetFocus(document.getElementById(pageElementId));
 }
 
// Event functions

function pageElementAttachEventFunction(pageElement, eventName, eventHandlerFunction)
 {
  if (document.addEventListener != null)
   {
    eventName = eventName.substr(2); // strip "on" prefix
    pageElement.addEventListener(eventName, eventHandlerFunction, false);
   }
  else
   {
    pageElement.attachEvent(eventName, eventHandlerFunction);
   }
 }

function pageElementAttrGetInitValue(item,attrName)
 {
  return(item.getAttribute(attrName,2));
 }

// [Misc functions]

function formInputResetAndClearAllHidden(formElement)
 {
  // Reset all elements, and clear all hidden ones
  formElement.reset();
  
  var formItems = formElement.getElementsByTagName('input');
  
  for (var i = 0; i < formItems.length; i++)
   {
    if (formItems[i].type.toLowerCase() == 'hidden')
     {
      formItems[i].value = '';
     }
   }
 }

// [/Misc functions]

// [DateTimeParseFixedDate]

//Parses ASP.NET "value.ToString(CultureInfo.InvariantCulture.DateTimeFormat)" output
//MM/DD/YYYY HH:MM:SS (03/07/2008 19:46:44 is a 07-Mar-2008)
var DateTimeParseFixedStringRegExpStr = "^(\\d{2})/(\\d{2})/(\\d{4}) (\\d{2}):(\\d{2}):(\\d{2})$";
var DateTimeParseFixedStringRegExp = new RegExp(DateTimeParseFixedStringRegExpStr,"");

function DateTimeParseFixedString(FixedDateTimeString)
 {
  if (FixedDateTimeString == null)
   {
    return(null);
   }
   
  if (FixedDateTimeString == "")
   {
    return(null);
   }
   
  var Matches = (""+FixedDateTimeString).match(DateTimeParseFixedStringRegExp);
  
  if (Matches == null)
   {
    return(null);
   }

  try
   {   
    var result 
         = new Date
            (
             parseInt(Matches[3],10),
             parseInt(Matches[1],10)-1,
             parseInt(Matches[2],10),
             parseInt(Matches[4],10),
             parseInt(Matches[5],10),
             parseInt(Matches[6],10)
            );
    
    if (isNaN(result))
     {
      return(null);
     }
    else
     {
      return(result);
     }
   }
  catch(e)
   {
    return(null);
   }
 }

function DateToFixedString(date)
 {
  var DayStr   = date.getDate();      if (DayStr < 10) { DayStr = "0"+""+DayStr }
  var MonthStr = (date.getMonth()+1); if (MonthStr < 10) { MonthStr = "0"+""+MonthStr }
  return(""+MonthStr+"/"+DayStr+"/"+date.getFullYear());
 }

// [/DateTimeParseFixedDate]