///-----------------------------------------------------------------------------
/// <copyright file="toolbargroup.js" company="Microsoft">
///  Copyright 1999-2008 (c) Microsoft Corporation. All Rights Reserved.
///  Information Contained Herein is Proprietary and Confidential.
/// </copyright>
/// <summary>Javascript file for Toolbar_v2 and ShareIt</summary>
///  <references path="" />
///-----------------------------------------------------------------------------  
    
// --------------------------------------------------------------------------------------------
// Generic Code
// --------------------------------------------------------------------------------------------

    listItemAppendTextForAnchorTitleAndImageAlt = function (listItem, appendText)
    {
        /// <summary>Sets Attributes On A and IMG Tags</summary>
        /// <param type="string" name="listItems">The List Items To Process</param>
        /// <param type="string" name="appendText">Text Value To Append to Image and Link Tooltips</param>
        /// <returns type="void"></returns>
        
        // verify and set tag <A>
        var aTag = listItem.childNodes[0];
        if (aTag.nodeName.toUpperCase() != "A")
        {
            return;
        }
        
        var aTagTitle = aTag.attributes.title.value;
        aTagTitle = appendStrings(aTagTitle, appendText);    
        listItem.childNodes[0].setAttribute('title', aTagTitle);
            
        // verify and set tag <IMG>
        var imgTag = listItem.childNodes[0].childNodes[0];
        if (imgTag.nodeName.toUpperCase() != "IMG")
        {
            return;
        }
        
        var imgTagAlt = imgTag.attributes.alt.value;
        imgTagAlt = appendStrings(imgTagAlt, appendText);
        listItem.childNodes[0].childNodes[0].setAttribute('alt', imgTagAlt);    
    };
    		
    appendStrings = function (existingText, textToAppend)
    {
        /// <summary>Appends Two Strings</summary>
        /// <param type="string" name="existingText">The Text To Append To</param>
        /// <param type="string" name="textToAppend">The Text To Append</param>
        /// <returns type="string">Resultant Appended String</returns>  
        if (existingText !== '') 
        {
            if (textToAppend !== '') 
            {
                return existingText + textToAppend;
            }
            else 
            {
                return existingText;
            }
        }
        else 
        {
            if (textToAppend !== '') 
            {
                return textToAppend;
            }
            else 
            {
                return '';
            }       
        }
    };
    		
    removeString = function (text, startText)
    {
        /// <summary>Removes all text between the input start and end text (inclusive)</summary>
        /// <param type="string" name="text">The Text To Process</param>
        /// <param type="string" name="startText">The text that marks the Start of the substring to remove</param>
        /// <returns type="string">Resultant Appended String</returns>
        var startPos = text.indexOf(startText);
        var endPos = text.length;
        
        if (startPos > -1)
        {
            var removeText = text.substring(startPos,endPos);
            text = text.replace(removeText, '');
        }
      
        return text;
    };
    		
    getHiddenPopupValue = function ()
    {
        /// <summary>Gets Hidden Text Value To Append to Image and Link Tooltips</summary>
        /// <returns type="string">Hidden Text Value To Append to Image and Link Tooltips</returns>		
	    var spanToolbarGroupHidden = document.getElementById("toolbargrouphidden");
	    if (!spanToolbarGroupHidden)
	    {
	        return;
	    }
    	
	    return spanToolbarGroupHidden.innerText;
    };

    listItemsReplaceClassValues = function (containerId, findtext, replacetext)
    {
        /// <summary>Replaces findtext with replacetext in class of List Items</summary>
        /// <param type="string" name="text">The text to find that will be replaced</param>
        /// <param type="string" name="text">The text that will replace</param>
        /// <returns type="void"/>	
	    var container = document.getElementById(containerId);
	    if (!container)
	    {
	        return;
	    }
    	
	    var listItems = container.getElementsByTagName("li");
	    if (!listItems)
	    {
	        return;
	    }
    	
        for (var i=0; i < listItems.length; i++)
        {
            // replace findtext with replacetext
            var liClass = listItems[i].attributes['class'];
	        if (!liClass)
	        {
	            continue;
	        }
	        
	        liClass = liClass.value;
    	
            var liClassReplaced = liClass.replace(findtext, replacetext);
            
            // set the attribute with the replaced value
            listItems[i].attributes['class'].value = liClassReplaced;
	    }
    };

    containerReplaceClassValues = function (containerId, findtext, replacetext)
    {
        /// <summary>Replaces findtext with replacetext in a container class</summary>
        /// <param type="string" name="text">The text to find that will be replaced</param>
        /// <param type="string" name="text">The text that will replace</param>
        /// <returns type="void"/>	
	    var container = document.getElementById(containerId);
	    if (!container)
	    {
	        return;
	    }
	    
        var divClass = container.attributes['class'];
	    if (!divClass)
	    {
	        return;
	    }
        
        divClass = divClass.value;
        if (divClass)
        {
            var divClassReplaced = divClass.replace(findtext, replacetext);
            
            // set the attribute with the replaced value
            container.attributes['class'].value = divClassReplaced;
        }
    };

    containerReplaceIdValue = function (containerId, replaceContainerId)
    {
        /// <summary>Replaces findtext with replacetext in a container id</summary>
        /// <param type="string" name="text">The text to find that will be replaced</param>
        /// <param type="string" name="text">The text that will replace</param>
        /// <returns type="void"/>	
	    var container = document.getElementById(containerId);
	    if (!container)
	    {
	        return;
	    }
	    
        var divId = container.attributes['id'];
	    if (!divId)
	    {
	        return;
	    }
        
        divId = divId.value;
        if (divId)
        {
            var divIdReplaced = divId.replace(containerId, replaceContainerId);
            
            // set the attribute with the replaced value
            container.attributes['id'].value = divIdReplaced;
        }
    };

   
    // --------------------------------------------------------------------------------------------
    // Toolbar Specific Code
    // --------------------------------------------------------------------------------------------
    
