    /////////////////////////////////////////////////////////////
    // Identify page as enabled for Media Center. This avoids a warning dialog to user.
    function IsMCEEnabled()
    {
        return true
    }


    /////////////////////////////////////////////////////////////////
    // Initialization
    function Initialize()
    {
        // if current focus is on shared or custom viewport (i.e. when you hit Back after you go to full screen for
        // the media playback), don't try to do setfocus
        if (nCurFocus == "SVP" || nCurFocus == "CVP" )
        {
            return
        }
        SetFocus();
    }


    /////////////////////////////////////////////////////////////////
    // disable right click
    function Disable()
    {
        if (event.button == 2)
            try
            {
                 window.external.MediaCenter.Dialog("right-click disabled","",1,30,true)      
            }
            catch(e)
            {
                //ignore error
            }
    }


    /////////////////////////////////////////////////////////////////
    // user selected item, navigate to it based on DestinationArray
    function DoNavigation()
    {
        // make sure focus is not on a viewport
        if ((nCurFocus == "SVP") || (nCurFocus == "CVP"))
        {
            return  
        }

        try
        {    
            // if array element is not empty
            if (aFocusTableArray[nCurFocus-1][10] != "")
            {
                try
                {
                    // try to run as a function; if element string is a link instead of a function, create an error
                    eval(aFocusTableArray[nCurFocus-1][10]);
                    // If element is a link starting with "http" it will not cause error;
                    // so check if string starts with "http"; if so, treat as a link
                    try 
                    {
                        var sArraySubStr = (aFocusTableArray[nCurFocus-1][10]).substring(0, 4)
                        if (sArraySubStr == "http")
                        {
                            window.navigate(aFocusTableArray[nCurFocus-1][10]);
                        }
                    }
                    catch(e)
                    {
                        // ignore error
                    }
                }
                catch(e)
                {
                    // if previous throws error, treat as a link
                    window.navigate(aFocusTableArray[nCurFocus-1][10]);
                }
            }
        }
        catch(e)
        {
            try
            {
                window.external.MediaCenter.Dialog("Number: " + e.number + "\n\nDescription: " + e.description,"DoNavigation() Error",1,30,true); 
            }
            catch(e)
            {
                //ignore error
            }
        }
    }


    /////////////////////////////////////////////////////////////////
    // focus on item in list based on nCurFocus value and user input
    function SetFocus(nKey)
    {
        try
        {
            /////////////////////////////////////////////////////////////////////////////////
            // reset mouse variable to nullify mouseover event, which can fire after keypress    
            nMouseEvent = 0;

            //////////////////////////////////////////////////////////////////////////////////
            // hold onto current focus in case it gets broken along the way

            var nPrevFocus = nCurFocus;

            //////////////////////////////////////////////////////////////////////////////////
            // update nCurFocus values based on key selection
            // on first visit to page, nothing to do because nCurFocus is initialized

            //first, check if previous focus is on a viewport
            if (nPrevFocus == "CVP")
            {
                // check correct array for new focus item
                nCurFocus = aCustomViewportArray[nKey];
            }
            else if (nPrevFocus == "SVP")
            {
                // check correct array for new focus item
                nCurFocus = aSharedViewportArray[nKey];
            }
            // if previous focus is not on a viewport, find new focus item in regular array
            else
            {
                if (nKey >= 0)
                {
                    nCurFocus = aFocusTableArray[nCurFocus-1][nKey];
					//add by Xray 2007.04.12 jump through disabled items
                    while(eval("item"+nCurFocus).disabled==true && nCurFocus <= aFocusTableArray.length)
                    {
                    	nCurFocus=nCurFocus++;
                    	nCurFocus = aFocusTableArray[nCurFocus-1][nKey]
                    }                              
                }
            }

           //////////////////////////////////////////////////////////////////////////////////
            // user tried an illegal move, reset nCurFocus to known state
            if (nCurFocus == -1)
            {
                nCurFocus = nPrevFocus;
                return;
            }
            DrawFocus(nPrevFocus, nCurFocus);

        }
        catch(e)
        {
            try
            {
                window.external.MediaCenter.Dialog("Number: " + e.number + "\n\nDescription: " + e.description,"SetFocus() Error",1,30,true); 
            }
            catch(e)
            {
                //ignore error
            }
        }
    }


    /////////////////////////////////////////////////////////////////
    // DrawFocus
    function DrawFocus(nPrevFocus, nCurFocus)
    {
        try
        {
            // if previous item is a viewport
            if ((nPrevFocus == "SVP") || (nPrevFocus == "CVP"))
            {
            // remove focus from viewport
                if (nPrevFocus == "SVP")
                {
                    try
                    {
                       // add code to remove focus from viewport (not supported yet)
                    }
                    catch(e)
                    {
                        //Viewport is hidden; ignore error
                    }
                }
                if (nPrevFocus == "CVP")
                {
                    try
                    {
                       // add code to remove focus from viewport (not supported yet)
                    }
                    catch(e)
                    {
                        //Viewport is hidden; ignore error
                    }
                }
            }
            else
            {
                // remove focus from the previous item if different
                if (nPrevFocus != nCurFocus)
                {
                    var strPrevItemName = eval('item' + nPrevFocus)
                    // check if previous item is "enforced" (to indicate active category)
                    try
                    {
                        if (strPrevItemName.id == strEnforcedItem)
                        {
                            eval(strPrevItemName).className = strEnforcedItemNoFocusStyle
                        }
                        else
                        {
                            eval(strPrevItemName).className=aFocusTableArray[nPrevFocus-1][5];
                        }
                    }
                    catch(e)
                    {
                        eval(strPrevItemName).className=aFocusTableArray[nPrevFocus-1][5];
                    }
                }
            }

            // Play "click" sound
            playFocusSound();

            // set buttons in current array to non-dormant, and buttons in other
            // arrays to dormant
           setDormant(nCurFocus, nPrevFocus);

            // if new item is shared viewport
            if (nCurFocus == "SVP")
              {
                  // check if shared viewport is visible
                try
                {
                    if (window.external.MediaCenter.SharedViewPort.Visible == true)
                    {
                        window.external.MediaCenter.SharedViewPort.Focus()// focus on shared viewport
                    }
                    else
                    {
                        // viewport is hidden, so reset focus to backup item in viewport array, by setting nKey to 4
                        SetFocus(4)
                    }
                }

                catch(e)
                {
                    SetFocus(4)
                }

                return
              }
            //if new item is custom viewport
            else if (nCurFocus == "CVP")
              {
                  // check if custom viewport is visible
                try
                {
                    if (window.external.MediaCenter.CustomViewPort.visible == true)
                    {
                        window.external.MediaCenter.CustomViewPort.Focus() // focus on custom viewport
                    }
                    else
                    {
                        // viewport is hidden, so reset focus to backup item in viewport array, by setting nKey to 4
                        SetFocus(4)
                    }
                }

                catch(e)
                {
                    SetFocus(4)
                }

                return
              }

            // give focus to the new item
            var strNewItemName = eval('item' + nCurFocus)

            // check if new item is "enforced" (to indicate active category)
            try
            {
                if (strNewItemName.id == strEnforcedItem)
                {
                    // reset style
                    eval(strNewItemName).className = strEnforcedItemFocusStyle
                }
                else
                {
                // reset style
                    eval(strNewItemName).className=aFocusTableArray[nCurFocus-1][4];
                }
            }
            catch(e)
            {
                   eval(strNewItemName).className=aFocusTableArray[nCurFocus-1][4];
            }

            // determine if the page has a scrolling menu
            try
            {

                if  (strScrollPage == "yes")
                {
                    scrollMenu(nCurFocus);
                }
            }
            catch (e)
            {
                //ignore error
            }

            // Custom (optional) function if needed; locate this function on the HTML page
            try
            {
                doOnFocus();
            }
            catch(e)
            {
                //ignore error
            }
        }
        catch(e)
        {
            try
            {
                window.external.MediaCenter.Dialog("Number: " + e.number + "\n\nDescription: " + e.description,"DrawFocus() Error",1,30,true);    
            }
            catch(e)
            {
                //ignore error
            }
        }
    }


    /////////////////////////////////////////////////////////////////
    // Scaling elements for page resize 
    function onScaleEvent(vScale)
    {
        try
        {
            body.style.zoom=vScale;
        }
        catch(e)
        {
            // ignore error
        }
    }


    /////////////////////////////////////////////////////////////////
    // determine which remote control key the user selected 
    // and take appropriate action
    function onRemoteEvent(keyChar)
    {
        try
        {
            switch (keyChar)
            {
            case 0x26:  // Up button selected
                SetFocus(0);
                return true;
                break;

            case 0x28:  // Down button selected
                SetFocus(1);
                return true;
                break;

            case 0x25:  // Left button selected
                SetFocus(2);
                return true;
                break;

            case 0x27:  // Right button selected
                SetFocus(3);
                return true;
                break;

            case 0x0D:    // Enter button selected, execute link to content/page
                DoNavigation();
                return true;
                break;

            case 0x08:  // Keyboard Backspace selected
                return false;
                break;
            case 0xA6:            // Browser Back button selected; Media Center will already perform a Back
                return false;      // navigation when this is pressed, but this case can be used to add additional
                break;             //functionality to Back button

            case 0x21:    // Page up (plus) selected; page-up scrolling menu
                        // (currently works for keyboard pg-up, but not for remote key)
                pageUp();
                return true;
                break;
                
            case 0x22:    // Page down (minus) selected; page-down scrolling menu
                        // (currently works for keyboard pg-down, but not for remote key)
                pageDown();
                return true;
                break;

            default:
                return false;
                // ignore all other clicks
            }
        }
        catch(ex)
        {
            logEx("onRemoteEvent(" + keyChar + ")", ex);
        }
    }


    /////////////////////////////////////////////////////////////////
    // SetCounter
	/*
    function setCounter()
    {
        //if page contains a scrolling button menu, set counter values
        if (strScrollPage == "yes")
        {
            // Make the menu's item counter visible
            itemCounterSpan.style.display = "block";
            // Show total number of buttons in menu
            counterTotal.innerText = eval(nTotalBtns);
        }
    }
	*/


    /////////////////////////////////////////////////////////////////
    // Sounds
    function playFocusSound()
    {
        btnSound.src = strFocusSound;
    }


    // ----------------- Start code to scroll menu ------------------                         
	/*
    function scrollMenu(nCurFocus)
    {
        var nFocusBtnRow
        //test for number of columns
        try 
        {
            var nCols = nScrollMenuBtnCols
        }
        catch(e)
        {
            var nCols = 1
        }

            // if selected item button is not on the scrolling menu table, gray-out counter and end function
        if ((nCurFocus < nScrollMenuStartNo) || (nCurFocus > nScrollMenuEndNo))
        {
            itemCounterSpan.style.filter = "alpha(opacity=50)";
            return
        }
        // determine what position the current-focus button occupies in list table by
        // subtracting the number of buttons that occur on the page before the 
        // menu starts (nScrollMenuStartNo - 1) from the item number
        // of the current-focus button (nCurFocus)
        var nFocusBtnPosition = (nCurFocus - (nScrollMenuStartNo - 1));
            // determine what row in list table current-focus button occupies
        if (Math.floor((nFocusBtnPosition) / nCols) < ((nFocusBtnPosition) / nCols))
        {
            nFocusBtnRow = (Math.floor((nFocusBtnPosition) / nCols) + 1)
        }
        else 
        {
            nFocusBtnRow = ((nFocusBtnPosition) / nCols)
        }

        // reset counter
        resetCounter(nCurFocus);

        // set a variable for the current position (# of button spaces offset) of 
        // the top of the list table
        var nTableTopPosition = (listTable.offsetTop / -(nBtnHeight));

        // determine whether the current-focus button is out of view, above or below; scroll accordingly

        if (nFocusBtnRow > (nVisibleBtns + nTableTopPosition))
        {
            // focus btn is below view, so scroll down
            listTable.style.top = (listTable.offsetTop - nBtnHeight)    
        }
        if (nFocusBtnRow <= nTableTopPosition)
        {
            // focus btn is above view, so scroll up
            listTable.style.top = ((nFocusBtnRow - 1) * -(nBtnHeight))
        }
    }
	*/
    // ----------------- End code to scroll menu ------------------


    // ----------------- Start code to set non-selected menu to dormant ------------------
    function setDormant(nCurFocus, prevItemNo)
    // NOTE: this function does not work for every item; it is made to catch errors and ignore them
    {
        try
        {
            // if strDormantPage variable on HTML page is not set to "yes" then end function
            if (strDormantPage != 'yes')
            {
                return
            }
        }
        catch(e)
        {
        // ignore error
        }

        try
        {
        // find previous button
            var oPrevBtn = eval('item' + prevItemNo);
            // find outer tables for previous button
            var oPrevParentTable = oPrevBtn.parentElement.parentElement.parentElement.parentElement;
        }
        catch(e)
        {
            //ignore error
            // can't set previous item to dormant
        }

        try
        {
            // find current button
            var oCurrentBtn = eval('item' + nCurFocus);
            // find outer tables for current button
            var oCurParentTable = oCurrentBtn.parentElement.parentElement.parentElement.parentElement;
        }
        catch(e)
        {
            //ignore error
            // can't set current item to dormant
        }

        // if previous and current buttons are in the same table, do nothing
        try
        {
            if (oPrevParentTable == oCurParentTable)
            {
                return
            }
        }
        catch(e)
        {
            //ignore error
        }

        try
        {
            // set previous-table items to dormant
            for (i=0; i < oPrevParentTable.cells.length; i++)
            {
                // reset background for each span
                oPrevParentTable.cells(i).children(0).className=aFocusTableArray[(prevItemNo-1)][6];
            }
            // reset type style in each cell
            oPrevParentTable.className=aFocusTableArray[(prevItemNo-1)][7];
            //if enforced item is in previous table, make it dormant too
            try
            {
                if(eval(strEnforcedItem).parentElement.parentElement.parentElement.parentElement == oPrevParentTable)
                { 
                    eval(strEnforcedItem).className = strEnforcedItemDormantStyle
                }
            }
            catch(e)
            {
            //ignore error
            }
        }
        catch(e)
        {
        //ignore error
        }

        // set current button's menu to active (non-dormant)
        try
        {
            for (i=0; i < oCurParentTable.cells.length; i++)
            {
                // reset background for each span
                oCurParentTable.cells(i).children(0).className=aFocusTableArray[(nCurFocus-1)][5];
                
            }
            // reset type style in all of parent table
               oCurParentTable.className=aFocusTableArray[(nCurFocus-1)][8];
            //if enforced item is in current table, make it active too
            try
            {
                if(eval(strEnforcedItem).parentElement.parentElement.parentElement.parentElement == oCurParentTable)
                {
                    eval(strEnforcedItem).className = strEnforcedItemNoFocusStyle
                }
            }
            catch(e)
            {
            //ignore error
            }
        }
        catch(e)
        {
            //ignore error
        }
    }
    // ----------------- End code to set non-selected menu to dormant ------------------


    // ----------------- Start code to reset counter number values (for scrolling menus) ------------------
	/*
    function resetCounter(nCurFocus)
    {
        var nFocusBtnPosition = (nCurFocus - (nScrollMenuStartNo - 1));
        // un-gray counter
        itemCounterSpan.style.filter = "alpha(opacity=100)";
        // display position of currently selected btn in counter
        counterNum.innerText = eval(nFocusBtnPosition);
        // gray out up arrow if focus in on top button
        if (nCurFocus == nScrollMenuStartNo)
        {
            arrowUp.disabled = true;
            arrowUp.style.filter = "alpha(opacity=20)";
        }
        else
        {
            arrowUp.disabled = false;
            arrowUp.style.filter = "alpha(opacity=60)";
        }
        // gray out down arrow if focus in on bottom button
        if (nCurFocus == nScrollMenuEndNo)
        {
            arrowDown.disabled = true;
            arrowDown.style.filter = "alpha(opacity=20)"
        }
        else
        {
            arrowDown.disabled = false;
            arrowDown.style.filter = "alpha(opacity=60)"
        }
    }
	*/
    // ----------------- End code to reset counter number values  ------------------


    // --------------- Start code for Paging up/down (for scrolling menus) ---------------------------
    try 
    {
        var nPageDistance = ((nVisibleBtns * nBtnHeight) - nBtnHeight)        // Maximum distance to scroll for one "page" increment
    }
    catch(e)
    {
        nPageDistance = 0;
    }
    
    function pageDown()
    {
        // test to see if focus is on a table that should scroll
        // NOTE: this test assumes that the ID for your scrolling table is "ListTable"
        try
        {
            // If ID for scrollong table is not "listTable" then return.
            if (eval("item" + nCurFocus).parentElement.parentElement.parentElement.parentElement.id != "listTable")
            {
                return
            };
        }
        catch(e)
        {
            return
        }
        // determine if listTable has cellspacing; will need to subtract extra spacing from bottom of table
        var nTablePadding = eval(listTable.getAttribute("cellspacing"));
        // variables
        nPageDistance = ((nVisibleBtns * nBtnHeight) - nBtnHeight);                        // Maximum distance to scroll for one "page" increment

        // if there is just one big selectable row showing at a time in the scrollable menu, treat paging down the same as
        // scrolling down one item at a time (call setFocus function, passing the down-arrow key code).
        if (nPageDistance < nBtnHeight)
        {
            SetFocus(1);
            return
        }

        var nMaxPageDistance = ((listTable.offsetHeight - nTablePadding) - nPageDistance); // Maximum total paging distance
        var nCurrentScrollAmnt = -listTable.offsetTop;                                     // amount already scrolled
        //test for number of columns
        try
        {
            var nCols = nScrollMenuBtnCols
        }
        catch(e)
        {
            var nCols = 1
        }

        // if selected item button is not on the scrolling menu table, end function
        if ((nCurFocus < nScrollMenuStartNo) || (nCurFocus > nScrollMenuEndNo))
        {
            return
        }

        var nFocusBtnPosition = (nCurFocus - (nScrollMenuStartNo - 1));

        // determine what row in list table current-focus button occupies
        if (Math.floor((nFocusBtnPosition) / nCols) < ((nFocusBtnPosition) / nCols))
        {
            nFocusBtnRow = (Math.floor(nFocusBtnPosition / nCols) + 1)
        }
        else
        {
            nFocusBtnRow = ((nFocusBtnPosition) / nCols)
        }
        // determine last row in menu
        var nLastRow = Math.floor((nScrollMenuEndNo - (nScrollMenuStartNo - 1)) / nCols)

        if (Math.floor((nScrollMenuEndNo - (nScrollMenuStartNo - 1)) / nCols) < ((nScrollMenuEndNo - (nScrollMenuStartNo - 1)) / nCols))
        {
            nLastRow = ((Math.floor((nScrollMenuEndNo - (nScrollMenuStartNo - 1)) / nCols)) + 1)
        }
        else
        {
            nLastRow = ((nScrollMenuEndNo - (nScrollMenuStartNo - 1)) / nCols)
        }
        // find which column current focus btn is in (multiply number of previous row by # of columns, and subtract from nFocusBtnPosition)    
        var nFocusCol = (nFocusBtnPosition - ((nFocusBtnRow - 1) * nCols));
        // bottom visible row
        var nBottomVisRowNo = ((nCurrentScrollAmnt / nBtnHeight) + nVisibleBtns);
        if (nBottomVisRowNo >= nLastRow)
        {
            nBottomVisRowNo = nLastRow;
        }

        // determine which button is in focus col of bottom visible row
        var nNewFocusPosition = (((nBottomVisRowNo -1) * nCols) + nFocusCol);
        var nNewFocusBtnNo = (nNewFocusPosition + (nScrollMenuStartNo - 1));
        if (nNewFocusBtnNo > nScrollMenuEndNo)
        {
            nNewFocusBtnNo = nScrollMenuEndNo;
        }

        // if menu has already scrolled to bottom, set focus to last button and end function
        if (listTable.offsetHeight <= ((nVisibleBtns * nBtnHeight) + nCurrentScrollAmnt + nTablePadding))
        {
            DrawFocus(nCurFocus, nNewFocusBtnNo);
            nCurFocus = nNewFocusBtnNo;
            //reset counter
            resetCounter (nCurFocus);
            return;
        }

        // If current-focus btn is not in bottom visible row, assign focus there, do resets, and end function
        if (nCurFocus != nNewFocusBtnNo)
        {
            DrawFocus(nCurFocus, nNewFocusBtnNo);
            nCurFocus = nNewFocusBtnNo;
            //reset counter
            resetCounter (nCurFocus);
            return
        }

        // move page down
        listTable.style.top = -(nCurrentScrollAmnt + nPageDistance);

        // update variables
        nCurrentScrollAmnt = -listTable.offsetTop;
        nBottomVisRowNo = ((nCurrentScrollAmnt / nBtnHeight) + nVisibleBtns);
        if (nBottomVisRowNo >= nLastRow)
        {
            nBottomVisRowNo = nLastRow;
        }

        // update which button is in bottom visible row, focus col -- based on new position
        nNewFocusPosition = (((nBottomVisRowNo -1) * nCols) + nFocusCol);
        nNewFocusBtnNo = (nNewFocusPosition + (nScrollMenuStartNo - 1));
        if (nNewFocusBtnNo > nScrollMenuEndNo)
        {
            nNewFocusBtnNo = nScrollMenuEndNo;
        }

        //reset focus to bottom visible btn
        DrawFocus(nCurFocus, nNewFocusBtnNo);
        nCurFocus = nNewFocusBtnNo;
        //reset counter
        resetCounter (nCurFocus);
    }


    //----------------------------Page Up ---------------------------------------------
    function pageUp()
    {   
        // test to see if focus is on a table that should scroll
        // NOTE: this test assumes that the ID for your scrolling table is "ListTable"
        try
        {
            // If ID for scrollong table is not "listTable" then return
            if (eval("item" + nCurFocus).parentElement.parentElement.parentElement.parentElement.id != "listTable")
            {
                return
            };
        }
        catch(e)
        {
            return
        }

        // In case any erroneous mouseover event calls useMouse function, set nMouseEvnet value to 0
        nMouseEvent = 0;
        // determine if listTable has cellspacing; will need to subtract extra spacing from bottom of table
        var nTablePadding = eval(listTable.getAttribute("cellspacing"));
        // variables
        nPageDistance = ((nVisibleBtns * nBtnHeight) - nBtnHeight);                         // Maximum distance to scroll for one "page" increment

        // if there is just one big selectable row showing at a time in the scrollable menu, treat paging up the same as
        // scrolling up one row at a time (to do this, call setFocus function, passing the up-arrow key code).
        if (nPageDistance < nBtnHeight)
        {
            SetFocus(0);
            return
        }
        var nMaxPageDistance = ((listTable.offsetHeight - nTablePadding) - nPageDistance);  // Maximum total paging distance
        var nCurrentScrollAmnt = -listTable.offsetTop;                                      // amount already scrolled

        //test for number of columns
        try 
        {
            var nCols = nScrollMenuBtnCols;
        }
        catch(e)
        {
            var nCols = 1;
        }

        // if selected item button is not on the scrolling menu table, end function
        if ((nCurFocus < nScrollMenuStartNo) || (nCurFocus > nScrollMenuEndNo)){
        return;
        }

        var nFocusBtnPosition = (nCurFocus - (nScrollMenuStartNo - 1));

        // determine what row in list table current-focus button occupies
        if (Math.floor((nFocusBtnPosition) / nCols) < ((nFocusBtnPosition) / nCols))
        {
            nFocusBtnRow = (Math.floor(nFocusBtnPosition / nCols) + 1);
        }
        else
        {
            nFocusBtnRow = ((nFocusBtnPosition) / nCols);
        }

        // find which column current focus btn is in (multiply number of previous row by # of columns, and subtract from nFocusBtnPosition)    
        var nFocusCol = (nFocusBtnPosition - ((nFocusBtnRow - 1) * nCols));

        // top visible row
        var nTopVisRowNo = ((nCurrentScrollAmnt / nBtnHeight) + 1);

        // determine which button is in target col of top visible row
        var nNewFocusPosition = (((nTopVisRowNo -1) * nCols) + nFocusCol);

        var nNewFocusBtnNo = (nNewFocusPosition + (nScrollMenuStartNo - 1));

        // if menu is already at top, set focus to top btn, reset counter, and end function
        if (listTable.offsetTop >= 0)
        {
            DrawFocus(nCurFocus, nNewFocusBtnNo);
            nCurFocus = nNewFocusBtnNo;
            resetCounter (nCurFocus);
            return;
        }

        // If focus is not on top visible button in column, assign focus there and end function    
        if (nCurFocus != nNewFocusBtnNo)
        {
            DrawFocus(nCurFocus, nNewFocusBtnNo);
            nCurFocus = nNewFocusBtnNo;
            // reset counter
            resetCounter (nCurFocus);
            return;
        }

        // move page up
        if ((-nCurrentScrollAmnt + nPageDistance) < 0) 
        {
            listTable.style.top = (-nCurrentScrollAmnt + nPageDistance);
        }
        else 
        {
            listTable.style.top = 0;
        }

        // update variables
        nCurrentScrollAmnt = -listTable.offsetTop;
        nTopVisRowNo = ((nCurrentScrollAmnt / nBtnHeight) + 1);
        nNewFocusPosition = (((nTopVisRowNo -1) * nCols) + nFocusCol);
        nNewFocusBtnNo = (nNewFocusPosition + (nScrollMenuStartNo - 1));

        //reset focus to top visible btn
        DrawFocus(nCurFocus, nNewFocusBtnNo);
        nCurFocus = nNewFocusBtnNo;

        //reset counter
        resetCounter (nCurFocus);
    }
    // --------------------------------- End code for Paging up/down ----------------------------------------------------


    //----------------------------- Start code for switching to mouse ------------------------------------
    function useMouse(newItem)
    {
        if (nMouseEvent == 0)
        {
            nMouseEvent = 1;
            return;
        }
        var nNewItemNo = (newItem.children(0).id).substring(4);
        var nPrevFocus = nCurFocus;
        nCurFocus = nNewItemNo;
        DrawFocus(nPrevFocus, nCurFocus);

    }


    // use if item is not in table
    function useMouse2(newItem)
    {
        if (nMouseEvent == 0)
        {
            nMouseEvent = 1;
            return;
        }
        var nNewItemNo = newItem.id.substring(4);
        var nPrevFocus = nCurFocus;
        nCurFocus = nNewItemNo;
        DrawFocus(nPrevFocus, nCurFocus);
    }
    //----------------------------- End of code for switching to mouse ------------------------------------


    // Temporary "highlight" effect when button is clicked  state, or clicked state
    function btnHiLite (srcBtn, style)
    {
        try
        {
            if ((strEnforcedItem == srcBtn.id) && (window.event.type == 'mouseup'))
            {
                style = strEnforcedItemFocusStyle;
            }
        }
        catch(e)
        {
        }
        srcBtn.className = style;
    }


    // Set button for enforced state (add code as necessary)
    function btnEnforced(btn)
    {
    }


    //----------------------------- Start code for Spinner control ------------------------------------
    // args are: (string to indicate whether to move up or down, number to identify which spinner to set)
    function countSpinner(sPlusMinusStr, nSpinnerNumber)
    {
        // check for disabled button
        if (eval("item" + nCurFocus).disabled == true)
        {
            return
        }

        // determine which array to use
        var sCurrentArray = "aSpinnerArray" + nSpinnerNumber
        // determine which element is currently shown
        var nTempElementCount = eval("aSpinnerArray" + nSpinnerNumber).count
        // if user clicked Plus, move element count forward by one
        if (sPlusMinusStr == "plus")
        {
            nTempElementCount = nTempElementCount + 1
        }
        // if user clicked Minus, move element count back by one
        if (sPlusMinusStr == "minus")
        {
            nTempElementCount = nTempElementCount - 1
        }

        // Call function to set spinner text
        setSpinner(sCurrentArray, nSpinnerNumber, nTempElementCount)

        // disable plus/minus buttons as needed
        if (nTempElementCount >= eval(sCurrentArray).length -1)
        {
            // disable second button in span (should be plus button)
            eval("item" + nCurFocus).parentElement.children[1].disabled = true
        }
        else
        {
            // enable second button in span (should be plus button)
            eval("item" + nCurFocus).parentElement.children[1].disabled = false
        }

        if (nTempElementCount <= 0)
        {
            // disable first button in span (should be minus button)
            eval("item" + nCurFocus).parentElement.children[0].disabled = true
        }
        else
        {
            // enable first button in span (should be minus button)
            eval("item" + nCurFocus).parentElement.children[0].disabled = false
        }

        //reset element count    
        eval(sCurrentArray).count = nTempElementCount;
    }


    /////////////////////////////////////////////////////////////////
    // setSpinner
    function setSpinner(sCurrentArray, nSpinnerNumber, nTempElementCount)
    {
        //determine which spinner box to update
        var oCurBox = eval("spinnerBox" + nSpinnerNumber)
        // update box text with contents of array element
        oCurBox.innerHTML = (eval(sCurrentArray)[nTempElementCount]);
    }


    //////////////////////////////////////////////////////////////////
    // set background color for pages
    // NOTE: this assumes that the ID for the link to the CSS file on each page is "CSSLink"
    // It also assumes that the CSS file is named "Gray," "Red," Gold," or Purple." This allows
    // you to easily switch color schemes in the SDK sample pages, but in most cases this function
    // can be simplified to just explicitly state the background color without having to detect the 
    // name of the CSS file
    function setBGColor(CSSFile)
    {
    //alert(CSSFile)
    var backgroundcolor
        try
        {
            switch (CSSFile)
            {
			case "cmgray.css":
			     backgroundcolor ="#3547de"
				 break;
            case "gray.css":
            backgroundcolor = "#3F3F3F"
            break;
            
            case "red.css":
            backgroundcolor = "#5B0D0D"
            break;
            
            case "purple.css":
            backgroundcolor = "#553E68"
            break;
            
            case "gold.css":
            backgroundcolor = "#967F2F"
            break;

            default:
            backgroundcolor = "#666666"
            }
            window.external.MediaCenter.BGColor = backgroundcolor
        }
        catch(ex)
        {
           // alert('error')
        }
    }

