Initial Commit of the PDM project (ready for DWS migration)

documentation/api_extracted/script/hs-common.js

@@ -0,0 +1,97 @@
+var isDesignTime = false;
+
+/* Utility */
+
+function getNextSibling(n)
+{
+    n=n.nextSibling;
+    while(n)
+    {
+        if(n.nodeType == 1)
+            return n;
+        else
+            n=n.nextSibling;
+    }
+}
+
+/* End Utility */
+
+/* Event wiring */
+
+function hsAddLoadEvent(loadFunc) 
+{
+  var oldFunc = window.onload;
+  if (typeof window.onload != 'function') 
+  {
+    window.onload = loadFunc;
+  } 
+  else {
+    window.onload = function() 
+    {
+      if (oldFunc) {
+        oldFunc();
+      }
+      loadFunc();
+    }
+  }
+}
+
+/* End Event wiring */
+
+/* Returns true if this content is running under Microsoft Help Viewer */
+function hsIsMshv() {
+    return (location.href.indexOf("/ms.help?") != -1)
+}
+
+/* Gets the MSHS base url for resources */
+function hsResourceBaseUrl() {
+
+    if (isDesignTime) {
+        return '';
+    }
+    else {
+        // Get the first script tag
+        var script = document.getElementById('mshs_support_script');
+
+        // Extract the src which is a full resource url to within our origin .mshc
+        var scriptSrc = script.src;
+
+        // Get the portion up to the ; (the base url for resource references)
+        var startIndex = scriptSrc.indexOf(';') + 1;
+        var scriptUrl = scriptSrc.substring(0, startIndex);
+
+        return scriptUrl;
+    }
+}
+
+function hsFixUrl(url) {
+    if (hsIsMshv()) {
+        var originalUrl;
+        if (url.indexOf('127.0.0.1') != -1) {
+            // Chrome - rule returned as full url
+            originalUrl = url.substring(url.indexOf('/', url.indexOf('127.0.0.1')) + 5, url.length);
+        }
+        else {
+            // IE - rule returned as original, with a .. prefix
+            originalUrl = url.substring(url.indexOf('../') + 2, url.lastIndexOf(')'));
+        }
+        if (originalUrl.indexOf("/help/") == -1) {
+            originalUrl = originalUrl.substring(originalUrl.indexOf("/", originalUrl.indexOf("/help/") + 5), originalUrl.length);
+        }
+        originalUrl = originalUrl.replace("\"", "");
+        var newUrl = hsResourceBaseUrl() + originalUrl;
+        return newUrl;
+    }
+    else {
+        return url
+    }
+}
+
+function hsFixRelativeUrl(url) {
+    if (hsIsMshv()) {
+        return hsResourceBaseUrl() + url;
+    }
+    else {
+        return url
+    }
+}

documentation/api_extracted/script/hs-enlargeimage.js