toolbarToggleShareItFlyout = function () 
{
    /// <summary>FUNCTION "toolbarToggleShareItFlyout": toggle flyout menu for Share It Toolbar item</summary>
    /// <param type="bool" name="flag">optional. If set to true or false then toggle is forced, otherwise it looks for class</param>
    /// <returns type="void"></returns>
    
    //toolbar_shareit
    
    var shareItListItem = document.getElementById("toolbar_shareit");
    
    //check share it toolbar icon exists
    if (!shareItListItem)
    {
        return;
    }
    
    var eventSourceElement = event.srcElement;
    var forceClose = false;
    
    //drop out if no event source
    if (!eventSourceElement)
    {
        return;
    }
    
    //if event source is not from the toolbar shareit icon click 
    if (eventSourceElement.id !== "toolbar_shareit")
    {
        var eventSourceParentElement = eventSourceElement.parentElement;
        
        //drop out if no event source parent
        if (!eventSourceParentElement)
        {
            return;
        }
        
        if (eventSourceParentElement.id  !== "toolbar_shareit")
        {
            forceClose = true;
        }
    }
    //trim class name on list item
    var popupClass = shareItListItem.parentElement.className.replace(/^\s+|\s+$/g, '');
    
    if (popupClass.indexOf('flyout close') >= 0 && forceClose === false) //toggle the open/close class on list items
    {
        //set class on shareit list item on toolbar
         updateParentElementId('toolbar_shareit', "flyout close", "flyout open");     
         //set class for Share It container div         
         containerReplaceClassValues('shareit', "flyoutclose", "flyoutopen");    
    }
    else if (popupClass.indexOf('flyout open') >= 0)
    {
        //set class on shareit list item on toolbar
        updateParentElementId('toolbar_shareit', "flyout open", "flyout close");     
        //set class for Share It container div
        containerReplaceClassValues('shareit', "flyoutopen", "flyoutclose");
    }
  
};
    
      
initialiseToolbarFlyoutHandler = function()
{
    /// <summary>FUNCTION "initialiseToolbarFlyoutHandler": called in top level, attaches toolbarToggleShareItFlyout method to page</summary>
    /// <returns type="void"></returns>

    /// <summary>PUBLIC "isIe" constant: boolean value (true = IE 4+, false: other browser)</summary>
    var isIe = (navigator.userAgent.indexOf("MSIE") > -1 && (parseInt(navigator.appVersion, 10) >=4));
    var toolbarShareItElement = document.getElementById("toolbar_shareit");
    
    //drop out of function if toolbar shareit icon is not on the toolbar
    if (!toolbarShareItElement)
    {
        return;
    }    
        
    if (document.attachEvent || isIe)
    {
        document.attachEvent("onclick", toolbarToggleShareItFlyout);
    }
    else
    {
        window.addEventListener("onclick", toolbarToggleShareItFlyout, false);
    }
    
    //remove href if shareit set to flyout
    if (jsFlyout === "true") 
    {
        toolbarShareItElement.attributes.removeNamedItem("href");
    }
}

    printIt = function () 
    {
        /// <summary>FUNCTION "printIt": open print dialog</summary>
        /// <returns type="void"></returns>
        window.print(); 
    };
    
    toolbarCSSUpdate = function ()
    {
        /// <summary>If the browser is not IE then remove the css class 'toolbar_ie' from the UL class attribute</summary>
        /// <summary>because toolbar_ie uses 'display: inline'. Defaults to 'display: table'.</summary>
        
        /// boolean value (true = IE 4+, false: other browser)
        var isIe = (navigator.userAgent.indexOf("MSIE") > -1 && (parseInt(navigator.appVersion, 10) >=4));
        
        // if not IE then remove the css class 'toolbar_ie' from the UL class attribute
        if (!isIe)
        {
            var toolbarElement = document.getElementById("toolbar");   	    
    	    
	        if (toolbarElement === null) 
	        {
	            return;
	        }
            
            var toolbarUl = toolbarElement.getElementsByTagName("ul");
            
            if (toolbarUl === null) 
	        {
	            return;
	        }
            
            // do the remove            
            var ulClass = toolbarUl[0].attributes['class'];
            
            if (!ulClass)
            {
                return;
            }
            ulClass = ulClass.value;    
            ulClass = removeString(ulClass, 'toolbar_ie');    
            toolbarUl[0].attributes['class'].value = ulClass;            
        }
    };
    getToolbarGroupSlotListItems = function (containerId)
    {
        /// <summary>Returns an array of list items found in the specified container within the toolbargroup div</summary>
        /// <param type="string" name="containerId">The id of the container within the toolbargroup div</param>
        /// <returns type="string">An array of list items found in the specified container within the toolbargroup div</returns>
	    var container=document.getElementById(containerId);

	    if (!container)
	    {
	        return null;
	    }

	    var listItems = container.getElementsByTagName("li");
	    if (!listItems)
	    {
	        return null;
	    }

	    return listItems;
    };

    toolbarUpdateIcons = function ()
    {
        /// <summary>Updates the toolbar icons with the enhanced icon versions</summary>
        /// <returns type="void"/>	
	    var toolbarElement = document.getElementById("toolbar");
	    
	    if (toolbarElement === null) 
	    {
	        return;
	    }
	    
	    var toolbarImgItems = toolbarElement.getElementsByTagName("img");
	    
        if (toolbarImgItems !== null) 
        {
            for (var i=0; i < toolbarImgItems.length; i++)
            {           
                var imgTag = toolbarImgItems[i];
                var imgTagSrc = imgTag.attributes.src.value;
                
                imgTagSrc = imgTagSrc.replace('/img/', '/img/enhanced/');
                imgTag.setAttribute('src', imgTagSrc);
	        }
	    }
    };

    toolbarListItemsRemoveStandardTextFromImageAltAnchorTitle = function ()
    {
        /// <summary>Removes standard text from image alt and anchor title
        /// since this text is not relevant because js is enabled</summary>
        /// <returns type="void" />	
	    var toolbarContainer=document.getElementById("toolbar");
	    if (!toolbarContainer)
	    {
	        return;
	    }
    	
	    var toolbarListItems = toolbarContainer.getElementsByTagName("li");
	    if (!toolbarListItems)
	    {
	        return;
	    }
    	
        for (var i=0; i < toolbarListItems.length; i++)
        {   
            var aTag = toolbarListItems[i].childNodes[0];
                
            if (aTag.nodeName.toUpperCase() == "SCRIPT")
            {
                aTag = toolbarListItems[i].childNodes[1];
            }
                
            // verify and set tag <A>
            if (aTag.nodeName.toUpperCase() != "A")
            {
                continue;
            }
            
            var aTagTitle = aTag.attributes.title.value;
            aTagTitle = removeString(aTagTitle, '... ');    
            aTag.setAttribute('title', aTagTitle);
                
            // verify and set tag <IMG>
            var imgTag = aTag.childNodes[0];
            
            if (imgTag.nodeName.toUpperCase() != "IMG")
            {
                continue;
            }
            
            var imgTagAlt = imgTag.attributes.alt.value;
            imgTagAlt = removeString(imgTagAlt, '... ');    
            imgTag.setAttribute('alt', imgTagAlt);
        }
    };

    toolbarListItemsReplaceClassPopupValues = function ()
    {
        /// <summary>Replaces 'jspopup' with 'popup' in class of Toolbar List Items</summary>
        /// <returns type="void" />	
        listItemsReplaceClassValues('toolbar', 'jspopup', 'popup');
    };

    toolbarListItemsRemoveClassDisableValue = function ()
    {
        /// <summary>Removes 'disable' from class of Toolbar List Items</summary>
        /// <returns type="void" />	
        listItemsReplaceClassValues('toolbar', ' disabled', '');
    };
	
    listItemsAppendOpenNewWindowTextToImageAltAnchorTitleIfPopup = function (containerId)
    {
        /// <summary>Builds Image and Link Tooltips on Toolbar. Adds text for 'opens in a new window' if class contains 'popup' and not 'jspopup'</summary>
        /// <returns type="void" />
        var popupHiddenValue = getHiddenPopupValue();
	    var toolbarListItems = getToolbarGroupSlotListItems(containerId);
    	
        if (toolbarListItems !== null) 
        {
            for (var i=0; i < toolbarListItems.length; i++)
            {
                var liClass = toolbarListItems[i].attributes['class'];
                if (!liClass)
    	        {
	                continue;
	            }
	        
    	        liClass = liClass.value;
                if (liClass.indexOf('popup') >= 0 && liClass.indexOf('jspopup') < 0) 
                {
                       listItemAppendTextForAnchorTitleAndImageAlt(toolbarListItems[i], popupHiddenValue);
                }
	        }
	    }
    };
    