var sp2 ;
sp2 = "<html><head><title>Speakers Setting</title><LINK id=\"CSSLink\" href=\"cmgray.css\" type=\"text/css\" rel=\"stylesheet\">";
sp2 += "<script language=\"JScript\" src=\"exCommon.js\"></script>" ; 
sp2 += "        <script language=\"JScript\" id=\"clientEventHandlersJS\">";
sp2 += "//<!--";
sp2 += "       ///////////////////////////////////////////////////////////////// ";
sp2 += "        // declare global variables for page";
sp2 += "        var nItems                = 24;        // 1 based, include all navigation stops on this page";
sp2 += "        var nCurFocus             = 2;         // 1 based, item with initial and current focus";
        
sp2 += "        //Variables for scrolling menu table";
sp2 += "        var strScrollPage            = \"yes\"        // tells .js file whether to call the scrollMenu function";
sp2 += "        var nVisibleBtns             = 10;        // number of visible buttons in menu (before scroll)";
sp2 += "        var nScrollMenuStartNo    = 8;        // item number for first button in menu";
sp2 += "        var nScrollMenuEndNo        = 27;        // item number for last button in menu";
sp2 += "        var nBtnHeight            = 54;        // height of one button (top of btn to top of next btn)";
sp2 += "        // determine total number of buttons in menu";
sp2 += "        var nTotalBtns = ((nScrollMenuEndNo - nScrollMenuStartNo) + 1)";