@@ -0,0 +1,77 @@
+// This function retained for legacy and custom Dynamic Image Widgets - current standard Widget uses hsToggleImage below
+//  for localization support
+function hsEnlargeImage(img, link, inplace) {
+    var newsrc;
+    var newlinktext;
+
+    if (img) {
+        if (!img.src)
+            img = documentElement(img);
+
+        if (img) {
+            if (img.src.substring(img.src.length - 9, img.src.length - 4).toLowerCase() == 'thumb') {
+                newsrc = img.src.substring(0, img.src.length - 10) + img.src.substring(img.src.length - 4);
+                newlinktext = link.innerHTML.replace(/enlarge/gi, "shrink");
+            }
+            else {
+                newsrc = img.src.substring(0, img.src.length - 4) + '_thumb' + img.src.substring(img.src.length - 4);
+                newlinktext = link.innerHTML.replace(/shrink/gi, "enlarge");
+            }
+            if (!inplace) {
+                var newimage = new Image();
+                newimage.src = newsrc;
+                hsOpenWindow(newimage.src, newimage.width + 20, newimage.height + 25);
+            }
+            else {
+                img.src = newsrc;
+                link.innerHTML = newlinktext;
+            }
+        }
+    }
+}
+
+function hsToggleImage(img, link, inplace) {
+    var newsrc;
+    var newlinktext;
+    var newlinkimgsrc;
+
+    if (img) {
+        if (!img.src)
+            img = documentElement(img);
+
+        if (img) {
+            var imgId = img.id;
+            var expandDiv = document.getElementById(imgId + "_expand");
+            var shrinkDiv = document.getElementById(imgId + "_shrink");
+            if (img.src.substring(img.src.length - 9, img.src.length - 4).toLowerCase() == 'thumb') {
+                // Currently collapsed - expand
+                expandDiv.style.display = "none";
+                shrinkDiv.style.display = "block";
+                // New img src
+                newsrc = img.src.substring(0, img.src.length - 10) + img.src.substring(img.src.length - 4);
+            }
+            else {
+                // Currently expanded - collapse
+                expandDiv.style.display = "block";
+                shrinkDiv.style.display = "none";
+                // New img src
+                newsrc = img.src.substring(0, img.src.length - 4) + '_thumb' + img.src.substring(img.src.length - 4);
+            }
+            // Update the img with the new src
+            if (!inplace) {
+                var newimage = new Image();
+                newimage.src = newsrc;
+                hsOpenWindow(newimage.src, newimage.width + 20, newimage.height + 25);
+            }
+            else {
+                img.src = newsrc;
+            }
+        }
+    }
+}
+
+function hsOpenWindow(strURL,strWidth,strHeight)
+{
+    /* open a new browser window based on info passed to the function */
+    window.open(strURL,"","Width=" + strWidth + ",Height=" + strHeight,0);
+}

documentation/api_extracted/script/hs-expandcollapse.js

@@ -0,0 +1,87 @@
+function HSToggleSection(id)
+{
+    var element;
+    var img;
+
+    // Find the element
+    element = documentElement(id);
+    img = documentElement(id+"_Image");
+    if (element)
+    {
+        if (element.className=="hs-collapsed")
+        {
+            element.className="hs-expanded";
+            if (img)
+            {
+                img.src = hsFixRelativeUrl("images/hs-expanded.gif");
+            }
+        }
+        else
+        {
+            element.className="hs-collapsed";
+            if (img)
+            {
+                img.src = hsFixRelativeUrl("images/hs-collapsed.gif");
+            }
+        };
+    }
+}
+
+function HSHideOrShowAllCSections(show)
+{
+    var spans
+    var divs
+
+    spans = document.getElementsByTagName("SPAN");
+    if (spans)
+    {
+        for (var spanindex = 0 ; spanindex < spans.length ; spanindex++)
+        {
+            if ((spans[spanindex].className == "hs-collapsed" && show) || (spans[spanindex].className == "hs-expanded" && !show))
+            {
+                HSToggleSection(spans[spanindex].id)
+            }
+        }
+    }
+    divs = document.getElementsByTagName("DIV")
+    if (divs)
+    {
+        for (var divindex = 0 ; divindex < divs.length ; divindex++)
+        {
+            if ((divs[divindex].className == "hs-collapsed" && show) || (divs[divindex].className == "hs-expanded" && !show))
+            {
+                HSToggleSection(divs[divindex].id)
+            }
+        }
+    }
+}
+function HSHideAllCSections()
+{
+    var HSHideAll = documentElement("HSHideAll");
+    var HSShowAll = documentElement("HSShowAll");
+    
+    HSHideOrShowAllCSections(false) 
+    if (HSHideAll)
+    {
+        HSHideAll.style.display="none";
+        if (HSShowAll)
+        {
+            HSShowAll.style.display="block";
+        }
+    }
+}
+function HSShowAllCSections()
+{
+    var HSHideAll = documentElement("HSHideAll");
+    var HSShowAll = documentElement("HSShowAll");
+    
+    HSHideOrShowAllCSections(true)
+    if (HSShowAll)
+    {
+        HSShowAll.style.display="none";
+        if (HSHideAll)
+        {
+            HSHideAll.style.display="block";
+        }
+    }   
+}