// --------------------------------------------------------------------------------------------
// Specific code for ShareIt module
// --------------------------------------------------------------------------------------------

    shareItInitialiseFlyoutMenu = function ()
    {
        /// <summary>Sets the Share It Flyout menu to initial state of 'closed'</summary>
        /// <returns type="void" />	
        if (jsFlyout === "true") {
            containerReplaceClassValues('shareit', 'shareit', 'shareit flyoutclose'); 
            containerReplaceIdValue('toolbargroupjs', 'toolbargroup');
        }
    };
    

// --------------------------------------------------------------------------------------------
// Trigger code for ShareIt module
// --------------------------------------------------------------------------------------------

    listItemsReplaceClassValues('shareit', 'jspopup', 'popup');
    listItemsAppendOpenNewWindowTextToImageAltAnchorTitleIfPopup('shareit');
    
    shareItInitialiseFlyoutMenu();

// --------------------------------------------------------------------------------------------
// Trigger code for the Toolbar module
// --------------------------------------------------------------------------------------------
    toolbarUpdateIcons();
    toolbarCSSUpdate();

    toolbarListItemsRemoveStandardTextFromImageAltAnchorTitle();

    toolbarListItemsReplaceClassPopupValues();
    
    toolbarListItemsRemoveClassDisableValue();

    listItemsReplaceClassValues('toolbar', 'jsflyout', 'flyout'); 
    
    initialiseToolbarFlyoutHandler();
    
    listItemsAppendOpenNewWindowTextToImageAltAnchorTitleIfPopup("toolbar");
    