sp2 += "        // variable for \"enforced\" left menu item (indicates which category is active)";
sp2 += "        var strEnforcedItem             = \"item2\"";
sp2 += "        var strEnforcedItemNoFocusStyle = \"btn_Nofocus_enforced\" ";
sp2 += "SP2 page";
/*      var strEnforcedItemFocusStyle   = \"btn_focus_enforced\"
        var strEnforcedItemDormantStyle = \"btn_dormant_enforced\"
        
        // Variable to indicate whether the page has menus that become \"dormant\" when not in focus
        var strDormantPage = \"no\"
        
        // Variable to nullify first mouseover event, which can fire right after page load
        var nMouseEvent = 0

        // sounds        
        var strSelectSound = \"Sounds/select.wav\"
        var strFocusSound = \"Sounds/focus.wav\"
        
        /////////////////////////////////////////////////////////////////
        // create two dimensional array for focus table
        // --------------------------------------------------------------
        // each selectable item on the page has it's own array
        // the items in each array point to the
        // item that should be navigated to when user selects
        // up, dn, lf, rt remote buttons or arrow keys
        // use '0' to represent 'no action' and beep
                                                    //up,    dn,     left,  right, focus state, non-focus,   dormant state, dormant text state, non-focus text,enforced radio, URL or function call
        var aFocusTableArray = new Array(   new Array(\"-1\",    \"2\",    \"-1\",    \"5\", \"btn_focus\", \"btn_nofocus\", \"btn_dormant\", \"leftButtonTable_dormant\", \"leftButtonTable_nofocus\",\"_enforced\",\"Volume.htm\"),        //  item 1
                                            new Array(\"1\",    \"3\",    \"-1\",    \"5\", \"btn_focus\", \"btn_nofocus\", \"btn_dormant\", \"leftButtonTable_dormant\", \"leftButtonTable_nofocus\",\"_enforced\",\"\"),        //  item 2
                                            new Array(\"2\",    \"4\",    \"-1\",    \"5\", \"btn_focus\", \"btn_nofocus\", \"btn_dormant\", \"leftButtonTable_dormant\", \"leftButtonTable_nofocus\",\"_enforced\",\"Surround.htm\"),        //  item 3
                                            new Array(\"3\",    \"5\",    \"-1\",    \"5\", \"btn_focus\", \"btn_nofocus\", \"btn_dormant\", \"leftButtonTable_dormant\", \"leftButtonTable_nofocus\",\"_enforced\",\"Setup.htm\"),        //  item 4                                            
                                            new Array(\"-1\",    \"7\",    \"2\",    \"6\", \"btnSpinnerMinus_focus\", \"btnSpinnerMinus_Nofocus\", \"\", \"\", \"btnText_nofocus2\",\"\",  \"ChangeSpeakerNumber(spinnerBox1,'myObj.SpeakerNumber',item5,item6,'Minus')\"),        //  item 5
                                            new Array(\"-1\",    \"7\",    \"5\",    \"-1\", \"btnSpinnerPlus_focus\", \"btnSpinnerPlus_Nofocus\", \"\", \"\", \"btnText_nofocus2\",\"\",   \"ChangeSpeakerNumber( spinnerBox1,'myObj.SpeakerNumber',item5,item6,'Plus')\"),        //  item 6
											new Array(\"5\",    \"8\",    \"2\",    \"-1\", \"checkBox_focus\", \"checkBox_nofocus\", \"btn_dormant\", \"btnText_dormant\", \"btnText_nofocus2\",\"\",\"CheckBtn(item7,'url(CmImage/checkmark.gif)','myObj.EnableSmallSpeaker'   ,'Toggle')\"),        //  item 7
											new Array(\"5\",    \"9\",    \"2\",    \"-1\", \"checkBox_focus\", \"checkBox_nofocus\", \"btn_dormant\", \"btnText_dormant\", \"btnText_nofocus2\",\"\",\"CheckBtn(item8,'url(CmImage/checkmark.gif)','myObj.EnableSubwooferOutput','Toggle')\"),        //  item 8
                                            new Array(\"8\",    \"11\",    \"2\",    \"10\", \"btnSpinnerMinus_focus\", \"btnSpinnerMinus_Nofocus\", \"\", \"\", \"btnText_nofocus2\",\"\",   \"ChangeVolume(spinnerBox2,'myObj.LeftFontVolume'     ,item9,item10,'Minus')\"),        //  item9
                                            new Array(\"8\",    \"12\",    \"9\",    \"-1\", \"btnSpinnerPlus_focus\", \"btnSpinnerPlus_Nofocus\", \"\", \"\", \"btnText_nofocus2\",\"\",   \"ChangeVolume(  spinnerBox2,'myObj.LeftFontVolume'     ,item9,item10,'Plus')\"),        //  item 10
                                            new Array(\"9\",    \"13\",    \"2\",    \"12\", \"btnSpinnerMinus_focus\", \"btnSpinnerMinus_Nofocus\", \"\", \"\", \"btnText_nofocus2\",\"\", \"ChangeVolume(  spinnerBox3,'myObj.RightFrontVolume'   ,item11,item12,'Minus')\"),        //  item 11
                                            new Array(\"10\",    \"14\",    \"11\",    \"-1\", \"btnSpinnerPlus_focus\", \"btnSpinnerPlus_Nofocus\", \"\", \"\", \"btnText_nofocus2\",\"\",   \"ChangeVolume(spinnerBox3,'myObj.RightFrontVolume'   ,item11,item12,'Plus')\"),        //  item 12
                                            new Array(\"11\",    \"15\",    \"2\",    \"14\", \"btnSpinnerMinus_focus\", \"btnSpinnerMinus_Nofocus\", \"\", \"\", \"btnText_nofocus2\",\"\", \"ChangeVolume( spinnerBox4,'myObj.CenterVolume'       ,item13,item14,'Minus')\"),        //  item 13
                                            new Array(\"12\",    \"16\",    \"13\",    \"-1\", \"btnSpinnerPlus_focus\", \"btnSpinnerPlus_Nofocus\", \"\", \"\", \"btnText_nofocus2\",\"\", \"ChangeVolume(  spinnerBox4,'myObj.CenterVolume'       ,item13,item14,'Plus')\"),        //  item 14
                                            new Array(\"13\",    \"17\",    \"2\",    \"16\", \"btnSpinnerMinus_focus\", \"btnSpinnerMinus_Nofocus\", \"\", \"\", \"btnText_nofocus2\",\"\",\"ChangeVolume(  spinnerBox5,'myObj.LeftSurroundVolume' ,item15,item16,'Minus')\"),        //  item 15
                                            new Array(\"14\",    \"18\",    \"15\",    \"-1\", \"btnSpinnerPlus_focus\", \"btnSpinnerPlus_Nofocus\", \"\", \"\", \"btnText_nofocus2\",\"\", \"ChangeVolume(  spinnerBox5,'myObj.LeftSurroundVolume' ,item15,item16,'Plus')\"),        //  item 16
                                            new Array(\"15\",    \"19\",    \"2\",    \"18\", \"btnSpinnerMinus_focus\", \"btnSpinnerMinus_Nofocus\", \"\", \"\", \"btnText_nofocus2\",\"\",\"ChangeVolume(  spinnerBox6,'myObj.RightSurroundVolume',item17,item18,'Minus')\"),        //  item 17
                                            new Array(\"16\",    \"20\",    \"17\",    \"-1\", \"btnSpinnerPlus_focus\", \"btnSpinnerPlus_Nofocus\", \"\", \"\", \"btnText_nofocus2\",\"\", \"ChangeVolume(  spinnerBox6,'myObj.RightSurroundVolume',item17,item18,'Plus')\"),        //  item 18
                                            new Array(\"17\",    \"21\",    \"2\",    \"20\", \"btnSpinnerMinus_focus\", \"btnSpinnerMinus_Nofocus\", \"\", \"\", \"btnText_nofocus2\",\"\",\"ChangeVolume(  spinnerBox7,'myObj.LeftBackVolume'     ,item19,item20,'Minus')\"),        //  item 19
                                            new Array(\"18\",    \"22\",    \"19\",    \"-1\", \"btnSpinnerPlus_focus\", \"btnSpinnerPlus_Nofocus\", \"\", \"\", \"btnText_nofocus2\",\"\", \"ChangeVolume(  spinnerBox7,'myObj.LeftBackVolume'     ,item19,item20,'Plus')\"),        //  item 20
                                            new Array(\"19\",    \"23\",    \"2\",    \"22\", \"btnSpinnerMinus_focus\", \"btnSpinnerMinus_Nofocus\", \"\", \"\", \"btnText_nofocus2\",\"\",\"ChangeVolume(  spinnerBox8,'myObj.RightBackVolume'    ,item21,item22,'Minus')\"),        //  item 21
                                            new Array(\"20\",    \"24\",    \"21\",    \"-1\", \"btnSpinnerPlus_focus\", \"btnSpinnerPlus_Nofocus\", \"\", \"\", \"btnText_nofocus2\",\"\", \"ChangeVolume(  spinnerBox8,'myObj.RightBackVolume'    ,item21,item22,'Plus')\"),        //  item 22
                                            new Array(\"21\",    \"-1\",    \"2\",    \"24\", \"btnSpinnerMinus_focus\", \"btnSpinnerMinus_Nofocus\", \"\", \"\", \"btnText_nofocus2\",\"\",\"ChangeVolume(  spinnerBox9,'myObj.SubwooferVolume'    ,item23,item24,'Minus')\"),        //  item 23
                                            new Array(\"22\",    \"-1\",    \"13\",    \"-1\", \"btnSpinnerPlus_focus\", \"btnSpinnerPlus_Nofocus\", \"\", \"\", \"btnText_nofocus2\",\"\", \"ChangeVolume(  spinnerBox9,'myObj.SubwooferVolume'    ,item23,item24,'Plus')\")        //  item 24
                                            
                                     );
 
         // Array for when focus is on shared viewport; tells where focus should go next
    // (5th element, \"backup,\" is where focus should go if viewport is closed)
                                   //    up, down,   L,    R, backup 
    var aSharedViewportArray = new Array(\"7\", \"SVP\", \"SVP\", \"7\", \"7\")
 
//-->//program
       var myObj = new ActiveXObject(\"CmAVConfig.AudioConfig\");
	   function CheckBtn(btn, checkImage,smyStatement,sAction)
	   {
	        try
			{
				var state=eval(smyStatement);
				//alert(state);
				if(sAction==\"Toggle\"){
				    if(state==1)
					   state=0;
					else
					   state=1;
				    eval(smyStatement +\"=\"+state)
				}
				if( state==1){
					btn.checked = \"yes\";
					btn.style.backgroundImage = checkImage;
				}else{
					btn.checked = \"no\";
					btn.style.backgroundImage = \"none\";
				}
			}
			catch(e)
			{
			}
	   }

	   function ChangeVolume(spinnerItem,smyVolume,MinusBtn,PlusBtn,sAction)
	   {
	      try
		  {
		    var maxVolume=12;
			var minVolume=-39;
			var SpecialVolume=-96;
   
			var delta    =3;
		    var Volume   =0;
			if( sAction==\"Plus\"){			    
			    if(PlusBtn.disabled==true)
				   return;
				if(MinusBtn.disabled){
				   MinusBtn.disabled=false;
				   MinusBtn.style.filter = '';
				}
				Volume=eval(smyVolume)+delta;
				if(Volume >=maxVolume){
				   Volume =maxVolume;
				}
				eval(smyVolume + \"=\" + Volume);
			}else if(sAction==\"Minus\"){
			    if(MinusBtn.disabled==true)
				   return;
				if(PlusBtn.disabled){
				   PlusBtn.disabled=false;
				   PlusBtn.style.filter = '';
				}
				Volume=eval(smyVolume)-delta;
				if(Volume <=minVolume){
				   Volume =minVolume;
				}
				eval(smyVolume + \"=\" + Volume);
			}else if(sAction ==\"Initial\"){
				Volume=eval(smyVolume);
			}
     
			if( Volume<=minVolume){
				spinnerItem.innerHTML=SpecialVolume;
			}else{
			    Volume=(Volume/delta)*delta;
				spinnerItem.innerHTML=Volume;
			}
			if(Volume>=maxVolume){
			   PlusBtn.disabled      =true;
			   PlusBtn.style.filter  ='alpha(opacity=30)';
			   MinusBtn.disabled     =false;
			   MinusBtn.style.filter ='';
				if(sAction=="Plus")
					SetFocus(2);			   
			}else if(Volume<=minVolume){
			   PlusBtn.disabled      =false;
			   PlusBtn.style.filter  ='';
			   MinusBtn.disabled      =true;
			   MinusBtn.style.filter  ='alpha(opacity=30)';
				if(sAction=="Minus")
					SetFocus(3);				   
			}
		  }
		  catch(e)
		  {
		  }
	   }
	   function ChangeSpeakerNumber(spinnerItem,smySpeakerNumber,MinusBtn,PlusBtn,sAction)
	   {
	      try
		  {
		    var spkNumer     =eval(smySpeakerNumber);
			if( sAction==\"Plus\"){
			    if(PlusBtn.disabled==true)
				   return;
				if(MinusBtn.disabled){
				   MinusBtn.disabled=false;
				   MinusBtn.style.filter = '';
				}
			    switch(spkNumer)
				{
					case 1:
					     spkNumer=2;
						 break;
					case 2:
					     spkNumer=4;
						 break;
					case 4:
					     spkNumer=5;
						 break;
					case 5:
					     spkNumer=7;
						 break;
					case 7:
					     return;
						 break;
					
				}
				
				eval(smySpeakerNumber +\"=\" + spkNumer);
				alert (spkNumer);
			}else if(sAction==\"Minus\"){
			    if(MinusBtn.disabled==true)
				   return;
				if(PlusBtn.disabled){
				   PlusBtn.disabled=false;
				   PlusBtn.style.filter = '';
				}
			    switch(spkNumer)
				{
					case 1:
					     return;
						 break;
					case 2:
					     spkNumer=1;
						 break;
					case 4:
					     spkNumer=2;
						 break;
					case 5:
					     spkNumer=4;
						 break;
					case 7:
					     spkNumer=5;
						 break;
				}
				eval(smySpeakerNumber +\"=\" + spkNumer);
				alert (spkNumer);
			}
			
			
			if( spkNumer==1){
				spinnerItem.innerHTML=\"HP\";
			}else{
				spinnerItem.innerHTML=spkNumer;
			}

			if(spkNumer>=7){
			   PlusBtn.disabled      =true;
			   PlusBtn.style.filter  ='alpha(opacity=30)';
			   MinusBtn.disabled     =false;
			   MinusBtn.style.filter ='';
			}else if(spkNumer<=1){
			   PlusBtn.disabled      =false;
			   PlusBtn.style.filter  ='';
			   MinusBtn.disabled      =true;
			   MinusBtn.style.filter  ='alpha(opacity=30)';
			}
			
		  }
		  catch(e)
		  {
		  }

	   }

</script>


</head>


<body id=\"body\" scroll=\"no\" onload=\"Initialize(); setBGColor(CSSLink.href)\" onkeydown=\"onRemoteEvent(window.event.keyCode)\">

<bgsound id=\"btnSound\"><!-- 
    NOTE: in order for transparency to work on backgrounds without affecting color of white text
    background must be placed in separate span inside of TD.
 -->
<table border=\"0\" class=\"textCaption\" cellpadding=\"0\" cellspacing=\"10\" id=\"Title\" style=\"LEFT: 781px; POSITION: absolute; TOP: 90px\">
<tr><td>Speakers</td></tr>
</table>
 
<table border=\"0\" class=\"leftButtonTable_nofocus\" cellpadding=\"0\" cellspacing=\"3\" id=\"leftMenu\">
    <tr><td class=\"btnText_nofocus\" onmousedown=\"btnHiLite(this.children(0),'btn_pressed')\" onmouseover=\"useMouse(this)\" onmouseup=\"btnHiLite(this.children(0),'btn_focus')\" 
    onclick=\"DoNavigation()\" 
     >Volume <span class=\"btn_nofocus\" id=\"item1\"></span></td></tr>
    <tr><td class=\"btnText_nofocus\" onmousedown=\"\" onmouseover=\"useMouse(this)\"                                                                                   
    onmouseup=\"\" onclick=\"btnHiLite(this.children(0),'btn_pressed'); DoNavigation(); btnHiLite(this.children(0),'btn_focus')\" 
   >Speakers<span class=\"btn_nofocus\" id=\"item2\"></span></td></tr>
    <tr><td class=\"btnText_nofocus\" onmousedown=\"btnHiLite(this.children(0),'btn_pressed')\" onmouseover=\"useMouse(this)\" onmouseup=\"btnHiLite(this.children(0),'btn_focus')\" 
    onclick=\"DoNavigation()\" 
     >Surround<span class=\"btn_Nofocus\" id=\"item3\"></span></td></tr>
    <tr><td class=\"btnText_nofocus\" onmousedown=\"btnHiLite(this.children(0),'btn_pressed')\" onmouseover=\"useMouse(this)\" onmouseup=\"btnHiLite(this.children(0),'btn_focus')\" 
    onclick=\"DoNavigation()\" 
     >Setup   <span class=\"btn_nofocus\" id=\"item4\"></span></td></tr>
</table>

<table border=\"0\" class=\"Text1\" cellpadding=\"0\" cellspacing=\"10\" id=\"rightMenu\" style=\"LEFT: 350px; POSITION: absolute; TOP: 150px\">
<tr>
    <td width=350 align=\"left\"><class=\"TEXTLAB\">Number of Satellite Speakers</FONT></td>
    <td width=60 >
        <span class=\"SpinnerBox\" id=\"spinnerBox1\" >
        </span>
    </td>
    <td width=60><!-- Note: do not add any extra tags inside this span or the enable/disable buttons function will stop working-->
        <span class=\"spinnerBtnSpan\">
        <SPAN id=\"item5\" class=\"btnSpinnerMinus_nofocus\" onmouseover=\"useMouse2(this)\" onclick=\"DoNavigation(this)\"></SPAN>
        <span id=\"item6\" class=\"btnSpinnerPlus_nofocus\"  onmouseover=\"useMouse2(this)\" onclick=\"DoNavigation(this)\"></span>
        </span>   
		
            <script>
            try
            {
			    
			    ChangeSpeakerNumber(spinnerBox1,\"myObj.SpeakerNumber\",item5,item6,\"Initial\");
            }
            catch (e)
            {
                //error ignored
            }
            </script>		 
    </td></tr></table>
	<table border=\"0\" class=\"TextVolume\" cellpadding=\"0\" cellspacing=\"10\" id=\"rightMenu\" style=\"LEFT: 380px; POSITION: absolute; TOP: 190px\">
	<tr><td class=\"CheckBoxLabel\" onmouseover=\"useMouse(this)\" onclick=\"DoNavigation()\">Small Speakers<span class=\"checkBox_nofocus\" id=\"item7\" checked=\"no\"></span></td></tr>
	<tr><td class=\"CheckBoxLabel\" onmouseover=\"useMouse(this)\" onclick=\"DoNavigation()\">Enable Subwoofer Output<span class=\"checkBox_nofocus\" id=\"item8\" checked=\"no\"></span></td></tr>
        <script>
            try
            {
			    CheckBtn(item7,\"url(CmImage/checkmark.gif)\",\"myObj.EnableSmallSpeaker\",\"Initial\");
				CheckBtn(item8,\"url(CmImage/checkmark.gif)\",\"myObj.EnableSubwooferOutput\",\"Initial\");
            }
            catch (e)
            {
                //error ignored
            }
            </script>		 
	</table>
	<table border=\"0\" class=\"Text1\" cellpadding=\"0\" cellspacing=\"10\" id=\"rightMenu\" style=\"LEFT: 350px; POSITION: absolute; TOP: 270px\">
	<tr><td width=\"533\" colspan=\"6\"><hr size=\"3\" color=\"#c0c0c0\"></td></tr> 
	<tr><td width=533><class=\"TEXTLAB\">Adjust the speaker channel volumes</td></tr>
    <tr></tr></table>
	<table border=\"0\" class=\"TextVolume\" cellpadding=\"0\" cellspacing=\"12\" id=\"rightMenu\" style=\"LEFT: 400px; POSITION: absolute; TOP: 350px\">
  
  <TR>
    <td width=200 align=\"right\" >Left Front</td>
    <td width=80>
        <span class=\"SpinnerBox\" id=\"spinnerBox2\">
        </span>
    </td>
    <td width=80><!-- Note: do not add any extra tags inside this span or the enable/disable buttons function will stop working-->
        <span class=\"spinnerBtnSpan\">
        <SPAN id=\"item9\" class=\"btnSpinnerMinus_nofocus\" onmouseover=\"useMouse2(this)\" onclick=\"DoNavigation(this)\"></SPAN>
        <span id=\"item10\" class=\"btnSpinnerPlus_nofocus\"  onmouseover=\"useMouse2(this)\" onclick=\"DoNavigation(this)\"></span>
        </span> 
           <script>
            try
            {
			    
			    ChangeVolume(spinnerBox2,\"myObj.LeftFontVolume\",item9,item10,\"Initial\");
            }
            catch (e)
            {
                //error ignored
            }
            </script>		 
    </td></TR>
<tr>
    <td width=200 align=\"right\">Right Front</td>
    <td width=80>
        <span class=\"SpinnerBox\" id=\"spinnerBox3\">

        </span>
    </td>
    <td width=80><!-- Note: do not add any extra tags inside this span or the enable/disable buttons function will stop working-->
        <span class=\"spinnerBtnSpan\">
        <SPAN id=\"item11\" class=\"btnSpinnerMinus_nofocus\" onmouseover=\"useMouse2(this)\" onclick=\"DoNavigation(this)\"></SPAN>
        <span id=\"item12\" class=\"btnSpinnerPlus_nofocus\"  onmouseover=\"useMouse2(this)\" onclick=\"DoNavigation(this)\"></span>
        </span>    
           <script>
            try
            {
			    
			    ChangeVolume(spinnerBox3,\"myObj.RightFrontVolume\",item11,item12,\"Initial\");
            }
            catch (e)
            {
                //error ignored
            }
            </script>		 

    </td></tr>

</table>

</body>

</html>"
*/