//Предзагрузка фона для левой менюшки
var ia = ['menu.gif','menuA.gif'],io=[],bo=[],next = 1,i;

for(i=0; i<ia.length; i++){
 io[i] = new Image();
 io[i].src = '/img/'+ia[i];
} //for i

//предзагрузка анимированой картинки слева вверху
for(i=0; i<3; i++){
 bo[i] = new Image();
 bo[i].src = '/anime/'+(i+1)+'.jpg';
} //for i

function ChangeImage(){
 if(bo.length==next) next = 0;
 Gid('anime').style.backgroundImage='url('+bo[next++].src+')';

 window.setTimeout("ChangeImage();", 5000);
} //function ChangeImage

function Gid(id){
 return document.getElementById(id);
}

function Go(url){
 document.location = url;
}

function cm(o,id,flag){
 if(o && io[flag]) o.style.backgroundImage='url('+io[flag].src+')';
 
 if(id>3){
  var aim = Gid('m'+id);
  if(aim) aim.className = (flag==1) ? 'LmenuA' : 'Lmenu';
  
  var aim = Gid('m'+id+'_1');
  if(aim) aim.className = (flag==1) ? 'LmenuA' : 'Lmenu';
  return;
 } //if id>3 
 
 var aim = Gid('mm'+id);
 if(aim) aim.className = (flag==1) ? 'SmenuA' : 'Smenu';
 return;
} //function cm

function BuildMenu(){
 Gid('hide3').style.display='none';
 cmDrawFromText ('About', 'vbr', cmThemeIE, 'ThemeIE');

 Gid('hide1').style.display='none';
 cmDrawFromText ('News', 'vbr', cmThemeIE, 'ThemeIE');

 Gid('hide2').style.display='none';
 cmDrawFromText ('Products', 'vbr', cmThemeIE, 'ThemeIE');
}

window.setTimeout("ChangeImage();", 5000);




// default node properties
var _cmNodeProperties =
{
        // theme prefix
        prefix:        '',

          // main menu display attributes
          //
          // Note.  When the menu bar is horizontal,
          // mainFolderLeft and mainFolderRight are
          // put in <span></span>.  When the menu
          // bar is vertical, they would be put in
          // a separate TD cell.

          // HTML code to the left of the folder item
          mainFolderLeft: '',
          // HTML code to the right of the folder item
          mainFolderRight: '',
        // HTML code to the left of the regular item
        mainItemLeft: '',
        // HTML code to the right of the regular item
        mainItemRight:        '',

        // sub menu display attributes

        // HTML code to the left of the folder item
        folderLeft:                '',
        // HTML code to the right of the folder item
        folderRight:        '',
        // HTML code to the left of the regular item
        itemLeft:                '',
        // HTML code to the right of the regular item
        itemRight:                '',
        // cell spacing for main menu
        mainSpacing:        0,
        // cell spacing for sub menus
        subSpacing:                0,

        // optional settings
        // If not set, use the default

        // auto disappear time for submenus in milli-seconds
        delay:                        1500,

        // 1st layer sub menu starting index
        zIndexStart:        1000,
        // z-index incremental step for subsequent layers
        zIndexInc:                5,

        // sub menu header appears before the sub menu table
        subMenuHeader:        null,
        // sub menu header appears after the sub menu table
        subMenuFooter:        null,

        // submenu location adjustments
        //
        // offsetHMainAdjust for adjusting the first submenu
        //                 of a 'hbr' menu.
        // offsetVMainAdjust for adjusting the first submenu
        //                of a 'vbr' menu.
        // offsetSubAdjust for subsequent level of submenus
        //
        offsetHMainAdjust:        [0, 0],
        offsetVMainAdjust:        [0, 0],
        offsetSubAdjust:        [0, 0],

        // act on click to open sub menu
        // not yet implemented
        // 0 : use default behavior
        // 1 : hover open in all cases
        // 2 : click on main, hover on sub
        // 3 : click open in all cases (illegal as of 1.5)
        clickOpen:                1,

        // special effects on open/closing a sub menu
        effect:                        null
};

// Globals
var _cmIDCount = 0;
var _cmIDName = 'cmSubMenuID';                // for creating submenu id

var _cmTimeOut = null;                                // how long the menu would stay
var _cmCurrentItem = null;                        // the current menu item being selected;

var _cmNoAction = new Object ();        // indicate that the item cannot be hovered.
var _cmNoClick = new Object ();                // similar to _cmNoAction but does not respond to mouseup/mousedown events
var _cmSplit = new Object ();                // indicate that the item is a menu split

var _cmMenuList = new Array ();                // a list of the current menus
var _cmItemList = new Array ();                // a simple list of items

var _cmFrameList = new Array ();        // a pool of reusable iframes
var _cmFrameListSize = 0;                        // keep track of the actual size
var _cmFrameIDCount = 0;                        // keep track of the frame id
var _cmFrameMasking = true;                        // use the frame masking

// disable iframe masking for IE7
/*@cc_on
        @if (@_jscript_version >= 5.6)
                if (_cmFrameMasking)
                {
                        var v = navigator.appVersion;
                        var i = v.indexOf ("MSIE ");
                        if (i >= 0)
                        {
                                if (parseInt (navigator.appVersion.substring (i + 5)) >= 7)
                                        _cmFrameMasking = false;
                        }
                }
        @end
@*/

var _cmClicked = false;                                // for onClick

// flag for turning on off hiding objects
//
// 0: automatic
// 1: hiding
// 2: no hiding
var _cmHideObjects = 0;

// Utility function to do a shallow copy a node property
function cmClone (nodeProperties)
{
        var returnVal = new Object ();
        for (v in nodeProperties)
                returnVal[v] = nodeProperties[v];
        return returnVal;
}

//
// store the new menu information into a structure to retrieve it later
//
function cmAllocMenu (id, menu, orient, nodeProperties, prefix)
{
        var info = new Object ();
        info.div = id;
        info.menu = menu;
        info.orient = orient;
        info.nodeProperties = nodeProperties;
        info.prefix = prefix;
        var menuID = _cmMenuList.length;
        _cmMenuList[menuID] = info;
        return menuID;
}

