OverlayElement* OverlayContainer::findElementAt(Real x, Real y) // relative to parent
{
OverlayElement* ret = NULL;
int currZ = -1;
if (mVisible)
{
ret = OverlayElement::findElementAt(x,y); //default to the current container if no others are found
if (ret && mChildrenProcessEvents)
{
ChildIterator it = getChildIterator();
while (it.hasMoreElements())
{
OverlayElement* currentOverlayElement = it.getNext();
if (currentOverlayElement->isVisible() && currentOverlayElement->isEnabled())
{
int z = currentOverlayElement->getZOrder();
if (z > currZ)
{
OverlayElement* elementFound = currentOverlayElement->findElementAt(x ,y );
if (elementFound)
{
currZ = z;
ret = elementFound;
}
}
}
}
}
}
return ret;
}
void IOPMPagingPlexus::processChildren ( void )
{
OSIterator * childIterator;
IOPowerConnection * nextChildNub;
IORegistryEntry * nextChild;
IOService * child;
unsigned int i;
childIterator = getChildIterator(gIOPowerPlane);
if ( childIterator ) {
while ( (nextChild = (IORegistryEntry *)(childIterator->getNextObject())) ) {
if ( (nextChildNub = OSDynamicCast(IOPowerConnection,nextChild)) ) {
child = (IOService *)nextChild->getChildEntry(gIOPowerPlane);
if ( child->pm_vars->theControllingDriver ) {
for ( i = 1; i < child->pm_vars->theNumberOfPowerStates; i++ ) {
child->pm_vars->thePowerStates[i].inputPowerRequirement |= IOPMPagingAvailable;
}
}
if ( child->pm_vars->myCurrentState ) {
nextChildNub->setDesiredDomainState(kIOPlexusPowerStateCount-1);
}
}
}
childIterator->release();
}
}
//---------------------------------------------------------------------
void OverlayContainer::_positionsOutOfDate(void)
{
OverlayElement::_positionsOutOfDate();
ChildIterator it = getChildIterator();
while (it.hasMoreElements())
{
it.getNext()->_positionsOutOfDate();
}
}
//========================================================
// Name : DetachChild
// Desc : no delete object, just detach in list
//========================================================
LPXNode _tagXMLNode::detachChild( LPXNode node )
{
XNodes::iterator it = getChildIterator( node );
if( (LPXNode)(*it) )
{
childs.erase( it );
return node;
}
return NULL;
}
//---------------------------------------------------------------------
void OverlayContainer::_notifyViewport()
{
OverlayElement::_notifyViewport();
// Update children
ChildIterator it = getChildIterator();
while (it.hasMoreElements())
{
it.getNext()->_notifyViewport();
}
}
//---------------------------------------------------------------------
void OverlayContainer::_notifyWorldTransforms(const Matrix4& xform)
{
OverlayElement::_notifyWorldTransforms(xform);
// Update children
ChildIterator it = getChildIterator();
while (it.hasMoreElements())
{
it.getNext()->_notifyWorldTransforms(xform);
}
}
//========================================================
// Name : RemoveChild
// Desc : detach node and delete object
//========================================================
bool _tagXMLNode::removeChild( LPXNode node )
{
XNodes::iterator it = getChildIterator( node );
if( (LPXNode)(*it) )
{
delete *it;
childs.erase( it );
return true;
}
return false;
}
//---------------------------------------------------------------------
void OverlayContainer::_notifyParent(OverlayContainer* parent, Overlay* overlay)
{
OverlayElement::_notifyParent(parent, overlay);
// Update children
ChildIterator it = getChildIterator();
while (it.hasMoreElements())
{
// Notify the children of the overlay
it.getNext()->_notifyParent(this, overlay);
}
}
//---------------------------------------------------------------------
void OverlayContainer::_update(void)
{
// call superclass
OverlayElement::_update();
// Update children
ChildIterator it = getChildIterator();
while (it.hasMoreElements())
{
it.getNext()->_update();
}
}
//---------------------------------------------------------------------
void OverlayContainer::_notifyZOrder(ushort newZOrder)
{
OverlayElement::_notifyZOrder(newZOrder);
// Update children
ChildIterator it = getChildIterator();
while (it.hasMoreElements())
{
// Give children ZOrder 1 higher than this
it.getNext()->_notifyZOrder(newZOrder + 1);
}
}
//---------------------------------------------------------------------
OverlayContainer::~OverlayContainer()
{
// remove from parent overlay if root
if (mOverlay && !mParent)
{
mOverlay->remove2D(this);
}
OverlayContainer::ChildIterator ci = getChildIterator();
while (ci.hasMoreElements())
{
OverlayElement* child = ci.getNext();
child->_notifyParent(0, 0);
}
}
//---------------------------------------------------------------------
ushort OverlayContainer::_notifyZOrder(ushort newZOrder)
{
OverlayElement::_notifyZOrder(newZOrder);
// One for us
newZOrder++;
// Update children
ChildIterator it = getChildIterator();
while (it.hasMoreElements())
{
// Children "consume" Z-order values, so keep track of them
newZOrder = it.getNext()->_notifyZOrder(newZOrder);
}
return newZOrder;
}
//---------------------------------------------------------------------
void OverlayContainer::_updateRenderQueue(RenderQueue* queue)
{
if (mVisible)
{
OverlayElement::_updateRenderQueue(queue);
// Also add children
ChildIterator it = getChildIterator();
while (it.hasMoreElements())
{
// Give children Z-order 1 higher than this
it.getNext()->_updateRenderQueue(queue);
}
}
}
/** Overridden from OverlayContainer */
void cCompassOverlay::_updateRenderQueue(RenderQueue* queue) {
if (mVisible)
{
if (!mTransparent && !mpMaterial.isNull())
{
OverlayElement::_updateRenderQueue(queue);
}
// Also add children
ChildIterator it = getChildIterator();
while (it.hasMoreElements())
{
// Give children ZOrder 1 higher than this
it.getNext()->_updateRenderQueue(queue);
}
}
}
OverlayElement* OverlayContainer::clone(const String& instanceName)
{
OverlayContainer *newContainer;
newContainer = static_cast<OverlayContainer*>(OverlayElement::clone(instanceName));
ChildIterator it = getChildIterator();
while (it.hasMoreElements())
{
OverlayElement* oldChildElement = it.getNext();
if (oldChildElement->isCloneable())
{
OverlayElement* newChildElement = oldChildElement->clone(instanceName);
newContainer->_addChild(newChildElement);
}
}
return newContainer;
}