documentation/api_extracted/script/hs-heading-expandcollapse.js

@@ -0,0 +1,237 @@
+/* Expand / Collapse Section support */
+
+var collapsedSections = new Array();
+var sectionsLoaded = false;
+
+if (!toggleExpanded) {
+    function toggleExpanded(img) {
+        // Firefox passes in the event object from the event handler, so
+        //  we check for that and set to null
+        if (img) {
+            if (img.tagName == null) {
+                e = img;
+                img = null;
+            }
+        }
+
+        // Find the expand & collapse image
+        if (!img) {
+            if (window.event)
+                e = window.event;
+
+            var img = sourceElement(e)
+            if (img) {
+                while (img) {
+                    if (img.className == "expandcollapse" && img.tagName == "SPAN")
+                        break;
+                    else
+                        img = img.parentNode;
+                }
+                if (img)
+                    img = findExpandCollapseImage(img);
+            }
+        }
+
+
+        if (img) {
+            if (isSectionCollapsed(img.id) == true) {
+                img.src = hsFixRelativeUrl("images/hs-heading-expanded.gif");
+                expandSection(img);
+                removeCollapsedItem(img.id);
+                if (img.id.indexOf("Family", 0) == 0) {
+                    protectedMembers = "on";
+                    configureMembersFilterCheckboxes();
+                    changeMembersFilterLabel();
+                }
+            }
+            else {
+                img.src = hsFixRelativeUrl("images/hs-heading-collapsed.gif");
+                collapseSection(img);
+                addCollapsedSection(img.id);
+            }
+
+            saveSections();
+        }
+    }
+}
+
+function findExpandCollapseImage(sourceElement)
+{
+    var e;
+    var elements;
+
+    if(sourceElement.tagName == "IMG" && sourceElement.className == "toggle")
+    {
+        return(sourceElement);
+    }
+    else
+    {
+        if(sourceElement)
+        {
+            elements = sourceElement.getElementsByTagName("IMG");
+
+            for(var i=0;i<elements.length;i++)
+            {
+                e = elements[i];
+                if(e.className == "toggle")
+                {
+                    return(e);
+                }
+            }
+        }
+    }
+}
+
+if (!toggleExpandedOnKey) {
+    function toggleExpandedOnKey(e) {
+        if (window.event) {
+            e = window.event;
+        }
+
+        if (e.keyCode == 13) {
+            toggleExpanded(findExpandCollapseImage(e.srcElement));
+        }
+    }
+}
+
+function expandSection(imageItem)
+{
+    if(imageItem.id != "toggleExpandedAllImage")
+    {
+        getNextSibling(imageItem.parentNode.parentNode).style.display = "";
+    }
+}
+
+function collapseSection(imageItem)
+{
+    if(imageItem.id != "toggleExpandedAllImage")
+    {
+        getNextSibling(imageItem.parentNode.parentNode).style.display = "none";
+    }
+}
+
+function isSectionCollapsed(imageId)
+{
+    for(var i=0; i < collapsedSections.length; ++i)
+    {
+        if(imageId == collapsedSections[i])
+        {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+function addCollapsedSection(imageId)
+{
+    if(isSectionCollapsed(imageId) == false)
+    {
+        collapsedSections[collapsedSections.length] = imageId;
+    }
+}
+
+function removeCollapsedItem(imageId)
+{
+    for(var i=0; i < collapsedSections.length; ++i)
+    {
+        if(imageId == collapsedSections[i])
+        {
+            collapsedSections.splice(i, 1);
+        }
+    }
+}
+
+function saveSections()
+{
+    var x = 0;
+
+    cleanUserDataStore();
+    for(var i=0; i < collapsedSections.length; ++i)
+    {
+        if(shouldSave(collapsedSections[i]) == true)
+        {
+            save("imageValue" + x, collapsedSections[i]);
+            x++;
+        }
+    }
+}
+
+function loadSections()
+{
+    var i = 0;
+    var imageId = load("imageValue" + i);
+
+    if(!sectionsLoaded)
+    {
+        while(imageId != null)
+        {
+            var imageItem = document.getElementById(imageId);
+
+            if(imageItem != null)
+            {
+                if(imageItem.id.indexOf("Family", 0) == 0)
+                {
+                    if(protectedMembers == "on")
+                    {
+                        toggleExpanded(imageItem);
+                    }
+                }
+                else
+                {
+                    toggleExpanded(imageItem);
+                }
+            }
+            else
+            {
+                addCollapsedSection(imageId);
+            }
+
+            i++;
+            imageId = load("imageValue" + i);
+        }
+        sectionsLoaded = true;
+    }
+    try {
+        setCollapseAll();
+    }
+    catch (e) { }
+}
+
+function shouldSave(imageId)
+{
+    var toggleName;
+
+    if(imageId == "toggleExpandedAllImage")
+    {
+        return false;
+    }
+
+    return true;
+}
+
+function openSectionById(id)
+{
+    var e=documentElement(id);
+
+    if(e)
+    {
+        if(isSectionCollapsed(e.id) == true)
+        {
+            toggleExpanded(e);
+        }
+    }
+}
+
+function cleanUserDataStore()
+{
+    var i = 0;
+    var imageId = load("imageValue" + i);
+
+    while(imageId != null)
+    {
+        removeAttribute("imageValue" + i);
+        i++;
+        imageId = load("imageValue" + i);
+    }
+}

documentation/api_extracted/script/hs-tabstrip.js

@@ -0,0 +1,210 @@
+/* GetSetting SaveSetting Alias */
+if (!hsTabGetSetting) var hsTabGetSetting = function (key)
+{
+    return load(key);
+}
+
+if (!hsTabSaveSetting) var hsTabSaveSetting = function (key, value)
+{
+    save(key, value)
+}
+/* End GetSetting SaveSetting Alias */
+
+/* Tab Strip */
+
+if (!hsSetSelectedTabOnTabstrips) var hsSetSelectedTabOnTabstrips = function ()
+{
+    // Set the default tab on any tab strips
+    var tabDivs = document.getElementsByTagName("DIV")
+    for (var i = 0; i < tabDivs.length; i++)
+    {
+        var div = tabDivs[i];
+        if (div.className == "HsTabStripContainer")
+        {
+            // Load the selected tab from the session cookie
+            var defaultTabName = hsTabGetSetting(div.id + "_SelectedTab");
+            if (defaultTabName)
+                hsSetActiveTabById(div.id, defaultTabName);
+            // Check that a tab is selected
+            var selectedTabName = hsGetSelectedTabName(div);
+            if (!selectedTabName)
+            {
+                var tabs = hsGetTabsFromTabContainer(div, true);
+                if (tabs)
+                    hsSetActiveTab(div, tabs[0]);
+            }
+        }
+    }
+}
+
+if (!hsRefreshSelectedTabOnTabstrips) var hsRefreshSelectedTabOnTabstrips = function ()
+{
+    // Refresh the selected tab on any tab strips
+    var tabDivs = document.getElementsByTagName("DIV")
+    for (var i = 0; i < tabDivs.length; i++)
+    {
+        var div = tabDivs[i];
+        if (div.className == "HsTabStripContainer")
+        {
+            // Get the currently selected tab
+            var selectedTabName = hsGetSelectedTabName(div);
+            hsSetActiveTabById(div.id, selectedTabName);
+            // Now check we have a selection
+            var selectedTabName = hsGetSelectedTabName(div);
+            if (!selectedTabName)
+            {
+                var tabs = hsGetTabsFromTabContainer(div, true);
+                if (tabs)
+                    hsSetActiveTab(div, tabs[0]);
+            }
+        }
+    }
+}
+
+if (!hsSaveSelectedTabs) var hsSaveSelectedTabs = function ()
+{
+    // Save the current tab on any tab strips
+    var tabDivs = document.getElementsByTagName("DIV");
+    for (var i = 0; i < tabDivs.length; i++)
+    {
+        var div = tabDivs[i];
+        if (div.className == "HsTabStripContainer")
+        {
+            var selectedTabName = hsGetSelectedTabName(div);
+            hsTabSaveSetting(div.id + "_SelectedTab", selectedTabName);
+        }
+    }
+}
+
+if (!hsSetActiveTabById) var hsSetActiveTabById = function (containerName, tabName)
+{
+    if (containerName && tabName)
+    {
+        var container = document.getElementById(containerName);
+        var childNodes = container.childNodes;
+        for (var i = 0; i < childNodes.length; i++)
+        {
+            var childNode = childNodes[i];
+            if (childNode.id == tabName)
+            {
+                return hsSetActiveTab(container, childNode);
+            }
+        }
+    }
+
+    hsSaveSelectedTabs();
+}
+
+if (!hsGetNextDiv) var hsGetNextDiv = function (div)
+{
+    do
+    {
+        if (div.nextSibling)
+        {
+            div = div.nextSibling;
+            if (div.tagName && div.tagName == "DIV" && div.style.display != "none")
+                return div;
+        }
+    } while (div.nextSibling);
+}
+
+if (!hsGetPreviousDiv) var hsGetPreviousDiv = function (div)
+{
+    do
+    {
+        if (div.previousSibling)
+        {
+            div = div.previousSibling;
+            if (div.tagName && div.tagName == "DIV" && div.style.display != "none")
+                return div;
+        }
+    } while (div.previousSibling);
+}
+
+if (!hsSetActiveTab) var hsSetActiveTab = function (container, tab)
+{
+    if (container && tab)
+    {
+        var childNodes = container.childNodes;
+        for (var i = 0; i < childNodes.length; i++)
+        {
+            var childNode = childNodes[i];
+            if (childNode.tagName && childNode.tagName == "DIV" && (childNode.className == "HsTab" || childNode.className.indexOf(" HsTab") == childNode.className.length - 6))
+            {
+                var isActiveTab = (childNode == tab);
+                if (isActiveTab)
+                    childNode.className = "HsTabActive HsTab";
+                else
+                    childNode.className = "HsTab";
+                // If this tab is visible, update the adjacent left / right end 
+                if (childNode.style.display != 'none')
+                {
+                    if (hsGetNextDiv(childNode) && hsGetNextDiv(childNode).className && hsGetNextDiv(childNode).className.indexOf("HsTabRightEnd") != -1)
+                    {
+                        /* Last tab, update right end */
+                        var rightEnd = hsGetNextDiv(childNode);
+                        if (isActiveTab)
+                            rightEnd.className = "HsTabRightEndActive HsTabRightEnd";
+                        else
+                            rightEnd.className = "HsTabRightEnd";
+                    }
+                    if (hsGetPreviousDiv(childNode) && hsGetPreviousDiv(childNode).className && hsGetPreviousDiv(childNode).className.indexOf("HsTabLeftEnd") != -1)
+                    {
+                        /* First tab, update right end */
+                        var leftEnd = hsGetPreviousDiv(childNode);
+                        if (isActiveTab)
+                            leftEnd.className = "HsTabLeftEndActive HsTabLeftEnd";
+                        else
+                            leftEnd.className = "HsTabLeftEnd";
+                    }
+                }
+                /* Find related content div and show/hide */
+                hsShowOrHideTabContentSection(childNode.id + "_Content", isActiveTab);
+            }
+        }
+    }
+}
+
+if (!hsShowOrHideTabContentSection) var hsShowOrHideTabContentSection = function (id, isVisible)
+{
+    var contentDiv = document.getElementById(id);
+    if (contentDiv)
+    {
+        if (isVisible)
+            contentDiv.style.display = "block";
+        else
+            contentDiv.style.display = "none";
+    }
+}
+
+if (!hsGetSelectedTabName) var hsGetSelectedTabName = function (container)
+{
+    var tabs = hsGetTabsFromTabContainer(container, true);
+    if (tabs)
+    {
+        for (var tabIndex = 0; tabIndex < tabs.length; tabIndex++)
+        {
+            var tab = tabs[tabIndex];
+            if (tab.className.indexOf("HsTabActive") != -1)
+                return tab.id;
+        }
+    }
+}
+
+if (!hsGetTabsFromTabContainer) var hsGetTabsFromTabContainer = function (container, visibleOnly)
+{
+    var tabs = [];
+    var childNodes = container.childNodes;
+    for (var i = 0; i < childNodes.length; i++)
+    {
+        var childNode = childNodes[i];
+        if (childNode.tagName && childNode.tagName == "DIV" && (childNode.className == "HsTab" || (childNode.className.indexOf(" HsTab") == childNode.className.length - 6)))
+        {
+            if (!visibleOnly || childNode.style.display != "none")
+                tabs[tabs.length] = childNode;
+        }
+    }
+    return tabs;
+}
+
+/* End Tab Strip */

documentation/api_extracted/script/languagefilter.js

@@ -0,0 +1,438 @@
+window.onload = hsLanguageFilteredBodyLoad;
+
+// Current language
+var curLang = "";
+
+function hsLanguageFilteredBodyLoad()
+{
+
+    var i;
+    var b;
+    var l;
+
+    bodyLoadCommonBefore();
+
+    // Check the context window for current language.
+    try
+    {
+        for (i=1; i< window.external.ContextAttributes.Count; i++)
+        {
+            if(window.external.ContextAttributes(i).Name.toUpperCase()=="DEVLANG")
+            {
+                b = window.external.ContextAttributes(i).Values.toArray();
+                curLang = b[0].toUpperCase();
+            }
+        }
+    }
+    catch(e)
+    {
+    }
+
+    if (curLang != null)
+    {
+        if (curLang.indexOf("VB") != -1)
+        {
+            curLang = "VB";
+        }
+        if (curLang.indexOf("VC") != -1)
+        {
+            curLang = "CPP";
+        }
+        if (curLang.indexOf("C++") != -1)
+        {
+            curLang = "CPP";
+        }
+        if (curLang.indexOf("CSHARP") != -1)
+        {
+            curLang = "CS";
+        }
+        if (curLang.indexOf("JSCRIPT") != -1)
+        {
+            curLang = "JScript";
+        }
+    }
+
+    if (curLang == null)
+    {
+        l = "";
+        var multipleLang = false;
+        var cLang = "";
+
+        try
+        {
+            l = window.external.Help.FilterQuery.toUpperCase();
+        }
+        catch(e)
+        {
+        }
+
+        if (l.indexOf("VB") != -1)
+        {
+            cLang = "VB";
+        }
+
+        if (l.indexOf("VC") != -1)
+        {
+            if (cLang != null)
+            {
+                multipleLang = true;
+            }
+            cLang = "CPP";
+        }
+
+        if (l.indexOf("C#") != -1)
+        {
+            if (cLang != null)
+            {
+                multipleLang = true;
+            }
+            cLang = "CS";
+        }
+
+        if (l.indexOf("CSHARP") != -1)
+        {
+            if (cLang != null)
+            {
+                multipleLang = true;
+            }
+            cLang = "CS";
+        }
+
+        if (l.indexOf("JSCRIPT") != -1)
+        {
+            if (cLang != null)
+            {
+                multipleLang = true;
+            }
+            cLang = "JScript";
+        }
+
+        if (l.indexOf("JSHARP") != -1)
+        {
+            if (cLang != null)
+            {
+                multipleLang = true;
+            }
+            cLang = "JSHARP";
+        }
+
+        if (multipleLang == false)
+        {
+            curLang = cLang;
+        }
+    }
+
+    bodyLoadCommonAfter();
+    
+    // load the languages   
+    loadLanguages();
+    configureLanguageCheckboxes();
+    displayLanguages();    
+    
+    window.onunload = hsLanguageFilteredWindowUnload;  
+    
+    if(parent)
+        parent.loaded = true;
+
+}
+
+function hsLanguageFilteredWindowUnload()
+{
+    saveLanguages();    
+    windowUnload();
+}
+
+function loadSettings()
+{
+    loadSettingsCommon();
+    
+    // load the community feature states
+    try
+    {
+        ic_loadCommunityFeatureStates();
+    }
+    catch(ex) {}     
+}
+
+function saveSettings()
+{
+    saveSettingsCommon();
+
+    // Community
+    try {ic_saveCommunityFeatureStates();} catch(ex) {}       
+}
+
+/* Language Filtering */
+
+var languageNames;
+var languageStates;
+
+function configureLanguageCheckboxes()
+{
+    var checkbox;
+        
+    for(var i=0;i<languageNames.length;i++)
+    {
+        checkbox = documentElement(languageNames[i] + "Checkbox");
+
+        if(languageStates[i] == "on")
+        {
+            checkbox.checked = true;
+        }
+        else
+        {
+            checkbox.checked = false;
+        }
+    }
+}
+
+function setLanguage(key)
+{
+    var languageName = key.id.substring(0,key.id.indexOf("Checkbox"));
+
+    if(getLanguageState(languageName) == "on")
+    {
+        // Always have at least one selected
+        if(getLanguageTickedCount() == 1)
+        {
+            key.checked = true;
+            return;
+        }
+
+        setLanguageState(languageName,"off");
+        key.checked = false;
+    }
+    else
+    {
+        setLanguageState(languageName,"on");
+        key.checked = true;
+    }
+        
+    // Update the content to reflect the new language filter
+    displayLanguages();
+}
+
+function displayLanguages()
+{
+    var pres = document.getElementsByTagName("DIV");
+    var pre;
+    var found;
+    var languageName;
+
+    if (pres)
+    {
+        for (var iPre = 0; iPre < pres.length; iPre++)
+        {
+            pre = pres[iPre];
+            
+            if (pre.id && pre.className)
+            {
+                if (pre.className == "LanguageSpecific")
+                {
+                    found = true;
+
+                    if (pre.id.substring(pre.id.length-1,pre.id.length) != "_")
+                    {                    
+                        for(var i=0;i<languageNames.length;i++)
+                        {
+                            if(languageStates[i] == "off")
+                            {
+                                languageName = languageNames[i].toUpperCase();
+
+                                // For each language specific element except the Syntax, treat CPP2005 as CPP
+                                if (languageName == "CPP2005" && pre.id.toUpperCase().indexOf("SYNTAX") == -1)
+                                {
+                                    languageName = "CPP";
+                                }
+
+                                if ((pre.id.toUpperCase().indexOf(languageName) != -1 && pre.id.toUpperCase().indexOf(languageName) == (pre.id.length - languageName.length)) || (pre.id.toUpperCase().indexOf(languageName + ".NET") != -1 && pre.id.toUpperCase().indexOf(languageName + ".NET") == (pre.id.length - languageName.length - 4)))
+                                {
+                                    found = false;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    
+                    if(found)
+                    {
+                        pre.style.display = "block";
+                    }
+                    else
+                    {
+                        pre.style.display = "none";
+                    }
+                }
+            }
+        }
+    }
+    
+    changeLanguageFilterLabel();
+}
+
+function getLanguageState(LanguageName)
+{
+    for(var i=0;i<languageNames.length;i++)
+    {
+        if(languageNames[i] == LanguageName)
+        {
+            return(languageStates[i]);
+        }
+    }
+}
+
+function setLanguageState(LanguageName,Value)
+{
+    for(var i=0;i<languageNames.length;i++)
+    {
+        if(languageNames[i] == LanguageName)
+        {
+            languageStates[i] = Value;
+        }
+    }
+}
+
+function getLanguageTickedCount()
+{
+    var tickedCount=0;
+    var labelElement;
+        
+    for(var i=0;i<languageNames.length;i++)
+    {
+        if(languageStates[i] == "on")
+        {
+            tickedCount++;
+        }
+    }
+        
+    return(tickedCount);
+}
+
+function changeLanguageFilterLabel()
+{
+    var tickedCount=0;
+    var labelElement;
+    var languageName;
+        
+    if(!document.getElementById("showAllLabel"))
+    {
+        return;
+    }
+        
+    for(var i=0;i<languageNames.length;i++)
+    {
+        if(languageStates[i] == "on")
+        {
+            tickedCount++;
+        }
+                        
+        labelElement = documentElement(languageNames[i] + "label");
+        
+        if(labelElement != null)
+        {
+            labelElement.style.display = "none";
+        }
+    }
+        
+    document.getElementById("showAllLabel").style.display = "none";
+    document.getElementById("multipleLabel").style.display = "none";
+        
+    if(tickedCount == languageNames.length)
+    {
+        document.getElementById("showAllLabel").style.display = "inline";
+    }
+    else if ((tickedCount > 1) && (tickedCount < languageNames.length))
+    {
+        if((tickedCount == 2) && (getLanguageState("VB") == "on") && (getLanguageState("vbUsage") == "on"))
+        {
+            document.getElementById("VBLabel").style.display = "inline";
+        }
+        else
+        {
+            document.getElementById("multipleLabel").style.display = "inline";
+        }
+    }
+    else if (tickedCount == 1)
+    {
+        for(var i=0;i<languageNames.length;i++)
+        {
+            if(languageStates[i] == "on")
+            {
+                if(languageNames[i] == "vbUsage")
+                {
+                    languageName = "VB";
+                }
+                else
+                {
+                    languageName = languageNames[i];
+                }
+                
+                document.getElementById(languageName + "Label").style.display = "inline";
+            }
+        }
+    }
+}
+
+function loadLanguages()
+{
+    var languageName;
+    var language;
+    var allNull;
+
+    // Build an array of this pages language names and state
+    languageNames = new Array();
+    languageStates = new Array();
+        
+    var elements = document.getElementsByName("languageFilter");
+        
+    allNull = true;
+    
+    for(var i=0;i<elements.length;i++)
+    {
+        var input = elements[i];
+                
+        languageNames[i] = input.id.substring(0,input.id.indexOf("Checkbox"));
+        var value = load("lang_" + languageNames[i]);
+        
+        if(value == null)
+        {
+            languageStates[i] = "on";
+        }
+        else
+        {
+            allNull = false;
+            languageStates[i] = value;
+        }
+    }
+        
+        // If no language preference has been established and we have an indicator of the current
+        //  language, set the languages filtered to only the current language
+    if(allNull && curLang.length > 0)
+    {
+        for(var i=0;i<elements.length;i++)
+        {
+            if(languageNames[i].toUpperCase() == curLang.toUpperCase())
+            {
+                languageStates[i] = "on";
+            }
+            else
+            {
+                languageStates[i] = "off";
+            }
+        }
+    }
+}
+
+function saveLanguages()
+{
+    if(languageNames)
+    {
+        for(var i=0;i<languageNames.length;i++)
+        {
+            var value = languageStates[i];
+            save("lang_" + languageNames[i], value);
+        }
+    }
+}
+
+/* End Language Filtering */