//
// request a frame
//
function cmAllocFrame ()
{
        if (_cmFrameListSize > 0)
                return cmGetObject (_cmFrameList[--_cmFrameListSize]);
        var frameObj = document.createElement ('iframe');
        var id = _cmFrameIDCount++;
        frameObj.id = 'cmFrame' + id;
        frameObj.frameBorder = '0';
        frameObj.style.display = 'none';
        frameObj.src = 'javascript:false';
        document.body.appendChild (frameObj);
        frameObj.style.filter = 'alpha(opacity=0)';
        frameObj.style.zIndex = 99;
        frameObj.style.position = 'absolute';
        frameObj.style.border = '0';
        frameObj.scrolling = 'no';
        return frameObj;
}

//
// make a frame resuable later
//
function cmFreeFrame (frameObj)
{
        _cmFrameList[_cmFrameListSize++] = frameObj.id;
}

//////////////////////////////////////////////////////////////////////
//
// Drawing Functions and Utility Functions
//
//////////////////////////////////////////////////////////////////////

//
// produce a new unique id
//
function cmNewID ()
{
        return _cmIDName + (++_cmIDCount);
}

//
// return the property string for the menu item
//
function cmActionItem (item, isMain, idSub, menuInfo, menuID)
{
        _cmItemList[_cmItemList.length] = item;
        var index = _cmItemList.length - 1;
        idSub = (!idSub) ? 'null' : ('\'' + idSub + '\'');

        var clickOpen = menuInfo.nodeProperties.clickOpen;
        var onClick = (clickOpen == 3) || (clickOpen == 2 && isMain);

        var param = 'this,' + isMain + ',' + idSub + ',' + menuID + ',' + index;

        var returnStr;
        if (onClick)
                returnStr = ' onmouseover="cmItemMouseOver(' + param + ',false)" onmousedown="cmItemMouseDownOpenSub (' + param + ')"';
        else
                returnStr = ' onmouseover="cmItemMouseOverOpenSub (' + param + ')" onmousedown="cmItemMouseDown (' + param + ')"';
        return returnStr + ' onmouseout="cmItemMouseOut (' + param + ')" onmouseup="cmItemMouseUp (' + param + ')"';
}

//
// this one is used by _cmNoClick to only take care of onmouseover and onmouseout
// events which are associated with menu but not actions associated with menu clicking/closing
//
function cmNoClickItem (item, isMain, idSub, menuInfo, menuID)
{
        // var index = _cmItemList.push (item) - 1;
        _cmItemList[_cmItemList.length] = item;
        var index = _cmItemList.length - 1;
        idSub = (!idSub) ? 'null' : ('\'' + idSub + '\'');

        var param = 'this,' + isMain + ',' + idSub + ',' + menuID + ',' + index;

        return ' onmouseover="cmItemMouseOver (' + param + ')" onmouseout="cmItemMouseOut (' + param + ')"';
}

function cmNoActionItem (item)
{
        return item[1];
}

function cmSplitItem (prefix, isMain, vertical)
{
        var classStr = 'cm' + prefix;
        if (isMain)
        {
                classStr += 'Main';
                if (vertical)
                        classStr += 'HSplit';
                else
                        classStr += 'VSplit';
        }
        else
                classStr += 'HSplit';
        return eval (classStr);
}

//
// draw the sub menu recursively
//
function cmDrawSubMenu (subMenu, prefix, id, nodeProperties, zIndexStart, menuInfo, menuID)
{
        var str = '<div class="' + prefix + 'SubMenu" id="' + id + '" style="z-index: ' + zIndexStart + ';position: absolute; top: 0px; left: 0px;">';
        if (nodeProperties.subMenuHeader)
                str += nodeProperties.subMenuHeader;

        str += '<table border=0 summary="sub menu" id="' + id + 'Table" cellspacing=0 cellpadding=0 class="' + prefix + 'SubMenuTable">'+
                '<tr height=8>'+
                 '<td width=8 nowrap background="/img/sm1.gif"></td>'+
                 '<td width=100% bgcolor=#f3b826></td>'+
                 '<td width=8 nowrap background="/img/sm2.gif"></td>'+
                '</tr>';

        var strSub = '';

        var item;
        var idSub;
        var hasChild;

        var i;

        var classStr;

        for (i = 5; i < subMenu.length; ++i)
        {
                item = subMenu[i];
                if (!item)
                        continue;

                if (item == _cmSplit)
                        item = cmSplitItem (prefix, 0, true);
                item.parentItem = subMenu;
                item.subMenuID = id;

                hasChild = (item.length > 5);
                idSub = hasChild ? cmNewID () : null;

                str += '<tr class="' + prefix + 'MenuItem"';
                if (item[0] != _cmNoClick)
                        str += cmActionItem (item, 0, idSub, menuInfo, menuID);
                else
                        str += cmNoClickItem (item, 0, idSub, menuInfo, menuID);
                str += '>'

                if (item[0] == _cmNoAction || item[0] == _cmNoClick)
                {
                        str += cmNoActionItem (item);
                        str += '</tr>';
                        continue;
                }

                classStr = prefix + 'Menu';
                classStr += hasChild ? 'Folder' : 'Item';

                str += '<td class="' + classStr + 'Left">';

                if (item[0] != null)
                        str += item[0];
                else
                        str += hasChild ? nodeProperties.folderLeft : nodeProperties.itemLeft;

                str += '</td><td class="' + classStr + 'Text">' + item[1];

                str += '</td><td class="' + classStr + 'Right">';

                if (hasChild)
                {
                        str += nodeProperties.folderRight;
                        strSub += cmDrawSubMenu (item, prefix, idSub, nodeProperties, zIndexStart + nodeProperties.zIndexInc, menuInfo, menuID);
                }
                else
                        str += nodeProperties.itemRight;
                str += '</td></tr>';
        }

        str +=  '<tr height=8>'+
                 '<td width=8 nowrap background="/img/sm3.gif"></td>'+
                 '<td width=100% bgcolor=#f3b826></td>'+
                 '<td width=8 nowrap background="/img/sm4.gif"></td>'+
                '</tr>'+
               '</table>';

        if (nodeProperties.subMenuFooter)
                str += nodeProperties.subMenuFooter;
        str += '</div>' + strSub;
        return str;
}