// --------------------------------------------------------------------------------------------
// Omniture Tracking Code
// --------------------------------------------------------------------------------------------

function ToolbarTracking() {
    /// <summary>PUBLIC "ToolbarTracking" object: custom "ToolbarTracking" object</summary>
    /// <remarks>Object tracks toolbar button clicks through Omniture</remarks>
    /// <summary>PRIVATE "_t" constant: pointing to instance of "this" object - good practise, required for JavaScript closure</summary>
    var _t = this;
    var tbarOAName = "msnportalmostpopular";
    var pageTitle_tb = document.title;

    /// <summary>PUBLIC properties</summary>
    _t.isOmni = _t.isIe = _t.trackingType = _t.omniImg = _t.omniSrc = _t.isMsnPopup = null; //
    
    _t.Init = function()
    {
        /// <summary></summary>
        _t.isOmni = (document.getElementById("omni") && window.s) ? true : false;
        
        if (!_t.isOmni) 
        {
            return;
        }
        /// <summary>PUBLIC "isIe" constant: boolean value (true = IE 4+, false: other browser)</summary>
        _t.isIe = (navigator.userAgent.indexOf("MSIE") > -1 && (parseInt(navigator.appVersion, 10) >=4));

        /// <summary>PUBLIC "trackingType" variable: string value - activity id value (MostBlogged, MostEmailed, MostPrinted, MostMessaged, MostKicked)</summary>
        _t.trackingType = "Unknown";

        /// <summary>PUBLIC "omniImg" variable: HTML img element</summary>
        _t.omniImg = document.getElementById("omni").getElementsByTagName("img")[0];
        
        /// <summary>PUBLIC "omniSrc" variable: string value of _t.omniImg src attrib on page load</summary>
        _t.omniSrc = _t.omniImg.src;
        
        createTrackImg();

        // initialize tracking object
        _t.AttachHandlers();
    };
    
    /// <summary>PRIVATE "createTrackImg" function: creates image element for tracking</summary>
    createTrackImg = function()
    {
        _t.trackImg = new Image(2,2);
        _t.trackImg.id = "xprTbarTrack";
        _t.trackImg.style.visibility = "hidden";
        _t.trackImg.style.position = "absolute";
        document.getElementById("omni").appendChild(_t.trackImg);
    };       
    
    /// <summary>PUBLIC "PostOminitureTrack" function: </summary>
    /// <remarks>Called by "Track" function</remarks>
    _t.PostOminitureTrack = function() {
    
        callOmniTrack = function(pageAccName, modAccName, propvalues)
        {
        /// <summary>PRIVATE "callOmniTrack" function: </summary>
        /// <param name="img">omniture IMG html element</param>
        /// <param name="pageAccName"></param>
        /// <param name="modAccName"></param>
        /// <param name="propvalues"></param>
            
            getImageUrl = function(i) {
            /// <summary>PRIVATE "getImageUrl" function: returns tracking image url</summary>
            /// <param name="i">img html element (page level omniture tracking image)</param>
            /// <remarks></remarks>
                // create & execute reg exp to capture page level tracking image src attribute value BEFORE "[AQE]" marker
                var re = new RegExp("(.*)&\\[AQE\\]");
                var arr = re.exec(i);
                // return matched url value + propvalues parameter value + "[AQE]" marker
                return arr[1].replace(pageAccName, modAccName) + propvalues + "&[AQE]";
            };
            _t.trackImg.src = getImageUrl(_t.omniSrc);
                        
        };
        
        getCleanUrl = function() 
        { 
        /// <summary>PRIVATE "getCleanUrl" function: strip anchor/bookmark hash value from URL</summary>
        /// <returns>document URL without anchor/bookmark hash value </returns>
        /// <remarks>Fix page url by stripping "#toolbar"</remarks>
        /// <remarks>Omniture system logs http://news.uk.msn.com/article.aspx?cp-documentid=000000#toolbar as different page to http://news.uk.msn.com/article.aspx?cp-documentid=000000</remarks>
            return document.URL.replace(location.hash,""); 
        };
        // load reference to"window.s" object (created in page for Omniture tracking)
        var source = window.s;
        
        // set custom toolbar property values
        source.prop40 = document.documentElement.getAttribute("lang"); // Market
        source.prop41 = (location.host.indexOf(".msn.")>-1) ? location.host.substr(0,location.host.indexOf(".msn.")).replace(/\./g," ") : location.host; // Site
        source.prop42 = location.pathname.substr(1).replace(location.pathname.substr(location.pathname.lastIndexOf("/")),"").replace(/\//g, " "); // Dept.

        source.prop43 = _t.trackingType; 
        
        // fix page url by stripping "#toolbar"
        var cleanUrl = getCleanUrl();
        source.prop44 = source.prop13 = source.prop29 = cleanUrl;
        source.prop45 = pageType_toolbar; // PG or Article
        
        if (source.prop49 === "") 
        { 
            source.prop49 = escape(document.title).replace(/"/g, '\\"'); 
        }
        
        // set charset property value (ensures double byte sets reported correctly)
        source.charSet = "UTF-8";
        
        lt = (source.prop16 !=='') ? 'o': 'e';

        var omniModuleValues = "&c40=" + escape(source.prop40) + "&c41=" + escape(source.prop41) + "&c42=" + escape(source.prop42) + "&c43=" + escape(source.prop43) + "&c44=" + escape(source.prop44)  + "&c45=" + escape(source.prop45);

        // call tracking  - with  module level account name & values
        callOmniTrack(window.s_account, tbarOAName, omniModuleValues);
        

    };
    
    
    /// <summary>PUBLIC "IsToolBarOnClick" function: determines if the click came from the toolbar</summary>
    /// <param name="srcElement" type="object">HTML element</param>
    /// <returns>boolean value: true (toolbar button clicked); false (toolbar button NOT clicked)</returns>
    /// <remarks>Called by "Track" function</remarks>
    _t.IsToolBarGroupOnClick = function(srcElement)
    {
        if (srcElement === null) {
            return false;
        }
        
        var currentElement = null;
        
        //Get A Tag
        if (srcElement.tagName === "A") {
            currentElement = srcElement;
        }
        else //When IMG or Span is clicked
        {
            currentElement = srcElement.parentElement;
            if (currentElement.tagName !== "A")
            {
                return false;
            }
        }
        
        var currentElementId = currentElement.id;
        var toolbarATagIdPrefix = "toolbar_";
        var featureId = null;
        
        if (currentElementId !== null)
        {
            // check if this is a toolbar element
            if (currentElementId.substring(0, toolbarATagIdPrefix.length) === toolbarATagIdPrefix)
            {
                featureId = currentElementId.substring(toolbarATagIdPrefix.length, toolbarATagIdPrefix.length + currentElementId.length);
            }
            else // check if this is a share it element
            {   
                // go up 3 levels to get share it ID from DIV
                for (var i = 0; i < 3; i++)
                {
                    if (currentElement === null)
                    {
                        return false;
                    }
                    else
                    {
                        currentElement = currentElement.parentElement;
                    }
                }
                
                // need to check if the id is the expected share it id
                if (currentElement.id === "shareit") {
                    featureId = currentElement.id;
                }
                else {
                    return false;
                }
            }
        }
        
        _t.SetTrackingType(featureId); 

        return true;
    };

    /// <summary>PUBLIC "SetTrackingType" function: </summary>
    /// <param name="trackingType" type="string">HTML element id value</param>
    /// <remarks>Called by "IsToolBarGroupOnClick" function</remarks>
    _t.SetTrackingType = function(trackingType)
    {
        if(trackingType.toLowerCase().indexOf("emailit") > -1) {
            _t.trackingType = "MostEmailed";
        }
        else if(trackingType.toLowerCase().indexOf("shareit") > -1) {
            _t.trackingType = "MostBlogged";
        }
        else if(trackingType.toLowerCase().indexOf("printit") > -1) {
            _t.trackingType = "MostPrinted";
        }
        else if(trackingType.toLowerCase().indexOf("imit") > -1) {
            _t.trackingType = "MostMessaged";
        }
        else if(trackingType.toLowerCase().indexOf("kickit") > -1) {
            _t.trackingType = "MostKicked";
        }
        else {
            _t.trackingType = "Unknown";
        }
    };
        
    _t.AttachHandlers = function()
    {
        /// <summary>PUBLIC "AttachHandlers" function: initializes object</summary>
        /// <remarks>Attachs event listeners to associated event handlers</remarks>
        if (!_t.isOmni) 
        {
            return;
        }
        
        var toolbarElement = document.getElementById("toolbar");
        var shareItElement = document.getElementById("shareit");
        
        if(document.attachEvent || _t.isIe)
        {
            document.body.detachEvent("onclick",window.s.bc);
            window.attachEvent("onunload",_t.OnDestroy);
            if ( toolbarElement !== null )
            { 
                _t.AttachIeHandlersToElementAnchors(toolbarElement);
            }
            if ( shareItElement !== null )
            {
               _t.AttachIeHandlersToElementAnchors(shareItElement);
            }
        }
        else
        {
            document.body.detachEventListener("click",window.s.bc, false);
            window.addEventListener("unload",_t.OnDestroy, false);
            if ( toolbarElement !== null )
            {
            _t.AttachNonIeHandlersToElementAnchors(toolbarElement);
            }
            if ( shareItElement !== null )
            {
            _t.AttachNonIeHandlersToElementAnchors(shareItElement);
            }
        }
    };
    
    _t.AttachIeHandlersToElementAnchors = function(element)
    {
        var numberOfElementAnchors = element.getElementsByTagName("a").length;
        
        if(numberOfElementAnchors === null)
        {
            return;
        }
        
        var currentAnchor = null;
              
              for(var i=0; i < numberOfElementAnchors; i++)
              {
                  currentAnchor = element.getElementsByTagName("a")[i];
                  currentAnchor.attachEvent("onclick", window.s.bc);
                  currentAnchor.attachEvent("onclick", _t.Track);
              }
    };
    
    _t.AttachNonIeHandlersToElementAnchors = function(element)
    {
        var numberOfElementAnchors = element.getElementsByTagName("a").length;
        
        if(numberOfElementAnchors === null)
        {
            return;
        }
        
        var currentAnchor = null;
    
              for(var i=0; i < numberOfElementAnchors; i++)
              {
                  currentAnchor = element.getElementsByTagName("a")[i];
                  currentAnchor.addEventListener("click", window.s.bc, false);
                  currentAnchor.addEventListener("click", _t.Track, false);
              }
    
    };
    
    _t.OnDestroy = function()
    {
        /// <summary>PUBLIC "OnDestroy" function: destroys object</summary>
        /// <remarks>Detachs event listeners, nulls object properties</remarks>
        if (document.detachEvent || _t.isIe) {
            window.detachEvent("onunload",_t.OnDestroy);
            document.detachEvent("onclick",_t.Track);
        }
        else {
            window.detachEventListener("unload",_t.OnDestroy, false);
            document.detachEventListener("click",_t.Track, false);    
        }

         _t = _t.trackingType = _t.isIe = _t.omniImg = _t.omniSrc = _t.trackImg = null;
    };
        
    _t.Track = function()
    {
    /// <summary>PUBLIC "Track" function: </summary>
    /// <param name="" type=""></param>
    /// <returns></returns>
    /// <remarks></remarks>
        if (window.s && _t.IsToolBarGroupOnClick(window.event.srcElement)) {
          if (window.s.trackExternalLinks) {
              window.s.trackExternalLinks = false;
          }
          _t.PostOminitureTrack();
        }
    };
}

/// <summary>PUBLIC "track_tb" object: custom "ToolbarTracking" object</summary>
var track_tb = new ToolbarTracking();
// initialize tracking object
track_tb.Init();

//---------------
// IM It Functionality
//---------------

updateParentElementId = function(childId, findText, replaceText) //******
{
/// <summary>Updates the class on the parent element of childId</summary>
/// <param name="childId">the id of the child element whose parent class you want to update</param>
/// <param name="findText">text in parent class to be replaced</param>
/// <param name="replaceText">text in parent class to replace findText with</param>
/// <return>void</return>

   var childElement=document.getElementById(childId);
   if (!childElement)
   {
       return;
   }
	    
   var parentElement = childElement.parentElement;
   var parentClass = parentElement.attributes['class'];

   if (!parentClass)
   {
       return;
   }
   
   parentClass = parentClass.value; 	
   
   var classReplaced = parentClass.replace(findText, replaceText);
            
   // set the attribute with the replaced value
   parentElement.attributes['class'].value = classReplaced;
};

testFlash = function()
{
/// <summary>Tests if flash is installed on local machine before initialising it. Otherwise it displays a message in the tooltip</summary>
/// <return>void</return>
    var flashInstalled = GetSwfVer();
    if(!flashInstalled || flashInstalled === -1)
    {
        if (navigator.userAgent.indexOf("MSIE") > -1) //imit is disabled in firefox, so this test is redundant
        {
            imDisable(noFlashMsg);    
        }
        
        updateParentElementId('toolbar_imit', ' popup', ' jspopup');
        return false;
    }
    else
    {
        InitFlashObj();
        return true;
    }
};

/// <summary>OBJECT "imObject": MSNMessenger.P4QuickLaunch ActiveX Object</summary>
/// <remarks>Object for use in imIt which launches IM if object is not null. assigned to below function declarations</remarks>
var imObject = null;
/// <summary>"flashInstalled"</summary>
/// <remarks>bool value used to indicate if Flash is installed on local machine or not</remarks>
var flashInstalled = null;

imCheck = function() {
/// <summary>FUNCTION "imCheck": tests for presence of MSNMessenger.P4QuickLaunch ActiveX Object</summary>
/// <return>Object or null</return>

  function getObject(sname) 
  {
    try { 
        return new ActiveXObject(sname); }
    catch(e) 
    { 
    return null; }
  }
    //If flash is not installed, exit function as IMIt won't work
    if (flashInstalled !== true)
    {
        return;
    }

  var a = null;
  var i = null;
  var obj = getObject("MSNMessenger.P4QuickLaunch");
  
  if (!obj) { 
    obj = null; 
    if (navigator.userAgent.indexOf("MSIE") > -1) { 
        imDisable(noimMsg); }
  }
  return obj;
};

imDisable = function(msg){
/// <summary>FUNCTION "imDisable": render IM link with disabled look and appropriate tooltip</summary>
/// <param name="msg">string value error message for img alt and anchor tooltip</param>

  a = document.getElementById(imLinkId);
   
  if (!a) 
  { 
      return; 
  }
  
  i = a.getElementsByTagName("IMG")[0];
  a.removeAttribute("href");
  
  if (msg!==null && msg!=="") 
  { 
      a.title = i.alt = msg; 
  }
  
  i.src = i.src.replace("/enhanced/imit.gif", "/imit.gif");
};

imIt = function(pname, pval) {
/// <summary>FUNCTION "imIt": opens messenger</summary>
/// <param name="pname">name of parameter</param>
/// <param name="pval">documentid for storing in cookie</param>
/// <remarks>if no appID supplied IM will open session in "Start an Activity" mode (after User selects buddy to contact)</remarks>
/// <remarks>when appID is supplied IM will open session in "Invite" mode (after User selects buddy to contact), launch the IE pane on invite acceptance and paste the web url and a comment in the "Send" area of the Users IM</remarks>
  if (imObject) {
    if (imAppId) {  
      var valueToStoreInFlash = encodeURIComponent(pname + "=" + pval).toLowerCase() + "|" + encodeURIComponent(document.location.href).toLowerCase();
      
      var dataWrittenToFlash = writeFlashObject(valueToStoreInFlash); //get result whether flash save was successful

        try 
        { 
            if (dataWrittenToFlash === true) //only try to launch
            {
               imObject.LaunchApp(imAppId, ""); 
            }
        }
        catch (e) 
        { 
            imDisable(''); 
        } //IM not running
    } 
    else 
    { 
        if (dataWrittenToFlash === true)
        {
            imObject.LaunchApp("", ""); 
        }
    } 
  }
};
    	
writeFlashObject = function(valueToStoreInFlash) 
{
/// <summary>Saves URL of page to local Flash object, to be loaded later in Messenger Activity Page</summary>
// <param name=valueToStoreInFlash>String value to store in Flash object</param>
/// <return>void</return>
    var objFlash = null;
    if (navigator.appName.indexOf("Microsoft") !== -1)
    {
        objFlash = window["myFlash"]
    }

    if (!objFlash)
    {
        return;
    }
    
    return objFlash.saveState(valueToStoreInFlash); //returns true if flash validated input data and stored it
};
     
function InitFlashObj()
{
/// <summary>Initialises Flash Object, which holds param value for IM It activity page</summary>
/// <return>void</return>

    if (typeof(flashVersion) === "undefined") //only initialise flash if the toolbar slot is on the page
    {
        return;
    }
    
		AC_FL_RunContent(
			'codebase', 'http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=9,0,0,0',
			'width', '1',
			'height', '1',
			'src', flashVersion + 'flashobj',
			'quality', 'high',
			'pluginspage', 'http://www.macromedia.com/go/getflashplayer',
			'align', 'middle',
			'play', 'true',
			'loop', 'true',
			'scale', 'showall',
			'wmode', 'window',
			'devicefont', 'false',
			'id', 'myFlash',
			'bgcolor', '#ffffff',
			'name', 'flashobj',
			'menu', 'true',
			'allowFullScreen', 'false',
			'allowScriptAccess','always',
			'movie', flashVersion + 'flashobj',
			'salign', ''
			);  
};

//v1.7
// Flash Player Version Detection
// Detect Client Browser type
// Copyright 2005-2007 Adobe Systems Incorporated.  All rights reserved.
var isIE  = (navigator.appVersion.indexOf("MSIE") != -1) ? true : false;
var isWin = (navigator.appVersion.toLowerCase().indexOf("win") != -1) ? true : false;
var isOpera = (navigator.userAgent.indexOf("Opera") != -1) ? true : false;

function ControlVersion()
{
	var version;
	var axo;
	var e;

	// NOTE : new ActiveXObject(strFoo) throws an exception if strFoo isn't in the registry

	try {
		// version will be set for 7.X or greater players
		axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash.7");
		version = axo.GetVariable("$version");
	} catch (e) {
	}

	if (!version)
	{
		try {
			// version will be set for 6.X players only
			axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash.6");
			
			// installed player is some revision of 6.0
			// GetVariable("$version") crashes for versions 6.0.22 through 6.0.29,
			// so we have to be careful. 
			
			// default to the first public version
			version = "WIN 6,0,21,0";

			// throws if AllowScripAccess does not exist (introduced in 6.0r47)		
			axo.AllowScriptAccess = "always";

			// safe to call for 6.0r47 or greater
			version = axo.GetVariable("$version");

		} catch (e) {
		}
	}

	if (!version)
	{
		try {
			// version will be set for 4.X or 5.X player
			axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash.3");
			version = axo.GetVariable("$version");
		} catch (e) {
		}
	}

	if (!version)
	{
		try {
			// version will be set for 3.X player
			axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash.3");
			version = "WIN 3,0,18,0";
		} catch (e) {
		}
	}

	if (!version)
	{
		try {
			// version will be set for 2.X player
			axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash");
			version = "WIN 2,0,0,11";
		} catch (e) {
			version = -1;
		}
	}
	
	return version;
}

// JavaScript helper required to detect Flash Player PlugIn version information
function GetSwfVer(){
	// NS/Opera version >= 3 check for Flash plugin in plugin array
	var flashVer = -1;
	
	if (navigator.plugins != null && navigator.plugins.length > 0) {
		if (navigator.plugins["Shockwave Flash 2.0"] || navigator.plugins["Shockwave Flash"]) {
			var swVer2 = navigator.plugins["Shockwave Flash 2.0"] ? " 2.0" : "";
			var flashDescription = navigator.plugins["Shockwave Flash" + swVer2].description;
			var descArray = flashDescription.split(" ");
			var tempArrayMajor = descArray[2].split(".");			
			var versionMajor = tempArrayMajor[0];
			var versionMinor = tempArrayMajor[1];
			var versionRevision = descArray[3];
			if (versionRevision == "") {
				versionRevision = descArray[4];
			}
			if (versionRevision[0] == "d") {
				versionRevision = versionRevision.substring(1);
			} else if (versionRevision[0] == "r") {
				versionRevision = versionRevision.substring(1);
				if (versionRevision.indexOf("d") > 0) {
					versionRevision = versionRevision.substring(0, versionRevision.indexOf("d"));
				}
			}
			var flashVer = versionMajor + "." + versionMinor + "." + versionRevision;
		}
	}
	// MSN/WebTV 2.6 supports Flash 4
	else if (navigator.userAgent.toLowerCase().indexOf("webtv/2.6") != -1) flashVer = 4;
	// WebTV 2.5 supports Flash 3
	else if (navigator.userAgent.toLowerCase().indexOf("webtv/2.5") != -1) flashVer = 3;
	// older WebTV supports Flash 2
	else if (navigator.userAgent.toLowerCase().indexOf("webtv") != -1) flashVer = 2;
	else if ( isIE && isWin && !isOpera ) {
		flashVer = ControlVersion();
	}	
	return flashVer;
}

// When called with reqMajorVer, reqMinorVer, reqRevision returns true if that version or greater is available
function DetectFlashVer(reqMajorVer, reqMinorVer, reqRevision)
{
	versionStr = GetSwfVer();
	if (versionStr == -1 ) {
		return false;
	} else if (versionStr != 0) {
		if(isIE && isWin && !isOpera) {
			// Given "WIN 2,0,0,11"
			tempArray         = versionStr.split(" "); 	// ["WIN", "2,0,0,11"]
			tempString        = tempArray[1];			// "2,0,0,11"
			versionArray      = tempString.split(",");	// ['2', '0', '0', '11']
		} else {
			versionArray      = versionStr.split(".");
		}
		var versionMajor      = versionArray[0];
		var versionMinor      = versionArray[1];
		var versionRevision   = versionArray[2];

        	// is the major.revision >= requested major.revision AND the minor version >= requested minor
		if (versionMajor > parseFloat(reqMajorVer)) {
			return true;
		} else if (versionMajor == parseFloat(reqMajorVer)) {
			if (versionMinor > parseFloat(reqMinorVer))
				return true;
			else if (versionMinor == parseFloat(reqMinorVer)) {
				if (versionRevision >= parseFloat(reqRevision))
					return true;
			}
		}
		return false;
	}
}

function AC_AddExtension(src, ext)
{
  if (src.indexOf('?') != -1)
    return src.replace(/\?/, ext+'?'); 
  else
    return src + ext;
}

function AC_Generateobj(objAttrs, params, embedAttrs) 
{ 
  var str = '';
  if (isIE && isWin && !isOpera)
  {
    str += '<object ';
    for (var i in objAttrs)
    {
      str += i + '="' + objAttrs[i] + '" ';
    }
    str += '>';
    for (var i in params)
    {
      str += '<param name="' + i + '" value="' + params[i] + '" /> ';
    }
    str += '</object>';
  }
  else
  {
    str += '<embed ';
    for (var i in embedAttrs)
    {
      str += i + '="' + embedAttrs[i] + '" ';
    }
    str += '> </embed>';
  }

  document.write(str);
}

function AC_FL_RunContent(){
  var ret = 
    AC_GetArgs
    (  arguments, ".swf", "movie", "clsid:d27cdb6e-ae6d-11cf-96b8-444553540000"
     , "application/x-shockwave-flash"
    );
  AC_Generateobj(ret.objAttrs, ret.params, ret.embedAttrs);
}

function AC_SW_RunContent(){
  var ret = 
    AC_GetArgs
    (  arguments, ".dcr", "src", "clsid:166B1BCA-3F9C-11CF-8075-444553540000"
     , null
    );
  AC_Generateobj(ret.objAttrs, ret.params, ret.embedAttrs);
}

function AC_GetArgs(args, ext, srcParamName, classid, mimeType){
  var ret = new Object();
  ret.embedAttrs = new Object();
  ret.params = new Object();
  ret.objAttrs = new Object();
  for (var i=0; i < args.length; i=i+2){
    var currArg = args[i].toLowerCase();    

    switch (currArg){	
      case "classid":
        break;
      case "pluginspage":
        ret.embedAttrs[args[i]] = args[i+1];
        break;
      case "src":
      case "movie":	
        args[i+1] = AC_AddExtension(args[i+1], ext);
        ret.embedAttrs["src"] = args[i+1];
        ret.params[srcParamName] = args[i+1];
        break;
      case "onafterupdate":
      case "onbeforeupdate":
      case "onblur":
      case "oncellchange":
      case "onclick":
      case "ondblclick":
      case "ondrag":
      case "ondragend":
      case "ondragenter":
      case "ondragleave":
      case "ondragover":
      case "ondrop":
      case "onfinish":
      case "onfocus":
      case "onhelp":
      case "onmousedown":
      case "onmouseup":
      case "onmouseover":
      case "onmousemove":
      case "onmouseout":
      case "onkeypress":
      case "onkeydown":
      case "onkeyup":
      case "onload":
      case "onlosecapture":
      case "onpropertychange":
      case "onreadystatechange":
      case "onrowsdelete":
      case "onrowenter":
      case "onrowexit":
      case "onrowsinserted":
      case "onstart":
      case "onscroll":
      case "onbeforeeditfocus":
      case "onactivate":
      case "onbeforedeactivate":
      case "ondeactivate":
      case "type":
      case "codebase":
      case "id":
        ret.objAttrs[args[i]] = args[i+1];
        break;
      case "width":
      case "height":
      case "align":
      case "vspace": 
      case "hspace":
      case "class":
      case "title":
      case "accesskey":
      case "name":
      case "tabindex":
        ret.embedAttrs[args[i]] = ret.objAttrs[args[i]] = args[i+1];
        break;
      default:
        ret.embedAttrs[args[i]] = ret.params[args[i]] = args[i+1];
    }
  }
  ret.objAttrs["classid"] = classid;
  if (mimeType) ret.embedAttrs["type"] = mimeType;
  return ret;
}

flashInstalled = testFlash();
imObject = imCheck();