function Navigation()
{
/*
This is the Navigation class, which is updated and accessed through the AEnavigation Active Element.
At the moment the Navigation class is defined in the same file as the Navigation AE but as a separate
entity.
*/

    this.NavSiteDetails = new Array;
    this.NavScreenDetails = new Array;
    this.NavRegionDetails = new Array;
    this.NavCategoryDetails = new Array;
    this.NavStatus = "begin";
    this.NavCurrentScreen = 'none';
    this.NavPreviousScreen = 'none';

    D.debug("Starting Navigation Constructor");

    this.AddWebsiteDetails = function(siteDetails)
    {
        D.debugStartFunction("AddWebsiteDetails", arguments);
        
        this.NavSiteDetails['siteName']       = siteDetails['siteName'];
        this.NavSiteDetails['siteHomePage']   = siteDetails['siteHomePage'];   // Screen name of home page
        this.NavSiteDetails['siteCategories'] = siteDetails['siteCategories']; // Probably an array
        this.NavSiteDetails['siteRegions']    = siteDetails['siteRegions'];    // Probably an array
        this.NavSiteDetails['rootDir']        = siteDetails['rootDir'];
        this.NavSiteDetails['dirStructure']   = siteDetails['dirStructure'];   // Array of main directories in website
        
        D.debugEndFunction();
    }
    
    this.NavAddScreen = function(screenDetails)
    {
        /*
        Screens will be added in the order in which they appear in the XML file.  This is important, as we want the user
        to be able to control the order of links in navbars by placing them in the XML file in a particular order.
        
        In order to preserve the order we need to index numerically rather than by screen name (which was the original
        intention).
        */
        
        D.debugStartFunction("AddScreen", arguments);

        var newScreen = screenDetails['Name'];
        var nextIndex = this.NavScreenDetails.length;
        var regionScreen = "";
        
        D.debug("Adding screen " + nextIndex + ", name = " + newScreen);
        
        this.NavScreenDetails[nextIndex] = new Array;
        
        this.NavScreenDetails[nextIndex]['screenName']       = screenDetails['Name'];
        this.NavScreenDetails[nextIndex]['screenTitleLong']  = screenDetails['Details']['screenTitleLong'];
        this.NavScreenDetails[nextIndex]['screenTitleShort'] = screenDetails['Details']['screenTitleShort'];
        this.NavScreenDetails[nextIndex]['screenTemplate']   = screenDetails['Details']['screenTemplate'];
        this.NavScreenDetails[nextIndex]['screenParent']     = screenDetails['Details']['screenParent'];
        this.NavScreenDetails[nextIndex]['screenRegion']     = screenDetails['Details']['screenRegion'];
        this.NavScreenDetails[nextIndex]['screenCategories'] = screenDetails['Details']['screenCategories'];
        
        if (screenDetails['Details']['screenRegion'] != "")
        {
            D.debug("Screen region specified, is '" + screenDetails['Details']['screenRegion'] + "'");
            
            // This screen is explicitly assigned to a region so add it to the list of regions.
                
            if (screenDetails['Details']['screenRegionHome'] == "true")
            {
                regionScreen = screenDetails['Name'];
            }
            this.NavAddRegion(screenDetails['Details']['screenRegion'], regionScreen);
        }
        
        D.debug("Screen Details : " + dump(this.NavScreenDetails[nextIndex]));
        D.debugEndFunction();
    }
    
    this.NavAddRegion = function(pRegion, pScreenName)
    {
        /*
        Adds this region to the list of regions if not already on it.  Also if a screen name is
        specified then this is the home page for that region (if not already present)
        */
        
        var i;
        
        D.debugStartFunction("AddRegion", arguments);
        
        var alreadyGotRegion = false;
        var screenProvided = false;
        var numRegions = this.NavGetNumRegions();
        var regionIndex = numRegions;
        
        // Can ignore if we have already got this region, but not if we have been given the home page for the region
        
        screenProvided = (pScreenName && pScreenName != "");
        
        for (i=0; i<numRegions && !alreadyGotRegion; i++)
        {
            D.debug("Looking for existing region at entry " + i);
            if (this.NavRegionDetails[i]['regionName'] == pRegion)
            {
                D.debug("found region");
                alreadyGotRegion = true;
                regionIndex = i;
            }
        }
        

        if (!alreadyGotRegion)
        {
            // Always use numRegions when adding to the array
            
            D.debug("Region " + pRegion + " will be added at entry " + numRegions);        
            
            this.NavRegionDetails[numRegions] = new Array;
            this.NavRegionDetails[numRegions]['regionName'] = pRegion;
        }
        if (screenProvided)
        {
            // Use regionIndex as could be adding to an existing entry not a new one
            
            D.debug("Screen '" + pScreenName + "' is the home screen for region '" + pRegion + "'");
            D.debug("Entry for region " + pRegion + " is " + regionIndex);
            this.NavRegionDetails[regionIndex]['regionHomeScreen'] = pScreenName;
        }
        D.debugEndFunction();
    }
    
    this.NavGetScreenIndex = function(pScreenName)
    {
        // D.debugStartFunction("GetScreenIndex", arguments);
        
        var i;
        var numScreens = this.NavGetNumScreens();
        
        for (i=0; i<numScreens && this.NavScreenDetails[i]['screenName'] != pScreenName; i++)
        {
            // Loop is just search, no processing
        }
        
        if (i < numScreens)
        {
            ret = i;
        }
        else
        {
            ret = false;
        }
        
        // D.debug("Index for " + pScreenName + " is " + i);
        // D.debugEndFunction();
        return ret;
    }
    
    this.NavGetScreenFromIndex = function(pIndex)
    {
        return this.NavScreenDetails[pIndex]['screenName'];
    }
    
    this.NavGetHomePage = function()
    {
        return this.NavSiteDetails['siteHomePage'];
    }

    this.NavGetNumScreens = function()
    {
        return this.NavScreenDetails.length;
    }
    
    this.NavGetNumRegions = function()
    {
        return this.NavRegionDetails.length;
    }
    
    this.NavGetTemplateName = function(pScreen)
    {
        D.debugStartFunction("NavGetTemplateName", arguments);
        
        var template = this.NavScreenDetails[this.NavGetScreenIndex(pScreen)]['screenTemplate'];
        
        D.debugEndFunction();
        return template;
    }

    this.NavGetScreenTitleLong = function(pScreen)
    {
        var index = this.NavGetScreenIndex(pScreen);
        var ret;
        
        if (false === index)
        {
            ret = false;
        }
        else
        {
            ret = this.NavScreenDetails[index]['screenTitleLong'];
        }
        return ret;
    }
    
    this.NavGetScreenTitleShort = function(pScreen)
    {
        var index = this.NavGetScreenIndex(pScreen);
        var ret;
        
        if (false === index)
        {
            ret = false;
        }
        else
        {
            ret = this.NavScreenDetails[index]['screenTitleShort'];
        }
        return ret;
    }
    
    this.NavGetScreenRegion = function(pScreen)
    {
        /*
        Calculates the region a screen is in.  Checks whether region is set, and if not
        recursively call same function with parent.  If gets to top of tree (no parent) then
        set region to "NoRegion"
        */
        
        var region;
        var index = this.NavGetScreenIndex(pScreen);
        var parent;
        
        if (false === index)
        {
            region = "NoRegion";
        }
        else
        {
            region = this.NavScreenDetails[index]['screenRegion'];
            
            if (region == "")
            {
                // alert("NavGetScreenRegion : pScreen = " + pScreen);
                parent = this.NavGetParent(pScreen);
                if (parent == "")
                {
                    region = "NoRegion";
                }
                else
                {
                    region = this.NavGetScreenRegion(parent);
                }
            }
        }
        return region;
    }
    
    this.NavCreateLinkData = function(pLinkArray, pBaseScreen)
    {
        /*
        Takes an array of screen names and a base screen name and returns an
        array containing data which can be used to create an HTML linkbar, which is:
        - HREF
        - text
        - (others - may need target, title etc but not straight away)
         
        This function does NOT create the final HTML linkbar, as we need the
        flexibility to alter information before generating HTML (e.g. we may
        not wish to use the standard title for a page but use HOME, Previous, Next
        etc.
         
        linkArray is an array of screen names 
        baseScreen : is the screen from which HREFs are to be calculated (not always current screen!)
        */
        
        D.debugStartFunction("NavCreateLinkData", arguments);
        
        var i; // Using numerical indexes as we need to retain the order
        var linkData = new Array;
        
        for (i=0; i<pLinkArray.length; i++)
        {
            linkData[i] = new Array;
            linkData[i]['href'] = this.NavCreateHREF(pBaseScreen, pLinkArray[i]);
            linkData[i]['text'] = this.NavScreenDetails[pLinkArray[i]]['screenTitleShort'];
        }
        D.debugEndFunction();
        return linkData;
    }
    
    this.NavProcessNavXML = function(pXML)
    {
        // Processes the XML received from the server and updates the local structure with website
        // navigation information.
        
        D.debug("pXML = " + pXML);
        D.debug("pXML.nodeName = " + pXML.nodeName);
        D.debug("pXML.firstChild.nextSibling.nodeName = " + pXML.firstChild.nextSibling.nodeName);

        siteData = pXML.getElementsByTagName("siteDetails");
        D.debug("siteData.length = " + siteData.length);
        var siteDataArray = new Array;
        siteDataArray['siteName'] = siteData[0].getElementsByTagName("siteName")[0].firstChild.nodeValue;
        siteDataArray['siteHomePage'] = siteData[0].getElementsByTagName("siteHomePage")[0].firstChild.nodeValue;
        // siteDataArray['siteCategories'] = (siteData[0].getElementsByTagName("siteCategories")[0].firstChild) ? siteDataArray['siteCategories'] = siteData[0].getElementsByTagName("siteCategories")[0].firstChild.nodeValue : "";
        // siteDataArray['siteRegions'] = (siteData[0].getElementsByTagName("siteRegions")[0].firstChild) ? siteDataArray['siteRegions'] = siteData[0].getElementsByTagName("siteRegions")[0].firstChild.nodeValue : "";
        
        // put this in an associative array
        this.AddWebsiteDetails( siteDataArray );
        
        screenData = pXML.getElementsByTagName("screen");
        // this gives us an array of screen data
        
        D.debug("There are " + screenData.length + " screens");
        for (i=0; i<screenData.length; i++)
        {
            var longTitle = extractNodeValue(screenData[i], "screenTitleLong");
            var shortTitle = extractNodeValue(screenData[i], "screenTitleShort");
            var screenName = extractNodeValue(screenData[i], "screenName");
            
            if (longTitle == "")
            {
                D.warn("No long title for screen " + screenName);
            }
            if (shortTitle == "" && longTitle != "")
            {
                {
                    D.warn("No short title for screen " + screenName + ", setting to long title = " + longTitle);
                    shortTitle = longTitle;
                }
            }
            
            this.NavAddScreen({ Name: screenName,
                                Details:
                                  {screenTitleLong:  longTitle,
                                   screenTitleShort: shortTitle,
                                   screenTemplate:   extractNodeValue(screenData[i], "screenTemplate"),
                                   screenParent:     extractNodeValue(screenData[i], "screenParent"),
                                   screenRegion:     extractNodeValue(screenData[i], "screenRegion"),
                                   screenRegionHome: extractNodeValue(screenData[i], "screenRegionHome"),
                                   screenCategories: extractNodeValue(screenData[i], "screenCategories")
                                  }
                             });
        }
    }

    this.NavAddScreenInfo = function(pScreenName)
    {
        // Creates and returns entries for all information which might be required about a screen
        // in order to include it in a link bar.
        
        var element = new Array;
        
        element['screenName'] = pScreenName;
        element['text'] = "";
        element['class'] = new Array;
        element['href'] = "";
        
        return element;
    }

    this.NavAssembleHTMLLinkbar = function(pLinkData)
    {
        D.debugStartFunction("NavAssembleHTMLLinkbar", arguments);
        
        var HTMLclass = "";
        var separator = "";
        var i, j;
        var HTML = "<ul>";
        var href = "";
        
        if (false === pLinkData)
        {
            // false so no data, just create well formed but empty linked list
            
            HTML = "<ul class=\"empty\"></ul>";
        }
        else
        {        
            for (i=0; i<pLinkData.length; i++)
            {
                HTMLclass = "";
                separator = "";
                if (pLinkData[i]['class'])
                {
                    for (j=0; j<pLinkData[i]['class'].length; j++)
                    {
                        HTMLclass += separator + pLinkData[i]['class'][j];
                        separator = " ";
                    }
                    if (HTMLclass != "")
                    {
                        HTMLclass = " class=\"" + HTMLclass + "\"";
                    }
                }
                
                href = pLinkData[i]['href'] == "" ? "" : " href=\"" + pLinkData[i]['href'] + "\"";
                
                HTML +=  "<li" + HTMLclass + ">" +
                        "<a" + href +
                        " title=\"" + pLinkData[i]['text'] + "\">" +
                        pLinkData[i]['text'] +
                        "</a>" +
                        "</li>";
            }
            HTML += "</ul>";
        }
        D.debugEndFunction();
        return HTML;
    }
    
    this.NavCreateHref = function(pBaseScreen, pTargetScreen)
    {
        /*
        This function calculates the href from BaseScreen to TargetScreen.  If the target screen is
        blank, or the target screen is the same as the BaseScreen, then no href should be calculated.
        */
        
        D.debugStartFunction("NavCreateHref", arguments);
        
        var href;
        
        if (href == "" || pBaseScreen == pTargetScreen)
        {
            href = ""
        }
        else
        {
            href = "javascript:pageAE.aeScreenChange(" + "'" + pTargetScreen + "')";
        }
        
        D.debugEndFunction();
        return href;
    }
    
    this.NavCalculateListHrefs = function(pList, pScreen)
    {
        var i;
        var status = true;
       
        D.debugStartFunction("NavCalculateListHrefs", arguments);
        
        for (i=0; i<pList.length; i++)
        {
            if ("" != pList[i]['screenName'])
            {
                pList[i]['href'] = this.NavCreateHref(pScreen, pList[i]['screenName']);
            }
            else
            {
                pList[i]['href'] = "";
            }
        }
        
        D.debugEndFunction();
        return status;
    }

    this.NavCalculateBaseScreen = function(pBaseSpecifier, pCurScreen)
    {
        var baseScreen = pCurScreen;
        
        switch (pBaseSpecifier)
        {
            case "home" :
                baseScreen = this.NavGetHomePage();
            break;
        
            case "this" :
                baseScreen = pCurScreen;
            break;
        
            case "regionHome" :
                baseScreen = this.NavGetRegionHome(pCurScreen);
            break;

            case "parent" :
                baseScreen = this.NavGetParent(pCurScreen);
            break;
        
            case "firstChild" :
                baseScreen = this.NavGetFirstChild(pCurScreen);
            break;
        
            case "lastChild" :
                baseScreen = this.NavGetLastChild(pCurScreen);
            break;
        
            case "prevSibling" :
                baseScreen = this.NavGetPrevSibling(pCurScreen);
            break;
        
            case "nextSibling" :
                baseScreen = pCurScreen;
            break;
        
            case "previousVisited" :
                baseScreen = pCurScreen;
            break;
        
            case "nextVisited" :
                baseScreen = pCurScreen;
            break;
        
            default:
                D.warn("base Specifer " + pBaseSpecifier + " not recognised");
                baseScreen = false;
            break;
        }
        return baseScreen;
    }

    this.NavCreateInitialList = function(pParamData, pCurScreen)
    {
        /*
        This function will create the list of screen names which will form the basis of the
        link bar, using the parameters to work out which screens to include.
        */

        D.debugStartFunction("NavCreateInitialList", arguments);
        
        var initialList = new Array;
        var baseSpec = pParamData['baseScreen'];
        var baseScreen = this.NavCalculateBaseScreen(baseSpec, pCurScreen);
        var i;
        
        D.debug("baseSpec = " + baseSpec);
        D.debug("baseScreen = " + baseScreen);
        
        if (false === baseScreen) { baseScreen = pCurScreen; }
        
        switch (pParamData['screenListSpecifier'])
        {
            case "none" :
            break;
            
            case "base" :
                initialList[0] = new Array;
                initialList[0]['screenName'] = baseScreen;
                initialList[0]['text'] = this.NavGetScreenTitleShort(initialList[0]['screenName']);
            break;
    
            case "home" :
                initialList[0] = new Array;
                initialList[0]['screenName'] = this.NavGetHomePage();
                initialList[0]['text'] = "Home";
            break;
    
            case "parent" :
                initialList[0] = new Array;
                initialList[0]['screenName'] = this.NavGetParent(baseScreen);
                initialList[0]['text'] = initialList[0]['screenName'];
            break;
    
            case "firstChild" :
                initialList[0] = new Array;
                initialList[0]['screenName'] = this.NavGetFirstChild(baseScreen);
                initialList[0]['text'] = initialList[0]['screenName'];
            break;
    
            case "lastChild" :
                initialList[0] = new Array;
                initialList[0]['screenName'] = this.NavGetLastChild(baseScreen);
                initialList[0]['text'] = initialList[0]['screenName'];
            break;
    
            case "prevSibling" :
                initialList[0] = new Array;
                initialList[0]['screenName'] = this.NavGetPrevSibling(baseScreen);
                initialList[0]['text'] = initialList[0]['screenName'];
            break;
    
            case "nextSibling" :
                initialList[0] = new Array;
                initialList[0]['screenName'] = this.NavGetNextSibling(baseScreen);
                initialList[0]['text'] = initialList[0]['screenName'];
            break;
    
            case "children" :
                D.debug("Calling GetChildren with base = " + baseScreen);
                initialList = this.NavGetChildren(baseScreen, false);
            break;
        
            case "childrenFirstChild" :
                initialList = this.NavGetChildren(baseScreen, true);
            break;
    
            case "siblings" :
                initialList = this.NavGetSiblings(baseScreen);
            break;
        
            case "fChildOfRegions" :
                var regionList = this.NavGetRegions();
                for (i=0; i<regionList.length; i++)
                {
                    initialList[i] = new Array;
                    initialList[i]['screenName'] = this.NavGetFirstChild(regionList[i]['regionHomeScreen']);
                    initialList[i]['text'] = regionList[i]['regionName'];
                }
                D.debug("Region initialList = :");
                D.debug(dump(initialList));
            break;
        
            default:
            D.debug("Modifier not recognised" + pParamData['screenListSpecifier']);
            break;
        }
        D.warn("Ending createInitialList");
        D.debugEndFunction();
        return initialList;
    }

    /*
    The following are the various methods for calculating specified pages relative to the current
    page.
    */

    this.NavGetParent = function(pCurScreen)
    {
        var index = this.NavGetScreenIndex(pCurScreen);
        var parent;
        
        //alert("NavGetParent: Index = " + index);
        
        if (false === index)
        {
            //alert("Parent not found!")
            parent = this.NavSiteDetails['siteHomePage']; // Better than nothing!
        }
        else
        {
            //alert("Just before assignment...")
            parent = this.NavScreenDetails[index]['screenParent'];
        }
        //alert("Returning from NavGetParent, parent = " + parent);
        return parent;
    }

    this.NavGetFirstChild = function(pScreen)
    {
        var i;
        var ret = false;
        var screen_i;
        
        for (i=0; i<this.NavGetNumScreens() && (this.NavGetParent(this.NavGetScreenFromIndex(i))) != pScreen; i++)
        {
            // Just a search loop, no processing
        }
        
        if (i == this.NavGetNumScreens())
        {
            ret = false;
        }
        else
        {
            ret = this.NavGetScreenFromIndex(i);
        }
        return ret;
    }

    this.NavGetLastChild = function(pCurScreen)
    {
        /*
        This function works differently from GetFirstChild as we have to go through
        all the screens before we know we have the last child.  Therefore we just call
        GetChildren and then extract the last entry in the returned array
        */
        
        var children = this.NavGetChildren(pCurScreen, false);
        if (isArray(children))
        {
            ret = children[children.length-1];
        }
        else
        {
            ret = false;
        }
        return ret;
    }

    /*
    The following are the various methods for generating a list of screen names to
    be used as the basis for a link bar.
    */
    
    this.NavGetChildren = function(pScreen, pFirstChildFlag)
    {
        /*
        This function creates a list of screens which are the children of the passed in screen.
        Optionally, if pFirstChildFlag is set to true, what is returned is actually the first child
        of the child screens, which is sometimes more appropriate.
        */
    
        // D.debugStartFunction("NavGetChildren", arguments);
        
        var children = new Array;
        var key;
        var i = 0;
        var j = 0;
        var screenName = "";
        var firstChildScreen = "";
        
        for (i=0; i<this.NavGetNumScreens(); i++)
        {
            screenName = this.NavGetScreenFromIndex(i);
            // D.debug("screen " + i + ", name = " + screenName);
            if (this.NavGetParent(screenName) == pScreen)
            {
                children[j] = new Array;
                // D.debug("Adding " + j + "'th entry");
                if (!pFirstChildFlag)
                {
                    // D.debug("Adding child, " + screenName);
                    children[j]['screenName'] = screenName;
                    children[j]['text'] = this.NavGetScreenTitleShort(screenName);
                }
                else
                {
                    firstChildScreen = this.NavGetFirstChild(screenName);
                    
                    // D.debug("Adding first child of " + screenName + ", = " + firstChildScreen);

                    children[j]['screenName'] = firstChildScreen;
                    children[j]['text'] = this.NavGetScreenTitleShort(firstChildScreen);
                }
                j++;
            }
        }
        // D.debug("Dumping children " + dump(children));
        // D.debugEndFunction();
        return children;
    }

    this.NavGetRegions = function(pFirstChildFlag)
    {
        return this.NavRegionDetails;
    }

    this.NavGetRegionHome = function(pScreen)
    {
        D.debugStartFunction("NavGetRegionHome", arguments);

        var region = this.NavGetScreenRegion(pScreen);
        var i;
        var numRegions = this.NavGetNumRegions();
        var ret;
        
        D.warn("Region for screen '" + pScreen + "' is '" + region);
        for (i=0; i<numRegions && this.NavRegionDetails[i]['regionName'] != region; i++)
        {
            // No processing, just used to search for region
        }
        if (i < numRegions)
        {
            ret = this.NavRegionDetails[i]['regionHomeScreen'];
            D.warn("Region home for region '" + region + "' is '" + ret);
        }
        else
        {
            ret = false;
            D.warn("NavGetRegions: Region home screen not found for screen " + pScreen);
        }
        D.debugEndFunction();
        return ret;
    }


    this.NavGetSiblings = function(pScreen)
    {
        D.debugStartFunction("NavGetSiblings", arguments);
        
        var thisParent = this.NavScreenDetails[this.NavGetScreenIndex(pScreen)]['screenParent'];
        
        D.debugEndFunction();
        
        return this.NavGetChildren(thisParent, false);
    }
    
    this.NavGetPrevSibling = function(pScreen)
    {
        D.debugStartFunction("NavGetPrevSibling", arguments);

        var siblings = this.NavGetSiblings(pScreen);
        var i;
        var ret = true;
        
        for (i=0; i<siblings.length && siblings[i]['screenName'] != pScreen; i++)
        {
            // No code - this is just to search for the element I want
        }
        if (i == siblings.length)
        {
            ret = false;
        }
        else
        {
            // found, so if not first element prev is in i-1            
            if (i > 0)
            {
                ret = siblings[i-1]['screenName'];
            }
            else
            {
                ret = false;
            }
        }
        D.debug("Returning " + ret);
        D.debugEndFunction();
        return ret;
    }

    this.NavGetNextSibling = function(pScreen)
    {
        D.debugStartFunction("NavGetNextSibling", arguments);

        var siblings = this.NavGetSiblings(pScreen);
        var i;
        var ret = true;
        
        for (i=0; i<siblings.length && siblings[i]['screenName'] != pScreen; i++)
        {
            // No code - this is just to search for the element I want
        }
        if (i == siblings.length)
        {
            ret = false;
        }
        else
        {
            // found, so if not last element prev is in i+1            
            if (i < siblings.length-1)
            {
                ret = siblings[i+1]['screenName'];
            }
            else
            {
                ret = false;
            }
        }
        D.debug("Returning " + ret);
        D.debugEndFunction();
        return ret;
    }

    this.NavAddScreenToList = function(pInsertFlag, pList, pScreenName, pText)
    {
        var index;
        
        if (pInsertFlag)
        {
            pList.unshift(new Array);
            index = 0
        }
        else
        {
            pList.push(new Array);
            index = pList.length-1;
        }
        pList[index]['screenName'] = pScreenName;
        pList[index]['text'] = pText;
    }
    
    this.NavAddClassToScreen = function( pListElement, pClass )
    {
        if (!pListElement['class'])
        {
            pListElement['class'] = new Array;
        }
        
        pListElement['class'].push([pClass]);
    }
        
    this.NavModifyList = function(pParamData, pList, pCurScreen)
    {
        /*
        This function add links to the start and end of the list based on the parameters set
        for the AE.  E.g. add a home link to the top, or prev next links to top and bottom.
        */
        
        D.debugStartFunction("NavModifyList", arguments);

        var addScreen = new Array;
        var status = true;
        var i;
        var insertCount = 0;
        var initialLength = pList.length;
        
        if (pParamData['screenListModifiers']['up'])
        {
            var upLinkScreen = this.NavGetParent(pCurScreen);
            if (!upLinkScreen) upLinkScreen = "";
            this.NavAddScreenToList(true, pList, upLinkScreen, "Up");
            insertCount++;
        }

        if (pParamData['screenListModifiers']['home'])
        {
            this.NavAddScreenToList(true, pList, this.NavGetHomePage(), "Home");
            insertCount++;
        }
        
        if (pParamData['screenListModifiers']['prevNext'])
        {
            var prev = this.NavGetPrevSibling(pCurScreen);
            var next = this.NavGetNextSibling(pCurScreen);
            var titlePrev = this.NavGetScreenTitleShort(prev);
            var titleNext = this.NavGetScreenTitleShort(next);
            
            this.NavAddScreenToList(true, pList, prev, (false===titlePrev) ? "" : titlePrev);
            insertCount++;
            this.NavAddScreenToList(false, pList, next, (false===titleNext) ? "" : titleNext);
        }

        if (pParamData['screenListModifiers']['firstLast'])
        {
            this.NavAddScreenToList(true, pList, pList[insertCount]['screenName'], "First");
            insertCount++;
            this.NavAddScreenToList(false, pList, pList[insertCount+initialLength-1]['screenName'], "Last");
        }

        if (pParamData['screenListModifiers']['backForward'])
        {
            // add forward screen name, and 'Forward' text to preList
            // note that this is only applicable if we have gone 'back'
        }
        
        D.debugEndFunction();

        return status;
    }

    this.NavAddClassInfo = function(pParamData, pList, pCurScreen)
    {
        /* This function applies class modifiers to update the list entries to provide further
           information when the list is turned into XHTML, to provide hooks for
           CSS to use
         */
        
        var status = true;
        var i;
        
        if (pParamData['classSpecifiers']['first'])
        {
            if (pList[0]) // Don't try and add a class to non-existent link.
            {
                this.NavAddClassToScreen( pList[0], 'first' );
            }
        }
        
        if (pParamData['classSpecifiers']['last'])
        {
            if (pList[pList.length-1]) // Don't try and add a class to non-existent link.
            {
                this.NavAddClassToScreen(pList[pList.length-1], 'last');
            }
        }
        
        if (pParamData['classSpecifiers']['active'])
        {
            for (i=0; i < pList.length; i++)
            {
                if (pList[i]['screenName'] == "")
                {
                    this.NavAddClassToScreen(pList[i], 'inactive');
                }
                else
                {
                    this.NavAddClassToScreen(pList[i], 'active');
                }
            }
        }
        
        /* if the current screen is in the list, append this fact to it can be treated
           differently (e.g made inactive, highlighted by colour)
          */
        for (i=0; i<pList.length; i++)
        {
            if (pList[i]['screenName'] == pCurScreen)
            {
                this.NavAddClassToScreen( pList[i], 'this');
            }
        }
        
        /* if we want to distinguish between adjacent items in a list, mark
           each item in the list alternately with 'odd' and 'even' to allow
           them to be coloured differently, for example
         */
        if (pParamData['classSpecifiers']['alternate'])
        {
            for (i=0; i < pList.length; i++)
            {
                if (i%2)
                {
                    this.NavAddClassToScreen( pList[i], 'even');
                }
                else
                {
                    this.NavAddClassToScreen( pList[i], 'odd');
                }
            }
        }
        return status;
    }
    
    this.NavLoadData = function()
    {
        D.debug("Sending Request");
        
        Header['msgseqnum']   = "01" // this.aeGetMsgSeqNum();
        Header['requesttype'] = 'datarequest';
        Header['loggingflag'] = 'true';
        Header['aetype']      = this.aeGetAEtype();
        Header['aeid']        = this.aeGetAEid();

        RequestXML = this.aeCreateRequestHeaderXML(Header);
        RequestXML += this.aeCreateDataRequestXML('NavXML');
        
        this.aeSetAlgorithmStatus("Navigation", "RequestingData");
        
        DataRequest = this.aeXMLnodeCreate('activeelementrequest', RequestXML);
        
        this.aeSendRequest(DataRequest);
    }
                                
        D.debug("Ending Navigation Constructor");
    }