//
// The function that builds the menu inside the specified element id.
//
// id                                id of the element
// orient                        orientation of the menu in [hv][ub][lr] format
// menu                                the menu object to be drawn
// nodeProperties        properties for the theme
// prefix                        prefix of the theme
//
function cmDraw (id, menu, orient, nodeProperties, prefix)
{
        var obj = cmGetObject (id);

        if (!prefix)
                prefix = nodeProperties.prefix;
        if (!prefix)
                prefix = '';
        if (!nodeProperties)
                nodeProperties = _cmNodeProperties;
        if (!orient)
                orient = 'hbr';

        var menuID = cmAllocMenu (id, menu, orient, nodeProperties, prefix);
        var menuInfo = _cmMenuList[menuID];

        // setup potentially missing properties
        if (!nodeProperties.delay)
                nodeProperties.delay = _cmNodeProperties.delay;
        if (!nodeProperties.clickOpen)
                nodeProperties.clickOpen = _cmNodeProperties.clickOpen;
        if (!nodeProperties.zIndexStart)
                nodeProperties.zIndexStart = _cmNodeProperties.zIndexStart;
        if (!nodeProperties.zIndexInc)
                nodeProperties.zIndexInc = _cmNodeProperties.zIndexInc;
        if (!nodeProperties.offsetHMainAdjust)
                nodeProperties.offsetHMainAdjust = _cmNodeProperties.offsetHMainAdjust;
        if (!nodeProperties.offsetVMainAdjust)
                nodeProperties.offsetVMainAdjust = _cmNodeProperties.offsetVMainAdjust;
        if (!nodeProperties.offsetSubAdjust)
                nodeProperties.offsetSubAdjust = _cmNodeProperties.offsetSubAdjust;
        // save user setting on frame masking
        menuInfo.cmFrameMasking = _cmFrameMasking;

        var str = '<table summary="main menu" class="' + prefix + 'Menu" cellspacing="' + nodeProperties.mainSpacing + '">';
        var strSub = '';

        var vertical;

        // draw the main menu items
        if (orient.charAt (0) == 'h')
        {
                str += '<tr>';
                vertical = false;
        }
        else
        {
                vertical = true;
        }

        var i;
        var item;
        var idSub;
        var hasChild;

        var classStr;

        for (i = 0; i < menu.length; ++i)
        {
                item = menu[i];

                if (!item)
                        continue;

                item.menu = menu;
                item.subMenuID = id;

                str += vertical ? '<tr' : '<td';
                str += ' class="' + prefix + 'MainItem"';

                hasChild = (item.length > 5);
                idSub = hasChild ? cmNewID () : null;

                str += cmActionItem (item, 1, idSub, menuInfo, menuID) + '>';

                if (item == _cmSplit)
                        item = cmSplitItem (prefix, 1, vertical);

                if (item[0] == _cmNoAction || item[0] == _cmNoClick)
                {
                        str += cmNoActionItem (item);
                        str += vertical? '</tr>' : '</td>';
                        continue;
                }

                classStr = prefix + 'Main' + (hasChild ? 'Folder' : 'Item');

                str += vertical ? '<td' : '<span';
                str += ' class="' + classStr + 'Left">';

                str += (item[0] == null) ? (hasChild ? nodeProperties.mainFolderLeft : nodeProperties.mainItemLeft)
                                         : item[0];
                str += vertical ? '</td>' : '</span>';

                str += vertical ? '<td' : '<span';
                str += ' class="' + classStr + 'Text">';
                str += item[1];

                str += vertical ? '</td>' : '</span>';

                str += vertical ? '<td' : '<span';
                str += ' class="' + classStr + 'Right">';

                str += hasChild ? nodeProperties.mainFolderRight : nodeProperties.mainItemRight;

                str += vertical ? '</td>' : '</span>';

                str += vertical ? '</tr>' : '</td>';

                if (hasChild)
                        strSub += cmDrawSubMenu (item, prefix, idSub, nodeProperties, nodeProperties.zIndexStart, menuInfo, menuID);
        }
        if (!vertical)
                str += '</tr>';
        str += '</table>' + strSub;
        obj.innerHTML = str;
}

//
// The function builds the menu inside the specified element id.
//
// This function is similar to cmDraw except that menu is taken from HTML node
// rather a javascript tree.  This feature allows links to be scanned by search
// bots.
//
// This function basically converts HTML node to a javascript tree, and then calls
// cmDraw to draw the actual menu, replacing the hidden menu tree.
//
// Format:
//        <div id="menu">
//                <ul style="visibility: hidden">
//                        <li><span>icon</span><a href="link" title="description">main menu text</a>
//                                <ul>
//                                        <li><span>icon</span><a href="link" title="description">submenu item</a>
//                                        </li>
//                                </ul>
//                        </li>
//                </ul>
//        </div>
//
function cmDrawFromText (id, orient, nodeProperties, prefix)
{
        var domMenu = cmGetObject (id);
        var menu = null;
        for (var currentDomItem = domMenu.firstChild; currentDomItem; currentDomItem = currentDomItem.nextSibling)
        {
                if (!currentDomItem.tagName)
                        continue;
                var tag = currentDomItem.tagName.toLowerCase ();
                if (tag != 'ul' && tag != 'ol')
                        continue;
                menu = cmDrawFromTextSubMenu (currentDomItem);
                break;
        }
        if (menu)
                cmDraw (id, menu, orient, nodeProperties, prefix);
}

