AdfUIPeer.createPeerClass(AdfUIPeer, "AdfRichUIPeer");
AdfRichUIPeer.createPeerClass = function(theSuperclass, peerName, stateless, peerInitialization) {
  AdfAssert.assertFunction(theSuperclass);
  AdfAssert.assertString(peerName);
  AdfAssert.assertBooleanOrNull(stateless);
  AdfAssert.assertObjectOrNull(peerInitialization);
  var theClass = AdfUIPeer.createPeerClass(theSuperclass, peerName, peerInitialization);
  var isSuperClassStateless = theSuperclass.STATELESS;
  if(!isSuperClassStateless) {
    isSuperClassStateless = true
  }
  if(stateless == null) {
    stateless = isSuperClassStateless
  }else {
    AdfAssert.assert(!stateless || isSuperClassStateless, "Can't create a stateless subclass of a stateful superclass")
  }
  theClass.InitClass = AdfRichUIPeer.DefaultInitClass;
  theClass.STATELESS = stateless !== false;
  return theClass
};
AdfRichUIPeer.createInnerPeerClassWithSubId = function(theSuperclass, peerName, subId) {
  var innerClassAdaptorName = peerName + "Shim";
  var adapterClass = AdfRichUIPeer.createPeerClass(theSuperclass, innerClassAdaptorName, false);
  var innerClass = AdfRichUIPeer.createPeerClass(adapterClass, peerName, false);
  var initFunc = new Function("c", "o", "AdfRichUIPeer._innerInit.call(this," + innerClassAdaptorName + ", c, o)");
  adapterClass.prototype._subId = subId;
  adapterClass.prototype.Init = initFunc;
  adapterClass.prototype.initialize = AdfRichUIPeer._innerSubIdInitialize;
  return innerClass
};
AdfRichUIPeer._innerSubIdInitialize = function(component) {
  AdfAssert.assertPrototype(component, AdfUIComponent);
  var outerId = component.getClientId();
  var innerId = AdfRichUIPeer.CreateSubId(outerId, this._subId);
  var domNode = AdfAgent.AGENT.getElementById(innerId);
  AdfAssert.assertDomNode(domNode);
  AdfAssert.assert(!this.constructor.STATELESS);
  this.InitDomElement(component, domNode);
  this.BindToComponent(component, domNode)
};
AdfRichUIPeer._innerInit = function(clazz, component, outerThis) {
  AdfAssert.assertPrototype(component, AdfUIComponent);
  AdfAssert.assertPrototype(outerThis, AdfRichUIPeer);
  this.outerThis = outerThis;
  clazz.superclass.Init.call(this, component)
};
AdfRichUIPeer.isComponentContainedByElement = function(component, element) {
  if(component && element) {
    var compNode = AdfRichUIPeer.getDomNodeForComponent(component);
    return AdfDomUtils.isAncestorOrSelf(element, compNode)
  }
  return false
};
AdfRichUIPeer.prototype.getDomDocument = function() {
  return AdfPage.PAGE.getDomDocument()
};
AdfRichUIPeer.prototype.getComponentParent = function(component) {
  this.bind(component);
  var parent = AdfRichUIPeer.getFirstAncestorComponent(this.getDomNode().parentNode);
  if(parent) {
    var ourClientId = component.getClientId();
    var nmSeparator = ourClientId.lastIndexOf(":");
    if(nmSeparator != -1) {
      var namingContainerId = ourClientId.substring(0, nmSeparator);
      if(!AdfAgent.AGENT.getElementById(namingContainerId)) {
        var namingContainer = AdfPage.PAGE.findComponent(namingContainerId);
        if(namingContainer) {
          var ncParent = namingContainer.getParent();
          while(ncParent) {
            if(ncParent === parent) {
              parent = namingContainer;
              break
            }
            ncParent = ncParent.getParent()
          }
        }
      }
    }
  }
  return parent
};
AdfRichUIPeer.prototype._truncateClientId = function(component, descendantComponent, childClientId, skipArray) {
  this.TruncateClientId(component, descendantComponent, childClientId, skipArray);
  var parentComponent = this.getComponentParent(component);
  if(parentComponent != null) {
    parentComponent.getPeer()._truncateClientId(parentComponent, descendantComponent, childClientId, skipArray)
  }
};
AdfRichUIPeer.prototype.TruncateClientId = function(component, descendantComponent, childClientId, skipArray) {
};
AdfRichUIPeer.TruncateClientIdOnceImpl = function(component, descendantComponent, childClientId, skipArray) {
  var clientId = component.getClientId();
  var clientIdDepth = AdfStrings.count(clientId, ":");
  skipArray.push(clientIdDepth + 1)
};
AdfRichUIPeer.prototype.getAbsoluteId = function(component, clientId) {
  var skipArray = [];
  this._truncateClientId(component, component, clientId, skipArray);
  var removeCount = skipArray.length;
  if(removeCount > 0) {
    var clientIdFragments = clientId.split(":");
    var clientIdFragmentCount = clientIdFragments.length;
    if(clientIdFragmentCount == 1) {
      return clientId
    }
    var absoluteIdFragments = new Array(clientIdFragmentCount - removeCount);
    var absoluteIdIndex = 0;
    var skipArrayIndex = removeCount - 1;
    var currSkipIndex = skipArray[skipArrayIndex];
    for(var clientIdIndex = 0;clientIdIndex < clientIdFragmentCount;clientIdIndex++) {
      if(clientIdIndex != currSkipIndex) {
        absoluteIdFragments[absoluteIdIndex++] = clientIdFragments[clientIdIndex]
      }else {
        currSkipIndex = skipArrayIndex > 0 ? skipArray[--skipArrayIndex] : -1
      }
    }
    return absoluteIdFragments.join(":")
  }else {
    return clientId
  }
};
AdfRichUIPeer.prototype.getAbsoluteLocator = function(component, clientId) {
  var absoluteLocator;
  var replaceArray = [];
  this._fixClientId(component, component, clientId, replaceArray);
  var replaceCount = replaceArray.length;
  if(replaceCount > 0) {
    var clientIdFragments = clientId.split(":");
    var clientIdFragmentCount = clientIdFragments.length;
    if(replaceCount > clientIdFragmentCount) {
      return clientId
    }
    var absoluteLocatorFragments = new Array(clientIdFragmentCount - replaceCount);
    var absoluteIdIndex = 0;
    var replaceArrayIndex = replaceCount - 1;
    var currReplaceIndex = replaceArray[replaceArrayIndex][0];
    for(var clientIdIndex = 0;clientIdIndex < clientIdFragmentCount;clientIdIndex++) {
      if(clientIdIndex == currReplaceIndex) {
        var itemValue = replaceArray[replaceArrayIndex][1];
        if(itemValue != null) {
          var parentIndex = absoluteIdIndex > 0 ? absoluteIdIndex - 1 : 0;
          absoluteLocatorFragments[parentIndex] = absoluteLocatorFragments[parentIndex] + "[" + replaceArray[replaceArrayIndex][1] + "]"
        }
        currReplaceIndex = replaceArrayIndex > 0 ? replaceArray[--replaceArrayIndex][0] : -1
      }else {
        absoluteLocatorFragments[absoluteIdIndex++] = clientIdFragments[clientIdIndex]
      }
    }
    absoluteLocator = absoluteLocatorFragments.join(":")
  }else {
    absoluteLocator = clientId
  }
  if(window.AdfDhtmlIteratorPeer) {
    absoluteLocator = AdfDhtmlIteratorPeer.fixupIteratorAbsoluteLocator(absoluteLocator, component)
  }
  return absoluteLocator
};
AdfRichUIPeer.prototype.convertLocatorToClientId = function(component, stampKey) {
  AdfAssert.assert(false, "Incorrect use of [] locator notation for component :" + component)
};
AdfRichUIPeer.getLocatorByDomElement = function(domElement) {
  AdfAssert.assertDomElement(domElement);
  var component;
  var thePage = AdfPage.PAGE;
  for(var element = domElement;element && (!component || component.getProperty("nested"));element = element.parentNode) {
    var clientId = element.id;
    if(component && component.getProperty("nested")) {
      component = component.getParent()
    }else {
      if(clientId) {
        var idStartIndex = clientId.lastIndexOf(":");
        var id = clientId.substr(idStartIndex + 1);
        if(id.indexOf(AdfRichUIPeer._FILTER_PREFIX) == 0) {
          idStartIndex++;
          clientId = clientId.substr(0, idStartIndex) + clientId.substr(idStartIndex + AdfRichUIPeer._FILTER_PREFIX.length)
        }
        component = thePage.findComponent(clientId)
      }
    }
  }
  if(component) {
    var peer = component.getPeer();
    if(peer) {
      peer.bind(component);
      var bestMatchSubId = peer.GetBestMatchSubId(domElement);
      var absoluteLocator = component.getAbsoluteLocator();
      if(bestMatchSubId) {
        return absoluteLocator + "#" + bestMatchSubId
      }else {
        return absoluteLocator
      }
    }
  }
  return null
};
AdfRichUIPeer.prototype.GetBestMatchSubId = function(domElement) {
  if(this.GetSubIdDomElement == AdfRichUIPeer.prototype.GetSubIdDomElement) {
    return null
  }else {
    AdfAssert.failedInAbstractFunction()
  }
};
AdfRichUIPeer.prototype._fixClientId = function(component, childComponent, descComponentClientId, replaceArray) {
  this.ConvertClientIdToLocator(component, childComponent, descComponentClientId, replaceArray);
  var parentComponent = this.getComponentParent(component);
  if(parentComponent != null) {
    parentComponent.getPeer()._fixClientId(parentComponent, component, descComponentClientId, replaceArray)
  }
};
AdfRichUIPeer.prototype.ConvertClientIdToLocator = function(component, childComponent, descComponentClientId, replaceArray) {
};
AdfRichUIPeer.prototype.getDescendantComponents = function(component, children) {
  var node;
  if(component instanceof AdfRichPopup) {
    node = AdfDhtmlPopupPeer.getContentDom(component)
  }else {
    node = AdfRichUIPeer.getDomElementForComponent(component)
  }
  AdfAssert.assertDomElement(node);
  return AdfAgent.AGENT.getDescendantComponentsForNode(node, children)
};
AdfRichUIPeer.prototype.getComponentProperty = function(component, propertyName) {
  var getterFunc = this.constructor["_componentPropertyGetters"][propertyName];
  if(getterFunc) {
    this.bind(component);
    return getterFunc.call(this, component, this.getDomElement())
  }
};
AdfRichUIPeer.prototype.getReadyState = function(component) {
  this.bind(component);
  return this.GetReadyState()
};
AdfRichUIPeer.prototype.GetReadyState = function() {
  return AdfUIComponent.STATE_COMPLETE
};
AdfRichUIPeer.prototype.getInlineEditor = function(component, event) {
  this.bind(component);
  return this.GetInlineEditor(event)
};
AdfRichUIPeer.prototype.GetInlineEditor = function(event) {
  return null
};
AdfRichUIPeer.prototype.getDragTransferable = function(component, inputEvent) {
  this.bind(component);
  return this.GetDragTransferable(inputEvent)
};
AdfRichUIPeer.prototype.GetDragTransferable = function(inputEvent) {
  return null
};
AdfRichUIPeer.prototype.getDragOverFeedback = function(component, inputEvent) {
  this.bind(component);
  return this.GetDragOverFeedback(inputEvent)
};
AdfRichUIPeer.prototype.GetDragOverFeedback = function(inputEvent) {
  return AdfRichUIPeer.CreateDraggableNode(this.getDomElement())
};
AdfRichUIPeer.prototype.applyDragReadyState = function(component, inputEvent) {
  this.bind(component);
  return this.ApplyDragReadyState(inputEvent)
};
AdfRichUIPeer.prototype.clearDragReadyState = function(component, dragReadyObj) {
  this.bind(component);
  this.ClearDragReadyState(dragReadyObj)
};
AdfRichUIPeer.prototype.applyDragSourceState = function(component, inputEvent) {
  this.bind(component);
  return this.ApplyDragSourceState(inputEvent)
};
AdfRichUIPeer.prototype.clearDragSourceState = function(component, dragSourceObj) {
  this.bind(component);
  this.ClearDragSourceState(dragSourceObj)
};
AdfRichUIPeer.prototype.ApplyDragReadyState = function(inputEvent) {
  var elem = this.getDomContentElement();
  AdfDomUtils.addCSSClassName(elem, AdfRichUIPeer.DRAG_READY_STYLECLASS);
  return elem
};
AdfRichUIPeer.prototype.ClearDragReadyState = function(dragReadyObj) {
  AdfAssert.assertDomElement(dragReadyObj);
  AdfDomUtils.removeCSSClassName(dragReadyObj, AdfRichUIPeer.DRAG_READY_STYLECLASS)
};
AdfRichUIPeer.prototype.ApplyDragSourceState = function(inputEvent) {
  var elem = this.getDomContentElement();
  AdfDomUtils.addCSSClassName(elem, AdfRichUIPeer.DRAG_SOURCE_STYLECLASS);
  return elem
};
AdfRichUIPeer.prototype.ClearDragSourceState = function(dragSourceObj) {
  AdfAssert.assertDomElement(dragSourceObj);
  AdfDomUtils.removeCSSClassName(dragSourceObj, AdfRichUIPeer.DRAG_SOURCE_STYLECLASS)
};
AdfRichUIPeer.CreateDraggableNode = function(domNode) {
  return AdfAgent.AGENT.createDraggableNode(domNode)
};
AdfRichUIPeer.prototype.replaceDomElement = function(component, newElement, oldElement) {
  this.bind(component);
  this.ReplaceDomElement(newElement, oldElement)
};
AdfRichUIPeer.prototype.ReplaceDomElement = function(newElement, oldElement) {
  AdfPage.PAGE.__replaceDomElement(newElement, oldElement)
};
AdfRichUIPeer.prototype.domReplaceNotify = function(component, domNode) {
  this.bind(component);
  return this.DomReplaceNotify(domNode)
};
AdfRichUIPeer.prototype.DomReplaceNotify = function(domNode) {
  return domNode
};
AdfRichUIPeer.createSubId = function(clientId, name) {
  var subIdArray = AdfRichUIPeer._CREATE_SUB_ID_ARRAY;
  subIdArray[0] = clientId;
  subIdArray[2] = name;
  return subIdArray.join("")
};
AdfRichUIPeer.CreateSubId = AdfRichUIPeer.createSubId;
AdfRichUIPeer._sliceArgumentsArray = function(theArguments, startIndex) {
  var argCount = theArguments.length;
  var arrayLength = argCount - startIndex;
  if(arrayLength > 0) {
    var outArray = new Array(arrayLength);
    var inIndex = startIndex;
    for(var outIndex = 0;outIndex < arrayLength;inIndex++, outIndex++) {
      outArray[outIndex] = theArguments[inIndex]
    }
    return outArray
  }else {
    return null
  }
};
AdfRichUIPeer.addSuppressedPPRAttributes = function(theClass, propertyNames) {
  AdfRichUIPeer._addSuppressedPPRAttributes(theClass, AdfRichUIPeer._sliceArgumentsArray(arguments, 1))
};
AdfRichUIPeer._addSuppressedPPRAttributes = function(theClass, propertyNames) {
  AdfAssert.assertFunction(theClass);
  var pprSuppressedProperties = theClass._pprSuppressedProperties;
  if(pprSuppressedProperties == null) {
    pprSuppressedProperties = new Object;
    theClass._pprSuppressedProperties = pprSuppressedProperties;
    if(theClass != AdfRichUIPeer) {
      var superClassProperties = theClass.superclass.constructor._pprSuppressedProperties;
      for(var currProperty in superClassProperties) {
        pprSuppressedProperties[currProperty] = true
      }
    }
  }
  if(propertyNames) {
    var propertyCount = propertyNames.length;
    for(var i = 0;i < propertyCount;i++) {
      var currArg = propertyNames[i];
      AdfAssert.assertString(currArg);
      pprSuppressedProperties[currArg] = true
    }
  }
};
AdfRichUIPeer.addComponentPropertyGetters = function(theClass, propertyNames) {
  AdfRichUIPeer._addComponentPropertyGetters(theClass, AdfRichUIPeer._sliceArgumentsArray(arguments, 1))
};
AdfRichUIPeer._addComponentPropertyGetters = function(theClass, propertyNames) {
  AdfRichUIPeer._initializeCallbacks(theClass, "_componentPropertyGetters", AdfRichUIPeer._GET_COMPONENT_FORMAT, null, propertyNames)
};
AdfRichUIPeer.addDomEventHandlers = function(theClass, domEventTypes) {
  AdfRichUIPeer._addDomEventHandlers(theClass, AdfRichUIPeer._sliceArgumentsArray(arguments, 1))
};
AdfRichUIPeer._addDomEventHandlers = function(theClass, domEventTypes) {
  AdfRichUIPeer._initializeCallbacks(theClass, "_domEventHandlers", AdfRichUIPeer._HANDLE_DOM_EVENT_FORMAT, AdfDhtmlLookAndFeel.EVENT_TYPE_TO_CAMEL_CASE_MAP, domEventTypes)
};
AdfRichUIPeer.addComponentEventHandlers = function(theClass, componentEventTypes) {
  AdfRichUIPeer._addComponentEventHandlers(theClass, AdfRichUIPeer._sliceArgumentsArray(arguments, 1))
};
AdfRichUIPeer._addComponentEventHandlers = function(theClass, componentEventTypes) {
  AdfRichUIPeer._initializeCallbacks(theClass, "_componentEventHandlers", AdfRichUIPeer._HANDLE_COMPONENT_EVENT_FORMAT, null, componentEventTypes)
};
AdfRichUIPeer.addComponentPropertyChanges = function(theClass, propertyNames) {
  AdfRichUIPeer._addComponentPropertyChanges(theClass, AdfRichUIPeer._sliceArgumentsArray(arguments, 1))
};
AdfRichUIPeer._addComponentPropertyChanges = function(theClass, propertyNames) {
  AdfRichUIPeer._initializeCallbacks(theClass, "_componentPropertyChanges", AdfRichUIPeer._PROPERTY_CHANGED_FORMAT, null, propertyNames)
};
AdfRichUIPeer._initializeCallbacks = function(theClass, callbackMapPropertyName, callbackFormat, transformationMap, callbackBases) {
  AdfAssert.assertFunction(theClass);
  AdfAssert.assertString(callbackMapPropertyName);
  AdfAssert.assertArray(callbackFormat);
  AdfAssert.assertObjectOrNull(transformationMap);
  AdfAssert.assertArrayOrNull(callbackBases);
  var ourPrototype = theClass.prototype;
  var transformedName;
  var callbackMap = theClass[callbackMapPropertyName];
  if(callbackMap == null) {
    callbackMap = new Object;
    theClass[callbackMapPropertyName] = callbackMap;
    if(theClass != AdfRichUIPeer) {
      var superClassCallbacks = theClass.superclass.constructor[callbackMapPropertyName];
      for(var baseCallbackName in superClassCallbacks) {
        transformedName = transformationMap != null ? transformationMap[baseCallbackName] : baseCallbackName;
        callbackFormat[1] = AdfStrings.initUpperCase(transformedName);
        callbackMap[baseCallbackName] = ourPrototype[callbackFormat.join("")]
      }
    }
  }
  if(callbackBases != null) {
    var callbackCount = callbackBases.length;
    for(var callbackIndex = 0;callbackIndex < callbackCount;callbackIndex++) {
      var baseCallbackName = callbackBases[callbackIndex];
      transformedName = transformationMap != null ? transformationMap[baseCallbackName] : baseCallbackName;
      callbackFormat[1] = AdfStrings.initUpperCase(transformedName);
      var callbackName = callbackFormat.join("");
      var callback = ourPrototype[callbackName];
      if(AdfAssert.DEBUG) {
        AdfAssert.assert(callback, "No callback for:" + callbackName + " on " + AdfObject.getTypeName(theClass))
      }
      callbackMap[baseCallbackName] = callback
    }
  }
};
AdfRichUIPeer.prototype.ComponentPropertyChanged = function(propertyChangeEvent) {
  var propertyName = propertyChangeEvent.getPropertyName();
  var component = propertyChangeEvent.getSource();
  var ourClass = this.constructor;
  var changeFunc = ourClass["_componentPropertyChanges"][propertyName];
  var handledChange = false;
  if(changeFunc) {
    this.bind(component);
    handledChange = changeFunc.call(this, component, this.getDomElement(), propertyChangeEvent.getNewValue(), propertyChangeEvent.getOldValue());
    if(handledChange === undefined) {
      handledChange = true
    }
  }
  if(handledChange) {
    AdfPage.PAGE.__queueDescendantResizeNotifySource(component)
  }else {
    if(!(propertyName in ourClass._pprSuppressedProperties)) {
      var propertyKey = component.getPropertyKeys()[propertyName];
      if(propertyKey != null && !propertyKey[AdfUIComponent.PROPERTY_DISCONNECTED]) {
        AdfPage.PAGE.addPartialTargets(component)
      }
    }
  }
};
AdfRichUIPeer.prototype.ComponentVisibleChanged = function(component, domElement, newValue, oldValue) {
  AdfAssert.assertBoolean(newValue);
  var parentHandledChange = false;
  var parentComponent = component.getParent();
  if(parentComponent) {
    var parentPeer = parentComponent.getPeer();
    if(parentPeer && parentPeer.needsChildVisibilityChanges()) {
      parentPeer.bind(parentComponent);
      parentHandledChange = parentPeer.ChildVisibilityChanged(component, domElement, newValue)
    }
  }
  if(!parentHandledChange) {
    AdfDomUtils.setVisible(domElement, newValue);
    if(newValue) {
      AdfPage.PAGE.doResizeNotifyDom(domElement, false)
    }
  }
};
AdfRichUIPeer.prototype.GetComponentVisible = function(component, domElement) {
  return AdfDomUtils.isVisible(domElement)
};
AdfRichUIPeer.prototype.GetComponentId = function(component, domElement) {
  var clientId = component.getClientId();
  var idStartIndex = clientId.lastIndexOf(":");
  return clientId.substr(idStartIndex + 1)
};
AdfRichUIPeer.prototype.ComponentInlineStyleChanged = function(component, domElement, newValue, oldValue) {
  AdfAssert.assertStringOrNull(newValue);
  if(newValue == null) {
    newValue = ""
  }
  var currStyle = domElement.style.cssText;
  if(currStyle != null) {
    if(oldValue == null) {
      if(currStyle[currStyle.length - 1] != ";") {
        currStyle = currStyle + ";"
      }
      newValue = currStyle + newValue
    }else {
      oldValue = oldValue.replace(/\s*:\s*/g, ":");
      currStyle = currStyle.replace(/\s*:\s*/g, ":");
      if(oldValue.length < currStyle.length) {
        var index = currStyle.indexOf(oldValue);
        if(index == 0) {
          oldValue = currStyle.substring(oldValue.length);
          if(oldValue[oldValue.length - 1] != ";") {
            oldValue = oldValue + ";"
          }
          newValue = oldValue + newValue
        }else {
          if(index > 0) {
            newValue = currStyle.substring(0, index) + newValue
          }
        }
      }
    }
  }
  domElement.style.cssText = newValue
};
AdfRichUIPeer.prototype.ComponentStyleClassChanged = function(component, domElement, newValue, oldValue) {
  AdfAssert.assertStringOrNull(newValue);
  if(oldValue != null) {
    AdfDomUtils.removeCSSClassName(domElement, oldValue)
  }
  AdfDomUtils.addCSSClassName(domElement, newValue)
};
AdfRichUIPeer.prototype.getInlineStyleProperty = function(component, propName) {
  AdfAssert.assertPrototype(component, AdfUIComponent);
  var domElement = AdfRichUIPeer.getDomElementForComponent(component);
  var style = domElement.style;
  var domPropertyName = AdfAgent.AGENT.getDomForCSSPropertyName(propName);
  return style[domPropertyName]
};
AdfRichUIPeer.prototype.setInlineStyleProperty = function(component, propName, propValue) {
  AdfAssert.assertPrototype(component, AdfUIComponent);
  var domElement = AdfRichUIPeer.getDomElementForComponent(component);
  var style = domElement.style;
  var domPropertyName = AdfAgent.AGENT.getDomForCSSPropertyName(propName);
  style[domPropertyName] = propValue
};
AdfRichUIPeer.prototype.setBusy = function(component, isBusy) {
  AdfAssert.assertPrototype(component, AdfUIComponent);
  AdfAssert.assertBoolean(isBusy);
  var domElement = AdfRichUIPeer.getDomContentElementForComponent(component);
  if(domElement == null) {
    return
  }
  if(AdfDomUtils.addOrRemoveCSSClassName(isBusy, domElement, AdfRichUIPeer.BUSY_STYLECLASS)) {
    this.bind(component);
    this.SetBusy(isBusy)
  }
};
AdfRichUIPeer.prototype.SetBusy = function(isBusy) {
  AdfAssert.assertBoolean(isBusy)
};
AdfRichUIPeer.prototype.isBusy = function() {
  return false
};
AdfRichUIPeer.registerKeyStroke = function(component, keystroke, keyPressedCallback) {
  AdfAssert.assertPrototype(component, AdfUIComponent);
  AdfAssert.assertPrototype(keystroke, AdfKeyStroke);
  AdfAssert.assertFunction(keyPressedCallback);
  AdfPage.PAGE.registerKeyStroke(keystroke, AdfRichUIPeer._keystrokeCallback, {clientId:component.getClientId(), callback:keyPressedCallback})
};
AdfRichUIPeer.unregisterKeyStroke = function(component, keystroke) {
  AdfAssert.assertPrototype(component, AdfUIComponent);
  AdfAssert.assertPrototype(keystroke, AdfKeyStroke);
  AdfPage.PAGE.unregisterKeyStroke(keystroke, component.getClientId())
};
AdfRichUIPeer._keystrokeCallback = function(keystroke) {
  AdfAssert.assertPrototype(keystroke, AdfKeyStroke);
  var peerComponent = AdfPage.PAGE.findComponent(this.clientId);
  if(peerComponent == null) {
    return false
  }
  var peer = peerComponent.getPeer();
  peer.bind(peerComponent);
  return this.callback.call(peer, keystroke)
};
AdfRichUIPeer.getDomElementForComponent = function(component) {
  AdfAssert.assertObject(component);
  return AdfAgent.AGENT.getElementById(component.getClientId())
};
AdfRichUIPeer.getDomNodeForComponent = function(component) {
  AdfAssert.assertPrototype(component, AdfUIComponent);
  var domNode = AdfAgent.AGENT.getElementById(component.getClientId());
  if(!domNode) {
    var peer = component.getPeer();
    if(peer) {
      domNode = peer.getDomNode()
    }
    if(!domNode) {
      domNode = AdfRichUIPeer.GetDomNodeForCommentComponent(component)
    }
  }
  AdfAssert.assert(domNode != null, "DOM node for the Id " + component.getClientId() + " is not found. This indicates a serious problem during rendering. " + "Inspect your DOM tree and try to determine why the client component is present, while its DOM node is not");
  return domNode
};
AdfRichUIPeer.GetDomNodeForCommentComponent = function(component) {
  var parentId = component.getProperty("_parentId");
  var commentString = "compS|" + component.getClientId();
  var startElement = AdfAgent.AGENT.getElementById(parentId);
  if(startElement) {
    var firstChild = startElement.firstChild;
    if(firstChild) {
      return AdfRichUIPeer._getCommentNodeForComponent(firstChild, commentString)
    }
  }
  var theBody = AdfPage.PAGE.getDomDocument().body;
  var commentNode = AdfRichUIPeer._findCommentNodeWithContent(theBody, commentString);
  if(commentNode != null) {
    return commentNode
  }
  return null
};
AdfRichUIPeer._findCommentNodeWithContent = function(ancestorNode, commentString) {
  AdfAssert.assertDomNode(ancestorNode);
  var nodeType = ancestorNode.nodeType;
  if(nodeType == 8) {
    if(commentString == ancestorNode.nodeValue) {
      return ancestorNode
    }
  }else {
    if(nodeType == 1) {
      var children = ancestorNode.childNodes;
      var childCount = children.length;
      var i = 0;
      for(i = 0;i < childCount;i++) {
        var child = children[i];
        var foundCommentNode = AdfRichUIPeer._findCommentNodeWithContent(child, commentString);
        if(foundCommentNode != null) {
          return foundCommentNode
        }
      }
    }
  }
  return null
};
AdfRichUIPeer.getDomContentElementForComponent = function(component) {
  var domNode = AdfRichUIPeer.getDomNodeForComponent(component);
  if(domNode == null) {
    return null
  }
  return this.GetDomContentElementForNode(domNode)
};
AdfRichUIPeer.GetDomContentElementForNode = function(domNode) {
  AdfAssert.assertDomNode(domNode);
  if(domNode.nodeType == 8) {
    domNode = domNode.nextSibling;
    while(domNode && domNode.nodeType != 1) {
      domNode = domNode.nextSibling
    }
  }
  AdfAssert.assertDomElement(domNode);
  return domNode
};
AdfRichUIPeer._getCommentNodeForComponent = function(firstSibling, commentString) {
  var currChild = firstSibling;
  while(currChild) {
    var nodeType = currChild.nodeType;
    if(nodeType == 8) {
      if(commentString == currChild.nodeValue) {
        return currChild
      }
    }else {
      if(nodeType == 1) {
        var id = currChild.id;
        if(!(id && AdfPage.PAGE.findComponent(id))) {
          var firstChild = currChild.firstChild;
          if(firstChild) {
            var domNode = AdfRichUIPeer._getCommentNodeForComponent(firstChild, commentString);
            if(domNode) {
              return domNode
            }
          }
        }
      }
    }
    currChild = currChild.nextSibling
  }
  return null
};
AdfRichUIPeer.prototype.getDomElement = function() {
  return this._domNode
};
AdfRichUIPeer.prototype.getDomNode = function() {
  return this._domNode
};
AdfRichUIPeer.getDomContentElement = function() {
};
AdfRichUIPeer.prototype.getDomContentElement = function() {
  return this._domNode
};
AdfRichUIPeer.prototype.initialize = function(component) {
  AdfAssert.assertPrototype(component, AdfUIComponent);
  AdfPage.PAGE.mapComponent(component.getClientId(), component);
  var domNode = AdfRichUIPeer.getDomNodeForComponent(component);
  if(domNode) {
    AdfAssert.assertDomNode(domNode);
    this.InitDomElement(component, domNode);
    if(!this.constructor.STATELESS) {
      this.BindToComponent(component, domNode)
    }
  }
};
AdfRichUIPeer.prototype.componentRemoved = function(component) {
  AdfAssert.assertPrototype(component, AdfUIComponent);
  AdfAssert.assertDomNode(AdfRichUIPeer.getDomNodeForComponent(component));
  this.cancelAllPopups(component, true);
  this.ComponentRemoved(component);
  if(this._component === component) {
    this.UnbindFromComponent()
  }
  AdfPage.PAGE.unmapComponent(component.getClientId())
};
AdfRichUIPeer.InitClass = function(initializationState) {
  this._PROPERTY_CHANGED_FORMAT = new Array("Component", null, "Changed");
  this._GET_COMPONENT_FORMAT = new Array("GetComponent", null);
  this._HANDLE_DOM_EVENT_FORMAT = new Array("HandleDom", null);
  this._HANDLE_COMPONENT_EVENT_FORMAT = new Array("HandleComponent", null);
  this._CREATE_SUB_ID_ARRAY = new Array(null, "::", null);
  this.addComponentPropertyChanges(this, AdfUIComponent.VISIBLE, AdfUIComponent.INLINE_STYLE, AdfUIComponent.STYLE_CLASS);
  this.addComponentPropertyGetters(this, AdfUIComponent.VISIBLE, AdfUIComponent.ID)
};
AdfRichUIPeer.DefaultInitClass = function(peerInitialization) {
  var propertyChanges = null;
  var propertyGetters = null;
  var eventHandlers = null;
  var domEventHandlers = null;
  var suppressedPPRAttribtutes = null;
  if(peerInitialization) {
    propertyChanges = peerInitialization.propertyChanges;
    propertyGetters = peerInitialization.propertyGetters;
    eventHandlers = peerInitialization.eventHandlers;
    domEventHandlers = peerInitialization.domEventHandlers;
    suppressedPPRAttribtutes = peerInitialization.suppressedPPRAttribtutes
  }
  AdfRichUIPeer._addComponentPropertyChanges(this, propertyChanges);
  AdfRichUIPeer._addComponentPropertyGetters(this, propertyGetters);
  AdfRichUIPeer._addComponentEventHandlers(this, eventHandlers);
  AdfRichUIPeer._addDomEventHandlers(this, domEventHandlers);
  AdfRichUIPeer._addSuppressedPPRAttributes(this, suppressedPPRAttribtutes);
  var f = this.InitSubclass;
  if(f == null) {
    f = this["InitSubclass"]
  }
  if(f != null) {
    f.call(this, peerInitialization)
  }
};
AdfRichUIPeer.prototype.InitDomElement = function(component, domElement) {
};
AdfRichUIPeer.prototype.ComponentRemoved = function(component) {
};
AdfRichUIPeer.prototype.BindToComponent = function(component, domNode) {
  this._component = component;
  this._domNode = domNode
};
AdfRichUIPeer.prototype.UnbindFromComponent = function() {
  this._component = null;
  this._domNode = null
};
AdfRichUIPeer.prototype.bind = function(component) {
  AdfAssert.assertPrototype(component, AdfUIComponent);
  AdfAssert.assert(!component.isDead(), "Attempt to bind a dead component");
  if(component !== this._component) {
    if(this.constructor.STATELESS) {
      var domElement = AdfRichUIPeer.getDomElementForComponent(component);
      AdfAssert.assertDomElementOrNull(domElement);
      if(!domElement) {
        AdfAssert.assert(this instanceof AdfDhtmlImplicitPeer)
      }
      this.UnbindFromComponent();
      this.BindToComponent(component, domElement)
    }
  }
};
AdfRichUIPeer.prototype.focus = function(component) {
  this.bind(component);
  this.Focus()
};
AdfRichUIPeer.prototype.Focus = function() {
  var dom = this.getDomContentElement();
  AdfFocusUtils.focusFirstTabStop(dom)
};
AdfRichUIPeer.prototype.processPushData = function(component, payload, changeCount) {
  this.bind(component);
  return this.ProcessPushData(payload, changeCount)
};
AdfRichUIPeer.prototype.ProcessPushData = function(payload, changeCount) {
  var component = this.getComponent();
  var alreadyTwinkled = false;
  for(key in payload) {
    var newValue = payload[key];
    AdfLogger.LOGGER.fine("On ", component, " set ", key, " to ", newValue);
    var oldValue = component.setProperty(key, newValue, false, AdfUIComponent.PROPAGATE_LOCALLY);
    if(!alreadyTwinkled && newValue !== oldValue) {
      alreadyTwinkled = true;
      var domElement = this.getDomElement();
      var twinkleAttrName = AdfRichUIPeer._TWINKLE_TIMER_ID_ATTR;
      var timerId = domElement.getAttribute(twinkleAttrName);
      var thePage = AdfPage.PAGE;
      if(timerId) {
        thePage.rescheduleTimer(timerId, 1E3)
      }else {
        AdfDomUtils.addCSSClassName(domElement, AdfRichUIPeer._TWINKLE_ON_STYLECLASS);
        timerId = thePage.scheduleTimer(null, AdfRichUIPeer._removeTwinkleCallback, domElement.id, 1E3);
        domElement.setAttribute(twinkleAttrName, timerId)
      }
    }
  }
  return true
};
AdfRichUIPeer.prototype.registerADSAccessibility = function(component) {
  this.bind(component);
  this.RegisterADSAccessibility()
};
AdfRichUIPeer.prototype.RegisterADSAccessibility = function() {
  var component = this.getComponent();
  var element = AdfRichUIPeer.getDomElementForComponent(component);
  var agent = AdfAgent.AGENT;
  if(element && agent.getAttribute(element, "aria-live") == null) {
    agent.setAttribute(element, "aria-live", "polite")
  }
};
AdfRichUIPeer.prototype.getComponent = function() {
  return this._component
};
AdfRichUIPeer.GetComponent = function(element) {
  AdfAssert.assertDomElement(element);
  var clientId = element.id;
  return clientId ? AdfPage.PAGE.findComponent(clientId) : null
};
AdfRichUIPeer.getFirstAncestorComponent = function(node) {
  AdfAssert.assertDomNode(node);
  var thePage = AdfPage.PAGE;
  var component;
  while(node) {
    var nodeType = node.nodeType;
    if(nodeType == 1) {
      var componentId = node.id;
      if(componentId) {
        component = thePage.findComponent(componentId);
        if(component) {
          return component
        }
      }
      var previousNode = node.previousSibling;
      if(previousNode && previousNode.nodeType == 8) {
        component = thePage._getComponentFromComment(previousNode);
        if(component) {
          return component
        }
      }
    }
    node = node.parentNode
  }
  return null
};
AdfRichUIPeer.prototype.visitChildren = function(component, callback, context, ignoreHidden) {
  AdfAssert.assertPrototype(component, AdfUIComponent);
  AdfAssert.assertFunction(callback);
  AdfAssert.assertObjectOrNull(context);
  var dom = AdfRichUIPeer.getDomElementForComponent(component);
  var returnValue = this._visitChildren(component, dom, callback, context, ignoreHidden);
  if(returnValue != 2) {
    var popups = this.getAllPopups(component);
    if(popups != null) {
      for(var prop in popups) {
        if(popups[prop].getElement) {
          dom = popups[prop].getElement();
          if(dom) {
            returnValue = this._visitChildren(component, dom, callback, context, ignoreHidden);
            if(returnValue == 2) {
              break
            }
          }
        }
      }
    }
  }
  return returnValue
};
AdfRichUIPeer.prototype.getPagePosition = function(component) {
  this.bind(component);
  return AdfAgent.AGENT.getElementPosition(this._domNode)
};
AdfRichUIPeer.prototype._visitChildren = function(component, domElement, callback, context, ignoreHidden) {
  var currChild = domElement.firstChild;
  if(!currChild) {
    return 0
  }
  var isVisibleFunc = AdfDomUtils.isVisible;
  var isHtmlFunc = AdfAgent.AGENT.isElementHTML;
  var page = AdfPage.PAGE;
  while(currChild) {
    if(currChild.nodeType == 1) {
      if(isHtmlFunc(currChild) && (!ignoreHidden || isVisibleFunc(currChild))) {
        var returnValue = 0;
        var childComponent = null;
        var componentId = currChild.id;
        if(componentId) {
          childComponent = page.findComponent(componentId)
        }
        if(childComponent && childComponent != component) {
          returnValue = callback.call(context, childComponent);
          if(!returnValue) {
            returnValue = childComponent.visitChildren(callback, context, ignoreHidden)
          }
        }else {
          returnValue = this._visitChildren(component, currChild, callback, context, ignoreHidden)
        }
        if(returnValue == 2) {
          return 2
        }
      }
    }
    currChild = currChild.nextSibling
  }
  return 0
};
AdfRichUIPeer.prototype.createComponentEvent = function(component, domEvent, prevComponent) {
  this.bind(component);
  return this.CreateComponentEvent(domEvent, prevComponent)
};
AdfRichUIPeer.prototype.CreateComponentEvent = function(domEvent, prevComponent) {
  return AdfAgent.AGENT.getComponentEvent(this.getComponent(), domEvent, prevComponent)
};
AdfRichUIPeer.prototype._dispatchDomEvent = function(agent, component, domEvent) {
  AdfAssert.assertObject(domEvent);
  var eventHandlerFunc = this.constructor["_domEventHandlers"][domEvent.type];
  if(eventHandlerFunc) {
    this.bind(component);
    eventHandlerFunc.call(this, component, domEvent)
  }
};
AdfRichUIPeer.prototype.DispatchComponentEvent = function(componentEvent) {
  var componentEventHandlers = this.constructor["_componentEventHandlers"];
  if(componentEventHandlers) {
    var eventHandlerFunc = componentEventHandlers[componentEvent.getType()];
    if(eventHandlerFunc) {
      var component = componentEvent.getCurrentTarget();
      this.bind(component, AdfRichUIPeer.getDomElementForComponent(component));
      eventHandlerFunc.call(this, componentEvent)
    }
  }
};
AdfRichUIPeer.prototype.DispatchUncanceledComponentEvent = function(componentEvent) {
  return false
};
AdfRichUIPeer.addEventHandlerToDomInstance = function(theClass, domElement, domEventType) {
  AdfAssert.assertFunction(theClass);
  AdfAssert.assertDomElement(domElement);
  AdfAssert.assertString(domEventType);
  var nativeAttribute = AdfDhtmlLookAndFeel.EVENT_TYPE_TO_ATTRIBUTE_MAP[domEventType];
  AdfAssert.assertString(nativeAttribute);
  AdfRichUIPeer.addDomEventHandlers(theClass, domEventType);
  domElement[nativeAttribute] = AdfRichUIPeer._defaultInstanceEventHandler
};
AdfRichUIPeer._defaultInstanceEventHandler = function(theEvent) {
  if(theEvent == null) {
    theEvent = AdfPage.PAGE.getDomWindow().event
  }
  var component = AdfRichUIPeer.getFirstAncestorComponent(this);
  if(component) {
    component.getPeer()._dispatchDomEvent(AdfAgent.AGENT, component, theEvent)
  }
};
AdfRichUIPeer.prototype.isActive = function() {
  return this.getComponent().getClientId() == AdfPage.PAGE.getActiveComponentId()
};
AdfRichUIPeer.prototype.getAccessibleName = function(component) {
  this.bind(component);
  return this.GetAccessibleName()
};
AdfRichUIPeer.prototype.GetAccessibleName = function() {
};
AdfRichUIPeer.prototype.isInActiveHeirarchy = function() {
  var activeId = AdfPage.PAGE.getActiveComponentId();
  if(activeId != null) {
    var activeComponent = AdfPage.PAGE.findComponent(activeId);
    var component = this.getComponent();
    do {
      if(component == activeComponent) {
        return true
      }
      activeComponent = activeComponent.getParent()
    }while(activeComponent != null)
  }
  return false
};
AdfRichUIPeer.prototype.needsFocusTargetStyleClass = function() {
  return false
};
AdfRichUIPeer.prototype.needsChildVisibilityChanges = function(component) {
  return false
};
AdfRichUIPeer.prototype.ChildVisibilityChanged = function(childComponent, childDomElement, childVisible) {
  return false
};
AdfRichUIPeer.prototype.resizeNotify = function(component, oldWidth, oldHeight, newWidth, newHeight) {
  this.bind(component);
  this.ResizeNotify(oldWidth, oldHeight, newWidth, newHeight)
};
AdfRichUIPeer.prototype.ResizeNotify = function(oldWidth, oldHeight, newWidth, newHeight) {
};
AdfRichUIPeer.prototype.descendantMessageChanged = function(component) {
  this.bind(component);
  this.DescendantMessageChanged()
};
AdfRichUIPeer.prototype.messageNotify = function(component, maxType, messages) {
  AdfAssert.assertNumberOrNull(maxType);
  AdfAssert.assertArrayOrNull(messages);
  this.bind(component);
  this.MessageNotify(maxType, messages)
};
AdfRichUIPeer.prototype.messageShow = function(component, maxType, messages) {
  AdfAssert.assertNumberOrNull(maxType);
  AdfAssert.assertArrayOrNull(messages);
  this.bind(component);
  this.MessageShow(maxType, messages)
};
AdfRichUIPeer.prototype.DescendantMessageChanged = function() {
};
AdfRichUIPeer.prototype.MessageNotify = function(maxType, messages) {
  var root = this.getDomElement();
  var oldType = AdfAgent.AGENT.getExpandoProperty(root, AdfRichUIPeer.__TYPE_ATTR);
  if(oldType != maxType) {
    AdfMessageUtils.switchCSSClassName(root, oldType, maxType);
    AdfAgent.AGENT.setExpandoProperty(root, AdfRichUIPeer.__TYPE_ATTR, maxType)
  }
};
AdfRichUIPeer.prototype.MessageShow = function(maxType, messages) {
};
AdfRichUIPeer.prototype.showContextMenu = function(domEvent, menuId, parentComponent, alignElement, alignHint, launchSourceId) {
  if(menuId) {
    var popup;
    if(parentComponent) {
      popup = parentComponent.findComponent(menuId)
    }else {
      popup = AdfPage.PAGE.findComponent(menuId)
    }
    if(popup) {
      AdfAssert.assert(popup instanceof AdfRichPopup, "Invalid popup component for context menu.");
      AdfAgent.AGENT.preventDefault(domEvent);
      var hints = {};
      hints[AdfDhtmlPopupHints.TYPE] = AdfDhtmlPopupHints.TYPE_MENU;
      hints[AdfDhtmlPopupHints.AUTODISMISS] = AdfDhtmlPopupHints.AUTODISMISS_MENU;
      hints[AdfDhtmlPopupHints.FOCUS] = true;
      if(launchSourceId) {
        hints[AdfRichPopup.HINT_LAUNCH_ID] = launchSourceId
      }
      if(alignElement != null) {
        hints[AdfDhtmlPopupHints.ALIGN_ELEMENT] = alignElement;
        hints[AdfRichPopup.HINT_ALIGN] = alignHint ? alignHint : AdfRichPopup.ALIGN_AFTER_START
      }else {
        var pos = AdfAgent.AGENT.getMousePosition(domEvent);
        hints[AdfDhtmlPopupHints.MOUSEPOSITION] = pos
      }
      popup.show(hints)
    }else {
      if(parentComponent) {
        AdfLogger.LOGGER.severe("Could not find popup for context menu ", menuId, " from component ", parentComponent)
      }else {
        AdfLogger.LOGGER.severe("Could not find popup for context menu ", menuId)
      }
    }
  }
};
AdfRichUIPeer.prototype.showPopup = function(component, contentDom, hints, popupId) {
  var popupList = component[AdfRichUIPeer._POPUP_LIST];
  if(popupList == null) {
    component[AdfRichUIPeer._POPUP_LIST] = popupList = {}
  }
  var peerHints = {};
  peerHints[AdfDhtmlPopupHints.AUTODISMISS] = AdfDhtmlPopupHints.AUTODISMISS_ALWAYS;
  peerHints[AdfDhtmlPopupHints.TYPE] = AdfDhtmlPopupHints.TYPE_INLINESELECTOR;
  peerHints[AdfDhtmlPopupHints.FOCUS] = true;
  peerHints[AdfDhtmlPopupHints.CLOSE_ON_ESCAPE] = true;
  if(component._childHints) {
    AdfCollections.copyInto(peerHints, component._childHints)
  }
  if(popupId == null) {
    popupId = AdfRichUIPeer._POPUP_ID_DEFAULT
  }
  AdfCollections.copyInto(peerHints, hints);
  if(hints) {
    hints["popupId"] = popupId
  }
  peerHints["popupId"] = popupId;
  var popupWindow = popupList[popupId];
  var page = AdfPage.PAGE;
  if(!popupWindow) {
    popupWindow = AdfDhtmlPopupWindowFactory.createPopup(peerHints);
    popupList[popupId] = popupWindow;
    var contentId = contentDom.id;
    var needsUnmapping = false;
    if(contentId && !page.findComponent(contentId)) {
      AdfPage.PAGE.mapComponent(contentId, component);
      needsUnmapping = true
    }
  }
  var anchorNode = contentDom.parentNode;
  var anchorId;
  if(anchorNode) {
    anchorId = anchorNode.id
  }
  peerHints[AdfDhtmlPopupHints.CONTENT] = contentDom;
  peerHints[AdfDhtmlPopupHints.CLOSE_HANDLER] = this.createCallback(this._popupClosedHandler);
  peerHints[AdfDhtmlPopupHints.COMPONENT_CLIENT_ID] = component.getClientId();
  var popupClosedHandlerParams = {"component":component, "contentDom":contentDom, "unmap":needsUnmapping, "popupId":popupId, "anchorId":anchorId};
  page.__addPopupInfo(component, popupClosedHandlerParams);
  var otherClosedHandler = hints ? hints[AdfDhtmlPopupHints.CLOSE_HANDLER] : null;
  if(otherClosedHandler) {
    popupClosedHandlerParams["otherClosedHandler"] = otherClosedHandler;
    popupClosedHandlerParams["otherClosedHandlerParams"] = hints[AdfDhtmlPopupHints.CLOSE_HANDLER_PARAM]
  }
  peerHints[AdfDhtmlPopupHints.CLOSE_HANDLER_PARAM] = popupClosedHandlerParams;
  var alignId = hints ? hints[AdfRichPopup.HINT_ALIGN_ID] : null;
  if(alignId) {
    var alignElement = AdfAgent.AGENT.getElementById(alignId);
    if(alignElement) {
      peerHints[AdfDhtmlPopupHints.ALIGN_ELEMENT] = alignElement
    }
    peerHints[AdfRichPopup.HINT_ALIGN_ID] = null
  }
  var ariaLabel = hints ? hints[AdfDhtmlPopupHints.ARIA_LABEL] : null;
  if(ariaLabel) {
    peerHints[AdfDhtmlPopupHints.ARIA_LABEL] = ariaLabel
  }
  popupWindow.show(peerHints)
};
AdfRichUIPeer.prototype.isPopupVisible = function(component, popupId) {
  var popupWindow = this.getPopupWindow(component, popupId);
  if(popupWindow) {
    return true
  }
  return false
};
AdfRichUIPeer.prototype.hidePopup = function(component, popupId) {
  var popupWindow = this.getPopupWindow(component, popupId);
  if(popupWindow) {
    popupWindow.hide()
  }
};
AdfRichUIPeer.prototype.hideAllPopups = function(component) {
  var popupList = component[AdfRichUIPeer._POPUP_LIST];
  if(popupList != null) {
    for(var popupId in popupList) {
      var popupWindow = popupList[popupId];
      if(popupWindow && popupWindow.hide) {
        popupWindow.hide()
      }
    }
  }
};
AdfRichUIPeer.prototype.cancelPopup = function(component, popupId) {
  var popupWindow = this.getPopupWindow(component, popupId);
  if(popupWindow) {
    popupWindow.cancel()
  }
};
AdfRichUIPeer.prototype.cancelAllPopups = function(component, replaceDom) {
  var popupList = component[AdfRichUIPeer._POPUP_LIST];
  if(popupList != null) {
    for(var popupId in popupList) {
      var popupWindow = popupList[popupId];
      if(popupWindow && popupWindow.cancel) {
        popupWindow.cancel(replaceDom)
      }
    }
  }
};
AdfRichUIPeer.prototype.getPopupWindow = function(component, popupId) {
  var popupWindow = null;
  var popupList = component[AdfRichUIPeer._POPUP_LIST];
  if(popupList != null) {
    if(popupId == null) {
      popupId = AdfRichUIPeer._POPUP_ID_DEFAULT
    }
    popupWindow = popupList[popupId]
  }
  return popupWindow
};
AdfRichUIPeer.prototype.getAllPopups = function(component) {
  return component[AdfRichUIPeer._POPUP_LIST]
};
AdfRichUIPeer._removeTwinkleCallback = function(domId) {
  var activeDomElement = AdfAgent.AGENT.getElementById(domId);
  if(activeDomElement != null) {
    activeDomElement.removeAttribute(AdfRichUIPeer._TWINKLE_TIMER_ID_ATTR);
    AdfDomUtils.removeCSSClassName(activeDomElement, AdfRichUIPeer._TWINKLE_ON_STYLECLASS)
  }
};
AdfRichUIPeer.prototype._popupClosedHandler = function(param) {
  var component = param["component"];
  var popupList = component[AdfRichUIPeer._POPUP_LIST];
  if(popupList == null) {
    return
  }
  var popupWindow = popupList[param["popupId"]];
  if(!popupWindow) {
    return
  }
  var contentDom = param["contentDom"];
  var popupId = param["popupId"];
  delete popupList[popupId];
  page.__removePopupInfo(component, popupId);
  if(param["unmap"]) {
    AdfPage.PAGE.unmapComponent(contentDom["id"])
  }
  this.bind(component);
  this.PopupClosed(component, contentDom, popupId);
  var otherClosedHandler = param["otherClosedHandler"];
  if(otherClosedHandler) {
    var otherClosedHandlerParams = param["otherClosedHandlerParams"];
    otherClosedHandler(otherClosedHandlerParams)
  }
};
AdfRichUIPeer.prototype.PopupClosed = function(component, contentDom, popupId) {
};
AdfRichUIPeer.prototype.GetRichResourceURL = function(path) {
  return AdfPage.PAGE.getResourceURL("/afr" + path)
};
AdfRichUIPeer.prototype.scrollIntoView = function(component, focus, subTargetId) {
  this.bind(component);
  this.ScrollIntoView(component, focus, subTargetId)
};
AdfRichUIPeer.prototype.ScrollIntoView = function(component, focus, subTargetId) {
  var rootElement = this.getDomElement();
  rootElement.scrollIntoView();
  var subTargetElement = null;
  if(subTargetId != null) {
    subTargetElement = AdfAgent.AGENT.getElementById(AdfRichUIPeer.CreateSubId(component.getClientId(), subTargetId));
    if(subTargetElement) {
      subTargetElement.scrollIntoView()
    }else {
      AdfLogger.LOGGER.warning("Invalid subTargetId specified:" + subTargetId)
    }
  }
  if(focus) {
    if(subTargetElement) {
      AdfFocusUtils.focusElement(subTargetElement)
    }else {
      var firstTabStop = AdfFocusUtils.getFirstTabStop(rootElement);
      if(firstTabStop) {
        AdfFocusUtils.focusElement(firstTabStop)
      }
    }
  }
};
AdfRichUIPeer.prototype.getSubIdDomElement = function(component, subId) {
  this.bind(component);
  return this.GetSubIdDomElement(subId)
};
AdfRichUIPeer.prototype.GetSubIdDomElement = function(subId) {
  AdfLogger.LOGGER.warning("Unknown subId:", subId, " for component ", this.getComponent());
  return null
};
AdfRichUIPeer.prototype.getFallbackDomElement = function(component, descendantLocator, subId) {
  this.bind(component);
  return this.GetFallbackDomElement(descendantLocator, subId)
};
AdfRichUIPeer.prototype.GetFallbackDomElement = function(descendantLocator, subId) {
  return null
};
AdfRichUIPeer.prototype.simulateMouse = function(component, subId, mouseEvent) {
  this.bind(component);
  var domElement;
  if(subId) {
    domElement = this.GetSubIdDomElement(subId);
    if(!domElement) {
      AdfLogger.LOGGER.warning("No DOM element found for provided subId: " + subId + ". Mouse event will not be processed.");
      return
    }
  }else {
    domElement = this.getDomElement()
  }
  this.SimulateMouseOnDescendant(component, domElement, mouseEvent)
};
AdfRichUIPeer.prototype.SimulateMouseOnDescendant = function(targetComponent, domElement, mouseEvent) {
  var parentComponent = this.getComponent().getParent();
  if(parentComponent) {
    var parentPeer = parentComponent.getPeer();
    parentPeer.bind(parentComponent);
    parentPeer.SimulateMouseOnDescendant(targetComponent, domElement, mouseEvent)
  }else {
    domElement.scrollIntoView();
    AdfPage.PAGE.simulateDomMouse(domElement, mouseEvent)
  }
};
AdfRichUIPeer.prototype.isAbsoluteLocatorCacheable = function() {
  return true
};
AdfRichUIPeer.DISABLED_STYLECLASS = "p_AFDisabled";
AdfRichUIPeer.SELECTED_STYLECLASS = "p_AFSelected";
AdfRichUIPeer.READONLY_STYLECLASS = "p_AFReadOnly";
AdfRichUIPeer.DROP_TARGET_STYLECLASS = "p_AFDropTarget";
AdfRichUIPeer.DRAG_SOURCE_STYLECLASS = "p_AFDragSource";
AdfRichUIPeer.BUSY_STYLECLASS = "p_AFBusy";
AdfRichUIPeer.HOVER_TARGET_STYLECLASS = "p_AFHoverTarget";
AdfRichUIPeer.FOCUS_TARGET_STYLECLASS = "p_AFFocusTarget";
AdfRichUIPeer.DRAG_READY_STYLECLASS = "p_AFDragReady";
AdfRichUIPeer.__TYPE_ATTR = "__adfPeerMsgType";
AdfRichUIPeer._POPUP_ID_DEFAULT = "__afrPeerPPDefault";
AdfRichUIPeer._POPUP_LIST = "__afrPeerPPList";
AdfRichUIPeer._TWINKLE_TIMER_ID_ATTR = "__afrTwinkleTimer";
AdfRichUIPeer._TWINKLE_ON_STYLECLASS = "p_AFTwinkleOn";
AdfRichUIPeer._FILTER_PREFIX = "_afrFltr";
