////////////////////////////////////////////////////////////////////////////////
//
//  THIS CODE IS NOT APPROVED FOR USE IN/ON ANY OTHER UI ELEMENT OR PRODUCT COMPONENT.
//  Copyright (c) 2006 Microsoft Corporation.  All rights reserved.
//
////////////////////////////////////////////////////////////////////////////////

var gGadgetMode   = (window.System !== undefined);        
var gBIDIMode     = (document.dir=='rtl');  

////////////////////////////////////////////////////////////////////////////////
//
// PICKLIST UTILITIES for use on SELECT Lists
//
////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////
//
// DoAdd(object oPickList, string anOptionValue, OPTIONAL string anOptionText)
//       Adds an Option to passed-in oPickList (SELECT Object)
//
////////////////////////////////////////////////////////////////////////////////
function DoAdd(oPickList, anOptionValue, anOptionText) 
{
  if (oPickList && anOptionValue.length) 
  {
    var anOption = new Option;
    anOption.value = anOptionValue;
    // If we've been given a display value different than the option value, use it
    if (anOptionText)
    {
      anOption.text  = anOptionText;
    }
    else
    {
      anOption.text  = anOptionValue;    
    }
    
    if (oPickList.selectedIndex > -1) 
    { // If something is selected, then insertion point is below that item
      // Insert new option above currently selected row
      oPickList.add(anOption, oPickList.selectedIndex);        
      // Set selectedIndex of Picklist to newly inserted item
      oPickList.selectedIndex -= 1;                                        
    } 
    else 
    {
      oPickList.add(anOption);
      oPickList.selectedIndex = DoFindIndex(oPickList, anOption.value);
    }
  }
}        
////////////////////////////////////////////////////////////////////////////////
//
// DoRemoveOption(object oPickList, OPTIONAL int anOptionIndex) 
// Removes option from passed-in Select List. Default is to remove Selected-
// Index but fn also accepts literal index in OPTIONAL param anOptionIndex
//
////////////////////////////////////////////////////////////////////////////////
function DoRemoveOption(oPickList, anOptionIndex) 
{
  var selectedItem  = anOptionIndex;
  if (anOptionIndex===undefined)
  {
    selectedItem  = oPickList.selectedIndex;
  }
  if (selectedItem > -1) 
  {
    oPickList.options[selectedItem] = null;
  }
  // Set selectedIndex of Picklist to item above the one just removed 
  // (or to the top of the list if we were already there)
  if (selectedItem>0)
  {
    oPickList.selectedIndex = selectedItem-1;        
  }
  else
  {
    oPickList.selectedIndex = 0;    
  }
}        
////////////////////////////////////////////////////////////////////////////////
//
// DoMoveUp(object oPickList) - Moves the currently selected option from 
//                              passed-in Select List Up one line
//
////////////////////////////////////////////////////////////////////////////////
function DoMoveUp(oPickList) 
{
  var selectedItem  = oPickList.selectedIndex;
  if (selectedItem > 0) 
  {        
    // If we're not already at the top of the list ...
    var theOption = oPickList[selectedItem];
    var theOptionB4 = oPickList[selectedItem-1];
    for (prop in theOption) 
    {
      if ((prop=="text") || (prop=="value")) 
      {    
        // Swap the salient properties of the two options
        var theOptionProp = theOption[prop];
        theOption[prop] = theOptionB4[prop];
        theOptionB4[prop] = theOptionProp;
      }
    }
    oPickList.selectedIndex = selectedItem - 1;
  }
}
////////////////////////////////////////////////////////////////////////////////
//
// DoMoveDown(object oPickList) - Moves the currently selected option from 
//                                passed-in Select List Up one line
//
////////////////////////////////////////////////////////////////////////////////
function DoMoveDown(oPickList) 
{
  var selectedItem  = oPickList.selectedIndex;
  if ( (selectedItem > -1) && (selectedItem < oPickList.length-1) ) 
  {
    var theOption = oPickList[selectedItem];
    var theOptionB4 = oPickList[selectedItem+1];
    for (prop in theOption) 
    {
      if ((prop=="text") || (prop=="value")) 
      {    
        // Swap the salient properties of the two options
        var theOptionProp = theOption[prop];
        theOption[prop] = theOptionB4[prop];
        theOptionB4[prop] = theOptionProp;
      }
    }
    oPickList.selectedIndex = selectedItem + 1;
  }
}
////////////////////////////////////////////////////////////////////////////////
//
// DoFindIndex(object oPickList, string anOptionValue, string anOptionText)
// returns index value from a passed-in oPickList for either an 
// optionValue or optionText (both OPTIONAL)
//
////////////////////////////////////////////////////////////////////////////////
 function DoFindIndex(oPickList, anOptionValue, anOptionText) 
{
  var theIndex = -1;
  if (oPickList.length) 
  {
    for (var i=0; i<oPickList.length; i++) 
    {
      if (anOptionText!==undefined) 
      {    
        // Search based on option.text if we have anOptionText
        if (oPickList[i].text == anOptionText) 
        {
          theIndex=i;
          break;
        }
      } 
      else 
      {                                    
        // otherwise, search based on option.value
        if (oPickList[i].value == anOptionValue) 
        {
          theIndex=i;
          break;
        }
      }
    }
  }
  return theIndex;
 }