//
// a recursive function that build menu tree structure
//
function cmDrawFromTextSubMenu (domMenu)
{
        var items = new Array ();
        for (var currentDomItem = domMenu.firstChild; currentDomItem; currentDomItem = currentDomItem.nextSibling)
        {
                if (!currentDomItem.tagName || currentDomItem.tagName.toLowerCase () != 'li')
                        continue;
                if (currentDomItem.firstChild == null)
                {
                        items[items.length] = _cmSplit;
                        continue;
                }
                var item = new Array ();
                var currentItem = currentDomItem.firstChild;
                var hasAction = false;
                for (; currentItem; currentItem = currentItem.nextSibling)
                {
                        // scan for span or div tag
                        if (!currentItem.tagName)
                                continue;
                        if (currentItem.className == 'cmNoClick')
                        {
                                item[0] = _cmNoClick;
                                item[1] = getActionHTML (currentItem);
                                hasAction = true;
                                break;
                        }
                        if (currentItem.className == 'cmNoAction')
                        {
                                item[0] = _cmNoAction;
                                item[1] = getActionHTML (currentItem);
                                hasAction = true;
                                break;
                        }
                        var tag = currentItem.tagName.toLowerCase ();
                        if (tag != 'span')
                                continue;
                        if (!currentItem.firstChild)
                                item[0] = null;
                        else
                                item[0] = currentItem.innerHTML;
                        currentItem = currentItem.nextSibling;
                        break;
                }
                if (hasAction)
                {
                        items[items.length] = item;
                        continue;
                }
                if (!currentItem)
                        continue;
                for (; currentItem; currentItem = currentItem.nextSibling)
                {
                        if (!currentItem.tagName)
                                continue;
                        var tag = currentItem.tagName.toLowerCase ();
                        if (tag == 'a')
                        {
                                item[1] = currentItem.innerHTML;
                                item[2] = currentItem.href;
                                item[3] = currentItem.target;
                                item[4] = currentItem.title;
                                if (item[4] == '')
                                        item[4] = null;
                        }
                        else if (tag == 'span' || tag == 'div')
                        {
                                item[1] = currentItem.innerHTML;
                                item[2] = null;
                                item[3] = null;
                                item[4] = null;
                        }
                        break;
                }

                for (; currentItem; currentItem = currentItem.nextSibling)
                {
                        // scan for span tag
                        if (!currentItem.tagName)
                                continue;
                        var tag = currentItem.tagName.toLowerCase ();
                        if (tag != 'ul' && tag != 'ol')
                                continue;
                        var subMenuItems = cmDrawFromTextSubMenu (currentItem);
                        for (i = 0; i < subMenuItems.length; ++i)
                                item[i + 5] = subMenuItems[i];
                        break;
                }
                items[items.length] = item;
        }
        return items;
}

//
// obtain the actual action item's action, which is inside a
// table.  The first row should be it
//
function getActionHTML (htmlNode)
{
        var returnVal = '<td></td><td></td><td></td>';
        var currentDomItem;
        // find the table first
        for (currentDomItem = htmlNode.firstChild; currentDomItem; currentDomItem = currentDomItem.nextSibling)
        {
                if (currentDomItem.tagName && currentDomItem.tagName.toLowerCase () == 'table')
                        break;
        }
        if (!currentDomItem)
                return returnVal;
        // skip over tbody
        for (currentDomItem = currentDomItem.firstChild; currentDomItem; currentDomItem = currentDomItem.nextSibling)
        {
                if (currentDomItem.tagName && currentDomItem.tagName.toLowerCase () == 'tbody')
                        break;
        }
        if (!currentDomItem)
                return returnVal;
        // get the first tr
        for (currentDomItem = currentDomItem.firstChild; currentDomItem; currentDomItem = currentDomItem.nextSibling)
        {
                if (currentDomItem.tagName && currentDomItem.tagName.toLowerCase () == 'tr')
                        break;
        }
        if (!currentDomItem)
                return returnVal;
        return currentDomItem.innerHTML;
}

//
// get the DOM object associated with the item
//
function cmGetMenuItem (item)
{
        if (!item.subMenuID)
                return null;
        var subMenu = cmGetObject (item.subMenuID);
        // we are dealing with a main menu item
        if (item.menu)
        {
                var menu = item.menu;
                // skip over table, tbody, tr, reach td
                subMenu = subMenu.firstChild.firstChild.firstChild.firstChild;
                var i;
                for (i = 0; i < menu.length; ++i)
                {
                        if (menu[i] == item)
                                return subMenu;
                        subMenu = subMenu.nextSibling;
                }
        }
        else if (item.parentItem) // sub menu item
        {
                var menu = item.parentItem;
                var table = cmGetObject (item.subMenuID + 'Table');
                if (!table)
                        return null;
                // skip over table, tbody, reach tr
                subMenu = table.firstChild.firstChild;
                var i;
                for (i = 5; i < menu.length; ++i)
                {
                        if (menu[i] == item)
                                return subMenu;
                        subMenu = subMenu.nextSibling;
                }
        }
        return null;
}

//
// disable a menu item
//
function cmDisableItem (item, prefix)
{
        if (!item)
                return;
        var menuItem = cmGetMenuItem (item);
        if (!menuItem)
                return;
        if (item.menu)
                menuItem.className = prefix + 'MainItemDisabled';
        else
                menuItem.className = prefix + 'MenuItemDisabled';
        item.isDisabled = true;
}

//
// enable a menu item
//
function cmEnableItem (item, prefix)
{
        if (!item)
                return;
        var menuItem = cmGetMenuItem (item);
        if (!menuItem)
                return;
        if (item.menu)
                menu.className = prefix + 'MainItem';
        else
                menu.className = prefix + 'MenuItem';
        item.isDisabled = true;
}

//////////////////////////////////////////////////////////////////////
//
// Mouse Event Handling Functions
//
//////////////////////////////////////////////////////////////////////

