<p>(function() {
var Constants = {
 MIIdSuffix: "_DXI",
 MMIdSuffix: "_DXM",
 SBIdSuffix: "_DXSB",
 SBUIdEnd: "_U",
 SBDIdEnd: "_D",
 ATSIdSuffix: "_ATS",
 SampleCssClassNameForImageElement: "SAMPLE_CSS_CLASS",
 ImagePostfix: "Img",
 PopupImagePostfix: "PImg"
};
var MenuItemInfo = ASPx.CreateClass(null, {
 constructor: function(menu, indexPath) {
  var itemElement = menu.GetItemElement(indexPath);
  this.clientHeight = itemElement.clientHeight;
  this.clientWidth = itemElement.clientWidth;
  this.clientTop = ASPx.GetClientTop(itemElement);
  this.clientLeft = ASPx.GetClientLeft(itemElement);
  this.offsetHeight = itemElement.offsetHeight;
  this.offsetWidth = itemElement.offsetWidth;
  this.offsetTop = 0;
  this.offsetLeft = 0;
 }
});
var MenuCssClasses = {};
MenuCssClasses.Prefix = "dxm-";
MenuCssClasses.Menu = "dxmLite";
MenuCssClasses.BorderCorrector = "dxmBrdCor";
MenuCssClasses.Disabled = MenuCssClasses.Prefix + "disabled";
MenuCssClasses.MainMenu = MenuCssClasses.Prefix + "main";
MenuCssClasses.PopupMenu = MenuCssClasses.Prefix + "popup";
MenuCssClasses.ItemTemplate = MenuCssClasses.Prefix + "tmpl";
MenuCssClasses.HorizontalMenu = MenuCssClasses.Prefix + "horizontal";
MenuCssClasses.VerticalMenu = MenuCssClasses.Prefix + "vertical";
MenuCssClasses.NoWrapMenu = MenuCssClasses.Prefix + "noWrap";
MenuCssClasses.AutoWidthMenu = MenuCssClasses.Prefix + "autoWidth";
MenuCssClasses.DX = "dx";
MenuCssClasses.Separator = MenuCssClasses.Prefix + "separator";
MenuCssClasses.Spacing = MenuCssClasses.Prefix + "spacing";
MenuCssClasses.Gutter = MenuCssClasses.Prefix + "gutter";
MenuCssClasses.WithoutImages = MenuCssClasses.Prefix + "noImages";
MenuCssClasses.Item = MenuCssClasses.Prefix + "item";
MenuCssClasses.ItemHovered = MenuCssClasses.Prefix + "hovered";
MenuCssClasses.ItemSelected = MenuCssClasses.Prefix + "selected";
MenuCssClasses.ItemChecked = MenuCssClasses.Prefix + "checked";
MenuCssClasses.ItemWithoutImage = MenuCssClasses.Prefix + "noImage";
MenuCssClasses.ItemWithSubMenu = MenuCssClasses.Prefix + "subMenu";
MenuCssClasses.ItemDropDownMode = MenuCssClasses.Prefix + "dropDownMode";
MenuCssClasses.ItemWithoutSubMenu = MenuCssClasses.Prefix + "noSubMenu"; 
MenuCssClasses.AdaptiveMenuItem = MenuCssClasses.Prefix + "ami";
MenuCssClasses.AdaptiveMenuItemSpacing = MenuCssClasses.Prefix + "amis";
MenuCssClasses.AdaptiveMenu = MenuCssClasses.Prefix + "am";
MenuCssClasses.AdaptiveMenuHiddenElement = MenuCssClasses.Prefix + "amhe";
MenuCssClasses.ContentContainer = MenuCssClasses.Prefix + "content";
MenuCssClasses.Image = MenuCssClasses.Prefix + "image";
MenuCssClasses.PopOutContainer = MenuCssClasses.Prefix + "popOut";
MenuCssClasses.PopOutImage = MenuCssClasses.Prefix + "pImage";
MenuCssClasses.ImageLeft = MenuCssClasses.Prefix + "image-l";
MenuCssClasses.ImageRight = MenuCssClasses.Prefix + "image-r";
MenuCssClasses.ImageTop = MenuCssClasses.Prefix + "image-t";
MenuCssClasses.ImageBottom = MenuCssClasses.Prefix + "image-b";
MenuCssClasses.ScrollArea = MenuCssClasses.Prefix + "scrollArea";
MenuCssClasses.ScrollUpButton = MenuCssClasses.Prefix + "scrollUpBtn";
MenuCssClasses.ScrollDownButton = MenuCssClasses.Prefix + "scrollDownBtn";
MenuCssClasses.ItemClearElement = MenuCssClasses.DX + "-clear";
MenuCssClasses.ItemTextElement = MenuCssClasses.DX + "-vam";
var MenuRenderHelper = ASPx.CreateClass(null, {
 constructor: function(menu) {
  this.menu = menu;
  this.itemLinkMode = "ContentBounds";
  this.elementsToHide = [];
 },
 InlineInitializeElements: function() {
  if(!this.menu.isPopupMenu)
   this.InlineInitializeMainMenuElements(this.menu.GetMainElement());
  else
   this.InlineInitializePopupMenuElements(this.menu.GetMainElement());
  var popupMenuElements = this.GetPopupMenuElements(this.menu.GetMainElement());
  for(var i = 0; i &lt; popupMenuElements.length; i++) {
   if(popupMenuElements[i] == this.menu.GetMainElement()) continue;
   this.InlineInitializePopupMenuElements(popupMenuElements[i]);
  }
 },
 InlineInitializeScrollElements: function(indexPath, menuElement) {
  var scrollArea = ASPx.GetNodeByClassName(menuElement, MenuCssClasses.ScrollArea);
  if(scrollArea) scrollArea.id = this.menu.GetScrollAreaId(indexPath);
  var scrollUpButton = ASPx.GetNodeByClassName(menuElement, MenuCssClasses.ScrollUpButton);
  if(scrollUpButton) {
   scrollUpButton.id = this.menu.GetScrollUpButtonId(indexPath);
   if(this.menu.NeedCreateItemsOnClientSide())
    ASPx.GetStateController().AddHoverItem(scrollUpButton.id, ["dxm-scrollBtnHovered"], [""]);
  }
  var scrollDownButton = ASPx.GetNodeByClassName(menuElement, MenuCssClasses.ScrollDownButton);
  if(scrollDownButton) {
   scrollDownButton.id = this.menu.GetScrollDownButtonId(indexPath);
   if(this.menu.NeedCreateItemsOnClientSide())
    ASPx.GetStateController().AddHoverItem(scrollDownButton.id, ["dxm-scrollBtnHovered"], [""]);
  }
 },
 InlineInitializeMainMenuElements: function(menuElement) {
  this.menu.CheckElementsCache(menuElement);
  var contentElement = this.GetContentElement(menuElement);
  if(contentElement.className.indexOf("dxm-ti") &gt; 1)
   this.itemLinkMode = "TextAndImage";
  else if(contentElement.className.indexOf("dxm-t") &gt; -1)
   this.itemLinkMode = "TextOnly";
  var itemElements = this.GetItemElements(menuElement);
  for(var i = 0; i &lt; itemElements.length; i++)
   this.InlineInitializeItemElement(itemElements[i], "", i);
  this.InlineInitializeScrollElements("", menuElement);
 },
 InlineInitializePopupMenuElements: function(parentElement) {
  parentElement.style.position = "absolute";
  var indexPath = this.GetSubMenuIndexPathByMenuParentElement(parentElement);
  var borderCorrectorElement = ASPx.GetNodeByClassName(parentElement, MenuCssClasses.BorderCorrector);
  if(borderCorrectorElement != null) {
   borderCorrectorElement.id = this.menu.GetMenuBorderCorrectorElementId(indexPath);
   borderCorrectorElement.style.position = "absolute";
   parentElement.removeChild(borderCorrectorElement);
   parentElement.parentNode.appendChild(borderCorrectorElement);
  }
  this.InlineInitializePopupMenuMenuElement(parentElement, indexPath);
 },
 GetSubMenuIndexPathByMenuParentElement: function(element){
  return this.menu.GetMenuIndexPathById(element.id);
 },
 InlineInitializePopupMenuMenuElement: function(parentElement, indexPath) {
  var menuElement = ASPx.GetNodeByClassName(parentElement, MenuCssClasses.PopupMenu);
  menuElement.id = this.menu.GetMenuMainElementId(indexPath);
  this.InlineInitializePopupMenuContentElements(parentElement, menuElement, indexPath);
 },
 InlineInitializePopupMenuContentElements: function(parentElement, menuElement, indexPath) {
  this.menu.CheckElementsCache(menuElement);
  var contentElement = this.GetContentElement(menuElement);
  if(contentElement != null) {
   var itemElements = this.GetItemElements(menuElement);
   var parentIndexPath = parentElement == this.menu.GetMainElement() ? "" : indexPath;
   for(var i = 0; i &lt; itemElements.length; i++) {
    var itemElementId = itemElements[i].id;
    if(itemElementId & aspxGetMenuCollection().GetMenu(itemElementId) != this.menu)
     continue;
    this.InlineInitializeItemElement(itemElements[i], parentIndexPath, i);
   }
  }
  this.InlineInitializeScrollElements(indexPath, menuElement);
 },
 HasSubMenuTemplate: function(menuElement) {
  var contentElement = this.GetContentElement(menuElement);
  return contentElement & (contentElement.tagName != "UL" || !ASPx.GetNodesByPartialClassName(contentElement, MenuCssClasses.ContentContainer).length);
 },
 InlineInitializeItemElement: function(itemElement, parentIndexPath, visibleIndex) {
  function getItemIndex(visibleIndex) {
   var itemData = parentItemData[Math.max(visibleIndex, 0)];
   return itemData.constructor == Array
    ? itemData[0]
    : itemData;
  }
  var parentItemData = this.menu.renderData[parentIndexPath],
   prepareItemOnClick = parentItemData[visibleIndex].constructor == Array,
   indexPathPrefix = parentIndexPath + (parentIndexPath != "" ? ASPx.ItemIndexSeparator : ""),
   indexPath = indexPathPrefix + getItemIndex(visibleIndex),
   prevIndexPath = indexPathPrefix + getItemIndex(visibleIndex - 1);
  itemElement.id = this.menu.GetItemElementId(indexPath);
  ASPx.AssignAccessibilityEventsToChildrenLinks(itemElement, true);
  var separatorElement = itemElement.previousSibling;
  if(separatorElement & separatorElement.className) {
   if(ASPx.ElementContainsCssClass(separatorElement, MenuCssClasses.Spacing))
    separatorElement.id = this.menu.GetItemIndentElementId(indexPath);
   else if(ASPx.ElementContainsCssClass(separatorElement, MenuCssClasses.Separator))
    separatorElement.id = this.menu.GetItemSeparatorElementId(indexPath);
  }
  var contentElement = this.GetItemContentElement(itemElement);
  if(contentElement != null) {
   contentElement.id = this.menu.GetItemContentElementId(indexPath);
   var imageElement = ASPx.GetNodeByClassName(contentElement, MenuCssClasses.Image);
   if(imageElement == null) {
    var hyperLinkElement = ASPx.GetNodeByClassName(contentElement, MenuCssClasses.DX);
    if(hyperLinkElement != null)
     imageElement = ASPx.GetNodeByClassName(hyperLinkElement, MenuCssClasses.Image);
   }
   if(imageElement != null)
    imageElement.id = this.menu.GetItemImageId(indexPath);
  }
  else
   prepareItemOnClick = false;
  var popOutElement = this.GetItemPopOutElement(itemElement);
  if(popOutElement != null) {
   popOutElement.id = this.menu.GetItemPopOutElementId(indexPath);
   var popOutImageElement = ASPx.GetNodeByClassName(popOutElement, MenuCssClasses.PopOutImage);
   if(popOutImageElement != null)
    popOutImageElement.id = this.menu.GetItemPopOutImageId(indexPath);
  }
  if(prepareItemOnClick)
   this.InlineInitializeItemOnClick(itemElement, indexPath);
 },
 InlineInitializeItemOnClick: function(itemElement, indexPath) {
  var self = this;
  var menu = this.menu;
  var name = this.menu.name;
  var onclick = this.GetItemOnClick(name, itemElement, indexPath);
  if(this.menu.IsDropDownItem(indexPath)) {
   var contentElement = this.menu.GetItemContentElement(indexPath);
   var dropDownElement = this.menu.GetItemPopOutElement(indexPath);
   var dropDownOnclick = this.GetItemDropdownOnClick(name, itemElement, indexPath);
   this.AssignItemOnClickToElement(contentElement, this.itemLinkMode, onclick);
   this.AssignItemOnClickToElement(dropDownElement, this.itemLinkMode, dropDownOnclick);
  }
  else
   this.AssignItemOnClickToElement(itemElement, this.itemLinkMode, onclick);
 },
 AssignItemOnClickToElement: function(element, itemLinkMode, method) {
  switch(itemLinkMode){
   case "ContentBounds":
    ASPx.Evt.AttachEventToElement(element, "click", method);
    break;
   case "TextOnly":
    var textElement = ASPx.GetNodeByTagName(element, "A");
    if(!textElement)
     textElement = ASPx.GetNodeByTagName(element, "SPAN");
    if(textElement)
     ASPx.Evt.AttachEventToElement(textElement, "click", method);
    break;
   case "TextAndImage":
    var linkElement = ASPx.GetNodeByTagName(element, "A");
    if(linkElement)
     ASPx.Evt.AttachEventToElement(linkElement, "click", method);
    else{
     var textElement = ASPx.GetNodeByTagName(element, "SPAN");
     if(textElement)
      ASPx.Evt.AttachEventToElement(textElement, "click", method);
     var imageElement = ASPx.GetNodeByTagName(element, "IMG");
     if(imageElement)
      ASPx.Evt.AttachEventToElement(imageElement, "click", method);
    }
    break;
  }
 },
 GetItemOnClick: function(name, itemElement, indexPath) { 
  var menu = this.menu;
  var sendPostBackHandler = function() {
   menu.SendPostBack("CLICK:" + indexPath);
  };
  var itemClickHandler = function(e) {
   ASPx.MIClick(e, name, indexPath);
  };
  var itemLink = ASPx.GetNodeByTagName(itemElement, "A");
  var handler = menu.autoPostBack & !menu.IsClientSideEventsAssigned() && (!itemLink || itemLink.href === "")
   ? sendPostBackHandler
   : itemClickHandler;
  return function(e) {
   if(!itemElement.clientDisabled)
    handler(e);
  };
 },
 GetItemDropdownOnClick: function(name, itemElement, indexPath) {
  return function(e) {
   if(!itemElement.clientDisabled)
    ASPx.MIDDClick(e, name, indexPath);
  };
 },
 ChangeItemEnabledAttributes: function(itemElement, enabled, accessibilityCompliant) {
  if(!itemElement) return;
  itemElement.clientDisabled = !enabled;
  ASPx.Attr.ChangeStyleAttributesMethod(enabled)(itemElement, "cursor");
  var hyperLink = ASPx.GetNodeByTagName(itemElement, "A");
  if(hyperLink) {
   if(accessibilityCompliant) {
    var action = enabled ? ASPx.Attr.RemoveAttribute : ASPx.Attr.SetAttribute;
    action(hyperLink, "aria-disabled", "true");
   }
   ASPx.Attr.ChangeAttributesMethod(enabled)(hyperLink, "href");
   if(accessibilityCompliant & !enabled && itemElement.enabled)
    hyperLink.href = ASPx.AccessibilityEmptyUrl;
  }
 },
 GetPopupMenuElements: function(menuElement) {
 return ASPx.GetChildNodesByTagName(menuElement.parentNode, "DIV");
 },
 GetContentElement: function(menuElement) {
  return ASPx.CacheHelper.GetCachedElement(this, "contentElement", 
   function() {
    var contentElement = ASPx.GetNodeByTagName(menuElement, "DIV", 0);
    if(contentElement & contentElement.className == MenuCssClasses.DX && contentElement.parentNode == menuElement) 
     return contentElement;
    contentElement = ASPx.GetNodeByTagName(menuElement, "UL", 0);
    if(contentElement)
     return contentElement;
    return ASPx.GetNodeByTagName(menuElement, "TABLE", 0); 
   }, menuElement);
 },
 GetItemElements: function(menuElement) {
  return ASPx.CacheHelper.GetCachedElements(this, "itemElements", 
   function() {
    var contentElement = this.GetContentElement(menuElement);
    return contentElement ? ASPx.GetNodesByClassName(contentElement, MenuCssClasses.Item) : null;
   }, menuElement);
 },
 GetSpacingElements: function(menuElement) {
  return ASPx.CacheHelper.GetCachedElements(this, "spacingElements", 
   function() {
    var contentElement = this.GetContentElement(menuElement);
    return contentElement ? ASPx.GetNodesByClassName(contentElement, MenuCssClasses.Spacing) : null;
   }, menuElement);
 },
 GetSeparatorElements: function(menuElement) {
  return ASPx.CacheHelper.GetCachedElements(this, "separatorElements", 
   function() {
    var contentElement = this.GetContentElement(menuElement);
    return contentElement ? ASPx.GetNodesByClassName(contentElement, MenuCssClasses.Separator) : null;
   }, menuElement);
 },
 GetItemContentElement: function(itemElement) {
  return ASPx.CacheHelper.GetCachedElement(this, "contentElement", 
   function() {
    return ASPx.GetNodeByClassName(itemElement, MenuCssClasses.ContentContainer);
   }, itemElement);
 },
 GetItemPopOutElement: function(itemElement) {
  return ASPx.CacheHelper.GetCachedElement(this, "popOutElement", 
   function() {
    return ASPx.GetNodeByClassName(itemElement, MenuCssClasses.PopOutContainer);
   }, itemElement);
 },
 GetAdaptiveMenuItemElement: function(menuElement) {
  return ASPx.CacheHelper.GetCachedElement(this, "adaptiveMenuItemElement", 
   function() {
    var contentElement = this.GetContentElement(menuElement);
    return contentElement ? ASPx.GetNodeByClassName(contentElement, MenuCssClasses.AdaptiveMenuItem) : null;
   }, menuElement);
 },
 GetAdaptiveMenuItemSpacingElement: function(menuElement) {
  return ASPx.CacheHelper.GetCachedElement(this, "adaptiveMenuItemSpacingElement", 
   function() {
    var contentElement = this.GetContentElement(menuElement);
    return contentElement ? ASPx.GetNodeByClassName(contentElement, MenuCssClasses.AdaptiveMenuItemSpacing) : null;
   }, menuElement);
 },
 GetAdaptiveMenuElement: function(menuElement) {
  return ASPx.CacheHelper.GetCachedElement(this, "adaptiveMenuElement", 
   function() {
    var adaptiveItemElement = this.GetAdaptiveMenuItemElement(menuElement);
    if(adaptiveItemElement){
     var adaptiveItemIndexPath = this.menu.GetIndexPathById(adaptiveItemElement.id);
     var adaptiveMenuParentElement = this.menu.GetMenuElement(adaptiveItemIndexPath);
     if(adaptiveMenuParentElement) 
      return this.menu.GetMenuMainElement(adaptiveMenuParentElement);
    }
    return null;
   }, menuElement);
 },
 GetAdaptiveMenuContentElement: function(menuElement) {
  return ASPx.CacheHelper.GetCachedElement(this, "adaptiveMenuContentElement", 
   function() {
    var adaptiveMenuElement = this.GetAdaptiveMenuElement(menuElement);
    return adaptiveMenuElement ? this.GetContentElement(adaptiveMenuElement) : null;
   }, menuElement);
 },
 CalculateMenuControl: function(menuElement, recalculate) {
  if(menuElement.offsetWidth === 0) return;
  this.PrecalculateMenuPopOuts(menuElement);
  var isVertical = this.menu.IsVertical("");
  var isAutoWidth = ASPx.ElementContainsCssClass(menuElement, MenuCssClasses.AutoWidthMenu);
  var isNoWrap = ASPx.ElementContainsCssClass(menuElement, MenuCssClasses.NoWrapMenu);
  var contentElement = this.GetContentElement(menuElement);
  if(this.menu.enableAdaptivity) 
   this.CalculateAdaptiveMainMenu(menuElement, contentElement, isVertical, isAutoWidth, isNoWrap, recalculate);
  else
   this.CalculateMainMenu(menuElement, contentElement, isVertical, isAutoWidth, isNoWrap, recalculate);
 },
 CalculateMainMenu: function(menuElement, contentElement, isVertical, isAutoWidth, isNoWrap, recalculate) {
  var itemElements = this.GetItemElements(menuElement);
  this.PrecalculateMenuItems(menuElement, itemElements, recalculate);
  this.CalculateMenuItemsAutoWidth(menuElement, itemElements, isVertical, isAutoWidth);
  this.CalculateMinSize(menuElement, contentElement, itemElements, isVertical, isAutoWidth, isNoWrap, recalculate);
  this.CalculateMenuItems(menuElement, contentElement, itemElements, isVertical, recalculate);
  this.CalculateSeparatorsAndSpacers(menuElement, itemElements, contentElement, isVertical);
 },
 PrecalculateMenuPopOuts: function(menuElement) {
  if(menuElement.popOutsPreCalculated) return;
  var elements = this.GetItemElements(menuElement);
  for(var i = 0; i &lt; elements.length; i++) {
   var popOutElement = this.GetItemPopOutElement(elements[i]);
   if(popOutElement) popOutElement.style.display = "block";
  }
  menuElement.popOutsPreCalculated = true;
 },
 PrecalculateMenuItems: function(menuElement, itemElements, recalculate) {
  if(!recalculate) return;
  for(var i = 0; i &lt; itemElements.length; i++) {
   var itemContentElement = this.GetItemContentElement(itemElements[i]);
   if(!itemContentElement || itemContentElement.offsetWidth === 0) continue;
   ASPx.SetElementFloat(itemContentElement, "");
   ASPx.Attr.RestoreStyleAttribute(itemContentElement, "padding-left");
   ASPx.Attr.RestoreStyleAttribute(itemContentElement, "padding-right");
     this.ReCalculateMenuItemContent(itemElements[i], itemContentElement);
  }
 },
 ReCalculateMenuItemContent: function(itemElement, itemContentElement) {
  for(var j = 0; j &lt; itemElement.childNodes.length; j++) {
   var child = itemElement.childNodes[j];
   if(!child.offsetWidth) continue;
   if(child !== itemContentElement) {
    if(ASPx.Browser.IE & ASPx.Browser.Version == 8)
     ASPx.Attr.RestoreStyleAttribute(child, "margin");
    else{
     ASPx.Attr.RestoreStyleAttribute(child, "margin-top");
     ASPx.Attr.RestoreStyleAttribute(child, "margin-bottom");
    }
   }
  }
 },
 CalculateMenuItemsAutoWidth: function(menuElement, itemElements, isVertical, isAutoWidth) {
  if(!isAutoWidth) return;
  for(var i = 0; i &lt; itemElements.length; i++) 
   ASPx.Attr.RestoreStyleAttribute(itemElements[i], "width");
  if(!isVertical) {
   var autoWidthItemCount = 0;
   for(var i = 0; i &lt; itemElements.length; i++) {
    if(ASPx.GetElementDisplay(itemElements[i]) & !ASPx.ElementHasCssClass(itemElements[i], MenuCssClasses.AdaptiveMenuItem))
     autoWidthItemCount++;
   }
   for(var i = 0; i &lt; itemElements.length; i++) {
    if(autoWidthItemCount &gt; 0 & !ASPx.ElementHasCssClass(itemElements[i], MenuCssClasses.AdaptiveMenuItem) && (itemElements[i].style.width === "" || itemElements[i].autoWidth)) { 
     ASPx.Attr.ChangeStyleAttribute(itemElements[i], "width", (100 / autoWidthItemCount) + "%");
     itemElements[i].autoWidth = true;
    }
   }
  }
 },
 CalculateMenuItems: function(menuElement, contentElement, itemElements, isVertical, recalculate) {
  if(contentElement.itemsCalculated & recalculate)
   contentElement.itemsCalculated = false;
  if(menuElement.offsetWidth === 0) return;
  if(contentElement.style.margin === "0px auto")
   ASPx.SetStyles(contentElement, { float: "none" }); 
  var menuWidth = ASPx.GetCurrentStyle(menuElement).width;
  var menuRequireItemCorrection = isVertical & menuWidth;
  for(var i = 0; i &lt; itemElements.length; i++) {
   if(!itemElements[i].style.width & !menuRequireItemCorrection) continue;
   if(ASPx.IsPercentageSize(itemElements[i].style.width) & contentElement.style.width === "")
    contentElement.style.width = "100%"; 
   var itemContentElement = this.GetItemContentElement(itemElements[i]);
   if(!itemContentElement || itemContentElement.offsetWidth === 0) continue;
   if(!contentElement.itemsCalculated) {
    ASPx.Attr.RestoreStyleAttribute(itemContentElement, "padding-left");
    ASPx.Attr.RestoreStyleAttribute(itemContentElement, "padding-right");
    ASPx.SetElementFloat(itemContentElement, "none");
    var itemContentCurrentStyle = ASPx.GetCurrentStyle(itemContentElement);
    if(!isVertical || (itemContentCurrentStyle.textAlign != "center" & menuWidth)) {
     var originalPaddingLeft = parseInt(itemContentCurrentStyle.paddingLeft);
     var originalPaddingRight = parseInt(itemContentCurrentStyle.paddingRight);
     var leftChildrenWidth = 0, rightChildrenWidth = 0;
     for(var j = 0; j &lt; itemElements[i].childNodes.length; j++) {
      var child = itemElements[i].childNodes[j];
      if(!child.offsetWidth) continue;
      if(child !== itemContentElement) {
       if(ASPx.GetElementFloat(child) === "right")
        rightChildrenWidth += child.offsetWidth + ASPx.GetLeftRightMargins(child);
       else if(ASPx.GetElementFloat(child) === "left")
        leftChildrenWidth += child.offsetWidth + ASPx.GetLeftRightMargins(child);
      }
     }
     if(leftChildrenWidth &gt; 0 || rightChildrenWidth &gt; 0){
      ASPx.Attr.ChangeStyleAttribute(itemContentElement, "padding-left", (leftChildrenWidth + originalPaddingLeft) + "px");
      ASPx.Attr.ChangeStyleAttribute(itemContentElement, "padding-right", (rightChildrenWidth + originalPaddingRight) + "px");
     }
    }
   }
   ASPx.AdjustWrappedTextInContainer(itemContentElement);
   this.CalculateMenuItemContent(itemElements[i], itemContentElement);
  }
  contentElement.itemsCalculated = true;
 },
 CalculateMenuItemContent: function(itemElement, itemContentElement) {
  var itemContentFound = false;
  for(var j = 0; j &lt; itemElement.childNodes.length; j++) {
   var child = itemElement.childNodes[j];
   if(!child.offsetWidth) continue;
   var contentHeight = itemContentElement.offsetHeight;
   if(child !== itemContentElement) {
    if(itemContentFound){
     if(ASPx.Browser.IE & ASPx.Browser.Version == 8)
      ASPx.Attr.ChangeStyleAttribute(child, "margin", "-" + contentHeight + "px 0 0");
     else
      ASPx.Attr.ChangeStyleAttribute(child, "margin-top", "-" + contentHeight + "px");
    }
    else{
     if(ASPx.Browser.IE & ASPx.Browser.Version == 8)
      ASPx.Attr.ChangeStyleAttribute(child, "margin", "0 0 -" + contentHeight + "px");
     else
      ASPx.Attr.ChangeStyleAttribute(child, "margin-bottom", "-" + contentHeight + "px");
    }
   }
   else
    itemContentFound = true;
  }
 },
 CalculateSubMenu: function(parentElement, recalculate) {
  var menuElement = this.menu.GetMenuMainElement(parentElement);
  var contentElement = this.GetContentElement(menuElement);
  if(!parentElement.isSubMenuCalculated || recalculate) {
   menuElement.style.width = "";
   menuElement.style.display = "table";
   menuElement.style.borderSpacing = "0px";
   parentElement.isSubMenuCalculated = true;
   if(contentElement.tagName === "UL") {
    if(contentElement.offsetWidth &gt; 0) {
     if(ASPx.Browser.IE & ASPx.ElementHasCssClass(menuElement, MenuCssClasses.AdaptiveMenu))
      menuElement.style.width = "0px";
     menuElement.style.width = contentElement.offsetWidth + "px";
     menuElement.style.display = "";
     if(ASPx.IsPercentageSize(contentElement.style.width))
      contentElement.style.width = menuElement.style.width;
    }
    else
     parentElement.isSubMenuCalculated = false;
   }
  }
  this.CalculateSubMenuItems(menuElement, contentElement, recalculate);
 },
 CalculateSubMenuItems: function(menuElement, contentElement, recalculate) {
  var itemElements = this.GetItemElements(menuElement);
  this.PrecalculateMenuItems(menuElement, itemElements, recalculate);
  this.CalculateMenuItems(menuElement, contentElement, itemElements, true, recalculate);
 },
 CalculateMinSize: function(menuElement, contentElement, itemElements, isVertical, isAutoWidth, isNoWrap, recalculate) {
  if(menuElement.isMinSizeCalculated & !recalculate) return;
  if(isVertical) {
   menuElement.style.minWidth = "";
   ASPx.Attr.ChangeStyleAttribute(contentElement, "width", "1px");
   for(var i = 0; i &lt; itemElements.length; i++) {
    var itemContentElement = this.GetItemContentElement(itemElements[i]);
    if(!itemContentElement || itemElements[i].offsetWidth === 0) continue;
    this.CalculateItemMinSize(itemElements[i], recalculate);
   }
   ASPx.Attr.RestoreStyleAttribute(contentElement, "width");
  }
  else {
   ASPx.RemoveClassNameFromElement(menuElement, MenuCssClasses.NoWrapMenu);
   ASPx.RemoveClassNameFromElement(menuElement, MenuCssClasses.AutoWidthMenu);
   ASPx.Attr.ChangeStyleAttribute(menuElement, "width", "1px");
   for(var i = 0; i &lt; itemElements.length; i++) {
    var itemContentElement = this.GetItemContentElement(itemElements[i]);
    if((!itemContentElement || itemElements[i].offsetWidth === 0) & !ASPx.ElementHasCssClass(itemElements[i], MenuCssClasses.ItemTemplate)) continue;
    var textContainer = ASPx.GetNodeByTagName(itemContentElement, "SPAN", 0);
    if(textContainer & ASPx.GetCurrentStyle(textContainer).whiteSpace !== "nowrap")
     ASPx.AdjustWrappedTextInContainer(itemContentElement);
    this.CalculateItemMinSize(itemElements[i], recalculate);
   }
   if(isAutoWidth)
    ASPx.AddClassNameToElement(menuElement, MenuCssClasses.AutoWidthMenu);
   if(isNoWrap)
    ASPx.AddClassNameToElement(menuElement, MenuCssClasses.NoWrapMenu);
   if(isAutoWidth || isNoWrap)
    menuElement.style.minWidth = (contentElement.offsetWidth + ASPx.GetLeftRightBordersAndPaddingsSummaryValue(menuElement)) + "px";
   ASPx.Attr.RestoreStyleAttribute(menuElement, "width");
  }
  menuElement.isMinSizeCalculated = true;
 },
 CalculateItemMinSize: function(itemElement, recalculate) {
  if(itemElement.isMinSizeCalculated & !recalculate) return;
  var sizeCorrection = ASPx.Browser.HardwareAcceleration ? 1 : 0;
  itemElement.style.minWidth = "";
  var childrenWidth = 0;
  if(ASPx.ElementHasCssClass(itemElement, MenuCssClasses.ItemTemplate)) {
   ASPx.Attr.ChangeStyleAttribute(itemElement, "display", "table");
   childrenWidth += itemElement.clientWidth + sizeCorrection;
   ASPx.Attr.RestoreStyleAttribute(itemElement, "display");
  } 
  else {
   for(var j = 0; j &lt; itemElement.childNodes.length; j++) {
    var child = itemElement.childNodes[j];
    if(!child.offsetWidth) continue;
    var float = ASPx.GetElementFloat(child);
    if(float === "none") {
     childrenWidth = child.offsetWidth;
     break;
    }
    else
     childrenWidth += child.offsetWidth + sizeCorrection;
   }
  }
  itemElement.style.minWidth = childrenWidth + "px";
  itemElement.isMinSizeCalculated = true;
 },
 CalculateSeparatorsAndSpacers: function(menuElement, itemElements, contentElement, isVertical, isAutoWidth, isNoWrap) {
  var spacerElements = this.GetSpacingElements(menuElement);
  var spacerAndSeparatorElements = spacerElements.concat(this.GetSeparatorElements(menuElement));
  for(var i = 0; i &lt; spacerAndSeparatorElements.length; i++)
   ASPx.Attr.RestoreStyleAttribute(spacerAndSeparatorElements[i], "height");
  if(!isVertical & itemElements) {
   var menuHeight = 0;
   if(!isAutoWidth & !isNoWrap) {
    for(var i=0; i &lt; itemElements.length; i++) {
     var newHeight = itemElements[i].offsetHeight;
     if(newHeight &gt; menuHeight)
      menuHeight = newHeight;
    }
   }
   for(var i = 0; i &lt; spacerAndSeparatorElements.length; i++){
    var separatorHeight = menuHeight - ASPx.GetTopBottomBordersAndPaddingsSummaryValue(spacerAndSeparatorElements[i]) - ASPx.GetTopBottomMargins(spacerAndSeparatorElements[i]);
    ASPx.Attr.ChangeStyleAttribute(spacerAndSeparatorElements[i], "height", separatorHeight + "px");
   }
   for(var i = 0; i &lt; spacerElements.length; i++){
    if(!ASPx.ElementContainsCssClass(spacerElements[i], MenuCssClasses.AdaptiveMenuItemSpacing))
     spacerElements[i].style.minWidth = spacerElements[i].style.width; 
   }
  }
 },
 CalculateAdaptiveMainMenu: function(menuElement, contentElement, isVertical, isAutoWidth, isNoWrap, recalculate) {
  var adaptiveItemElement = this.GetAdaptiveMenuItemElement(menuElement);
  if(!adaptiveItemElement) return;
  var adaptiveItemSpacing = this.GetAdaptiveMenuItemSpacingElement(menuElement);
  if(adaptiveItemSpacing) adaptiveItemSpacing.style.width = "";
  var adaptiveMenuElement = this.GetAdaptiveMenuElement(menuElement);
  if(!adaptiveMenuElement) return;
  var adaptiveMenuContentElement = this.GetAdaptiveMenuContentElement(menuElement);
  if(!contentElement.adaptiveInfo)
   this.InitAdaptiveInfo(contentElement);
  var wasAdaptivity = contentElement.adaptiveInfo.hasAdaptivity;
  if(wasAdaptivity)
   this.RestoreAdaptiveItems(adaptiveItemSpacing || adaptiveItemElement, contentElement, isVertical);
  if(!isVertical) {
   ASPx.SetElementDisplay(adaptiveItemElement, true);
   if(adaptiveItemSpacing) ASPx.SetElementDisplay(adaptiveItemSpacing, true);
   ASPx.RemoveClassNameFromElement(menuElement, MenuCssClasses.NoWrapMenu);
   menuElement.style.minWidth = "";
   var adaptiveItemWidth = adaptiveItemElement.offsetWidth;
   if(isAutoWidth) {
    ASPx.Attr.ChangeStyleAttribute(contentElement, "display", "none");
    ASPx.Attr.ChangeStyleAttribute(menuElement, "min-width", "");
   }
   var menuWidth = menuElement.offsetWidth - ASPx.GetLeftRightBordersAndPaddingsSummaryValue(menuElement) - adaptiveItemWidth;
   if(isAutoWidth) {
    ASPx.Attr.RestoreStyleAttribute(contentElement, "display");
    ASPx.Attr.RestoreStyleAttribute(menuElement, "min-width");
   }
   var additionalWidth = adaptiveItemWidth;
   if(adaptiveItemSpacing) {
    menuWidth -= adaptiveItemSpacing.offsetWidth;
    additionalWidth += adaptiveItemSpacing.offsetWidth;
   }
   var hasAdaptivity = this.HideAdaptiveItems(menuWidth, additionalWidth, contentElement, adaptiveMenuContentElement);
   contentElement.adaptiveInfo.hasAdaptivity = hasAdaptivity;
   ASPx.SetElementDisplay(adaptiveItemElement, hasAdaptivity);
   if(adaptiveItemSpacing) ASPx.SetElementDisplay(adaptiveItemSpacing, hasAdaptivity);
   contentElement.style.width = hasAdaptivity ? "100%" : "";
   if(hasAdaptivity){
    ASPx.CacheHelper.DropCache(adaptiveMenuElement);
    this.CalculateSubMenu(adaptiveMenuElement, true);
    this.CalculateSeparatorsAndSpacers(adaptiveMenuElement, null, adaptiveMenuContentElement, true);
   }
   if(isNoWrap) {
    ASPx.AddClassNameToElement(menuElement, MenuCssClasses.NoWrapMenu);
    if(adaptiveItemSpacing) adaptiveItemSpacing.style.width = hasAdaptivity ? "100%" : "";
   }
  }
  else {
   ASPx.SetElementDisplay(adaptiveItemElement, false);
   if(adaptiveItemSpacing) ASPx.SetElementDisplay(adaptiveItemSpacing, false);
  }
  if(wasAdaptivity || contentElement.adaptiveInfo.hasAdaptivity)
   ASPx.CacheHelper.DropCache(menuElement);
  this.CalculateMainMenu(menuElement, contentElement, isVertical, isAutoWidth, isNoWrap, wasAdaptivity || contentElement.adaptiveInfo.hasAdaptivity || recalculate);
 },
 InitAdaptiveInfo: function(contentElement) {
  if(contentElement.adaptiveInfo) return;
  contentElement.adaptiveInfo = { };
  contentElement.adaptiveInfo.elements = this.CreateAdaptiveElementsArray(contentElement);
  contentElement.adaptiveInfo.hasAdaptivity = false;
 },
 RestoreAdaptiveItems: function(previousSibling, contentElement, isVertical) {
  this.SetLastSeparatorsVisible(true, contentElement);
  for(var i = 0; i &lt; contentElement.adaptiveInfo.elements.length; i++) {
   var element = contentElement.adaptiveInfo.elements[i];
   if(ASPx.Browser.IE)
    ASPx.RemoveElement(element);
   var isReplacedIndent = !element.parent;
   if(isReplacedIndent)
    ASPx.RemoveElement(ASPx.GetElementById(element.id));
   contentElement.insertBefore(element, previousSibling);
   ASPx.Attr.RestoreStyleAttribute(element, "width");
   if(!isVertical)
    this.SetItemItemPopOutImageHorizontal(element);
   if(ASPx.ElementContainsCssClass(element, MenuCssClasses.Separator) || ASPx.ElementContainsCssClass(element, MenuCssClasses.Spacing))
    ASPx.RemoveClassNameFromElement(element, MenuCssClasses.AdaptiveMenuHiddenElement);
  }
  if(this.menu.GetRootItem()) {
   for(var i = this.elementsToHide.length - 1; i &gt;= 0; i--) {
    if(!this.elementsToHide[i]) continue;
    var indexPath = this.elementsToHide[i].indexPath;
    if(this.menu.GetItemByIndexPath(indexPath).GetVisible())
     this.menu.UpdateItemCssClasses(indexPath, true);
    this.elementsToHide[i] = null;
   }
  }
  this.elementsToHide = [];
 },
 SetLastSeparatorsVisible: function(isVisible, contentElement) {
  var elements = ASPx.GetChildElementNodes(contentElement);
  for(var i = 0; i &lt; elements.length; i++) {
   var element = elements[i];
   if(ASPx.ElementContainsCssClass(element, MenuCssClasses.Separator) || ASPx.ElementContainsCssClass(element, MenuCssClasses.Spacing))
    ASPx.RemoveClassNameFromElement(element, MenuCssClasses.AdaptiveMenuHiddenElement);
   else
    break;
  }
 },
 CreateAdaptiveElementsArray: function(contentElement) {
  var result = [];
  var elements = ASPx.GetChildElementNodes(contentElement);
  for(var i = 0; i &lt; elements.length; i++) {
   if(!ASPx.ElementHasCssClass(elements[i], MenuCssClasses.AdaptiveMenuItem) & !ASPx.ElementHasCssClass(elements[i], MenuCssClasses.AdaptiveMenuItemSpacing)) 
    result.push(elements[i]);
  }
  return result;
 },
 SetItemItemPopOutImageHorizontal: function(element) {
  var popOutElements = ASPx.GetNodesByPartialClassName(element, "dxWeb_mVerticalPopOut");
  for(var i = 0; i &lt; popOutElements.length; i++)
   popOutElements[i].className = popOutElements[i].className.replace("Vertical", "Horizontal");
 },
 CheckAdaptiveItemsWidth: function(contentElement, menuWidth, additionalWidth) {
  var itemsWidth = 0;
  var sizeCorrection = ASPx.Browser.HardwareAcceleration ? 1 : 0;
  var elements = ASPx.GetChildElementNodes(contentElement);
  for(var i = 0; i &lt; elements.length; i++) {
   var element = elements[i];
   if(!ASPx.ElementHasCssClass(element, MenuCssClasses.AdaptiveMenuItem) & 
    !ASPx.ElementHasCssClass(element, MenuCssClasses.AdaptiveMenuItemSpacing) && element.offsetWidth > 0) {
    if(element.style.minWidth !== "")
     itemsWidth += parseInt(element.style.minWidth) + ASPx.GetHorizontalBordersWidth(element);
    else
     itemsWidth += element.offsetWidth;
   }
   if(itemsWidth &gt; menuWidth + additionalWidth)
    return false;
  }
  return true;
 },
 HideAdaptiveItems: function(menuWidth, additionalWidth, contentElement, adaptiveMenuContentElement) {
  if(this.CheckAdaptiveItemsWidth(contentElement, menuWidth, additionalWidth))
   return false;
  this.elementsToHide = [];
  var elementsToHide = this.elementsToHide;
  var addToHide = function(index, indexPath, itemElement, separatorElement, indentElement, insteadSeparatorElement) {
   if(!itemElement) return;
   if(separatorElement & ASPx.ElementHasCssClass(separatorElement, MenuCssClasses.AdaptiveMenuItemSpacing))
    separatorElement = null;
   if(indentElement & ASPx.ElementHasCssClass(indentElement, MenuCssClasses.AdaptiveMenuItemSpacing))
    indentElement = null;
   elementsToHide[index] = { indexPath: indexPath, itemElement: itemElement, separatorElement: separatorElement, indentElement: indentElement, insteadSeparatorElement: insteadSeparatorElement };
   ASPx.Attr.ChangeStyleAttribute(itemElement, "display", "none");
   if(separatorElement) {
    var elementForHide = insteadSeparatorElement || separatorElement;
    ASPx.Attr.ChangeStyleAttribute(elementForHide, "display", "none");
   }
   if(indentElement)
    ASPx.Attr.ChangeStyleAttribute(indentElement, "display", "none");
  };
  for(var i = 0; i &lt; this.menu.adaptiveItemsOrder.length; i++){
   var indexPath = this.menu.adaptiveItemsOrder[i],
    index = parseInt(indexPath, 10),
    itemToKeepSeparator = this.menu.GetRootItem() ? this.GetItemForKeepSeparator(index) : null,
    insteadSeparatorElement = itemToKeepSeparator ? this.menu.GetItemIndentElement(itemToKeepSeparator.indexPath) : null;
   addToHide(index, indexPath, this.menu.GetItemElement(indexPath), this.menu.GetItemSeparatorElement(indexPath), this.menu.GetItemIndentElement(indexPath), insteadSeparatorElement);
   if(this.CheckAdaptiveItemsWidth(contentElement, menuWidth, 0))
    break;
  }
  var hasImages = false;
  for(var i = 0; i &lt; elementsToHide.length; i++) {
   if(!elementsToHide[i]) continue;
   ASPx.Attr.RestoreStyleAttribute(elementsToHide[i].itemElement, "display");
   if(elementsToHide[i].separatorElement) {
    var elementForRestore = elementsToHide[i].insteadSeparatorElement || elementsToHide[i].separatorElement;
    ASPx.Attr.RestoreStyleAttribute(elementForRestore, "display");
   }
   if(elementsToHide[i].indentElement)
    ASPx.Attr.RestoreStyleAttribute(elementsToHide[i].indentElement, "display");
   this.menu.UpdateItemCssClasses(elementsToHide[i].indexPath, false);
   if(elementsToHide[i].separatorElement) {
    if(this.menu.GetRootItem())
     this.KeepSeparatorInRoot(i);
    adaptiveMenuContentElement.appendChild(elementsToHide[i].separatorElement);
   }
   else if(this.menu.GetRootItem())
    this.InsertSeparatorInAdaptiveMenu(i, elementsToHide[i].indexPath);
   if(elementsToHide[i].indentElement)
    adaptiveMenuContentElement.appendChild(elementsToHide[i].indentElement);
   adaptiveMenuContentElement.appendChild(elementsToHide[i].itemElement);
   var popOutElement = ASPx.GetNodeByClassName(elementsToHide[i].itemElement, "dxm-popOut", 0),
    imageElement = ASPx.GetNodeByClassName(elementsToHide[i].itemElement, "dxm-pImage", 0);
   this.menu.ResetElementVerticalAligmentFlag(popOutElement);
   this.menu.ResetElementVerticalAligmentFlag(imageElement);
   ASPx.Attr.ChangeStyleAttribute(elementsToHide[i].itemElement, "width", "auto");
   if(ASPx.GetNodeByClassName(elementsToHide[i].itemElement, "dxm-image"))
    hasImages = true;
   this.SetItemPopOutImageVertical(elementsToHide[i].itemElement);
  }
  for(var i = 0; i &lt; elementsToHide.length; i++) {
   if(!elementsToHide[i]) continue;
   if(elementsToHide[i].separatorElement) 
    ASPx.AddClassNameToElement(elementsToHide[i].separatorElement, MenuCssClasses.AdaptiveMenuHiddenElement);
   if(elementsToHide[i].indentElement) 
    ASPx.AddClassNameToElement(elementsToHide[i].indentElement, MenuCssClasses.AdaptiveMenuHiddenElement);
   break;
  }
  this.SetLastSeparatorsVisible(false, contentElement);
  if(hasImages)
   ASPx.RemoveClassNameFromElement(adaptiveMenuContentElement, MenuCssClasses.WithoutImages);
  else
   ASPx.AddClassNameToElement(adaptiveMenuContentElement, MenuCssClasses.WithoutImages);
  return elementsToHide.length &gt; 0;
 },
 KeepSeparatorInRoot: function(index) {
  var nextItemInGroup = this.GetItemForKeepSeparator(index);
  if(nextItemInGroup) {
   var separatorElement = this.elementsToHide[index].separatorElement;
   this.ReplaceIndentElement(nextItemInGroup.indexPath, separatorElement);
  }
 },
 InsertSeparatorInAdaptiveMenu: function(index, indexPath) {
  var itemWithSeparator = this.GetItemWithSeparatorForAdaptiveMenu(index);
  if(itemWithSeparator) {
   var separatorElement = this.menu.GetItemSeparatorElement(itemWithSeparator.indexPath);
   if(!separatorElement) return;
   this.elementsToHide[index].indentElement = this.ReplaceIndentElement(indexPath, separatorElement);
  }
 },
 ReplaceIndentElement: function(indexPath, separatorElement) {
  var itemElement = this.menu.GetItemElement(indexPath),
   itemIndent = this.menu.GetItemIndentElement(indexPath),
   newIndentElement = separatorElement.cloneNode(true),
   parentNode = itemElement.parentNode;
  newIndentElement.id = this.menu.GetItemIndentElementId(indexPath);
  if(itemIndent)
   itemIndent.parentNode.removeChild(itemIndent);
  parentNode.insertBefore(newIndentElement, itemElement);
  return newIndentElement;
 },
 GetItemForKeepSeparator: function(index) {
  var rootItem = this.menu.GetRootItem(),
   nextItemInGroup = this.menu.GetNextVisibleItemInGroup(rootItem, index, true);
  if(nextItemInGroup & this.IsItemInAdaptiveMenu(nextItemInGroup.index)) {
   while(nextItemInGroup && this.IsItemInAdaptiveMenu(nextItemInGroup.index))
    nextItemInGroup = this.menu.GetNextVisibleItemInGroup(rootItem, nextItemInGroup.index, true);
  }
  return nextItemInGroup;
 },
 GetItemWithSeparatorForAdaptiveMenu: function(index) {
  var rootItem = this.menu.GetRootItem(),
   prevItemInGroup = this.menu.GetPrevVisibleItemInGroup(rootItem, index);
  if(prevItemInGroup & !this.IsItemInAdaptiveMenu(prevItemInGroup.index) && !this.menu.IsItemBeginsGroup(prevItemInGroup)) {
   while(prevItemInGroup && !this.IsItemInAdaptiveMenu(prevItemInGroup.index) && !this.menu.IsItemBeginsGroup(prevItemInGroup))
    prevItemInGroup = this.menu.GetPrevVisibleItemInGroup(rootItem, prevItemInGroup.index);
  }
  return prevItemInGroup & !this.IsItemInAdaptiveMenu(prevItemInGroup.index) ? prevItemInGroup : null;
 },
 IsItemInAdaptiveMenu: function(index) {
  return this.elementsToHide.length &gt;= index ? !!this.elementsToHide[index] : false;
 },
 SetItemPopOutImageVertical: function(element) {
  var popOutElements = ASPx.GetNodesByPartialClassName(element, "dxWeb_mHorizontalPopOut");
  for(var i = 0; i &lt; popOutElements.length; i++)
   popOutElements[i].className = popOutElements[i].className.replace("Horizontal", "Vertical");
 },
 ChangeItemsPopOutImages: function(menuElement, isVertical) {
  var itemElements = this.GetItemElements(menuElement);
  for(var i = 0; i &lt; itemElements.length; i++){
   if(isVertical)
    this.SetItemPopOutImageVertical(itemElements[i]);
   else
    this.SetItemItemPopOutImageHorizontal(itemElements[i]);
  }
 },
 ChangeOrientaion: function(menuElement, isVertical) {
  var oldCssSelector = isVertical ? MenuCssClasses.HorizontalMenu : MenuCssClasses.VerticalMenu;
  var newCssSelector = isVertical ? MenuCssClasses.VerticalMenu : MenuCssClasses.HorizontalMenu;
  menuElement.className = menuElement.className.replace(oldCssSelector, newCssSelector);
  this.ChangeItemsPopOutImages(menuElement, isVertical);
  this.CalculateMenuControl(menuElement, true);
  this.ChangeItemsPopOutImages(menuElement, isVertical);
 }
});
var MenuScrollingManager = ASPx.CreateClass(ASPx.ScrollingManager, {
 constructor: function(menuScrollHelper) {
  this.constructor.prototype.constructor.call(this, menuScrollHelper, menuScrollHelper.scrollingAreaElement, [0, 1],
   function(manager, direction) {
    manager.owner.OnBeforeScrolling(direction);
   },
   function(manager, direction) {
    manager.owner.OnAfterScrolling(direction);
   }
  );
 },
 setParentNodeOverflow: function() { 
  if(ASPx.Browser.MSTouchUI) {
   this.scrollableArea.parentNode.style.overflow = "auto";
   this.scrollableArea.parentNode.style["-ms-overflow-style"] = "none";
  }  
 }
});
var MenuScrollHelper = ASPx.CreateClass(null, {
 constructor: function(menu, indexPath) {
  this.menu = menu;
  this.indexPath = indexPath;
  this.scrollingAreaElement = null;
  this.manager = null;
  this.initialized = false;
  this.visibleItems = [];
  this.itemsHeight = 0;
  this.scrollHeight = 0;
  this.scrollUpButtonHeight = 0;
  this.scrollDownButtonHeight = 0;
  this.scrollAreaHeight = null;
  this.scrollUpButtonVisible = false;
  this.scrollDownButtonVisible = false;
 },
 Initialize: function() {
  if(this.initialized & !this.menu.NeedCreateItemsOnClientSide()) return;
  this.scrollingAreaElement = this.menu.GetScrollContentItemsContainer(this.indexPath);
  this.manager = new MenuScrollingManager(this);
  this.ShowScrollButtons();
  var scrollUpButton = this.menu.GetScrollUpButtonElement(this.indexPath);
  if(scrollUpButton) {
   this.scrollUpButtonHeight = this.GetScrollButtonHeight(scrollUpButton);
   ASPx.Selection.SetElementSelectionEnabled(scrollUpButton, false);
  }
  var scrollDownButton = this.menu.GetScrollDownButtonElement(this.indexPath);
  if(scrollDownButton) {
   this.scrollDownButtonHeight = this.GetScrollButtonHeight(scrollDownButton);
   ASPx.Selection.SetElementSelectionEnabled(scrollDownButton, false);
  }
  if(ASPx.Browser.WebKitTouchUI) {
   var preventDefault = function(event) { event.preventDefault(); };
   ASPx.Evt.AttachEventToElement(scrollUpButton, "touchstart", preventDefault);
   ASPx.Evt.AttachEventToElement(scrollDownButton, "touchstart", preventDefault);
  }
  this.HideScrollButtons();
  this.initialized = true;
 },
 GetScrollButtonHeight: function(button) {
  var style = ASPx.GetCurrentStyle(button);
  return button.offsetHeight + ASPx.PxToInt(style.marginTop) + ASPx.PxToInt(style.marginBottom);
 },
 FillVisibleItemsList: function() {
  var index = 0;
  this.visibleItems = [];
  while(true) {
   var childIndexPath = (this.indexPath != "" ? this.indexPath + ASPx.ItemIndexSeparator : "") + index;
   var itemElement = this.menu.GetItemElement(childIndexPath);
   if(itemElement == null)
    break;
   if(ASPx.GetElementDisplay(itemElement))
    this.visibleItems.push(itemElement);
   index++;
  }
 },
 CanCalculate: function() {
  return this.scrollingAreaElement & ASPx.IsElementDisplayed(this.scrollingAreaElement);
 },
 Calculate: function(scrollHeight) {
  if(!this.CanCalculate()) return;
  this.FillVisibleItemsList();
  this.itemsHeight = 0;
  this.scrollHeight = scrollHeight;
  var itemsContainer = this.menu.GetScrollContentItemsContainer(this.indexPath);
  if(itemsContainer) this.itemsHeight = itemsContainer.offsetHeight;
  this.SetPosition(0);
  this.CalculateScrollingElements(-1);
 },
 GetPosition: function() {
  return -this.manager.GetScrolledAreaPosition();
 },
 SetPosition: function(pos) {
  this.manager.SetScrolledAreaPosition(-pos);
 },
 CalculateScrollingElements: function(direction) {
  if(this.itemsHeight &lt;= this.scrollHeight) {
   this.scrollUpButtonVisible = false;
   this.scrollDownButtonVisible = false;
   this.scrollAreaHeight = null;
   this.SetPosition(0);
  }
  else {
   var scrollTop = this.GetPosition();
   this.scrollAreaHeight = this.scrollHeight;
   if(direction &gt; 0) {
    var showScrollUpButton = !this.scrollUpButtonVisible;
    this.scrollUpButtonVisible = true;
    this.scrollAreaHeight -= this.scrollUpButtonHeight;
    this.scrollDownButtonVisible = this.itemsHeight - this.scrollAreaHeight - scrollTop &gt; this.scrollDownButtonHeight;
    if(this.scrollDownButtonVisible) {
     this.scrollAreaHeight -= this.scrollDownButtonHeight;
     if(showScrollUpButton)
      this.SetPosition(this.GetPosition() + this.scrollUpButtonHeight);
    }
    else {
     this.SetPosition(this.itemsHeight - this.scrollAreaHeight);
    }
   }
   else {
    this.scrollDownButtonVisible = true;
    this.scrollAreaHeight -= this.scrollDownButtonHeight;
    this.scrollUpButtonVisible = scrollTop &gt; this.scrollUpButtonHeight;
    if(this.scrollUpButtonVisible)
     this.scrollAreaHeight -= this.scrollUpButtonHeight;
    else
     this.SetPosition(0);
   }
   if(this.scrollAreaHeight &lt; 1) this.scrollAreaHeight = 1;
  }
  this.UpdateScrollingElements();
 },
 UpdateScrollingElements: function() {
  this.UpdateScrollAreaHeight();
  this.UpdateScrollButtonsVisibility();
 },
 UpdateScrollAreaHeight: function() {
  var scrollAreaElement = this.menu.GetScrollAreaElement(this.indexPath);
  if(scrollAreaElement)
   scrollAreaElement.style.height = (this.scrollAreaHeight) ? (this.scrollAreaHeight + "px") : "";
 },
 UpdateScrollButtonsVisibility: function() {
  var scrollUpButton = this.menu.GetScrollUpButtonElement(this.indexPath);
  if(scrollUpButton) ASPx.SetElementDisplay(scrollUpButton, this.scrollUpButtonVisible);
  var scrollDownButton = this.menu.GetScrollDownButtonElement(this.indexPath);
  if(scrollDownButton) ASPx.SetElementDisplay(scrollDownButton, this.scrollDownButtonVisible);
 },
 ChangeScrollButtonsVisibility: function(visible) {
  this.scrollUpButtonVisible = visible;
  this.scrollDownButtonVisible = visible;
  this.UpdateScrollButtonsVisibility();
 },
 ShowScrollButtons: function() {
  this.ChangeScrollButtonsVisibility(true);
 },
 HideScrollButtons: function() {
  this.ChangeScrollButtonsVisibility(false);
 },
 ResetScrolling: function() {
  if(!this.initialized)
   return;
  this.HideScrollButtons();
  this.SetPosition(0);
  this.scrollAreaHeight = null;
  this.UpdateScrollAreaHeight();
 },
 GetScrollAreaHeight: function() {
  var scrollAreaElement = this.menu.GetScrollAreaElement(this.indexPath);
  if(scrollAreaElement)
   return scrollAreaElement.offsetHeight;
  return 0;
 },
 OnAfterScrolling: function(direction) {
  this.CalculateScrollingElements(direction);
 },
 OnBeforeScrolling: function(direction) {
  var scrollButton = (direction &gt; 0) ? this.menu.GetScrollDownButtonElement(this.indexPath) :
   this.menu.GetScrollUpButtonElement(this.indexPath);
  if(!scrollButton || !ASPx.GetElementDisplay(scrollButton))
   this.manager.StopScrolling();
 },
 StartScrolling: function(direction, delay, step) {
  this.manager.StartScrolling(direction, delay, step);
 },
 StopScrolling: function() {
  this.manager.StopScrolling();
 }
});
MenuScrollHelper.GetMenuByScrollButtonId = function(id) {
 var menuName = aspxGetMenuCollection().GetMenuNameBySuffixes(id, [Constants.SBIdSuffix]);
 return aspxGetMenuCollection().Get(menuName);
};
var ASPxClientMenuBase = ASPx.CreateClass(ASPxClientControl, {
 constructor: function(name) {
  this.constructor.prototype.constructor.call(this, name);
  this.renderData = null;
  this.renderHelper = this.CreateRenderHelper();
  this.sampleItemsFlags = {
   TextOnly: 0,
   SubItems: 1,
   Image: 2,
   NavigateUrl: 4,
   DropDownMode: 8,
   CheckBox: 16,
   ImageClassName: 32
  };
  this.rootMenuSample = null;
  this.dropElementsCache = false;
  this.allowSelectItem = false;
  this.allowCheckItems = false;
  this.allowMultipleCallbacks = false;
  this.appearAfter = 300;
  this.slideAnimationDuration = 60;
  this.disappearAfter = 500;
  this.enableAnimation = true;
  this.enableAdaptivity = false;
  this.adaptiveItemsOrder = [];
  this.enableSubMenuFullWidth = false;
  this.checkedItems = [];
  this.isVertical = true;
  this.itemCheckedGroups = [];
  this.itemCheckedGroups.groupNames = {};
  this.lockHoverEvents = false;
  this.popupToLeft = false;
  this.popupCount = 0;
  this.rootItem = null;
  this.showSubMenus = false;
  this.savedCallbackHoverItem = null;
  this.savedCallbackHoverElement = null;
  this.selectedItemIndexPath = "";
  this.checkedState = null;
  this.scrollInfo = [];
  this.scrollHelpers = {};
  this.scrollVertOffset = 1;
  this.keyboardHelper = null;
  this.isContextMenu = false;
  this.accessibleFocusElement = null;
  this.rootSubMenuFIXOffset = 0;
  this.rootSubMenuFIYOffset = 0;
  this.rootSubMenuLIXOffset = 0;
  this.rootSubMenuLIYOffset = 0;
  this.rootSubMenuXOffset = 0;
  this.rootSubMenuYOffset = 0;
  this.subMenuFIXOffset = 0;
  this.subMenuFIYOffset = 0;
  this.subMenuLIXOffset = 0;
  this.subMenuLIYOffset = 0;
  this.subMenuXOffset = 0;
  this.subMenuYOffset = 0;
  this.maxHorizontalOverlap = -3;
  this.sizingConfig.allowSetHeight = false;
  this.ItemClick = new ASPxClientEvent();
  this.ItemMouseOver = new ASPxClientEvent();
  this.ItemMouseOut = new ASPxClientEvent();
  this.PopUp = new ASPxClientEvent();
  this.CloseUp = new ASPxClientEvent();
  aspxGetMenuCollection().Add(this);
 },
 SetData: function(data){
  if(data.items)
   this.CreateItems(data.items);
 },
 InlineInitialize: function() {
  ASPxClientControl.prototype.InlineInitialize.call(this);
  if(!this.NeedCreateItemsOnClientSide())
   this.renderHelper.InlineInitializeElements();
  this.InitializeInternal(true);
  if(this.IsCallbacksEnabled()) {
   this.showSubMenus = this.GetLoadingElement() != null;
   this.CreateCallback("DXMENUCONTENT");
  }
  else
   this.showSubMenus = true;
  this.popupToLeft = this.rtl;
 },
 InitializeInternal: function(inline) {
  if(!this.NeedCreateItemsOnClientSide()) {
   this.InitializeCheckedItems();
   this.InitializeSelectedItem();
  }
  this.InitializeEnabledAndVisible(!inline || !this.IsCallbacksEnabled());
  if(!this.IsCallbacksEnabled())
   this.InitializeScrollableMenus();
  this.InitializeKeyboardHelper();
 },
 InitializeEnabledAndVisible: function(recursive) {
  if(this.rootItem == null) return;
  for(var i = 0; i &lt; this.rootItem.items.length; i++)
   this.rootItem.items[i].InitializeEnabledAndVisible(recursive);
 },
 InitializeScrollableMenus: function() {
  var info = eval(this.scrollInfo);
  this.scrollHelpers = {};
  for(var i = 0; i &lt; info.length; i++)
   this.InitializeScrollableMenu(info[i]);
 },
 InitializeScrollableMenu: function(indexPath) {
  if(!this.scrollHelpers[indexPath])
   this.scrollHelpers[indexPath] = new MenuScrollHelper(this, indexPath);
 },
 GetScrollHelper: function(indexPath) {
  var scrollsEnabledOnServer = this.scrollInfo.length &gt; 0;
  if(this.NeedCreateItemsOnClientSide() & scrollsEnabledOnServer)
   this.InitializeScrollableMenu(indexPath);
  return this.scrollHelpers[indexPath];
 },
 InitializeKeyboardHelper: function() {
  this.keyboardHelper = new ASPxMenuKeyboardHelper(this);
 },
 InitializeMenuSamples: function() {
  this.rootMenuSample = this.GetSampleNode(this.samples.root);
  this.samples.spacing = this.GetSampleNode(this.samples.spacing);
  this.samples.separator = this.GetSampleNode(this.samples.separator);
  this.InitializeItemsSamples(this.samples.rootItems);
  if(this.samples.submenu) {
   this.samples.submenu = this.GetSampleNode(this.samples.submenu);
   this.InitializeItemsSamples(this.samples.submenuItems);
  }
 },
 InitializeItemsSamples: function(itemsSamples) {
  for(var sampleProperty in itemsSamples) {
   if(itemsSamples.hasOwnProperty(sampleProperty)) {
    itemsSamples[sampleProperty] = itemsSamples[sampleProperty].replace(/DXFAKE/, "");
    itemsSamples[sampleProperty] = this.GetSampleNode(itemsSamples[sampleProperty]);
   }
  }
 },
 CheckElementsCache: function(menuElement){
  if(this.dropElementsCache) {
   ASPx.CacheHelper.DropCache(menuElement);
   this.dropElementsCache = false;
  }
 },
 NeedCreateItemsOnClientSide: function() {
  return false;
 },
 IsClientSideEventsAssigned: function() {
  return !this.ItemClick.IsEmpty()
   || !this.ItemMouseOver.IsEmpty()
   || !this.ItemMouseOut.IsEmpty()
   || !this.PopUp.IsEmpty()
   || !this.CloseUp.IsEmpty()
   || !this.Init.IsEmpty();
 },
 IsCallbacksEnabled: function() {
  return ASPx.IsFunction(this.callBack);
 },
 ShouldHideExistingLoadingElements: function() {
  return false;
 },
 CreateRenderHelper: function(){
  return new MenuRenderHelper(this);
 },
 GetMenuElementId: function(indexPath) {
  return this.name + Constants.MMIdSuffix + indexPath + "_";
 },
 GetMenuMainElementId: function(indexPath) {
  return this.name + "_DXME" + indexPath + "_";
 },
 GetMenuBorderCorrectorElementId: function(indexPath) {
  return this.name + "_DXMBC" + indexPath + "_";
 },
 GetMenuIFrameElementId: function(indexPath) {
  return this.name + "_DXMIF" + this.GetMenuLevel(indexPath);
 },
 GetScrollAreaId: function(indexPath) {
  return this.name + "_DXSA" + indexPath;
 },
 GetMenuTemplateContainerID: function(indexPath) {
  return this.name + "_MTCNT" + indexPath;
 },
 GetItemTemplateContainerID: function(indexPath) {
  return this.name + "_ITCNT" + indexPath;
 },
 GetScrollUpButtonId: function(indexPath) {
  return this.name + Constants.SBIdSuffix + indexPath + Constants.SBUIdEnd;
 },
 GetScrollDownButtonId: function(indexPath) {
  return this.name + Constants.SBIdSuffix + indexPath + Constants.SBDIdEnd;
 },
 GetItemElementId: function(indexPath) {
  return this.name + Constants.MIIdSuffix + indexPath + "_";
 },
 GetItemContentElementId: function(indexPath) {
  return this.GetItemElementId(indexPath) + "T";
 },
 GetItemPopOutElementId: function(indexPath) {
  return this.GetItemElementId(indexPath) + "P";
 },
 GetItemImageId: function(indexPath) {
  return this.GetItemElementId(indexPath) + Constants.ImagePostfix;
 },
 GetItemPopOutImageId: function(indexPath) {
  return this.GetItemElementId(indexPath) + Constants.PopupImagePostfix;
 },
 GetItemIndentElementId: function(indexPath) {
  return this.GetItemElementId(indexPath) + "II";
 },
 GetItemSeparatorElementId: function(indexPath) {
  return this.GetItemElementId(indexPath) + "IS";
 },
 GetMenuElement: function (indexPath) { 
  if(indexPath == "")
   return this.GetMainElement();
  return ASPx.CacheHelper.GetCachedElementById(this, this.GetMenuElementId(indexPath));
 },
 GetMenuIFrameElement: function(indexPath) {
  var elementId = this.GetMenuIFrameElementId(indexPath);
  var element = ASPx.GetElementById(elementId);
  if(!element & this.renderIFrameForPopupElements)
   return this.CreateIFrameElement(elementId);
  return element;
 },
 CreateIFrameElement: function(elementId) {
  var element = document.createElement("IFRAME");
  ASPx.Attr.SetAttribute(element, "id", elementId);
  ASPx.Attr.SetAttribute(element, "src", "javascript:false");
  ASPx.Attr.SetAttribute(element, "scrolling", "no");
  ASPx.Attr.SetAttribute(element, "frameborder", "0");
  if(this.accessibilityCompliant)
   ASPx.Attr.SetAttribute(element, "title", ASPx.AccessibilitySR.AccessibilityIFrameTitle);
  element.style.position = "absolute";
  element.style.display = "none";
  element.style.zIndex = "19997";
  element.style.filter = "progid:DXImageTransform.Microsoft.Alpha(Style=0, Opacity=0)";
  ASPx.InsertElementAfter(element, this.GetMainElement());
  return element;
 },
 GetMenuBorderCorrectorElement: function(indexPath) {
  return ASPx.CacheHelper.GetCachedElementById(this, this.GetMenuBorderCorrectorElementId(indexPath));
 },
 GetMenuMainElement: function(element) {
  var indexPath = this.GetIndexPathById(element.id, true);
  return ASPx.CacheHelper.GetCachedElement(this, "menuMainElement" + indexPath, 
   function() { 
    var shadowTable = ASPx.GetElementById(this.GetMenuMainElementId(indexPath));
    return shadowTable != null ? shadowTable : element;
   });
 },
 GetScrollAreaElement: function(indexPath) {
  return ASPx.CacheHelper.GetCachedElementById(this, this.GetScrollAreaId(indexPath));
 },
 GetScrollContentItemsContainer: function(indexPath) {
  return ASPx.CacheHelper.GetCachedElement(this, "scrollContentItemsContainer" + indexPath, 
   function() { 
    return ASPx.GetNodeByTagName(this.GetScrollAreaElement(indexPath), "UL", 0);
   });
 },
 GetScrollUpButtonElement: function(indexPath) {
  return ASPx.CacheHelper.GetCachedElementById(this, this.GetScrollUpButtonId(indexPath));
 },
 GetScrollDownButtonElement: function(indexPath) {
  return ASPx.CacheHelper.GetCachedElementById(this, this.GetScrollDownButtonId(indexPath));
 },
 GetItemElement: function(indexPath) {
  return ASPx.CacheHelper.GetCachedElementById(this, this.GetItemElementId(indexPath));
 },
 GetItemTemplateElement: function(indexPath) { 
  return this.GetItemTextTemplateContainer(indexPath);
 },
 GetItemTemplateContainer: function(indexPath) {
  return this.GetItemElement(indexPath);
 },
 GetItemTextTemplateContainer: function(indexPath) {
  return this.GetItemContentElement(indexPath);
 },
 GetItemContentElement: function(indexPath) {
  return ASPx.CacheHelper.GetCachedElementById(this, this.GetItemContentElementId(indexPath));
 },
 GetItemPopOutElement: function(indexPath) {
  return ASPx.CacheHelper.GetCachedElementById(this, this.GetItemPopOutElementId(indexPath));
 },
 GetPopOutElements: function() {
  return ASPx.GetNodesByClassName(this.GetMainElement().parentNode, "dxm-popOut");
 },
 GetPopOutImages: function() {
  return ASPx.GetNodesByClassName(this.GetMainElement().parentNode, "dxm-pImage");
 },
 GetSubMenuXPosition: function(indexPath, isVertical) {
  var itemElement = this.GetItemElement(indexPath);
  var pos = ASPx.GetAbsoluteX(itemElement) + (isVertical ? itemElement.clientWidth + itemElement.clientLeft : 0);
  if(ASPx.Browser.WebKitFamily & !this.IsParentElementPositionStatic(indexPath))
   pos -= document.body.offsetLeft;
  return pos;
 },
 GetSubMenuYPosition: function(indexPath, isVertical) {
  var position = 0;
  var element = this.GetItemElement(indexPath);
  if(element != null) {
   if(isVertical) {
    position = ASPx.GetAbsoluteY(element); 
   }
   else {
    if(ASPx.Browser.NetscapeFamily || ASPx.Browser.Opera & ASPx.Browser.Version >= 9 || ASPx.Browser.Safari && ASPx.Browser.Version >= 3 || ASPx.Browser.Chrome || ASPx.Browser.AndroidDefaultBrowser)
     position = ASPx.GetAbsoluteY(element) + element.offsetHeight - ASPx.GetClientTop(element);
    else if(ASPx.Browser.WebKitFamily)
     position = ASPx.GetAbsoluteY(element) + element.offsetHeight + element.offsetTop - ASPx.GetClientTop(element);
    else
     position = ASPx.GetAbsoluteY(element) + element.clientHeight + ASPx.GetClientTop(element);
   }
  }
  if(ASPx.Browser.WebKitFamily & !this.IsParentElementPositionStatic(indexPath))
   position -= document.body.offsetTop;
  return position;
 },
 GetClientSubMenuXPosition: function(element, x, indexPath, isVertical) {
  var itemInfo = new MenuItemInfo(this, indexPath);
  var itemWidth = itemInfo.clientWidth;
  var itemOffsetWidth = itemInfo.offsetWidth;
  var subMenuWidth = this.GetMenuMainElement(element).offsetWidth;
  var docClientWidth = ASPx.GetDocumentClientWidth();
  if(isVertical) {
   var left = x - ASPx.GetDocumentScrollLeft();
   var right = left + subMenuWidth;
   var toLeftX = x - subMenuWidth - itemWidth;
   var toLeftLeft = left - subMenuWidth - itemWidth;
   var toLeftRight = right - subMenuWidth - itemWidth;
   if(this.IsCorrectionDisableMethodRequired(indexPath)) {
    return this.GetCorrectionDisabledResult(x, toLeftX);
   }
   if(this.popupToLeft) {
    if(toLeftLeft &gt; this.maxHorizontalOverlap) {
     return toLeftX;
    }
    if(docClientWidth - right &gt; this.maxHorizontalOverlap || !this.rtl) {
     this.popupToLeft = false;
     return x;
    }
    if(isVertical)
     return ASPx.InvalidPosition;
    return toLeftX;
   }
   else {
    if(docClientWidth - right &gt; this.maxHorizontalOverlap) {
     return x;
    }
    if(toLeftLeft &gt; this.maxHorizontalOverlap || this.rtl) {
     this.popupToLeft = true;
     return toLeftX;
    }
    if(isVertical)
     return ASPx.InvalidPosition;
    return x;
   }
  }
  else {
   var left = x - ASPx.GetDocumentScrollLeft();
   var right = left + subMenuWidth;
   var toLeftX = x - subMenuWidth + itemOffsetWidth;
   var toLeftLeft = left - subMenuWidth + itemOffsetWidth;
   var toLeftRight = right - subMenuWidth + itemOffsetWidth;
   if(this.popupToLeft) {
    if(toLeftLeft &lt; 0 & toLeftLeft < docClientWidth - right) {
     this.popupToLeft = false;
     return x;
    }
    else
     return toLeftX;
   }
   else {
    if(docClientWidth - right &lt; 0 & docClientWidth - right < toLeftLeft) {
     this.popupToLeft = true;
     return toLeftX;
    }
    else
     return x;
   }
  }
 },
 GetClientSubMenuYPosition: function(element, y, indexPath, isVertical) {
  var itemInfo = new MenuItemInfo(this, indexPath);
  var itemHeight = itemInfo.offsetHeight;
  var itemOffsetHeight = itemInfo.offsetHeight;
  var subMenuHeight = this.GetMenuMainElement(element).offsetHeight;
  var menuItemTop = y - ASPx.GetDocumentScrollTop();
  var subMenuBottom = menuItemTop + subMenuHeight;
  var docClientHeight = ASPx.GetDocumentClientHeight();
  var clientSubMenuYPos = y;
  if(isVertical) {
   var notEnoughSpaceToShowDown = subMenuBottom &gt; docClientHeight;
   var menuItemBottom = menuItemTop + itemHeight;
   if(menuItemBottom &gt; docClientHeight) {
    menuItemBottom = docClientHeight;
    itemHeight = menuItemBottom - menuItemTop;
   }
   var notEnoughSpaceToShowUp = menuItemBottom &lt; subMenuHeight;
   var subMenuIsFitToDisplayFrames = docClientHeight &gt;= subMenuHeight;
   if(!subMenuIsFitToDisplayFrames) clientSubMenuYPos = y - menuItemTop;
   else if(notEnoughSpaceToShowDown) {
    if(notEnoughSpaceToShowUp) {
     var docClientBottom = ASPx.GetDocumentScrollTop() + docClientHeight;
     clientSubMenuYPos = docClientBottom - subMenuHeight;
    } else
     clientSubMenuYPos = y + itemHeight - subMenuHeight;
   }
  }
  else {
   if(this.IsHorizontalSubmenuNeedInversion(subMenuBottom, docClientHeight, menuItemTop, subMenuHeight, itemHeight))
    clientSubMenuYPos = y - subMenuHeight - itemHeight;
  }
  return clientSubMenuYPos;
 },
 IsHorizontalSubmenuNeedInversion: function(subMenuBottom, docClientHeight, menuItemTop, subMenuHeight, itemHeight) {
  return subMenuBottom &gt; docClientHeight & menuItemTop - subMenuHeight - itemHeight > docClientHeight - subMenuBottom;
 },
 IsCorrectionDisableMethodRequired: function(indexPath) {
  return false;
 },
 HasChildren: function(indexPath) {
  return (this.GetMenuElement(indexPath) != null);
 },
 IsVertical: function(indexPath) {
  return true;
 },
 IsRootItem: function(indexPath) {
  return this.GetMenuLevel(indexPath) &lt;= 1;
 },
 IsParentElementPositionStatic: function(indexPath) {
  return this.IsRootItem(indexPath);
 },
 GetItemIndexPath: function(indexes) {
  return aspxGetMenuCollection().GetItemIndexPath(indexes);
 },
 GetItemIndexes: function(indexPath) {
  return aspxGetMenuCollection().GetItemIndexes(indexPath);
 },
 GetItemIndexPathById: function(id) {
  return aspxGetMenuCollection().GetIndexPathById(id, Constants.MIIdSuffix);
 },
 GetMenuIndexPathById: function(id) {
  return aspxGetMenuCollection().GetIndexPathById(id, Constants.MMIdSuffix);
 },
 GetScrollButtonIndexPathById: function(id) {
  return aspxGetMenuCollection().GetIndexPathById(id, Constants.SBIdSuffix);
 },
 GetIndexPathById: function(id, checkMenu) {
  var indexPath = this.GetItemIndexPathById(id);
  if(indexPath == "" & checkMenu)
   indexPath = this.GetMenuIndexPathById(id);
  return indexPath;
 },
 GetMenuLevelInternal: function(indexPath) {
  if(indexPath == "")
   return 0;
  else {
   var indexes = this.GetItemIndexes(indexPath);
   return indexes.length;
  }
 },
 GetMenuLevel: function(indexPath) {
  var level = this.GetMenuLevelInternal(indexPath);
  if(this.IsAdaptiveMenuItem(indexPath))
   level ++;
  return level;
 },
 IsAdaptiveMenuItem: function(indexPath){
  var level = this.GetMenuLevelInternal(indexPath);
  while(level &gt; 1){
   indexPath = this.GetParentIndexPath(indexPath);
   level = this.GetMenuLevelInternal(indexPath);
  }
  var itemElement = this.GetItemElement(indexPath);
  if(itemElement & ASPx.GetParentByClassName(itemElement, MenuCssClasses.AdaptiveMenu))
   return true;
  return false;
 },
 IsAdaptiveItem: function(indexPath){
  var itemElement = this.GetItemElement(indexPath);
  if(itemElement & ASPx.ElementContainsCssClass(itemElement, MenuCssClasses.AdaptiveMenuItem))
   return true;
  return false;
 },
 GetParentIndexPath: function(indexPath) {
  var indexes = this.GetItemIndexes(indexPath);
  indexes.length--;
  return (indexes.length &gt; 0) ? this.GetItemIndexPath(indexes) : "";
 },
 IsLastElement: function(element) {
  return element & (!element.nextSibling || !element.nextSibling.tagName);
 },
 IsLastItem: function(indexPath) {
  var itemElement = this.GetItemElement(indexPath);
  return this.IsLastElement(itemElement);
 },
 IsFirstElement: function(element) {
  return element & (!element.previousSibling || !element.previousSibling.tagName);
 },
 IsFirstItem: function(indexPath) {
  var itemElement = this.GetItemElement(indexPath);
  return this.IsFirstElement(itemElement);
 },
 GetClientSubMenuPos: function(element, indexPath, pos, isVertical, isXPos) {
  if(!ASPx.IsValidPosition(pos)) {
   pos = isXPos ? this.GetSubMenuXPosition(indexPath, isVertical) : this.GetSubMenuYPosition(indexPath, isVertical);
  }
  var clientPos = isXPos ? this.GetClientSubMenuXPosition(element, pos, indexPath, isVertical) : this.GetClientSubMenuYPosition(element, pos, indexPath, isVertical);
  var isInverted = pos != clientPos;
  if(clientPos !== ASPx.InvalidPosition){
   var offset = isXPos ? this.GetSubMenuXOffset(indexPath) : this.GetSubMenuYOffset(indexPath);
   clientPos += isInverted ? -offset : offset;
   clientPos -= ASPx.GetPositionElementOffset(this.GetMenuElement(indexPath), isXPos);
  }
  return new ASPx.PopupPosition(clientPos, isInverted);
 },
 GetSubMenuXOffset: function(indexPath) {
  if(indexPath == "")
   return 0;
  else if(this.IsRootItem(indexPath)) {
   if(this.IsFirstItem(indexPath))
    return this.rootSubMenuFIXOffset;
   else if(this.IsLastItem(indexPath))
    return this.rootSubMenuLIXOffset;
   else
    return this.rootSubMenuXOffset;
  }
  else {
   if(this.IsFirstItem(indexPath))
    return this.subMenuFIXOffset;
   else if(this.IsLastItem(indexPath))
    return this.subMenuLIXOffset;
   else
    return this.subMenuXOffset;
  }
 },
 GetSubMenuYOffset: function(indexPath) {
  if(indexPath == "")
   return 0;
  else if(this.IsRootItem(indexPath)) {
   if(this.IsFirstItem(indexPath))
    return this.rootSubMenuFIYOffset;
   else if(this.IsLastItem(indexPath))
    return this.rootSubMenuLIYOffset;
   else
    return this.rootSubMenuYOffset;
  }
  else {
   if(this.IsFirstItem(indexPath))
    return this.subMenuFIYOffset;
   else if(this.IsLastItem(indexPath))
    return this.subMenuLIYOffset;
   else
    return this.subMenuYOffset;
  }
 },
 CalculateSubMenuPosition: function(element, x, y, indexPath, enableAnimation) {
  var isVertical = this.IsVertical(indexPath);
  var horizontalPopupPosition = this.GetClientSubMenuPos(element, indexPath, x, isVertical, true);
  if(horizontalPopupPosition.position === ASPx.InvalidPosition) {
   isVertical = !isVertical;
   horizontalPopupPosition = this.GetClientSubMenuPos(element, indexPath, x, isVertical, true);
  }
  var verticalPopupPosition = this.GetClientSubMenuPos(element, indexPath, y, isVertical, false);
  var clientX = horizontalPopupPosition.position;
  var clientY = verticalPopupPosition.position;
  var toTheLeft = horizontalPopupPosition.isInverted;
  var toTheTop = verticalPopupPosition.isInverted;
  var scrollHelper = this.GetScrollHelper(indexPath);
  if(scrollHelper) {
   var yClientCorrection = this.GetScrollSubMenuYCorrection(element, scrollHelper, clientY);
   if(yClientCorrection &gt; 0) {
    clientY += yClientCorrection;
    verticalPopupPosition.position = clientY;
   }
  }
  var parentElement = this.GetItemContentElement(indexPath);
  var prevParentPos = ASPx.GetAbsoluteX(parentElement);
  ASPx.SetStyles(element, {
   left: clientX, top: clientY
  });
  if(ASPx.Browser.IE & ASPx.IsElementRightToLeft(document.body)) {
   ASPx.SetElementDisplay(element, false);
   ASPx.SetElementDisplay(element, true);
  }
  clientX += ASPx.GetAbsoluteX(parentElement) - prevParentPos;
  if(enableAnimation) {
   this.StartAnimation(element, indexPath, horizontalPopupPosition, verticalPopupPosition, isVertical);
  }
  else {
   ASPx.SetStyles(element, { left: clientX, top: clientY });
   ASPx.SetElementVisibility(element, true);
   if(this.enableSubMenuFullWidth)
    this.ApplySubMenuFullWidth(element);
   this.DoShowPopupMenuIFrame(element, clientX, clientY, ASPx.InvalidDimension, ASPx.InvalidDimension, indexPath);
   this.DoShowPopupMenuBorderCorrector(element, clientX, clientY, indexPath, toTheLeft, toTheTop);
  }
 },
 StartScrolling: function(buttonId, delay, step) {
  var indexPath = this.GetScrollButtonIndexPathById(buttonId);
  var level = this.GetMenuLevel(indexPath);
  aspxGetMenuCollection().DoHidePopupMenus(null, level, this.name, false, "");
  var direction = (buttonId.lastIndexOf(Constants.SBDIdEnd) == buttonId.length - Constants.SBDIdEnd.length) ? 1 : -1;
  var scrollHelper = this.GetScrollHelper(indexPath);
  if(scrollHelper) scrollHelper.StartScrolling(direction, delay, step);
 },
 StopScrolling: function(buttonId) {
  var indexPath = this.GetScrollButtonIndexPathById(buttonId);
  var scrollHelper = this.GetScrollHelper(indexPath);
  if(scrollHelper) scrollHelper.StopScrolling();
 },
 ClearAppearTimer: function() {
  aspxGetMenuCollection().ClearAppearTimer();
 },
 ClearDisappearTimer: function() {
  aspxGetMenuCollection().ClearDisappearTimer();
 },
 IsAppearTimerActive: function() {
  return aspxGetMenuCollection().IsAppearTimerActive();
 },
 IsDisappearTimerActive: function() {
  return aspxGetMenuCollection().IsDisappearTimerActive();
 },
 SetAppearTimer: function(indexPath, preventSubMenu) {
  aspxGetMenuCollection().SetAppearTimer(this.name, indexPath, this.appearAfter, preventSubMenu);
 },
 SetDisappearTimer: function() {
  aspxGetMenuCollection().SetDisappearTimer(this.name, this.disappearAfter);
 },
 IsDropDownItem: function(indexPath) {
  return ASPx.ElementContainsCssClass(this.GetItemElement(indexPath), MenuCssClasses.ItemDropDownMode);
 },
 DoItemClick: function(indexPath, hasItemLink, htmlEvent) {
  aspxGetMenuCollection().LockMenusVisibility();
  var processOnServer = this.RaiseItemClick(indexPath, htmlEvent);
  if(processOnServer & !hasItemLink) {
   if(ASPx.Browser.IE || ASPx.Browser.Edge) { 
    var activeElement = document.activeElement;
    if(activeElement)
     activeElement.blur();
   }
   this.SendPostBack("CLICK:" + indexPath);
  }
  else {
   this.ClearDisappearTimer();
   this.ClearAppearTimer();
   if(!this.HasChildren(indexPath) || this.IsDropDownItem(indexPath))
    aspxGetMenuCollection().DoHidePopupMenus(null, -1, this.name, false, "");
   else if(this.IsItemEnabled(indexPath) & !this.IsDropDownItem(indexPath))
    this.ShowSubMenu(indexPath);
  }
  aspxGetMenuCollection().UnlockMenusVisibility();
 },
 HasContent: function(mainCell) {
  for(var i = 0; i &lt; mainCell.childNodes.length; i++)
   if(mainCell.childNodes[i].tagName)
    return true;
  return false;
 },
 DoShowPopupMenu: function(element, x, y, indexPath) {
  var parent = this.GetItemByIndexPath(indexPath);
  var menuElement = this.GetMenuMainElement(element);
  var popupMenuHasVisibleContent = menuElement & (this.renderHelper.HasSubMenuTemplate(menuElement) || 
   ASPx.ElementContainsCssClass(menuElement, MenuCssClasses.AdaptiveMenu)) || 
   parent && this.HasVisibleItems(parent);
  if(popupMenuHasVisibleContent === false)
   return;
  if(element & this.IsCallbacksEnabled())
   this.ShowLoadingInMenu(element);
  if(ASPx.GetElementVisibility(element))
   ASPx.SetStyles(element, { left: ASPx.InvalidPosition, top: ASPx.InvalidPosition });
  ASPx.SetElementDisplay(element, true, true);
  if(parent) {
   for(var i = 0; i &lt; parent.GetItemCount() ; i++) {
    var item = parent.GetItem(i);
    this.SetPopOutElementVisible(item.indexPath, this.HasVisibleItems(item));
   }
  }
  this.renderHelper.CalculateSubMenu(element, false);
  if(this.popupCount == 0) this.popupToLeft = this.rtl;
  this.CalculateSubMenuPosition(element, x, y, indexPath, this.enableAnimation);
  aspxGetMenuCollection().VisiblePopupMenu(this.name, element.id);
  this.popupCount++;
  ASPx.GetControlCollection().AdjustControls(element);
  this.CorrectVerticalAlignment(ASPx.AdjustHeight, this.GetPopOutElements, "PopOut");
  this.CorrectVerticalAlignment(ASPx.AdjustVerticalMargins, this.GetPopOutImages, "PopOutImg");
  this.RaisePopUp(indexPath);
 },
 ShowLoadingInMenu: function(element) {
  var lpParent = this.GetMenuMainElement(element);
  if(lpParent & !this.HasContent(lpParent))
   this.CreateLoadingInsideContainer(lpParent);
 },
 GetScrollSubMenuYCorrection: function(element, scrollHelper, clientY) {
  var absoluteClientY = clientY + ASPx.GetPositionElementOffset(element);
  var excessTop = this.GetScrollExcessTop(absoluteClientY);
  var excessBottom = this.GetScrollExcessBottom(element, absoluteClientY);
  var correction = 0;
  if(excessTop &gt; 0)
   correction += excessTop + this.scrollVertOffset;
  if(excessBottom &gt; 0 & (absoluteClientY + correction == ASPx.GetDocumentScrollTop())) {
   excessBottom += this.scrollVertOffset;
   correction += this.scrollVertOffset;
  }
  this.PrepareScrolling(element, scrollHelper, excessTop, excessBottom);
  return correction;
 },
 GetScrollExcessTop: function(clientY) {
  return ASPx.GetDocumentScrollTop() - clientY;
 },
 GetScrollExcessBottom: function(element, clientY) {
  ASPx.SetElementDisplay(element, false);
  var docHeight = ASPx.GetDocumentClientHeight();
  ASPx.SetElementDisplay(element, true);
  return clientY + element.offsetHeight - ASPx.GetDocumentScrollTop() - docHeight;
 },
 PrepareScrolling: function(element, scrollHelper, excessTop, excessBottom) {
  scrollHelper.Initialize();
  var corrector = element.offsetHeight - scrollHelper.GetScrollAreaHeight() + this.scrollVertOffset;
  if(excessTop &gt; 0)
   scrollHelper.Calculate(element.offsetHeight - excessTop - corrector);
  if(excessBottom &gt; 0)
   scrollHelper.Calculate(element.offsetHeight - excessBottom - corrector);
 },
 ApplySubMenuFullWidth: function(element) {
  ASPx.SetStyles(element, { left: 0, right: 0, width: "auto" });
  var menuElement = this.GetMenuMainElement(element);
  ASPx.SetStyles(menuElement, { width: "100%", "box-sizing": "border-box" });
  var templateElement = ASPx.GetChildByClassName(menuElement, "dx");
  if(templateElement) ASPx.SetStyles(templateElement, { width: "100%" });
 },
 DoShowPopupMenuIFrame: function(element, x, y, width, height, indexPath) {
  if(!this.renderIFrameForPopupElements) return;
  var iFrame = element.overflowElement;
  if(!iFrame) {
   iFrame = this.GetMenuIFrameElement(indexPath);
   element.overflowElement = iFrame;
  }
  if(iFrame) {
   var menuElement = this.GetMenuMainElement(element);
   if(width &lt; 0)
    width = menuElement.offsetWidth;
   if(height &lt; 0)
    height = menuElement.offsetHeight;
   ASPx.SetStyles(iFrame, {
    width: width, height: height,
    left: x, top: y, display: ""
   });
  }
 },
 DoShowPopupMenuBorderCorrector: function(element, x, y, indexPath, toTheLeft, toTheTop) {
  var borderCorrectorElement = this.GetMenuBorderCorrectorElement(indexPath);
  if(borderCorrectorElement) {
   var params = this.GetPopupMenuBorderCorrectorPositionAndSize(element, x, y, indexPath, toTheLeft, toTheTop);
   var itemCell = this.GetItemContentElement(indexPath);
   var popOutImageCell = this.GetItemPopOutElement(indexPath);
   if(ASPx.Browser.IE & ASPx.Browser.MajorVersion == 9) { 
    var isVertical = this.IsVertical(indexPath);
    var itemBoundCoord = itemCell.getBoundingClientRect()[isVertical ? 'bottom' : 'right'];
    var itemBorderWidth = ASPx.PxToInt(ASPx.GetCurrentStyle(itemCell)[isVertical ? 'borderBottomWidth' : 'borderRightWidth']);
    if(popOutImageCell != null) {
     var popOutImageBoundCoord = popOutImageCell.getBoundingClientRect()[isVertical ? 'bottom' : 'right'];
     if(popOutImageBoundCoord &gt; itemBoundCoord) {
      itemBoundCoord = popOutImageBoundCoord;
      itemBorderWidth = ASPx.PxToInt(ASPx.GetCurrentStyle(popOutImageCell)[isVertical ? 'borderBottomWidth' : 'borderRightWidth']);
     }
    }
    var menu = this.GetMainElement();
    itemBoundCoord -= Math.min(menu.getBoundingClientRect()[isVertical ? 'top' : 'left'], ASPx.GetPositionElementOffset(menu, !isVertical));
    if(isVertical) {
     var bottomsDifference = this.GetItemElement(indexPath).getBoundingClientRect().bottom -
      this.GetMenuElement(indexPath).getBoundingClientRect().bottom;
     itemBoundCoord -= bottomsDifference &gt; 0 & bottomsDifference;
    }
    var borderCorrectorBoundCoord = isVertical ? params.top + params.height : params.left + params.width;
    if(itemBoundCoord - borderCorrectorBoundCoord != itemBorderWidth) {
     borderCorrectorBoundCoord = itemBoundCoord - itemBorderWidth;
     if(isVertical)
      params.height = borderCorrectorBoundCoord - params.top;
     else
      params.width = borderCorrectorBoundCoord - params.left;
    }
   }
   ASPx.SetStyles(borderCorrectorElement, {
    width: params.width, height: params.height,
    left: params.left, top: params.top,
    display: "", visibility: "visible"
   });
   element.borderCorrectorElement = borderCorrectorElement;
  }
 },
 GetPopupMenuBorderCorrectorPositionAndSize: function(element, x, y, indexPath, toTheLeft, toTheTop) {
  var result = {};
  var itemInfo = new MenuItemInfo(this, indexPath);
  var menuXOffset = ASPx.GetClientLeft(this.GetMenuMainElement(element));
  var menuYOffset = ASPx.GetClientTop(this.GetMenuMainElement(element));
  var menuElement = this.GetMenuMainElement(element);
  var menuClientWidth = menuElement.clientWidth;
  var menuClientHeight = menuElement.clientHeight;
  if(this.IsVertical(indexPath)) {
   var commonClientHeight = itemInfo.clientHeight &lt; menuClientHeight
    ? itemInfo.clientHeight
    : menuClientHeight;
   result.width = menuXOffset;
   result.height = commonClientHeight + itemInfo.clientTop - menuYOffset;
   result.left = x;
   if(toTheLeft)
    result.left += menuClientWidth + menuXOffset;
   result.top = y + menuYOffset;
   if(toTheTop)
    result.top += menuClientHeight - result.height;
  }
  else {
   var itemWidth = itemInfo.clientWidth;
   if(this.IsDropDownItem(indexPath))
    itemWidth = this.GetItemContentElement(indexPath).clientWidth;
   var commonClientWidth = itemWidth &lt; menuClientWidth
    ? itemWidth
    : menuClientWidth;
   result.width = commonClientWidth + itemInfo.clientLeft - menuXOffset;
   result.height = menuYOffset;
   result.left = x + menuXOffset;
   if(toTheLeft)
    result.left += menuClientWidth - result.width;
   result.top = y;
   if(toTheTop)
    result.top += menuClientHeight + menuYOffset;
  }
  return result;
 },
 DoHidePopupMenu: function(evt, element) {
  this.DoHidePopupMenuBorderCorrector(element);
  this.DoHidePopupMenuIFrame(element);
  var menuElement = this.GetMenuMainElement(element);
  ASPx.PopupUtils.StopAnimation(element, menuElement);
  ASPx.SetElementVisibility(element, false);
  ASPx.SetElementDisplay(element, false);
  this.CancelSubMenuItemHoverItem(element);
  aspxGetMenuCollection().UnVisiblePopupMenu(this.name, element.id);
  this.popupCount--;
  var indexPath = this.GetIndexPathById(element.id, true);
  var scrollHelper = this.GetScrollHelper(indexPath);
  if(scrollHelper) {
   element.style.height = "";
   scrollHelper.ResetScrolling();
  }
  this.RaiseCloseUp(indexPath);
 },
 DoHidePopupMenuIFrame: function(element) {
  if(!this.renderIFrameForPopupElements) return;
  var iFrame = element.overflowElement;
  if(iFrame)
   ASPx.SetElementDisplay(iFrame, false);
 },
 DoHidePopupMenuBorderCorrector: function(element) {
  var borderCorrectorElement = element.borderCorrectorElement;
  if(borderCorrectorElement) {
   ASPx.SetElementVisibility(borderCorrectorElement, false);
   ASPx.SetElementDisplay(borderCorrectorElement, false);
   element.borderCorrectorElement = null;
  }
 },
 SetHoverElement: function(element) {
  if(!this.IsStateControllerEnabled()) return;
  this.lockHoverEvents = true;
  ASPx.GetStateController().SetCurrentHoverElementBySrcElement(element);
  this.lockHoverEvents = false;
 },
 ApplySubMenuItemHoverItem: function(element, hoverItem, hoverElement) {
  if(!element.hoverItem & ASPx.GetElementDisplay(element)) {
   var newHoverItem = hoverItem.Clone();
   element.hoverItem = newHoverItem;
   element.hoverElement = hoverElement;
   newHoverItem.Apply(hoverElement);
  }
 },
 CancelSubMenuItemHoverItem: function(element) {
  if(element.hoverItem) {
   element.hoverItem.Cancel(element.hoverElement);
   element.hoverItem = null;
   element.hoverElement = null;
  }
 },
 ShowSubMenu: function(indexPath) {
  var element = this.GetMenuElement(indexPath);
  if(element != null) {
   var level = this.GetMenuLevel(indexPath);
   aspxGetMenuCollection().DoHidePopupMenus(null, level - 1, this.name, false, element.id);
   if(!ASPx.GetElementDisplay(element, true) & this.IsItemEnabled(indexPath))
    this.DoShowPopupMenu(element, ASPx.InvalidPosition, ASPx.InvalidPosition, indexPath);
  }
  this.ClearAppearTimer();
 },
 SelectItem: function(indexPath) {
  if(!this.IsStateControllerEnabled()) return;
  var element = this.GetItemContentElement(indexPath);
  if(element != null)
   ASPx.GetStateController().SelectElementBySrcElement(element);
 },
 DeselectItem: function(indexPath) {
  if(!this.IsStateControllerEnabled()) return;
  var element = this.GetItemContentElement(indexPath);
  if(element != null) {
   var hoverItem = null;
   var hoverElement = null;
   var menuElement = this.GetMenuElement(indexPath);
   if(menuElement & menuElement.hoverItem) {
    hoverItem = menuElement.hoverItem;
    hoverElement = menuElement.hoverElement;
    this.CancelSubMenuItemHoverItem(menuElement);
   }
   ASPx.GetStateController().DeselectElementBySrcElement(element);
   if(menuElement != null & hoverItem != null)
    this.ApplySubMenuItemHoverItem(menuElement, hoverItem, hoverElement);
  }
 },
 InitializeSelectedItem: function() {
  if(!this.allowSelectItem) return;
  this.SelectItem(this.GetSelectedItemIndexPath());
 },
 GetSelectedItemIndexPath: function() {
  return this.selectedItemIndexPath;
 },
 SetSelectedItemInternal: function(indexPath, modifyHotTrackSelection) {
  if(modifyHotTrackSelection)
   this.SetHoverElement(null);
  this.DeselectItem(this.selectedItemIndexPath);
  this.selectedItemIndexPath = indexPath;
  var item = this.GetItemByIndexPath(indexPath);
  if(item == null || item.GetEnabled())
   this.SelectItem(this.selectedItemIndexPath);
  if(modifyHotTrackSelection) {
   var element = this.GetItemContentElement(indexPath);
   if(element != null)
    this.SetHoverElement(element);
  }
 },
 InitializeCheckedItems: function() {
  if(!this.allowCheckItems) return;
  var indexPathes = this.checkedState.split(";");
  for(var i = 0; i &lt; indexPathes.length; i++) {
   if(indexPathes[i] != "") {
    this.checkedItems.push(indexPathes[i]);
    this.SelectItem(indexPathes[i]);
   }
  }
 },
 ChangeCheckedItem: function(indexPath) {
  this.SetHoverElement(null);
  var itemsGroup = this.GetItemsGroup(indexPath);
  if(itemsGroup != null) {
   if(itemsGroup.length &gt; 1) {
    if(!this.IsCheckedItem(indexPath)) {
     for(var i = 0; i &lt; itemsGroup.length; i++) {
      if(itemsGroup[i] == indexPath) continue;
      if(this.IsCheckedItem(itemsGroup[i])) {
       ASPx.Data.ArrayRemove(this.checkedItems, itemsGroup[i]);
       this.DeselectItem(itemsGroup[i]);
      }
     }
     this.SelectItem(indexPath);
     this.checkedItems.push(indexPath);
    }
   }
   else {
    if(this.IsCheckedItem(indexPath)) {
     ASPx.Data.ArrayRemove(this.checkedItems, indexPath);
     this.DeselectItem(indexPath);
    }
    else {
     this.SelectItem(indexPath);
     this.checkedItems.push(indexPath);
    }
   }
  }
  var element = this.GetItemContentElement(indexPath);
  if(element != null)
   this.SetHoverElement(element);
 },
 GetItemsGroup: function(indexPath) {
  for(var i = 0; i &lt; this.itemCheckedGroups.length; i++) {
   if(ASPx.Data.ArrayIndexOf(this.itemCheckedGroups[i], indexPath) &gt; -1)
    return this.itemCheckedGroups[i];
  }
  return null;
 },
 IsCheckedItem: function(indexPath) {
  return ASPx.Data.ArrayIndexOf(this.checkedItems, indexPath) &gt; -1;
 },
 UpdateStateObject: function(){
  this.UpdateStateObjectWithObject({ selectedItemIndexPath: this.selectedItemIndexPath, checkedState: this.GetCheckedState() });
 },
 GetCheckedState: function() {
  var state = "";
  for(var i = 0; i &lt; this.checkedItems.length; i++) {
   state += this.checkedItems[i];
   if(i &lt; this.checkedItems.length - 1)
    state += ";";
  }
  return state;
 },
 GetAnimationVerticalDirection: function(indexPath, popupPosition, isVertical) {
  var verticalDirection = (this.IsRootItem(indexPath) & !isVertical) ? -1 : 0;
  if(popupPosition.isInverted) verticalDirection *= -1;
  return verticalDirection;
 },
 GetAnimationHorizontalDirection: function(indexPath, popupPosition, isVertical) {
  var horizontalDirection = (this.IsRootItem(indexPath) & !isVertical) ? 0 : -1;
  if(popupPosition.isInverted) horizontalDirection *= -1;
  return horizontalDirection;
 },
 StartAnimation: function(animationDivElement, indexPath, horizontalPopupPosition, verticalPopupPosition, isVertical) {
  var element = this.GetMenuMainElement(animationDivElement);
  var clientX = horizontalPopupPosition.position;
  var clientY = verticalPopupPosition.position;
  ASPx.PopupUtils.InitAnimationDiv(animationDivElement, clientX, clientY);
  var verticalDirection = this.GetAnimationVerticalDirection(indexPath, verticalPopupPosition, isVertical);
  var horizontalDirection = this.GetAnimationHorizontalDirection(indexPath, horizontalPopupPosition, isVertical);
  var yPos = verticalDirection * element.offsetHeight;
  var xPos = horizontalDirection * element.offsetWidth;
  ASPx.SetStyles(element, { left: xPos, top: yPos });
  ASPx.SetElementVisibility(animationDivElement, true);
  if(this.enableSubMenuFullWidth)
   this.ApplySubMenuFullWidth(animationDivElement);
  this.DoShowPopupMenuIFrame(animationDivElement, clientX, clientY, 0, 0, indexPath);
  this.DoShowPopupMenuBorderCorrector(animationDivElement, clientX, clientY, indexPath,
   horizontalPopupPosition.isInverted, verticalPopupPosition.isInverted);
  ASPx.PopupUtils.StartSlideAnimation(animationDivElement, element, this.GetMenuIFrameElement(indexPath), this.slideAnimationDuration, this.enableSubMenuFullWidth, false);
 },
 OnItemClick: function(indexPath, evt) {
  var sourceElement = ASPx.Evt.GetEventSource(evt);
  var clickedLinkElement = ASPx.GetParentByTagName(sourceElement, "A");
  var isLinkClicked = (clickedLinkElement != null & clickedLinkElement.href != ASPx.AccessibilityEmptyUrl);
  var element = this.GetItemContentElement(indexPath);
  var linkElement = (element != null) ? (element.tagName === "A" ? element : ASPx.GetNodeByTagName(element, "A", 0)) : null;
  if(linkElement != null & linkElement.href == ASPx.AccessibilityEmptyUrl)
   linkElement = null;
  if(this.allowSelectItem)
   this.SetSelectedItemInternal(indexPath, true);
  if(this.allowCheckItems)
   this.ChangeCheckedItem(indexPath);
  this.DoItemClick(indexPath, isLinkClicked || (linkElement != null), evt);
  if(!isLinkClicked & linkElement != null && !(ASPx.Browser.WebKitTouchUI && this.HasChildren(indexPath)))
   ASPx.Url.NavigateByLink(linkElement);
 },
 OnItemDropDownClick: function(indexPath, evt) {
  if(this.IsItemEnabled(indexPath))
   this.keyboardHelper.ShowSubMenuAccessible(indexPath);
 },
 AfterItemOverAllowed: function(hoverItem) {
  return hoverItem.name != "" & !this.lockHoverEvents;
 },
 OnAfterItemOver: function(hoverItem, hoverElement) {
  if(!this.AfterItemOverAllowed(hoverItem)) return;
  if(!this.showSubMenus) {
   this.savedCallbackHoverItem = hoverItem;
   this.savedCallbackHoverElement = hoverElement;
   return;
  }
  this.ClearDisappearTimer();
  this.ClearAppearTimer();
  var indexPath = this.GetMenuIndexPathById(hoverItem.name);
  if(indexPath == "") {
   indexPath = this.GetItemIndexPathById(hoverItem.name);
   var canShowSubMenu = true;
   if(this.IsDropDownItem(indexPath)) {
    var popOutImageElement = this.GetItemPopOutElement(indexPath);
    if(popOutImageElement != null & popOutImageElement != hoverElement) {
     hoverItem.needRefreshBetweenElements = true;
     canShowSubMenu = false;
    }
   }
   var preventSubMenu = !(canShowSubMenu & hoverItem.enabled && hoverItem.kind == ASPx.HoverItemKind);
   this.SetAppearTimer(indexPath, preventSubMenu);
   this.RaiseItemMouseOver(indexPath);
  }
 },
 OnBeforeItemOver: function(hoverItem, hoverElement) {
  if(ASPx.Browser.NetscapeFamily & ASPx.IsExists(hoverElement.offsetParent) &&
    hoverElement.offsetParent.style.borderCollapse == "collapse") {
   hoverElement.offsetParent.style.borderCollapse = "separate";
   hoverElement.offsetParent.style.borderCollapse = "collapse";
  }
  var indexPath = this.GetItemIndexPathById(hoverItem.name);
  var element = this.GetMenuElement(indexPath);
  if(element) this.CancelSubMenuItemHoverItem(element);
 },
 OnItemOverTimer: function(indexPath, preventSubMenu) {
  var element = this.GetMenuElement(indexPath);
  if(element == null || preventSubMenu) {
   var level = this.GetMenuLevel(indexPath);
   aspxGetMenuCollection().DoHidePopupMenus(null, level - 1, this.name, false, "");
  }
  if(this.IsAppearTimerActive() & !preventSubMenu) {
   this.ClearAppearTimer();
   if(this.GetItemContentElement(indexPath) != null || this.GetItemPopOutElement(indexPath) != null) {
    this.ShowSubMenu(indexPath);
   }
  }
 },
 OnBeforeItemDisabled: function(disabledItem, disabledElement) {
  this.ClearAppearTimer();
  var indexPath = this.GetItemIndexPathById(disabledElement.id);
  if(indexPath != "") {
   var element = this.GetMenuElement(indexPath);
   if(element != null) this.DoHidePopupMenu(null, element);
  }
 },
 OnAfterItemOut: function(hoverItem, hoverElement, newHoverElement) {
  if(!this.showSubMenus) {
   this.savedCallbackHoverItem = null;
   this.savedCallbackHoverElement = null;
  }
  if(hoverItem.name == "" || this.lockHoverEvents) return;
  if(hoverItem.IsChildElement(newHoverElement)) return;
  var indexPath = this.GetItemIndexPathById(hoverItem.name);
  var element = this.GetMenuElement(indexPath);
  this.ClearDisappearTimer();
  this.ClearAppearTimer();
  if(element == null || !ASPx.GetIsParent(element, newHoverElement))
   this.SetDisappearTimer();
  if(element != null)
   this.ApplySubMenuItemHoverItem(element, hoverItem, hoverElement);
  if(indexPath != "")
   this.RaiseItemMouseOut(indexPath);
 },
 OnItemOutTimer: function() {
  if(this.IsDisappearTimerActive()) {
   this.ClearDisappearTimer();
   if(aspxGetMenuCollection().CheckFocusedElement())
    this.SetDisappearTimer();
   else
    this.OnHideByItemOut();
  }
 },
 OnHideByItemOut: function() {
  aspxGetMenuCollection().DoHidePopupMenus(null, 0, this.name, true, "");
 },
 TryFocusItem: function(itemIndex) {
  var item = this.GetItem(itemIndex);
  if(item.GetVisible() & item.GetEnabled()) {
   this.FocusItemByIndexPath(item.GetIndexPath());
   return true;
  }
  return false;
 },
 Focus: function() {
  if(this.rootItem != null) { 
   for(var i = 0; i &lt; this.GetItemCount() ; i++) {
    if(this.TryFocusItem(i))
     return true;
   }
  }
  else
   this.keyboardHelper.FocusNextItem("-1");
 },
 FocusLastItem: function() {
  if(this.rootItem != null) { 
   for(var i = this.GetItemCount() - 1; i &gt;= 0; i--) {
    if(this.TryFocusItem(i))
     return true;
   }
  }
  else
   this.keyboardHelper.FocusPrevItem(this.GetItemCount() - 1);
 },
 FocusItemByIndexPath: function(indexPath) {
  this.keyboardHelper.FocusItemByIndexPath(indexPath);
 },
 OnFocusedItemKeyDown: function(evt, focusedItem) {
  this.keyboardHelper.OnFocusedItemKeyDown(evt, focusedItem);
 },
 ProcessLostFocus: function(evt) {
  if(!this.isContextMenu || !this.accessibilityCompliant) return;
  if(this.accessibleFocusElement) {
   this.accessibleFocusElement.focus();
   this.accessibleFocusElement = null;
  }
  this.Hide();
  if(evt)
   ASPx.Evt.PreventEventAndBubble(evt);
 },
 OnCallback: function(result) {
  ASPx.InitializeScripts(); 
  this.InitializeScrollableMenus();
  for (var indexPath in result) {
   if(result.hasOwnProperty(indexPath)) {
    var menuElement = this.GetMenuElement(indexPath);
    if(menuElement) {
     var menuResult = result[indexPath];
     if(aspxGetMenuCollection().IsSubMenuVisible(menuElement.id))
      this.ShowPopupSubMenuAfterCallback(menuElement, menuResult);
     else
      this.SetSubMenuInnerHtml(menuElement, menuResult);
    }
   }
  }
  this.ClearVerticalAlignedElementsCache();
  this.CorrectVerticalAlignment(ASPx.AdjustHeight, this.GetPopOutElements, "PopOut");
  this.CorrectVerticalAlignment(ASPx.AdjustVerticalMargins, this.GetPopOutImages, "PopOutImg");
  this.InitializeInternal(false);
  if(!this.showSubMenus) {
   this.showSubMenus = true;
   if(this.savedCallbackHoverItem != null & this.savedCallbackHoverElement != null)
    this.OnAfterItemOver(this.savedCallbackHoverItem, this.savedCallbackHoverElement);
   this.savedCallbackHoverItem = null;
   this.savedCallbackHoverElement = null;
  }
 },
 SetSubMenuInnerHtml: function(menuElement, html) {
  ASPx.SetInnerHtml(this.GetMenuMainElement(menuElement), html);
  this.dropElementsCache = true;
  this.renderHelper.InlineInitializePopupMenuMenuElement(menuElement, this.GetIndexPathById(menuElement.id, true));
  this.renderHelper.CalculateSubMenu(menuElement, true);
 },
 ShowPopupSubMenuAfterCallback: function(element, callbackResult) {
  var indexPath = this.GetIndexPathById(element.id, true);
  var currentX = ASPx.PxToInt(element.style.left);
  var currentY = ASPx.PxToInt(element.style.top);
  var showedToTheTop = this.ShowedToTheTop(element, indexPath);
  var showedToTheLeft = this.ShowedToTheLeft(element, indexPath);
  ASPx.SetStyles(element, {
   left: ASPx.InvalidPosition, top: ASPx.InvalidPosition
  });
  this.SetSubMenuInnerHtml(element, callbackResult);
  var vertPos = this.GetClientSubMenuPos(element, indexPath, ASPx.InvalidPosition, this.IsVertical(indexPath), false);
  var clientY = vertPos.position;
  var toTheTop = vertPos.isInverted;
  if(!this.IsVertical(indexPath) & showedToTheTop != toTheTop) {
   clientY = currentY;
   toTheTop = showedToTheTop;
  }
  var scrollHelper = this.GetScrollHelper(indexPath);
  if(scrollHelper) {
   var yClientCorrection = this.GetScrollSubMenuYCorrection(element, scrollHelper, clientY);
   if(yClientCorrection &gt; 0)
    clientY += yClientCorrection;
  }
  ASPx.SetStyles(element, { left: currentX, top: clientY });
  if(this.enableSubMenuFullWidth)
   this.ApplySubMenuFullWidth(element);
  this.DoShowPopupMenuIFrame(element, currentX, clientY, ASPx.InvalidDimension, ASPx.InvalidDimension, indexPath);
  this.DoShowPopupMenuBorderCorrector(element, currentX, clientY, indexPath, showedToTheLeft, toTheTop);
  ASPx.GetControlCollection().AdjustControls(element);
 },
 ShowedToTheTop: function(element, indexPath) {
  var currentY = ASPx.PxToInt(element.style.top);
  var parentBottomY = this.GetSubMenuYPosition(indexPath, this.IsVertical(indexPath));
  return currentY &lt; parentBottomY;
 },
 ShowedToTheLeft: function(element, indexPath) {
  var currentX = ASPx.PxToInt(element.style.left);
  var parentX = this.GetSubMenuXPosition(indexPath, this.IsVertical(indexPath));
  return currentX &lt; parentX;
 },
 CreateItems: function(items) {
  if (items.length == 0)
   return;
  if(this.NeedCreateItemsOnClientSide())
   this.CreateClientItems(items);
  else
   this.CreateServerItems(items);
 },
 AddItem: function(item) {
  this.CreateClientItems([item]);
 },
 CreateClientItems: function(items) {
  this.PreInitializeClientMenuItems();
  this.rootItem.CreateItems(items);
  this.RenderItems(this.rootItem.items);
  this.InitializeClientItems();
 },
 CreateServerItems: function(items) {
  this.CreateRootItemIfRequired();
  this.rootItem.CreateItems(items);
 },
 PreInitializeClientMenuItems: function() {
  if(!this.rootMenuSample)
   this.InitializeMenuSamples();
  this.CreateRootItemIfRequired();
  if(!this.renderData)
   this.CreateRenderData();
 },
 InitializeClientItems: function() {
  this.dropElementsCache = true;
  this.renderHelper.InlineInitializeElements();
  this.ApplyItemsProperties(this.rootItem.items);
  this.InitializeEnabledAndVisible(true);
  if(this.isPopupMenu)
   this.renderHelper.CalculateSubMenu(this.GetMainElement(), true);
  else
   this.renderHelper.CalculateMenuControl(this.GetMainElement(), true);
 },
 ApplyItemsProperties: function(items) {
  var itemsCount = items.length;
  if(itemsCount == 0)
   return;
  for(var i = 0; i &lt; itemsCount; i++) {
   var item = items[i];
   this.ApplyItemProperties(item);
   this.ApplyItemsProperties(item.items);
  }
 },
 ApplyItemProperties: function(item) {
  var indexPath = item.GetIndexPath();
  if(item.imageUrl)
   this.SetItemImageUrl(indexPath, item.imageUrl);
  if(item.imageClassName)
   this.AddItemImageClassName(indexPath, item.imageClassName);
  if(item.navigateUrl)
   this.SetItemNavigateUrl(indexPath, item.navigateUrl, item.target);
  if(item.tooltip != "")
   this.SetItemTooltip(indexPath, item.tooltip);
  this.FindTextNode(indexPath).parentNode.innerHTML = this.HtmlEncode(item.text);
  this.SetItemChecked(indexPath, item.checked);
  if(item.textTemplate)
   this.SetItemTextTemplate(indexPath, item.textTemplate);
 },
 ProcessItemGroupName: function(item, groupName) {
  if(this.allowSelectItem || !groupName)
   return;
  this.allowCheckItems = true;
  var groupNames = this.itemCheckedGroups.groupNames;
  if(groupNames[groupName])
   groupNames[groupName].push(item.indexPath);
  else {
   groupNames[groupName] = [item.indexPath];
   this.itemCheckedGroups.push(groupNames[groupName]);
  }
  item.checkedGroup = groupNames[groupName];
 },
 CreateRootItemIfRequired: function() {
  if(!this.rootItem) {
   var itemType = this.GetClientItemType();
   this.rootItem = new itemType(this, null, 0, "");
  }
 },
 ClearRootMenuElement: function() {
  var wrapperElement = this.GetMainElement().parentNode;
  wrapperElement.innerHTML = "";
  wrapperElement.appendChild(this.rootMenuSample.cloneNode(true));
 }, 
 NeedAppendToRenderData: function(item) {
  return this.NeedCreateItemsOnClientSide() & item.visible || typeof(item.visible) == "undefined";
 },
 ClearItems: function() {
  this.PreInitializeClientMenuItems();
  this.ClearRootMenuElement();
  this.ClearRenderData();
  this.rootItem.items = [];
  this.checkedItems = [];
 },
 GetSampleNode: function(sampleHtml) {
  return ASPx.CreateHtmlElementFromString(sampleHtml);
 },
 GetParentItem: function(rootItemIndexPath) {
  if(!rootItemIndexPath)
   return this.rootItem;
  return this.GetItemByIndexPath(rootItemIndexPath);
 },
 RenderItems: function(items) {
  for(var i=0; i &lt; items.length; i++) {
   var item = items[i];
   this.RenderItemIfRequired(item);
   this.RenderItems(item.items);
  }
 },
 RenderItemIfRequired: function(item) {
  if(!this.GetItemElement(item.indexPath)) {
   var isRootItem = !this.GetItemElement(item.parent.indexPath);
   var rootMenuElement = this.GetOrRenderRootItem(item, isRootItem);
   this.RenderItemInternal(rootMenuElement, item, isRootItem);
   this.ApplyStylesToRenderItem(item, isRootItem);
  }
 },
 ApplyStylesToRenderItem: function(item, isRootItem) {
  var styles = JSON.parse(JSON.stringify(isRootItem ? this.samples.itemsStyles : this.samples.subitemsStyles));
  var hoverStyle = styles.hover;
  var disabledStyle = styles.disable;
  var selectedStyle = styles.select;
  var checkedStyle = styles.check;
  var itemElementId = this.GetItemElementId(item.indexPath);
  if(item.styles & item.styles.ho) {
   var itemHover = item.styles.ho;
   if(!!itemHover.style)
    hoverStyle.cssTexts[0] = itemHover.style;
   if(!!itemHover.cssClass)
    hoverStyle.classNames[0] += " " + itemHover.cssClass;
  }
  if(item.styles & item.styles.st) {
   var itemElement = this.GetItemElement(item.indexPath);
   var style = item.styles.st;
   itemElement.setAttribute("style", style.style);
   if(!!style.cssClass)
    ASPx.AddClassNameToElement(itemElement, style.cssClass);
  }
  ASPx.GetStateController().AddHoverItem(itemElementId, hoverStyle.classNames || [MenuCssClasses.ItemHovered], hoverStyle.cssTexts || [""], hoverStyle.postfixes || [""], item.imageHottrackSrc ? [item.imageHottrackSrc] : null, [Constants.ImagePostfix, Constants.PopupImagePostfix], false);
  ASPx.GetStateController().AddDisabledItem(itemElementId, disabledStyle.classNames || [MenuCssClasses.Disabled], disabledStyle.cssTexts || [""], disabledStyle.postfixes || [""], null, null, false);
  if(selectedStyle & this.allowSelectItem)
   ASPx.GetStateController().AddSelectedItem(itemElementId, selectedStyle.classNames || [MenuCssClasses.ItemSelected], selectedStyle.cssTexts || [""], selectedStyle.postfixes || [""], null, null, false);
  else if(checkedStyle & this.allowCheckItems && item.checkedGroup.length) {
   var checkedClassName = null;
   if(!item.imageClassName)
    checkedClassName = [this.samples.checkedClassName];
   ASPx.GetStateController().AddSelectedItem(itemElementId, checkedStyle.classNames || [MenuCssClasses.ItemChecked], checkedStyle.cssTexts || [""], checkedStyle.postfixes || [""], checkedClassName, ['Img'], false);
  }
 },
 GetOrRenderRootItem: function(item, isRootItem) {
  if(!isRootItem) {
   var rootMenuElement = this.GetMenuElement(item.parent.indexPath);
   return rootMenuElement ? rootMenuElement : this.RenderSubMenuItem(item.parent.indexPath);
  } else
   return this.GetMenuElement("");
 },
 RenderItemInternal: function(rootItem, item, isRootItem) {
  var contentElement = this.renderHelper.GetContentElement(rootItem);
  var element = this.CreateItemElement(item, isRootItem);
  this.RenderSeparatorElementIfRequired(contentElement, item);
  this.RenderSpaceElementIfRequired(contentElement, item);
  contentElement.appendChild(element);
 },
 RenderSeparatorElementIfRequired: function(rootItem, item) {
  if(item.beginGroup & item.index > 0) {
   var separatorElement = this.CreateSeparatorElement(item.indexPath);
   rootItem.appendChild(separatorElement);
  }
 },
 RenderSpaceElementIfRequired: function(rootItem, item) {
  if(!item.beginGroup & item.index > 0 && rootItem.childNodes.length > 0) {
   var spacingElement = this.CreateSpacingElement(item.indexPath);
   rootItem.appendChild(spacingElement);
  }
 },
 RenderSubMenuItem: function(indexPath) {
  var subMenuElement = this.CreateSubMenuElement(indexPath);
  this.GetMainElement().parentElement.appendChild(subMenuElement);
  return subMenuElement;
 },
 HasSeparatorOnCurrentPosition: function(itemElements, position) {
  return itemElements[position - 1 &gt; 0 ? position - 1 : 0].className.indexOf(MenuCssClasses.Separator) &gt; -1;
 },
 CreateItemElement: function(item, isRootItem) {
  var itemSample = isRootItem ? this.GetRootItemSample(item) : this.GetSubitemSample(item);
  var itemElement = itemSample.cloneNode(true);
  itemElement.id = this.GetItemElementId(item.indexPath);
  return itemElement;
 },
 GetRootItemSample: function(item) {
  return this.GetItemSample(this.samples.rootItems, item);
 },
 GetSubitemSample: function(item) {
  return this.GetItemSample(this.samples.submenuItems, item);
 },
 GetItemSample: function(samples, item) {
  var key = this.sampleItemsFlags.TextOnly;
  if(item.items.length &gt; 0)
   key = key | this.sampleItemsFlags.SubItems;
  if(item.imageUrl)
   key = key | this.sampleItemsFlags.Image;
  if(item.navigateUrl)
   key = key | this.sampleItemsFlags.NavigateUrl;
  if(item.dropDownMode)
   key = key | this.sampleItemsFlags.DropDownMode;
  if(item.checkedGroup.length)
   key = key | this.sampleItemsFlags.CheckBox;
  if(item.imageClassName)
   key = key | this.sampleItemsFlags.ImageClassName;
  return samples[key];
 },
 CreateSpacingElement: function(indexPath) {
  var item = this.samples.spacing.cloneNode();
  item.id = this.GetItemIndentElementId(indexPath);
  return item;
 },
 CreateSeparatorElement: function(indexPath) {
  var item = this.samples.separator.cloneNode(true);
  item.id = this.GetItemSeparatorElementId(indexPath);
  return item;
 },
 CreateSubMenuElement: function(indexPath) {
  var subMenu = this.samples.submenu.cloneNode(true);
  subMenu.id =  this.name + Constants.MMIdSuffix + indexPath + "_";
  return subMenu;
 },
 AppendToRenderData: function(rootItemIndexPath, index) {
  if(rootItemIndexPath) {
   if(!this.renderData[rootItemIndexPath])
    this.renderData[rootItemIndexPath] = [[index]];
   this.renderData[rootItemIndexPath][index] = [index];
  } else {
   this.renderData[""].push([[index]]);
  }
 },
 CreateRenderData: function() {
  this.renderData = {"" : []};
 },
 ClearRenderData: function() {
  this.renderData = null;
 },
 GetClientItemType: function() {
  return ASPxClientMenuItem;
 },
 GetItemByIndexPath: function(indexPath) {
  var item = this.rootItem;
  if(indexPath != "" & item != null) {
   var indexes = this.GetItemIndexes(indexPath);
   for(var i = 0; i &lt; indexes.length; i++)
    item = item.GetItem(indexes[i]);
  }
  return item;
 },
 GetLinkElementByIndexPath: function(indexPath) {
  var itemElement = this.GetItemElement(indexPath);
  return ASPx.GetNodeByTagName(itemElement, "A", 0);
 },
 SetItemChecked: function(indexPath, checked) {
  var itemsGroup = this.GetItemsGroup(indexPath);
  if(itemsGroup != null) {
   if(!checked & this.IsCheckedItem(indexPath)) {
    ASPx.Data.ArrayRemove(this.checkedItems, indexPath);
    this.DeselectItem(indexPath);
   }
   else if(checked & !this.IsCheckedItem(indexPath)) {
    if(itemsGroup.length > 1) {
     for(var i = 0; i &lt; itemsGroup.length; i++) {
      if(itemsGroup[i] == indexPath) continue;
      if(this.IsCheckedItem(itemsGroup[i])) {
       ASPx.Data.ArrayRemove(this.checkedItems, itemsGroup[i]);
       this.DeselectItem(itemsGroup[i]);
      }
     }
    }
    this.SelectItem(indexPath);
    this.checkedItems.push(indexPath);
   }
   if(this.accessibilityCompliant) {
    var link = this.GetLinkElementByIndexPath(indexPath);
    if(link)
     ASPx.Attr.SetAttribute(link, "aria-checked", checked ? "true" : "false");
   }
  }
 },
 ChangeItemEnabledAttributes: function(indexPath, enabled) {
  this.renderHelper.ChangeItemEnabledAttributes(this.GetItemElement(indexPath), enabled, this.accessibilityCompliant);
 },
 IsItemEnabled: function(indexPath) {
  var item = this.GetItemByIndexPath(indexPath);
  return (item != null) ? item.GetEnabled() : true;
 },
 SetItemEnabled: function(indexPath, enabled, initialization) {
  if(indexPath == "" || !this.GetItemByIndexPath(indexPath).enabled) return;
  if(!enabled) {
   if(this.GetSelectedItemIndexPath() == indexPath)
    this.DeselectItem(indexPath);
  }
  if(!initialization || !enabled)
   this.ChangeItemEnabledStateItems(indexPath, enabled);
  this.ChangeItemEnabledAttributes(indexPath, enabled);
  if(enabled) {
   if(this.GetSelectedItemIndexPath() == indexPath)
    this.SelectItem(indexPath);
  }
 },
 ChangeItemEnabledStateItems: function(indexPath, enabled) {
  if(!this.IsStateControllerEnabled()) return;
  var element = this.GetItemElement(indexPath);
  if(element)
   ASPx.GetStateController().SetElementEnabled(element, enabled);
 },
 GetItemImageUrl: function(indexPath) {
  var image = this.GetItemImage(indexPath);
  if(image)
   return image.src;
  return "";
 },
 SetItemImageUrl: function(indexPath, url) {
  var image = this.GetItemImage(indexPath);
  if(image)
   image.src = url;
 },
 AddItemImageClassName: function(indexPath, className) {
  var image = this.GetItemImage(indexPath);
  if(image) {
   var accessibilityElement = image.parentNode;
   if(accessibilityElement.tagName == "SPAN")
    ASPx.AddClassNameToElement(accessibilityElement, className);
   else
    ASPx.AddClassNameToElement(image, className);
  }
 },
 GetItemImage: function(indexPath) {
  var element = this.GetItemContentElement(indexPath);
  if(element != null) {
   var img = ASPx.GetNodeByTagName(element, "IMG", 0);
   if(img != null)
    return img;
  }
 },
 GetItemNavigateUrl: function(indexPath) {
  var element = this.GetItemContentElement(indexPath);
  if(element != null & element.tagName === "A")
   return ASPx.Attr.GetAttribute(element, "savedhref") || element.href;
  if(element != null) {
   var link = ASPx.GetNodeByTagName(element, "A", 0);
   if(link != null)
    return ASPx.Attr.GetAttribute(link, "savedhref") || link.href;
  }
  return "";
 },
 SetUrl: function(link, url, target) {
  if(link != null) {
   if(ASPx.Attr.IsExistsAttribute(link, "savedhref"))
    ASPx.Attr.SetAttribute(link, "savedhref", url);
   else if(ASPx.Attr.IsExistsAttribute(link, "href"))
    link.href = url;
   if(!!target)
    link.target = target;
  }
 },
 SetItemNavigateUrl: function(indexPath, url, target) {
  var element = this.GetItemContentElement(indexPath);
  if(element != null) {
   if(element.tagName === "A")
    this.SetUrl(element, url, target);
   else {
    this.SetUrl(ASPx.GetNodeByTagName(element, "A", 0), url, target);
    this.SetUrl(ASPx.GetNodeByTagName(element, "A", 1), url, target);
   }
  }
 },
 FindTextNode: function(indexPath) {
  var element = this.GetItemContentElement(indexPath);
  if(element) {
   var link = this.GetLinkElementByIndexPath(indexPath); 
   if(link)
    return ASPx.GetNormalizedTextNode(link);
   var titleSpan = ASPx.GetNodeByTagName(element, "SPAN", 0); 
   if(titleSpan)
    return ASPx.GetNormalizedTextNode(titleSpan);
   for(var i = 0; i &lt; element.childNodes.length; i++) { 
    var child = element.childNodes[i];
    if(child.nodeValue & (ASPx.Str.Trim(child.nodeValue) != "")) {
     ASPx.MergeAdjacentTextNodes(child);
     return child;
    }
   }
   return ASPx.GetNormalizedTextNode(element);
  }
  return null;
 },
 GetItemText: function(indexPath) {
  var textNode = this.FindTextNode(indexPath);
  return textNode
   ? ASPx.Str.Trim(textNode.nodeValue) 
   : "";
 },
 SetItemText: function(indexPath, text) {
  var textNode = this.FindTextNode(indexPath);
  if(textNode) {
   textNode.nodeValue = text;
   var menuElement = this.GetMenuElement(this.GetParentIndexPath(indexPath));
   if(menuElement & !this.IsRootItem(indexPath))
    this.renderHelper.CalculateSubMenu(menuElement, true);
   if(this.IsRootItem(indexPath) & !this.isPopupMenu) {
    var itemElement = this.GetItemElement(indexPath);
    if(itemElement)
     this.renderHelper.CalculateItemMinSize(itemElement, true);
   }
   this.AdjustControl();
  }
 },
 SetItemTextTemplate: function(indexPath, textTemplate) {
  var contentElement = this.GetItemContentElement(indexPath),
   textElement = ASPx.GetChildByClassName(contentElement, MenuCssClasses.ItemTextElement, 1),
   container = document.createElement("DIV");
  container.innerHTML = textTemplate;
  contentElement.replaceChild(container.firstChild, textElement);
 },
 SetItemTooltip: function(indexPath, tooltip) {
  var itemElement = this.GetItemElement(indexPath);
  if(itemElement & tooltip)
   itemElement.title = tooltip;
 },
 SetItemVisible: function(indexPath, visible, initialization) {
  var item = this.GetItemByIndexPath(indexPath);
  if(indexPath == "" || !item.visible) return;
  if(visible & initialization) return;
  var element = this.GetItemElement(indexPath);
  if(element != null)
   ASPx.SetElementDisplay(element, visible);
  this.SetIndentsVisiblility(indexPath);
  this.SetSeparatorsVisiblility(indexPath);
  if(!this.IsItemInAdaptiveMenu(item))
   this.UpdateItemCssClasses(indexPath, visible);
  var parent = this.GetItemByIndexPath(indexPath).parent;
  var parentHasVisibleItems = this.HasVisibleItems(parent);
  if(this.IsRootItem(indexPath) & !this.isPopupMenu) {
   if(this.clientVisible)
    ASPx.SetElementDisplay(this.GetMainElement(), parentHasVisibleItems);
  }
  else
   this.SetPopOutElementVisible(parent.indexPath, parentHasVisibleItems);
  var parentIndexPath = this.GetParentIndexPath(indexPath); 
  if(!this.IsRootItem(parentIndexPath) || this.isPopupMenu) {
   var menuElement = this.GetMenuElement(parentIndexPath);
   if(menuElement) 
    this.renderHelper.CalculateSubMenu(menuElement, true);
  }
  if(this.IsRootItem(indexPath) & !this.isPopupMenu) 
   this.renderHelper.CalculateMenuControl(this.GetMainElement(), true);
 },
 SetIndentsVisiblility: function(indexPath) {
  var parent = this.GetItemByIndexPath(indexPath).parent;
  for(var i = 0; i &lt; parent.GetItemCount() ; i++) {
   var item = parent.GetItem(i);
   var separatorVisible = this.HasPrevVisibleItems(parent, i) & item.GetVisible();
   var element = this.GetItemIndentElement(item.GetIndexPath());
   if(element != null) ASPx.SetElementDisplay(element, separatorVisible);
  }
 },
 SetSeparatorsVisiblility: function(indexPath) {
  var parent = this.GetItemByIndexPath(indexPath).parent;
  for(var i = 0; i &lt; parent.GetItemCount() ; i++) {
   var item = parent.GetItem(i);
   var separatorVisible = this.HasPrevVisibleItems(parent, i) & (item.GetVisible() || this.HasNextVisibleItemInGroup(parent, i));
   var element = this.GetItemSeparatorElement(item.GetIndexPath());
   if(element != null) ASPx.SetElementDisplay(element, separatorVisible);
  }
 },
 UpdateItemCssClasses: function(indexPath, visible) {
 },
 SetPopOutElementVisible: function(indexPath, visible) {
  var popOutElement = this.GetItemPopOutElement(indexPath);
  if(popOutElement)
   ASPx.SetElementDisplay(popOutElement, visible);
 },
 GetPrevVisibleItemInGroup: function(parent, index, skipItemsInAdaptiveMenu) {
  if(this.IsItemBeginsGroup(parent.GetItem(index)))
   return null;
  for(var i = index - 1; i &gt;= 0; i--) {
   var item = parent.GetItem(i);
   if(item.GetVisible() & !this.IsAdaptiveItem(item.indexPath) && (!skipItemsInAdaptiveMenu || !this.IsItemInAdaptiveMenu(item)))
    return item;
   if(this.IsItemBeginsGroup(item))
    return null;
  }
  return null;
 },
 GetNextVisibleItemInGroup: function(parent, index, skipItemsInAdaptiveMenu) {
  for(var i = index + 1; i &lt; parent.GetItemCount(); i++) {
   var item = parent.GetItem(i);
   if(this.IsItemBeginsGroup(item))
    return null;
   if(item.GetVisible() & !this.IsAdaptiveItem(item.indexPath) && (!skipItemsInAdaptiveMenu || !this.IsItemInAdaptiveMenu(item)))
    return item;
  }
  return null;
 },
 HasNextVisibleItemInGroup: function(parent, index, skipItemsInAdaptiveMenu) {
  return !!this.GetNextVisibleItemInGroup(parent, index, skipItemsInAdaptiveMenu);
 },
 IsItemBeginsGroup: function(item) {
  var itemSeparator = this.GetItemSeparatorElement(item.GetIndexPath());
  return itemSeparator & ASPx.ElementContainsCssClass(itemSeparator, MenuCssClasses.Separator);
 },
 IsItemInAdaptiveMenu: function(item) {
  return this.enableAdaptivity ? this.renderHelper.IsItemInAdaptiveMenu(item.index) : false;
 },
 HasVisibleItems: function(parent) {
  for(var i = 0; i &lt; parent.GetItemCount() ; i++) {
   if(parent.GetItem(i).GetVisible())
    return true;
  }
  return false;
 },
 HasNextVisibleItems: function(parent, index, skipItemsInAdaptiveMenu) {
  for(var i = index + 1; i &lt; parent.GetItemCount() ; i++) {
   var item = parent.GetItem(i);
   if(item.GetVisible() & (!skipItemsInAdaptiveMenu || !this.IsItemInAdaptiveMenu(item)))
    return true;
  }
  return false;
 },
 HasPrevVisibleItems: function(parent, index, skipItemsInAdaptiveMenu) {
  for(var i = index - 1; i &gt;= 0; i--) {
   var item = parent.GetItem(i);
   if(item.GetVisible() & (!skipItemsInAdaptiveMenu || !this.IsItemInAdaptiveMenu(item)))
    return true;
  }
  return false;
 },
 NeedCollapseControlCore: function() {
  return this.enableAdaptivity || ASPxClientControl.prototype.NeedCollapseControlCore.call(this);
 },
 GetItemIndentElement: function(indexPath) {
  return ASPx.GetElementById(this.GetItemIndentElementId(indexPath));
 },
 GetItemSeparatorElement: function(indexPath) {
  return ASPx.GetElementById(this.GetItemSeparatorElementId(indexPath));
 },
 RaiseItemClick: function(indexPath, htmlEvent) {
  var processOnServer = this.autoPostBack || this.IsServerEventAssigned("ItemClick");
  if(!this.ItemClick.IsEmpty()) {
   var item = this.GetItemByIndexPath(indexPath);
   var htmlElement = this.GetItemElement(indexPath);
   var args = new ASPxClientMenuItemClickEventArgs(processOnServer, item, htmlElement, htmlEvent);
   this.ItemClick.FireEvent(this, args);
   processOnServer = args.processOnServer;
  }
  return processOnServer;
 },
 RaiseItemMouseOver: function(indexPath) {
  if(!this.ItemMouseOver.IsEmpty()) {
   var item = this.GetItemByIndexPath(indexPath);
   var htmlElement = this.GetItemContentElement(indexPath);
   var args = new ASPxClientMenuItemMouseEventArgs(item, htmlElement);
   this.ItemMouseOver.FireEvent(this, args);
  }
 },
 RaiseItemMouseOut: function(indexPath) {
  if(!this.ItemMouseOut.IsEmpty()) {
   var item = this.GetItemByIndexPath(indexPath);
   var htmlElement = this.GetItemContentElement(indexPath);
   var args = new ASPxClientMenuItemMouseEventArgs(item, htmlElement);
   this.ItemMouseOut.FireEvent(this, args);
  }
 },
 RaisePopUp: function(indexPath) {
  var item = this.GetItemByIndexPath(indexPath);
  if(!this.PopUp.IsEmpty()) {
   var args = new ASPxClientMenuItemEventArgs(item);
   this.PopUp.FireEvent(this, args);
  }
 },
 RaiseCloseUp: function(indexPath) {
  var item = this.GetItemByIndexPath(indexPath);
  if(!this.CloseUp.IsEmpty()) {
   var args = new ASPxClientMenuItemEventArgs(item);
   this.CloseUp.FireEvent(this, args);
  }
 },
 SetEnabled: function(enabled) {
  for(var i = this.GetItemCount() - 1; i &gt;= 0; i--) {
   var item = this.GetItem(i);
   item.SetEnabled(enabled);
  }
 },
 SetVisible: function(visible) {
  ASPxClientControl.prototype.SetVisible.call(this, visible);
  if(visible & !this.HasVisibleItems(this))
   ASPx.SetElementDisplay(this.GetMainElement(), false);
 },
 GetItemCount: function() {
  return (this.rootItem != null) ? this.rootItem.GetItemCount() : 0;
 },
 GetItem: function(index) {
  return (this.rootItem != null) ? this.rootItem.GetItem(index) : null;
 },
 GetItemByName: function(name) {
  return (this.rootItem != null) ? this.rootItem.GetItemByName(name) : null;
 },
 GetSelectedItem: function() {
  var indexPath = this.GetSelectedItemIndexPath();
  if(indexPath != "")
   return this.GetItemByIndexPath(indexPath);
  return null;
 },
 SetSelectedItem: function(item) {
  var indexPath = (item != null) ? item.GetIndexPath() : "";
  this.SetSelectedItemInternal(indexPath, false);
 },
 GetRootItem: function() {
  return this.rootItem;
 }
});
ASPxClientMenuBase.GetMenuCollection = function() {
 return aspxGetMenuCollection();
};
var ASPxMenuKeyboardHelper = ASPx.CreateClass(null, {
 constructor: function(menu) {
  this.menu = menu;
  this.accessibilityCompliant = menu.accessibilityCompliant;
  this.isContextMenu = menu.isContextMenu;
  this.rtl = menu.rtl;
 },
 OnFocusedItemKeyDown: function(evt, focusedItem) {
  var indexPath = this.menu.GetItemIndexPathById(focusedItem.name);
  if(!this.IsAllowedItemAction(evt, focusedItem.enabled, indexPath))
   ASPx.Evt.PreventEventAndBubble(evt);
  else
   this.OnFocusedItemKeyDownInternal(evt, indexPath);
 },
 OnFocusedItemKeyDownInternal: function(evt, indexPath) {
  if(!indexPath)
   return;
  var keyKode = ASPx.Evt.GetKeyCode(evt);
  switch (keyKode) {
   case ASPx.Key.Tab:
    this.OnTab(indexPath, evt);
    break;
   case ASPx.Key.Down:
    this.OnArrowDown(indexPath, evt);
    break;
   case ASPx.Key.Up:
    this.OnArrowUp(indexPath, evt);
    break;
   case ASPx.Key.Left:
    if(this.rtl)
     this.OnArrowRight(indexPath, evt);
    else
     this.OnArrowLeft(indexPath, evt);
    break;
   case ASPx.Key.Right:
    if(this.rtl)
     this.OnArrowLeft(indexPath, evt);
    else
     this.OnArrowRight(indexPath, evt);
    break;
   case ASPx.Key.Esc:
    this.OnEscape(indexPath, evt);
    break;
   case ASPx.Key.Space: break;
   case ASPx.Key.Enter: break;
   case ASPx.Key.Shift: break;
   case ASPx.Key.Alt: break;
   case ASPx.Key.Ctrl: break;
   default:
    ASPx.Evt.PreventEventAndBubble(evt);
    break;
  }
 },
 OnTab: function(indexPath, evt) {
  var isRootItem = this.IsRootItem(indexPath);
  if(isRootItem & !this.accessibilityCompliant) return;
  if(this.IsLostFocus(indexPath, evt))
   this.menu.ProcessLostFocus(evt);
  else
   this.ProcessTab(indexPath, evt);
 },
 ProcessTab: function(indexPath, evt) {
  if(this.IsRootItem(indexPath))
   this.FocusRootItem(indexPath, evt);
  else
   this.FocusSubmenuItem(indexPath, evt);
 },
 OnArrowDown: function(indexPath, evt) {
  if(this.menu.IsVertical(indexPath))
   this.FocusNextItem(indexPath);
  else
   this.ShowSubMenuAccessible(indexPath);
  ASPx.Evt.PreventEventAndBubble(evt);
 },
 OnArrowUp: function(indexPath, evt) {
  if(this.menu.IsVertical(indexPath))
   this.FocusPrevItem(indexPath);
  else
   this.ShowSubMenuAccessible(indexPath);
  ASPx.Evt.PreventEventAndBubble(evt);
 },
 OnArrowLeft: function(indexPath, evt) {
  var isVertical = this.menu.IsVertical(indexPath);
  if(isVertical) {
   var isRootItem = this.IsRootItem(indexPath);
   if(isRootItem)
    this.FocusPrevItem(indexPath);
   else
    this.FocusItemByIndexPathAccessible(this.GetLeftParentIndexPath(indexPath));
  } else
   this.FocusPrevItem(indexPath);
  ASPx.Evt.PreventEventAndBubble(evt);
 },
 OnArrowRight: function(indexPath, evt) {
  var isVertical = this.menu.IsVertical(indexPath);
  if(isVertical) {
   var hasChildren = this.menu.HasChildren(indexPath);
   if(hasChildren)
    this.ShowSubMenuAccessible(indexPath);
   else
    this.FocusItemByIndexPathAccessible(this.GetRightRootParentIndexPath(indexPath));
  }
  else
   this.FocusNextItem(indexPath);
  ASPx.Evt.PreventEventAndBubble(evt);
 },
 OnEscape: function(indexPath, evt) {
  var needPreventEvent = true;
  if(this.IsRootItem(indexPath)) {
   aspxGetMenuCollection().DoHidePopupMenus(null, -1, this.name, false, "");
   this.menu.ProcessLostFocus(evt);
  }
  else {
   var parentIndexPath = this.menu.GetParentIndexPath(indexPath);
   this.FocusItemByIndexPathAccessible(parentIndexPath);
   var element = this.menu.GetMenuElement(parentIndexPath);
   if(element != null)
    this.menu.DoHidePopupMenu(null, element);
   else
    needPreventEvent = false;
  }
  if(needPreventEvent)
   ASPx.Evt.PreventEventAndBubble(evt);
 },
 IsLostFocus: function(indexPath, evt) {
  var keyCode = ASPx.Evt.GetKeyCode(evt);
  var isRootItem = this.IsRootItem(indexPath); 
  if(keyCode !== ASPx.Key.Tab || !isRootItem)
   return false;
  var canPrevItemGetFocus = evt.shiftKey & this.GetPrevSiblingIndexPath(indexPath);
  var canNextItemGetFocus = !evt.shiftKey & this.GetNextSiblingIndexPath(indexPath);
  return !canPrevItemGetFocus & !canNextItemGetFocus;
 },
 FocusRootItem: function(indexPath, evt) {
  if(evt.shiftKey)
   this.FocusPrevItem(indexPath, evt);
  else
   this.FocusNextItem(indexPath, evt);
  var isFocusElementChanged = ASPx.Evt.GetEventSource(evt) !== document.activeElement;
  if(isFocusElementChanged)
   ASPx.Evt.PreventEventAndBubble(evt);
 },
 FocusSubmenuItem: function(indexPath, evt) {
  if(evt.shiftKey)
   this.FocusPreviousSubmenuItem(indexPath, evt);
  else
   this.FocusNextSubmenuItem(indexPath, evt);
 },
 FocusPreviousSubmenuItem: function(indexPath, evt) {
  if(!this.GetPrevSiblingIndexPath(indexPath)) {
   var parentIndexPath = this.menu.GetParentIndexPath(indexPath);
   this.FocusItemByIndexPathAccessible(parentIndexPath);
  } else
   this.FocusPrevItem(indexPath);
  ASPx.Evt.PreventEventAndBubble(evt);
 },
 FocusNextSubmenuItem: function(indexPath, evt) {
  var nextIndexPath = this.GetNextIndexPath(indexPath);
  if(nextIndexPath) {
   var isLevelChanged = this.IsLevelChanged(indexPath, nextIndexPath);
   this.FocusItemCore(nextIndexPath, isLevelChanged); 
   ASPx.Evt.PreventEventAndBubble(evt);
  } else
   this.menu.ProcessLostFocus(evt);
 },
 GetNextIndexPath: function(indexPath) {
  var result = this.GetNextSiblingIndexPath(indexPath);
  if(!result) {
   var parentIndexPath = this.menu.GetParentIndexPath(indexPath);
   if(parentIndexPath)
    result = this.GetNextIndexPath(parentIndexPath);
  }
  return result;
 },
 GetRightRootParentIndexPath: function(indexPath) {
  var parentIndexPath = this.GetParentRootIndexPath(indexPath);
  return this.GetNextFocusableItemIndexPath(parentIndexPath);
 },
 GetLeftParentIndexPath: function(indexPath) {
  var parentIndexPath = this.menu.GetParentIndexPath(indexPath);
  if(!this.menu.IsVertical(parentIndexPath))
   parentIndexPath = this.GetPrevFocusableItemIndexPath(parentIndexPath);
  return parentIndexPath;
 },
 GetParentRootIndexPath: function(indexPath) {
  while(!this.IsRootItem(indexPath))
   indexPath = this.menu.GetParentIndexPath(indexPath);
  return indexPath;
 },
 ShowSubMenuAccessible: function(indexPath) {
  var newIndexPath = this.GetFirstChildIndexPath(indexPath);
  if(!!newIndexPath) {
   this.menu.ShowSubMenu(indexPath);
   this.FocusItemByIndexPathAccessible(newIndexPath);
  }
 },
 FocusItemByIndexPathAccessible: function(indexPath) {
  this.FocusItemCore(indexPath, true);
 },
 IsAllowedItemAction: function(evt, isEnabled, indexPath) {
  var isVertical = this.menu.IsVertical(indexPath);
  return !this.accessibilityCompliant ||
      isEnabled ||
      this.IsAllowedFocusMoving(evt) ||
      this.IsAllowedHorizontalFocusMoving(evt, isVertical) ||
      this.IsAllowedVerticalFocusMoving(evt, isVertical);
 },
 IsAllowedFocusMoving: function(evt) {
  return evt.keyCode == ASPx.Key.Tab || evt.keyCode == ASPx.Key.Esc;
 },
 IsAllowedHorizontalFocusMoving: function(evt, isVertical) {
  return !isVertical & (evt.keyCode == ASPx.Key.Left || evt.keyCode == ASPx.Key.Right);
 },
 IsAllowedVerticalFocusMoving: function(evt, isVertical) {
  return isVertical & (evt.keyCode == ASPx.Key.Up || evt.keyCode == ASPx.Key.Down);
 },
 FocusItemByIndexPath: function(indexPath) {
  var link = this.menu.GetLinkElementByIndexPath(indexPath);
  if(link != null) {
   if(this.accessibilityCompliant & !link.href)
    link.href = ASPx.AccessibilityEmptyUrl;
   ASPx.SetFocus(link);
  } else
   this.FocusTemplateItemActionElement(indexPath);
 },
 FocusTemplateItemActionElement: function(indexPath) {
  var element = this.menu.GetItemElement(indexPath);
  var focusableElement = ASPx.FindFirstChildActionElement(element);
  if(focusableElement)
   ASPx.SetFocus(focusableElement);
  else {
   var parentIndexPath = this.menu.GetParentIndexPath(indexPath);
   this.tryFocusColorPickerByIndexPath(parentIndexPath);
  }
 },
 tryFocusColorPickerByIndexPath: function(indexPath) {
  var colorPicker = this.getColorPickerByIndexPath(indexPath);
  if(colorPicker)
   colorPicker.Focus();
 },
 getColorPickerByIndexPath: function(indexPath) {
  var menuItem = this.menu.GetItemByIndexPath(indexPath);
  return menuItem.colorPicker;
 },
 PronounceItemDescription: function(indexPath) {
  var link = this.menu.GetLinkElementByIndexPath(indexPath);
  var span = ASPx.GetNodeByTagName(link, "SPAN", 0);
  if(!link) return;
  if(!!span & !span.id) {
   var spanID = this.GetAccessibilityTextSpanID(indexPath);
   span.id = spanID;
   ASPx.Attr.SetAttribute(link, "aria-describedby", spanID);
  }
  ASPx.Attr.SetAttribute(link, "aria-label", this.GetAccessibilityItemDescription(indexPath));
 },
 RemoveAccessibilityDescription: function(indexPath) {
  var link = this.menu.GetLinkElementByIndexPath(indexPath);
  if(link & ASPx.Attr.GetAttribute(link, "aria-label"))
   ASPx.Attr.RemoveAttribute(link, "aria-label");
 },
 GetAccessibilityTextSpanID: function(indexPath) {
  return this.name + Constants.ATSIdSuffix + indexPath;
 },
 GetAccessibilityItemDescription: function(indexPath) {
  var descriptionParts = [];
  descriptionParts.push(this.menu.IsVertical(indexPath) ? ASPx.AccessibilitySR.MenuVerticalText : ASPx.AccessibilitySR.MenuHorizontalText);
  descriptionParts.push(this.IsRootItem(indexPath) ? ASPx.AccessibilitySR.MenuBarText : ASPx.AccessibilitySR.MenuText);
  descriptionParts.push(this.menu.GetMenuLevel(indexPath));
  descriptionParts.push(ASPx.AccessibilitySR.MenuLevelText);
  return descriptionParts.(' ');
 },
 FocusNextItem: function(indexPath) {
  var newIndexPath = this.GetNextFocusableItemIndexPath(indexPath);
  if(newIndexPath)
   this.FocusItemCore(newIndexPath, false);
 },
 FocusPrevItem: function(indexPath) {
  var newIndexPath = this.GetPrevFocusableItemIndexPath(indexPath);
  if(newIndexPath)
   this.FocusItemCore(newIndexPath, false);
 },
 FocusItemCore: function(indexPath, needDescription) {
  if(this.accessibilityCompliant) {
   if(needDescription)
    this.PronounceItemDescription(indexPath);
   else
    this.RemoveAccessibilityDescription(indexPath);
  }
  this.FocusItemByIndexPath(indexPath);
 },
 GetNextFocusableItemIndexPath: function(indexPath) {
  var newIndexPath = this.GetNextSiblingIndexPath(indexPath);
  if(newIndexPath == null)
   newIndexPath = this.GetFirstSiblingIndexPath(indexPath);
  if(indexPath != newIndexPath)
   return newIndexPath;
 },
 GetPrevFocusableItemIndexPath: function(indexPath) {
  var newIndexPath = this.GetPrevSiblingIndexPath(indexPath);
  if(newIndexPath == null)
   newIndexPath = this.GetLastSiblingIndexPath(indexPath);
  if(indexPath != newIndexPath)
   return newIndexPath;
 },
 GetFirstChildIndexPath: function(indexPath) {
  var indexes = this.menu.GetItemIndexes(indexPath);
  indexes[indexes.length] = 0;
  var newIndexPath = this.menu.GetItemIndexPath(indexes);
  return this.GetFirstSiblingIndexPath(newIndexPath);
 },
 GetFirstSiblingIndexPath: function(indexPath) {
  var indexes = this.menu.GetItemIndexes(indexPath);
  var i = 0;
  while(true) {
   indexes[indexes.length - 1] = i;
   var newIndexPath = this.menu.GetItemIndexPath(indexes);
   if(!this.IsItemExist(newIndexPath))
    return null;
   if(this.IsFocusableItem(newIndexPath))
    return newIndexPath;
   i++;
  }
  return null;
 },
 GetLastSiblingIndexPath: function(indexPath) {
  var indexes = this.menu.GetItemIndexes(indexPath);
  var parentItem = this.menu.GetItemByIndexPath(this.menu.GetParentIndexPath(indexPath));
  var i = parentItem ? parentItem.GetItemCount() - 1 : 0;
  while(true) {
   indexes[indexes.length - 1] = i;
   var newIndexPath = this.menu.GetItemIndexPath(indexes);
   if(!this.IsItemExist(newIndexPath))
    return null;
   if(this.IsFocusableItem(newIndexPath))
    return newIndexPath;
   i--;
  }
  return null;
 },
 GetNextSiblingIndexPath: function(indexPath) {
  if(this.menu.IsLastItem(indexPath)) return null;
  var indexes = this.menu.GetItemIndexes(indexPath);
  var i = indexes[indexes.length - 1] + 1;
  while(true) {
   indexes[indexes.length - 1] = i;
   var newIndexPath = this.menu.GetItemIndexPath(indexes);
   if(!this.IsItemExist(newIndexPath))
    return null;
   if(this.IsFocusableItem(newIndexPath))
    return newIndexPath;
   i++;
  }
  return null;
 },
 GetPrevSiblingIndexPath: function(indexPath) {
  if(this.menu.IsFirstItem(indexPath)) return null;
  var indexes = this.menu.GetItemIndexes(indexPath);
  var i = indexes[indexes.length - 1] - 1;
  while(true) {
   indexes[indexes.length - 1] = i;
   var newIndexPath = this.menu.GetItemIndexPath(indexes);
   if(!this.IsItemExist(newIndexPath))
    return null;
   if(this.IsFocusableItem(newIndexPath))
    return newIndexPath;
   i--;
  }
  return null;
 },
 IsItemExist: function(indexPath) {
  return !!this.menu.GetItemByIndexPath(indexPath);
 },
 IsItemVisible: function(indexPath) {
  var item = this.menu.GetItemByIndexPath(indexPath);
  return item ? item.GetVisible() : false;
 },
 IsFocusableItem: function(indexPath) {
  return this.IsItemVisible(indexPath) & (this.menu.IsItemEnabled(indexPath) || this.IsItemAccessibleEnabled(indexPath));
 },
 IsRootItem: function(indexPath) {
  return this.menu.IsRootItem(indexPath);
 },
 IsItemAccessibleEnabled: function(indexPath) {
  var item = this.menu.GetItemByIndexPath(indexPath);
  return this.accessibilityCompliant & item && item.enabled;
 },
 IsLevelChanged: function(firstIndexPath, secondIndexPath) {
  return this.menu.GetMenuLevel(firstIndexPath) !== this.menu.GetMenuLevel(secondIndexPath);
 }
});
var ASPxClientMenuCollection = ASPx.CreateClass(ASPxClientControlCollection, {
 constructor: function() {
  this.constructor.prototype.constructor.call(this);
  this.appearTimerID = -1;
  this.disappearTimerID = -1;
  this.currentShowingPopupMenuName = null;
  this.visibleSubMenusMenuName = "";
  this.visibleSubMenuIds = [];
  this.overXPos = -1;
  this.overYPos = -1;
 },
 GetCollectionType: function(){
  return "Menu";
 },
 Remove: function(element) {
  if(element.name === this.visibleSubMenusMenuName) {
   this.visibleSubMenusMenuName = "";
   this.visibleSubMenuIds = [ ];
  }
  ASPxClientControlCollection.prototype.Remove.call(this, element);
 },
 VisiblePopupMenu: function(name, id) {
  this.visibleSubMenuIds.push(id);
  this.visibleSubMenusMenuName = name;
 },
 UnVisiblePopupMenu: function(name, id) {
  ASPx.Data.ArrayRemove(this.visibleSubMenuIds, id);
  if(this.visibleSubMenuIds.length == 0)
   this.visibleSubMenusMenuName = "";
 },
 IsSubMenuVisible: function(subMenuId) {
  for(var i = 0; i &lt; this.visibleSubMenuIds.length; i++) {
   if(this.visibleSubMenuIds[i] == subMenuId)
    return true;
  }
  return false;
 },
 GetMenu: function(id) {
  return this.Get(this.GetMenuName(id));
 },
 GetMenuName: function(id) {
  return this.GetMenuNameBySuffixes(id, [Constants.MMIdSuffix, Constants.MIIdSuffix]);
 },
 GetMenuNameBySuffixes: function(id, idSuffixes) {
  for(var i = 0; i &lt; idSuffixes.length; i++) {
   var pos = id.lastIndexOf(idSuffixes[i]);
   if(pos &gt; -1)
    return id.substring(0, pos);
  }
  return id;
 },
 ClearCurrentShowingPopupMenuName: function() {
  this.SetCurrentShowingPopupMenuName(null);
 },
 SetCurrentShowingPopupMenuName: function(value) {
  this.currentShowingPopupMenuName = value;
 },
 NowPopupMenuIsShowing: function() {
  return this.currentShowingPopupMenuName != null;
 },
 GetMenuLevelById: function(id) {
  var indexPath = this.GetIndexPathById(id, Constants.MMIdSuffix);
  var menu = this.GetMenu(id);
  return menu.GetMenuLevel(indexPath);
 },
 GetIndexPathById: function(id, idSuffix) {
  var pos = id.lastIndexOf(idSuffix);
  if(pos &gt; -1) {
   id = id.substring(pos + idSuffix.length);
   pos = id.lastIndexOf("_");
   if(pos &gt; -1)
    return id.substring(0, pos);
  }
  return "";
 },
 GetItemIndexPath: function(indexes) {
  var indexPath = "";
  for(var i = 0; i &lt; indexes.length; i++) {
   indexPath += indexes[i];
   if(i &lt; indexes.length - 1)
    indexPath += ASPx.ItemIndexSeparator;
  }
  return indexPath;
 },
 GetItemIndexes: function(indexPath) {
  var indexes = indexPath.split(ASPx.ItemIndexSeparator);
  for(var i = 0; i &lt; indexes.length; i++)
   indexes[i] = parseInt(indexes[i]);
  return indexes;
 },
 ClearAppearTimer: function() {
  this.appearTimerID = ASPx.Timer.ClearTimer(this.appearTimerID);
 },
 ClearDisappearTimer: function() {
  this.disappearTimerID = ASPx.Timer.ClearTimer(this.disappearTimerID);
 },
 IsAppearTimerActive: function() {
  return this.appearTimerID &gt; -1;
 },
 IsDisappearTimerActive: function() {
  return this.disappearTimerID &gt; -1;
 },
 SetAppearTimer: function(name, indexPath, timeout, preventSubMenu) {
  this.appearTimerID = window.setTimeout(function() {
   var menu = aspxGetMenuCollection().Get(name);
   if(menu != null) menu.OnItemOverTimer(indexPath, preventSubMenu);
  }, timeout);
 },
 SetDisappearTimer: function(name, timeout) {
  this.disappearTimerID = window.setTimeout(function() {
   var menu = aspxGetMenuCollection().Get(name);
   if(menu != null)
    menu.OnItemOutTimer();
  }, timeout);
 },
 GetMouseDownMenuLevel: function(evt) {
  var srcElement = ASPx.Evt.GetEventSource(evt);
  for(var i = this.visibleSubMenuIds.length - 1; i &gt;= 0; i--) {
   var element = ASPx.GetParentById(srcElement, this.visibleSubMenuIds[i]);
   if(element != null)
    return this.GetMenuLevelById(this.visibleSubMenuIds[i]) + 1;
  }
  if(this.visibleSubMenusMenuName != "") {
   var element = ASPx.GetParentById(srcElement, this.visibleSubMenusMenuName);
   if(element != null) return 1;
  }
  return -1;
 },
 CheckFocusedElement: function() {
  var isValid = false;
  try {
   var activeElement = document.activeElement;
   if(activeElement != null) {
    for(var i = 0; i &lt; this.visibleSubMenuIds.length; i++) {
     var menuElement = ASPx.GetElementById(this.visibleSubMenuIds[i]);
     if(menuElement != null & ASPx.GetIsParent(menuElement, activeElement)) {
      var tagName = activeElement.tagName;
      if(tagName != "A" || 
         !ASPx.ElementHasCssClass(activeElement, MenuCssClasses.ContentContainer) || 
         this.GetMenu(this.visibleSubMenusMenuName).accessibilityCompliant)
          isValid = true;
      break;
     }
    }
   }
  } catch (e) {
  }
  return isValid;
 },
 LockMenusVisibility: function() {
  this.visibilityLocked = true;
  this.visibilityLockedIds = [];
  for(var i = this.visibleSubMenuIds.length - 1; i &gt;= 0 ; i--)
   this.visibilityLockedIds.push(this.visibleSubMenuIds[i]);
 },
 UnlockMenusVisibility: function() {
  this.visibilityLocked = false;
  this.visibilityLockedIds = [];
 },
 CanHideSubMenu: function(subMenuId) {
  return !this.visibilityLocked || this.visibilityLocked & this.visibilityLockedIds.indexOf(subMenuId) > -1;
 },
 DoHidePopupMenus: function(evt, level, name, leavePopups, exceptId) {
  for(var i = this.visibleSubMenuIds.length - 1; i &gt;= 0 ; i--) {
   var subMenuId = this.visibleSubMenuIds[i];
   if(this.CanHideSubMenu(subMenuId)) {
    var menu = this.GetMenu(subMenuId);
    if(menu != null) {
     var menuLevel = this.GetMenuLevelById(subMenuId);
     if((!leavePopups || menuLevel &gt; 0) & exceptId != subMenuId) {
      if(menuLevel > level || (menu.name != name && name != "")) {
       var element = ASPx.GetElementById(subMenuId);
       if(element != null)
        menu.DoHidePopupMenu(evt, element);
      }
     }
    }
   }
  }
 },
 DoShowAtCurrentPos: function(name, indexPath) {
  var pc = this.Get(name);
  var element = pc.GetMainElement();
  if(pc != null & !ASPx.GetElementDisplay(element))
   pc.DoShowPopupMenu(element, this.overXPos, this.overYPos, indexPath);
 },
 SaveCurrentMouseOverPos: function(evt, popupElement) {
  if(!this.NowPopupMenuIsShowing()) return;
  var currentShowingPopupMenu = this.Get(this.currentShowingPopupMenuName);
  if(currentShowingPopupMenu.popupElement == popupElement)
   if(!currentShowingPopupMenu.IsMenuVisible()) {
    this.overXPos = ASPx.Evt.GetEventX(evt);
    this.overYPos = ASPx.Evt.GetEventY(evt);
   }
 },
 OnMouseDown: function(evt) {
  var menuLevel = this.GetMouseDownMenuLevel(evt);
  this.DoHidePopupMenus(evt, menuLevel, "", false, "");
  if (ASPx.Browser.TouchUI & menuLevel == -1) 
   ASPx.SetHoverState(null);
 },
 RecalculateAll: function() {
  var visibleSubMenusLength = this.visibleSubMenuIds.length;
  for(var i = 0; i &lt; visibleSubMenusLength; i++) {
   var menu = this.GetMenu(this.visibleSubMenuIds[i]);
   if(menu != null) {
    var element = ASPx.GetElementById(this.visibleSubMenuIds[i]);
    if(element != null) {
     var indexPath = this.GetIndexPathById(this.visibleSubMenuIds[i], Constants.MMIdSuffix);
     menu.CalculateSubMenuPosition(element, ASPx.InvalidPosition, ASPx.InvalidPosition, indexPath, false);
    }
   }
  }
 },
 HideAll: function() {
  this.DoHidePopupMenus(null, -1, "", false, "");
 },
 IsAnyMenuVisible: function() {
  return this.visibleSubMenuIds.length != 0;
 }
});
var menuCollection = null;
function aspxGetMenuCollection() {
 if(menuCollection == null)
  menuCollection = new ASPxClientMenuCollection();
 return menuCollection;
}
var ASPxClientMenuItem = ASPx.CreateClass(null, {
 constructor: function(menu, parent, index, name) {
  this.menu = menu;
  this.parent = parent;
  this.index = index;
  this.name = name;
  this.indexPath = "";
  this.text = "";
  this.imageUrl = "";
  this.imageClassName = "";
  this.tooltip = "";
  this.target = "";
  this.beginGroup = false;
  this.dropDownMode = false;
  if(parent) {
   this.indexPath = this.CreateItemIndexPath(parent);
  }
  this.enabled = true;
  this.clientEnabled = true;
  this.visible = true;
  this.clientVisible = true;
  this.items = [];
  this.colorPicker = null;
  this.checkedGroup = [];
  this.checked = false;
 },
 CreateItemIndexPath: function(parent) {
  return parent.indexPath ? parent.indexPath + ASPx.ItemIndexSeparator + this.index.toString() : this.index.toString();
 },
 CreateItems: function(itemsProperties) {
  for(var i = 0, len = itemsProperties.length; i &lt; len; i++) {
   var itemProperties = itemsProperties[i],
    item = this.CreateItemInternal(itemProperties);
   if(itemProperties.items & itemProperties.items.length > 0)
    item.CreateItems(itemProperties.items);
  }
 },
 CreateItemInternal: function(itemProperties) {
  var itemName = itemProperties.name || "";
  var index = this.items.length;
  var itemType = this.menu.GetClientItemType();
  var item = new itemType(this.menu, this, index, itemName);
  if(ASPx.IsExists(itemProperties.text))
   item.text = itemProperties.text;
  if(ASPx.IsExists(itemProperties.imageUrl))
   item.imageUrl = itemProperties.imageUrl;
  if(ASPx.IsExists(itemProperties.imageHottrackSrc))
   item.imageHottrackSrc = itemProperties.imageHottrackSrc;
  if(ASPx.IsExists(itemProperties.imageClassName))
   item.imageClassName = itemProperties.imageClassName;
  if(ASPx.IsExists(itemProperties.navigateUrl))
   item.navigateUrl = itemProperties.navigateUrl;
  if(ASPx.IsExists(itemProperties.beginGroup))
   item.beginGroup = itemProperties.beginGroup;
  if(ASPx.IsExists(itemProperties.clientEnabled))
   item.clientEnabled = itemProperties.clientEnabled;
  if(ASPx.IsExists(itemProperties.visible))
   item.visible = itemProperties.visible;
  if(ASPx.IsExists(itemProperties.clientVisible))
   item.clientVisible = itemProperties.clientVisible;
  if(ASPx.IsExists(itemProperties.groupName)) {
   this.menu.ProcessItemGroupName(item, itemProperties.groupName);
   item.checked = !!itemProperties.checked;
  }
  if(ASPx.IsExists(itemProperties.tooltip))
   item.tooltip = itemProperties.tooltip;
  if(ASPx.IsExists(itemProperties.target))
   item.target = itemProperties.target;
  if(ASPx.IsExists(itemProperties.dropDownMode))
   item.dropDownMode = itemProperties.dropDownMode;
  if(ASPx.IsExists(itemProperties.textTemplate))
   item.textTemplate = itemProperties.textTemplate;
  if(ASPx.IsExists(itemProperties.styles))
   item.styles = itemProperties.styles;
  if(this.menu.NeedAppendToRenderData(item))
   this.menu.AppendToRenderData(this.indexPath, index);
  this.items.push(item);
  return item;
 },
 GetIndexPath: function() {
  return this.indexPath;
 },
 GetItemCount: function() {
  return this.items.length;
 },
 GetItem: function(index) {
  return (0 &lt;= index & index < this.items.length) ? this.items[index] : null;
 },
 GetItemByName: function(name) {
  for(var i = 0; i &lt; this.items.length; i++)
   if(this.items[i].name == name) return this.items[i];
  for(var i = 0; i &lt; this.items.length; i++) {
   var item = this.items[i].GetItemByName(name);
   if(item != null) return item;
  }
  return null;
 },
 GetChecked: function() {
  var indexPath = this.GetIndexPath();
  return this.menu.IsCheckedItem(indexPath);
 },
 SetChecked: function(value) {
  var indexPath = this.GetIndexPath();
  this.menu.SetItemChecked(indexPath, value);
 },
 GetEnabled: function() {
  return this.enabled & this.clientEnabled;
 },
 SetEnabled: function(value) {
  if(this.clientEnabled != value) {
   this.clientEnabled = value;
   this.menu.SetItemEnabled(this.GetIndexPath(), value, false);
  }
 },
 GetImage: function() {
  return this.menu.GetItemImage(this.GetIndexPath());
 },
 GetImageUrl: function() {
  return this.menu.GetItemImageUrl(this.GetIndexPath());
 },
 SetImageUrl: function(value) {
  var indexPath = this.GetIndexPath();
  this.menu.SetItemImageUrl(indexPath, value);
 },
 GetNavigateUrl: function() {
  var indexPath = this.GetIndexPath();
  return this.menu.GetItemNavigateUrl(indexPath);
 },
 SetNavigateUrl: function(value) {
  var indexPath = this.GetIndexPath();
  this.menu.SetItemNavigateUrl(indexPath, value);
 },
 GetText: function() {
  var indexPath = this.GetIndexPath();
  return this.menu.GetItemText(indexPath);
 },
 SetText: function(value) {
  var indexPath = this.GetIndexPath();
  this.menu.SetItemText(indexPath, value);
 },
 GetVisible: function() {
  return this.visible & this.clientVisible;
 },
 SetVisible: function(value) {
  if(this.clientVisible != value) {
   this.clientVisible = value;
   this.menu.SetItemVisible(this.GetIndexPath(), value, false);
  }
 },
 InitializeEnabledAndVisible: function(recursive) {
  this.menu.SetItemEnabled(this.GetIndexPath(), this.clientEnabled, true);
  this.menu.SetItemVisible(this.GetIndexPath(), this.clientVisible, true);
  if(recursive) {
   for(var i = 0; i &lt; this.items.length; i++)
    this.items[i].InitializeEnabledAndVisible(recursive);
  }
 },
 GetOwnProperties: function() {
  return {
   menuItem: this,
   focusableElement: this.GetFocusableElement()
  };
 },
 GetFocusableElement: function() {
  return this.menu.GetLinkElementByIndexPath(this.indexPath);
 }
});
var ASPxClientMenu = ASPx.CreateClass(ASPxClientMenuBase, {
 constructor: function(name) {
  this.constructor.prototype.constructor.call(this, name);
  this.isVertical = false;
  this.orientationChanged = false;
  this.firstSubMenuDirection = "Auto";
 },
 SetData: function(data){
  ASPxClientMenuBase.prototype.SetData.call(this, data);
  if(data.adaptiveModeData)
   this.SetAdaptiveMode(data.adaptiveModeData);
 },
 IsVertical: function(indexPath) {
  return this.isVertical || !this.IsRootItem(indexPath) || this.IsAdaptiveMenuItem(indexPath);
 },
 IsCorrectionDisableMethodRequired: function(indexPath) {
  return (indexPath.indexOf("i") == -1) & (this.firstSubMenuDirection == "RightOrBottom" || this.firstSubMenuDirection == "LeftOrTop");
 },
 SetAdaptiveMode: function(data) {
  this.enableAdaptivity = true;
  if(ASPx.Ident.IsArray(data))
   this.adaptiveItemsOrder = data;
  else {
   for(var i = data - 1; i &gt;= 0; i--)
    this.adaptiveItemsOrder.push(i.toString());
  }
 }, 
 OnBrowserWindowResize: function (e) {
  this.AdjustControl();
 },
 AdjustControlCore: function() {
  this.CorrectVerticalAlignment(ASPx.ClearHeight, this.GetPopOutElements, "PopOut", true);
  this.CorrectVerticalAlignment(ASPx.ClearVerticalMargins, this.GetPopOutImages, "PopOutImg", true);
  if(this.orientationChanged){
   this.renderHelper.ChangeOrientaion(this.GetMainElement(), this.isVertical);
   this.orientationChanged = false;
  }
  else
   this.renderHelper.CalculateMenuControl(this.GetMainElement());
  this.CorrectVerticalAlignment(ASPx.AdjustHeight, this.GetPopOutElements, "PopOut", true);
  this.CorrectVerticalAlignment(ASPx.AdjustVerticalMargins, this.GetPopOutImages, "PopOutImg", true);
 },
 GetCorrectionDisabledResult: function(x, toLeftX) {
  switch (this.firstSubMenuDirection) {
   case "RightOrBottom": {
    this.popupToLeft = false;
    return x;
   }
   case "LeftOrTop": {
    this.popupToLeft = true;
    return toLeftX;
   }
  }
 },
 IsHorizontalSubmenuNeedInversion: function(subMenuBottom, docClientHeight, menuItemTop, subMenuHeight, itemHeight) {
  if(this.firstSubMenuDirection == "Auto")
   return ASPxClientMenuBase.prototype.IsHorizontalSubmenuNeedInversion.call(this, subMenuBottom, docClientHeight, menuItemTop, subMenuHeight, itemHeight);
  return this.firstSubMenuDirection == "LeftOrTop";
 },
 GetOrientation: function() {
  return this.isVertical ? "Vertical" : "Horizontal";
 },
 SetOrientation: function(orientation) {
  var isVertical = orientation === "Vertical";
  if(this.isVertical !== isVertical){
   this.isVertical = isVertical;
   this.orientationChanged = true;
   this.ResetControlAdjustment();
   this.AdjustControl();
  }
 }
});
ASPx.Ident.scripts.ASPxClientMenu = true;
var ASPxClientMenuExt = ASPx.CreateClass(ASPxClientMenu, {
 constructor: function(name) {
  this.constructor.prototype.constructor.call(this, name); 
 },
 NeedCreateItemsOnClientSide: function() {
  return true;
 }
});
ASPxClientMenu.Cast = ASPxClientControl.Cast;
var ASPxClientMenuItemEventArgs = ASPx.CreateClass(ASPxClientEventArgs, {
 constructor: function(item) {
  this.constructor.prototype.constructor.call(this);
  this.item = item;
 }
});
var ASPxClientMenuItemMouseEventArgs = ASPx.CreateClass(ASPxClientMenuItemEventArgs, {
 constructor: function(item, htmlElement) {
  this.constructor.prototype.constructor.call(this, item);
  this.htmlElement = htmlElement;
 }
});
var ASPxClientMenuItemClickEventArgs = ASPx.CreateClass(ASPxClientProcessingModeEventArgs, {
 constructor: function(processOnServer, item, htmlElement, htmlEvent) {
  this.constructor.prototype.constructor.call(this, processOnServer);
  this.item = item;
  this.htmlElement = htmlElement;
  this.htmlEvent = htmlEvent;
 }
});
ASPx.Evt.AttachEventToDocument(ASPx.TouchUIHelper.touchMouseDownEventName, function(evt) {
 return aspxGetMenuCollection().OnMouseDown(evt);
});
function aspxAMIMOver(source, args) {
 var menu = aspxGetMenuCollection().GetMenu(args.item.name);
 if(menu != null) menu.OnAfterItemOver(args.item, args.element);
}
function aspxBMIMOver(source, args) {
 var menu = aspxGetMenuCollection().GetMenu(args.item.name);
 if(menu != null) menu.OnBeforeItemOver(args.item, args.element);
}
function aspxAMIMOut(source, args) {
 var menu = aspxGetMenuCollection().GetMenu(args.item.name);
 if(menu != null) menu.OnAfterItemOut(args.item, args.element, args.toElement);
}
function aspxMSBOver(source, args) {
 var menu = MenuScrollHelper.GetMenuByScrollButtonId(args.element.id);
 if(menu != null) menu.ClearDisappearTimer();
}
ASPx.AddAfterSetFocusedState(aspxAMIMOver);
ASPx.AddAfterClearFocusedState(aspxAMIMOut);
ASPx.AddAfterSetHoverState(aspxAMIMOver);
ASPx.AddAfterClearHoverState(aspxAMIMOut);
ASPx.AddBeforeSetFocusedState(aspxBMIMOver);
ASPx.AddBeforeSetHoverState(aspxBMIMOver);
ASPx.AddAfterSetHoverState(aspxMSBOver);
ASPx.AddAfterSetPressedState(aspxMSBOver);
ASPx.AddBeforeDisabled(function(source, args) {
 var menu = aspxGetMenuCollection().GetMenu(args.item.name);
 if(menu != null)
  menu.OnBeforeItemDisabled(args.item, args.element);
});
ASPx.AddFocusedItemKeyDown(function(source, args) {
 var menu = aspxGetMenuCollection().GetMenu(args.item.name);
 if(menu != null)
  menu.OnFocusedItemKeyDown(args.htmlEvent, args.item);
});
ASPx.AddAfterClearHoverState(function(source, args) {
 var menu = MenuScrollHelper.GetMenuByScrollButtonId(args.element.id);
 if(menu != null) menu.SetDisappearTimer();
});
ASPx.AddAfterSetPressedState(function(source, args) {
 var menu = MenuScrollHelper.GetMenuByScrollButtonId(args.element.id);
 if(menu) menu.StartScrolling(args.element.id, 1, 4);
});
ASPx.AddAfterClearPressedState(function(source, args) {
 var menu = MenuScrollHelper.GetMenuByScrollButtonId(args.element.id);
 if(menu) menu.StopScrolling(args.element.id);
});
if(!ASPx.Browser.TouchUI) {
 ASPx.AddAfterSetHoverState(function(source, args) {
  var menu = MenuScrollHelper.GetMenuByScrollButtonId(args.element.id);
  if(menu) menu.StartScrolling(args.element.id, 15, 1);
 });
 ASPx.AddAfterClearHoverState(function(source, args) {
  var menu = MenuScrollHelper.GetMenuByScrollButtonId(args.element.id);
  if(menu) menu.StopScrolling(args.element.id);
 });
}
ASPx.MIClick = function(evt, name, indexPath) {
 if(ASPx.TouchUIHelper.isMouseEventFromScrolling) return;
 var menu = aspxGetMenuCollection().Get(name);
 if(menu != null) menu.OnItemClick(indexPath, evt);
};
ASPx.MIDDClick = function(evt, name, indexPath) {
 var menu = aspxGetMenuCollection().Get(name);
 if(menu != null) menu.OnItemDropDownClick(indexPath, evt);
 if(!ASPx.Browser.NetscapeFamily)
  evt.cancelBubble = true;
};
ASPx.GetMenuCollection = aspxGetMenuCollection;
ASPx.MenuRenderHelper = MenuRenderHelper;
window.ASPxClientMenuBase = ASPxClientMenuBase;
window.ASPxClientMenuCollection = ASPxClientMenuCollection;
window.ASPxClientMenuItem = ASPxClientMenuItem;
window.ASPxClientMenu = ASPxClientMenu;
window.ASPxClientMenuExt = ASPxClientMenuExt;
window.ASPxClientMenuItemEventArgs = ASPxClientMenuItemEventArgs;
window.ASPxClientMenuItemMouseEventArgs = ASPxClientMenuItemMouseEventArgs;
window.ASPxClientMenuItemClickEventArgs = ASPxClientMenuItemClickEventArgs;
})();
 3f6u3n</p>