////////////////////////////////////////////////////////////////////////////////
//
// SETTINGS UTILITIES
//
////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////
//
// saveSetting(string theSettingName, string aSettingValue)- Saves a Setting
//
////////////////////////////////////////////////////////////////////////////////
function saveSetting(theSettingName, aSettingValue) 
{
  if (gGadgetMode) 
  {    
    // If we are in "Gadget Mode", save off the value using that mechanism
    System.Gadget.Settings.write(theSettingName, aSettingValue);
  } 
  else 
  {
    // If we are in "development mode" - use a cookie instead
    writeCookie(theSettingName,aSettingValue);
  }
}
////////////////////////////////////////////////////////////////////////////////
//
// readSetting(string theSettingName)- Reads a Setting
//
////////////////////////////////////////////////////////////////////////////////
function readSetting(theSettingName) 
{
  var retVal = "";
  if (gGadgetMode) 
  {    
    // If we are in "Gadget Mode", read value using that mechanism
    retVal = System.Gadget.Settings.read(theSettingName);
  } 
  else 
  {                    
    // If we are in "development mode" - read from a cookie instead
    retVal = readCookie(theSettingName);
  }
  return retVal;
}
////////////////////////////////////////////////////////////////////////////////
//
// writeCookie(string theCookieName, string aCookieValue) - Writes a cookie
//
////////////////////////////////////////////////////////////////////////////////
function writeCookie(theCookieName, aCookieValue) 
{
  var theCookieExpirationDate = new Date ();
  // Set cookie to expire in 1 year
  theCookieExpirationDate.setYear(theCookieExpirationDate.getYear() + 1);    
  // Convert to GMT
  theCookieExpirationDate = theCookieExpirationDate.toGMTString ();            
  document.cookie = escape(theCookieName) + "=" + escape(aCookieValue) + "; expires=" + theCookieExpirationDate;
}
////////////////////////////////////////////////////////////////////////////////
//
// readCookie(string theCookieName) - Reads a cookie
//
////////////////////////////////////////////////////////////////////////////////
function readCookie(theCookieName) 
{
  var aCookieValue = "";
  var theCookies = ("" + document.cookie).split("; ");
  for (var i=0; i < theCookies.length; i++)     
  {
    if (theCookies[i].indexOf("=") > -1) 
    {  
      // If we have a non-empty cookie, extract the Cookie Name
      var aCookieName = theCookies[i].split("=")[0];    
      if (aCookieName == theCookieName) 
      {
        // If this is the one we're looking for, set that as our return value and get out
        aCookieValue = theCookies[i].split("=")[1];  
        break;
      }
    }
  }
  return aCookieValue; 
}