//
// action should be taken for mouse moving in to the menu item
//
// Here we just do things concerning this menu item, w/o opening sub menus.
//
function cmItemMouseOver (obj, isMain, idSub, menuID, index, calledByOpenSub)
{
        if (!calledByOpenSub && _cmClicked)
        {
                cmItemMouseOverOpenSub (obj, isMain, idSub, menuID, index);
                return;
        }

        clearTimeout (_cmTimeOut);

        if (_cmItemList[index].isDisabled)
                return;

        var prefix = _cmMenuList[menuID].prefix;

        if (!obj.cmMenuID)
        {
                obj.cmMenuID = menuID;
                obj.cmIsMain = isMain;
        }

        var thisMenu = cmGetThisMenu (obj, prefix);

        // insert obj into cmItems if cmItems doesn't have obj
        if (!thisMenu.cmItems)
                thisMenu.cmItems = new Array ();
        var i;
        for (i = 0; i < thisMenu.cmItems.length; ++i)
        {
                if (thisMenu.cmItems[i] == obj)
                        break;
        }
        if (i == thisMenu.cmItems.length)
        {
                //thisMenu.cmItems.push (obj);
                thisMenu.cmItems[i] = obj;
        }

        // hide the previous submenu that is not this branch
        if (_cmCurrentItem)
        {
                // occationally, we get this case when user
                // move the mouse slowly to the border
                if (_cmCurrentItem == obj || _cmCurrentItem == thisMenu)
                {
                        var item = _cmItemList[index];
                        cmSetStatus (item);
                        return;
                }

                var thatMenuInfo = _cmMenuList[_cmCurrentItem.cmMenuID];
                var thatPrefix = thatMenuInfo.prefix;
                var thatMenu = cmGetThisMenu (_cmCurrentItem, thatPrefix);

                if (thatMenu != thisMenu.cmParentMenu)
                {
                        if (_cmCurrentItem.cmIsMain)
                                _cmCurrentItem.className = thatPrefix + 'MainItem';
                        else
                                _cmCurrentItem.className = thatPrefix + 'MenuItem';
                        if (thatMenu.id != idSub)
                                cmHideMenu (thatMenu, thisMenu, thatMenuInfo);
                }
        }

        // okay, set the current menu to this obj
        _cmCurrentItem = obj;

        // just in case, reset all items in this menu to MenuItem
        cmResetMenu (thisMenu, prefix);

        var item = _cmItemList[index];
        var isDefaultItem = cmIsDefaultItem (item);

        if (isDefaultItem)
        {
                if (isMain)
                        obj.className = prefix + 'MainItemHover';
                else
                        obj.className = prefix + 'MenuItemHover';
        }

        cmSetStatus (item);
}

//
// action should be taken for mouse moving in to the menu item
//
// This function also opens sub menu
//
function cmItemMouseOverOpenSub (obj, isMain, idSub, menuID, index)
{
        clearTimeout (_cmTimeOut);

        if (_cmItemList[index].isDisabled)
                return;

        cmItemMouseOver (obj, isMain, idSub, menuID, index, true);

        if (idSub)
        {
                var subMenu = cmGetObject (idSub);
                var menuInfo = _cmMenuList[menuID];
                var orient = menuInfo.orient;
                var prefix = menuInfo.prefix;
                cmShowSubMenu (obj, isMain, subMenu, menuInfo);
        }
}

//
// action should be taken for mouse moving out of the menu item
//
function cmItemMouseOut (obj, isMain, idSub, menuID, index)
{
        var delayTime = _cmMenuList[menuID].nodeProperties.delay;
        _cmTimeOut = window.setTimeout ('cmHideMenuTime ()', delayTime);
        window.defaultStatus = '';
}

//
// action should be taken for mouse button down at a menu item
//
function cmItemMouseDown (obj, isMain, idSub, menuID, index)
{
        if (_cmItemList[index].isDisabled)
                return;

        if (cmIsDefaultItem (_cmItemList[index]))
        {
                var prefix = _cmMenuList[menuID].prefix;
                if (obj.cmIsMain)
                        obj.className = prefix + 'MainItemActive';
                else
                        obj.className = prefix + 'MenuItemActive';
        }
}

//
// action should be taken for mouse button down at a menu item
// this is one also opens submenu if needed
//
function cmItemMouseDownOpenSub (obj, isMain, idSub, menuID, index)
{
        if (_cmItemList[index].isDisabled)
                return;

        _cmClicked = true;
        cmItemMouseDown (obj, isMain, idSub, menuID, index);

        if (idSub)
        {
                var subMenu = cmGetObject (idSub);
                var menuInfo = _cmMenuList[menuID];
                cmShowSubMenu (obj, isMain, subMenu, menuInfo);
        }
}

//
// action should be taken for mouse button up at a menu item
//
function cmItemMouseUp (obj, isMain, idSub, menuID, index)
{
        if (_cmItemList[index].isDisabled)
                return;

        var item = _cmItemList[index];

        var link = null, target = '_self';

        if (item.length > 2)
                link = item[2];
        if (item.length > 3 && item[3])
                target = item[3];

        if (link != null)
        {
                _cmClicked = false;
                window.open (link, target);
        }

        var menuInfo = _cmMenuList[menuID];
        var prefix = menuInfo.prefix;
        var thisMenu = cmGetThisMenu (obj, prefix);

        var hasChild = (item.length > 5);
        if (!hasChild)
        {
                if (cmIsDefaultItem (item))
                {
                        if (obj.cmIsMain)
                                obj.className = prefix + 'MainItem';
                        else
                                obj.className = prefix + 'MenuItem';
                }
                cmHideMenu (thisMenu, null, menuInfo);
        }
        else
        {
                if (cmIsDefaultItem (item))
                {
                        if (obj.cmIsMain)
                                obj.className = prefix + 'MainItemHover';
                        else
                                obj.className = prefix + 'MenuItemHover';
                }
        }
}

//////////////////////////////////////////////////////////////////////
//
// Mouse Event Support Utility Functions
//
//////////////////////////////////////////////////////////////////////

//
// move submenu to the appropriate location
//
function cmMoveSubMenu (obj, isMain, subMenu, menuInfo)
{
        var orient = menuInfo.orient;

        var offsetAdjust;

        if (isMain)
        {
                if (orient.charAt (0) == 'h')
                        offsetAdjust = menuInfo.nodeProperties.offsetHMainAdjust;
                else
                        offsetAdjust = menuInfo.nodeProperties.offsetVMainAdjust;
        }
        else
                offsetAdjust = menuInfo.nodeProperties.offsetSubAdjust;

        if (!isMain && orient.charAt (0) == 'h')
                orient = 'v' + orient.charAt (1) + orient.charAt (2);

        var mode = String (orient);
        var p = subMenu.offsetParent;
        var subMenuWidth = cmGetWidth (subMenu);
        var horiz = cmGetHorizontalAlign (obj, mode, p, subMenuWidth);
        if (mode.charAt (0) == 'h')
        {
                if (mode.charAt (1) == 'b')
                        subMenu.style.top = (cmGetYAt (obj, p) + cmGetHeight (obj) + offsetAdjust[1]) + 'px';
                else
                        subMenu.style.top = (cmGetYAt (obj, p) - cmGetHeight (subMenu) - offsetAdjust[1]) + 'px';
                if (horiz == 'r')
                        subMenu.style.left = (cmGetXAt (obj, p) + offsetAdjust[0]) + 'px';
                else
                        subMenu.style.left = (cmGetXAt (obj, p) + cmGetWidth (obj) - subMenuWidth - offsetAdjust[0]) + 'px';
        }
        else
        {
                if (horiz == 'r')
                        subMenu.style.left = (cmGetXAt (obj, p) + cmGetWidth (obj) + offsetAdjust[0]) + 'px';
                else
                        subMenu.style.left = (cmGetXAt (obj, p) - subMenuWidth - offsetAdjust[0]) + 'px';
                if (mode.charAt (1) == 'b')
                        subMenu.style.top = (cmGetYAt (obj, p) + offsetAdjust[1]) + 'px';
                else
                        subMenu.style.top = (cmGetYAt (obj, p) + cmGetHeight (obj) - cmGetHeight (subMenu) + offsetAdjust[1]) + 'px';
        }

        // IE specific iframe masking method
        /*@cc_on
                @if (@_jscript_version >= 5.5)
                        if (menuInfo.cmFrameMasking)
                        {
                                if (!subMenu.cmFrameObj)
                                {
                                        var frameObj = cmAllocFrame ();
                                        subMenu.cmFrameObj = frameObj;
                                }

                                var frameObj = subMenu.cmFrameObj;
                                frameObj.style.zIndex = subMenu.style.zIndex - 1;
                                frameObj.style.left = (cmGetX (subMenu) - cmGetX (frameObj.offsetParent)) + 'px';
                                frameObj.style.top = (cmGetY (subMenu)  - cmGetY (frameObj.offsetParent)) + 'px';
                                frameObj.style.width = cmGetWidth (subMenu) + 'px';
                                frameObj.style.height = cmGetHeight (subMenu) + 'px';
                                frameObj.style.display = 'block';
                        }
                @end
        @*/
        if (horiz != orient.charAt (2))
                orient = orient.charAt (0) + orient.charAt (1) + horiz;
        return orient;
}

//
// automatically re-adjust the menu position based on available screen size.
//
function cmGetHorizontalAlign (obj, mode, p, subMenuWidth)
{
        var horiz = mode.charAt (2);
        if (!(document.body))
                return horiz;
        var body = document.body;
        var browserLeft;
        var browserRight;
        if (window.innerWidth)
        {
                // DOM window attributes
                browserLeft = window.pageXOffset;
                browserRight = window.innerWidth + browserLeft;
        }
        else if (body.clientWidth)
        {
                // IE attributes
                browserLeft = body.clientLeft;
                browserRight = body.clientWidth + browserLeft;
        }
        else
                return horiz;
        if (mode.charAt (0) == 'h')
        {
                if (horiz == 'r' && (cmGetXAt (obj) + subMenuWidth) > browserRight)
                        horiz = 'l';
                if (horiz == 'l' && (cmGetXAt (obj) + cmGetWidth (obj) - subMenuWidth) < browserLeft)
                        horiz = 'r';
                return horiz;
        }
        else
        {
                if (horiz == 'r' && (cmGetXAt (obj, p) + cmGetWidth (obj) + subMenuWidth) > browserRight)
                        horiz = 'l';
                if (horiz == 'l' && (cmGetXAt (obj, p) - subMenuWidth) < browserLeft)
                        horiz = 'r';
                return horiz;
        }
}

//
// show the subMenu w/ specified orientation
// also move it to the correct coordinates
//
function cmShowSubMenu (obj, isMain, subMenu, menuInfo)
{
        var prefix = menuInfo.prefix;

        if (!subMenu.cmParentMenu)
        {
                // establish the tree w/ back edge
                var thisMenu = cmGetThisMenu (obj, prefix);
                subMenu.cmParentMenu = thisMenu;
                if (!thisMenu.cmSubMenu)
                        thisMenu.cmSubMenu = new Array ();
                thisMenu.cmSubMenu[thisMenu.cmSubMenu.length] = subMenu;
        }

        var effectInstance = subMenu.cmEffect;
        if (effectInstance)
                effectInstance.showEffect (true);
        else
        {
                // position the sub menu only if we are not already showing the submenu
                var orient = cmMoveSubMenu (obj, isMain, subMenu, menuInfo);
                subMenu.cmOrient = orient;

                var forceShow = false;
                if (subMenu.style.visibility != 'visible' && menuInfo.nodeProperties.effect)
                {
                        try
                        {
                                effectInstance = menuInfo.nodeProperties.effect.getInstance (subMenu, orient);
                                effectInstance.showEffect (false);
                        }
                        catch (e)
                        {
                                forceShow = true;
                                subMenu.cmEffect = null;
                        }
                }
                else
                        forceShow = true;

                if (forceShow)
                {
                        subMenu.style.visibility = 'visible';
                        /*@cc_on
                                @if (@_jscript_version >= 5.5)
                                        if (subMenu.cmFrameObj)
                                                subMenu.cmFrameObj.style.display = 'block';
                                @end
                        @*/
                }
        }

        if (!_cmHideObjects)
        {
                _cmHideObjects = 2;        // default = not hide, may change behavior later
                try
                {
                        if (window.opera)
                        {
                                if (parseInt (navigator.appVersion) < 9)
                                        _cmHideObjects = 1;
                        }
                }
                catch (e)
                {
                }
        }

        if (_cmHideObjects == 1)
        {
                if (!subMenu.cmOverlap)
                        subMenu.cmOverlap = new Array ();
                cmHideControl ("IFRAME", subMenu);
                cmHideControl ("OBJECT", subMenu);
        }
}