////////////////////////////////////////////////////////////////////////////////
//
// GENERAL UTILITIES
//
////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////
//
// showOrHide([object|string] oHTMLElement, boolean bShowOrHide)
//           Shows or Hides an HTMLElement.  
//           You can pass in the id to an object or the actual object
//
////////////////////////////////////////////////////////////////////////////////
function showOrHide(oHTMLElement, bShowOrHide) 
{
  try 
  {
    if (typeof(oHTMLElement)=="string") 
    { 
      oHTMLElement = document.getElementById(oHTMLElement); 
    }
    if (oHTMLElement && oHTMLElement.style) 
    {
      if (bShowOrHide == 'inherit') 
      {
        oHTMLElement.style.visibility = 'inherit';
      } 
      else 
      {
        if (bShowOrHide)
        {
          oHTMLElement.style.visibility = 'visible';
        }
        else
        {
          oHTMLElement.style.visibility = 'hidden';
        }
        try 
        {
          if (bShowOrHide)
          {
            oHTMLElement.style.display = 'block';
          }
          else
          {
            oHTMLElement.style.display = 'none';
          }
        }
        catch (ex) 
        {
        }
      }
    }
  }
  catch (ex) 
  {
  }
}
////////////////////////////////////////////////////////////////////////////////
//
// setImage(oHTMLElement, imageURL) - places an image into an element
//                                    applying alphaImageLoader as necessary
//
////////////////////////////////////////////////////////////////////////////////
function setImage(oHTMLElement, imageURL) {  
  if (typeof(oHTMLElement)=="string") 
  { 
    oHTMLElement = document.getElementById(oHTMLElement); 
  }
  if (gGadgetMode) 
  {
    oHTMLElement.src = imageURL;
  } 
  else 
  {
    oHTMLElement.style.backgroundImage = "url(images/1px.gif)";
    oHTMLElement.style.filter = "progid:DXImageTransform.Microsoft.AlphaImageLoader(src='" + imageURL + "',sizingMethod='scale')";
  }
}
////////////////////////////////////////////////////////////////////////////////
//
// getSpinner( string spinnerDivID ) - establishes a Spinner Object.
//
////////////////////////////////////////////////////////////////////////////////
function getSpinner( spinnerDivID ) 
{
  var self = this;
  this.id = spinnerDivID;
  this.parentDiv = document.getElementById( self.id );
  this.fps = 1000/30;  
  with ( this.parentDiv.style ) 
  {
    fontSize=0;
    posWidth=16;
    posHeight=16;
    backgroundImage = 'url("images/activity16v.png")';
    backgroundPositionY = 0;
  }
  this.hide  = function() 
  { 
    self.parentDiv.style.display='none';  
  }
  this.show  = function() 
  { 
    self.parentDiv.style.display='block'; 
  }
  this.stop  = function() 
  { 
    clearInterval( self.animationInterval ); 
  }
  this.start = function() 
  {
    clearInterval( self.animationInterval );
    this.animationInterval = setInterval( 'animateSpinner(' + self.id + ')', 30 );
  }
} 
////////////////////////////////////////////////////////////////////////////////
//
// animateSpinner( oHTMLElement spinnerDiv ) - animates spinner image
//
////////////////////////////////////////////////////////////////////////////////
function animateSpinner(spinnerDiv) 
{
  spinnerDiv.style.backgroundPositionY=parseInt(spinnerDiv.style.backgroundPositionY)-16; 
}
////////////////////////////////////////////////////////////////////////////////
//
// isVisible([object|string] oHTMLElement) - boolean of if Object visible.
// You can pass in the id to an object or the actual object
//
////////////////////////////////////////////////////////////////////////////////
function isVisible(oHTMLElement) 
{
  var bIsVisible = true;
  if (typeof(oHTMLElement)=="string") 
  { 
    oHTMLElement = document.getElementById(oHTMLElement); 
  }
  if (oHTMLElement && oHTMLElement.style) 
  {
    bIsVisible =  (oHTMLElement.style.display=='block');
  }
  return bIsVisible;
}
////////////////////////////////////////////////////////////////////////////////
//
// getLocalizedString(string key) - returns localized string.
//                                  Defaults to English version if not found
//
////////////////////////////////////////////////////////////////////////////////
function getLocalizedString(key) 
{
 var retVal = key;
 try 
 {
   retVal = L_localizedStrings_Text[key];
   if (retVal === undefined) 
   {
     retVal = key
   }
 }
 catch (ex) 
 {
 }
 return retVal;
}
////////////////////////////////////////////////////////////////////////////////
//
// commify(string aNumber) - returns a number properly "commified" 
//                           with a comma every three digits nnn,nnn,nnn.nn
//
////////////////////////////////////////////////////////////////////////////////
function commify(aNumber) {
  var retVal = aNumber;
  var theDecimalValue="";
  var oRegExp = new RegExp("[0-9]");
  if (aNumber.length) 
  {
    if (aNumber.lastIndexOf(".") > -1) 
    {        
      // If we have a number with decimal places, save off the value to the 
      // right of the decimal place for later use
      theDecimalValue = aNumber.substring(aNumber.lastIndexOf("."), aNumber.length);
      // Strip off the decimal portion of the number
      retVal = retVal.substring(0, retVal.lastIndexOf("."));    
    }
    // Reverse the number
    var aNewNumber = "";
    for (var i=0;i<retVal.length;i++) 
    {                                    
      var aChar = retVal.substring(i,i+1);
      if (oRegExp.exec(aChar)) 
      { 
        // So long as we have a numeric character, use it. Has the 
        // effect of stripping out any previous formatting from the number.
        aNewNumber = aChar + aNewNumber;
      }
    }
    // Rebuild number from the beginning, adding a comma every 3 characters
    retVal = "";
    for (var i=0;i<aNewNumber.length;i++) 
    {                            
      retVal = aNewNumber.substring(i,i+1) + retVal;
      if (((i+1) % 3 == 0) && (i+1<aNewNumber.length)) 
      {
        retVal = ',' + retVal;
      }
    }
    // Add the decimal value back to the end of the string
    retVal += theDecimalValue;        
  }
  return retVal;
}
////////////////////////////////////////////////////////////////////////////////
//
// cleanURL(string aURL) - formats URLS like 
//          http://www.microsoft.com/gadgets.html into 
//          http:\/\/www.microsoft.com\/gadgets.html.  
// Useful if Hyperlinks myst be passed around as strings via Javascript 
//
////////////////////////////////////////////////////////////////////////////////
function cleanURL(aURL) 
{
  return aURL.split('/').join('\\/');
}
////////////////////////////////////////////////////////////////////////////////
//
// URLDecode(string aString) - decodes URLEncoded strings
//
////////////////////////////////////////////////////////////////////////////////
function URLDecode(aString) 
{
  aString = aString.replace("%2F", "/");
  aString = aString.replace("%7C", "|");
  aString = aString.replace("%3F", "?");
  aString = aString.replace("%21", "!");
  aString = aString.replace("%40", "@");
  aString = aString.replace("%5C", "");
  aString = aString.replace("%23", "#");
  aString = aString.replace("%24", "$");
  aString = aString.replace("%5E", "^");
  aString = aString.replace("%26", "&");
  aString = aString.replace("%25", "%");
  aString = aString.replace("%2A", "*");
  aString = aString.replace("%28", "(");
  aString = aString.replace("%29", ")");
  aString = aString.replace("%7D", "}");
  aString = aString.replace("%3A", ":");
  aString = aString.replace("%2C", ",");
  aString = aString.replace("%7B", "{");
  aString = aString.replace("%2B", "+");
  aString = aString.replace("%2E", ".");
  aString = aString.replace("%2D", "-");
  aString = aString.replace("%7E", "~");
  aString = aString.replace("%2D", "-");
  aString = aString.replace("%5B", "[");
  aString = aString.replace("%5F", "_");
  aString = aString.replace("%5D", "]");
  aString = aString.replace("%60", "`"); 
  aString = aString.replace("%3D", "=");
  aString = aString.replace("%27", "'");
  aString = aString.replace("+", " ");
  aString = aString.replace("%22", '"');
  return aString;
}
////////////////////////////////////////////////////////////////////////////////
//
// function setCaretPos(anInputElement, int startPoint, int endPoint)
//                      sets cursor selection within an input element
//
////////////////////////////////////////////////////////////////////////////////
function setCaretPos( anInputElement, startPoint, endPoint ) 
{
  var startPoint = startPoint || 0;
  var endPoint   = endPoint || startPoint;
  var theInputElement = anInputElement.createTextRange();
  with ( theInputElement ) 
  {
    collapse(true);
    moveEnd('character', endPoint);
    moveStart('character', startPoint);
    select();
  } 
  theInputElement = null;   
}
////////////////////////////////////////////////////////////////////////////////
//
// function toLocalizedString(string str)
//                           Returns localized string substituted in word units.
//                           Defaults to inputed string if not found.
//
// Added by dyhan81
//
////////////////////////////////////////////////////////////////////////////////
function toLocalizedString(str)
{
	var tempstr;
	var spaceAtStart = 0;
	var spaceAtEnd   = 0;
  var delimiters              = "-/,[]()";
  var delimitersWillBeDeleted = "-";

	// Trimming
	while (str.charAt(0) == " ")
	{
		spaceAtStart++;
		str = str.substr(1,str.length-1);
	}
	while (str.charAt(str.length-1) == " ")
	{
		spaceAtEnd++;
		str = str.substr(0,str.length-1);
	}
	
	// return exactly matched string when it is available.
	if (str.toLowerCase() != (tempstr = getLocalizedString(str.toLowerCase())))
		str = tempstr;
	else if (str != (tempstr = getLocalizedString(str)))
		str = tempstr;
	else
	{
		// ", " separated string parsing, and then " " separated string parsing.
		var words;
		var delimiters     = "[]()/,-";
		var delimitersDisp = "1111110";
		var splited = false;
		for (var i=0; i<delimiters.length; i++)
		{
			words = str.split(delimiters.charAt(i));
			var tempWords = new Array(words.length);
			for (var j=0; j<words.length; j++)
			  tempWords[j] = words[j];
			  
			if (words.length > 1)
			{
				splited = true;
				for (var j=0; j < words.length; j++)
					tempWords[j] = toLocalizedString(words[j]);
				
				str = tempWords[0];
				
				for (var j=1; j < words.length; j++)
				{
				  if ((delimitersDisp.charAt(i) == "0") && (words[j-1] != tempWords[j-1]) && (words[j] != tempWords[j]))
				  {
						str = str + tempWords[j];
					}
					else 
					{
						str = str + delimiters.charAt(i) + tempWords[j];
					}
				}
			}
		}
		if (!splited)
		{
			words = str.split(" ");
			for (var i = 0; i < words.length; i++)
			{
				if (words[i].toLowerCase() != (tempstr = getLocalizedString(words[i].toLowerCase())))
					words[i] = tempstr;
				else
					words[i] = getLocalizedString(words[i]);
			}
			str = words[0];
			for (var i = 1; i < words.length; i++)
				str = str + " " + words[i];
		}
	}	
	
	// Trimed Space Recover
	if (spaceAtStart>0)
		str = " " + str;
	if (spaceAtEnd>0)
		str += " ";
		
	return str;

}
////////////////////////////////////////////////////////////////////////////////
//
// function hide(id) / show(id) / highlight(id[, cursor shape])
//                    Show / hide / hightlight elements.
//
// Added by dyhan81
//
////////////////////////////////////////////////////////////////////////////////
function hide(idstr) {
  document.getElementById(idstr).style.visibility='hidden';
	document.getElementById(idstr).style.textDecoration='none';
}
function show(idstr) {
	document.getElementById(idstr).style.visibility='visible';
}
function highlight(idstr, cursor) {
	document.getElementById(idstr).style.textDecoration='underline';
	document.getElementById(idstr).style.cursor=cursor;
}