//
// reset all the menu items to class MenuItem in thisMenu
//
function cmResetMenu (thisMenu, prefix)
{
        if (thisMenu.cmItems)
        {
                var i;
                var str;
                var items = thisMenu.cmItems;
                for (i = 0; i < items.length; ++i)
                {
                        if (items[i].cmIsMain)
                        {
                                if (items[i].className == (prefix + 'MainItemDisabled'))
                                        continue;
                        }
                        else
                        {
                                if (items[i].className == (prefix + 'MenuItemDisabled'))
                                        continue;
                        }
                        if (items[i].cmIsMain)
                                str = prefix + 'MainItem';
                        else
                                str = prefix + 'MenuItem';
                        if (items[i].className != str)
                                items[i].className = str;
                }
        }
}

//
// called by the timer to hide the menu
//
function cmHideMenuTime ()
{
        _cmClicked = false;
        if (_cmCurrentItem)
        {
                var menuInfo = _cmMenuList[_cmCurrentItem.cmMenuID];
                var prefix = menuInfo.prefix;
                cmHideMenu (cmGetThisMenu (_cmCurrentItem, prefix), null, menuInfo);
                _cmCurrentItem = null;
        }
}

//
// Only hides this menu
//
function cmHideThisMenu (thisMenu, menuInfo)
{
        var effectInstance = thisMenu.cmEffect;
        if (effectInstance)
                effectInstance.hideEffect (true);
        else
        {
                thisMenu.style.visibility = 'hidden';
                thisMenu.style.top = '0px';
                thisMenu.style.left = '0px';
                thisMenu.cmOrient = null;
                /*@cc_on
                        @if (@_jscript_version >= 5.5)
                                if (thisMenu.cmFrameObj)
                                {
                                        var frameObj = thisMenu.cmFrameObj;
                                        frameObj.style.display = 'none';
                                        frameObj.style.width = '1px';
                                        frameObj.style.height = '1px';
                                        thisMenu.cmFrameObj = null;
                                        cmFreeFrame (frameObj);
                                }
                        @end
                @*/
        }

        cmShowControl (thisMenu);
        thisMenu.cmItems = null;
}

//
// hide thisMenu, children of thisMenu, as well as the ancestor
// of thisMenu until currentMenu is encountered.  currentMenu
// will not be hidden
//
function cmHideMenu (thisMenu, currentMenu, menuInfo)
{
        var prefix = menuInfo.prefix;
        var str = prefix + 'SubMenu';

        // hide the down stream menus
        if (thisMenu.cmSubMenu)
        {
                var i;
                for (i = 0; i < thisMenu.cmSubMenu.length; ++i)
                {
                        cmHideSubMenu (thisMenu.cmSubMenu[i], menuInfo);
                }
        }

        // hide the upstream menus
        while (thisMenu && thisMenu != currentMenu)
        {
                cmResetMenu (thisMenu, prefix);
                if (thisMenu.className == str)
                {
                        cmHideThisMenu (thisMenu, menuInfo);
                }
                else
                        break;
                thisMenu = cmGetThisMenu (thisMenu.cmParentMenu, prefix);
        }
}

//
// hide thisMenu as well as its sub menus if thisMenu is not
// already hidden
//
function cmHideSubMenu (thisMenu, menuInfo)
{
        if (thisMenu.style.visibility == 'hidden')
                return;
        if (thisMenu.cmSubMenu)
        {
                var i;
                for (i = 0; i < thisMenu.cmSubMenu.length; ++i)
                {
                        cmHideSubMenu (thisMenu.cmSubMenu[i], menuInfo);
                }
        }
        var prefix = menuInfo.prefix;
        cmResetMenu (thisMenu, prefix);
        cmHideThisMenu (thisMenu, menuInfo);
}

//
// hide a control such as IFRAME
//
function cmHideControl (tagName, subMenu)
{
        var x = cmGetX (subMenu);
        var y = cmGetY (subMenu);
        var w = subMenu.offsetWidth;
        var h = subMenu.offsetHeight;

        var i;
        for (i = 0; i < document.all.tags(tagName).length; ++i)
        {
                var obj = document.all.tags(tagName)[i];
                if (!obj || !obj.offsetParent)
                        continue;

                // check if the object and the subMenu overlap

                var ox = cmGetX (obj);
                var oy = cmGetY (obj);
                var ow = obj.offsetWidth;
                var oh = obj.offsetHeight;

                if (ox > (x + w) || (ox + ow) < x)
                        continue;
                if (oy > (y + h) || (oy + oh) < y)
                        continue;

                // if object is already made hidden by a different
                // submenu then we dont want to put it on overlap list of
                // of a submenu a second time.
                // - bug fixed by Felix Zaslavskiy
                if(obj.style.visibility == 'hidden')
                        continue;

                //subMenu.cmOverlap.push (obj);
                subMenu.cmOverlap[subMenu.cmOverlap.length] = obj;
                obj.style.visibility = 'hidden';
        }
}

//
// show the control hidden by the subMenu
//
function cmShowControl (subMenu)
{
        if (subMenu.cmOverlap)
        {
                var i;
                for (i = 0; i < subMenu.cmOverlap.length; ++i)
                        subMenu.cmOverlap[i].style.visibility = "";
        }
        subMenu.cmOverlap = null;
}

//
// returns the main menu or the submenu table where this obj (menu item)
// is in
//
function cmGetThisMenu (obj, prefix)
{
        var str1 = prefix + 'SubMenu';
        var str2 = prefix + 'Menu';
        while (obj)
        {
                if (obj.className == str1 || obj.className == str2)
                        return obj;
                obj = obj.parentNode;
        }
        return null;
}

//
// A special effect function to hook the menu which contains
// special effect object to the timer.
//
function cmTimeEffect (menuID, show, delayTime)
{
        window.setTimeout ('cmCallEffect("' + menuID + '",' + show + ')', delayTime);
}

//
// A special effect function.  Called by timer.
//
function cmCallEffect (menuID, show)
{
        var menu = cmGetObject (menuID);
        if (!menu || !menu.cmEffect)
                return;
        try
        {
                if (show)
                        menu.cmEffect.showEffect (false);
                else
                        menu.cmEffect.hideEffect (false);
        }
        catch (e)
        {
        }
}

//
// return true if this item is handled using default handlers
//
function cmIsDefaultItem (item)
{
        if (item == _cmSplit || item[0] == _cmNoAction || item[0] == _cmNoClick)
                return false;
        return true;
}

//
// returns the object baring the id
//
function cmGetObject (id)
{
        if (document.all)
                return document.all[id];
        return document.getElementById (id);
}

//
// functions that obtain the width of an HTML element.
//
function cmGetWidth (obj)
{
        var width = obj.offsetWidth;
        if (width > 0 || !cmIsTRNode (obj))
                return width;
        if (!obj.firstChild)
                return 0;
        // use TABLE's length can cause an extra pixel gap
        //return obj.parentNode.parentNode.offsetWidth;

        // use the left and right child instead
        return obj.lastChild.offsetLeft - obj.firstChild.offsetLeft + cmGetWidth (obj.lastChild);
}

//
// functions that obtain the height of an HTML element.
//
function cmGetHeight (obj)
{
        var height = obj.offsetHeight;
        if (height > 0 || !cmIsTRNode (obj))
                return height;
        if (!obj.firstChild)
                return 0;
        // use the first child's height
        return obj.firstChild.offsetHeight;
}

//
// functions that obtain the coordinates of an HTML element
//
function cmGetX (obj)
{
        if (!obj)
                return 0;
        var x = 0;

        do
        {
                x += obj.offsetLeft;
                obj = obj.offsetParent;
        }
        while (obj);
        return x;
}

function cmGetXAt (obj, elm)
{
        var x = 0;

        while (obj && obj != elm)
        {
                x += obj.offsetLeft;
                obj = obj.offsetParent;
        }
        if (obj == elm)
                return x;
        return x - cmGetX (elm);
}

function cmGetY (obj)
{
        if (!obj)
                return 0;
        var y = 0;
        do
        {
                y += obj.offsetTop;
                obj = obj.offsetParent;
        }
        while (obj);
        return y;
}

function cmIsTRNode (obj)
{
        var tagName = obj.tagName;
        return tagName == "TR" || tagName == "tr" || tagName == "Tr" || tagName == "tR";
}

//
// get the Y position of the object.  In case of TR element though,
// we attempt to adjust the value.
//
function cmGetYAt (obj, elm)
{
        var y = 0;

        if (!obj.offsetHeight && cmIsTRNode (obj))
        {
                var firstTR = obj.parentNode.firstChild;
                obj = obj.firstChild;
                y -= firstTR.firstChild.offsetTop;
        }

        while (obj && obj != elm)
        {
                y += obj.offsetTop;
                obj = obj.offsetParent;
        }

        if (obj == elm)
                return y;
        return y - cmGetY (elm);
}

//
// extract description from the menu item and set the status text
//
function cmSetStatus (item)
{
        var descript = '';
        if (item.length > 4)
                descript = (item[4] != null) ? item[4] : (item[2] ? item[2] : descript);
        else if (item.length > 2)
                descript = (item[2] ? item[2] : descript);

        window.defaultStatus = descript;
}

//
// debug function, ignore :)
//
function cmGetProperties (obj)
{
        if (obj == undefined)
                return 'undefined';
        if (obj == null)
                return 'null';

        var msg = obj + ':\n';
        var i;
        for (i in obj)
                msg += i + ' = ' + obj[i] + '; ';
        return msg;
}


var cmThemeIEBase = '../img/';

// the follow block allows user to re-define theme base directory
// before it is loaded.
try
{
        if (myThemeIEBase)
        {
                cmThemeIEBase = myThemeIEBase;
        }
}
catch (e)
{
}

var cmThemeIE =
{
        prefix:        'ThemeIE',
          // main menu display attributes
          //
          // Note.  When the menu bar is horizontal,
          // mainFolderLeft and mainFolderRight are
          // put in <span></span>.  When the menu
          // bar is vertical, they would be put in
          // a separate TD cell.

          // HTML code to the left of the folder item
          mainFolderLeft: '',
          // HTML code to the right of the folder item
          mainFolderRight: '',
        // HTML code to the left of the regular item
        mainItemLeft: '',
        // HTML code to the right of the regular item
        mainItemRight: '',

        // sub menu display attributes
        // HTML code to the left of the folder item
        folderLeft: '',
        // HTML code to the right of the folder item
        folderRight: '&nbsp;',
        // HTML code to the left of the regular item
        itemLeft: '',
        // HTML code to the right of the regular item
        itemRight: '',
        // cell spacing for main menu
        mainSpacing: 0,
        // cell spacing for sub menus
        subSpacing: 0,
        // auto dispear time for submenus in milli-seconds
        delay: 100,

        subMenuHeader: '<div class="ThemeIESubMenuShadow"></div><div class="ThemeIESubMenuBorder">',
        subMenuFooter: '</div>',

        // adjust sub menu positions
        offsetSubAdjust:        [-4, -3]
        // rest use default settins
};

// horizontal split, used only in sub menus
var cmThemeIEHSplit = [_cmNoClick, '<td colspan="3" class="ThemeIEMenuSplit"><div class="ThemeIEMenuSplit"></div></td>'];
// horizontal split, used only in main menu
var cmThemeIEMainHSplit = [_cmNoClick, '<td colspan="3" class="ThemeIEMenuSplit"><div class="ThemeIEMenuSplit"></div></td>'];
// vertical split, used only in main menu
var cmThemeIEMainVSplit = [_cmNoClick, '<div class="ThemeIEMenuVSplit">|</div>'];

/* IE can't do negative margin on tables */
/*@cc_on
        cmThemeIE.subMenuHeader = '<div class="ThemeIESubMenuShadow" style="background-color: #7f7f7f;filter: alpha(opacity=50);"></div><div class="ThemeIESubMenuBorder">';
@*/